Skip to content

Commit

Permalink
FHSS: Continued fhss_structure cleaning
Browse files Browse the repository at this point in the history
  • Loading branch information
Jarkko Paso committed Feb 16, 2018
1 parent 93b7e32 commit 1ca1d0b
Show file tree
Hide file tree
Showing 15 changed files with 417 additions and 385 deletions.
285 changes: 155 additions & 130 deletions source/Service_Libs/fhss/fhss.c
View file

Large diffs are not rendered by default.

22 changes: 21 additions & 1 deletion source/Service_Libs/fhss/fhss.h
View file
Expand Up @@ -57,12 +57,31 @@ struct fhss_failed_tx
uint8_t retries_done;
ns_list_link_t link;
};
typedef NS_LIST_HEAD(fhss_failed_tx_t, link) fhss_failed_tx_list_t;


struct fhss_bs
{
uint8_t uc_channel_index;
uint8_t current_superframe;
uint8_t current_channel_index;
uint8_t own_hop;
uint8_t beacons_received_timer;
uint8_t broadcast_start_superframe;
uint8_t synch_infos_sent_counter;
bool tx_allowed;
bool send_synch_info_on_next_broadcast_channel;
bool beacon_received_on_this_bc_channel;
uint16_t channel_list_counter;
fhss_configuration_t fhss_configuration;
uint16_t synch_panid;
uint32_t synch_interval;
struct fhss_statistics *fhss_stats_ptr;
struct fhss_beacon_info *fhss_beacon_info_store;
struct fhss_configuration fhss_configuration;
struct fhss_synch_configuration synch_configuration;
struct fhss_synch_monitor synch_monitor;
fhss_failed_tx_list_t fhss_failed_tx_list;
uint8_t fhss_scramble_table[MAX_SCRAMBLE_TABLE_INDEXES];
};

