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

1645 lines
42 KiB
C
Raw Blame History

/*!
* \file LmHandler.c
*
* \brief Implements the LoRaMac layer handling.
* Provides the possibility to register applicative packages.
*
* \remark Inspired by the examples provided on the en.i-cube_lrwan fork.
* MCD Application Team ( STMicroelectronics International )
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
* ______ _
* / _____) _ | |
* ( (____ _____ ____ _| |_ _____ ____| |__
* \____ \| ___ | (_ _) ___ |/ ___) _ \
* _____) ) ____| | | || |_| ____( (___| | | |
* (______/|_____)_|_|_| \__)_____)\____)_| |_|
* (C)2013-2018 Semtech
*
* \endcode
*
* \author Miguel Luis ( Semtech )
*/
/**
******************************************************************************
*
* Portions COPYRIGHT 2020 STMicroelectronics
*
* @file LmHandler.c
* @author MCD Application Team
* @brief LoRaMAC Layer handling definition
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "secure-element.h"
#include "LmHandler.h"
#include "Region.h"
#include "mw_log_conf.h" /* needed for MW_LOG */
#include "lorawan_version.h"
#include "Commissioning.h"
#if (!defined (LORAWAN_KMS) || (LORAWAN_KMS == 0))
#else /* LORAWAN_KMS == 1 */
#include "kms.h"
#include "kms_platf_objects_interface.h"
#endif /* LORAWAN_KMS */
#include "NvmCtxMgmt.h"
#include "lora_info.h"
#include "LmhpCompliance.h"
#include "LoRaMacTest.h"
#if (!defined (LORAWAN_DATA_DISTRIB_MGT) || (LORAWAN_DATA_DISTRIB_MGT == 0))
#else /* LORAWAN_DATA_DISTRIB_MGT == 1 */
#include "LmhpDataDistribution.h"
#endif /* LORAWAN_DATA_DISTRIB_MGT */
/* Private typedef -----------------------------------------------------------*/
/*!
* MAC notification type
*/
typedef enum PackageNotifyTypes_e
{
PACKAGE_MCPS_CONFIRM,
PACKAGE_MCPS_INDICATION,
PACKAGE_MLME_CONFIRM,
} PackageNotifyTypes_t;
/* Private define ------------------------------------------------------------*/
/*!
* Package application data buffer size
*/
#define LORAWAN_APP_DATA_BUFFER_MAX_SIZE 242
/* Private macro -------------------------------------------------------------*/
/*!
* Hex 8 split buffer
*/
#define HEX8(X) X[0], X[1], X[2], X[3], X[4], X[5], X[6], X[7]
/*!
* Hex 16 split buffer
*/
#define HEX16(X) HEX8(X), X[8], X[9], X[10], X[11], X[12], X[13], X[14], X[15]
/* Private function prototypes -----------------------------------------------*/
/*!
* \brief MCPS-Confirm event function
*
* \param [IN] mcpsConfirm Pointer to the confirm structure,
* containing confirm attributes.
*/
static void McpsConfirm(McpsConfirm_t *mcpsConfirm);
/*!
* \brief MCPS-Indication event function
*
* \param [IN] mcpsIndication Pointer to the indication structure,
* containing indication attributes.
*/
static void McpsIndication(McpsIndication_t *mcpsIndication);
/*!
* \brief MLME-Confirm event function
*
* \param [IN] MlmeConfirm Pointer to the confirm structure,
* containing confirm attributes.
*/
static void MlmeConfirm(MlmeConfirm_t *mlmeConfirm);
/*!
* \brief MLME-Indication event function
*
* \param [IN] mlmeIndication Pointer to the indication structure,
* containing indication attributes.
*/
static void MlmeIndication(MlmeIndication_t *mlmeIndication);
/*!
* \brief Requests network server time update
*
* \retval status Returns \ref LORAMAC_HANDLER_SUCCESS if request has been
* processed else \ref LORAMAC_HANDLER_ERROR
*/
static LmHandlerErrorStatus_t LmHandlerDeviceTimeReq(void);
#if ( LORAMAC_CLASSB_ENABLED == 1 )
/*!
* \brief Starts the beacon search
*
* \retval status Returns \ref LORAMAC_HANDLER_SUCCESS if request has been
* processed else \ref LORAMAC_HANDLER_ERROR
*/
static LmHandlerErrorStatus_t LmHandlerBeaconReq(void);
/*!
* \brief Informs the server on the ping-slot periodicity to use
*
* \param [IN] periodicity Is equal to 2^periodicity seconds.
* Example: 2^3 = 8 seconds. The end-device will open an Rx slot every 8 seconds.
*
* \retval status Returns \ref LORAMAC_HANDLER_SUCCESS if request has been
* processed else \ref LORAMAC_HANDLER_ERROR
*/
static LmHandlerErrorStatus_t LmHandlerPingSlotReq(uint8_t periodicity);
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
/*!
* \brief Notifies the package to process the LoRaMac callbacks.
*
* \param [IN] notifyType MAC notification type [PACKAGE_MCPS_CONFIRM,
* PACKAGE_MCPS_INDICATION,
* PACKAGE_MLME_CONFIRM,
* PACKAGE_MLME_INDICATION]
* \param [IN] params Notification parameters. The params type can be
* [McpsConfirm_t, McpsIndication_t, MlmeConfirm_t, MlmeIndication_t]
*/
static void LmHandlerPackagesNotify(PackageNotifyTypes_t notifyType, void *params);
/*!
* \brief Check if the package ID is initialized
*
* \param [IN] id package identifier
*
* \retval status Returns true if initialized else false
*/
static bool LmHandlerPackageIsInitialized(uint8_t id);
/*!
* \brief Displays end-device class update
*
* \param [IN] deviceClass Current end-device class
*/
static void DisplayClassUpdate(DeviceClass_t deviceClass);
#if ( LORAMAC_CLASSB_ENABLED == 1 )
/*!
* \brief Displays beacon status update
*
* \param [IN] params Beacon parameters
*/
static void DisplayBeaconUpdate(LmHandlerBeaconParams_t *params);
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
/* Private variables ---------------------------------------------------------*/
static CommissioningParams_t CommissioningParams =
{
.DevEui = { 0 }, /* Automatically filed from secure-element */
.JoinEui = { 0 }, /* Automatically filed from secure-element */
.NetworkId = LORAWAN_NETWORK_ID,
.DevAddr = LORAWAN_DEVICE_ADDRESS,
};
/*!
* LoRaWAN compliance tests handler parameters
*/
static LmhpComplianceParams_t LmhpComplianceParams =
{
.AdrEnabled = LORAMAC_HANDLER_ADR_ON,
.DutyCycleEnabled = false,
.StopPeripherals = NULL,
.StartPeripherals = NULL,
};
static LmhPackage_t *LmHandlerPackages[PKG_MAX_NUMBER];
/*!
* Upper layer LoRaMac parameters
*/
static LmHandlerParams_t LmHandlerParams;
/*!
* Upper layer callbacks
*/
static LmHandlerCallbacks_t LmHandlerCallbacks;
/*!
* Used to notify LmHandler of LoRaMac events
*/
static LoRaMacPrimitives_t LoRaMacPrimitives;
/*!
* LoRaMac callbacks
*/
static LoRaMacCallback_t LoRaMacCallbacks;
static LmHandlerJoinParams_t JoinParams =
{
.Mode = ACTIVATION_TYPE_NONE,
.Datarate = DR_0,
.Status = LORAMAC_HANDLER_ERROR
};
static LmHandlerTxParams_t TxParams =
{
.MsgType = LORAMAC_HANDLER_UNCONFIRMED_MSG,
.AckReceived = 0,
.Datarate = DR_0,
.UplinkCounter = 0,
.AppData =
{
.Port = 0,
.BufferSize = 0,
.Buffer = NULL
},
.TxPower = TX_POWER_0,
.Channel = 0
};
static LmHandlerRxParams_t RxParams =
{
.Rssi = 0,
.Snr = 0,
.DownlinkCounter = 0,
.RxSlot = -1
};
#if ( LORAMAC_CLASSB_ENABLED == 1 )
static LmHandlerBeaconParams_t BeaconParams =
{
.State = LORAMAC_HANDLER_BEACON_ACQUIRING,
.Info =
{
.Time = { .Seconds = 0, .SubSeconds = 0 },
.Frequency = 0,
.Datarate = 0,
.Rssi = 0,
.Snr = 0,
.GwSpecific =
{
.InfoDesc = 0,
.Info = { 0 }
}
}
};
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
/*!
* Package Application buffer
*/
static uint8_t AppDataBuffer[LORAWAN_APP_DATA_BUFFER_MAX_SIZE];
/*!
* Package application data structure
*/
static LmHandlerAppData_t AppData = { 0, 0, AppDataBuffer };
#if ( LORAMAC_CLASSB_ENABLED == 1 )
/*!
* Indicates if a switch to Class B operation is pending or not.
*/
static bool IsClassBSwitchPending = false;
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
static bool CtxRestoreDone = false;
/* Exported functions ---------------------------------------------------------*/
LmHandlerErrorStatus_t LmHandlerInit(LmHandlerCallbacks_t *handlerCallbacks)
{
UTIL_MEM_cpy_8((void *)&LmHandlerCallbacks, (const void *)handlerCallbacks, sizeof(LmHandlerCallbacks_t));
LoRaMacPrimitives.MacMcpsConfirm = McpsConfirm;
LoRaMacPrimitives.MacMcpsIndication = McpsIndication;
LoRaMacPrimitives.MacMlmeConfirm = MlmeConfirm;
LoRaMacPrimitives.MacMlmeIndication = MlmeIndication;
LoRaMacCallbacks.GetBatteryLevel = LmHandlerCallbacks.GetBatteryLevel;
LoRaMacCallbacks.GetTemperatureLevel = LmHandlerCallbacks.GetTemperature;
LoRaMacCallbacks.NvmContextChange = NvmCtxMgmtEvent;
LoRaMacCallbacks.MacProcessNotify = LmHandlerCallbacks.OnMacProcess;
/*The LoRa-Alliance Compliance protocol package should always be initialized and activated.*/
if (LmHandlerPackageRegister(PACKAGE_ID_COMPLIANCE, &LmhpComplianceParams) != LORAMAC_HANDLER_SUCCESS)
{
return LORAMAC_HANDLER_ERROR;
}
#if (!defined (LORAWAN_DATA_DISTRIB_MGT) || (LORAWAN_DATA_DISTRIB_MGT == 0))
#else /*LORAWAN_DATA_DISTRIB_MGT == 1*/
if (LmhpDataDistributionInit() != LORAMAC_HANDLER_SUCCESS)
{
return LORAMAC_HANDLER_ERROR;
}
#endif /*LORAWAN_DATA_DISTRIB_MGT*/
return LORAMAC_HANDLER_SUCCESS;
}
LmHandlerErrorStatus_t LmHandlerConfigure(LmHandlerParams_t *handlerParams)
{
MibRequestConfirm_t mibReq;
LoraInfo_t *loraInfo;
UTIL_MEM_cpy_8((void *)&LmHandlerParams, (const void *)handlerParams, sizeof(LmHandlerParams_t));
#if ( LORAMAC_CLASSB_ENABLED == 1 )
IsClassBSwitchPending = false;
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
loraInfo = LoraInfo_GetPtr();
if (0U != ((1 << (LmHandlerParams.ActiveRegion)) & (loraInfo->Region)))
{
if (LoRaMacInitialization(&LoRaMacPrimitives, &LoRaMacCallbacks, LmHandlerParams.ActiveRegion) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
}
else
{
MW_LOG(TS_ON, VLEVEL_ALWAYS, "error: Region is not defined in the MW: set lorawan_conf.h accordingly\r\n");
while (1) {} /* error: Region is not defined in the MW */
}
/* Try to restore from NVM and query the mac if possible. */
if (NvmCtxMgmtRestore() == NVMCTXMGMT_STATUS_SUCCESS)
{
CtxRestoreDone = true;
}
else
{
CtxRestoreDone = false;
#if (defined (LORAWAN_KMS) && (LORAWAN_KMS == 1))
SecureElementSetObjHandler(APP_KEY, KMS_APP_KEY_OBJECT_HANDLE);
SecureElementSetObjHandler(NWK_KEY, KMS_NWK_KEY_OBJECT_HANDLE);
#if ( LORAMAC_CLASSB_ENABLED == 1 )
SecureElementSetObjHandler(SLOT_RAND_ZERO_KEY, KMS_ZERO_KEY_OBJECT_HANDLE);
#endif /* LORAMAC_CLASSB_ENABLED */
#endif /* LORAWAN_KMS == 1 */
/* Read secure-element DEV_EUI and JOIN_EUI values. */
mibReq.Type = MIB_DEV_EUI;
LoRaMacMibGetRequestConfirm(&mibReq);
memcpy1(CommissioningParams.DevEui, mibReq.Param.DevEui, 8);
mibReq.Type = MIB_JOIN_EUI;
LoRaMacMibGetRequestConfirm(&mibReq);
memcpy1(CommissioningParams.JoinEui, mibReq.Param.JoinEui, 8);
}
MW_LOG(TS_OFF, VLEVEL_M, "###### DevEui: %02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\r\n",
HEX8(CommissioningParams.DevEui));
MW_LOG(TS_OFF, VLEVEL_M, "###### AppEui: %02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\r\n",
HEX8(CommissioningParams.JoinEui));
#if (defined (LORAWAN_KMS) && (LORAWAN_KMS == 1))
MW_LOG(TS_OFF, VLEVEL_L, "###### KMS ENABLED \r\n");
#endif /* LORAWAN_KMS == 1 */
mibReq.Type = MIB_PUBLIC_NETWORK;
mibReq.Param.EnablePublicNetwork = LORAWAN_PUBLIC_NETWORK;
LoRaMacMibSetRequestConfirm(&mibReq);
mibReq.Type = MIB_REPEATER_SUPPORT;
mibReq.Param.EnableRepeaterSupport = LORAWAN_REPEATER_SUPPORT;
LoRaMacMibSetRequestConfirm(&mibReq);
mibReq.Type = MIB_ADR;
mibReq.Param.AdrEnable = LmHandlerParams.AdrEnable;
LoRaMacMibSetRequestConfirm(&mibReq);
mibReq.Type = MIB_SYSTEM_MAX_RX_ERROR;
mibReq.Param.SystemMaxRxError = 20;
LoRaMacMibSetRequestConfirm(&mibReq);
GetPhyParams_t getPhy;
PhyParam_t phyParam;
getPhy.Attribute = PHY_DUTY_CYCLE;
phyParam = RegionGetPhyParam(LmHandlerParams.ActiveRegion, &getPhy);
LmHandlerParams.DutyCycleEnabled = (bool) phyParam.Value;
/* override previous value if reconfigure new region */
LoRaMacTestSetDutyCycleOn(LmHandlerParams.DutyCycleEnabled);
return LORAMAC_HANDLER_SUCCESS;
}
bool LmHandlerIsBusy(void)
{
if (LoRaMacIsBusy() == true)
{
return true;
}
if (LmHandlerJoinStatus() != LORAMAC_HANDLER_SET)
{
/* The network isn't yet joined, try again later. */
LmHandlerJoin(JoinParams.Mode);
return true;
}
if (LmHandlerPackages[PACKAGE_ID_COMPLIANCE]->IsRunning() == true)
{
return true;
}
return false;
}
void LmHandlerProcess(void)
{
/* Call at first the LoRaMAC process before to run all package process features */
/* Processes the LoRaMac events */
LoRaMacProcess();
/* Call all packages process functions */
for (int8_t i = 0; i < PKG_MAX_NUMBER; i++)
{
if ((LmHandlerPackages[i] != NULL) &&
(LmHandlerPackages[i]->Process != NULL) &&
(LmHandlerPackageIsInitialized(i) != false))
{
LmHandlerPackages[i]->Process();
}
}
NvmCtxMgmtStore();
}
LmHandlerFlagStatus_t LmHandlerJoinStatus(void)
{
MibRequestConfirm_t mibReq;
LoRaMacStatus_t status;
mibReq.Type = MIB_NETWORK_ACTIVATION;
status = LoRaMacMibGetRequestConfirm(&mibReq);
if (status == LORAMAC_STATUS_OK)
{
if (mibReq.Param.NetworkActivation == ACTIVATION_TYPE_NONE)
{
return LORAMAC_HANDLER_RESET;
}
else
{
return LORAMAC_HANDLER_SET;
}
}
else
{
return LORAMAC_HANDLER_RESET;
}
}
void LmHandlerJoin(ActivationType_t mode)
{
MibRequestConfirm_t mibReq;
#if (!defined (LORAWAN_KMS) || (LORAWAN_KMS == 0))
#else /* LORAWAN_KMS == 1 */
#if (OVER_THE_AIR_ACTIVATION == 0)
if (mode == ACTIVATION_TYPE_OTAA)
{
MW_LOG(TS_OFF, VLEVEL_M, "ERROR: OTAA mode not implemented\r\n");
while (1);
}
#endif /* OVER_THE_AIR_ACTIVATION */
#if (ACTIVATION_BY_PERSONALISATION == 0)
if (mode == ACTIVATION_TYPE_ABP)
{
MW_LOG(TS_OFF, VLEVEL_M, "ERROR: ABP mode not implemented\r\n");
while (1);
}
#endif /* ACTIVATION_BY_PERSONALISATION */
SecureElementDeleteDerivedKeys(NULL);
#endif /* LORAWAN_KMS */
if (mode == ACTIVATION_TYPE_OTAA)
{
MlmeReq_t mlmeReq;
JoinParams.Mode = ACTIVATION_TYPE_OTAA;
LoRaMacStart();
/* Starts the OTAA join procedure */
mlmeReq.Type = MLME_JOIN;
mlmeReq.Req.Join.Datarate = LmHandlerParams.TxDatarate;
LoRaMacMlmeRequest(&mlmeReq);
}
else
{
JoinParams.Mode = ACTIVATION_TYPE_ABP;
JoinParams.Status = LORAMAC_HANDLER_SUCCESS;
if (CtxRestoreDone == false)
{
/* Tell the MAC layer which network server version are we connecting too. */
mibReq.Type = MIB_ABP_LORAWAN_VERSION;
mibReq.Param.AbpLrWanVersion.Value = ABP_ACTIVATION_LRWAN_VERSION;
LoRaMacMibSetRequestConfirm(&mibReq);
mibReq.Type = MIB_NET_ID;
mibReq.Param.NetID = CommissioningParams.NetworkId;
LoRaMacMibSetRequestConfirm(&mibReq);
#if ( STATIC_DEVICE_ADDRESS != 1 )
CommissioningParams.DevAddr = GetDevAddr();
#endif /* STATIC_DEVICE_ADDRESS != 1 */
mibReq.Type = MIB_DEV_ADDR;
mibReq.Param.DevAddr = CommissioningParams.DevAddr;
LoRaMacMibSetRequestConfirm(&mibReq);
MW_LOG(TS_OFF, VLEVEL_M, "###### DevAddr: %08X\r\n", CommissioningParams.DevAddr);
#if (defined (LORAWAN_KMS) && (LORAWAN_KMS == 1))
#if ( USE_LRWAN_1_1_X_CRYPTO == 1 )
SecureElementSetObjHandler(F_NWK_S_INT_KEY, KMS_F_NWK_S_INT_KEY_OBJECT_HANDLE);
SecureElementSetObjHandler(S_NWK_S_INT_KEY, KMS_S_NWK_S_INT_KEY_OBJECT_HANDLE);
SecureElementSetObjHandler(NWK_S_ENC_KEY, KMS_NWK_S_ENC_KEY_OBJECT_HANDLE);
#else /* USE_LRWAN_1_1_X_CRYPTO == 0 */
SecureElementSetObjHandler(NWK_S_KEY, KMS_NWK_S_KEY_OBJECT_HANDLE);
#endif /* USE_LRWAN_1_1_X_CRYPTO */
SecureElementSetObjHandler(APP_S_KEY, KMS_APP_S_KEY_OBJECT_HANDLE);
#endif /* LORAWAN_KMS == 1 */
}
LoRaMacStart();
mibReq.Type = MIB_NETWORK_ACTIVATION;
mibReq.Param.NetworkActivation = ACTIVATION_TYPE_ABP;
LoRaMacMibSetRequestConfirm(&mibReq);
LmHandlerCallbacks.OnJoinRequest(&JoinParams);
LmHandlerRequestClass(LmHandlerParams.DefaultClass);
}
}
LmHandlerErrorStatus_t LmHandlerStop(void)
{
if (LoRaMacDeInitialization() == LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_SUCCESS;
}
else
{
return LORAMAC_HANDLER_BUSY_ERROR;
}
}
LmHandlerErrorStatus_t LmHandlerSend(LmHandlerAppData_t *appData, LmHandlerMsgTypes_t isTxConfirmed,
TimerTime_t *nextTxIn, bool allowDelayedTx)
{
LoRaMacStatus_t status;
LmHandlerErrorStatus_t lmhStatus = LORAMAC_HANDLER_ERROR;
McpsReq_t mcpsReq;
LoRaMacTxInfo_t txInfo;
if (LoRaMacIsBusy() == true)
{
return LORAMAC_HANDLER_BUSY_ERROR;
}
if (LmHandlerJoinStatus() != LORAMAC_HANDLER_SET)
{
/* The network isn't yet joined, try again later. */
LmHandlerJoin(JoinParams.Mode);
return LORAMAC_HANDLER_NO_NETWORK_JOINED;
}
if ((LmHandlerPackages[PACKAGE_ID_COMPLIANCE]->IsRunning() == true)
&& (appData->Port != LmHandlerPackages[PACKAGE_ID_COMPLIANCE]->Port) && (appData->Port != 0))
{
return LORAMAC_HANDLER_COMPLIANCE_RUNNING;
}
mcpsReq.Req.Unconfirmed.Datarate = LmHandlerParams.TxDatarate;
if (LoRaMacQueryTxPossible(appData->BufferSize, &txInfo) != LORAMAC_STATUS_OK)
{
/* Send empty frame in order to flush MAC commands */
TxParams.MsgType = LORAMAC_HANDLER_UNCONFIRMED_MSG;
mcpsReq.Type = MCPS_UNCONFIRMED;
mcpsReq.Req.Unconfirmed.fBuffer = NULL;
mcpsReq.Req.Unconfirmed.fBufferSize = 0;
}
else
{
TxParams.MsgType = isTxConfirmed;
mcpsReq.Req.Unconfirmed.fPort = appData->Port;
mcpsReq.Req.Unconfirmed.fBufferSize = appData->BufferSize;
mcpsReq.Req.Unconfirmed.fBuffer = appData->Buffer;
if (isTxConfirmed == LORAMAC_HANDLER_UNCONFIRMED_MSG)
{
mcpsReq.Type = MCPS_UNCONFIRMED;
}
else
{
mcpsReq.Type = MCPS_CONFIRMED;
mcpsReq.Req.Confirmed.NbTrials = 8;
}
}
TxParams.AppData = *appData;
TxParams.Datarate = LmHandlerParams.TxDatarate;
status = LoRaMacMcpsRequest(&mcpsReq, allowDelayedTx);
if (nextTxIn != NULL)
{
*nextTxIn = mcpsReq.ReqReturn.DutyCycleWaitTime;
}
switch(status)
{
case LORAMAC_STATUS_OK:
lmhStatus = LORAMAC_HANDLER_SUCCESS;
break;
case LORAMAC_STATUS_BUSY:
case LORAMAC_STATUS_BUSY_UPLINK_COLLISION:
case LORAMAC_STATUS_BUSY_BEACON_RESERVED_TIME:
case LORAMAC_STATUS_BUSY_PING_SLOT_WINDOW_TIME:
lmhStatus = LORAMAC_HANDLER_BUSY_ERROR;
break;
case LORAMAC_STATUS_NO_NETWORK_JOINED:
lmhStatus = LORAMAC_HANDLER_NO_NETWORK_JOINED;
break;
case LORAMAC_STATUS_CRYPTO_ERROR:
lmhStatus = LORAMAC_HANDLER_CRYPTO_ERROR;
break;
case LORAMAC_STATUS_DUTYCYCLE_RESTRICTED:
lmhStatus = LORAMAC_HANDLER_DUTYCYCLE_RESTRICTED;
break;
case LORAMAC_STATUS_SERVICE_UNKNOWN:
case LORAMAC_STATUS_PARAMETER_INVALID:
case LORAMAC_STATUS_MAC_COMMAD_ERROR:
case LORAMAC_STATUS_FCNT_HANDLER_ERROR:
case LORAMAC_STATUS_REGION_NOT_SUPPORTED:
case LORAMAC_STATUS_NO_FREE_CHANNEL_FOUND:
case LORAMAC_STATUS_NO_CHANNEL_FOUND:
case LORAMAC_STATUS_LENGTH_ERROR:
default:
lmhStatus = LORAMAC_HANDLER_ERROR;
break;
}
return lmhStatus;
}
LmHandlerErrorStatus_t LmHandlerRequestClass(DeviceClass_t newClass)
{
MibRequestConfirm_t mibReq;
DeviceClass_t currentClass;
LmHandlerErrorStatus_t errorStatus = LORAMAC_HANDLER_SUCCESS;
if (LmHandlerJoinStatus() != LORAMAC_HANDLER_SET)
{
return LORAMAC_HANDLER_NO_NETWORK_JOINED;
}
mibReq.Type = MIB_DEVICE_CLASS;
if (LoRaMacMibGetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
currentClass = mibReq.Param.Class;
/* Attempt to switch only if class update */
if (currentClass != newClass)
{
switch (newClass)
{
case CLASS_A:
{
if (currentClass != CLASS_A)
{
mibReq.Param.Class = CLASS_A;
if (LoRaMacMibSetRequestConfirm(&mibReq) == LORAMAC_STATUS_OK)
{
/* Switch is instantaneous */
DisplayClassUpdate(CLASS_A);
}
else
{
errorStatus = LORAMAC_HANDLER_ERROR;
}
}
}
break;
case CLASS_B:
{
#if ( LORAMAC_CLASSB_ENABLED == 1 )
if (currentClass != CLASS_A)
{
errorStatus = LORAMAC_HANDLER_ERROR;
}
else
{
/* Beacon must first be acquired */
errorStatus = LmHandlerDeviceTimeReq();
IsClassBSwitchPending = true;
}
#else /* LORAMAC_CLASSB_ENABLED == 0 */
errorStatus = LORAMAC_HANDLER_ERROR;
#endif /* LORAMAC_CLASSB_ENABLED */
}
break;
case CLASS_C:
{
if (currentClass != CLASS_A)
{
errorStatus = LORAMAC_HANDLER_ERROR;
}
else
{
/* Switch is instantaneous */
mibReq.Param.Class = CLASS_C;
if (LoRaMacMibSetRequestConfirm(&mibReq) == LORAMAC_STATUS_OK)
{
DisplayClassUpdate(CLASS_C);
}
else
{
errorStatus = LORAMAC_HANDLER_ERROR;
}
}
}
break;
default:
break;
}
}
return errorStatus;
}
LmHandlerErrorStatus_t LmHandlerPackageRegister(uint8_t id, void *params)
{
LmhPackage_t *package = NULL;
switch (id)
{
case PACKAGE_ID_COMPLIANCE:
{
package = LmphCompliancePackageFactory();
break;
}
default:
#if (!defined (LORAWAN_DATA_DISTRIB_MGT) || (LORAWAN_DATA_DISTRIB_MGT == 0))
#else /*LORAWAN_DATA_DISTRIB_MGT == 1*/
LmhpDataDistributionPackageRegister(id, &package);
#endif /*LORAWAN_DATA_DISTRIB_MGT*/
break;
}
if (package != NULL)
{
LmHandlerPackages[id] = package;
LmHandlerPackages[id]->OnJoinRequest = LmHandlerJoin;
LmHandlerPackages[id]->OnSendRequest = LmHandlerSend;
LmHandlerPackages[id]->OnDeviceTimeRequest = LmHandlerDeviceTimeReq;
LmHandlerPackages[id]->Init(params, AppData.Buffer, LORAWAN_APP_DATA_BUFFER_MAX_SIZE);
return LORAMAC_HANDLER_SUCCESS;
}
else
{
return LORAMAC_HANDLER_ERROR;
}
}
int32_t LmHandlerGetCurrentClass(DeviceClass_t *deviceClass)
{
MibRequestConfirm_t mibReq;
if (deviceClass == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
mibReq.Type = MIB_DEVICE_CLASS;
if (LoRaMacMibGetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
*deviceClass = mibReq.Param.Class;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetTxDatarate(int8_t *txDatarate)
{
MibRequestConfirm_t mibGet;
if (txDatarate == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
mibGet.Type = MIB_CHANNELS_DATARATE;
if (LoRaMacMibGetRequestConfirm(&mibGet) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
*txDatarate = mibGet.Param.ChannelsDatarate;
LmHandlerParams.TxDatarate = mibGet.Param.ChannelsDatarate;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetActiveRegion(LoRaMacRegion_t *region)
{
if (region == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
*region = LmHandlerParams.ActiveRegion;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetDevEUI(uint8_t *devEUI)
{
if (devEUI == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
UTIL_MEM_cpy_8(devEUI, CommissioningParams.DevEui, 8);
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetDevEUI(uint8_t *devEUI)
{
#if ( STATIC_DEVICE_EUI != 1 )
MibRequestConfirm_t mibReq;
/* Not yet joined */
if (LmHandlerJoinStatus() != LORAMAC_HANDLER_SET)
{
mibReq.Type = MIB_DEV_EUI;
UTIL_MEM_cpy_8(mibReq.Param.DevEui, devEUI, SE_EUI_SIZE);
if (LoRaMacMibSetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
UTIL_MEM_cpy_8(CommissioningParams.DevEui, devEUI, SE_EUI_SIZE);
return LORAMAC_HANDLER_SUCCESS;
}
else
{
/* Cannot change Keys in running state */
return LORAMAC_HANDLER_ERROR;
}
#else /* STATIC_DEVICE_EUI == 1 */
return LORAMAC_HANDLER_ERROR;
#endif /* STATIC_DEVICE_EUI */
}
int32_t LmHandlerGetAppEUI(uint8_t *appEUI)
{
if (appEUI == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
UTIL_MEM_cpy_8(appEUI, CommissioningParams.JoinEui, 8);
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetAppEUI(uint8_t *appEUI)
{
/* Not yet joined */
if (LmHandlerJoinStatus() != LORAMAC_HANDLER_SET)
{
UTIL_MEM_cpy_8(CommissioningParams.JoinEui, appEUI, 8);
return LmHandlerConfigure(&LmHandlerParams);
}
else
{
/* Cannot change Keys in running state */
return LORAMAC_HANDLER_ERROR;
}
}
int32_t LmHandlerGetNetworkID(uint32_t *networkId)
{
if (networkId == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
*networkId = CommissioningParams.NetworkId;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetNetworkID(uint32_t networkId)
{
/* Not yet joined */
if (LmHandlerJoinStatus() != LORAMAC_HANDLER_SET)
{
CommissioningParams.NetworkId = networkId;
return LmHandlerConfigure(&LmHandlerParams);
}
else
{
/* Cannot change NetworkID in running state */
return LORAMAC_HANDLER_ERROR;
}
}
int32_t LmHandlerGetDevAddr(uint32_t *devAddr)
{
if (devAddr == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
*devAddr = CommissioningParams.DevAddr;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetDevAddr(uint32_t devAddr)
{
#if ( STATIC_DEVICE_ADDRESS != 1 )
/* Not yet joined */
if (LmHandlerJoinStatus() != LORAMAC_HANDLER_SET)
{
CommissioningParams.DevAddr = devAddr;
return LmHandlerConfigure(&LmHandlerParams);
}
else
{
/* Cannot change DevAddr in running state */
return LORAMAC_HANDLER_ERROR;
}
#else /* STATIC_DEVICE_ADDRESS == 1 */
return LORAMAC_HANDLER_ERROR;
#endif /* STATIC_DEVICE_ADDRESS */
}
int32_t LmHandlerSetActiveRegion(LoRaMacRegion_t region)
{
/* Not yet joined */
if (LmHandlerJoinStatus() != LORAMAC_HANDLER_SET)
{
LmHandlerParams.ActiveRegion = region;
return LmHandlerConfigure(&LmHandlerParams);
}
else
{
/* Cannot change Region in running state */
return LORAMAC_HANDLER_ERROR;
}
}
int32_t LmHandlerGetAdrEnable(bool *adrEnable)
{
if (adrEnable == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
*adrEnable = LmHandlerParams.AdrEnable;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetAdrEnable(bool adrEnable)
{
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_ADR;
mibReq.Param.AdrEnable = adrEnable;
if (LoRaMacMibSetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
LmHandlerParams.AdrEnable = adrEnable;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetTxDatarate(int8_t txDatarate)
{
if (LmHandlerParams.AdrEnable == true)
{
return LORAMAC_HANDLER_ERROR;
}
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_CHANNELS_DATARATE;
mibReq.Param.ChannelsDatarate = txDatarate;
if (LoRaMacMibSetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
LmHandlerParams.TxDatarate = txDatarate;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetDutyCycleEnable(bool *dutyCycleEnable)
{
if (dutyCycleEnable == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
*dutyCycleEnable = LmHandlerParams.DutyCycleEnabled;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetDutyCycleEnable(bool dutyCycleEnable)
{
LmHandlerParams.DutyCycleEnabled = dutyCycleEnable;
LoRaMacTestSetDutyCycleOn(dutyCycleEnable);
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetRX2Params(RxChannelParams_t *rxParams)
{
if (rxParams == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_RX2_CHANNEL;
if (LoRaMacMibGetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
rxParams->Frequency = mibReq.Param.Rx2Channel.Frequency;
rxParams->Datarate = mibReq.Param.Rx2Channel.Datarate;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetTxPower(int8_t *txPower)
{
MibRequestConfirm_t mibReq;
if (txPower == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
mibReq.Type = MIB_CHANNELS_TX_POWER;
if (LoRaMacMibGetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
*txPower = mibReq.Param.ChannelsTxPower;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetRx1Delay(uint32_t *rxDelay)
{
MibRequestConfirm_t mibReq;
if (rxDelay == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
mibReq.Type = MIB_RECEIVE_DELAY_1;
if (LoRaMacMibGetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
*rxDelay = mibReq.Param.ReceiveDelay1;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetRx2Delay(uint32_t *rxDelay)
{
MibRequestConfirm_t mibReq;
if (rxDelay == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
mibReq.Type = MIB_RECEIVE_DELAY_2;
if (LoRaMacMibGetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
*rxDelay = mibReq.Param.ReceiveDelay2;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetJoinRx1Delay(uint32_t *rxDelay)
{
MibRequestConfirm_t mibReq;
if (rxDelay == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
mibReq.Type = MIB_JOIN_ACCEPT_DELAY_1;
if (LoRaMacMibGetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
*rxDelay = mibReq.Param.JoinAcceptDelay1;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetJoinRx2Delay(uint32_t *rxDelay)
{
MibRequestConfirm_t mibReq;
if (rxDelay == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
mibReq.Type = MIB_JOIN_ACCEPT_DELAY_2;
if (LoRaMacMibGetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
*rxDelay = mibReq.Param.JoinAcceptDelay2;
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetTxPower(int8_t txPower)
{
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_CHANNELS_TX_POWER;
mibReq.Param.ChannelsTxPower = txPower;
if (LoRaMacMibSetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetRX2Params(RxChannelParams_t *rxParams)
{
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_RX2_CHANNEL;
mibReq.Param.Rx2Channel.Frequency = rxParams->Frequency;
mibReq.Param.Rx2Channel.Datarate = rxParams->Datarate;
if (LoRaMacMibSetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetRx1Delay(uint32_t rxDelay)
{
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_RECEIVE_DELAY_1;
mibReq.Param.ReceiveDelay1 = rxDelay;
if (LoRaMacMibSetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetRx2Delay(uint32_t rxDelay)
{
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_RECEIVE_DELAY_2;
mibReq.Param.ReceiveDelay2 = rxDelay;
if (LoRaMacMibSetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetJoinRx1Delay(uint32_t rxDelay)
{
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_JOIN_ACCEPT_DELAY_1;
mibReq.Param.JoinAcceptDelay1 = rxDelay;
if (LoRaMacMibSetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerSetJoinRx2Delay(uint32_t rxDelay)
{
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_JOIN_ACCEPT_DELAY_2;
mibReq.Param.JoinAcceptDelay2 = rxDelay;
if (LoRaMacMibSetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
return LORAMAC_HANDLER_SUCCESS;
}
int32_t LmHandlerGetPingPeriodicity(uint8_t *pingPeriodicity)
{
#if ( LORAMAC_CLASSB_ENABLED == 1 )
if (pingPeriodicity == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
*pingPeriodicity = LmHandlerParams.PingPeriodicity;
return LORAMAC_HANDLER_SUCCESS;
#else /* LORAMAC_CLASSB_ENABLED == 0 */
return LORAMAC_HANDLER_ERROR;
#endif /* LORAMAC_CLASSB_ENABLED */
}
int32_t LmHandlerSetPingPeriodicity(uint8_t pingPeriodicity)
{
#if ( LORAMAC_CLASSB_ENABLED == 1 )
/* Not yet joined */
if (LmHandlerJoinStatus() != LORAMAC_HANDLER_SET)
{
LmHandlerParams.PingPeriodicity = pingPeriodicity;
return LORAMAC_HANDLER_SUCCESS;
}
else
{
/* Cannot change Region in running state */
return LmHandlerPingSlotReq(pingPeriodicity);
}
#else /* LORAMAC_CLASSB_ENABLED == 0 */
return LORAMAC_HANDLER_ERROR;
#endif /* LORAMAC_CLASSB_ENABLED */
}
int32_t LmHandlerGetBeaconState(BeaconState_t *beaconState)
{
#if ( LORAMAC_CLASSB_ENABLED == 1 )
MibRequestConfirm_t mibReq;
LoRaMacClassBNvmCtx_t *CtxClassB;
if (beaconState == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
mibReq.Type = MIB_NVM_CTXS;
if (LoRaMacMibGetRequestConfirm(&mibReq) != LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_ERROR;
}
CtxClassB = (LoRaMacClassBNvmCtx_t *) mibReq.Param.Contexts->ClassBNvmCtx;
if (CtxClassB == NULL)
{
return LORAMAC_HANDLER_ERROR;
}
*beaconState = CtxClassB->BeaconCtx.BeaconState;
return LORAMAC_HANDLER_SUCCESS;
#else /* LORAMAC_CLASSB_ENABLED == 0 */
return LORAMAC_HANDLER_ERROR;
#endif /* LORAMAC_CLASSB_ENABLED */
}
/* Private functions ---------------------------------------------------------*/
static LmHandlerErrorStatus_t LmHandlerDeviceTimeReq(void)
{
LoRaMacStatus_t status;
MlmeReq_t mlmeReq;
mlmeReq.Type = MLME_DEVICE_TIME;
status = LoRaMacMlmeRequest(&mlmeReq);
if (status == LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_SUCCESS;
}
else
{
return LORAMAC_HANDLER_ERROR;
}
}
#if ( LORAMAC_CLASSB_ENABLED == 1 )
static LmHandlerErrorStatus_t LmHandlerBeaconReq(void)
{
LoRaMacStatus_t status = LORAMAC_STATUS_OK;
MlmeReq_t mlmeReq;
mlmeReq.Type = MLME_BEACON_ACQUISITION;
status = LoRaMacMlmeRequest(&mlmeReq);
if (status == LORAMAC_STATUS_OK)
{
return LORAMAC_HANDLER_SUCCESS;
}
else
{
return LORAMAC_HANDLER_ERROR;
}
}
static LmHandlerErrorStatus_t LmHandlerPingSlotReq(uint8_t periodicity)
{
LoRaMacStatus_t status;
MlmeReq_t mlmeReq;
mlmeReq.Type = MLME_PING_SLOT_INFO;
mlmeReq.Req.PingSlotInfo.PingSlot.Fields.Periodicity = periodicity;
mlmeReq.Req.PingSlotInfo.PingSlot.Fields.RFU = 0;
status = LoRaMacMlmeRequest(&mlmeReq);
if (status == LORAMAC_STATUS_OK)
{
LmHandlerParams.PingPeriodicity = periodicity;
/* Send an empty message */
LmHandlerAppData_t appData =
{
.Buffer = NULL,
.BufferSize = 0,
.Port = 0
};
return LmHandlerSend(&appData, LORAMAC_HANDLER_UNCONFIRMED_MSG, NULL, false);
}
else
{
return LORAMAC_HANDLER_ERROR;
}
}
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
static void McpsConfirm(McpsConfirm_t *mcpsConfirm)
{
TxParams.IsMcpsConfirm = 1;
TxParams.Status = mcpsConfirm->Status;
TxParams.Datarate = mcpsConfirm->Datarate;
TxParams.UplinkCounter = mcpsConfirm->UpLinkCounter;
TxParams.TxPower = mcpsConfirm->TxPower;
TxParams.Channel = mcpsConfirm->Channel;
TxParams.AckReceived = mcpsConfirm->AckReceived;
LmHandlerCallbacks.OnTxData(&TxParams);
LmHandlerPackagesNotify(PACKAGE_MCPS_CONFIRM, mcpsConfirm);
}
static void McpsIndication(McpsIndication_t *mcpsIndication)
{
LmHandlerAppData_t appData;
DeviceClass_t deviceClass;
RxParams.IsMcpsIndication = 1;
RxParams.Status = mcpsIndication->Status;
if (RxParams.Status != LORAMAC_EVENT_INFO_STATUS_OK)
{
return;
}
if (mcpsIndication->BufferSize > 0)
{
RxParams.Datarate = mcpsIndication->RxDatarate;
RxParams.Rssi = mcpsIndication->Rssi;
RxParams.Snr = mcpsIndication->Snr;
RxParams.DownlinkCounter = mcpsIndication->DownLinkCounter;
RxParams.RxSlot = mcpsIndication->RxSlot;
appData.Port = mcpsIndication->Port;
appData.BufferSize = mcpsIndication->BufferSize;
appData.Buffer = mcpsIndication->Buffer;
LmHandlerCallbacks.OnRxData(&appData, &RxParams);
}
/* Call packages RxProcess function */
LmHandlerPackagesNotify(PACKAGE_MCPS_INDICATION, mcpsIndication);
LmHandlerGetCurrentClass(&deviceClass);
if ((mcpsIndication->FramePending == true) && (deviceClass == CLASS_A))
{
/* The server signals that it has pending data to be sent. */
/* We schedule an uplink as soon as possible to flush the server. */
/* Send an empty message */
LmHandlerAppData_t appData =
{
.Buffer = NULL,
.BufferSize = 0,
.Port = 0
};
LmHandlerSend(&appData, LORAMAC_HANDLER_UNCONFIRMED_MSG, NULL, true);
}
}
static void MlmeConfirm(MlmeConfirm_t *mlmeConfirm)
{
TxParams.IsMcpsConfirm = 0;
TxParams.Status = mlmeConfirm->Status;
LmHandlerPackagesNotify(PACKAGE_MLME_CONFIRM, mlmeConfirm);
switch (mlmeConfirm->MlmeRequest)
{
case MLME_JOIN:
{
MibRequestConfirm_t mibReq;
mibReq.Type = MIB_DEV_ADDR;
LoRaMacMibGetRequestConfirm(&mibReq);
CommissioningParams.DevAddr = mibReq.Param.DevAddr;
LmHandlerGetTxDatarate(&JoinParams.Datarate);
if (mlmeConfirm->Status == LORAMAC_EVENT_INFO_STATUS_OK)
{
/* Status is OK, node has joined the network */
JoinParams.Status = LORAMAC_HANDLER_SUCCESS;
/* Notify upper layer */
LmHandlerRequestClass(LmHandlerParams.DefaultClass);
}
else
{
/* Join was not successful. Try to join again */
JoinParams.Status = LORAMAC_HANDLER_ERROR;
}
LmHandlerCallbacks.OnJoinRequest(&JoinParams);
}
break;
case MLME_LINK_CHECK:
{
/* Check DemodMargin */
/* Check NbGateways */
}
break;
case MLME_DEVICE_TIME:
{
#if ( LORAMAC_CLASSB_ENABLED == 1 )
if (IsClassBSwitchPending == true)
{
LmHandlerBeaconReq();
}
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
}
break;
#if ( LORAMAC_CLASSB_ENABLED == 1 )
case MLME_BEACON_ACQUISITION:
{
if (mlmeConfirm->Status == LORAMAC_EVENT_INFO_STATUS_OK)
{
/* Beacon has been acquired */
/* Request server for ping slot */
LmHandlerPingSlotReq(LmHandlerParams.PingPeriodicity);
}
else
{
/* Beacon not acquired */
/* Request Device Time again. */
LmHandlerDeviceTimeReq();
}
}
break;
case MLME_PING_SLOT_INFO:
{
if (mlmeConfirm->Status == LORAMAC_EVENT_INFO_STATUS_OK)
{
MibRequestConfirm_t mibReq;
/* Class B is now activated */
mibReq.Type = MIB_DEVICE_CLASS;
mibReq.Param.Class = CLASS_B;
LoRaMacMibSetRequestConfirm(&mibReq);
DisplayClassUpdate(CLASS_B);
IsClassBSwitchPending = false;
}
else
{
LmHandlerPingSlotReq(LmHandlerParams.PingPeriodicity);
}
}
break;
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
default:
break;
}
}
static void MlmeIndication(MlmeIndication_t *mlmeIndication)
{
RxParams.IsMcpsIndication = 0;
RxParams.Status = mlmeIndication->Status;
switch (mlmeIndication->MlmeIndication)
{
#if ( LORAMAC_CLASSB_ENABLED == 1 )
case MLME_BEACON_LOST:
{
MibRequestConfirm_t mibReq;
/* Switch to class A again */
mibReq.Type = MIB_DEVICE_CLASS;
mibReq.Param.Class = CLASS_A;
LoRaMacMibSetRequestConfirm(&mibReq);
BeaconParams.State = LORAMAC_HANDLER_BEACON_LOST;
BeaconParams.Info.Time.Seconds = 0;
BeaconParams.Info.GwSpecific.InfoDesc = 0;
UTIL_MEM_set_8(BeaconParams.Info.GwSpecific.Info, 0, 6);
DisplayClassUpdate(CLASS_A);
DisplayBeaconUpdate(&BeaconParams);
LmHandlerDeviceTimeReq();
}
break;
case MLME_BEACON:
{
if (mlmeIndication->Status == LORAMAC_EVENT_INFO_STATUS_BEACON_LOCKED)
{
BeaconParams.State = LORAMAC_HANDLER_BEACON_RX;
BeaconParams.Info = mlmeIndication->BeaconInfo;
DisplayBeaconUpdate(&BeaconParams);
}
else
{
BeaconParams.State = LORAMAC_HANDLER_BEACON_NRX;
BeaconParams.Info = mlmeIndication->BeaconInfo;
DisplayBeaconUpdate(&BeaconParams);
}
break;
}
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
default:
break;
}
}
static bool LmHandlerPackageIsInitialized(uint8_t id)
{
if ((id < PKG_MAX_NUMBER) && (LmHandlerPackages[id]->IsInitialized != NULL))
{
return LmHandlerPackages[id]->IsInitialized();
}
else
{
return false;
}
}
static void LmHandlerPackagesNotify(PackageNotifyTypes_t notifyType, void *params)
{
for (int8_t i = 0; i < PKG_MAX_NUMBER; i++)
{
if (LmHandlerPackages[i] != NULL)
{
switch (notifyType)
{
case PACKAGE_MCPS_CONFIRM:
{
if (LmHandlerPackages[i]->OnMcpsConfirmProcess != NULL)
{
LmHandlerPackages[i]->OnMcpsConfirmProcess(params);
}
break;
}
case PACKAGE_MCPS_INDICATION:
{
if ((LmHandlerPackages[i]->OnMcpsIndicationProcess != NULL) &&
((LmHandlerPackages[i]->Port == ((McpsIndication_t *)params)->Port) ||
((i == PACKAGE_ID_COMPLIANCE) && (LmHandlerPackages[PACKAGE_ID_COMPLIANCE]->IsRunning()))))
{
LmHandlerPackages[i]->OnMcpsIndicationProcess(params);
}
break;
}
case PACKAGE_MLME_CONFIRM:
{
if (LmHandlerPackages[i]->OnMlmeConfirmProcess != NULL)
{
LmHandlerPackages[i]->OnMlmeConfirmProcess(params);
}
break;
}
default:
break;
}
}
}
}
static void DisplayClassUpdate(DeviceClass_t deviceClass)
{
MW_LOG(TS_OFF, VLEVEL_M, "Switch to Class %c done\r\n", "ABC"[deviceClass]);
}
#if ( LORAMAC_CLASSB_ENABLED == 1 )
static void DisplayBeaconUpdate(LmHandlerBeaconParams_t *params)
{
static const char *EventBeaconStateStrings[] = { "BC_ACQUIRING", "BC_LOST", "BC_RECEIVED", "BC_NOT_RECEIVED" };
MW_LOG(TS_OFF, VLEVEL_M, "\r\n###### ========== %s\r\n", EventBeaconStateStrings[params->State]);
if (params->State == LORAMAC_HANDLER_BEACON_RX)
{
MW_LOG(TS_OFF, VLEVEL_H, "###### BTIME:%010d | GW DESC:%d | GW INFO:%02X %02X %02X %02X %02X %02X\r\n",
params->Info.Time.Seconds, params->Info.GwSpecific.InfoDesc,
params->Info.GwSpecific.Info[0], params->Info.GwSpecific.Info[1],
params->Info.GwSpecific.Info[2], params->Info.GwSpecific.Info[3],
params->Info.GwSpecific.Info[4], params->Info.GwSpecific.Info[5]);
MW_LOG(TS_OFF, VLEVEL_H, "###### FREQ:%d | DR:%d | RSSI:%d | SNR:%d\r\n",
params->Info.Frequency, params->Info.Datarate,
params->Info.Rssi, params->Info.Snr);
}
}
#endif /* LORAMAC_CLASSB_ENABLED == 1 */
Reference in New Issue View Git Blame Copy Permalink