deac/osd-contiki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

TSCH: put tsch_ prefix to definitions in the global scope

Browse source 
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 2016-12-14 16:50:28 +01:00
parent 7d9134757f
commit 667dd6a210
14 changed files with 67 additions and 66 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
core/net/mac/frame802154e-ie.h
View file

@ -70,7 +70,7 @@ struct ieee802154_ies {
uint16_t ie_mlme_len; uint16_t ie_mlme_len;
/* Payload Short MLME IEs */ /* Payload Short MLME IEs */
uint8_t ie_tsch_synchronization_offset; 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_join_priority;
uint8_t ie_tsch_timeslot_id; uint8_t ie_tsch_timeslot_id;
uint16_t ie_tsch_timeslot[tsch_ts_elements_count]; uint16_t ie_tsch_timeslot[tsch_ts_elements_count];

16
core/net/mac/tsch/tsch-asn.h
View file

@ -44,13 +44,13 @@
/************ Types ***********/ /************ Types ***********/
/* The ASN is an absolute slot number over 5 bytes. */ /* The ASN is an absolute slot number over 5 bytes. */
struct asn_t { struct tsch_asn_t {
uint32_t ls4b; /* least significant 4 bytes */ uint32_t ls4b; /* least significant 4 bytes */
uint8_t ms1b; /* most significant 1 byte */ uint8_t ms1b; /* most significant 1 byte */
}; };
/* For quick modulo operation on ASN */ /* For quick modulo operation on ASN */
struct asn_divisor_t { struct tsch_asn_divisor_t {
uint16_t val; /* Divisor value */ uint16_t val; /* Divisor value */
uint16_t asn_ms1b_remainder; /* Remainder of the operation 0x100000000 / val */ uint16_t asn_ms1b_remainder; /* Remainder of the operation 0x100000000 / val */
}; };
@ -58,38 +58,38 @@ struct asn_divisor_t {
/************ Macros **********/ /************ Macros **********/
/* Initialize ASN */ /* Initialize ASN */
#define ASN_INIT(asn, ms1b_, ls4b_) do { \ #define TSCH_ASN_INIT(asn, ms1b_, ls4b_) do { \
(asn).ms1b = (ms1b_); \ (asn).ms1b = (ms1b_); \
(asn).ls4b = (ls4b_); \ (asn).ls4b = (ls4b_); \
} while(0); } while(0);
/* Increment an ASN by inc (32 bits) */ /* 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); \ uint32_t new_ls4b = (asn).ls4b + (inc); \
if(new_ls4b < (asn).ls4b) { (asn).ms1b++; } \ if(new_ls4b < (asn).ls4b) { (asn).ms1b++; } \
(asn).ls4b = new_ls4b; \ (asn).ls4b = new_ls4b; \
} while(0); } while(0);
/* Decrement an ASN by inc (32 bits) */ /* 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); \ uint32_t new_ls4b = (asn).ls4b - (dec); \
if(new_ls4b > (asn).ls4b) { (asn).ms1b--; } \ if(new_ls4b > (asn).ls4b) { (asn).ms1b--; } \
(asn).ls4b = new_ls4b; \ (asn).ls4b = new_ls4b; \
} while(0); } while(0);
/* Returns the 32-bit diff between asn1 and asn2 */ /* Returns the 32-bit diff between asn1 and asn2 */
#define ASN_DIFF(asn1, asn2) \ #define TSCH_ASN_DIFF(asn1, asn2) \
((asn1).ls4b - (asn2).ls4b) ((asn1).ls4b - (asn2).ls4b)
/* Initialize a struct asn_divisor_t */ /* 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).val = (val_); \
(div).asn_ms1b_remainder = ((0xffffffff % (val_)) + 1) % (val_); \ (div).asn_ms1b_remainder = ((0xffffffff % (val_)) + 1) % (val_); \
} while(0); } while(0);
/* Returns the result (16 bits) of a modulo operation on ASN, /* Returns the result (16 bits) of a modulo operation on ASN,
* with divisor being a struct asn_divisor_t */ * 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).ls4b % (div).val) \
+ (uint16_t)((asn).ms1b * (div).asn_ms1b_remainder % (div).val)) \ + (uint16_t)((asn).ms1b * (div).asn_ms1b_remainder % (div).val)) \
% (div).val % (div).val

