/********************************************************************* * @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 CyclingService_ProcessEvent * * @brief process incoming event. * * @param task_id - OSAL task id. * * @param events - event bit(s) set for the task(s) * * @return none */ uint16 CyclingService_ProcessEvent( uint8 task_id, uint16 events ) { VOID task_id; if ( events & SYS_EVENT_MSG ) { uint8 *pMsg; if ( (pMsg = osal_msg_receive( cyclingService_TaskID )) != NULL ) { cycling_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 & CSC_CMD_IND_SEND_EVT ) { GATT_Indication( connectionHandle, &cscCmdInd, FALSE, cyclingService_TaskID ); // Set Control Point Cfg done scOpInProgress = FALSE; return ( events ^ CSC_CMD_IND_SEND_EVT ); } return 0; }
/********************************************************************* * @fn HidEmuKbd_ProcessEvent * * @brief HidEmuKbd 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 HidEmuKbd_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( hidEmuKbdTaskId )) != NULL ) { hidEmuKbd_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 ) { return ( events ^ START_DEVICE_EVT ); } return 0; }
/** * @brief Central Profile Task event processing function. * * @param taskId - Task ID * @param events - Events. * * @return events not processed */ uint16 GAPCentralRole_ProcessEvent( uint8 taskId, uint16 events ) { if ( events & SYS_EVENT_MSG ) { uint8 *pMsg; if ( (pMsg = osal_msg_receive( gapCentralRoleTaskId )) != NULL ) { gapCentralRole_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 & GAP_EVENT_SIGN_COUNTER_CHANGED ) { // Sign counter changed, save it to NV VOID osal_snv_write( BLE_NVID_SIGNCOUNTER, sizeof( uint32 ), &gapCentralRoleSignCounter ); return ( events ^ GAP_EVENT_SIGN_COUNTER_CHANGED ); } // Discard unknown events return 0; }
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; };
void MT_UartProcessZToolData ( uint8 port, uint8 event ) { uint8 flag=0,i,j=0; //flag是判断有没有收到数据,j记录数据长度 uint8 buf[128]; //串口buffer最大缓冲默认是128,我们这里用128. (void)event; // Intentionally unreferenced parameter while (Hal_UART_RxBufLen(port)) //检测串口数据是否接收完成 { HalUARTRead (port,&buf[j], 1); //把数据接收放到buf中 j++; //记录字符数 flag=1; //已经从串口接收到信息 } if(flag==1) //已经从串口接收到信息 { /* Allocate memory for the data */ //分配内存空间,为机构体内容+数据内容+1个记录长度的数据 pMsg = (mtOSALSerialData_t *)osal_msg_allocate( sizeof ( mtOSALSerialData_t )+j+1); //事件号用原来的CMD_SERIAL_MSG pMsg->hdr.event = CMD_SERIAL_MSG; pMsg->msg = (uint8*)(pMsg+1); // 把数据定位到结构体数据部分 pMsg->msg [0]= j; //给上层的数据第一个是长度 for(i=0;i<j;i++) //从第二个开始记录数据 pMsg->msg [i+1]= buf[i]; osal_msg_send( App_TaskID, (byte *)pMsg ); //登记任务,发往上层 /* deallocate the msg */ osal_msg_deallocate ( (uint8 *)pMsg ); //释放内存 } }
/************************************************************************************************** * @fn Hal_ProcessEvent * * @brief Hal Process Event * * @param task_id - Hal TaskId * events - events * * @return None **************************************************************************************************/ uint16 Hal_ProcessEvent( uint8 task_id, uint16 events ) { uint8 *msgPtr; (void)task_id; // Intentionally unreferenced parameter //--------------------------------------------------------------------------// // processing the system message //--------------------------------------------------------------------------// if ( events & SYS_EVENT_MSG ) { msgPtr = osal_msg_receive(Hal_TaskID); while (msgPtr) { /* Do something here - for now, just deallocate the msg and move on */ /* De-allocate */ osal_msg_deallocate( msgPtr ); /* Next */ msgPtr = osal_msg_receive( Hal_TaskID ); } return events ^ SYS_EVENT_MSG; } return 0; }
/************************************************************************************************** * @fn MHMSSysEvtMsg * * @brief This function is called by MHMSAppEvt() to process all of the pending OSAL messages. * * input parameters * * None. * * output parameters * * None. * * @return None. ************************************************************************************************** */ static void MHMSSysEvtMsg(void) { uint8 *msg; while ((msg = osal_msg_receive(MHMSTaskId))) { switch (*msg) { #if TVSA_DATA_CNF //MHMS Question what is this for? case AF_DATA_CONFIRM_CMD: if (ZSuccess != ((afDataConfirm_t *)msg)->hdr.status) { if (0 == ++MHMSCnfErrCnt) { MHMSCnfErrCnt = 255; } } break; #endif case AF_INCOMING_MSG_CMD: //MHMS this a router processing the incomming command from the coordinator MHMSAfMsgRx((afIncomingMSGPacket_t *)msg); break; case ZDO_STATE_CHANGE: MHMSZdoStateChange(); break; default: break; } (void)osal_msg_deallocate(msg); // Receiving task is responsible for releasing the memory. } }
/********************************************************************* * @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 Hal_ProcessEvent * * @brief Hal Process Event * * @param task_id - Hal TaskId * events - events * * @return None **************************************************************************************************/ uint16 Hal_ProcessEvent( uint8 task_id, uint16 events ) { uint8 *msgPtr; (void)task_id; // Intentionally unreferenced parameter if ( events & SYS_EVENT_MSG ) { msgPtr = osal_msg_receive(Hal_TaskID); while (msgPtr) { /* Do something here - for now, just deallocate the msg and move on */ /* De-allocate */ osal_msg_deallocate( msgPtr ); /* Next */ msgPtr = osal_msg_receive( Hal_TaskID ); } return events ^ SYS_EVENT_MSG; } if ( events & HAL_LED_BLINK_EVENT ) { #if (defined (BLINK_LEDS)) && (HAL_LED == TRUE) HalLedUpdate(); #endif /* BLINK_LEDS && HAL_LED */ return events ^ HAL_LED_BLINK_EVENT; } if (events & HAL_KEY_EVENT) { #if (defined HAL_KEY) && (HAL_KEY == TRUE) /* Check for keys */ HalKeyPoll(); /* if interrupt disabled, do next polling */ if (!Hal_KeyIntEnable) { osal_start_timerEx( Hal_TaskID, HAL_KEY_EVENT, 100); } #endif // HAL_KEY return events ^ HAL_KEY_EVENT; } #ifdef POWER_SAVING if ( events & HAL_SLEEP_TIMER_EVENT ) { halRestoreSleepLevel(); return events ^ HAL_SLEEP_TIMER_EVENT; } #endif /* Nothing interested, discard the message */ return 0; }
/********************************************************************* * @fn afBuildMSGIncoming * * @brief Build the message for the app * * @param * * @return pointer to next in data buffer */ static void afBuildMSGIncoming( aps_FrameFormat_t *aff, endPointDesc_t *epDesc, zAddrType_t *SrcAddress, uint16 SrcPanId, NLDE_Signal_t *sig, uint8 nwkSeqNum, uint8 SecurityUse, uint32 timestamp, uint8 radius ) { afIncomingMSGPacket_t *MSGpkt; const uint8 len = sizeof( afIncomingMSGPacket_t ) + aff->asduLength; uint8 *asdu = aff->asdu; MSGpkt = (afIncomingMSGPacket_t *)osal_msg_allocate( len ); if ( MSGpkt == NULL ) { return; } MSGpkt->hdr.event = AF_INCOMING_MSG_CMD; MSGpkt->groupId = aff->GroupID; MSGpkt->clusterId = aff->ClusterID; afCopyAddress( &MSGpkt->srcAddr, SrcAddress ); MSGpkt->srcAddr.endPoint = aff->SrcEndPoint; MSGpkt->endPoint = epDesc->endPoint; MSGpkt->wasBroadcast = aff->wasBroadcast; MSGpkt->LinkQuality = sig->LinkQuality; MSGpkt->correlation = sig->correlation; MSGpkt->rssi = sig->rssi; MSGpkt->SecurityUse = SecurityUse; MSGpkt->timestamp = timestamp; MSGpkt->nwkSeqNum = nwkSeqNum; MSGpkt->macSrcAddr = aff->macSrcAddr; MSGpkt->macDestAddr = aff->macDestAddr; MSGpkt->srcAddr.panId = SrcPanId; MSGpkt->cmd.TransSeqNumber = 0; MSGpkt->cmd.DataLength = aff->asduLength; MSGpkt->radius = radius; if ( MSGpkt->cmd.DataLength ) { MSGpkt->cmd.Data = (uint8 *)(MSGpkt + 1); osal_memcpy( MSGpkt->cmd.Data, asdu, MSGpkt->cmd.DataLength ); } else { MSGpkt->cmd.Data = NULL; } #if defined ( MT_AF_CB_FUNC ) // If ZDO or SAPI have registered for this endpoint, dont intercept it here if (AFCB_CHECK(CB_ID_AF_DATA_IND, *(epDesc->task_id))) { MT_AfIncomingMsg( (void *)MSGpkt ); // Release the memory. osal_msg_deallocate( (void *)MSGpkt ); } else #endif { // Send message through task message. osal_msg_send( *(epDesc->task_id), (uint8 *)MSGpkt ); } }
/** * @brief Central Profile Task event processing function. * * @param taskId - Task ID * @param events - Events. * * @return events not processed */ uint16 GAPCentralRole_ProcessEvent( uint8 taskId, uint16 events ) { if ( events & SYS_EVENT_MSG ) { uint8 *pMsg; if ( (pMsg = osal_msg_receive( gapCentralRoleTaskId )) != NULL ) { gapCentralRole_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 & GAP_EVENT_SIGN_COUNTER_CHANGED ) { // Sign counter changed, save it to NV VOID osal_snv_write( BLE_NVID_SIGNCOUNTER, sizeof( uint32 ), &gapCentralRoleSignCounter ); return ( events ^ GAP_EVENT_SIGN_COUNTER_CHANGED ); } if ( events & START_ADVERTISING_EVT ) { if ( gapRole_AdvEnabled ) { gapAdvertisingParams_t params; // Setup advertisement parameters params.eventType = gapRole_AdvEventType; params.initiatorAddrType = gapRole_AdvDirectType; VOID osal_memcpy( params.initiatorAddr, gapRole_AdvDirectAddr, B_ADDR_LEN ); params.channelMap = gapRole_AdvChanMap; params.filterPolicy = gapRole_AdvFilterPolicy; if ( GAP_MakeDiscoverable( gapRole_TaskID, ¶ms ) != SUCCESS ) { gapRole_state = GAPROLE_ERROR; // Notify the application if ( pGapCentralRoleCB && pGapCentralRoleCB->broadcastCB ) { pGapCentralRoleCB->broadcastCB( gapRole_state ); } } } return ( events ^ START_ADVERTISING_EVT ); } // Discard unknown events return 0; }
/************************************************************************************************** * @fn zapSBL_SysEvtMsg * * @brief This function is called by zapSBL_Evt() to process all pending OSAL messages. * * input parameters * * None. * * output parameters * * None. * * @return None. ************************************************************************************************** */ static void zapSBL_SysEvtMsg(void) { uint8 *msg; while ((msg = osal_msg_receive(zapSBL_TaskId))) { (void)osal_msg_deallocate(msg); // Receiving task is responsible for releasing the memory. } }
/********************************************************************* * @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 SimpleBLECentral_ProcessEvent * * @brief Simple BLE Central 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 SimpleBLECentral_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( simpleBLETaskId )) != NULL ) { simpleBLECentral_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 GAPCentralRole_StartDevice( (gapCentralRoleCB_t *) &simpleBLERoleCB ); // Register with bond manager after starting device GAPBondMgr_Register( (gapBondCBs_t *) &simpleBLEBondCB ); return ( events ^ START_DEVICE_EVT ); } if ( events & START_DISCOVERY_EVT ) { simpleBLECentralStartDiscovery( ); return ( events ^ START_DISCOVERY_EVT ); } if ( events & SBP_PERIODIC_EVT ) { // Restart timer if ( SBP_PERIODIC_EVT_PERIOD && simpleBLEState == BLE_STATE_CONNECTED ) { osal_start_timerEx( simpleBLETaskId, SBP_PERIODIC_EVT, SBP_PERIODIC_EVT_PERIOD ); } // Perform periodic application task performPeriodicTask(); return (events ^ SBP_PERIODIC_EVT); } // Discard unknown events return 0; }
/************************************************************************************************** * @fn afRetrieve * * @brief This function retrieves the data of a huge incoming message. On an failure during * the retrieval, the incoming message is freed. Otherwise, the incoming message is * forwarded to the corresponding task. * * input parameters * * @param pMsg - Pointer to the incoming AF message. * @param taskId - The task ID corresponding to the destination endpoint of the message. * * output parameters * * @param pMsg->cmd.Data - The incoming message data buffer member is filled. * * @return None. ************************************************************************************************** */ static void afRetrieve(uint8 taskId, afIncomingMSGPacket_t *pMsg) { #define ZAP_AF_RTV_MSG_HDR 7 // Retrieve message header length. #define ZAP_AF_RTV_RPY_HDR 2 // Retrieve-reply message header length. #define ZAP_AF_RTV_DAT_MAX (MT_RPC_DATA_MAX - ZAP_AF_RTV_RPY_HDR) uint16 idx = 0, len = pMsg->cmd.DataLength; uint8 *pBuf, rtrn, tmpLen = 0; do { /* This trick to pre-decrement (with zero on the first pass) allows the while() test to * succeed and loop to send a zero data length message which will trigger the ZNP to * de-allocate the huge incoming message being held. */ len -= tmpLen; idx += tmpLen; if (len > ZAP_AF_RTV_DAT_MAX) { tmpLen = ZAP_AF_RTV_DAT_MAX; } else { tmpLen = len; } if ((pBuf = zap_msg_allocate(ZAP_AF_RTV_MSG_HDR, ((uint8)MT_RPC_SYS_AF | MT_RPC_CMD_SREQ), MT_AF_DATA_RETRIEVE)) == NULL) { rtrn = afStatus_MEM_FAIL; break; } pBuf[0] = BREAK_UINT32(pMsg->timestamp, 0); pBuf[1] = BREAK_UINT32(pMsg->timestamp, 1); pBuf[2] = BREAK_UINT32(pMsg->timestamp, 2); pBuf[3] = BREAK_UINT32(pMsg->timestamp, 3); pBuf[4] = LO_UINT16(idx); pBuf[5] = HI_UINT16(idx); pBuf[6] = tmpLen; zapPhySend(zapAppPort, pBuf); rtrn = (afStatus_t)ZAP_SRSP_STATUS(pBuf); (void)osal_memcpy(pMsg->cmd.Data+idx, pBuf+ZAP_AF_RTV_RPY_HDR, tmpLen); zap_msg_deallocate(&pBuf); } while ((rtrn == afStatus_SUCCESS) && len); if (rtrn == afStatus_SUCCESS) { (void)osal_msg_send(taskId, (uint8 *)pMsg); } else { (void)osal_msg_deallocate((uint8 *)pMsg); } }
uint16 DisplayTaskEventLoop(uint8 task_id, uint16 events) { Dis_Msg_t *msg = NULL; if(events & SYS_EVENT_MSG) { msg = (Dis_Msg_t *)osal_msg_receive(task_id); while(msg) { switch(msg->hdr.event) { case DIS_UPDATE: if(false == IS_Flag_Valid(DISPLAY_UPDATE_LOCK)){ dispaly_update_handler(gSystem_t, cur_menu->id, msg->value); } break; case DIS_JUMP: dispaly_update_handler(gSystem_t, (menu_id_t)msg->value, 0); break; default: break; } osal_msg_deallocate((uint8 *) msg); msg = (Dis_Msg_t *)osal_msg_receive(task_id); } return (events ^ SYS_EVENT_MSG); } if(events & VOL_DIS_BACK_MSG){ vol_dis_timeout_handler(); return (events ^ VOL_DIS_BACK_MSG); } if(events & SRC_MENU_TIMEOUT_MSG){ src_dis_timeout_handler(); return (events ^ SRC_MENU_TIMEOUT_MSG); } if(events & SRC_MENU_TO_FILE_LIST_TIMEOUT_MSG){ src_menu_to_file_list_handler(); return(events ^ SRC_MENU_TO_FILE_LIST_TIMEOUT_MSG); } return 0; }
/********************************************************************* * @fn StubAPS_ProcessEvent() * * @brief Main event loop for Stub APS task. This function should be called * at periodic intervals when event occur. * * @param task_id - Task ID * @param events - Bitmap of events * * @return none */ UINT16 StubAPS_ProcessEvent( uint8 task_id, uint16 events ) { (void)task_id; // Intentionally unreferenced parameter if ( events & SYS_EVENT_MSG ) { osal_event_hdr_t *msg_ptr; while ( (msg_ptr = (osal_event_hdr_t *)osal_msg_receive( StubAPS_TaskID )) != NULL ) { if ( msg_ptr->event == MAC_MCPS_DATA_CNF ) { INTERP_DataConfirm( (ZMacDataCnf_t *)msg_ptr ); } else if ( msg_ptr->event == MAC_MCPS_DATA_IND ) { INTERP_DataIndication( (macMcpsDataInd_t *)msg_ptr ); } osal_msg_deallocate( (uint8 *)msg_ptr ); } // Return unproccessed events return ( events ^ SYS_EVENT_MSG ); } if ( events & CHANNEL_CHANGE_EVT ) { // try to change to the new channel ZStatus_t status = StubAPS_SetNewChannel( newChannel ); if ( status != ZSuccess ) { // turn MAC receiver back on uint8 rxOnIdle = true; ZMacSetReq( ZMacRxOnIdle, &rxOnIdle ); // set NWK task to run nwk_setStateIdle( FALSE ); channelChangeInProgress = FALSE; } // notify the application StubAPS_NotifyApp( status ); return ( events ^ CHANNEL_CHANGE_EVT ); } // If reach here, the events are unknown // Discard or make more handlers return 0; } /* StubAPS_ProcessEvent() */
/********************************************************************* * @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 SampleApp_ProcessEvent * @brief Generic 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 SampleApp_ProcessEvent( uint8 task_id, uint16 events ) { afIncomingMSGPacket_t *MSGpkt; (void)task_id; // Intentionally unreferenced parameter if ( events & SYS_EVENT_MSG ) { MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( SampleApp_TaskID ); //Databuf = osal_mem_alloc(MSGpkt->cmd.DataLength); while ( MSGpkt ) { switch ( MSGpkt->hdr.event ) { // Received when a messages is received (OTA) for this endpoint case AF_INCOMING_MSG_CMD: SampleApp_MessageMSGCB( MSGpkt ); break; default: break; } // Release the memory osal_msg_deallocate((uint8 *)MSGpkt ); // Next - if one is available MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( SampleApp_TaskID ); } // return unprocessed events return (events ^ SYS_EVENT_MSG); } // Send a message out - This event is generated by a timer // (setup in SampleApp_Init()). if ( events & SAMPLEAPP_SEND_PERIODIC_MSG_EVT ) { SampleApp_SendPeriodicMessage(); //发送数据函数 // Setup to send message again in normal period (+ a little jitter) osal_start_timerEx( SampleApp_TaskID, SAMPLEAPP_SEND_PERIODIC_MSG_EVT, (SAMPLEAPP_SEND_PERIODIC_MSG_TIMEOUT + (osal_rand() & 0x00FF)) ); // return unprocessed events return (events ^ SAMPLEAPP_SEND_PERIODIC_MSG_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; }
/********************************************************************* * @fn zclHomelink_event_loop * * @brief Event Loop Processor for zclGeneral. * * @param none * * @return none */ uint16 zclHomelink_event_loop( uint8 task_id, uint16 events ) { afIncomingMSGPacket_t *MSGpkt; (void)task_id; // Intentionally unreferenced parameter if ( events & SYS_EVENT_MSG ) { while ( (MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( zclHomelink_TaskID )) ) { switch ( MSGpkt->hdr.event ) { case ZCL_INCOMING_MSG: // Incoming ZCL Foundation command/response messages zclHomelink_ProcessIncomingMsg( (zclIncomingMsg_t *)MSGpkt ); break; case KEY_CHANGE: zclHomelink_HandleKeys( ((keyChange_t *)MSGpkt)->state, ((keyChange_t *)MSGpkt)->keys ); break; case ZDO_STATE_CHANGE: zclHomelink_NwkState = (devStates_t)(MSGpkt->hdr.status); // now on the network if ( (zclHomelink_NwkState == DEV_ZB_COORD) || (zclHomelink_NwkState == DEV_ROUTER) || (zclHomelink_NwkState == DEV_END_DEVICE) ) { if (initState == 0) { initState = 1; } } break; default: break; } // Release the memory osal_msg_deallocate( (uint8 *)MSGpkt ); } // return unprocessed events return (events ^ SYS_EVENT_MSG); } // Discard unknown events return 0; }
/*************************************************************************************************** * @fn MT_ProcessDebugMsg * * @brief Build and send a debug message. * * @param byte *data - pointer to the data portion of the debug message * * @return void ***************************************************************************************************/ void MT_ProcessDebugMsg( mtDebugMsg_t *msg ) { byte *msg_ptr; byte dataLen; uint8 buf[11]; uint8 *pBuf; /* Calculate the data length based */ dataLen = 5 + (msg->numParams * sizeof ( uint16 )); /* Get a message buffer to build the debug message */ msg_ptr = osal_msg_allocate( (byte)(SPI_0DATA_MSG_LEN + dataLen + 1) ); if ( msg_ptr ) { /* Build the message */ pBuf = buf; *pBuf++ = msg->compID; *pBuf++ = msg->severity; *pBuf++ = msg->numParams; if ( msg->numParams >= 1 ) { *pBuf++ = LO_UINT16( msg->param1 ); *pBuf++ = HI_UINT16( msg->param1 ); } if ( msg->numParams >= 2 ) { *pBuf++ = LO_UINT16( msg->param2 ); *pBuf++ = HI_UINT16( msg->param2 ); } if ( msg->numParams == 3 ) { *pBuf++ = LO_UINT16( msg->param3 ); *pBuf++ = HI_UINT16( msg->param3 ); } *pBuf++ = LO_UINT16( msg->timestamp ); *pBuf = HI_UINT16( msg->timestamp ); #ifdef MT_UART_DEFAULT_PORT /* Debug message is set to AREQ CMD 0x80 for now */ /* Build and send back the response */ MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_AREQ | (uint8)MT_RPC_SYS_DBG), 0x80, dataLen, buf); #endif osal_msg_deallocate( msg_ptr ); } }
/********************************************************************* * @brief Task Event Processor function. * * Internal function defined in broadcaster.h. */ uint16 GAPRole_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( gapRole_TaskID )) != NULL ) { gapRole_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_ADVERTISING_EVT ) { if ( gapRole_AdvEnabled ) { gapAdvertisingParams_t params; // Setup advertisement parameters params.eventType = gapRole_AdvEventType; params.initiatorAddrType = gapRole_AdvDirectType; VOID osal_memcpy( params.initiatorAddr, gapRole_AdvDirectAddr, B_ADDR_LEN ); params.channelMap = gapRole_AdvChanMap; params.filterPolicy = gapRole_AdvFilterPolicy; if ( GAP_MakeDiscoverable( gapRole_TaskID, ¶ms ) != SUCCESS ) { gapRole_state = GAPROLE_ERROR; if ( pGapRoles_AppCGs && pGapRoles_AppCGs->pfnStateChange ) { pGapRoles_AppCGs->pfnStateChange( gapRole_state ); } } } return ( events ^ START_ADVERTISING_EVT ); } // Discard unknown events return 0; }
/*--------------------------------------------------------------------------- * 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 zclSample_event_loop * * @brief Event Loop Processor for zclGeneral. * * @param none * * @return none */ uint16 zclSampleSw_event_loop( uint8 task_id, uint16 events ) { afIncomingMSGPacket_t *MSGpkt; (void)task_id; // Intentionally unreferenced parameter if ( events & SYS_EVENT_MSG ) { while ( (MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( zclSampleSw_TaskID )) ) { switch ( MSGpkt->hdr.event ) { case ZCL_INCOMING_MSG: // Incoming ZCL Foundation command/response messages zclSampleSw_ProcessIncomingMsg( (zclIncomingMsg_t *)MSGpkt ); break; case ZDO_CB_MSG: zclSampleSw_ProcessZDOMsgs( (zdoIncomingMsg_t *)MSGpkt ); break; case KEY_CHANGE: zclSampleSw_HandleKeys( ((keyChange_t *)MSGpkt)->state, ((keyChange_t *)MSGpkt)->keys ); break; default: break; } // Release the memory osal_msg_deallocate( (uint8 *)MSGpkt ); } // return unprocessed events return (events ^ SYS_EVENT_MSG); } if ( events & SAMPLESW_IDENTIFY_TIMEOUT_EVT ) { zclSampleSw_IdentifyTime = 10; zclSampleSw_ProcessIdentifyTimeChange(); return ( events ^ SAMPLESW_IDENTIFY_TIMEOUT_EVT ); } // Discard unknown events return 0; }
/* @fn LoacationApp_ProcessEvent * @brief Generic Application Task event processor. * @param task_id - The OSAL assigned task ID. * @param events - Bit map of events to process. * @return none*/ uint16 LoacationApp_ProcessEvent( uint8 task_id, uint16 events ) { if ( events & SYS_EVENT_MSG ) { afIncomingMSGPacket_t *MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( LoacationApp_TaskID ); while ( MSGpkt != NULL ) { switch ( MSGpkt->hdr.event ) { case KEY_CHANGE: handleKeys( ((keyChange_t *)MSGpkt)->state, ((keyChange_t *)MSGpkt)->keys ); break; case AF_DATA_CONFIRM_CMD: #if !defined( RTR_NWK ) { // This message is received as a confirmation of a data packet sent. // The status is of ZStatus_t type [defined in ZComDef.h] afDataConfirm_t *afDataConfirm = (afDataConfirm_t *)MSGpkt; /* No ACK from the MAC layer implies that mobile device is out of * range of most recent parent. Therefore, begin an orphan scan * to try to find a former parent. * NOTE: To get the fastest action in the process of finding a new * parent, set the MAX_JOIN_ATTEMPTS in ZDApp.c to 1.*/ if(afDataConfirm->hdr.status == ZMacNoACK) LoacationApp_NoACK(); else{}// Some other error -- Do something. } #endif break; case AF_INCOMING_MSG_CMD: processMSGCmd( MSGpkt ); break; case ZDO_STATE_CHANGE: #if defined( POWER_SAVING ) if(rejoinPending) { rejoinPending = FALSE; LoacationApp_Sleep(TRUE); //Ok to resume power saving ops. } #endif break; default: break; } osal_msg_deallocate( (uint8 *)MSGpkt ); MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive(LoacationApp_TaskID); } return (events ^ SYS_EVENT_MSG); // Return unprocessed events. } return 0; // Discard unknown events }