uint16 FanProcessEvent(uint8 taskId, uint16 events)
{
if (events & SYS_EVENT_MSG)
{
uint8* message = NULL;
if ((message = osal_msg_receive(fanTaskId)) != NULL)
{
FanProcessOSALMessage((osal_event_hdr_t*)message);
osal_msg_deallocate(message);
}
return (events ^ SYS_EVENT_MSG);
}
if (events & FAN_START_DEVICE_EVT)
{
GAPRole_StartDevice(&fanPeripheralCallBacks);
GAPBondMgr_Register(&fanBondManagerCallBacks);
return (events ^ FAN_START_DEVICE_EVT);
}
if (events & FAN_UPDATE_STATUS_EVT)
{
FanUpdateStatus();
return (events ^ FAN_UPDATE_STATUS_EVT);
}
return 0;
};
/*********************************************************************
* @fn SimpleBLEBroadcaster_ProcessEvent
*
* @brief Simple BLE Broadcaster Application Task event processor. This
* function is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SimpleBLEBroadcaster_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( simpleBLEBroadcaster_TaskID )) != NULL )
{
simpleBLEBroadcaster_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &simpleBLEBroadcaster_BroadcasterCBs );
return ( events ^ SBP_START_DEVICE_EVT );
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn TimeApp_ProcessEvent
*
* @brief Time App Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 TimeApp_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( timeAppTaskId )) != NULL )
{
timeApp_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return ( events ^ SYS_EVENT_MSG );
}
if ( events & START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &timeAppPeripheralCB );
// Register with bond manager after starting device
GAPBondMgr_Register( (gapBondCBs_t *) &timeAppBondCB );
return ( events ^ START_DEVICE_EVT );
}
if ( events & START_DISCOVERY_EVT )
{
if ( timeAppPairingStarted )
{
// Postpone discovery until pairing completes
timeAppDiscPostponed = TRUE;
}
else
{
timeAppDiscState = timeAppDiscStart();
}
return ( events ^ START_DISCOVERY_EVT );
}
if ( events & CLOCK_UPDATE_EVT )
{
timeAppClockDisplay();
// Restart clock tick timer
osal_start_timerEx( timeAppTaskId, CLOCK_UPDATE_EVT, DEFAULT_CLOCK_UPDATE_PERIOD );
return ( events ^ CLOCK_UPDATE_EVT );
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn SimpleBLEPeripheral_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SimpleBLEPeripheral_ProcessEvent( uint8 task_id, uint16 events )
{
//tasksArr[] ÊÇ11¸öTaskµÄ×îºóÒ»¸ö£¬ÓÉOSAL ϵͳ½øÐе÷¶È¡£ÓÐʱ¼äÀ´ÁË£¬Óø÷½·¨´¦Àí¡£³õʼ»¯OSAL_SimpleBLEperipheal
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( simpleBLEPeripheral_TaskID )) != NULL )
{
simpleBLEPeripheral_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
// Start the Device Õâ¸öÊÇÉ豸ÓÐ״̬±ä»¯²Å»áµ÷ÓõĻص÷º¯Êý
VOID GAPRole_StartDevice( &simpleBLEPeripheral_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &simpleBLEPeripheral_BondMgrCBs );
// Set timer for first periodic event
//init LED
PWM_init();
init_QI_Switch(1);
//dataChange(1,0);
//osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD );
//LedChange();
return ( events ^ SBP_START_DEVICE_EVT );
}
if ( events & SBP_PERIODIC_EVT )
{
//osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD );
//Ö´ÐеƹâchangeµÄº¯Êý
if(P1_1 == 1){
//HalLcdWriteString("HEIGH",HAL_LCD_LINE_4);
}else{
//HalLcdWriteString("LOW",HAL_LCD_LINE_4);
}
LedChange();
return (events ^ SBP_PERIODIC_EVT);
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn SimpleBLEPeripheral_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SimpleBLEPeripheral_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( simpleBLEPeripheral_TaskID )) != NULL )
{
simpleBLEPeripheral_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
P0_7 = 0; //防止继电器跳变，初始化为高
P0DIR |= BV(7); //设置为输出
P0SEL &=~BV(7); //设置该脚为普通GPIO
//HCI_EXT_SetTxPowerCmd (HCI_EXT_TX_POWER_MINUS_23_DBM);
// Start the Device
VOID GAPRole_StartDevice( &simpleBLEPeripheral_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &simpleBLEPeripheral_BondMgrCBs );
return ( events ^ SBP_START_DEVICE_EVT );
}
if ( events & SBP_PERIODIC_EVT )
{
//成功写入后，重启从机
HAL_SYSTEM_RESET();
return (events ^ SBP_PERIODIC_EVT);
}
#if defined ( PLUS_BROADCASTER )
if ( events & SBP_ADV_IN_CONNECTION_EVT )
{
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &turnOnAdv );
return (events ^ SBP_ADV_IN_CONNECTION_EVT);
}
#endif // PLUS_BROADCASTER
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn PIRSensor_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 PIRSensor_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( PIRSensor_TaskID )) != NULL )
{
PIRSensor_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &PIRSensor_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &PIRSensor_BondMgrCBs );
return ( events ^ SBP_START_DEVICE_EVT );
}
//////////////////////////
// AIN //
//////////////////////////
if ( events & SBP_READ_AIN_EVT )
{
if(ainEnabled)
{
uint16 ainData;
ainData = readAdcData(HAL_ADC_CHANNEL_6);
Ain_SetParameter(SENSOR_DATA, AIN_DATA_LEN, &ainData);
osal_start_timerEx( PIRSensor_TaskID, SBP_READ_AIN_EVT, sensorAinPeriod );
}
else
{
resetCharacteristicValue( AIN_SERV_UUID, SENSOR_DATA, 0, AIN_DATA_LEN);
resetCharacteristicValue( AIN_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
}
return (events ^ SBP_READ_AIN_EVT);
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn SoftCmd_ProcessEvent
*
* @brief Soft Command Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SoftCmd_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( softCmdTaskId )) != NULL )
{
softCmd_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &softCmdPeripheralCBs );
// Register with bond manager after starting device
GAPBondMgr_Register( (gapBondCBs_t *) &softCmdBondCB );
return ( events ^ START_DEVICE_EVT );
}
if ( events & START_DISCOVERY_EVT )
{
if ( softCmdPairingStarted )
{
// Postpone discovery until pairing completes
softCmdDiscPostponed = TRUE;
}
else
{
softCmdDiscState = softCmdDiscStart();
}
return ( events ^ START_DISCOVERY_EVT );
}
if ( events & BATT_PERIODIC_EVT )
{
// Perform periodic battery task
softCmdBattPeriodicTask();
return (events ^ BATT_PERIODIC_EVT);
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn simpleTopology_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 simpleTopology_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);
// Create an RTOS queue for message from profile to be sent to app.
appMsgQueue = Util_constructQueue(&appMsg);
Util_constructClock(&scanClock, SensorTagMultiRoleTest_scanStartHandler,
SCAN_EVENT_PERIOD, SCAN_EVENT_PERIOD, TRUE, SCAN_EVENT);
// Setup the GAP
{
/*-------------------PERIPHERAL-------------------*/
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);
GAP_SetParamValue(TGAP_LIM_ADV_TIMEOUT, ADV_DURATION);
/*-------------------CENTRAL-------------------*/
GAP_SetParamValue(TGAP_GEN_DISC_SCAN, DEFAULT_SCAN_DURATION);
GAP_SetParamValue(TGAP_GEN_DISC_SCAN_INT, DEFAULT_SCAN_INT);
GAP_SetParamValue(TGAP_GEN_DISC_SCAN_WIND, DEFAULT_SCAN_WIND);
GAP_SetParamValue(TGAP_LIM_DISC_SCAN_INT, DEFAULT_SCAN_INT);
GAP_SetParamValue(TGAP_LIM_DISC_SCAN_WIND, DEFAULT_SCAN_WIND);
}
// Setup the GAP Role Profile
{
/*--------PERIPHERAL-------------*/
// For all hardware platforms, device starts advertising upon initialization
uint8_t initialAdvertEnable = FALSE;
// 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;
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&initialAdvertEnable, NULL);
GAPRole_SetParameter(GAPROLE_ADVERT_OFF_TIME, sizeof(uint16_t),
&advertOffTime, NULL);
GAPRole_SetParameter(GAPROLE_ADVERT_DATA, sizeof(advertData), advertData, NULL);
// Register with GAP for HCI/Host messages
GAP_RegisterForMsgs(selfEntity);
}
VOID GAPRole_StartDevice(&simpleTopology_gapRoleCBs);
}
/*********************************************************************
* @fn Biscuit_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 Biscuit_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( biscuit_TaskID )) != NULL )
{
biscuit_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &biscuit_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &biscuit_BondMgrCBs );
// Set timer for first periodic event
osal_start_timerEx( biscuit_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD );
return ( events ^ SBP_START_DEVICE_EVT );
}
if ( events & SBP_PERIODIC_EVT )
{
// Restart timer
if ( SBP_PERIODIC_EVT_PERIOD )
{
osal_start_timerEx( biscuit_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD );
}
// Perform periodic application task
performPeriodicTask();
return (events ^ SBP_PERIODIC_EVT);
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn HeartRate_ProcessEvent
*
* @brief Heart Rate Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 HeartRate_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( heartRate_TaskID )) != NULL )
{
heartRate_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &heartRatePeripheralCB );
// Register with bond manager after starting device
GAPBondMgr_Register( (gapBondCBs_t *) &heartRateBondCB );
return ( events ^ START_DEVICE_EVT );
}
if ( events & HEART_PERIODIC_EVT )
{
// Perform periodic heart rate task
heartRatePeriodicTask();
return (events ^ HEART_PERIODIC_EVT);
}
if ( events & BATT_PERIODIC_EVT )
{
// Perform periodic battery task
heartRateBattPeriodicTask();
return (events ^ BATT_PERIODIC_EVT);
}
// Discard unknown events
return 0;
}
/**
* SNP_setAdvData
*
*/
uint8_t SNP_setAdvData(snpSetAdvDataReq_t *pReq, uint8_t len)
{
uint8_t status = 0;
uint8_t *pDataPtr;
//Device must be started, or the set adv command will failed.
VOID GAPRole_StartDevice(&SNP_gapRoleCBs);
if(pReq->type < SNP_ADV_DATA_MAX_IDX)
{
pDataPtr = advPtrTable[pReq->type].pData;
if(pDataPtr)
{
ICall_free(advPtrTable[pReq->type].pData);
}
advPtrTable[pReq->type].pData = pDataPtr = ICall_malloc(len);
if(pDataPtr)
{
advPtrTable[pReq->type].length = len;
memcpy(pDataPtr, pReq->pData, len);
if(pReq->type == SNP_ADV_DATA_SCAN_RSP_IDX)
{
status = GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, len, pDataPtr);
}
else if(pReq->type == SNP_ADV_DATA_NON_CONN_IDX)
{
status = GAPRole_SetParameter(GAPROLE_ADVERT_DATA, len, pDataPtr);
}
else if(pReq->type == SNP_ADV_DATA_CONN_IDX)
{
uint8_t value;
GAPRole_GetParameter(GAPROLE_STATE, &value);
if(value == GAPROLE_CONNECTED_ADV)
{
status = GAPRole_SetParameter(GAPROLE_ADVERT_DATA, len, pDataPtr);
}
}
}
else
{
status = SNP_OUT_OF_RESOURCES;
}
}
else
{
//Error, bad type
status = SNP_INVALID_PARAMS;
}
return status;
}
/*---------------------------------------------------------------------------
* Application event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
* - task_id: The OSAL assigned task ID.
* - events: Events to process. This is a bit map and can contain more
* than one event.
*-------------------------------------------------------------------------*/
uint16 PMD_processEvent( uint8 taskId, uint16 events )
{
if ( events & START_STREAMING)
{
attHandleValueNoti_t nData2;
nData2.len = 20;
nData2.handle = 20;
getNameWithAddressInfo(nData2);
GATT_Notification( 0, &nData2, FALSE );
return (events ^ START_STREAMING);
}
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( pmd.taskId )) != NULL )
{
processOSALMsg( (osal_event_hdr_t *)pMsg );
VOID osal_msg_deallocate( pMsg );
}
return (events ^ SYS_EVENT_MSG);
}
if ( events & PMD_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &peripheralRoleCallbacks );
// Start Bond Manager
VOID GAPBondMgr_Register( &bondMgrCallbacks );
// Flash red LED twice
//cbLED_flash(cbLED_RED, 2, 250, 500);
PMD_INT_init();
return ( events ^ PMD_START_DEVICE_EVT );
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn simpleTopology_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 simpleTopology_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);
// Create an RTOS queue for message from profile to be sent to app.
appMsgQueue = Util_constructQueue(&appMsg);
// Setup discovery delay as a one-shot timer
Util_constructClock(&startDiscClock, simpleTopology_startDiscHandler,
DEFAULT_SVC_DISCOVERY_DELAY, 0, false, 0);
//init keys and LCD
Board_initKeys(simpleTopology_keyChangeHandler);
Board_openLCD();
// Setup the GAP
{
/*-------------------PERIPHERAL-------------------*/
uint16_t advInt = DEFAULT_ADVERTISING_INTERVAL;
GAP_SetParamValue(TGAP_CONN_PAUSE_PERIPHERAL, DEFAULT_CONN_PAUSE_PERIPHERAL);
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);
/*-------------------CENTRAL-------------------*/
GAP_SetParamValue(TGAP_GEN_DISC_SCAN, DEFAULT_SCAN_DURATION);
GAP_SetParamValue(TGAP_CONN_SCAN_INT, DEFAULT_SCAN_INT);
GAP_SetParamValue(TGAP_CONN_SCAN_WIND, DEFAULT_SCAN_WIND);
GAP_SetParamValue(TGAP_CONN_HIGH_SCAN_INT, DEFAULT_SCAN_INT);
GAP_SetParamValue(TGAP_CONN_HIGH_SCAN_WIND, DEFAULT_SCAN_WIND);
GAP_SetParamValue(TGAP_GEN_DISC_SCAN_INT, DEFAULT_SCAN_INT);
GAP_SetParamValue(TGAP_GEN_DISC_SCAN_WIND, DEFAULT_SCAN_WIND);
GAP_SetParamValue(TGAP_LIM_DISC_SCAN_INT, DEFAULT_SCAN_INT);
GAP_SetParamValue(TGAP_LIM_DISC_SCAN_WIND, DEFAULT_SCAN_WIND);
GAP_SetParamValue(TGAP_CONN_EST_SCAN_INT, DEFAULT_SCAN_INT);
GAP_SetParamValue(TGAP_CONN_EST_SCAN_WIND, DEFAULT_SCAN_WIND);
GAP_SetParamValue(TGAP_CONN_EST_INT_MIN, DEFAULT_CONN_INT);
GAP_SetParamValue(TGAP_CONN_EST_INT_MAX, DEFAULT_CONN_INT);
GAP_SetParamValue(TGAP_CONN_EST_SUPERV_TIMEOUT, DEFAULT_CONN_TIMEOUT);
GAP_SetParamValue(TGAP_CONN_EST_LATENCY, DEFAULT_CONN_LATENCY);
}
// Setup the GAP Role Profile
{
/*--------PERIPHERAL-------------*/
// 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;
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;
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&initialAdvertEnable, NULL);
GAPRole_SetParameter(GAPROLE_ADVERT_OFF_TIME, sizeof(uint16_t),
&advertOffTime, NULL);
GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanRspData),
scanRspData, NULL);
GAPRole_SetParameter(GAPROLE_ADVERT_DATA, sizeof(advertData), advertData, NULL);
GAPRole_SetParameter(GAPROLE_MIN_CONN_INTERVAL, sizeof(uint16_t),
&desiredMinInterval, NULL);
GAPRole_SetParameter(GAPROLE_MAX_CONN_INTERVAL, sizeof(uint16_t),
&desiredMaxInterval, NULL);
GAPRole_SetParameter(GAPROLE_SLAVE_LATENCY, sizeof(uint16_t),
&desiredSlaveLatency, NULL);
GAPRole_SetParameter(GAPROLE_TIMEOUT_MULTIPLIER, sizeof(uint16_t),
&desiredConnTimeout, NULL);
/*--------------CENTRAL-----------------*/
uint8_t scanRes = DEFAULT_MAX_SCAN_RES;
GAPRole_SetParameter(GAPROLE_MAX_SCAN_RES, sizeof(uint8_t),
&scanRes, NULL);
// Register with GAP for HCI/Host messages
GAP_RegisterForMsgs(selfEntity);
}
//GATT
{
/*---------------------SERVER------------------------*/
// Set the GAP Characteristics
GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName);
// Initialize GATT Server Services
GGS_AddService(GATT_ALL_SERVICES); // GAP
GATTServApp_AddService(GATT_ALL_SERVICES); // GATT attributes
DevInfo_AddService(); // Device Information Service
SimpleProfile_AddService(GATT_ALL_SERVICES); // Simple GATT Profile
// Setup Profile 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(&simpleTopology_simpleProfileCBs);
/*-----------------CLIENT------------------*/
// Initialize GATT Client
VOID GATT_InitClient();
// Register for GATT local events and ATT Responses pending for transmission
GATT_RegisterForMsgs(selfEntity);
}
// Start the Device
VOID GAPRole_StartDevice(&simpleTopology_gapRoleCBs);
}
/*********************************************************************
* @fn RunningSensor_ProcessEvent
*
* @brief Running Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 RunningSensor_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( sensor_TaskID )) != NULL )
{
sensor_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &runningPeripheralCB );
// Register with bond manager after starting device
GAPBondMgr_Register( (gapBondCBs_t *) &runningBondCB );
return ( events ^ START_DEVICE_EVT );
}
if ( events & RSC_PERIODIC_EVT )
{
// Perform periodic sensor's periodic task
sensorPeriodicTask();
return (events ^ RSC_PERIODIC_EVT);
}
if ( events & RSC_CONN_PARAM_UPDATE_EVT )
{
// Send param update. If it fails, retry until successful.
GAPRole_SendUpdateParam( DEFAULT_DESIRED_MIN_CONN_INTERVAL, DEFAULT_DESIRED_MAX_CONN_INTERVAL,
DEFAULT_DESIRED_SLAVE_LATENCY, DEFAULT_DESIRED_CONN_TIMEOUT,
GAPROLE_RESEND_PARAM_UPDATE );
// Assuming service discovery complete, start neglect timer
if ( USING_NEGLECT_TIMEOUT )
{
osal_start_timerEx( sensor_TaskID, RSC_NEGLECT_TIMEOUT_EVT, NEGLECT_TIMEOUT_DELAY );
}
return (events ^ RSC_CONN_PARAM_UPDATE_EVT);
}
if ( events & RSC_NEGLECT_TIMEOUT_EVT )
{
// No user input, terminate connection.
GAPRole_TerminateConnection();
return ( events ^ RSC_NEGLECT_TIMEOUT_EVT );
}
if ( events & RSC_RESET_EVT )
{
if ( gapProfileState == GAPROLE_CONNECTED )
{
// Exit the connection
GAPRole_TerminateConnection();
// There is no callback for manual termination of the link. change state variable here.
gapProfileState = GAPROLE_WAITING;
// Set timer to give the end advertising event time to finish
osal_start_timerEx( sensor_TaskID, RSC_RESET_EVT, 500 );
}
else if ( gapProfileState == GAPROLE_ADVERTISING )
{
uint8 value = FALSE;
// Turn off advertising
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &value );
// Set timer to give the end advertising event time to finish
osal_start_timerEx( sensor_TaskID, RSC_RESET_EVT, 500 );
}
else if ( USING_WHITE_LIST == TRUE )
{
//temporary variable
uint8 value = GAP_FILTER_POLICY_ALL;
// Turn off white list filter policy
GAPRole_SetParameter(GAPROLE_ADV_FILTER_POLICY, sizeof( uint8 ), &value);
sensorUsingWhiteList = FALSE;
// Clear the white list
HCI_LE_ClearWhiteListCmd();
// Set timer to give the end advertising event time to finish
osal_start_timerEx( sensor_TaskID, RSC_RESET_EVT, 500 );
}
else if ( (gapProfileState == GAPROLE_STARTED) ||
(gapProfileState == GAPROLE_WAITING) ||
(gapProfileState == GAPROLE_WAITING_AFTER_TIMEOUT) )
{
uint8 eraseBonds = TRUE;
// Erase all bonds
GAPBondMgr_SetParameter( GAPBOND_ERASE_ALLBONDS, 0, &eraseBonds );
// Turn on GREEN LED for set time
HalLedSet( HAL_LED_1, HAL_LED_MODE_BLINK );
return (events ^ RSC_RESET_EVT);
}
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn HeartRate_init
*
* @brief Initialization function for the Heart Rate application thread.
* This is called during initialization and should contain
* any application specific initialization (ie. hardware
* initialization/setup, table initialization, power up
* notification ...).
*
* @param none
*
* @return none
*/
void HeartRate_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);
// Hard code the DB Address till CC2650 board gets its own IEEE address.
//uint8_t bdAddress[B_ADDR_LEN] = { 0x22, 0x22, 0x22, 0x22, 0x22, 0x22 };
//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);
// Create one-shot clocks for internal periodic events.
Util_constructClock(&measPerClock, HeartRate_clockHandler,
DEFAULT_HEARTRATE_PERIOD, 0, false,
HEARTRATE_MEAS_PERIODIC_EVT);
Util_constructClock(&battPerClock, HeartRate_clockHandler,
DEFAULT_BATT_PERIOD, 0, false,
HEARTRATE_BATT_PERIODIC_EVT);
// Initialize keys on SRF06.
Board_initKeys(HeartRate_keyPressHandler);
// Setup the GAP Peripheral Role Profile.
{
#if ADVERTISE_WHEN_NOT_CONNECTED
uint8_t initial_advertising_enable = TRUE;
#else
// Press right key to initiate advertising and measurement.
uint8_t initial_advertising_enable = FALSE;
#endif //ADVERTISE_WHEN_NOT_CONNECTED
// 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 gapRole_AdvertOffTime = 0;
uint8_t enable_update_request = DEFAULT_ENABLE_UPDATE_REQUEST;
uint16_t desired_min_interval = DEFAULT_DESIRED_MIN_CONN_INTERVAL;
uint16_t desired_max_interval = DEFAULT_DESIRED_MAX_CONN_INTERVAL;
uint16_t desired_slave_latency = DEFAULT_DESIRED_SLAVE_LATENCY;
uint16_t desired_conn_timeout = DEFAULT_DESIRED_CONN_TIMEOUT;
// Set the GAP Role Parameters.
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&initial_advertising_enable);
GAPRole_SetParameter(GAPROLE_ADVERT_OFF_TIME, sizeof(uint16_t),
&gapRole_AdvertOffTime);
GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof (scanData),
scanData);
GAPRole_SetParameter(GAPROLE_ADVERT_DATA, sizeof(advertData),
advertData);
GAPRole_SetParameter(GAPROLE_PARAM_UPDATE_ENABLE, sizeof(uint8_t),
&enable_update_request);
GAPRole_SetParameter(GAPROLE_MIN_CONN_INTERVAL, sizeof(uint16_t),
&desired_min_interval);
GAPRole_SetParameter(GAPROLE_MAX_CONN_INTERVAL, sizeof(uint16_t),
&desired_max_interval);
GAPRole_SetParameter(GAPROLE_SLAVE_LATENCY, sizeof(uint16_t),
&desired_slave_latency);
GAPRole_SetParameter(GAPROLE_TIMEOUT_MULTIPLIER, sizeof(uint16_t),
&desired_conn_timeout);
}
// Set the GAP Characteristics.
GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, attDeviceName);
// Setup the GAP Bond Manager.
{
uint32 passkey = 0; // passkey "000000"
uint8_t pairMode = GAPBOND_PAIRING_MODE_WAIT_FOR_REQ;
uint8_t mitm = FALSE;
uint8_t ioCap = GAPBOND_IO_CAP_DISPLAY_ONLY;
uint8_t bonding = TRUE;
GAPBondMgr_SetParameter(GAPBOND_DEFAULT_PASSCODE, sizeof (uint32),
&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
// Add heart rate service.
HeartRate_AddService(GATT_ALL_SERVICES);
// Add device info service.
DevInfo_AddService();
// Add battery service.
Batt_AddService();
// Setup the Heart Rate Characteristic Values.
{
uint8_t sensLoc = HEARTRATE_SENS_LOC_WRIST;
HeartRate_SetParameter(HEARTRATE_SENS_LOC, sizeof (uint8_t), &sensLoc);
}
// Setup Battery Characteristic Values.
{
uint8_t critical = DEFAULT_BATT_CRITICAL_LEVEL;
Batt_SetParameter(BATT_PARAM_CRITICAL_LEVEL, sizeof(uint8_t), &critical);
}
// Register for Heart Rate service callback.
HeartRate_Register(&HeartRate_serviceCB);
// Register for Battery service callback.
Batt_Register (&HeartRate_battCB);
// Start the Device.
GAPRole_StartDevice(&heartRatePeripheralCB);
// Start the Bond Manager.
GAPBondMgr_Register((gapBondCBs_t *)&heartRateBondCB);
}
/*********************************************************************
* @fn BloodPressure_ProcessEvent
*
* @brief BloodPressure Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 BloodPressure_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( bloodPressureTaskId )) != NULL )
{
bloodPressure_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & BP_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &bloodPressure_PeripheralCBs );
// Register with bond manager after starting device
GAPBondMgr_Register( (gapBondCBs_t *) &timeAppBondCB );
updateUI();
return ( events ^ BP_START_DEVICE_EVT );
}
if ( events & BP_START_DISCOVERY_EVT )
{
if ( timeAppPairingStarted )
{
// Postpone discovery until pairing completes
timeAppDiscPostponed = TRUE;
}
else
{
timeAppDiscState = timeAppDiscStart();
}
return ( events ^ BP_START_DISCOVERY_EVT );
}
///////////////////////////////////
// BP MEAS DONE
///////////////////////////////////
if ( events & TIMER_BPMEAS_EVT )
{
// Perform final measurement
bpFinalMeas();
return (events ^ TIMER_BPMEAS_EVT);
}
///////////////////////////////////
// CUFF
///////////////////////////////////
if ( events & BP_TIMER_CUFF_EVT )
{
// Perform a Cutoff Measurement
cuffMeas();
cuffCount++;
// If cuff count not met, keep sending cuff measurements
if(cuffCount < CUFF_MAX)
{
// Start interval timer to send BP, just for simulation
osal_start_timerEx( bloodPressureTaskId, BP_TIMER_CUFF_EVT, TIMER_CUFF_PERIOD );
}
// Get ready to send final measurement
else
{
// Start timer to send final BP meas
osal_start_timerEx( bloodPressureTaskId, TIMER_BPMEAS_EVT, TIMER_CUFF_PERIOD );
}
return (events ^ BP_TIMER_CUFF_EVT);
}
// Enable Bloodpressure CCC
if ( events & BP_CCC_UPDATE_EVT )
{
if (gapProfileState == GAPROLE_CONNECTED)
{
//if previously connected and measurements are active send stored
if( connectedToLastAddress == true)
{
//send stored measurements
bpSendStoredMeas();
}
}
return (events ^ BP_CCC_UPDATE_EVT);
}
// Disconnect after sending measurement
if ( events & BP_DISCONNECT_EVT )
{
uint8 advEnable = FALSE;
//disable advertising on disconnect
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advEnable );
HalLedSet ( HAL_LED_1, HAL_LED_MODE_ON );
// Terminate Connection
GAPRole_TerminateConnection();
return (events ^ BP_DISCONNECT_EVT);
}
return 0;
}
/*********************************************************************
* @fn Thermometer_ProcessEvent
*
* @brief Thermometer Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 Thermometer_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
uint8 notify_interval;
int32 n32;
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( thermometerTaskId )) != NULL )
{
thermometer_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & TH_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &thermometer_PeripheralCBs );
// Register with bond manager after starting device
VOID GAPBondMgr_Register( &thermometer_BondMgrCBs );
updateUI();
return ( events ^ TH_START_DEVICE_EVT );
}
if ( events & TH_START_DISCOVERY_EVT )
{
if ( timeAppPairingStarted )
{
// Postpone discovery until pairing completes
timeAppDiscPostponed = TRUE;
}
else
{
timeAppDiscState = timeAppDiscStart();
}
timeAppDiscState = timeAppDiscStart();
return ( events ^ TH_START_DISCOVERY_EVT );
}
//periodic indications - if enabled
if ( events & TH_PERIODIC_MEAS_EVT )
{
// Perform periodic application task
performPeriodicTask();
return (events ^ TH_PERIODIC_MEAS_EVT);
}
//periodic notifications for IMEAS
if ( events & TH_PERIODIC_IMEAS_EVT )
{
// Perform periodic application task
performPeriodicImeasTask();
return (events ^ TH_PERIODIC_IMEAS_EVT);
}
// Disconnect after sending measurement
if ( events & TH_DISCONNECT_EVT )
{
uint8 advEnable = FALSE;
//disable advertising on disconnect
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &advEnable );
// Terminate Connection
GAPRole_TerminateConnection();
return (events ^ TH_DISCONNECT_EVT);
}
if ( events & TH_CCC_UPDATE_EVT )
//This event is triggered when CCC is enabled
if (gapProfileState == GAPROLE_CONNECTED)
{
temperatureMeasCharConfig = true;
//if previously connected and measurements are active send stored
if( connectedToLastAddress == true)
{
//send stored measurements
thermometerSendStoredMeas();
}
//Only start meas timer if it's not running
if(thMeasTimerRunning == FALSE)
{
//read stored interval value
Thermometer_GetParameter( THERMOMETER_INTERVAL, ¬ify_interval );
n32 = ((uint32)(notify_interval)) * (1000);
//zero interval means should not perform meas
if (n32 !=0)
{
// Start interval timer
osal_start_timerEx( thermometerTaskId, TH_PERIODIC_MEAS_EVT, n32 );
thMeasTimerRunning = TRUE;
}
}
return (events ^ TH_CCC_UPDATE_EVT);
}
return 0;
}
/*********************************************************************
* @fn SimpleBLEPeripheral_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SimpleBLEPeripheral_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( simpleBLEPeripheral_TaskID )) != NULL )
{
simpleBLEPeripheral_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &simpleBLEPeripheral_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &simpleBLEPeripheral_BondMgrCBs );
// Set timer for first periodic event
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD );
return ( events ^ SBP_START_DEVICE_EVT );
}
if ( events & SBP_PERIODIC_EVT )
{
// Restart timer
if ( SBP_PERIODIC_EVT_PERIOD )
{
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD );
}
// Perform periodic application task
performPeriodicTask();
return (events ^ SBP_PERIODIC_EVT);
}
if ( events & SBP_LED_TOGGLE_EVT )
{
// Assuming that the LED is on P0_4 in the circuit.
if(led_toggle_flag == 0)
{
P0_4 = 1;
led_toggle_flag = 1;
}
else
{
P0_4 = 0;
led_toggle_flag = 0;
}
VOID osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_LED_TOGGLE_EVT, 1000 );
return ( events ^ SBP_LED_TOGGLE_EVT );
}
// Discard unknown events
return 0;
}
uint16 SensorTag_ProcessEvent(uint8 task_id, uint16 events)
{
VOID task_id; // OSAL required parameter that isn't used in this function
///////////////////////////////////////////////////////////////////////
// system event handle //
///////////////////////////////////////////////////////////////////////
if (events & SYS_EVENT_MSG) {
uint8 *msg;
if ((msg = osal_msg_receive(sensorTag_TaskID)) != NULL) {
sensorTag_ProcessOSALMsg((osal_event_hdr_t *) msg);
// release the OSAL message
osal_msg_deallocate(msg);
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
///////////////////////////////////////////////////////////////////////
// start device event //
///////////////////////////////////////////////////////////////////////
if (events & EVT_START_DEVICE) {
// start the device
GAPRole_StartDevice(&sensorTag_PeripheralCBs);
// start bond manager
#if !defined(GAPBONDMGR_NO_SUPPORT)
GAPBondMgr_Register(&sensorTag_BondMgrCBs);
#endif
// start peripheral device
oled_init();
adxl345_softrst();
// adxl345_self_calibration();
steps = 0;
BATCD_PXIFG = ~(BATCD_BV);
BATCD_IEN |= BATCD_IENBIT;
osal_start_reload_timer(sensorTag_TaskID, EVT_RTC, PERIOD_RTC);
pwmgr_state_change(PWMGR_S0, 0);
fmsg(("\033[40;32m\n[power on]\033[0m\n"));
return (events ^ EVT_START_DEVICE);
}
///////////////////////////////////////////////////////////////////////
// key long press handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_MODE) {
if (key1_press) {
oled_clr_screen();
if ((opmode & 0xF0) == MODE_NORMAL) {
opmode = MODE_WORKOUT | MODE_TIME;
workout.steps = normal.steps;
workout.time = osal_getClock();
fmsg(("\033[40;32m[workout mode]\033[0m\n"));
} else {
opmode = MODE_NORMAL | MODE_TIME;
fmsg(("\033[40;32m[normal mode]\033[0m\n"));
}
pwmgr_state_change(pwmgr, TIME_OLED_OFF);
}
return (events ^ EVT_MODE);
}
if (events & EVT_SLEEP) {
if (key1_press) {
oled_clr_screen();
opmode = MODE_SLEEP;
fmsg(("\033[40;32m[sleep mode]\033[0m\n"));
pwmgr_state_change(pwmgr, TIME_OLED_OFF);
}
return (events ^ EVT_SLEEP);
}
if (events & EVT_SYSRST) {
if (key1_press) {
fmsg(("\033[40;32m[system reset]\033[0m\n"));
HAL_SYSTEM_RESET();
// adxl345_self_calibration();
}
return (events ^ EVT_SYSRST);
}
///////////////////////////////////////////////////////////////////////
// display handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_DISP) {
if (pwmgr == PWMGR_S1) {
sensorTag_HandleDisp(opmode, acc);
} else {
// display battery only
sensorTag_BattDisp(batt_get_level());
}
if (pwmgr != PWMGR_S6) {
osal_start_timerEx(sensorTag_TaskID, EVT_DISP, PERIOD_DISP);
}
return (events ^ EVT_DISP);
}
///////////////////////////////////////////////////////////////////////
// g-sensor handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_GSNINT1) {
adxl345_exit_sleep();
pwmgr_state_change(PWMGR_S3, TIME_GSEN_OFF);
return (events ^ EVT_GSNINT1);
}
if (events & EVT_GSNINT2) {
unsigned char sampling;
unsigned char i;
sampling = adxl345_chk_fifo();
for (i=0; i<sampling; i++) {
adxl345_read(acc);
#if (DEBUG_MESSAGE & MSG_STEPS)
{
unsigned long tmp = algo_step(acc);
if (normal.steps != tmp) {
stepmsg(("\033[1;33mstep=%0lu\n\033[0m", tmp));
}
normal.steps = tmp;
}
#else
normal.steps = algo_step(acc);
#endif
}
normal.distance = calc_distance(normal.steps, pi.stride);
workout.distance = calc_distance((normal.steps - workout.steps), pi.stride);
normal.calorie = calc_calorie(normal.distance, pi.weight);
workout.calorie = calc_calorie(workout.distance, pi.weight);
return (events ^ EVT_GSNINT2);
}
if (events & EVT_GSENSOR) {
adxl345_exit_sleep();
return (events ^ EVT_GSENSOR);
}
///////////////////////////////////////////////////////////////////////
// RTC handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_RTC) {
// performed once per second
// record data
if ((pwmgr != PWMGR_S5) && (pwmgr != PWMGR_S6)) {
#if defined(HAL_IMAGE_A) || defined(HAL_IMAGE_B)
if ((osal_getClock() - mark.time) >= (12UL*60UL)) {
#else
if ((osal_getClock() - mark.time) >= (12UL)) {
#endif
if (!hash_is_full()) {
unsigned short tmp = normal.steps - mark.steps;
switch (opmode & 0xF0) {
case MODE_WORKOUT: tmp |= 0x8000; break;
case MODE_SLEEP: tmp |= 0x4000; break;
}
hash_put(&tmp);
}
mark.time = osal_getClock();
#if defined(HAL_IMAGE_A) || defined(HAL_IMAGE_B)
if ((mark.time % (24UL*60UL*60UL)) <= (13UL*60UL)) {
#else
if ((mark.time % (24UL*60UL*60UL)) <= (13UL)) {
#endif
dmsg(("reset steps...\n"));
normal.steps = 0;
workout.steps = 0;
STEPS = 0;
}
mark.steps = normal.steps;
}
}
// power management
switch (pwmgr) {
case PWMGR_S0:
pmsg(("\033[40;35mS0 (power on)\033[0m\n"));
if (pwmgr_saving_timer()) {
adxl345_enter_sleep();
osal_pwrmgr_device(PWRMGR_BATTERY);
pwmgr_state_change(PWMGR_S4, 0);
}
break;
case PWMGR_S1:
pmsg(("\033[40;35mS1 (rtc+gsen+ble+oled)\033[0m\n"));
if (pwmgr_saving_timer()) {
oled_enter_sleep();
osal_stop_timerEx(sensorTag_TaskID, EVT_MODE);
osal_stop_timerEx(sensorTag_TaskID, EVT_SLEEP);
osal_stop_timerEx(sensorTag_TaskID, EVT_SYSRST);
pwmgr_state_change(PWMGR_S3, TIME_GSEN_OFF);
}
break;
case PWMGR_S2:
pmsg(("\033[40;35mS2 (rtc+gsen+ble)\033[0m\n"));
if (gapProfileState == GAPROLE_WAITING) {
// enable key interrupt mode
InitBoard(OB_READY);
pwmgr_state_change(PWMGR_S3, TIME_GSEN_OFF);
}
break;
case PWMGR_S3:
pmsg(("\033[40;35mS3 (rtc+gsen)\033[0m\n"));
if (steps == normal.steps) {
if (pwmgr_saving_timer()) {
adxl345_enter_sleep();
pwmgr_state_change(PWMGR_S4, 0);
}
} else {
steps = normal.steps;
pwmgr_state_change(pwmgr, TIME_GSEN_OFF);
}
break;
case PWMGR_S4:
pmsg(("\033[40;35mS4 (rtc)\033[0m\n"));
dmsg(("$"));
break;
default:
case PWMGR_S5:
pmsg(("\033[40;35mS5 (shutdown)\033[0m\n"));
adxl345_shutdown();
osal_stop_timerEx(sensorTag_TaskID, EVT_RTC);
break;
case PWMGR_S6:
pmsg(("\033[40;35mS6 (rtc+oled)\033[0m\n"));
if (pwmgr_saving_timer()) {
oled_enter_sleep();
// enable key interrupt mode
InitBoard(OB_READY);
pwmgr_state_change(PWMGR_S5, 0);
}
break;
}
// battery measure
if ((!batt_measure()) && (pwmgr != PWMGR_S6)) {
pwmgr_state_change(PWMGR_S5, 0);
}
return (events ^ EVT_RTC);
}
///////////////////////////////////////////////////////////////////////
// battery charge detect handle //
///////////////////////////////////////////////////////////////////////
if (events & EVT_CHARGING) {
if (pwmgr != PWMGR_S1) {
if (!BATCD_SBIT) {
dmsg(("[charging]\n"));
oled_exit_sleep();
if ((pwmgr == PWMGR_S5) || (pwmgr == PWMGR_S6)) {
osal_start_reload_timer(sensorTag_TaskID, EVT_RTC, PERIOD_RTC);
pwmgr_state_change(PWMGR_S4, 0);
}
} else {
dmsg(("[no charge]\n"));
oled_enter_sleep();
}
}
return (events ^ EVT_CHARGING);
}
///////////////////////////////////////////////////////////////////////
// discard unknown events //
///////////////////////////////////////////////////////////////////////
return 0;
}
/*********************************************************************
* @fn Biscuit_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 Biscuit_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( biscuit_TaskID )) != NULL )
{
biscuit_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &biscuit_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &biscuit_BondMgrCBs );
// Set timer for first periodic event
osal_start_timerEx( biscuit_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD );
return ( events ^ SBP_START_DEVICE_EVT );
}
if ( events & SBP_RX_TIME_OUT_EVT )
{
uint8 data[20];
uint8 send;
while(rxLen != 0)
{
if(rxLen <= 20)
{
send = rxLen;
rxLen = 0;
}
else
{
send = 20;
rxLen -= 20;
}
for(uint8 i=0; i<send; i++)
{
data[i] = RXBuf[rxTail];
rxTail++;
if(rxTail == MAX_RX_LEN)
{
rxTail = 0;
}
}
TXRX_SetParameter(TX_DATA_CHAR, send, data);
}
return (events ^ SBP_RX_TIME_OUT_EVT);
}
if ( events & SBP_PERIODIC_EVT )
{
// Restart timer
if ( SBP_PERIODIC_EVT_PERIOD )
{
osal_start_timerEx( biscuit_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD );
}
// Perform periodic application task
performPeriodicTask();
return (events ^ SBP_PERIODIC_EVT);
}
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn SimpleBLEBroadcaster_init
*
* @brief Initialization function for the Simple BLE Broadcaster App
* Task. This is called during initialization and should contain
* any application specific initialization (ie. hardware
* initialization/setup, table initialization, power up
* notification ...).
*
* @param none
*
* @return none
*/
static void SimpleBLEBroadcaster_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);
// Hard code the DB Address till CC2650 board gets its own IEEE address
//uint8 bdAddress[B_ADDR_LEN] = { 0x33, 0x33, 0x33, 0x33, 0x33, 0x33 };
//HCI_EXT_SetBDADDRCmd(bdAddress);
// Create an RTOS queue for message from profile to be sent to app.
appMsgQueue = Util_constructQueue(&appMsg);
#ifdef TI_DRIVERS_LCD_INCLUDED
//Enable the 3V3 Domain and open LCD
Board_openLCD();
#endif //TI_DRIVERS_LCD_INCLUDED
// Setup the GAP Broadcaster Role Profile
{
// For all hardware platforms, device starts advertising upon initialization
uint8_t initial_advertising_enable = 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 gapRole_AdvertOffTime = 0;
#ifndef BEACON_FEATURE
uint8_t advType = GAP_ADTYPE_ADV_SCAN_IND; // use scannable undirected adv
#else
uint8_t advType = GAP_ADTYPE_ADV_NONCONN_IND; // use non-connectable adv
#endif // !BEACON_FEATURE
// Set the GAP Role Parameters
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&initial_advertising_enable);
GAPRole_SetParameter(GAPROLE_ADVERT_OFF_TIME, sizeof(uint16_t),
&gapRole_AdvertOffTime);
GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof (scanRspData),
scanRspData);
GAPRole_SetParameter(GAPROLE_ADVERT_DATA, sizeof(advertData), advertData);
GAPRole_SetParameter(GAPROLE_ADV_EVENT_TYPE, sizeof(uint8_t), &advType);
}
// 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);
}
// Start the Device
VOID GAPRole_StartDevice(&simpleBLEBroadcaster_BroadcasterCBs);
LCD_WRITE_STRING("BLE Broadcaster", LCD_PAGE0);
}
/*******************************************************************************
* @fn SensorTag_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 SensorTag_init(void)
{
//uint8_t selfTestMap;
// Setup I2C for sensors
//bspI2cInit();
// Handling of buttons, LED, relay
hGpioPin = PIN_open(&pinGpioState, SensortagAppPinTable);
PIN_registerIntCb(hGpioPin, SensorTag_callback);
// ***************************************************************************
// 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);
// 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, SensorTag_clockHandler,
ST_PERIODIC_EVT_PERIOD, 0, false, ST_PERIODIC_EVT);
// 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);
//Returns 18, but this seems to be normal
GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanRspData),
scanRspData);
//Returns 18
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,
(void*)attDeviceName);
#ifdef FEATURE_OAD
// Register connection parameter update
GAPRole_RegisterAppCBs( ¶mUpdateCB);
#endif
// 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
DevInfo_AddService(); // Device Information Service
// Add application specific device information
SensorTag_setDeviceInfo();
#ifdef FACTORY_IMAGE
// Check if a factory image exists and apply current image if necessary
//if (!SensorTag_hasFactoryImage())
//{
// SensorTag_saveFactoryImage();
//}
#endif
#ifdef FEATURE_REGISTER_SERVICE
//Register_addService(); // Generic register access
//
#endif
#ifdef FEATURE_LCD
SensorTagDisplay_init(); // Display service DevPack LCD
#endif
#ifdef FEATURE_OAD
SensorTagConnectionControl_init(); // Connection control to
// support OAD for iOs/Android
OAD_addService(); // OAD Profile
OAD_register((oadTargetCBs_t *)&simpleBLEPeripheral_oadCBs);
hOadQ = Util_constructQueue(&oadQ);
#endif
// Start the Device
GAPRole_StartDevice(&SensorTag_gapRoleCBs);
// Start Bond Manager
GAPBondMgr_Register(NULL);
// Enable interrupt handling for keys and relay
PIN_registerIntCb(hGpioPin, SensorTag_callback);
}
/*********************************************************************
* @fn SensorTag_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SensorTag_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( sensorTag_TaskID )) != NULL )
{
sensorTag_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// Handle system reset (long press on side key)
if ( events & ST_SYS_RESET_EVT )
{
if (sysResetRequest)
{
HAL_SYSTEM_RESET();
}
return ( events ^ ST_SYS_RESET_EVT );
}
if ( events & ST_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &sensorTag_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &sensorTag_BondMgrCBs );
return ( events ^ ST_START_DEVICE_EVT );
}
//////////////////////////
// IR TEMPERATURE //
//////////////////////////
if ( events & ST_IRTEMPERATURE_READ_EVT )
{
if ( irTempEnabled )
{
if (HalIRTempStatus() == TMP006_DATA_READY)
{
readIrTempData();
osal_start_timerEx( sensorTag_TaskID, ST_IRTEMPERATURE_READ_EVT, sensorTmpPeriod-TEMP_MEAS_DELAY );
}
else if (HalIRTempStatus() == TMP006_OFF)
{
HalIRTempTurnOn();
osal_start_timerEx( sensorTag_TaskID, ST_IRTEMPERATURE_READ_EVT, TEMP_MEAS_DELAY );
}
}
else
{
//Turn off Temperatur sensor
VOID HalIRTempTurnOff();
VOID resetCharacteristicValue(IRTEMPERATURE_SERV_UUID,SENSOR_DATA,0,IRTEMPERATURE_DATA_LEN);
VOID resetCharacteristicValue(IRTEMPERATURE_SERV_UUID,SENSOR_CONF,ST_CFG_SENSOR_DISABLE,sizeof ( uint8 ));
}
return (events ^ ST_IRTEMPERATURE_READ_EVT);
}
//////////////////////////
// Accelerometer //
//////////////////////////
if ( events & ST_ACCELEROMETER_SENSOR_EVT )
{
if(accConfig != ST_CFG_SENSOR_DISABLE)
{
readAccData();
osal_start_timerEx( sensorTag_TaskID, ST_ACCELEROMETER_SENSOR_EVT, sensorAccPeriod );
}
else
{
VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, SENSOR_DATA, 0, ACCELEROMETER_DATA_LEN );
VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
}
return (events ^ ST_ACCELEROMETER_SENSOR_EVT);
}
//////////////////////////
// Humidity //
//////////////////////////
if ( events & ST_HUMIDITY_SENSOR_EVT )
{
if (humiEnabled)
{
HalHumiExecMeasurementStep(humiState);
if (humiState == 2)
{
readHumData();
humiState = 0;
osal_start_timerEx( sensorTag_TaskID, ST_HUMIDITY_SENSOR_EVT, sensorHumPeriod );
}
else
{
humiState++;
osal_start_timerEx( sensorTag_TaskID, ST_HUMIDITY_SENSOR_EVT, HUM_FSM_PERIOD );
}
}
else
{
resetCharacteristicValue( HUMIDITY_SERV_UUID, SENSOR_DATA, 0, HUMIDITY_DATA_LEN);
resetCharacteristicValue( HUMIDITY_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
}
return (events ^ ST_HUMIDITY_SENSOR_EVT);
}
//////////////////////////
// Magnetometer //
//////////////////////////
if ( events & ST_MAGNETOMETER_SENSOR_EVT )
{
if(magEnabled)
{
if (HalMagStatus() == MAG3110_DATA_READY)
{
readMagData();
}
else if (HalMagStatus() == MAG3110_OFF)
{
HalMagTurnOn();
}
osal_start_timerEx( sensorTag_TaskID, ST_MAGNETOMETER_SENSOR_EVT, sensorMagPeriod );
}
else
{
HalMagTurnOff();
resetCharacteristicValue( MAGNETOMETER_SERV_UUID, SENSOR_DATA, 0, MAGNETOMETER_DATA_LEN);
resetCharacteristicValue( MAGNETOMETER_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
}
return (events ^ ST_MAGNETOMETER_SENSOR_EVT);
}
//////////////////////////
// Barometer //
//////////////////////////
if ( events & ST_BAROMETER_SENSOR_EVT )
{
if (barEnabled)
{
if (barBusy)
{
barBusy = FALSE;
readBarData();
osal_start_timerEx( sensorTag_TaskID, ST_BAROMETER_SENSOR_EVT, sensorBarPeriod );
}
else
{
barBusy = TRUE;
HalBarStartMeasurement();
osal_start_timerEx( sensorTag_TaskID, ST_BAROMETER_SENSOR_EVT, BAR_FSM_PERIOD );
}
}
else
{
resetCharacteristicValue( BAROMETER_SERV_UUID, SENSOR_DATA, 0, BAROMETER_DATA_LEN);
resetCharacteristicValue( BAROMETER_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
resetCharacteristicValue( BAROMETER_SERV_UUID, SENSOR_CALB, 0, BAROMETER_CALI_LEN);
}
return (events ^ ST_BAROMETER_SENSOR_EVT);
}
//////////////////////////
// Gyroscope //
//////////////////////////
if ( events & ST_GYROSCOPE_SENSOR_EVT )
{
uint8 status;
status = HalGyroStatus();
if(gyroEnabled)
{
if (status == HAL_GYRO_STOPPED)
{
HalGyroSelectAxes(sensorGyroAxes);
HalGyroTurnOn();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_STARTUP_TIME);
}
else
{
if(sensorGyroUpdateAxes)
{
HalGyroSelectAxes(sensorGyroAxes);
sensorGyroUpdateAxes = FALSE;
}
if (status == HAL_GYRO_DATA_READY)
{
readGyroData();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, sensorGyrPeriod - GYRO_STARTUP_TIME);
}
else
{
// Gyro needs to be activated;
HalGyroWakeUp();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_STARTUP_TIME);
}
}
}
else
{
HalGyroTurnOff();
resetCharacteristicValue( GYROSCOPE_SERV_UUID, SENSOR_DATA, 0, GYROSCOPE_DATA_LEN);
resetCharacteristicValue( GYROSCOPE_SERV_UUID, SENSOR_CONF, ST_CFG_SENSOR_DISABLE, sizeof( uint8 ));
}
return (events ^ ST_GYROSCOPE_SENSOR_EVT);
}
#if defined ( PLUS_BROADCASTER )
if ( events & ST_ADV_IN_CONNECTION_EVT )
{
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &turnOnAdv );
return (events ^ ST_ADV_IN_CONNECTION_EVT);
}
#endif // PLUS_BROADCASTER
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn SensorTag_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SensorTag_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( sensorTag_TaskID )) != NULL )
{
sensorTag_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
// Handle system reset (long press on side key)
if ( events & ST_SYS_RESET_EVT )
{
if (sysResetRequest)
{
HAL_SYSTEM_RESET();
}
return ( events ^ ST_SYS_RESET_EVT );
}
if ( events & ST_START_DEVICE_EVT )
{
// Start the Device
GAPRole_StartDevice( &sensorTag_PeripheralCBs );
// Start Bond Manager
GAPBondMgr_Register( &sensorTag_BondMgrCBs );
return ( events ^ ST_START_DEVICE_EVT );
}
////////////////////////////
//// Accelerometer //
////////////////////////////
// if ( events & ST_ACCELEROMETER_SENSOR_EVT )
// {
// if(accConfig != ST_CFG_SENSOR_DISABLE)
// {
// readAccData();
// osal_start_timerEx( sensorTag_TaskID, ST_ACCELEROMETER_SENSOR_EVT, sensorAccPeriod );
// }
// else
// {
// VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, ACCELEROMETER_DATA, 0, ACCELEROMETER_DATA_LEN );
// VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, ACCELEROMETER_CONF, ST_CFG_SENSOR_DISABLE, sizeof ( uint8 ));
// VOID resetCharacteristicValue( ACCELEROMETER_SERV_UUID, ACCELEROMETER_PERI, ACC_DEFAULT_PERIOD/ACCELEROMETER_TIME_UNIT, sizeof ( uint8 ));
// }
// return (events ^ ST_ACCELEROMETER_SENSOR_EVT);
// }
//////////////////////////
// Gyroscope //
//////////////////////////
if ( events & ST_GYROSCOPE_SENSOR_EVT )
{
uint8 status;
status = HalGyroStatus();
if(gyroEnabled)
{
if (status == HAL_GYRO_STOPPED)
{
HalGyroSelectAxes(sensorGyroAxes);
HalGyroTurnOn();
GAPRole_SendUpdateParam( 240, 256,0, 138, GAPROLE_TERMINATE_LINK);
//GAPRole_SendUpdateParam( 100, 105,0, 138, GAPROLE_TERMINATE_LINK);
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_STARTUP_TIME);
}
else
{
if(sensorGyroUpdateAxes)
{
HalGyroSelectAxes(sensorGyroAxes);
sensorGyroUpdateAxes = FALSE;
}
if (status == HAL_GYRO_DATA_READY)
{
readGyroData();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_DEFAULT_PERIOD - GYRO_STARTUP_TIME);
}
else
{
// Gyro needs to be activated;
HalGyroWakeUp();
osal_start_timerEx( sensorTag_TaskID, ST_GYROSCOPE_SENSOR_EVT, GYRO_STARTUP_TIME);
}
}
}
else
{
HalGyroTurnOff();
if ( status == HAL_GYRO_STOPPED)
{
resetCharacteristicValue( GYROSCOPE_SERV_UUID, GYROSCOPE_DATA, 0, GYROSCOPE_DATA_LEN);
resetCharacteristicValue( GYROSCOPE_SERV_UUID, GYROSCOPE_CONF, ST_CFG_SENSOR_DISABLE, sizeof( uint8 ));
}
else
{
// Indicate error
resetCharacteristicValue( GYROSCOPE_SERV_UUID, GYROSCOPE_DATA, ST_CFG_ERROR, GYROSCOPE_DATA_LEN);
resetCharacteristicValue( GYROSCOPE_SERV_UUID, GYROSCOPE_CONF, ST_CFG_ERROR, sizeof( uint8 ));
}
}
return (events ^ ST_GYROSCOPE_SENSOR_EVT);
}
#if defined ( PLUS_BROADCASTER )
if ( events & ST_ADV_IN_CONNECTION_EVT )
{
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &turnOnAdv );
return (events ^ ST_ADV_IN_CONNECTION_EVT);
}
#endif // PLUS_BROADCASTER
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn SimpleBLEPeriph(P0 &= 0xFD)eral_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SimpleBLEPeripheral_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
uint8 value = 0;
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( simpleBLEPeripheral_TaskID )) != NULL )
{
simpleBLEPeripheral_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &simpleBLEPeripheral_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &simpleBLEPeripheral_BondMgrCBs );
// Set timer for first periodic event
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_PERIODIC_EVT, advert_internal * 1000);
return ( events ^ SBP_START_DEVICE_EVT );
}
if ( events & SBP_PERIODIC_EVT )
{
if (!gOpenDoorStep)
performPeriodicTask();
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_PERIODIC_EVT, advert_internal * 1000);
return (events ^ SBP_PERIODIC_EVT);
}
if(events & SBP_OPENDOOR_DEVICE_EVT)
{
switch(gOpenDoorStep)
{
case 1:
//P0.0 ->0
P0 &= 0xFE;
DelayMS(20);
P0 &= 0xFE;
gOpenDoorStep++;
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_OPENDOOR_DEVICE_EVT, 0 );
break;
case 2:
//P0.1 ->1; P0.2 ->0; keep 2s
//P01_LOW;
P01_HIGH;
DelayMS(20);
//P02_HIGH;
P02_LOW;
DelayMS(20);
// P0 |= 0x02;
// DelayMS(20);
// P0 &= 0xFB;
// DelayMS(20);
gOpenDoorStep++;
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_OPENDOOR_DEVICE_EVT, 500 );
break;
case 3:
//P0.1 ->0; P0.2 ->0; keep 5s
P0 &= 0xFD;
DelayMS(20);
P0 &= 0xFB;
DelayMS(20);
gOpenDoorStep++;
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_OPENDOOR_DEVICE_EVT, 3500 );
break;
case 4:
//P0.1 ->0; P0.2 ->1; keep 2s
P0 &= 0xFD;
DelayMS(20);
P0 |= 0x04;
DelayMS(20);
gOpenDoorStep++;
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_OPENDOOR_DEVICE_EVT, 1000 );
break;
case 5:
//P0.0 ->1
P0 |= 0x01;
P01_LOW;
P02_LOW;
DelayMS(20);
gOpenDoorStep =0;
SimpleProfile_SetParameter( SIMPLEPROFILE_CHAR2, sizeof ( uint8 ), &value );
break;
default:
gOpenDoorStep =0;
break;
}
return (events ^ SBP_OPENDOOR_DEVICE_EVT);
}
#if defined ( PLUS_BROADCASTER )
if ( events & SBP_ADV_IN_CONNECTION_EVT )
{
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &turnOnAdv );
return (events ^ SBP_ADV_IN_CONNECTION_EVT);
}
#endif // PLUS_BROADCASTER
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn KeyFobApp_ProcessEvent
*
* @brief Key Fob Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return none
*/
uint16 KeyFobApp_ProcessEvent( uint8 task_id, uint16 events )
{
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( keyfobapp_TaskID )) != NULL )
{
keyfobapp_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & KFD_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &keyFob_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &keyFob_BondMgrCBs );
// Start the Proximity Profile
VOID ProxReporter_RegisterAppCBs( &keyFob_ProximityCBs );
// Set timer for first battery read event
osal_start_timerEx( keyfobapp_TaskID, KFD_BATTERY_CHECK_EVT, BATTERY_CHECK_PERIOD );
// Start the Accelerometer Profile
VOID Accel_RegisterAppCBs( &keyFob_AccelCBs );
//Set the proximity attribute values to default
ProxReporter_SetParameter( PP_LINK_LOSS_ALERT_LEVEL, sizeof ( uint8 ), &keyfobProxLLAlertLevel );
ProxReporter_SetParameter( PP_IM_ALERT_LEVEL, sizeof ( uint8 ), &keyfobProxIMAlertLevel );
ProxReporter_SetParameter( PP_TX_POWER_LEVEL, sizeof ( int8 ), &keyfobProxTxPwrLevel );
// Set LED1 on to give feedback that the power is on, and a timer to turn off
HalLedSet( HAL_LED_1, HAL_LED_MODE_ON );
osal_pwrmgr_device( PWRMGR_ALWAYS_ON ); // To keep the LED on continuously.
osal_start_timerEx( keyfobapp_TaskID, KFD_POWERON_LED_TIMEOUT_EVT, 1000 );
return ( events ^ KFD_START_DEVICE_EVT );
}
if ( events & KFD_POWERON_LED_TIMEOUT_EVT )
{
osal_pwrmgr_device( PWRMGR_BATTERY ); // Revert to battery mode after LED off
HalLedSet( HAL_LED_1, HAL_LED_MODE_OFF );
return ( events ^ KFD_POWERON_LED_TIMEOUT_EVT );
}
if ( events & KFD_ACCEL_READ_EVT )
{
bStatus_t status = Accel_GetParameter( ACCEL_ENABLER, &accelEnabler );
if (status == SUCCESS)
{
if ( accelEnabler )
{
// Restart timer
if ( ACCEL_READ_PERIOD )
{
osal_start_timerEx( keyfobapp_TaskID, KFD_ACCEL_READ_EVT, ACCEL_READ_PERIOD );
}
// Read accelerometer data
accelRead();
}
else
{
// Stop the acceleromter
osal_stop_timerEx( keyfobapp_TaskID, KFD_ACCEL_READ_EVT);
}
}
else
{
//??
}
return (events ^ KFD_ACCEL_READ_EVT);
}
if ( events & KFD_BATTERY_CHECK_EVT )
{
// Restart timer
if ( BATTERY_CHECK_PERIOD )
{
osal_start_timerEx( keyfobapp_TaskID, KFD_BATTERY_CHECK_EVT, BATTERY_CHECK_PERIOD );
}
// perform battery level check
Batt_MeasLevel( );
return (events ^ KFD_BATTERY_CHECK_EVT);
}
if ( events & KFD_TOGGLE_BUZZER_EVT )
{
// if this event was triggered while buzzer is on, turn it off, increment beep_count,
// check whether max has been reached, and if not set the OSAL timer for next event to
// turn buzzer back on.
if ( buzzer_state == BUZZER_ON )
{
buzzerStop();
buzzer_state = BUZZER_OFF;
buzzer_beep_count++;
#if defined ( POWER_SAVING )
osal_pwrmgr_device( PWRMGR_BATTERY );
#endif
// check to see if buzzer has beeped maximum number of times
// if it has, then don't turn it back on
if ( ( buzzer_beep_count < BUZZER_MAX_BEEPS ) &&
( ( keyfobProximityState == KEYFOB_PROXSTATE_LINK_LOSS ) ||
( keyfobProximityState == KEYFOB_PROXSTATE_PATH_LOSS ) ) )
{
osal_start_timerEx( keyfobapp_TaskID, KFD_TOGGLE_BUZZER_EVT, 800 );
}
}
else if ( keyfobAlertState != ALERT_STATE_OFF )
{
// if this event was triggered while the buzzer is off then turn it on if appropriate
keyfobapp_PerformAlert();
}
return (events ^ KFD_TOGGLE_BUZZER_EVT);
}
#if defined ( PLUS_BROADCASTER )
if ( events & KFD_ADV_IN_CONNECTION_EVT )
{
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &turnOnAdv );
}
#endif
// Discard unknown events
return 0;
}
/*********************************************************************
* @fn SimpleBLEPeripheral_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SimpleBLEPeripheral_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( simpleBLEPeripheral_TaskID )) != NULL )
{
simpleBLEPeripheral_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & SBP_START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &simpleBLEPeripheral_PeripheralCBs );
// Start Bond Manager
VOID GAPBondMgr_Register( &simpleBLEPeripheral_BondMgrCBs );
// sys_config.pwm[0] = 0; //blue
// sys_config.pwm[1] = 0;//green
// sys_config.pwm[2] = 0;//red
// sys_config.pwm[3] = 0;//white
ti_pwm_init(2500, sys_config.pwm[0], sys_config.pwm[1], sys_config.pwm[2], sys_config.pwm[3]);
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_SET_PWM_EVT, 100 );
//if(g_initFlag == FALSE)
{
// 进行自测 SBP_SELF_TEST_EVT
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_SELF_TEST_EVT, 200 );
}
return ( events ^ SBP_START_DEVICE_EVT );
}
if ( events & SBP_SELF_TEST_EVT )
{
static uint8 count = 0;
if(count%3 == 0)
{
sys_config.pwm[3] = 0; // 白色
sys_config.pwm[2] = 0; // 红色
sys_config.pwm[1] = 0; // 绿色
sys_config.pwm[0] = 255; // 蓝色
}
else if(count%3 == 1)
{
sys_config.pwm[3] = 0; // 白色
sys_config.pwm[2] = 0; // 红色
sys_config.pwm[1] = 255; // 绿色
sys_config.pwm[0] = 0; // 蓝色
}
else if(count%3 == 2)
{
sys_config.pwm[3] = 0; // 白色
sys_config.pwm[2] = 255; // 红色
sys_config.pwm[1] = 0; // 绿色
sys_config.pwm[0] = 0; // 蓝色
}
count++;
if(count < 10)
{
osal_set_event( simpleBLEPeripheral_TaskID, SBP_SET_PWM_EVT);
osal_start_timerEx( simpleBLEPeripheral_TaskID, SBP_SELF_TEST_EVT, 800 );
}
return (events ^ SBP_SELF_TEST_EVT);
}
if ( events & SBP_PERIODIC_EVT )
{
// Restart timer
if ( SBP_PERIODIC_EVT_PERIOD )
{
}
// Perform periodic application task
//performPeriodicTask();
return (events ^ SBP_PERIODIC_EVT);
}
if ( events & SBP_READ_SENSOR_EVT )
{
return (events ^ SBP_READ_SENSOR_EVT);
}
if ( events & KFD_BATTERY_CHECK_EVT )
{
// Restart timer
if ( BATTERY_CHECK_PERIOD )
{
osal_start_timerEx( simpleBLEPeripheral_TaskID, KFD_BATTERY_CHECK_EVT, BATTERY_CHECK_PERIOD );
}
// perform battery level check
Batt_MeasLevel( );
return (events ^ KFD_BATTERY_CHECK_EVT);
}
if ( events & SBP_SET_PWM_EVT )
{
ti_pwm_set_period(PWM1_P11, sys_config.pwm[0], 300);
ti_pwm_set_period(PWM2_P10, sys_config.pwm[1], 300);
ti_pwm_set_period(PWM3_P07, sys_config.pwm[2], 300);
ti_pwm_set_period(PWM4_P06, sys_config.pwm[3], 300);
return (events ^ SBP_SET_PWM_EVT);
}
#if defined ( PLUS_BROADCASTER )
if ( events & SBP_ADV_IN_CONNECTION_EVT )
{
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter( GAPROLE_ADVERT_ENABLED, sizeof( uint8 ), &turnOnAdv );
return (events ^ SBP_ADV_IN_CONNECTION_EVT);
}
#endif // PLUS_BROADCASTER
// Discard unknown events
return 0;
}
/**
* SNP_startAdv
*
*/
uint8_t SNP_startAdv(snpStartAdvReq_t *pReq)
{
uint8_t status = SNP_SUCCESS;
uint8_t value;
VOID GAPRole_StartDevice(&SNP_gapRoleCBs);
// Duration of the advertisement
// In order to simplify design, set the timeout and interval for both
// limited and general mode. The mode is define by the Adflags advertisement
// token.
// User can still set them individually by using the 'setGapParam' command.
if(pReq->timeout)
{
// Save the timeout in second for the limited mode.
uint16_t temp = pReq->timeout/1000;
status |= GAPRole_SetParameter(TGAP_LIM_ADV_TIMEOUT, sizeof(uint16_t),
&temp);
status |= GAPRole_SetParameter(TGAP_GEN_DISC_ADV_MIN, sizeof(uint16_t),
&pReq->timeout);
}
// Set advertising interval
if(pReq->interval)
{
status |= GAP_SetParamValue(TGAP_LIM_DISC_ADV_INT_MIN, pReq->interval);
status |= GAP_SetParamValue(TGAP_LIM_DISC_ADV_INT_MAX, pReq->interval);
status |= GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MIN, pReq->interval);
status |= GAP_SetParamValue(TGAP_GEN_DISC_ADV_INT_MAX, pReq->interval);
}
//Set Advertise Type
status |= GAPRole_SetParameter(GAPROLE_ADV_EVENT_TYPE, sizeof(uint8_t),
&pReq->type);
if(status)
{
//Error management
return SNP_OUT_OF_RESOURCES ;
}
//Store behavior of the advertisement.
advBehavior = (pReq->behavior) & 0x3;
advReqAdvType = pReq->type;
//Enable Advertising.
if(GAP_ADTYPE_ADV_NONCONN_IND == pReq->type)
{
uint8_t start = TRUE;
GAPRole_GetParameter(GAPROLE_STATE, &value);
if(value == GAPROLE_CONNECTED)
{
if(advPtrTable[SNP_ADV_DATA_CONN_IDX].length)
{
// SNP was using adv data for connected mode, switch to use adv
// Data for non-connected mode
GAPRole_SetParameter(GAPROLE_ADVERT_DATA,
advPtrTable[SNP_ADV_DATA_NON_CONN_IDX].length,
advPtrTable[SNP_ADV_DATA_NON_CONN_IDX].pData);
}
}
status = GAPRole_SetParameter(GAPROLE_ADV_NONCONN_ENABLED, sizeof(uint8_t),
&start);
}
else
{
uint8_t start = TRUE;
GAPRole_GetParameter(GAPROLE_STATE, &value);
if(value == GAPROLE_CONNECTED)
{
return SNP_CMD_REJECTED;
}
status = GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&start);
}
return status;
}
/*********************************************************************
* @fn HidDev_ProcessEvent
*
* @brief Hid Dev Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 HidDev_ProcessEvent( uint8 task_id, uint16 events )
{
VOID task_id; // OSAL required parameter that isn't used in this function
if ( events & SYS_EVENT_MSG )
{
uint8 *pMsg;
if ( (pMsg = osal_msg_receive( hidDevTaskId )) != NULL )
{
hidDev_ProcessOSALMsg( (osal_event_hdr_t *)pMsg );
// Release the OSAL message
VOID osal_msg_deallocate( pMsg );
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if ( events & START_DEVICE_EVT )
{
// Start the Device
VOID GAPRole_StartDevice( &hidDev_PeripheralCBs );
// Register with bond manager after starting device
GAPBondMgr_Register( (gapBondCBs_t *) &hidDevBondCB );
return ( events ^ START_DEVICE_EVT );
}
if ( events & HID_IDLE_EVT )
{
if ( hidDevGapState == GAPROLE_CONNECTED )
{
// if pairing in progress then restart timer
if ( hidDevPairingStarted )
{
hidDevStartIdleTimer();
}
// else disconnect
else
{
GAPRole_TerminateConnection();
}
}
return ( events ^ HID_IDLE_EVT );
}
if ( events & BATT_PERIODIC_EVT )
{
// Perform periodic battery task
hidDevBattPeriodicTask();
return ( events ^ BATT_PERIODIC_EVT );
}
if ( events & HID_SEND_REPORT_EVT )
{
// if connection is secure
if ( hidDevConnSecure )
{
hidDevReport_t *pReport = hidDevDequeueReport();
if ( pReport != NULL )
{
// Send report
hidDevSendReport( pReport->id, pReport->type, pReport->len, pReport->data );
}
return ( reportQEmpty() ? events ^ HID_SEND_REPORT_EVT : events );
}
return ( events ^ HID_SEND_REPORT_EVT );
}
return 0;
}
/*********************************************************************
* @fn SimpleBLEPeripheral_ProcessEvent
*
* @brief Simple BLE Peripheral Application Task event processor. This function
* is called to process all events for the task. Events
* include timers, messages and any other user defined events.
*
* @param task_id - The OSAL assigned task ID.
* @param events - events to process. This is a bit map and can
* contain more than one event.
*
* @return events not processed
*/
uint16 SimpleBLEPeripheral_ProcessEvent(uint8 task_id, uint16 events) {
VOID task_id; // OSAL required parameter that isn't used in this function
if (events & SYS_EVENT_MSG) {
uint8 *pMsg;
if ((pMsg = osal_msg_receive(simpleBLEPeripheral_TaskID)) != NULL) {
simpleBLEPeripheral_ProcessOSALMsg((osal_event_hdr_t *) pMsg);
// Release the OSAL message
VOID osal_msg_deallocate(pMsg);
}
// return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if (events & SBP_START_DEVICE_EVT) {
// Start the Device
GAPRole_StartDevice(&simpleBLEPeripheral_PeripheralCBs);
// Start Bond Manager
GAPBondMgr_Register(&simpleBLEPeripheral_BondMgrCBs);
// Set timer for first periodic event
osal_start_timerEx(simpleBLEPeripheral_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD);
return (events ^ SBP_START_DEVICE_EVT);
}
if (events & SBP_PERIODIC_EVT) {
// Restart timer
if (SBP_PERIODIC_EVT_PERIOD) {
osal_start_timerEx(simpleBLEPeripheral_TaskID, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD);
}
// Perform periodic application task
performPeriodicTask();
return (events ^ SBP_PERIODIC_EVT);
}
if (events & SBP_ZEKEZANG_EVT) {
uint8 initial_advertising_enable = FALSE;
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8), &initial_advertising_enable);
return (events ^ SBP_ZEKEZANG_EVT);
}
if (events & SBP_SEND_IRDATA_EVT) {
HalLcdWriteString("send plan complete...", HAL_LCD_LINE_4);
return (events ^ SBP_SEND_IRDATA_EVT);
}
if (events & SBP_ADV_IN_CONNECTION_EVT) {
uint8 turnOnAdv = TRUE;
// Turn on advertising while in a connection
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8), &turnOnAdv);
return (events ^ SBP_ADV_IN_CONNECTION_EVT);
}
return 0;
}