mirror of
https://github.com/oliverschmidt/contiki.git
synced 2024-06-11 01:29:33 +00:00
TSCH: put tsch_ prefix to definitions in the global scope
struct asn_t -> struct tsch_asn_t struct asn_divisor_t -> tsch_asn_divisor_t ASN_ macros -> TSCH_ASN_ macros current_asn -> tsch_current_asn
This commit is contained in:
Yasuyuki Tanaka
parent
7d9134757f
commit
667dd6a210
|
|
@ -70,7 +70,7 @@ struct ieee802154_ies {
|
|||
uint16_t ie_mlme_len;
|
||||
/* Payload Short MLME IEs */
|
||||
uint8_t ie_tsch_synchronization_offset;
|
||||
struct asn_t ie_asn;
|
||||
struct tsch_asn_t ie_asn;
|
||||
uint8_t ie_join_priority;
|
||||
uint8_t ie_tsch_timeslot_id;
|
||||
uint16_t ie_tsch_timeslot[tsch_ts_elements_count];
|
||||
|
|
|
|||
|
|
@ -44,13 +44,13 @@
|
|||
/************ Types ***********/
|
||||
|
||||
/* The ASN is an absolute slot number over 5 bytes. */
|
||||
struct asn_t {
|
||||
struct tsch_asn_t {
|
||||
uint32_t ls4b; /* least significant 4 bytes */
|
||||
uint8_t ms1b; /* most significant 1 byte */
|
||||
};
|
||||
|
||||
/* For quick modulo operation on ASN */
|
||||
struct asn_divisor_t {
|
||||
struct tsch_asn_divisor_t {
|
||||
uint16_t val; /* Divisor value */
|
||||
uint16_t asn_ms1b_remainder; /* Remainder of the operation 0x100000000 / val */
|
||||
};
|
||||
|
|
@ -58,38 +58,38 @@ struct asn_divisor_t {
|
|||
/************ Macros **********/
|
||||
|
||||
/* Initialize ASN */
|
||||
#define ASN_INIT(asn, ms1b_, ls4b_) do { \
|
||||
#define TSCH_ASN_INIT(asn, ms1b_, ls4b_) do { \
|
||||
(asn).ms1b = (ms1b_); \
|
||||
(asn).ls4b = (ls4b_); \
|
||||
} while(0);
|
||||
|
||||
/* Increment an ASN by inc (32 bits) */
|
||||
#define ASN_INC(asn, inc) do { \
|
||||
#define TSCH_ASN_INC(asn, inc) do { \
|
||||
uint32_t new_ls4b = (asn).ls4b + (inc); \
|
||||
if(new_ls4b < (asn).ls4b) { (asn).ms1b++; } \
|
||||
(asn).ls4b = new_ls4b; \
|
||||
} while(0);
|
||||
|
||||
/* Decrement an ASN by inc (32 bits) */
|
||||
#define ASN_DEC(asn, dec) do { \
|
||||
#define TSCH_ASN_DEC(asn, dec) do { \
|
||||
uint32_t new_ls4b = (asn).ls4b - (dec); \
|
||||
if(new_ls4b > (asn).ls4b) { (asn).ms1b--; } \
|
||||
(asn).ls4b = new_ls4b; \
|
||||
} while(0);
|
||||
|
||||
/* Returns the 32-bit diff between asn1 and asn2 */
|
||||
#define ASN_DIFF(asn1, asn2) \
|
||||
#define TSCH_ASN_DIFF(asn1, asn2) \
|
||||
((asn1).ls4b - (asn2).ls4b)
|
||||
|
||||
/* Initialize a struct asn_divisor_t */
|
||||
#define ASN_DIVISOR_INIT(div, val_) do { \
|
||||
#define TSCH_ASN_DIVISOR_INIT(div, val_) do { \
|
||||
(div).val = (val_); \
|
||||
(div).asn_ms1b_remainder = ((0xffffffff % (val_)) + 1) % (val_); \
|
||||
} while(0);
|
||||
|
||||
/* Returns the result (16 bits) of a modulo operation on ASN,
|
||||
* with divisor being a struct asn_divisor_t */
|
||||
#define ASN_MOD(asn, div) \
|
||||
#define TSCH_ASN_MOD(asn, div) \
|
||||
((uint16_t)((asn).ls4b % (div).val) \
|
||||
+ (uint16_t)((asn).ms1b * (div).asn_ms1b_remainder % (div).val)) \
|
||||
% (div).val
|
||||
|
|
|
|||
|
|
@ -132,7 +132,7 @@ tsch_log_prepare_add(void)
|
|||
int log_index = ringbufindex_peek_put(&log_ringbuf);
|
||||
if(log_index != -1) {
|
||||
struct tsch_log_t *log = &log_array[log_index];
|
||||
log->asn = current_asn;
|
||||
log->asn = tsch_current_asn;
|
||||
log->link = current_link;
|
||||
return log;
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ struct tsch_log_t {
|
|||
tsch_log_rx,
|
||||
tsch_log_message
|
||||
} type;
|
||||
struct asn_t asn;
|
||||
struct tsch_asn_t asn;
|
||||
struct tsch_link *link;
|
||||
union {
|
||||
char message[48];
|
||||
|
|
|
|||
|
|
@ -338,7 +338,7 @@ int
|
|||
tsch_packet_update_eb(uint8_t *buf, int buf_size, uint8_t tsch_sync_ie_offset)
|
||||
{
|
||||
struct ieee802154_ies ies;
|
||||
ies.ie_asn = current_asn;
|
||||
ies.ie_asn = tsch_current_asn;
|
||||
ies.ie_join_priority = tsch_join_priority;
|
||||
frame80215e_create_ie_tsch_synchronization(buf+tsch_sync_ie_offset, buf_size-tsch_sync_ie_offset, &ies);
|
||||
return 1;
|
||||
|
|
|
|||
|
|
@ -80,12 +80,12 @@ extern const linkaddr_t tsch_broadcast_address;
|
|||
/* The address we use to identify EB queue */
|
||||
extern const linkaddr_t tsch_eb_address;
|
||||
/* The current Absolute Slot Number (ASN) */
|
||||
extern struct asn_t current_asn;
|
||||
extern struct tsch_asn_t tsch_current_asn;
|
||||
extern uint8_t tsch_join_priority;
|
||||
extern struct tsch_link *current_link;
|
||||
/* TSCH channel hopping sequence */
|
||||
extern uint8_t tsch_hopping_sequence[TSCH_HOPPING_SEQUENCE_MAX_LEN];
|
||||
extern struct asn_divisor_t tsch_hopping_sequence_length;
|
||||
extern struct tsch_asn_divisor_t tsch_hopping_sequence_length;
|
||||
/* TSCH timeslot timing (in rtimer ticks) */
|
||||
extern rtimer_clock_t tsch_timing[tsch_ts_elements_count];
|
||||
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ tsch_schedule_add_slotframe(uint16_t handle, uint16_t size)
|
|||
if(sf != NULL) {
|
||||
/* Initialize the slotframe */
|
||||
sf->handle = handle;
|
||||
ASN_DIVISOR_INIT(sf->size, size);
|
||||
TSCH_ASN_DIVISOR_INIT(sf->size, size);
|
||||
LIST_STRUCT_INIT(sf, links_list);
|
||||
/* Add the slotframe to the global list */
|
||||
list_add(slotframe_list, sf);
|
||||
|
|
@ -310,7 +310,7 @@ tsch_schedule_get_link_by_timeslot(struct tsch_slotframe *slotframe, uint16_t ti
|
|||
/*---------------------------------------------------------------------------*/
|
||||
/* Returns the next active link after a given ASN, and a backup link (for the same ASN, with Rx flag) */
|
||||
struct tsch_link *
|
||||
tsch_schedule_get_next_active_link(struct asn_t *asn, uint16_t *time_offset,
|
||||
tsch_schedule_get_next_active_link(struct tsch_asn_t *asn, uint16_t *time_offset,
|
||||
struct tsch_link **backup_link)
|
||||
{
|
||||
uint16_t time_to_curr_best = 0;
|
||||
|
|
@ -324,7 +324,7 @@ tsch_schedule_get_next_active_link(struct asn_t *asn, uint16_t *time_offset,
|
|||
/* For each slotframe, look for the earliest occurring link */
|
||||
while(sf != NULL) {
|
||||
/* Get timeslot from ASN, given the slotframe length */
|
||||
uint16_t timeslot = ASN_MOD(*asn, sf->size);
|
||||
uint16_t timeslot = TSCH_ASN_MOD(*asn, sf->size);
|
||||
struct tsch_link *l = list_head(sf->links_list);
|
||||
while(l != NULL) {
|
||||
uint16_t time_to_timeslot =
|
||||
|
|
|
|||
|
|
@ -119,7 +119,7 @@ struct tsch_slotframe {
|
|||
uint16_t handle;
|
||||
/* Number of timeslots in the slotframe.
|
||||
* Stored as struct asn_divisor_t because we often need ASN%size */
|
||||
struct asn_divisor_t size;
|
||||
struct tsch_asn_divisor_t size;
|
||||
/* List of links belonging to this slotframe */
|
||||
LIST_STRUCT(links_list);
|
||||
};
|
||||
|
|
@ -158,7 +158,7 @@ int tsch_schedule_remove_link(struct tsch_slotframe *slotframe, struct tsch_link
|
|||
int tsch_schedule_remove_link_by_timeslot(struct tsch_slotframe *slotframe, uint16_t timeslot);
|
||||
|
||||
/* Returns the next active link after a given ASN, and a backup link (for the same ASN, with Rx flag) */
|
||||
struct tsch_link * tsch_schedule_get_next_active_link(struct asn_t *asn, uint16_t *time_offset,
|
||||
struct tsch_link * tsch_schedule_get_next_active_link(struct tsch_asn_t *asn, uint16_t *time_offset,
|
||||
struct tsch_link **backup_link);
|
||||
|
||||
#endif /* __TSCH_SCHEDULE_H__ */
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ static aes_key keys[] = {
|
|||
/*---------------------------------------------------------------------------*/
|
||||
static void
|
||||
tsch_security_init_nonce(uint8_t *nonce,
|
||||
const linkaddr_t *sender, struct asn_t *asn)
|
||||
const linkaddr_t *sender, struct tsch_asn_t *asn)
|
||||
{
|
||||
memcpy(nonce, sender, 8);
|
||||
nonce[8] = asn->ms1b;
|
||||
|
|
@ -137,7 +137,7 @@ tsch_security_mic_len(const frame802154_t *frame)
|
|||
/*---------------------------------------------------------------------------*/
|
||||
unsigned int
|
||||
tsch_security_secure_frame(uint8_t *hdr, uint8_t *outbuf,
|
||||
int hdrlen, int datalen, struct asn_t *asn)
|
||||
int hdrlen, int datalen, struct tsch_asn_t *asn)
|
||||
{
|
||||
frame802154_t frame;
|
||||
uint8_t key_index = 0;
|
||||
|
|
@ -200,7 +200,8 @@ tsch_security_secure_frame(uint8_t *hdr, uint8_t *outbuf,
|
|||
/*---------------------------------------------------------------------------*/
|
||||
unsigned int
|
||||
tsch_security_parse_frame(const uint8_t *hdr, int hdrlen, int datalen,
|
||||
const frame802154_t *frame, const linkaddr_t *sender, struct asn_t *asn)
|
||||
const frame802154_t *frame, const linkaddr_t *sender,
|
||||
struct tsch_asn_t *asn)
|
||||
{
|
||||
uint8_t generated_mic[16];
|
||||
uint8_t key_index = 0;
|
||||
|
|
|
|||
|
|
@ -130,7 +130,7 @@ unsigned int tsch_security_mic_len(const frame802154_t *frame);
|
|||
*/
|
||||
unsigned int tsch_security_secure_frame(uint8_t *hdr, uint8_t *outbuf,
|
||||
int hdrlen, int datalen,
|
||||
struct asn_t *asn);
|
||||
struct tsch_asn_t *asn);
|
||||
|
||||
/**
|
||||
* \brief Parse and check a frame protected with encryption and/or MIC
|
||||
|
|
@ -140,6 +140,6 @@ unsigned int tsch_security_secure_frame(uint8_t *hdr, uint8_t *outbuf,
|
|||
unsigned int tsch_security_parse_frame(const uint8_t *hdr, int hdrlen,
|
||||
int datalen, const frame802154_t *frame,
|
||||
const linkaddr_t *sender,
|
||||
struct asn_t *asn);
|
||||
struct tsch_asn_t *asn);
|
||||
|
||||
#endif /* __TSCH_SECURITY_H__ */
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ struct ringbufindex input_ringbuf;
|
|||
struct input_packet input_array[TSCH_MAX_INCOMING_PACKETS];
|
||||
|
||||
/* Last time we received Sync-IE (ACK or data packet from a time source) */
|
||||
static struct asn_t last_sync_asn;
|
||||
static struct tsch_asn_t last_sync_asn;
|
||||
|
||||
/* A global lock for manipulating data structures safely from outside of interrupt */
|
||||
static volatile int tsch_locked = 0;
|
||||
|
|
@ -248,9 +248,9 @@ tsch_release_lock(void)
|
|||
|
||||
/* Return channel from ASN and channel offset */
|
||||
uint8_t
|
||||
tsch_calculate_channel(struct asn_t *asn, uint8_t channel_offset)
|
||||
tsch_calculate_channel(struct tsch_asn_t *asn, uint8_t channel_offset)
|
||||
{
|
||||
uint16_t index_of_0 = ASN_MOD(*asn, tsch_hopping_sequence_length);
|
||||
uint16_t index_of_0 = TSCH_ASN_MOD(*asn, tsch_hopping_sequence_length);
|
||||
uint16_t index_of_offset = (index_of_0 + channel_offset) % tsch_hopping_sequence_length.val;
|
||||
return tsch_hopping_sequence[index_of_offset];
|
||||
}
|
||||
|
|
@ -530,7 +530,7 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t))
|
|||
* the original untouched. This is to allow for future retransmissions. */
|
||||
int with_encryption = queuebuf_attr(current_packet->qb, PACKETBUF_ATTR_SECURITY_LEVEL) & 0x4;
|
||||
packet_len += tsch_security_secure_frame(packet, with_encryption ? encrypted_packet : packet, current_packet->header_len,
|
||||
packet_len - current_packet->header_len, ¤t_asn);
|
||||
packet_len - current_packet->header_len, &tsch_current_asn);
|
||||
if(with_encryption) {
|
||||
packet = encrypted_packet;
|
||||
}
|
||||
|
|
@ -627,7 +627,7 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t))
|
|||
#if LLSEC802154_ENABLED
|
||||
if(ack_len != 0) {
|
||||
if(!tsch_security_parse_frame(ackbuf, ack_hdrlen, ack_len - ack_hdrlen - tsch_security_mic_len(&frame),
|
||||
&frame, ¤t_neighbor->addr, ¤t_asn)) {
|
||||
&frame, ¤t_neighbor->addr, &tsch_current_asn)) {
|
||||
TSCH_LOG_ADD(tsch_log_message,
|
||||
snprintf(log->message, sizeof(log->message),
|
||||
"!failed to authenticate ACK"));
|
||||
|
|
@ -644,7 +644,7 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t))
|
|||
if(ack_len != 0) {
|
||||
if(is_time_source) {
|
||||
int32_t eack_time_correction = US_TO_RTIMERTICKS(ack_ies.ie_time_correction);
|
||||
int32_t since_last_timesync = ASN_DIFF(current_asn, last_sync_asn);
|
||||
int32_t since_last_timesync = TSCH_ASN_DIFF(tsch_current_asn, last_sync_asn);
|
||||
if(eack_time_correction > SYNC_IE_BOUND) {
|
||||
drift_correction = SYNC_IE_BOUND;
|
||||
} else if(eack_time_correction < -SYNC_IE_BOUND) {
|
||||
|
|
@ -661,7 +661,7 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t))
|
|||
is_drift_correction_used = 1;
|
||||
tsch_timesync_update(current_neighbor, since_last_timesync, drift_correction);
|
||||
/* Keep track of sync time */
|
||||
last_sync_asn = current_asn;
|
||||
last_sync_asn = tsch_current_asn;
|
||||
tsch_schedule_keepalive();
|
||||
}
|
||||
mac_tx_status = MAC_TX_OK;
|
||||
|
|
@ -793,7 +793,7 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t))
|
|||
/* Read packet */
|
||||
current_input->len = NETSTACK_RADIO.read((void *)current_input->payload, TSCH_PACKET_MAX_LEN);
|
||||
NETSTACK_RADIO.get_value(RADIO_PARAM_LAST_RSSI, &radio_last_rssi);
|
||||
current_input->rx_asn = current_asn;
|
||||
current_input->rx_asn = tsch_current_asn;
|
||||
current_input->rssi = (signed)radio_last_rssi;
|
||||
current_input->channel = current_channel;
|
||||
header_len = frame802154_parse((uint8_t *)current_input->payload, current_input->len, &frame);
|
||||
|
|
@ -813,7 +813,7 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t))
|
|||
if(frame_valid) {
|
||||
if(tsch_security_parse_frame(
|
||||
current_input->payload, header_len, current_input->len - header_len - tsch_security_mic_len(&frame),
|
||||
&frame, &source_address, ¤t_asn)) {
|
||||
&frame, &source_address, &tsch_current_asn)) {
|
||||
current_input->len -= tsch_security_mic_len(&frame);
|
||||
} else {
|
||||
TSCH_LOG_ADD(tsch_log_message,
|
||||
|
|
@ -864,7 +864,7 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t))
|
|||
#if LLSEC802154_ENABLED
|
||||
if(tsch_is_pan_secured) {
|
||||
/* Secure ACK frame. There is only header and header IEs, therefore data len == 0. */
|
||||
ack_len += tsch_security_secure_frame(ack_buf, ack_buf, ack_len, 0, ¤t_asn);
|
||||
ack_len += tsch_security_secure_frame(ack_buf, ack_buf, ack_len, 0, &tsch_current_asn);
|
||||
}
|
||||
#endif /* LLSEC802154_ENABLED */
|
||||
|
||||
|
|
@ -882,9 +882,9 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t))
|
|||
/* If the sender is a time source, proceed to clock drift compensation */
|
||||
n = tsch_queue_get_nbr(&source_address);
|
||||
if(n != NULL && n->is_time_source) {
|
||||
int32_t since_last_timesync = ASN_DIFF(current_asn, last_sync_asn);
|
||||
int32_t since_last_timesync = TSCH_ASN_DIFF(tsch_current_asn, last_sync_asn);
|
||||
/* Keep track of last sync time */
|
||||
last_sync_asn = current_asn;
|
||||
last_sync_asn = tsch_current_asn;
|
||||
/* Save estimated drift */
|
||||
drift_correction = -estimated_drift;
|
||||
is_drift_correction_used = 1;
|
||||
|
|
@ -970,7 +970,7 @@ PT_THREAD(tsch_slot_operation(struct rtimer *t, void *ptr))
|
|||
is_active_slot = current_packet != NULL || (current_link->link_options & LINK_OPTION_RX);
|
||||
if(is_active_slot) {
|
||||
/* Hop channel */
|
||||
current_channel = tsch_calculate_channel(¤t_asn, current_link->channel_offset);
|
||||
current_channel = tsch_calculate_channel(&tsch_current_asn, current_link->channel_offset);
|
||||
NETSTACK_RADIO.set_value(RADIO_PARAM_CHANNEL, current_channel);
|
||||
/* Turn the radio on already here if configured so; necessary for radios with slow startup */
|
||||
tsch_radio_on(TSCH_RADIO_CMD_ON_START_OF_TIMESLOT);
|
||||
|
|
@ -996,12 +996,12 @@ PT_THREAD(tsch_slot_operation(struct rtimer *t, void *ptr))
|
|||
/* End of slot operation, schedule next slot or resynchronize */
|
||||
|
||||
/* Do we need to resynchronize? i.e., wait for EB again */
|
||||
if(!tsch_is_coordinator && (ASN_DIFF(current_asn, last_sync_asn) >
|
||||
if(!tsch_is_coordinator && (TSCH_ASN_DIFF(tsch_current_asn, last_sync_asn) >
|
||||
(100 * TSCH_CLOCK_TO_SLOTS(TSCH_DESYNC_THRESHOLD / 100, tsch_timing[tsch_ts_timeslot_length])))) {
|
||||
TSCH_LOG_ADD(tsch_log_message,
|
||||
snprintf(log->message, sizeof(log->message),
|
||||
"! leaving the network, last sync %u",
|
||||
(unsigned)ASN_DIFF(current_asn, last_sync_asn));
|
||||
(unsigned)TSCH_ASN_DIFF(tsch_current_asn, last_sync_asn));
|
||||
);
|
||||
last_timesource_neighbor = NULL;
|
||||
tsch_disassociate();
|
||||
|
|
@ -1023,14 +1023,14 @@ PT_THREAD(tsch_slot_operation(struct rtimer *t, void *ptr))
|
|||
}
|
||||
|
||||
/* Get next active link */
|
||||
current_link = tsch_schedule_get_next_active_link(¤t_asn, ×lot_diff, &backup_link);
|
||||
current_link = tsch_schedule_get_next_active_link(&tsch_current_asn, ×lot_diff, &backup_link);
|
||||
if(current_link == NULL) {
|
||||
/* There is no next link. Fall back to default
|
||||
* behavior: wake up at the next slot. */
|
||||
timeslot_diff = 1;
|
||||
}
|
||||
/* Update ASN */
|
||||
ASN_INC(current_asn, timeslot_diff);
|
||||
TSCH_ASN_INC(tsch_current_asn, timeslot_diff);
|
||||
/* Time to next wake up */
|
||||
time_to_next_active_slot = timeslot_diff * tsch_timing[tsch_ts_timeslot_length] + drift_correction;
|
||||
drift_correction = 0;
|
||||
|
|
@ -1061,14 +1061,14 @@ tsch_slot_operation_start(void)
|
|||
do {
|
||||
uint16_t timeslot_diff;
|
||||
/* Get next active link */
|
||||
current_link = tsch_schedule_get_next_active_link(¤t_asn, ×lot_diff, &backup_link);
|
||||
current_link = tsch_schedule_get_next_active_link(&tsch_current_asn, ×lot_diff, &backup_link);
|
||||
if(current_link == NULL) {
|
||||
/* There is no next link. Fall back to default
|
||||
* behavior: wake up at the next slot. */
|
||||
timeslot_diff = 1;
|
||||
}
|
||||
/* Update ASN */
|
||||
ASN_INC(current_asn, timeslot_diff);
|
||||
TSCH_ASN_INC(tsch_current_asn, timeslot_diff);
|
||||
/* Time to next wake up */
|
||||
time_to_next_active_slot = timeslot_diff * tsch_timing[tsch_ts_timeslot_length];
|
||||
/* Update current slot start */
|
||||
|
|
@ -1080,11 +1080,11 @@ tsch_slot_operation_start(void)
|
|||
/* Start actual slot operation */
|
||||
void
|
||||
tsch_slot_operation_sync(rtimer_clock_t next_slot_start,
|
||||
struct asn_t *next_slot_asn)
|
||||
struct tsch_asn_t *next_slot_asn)
|
||||
{
|
||||
current_slot_start = next_slot_start;
|
||||
current_asn = *next_slot_asn;
|
||||
last_sync_asn = current_asn;
|
||||
tsch_current_asn = *next_slot_asn;
|
||||
last_sync_asn = tsch_current_asn;
|
||||
current_link = NULL;
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ int TSCH_CALLBACK_DO_NACK(struct tsch_link *link, linkaddr_t *src, linkaddr_t *d
|
|||
/* Stores data about an incoming packet */
|
||||
struct input_packet {
|
||||
uint8_t payload[TSCH_PACKET_MAX_LEN]; /* Packet payload */
|
||||
struct asn_t rx_asn; /* ASN when the packet was received */
|
||||
struct tsch_asn_t rx_asn; /* ASN when the packet was received */
|
||||
int len; /* Packet len */
|
||||
int16_t rssi; /* RSSI for this packet */
|
||||
uint8_t channel; /* Channel we received the packet on */
|
||||
|
|
@ -107,7 +107,7 @@ extern struct input_packet input_array[TSCH_MAX_INCOMING_PACKETS];
|
|||
/********** Functions *********/
|
||||
|
||||
/* Returns a 802.15.4 channel from an ASN and channel offset */
|
||||
uint8_t tsch_calculate_channel(struct asn_t *asn, uint8_t channel_offset);
|
||||
uint8_t tsch_calculate_channel(struct tsch_asn_t *asn, uint8_t channel_offset);
|
||||
/* Is TSCH locked? */
|
||||
int tsch_is_locked(void);
|
||||
/* Lock TSCH (no link operation) */
|
||||
|
|
@ -117,7 +117,7 @@ void tsch_release_lock(void);
|
|||
/* Set global time before starting slot operation,
|
||||
* with a rtimer time and an ASN */
|
||||
void tsch_slot_operation_sync(rtimer_clock_t next_slot_start,
|
||||
struct asn_t *next_slot_asn);
|
||||
struct tsch_asn_t *next_slot_asn);
|
||||
/* Start actual slot operation */
|
||||
void tsch_slot_operation_start(void);
|
||||
|
||||
|
|
|
|||
|
|
@ -90,7 +90,7 @@ NBR_TABLE(struct eb_stat, eb_stats);
|
|||
|
||||
/* TSCH channel hopping sequence */
|
||||
uint8_t tsch_hopping_sequence[TSCH_HOPPING_SEQUENCE_MAX_LEN];
|
||||
struct asn_divisor_t tsch_hopping_sequence_length;
|
||||
struct tsch_asn_divisor_t tsch_hopping_sequence_length;
|
||||
|
||||
/* Default TSCH timeslot timing (in micro-second) */
|
||||
static const uint16_t tsch_default_timing_us[tsch_ts_elements_count] = {
|
||||
|
|
@ -131,7 +131,7 @@ int tsch_is_associated = 0;
|
|||
/* Is the PAN running link-layer security? */
|
||||
int tsch_is_pan_secured = LLSEC802154_ENABLED;
|
||||
/* The current Absolute Slot Number (ASN) */
|
||||
struct asn_t current_asn;
|
||||
struct tsch_asn_t tsch_current_asn;
|
||||
/* Device rank or join priority:
|
||||
* For PAN coordinator: 0 -- lower is better */
|
||||
uint8_t tsch_join_priority;
|
||||
|
|
@ -202,7 +202,7 @@ tsch_reset(void)
|
|||
tsch_queue_update_time_source(NULL);
|
||||
/* Initialize global variables */
|
||||
tsch_join_priority = 0xff;
|
||||
ASN_INIT(current_asn, 0, 0);
|
||||
TSCH_ASN_INIT(tsch_current_asn, 0, 0);
|
||||
current_link = NULL;
|
||||
/* Reset timeslot timing to defaults */
|
||||
for(i = 0; i < tsch_ts_elements_count; i++) {
|
||||
|
|
@ -310,7 +310,7 @@ eb_input(struct input_packet *current_input)
|
|||
/* Did the EB come from our time source? */
|
||||
if(n != NULL && linkaddr_cmp((linkaddr_t *)&frame.src_addr, &n->addr)) {
|
||||
/* Check for ASN drift */
|
||||
int32_t asn_diff = ASN_DIFF(current_input->rx_asn, eb_ies.ie_asn);
|
||||
int32_t asn_diff = TSCH_ASN_DIFF(current_input->rx_asn, eb_ies.ie_asn);
|
||||
if(asn_diff != 0) {
|
||||
/* We disagree with our time source's ASN -- leave the network */
|
||||
PRINTF("TSCH:! ASN drifted by %ld, leaving the network\n", asn_diff);
|
||||
|
|
@ -401,7 +401,7 @@ tsch_start_coordinator(void)
|
|||
frame802154_set_pan_id(IEEE802154_PANID);
|
||||
/* Initialize hopping sequence as default */
|
||||
memcpy(tsch_hopping_sequence, TSCH_DEFAULT_HOPPING_SEQUENCE, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
|
||||
ASN_DIVISOR_INIT(tsch_hopping_sequence_length, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
|
||||
TSCH_ASN_DIVISOR_INIT(tsch_hopping_sequence_length, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
|
||||
#if TSCH_SCHEDULE_WITH_6TISCH_MINIMAL
|
||||
tsch_schedule_create_minimal();
|
||||
#endif
|
||||
|
|
@ -410,10 +410,10 @@ tsch_start_coordinator(void)
|
|||
tsch_join_priority = 0;
|
||||
|
||||
PRINTF("TSCH: starting as coordinator, PAN ID %x, asn-%x.%lx\n",
|
||||
frame802154_get_pan_id(), current_asn.ms1b, current_asn.ls4b);
|
||||
frame802154_get_pan_id(), tsch_current_asn.ms1b, tsch_current_asn.ls4b);
|
||||
|
||||
/* Start slot operation */
|
||||
tsch_slot_operation_sync(RTIMER_NOW(), ¤t_asn);
|
||||
tsch_slot_operation_sync(RTIMER_NOW(), &tsch_current_asn);
|
||||
}
|
||||
/*---------------------------------------------------------------------------*/
|
||||
/* Leave the TSCH network */
|
||||
|
|
@ -442,7 +442,7 @@ tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
|
|||
return 0;
|
||||
}
|
||||
|
||||
current_asn = ies.ie_asn;
|
||||
tsch_current_asn = ies.ie_asn;
|
||||
tsch_join_priority = ies.ie_join_priority + 1;
|
||||
|
||||
#if TSCH_JOIN_SECURED_ONLY
|
||||
|
|
@ -455,7 +455,7 @@ tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
|
|||
#if LLSEC802154_ENABLED
|
||||
if(!tsch_security_parse_frame(input_eb->payload, hdrlen,
|
||||
input_eb->len - hdrlen - tsch_security_mic_len(&frame),
|
||||
&frame, (linkaddr_t*)&frame.src_addr, ¤t_asn)) {
|
||||
&frame, (linkaddr_t*)&frame.src_addr, &tsch_current_asn)) {
|
||||
PRINTF("TSCH:! parse_eb: failed to authenticate\n");
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -494,11 +494,11 @@ tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
|
|||
/* TSCH hopping sequence */
|
||||
if(ies.ie_channel_hopping_sequence_id == 0) {
|
||||
memcpy(tsch_hopping_sequence, TSCH_DEFAULT_HOPPING_SEQUENCE, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
|
||||
ASN_DIVISOR_INIT(tsch_hopping_sequence_length, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
|
||||
TSCH_ASN_DIVISOR_INIT(tsch_hopping_sequence_length, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
|
||||
} else {
|
||||
if(ies.ie_hopping_sequence_len <= sizeof(tsch_hopping_sequence)) {
|
||||
memcpy(tsch_hopping_sequence, ies.ie_hopping_sequence_list, ies.ie_hopping_sequence_len);
|
||||
ASN_DIVISOR_INIT(tsch_hopping_sequence_length, ies.ie_hopping_sequence_len);
|
||||
TSCH_ASN_DIVISOR_INIT(tsch_hopping_sequence_length, ies.ie_hopping_sequence_len);
|
||||
} else {
|
||||
PRINTF("TSCH:! parse_eb: hopping sequence too long (%u)\n", ies.ie_hopping_sequence_len);
|
||||
return 0;
|
||||
|
|
@ -509,10 +509,10 @@ tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
|
|||
/* Divide by 4k and multiply again to avoid integer overflow */
|
||||
uint32_t expected_asn = 4096 * TSCH_CLOCK_TO_SLOTS(clock_time() / 4096, tsch_timing_timeslot_length); /* Expected ASN based on our current time*/
|
||||
int32_t asn_threshold = TSCH_CHECK_TIME_AT_ASSOCIATION * 60ul * TSCH_CLOCK_TO_SLOTS(CLOCK_SECOND, tsch_timing_timeslot_length);
|
||||
int32_t asn_diff = (int32_t)current_asn.ls4b - expected_asn;
|
||||
int32_t asn_diff = (int32_t)tsch_current_asn.ls4b - expected_asn;
|
||||
if(asn_diff > asn_threshold) {
|
||||
PRINTF("TSCH:! EB ASN rejected %lx %lx %ld\n",
|
||||
current_asn.ls4b, expected_asn, asn_diff);
|
||||
tsch_current_asn.ls4b, expected_asn, asn_diff);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -562,7 +562,7 @@ tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
|
|||
frame802154_set_pan_id(frame.src_pid);
|
||||
|
||||
/* Synchronize on EB */
|
||||
tsch_slot_operation_sync(timestamp - tsch_timing[tsch_ts_tx_offset], ¤t_asn);
|
||||
tsch_slot_operation_sync(timestamp - tsch_timing[tsch_ts_tx_offset], &tsch_current_asn);
|
||||
|
||||
/* Update global flags */
|
||||
tsch_is_associated = 1;
|
||||
|
|
@ -578,7 +578,7 @@ tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
|
|||
PRINTF("TSCH: association done, sec %u, PAN ID %x, asn-%x.%lx, jp %u, timeslot id %u, hopping id %u, slotframe len %u with %u links, from ",
|
||||
tsch_is_pan_secured,
|
||||
frame.src_pid,
|
||||
current_asn.ms1b, current_asn.ls4b, tsch_join_priority,
|
||||
tsch_current_asn.ms1b, tsch_current_asn.ls4b, tsch_join_priority,
|
||||
ies.ie_tsch_timeslot_id,
|
||||
ies.ie_channel_hopping_sequence_id,
|
||||
ies.ie_tsch_slotframe_and_link.slotframe_size,
|
||||
|
|
@ -609,7 +609,7 @@ PT_THREAD(tsch_scan(struct pt *pt))
|
|||
/* Time when we started scanning on current_channel */
|
||||
static clock_time_t current_channel_since;
|
||||
|
||||
ASN_INIT(current_asn, 0, 0);
|
||||
TSCH_ASN_INIT(tsch_current_asn, 0, 0);
|
||||
|
||||
etimer_set(&scan_timer, CLOCK_SECOND / TSCH_ASSOCIATION_POLL_FREQUENCY);
|
||||
current_channel_since = clock_time();
|
||||
|
|
|
|||
|
|
@ -201,7 +201,7 @@ PROCESS_THREAD(node_process, ev, data)
|
|||
if (host_found) {
|
||||
/* Make sample count dependent on asn. After a disconnect, waveforms remain
|
||||
synchronous. Use node_mac to create phase offset between waveforms in different nodes */
|
||||
sample_count = ((current_asn.ls4b/((1000/(TSCH_CONF_DEFAULT_TIMESLOT_LENGTH/1000)))/INTERVAL)+node_mac[7]) % (SIZE_OF_WAVEFORM-1);
|
||||
sample_count = ((tsch_current_asn.ls4b/((1000/(TSCH_CONF_DEFAULT_TIMESLOT_LENGTH/1000)))/INTERVAL)+node_mac[7]) % (SIZE_OF_WAVEFORM-1);
|
||||
printf("%d sec. waveform=%s. cnt=%d. value=%d\n", total_time, waveform_table[selected_waveform].str, sample_count, waveform_table[selected_waveform].table[sample_count]);
|
||||
my_sprintf(udp_buf, waveform_table[selected_waveform].table[sample_count]);
|
||||
uip_udp_packet_send(udp_conn_tx, udp_buf, strlen(udp_buf));
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user