2
core/net/mac/tsch/tsch-log.c
View file

@ -132,7 +132,7 @@ tsch_log_prepare_add(void)
int log_index = ringbufindex_peek_put(&log_ringbuf); int log_index = ringbufindex_peek_put(&log_ringbuf);
if(log_index != -1) { if(log_index != -1) {
struct tsch_log_t *log = &log_array[log_index]; struct tsch_log_t *log = &log_array[log_index];
log->asn = current_asn; log->asn = tsch_current_asn;
log->link = current_link; log->link = current_link;
return log; return log;
} else { } else {

2
core/net/mac/tsch/tsch-log.h
View file

@ -81,7 +81,7 @@ struct tsch_log_t {
tsch_log_rx, tsch_log_rx,
tsch_log_message tsch_log_message
} type; } type;
struct asn_t asn; struct tsch_asn_t asn;
struct tsch_link *link; struct tsch_link *link;
union { union {
char message[48]; char message[48];

2
core/net/mac/tsch/tsch-packet.c
View file

@ -338,7 +338,7 @@ int
tsch_packet_update_eb(uint8_t *buf, int buf_size, uint8_t tsch_sync_ie_offset) tsch_packet_update_eb(uint8_t *buf, int buf_size, uint8_t tsch_sync_ie_offset)
{ {
struct ieee802154_ies ies; struct ieee802154_ies ies;
ies.ie_asn = current_asn; ies.ie_asn = tsch_current_asn;
ies.ie_join_priority = tsch_join_priority; ies.ie_join_priority = tsch_join_priority;
frame80215e_create_ie_tsch_synchronization(buf+tsch_sync_ie_offset, buf_size-tsch_sync_ie_offset, &ies); frame80215e_create_ie_tsch_synchronization(buf+tsch_sync_ie_offset, buf_size-tsch_sync_ie_offset, &ies);
return 1; return 1;

4
core/net/mac/tsch/tsch-private.h
View file

@ -80,12 +80,12 @@ extern const linkaddr_t tsch_broadcast_address;
/* The address we use to identify EB queue */ /* The address we use to identify EB queue */
extern const linkaddr_t tsch_eb_address; extern const linkaddr_t tsch_eb_address;
/* The current Absolute Slot Number (ASN) */ /* 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 uint8_t tsch_join_priority;
extern struct tsch_link *current_link; extern struct tsch_link *current_link;
/* TSCH channel hopping sequence */ /* TSCH channel hopping sequence */
extern uint8_t tsch_hopping_sequence[TSCH_HOPPING_SEQUENCE_MAX_LEN]; 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) */ /* TSCH timeslot timing (in rtimer ticks) */
extern rtimer_clock_t tsch_timing[tsch_ts_elements_count]; extern rtimer_clock_t tsch_timing[tsch_ts_elements_count];

6
core/net/mac/tsch/tsch-schedule.c
View file

@ -87,7 +87,7 @@ tsch_schedule_add_slotframe(uint16_t handle, uint16_t size)
if(sf != NULL) { if(sf != NULL) {
/* Initialize the slotframe */ /* Initialize the slotframe */
sf->handle = handle; sf->handle = handle;
ASN_DIVISOR_INIT(sf->size, size); TSCH_ASN_DIVISOR_INIT(sf->size, size);
LIST_STRUCT_INIT(sf, links_list); LIST_STRUCT_INIT(sf, links_list);
/* Add the slotframe to the global list */ /* Add the slotframe to the global list */
list_add(slotframe_list, sf); 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) */ /* Returns the next active link after a given ASN, and a backup link (for the same ASN, with Rx flag) */
struct tsch_link * 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) struct tsch_link **backup_link)
{ {
uint16_t time_to_curr_best = 0; 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 */ /* For each slotframe, look for the earliest occurring link */
while(sf != NULL) { while(sf != NULL) {
/* Get timeslot from ASN, given the slotframe length */ /* 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); struct tsch_link *l = list_head(sf->links_list);
while(l != NULL) { while(l != NULL) {
uint16_t time_to_timeslot = uint16_t time_to_timeslot =

4
core/net/mac/tsch/tsch-schedule.h
View file

@ -119,7 +119,7 @@ struct tsch_slotframe {
uint16_t handle; uint16_t handle;
/* Number of timeslots in the slotframe. /* Number of timeslots in the slotframe.
* Stored as struct asn_divisor_t because we often need ASN%size */ * 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 of links belonging to this slotframe */
LIST_STRUCT(links_list); 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); 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) */ /* 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); struct tsch_link **backup_link);
#endif /* __TSCH_SCHEDULE_H__ */ #endif /* __TSCH_SCHEDULE_H__ */

7
core/net/mac/tsch/tsch-security.c
View file

@ -73,7 +73,7 @@ static aes_key keys[] = {
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static void static void
tsch_security_init_nonce(uint8_t *nonce, 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); memcpy(nonce, sender, 8);
nonce[8] = asn->ms1b; nonce[8] = asn->ms1b;
@ -137,7 +137,7 @@ tsch_security_mic_len(const frame802154_t *frame)
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
unsigned int unsigned int
tsch_security_secure_frame(uint8_t *hdr, uint8_t *outbuf, 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; frame802154_t frame;
uint8_t key_index = 0; uint8_t key_index = 0;
@ -200,7 +200,8 @@ tsch_security_secure_frame(uint8_t *hdr, uint8_t *outbuf,
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
unsigned int unsigned int
tsch_security_parse_frame(const uint8_t *hdr, int hdrlen, int datalen, 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 generated_mic[16];
uint8_t key_index = 0; uint8_t key_index = 0;

4
core/net/mac/tsch/tsch-security.h
View file

@ -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, unsigned int tsch_security_secure_frame(uint8_t *hdr, uint8_t *outbuf,
int hdrlen, int datalen, 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 * \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, unsigned int tsch_security_parse_frame(const uint8_t *hdr, int hdrlen,
int datalen, const frame802154_t *frame, int datalen, const frame802154_t *frame,
const linkaddr_t *sender, const linkaddr_t *sender,
struct asn_t *asn); struct tsch_asn_t *asn);
#endif /* __TSCH_SECURITY_H__ */ #endif /* __TSCH_SECURITY_H__ */

44
core/net/mac/tsch/tsch-slot-operation.c
View file

@ -139,7 +139,7 @@ struct ringbufindex input_ringbuf;
struct input_packet input_array[TSCH_MAX_INCOMING_PACKETS]; struct input_packet input_array[TSCH_MAX_INCOMING_PACKETS];
/* Last time we received Sync-IE (ACK or data packet from a time source) */ /* 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 */ /* A global lock for manipulating data structures safely from outside of interrupt */
static volatile int tsch_locked = 0; static volatile int tsch_locked = 0;
@ -248,9 +248,9 @@ tsch_release_lock(void)
/* Return channel from ASN and channel offset */ /* Return channel from ASN and channel offset */
uint8_t 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; uint16_t index_of_offset = (index_of_0 + channel_offset) % tsch_hopping_sequence_length.val;
return tsch_hopping_sequence[index_of_offset]; 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. */ * the original untouched. This is to allow for future retransmissions. */
int with_encryption = queuebuf_attr(current_packet->qb, PACKETBUF_ATTR_SECURITY_LEVEL) & 0x4; 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 += tsch_security_secure_frame(packet, with_encryption ? encrypted_packet : packet, current_packet->header_len,
packet_len - current_packet->header_len, &current_asn); packet_len - current_packet->header_len, &tsch_current_asn);
if(with_encryption) { if(with_encryption) {
packet = encrypted_packet; packet = encrypted_packet;
} }
@ -627,7 +627,7 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t))
#if LLSEC802154_ENABLED #if LLSEC802154_ENABLED
if(ack_len != 0) { if(ack_len != 0) {
if(!tsch_security_parse_frame(ackbuf, ack_hdrlen, ack_len - ack_hdrlen - tsch_security_mic_len(&frame), if(!tsch_security_parse_frame(ackbuf, ack_hdrlen, ack_len - ack_hdrlen - tsch_security_mic_len(&frame),
&frame, &current_neighbor->addr, &current_asn)) { &frame, &current_neighbor->addr, &tsch_current_asn)) {
TSCH_LOG_ADD(tsch_log_message, TSCH_LOG_ADD(tsch_log_message,
snprintf(log->message, sizeof(log->message), snprintf(log->message, sizeof(log->message),
"!failed to authenticate ACK")); "!failed to authenticate ACK"));
@ -644,7 +644,7 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t))
if(ack_len != 0) { if(ack_len != 0) {
if(is_time_source) { if(is_time_source) {
int32_t eack_time_correction = US_TO_RTIMERTICKS(ack_ies.ie_time_correction); 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) { if(eack_time_correction > SYNC_IE_BOUND) {
drift_correction = SYNC_IE_BOUND; drift_correction = SYNC_IE_BOUND;
} else if(eack_time_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; is_drift_correction_used = 1;
tsch_timesync_update(current_neighbor, since_last_timesync, drift_correction); tsch_timesync_update(current_neighbor, since_last_timesync, drift_correction);
/* Keep track of sync time */ /* Keep track of sync time */
last_sync_asn = current_asn; last_sync_asn = tsch_current_asn;
tsch_schedule_keepalive(); tsch_schedule_keepalive();
} }
mac_tx_status = MAC_TX_OK; mac_tx_status = MAC_TX_OK;
@ -793,7 +793,7 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t))
/* Read packet */ /* Read packet */
current_input->len = NETSTACK_RADIO.read((void *)current_input->payload, TSCH_PACKET_MAX_LEN); 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); 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->rssi = (signed)radio_last_rssi;
current_input->channel = current_channel; current_input->channel = current_channel;
header_len = frame802154_parse((uint8_t *)current_input->payload, current_input->len, &frame); 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(frame_valid) {
if(tsch_security_parse_frame( if(tsch_security_parse_frame(
current_input->payload, header_len, current_input->len - header_len - tsch_security_mic_len(&frame), current_input->payload, header_len, current_input->len - header_len - tsch_security_mic_len(&frame),
&frame, &source_address, &current_asn)) { &frame, &source_address, &tsch_current_asn)) {
current_input->len -= tsch_security_mic_len(&frame); current_input->len -= tsch_security_mic_len(&frame);
} else { } else {
TSCH_LOG_ADD(tsch_log_message, 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 LLSEC802154_ENABLED
if(tsch_is_pan_secured) { if(tsch_is_pan_secured) {
/* Secure ACK frame. There is only header and header IEs, therefore data len == 0. */ /* 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, &current_asn); ack_len += tsch_security_secure_frame(ack_buf, ack_buf, ack_len, 0, &tsch_current_asn);
} }
#endif /* LLSEC802154_ENABLED */ #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 */ /* If the sender is a time source, proceed to clock drift compensation */
n = tsch_queue_get_nbr(&source_address); n = tsch_queue_get_nbr(&source_address);
if(n != NULL && n->is_time_source) { 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 */ /* Keep track of last sync time */
last_sync_asn = current_asn; last_sync_asn = tsch_current_asn;
/* Save estimated drift */ /* Save estimated drift */
drift_correction = -estimated_drift; drift_correction = -estimated_drift;
is_drift_correction_used = 1; 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); is_active_slot = current_packet != NULL || (current_link->link_options & LINK_OPTION_RX);
if(is_active_slot) { if(is_active_slot) {
/* Hop channel */ /* Hop channel */
current_channel = tsch_calculate_channel(&current_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); NETSTACK_RADIO.set_value(RADIO_PARAM_CHANNEL, current_channel);
/* Turn the radio on already here if configured so; necessary for radios with slow startup */ /* 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); 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 */ /* End of slot operation, schedule next slot or resynchronize */
/* Do we need to resynchronize? i.e., wait for EB again */ /* 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])))) { (100 * TSCH_CLOCK_TO_SLOTS(TSCH_DESYNC_THRESHOLD / 100, tsch_timing[tsch_ts_timeslot_length])))) {
TSCH_LOG_ADD(tsch_log_message, TSCH_LOG_ADD(tsch_log_message,
snprintf(log->message, sizeof(log->message), snprintf(log->message, sizeof(log->message),
"! leaving the network, last sync %u", "! 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; last_timesource_neighbor = NULL;
tsch_disassociate(); tsch_disassociate();
@ -1023,14 +1023,14 @@ PT_THREAD(tsch_slot_operation(struct rtimer *t, void *ptr))
} }
/* Get next active link */ /* Get next active link */
current_link = tsch_schedule_get_next_active_link(&current_asn, &timeslot_diff, &backup_link); current_link = tsch_schedule_get_next_active_link(&tsch_current_asn, &timeslot_diff, &backup_link);
if(current_link == NULL) { if(current_link == NULL) {
/* There is no next link. Fall back to default /* There is no next link. Fall back to default
* behavior: wake up at the next slot. */ * behavior: wake up at the next slot. */
timeslot_diff = 1; timeslot_diff = 1;
} }
/* Update ASN */ /* Update ASN */
ASN_INC(current_asn, timeslot_diff); TSCH_ASN_INC(tsch_current_asn, timeslot_diff);
/* Time to next wake up */ /* Time to next wake up */
time_to_next_active_slot = timeslot_diff * tsch_timing[tsch_ts_timeslot_length] + drift_correction; time_to_next_active_slot = timeslot_diff * tsch_timing[tsch_ts_timeslot_length] + drift_correction;
drift_correction = 0; drift_correction = 0;
@ -1061,14 +1061,14 @@ tsch_slot_operation_start(void)
do { do {
uint16_t timeslot_diff; uint16_t timeslot_diff;
/* Get next active link */ /* Get next active link */
current_link = tsch_schedule_get_next_active_link(&current_asn, &timeslot_diff, &backup_link); current_link = tsch_schedule_get_next_active_link(&tsch_current_asn, &timeslot_diff, &backup_link);
if(current_link == NULL) { if(current_link == NULL) {
/* There is no next link. Fall back to default /* There is no next link. Fall back to default
* behavior: wake up at the next slot. */ * behavior: wake up at the next slot. */
timeslot_diff = 1; timeslot_diff = 1;
} }
/* Update ASN */ /* Update ASN */
ASN_INC(current_asn, timeslot_diff); TSCH_ASN_INC(tsch_current_asn, timeslot_diff);
/* Time to next wake up */ /* Time to next wake up */
time_to_next_active_slot = timeslot_diff * tsch_timing[tsch_ts_timeslot_length]; time_to_next_active_slot = timeslot_diff * tsch_timing[tsch_ts_timeslot_length];
/* Update current slot start */ /* Update current slot start */
@ -1080,11 +1080,11 @@ tsch_slot_operation_start(void)
/* Start actual slot operation */ /* Start actual slot operation */
void void
tsch_slot_operation_sync(rtimer_clock_t next_slot_start, 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_slot_start = next_slot_start;
current_asn = *next_slot_asn; tsch_current_asn = *next_slot_asn;
last_sync_asn = current_asn; last_sync_asn = tsch_current_asn;
current_link = NULL; current_link = NULL;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/

6
core/net/mac/tsch/tsch-slot-operation.h
View file

@ -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 */ /* Stores data about an incoming packet */
struct input_packet { struct input_packet {
uint8_t payload[TSCH_PACKET_MAX_LEN]; /* Packet payload */ 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 */ int len; /* Packet len */
int16_t rssi; /* RSSI for this packet */ int16_t rssi; /* RSSI for this packet */
uint8_t channel; /* Channel we received the packet on */ uint8_t channel; /* Channel we received the packet on */
@ -107,7 +107,7 @@ extern struct input_packet input_array[TSCH_MAX_INCOMING_PACKETS];
/********** Functions *********/ /********** Functions *********/
/* Returns a 802.15.4 channel from an ASN and channel offset */ /* 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? */ /* Is TSCH locked? */
int tsch_is_locked(void); int tsch_is_locked(void);
/* Lock TSCH (no link operation) */ /* Lock TSCH (no link operation) */
@ -117,7 +117,7 @@ void tsch_release_lock(void);
/* Set global time before starting slot operation, /* Set global time before starting slot operation,
* with a rtimer time and an ASN */ * with a rtimer time and an ASN */
void tsch_slot_operation_sync(rtimer_clock_t next_slot_start, 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 */ /* Start actual slot operation */
void tsch_slot_operation_start(void); void tsch_slot_operation_start(void);

32
core/net/mac/tsch/tsch.c
View file

@ -90,7 +90,7 @@ NBR_TABLE(struct eb_stat, eb_stats);
/* TSCH channel hopping sequence */ /* TSCH channel hopping sequence */
uint8_t tsch_hopping_sequence[TSCH_HOPPING_SEQUENCE_MAX_LEN]; 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) */ /* Default TSCH timeslot timing (in micro-second) */
static const uint16_t tsch_default_timing_us[tsch_ts_elements_count] = { 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? */ /* Is the PAN running link-layer security? */
int tsch_is_pan_secured = LLSEC802154_ENABLED; int tsch_is_pan_secured = LLSEC802154_ENABLED;
/* The current Absolute Slot Number (ASN) */ /* The current Absolute Slot Number (ASN) */
struct asn_t current_asn; struct tsch_asn_t tsch_current_asn;
/* Device rank or join priority: /* Device rank or join priority:
* For PAN coordinator: 0 -- lower is better */ * For PAN coordinator: 0 -- lower is better */
uint8_t tsch_join_priority; uint8_t tsch_join_priority;
@ -202,7 +202,7 @@ tsch_reset(void)
tsch_queue_update_time_source(NULL); tsch_queue_update_time_source(NULL);
/* Initialize global variables */ /* Initialize global variables */
tsch_join_priority = 0xff; tsch_join_priority = 0xff;
ASN_INIT(current_asn, 0, 0); TSCH_ASN_INIT(tsch_current_asn, 0, 0);
current_link = NULL; current_link = NULL;
/* Reset timeslot timing to defaults */ /* Reset timeslot timing to defaults */
for(i = 0; i < tsch_ts_elements_count; i++) { 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? */ /* Did the EB come from our time source? */
if(n != NULL && linkaddr_cmp((linkaddr_t *)&frame.src_addr, &n->addr)) { if(n != NULL && linkaddr_cmp((linkaddr_t *)&frame.src_addr, &n->addr)) {
/* Check for ASN drift */ /* 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) { if(asn_diff != 0) {
/* We disagree with our time source's ASN -- leave the network */ /* We disagree with our time source's ASN -- leave the network */
PRINTF("TSCH:! ASN drifted by %ld, leaving the network\n", asn_diff); 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); frame802154_set_pan_id(IEEE802154_PANID);
/* Initialize hopping sequence as default */ /* Initialize hopping sequence as default */
memcpy(tsch_hopping_sequence, TSCH_DEFAULT_HOPPING_SEQUENCE, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE)); 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 #if TSCH_SCHEDULE_WITH_6TISCH_MINIMAL
tsch_schedule_create_minimal(); tsch_schedule_create_minimal();
#endif #endif
@ -410,10 +410,10 @@ tsch_start_coordinator(void)
tsch_join_priority = 0; tsch_join_priority = 0;
PRINTF("TSCH: starting as coordinator, PAN ID %x, asn-%x.%lx\n", 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 */ /* Start slot operation */
tsch_slot_operation_sync(RTIMER_NOW(), &current_asn); tsch_slot_operation_sync(RTIMER_NOW(), &tsch_current_asn);
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* Leave the TSCH network */ /* Leave the TSCH network */
@ -442,7 +442,7 @@ tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
return 0; return 0;
} }
current_asn = ies.ie_asn; tsch_current_asn = ies.ie_asn;
tsch_join_priority = ies.ie_join_priority + 1; tsch_join_priority = ies.ie_join_priority + 1;
#if TSCH_JOIN_SECURED_ONLY #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 LLSEC802154_ENABLED
if(!tsch_security_parse_frame(input_eb->payload, hdrlen, if(!tsch_security_parse_frame(input_eb->payload, hdrlen,
input_eb->len - hdrlen - tsch_security_mic_len(&frame), input_eb->len - hdrlen - tsch_security_mic_len(&frame),
&frame, (linkaddr_t*)&frame.src_addr, &current_asn)) { &frame, (linkaddr_t*)&frame.src_addr, &tsch_current_asn)) {
PRINTF("TSCH:! parse_eb: failed to authenticate\n"); PRINTF("TSCH:! parse_eb: failed to authenticate\n");
return 0; return 0;
} }
@ -494,11 +494,11 @@ tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
/* TSCH hopping sequence */ /* TSCH hopping sequence */
if(ies.ie_channel_hopping_sequence_id == 0) { if(ies.ie_channel_hopping_sequence_id == 0) {
memcpy(tsch_hopping_sequence, TSCH_DEFAULT_HOPPING_SEQUENCE, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE)); 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 { } else {
if(ies.ie_hopping_sequence_len <= sizeof(tsch_hopping_sequence)) { if(ies.ie_hopping_sequence_len <= sizeof(tsch_hopping_sequence)) {
memcpy(tsch_hopping_sequence, ies.ie_hopping_sequence_list, ies.ie_hopping_sequence_len); 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 { } else {
PRINTF("TSCH:! parse_eb: hopping sequence too long (%u)\n", ies.ie_hopping_sequence_len); PRINTF("TSCH:! parse_eb: hopping sequence too long (%u)\n", ies.ie_hopping_sequence_len);
return 0; 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 */ /* 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*/ 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_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) { if(asn_diff > asn_threshold) {
PRINTF("TSCH:! EB ASN rejected %lx %lx %ld\n", 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; return 0;
} }
#endif #endif
@ -562,7 +562,7 @@ tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
frame802154_set_pan_id(frame.src_pid); frame802154_set_pan_id(frame.src_pid);
/* Synchronize on EB */ /* Synchronize on EB */
tsch_slot_operation_sync(timestamp - tsch_timing[tsch_ts_tx_offset], &current_asn); tsch_slot_operation_sync(timestamp - tsch_timing[tsch_ts_tx_offset], &tsch_current_asn);
/* Update global flags */ /* Update global flags */
tsch_is_associated = 1; 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 ", 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, tsch_is_pan_secured,
frame.src_pid, 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_tsch_timeslot_id,
ies.ie_channel_hopping_sequence_id, ies.ie_channel_hopping_sequence_id,
ies.ie_tsch_slotframe_and_link.slotframe_size, 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 */ /* Time when we started scanning on current_channel */
static clock_time_t current_channel_since; 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); etimer_set(&scan_timer, CLOCK_SECOND / TSCH_ASSOCIATION_POLL_FREQUENCY);
current_channel_since = clock_time(); current_channel_since = clock_time();

2
examples/jn516x/tsch/simple-sensor-network/node/node.c
View file

@ -201,7 +201,7 @@ PROCESS_THREAD(node_process, ev, data)
if (host_found) { if (host_found) {
/* Make sample count dependent on asn. After a disconnect, waveforms remain /* Make sample count dependent on asn. After a disconnect, waveforms remain
synchronous. Use node_mac to create phase offset between waveforms in different nodes */ 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]); 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]); my_sprintf(udp_buf, waveform_table[selected_waveform].table[sample_count]);
uip_udp_packet_send(udp_conn_tx, udp_buf, strlen(udp_buf)); uip_udp_packet_send(udp_conn_tx, udp_buf, strlen(udp_buf));