LoRa: Struct cleanups

- Unneeded structs removed and replaced by variables in functions

Author: Antti Kauppila

features/lorawan/lorastack/mac/LoRaMac.cpp

@@ -182,7 +182,6 @@ void LoRaMac::handle_fhss_change_channel(uint8_t cur_channel)
  **************************************************************************/
 void LoRaMac::on_radio_tx_done( void )
 {
-    set_band_txdone_params_t tx_done_params;
     lorawan_time_t cur_time = _lora_time.get_current_time( );
 
     if (_device_class != CLASS_C) {
@@ -223,10 +222,7 @@ void LoRaMac::on_radio_tx_done( void )
 
     _params.last_channel_idx = _params.channel;
 
-    tx_done_params.channel = _params.channel;
-    tx_done_params.joined = _is_nwk_joined;
-    tx_done_params.last_tx_done_time = cur_time;
-    _lora_phy.set_last_tx_done(&tx_done_params);
+    _lora_phy.set_last_tx_done(_params.channel, _is_nwk_joined, cur_time);
 
     _params.timers.aggregated_last_tx_time = cur_time;
 
@@ -257,7 +253,6 @@ void LoRaMac::on_radio_rx_done(uint8_t *payload, uint16_t size, int16_t rssi,
 {
     loramac_mhdr_t mac_hdr;
     loramac_frame_ctrl_t fctrl;
-    cflist_params_t cflist;
 
     uint8_t pkt_header_len = 0;
     uint32_t address = 0;
@@ -361,11 +356,8 @@ void LoRaMac::on_radio_rx_done(uint8_t *payload, uint16_t size, int16_t rssi,
                 _params.sys_params.recv_delay1 *= 1000;
                 _params.sys_params.recv_delay2 = _params.sys_params.recv_delay1 + 1000;
 
-                cflist.payload = &_params.payload[13];
                 // Size of the regular payload is 12. Plus 1 byte MHDR and 4 bytes MIC
-                cflist.size = size - 17;
-
-                _lora_phy.apply_cf_list(&cflist);
+                _lora_phy.apply_cf_list(&_params.payload[13], size - 17);
 
                 _mlme_confirmation.status = LORAMAC_EVENT_INFO_STATUS_OK;
                 _is_nwk_joined = true;
@@ -1182,17 +1174,12 @@ lorawan_status_t LoRaMac::schedule_tx(void)
 
 void LoRaMac::calculate_backOff(uint8_t channel)
 {
-    backoff_params_t backoff_params;
+    lorawan_time_t elapsed_time = _lora_time.get_elapsed_time(_params.timers.mac_init_time);
 
-    backoff_params.joined = _is_nwk_joined;
     _params.is_dutycycle_on = MBED_CONF_LORA_DUTY_CYCLE_ON;
-    backoff_params.dc_enabled = _params.is_dutycycle_on;
-    backoff_params.channel = channel;
-    backoff_params.elapsed_time = _lora_time.get_elapsed_time(_params.timers.mac_init_time);
-    backoff_params.tx_toa = _params.timers.tx_toa;
-    backoff_params.last_tx_was_join_req = _params.is_last_tx_join_request;
 
-    _lora_phy.calculate_backoff(&backoff_params);
+    _lora_phy.calculate_backoff(_is_nwk_joined, _params.is_last_tx_join_request, _params.is_dutycycle_on,
+                                channel, elapsed_time, _params.timers.tx_toa);
 
     // Update aggregated time-off. This must be an assignment and no incremental
     // update as we do only calculate the time-off based on the last transmission

features/lorawan/lorastack/mac/LoRaMacCommand.cpp

@@ -345,11 +345,8 @@ lorawan_status_t LoRaMacCommand::process_mac_commands(uint8_t *payload, uint8_t
                 break;
             }
             case SRV_MAC_NEW_CHANNEL_REQ: {
-                new_channel_req_params_t newChannelReq;
                 channel_params_t chParam;
-
-                newChannelReq.channel_id = payload[mac_index++];
-                newChannelReq.new_channel = &chParam;
+                int8_t channel_id = payload[mac_index++];
 
                 chParam.frequency = (uint32_t) payload[mac_index++];
                 chParam.frequency |= (uint32_t) payload[mac_index++] << 8;
@@ -358,7 +355,7 @@ lorawan_status_t LoRaMacCommand::process_mac_commands(uint8_t *payload, uint8_t
                 chParam.rx1_frequency = 0;
                 chParam.dr_range.value = payload[mac_index++];
 
-                status = lora_phy.request_new_channel(&newChannelReq);
+                status = lora_phy.request_new_channel(channel_id, &chParam);
 
                 ret_value = add_mac_command(MOTE_MAC_NEW_CHANNEL_ANS, status, 0);
             }
@@ -375,44 +372,47 @@ lorawan_status_t LoRaMacCommand::process_mac_commands(uint8_t *payload, uint8_t
             }
                 break;
             case SRV_MAC_TX_PARAM_SETUP_REQ: {
-                tx_param_setup_req_t txParamSetupReq;
                 uint8_t eirpDwellTime = payload[mac_index++];
+                uint8_t ul_dwell_time;
+                uint8_t dl_dwell_time;
+                uint8_t max_eirp;
 
-                txParamSetupReq.ul_dwell_time = 0;
-                txParamSetupReq.dl_dwell_time = 0;
+                ul_dwell_time = 0;
+                dl_dwell_time = 0;
 
                 if ((eirpDwellTime & 0x20) == 0x20) {
-                    txParamSetupReq.dl_dwell_time = 1;
+                    dl_dwell_time = 1;
                 }
                 if ((eirpDwellTime & 0x10) == 0x10) {
-                    txParamSetupReq.ul_dwell_time = 1;
+                    ul_dwell_time = 1;
                 }
-                txParamSetupReq.max_eirp = eirpDwellTime & 0x0F;
+                max_eirp = eirpDwellTime & 0x0F;
 
                 // Check the status for correctness
-                if (lora_phy.accept_tx_param_setup_req(&txParamSetupReq)) {
+                if (lora_phy.accept_tx_param_setup_req(ul_dwell_time, dl_dwell_time)) {
                     // Accept command
                     mac_sys_params.uplink_dwell_time =
-                            txParamSetupReq.ul_dwell_time;
+                            ul_dwell_time;
                     mac_sys_params.downlink_dwell_time =
-                            txParamSetupReq.dl_dwell_time;
+                            dl_dwell_time;
                     mac_sys_params.max_eirp =
-                            max_eirp_table[txParamSetupReq.max_eirp];
+                            max_eirp_table[max_eirp];
                     // Add command response
                     ret_value = add_mac_command(MOTE_MAC_TX_PARAM_SETUP_ANS, 0, 0);
                 }
             }
                 break;
             case SRV_MAC_DL_CHANNEL_REQ: {
-                dl_channel_req_params_t dlChannelReq;
 
-                dlChannelReq.channel_id = payload[mac_index++];
-                dlChannelReq.rx1_frequency = (uint32_t) payload[mac_index++];
-                dlChannelReq.rx1_frequency |= (uint32_t) payload[mac_index++] << 8;
-                dlChannelReq.rx1_frequency |= (uint32_t) payload[mac_index++] << 16;
-                dlChannelReq.rx1_frequency *= 100;
+                uint8_t channel_id = payload[mac_index++];
+                uint32_t rx1_frequency;
+
+                rx1_frequency = (uint32_t) payload[mac_index++];
+                rx1_frequency |= (uint32_t) payload[mac_index++] << 8;
+                rx1_frequency |= (uint32_t) payload[mac_index++] << 16;
+                rx1_frequency *= 100;
 
-                status = lora_phy.dl_channel_request(&dlChannelReq);
+                status = lora_phy.dl_channel_request(channel_id, rx1_frequency);
 
                 ret_value = add_mac_command(MOTE_MAC_DL_CHANNEL_ANS, status, 0);
             }

features/lorawan/lorastack/phy/LoRaPHY.cpp

@@ -112,22 +112,22 @@ void LoRaPHY::handle_send(uint8_t *buf, uint8_t size)
     _radio->unlock();
 }
 
-uint8_t LoRaPHY::request_new_channel(new_channel_req_params_t* params)
+uint8_t LoRaPHY::request_new_channel(int8_t channel_id, channel_params_t* new_channel)
 {
     if (!phy_params.custom_channelplans_supported) {
         return 0;
     }
 
     uint8_t status = 0x03;
 
-    if (params->new_channel->frequency == 0) {
+    if (new_channel->frequency == 0) {
         // Remove
-        if (remove_channel(params->channel_id) == false) {
+        if (remove_channel(channel_id) == false) {
             status &= 0xFC;
         }
     } else {
 
-        switch (add_channel(params->new_channel, params->channel_id)) {
+        switch (add_channel(new_channel, channel_id)) {
             case LORAWAN_STATUS_OK:
             {
                 break;
@@ -175,7 +175,7 @@ bool LoRaPHY::verify_channel_DR(uint8_t nb_channels, uint16_t* channel_mask,
         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))) {
+                             (channels[i].dr_range.fields.max & 0x0F))) {
                 // At least 1 channel has been found we can return OK.
                 return true;
             }
@@ -247,22 +247,18 @@ void LoRaPHY::copy_channel_mask(uint16_t* dest_mask, uint16_t* src_mask, uint8_t
     }
 }
 
-void LoRaPHY::set_last_tx_done(set_band_txdone_params_t* last_tx_params)
+void LoRaPHY::set_last_tx_done(uint8_t channel, bool joined, lorawan_time_t last_tx_done_time)
 {
-    if (!last_tx_params) {
-        return;
-    }
-
     band_t *band_table = (band_t *) phy_params.bands.table;
     channel_params_t *channel_list = phy_params.channels.channel_list;
 
-    if (last_tx_params->joined == true) {
-        band_table[channel_list[last_tx_params->channel].band].last_tx_time = last_tx_params->last_tx_done_time;
+    if (joined == true) {
+        band_table[channel_list[channel].band].last_tx_time = last_tx_done_time;
         return;
     }
 
-    band_table[channel_list[last_tx_params->channel].band].last_tx_time = last_tx_params->last_tx_done_time;
-    band_table[channel_list[last_tx_params->channel].band].last_join_tx_time = last_tx_params->last_tx_done_time;
+    band_table[channel_list[channel].band].last_tx_time = last_tx_done_time;
+    band_table[channel_list[channel].band].last_join_tx_time = last_tx_done_time;
 
 }
 
@@ -692,7 +688,7 @@ bool LoRaPHY::verify_nb_join_trials(uint8_t nb_join_trials)
     return true;
 }
 
-void LoRaPHY::apply_cf_list(cflist_params_t* cf_list)
+void LoRaPHY::apply_cf_list(const uint8_t* payload, uint8_t size)
 {
     // if the underlying PHY doesn't support CF-List, ignore the request
     if (!phy_params.cflist_supported) {
@@ -703,10 +699,10 @@ void LoRaPHY::apply_cf_list(cflist_params_t* cf_list)
 
     // Setup default datarate range
     new_channel.dr_range.value = (phy_params.default_max_datarate << 4)
-                                  | phy_params.default_datarate;
+            | phy_params.default_datarate;
 
     // Size of the optional CF list
-    if (cf_list->size != 16) {
+    if (size != 16) {
         return;
     }
 
@@ -721,9 +717,9 @@ void LoRaPHY::apply_cf_list(cflist_params_t* cf_list)
          channel_id < phy_params.max_channel_cnt; i+=phy_params.default_channel_cnt, channel_id++) {
         if (channel_id < (phy_params.cflist_channel_cnt + phy_params.default_channel_cnt)) {
             // Channel frequency
-            new_channel.frequency = (uint32_t) cf_list->payload[i];
-            new_channel.frequency |= ((uint32_t) cf_list->payload[i + 1] << 8);
-            new_channel.frequency |= ((uint32_t) cf_list->payload[i + 2] << 16);
+            new_channel.frequency = (uint32_t) payload[i];
+            new_channel.frequency |= ((uint32_t) payload[i + 1] << 8);
+            new_channel.frequency |= ((uint32_t) payload[i + 2] << 16);
             new_channel.frequency *= 100;
 
             // Initialize alternative frequency to 0
@@ -1057,11 +1053,11 @@ uint8_t LoRaPHY::accept_rx_param_setup_req(rx_param_setup_req_t* params)
     return status;
 }
 
-bool LoRaPHY::accept_tx_param_setup_req(tx_param_setup_req_t *params)
+bool LoRaPHY::accept_tx_param_setup_req(uint8_t ul_dwell_time, uint8_t dl_dwell_time)
 {
     if (phy_params.accept_tx_param_setup_req) {
-        phy_params.ul_dwell_time_setting = params->ul_dwell_time;
-        phy_params.dl_dwell_time_setting = params->dl_dwell_time;
+        phy_params.ul_dwell_time_setting = ul_dwell_time;
+        phy_params.dl_dwell_time_setting = dl_dwell_time;
     }
 
     return phy_params.accept_tx_param_setup_req;
@@ -1084,7 +1080,7 @@ bool LoRaPHY::verify_frequency(uint32_t freq)
     return false;
 }
 
-uint8_t LoRaPHY::dl_channel_request(dl_channel_req_params_t* params)
+uint8_t LoRaPHY::dl_channel_request(uint8_t channel_id, uint32_t rx1_frequency)
 {
     if (!phy_params.dl_channel_req_supported) {
         return 0;
@@ -1093,18 +1089,18 @@ uint8_t LoRaPHY::dl_channel_request(dl_channel_req_params_t* params)
     uint8_t status = 0x03;
 
     // Verify if the frequency is supported
-    if (verify_frequency(params->rx1_frequency) == false) {
+    if (verify_frequency(rx1_frequency) == false) {
         status &= 0xFE;
     }
 
     // Verify if an uplink frequency exists
-    if (phy_params.channels.channel_list[params->channel_id].frequency == 0) {
+    if (phy_params.channels.channel_list[channel_id].frequency == 0) {
         status &= 0xFD;
     }
 
     // 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[channel_id].rx1_frequency = rx1_frequency;
     }
 
     return status;
@@ -1158,23 +1154,24 @@ int8_t LoRaPHY::get_alternate_DR(uint8_t nb_trials)
     return datarate;
 }
 
-void LoRaPHY::calculate_backoff(backoff_params_t* calc_backoff)
+void LoRaPHY::calculate_backoff(bool joined, bool last_tx_was_join_req, bool dc_enabled, uint8_t channel,
+                                lorawan_time_t elapsed_time, lorawan_time_t tx_toa)
 {
     band_t *band_table = (band_t *) phy_params.bands.table;
     channel_params_t *channel_list = phy_params.channels.channel_list;
 
-    uint8_t band_idx = channel_list[calc_backoff->channel].band;
+    uint8_t band_idx = channel_list[channel].band;
     uint16_t duty_cycle = band_table[band_idx].duty_cycle;
     uint16_t join_duty_cycle = 0;
 
     // Reset time-off to initial value.
     band_table[band_idx].off_time = 0;
 
-    if (calc_backoff->joined == false) {
+    if (joined == false) {
         // Get the join duty cycle
-        if (calc_backoff->elapsed_time < 3600000) {
+        if (elapsed_time < 3600000) {
             join_duty_cycle = BACKOFF_DC_1_HOUR;
-        } else if (calc_backoff->elapsed_time < (3600000 + 36000000)) {
+        } else if (elapsed_time < (3600000 + 36000000)) {
             join_duty_cycle = BACKOFF_DC_10_HOURS;
         } else {
             join_duty_cycle = BACKOFF_DC_24_HOURS;
@@ -1186,12 +1183,12 @@ void LoRaPHY::calculate_backoff(backoff_params_t* calc_backoff)
 
     // No back-off if the last frame was not a join request and when the
     // duty cycle is not enabled
-    if (calc_backoff->dc_enabled == false &&
-        calc_backoff->last_tx_was_join_req == false) {
+    if (dc_enabled == false &&
+        last_tx_was_join_req == false) {
         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 = tx_toa * duty_cycle - tx_toa;
     }
 }
 
@@ -1350,7 +1347,7 @@ bool LoRaPHY::remove_channel(uint8_t channel_id)
 
 
     // Remove the channel from the list of channels
-    const channel_params_t empty_channel = { 0, 0, { 0 }, 0 };
+    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, channel_id,