/******************************************************************************* * @fn AssertHandler * * @brief This is the Application's callback handler for asserts raised * in the stack. * * input parameters * * @param assertCause - Assert cause as defined in hal_assert.h. * @param assertSubcause - Optional assert subcause (see hal_assert.h). * * output parameters * * @param None. * * @return None. */ void AssertHandler(uint8 assertCause, uint8 assertSubcause) { // Open the display if the app has not already done so if ( !dispHandle ) { dispHandle = Display_open(Display_Type_LCD, NULL); } Display_print0(dispHandle, 0, 0, ">>>STACK ASSERT"); // check the assert cause switch (assertCause) { case HAL_ASSERT_CAUSE_OUT_OF_MEMORY: Display_print0(dispHandle, 0, 0, "***ERROR***"); Display_print0(dispHandle, 2, 0, ">> OUT OF MEMORY!"); break; case HAL_ASSERT_CAUSE_INTERNAL_ERROR: // check the subcause if (assertSubcause == HAL_ASSERT_SUBCAUSE_FW_INERNAL_ERROR) { Display_print0(dispHandle, 0, 0, "***ERROR***"); Display_print0(dispHandle, 2, 0, ">> INTERNAL FW ERROR!"); } else { Display_print0(dispHandle, 0, 0, "***ERROR***"); Display_print0(dispHandle, 2, 0, ">> INTERNAL ERROR!"); } break; case HAL_ASSERT_CAUSE_ICALL_ABORT: Display_print0(dispHandle, 0, 0, "***ERROR***"); Display_print0(dispHandle, 2, 0, ">> ICALL ABORT!"); HAL_ASSERT_SPINLOCK; break; default: Display_print0(dispHandle, 0, 0, "***ERROR***"); Display_print0(dispHandle, 2, 0, ">> DEFAULT SPINLOCK!"); HAL_ASSERT_SPINLOCK; } return; }
/********************************************************************* * @fn SensorTagDisplay_init * * @brief Initialization function for the SensorTag Display * */ void SensorTagDisplay_init(void) { uint8_t config[DISPLAY_CONF_LEN]; // Add service Display_addService(); Display_registerAppCBs(&sensorTag_displayCBs); // Initialize the service config[DISPLAY_CMD_OFFSET] = DISPLAY_CONF_MOV; config[DISPLAY_LINE_OFFSET] = DISPLAY_LINE_DEFAULT; config[DISPLAY_COL_OFFSET] = 1; Display_setParameter(DISPLAY_CONF, sizeof(config), config); // Store active "cursor" position pos.line = config[DISPLAY_LINE_OFFSET]; pos.column = config[DISPLAY_COL_OFFSET]; // Initialize LCD Display_Params params; Display_Params_init(¶ms); params.lineClearMode = DISPLAY_CLEAR_NONE; handle = Display_open(Display_Type_LCD, ¶ms); }
/********************************************************************* * @fn SensorTagDisplay_processCharChangeEvt * * @brief Process a change in the IO characteristics * * @return none */ void SensorTagDisplay_processCharChangeEvt(uint8_t paramID) { if (paramID == DISPLAY_CONF) { uint8_t config[DISPLAY_CONF_LEN]; Display_getParameter(DISPLAY_CONF, config); // Execute the control sequence switch (config[DISPLAY_CMD_OFFSET]) { case DISPLAY_CONF_OFF: if (handle != NULL) { // NB! Has no effect on SensorTag because LCD_ENABLE pin is // shared with UART_TX, causing the LCD to get enabled again // as soon as the PINs used by the LCD are released. Display_clear(handle); Display_print0(handle, DISPLAY_LINE_DEFAULT, 2, "Display off"); Display_close(handle); handle = NULL; } break; case DISPLAY_CONF_ON: // Initialize LCD if (handle == NULL) { Display_Params params; Display_Params_init(¶ms); params.lineClearMode = DISPLAY_CLEAR_NONE; handle = Display_open(Display_Type_LCD, ¶ms); // Update status SensorTagDisplay_showStatus(); } break; case DISPLAY_CONF_CLR: // Clear display if (handle != NULL) { Display_clear(handle); } break; case DISPLAY_CONF_CLR_LINE: // Clear line pos.line = config[DISPLAY_LINE_OFFSET]; if (handle != NULL) { Display_clearLines(handle, pos.line, pos.line); } break; case DISPLAY_CONF_INV: if (handle != NULL) { uint8_t tmp; // Swap foreground and background colors tmp = color.fg; color.fg = color.bg; color.bg = tmp; Display_control(handle, DISPLAYSHARP_CMD_SET_COLORS, &color); // Update status SensorTagDisplay_showStatus(); } break; case DISPLAY_CONF_MOV: // Store active "cursor" position pos.line = config[DISPLAY_LINE_OFFSET]; pos.column = config[DISPLAY_COL_OFFSET]; break; default: break; } } if (paramID == DISPLAY_DATA && handle != NULL) { uint8_t data[DISPLAY_BUFFER_LEN]; Display_getParameter(DISPLAY_DATA, data); Display_print0(handle, pos.line, pos.column, (const char*)data); } }
static void SimplePropBeacon_init(void) { // ****************************************************************** // N0 STACK API CALLS CAN OCCUR BEFORE THIS CALL TO ICall_registerApp // ****************************************************************** // Register the current thread as an ICall dispatcher application // so that the application can send and receive messages. ICall_registerApp(&selfEntity, &sem); #ifdef USE_RCOSC RCOSC_enableCalibration(); #endif // USE_RCOSC // Create an RTOS queue for message from profile to be sent to app. appMsgQueue = Util_constructQueue(&appMsg); dispHandle = Display_open(Display_Type_LCD, NULL); // Setup the GAP GAP_SetParamValue(TGAP_CONN_PAUSE_PERIPHERAL, DEFAULT_CONN_PAUSE_PERIPHERAL); // Setup the GAP Peripheral Role Profile { uint8_t initialAdvertEnable = TRUE; uint8_t initialNonConnAdvEnable = TRUE; // By setting this to zero, the device will go into the waiting state after // being discoverable for 30.72 second, and will not being advertising again // until the enabler is set back to TRUE uint16_t advertOffTime = 0; uint8_t enableUpdateRequest = DEFAULT_ENABLE_UPDATE_REQUEST; uint16_t desiredMinInterval = DEFAULT_DESIRED_MIN_CONN_INTERVAL; uint16_t desiredMaxInterval = DEFAULT_DESIRED_MAX_CONN_INTERVAL; uint16_t desiredSlaveLatency = DEFAULT_DESIRED_SLAVE_LATENCY; uint16_t desiredConnTimeout = DEFAULT_DESIRED_CONN_TIMEOUT; // Set the GAP Role Parameters GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &initialAdvertEnable); GAPRole_SetParameter(GAPROLE_ADV_NONCONN_ENABLED, sizeof(uint8_t), &initialNonConnAdvEnable); GAPRole_SetParameter(GAPROLE_ADVERT_OFF_TIME, sizeof(uint16_t), &advertOffTime); GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanRspData), scanRspData); GAPRole_SetParameter(GAPROLE_PARAM_UPDATE_ENABLE, sizeof(uint8_t), &enableUpdateRequest); GAPRole_SetParameter(GAPROLE_MIN_CONN_INTERVAL, sizeof(uint16_t), &desiredMinInterval); GAPRole_SetParameter(GAPROLE_MAX_CONN_INTERVAL, sizeof(uint16_t), &desiredMaxInterval); GAPRole_SetParameter(GAPROLE_SLAVE_LATENCY, sizeof(uint16_t), &desiredSlaveLatency); GAPRole_SetParameter(GAPROLE_TIMEOUT_MULTIPLIER, sizeof(uint16_t), &desiredConnTimeout); } // Set the GAP Characteristics GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName); // Register an event for adv completion HCI_EXT_AdvEventNoticeCmd(selfEntity, SPB_ADV_COMPLETE_EVT); // Setup the GAP Bond Manager { uint32_t passkey = 0; // passkey "000000" uint8_t pairMode = GAPBOND_PAIRING_MODE_WAIT_FOR_REQ; uint8_t mitm = TRUE; uint8_t ioCap = GAPBOND_IO_CAP_DISPLAY_ONLY; uint8_t bonding = TRUE; GAPBondMgr_SetParameter(GAPBOND_DEFAULT_PASSCODE, sizeof(uint32_t), &passkey); GAPBondMgr_SetParameter(GAPBOND_PAIRING_MODE, sizeof(uint8_t), &pairMode); GAPBondMgr_SetParameter(GAPBOND_MITM_PROTECTION, sizeof(uint8_t), &mitm); GAPBondMgr_SetParameter(GAPBOND_IO_CAPABILITIES, sizeof(uint8_t), &ioCap); GAPBondMgr_SetParameter(GAPBOND_BONDING_ENABLED, sizeof(uint8_t), &bonding); } // Initialize GATT attributes GGS_AddService(GATT_ALL_SERVICES); // GAP GATTServApp_AddService(GATT_ALL_SERVICES); // GATT attributes DevInfo_AddService(); // Device Information Service // Start the Device VOID GAPRole_StartDevice(&SimplePropBeacon_gapRoleCBs); // Start Bond Manager VOID GAPBondMgr_Register(&SimplePropBeacon_BondMgrCBs); // Register with GAP for HCI/Host messages GAP_RegisterForMsgs(selfEntity); // Register for GATT local events and ATT Responses pending for transmission GATT_RegisterForMsgs(selfEntity); }
/********************************************************************* * @fn DualImageConcept_init * * @brief Called during initialization and contains application * specific initialization (ie. hardware initialization/setup, * table initialization, power up notification, etc), and * profile initialization/setup. * * @param None. * * @return None. */ static void DualImageConcept_init(void) { // For CC1350LP Set DIO1 High for 2.4 GHz Radio usage. // Set DIO30 High to power radio. // ****************************************************************** // N0 STACK API CALLS CAN OCCUR BEFORE THIS CALL TO ICall_registerApp // ****************************************************************** // Register the current thread as an ICall dispatcher application // so that the application can send and receive messages. ICall_registerApp(&selfEntity, &sem); // Hard code the BD Address till CC2650 board gets its own IEEE address uint8 bdAddress[B_ADDR_LEN] = { 0x1C, 0xCD, 0xD1, 0x1C, 0xCD, 0xD1 }; HCI_EXT_SetBDADDRCmd(bdAddress); // Set device's Sleep Clock Accuracy //HCI_EXT_SetSCACmd(40); // Create an RTOS queue for message from profile to be sent to app. appMsgQueue = Util_constructQueue(&appMsg); Board_initKeys(DualImageConcept_keyChangeHandler); dispHandle = Display_open(Display_Type_LCD, NULL); // Setup the GAP GAP_SetParamValue(TGAP_CONN_PAUSE_PERIPHERAL, DEFAULT_CONN_PAUSE_PERIPHERAL); // Setup the GAP Peripheral Role Profile { // For all hardware platforms, device starts advertising upon initialization uint8_t initialAdvertEnable = TRUE; // By setting this to zero, the device will go into the waiting state after // being discoverable for 30.72 second, and will not being advertising again // until the enabler is set back to TRUE uint16_t advertOffTime = 0; uint8_t enableUpdateRequest = DEFAULT_ENABLE_UPDATE_REQUEST; uint16_t desiredMinInterval = DEFAULT_DESIRED_MIN_CONN_INTERVAL; uint16_t desiredMaxInterval = DEFAULT_DESIRED_MAX_CONN_INTERVAL; uint16_t desiredSlaveLatency = DEFAULT_DESIRED_SLAVE_LATENCY; uint16_t desiredConnTimeout = DEFAULT_DESIRED_CONN_TIMEOUT; // Set the GAP Role Parameters GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &initialAdvertEnable); GAPRole_SetParameter(GAPROLE_ADVERT_OFF_TIME, sizeof(uint16_t), &advertOffTime); GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanRspData), scanRspData); GAPRole_SetParameter(GAPROLE_ADVERT_DATA, sizeof(advertData), advertData); GAPRole_SetParameter(GAPROLE_PARAM_UPDATE_ENABLE, sizeof(uint8_t), &enableUpdateRequest); GAPRole_SetParameter(GAPROLE_MIN_CONN_INTERVAL, sizeof(uint16_t), &desiredMinInterval); GAPRole_SetParameter(GAPROLE_MAX_CONN_INTERVAL, sizeof(uint16_t), &desiredMaxInterval); GAPRole_SetParameter(GAPROLE_SLAVE_LATENCY, sizeof(uint16_t), &desiredSlaveLatency); GAPRole_SetParameter(GAPROLE_TIMEOUT_MULTIPLIER, sizeof(uint16_t), &desiredConnTimeout); } // Set the GAP Characteristics GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName); // Set advertising interval { uint16_t advInt = DEFAULT_ADVERTISING_INTERVAL; GAP_SetParamValue(TGAP_LIM_DISC_ADV_INT_MIN, advInt); GAP_SetParamValue(TGAP_LIM_DISC_ADV_INT_MAX, advInt); GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MIN, advInt); GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MAX, advInt); } // Initialize GATT attributes GGS_AddService(GATT_ALL_SERVICES); // GAP GATTServApp_AddService(GATT_ALL_SERVICES); // GATT attributes // Start the Device VOID GAPRole_StartDevice(&DualImageConcept_gapRoleCBs); Display_print0(dispHandle, 0, 0, "CC1350 BLE Image A"); // Check for shared data osal_snv_read(0x80, sizeof(uint8_t), &sharedData); // Write the shared data to the LCD. Display_print1(dispHandle, 6, 0, "Shared Data: %d", sharedData); }
/********************************************************************* * @fn SimpleBLEPeripheral_init * * @brief Called during initialization and contains application * specific initialization (ie. hardware initialization/setup, * table initialization, power up notification, etc), and * profile initialization/setup. * * @param None. * * @return None. */ static void SimpleBLEPeripheral_init(void) { // ****************************************************************** // N0 STACK API CALLS CAN OCCUR BEFORE THIS CALL TO ICall_registerApp // ****************************************************************** // Register the current thread as an ICall dispatcher application // so that the application can send and receive messages. ICall_registerApp(&selfEntity, &sem); #ifdef USE_RCOSC RCOSC_enableCalibration(); #endif // USE_RCOSC // Create an RTOS queue for message from profile to be sent to app. appMsgQueue = Util_constructQueue(&appMsg); // Create one-shot clocks for internal periodic events. Util_constructClock(&periodicClock, SimpleBLEPeripheral_clockHandler, SBP_PERIODIC_EVT_PERIOD, 0, false, SBP_PERIODIC_EVT); #ifdef PLUS_OBSERVER Board_initKeys(SimpleBLEPeripheral_keyChangeHandler); #endif dispHandle = Display_open(Display_Type_UART, NULL); //ZH change to UART for LP UART support #ifdef PLUS_OBSERVER //Setup GAP Observer params { uint8_t scanRes = DEFAULT_MAX_SCAN_RES; GAPRole_SetParameter(GAPROLE_MAX_SCAN_RES, sizeof(uint8_t), &scanRes); // Set the GAP Characteristics GAP_SetParamValue(TGAP_GEN_DISC_SCAN, DEFAULT_SCAN_DURATION); //how long to scan (in scan state) GAP_SetParamValue(TGAP_LIM_DISC_SCAN, DEFAULT_SCAN_DURATION); //Set scan interval GAP_SetParamValue(TGAP_GEN_DISC_SCAN_INT, (DEFAULT_SCAN_INTERVAL)/(0.625)); //period for one scan channel //Set scan window GAP_SetParamValue(TGAP_GEN_DISC_SCAN_WIND, (DEFAULT_SCAN_WINDOW)/(0.625)); //active scanning time within scan interval } #endif // Setup the GAP GAP_SetParamValue(TGAP_CONN_PAUSE_PERIPHERAL, DEFAULT_CONN_PAUSE_PERIPHERAL); // Setup the GAP Peripheral Role Profile { // For all hardware platforms, device starts advertising upon initialization uint8_t initialAdvertEnable = TRUE; // By setting this to zero, the device will go into the waiting state after // being discoverable for 30.72 second, and will not being advertising again // until the enabler is set back to TRUE uint16_t advertOffTime = 0; uint8_t enableUpdateRequest = DEFAULT_ENABLE_UPDATE_REQUEST; uint16_t desiredMinInterval = DEFAULT_DESIRED_MIN_CONN_INTERVAL; uint16_t desiredMaxInterval = DEFAULT_DESIRED_MAX_CONN_INTERVAL; uint16_t desiredSlaveLatency = DEFAULT_DESIRED_SLAVE_LATENCY; uint16_t desiredConnTimeout = DEFAULT_DESIRED_CONN_TIMEOUT; // Set the GAP Role Parameters GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &initialAdvertEnable); GAPRole_SetParameter(GAPROLE_ADVERT_OFF_TIME, sizeof(uint16_t), &advertOffTime); GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanRspData), scanRspData); GAPRole_SetParameter(GAPROLE_ADVERT_DATA, sizeof(advertData), advertData); GAPRole_SetParameter(GAPROLE_PARAM_UPDATE_ENABLE, sizeof(uint8_t), &enableUpdateRequest); GAPRole_SetParameter(GAPROLE_MIN_CONN_INTERVAL, sizeof(uint16_t), &desiredMinInterval); GAPRole_SetParameter(GAPROLE_MAX_CONN_INTERVAL, sizeof(uint16_t), &desiredMaxInterval); GAPRole_SetParameter(GAPROLE_SLAVE_LATENCY, sizeof(uint16_t), &desiredSlaveLatency); GAPRole_SetParameter(GAPROLE_TIMEOUT_MULTIPLIER, sizeof(uint16_t), &desiredConnTimeout); } // Set the GAP Characteristics GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName); // Set advertising interval { uint16_t advInt = DEFAULT_ADVERTISING_INTERVAL; GAP_SetParamValue(TGAP_LIM_DISC_ADV_INT_MIN, advInt); GAP_SetParamValue(TGAP_LIM_DISC_ADV_INT_MAX, advInt); GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MIN, advInt); GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MAX, advInt); } // Setup the GAP Bond Manager { uint32_t passkey = 0; // passkey "000000" uint8_t pairMode = GAPBOND_PAIRING_MODE_WAIT_FOR_REQ; uint8_t mitm = TRUE; uint8_t ioCap = GAPBOND_IO_CAP_DISPLAY_ONLY; uint8_t bonding = TRUE; GAPBondMgr_SetParameter(GAPBOND_DEFAULT_PASSCODE, sizeof(uint32_t), &passkey); GAPBondMgr_SetParameter(GAPBOND_PAIRING_MODE, sizeof(uint8_t), &pairMode); GAPBondMgr_SetParameter(GAPBOND_MITM_PROTECTION, sizeof(uint8_t), &mitm); GAPBondMgr_SetParameter(GAPBOND_IO_CAPABILITIES, sizeof(uint8_t), &ioCap); GAPBondMgr_SetParameter(GAPBOND_BONDING_ENABLED, sizeof(uint8_t), &bonding); } // Initialize GATT attributes GGS_AddService(GATT_ALL_SERVICES); // GAP GATTServApp_AddService(GATT_ALL_SERVICES); // GATT attributes DevInfo_AddService(); // Device Information Service #ifndef FEATURE_OAD_ONCHIP SimpleProfile_AddService(GATT_ALL_SERVICES); // Simple GATT Profile #endif //!FEATURE_OAD_ONCHIP #ifdef FEATURE_OAD VOID OAD_addService(); // OAD Profile OAD_register((oadTargetCBs_t *)&simpleBLEPeripheral_oadCBs); hOadQ = Util_constructQueue(&oadQ); #endif //FEATURE_OAD #ifdef IMAGE_INVALIDATE Reset_addService(); #endif //IMAGE_INVALIDATE #ifndef FEATURE_OAD_ONCHIP // Setup the SimpleProfile Characteristic Values { uint8_t charValue1 = 1; uint8_t charValue2 = 2; uint8_t charValue3 = 3; uint8_t charValue4 = 4; uint8_t charValue5[SIMPLEPROFILE_CHAR5_LEN] = { 1, 2, 3, 4, 5 }; SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR1, sizeof(uint8_t), &charValue1); SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR2, sizeof(uint8_t), &charValue2); SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR3, sizeof(uint8_t), &charValue3); SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR4, sizeof(uint8_t), &charValue4); SimpleProfile_SetParameter(SIMPLEPROFILE_CHAR5, SIMPLEPROFILE_CHAR5_LEN, charValue5); } // Register callback with SimpleGATTprofile SimpleProfile_RegisterAppCBs(&SimpleBLEPeripheral_simpleProfileCBs); #endif //!FEATURE_OAD_ONCHIP // Start the Device VOID GAPRole_StartDevice(&SimpleBLEPeripheral_gapRoleCBs); // Start Bond Manager VOID GAPBondMgr_Register(&simpleBLEPeripheral_BondMgrCBs); // Register with GAP for HCI/Host messages GAP_RegisterForMsgs(selfEntity); // Register for GATT local events and ATT Responses pending for transmission GATT_RegisterForMsgs(selfEntity); HCI_LE_ReadMaxDataLenCmd(); #if defined FEATURE_OAD #if defined (HAL_IMAGE_A) Display_print0(dispHandle, 0, 0, "BLE Peripheral A"); #else Display_print0(dispHandle, 0, 0, "BLE Peripheral B"); #endif // HAL_IMAGE_A #else #ifdef PLUS_OBSERVER Display_print0(dispHandle, 0, 0, "BLE Peripheral Observer"); #else Display_print0(dispHandle, 0, 0, "BLE Peripheral"); #endif #endif // FEATURE_OAD }