From d79ce957a1e3221600897872fbf7c8eff2af115c Mon Sep 17 00:00:00 2001 From: Atis Elsts Date: Wed, 11 Nov 2015 17:34:33 +0100 Subject: [PATCH] Adaptive time synchronization for TSCH --- apps/orchestra/orchestra-conf.h | 6 +- core/net/mac/tsch/Makefile.tsch | 2 +- core/net/mac/tsch/tsch-adaptive-timesync.c | 186 +++++++++++++++++++++ core/net/mac/tsch/tsch-adaptive-timesync.h | 89 ++++++++++ core/net/mac/tsch/tsch-conf.h | 7 + core/net/mac/tsch/tsch-slot-operation.c | 48 ++++-- core/net/mac/tsch/tsch-slot-operation.h | 11 -- platform/sky/platform-conf.h | 2 + platform/z1/platform-conf.h | 2 + 9 files changed, 327 insertions(+), 26 deletions(-) create mode 100644 core/net/mac/tsch/tsch-adaptive-timesync.c create mode 100644 core/net/mac/tsch/tsch-adaptive-timesync.h diff --git a/apps/orchestra/orchestra-conf.h b/apps/orchestra/orchestra-conf.h index 2d3379e7e..910917620 100644 --- a/apps/orchestra/orchestra-conf.h +++ b/apps/orchestra/orchestra-conf.h @@ -98,8 +98,8 @@ /* Is the "hash" function collision-free? (e.g. it maps to unique node-ids) */ #ifdef ORCHESTRA_CONF_COLLISION_FREE_HASH #define ORCHESTRA_COLLISION_FREE_HASH ORCHESTRA_CONF_COLLISION_FREE_HASH -#else /* ORCHESTRA_CONF_MAX_HASH */ -#define ORCHESTRA_CONF_COLLISION_FREE_HASH 0 /* Set to 1 if ORCHESTRA_LINKADDR_HASH returns unique hashes */ -#endif /* ORCHESTRA_CONF_MAX_HASH */ +#else /* ORCHESTRA_CONF_COLLISION_FREE_HASH */ +#define ORCHESTRA_COLLISION_FREE_HASH 0 /* Set to 1 if ORCHESTRA_LINKADDR_HASH returns unique hashes */ +#endif /* ORCHESTRA_CONF_COLLISION_FREE_HASH */ #endif /* __ORCHESTRA_CONF_H__ */ diff --git a/core/net/mac/tsch/Makefile.tsch b/core/net/mac/tsch/Makefile.tsch index 59487923c..e19ff8b13 100644 --- a/core/net/mac/tsch/Makefile.tsch +++ b/core/net/mac/tsch/Makefile.tsch @@ -1 +1 @@ -CONTIKI_SOURCEFILES += tsch.c tsch-slot-operation.c tsch-queue.c tsch-packet.c tsch-schedule.c tsch-log.c tsch-rpl.c +CONTIKI_SOURCEFILES += tsch.c tsch-slot-operation.c tsch-queue.c tsch-packet.c tsch-schedule.c tsch-log.c tsch-rpl.c tsch-adaptive-timesync.c diff --git a/core/net/mac/tsch/tsch-adaptive-timesync.c b/core/net/mac/tsch/tsch-adaptive-timesync.c new file mode 100644 index 000000000..0b4601621 --- /dev/null +++ b/core/net/mac/tsch/tsch-adaptive-timesync.c @@ -0,0 +1,186 @@ +/* + * Copyright (c) 2015, SICS Swedish ICT. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + * + */ + +/** + * \file + * TSCH adaptive time synchronization + * \author + * Atis Elsts + * + */ + +#include "tsch-adaptive-timesync.h" +#include "tsch-log.h" +#include + +#if TSCH_ADAPTIVE_TIMESYNC + +/* Estimated drift of the time-source neighbor. Can be negative. + * Units used: ppm multiplied by 256. */ +static int32_t drift_ppm; +/* Ticks compensated locally since the last timesync time */ +static int32_t compensated_ticks; +/* Number of already recorded timesync history entries */ +static uint8_t timesync_entry_count; +/* Since last learning of the drift; may be more than time since last timesync */ +static uint32_t asn_since_last_learning; + +/* Units in which drift is stored: ppm * 256 */ +#define TSCH_DRIFT_UNIT (1000L * 1000 * 256) + +/*---------------------------------------------------------------------------*/ +/* Add a value to a moving average estimator */ +static int32_t +timesync_entry_add(int32_t val, uint32_t time_delta) +{ +#define NUM_TIMESYNC_ENTRIES 8 + static int32_t buffer[NUM_TIMESYNC_ENTRIES]; + static uint8_t pos; + int i; + if(timesync_entry_count == 0) { + pos = 0; + } + buffer[pos] = val; + if(timesync_entry_count < NUM_TIMESYNC_ENTRIES) { + timesync_entry_count++; + } + pos = (pos + 1) % NUM_TIMESYNC_ENTRIES; + + val = 0; + for(i = 0; i < timesync_entry_count; ++i) { + val += buffer[i]; + } + return val / timesync_entry_count; +} +/*---------------------------------------------------------------------------*/ +/* Learn the neighbor drift rate at ppm */ +static void +timesync_learn_drift_ticks(uint32_t time_delta_asn, int32_t drift_ticks) +{ + /* should fit in 32-bit unsigned integer */ + uint32_t time_delta_ticks = time_delta_asn * tsch_timing[tsch_ts_timeslot_length]; + int32_t real_drift_ticks = drift_ticks + compensated_ticks; + int32_t last_drift_ppm = (int32_t)((int64_t)real_drift_ticks * TSCH_DRIFT_UNIT / time_delta_ticks); + + drift_ppm = timesync_entry_add(last_drift_ppm, time_delta_ticks); +} +/*---------------------------------------------------------------------------*/ +/* Either reset or update the neighbor's drift */ +void +tsch_timesync_update(struct tsch_neighbor *n, uint16_t time_delta_asn, int32_t drift_correction) +{ + /* Account the drift if either this is a new timesource, + * or the timedelta is not too small, as smaller timedelta + * means proportionally larger measurement error. */ + if(last_timesource_neighbor != n) { + last_timesource_neighbor = n; + drift_ppm = 0; + timesync_entry_count = 0; + compensated_ticks = 0; + asn_since_last_learning = 0; + } else { + asn_since_last_learning += time_delta_asn; + if(asn_since_last_learning >= 4 * TSCH_SLOTS_PER_SECOND) { + timesync_learn_drift_ticks(asn_since_last_learning, drift_correction); + compensated_ticks = 0; + asn_since_last_learning = 0; + } else { + /* Too small timedelta, do not recalculate the drift to avoid introducing error. instead account for the corrected ticks */ + compensated_ticks += drift_correction; + } + } +} +/*---------------------------------------------------------------------------*/ +/* Error-accumulation free compensation algorithm */ +static int32_t +compensate_internal(uint32_t time_delta_usec, int32_t drift_ppm, int32_t *remainder, int16_t *tick_conversion_error) +{ + int64_t d = (int64_t)time_delta_usec * drift_ppm + *remainder; + int32_t amount = d / TSCH_DRIFT_UNIT; + int32_t amount_ticks; + + *remainder = (int32_t)(d - amount * TSCH_DRIFT_UNIT); + + amount += *tick_conversion_error; + amount_ticks = US_TO_RTIMERTICKS(amount); + *tick_conversion_error = amount - RTIMERTICKS_TO_US(amount_ticks); + + if(ABS(amount_ticks) > RTIMER_ARCH_SECOND / 128) { + TSCH_LOG_ADD(tsch_log_message, + snprintf(log->message, sizeof(log->message), + "!too big compensation %ld delta %ld", amount_ticks, time_delta_usec)); + amount_ticks = (amount_ticks > 0 ? RTIMER_ARCH_SECOND : -RTIMER_ARCH_SECOND) / 128; + } + + return amount_ticks; +} +/*---------------------------------------------------------------------------*/ +/* Do the compensation step before scheduling a new timeslot */ +int32_t +tsch_timesync_adaptive_compensate(rtimer_clock_t time_delta_ticks) +{ + int32_t result = 0; + uint32_t time_delta_usec = RTIMERTICKS_TO_US_64(time_delta_ticks); + + /* compensate, but not if the neighbor is not known */ + if(drift_ppm && last_timesource_neighbor != NULL) { + static int32_t remainder; + static int16_t tick_conversion_error; + result = compensate_internal(time_delta_usec, drift_ppm, + &remainder, &tick_conversion_error); + compensated_ticks += result; + } + + if(TSCH_BASE_DRIFT_PPM) { + static int32_t base_drift_remainder; + static int16_t base_drift_tick_conversion_error; + result += compensate_internal(time_delta_usec, 256L * TSCH_BASE_DRIFT_PPM, + &base_drift_remainder, &base_drift_tick_conversion_error); + } + + return result; +} +/*---------------------------------------------------------------------------*/ +#else /* TSCH_ADAPTIVE_TIMESYNC */ +/*---------------------------------------------------------------------------*/ +void +tsch_timesync_update(struct tsch_neighbor *n, uint16_t time_delta_asn, int32_t drift_correction) +{ +} +/*---------------------------------------------------------------------------*/ +int32_t +tsch_timesync_adaptive_compensate(rtimer_clock_t delta_ticks) +{ + return 0; +} +/*---------------------------------------------------------------------------*/ +#endif /* TSCH_ADAPTIVE_TIMESYNC */ diff --git a/core/net/mac/tsch/tsch-adaptive-timesync.h b/core/net/mac/tsch/tsch-adaptive-timesync.h new file mode 100644 index 000000000..d043ca021 --- /dev/null +++ b/core/net/mac/tsch/tsch-adaptive-timesync.h @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2015, SICS Swedish ICT. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * This file is part of the Contiki operating system. + * + */ + +#ifndef __TSCH_ADAPTIVE_TIMESYNC_H__ +#define __TSCH_ADAPTIVE_TIMESYNC_H__ + +/********** Includes **********/ + +#include "contiki.h" +#include "net/mac/tsch/tsch-private.h" + +/******** Configuration *******/ + +/* Use SFD timestamp for synchronization? By default we merely rely on rtimer and busy wait + * until SFD is high, which we found to provide greater accuracy on JN516x and CC2420. + * Note: for association, however, we always use SFD timestamp to know the time of arrival + * of the EB (because we do not busy-wait for the whole scanning process) + * */ +#ifdef TSCH_CONF_RESYNC_WITH_SFD_TIMESTAMPS +#define TSCH_RESYNC_WITH_SFD_TIMESTAMPS TSCH_CONF_RESYNC_WITH_SFD_TIMESTAMPS +#else +#define TSCH_RESYNC_WITH_SFD_TIMESTAMPS 0 +#endif + +/* If enabled, remove jitter due to measurement errors */ +#ifdef TSCH_CONF_TIMESYNC_REMOVE_JITTER +#define TSCH_TIMESYNC_REMOVE_JITTER TSCH_CONF_TIMESYNC_REMOVE_JITTER +#else +#define TSCH_TIMESYNC_REMOVE_JITTER TSCH_RESYNC_WITH_SFD_TIMESTAMPS +#endif + +/* The jitter to remove in ticks. + * This should be the sum of measurement errors on Tx and Rx nodes. + * */ +#define TSCH_TIMESYNC_MEASUREMENT_ERROR US_TO_RTIMERTICKS(32) + +/* Base drift value. + * Used to compensate locally know inaccuracies, such as + * the effect of having a binary 32.768 kHz timer as the TSCH time base. */ +#ifdef TSCH_CONF_BASE_DRIFT_PPM +#define TSCH_BASE_DRIFT_PPM TSCH_CONF_BASE_DRIFT_PPM +#else +#define TSCH_BASE_DRIFT_PPM 0 +#endif + +/* The approximate number of slots per second */ +#define TSCH_SLOTS_PER_SECOND (1000000 / TSCH_DEFAULT_TS_TIMESLOT_LENGTH) + +/***** External Variables *****/ + +/* The neighbor last used as our time source */ +extern struct tsch_neighbor *last_timesource_neighbor; + +/********** Functions *********/ + +void tsch_timesync_update(struct tsch_neighbor *n, uint16_t time_delta_asn, int32_t drift_correction); + +int32_t tsch_timesync_adaptive_compensate(rtimer_clock_t delta_ticks); + +#endif /* __TSCH_ADAPTIVE_TIMESYNC_H__ */ diff --git a/core/net/mac/tsch/tsch-conf.h b/core/net/mac/tsch/tsch-conf.h index 6c4735d20..bd9726042 100644 --- a/core/net/mac/tsch/tsch-conf.h +++ b/core/net/mac/tsch/tsch-conf.h @@ -168,4 +168,11 @@ #define TSCH_WITH_LINK_SELECTOR 0 #endif /* TSCH_CONF_WITH_LINK_SELECTOR */ +/* Estimate the drift of the time-source neighbor and compensate for it? */ +#ifdef TSCH_CONF_ADAPTIVE_TIMESYNC +#define TSCH_ADAPTIVE_TIMESYNC TSCH_CONF_ADAPTIVE_TIMESYNC +#else +#define TSCH_ADAPTIVE_TIMESYNC 0 +#endif + #endif /* __TSCH_CONF_H__ */ diff --git a/core/net/mac/tsch/tsch-slot-operation.c b/core/net/mac/tsch/tsch-slot-operation.c index 2ce84d50e..3607ba2fb 100644 --- a/core/net/mac/tsch/tsch-slot-operation.c +++ b/core/net/mac/tsch/tsch-slot-operation.c @@ -52,6 +52,7 @@ #include "net/mac/tsch/tsch-log.h" #include "net/mac/tsch/tsch-packet.h" #include "net/mac/tsch/tsch-security.h" +#include "net/mac/tsch/tsch-adaptive-timesync.h" #if TSCH_LOG_LEVEL >= 1 #define DEBUG DEBUG_PRINT @@ -126,9 +127,13 @@ static volatile int tsch_locked = 0; static volatile int tsch_lock_requested = 0; /* Last estimated drift in RTIMER ticks - * (Sky: 1 tick ~= 30.52 uSec) */ + * (Sky: 1 tick = 30.517578125 usec exactly) */ static int32_t drift_correction = 0; -static struct tsch_neighbor *drift_neighbor = NULL; +/* Is drift correction used? (Can be true even if drift_correction == 0) */ +static uint8_t is_drift_correction_used; + +/* The neighbor last used as our time source */ +struct tsch_neighbor *last_timesource_neighbor = NULL; /* Used from tsch_slot_operation and sub-protothreads */ static rtimer_clock_t volatile current_slot_start; @@ -545,6 +550,7 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t)) if(ack_len != 0) { if(is_time_source) { int32_t eack_time_correction = US_TO_RTIMERTICKS(ack_ies.ie_time_correction); + int32_t since_last_timesync = ASN_DIFF(current_asn, last_sync_asn); if(eack_time_correction > SYNC_IE_BOUND) { drift_correction = SYNC_IE_BOUND; } else if(eack_time_correction < -SYNC_IE_BOUND) { @@ -558,7 +564,8 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t)) "!truncated dr %d %d", (int)eack_time_correction, (int)drift_correction); ); } - drift_neighbor = current_neighbor; + is_drift_correction_used = 1; + tsch_timesync_update(current_neighbor, since_last_timesync, drift_correction); /* Keep track of sync time */ last_sync_asn = current_asn; tsch_schedule_keepalive(); @@ -595,7 +602,7 @@ PT_THREAD(tsch_tx_slot(struct pt *pt, struct rtimer *t)) log->tx.num_tx = current_packet->transmissions; log->tx.datalen = queuebuf_datalen(current_packet->qb); log->tx.drift = drift_correction; - log->tx.drift_used = drift_neighbor != NULL; + log->tx.drift_used = is_drift_correction_used; log->tx.is_data = ((((uint8_t *)(queuebuf_dataptr(current_packet->qb)))[0]) & 7) == FRAME802154_DATAFRAME; log->tx.sec_level = queuebuf_attr(current_packet->qb, PACKETBUF_ATTR_SECURITY_LEVEL); log->tx.dest = TSCH_LOG_ID_FROM_LINKADDR(queuebuf_addr(current_packet->qb, PACKETBUF_ADDR_RECEIVER)); @@ -643,6 +650,7 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t)) static rtimer_clock_t rx_start_time; static rtimer_clock_t expected_rx_time; static rtimer_clock_t packet_duration; + uint8_t packet_seen; expected_rx_time = current_slot_start + tsch_timing[tsch_ts_tx_offset]; /* Default start time: expected Rx time */ @@ -656,13 +664,16 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t)) /* Start radio for at least guard time */ NETSTACK_RADIO.on(); - if(!NETSTACK_RADIO.receiving_packet()) { + packet_seen = NETSTACK_RADIO.receiving_packet(); + if(!packet_seen) { /* Check if receiving within guard time */ - BUSYWAIT_UNTIL_ABS(NETSTACK_RADIO.receiving_packet(), + BUSYWAIT_UNTIL_ABS((packet_seen = NETSTACK_RADIO.receiving_packet()), current_slot_start, tsch_timing[tsch_ts_rx_offset] + tsch_timing[tsch_ts_rx_wait]); + } + if(packet_seen) { TSCH_DEBUG_RX_EVENT(); /* Save packet timestamp */ - rx_start_time = RTIMER_NOW(); + rx_start_time = RTIMER_NOW() - RADIO_DELAY_BEFORE_DETECT; } if(!NETSTACK_RADIO.receiving_packet() && !NETSTACK_RADIO.pending_packet()) { NETSTACK_RADIO.off(); @@ -724,6 +735,17 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t)) int do_nack = 0; estimated_drift = ((int32_t)expected_rx_time - (int32_t)rx_start_time); +#if TSCH_TIMESYNC_REMOVE_JITTER + /* remove jitter due to measurement errors */ + if(abs(estimated_drift) <= TSCH_TIMESYNC_MEASUREMENT_ERROR) { + estimated_drift = 0; + } else if(estimated_drift > 0) { + estimated_drift -= TSCH_TIMESYNC_MEASUREMENT_ERROR; + } else { + estimated_drift += TSCH_TIMESYNC_MEASUREMENT_ERROR; + } +#endif + #ifdef TSCH_CALLBACK_DO_NACK if(frame.fcf.ack_required) { do_nack = TSCH_CALLBACK_DO_NACK(current_link, @@ -759,11 +781,13 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t)) /* If the sender is a time source, proceed to clock drift compensation */ n = tsch_queue_get_nbr(&source_address); if(n != NULL && n->is_time_source) { + int32_t since_last_timesync = ASN_DIFF(current_asn, last_sync_asn); /* Keep track of last sync time */ last_sync_asn = current_asn; /* Save estimated drift */ drift_correction = -estimated_drift; - drift_neighbor = n; + is_drift_correction_used = 1; + tsch_timesync_update(n, since_last_timesync, -estimated_drift); tsch_schedule_keepalive(); } @@ -776,7 +800,7 @@ PT_THREAD(tsch_rx_slot(struct pt *pt, struct rtimer *t)) log->rx.is_unicast = frame.fcf.ack_required; log->rx.datalen = current_input->len; log->rx.drift = drift_correction; - log->rx.drift_used = drift_neighbor != NULL; + log->rx.drift_used = is_drift_correction_used; log->rx.is_data = frame.fcf.frame_type == FRAME802154_DATAFRAME; log->rx.sec_level = frame.aux_hdr.security_control.security_level; log->rx.estimated_drift = estimated_drift; @@ -849,7 +873,7 @@ PT_THREAD(tsch_slot_operation(struct rtimer *t, void *ptr)) NETSTACK_RADIO.set_value(RADIO_PARAM_CHANNEL, current_channel); /* Reset drift correction */ drift_correction = 0; - drift_neighbor = NULL; + is_drift_correction_used = 0; /* Decide whether it is a TX/RX/IDLE or OFF slot */ /* Actual slot operation */ if(current_packet != NULL) { @@ -878,6 +902,7 @@ PT_THREAD(tsch_slot_operation(struct rtimer *t, void *ptr)) "! leaving the network, last sync %u", (unsigned)ASN_DIFF(current_asn, last_sync_asn)); ); + last_timesource_neighbor = NULL; tsch_disassociate(); } else { /* backup of drift correction for printing debug messages */ @@ -908,10 +933,11 @@ PT_THREAD(tsch_slot_operation(struct rtimer *t, void *ptr)) /* Time to next wake up */ time_to_next_active_slot = timeslot_diff * tsch_timing[tsch_ts_timeslot_length] + drift_correction; drift_correction = 0; - drift_neighbor = NULL; + is_drift_correction_used = 0; /* Update current slot start */ prev_slot_start = current_slot_start; current_slot_start += time_to_next_active_slot; + current_slot_start += tsch_timesync_adaptive_compensate(time_to_next_active_slot); } while(!tsch_schedule_slot_operation(t, prev_slot_start, time_to_next_active_slot, "main")); } diff --git a/core/net/mac/tsch/tsch-slot-operation.h b/core/net/mac/tsch/tsch-slot-operation.h index 76d495848..f74778c00 100644 --- a/core/net/mac/tsch/tsch-slot-operation.h +++ b/core/net/mac/tsch/tsch-slot-operation.h @@ -74,17 +74,6 @@ #define TSCH_MAX_INCOMING_PACKETS 4 #endif -/* Use SFD timestamp for synchronization? By default we merely rely on rtimer and busy wait - * until SFD is high, which we found to provide greater accuracy on JN516x and CC2420. - * Note: for association, however, we always use SFD timestamp to know the time of arrival - * of the EB (because we do not busy-wait for the whole scanning process) - * */ -#ifdef TSCH_CONF_RESYNC_WITH_SFD_TIMESTAMPS -#define TSCH_RESYNC_WITH_SFD_TIMESTAMPS TSCH_CONF_RESYNC_WITH_SFD_TIMESTAMPS -#else -#define TSCH_RESYNC_WITH_SFD_TIMESTAMPS 0 -#endif - /*********** Callbacks *********/ /* Called by TSCH form interrupt after receiving a frame, enabled upper-layer to decide diff --git a/platform/sky/platform-conf.h b/platform/sky/platform-conf.h index 4d5bd9094..cb6ea0cba 100644 --- a/platform/sky/platform-conf.h +++ b/platform/sky/platform-conf.h @@ -52,6 +52,8 @@ /* Delay between GO signal and start listening * ~50us delay + 129preample + ?? = 183 us */ #define RADIO_DELAY_BEFORE_RX ((unsigned)US_TO_RTIMERTICKS(183)) +/* Delay between the SFD finishes arriving and it is detected in software */ +#define RADIO_DELAY_BEFORE_DETECT 0 #define PLATFORM_HAS_LEDS 1 #define PLATFORM_HAS_BUTTON 1 diff --git a/platform/z1/platform-conf.h b/platform/z1/platform-conf.h index d17c463b6..15cab1127 100644 --- a/platform/z1/platform-conf.h +++ b/platform/z1/platform-conf.h @@ -49,6 +49,8 @@ /* Delay between GO signal and start listening * ~50us delay + 129preample + ?? = 183 us */ #define RADIO_DELAY_BEFORE_RX ((unsigned)US_TO_RTIMERTICKS(183)) +/* Delay between the SFD finishes arriving and it is detected in software */ +#define RADIO_DELAY_BEFORE_DETECT 0 #define PLATFORM_HAS_LEDS 1 #define PLATFORM_HAS_BUTTON 1