ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

A few Cosmetics & methods for mask manipulation 

LoRaMacChannelPlan class provides APIs which are not usable for
PHY layer implementations who do not support custom channel plans.
So we had some code in APIs which was explicitely using magic numbers
for the channel mask. Although it turned out to be not a bug as a layer
down we were checking for custom channel support. However, we now
check for custom channel support before going deep into PHY layer that will
make the code run faster and we have done some cosmetics to the code for
readability.

Channel mask is manipulated with inline methods
pull/6059/head
Hasnain Virk 2018-02-12 16:10:37 +02:00
parent 90c02f2843
commit d7c22a6b09
26 changed files with 413 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
features/lorawan/lorastack/mac/LoRaMacChannelPlan.cpp
View File

@ -48,6 +48,14 @@ lorawan_status_t LoRaMacChannelPlan::set_plan(const lorawan_channelplan_t& plan)
phy_param_t phy_param;
uint8_t max_num_channels;
// Check if the PHY layer supports custom channel plans or not.
get_phy.attribute = PHY_CUSTOM_CHANNEL_PLAN_SUPPORT;
phy_param = _lora_phy->get_phy_params(&get_phy);
if (!phy_param.value) {
return LORAWAN_STATUS_SERVICE_UNKNOWN;
}
// Check first how many channels the selected PHY layer supports
get_phy.attribute = PHY_MAX_NB_CHANNELS;
phy_param = _lora_phy->get_phy_params(&get_phy);
@ -91,18 +99,26 @@ lorawan_status_t LoRaMacChannelPlan::get_plan(lorawan_channelplan_t& plan,
get_phy_params_t get_phy;
phy_param_t phy_param;
uint8_t max_num_channels;
uint16_t *channel_masks;
uint16_t *channel_mask;
uint8_t count = 0;
// Check if the PHY layer supports custom channel plans or not.
get_phy.attribute = PHY_CUSTOM_CHANNEL_PLAN_SUPPORT;
phy_param = _lora_phy->get_phy_params(&get_phy);
if (!phy_param.value) {
return LORAWAN_STATUS_SERVICE_UNKNOWN;
}
// Check first how many channels the selected PHY layer supports
get_phy.attribute = PHY_MAX_NB_CHANNELS;
phy_param = _lora_phy->get_phy_params(&get_phy);
max_num_channels = (uint8_t) phy_param.value;
// Now check the Default channel mask
get_phy.attribute = PHY_CHANNELS_MASK;
get_phy.attribute = PHY_CHANNEL_MASK;
phy_param = _lora_phy->get_phy_params(&get_phy);
channel_masks = phy_param.channel_mask;
channel_mask = phy_param.channel_mask;
// Request Mib to get channels
memset(&mib_confirm, 0, sizeof(mib_confirm));
@ -116,7 +132,7 @@ lorawan_status_t LoRaMacChannelPlan::get_plan(lorawan_channelplan_t& plan,
for (uint8_t i = 0; i < max_num_channels; i++) {
// skip the channels which are not enabled
if ((channel_masks[0] & (1U << i)) == 0) {
if (_lora_phy->mask_bit_test(channel_mask, i) == 0) {
continue;
}
@ -143,8 +159,16 @@ lorawan_status_t LoRaMacChannelPlan::remove_plan()
get_phy_params_t get_phy;
phy_param_t phy_param;
uint8_t max_num_channels;
uint16_t *channel_masks;
uint16_t *default_channel_masks;
uint16_t *channel_mask;
uint16_t *default_channel_mask;
// Check if the PHY layer supports custom channel plans or not.
get_phy.attribute = PHY_CUSTOM_CHANNEL_PLAN_SUPPORT;
phy_param = _lora_phy->get_phy_params(&get_phy);
if (!phy_param.value) {
return LORAWAN_STATUS_SERVICE_UNKNOWN;
}
// Check first how many channels the selected PHY layer supports
get_phy.attribute = PHY_MAX_NB_CHANNELS;
@ -152,23 +176,23 @@ lorawan_status_t LoRaMacChannelPlan::remove_plan()
max_num_channels = (uint8_t) phy_param.value;
// Now check the channel mask for enabled channels
get_phy.attribute = PHY_CHANNELS_MASK;
get_phy.attribute = PHY_CHANNEL_MASK;
phy_param = _lora_phy->get_phy_params(&get_phy);
channel_masks = phy_param.channel_mask;
channel_mask = phy_param.channel_mask;
// Now check the channel mask for default channels
get_phy.attribute = PHY_CHANNELS_DEFAULT_MASK;
get_phy.attribute = PHY_DEFAULT_CHANNEL_MASK;
phy_param = _lora_phy->get_phy_params(&get_phy);
default_channel_masks = phy_param.channel_mask;
default_channel_mask = phy_param.channel_mask;
for (uint8_t i = 0; i < max_num_channels; i++) {
// skip any default channels
if ((default_channel_masks[0] & (1U<<i)) != 0) {
if (_lora_phy->mask_bit_test(default_channel_mask, i) != 0) {
continue;
}
// skip any channels which are not currently enabled
if ((channel_masks[0] & (1U<<i)) == 0) {
if (_lora_phy->mask_bit_test(channel_mask, i) == 0) {
continue;
}
@ -187,7 +211,14 @@ lorawan_status_t LoRaMacChannelPlan::remove_single_channel(uint8_t channel_id)
get_phy_params_t get_phy;
phy_param_t phy_param;
uint8_t max_num_channels;
uint16_t *channel_masks;
// Check if the PHY layer supports custom channel plans or not.
get_phy.attribute = PHY_CUSTOM_CHANNEL_PLAN_SUPPORT;
phy_param = _lora_phy->get_phy_params(&get_phy);
if (!phy_param.value) {
return LORAWAN_STATUS_SERVICE_UNKNOWN;
}
// Check first how many channels the selected PHY layer supports
get_phy.attribute = PHY_MAX_NB_CHANNELS;
@ -201,21 +232,7 @@ lorawan_status_t LoRaMacChannelPlan::remove_single_channel(uint8_t channel_id)
return LORAWAN_STATUS_PARAMETER_INVALID;
}
// Now check the Default channel mask
get_phy.attribute = PHY_CHANNELS_DEFAULT_MASK;
phy_param = _lora_phy->get_phy_params(&get_phy);
channel_masks = phy_param.channel_mask;
// check if the channel ID give belongs to a default channel
// Mostly the default channels are in the first mask if the region
// have multiple channel masks for various sub-bands. So we check the first
// mask only and return an error code if user sent a default channel id
if ((channel_masks[0] & (1U << channel_id)) != 0) {
return LORAWAN_STATUS_PARAMETER_INVALID;
}
if(_lora_phy->remove_channel(channel_id) == false)
{
if (_lora_phy->remove_channel(channel_id) == false) {
return LORAWAN_STATUS_PARAMETER_INVALID;
}

4
features/lorawan/lorastack/mac/LoRaMacMib.cpp
View File

@ -355,7 +355,7 @@ lorawan_status_t LoRaMacMib::get_request(loramac_mib_req_confirm_t *mibGet,
}
case MIB_CHANNELS_DEFAULT_MASK:
{
get_phy.attribute = PHY_CHANNELS_DEFAULT_MASK;
get_phy.attribute = PHY_DEFAULT_CHANNEL_MASK;
phy_param = _lora_phy->get_phy_params( &get_phy );
mibGet->param.default_channel_mask = phy_param.channel_mask;
@ -363,7 +363,7 @@ lorawan_status_t LoRaMacMib::get_request(loramac_mib_req_confirm_t *mibGet,
}
case MIB_CHANNELS_MASK:
{
get_phy.attribute = PHY_CHANNELS_MASK;
get_phy.attribute = PHY_CHANNEL_MASK;
phy_param = _lora_phy->get_phy_params( &get_phy );
mibGet->param.channel_mask = phy_param.channel_mask;

180
features/lorawan/lorastack/phy/LoRaPHY.cpp
View File

@ -151,23 +151,21 @@ int32_t LoRaPHY::get_random(int32_t min, int32_t max)
return (int32_t) rand() % (max - min + 1) + min;
}
bool LoRaPHY::verify_channel_DR(uint8_t nbChannels, uint16_t* channelsMask,
int8_t dr, int8_t minDr, int8_t maxDr,
bool LoRaPHY::verify_channel_DR(uint8_t nb_channels, uint16_t* channel_mask,
int8_t dr, int8_t min_dr, int8_t max_dr,
channel_params_t* channels)
{
if (val_in_range(dr, minDr, maxDr) == 0) {
if (val_in_range(dr, min_dr, max_dr) == 0) {
return false;
}
for (uint8_t i = 0, k = 0; i < nbChannels; i += 16, k++) {
for( uint8_t j = 0; j < 16; j++ ) {
if( ((channelsMask[k] & (1 << j)) != 0)) {
// Check datarate validity for enabled channels
if (val_in_range(dr, (channels[i + j].dr_range.fields.min & 0x0F),
(channels[i + j].dr_range.fields.max & 0x0F)) == 1 ) {
// At least 1 channel has been found we can return OK.
return true;
}
for (uint8_t i; i < phy_params.max_channel_cnt; i++) {
if (mask_bit_test(channel_mask, i)) {
// Check datarate validity for enabled channels
if (val_in_range(dr, (channels[i].dr_range.fields.min & 0x0F),
(channels[i].dr_range.fields.max & 0x0F))) {
// At least 1 channel has been found we can return OK.
return true;
}
}
}
@ -184,17 +182,17 @@ uint8_t LoRaPHY::val_in_range( int8_t value, int8_t min, int8_t max )
return 0;
}
bool LoRaPHY::disable_channel(uint16_t* channelsMask, uint8_t id,
uint8_t maxChannels)
bool LoRaPHY::disable_channel(uint16_t* channel_mask, uint8_t id,
uint8_t max_channels_num)
{
uint8_t index = id / 16;
if ((index > phy_params.channels.mask_list_size) || (id >= maxChannels)) {
if ((index > phy_params.channels.mask_size) || (id >= max_channels_num)) {
return false;
}
// Deactivate channel
channelsMask[index] &= ~(1 << (id % 16));
mask_bit_clear(channel_mask, id);
return true;
}
@ -204,7 +202,7 @@ uint8_t LoRaPHY::count_bits(uint16_t mask, uint8_t nbBits)
uint8_t nbActiveBits = 0;
for(uint8_t j = 0; j < nbBits; j++) {
if ((mask & (1 << j)) == (1 << j)) {
if (mask_bit_test(&mask, j)) {
nbActiveBits++;
}
}
@ -212,26 +210,27 @@ uint8_t LoRaPHY::count_bits(uint16_t mask, uint8_t nbBits)
return nbActiveBits;
}
uint8_t LoRaPHY::num_active_channels( uint16_t* channelsMask, uint8_t startIdx, uint8_t stopIdx )
uint8_t LoRaPHY::num_active_channels(uint16_t* channel_mask, uint8_t start_idx,
uint8_t stop_idx)
{
uint8_t nbChannels = 0;
uint8_t nb_channels = 0;
if (channelsMask == NULL) {
if (channel_mask == NULL) {
return 0;
}
for (uint8_t i = startIdx; i < stopIdx; i++) {
nbChannels += count_bits(channelsMask[i], 16);
for (uint8_t i = start_idx; i < stop_idx; i++) {
nb_channels += count_bits(channel_mask[i], 16);
}
return nbChannels;
return nb_channels;
}
void LoRaPHY::copy_channel_mask(uint16_t* channelsMaskDest, uint16_t* channelsMaskSrc, uint8_t len)
void LoRaPHY::copy_channel_mask(uint16_t* dest_mask, uint16_t* src_mask, uint8_t len)
{
if ((channelsMaskDest != NULL) && (channelsMaskSrc != NULL)) {
if ((dest_mask != NULL) && (src_mask != NULL)) {
for( uint8_t i = 0; i < len; i++ ) {
channelsMaskDest[i] = channelsMaskSrc[i];
dest_mask[i] = src_mask[i];
}
}
}
@ -443,36 +442,31 @@ uint8_t LoRaPHY::get_bandwidth(uint8_t dr)
}
uint8_t LoRaPHY::enabled_channel_count(bool joined, uint8_t datarate,
uint16_t *mask_list,
uint8_t mask_list_size,
const uint16_t *channel_mask,
uint8_t *channel_indices,
uint8_t *delayTx)
{
uint8_t count = 0;
uint8_t delay_transmission = 0;
for (uint8_t i = 0, k = 0; i < phy_params.max_channel_cnt && k < mask_list_size;
i += CHANNELS_IN_MASK, k++) {
for (uint8_t i = 0; i < phy_params.max_channel_cnt; i++) {
if (mask_bit_test(channel_mask, i)) {
for (uint8_t j = 0; j < CHANNELS_IN_MASK; j++) {
if ((mask_list[k] & (1 << j)) != 0) {
if (val_in_range(datarate, phy_params.channels.channel_list[i + j].dr_range.fields.min,
phy_params.channels.channel_list[i + j].dr_range.fields.max ) == 0) {
// data rate range invalid for this channel
continue;
}
band_t *band_table = (band_t *) phy_params.bands.table;
if (band_table[phy_params.channels.channel_list[i + j].band].off_time > 0) {
// Check if the band is available for transmission
delay_transmission++;
continue;
}
// otherwise count the channel as enabled
channel_indices[count++] = i + j;
if (val_in_range(datarate, phy_params.channels.channel_list[i].dr_range.fields.min,
phy_params.channels.channel_list[i].dr_range.fields.max ) == 0) {
// data rate range invalid for this channel
continue;
}
band_t *band_table = (band_t *) phy_params.bands.table;
if (band_table[phy_params.channels.channel_list[i].band].off_time > 0) {
// Check if the band is available for transmission
delay_transmission++;
continue;
}
// otherwise count the channel as enabled
channel_indices[count++] = i;
}
}
@ -526,8 +520,7 @@ phy_param_t LoRaPHY::get_phy_params(get_phy_params_t* getPhy)
break;
}
case PHY_MAX_PAYLOAD_REPEATER: {
uint8_t *payload_table =
(uint8_t *) phy_params.payloads_with_repeater.table;
uint8_t *payload_table = (uint8_t *) phy_params.payloads_with_repeater.table;
phyParam.value = payload_table[getPhy->datarate];
break;
}
@ -578,12 +571,12 @@ phy_param_t LoRaPHY::get_phy_params(get_phy_params_t* getPhy)
phyParam.value = phy_params.rx_window2_datarate;
break;
}
case PHY_CHANNELS_MASK: {
phyParam.channel_mask = phy_params.channels.mask_list;
case PHY_CHANNEL_MASK: {
phyParam.channel_mask = phy_params.channels.mask;
break;
}
case PHY_CHANNELS_DEFAULT_MASK: {
phyParam.channel_mask = phy_params.channels.default_mask_list;
case PHY_DEFAULT_CHANNEL_MASK: {
phyParam.channel_mask = phy_params.channels.default_mask;
break;
}
case PHY_MAX_NB_CHANNELS: {
@ -594,6 +587,12 @@ phy_param_t LoRaPHY::get_phy_params(get_phy_params_t* getPhy)
phyParam.channel_params = phy_params.channels.channel_list;
break;
}
case PHY_CUSTOM_CHANNEL_PLAN_SUPPORT:
// 0 if custom channel plans are not supported (in LoRaWAN terms
// the regions who do not support custom channels are called as
// regions with dynamic channel plans)
phyParam.value = (uint32_t) phy_params.custom_channelplans_supported;
break;
case PHY_DEF_UPLINK_DWELL_TIME: {
phyParam.value = phy_params.ul_dwell_time_setting;
break;
@ -626,8 +625,8 @@ phy_param_t LoRaPHY::get_phy_params(get_phy_params_t* getPhy)
void LoRaPHY::restore_default_channels()
{
// Restore channels default mask
for (uint8_t i=0; i < phy_params.channels.mask_list_size; i++) {
phy_params.channels.mask_list[i] |= phy_params.channels.default_mask_list[i];
for (uint8_t i=0; i < phy_params.channels.mask_size; i++) {
phy_params.channels.mask[i] |= phy_params.channels.default_mask[i];
}
}
@ -768,7 +767,6 @@ bool LoRaPHY::get_next_ADR(bool restore_channel_mask, int8_t& dr_out,
set_adr_ack_bit = true;
tx_power_out = phy_params.max_tx_power;
if (adr_ack_cnt >= ack_limit_plus_delay) {
if ((adr_ack_cnt % phy_params.adr_ack_delay) == 1) {
// Decrease the datarate
@ -943,7 +941,7 @@ uint8_t LoRaPHY::link_ADR_request(adr_req_params_t* link_adr_req,
// a channel mask list size of unity here as we know that all
// the PHY layer implementations who have more than 16 channels, i.e.,
// have channel mask list size more than unity, override this method.
uint16_t temp_channel_masks[1] = {0};
uint16_t temp_channel_mask[1] = {0};
verify_adr_params_t verify_params;
@ -963,10 +961,10 @@ uint8_t LoRaPHY::link_ADR_request(adr_req_params_t* link_adr_req,
status = 0x07;
// Setup temporary channels mask
temp_channel_masks[0] = adr_settings.channel_mask;
temp_channel_mask[0] = adr_settings.channel_mask;
// Verify channels mask
if (adr_settings.ch_mask_ctrl == 0 && temp_channel_masks[0] == 0) {
if (adr_settings.ch_mask_ctrl == 0 && temp_channel_mask[0] == 0) {
status &= 0xFE; // Channel mask KO
}
@ -979,7 +977,7 @@ uint8_t LoRaPHY::link_ADR_request(adr_req_params_t* link_adr_req,
// turn on all channels if channel mask control is 6
if (adr_settings.ch_mask_ctrl == 6) {
if (phy_params.channels.channel_list[i].frequency != 0) {
temp_channel_masks[0] |= 1 << i;
mask_bit_set(temp_channel_mask, i);
}
continue;
@ -987,8 +985,8 @@ uint8_t LoRaPHY::link_ADR_request(adr_req_params_t* link_adr_req,
// if channel mask control is 0, we test the bits and
// frequencies and change the status if we find a discrepancy
if (((temp_channel_masks[0] & (1 << i)) != 0)
&& (phy_params.channels.channel_list[i].frequency == 0)) {
if ((mask_bit_test(temp_channel_mask, i)) &&
(phy_params.channels.channel_list[i].frequency == 0)) {
// Trying to enable an undefined channel
status &= 0xFE; // Channel mask KO
}
@ -1011,7 +1009,7 @@ uint8_t LoRaPHY::link_ADR_request(adr_req_params_t* link_adr_req,
verify_params.nb_rep = adr_settings.nb_rep;
verify_params.channel_mask = temp_channel_masks;
verify_params.channel_mask = temp_channel_mask;
// Verify the parameters and update, if necessary
status = verify_link_ADR_req(&verify_params, &adr_settings.datarate,
@ -1020,12 +1018,12 @@ uint8_t LoRaPHY::link_ADR_request(adr_req_params_t* link_adr_req,
// Update channelsMask if everything is correct
if (status == 0x07) {
// Set the channels mask to a default value
memset(phy_params.channels.mask_list, 0,
sizeof(uint16_t)*phy_params.channels.mask_list_size);
memset(phy_params.channels.mask, 0,
sizeof(uint16_t)*phy_params.channels.mask_size);
// Update the channels mask
copy_channel_mask(phy_params.channels.mask_list, temp_channel_masks,
phy_params.channels.mask_list_size);
copy_channel_mask(phy_params.channels.mask, temp_channel_mask,
phy_params.channels.mask_size);
}
// Update status variables
@ -1108,8 +1106,7 @@ uint8_t LoRaPHY::dl_channel_request(dl_channel_req_params_t* params)
// Apply Rx1 frequency, if the status is OK
if (status == 0x03) {
phy_params.channels.channel_list[params->channel_id].rx1_frequency
= params->rx1_frequency;
phy_params.channels.channel_list[params->channel_id].rx1_frequency = params->rx1_frequency;
}
return status;
@ -1196,8 +1193,7 @@ void LoRaPHY::calculate_backoff(backoff_params_t* calc_backoff)
band_table[band_idx].off_time = 0;
} else {
// Apply band time-off.
band_table[band_idx].off_time = calc_backoff->tx_toa * duty_cycle
- calc_backoff->tx_toa;
band_table[band_idx].off_time = calc_backoff->tx_toa * duty_cycle - calc_backoff->tx_toa;
}
}
@ -1220,13 +1216,13 @@ bool LoRaPHY::set_next_channel(channel_selection_params_t* params,
lorawan_time_t next_tx_delay = 0;
band_t *band_table = (band_t *) phy_params.bands.table;
if (num_active_channels(phy_params.channels.mask_list, 0,
phy_params.channels.mask_list_size) == 0) {
if (num_active_channels(phy_params.channels.mask, 0,
phy_params.channels.mask_size) == 0) {
// Reactivate default channels
copy_channel_mask(phy_params.channels.mask_list,
phy_params.channels.default_mask_list,
phy_params.channels.mask_list_size);
copy_channel_mask(phy_params.channels.mask,
phy_params.channels.default_mask,
phy_params.channels.mask_size);
}
if (params->aggregate_timeoff
@ -1241,8 +1237,7 @@ bool LoRaPHY::set_next_channel(channel_selection_params_t* params,
// Search how many channels are enabled
channel_count = enabled_channel_count(params->joined, params->current_datarate,
phy_params.channels.mask_list,
phy_params.channels.mask_list_size,
phy_params.channels.mask,
enabled_channels, &delay_tx);
} else {
delay_tx++;
@ -1264,9 +1259,9 @@ bool LoRaPHY::set_next_channel(channel_selection_params_t* params,
}
// Datarate not supported by any channel, restore defaults
copy_channel_mask(phy_params.channels.mask_list,
phy_params.channels.default_mask_list,
phy_params.channels.mask_list_size);
copy_channel_mask(phy_params.channels.mask,
phy_params.channels.default_mask,
phy_params.channels.mask_size);
*time = 0;
return false;
}
@ -1338,38 +1333,29 @@ lorawan_status_t LoRaPHY::add_channel(channel_params_t* new_channel, uint8_t id)
return LORAWAN_STATUS_FREQUENCY_INVALID;
}
memcpy(&(phy_params.channels.channel_list[id]), new_channel,
sizeof(phy_params.channels.channel_list[id]));
memcpy(&(phy_params.channels.channel_list[id]), new_channel, sizeof(channel_params_t));
phy_params.channels.channel_list[id].band = new_channel->band;
// if there are multiple channel masks, i.e., there are more than 16 channels
// defined by the PHY layer, we search the channel index in all masks and
// set the appropriate bit in the appropriate mask
for (uint8_t i = 0; i < phy_params.max_channel_cnt; i ++) {
if (i == id) {
phy_params.channels.mask_list[i/16] |= (1 << (i%16));
}
}
mask_bit_set(phy_params.channels.mask, id);
return LORAWAN_STATUS_OK;
}
bool LoRaPHY::remove_channel(uint8_t channel_id)
{
if (!phy_params.custom_channelplans_supported) {
// upper layers are checking if the custom channel planning is supported or
// not. So we don't need to worry about that
if (mask_bit_test(phy_params.channels.default_mask, channel_id)) {
return false;
}
if (channel_id < phy_params.default_channel_cnt) {
return false;
}
// Remove the channel from the list of channels
const channel_params_t empty_channel = { 0, 0, { 0 }, 0 };
phy_params.channels.channel_list[channel_id] = empty_channel;
return disable_channel(phy_params.channels.mask_list, channel_id,
return disable_channel(phy_params.channels.mask, channel_id,
phy_params.max_channel_cnt);
}

54
features/lorawan/lorastack/phy/LoRaPHY.h
View File

@ -112,6 +112,27 @@ public:
*/
void calculate_backoff(backoff_params_t* backoff_params);
/**
* Tests if a channel is on or off in the channel mask
*/
inline bool mask_bit_test(const uint16_t *mask, unsigned bit) {
return mask[bit/16] & (1U << (bit % 16));
}
/**
* Tests if a channel is on or off in the channel mask
*/
inline void mask_bit_set(uint16_t *mask, unsigned bit) {
mask[bit/16] |= (1U << (bit % 16));
}
/**
* Tests if a channel is on or off in the channel mask
*/
inline void mask_bit_clear(uint16_t *mask, unsigned bit) {
mask[bit/16] &= ~(1U << (bit % 16));
}
/** Entertain a new channel request MAC command.
*
* MAC command subsystem processes the new channel request coming form
@ -407,66 +428,68 @@ protected:
* Verifies, if a datarate is available on an active channel.
*/
bool verify_channel_DR(uint8_t nbChannels, uint16_t* channelsMask, int8_t dr,
int8_t minDr, int8_t maxDr, channel_params_t* channels );
int8_t minDr, int8_t maxDr, channel_params_t* channels);
/**
* Disables a channel in a given channels mask.
*/
bool disable_channel( uint16_t* channelsMask, uint8_t id, uint8_t maxChannels );
bool disable_channel(uint16_t* channel_mask, uint8_t id, uint8_t max_channels);
/**
* Counts number of bits on in a given mask
*/
uint8_t count_bits(uint16_t mask, uint8_t nbBits);
uint8_t count_bits(uint16_t mask, uint8_t nb_bits);
/**
* Counts the number of active channels in a given channels mask.
*/
uint8_t num_active_channels(uint16_t* channelsMask, uint8_t startIdx,
uint8_t stopIdx);
uint8_t num_active_channels(uint16_t* channel_mask, uint8_t start_idx,
uint8_t stop_idx);
/**
* Copy channel masks.
*/
void copy_channel_mask(uint16_t* channelsMaskDest, uint16_t* channelsMaskSrc,
uint8_t len );
void copy_channel_mask(uint16_t* dest_mask, uint16_t* src_mask, uint8_t len);
/**
* Updates the time-offs of the bands.
*/
lorawan_time_t update_band_timeoff(bool joined, bool dutyCycle, band_t* bands,
uint8_t nbBands);
uint8_t nb_bands);
/**
* Parses the parameter of an LinkAdrRequest.
*/
uint8_t parse_link_ADR_req(uint8_t* payload, link_adr_params_t* parseLinkAdr );
uint8_t parse_link_ADR_req(uint8_t* payload, link_adr_params_t* adr_params);
/**
* Verifies and updates the datarate, the TX power and the number of repetitions
* of a LinkAdrRequest.
*/
uint8_t verify_link_ADR_req( verify_adr_params_t* verifyParams, int8_t* dr, int8_t* txPow, uint8_t* nbRep );
uint8_t verify_link_ADR_req(verify_adr_params_t* verify_params, int8_t* dr,
int8_t* tx_pow, uint8_t* nb_rep);
/**
* Computes the symbol time for LoRa modulation.
*/
double compute_symb_timeout_lora( uint8_t phyDr, uint32_t bandwidth );
double compute_symb_timeout_lora(uint8_t phy_dr, uint32_t bandwidth );
/**
* Computes the symbol time for FSK modulation.
*/
double compute_symb_timeout_fsk( uint8_t phyDr );
double compute_symb_timeout_fsk(uint8_t phy_dr);
/**
* Computes the RX window timeout and the RX window offset.
*/
void get_rx_window_params( double tSymbol, uint8_t minRxSymbols, uint32_t rxError, uint32_t wakeUpTime, uint32_t* windowTimeout, int32_t* windowOffset );
void get_rx_window_params(double t_symbol, uint8_t min_rx_symbols,
uint32_t rx_error, uint32_t wakeup_time,
uint32_t* window_timeout, int32_t* window_offset);
/**
* Computes the txPower, based on the max EIRP and the antenna gain.
*/
int8_t compute_tx_power( int8_t txPowerIndex, float maxEirp, float antennaGain );
int8_t compute_tx_power(int8_t txPowerIndex, float maxEirp, float antennaGain);
/**
* Provides a random number in the range provided.
@ -484,8 +507,7 @@ protected:
uint8_t get_bandwidth(uint8_t dr_index);
uint8_t enabled_channel_count(bool joined, uint8_t datarate,
uint16_t *mask_list, uint8_t mask_list_size,
uint8_t* enabledChannels,
const uint16_t *mask, uint8_t* enabledChannels,
uint8_t* delayTx);
};

19
features/lorawan/lorastack/phy/LoRaPHYAS923.cpp
View File

@ -252,17 +252,17 @@ LoRaPHYAS923::LoRaPHYAS923(LoRaWANTimeHandler &lora_time)
channels[1] = AS923_LC2;
// Initialize the default channel mask
default_channel_masks[0] = LC(1) + LC(2);
default_channel_mask[0] = LC(1) + LC(2);
// Update the channel mask list
copy_channel_mask(channel_masks, default_channel_masks, AS923_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, AS923_CHANNEL_MASK_SIZE);
// set default channels
phy_params.channels.channel_list = channels;
phy_params.channels.channel_list_size = AS923_MAX_NB_CHANNELS;
phy_params.channels.mask_list = channel_masks;
phy_params.channels.default_mask_list = default_channel_masks;
phy_params.channels.mask_list_size = AS923_CHANNELS_MASK_SIZE;
phy_params.channels.mask = channel_mask;
phy_params.channels.default_mask = default_channel_mask;
phy_params.channels.mask_size = AS923_CHANNEL_MASK_SIZE;
// set bands for AS923 spectrum
phy_params.bands.table = (void *) bands;
@ -344,9 +344,9 @@ bool LoRaPHYAS923::set_next_channel(channel_selection_params_t* next_channel_pra
uint8_t enabled_channels[AS923_MAX_NB_CHANNELS] = { 0 };
lorawan_time_t next_tx_delay = 0;
if (num_active_channels(channel_masks, 0, 1) == 0) {
if (num_active_channels(channel_mask, 0, 1) == 0) {
// Reactivate default channels
channel_masks[0] |= LC(1) + LC(2);
channel_mask[0] |= LC(1) + LC(2);
}
if (next_channel_prams->aggregate_timeoff <= _lora_time.get_elapsed_time(next_channel_prams->last_aggregate_tx_time)) {
@ -361,8 +361,7 @@ bool LoRaPHYAS923::set_next_channel(channel_selection_params_t* next_channel_pra
// Search how many channels are enabled
nb_enabled_channels = enabled_channel_count(next_channel_prams->joined,
next_channel_prams->current_datarate,
channel_masks,
AS923_CHANNELS_MASK_SIZE,
channel_mask,
enabled_channels, &delay_tx);
} else {
delay_tx++;
@ -402,7 +401,7 @@ bool LoRaPHYAS923::set_next_channel(channel_selection_params_t* next_channel_pra
}
// Datarate not supported by any channel, restore defaults
channel_masks[0] |= LC( 1 ) + LC( 2 );
channel_mask[0] |= LC( 1 ) + LC( 2 );
*time = 0;
return false;
}

6
features/lorawan/lorastack/phy/LoRaPHYAS923.h
View File

@ -44,7 +44,7 @@
*/
#define AS923_MAX_NB_BANDS 1
#define AS923_CHANNELS_MASK_SIZE 1
#define AS923_CHANNEL_MASK_SIZE 1
class LoRaPHYAS923 : public LoRaPHY {
@ -64,8 +64,8 @@ public:
private:
channel_params_t channels[AS923_MAX_NB_CHANNELS];
band_t bands[AS923_MAX_NB_BANDS];
uint16_t channel_masks[AS923_CHANNELS_MASK_SIZE];
uint16_t default_channel_masks[AS923_CHANNELS_MASK_SIZE];
uint16_t channel_mask[AS923_CHANNEL_MASK_SIZE];
uint16_t default_channel_mask[AS923_CHANNEL_MASK_SIZE];
};
#endif /* MBED_OS_LORAPHY_AS923_H_ */

51
features/lorawan/lorastack/phy/LoRaPHYAU915.cpp
View File

@ -245,23 +245,23 @@ LoRaPHYAU915::LoRaPHYAU915(LoRaWANTimeHandler &lora_time)
// All channels are default channels here
// Join request needs to alternate between 125 KHz and 500 KHz channels
// randomly.
default_channel_masks[0] = 0xFFFF;
default_channel_masks[1] = 0xFFFF;
default_channel_masks[2] = 0xFFFF;
default_channel_masks[3] = 0xFFFF;
default_channel_masks[4] = 0x00FF;
default_channel_mask[0] = 0xFFFF;
default_channel_mask[1] = 0xFFFF;
default_channel_mask[2] = 0xFFFF;
default_channel_mask[3] = 0xFFFF;
default_channel_mask[4] = 0x00FF;
memset(channel_masks, 0, sizeof(channel_masks));
memset(current_channel_masks, 0, sizeof(current_channel_masks));
memset(channel_mask, 0, sizeof(channel_mask));
memset(current_channel_mask, 0, sizeof(current_channel_mask));
// Copy channels default mask
copy_channel_mask(channel_masks, default_channel_masks, AU915_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, AU915_CHANNEL_MASK_SIZE);
// Copy into current channels mask
// This mask is used to keep track of the channels which were used in
// previous transmissions as the AU915 band doesn't allow concurrent
// transmission on the same channel
copy_channel_mask(current_channel_masks, channel_masks, AU915_CHANNELS_MASK_SIZE);
copy_channel_mask(current_channel_mask, channel_mask, AU915_CHANNEL_MASK_SIZE);
// set bands for EU868 spectrum
phy_params.bands.table = (void *) bands;
@ -417,12 +417,12 @@ uint8_t LoRaPHYAU915::link_ADR_request(adr_req_params_t* params,
link_adr_params_t adr_settings;
uint8_t next_index = 0;
uint8_t bytes_processed = 0;
uint16_t temp_channel_masks[AU915_CHANNELS_MASK_SIZE] = { 0, 0, 0, 0, 0};
uint16_t temp_channel_masks[AU915_CHANNEL_MASK_SIZE] = { 0, 0, 0, 0, 0};
verify_adr_params_t verify_params;
// Initialize local copy of channels mask
copy_channel_mask(temp_channel_masks, channel_masks, AU915_CHANNELS_MASK_SIZE);
copy_channel_mask(temp_channel_masks, channel_mask, AU915_CHANNEL_MASK_SIZE);
while (bytes_processed < params->payload_size) {
next_index = parse_link_ADR_req(&(params->payload[bytes_processed]),
@ -483,16 +483,16 @@ uint8_t LoRaPHYAU915::link_ADR_request(adr_req_params_t* params,
status = verify_link_ADR_req(&verify_params, &adr_settings.datarate,
&adr_settings.tx_power, &adr_settings.nb_rep);
// Update channelsMask if everything is correct
// Update cchannel mask if everything is correct
if (status == 0x07) {
// Copy Mask
copy_channel_mask(channel_masks, temp_channel_masks, AU915_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, temp_channel_masks, AU915_CHANNEL_MASK_SIZE);
current_channel_masks[0] &= channel_masks[0];
current_channel_masks[1] &= channel_masks[1];
current_channel_masks[2] &= channel_masks[2];
current_channel_masks[3] &= channel_masks[3];
current_channel_masks[4] = channel_masks[4];
current_channel_mask[0] &= channel_mask[0];
current_channel_mask[1] &= channel_mask[1];
current_channel_mask[2] &= channel_mask[2];
current_channel_mask[3] &= channel_mask[3];
current_channel_mask[4] = channel_mask[4];
}
// Update status variables
@ -544,7 +544,7 @@ int8_t LoRaPHYAU915::get_alternate_DR(uint8_t nb_trials)
int8_t datarate = 0;
// Re-enable 500 kHz default channels
channel_masks[4] = 0x00FF;
channel_mask[4] = 0x00FF;
if ((nb_trials & 0x01) == 0x01) {
datarate = DR_6;
@ -565,16 +565,16 @@ bool LoRaPHYAU915::set_next_channel(channel_selection_params_t* next_chan_params
lorawan_time_t next_tx_delay = 0;
// Count 125kHz channels
if (num_active_channels(current_channel_masks, 0, 4) == 0) {
if (num_active_channels(current_channel_mask, 0, 4) == 0) {
// Reactivate 125 kHz default channels
copy_channel_mask(current_channel_masks, channel_masks, 4);
copy_channel_mask(current_channel_mask, channel_mask, 4);
}
// Check other channels
if (next_chan_params->current_datarate >= DR_6) {
if ((current_channel_masks[4] & 0x00FF) == 0) {
if ((current_channel_mask[4] & 0x00FF) == 0) {
// fall back to 500 kHz default channels
current_channel_masks[4] = channel_masks[4];
current_channel_mask[4] = channel_mask[4];
}
}
@ -590,8 +590,7 @@ bool LoRaPHYAU915::set_next_channel(channel_selection_params_t* next_chan_params
// Search how many channels are enabled
nb_enabled_channels = enabled_channel_count(next_chan_params->joined,
next_chan_params->current_datarate,
current_channel_masks,
AU915_CHANNELS_MASK_SIZE,
current_channel_mask,
enabled_channels, &delay_tx);
} else {
delay_tx++;
@ -602,7 +601,7 @@ bool LoRaPHYAU915::set_next_channel(channel_selection_params_t* next_chan_params
// We found a valid channel
*channel = enabled_channels[get_random(0, nb_enabled_channels - 1)];
// Disable the channel in the mask
disable_channel(current_channel_masks, *channel,
disable_channel(current_channel_mask, *channel,
AU915_MAX_NB_CHANNELS - 8);
*time = 0;

12
features/lorawan/lorastack/phy/LoRaPHYAU915.h
View File

@ -46,7 +46,7 @@
*/
#define AU915_MAX_NB_BANDS 1
#define AU915_CHANNELS_MASK_SIZE 5
#define AU915_CHANNEL_MASK_SIZE 5
class LoRaPHYAU915 : public LoRaPHY{
@ -89,19 +89,19 @@ private:
band_t bands[AU915_MAX_NB_BANDS];
/*!
* LoRaMac channels mask
* LoRaMac channel mask
*/
uint16_t channel_masks[AU915_CHANNELS_MASK_SIZE];
uint16_t channel_mask[AU915_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels remaining
* Previously used channel mask
*/
uint16_t current_channel_masks[AU915_CHANNELS_MASK_SIZE];
uint16_t current_channel_mask[AU915_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels default mask
*/
uint16_t default_channel_masks[AU915_CHANNELS_MASK_SIZE];
uint16_t default_channel_mask[AU915_CHANNEL_MASK_SIZE];
};
#endif /* MBED_OS_LORAPHY_AU915_H_ */

26
features/lorawan/lorastack/phy/LoRaPHYCN470.cpp
View File

@ -219,22 +219,22 @@ LoRaPHYCN470::LoRaPHYCN470(LoRaWANTimeHandler &lora_time)
}
// Initialize the channels default mask
default_channel_masks[0] = 0xFFFF;
default_channel_masks[1] = 0xFFFF;
default_channel_masks[2] = 0xFFFF;
default_channel_masks[3] = 0xFFFF;
default_channel_masks[4] = 0xFFFF;
default_channel_masks[5] = 0xFFFF;
default_channel_mask[0] = 0xFFFF;
default_channel_mask[1] = 0xFFFF;
default_channel_mask[2] = 0xFFFF;
default_channel_mask[3] = 0xFFFF;
default_channel_mask[4] = 0xFFFF;
default_channel_mask[5] = 0xFFFF;
// Update the channels mask
copy_channel_mask(channel_masks, default_channel_masks, CN470_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, CN470_CHANNEL_MASK_SIZE);
// set default channels
phy_params.channels.channel_list = channels;
phy_params.channels.channel_list_size = CN470_MAX_NB_CHANNELS;
phy_params.channels.mask_list = channel_masks;
phy_params.channels.default_mask_list = default_channel_masks;
phy_params.channels.mask_list_size = CN470_CHANNELS_MASK_SIZE;
phy_params.channels.mask = channel_mask;
phy_params.channels.default_mask = default_channel_mask;
phy_params.channels.mask_size = CN470_CHANNEL_MASK_SIZE;
// set bands for CN470 spectrum
phy_params.bands.table = (void *) bands;
@ -398,12 +398,12 @@ uint8_t LoRaPHYCN470::link_ADR_request(adr_req_params_t* params,
link_adr_params_t adr_settings;
uint8_t next_index = 0;
uint8_t bytes_processed = 0;
uint16_t temp_channel_masks[CN470_CHANNELS_MASK_SIZE] = {0, 0, 0, 0, 0, 0};
uint16_t temp_channel_masks[CN470_CHANNEL_MASK_SIZE] = {0, 0, 0, 0, 0, 0};
verify_adr_params_t verify_params;
// Initialize local copy of channels mask
copy_channel_mask(temp_channel_masks, channel_masks, CN470_CHANNELS_MASK_SIZE);
copy_channel_mask(temp_channel_masks, channel_mask, CN470_CHANNEL_MASK_SIZE);
while(bytes_processed < params->payload_size) {
@ -467,7 +467,7 @@ uint8_t LoRaPHYCN470::link_ADR_request(adr_req_params_t* params,
// Update channelsMask if everything is correct
if (status == 0x07) {
// Copy Mask
copy_channel_mask(channel_masks, temp_channel_masks, CN470_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, temp_channel_masks, CN470_CHANNEL_MASK_SIZE);
}
// Update status variables

10
features/lorawan/lorastack/phy/LoRaPHYCN470.h
View File

@ -46,7 +46,7 @@
#define CN470_MAX_NB_BANDS 1
#define CN470_CHANNELS_MASK_SIZE 6
#define CN470_CHANNEL_MASK_SIZE 6
class LoRaPHYCN470 : public LoRaPHY {
@ -80,14 +80,14 @@ private:
band_t bands[CN470_MAX_NB_BANDS];
/*!
* LoRaMac channels mask
* LoRaMac channel mask
*/
uint16_t channel_masks[CN470_CHANNELS_MASK_SIZE];
uint16_t channel_mask[CN470_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels default mask
* LoRaMac default channel mask
*/
uint16_t default_channel_masks[CN470_CHANNELS_MASK_SIZE];
uint16_t default_channel_mask[CN470_CHANNEL_MASK_SIZE];
};
#endif /* MBED_OS_LORAPHY_CN470_H_ */

10
features/lorawan/lorastack/phy/LoRaPHYCN779.cpp
View File

@ -241,16 +241,16 @@ LoRaPHYCN779::LoRaPHYCN779(LoRaWANTimeHandler &lora_time)
channels[2] = CN779_LC3;
// Initialize the channels default mask
default_channel_masks[0] = LC(1) + LC(2) + LC(3);
default_channel_mask[0] = LC(1) + LC(2) + LC(3);
// Update the channels mask
copy_channel_mask(channel_masks, default_channel_masks, CN779_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, CN779_CHANNEL_MASK_SIZE);
// set default channels
phy_params.channels.channel_list = channels;
phy_params.channels.channel_list_size = CN779_MAX_NB_CHANNELS;
phy_params.channels.mask_list = channel_masks;
phy_params.channels.default_mask_list = default_channel_masks;
phy_params.channels.mask_list_size = CN779_CHANNELS_MASK_SIZE;
phy_params.channels.mask = channel_mask;
phy_params.channels.default_mask = default_channel_mask;
phy_params.channels.mask_size = CN779_CHANNEL_MASK_SIZE;
// set bands for CN779 spectrum
phy_params.bands.table = bands;

10
features/lorawan/lorastack/phy/LoRaPHYCN779.h
View File

@ -38,7 +38,7 @@
#define CN779_MAX_NB_BANDS 1
#define CN779_CHANNELS_MASK_SIZE 1
#define CN779_CHANNEL_MASK_SIZE 1
class LoRaPHYCN779 : public LoRaPHY {
@ -60,14 +60,14 @@ private:
band_t bands[CN779_MAX_NB_BANDS];
/*!
* LoRaMac channels mask
* LoRaMac channel mask
*/
uint16_t channel_masks[CN779_CHANNELS_MASK_SIZE];
uint16_t channel_mask[CN779_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels default mask
* LoRaMac default channel mask
*/
uint16_t default_channel_masks[CN779_CHANNELS_MASK_SIZE];
uint16_t default_channel_mask[CN779_CHANNEL_MASK_SIZE];
};
#endif /* MBED_OS_LORAPHY_CN779_H_ */

10
features/lorawan/lorastack/phy/LoRaPHYEU433.cpp
View File

@ -242,16 +242,16 @@ LoRaPHYEU433::LoRaPHYEU433(LoRaWANTimeHandler &lora_time)
channels[2] = EU433_LC3;;
// Initialize the channels default mask
default_channel_masks[0] = LC(1) + LC(2) + LC(3);
default_channel_mask[0] = LC(1) + LC(2) + LC(3);
// Update the channels mask
copy_channel_mask(channel_masks, default_channel_masks, EU433_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, EU433_CHANNEL_MASK_SIZE);
// set default channels
phy_params.channels.channel_list = channels;
phy_params.channels.channel_list_size = EU433_MAX_NB_CHANNELS;
phy_params.channels.mask_list = channel_masks;
phy_params.channels.default_mask_list = default_channel_masks;
phy_params.channels.mask_list_size = EU433_CHANNELS_MASK_SIZE;
phy_params.channels.mask = channel_mask;
phy_params.channels.default_mask = default_channel_mask;
phy_params.channels.mask_size = EU433_CHANNEL_MASK_SIZE;
// set bands for EU433 spectrum
phy_params.bands.table = bands;

10
features/lorawan/lorastack/phy/LoRaPHYEU433.h
View File

@ -44,7 +44,7 @@
*/
#define EU433_MAX_NB_BANDS 1
#define EU433_CHANNELS_MASK_SIZE 1
#define EU433_CHANNEL_MASK_SIZE 1
class LoRaPHYEU433 : public LoRaPHY {
@ -66,14 +66,14 @@ private:
band_t bands[EU433_MAX_NB_BANDS];
/*!
* LoRaMac channels mask
* LoRaMac channel mask
*/
uint16_t channel_masks[EU433_CHANNELS_MASK_SIZE];
uint16_t channel_mask[EU433_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels default mask
* LoRaMac default channel mask
*/
uint16_t default_channel_masks[EU433_CHANNELS_MASK_SIZE];
uint16_t default_channel_mask[EU433_CHANNEL_MASK_SIZE];
};

10
features/lorawan/lorastack/phy/LoRaPHYEU868.cpp
View File

@ -272,16 +272,16 @@ LoRaPHYEU868::LoRaPHYEU868(LoRaWANTimeHandler &lora_time)
channels[2] = EU868_LC3;
// Initialize the channels default mask
default_channel_masks[0] = LC(1) + LC(2) + LC(3);
default_channel_mask[0] = LC(1) + LC(2) + LC(3);
// Update the channels mask
copy_channel_mask(channel_masks, default_channel_masks, 1);
copy_channel_mask(channel_mask, default_channel_mask, 1);
// set default channels
phy_params.channels.channel_list = channels;
phy_params.channels.channel_list_size = EU868_MAX_NB_CHANNELS;
phy_params.channels.mask_list = channel_masks;
phy_params.channels.default_mask_list = default_channel_masks;
phy_params.channels.mask_list_size = EU868_CHANNELS_MASK_SIZE;
phy_params.channels.mask = channel_mask;
phy_params.channels.default_mask = default_channel_mask;
phy_params.channels.mask_size = EU868_CHANNEL_MASK_SIZE;
// set bands for EU868 spectrum
phy_params.bands.table = (void *) bands;

8
features/lorawan/lorastack/phy/LoRaPHYEU868.h
View File

@ -49,7 +49,7 @@
*/
#define EU868_MAX_NB_BANDS 6
#define EU868_CHANNELS_MASK_SIZE 1
#define EU868_CHANNEL_MASK_SIZE 1
class LoRaPHYEU868 : public LoRaPHY {
@ -71,12 +71,12 @@ private:
/*!
* LoRaMac channels mask
*/
uint16_t channel_masks[EU868_CHANNELS_MASK_SIZE];
uint16_t channel_mask[EU868_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels default mask
* LoRaMac default channel mask
*/
uint16_t default_channel_masks[EU868_CHANNELS_MASK_SIZE];
uint16_t default_channel_mask[EU868_CHANNEL_MASK_SIZE];
};
#endif /* MBED_OS_LORAPHY_EU868_H_ */

10
features/lorawan/lorastack/phy/LoRaPHYIN865.cpp
View File

@ -243,16 +243,16 @@ LoRaPHYIN865::LoRaPHYIN865(LoRaWANTimeHandler &lora_time)
channels[2] = IN865_LC3;
// Initialize the channels default mask
default_channel_masks[0] = LC(1) + LC(2) + LC(3);
default_channel_mask[0] = LC(1) + LC(2) + LC(3);
// Update the channels mask
copy_channel_mask(channel_masks, default_channel_masks, 1);
copy_channel_mask(channel_mask, default_channel_mask, 1);
// set default channels
phy_params.channels.channel_list = channels;
phy_params.channels.channel_list_size = IN865_MAX_NB_CHANNELS;
phy_params.channels.mask_list = channel_masks;
phy_params.channels.default_mask_list = default_channel_masks;
phy_params.channels.mask_list_size = IN865_CHANNELS_MASK_SIZE;
phy_params.channels.mask = channel_mask;
phy_params.channels.default_mask = default_channel_mask;
phy_params.channels.mask_size = IN865_CHANNEL_MASK_SIZE;
// set bands for IN865 spectrum
phy_params.bands.table = (void *) bands;

11
features/lorawan/lorastack/phy/LoRaPHYIN865.h
View File

@ -45,8 +45,7 @@
*/
#define IN865_MAX_NB_BANDS 1
#define IN865_CHANNELS_MASK_SIZE 1
#define IN865_CHANNEL_MASK_SIZE 1
class LoRaPHYIN865 : public LoRaPHY {
@ -70,14 +69,14 @@ private:
band_t bands[IN865_MAX_NB_BANDS];
/*!
* LoRaMac channels mask
* LoRaMac channel mask
*/
uint16_t channel_masks[IN865_CHANNELS_MASK_SIZE];
uint16_t channel_mask[IN865_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels default mask
* LoRaMac default channel mask
*/
uint16_t default_channel_masks[IN865_CHANNELS_MASK_SIZE];
uint16_t default_channel_mask[IN865_CHANNEL_MASK_SIZE];
};
#endif /* MBED_OS_LORAPHY_IN865_H_ */

28
features/lorawan/lorastack/phy/LoRaPHYKR920.cpp
View File

@ -252,16 +252,16 @@ LoRaPHYKR920::LoRaPHYKR920(LoRaWANTimeHandler &lora_time)
channels[2] = KR920_LC3;
// Initialize the channels default mask
default_channel_masks[0] = LC( 1 ) + LC( 2 ) + LC( 3 );
default_channel_mask[0] = LC( 1 ) + LC( 2 ) + LC( 3 );
// Update the channels mask
copy_channel_mask(channel_masks, default_channel_masks, KR920_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, KR920_CHANNEL_MASK_SIZE);
// set default channels
phy_params.channels.channel_list = channels;
phy_params.channels.channel_list_size = KR920_MAX_NB_CHANNELS;
phy_params.channels.mask_list = channel_masks;
phy_params.channels.default_mask_list = default_channel_masks;
phy_params.channels.mask_list_size = KR920_CHANNELS_MASK_SIZE;
phy_params.channels.mask = channel_mask;
phy_params.channels.default_mask = default_channel_mask;
phy_params.channels.mask_size = KR920_CHANNEL_MASK_SIZE;
// set bands for KR920 spectrum
phy_params.bands.table = (void *) bands;
@ -341,11 +341,11 @@ int8_t LoRaPHYKR920::get_max_eirp(uint32_t freq)
bool LoRaPHYKR920::verify_frequency(uint32_t freq)
{
uint32_t tmpFreq = freq;
uint32_t tmp_freq = freq;
_radio->lock();
if (_radio->check_rf_frequency(tmpFreq) == false) {
if (_radio->check_rf_frequency(tmp_freq) == false) {
_radio->unlock();
return false;
}
@ -354,10 +354,10 @@ bool LoRaPHYKR920::verify_frequency(uint32_t freq)
// Verify if the frequency is valid. The frequency must be in a specified
// range and can be set to specific values.
if ((tmpFreq >= 920900000) && (tmpFreq <=923300000)) {
if ((tmp_freq >= 920900000) && (tmp_freq <=923300000)) {
// Range ok, check for specific value
tmpFreq -= 920900000;
if ((tmpFreq % 200000) == 0) {
tmp_freq -= 920900000;
if ((tmp_freq % 200000) == 0) {
return true;
}
}
@ -414,9 +414,9 @@ bool LoRaPHYKR920::set_next_channel(channel_selection_params_t* params,
uint8_t enabled_channels[KR920_MAX_NB_CHANNELS] = {0};
lorawan_time_t nextTxDelay = 0;
if (num_active_channels(channel_masks, 0, 1) == 0) {
if (num_active_channels(channel_mask, 0, 1) == 0) {
// Reactivate default channels
channel_masks[0] |= LC(1) + LC(2) + LC(3);
channel_mask[0] |= LC(1) + LC(2) + LC(3);
}
if (params->aggregate_timeoff <= _lora_time.get_elapsed_time(params->last_aggregate_tx_time)) {
@ -429,7 +429,7 @@ bool LoRaPHYKR920::set_next_channel(channel_selection_params_t* params,
// Search how many channels are enabled
nb_enabled_channels = enabled_channel_count(params->joined, params->current_datarate,
channel_masks, KR920_CHANNELS_MASK_SIZE,
channel_mask,
enabled_channels, &delay_tx);
} else {
delay_tx++;
@ -472,7 +472,7 @@ bool LoRaPHYKR920::set_next_channel(channel_selection_params_t* params,
}
// Datarate not supported by any channel, restore defaults
channel_masks[0] |= LC(1) + LC(2) + LC(3);
channel_mask[0] |= LC(1) + LC(2) + LC(3);
*time = 0;
return false;
}

10
features/lorawan/lorastack/phy/LoRaPHYKR920.h
View File

@ -44,7 +44,7 @@
*/
#define KR920_MAX_NB_BANDS 1
#define KR920_CHANNELS_MASK_SIZE 1
#define KR920_CHANNEL_MASK_SIZE 1
class LoRaPHYKR920 : public LoRaPHY {
@ -82,14 +82,14 @@ private:
band_t bands[KR920_MAX_NB_BANDS];
/**
* LoRaMac channels mask
* LoRaMac channel mask
*/
uint16_t channel_masks[KR920_CHANNELS_MASK_SIZE];
uint16_t channel_mask[KR920_CHANNEL_MASK_SIZE];
/**
* LoRaMac channels default mask
* LoRaMac default channel mask
*/
uint16_t default_channel_masks[KR920_CHANNELS_MASK_SIZE];
uint16_t default_channel_mask[KR920_CHANNEL_MASK_SIZE];
};
#endif // MBED_OS_LORAPHY_KR920_H_

75
features/lorawan/lorastack/phy/LoRaPHYUS915.cpp
View File

@ -231,29 +231,29 @@ LoRaPHYUS915::LoRaPHYUS915(LoRaWANTimeHandler &lora_time)
}
// ChannelsMask
default_channel_masks[0] = 0xFFFF;
default_channel_masks[1] = 0xFFFF;
default_channel_masks[2] = 0xFFFF;
default_channel_masks[3] = 0xFFFF;
default_channel_masks[4] = 0x00FF;
default_channel_mask[0] = 0xFFFF;
default_channel_mask[1] = 0xFFFF;
default_channel_mask[2] = 0xFFFF;
default_channel_mask[3] = 0xFFFF;
default_channel_mask[4] = 0x00FF;
memset(channel_masks, 0, sizeof(channel_masks));
memset(current_channel_masks, 0, sizeof(current_channel_masks));
memset(channel_mask, 0, sizeof(channel_mask));
memset(current_channel_mask, 0, sizeof(current_channel_mask));
// Copy channels default mask
copy_channel_mask(channel_masks, default_channel_masks, US915_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, US915_CHANNEL_MASK_SIZE);
// current channel masks keep track what of the
// channels previously used, i.e., which channels should be avoided in
// next transmission
copy_channel_mask(current_channel_masks, channel_masks, US915_CHANNELS_MASK_SIZE);
copy_channel_mask(current_channel_mask, channel_mask, US915_CHANNEL_MASK_SIZE);
// set default channels
phy_params.channels.channel_list = channels;
phy_params.channels.channel_list_size = US915_MAX_NB_CHANNELS;
phy_params.channels.mask_list = channel_masks;
phy_params.channels.default_mask_list = default_channel_masks;
phy_params.channels.mask_list_size = US915_CHANNELS_MASK_SIZE;
phy_params.channels.mask = channel_mask;
phy_params.channels.default_mask = default_channel_mask;
phy_params.channels.mask_size = US915_CHANNEL_MASK_SIZE;
// set bands for US915 spectrum
phy_params.bands.table = (void *) bands;
@ -333,7 +333,7 @@ int8_t LoRaPHYUS915::limit_tx_power(int8_t tx_power, int8_t max_band_tx_power,
tx_power_out = MAX (tx_power, TX_POWER_2);
} else {
if (num_active_channels(channel_masks, 0, 4) < 50) {
if (num_active_channels(channel_mask, 0, 4) < 50) {
// Limit tx power to max 21dBm
tx_power_out = MAX (tx_power, TX_POWER_5);
}
@ -345,11 +345,11 @@ int8_t LoRaPHYUS915::limit_tx_power(int8_t tx_power, int8_t max_band_tx_power,
void LoRaPHYUS915::restore_default_channels()
{
// Copy channels default mask
copy_channel_mask(channel_masks, default_channel_masks, US915_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, US915_CHANNEL_MASK_SIZE);
for ( uint8_t i = 0; i < US915_CHANNELS_MASK_SIZE; i++ ) {
for ( uint8_t i = 0; i < US915_CHANNEL_MASK_SIZE; i++ ) {
// Copy-And the channels mask
current_channel_masks[i] &= channel_masks[i];
current_channel_mask[i] &= channel_mask[i];
}
}
@ -429,16 +429,16 @@ bool LoRaPHYUS915::tx_config(tx_config_params_t* config, int8_t* tx_power,
_radio->lock();
_radio->set_channel( channels[config->channel].frequency );
_radio->set_channel(channels[config->channel].frequency);
_radio->set_tx_config( MODEM_LORA, phy_tx_power, 0, bandwidth, phy_dr, 1, 8,
false, true, 0, 0, false, 3000 );
_radio->set_tx_config(MODEM_LORA, phy_tx_power, 0, bandwidth, phy_dr, 1, 8,
false, true, 0, 0, false, 3000);
// Setup maximum payload lenght of the radio driver
_radio->set_max_payload_length( MODEM_LORA, config->pkt_len );
_radio->set_max_payload_length(MODEM_LORA, config->pkt_len);
// Get the time-on-air of the next tx frame
*tx_toa = _radio->time_on_air( MODEM_LORA, config->pkt_len );
*tx_toa = _radio->time_on_air(MODEM_LORA, config->pkt_len);
_radio->unlock();
@ -456,12 +456,12 @@ uint8_t LoRaPHYUS915::link_ADR_request(adr_req_params_t* params,
link_adr_params_t adr_settings;
uint8_t next_idx = 0;
uint8_t bytes_processed = 0;
uint16_t temp_channel_masks[US915_CHANNELS_MASK_SIZE] = {0, 0, 0, 0, 0};
uint16_t temp_channel_masks[US915_CHANNEL_MASK_SIZE] = {0, 0, 0, 0, 0};
verify_adr_params_t verify_params;
// Initialize local copy of channels mask
copy_channel_mask(temp_channel_masks, channel_masks, US915_CHANNELS_MASK_SIZE);
copy_channel_mask(temp_channel_masks, channel_mask, US915_CHANNEL_MASK_SIZE);
while (bytes_processed < params->payload_size) {
next_idx = parse_link_ADR_req(&(params->payload[bytes_processed]),
@ -498,14 +498,11 @@ uint8_t LoRaPHYUS915::link_ADR_request(adr_req_params_t* params,
temp_channel_masks[4] = adr_settings.channel_mask;
} else if (adr_settings.ch_mask_ctrl == 5) {
// RFU
status &= 0xFE; // Channel mask KO
} else {
temp_channel_masks[adr_settings.ch_mask_ctrl] = adr_settings.channel_mask;
}
}
@ -534,13 +531,13 @@ uint8_t LoRaPHYUS915::link_ADR_request(adr_req_params_t* params,
// Update channelsMask if everything is correct
if (status == 0x07) {
// Copy Mask
copy_channel_mask(channel_masks, temp_channel_masks, US915_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, temp_channel_masks, US915_CHANNEL_MASK_SIZE);
current_channel_masks[0] &= channel_masks[0];
current_channel_masks[1] &= channel_masks[1];
current_channel_masks[2] &= channel_masks[2];
current_channel_masks[3] &= channel_masks[3];
current_channel_masks[4] = channel_masks[4];
current_channel_mask[0] &= channel_mask[0];
current_channel_mask[1] &= channel_mask[1];
current_channel_mask[2] &= channel_mask[2];
current_channel_mask[3] &= channel_mask[3];
current_channel_mask[4] = channel_mask[4];
}
// Update status variables
@ -594,7 +591,7 @@ int8_t LoRaPHYUS915::get_alternate_DR(uint8_t nb_trials)
int8_t datarate = 0;
// Re-enable 500 kHz default channels
channel_masks[4] = 0x00FF;
channel_mask[4] = 0x00FF;
if ((nb_trials & 0x01) == 0x01) {
datarate = DR_4;
@ -615,16 +612,16 @@ bool LoRaPHYUS915::set_next_channel(channel_selection_params_t* params,
lorawan_time_t next_tx_delay = 0;
// Count 125kHz channels
if (num_active_channels(current_channel_masks, 0, 4) == 0) {
if (num_active_channels(current_channel_mask, 0, 4) == 0) {
// If none of the 125 kHz Upstream channel found,
// Reactivate default channels
copy_channel_mask(current_channel_masks, channel_masks, 4);
copy_channel_mask(current_channel_mask, channel_mask, 4);
}
// Check other channels
if (params->current_datarate >= DR_4) {
if ((current_channel_masks[4] & 0x00FF ) == 0) {
current_channel_masks[4] = channel_masks[4];
if ((current_channel_mask[4] & 0x00FF ) == 0) {
current_channel_mask[4] = channel_mask[4];
}
}
@ -638,7 +635,7 @@ bool LoRaPHYUS915::set_next_channel(channel_selection_params_t* params,
// Search how many channels are enabled
nb_enabled_channels = enabled_channel_count(params->joined,
params->current_datarate,
current_channel_masks, US915_CHANNELS_MASK_SIZE,
current_channel_mask,
enabled_channels, &delay_tx);
} else {
delay_tx++;
@ -649,7 +646,7 @@ bool LoRaPHYUS915::set_next_channel(channel_selection_params_t* params,
// We found a valid channel
*channel = enabled_channels[get_random( 0, nb_enabled_channels - 1 )];
// Disable the channel in the mask
disable_channel(current_channel_masks, *channel, US915_MAX_NB_CHANNELS - 8);
disable_channel(current_channel_mask, *channel, US915_MAX_NB_CHANNELS - 8);
*time = 0;
return true;

14
features/lorawan/lorastack/phy/LoRaPHYUS915.h
View File

@ -44,7 +44,7 @@
*/
#define US915_MAX_NB_BANDS 1
#define US915_CHANNELS_MASK_SIZE 5
#define US915_CHANNEL_MASK_SIZE 5
class LoRaPHYUS915 : public LoRaPHY {
@ -94,19 +94,19 @@ private:
band_t bands[US915_MAX_NB_BANDS];
/*!
* LoRaMac channels mask
* LoRaMac channel mask
*/
uint16_t channel_masks[US915_CHANNELS_MASK_SIZE];
uint16_t channel_mask[US915_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels remaining
* Previously used channel mask
*/
uint16_t current_channel_masks[US915_CHANNELS_MASK_SIZE];
uint16_t current_channel_mask[US915_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels default mask
* LoRaMac default channel mask
*/
uint16_t default_channel_masks[US915_CHANNELS_MASK_SIZE];
uint16_t default_channel_mask[US915_CHANNEL_MASK_SIZE];
};
#endif /* MBED_OS_LORAPHY_US915_H_ */

95
features/lorawan/lorastack/phy/LoRaPHYUS915Hybrid.cpp
View File

@ -231,27 +231,27 @@ LoRaPHYUS915Hybrid::LoRaPHYUS915Hybrid(LoRaWANTimeHandler &lora_time)
}
// ChannelsMask
default_channel_masks[0] = 0x00FF;
default_channel_masks[1] = 0x0000;
default_channel_masks[2] = 0x0000;
default_channel_masks[3] = 0x0000;
default_channel_masks[4] = 0x0001;
default_channel_mask[0] = 0x00FF;
default_channel_mask[1] = 0x0000;
default_channel_mask[2] = 0x0000;
default_channel_mask[3] = 0x0000;
default_channel_mask[4] = 0x0001;
memset(channel_masks, 0, sizeof(channel_masks));
memset(current_channel_masks, 0, sizeof(current_channel_masks));
memset(channel_mask, 0, sizeof(channel_mask));
memset(current_channel_mask, 0, sizeof(current_channel_mask));
// Copy channels default mask
copy_channel_mask(channel_masks, default_channel_masks, US915_HYBRID_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, US915_HYBRID_CHANNEL_MASK_SIZE);
// Copy into channels mask remaining
copy_channel_mask(current_channel_masks, channel_masks, US915_HYBRID_CHANNELS_MASK_SIZE);
copy_channel_mask(current_channel_mask, channel_mask, US915_HYBRID_CHANNEL_MASK_SIZE);
// set default channels
phy_params.channels.channel_list = channels;
phy_params.channels.channel_list_size = US915_HYBRID_MAX_NB_CHANNELS;
phy_params.channels.mask_list = channel_masks;
phy_params.channels.default_mask_list = default_channel_masks;
phy_params.channels.mask_list_size = US915_HYBRID_CHANNELS_MASK_SIZE;
phy_params.channels.mask = channel_mask;
phy_params.channels.default_mask = default_channel_mask;
phy_params.channels.mask_size = US915_HYBRID_CHANNEL_MASK_SIZE;
// set bands for US915_HYBRID spectrum
phy_params.bands.table = (void *) bands;
@ -321,11 +321,11 @@ LoRaPHYUS915Hybrid::~LoRaPHYUS915Hybrid()
void LoRaPHYUS915Hybrid::restore_default_channels()
{
// Copy channels default mask
copy_channel_mask(channel_masks, default_channel_masks, US915_HYBRID_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, default_channel_mask, US915_HYBRID_CHANNEL_MASK_SIZE);
for (uint8_t i = 0; i < US915_HYBRID_CHANNELS_MASK_SIZE; i++) {
for (uint8_t i = 0; i < US915_HYBRID_CHANNEL_MASK_SIZE; i++) {
// Copy-And the channels mask
current_channel_masks[i] &= channel_masks[i];
current_channel_mask[i] &= channel_mask[i];
}
}
@ -366,7 +366,7 @@ bool LoRaPHYUS915Hybrid::get_next_ADR(bool restore_channel_mask, int8_t& dr_out,
adrAckReq = false;
if (restore_channel_mask) {
// Re-enable default channels
reenable_500khz_channels(channel_masks[4], channel_masks);
reenable_500khz_channels(channel_mask[4], channel_mask);
}
}
}
@ -469,12 +469,12 @@ uint8_t LoRaPHYUS915Hybrid::link_ADR_request(adr_req_params_t* params,
link_adr_params_t adr_settings;
uint8_t next_idx = 0;
uint8_t bytes_processed = 0;
uint16_t temp_channel_masks[US915_HYBRID_CHANNELS_MASK_SIZE] = {0, 0, 0, 0, 0};
uint16_t temp_channel_mask[US915_HYBRID_CHANNEL_MASK_SIZE] = {0, 0, 0, 0, 0};
verify_adr_params_t verify_params;
// Initialize local copy of channels mask
copy_channel_mask(temp_channel_masks, channel_masks, US915_HYBRID_CHANNELS_MASK_SIZE);
copy_channel_mask(temp_channel_mask, channel_mask, US915_HYBRID_CHANNEL_MASK_SIZE);
while (bytes_processed < params->payload_size) {
next_idx = parse_link_ADR_req(&(params->payload[bytes_processed]),
@ -492,35 +492,35 @@ uint8_t LoRaPHYUS915Hybrid::link_ADR_request(adr_req_params_t* params,
if (adr_settings.ch_mask_ctrl == 6) {
// Enable all 125 kHz channels
temp_channel_masks[0] = 0xFFFF;
temp_channel_masks[1] = 0xFFFF;
temp_channel_masks[2] = 0xFFFF;
temp_channel_masks[3] = 0xFFFF;
temp_channel_mask[0] = 0xFFFF;
temp_channel_mask[1] = 0xFFFF;
temp_channel_mask[2] = 0xFFFF;
temp_channel_mask[3] = 0xFFFF;
// Apply chMask to channels 64 to 71
temp_channel_masks[4] = adr_settings.channel_mask;
temp_channel_mask[4] = adr_settings.channel_mask;
} else if( adr_settings.ch_mask_ctrl == 7 ) {
// Disable all 125 kHz channels
temp_channel_masks[0] = 0x0000;
temp_channel_masks[1] = 0x0000;
temp_channel_masks[2] = 0x0000;
temp_channel_masks[3] = 0x0000;
temp_channel_mask[0] = 0x0000;
temp_channel_mask[1] = 0x0000;
temp_channel_mask[2] = 0x0000;
temp_channel_mask[3] = 0x0000;
// Apply chMask to channels 64 to 71
temp_channel_masks[4] = adr_settings.channel_mask;
temp_channel_mask[4] = adr_settings.channel_mask;
} else if( adr_settings.ch_mask_ctrl == 5 ) {
// RFU
status &= 0xFE; // Channel mask KO
} else {
temp_channel_masks[adr_settings.ch_mask_ctrl] = adr_settings.channel_mask;
temp_channel_mask[adr_settings.ch_mask_ctrl] = adr_settings.channel_mask;
}
}
// FCC 15.247 paragraph F mandates to hop on at least 2 125 kHz channels
if ((adr_settings.datarate < DR_4) &&
(num_active_channels( temp_channel_masks, 0, 4 ) < 2)) {
(num_active_channels( temp_channel_mask, 0, 4 ) < 2)) {
status &= 0xFE; // Channel mask KO
}
if( validate_channel_mask(temp_channel_masks ) == false) {
if( validate_channel_mask(temp_channel_mask ) == false) {
status &= 0xFE; // Channel mask KO
}
@ -532,7 +532,7 @@ uint8_t LoRaPHYUS915Hybrid::link_ADR_request(adr_req_params_t* params,
verify_params.current_datarate = params->current_datarate;
verify_params.current_tx_power = params->current_tx_power;
verify_params.current_nb_rep = params->current_nb_rep;
verify_params.channel_mask = temp_channel_masks;
verify_params.channel_mask = temp_channel_mask;
// Verify the parameters and update, if necessary
@ -542,13 +542,13 @@ uint8_t LoRaPHYUS915Hybrid::link_ADR_request(adr_req_params_t* params,
// Update channelsMask if everything is correct
if (status == 0x07) {
// Copy Mask
copy_channel_mask(channel_masks, temp_channel_masks, US915_HYBRID_CHANNELS_MASK_SIZE);
copy_channel_mask(channel_mask, temp_channel_mask, US915_HYBRID_CHANNEL_MASK_SIZE);
current_channel_masks[0] &= channel_masks[0];
current_channel_masks[1] &= channel_masks[1];
current_channel_masks[2] &= channel_masks[2];
current_channel_masks[3] &= channel_masks[3];
current_channel_masks[4] = channel_masks[4];
current_channel_mask[0] &= channel_mask[0];
current_channel_mask[1] &= channel_mask[1];
current_channel_mask[2] &= channel_mask[2];
current_channel_mask[3] &= channel_mask[3];
current_channel_mask[4] = channel_mask[4];
}
// Update status variables
@ -596,7 +596,7 @@ int8_t LoRaPHYUS915Hybrid::get_alternate_DR(uint8_t nb_trials)
int8_t datarate = 0;
// Re-enable 500 kHz default channels
reenable_500khz_channels(channel_masks[4], channel_masks);
reenable_500khz_channels(channel_mask[4], channel_mask);
if ((nb_trials & 0x01) == 0x01) {
datarate = DR_4;
@ -617,15 +617,15 @@ bool LoRaPHYUS915Hybrid::set_next_channel(channel_selection_params_t* params,
lorawan_time_t next_tx_delay = 0;
// Count 125kHz channels
if (num_active_channels(current_channel_masks, 0, 4) == 0) {
if (num_active_channels(current_channel_mask, 0, 4) == 0) {
// Reactivate default channels
copy_channel_mask(current_channel_masks, channel_masks, 4);
copy_channel_mask(current_channel_mask, channel_mask, 4);
}
// Check other channels
if (params->current_datarate >= DR_4) {
if ((current_channel_masks[4] & 0x00FF ) == 0) {
current_channel_masks[4] = channel_masks[4];
if ((current_channel_mask[4] & 0x00FF ) == 0) {
current_channel_mask[4] = channel_mask[4];
}
}
@ -641,8 +641,7 @@ bool LoRaPHYUS915Hybrid::set_next_channel(channel_selection_params_t* params,
// Search how many channels are enabled
nb_enabled_channels = enabled_channel_count(params->joined,
params->current_datarate,
current_channel_masks,
US915_HYBRID_CHANNELS_MASK_SIZE,
current_channel_mask,
enabled_channels, &delay_tx);
} else {
delay_tx++;
@ -654,7 +653,7 @@ bool LoRaPHYUS915Hybrid::set_next_channel(channel_selection_params_t* params,
// We found a valid channel
*channel = enabled_channels[get_random(0, nb_enabled_channels - 1)];
// Disable the channel in the mask
disable_channel(current_channel_masks, *channel, US915_HYBRID_MAX_NB_CHANNELS - 8);
disable_channel(current_channel_mask, *channel, US915_HYBRID_MAX_NB_CHANNELS - 8);
*time = 0;
return true;
@ -737,7 +736,7 @@ int8_t LoRaPHYUS915Hybrid::limit_tx_power(int8_t txPower, int8_t maxBandTxPower,
} else {
if (num_active_channels(channel_masks, 0, 4) < 50) {
if (num_active_channels(channel_mask, 0, 4) < 50) {
// Limit tx power to max 21dBm
txPowerResult = MAX(txPower, TX_POWER_5);
}
@ -753,7 +752,7 @@ bool LoRaPHYUS915Hybrid::validate_channel_mask(uint16_t* channel_masks)
uint16_t block1 = 0;
uint16_t block2 = 0;
uint8_t index = 0;
uint16_t temp_channel_masks[US915_HYBRID_CHANNELS_MASK_SIZE];
uint16_t temp_channel_masks[US915_HYBRID_CHANNEL_MASK_SIZE];
// Copy channels mask to not change the input
for (uint8_t i = 0; i < 4; i++) {

12
features/lorawan/lorastack/phy/LoRaPHYUS915Hybrid.h
View File

@ -45,7 +45,7 @@
*/
#define US915_HYBRID_MAX_NB_BANDS 1
#define US915_HYBRID_CHANNELS_MASK_SIZE 5
#define US915_HYBRID_CHANNEL_MASK_SIZE 5
class LoRaPHYUS915Hybrid : public LoRaPHY {
@ -101,17 +101,17 @@ private:
/*!
* LoRaMac channels mask
*/
uint16_t channel_masks[US915_HYBRID_CHANNELS_MASK_SIZE];
uint16_t channel_mask[US915_HYBRID_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels remaining
* Previously used channel mask
*/
uint16_t current_channel_masks[US915_HYBRID_CHANNELS_MASK_SIZE];
uint16_t current_channel_mask[US915_HYBRID_CHANNEL_MASK_SIZE];
/*!
* LoRaMac channels default mask
* LoRaMac default channel mask
*/
uint16_t default_channel_masks[US915_HYBRID_CHANNELS_MASK_SIZE];
uint16_t default_channel_mask[US915_HYBRID_CHANNEL_MASK_SIZE];
};
#endif /* MBED_OS_LORAPHY_US915HYBRID_H_ */

19
features/lorawan/lorastack/phy/lora_phy_ds.h
View File

@ -620,11 +620,11 @@ typedef enum phy_attributes__e
/*!
* The channels mask.
*/
PHY_CHANNELS_MASK,
PHY_CHANNEL_MASK,
/*!
* The channels default mask.
* The default channel mask.
*/
PHY_CHANNELS_DEFAULT_MASK,
PHY_DEFAULT_CHANNEL_MASK,
/*!
* The maximum number of supported channels.
*/
@ -633,6 +633,13 @@ typedef enum phy_attributes__e
* The channels.
*/
PHY_CHANNELS,
/*!
* The PHYs that support dynamic channel plan (non-custom)
* support do not let the user add/remove to the channel plan.
* The network guides the device for the plan. So only
* EU like regions support custom channel planning.
*/
PHY_CUSTOM_CHANNEL_PLAN_SUPPORT,
/*!
* The default value of the uplink dwell time.
*/
@ -1073,9 +1080,9 @@ typedef struct {
channel_params_t *channel_list;
uint8_t channel_list_size;
uint16_t *mask_list;
uint16_t *default_mask_list;
uint8_t mask_list_size;
uint16_t *mask;
uint16_t *default_mask;
uint8_t mask_size;
} loraphy_channels_t;

19
features/lorawan/system/lorawan_data_structures.h
View File

@ -44,6 +44,21 @@ typedef uint32_t lorawan_time_t;
#define MSG_MULTICAST_FLAG 0x04
#define MSG_PROPRIETARY_FLAG 0x08
/**
* A macro to test a if a bit is on in a channel mask or not.
*/
//#define MASK_BIT_TEST(mask, bit) (mask & (1U << bit))
//#define MASK_BIT_TEST(mask, bit) ((mask)[(bit) / 16] & (1U << ((bit) % 16)))
/**
* A macro to clear a bit in a channel mask.
*/
//#define MASK_BIT_CLEAR(mask, bit) (mask &= ~(1 << bit))
/**
* A macro to clear a bit in a channel mask.
*/
//#define MASK_BIT_SET(mask, bit) (mask |= (1 << bit))
/**
* Bit mask for message flags
*/
@ -2361,11 +2376,11 @@ typedef enum lora_events {
RX_TIMEOUT,
RX_ERROR,
JOIN_FAILURE,
} lorawan_events_t;
} lorawan_event_t;
typedef struct {
// Mandatory. Event Callback must be provided
mbed::Callback<void(lorawan_events_t)> events;
mbed::Callback<void(lorawan_event_t)> events;
// Rest are optional
// If the user do not assign these callbacks, these callbacks would return