55 #include "sys/critical.h" 60 #ifndef TSCH_DEBUG_INIT 61 #define TSCH_DEBUG_INIT() 63 #ifndef TSCH_DEBUG_INTERRUPT 64 #define TSCH_DEBUG_INTERRUPT() 66 #ifndef TSCH_DEBUG_RX_EVENT 67 #define TSCH_DEBUG_RX_EVENT() 69 #ifndef TSCH_DEBUG_TX_EVENT 70 #define TSCH_DEBUG_TX_EVENT() 72 #ifndef TSCH_DEBUG_SLOT_START 73 #define TSCH_DEBUG_SLOT_START() 75 #ifndef TSCH_DEBUG_SLOT_END 76 #define TSCH_DEBUG_SLOT_END() 80 #if (TSCH_MAX_INCOMING_PACKETS & (TSCH_MAX_INCOMING_PACKETS - 1)) != 0 81 #error TSCH_MAX_INCOMING_PACKETS must be power of two 85 #if TSCH_DEQUEUED_ARRAY_SIZE < QUEUEBUF_NUM 86 #error TSCH_DEQUEUED_ARRAY_SIZE must be greater or equal to QUEUEBUF_NUM 88 #if (TSCH_DEQUEUED_ARRAY_SIZE & (TSCH_DEQUEUED_ARRAY_SIZE - 1)) != 0 89 #error TSCH_DEQUEUED_ARRAY_SIZE must be power of two 94 #define SYNC_IE_BOUND ((int32_t)US_TO_RTIMERTICKS(tsch_timing_us[tsch_ts_rx_wait] / 4)) 97 #if RTIMER_SECOND < (32 * 1024) 98 #error "TSCH: RTIMER_SECOND < (32 * 1024)" 100 #if CONTIKI_TARGET_COOJA 102 #define RTIMER_GUARD 0u 103 #elif RTIMER_SECOND >= 200000 104 #define RTIMER_GUARD (RTIMER_SECOND / 100000) 106 #define RTIMER_GUARD 2u 109 enum tsch_radio_state_on_cmd {
110 TSCH_RADIO_CMD_ON_START_OF_TIMESLOT,
111 TSCH_RADIO_CMD_ON_WITHIN_TIMESLOT,
112 TSCH_RADIO_CMD_ON_FORCE,
115 enum tsch_radio_state_off_cmd {
116 TSCH_RADIO_CMD_OFF_END_OF_TIMESLOT,
117 TSCH_RADIO_CMD_OFF_WITHIN_TIMESLOT,
118 TSCH_RADIO_CMD_OFF_FORCE,
123 struct ringbufindex dequeued_ringbuf;
124 struct tsch_packet *dequeued_array[TSCH_DEQUEUED_ARRAY_SIZE];
127 struct ringbufindex input_ringbuf;
128 struct input_packet input_array[TSCH_MAX_INCOMING_PACKETS];
133 clock_time_t tsch_last_sync_time;
136 static volatile int tsch_locked = 0;
138 static volatile int tsch_lock_requested = 0;
142 static int32_t drift_correction = 0;
144 static uint8_t is_drift_correction_used;
147 static rtimer_clock_t
volatile current_slot_start;
150 static volatile int tsch_in_slot_operation = 0;
153 uint8_t tsch_current_channel;
154 uint8_t tsch_current_channel_offset;
162 static struct tsch_link *backup_link = NULL;
167 static int burst_link_scheduled = 0;
169 int tsch_current_burst_count = 0;
176 static struct pt slot_operation_pt;
196 rtimer_clock_t busy_wait_time;
199 tsch_lock_requested = 1;
201 if(tsch_in_slot_operation) {
204 while(tsch_in_slot_operation) {
207 busy_wait_time =
RTIMER_NOW() - busy_wait_time;
212 tsch_lock_requested = 0;
216 snprintf(log->message,
sizeof(log->message),
217 "!get lock delay %u", (
unsigned)busy_wait_time);
224 snprintf(log->message,
sizeof(log->message),
244 #if TSCH_WITH_LINK_SELECTOR 246 uint16_t packet_channel_offset = queuebuf_attr(p->qb, PACKETBUF_ATTR_TSCH_CHANNEL_OFFSET);
247 if(packet_channel_offset != 0xffff) {
249 return packet_channel_offset;
253 return link->channel_offset;
267 uint16_t index_of_0, index_of_offset;
268 index_of_0 =
TSCH_ASN_MOD(*asn, tsch_hopping_sequence_length);
269 index_of_offset = (index_of_0 + channel_offset) % tsch_hopping_sequence_length.val;
270 return tsch_hopping_sequence[index_of_offset];
279 check_timer_miss(rtimer_clock_t ref_time, rtimer_clock_t offset, rtimer_clock_t now)
281 rtimer_clock_t target = ref_time + offset;
282 int now_has_overflowed = now < ref_time;
283 int target_has_overflowed = target < ref_time;
285 if(now_has_overflowed == target_has_overflowed) {
287 return target <= now;
293 return now_has_overflowed;
301 tsch_schedule_slot_operation(
struct rtimer *tm, rtimer_clock_t ref_time, rtimer_clock_t offset,
const char *str)
307 int missed = check_timer_miss(ref_time, offset - RTIMER_GUARD, now);
311 snprintf(log->message,
sizeof(log->message),
313 str, (
int)(now-ref_time), (
int)offset);
316 r =
rtimer_set(tm, ref_time + offset, 1, (
void (*)(
struct rtimer *,
void *))tsch_slot_operation, NULL);
330 #define TSCH_SCHEDULE_AND_YIELD(pt, tm, ref_time, offset, str) \ 332 if(tsch_schedule_slot_operation(tm, ref_time, offset - RTIMER_GUARD, str)) { \ 334 RTIMER_BUSYWAIT_UNTIL_ABS(0, ref_time, offset); \ 346 if(link->link_options & LINK_OPTION_TX) {
348 if(link->link_type == LINK_TYPE_ADVERTISING || link->link_type == LINK_TYPE_ADVERTISING_ONLY) {
353 if(link->link_type != LINK_TYPE_ADVERTISING_ONLY) {
360 if(p == NULL && n == n_broadcast) {
367 if(target_neighbor != NULL) {
368 *target_neighbor = n;
378 uint64_t uptime_ticks;
381 if(!tsch_is_associated) {
388 uptime_asn = last_sync_asn.ls4b + ((uint64_t)last_sync_asn.ms1b << 32);
390 uptime_ticks = uptime_asn * tsch_timing[tsch_ts_timeslot_length];
394 uptime_ticks += (
clock_time() - tsch_last_sync_time);
413 case TSCH_RADIO_CMD_ON_START_OF_TIMESLOT:
414 if(TSCH_RADIO_ON_DURING_TIMESLOT) {
418 case TSCH_RADIO_CMD_ON_WITHIN_TIMESLOT:
419 if(!TSCH_RADIO_ON_DURING_TIMESLOT) {
423 case TSCH_RADIO_CMD_ON_FORCE:
444 case TSCH_RADIO_CMD_OFF_END_OF_TIMESLOT:
445 if(TSCH_RADIO_ON_DURING_TIMESLOT) {
449 case TSCH_RADIO_CMD_OFF_WITHIN_TIMESLOT:
450 if(!TSCH_RADIO_ON_DURING_TIMESLOT) {
454 case TSCH_RADIO_CMD_OFF_FORCE:
459 NETSTACK_RADIO.off();
478 static uint8_t mac_tx_status;
481 static int dequeued_index;
482 static int packet_ready = 1;
486 TSCH_DEBUG_TX_EVENT();
491 if(dequeued_index != -1) {
492 if(current_packet == NULL || current_packet->qb == NULL) {
493 mac_tx_status = MAC_TX_ERR_FATAL;
497 #if LLSEC802154_ENABLED 499 static uint8_t encrypted_packet[TSCH_PACKET_MAX_LEN];
502 static uint8_t packet_len;
504 static uint8_t seqno;
506 static uint8_t do_wait_for_ack;
507 static rtimer_clock_t tx_start_time;
509 static int burst_link_requested;
512 static uint8_t cca_status;
516 packet = queuebuf_dataptr(current_packet->qb);
517 packet_len = queuebuf_datalen(current_packet->qb);
519 do_wait_for_ack = !current_neighbor->is_broadcast;
521 burst_link_requested = 0;
523 && tsch_current_burst_count + 1 < TSCH_BURST_MAX_LEN
525 burst_link_requested = 1;
529 seqno = ((uint8_t *)(packet))[2];
531 if(current_neighbor == n_eb) {
537 #if LLSEC802154_ENABLED 538 if(tsch_is_pan_secured) {
541 int with_encryption = queuebuf_attr(current_packet->qb, PACKETBUF_ATTR_SECURITY_LEVEL) & 0x4;
543 packet_len - current_packet->header_len, &tsch_current_asn);
544 if(with_encryption) {
545 packet = encrypted_packet;
551 if(packet_ready && NETSTACK_RADIO.prepare(packet, packet_len) == 0) {
552 static rtimer_clock_t tx_duration;
557 TSCH_SCHEDULE_AND_YIELD(pt, t, current_slot_start, tsch_timing[tsch_ts_cca_offset],
"cca");
558 TSCH_DEBUG_TX_EVENT();
562 current_slot_start, tsch_timing[tsch_ts_cca_offset] + tsch_timing[tsch_ts_cca]);
563 TSCH_DEBUG_TX_EVENT();
566 if(cca_status == 0) {
572 TSCH_SCHEDULE_AND_YIELD(pt, t, current_slot_start, tsch_timing[tsch_ts_tx_offset] - RADIO_DELAY_BEFORE_TX,
"TxBeforeTx");
573 TSCH_DEBUG_TX_EVENT();
575 mac_tx_status = NETSTACK_RADIO.transmit(packet_len);
578 tx_start_time = current_slot_start + tsch_timing[tsch_ts_tx_offset];
580 tx_duration = TSCH_PACKET_DURATION(packet_len);
582 tx_duration = MIN(tx_duration, tsch_timing[tsch_ts_max_tx]);
586 if(mac_tx_status == RADIO_TX_OK) {
587 if(do_wait_for_ack) {
588 uint8_t ackbuf[TSCH_PACKET_MAX_LEN];
590 rtimer_clock_t ack_start_time;
592 struct ieee802154_ies ack_ies;
596 #if TSCH_HW_FRAME_FILTERING 599 NETSTACK_RADIO.get_value(RADIO_PARAM_RX_MODE, &radio_rx_mode);
603 TSCH_SCHEDULE_AND_YIELD(pt, t, current_slot_start,
604 tsch_timing[tsch_ts_tx_offset] + tx_duration + tsch_timing[tsch_ts_rx_ack_delay] - RADIO_DELAY_BEFORE_RX,
"TxBeforeAck");
605 TSCH_DEBUG_TX_EVENT();
609 tx_start_time, tx_duration + tsch_timing[tsch_ts_rx_ack_delay] + tsch_timing[tsch_ts_ack_wait] + RADIO_DELAY_BEFORE_DETECT);
610 TSCH_DEBUG_TX_EVENT();
612 ack_start_time =
RTIMER_NOW() - RADIO_DELAY_BEFORE_DETECT;
616 ack_start_time, tsch_timing[tsch_ts_max_ack]);
617 TSCH_DEBUG_TX_EVENT();
620 #if TSCH_HW_FRAME_FILTERING 622 NETSTACK_RADIO.get_value(RADIO_PARAM_RX_MODE, &radio_rx_mode);
627 ack_len = NETSTACK_RADIO.read((
void *)ackbuf,
sizeof(ackbuf));
632 is_time_source = current_neighbor != NULL && current_neighbor->is_time_source;
634 &frame, &ack_ies, &ack_hdrlen) == 0) {
638 #if LLSEC802154_ENABLED 641 &frame, ¤t_neighbor->addr, &tsch_current_asn)) {
643 snprintf(log->message,
sizeof(log->message),
644 "!failed to authenticate ACK"));
649 snprintf(log->message,
sizeof(log->message),
650 "!failed to parse ACK"));
657 int32_t eack_time_correction = US_TO_RTIMERTICKS(ack_ies.ie_time_correction);
658 int32_t since_last_timesync =
TSCH_ASN_DIFF(tsch_current_asn, last_sync_asn);
659 if(eack_time_correction > SYNC_IE_BOUND) {
660 drift_correction = SYNC_IE_BOUND;
661 }
else if(eack_time_correction < -SYNC_IE_BOUND) {
662 drift_correction = -SYNC_IE_BOUND;
664 drift_correction = eack_time_correction;
666 if(drift_correction != eack_time_correction) {
668 snprintf(log->message,
sizeof(log->message),
669 "!truncated dr %d %d", (
int)eack_time_correction, (
int)drift_correction);
672 tsch_stats_on_time_synchronization(eack_time_correction);
673 is_drift_correction_used = 1;
676 last_sync_asn = tsch_current_asn;
684 if(burst_link_requested) {
685 burst_link_scheduled = 1;
704 current_packet->transmissions++;
705 current_packet->ret = mac_tx_status;
712 dequeued_array[dequeued_index] = current_packet;
717 if(current_neighbor != NULL && current_neighbor->is_time_source) {
718 tsch_stats_tx_packet(current_neighbor, mac_tx_status, tsch_current_channel);
723 log->tx.mac_tx_status = mac_tx_status;
724 log->tx.num_tx = current_packet->transmissions;
725 log->tx.datalen = queuebuf_datalen(current_packet->qb);
726 log->tx.drift = drift_correction;
727 log->tx.drift_used = is_drift_correction_used;
728 log->tx.is_data = ((((uint8_t *)(queuebuf_dataptr(current_packet->qb)))[0]) & 7) == FRAME802154_DATAFRAME;
729 #
if LLSEC802154_ENABLED
730 log->tx.sec_level = queuebuf_attr(current_packet->qb, PACKETBUF_ATTR_SECURITY_LEVEL);
732 log->tx.sec_level = 0;
734 linkaddr_copy(&log->tx.dest, queuebuf_addr(current_packet->qb, PACKETBUF_ADDR_RECEIVER));
735 log->tx.seqno = queuebuf_attr(current_packet->qb, PACKETBUF_ATTR_MAC_SEQNO);
742 TSCH_DEBUG_TX_EVENT();
760 static linkaddr_t source_address;
761 static linkaddr_t destination_address;
762 static int16_t input_index;
763 static int input_queue_drop = 0;
767 TSCH_DEBUG_RX_EVENT();
770 if(input_index == -1) {
775 static int32_t estimated_drift;
777 static rtimer_clock_t rx_start_time;
778 static rtimer_clock_t expected_rx_time;
779 static rtimer_clock_t packet_duration;
782 expected_rx_time = current_slot_start + tsch_timing[tsch_ts_tx_offset];
784 rx_start_time = expected_rx_time;
786 current_input = &input_array[input_index];
789 TSCH_SCHEDULE_AND_YIELD(pt, t, current_slot_start, tsch_timing[tsch_ts_rx_offset] - RADIO_DELAY_BEFORE_RX,
"RxBeforeListen");
790 TSCH_DEBUG_RX_EVENT();
794 packet_seen = NETSTACK_RADIO.receiving_packet() || NETSTACK_RADIO.pending_packet();
798 current_slot_start, tsch_timing[tsch_ts_rx_offset] + tsch_timing[tsch_ts_rx_wait] + RADIO_DELAY_BEFORE_DETECT);
804 TSCH_DEBUG_RX_EVENT();
806 rx_start_time =
RTIMER_NOW() - RADIO_DELAY_BEFORE_DETECT;
810 current_slot_start, tsch_timing[tsch_ts_rx_offset] + tsch_timing[tsch_ts_rx_wait] + tsch_timing[tsch_ts_max_tx]);
811 TSCH_DEBUG_RX_EVENT();
814 if(NETSTACK_RADIO.pending_packet()) {
815 static int frame_valid;
816 static int header_len;
822 current_input->len = NETSTACK_RADIO.read((
void *)current_input->payload, TSCH_PACKET_MAX_LEN);
823 NETSTACK_RADIO.get_value(RADIO_PARAM_LAST_RSSI, &radio_last_rssi);
824 current_input->rx_asn = tsch_current_asn;
825 current_input->rssi = (signed)radio_last_rssi;
826 current_input->channel = tsch_current_channel;
827 header_len =
frame802154_parse((uint8_t *)current_input->payload, current_input->len, &frame);
828 frame_valid = header_len > 0 &&
829 frame802154_check_dest_panid(&frame) &&
830 frame802154_extract_linkaddr(&frame, &source_address, &destination_address);
832 #if TSCH_RESYNC_WITH_SFD_TIMESTAMPS 834 NETSTACK_RADIO.get_object(RADIO_PARAM_LAST_PACKET_TIMESTAMP, &rx_start_time,
sizeof(rtimer_clock_t));
837 packet_duration = TSCH_PACKET_DURATION(current_input->len);
839 packet_duration = MIN(packet_duration, tsch_timing[tsch_ts_max_tx]);
843 snprintf(log->message,
sizeof(log->message),
844 "!failed to parse frame %u %u", header_len, current_input->len));
851 snprintf(log->message,
sizeof(log->message),
852 "!discarding frame with type %u, len %u", frame.
fcf.
frame_type, current_input->len));
857 #if LLSEC802154_ENABLED 862 &frame, &source_address, &tsch_current_asn)) {
866 snprintf(log->message,
sizeof(log->message),
867 "!failed to authenticate frame %u", current_input->len));
882 estimated_drift = RTIMER_CLOCK_DIFF(expected_rx_time, rx_start_time);
883 tsch_stats_on_time_synchronization(estimated_drift);
885 #if TSCH_TIMESYNC_REMOVE_JITTER 887 if(ABS(estimated_drift) <= TSCH_TIMESYNC_MEASUREMENT_ERROR) {
889 }
else if(estimated_drift > 0) {
890 estimated_drift -= TSCH_TIMESYNC_MEASUREMENT_ERROR;
892 estimated_drift += TSCH_TIMESYNC_MEASUREMENT_ERROR;
896 #ifdef TSCH_CALLBACK_DO_NACK 898 do_nack = TSCH_CALLBACK_DO_NACK(current_link,
899 &source_address, &destination_address);
904 static uint8_t ack_buf[TSCH_PACKET_MAX_LEN];
909 &source_address, frame.
seq, (int16_t)RTIMERTICKS_TO_US(estimated_drift), do_nack);
912 #if LLSEC802154_ENABLED 913 if(tsch_is_pan_secured) {
920 NETSTACK_RADIO.prepare((
const void *)ack_buf, ack_len);
923 TSCH_SCHEDULE_AND_YIELD(pt, t, rx_start_time,
924 packet_duration + tsch_timing[tsch_ts_tx_ack_delay] - RADIO_DELAY_BEFORE_TX,
"RxBeforeAck");
925 TSCH_DEBUG_RX_EVENT();
926 NETSTACK_RADIO.transmit(ack_len);
936 if(n != NULL && n->is_time_source) {
937 int32_t since_last_timesync =
TSCH_ASN_DIFF(tsch_current_asn, last_sync_asn);
939 last_sync_asn = tsch_current_asn;
942 drift_correction = -estimated_drift;
943 is_drift_correction_used = 1;
954 NETSTACK_RADIO.get_value(RADIO_PARAM_LAST_LINK_QUALITY, &radio_last_lqi);
955 tsch_stats_rx_packet(n, current_input->rssi, radio_last_lqi, tsch_current_channel);
962 log->rx.datalen = current_input->len;
963 log->rx.drift = drift_correction;
964 log->rx.drift_used = is_drift_correction_used;
965 log->rx.is_data = frame.
fcf.
frame_type == FRAME802154_DATAFRAME;
967 log->rx.estimated_drift = estimated_drift;
968 log->rx.seqno = frame.
seq;
980 if(input_queue_drop != 0) {
982 snprintf(log->message,
sizeof(log->message),
983 "!queue full skipped %u", input_queue_drop);
985 input_queue_drop = 0;
989 TSCH_DEBUG_RX_EVENT();
999 TSCH_DEBUG_INTERRUPT();
1003 while(tsch_is_associated) {
1005 if(current_link == NULL || tsch_lock_requested) {
1009 snprintf(log->message,
sizeof(log->message),
1010 "!skipped slot %u %u %u",
1012 tsch_lock_requested,
1013 current_link == NULL);
1018 TSCH_DEBUG_SLOT_START();
1019 tsch_in_slot_operation = 1;
1021 tsch_stats_sample_rssi();
1023 drift_correction = 0;
1024 is_drift_correction_used = 0;
1026 current_packet = get_packet_and_neighbor_for_link(current_link, ¤t_neighbor);
1029 if(current_packet == NULL && !(current_link->link_options & LINK_OPTION_RX) && backup_link != NULL) {
1030 current_link = backup_link;
1031 current_packet = get_packet_and_neighbor_for_link(current_link, ¤t_neighbor);
1033 is_active_slot = current_packet != NULL || (current_link->link_options & LINK_OPTION_RX);
1034 if(is_active_slot) {
1037 if(burst_link_scheduled) {
1039 burst_link_scheduled = 0;
1042 tsch_current_channel_offset = tsch_get_channel_offset(current_link, current_packet);
1045 NETSTACK_RADIO.set_value(RADIO_PARAM_CHANNEL, tsch_current_channel);
1050 if(current_packet != NULL) {
1056 static struct pt slot_tx_pt;
1057 PT_SPAWN(&slot_operation_pt, &slot_tx_pt, tsch_tx_slot(&slot_tx_pt, t));
1060 static struct pt slot_rx_pt;
1061 PT_SPAWN(&slot_operation_pt, &slot_rx_pt, tsch_rx_slot(&slot_rx_pt, t));
1066 burst_link_scheduled = 0;
1068 TSCH_DEBUG_SLOT_END();
1073 if(tsch_is_coordinator) {
1076 last_sync_asn = tsch_current_asn;
1081 if(!tsch_is_coordinator && (
TSCH_ASN_DIFF(tsch_current_asn, last_sync_asn) >
1082 (100 * TSCH_CLOCK_TO_SLOTS(TSCH_DESYNC_THRESHOLD / 100, tsch_timing[tsch_ts_timeslot_length])))) {
1084 snprintf(log->message,
sizeof(log->message),
1085 "! leaving the network, last sync %u",
1092 uint16_t timeslot_diff = 0;
1093 rtimer_clock_t prev_slot_start;
1095 rtimer_clock_t time_to_next_active_slot;
1098 if(current_link != NULL
1099 && current_link->link_options & LINK_OPTION_TX
1100 && current_link->link_options & LINK_OPTION_SHARED) {
1108 if(burst_link_scheduled && current_link != NULL) {
1112 tsch_current_burst_count++;
1116 if(current_link == NULL) {
1123 tsch_current_burst_count = 0;
1130 time_to_next_active_slot = timeslot_diff * tsch_timing[tsch_ts_timeslot_length] + drift_correction;
1132 drift_correction = 0;
1133 is_drift_correction_used = 0;
1135 prev_slot_start = current_slot_start;
1136 current_slot_start += time_to_next_active_slot;
1137 }
while(!tsch_schedule_slot_operation(t, prev_slot_start, time_to_next_active_slot,
"main"));
1140 tsch_in_slot_operation = 0;
1144 PT_END(&slot_operation_pt);
1152 static struct rtimer slot_operation_timer;
1153 rtimer_clock_t time_to_next_active_slot;
1154 rtimer_clock_t prev_slot_start;
1157 uint16_t timeslot_diff;
1160 if(current_link == NULL) {
1168 time_to_next_active_slot = timeslot_diff * tsch_timing[tsch_ts_timeslot_length];
1172 prev_slot_start = current_slot_start;
1173 current_slot_start += time_to_next_active_slot;
1174 }
while(!tsch_schedule_slot_operation(&slot_operation_timer, prev_slot_start, time_to_next_active_slot,
"assoc"));
1184 current_slot_start = next_slot_start;
1185 tsch_current_asn = *next_slot_asn;
1187 last_sync_asn = tsch_current_asn;
1190 current_link = NULL;
#define TSCH_LOG_ADD(log_type, init_code)
Use this macro to add a log to the queue (will be printed out later, after leaving interrupt context)...
frame802154_scf_t security_control
Security control bitfield.
struct tsch_neighbor * tsch_queue_get_nbr(const linkaddr_t *addr)
Get a TSCH neighbor.
static void tsch_radio_off(enum tsch_radio_state_off_cmd command)
This function turns off the radio.
int rtimer_set(struct rtimer *rtimer, rtimer_clock_t time, rtimer_clock_t duration, rtimer_callback_t func, void *ptr)
Post a real-time task.
The MAC layer did not get an acknowledgement for the packet.
frame802154_fcf_t fcf
Frame control field.
Representation of a real-time task.
int tsch_get_lock(void)
Takes the TSCH lock.
Header file for the radio API
uint8_t security_level
3 bit.
static void critical_exit(int_master_status_t status)
Exit a critical section and restore the master interrupt.
void tsch_release_lock(void)
Releases the TSCH lock.
int frame802154_parse(uint8_t *data, int len, frame802154_t *pf)
Parses an input frame.
TSCH neighbor information.
void tsch_queue_update_all_backoff_windows(const linkaddr_t *dest_addr)
Decrement backoff window for the queue(s) able to Tx to a given address.
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.
#define PT_BEGIN(pt)
Declare the start of a protothread inside the C function implementing the protothread.
void tsch_timesync_update(struct tsch_neighbor *n, uint16_t time_delta_asn, int32_t drift_correction)
Updates timesync information for a given neighbor.
int radio_value_t
Each radio has a set of parameters that designate the current configuration and state of the radio...
uint8_t src_addr[8]
Source address.
A MAC framer for IEEE 802.15.4
const linkaddr_t linkaddr_null
The null link-layer address.
#define PT_SPAWN(pt, child, thread)
Spawn a child protothread and wait until it exits.
The MAC layer transmission was OK.
rtimer task is scheduled successfully
int tsch_packet_update_eb(uint8_t *buf, int buf_size, uint8_t tsch_sync_ie_offset)
Update ASN in EB packet.
linkaddr_t linkaddr_node_addr
The link-layer address of the node.
static int_master_status_t critical_enter()
Enter a critical section.
#define RTIMER_NOW()
Get the current clock time.
int32_t tsch_timesync_adaptive_compensate(rtimer_clock_t delta_ticks)
Computes time compensation for a given point in the future.
unsigned int tsch_security_mic_len(const frame802154_t *frame)
Return MIC length.
INT_MASTER_STATUS_DATATYPE int_master_status_t
Master interrupt state representation data type.
#define CLOCK_SECOND
A second, measured in system clock time.
#define PT_END(pt)
Declare the end of a protothread.
Header file for the Packet queue buffer management
void process_poll(struct process *p)
Request a process to be polled.
struct tsch_link * tsch_schedule_get_next_active_link(struct tsch_asn_t *asn, uint16_t *time_offset, struct tsch_link **backup_link)
Returns the next active link after a given ASN, and a backup link (for the same ASN, with Rx flag)
static uint8_t tsch_calculate_channel(struct tsch_asn_t *asn, uint16_t channel_offset)
Returns a 802.15.4 channel from an ASN and channel offset.
void tsch_schedule_keepalive(int immediate)
Schedule a keep-alive transmission within [timeout*0.9, timeout[ Can be called from an interrupt...
#define TSCH_ASN_MOD(asn, div)
Returns the result (16 bits) of a modulo operation on ASN, with divisor being a struct asn_divisor_t...
#define PT_YIELD(pt)
Yield from the current protothread.
int tsch_packet_parse_eack(const uint8_t *buf, int buf_size, uint8_t seqno, frame802154_t *frame, struct ieee802154_ies *ies, uint8_t *hdr_len)
Parse enhanced ACK packet.
Main API declarations for TSCH.
clock_time_t clock_time(void)
Get the current clock time.
#define RTIMER_BUSYWAIT_UNTIL_ABS(cond, t0, max_time)
Busy-wait until a condition.
The MAC layer transmission could not be performed because of a fatal error.
struct tsch_packet * tsch_queue_get_packet_for_nbr(const struct tsch_neighbor *n, struct tsch_link *link)
Returns the first packet that can be sent from a queue on a given link.
#define RADIO_RX_MODE_ADDRESS_FILTER
The radio reception mode controls address filtering and automatic transmission of acknowledgements in...
int tsch_is_locked(void)
Checks if the TSCH lock is set.
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.
void linkaddr_copy(linkaddr_t *dest, const linkaddr_t *src)
Copy a link-layer address.
#define PT_THREAD(name_args)
Declaration of a protothread.
uint64_t tsch_get_network_uptime_ticks(void)
Get the time, in clock ticks, since the TSCH network was started.
void tsch_packet_set_frame_pending(uint8_t *buf, int buf_size)
Set frame pending bit in a packet (whose header was already build)
int tsch_queue_packet_sent(struct tsch_neighbor *n, struct tsch_packet *p, struct tsch_link *link, uint8_t mac_tx_status)
Updates neighbor queue state after a transmission.
#define TSCH_ASN_DIFF(asn1, asn2)
Returns the 32-bit diff between asn1 and asn2.
int linkaddr_cmp(const linkaddr_t *addr1, const linkaddr_t *addr2)
Compare two link-layer addresses.
static void tsch_radio_on(enum tsch_radio_state_on_cmd command)
This function turns on the radio.
int tsch_queue_packet_count(const linkaddr_t *addr)
Returns the number of packets currently a given neighbor queue.
#define TSCH_ASN_INC(asn, inc)
Increment an ASN by inc (32 bits)
uint8_t seq
Sequence number.
int tsch_packet_get_frame_pending(uint8_t *buf, int buf_size)
Get frame pending bit from a packet.
int ringbufindex_peek_put(const struct ringbufindex *r)
Check if there is space to put an element.
void tsch_disassociate(void)
Leave the TSCH network we are currently in.
An IEEE 802.15.4-2015 TSCH link (also called cell or slot)
Header file for the Packet buffer (packetbuf) management
Include file for the Contiki low-layer network stack (NETSTACK)
void watchdog_periodic(void)
Writes the WDT clear sequence.
struct tsch_packet * tsch_queue_get_unicast_packet_for_any(struct tsch_neighbor **n, struct tsch_link *link)
Gets the head packet of any neighbor queue with zero backoff counter.
unsigned int tsch_security_secure_frame(uint8_t *hdr, uint8_t *outbuf, int hdrlen, int datalen, struct tsch_asn_t *asn)
Protect a frame with encryption and/or MIC.
Header file for the logging system
The MAC layer deferred the transmission for a later time.
uint8_t ack_required
1 bit.
int ringbufindex_put(struct ringbufindex *r)
Put one element to the ring buffer.
void tsch_slot_operation_start(void)
Start actual slot operation.
The ASN is an absolute slot number over 5 bytes.
frame802154_aux_hdr_t aux_hdr
Aux security header.
int tsch_packet_create_eack(uint8_t *buf, uint16_t buf_len, const linkaddr_t *dest_addr, uint8_t seqno, int16_t drift, int nack)
Construct Enhanced ACK packet.