Software containerization technologies for resource-limited devices enable multi-tenant microcontrollers, which allow running multiple applications with different permission levels. However, current solutions lack run time configuration over various settings on container scheduling and container permissions to host resources. This limits the applicability of constrained containerization in dynamic and heterogeneous environments. This paper introduces TinyContainer, a lightweight software container management middleware designed for multi-tenant microcontrollers. TinyContainer provides per-container configurable scheduling and fine-grained access control to host resources through a metadata-driven approach, supporting multiple runtimes via a runtime abstraction layer. We analyze the performance of TinyContainer with a small WebAssembly runtime, CS4WAMR, and RIOT OS, a common RTOS. We report on experiments using popular IoT boards based on various Cortex-M microcontrollers. We show the endpoint system brought by TinyContainer allowing to regulate access of containers to host resources and provide host services to containers with an overhead of up to 4 ms per call. In particular, we showcase a TinyML use case, whereby containers retain data and model weights, while model inference is delegated to native host RTOS services.

International audience

AI spans from large language models to tiny models running on microcontrollers (MCUs). Extremely memory-efficient model architectures are decisive to fit within an MCU's tiny memory budget e.g., 128kB of RAM. However, inference latency must remain small to fit real-time constraints. An approach to tackle this is *patch-based fusion*, which aims to optimize data flows across neural network layers. In this paper, we introduce *msf-CNN*, a novel technique that efficiently finds optimal fusion settings for convolutional neural networks (CNNs) by walking through the fusion solution space represented as a directed acyclic graph. Compared to previous work on CNN fusion for MCUs, msf-CNN identifies a wider set of solutions. We published an implementation of msf-CNN running on various microcontrollers (ARM Cortex-M, RISC-V, ESP32). We show that msf-CNN can achieve inference using 50% less RAM compared to the prior art (MCUNetV2 and StreamNet). We thus demonstrate how msf-CNN offers additional flexibility for system designers.

Results from the TinyML community demonstrate that, it is possible to execute machine learning models directly on the terminals themselves, even if these are small microcontroller-based devices. However, to date, practitioners in the domain lack convenient all-in-one toolkits to help them evaluate the feasibility of executing arbitrary models on arbitrary low-power IoT hardware. To this effect, we present in this paper U-TOE, a universal toolkit we designed to facilitate the task of IoT designers and researchers, by combining functionalities from a low-power embedded OS, a generic model transpiler and compiler, an integrated performance measurement module, and an open-access remote IoT testbed. We provide an open source implementation of U-TOE and we demonstrate its use to experimentally evaluate the performance of various models, on a wide variety of low-power IoT boards, based on popular microcontroller architectures. U-TOE allows easily reproducible and customizable comparative evaluation experiments on a wide variety of IoT hardware all-at-once. The availability of a toolkit such as U-TOE is desirable to accelerate research combining Artificial Intelligence and IoT towards fully exploiting the potential of edge computing.

CubeSat design is facilitated by the increasing availability of open-source software in the domain, and a variety of low-cost hardware blueprints based on commodity micro-controllers. We attain the rock-bottom price to reach orbit as entities that design, launch and operate CubeSats started selling to multiple tenants tiny rack slots for low-power payloads that may be hosted on their CubeSat. The question arises of how to provide state-of-the-art security for software updates on a multi-tenant CubeSat, whereby mutual trust between tenants is limited. In this paper, we provide a case-study: ThingSat, a low-power payload we designed, is currently hosted on a CubeSat orbiting at 500km altitude operated by a separate entity. We then design Cubedate, a framework for securing continuous deployment of software to be updated on orbiting multi-tenant CubeSats. We also provide a highly portable open-source implementation of Cubedate, based on the IoT operating system RIOT, which we evaluate experimentally.

