DaaS-IoT uses transport drivers to connect the core to the primitives provided by the available network or hardware. The core operates on nodes, identities, and messages.
This architecture preserves the same data model across IP, radio, serial buses, and proprietary technologies.
The boundary between overlay and underlay
Communication is divided into three layers:
The core requests a channel to an endpoint from the driver and provides the DaaS frames to transmit. On reception, the driver reconstructs the transport byte stream and passes it to the core, which interprets the DME and delivers the DDO to the destination.
The driver manages channel opening, frame transfer, and error reporting. Typesets and payloads remain under the control of the core and the application.
Driver contract
Each technology has its own characteristics: connection-oriented or datagram operation, MTU, latency, ordering, reliability, addressing, and power consumption. The driver layer normalizes them into a consistent set of operations:
- initialize and stop the transport;
- associate a URI with a local or remote endpoint;
- open, reuse, and close channels;
- send and receive complete frames;
- report errors and state changes;
- manage multiple peers or subchannels;
- participate in discovery when supported by the medium.
The driver enforces medium-specific constraints: segmentation for small MTUs, serialization on half-duplex links, and propagation of failures to the layer that manages retries and delivery policies.
URIs and identities remain separate
The DIN identifies the node. The URI identifies the underlay point through which that node can be reached.
On IP, the URI may represent an address and port. On a bus, it may contain an interface and address. On a radio, it may describe a device, frequency, or logical channel. The syntax belongs to the driver, while the mapping remains understandable to the core.
If the physical endpoint changes, the mapping is updated; the DIN and DDO remain stable. The application contract stays independent of transport mobility.
Direct channels and forwarding
A driver manages the channels that are actually available on the local node. The DDO destination, however, may lie beyond that channel.
When the peer is direct, the DME is delivered to the driver associated with its mapping. When the peer is indirect, the core selects an intermediate node and delegates the next-hop transfer to the driver. Each hop may use a different technology:
From the application's perspective, communication still occurs between DINs. Conversion between media takes place in nodes that have multiple drivers and participate in overlay routing.
Discovery over the available medium
Discovery uses driver capabilities to advertise or search for a network. On a broadcast medium, it may use a beacon; on a bus, it may query available addresses; on a technology without native discovery, it may use a known endpoint or a technology-specific mechanism.
The result is expressed in DaaS terms: the discovered network, the node exposing it, and the link over which it was reached. The driver manages the beacon format and the technology primitives.
Buffers, MTU, and backpressure
The driver is the first point where underlay speed meets core speed. It must correctly handle:
- partial writes;
- fragmented reads;
- frames larger than the MTU;
- timeouts and disconnections;
- queue saturation;
- channel reopening.
When the network is under pressure, backpressure must be visible to the core. Hiding a full queue indefinitely increases latency, memory usage, and the risk of message reordering.
DriverKit opens the overlay to new transports
DriverKit integrates a new technology into DaaS-IoT. The developer implements the medium adapter and registers it as a driver; the transport then becomes available to DaaS services with the same semantics as the other links.
DriverKit is intended for cases such as:
- industrial buses;
- proprietary modems and radios;
- interfaces provided by an operating system or RTOS;
- legacy protocols;
- specialized links for embedded hardware.
The extension remains below the core; routing, discovery, synchronization, and DDO exchange continue to use the common services.
Guarantees required from a custom driver
A correct DriverKit integration preserves several invariants:
- Frame boundaries. The core must receive exactly the bytes belonging to each frame, even when the medium fragments or aggregates reads.
- Channel identity. Every event must be associated with the correct peer or subchannel.
- Deterministic lifecycle. Initialization, shutdown, and reconnection must fully release resources and callbacks.
- Observable errors. Timeouts, closures, and I/O failures must reach the core.
- Controlled concurrency. Callbacks and buffer access must comply with the platform's threaded or cooperative model.
- Stable URIs. The endpoint representation must be storable, comparable, and reconstructable.
- Message integrity. The driver transfers the DME while preserving typeset, timestamp, and payload.
Validating a new driver
Testing spans the entire stack:
- repeated driver opening and closing;
- bidirectional exchange between multiple nodes;
- minimum, maximum, and fragmented payloads;
- link loss during a frame;
- queue saturation;
- discovery and network entry;
- time synchronization;
- routing through a node with two different drivers;
- recovery after timeout or reconnection.
The driver is complete when the new medium becomes an underlay property and ceases to be a special case for the rest of the platform.
Multiprotocol integration
Drivers and DriverKit integrate heterogeneous transports into the network. The core maintains a single identity, message, and routing model; each driver manages its own medium.
The result is a network in which each new technology uses the same application protocol and preserves data meaning end to end.