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.
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.
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.
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.
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 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.