Get the SDK

Overview/Guides

Overview

Guides: how a DaaS-IoT node comes to life

The steps a node follows to acquire an identity, open a link, enter a network, and keep working through change.

A DaaS-IoT network can connect very different devices: a sensor on a microcontroller, a Linux gateway, a mobile application, or a cloud service. They do not need to use the same operating system or the same communication medium. What makes them part of the same network is a common model for identity, data exchange, and link management.

Starting a node means guiding it through a few steps: assigning it an identity, making at least one communication channel available, connecting it to the other participants, and allowing the core to manage traffic, time, and network changes.

identity
link
network entry
data exchange
continuity and recovery
The path a node follows to come to life.

1. Every node has a stable identity

In a traditional network, a device is often recognized through its IP address or the interface it uses. These references may change: Wi-Fi assigns a new address, the device switches to BLE, or it is moved to another physical network.

DaaS-IoT separates identity from connectivity. The SID identifies the logical segment to which the node belongs; the DIN identifies the node within that context. An IP address, port, or radio endpoint only describes how to reach it at a given moment.

This separation provides an immediate benefit: the application continues to address the same DIN even when the physical path changes. Service logic does not need to be rewritten every time connectivity changes.

2. The node enables the available links

After defining its identity, the node activates one or more drivers. Each driver connects DaaS-IoT to a concrete technology such as Ethernet, Wi-Fi, BLE, serial communication, or LoRa.

A device may use a single link or keep several available. A gateway, for example, may prefer Ethernet for capacity and stability, use Wi-Fi when the cable is unavailable, and retain BLE as an additional alternative.

From the application's perspective, the data remains the same. The core knows which channels are available and reacts when one of them can no longer be used. This reduces the amount of network logic that must be implemented in application software.

DriverKit extends the same principle to proprietary technologies. A new communication medium can enter the architecture without introducing a separate model for data, identities, and error handling.

3. Network entry can be manual or dynamic

There are two ways to connect a node to the network. The choice depends on how predictable the installation environment is.

Manual configuration

In a controlled network, the participants and their endpoints are already known. The node therefore receives a configuration that associates the peer DIN with the driver and address to use.

This is a direct approach suited to stable installations, gateways with known addresses, and environments in which the topology is planned in advance.

peer DIN
link
endpoint

Physical configuration remains separate from the application: if the endpoint changes, the mapping is updated without changing the data format or the destination identity.

Dynamic discovery

In mobile or distributed environments, it is not always possible to know before startup which gateway will be available. The node can therefore autonomously search for reachable DaaS-IoT networks through its active drivers.

Discovery detects possible ingress points and available segments. The node selects the appropriate context and completes the join. At the end of the process, it knows the effective identity to use, the first peer, and the initial link.

search
network detected
selection
join
node connected

The benefit is operational: the same device can be installed in a new environment without manually entering the address of every peer. An available gateway exposes the network; the new node recognizes it and completes its own configuration.

4. The core keeps the node active in the network

Once started, a node does more than send and receive bytes. The core manages timeouts, queues, driver state, discovery, paths, retries, and events.

On an operating system, this work can be performed by a dedicated thread. On a microcontroller, it can progress within the normal execution loop. The result is the same: network processing continues without mixing protocol logic with application logic.

Events notify the application when a network is detected, a join is completed, a peer changes state, or new data becomes available. The application can therefore react to what happens without continuously polling every component.

5. Nodes exchange DDOs, not transport-specific packets

The DDO is the object through which the application shares information. The typeset describes its meaning; the payload contains the value; origin and timestamp identify where it came from and when it was produced.

A DDO can represent a measurement, a command, a state, or an event. The application specifies the destination DIN, while DaaS-IoT handles delivery.

sensortemperature
DDO
destination DIN
available path
receiving application

The destination is notified when the DDO becomes available. It can read it immediately or place it in an inbox, including a persistent inbox, and process it at its own pace. This prevents a slower processing stage from blocking the thread that keeps the network active.

Streams are also available for continuous transfers. DDOs and streams address different needs, but use the same identities and links.

6. Time and paths remain coherent

In a distributed network, each device has a different clock. dATS brings nodes onto a shared time reference without requiring every timestamp to depend on a central server.

This makes data produced by different devices comparable: a measurement acquired by a sensor and an event recorded by a gateway can be placed on the same time axis.

The path can also change. If the direct link is unavailable, the core can use another driver or pass through an intermediate node. The DDO retains its identity, typeset, timestamp, and payload. From the application's perspective, the route changes, not the data.

7. The node can restart without starting over

Identity, drivers, mappings, policies, and useful network information can be retained. On restart, the node restores its configuration and verifies whether the links are still valid. If the environment has changed, it can repeat discovery instead of remaining tied to endpoints that are no longer available.

A persistent inbox can also retain DDOs that have already been received but not yet processed. Persistence does not make every delivery infallible, but it reduces context loss and allows the application to resume work in a controlled manner.

A network that absorbs change

The potential of DaaS-IoT emerges from the combination of these elements. Logical identities, interchangeable drivers, discovery, routing, and shared time allow heterogeneous devices to cooperate without pushing all complexity into the application.

Software continues to reason in terms of node, destination, and data. The network handles finding a link, maintaining the time reference, reacting to failures, and rebuilding reachability when the environment changes.

Watch a node come to life.

Open the Lab Simulator