Contiki-NG
tsch.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015, SICS Swedish ICT.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the Institute nor the names of its contributors
14  * may be used to endorse or promote products derived from this software
15  * without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * This file is part of the Contiki operating system.
30  *
31  */
32 
33 /**
34  * \file
35  * IEEE 802.15.4 TSCH MAC implementation.
36  * Does not use any RDC layer. Should be used with nordc.
37  * \author
38  * Simon Duquennoy <simonduq@sics.se>
39  * Beshr Al Nahas <beshr@sics.se>
40  *
41  */
42 
43 /**
44  * \addtogroup tsch
45  * @{
46 */
47 
48 #include "contiki.h"
49 #include "dev/radio.h"
50 #include "net/netstack.h"
51 #include "net/packetbuf.h"
52 #include "net/queuebuf.h"
53 #include "net/nbr-table.h"
54 #include "net/link-stats.h"
56 #include "net/mac/tsch/tsch.h"
57 #include "net/mac/mac-sequence.h"
58 #include "lib/random.h"
59 #include "net/routing/routing.h"
60 
61 #if TSCH_WITH_SIXTOP
63 #endif
64 
65 #if FRAME802154_VERSION < FRAME802154_IEEE802154_2015
66 #error TSCH: FRAME802154_VERSION must be at least FRAME802154_IEEE802154_2015
67 #endif
68 
69 /* Log configuration */
70 #include "sys/log.h"
71 #define LOG_MODULE "TSCH"
72 #define LOG_LEVEL LOG_LEVEL_MAC
73 
74 /* The address of the last node we received an EB from (other than our time source).
75  * Used for recovery */
76 static linkaddr_t last_eb_nbr_addr;
77 /* The join priority advertised by last_eb_nbr_addr */
78 static uint8_t last_eb_nbr_jp;
79 
80 /* Let TSCH select a time source with no help of an upper layer.
81  * We do so using statistics from incoming EBs */
82 #if TSCH_AUTOSELECT_TIME_SOURCE
83 int best_neighbor_eb_count;
84 struct eb_stat {
85  int rx_count;
86  int jp;
87 };
88 NBR_TABLE(struct eb_stat, eb_stats);
89 #endif /* TSCH_AUTOSELECT_TIME_SOURCE */
90 
91 /* TSCH channel hopping sequence */
92 uint8_t tsch_hopping_sequence[TSCH_HOPPING_SEQUENCE_MAX_LEN];
93 struct tsch_asn_divisor_t tsch_hopping_sequence_length;
94 
95 /* Default TSCH timeslot timing (in micro-second) */
96 static const uint16_t *tsch_default_timing_us;
97 /* TSCH timeslot timing (in micro-second) */
98 uint16_t tsch_timing_us[tsch_ts_elements_count];
99 /* TSCH timeslot timing (in rtimer ticks) */
100 rtimer_clock_t tsch_timing[tsch_ts_elements_count];
101 
102 #if LINKADDR_SIZE == 8
103 /* 802.15.4 broadcast MAC address */
104 const linkaddr_t tsch_broadcast_address = { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };
105 /* Address used for the EB virtual neighbor queue */
106 const linkaddr_t tsch_eb_address = { { 0, 0, 0, 0, 0, 0, 0, 0 } };
107 #else /* LINKADDR_SIZE == 8 */
108 const linkaddr_t tsch_broadcast_address = { { 0xff, 0xff } };
109 const linkaddr_t tsch_eb_address = { { 0, 0 } };
110 #endif /* LINKADDR_SIZE == 8 */
111 
112 /* Is TSCH started? */
113 int tsch_is_started = 0;
114 /* Has TSCH initialization failed? */
115 int tsch_is_initialized = 0;
116 /* Are we coordinator of the TSCH network? */
117 int tsch_is_coordinator = 0;
118 /* Are we associated to a TSCH network? */
119 int tsch_is_associated = 0;
120 /* Total number of associations since boot */
121 int tsch_association_count = 0;
122 /* Is the PAN running link-layer security? */
123 int tsch_is_pan_secured = LLSEC802154_ENABLED;
124 /* The current Absolute Slot Number (ASN) */
125 struct tsch_asn_t tsch_current_asn;
126 /* Device rank or join priority:
127  * For PAN coordinator: 0 -- lower is better */
128 uint8_t tsch_join_priority;
129 /* The current TSCH sequence number, used for unicast data frames only */
130 static uint8_t tsch_packet_seqno;
131 /* Current period for EB output */
132 static clock_time_t tsch_current_eb_period;
133 /* Current period for keepalive output */
134 static clock_time_t tsch_current_ka_timeout;
135 
136 /* For scheduling keepalive messages */
137 enum tsch_keepalive_status {
138  KEEPALIVE_SCHEDULING_UNCHANGED,
139  KEEPALIVE_SCHEDULE_OR_STOP,
140  KEEPALIVE_SEND_IMMEDIATELY,
141 };
142 /* Should we send or schedule a keepalive? */
143 static volatile enum tsch_keepalive_status keepalive_status;
144 
145 /* timer for sending keepalive messages */
146 static struct ctimer keepalive_timer;
147 
148 /* Statistics on the current session */
149 unsigned long tx_count;
150 unsigned long rx_count;
151 unsigned long sync_count;
152 int32_t min_drift_seen;
153 int32_t max_drift_seen;
154 
155 /* TSCH processes and protothreads */
156 PT_THREAD(tsch_scan(struct pt *pt));
157 PROCESS(tsch_process, "main process");
158 PROCESS(tsch_send_eb_process, "send EB process");
159 PROCESS(tsch_pending_events_process, "pending events process");
160 
161 /* Other function prototypes */
162 static void packet_input(void);
163 
164 /* Getters and setters */
165 
166 /*---------------------------------------------------------------------------*/
167 void
169 {
170  if(tsch_is_coordinator != enable) {
171  tsch_is_associated = 0;
172  }
173  tsch_is_coordinator = enable;
174  tsch_set_eb_period(TSCH_EB_PERIOD);
175 }
176 /*---------------------------------------------------------------------------*/
177 void
179 {
180  tsch_is_pan_secured = LLSEC802154_ENABLED && enable;
181 }
182 /*---------------------------------------------------------------------------*/
183 void
185 {
186  tsch_join_priority = jp;
187 }
188 /*---------------------------------------------------------------------------*/
189 void
190 tsch_set_ka_timeout(uint32_t timeout)
191 {
192  tsch_current_ka_timeout = timeout;
194 }
195 /*---------------------------------------------------------------------------*/
196 void
197 tsch_set_eb_period(uint32_t period)
198 {
199  tsch_current_eb_period = MIN(period, TSCH_MAX_EB_PERIOD);
200 }
201 /*---------------------------------------------------------------------------*/
202 static void
203 tsch_reset(void)
204 {
205  int i;
206  frame802154_set_pan_id(0xffff);
207  /* First make sure pending packet callbacks are sent etc */
208  process_post_synch(&tsch_pending_events_process, PROCESS_EVENT_POLL, NULL);
209  /* Reset neighbor queues */
211  /* Remove unused neighbors */
214  /* Initialize global variables */
215  tsch_join_priority = 0xff;
216  TSCH_ASN_INIT(tsch_current_asn, 0, 0);
217  current_link = NULL;
218  /* Reset timeslot timing to defaults */
219  tsch_default_timing_us = TSCH_DEFAULT_TIMESLOT_TIMING;
220  for(i = 0; i < tsch_ts_elements_count; i++) {
221  tsch_timing_us[i] = tsch_default_timing_us[i];
222  tsch_timing[i] = US_TO_RTIMERTICKS(tsch_timing_us[i]);
223  }
224 #ifdef TSCH_CALLBACK_LEAVING_NETWORK
225  TSCH_CALLBACK_LEAVING_NETWORK();
226 #endif
227  linkaddr_copy(&last_eb_nbr_addr, &linkaddr_null);
228 #if TSCH_AUTOSELECT_TIME_SOURCE
229  struct nbr_sync_stat *stat;
230  best_neighbor_eb_count = 0;
231  /* Remove all nbr stats */
232  stat = nbr_table_head(sync_stats);
233  while(stat != NULL) {
234  nbr_table_remove(sync_stats, stat);
235  stat = nbr_table_next(sync_stats, stat);
236  }
237 #endif /* TSCH_AUTOSELECT_TIME_SOURCE */
238  tsch_set_eb_period(TSCH_EB_PERIOD);
239  keepalive_status = KEEPALIVE_SCHEDULING_UNCHANGED;
240 }
241 /* TSCH keep-alive functions */
242 
243 /*---------------------------------------------------------------------------*/
244 /* Resynchronize to last_eb_nbr.
245  * Return non-zero if this function schedules the next keepalive.
246  * Return zero otherwise.
247  */
248 static int
249 resynchronize(const linkaddr_t *original_time_source_addr)
250 {
251  const struct tsch_neighbor *current_time_source = tsch_queue_get_time_source();
252  if(current_time_source && !linkaddr_cmp(&current_time_source->addr, original_time_source_addr)) {
253  /* Time source has already been changed (e.g. by RPL). Let's see if it works. */
254  LOG_INFO("time source has been changed to ");
255  LOG_INFO_LLADDR(&current_time_source->addr);
256  LOG_INFO_("\n");
257  return 0;
258  }
259  /* Switch time source to the last neighbor we received an EB from */
260  if(linkaddr_cmp(&last_eb_nbr_addr, &linkaddr_null)) {
261  LOG_WARN("not able to re-synchronize, received no EB from other neighbors\n");
262  if(sync_count == 0) {
263  /* We got no synchronization at all in this session, leave the network */
265  }
266  return 0;
267  } else {
268  LOG_WARN("re-synchronizing on ");
269  LOG_WARN_LLADDR(&last_eb_nbr_addr);
270  LOG_WARN_("\n");
271  /* We simply pick the last neighbor we receiver sync information from */
272  tsch_queue_update_time_source(&last_eb_nbr_addr);
273  tsch_join_priority = last_eb_nbr_jp + 1;
274  /* Try to get in sync ASAP */
276  return 1;
277  }
278 }
279 
280 /*---------------------------------------------------------------------------*/
281 /* Tx callback for keepalive messages */
282 static void
283 keepalive_packet_sent(void *ptr, int status, int transmissions)
284 {
285  int schedule_next_keepalive = 1;
286  /* Update neighbor link statistics */
287  link_stats_packet_sent(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), status, transmissions);
288  /* Call RPL callback if RPL is enabled */
289 #ifdef TSCH_CALLBACK_KA_SENT
290  TSCH_CALLBACK_KA_SENT(status, transmissions);
291 #endif /* TSCH_CALLBACK_KA_SENT */
292  LOG_INFO("KA sent to ");
293  LOG_INFO_LLADDR(packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
294  LOG_INFO_(", st %d-%d\n", status, transmissions);
295 
296  /* We got no ack, try to resynchronize */
297  if(status == MAC_TX_NOACK) {
298  schedule_next_keepalive = !resynchronize(packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
299  }
300 
301  if(schedule_next_keepalive) {
303  }
304 }
305 /*---------------------------------------------------------------------------*/
306 /* Prepare and send a keepalive message */
307 static void
308 keepalive_send(void *ptr)
309 {
310  /* If not here from a timer callback, the timer must be stopped */
311  ctimer_stop(&keepalive_timer);
312 
313  if(tsch_is_associated) {
315  if(n != NULL) {
316  /* Simply send an empty packet */
317  packetbuf_clear();
318  packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER, &n->addr);
319  NETSTACK_MAC.send(keepalive_packet_sent, NULL);
320  LOG_INFO("sending KA to ");
321  LOG_INFO_LLADDR(&n->addr);
322  LOG_INFO_("\n");
323  } else {
324  LOG_ERR("no timesource - KA not sent\n");
325  }
326  }
327 }
328 /*---------------------------------------------------------------------------*/
329 void
331 {
332  if(immediate) {
333  /* send as soon as possible */
334  keepalive_status = KEEPALIVE_SEND_IMMEDIATELY;
335  } else if(keepalive_status != KEEPALIVE_SEND_IMMEDIATELY) {
336  /* send based on the tsch_current_ka_timeout */
337  keepalive_status = KEEPALIVE_SCHEDULE_OR_STOP;
338  }
339  process_poll(&tsch_pending_events_process);
340 }
341 /*---------------------------------------------------------------------------*/
342 static void
343 tsch_keepalive_process_pending(void)
344 {
345  if(keepalive_status != KEEPALIVE_SCHEDULING_UNCHANGED) {
346  /* first, save and reset the old status */
347  enum tsch_keepalive_status scheduled_status = keepalive_status;
348  keepalive_status = KEEPALIVE_SCHEDULING_UNCHANGED;
349 
350  if(!tsch_is_coordinator && tsch_is_associated) {
351  switch(scheduled_status) {
352  case KEEPALIVE_SEND_IMMEDIATELY:
353  /* always send, and as soon as possible (now) */
354  keepalive_send(NULL);
355  break;
356 
357  case KEEPALIVE_SCHEDULE_OR_STOP:
358  if(tsch_current_ka_timeout > 0) {
359  /* Pick a delay in the range [tsch_current_ka_timeout*0.9, tsch_current_ka_timeout[ */
360  unsigned long delay;
361  if(tsch_current_ka_timeout >= 10) {
362  delay = (tsch_current_ka_timeout - tsch_current_ka_timeout / 10)
363  + random_rand() % (tsch_current_ka_timeout / 10);
364  } else {
365  delay = tsch_current_ka_timeout - 1;
366  }
367  ctimer_set(&keepalive_timer, delay, keepalive_send, NULL);
368  } else {
369  /* zero timeout set, stop sending keepalives */
370  ctimer_stop(&keepalive_timer);
371  }
372  break;
373 
374  default:
375  break;
376  }
377  } else {
378  /* either coordinator or not associated */
379  ctimer_stop(&keepalive_timer);
380  }
381  }
382 }
383 /*---------------------------------------------------------------------------*/
384 static void
385 eb_input(struct input_packet *current_input)
386 {
387  /* LOG_INFO("EB received\n"); */
388  frame802154_t frame;
389  /* Verify incoming EB (does its ASN match our Rx time?),
390  * and update our join priority. */
391  struct ieee802154_ies eb_ies;
392 
393  if(tsch_packet_parse_eb(current_input->payload, current_input->len,
394  &frame, &eb_ies, NULL, 1)) {
395  /* PAN ID check and authentication done at rx time */
396 
397  /* Got an EB from a different neighbor than our time source, keep enough data
398  * to switch to it in case we lose the link to our time source */
400  if(ts == NULL || !linkaddr_cmp(&last_eb_nbr_addr, &ts->addr)) {
401  linkaddr_copy(&last_eb_nbr_addr, (linkaddr_t *)&frame.src_addr);
402  last_eb_nbr_jp = eb_ies.ie_join_priority;
403  }
404 
405 #if TSCH_AUTOSELECT_TIME_SOURCE
406  if(!tsch_is_coordinator) {
407  /* Maintain EB received counter for every neighbor */
408  struct eb_stat *stat = (struct eb_stat *)nbr_table_get_from_lladdr(eb_stats, (linkaddr_t *)&frame.src_addr);
409  if(stat == NULL) {
410  stat = (struct eb_stat *)nbr_table_add_lladdr(eb_stats, (linkaddr_t *)&frame.src_addr, NBR_TABLE_REASON_MAC, NULL);
411  }
412  if(stat != NULL) {
413  stat->rx_count++;
414  stat->jp = eb_ies.ie_join_priority;
415  best_neighbor_eb_count = MAX(best_neighbor_eb_count, stat->rx_count);
416  }
417  /* Select best time source */
418  struct eb_stat *best_stat = NULL;
419  stat = nbr_table_head(eb_stats);
420  while(stat != NULL) {
421  /* Is neighbor eligible as a time source? */
422  if(stat->rx_count > best_neighbor_eb_count / 2) {
423  if(best_stat == NULL ||
424  stat->jp < best_stat->jp) {
425  best_stat = stat;
426  }
427  }
428  stat = nbr_table_next(eb_stats, stat);
429  }
430  /* Update time source */
431  if(best_stat != NULL) {
432  tsch_queue_update_time_source(nbr_table_get_lladdr(eb_stats, best_stat));
433  tsch_join_priority = best_stat->jp + 1;
434  }
435  }
436 #endif /* TSCH_AUTOSELECT_TIME_SOURCE */
437 
438  /* Did the EB come from our time source? */
439  if(ts != NULL && linkaddr_cmp((linkaddr_t *)&frame.src_addr, &ts->addr)) {
440  /* Check for ASN drift */
441  int32_t asn_diff = TSCH_ASN_DIFF(current_input->rx_asn, eb_ies.ie_asn);
442  if(asn_diff != 0) {
443  /* We disagree with our time source's ASN -- leave the network */
444  LOG_WARN("! ASN drifted by %ld, leaving the network\n", asn_diff);
446  }
447 
448  if(eb_ies.ie_join_priority >= TSCH_MAX_JOIN_PRIORITY) {
449  /* Join priority unacceptable. Leave network. */
450  LOG_WARN("! EB JP too high %u, leaving the network\n",
451  eb_ies.ie_join_priority);
453  } else {
454 #if TSCH_AUTOSELECT_TIME_SOURCE
455  /* Update join priority */
456  if(tsch_join_priority != eb_ies.ie_join_priority + 1) {
457  LOG_INFO("update JP from EB %u -> %u\n",
458  tsch_join_priority, eb_ies.ie_join_priority + 1);
459  tsch_join_priority = eb_ies.ie_join_priority + 1;
460  }
461 #endif /* TSCH_AUTOSELECT_TIME_SOURCE */
462  }
463 
464  /* TSCH hopping sequence */
465  if(eb_ies.ie_channel_hopping_sequence_id != 0) {
466  if(eb_ies.ie_hopping_sequence_len != tsch_hopping_sequence_length.val
467  || memcmp((uint8_t *)tsch_hopping_sequence, eb_ies.ie_hopping_sequence_list, tsch_hopping_sequence_length.val)) {
468  if(eb_ies.ie_hopping_sequence_len <= sizeof(tsch_hopping_sequence)) {
469  memcpy((uint8_t *)tsch_hopping_sequence, eb_ies.ie_hopping_sequence_list,
470  eb_ies.ie_hopping_sequence_len);
471  TSCH_ASN_DIVISOR_INIT(tsch_hopping_sequence_length, eb_ies.ie_hopping_sequence_len);
472 
473  LOG_WARN("Updating TSCH hopping sequence from EB\n");
474  } else {
475  LOG_WARN("TSCH:! parse_eb: hopping sequence too long (%u)\n", eb_ies.ie_hopping_sequence_len);
476  }
477  }
478  }
479  }
480  }
481 }
482 /*---------------------------------------------------------------------------*/
483 /* Process pending input packet(s) */
484 static void
485 tsch_rx_process_pending()
486 {
487  int16_t input_index;
488  /* Loop on accessing (without removing) a pending input packet */
489  while((input_index = ringbufindex_peek_get(&input_ringbuf)) != -1) {
490  struct input_packet *current_input = &input_array[input_index];
491  frame802154_t frame;
492  uint8_t ret = frame802154_parse(current_input->payload, current_input->len, &frame);
493  int is_data = ret && frame.fcf.frame_type == FRAME802154_DATAFRAME;
494  int is_eb = ret
495  && frame.fcf.frame_version == FRAME802154_IEEE802154_2015
496  && frame.fcf.frame_type == FRAME802154_BEACONFRAME;
497 
498  if(is_data) {
499  /* Skip EBs and other control messages */
500  /* Copy to packetbuf for processing */
501  packetbuf_copyfrom(current_input->payload, current_input->len);
502  packetbuf_set_attr(PACKETBUF_ATTR_RSSI, current_input->rssi);
503  packetbuf_set_attr(PACKETBUF_ATTR_CHANNEL, current_input->channel);
504  }
505 
506  if(is_data) {
507  /* Pass to upper layers */
508  packet_input();
509  } else if(is_eb) {
510  eb_input(current_input);
511  }
512 
513  /* Remove input from ringbuf */
514  ringbufindex_get(&input_ringbuf);
515  }
516 }
517 /*---------------------------------------------------------------------------*/
518 /* Pass sent packets to upper layer */
519 static void
520 tsch_tx_process_pending(void)
521 {
522  int16_t dequeued_index;
523  /* Loop on accessing (without removing) a pending input packet */
524  while((dequeued_index = ringbufindex_peek_get(&dequeued_ringbuf)) != -1) {
525  struct tsch_packet *p = dequeued_array[dequeued_index];
526  /* Put packet into packetbuf for packet_sent callback */
527  queuebuf_to_packetbuf(p->qb);
528  LOG_INFO("packet sent to ");
529  LOG_INFO_LLADDR(packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
530  LOG_INFO_(", seqno %u, status %d, tx %d\n",
531  packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO), p->ret, p->transmissions);
532  /* Call packet_sent callback */
533  mac_call_sent_callback(p->sent, p->ptr, p->ret, p->transmissions);
534  /* Free packet queuebuf */
536  /* Free all unused neighbors */
538  /* Remove dequeued packet from ringbuf */
539  ringbufindex_get(&dequeued_ringbuf);
540  }
541 }
542 /*---------------------------------------------------------------------------*/
543 /* Setup TSCH as a coordinator */
544 static void
545 tsch_start_coordinator(void)
546 {
547  frame802154_set_pan_id(IEEE802154_PANID);
548  /* Initialize hopping sequence as default */
549  memcpy(tsch_hopping_sequence, TSCH_DEFAULT_HOPPING_SEQUENCE, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
550  TSCH_ASN_DIVISOR_INIT(tsch_hopping_sequence_length, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
551 #if TSCH_SCHEDULE_WITH_6TISCH_MINIMAL
553 #endif
554 
555  tsch_is_associated = 1;
556  tsch_join_priority = 0;
557 
558  LOG_INFO("starting as coordinator, PAN ID %x, asn-%x.%lx\n",
559  frame802154_get_pan_id(), tsch_current_asn.ms1b, tsch_current_asn.ls4b);
560 
561  /* Start slot operation */
562  tsch_slot_operation_sync(RTIMER_NOW(), &tsch_current_asn);
563 }
564 /*---------------------------------------------------------------------------*/
565 /* Leave the TSCH network */
566 void
568 {
569  if(tsch_is_associated == 1) {
570  tsch_is_associated = 0;
572  process_poll(&tsch_process);
573  }
574 }
575 /*---------------------------------------------------------------------------*/
576 /* Attempt to associate to a network form an incoming EB */
577 static int
578 tsch_associate(const struct input_packet *input_eb, rtimer_clock_t timestamp)
579 {
580  frame802154_t frame;
581  struct ieee802154_ies ies;
582  uint8_t hdrlen;
583  int i;
584 
585  if(input_eb == NULL || tsch_packet_parse_eb(input_eb->payload, input_eb->len,
586  &frame, &ies, &hdrlen, 0) == 0) {
587  LOG_DBG("! failed to parse EB (len %u)\n", input_eb->len);
588  return 0;
589  }
590 
591  tsch_current_asn = ies.ie_asn;
592  tsch_join_priority = ies.ie_join_priority + 1;
593 
594 #if TSCH_JOIN_SECURED_ONLY
595  if(frame.fcf.security_enabled == 0) {
596  LOG_ERR("! parse_eb: EB is not secured\n");
597  return 0;
598  }
599 #endif /* TSCH_JOIN_SECURED_ONLY */
600 #if LLSEC802154_ENABLED
601  if(!tsch_security_parse_frame(input_eb->payload, hdrlen,
602  input_eb->len - hdrlen - tsch_security_mic_len(&frame),
603  &frame, (linkaddr_t*)&frame.src_addr, &tsch_current_asn)) {
604  LOG_ERR("! parse_eb: failed to authenticate\n");
605  return 0;
606  }
607 #endif /* LLSEC802154_ENABLED */
608 
609 #if !LLSEC802154_ENABLED
610  if(frame.fcf.security_enabled == 1) {
611  LOG_ERR("! parse_eb: we do not support security, but EB is secured\n");
612  return 0;
613  }
614 #endif /* !LLSEC802154_ENABLED */
615 
616 #if TSCH_JOIN_MY_PANID_ONLY
617  /* Check if the EB comes from the PAN ID we expect */
618  if(frame.src_pid != IEEE802154_PANID) {
619  LOG_ERR("! parse_eb: PAN ID %x != %x\n", frame.src_pid, IEEE802154_PANID);
620  return 0;
621  }
622 #endif /* TSCH_JOIN_MY_PANID_ONLY */
623 
624  /* There was no join priority (or 0xff) in the EB, do not join */
625  if(ies.ie_join_priority == 0xff) {
626  LOG_ERR("! parse_eb: no join priority\n");
627  return 0;
628  }
629 
630  /* TSCH timeslot timing */
631  for(i = 0; i < tsch_ts_elements_count; i++) {
632  if(ies.ie_tsch_timeslot_id == 0) {
633  tsch_timing_us[i] = tsch_default_timing_us[i];
634  } else {
635  tsch_timing_us[i] = ies.ie_tsch_timeslot[i];
636  }
637  tsch_timing[i] = US_TO_RTIMERTICKS(tsch_timing_us[i]);
638  }
639 
640  /* TSCH hopping sequence */
641  if(ies.ie_channel_hopping_sequence_id == 0) {
642  memcpy(tsch_hopping_sequence, TSCH_DEFAULT_HOPPING_SEQUENCE, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
643  TSCH_ASN_DIVISOR_INIT(tsch_hopping_sequence_length, sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE));
644  } else {
645  if(ies.ie_hopping_sequence_len <= sizeof(tsch_hopping_sequence)) {
646  memcpy(tsch_hopping_sequence, ies.ie_hopping_sequence_list, ies.ie_hopping_sequence_len);
647  TSCH_ASN_DIVISOR_INIT(tsch_hopping_sequence_length, ies.ie_hopping_sequence_len);
648  } else {
649  LOG_ERR("! parse_eb: hopping sequence too long (%u)\n", ies.ie_hopping_sequence_len);
650  return 0;
651  }
652  }
653 
654 #if TSCH_CHECK_TIME_AT_ASSOCIATION > 0
655  /* Divide by 4k and multiply again to avoid integer overflow */
656  uint32_t expected_asn = 4096 * TSCH_CLOCK_TO_SLOTS(clock_time() / 4096, tsch_timing_timeslot_length); /* Expected ASN based on our current time*/
657  int32_t asn_threshold = TSCH_CHECK_TIME_AT_ASSOCIATION * 60ul * TSCH_CLOCK_TO_SLOTS(CLOCK_SECOND, tsch_timing_timeslot_length);
658  int32_t asn_diff = (int32_t)tsch_current_asn.ls4b - expected_asn;
659  if(asn_diff > asn_threshold) {
660  LOG_ERR("! EB ASN rejected %lx %lx %ld\n",
661  tsch_current_asn.ls4b, expected_asn, asn_diff);
662  return 0;
663  }
664 #endif
665 
666 #if TSCH_INIT_SCHEDULE_FROM_EB
667  /* Create schedule */
668  if(ies.ie_tsch_slotframe_and_link.num_slotframes == 0) {
669 #if TSCH_SCHEDULE_WITH_6TISCH_MINIMAL
670  LOG_INFO("parse_eb: no schedule, setting up minimal schedule\n");
672 #else
673  LOG_INFO("parse_eb: no schedule\n");
674 #endif
675  } else {
676  /* First, empty current schedule */
678  /* We support only 0 or 1 slotframe in this IE */
679  int num_links = ies.ie_tsch_slotframe_and_link.num_links;
680  if(num_links <= FRAME802154E_IE_MAX_LINKS) {
681  int i;
683  ies.ie_tsch_slotframe_and_link.slotframe_handle,
684  ies.ie_tsch_slotframe_and_link.slotframe_size);
685  for(i = 0; i < num_links; i++) {
687  ies.ie_tsch_slotframe_and_link.links[i].link_options,
688  LINK_TYPE_ADVERTISING, &tsch_broadcast_address,
689  ies.ie_tsch_slotframe_and_link.links[i].timeslot, ies.ie_tsch_slotframe_and_link.links[i].channel_offset);
690  }
691  } else {
692  LOG_ERR("! parse_eb: too many links in schedule (%u)\n", num_links);
693  return 0;
694  }
695  }
696 #endif /* TSCH_INIT_SCHEDULE_FROM_EB */
697 
698  if(tsch_join_priority < TSCH_MAX_JOIN_PRIORITY) {
699  struct tsch_neighbor *n;
700 
701  /* Add coordinator to list of neighbors, lock the entry */
702  n = tsch_queue_add_nbr((linkaddr_t *)&frame.src_addr);
703 
704  if(n != NULL) {
705  tsch_queue_update_time_source((linkaddr_t *)&frame.src_addr);
706 
707  /* Set PANID */
708  frame802154_set_pan_id(frame.src_pid);
709 
710  /* Synchronize on EB */
711  tsch_slot_operation_sync(timestamp - tsch_timing[tsch_ts_tx_offset], &tsch_current_asn);
712 
713  /* Update global flags */
714  tsch_is_associated = 1;
715  tsch_is_pan_secured = frame.fcf.security_enabled;
716  tx_count = 0;
717  rx_count = 0;
718  sync_count = 0;
719  min_drift_seen = 0;
720  max_drift_seen = 0;
721 
722  /* Start sending keep-alives now that tsch_is_associated is set */
724 
725 #ifdef TSCH_CALLBACK_JOINING_NETWORK
726  TSCH_CALLBACK_JOINING_NETWORK();
727 #endif
728 
729  tsch_association_count++;
730  LOG_INFO("association done (%u), sec %u, PAN ID %x, asn-%x.%lx, jp %u, timeslot id %u, hopping id %u, slotframe len %u with %u links, from ",
731  tsch_association_count,
732  tsch_is_pan_secured,
733  frame.src_pid,
734  tsch_current_asn.ms1b, tsch_current_asn.ls4b, tsch_join_priority,
735  ies.ie_tsch_timeslot_id,
736  ies.ie_channel_hopping_sequence_id,
737  ies.ie_tsch_slotframe_and_link.slotframe_size,
738  ies.ie_tsch_slotframe_and_link.num_links);
739  LOG_INFO_LLADDR((const linkaddr_t *)&frame.src_addr);
740  LOG_INFO_("\n");
741 
742  return 1;
743  }
744  }
745  LOG_ERR("! did not associate.\n");
746  return 0;
747 }
748 /* Processes and protothreads used by TSCH */
749 
750 /*---------------------------------------------------------------------------*/
751 /* Scanning protothread, called by tsch_process:
752  * Listen to different channels, and when receiving an EB,
753  * attempt to associate.
754  */
755 PT_THREAD(tsch_scan(struct pt *pt))
756 {
757  PT_BEGIN(pt);
758 
759  static struct input_packet input_eb;
760  static struct etimer scan_timer;
761  /* Time when we started scanning on current_channel */
762  static clock_time_t current_channel_since;
763 
764  TSCH_ASN_INIT(tsch_current_asn, 0, 0);
765 
766  etimer_set(&scan_timer, CLOCK_SECOND / TSCH_ASSOCIATION_POLL_FREQUENCY);
767  current_channel_since = clock_time();
768 
769  while(!tsch_is_associated && !tsch_is_coordinator) {
770  /* Hop to any channel offset */
771  static uint8_t current_channel = 0;
772 
773  /* We are not coordinator, try to associate */
774  rtimer_clock_t t0;
775  int is_packet_pending = 0;
776  clock_time_t now_time = clock_time();
777 
778  /* Switch to a (new) channel for scanning */
779  if(current_channel == 0 || now_time - current_channel_since > TSCH_CHANNEL_SCAN_DURATION) {
780  /* Pick a channel at random in TSCH_JOIN_HOPPING_SEQUENCE */
781  uint8_t scan_channel = TSCH_JOIN_HOPPING_SEQUENCE[
782  random_rand() % sizeof(TSCH_JOIN_HOPPING_SEQUENCE)];
783 
784  NETSTACK_RADIO.set_value(RADIO_PARAM_CHANNEL, scan_channel);
785  current_channel = scan_channel;
786  LOG_INFO("scanning on channel %u\n", scan_channel);
787 
788  current_channel_since = now_time;
789  }
790 
791  /* Turn radio on and wait for EB */
792  NETSTACK_RADIO.on();
793 
794  is_packet_pending = NETSTACK_RADIO.pending_packet();
795  if(!is_packet_pending && NETSTACK_RADIO.receiving_packet()) {
796  /* If we are currently receiving a packet, wait until end of reception */
797  t0 = RTIMER_NOW();
798  RTIMER_BUSYWAIT_UNTIL_ABS((is_packet_pending = NETSTACK_RADIO.pending_packet()), t0, RTIMER_SECOND / 100);
799  }
800 
801  if(is_packet_pending) {
802  rtimer_clock_t t1;
803  /* Read packet */
804  input_eb.len = NETSTACK_RADIO.read(input_eb.payload, TSCH_PACKET_MAX_LEN);
805 
806  if(input_eb.len > 0) {
807  /* Save packet timestamp */
808  NETSTACK_RADIO.get_object(RADIO_PARAM_LAST_PACKET_TIMESTAMP, &t0, sizeof(rtimer_clock_t));
809  t1 = RTIMER_NOW();
810 
811  /* Parse EB and attempt to associate */
812  LOG_INFO("scan: received packet (%u bytes) on channel %u\n", input_eb.len, current_channel);
813 
814  /* Sanity-check the timestamp */
815  if(ABS(RTIMER_CLOCK_DIFF(t0, t1)) < 2ul * RTIMER_SECOND) {
816  tsch_associate(&input_eb, t0);
817  } else {
818  LOG_WARN("scan: dropping packet, timestamp too far from current time %u %u\n",
819  (unsigned)t0,
820  (unsigned)t1
821  );
822  }
823  }
824  }
825 
826  if(tsch_is_associated) {
827  /* End of association, turn the radio off */
828  NETSTACK_RADIO.off();
829  } else if(!tsch_is_coordinator) {
830  /* Go back to scanning */
831  etimer_reset(&scan_timer);
832  PT_WAIT_UNTIL(pt, etimer_expired(&scan_timer));
833  }
834  }
835 
836  PT_END(pt);
837 }
838 
839 /*---------------------------------------------------------------------------*/
840 /* The main TSCH process */
841 PROCESS_THREAD(tsch_process, ev, data)
842 {
843  static struct pt scan_pt;
844 
845  PROCESS_BEGIN();
846 
847  while(1) {
848 
849  while(!tsch_is_associated) {
850  if(tsch_is_coordinator) {
851  /* We are coordinator, start operating now */
852  tsch_start_coordinator();
853  } else {
854  /* Start scanning, will attempt to join when receiving an EB */
855  PROCESS_PT_SPAWN(&scan_pt, tsch_scan(&scan_pt));
856  }
857  }
858 
859  /* We are part of a TSCH network, start slot operation */
861 
862  /* Yield our main process. Slot operation will re-schedule itself
863  * as long as we are associated */
864  PROCESS_YIELD_UNTIL(!tsch_is_associated);
865 
866  LOG_WARN("leaving the network, stats: tx %lu, rx %lu, sync %lu\n",
867  tx_count, rx_count, sync_count);
868 
869  /* Will need to re-synchronize */
870  tsch_reset();
871  }
872 
873  PROCESS_END();
874 }
875 
876 /*---------------------------------------------------------------------------*/
877 /* A periodic process to send TSCH Enhanced Beacons (EB) */
878 PROCESS_THREAD(tsch_send_eb_process, ev, data)
879 {
880  static struct etimer eb_timer;
881 
882  PROCESS_BEGIN();
883 
884  /* Wait until association */
885  etimer_set(&eb_timer, CLOCK_SECOND / 10);
886  while(!tsch_is_associated) {
888  etimer_reset(&eb_timer);
889  }
890 
891  /* Set an initial delay except for coordinator, which should send an EB asap */
892  if(!tsch_is_coordinator) {
893  etimer_set(&eb_timer, TSCH_EB_PERIOD ? random_rand() % TSCH_EB_PERIOD : 0);
895  }
896 
897  while(1) {
898  unsigned long delay;
899 
900  if(tsch_is_associated && tsch_current_eb_period > 0
901 #ifdef TSCH_RPL_CHECK_DODAG_JOINED
902  /* Implementation section 6.3 of RFC 8180 */
903  && TSCH_RPL_CHECK_DODAG_JOINED()
904 #endif /* TSCH_RPL_CHECK_DODAG_JOINED */
905  /* don't send when in leaf mode */
906  && !NETSTACK_ROUTING.is_in_leaf_mode()
907  ) {
908  /* Enqueue EB only if there isn't already one in queue */
909  if(tsch_queue_packet_count(&tsch_eb_address) == 0) {
910  uint8_t hdr_len = 0;
911  uint8_t tsch_sync_ie_offset;
912  /* Prepare the EB packet and schedule it to be sent */
913  if(tsch_packet_create_eb(&hdr_len, &tsch_sync_ie_offset) > 0) {
914  struct tsch_packet *p;
915  /* Enqueue EB packet, for a single transmission only */
916  if(!(p = tsch_queue_add_packet(&tsch_eb_address, 1, NULL, NULL))) {
917  LOG_ERR("! could not enqueue EB packet\n");
918  } else {
919  LOG_INFO("TSCH: enqueue EB packet %u %u\n",
921  p->tsch_sync_ie_offset = tsch_sync_ie_offset;
922  p->header_len = hdr_len;
923  }
924  }
925  }
926  }
927  if(tsch_current_eb_period > 0) {
928  /* Next EB transmission with a random delay
929  * within [tsch_current_eb_period*0.75, tsch_current_eb_period[ */
930  delay = (tsch_current_eb_period - tsch_current_eb_period / 4)
931  + random_rand() % (tsch_current_eb_period / 4);
932  } else {
933  delay = TSCH_EB_PERIOD;
934  }
935  etimer_set(&eb_timer, delay);
937  }
938  PROCESS_END();
939 }
940 
941 /*---------------------------------------------------------------------------*/
942 /* A process that is polled from interrupt and calls tx/rx input
943  * callbacks, outputs pending logs. */
944 PROCESS_THREAD(tsch_pending_events_process, ev, data)
945 {
946  PROCESS_BEGIN();
947  while(1) {
948  PROCESS_YIELD_UNTIL(ev == PROCESS_EVENT_POLL);
949  tsch_rx_process_pending();
950  tsch_tx_process_pending();
952  tsch_keepalive_process_pending();
953 #ifdef TSCH_CALLBACK_SELECT_CHANNELS
954  TSCH_CALLBACK_SELECT_CHANNELS();
955 #endif
956  }
957  PROCESS_END();
958 }
959 
960 /* Functions from the Contiki MAC layer driver interface */
961 
962 /*---------------------------------------------------------------------------*/
963 static void
964 tsch_init(void)
965 {
966  radio_value_t radio_rx_mode;
967  radio_value_t radio_tx_mode;
968  radio_value_t radio_max_payload_len;
969 
970  rtimer_clock_t t;
971 
972  /* Check that the platform provides a TSCH timeslot timing template */
973  if(TSCH_DEFAULT_TIMESLOT_TIMING == NULL) {
974  LOG_ERR("! platform does not provide a timeslot timing template.\n");
975  return;
976  }
977 
978  /* Check that the radio can correctly report its max supported payload */
979  if(NETSTACK_RADIO.get_value(RADIO_CONST_MAX_PAYLOAD_LEN, &radio_max_payload_len) != RADIO_RESULT_OK) {
980  LOG_ERR("! radio does not support getting RADIO_CONST_MAX_PAYLOAD_LEN. Abort init.\n");
981  return;
982  }
983 
984  /* Radio Rx mode */
985  if(NETSTACK_RADIO.get_value(RADIO_PARAM_RX_MODE, &radio_rx_mode) != RADIO_RESULT_OK) {
986  LOG_ERR("! radio does not support getting RADIO_PARAM_RX_MODE. Abort init.\n");
987  return;
988  }
989  /* Disable radio in frame filtering */
990  radio_rx_mode &= ~RADIO_RX_MODE_ADDRESS_FILTER;
991  /* Unset autoack */
992  radio_rx_mode &= ~RADIO_RX_MODE_AUTOACK;
993  /* Set radio in poll mode */
994  radio_rx_mode |= RADIO_RX_MODE_POLL_MODE;
995  if(NETSTACK_RADIO.set_value(RADIO_PARAM_RX_MODE, radio_rx_mode) != RADIO_RESULT_OK) {
996  LOG_ERR("! radio does not support setting required RADIO_PARAM_RX_MODE. Abort init.\n");
997  return;
998  }
999 
1000  /* Radio Tx mode */
1001  if(NETSTACK_RADIO.get_value(RADIO_PARAM_TX_MODE, &radio_tx_mode) != RADIO_RESULT_OK) {
1002  LOG_ERR("! radio does not support getting RADIO_PARAM_TX_MODE. Abort init.\n");
1003  return;
1004  }
1005  /* Unset CCA */
1006  radio_tx_mode &= ~RADIO_TX_MODE_SEND_ON_CCA;
1007  if(NETSTACK_RADIO.set_value(RADIO_PARAM_TX_MODE, radio_tx_mode) != RADIO_RESULT_OK) {
1008  LOG_ERR("! radio does not support setting required RADIO_PARAM_TX_MODE. Abort init.\n");
1009  return;
1010  }
1011  /* Test setting channel */
1012  if(NETSTACK_RADIO.set_value(RADIO_PARAM_CHANNEL, TSCH_DEFAULT_HOPPING_SEQUENCE[0]) != RADIO_RESULT_OK) {
1013  LOG_ERR("! radio does not support setting channel. Abort init.\n");
1014  return;
1015  }
1016  /* Test getting timestamp */
1017  if(NETSTACK_RADIO.get_object(RADIO_PARAM_LAST_PACKET_TIMESTAMP, &t, sizeof(rtimer_clock_t)) != RADIO_RESULT_OK) {
1018  LOG_ERR("! radio does not support getting last packet timestamp. Abort init.\n");
1019  return;
1020  }
1021  /* Check max hopping sequence length vs default sequence length */
1022  if(TSCH_HOPPING_SEQUENCE_MAX_LEN < sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE)) {
1023  LOG_ERR("! TSCH_HOPPING_SEQUENCE_MAX_LEN < sizeof(TSCH_DEFAULT_HOPPING_SEQUENCE). Abort init.\n");
1024  return;
1025  }
1026 
1027  /* Init TSCH sub-modules */
1028  tsch_reset();
1029  tsch_queue_init();
1031  tsch_log_init();
1032  ringbufindex_init(&input_ringbuf, TSCH_MAX_INCOMING_PACKETS);
1033  ringbufindex_init(&dequeued_ringbuf, TSCH_DEQUEUED_ARRAY_SIZE);
1034 #if TSCH_AUTOSELECT_TIME_SOURCE
1035  nbr_table_register(sync_stats, NULL);
1036 #endif /* TSCH_AUTOSELECT_TIME_SOURCE */
1037 
1038  tsch_packet_seqno = random_rand();
1039  tsch_is_initialized = 1;
1040 
1041 #if TSCH_AUTOSTART
1042  /* Start TSCH operation.
1043  * If TSCH_AUTOSTART is not set, one needs to call NETSTACK_MAC.on() to start TSCH. */
1044  NETSTACK_MAC.on();
1045 #endif /* TSCH_AUTOSTART */
1046 
1047 #if TSCH_WITH_SIXTOP
1048  sixtop_init();
1049 #endif
1050 
1051  tsch_stats_init();
1052 }
1053 /*---------------------------------------------------------------------------*/
1054 /* Function send for TSCH-MAC, puts the packet in packetbuf in the MAC queue */
1055 static void
1056 send_packet(mac_callback_t sent, void *ptr)
1057 {
1058  int ret = MAC_TX_DEFERRED;
1059  int hdr_len = 0;
1060  const linkaddr_t *addr = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
1061  uint8_t max_transmissions = 0;
1062 
1063  if(!tsch_is_associated) {
1064  if(!tsch_is_initialized) {
1065  LOG_WARN("! not initialized (see earlier logs), drop outgoing packet\n");
1066  } else {
1067  LOG_WARN("! not associated, drop outgoing packet\n");
1068  }
1069  ret = MAC_TX_ERR;
1070  mac_call_sent_callback(sent, ptr, ret, 1);
1071  return;
1072  }
1073 
1074  /* Ask for ACK if we are sending anything other than broadcast */
1075  if(!linkaddr_cmp(addr, &linkaddr_null)) {
1076  /* PACKETBUF_ATTR_MAC_SEQNO cannot be zero, due to a pecuilarity
1077  in framer-802154.c. */
1078  if(++tsch_packet_seqno == 0) {
1079  tsch_packet_seqno++;
1080  }
1081  packetbuf_set_attr(PACKETBUF_ATTR_MAC_SEQNO, tsch_packet_seqno);
1082  packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
1083  } else {
1084  /* Broadcast packets shall be added to broadcast queue
1085  * The broadcast address in Contiki is linkaddr_null which is equal
1086  * to tsch_eb_address */
1087  addr = &tsch_broadcast_address;
1088  }
1089 
1090  packetbuf_set_attr(PACKETBUF_ATTR_FRAME_TYPE, FRAME802154_DATAFRAME);
1091 
1092 #if LLSEC802154_ENABLED
1093  tsch_security_set_packetbuf_attr(FRAME802154_DATAFRAME);
1094 #endif /* LLSEC802154_ENABLED */
1095 
1096 #if !NETSTACK_CONF_BRIDGE_MODE
1097  /*
1098  * In the Contiki stack, the source address of a frame is set at the RDC
1099  * layer. Since TSCH doesn't use any RDC protocol and bypasses the layer to
1100  * transmit a frame, it should set the source address by itself.
1101  */
1102  packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &linkaddr_node_addr);
1103 #endif
1104 
1105  max_transmissions = packetbuf_attr(PACKETBUF_ATTR_MAX_MAC_TRANSMISSIONS);
1106  if(max_transmissions == 0) {
1107  /* If not set by the application, use the default TSCH value */
1108  max_transmissions = TSCH_MAC_MAX_FRAME_RETRIES + 1;
1109  }
1110 
1111  if((hdr_len = NETSTACK_FRAMER.create()) < 0) {
1112  LOG_ERR("! can't send packet due to framer error\n");
1113  ret = MAC_TX_ERR;
1114  } else {
1115  struct tsch_packet *p;
1116  /* Enqueue packet */
1117  p = tsch_queue_add_packet(addr, max_transmissions, sent, ptr);
1118  if(p == NULL) {
1119  LOG_ERR("! can't send packet to ");
1120  LOG_ERR_LLADDR(addr);
1121  LOG_ERR_(" with seqno %u, queue %u %u\n",
1122  tsch_packet_seqno, tsch_queue_packet_count(addr), tsch_queue_global_packet_count());
1123  ret = MAC_TX_ERR;
1124  } else {
1125  p->header_len = hdr_len;
1126  LOG_INFO("send packet to ");
1127  LOG_INFO_LLADDR(addr);
1128  LOG_INFO_(" with seqno %u, queue %u %u, len %u %u\n",
1129  tsch_packet_seqno,
1131  p->header_len, queuebuf_datalen(p->qb));
1132  }
1133  }
1134  if(ret != MAC_TX_DEFERRED) {
1135  mac_call_sent_callback(sent, ptr, ret, 1);
1136  }
1137 }
1138 /*---------------------------------------------------------------------------*/
1139 static void
1140 packet_input(void)
1141 {
1142  int frame_parsed = 1;
1143 
1144  frame_parsed = NETSTACK_FRAMER.parse();
1145 
1146  if(frame_parsed < 0) {
1147  LOG_ERR("! failed to parse %u\n", packetbuf_datalen());
1148  } else {
1149  int duplicate = 0;
1150 
1151  /* Seqno of 0xffff means no seqno */
1152  if(packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO) != 0xffff) {
1153  /* Check for duplicates */
1154  duplicate = mac_sequence_is_duplicate();
1155  if(duplicate) {
1156  /* Drop the packet. */
1157  LOG_WARN("! drop dup ll from ");
1158  LOG_WARN_LLADDR(packetbuf_addr(PACKETBUF_ADDR_SENDER));
1159  LOG_WARN_(" seqno %u\n", packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO));
1160  } else {
1162  }
1163  }
1164 
1165  if(!duplicate) {
1166  LOG_INFO("received from ");
1167  LOG_INFO_LLADDR(packetbuf_addr(PACKETBUF_ADDR_SENDER));
1168  LOG_INFO_(" with seqno %u\n", packetbuf_attr(PACKETBUF_ATTR_MAC_SEQNO));
1169 #if TSCH_WITH_SIXTOP
1170  sixtop_input();
1171 #endif /* TSCH_WITH_SIXTOP */
1172  NETSTACK_NETWORK.input();
1173  }
1174  }
1175 }
1176 /*---------------------------------------------------------------------------*/
1177 static int
1178 turn_on(void)
1179 {
1180  if(tsch_is_initialized == 1 && tsch_is_started == 0) {
1181  tsch_is_started = 1;
1182  /* Process tx/rx callback and log messages whenever polled */
1183  process_start(&tsch_pending_events_process, NULL);
1184  if(TSCH_EB_PERIOD > 0) {
1185  /* periodically send TSCH EBs */
1186  process_start(&tsch_send_eb_process, NULL);
1187  }
1188  /* try to associate to a network or start one if setup as coordinator */
1189  process_start(&tsch_process, NULL);
1190  LOG_INFO("starting as %s\n", tsch_is_coordinator ? "coordinator": "node");
1191  return 1;
1192  }
1193  return 0;
1194 }
1195 /*---------------------------------------------------------------------------*/
1196 static int
1197 turn_off(void)
1198 {
1199  NETSTACK_RADIO.off();
1200  return 1;
1201 }
1202 /*---------------------------------------------------------------------------*/
1203 static int
1204 max_payload(void)
1205 {
1206  int framer_hdrlen;
1207  radio_value_t max_radio_payload_len;
1208  radio_result_t res;
1209 
1210  res = NETSTACK_RADIO.get_value(RADIO_CONST_MAX_PAYLOAD_LEN,
1211  &max_radio_payload_len);
1212 
1213  if(res == RADIO_RESULT_NOT_SUPPORTED) {
1214  LOG_ERR("Failed to retrieve max radio driver payload length\n");
1215  return 0;
1216  }
1217 
1218  /* Set packetbuf security attributes */
1219  tsch_security_set_packetbuf_attr(FRAME802154_DATAFRAME);
1220 
1221  framer_hdrlen = NETSTACK_FRAMER.length();
1222  if(framer_hdrlen < 0) {
1223  return 0;
1224  }
1225 
1226  /* Setup security... before. */
1227  return MIN(max_radio_payload_len, TSCH_PACKET_MAX_LEN)
1228  - framer_hdrlen
1229  - LLSEC802154_PACKETBUF_MIC_LEN();
1230 }
1231 /*---------------------------------------------------------------------------*/
1232 const struct mac_driver tschmac_driver = {
1233  "TSCH",
1234  tsch_init,
1235  send_packet,
1236  packet_input,
1237  turn_on,
1238  turn_off,
1239  max_payload,
1240 };
1241 /*---------------------------------------------------------------------------*/
1242 /** @} */
uint16_t src_pid
Source PAN ID.
Definition: frame802154.h:207
TSCH packet information.
Definition: tsch-types.h:97
#define TSCH_ASN_DIVISOR_INIT(div, val_)
Initialize a struct asn_divisor_t.
Definition: tsch-asn.h:86
int tsch_queue_global_packet_count(void)
Returns the number of packets currently in all TSCH queues.
Definition: tsch-queue.c:280
void process_post_synch(struct process *p, process_event_t ev, process_data_t data)
Post a synchronous event to a process.
Definition: process.c:362
#define PROCESS(name, strname)
Declare a process.
Definition: process.h:307
void ctimer_stop(struct ctimer *c)
Stop a pending callback timer.
Definition: ctimer.c:149
void ringbufindex_init(struct ringbufindex *r, uint8_t size)
Initialize a ring buffer.
Definition: ringbufindex.c:50
void tsch_log_process_pending(void)
Process pending log messages.
int tsch_packet_create_eb(uint8_t *hdr_len, uint8_t *tsch_sync_ie_offset)
Create an EB packet directly in packetbuf.
Definition: tsch-packet.c:220
int(* on)(void)
Turn the MAC layer on.
Definition: mac.h:75
frame802154_fcf_t fcf
Frame control field.
Definition: frame802154.h:204
void packetbuf_clear(void)
Clear and reset the packetbuf.
Definition: packetbuf.c:75
static uip_ds6_addr_t * addr
Pointer to a nbr cache entry.
Definition: uip-nd6.c:107
int ringbufindex_peek_get(const struct ringbufindex *r)
Return the index of the first element which will be removed if calling ringbufindex_get.
Definition: ringbufindex.c:115
int tsch_schedule_init(void)
Module initialization, call only once at init.
The structure of a MAC protocol driver in Contiki.
Definition: mac.h:62
void tsch_set_join_priority(uint8_t jp)
Set the TSCH join priority (JP)
Definition: tsch.c:184
#define PROCESS_YIELD_UNTIL(c)
Yield the currently running process until a condition occurs.
Definition: process.h:178
Header file for the radio API
#define PROCESS_BEGIN()
Define the beginning of a process.
Definition: process.h:120
uint8_t security_enabled
1 bit.
Definition: frame802154.h:154
void tsch_log_init(void)
Initialize log module.
#define PROCESS_END()
Define the end of a process.
Definition: process.h:131
static void send_packet(linkaddr_t *dest)
This function is called by the 6lowpan code to send out a packet.
Definition: sicslowpan.c:1491
int frame802154_parse(uint8_t *data, int len, frame802154_t *pf)
Parses an input frame.
Definition: frame802154.c:500
int mac_sequence_is_duplicate(void)
Tell whether the packetbuf is a duplicate packet.
Definition: mac-sequence.c:72
TSCH neighbor information.
Definition: tsch-types.h:109
802.15.4e slotframe (contains links)
Definition: tsch-types.h:84
void tsch_queue_init(void)
Initialize TSCH queue module.
Definition: tsch-queue.c:528
#define PT_BEGIN(pt)
Declare the start of a protothread inside the C function implementing the protothread.
Definition: pt.h:114
unsigned int tsch_security_parse_frame(const uint8_t *hdr, int hdrlen, int datalen, const frame802154_t *frame, const linkaddr_t *sender, struct tsch_asn_t *asn)
Parse and check a frame protected with encryption and/or MIC.
struct tsch_neighbor * tsch_queue_get_time_source(void)
Get the TSCH time source (we currently assume there is only one)
Definition: tsch-queue.c:124
#define PT_WAIT_UNTIL(pt, condition)
Block and wait until condition is true.
Definition: pt.h:147
void tsch_set_ka_timeout(uint32_t timeout)
Set the desynchronization timeout after which a node sends a unicasst keep-alive (KA) to its time sou...
Definition: tsch.c:190
uint8_t packetbuf_hdrlen(void)
Get the length of the header in the packetbuf.
Definition: packetbuf.c:161
struct tsch_slotframe * tsch_schedule_add_slotframe(uint16_t handle, uint16_t size)
Creates and adds a new slotframe.
Definition: tsch-schedule.c:72
uint8_t(* is_in_leaf_mode)(void)
Tells whether the protocol is in leaf mode.
Definition: routing.h:190
int radio_value_t
Each radio has a set of parameters that designate the current configuration and state of the radio...
Definition: radio.h:88
uint8_t src_addr[8]
Source address.
Definition: frame802154.h:203
A MAC framer for IEEE 802.15.4
const linkaddr_t linkaddr_null
The null link-layer address.
#define RTIMER_SECOND
Number of rtimer ticks for 1 second.
Definition: rtimer.h:112
Header file for MAC sequence numbers management
void tsch_queue_free_unused_neighbors(void)
Deallocate all neighbors with empty queue.
Definition: tsch-queue.c:390
The MAC layer transmission could not be performed because of an error.
Definition: mac.h:97
uint16_t packetbuf_datalen(void)
Get the length of the data in the packetbuf.
Definition: packetbuf.c:155
linkaddr_t linkaddr_node_addr
The link-layer address of the node.
Definition: linkaddr.c:48
void sixtop_init(void)
Initialize 6top module This initialization function removes all the SFs which has been installed into...
Definition: sixtop.c:260
#define RTIMER_NOW()
Get the current clock time.
Definition: rtimer.h:185
void sixtop_input(void)
Input a packet stored in packetbuf.
Definition: sixtop.c:203
unsigned int tsch_security_mic_len(const frame802154_t *frame)
Return MIC length.
#define CLOCK_SECOND
A second, measured in system clock time.
Definition: clock.h:82
For quick modulo operation on ASN.
Definition: tsch-asn.h:54
#define PT_END(pt)
Declare the end of a protothread.
Definition: pt.h:126
struct tsch_neighbor * tsch_queue_add_nbr(const linkaddr_t *addr)
Add a TSCH neighbor queue.
Definition: tsch-queue.c:80
Header file for the Packet queue buffer management
void tsch_set_eb_period(uint32_t period)
Set the period at wich TSCH enhanced beacons (EBs) are sent.
Definition: tsch.c:197
uint8_t frame_version
2 bit.
Definition: frame802154.h:162
void process_poll(struct process *p)
Request a process to be polled.
Definition: process.c:371
uint16_t packetbuf_totlen(void)
Get the total length of the header and data in the packetbuf.
Definition: packetbuf.c:167
void tsch_schedule_keepalive(int immediate)
Schedule a keep-alive transmission within [timeout*0.9, timeout[ Can be called from an interrupt...
Definition: tsch.c:330
int tsch_queue_update_time_source(const linkaddr_t *new_addr)
Update TSCH time source.
Definition: tsch-queue.c:140
void ctimer_set(struct ctimer *c, clock_time_t t, void(*f)(void *), void *ptr)
Set a callback timer.
Definition: ctimer.c:99
Routing driver header file
Main API declarations for TSCH.
int packetbuf_copyfrom(const void *from, uint16_t len)
Copy from external data into the packetbuf.
Definition: packetbuf.c:84
clock_time_t clock_time(void)
Get the current clock time.
Definition: clock.c:118
#define RTIMER_BUSYWAIT_UNTIL_ABS(cond, t0, max_time)
Busy-wait until a condition.
Definition: rtimer.h:202
int etimer_expired(struct etimer *et)
Check if an event timer has expired.
Definition: etimer.c:213
struct tsch_link * tsch_schedule_add_link(struct tsch_slotframe *slotframe, uint8_t link_options, enum link_type link_type, const linkaddr_t *address, uint16_t timeslot, uint16_t channel_offset)
Adds a link to a slotframe.
The MAC layer transmission could not be performed because of a fatal error.
Definition: mac.h:101
#define TSCH_ASN_INIT(asn, ms1b_, ls4b_)
Initialize ASN.
Definition: tsch-asn.h:62
void tsch_security_set_packetbuf_attr(uint8_t frame_type)
Set packetbuf (or eackbuf) attributes depending on a given frame type.
#define RADIO_RX_MODE_ADDRESS_FILTER
The radio reception mode controls address filtering and automatic transmission of acknowledgements in...
Definition: radio.h:252
uint8_t frame_type
3 bit.
Definition: frame802154.h:153
void tsch_slot_operation_sync(rtimer_clock_t next_slot_start, struct tsch_asn_t *next_slot_asn)
Set global time before starting slot operation, with a rtimer time and an ASN.
Parameters used by the frame802154_create() function.
Definition: frame802154.h:198
void linkaddr_copy(linkaddr_t *dest, const linkaddr_t *src)
Copy a link-layer address.
Definition: linkaddr.c:63
#define PT_THREAD(name_args)
Declaration of a protothread.
Definition: pt.h:99
A timer.
Definition: etimer.h:76
6TiSCH Operation Sublayer (6top) APIs
#define RADIO_TX_MODE_SEND_ON_CCA
The radio transmission mode controls whether transmissions should be done using clear channel assessm...
Definition: radio.h:264
#define TSCH_ASN_DIFF(asn1, asn2)
Returns the 32-bit diff between asn1 and asn2.
Definition: tsch-asn.h:82
int linkaddr_cmp(const linkaddr_t *addr1, const linkaddr_t *addr2)
Compare two link-layer addresses.
Definition: linkaddr.c:69
void tsch_queue_reset(void)
Reset neighbor queues module.
Definition: tsch-queue.c:372
void(* send)(mac_callback_t sent_callback, void *ptr)
Send a packet from the packetbuf.
Definition: mac.h:69
int tsch_schedule_remove_all_slotframes(void)
Removes all slotframes, resulting in an empty schedule.
int tsch_queue_packet_count(const linkaddr_t *addr)
Returns the number of packets currently a given neighbor queue.
Definition: tsch-queue.c:287
int ringbufindex_get(struct ringbufindex *r)
Remove the first element and return its index.
Definition: ringbufindex.c:90
void tsch_disassociate(void)
Leave the TSCH network we are currently in.
Definition: tsch.c:567
void tsch_set_pan_secured(int enable)
Enable/disable security.
Definition: tsch.c:178
Header file for the Packet buffer (packetbuf) management
Include file for the Contiki low-layer network stack (NETSTACK)
void mac_sequence_register_seqno(void)
Register the sequence number of the packetbuf.
Definition: mac-sequence.c:101
#define PROCESS_PT_SPAWN(pt, thread)
Spawn a protothread from the process.
Definition: process.h:211
int(* max_payload)(void)
Read out estimated max payload size based on payload in packetbuf.
Definition: mac.h:81
void tsch_queue_free_packet(struct tsch_packet *p)
Free a packet.
Definition: tsch-queue.c:319
PROCESS_THREAD(cc2538_rf_process, ev, data)
Implementation of the cc2538 RF driver process.
Definition: cc2538-rf.c:1107
unsigned short random_rand(void)
Generates a new random number using the cc2538 RNG.
Definition: random.c:58
struct tsch_packet * tsch_queue_add_packet(const linkaddr_t *addr, uint8_t max_transmissions, mac_callback_t sent, void *ptr)
Add packet to neighbor queue.
Definition: tsch-queue.c:230
void tsch_adaptive_timesync_reset(void)
Reset the status of the module.
Stores data about an incoming packet.
Definition: tsch-types.h:152
void etimer_reset(struct etimer *et)
Reset an event timer with the same interval as was previously set.
Definition: etimer.c:192
Header file for the logging system
The MAC layer deferred the transmission for a later time.
Definition: mac.h:94
void tsch_slot_operation_start(void)
Start actual slot operation.
int tsch_packet_parse_eb(const uint8_t *buf, int buf_size, frame802154_t *frame, struct ieee802154_ies *ies, uint8_t *hdr_len, int frame_without_mic)
Parse EB.
Definition: tsch-packet.c:387
void etimer_set(struct etimer *et, clock_time_t interval)
Set an event timer.
Definition: etimer.c:177
The ASN is an absolute slot number over 5 bytes.
Definition: tsch-asn.h:48
void tsch_schedule_create_minimal(void)
Create a 6tisch minimal schedule with length TSCH_SCHEDULE_DEFAULT_LENGTH.
#define PROCESS_WAIT_UNTIL(c)
Wait for a condition to occur.
Definition: process.h:192
void tsch_set_coordinator(int enable)
Set the node as PAN coordinator.
Definition: tsch.c:168
void process_start(struct process *p, process_data_t data)
Start a process.
Definition: process.c:99