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; }