Configure TXRX slot length using given datarate (#2275)

Author: Jarkko Paso

nanostack/platform/arm_hal_phy.h

@@ -161,7 +161,8 @@ typedef enum {
     CHANNEL_PAGE_5 = 5,     ///< Page 5
     CHANNEL_PAGE_6 = 6,     ///< Page 6
     CHANNEL_PAGE_9 = 9,     ///< Page 9
-    CHANNEL_PAGE_10 = 10    ///< Page 10
+    CHANNEL_PAGE_10 = 10,   ///< Page 10
+    CHANNEL_PAGE_UNDEFINED  ///< Undefined
 } channel_page_e;
 
 /** Modulation index */

source/MAC/IEEE802_15_4/mac_defines.h

@@ -245,6 +245,7 @@ typedef struct protocol_interface_rf_mac_setup {
     uint32_t mlme_tick_count;
     uint32_t symbol_rate;
     uint32_t symbol_time_us;
+    uint32_t datarate;
     uint8_t max_ED;
     uint16_t mlme_ED_counter;
     mac_tx_status_t mac_tx_status;

source/MAC/IEEE802_15_4/mac_fhss_callbacks.c

@@ -57,8 +57,13 @@ uint32_t mac_read_phy_datarate(const fhss_api_t *fhss_api)
     if (!mac_setup) {
         return 0;
     }
-    uint32_t datarate = dev_get_phy_datarate(mac_setup->dev_driver->phy_driver, mac_setup->mac_channel_list.channel_page);
-    // If datarate is not set, use default 250kbit/s.
+    uint32_t datarate = 0;
+    // When channel page is set, ask data rate directly from PHY driver, otherwise use data rate configured to MAC. Ultimately, use default value instead 0.
+    if (mac_setup->mac_channel_list.channel_page != CHANNEL_PAGE_UNDEFINED) {
+        datarate = dev_get_phy_datarate(mac_setup->dev_driver->phy_driver, mac_setup->mac_channel_list.channel_page);
+    } else if (mac_setup->datarate) {
+        datarate = mac_setup->datarate;
+    }
     if (!datarate) {
         datarate = 250000;
     }

source/MAC/IEEE802_15_4/mac_mlme.c

@@ -783,7 +783,7 @@ int8_t mac_mlme_set_req(protocol_interface_rf_mac_setup_s *rf_mac_setup, const m
             rf_mac_setup->dev_driver->phy_driver->extension(PHY_EXTENSION_SET_RF_CONFIGURATION, (uint8_t *) set_req->value_pointer);
             mac_mlme_set_symbol_rate(rf_mac_setup);
             phy_rf_channel_configuration_s *config_params = (phy_rf_channel_configuration_s *)set_req->value_pointer;
-            (void) config_params;   // unused variable if traces disabled
+            rf_mac_setup->datarate = config_params->datarate;
             tr_info("RF config update:");
             tr_info("Frequency(ch0): %"PRIu32"Hz", config_params->channel_0_center_frequency);
             tr_info("Channel spacing: %"PRIu32"Hz", config_params->channel_spacing);
@@ -1091,6 +1091,7 @@ protocol_interface_rf_mac_setup_s *mac_mlme_data_base_allocate(uint8_t *mac64, a
     entry->aUnitBackoffPeriod = 20; //This can be different in some Platform 20 comes from 12-symbol turnaround and 8 symbol CCA read
     entry->number_of_csma_ca_periods = MAC_DEFAULT_NUMBER_OF_CSMA_PERIODS;
     entry->multi_cca_interval = MAC_DEFAULT_CSMA_MULTI_CCA_INTERVAL;
+    entry->mac_channel_list.channel_page = CHANNEL_PAGE_UNDEFINED;
 
     if (mac_sec_mib_init(entry, storage_sizes) != 0) {
         mac_mlme_data_base_deallocate(entry);

source/Service_Libs/fhss/fhss_ws.c

@@ -83,7 +83,7 @@ static void fhss_event_timer_cb(int8_t timer_id, uint16_t slots);
 static void fhss_ws_update_uc_channel_callback(fhss_structure_t *fhss_structure);
 static void fhss_unicast_handler(const fhss_api_t *fhss_api, uint16_t delay);
 static bool fhss_ws_check_tx_allowed(fhss_structure_t *fhss_structure);
-static uint32_t fhss_set_txrx_slot_length(fhss_structure_t *fhss_structure);
+static void fhss_set_txrx_slot_length(fhss_structure_t *fhss_structure);
 
 // This function supports rounding up
 static int64_t divide_integer(int64_t dividend, int32_t divisor)
@@ -150,7 +150,6 @@ fhss_structure_t *fhss_ws_enable(fhss_api_t *fhss_api, const fhss_ws_configurati
     fhss_ws_set_hop_count(fhss_struct, 0xff);
     fhss_struct->rx_channel = fhss_configuration->unicast_fixed_channel;
     fhss_struct->ws->min_synch_interval = DEFAULT_MIN_SYNCH_INTERVAL;
-    fhss_set_txrx_slot_length(fhss_struct);
     ns_list_init(&fhss_struct->fhss_failed_tx_list);
     return fhss_struct;
 }
@@ -173,14 +172,46 @@ static int fhss_ws_manage_channel_table_allocation(fhss_structure_t *fhss_struct
     return 0;
 }
 
-static uint32_t fhss_set_txrx_slot_length(fhss_structure_t *fhss_structure)
+static void fhss_set_txrx_slot_length(fhss_structure_t *fhss_structure)
 {
-    uint32_t number_of_tx_slots = ((fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) / WS_MAX_TXRX_SLOT_LEN_MS) / 2;
+    // No broadcast schedule, no TX slots
+    if (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval == 0 || fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval == 0) {
+        return;
+    }
+    uint32_t txrx_slot_length_ms_tmp = WS_TXRX_SLOT_LEN_MS;
+    if (fhss_structure->callbacks.read_datarate) {
+        /* Calculate minimum TX slot length which can fit optimal packet length twice.
+         * Twice, because 0, 1, 4, 5... hop starts transmission at the beginning of TX slot and 2, 3, 6, 7... hop at the middle of TX slot
+         *
+         * hop 0
+         * tx'ing            |    |            | |               |   |
+         * |   BC   |   RX   |   TX   |   RX   |   TX   |   RX   |   TX   |   BC   |
+         * hop 1
+         * tx'ing   |    |            | |               |   |
+         * |   BC   |   TX   |   RX   |   TX   |   RX   |   TX   |   RX   |   BC   |
+         * hop 2
+         * tx'ing                 |   |             | |               |   |
+         * |   BC   |   RX   |   TX   |   RX   |   TX   |   RX   |   TX   |   BC   |
+         * hop 3
+         * tx'ing        |   |             | |               |   |
+         * |   BC   |   TX   |   RX   |   TX   |   RX   |   TX   |   RX   |   BC   |
+         */
+        uint32_t datarate = fhss_structure->callbacks.read_datarate(fhss_structure->fhss_api);
+        if (datarate) {
+            txrx_slot_length_ms_tmp = ((OPTIMAL_PACKET_LENGTH * 2) * (8000000 / datarate)) / 1000;
+        }
+    }
+    uint32_t number_of_tx_slots = ((fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) / txrx_slot_length_ms_tmp) / 2;
     if (!number_of_tx_slots) {
-        return 0;
+        return;
     }
     fhss_structure->ws->txrx_slot_length_ms = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) / (number_of_tx_slots * 2);
-    return number_of_tx_slots;
+    tr_info("TX slot length: %"PRIu32"ms", fhss_structure->ws->txrx_slot_length_ms);
+}
+
+static uint32_t fhss_get_number_of_tx_slots(fhss_structure_t *fhss_structure)
+{
+    return ((fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) / fhss_structure->ws->txrx_slot_length_ms) / 2;
 }
 
 static int32_t fhss_ws_calc_bc_channel(fhss_structure_t *fhss_structure)
@@ -397,7 +428,7 @@ static int16_t fhss_ws_synch_state_set_callback(const fhss_api_t *api, fhss_stat
     if (fhss_state == FHSS_SYNCHRONIZED) {
         uint32_t fhss_broadcast_interval = fhss_structure->ws->fhss_configuration.fhss_broadcast_interval;
         uint8_t fhss_bc_dwell_interval = fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval;
-
+        fhss_set_txrx_slot_length(fhss_structure);
         // Start broadcast schedule when BC intervals are known
         if (fhss_broadcast_interval && fhss_bc_dwell_interval) {
             fhss_broadcast_handler(fhss_structure->fhss_api, 0);
@@ -537,17 +568,30 @@ static bool fhss_ws_check_tx_allowed(fhss_structure_t *fhss_structure)
     if (fhss_structure->ws->is_on_bc_channel == true) {
         return true;
     }
-    uint32_t number_of_tx_slots = fhss_set_txrx_slot_length(fhss_structure);
+    uint32_t number_of_tx_slots = fhss_get_number_of_tx_slots(fhss_structure);
     // Allow transmission when broadcast interval is very short comparing to MAX slot length
     if (!number_of_tx_slots) {
         return true;
     }
 
     uint32_t remaining_time_ms = get_remaining_slots_us(fhss_structure, fhss_broadcast_handler, MS_TO_US(fhss_structure->ws->fhss_configuration.fhss_broadcast_interval)) / 1000;
     uint32_t tx_slot_begin_ms = (fhss_structure->ws->fhss_configuration.fhss_broadcast_interval - fhss_structure->ws->fhss_configuration.fhss_bc_dwell_interval) - (fhss_structure->ws->txrx_slot_length_ms * (fhss_structure->own_hop & 1));
+    /* Return false when our first TX slot has not yet started
+     *         |------remaining_time_ms---|
+     *         |
+     *         v
+     * | BC | RX | TX | RX | TX | RX | TX | BC |
+     */
+    if (tx_slot_begin_ms < remaining_time_ms) {
+        return false;
+    }
     tx_slot_begin_ms = tx_slot_begin_ms - (((tx_slot_begin_ms - remaining_time_ms) / (2 * fhss_structure->ws->txrx_slot_length_ms)) * (2 * fhss_structure->ws->txrx_slot_length_ms));
     uint32_t rx_slot_begin_ms = tx_slot_begin_ms - fhss_structure->ws->txrx_slot_length_ms;
-    // Check if we are currently on TX slot.
+    /* Check if we are currently on TX slot.
+     *              |        |        |
+     *              v        v        v
+     * | BC | RX | TX | RX | TX | RX | TX | BC |
+     */
     if ((remaining_time_ms <= tx_slot_begin_ms) && (remaining_time_ms > rx_slot_begin_ms)) {
         return true;
     }

source/Service_Libs/fhss/fhss_ws.h

@@ -21,8 +21,10 @@
  * At least 4 channel retries must be used: (Initial channel + WS_NUMBER_OF_CHANNEL_RETRIES) * MAC attempts = (1+4)*4=20 attempts
  */
 #define WS_NUMBER_OF_CHANNEL_RETRIES    4
-//TX/RX slot length in milliseconds
-#define WS_MAX_TXRX_SLOT_LEN_MS         100
+// TX slot length is optimised to this packet length
+#define OPTIMAL_PACKET_LENGTH   500
+// Default TX/RX slot length in milliseconds. Is used when datarate is not given by PHY.
+#define WS_TXRX_SLOT_LEN_MS             100
 // Default minimum broadcast synchronization interval in seconds
 #define DEFAULT_MIN_SYNCH_INTERVAL      60
 // Drift compensation allowed if at least SYNCH_COMPENSATION_MIN_INTERVAL (seconds) since last synchronization