static void FanPeripheralStateNotificationCallBack(gaprole_States_t newState)
{
switch (newState)
{
case GAPROLE_STARTED:
{
uint8 ownAddress[B_ADDR_LEN];
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
}
break;
case GAPROLE_ADVERTISING:
break;
case GAPROLE_CONNECTED:
FanConnected(fanTaskId);
break;
case GAPROLE_WAITING:
{
FanDisConnected();
uint8 advertEnabled = FALSE;
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8), &advertEnabled);
GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanResponseData), scanResponseData);
GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, scanResponseData + 2);
advertEnabled = TRUE;
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8), &advertEnabled);
}
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
break;
case GAPROLE_ERROR:
break;
default:
break;
}
};
/*********************************************************************
* @fn peripheralStateNotificationCB
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void peripheralStateNotificationCB( gaprole_States_t newState )
{
switch ( newState )
{
case GAPROLE_STARTED:
{
uint8 ownAddress[B_ADDR_LEN];
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
}
break;
case GAPROLE_ADVERTISING:
HalLedSet(HAL_LED_1, HAL_LED_MODE_ON );
break;
case GAPROLE_CONNECTED:
HalLedSet(HAL_LED_1, HAL_LED_MODE_OFF );
break;
case GAPROLE_WAITING:
// Link terminated intentionally: reset all sensors
resetSensorSetup();
break;
default:
break;
}
gapProfileState = newState;
}
/*******************************************************************************
* @fn SensorTag_setDeviceInfo
*
* @brief Set application specific Device Information
*
* @param none
*
* @return none
*/
static void SensorTag_setDeviceInfo(void)
{
DevInfo_SetParameter(DEVINFO_MODEL_NUMBER, sizeof(devInfoModelNumber),
(void*)devInfoModelNumber);
DevInfo_SetParameter(DEVINFO_SERIAL_NUMBER, sizeof(devInfoNA),
(void*)devInfoNA);
DevInfo_SetParameter(DEVINFO_SOFTWARE_REV, sizeof(devInfoNA),
(void*)devInfoNA);
DevInfo_SetParameter(DEVINFO_FIRMWARE_REV, sizeof(devInfoFirmwareRev),
(void*)devInfoFirmwareRev);
DevInfo_SetParameter(DEVINFO_HARDWARE_REV, sizeof(devInfoHardwareRev),
(void*)devInfoHardwareRev);
DevInfo_SetParameter(DEVINFO_MANUFACTURER_NAME, sizeof(devInfoMfrName),
(void*)devInfoMfrName);
}
/*******************************************************************************
* @fn SensorTag_processStateChangeEvt
*
* @brief Process a pending GAP Role state change event.
*
* @param newState - new state
*
* @return none
*/
static void SensorTag_processStateChangeEvt(gaprole_States_t newState)
{
#ifdef PLUS_BROADCASTER
static bool firstConnFlag = false;
#endif // PLUS_BROADCASTER
switch (newState)
{
case GAPROLE_STARTED:
{
uint8_t ownAddress[B_ADDR_LEN];
uint8_t systemId[DEVINFO_SYSTEM_ID_LEN];
SensorTag_blinkLed(Board_LED2, 5);
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
LCD_WRITES_STATUS("Initialized");
}
break;
case GAPROLE_ADVERTISING:
// Start the clock
if (!Util_isActive(&periodicClock))
{
Util_startClock(&periodicClock);
}
// Make sure key presses are not stuck
sensorTag_updateAdvertisingData(0);
LCD_WRITES_STATUS("Advertising");
break;
case GAPROLE_CONNECTED:
{
// Start the clock
if (!Util_isActive(&periodicClock))
{
Util_startClock(&periodicClock);
}
// Turn of LEDs and buzzer
PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, Board_BUZZER, Board_BUZZER_OFF);
#ifdef FEATURE_OAD
SensorTagConnectionControl_update();
#endif
#ifdef PLUS_BROADCASTER
// Only turn advertising on for this state when we first connect
// otherwise, when we go from connected_advertising back to this state
// we will be turning advertising back on.
if (firstConnFlag == false)
{
uint8_t advertEnabled = TRUE; // Turn on Advertising
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&advertEnabled);
firstConnFlag = true;
}
#endif // PLUS_BROADCASTER
}
LCD_WRITES_STATUS("Connected");
break;
case GAPROLE_CONNECTED_ADV:
break;
case GAPROLE_WAITING:
case GAPROLE_WAITING_AFTER_TIMEOUT:
SensorTag_resetAllSensors();
LCD_WRITES_STATUS("Waiting...");
break;
case GAPROLE_ERROR:
SensorTag_resetAllSensors();
PIN_setOutputValue(hGpioPin,Board_LED1, Board_LED_ON);
LCD_WRITES_STATUS("Error");
break;
default:
break;
}
gapProfileState = newState;
}
/*********************************************************************
* @fn peripheralStateNotificationCB
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void peripheralStateNotificationCB( gaprole_States_t newState )
{
#ifdef PLUS_BROADCASTER
static uint8 first_conn_flag = 0;
#endif // PLUS_BROADCASTER
switch ( newState )
{
case GAPROLE_STARTED:
{
uint8 ownAddress[B_ADDR_LEN];
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
// Display device address
HalLcdWriteString( bdAddr2Str( ownAddress ), HAL_LCD_LINE_2 );
HalLcdWriteString( "Initialized", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
case GAPROLE_ADVERTISING:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Advertising", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
case GAPROLE_CONNECTED:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Connected", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
#ifdef PLUS_BROADCASTER
// Only turn advertising on for this state when we first connect
// otherwise, when we go from connected_advertising back to this state
// we will be turning advertising back on.
if ( first_conn_flag == 0 )
{
uint8 adv_enabled_status = 1;
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8), &adv_enabled_status); // Turn on Advertising
first_conn_flag = 1;
}
#endif // PLUS_BROADCASTER
}
break;
case GAPROLE_CONNECTED_ADV:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Connected Advertising", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
case GAPROLE_WAITING:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Disconnected", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Timed Out", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
#ifdef PLUS_BROADCASTER
// Reset flag for next connection.
first_conn_flag = 0;
#endif //#ifdef (PLUS_BROADCASTER)
}
break;
case GAPROLE_ERROR:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Error", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
default:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
}
gapProfileState = newState;
#if !defined( CC2540_MINIDK )
VOID gapProfileState; // added to prevent compiler warning with
// "CC2540 Slave" configurations
#endif
}
/*********************************************************************
* @fn peripheralStateNotificationCB
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void peripheralStateNotificationCB( gaprole_States_t newState )
{
uint16 connHandle = INVALID_CONNHANDLE;
uint8 valFalse = FALSE;
if ( gapProfileState != newState )
{
switch( newState )
{
case GAPROLE_STARTED:
{
// Set the system ID from the bd addr
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, systemId);
// shift three bytes up
systemId[7] = systemId[5];
systemId[6] = systemId[4];
systemId[5] = systemId[3];
// set middle bytes to zero
systemId[4] = 0;
systemId[3] = 0;
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
}
break;
//if the state changed to connected, initially assume that keyfob is in range
case GAPROLE_ADVERTISING:
{
// Visual feedback that we are advertising.
HalLedSet( HAL_LED_2, HAL_LED_MODE_ON );
}
break;
//if the state changed to connected, initially assume that keyfob is in range
case GAPROLE_CONNECTED:
{
// set the proximity state to either path loss alert or in range depending
// on the value of keyfobProxIMAlertLevel (which was set by proximity monitor)
if( keyfobProxIMAlertLevel != PP_ALERT_LEVEL_NO )
{
keyfobProximityState = KEYFOB_PROXSTATE_PATH_LOSS;
// perform alert
keyfobapp_PerformAlert();
buzzer_beep_count = 0;
}
else // if keyfobProxIMAlertLevel == PP_ALERT_LEVEL_NO
{
keyfobProximityState = KEYFOB_PROXSTATE_CONNECTED_IN_RANGE;
keyfobapp_StopAlert();
}
GAPRole_GetParameter( GAPROLE_CONNHANDLE, &connHandle );
#if defined ( PLUS_BROADCASTER )
osal_start_timerEx( keyfobapp_TaskID, KFD_ADV_IN_CONNECTION_EVT, ADV_IN_CONN_WAIT );
#endif
// Turn off LED that shows we're advertising
HalLedSet( HAL_LED_2, HAL_LED_MODE_OFF );
}
break;
case GAPROLE_WAITING:
{
// then the link was terminated intentionally by the slave or master,
// or advertising timed out
keyfobProximityState = KEYFOB_PROXSTATE_INITIALIZED;
// Turn off immediate alert
ProxReporter_SetParameter(PP_IM_ALERT_LEVEL, sizeof(valFalse), &valFalse);
keyfobProxIMAlertLevel = PP_ALERT_LEVEL_NO;
// Change attribute value of Accelerometer Enable to FALSE
Accel_SetParameter(ACCEL_ENABLER, sizeof(valFalse), &valFalse);
// Stop the acceleromter
accelEnablerChangeCB(); // SetParameter does not trigger the callback
// Turn off LED that shows we're advertising
HalLedSet( HAL_LED_2, HAL_LED_MODE_OFF );
// Stop alert if it was active
if( keyfobAlertState != ALERT_STATE_OFF )
{
keyfobapp_StopAlert();
}
}
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
{
// the link was dropped due to supervision timeout
keyfobProximityState = KEYFOB_PROXSTATE_LINK_LOSS;
// Turn off immediate alert
ProxReporter_SetParameter(PP_IM_ALERT_LEVEL, sizeof(valFalse), &valFalse);
keyfobProxIMAlertLevel = PP_ALERT_LEVEL_NO;
// Change attribute value of Accelerometer Enable to FALSE
Accel_SetParameter(ACCEL_ENABLER, sizeof(valFalse), &valFalse);
// Stop the acceleromter
accelEnablerChangeCB(); // SetParameter does not trigger the callback
// Perform link loss alert if enabled
if( keyfobProxLLAlertLevel != PP_ALERT_LEVEL_NO )
{
keyfobapp_PerformAlert();
buzzer_beep_count = 0;
}
}
break;
default:
// do nothing
break;
}
}
gapProfileState = newState;
}
/*********************************************************************
* @fn SimpleBLEPeripheral_processStateChangeEvt
*
* @brief Process a pending GAP Role state change event.
*
* @param newState - new state
*
* @return None.
*/
static void SimpleBLEPeripheral_processStateChangeEvt(gaprole_States_t newState)
{
#ifdef PLUS_BROADCASTER
static bool firstConnFlag = false;
#endif // PLUS_BROADCASTER
switch ( newState )
{
case GAPROLE_STARTED:
{
uint8_t ownAddress[B_ADDR_LEN];
uint8_t systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
// Display device address
Display_print0(dispHandle, 1, 0, Util_convertBdAddr2Str(ownAddress));
Display_print0(dispHandle, 2, 0, "Initialized");
}
break;
case GAPROLE_ADVERTISING:
Display_print0(dispHandle, 2, 0, "Advertising");
break;
#ifdef PLUS_BROADCASTER
/* After a connection is dropped a device in PLUS_BROADCASTER will continue
* sending non-connectable advertisements and shall sending this change of
* state to the application. These are then disabled here so that sending
* connectable advertisements can resume.
*/
case GAPROLE_ADVERTISING_NONCONN:
{
uint8_t advertEnabled = FALSE;
// Disable non-connectable advertising.
GAPRole_SetParameter(GAPROLE_ADV_NONCONN_ENABLED, sizeof(uint8_t),
&advertEnabled);
advertEnabled = TRUE;
// Enabled connectable advertising.
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&advertEnabled);
// Reset flag for next connection.
firstConnFlag = false;
SimpleBLEPeripheral_freeAttRsp(bleNotConnected);
}
break;
#endif //PLUS_BROADCASTER
case GAPROLE_CONNECTED:
{
linkDBInfo_t linkInfo;
uint8_t numActive = 0;
Util_startClock(&periodicClock);
numActive = linkDB_NumActive();
// Use numActive to determine the connection handle of the last
// connection
if ( linkDB_GetInfo( numActive - 1, &linkInfo ) == SUCCESS )
{
Display_print1(dispHandle, 2, 0, "Num Conns: %d", (uint16_t)numActive);
Display_print0(dispHandle, 3, 0, Util_convertBdAddr2Str(linkInfo.addr));
}
else
{
uint8_t peerAddress[B_ADDR_LEN];
GAPRole_GetParameter(GAPROLE_CONN_BD_ADDR, peerAddress);
Display_print0(dispHandle, 2, 0, "Connected");
Display_print0(dispHandle, 3, 0, Util_convertBdAddr2Str(peerAddress));
}
#ifdef PLUS_BROADCASTER
// Only turn advertising on for this state when we first connect
// otherwise, when we go from connected_advertising back to this state
// we will be turning advertising back on.
if (firstConnFlag == false)
{
uint8_t advertEnabled = FALSE; // Turn on Advertising
// Disable connectable advertising.
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&advertEnabled);
// Set to true for non-connectabel advertising.
advertEnabled = TRUE;
// Enable non-connectable advertising.
GAPRole_SetParameter(GAPROLE_ADV_NONCONN_ENABLED, sizeof(uint8_t),
&advertEnabled);
firstConnFlag = true;
}
#endif // PLUS_BROADCASTER
}
break;
case GAPROLE_CONNECTED_ADV:
Display_print0(dispHandle, 2, 0, "Connected Advertising");
break;
case GAPROLE_WAITING:
Util_stopClock(&periodicClock);
SimpleBLEPeripheral_freeAttRsp(bleNotConnected);
Display_print0(dispHandle, 2, 0, "Disconnected");
// Clear remaining lines
Display_clearLines(dispHandle, 3, 5);
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
SimpleBLEPeripheral_freeAttRsp(bleNotConnected);
Display_print0(dispHandle, 2, 0, "Timed Out");
// Clear remaining lines
Display_clearLines(dispHandle, 3, 5);
#ifdef PLUS_BROADCASTER
// Reset flag for next connection.
firstConnFlag = false;
#endif //#ifdef (PLUS_BROADCASTER)
break;
case GAPROLE_ERROR:
Display_print0(dispHandle, 2, 0, "Error");
break;
default:
Display_clearLine(dispHandle, 2);
break;
}
// Update the state
//gapProfileState = newState;
}
/*********************************************************************
* @fn simpleTopology_processRoleEvent
*
* @brief Multi role event processing function.
*
* @param pEvent - pointer to event structure
*
* @return none
*/
static void simpleTopology_processRoleEvent(gapMultiRoleEvent_t *pEvent)
{
switch (pEvent->gap.opcode)
{
case GAP_DEVICE_INIT_DONE_EVENT:
{
maxPduSize = pEvent->initDone.dataPktLen;
LCD_WRITE_STRING("Connected to 0", LCD_PAGE0);
LCD_WRITE_STRING(Util_convertBdAddr2Str(pEvent->initDone.devAddr),
LCD_PAGE1);
LCD_WRITE_STRING("Initialized", LCD_PAGE2);
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, pEvent->initDone.devAddr);
}
break;
case GAP_MAKE_DISCOVERABLE_DONE_EVENT:
{
if (gapRoleNumLinks(GAPROLE_ACTIVE_LINKS) > 0)
{
LCD_WRITE_STRING("Advertising", LCD_PAGE2);
}
else
{
LCD_WRITE_STRING("Advertising", LCD_PAGE2);
}
}
break;
case GAP_END_DISCOVERABLE_DONE_EVENT:
{
if (gapRoleNumLinks(GAPROLE_AVAILABLE_LINKS) > 0)
{
LCD_WRITE_STRING("Ready to Advertise", LCD_PAGE2);
}
else
{
LCD_WRITE_STRING("Can't Adv : No links", LCD_PAGE2);
}
}
break;
case GAP_DEVICE_INFO_EVENT:
{
// if filtering device discovery results based on service UUID
if (DEFAULT_DEV_DISC_BY_SVC_UUID == TRUE)
{
if (simpleTopology_findSvcUuid(SIMPLEPROFILE_SERV_UUID,
pEvent->deviceInfo.pEvtData,
pEvent->deviceInfo.dataLen))
{
simpleTopology_addDeviceInfo(pEvent->deviceInfo.addr,
pEvent->deviceInfo.addrType);
}
}
}
break;
case GAP_DEVICE_DISCOVERY_EVENT:
{
// discovery complete
scanningStarted = FALSE;
// if not filtering device discovery results based on service UUID
if (DEFAULT_DEV_DISC_BY_SVC_UUID == FALSE)
{
// Copy results
scanRes = pEvent->discCmpl.numDevs;
memcpy(devList, pEvent->discCmpl.pDevList,
(sizeof(gapDevRec_t) * scanRes));
}
LCD_WRITE_STRING_VALUE("Devices Found", scanRes, 10, LCD_PAGE3);
if (scanRes > 0)
{
LCD_WRITE_STRING("<- To Select", LCD_PAGE4);
}
// initialize scan index to last device
scanIdx = scanRes;
}
break;
case GAP_LINK_ESTABLISHED_EVENT:
{
if (pEvent->gap.hdr.status == SUCCESS)
{
LCD_WRITE_STRING("Connected!", LCD_PAGE3);
LCD_WRITE_STRING_VALUE("Connected to ", gapRoleNumLinks(GAPROLE_ACTIVE_LINKS) ,10, LCD_PAGE0);
//update state
connecting_state = 0;
//store connection handle
connHandle = pEvent->linkCmpl.connectionHandle;
//if we're not advertising, attempt to turn advertising back on
uint8_t adv;
GAPRole_GetParameter(GAPROLE_ADVERT_ENABLED, &adv, NULL);
if (adv == 1) //connected and advertising
{
if (gapRoleNumLinks(GAPROLE_AVAILABLE_LINKS) > 0)
{
LCD_WRITE_STRING("Advertising", LCD_PAGE2);
}
else //no available links
{
LCD_WRITE_STRING("Can't adv: no links", LCD_PAGE2);
}
}
else //not currently advertising
{
LCD_WRITE_STRING("Ready to Advertise", LCD_PAGE2);
//attempt to turn advertising back o
uint8_t advertEnabled = TRUE;
uint8_t stat = GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &advertEnabled, NULL);
if (stat == bleNoResources) //no more links
{
LCD_WRITE_STRING("Can't adv: no links", LCD_PAGE2);
}
else if (stat == SUCCESS) //turning advertising back on
{
LCD_WRITE_STRING("Advertising", LCD_PAGE2);
}
else
{
while(1);
}
}
// Print last connected device
LCD_WRITE_STRING("", LCD_PAGE4);
LCD_WRITE_STRING(Util_convertBdAddr2Str(pEvent->linkCmpl.devAddr), LCD_PAGE5 );
// initiate service discovery
Util_startClock(&startDiscClock);
}
else
{
connHandle = GAP_CONNHANDLE_INIT;
discState = BLE_DISC_STATE_IDLE;
LCD_WRITE_STRING("Connect Failed", LCD_PAGE4);
LCD_WRITE_STRING_VALUE("Reason:", pEvent->gap.hdr.status, 10,
LCD_PAGE3);
}
}
break;
case GAP_LINK_TERMINATED_EVENT:
{
connHandle = GAP_CONNHANDLE_INIT;
discState = BLE_DISC_STATE_IDLE;
uint8_t i;
for (i=0; i < MAX_NUM_BLE_CONNS; i++)
{
if (multiConnInfo[i].gapRole_ConnectionHandle == GAPROLE_CONN_JUST_TERMINATED)
{
//clear screen, reset discovery info, and return to main menu
multiConnInfo[i].gapRole_ConnectionHandle = INVALID_CONNHANDLE;
charHdl[i] = 0;
LCD_WRITE_STRING_VALUE("Connected to ", gapRoleNumLinks(GAPROLE_ACTIVE_LINKS) ,10, LCD_PAGE0);
LCD_WRITE_STRING("Disconnected!", LCD_PAGE5);
LCD_WRITE_STRING("Main Menu", LCD_PAGE3);
LCDmenu = MAIN_MENU;
}
if ((gapRoleNumLinks(GAPROLE_ACTIVE_LINKS) == (MAX_NUM_BLE_CONNS-1))) //now we can advertise again
{
LCD_WRITE_STRING("Ready to Advertise", LCD_PAGE2);
}
}
}
break;
case GAP_LINK_PARAM_UPDATE_EVENT:
{
LCD_WRITE_STRING_VALUE("Param Update:", pEvent->linkUpdate.status,
10, LCD_PAGE2);
}
break;
default:
break;
}
}
/*********************************************************************
* @fn HeartRateGapStateCB
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void HeartRateGapStateCB( gaprole_States_t newState )
{
// if connected
if (newState == GAPROLE_CONNECTED)
{
// get connection handle
GAPRole_GetParameter(GAPROLE_CONNHANDLE, &gapConnHandle);
}
// if disconnected
else if (gapProfileState == GAPROLE_CONNECTED &&
newState != GAPROLE_CONNECTED)
{
uint8 advState = TRUE;
// stop periodic measurement
osal_stop_timerEx( heartRate_TaskID, HEART_PERIODIC_EVT );
if ( newState == GAPROLE_WAITING_AFTER_TIMEOUT )
{
// link loss timeout-- use fast advertising
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 );
}
else
{
// Else use slow advertising
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_MIN, DEFAULT_SLOW_ADV_DURATION );
}
// Enable advertising
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advState );
}
// if advertising stopped
else if ( gapProfileState == GAPROLE_ADVERTISING &&
newState == GAPROLE_WAITING )
{
// if advertising stopped by user
if ( heartRateAdvCancelled )
{
heartRateAdvCancelled = FALSE;
}
// if fast advertising switch to slow
else if ( GAP_GetParamValue( TGAP_GEN_DISC_ADV_INT_MIN ) == DEFAULT_FAST_ADV_INTERVAL )
{
uint8 advState = TRUE;
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_MIN, DEFAULT_SLOW_ADV_DURATION );
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advState );
}
}
// if started
else if (newState == GAPROLE_STARTED)
{
// Set the system ID from the bd addr
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, systemId);
// shift three bytes up
systemId[7] = systemId[5];
systemId[6] = systemId[4];
systemId[5] = systemId[3];
// set middle bytes to zero
systemId[4] = 0;
systemId[3] = 0;
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
}
gapProfileState = newState;
}
/*********************************************************************
* @fn trainingTag_processStateChangeEvt
*
* @brief Process a pending GAP Role state change event.
*
* @param newState - new state
*
* @return None.
*/
static void trainingTag_processStateChangeEvt(gaprole_States_t newState)
{
switch ( newState )
{
case GAPROLE_STARTED:
{
uint8_t ownAddress[B_ADDR_LEN];
uint8_t systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
// Display device address
System_printf("Device address: %s\r\n", Util_convertBdAddr2Str(ownAddress));
System_printf("Initialized\r\n");
}
break;
case GAPROLE_ADVERTISING:
System_printf("Advertising\r\n");
break;
case GAPROLE_CONNECTED:
{
uint8_t peerAddress[B_ADDR_LEN];
GAPRole_GetParameter(GAPROLE_CONN_BD_ADDR, peerAddress);
Util_startClock(&periodicClock);
System_printf("Connected\r\n");
System_printf("Device address: %s\r\n", Util_convertBdAddr2Str(peerAddress));
#ifdef PLUS_BROADCASTER
// Only turn advertising on for this state when we first connect
// otherwise, when we go from connected_advertising back to this state
// we will be turning advertising back on.
if (firstConnFlag == false)
{
uint8_t advertEnabled = TRUE; // Turn on Advertising
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&advertEnabled);
firstConnFlag = true;
}
#endif // PLUS_BROADCASTER
}
break;
case GAPROLE_CONNECTED_ADV:
System_printf("Connected Advertising\r\n");
break;
case GAPROLE_WAITING:
Util_stopClock(&periodicClock);
System_printf("Disconnected\r\n");
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
System_printf("Timed Out\r\n");
#ifdef PLUS_BROADCASTER
// Reset flag for next connection.
firstConnFlag = false;
#endif //#ifdef (PLUS_BROADCASTER)
break;
case GAPROLE_ERROR:
System_printf("Error\r\n");
break;
default:
System_printf("\r\n");
break;
}
// Update the state
//gapProfileState = newState;
}
/*********************************************************************
* @fn SimplePropBeacon_processStateChangeEvt
*
* @brief Process a pending GAP Role state change event.
*
* @param newState - new state
*
* @return None.
*/
static void SimplePropBeacon_processStateChangeEvt(gaprole_States_t newState)
{
switch ( newState )
{
case GAPROLE_STARTED:
{
uint8_t ownAddress[B_ADDR_LEN];
uint8_t systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
// Display device address
Display_print0(dispHandle, 1, 0, Util_convertBdAddr2Str(ownAddress));
Display_print0(dispHandle, 2, 0, "Initialized");
// Start advertising
SimplePropBeacon_startRegularAdv();
}
break;
case GAPROLE_ADVERTISING:
Display_print0(dispHandle, 2, 0, "Config Mode");
break;
case GAPROLE_ADVERTISING_NONCONN:
{
SimplePropBeacon_freeAttRsp(bleNotConnected);
Display_print0(dispHandle, 2, 0, "Advertising Proprietary Beacon");
Display_print0(dispHandle, 3, 0, "");
break;
}
case GAPROLE_CONNECTED:
{
linkDBInfo_t linkInfo;
uint8_t numActive = 0;
numActive = linkDB_NumActive();
// Use numActive to determine the connection handle of the last
// connection
if ( linkDB_GetInfo( numActive - 1, &linkInfo ) == SUCCESS )
{
Display_print1(dispHandle, 2, 0, "Num Conns: %d", (uint16_t)numActive);
Display_print0(dispHandle, 3, 0, Util_convertBdAddr2Str(linkInfo.addr));
}
else
{
uint8_t peerAddress[B_ADDR_LEN];
GAPRole_GetParameter(GAPROLE_CONN_BD_ADDR, peerAddress);
Display_print0(dispHandle, 2, 0, "Connected");
Display_print0(dispHandle, 3, 0, Util_convertBdAddr2Str(peerAddress));
}
}
break;
case GAPROLE_WAITING:
case GAPROLE_WAITING_AFTER_TIMEOUT:
SimplePropBeacon_freeAttRsp(bleNotConnected);
SimplePropBeacon_startRegularAdv();
break;
case GAPROLE_ERROR:
Display_print0(dispHandle, 2, 0, "Error");
break;
default:
Display_clearLine(dispHandle, 2);
break;
}
}
/*********************************************************************
* @fn peripheralStateNotificationCB
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void peripheralStateNotificationCB( gaprole_States_t newState )
{
#ifdef PLUS_BROADCASTER
static uint8 first_conn_flag = 0;
#endif // PLUS_BROADCASTER
switch ( newState )
{
case GAPROLE_STARTED:
{
uint8 ownAddress[B_ADDR_LEN];
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
// Display device address
HalLcdWriteString( bdAddr2Str( ownAddress ), HAL_LCD_LINE_2 );
HalLcdWriteString( "Initialized", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
UART_SEND_DEBUG_MSG( "State > DevInit\r\n", 17 );
}
break;
case GAPROLE_ADVERTISING:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Advertising", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( " ", HAL_LCD_LINE_6 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
UART_SEND_DEBUG_MSG( "State > Advertising...\r\n", 24 );
UART_SEND_STRING("s,dB,disconnect,e\r\n",19);
// << Wayne >> << Check Connect Overtime> > ++
osal_stop_timerEx( simpleBLEPeripheral_TaskID, SBP_CONNECT_OVERTIME_EVT );
// << Wayne >> << Check Connect Overtime> > --
// << Wayne >> << Random Number Generator 20 bytes >> ++
SimpleProfile_SetParameter( SIMPLEPROFILE_CHAR2, SIMPLEPROFILE_CHAR2_LEN, randomGen_Max20bytes(SIMPLEPROFILE_CHAR2_LEN) );
// << Wayne >> << Random Number Generator 20 bytes >> --
}
break;
case GAPROLE_CONNECTED:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Connected", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
UART_SEND_DEBUG_MSG( "State > Connected\r\n", 19 );
// << Wayne >> << Check Connect Overtime> > ++
//osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_CONNECT_OVERTIME_EVT, SBP_CHECK_CONNECT_OVERTIME_DELAY );
// << Wayne >> << Check Connect Overtime> > --
#ifdef PLUS_BROADCASTER
// Only turn advertising on for this state when we first connect
// otherwise, when we go from connected_advertising back to this state
// we will be turning advertising back on.
if ( first_conn_flag == 0 )
{
uint8 adv_enabled_status = 1;
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8), &adv_enabled_status); // Turn on Advertising
first_conn_flag = 1;
}
#endif // PLUS_BROADCASTER
}
break;
case GAPROLE_CONNECTED_ADV:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Connected Advertising", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
UART_SEND_DEBUG_MSG( "State > Connected Advertising\r\n", 31 );
}
break;
case GAPROLE_WAITING:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Disconnected", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
UART_SEND_DEBUG_MSG( "State > Waiting\r\n", 17 );
}
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Timed Out", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
UART_SEND_DEBUG_MSG( "State > Time Out\r\n", 18 );
#ifdef PLUS_BROADCASTER
// Reset flag for next connection.
first_conn_flag = 0;
#endif //#ifdef (PLUS_BROADCASTER)
}
break;
case GAPROLE_ERROR:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Error", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
UART_SEND_DEBUG_MSG( "State > Error\r\n", 15 );
}
break;
default:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
}
gapProfileState = newState;
VOID gapProfileState; // added to prevent compiler warning with
}
/*********************************************************************
* @fn peripheralStateNotificationCB
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void peripheralStateNotificationCB( gaprole_States_t newState )
{
switch ( newState )
{
case GAPROLE_STARTED:
{
uint8 ownAddress[B_ADDR_LEN];
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
UartCommand = 1;
#ifdef UARTDEBUG
memset(SerialApp_Buf,0,sizeof(SerialApp_Buf));
strcpy(SerialApp_Buf,"Initialized\nMAC: ");
strcat(SerialApp_Buf,bdAddr2Str(ownAddress));
strcat(SerialApp_Buf,"\n");
HalUARTWrite(USE_UART_PORT, SerialApp_Buf,sizeof(SerialApp_Buf));
#endif
}
break;
case GAPROLE_ADVERTISING:
{
HalLedSet ( HAL_LED_1, HAL_LED_MODE_ON );
UartCommand = 2;
#ifdef UARTDEBUG
memset(SerialApp_Buf,0,sizeof(SerialApp_Buf));
strcpy(SerialApp_Buf,"Advertising\n");
HalUARTWrite(USE_UART_PORT, SerialApp_Buf,sizeof("Advertising\n"));
#endif
}
break;
case GAPROLE_CONNECTED:
{
HalLedSet ( HAL_LED_1, HAL_LED_MODE_FLASH ); //LED1间隔闪烁
#ifdef UARTDEBUG
memset(SerialApp_Buf,0,sizeof(SerialApp_Buf));
strcpy(SerialApp_Buf,"Connected\n");
HalUARTWrite(USE_UART_PORT, SerialApp_Buf,sizeof("Connected\n"));
#endif
ADS1194_StartReadDataContinuous();
}
break;
case GAPROLE_WAITING:
{
HalLedSet ( HAL_LED_1, HAL_LED_MODE_ON ); //
uint8 once_advertising_enable = TRUE;
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &once_advertising_enable ); //重新发送Advertising，断开之后的重连
#ifdef UARTDEBUG
memset(SerialApp_Buf,0,sizeof(SerialApp_Buf));
strcpy(SerialApp_Buf,"Disconnected\n");
HalUARTWrite(USE_UART_PORT, SerialApp_Buf,sizeof(SerialApp_Buf));
#endif
}
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
{
HalLedSet ( HAL_LED_1, HAL_LED_MODE_ON );
#ifdef UARTDEBUG
memset(SerialApp_Buf,0,sizeof(SerialApp_Buf));
strcpy(SerialApp_Buf,"Timed Out\n");
HalUARTWrite(USE_UART_PORT, SerialApp_Buf,sizeof(SerialApp_Buf));
#endif
uint8 once_advertising_enable = TRUE;
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &once_advertising_enable ); //重新发送Advertising，断开之后的重连
#ifdef UARTDEBUG
memset(SerialApp_Buf,0,sizeof(SerialApp_Buf));
strcpy(SerialApp_Buf,"Try connect again\n");
HalUARTWrite(USE_UART_PORT, SerialApp_Buf,sizeof(SerialApp_Buf));
#endif
}
break;
case GAPROLE_ERROR:
{
#ifdef UARTDEBUG
memset(SerialApp_Buf,0,sizeof(SerialApp_Buf));
strcpy(SerialApp_Buf,"Error\n");
HalUARTWrite(USE_UART_PORT, SerialApp_Buf,sizeof(SerialApp_Buf));
#endif
uint8 once_advertising_enable = TRUE;
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &once_advertising_enable ); //重新发送Advertising，断开之后的重连
}
break;
default:
{
#ifdef UARTDEBUG
memset(SerialApp_Buf,0,sizeof(SerialApp_Buf));
strcpy(SerialApp_Buf,"Hellowin\n");
HalUARTWrite(USE_UART_PORT, SerialApp_Buf,sizeof(SerialApp_Buf));
#endif
}
break;
}
gapProfileState = newState;
#if !defined( CC2540_ECG )
VOID gapProfileState; // added to prevent compiler warning with
// "CC2540 Slave" configurations
#endif
}
/*********************************************************************
* @fn SensorGapStateCB
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void SensorGapStateCB( gaprole_States_t newState )
{
// if connected
if (newState == GAPROLE_CONNECTED)
{
// get connection handle
GAPRole_GetParameter(GAPROLE_CONNHANDLE, &gapConnHandle);
// Set timer to update connection parameters
// 5 seconds should allow enough time for Service Discovery by the collector to finish
osal_start_timerEx( sensor_TaskID, RSC_CONN_PARAM_UPDATE_EVT, SVC_DISC_DELAY);
}
// if disconnected
else if (gapProfileState == GAPROLE_CONNECTED &&
newState != GAPROLE_CONNECTED)
{
uint8 advState = TRUE;
uint8 bondCount = 0;
// stop periodic measurement
osal_stop_timerEx( sensor_TaskID, RSC_PERIODIC_EVT );
// reset client characteristic configuration descriptors
Running_HandleConnStatusCB( gapConnHandle, LINKDB_STATUS_UPDATE_REMOVED );
//Batt_HandleConnStatusCB( gapConnHandle, LINKDB_STATUS_UPDATE_REMOVED );
// If not already using white list, begin to do so.
GAPBondMgr_GetParameter( GAPBOND_BOND_COUNT, &bondCount );
if(USING_WHITE_LIST && sensorUsingWhiteList == FALSE && bondCount > 0 )
{
uint8 value = GAP_FILTER_POLICY_WHITE;
GAPRole_SetParameter(GAPROLE_ADV_FILTER_POLICY, sizeof( uint8 ), &value);
sensorUsingWhiteList = TRUE;
}
if ( newState == GAPROLE_WAITING_AFTER_TIMEOUT )
{
// link loss timeout-- use fast advertising
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_WHITE_LIST_ADV_DURATION );
}
else
{
// Else use slow advertising
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_MIN, DEFAULT_WHITE_LIST_ADV_DURATION );
}
// Enable advertising
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advState );
}
// if advertising stopped
else if ( gapProfileState == GAPROLE_ADVERTISING &&
newState == GAPROLE_WAITING )
{
uint8 whiteListUsed = FALSE;
// if white list is in use, disable to allow general access
if ( sensorUsingWhiteList == TRUE )
{
uint8 value = GAP_FILTER_POLICY_ALL;
GAPRole_SetParameter(GAPROLE_ADV_FILTER_POLICY, sizeof( uint8), &value);
whiteListUsed = TRUE;
sensorUsingWhiteList = FALSE;
}
// if advertising stopped by user
if ( sensorAdvCancelled )
{
sensorAdvCancelled = FALSE;
}
// if fast advertising interrupted to cancel white list
else if ( ( (!USING_WHITE_LIST) || whiteListUsed) &&
(GAP_GetParamValue( TGAP_GEN_DISC_ADV_INT_MIN ) == DEFAULT_FAST_ADV_INTERVAL ) )
{
uint8 advState = TRUE;
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 );
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advState );
}
// if fast advertising switch to slow or if was already slow but using white list.
else if ( ((!USING_WHITE_LIST) || whiteListUsed) ||
(GAP_GetParamValue( TGAP_GEN_DISC_ADV_INT_MIN ) == DEFAULT_FAST_ADV_INTERVAL) )
{
uint8 advState = TRUE;
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL );
GAP_SetParamValue( TGAP_GEN_DISC_ADV_MIN, DEFAULT_SLOW_ADV_DURATION );
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advState );
}
}
// if started
else if (newState == GAPROLE_STARTED)
{
// Set the system ID from the bd addr
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, systemId);
// shift three bytes up
systemId[7] = systemId[5];
systemId[6] = systemId[4];
systemId[5] = systemId[3];
// set middle bytes to zero
systemId[4] = 0;
systemId[3] = 0;
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
}
gapProfileState = newState;
}
/*********************************************************************
* @fn HeartRate_stateChangeEvt
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void HeartRate_stateChangeEvt(gaprole_States_t newState)
{
// If no change to the GAP Role state has occurred
if (gapProfileState == newState)
{
return;
}
// If connected
if (newState == GAPROLE_CONNECTED)
{
// Get connection handle.
GAPRole_GetParameter(GAPROLE_CONNHANDLE, &gapConnHandle);
}
// If disconnected
else if (gapProfileState == GAPROLE_CONNECTED &&
newState != GAPROLE_CONNECTED)
{
// Stop periodic measurement of heart rate.
Util_stopClock(&measPerClock);
if (newState == GAPROLE_WAITING_AFTER_TIMEOUT)
{
// Link loss timeout-- use fast advertising
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);
}
else
{
// Else use slow advertising
GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL);
GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL);
GAP_SetParamValue(TGAP_GEN_DISC_ADV_MIN, DEFAULT_SLOW_ADV_DURATION);
}
// Enable advertising.
HeartRate_toggleAdvertising();
}
// If advertising stopped
else if (gapProfileState == GAPROLE_ADVERTISING &&
newState == GAPROLE_WAITING)
{
// If advertising stopped by user
if (advCancelled)
{
// Disable advertising.
advCancelled = FALSE;
}
// Else if fast advertising switch to slow
else if (GAP_GetParamValue(TGAP_GEN_DISC_ADV_INT_MIN) == DEFAULT_FAST_ADV_INTERVAL)
{
GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL);
GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL);
GAP_SetParamValue(TGAP_GEN_DISC_ADV_MIN, DEFAULT_SLOW_ADV_DURATION);
// Enable advertising.
HeartRate_toggleAdvertising();
}
#if ADVERTISE_WHEN_NOT_CONNECTED
else
{
// Test mode: continue advertising.
HeartRate_toggleAdvertising();
}
#endif //ADVERTISE_WHEN_NOT_CONNECTED
}
#if ADVERTISE_WHEN_NOT_CONNECTED
else if (newState == GAPROLE_WAITING_AFTER_TIMEOUT)
{
// Test mode: continue advertising.
HeartRate_toggleAdvertising();
}
#endif //ADVERTISE_WHEN_NOT_CONNECTED
// If started
else if (newState == GAPROLE_STARTED)
{
// Set the system ID from the bd addr.
uint8_t systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, systemId);
// Shift three bytes up.
systemId[7] = systemId[5];
systemId[6] = systemId[4];
systemId[5] = systemId[3];
// Set middle bytes to zero.
systemId[4] = 0;
systemId[3] = 0;
// Pass systemId to the Device Info service.
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
}
// Update GAP profile state.
gapProfileState = newState;
}
/*********************************************************************
* @fn peripheralStateNotificationCB
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void peripheralStateNotificationCB( gaprole_States_t newState )
{
switch ( newState )
{
case GAPROLE_STARTED:
{
uint8 ownAddress[B_ADDR_LEN];
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
// Display device address
HalLcdWriteString( bdAddr2Str( ownAddress ), HAL_LCD_LINE_2 );
HalLcdWriteString( "Initialized", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
case GAPROLE_ADVERTISING:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Advertising", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLedSet( HAL_LED_2, HAL_LED_MODE_ON );
}
break;
case GAPROLE_CONNECTED:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Connected", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLedSet( HAL_LED_2, HAL_LED_MODE_OFF );
}
break;
case GAPROLE_WAITING:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Disconnected", HAL_LCD_LINE_3 );
P0_7=0;
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Timed Out", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
case GAPROLE_ERROR:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "Error", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
default:
{
#if (defined HAL_LCD) && (HAL_LCD == TRUE)
HalLcdWriteString( "", HAL_LCD_LINE_3 );
#endif // (defined HAL_LCD) && (HAL_LCD == TRUE)
}
break;
}
gapProfileState = newState;
#if !defined( CC2540_MINIDK )
VOID gapProfileState; // added to prevent compiler warning with
// "CC2540 Slave" configurations
#endif
}
/**
* @fn pperipheral_StateNotification
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void pperipheral_StateNotification(gaprole_States_t newState)
{
switch (newState) {
case GAPROLE_STARTED:
{
uint8 ownAddress[B_ADDR_LEN];
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
btmsg(("\033[1;34m{started}\033[0m - %02x:%02x:%02x:%02x:%02x:%02x\n",
ownAddress[0], ownAddress[1], ownAddress[2], ownAddress[3], ownAddress[4], ownAddress[5]));
}
break;
case GAPROLE_ADVERTISING:
btmsg(("\033[1;34m{advertising}\033[0m\n"));
break;
case GAPROLE_CONNECTED:
btmsg(("\033[1;34m{connected}\033[0m\n"));
break;
case GAPROLE_WAITING:
btmsg(("\033[1;34m{waiting}\033[0m\n"));
break;
case GAPROLE_CONNECTED_ADV:
btmsg(("\033[1;34m{connected adv.}\033[0m\n"));
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
btmsg(("\033[1;34m{timeout}\033[0m\n"));
break;
case GAPROLE_ERROR:
btmsg(("\033[1;34m{error}\033[0m\n"));
break;
default:
case GAPROLE_INIT:
btmsg(("\033[1;34m{init}\033[0m\n"));
break;
}
gapProfileState = newState;
}
/*********************************************************************
* @fn peripheralStateNotificationCB
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void peripheralStateNotificationCB( gaprole_States_t newState )
{
switch ( newState )
{
case GAPROLE_STARTED:
{
uint8 ownAddress[B_ADDR_LEN];
uint8 systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
}
break;
case GAPROLE_ADVERTISING:
{
}
break;
case GAPROLE_CONNECTED:
{
}
break;
case GAPROLE_CONNECTED_ADV:
{
}
break;
case GAPROLE_WAITING:
{
}
break;
case GAPROLE_WAITING_AFTER_TIMEOUT:
{
}
break;
case GAPROLE_ERROR:
{
}
break;
default:
{
}
break;
}
gapProfileState = newState;
}
/*********************************************************************
* @fn RunningSensor_processStateChangeEvt
*
* @brief Notification from the profile of a state change.
*
* @param newState - new state
*
* @return none
*/
static void RunningSensor_processStateChangeEvt(gaprole_States_t newState)
{
// If connected
if (newState == GAPROLE_CONNECTED)
{
// Get the connection handle.
GAPRole_GetParameter(GAPROLE_CONNHANDLE, &gapConnHandle);
// Begin delay for service discovery.
Util_startClock(¶mUpdateClock);
}
// If disconnected
else if (gapProfileState == GAPROLE_CONNECTED &&
newState != GAPROLE_CONNECTED)
{
uint8_t advState = TRUE;
uint8_t bondCount = 0;
// Stop periodic measurement.
Util_stopClock(&periodicClock);
// Get the bond count.
GAPBondMgr_GetParameter(GAPBOND_BOND_COUNT, &bondCount);
// If enabled and previously bonded, turn on white list if not already done.
if(USING_WHITE_LIST && sensorUsingWhiteList == FALSE && bondCount > 0)
{
uint8_t value = GAP_FILTER_POLICY_WHITE;
GAPRole_SetParameter(GAPROLE_ADV_FILTER_POLICY, sizeof(uint8_t), &value);
sensorUsingWhiteList = TRUE;
}
// If waiting after a connection timeout
if (newState == GAPROLE_WAITING_AFTER_TIMEOUT)
{
// Link loss timeout-- use fast advertising.
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_WHITE_LIST_ADV_DURATION);
}
else
{
// Use slow advertising.
GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL);
GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL);
GAP_SetParamValue(TGAP_GEN_DISC_ADV_MIN, DEFAULT_WHITE_LIST_ADV_DURATION);
}
// Enable advertising.
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &advState);
}
// If advertising stopped
else if (gapProfileState == GAPROLE_ADVERTISING &&
newState == GAPROLE_WAITING)
{
uint8_t whiteListUsed = FALSE;
// If white list is in use, turn off white list filtering to allow general
// access.
if (sensorUsingWhiteList == TRUE)
{
uint8_t value = GAP_FILTER_POLICY_ALL;
GAPRole_SetParameter(GAPROLE_ADV_FILTER_POLICY, sizeof(uint8_t), &value);
whiteListUsed = TRUE;
sensorUsingWhiteList = FALSE;
}
// If advertising stopped by user
if (sensorAdvCancelled)
{
sensorAdvCancelled = FALSE;
}
// If fast advertising was interrupted to cancel white list
else if (((!USING_WHITE_LIST) || whiteListUsed) &&
(GAP_GetParamValue(TGAP_GEN_DISC_ADV_INT_MIN) == DEFAULT_FAST_ADV_INTERVAL))
{
uint8_t advState = TRUE;
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);
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &advState);
}
// If fast advertising or was using white list switch to slow advertising.
else if (((!USING_WHITE_LIST) || whiteListUsed) ||
(GAP_GetParamValue(TGAP_GEN_DISC_ADV_INT_MIN) == DEFAULT_FAST_ADV_INTERVAL))
{
uint8_t advState = TRUE;
GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MIN, DEFAULT_SLOW_ADV_INTERVAL);
GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MAX, DEFAULT_SLOW_ADV_INTERVAL);
GAP_SetParamValue(TGAP_GEN_DISC_ADV_MIN, DEFAULT_SLOW_ADV_DURATION);
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &advState);
}
}
// If started
else if (newState == GAPROLE_STARTED)
{
// Set the system ID from the bd addr.
uint8_t systemId[DEVINFO_SYSTEM_ID_LEN];
GAPRole_GetParameter(GAPROLE_BD_ADDR, systemId);
// Shift three bytes up.
systemId[7] = systemId[5];
systemId[6] = systemId[4];
systemId[5] = systemId[3];
// Set middle bytes to zero.
systemId[4] = 0;
systemId[3] = 0;
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
}
// Update state.
gapProfileState = newState;
}