sundp
/
STM32CubeWL
mirror of https://github.com/STMicroelectronics/STM32CubeWL.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
STM32CubeWL/Middlewares/Third_Party/LoRaWAN/LmHandler/Packages/LmhpFragmentation.c

540 lines
19 KiB
C
Raw Blame History

/*!
* \file LmhpFragmentation.c
*
* \brief Implements the LoRa-Alliance fragmented data block transport package
* Specification: https://lora-alliance.org/sites/default/files/2018-09/fragmented_data_block_transport_v1.0.0.pdf
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
* ______ _
* / _____) _ | |
* ( (____ _____ ____ _| |_ _____ ____| |__
* \____ \| ___ | (_ _) ___ |/ ___) _ \
* _____) ) ____| | | || |_| ____( (___| | | |
* (______/|_____)_|_|_| \__)_____)\____)_| |_|
* (C)2013-2018 Semtech
*
* \endcode
*
* \author Miguel Luis ( Semtech )
*/
/**
******************************************************************************
*
* Portions COPYRIGHT 2020 STMicroelectronics
*
* @file LmhpFragmentation.c
* @author MCD Application Team
* @brief Fragmentation Data Block Transport Package definition
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "LmHandler.h"
#include "LmhpFragmentation.h"
#include "utilities.h"
/* Private typedef -----------------------------------------------------------*/
/* Fragmentation Tx delay state */
typedef enum LmhpFragmentationTxDelayStates_e
{
/* Tx delay in idle state */
FRAGMENTATION_TX_DELAY_STATE_IDLE,
/* Tx delay to be started */
FRAGMENTATION_TX_DELAY_STATE_START,
/* Tx is in pending */
FRAGMENTATION_TX_DELAY_STATE_PENDING,
} LmhpFragmentationTxDelayStates_t;
/*!
* Package current context
*/
typedef struct LmhpFragmentationState_s
{
bool Initialized;
bool IsRunning;
LmhpFragmentationTxDelayStates_t TxDelayState;
uint8_t DataBufferMaxSize;
uint8_t *DataBuffer;
uint8_t *file;
} LmhpFragmentationState_t;
typedef enum LmhpFragmentationMoteCmd_e
{
FRAGMENTATION_PKG_VERSION_ANS = 0x00,
FRAGMENTATION_FRAG_STATUS_ANS = 0x01,
FRAGMENTATION_FRAG_SESSION_SETUP_ANS = 0x02,
FRAGMENTATION_FRAG_SESSION_DELETE_ANS = 0x03,
} LmhpFragmentationMoteCmd_t;
typedef enum LmhpFragmentationSrvCmd_e
{
FRAGMENTATION_PKG_VERSION_REQ = 0x00,
FRAGMENTATION_FRAG_STATUS_REQ = 0x01,
FRAGMENTATION_FRAG_SESSION_SETUP_REQ = 0x02,
FRAGMENTATION_FRAG_SESSION_DELETE_REQ = 0x03,
FRAGMENTATION_DATA_FRAGMENT = 0x08,
} LmhpFragmentationSrvCmd_t;
typedef struct FragGroupData_s
{
bool IsActive;
union
{
uint8_t Value;
struct
{
uint8_t McGroupBitMask: 4;
uint8_t FragIndex: 2;
uint8_t RFU: 2;
} Fields;
} FragSession;
uint16_t FragNb;
uint8_t FragSize;
union
{
uint8_t Value;
struct
{
uint8_t BlockAckDelay: 3;
uint8_t FragAlgo: 3;
uint8_t RFU: 2;
} Fields;
} Control;
uint8_t Padding;
uint32_t Descriptor;
} FragGroupData_t;
typedef struct FragSessionData_s
{
FragGroupData_t FragGroupData;
FragDecoderStatus_t FragDecoderStatus;
int32_t FragDecoderProcessStatus;
} FragSessionData_t;
/* Private define ------------------------------------------------------------*/
/*!
* LoRaWAN Application Layer Fragmented Data Block Transport Specification
*/
#define FRAGMENTATION_PORT 201
#define FRAGMENTATION_ID 3
#define FRAGMENTATION_VERSION 1
#define FRAGMENTATION_MAX_SESSIONS 4
/* Private macro -------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/*!
* \brief Callback function for Fragment delay timer.
*/
static void OnFragmentTxDelay(void *context);
/*!
* Initializes the package with provided parameters
*
* \param [in] params Pointer to the package parameters
* \param [in] dataBuffer Pointer to main application buffer
* \param [in] dataBufferMaxSize Main application buffer maximum size
*/
static void LmhpFragmentationInit(void *params, uint8_t *dataBuffer, uint8_t dataBufferMaxSize);
/*!
* Returns the current package initialization status.
*
* \retval status Package initialization status
* [true: Initialized, false: Not initialized]
*/
static bool LmhpFragmentationIsInitialized(void);
/*!
* Returns the package operation status.
*
* \retval status Package operation status
* [true: Running, false: Not running]
*/
static bool LmhpFragmentationIsRunning(void);
/*!
* Processes the internal package events.
*/
static void LmhpFragmentationProcess(void);
/*!
* Processes the MCPS Indication
*
* \param [in] mcpsIndication MCPS indication primitive data
*/
static void LmhpFragmentationOnMcpsIndication(McpsIndication_t *mcpsIndication);
/* Private variables ---------------------------------------------------------*/
/*!
* LoRaWAN fragmented data block transport handler parameters
*/
static LmhpFragmentationParams_t *LmhpFragmentationParams;
static LmhpFragmentationState_t LmhpFragmentationState =
{
.Initialized = false,
.IsRunning = false,
.TxDelayState = FRAGMENTATION_TX_DELAY_STATE_IDLE,
};
static FragSessionData_t FragSessionData[FRAGMENTATION_MAX_SESSIONS];
/* Answer struct for the commands. */
LmHandlerAppData_t DelayedReplyAppData;
static LmhPackage_t LmhpFragmentationPackage =
{
.Port = FRAGMENTATION_PORT,
.Init = LmhpFragmentationInit,
.IsInitialized = LmhpFragmentationIsInitialized,
.IsRunning = LmhpFragmentationIsRunning,
.Process = LmhpFragmentationProcess,
.OnMcpsConfirmProcess = NULL, /* Not used in this package */
.OnMcpsIndicationProcess = LmhpFragmentationOnMcpsIndication,
.OnMlmeConfirmProcess = NULL, /* Not used in this package */
.OnJoinRequest = NULL, /* To be initialized by LmHandler */
.OnSendRequest = NULL, /* To be initialized by LmHandler */
.OnDeviceTimeRequest = NULL, /* To be initialized by LmHandler */
};
/* Delay value. */
static uint32_t TxDelayTime;
/* Fragment Delay Timer struct */
static TimerEvent_t FragmentTxDelayTimer;
/* Exported functions ---------------------------------------------------------*/
LmhPackage_t *LmhpFragmentationPackageFactory(void)
{
return &LmhpFragmentationPackage;
}
/* Private functions ---------------------------------------------------------*/
static void OnFragmentTxDelay(void *context)
{
/* Stop the timer. */
TimerStop(&FragmentTxDelayTimer);
/* Set the state. */
LmhpFragmentationState.TxDelayState = FRAGMENTATION_TX_DELAY_STATE_PENDING;
}
static void LmhpFragmentationInit(void *params, uint8_t *dataBuffer, uint8_t dataBufferMaxSize)
{
if ((params != NULL) && (dataBuffer != NULL))
{
LmhpFragmentationParams = (LmhpFragmentationParams_t *)params;
LmhpFragmentationState.DataBuffer = dataBuffer;
LmhpFragmentationState.DataBufferMaxSize = dataBufferMaxSize;
LmhpFragmentationState.Initialized = true;
LmhpFragmentationState.IsRunning = true;
/* Initialize Fragmentation delay time. */
TxDelayTime = 0;
/* Initialize Fragmentation delay timer. */
TimerInit(&FragmentTxDelayTimer, OnFragmentTxDelay);
}
else
{
LmhpFragmentationParams = NULL;
LmhpFragmentationState.IsRunning = false;
LmhpFragmentationState.Initialized = false;
}
/* initialize the global fragmentation session buffer */
UTIL_MEM_set_8(FragSessionData, 0, sizeof(FragSessionData));
}
static bool LmhpFragmentationIsInitialized(void)
{
return LmhpFragmentationState.Initialized;
}
static bool LmhpFragmentationIsRunning(void)
{
if (LmhpFragmentationState.Initialized == false)
{
return false;
}
return LmhpFragmentationState.IsRunning;
}
static void LmhpFragmentationProcess(void)
{
LmhpFragmentationTxDelayStates_t delayTimerState;
TimerTime_t nextTxIn = 0;
CRITICAL_SECTION_BEGIN();
delayTimerState = LmhpFragmentationState.TxDelayState;
CRITICAL_SECTION_END();
switch (delayTimerState)
{
case FRAGMENTATION_TX_DELAY_STATE_START:
/* Set the timer with the initially calculated Delay value. */
TimerSetValue(&FragmentTxDelayTimer, TxDelayTime);
/* Start the timer. */
TimerStart(&FragmentTxDelayTimer);
break;
case FRAGMENTATION_TX_DELAY_STATE_PENDING:
/* Send the reply. */
if (LmhpFragmentationPackage.OnSendRequest(&DelayedReplyAppData, LORAMAC_HANDLER_UNCONFIRMED_MSG, &nextTxIn,
true) == LORAMAC_HANDLER_SUCCESS)
{
LmhpFragmentationState.TxDelayState = FRAGMENTATION_TX_DELAY_STATE_IDLE;
}
break;
case FRAGMENTATION_TX_DELAY_STATE_IDLE:
/* Intentional fall through */
default:
/* Nothing to do. */
break;
}
}
static void LmhpFragmentationOnMcpsIndication(McpsIndication_t *mcpsIndication)
{
uint8_t cmdIndex = 0;
uint8_t dataBufferIndex = 0;
bool isAnswerDelayed = false;
/* Co-efficient used to calculate delay. */
uint8_t blockAckDelay = 0;
while (cmdIndex < mcpsIndication->BufferSize)
{
switch (mcpsIndication->Buffer[cmdIndex++])
{
case FRAGMENTATION_PKG_VERSION_REQ:
{
if (mcpsIndication->Multicast == 1)
{
/* Multicast channel. Don't process command. */
break;
}
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = FRAGMENTATION_PKG_VERSION_ANS;
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = FRAGMENTATION_ID;
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = FRAGMENTATION_VERSION;
break;
}
case FRAGMENTATION_FRAG_STATUS_REQ:
{
uint8_t fragIndex = mcpsIndication->Buffer[cmdIndex++];
uint8_t participants = fragIndex & 0x01;
fragIndex >>= 1;
FragSessionData[fragIndex].FragDecoderStatus = FragDecoderGetStatus();
if ((participants == 1) ||
((participants == 0) && (FragSessionData[fragIndex].FragDecoderStatus.FragNbLost > 0)))
{
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = FRAGMENTATION_FRAG_STATUS_ANS;
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = (fragIndex << 14) |
((FragSessionData[fragIndex].FragDecoderStatus.FragNbRx >> 8) & 0x3F);
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = FragSessionData[fragIndex].FragDecoderStatus.FragNbRx & 0xFF;
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = FragSessionData[fragIndex].FragDecoderStatus.FragNbLost;
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = FragSessionData[fragIndex].FragDecoderStatus.MatrixError & 0x01;
/* Fetch the co-efficient value required to calculate delay of that respective session. */
blockAckDelay = FragSessionData[fragIndex].FragGroupData.Control.Fields.BlockAckDelay;
isAnswerDelayed = true;
}
break;
}
case FRAGMENTATION_FRAG_SESSION_SETUP_REQ:
{
if (mcpsIndication->Multicast == 1)
{
/* Multicast channel. Don't process command. */
break;
}
FragSessionData_t fragSessionData;
uint8_t status = 0x00;
fragSessionData.FragGroupData.FragSession.Value = mcpsIndication->Buffer[cmdIndex++];
fragSessionData.FragGroupData.FragNb = (mcpsIndication->Buffer[cmdIndex++] << 0) & 0x00FF;
fragSessionData.FragGroupData.FragNb |= (mcpsIndication->Buffer[cmdIndex++] << 8) & 0xFF00;
fragSessionData.FragGroupData.FragSize = mcpsIndication->Buffer[cmdIndex++];
fragSessionData.FragGroupData.Control.Value = mcpsIndication->Buffer[cmdIndex++];
fragSessionData.FragGroupData.Padding = mcpsIndication->Buffer[cmdIndex++];
fragSessionData.FragGroupData.Descriptor = (mcpsIndication->Buffer[cmdIndex++] << 0) & 0x000000FF;
fragSessionData.FragGroupData.Descriptor += (mcpsIndication->Buffer[cmdIndex++] << 8) & 0x0000FF00;
fragSessionData.FragGroupData.Descriptor += (mcpsIndication->Buffer[cmdIndex++] << 16) & 0x00FF0000;
fragSessionData.FragGroupData.Descriptor += (mcpsIndication->Buffer[cmdIndex++] << 24) & 0xFF000000;
if (fragSessionData.FragGroupData.Control.Fields.FragAlgo > 0)
{
status |= 0x01; /* Encoding unsupported */
}
if ((fragSessionData.FragGroupData.FragNb * fragSessionData.FragGroupData.FragSize) > FragDecoderGetMaxFileSize())
{
status |= 0x02; /* Not enough Memory */
}
status |= (fragSessionData.FragGroupData.FragSession.Fields.FragIndex << 6) & 0xC0;
if (fragSessionData.FragGroupData.FragSession.Fields.FragIndex >= FRAGMENTATION_MAX_SESSIONS)
{
status |= 0x04; /* FragSession index not supported */
}
/* Descriptor is not really defined in the specification */
/* Not clear how to handle this. */
/* Currently the descriptor is always correct */
if (fragSessionData.FragGroupData.Descriptor != 0x01020304)
{
/* status |= 0x08; // Wrong Descriptor */
}
if ((status & 0x0F) == 0)
{
/* The FragSessionSetup is accepted */
fragSessionData.FragGroupData.IsActive = true;
fragSessionData.FragDecoderProcessStatus = FRAG_SESSION_ONGOING;
FragSessionData[fragSessionData.FragGroupData.FragSession.Fields.FragIndex] = fragSessionData;
FragDecoderInit(fragSessionData.FragGroupData.FragNb,
fragSessionData.FragGroupData.FragSize,
&LmhpFragmentationParams->DecoderCallbacks);
}
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = FRAGMENTATION_FRAG_SESSION_SETUP_ANS;
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = status;
isAnswerDelayed = false;
break;
}
case FRAGMENTATION_FRAG_SESSION_DELETE_REQ:
{
if (mcpsIndication->Multicast == 1)
{
/* Multicast channel. Don't process command. */
break;
}
uint8_t status = 0x00;
uint8_t id = mcpsIndication->Buffer[cmdIndex++] & 0x03;
status |= id;
if ((id >= FRAGMENTATION_MAX_SESSIONS) || (FragSessionData[id].FragGroupData.IsActive == false))
{
status |= 0x04; /* Session does not exist */
}
else
{
/* Delete session */
FragSessionData[id].FragGroupData.IsActive = false;
}
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = FRAGMENTATION_FRAG_SESSION_DELETE_ANS;
LmhpFragmentationState.DataBuffer[dataBufferIndex++] = status;
isAnswerDelayed = false;
break;
}
case FRAGMENTATION_DATA_FRAGMENT:
{
uint8_t fragIndex = 0;
uint16_t fragCounter = 0;
fragCounter = (mcpsIndication->Buffer[cmdIndex++] << 0) & 0x00FF;
fragCounter |= (mcpsIndication->Buffer[cmdIndex++] << 8) & 0xFF00;
fragIndex = (fragCounter >> 14) & 0x03;
fragCounter &= 0x3FFF;
if (FragSessionData[fragIndex].FragGroupData.IsActive == false)
{
cmdIndex = mcpsIndication->BufferSize;
break;
}
if (mcpsIndication->Multicast == 1)
{
/* Message received on a multicast address */
/* Check McGroupBitMask */
uint8_t groupId = LoRaMacMcChannelGetGroupId(mcpsIndication->DevAddress);
if ((groupId == 0xFF) ||
((FragSessionData[fragIndex].FragGroupData.FragSession.Fields.McGroupBitMask & (1 << groupId)) == 0))
{
/* Ignore message */
cmdIndex = mcpsIndication->BufferSize;
break;
}
}
if (FragSessionData[fragIndex].FragDecoderProcessStatus == FRAG_SESSION_ONGOING)
{
FragSessionData[fragIndex].FragDecoderProcessStatus = FragDecoderProcess(fragCounter, &mcpsIndication->Buffer[cmdIndex]);
FragSessionData[fragIndex].FragDecoderStatus = FragDecoderGetStatus();
if (LmhpFragmentationParams->OnProgress != NULL)
{
LmhpFragmentationParams->OnProgress(FragSessionData[fragIndex].FragDecoderStatus.FragNbRx,
FragSessionData[fragIndex].FragGroupData.FragNb,
FragSessionData[fragIndex].FragGroupData.FragSize,
FragSessionData[fragIndex].FragDecoderStatus.FragNbLost);
}
}
else
{
if (FragSessionData[fragIndex].FragDecoderProcessStatus >= 0)
{
/* Fragmentation successfully done */
if (LmhpFragmentationParams->OnDone != NULL)
{
LmhpFragmentationParams->OnDone(FragSessionData[fragIndex].FragDecoderProcessStatus,
(FragSessionData[fragIndex].FragGroupData.FragNb * FragSessionData[fragIndex].FragGroupData.FragSize) -
FragSessionData[fragIndex].FragGroupData.Padding);
}
FragSessionData[fragIndex].FragDecoderProcessStatus = FRAG_SESSION_NOT_STARTED;
}
}
cmdIndex += FragSessionData[fragIndex].FragGroupData.FragSize;
break;
}
default:
{
break;
}
}
}
/* After processing the commands, if the end-node has to reply back then a flag is checked if the */
/* reply is to be sent immediately or with a delay. */
/* In some scenarios it is not desired that multiple end-notes send uplinks at the same time to */
/* the same server. (Example: Fragment status during a multicast FUOTA) */
if (dataBufferIndex != 0)
{
/* Answer commands */
LmHandlerAppData_t appData =
{
.Buffer = LmhpFragmentationState.DataBuffer,
.BufferSize = dataBufferIndex,
.Port = FRAGMENTATION_PORT
};
if (isAnswerDelayed == true)
{
/* Delay value is calculated using BlockAckDelay which is communicated by server during the FragSessionSetupReq */
/* Pseudo Random Delay = rand(0:1) * 2^(blockAckDelay + 4) Seconds. */
/* Delay = Pseudo Random Delay * 1000 milli seconds. */
/* Eg: blockAckDelay = 7 */
/* Pseudo Random Delay = rand(0:1) * 2^11 */
/* rand(0:1) seconds = rand(0:1000) milliseconds */
/* Delay = rand(0:1000) * 2048 => 2048000ms = 34 minutes */
TxDelayTime = randr(0, 1000) * (1 << (blockAckDelay + 4));
DelayedReplyAppData = appData;
LmhpFragmentationState.TxDelayState = FRAGMENTATION_TX_DELAY_STATE_START;
}
else
{
/* Send the prepared answer */
bool current_dutycycle;
LmHandlerGetDutyCycleEnable(&current_dutycycle);
/* force Duty Cycle OFF to this Send */
LmHandlerSetDutyCycleEnable(false);
LmhpFragmentationPackage.OnSendRequest(&appData, LORAMAC_HANDLER_UNCONFIRMED_MSG, NULL, true);
/* restore initial Duty Cycle */
LmHandlerSetDutyCycleEnable(current_dutycycle);
}
}
}
Reference in New Issue View Git Blame Copy Permalink