/*********************************************************************
* @fn oadManagerSendImgNotify
*
* @brief OAD device discovery.
*
* @return none
*/
static void oadManagerSendImgNotify(void)
{
attWriteReq_t req;
img_hdr_t ImgHdr;
HalFlashRead(OAD_IMG_B_PAGE, OAD_IMG_HDR_OSET, (uint8 *)&ImgHdr, sizeof(img_hdr_t));
req.handle = oadManagerHandles[OAD_CHAR_IMG_IDENTIFY];
req.len = OAD_IMG_HDR_SIZE;
req.value[0] = LO_UINT16(ImgHdr.ver);
req.value[1] = HI_UINT16(ImgHdr.ver);
req.value[2] = LO_UINT16(ImgHdr.len);
req.value[3] = HI_UINT16(ImgHdr.len);
(void)osal_memcpy(req.value+4, ImgHdr.uid, sizeof(ImgHdr.uid));
req.sig = FALSE;
req.cmd = TRUE;
VOID GATT_WriteNoRsp(oadManagerConnHandle, &req);
// Save the total number of blocks
oadBlkTot = ImgHdr.len / (OAD_BLOCK_SIZE / HAL_FLASH_WORD_SIZE);
}
/*********************************************************************
* @fn oadManagerHandleNoti
*
* @brief Handle Notifications and Indications.
*
* @return none
*/
static void oadManagerHandleNoti(attHandleValueNoti_t *pNoti)
{
if (pNoti->handle == oadManagerHandles[OAD_CHAR_IMG_IDENTIFY])
{
#if (defined HAL_LCD && (HAL_LCD == TRUE))
uint16 ver = BUILD_UINT16(pNoti->value[0], pNoti->value[1]);
uint8 userId[12] = "UserId ";
osal_memcpy(&(userId[7]), &(pNoti->value[4]), 4);
userId[11] = '\0';
if ( OAD_IMG_ID( ver ) == 0 )
{
HalLcdWriteStringValueValue("ImgA Id", OAD_VER_NUM( ver ), 16,
BUILD_UINT16(pNoti->value[2], pNoti->value[3]), 16,
HAL_LCD_LINE_2);
}
else
{
HalLcdWriteStringValueValue("ImgB Id", OAD_VER_NUM( ver ), 16,
BUILD_UINT16(pNoti->value[2], pNoti->value[3]), 16,
HAL_LCD_LINE_2);
}
HalLcdWriteString((char*)userId, HAL_LCD_LINE_3);
#endif
}
else if (pNoti->handle == oadManagerHandles[OAD_CHAR_IMG_BLOCK])
{
oadBlkNum = BUILD_UINT16(pNoti->value[0], pNoti->value[1]);
attWriteReq_t req;
req.handle = oadManagerHandles[OAD_CHAR_IMG_BLOCK];
req.len = 2 + OAD_BLOCK_SIZE;
req.sig = FALSE;
req.cmd = TRUE;
req.value[0] = LO_UINT16(oadBlkNum);
req.value[1] = HI_UINT16(oadBlkNum);
uint8 page = oadBlkNum / OAD_BLOCKS_PER_PAGE;
uint16 oset = (oadBlkNum - (OAD_BLOCKS_PER_PAGE * page)) * OAD_BLOCK_SIZE;
HalFlashRead(page+OAD_IMG_B_PAGE, oset, req.value+2, OAD_BLOCK_SIZE);
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
if (oadBlkNum == 0)
{
HalLcdWriteString("", HAL_LCD_LINE_3);
}
HalLcdDisplayPercentBar( "OAD Progress...", (oadBlkNum / (oadBlkTot / 100)) );
#endif
VOID GATT_WriteNoRsp(oadManagerConnHandle, &req);
VOID osal_start_timerEx( oadManagerTaskId, OAD_DOWNLOAD_EVT, OAD_DOWNLOAD_TIMEOUT );
}
}
void bleshield_central_write_bytes(uint8 *buf, uint8 len)
{
attWriteReq_t writeReq;
writeReq.handle = 0x0010;
writeReq.len = len;
memcpy(writeReq.value, buf, len);
GATT_WriteNoRsp( 0x0000, &writeReq, 0 );
}
/*********************************************************************
* @fn oadManagerEnableNoti
*
* @brief Enable notification on the OAD Target
*
* @return none
*/
static void oadManagerEnableNoti( uint16 handle )
{
attWriteReq_t req;
req.handle = handle;
req.len = 2;
req.sig = FALSE;
req.cmd = TRUE;
req.value[0] = LO_UINT16(GATT_CLIENT_CFG_NOTIFY);
req.value[1] = HI_UINT16(GATT_CLIENT_CFG_NOTIFY);
VOID GATT_WriteNoRsp(oadManagerConnHandle, &req);
}
/*********************************************************************
* @fn softCmdSend
*
* @brief Send a soft command to peer
*
* @param cmd - Command to send
*
* @return status
*/
static void softCmdSend( uint8 cmd )
{
attWriteReq_t req;
if ( softCmdHdlCache[HDL_GEN_CTRL_CMD_ENUM] != 0 )
{
// Send write command
req.len = 1;
req.value[0] = cmd;
req.sig = 0;
req.cmd = 1;
req.handle = softCmdHdlCache[HDL_GEN_CTRL_CMD_ENUM];
GATT_WriteNoRsp( softCmdConnHandle, &req );
}
}
/*********************************************************************
* @fn timeAppWriteCtrl
*
* @brief Write a control point.
*
* @param handle - attribute handle
* @param value - attribute value
*
* @return none
*/
static void timeAppWriteCtrl( uint16 handle, uint8 value )
{
attWriteReq_t req;
req.pValue = GATT_bm_alloc( timeAppConnHandle, ATT_WRITE_REQ, 1, NULL );
if (req.pValue != NULL)
{
req.len = 1;
req.pValue[0] = value;
req.sig = 0;
req.cmd = 1;
req.handle = handle;
// Send write command
if ( GATT_WriteNoRsp(timeAppConnHandle, &req) != SUCCESS )
{
GATT_bm_free( (gattMsg_t *)&req, ATT_WRITE_REQ );
}
}
}
/*********************************************************************
* @fn timeApp_HandleKeys
*
* @brief Handles all key events for this device.
*
* @param shift - true if in shift/alt.
* @param keys - bit field for key events. Valid entries:
* HAL_KEY_SW_2
* HAL_KEY_SW_1
*
* @return none
*/
static void timeApp_HandleKeys( uint8 shift, uint8 keys )
{
if ( keys & HAL_KEY_UP )
{
// Start or stop advertising
if ( timeAppGapState != GAPROLE_CONNECTED )
{
uint8 advState;
// Set fast advertising interval for user-initiated connections
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_FAST_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_FAST_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_MIN, DEFAULT_FAST_ADV_DURATION );
// Toggle advertising state
GAPRole_GetParameter( GAPROLE_ADVERT_ENABLED, &advState );
advState = !advState;
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advState );
// Set state variable
if (advState == FALSE)
{
timeAppAdvCancelled = TRUE;
}
}
}
if ( keys & HAL_KEY_LEFT )
{
attWriteReq_t req;
// Send command to alert notificaton control point
if ( ( timeAppGapState == GAPROLE_CONNECTED ) &&
( timeAppHdlCache[HDL_ALERT_NTF_CTRL] != 0 ) )
{
// Send write request
req.len = 2;
req.value[0] = *pTimeAppAlertCmd;
req.value[1] = ALERT_NOTIF_CAT_ALL;
req.sig = 0;
req.cmd = 0;
req.handle = timeAppHdlCache[HDL_ALERT_NTF_CTRL];
GATT_WriteCharValue( timeAppConnHandle, &req, timeAppTaskId );
LCD_WRITE_STRING_VALUE( "Alert cmd:", *pTimeAppAlertCmd, 10, HAL_LCD_LINE_1);
}
// Cycle through command test values
if ( *pTimeAppAlertCmd == ALERT_NOTIF_DISABLE_UNREAD )
{
pTimeAppAlertCmd = timeAppAlertCmd;
}
else
{
pTimeAppAlertCmd++;
}
}
if ( keys & HAL_KEY_RIGHT )
{
attWriteReq_t req;
// Do a reference time update
if ( ( timeAppGapState == GAPROLE_CONNECTED ) &&
( timeAppHdlCache[HDL_REF_TIME_UPD_CTRL] != 0 ) )
{
// Send write command
req.len = 1;
req.value[0] = timeAppRefUpdateVal;
req.sig = 0;
req.cmd = 1;
req.handle = timeAppHdlCache[HDL_REF_TIME_UPD_CTRL];
GATT_WriteNoRsp( timeAppConnHandle, &req );
LCD_WRITE_STRING_VALUE( "Time update:", timeAppRefUpdateVal, 10, HAL_LCD_LINE_1);
// Toggle between two reference time update values
if ( timeAppRefUpdateVal == REF_TIME_UPDATE_GET )
{
timeAppRefUpdateVal = REF_TIME_UPDATE_CANCEL;
}
else
{
timeAppRefUpdateVal = REF_TIME_UPDATE_GET;
}
}
}
if ( keys & HAL_KEY_CENTER )
{
// If connected, terminate connection
if ( timeAppGapState == GAPROLE_CONNECTED )
{
GAPRole_TerminateConnection();
}
}
if ( keys & HAL_KEY_DOWN )
{
attWriteReq_t req;
// Write ringer control point
if ( ( timeAppGapState == GAPROLE_CONNECTED ) &&
( timeAppHdlCache[HDL_PAS_CTRL] != 0 ) )
{
// Send write command
req.len = 1;
req.value[0] = timeAppRingerCmd;
req.sig = 0;
req.cmd = 1;
req.handle = timeAppHdlCache[HDL_PAS_CTRL];
GATT_WriteNoRsp( timeAppConnHandle, &req );
LCD_WRITE_STRING_VALUE( "Ringer ctrl:", timeAppRingerCmd, 10, HAL_LCD_LINE_1);
// Toggle between values
if ( ++timeAppRingerCmd > RINGER_CANCEL_SILENT )
{
timeAppRingerCmd = RINGER_SILENT_MODE;
}
}
}
if ( keys & HAL_KEY_SW_6 )
{
}
}
