/*********************************************************************
* @fn gapCentralRole_ProcessGAPMsg
*
* @brief Process an incoming task message from GAP.
*
* @param pMsg - message to process
*
* @return none
*/
static void gapCentralRole_ProcessGAPMsg( gapEventHdr_t *pMsg )
{
switch ( pMsg->opcode )
{
case GAP_DEVICE_INIT_DONE_EVENT:
{
gapDeviceInitDoneEvent_t *pPkt = (gapDeviceInitDoneEvent_t *) pMsg;
if ( pPkt->hdr.status == SUCCESS )
{
// Save off the generated keys
VOID osal_snv_write( BLE_NVID_IRK, KEYLEN, gapCentralRoleIRK );
VOID osal_snv_write( BLE_NVID_CSRK, KEYLEN, gapCentralRoleSRK );
// Save off the information
VOID osal_memcpy( gapCentralRoleBdAddr, pPkt->devAddr, B_ADDR_LEN );
}
}
break;
case GAP_LINK_ESTABLISHED_EVENT:
{
gapEstLinkReqEvent_t *pPkt = (gapEstLinkReqEvent_t *) pMsg;
if (pPkt->hdr.status == SUCCESS)
{
// Notify the Bond Manager of the connection
VOID GAPBondMgr_LinkEst( pPkt->devAddrType, pPkt->devAddr,
pPkt->connectionHandle, GAP_PROFILE_CENTRAL );
}
}
break;
case GAP_LINK_TERMINATED_EVENT:
{
uint16 connHandle = ((gapTerminateLinkEvent_t *) pMsg)->connectionHandle;
GAPBondMgr_ProcessGAPMsg( (gapEventHdr_t *)pMsg );
// Cancel RSSI reads
GAPCentralRole_CancelRssi( connHandle );
}
break;
// temporary workaround
case GAP_SLAVE_REQUESTED_SECURITY_EVENT:
GAPBondMgr_ProcessGAPMsg( pMsg );
break;
default:
break;
}
// Pass event to app
if ( pGapCentralRoleCB && pGapCentralRoleCB->eventCB )
{
pGapCentralRoleCB->eventCB( (gapCentralRoleEvent_t *) pMsg );
}
}
static void controlBLECentral_HandleKeys( uint8 shift, uint8 keys )
{
(void)shift; // Intentionally unreferenced parameter
uint8 adc;
if(keys & KEY_FUN1)
{
app_write_string("\r\ngot the KEY_FUN1 V:");
adc=halGetVoltageMonitorInput();
app_write_string( uint8_to_string(adc));
HalLedSet( HAL_LED_1 , HAL_LED_MODE_FLASH );
}
if(keys & KEY_FUN2)
{
app_write_string("\r\ngot the KEY_FUN2");
HalLedSet(HAL_LED_2, HAL_LED_MODE_BLINK);
}
if ( keys & HAL_KEY_UP )
{
// Start or stop discovery
if ( simpleBLEState != BLE_STATE_CONNECTED )
{
if ( !simpleBLEScanning )
{
simpleBLEScanning = TRUE;
simpleBLEScanRes = 0;
LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( "", HAL_LCD_LINE_2 );
GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,
DEFAULT_DISCOVERY_ACTIVE_SCAN,
DEFAULT_DISCOVERY_WHITE_LIST );
}
else
{
GAPCentralRole_CancelDiscovery();
}
}
else if ( simpleBLEState == BLE_STATE_CONNECTED &&
simpleBLECharHdl != 0 &&
simpleBLEProcedureInProgress == FALSE )
{
uint8 status;
// Do a read or write as long as no other read or write is in progress
if ( simpleBLEDoWrite )
{
// Do a write
attWriteReq_t req;
req.handle = simpleBLECharHdl;
req.len = 1;
req.value[0] = simpleBLECharVal;
req.sig = 0;
req.cmd = 0;
status = GATT_WriteCharValue( simpleBLEConnHandle, &req, simpleBLETaskId );
}
else
{
// Do a read
attReadReq_t req;
req.handle = simpleBLECharHdl;
status = GATT_ReadCharValue( simpleBLEConnHandle, &req, simpleBLETaskId );
}
if ( status == SUCCESS )
{
simpleBLEProcedureInProgress = TRUE;
simpleBLEDoWrite = !simpleBLEDoWrite;
}
}
}
if ( keys & HAL_KEY_LEFT )
{
// Display discovery results
if ( !simpleBLEScanning && simpleBLEScanRes > 0 )
{
// Increment index of current result (with wraparound)
simpleBLEScanIdx++;
if ( simpleBLEScanIdx >= simpleBLEScanRes )
{
simpleBLEScanIdx = 0;
}
LCD_WRITE_STRING_VALUE( "Device", simpleBLEScanIdx + 1,
10, HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ),
HAL_LCD_LINE_2 );
}
}
if ( keys & HAL_KEY_RIGHT )
{
// Connection update
if ( simpleBLEState == BLE_STATE_CONNECTED )
{
GAPCentralRole_UpdateLink( simpleBLEConnHandle,
DEFAULT_UPDATE_MIN_CONN_INTERVAL,
DEFAULT_UPDATE_MAX_CONN_INTERVAL,
DEFAULT_UPDATE_SLAVE_LATENCY,
DEFAULT_UPDATE_CONN_TIMEOUT );
}
}
if ( keys & HAL_KEY_CENTER )
{
uint8 addrType;
uint8 *peerAddr;
// Connect or disconnect
if ( simpleBLEState == BLE_STATE_IDLE )
{
// if there is a scan result
if ( simpleBLEScanRes > 0 )
{
// connect to current device in scan result
peerAddr = simpleBLEDevList[simpleBLEScanIdx].addr;
addrType = simpleBLEDevList[simpleBLEScanIdx].addrType;
simpleBLEState = BLE_STATE_CONNECTING;
GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
addrType, peerAddr );
LCD_WRITE_STRING( "Connecting", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 );
}
}
else if ( simpleBLEState == BLE_STATE_CONNECTING ||
simpleBLEState == BLE_STATE_CONNECTED )
{
// disconnect
simpleBLEState = BLE_STATE_DISCONNECTING;
gStatus = GAPCentralRole_TerminateLink( simpleBLEConnHandle );
LCD_WRITE_STRING( "Disconnecting", HAL_LCD_LINE_1 );
}
}
if ( keys & HAL_KEY_DOWN )
{
// Start or cancel RSSI polling
if ( simpleBLEState == BLE_STATE_CONNECTED )
{
if ( !simpleBLERssi )
{
simpleBLERssi = TRUE;
GAPCentralRole_StartRssi( simpleBLEConnHandle, DEFAULT_RSSI_PERIOD );
}
else
{
simpleBLERssi = FALSE;
GAPCentralRole_CancelRssi( simpleBLEConnHandle );
LCD_WRITE_STRING( "RSSI Cancelled", HAL_LCD_LINE_1 );
}
}
}
}
static void simpleBLECentral_HandleKeys( uint8 shift, uint8 keys )
{
(void)shift; // Intentionally unreferenced parameter
if ( keys & HAL_KEY_UP )
{
// Start or stop discovery
if ( simpleBLEState != BLE_STATE_CONNECTED )
{
if ( !simpleBLEScanning )
{ uint8 adc7 = HalAdcRead (HAL_ADC_CHANNEL_7, HAL_ADC_RESOLUTION_8);
LCD_WRITE_STRING_VALUE( "Value",adc7,
16, HAL_LCD_LINE_2);
advertData[6]= var1[6];
advertData[8]= 0xA9;
if(adc7>0x7E)
advertData[9]= 0x01;
else
advertData[9]= 0x02;
advertData[10]= 0xB9;
GAP_UpdateAdvertisingData( GAPROLE_ADVERT_ENABLED,TRUE, sizeof(advertData),advertData);
simpleBLEScanning = TRUE;
simpleBLEScanRes = 0;
LCD_WRITE_STRING( "Discovering...", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( "", HAL_LCD_LINE_2 );
GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,
DEFAULT_DISCOVERY_ACTIVE_SCAN,
DEFAULT_DISCOVERY_WHITE_LIST );
}
else
{
GAPCentralRole_CancelDiscovery();
}
}
else if ( simpleBLEState == BLE_STATE_CONNECTED &&
simpleBLECharHdl != 0 &&
simpleBLEProcedureInProgress == FALSE )
{
uint8 status;
// Do a read or write as long as no other read or write is in progress
if ( simpleBLEDoWrite )
{
// Do a write
attWriteReq_t req;
req.handle = simpleBLECharHdl;
req.len = 1;
req.value[0] = simpleBLECharVal;
req.sig = 0;
req.cmd = 0;
status = GATT_WriteCharValue( simpleBLEConnHandle, &req, simpleBLETaskId );
}
else
{
// Do a read
attReadReq_t req;
req.handle = simpleBLECharHdl;
status = GATT_ReadCharValue( simpleBLEConnHandle, &req, simpleBLETaskId );
}
if ( status == SUCCESS )
{
simpleBLEProcedureInProgress = TRUE;
simpleBLEDoWrite = !simpleBLEDoWrite;
}
}
}
if ( keys & HAL_KEY_LEFT )
{
// Display discovery results
if ( !simpleBLEScanning && simpleBLEScanRes > 0 )
{
// Increment index of current result (with wraparound)
simpleBLEScanIdx++;
if ( simpleBLEScanIdx >= simpleBLEScanRes )
{
simpleBLEScanIdx = 0;
}
LCD_WRITE_STRING_VALUE( "Device", simpleBLEScanIdx + 1,
10, HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( simpleBLEDevList[simpleBLEScanIdx].addr ),
HAL_LCD_LINE_2 );
}
}
////////////////////////////////////////////////////////////////////////////////
// Advertising
if ( keys & HAL_KEY_RIGHT )
{
// ressing the right key should toggle advertising on and off
uint8 current_adv_enabled_status;
uint8 new_adv_enabled_status;
uint8 adc7 = HalAdcRead (HAL_ADC_CHANNEL_7, HAL_ADC_RESOLUTION_8);
LCD_WRITE_STRING_VALUE( "Value",adc7,
16, HAL_LCD_LINE_2);
advertData[6]= var1[6];
advertData[8]= 0xA9;
if(adc7>0x7E)
advertData[9]= 0x01;
else
advertData[9]= 0x02;
advertData[10]= 0xB9;
GAP_UpdateAdvertisingData( GAPROLE_ADVERT_ENABLED,TRUE, sizeof(advertData),advertData);
//Find the current GAP advertisement status
if( current_adv_enabled_status == FALSE )
{
new_adv_enabled_status = TRUE;
}
else
{
new_adv_enabled_status = FALSE;
}
// if(var1[2] == 0x53) {
//scanRspData[18] =0xAA;
//scanRspData[19] =(uint8) var1[2];
//bStatus_t stat;
//stat = GAP_UpdateAdvertisingData( 0, TRUE, 1, scanRspData);
//}
//change the GAP advertisement status to opposite of current status
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &new_adv_enabled_status );
}
////////////////////////////////////////////////////////////////////////////////
/*if ( keys & HAL_KEY_CENTER )
{
uint8 addrType;
uint8 *peerAddr;
// Connect or disconnect
if ( simpleBLEState == BLE_STATE_IDLE )
{
// if there is a scan result
if ( simpleBLEScanRes > 0 )
{
// connect to current device in scan result
peerAddr = simpleBLEDevList[simpleBLEScanIdx].addr;
addrType = simpleBLEDevList[simpleBLEScanIdx].addrType;
simpleBLEState = BLE_STATE_CONNECTING;
GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
addrType, peerAddr );
LCD_WRITE_STRING( "Connecting", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 );
}
}
else if ( simpleBLEState == BLE_STATE_CONNECTING ||
simpleBLEState == BLE_STATE_CONNECTED )
{
// disconnect
simpleBLEState = BLE_STATE_DISCONNECTING;
gStatus = GAPCentralRole_TerminateLink( simpleBLEConnHandle );
LCD_WRITE_STRING( "Disconnecting", HAL_LCD_LINE_1 );
}
}*/
if ( keys & HAL_KEY_DOWN )
{
// Start or cancel RSSI polling
if ( simpleBLEState == BLE_STATE_CONNECTED )
{
if ( !simpleBLERssi )
{
simpleBLERssi = TRUE;
GAPCentralRole_StartRssi( simpleBLEConnHandle, DEFAULT_RSSI_PERIOD );
}
else
{
simpleBLERssi = FALSE;
GAPCentralRole_CancelRssi( simpleBLEConnHandle );
LCD_WRITE_STRING( "RSSI Cancelled", HAL_LCD_LINE_1 );
}
}
}
}
/*********************************************************************
* @fn gapCentralRole_ProcessGAPMsg
*
* @brief Process an incoming task message from GAP.
*
* @param pMsg - message to process
*
* @return none
*/
static void gapCentralRole_ProcessGAPMsg( gapEventHdr_t *pMsg )
{
uint8 isBroadcastMsg = FALSE;
switch ( pMsg->opcode )
{
case GAP_DEVICE_INIT_DONE_EVENT:
{
gapDeviceInitDoneEvent_t *pPkt = (gapDeviceInitDoneEvent_t *) pMsg;
bStatus_t stat = pPkt->hdr.status;
if ( pPkt->hdr.status == SUCCESS )
{
// Save off the generated keys
VOID osal_snv_write( BLE_NVID_IRK, KEYLEN, gapCentralRoleIRK );
VOID osal_snv_write( BLE_NVID_CSRK, KEYLEN, gapCentralRoleSRK );
// Save off the information
VOID osal_memcpy( gapCentralRoleBdAddr, pPkt->devAddr, B_ADDR_LEN );
///////////////////////////////////////////////////////////////////////
// Broadcast
// Save off the information
VOID osal_memcpy( gapRole_bdAddr, pPkt->devAddr, B_ADDR_LEN );
gapRole_state = GAPROLE_STARTED;
// Update the advertising data
stat =GAP_UpdateAdvertisingData( gapRole_TaskID, TRUE,
gapRole_AdvertDataLen,
gapRole_AdvertData );
}
if ( stat != SUCCESS )
{
gapRole_state = GAPROLE_ERROR;
}
isBroadcastMsg = TRUE;
}
break;
case GAP_LINK_ESTABLISHED_EVENT:
{
gapEstLinkReqEvent_t *pPkt = (gapEstLinkReqEvent_t *) pMsg;
if (pPkt->hdr.status == SUCCESS)
{
// Notify the Bond Manager of the connection
VOID GAPBondMgr_LinkEst( pPkt->devAddrType, pPkt->devAddr,
pPkt->connectionHandle, GAP_PROFILE_CENTRAL );
}
}
break;
case GAP_LINK_TERMINATED_EVENT:
{
uint16 connHandle = ((gapTerminateLinkEvent_t *) pMsg)->connectionHandle;
GAPBondMgr_ProcessGAPMsg( (gapEventHdr_t *)pMsg );
// Cancel RSSI reads
GAPCentralRole_CancelRssi( connHandle );
}
break;
// temporary workaround
case GAP_SLAVE_REQUESTED_SECURITY_EVENT:
GAPBondMgr_ProcessGAPMsg( pMsg );
break;
case GAP_ADV_DATA_UPDATE_DONE_EVENT:
{
gapAdvDataUpdateEvent_t *pPkt = (gapAdvDataUpdateEvent_t *)pMsg;
if ( pPkt->hdr.status == SUCCESS )
{
if ( pPkt->adType )
{
// Setup the Response Data
pPkt->hdr.status = GAP_UpdateAdvertisingData( gapRole_TaskID,
FALSE, gapRole_ScanRspDataLen, gapRole_ScanRspData );
}
else
{
// Start advertising
VOID osal_set_event( gapRole_TaskID, START_ADVERTISING_EVT );
}
}
if ( pPkt->hdr.status != SUCCESS )
{
// Set into Error state
gapRole_state = GAPROLE_ERROR;
isBroadcastMsg = TRUE;
}
}
break;
case GAP_MAKE_DISCOVERABLE_DONE_EVENT:
case GAP_END_DISCOVERABLE_DONE_EVENT:
{
gapMakeDiscoverableRspEvent_t *pPkt = (gapMakeDiscoverableRspEvent_t *)pMsg;
if ( pPkt->hdr.status == SUCCESS )
{
if ( pMsg->opcode == GAP_MAKE_DISCOVERABLE_DONE_EVENT )
{
gapRole_state = GAPROLE_ADVERTISING;
}
else // GAP_END_DISCOVERABLE_DONE_EVENT
{
if ( gapRole_AdvertOffTime != 0 )
{
if ( ( gapRole_AdvEnabled ) )
{
VOID osal_start_timerEx( gapRole_TaskID, START_ADVERTISING_EVT, gapRole_AdvertOffTime );
}
}
else
{
// Since gapRole_AdvertOffTime is set to 0, the device should not
// automatically become discoverable again after a period of time.
// Set enabler to FALSE; device will become discoverable again when
// this value gets set to TRUE
gapRole_AdvEnabled = FALSE;
}
// In the Advertising Off period
gapRole_state = GAPROLE_WAITING;
}
}
else
{
gapRole_state = GAPROLE_ERROR;
}
isBroadcastMsg = TRUE;
}
break;
default:
break;
}
// If a broadcast event, pass to broadcast callback.
if ( isBroadcastMsg == TRUE )
{
// Notify the application
if ( pGapCentralRoleCB && pGapCentralRoleCB->broadcastCB )
{
pGapCentralRoleCB->broadcastCB( gapRole_state );
}
}
// Otherwise pass to central callback
else if ( pGapCentralRoleCB && pGapCentralRoleCB->centralCB )
{
pGapCentralRoleCB->centralCB( (gapCentralRoleEvent_t *) pMsg );
}
}
