jmg
/
lora-irrigation
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Implement a secure ICS protocol targeting LoRa Node151 microcontroller for controlling irrigation.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
111 Commits
4 Branches
18 MiB
 
 
 
 
 
 
Tree: b3ec53c4cb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b3ec53c4cb'
${ noResults }
lora-irrigation/loramac/src/mac/region/RegionAU915.c

940 lines
32 KiB
Raw Blame History 

  1. /*!

  2.  * \file      RegionAU915.c

  3.  *

  4.  * \brief     Region implementation for AU915

  5.  *

  6.  * \copyright Revised BSD License, see section \ref LICENSE.

  7.  *

  8.  * \code

  9.  *                ______                              _

  10.  *               / _____)             _              | |

  11.  *              ( (____  _____ ____ _| |_ _____  ____| |__

  12.  *               \____ \| ___ |    (_   _) ___ |/ ___)  _ \

  13.  *               _____) ) ____| | | || |_| ____( (___| | | |

  14.  *              (______/|_____)_|_|_| \__)_____)\____)_| |_|

  15.  *              (C)2013-2017 Semtech

  16.  *

  17.  *               ___ _____ _   ___ _  _____ ___  ___  ___ ___

  18.  *              / __|_   _/_\ / __| |/ / __/ _ \| _ \/ __| __|

  19.  *              \__ \ | |/ _ \ (__| ' <| _| (_) |   / (__| _|

  20.  *              |___/ |_/_/ \_\___|_|\_\_| \___/|_|_\\___|___|

  21.  *              embedded.connectivity.solutions===============

  22.  *

  23.  * \endcode

  24.  *

  25.  * \author    Miguel Luis ( Semtech )

  26.  *

  27.  * \author    Gregory Cristian ( Semtech )

  28.  *

  29.  * \author    Daniel Jaeckle ( STACKFORCE )

  30. */

  31. #include "radio.h"

  32. #include "RegionCommon.h"

  33. #include "RegionAU915.h"

  34. #include "RegionBaseUS.h"

  35. 

  36. // Definitions

  37. #define CHANNELS_MASK_SIZE              6

  38. 

  39. // A mask to select only valid 500KHz channels

  40. #define CHANNELS_MASK_500KHZ_MASK       0x00FF

  41. 

  42. /*

  43.  * Non-volatile module context.

  44.  */

  45. static RegionNvmDataGroup1_t* RegionNvmGroup1;

  46. static RegionNvmDataGroup2_t* RegionNvmGroup2;

  47. static Band_t* RegionBands;

  48. 

  49. static bool VerifyRfFreq( uint32_t freq )

  50. {

  51.     // Check radio driver support

  52.     if( Radio.CheckRfFrequency( freq ) == false )

  53.     {

  54.         return false;

  55.     }

  56. 

  57.     // Rx frequencies

  58.     if( ( freq < AU915_FIRST_RX1_CHANNEL ) ||

  59.         ( freq > AU915_LAST_RX1_CHANNEL ) ||

  60.         ( ( ( freq - ( uint32_t ) AU915_FIRST_RX1_CHANNEL ) % ( uint32_t ) AU915_STEPWIDTH_RX1_CHANNEL ) != 0 ) )

  61.     {

  62.         return false;

  63.     }

  64. 

  65.     // Tx frequencies for 125kHz

  66.     // Also includes the range for 500kHz channels

  67.     if( ( freq < 915200000 ) ||  ( freq > 927800000 ) )

  68.     {

  69.         return false;

  70.     }

  71.     return true;

  72. }

  73. 

  74. static TimerTime_t GetTimeOnAir( int8_t datarate, uint16_t pktLen )

  75. {

  76.     int8_t phyDr = DataratesAU915[datarate];

  77.     uint32_t bandwidth = RegionCommonGetBandwidth( datarate, BandwidthsAU915 );

  78. 

  79.     return Radio.TimeOnAir( MODEM_LORA, bandwidth, phyDr, 1, 8, false, pktLen, true );

  80. }

  81. 

  82. PhyParam_t RegionAU915GetPhyParam( GetPhyParams_t* getPhy )

  83. {

  84.     PhyParam_t phyParam = { 0 };

  85. 

  86.     switch( getPhy->Attribute )

  87.     {

  88.         case PHY_MIN_RX_DR:

  89.         {

  90.             if( getPhy->DownlinkDwellTime == 0)

  91.             {

  92.                 phyParam.Value = AU915_RX_MIN_DATARATE;

  93.             }

  94.             else

  95.             {

  96.                 phyParam.Value = AU915_DWELL_LIMIT_DATARATE;

  97.             }

  98.             break;

  99.         }

  100.         case PHY_MIN_TX_DR:

  101.         {

  102.             if( getPhy->UplinkDwellTime == 0)

  103.             {

  104.                 phyParam.Value = AU915_TX_MIN_DATARATE;

  105.             }

  106.             else

  107.             {

  108.                 phyParam.Value = AU915_DWELL_LIMIT_DATARATE;

  109.             }

  110.             break;

  111.         }

  112.         case PHY_DEF_TX_DR:

  113.         {

  114.             phyParam.Value = AU915_DEFAULT_DATARATE;

  115.             break;

  116.         }

  117.         case PHY_NEXT_LOWER_TX_DR:

  118.         {

  119.             RegionCommonGetNextLowerTxDrParams_t nextLowerTxDrParams =

  120.             {

  121.                 .CurrentDr = getPhy->Datarate,

  122.                 .MaxDr = ( int8_t )AU915_TX_MAX_DATARATE,

  123.                 .MinDr = ( int8_t )( ( getPhy->UplinkDwellTime == 0 ) ? AU915_TX_MIN_DATARATE : AU915_DWELL_LIMIT_DATARATE ),

  124.                 .NbChannels = AU915_MAX_NB_CHANNELS,

  125.                 .ChannelsMask = RegionNvmGroup2->ChannelsMask,

  126.                 .Channels = RegionNvmGroup2->Channels,

  127.             };

  128.             phyParam.Value = RegionCommonGetNextLowerTxDr( &nextLowerTxDrParams );

  129.             break;

  130.         }

  131.         case PHY_MAX_TX_POWER:

  132.         {

  133.             phyParam.Value = AU915_MAX_TX_POWER;

  134.             break;

  135.         }

  136.         case PHY_DEF_TX_POWER:

  137.         {

  138.             phyParam.Value = AU915_DEFAULT_TX_POWER;

  139.             break;

  140.         }

  141.         case PHY_DEF_ADR_ACK_LIMIT:

  142.         {

  143.             phyParam.Value = REGION_COMMON_DEFAULT_ADR_ACK_LIMIT;

  144.             break;

  145.         }

  146.         case PHY_DEF_ADR_ACK_DELAY:

  147.         {

  148.             phyParam.Value = REGION_COMMON_DEFAULT_ADR_ACK_DELAY;

  149.             break;

  150.         }

  151.         case PHY_MAX_PAYLOAD:

  152.         {

  153.             if( getPhy->UplinkDwellTime == 0 )

  154.             {

  155.                 phyParam.Value = MaxPayloadOfDatarateDwell0AU915[getPhy->Datarate];

  156.             }

  157.             else

  158.             {

  159.                 phyParam.Value = MaxPayloadOfDatarateDwell1AU915[getPhy->Datarate];

  160.             }

  161.             break;

  162.         }

  163.         case PHY_DUTY_CYCLE:

  164.         {

  165.             phyParam.Value = AU915_DUTY_CYCLE_ENABLED;

  166.             break;

  167.         }

  168.         case PHY_MAX_RX_WINDOW:

  169.         {

  170.             phyParam.Value = AU915_MAX_RX_WINDOW;

  171.             break;

  172.         }

  173.         case PHY_RECEIVE_DELAY1:

  174.         {

  175.             phyParam.Value = REGION_COMMON_DEFAULT_RECEIVE_DELAY1;

  176.             break;

  177.         }

  178.         case PHY_RECEIVE_DELAY2:

  179.         {

  180.             phyParam.Value = REGION_COMMON_DEFAULT_RECEIVE_DELAY2;

  181.             break;

  182.         }

  183.         case PHY_JOIN_ACCEPT_DELAY1:

  184.         {

  185.             phyParam.Value = REGION_COMMON_DEFAULT_JOIN_ACCEPT_DELAY1;

  186.             break;

  187.         }

  188.         case PHY_JOIN_ACCEPT_DELAY2:

  189.         {

  190.             phyParam.Value = REGION_COMMON_DEFAULT_JOIN_ACCEPT_DELAY2;

  191.             break;

  192.         }

  193.         case PHY_RETRANSMIT_TIMEOUT:

  194.         {

  195.             phyParam.Value = ( REGION_COMMON_DEFAULT_RETRANSMIT_TIMEOUT + randr( -REGION_COMMON_DEFAULT_RETRANSMIT_TIMEOUT_RND, REGION_COMMON_DEFAULT_RETRANSMIT_TIMEOUT_RND ) );

  196.             break;

  197.         }

  198.         case PHY_DEF_DR1_OFFSET:

  199.         {

  200.             phyParam.Value = REGION_COMMON_DEFAULT_RX1_DR_OFFSET;

  201.             break;

  202.         }

  203.         case PHY_DEF_RX2_FREQUENCY:

  204.         {

  205.             phyParam.Value = AU915_RX_WND_2_FREQ;

  206.             break;

  207.         }

  208.         case PHY_DEF_RX2_DR:

  209.         {

  210.             phyParam.Value = AU915_RX_WND_2_DR;

  211.             break;

  212.         }

  213.         case PHY_CHANNELS_MASK:

  214.         {

  215.             phyParam.ChannelsMask = RegionNvmGroup2->ChannelsMask;

  216.             break;

  217.         }

  218.         case PHY_CHANNELS_DEFAULT_MASK:

  219.         {

  220.             phyParam.ChannelsMask = RegionNvmGroup2->ChannelsDefaultMask;

  221.             break;

  222.         }

  223.         case PHY_MAX_NB_CHANNELS:

  224.         {

  225.             phyParam.Value = AU915_MAX_NB_CHANNELS;

  226.             break;

  227.         }

  228.         case PHY_CHANNELS:

  229.         {

  230.             phyParam.Channels = RegionNvmGroup2->Channels;

  231.             break;

  232.         }

  233.         case PHY_DEF_UPLINK_DWELL_TIME:

  234.         {

  235.             phyParam.Value = AU915_DEFAULT_UPLINK_DWELL_TIME;

  236.             break;

  237.         }

  238.         case PHY_DEF_DOWNLINK_DWELL_TIME:

  239.         {

  240.             phyParam.Value = REGION_COMMON_DEFAULT_DOWNLINK_DWELL_TIME;

  241.             break;

  242.         }

  243.         case PHY_DEF_MAX_EIRP:

  244.         {

  245.             phyParam.fValue = AU915_DEFAULT_MAX_EIRP;

  246.             break;

  247.         }

  248.         case PHY_DEF_ANTENNA_GAIN:

  249.         {

  250.             phyParam.fValue = AU915_DEFAULT_ANTENNA_GAIN;

  251.             break;

  252.         }

  253.         case PHY_BEACON_CHANNEL_FREQ:

  254.         {

  255.             phyParam.Value = RegionBaseUSCalcDownlinkFrequency( getPhy->Channel,

  256.                                                                 AU915_BEACON_CHANNEL_FREQ,

  257.                                                                 AU915_BEACON_CHANNEL_STEPWIDTH );

  258.             break;

  259.         }

  260.         case PHY_BEACON_FORMAT:

  261.         {

  262.             phyParam.BeaconFormat.BeaconSize = AU915_BEACON_SIZE;

  263.             phyParam.BeaconFormat.Rfu1Size = AU915_RFU1_SIZE;

  264.             phyParam.BeaconFormat.Rfu2Size = AU915_RFU2_SIZE;

  265.             break;

  266.         }

  267.         case PHY_BEACON_CHANNEL_DR:

  268.         {

  269.             phyParam.Value = AU915_BEACON_CHANNEL_DR;

  270.             break;

  271.         }

  272.         case PHY_BEACON_NB_CHANNELS:

  273.         {

  274.             phyParam.Value = AU915_BEACON_NB_CHANNELS;

  275.             break;

  276.         }

  277.         case PHY_PING_SLOT_CHANNEL_FREQ:

  278.         {

  279.             phyParam.Value = RegionBaseUSCalcDownlinkFrequency( getPhy->Channel,

  280.                                                                 AU915_PING_SLOT_CHANNEL_FREQ,

  281.                                                                 AU915_BEACON_CHANNEL_STEPWIDTH );

  282.             break;

  283.         }

  284.         case PHY_PING_SLOT_CHANNEL_DR:

  285.         {

  286.             phyParam.Value = AU915_PING_SLOT_CHANNEL_DR;

  287.             break;

  288.         }

  289.         case PHY_PING_SLOT_NB_CHANNELS:

  290.         {

  291.             phyParam.Value = AU915_BEACON_NB_CHANNELS;

  292.             break;

  293.         }

  294.         case PHY_SF_FROM_DR:

  295.         {

  296.             phyParam.Value = DataratesAU915[getPhy->Datarate];

  297.             break;

  298.         }

  299.         case PHY_BW_FROM_DR:

  300.         {

  301.             phyParam.Value = RegionCommonGetBandwidth( getPhy->Datarate, BandwidthsAU915 );

  302.             break;

  303.         }

  304.         default:

  305.         {

  306.             break;

  307.         }

  308.     }

  309. 

  310.     return phyParam;

  311. }

  312. 

  313. void RegionAU915SetBandTxDone( SetBandTxDoneParams_t* txDone )

  314. {

  315.     RegionCommonSetBandTxDone( &RegionBands[RegionNvmGroup2->Channels[txDone->Channel].Band],

  316.                                txDone->LastTxAirTime, txDone->Joined, txDone->ElapsedTimeSinceStartUp );

  317. }

  318. 

  319. void RegionAU915InitDefaults( InitDefaultsParams_t* params )

  320. {

  321.     Band_t bands[AU915_MAX_NB_BANDS] =

  322.     {

  323.         AU915_BAND0

  324.     };

  325. 

  326.     switch( params->Type )

  327.     {

  328.         case INIT_TYPE_DEFAULTS:

  329.         {

  330.             if( ( params->NvmGroup1 == NULL ) || ( params->NvmGroup2 == NULL ) )

  331.             {

  332.                 return;

  333.             }

  334. 

  335.             RegionNvmGroup1 = (RegionNvmDataGroup1_t*) params->NvmGroup1;

  336.             RegionNvmGroup2 = (RegionNvmDataGroup2_t*) params->NvmGroup2;

  337.             RegionBands = (Band_t*) params->Bands;

  338. 

  339.             // Initialize 8 bit channel groups index

  340.             RegionNvmGroup1->JoinChannelGroupsCurrentIndex = 0;

  341. 

  342.             // Initialize the join trials counter

  343.             RegionNvmGroup1->JoinTrialsCounter = 0;

  344. 

  345.             // Default bands

  346.             memcpy1( ( uint8_t* )RegionBands, ( uint8_t* )bands, sizeof( Band_t ) * AU915_MAX_NB_BANDS );

  347. 

  348.             // Channels

  349.             for( uint8_t i = 0; i < AU915_MAX_NB_CHANNELS - 8; i++ )

  350.             {

  351.                 // 125 kHz channels

  352.                 RegionNvmGroup2->Channels[i].Frequency = 915200000 + i * 200000;

  353.                 RegionNvmGroup2->Channels[i].DrRange.Value = ( DR_5 << 4 ) | DR_0;

  354.                 RegionNvmGroup2->Channels[i].Band = 0;

  355.             }

  356.             for( uint8_t i = AU915_MAX_NB_CHANNELS - 8; i < AU915_MAX_NB_CHANNELS; i++ )

  357.             {

  358.                 // 500 kHz channels

  359.                 RegionNvmGroup2->Channels[i].Frequency = 915900000 + ( i - ( AU915_MAX_NB_CHANNELS - 8 ) ) * 1600000;

  360.                 RegionNvmGroup2->Channels[i].DrRange.Value = ( DR_6 << 4 ) | DR_6;

  361.                 RegionNvmGroup2->Channels[i].Band = 0;

  362.             }

  363. 

  364.             // Initialize channels default mask

  365.             RegionNvmGroup2->ChannelsDefaultMask[0] = 0xFFFF;

  366.             RegionNvmGroup2->ChannelsDefaultMask[1] = 0xFFFF;

  367.             RegionNvmGroup2->ChannelsDefaultMask[2] = 0xFFFF;

  368.             RegionNvmGroup2->ChannelsDefaultMask[3] = 0xFFFF;

  369.             RegionNvmGroup2->ChannelsDefaultMask[4] = 0x00FF;

  370.             RegionNvmGroup2->ChannelsDefaultMask[5] = 0x0000;

  371. 

  372.             // Copy channels default mask

  373.             RegionCommonChanMaskCopy( RegionNvmGroup2->ChannelsMask, RegionNvmGroup2->ChannelsDefaultMask, CHANNELS_MASK_SIZE );

  374. 

  375.             // Copy into channels mask remaining

  376.             RegionCommonChanMaskCopy( RegionNvmGroup1->ChannelsMaskRemaining, RegionNvmGroup2->ChannelsMask, CHANNELS_MASK_SIZE );

  377.             break;

  378.         }

  379.         case INIT_TYPE_RESET_TO_DEFAULT_CHANNELS:

  380.         {

  381.             // Intentional fallthrough

  382.         }

  383.         case INIT_TYPE_ACTIVATE_DEFAULT_CHANNELS:

  384.         {

  385.             // Copy channels default mask

  386.             RegionCommonChanMaskCopy( RegionNvmGroup2->ChannelsMask, RegionNvmGroup2->ChannelsDefaultMask, CHANNELS_MASK_SIZE );

  387. 

  388.             for( uint8_t i = 0; i < CHANNELS_MASK_SIZE; i++ )

  389.             { // Copy-And the channels mask

  390.                 RegionNvmGroup1->ChannelsMaskRemaining[i] &= RegionNvmGroup2->ChannelsMask[i];

  391.             }

  392.             break;

  393.         }

  394.         default:

  395.         {

  396.             break;

  397.         }

  398.     }

  399. }

  400. 

  401. bool RegionAU915Verify( VerifyParams_t* verify, PhyAttribute_t phyAttribute )

  402. {

  403.     switch( phyAttribute )

  404.     {

  405.         case PHY_FREQUENCY:

  406.         {

  407.             return VerifyRfFreq( verify->Frequency );

  408.         }

  409.         case PHY_TX_DR:

  410.         case PHY_DEF_TX_DR:

  411.         {

  412.             if( verify->DatarateParams.UplinkDwellTime == 0 )

  413.             {

  414.                 return RegionCommonValueInRange( verify->DatarateParams.Datarate, AU915_TX_MIN_DATARATE, AU915_TX_MAX_DATARATE );

  415.             }

  416.             else

  417.             {

  418.                 return RegionCommonValueInRange( verify->DatarateParams.Datarate, AU915_DWELL_LIMIT_DATARATE, AU915_TX_MAX_DATARATE );

  419.             }

  420.         }

  421.         case PHY_RX_DR:

  422.         {

  423.             if( verify->DatarateParams.UplinkDwellTime == 0 )

  424.             {

  425.                 return RegionCommonValueInRange( verify->DatarateParams.Datarate, AU915_RX_MIN_DATARATE, AU915_RX_MAX_DATARATE );

  426.             }

  427.             else

  428.             {

  429.                 return RegionCommonValueInRange( verify->DatarateParams.Datarate, AU915_DWELL_LIMIT_DATARATE, AU915_RX_MAX_DATARATE );

  430.             }

  431.         }

  432.         case PHY_DEF_TX_POWER:

  433.         case PHY_TX_POWER:

  434.         {

  435.             // Remark: switched min and max!

  436.             return RegionCommonValueInRange( verify->TxPower, AU915_MAX_TX_POWER, AU915_MIN_TX_POWER );

  437.         }

  438.         case PHY_DUTY_CYCLE:

  439.         {

  440.             return AU915_DUTY_CYCLE_ENABLED;

  441.         }

  442.         default:

  443.             return false;

  444.     }

  445. }

  446. 

  447. void RegionAU915ApplyCFList( ApplyCFListParams_t* applyCFList )

  448. {

  449.     // Size of the optional CF list must be 16 byte

  450.     if( applyCFList->Size != 16 )

  451.     {

  452.         return;

  453.     }

  454. 

  455.     // Last byte CFListType must be 0x01 to indicate the CFList contains a series of ChMask fields

  456.     if( applyCFList->Payload[15] != 0x01 )

  457.     {

  458.         return;

  459.     }

  460. 

  461.     // ChMask0 - ChMask4 must be set (every ChMask has 16 bit)

  462.     for( uint8_t chMaskItr = 0, cntPayload = 0; chMaskItr <= 4; chMaskItr++, cntPayload+=2 )

  463.     {

  464.         RegionNvmGroup2->ChannelsMask[chMaskItr] = (uint16_t) (0x00FF & applyCFList->Payload[cntPayload]);

  465.         RegionNvmGroup2->ChannelsMask[chMaskItr] |= (uint16_t) (applyCFList->Payload[cntPayload+1] << 8);

  466.         if( chMaskItr == 4 )

  467.         {

  468.             RegionNvmGroup2->ChannelsMask[chMaskItr] = RegionNvmGroup2->ChannelsMask[chMaskItr] & CHANNELS_MASK_500KHZ_MASK;

  469.         }

  470.         // Set the channel mask to the remaining

  471.         RegionNvmGroup1->ChannelsMaskRemaining[chMaskItr] &= RegionNvmGroup2->ChannelsMask[chMaskItr];

  472.     }

  473. }

  474. 

  475. bool RegionAU915ChanMaskSet( ChanMaskSetParams_t* chanMaskSet )

  476. {

  477.     switch( chanMaskSet->ChannelsMaskType )

  478.     {

  479.         case CHANNELS_MASK:

  480.         {

  481.             RegionCommonChanMaskCopy( RegionNvmGroup2->ChannelsMask, chanMaskSet->ChannelsMaskIn, CHANNELS_MASK_SIZE );

  482. 

  483.             RegionNvmGroup2->ChannelsDefaultMask[4] = RegionNvmGroup2->ChannelsDefaultMask[4] & CHANNELS_MASK_500KHZ_MASK;

  484.             RegionNvmGroup2->ChannelsDefaultMask[5] = 0x0000;

  485. 

  486.             for( uint8_t i = 0; i < 6; i++ )

  487.             { // Copy-And the channels mask

  488.                 RegionNvmGroup1->ChannelsMaskRemaining[i] &= RegionNvmGroup2->ChannelsMask[i];

  489.             }

  490.             break;

  491.         }

  492.         case CHANNELS_DEFAULT_MASK:

  493.         {

  494.             RegionCommonChanMaskCopy( RegionNvmGroup2->ChannelsDefaultMask, chanMaskSet->ChannelsMaskIn, CHANNELS_MASK_SIZE );

  495.             break;

  496.         }

  497.         default:

  498.             return false;

  499.     }

  500.     return true;

  501. }

  502. 

  503. void RegionAU915ComputeRxWindowParameters( int8_t datarate, uint8_t minRxSymbols, uint32_t rxError, RxConfigParams_t *rxConfigParams )

  504. {

  505.     uint32_t tSymbolInUs = 0;

  506. 

  507.     // Get the datarate, perform a boundary check

  508.     rxConfigParams->Datarate = MIN( datarate, AU915_RX_MAX_DATARATE );

  509.     rxConfigParams->Bandwidth = RegionCommonGetBandwidth( rxConfigParams->Datarate, BandwidthsAU915 );

  510. 

  511.     tSymbolInUs = RegionCommonComputeSymbolTimeLoRa( DataratesAU915[rxConfigParams->Datarate], BandwidthsAU915[rxConfigParams->Datarate] );

  512. 

  513.     RegionCommonComputeRxWindowParameters( tSymbolInUs, minRxSymbols, rxError, Radio.GetWakeupTime( ), &rxConfigParams->WindowTimeout, &rxConfigParams->WindowOffset );

  514. }

  515. 

  516. bool RegionAU915RxConfig( RxConfigParams_t* rxConfig, int8_t* datarate )

  517. {

  518.     int8_t dr = rxConfig->Datarate;

  519.     int8_t phyDr = 0;

  520.     uint32_t frequency = rxConfig->Frequency;

  521. 

  522.     if( Radio.GetStatus( ) != RF_IDLE )

  523.     {

  524.         return false;

  525.     }

  526. 

  527.     if( rxConfig->RxSlot == RX_SLOT_WIN_1 )

  528.     {

  529.         // Apply window 1 frequency

  530.         frequency = AU915_FIRST_RX1_CHANNEL + ( rxConfig->Channel % 8 ) * AU915_STEPWIDTH_RX1_CHANNEL;

  531.     }

  532. 

  533.     // Read the physical datarate from the datarates table

  534.     phyDr = DataratesAU915[dr];

  535. 

  536.     Radio.SetChannel( frequency );

  537. 

  538.     // Radio configuration

  539.     Radio.SetRxConfig( MODEM_LORA, rxConfig->Bandwidth, phyDr, 1, 0, 8, rxConfig->WindowTimeout, false, 0, false, 0, 0, true, rxConfig->RxContinuous );

  540. 

  541.     Radio.SetMaxPayloadLength( MODEM_LORA, MaxPayloadOfDatarateDwell0AU915[dr] + LORAMAC_FRAME_PAYLOAD_OVERHEAD_SIZE );

  542. 

  543.     *datarate = (uint8_t) dr;

  544.     return true;

  545. }

  546. 

  547. bool RegionAU915TxConfig( TxConfigParams_t* txConfig, int8_t* txPower, TimerTime_t* txTimeOnAir )

  548. {

  549.     int8_t phyDr = DataratesAU915[txConfig->Datarate];

  550.     int8_t txPowerLimited = RegionCommonLimitTxPower( txConfig->TxPower, RegionBands[RegionNvmGroup2->Channels[txConfig->Channel].Band].TxMaxPower );

  551.     uint32_t bandwidth = RegionCommonGetBandwidth( txConfig->Datarate, BandwidthsAU915 );

  552.     int8_t phyTxPower = 0;

  553. 

  554.     // Calculate physical TX power

  555.     phyTxPower = RegionCommonComputeTxPower( txPowerLimited, txConfig->MaxEirp, txConfig->AntennaGain );

  556. 

  557.     // Setup the radio frequency

  558.     Radio.SetChannel( RegionNvmGroup2->Channels[txConfig->Channel].Frequency );

  559. 

  560.     Radio.SetTxConfig( MODEM_LORA, phyTxPower, 0, bandwidth, phyDr, 1, 8, false, true, 0, 0, false, 4000 );

  561. 

  562.     // Setup maximum payload lenght of the radio driver

  563.     Radio.SetMaxPayloadLength( MODEM_LORA, txConfig->PktLen );

  564.     // Update time-on-air

  565.     *txTimeOnAir = GetTimeOnAir( txConfig->Datarate, txConfig->PktLen );

  566. 

  567.     *txPower = txPowerLimited;

  568.     return true;

  569. }

  570. 

  571. uint8_t RegionAU915LinkAdrReq( LinkAdrReqParams_t* linkAdrReq, int8_t* drOut, int8_t* txPowOut, uint8_t* nbRepOut, uint8_t* nbBytesParsed )

  572. {

  573.     uint8_t status = 0x07;

  574.     RegionCommonLinkAdrParams_t linkAdrParams = { 0 };

  575.     uint8_t nextIndex = 0;

  576.     uint8_t bytesProcessed = 0;

  577.     uint16_t channelsMask[6] = { 0, 0, 0, 0, 0, 0 };

  578.     GetPhyParams_t getPhy;

  579.     PhyParam_t phyParam;

  580.     RegionCommonLinkAdrReqVerifyParams_t linkAdrVerifyParams;

  581. 

  582.     // Initialize local copy of channels mask

  583.     RegionCommonChanMaskCopy( channelsMask, RegionNvmGroup2->ChannelsMask, 6 );

  584. 

  585.     while( bytesProcessed < linkAdrReq->PayloadSize )

  586.     {

  587.         nextIndex = RegionCommonParseLinkAdrReq( &( linkAdrReq->Payload[bytesProcessed] ), &linkAdrParams );

  588. 

  589.         if( nextIndex == 0 )

  590.             break; // break loop, since no more request has been found

  591. 

  592.         // Update bytes processed

  593.         bytesProcessed += nextIndex;

  594. 

  595.         // Revert status, as we only check the last ADR request for the channel mask KO

  596.         status = 0x07;

  597. 

  598.         if( linkAdrParams.ChMaskCtrl == 6 )

  599.         {

  600.             // Enable all 125 kHz channels

  601.             channelsMask[0] = 0xFFFF;

  602.             channelsMask[1] = 0xFFFF;

  603.             channelsMask[2] = 0xFFFF;

  604.             channelsMask[3] = 0xFFFF;

  605.             // Apply chMask to channels 64 to 71

  606.             channelsMask[4] = linkAdrParams.ChMask & CHANNELS_MASK_500KHZ_MASK;

  607.         }

  608.         else if( linkAdrParams.ChMaskCtrl == 7 )

  609.         {

  610.             // Disable all 125 kHz channels

  611.             channelsMask[0] = 0x0000;

  612.             channelsMask[1] = 0x0000;

  613.             channelsMask[2] = 0x0000;

  614.             channelsMask[3] = 0x0000;

  615.             // Apply chMask to channels 64 to 71

  616.             channelsMask[4] = linkAdrParams.ChMask & CHANNELS_MASK_500KHZ_MASK;

  617.         }

  618.         else if( linkAdrParams.ChMaskCtrl == 5 )

  619.         {

  620.             // Start value for comparision

  621.             uint8_t bitMask = 1;

  622. 

  623.             // cntChannelMask for channelsMask[0] until channelsMask[3]

  624.             uint8_t cntChannelMask = 0;

  625. 

  626.             // i will be 1, 2, 3, ..., 7

  627.             for( uint8_t i = 0; i <= 7; i++ )

  628.             {

  629.                 // 8 MSBs of ChMask are RFU

  630.                 // Checking if the ChMask is set, then true

  631.                 if( ( ( linkAdrParams.ChMask & 0x00FF ) & ( bitMask << i ) ) != 0 )

  632.                 {

  633.                     if( ( i % 2 ) == 0 )

  634.                     {

  635.                         // Enable a bank of 8 125kHz channels, 8 LSBs

  636.                         channelsMask[cntChannelMask] |= 0x00FF;

  637.                         // Enable the corresponding 500kHz channel

  638.                         channelsMask[4] |= ( bitMask << i );

  639.                     }

  640.                     else

  641.                     {

  642.                         // Enable a bank of 8 125kHz channels, 8 MSBs

  643.                         channelsMask[cntChannelMask] |= 0xFF00;

  644.                         // Enable the corresponding 500kHz channel

  645.                         channelsMask[4] |= ( bitMask << i );

  646.                         // cntChannelMask increment for uneven i

  647.                         cntChannelMask++;

  648.                     }

  649.                 }

  650.                 // ChMask is not set

  651.                 else

  652.                 {

  653.                     if( ( i % 2 ) == 0 )

  654.                     {

  655.                         // Disable a bank of 8 125kHz channels, 8 LSBs

  656.                         channelsMask[cntChannelMask] &= 0xFF00;

  657.                         // Disable the corresponding 500kHz channel

  658.                         channelsMask[4] &= ~( bitMask << i );

  659.                     }

  660.                     else

  661.                     {

  662.                         // Enable a bank of 8 125kHz channels, 8 MSBs

  663.                         channelsMask[cntChannelMask] &= 0x00FF;

  664.                         // Disable the corresponding 500kHz channel

  665.                         channelsMask[4] &= ~( bitMask << i );

  666.                         // cntChannelMask increment for uneven i

  667.                         cntChannelMask++;

  668.                     }

  669.                 }

  670.             }

  671.         }

  672.         else

  673.         {

  674.             channelsMask[linkAdrParams.ChMaskCtrl] = linkAdrParams.ChMask;

  675.         }

  676.     }

  677. 

  678.     // FCC 15.247 paragraph F mandates to hop on at least 2 125 kHz channels

  679.     if( ( linkAdrParams.Datarate < DR_6 ) && ( RegionCommonCountChannels( channelsMask, 0, 4 ) < 2 ) )

  680.     {

  681.         status &= 0xFE; // Channel mask KO

  682.     }

  683. 

  684.     // Get the minimum possible datarate

  685.     getPhy.Attribute = PHY_MIN_TX_DR;

  686.     getPhy.UplinkDwellTime = linkAdrReq->UplinkDwellTime;

  687.     phyParam = RegionAU915GetPhyParam( &getPhy );

  688. 

  689.     linkAdrVerifyParams.Status = status;

  690.     linkAdrVerifyParams.AdrEnabled = linkAdrReq->AdrEnabled;

  691.     linkAdrVerifyParams.Datarate = linkAdrParams.Datarate;

  692.     linkAdrVerifyParams.TxPower = linkAdrParams.TxPower;

  693.     linkAdrVerifyParams.NbRep = linkAdrParams.NbRep;

  694.     linkAdrVerifyParams.CurrentDatarate = linkAdrReq->CurrentDatarate;

  695.     linkAdrVerifyParams.CurrentTxPower = linkAdrReq->CurrentTxPower;

  696.     linkAdrVerifyParams.CurrentNbRep = linkAdrReq->CurrentNbRep;

  697.     linkAdrVerifyParams.NbChannels = AU915_MAX_NB_CHANNELS;

  698.     linkAdrVerifyParams.ChannelsMask = channelsMask;

  699.     linkAdrVerifyParams.MinDatarate = ( int8_t )phyParam.Value;

  700.     linkAdrVerifyParams.MaxDatarate = AU915_TX_MAX_DATARATE;

  701.     linkAdrVerifyParams.Channels = RegionNvmGroup2->Channels;

  702.     linkAdrVerifyParams.MinTxPower = AU915_MIN_TX_POWER;

  703.     linkAdrVerifyParams.MaxTxPower = AU915_MAX_TX_POWER;

  704.     linkAdrVerifyParams.Version = linkAdrReq->Version;

  705. 

  706.     // Verify the parameters and update, if necessary

  707.     status = RegionCommonLinkAdrReqVerifyParams( &linkAdrVerifyParams, &linkAdrParams.Datarate, &linkAdrParams.TxPower, &linkAdrParams.NbRep );

  708. 

  709.     // Update channelsMask if everything is correct

  710.     if( status == 0x07 )

  711.     {

  712.         // Copy Mask

  713.         RegionCommonChanMaskCopy( RegionNvmGroup2->ChannelsMask, channelsMask, 6 );

  714. 

  715.         RegionNvmGroup1->ChannelsMaskRemaining[0] &= RegionNvmGroup2->ChannelsMask[0];

  716.         RegionNvmGroup1->ChannelsMaskRemaining[1] &= RegionNvmGroup2->ChannelsMask[1];

  717.         RegionNvmGroup1->ChannelsMaskRemaining[2] &= RegionNvmGroup2->ChannelsMask[2];

  718.         RegionNvmGroup1->ChannelsMaskRemaining[3] &= RegionNvmGroup2->ChannelsMask[3];

  719.         RegionNvmGroup1->ChannelsMaskRemaining[4] = RegionNvmGroup2->ChannelsMask[4];

  720.         RegionNvmGroup1->ChannelsMaskRemaining[5] = RegionNvmGroup2->ChannelsMask[5];

  721.     }

  722. 

  723.     // Update status variables

  724.     *drOut = linkAdrParams.Datarate;

  725.     *txPowOut = linkAdrParams.TxPower;

  726.     *nbRepOut = linkAdrParams.NbRep;

  727.     *nbBytesParsed = bytesProcessed;

  728. 

  729.     return status;

  730. }

  731. 

  732. uint8_t RegionAU915RxParamSetupReq( RxParamSetupReqParams_t* rxParamSetupReq )

  733. {

  734.     uint8_t status = 0x07;

  735. 

  736.     // Verify radio frequency

  737.     if( VerifyRfFreq( rxParamSetupReq->Frequency ) == false )

  738.     {

  739.         status &= 0xFE; // Channel frequency KO

  740.     }

  741. 

  742.     // Verify datarate

  743.     if( RegionCommonValueInRange( rxParamSetupReq->Datarate, AU915_RX_MIN_DATARATE, AU915_RX_MAX_DATARATE ) == false )

  744.     {

  745.         status &= 0xFD; // Datarate KO

  746.     }

  747.     if( ( rxParamSetupReq->Datarate == DR_7 ) ||

  748.         ( rxParamSetupReq->Datarate > DR_13 ) )

  749.     {

  750.         status &= 0xFD; // Datarate KO

  751.     }

  752. 

  753.     // Verify datarate offset

  754.     if( RegionCommonValueInRange( rxParamSetupReq->DrOffset, AU915_MIN_RX1_DR_OFFSET, AU915_MAX_RX1_DR_OFFSET ) == false )

  755.     {

  756.         status &= 0xFB; // Rx1DrOffset range KO

  757.     }

  758. 

  759.     return status;

  760. }

  761. 

  762. int8_t RegionAU915NewChannelReq( NewChannelReqParams_t* newChannelReq )

  763. {

  764.     // Do not accept the request

  765.     return -1;

  766. }

  767. 

  768. int8_t RegionAU915TxParamSetupReq( TxParamSetupReqParams_t* txParamSetupReq )

  769. {

  770.     // Accept the request

  771.     return 0;

  772. }

  773. 

  774. int8_t RegionAU915DlChannelReq( DlChannelReqParams_t* dlChannelReq )

  775. {

  776.     // Do not accept the request

  777.     return -1;

  778. }

  779. 

  780. int8_t RegionAU915AlternateDr( int8_t currentDr, AlternateDrType_t type )

  781. {

  782.     // Alternates the data rate according to the channel sequence:

  783.     // Eight times a 125kHz DR_2 and then one 500kHz DR_6 channel

  784.     if( type == ALTERNATE_DR )

  785.     {

  786.         RegionNvmGroup1->JoinTrialsCounter++;

  787.     }

  788.     else

  789.     {

  790.         RegionNvmGroup1->JoinTrialsCounter--;

  791.     }

  792. 

  793.     if( RegionNvmGroup1->JoinTrialsCounter % 9 == 0 )

  794.     {

  795.         // Use DR_6 every 9th times.

  796.         currentDr = DR_6;

  797.     }

  798.     else

  799.     {

  800.         currentDr = DR_2;

  801.     }

  802.     return currentDr;

  803. }

  804. 

  805. LoRaMacStatus_t RegionAU915NextChannel( NextChanParams_t* nextChanParams, uint8_t* channel, TimerTime_t* time, TimerTime_t* aggregatedTimeOff )

  806. {

  807.     uint8_t nbEnabledChannels = 0;

  808.     uint8_t nbRestrictedChannels = 0;

  809.     uint8_t enabledChannels[AU915_MAX_NB_CHANNELS] = { 0 };

  810.     RegionCommonIdentifyChannelsParam_t identifyChannelsParam;

  811.     RegionCommonCountNbOfEnabledChannelsParams_t countChannelsParams;

  812.     LoRaMacStatus_t status = LORAMAC_STATUS_NO_CHANNEL_FOUND;

  813. 

  814.     // Count 125kHz channels

  815.     if( RegionCommonCountChannels( RegionNvmGroup1->ChannelsMaskRemaining, 0, 4 ) == 0 )

  816.     { // Reactivate default channels

  817.         RegionCommonChanMaskCopy( RegionNvmGroup1->ChannelsMaskRemaining, RegionNvmGroup2->ChannelsMask, 4  );

  818. 

  819.         RegionNvmGroup1->JoinChannelGroupsCurrentIndex = 0;

  820.     }

  821.     // Check other channels

  822.     if( nextChanParams->Datarate >= DR_6 )

  823.     {

  824.         if( ( RegionNvmGroup1->ChannelsMaskRemaining[4] & CHANNELS_MASK_500KHZ_MASK ) == 0 )

  825.         {

  826.             RegionNvmGroup1->ChannelsMaskRemaining[4] = RegionNvmGroup2->ChannelsMask[4];

  827.         }

  828.     }

  829. 

  830.     // Search how many channels are enabled

  831.     countChannelsParams.Joined = nextChanParams->Joined;

  832.     countChannelsParams.Datarate = nextChanParams->Datarate;

  833.     countChannelsParams.ChannelsMask = RegionNvmGroup1->ChannelsMaskRemaining;

  834.     countChannelsParams.Channels = RegionNvmGroup2->Channels;

  835.     countChannelsParams.Bands = RegionBands;

  836.     countChannelsParams.MaxNbChannels = AU915_MAX_NB_CHANNELS;

  837.     countChannelsParams.JoinChannels = NULL;

  838. 

  839.     identifyChannelsParam.AggrTimeOff = nextChanParams->AggrTimeOff;

  840.     identifyChannelsParam.LastAggrTx = nextChanParams->LastAggrTx;

  841.     identifyChannelsParam.DutyCycleEnabled = nextChanParams->DutyCycleEnabled;

  842.     identifyChannelsParam.MaxBands = AU915_MAX_NB_BANDS;

  843. 

  844.     identifyChannelsParam.ElapsedTimeSinceStartUp = nextChanParams->ElapsedTimeSinceStartUp;

  845.     identifyChannelsParam.LastTxIsJoinRequest = nextChanParams->LastTxIsJoinRequest;

  846.     identifyChannelsParam.ExpectedTimeOnAir = GetTimeOnAir( nextChanParams->Datarate, nextChanParams->PktLen );

  847. 

  848.     identifyChannelsParam.CountNbOfEnabledChannelsParam = &countChannelsParams;

  849. 

  850.     status = RegionCommonIdentifyChannels( &identifyChannelsParam, aggregatedTimeOff, enabledChannels,

  851.                                            &nbEnabledChannels, &nbRestrictedChannels, time );

  852. 

  853.     if( status == LORAMAC_STATUS_OK )

  854.     {

  855.         if( nextChanParams->Joined == true )

  856.         {

  857.             // Choose randomly on of the remaining channels

  858.             *channel = enabledChannels[randr( 0, nbEnabledChannels - 1 )];

  859.         }

  860.         else

  861.         {

  862.             // For rapid network acquisition in mixed gateway channel plan environments, the device

  863.             // follow a random channel selection sequence. It probes alternating one out of a

  864.             // group of eight 125 kHz channels followed by probing one 500 kHz channel each pass.

  865.             // Each time a 125 kHz channel will be selected from another group.

  866. 

  867.             // 125kHz Channels (0 - 63) DR2

  868.             if( nextChanParams->Datarate == DR_2 )

  869.             {

  870.                 if( RegionBaseUSComputeNext125kHzJoinChannel( ( uint16_t* ) RegionNvmGroup1->ChannelsMaskRemaining,

  871.                     &RegionNvmGroup1->JoinChannelGroupsCurrentIndex, channel ) == LORAMAC_STATUS_PARAMETER_INVALID )

  872.                 {

  873.                     return LORAMAC_STATUS_PARAMETER_INVALID;

  874.                 }

  875.             }

  876.             // 500kHz Channels (64 - 71) DR6

  877.             else

  878.             {

  879.                 // Choose the next available channel

  880.                 uint8_t i = 0;

  881.                 while( ( ( RegionNvmGroup1->ChannelsMaskRemaining[4] & CHANNELS_MASK_500KHZ_MASK ) & ( 1 << i ) ) == 0 )

  882.                 {

  883.                     i++;

  884.                 }

  885.                 *channel = 64 + i;

  886.             }

  887.         }

  888. 

  889.         // Disable the channel in the mask

  890.         RegionCommonChanDisable( RegionNvmGroup1->ChannelsMaskRemaining, *channel, AU915_MAX_NB_CHANNELS );

  891.     }

  892.     return status;

  893. }

  894. 

  895. LoRaMacStatus_t RegionAU915ChannelAdd( ChannelAddParams_t* channelAdd )

  896. {

  897.     return LORAMAC_STATUS_PARAMETER_INVALID;

  898. }

  899. 

  900. bool RegionAU915ChannelsRemove( ChannelRemoveParams_t* channelRemove  )

  901. {

  902.     return LORAMAC_STATUS_PARAMETER_INVALID;

  903. }

  904. 

  905. uint8_t RegionAU915ApplyDrOffset( uint8_t downlinkDwellTime, int8_t dr, int8_t drOffset )

  906. {

  907.     int8_t datarate = DatarateOffsetsAU915[dr][drOffset];

  908. 

  909.     if( datarate < 0 )

  910.     {

  911.         if( downlinkDwellTime == 0 )

  912.         {

  913.             datarate = AU915_TX_MIN_DATARATE;

  914.         }

  915.         else

  916.         {

  917.             datarate = AU915_DWELL_LIMIT_DATARATE;

  918.         }

  919.     }

  920.     return datarate;

  921. }

  922. 

  923. void RegionAU915RxBeaconSetup( RxBeaconSetup_t* rxBeaconSetup, uint8_t* outDr )

  924. {

  925.     RegionCommonRxBeaconSetupParams_t regionCommonRxBeaconSetup;

  926. 

  927.     regionCommonRxBeaconSetup.Datarates = DataratesAU915;

  928.     regionCommonRxBeaconSetup.Frequency = rxBeaconSetup->Frequency;

  929.     regionCommonRxBeaconSetup.BeaconSize = AU915_BEACON_SIZE;

  930.     regionCommonRxBeaconSetup.BeaconDatarate = AU915_BEACON_CHANNEL_DR;

  931.     regionCommonRxBeaconSetup.BeaconChannelBW = AU915_BEACON_CHANNEL_BW;

  932.     regionCommonRxBeaconSetup.RxTime = rxBeaconSetup->RxTime;

  933.     regionCommonRxBeaconSetup.SymbolTimeout = rxBeaconSetup->SymbolTimeout;

  934. 

  935.     RegionCommonRxBeaconSetup( &regionCommonRxBeaconSetup );

  936. 

  937.     // Store downlink datarate

  938.     *outDr = AU915_BEACON_CHANNEL_DR;

  939. }