Diff: mac/region_arib8ch.cpp

Revision:

0:6b3ac9c5a042

Child:

3:eb174e10afbb

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mac/region_arib8ch.cpp	Wed Feb 28 10:48:11 2018 -0800
@@ -0,0 +1,367 @@
+//#include "Commissioning.h"
+#include "board.h"
+#if defined(USE_BAND_ARIB_8CH)
+#include <stdint.h>
+#include "LoRaMacPrivate.h"
+
+const uint8_t MaxPayloadOfDatarate[] = { 51, 51, 51, 115, 242, 242, 242, 242 };
+const uint8_t Datarates[]  = { 12, 11, 10,  9,  8,  7,  7, 50 };
+const int8_t TxPowers[]    = { 20, 14, 11,  8,  5,  2 };
+
+ChannelParams_t Channels[LORA_MAX_NB_CHANNELS] =
+{
+    LC1,
+    LC2
+    /* other channels given by mac command */
+};
+
+uint32_t region_GetRxBandwidth( int8_t datarate )
+{
+    if( datarate == DR_6 )
+    {// LoRa 250 kHz
+        return 1;
+    }
+    return 0; // LoRa 125 kHz
+}
+
+uint16_t region_GetRxSymbolTimeout( int8_t datarate )
+{
+    if( ( datarate == DR_3 ) || ( datarate == DR_4 ) )
+    { // DR_4, DR_3
+        return 8;
+    }
+    else if( datarate == DR_5 )
+    {
+        return 10;
+    }
+    else if( datarate == DR_6 )
+    {
+        return 14;
+    }
+    return 5; // DR_2, DR_1, DR_0
+}
+
+void region_rx1_setup(uint8_t chan)
+{
+    int8_t datarate = LoRaMacParams.ChannelsDatarate - LoRaMacParams.Rx1DrOffset;
+    if( datarate < 0 )
+    {
+        datarate = DR_0;
+    }
+
+    RxWindowSetup(
+        Channels[chan].FreqHz,
+        datarate,
+        region_GetRxBandwidth(datarate),
+        region_GetRxSymbolTimeout(datarate)
+    );
+}
+
+void
+region_adr_next_dr(int8_t* dr, bool update)
+{
+    if( *dr > LORAMAC_TX_MIN_DATARATE )
+    {
+        (*dr)--;
+    }
+    if( *dr == LORAMAC_TX_MIN_DATARATE )
+    {
+        if( update == true )
+        {
+            // Re-enable default channels, boot channels
+            LoRaMacParams.ChannelsMask[0] = LoRaMacParamsDefaults.ChannelsMask[0];
+            MAC_PRINTF("adr: reset channel mask\r\n");
+        }
+    }
+}
+
+static bool SetNextChannel(LoRaMacStatus_t* status)
+{
+    uint8_t nbEnabledChannels = 0;
+    uint8_t enabledChannels[LORA_MAX_NB_CHANNELS];
+
+    memset( enabledChannels, 0, LORA_MAX_NB_CHANNELS );
+
+    *status = LORAMAC_STATUS_SERVICE_UNKNOWN;
+    if( CountBits( LoRaMacParams.ChannelsMask[0], 16 ) == 0 )
+    {
+        // Re-enable default channels, if no channel is enabled
+        LoRaMacParams.ChannelsMask[0] = LoRaMacParams.ChannelsMask[0] | ( LC( 1 ) + LC( 2 ) + LC( 3 ) );
+    }
+
+    // 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++ )
+        {
+            if( ( LoRaMacParams.ChannelsMask[k] & ( 1 << j ) ) != 0 )
+            {
+                if( Channels[i + j].FreqHz == 0 )
+                { // Check if the channel is enabled
+                    continue;
+                }
+#ifdef OVER_THE_AIR_ACTIVATION
+                if (!flags.IsLoRaMacNetworkJoined)
+                {
+                    if( ( JOIN_CHANNELS & ( 1 << j ) ) == 0 )
+                    {
+                        continue;
+                    }
+                }
+#endif /* OVER_THE_AIR_ACTIVATION  */
+                if( ( ( Channels[i + j].DrRange.Fields.Min <= LoRaMacParams.ChannelsDatarate ) &&
+                      ( LoRaMacParams.ChannelsDatarate <= Channels[i + j].DrRange.Fields.Max ) ) == false )
+                { // Check if the current channel selection supports the given datarate
+                    *status = LORAMAC_STATUS_DATARATE_INVALID;
+                    continue;
+                }
+                enabledChannels[nbEnabledChannels++] = i + j;
+            }
+        }
+    }
+
+    if( nbEnabledChannels > 0 )
+    {
+        Channel = enabledChannels[random_at_most(nbEnabledChannels - 1)];
+        *status = LORAMAC_STATUS_OK;
+        return true;
+    }
+    else
+    {
+        // Datarate not supported by any channel
+        return false;
+    }
+}
+
+
+static us_timestamp_t defer_uplink_us;
+
+void region_ScheduleTx( )
+{
+    LoRaMacStatus_t ret;
+
+    if (defer_uplink_us > 0) {
+        TxDelayedEvent.attach_us(OnTxDelayedTimerEvent, defer_uplink_us);
+        defer_uplink_us = 0;
+        return;
+    }
+
+    // Select channel
+    if (!SetNextChannel(&ret))
+    {
+        // Set the default datarate
+        LoRaMacParams.ChannelsDatarate = LoRaMacParamsDefaults.ChannelsDatarate;
+        // re-enable default channels
+        LoRaMacParams.ChannelsMask[0] = LoRaMacParamsDefaults.ChannelsMask[0];
+        if (!SetNextChannel(&ret))
+            return;
+    }
+
+    // Schedule transmission of frame
+    // Try to send now
+    SendFrameOnChannel( Channel );
+}
+
+void region_mac_init()
+{
+    /* only boot channels enabled */
+    LoRaMacParamsDefaults.ChannelsMask[0] = (LC(1)+LC(2));
+}
+
+void region_adr_request(adr_t* adr)
+{
+    uint8_t i;
+
+    if( ( adr->chMaskCntl == 0 ) && ( adr->chMask == 0 ) )
+    {
+        adr->status &= 0xFE; // Channel mask KO
+    }
+    else if( ( ( adr->chMaskCntl >= 1 ) && ( adr->chMaskCntl <= 5 )) ||
+             ( adr->chMaskCntl >= 7 ) )
+    {
+        // RFU
+        adr->status &= 0xFE; // Channel mask KO
+    }
+    else
+    {
+        for( i = 0; i < LORA_MAX_NB_CHANNELS; i++ )
+        {
+            if( adr->chMaskCntl == 6 )
+            {
+                if( Channels[i].FreqHz != 0 )
+                {
+                    adr->chMask |= 1 << i;
+                }
+            }
+            else
+            {
+                if( ( ( adr->chMask & ( 1 << i ) ) != 0 ) &&
+                    ( Channels[i].FreqHz == 0 ) )
+                {// Trying to enable an undefined channel
+                    adr->status &= 0xFE; // Channel mask KO
+                }
+            }
+        }
+        adr->channelsMask[0] = adr->chMask;
+        MAC_PRINTF("arib set channelsMask:%04x ", adr->channelsMask[0]);
+    }
+}
+
+void region_tx_setup(int8_t txPower, uint8_t pktLen)
+{
+    int8_t datarate = Datarates[LoRaMacParams.ChannelsDatarate];
+
+    if( LoRaMacParams.ChannelsDatarate == DR_7 )
+    { // High Speed FSK channel
+        Radio::SetTxConfig( MODEM_FSK, txPower, 25e3, 0, datarate * 1e3, 0, 5, false, true, false);
+        //TxTimeOnAir_us = Radio.TimeOnAir_us( MODEM_FSK, LoRaMacBufferPktLen );
+
+    }
+    else if( LoRaMacParams.ChannelsDatarate == DR_6 )
+    { // High speed LoRa channel
+        Radio::SetTxConfig( MODEM_LORA, txPower, 0, 1, datarate, 1, 8, false, true, false);
+        //TxTimeOnAir_us = Radio.TimeOnAir_us( MODEM_LORA, LoRaMacBufferPktLen );
+    }
+    else
+    { // Normal LoRa channel
+        Radio::SetTxConfig( MODEM_LORA, txPower, 0, 0, datarate, 1, 8, false, true, false);
+        //TxTimeOnAir_us = Radio.TimeOnAir_us( MODEM_LORA, LoRaMacBufferPktLen );
+    }
+}
+
+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;
+}
+
+LoRaMacStatus_t LoRaMacChannelRemove( uint8_t id )
+{
+    /*if( ( LoRaMacState & LORAMAC_TX_RUNNING ) == LORAMAC_TX_RUNNING )
+    {
+        if( ( LoRaMacState & LORAMAC_TX_CONFIG ) != LORAMAC_TX_CONFIG )
+        {
+            return LORAMAC_STATUS_BUSY;
+        }
+    }*/
+
+    if( ( id < 3 ) || ( id >= LORA_MAX_NB_CHANNELS ) )
+    {
+        return LORAMAC_STATUS_PARAMETER_INVALID;
+    }
+    else
+    {
+        // Remove the channel from the list of channels
+        Channels[id] = ( ChannelParams_t ){ 0, { 0 }, 0 };
+
+        // Disable the channel as it doesn't exist anymore
+        if( DisableChannelInMask( id, LoRaMacParams.ChannelsMask ) == false )
+        {
+            return LORAMAC_STATUS_PARAMETER_INVALID;
+        }
+    }
+    return LORAMAC_STATUS_OK;
+}
+
+static bool ValidateDrRange( DrRange_t drRange, int8_t min, int8_t max )
+{
+    int8_t drMin = drRange.Fields.Min & 0x0F;
+    int8_t drMax = drRange.Fields.Max & 0x0F;
+
+    if( drMin > drMax )
+    {
+        return false;
+    }
+    if( ValueInRange( drMin, min, max ) == false )
+    {
+        return false;
+    }
+    if( ValueInRange( drMax, min, max ) == false )
+    {
+        return false;
+    }
+    return true;
+}
+
+LoRaMacStatus_t LoRaMacChannelAdd( uint8_t id, ChannelParams_t params )
+{
+    bool datarateInvalid = false;
+    bool frequencyInvalid = false;
+    uint8_t band = 0;
+
+    //MAC_PRINTF("channelAdd(%u,%u)\r\n", id, params.Frequency);
+    // The id must not exceed LORA_MAX_NB_CHANNELS
+    if( id >= LORA_MAX_NB_CHANNELS )
+    {
+        return LORAMAC_STATUS_PARAMETER_INVALID;
+    }
+
+    // Validate the datarate
+    if( ValidateDrRange( params.DrRange, LORAMAC_TX_MIN_DATARATE, LORAMAC_TX_MAX_DATARATE ) == false )
+    {
+        datarateInvalid = true;
+    }
+
+    // Validate the frequency
+    if( ( Radio::CheckRfFrequency( params.FreqHz ) == true ) && ( params.FreqHz > 0 ) && ( frequencyInvalid == false ) )
+    {
+        frequencyInvalid = false;
+    }
+    else
+    {
+        frequencyInvalid = true;
+    }
+
+    if( ( datarateInvalid == true ) && ( frequencyInvalid == true ) )
+    {
+        return LORAMAC_STATUS_FREQ_AND_DR_INVALID;
+    }
+    if( datarateInvalid == true )
+    {
+        return LORAMAC_STATUS_DATARATE_INVALID;
+    }
+    if( frequencyInvalid == true )
+    {
+        return LORAMAC_STATUS_FREQUENCY_INVALID;
+    }
+
+    // Every parameter is valid, activate the channel
+    Channels[id] = params;
+    Channels[id].Band = band;
+    LoRaMacParams.ChannelsMask[0] |= ( 1 << id );
+
+    return LORAMAC_STATUS_OK;
+}
+
+void
+region_session_start(LoRaMacEventInfoStatus_t status)
+{
+    McpsReq_t mcpsReq;
+        
+    if (LoRaMacParams.ChannelsMask[0] == 0x003c) {
+        return;
+    }
+    /* send mac commands until desired channel mask */
+
+    mcpsReq.Type = MCPS_UNCONFIRMED;
+    mcpsReq.Req.fPort = 1;
+    mcpsReq.Req.fBuffer = NULL;
+    mcpsReq.Req.fBufferSize = 0;
+    mcpsReq.Req.Datarate = DR_3;
+
+    defer_uplink_us = 2000000 + random_at_most(2000000);
+    LoRaMacMcpsRequest( &mcpsReq );
+}
+
+#endif /* USE_BAND_ARIB_8CH */
+