Channel Mask update ,support for excluded Channels and FHSS API pdate

Excluded Channel Parsing, write and storage support

Support for RX excluded channel information and generate active unicast channel list and keep updated that.

Support for write unicast excluded channels.

Support to store node own excluded data.

Simplify Domain / Unicast channel mask and exclude mask build operation

Seperate Unicast and Domain mask for wi-sun FHSS and integrate channel selection.

Fixed Channel Plan 1 parsing and writing.

Removed wrong channel compare we must support 1 & 0 both.

Author: Juha Heiskanen

nanostack/fhss_config.h

@@ -116,9 +116,12 @@ typedef struct fhss_ws_configuration {
     /** Broadcast fixed channel */
     uint8_t broadcast_fixed_channel;
 
-    /** Channel mask. */
+    /** Channel mask. Wi-SUN will use this for broadcast */
     uint32_t channel_mask[8];
 
+    /** Wi-SUN specific unicast channel mask */
+    uint32_t unicast_channel_mask[8];
+
     /** Vendor defined channel function. */
     fhss_vendor_defined_cf *vendor_defined_cf;
 

nanostack/fhss_ws_extension.h

@@ -30,6 +30,14 @@
 extern "C" {
 #endif
 
+/**
+ * @brief ws_channel_mask_t WS neighbour supported channel mask
+ */
+typedef struct ws_channel_mask {
+    uint16_t channel_count;                     /**<active channels at mask */
+    uint32_t channel_mask[8];                   /**< Supported channels */
+} ws_channel_mask_t;
+
 /**
  * @brief unicast_timing_info Unicast timing/hopping schedule information structure.
  */
@@ -64,6 +72,7 @@ typedef struct fhss_ws_neighbor_timing_info {
     uint8_t timing_accuracy;                    /**< Neighbor timing accuracy */
     unicast_timing_info_t uc_timing_info;       /**< Neighbor unicast timing info */
     broadcast_timing_info_t bc_timing_info;     /**< Neighbor broadcast timing info */
+    ws_channel_mask_t uc_channel_list;          /**< Neighbor Unicast channel list */
     uint32_t *excluded_channels;                /**< Neighbor excluded channels (bit mask) */
 } fhss_ws_neighbor_timing_info_t;
 

source/6LoWPAN/ws/ws_bootstrap.c

@@ -417,7 +417,6 @@ static fhss_ws_neighbor_timing_info_t *ws_get_neighbor_info(const fhss_api_t *ap
 }
 static void ws_bootstrap_llc_hopping_update(struct protocol_interface_info_entry *cur, const fhss_ws_configuration_t *fhss_configuration)
 {
-    memcpy(cur->ws_info->hopping_schdule.channel_mask, fhss_configuration->channel_mask, sizeof(uint32_t) * 8);
     cur->ws_info->hopping_schdule.uc_fixed_channel = fhss_configuration->unicast_fixed_channel;
     cur->ws_info->hopping_schdule.bc_fixed_channel = fhss_configuration->broadcast_fixed_channel;
     // Read UC channel function from WS info because FHSS might be temporarily configured to fixed channel during discovery.
@@ -429,19 +428,80 @@ static void ws_bootstrap_llc_hopping_update(struct protocol_interface_info_entry
     cur->ws_info->hopping_schdule.fhss_bsi = fhss_configuration->bsi;
 }
 
+static uint8_t ws_generate_exluded_channel_list_from_active_channels(ws_excluded_channel_data_t *excluded_data, const uint32_t *selected_channel_mask, uint16_t number_of_channels)
+{
+    bool active_range = false;
+
+    //Clear Old Data
+    memset(excluded_data, 0, sizeof(ws_excluded_channel_data_t));
+
+    for (uint8_t i = 0; i < number_of_channels; i++) {
+        if (selected_channel_mask[0 + (i / 32)] & (1 << (i % 32))) {
+            if (active_range) {
+                //Mark range stop here
+                active_range = false;
+            }
+        } else {
+            //Mark excluded channel
+            //Swap Order already here
+            excluded_data->channel_mask[0 + (i / 32)] |= 1 << (31 - (i % 32));
+            excluded_data->excluded_channel_count++;
+
+            if (excluded_data->excluded_range_length < WS_EXCLUDED_MAX_RANGE_TO_SEND) {
+                if (!active_range) {
+                    excluded_data->excluded_range_length++;
+                    active_range = true;
+                    //Set start channel
+                    excluded_data->exluded_range[excluded_data->excluded_range_length - 1].range_start = i;
+                } else {
+                    excluded_data->exluded_range[excluded_data->excluded_range_length - 1].range_end = i;
+                }
+            }
+        }
+    }
+
+    excluded_data->channel_mask_bytes_inline = ((number_of_channels + 7) / 8);
+
+    uint8_t channel_plan = 0;
+    if (excluded_data->excluded_range_length == 0) {
+        excluded_data->excuded_channel_ctrl = WS_EXC_CHAN_CTRL_NONE;
+    } else if (excluded_data->excluded_range_length <= WS_EXCLUDED_MAX_RANGE_TO_SEND) {
+
+        uint8_t range_length = (excluded_data->excluded_range_length * 4) + 3;
+        if (range_length <= ((number_of_channels + 7) / 8) + 6) {
+            excluded_data->excuded_channel_ctrl = WS_EXC_CHAN_CTRL_RANGE;
+        } else {
+            excluded_data->excuded_channel_ctrl = WS_EXC_CHAN_CTRL_BITMASK;
+            channel_plan = 1;
+        }
+    } else {
+        excluded_data->excuded_channel_ctrl = WS_EXC_CHAN_CTRL_BITMASK;
+        channel_plan = 1;
+    }
+    tr_debug("Excluded ctrl %u, exluded channel count %u, total domain channels %u", excluded_data->excuded_channel_ctrl, excluded_data->excluded_channel_count, number_of_channels);
+    return channel_plan;
+}
+
+static void ws_fhss_configure_channel_masks(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration)
+{
+    ws_generate_channel_list(fhss_configuration->channel_mask, cur->ws_info->hopping_schdule.number_of_channels, cur->ws_info->hopping_schdule.regulatory_domain);
+    ws_generate_channel_list(fhss_configuration->unicast_channel_mask, cur->ws_info->hopping_schdule.number_of_channels, cur->ws_info->hopping_schdule.regulatory_domain);
+    // using bitwise AND operation for user set channel mask to remove channels not allowed in this device
+    for (uint8_t n = 0; n < 8; n++) {
+        fhss_configuration->unicast_channel_mask[n] &= cur->ws_info->cfg->fhss.fhss_channel_mask[n];
+    }
+    //Update Exluded channels
+    cur->ws_info->hopping_schdule.channel_plan = ws_generate_exluded_channel_list_from_active_channels(&cur->ws_info->hopping_schdule.excluded_channels, fhss_configuration->unicast_channel_mask, cur->ws_info->hopping_schdule.number_of_channels);
+}
+
 static int8_t ws_fhss_initialize(protocol_interface_info_entry_t *cur)
 {
     fhss_api_t *fhss_api = ns_sw_mac_get_fhss_api(cur->mac_api);
+    fhss_ws_configuration_t fhss_configuration;
+    memset(&fhss_configuration, 0, sizeof(fhss_ws_configuration_t));
     if (!fhss_api) {
         // When FHSS doesn't exist yet, create one
-        fhss_ws_configuration_t fhss_configuration;
-        memset(&fhss_configuration, 0, sizeof(fhss_ws_configuration_t));
-        ws_generate_channel_list(fhss_configuration.channel_mask, cur->ws_info->hopping_schdule.number_of_channels, cur->ws_info->hopping_schdule.regulatory_domain);
-
-        // using bitwise AND operation for user set channel mask to remove channels not allowed in this device
-        for (uint8_t n = 0; n < 8; n++) {
-            fhss_configuration.channel_mask[n] &= cur->ws_info->cfg->fhss.fhss_channel_mask[n];
-        }
+        ws_fhss_configure_channel_masks(cur, &fhss_configuration);
 
         fhss_configuration.fhss_uc_dwell_interval = cur->ws_info->cfg->fhss.fhss_uc_dwell_interval;
         fhss_configuration.ws_uc_channel_function = (fhss_ws_channel_functions)cur->ws_info->cfg->fhss.fhss_uc_channel_function;
@@ -456,22 +516,27 @@ static int8_t ws_fhss_initialize(protocol_interface_info_entry_t *cur)
         ns_sw_mac_fhss_register(cur->mac_api, fhss_api);
     } else {
         // Read defaults from the configuration to help FHSS testing
-        const fhss_ws_configuration_t *fhss_configuration = ns_fhss_ws_configuration_get(fhss_api);
-        if (!fhss_configuration) {
+        const fhss_ws_configuration_t *fhss_configuration_copy = ns_fhss_ws_configuration_get(fhss_api);
+        if (!fhss_configuration_copy) {
             // no configuration set yet
             return 0;
         }
-        memcpy(cur->ws_info->cfg->fhss.fhss_channel_mask, fhss_configuration->channel_mask, sizeof(uint32_t) * 8);
-        cur->ws_info->cfg->fhss.fhss_uc_channel_function = fhss_configuration->ws_uc_channel_function;
-        cur->ws_info->cfg->fhss.fhss_bc_channel_function = fhss_configuration->ws_bc_channel_function;
-        cur->ws_info->cfg->fhss.fhss_bc_dwell_interval = fhss_configuration->fhss_bc_dwell_interval;
-        cur->ws_info->cfg->fhss.fhss_bc_interval = fhss_configuration->fhss_broadcast_interval;
-        cur->ws_info->cfg->fhss.fhss_uc_dwell_interval = fhss_configuration->fhss_uc_dwell_interval;
-        cur->ws_info->cfg->fhss.fhss_bc_fixed_channel = fhss_configuration->broadcast_fixed_channel;
-        cur->ws_info->cfg->fhss.fhss_uc_fixed_channel = fhss_configuration->unicast_fixed_channel;
+        fhss_configuration = *fhss_configuration_copy;
+        memcpy(cur->ws_info->cfg->fhss.fhss_channel_mask, fhss_configuration_copy->unicast_channel_mask, sizeof(uint32_t) * 8);
+        cur->ws_info->cfg->fhss.fhss_uc_channel_function = fhss_configuration_copy->ws_uc_channel_function;
+        cur->ws_info->cfg->fhss.fhss_bc_channel_function = fhss_configuration_copy->ws_bc_channel_function;
+        cur->ws_info->cfg->fhss.fhss_bc_dwell_interval = fhss_configuration_copy->fhss_bc_dwell_interval;
+        cur->ws_info->cfg->fhss.fhss_bc_interval = fhss_configuration_copy->fhss_broadcast_interval;
+        cur->ws_info->cfg->fhss.fhss_uc_dwell_interval = fhss_configuration_copy->fhss_uc_dwell_interval;
+        cur->ws_info->cfg->fhss.fhss_bc_fixed_channel = fhss_configuration_copy->broadcast_fixed_channel;
+        cur->ws_info->cfg->fhss.fhss_uc_fixed_channel = fhss_configuration_copy->unicast_fixed_channel;
+        ws_fhss_configure_channel_masks(cur, &fhss_configuration);
+        ns_fhss_ws_configuration_set(fhss_api, &fhss_configuration);
     }
+
     return 0;
 }
+
 static int8_t ws_fhss_set_defaults(protocol_interface_info_entry_t *cur, fhss_ws_configuration_t *fhss_configuration)
 {
     fhss_configuration->fhss_uc_dwell_interval = cur->ws_info->cfg->fhss.fhss_uc_dwell_interval;
@@ -483,12 +548,6 @@ static int8_t ws_fhss_set_defaults(protocol_interface_info_entry_t *cur, fhss_ws
         fhss_configuration->unicast_fixed_channel = cur->ws_info->cfg->fhss.fhss_uc_fixed_channel;
     }
     fhss_configuration->broadcast_fixed_channel = cur->ws_info->cfg->fhss.fhss_bc_fixed_channel;
-    ws_generate_channel_list(fhss_configuration->channel_mask, cur->ws_info->hopping_schdule.number_of_channels, cur->ws_info->hopping_schdule.regulatory_domain);
-
-    // using bitwise AND operation for user set channel mask to remove channels not allowed in this device
-    for (uint8_t n = 0; n < 8; n++) {
-        fhss_configuration->channel_mask[n] &= cur->ws_info->cfg->fhss.fhss_channel_mask[n];
-    }
     return 0;
 }
 static int8_t ws_fhss_border_router_configure(protocol_interface_info_entry_t *cur)
@@ -501,6 +560,7 @@ static int8_t ws_fhss_border_router_configure(protocol_interface_info_entry_t *c
         memcpy(&fhss_configuration, ns_fhss_ws_configuration_get(cur->ws_info->fhss_api), sizeof(fhss_ws_configuration_t));
     }
     ws_fhss_set_defaults(cur, &fhss_configuration);
+    ws_fhss_configure_channel_masks(cur, &fhss_configuration);
     ns_fhss_ws_configuration_set(cur->ws_info->fhss_api, &fhss_configuration);
     ws_bootstrap_llc_hopping_update(cur, &fhss_configuration);
 
@@ -525,6 +585,7 @@ static int8_t ws_fhss_configure(protocol_interface_info_entry_t *cur, bool disco
     if (ns_fhss_ws_configuration_get(cur->ws_info->fhss_api)) {
         memcpy(&fhss_configuration, ns_fhss_ws_configuration_get(cur->ws_info->fhss_api), sizeof(fhss_ws_configuration_t));
         ws_fhss_set_defaults(cur, &fhss_configuration);
+        ws_fhss_configure_channel_masks(cur, &fhss_configuration);
     }
     // Discovery is done using fixed channel
     if (discovery) {
@@ -907,12 +968,54 @@ static parent_info_t *ws_bootstrap_candidate_parent_get_best(protocol_interface_
     return ns_list_get_first(&cur->ws_info->parent_list_reserved);
 }
 
+static void ws_bootstrap_decode_exclude_range_to_mask_by_range(void *mask_buffer, ws_excluded_channel_range_t *range_info, uint16_t number_of_channels)
+{
+    uint16_t range_start, range_stop;
+    uint8_t mask_index = 0;
+    //uint8_t channel_index = 0;
+    uint8_t *range_ptr = range_info->range_start;
+    uint32_t *mask_ptr = mask_buffer;
+    while (range_info->number_of_range) {
+        range_start = common_read_16_bit_inverse(range_ptr);
+        range_ptr += 2;
+        range_stop = common_read_16_bit_inverse(range_ptr);
+        range_ptr += 2;
+        range_info->number_of_range--;
+        for (uint16_t channel = 0; channel < number_of_channels; channel++) {
+
+            if (channel && (channel % 32 == 0)) {
+                mask_index++;
+                //channel_index = 0;
+            }
+            if (channel >= range_start && channel <= range_stop) {
+                //mask_ptr[mask_index] |= 1 << (31 - channel_index);
+                mask_ptr[0 + (channel / 32)] |= 1 << (31 - (channel % 32));
+            } else if (channel > range_stop) {
+                break;
+            }
+        }
+    }
+}
+
 static void ws_bootstrap_candidate_parent_store(parent_info_t *parent, const struct mcps_data_ind_s *data, ws_utt_ie_t *ws_utt, ws_us_ie_t *ws_us, ws_pan_information_t *pan_information)
 {
     parent->ws_utt = *ws_utt;
     // Saved from unicast IE
     parent->ws_us = *ws_us;
 
+    //copy excluded channel here if it is inline
+    if (ws_us->excluded_channel_ctrl == WS_EXC_CHAN_CTRL_RANGE) {
+        memset(parent->excluded_channel_data, 0, 32);
+        //Decode Range to mask here
+        ws_bootstrap_decode_exclude_range_to_mask_by_range(parent->excluded_channel_data, &parent->ws_us.excluded_channels.range, 256);
+        parent->ws_us.excluded_channels.mask.channel_mask = parent->excluded_channel_data;
+        parent->ws_us.excluded_channels.mask.mask_len_inline = 32;
+        parent->ws_us.excluded_channel_ctrl = WS_EXC_CHAN_CTRL_BITMASK;
+    } else if (ws_us->excluded_channel_ctrl == WS_EXC_CHAN_CTRL_BITMASK) {
+        parent->ws_us.excluded_channels.mask.channel_mask = parent->excluded_channel_data;
+        memcpy(parent->excluded_channel_data, ws_us->excluded_channels.mask.channel_mask, ws_us->excluded_channels.mask.mask_len_inline);
+    }
+
     // Saved from Pan information, do not overwrite pan_version as it is not valid here
     parent->pan_information.pan_size = pan_information->pan_size;
     parent->pan_information.routing_cost = pan_information->routing_cost;
@@ -1099,6 +1202,13 @@ static void ws_bootstrap_pan_advertisement_analyse(struct protocol_interface_inf
         return;
     }
 
+    if (ws_us->excluded_channel_ctrl) {
+        //Validate that we can storage data
+        if (ws_us->excluded_channel_ctrl == WS_EXC_CHAN_CTRL_BITMASK && ws_us->excluded_channels.mask.mask_len_inline > 32) {
+            return;
+        }
+    }
+
     // Check pan flags so that it is valid
     if (!pan_information.rpl_routing_method) {
         // NOT RPL routing
@@ -1415,11 +1525,6 @@ static void ws_bootstrap_asynch_ind(struct protocol_interface_info_entry *cur, c
         return;
     }
 
-    //Compare Unicast channel Plan
-    if (ws_us.channel_plan != cur->ws_info->hopping_schdule.channel_plan) {
-        return;
-    }
-
     if (ws_us.channel_plan == 0) {
         if (!ws_channel_plan_zero_compare(&ws_us.plan.zero, &cur->ws_info->hopping_schdule)) {
             return;

source/6LoWPAN/ws/ws_common.c

@@ -203,8 +203,6 @@ int8_t ws_common_regulatory_domain_config(protocol_interface_info_entry_t *cur,
     }
 
     if (cur) {
-        // Note: doesn't work for Brazil region
-        ws_generate_channel_list(hopping_schdule->channel_mask, hopping_schdule->number_of_channels, hopping_schdule->regulatory_domain);
         ws_set_domain_rf_config(cur);
     }
     return 0;
@@ -293,9 +291,9 @@ int8_t ws_common_allocate_and_init(protocol_interface_info_entry_t *cur)
     // Timing accuracy is given from 0 to 2.55msec with 10usec resolution
     cur->ws_info->hopping_schdule.timing_accurancy = 100;
     ws_common_regulatory_domain_config(cur, &cur->ws_info->hopping_schdule);
-
     cur->ws_info->pending_key_index_info.state = NO_PENDING_PROCESS;
 
+
     return 0;
 }
 

source/6LoWPAN/ws/ws_common.h

@@ -35,6 +35,7 @@ extern uint16_t test_max_child_count_override;
 
 struct ws_pan_information_s;
 struct ws_neighbor_class_s;
+struct ws_excluded_channel_data_s;
 struct ws_cfg_s;
 
 typedef struct parent_info_s {
@@ -47,6 +48,7 @@ typedef struct parent_info_s {
     ws_us_ie_t           ws_us;
     uint32_t             timestamp;          /**< Timestamp when packet was received */
     uint32_t             age;          /**< Age of entry in 100ms ticks */
+    uint8_t              excluded_channel_data[32]; //Channel mask Max length and it accept 8 different range
     ns_list_link_t       link;
 } parent_info_t;