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