Simplified LoRaWAN library.
Fork of LoRaWAN-lib-v1_0_1 by
Diff: LoRaMac.cpp
- Revision:
- 2:14a5d6ad92d5
- Parent:
- 1:91e4e6c60d1e
- Child:
- 3:b9d87593a8ae
diff -r 91e4e6c60d1e -r 14a5d6ad92d5 LoRaMac.cpp --- a/LoRaMac.cpp Mon Nov 23 10:09:43 2015 +0000 +++ b/LoRaMac.cpp Tue Jan 05 16:41:54 2016 +0000 @@ -5,17 +5,23 @@ _____) ) ____| | | || |_| ____( (___| | | | (______/|_____)_|_|_| \__)_____)\____)_| |_| (C)2013 Semtech + ___ _____ _ ___ _ _____ ___ ___ ___ ___ +/ __|_ _/_\ / __| |/ / __/ _ \| _ \/ __| __| +\__ \ | |/ _ \ (__| ' <| _| (_) | / (__| _| +|___/ |_/_/ \_\___|_|\_\_| \___/|_|_\\___|___| +embedded.connectivity.solutions=============== Description: LoRa MAC layer implementation License: Revised BSD License, see LICENSE.TXT file include in the project -Maintainer: Miguel Luis and Gregory Cristian +Maintainer: Miguel Luis ( Semtech ), Gregory Cristian ( Semtech ) and Daniel Jäckle ( STACKFORCE ) */ #include "board.h" #include "LoRaMacCrypto.h" #include "LoRaMac.h" +#include "LoRaMacTest.h" /*! * Maximum PHY layer payload size @@ -77,7 +83,7 @@ static uint32_t LoRaMacDevAddr; /*! - * Mutlicast channels linked list + * Multicast channels linked list */ static MulticastParams_t *MulticastChannels = NULL; @@ -310,7 +316,7 @@ /*! * Up/Down link data rates offset definition */ -const int8_t datarateOffsets[16][4] = +const int8_t datarateOffsets[16][4] = { { DR_10, DR_9 , DR_8 , DR_8 }, // DR_0 { DR_11, DR_10, DR_9 , DR_8 }, // DR_1 @@ -358,6 +364,11 @@ */ static ChannelParams_t Channels[LORA_MAX_NB_CHANNELS]; +/*! + * Contains the channels which remain to be applied. + */ +static uint16_t ChannelsMaskRemaining[6]; + #else #error "Please define a frequency band in the compiler options." #endif @@ -409,7 +420,7 @@ static uint8_t MaxDCycle = 0; /*! - * Agregated duty cycle management + * Aggregated duty cycle management */ static uint16_t AggregatedDCycle; static TimerTime_t AggregatedLastTxDoneTime; @@ -428,14 +439,14 @@ /*! * LoRaMac internal states */ -enum LoRaMacState_e +enum eLoRaMacState { MAC_IDLE = 0x00000000, MAC_TX_RUNNING = 0x00000001, MAC_RX = 0x00000002, MAC_ACK_REQ = 0x00000004, MAC_ACK_RETRY = 0x00000008, - MAC_CHANNEL_CHECK = 0x00000010, + MAC_TX_DELAYED = 0x00000010, }; /*! @@ -451,22 +462,17 @@ /*! * LoRaMac upper layer event functions */ -static LoRaMacCallbacks_t *LoRaMacCallbacks; - -/*! - * LoRaMac notification event flags - */ -LoRaMacEventFlags_t LoRaMacEventFlags; +static LoRaMacPrimitives_t *LoRaMacPrimitives; /*! - * LoRaMac notification event info + * LoRaMac upper layer callback functions */ -LoRaMacEventInfo_t LoRaMacEventInfo; +static LoRaMacCallback_t *LoRaMacCallbacks; /*! - * LoRaMac channel check timer + * Radio events function pointer */ -static TimerEvent_t ChannelCheckTimer; +static RadioEvents_t RadioEvents; /*! * LoRaMac duty cycle delayed Tx timer @@ -526,64 +532,122 @@ TimerTime_t TxTimeOnAir = 0; /*! - * Function to be executed on Radio Tx Done event + * Structure to hold an MCPS indication data. + */ +static McpsIndication_t McpsIndication; + +/*! + * Structure to hold MCPS confirm data. + */ +static McpsConfirm_t McpsConfirm; + +/*! + * Structure to hold MLME confirm data. + */ +static MlmeConfirm_t MlmeConfirm; + +/*! + * Holds the current rx window slot + */ +static uint8_t RxSlot = 0; + +/*! + * LoRaMac tx/rx operation state + */ +LoRaMacFlags_t LoRaMacFlags; + +/*! + * \brief Function to be executed on Radio Tx Done event */ static void OnRadioTxDone( void ); /*! - * Function to be executed on Radio Rx Done event + * \brief Function to be executed on Radio Rx Done event */ static void OnRadioRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr ); /*! - * Function executed on Radio Tx Timeout event + * \brief Function executed on Radio Tx Timeout event */ static void OnRadioTxTimeout( void ); /*! - * Function executed on Radio Rx error event + * \brief Function executed on Radio Rx error event */ static void OnRadioRxError( void ); /*! - * Function executed on Radio Rx Timeout event + * \brief Function executed on Radio Rx Timeout event */ static void OnRadioRxTimeout( void ); /*! - * Function executed on Resend Frame timer event. + * \brief Function executed on Resend Frame timer event. */ static void OnMacStateCheckTimerEvent( void ); /*! - * Function executed on duty cycle delayed Tx timer event + * \brief Function executed on duty cycle delayed Tx timer event */ static void OnTxDelayedTimerEvent( void ); /*! - * Function executed on channel check timer event - */ -static void OnChannelCheckTimerEvent( void ); - -/*! - * Function executed on first Rx window timer event + * \brief Function executed on first Rx window timer event */ static void OnRxWindow1TimerEvent( void ); /*! - * Function executed on second Rx window timer event + * \brief Function executed on second Rx window timer event */ static void OnRxWindow2TimerEvent( void ); /*! - * Function executed on AckTimeout timer event + * \brief Function executed on AckTimeout timer event */ static void OnAckTimeoutTimerEvent( void ); /*! - * Radio events function pointer + * \brief Searches and set the next random available channel + * + * \retval status Function status [0: OK, 1: Unable to find a free channel] + */ +static TimerTime_t SetNextChannel( void ); + +/*! + * \brief Sets the network to public or private. Updates the sync byte. + * + * \param [IN] enable if true, it enables a public network + */ +static void SetPublicNetwork( bool enable ); + +/*! + * \brief Initializes and opens the reception window + * + * \param [IN] freq window channel frequency + * \param [IN] datarate window channel datarate + * \param [IN] bandwidth window channel bandwidth + * \param [IN] timeout window channel timeout */ -static RadioEvents_t RadioEvents; +static void RxWindowSetup( uint32_t freq, int8_t datarate, uint32_t bandwidth, uint16_t timeout, bool rxContinuous ); + +/*! + * \brief Adds a new MAC command to be sent. + * + * \Remark MAC layer internal function + * + * \param [in] cmd MAC command to be added + * [MOTE_MAC_LINK_CHECK_REQ, + * MOTE_MAC_LINK_ADR_ANS, + * MOTE_MAC_DUTY_CYCLE_ANS, + * MOTE_MAC_RX2_PARAM_SET_ANS, + * MOTE_MAC_DEV_STATUS_ANS + * MOTE_MAC_NEW_CHANNEL_ANS] + * \param [in] p1 1st parameter ( optional depends on the command ) + * \param [in] p2 2nd parameter ( optional depends on the command ) + * + * \retval status Function status [0: OK, 1: Unknown command, 2: Buffer full] + */ +static LoRaMacStatus_t AddMacCommand( uint8_t cmd, uint8_t p1, uint8_t p2 ); /*! * \brief Validates if the payload fits into the frame, taking the datarate @@ -596,10 +660,12 @@ * * \param datarate Current datarate * + * \param fOptsLen Length of the fOpts field + * * \retval [false: payload does not fit into the frame, true: payload fits into * the frame] */ -static bool ValidatePayloadLength( uint8_t lenN, int8_t datarate ); +static bool ValidatePayloadLength( uint8_t lenN, int8_t datarate, uint8_t fOptsLen ); #if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) /*! @@ -621,132 +687,1203 @@ static int8_t LimitTxPower( int8_t txPower ); /*! - * Searches and set the next random available channel + * \brief Verifies, if a value is in a given range. + * + * \param value Value to verify, if it is in range + * + * \param min Minimum possible value + * + * \param max Maximum possible value + * + * \retval Returns the maximum valid tx power + */ +static bool ValueInRange( int8_t value, int8_t min, int8_t max ); + +/*! + * \brief Calculates the next datarate to set, when ADR is on or off + * + * \param [IN] adrEnabled Specify whether ADR is on or off + * + * \param [IN] updateChannelMask Set to true, if the channel masks shall be updated + * + * \param [OUT] datarateOut Reports the datarate which will be used next + * + * \retval Returns the state of ADR ack request + */ +static bool AdrNextDr( bool adrEnabled, bool updateChannelMask, int8_t* datarateOut ); + +/*! + * \brief Disables channel in a specified channel mask + * + * \param [IN] id - Id of the channel + * + * \param [IN] mask - Pointer to the channel mask to edit * - * \retval status Function status [0: OK, 1: Unable to find a free channel] + * \retval [true, if disable was successful, false if not] + */ +static bool DisableChannelInMask( uint8_t id, uint16_t* mask ); + +/*! + * \brief Decodes MAC commands in the fOpts field and in the payload + */ +static void ProcessMacCommands( uint8_t *payload, uint8_t macIndex, uint8_t commandsSize, uint8_t snr ); + +/*! + * \brief LoRaMAC layer generic send frame + * + * \param [IN] macHdr MAC header field + * \param [IN] fPort MAC payload port + * \param [IN] fBuffer MAC data buffer to be sent + * \param [IN] fBufferSize MAC data buffer size + * \retval status Status of the operation. + */ +LoRaMacStatus_t Send( LoRaMacHeader_t *macHdr, uint8_t fPort, void *fBuffer, uint16_t fBufferSize ); + +/*! + * \brief LoRaMAC layer frame buffer initialization + * + * \param [IN] macHdr MAC header field + * \param [IN] fCtrl MAC frame control field + * \param [IN] fOpts MAC commands buffer + * \param [IN] fPort MAC payload port + * \param [IN] fBuffer MAC data buffer to be sent + * \param [IN] fBufferSize MAC data buffer size + * \retval status Status of the operation. + */ +LoRaMacStatus_t PrepareFrame( LoRaMacHeader_t *macHdr, LoRaMacFrameCtrl_t *fCtrl, uint8_t fPort, void *fBuffer, uint16_t fBufferSize ); + +/* + * \brief Schedules the frame according to the duty cycle + * + * \retval Status of the operation + */ +static LoRaMacStatus_t ScheduleTx( void ); + +/*! + * \brief LoRaMAC layer prepared frame buffer transmission with channel specification + * + * \remark PrepareFrame must be called at least once before calling this + * function. + * + * \param [IN] channel Channel parameters + * \retval status Status of the operation. */ -static uint8_t LoRaMacSetNextChannel( void ) +LoRaMacStatus_t SendFrameOnChannel( ChannelParams_t channel ); + + + +static void OnRadioTxDone( void ) +{ + TimerTime_t curTime = TimerGetCurrentTime( ); + if( LoRaMacDeviceClass != CLASS_C ) + { + Radio.Sleep( ); + } + else + { + OnRxWindow2TimerEvent( ); + } + + // Update Band Time OFF + Bands[Channels[Channel].Band].LastTxDoneTime = curTime; + if( DutyCycleOn == true ) + { + Bands[Channels[Channel].Band].TimeOff = TxTimeOnAir * Bands[Channels[Channel].Band].DCycle - TxTimeOnAir; + } + else + { + Bands[Channels[Channel].Band].TimeOff = 0; + } + // Update Aggregated Time OFF + AggregatedLastTxDoneTime = curTime; + AggregatedTimeOff = AggregatedTimeOff + ( TxTimeOnAir * AggregatedDCycle - TxTimeOnAir ); + + if( IsRxWindowsEnabled == true ) + { + TimerSetValue( &RxWindowTimer1, RxWindow1Delay ); + TimerStart( &RxWindowTimer1 ); + if( LoRaMacDeviceClass != CLASS_C ) + { + TimerSetValue( &RxWindowTimer2, RxWindow2Delay ); + TimerStart( &RxWindowTimer2 ); + } + if( ( LoRaMacDeviceClass == CLASS_C ) || ( NodeAckRequested == true ) ) + { + TimerSetValue( &AckTimeoutTimer, RxWindow2Delay + ACK_TIMEOUT + + randr( -ACK_TIMEOUT_RND, ACK_TIMEOUT_RND ) ); + TimerStart( &AckTimeoutTimer ); + } + } + else + { + McpsConfirm.Status = LORAMAC_EVENT_INFO_STATUS_OK; + MlmeConfirm.Status = LORAMAC_EVENT_INFO_STATUS_RX2_TIMEOUT; + + if( LoRaMacFlags.Value == 0 ) + { + LoRaMacFlags.Bits.McpsReq = 1; + } + LoRaMacFlags.Bits.MacDone = 1; + } + + if( NodeAckRequested == false ) + { + McpsConfirm.Status = LORAMAC_EVENT_INFO_STATUS_OK; + ChannelsNbRepCounter++; + } +} + +static void OnRadioRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr ) { - uint8_t i = 0; - uint8_t j = 0; - uint8_t k = 0; + LoRaMacHeader_t macHdr; + LoRaMacFrameCtrl_t fCtrl; + + uint8_t pktHeaderLen = 0; + uint32_t address = 0; + uint8_t appPayloadStartIndex = 0; + uint8_t port = 0xFF; + uint8_t frameLen = 0; + uint32_t mic = 0; + uint32_t micRx = 0; + + uint16_t sequenceCounter = 0; + uint16_t sequenceCounterPrev = 0; + uint16_t sequenceCounterDiff = 0; + uint32_t downLinkCounter = 0; + + MulticastParams_t *curMulticastParams = NULL; + uint8_t *nwkSKey = LoRaMacNwkSKey; + uint8_t *appSKey = LoRaMacAppSKey; + + uint8_t multicast = 0; + + bool isMicOk = false; + + McpsConfirm.AckReceived = false; + McpsIndication.Rssi = rssi; + McpsIndication.Snr = snr; + McpsIndication.RxSlot = RxSlot; + McpsIndication.Port = 0; + McpsIndication.Multicast = 0; + McpsIndication.FramePending = 0; + McpsIndication.Buffer = NULL; + McpsIndication.BufferSize = 0; + McpsIndication.RxData = false; + McpsIndication.AckReceived = false; + McpsIndication.DownLinkCounter = 0; + McpsIndication.McpsIndication = MCPS_UNCONFIRMED; + + if( LoRaMacDeviceClass != CLASS_C ) + { + Radio.Sleep( ); + } + TimerStop( &RxWindowTimer2 ); + + macHdr.Value = payload[pktHeaderLen++]; + + switch( macHdr.Bits.MType ) + { + case FRAME_TYPE_JOIN_ACCEPT: + if( IsLoRaMacNetworkJoined == true ) + { + break; + } + LoRaMacJoinDecrypt( payload + 1, size - 1, LoRaMacAppKey, LoRaMacRxPayload + 1 ); + + LoRaMacRxPayload[0] = macHdr.Value; + + LoRaMacJoinComputeMic( LoRaMacRxPayload, size - LORAMAC_MFR_LEN, LoRaMacAppKey, &mic ); + + micRx |= ( uint32_t )LoRaMacRxPayload[size - LORAMAC_MFR_LEN]; + micRx |= ( ( uint32_t )LoRaMacRxPayload[size - LORAMAC_MFR_LEN + 1] << 8 ); + micRx |= ( ( uint32_t )LoRaMacRxPayload[size - LORAMAC_MFR_LEN + 2] << 16 ); + micRx |= ( ( uint32_t )LoRaMacRxPayload[size - LORAMAC_MFR_LEN + 3] << 24 ); + + if( micRx == mic ) + { + LoRaMacJoinComputeSKeys( LoRaMacAppKey, LoRaMacRxPayload + 1, LoRaMacDevNonce, LoRaMacNwkSKey, LoRaMacAppSKey ); + + LoRaMacNetID = ( uint32_t )LoRaMacRxPayload[4]; + LoRaMacNetID |= ( ( uint32_t )LoRaMacRxPayload[5] << 8 ); + LoRaMacNetID |= ( ( uint32_t )LoRaMacRxPayload[6] << 16 ); + + LoRaMacDevAddr = ( uint32_t )LoRaMacRxPayload[7]; + LoRaMacDevAddr |= ( ( uint32_t )LoRaMacRxPayload[8] << 8 ); + LoRaMacDevAddr |= ( ( uint32_t )LoRaMacRxPayload[9] << 16 ); + LoRaMacDevAddr |= ( ( uint32_t )LoRaMacRxPayload[10] << 24 ); + + // DLSettings + Rx1DrOffset = ( LoRaMacRxPayload[11] >> 4 ) & 0x07; + Rx2Channel.Datarate = LoRaMacRxPayload[11] & 0x0F; +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + /* + * WARNING: To be removed once Semtech server implementation + * is corrected. + */ + if( Rx2Channel.Datarate == DR_3 ) + { + Rx2Channel.Datarate = DR_8; + } +#endif + // RxDelay + ReceiveDelay1 = ( LoRaMacRxPayload[12] & 0x0F ); + if( ReceiveDelay1 == 0 ) + { + ReceiveDelay1 = 1; + } + ReceiveDelay1 *= 1e6; + ReceiveDelay2 = ReceiveDelay1 + 1e6; + +#if !( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) + //CFList + if( ( size - 1 ) > 16 ) + { + ChannelParams_t param; + param.DrRange.Value = ( DR_5 << 4 ) | DR_0; + + for( uint8_t i = 3, j = 0; i < ( 5 + 3 ); i++, j += 3 ) + { + param.Frequency = ( ( uint32_t )LoRaMacRxPayload[13 + j] | ( ( uint32_t )LoRaMacRxPayload[14 + j] << 8 ) | ( ( uint32_t )LoRaMacRxPayload[15 + j] << 16 ) ) * 100; + LoRaMacChannelAdd( i, param ); + } + } +#endif + MlmeConfirm.Status = LORAMAC_EVENT_INFO_STATUS_OK; + IsLoRaMacNetworkJoined = true; + ChannelsDatarate = ChannelsDefaultDatarate; + } + else + { + MlmeConfirm.Status = LORAMAC_EVENT_INFO_STATUS_JOIN_FAIL; + } + break; + case FRAME_TYPE_DATA_CONFIRMED_DOWN: + case FRAME_TYPE_DATA_UNCONFIRMED_DOWN: + { + LoRaMacFlags.Bits.McpsInd = 1; + + address = payload[pktHeaderLen++]; + address |= ( (uint32_t)payload[pktHeaderLen++] << 8 ); + address |= ( (uint32_t)payload[pktHeaderLen++] << 16 ); + address |= ( (uint32_t)payload[pktHeaderLen++] << 24 ); + + if( address != LoRaMacDevAddr ) + { + curMulticastParams = MulticastChannels; + while( curMulticastParams != NULL ) + { + if( address == curMulticastParams->Address ) + { + multicast = 1; + nwkSKey = curMulticastParams->NwkSKey; + appSKey = curMulticastParams->AppSKey; + downLinkCounter = curMulticastParams->DownLinkCounter; + break; + } + curMulticastParams = curMulticastParams->Next; + } + if( multicast == 0 ) + { + // We are not the destination of this frame. + LoRaMacFlags.Bits.MacDone = 1; + McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_ADDRESS_FAIL; + LoRaMacState &= ~MAC_TX_RUNNING; + if( NodeAckRequested ) + { + OnAckTimeoutTimerEvent( ); + } + return; + } + } + else + { + multicast = 0; + nwkSKey = LoRaMacNwkSKey; + appSKey = LoRaMacAppSKey; + downLinkCounter = DownLinkCounter; + } + + if( LoRaMacDeviceClass != CLASS_A ) + { + LoRaMacState |= MAC_RX; + // Starts the MAC layer status check timer + TimerStart( &MacStateCheckTimer ); + } + fCtrl.Value = payload[pktHeaderLen++]; + + sequenceCounter = ( uint16_t )payload[pktHeaderLen++]; + sequenceCounter |= ( uint16_t )payload[pktHeaderLen++] << 8; + + appPayloadStartIndex = 8 + fCtrl.Bits.FOptsLen; + + micRx |= ( uint32_t )payload[size - LORAMAC_MFR_LEN]; + micRx |= ( ( uint32_t )payload[size - LORAMAC_MFR_LEN + 1] << 8 ); + micRx |= ( ( uint32_t )payload[size - LORAMAC_MFR_LEN + 2] << 16 ); + micRx |= ( ( uint32_t )payload[size - LORAMAC_MFR_LEN + 3] << 24 ); + + sequenceCounterPrev = ( uint16_t )downLinkCounter; + sequenceCounterDiff = ( sequenceCounter - sequenceCounterPrev ); + + if( sequenceCounterDiff < ( 1 << 15 ) ) + { + downLinkCounter += sequenceCounterDiff; + LoRaMacComputeMic( payload, size - LORAMAC_MFR_LEN, nwkSKey, address, DOWN_LINK, downLinkCounter, &mic ); + if( micRx == mic ) + { + isMicOk = true; + } + } + else + { + // check for sequence roll-over + uint32_t downLinkCounterTmp = downLinkCounter + 0x10000 + ( int16_t )sequenceCounterDiff; + LoRaMacComputeMic( payload, size - LORAMAC_MFR_LEN, nwkSKey, address, DOWN_LINK, downLinkCounterTmp, &mic ); + if( micRx == mic ) + { + isMicOk = true; + downLinkCounter = downLinkCounterTmp; + } + } + + if( isMicOk == true ) + { + McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_OK; + McpsIndication.Multicast = multicast; + McpsIndication.FramePending = fCtrl.Bits.FPending; + McpsIndication.Buffer = NULL; + McpsIndication.BufferSize = 0; + McpsIndication.DownLinkCounter = downLinkCounter; + + McpsConfirm.Status = LORAMAC_EVENT_INFO_STATUS_OK; + + AdrAckCounter = 0; + + // Update 32 bits downlink counter + if( multicast == 1 ) + { + McpsIndication.McpsIndication = MCPS_MULTICAST; + + if( ( curMulticastParams->DownLinkCounter == downLinkCounter ) && + ( curMulticastParams->DownLinkCounter != 0 ) ) + { + LoRaMacFlags.Bits.MacDone = 1; + McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_DOWNLINK_REPEATED; + McpsIndication.DownLinkCounter = downLinkCounter; + LoRaMacState &= ~MAC_TX_RUNNING; + if( NodeAckRequested == true ) + { + OnAckTimeoutTimerEvent( ); + } + return; + } + curMulticastParams->DownLinkCounter = downLinkCounter; + } + else + { + if( macHdr.Bits.MType == FRAME_TYPE_DATA_CONFIRMED_DOWN ) + { + McpsIndication.McpsIndication = MCPS_CONFIRMED; + } + else + { + McpsIndication.McpsIndication = MCPS_UNCONFIRMED; + } + if( ( DownLinkCounter == downLinkCounter ) && + ( DownLinkCounter != 0 ) ) + { + LoRaMacFlags.Bits.MacDone = 1; + McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_DOWNLINK_REPEATED; + McpsIndication.DownLinkCounter = downLinkCounter; + LoRaMacState &= ~MAC_TX_RUNNING; + if( NodeAckRequested == true ) + { + OnAckTimeoutTimerEvent( ); + } + return; + } + DownLinkCounter = downLinkCounter; + } + + if( macHdr.Bits.MType == FRAME_TYPE_DATA_CONFIRMED_DOWN ) + { + SrvAckRequested = true; + } + else + { + SrvAckRequested = false; + } + // Check if the frame is an acknowledgement + if( fCtrl.Bits.Ack == 1 ) + { + McpsConfirm.AckReceived = true; + McpsIndication.AckReceived = true; + + // Stop the AckTimeout timer as no more retransmissions + // are needed. + TimerStop( &AckTimeoutTimer ); + } + else + { + McpsConfirm.AckReceived = false; + + if( AckTimeoutRetriesCounter > AckTimeoutRetries ) + { + // Stop the AckTimeout timer as no more retransmissions + // are needed. + TimerStop( &AckTimeoutTimer ); + } + } + + if( fCtrl.Bits.FOptsLen > 0 ) + { + // Decode Options field MAC commands + ProcessMacCommands( payload, 8, appPayloadStartIndex, snr ); + } + if( ( ( size - 4 ) - appPayloadStartIndex ) > 0 ) + { + port = payload[appPayloadStartIndex++]; + frameLen = ( size - 4 ) - appPayloadStartIndex; + + McpsIndication.Port = port; + + if( port == 0 ) + { + LoRaMacPayloadDecrypt( payload + appPayloadStartIndex, + frameLen, + nwkSKey, + address, + DOWN_LINK, + downLinkCounter, + LoRaMacRxPayload ); + + // Decode frame payload MAC commands + ProcessMacCommands( LoRaMacRxPayload, 0, frameLen, snr ); + } + else + { + LoRaMacPayloadDecrypt( payload + appPayloadStartIndex, + frameLen, + appSKey, + address, + DOWN_LINK, + downLinkCounter, + LoRaMacRxPayload ); + + McpsIndication.Buffer = LoRaMacRxPayload; + McpsIndication.BufferSize = frameLen; + McpsIndication.RxData = true; + } + } + } + else + { + McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_MIC_FAIL; + LoRaMacState &= ~MAC_TX_RUNNING; + if( NodeAckRequested == true ) + { + OnAckTimeoutTimerEvent( ); + } + } + } + break; + case FRAME_TYPE_PROPRIETARY: + { + LoRaMacFlags.Bits.McpsInd = 1; + + memcpy1( LoRaMacRxPayload, &payload[pktHeaderLen], size ); + + McpsIndication.McpsIndication = MCPS_PROPRIETARY; + McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_OK; + McpsIndication.Buffer = LoRaMacRxPayload; + McpsIndication.BufferSize = size - pktHeaderLen; + break; + } + default: + LoRaMacFlags.Bits.McpsInd = 1; + McpsIndication.Status = LORAMAC_EVENT_INFO_STATUS_ERROR; + LoRaMacState &= ~MAC_TX_RUNNING; + break; + } + + if( ( RxSlot == 0 ) && ( LoRaMacDeviceClass == CLASS_C ) ) + { + OnRxWindow2TimerEvent( ); + } + + LoRaMacFlags.Bits.MacDone = 1; +} + +static void OnRadioTxTimeout( void ) +{ + if( LoRaMacDeviceClass != CLASS_C ) + { + Radio.Sleep( ); + } + else + { + OnRxWindow2TimerEvent( ); + } + + McpsConfirm.Status = LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT; + MlmeConfirm.Status = LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT; + LoRaMacFlags.Bits.MacDone = 1; +} + +static void OnRadioRxError( void ) +{ + if( LoRaMacDeviceClass != CLASS_C ) + { + Radio.Sleep( ); + } + else + { + OnRxWindow2TimerEvent( ); + } + + if( RxSlot == 1 ) + { + if( NodeAckRequested == true ) + { + McpsConfirm.Status = LORAMAC_EVENT_INFO_STATUS_RX2_ERROR; + } + MlmeConfirm.Status = LORAMAC_EVENT_INFO_STATUS_RX2_ERROR; + LoRaMacFlags.Bits.MacDone = 1; + } +} + +static void OnRadioRxTimeout( void ) +{ + if( LoRaMacDeviceClass != CLASS_C ) + { + Radio.Sleep( ); + } + else + { + OnRxWindow2TimerEvent( ); + } + + if( RxSlot == 1 ) + { + if( NodeAckRequested == true ) + { + McpsConfirm.Status = LORAMAC_EVENT_INFO_STATUS_RX2_TIMEOUT; + } + MlmeConfirm.Status = LORAMAC_EVENT_INFO_STATUS_RX2_TIMEOUT; + LoRaMacFlags.Bits.MacDone = 1; + } +} + +static void OnMacStateCheckTimerEvent( void ) +{ + TimerStop( &MacStateCheckTimer ); + bool txTimeout = false; + + if( LoRaMacFlags.Bits.MacDone == 1 ) + { + if( ( LoRaMacFlags.Bits.MlmeReq == 1 ) || ( ( LoRaMacFlags.Bits.McpsReq == 1 ) ) ) + { + if( ( McpsConfirm.Status == LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT ) || + ( MlmeConfirm.Status == LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT ) ) + { + // Stop transmit cycle due to tx timeout. + LoRaMacState &= ~MAC_TX_RUNNING; + McpsConfirm.NbRetries = AckTimeoutRetriesCounter; + McpsConfirm.AckReceived = false; + McpsConfirm.TxTimeOnAir = 0; + txTimeout = true; + } + } + + if( ( NodeAckRequested == false ) && ( txTimeout == false ) ) + { + if( LoRaMacFlags.Bits.MlmeReq == 1 ) + { + if( MlmeConfirm.MlmeRequest == MLME_JOIN ) + { + if( MlmeConfirm.Status == LORAMAC_EVENT_INFO_STATUS_OK ) + { + UpLinkCounter = 0; + } + // Join messages aren't repeated automatically + ChannelsNbRepCounter = ChannelsNbRep; + } + } + if( ( LoRaMacFlags.Bits.MlmeReq == 1 ) || ( ( LoRaMacFlags.Bits.McpsReq == 1 ) ) ) + { + if( ( ChannelsNbRepCounter >= ChannelsNbRep ) || ( LoRaMacFlags.Bits.McpsInd == 1 ) ) + { + ChannelsNbRepCounter = 0; + + AdrAckCounter++; + if( IsUpLinkCounterFixed == false ) + { + UpLinkCounter++; + } + + LoRaMacState &= ~MAC_TX_RUNNING; + } + else + { + LoRaMacFlags.Bits.MacDone = 0; + // Sends the same frame again + ScheduleTx( ); + } + } + } + + if( LoRaMacFlags.Bits.McpsInd == 1 ) + { + if( ( McpsConfirm.AckReceived == true ) || ( AckTimeoutRetriesCounter > AckTimeoutRetries ) ) + { + AckTimeoutRetry = false; + if( IsUpLinkCounterFixed == false ) + { + UpLinkCounter++; + } + McpsConfirm.NbRetries = AckTimeoutRetriesCounter; + + LoRaMacState &= ~MAC_TX_RUNNING; + } + } + + if( ( AckTimeoutRetry == true ) && ( ( LoRaMacState & MAC_TX_DELAYED ) == 0 ) ) + { + AckTimeoutRetry = false; + if( ( AckTimeoutRetriesCounter < AckTimeoutRetries ) && ( AckTimeoutRetriesCounter <= MAX_ACK_RETRIES ) ) + { + AckTimeoutRetriesCounter++; + + if( ( AckTimeoutRetriesCounter % 2 ) == 1 ) + { + ChannelsDatarate = MAX( ChannelsDatarate - 1, LORAMAC_MIN_DATARATE ); + } + LoRaMacFlags.Bits.MacDone = 0; + // Sends the same frame again + ScheduleTx( ); + } + else + { +#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) + // Re-enable default channels LC1, LC2, LC3 + ChannelsMask[0] = ChannelsMask[0] | ( LC( 1 ) + LC( 2 ) + LC( 3 ) ); +#elif defined( USE_BAND_915 ) + // Re-enable default channels + ChannelsMask[0] = 0xFFFF; + ChannelsMask[1] = 0xFFFF; + ChannelsMask[2] = 0xFFFF; + ChannelsMask[3] = 0xFFFF; + ChannelsMask[4] = 0x00FF; + ChannelsMask[5] = 0x0000; +#elif defined( USE_BAND_915_HYBRID ) + // Re-enable default channels + ChannelsMask[0] = 0x00FF; + ChannelsMask[1] = 0x0000; + ChannelsMask[2] = 0x0000; + ChannelsMask[3] = 0x0000; + ChannelsMask[4] = 0x0001; + ChannelsMask[5] = 0x0000; +#else + #error "Please define a frequency band in the compiler options." +#endif + LoRaMacState &= ~MAC_TX_RUNNING; + + McpsConfirm.AckReceived = false; + McpsConfirm.NbRetries = AckTimeoutRetriesCounter; + if( IsUpLinkCounterFixed == false ) + { + UpLinkCounter++; + } + } + } + } + // Handle reception for Class B and Class C + if( ( LoRaMacState & MAC_RX ) == MAC_RX ) + { + LoRaMacState &= ~MAC_RX; + } + if( LoRaMacState == MAC_IDLE ) + { + if( LoRaMacFlags.Bits.McpsReq == 1 ) + { + LoRaMacPrimitives->MacMcpsConfirm( &McpsConfirm ); + LoRaMacFlags.Bits.McpsReq = 0; + } + + if( LoRaMacFlags.Bits.MlmeReq == 1 ) + { + LoRaMacPrimitives->MacMlmeConfirm( &MlmeConfirm ); + LoRaMacFlags.Bits.MlmeReq = 0; + } + + LoRaMacFlags.Bits.MacDone = 0; + } + else + { + // Operation not finished restart timer + TimerStart( &MacStateCheckTimer ); + } + + if( LoRaMacFlags.Bits.McpsInd == 1 ) + { + LoRaMacPrimitives->MacMcpsIndication( &McpsIndication ); + LoRaMacFlags.Bits.McpsInd = 0; + } +} + +static void OnTxDelayedTimerEvent( void ) +{ + TimerStop( &TxDelayedTimer ); + LoRaMacState &= ~MAC_TX_DELAYED; + + ScheduleTx( ); +} + +static void OnRxWindow1TimerEvent( void ) +{ + uint16_t symbTimeout = 5; // DR_2, DR_1, DR_0 + int8_t datarate = 0; + uint32_t bandwidth = 0; // LoRa 125 kHz + + TimerStop( &RxWindowTimer1 ); + RxSlot = 0; + + if( LoRaMacDeviceClass == CLASS_C ) + { + Radio.Standby( ); + } + +#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) + datarate = ChannelsDatarate - Rx1DrOffset; + if( datarate < 0 ) + { + datarate = DR_0; + } + + // For higher datarates, we increase the number of symbols generating a Rx Timeout + if( datarate >= DR_3 ) + { // DR_6, DR_5, DR_4, DR_3 + symbTimeout = 8; + } + if( datarate == DR_6 ) + {// LoRa 250 kHz + bandwidth = 1; + } + RxWindowSetup( Channels[Channel].Frequency, datarate, bandwidth, symbTimeout, false ); +#elif ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) + datarate = datarateOffsets[ChannelsDatarate][Rx1DrOffset]; + if( datarate < 0 ) + { + datarate = DR_0; + } + // For higher datarates, we increase the number of symbols generating a Rx Timeout + if( datarate > DR_0 ) + { // DR_1, DR_2, DR_3, DR_4, DR_8, DR_9, DR_10, DR_11, DR_12, DR_13 + symbTimeout = 8; + } + if( datarate >= DR_4 ) + {// LoRa 500 kHz + bandwidth = 2; + } + RxWindowSetup( 923.3e6 + ( Channel % 8 ) * 600e3, datarate, bandwidth, symbTimeout, false ); +#else + #error "Please define a frequency band in the compiler options." +#endif +} + +static void OnRxWindow2TimerEvent( void ) +{ + uint16_t symbTimeout = 5; // DR_2, DR_1, DR_0 + uint32_t bandwidth = 0; // LoRa 125 kHz + + TimerStop( &RxWindowTimer2 ); + RxSlot = 1; + +#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) + // For higher datarates, we increase the number of symbols generating a Rx Timeout + if( Rx2Channel.Datarate >= DR_3 ) + { // DR_6, DR_5, DR_4, DR_3 + symbTimeout = 8; + } + if( Rx2Channel.Datarate == DR_6 ) + {// LoRa 250 kHz + bandwidth = 1; + } +#elif ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) + // For higher datarates, we increase the number of symbols generating a Rx Timeout + if( Rx2Channel.Datarate > DR_0 ) + { // DR_1, DR_2, DR_3, DR_4, DR_8, DR_9, DR_10, DR_11, DR_12, DR_13 + symbTimeout = 8; + } + if( Rx2Channel.Datarate >= DR_4 ) + {// LoRa 500 kHz + bandwidth = 2; + } +#else + #error "Please define a frequency band in the compiler options." +#endif + if( LoRaMacDeviceClass != CLASS_C ) + { + RxWindowSetup( Rx2Channel.Frequency, Rx2Channel.Datarate, bandwidth, symbTimeout, false ); + } + else + { + RxWindowSetup( Rx2Channel.Frequency, Rx2Channel.Datarate, bandwidth, symbTimeout, true ); + } +} + +static void OnAckTimeoutTimerEvent( void ) +{ + TimerStop( &AckTimeoutTimer ); + + if( NodeAckRequested == true ) + { + AckTimeoutRetry = true; + LoRaMacState &= ~MAC_ACK_REQ; + } + if( LoRaMacDeviceClass == CLASS_C ) + { + LoRaMacFlags.Bits.MacDone = 1; + } +} + +static TimerTime_t SetNextChannel( void ) +{ uint8_t nbEnabledChannels = 0; uint8_t enabledChannels[LORA_MAX_NB_CHANNELS]; TimerTime_t curTime = TimerGetCurrentTime( ); + TimerTime_t nextTxDelay = ( TimerTime_t )( -1 ); memset1( enabledChannels, 0, LORA_MAX_NB_CHANNELS ); +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + if( ( CountNbEnabled125kHzChannels( ChannelsMaskRemaining ) + + ( ChannelsMaskRemaining[4] & 0x00FF ) ) == 0 ) + { + memcpy1( ( uint8_t* ) ChannelsMaskRemaining, ( uint8_t* ) ChannelsMask, + sizeof( ChannelsMask ) ); + } +#endif + // Update Aggregated duty cycle if( AggregatedTimeOff < ( curTime - AggregatedLastTxDoneTime ) ) { AggregatedTimeOff = 0; - } - - // Update bands Time OFF - TimerTime_t minTime = ( TimerTime_t )( -1 ); - for( i = 0; i < LORA_MAX_NB_BANDS; i++ ) - { - if( DutyCycleOn == true ) + + // Update bands Time OFF + for( uint8_t i = 0; i < LORA_MAX_NB_BANDS; i++ ) { - if( Bands[i].TimeOff < ( curTime - Bands[i].LastTxDoneTime ) ) + if( DutyCycleOn == true ) { + if( Bands[i].TimeOff < ( curTime - Bands[i].LastTxDoneTime ) ) + { + Bands[i].TimeOff = 0; + } + if( Bands[i].TimeOff != 0 ) + { + nextTxDelay = MIN( Bands[i].TimeOff - + ( curTime - Bands[i].LastTxDoneTime ), + nextTxDelay ); + } + } + else + { + nextTxDelay = 0; Bands[i].TimeOff = 0; } - if( Bands[i].TimeOff != 0 ) + } + + // Search how many channels are enabled + for( uint8_t i = 0, k = 0; i < LORA_MAX_NB_CHANNELS; i += 16, k++ ) + { + for( uint8_t j = 0; j < 16; j++ ) { - minTime = MIN( Bands[i].TimeOff, minTime ); +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + if( ( ChannelsMaskRemaining[k] & ( 1 << j ) ) != 0 ) +#else + if( ( ChannelsMask[k] & ( 1 << j ) ) != 0 ) +#endif + { + if( Channels[i + j].Frequency == 0 ) + { // Check if the channel is enabled +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + DisableChannelInMask( i + j, ChannelsMaskRemaining ); +#endif + continue; + } + if( ( ( Channels[i + j].DrRange.Fields.Min <= ChannelsDatarate ) && + ( ChannelsDatarate <= Channels[i + j].DrRange.Fields.Max ) ) == false ) + { // Check if the current channel selection supports the given datarate +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + DisableChannelInMask( i + j, ChannelsMaskRemaining ); +#endif + continue; + } + if( Bands[Channels[i + j].Band].TimeOff > 0 ) + { // Check if the band is available for transmission + continue; + } + enabledChannels[nbEnabledChannels++] = i + j; + } + } + } + } + else + { + nextTxDelay = AggregatedTimeOff - ( curTime - AggregatedLastTxDoneTime ); + } + + if( nbEnabledChannels > 0 ) + { + Channel = enabledChannels[randr( 0, nbEnabledChannels - 1 )]; +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + DisableChannelInMask( Channel, ChannelsMaskRemaining ); +#endif + return 0; + } + else + { + // Protect the function of returning the initialization value of nextTxDelay + return ( nextTxDelay == ( TimerTime_t )( -1 ) ) ? 0 : nextTxDelay; + } +} + +static void SetPublicNetwork( bool enable ) +{ + PublicNetwork = enable; + Radio.SetModem( MODEM_LORA ); + if( PublicNetwork == true ) + { + // Change LoRa modem SyncWord + Radio.Write( REG_LR_SYNCWORD, LORA_MAC_PUBLIC_SYNCWORD ); + } + else + { + // Change LoRa modem SyncWord + Radio.Write( REG_LR_SYNCWORD, LORA_MAC_PRIVATE_SYNCWORD ); + } +} + +static void RxWindowSetup( uint32_t freq, int8_t datarate, uint32_t bandwidth, uint16_t timeout, bool rxContinuous ) +{ + uint8_t downlinkDatarate = Datarates[datarate]; + RadioModems_t modem; + + if( Radio.GetStatus( ) == RF_IDLE ) + { + Radio.SetChannel( freq ); + + // Store downlink datarate + McpsIndication.RxDatarate = ( uint8_t ) datarate; + +#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) + if( datarate == DR_7 ) + { + modem = MODEM_FSK; + Radio.SetRxConfig( modem, 50e3, downlinkDatarate * 1e3, 0, 83.333e3, 5, 0, false, 0, true, 0, 0, false, rxContinuous ); + } + else + { + modem = MODEM_LORA; + Radio.SetRxConfig( modem, bandwidth, downlinkDatarate, 1, 0, 8, timeout, false, 0, false, 0, 0, true, rxContinuous ); + } +#elif defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + modem = MODEM_LORA; + Radio.SetRxConfig( modem, bandwidth, downlinkDatarate, 1, 0, 8, timeout, false, 0, false, 0, 0, true, rxContinuous ); +#endif + + if( RepeaterSupport == true ) + { + Radio.SetMaxPayloadLength( modem, MaxPayloadOfDatarateRepeater[datarate] ); + } + else + { + Radio.SetMaxPayloadLength( modem, MaxPayloadOfDatarate[datarate] ); + } + + if( rxContinuous == false ) + { + Radio.Rx( MaxRxWindow ); + } + else + { + Radio.Rx( 0 ); // Continuous mode + } + } +} + +static bool ValidatePayloadLength( uint8_t lenN, int8_t datarate, uint8_t fOptsLen ) +{ + uint16_t maxN = 0; + uint16_t payloadSize = 0; + + // Get the maximum payload length + if( RepeaterSupport == true ) + { + maxN = MaxPayloadOfDatarateRepeater[datarate]; + } + else + { + maxN = MaxPayloadOfDatarate[datarate]; + } + + // Calculate the resulting payload size + payloadSize = ( lenN + fOptsLen ); + + // Validation of the application payload size + if( ( payloadSize <= maxN ) && ( payloadSize <= LORAMAC_PHY_MAXPAYLOAD ) ) + { + return true; + } + return false; +} + +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) +static uint8_t CountNbEnabled125kHzChannels( uint16_t *channelsMask ) +{ + uint8_t nb125kHzChannels = 0; + + for( uint8_t i = 0, k = 0; i < LORA_MAX_NB_CHANNELS - 8; i += 16, k++ ) + { + for( uint8_t j = 0; j < 16; j++ ) + {// Verify if the channel is active + if( ( channelsMask[k] & ( 1 << j ) ) == ( 1 << j ) ) + { + nb125kHzChannels++; + } + } + } + + return nb125kHzChannels; +} +#endif + +static int8_t LimitTxPower( int8_t txPower ) +{ + int8_t resultTxPower = txPower; +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + if( ( ChannelsDatarate == DR_4 ) || + ( ( ChannelsDatarate >= DR_8 ) && ( ChannelsDatarate <= DR_13 ) ) ) + {// Limit tx power to max 26dBm + resultTxPower = MAX( txPower, TX_POWER_26_DBM ); + } + else + { + if( CountNbEnabled125kHzChannels( ChannelsMask ) < 50 ) + {// Limit tx power to max 21dBm + resultTxPower = MAX( txPower, TX_POWER_20_DBM ); + } + } +#endif + return resultTxPower; +} + +static bool ValueInRange( int8_t value, int8_t min, int8_t max ) +{ + if( ( value >= min ) && ( value <= max ) ) + { + return true; + } + return false; +} + +static bool DisableChannelInMask( uint8_t id, uint16_t* mask ) +{ + uint8_t index = 0; + index = id / 16; + + if( ( index > 4 ) || ( id >= LORA_MAX_NB_CHANNELS ) ) + { + return false; + } + + // Deactivate channel + mask[index] &= ~( 1 << ( id % 16 ) ); + + return true; +} + +static bool AdrNextDr( bool adrEnabled, bool updateChannelMask, int8_t* datarateOut ) +{ + bool adrAckReq = false; + int8_t datarate = ChannelsDatarate; + + if( adrEnabled == true ) + { + if( datarate == LORAMAC_MIN_DATARATE ) + { + AdrAckCounter = 0; + adrAckReq = false; + + if( updateChannelMask == true ) + { +#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) + // Re-enable default channels LC1, LC2, LC3 + ChannelsMask[0] = ChannelsMask[0] | ( LC( 1 ) + LC( 2 ) + LC( 3 ) ); +#elif defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) +#if defined( USE_BAND_915 ) + // Re-enable default channels + ChannelsMask[0] = 0xFFFF; + ChannelsMask[1] = 0xFFFF; + ChannelsMask[2] = 0xFFFF; + ChannelsMask[3] = 0xFFFF; + ChannelsMask[4] = 0x00FF; + ChannelsMask[5] = 0x0000; +#else // defined( USE_BAND_915_HYBRID ) + // Re-enable default channels + ChannelsMask[0] = 0x00FF; + ChannelsMask[1] = 0x0000; + ChannelsMask[2] = 0x0000; + ChannelsMask[3] = 0x0000; + ChannelsMask[4] = 0x0001; + ChannelsMask[5] = 0x0000; +#endif +#else +#error "Please define a frequency band in the compiler options." +#endif } } else { - minTime = 0; - Bands[i].TimeOff = 0; - } - } - - // Search how many channels are enabled - for( i = 0, k = 0; i < LORA_MAX_NB_CHANNELS; i += 16, k++ ) - { - for( j = 0; j < 16; j++ ) - { - if( ( ChannelsMask[k] & ( 1 << j ) ) != 0 ) + if( AdrAckCounter > ADR_ACK_LIMIT ) + { + adrAckReq = true; + } + else + { + adrAckReq = false; + } + if( AdrAckCounter > ( ADR_ACK_LIMIT + ADR_ACK_DELAY ) ) { - if( Channels[i + j].Frequency == 0 ) - { // Check if the channel is enabled - continue; - } - if( ( ( Channels[i + j].DrRange.Fields.Min <= ChannelsDatarate ) && - ( ChannelsDatarate <= Channels[i + j].DrRange.Fields.Max ) ) == false ) - { // Check if the current channel selection supports the given datarate - continue; + AdrAckCounter = 0; +#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) + if( datarate > LORAMAC_MIN_DATARATE ) + { + datarate--; } - if( Bands[Channels[i + j].Band].TimeOff > 0 ) - { // Check if the band is available for transmission - continue; +#elif defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + if( ( datarate > LORAMAC_MIN_DATARATE ) && ( datarate == DR_8 ) ) + { + datarate = DR_4; } - if( AggregatedTimeOff > 0 ) - { // Check if there is time available for transmission - continue; + else if( datarate > LORAMAC_MIN_DATARATE ) + { + datarate--; } - enabledChannels[nbEnabledChannels++] = i + j; +#else +#error "Please define a frequency band in the compiler options." +#endif } } } - if( nbEnabledChannels > 0 ) - { - Channel = enabledChannels[randr( 0, nbEnabledChannels - 1 )]; - LoRaMacState &= ~MAC_CHANNEL_CHECK; - TimerStop( &ChannelCheckTimer ); - return 0; - } - // No free channel found. - // Check again - if( ( LoRaMacState & MAC_CHANNEL_CHECK ) == 0 ) - { - TimerSetValue( &ChannelCheckTimer, minTime ); - TimerStart( &ChannelCheckTimer ); - LoRaMacState |= MAC_CHANNEL_CHECK; - } - return 1; + + *datarateOut = datarate; + + return adrAckReq; } -/* - * TODO: Add documentation - */ -void OnChannelCheckTimerEvent( void ) +static LoRaMacStatus_t AddMacCommand( uint8_t cmd, uint8_t p1, uint8_t p2 ) { - TimerStop( &ChannelCheckTimer ); - - LoRaMacState &= ~MAC_CHANNEL_CHECK; - if( LoRaMacSetNextChannel( ) == 0 ) - { - if( ( LoRaMacState & MAC_TX_RUNNING ) == MAC_TX_RUNNING ) - { - LoRaMacSendFrameOnChannel( Channels[Channel] ); - } - } -} - -/*! - * Adds a new MAC command to be sent. - * - * \Remark MAC layer internal function - * - * \param [in] cmd MAC command to be added - * [MOTE_MAC_LINK_CHECK_REQ, - * MOTE_MAC_LINK_ADR_ANS, - * MOTE_MAC_DUTY_CYCLE_ANS, - * MOTE_MAC_RX2_PARAM_SET_ANS, - * MOTE_MAC_DEV_STATUS_ANS - * MOTE_MAC_NEW_CHANNEL_ANS] - * \param [in] p1 1st parameter ( optional depends on the command ) - * \param [in] p2 2nd parameter ( optional depends on the command ) - * - * \retval status Function status [0: OK, 1: Unknown command, 2: Busy] - */ -static uint8_t AddMacCommand( uint8_t cmd, uint8_t p1, uint8_t p2 ) -{ - uint8_t status = 2; // Busy + LoRaMacStatus_t status = LORAMAC_STATUS_BUSY; switch( cmd ) { @@ -755,7 +1892,7 @@ { MacCommandsBuffer[MacCommandsBufferIndex++] = cmd; // No payload for this command - status = 0; // OK + status = LORAMAC_STATUS_OK; } break; case MOTE_MAC_LINK_ADR_ANS: @@ -764,7 +1901,7 @@ MacCommandsBuffer[MacCommandsBufferIndex++] = cmd; // Margin MacCommandsBuffer[MacCommandsBufferIndex++] = p1; - status = 0; // OK + status = LORAMAC_STATUS_OK; } break; case MOTE_MAC_DUTY_CYCLE_ANS: @@ -772,7 +1909,7 @@ { MacCommandsBuffer[MacCommandsBufferIndex++] = cmd; // No payload for this answer - status = 0; // OK + status = LORAMAC_STATUS_OK; } break; case MOTE_MAC_RX_PARAM_SETUP_ANS: @@ -781,7 +1918,7 @@ MacCommandsBuffer[MacCommandsBufferIndex++] = cmd; // Status: Datarate ACK, Channel ACK MacCommandsBuffer[MacCommandsBufferIndex++] = p1; - status = 0; // OK + status = LORAMAC_STATUS_OK; } break; case MOTE_MAC_DEV_STATUS_ANS: @@ -792,7 +1929,7 @@ // 2nd byte Margin MacCommandsBuffer[MacCommandsBufferIndex++] = p1; MacCommandsBuffer[MacCommandsBufferIndex++] = p2; - status = 0; // OK + status = LORAMAC_STATUS_OK; } break; case MOTE_MAC_NEW_CHANNEL_ANS: @@ -801,7 +1938,7 @@ MacCommandsBuffer[MacCommandsBufferIndex++] = cmd; // Status: Datarate range OK, Channel frequency OK MacCommandsBuffer[MacCommandsBufferIndex++] = p1; - status = 0; // OK + status = LORAMAC_STATUS_OK; } break; case MOTE_MAC_RX_TIMING_SETUP_ANS: @@ -809,642 +1946,20 @@ { MacCommandsBuffer[MacCommandsBufferIndex++] = cmd; // No payload for this answer - status = 0; // OK + status = LORAMAC_STATUS_OK; } break; default: - return 1; // Unknown command + return LORAMAC_STATUS_SERVICE_UNKNOWN; } - if( status == 0 ) + if( status == LORAMAC_STATUS_OK ) { MacCommandsInNextTx = true; } return status; } -// TODO: Add Documentation -static void LoRaMacNotify( LoRaMacEventFlags_t *flags, LoRaMacEventInfo_t *info ) -{ - if( ( LoRaMacCallbacks != NULL ) && ( LoRaMacCallbacks->MacEvent != NULL ) ) - { - LoRaMacCallbacks->MacEvent( flags, info ); - } - flags->Value = 0; -} - -void LoRaMacInit( LoRaMacCallbacks_t *callbacks ) -{ - LoRaMacCallbacks = callbacks; - - LoRaMacEventFlags.Value = 0; - - LoRaMacEventInfo.TxAckReceived = false; - LoRaMacEventInfo.TxNbRetries = 0; - LoRaMacEventInfo.TxDatarate = 7; - LoRaMacEventInfo.RxPort = 1; - LoRaMacEventInfo.RxBuffer = NULL; - LoRaMacEventInfo.RxBufferSize = 0; - LoRaMacEventInfo.RxRssi = 0; - LoRaMacEventInfo.RxSnr = 0; - LoRaMacEventInfo.Energy = 0; - LoRaMacEventInfo.DemodMargin = 0; - LoRaMacEventInfo.NbGateways = 0; - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_OK; - - LoRaMacDeviceClass = CLASS_A; - - UpLinkCounter = 1; - DownLinkCounter = 0; - - IsLoRaMacNetworkJoined = false; - LoRaMacState = MAC_IDLE; - -#if defined( USE_BAND_433 ) - ChannelsMask[0] = LC( 1 ) + LC( 2 ) + LC( 3 ); -#elif defined( USE_BAND_780 ) - ChannelsMask[0] = LC( 1 ) + LC( 2 ) + LC( 3 ); -#elif defined( USE_BAND_868 ) - ChannelsMask[0] = LC( 1 ) + LC( 2 ) + LC( 3 ); -#elif defined( USE_BAND_915 ) - ChannelsMask[0] = 0xFFFF; - ChannelsMask[1] = 0xFFFF; - ChannelsMask[2] = 0xFFFF; - ChannelsMask[3] = 0xFFFF; - ChannelsMask[4] = 0x00FF; - ChannelsMask[5] = 0x0000; -#elif defined( USE_BAND_915_HYBRID ) - ChannelsMask[0] = 0x00FF; - ChannelsMask[1] = 0x0000; - ChannelsMask[2] = 0x0000; - ChannelsMask[3] = 0x0000; - ChannelsMask[4] = 0x0001; - ChannelsMask[5] = 0x0000; -#else - #error "Please define a frequency band in the compiler options." -#endif - -#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - // 125 kHz channels - for( uint8_t i = 0; i < LORA_MAX_NB_CHANNELS - 8; i++ ) - { - Channels[i].Frequency = 902.3e6 + i * 200e3; - Channels[i].DrRange.Value = ( DR_3 << 4 ) | DR_0; - Channels[i].Band = 0; - } - // 500 kHz channels - for( uint8_t i = LORA_MAX_NB_CHANNELS - 8; i < LORA_MAX_NB_CHANNELS; i++ ) - { - Channels[i].Frequency = 903.0e6 + ( i - ( LORA_MAX_NB_CHANNELS - 8 ) ) * 1.6e6; - Channels[i].DrRange.Value = ( DR_4 << 4 ) | DR_4; - Channels[i].Band = 0; - } -#endif - - ChannelsTxPower = LORAMAC_DEFAULT_TX_POWER; - ChannelsDefaultDatarate = ChannelsDatarate = LORAMAC_DEFAULT_DATARATE; - ChannelsNbRep = 1; - ChannelsNbRepCounter = 0; - - MaxDCycle = 0; - AggregatedDCycle = 1; - AggregatedLastTxDoneTime = 0; - AggregatedTimeOff = 0; - -#if defined( USE_BAND_433 ) - DutyCycleOn = false; -#elif defined( USE_BAND_780 ) - DutyCycleOn = false; -#elif defined( USE_BAND_868 ) - DutyCycleOn = true; -#elif defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - DutyCycleOn = false; -#else - #error "Please define a frequency band in the compiler options." -#endif - - MaxRxWindow = MAX_RX_WINDOW; - ReceiveDelay1 = RECEIVE_DELAY1; - ReceiveDelay2 = RECEIVE_DELAY2; - JoinAcceptDelay1 = JOIN_ACCEPT_DELAY1; - JoinAcceptDelay2 = JOIN_ACCEPT_DELAY2; - - TimerInit( &MacStateCheckTimer, OnMacStateCheckTimerEvent ); - TimerSetValue( &MacStateCheckTimer, MAC_STATE_CHECK_TIMEOUT ); - - TimerInit( &ChannelCheckTimer, OnChannelCheckTimerEvent ); - TimerInit( &TxDelayedTimer, OnTxDelayedTimerEvent ); - TimerInit( &RxWindowTimer1, OnRxWindow1TimerEvent ); - TimerInit( &RxWindowTimer2, OnRxWindow2TimerEvent ); - TimerInit( &AckTimeoutTimer, OnAckTimeoutTimerEvent ); - - // Initialize Radio driver - RadioEvents.TxDone = OnRadioTxDone; - RadioEvents.RxDone = OnRadioRxDone; - RadioEvents.RxError = OnRadioRxError; - RadioEvents.TxTimeout = OnRadioTxTimeout; - RadioEvents.RxTimeout = OnRadioRxTimeout; - Radio.Init( &RadioEvents ); - - // Random seed initialization - srand1( Radio.Random( ) ); - - // Initialize channel index. - Channel = LORA_MAX_NB_CHANNELS; - - PublicNetwork = true; - LoRaMacSetPublicNetwork( PublicNetwork ); - Radio.Sleep( ); -} - -void LoRaMacSetAdrOn( bool enable ) -{ - AdrCtrlOn = enable; -} - -void LoRaMacInitNwkIds( uint32_t netID, uint32_t devAddr, uint8_t *nwkSKey, uint8_t *appSKey ) -{ - LoRaMacNetID = netID; - LoRaMacDevAddr = devAddr; - LoRaMacMemCpy( nwkSKey, LoRaMacNwkSKey, 16 ); - LoRaMacMemCpy( appSKey, LoRaMacAppSKey, 16 ); - - IsLoRaMacNetworkJoined = true; -} - -void LoRaMacMulticastChannelAdd( MulticastParams_t *channelParam ) -{ - // Reset downlink counter - channelParam->DownLinkCounter = 0; - - if( MulticastChannels == NULL ) - { - MulticastChannels = channelParam; - } - else - { - MulticastParams_t *cur = MulticastChannels; - while( cur->Next != NULL ) - { - cur = cur->Next; - } - cur->Next = channelParam; - } -} - -void LoRaMacMulticastChannelRemove( MulticastParams_t *channelParam ) -{ - MulticastParams_t *cur = NULL; - - // Remove the front element - if( MulticastChannels == channelParam ) - { - if( MulticastChannels != NULL ) - { - cur = MulticastChannels; - MulticastChannels = MulticastChannels->Next; - cur->Next = NULL; - // Last node in the list - if( cur == MulticastChannels ) - { - MulticastChannels = NULL; - } - } - return; - } - - // Remove last element - if( channelParam->Next == NULL ) - { - if( MulticastChannels != NULL ) - { - cur = MulticastChannels; - MulticastParams_t *last = NULL; - while( cur->Next != NULL ) - { - last = cur; - cur = cur->Next; - } - if( last != NULL ) - { - last->Next = NULL; - } - // Last node in the list - if( cur == last ) - { - MulticastChannels = NULL; - } - } - return; - } - - // Remove a middle element - cur = MulticastChannels; - while( cur != NULL ) - { - if( cur->Next == channelParam ) - { - break; - } - cur = cur->Next; - } - if( cur != NULL ) - { - MulticastParams_t *tmp = cur ->Next; - cur->Next = tmp->Next; - tmp->Next = NULL; - } -} - -uint8_t LoRaMacJoinReq( uint8_t *devEui, uint8_t *appEui, uint8_t *appKey ) -{ - LoRaMacHeader_t macHdr; - - LoRaMacDevEui = devEui; - LoRaMacAppEui = appEui; - LoRaMacAppKey = appKey; - - macHdr.Value = 0; - macHdr.Bits.MType = FRAME_TYPE_JOIN_REQ; - - IsLoRaMacNetworkJoined = false; - -#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - static uint8_t drSwitch = 0; - - if( ( ++drSwitch & 0x01 ) == 0x01 ) - { - ChannelsDatarate = DR_0; - } - else - { - ChannelsDatarate = DR_4; - } -#endif - return LoRaMacSend( &macHdr, NULL, 0, NULL, 0 ); -} - -uint8_t LoRaMacLinkCheckReq( void ) -{ - return AddMacCommand( MOTE_MAC_LINK_CHECK_REQ, 0, 0 ); -} - -uint8_t LoRaMacSendFrame( uint8_t fPort, void *fBuffer, uint16_t fBufferSize ) -{ - LoRaMacHeader_t macHdr; - - macHdr.Value = 0; - - macHdr.Bits.MType = FRAME_TYPE_DATA_UNCONFIRMED_UP; - return LoRaMacSend( &macHdr, NULL, fPort, fBuffer, fBufferSize ); -} - -uint8_t LoRaMacSendConfirmedFrame( uint8_t fPort, void *fBuffer, uint16_t fBufferSize, uint8_t retries ) -{ - LoRaMacHeader_t macHdr; - - if( AdrCtrlOn == false ) - { - ChannelsDatarate = ChannelsDefaultDatarate; - } - AckTimeoutRetries = retries; - AckTimeoutRetriesCounter = 1; - - macHdr.Value = 0; - - macHdr.Bits.MType = FRAME_TYPE_DATA_CONFIRMED_UP; - return LoRaMacSend( &macHdr, NULL, fPort, fBuffer, fBufferSize ); -} - -uint8_t LoRaMacSend( LoRaMacHeader_t *macHdr, uint8_t *fOpts, uint8_t fPort, void *fBuffer, uint16_t fBufferSize ) -{ - LoRaMacFrameCtrl_t fCtrl; - - fCtrl.Value = 0; - - fCtrl.Bits.FOptsLen = 0; - fCtrl.Bits.FPending = 0; - fCtrl.Bits.Ack = false; - fCtrl.Bits.AdrAckReq = false; - fCtrl.Bits.Adr = AdrCtrlOn; - - if( LoRaMacSetNextChannel( ) == 0 ) - { - return LoRaMacSendOnChannel( Channels[Channel], macHdr, &fCtrl, fOpts, fPort, fBuffer, fBufferSize ); - } - return 5; -} - -uint8_t LoRaMacPrepareFrame( ChannelParams_t channel, LoRaMacHeader_t *macHdr, LoRaMacFrameCtrl_t *fCtrl, uint8_t *fOpts, uint8_t fPort, void *fBuffer, uint16_t fBufferSize ) -{ - uint16_t i; - uint8_t pktHeaderLen = 0; - uint32_t mic = 0; - - LoRaMacBufferPktLen = 0; - - NodeAckRequested = false; - - if( fBuffer == NULL ) - { - fBufferSize = 0; - } - else - { - if( ValidatePayloadLength( fBufferSize, ChannelsDatarate ) == false ) - { - return 3; - } - } - - LoRaMacBuffer[pktHeaderLen++] = macHdr->Value; - - switch( macHdr->Bits.MType ) - { - case FRAME_TYPE_JOIN_REQ: - RxWindow1Delay = JoinAcceptDelay1 - RADIO_WAKEUP_TIME; - RxWindow2Delay = JoinAcceptDelay2 - RADIO_WAKEUP_TIME; - - LoRaMacBufferPktLen = pktHeaderLen; - - LoRaMacMemCpy( LoRaMacAppEui, LoRaMacBuffer + LoRaMacBufferPktLen, 8 ); - LoRaMacBufferPktLen += 8; - LoRaMacMemCpy( LoRaMacDevEui, LoRaMacBuffer + LoRaMacBufferPktLen, 8 ); - LoRaMacBufferPktLen += 8; - - LoRaMacDevNonce = Radio.Random( ); - - LoRaMacBuffer[LoRaMacBufferPktLen++] = LoRaMacDevNonce & 0xFF; - LoRaMacBuffer[LoRaMacBufferPktLen++] = ( LoRaMacDevNonce >> 8 ) & 0xFF; - - LoRaMacJoinComputeMic( LoRaMacBuffer, LoRaMacBufferPktLen & 0xFF, LoRaMacAppKey, &mic ); - - LoRaMacBuffer[LoRaMacBufferPktLen++] = mic & 0xFF; - LoRaMacBuffer[LoRaMacBufferPktLen++] = ( mic >> 8 ) & 0xFF; - LoRaMacBuffer[LoRaMacBufferPktLen++] = ( mic >> 16 ) & 0xFF; - LoRaMacBuffer[LoRaMacBufferPktLen++] = ( mic >> 24 ) & 0xFF; - - break; - case FRAME_TYPE_DATA_CONFIRMED_UP: - NodeAckRequested = true; - //Intentional falltrough - case FRAME_TYPE_DATA_UNCONFIRMED_UP: - if( IsLoRaMacNetworkJoined == false ) - { - return 2; // No network has been joined yet - } - - RxWindow1Delay = ReceiveDelay1 - RADIO_WAKEUP_TIME; - RxWindow2Delay = ReceiveDelay2 - RADIO_WAKEUP_TIME; - - if( fOpts == NULL ) - { - fCtrl->Bits.FOptsLen = 0; - } - - if( SrvAckRequested == true ) - { - SrvAckRequested = false; - fCtrl->Bits.Ack = 1; - } - - if( fCtrl->Bits.Adr == true ) - { - if( ChannelsDatarate == LORAMAC_MIN_DATARATE ) - { - AdrAckCounter = 0; - fCtrl->Bits.AdrAckReq = false; - } - else - { - if( AdrAckCounter > ADR_ACK_LIMIT ) - { - fCtrl->Bits.AdrAckReq = true; - } - else - { - fCtrl->Bits.AdrAckReq = false; - } - if( AdrAckCounter > ( ADR_ACK_LIMIT + ADR_ACK_DELAY ) ) - { - AdrAckCounter = 0; -#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) - if( ChannelsDatarate > LORAMAC_MIN_DATARATE ) - { - ChannelsDatarate--; - } - else - { - // Re-enable default channels LC1, LC2, LC3 - ChannelsMask[0] = ChannelsMask[0] | ( LC( 1 ) + LC( 2 ) + LC( 3 ) ); - } -#elif defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - if( ( ChannelsDatarate > LORAMAC_MIN_DATARATE ) && ( ChannelsDatarate == DR_8 ) ) - { - ChannelsDatarate = DR_4; - } - if( ChannelsDatarate > LORAMAC_MIN_DATARATE ) - { - ChannelsDatarate--; - } - else - { -#if defined( USE_BAND_915 ) - // Re-enable default channels - ChannelsMask[0] = 0xFFFF; - ChannelsMask[1] = 0xFFFF; - ChannelsMask[2] = 0xFFFF; - ChannelsMask[3] = 0xFFFF; - ChannelsMask[4] = 0x00FF; - ChannelsMask[5] = 0x0000; -#else // defined( USE_BAND_915_HYBRID ) - // Re-enable default channels - ChannelsMask[0] = 0x00FF; - ChannelsMask[1] = 0x0000; - ChannelsMask[2] = 0x0000; - ChannelsMask[3] = 0x0000; - ChannelsMask[4] = 0x0001; - ChannelsMask[5] = 0x0000; -#endif - } -#else - #error "Please define a frequency band in the compiler options." -#endif - } - } - } - - LoRaMacBuffer[pktHeaderLen++] = ( LoRaMacDevAddr ) & 0xFF; - LoRaMacBuffer[pktHeaderLen++] = ( LoRaMacDevAddr >> 8 ) & 0xFF; - LoRaMacBuffer[pktHeaderLen++] = ( LoRaMacDevAddr >> 16 ) & 0xFF; - LoRaMacBuffer[pktHeaderLen++] = ( LoRaMacDevAddr >> 24 ) & 0xFF; - - LoRaMacBuffer[pktHeaderLen++] = fCtrl->Value; - - LoRaMacBuffer[pktHeaderLen++] = UpLinkCounter & 0xFF; - LoRaMacBuffer[pktHeaderLen++] = ( UpLinkCounter >> 8 ) & 0xFF; - - if( fOpts != NULL ) - { - for( i = 0; i < fCtrl->Bits.FOptsLen; i++ ) - { - LoRaMacBuffer[pktHeaderLen++] = fOpts[i]; - } - } - if( ( MacCommandsBufferIndex + fCtrl->Bits.FOptsLen ) <= 15 ) - { - if( MacCommandsInNextTx == true ) - { - fCtrl->Bits.FOptsLen += MacCommandsBufferIndex; - - // Update FCtrl field with new value of OptionsLength - LoRaMacBuffer[0x05] = fCtrl->Value; - for( i = 0; i < MacCommandsBufferIndex; i++ ) - { - LoRaMacBuffer[pktHeaderLen++] = MacCommandsBuffer[i]; - } - } - } - MacCommandsInNextTx = false; - MacCommandsBufferIndex = 0; - - if( ( pktHeaderLen + fBufferSize ) > LORAMAC_PHY_MAXPAYLOAD ) - { - return 3; - } - - if( fBuffer != NULL ) - { - LoRaMacBuffer[pktHeaderLen++] = fPort; - - if( fPort == 0 ) - { - LoRaMacPayloadEncrypt( ( uint8_t* )fBuffer, fBufferSize, LoRaMacNwkSKey, LoRaMacDevAddr, UP_LINK, UpLinkCounter, LoRaMacPayload ); - } - else - { - LoRaMacPayloadEncrypt( ( uint8_t* )fBuffer, fBufferSize, LoRaMacAppSKey, LoRaMacDevAddr, UP_LINK, UpLinkCounter, LoRaMacPayload ); - } - LoRaMacMemCpy( LoRaMacPayload, LoRaMacBuffer + pktHeaderLen, fBufferSize ); - } - LoRaMacBufferPktLen = pktHeaderLen + fBufferSize; - - LoRaMacComputeMic( LoRaMacBuffer, LoRaMacBufferPktLen, LoRaMacNwkSKey, LoRaMacDevAddr, UP_LINK, UpLinkCounter, &mic ); - - if( ( LoRaMacBufferPktLen + LORAMAC_MFR_LEN ) > LORAMAC_PHY_MAXPAYLOAD ) - { - return 3; - } - LoRaMacBuffer[LoRaMacBufferPktLen + 0] = mic & 0xFF; - LoRaMacBuffer[LoRaMacBufferPktLen + 1] = ( mic >> 8 ) & 0xFF; - LoRaMacBuffer[LoRaMacBufferPktLen + 2] = ( mic >> 16 ) & 0xFF; - LoRaMacBuffer[LoRaMacBufferPktLen + 3] = ( mic >> 24 ) & 0xFF; - - LoRaMacBufferPktLen += LORAMAC_MFR_LEN; - break; - default: - return 4; - } - - return 0; -} - -uint8_t LoRaMacSendFrameOnChannel( ChannelParams_t channel ) -{ - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_ERROR; - LoRaMacEventInfo.TxDatarate = ChannelsDatarate; - - ChannelsTxPower = LimitTxPower( ChannelsTxPower ); - - Radio.SetChannel( channel.Frequency ); - Radio.SetMaxPayloadLength( MODEM_LORA, LoRaMacBufferPktLen ); - -#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) - if( ChannelsDatarate == DR_7 ) - { // High Speed FSK channel - Radio.SetTxConfig( MODEM_FSK, TxPowers[ChannelsTxPower], 25e3, 0, Datarates[ChannelsDatarate] * 1e3, 0, 5, false, true, 0, 0, false, 3e6 ); - TxTimeOnAir = Radio.TimeOnAir( MODEM_FSK, LoRaMacBufferPktLen ); - } - else if( ChannelsDatarate == DR_6 ) - { // High speed LoRa channel - Radio.SetTxConfig( MODEM_LORA, TxPowers[ChannelsTxPower], 0, 1, Datarates[ChannelsDatarate], 1, 8, false, true, 0, 0, false, 3e6 ); - TxTimeOnAir = Radio.TimeOnAir( MODEM_LORA, LoRaMacBufferPktLen ); - } - else - { // Normal LoRa channel - Radio.SetTxConfig( MODEM_LORA, TxPowers[ChannelsTxPower], 0, 0, Datarates[ChannelsDatarate], 1, 8, false, true, 0, 0, false, 3e6 ); - TxTimeOnAir = Radio.TimeOnAir( MODEM_LORA, LoRaMacBufferPktLen ); - } -#elif defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - if( ChannelsDatarate >= DR_4 ) - { // High speed LoRa channel BW500 kHz - Radio.SetTxConfig( MODEM_LORA, TxPowers[ChannelsTxPower], 0, 2, Datarates[ChannelsDatarate], 1, 8, false, true, 0, 0, false, 3e6 ); - TxTimeOnAir = Radio.TimeOnAir( MODEM_LORA, LoRaMacBufferPktLen ); - } - else - { // Normal LoRa channel - Radio.SetTxConfig( MODEM_LORA, TxPowers[ChannelsTxPower], 0, 0, Datarates[ChannelsDatarate], 1, 8, false, true, 0, 0, false, 3e6 ); - TxTimeOnAir = Radio.TimeOnAir( MODEM_LORA, LoRaMacBufferPktLen ); - } -#else - #error "Please define a frequency band in the compiler options." -#endif - - if( MaxDCycle == 255 ) - { - return 6; - } - if( MaxDCycle == 0 ) - { - AggregatedTimeOff = 0; - } - - LoRaMacState |= MAC_TX_RUNNING; - // Starts the MAC layer status check timer - TimerStart( &MacStateCheckTimer ); - - if( MAX( Bands[channel.Band].TimeOff, AggregatedTimeOff ) > ( TimerGetCurrentTime( ) ) ) - { - // Schedule transmission - TimerSetValue( &TxDelayedTimer, MAX( Bands[channel.Band].TimeOff, AggregatedTimeOff ) ); - TimerStart( &TxDelayedTimer ); - } - else - { - // Send now - Radio.Send( LoRaMacBuffer, LoRaMacBufferPktLen ); - } - return 0; -} - - -void OnTxDelayedTimerEvent( void ) -{ - TimerStop( &TxDelayedTimer ); - Radio.Send( LoRaMacBuffer, LoRaMacBufferPktLen ); -} - -uint8_t LoRaMacSendOnChannel( ChannelParams_t channel, LoRaMacHeader_t *macHdr, LoRaMacFrameCtrl_t *fCtrl, uint8_t *fOpts, uint8_t fPort, void *fBuffer, uint16_t fBufferSize ) -{ - uint8_t status = 0; - - if( ( LoRaMacState & MAC_TX_RUNNING ) == MAC_TX_RUNNING ) - { - return 1; // MAC is busy transmitting a previous frame - } - - status = LoRaMacPrepareFrame( channel, macHdr, fCtrl, fOpts, fPort, fBuffer, fBufferSize ); - if( status != 0 ) - { - return status; - } - - LoRaMacEventInfo.TxNbRetries = 0; - LoRaMacEventInfo.TxAckReceived = false; - - return LoRaMacSendFrameOnChannel( channel ); -} - -static void LoRaMacProcessMacCommands( uint8_t *payload, uint8_t macIndex, uint8_t commandsSize ) +static void ProcessMacCommands( uint8_t *payload, uint8_t macIndex, uint8_t commandsSize, uint8_t snr ) { while( macIndex < commandsSize ) { @@ -1452,12 +1967,13 @@ switch( payload[macIndex++] ) { case SRV_MAC_LINK_CHECK_ANS: - LoRaMacEventFlags.Bits.LinkCheck = 1; - LoRaMacEventInfo.DemodMargin = payload[macIndex++]; - LoRaMacEventInfo.NbGateways = payload[macIndex++]; + MlmeConfirm.Status = LORAMAC_EVENT_INFO_STATUS_OK; + MlmeConfirm.DemodMargin = payload[macIndex++]; + MlmeConfirm.NbGateways = payload[macIndex++]; break; case SRV_MAC_LINK_ADR_REQ: { + uint8_t i; uint8_t status = 0x07; uint16_t chMask; int8_t txPower = 0; @@ -1465,9 +1981,9 @@ uint8_t nbRep = 0; uint8_t chMaskCntl = 0; uint16_t channelsMask[6] = { 0, 0, 0, 0, 0, 0 }; - + // Initialize local copy of the channels mask array - for( uint8_t i = 0; i < 6; i++ ) + for( i = 0; i < 6; i++ ) { channelsMask[i] = ChannelsMask[i]; } @@ -1475,7 +1991,7 @@ txPower = datarate & 0x0F; datarate = ( datarate >> 4 ) & 0x0F; - if( ( AdrCtrlOn == false ) && + if( ( AdrCtrlOn == false ) && ( ( ChannelsDatarate != datarate ) || ( ChannelsTxPower != txPower ) ) ) { // ADR disabled don't handle ADR requests if server tries to change datarate or txpower // Answer the server with fail status @@ -1501,14 +2017,15 @@ { status &= 0xFE; // Channel mask KO } - else if( ( chMaskCntl >= 1 ) && ( chMaskCntl <= 5 ) ) + else if( ( ( chMaskCntl >= 1 ) && ( chMaskCntl <= 5 )) || + ( chMaskCntl >= 7 ) ) { // RFU status &= 0xFE; // Channel mask KO } else { - for( uint8_t i = 0; i < LORA_MAX_NB_CHANNELS; i++ ) + for( i = 0; i < LORA_MAX_NB_CHANNELS; i++ ) { if( chMaskCntl == 6 ) { @@ -1567,7 +2084,7 @@ } } channelsMask[chMaskCntl] = chMask; - + if( CountNbEnabled125kHzChannels( channelsMask ) < 6 ) { status &= 0xFE; // Channel mask KO @@ -1576,8 +2093,7 @@ #else #error "Please define a frequency band in the compiler options." #endif - if( ( ( datarate < LORAMAC_MIN_DATARATE ) || - ( datarate > LORAMAC_MAX_DATARATE ) ) == true ) + if( ValueInRange( datarate, LORAMAC_MIN_DATARATE, LORAMAC_MAX_DATARATE ) == false ) { status &= 0xFD; // Datarate KO } @@ -1585,8 +2101,7 @@ // // Remark MaxTxPower = 0 and MinTxPower = 5 // - if( ( ( LORAMAC_MAX_TX_POWER <= txPower ) && - ( txPower <= LORAMAC_MIN_TX_POWER ) ) == false ) + if( ValueInRange( txPower, LORAMAC_MAX_TX_POWER, LORAMAC_MIN_TX_POWER ) == false ) { status &= 0xFB; // TxPower KO } @@ -1625,32 +2140,37 @@ int8_t datarate = 0; int8_t drOffset = 0; uint32_t freq = 0; - + drOffset = ( payload[macIndex] >> 4 ) & 0x07; datarate = payload[macIndex] & 0x0F; macIndex++; - freq = ( uint32_t )payload[macIndex++]; + + freq = ( uint32_t )payload[macIndex++]; freq |= ( uint32_t )payload[macIndex++] << 8; freq |= ( uint32_t )payload[macIndex++] << 16; freq *= 100; - + if( Radio.CheckRfFrequency( freq ) == false ) { status &= 0xFE; // Channel frequency KO } - - if( ( ( datarate < LORAMAC_MIN_DATARATE ) || - ( datarate > LORAMAC_MAX_DATARATE ) ) == true ) + + if( ValueInRange( datarate, LORAMAC_MIN_DATARATE, LORAMAC_MAX_DATARATE ) == false ) { status &= 0xFD; // Datarate KO } - - if( ( ( drOffset < LORAMAC_MIN_RX1_DR_OFFSET ) || - ( drOffset > LORAMAC_MAX_RX1_DR_OFFSET ) ) == true ) +#if ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) + if( ( ValueInRange( datarate, DR_5, DR_7 ) == true ) || + ( datarate > DR_13 ) ) + { + status &= 0xFD; // Datarate KO + } +#endif + if( ValueInRange( drOffset, LORAMAC_MIN_RX1_DR_OFFSET, LORAMAC_MAX_RX1_DR_OFFSET ) == false ) { status &= 0xFB; // Rx1DrOffset range KO } - + if( ( status & 0x07 ) == 0x07 ) { Rx2Channel.Datarate = datarate; @@ -1667,51 +2187,48 @@ { batteryLevel = LoRaMacCallbacks->GetBatteryLevel( ); } - AddMacCommand( MOTE_MAC_DEV_STATUS_ANS, batteryLevel, LoRaMacEventInfo.RxSnr ); + AddMacCommand( MOTE_MAC_DEV_STATUS_ANS, batteryLevel, snr ); + break; } - break; case SRV_MAC_NEW_CHANNEL_REQ: { uint8_t status = 0x03; +#if ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) + status &= 0xFE; // Channel frequency KO +#else int8_t channelIndex = 0; ChannelParams_t chParam; - + channelIndex = payload[macIndex++]; chParam.Frequency = ( uint32_t )payload[macIndex++]; chParam.Frequency |= ( uint32_t )payload[macIndex++] << 8; chParam.Frequency |= ( uint32_t )payload[macIndex++] << 16; chParam.Frequency *= 100; chParam.DrRange.Value = payload[macIndex++]; - - if( ( channelIndex < 3 ) || ( channelIndex > LORA_MAX_NB_CHANNELS ) ) + + if( ValueInRange( channelIndex, 3, LORA_MAX_NB_CHANNELS - 1 ) == false ) + { status &= 0xFE; // Channel frequency KO } - + if( Radio.CheckRfFrequency( chParam.Frequency ) == false ) { status &= 0xFE; // Channel frequency KO } - if( ( chParam.DrRange.Fields.Min > chParam.DrRange.Fields.Max ) || - ( ( ( LORAMAC_MIN_DATARATE <= chParam.DrRange.Fields.Min ) && - ( chParam.DrRange.Fields.Min <= LORAMAC_MAX_DATARATE ) ) == false ) || - ( ( ( LORAMAC_MIN_DATARATE <= chParam.DrRange.Fields.Max ) && - ( chParam.DrRange.Fields.Max <= LORAMAC_MAX_DATARATE ) ) == false ) ) + if( LoRaMacChannelAdd( channelIndex, chParam ) != LORAMAC_STATUS_OK ) { status &= 0xFD; // Datarate range KO } - if( ( status & 0x03 ) == 0x03 ) - { - LoRaMacSetChannel( channelIndex, chParam ); - } +#endif AddMacCommand( MOTE_MAC_NEW_CHANNEL_ANS, status, 0 ); } break; case SRV_MAC_RX_TIMING_SETUP_REQ: { uint8_t delay = payload[macIndex++] & 0x0F; - + if( delay == 0 ) { delay++; @@ -1728,891 +2245,836 @@ } } -/*! - * Function to be executed on Tx Done event - */ -static void OnRadioTxDone( void ) +LoRaMacStatus_t Send( LoRaMacHeader_t *macHdr, uint8_t fPort, void *fBuffer, uint16_t fBufferSize ) { - TimerTime_t curTime = TimerGetCurrentTime( ); - if( LoRaMacDeviceClass != CLASS_C ) - { - Radio.Sleep( ); - } - else - { - OnRxWindow2TimerEvent( ); - } - - // Update Band Time OFF - Bands[Channels[Channel].Band].LastTxDoneTime = curTime; - if( DutyCycleOn == true ) - { - Bands[Channels[Channel].Band].TimeOff = TxTimeOnAir * Bands[Channels[Channel].Band].DCycle - TxTimeOnAir; - } - else - { - Bands[Channels[Channel].Band].TimeOff = 0; - } - // Update Agregated Time OFF - AggregatedLastTxDoneTime = curTime; - AggregatedTimeOff = AggregatedTimeOff + ( TxTimeOnAir * AggregatedDCycle - TxTimeOnAir ); - - if( IsRxWindowsEnabled == true ) + LoRaMacFrameCtrl_t fCtrl; + LoRaMacStatus_t status = LORAMAC_STATUS_PARAMETER_INVALID; + + fCtrl.Value = 0; + fCtrl.Bits.FOptsLen = 0; + fCtrl.Bits.FPending = 0; + fCtrl.Bits.Ack = false; + fCtrl.Bits.AdrAckReq = false; + fCtrl.Bits.Adr = AdrCtrlOn; + + // Prepare the frame + status = PrepareFrame( macHdr, &fCtrl, fPort, fBuffer, fBufferSize ); + + // Validate status + if( status != LORAMAC_STATUS_OK ) { - TimerSetValue( &RxWindowTimer1, RxWindow1Delay ); - TimerStart( &RxWindowTimer1 ); - if( LoRaMacDeviceClass != CLASS_C ) - { - TimerSetValue( &RxWindowTimer2, RxWindow2Delay ); - TimerStart( &RxWindowTimer2 ); - } - if( ( LoRaMacDeviceClass == CLASS_C ) || ( NodeAckRequested == true ) ) - { - TimerSetValue( &AckTimeoutTimer, RxWindow2Delay + ACK_TIMEOUT + - randr( -ACK_TIMEOUT_RND, ACK_TIMEOUT_RND ) ); - TimerStart( &AckTimeoutTimer ); - } + return status; } - else - { - LoRaMacEventFlags.Bits.Tx = 1; - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_OK; - } - - if( NodeAckRequested == false ) - { - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_OK; - ChannelsNbRepCounter++; - } + + // Reset confirm parameters + McpsConfirm.NbRetries = 0; + McpsConfirm.AckReceived = false; + McpsConfirm.UpLinkCounter = UpLinkCounter; + + status = ScheduleTx( ); + + return status; } -/*! - * Function to be executed on Rx Done event - */ -static void OnRadioRxDone( uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr ) +static LoRaMacStatus_t ScheduleTx( ) { - LoRaMacHeader_t macHdr; - LoRaMacFrameCtrl_t fCtrl; - - uint8_t pktHeaderLen = 0; - uint32_t address = 0; - uint8_t appPayloadStartIndex = 0; - uint8_t port = 0xFF; - uint8_t frameLen = 0; - uint32_t mic = 0; - uint32_t micRx = 0; - - uint16_t sequenceCounter = 0; - uint16_t sequenceCounterPrev = 0; - uint16_t sequenceCounterDiff = 0; - uint32_t downLinkCounter = 0; - - MulticastParams_t *curMulticastParams = NULL; - uint8_t *nwkSKey = LoRaMacNwkSKey; - uint8_t *appSKey = LoRaMacAppSKey; - - bool isMicOk = false; - - if( LoRaMacDeviceClass != CLASS_C ) + TimerTime_t dutyCycleTimeOff = 0; + + // Check if the device is off + if( MaxDCycle == 255 ) + { + return LORAMAC_STATUS_DEVICE_OFF; + } + if( MaxDCycle == 0 ) { - Radio.Sleep( ); + AggregatedTimeOff = 0; + } + + // Select channel + dutyCycleTimeOff = SetNextChannel( ); + + // Schedule transmission of frame + if( dutyCycleTimeOff == 0 ) + { + // Try to send now + return SendFrameOnChannel( Channels[Channel] ); } else { - if( LoRaMacEventFlags.Bits.RxSlot == 0 ) - { - OnRxWindow2TimerEvent( ); - } + // Send later - prepare timer + LoRaMacState |= MAC_TX_DELAYED; + TimerSetValue( &TxDelayedTimer, dutyCycleTimeOff ); + TimerStart( &TxDelayedTimer ); + + return LORAMAC_STATUS_OK; } - TimerStop( &RxWindowTimer2 ); - - macHdr.Value = payload[pktHeaderLen++]; - - switch( macHdr.Bits.MType ) +} + +LoRaMacStatus_t PrepareFrame( LoRaMacHeader_t *macHdr, LoRaMacFrameCtrl_t *fCtrl, uint8_t fPort, void *fBuffer, uint16_t fBufferSize ) +{ + uint16_t i; + uint8_t pktHeaderLen = 0; + uint32_t mic = 0; + const void* payload = fBuffer; + uint8_t payloadSize = fBufferSize; + uint8_t framePort = fPort; + + LoRaMacBufferPktLen = 0; + + NodeAckRequested = false; + + if( fBuffer == NULL ) { - case FRAME_TYPE_JOIN_ACCEPT: - if( IsLoRaMacNetworkJoined == true ) - { - break; - } - LoRaMacJoinDecrypt( payload + 1, size - 1, LoRaMacAppKey, LoRaMacRxPayload + 1 ); - - LoRaMacRxPayload[0] = macHdr.Value; - - LoRaMacJoinComputeMic( LoRaMacRxPayload, size - LORAMAC_MFR_LEN, LoRaMacAppKey, &mic ); - - micRx |= ( uint32_t )LoRaMacRxPayload[size - LORAMAC_MFR_LEN]; - micRx |= ( ( uint32_t )LoRaMacRxPayload[size - LORAMAC_MFR_LEN + 1] << 8 ); - micRx |= ( ( uint32_t )LoRaMacRxPayload[size - LORAMAC_MFR_LEN + 2] << 16 ); - micRx |= ( ( uint32_t )LoRaMacRxPayload[size - LORAMAC_MFR_LEN + 3] << 24 ); - - if( micRx == mic ) + fBufferSize = 0; + } + + LoRaMacBuffer[pktHeaderLen++] = macHdr->Value; + + switch( macHdr->Bits.MType ) + { + case FRAME_TYPE_JOIN_REQ: + RxWindow1Delay = JoinAcceptDelay1 - RADIO_WAKEUP_TIME; + RxWindow2Delay = JoinAcceptDelay2 - RADIO_WAKEUP_TIME; + + LoRaMacBufferPktLen = pktHeaderLen; + + memcpyr( LoRaMacBuffer + LoRaMacBufferPktLen, LoRaMacAppEui, 8 ); + LoRaMacBufferPktLen += 8; + memcpyr( LoRaMacBuffer + LoRaMacBufferPktLen, LoRaMacDevEui, 8 ); + LoRaMacBufferPktLen += 8; + + LoRaMacDevNonce = Radio.Random( ); + + LoRaMacBuffer[LoRaMacBufferPktLen++] = LoRaMacDevNonce & 0xFF; + LoRaMacBuffer[LoRaMacBufferPktLen++] = ( LoRaMacDevNonce >> 8 ) & 0xFF; + + LoRaMacJoinComputeMic( LoRaMacBuffer, LoRaMacBufferPktLen & 0xFF, LoRaMacAppKey, &mic ); + + LoRaMacBuffer[LoRaMacBufferPktLen++] = mic & 0xFF; + LoRaMacBuffer[LoRaMacBufferPktLen++] = ( mic >> 8 ) & 0xFF; + LoRaMacBuffer[LoRaMacBufferPktLen++] = ( mic >> 16 ) & 0xFF; + LoRaMacBuffer[LoRaMacBufferPktLen++] = ( mic >> 24 ) & 0xFF; + + break; + case FRAME_TYPE_DATA_CONFIRMED_UP: + NodeAckRequested = true; + //Intentional falltrough + case FRAME_TYPE_DATA_UNCONFIRMED_UP: + if( IsLoRaMacNetworkJoined == false ) { - LoRaMacEventFlags.Bits.Rx = 1; - LoRaMacEventInfo.RxSnr = snr; - LoRaMacEventInfo.RxRssi = rssi; - - LoRaMacJoinComputeSKeys( LoRaMacAppKey, LoRaMacRxPayload + 1, LoRaMacDevNonce, LoRaMacNwkSKey, LoRaMacAppSKey ); - - LoRaMacNetID = ( uint32_t )LoRaMacRxPayload[4]; - LoRaMacNetID |= ( ( uint32_t )LoRaMacRxPayload[5] << 8 ); - LoRaMacNetID |= ( ( uint32_t )LoRaMacRxPayload[6] << 16 ); - - LoRaMacDevAddr = ( uint32_t )LoRaMacRxPayload[7]; - LoRaMacDevAddr |= ( ( uint32_t )LoRaMacRxPayload[8] << 8 ); - LoRaMacDevAddr |= ( ( uint32_t )LoRaMacRxPayload[9] << 16 ); - LoRaMacDevAddr |= ( ( uint32_t )LoRaMacRxPayload[10] << 24 ); - - // DLSettings - Rx1DrOffset = ( LoRaMacRxPayload[11] >> 4 ) & 0x07; - Rx2Channel.Datarate = LoRaMacRxPayload[11] & 0x0F; -#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - /* - * WARNING: To be removed once Semtech server implementation - * is corrected. - */ - if( Rx2Channel.Datarate == DR_3 ) + return LORAMAC_STATUS_NO_NETWORK_JOINED; // No network has been joined yet + } + + if( ValidatePayloadLength( fBufferSize, ChannelsDatarate, MacCommandsBufferIndex ) == false ) + { + return LORAMAC_STATUS_LENGTH_ERROR; + } + + RxWindow1Delay = ReceiveDelay1 - RADIO_WAKEUP_TIME; + RxWindow2Delay = ReceiveDelay2 - RADIO_WAKEUP_TIME; + + if( SrvAckRequested == true ) + { + SrvAckRequested = false; + fCtrl->Bits.Ack = 1; + } + + fCtrl->Bits.AdrAckReq = AdrNextDr( fCtrl->Bits.Adr, true, &ChannelsDatarate ); + + LoRaMacBuffer[pktHeaderLen++] = ( LoRaMacDevAddr ) & 0xFF; + LoRaMacBuffer[pktHeaderLen++] = ( LoRaMacDevAddr >> 8 ) & 0xFF; + LoRaMacBuffer[pktHeaderLen++] = ( LoRaMacDevAddr >> 16 ) & 0xFF; + LoRaMacBuffer[pktHeaderLen++] = ( LoRaMacDevAddr >> 24 ) & 0xFF; + + LoRaMacBuffer[pktHeaderLen++] = fCtrl->Value; + + LoRaMacBuffer[pktHeaderLen++] = UpLinkCounter & 0xFF; + LoRaMacBuffer[pktHeaderLen++] = ( UpLinkCounter >> 8 ) & 0xFF; + + if( ( payload != NULL ) && ( payloadSize > 0 ) ) + { + if( ( MacCommandsBufferIndex <= LORA_MAC_COMMAND_MAX_LENGTH ) && ( MacCommandsInNextTx == true ) ) { - Rx2Channel.Datarate = DR_8; - } -#endif - // RxDelay - ReceiveDelay1 = ( LoRaMacRxPayload[12] & 0x0F ); - if( ReceiveDelay1 == 0 ) - { - ReceiveDelay1 = 1; - } - ReceiveDelay1 *= 1e6; - ReceiveDelay2 = ReceiveDelay1 + 1e6; - -#if !( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) - //CFList - if( ( size - 1 ) > 16 ) - { - ChannelParams_t param; - param.DrRange.Value = ( DR_5 << 4 ) | DR_0; - - for( uint8_t i = 3, j = 0; i < ( 5 + 3 ); i++, j += 3 ) + fCtrl->Bits.FOptsLen += MacCommandsBufferIndex; + + // Update FCtrl field with new value of OptionsLength + LoRaMacBuffer[0x05] = fCtrl->Value; + for( i = 0; i < MacCommandsBufferIndex; i++ ) { - param.Frequency = ( ( uint32_t )LoRaMacRxPayload[13 + j] | ( ( uint32_t )LoRaMacRxPayload[14 + j] << 8 ) | ( ( uint32_t )LoRaMacRxPayload[15 + j] << 16 ) ) * 100; - LoRaMacSetChannel( i, param ); + LoRaMacBuffer[pktHeaderLen++] = MacCommandsBuffer[i]; } } -#endif - LoRaMacEventFlags.Bits.JoinAccept = 1; - IsLoRaMacNetworkJoined = true; - ChannelsDatarate = ChannelsDefaultDatarate; - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_OK; } else { - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_JOIN_FAIL; - } - break; - case FRAME_TYPE_DATA_CONFIRMED_DOWN: - case FRAME_TYPE_DATA_UNCONFIRMED_DOWN: - { - address = payload[pktHeaderLen++]; - address |= ( (uint32_t)payload[pktHeaderLen++] << 8 ); - address |= ( (uint32_t)payload[pktHeaderLen++] << 16 ); - address |= ( (uint32_t)payload[pktHeaderLen++] << 24 ); - - if( address != LoRaMacDevAddr ) + if( ( MacCommandsBufferIndex > 0 ) && ( MacCommandsInNextTx ) ) { - curMulticastParams = MulticastChannels; - while( curMulticastParams != NULL ) - { - if( address == curMulticastParams->Address ) - { - LoRaMacEventFlags.Bits.Multicast = 1; - nwkSKey = curMulticastParams->NwkSKey; - appSKey = curMulticastParams->AppSKey; - downLinkCounter = curMulticastParams->DownLinkCounter; - break; - } - curMulticastParams = curMulticastParams->Next; - } - if( LoRaMacEventFlags.Bits.Multicast == 0 ) - { - // We are not the destination of this frame. - LoRaMacEventFlags.Bits.Tx = 1; - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_ADDRESS_FAIL; - LoRaMacState &= ~MAC_TX_RUNNING; - return; - } + payloadSize = MacCommandsBufferIndex; + payload = MacCommandsBuffer; + framePort = 0; } - else - { - LoRaMacEventFlags.Bits.Multicast = 0; - nwkSKey = LoRaMacNwkSKey; - appSKey = LoRaMacAppSKey; - downLinkCounter = DownLinkCounter; - } - - if( LoRaMacDeviceClass != CLASS_A ) + } + MacCommandsInNextTx = false; + MacCommandsBufferIndex = 0; + + if( ( payload != NULL ) && ( payloadSize > 0 ) ) + { + LoRaMacBuffer[pktHeaderLen++] = framePort; + + if( framePort == 0 ) { - LoRaMacState |= MAC_RX; - // Starts the MAC layer status check timer - TimerStart( &MacStateCheckTimer ); - } - fCtrl.Value = payload[pktHeaderLen++]; - - sequenceCounter = ( uint16_t )payload[pktHeaderLen++]; - sequenceCounter |= ( uint16_t )payload[pktHeaderLen++] << 8; - - appPayloadStartIndex = 8 + fCtrl.Bits.FOptsLen; - - micRx |= ( uint32_t )payload[size - LORAMAC_MFR_LEN]; - micRx |= ( (uint32_t)payload[size - LORAMAC_MFR_LEN + 1] << 8 ); - micRx |= ( (uint32_t)payload[size - LORAMAC_MFR_LEN + 2] << 16 ); - micRx |= ( (uint32_t)payload[size - LORAMAC_MFR_LEN + 3] << 24 ); - - sequenceCounterPrev = ( uint16_t )downLinkCounter; - sequenceCounterDiff = ( sequenceCounter - sequenceCounterPrev ); - - if( sequenceCounterDiff < ( 1 << 15 ) ) - { - downLinkCounter += sequenceCounterDiff; - LoRaMacComputeMic( payload, size - LORAMAC_MFR_LEN, nwkSKey, address, DOWN_LINK, downLinkCounter, &mic ); - if( micRx == mic ) - { - isMicOk = true; - } + LoRaMacPayloadEncrypt( (uint8_t* ) payload, payloadSize, LoRaMacNwkSKey, LoRaMacDevAddr, UP_LINK, UpLinkCounter, LoRaMacPayload ); } else { - // check for downlink counter roll-over - uint32_t downLinkCounterTmp = downLinkCounter + 0x10000 + ( int16_t )sequenceCounterDiff; - LoRaMacComputeMic( payload, size - LORAMAC_MFR_LEN, nwkSKey, address, DOWN_LINK, downLinkCounterTmp, &mic ); - if( micRx == mic ) - { - isMicOk = true; - downLinkCounter = downLinkCounterTmp; - } + LoRaMacPayloadEncrypt( (uint8_t* ) payload, payloadSize, LoRaMacAppSKey, LoRaMacDevAddr, UP_LINK, UpLinkCounter, LoRaMacPayload ); } - - if( isMicOk == true ) - { - LoRaMacEventFlags.Bits.Rx = 1; - LoRaMacEventInfo.RxSnr = snr; - LoRaMacEventInfo.RxRssi = rssi; - LoRaMacEventInfo.RxBufferSize = 0; - AdrAckCounter = 0; - - // Update 32 bits downlink counter - if( LoRaMacEventFlags.Bits.Multicast == 1 ) - { - curMulticastParams->DownLinkCounter = downLinkCounter; - } - else - { - DownLinkCounter = downLinkCounter; - } - - if( macHdr.Bits.MType == FRAME_TYPE_DATA_CONFIRMED_DOWN ) - { - SrvAckRequested = true; - } - else - { - SrvAckRequested = false; - } - // Check if the frame is an acknowledgement - if( fCtrl.Bits.Ack == 1 ) - { - LoRaMacEventInfo.TxAckReceived = true; - - // Stop the AckTimeout timer as no more retransmissions - // are needed. - TimerStop( &AckTimeoutTimer ); - } - else - { - LoRaMacEventInfo.TxAckReceived = false; - if( AckTimeoutRetriesCounter > AckTimeoutRetries ) - { - // Stop the AckTimeout timer as no more retransmissions - // are needed. - TimerStop( &AckTimeoutTimer ); - } - } - - if( fCtrl.Bits.FOptsLen > 0 ) - { - // Decode Options field MAC commands - LoRaMacProcessMacCommands( payload, 8, appPayloadStartIndex ); - } - - if( ( ( size - 4 ) - appPayloadStartIndex ) > 0 ) - { - port = payload[appPayloadStartIndex++]; - frameLen = ( size - 4 ) - appPayloadStartIndex; - - if( port == 0 ) - { - LoRaMacPayloadDecrypt( payload + appPayloadStartIndex, - frameLen, - nwkSKey, - address, - DOWN_LINK, - downLinkCounter, - LoRaMacRxPayload ); - - // Decode frame payload MAC commands - LoRaMacProcessMacCommands( LoRaMacRxPayload, 0, frameLen ); - } - else - { - LoRaMacPayloadDecrypt( payload + appPayloadStartIndex, - frameLen, - appSKey, - address, - DOWN_LINK, - downLinkCounter, - LoRaMacRxPayload ); - - LoRaMacEventFlags.Bits.RxData = 1; - LoRaMacEventInfo.RxPort = port; - LoRaMacEventInfo.RxBuffer = LoRaMacRxPayload; - LoRaMacEventInfo.RxBufferSize = frameLen; - } - } - - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_OK; - } - else - { - LoRaMacEventInfo.TxAckReceived = false; - - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_MIC_FAIL; - LoRaMacState &= ~MAC_TX_RUNNING; - if( NodeAckRequested == true ) - { - OnAckTimeoutTimerEvent( ); - } - } + memcpy1( LoRaMacBuffer + pktHeaderLen, LoRaMacPayload, payloadSize ); + } + LoRaMacBufferPktLen = pktHeaderLen + payloadSize; + + LoRaMacComputeMic( LoRaMacBuffer, LoRaMacBufferPktLen, LoRaMacNwkSKey, LoRaMacDevAddr, UP_LINK, UpLinkCounter, &mic ); + + LoRaMacBuffer[LoRaMacBufferPktLen + 0] = mic & 0xFF; + LoRaMacBuffer[LoRaMacBufferPktLen + 1] = ( mic >> 8 ) & 0xFF; + LoRaMacBuffer[LoRaMacBufferPktLen + 2] = ( mic >> 16 ) & 0xFF; + LoRaMacBuffer[LoRaMacBufferPktLen + 3] = ( mic >> 24 ) & 0xFF; + + LoRaMacBufferPktLen += LORAMAC_MFR_LEN; + + break; + case FRAME_TYPE_PROPRIETARY: + if( ( fBuffer != NULL ) && ( fBufferSize > 0 ) ) + { + memcpy1( LoRaMacBuffer + pktHeaderLen, ( uint8_t* ) fBuffer, fBufferSize ); + LoRaMacBufferPktLen = pktHeaderLen + fBufferSize; } break; - case FRAME_TYPE_PROPRIETARY: - //Intentional falltrough default: - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_ERROR; - LoRaMacState &= ~MAC_TX_RUNNING; - break; + return LORAMAC_STATUS_SERVICE_UNKNOWN; } - LoRaMacEventFlags.Bits.Tx = 1; + + return LORAMAC_STATUS_OK; } -/*! - * Function executed on Radio Tx Timeout event - */ -static void OnRadioTxTimeout( void ) +LoRaMacStatus_t SendFrameOnChannel( ChannelParams_t channel ) { - if( LoRaMacDeviceClass != CLASS_C ) - { - Radio.Sleep( ); - } - else - { - OnRxWindow2TimerEvent( ); + int8_t datarate = Datarates[ChannelsDatarate]; + int8_t txPower = 0; + + ChannelsTxPower = LimitTxPower( ChannelsTxPower ); + txPower = TxPowers[ChannelsTxPower]; + + MlmeConfirm.Status = LORAMAC_EVENT_INFO_STATUS_ERROR; + McpsConfirm.Status = LORAMAC_EVENT_INFO_STATUS_ERROR; + McpsConfirm.Datarate = ChannelsDatarate; + McpsConfirm.TxPower = ChannelsTxPower; + + Radio.SetChannel( channel.Frequency ); + +#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) + if( ChannelsDatarate == DR_7 ) + { // High Speed FSK channel + Radio.SetMaxPayloadLength( MODEM_FSK, LoRaMacBufferPktLen ); + Radio.SetTxConfig( MODEM_FSK, txPower, 25e3, 0, datarate * 1e3, 0, 5, false, true, 0, 0, false, 3e6 ); + TxTimeOnAir = Radio.TimeOnAir( MODEM_FSK, LoRaMacBufferPktLen ); + } - - LoRaMacEventFlags.Bits.Tx = 1; - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_TX_TIMEOUT; -} - -/*! - * Function executed on Radio Rx Timeout event - */ -static void OnRadioRxTimeout( void ) -{ - if( LoRaMacDeviceClass != CLASS_C ) - { - Radio.Sleep( ); + else if( ChannelsDatarate == DR_6 ) + { // High speed LoRa channel + Radio.SetMaxPayloadLength( MODEM_LORA, LoRaMacBufferPktLen ); + Radio.SetTxConfig( MODEM_LORA, txPower, 0, 1, datarate, 1, 8, false, true, 0, 0, false, 3e6 ); + TxTimeOnAir = Radio.TimeOnAir( MODEM_LORA, LoRaMacBufferPktLen ); } else - { - OnRxWindow2TimerEvent( ); - } - if( LoRaMacEventFlags.Bits.RxSlot == 1 ) - { - LoRaMacEventFlags.Bits.Tx = 1; - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_RX2_TIMEOUT; + { // Normal LoRa channel + Radio.SetMaxPayloadLength( MODEM_LORA, LoRaMacBufferPktLen ); + Radio.SetTxConfig( MODEM_LORA, txPower, 0, 0, datarate, 1, 8, false, true, 0, 0, false, 3e6 ); + TxTimeOnAir = Radio.TimeOnAir( MODEM_LORA, LoRaMacBufferPktLen ); } -} - -/*! - * Function executed on Radio Rx Error event - */ -static void OnRadioRxError( void ) -{ - if( LoRaMacDeviceClass != CLASS_C ) - { - Radio.Sleep( ); +#elif defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + Radio.SetMaxPayloadLength( MODEM_LORA, LoRaMacBufferPktLen ); + if( ChannelsDatarate >= DR_4 ) + { // High speed LoRa channel BW500 kHz + Radio.SetTxConfig( MODEM_LORA, txPower, 0, 2, datarate, 1, 8, false, true, 0, 0, false, 3e6 ); + TxTimeOnAir = Radio.TimeOnAir( MODEM_LORA, LoRaMacBufferPktLen ); } else - { - OnRxWindow2TimerEvent( ); - } - if( LoRaMacEventFlags.Bits.RxSlot == 1 ) - { - LoRaMacEventFlags.Bits.Tx = 1; - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_RX2_ERROR; - } -} - -/*! - * Initializes and opens the reception window - * - * \param [IN] freq window channel frequency - * \param [IN] datarate window channel datarate - * \param [IN] bandwidth window channel bandwidth - * \param [IN] timeout window channel timeout - */ -void LoRaMacRxWindowSetup( uint32_t freq, int8_t datarate, uint32_t bandwidth, uint16_t timeout, bool rxContinuous ) -{ - uint8_t downlinkDatarate = Datarates[datarate]; - RadioModems_t modem; - - if( Radio.GetStatus( ) == RF_IDLE ) - { - Radio.SetChannel( freq ); -#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) - if( datarate == DR_7 ) - { - modem = MODEM_FSK; - Radio.SetRxConfig( MODEM_FSK, 50e3, downlinkDatarate * 1e3, 0, 83.333e3, 5, 0, false, 0, true, 0, 0, false, rxContinuous ); - } - else - { - modem = MODEM_LORA; - Radio.SetRxConfig( MODEM_LORA, bandwidth, downlinkDatarate, 1, 0, 8, timeout, false, 0, false, 0, 0, true, rxContinuous ); - } -#elif defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - modem = MODEM_LORA; - Radio.SetRxConfig( MODEM_LORA, bandwidth, downlinkDatarate, 1, 0, 8, timeout, false, 0, false, 0, 0, true, rxContinuous ); -#endif - if( RepeaterSupport == true ) - { - Radio.SetMaxPayloadLength( modem, MaxPayloadOfDatarateRepeater[datarate] ); - } - else - { - Radio.SetMaxPayloadLength( modem, MaxPayloadOfDatarate[datarate] ); - } - - if( rxContinuous == false ) - { - Radio.Rx( MaxRxWindow ); - } - else - { - Radio.Rx( 0 ); // Continuous mode - } - } -} - -/*! - * Function executed on first Rx window timer event - */ -static void OnRxWindow1TimerEvent( void ) -{ - uint16_t symbTimeout = 5; // DR_2, DR_1, DR_0 - int8_t datarate = 0; - uint32_t bandwidth = 0; // LoRa 125 kHz - - TimerStop( &RxWindowTimer1 ); - LoRaMacEventFlags.Bits.RxSlot = 0; - - if( LoRaMacDeviceClass == CLASS_C ) - { - Radio.Standby( ); - } -#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) - datarate = ChannelsDatarate - Rx1DrOffset; - if( datarate < 0 ) - { - datarate = DR_0; - } - - // For higher datarates, we increase the number of symbols generating a Rx Timeout - if( datarate >= DR_3 ) - { // DR_6, DR_5, DR_4, DR_3 - symbTimeout = 8; - } - if( datarate == DR_6 ) - {// LoRa 250 kHz - bandwidth = 1; - } - LoRaMacRxWindowSetup( Channels[Channel].Frequency, datarate, bandwidth, symbTimeout, false ); -#elif ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) - datarate = datarateOffsets[ChannelsDatarate][Rx1DrOffset]; - if( datarate < 0 ) - { - datarate = DR_0; - } - // For higher datarates, we increase the number of symbols generating a Rx Timeout - if( datarate > DR_0 ) - { // DR_1, DR_2, DR_3, DR_4, DR_8, DR_9, DR_10, DR_11, DR_12, DR_13 - symbTimeout = 8; - } - if( datarate >= DR_4 ) - {// LoRa 500 kHz - bandwidth = 2; - } - LoRaMacRxWindowSetup( 923.3e6 + ( Channel % 8 ) * 600e3, datarate, bandwidth, symbTimeout, false ); -#else - #error "Please define a frequency band in the compiler options." -#endif -} - -/*! - * Function executed on second Rx window timer event - */ -static void OnRxWindow2TimerEvent( void ) -{ - uint16_t symbTimeout = 5; // DR_2, DR_1, DR_0 - uint32_t bandwidth = 0; // LoRa 125 kHz - - TimerStop( &RxWindowTimer2 ); - LoRaMacEventFlags.Bits.RxSlot = 1; - - if( NodeAckRequested == true ) - { - TimerSetValue( &AckTimeoutTimer, ACK_TIMEOUT + randr( -ACK_TIMEOUT_RND, ACK_TIMEOUT_RND ) ); - TimerStart( &AckTimeoutTimer ); - } - -#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) - // For higher datarates, we increase the number of symbols generating a Rx Timeout - if( Rx2Channel.Datarate >= DR_3 ) - { // DR_6, DR_5, DR_4, DR_3 - symbTimeout = 8; - } - if( Rx2Channel.Datarate == DR_6 ) - {// LoRa 250 kHz - bandwidth = 1; - } -#elif ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) - // For higher datarates, we increase the number of symbols generating a Rx Timeout - if( Rx2Channel.Datarate > DR_0 ) - { // DR_1, DR_2, DR_3, DR_4, DR_8, DR_9, DR_10, DR_11, DR_12, DR_13 - symbTimeout = 8; - } - if( Rx2Channel.Datarate >= DR_4 ) - {// LoRa 500 kHz - bandwidth = 2; + { // Normal LoRa channel + Radio.SetTxConfig( MODEM_LORA, txPower, 0, 0, datarate, 1, 8, false, true, 0, 0, false, 3e6 ); + TxTimeOnAir = Radio.TimeOnAir( MODEM_LORA, LoRaMacBufferPktLen ); } #else #error "Please define a frequency band in the compiler options." #endif - if( LoRaMacDeviceClass != CLASS_C ) + + // Store the time on air + McpsConfirm.TxTimeOnAir = TxTimeOnAir; + MlmeConfirm.TxTimeOnAir = TxTimeOnAir; + + // Starts the MAC layer status check timer + TimerStart( &MacStateCheckTimer ); + + // Send now + Radio.Send( LoRaMacBuffer, LoRaMacBufferPktLen ); + + LoRaMacState |= MAC_TX_RUNNING; + + return LORAMAC_STATUS_OK; +} + +LoRaMacStatus_t LoRaMacInitialization( LoRaMacPrimitives_t *primitives, LoRaMacCallback_t *callbacks ) +{ + if( primitives == NULL ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + + if( ( primitives->MacMcpsConfirm == NULL ) || + ( primitives->MacMcpsIndication == NULL ) || + ( primitives->MacMlmeConfirm == NULL )) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + + LoRaMacPrimitives = primitives; + LoRaMacCallbacks = callbacks; + + LoRaMacFlags.Value = 0; + + LoRaMacDeviceClass = CLASS_A; + + UpLinkCounter = 1; + DownLinkCounter = 0; + AdrAckCounter = 0; + + RepeaterSupport = false; + IsRxWindowsEnabled = true; + IsLoRaMacNetworkJoined = false; + LoRaMacState = MAC_IDLE; + +#if defined( USE_BAND_433 ) + ChannelsMask[0] = LC( 1 ) + LC( 2 ) + LC( 3 ); +#elif defined( USE_BAND_780 ) + ChannelsMask[0] = LC( 1 ) + LC( 2 ) + LC( 3 ); +#elif defined( USE_BAND_868 ) + ChannelsMask[0] = LC( 1 ) + LC( 2 ) + LC( 3 ); +#elif defined( USE_BAND_915 ) + ChannelsMask[0] = 0xFFFF; + ChannelsMask[1] = 0xFFFF; + ChannelsMask[2] = 0xFFFF; + ChannelsMask[3] = 0xFFFF; + ChannelsMask[4] = 0x00FF; + ChannelsMask[5] = 0x0000; + + memcpy1( ( uint8_t* ) ChannelsMaskRemaining, ( uint8_t* ) ChannelsMask, sizeof( ChannelsMask ) ); +#elif defined( USE_BAND_915_HYBRID ) + ChannelsMask[0] = 0x00FF; + ChannelsMask[1] = 0x0000; + ChannelsMask[2] = 0x0000; + ChannelsMask[3] = 0x0000; + ChannelsMask[4] = 0x0001; + ChannelsMask[5] = 0x0000; + + memcpy1( ( uint8_t* ) ChannelsMaskRemaining, ( uint8_t* ) ChannelsMask, sizeof( ChannelsMask ) ); +#else + #error "Please define a frequency band in the compiler options." +#endif + +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + // 125 kHz channels + for( uint8_t i = 0; i < LORA_MAX_NB_CHANNELS - 8; i++ ) { - LoRaMacRxWindowSetup( Rx2Channel.Frequency, Rx2Channel.Datarate, bandwidth, symbTimeout, false ); + Channels[i].Frequency = 902.3e6 + i * 200e3; + Channels[i].DrRange.Value = ( DR_3 << 4 ) | DR_0; + Channels[i].Band = 0; + } + // 500 kHz channels + for( uint8_t i = LORA_MAX_NB_CHANNELS - 8; i < LORA_MAX_NB_CHANNELS; i++ ) + { + Channels[i].Frequency = 903.0e6 + ( i - ( LORA_MAX_NB_CHANNELS - 8 ) ) * 1.6e6; + Channels[i].DrRange.Value = ( DR_4 << 4 ) | DR_4; + Channels[i].Band = 0; + } +#endif + + ChannelsTxPower = LORAMAC_DEFAULT_TX_POWER; + ChannelsDefaultDatarate = ChannelsDatarate = LORAMAC_DEFAULT_DATARATE; + ChannelsNbRep = 1; + ChannelsNbRepCounter = 0; + + MaxDCycle = 0; + AggregatedDCycle = 1; + AggregatedLastTxDoneTime = 0; + AggregatedTimeOff = 0; + +#if defined( USE_BAND_433 ) + DutyCycleOn = false; +#elif defined( USE_BAND_780 ) + DutyCycleOn = false; +#elif defined( USE_BAND_868 ) + DutyCycleOn = true; +#elif defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + DutyCycleOn = false; +#else + #error "Please define a frequency band in the compiler options." +#endif + + MaxRxWindow = MAX_RX_WINDOW; + ReceiveDelay1 = RECEIVE_DELAY1; + ReceiveDelay2 = RECEIVE_DELAY2; + JoinAcceptDelay1 = JOIN_ACCEPT_DELAY1; + JoinAcceptDelay2 = JOIN_ACCEPT_DELAY2; + + TimerInit( &MacStateCheckTimer, OnMacStateCheckTimerEvent ); + TimerSetValue( &MacStateCheckTimer, MAC_STATE_CHECK_TIMEOUT ); + + TimerInit( &TxDelayedTimer, OnTxDelayedTimerEvent ); + TimerInit( &RxWindowTimer1, OnRxWindow1TimerEvent ); + TimerInit( &RxWindowTimer2, OnRxWindow2TimerEvent ); + TimerInit( &AckTimeoutTimer, OnAckTimeoutTimerEvent ); + + // Initialize Radio driver + RadioEvents.TxDone = OnRadioTxDone; + RadioEvents.RxDone = OnRadioRxDone; + RadioEvents.RxError = OnRadioRxError; + RadioEvents.TxTimeout = OnRadioTxTimeout; + RadioEvents.RxTimeout = OnRadioRxTimeout; + Radio.Init( &RadioEvents ); + + // Random seed initialization + srand1( Radio.Random( ) ); + + // Initialize channel index. + Channel = LORA_MAX_NB_CHANNELS; + + PublicNetwork = true; + SetPublicNetwork( PublicNetwork ); + Radio.Sleep( ); + + return LORAMAC_STATUS_OK; +} + +LoRaMacStatus_t LoRaMacQueryTxPossible( uint8_t size, LoRaMacTxInfo_t* txInfo ) +{ + int8_t datarate = ChannelsDefaultDatarate; + + if( txInfo == NULL ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + + AdrNextDr( AdrCtrlOn, false, &datarate ); + + if( RepeaterSupport == true ) + { + txInfo->CurrentPayloadSize = MaxPayloadOfDatarateRepeater[datarate]; } else { - LoRaMacRxWindowSetup( Rx2Channel.Frequency, Rx2Channel.Datarate, bandwidth, symbTimeout, true ); + txInfo->CurrentPayloadSize = MaxPayloadOfDatarate[datarate]; } -} - -/*! - * Function executed on MacStateCheck timer event - */ -static void OnMacStateCheckTimerEvent( void ) -{ - TimerStop( &MacStateCheckTimer ); - - if( LoRaMacEventFlags.Bits.Tx == 1 ) + + if( txInfo->CurrentPayloadSize >= MacCommandsBufferIndex ) { - if( NodeAckRequested == false ) - { - if( LoRaMacEventFlags.Bits.JoinAccept == true ) - { - // Join messages aren't repeated automatically - ChannelsNbRepCounter = ChannelsNbRep; - UpLinkCounter = 0; - } - if( ChannelsNbRepCounter >= ChannelsNbRep ) - { - ChannelsNbRepCounter = 0; - - LoRaMacEventInfo.Status = LORAMAC_EVENT_INFO_STATUS_OK; - - AdrAckCounter++; - if( IsUpLinkCounterFixed == false ) - { - UpLinkCounter++; - } - - LoRaMacState &= ~MAC_TX_RUNNING; - } - else - { - LoRaMacEventFlags.Bits.Tx = 0; - // Sends the same frame again - if( LoRaMacSetNextChannel( ) == 0 ) - { - LoRaMacSendFrameOnChannel( Channels[Channel] ); - } - } - } - - if( LoRaMacEventFlags.Bits.Rx == 1 ) - { - if( ( LoRaMacEventInfo.TxAckReceived == true ) || ( AckTimeoutRetriesCounter > AckTimeoutRetries ) ) - { - AckTimeoutRetry = false; - if( IsUpLinkCounterFixed == false ) - { - UpLinkCounter++; - } - LoRaMacEventInfo.TxNbRetries = AckTimeoutRetriesCounter; - - LoRaMacState &= ~MAC_TX_RUNNING; - } - } - - if( ( AckTimeoutRetry == true ) && ( ( LoRaMacState & MAC_CHANNEL_CHECK ) == 0 ) ) - { - AckTimeoutRetry = false; - if( ( AckTimeoutRetriesCounter < AckTimeoutRetries ) && ( AckTimeoutRetriesCounter <= MAX_ACK_RETRIES ) ) - { - AckTimeoutRetriesCounter++; - - if( ( AckTimeoutRetriesCounter % 2 ) == 1 ) - { - ChannelsDatarate = MAX( ChannelsDatarate - 1, LORAMAC_MIN_DATARATE ); - } - LoRaMacEventFlags.Bits.Tx = 0; - // Sends the same frame again - if( LoRaMacSetNextChannel( ) == 0 ) - { - LoRaMacSendFrameOnChannel( Channels[Channel] ); - } - } - else - { -#if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) || defined( USE_BAND_868 ) - // Re-enable default channels LC1, LC2, LC3 - ChannelsMask[0] = ChannelsMask[0] | ( LC( 1 ) + LC( 2 ) + LC( 3 ) ); -#elif defined( USE_BAND_915 ) - // Re-enable default channels - ChannelsMask[0] = 0xFFFF; - ChannelsMask[1] = 0xFFFF; - ChannelsMask[2] = 0xFFFF; - ChannelsMask[3] = 0xFFFF; - ChannelsMask[4] = 0x00FF; - ChannelsMask[5] = 0x0000; -#elif defined( USE_BAND_915_HYBRID ) - // Re-enable default channels - ChannelsMask[0] = 0x00FF; - ChannelsMask[1] = 0x0000; - ChannelsMask[2] = 0x0000; - ChannelsMask[3] = 0x0000; - ChannelsMask[4] = 0x0001; - ChannelsMask[5] = 0x0000; -#else - #error "Please define a frequency band in the compiler options." -#endif - LoRaMacState &= ~MAC_TX_RUNNING; - - LoRaMacEventInfo.TxAckReceived = false; - LoRaMacEventInfo.TxNbRetries = AckTimeoutRetriesCounter; - if( IsUpLinkCounterFixed == false ) - { - UpLinkCounter++; - } - } - } - } - // Handle reception for Class B and Class C - if( ( LoRaMacState & MAC_RX ) == MAC_RX ) - { - LoRaMacState &= ~MAC_RX; - } - if( LoRaMacState == MAC_IDLE ) - { - LoRaMacNotify( &LoRaMacEventFlags, &LoRaMacEventInfo ); - LoRaMacEventFlags.Bits.Tx = 0; + txInfo->MaxPossiblePayload = txInfo->CurrentPayloadSize - MacCommandsBufferIndex; } else { - // Operation not finished restart timer - TimerStart( &MacStateCheckTimer ); + return LORAMAC_STATUS_MAC_CMD_LENGTH_ERROR; + } + + if( ValidatePayloadLength( size, datarate, 0 ) == false ) + { + return LORAMAC_STATUS_LENGTH_ERROR; } -} - -static void OnAckTimeoutTimerEvent( void ) -{ - TimerStop( &AckTimeoutTimer ); - - AckTimeoutRetry = true; - LoRaMacState &= ~MAC_ACK_REQ; -} - -/*! - * ============================================================================ - * = LoRaMac utility functions = - * ============================================================================ - */ -static bool ValidatePayloadLength( uint8_t lenN, int8_t datarate ) -{ - bool payloadSizeOk = false; - uint8_t maxN = 0; - - // Get the maximum payload length - if( RepeaterSupport == true ) + + if( ValidatePayloadLength( size, datarate, MacCommandsBufferIndex ) == false ) { - maxN = MaxPayloadOfDatarateRepeater[datarate]; - } - else - { - maxN = MaxPayloadOfDatarate[datarate]; + return LORAMAC_STATUS_MAC_CMD_LENGTH_ERROR; } - // Validation of the application payload size - if( lenN <= maxN ) - { - payloadSizeOk = true; - } - - return payloadSizeOk; + return LORAMAC_STATUS_OK; } -#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) -static uint8_t CountNbEnabled125kHzChannels( uint16_t *channelsMask ) +LoRaMacStatus_t LoRaMacMibGetRequestConfirm( MibRequestConfirm_t *mibGet ) { - uint8_t nb125kHzChannels = 0; - - for( uint8_t i = 0, k = 0; i < LORA_MAX_NB_CHANNELS - 8; i += 16, k++ ) + LoRaMacStatus_t status = LORAMAC_STATUS_OK; + + if( mibGet == NULL ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + + switch( mibGet->Type ) { - for( uint8_t j = 0; j < 16; j++ ) - {// Verify if the channel is active - if( ( channelsMask[k] & ( 1 << j ) ) == ( 1 << j ) ) - { - nb125kHzChannels++; - } + case MIB_DEVICE_CLASS: + { + mibGet->Param.Class = LoRaMacDeviceClass; + break; + } + case MIB_NETWORK_JOINED: + { + mibGet->Param.IsNetworkJoined = IsLoRaMacNetworkJoined; + break; + } + case MIB_ADR: + { + mibGet->Param.AdrEnable = AdrCtrlOn; + break; + } + case MIB_NET_ID: + { + mibGet->Param.NetID = LoRaMacNetID; + break; + } + case MIB_DEV_ADDR: + { + mibGet->Param.DevAddr = LoRaMacDevAddr; + break; + } + case MIB_NWK_SKEY: + { + mibGet->Param.NwkSKey = LoRaMacNwkSKey; + break; + } + case MIB_APP_SKEY: + { + mibGet->Param.AppSKey = LoRaMacAppSKey; + break; + } + case MIB_PUBLIC_NETWORK: + { + mibGet->Param.EnablePublicNetwork = PublicNetwork; + break; + } + case MIB_REPEATER_SUPPORT: + { + mibGet->Param.EnableRepeaterSupport = RepeaterSupport; + break; + } + case MIB_CHANNELS: + { + mibGet->Param.ChannelList = Channels; + break; + } + case MIB_RX2_CHANNEL: + { + mibGet->Param.Rx2Channel = Rx2Channel; + break; + } + case MIB_CHANNELS_MASK: + { + mibGet->Param.ChannelsMask = ChannelsMask; + break; } + case MIB_CHANNELS_NB_REP: + { + mibGet->Param.ChannelNbRep = ChannelsNbRep; + break; + } + case MIB_MAX_RX_WINDOW_DURATION: + { + mibGet->Param.MaxRxWindow = MaxRxWindow; + break; + } + case MIB_RECEIVE_DELAY_1: + { + mibGet->Param.ReceiveDelay1 = ReceiveDelay1; + break; + } + case MIB_RECEIVE_DELAY_2: + { + mibGet->Param.ReceiveDelay2 = ReceiveDelay2; + break; + } + case MIB_JOIN_ACCEPT_DELAY_1: + { + mibGet->Param.JoinAcceptDelay1 = JoinAcceptDelay1; + break; + } + case MIB_JOIN_ACCEPT_DELAY_2: + { + mibGet->Param.JoinAcceptDelay2 = JoinAcceptDelay2; + break; + } + case MIB_CHANNELS_DATARATE: + { + mibGet->Param.ChannelsDatarate = ChannelsDatarate; + break; + } + case MIB_CHANNELS_TX_POWER: + { + mibGet->Param.ChannelsTxPower = ChannelsTxPower; + break; + } + case MIB_UPLINK_COUNTER: + { + mibGet->Param.UpLinkCounter = UpLinkCounter; + break; + } + case MIB_DOWNLINK_COUNTER: + { + mibGet->Param.DownLinkCounter = DownLinkCounter; + break; + } + case MIB_MULTICAST_CHANNEL: + { + mibGet->Param.MulticastList = MulticastChannels; + break; + } + default: + status = LORAMAC_STATUS_SERVICE_UNKNOWN; + break; } - return nb125kHzChannels; + return status; } -#endif - -static int8_t LimitTxPower( int8_t txPower ) + +LoRaMacStatus_t LoRaMacMibSetRequestConfirm( MibRequestConfirm_t *mibSet ) { - int8_t resultTxPower = txPower; -#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - if( ( ChannelsDatarate == DR_4 ) || - ( ( ChannelsDatarate >= DR_8 ) && ( ChannelsDatarate <= DR_13 ) ) ) - {// Limit tx power to max 26dBm - resultTxPower = MAX( txPower, TX_POWER_26_DBM ); + LoRaMacStatus_t status = LORAMAC_STATUS_OK; + + if( mibSet == NULL ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; } - else - { - if( CountNbEnabled125kHzChannels( ChannelsMask ) < 50 ) - {// Limit tx power to max 21dBm - resultTxPower = MAX( txPower, TX_POWER_20_DBM ); - } - } -#endif - return resultTxPower; -} - -void LoRaMacChannelRemove( uint8_t id ) -{ if( ( LoRaMacState & MAC_TX_RUNNING ) == MAC_TX_RUNNING ) { - return; + return LORAMAC_STATUS_BUSY; } -#if ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) - if( id < 64 ) + + switch( mibSet->Type ) { - if( CountNbEnabled125kHzChannels( ChannelsMask ) <= 6 ) + case MIB_DEVICE_CLASS: + { + LoRaMacDeviceClass = mibSet->Param.Class; + switch( LoRaMacDeviceClass ) + { + case CLASS_A: + { + // Set the radio into sleep to setup a defined state + Radio.Sleep( ); + break; + } + case CLASS_B: + { + break; + } + case CLASS_C: + { + // Set the NodeAckRequested indicator to default + NodeAckRequested = false; + OnRxWindow2TimerEvent( ); + break; + } + } + break; + } + case MIB_NETWORK_JOINED: + { + IsLoRaMacNetworkJoined = mibSet->Param.IsNetworkJoined; + break; + } + case MIB_ADR: + { + AdrCtrlOn = mibSet->Param.AdrEnable; + break; + } + case MIB_NET_ID: + { + LoRaMacNetID = mibSet->Param.NetID; + break; + } + case MIB_DEV_ADDR: + { + LoRaMacDevAddr = mibSet->Param.DevAddr; + break; + } + case MIB_NWK_SKEY: { - return; + if( mibSet->Param.NwkSKey != NULL ) + { + memcpy1( LoRaMacNwkSKey, mibSet->Param.NwkSKey, + sizeof( LoRaMacNwkSKey ) ); + } + else + { + status = LORAMAC_STATUS_PARAMETER_INVALID; + } + break; + } + case MIB_APP_SKEY: + { + if( mibSet->Param.AppSKey != NULL ) + { + memcpy1( LoRaMacAppSKey, mibSet->Param.AppSKey, + sizeof( LoRaMacAppSKey ) ); + } + else + { + status = LORAMAC_STATUS_PARAMETER_INVALID; + } + break; + } + case MIB_PUBLIC_NETWORK: + { + SetPublicNetwork( mibSet->Param.EnablePublicNetwork ); + break; } - } + case MIB_REPEATER_SUPPORT: + { + RepeaterSupport = mibSet->Param.EnableRepeaterSupport; + break; + } + case MIB_RX2_CHANNEL: + { + Rx2Channel = mibSet->Param.Rx2Channel; + break; + } + case MIB_CHANNELS_MASK: + { + if( mibSet->Param.ChannelsMask ) + { +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + if( ( CountNbEnabled125kHzChannels( mibSet->Param.ChannelsMask ) < 6 ) && + ( CountNbEnabled125kHzChannels( mibSet->Param.ChannelsMask ) > 0 ) ) + { + status = LORAMAC_STATUS_PARAMETER_INVALID; + } + else + { + memcpy1( ( uint8_t* ) ChannelsMask, + ( uint8_t* ) mibSet->Param.ChannelsMask, sizeof( ChannelsMask ) ); + for ( uint8_t i = 0; i < sizeof( ChannelsMask ) / 2; i++ ) + { + ChannelsMaskRemaining[i] &= ChannelsMask[i]; + } + } #else - if( id < 3 ) - { - return; - } + memcpy1( ( uint8_t* ) ChannelsMask, + ( uint8_t* ) mibSet->Param.ChannelsMask, 2 ); #endif - - uint8_t index = 0; - index = id / 16; - - if( ( index > 4 ) || ( id >= LORA_MAX_NB_CHANNELS ) ) - { - return; + } + else + { + status = LORAMAC_STATUS_PARAMETER_INVALID; + } + break; + } + case MIB_CHANNELS_NB_REP: + { + if( ( mibSet->Param.ChannelNbRep >= 1 ) && + ( mibSet->Param.ChannelNbRep <= 15 ) ) + { + ChannelsNbRep = mibSet->Param.ChannelNbRep; + } + else + { + status = LORAMAC_STATUS_PARAMETER_INVALID; + } + break; + } + case MIB_MAX_RX_WINDOW_DURATION: + { + MaxRxWindow = mibSet->Param.MaxRxWindow; + break; + } + case MIB_RECEIVE_DELAY_1: + { + ReceiveDelay1 = mibSet->Param.ReceiveDelay1; + break; + } + case MIB_RECEIVE_DELAY_2: + { + ReceiveDelay2 = mibSet->Param.ReceiveDelay2; + break; + } + case MIB_JOIN_ACCEPT_DELAY_1: + { + JoinAcceptDelay1 = mibSet->Param.JoinAcceptDelay1; + break; + } + case MIB_JOIN_ACCEPT_DELAY_2: + { + JoinAcceptDelay2 = mibSet->Param.JoinAcceptDelay2; + break; + } + case MIB_CHANNELS_DATARATE: + { + if( ValueInRange( mibSet->Param.ChannelsDatarate, + LORAMAC_MIN_DATARATE, LORAMAC_MAX_DATARATE ) ) + { + ChannelsDatarate = mibSet->Param.ChannelsDatarate; + } + else + { + status = LORAMAC_STATUS_PARAMETER_INVALID; + } + break; + } + case MIB_CHANNELS_TX_POWER: + { + if( ValueInRange( mibSet->Param.ChannelsTxPower, + LORAMAC_MAX_TX_POWER, LORAMAC_MIN_TX_POWER ) ) + { +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + int8_t txPower = LimitTxPower( mibSet->Param.ChannelsTxPower ); + if( txPower == mibSet->Param.ChannelsTxPower ) + { + ChannelsTxPower = mibSet->Param.ChannelsTxPower; + } + else + { + status = LORAMAC_STATUS_PARAMETER_INVALID; + } +#else + ChannelsTxPower = mibSet->Param.ChannelsTxPower; +#endif + } + else + { + status = LORAMAC_STATUS_PARAMETER_INVALID; + } + break; + } + default: + status = LORAMAC_STATUS_SERVICE_UNKNOWN; + break; } - // Deactivate channel - ChannelsMask[index] &= ~( 1 << ( id % 16 ) ); - - return; + return status; } -/*! - * ============================================================================ - * = LoRaMac setup functions = - * ============================================================================ - */ -void LoRaMacSetDeviceClass( DeviceClass_t deviceClass ) -{ - LoRaMacDeviceClass = deviceClass; -} - -void LoRaMacSetPublicNetwork( bool enable ) +LoRaMacStatus_t LoRaMacChannelAdd( uint8_t id, ChannelParams_t params ) { - PublicNetwork = enable; - Radio.SetModem( MODEM_LORA ); - if( PublicNetwork == true ) - { - // Change LoRa modem SyncWord - Radio.Write( REG_LR_SYNCWORD, LORA_MAC_PUBLIC_SYNCWORD ); - } - else + if( id >= LORA_MAX_NB_CHANNELS ) { - // Change LoRa modem SyncWord - Radio.Write( REG_LR_SYNCWORD, LORA_MAC_PRIVATE_SYNCWORD ); + return LORAMAC_STATUS_PARAMETER_INVALID; } -} - -void LoRaMacSetChannel( uint8_t id, ChannelParams_t params ) -{ - params.Band = 0; - Channels[id] = params; - // Activate the newly created channel - if( id < 16 ) + if( ( LoRaMacState & MAC_TX_RUNNING ) == MAC_TX_RUNNING ) { - ChannelsMask[0] |= 1 << id; + return LORAMAC_STATUS_BUSY; } - else if( id < 32 ) - { - ChannelsMask[1] |= 1 << ( id - 16 ); - } - else if( id < 48 ) + if( ( params.DrRange.Fields.Min > params.DrRange.Fields.Max ) || + ( ValueInRange( params.DrRange.Fields.Min, LORAMAC_MIN_DATARATE, + LORAMAC_MAX_DATARATE ) == false ) || + ( ValueInRange( params.DrRange.Fields.Max, LORAMAC_MIN_DATARATE, + LORAMAC_MAX_DATARATE ) == false ) ) { - ChannelsMask[2] |= 1 << ( id - 32 ); - } - else if( id < 64 ) - { - ChannelsMask[3] |= 1 << ( id - 48 ); + return LORAMAC_STATUS_PARAMETER_INVALID; } - else if( id < 72 ) - { - ChannelsMask[4] |= 1 << ( id - 64 ); - } - else - { - // Don't activate the channel - } + + params.Band = 0; + +#if ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) + return LORAMAC_STATUS_PARAMETER_INVALID; +#else #if defined( USE_BAND_433 ) || defined( USE_BAND_780 ) - Channels[id].Band = 0; // 1% duty cycle on EU433 and CN780 bands + Channels[id] = params; + Channels[id].Band = 0; // No duty cycle on EU433 and CN470 bands #elif defined( USE_BAND_868 ) + Channels[id] = params; if( ( Channels[id].Frequency >= 865000000 ) && ( Channels[id].Frequency <= 868000000 ) ) { if( Channels[id].Band != BAND_G1_0 ) @@ -2653,126 +3115,304 @@ Channels[id].Frequency = 0; Channels[id].DrRange.Value = 0; } -#elif ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) - Channels[id].Band = 0; // No duty cycle on US915 band #else #error "Please define a frequency band in the compiler options." #endif // Check if it is a valid channel - if( Channels[id].Frequency == 0 ) + if( Channels[id].Frequency > 0 ) { - LoRaMacChannelRemove( id ); - } -} - -void LoRaMacSetRx2Channel( Rx2ChannelParams_t param ) -{ - Rx2Channel = param; -} - -void LoRaMacSetChannelsTxPower( int8_t txPower ) -{ - if( ( txPower >= LORAMAC_MAX_TX_POWER ) && - ( txPower <= LORAMAC_MIN_TX_POWER ) ) - { -#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - int8_t txPwr = LimitTxPower( txPower ); - if( txPwr == txPower ) + // Activate the newly created channel + if( id < 16 ) { - ChannelsTxPower = txPower; + ChannelsMask[0] |= 1 << id; } -#else - ChannelsTxPower = txPower; + } + + return LORAMAC_STATUS_OK; #endif - } -} - -void LoRaMacSetChannelsDatarate( int8_t datarate ) -{ - ChannelsDefaultDatarate = ChannelsDatarate = datarate; } -void LoRaMacSetChannelsMask( uint16_t *mask ) +LoRaMacStatus_t LoRaMacChannelRemove( uint8_t id ) { -#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) - if( ( CountNbEnabled125kHzChannels( mask ) < 6 ) && - ( CountNbEnabled125kHzChannels( mask ) > 0 ) ) + if( ( LoRaMacState & MAC_TX_RUNNING ) == MAC_TX_RUNNING ) { - + return LORAMAC_STATUS_BUSY; } - else +#if ( defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) ) + if( id < 64 ) { - LoRaMacMemCpy( (uint8_t* ) mask, - ( uint8_t* ) ChannelsMask, 10 ); + if( CountNbEnabled125kHzChannels( ChannelsMask ) <= 6 ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } } #else - if( ( mask[0] & 0x0007 ) != 0x0007 ) + if( id < 3 ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } +#endif + + if( DisableChannelInMask( id, ChannelsMask ) == false ) { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + + return LORAMAC_STATUS_OK; +} + +LoRaMacStatus_t LoRaMacMulticastChannelLink( MulticastParams_t *channelParam ) +{ + if( channelParam == NULL ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + if( ( LoRaMacState & MAC_TX_RUNNING ) == MAC_TX_RUNNING ) + { + return LORAMAC_STATUS_BUSY; + } + + // Reset downlink counter + channelParam->DownLinkCounter = 0; + + if( MulticastChannels == NULL ) + { + // New node is the fist element + MulticastChannels = channelParam; } else { - LoRaMacMemCpy( ( uint8_t* ) mask, - ( uint8_t* ) ChannelsMask, 2 ); + MulticastParams_t *cur = MulticastChannels; + + // Search the last node in the list + while( cur->Next != NULL ) + { + cur = cur->Next; + } + // This function always finds the last node + cur->Next = channelParam; } -#endif + + return LORAMAC_STATUS_OK; } -void LoRaMacSetChannelsNbRep( uint8_t nbRep ) +LoRaMacStatus_t LoRaMacMulticastChannelUnlink( MulticastParams_t *channelParam ) { - if( nbRep < 1 ) + if( channelParam == NULL ) { - nbRep = 1; + return LORAMAC_STATUS_PARAMETER_INVALID; } - if( nbRep > 15 ) + if( ( LoRaMacState & MAC_TX_RUNNING ) == MAC_TX_RUNNING ) + { + return LORAMAC_STATUS_BUSY; + } + + if( MulticastChannels != NULL ) { - nbRep = 15; + if( MulticastChannels == channelParam ) + { + // First element + MulticastChannels = channelParam->Next; + } + else + { + MulticastParams_t *cur = MulticastChannels; + + // Search the node in the list + while( cur->Next && cur->Next != channelParam ) + { + cur = cur->Next; + } + // If we found the node, remove it + if( cur->Next ) + { + cur->Next = channelParam->Next; + } + } + channelParam->Next = NULL; } - ChannelsNbRep = nbRep; + + return LORAMAC_STATUS_OK; } -void LoRaMacSetMaxRxWindow( uint32_t delay ) -{ - MaxRxWindow = delay; -} - -void LoRaMacSetReceiveDelay1( uint32_t delay ) -{ - ReceiveDelay1 = delay; -} - -void LoRaMacSetReceiveDelay2( uint32_t delay ) +LoRaMacStatus_t LoRaMacMlmeRequest( MlmeReq_t *mlmeRequest ) { - ReceiveDelay2 = delay; -} - -void LoRaMacSetJoinAcceptDelay1( uint32_t delay ) -{ - JoinAcceptDelay1 = delay; + LoRaMacStatus_t status = LORAMAC_STATUS_SERVICE_UNKNOWN; + LoRaMacHeader_t macHdr; + + if( mlmeRequest == NULL ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + if( ( LoRaMacState & MAC_TX_RUNNING ) == MAC_TX_RUNNING ) + { + return LORAMAC_STATUS_BUSY; + } + + memset1( ( uint8_t* ) &MlmeConfirm, 0, sizeof( MlmeConfirm ) ); + + MlmeConfirm.Status = LORAMAC_EVENT_INFO_STATUS_ERROR; + + switch( mlmeRequest->Type ) + { + case MLME_JOIN: + { + if( ( LoRaMacState & MAC_TX_DELAYED ) == MAC_TX_DELAYED ) + { + status = LORAMAC_STATUS_BUSY; + } + + MlmeConfirm.MlmeRequest = mlmeRequest->Type; + + if( ( mlmeRequest->Req.Join.DevEui == NULL ) || + ( mlmeRequest->Req.Join.AppEui == NULL ) || + ( mlmeRequest->Req.Join.AppKey == NULL ) ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + + LoRaMacFlags.Bits.MlmeReq = 1; + + LoRaMacDevEui = mlmeRequest->Req.Join.DevEui; + LoRaMacAppEui = mlmeRequest->Req.Join.AppEui; + LoRaMacAppKey = mlmeRequest->Req.Join.AppKey; + + macHdr.Value = 0; + macHdr.Bits.MType = FRAME_TYPE_JOIN_REQ; + + IsLoRaMacNetworkJoined = false; + +#if defined( USE_BAND_915 ) || defined( USE_BAND_915_HYBRID ) + static uint8_t drSwitch = 0; + + if( ( ++drSwitch & 0x01 ) == 0x01 ) + { + ChannelsDatarate = DR_0; + } + else + { + ChannelsDatarate = DR_4; + } +#endif + + status = Send( &macHdr, 0, NULL, 0 ); + break; + } + case MLME_LINK_CHECK: + { + LoRaMacFlags.Bits.MlmeReq = 1; + // LoRaMac will send this command piggy-pack + MlmeConfirm.MlmeRequest = mlmeRequest->Type; + + status = AddMacCommand( MOTE_MAC_LINK_CHECK_REQ, 0, 0 ); + break; + } + default: + break; + } + + if( status != LORAMAC_STATUS_OK ) + { + NodeAckRequested = false; + LoRaMacFlags.Bits.MlmeReq = 0; + } + + return status; } -void LoRaMacSetJoinAcceptDelay2( uint32_t delay ) -{ - JoinAcceptDelay2 = delay; -} - -uint32_t LoRaMacGetUpLinkCounter( void ) +LoRaMacStatus_t LoRaMacMcpsRequest( McpsReq_t *mcpsRequest ) { - return UpLinkCounter; -} - -uint32_t LoRaMacGetDownLinkCounter( void ) -{ - return DownLinkCounter; -} - -/*! - * ============================================================================ - * = LoRaMac test functions = - * ============================================================================ - */ -void LoRaMacTestSetDutyCycleOn( bool enable ) -{ - DutyCycleOn = enable; + LoRaMacStatus_t status = LORAMAC_STATUS_SERVICE_UNKNOWN; + LoRaMacHeader_t macHdr; + uint8_t fPort = 0; + void *fBuffer; + uint16_t fBufferSize; + int8_t datarate; + bool readyToSend = false; + + if( mcpsRequest == NULL ) + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + if( ( ( LoRaMacState & MAC_TX_RUNNING ) == MAC_TX_RUNNING ) || + ( ( LoRaMacState & MAC_TX_DELAYED ) == MAC_TX_DELAYED ) ) + { + return LORAMAC_STATUS_BUSY; + } + + macHdr.Value = 0; + memset1 ( ( uint8_t* ) &McpsConfirm, 0, sizeof( McpsConfirm ) ); + McpsConfirm.Status = LORAMAC_EVENT_INFO_STATUS_ERROR; + + switch( mcpsRequest->Type ) + { + case MCPS_UNCONFIRMED: + { + readyToSend = true; + AckTimeoutRetries = 1; + + macHdr.Bits.MType = FRAME_TYPE_DATA_UNCONFIRMED_UP; + fPort = mcpsRequest->Req.Unconfirmed.fPort; + fBuffer = mcpsRequest->Req.Unconfirmed.fBuffer; + fBufferSize = mcpsRequest->Req.Unconfirmed.fBufferSize; + datarate = mcpsRequest->Req.Unconfirmed.Datarate; + break; + } + case MCPS_CONFIRMED: + { + readyToSend = true; + AckTimeoutRetriesCounter = 1; + AckTimeoutRetries = mcpsRequest->Req.Confirmed.nbRetries; + + macHdr.Bits.MType = FRAME_TYPE_DATA_CONFIRMED_UP; + fPort = mcpsRequest->Req.Confirmed.fPort; + fBuffer = mcpsRequest->Req.Confirmed.fBuffer; + fBufferSize = mcpsRequest->Req.Confirmed.fBufferSize; + datarate = mcpsRequest->Req.Confirmed.Datarate; + break; + } + case MCPS_PROPRIETARY: + { + readyToSend = true; + AckTimeoutRetries = 1; + + macHdr.Bits.MType = FRAME_TYPE_PROPRIETARY; + fBuffer = mcpsRequest->Req.Proprietary.fBuffer; + fBufferSize = mcpsRequest->Req.Proprietary.fBufferSize; + datarate = mcpsRequest->Req.Proprietary.Datarate; + break; + } + default: + break; + } + + if( readyToSend == true ) + { + if( AdrCtrlOn == false ) + { + if( ValueInRange( datarate, LORAMAC_MIN_DATARATE, LORAMAC_MAX_DATARATE ) == true ) + { + ChannelsDatarate = datarate; + } + else + { + return LORAMAC_STATUS_PARAMETER_INVALID; + } + } + + status = Send( &macHdr, fPort, fBuffer, fBufferSize ); + if( status == LORAMAC_STATUS_OK ) + { + McpsConfirm.McpsRequest = mcpsRequest->Type; + LoRaMacFlags.Bits.McpsReq = 1; + } + else + { + NodeAckRequested = false; + } + } + + return status; } void LoRaMacTestRxWindowsOn( bool enable ) @@ -2780,8 +3420,13 @@ IsRxWindowsEnabled = enable; } -void LoRaMacTestSetMic( uint16_t upLinkCounter ) +void LoRaMacTestSetMic( uint16_t txPacketCounter ) { - UpLinkCounter = upLinkCounter; + UpLinkCounter = txPacketCounter; IsUpLinkCounterFixed = true; } + +void LoRaMacTestSetDutyCycleOn( bool enable ) +{ + DutyCycleOn = enable; +}