Abstract

This TEP describes a packet-level time synchronization mechanism that allows for sending a time value along with the packet which is automatically converted from the sender's local time to the receiver's local time by the communications stack.

1. Introduction

Time of occurrence of events is often of interest in a sensor network. Maintaining a synchronized UTC or a virtual global time in a sensor network may, however, lead to significant communication overhead and may not always be required by the application.

This TEP describes a packet-level time synchronization mechanism that allows for sending a time value along with the packet which is automatically converted from the sender's local time to the receiver's local time by the communications stack. Packet-level time synchronization is limited to single-hop communication and does not provide synchronized network time. It provides a simple yet powerful abstraction, on top of which it is possible to implement higher-level time synchronization services (e.g. FTSP [6])in a platform-independent way. Packet-level time synchronization is semantically equivalent to the ETA primitives [1].

The rest of this TEP specifies:

• Platform-independent packet-level time synchronization interfaces
• How these interfaces are provided in the HIL
• A guideline how each transceiver's HAL may implement the above interfaces

2. Interface

Packet-level time synchronization is implemented by the communication stack and is exposed through two interfaces, TimeSyncAMSend and TimeSyncPacket.

The TimeSyncAMSend interface allows for sending a time value (e.g. an event timestamp) along with a message. It is parameterized by the precision and width of the time value:

interface TimeSyncAMSend<precision_tag, size_type>
{
  command error_t send(am_addr_t addr, message_t* msg, uint8_t len, size_type event_time);
  command error_t cancel(message_t* msg);
  event void sendDone(message_t* msg, error_t error);
  command uint8_t maxPayloadLength();
  command void* getPayload(message_t* msg, uint8_t len);
}

The send command sends a regular message just like AMSend.send [2], but it also performs sender-receiver time synchronization. The event_time parameter holds the time of some event as expressed in the local clock of the sender. The receiver can obtain the time of this event (expressed in its own local time) via the TimeSyncPacket interface.

The rest of the functionality is identical to that of the AMSend interface, therefore its description is omitted here. Please refer to [2] for details.

The TimeSyncPacket interface, parameterized by a precision tag and width, allows for retrieving a time value that was sent along the received packet:

interface TimeSyncPacket<precision_tag, size_type>
{
        command bool isValid(message_t* msg);
        command size_type eventTime(message_t* msg);
}

The isValid command returns TRUE if the value returned by eventTime can be trusted. Under certain circumstances the received packet cannot be properly time stamped, so the sender-receiver synchronization cannot be finished on the receiver side. In such case, this command returns FALSE. This command MUST be called only on the receiver side and only for messages transmitted via the TimeSyncAMSend interface.

The communications stack MUST guarantee that if the isValid command called from within the receive event handler returns TRUE, then the value returned by the eventTime command can be trusted. However, it might be possible that the local clock overflowed more than once or that is was stopped or reset since the packet was received, which causes the event_time to be invalid. The isValid command MAY return TRUE in such situations, and it is the responsibility of the user of the interface to ensure that the clock runs freely from the time of message reception to the time when eventTime is called. To avoid this issue, it is recommended that isValid and eventTime are called from the receive event handler.

The eventTime command should be called by the receiver of a packet. The time of the synchronization event is returned as expressed in the local clock of the caller. This command MUST BE called only on the receiver side and only for messages transmitted via the TimeSyncAMSend interface.

3. HIL requirements

The signature of the platform's ActiveMessageC [5] MUST include:

provides interface TimeSyncAMSend<TMilli, uint32_t>;
provides interface TimeSyncPacket<TMilli, uint32_t>;

where event times are given in the node's local time, which is available through HILTimerMilliC.LocalTime.

The communications stack MAY support timestamp precisions and widths other than TMilli and uint32_t, respectively. Also, alternative TimeSyncAMSend and TimeSyncPacket implementations MAY use clock sources other than HILTimerMilliC.LocalTime.

4. Implementation guidelines

Packet-level time synchronization employs the ETA primitives. In this TEP, only the basics of the time synchronization mechanism are described, for details please see [1]. This section presents two possible implementation approaches. The first approach assumes that the payload of the packet is still mutable when the transmission time of the packet (e.g. the timestamp of the SFD interrupt) becomes available. The second approach avoids this assumption and uses the packet timestamping functionality described in TEP [4] to implement packet- level time synchronization.

6. Author's Address

7. Citations