Contact Tracing (CT) is an old, recognized epi-demiological tool, and since a digital variant is now within reach, a variety of smartphone-based solutions have been rapidly developed and deployed since 2020, with mixed results and amid controversies. Yet, achieving reliable and effective digital CT at large scale is still an open problem. In this work, we contribute with an open source software platform on top of which various CT solutions can be quickly developed and tested. More specifically, we design PEPPER, which jointly leverages Bluetooth Low Energy (BLE) and Ultra Wide Band (UWB) radios for contact detection, combined with the DESIRE privacy-preserving CT protocol. We show that PEPPER+DESIRE can operate on cheap physical tokens based on low-power microcontrollers, opening new use-cases with less personal, potentially disposable devices, that could be more widely used. We also evaluate the complementarity of Bluetooth and UWB in this context, via experiments mimicking various scenarios relevant for CT. Compared to BLE-only CT, we show that UWB can decrease false negatives (e.g., in presence of human body occlusion), meaning that more actual contacts will be found, a key benefit from an epidemiological viewpoint. Our results suggest that, while PEPPER+DESIRE improves precision over state-of-the-art, further research is required to harness UWB-BLE synergy for CT in practice. To this end, our open source platform (which can run on an open-access testbed) provides a useful playground for the research community.

Abstract RIOT is a micro-kernel dedicated to IoT applications that adopts eBPF (extended Berkeley Packet Filters) to implement so-called femto-containers. As micro-controllers rarely feature hardware memory protection, the isolation of eBPF virtual machines (VM) is critical to ensure system integrity against potentially malicious programs. This paper shows how to directly derive, within the Coq proof assistant, the verified C implementation of an eBPF virtual machine from a Gallina specification. Leveraging the formal semantics of the CompCert C compiler, we obtain an end-to-end theorem stating that the C code of our VM inherits the safety and security properties of the Gallina specification. Our refinement methodology ensures that the isolation property of the specification holds in the verified C implementation. Preliminary experiments demonstrate satisfying performance.

Low-power operating system runtimes used on IoT microcontrollers typically provide rudimentary APIs, basic connectivity and, sometimes, a (secure) firmware update mechanism. In contrast, on less constrained hardware, networked software has entered the age of serverless, microservices and agility. With a view to bridge this gap, in the paper we design Femto-Containers, a new middleware runtime which can be embedded on heterogeneous low-power IoT devices. Femto-Containers enable the secure deployment, execution and isolation of small virtual software functions on low-power IoT devices, over the network. We implement Femto-Containers, and provide integration in RIOT, a popular open source IoT operating system. We then evaluate the performance of our implementation, which was formally verified for fault-isolation, guaranteeing that RIOT is shielded from logic loaded and executed in a Femto-Container. Our experiments on various popular micro-controller architectures (Arm Cortex-M, ESP32 and RISC-V) show that Femto-Containers offer an attractive trade-off in terms of memory footprint overhead, energy consumption, and security.

We present an overview and initial results from a project bringing together orchestra conducting, e-textile material studies, costume tailoring, low power computing and machine learning (ML). We describe a wearable interactive system comprising of textile sensors embedded into a suit, low-power transmission and gesture recognition using creative computing tools. We introduce first observations made during the semi-participatory approach, which placed the conductor’s movements and personal performative expressiveness at the centre for technical and conceptual development. The project is a two-month collaboration between the Verworner-Krause Kammerorchester (VKKO), technical and design researchers, currently still running. Preliminary analyses of the data recorded while the conductor is wearing the prototype demonstrate that the developed system can be used to robustly decode a large number of conducting and performative movements. In particular the user interface of the ML system is designed such that the training of the algorithms can be intuitively controlled by the conductor, in sync with the MIDI clock.

Short development cycles, application-field diversity, and requirements on network size or reliability put an ever increasing strain on Internet of Things (IoT) application developers. Real-time embedded operating systems (RTOS) aim to provide a key set of features, abstractions and services that enable faster development. To fulfill the promise of wire-like communication reliability, wireless standards such as WirelessHART, ISA100.11a and 6TiSCH have been developed and are used in the industry. Keeping these networks synchronized requires precise timing information from the underlying hardware. However, the hardware abstractions of an RTOS do come with an overhead, and the question arises on how these abstractions impact the performance of a complex network stack. To study this, we integrated Open-WSN, a standards-compliant open-source implementation of the 6TiSCH network stack, with RIOT, a prominent open-source RTOS. We compare the minimalistic "bare metal" approach of OpenWSN with RIOT's full-fledged RTOS environment. We study the impact on network performance, power consumption and real-time application properties. On the one hand, we show that using RIOT to execute a 6TiSCH stack does not degrade power consumption or network performance. On the other hand, we demonstrate how RIOT brings improvements on the time it takes to execute application tasks.

