This thread has been locked.
If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.
Part Number: CC2652P
Other Parts Discussed in Thread: SYSCONFIG, Z-STACK
A CC2652P send a fragment packet(aps data is 90 byte) to another CC2652P and DstEndPoint is 0xFF, the other CC2652P can't receive this packet. And the sender CC2652P will wait for long time(more than 15s) and trigger AF_DATA_CONFIRM with failure status.
Hi Aries,
The APS fragmentation layer of the Z-Stack source libraries will discard fragmented packets if the endpoint is not registered into the endpoint description list, which applies to the 0xFF broadcast endpoint. To work around this limitation you can send the fragmented packets to a direct registered endpoint or break up the large APS packet outside of the packet fragmentation feature context. I have not further looked into what would happen if the 0xFF endpoint were attempted to be registered by the application. The delay for AF_DATA_CONFIRM failure will depend on whether APS ACK is enabled and Packet Sending parameters set in SysConfig (like NWK Data Retries, APS Retries, and APC ACK Wait Duration)
Regards,
Ryan
fragmented packets with 0xFF broadcast endpoint is useful in Zigbee Application. I have tried to fix this issue in "aps_frag.c" of Z-stack 3.0.2. But I have no this source file of SDK 8.30.
/**************************************************************************************************
Filename: aps_frag.c
Revised: $Date: 2013-09-27 11:56:40 -0700 (Fri, 27 Sep 2013) $
Revision: $Revision: 35472 $
Description: Implements APS Application Data Unit Fragmentation
Copyright 2006-2013 Texas Instruments Incorporated. All rights reserved.
IMPORTANT: Your use of this Software is limited to those specific rights
granted under the terms of a software license agreement between the user
who downloaded the software, his/her employer (which must be your employer)
and Texas Instruments Incorporated (the "License"). You may not use this
Software unless you agree to abide by the terms of the License. The License
limits your use, and you acknowledge, that the Software may not be modified,
copied or distributed unless embedded on a Texas Instruments microcontroller
or used solely and exclusively in conjunction with a Texas Instruments radio
frequency transceiver, which is integrated into your product. Other than for
the foregoing purpose, you may not use, reproduce, copy, prepare derivative
works of, modify, distribute, perform, display or sell this Software and/or
its documentation for any purpose.
YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE
PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,
NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT,
NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER
LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE
OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT
OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
(INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
Should you have any questions regarding your right to use this Software,
contact Texas Instruments Incorporated at www.TI.com.
**************************************************************************************************/
/*********************************************************************
* INCLUDES
*/
#include "OSAL.h"
#include "AF.h"
#include "ZDApp.h"
#include "aps_frag.h"
#include "aps_util.h"
#include "hal_assert.h"
#include "nwk_util.h"
#include "ZGlobals.h"
/*********************************************************************
* MACROS
*/
// Time to wait for an ackknowledgement
#define APSF_ACK_WAIT (100 * _NIB.MaxDepth * zgApsAckWaitMultiplier)
// Time to wait for retrys before timing out the reception
#define APSF_RX_TOUT (APSF_ACK_WAIT + APSF_ACK_WAIT * zgApscMaxFrameRetries)
// Object list type
#define APSF_TX_TYPE 1
#define APSF_RX_TYPE 2
/*********************************************************************
* CONSTANTS
*/
#define APSF_DEF_FRAME_DELAY 50
#define APSF_DEF_WINDOW_SIZE 3
#define APSF_ZCL_WINDOW_SIZE 1
/*********************************************************************
* TYPEDEFS
*/
typedef struct _apsf_hdr_t {
uint16 timeStamp;
uint16 duration;
uint16 shortAddr;
uint8 type;
uint8 apsCount;
uint8 numBlocks;
struct _apsf_hdr_t *pNext;
} APSF_Header_t;
typedef struct {
APSF_Header_t hdr;
APSDE_DataReq_t dataReq;
uint8 blockSize;
uint8 firstBlk; // First block in the window
uint8 sendMask; // Mask of sent blocks (1=sent)
uint8 ackBits; // Mask of acked blocks (1=ack)
uint8 retry;
uint8 windowSize;
uint8 frameDelay;
uint16 len;
uint8 *pData;
} APSF_TxObj_t;
typedef struct {
APSF_Header_t hdr;
uint8 taskID;
uint8 ackBits;
uint8 fragSize;
uint8 firstBlk; // First block in the window
uint8 windowSize;
afIncomingMSGPacket_t *pMsg;
} APSF_RxObj_t;
/*********************************************************************
* GLOBAL VARIABLES
*/
uint8 APSF_taskID = 0xff;
/*********************************************************************
* EXTERNAL VARIABLES
*/
extern uint8 zgApsAckWaitMultiplier;
/*********************************************************************
* EXTERNAL FUNCTIONS
*/
/*********************************************************************
* LOCAL VARIABLES
*/
static APSF_Header_t *APSF_ObjList;
/*********************************************************************
* LOCAL FUNCTIONS
*/
static void APSF_AddObj(APSF_Header_t *pHdr, uint8 type);
static APSF_Header_t *APSF_FindObj(uint8 apsCount, uint16 shortAddr, uint8 type);
static APSF_Header_t *APSF_FreeObj(APSF_Header_t *pHdr);
static void APSF_TxNextFrame(APSF_TxObj_t *pTx);
static void APSF_Schedule( void );
static APSF_Header_t *APSF_AllocRxObj(aps_FrameFormat_t *aff, zAddrType_t *SrcAddress,
NLDE_Signal_t *sig, uint8 SecurityUse, uint32 timestamp );
static void APSF_IncomingData(aps_FrameFormat_t *aff, zAddrType_t *SrcAddress,
NLDE_Signal_t *sig, uint8 SecurityUse, uint32 timestamp);
uint8 (*pAPSF_IgnoreBlock)( uint8 block ) = (void*)NULL;
/*********************************************************************
* PUBLIC FUNCTIONS
*/
/*********************************************************************
* @fn APSF_Init
*
* @brief Initialization function for the Task.
* This is called during initialization and should contain
* any application specific initialization (ie. hardware
* initialization/setup, table initialization, power up
* notificaiton ... ).
*
* @param task_id - the ID assigned by OSAL. This ID should be
* used to send messages and set timers.
*
* @return none
*/
void APSF_Init(uint8 task_id)
{
// Record the task ID
APSF_taskID = task_id;
// Setup the entry points
apsfSendFragmented = &APSF_SendFragmented;
apsfProcessAck = &APSF_ProcessAck;
apsfSendOsalMsg = &APSF_SendOsalMsg;
}
/*********************************************************************
* @fn APSF_AddObj
*
* @brief Adds a block message to the list of TX and RX messages.
*
* @param pObj - Pointer to type dpecific data to store in the block.
* type - The block represents an RX or TX.
*
* @return none
*/
static void APSF_AddObj(APSF_Header_t *pHdr, uint8 type)
{
APSF_Header_t *pTmp;
HAL_ASSERT(pHdr);
// Insert the block message in the list
if (!APSF_ObjList)
APSF_ObjList = pHdr;
else
{
pTmp = APSF_ObjList;
while (pTmp->pNext)
pTmp = pTmp->pNext;
pTmp->pNext = pHdr;
}
// Initialize the header
pHdr->pNext = NULL;
pHdr->type = type;
}
/*********************************************************************
* @fn APSF_FindObj
*
* @brief Finds a block message in the list of TX and RX messages.
*
* @param apsCount - The APS Count ID of the fragmented data.
* type - The opject represents an RX or TX.
*
* @return none
*/
static APSF_Header_t *APSF_FindObj(uint8 apsCount, uint16 shortAddr, uint8 type)
{
APSF_Header_t *pHdr = APSF_ObjList;
while (pHdr)
{
if ((pHdr->apsCount == apsCount) &&
(pHdr->shortAddr == shortAddr) &&
(pHdr->type == type))
return pHdr;
pHdr = pHdr->pNext;
}
return NULL;
}
/*********************************************************************
* @fn APSF_FreeObj
*
* @brief Frees a block message from the list of TX and RX messages.
*
* @param pHdr - Block to free.
*
* @return Block previous to pHdr.
*/
static APSF_Header_t *APSF_FreeObj(APSF_Header_t *pHdr)
{
APSF_Header_t *pTmp = APSF_ObjList;
// Remove the object from the list
if (pHdr == APSF_ObjList)
pTmp = APSF_ObjList = APSF_ObjList->pNext;
else
{
while (pTmp)
{
if (pTmp->pNext == pHdr)
{
pTmp->pNext = pHdr->pNext;
break;
}
pTmp = pTmp->pNext;
}
}
// Free the object
osal_mem_free(pHdr);
return pTmp;
}
/*********************************************************************
* @fn APSF_SendFragmented
*
* @brief Puts a afMultiHdr into the list of block messages.
*
* @param p_hdr - afMultiHdr_t to be transmitted.
* profileID - The profile ID of the endpoint
*
* @return none
*/
afStatus_t APSF_SendFragmented(APSDE_DataReq_t *pReq)
{
APSF_TxObj_t *pTx;
afDataReqMTU_t mtu;
uint16 dstAddr;
if ( pReq->dstAddr.addrMode == AddrNotPresent ||
pReq->dstAddr.addrMode == AddrGroup ||
NLME_IsAddressBroadcast(pReq->dstAddr.addr.shortAddr) != ADDR_NOT_BCAST )
{
return afStatus_INVALID_PARAMETER;
}
// Find out the destination short address
if ( pReq->dstAddr.addrMode == Addr64Bit )
{
if ( APSME_LookupNwkAddr( pReq->dstAddr.addr.extAddr, &dstAddr ) == FALSE )
{
return afStatus_INVALID_PARAMETER;
}
}
else
{
dstAddr = pReq->dstAddr.addr.shortAddr;
}
// Allocate a TX object
pTx = osal_mem_alloc(sizeof(APSF_TxObj_t) + pReq->asduLen);
if (pTx)
{
afAPSF_Config_t cfg;
// Initialize the pTx
osal_memset(pTx, 0, sizeof(APSF_TxObj_t));
afAPSF_ConfigGet(pReq->srcEP, &cfg);
pTx->frameDelay = cfg.frameDelay;
pTx->windowSize = cfg.windowSize;
// Add the TX object to the list
APSF_AddObj((APSF_Header_t*) pTx, APSF_TX_TYPE);
// Copy the data request information
osal_memcpy(&pTx->dataReq, pReq, sizeof(APSDE_DataReq_t));
// Copy the msg data
pTx->pData = (uint8*) (pTx + 1);
pTx->len = pReq->asduLen;
osal_memcpy(pTx->pData, pReq->asdu, pReq->asduLen);
pTx->hdr.shortAddr = dstAddr;
pTx->hdr.apsCount = APS_Counter++;
pTx->hdr.timeStamp = (uint16) osal_GetSystemClock();
pTx->sendMask = pTx->ackBits = 0xff << pTx->windowSize;
mtu.kvp = FALSE;
if (pReq->txOptions & APS_TX_OPTIONS_SECURITY_ENABLE)
mtu.aps.secure = TRUE;
else
mtu.aps.secure = FALSE;
pTx->blockSize = afDataReqMTU(&mtu) - APS_XFRAME_CTRL_FIELD_LEN - APS_BLOCK_CNT_FIELD_LEN;
// Set the total number of blocks
pTx->hdr.numBlocks = pTx->len / pTx->blockSize;
if (pTx->len % pTx->blockSize)
{
pTx->hdr.numBlocks++;
}
// Enable fragmentation permitted tx option
pTx->dataReq.txOptions |= APS_TX_OPTIONS_PERMIT_FRAGMENT;
// Kick the scheduler
osal_set_event(APSF_taskID, APSF_SCHED_EVT);
return afStatus_SUCCESS;
}
return afStatus_MEM_FAIL;
}
/*********************************************************************
* @fn APSF_TxNextFrame
*
* @brief Goes through the list of block messages and transmits
* the next frame.
*
* @param none
*
* @return none
*/
static void APSF_TxNextFrame(APSF_TxObj_t *pTx)
{
uint16 len;
uint8 block;
uint8 i;
pTx->hdr.timeStamp = (uint16) osal_GetSystemClock();
if (pTx->retry < zgApscMaxFrameRetries)
{
if (pTx->sendMask == 0xff)
{
// No ack received. Retry
pTx->retry++;
pTx->sendMask = pTx->ackBits;
}
// Determine the block to send
block = pTx->firstBlk;
for ( i = 0; i < pTx->windowSize; i++ )
{
if ( (pTx->sendMask ^ 0xFF) & (1 << i) )
{
block += i;
pTx->sendMask |= (1 << i);
break;
}
}
// Calculate the block length
len = pTx->len - (block * pTx->blockSize);
if (len >= pTx->blockSize)
{
len = pTx->blockSize;
}
else
{
// Last block, fill in all bits in the sent mask
pTx->sendMask = 0xff;
}
if (pTx->sendMask == 0xff)
{
// Last block in the window. Request an ack
pTx->hdr.duration = APSF_ACK_WAIT;
}
else
{
pTx->hdr.duration = pTx->frameDelay;
}
if (block == 0)
{
// First fragment
pTx->dataReq.txOptions |= APS_TX_OPTIONS_FIRST_FRAGMENT;
// blkCount contains total number of blocks
pTx->dataReq.blkCount = pTx->hdr.numBlocks;
// Set pReq asdu ptr to beginnning
pTx->dataReq.asdu = pTx->pData;
}
else
{
// Not first fragment
pTx->dataReq.txOptions &= ~APS_TX_OPTIONS_FIRST_FRAGMENT;
// Set the block
pTx->dataReq.blkCount = block;
// Set pReq asdu ptr to data to send
pTx->dataReq.asdu = pTx->pData + block * pTx->blockSize;
}
pTx->dataReq.apsCount = pTx->hdr.apsCount;
pTx->dataReq.asduLen = (uint8) len;
// For error testing
if ( pAPSF_IgnoreBlock && pAPSF_IgnoreBlock( block ) )
return; // Don't send the packet
// Send the block
APSDE_DataReq(&pTx->dataReq);
}
else
{
// Max retry reached, send DATA.confirm failure
afDataConfirm(pTx->dataReq.srcEP, pTx->dataReq.transID, ZMacNoACK);
APSF_FreeObj((APSF_Header_t*) pTx);
}
}
/*********************************************************************
* @fn APSF_Schedule
*
* @brief Goes through the list of block messages, picks the next
* block to transmit, and timeout any old RX block messages.
*
* @param none
*
* @return none
*/
static void APSF_Schedule( void )
{
APSF_Header_t *pHdr = APSF_ObjList;
uint16 sysClk = (uint16) osal_GetSystemClock();
uint16 nextTime = 0xffff;
uint16 duration;
// Go through list
while (pHdr)
{
duration = sysClk - pHdr->timeStamp;
if (duration >= pHdr->duration)
{
// RX or TX Object
if (pHdr->type == APSF_RX_TYPE)
{
APSF_RxObj_t *pRx = (APSF_RxObj_t*) pHdr;
// The task owns the pMsg id the rx completed sucessfully, else free the pMsg
if (pRx->taskID != 0xff)
{
osal_msg_deallocate((uint8*) pRx->pMsg);
}
// Free the RX Obj
APSF_FreeObj(pHdr);
}
else
{
// Handle TX timeout
APSF_TxNextFrame((APSF_TxObj_t*) pHdr);
}
// Only process one Object at a time without context switch
osal_set_event(APSF_taskID, APSF_SCHED_EVT);
return;
}
else
{
// Keep track of smallest time for next scheduled event
if (pHdr->duration - duration < nextTime)
nextTime = pHdr->duration - duration;
}
pHdr = pHdr->pNext;
}
// Start timer for next escheduled event
if (nextTime != 0xffff)
osal_start_timerEx(APSF_taskID, APSF_SCHED_EVT, nextTime);
}
/*********************************************************************
* @fn APSF_ProccessAck
*
* @brief Processes an ack on Fragmented APS data.
*
* @param aff - Frame format.
* status - The status of the operation.
*
* @return none
*/
void APSF_ProcessAck(aps_FrameFormat_t *aff, uint16 srcAddr, uint8 status)
{
APSF_TxObj_t *pTx = (APSF_TxObj_t*) APSF_FindObj(aff->ApsCounter, srcAddr, APSF_TX_TYPE);
if (pTx && status == ZSuccess)
{
// Verify the ack matches the window
if (aff->BlkCount != pTx->firstBlk)
return;
if ((aff->BlkCount + pTx->windowSize >= pTx->hdr.numBlocks) &&
(aff->AckBits == 0xff))
{
// TX complete. Send data confirm and free the TX object
afDataConfirm(pTx->dataReq.srcEP, pTx->dataReq.transID, status);
APSF_FreeObj((APSF_Header_t*) pTx);
}
else
{
// Check if we are moving to the next window
if (aff->AckBits == 0xff)
{
pTx->ackBits = pTx->sendMask = 0xff << pTx->windowSize;
pTx->firstBlk += pTx->windowSize;
pTx->retry = 0;
}
else
{
// Record the ack
pTx->ackBits = aff->AckBits;
pTx->sendMask = aff->AckBits;
}
// Set the delay
pTx->hdr.timeStamp = (uint16) osal_GetSystemClock();
pTx->hdr.duration = pTx->frameDelay;
// Kick the scheduler
osal_set_event(APSF_taskID, APSF_SCHED_EVT);
}
}
}
/*********************************************************************
* @fn APSF_AllocRxObj
*
* @brief Allocates an object used to track the RX fragmented data.
*
* @param aff - APS frame format
* SrcAddress - Source address of data.
* sig - Link quality of received data.
* SecurityUse - Passed in from APS
* timestamp - when the message arrived
*
* @return none
*/
static APSF_Header_t *APSF_AllocRxObj(aps_FrameFormat_t *aff, zAddrType_t *SrcAddress,
NLDE_Signal_t *sig, uint8 SecurityUse, uint32 timestamp )
{
uint16 msgLen;
afIncomingMSGPacket_t *MSGpkt;
endPointDesc_t *epDesc = NULL;
APSF_RxObj_t *pRx;
// Discard if the endpoint is not supported
if (aff->DstEndPoint != 0xFF)
{
// Only look for an endpoint if the message is not a broadcast, fixed by Luoyiming 2026-06-08
epDesc = afFindEndPointDesc(aff->DstEndPoint);
if (!epDesc)
return NULL;
}
// Allocate an RX object
pRx = osal_mem_alloc(sizeof(APSF_RxObj_t));
if (pRx)
{
afAPSF_Config_t cfg;
// Initialize the RX Object
osal_memset(pRx, 0, sizeof(APSF_RxObj_t));
afAPSF_ConfigGet(aff->DstEndPoint, &cfg);
pRx->windowSize = cfg.windowSize;
// Add the RX Object to the list
APSF_AddObj((APSF_Header_t*) pRx, APSF_RX_TYPE);
pRx->hdr.shortAddr = SrcAddress->addr.shortAddr;
pRx->hdr.apsCount = aff->ApsCounter;
pRx->ackBits = 0xff << pRx->windowSize;
// Record the task ID
if (aff->DstEndPoint == AF_BROADCAST_ENDPOINT)
{
// If DstEndPoint is a broadcast, set taskID to APSF_taskID and let APSF_ProcessEvent
// send the message to all matching endpoints. Fixed by Luoyiming 2026-06-08
pRx->taskID = APSF_taskID;
}
else
{
pRx->taskID = *epDesc->task_id;
}
// The block count on the first fragment contians the total number of blocks
// The asduLength contains the length of each block ( not clear in spec ??? )
pRx->fragSize = aff->asduLength;
msgLen = sizeof(afIncomingMSGPacket_t) + aff->BlkCount * pRx->fragSize;
pRx->pMsg = MSGpkt = (afIncomingMSGPacket_t*) osal_msg_allocate( msgLen );
if (MSGpkt)
{
MSGpkt->hdr.event = AF_INCOMING_MSG_CMD;
MSGpkt->hdr.status = afStatus_SUCCESS;
MSGpkt->groupId = 0;
MSGpkt->clusterId = aff->ClusterID;
// Make an AF source address
afCopyAddress ( &(MSGpkt->srcAddr), SrcAddress );
MSGpkt->srcAddr.endPoint = aff->SrcEndPoint;
// A fragmented message could not have been received via Inter-PAN.
MSGpkt->srcAddr.panId = _NIB.nwkPanId;
MSGpkt->macSrcAddr = aff->macSrcAddr;
MSGpkt->macDestAddr = aff->macDestAddr;
MSGpkt->endPoint = aff->DstEndPoint;
MSGpkt->wasBroadcast = aff->wasBroadcast;
MSGpkt->LinkQuality = sig->LinkQuality;
MSGpkt->correlation = sig->correlation;
MSGpkt->rssi = sig->rssi;
MSGpkt->SecurityUse = SecurityUse;
MSGpkt->timestamp = timestamp;
MSGpkt->cmd.Data = (uint8 *) (MSGpkt + 1);
MSGpkt->cmd.TransSeqNumber = aff->transID;
}
else
{
APSF_FreeObj((APSF_Header_t*)pRx);
pRx = NULL;
}
}
return ( (APSF_Header_t*) pRx );
}
/*********************************************************************
* @fn APSF_IncomingData
*
* @brief Processes incomming fragmented APS data
*
* @param aff - APS frame format
* SrcAddress - Source address of data.
* sig - Link quality of received data.
*
* @return none
*/
static void APSF_IncomingData(aps_FrameFormat_t *aff, zAddrType_t *SrcAddress,
NLDE_Signal_t *sig, uint8 SecurityUse, uint32 timestamp)
{
// Find or add header to the list
APSF_RxObj_t *pRx;
uint8 lastBlk = FALSE;
uint8 block = aff->BlkCount;
// For error testing
if ( pAPSF_IgnoreBlock && pAPSF_IgnoreBlock( block ) )
return; // Don't receive the packet
pRx = (APSF_RxObj_t*) APSF_FindObj(aff->ApsCounter,
SrcAddress->addr.shortAddr,
APSF_RX_TYPE);
if (pRx == NULL)
{
// Add to list if first fragment
if (aff->XtndFrmCtrl & APS_XFC_FIRST_FRAG)
{
pRx = (APSF_RxObj_t*) APSF_AllocRxObj(aff, SrcAddress, sig,
SecurityUse, timestamp);
if (pRx)
{
// First fragment blkCount contains total number of blocks
pRx->hdr.numBlocks = block;
// Kick the scheduler
osal_set_event(APSF_taskID, APSF_SCHED_EVT);
}
}
}
if (pRx)
{
// Record if last block of the transfer
if (block == pRx->hdr.numBlocks - 1)
{
lastBlk = TRUE;
}
if (pRx->taskID != 0xff)
{
// Set block count to zero on first fragment
if (aff->XtndFrmCtrl & APS_XFC_FIRST_FRAG)
{
block = 0;
}
// Check if the window has moved
if (block >= pRx->firstBlk + pRx->windowSize)
{
pRx->firstBlk += pRx->windowSize;
pRx->ackBits = 0xff << pRx->windowSize;
}
// Copy the data
osal_memcpy(pRx->pMsg->cmd.Data + block * pRx->fragSize,
aff->asdu, aff->asduLength);
// Set the ack bit
pRx->ackBits |= 1 << (block % pRx->windowSize);
if (lastBlk)
{
// Fill in all unused ack bits
pRx->ackBits |= 0xff << ((block % pRx->windowSize) + 1);
// Calcualte the actual length of the message
pRx->pMsg->cmd.DataLength = pRx->fragSize * block + aff->asduLength;
}
// Check if the transfer is complete
if (lastBlk && pRx->ackBits == 0xff)
{
// Send message to endpoint task
osal_msg_send(pRx->taskID, (uint8*) pRx->pMsg);
// The RX object must persist incase the last ack was lost.
// Set the task ID to 0xff indicating the rx process is complete
// then free the RX object in the timeout
pRx->taskID = 0xff;
}
else
{
// Reset timer for RX timeout error
pRx->hdr.timeStamp = (uint16) osal_GetSystemClock();
pRx->hdr.duration = APSF_RX_TOUT;
}
}
// Send ack on last block in the window, retry is complete, or on last block in transfer
if (block == pRx->firstBlk + pRx->windowSize - 1 || pRx->ackBits == 0xff || lastBlk)
{
aff->BlkCount = pRx->firstBlk;
aff->AckBits = pRx->ackBits;
apsGenerateAck(SrcAddress->addr.shortAddr, aff);
}
}
}
/*********************************************************************
* @fn APSF_SendOsalMsg
*
* @brief Sends a message to the APSF_Task
*
* @param msgPtr - Message
*
* @return none
*/
void APSF_SendOsalMsg(uint8 *msgPtr)
{
osal_msg_send(APSF_taskID, msgPtr);
}
/*********************************************************************
* @fn Sim_ProcessEvent
*
* @brief 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 APSF_ProcessEvent(uint8 task_id, UINT16 events)
{
afIncomingMSGPacket_t *MSGpkt;
apsInMsg_t *pData;
(void)task_id; // Intentionally unreferenced parameter
if (events & SYS_EVENT_MSG)
{
while ((MSGpkt = (afIncomingMSGPacket_t*) osal_msg_receive(APSF_taskID)) != NULL)
{
switch (MSGpkt->hdr.event)
{
case APS_INCOMING_MSG:
pData = (apsInMsg_t*) MSGpkt;
APSF_IncomingData(&pData->aff, &pData->SrcAddress,
&(pData->sig), pData->SecurityUse, pData->timestamp);
break;
case AF_INCOMING_MSG_CMD:
{
// If the message is a broadcast, send it to all endpoints that match the profile ID, fixed by Luoyiming 2026-06-08
if (MSGpkt->endPoint == AF_BROADCAST_ENDPOINT)
{
// Broadcast message
epList_t *pList = epList;
while (pList)
{
if ( (pList->epDesc->AppProfId == aff->ProfileID) ||
((pList->epDesc->endPoint != ZDO_EP) && ( aff->ProfileID == ZDO_WILDCARD_PROFILE_ID )) )
{
afIncomingMSGPacket_t *pNewMsg = (afIncomingMSGPacket_t*) osal_msg_allocate( OSAL_MSG_LEN(MSGpkt) );
if (pNewMsg)
{
osal_memcpy(pNewMsg, MSGpkt, OSAL_MSG_LEN(MSGpkt));
osal_msg_send(*pList->epDesc->task_id, (uint8*) pNewMsg);
}
}
pList = pList->next;
}
}
}
break;
default:
break;
}
osal_msg_deallocate((uint8*) MSGpkt);
}
// Return unprocessed events
return (events ^ SYS_EVENT_MSG);
}
if (events & APSF_SCHED_EVT)
{
APSF_Schedule();
return (events ^ APSF_SCHED_EVT);
}
// Discard unknown events
return 0;
}
/**************************************************************************************************
*/
