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/LmhpClockSync.c

415 lines
13 KiB
C
Raw Blame History

/*!
* \file LmhpClockSync.c
*
* \brief Implements the LoRa-Alliance clock synchronization package
* Specification: https://lora-alliance.org/sites/default/files/2018-09/application_layer_clock_synchronization_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 LmhpClockSync.c
* @author MCD Application Team
* @brief Clock Synchronisation Package definition
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "LmHandler.h"
#include "LmhpClockSync.h"
#include "utilities.h"
/* Private typedef -----------------------------------------------------------*/
/*!
* Package current context
*/
typedef struct LmhpClockSyncState_s
{
bool Initialized;
bool IsRunning;
uint8_t DataBufferMaxSize;
uint8_t *DataBuffer;
union
{
uint8_t Value;
struct
{
uint8_t TokenReq: 4;
uint8_t AnsRequired: 1;
uint8_t RFU: 3;
} Fields;
} TimeReqParam;
bool AppTimeReqPending;
bool AdrEnabledPrev;
uint8_t NbTransPrev;
uint8_t DataratePrev;
uint8_t NbTransmissions;
} LmhpClockSyncState_t;
typedef enum LmhpClockSyncMoteCmd_e
{
CLOCK_SYNC_PKG_VERSION_ANS = 0x00,
CLOCK_SYNC_APP_TIME_REQ = 0x01,
CLOCK_SYNC_APP_TIME_PERIOD_ANS = 0x02,
CLOCK_SYNC_FORCE_RESYNC_ANS = 0x03,
} LmhpClockSyncMoteCmd_t;
typedef enum LmhpClockSyncSrvCmd_e
{
CLOCK_SYNC_PKG_VERSION_REQ = 0x00,
CLOCK_SYNC_APP_TIME_ANS = 0x01,
CLOCK_SYNC_APP_TIME_PERIOD_REQ = 0x02,
CLOCK_SYNC_FORCE_RESYNC_REQ = 0x03,
} LmhpClockSyncSrvCmd_t;
/* Private define ------------------------------------------------------------*/
/*!
* LoRaWAN Application Layer Clock Synchronization Specification
*/
#define CLOCK_SYNC_PORT 202
#define CLOCK_SYNC_ID 1
#define CLOCK_SYNC_VERSION 1
/* Private macro -------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/*!
* 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 LmhpClockSyncInit(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 LmhpClockSyncIsInitialized(void);
/*!
* Returns the package operation status.
*
* \retval status Package operation status
* [true: Running, false: Not running]
*/
static bool LmhpClockSyncIsRunning(void);
/*!
* Processes the internal package events.
*/
static void LmhpClockSyncProcess(void);
/*!
* Processes the MCSP Confirm
*
* \param [in] mcpsConfirm MCPS confirmation primitive data
*/
static void LmhpClockSyncOnMcpsConfirm(McpsConfirm_t *mcpsConfirm);
/*!
* Processes the MCPS Indication
*
* \param [in] mcpsIndication MCPS indication primitive data
*/
static void LmhpClockSyncOnMcpsIndication(McpsIndication_t *mcpsIndication);
static void OnPeriodicTimeStartTimer(void *context);
/* Private variables ---------------------------------------------------------*/
static LmhpClockSyncState_t LmhpClockSyncState =
{
.Initialized = false,
.IsRunning = false,
.TimeReqParam.Value = 0,
.AppTimeReqPending = false,
.AdrEnabledPrev = false,
.NbTransPrev = 0,
.NbTransmissions = 0
};
static LmhPackage_t LmhpClockSyncPackage =
{
.Port = CLOCK_SYNC_PORT,
.Init = LmhpClockSyncInit,
.IsInitialized = LmhpClockSyncIsInitialized,
.IsRunning = LmhpClockSyncIsRunning,
.Process = LmhpClockSyncProcess,
.OnMcpsConfirmProcess = LmhpClockSyncOnMcpsConfirm,
.OnMcpsIndicationProcess = LmhpClockSyncOnMcpsIndication,
.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 */
};
/*!
* Periodic Time start timer
*/
static TimerEvent_t PeriodicTimeStartTimer;
/* Exported functions ---------------------------------------------------------*/
LmhPackage_t *LmphClockSyncPackageFactory(void)
{
return &LmhpClockSyncPackage;
}
LmHandlerErrorStatus_t LmhpClockSyncAppTimeReq(void)
{
if (LmHandlerIsBusy() == true)
{
return LORAMAC_HANDLER_ERROR;
}
if (LmhpClockSyncState.AppTimeReqPending == false)
{
MibRequestConfirm_t mibReq;
/* Disable ADR */
mibReq.Type = MIB_ADR;
LoRaMacMibGetRequestConfirm(&mibReq);
LmhpClockSyncState.AdrEnabledPrev = mibReq.Param.AdrEnable;
mibReq.Param.AdrEnable = false;
LoRaMacMibSetRequestConfirm(&mibReq);
/* Set NbTrans = 1 */
mibReq.Type = MIB_CHANNELS_NB_TRANS;
LoRaMacMibGetRequestConfirm(&mibReq);
LmhpClockSyncState.NbTransPrev = mibReq.Param.ChannelsNbTrans;
mibReq.Param.ChannelsNbTrans = 1;
LoRaMacMibSetRequestConfirm(&mibReq);
/* Store data rate */
mibReq.Type = MIB_CHANNELS_DATARATE;
LoRaMacMibGetRequestConfirm(&mibReq);
LmhpClockSyncState.DataratePrev = mibReq.Param.ChannelsDatarate;
/* Add DeviceTimeReq MAC command. */
/* In case the network server supports this more precise command */
/* this package will use DeviceTimeAns answer as clock synchronization */
/* mechanism. */
LmhpClockSyncPackage.OnDeviceTimeRequest();
}
SysTime_t curTime = SysTimeGet();
uint8_t dataBufferIndex = 0;
/* Subtract Unix to Gps epcoh offset. The system time is based on Unix time. */
curTime.Seconds -= UNIX_GPS_EPOCH_OFFSET;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = CLOCK_SYNC_APP_TIME_REQ;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = (curTime.Seconds >> 0) & 0xFF;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = (curTime.Seconds >> 8) & 0xFF;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = (curTime.Seconds >> 16) & 0xFF;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = (curTime.Seconds >> 24) & 0xFF;
LmhpClockSyncState.TimeReqParam.Fields.AnsRequired = 0;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = LmhpClockSyncState.TimeReqParam.Value;
LmHandlerAppData_t appData =
{
.Buffer = LmhpClockSyncState.DataBuffer,
.BufferSize = dataBufferIndex,
.Port = CLOCK_SYNC_PORT
};
LmhpClockSyncState.AppTimeReqPending = true;
bool current_dutycycle;
LmHandlerGetDutyCycleEnable(&current_dutycycle);
/* force Duty Cycle OFF to this Send */
LmHandlerSetDutyCycleEnable(false);
LmHandlerErrorStatus_t status = LmhpClockSyncPackage.OnSendRequest(&appData, LORAMAC_HANDLER_UNCONFIRMED_MSG, NULL, true);
/* restore initial Duty Cycle */
LmHandlerSetDutyCycleEnable(current_dutycycle);
return status;
}
/* Private functions ---------------------------------------------------------*/
static void LmhpClockSyncInit(void *params, uint8_t *dataBuffer, uint8_t dataBufferMaxSize)
{
if (dataBuffer != NULL)
{
LmhpClockSyncState.DataBuffer = dataBuffer;
LmhpClockSyncState.DataBufferMaxSize = dataBufferMaxSize;
LmhpClockSyncState.Initialized = true;
LmhpClockSyncState.IsRunning = true;
TimerInit(&PeriodicTimeStartTimer, OnPeriodicTimeStartTimer);
}
else
{
LmhpClockSyncState.IsRunning = false;
LmhpClockSyncState.Initialized = false;
}
}
static bool LmhpClockSyncIsInitialized(void)
{
return LmhpClockSyncState.Initialized;
}
static bool LmhpClockSyncIsRunning(void)
{
if (LmhpClockSyncState.Initialized == false)
{
return false;
}
return LmhpClockSyncState.IsRunning;
}
static void LmhpClockSyncProcess(void)
{
if (LmhpClockSyncState.NbTransmissions > 0)
{
if (LmhpClockSyncAppTimeReq() == LORAMAC_HANDLER_SUCCESS)
{
LmhpClockSyncState.NbTransmissions--;
}
}
}
static void LmhpClockSyncOnMcpsConfirm(McpsConfirm_t *mcpsConfirm)
{
MibRequestConfirm_t mibReq;
if (LmhpClockSyncState.AppTimeReqPending == true)
{
/* Revert ADR setting */
mibReq.Type = MIB_ADR;
mibReq.Param.AdrEnable = LmhpClockSyncState.AdrEnabledPrev;
LoRaMacMibSetRequestConfirm(&mibReq);
/* Revert NbTrans setting */
mibReq.Type = MIB_CHANNELS_NB_TRANS;
mibReq.Param.ChannelsNbTrans = LmhpClockSyncState.NbTransPrev;
LoRaMacMibSetRequestConfirm(&mibReq);
/* Revert data rate setting */
mibReq.Type = MIB_CHANNELS_DATARATE;
mibReq.Param.ChannelsDatarate = LmhpClockSyncState.DataratePrev;
LoRaMacMibSetRequestConfirm(&mibReq);
LmhpClockSyncState.AppTimeReqPending = false;
}
}
static void LmhpClockSyncOnMcpsIndication(McpsIndication_t *mcpsIndication)
{
uint8_t cmdIndex = 0;
uint8_t dataBufferIndex = 0;
while (cmdIndex < mcpsIndication->BufferSize)
{
switch (mcpsIndication->Buffer[cmdIndex++])
{
case CLOCK_SYNC_PKG_VERSION_REQ:
{
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = CLOCK_SYNC_PKG_VERSION_ANS;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = CLOCK_SYNC_ID;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = CLOCK_SYNC_VERSION;
break;
}
case CLOCK_SYNC_APP_TIME_ANS:
{
LmhpClockSyncState.NbTransmissions = 0;
/* Check if a more precise time correction has been received. */
/* If yes then don't process and ignore this answer. */
if (mcpsIndication->DeviceTimeAnsReceived == true)
{
cmdIndex += 5;
break;
}
int32_t timeCorrection = 0;
timeCorrection = (mcpsIndication->Buffer[cmdIndex++] << 0) & 0x000000FF;
timeCorrection += (mcpsIndication->Buffer[cmdIndex++] << 8) & 0x0000FF00;
timeCorrection += (mcpsIndication->Buffer[cmdIndex++] << 16) & 0x00FF0000;
timeCorrection += (mcpsIndication->Buffer[cmdIndex++] << 24) & 0xFF000000;
if ((mcpsIndication->Buffer[cmdIndex++] & 0x0F) == LmhpClockSyncState.TimeReqParam.Fields.TokenReq)
{
SysTime_t curTime = { .Seconds = 0, .SubSeconds = 0 };
curTime = SysTimeGet();
curTime.Seconds += timeCorrection;
SysTimeSet(curTime);
LmhpClockSyncState.TimeReqParam.Fields.TokenReq = (LmhpClockSyncState.TimeReqParam.Fields.TokenReq + 1) & 0x0F;
}
break;
}
case CLOCK_SYNC_APP_TIME_PERIOD_REQ:
{
uint32_t periodTime = mcpsIndication->Buffer[cmdIndex++] & 0x0F;
periodTime = (128 << periodTime) + randr(0, 30);
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = CLOCK_SYNC_APP_TIME_PERIOD_ANS;
/* Answer status supported. */
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = 0x00;
SysTime_t curTime = SysTimeGet();
/* Subtract Unix to Gps epcoh offset. The system time is based on Unix time. */
curTime.Seconds -= UNIX_GPS_EPOCH_OFFSET;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = (curTime.Seconds >> 0) & 0xFF;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = (curTime.Seconds >> 8) & 0xFF;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = (curTime.Seconds >> 16) & 0xFF;
LmhpClockSyncState.DataBuffer[dataBufferIndex++] = (curTime.Seconds >> 24) & 0xFF;
/* Start Periodic timer */
TimerSetValue(&PeriodicTimeStartTimer, periodTime * 1000);
TimerStart(&PeriodicTimeStartTimer);
break;
}
case CLOCK_SYNC_FORCE_RESYNC_REQ:
{
LmhpClockSyncState.NbTransmissions = mcpsIndication->Buffer[cmdIndex++] & 0X07;
break;
}
}
}
if (dataBufferIndex != 0)
{
/* Answer commands */
LmHandlerAppData_t appData =
{
.Buffer = LmhpClockSyncState.DataBuffer,
.BufferSize = dataBufferIndex,
.Port = CLOCK_SYNC_PORT
};
bool current_dutycycle;
LmHandlerGetDutyCycleEnable(&current_dutycycle);
/* force Duty Cycle OFF to this Send */
LmHandlerSetDutyCycleEnable(false);
LmhpClockSyncPackage.OnSendRequest(&appData, LORAMAC_HANDLER_UNCONFIRMED_MSG, NULL, true);
/* restore initial Duty Cycle */
LmHandlerSetDutyCycleEnable(current_dutycycle);
}
}
static void OnPeriodicTimeStartTimer(void *context)
{
LmhpClockSyncState.NbTransmissions = 1;
TimerStart(&PeriodicTimeStartTimer);
}
Reference in New Issue View Git Blame Copy Permalink