Similarly to elsewhere on the Internet, practical security in the Internet of Things (IoT) is achieved by combining an array of mechanisms, at work at all layers of the protocol stack, in system software, and in hardware. Standardized protocols, such as Datagram Transport Layer Security (DTLS 1.2) and Transport Layer Security (TLS 1.2), are often recommended to secure communications to/from IoT devices. Recently, the TLS 1.3 standard was released and DTLS 1.3 is in the final stages of standardization. In this paper, we give an overview of version 1.3 of these protocols, and we provide the first experimental comparative performance analysis of different implementations and various configurations of these protocols, on real IoT devices based on low-power microcontrollers. We show how different implementations lead to different compromises. We measure and compare bytes-over-the-air, memory footprint, and energy consumption. We show that, when DTLS/TLS 1.3 requires more resources than DTLS/TLS 1.2, this additional overhead is quite reasonable. We also observe that, in some configurations, DTLS/TLS 1.3 actually decreases overhead and resource consumption. All in all, our study indicates that there is still room to optimize the existing implementations of these protocols.

The following topics are dealt with: Internet of Things; embedded systems; microcontrollers; telecommunication power management; protocols; data privacy; wireless sensor networks; virtual machines; operating systems (computers); transport protocols.

In the future, IoT devices will be part of the robotics ecosystem, and the border between IoT and robotics will blur. Already today, we observe converging trends between low-end IoT devices and minibots (i.e. tiny, cheap robots) concerning their hardware, and open source software. In this paper, we explore the potential of programming minibots with the open source robotics software framework ROS2, running on top of the IoT operating system RIOT; we call the fruitful association of both elements RIOT-ROS2. In this article, the emphasis is particularly on the networking layer: using an information-centric networking (ICN) paradigm, we design and implement the communication primitives for RIOT-ROS2. We further evaluate the performance of our design on prototype minibots based on cheap, off-the-shelf hardware elements. We show that RIOT-ROS2 fits on low-end robotics hardware such as a System-on-Chip costing under $2, based on an ARM Cortex-M0+ microcontroller. Our experiments also show that the latency incurred with our information-centric approach is acceptable for minibot control, even on a low-throughput IEEE 802.15.4 radio.

As the Internet of Things (IoT) emerges, compact operating systems (OSs) are required on low-end devices to ease development and portability of IoT applications. RIOT is a prominent free and open source OS in this space. In this paper, we provide the first comprehensive overview of RIOT. We cover the key components of interest to potential developers and users: the kernel, hardware abstraction, and software modularity, both conceptually and in practice for various example configurations. We explain operational aspects like system boot-up, timers, power management, and the use of networking. Finally, the relevant APIs as exposed by the OS are discussed along with the larger ecosystem around RIOT, including development and open source community aspects.

The Internet of Things (IoT) is projected to soon interconnect tens of billions of new devices, in large part also connected to the Internet. IoT devices include both high-end devices which can use traditional go-to operating systems (OSs) such as Linux, and low-end devices which cannot, due to stringent resource constraints, e.g., very limited memory, computational power, and power supply. However, large-scale IoT software development, deployment, and maintenance requires an appropriate OS to build upon. In this paper, we thus analyze in detail the specific requirements that an OS should satisfy to run on low-end IoT devices, and we survey applicable OSs, focusing on candidates that could become an equivalent of Linux for such devices, i.e., a one-size-fits-most, open source OS for low-end IoT devices.

Industrial control systems have traditionally been built around dedicated wired solutions. The requirements of flexibility, mobility, and cost have created a strong push toward wireless solutions, preferably solutions requiring low power. Simultaneously, the increased need for interoperability and integration with the wider Internet made a transition to IP-based communication unavoidable. Following these trends, we survey 6TiSCH, the emerging family of standards for IP-based industrial communication over low-power and lossy networks. We describe the state of the standardization work, the major issues being discussed, and open questions recently identified. Based on extensive first-hand experience, we discuss challenges in implementation of this new wave of standards. Lessons learned are highlighted from four popular open-source implementations of these standards: OpenWSN, Contiki, RIOT, and TinyOS. We outline major requirements, present insights from early interoperability testing and performance evaluations, and provide guidelines for chip manufacturers and implementers.

