mirror of https://github.com/ARMmbed/mbed-os.git
297 lines
13 KiB
C
297 lines
13 KiB
C
/*
|
|
* Copyright (c) 2016-2018, Arm Limited and affiliates.
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
#include "nsconfig.h"
|
|
#include "ns_types.h"
|
|
#include "fhss_api.h"
|
|
#include "fhss_config.h"
|
|
#include "fhss.h"
|
|
#include "fhss_common.h"
|
|
#include "fhss_channel.h"
|
|
#include "channel_list.h"
|
|
#include "randLIB.h"
|
|
#include "ns_trace.h"
|
|
|
|
#define TRACE_GROUP "fhss"
|
|
|
|
#ifdef FHSS_CHANNEL_DEBUG_CBS
|
|
void (*fhss_uc_switch)(void) = NULL;
|
|
void (*fhss_bc_switch)(void) = NULL;
|
|
#endif /*FHSS_CHANNEL_DEBUG_CBS*/
|
|
|
|
#ifdef FHSS_CHANNEL_DEBUG
|
|
uint8_t debug_destination_channel = 0;
|
|
#endif /*FHSS_CHANNEL_DEBUG*/
|
|
|
|
static uint8_t fhss_get_bc_index(const fhss_structure_t *fhss_structure);
|
|
|
|
uint8_t fhss_calc_channel_shuffle(uint8_t index, uint16_t number_of_channels, uint8_t number_of_broadcast_channels)
|
|
{
|
|
/* To break the ...1, 2, 3, 4,... hopping sequence and to spread broadcast channels equally on frequency band.
|
|
*
|
|
* Also to randomise the sequence, for Unicast channels:
|
|
* - Even indexes are divided by 2
|
|
* - Odd indexes are divided by 2 and result is subtracted from highest Unicast index (which is (number_of_channels-number_of_broadcast_channels) - 1)
|
|
*
|
|
*
|
|
* Example:
|
|
* Hopping sequence: Without Unicast randomising: With Unicast randomising:
|
|
* 0, 1, 2, 3, 0, 4, 8, 12, 0, 14, 4, 10,
|
|
* 4, 5, 6, 7, 1, 5, 9, 13, 8, 6, 12, 2,
|
|
* 8, 9, 10, 11, 2, 6, 10, 14, 1, 13, 5, 9,
|
|
* 12, 13, 14, 15 3, 7, 11, 15, 3, 7, 11, 15,
|
|
*
|
|
* If number of broadcast channels is 4 (last 4 indexes 3, 7, 11, 15), the hopping sequence is: 3, 0, 14, 4, 7, 10, 8, 6, 11, 12, 2, 1, 15, 13, 5, 9
|
|
*/
|
|
#ifndef DISABLE_CHANNEL_SHUFFLE
|
|
// Unicast randomising
|
|
if (index < (number_of_channels - number_of_broadcast_channels)) {
|
|
if (!(index % 2)) {
|
|
index /= 2;
|
|
} else {
|
|
index = ((number_of_channels - number_of_broadcast_channels) - 1) - (index / 2);
|
|
}
|
|
}
|
|
// Spread Broadcast channels
|
|
index = (index % number_of_broadcast_channels) * (number_of_channels / number_of_broadcast_channels) + (index / number_of_broadcast_channels);
|
|
#endif /*DISABLE_CHANNEL_SHUFFLE*/
|
|
return index;
|
|
}
|
|
|
|
uint8_t fhss_add_channel_list_counter(uint8_t index, uint16_t number_of_channels, uint16_t channel_list_counter, uint8_t *scramble_table)
|
|
{
|
|
/* To avoid repeating same channel list constantly, channel list counter is added to given index*/
|
|
#ifndef DISABLE_CHANNEL_COUNTER
|
|
|
|
/* Break repeating cycle when channel list counter reaches the number of channels.
|
|
* Using known channel list counter and generated scramble table, create pseudo-random index that changes the repeated cycle longer.
|
|
* All channels are equally used as broadcast and unicast channels
|
|
*
|
|
* If number of channels is 50, number of scramble table indexes is 10 and channel dwell time is 400ms, the repeated cycle starts from beginning after 50 * 50 * 10 * 400ms = 166min
|
|
*/
|
|
uint32_t index_tmp;
|
|
uint8_t calc_tmp = (channel_list_counter / number_of_channels) % MAX_SCRAMBLE_TABLE_INDEXES;
|
|
index_tmp = (uint32_t) channel_list_counter * scramble_table[calc_tmp];
|
|
|
|
index_tmp += index;
|
|
index_tmp %= number_of_channels;
|
|
index = index_tmp;
|
|
#endif /*DISABLE_CHANNEL_COUNTER*/
|
|
return index;
|
|
}
|
|
|
|
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->bs->synch_configuration.fhss_number_of_superframes < 8) {
|
|
fhss_structure->bs->broadcast_start_superframe = 0;
|
|
} else {
|
|
fhss_structure->bs->broadcast_start_superframe = randLIB_get_random_in_range(0, NUMBER_OF_BC_START_SUPERFRAMES - 1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update channel
|
|
*
|
|
* This function is called by superframe handler on first(0) superframe
|
|
* of every channel to resolve and change new channel.
|
|
*
|
|
* @param cur network interface to work on
|
|
* @return true if changed to broadcast channel, false otherwise
|
|
*/
|
|
bool fhss_change_to_next_channel(fhss_structure_t *fhss_structure)
|
|
{
|
|
int next_channel;
|
|
bool broadcast_channel = false;
|
|
|
|
uint16_t number_of_channels = fhss_structure->number_of_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;
|
|
|
|
/* Get the channel number using channel index. Latter (number_of_broadcast_channels) indexes in channel table are broadcast channels and
|
|
* first (number_of_channels - number_of_broadcast_channels) are unicast channels.
|
|
* In channel hopping sequence, every (number_of_channels / number_of_broadcast_channels) channel is broadcast channel and
|
|
* channel hopping sequence is e.g. |uc0|uc1|uc2|bc0|uc3|uc4|uc5|bc1|uc6|...
|
|
*/
|
|
/* 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->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->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->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;
|
|
|
|
if (fhss_is_current_channel_broadcast(fhss_structure) == true) {
|
|
#ifdef FHSS_CHANNEL_DEBUG
|
|
tr_info("%"PRIu32" BC %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), next_channel);
|
|
#endif /*FHSS_CHANNEL_DEBUG*/
|
|
} else {
|
|
#ifdef FHSS_CHANNEL_DEBUG_CBS
|
|
if (fhss_uc_switch) {
|
|
fhss_uc_switch();
|
|
}
|
|
#endif /*FHSS_CHANNEL_DEBUG_CBS*/
|
|
#ifdef FHSS_CHANNEL_DEBUG
|
|
tr_info("%"PRIu32" UC %u", fhss_structure->platform_functions.fhss_get_timestamp(fhss_structure->fhss_api), next_channel);
|
|
#endif /*FHSS_CHANNEL_DEBUG*/
|
|
}
|
|
|
|
fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, next_channel);
|
|
return broadcast_channel;
|
|
}
|
|
|
|
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->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);
|
|
}
|
|
|
|
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->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;
|
|
}
|
|
|
|
// Offset to unicast channel index is calculated using XOR operation
|
|
for (i = 0; i < 7; i++) {
|
|
index ^= *ptr++;
|
|
}
|
|
// Offset must be < number of unicast channels
|
|
index %= (fhss_structure->number_of_channels - fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels);
|
|
|
|
return index;
|
|
}
|
|
|
|
bool fhss_is_current_channel_broadcast(fhss_structure_t *fhss_structure)
|
|
{
|
|
// Every channel is broadcast channel when FHSS is not enabled
|
|
if (!fhss_structure) {
|
|
return true;
|
|
}
|
|
|
|
// Should always have broadcast channels with FHSS
|
|
if (!fhss_structure->bs->synch_configuration.fhss_number_of_bc_channels) {
|
|
return true;
|
|
}
|
|
|
|
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->bs->synch_configuration.fhss_number_of_bc_channels;
|
|
|
|
if (!(channel_index % (number_of_channels / number_of_broadcast_channels))) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static uint8_t fhss_get_destination_channel(fhss_structure_t *fhss_structure, uint8_t *destination_address)
|
|
{
|
|
uint8_t destination_offset;
|
|
uint8_t uc_index;
|
|
|
|
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->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->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;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int fhss_change_to_tx_channel(fhss_structure_t *fhss_structure, uint8_t *destination_address)
|
|
{
|
|
if (fhss_structure) {
|
|
if (fhss_structure->fhss_state != FHSS_UNSYNCHRONIZED) {
|
|
uint8_t destination_channel = fhss_get_destination_channel(fhss_structure, destination_address);
|
|
fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, destination_channel);
|
|
#ifdef FHSS_CHANNEL_DEBUG
|
|
debug_destination_channel = destination_channel;
|
|
#endif /*FHSS_CHANNEL_DEBUG*/
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int fhss_change_to_parent_channel(fhss_structure_t *fhss_structure)
|
|
{
|
|
uint8_t uc_index;
|
|
uint8_t destination_channel;
|
|
uint8_t destination_offset;
|
|
if (fhss_structure) {
|
|
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->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->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
|
|
tr_info("Parent channel: %u", destination_channel);
|
|
#endif /*FHSS_CHANNEL_DEBUG*/
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int fhss_change_to_rx_channel(fhss_structure_t *fhss_structure)
|
|
{
|
|
if (fhss_structure) {
|
|
if (fhss_structure->fhss_state == FHSS_SYNCHRONIZED) {
|
|
fhss_structure->callbacks.change_channel(fhss_structure->fhss_api, fhss_structure->rx_channel);
|
|
}
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|