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 debug_str * * @brief * * This feature allows modules to display a debug text string as * applications execute in real-time. This feature will output to * the serial port for display in the Z-Test tool. * * This feature will most likely be compiled out in the production * code in order to save code space. * * @param byte *str_ptr - pointer to null-terminated string * * @return void */ void debug_str( byte *str_ptr ) { mtDebugStr_t *msg; byte mln; byte strLen; // Text string length strLen = (byte)osal_strlen( (void*)str_ptr ); // Debug string message length mln = sizeof ( mtDebugStr_t ) + strLen; // Get a message buffer to build the debug message msg = (mtDebugStr_t *)osal_msg_allocate( mln ); if ( msg ) { // Message type, length msg->hdr.event = CMD_DEBUG_STR; msg->strLen = strLen; // Append message, no terminator msg->pString = (uint8 *)(msg+1); osal_memcpy ( msg->pString, str_ptr, strLen ); osal_msg_send( MT_TaskID, (uint8 *)msg ); } } // debug_str()
/********************************************************************* * @fn ZDO_SendMsgCBs * * @brief De-mux the ZDO_CB_MSG from the ZNP. * * @param inMsg - pointer to the incoming message buffer. * * @return none */ static void ZDO_SendMsgCBs(zdoIncomingMsg_t *inMsg) { ZDO_MsgCB_t *pList = zdoMsgCBs; while ( pList ) { if ( pList->clusterID == inMsg->clusterID ) { zdoIncomingMsg_t *msgPtr; // Send the address to the task msgPtr = (zdoIncomingMsg_t *)osal_msg_allocate( sizeof( zdoIncomingMsg_t ) + inMsg->asduLen ); if ( msgPtr ) { // copy struct osal_memcpy( msgPtr, inMsg, sizeof( zdoIncomingMsg_t )); if ( inMsg->asduLen ) { msgPtr->asdu = (byte*)(((byte*)msgPtr) + sizeof( zdoIncomingMsg_t )); osal_memcpy( msgPtr->asdu, inMsg->asdu, inMsg->asduLen ); } msgPtr->hdr.event = ZDO_CB_MSG; osal_msg_send( pList->taskID, (uint8 *)msgPtr ); } } pList = (ZDO_MsgCB_t *)pList->next; } }
/*************************************************************************************************** * @fn MT_OtaCommandProcessing * * @brief Process all the MT OTA commands that are issued by the OTA Console tool * * @param pBuf - pointer to the msg buffer * * | LEN | CMD0 | CMD1 | DATA | * | 1 | 1 | 1 | 0-255 | * * @return status ***************************************************************************************************/ uint8 MT_OtaCommandProcessing(uint8* pBuf) { uint8 status = MT_RPC_SUCCESS; uint8 len; OTA_MtMsg_t *pMsg; uint8 cmd = pBuf[MT_RPC_POS_CMD1]; if (cmd == MT_OTA_FILE_READ_RSP || cmd == MT_OTA_NEXT_IMG_RSP) { // Forward the message to the task if (OTA_Task != 0xff) { len = pBuf[MT_RPC_POS_LEN]; pMsg = (OTA_MtMsg_t*) osal_msg_allocate(len + sizeof(OTA_MtMsg_t)); if (pMsg) { pMsg->hdr.event = MT_SYS_OTA_MSG; pMsg->cmd = cmd; osal_memcpy(pMsg->data, &pBuf[MT_RPC_POS_DAT0], len); osal_msg_send(OTA_Task, (uint8*) pMsg); } } } else { status = MT_RPC_ERR_COMMAND_ID; } return status; }
static struct UsbISR * createMsgForBind(void) { uint8 * data; uint8 i; struct BindRequestMsg * msgBind = (struct BindRequestMsg *)osal_msg_allocate(sizeof(struct BindRequestMsg) ); msgBind->isr.msg.event = EVENT_USB_ISR; msgBind->destAddr.addrMode = Addr16Bit; data = (uint8 *)msgBind->destAddr.addr.shortAddr; *data = USBF2; data++; *data = USBF2; data = (uint8 *)msgBind->outClusterAddr; for (i=0; i < Z_EXTADDR_LEN+3; i++){ *data = USBF2; data++; } msgBind->inCluster.addrMode = Addr64Bit; data = (uint8 *)msgBind->inCluster.addr.extAddr; for(i=0; i< Z_EXTADDR_LEN; i++){ *data = USBF2; data++; } msgBind->inClusterEP = USBF2; return &(msgBind->isr); }
/********************************************************************* * @fn debug_msg * * @brief * * This feature allows modules to display debug information as * applications execute in real-time. This feature will work similar * to "printf()" but will output to the serial port for display in * the Z-Test tool. * * This feature will most likely be compiled out in the production code * to save code space. * * @param byte compID - Component ID * @param byte severity - CRITICAL(0x01), ERROR(0x02), INFORMATION(0x03) * or TRACE(0x04) * @param byte numParams - number of parameter fields (param1-3) * @param UINT16 param1 - user defined data * @param UINT16 param2 - user defined data * @param UINT16 param3 - user defined data * * @return void */ void debug_msg( byte compID, byte severity, byte numParams, UINT16 param1, UINT16 param2, UINT16 param3 ) { mtDebugMsg_t *mtDebugMsg; UINT16 timestamp; if ( debugThreshold == 0 || debugCompId != compID ) return; // Fill in the timestamp timestamp = 0; // Get a message buffer to build the debug message mtDebugMsg = (mtDebugMsg_t *)osal_msg_allocate( sizeof( mtDebugMsg_t ) ); if ( mtDebugMsg ) { mtDebugMsg->hdr.event = CMD_DEBUG_MSG; mtDebugMsg->compID = compID; mtDebugMsg->severity = severity; mtDebugMsg->numParams = numParams; mtDebugMsg->param1 = param1; mtDebugMsg->param2 = param2; mtDebugMsg->param3 = param3; mtDebugMsg->timestamp = timestamp; osal_msg_send( MT_TaskID, (uint8 *)mtDebugMsg ); } } /* debug_msg() */
/********************************************************************* * @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 ); } }
/*************************************************************************************************** * @fn MT_UartProcessZAppData * * @brief | SOP | CMD | Data Length | FSC | * | 1 | 2 | 1 | 1 | * * Parses the data and determine either is SPI or just simply serial data * then send the data to correct place (MT or APP) * * @param port - UART port * event - Event that causes the callback * * * @return None ***************************************************************************************************/ void MT_UartProcessZAppData ( uint8 port, uint8 event ) { osal_event_hdr_t *msg_ptr; uint16 length = 0; uint16 rxBufLen = Hal_UART_RxBufLen(MT_UART_DEFAULT_PORT); /* If maxZAppBufferLength is 0 or larger than current length the entire length of the current buffer is returned. */ if ((MT_UartMaxZAppBufLen != 0) && (MT_UartMaxZAppBufLen <= rxBufLen)) { length = MT_UartMaxZAppBufLen; } else { length = rxBufLen; } /* Verify events */ if (event == HAL_UART_TX_FULL) { // Do something when TX if full return; } if (event & ( HAL_UART_RX_FULL | HAL_UART_RX_ABOUT_FULL | HAL_UART_RX_TIMEOUT)) { if ( App_TaskID ) { /* If Application is ready to receive and there is something in the Rx buffer then send it up */ if ((MT_UartZAppRxStatus == MT_UART_ZAPP_RX_READY ) && (length != 0)) { /* Disable App flow control until it processes the current data */ MT_UartAppFlowControl (MT_UART_ZAPP_RX_NOT_READY); /* 2 more bytes are added, 1 for CMD type, other for length */ msg_ptr = (osal_event_hdr_t *)osal_msg_allocate( length + sizeof(osal_event_hdr_t) ); if ( msg_ptr ) { msg_ptr->event = SPI_INCOMING_ZAPP_DATA; msg_ptr->status = length; /* Read the data of Rx buffer */ HalUARTRead( MT_UART_DEFAULT_PORT, (uint8 *)(msg_ptr + 1), length ); /* Send the raw data to application...or where ever */ osal_msg_send( App_TaskID, (uint8 *)msg_ptr ); } } } } }
void zapPhySpiPoll(uint8 port) { #if ZAP_SBL_PROXY extern uint8 zapSBL_Active; #endif uint8 pPoll[MT_RPC_FRAME_HDR_SZ]; #if ZAP_SBL_PROXY if (!HAL_ZNP_SRDY_SET() || zapSBL_Active) #else if (!HAL_ZNP_SRDY_SET()) #endif { return; } HAL_ZNP_MRDY_SET(); // MRDY must be set before talking to the slave. osal_memset(pPoll, 0, MT_RPC_FRAME_HDR_SZ); HalSpiWrite(port, pPoll, MT_RPC_FRAME_HDR_SZ); if (getSRDY2(port)) { osal_memset(pPoll, 0, MT_RPC_FRAME_HDR_SZ); HalSpiWrite(port, pPoll, MT_RPC_FRAME_HDR_SZ); if (MT_RPC_CMD_AREQ == (pPoll[MT_RPC_POS_CMD0] & MT_RPC_CMD_TYPE_MASK)) { mtOSALSerialData_t *pMsg = (mtOSALSerialData_t *)osal_msg_allocate(sizeof(mtOSALSerialData_t) + MT_RPC_FRAME_HDR_SZ + *pPoll); if (NULL != pMsg) { pMsg->hdr.event = CMD_SERIAL_MSG; pMsg->hdr.status = port; pMsg->msg = (uint8 *)(pMsg + 1); osal_memcpy(pMsg->msg, pPoll, MT_RPC_FRAME_HDR_SZ); if (*pPoll) { HalSpiWrite(port, pMsg->msg+MT_RPC_POS_DAT0, *pPoll); } HAL_ZNP_MRDY_CLR(); // Faster release of ZNP with redundant mrdy clear here. osal_msg_send(zapTaskId, (uint8 *)pMsg); } else // Cannot leave the slave hanging in its "ready-to-send" state. { HalSpiFlush(port, *pPoll); } } } HAL_ZNP_MRDY_CLR(); }
/************************************************************************************************** * * @fn HalUARTCBack * * @brief This routine handles events of UART * * @param port - serial port that has the event * event - Event that cause the callback * * @return * **************************************************************************************************/ void HalUARTCBack (uint8 port, uint8 event){ /*only idle timeout on rx buffer is handled*/ //printvalue("UART callback evt",event); if ((port == HAL_UART_PORT) && (event == HAL_UART_RX_TIMEOUT)){ mymessage = (uint8*) osal_msg_allocate(sizeof (uint8)); if (mymessage!= NULL){ *mymessage = MSA_UART_RX_TIMEOUT; osal_msg_send(MSA_TaskId,mymessage); } } }
/************************************************************************************************** * @fn afRecv * * @brief This function de-muxes an incoming AF data message. * * input parameters * * @param pBuf - Pointer to the RPC message buffer. * * output parameters * * None. * * @return None. ************************************************************************************************** */ static void afRecv(uint8 *pBuf) { #define ZAP_AF_INC_MSG_HDR 27 #define ZAP_AF_INC_DAT_MAX (MT_RPC_DATA_MAX - ZAP_AF_INC_MSG_HDR) afIncomingMSGPacket_t *pMsg; epList_t *pEP; uint16 tmp; uint8 cmd1 = pBuf[MT_RPC_POS_CMD1]; pBuf += MT_RPC_FRAME_HDR_SZ; if (cmd1 == MT_AF_INCOMING_MSG) { pEP = afFindEndPointDescList(pBuf[7]); tmp = pBuf[16]; } else { pEP = afFindEndPointDescList(pBuf[16]); tmp = BUILD_UINT16(pBuf[25], pBuf[26]); } if ((pEP == NULL) || (NULL == (pMsg = (afIncomingMSGPacket_t *)osal_msg_allocate(sizeof(afIncomingMSGPacket_t) + tmp)))) { return; } pMsg->hdr.event = AF_INCOMING_MSG_CMD; pBuf = afIncMsgPktParse(cmd1, pBuf, pMsg); #if ZAP_AF_DATA_REQ_FRAG if (pMsg->cmd.DataLength > ZAP_AF_INC_DAT_MAX) { afRetrieve(*(pEP->epDesc->task_id), pMsg); } else #endif { if (pMsg->cmd.DataLength) { (void)osal_memcpy(pMsg->cmd.Data, pBuf, pMsg->cmd.DataLength); } else { pMsg->cmd.Data = NULL; } (void)osal_msg_send(*(pEP->epDesc->task_id), (uint8 *)pMsg); } }
/************************************************************************************************** * @fn zapUtilParseKeyInd * * @brief This function parses a packed keyEstablishmentInd_t. * * input parameters * * @param pBuf - A buffer containing a packed keyEstablishmentInd_t. * * output parameters * * None. * * @return None. ************************************************************************************************** */ static void zapUtilParseKeyInd(uint8 *pBuf) { keyEstablishmentInd_t *pInd; // Send osal message to the application. if (NULL != (pInd = (keyEstablishmentInd_t *)osal_msg_allocate(sizeof(keyEstablishmentInd_t)))) { pInd->hdr.event = pBuf[1]; pInd->hdr.status = pBuf[2]; pInd->waitTime = pBuf[3]; pInd->keyEstablishmentSuite = BUILD_UINT16(pBuf[4], pBuf[5]); osal_msg_send(pBuf[0], (uint8 *)pInd); } }
/*************************************************************************************************** * @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 ); } }
/********************************************************************* * @fn SAPI_SendCback * * @brief Sends a message to the sapi task ( itself ) so that a * callback can be generated later. * * @return none */ void SAPI_SendCback( uint8 event, uint8 status, uint16 data ) { sapi_CbackEvent_t *pMsg; pMsg = (sapi_CbackEvent_t *)osal_msg_allocate( sizeof(sapi_CbackEvent_t) ); if( pMsg ) { pMsg->hdr.event = event; pMsg->hdr.status = status; pMsg->data = data; osal_msg_send( sapi_TaskID, (uint8 *)pMsg ); } }
/****************************************************************************** * @fn StubAPS_NotifyApp * * @brief This function sends an OSAL message to the Application task. * * @param status - command status * * @return none */ static void StubAPS_NotifyApp( uint8 status ) { osal_event_hdr_t *msgPtr; // Notify the application task msgPtr = (osal_event_hdr_t *)osal_msg_allocate( sizeof(osal_event_hdr_t) ); if ( msgPtr ) { msgPtr->event = SAPS_CHANNEL_CHANGE; msgPtr->status = status; osal_msg_send( appTaskID, (uint8 *)msgPtr ); } } /* StubAPS_NotifyApp */
uint8 OnBoard_SendHall( void ) { uint8 *msgPtr; if (registeredHallTaskID != NO_TASK_ID) { msgPtr = (uint8 *)osal_msg_allocate(1); if (msgPtr) { osal_msg_send(registeredHallTaskID, msgPtr); //HalLedBlink(HAL_LED_2, 5, HAL_LED_DEFAULT_DUTY_CYCLE, HAL_LED_DEFAULT_FLASH_TIME); } return (SUCCESS); } else return (FAILURE); }
/********************************************************************* * @fn gapCentralRole_timerCB * * @brief OSAL timer callback function * * @param pData - Data pointer * * @return none */ static void gapCentralRole_timerCB( uint8 *pData ) { gapCentralRoleRssiEvent_t *pMsg; // Timer has expired so clear timer ID ((gapCentralRoleRssi_t *) pData)->timerId = INVALID_TIMER_ID; // Send OSAL message pMsg = (gapCentralRoleRssiEvent_t *) osal_msg_allocate( sizeof(gapCentralRoleRssiEvent_t) ); if ( pMsg ) { pMsg->hdr.event = GAPCENTRALROLE_RSSI_MSG_EVT; pMsg->pRssi = (gapCentralRoleRssi_t *) pData; osal_msg_send ( gapCentralRoleTaskId, (uint8 *) pMsg ); } }
/*************************************************************************************************** * @fn MT_AppPB_ZCLCfg * * @brief Process MT_APP_PB_ZCL_CFG command * * @param pBuf - pointer to the received buffer * * @return void ***************************************************************************************************/ static void MT_AppPB_ZCLCfg( uint8 *pBuf ) { uint8 retValue = ZFailure; uint8 appEP; endPointDesc_t *epDesc; mtAppPB_ZCLCfg_t *cmd; uint8 cmdId; /* Parse the RPC header */ cmdId = pBuf[MT_RPC_POS_CMD1]; pBuf += MT_RPC_FRAME_HDR_SZ; /* Application End Point */ appEP = *pBuf++; /* Look up the endpoint */ epDesc = afFindEndPointDesc( appEP ); if ( epDesc ) { /* Build and send the message to the APP */ cmd = (mtAppPB_ZCLCfg_t *)osal_msg_allocate( sizeof( mtAppPB_ZCLCfg_t ) ); if ( cmd ) { /* Build and send message to the app */ cmd->hdr.event = MT_SYS_APP_PB_ZCL_CMD; /* PB ZCL command type*/ cmd->type = MT_APP_PB_ZCL_CMD_CFG; /* PB ZCL Config Mode */ cmd->mode = *pBuf++; /* Send the message */ osal_msg_send( *(epDesc->task_id), (uint8 *)cmd ); /* Info for response */ retValue = ZSuccess; } } /* Build and send back the response */ MT_BuildAndSendZToolResponse( ( (uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_APP ), cmdId, 1, &retValue ); }
/*************************************************************************************************** * @fn MT_TransportAlloc * * @brief Allocate memory for transport msg * * @param uint8 cmd0 - The first byte of the MT command id containing the command type and subsystem. * uint8 len - length * * @return pointer the allocated memory or NULL if fail to allocate the memory ***************************************************************************************************/ uint8 *MT_TransportAlloc(uint8 cmd0, uint8 len) { uint8 *p; (void)cmd0; // Intentionally unreferenced parameter /* Allocate a buffer of data length + SOP+CMD+FCS (5bytes) */ p = osal_msg_allocate(len + SPI_0DATA_MSG_LEN); if (p) { p++; /* Save space for SOP_VALUE, msg structure */ return p; } else { return NULL; } }
void Send_DisplayTask_Msg(dis_event_t event, uint8 value) { uint8 result = 0; gDisplay = (Dis_Msg_t *)osal_msg_allocate(sizeof(Dis_Msg_t)); if(NULL == gDisplay) { SYS_TRACE("no memory for dispaly msg\r\n"); return; } gDisplay->hdr.event = (uint8)event; gDisplay->value = value; result = osal_msg_send(gDisTaskID,(uint8 *)gDisplay); if(result != SUCCESS) { SYS_TRACE("send display msg fail\r\n"); } }
void Send_MdcTask_Msg(Mdc_event_t event, uint8 value) { uint8 result = 0; gMdcMsg_t = (Mdc_Task_Msg_t *)osal_msg_allocate(sizeof(Mdc_Task_Msg_t)); if(NULL == gMdcMsg_t) { SYS_TRACE("no memory for mdc msg\r\n"); return; } gMdcMsg_t->hdr.event = (uint8)event; gMdcMsg_t->value = value; result = osal_msg_send(gMdcTaskID,(uint8 *)gMdcMsg_t); if(result != SUCCESS) { SYS_TRACE("send mdc msg fail\r\n"); } }
/************************************************************************************************** * @fn afCnf * * @brief This function de-muxes an incoming AF data confirm message. * * input parameters * * @param pBuf - Pointer to the RPC message buffer. * * output parameters * * None. * * @return None. ************************************************************************************************** */ static void afCnf(uint8 *pBuf) { pBuf += MT_RPC_FRAME_HDR_SZ; epList_t *pEP = afFindEndPointDescList(pBuf[1]); if (NULL != pEP) { afDataConfirm_t *pMsg = (afDataConfirm_t *)osal_msg_allocate(sizeof(afDataConfirm_t)); if (NULL != pMsg) { pMsg->hdr.event = AF_DATA_CONFIRM_CMD; pMsg->hdr.status = *pBuf++; pMsg->endpoint = *pBuf++; pMsg->transID = *pBuf; osal_msg_send(*(pEP->epDesc->task_id), (uint8 *)pMsg); } } }
/*************************************************************************************************** * @fn MT_AppMsg * * @brief Process APP_MSG command * * @param pBuf - pointer to the received buffer * * @return void ***************************************************************************************************/ static void MT_AppMsg(uint8 *pBuf) { uint8 retValue = ZFailure; uint8 endpoint; endPointDesc_t *epDesc; mtSysAppMsg_t *msg; uint8 cmdId, dataLen; /* parse header */ dataLen = pBuf[MT_RPC_POS_LEN]; cmdId = pBuf[MT_RPC_POS_CMD1]; pBuf += MT_RPC_FRAME_HDR_SZ; /* Get the endpoint and skip past it.*/ endpoint = *pBuf++; dataLen--; /* Look up the endpoint */ epDesc = afFindEndPointDesc( endpoint ); if (epDesc) { /* Build and send the message to the APP */ msg = (mtSysAppMsg_t *)osal_msg_allocate(sizeof(mtSysAppMsg_t) + (dataLen)); if ( msg ) { /* Build and send message up the app */ msg->hdr.event = MT_SYS_APP_MSG; msg->endpoint = endpoint; msg->appDataLen = dataLen; msg->appData = (uint8*)(msg+1); osal_memcpy( msg->appData, pBuf, dataLen); osal_msg_send( *(epDesc->task_id), (uint8 *)msg ); /* Info for response */ retValue = ZSuccess; } } /* Build and send back the response */ MT_BuildAndSendZToolResponse(((uint8)MT_RPC_CMD_SRSP | (uint8)MT_RPC_SYS_APP), cmdId, 1, &retValue); }
/********************************************************************* * @fn OnBoard_SendKeys * * @brief Send "Key Pressed" message to application. * * @param keys - keys that were pressed * state - shifted * * @return status *********************************************************************/ uint8 OnBoard_SendKeys( uint8 keys, uint8 state ) { keyChange_t *msgPtr; if ( registeredKeysTaskID != NO_TASK_ID ) { // Send the address to the task msgPtr = (keyChange_t *)osal_msg_allocate( sizeof(keyChange_t) ); if ( msgPtr ) { msgPtr->hdr.event = KEY_CHANGE; msgPtr->state = state; msgPtr->keys = keys; osal_msg_send( registeredKeysTaskID, (uint8 *)msgPtr ); } return ( ZSuccess ); } else return ( ZFailure ); }
/********************************************************************* * @fn afReflectError * * @brief This function will generate the Reflect Error message to * the application. * * @param srcEP - Source Endpoint * @param dstAddrMode - mode of dstAdd - 0 - normal short addr, 1 - group Address * @param dstAddr - intended destination * @param dstEP - Destination Endpoint * @param transID - transaction ID from APSDE_DATA_REQUEST * @param status - status of APSDE_DATA_REQUEST * * @return none */ void afReflectError( uint8 srcEP, uint8 dstAddrMode, uint16 dstAddr, uint8 dstEP, uint8 transID, ZStatus_t status ) { endPointDesc_t *epDesc; afReflectError_t *msgPtr; // Find the endpoint description epDesc = afFindEndPointDesc( srcEP ); if ( epDesc == NULL ) return; // Determine the incoming command type msgPtr = (afReflectError_t *)osal_msg_allocate( sizeof(afReflectError_t) ); if ( msgPtr ) { // Build the Data Confirm message msgPtr->hdr.event = AF_REFLECT_ERROR_CMD; msgPtr->hdr.status = status; msgPtr->endpoint = dstEP; msgPtr->transID = transID; msgPtr->dstAddrMode = dstAddrMode; msgPtr->dstAddr = dstAddr; #if defined ( MT_AF_CB_FUNC ) /* If MT has subscribed for this callback, don't send as a message. */ if ( AFCB_CHECK( CB_ID_AF_REFLECT_ERROR, *(epDesc->task_id) ) ) { /* Send callback if it's subscribed */ MT_AfReflectError( (void *)msgPtr ); /* Release the memory. */ osal_msg_deallocate( (void *)msgPtr ); } else #endif { /* send message through task message */ osal_msg_send( *(epDesc->task_id), (uint8 *)msgPtr ); } } }
/*************************************************************************************************** * @fn MT_ProcessSrngEvent * * @brief * * Process SRNG Event Messages. * * @param None * * @return None ***************************************************************************************************/ void MT_ProcessSrngEvent(void) { uint8 * msg; osal_event_hdr_t * msg_ptr; msg_ptr = (osal_event_hdr_t *)osal_msg_allocate( MT_RPC_FRAME_HDR_SZ + 4 + sizeof(osal_event_hdr_t) ); msg = msg_ptr + sizeof(osal_event_hdr_t) + 4; if ( msg_ptr ) { msg_ptr->event = CMD_SERIAL_MSG; msg_ptr->status = 4; if(msg) { msg[MT_RPC_POS_LEN] = 4 + MT_RPC_FRAME_HDR_SZ; msg[MT_RPC_POS_CMD0] = MT_RPC_SYS_UTIL; msg[MT_RPC_POS_CMD1] = MT_UTIL_SRNG_GENERATE; } osal_memcpy(msg_ptr + sizeof(osal_event_hdr_t), &msg, 4); } osal_msg_send( MT_TaskID, (uint8 *)msg_ptr ); }
/********************************************************************* * @fn afDataConfirm * * @brief This function will generate the Data Confirm back to * the application. * * @param endPoint - confirm end point * @param transID - transaction ID from APSDE_DATA_REQUEST * @param status - status of APSDE_DATA_REQUEST * * @return none */ void afDataConfirm( uint8 endPoint, uint8 transID, ZStatus_t status ) { endPointDesc_t *epDesc; afDataConfirm_t *msgPtr; // Find the endpoint description epDesc = afFindEndPointDesc( endPoint ); if ( epDesc == NULL ) return; // Determine the incoming command type msgPtr = (afDataConfirm_t *)osal_msg_allocate( sizeof(afDataConfirm_t) ); if ( msgPtr ) { // Build the Data Confirm message msgPtr->hdr.event = AF_DATA_CONFIRM_CMD; msgPtr->hdr.status = status; msgPtr->endpoint = endPoint; msgPtr->transID = transID; #if defined ( MT_AF_CB_FUNC ) /* If MT has subscribed for this callback, don't send as a message. */ if ( AFCB_CHECK(CB_ID_AF_DATA_CNF,*(epDesc->task_id)) ) { /* Send callback if it's subscribed */ MT_AfDataConfirm ((void *)msgPtr); /* Release the memory. */ osal_msg_deallocate( (void *)msgPtr ); } else #endif { /* send message through task message */ osal_msg_send( *(epDesc->task_id), (byte *)msgPtr ); } } }
/************************************************************************************************** * @fn ZDO_UpdateNwkStatus * * @brief This function sends a ZDO_STATE_CHANGE message to the task of every EndPoint * registered with AF (except, of course, the ZDO_EP). Even if a single task has more * than one registered EndPoint, it will only receive one notification per state * change. Although the device may go through a sequence of state changes, the * Application task may only receive notification of the final, steady-state state * because it has the lowest priority and never even runs to receive the intermediate * state change notifications. * * input parameters * * @param state - The current device state. * * output parameters * * None. * * @return None. ************************************************************************************************** */ void ZDO_UpdateNwkStatus(devStates_t state) { epList_t *pItem = epList; while (pItem != NULL) { if (pItem->epDesc->endPoint != ZDO_EP) { osal_event_hdr_t *pMsg = (osal_event_hdr_t *)osal_msg_find(*(pItem->epDesc->task_id), ZDO_STATE_CHANGE); if (NULL == pMsg) { if (NULL == (pMsg = (osal_event_hdr_t *)osal_msg_allocate(sizeof(osal_event_hdr_t)))) { // Upon failure to notify any EndPoint of the state change, re-set the ZDO event to // try again later when more Heap may be available. osal_set_event(zapTaskId, ZAP_APP_ZDO_STATE_CHANGE_EVT); } else { pMsg->event = ZDO_STATE_CHANGE; pMsg->status = (uint8)state; (void)osal_msg_send(*(pItem->epDesc->task_id), (uint8 *)pMsg); } } else { // Modify in place the status of an existing ZDO_STATE_CHANGE message to the EndPoint. pMsg->status = (uint8)state; } } pItem = pItem->nextDesc; } }
/*************************************************************************************************** * @fn MT_UartProcessZToolData * * @brief | SOP | Data Length | CMD | Data | FCS | * | 1 | 1 | 2 | 0-Len | 1 | * * Parses the data and determine either is SPI or just simply serial data * then send the data to correct place (MT or APP) * * @param port - UART port * event - Event that causes the callback * * * @return None ***************************************************************************************************/ void MT_UartProcessZToolData( uint8 port, uint8 event ) { uint8 ch; (void)event; // Intentionally unreferenced parameter uint8 i,j,flag = 0; uint8 str[128]; while (Hal_UART_RxBufLen(port)) { HalUARTRead (port, &ch, 1); j++; str[j] = ch; flag = 1; } if(flag == 1) { pMsg = (mtOSALSerialData_t *) osal_msg_allocate(sizeof(mtOSALSerialData_t) + j +1); pMsg->hdr.event = CMD_SERIAL_MSG; pMsg->msg = (uint8 *)(pMsg + 1); pMsg->msg[0] = j; for(i = 1; i <= j; i++) { pMsg->msg[i] = str[i]; } osal_msg_send(App_TaskID,(byte *) pMsg); osal_msg_deallocate( (uint8 *)pMsg); } }
u16 APP_ProcessEvent( u8 task_id, u16 events ) { loraMAC_msg_t* pMsgSend = NULL; loraMAC_msg_t* pMsgRecieve = NULL; u8 tmp_buf[64]; u8 len = 0 ; //system event if(events & SYS_EVENT_MSG) { //receive msg loop while(NULL != (pMsgRecieve = (loraMAC_msg_t*)osal_msg_receive(APP_taskID))) { //pMsgRecieve[0] is system event type switch(pMsgRecieve->msgID) { //tx done case TXDONE : //调度下一次发送 //RedLED(ON); HalLedSet (HAL_LED_1, HAL_LED_MODE_ON); if(Txpacket_count > 0) { Txpacket_count--; HAL_UART_SendBytes(uart1_rxBuf,uart1_Rxcount); pMsgSend = (loraMAC_msg_t*)osal_msg_allocate(72); if(pMsgSend != NULL) { osal_memset(pMsgSend,0,72);//需要全部置0,要不然会出现发完串口数据包后不再进入TXDONE pMsgSend->msgID = TXREQUEST; pMsgSend->msgLen = uart1_Rxcount+2; osal_memcpy(pMsgSend->msgData,uart1_rxBuf,uart1_Rxcount); osal_msg_send(LoraMAC_taskID,(u8*)pMsgSend); osal_msg_deallocate((u8*)pMsgSend); } } else { //send a packet to LoRaMac osal (then can be send by the radio) pMsgSend = (loraMAC_msg_t*)osal_msg_allocate(72); if(pMsgSend != NULL) { osal_memset(pMsgSend,0,72); pMsgSend->msgID = TXREQUEST; pMsgSend->msgLen = 70; for(u8 dataCount = 0; dataCount < 70; dataCount++) { pMsgSend->msgData[dataCount] = dataCount; } osal_msg_send(LoraMAC_taskID,(u8*)pMsgSend); osal_msg_deallocate((u8*)pMsgSend); HAL_UART_SendBytes("app send\n", osal_strlen("app send\n")); } } //RedLED(OFF); HalLedSet (HAL_LED_1, HAL_LED_MODE_OFF); break; //rx done case RXDONE: HalLedSet (HAL_LED_2, HAL_LED_MODE_ON); OLED_Clear_Half();//先把屏幕下一半清空 APP_ShowMoteID(g_appData.devAddr); len = 0 ; g_number++ ; memset(Rx_buf , 0 ,sizeof(Rx_buf)); osal_memcpy(Rx_buf,pMsgRecieve->msgData,pMsgRecieve->msgLen); len = pMsgRecieve->msgLen; Rx_buf[len] = 0; OLED_ShowString( 0,36, (u8*)Rx_buf,12 ); OLED_Refresh_Gram(); HAL_UART_SendBytes("\n",1); HAL_UART_SendBytes((uint8_t *)Rx_buf,strlen(Rx_buf)); HalLedSet (HAL_LED_2, HAL_LED_MODE_OFF); break; case TXERR_STATUS: { //TODO MOTE send packet error deal memset( tmp_buf ,0 ,sizeof(tmp_buf) ); sprintf( (char *)tmp_buf,"send err ret=%d,no=%d",pMsgRecieve->msgData[0], pMsgRecieve->msgData[1]+( pMsgRecieve->msgData[2]<<8 ) ); OLED_ShowString( 0,36,tmp_buf,12 ); OLED_Refresh_Gram(); break; } default: break; } osal_msg_deallocate((u8*)pMsgRecieve); } return (events ^ SYS_EVENT_MSG); } //send a packet event if(events & APP_PERIOD_SEND) { //RedLED(OFF); HalLedSet (HAL_LED_1, HAL_LED_MODE_OFF); //send a packet to LoRaMac osal (then can be send by the radio) pMsgSend = (loraMAC_msg_t*)osal_msg_allocate(72); if(pMsgSend != NULL) { osal_memset(pMsgSend,0,72); pMsgSend->msgID = TXREQUEST; pMsgSend->msgLen = 70; for(u8 dataCount = 0; dataCount < 70; dataCount++) { pMsgSend->msgData[dataCount] = dataCount; } osal_msg_send(LoraMAC_taskID,(u8*)pMsgSend); } //osal_start_timerEx(APP_taskID, APP_PERIOD_SEND,1000);//延时继续发送 return (events ^ APP_PERIOD_SEND); } //uart test event if(events & APP_TEST_UART) { Txpacket_count = 1;//串口收到一个数据包,就发一遍无线包出去add by hxz //HAL_UART_SendBytes("hello,world!", 10); //osal_start_timerEx(APP_taskID, APP_TEST_UART,1000);//延时继续发送 return (events ^ APP_TEST_UART); } return 0 ; }