void Clock::tick()
{
ticks++;
if ((getId() == 1) || (getId() == 2)) {
Log_info4("id %d : %d:%d:%d", getId(), hour, minute, second);
Log_info5("id %d : %s %d, %d%d", getId(), (IArg)months[month-1], day, century, year);
}
/*
* Change selected function to alter clock rate
*/
// setMicrosecond();
// setMillisecond();
setSecond();
// setMinute();
// setDay();
return;
}
/*********************************************************************
* @fn Data_Service_WriteAttrCB
*
* @brief Validate attribute data prior to a write operation
*
* @param connHandle - connection message was received on
* @param pAttr - pointer to attribute
* @param pValue - pointer to data to be written
* @param len - length of data
* @param offset - offset of the first octet to be written
* @param method - type of write message
*
* @return SUCCESS, blePending or Failure
*/
static bStatus_t Data_Service_WriteAttrCB( uint16_t connHandle, gattAttribute_t *pAttr,
uint8_t *pValue, uint16_t len, uint16_t offset,
uint8_t method )
{
bStatus_t status = SUCCESS;
uint8_t paramID = 0xFF;
uint8_t changeParamID = 0xFF;
uint16_t writeLenMin;
uint16_t writeLenMax;
uint16_t *pValueLenVar;
// See if request is regarding a Client Characterisic Configuration
if (ATT_BT_UUID_SIZE == pAttr->type.len && GATT_CLIENT_CHAR_CFG_UUID == *(uint16_t *)pAttr->type.uuid)
{
Log_info3("WriteAttrCB (CCCD): param: %d connHandle: %d %s",
(IArg)Data_Service_findCharParamId(pAttr),
(IArg)connHandle,
(IArg)(method == GATT_LOCAL_WRITE?"- restoring bonded state":"- OTA write"));
// Allow notification and indication, but do not check if really allowed per CCCD.
status = GATTServApp_ProcessCCCWriteReq( connHandle, pAttr, pValue, len,
offset, GATT_CLIENT_CFG_NOTIFY |
GATT_CLIENT_CFG_INDICATE );
if (SUCCESS == status && pAppCBs && pAppCBs->pfnCfgChangeCb)
pAppCBs->pfnCfgChangeCb( connHandle, DATA_SERVICE_SERV_UUID,
Data_Service_findCharParamId(pAttr), pValue, len );
return status;
}
// Find settings for the characteristic to be written.
paramID = Data_Service_findCharParamId( pAttr );
switch ( paramID )
{
case DS_STRING_ID:
writeLenMin = DS_STRING_LEN_MIN;
writeLenMax = DS_STRING_LEN;
pValueLenVar = &ds_StringValLen;
Log_info5("WriteAttrCB : %s connHandle(%d) len(%d) offset(%d) method(0x%02x)",
(IArg)"String",
(IArg)connHandle,
(IArg)len,
(IArg)offset,
(IArg)method);
/* Other considerations for String can be inserted here */
break;
case DS_STREAM_ID:
writeLenMin = DS_STREAM_LEN_MIN;
writeLenMax = DS_STREAM_LEN;
pValueLenVar = &ds_StreamValLen;
Log_info5("WriteAttrCB : %s connHandle(%d) len(%d) offset(%d) method(0x%02x)",
(IArg)"Stream",
(IArg)connHandle,
(IArg)len,
(IArg)offset,
(IArg)method);
/* Other considerations for Stream can be inserted here */
break;
default:
Log_error0("Attribute was not found.");
return ATT_ERR_ATTR_NOT_FOUND;
}
// Check whether the length is within bounds.
if ( offset >= writeLenMax )
{
Log_error0("An invalid offset was requested.");
status = ATT_ERR_INVALID_OFFSET;
}
else if ( offset + len > writeLenMax )
{
Log_error0("Invalid value length was received.");
status = ATT_ERR_INVALID_VALUE_SIZE;
}
else if ( offset + len < writeLenMin && ( method == ATT_EXECUTE_WRITE_REQ || method == ATT_WRITE_REQ ) )
{
// Refuse writes that are lower than minimum.
// Note: Cannot determine if a Reliable Write (to several chars) is finished, so those will
// only be refused if this attribute is the last in the queue (method is execute).
// Otherwise, reliable writes are accepted and parsed piecemeal.
Log_error0("Invalid value length was received.");
status = ATT_ERR_INVALID_VALUE_SIZE;
}
else
{
// Copy pValue into the variable we point to from the attribute table.
memcpy(pAttr->pValue + offset, pValue, len);
// Only notify application and update length if enough data is written.
//
// Note: If reliable writes are used (meaning several attributes are written to using ATT PrepareWrite),
// the application will get a callback for every write with an offset + len larger than _LEN_MIN.
// Note: For Long Writes (ATT Prepare + Execute towards only one attribute) only one callback will be issued,
// because the write fragments are concatenated before being sent here.
if ( offset + len >= writeLenMin )
{
changeParamID = paramID;
*pValueLenVar = offset + len; // Update data length.
}
}
// Let the application know something changed (if it did) by using the
// callback it registered earlier (if it did).
if (changeParamID != 0xFF)
if ( pAppCBs && pAppCBs->pfnChangeCb )
pAppCBs->pfnChangeCb( connHandle, DATA_SERVICE_SERV_UUID, paramID, pValue, len+offset ); // Call app function from stack task context.
return status;
}