fhss_structure_t *fhss_enable(fhss_api_t *fhss_api, const fhss_configuration_t *fhss_configuration, const fhss_timer_t *fhss_timer, fhss_statistics_t *fhss_statistics);
Expand All @@ -76,6 +95,7 @@ uint32_t fhss_get_tx_time(fhss_structure_t *fhss_structure, uint16_t bytes_to_se
* @return microseconds left to start of next superframe
*/
uint32_t fhss_get_remaining_time_to_next_superframe(const fhss_structure_t *fhss_struct);
int8_t fhss_set_synch_configuration(fhss_structure_t *fhss_structure, const fhss_synch_configuration_t *fhss_synch_configuration);
int fhss_set_callbacks(fhss_structure_t *fhss_structure);

#endif /* FHSS_H_ */
8 changes: 4 additions & 4 deletions source/Service_Libs/fhss/fhss_beacon.c
View file
Expand Up @@ -39,20 +39,20 @@ int fhss_beacon_update_payload(fhss_structure_t *fhss_structure,
return -1;
}

const fhss_synch_configuration_t *config = &fhss_structure->synch_configuration;
const fhss_synch_configuration_t *config = &fhss_structure->bs->synch_configuration;

payload->channel_index = fhss_structure->current_channel_index;
payload->channel_index = fhss_structure->bs->current_channel_index;

payload->sender_unicast_channel = 0;

payload->current_superframe = fhss_structure->current_superframe;
payload->current_superframe = fhss_structure->bs->current_superframe;

// This assumes that the time is always in the range of 0..2**16, which
// should be the case as the superframe length field is also in that range.
payload->remaining_slots = (uint16_t) fhss_get_remaining_time_to_next_superframe(fhss_structure);
payload->channel_list_counter = fhss_structure->bs->channel_list_counter;

payload->hop_count = fhss_structure->own_hop;
payload->hop_count = fhss_structure->bs->own_hop;
payload->number_of_broadcast_channels = config->fhss_number_of_bc_channels;
payload->number_of_tx_slots = config->fhss_number_of_tx_slots;
payload->time_since_last_beacon = 0; // XXX not available yet
Expand Down
20 changes: 10 additions & 10 deletions source/Service_Libs/fhss/fhss_beacon_tasklet.c
View file
Expand Up @@ -74,21 +74,21 @@ static void fhss_beacon_tasklet_func(arm_event_s* event)
// skip the init event as there will be a timer event after
if (event->event_type == FHSS_TIMER_EVENT) {
// Stop network when lost number of FHSS_SYNCHRONIZATION_LOST synchronization beacons from parent in a row.
if (fhss_structure->beacons_received_timer >= FHSS_SYNCHRONIZATION_LOST) {
if (fhss_structure->bs->beacons_received_timer >= FHSS_SYNCHRONIZATION_LOST) {
fhss_structure->callbacks.synch_lost_notification(fhss_structure->fhss_api);
fhss_stats_update(fhss_structure, STATS_FHSS_SYNCH_LOST, 1);
tr_err("FHSS synchronization lost");
} else {
uint16_t bc_density = (fhss_structure->number_of_channels / fhss_structure->synch_configuration.fhss_number_of_bc_channels);
uint16_t channel_dwell_time = ((uint32_t)fhss_structure->synch_configuration.fhss_superframe_length * fhss_structure->synch_configuration.fhss_number_of_superframes) / 1000;
uint16_t bc_density = (fhss_structure->number_of_channels / fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
uint16_t channel_dwell_time = ((uint32_t)fhss_structure->bs->synch_configuration.fhss_superframe_length * fhss_structure->bs->synch_configuration.fhss_number_of_superframes) / 1000;

fhss_beacon_periodic_start(fhss_structure, (bc_density * channel_dwell_time) * 2);
// Send synchronization request
fhss_structure->callbacks.send_fhss_frame(fhss_structure->fhss_api, FHSS_SYNCH_REQUEST_FRAME);
fhss_structure->beacons_received_timer++;
fhss_structure->bs->beacons_received_timer++;
#ifdef FEA_TRACE_SUPPORT
if (!fhss_get_parent_address(fhss_structure, parent_address)) {
tr_debug("Update synch, attempt: %u, %s", fhss_structure->beacons_received_timer, trace_array(parent_address, 8));
tr_debug("Update synch, attempt: %u, %s", fhss_structure->bs->beacons_received_timer, trace_array(parent_address, 8));
} else {
tr_err("No synch parent found");
}
Expand All @@ -99,9 +99,9 @@ static void fhss_beacon_tasklet_func(arm_event_s* event)
else if(event->event_type == FHSS_COMPARE_SYNCH_PARENT)
{
if (fhss_compare_with_synch_parent_address(fhss_structure, fhss_structure->synch_parent)) {
fhss_structure->synch_monitor.avg_synch_fix = 0;
if(fhss_structure->synch_monitor.avg_synch_fix_counter > 0) {
fhss_structure->synch_monitor.avg_synch_fix_counter = 0;
fhss_structure->bs->synch_monitor.avg_synch_fix = 0;
if(fhss_structure->bs->synch_monitor.avg_synch_fix_counter > 0) {
fhss_structure->bs->synch_monitor.avg_synch_fix_counter = 0;
}
// Send synchronization request
fhss_structure->callbacks.send_fhss_frame(fhss_structure->fhss_api, FHSS_SYNCH_REQUEST_FRAME);
Expand All @@ -116,8 +116,8 @@ static void fhss_beacon_tasklet_func(arm_event_s* event)
}
else if(event->event_type == FHSS_BROADCAST_CHANNEL)
{
uint16_t superframe_length = fhss_structure->synch_configuration.fhss_superframe_length;
uint8_t number_of_superframes = fhss_structure->synch_configuration.fhss_number_of_superframes;
uint16_t superframe_length = fhss_structure->bs->synch_configuration.fhss_superframe_length;
uint8_t number_of_superframes = fhss_structure->bs->synch_configuration.fhss_number_of_superframes;
// Given broadcast time is channel length minus 1 superframe
fhss_structure->callbacks.broadcast_notify(fhss_structure->fhss_api, (uint32_t)superframe_length * (number_of_superframes - 1));
}
Expand Down
56 changes: 28 additions & 28 deletions source/Service_Libs/fhss/fhss_channel.c
View file
Expand Up @@ -91,10 +91,10 @@ uint8_t fhss_add_channel_list_counter(uint8_t index, uint16_t number_of_channels
static void fhss_generate_broadcast_start_superframe(fhss_structure_t *fhss_structure)
{
// If the number of superframes is low, allow broadcast on any superframe
if (fhss_structure->synch_configuration.fhss_number_of_superframes < 8) {
fhss_structure->broadcast_start_superframe = 0;
if (fhss_structure->bs->synch_configuration.fhss_number_of_superframes < 8) {
fhss_structure->bs->broadcast_start_superframe = 0;
} else {
fhss_structure->broadcast_start_superframe = randLIB_get_random_in_range(0, NUMBER_OF_BC_START_SUPERFRAMES - 1);
fhss_structure->bs->broadcast_start_superframe = randLIB_get_random_in_range(0, NUMBER_OF_BC_START_SUPERFRAMES - 1);
}
}

Expand All @@ -113,7 +113,7 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
bool broadcast_channel = false;

uint16_t number_of_channels = fhss_structure->number_of_channels;
uint8_t number_of_broadcast_channels = fhss_structure->synch_configuration.fhss_number_of_bc_channels;
uint8_t number_of_broadcast_channels = fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels;
uint8_t unicast_channel_index = fhss_structure->bs->uc_channel_index;
uint8_t channel_index_tmp;

Expand All @@ -124,18 +124,18 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
*/
/* Get broadcast channel */
if (fhss_is_current_channel_broadcast(fhss_structure) == true) {
channel_index_tmp = fhss_calc_channel_shuffle((number_of_channels - number_of_broadcast_channels) + fhss_get_bc_index(fhss_structure), fhss_structure->number_of_channels, fhss_structure->synch_configuration.fhss_number_of_bc_channels);
channel_index_tmp = fhss_calc_channel_shuffle((number_of_channels - number_of_broadcast_channels) + fhss_get_bc_index(fhss_structure), fhss_structure->number_of_channels, fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
fhss_generate_broadcast_start_superframe(fhss_structure);
broadcast_channel = true;
} else { /* Get unicast channel */
channel_index_tmp = fhss_calc_channel_shuffle(unicast_channel_index, fhss_structure->number_of_channels, fhss_structure->synch_configuration.fhss_number_of_bc_channels);
channel_index_tmp = fhss_calc_channel_shuffle(unicast_channel_index, fhss_structure->number_of_channels, fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
if (++fhss_structure->bs->uc_channel_index >= number_of_channels - number_of_broadcast_channels) {
fhss_structure->bs->uc_channel_index = 0;
}
}
// Reset Beacon received flag when channel has changed
fhss_structure->beacon_received_on_this_bc_channel = false;
channel_index_tmp = fhss_add_channel_list_counter(channel_index_tmp, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->fhss_scramble_table);
fhss_structure->bs->beacon_received_on_this_bc_channel = false;
channel_index_tmp = fhss_add_channel_list_counter(channel_index_tmp, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->bs->fhss_scramble_table);
next_channel = channel_list_get_channel(fhss_structure->bs->fhss_configuration.channel_mask, channel_index_tmp);

fhss_structure->rx_channel = next_channel;
Expand All @@ -153,8 +153,8 @@ bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
static uint8_t fhss_get_bc_index(const fhss_structure_t *fhss_structure)
{
uint16_t number_of_channels = fhss_structure->number_of_channels;
uint8_t number_of_bc_channels = fhss_structure->synch_configuration.fhss_number_of_bc_channels;
uint8_t cur_channel_index = fhss_structure->current_channel_index;
uint8_t number_of_bc_channels = fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels;
uint8_t cur_channel_index = fhss_structure->bs->current_channel_index;

return cur_channel_index / (number_of_channels/number_of_bc_channels);
}
Expand All @@ -164,7 +164,7 @@ uint8_t fhss_get_offset(fhss_structure_t *fhss_structure, const uint8_t *ptr)
uint8_t i;
uint8_t index = *ptr++;

if (fhss_structure->number_of_channels == fhss_structure->synch_configuration.fhss_number_of_bc_channels) {
if (fhss_structure->number_of_channels == fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) {
// If all channels are defined as broadcast channels then return 0 to avoid division by 0.
// This could happen e.g. in OTA case when fast download is needed.
return 0;
Expand All @@ -176,7 +176,7 @@ uint8_t fhss_get_offset(fhss_structure_t *fhss_structure, const uint8_t *ptr)
index ^= *ptr++;
}
// Offset must be < number of unicast channels
index %= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels);
index %= (fhss_structure->number_of_channels - fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);

return index;
}
Expand All @@ -189,13 +189,13 @@ bool fhss_is_current_channel_broadcast(fhss_structure_t *fhss_structure)
}

// Should always have broadcast channels with FHSS
if (!fhss_structure->synch_configuration.fhss_number_of_bc_channels) {
if (!fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) {
return true;
}

uint8_t channel_index = fhss_structure->current_channel_index;
uint8_t channel_index = fhss_structure->bs->current_channel_index;
uint16_t number_of_channels = fhss_structure->number_of_channels;
uint8_t number_of_broadcast_channels = fhss_structure->synch_configuration.fhss_number_of_bc_channels;
uint8_t number_of_broadcast_channels = fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels;

if (!(channel_index % (number_of_channels / number_of_broadcast_channels))) {
return true;
Expand All @@ -211,14 +211,14 @@ static uint8_t fhss_get_destination_channel(fhss_structure_t *fhss_structure, ui
if (fhss_structure) {
if (fhss_is_current_channel_broadcast(fhss_structure) == false) {
destination_offset = fhss_get_offset(fhss_structure, destination_address);
uc_index = fhss_calculate_uc_index(fhss_structure->current_channel_index, fhss_structure->number_of_channels,
fhss_structure->synch_configuration.fhss_number_of_bc_channels) + destination_offset;
if (uc_index >= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels)) {
uc_index -= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels);
uc_index = fhss_calculate_uc_index(fhss_structure->bs->current_channel_index, fhss_structure->number_of_channels,
fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) + destination_offset;
if (uc_index >= (fhss_structure->number_of_channels - fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels)) {
uc_index -= (fhss_structure->number_of_channels - fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
}

uc_index = fhss_calc_channel_shuffle(uc_index, fhss_structure->number_of_channels, fhss_structure->synch_configuration.fhss_number_of_bc_channels);
uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->fhss_scramble_table);
uc_index = fhss_calc_channel_shuffle(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->bs->fhss_scramble_table);
return channel_list_get_channel(fhss_structure->bs->fhss_configuration.channel_mask, uc_index);
}
return fhss_structure->rx_channel;
Expand Down Expand Up @@ -246,21 +246,21 @@ int fhss_change_to_parent_channel(fhss_structure_t *fhss_structure)
uint8_t destination_channel;
uint8_t destination_offset;
if (fhss_structure) {
if (fhss_structure->number_of_channels != fhss_structure->synch_configuration.fhss_number_of_bc_channels) {
if (fhss_structure->number_of_channels != fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) {
uint8_t parent_address[8];
if (fhss_get_parent_address(fhss_structure, parent_address)) {
return -1;
}

destination_offset = fhss_get_offset(fhss_structure, parent_address);

uc_index = fhss_calculate_uc_index(fhss_structure->current_channel_index, fhss_structure->number_of_channels,
fhss_structure->synch_configuration.fhss_number_of_bc_channels) + destination_offset;
if (uc_index >= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels)) {
uc_index -= (fhss_structure->number_of_channels - fhss_structure->synch_configuration.fhss_number_of_bc_channels);
uc_index = fhss_calculate_uc_index(fhss_structure->bs->current_channel_index, fhss_structure->number_of_channels,
fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) + destination_offset;
if (uc_index >= (fhss_structure->number_of_channels - fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels)) {
uc_index -= (fhss_structure->number_of_channels - fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
}
uc_index = fhss_calc_channel_shuffle(uc_index, fhss_structure->number_of_channels, fhss_structure->synch_configuration.fhss_number_of_bc_channels);
uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->fhss_scramble_table);
uc_index = fhss_calc_channel_shuffle(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
uc_index = fhss_add_channel_list_counter(uc_index, fhss_structure->number_of_channels, fhss_structure->bs->channel_list_counter, fhss_structure->bs->fhss_scramble_table);
destination_channel = channel_list_get_channel(fhss_structure->bs->fhss_configuration.channel_mask, uc_index);
fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, destination_channel);
#ifdef FHSS_CHANNEL_DEBUG
Expand Down
25 changes: 0 additions & 25 deletions source/Service_Libs/fhss/fhss_common.c
View file
Expand Up @@ -93,31 +93,6 @@ int8_t fhss_set_datarate(fhss_structure_t *fhss_structure, uint32_t datarate)
return 0;
}

int8_t fhss_set_synch_configuration(fhss_structure_t *fhss_structure, const fhss_synch_configuration_t *fhss_synch_configuration)
{
if (!fhss_structure) {
return -1;
}
if (!fhss_synch_configuration) {
return -2;
}
// None of the configurations can be set zero
if( fhss_synch_configuration->fhss_number_of_bc_channels == 0 || fhss_synch_configuration->fhss_number_of_tx_slots == 0
|| fhss_synch_configuration->fhss_number_of_superframes == 0 || fhss_synch_configuration->fhss_superframe_length == 0) {
return -3;
}
// Number of channels must be divisible with the number of broadcast channels.
// Number of superframes must be divisible with the number of TX slots
if (((fhss_structure->number_of_channels % fhss_synch_configuration->fhss_number_of_bc_channels) != 0) ||
((fhss_synch_configuration->fhss_number_of_superframes % fhss_synch_configuration->fhss_number_of_tx_slots) != 0) ||
(fhss_synch_configuration->fhss_number_of_superframes <= fhss_synch_configuration->fhss_number_of_tx_slots)) {
return -4;
}
fhss_structure->synch_configuration = *fhss_synch_configuration;
fhss_structure->own_hop = 0;
return 0;
}

fhss_structure_t *fhss_get_object_with_api(const fhss_api_t *fhss_api)
{
if (!fhss_api || !fhss_struct) {
Expand Down

0 comments on commit 1ca1d0b

Please sign in to comment.