void wkxboot_start_connect()
{
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 );
app_write_string("connecting...");
app_write_string(bdAddr2Str( peerAddr ));
}
}
}
/*********************************************************************
* @fn hidappEstablishLink
*
* @brief Establish a link to a peer device.
*
* @param whiteList - determines use of the white list
* @param addrType - address type of the peer devic
* @param remoteAddr - peer device address
*
* @return none
*/
static void hidappEstablishLink( uint8 whiteList, uint8 addrType, uint8 *remoteAddr )
{
if ( hidappBLEState != BLE_STATE_CONNECTED )
{
hidappBLEState = BLE_STATE_CONNECTING;
// Try to connect to remote device
VOID GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE,
whiteList, addrType, remoteAddr );
VOID osal_start_reload_timer( hidappTaskId, HIDAPP_EVT_INIT_CONNECT,
(uint32)INIT_CONNECT_TIMEOUT );
}
}
void bleshield_central_connect(uint8 *address)
{
GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
1, address );
}
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 );
}
}
}
}
/*********************************************************************
* @fn glucCollCentral_handleKeys
*
* @brief Handles all key events for this device.
*
* @param shift - true if in shift/alt.
* @param keys - bit field for key events.
*
* @return none
*/
static void glucCollCentral_handleKeys(uint8_t shift, uint8_t keys)
{
(void)shift; // Intentionally unreferenced parameter
if (keys & KEY_UP)
{
// Start or stop discovery
if (glucCollState != BLE_STATE_CONNECTED)
{
if (!glucCollScanning)
{
glucCollScanning = TRUE;
glucCollScanRes = 0;
LCD_WRITE_STRING("Discovering...", LCD_PAGE0);
LCD_WRITE_STRING("", LCD_PAGE1);
LCD_WRITE_STRING("", LCD_PAGE2);
GAPCentralRole_StartDiscovery(DEFAULT_DISCOVERY_MODE,
DEFAULT_DISCOVERY_ACTIVE_SCAN,
DEFAULT_DISCOVERY_WHITE_LIST);
}
else
{
GAPCentralRole_CancelDiscovery();
}
}
else if (glucCollState == BLE_STATE_CONNECTED &&
glucCollCharHdls == true &&
glucCollWritePending == false)
{
uint8_t status;
#if GLUCOSE_FILTER_ENABLED
// Request number of records
status = glucoseCtlPntWriteFilter(CTL_PNT_OP_GET_NUM, CTL_PNT_OPER_RANGE,
DEFAULT_FILTER_TYPE, pFilter1, pFilter2);
#else
// Request number of records
status = glucoseCtlPntWrite(CTL_PNT_OP_GET_NUM, CTL_PNT_OPER_ALL);
#endif
if(status == 0)
{
glucCollWritePending = true;
}
}
return;
}
if (keys & KEY_LEFT)
{
// Display discovery results
if (glucCollState != BLE_STATE_CONNECTED && !glucCollScanning &&
glucCollScanRes > 0)
{
// Increment index of current result (with wraparound)
glucCollScanIdx++;
if (glucCollScanIdx >= glucCollScanRes)
{
glucCollScanIdx = 0;
}
LCD_WRITE_STRING_VALUE("Device", glucCollScanIdx + 1,
10, LCD_PAGE0);
LCD_WRITE_STRING(Util_convertBdAddr2Str(glucCollDevList[glucCollScanIdx].addr),
LCD_PAGE1);
LCD_WRITE_STRING("", LCD_PAGE2);
}
else if (glucCollState == BLE_STATE_CONNECTED)
{
if(glucoseCtlPntWrite(CTL_PNT_OP_ABORT, CTL_PNT_OPER_NULL) == 0)
{
glucCollWritePending = false;
}
}
return;
}
if (keys & KEY_RIGHT)
{
// Request all records
if (glucCollState == BLE_STATE_CONNECTED &&
glucCollCharHdls == true &&
glucCollWritePending == false)
{
uint8_t status;
#if GLUCOSE_FILTER_ENABLED
status = glucoseCtlPntWriteFilter(CTL_PNT_OP_REQ, CTL_PNT_OPER_RANGE,
DEFAULT_FILTER_TYPE, pFilter1, pFilter2);
#else
status = glucoseCtlPntWrite(CTL_PNT_OP_REQ, CTL_PNT_OPER_ALL);
#endif
if(status == SUCCESS)
{
glucCollWritePending = true;
}
}
return;
}
if (keys & KEY_SELECT)
{
uint8_t addrType;
uint8_t *peerAddr;
// Connect or disconnect
if (glucCollState == BLE_STATE_IDLE)
{
// if there is a scan result
if (glucCollScanRes > 0)
{
// connect to current device in scan result
peerAddr = glucCollDevList[glucCollScanIdx].addr;
addrType = glucCollDevList[glucCollScanIdx].addrType;
glucCollState = BLE_STATE_CONNECTING;
GAPCentralRole_EstablishLink(DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
addrType, peerAddr);
LCD_WRITE_STRING("Connecting", LCD_PAGE0);
LCD_WRITE_STRING(Util_convertBdAddr2Str(peerAddr), LCD_PAGE1);
LCD_WRITE_STRING("", LCD_PAGE2);
}
}
else if (glucCollState == BLE_STATE_CONNECTING ||
glucCollState == BLE_STATE_CONNECTED)
{
// disconnect
glucCollState = BLE_STATE_DISCONNECTING;
GAPCentralRole_TerminateLink(glucCollConnHandle);
LCD_WRITE_STRING("Disconnecting", LCD_PAGE0);
LCD_WRITE_STRING("", LCD_PAGE1);
LCD_WRITE_STRING("", LCD_PAGE2);
}
return;
}
if (keys & KEY_DOWN)
{
// Clear stored records
if (glucCollState == BLE_STATE_CONNECTED &&
glucCollCharHdls == true &&
glucCollWritePending == false)
{
uint8_t status;
#if GLUCOSE_FILTER_ENABLED
status = glucoseCtlPntWriteFilter(CTL_PNT_OP_CLR, CTL_PNT_OPER_RANGE,
DEFAULT_FILTER_TYPE, pFilter1, pFilter2);
#else
status = glucoseCtlPntWrite(CTL_PNT_OP_CLR, CTL_PNT_OPER_ALL);
#endif
if(status == 0)
{
glucCollWritePending = true;
glucCollClearPending = true;
}
}
else if (glucCollState != BLE_STATE_CONNECTED)
{
// erase all bonds
GAPBondMgr_SetParameter(GAPBOND_ERASE_ALLBONDS, 0, NULL);
LCD_WRITE_STRING("Erasing bonds", LCD_PAGE0);
LCD_WRITE_STRING("", LCD_PAGE1);
LCD_WRITE_STRING("", LCD_PAGE2);
// initiate service discovery again
glucCollCharHdls = false;
}
}
}
/*********************************************************************
* @fn simpleBLECentralEventCB
*
* @brief Central event callback function.
*
* @param pEvent - pointer to event structure
*
* @return none
*/
static void simpleBLECentralEventCB( gapCentralRoleEvent_t *pEvent )
{
switch ( pEvent->gap.opcode )
{
case GAP_DEVICE_INIT_DONE_EVENT:
{
LCD_WRITE_STRING( "BLE Central", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( pEvent->initDone.devAddr ), HAL_LCD_LINE_2 );
#if 1
// 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 );
//HCI_EXT_SetRxGainCmd(HCI_EXT_RX_GAIN_HIGH);
//HCI_EXT_SetTxPowerCmd(HCI_EXT_TX_POWER_0_DBM);
GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,
DEFAULT_DISCOVERY_ACTIVE_SCAN,
DEFAULT_DISCOVERY_WHITE_LIST );
HalLedSet(HAL_LED_1,HAL_LED_MODE_ON);
}
else
{
HalLedSet(HAL_LED_1,HAL_LED_MODE_OFF);
GAPCentralRole_CancelDiscovery();
}
}
#endif
}
break;
case GAP_DEVICE_INFO_EVENT:
{
// if filtering device discovery results based on service UUID
//HalLedSet(HAL_LED_1,HAL_LED_MODE_OFF);
if ( DEFAULT_DEV_DISC_BY_SVC_UUID == TRUE )
{
if ( simpleBLEFindSvcUuid( SIMPLEPROFILE_SERV_UUID,
pEvent->deviceInfo.pEvtData,
pEvent->deviceInfo.dataLen ) )
{
//HalLedSet(HAL_LED_1,HAL_LED_MODE_OFF);
simpleBLEAddDeviceInfo( pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType );
}
}
}
break;
case GAP_DEVICE_DISCOVERY_EVENT:
{
// discovery complete
simpleBLEScanning = FALSE;
// if not filtering device discovery results based on service UUID
if ( DEFAULT_DEV_DISC_BY_SVC_UUID == FALSE )
{
// Copy results
simpleBLEScanRes = pEvent->discCmpl.numDevs;
osal_memcpy( simpleBLEDevList, pEvent->discCmpl.pDevList,
(sizeof( gapDevRec_t ) * pEvent->discCmpl.numDevs) );
//HalLedSet(HAL_LED_2,HAL_LED_MODE_ON);
}
LCD_WRITE_STRING_VALUE( "Devices Found", simpleBLEScanRes,
10, HAL_LCD_LINE_1 );
if ( simpleBLEScanRes > 0 )
{
LCD_WRITE_STRING( "<- To Select", HAL_LCD_LINE_2 );
//HalLedSet(HAL_LED_2,HAL_LED_MODE_OFF);
}
// initialize scan index to last device
simpleBLEScanIdx = simpleBLEScanRes;
#if 1
// 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 );
}
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 1
// 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 );
//HCI_EXT_SetRxGainCmd(HCI_EXT_RX_GAIN_HIGH);
//HCI_EXT_SetTxPowerCmd(HCI_EXT_TX_POWER_0_DBM);
GAPCentralRole_StartDiscovery( DEFAULT_DISCOVERY_MODE,
DEFAULT_DISCOVERY_ACTIVE_SCAN,
DEFAULT_DISCOVERY_WHITE_LIST );
//HalLedSet(HAL_LED_1,HAL_LED_MODE_ON);
}
else
{
HalLedSet(HAL_LED_1,HAL_LED_MODE_OFF);
GAPCentralRole_CancelDiscovery();
}
}
#endif
}
}
#endif
}
break;
case GAP_LINK_ESTABLISHED_EVENT:
{
if ( pEvent->gap.hdr.status == SUCCESS )
{
simpleBLEState = BLE_STATE_CONNECTED;
simpleBLEConnHandle = pEvent->linkCmpl.connectionHandle;
simpleBLEProcedureInProgress = TRUE;
// If service discovery not performed initiate service discovery
if ( simpleBLECharHdl == 0 )
{
osal_start_timerEx( simpleBLETaskId, START_DISCOVERY_EVT, DEFAULT_SVC_DISCOVERY_DELAY );
}
LCD_WRITE_STRING( "Connected", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( pEvent->linkCmpl.devAddr ), HAL_LCD_LINE_2 );
HalLedSet(HAL_LED_2,HAL_LED_MODE_ON);
}
else
{
simpleBLEState = BLE_STATE_IDLE;
simpleBLEConnHandle = GAP_CONNHANDLE_INIT;
simpleBLERssi = FALSE;
simpleBLEDiscState = BLE_DISC_STATE_IDLE;
LCD_WRITE_STRING( "Connect Failed", HAL_LCD_LINE_1 );
LCD_WRITE_STRING_VALUE( "Reason:", pEvent->gap.hdr.status, 10, HAL_LCD_LINE_2 );
}
}
break;
case GAP_LINK_TERMINATED_EVENT:
{
simpleBLEState = BLE_STATE_IDLE;
simpleBLEConnHandle = GAP_CONNHANDLE_INIT;
simpleBLERssi = FALSE;
simpleBLEDiscState = BLE_DISC_STATE_IDLE;
simpleBLECharHdl = 0;
simpleBLEProcedureInProgress = FALSE;
LCD_WRITE_STRING( "Disconnected", HAL_LCD_LINE_1 );
LCD_WRITE_STRING_VALUE( "Reason:", pEvent->linkTerminate.reason,
10, HAL_LCD_LINE_2 );
HalLedSet(HAL_LED_2,HAL_LED_MODE_OFF);
}
break;
case GAP_LINK_PARAM_UPDATE_EVENT:
{
LCD_WRITE_STRING( "Param Update", HAL_LCD_LINE_1 );
}
break;
default:
break;
}
}
/*********************************************************************************************
* @fn simpleBLECentralEventCB
*
* @brief Central event callback function.
*
* @param pEvent - pointer to event structure
*
* @return none
**********************************************************************************************/
static void simpleBLECentralEventCB( gapCentralRoleEvent_t *pEvent ){
switch ( pEvent->gap.opcode ){
case GAP_DEVICE_INIT_DONE_EVENT:{
//LCDPrintText("Central Initialized",0,PRINT_STRING);
osal_memcpy(mac_buffer[0],pEvent->initDone.devAddr, MAC_LEN);
HalLcdWriteString(bdAddr2Str( mac_buffer[0]), HAL_LCD_LINE_1);
uint32 random_scan_duration =500;//to avoid normal scan be discarded by the timer,so its lasting-time should be short
GAP_SetParamValue( TGAP_GEN_DISC_SCAN, random_scan_duration ); //random scan duration
//LCDPrintText("discovering",0,PRINT_STRING);
uint32 timeout_value = 200; // timeout_value - in milliseconds.
osal_start_timerEx(MasterSlaveSwitchTaskID, PERIOD_DETECH_EVT, timeout_value);
uint8 return_status;
if(return_status = GAPCentralRole_StartDiscovery(DISCOVERY_MODE, ACTIVE_SCAN, DISCOVERY_WHITE_LIST ))
LCDPrintText("discovery error:",return_status,PRINT_VALUE);
break;
}
case GAP_DEVICE_INFO_EVENT:{ //find a new device
// filtering device discovery results based on service UUID
//LCDPrintText("find new device",0,PRINT_STRING);
if(simpleBLEScanRes >= MAX_SCAN_RES){
GAPCentralRole_CancelDiscovery();
break;
}
if ( simpleBLEFindSvcUuid(WANTED_SERVICE_UUID, pEvent->deviceInfo.pEvtData, pEvent->deviceInfo.dataLen) ){
simpleBLEAddDeviceInfo( pEvent->deviceInfo.addr, pEvent->deviceInfo.addrType );
//GAPCentralRole_CancelDiscovery(); //stop discoverying
}
break;
}
case GAP_DEVICE_DISCOVERY_EVENT:{ //discaovery has completed
osal_stop_timerEx(MasterSlaveSwitchTaskID,PERIOD_DETECH_EVT);
//LCDPrintText("disca completed ",0,PRINT_STRING);
if ( simpleBLEScanRes > 0 ){
// connect to current device in scan result
uint8 random_select = random_num%simpleBLEScanRes;
//LCDPrintText("random_select ",random_select,PRINT_STRING);
CurrentConnectionInfo.MacType= simpleBLEDevList[random_select].addrType;
CurrentConnectionInfo.MacAddr= simpleBLEDevList[random_select].addr;
uint8 return_status;
if(return_status = GAPCentralRole_EstablishLink( LINK_HIGH_DUTY_CYCLE, LINK_WHITE_LIST, CurrentConnectionInfo.MacType, CurrentConnectionInfo.MacAddr)){
LCDPrintText("Link Error",return_status,PRINT_VALUE);
osal_set_event(MasterSlaveSwitchTaskID, MSS_CHANGE_ROLE_EVT);
}
}
else{
//LCDPrintText("no device found",0,PRINT_STRING);
osal_set_event(MasterSlaveSwitchTaskID, MSS_CHANGE_ROLE_EVT); //switch to periperal
}
break;
}
case GAP_LINK_ESTABLISHED_EVENT:{
if ( pEvent->gap.hdr.status == SUCCESS ){
//LCDPrintText("Connected",0,PRINT_STRING);
CurrentConnectionInfo.Handle= pEvent->linkCmpl.connectionHandle;
if(CharHandleSearchFlag == 1)
simpleBLECentralStartDiscovery();
else{
ClientWriteValue();
CharSendingFlag =1;
//LCDPrintText("NO NEED TO",0,PRINT_STRING);
}
}
else{
LCDPrintText("Connect Failed ",pEvent->gap.hdr.status,PRINT_VALUE);
osal_set_event(MasterSlaveSwitchTaskID, MSS_CHANGE_ROLE_EVT);
}
break;
}
case GAP_LINK_TERMINATED_EVENT:{
osal_set_event(MasterSlaveSwitchTaskID, MSS_CHANGE_ROLE_EVT);
break;
}
case GAP_LINK_PARAM_UPDATE_EVENT:
break;
default:
break;
}
}
/*********************************************************************
* @fn oadManager_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 oadManager_HandleKeys( uint8 shift, uint8 keys )
{
(void)shift; // Intentionally unreferenced parameter
if ( keys & HAL_KEY_UP ) // Start or stop discovery
{
if ( oadManagerState != BLE_STATE_CONNECTED )
{
if ( !oadManagerScanning )
{
(void)osal_set_event(oadManagerTaskId, DEV_DISCOVERY_EVT);
}
else
{
GAPCentralRole_CancelDiscovery();
}
}
}
if ( keys & HAL_KEY_LEFT )
{
// Display discovery results
if ( !oadManagerScanning && oadManagerScanRes > 0 )
{
// Increment index of current result (with wraparound)
oadManagerScanIdx++;
if ( oadManagerScanIdx >= oadManagerScanRes )
{
oadManagerScanIdx = 0;
}
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
LCD_WRITE_STRING_VALUE( "Device", oadManagerScanIdx + 1, 10, HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( oadManagerDevList[oadManagerScanIdx].addr ), HAL_LCD_LINE_2 );
#endif
}
}
if ( keys & HAL_KEY_RIGHT )
{
}
if ( keys & HAL_KEY_CENTER )
{
uint8 addrType;
uint8 *peerAddr;
// Connect or disconnect
if ( oadManagerState == BLE_STATE_IDLE )
{
// if there is a scan result
if ( oadManagerScanRes > 0 )
{
if ( oadManagerScanIdx < oadManagerScanRes )
{
// connect to current device in scan result
peerAddr = oadManagerDevList[oadManagerScanIdx].addr;
addrType = oadManagerDevList[oadManagerScanIdx].addrType;
oadManagerState = BLE_STATE_CONNECTING;
GAPCentralRole_EstablishLink( DEFAULT_LINK_HIGH_DUTY_CYCLE,
DEFAULT_LINK_WHITE_LIST,
addrType, peerAddr );
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
LCD_WRITE_STRING( "Connecting", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( bdAddr2Str( peerAddr ), HAL_LCD_LINE_2 );
}
else
{
LCD_WRITE_STRING( "Select device", HAL_LCD_LINE_3 );
#endif
}
}
}
else if ( oadManagerState == BLE_STATE_CONNECTING || oadManagerState == BLE_STATE_CONNECTED )
{
// disconnect
oadManagerState = BLE_STATE_DISCONNECTING;
VOID GAPCentralRole_TerminateLink( oadManagerConnHandle );
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
LCD_WRITE_STRING( "Disconnecting", HAL_LCD_LINE_1 );
LCD_WRITE_STRING( "", HAL_LCD_LINE_2 );
LCD_WRITE_STRING( "", HAL_LCD_LINE_3 );
#endif
}
}
if ( keys & HAL_KEY_DOWN )
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
LCD_WRITE_STRING("SBL Mode...", HAL_LCD_LINE_3);
#endif
EA = 0;
sblRun();
EA = 1;
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
LCD_WRITE_STRING("SBL Done.", HAL_LCD_LINE_3);
#endif
}
}
