/*! | |
* \file RegionEU868.c | |
* | |
* \brief Region implementation for EU868 | |
* | |
* \copyright Revised BSD License, see section \ref LICENSE. | |
* | |
* \code | |
* ______ _ | |
* / _____) _ | | | |
* ( (____ _____ ____ _| |_ _____ ____| |__ | |
* \____ \| ___ | (_ _) ___ |/ ___) _ \ | |
* _____) ) ____| | | || |_| ____( (___| | | | | |
* (______/|_____)_|_|_| \__)_____)\____)_| |_| | |
* (C)2013-2017 Semtech | |
* | |
* ___ _____ _ ___ _ _____ ___ ___ ___ ___ | |
* / __|_ _/_\ / __| |/ / __/ _ \| _ \/ __| __| | |
* \__ \ | |/ _ \ (__| ' <| _| (_) | / (__| _| | |
* |___/ |_/_/ \_\___|_|\_\_| \___/|_|_\\___|___| | |
* embedded.connectivity.solutions=============== | |
* | |
* \endcode | |
* | |
* \author Miguel Luis ( Semtech ) | |
* | |
* \author Gregory Cristian ( Semtech ) | |
* | |
* \author Daniel Jaeckle ( STACKFORCE ) | |
*/ | |
#include "node/utilities.h" | |
#include "RegionCommon.h" | |
#include "RegionEU868.h" | |
// Definitions | |
#define CHANNELS_MASK_SIZE 1 | |
// Global attributes | |
/*! | |
* LoRaMAC channels | |
*/ | |
static ChannelParams_t Channels[EU868_MAX_NB_CHANNELS]; | |
/*! | |
* LoRaMac bands | |
*/ | |
static Band_t Bands[EU868_MAX_NB_BANDS] = | |
{ | |
EU868_BAND0, | |
EU868_BAND1, | |
EU868_BAND2, | |
EU868_BAND3, | |
EU868_BAND4, | |
}; | |
/*! | |
* LoRaMac channels mask | |
*/ | |
static uint16_t ChannelsMask[CHANNELS_MASK_SIZE]; | |
/*! | |
* LoRaMac channels default mask | |
*/ | |
static uint16_t ChannelsDefaultMask[CHANNELS_MASK_SIZE]; | |
// Static functions | |
static int8_t GetNextLowerTxDr( int8_t dr, int8_t minDr ) | |
{ | |
uint8_t nextLowerDr = 0; | |
if( dr == minDr ) | |
{ | |
nextLowerDr = minDr; | |
} | |
else | |
{ | |
nextLowerDr = dr - 1; | |
} | |
return nextLowerDr; | |
} | |
static uint32_t GetBandwidth( uint32_t drIndex ) | |
{ | |
switch( BandwidthsEU868[drIndex] ) | |
{ | |
default: | |
case 125000: | |
return 0; | |
case 250000: | |
return 1; | |
case 500000: | |
return 2; | |
} | |
} | |
static int8_t LimitTxPower( int8_t txPower, int8_t maxBandTxPower, int8_t datarate, uint16_t* channelsMask ) | |
{ | |
int8_t txPowerResult = txPower; | |
// Limit tx power to the band max | |
txPowerResult = MAX( txPower, maxBandTxPower ); | |
return txPowerResult; | |
} | |
static bool VerifyTxFreq( uint32_t freq, uint8_t *band ) | |
{ | |
// Check radio driver support | |
if( Radio.CheckRfFrequency( freq ) == false ) | |
{ | |
return false; | |
} | |
// Check frequency bands | |
if( ( freq >= 863000000 ) && ( freq < 865000000 ) ) | |
{ | |
*band = 2; | |
} | |
else if( ( freq >= 865000000 ) && ( freq <= 868000000 ) ) | |
{ | |
*band = 0; | |
} | |
else if( ( freq > 868000000 ) && ( freq <= 868600000 ) ) | |
{ | |
*band = 1; | |
} | |
else if( ( freq >= 868700000 ) && ( freq <= 869200000 ) ) | |
{ | |
*band = 2; | |
} | |
else if( ( freq >= 869400000 ) && ( freq <= 869650000 ) ) | |
{ | |
*band = 3; | |
} | |
else if( ( freq >= 869700000 ) && ( freq <= 870000000 ) ) | |
{ | |
*band = 4; | |
} | |
else | |
{ | |
return false; | |
} | |
return true; | |
} | |
static uint8_t CountNbOfEnabledChannels( bool joined, uint8_t datarate, uint16_t* channelsMask, ChannelParams_t* channels, Band_t* bands, uint8_t* enabledChannels, uint8_t* delayTx ) | |
{ | |
uint8_t nbEnabledChannels = 0; | |
uint8_t delayTransmission = 0; | |
for( uint8_t i = 0, k = 0; i < EU868_MAX_NB_CHANNELS; i += 16, k++ ) | |
{ | |
for( uint8_t j = 0; j < 16; j++ ) | |
{ | |
if( ( channelsMask[k] & ( 1 << j ) ) != 0 ) | |
{ | |
if( channels[i + j].Frequency == 0 ) | |
{ // Check if the channel is enabled | |
continue; | |
} | |
if( joined == false ) | |
{ | |
if( ( EU868_JOIN_CHANNELS & ( 1 << j ) ) == 0 ) | |
{ | |
continue; | |
} | |
} | |
if( RegionCommonValueInRange( datarate, channels[i + j].DrRange.Fields.Min, | |
channels[i + j].DrRange.Fields.Max ) == false ) | |
{ // Check if the current channel selection supports the given datarate | |
continue; | |
} | |
if( bands[channels[i + j].Band].TimeOff > 0 ) | |
{ // Check if the band is available for transmission | |
delayTransmission++; | |
continue; | |
} | |
enabledChannels[nbEnabledChannels++] = i + j; | |
} | |
} | |
} | |
*delayTx = delayTransmission; | |
return nbEnabledChannels; | |
} | |
PhyParam_t RegionEU868GetPhyParam( GetPhyParams_t* getPhy ) | |
{ | |
PhyParam_t phyParam = { 0 }; | |
switch( getPhy->Attribute ) | |
{ | |
case PHY_MIN_RX_DR: | |
{ | |
phyParam.Value = EU868_RX_MIN_DATARATE; | |
break; | |
} | |
case PHY_MIN_TX_DR: | |
{ | |
phyParam.Value = EU868_TX_MIN_DATARATE; | |
break; | |
} | |
case PHY_DEF_TX_DR: | |
{ | |
phyParam.Value = EU868_DEFAULT_DATARATE; | |
break; | |
} | |
case PHY_NEXT_LOWER_TX_DR: | |
{ | |
phyParam.Value = GetNextLowerTxDr( getPhy->Datarate, EU868_TX_MIN_DATARATE ); | |
break; | |
} | |
case PHY_DEF_TX_POWER: | |
{ | |
phyParam.Value = EU868_DEFAULT_TX_POWER; | |
break; | |
} | |
case PHY_MAX_PAYLOAD: | |
{ | |
phyParam.Value = MaxPayloadOfDatarateEU868[getPhy->Datarate]; | |
break; | |
} | |
case PHY_MAX_PAYLOAD_REPEATER: | |
{ | |
phyParam.Value = MaxPayloadOfDatarateRepeaterEU868[getPhy->Datarate]; | |
break; | |
} | |
case PHY_DUTY_CYCLE: | |
{ | |
phyParam.Value = EU868_DUTY_CYCLE_ENABLED; | |
break; | |
} | |
case PHY_MAX_RX_WINDOW: | |
{ | |
phyParam.Value = EU868_MAX_RX_WINDOW; | |
break; | |
} | |
case PHY_RECEIVE_DELAY1: | |
{ | |
phyParam.Value = EU868_RECEIVE_DELAY1; | |
break; | |
} | |
case PHY_RECEIVE_DELAY2: | |
{ | |
phyParam.Value = EU868_RECEIVE_DELAY2; | |
break; | |
} | |
case PHY_JOIN_ACCEPT_DELAY1: | |
{ | |
phyParam.Value = EU868_JOIN_ACCEPT_DELAY1; | |
break; | |
} | |
case PHY_JOIN_ACCEPT_DELAY2: | |
{ | |
phyParam.Value = EU868_JOIN_ACCEPT_DELAY2; | |
break; | |
} | |
case PHY_MAX_FCNT_GAP: | |
{ | |
phyParam.Value = EU868_MAX_FCNT_GAP; | |
break; | |
} | |
case PHY_ACK_TIMEOUT: | |
{ | |
phyParam.Value = ( EU868_ACKTIMEOUT + randr( -EU868_ACK_TIMEOUT_RND, EU868_ACK_TIMEOUT_RND ) ); | |
break; | |
} | |
case PHY_DEF_DR1_OFFSET: | |
{ | |
phyParam.Value = EU868_DEFAULT_RX1_DR_OFFSET; | |
break; | |
} | |
case PHY_DEF_RX2_FREQUENCY: | |
{ | |
phyParam.Value = EU868_RX_WND_2_FREQ; | |
break; | |
} | |
case PHY_DEF_RX2_DR: | |
{ | |
phyParam.Value = EU868_RX_WND_2_DR; | |
break; | |
} | |
case PHY_CHANNELS_MASK: | |
{ | |
phyParam.ChannelsMask = ChannelsMask; | |
break; | |
} | |
case PHY_CHANNELS_DEFAULT_MASK: | |
{ | |
phyParam.ChannelsMask = ChannelsDefaultMask; | |
break; | |
} | |
case PHY_MAX_NB_CHANNELS: | |
{ | |
phyParam.Value = EU868_MAX_NB_CHANNELS; | |
break; | |
} | |
case PHY_CHANNELS: | |
{ | |
phyParam.Channels = Channels; | |
break; | |
} | |
case PHY_DEF_UPLINK_DWELL_TIME: | |
case PHY_DEF_DOWNLINK_DWELL_TIME: | |
{ | |
phyParam.Value = 0; | |
break; | |
} | |
case PHY_DEF_MAX_EIRP: | |
{ | |
phyParam.fValue = EU868_DEFAULT_MAX_EIRP; | |
break; | |
} | |
case PHY_DEF_ANTENNA_GAIN: | |
{ | |
phyParam.fValue = EU868_DEFAULT_ANTENNA_GAIN; | |
break; | |
} | |
default: | |
{ | |
break; | |
} | |
} | |
return phyParam; | |
} | |
void RegionEU868SetBandTxDone( SetBandTxDoneParams_t* txDone ) | |
{ | |
RegionCommonSetBandTxDone( txDone->Joined, &Bands[Channels[txDone->Channel].Band], txDone->LastTxDoneTime ); | |
} | |
void RegionEU868InitDefaults( InitType_t type ) | |
{ | |
switch( type ) | |
{ | |
case INIT_TYPE_INIT: | |
{ | |
// Channels | |
Channels[0] = ( ChannelParams_t ) EU868_LC1; | |
Channels[1] = ( ChannelParams_t ) EU868_LC2; | |
Channels[2] = ( ChannelParams_t ) EU868_LC3; | |
// Initialize the channels default mask | |
ChannelsDefaultMask[0] = LC( 1 ) + LC( 2 ) + LC( 3 ); | |
// Update the channels mask | |
RegionCommonChanMaskCopy( ChannelsMask, ChannelsDefaultMask, 1 ); | |
break; | |
} | |
case INIT_TYPE_RESTORE: | |
{ | |
// Restore channels default mask | |
ChannelsMask[0] |= ChannelsDefaultMask[0]; | |
break; | |
} | |
case INIT_TYPE_APP_DEFAULTS: | |
{ | |
// Update the channels mask defaults | |
RegionCommonChanMaskCopy( ChannelsMask, ChannelsDefaultMask, 1 ); | |
break; | |
} | |
default: | |
{ | |
break; | |
} | |
} | |
} | |
bool RegionEU868Verify( VerifyParams_t* verify, PhyAttribute_t phyAttribute ) | |
{ | |
switch( phyAttribute ) | |
{ | |
case PHY_TX_DR: | |
{ | |
return RegionCommonValueInRange( verify->DatarateParams.Datarate, EU868_TX_MIN_DATARATE, EU868_TX_MAX_DATARATE ); | |
} | |
case PHY_DEF_TX_DR: | |
{ | |
return RegionCommonValueInRange( verify->DatarateParams.Datarate, DR_0, DR_5 ); | |
} | |
case PHY_RX_DR: | |
{ | |
return RegionCommonValueInRange( verify->DatarateParams.Datarate, EU868_RX_MIN_DATARATE, EU868_RX_MAX_DATARATE ); | |
} | |
case PHY_DEF_TX_POWER: | |
case PHY_TX_POWER: | |
{ | |
// Remark: switched min and max! | |
return RegionCommonValueInRange( verify->TxPower, EU868_MAX_TX_POWER, EU868_MIN_TX_POWER ); | |
} | |
case PHY_DUTY_CYCLE: | |
{ | |
return EU868_DUTY_CYCLE_ENABLED; | |
} | |
default: | |
return false; | |
} | |
} | |
void RegionEU868ApplyCFList( ApplyCFListParams_t* applyCFList ) | |
{ | |
ChannelParams_t newChannel; | |
ChannelAddParams_t channelAdd; | |
ChannelRemoveParams_t channelRemove; | |
// Setup default datarate range | |
newChannel.DrRange.Value = ( DR_5 << 4 ) | DR_0; | |
// Size of the optional CF list | |
if( applyCFList->Size != 16 ) | |
{ | |
return; | |
} | |
// Last byte is RFU, don't take it into account | |
for( uint8_t i = 0, chanIdx = EU868_NUMB_DEFAULT_CHANNELS; chanIdx < EU868_MAX_NB_CHANNELS; i+=3, chanIdx++ ) | |
{ | |
if( chanIdx < ( EU868_NUMB_CHANNELS_CF_LIST + EU868_NUMB_DEFAULT_CHANNELS ) ) | |
{ | |
// Channel frequency | |
newChannel.Frequency = (uint32_t) applyCFList->Payload[i]; | |
newChannel.Frequency |= ( (uint32_t) applyCFList->Payload[i + 1] << 8 ); | |
newChannel.Frequency |= ( (uint32_t) applyCFList->Payload[i + 2] << 16 ); | |
newChannel.Frequency *= 100; | |
// Initialize alternative frequency to 0 | |
newChannel.Rx1Frequency = 0; | |
} | |
else | |
{ | |
newChannel.Frequency = 0; | |
newChannel.DrRange.Value = 0; | |
newChannel.Rx1Frequency = 0; | |
} | |
if( newChannel.Frequency != 0 ) | |
{ | |
channelAdd.NewChannel = &newChannel; | |
channelAdd.ChannelId = chanIdx; | |
// Try to add all channels | |
RegionEU868ChannelAdd( &channelAdd ); | |
} | |
else | |
{ | |
channelRemove.ChannelId = chanIdx; | |
RegionEU868ChannelsRemove( &channelRemove ); | |
} | |
} | |
} | |
bool RegionEU868ChanMaskSet( ChanMaskSetParams_t* chanMaskSet ) | |
{ | |
switch( chanMaskSet->ChannelsMaskType ) | |
{ | |
case CHANNELS_MASK: | |
{ | |
RegionCommonChanMaskCopy( ChannelsMask, chanMaskSet->ChannelsMaskIn, 1 ); | |
break; | |
} | |
case CHANNELS_DEFAULT_MASK: | |
{ | |
RegionCommonChanMaskCopy( ChannelsDefaultMask, chanMaskSet->ChannelsMaskIn, 1 ); | |
break; | |
} | |
default: | |
return false; | |
} | |
return true; | |
} | |
bool RegionEU868AdrNext( AdrNextParams_t* adrNext, int8_t* drOut, int8_t* txPowOut, uint32_t* adrAckCounter ) | |
{ | |
bool adrAckReq = false; | |
int8_t datarate = adrNext->Datarate; | |
int8_t txPower = adrNext->TxPower; | |
GetPhyParams_t getPhy; | |
PhyParam_t phyParam; | |
// Report back the adr ack counter | |
*adrAckCounter = adrNext->AdrAckCounter; | |
if( adrNext->AdrEnabled == true ) | |
{ | |
if( datarate == EU868_TX_MIN_DATARATE ) | |
{ | |
*adrAckCounter = 0; | |
adrAckReq = false; | |
} | |
else | |
{ | |
if( adrNext->AdrAckCounter >= EU868_ADR_ACK_LIMIT ) | |
{ | |
adrAckReq = true; | |
txPower = EU868_MAX_TX_POWER; | |
} | |
else | |
{ | |
adrAckReq = false; | |
} | |
if( adrNext->AdrAckCounter >= ( EU868_ADR_ACK_LIMIT + EU868_ADR_ACK_DELAY ) ) | |
{ | |
if( ( adrNext->AdrAckCounter % EU868_ADR_ACK_DELAY ) == 1 ) | |
{ | |
// Decrease the datarate | |
getPhy.Attribute = PHY_NEXT_LOWER_TX_DR; | |
getPhy.Datarate = datarate; | |
getPhy.UplinkDwellTime = adrNext->UplinkDwellTime; | |
phyParam = RegionEU868GetPhyParam( &getPhy ); | |
datarate = phyParam.Value; | |
if( datarate == EU868_TX_MIN_DATARATE ) | |
{ | |
// We must set adrAckReq to false as soon as we reach the lowest datarate | |
adrAckReq = false; | |
if( adrNext->UpdateChanMask == true ) | |
{ | |
// Re-enable default channels | |
ChannelsMask[0] |= LC( 1 ) + LC( 2 ) + LC( 3 ); | |
} | |
} | |
} | |
} | |
} | |
} | |
*drOut = datarate; | |
*txPowOut = txPower; | |
return adrAckReq; | |
} | |
void RegionEU868ComputeRxWindowParameters( int8_t datarate, uint8_t minRxSymbols, uint32_t rxError, RxConfigParams_t *rxConfigParams ) | |
{ | |
double tSymbol = 0.0; | |
// Get the datarate, perform a boundary check | |
rxConfigParams->Datarate = MIN( datarate, EU868_RX_MAX_DATARATE ); | |
rxConfigParams->Bandwidth = GetBandwidth( rxConfigParams->Datarate ); | |
if( rxConfigParams->Datarate == DR_7 ) | |
{ // FSK | |
tSymbol = RegionCommonComputeSymbolTimeFsk( DataratesEU868[rxConfigParams->Datarate] ); | |
} | |
else | |
{ // LoRa | |
tSymbol = RegionCommonComputeSymbolTimeLoRa( DataratesEU868[rxConfigParams->Datarate], BandwidthsEU868[rxConfigParams->Datarate] ); | |
} | |
rxConfigParams->tsymbol = tSymbol; | |
RegionCommonComputeRxWindowParameters( tSymbol, minRxSymbols, rxError, Radio.GetWakeupTime( ), &rxConfigParams->WindowTimeout, &rxConfigParams->WindowOffset ); | |
} | |
bool RegionEU868RxConfig( RxConfigParams_t* rxConfig, int8_t* datarate ) | |
{ | |
RadioModems_t modem; | |
int8_t dr = rxConfig->Datarate; | |
uint8_t maxPayload = 0; | |
int8_t phyDr = 0; | |
uint32_t frequency = rxConfig->Frequency; | |
if( Radio.GetStatus( ) != RF_IDLE ) | |
{ | |
return false; | |
} | |
if( rxConfig->RxSlot == RX_SLOT_WIN_1 ) | |
{ | |
// Apply window 1 frequency | |
frequency = Channels[rxConfig->Channel].Frequency; | |
// Apply the alternative RX 1 window frequency, if it is available | |
if( Channels[rxConfig->Channel].Rx1Frequency != 0 ) | |
{ | |
frequency = Channels[rxConfig->Channel].Rx1Frequency; | |
} | |
} | |
// Read the physical datarate from the datarates table | |
phyDr = DataratesEU868[dr]; | |
lora_node_log(LORA_NODE_LOG_RX_CFG, rxConfig->Bandwidth, | |
((uint16_t)dr << 16) | phyDr, frequency); | |
Radio.SetChannel( frequency ); | |
// Radio configuration | |
if( dr == DR_7 ) | |
{ | |
modem = MODEM_FSK; | |
Radio.SetRxConfig( modem, 50000, phyDr * 1000, 0, 83333, 5, rxConfig->WindowTimeout, false, 0, true, 0, 0, false, rxConfig->RxContinuous ); | |
} | |
else | |
{ | |
modem = MODEM_LORA; | |
Radio.SetRxConfig( modem, rxConfig->Bandwidth, phyDr, 1, 0, 8, rxConfig->WindowTimeout, false, 0, false, 0, 0, true, rxConfig->RxContinuous ); | |
} | |
if( rxConfig->RepeaterSupport == true ) | |
{ | |
maxPayload = MaxPayloadOfDatarateRepeaterEU868[dr]; | |
} | |
else | |
{ | |
maxPayload = MaxPayloadOfDatarateEU868[dr]; | |
} | |
Radio.SetMaxPayloadLength( modem, maxPayload + LORA_MAC_FRMPAYLOAD_OVERHEAD ); | |
*datarate = (uint8_t) dr; | |
return true; | |
} | |
bool RegionEU868TxConfig( TxConfigParams_t* txConfig, int8_t* txPower, TimerTime_t* txTimeOnAir ) | |
{ | |
RadioModems_t modem; | |
int8_t phyDr = DataratesEU868[txConfig->Datarate]; | |
int8_t txPowerLimited = LimitTxPower( txConfig->TxPower, Bands[Channels[txConfig->Channel].Band].TxMaxPower, txConfig->Datarate, ChannelsMask ); | |
uint32_t bandwidth = GetBandwidth( txConfig->Datarate ); | |
int8_t phyTxPower = 0; | |
// Calculate physical TX power | |
phyTxPower = RegionCommonComputeTxPower( txPowerLimited, txConfig->MaxEirp, txConfig->AntennaGain ); | |
// Setup the radio frequency | |
Radio.SetChannel( Channels[txConfig->Channel].Frequency ); | |
if( txConfig->Datarate == DR_7 ) | |
{ // High Speed FSK channel | |
modem = MODEM_FSK; | |
Radio.SetTxConfig( modem, phyTxPower, 25000, bandwidth, phyDr * 1000, 0, 5, false, true, 0, 0, false, 3000 ); | |
} | |
else | |
{ | |
modem = MODEM_LORA; | |
Radio.SetTxConfig( modem, phyTxPower, 0, bandwidth, phyDr, 1, 8, false, true, 0, 0, false, 3000 ); | |
} | |
// Setup maximum payload lenght of the radio driver | |
Radio.SetMaxPayloadLength( modem, txConfig->PktLen ); | |
// Get the time-on-air of the next tx frame | |
*txTimeOnAir = Radio.TimeOnAir( modem, txConfig->PktLen ); | |
*txPower = txPowerLimited; | |
lora_node_log(LORA_NODE_LOG_TX_SETUP, phyTxPower, | |
((uint16_t)phyDr << 8) | bandwidth, | |
Channels[txConfig->Channel].Frequency); | |
return true; | |
} | |
uint8_t RegionEU868LinkAdrReq( LinkAdrReqParams_t* linkAdrReq, int8_t* drOut, int8_t* txPowOut, uint8_t* nbRepOut, uint8_t* nbBytesParsed ) | |
{ | |
uint8_t status = 0x07; | |
RegionCommonLinkAdrParams_t linkAdrParams; | |
uint8_t nextIndex = 0; | |
uint8_t bytesProcessed = 0; | |
uint16_t chMask = 0; | |
GetPhyParams_t getPhy; | |
PhyParam_t phyParam; | |
RegionCommonLinkAdrReqVerifyParams_t linkAdrVerifyParams; | |
while( bytesProcessed < linkAdrReq->PayloadSize ) | |
{ | |
// Get ADR request parameters | |
nextIndex = RegionCommonParseLinkAdrReq( &( linkAdrReq->Payload[bytesProcessed] ), &linkAdrParams ); | |
if( nextIndex == 0 ) | |
break; // break loop, since no more request has been found | |
// Update bytes processed | |
bytesProcessed += nextIndex; | |
// Revert status, as we only check the last ADR request for the channel mask KO | |
status = 0x07; | |
// Setup temporary channels mask | |
chMask = linkAdrParams.ChMask; | |
// Verify channels mask | |
if( ( linkAdrParams.ChMaskCtrl == 0 ) && ( chMask == 0 ) ) | |
{ | |
status &= 0xFE; // Channel mask KO | |
} | |
else if( ( ( linkAdrParams.ChMaskCtrl >= 1 ) && ( linkAdrParams.ChMaskCtrl <= 5 )) || | |
( linkAdrParams.ChMaskCtrl >= 7 ) ) | |
{ | |
// RFU | |
status &= 0xFE; // Channel mask KO | |
} | |
else | |
{ | |
for( uint8_t i = 0; i < EU868_MAX_NB_CHANNELS; i++ ) | |
{ | |
if( linkAdrParams.ChMaskCtrl == 6 ) | |
{ | |
if( Channels[i].Frequency != 0 ) | |
{ | |
chMask |= 1 << i; | |
} | |
} | |
else | |
{ | |
if( ( ( chMask & ( 1 << i ) ) != 0 ) && | |
( Channels[i].Frequency == 0 ) ) | |
{// Trying to enable an undefined channel | |
status &= 0xFE; // Channel mask KO | |
} | |
} | |
} | |
} | |
} | |
// Get the minimum possible datarate | |
getPhy.Attribute = PHY_MIN_TX_DR; | |
getPhy.UplinkDwellTime = linkAdrReq->UplinkDwellTime; | |
phyParam = RegionEU868GetPhyParam( &getPhy ); | |
linkAdrVerifyParams.Status = status; | |
linkAdrVerifyParams.AdrEnabled = linkAdrReq->AdrEnabled; | |
linkAdrVerifyParams.Datarate = linkAdrParams.Datarate; | |
linkAdrVerifyParams.TxPower = linkAdrParams.TxPower; | |
linkAdrVerifyParams.NbRep = linkAdrParams.NbRep; | |
linkAdrVerifyParams.CurrentDatarate = linkAdrReq->CurrentDatarate; | |
linkAdrVerifyParams.CurrentTxPower = linkAdrReq->CurrentTxPower; | |
linkAdrVerifyParams.CurrentNbRep = linkAdrReq->CurrentNbRep; | |
linkAdrVerifyParams.NbChannels = EU868_MAX_NB_CHANNELS; | |
linkAdrVerifyParams.ChannelsMask = &chMask; | |
linkAdrVerifyParams.MinDatarate = ( int8_t )phyParam.Value; | |
linkAdrVerifyParams.MaxDatarate = EU868_TX_MAX_DATARATE; | |
linkAdrVerifyParams.Channels = Channels; | |
linkAdrVerifyParams.MinTxPower = EU868_MIN_TX_POWER; | |
linkAdrVerifyParams.MaxTxPower = EU868_MAX_TX_POWER; | |
// Verify the parameters and update, if necessary | |
status = RegionCommonLinkAdrReqVerifyParams( &linkAdrVerifyParams, &linkAdrParams.Datarate, &linkAdrParams.TxPower, &linkAdrParams.NbRep ); | |
// Update channelsMask if everything is correct | |
if( status == 0x07 ) | |
{ | |
// Set the channels mask to a default value | |
memset1( ( uint8_t* )ChannelsMask, 0, sizeof( ChannelsMask ) ); | |
// Update the channels mask | |
ChannelsMask[0] = chMask; | |
} | |
// Update status variables | |
*drOut = linkAdrParams.Datarate; | |
*txPowOut = linkAdrParams.TxPower; | |
*nbRepOut = linkAdrParams.NbRep; | |
*nbBytesParsed = bytesProcessed; | |
return status; | |
} | |
uint8_t RegionEU868RxParamSetupReq( RxParamSetupReqParams_t* rxParamSetupReq ) | |
{ | |
uint8_t status = 0x07; | |
// Verify radio frequency | |
if( Radio.CheckRfFrequency( rxParamSetupReq->Frequency ) == false ) | |
{ | |
status &= 0xFE; // Channel frequency KO | |
} | |
// Verify datarate | |
if( RegionCommonValueInRange( rxParamSetupReq->Datarate, EU868_RX_MIN_DATARATE, EU868_RX_MAX_DATARATE ) == false ) | |
{ | |
status &= 0xFD; // Datarate KO | |
} | |
// Verify datarate offset | |
if( RegionCommonValueInRange( rxParamSetupReq->DrOffset, EU868_MIN_RX1_DR_OFFSET, EU868_MAX_RX1_DR_OFFSET ) == false ) | |
{ | |
status &= 0xFB; // Rx1DrOffset range KO | |
} | |
return status; | |
} | |
uint8_t RegionEU868NewChannelReq( NewChannelReqParams_t* newChannelReq ) | |
{ | |
uint8_t status = 0x03; | |
ChannelAddParams_t channelAdd; | |
ChannelRemoveParams_t channelRemove; | |
if( newChannelReq->NewChannel->Frequency == 0 ) | |
{ | |
channelRemove.ChannelId = newChannelReq->ChannelId; | |
// Remove | |
if( RegionEU868ChannelsRemove( &channelRemove ) == false ) | |
{ | |
status &= 0xFC; | |
} | |
} | |
else | |
{ | |
channelAdd.NewChannel = newChannelReq->NewChannel; | |
channelAdd.ChannelId = newChannelReq->ChannelId; | |
switch( RegionEU868ChannelAdd( &channelAdd ) ) | |
{ | |
case LORAMAC_STATUS_OK: | |
{ | |
break; | |
} | |
case LORAMAC_STATUS_FREQUENCY_INVALID: | |
{ | |
status &= 0xFE; | |
break; | |
} | |
case LORAMAC_STATUS_DATARATE_INVALID: | |
{ | |
status &= 0xFD; | |
break; | |
} | |
case LORAMAC_STATUS_FREQ_AND_DR_INVALID: | |
{ | |
status &= 0xFC; | |
break; | |
} | |
default: | |
{ | |
status &= 0xFC; | |
break; | |
} | |
} | |
} | |
return status; | |
} | |
int8_t RegionEU868TxParamSetupReq( TxParamSetupReqParams_t* txParamSetupReq ) | |
{ | |
return -1; | |
} | |
uint8_t RegionEU868DlChannelReq( DlChannelReqParams_t* dlChannelReq ) | |
{ | |
uint8_t status = 0x03; | |
uint8_t band = 0; | |
// Verify if the frequency is supported | |
if( VerifyTxFreq( dlChannelReq->Rx1Frequency, &band ) == false ) | |
{ | |
status &= 0xFE; | |
} | |
// Verify if an uplink frequency exists | |
if( Channels[dlChannelReq->ChannelId].Frequency == 0 ) | |
{ | |
status &= 0xFD; | |
} | |
// Apply Rx1 frequency, if the status is OK | |
if( status == 0x03 ) | |
{ | |
Channels[dlChannelReq->ChannelId].Rx1Frequency = dlChannelReq->Rx1Frequency; | |
} | |
return status; | |
} | |
int8_t RegionEU868AlternateDr( int8_t currentDr ) | |
{ | |
return currentDr; | |
} | |
void RegionEU868CalcBackOff( CalcBackOffParams_t* calcBackOff ) | |
{ | |
RegionCommonCalcBackOffParams_t calcBackOffParams; | |
calcBackOffParams.Channels = Channels; | |
calcBackOffParams.Bands = Bands; | |
calcBackOffParams.LastTxIsJoinRequest = calcBackOff->LastTxIsJoinRequest; | |
calcBackOffParams.Joined = calcBackOff->Joined; | |
calcBackOffParams.DutyCycleEnabled = calcBackOff->DutyCycleEnabled; | |
calcBackOffParams.Channel = calcBackOff->Channel; | |
calcBackOffParams.ElapsedTime = calcBackOff->ElapsedTime; | |
calcBackOffParams.TxTimeOnAir = calcBackOff->TxTimeOnAir; | |
RegionCommonCalcBackOff( &calcBackOffParams ); | |
} | |
LoRaMacStatus_t RegionEU868NextChannel( NextChanParams_t* nextChanParams, uint8_t* channel, TimerTime_t* time, TimerTime_t* aggregatedTimeOff ) | |
{ | |
uint8_t nbEnabledChannels = 0; | |
uint8_t delayTx = 0; | |
uint8_t enabledChannels[EU868_MAX_NB_CHANNELS] = { 0 }; | |
TimerTime_t nextTxDelay = 0; | |
if( RegionCommonCountChannels( ChannelsMask, 0, 1 ) == 0 ) | |
{ // Reactivate default channels | |
ChannelsMask[0] |= LC( 1 ) + LC( 2 ) + LC( 3 ); | |
} | |
if( nextChanParams->AggrTimeOff <= TimerGetElapsedTime( nextChanParams->LastAggrTx ) ) | |
{ | |
// Reset Aggregated time off | |
*aggregatedTimeOff = 0; | |
// Update bands Time OFF | |
nextTxDelay = RegionCommonUpdateBandTimeOff( nextChanParams->Joined, nextChanParams->DutyCycleEnabled, Bands, EU868_MAX_NB_BANDS ); | |
// Search how many channels are enabled | |
nbEnabledChannels = CountNbOfEnabledChannels( nextChanParams->Joined, nextChanParams->Datarate, | |
ChannelsMask, Channels, | |
Bands, enabledChannels, &delayTx ); | |
} | |
else | |
{ | |
delayTx++; | |
nextTxDelay = nextChanParams->AggrTimeOff - TimerGetElapsedTime( nextChanParams->LastAggrTx ); | |
} | |
if( nbEnabledChannels > 0 ) | |
{ | |
// We found a valid channel | |
*channel = enabledChannels[randr( 0, nbEnabledChannels - 1 )]; | |
*time = 0; | |
return LORAMAC_STATUS_OK; | |
} | |
else | |
{ | |
if( delayTx > 0 ) | |
{ | |
// Delay transmission due to AggregatedTimeOff or to a band time off | |
*time = nextTxDelay; | |
return LORAMAC_STATUS_DUTYCYCLE_RESTRICTED; | |
} | |
// Datarate not supported by any channel, restore defaults | |
ChannelsMask[0] |= LC( 1 ) + LC( 2 ) + LC( 3 ); | |
*time = 0; | |
return LORAMAC_STATUS_NO_CHANNEL_FOUND; | |
} | |
} | |
LoRaMacStatus_t RegionEU868ChannelAdd( ChannelAddParams_t* channelAdd ) | |
{ | |
uint8_t band = 0; | |
bool drInvalid = false; | |
bool freqInvalid = false; | |
uint8_t id = channelAdd->ChannelId; | |
if( id >= EU868_MAX_NB_CHANNELS ) | |
{ | |
return LORAMAC_STATUS_PARAMETER_INVALID; | |
} | |
// Validate the datarate range | |
if( RegionCommonValueInRange( channelAdd->NewChannel->DrRange.Fields.Min, EU868_TX_MIN_DATARATE, EU868_TX_MAX_DATARATE ) == false ) | |
{ | |
drInvalid = true; | |
} | |
if( RegionCommonValueInRange( channelAdd->NewChannel->DrRange.Fields.Max, EU868_TX_MIN_DATARATE, EU868_TX_MAX_DATARATE ) == false ) | |
{ | |
drInvalid = true; | |
} | |
if( channelAdd->NewChannel->DrRange.Fields.Min > channelAdd->NewChannel->DrRange.Fields.Max ) | |
{ | |
drInvalid = true; | |
} | |
// Default channels don't accept all values | |
if( id < EU868_NUMB_DEFAULT_CHANNELS ) | |
{ | |
// Validate the datarate range for min: must be DR_0 | |
if( channelAdd->NewChannel->DrRange.Fields.Min > DR_0 ) | |
{ | |
drInvalid = true; | |
} | |
// Validate the datarate range for max: must be DR_5 <= Max <= TX_MAX_DATARATE | |
if( RegionCommonValueInRange( channelAdd->NewChannel->DrRange.Fields.Max, DR_5, EU868_TX_MAX_DATARATE ) == false ) | |
{ | |
drInvalid = true; | |
} | |
// We are not allowed to change the frequency | |
if( channelAdd->NewChannel->Frequency != Channels[id].Frequency ) | |
{ | |
freqInvalid = true; | |
} | |
} | |
// Check frequency | |
if( freqInvalid == false ) | |
{ | |
if( VerifyTxFreq( channelAdd->NewChannel->Frequency, &band ) == false ) | |
{ | |
freqInvalid = true; | |
} | |
} | |
// Check status | |
if( ( drInvalid == true ) && ( freqInvalid == true ) ) | |
{ | |
return LORAMAC_STATUS_FREQ_AND_DR_INVALID; | |
} | |
if( drInvalid == true ) | |
{ | |
return LORAMAC_STATUS_DATARATE_INVALID; | |
} | |
if( freqInvalid == true ) | |
{ | |
return LORAMAC_STATUS_FREQUENCY_INVALID; | |
} | |
memcpy1( ( uint8_t* )( Channels + id ), ( uint8_t* )channelAdd->NewChannel, sizeof( Channels[id] ) ); | |
Channels[id].Band = band; | |
ChannelsMask[0] |= ( 1 << id ); | |
return LORAMAC_STATUS_OK; | |
} | |
bool RegionEU868ChannelsRemove( ChannelRemoveParams_t* channelRemove ) | |
{ | |
uint8_t id = channelRemove->ChannelId; | |
if( id < EU868_NUMB_DEFAULT_CHANNELS ) | |
{ | |
return false; | |
} | |
// Remove the channel from the list of channels | |
Channels[id] = ( ChannelParams_t ){ 0, 0, { 0 }, 0 }; | |
return RegionCommonChanDisable( ChannelsMask, id, EU868_MAX_NB_CHANNELS ); | |
} | |
void RegionEU868SetContinuousWave( ContinuousWaveParams_t* continuousWave ) | |
{ | |
int8_t txPowerLimited = LimitTxPower( continuousWave->TxPower, Bands[Channels[continuousWave->Channel].Band].TxMaxPower, continuousWave->Datarate, ChannelsMask ); | |
int8_t phyTxPower = 0; | |
uint32_t frequency = Channels[continuousWave->Channel].Frequency; | |
// Calculate physical TX power | |
phyTxPower = RegionCommonComputeTxPower( txPowerLimited, continuousWave->MaxEirp, continuousWave->AntennaGain ); | |
Radio.SetTxContinuousWave( frequency, phyTxPower, continuousWave->Timeout ); | |
} | |
uint8_t RegionEU868ApplyDrOffset( uint8_t downlinkDwellTime, int8_t dr, int8_t drOffset ) | |
{ | |
int8_t datarate = dr - drOffset; | |
if( datarate < 0 ) | |
{ | |
datarate = DR_0; | |
} | |
return datarate; | |
} |