We study the information propagation speed in multi-lane vehicle-to-vehicle networks such as roads or highways. We focus on the impact of time-varying radio ranges and of multiple lanes of vehicles, varying in speed and in density. We assess the existence of a vehicle density threshold under which information propagates on average at the fastest vehicle speed and above which information propagates dramatically faster. We first prove that no such phase transition occurs if there is only one lane, regardless of the density of vehicles, when one takes into account real-time radio communication range variations at the MAC layer. We then prove that, on the other hand, a phase transition exists as soon as there are multiple lanes with different vehicle speeds and appropriate densities. We characterize conditions under which the phase transition occurs and we derive bounds on the corresponding threshold as a simple relationship between the vehicle density on the fastest lane and the sum of densities on the other lanes. Our results intrinsically encompass a wide range of vehicular network scenarios, including one-way and two-way roads, as well as special cases such as road side units and/or parked cars being used as relays. We confirm our analytical results using simulations.

Jitter is used in wireless ad hoc networks to reduce the number of packet collisions and the number of transmissions. This is done by scheduling random back-off for each packet to be transmitted and by piggybacking multiple packets in a single transmission. This technique has been standardized by the IETF in RFC 5148. This paper investigates on the impact of the standardized jitter mechanism on network-wide packet dissemination - i.e. flooding, an important component for many protocols used today. A novel analytical model is introduced, capturing standard jitter traits. From this model is derived accurate characterization of the effects of jittering on flooding performance, including the additional delay for flooded packets on each traversed network interface, the reduction of the number of transmissions over each network interface, and the increased length of transmissions, depending on jitter parameters. This paper also presents an analysis of the use of jitter in practice, over an 802.11 wireless link layer based on CSMA. The analytical results are then validated via statistical discrete event simulations. The paper thus provides a comprehensive overview of the impact of jittering in wireless ad hoc networks.

