Get the SDK

Architecture/dATS consensus

Architecture

dATS: distributed time synchronization

The shared time base used by DaaS-IoT nodes for distributed data and events.

dATS maintains a shared time reference among DaaS-IoT nodes and assigns DDOs timestamps that are comparable across the mesh overlay.

Why time is a distributed problem

In a decentralized system, each node measures time through a local oscillator and observes events from its own position in the network. Differences in frequency, temperature, power supply, and scheduling cause progressive drift even after a common initialization.

A message contains the time assigned by the sender and reaches the destination after a variable latency composed of queuing, medium access, forwarding, and processing. Origin time describes the event; reception time describes its arrival.

A common time base provides the properties required for distributed operation:

In a decentralized network, synchronization propagates between peers, follows topology changes, and updates its own state when intermittent links or partitions reduce the available accuracy.

dATS builds a time axis on which node timestamps are comparable within a known, observable error compatible with the time scale of the distributed process.

dATS provides DaaS-IoT nodes with a common time base. The core manages clock correction, and the application directly uses network time.

Each device uses its own local timer. The node maintains a network offset, updates it through time exchanges with peers, and applies it when producing DaaS timestamps. Shared time remains separate from the system clock; corrections affect the DaaS offset.

Local clock and shared time axis

The local clock is the monotonic measurement provided by the hardware or operating system of an individual device.

dATS constructs network time as follows:

T_network = T_local + offset_network

The offset compensates for the estimated difference from the segment reference. Synchronization state becomes valid when the residual error falls within the configured tolerance.

This approach avoids two problems:

dATS corrects the DaaS time domain and leaves management of platform time to the platform itself.

Why the network must share time

The timestamp is part of the DDO. Synchronization makes it possible to order measurements produced by different nodes and to separate transport latency from acquisition time.

A common base makes it possible to:

The timing requirement keeps the deviation between nodes within a known maximum error.

Reference selection

Within the segment, dATS determines which node provides the time reference. Selection favors network continuity: the oldest node assumes the reference role relative to nodes that join later.

This relationship prevents every new participant from causing an arbitrary change to the time base. When the topology changes, synchronization is re-established along the available relationships and each node's offset is updated.

dATS synchronizes the segment to a coherent axis. When absolute time is required, a node associates that axis with a UTC source.

Three-stage time exchange

Synchronization uses a three-stage negotiation between the reference node and the node whose time must be aligned.

referencenode
node beingsynchronized

Stage 1: synchronization initialization

The reference starts the exchange and associates its current time with the session. The receiving node captures local time at the point where it observes the message. The measurement is taken within the protocol, close to reception, to prevent application processing time from being included in the estimate.

Stage 2: offset estimation

The node being synchronized returns the collected timing information. By comparing the instants observed at both ends, dATS estimates the delta between the clocks and, as far as possible, separates the time offset from the time taken by the message to traverse the link.

The estimate is compared with the maximum permitted error. A delta beyond tolerance keeps synchronization in progress and requires either a correction update or another exchange.

Stage 3: application and confirmation

The final stage communicates the result, applies the correction to the DaaS time domain, and closes the session. Confirmation makes the node's network time valid.

The dATS result comprises two values:

corrected time + validity state

During reconfiguration, the node may calculate timestamps using the last available offset. The timing guarantee resumes when synchronization state becomes valid again.

The procedure occurs between peers and propagates through topology relationships. Each participant reaches synchronized state by completing the exchange with its own reference.

Synchronization in the network lifecycle

Connectivity establishes SID, DIN, and channels; synchronization then calculates the time offset and its validity state.

active drivers
discovery and segment entry
time-reference identification
stage 1 → stage 2 → stage 3
offset applied and synchronized state
time-aware application traffic
Timing guarantees attach to data only after the offset converges.

Discovery, join, and dATS messages circulate during the synchronization phase. DDOs with comparable timestamps acquire temporal validity once the exchange has completed.

This sequence associates timing guarantees with data after offset convergence.

Maximum error and convergence

The dATS tolerance defines the maximum acceptable deviation between the node's corrected time and the reference.

A narrow threshold increases the required accuracy and makes synchronization more sensitive to:

A wider threshold facilitates convergence and reduces event-correlation accuracy. The configuration must be below the time scale of the observed phenomenon. Events separated by 10 ms require a tolerance below 10 ms.

Synchronized state indicates that deviation satisfies the threshold. A complete assessment uses three metrics:

A node may converge quickly while showing a variable delta, or stabilize only after a longer convergence period. The threshold must be chosen together with convergence time, delta, and jitter.

Drift and resynchronization

Oscillators advance at slightly different rates; dATS periodically updates the correction to contain drift.

dATS therefore monitors synchronization quality and repeats the exchange when:

During resynchronization, the node may retain the last known offset and report the timing guarantee as suspended. The application may queue, mark, or discard data produced during that window.

Synchronization and topology

dATS follows overlay-network relationships. A node synchronizes through a peer reached over an IP, radio, or serial driver while remaining in the same time domain.

Quality depends on the path. Each hop introduces scheduling and variable latency. When the topology provides multiple alternatives, selection favors stability and low jitter.

Merging two segments requires a decision about which reference to preserve. Nodes from the incorporated topology progressively update their offsets until they converge on the time base of the resulting segment.

DDO timestamps

When a node produces a DDO, the timestamp is acquired from dATS time and travels with the object. Routers preserve the origin time during forwarding.

This property makes it possible to distinguish:

DDO timestamp           when the data was produced
reception time          when it reached the destination
difference              observed end-to-end delay

Synchronization state qualifies every timestamp: valid state enables comparison with other participants, while converging state indicates a suspended timing guarantee.

Network time and time zones

The protocol uses network time; time zone and daylight-saving adjustments are applied during display.

Within the network, comparable and monotonic numerical values are required. Conversion to a human-readable date and time occurs at the application layer after the epoch and units associated with the deployment have been established.

Observing dATS quality

An operational system should monitor at least:

These metrics help classify clock and network problems. Missing messages indicate incomplete connectivity or lifecycle handling; repeated attempts with an unstable delta indicate jitter, drift, or a tolerance incompatible with the medium.

Network time

dATS makes time a property of the DaaS-IoT network. Nodes maintain independent local clocks, produce timestamps on a shared axis, and expose their validity.

Synchronization remains internal to the core, crosses the available drivers, and follows segment reconfigurations. The application receives data positioned within the network's shared time.

See nodes converge on a shared time axis.

Open the Lab Simulator