As wireless mesh networks are deployed, a new concept emerges: compound internetworks, i.e., internetworks that contain both wired networks and wireless mesh networks. Routing is one of the key challenges that arises in compound internetworks: indeed, while specific routing protocols are typically used for wired networks on one hand, and for wireless mesh networks on the other hand, it has been observed that operating a single routing protocol to manage a compound internetwork as a whole brings several advantages. In this realm, the IETF has thus standardized protocol extensions to Open Shortest Path First (OSPF, the routing protocol used by more than 50 % of the wired routers in today's Internet), enabling OSPF to operate simultaneously on wired networks, and on wireless mesh or moderately mobile ad hoc networks (MANETs). This paper evaluates the performance of OSPF coupled with such a protocol extension for MANETs on an experimental compound internetwork testbed. This paper reports on experiments carried out with OSPF operating simultaneously over Ethernet and 802.11b. Despite the limitations of the testbed, these experiments provide both a proof-of-concept and complementary results compared to prior work in the domain, which was mostly based on simulations, and focused on wireless ad hoc network scenarios only.

In this paper, we provide a full analysis of the information propagation speed in bidirectional vehicular delay tolerant networks such as roads or highways. The provided analysis shows that a phase transition occurs concerning the information propagation speed, with respect to the vehicle densities in each direction of the highway. We prove that under a certain threshold, information propagates on average at vehicle speed, while above this threshold, information propagates dramatically faster at a speed that increases quasi-exponentially when the vehicle density increases. We provide the exact expressions of the threshold and of the average information propagation speed near the threshold, in case of finite or infinite radio propagation speed. Furthermore, we investigate in detail the way information propagates under the threshold, and we prove that delay tolerant routing using cars moving on both directions provides a gain in propagation distance, which is bounded by a sublinear power law with respect to the elapsed time, in the referential of the moving cars. Combining these results, we thus obtain a complete picture of the way information propagates in vehicular networks on roads and highways, which may help designing and evaluating appropriate vehicular ad hoc networks routing protocols. We confirm our analytical results using simulations carried out in several environments (The One and Maple).

In this paper, we provide an analysis of the information propagation speed in bidirectional vehicular delay tolerant networks on highways. We show that a phase transition occurs concerning the information propagation speed, with respect to the vehicle densities in each direction of the highway. We prove that under a certain threshold, information propagates on average at vehicle speed, while above this threshold, information propagates dramatically faster at a speed that increase exponentially when vehicle density increases. We provide the exact expressions of the threshold and of the average propagation speed near the threshold. We show that under the threshold, the information propagates on a distance which is bounded by a sub-linear power law with respect to the elapsed time, in the referential of the moving cars. On the other hand, we show that information propagation speed grows quasi-exponentially with respect to vehicle densities in each direction of the highway, when the densities become large, above the threshold. We confirm our analytical results using simulations carried out in several environments.

Directed Acyclic Graphs (DAGs), rooted at popular/default destinations, have emerged as a preferred mechanism to provide IPv6 routing functionality in large scale low power and lossy networks, that include wireless sensor networks and those based on power line communication. A DAG maintains its acyclic nature by requiring that each DAG node must have a higher 'rank' than any of its DAG parents. While a node may decrease its DAG rank safely, increasing its DAG rank to add a new parent may result in a routing loop if the new parent is also a descendant in the DAG. In this paper, we first study via simulations the time required by the network to converge to a stable, loop-free state following a rank increase operation and the number of routing messages generated (the network 'churn') during this time. Then, we describe the precautionary measures that can be used to avoid routing loops and evaluate via simulations how these measures affect the time and churn involved in reaching a stable state following a rank increase operation.

In practice, ad hoc networks are still too unreliable for standard mobile and vehicular communications. It is thus important to complement current protocols in this context, with schemes guaranteeing the exchange of critical data when needed. A promising approach in this realm is to use an overlay subgraph, over which critical messages are exchanged and acknowledged in a peer to peer fashion. Overlay nodes' local databases remain thus synchronized over time, at least concerning critical data. This paper elaborates on the problem of performance, related to the discovery and maintenance of such overlay networks in a mobile ad hoc context. We analyze SLOT, an overlay selected based on a Relative Neighbour Graph (RNG) scheme. We then apply SLOT to a standard IP protocol: OSPF, a popular routing protocol which has recently been extended, with RFC 5449 and RFC 5614, to work also on mobile ad hoc networks, and which makes use of a similar overlay synchronization subgraph. This paper compares the performance of these existing OSPF mechanisms with that of SLOT-OSPF, a novel OSPF extension for mobile ad hoc networks using SLOT. Simulations show that SLOT-OSPF produces drastically less control traffic than RFC 5449 or RFC 5614, allowing SLOT-OSPF to function correctly while the other existing approaches stall, when the number of routers in the domain is large.

The optimized link-state routing protocol (OLSR) is a proactive link-state routing protocol. While similar to the well-known Internet routing protocol OSPF, OLSR is designed to be simple, and to maintain connectivity in face of highly dense and dynamic networks, while being resource-economic (battery, bandwidth etc.) These characteristics make OLSR suitable as an underlaying routing protocol in a wide range of ad-hoc sensor networks. In this paper, we introduce an extension to OLSR: OSPF-style database exchange and reliable synchronization. The goal of this extension is to provide a mechanism, through which nodes in an ad-hoc sensor network can detect and correct discrepancies in their link-state databases. We qualify why the mechanism, found in OSPF, is not directly applicable for ad-hoc sensor networks, describe an adopted mechanism, accomplishing the same goal, and evaluate the performance of this mechanism in comparison to the database exchange mechanism found in OSPF. We finally discuss some applications of database exchange and reliable synchronization in ad-hoc sensor networks.

We present the design and the implementation of an open shortest path first (OSPF) monitoring service hooked up to a managed IP network, enabling the administrator to be aware of the paths currently taken by IP packets throughout the OSPF domain. Such a service represent an advance over tools available today that offer off-line emulations of routing protocols, or that track network routing behavior in a local, semi-static manner. The proposed routing monitoring service has applications to network management functions such as QoS service fulfilment, performance analysis and SLA verification.