Quantized CNN inference on ultra-low-power MCUs incurs unnecessary computations in neurons that produce saturated output values. These values are too extreme and are eventually clamped to the boundaries allowed by the neuron. Often times, the neuron can save time by only producing a value that is extreme enough to lead to the clamped result, instead of completing the computation, yet without introducing any error. Based on this, we present saturation-aware convolution: an inference technique whereby we alter the order of computations in convolution kernels to induce earlier saturation, and value checks are inserted to omit unnecessary computations when the intermediate result is sufficiently extreme. Our experimental results display up to 24% inference time saving on a Cortex-M0+ MCU, with zero impact on accuracy.

We present Neuro-centric Networks (Neuro-C), a neural network architecture we design to eliminate multiply-accumulate operations for efficient inference on ultra-low-power microcontrollers (MCUs). Although some MCUs include specialized hardware for neural acceleration, many ultra-low-power MCUs do not, requiring neural networks to align with limited compute and memory resources. Rather than compressing existing models or assuming dedicated hardware, Neuro-C integrates hardware constraints directly into the architecture, effectively shaping the network design around the limitations of the target platform. We shift the computational burden from connections to neurons and encode connectivity with a fixed ternary adjacency matrix, overcoming the bottleneck of matrix multiplications and large weight storage. This design enables a specialized inference kernel implementation that reduces memory usage and latency through pointer-based traversal and sparse dynamic memory allocation, complex control flows, and index decoding logic common in sparse or compressed models. Experimental results show that Neuro-C achieves accuracy comparable to or better than standard multilayer perceptrons across multiple datasets, while reducing inference latency and program memory usage by up to 90%. Compared to conventional ternary neural networks, Neuro-C provides improved convergence and accuracy under identical architectural settings, with negligible impact on inference latency.

We reveal two fundamental insights when deploying inference workloads on intermittent systems that use capacitors as energy buffers. Because of varying structural characteristics and data-independent execution of Deep Neural Network (DNN) models, different capacitor configurations can swing inference performance from the good to the bad. Second, capacitor leakage, which is inevitable in real deployments and yet vastly overlooked in existing literature, makes a whole difference when determining the most efficient capacitor configuration. Both insights hold independently of specific techniques that enable intermittent inference. They form the basis to design LEACS: an off-line technique to determine an efficient energy storage configuration for intermittent inference workloads. LEACS determines the number and size of capacitors based on the nature of the energy source, while accounting for capacitor leakage. We test LEACS together with two state-of-the-art intermittent inference execution techniques and compare its performance with four different baselines across three hardware platforms, seven DNNs models, and three real-world energy sources. Our results indicate that LEACS improves inference throughput by up to 3.4 ×, with an average 1.59 × across the settings we test.

ACM TIOT launched a special issue on the theme of LLM Empowered Internet of Things, exploring the intersection of Large Language Models (LLMs) and the Internet of Things (IoT). As IoT continues to expand, advanced computational models are increasingly essential for processing and analyzing the massive data generated by interconnected devices. This special issue focuses on how LLMs can enhance IoT systems in several key areas. The second part of this special issue introduces the remaining six accepted papers that spans a board range of IoT scenarios from embedded and cyber-physical systems, human-centered applications, to IoT security.

Tiny battery-free devices running deep neural networks (DNNs) embody intermittent TinyML, a paradigm at the intersection of intermittent computing and deep learning, bringing sustainable intelligence to the extreme edge. This paper, as an overview of a special session at Embedded Systems Week (ESWEEK) 2025, presents four tales from diverse research backgrounds, sharing experiences in addressing unique challenges of efficient and reliable DNN inference despite the intermittent nature of ambient power. The first explores enhancing inference engines for efficient progress accumulation in hardware-accelerated intermittent inference and designing networks tailored for such execution. The second investigates computationally light, adaptive algorithms for faster, energy-efficient inference, and emerging computing-in-memory architectures for power failure resiliency. The third addresses battery-free networking, focusing on timely neighbor discovery and maintaining synchronization despite spatio-temporal energy dynamics across nodes. The fourth leverages modern nonvolatile memory fault behavior and DNN robustness to save energy without significant accuracy loss, with applicability to intermittent inference on nano-satellites. Collectively, these early efforts advance intermittent TinyML research and promote future cross-domain collaboration to tackle open challenges.

We present a measurement and performance analysis of system-level settings to improve the energy efficiency of Deep Neural Network (DNN) inference on battery-less Internet of Things (IoT) devices. To do so, we deliberately trade a small, controllable reduction in inference accuracy for energy gains. Battery-less IoT devices are severely resource-constrained platforms powered by energy harvesting, where execution becomes intermittent as it alternates between bursts of computation and periods of energy recharge. To survive frequent energy failures, devices persist their system state into non-volatile memories, incurring significant energy costs. We leverage aggressive current scaling offered by Spin-Transfer Torque Magnetic RandomAccess Memory (STT-MRAM) during state writes to reduce energy consumption, intentionally allowing controlled write errors that affect inference outcomes. Through an extensive experimental campaign comprising over 2.2+ trillion data points across 4 microcontroller units (MCUs) and 8 benchmarks, we demonstrate that by tolerating a limited accuracy loss we can obtain up to $40 \%$ energy savings. We release our framework and toolset to foster further research in this emerging design space.

ACM TIOT launched a special issue on the theme of LLM Empowered Internet of Things, exploring the intersection of Large Language Models (LLMs) and the Internet of Things (IoT). As IoT continues to expand, advanced computational models are increasingly essential for processing and analyzing the massive data generated by interconnected devices. This special issue focuses on how LLMs can enhance IoT systems in several key areas. These include improving context-aware perception and retrieval in complex IoT environments, applications of LLMs in human–computer interaction as well as applications of AI agents for IoT. The issue also highlights emerging trends in low-code and zero-code development for IoT programming, and the deployment of AI models at the edge. These research directions reflect the diverse and evolving landscape of IoT and LLM integration, offering innovative solutions to real-world challenges.

We present hardware/software techniques to intelligently regulate supply voltage and clock frequency of intermittently computing devices. These devices rely on ambient energy harvesting to power their operation and small capacitors as energy buffers. Statically setting their clock frequency fails to capture the unique relations these devices expose between capacitor voltage, energy efficiency at a given operating frequency, and the corresponding operating range. Existing dynamic voltage and frequency scaling techniques are also largely inapplicable due to extreme energy scarcity and peculiar hardware features. We introduce two hardware/software co-designs that accommodate the distinct hardware features and function within a constrained energy envelope, offering varied tradeoffs and functionalities. Our experimental evaluation combines tests on custom-manufactured hardware and detailed emulation experiments. The data gathered indicate that our approaches result in up to 3.75× reduced energy consumption and 12× swifter execution times compared to the considered baselines, all while utilizing smaller capacitors to accomplish identical workloads.

In a long-term commitment to designing for the aesthetics of human–drone interactions, we have been troubled by the lack of tools for shaping and interactively feeling drone behaviours. By observing participants in a three-day drone challenge, we isolated components of drones that, if made transparent, could have helped participants better explore their aesthetic potential. Through a bricolage approach to analysing interviews, field notes, video recordings, and inspection of each team’s code, we describe how teams 1) shifted their efforts from aiming for seamless human–drone interaction, to seeing drones as fragile, wilful, and prone to crashes; 2) engaged with intimate, bodily interactions to more precisely probe, understand and define their drone’s capabilities; 3) adopted different workaround strategies, emphasising either training the drone or the pilot. We contribute an empirical account of constraints in shaping the potential aesthetics of drone behaviour, and discuss how programming environments could better support somaesthetic perception–action loops for design and programming purposes.

This paper presents an innovative approach to archaeological and geological exploration, combining Synthetic Aperture Radar (SAR) imagery, Ground Penetrating Radar (GPR), and advanced robotic algorithms. Utilizing SAR data captured by Capella, the study identifies areas of interest (AOIs) through supervised classification methods. These AOIs are then surveyed by a UAV equipped with GPR, optimized for efficient pathfinding and maximal coverage using robotic exploration algorithms. The survey generates high-resolution radar images, detailed digital elevation models, and orthomosaic images through photogrammetry, providing a comprehensive view of both surface and subsurface features.

We present INTERCEPT, a compile-time toolchain enabling manifold throughput improvements when running intermittent DNN inference on IoT devices, in exchange of a maximum 1% accuracy loss. Intermittently-computing IoT devices rely on ambient energy harvesting and compute opportunistically, as energy is available. They use NVM to persist intermediate results in anticipation of energy failures. Without requiring changes to existing models and by exploiting the features of STT-MRAM as NVM, INTERCEPT optimizes the placement and configuration of state persistence operations when executing the inference process. This happens off-line with no user intervention, while enforcing a maximum 1% accuracy loss. Our results, obtained across three platforms and six diverse neural networks, indicate that INTERCEPT provides a 40% energy gain in a single inference process, on average. With the same energy budget, this yields a 1.9x throughput speedup.

We present HUM-High-frequency UAV Messaging: an acoustic side channel communication system we design for localized drone-to-drone communications. We generate Pulse Width Modulated (PWM) signals from drone motors to carry information and improve communication reliability by mitigating propeller noise interference through modifications to the propeller's physical design. These modifications reduce propeller noise in the designated acoustic spectrum by up to 7 dB. We deploy a custom ultrasonic microphone shield specifically designed for decoding in the receiver. HUM's improved signal-to-noise ratio enables up to 80x higher data rates compared to the existing design from the literature while providing better scalability. HUM supports simultaneous decoding across 16 drones within 8 m, range as seen in real flight tests. The cost of this performance is minimal; we experimentally demonstrate that HUM has a marginal impact on flight dynamics and battery life.

We present TaDA, a system architecture enabling efficient execution of Internet of Things (IoT) applications across multiple computing units, powered by ambient energy harvesting. Low-power microcontroller units (MCUs) are increasingly specialized; for example, custom designs feature hardware acceleration of neural network inference, next to designs providing energy-efficient input/output. As application requirements are growingly diverse, we argue that no single MCU can efficiently fulfill them. TaDA allows programmers to assign the execution of different slices of the application logic to the most efficient MCU for the job. We achieve this by decoupling task executions in time and space, using a special-purpose hardware interconnect we design, while providing persistent storage to cross periods of energy unavailability. We compare our prototype performance against the single most efficient computing unit for a given workload. We show that our prototype saves up to 96.7% energy per application round. Given the same energy budget, this yields up to a 68.7x throughput improvement.

We presentMicNest: an acoustic localization system enabling precise drone landing. InMicNest, multiple microphones are deployed on a landing platform in carefully devised configurations. The drone carries a speaker transmitting purposefully-designed acoustic pulses. The drone may be localized as long as the pulses are correctly detected. Doing so is challenging:i)because of limited transmission power, propagation attenuation, background noise, and propeller interference, the Signal-to-Noise Ratio (SNR) of received pulses is intrinsically low;ii)the pulses experience non-linear Doppler distortion due to the physical drone dynamics;iii)as location information is used during landing, the processing latency must be reduced to effectively feed the flight control loop. To tackle these issues, we design a novel pulse detector, Matched Filter Tree (MFT), whose idea is to convert pulse detection to a tree search problem. We further present three practical methods to accelerate tree search jointly. Our experiments show thatMicNestcan localize a drone 120 m away with 0.53% relative localization error at 20 Hz location update frequency. For navigating drone landing,MicNestcan achieve a success rate of 94%. The average landing error (distance between landing point and target point) is only 4.3 cm.

We present Acoustic Inertial Measurement (AIM), a one-of-a-kind technique for indoor drone localization and tracking. Indoor drone localization and tracking are arguably a crucial, yet unsolved challenge: in GPS-denied environments, existing approaches enjoy limited applicability, especially in Non-Line of Sight (NLoS), require extensive environment instrumentation, or demand considerable hardware/software changes on drones. In contrast, AIM exploits the acoustic characteristics of the drones to estimate their location and derive their motion, even in NLoS settings. We tame location estimation errors using a dedicated Kalman filter and the Interquartile Range rule (IQR) and demonstrate that AIM can support indoor spaces with arbitrary ranges and layouts. We implement AIM using an off-the-shelf microphone array and evaluate its performance with a commercial drone under varied settings. Results indicate that the mean localization error of AIM is 46% lower than that of commercial UWB-based systems in a complex 10m×10m indoor scenario, where state-of-the-art infrared systems would not even work because of NLoS situations. When distributed microphone arrays are deployed, the mean error can be reduced to less than 0.5m in a 20m range, and even support spaces with arbitrary ranges and layouts.

We present a machine learning approach that uses a custom Convolutional Neural Network (CNN) for estimating the depth of water pools from multispectral drone imagery. Using drones to obtain this information offers a cheaper, timely, and more accurate solution compared to alternative methods, such as manual inspection. This information, in turn, represents an asset to identify potential breeding sites of mosquito larvae, which grow only in shallow water pools. As a significant part of the world’s population is affected by mosquito-borne viral infections, including Dengue and Zika, identifying mosquito breeding sites is key to control their spread. Experiments with 5-band drone imagery show that our CNN-based approach is able to measure shallow water depths accurately up to a root mean square error of less than 0.5 cm, outperforming state-of-the-art Random Forest methods and empirical approaches.

UAVs are becoming versatile and valuable platforms for various applications. However, the main limitation is their flying time. We present BEAVIS, a novel aerial robotic platform striking an unparalleled trade-off between the maneuverability of drones and the long-lasting capacity of blimps. BEAVIS scores highly in applications where drones enjoy unconstrained mobility yet suffer from limited lifetime. A nonlinear flight controller exploiting novel, unexplored, aerodynamic phenomena to regulate the ambient pressure and enable all translational and yaw degrees of freedom is proposed without direct actuation in the vertical direction. BEAVIS has built-in rotor fault detection and tolerance. We explain the design and the necessary background in detail. We verify the dynamics of BEAVIS and demonstrate its distinct advantages, such as agility, over existing platforms including the degrees of freedom akin to a drone with 11.36× increased lifetime. We exemplify the potential of BEAVIS to become an invaluable platform for many applications.

We present ReTA (Relative Timing Analysis), a differential timing analysis technique to verify the impact of an update on the execution time of embedded software. Timing analysis is computationally expensive and labor intensive. Software updates render repeating the analysis from scratch a waste of resources and time, because their impact is inherently confined. To determine this boundary, in ReTA we apply a slicing procedure that identifies all relevant code segments and a statement categorization that determines how to analyze each such line of code. We adapt a subset of ReTA for integration into aiT, an industrial timing analysis tool, and also develop a complete implementation in a tool called Delta. Based on staple benchmarks and realistic code updates from official repositories, we test the accuracy by analyzing the worst-case execution time (WCET) before and after an update, comparing the measures with the use of the unmodified aiT as well as real executions on embedded hardware. Delta returns WCET information that ranges from exactly the WCET of real hardware to 148% of the new version's measured WCET. With the same benchmarks, the unmodified aiT estimates are 112% and 149% of the actual executions; therefore, even when Delta is pessimistic, an industry-strength tool such as aiT cannot do better. Crucially, we also show that ReTA decreases aiT's analysis time by 45% and its memory consumption by 8.9%, whereas removing ReTA from Delta, effectively rendering it a regular timing analysis tool, increases its analysis time by 27%.

We explore how hardware approximation techniques can be used to reduce the overhead introduced by state persistence operations in intermittent computing. We do so by exploring the trade-off between energy consumption and quality of the results. We specifically adjust the energy/quality ratio of write operations in Spin Transfer Torque Magnetic Random Access Memory (STT-MRAM) by modifying the current applied during these operations. Our evaluation on a heterogeneus set of benchmarks demonstrates up to ≈50% reduction in the state persistence overhead while maintaining an acceptable output quality.

We present NeRTA ( Ne xt R elease T ime A nalysis), a technique to enable dynamic software updates for low-level control software of mobile robots. Dynamic software updates enable software correction and evolution during system operation. In mobile robotics, they are crucial to resolve software defects without interrupting system operation or to enable on-the-fly extensions. Low-level control software for mobile robots, however, is time sensitive and runs on resource-constrained hardware with no operating system support. To minimize the impact of the update process, NeRTA safely schedules updates during times when the computing unit would otherwise be idle. It does so by utilizing information from the existing scheduling algorithm without impacting its operation. As such, NeRTA works orthogonal to the existing scheduler, retaining the existing platform-specific optimizations and fine-tuning, and may simply operate as a plug-in component. To enable larger dynamic updates, we further conceive an additional mechanism called bounded reactive control and apply mixed-criticality concepts. The former cautiously reduces the overall control frequency, whereas the latter excludes less critical tasks from NeRTA processing. Their use increases the available idle times. We combine real-world experiments on embedded hardware with simulations to evaluate NeRTA. Our experimental evaluation shows that the difference between NeRTA’s estimated idle times and the measured idle times is less than 15% in more than three-quarters of the samples. The combined effect of bounded reactive control and mixed-criticality concepts results in a 150+% increase in available idle times. We also show that the processing overhead of NeRTA and of the additional mechanisms is essentially negligible.

We present the concept of approximate intermittent computing and concretely demonstrate its application. Intermittent computations stem from the erratic energy patterns caused by energy harvesting: computations unpredictably terminate whenever energy is insufficient and the application state is lost. Existing solutions maintain equivalence to continuous executions by creating persistent state on non-volatile memory, enabling stateful computations to cross power failures. The performance penalty is massive: system throughput reduces while energy consumption increases. In contrast, approxi-mate intermittent computations trade the accuracy of the results for sparing the entire overhead to maintain equivalence to a continuous execution. This is possible as we use approximation to limit the extent of stateful computations to the single power cycle, enabling the system to completely shift the energy budget for managing persistent state to useful computations towards an immediate ap-proximate result. To this end, we effectively reverse the regular formulation of approximate computing problems. First, we apply approximate intermittent computing to human activity recognition. We design an anytime variation of support vector machines able to improve the accuracy of the classification as energy is available. We build a hw/sw prototype using kinetic energy and show a 7x improvement in system throughput compared to state-of-the-art system support for intermittent computing, while retaining 83% accuracy in a setting where the best attainable accuracy is 88%. Next, we apply approximate intermittent computing in a sharply different scenario, that is, embedded image processing, using loop perforation. Using a different hw / sw prototype we build and diverse energy traces, we show a 5x improvement in system throughput compared to state-of-the-art system support for intermittent computing, while providing an equivalent output in 84% of the cases.

We present radio-frequency (RF) information harvesting, a chan-nel sensing technique that takes advantage of the energy in the wireless medium to detect channel activity at essentially no en-ergy cost. RF information harvesting is essential for event-driven wireless sensing applications using battery-less devices that har-vest tiny amounts of energy from impromptu events, such as op-erating a switch, and then transmit the event notification to a one-hop gateway. As multiple such devices may concurrently de-tect events, coordinating access to the channel is key. RF infor-mation harvesting allows devices to break the symmetry between concurrently-transmitting devices based on the harvested energy from the ongoing transmissions. To demonstrate the benefits of RF information harvesting, we integrate it in a tailor-made ultra low-power hardware MAC protocol we call Radio Frequency-Distance Packet Queuing (RF-DiPaQ). We build a hardware/software proto-type of RF-DiPaQ and use an established Markov framework to study its performance at scale. Comparing RF-DiPaQ against sta-ple contention-based MAC protocols, we show that it outperforms pure Aloha and 1-CSMA by factors of 3.55 and 1.21 respectively in throughput, while it saturates at more than double the offered load compared to 1-CSMA. As traffic increases, the energy saving of RF-DiPaQ against CSMA protocols increases, consuming 36% less energy than np-CSMA at typical offered loads.

We present Acoustic Inertial Measurement (AIM), a one-of-a-kind technique for indoor drone localization and tracking. Indoor drone localization and tracking are arguably a crucial, yet unsolved challenge: in GPS-denied environments, existing approaches enjoy limited applicability, especially in Non-Line of Sight (NLoS), require extensive environment instrumentation, or demand considerable hardware/software changes on drones. In contrast, AIM exploits the acoustic characteristics of the drones to estimate their location and derive their motion, even in NLoS settings. We tame location estimation errors using a dedicated Kalman filter and the Interquartile Range rule (IQR). We implement AIM using an off-the-shelf microphone array and evaluate its performance with a commercial drone under varied settings. Results indicate that the mean localization error of AIM is 46% lower than commercial UWB-based systems in complex indoor scenarios, where state-of-the-art infrared systems would not even work because of NLoS settings. We further demonstrate that AIM can be extended to support indoor spaces with arbitrary ranges and layouts without loss of accuracy by deploying distributed microphone arrays.

We present MicNest: an acoustic localization system enabling precise landing of aerial drones. Drone landing is a crucial step in a drone's operation, especially as high-bandwidth wireless networks, such as 5G, enable beyond-line-of-sight operation in a shared airspace and applications such as instant asset delivery with drones gain traction. In MicNest, multiple microphones are deployed on a landing platform in carefully devised configurations. The drone carries a speaker transmitting purposefully-designed acoustic pulses. The drone may be localized as long as the pulses are correctly detected. Doing so is challenging: i) because of limited transmission power, propagation attenuation, background noise, and propeller interference, the Signal-to-Noise Ratio (SNR) of received pulses is intrinsically low; ii) the pulses experience non-linear Doppler distortion due to the physical drone dynamics while airborne; iii) as location information is to be used during landing, the processing latency must be reduced to effectively feed the flight control loop. To tackle these issues, we design a novel pulse detector, Matched Filter Tree (MFT), whose idea is to convert pulse detection to a tree search problem. We further present three practical methods to accelerate tree search jointly. Our real-world experiments show that MicNest is able to localize a drone 120 m away with 0.53% relative localization error at 20 Hz location update frequency.

We present ALFRED: a virtual memory abstraction that resolves the dichotomy between volatile and non-volatile memory in intermittent computing. Mixed-volatile microcontrollers allow programmers to allocate part of the application state onto non-volatile memory. Programmers are therefore to manually explore the tradeoff between simpler management of persistent state against energy overhead and possibility of intermittence anomalies due to nonvolatile memory operations. This approach is laborious and yields sub-optimal performance. We take a different stand with ALFRED: we provide programmers with a virtual memory abstraction detached from the specific volatile nature of memory and automatically determine an efficient mapping from virtual to volatile or non-volatile memory. Unlike existing works, ALFRED does not require programmers to learn a new language syntax and the mapping is entirely resolved at compile-time, reducing the run-time energy overhead. We implement ALFRED through a series of machine-level code transformations. Compared to existing systems, we demonstrate that ALFRED reduces energy consumption by up to two orders of magnitude given a fixed workload. This enables workloads to finish sooner, as the use of available energy shifts from ensuring forward progress to useful application processing.

High accuracy and device-free indoor localization is still a holy grail to enable smart environments. With the growing privacy concerns and regulations, it is necessary to develop methods and systems that can be low-power, device-free as well as privacy-aware. While IR-based solutions fit the bill, they require many modules to be installed in the area of interest for higher accuracy, or proper planning during installation, or they may not work if the background has multiple heat-emitting objects, etc. In this paper, we propose a custom-built miniature device called LOCI that uses IR sensing. One unit of LOCI can provide three-dimensional localization at best. LOCI uses only a thermopile and a PIR sensor built within a 5x5x2 cm3module. Since IR-based sensing is used, LOCI consumes around 80 mW. LOCI uses analog waveform from the PIR sensor with the gain of the PIR sensor dynamically controlled through software in real-time to simulate spatial diversity. LOCI proposes low-complexity techniques with sensor fusion to eliminate the noise in the background, which has not been handled in previous works even with sophisticated signal processing techniques. Since LOCI uses raw data from the thermopile, the computations are power-efficient. We present the complete design of LOCI and the proposed methodology to estimate height and location. LOCI achieves accuracies of sub-22 cm with a confidence of 0.5 and sub-35 cm with a confidence of 0.8. The best-case location accuracy is 12.5 cm. The accuracy of height estimation is within 8 cm in majority cases. LOCI can easily be extended to recognize activities.

Global Positioning System is a widely adopted localization technique. With the increasing demand for small satellites, the need for a low-power GPS for satellites is also increasing. To enable many state-of-the-art applications, the exact position of the satellites is necessary. However, building low-power GPS receivers which operate in low earth orbit pose significant challenges. This is mainly due to the high speed (~7.8 km/s) of small satellites. While duty-cycling the receiver is a possible solution, the high relative Doppler shift between the GPS satellites and the small satellite contributes to the increase in Time To First Fix (TTFF), thus increasing the energy consumption. Further, if the GPS receiver is tumbling along with the small satellite on which it is mounted, longer TTFF may lead to no GPS fix due to disorientation of the receiver antenna. In this paper, we elucidate the design of a low-cost, low-power GPS receiver for small satellite applications. We also propose an energy optimization algorithm called F3to improve the TTFF which is the main contributor to the energy consumption during cold start. With simulations and in-orbit evaluation from a launched nanosatellite with our μGPS and high-end GPS simulators, we show that up to 96.16% of energy savings (consuming only ~ 1/25th energy compared to the state of the art) can be achieved using our algorithm without compromising much (~10 m) on the navigation accuracy. The TTFF achieved is at most 33 s.

We present the design and evaluation of a 3.5-year embedded sensing deployment at the Mithræum of Circus Maximus, a UNESCO-protected underground archaeological site in Rome (Italy). Unique to our work is the use of energy harvesting through thermal and kinetic energy sources. The extreme scarcity and erratic availability of energy, however, pose great challenges in system software, embedded hardware, and energy management. We tackle them by testing, for the first time in a multi-year deployment, existing solutions in intermittent computing, low-power hardware, and energy harvesting. Through three major design iterations, we find that these solutions operate as isolated silos and lack integration into a complete system, performing suboptimally. In contrast, we demonstrate the efficient performance of a hardware/software co-design featuring accurate energy management and capturing the coupling between energy sources and sensed quantities. Installing a battery-operated system alongside also allows us to perform a comparative study of energy harvesting in a demanding setting. Albeit the latter reduces energy availability and thus lowers the data yield to about 22% of that provided by batteries, our system provides a comparable level of insight into environmental conditions and structural health of the site. Further, unlike existing energy-harvesting deployments that are limited to a few months of operation in the best cases, our system runs with zero maintenance since almost 2 years, including 3 months of site inaccessibility due to a COVID19 lockdown.

Intermittently powered embedded devices ensure forward progress of programs through state checkpointing in non-volatile memory. Checkpointing is, however, expensive in energy and adds to the execution times. To minimize this overhead, we present DICE, a system that renders differential checkpointing profitable on these devices. DICE is unique because it is a software-only technique and efficient because it only operates in volatile main memory to evaluate the differential. DICE may be integrated with reactive (Hibernus) or proactive (MementOS, HarvOS) checkpointing systems, and arbitrary code can be enabled with DICE using automatic code-instrumentation requiring no additional programmer effort. By reducing the cost of checkpoints, DICE cuts the peak energy demand of these devices, allowing operation with energy buffers that are one-eighth of the size originally required, thus leading to benefits such as smaller device footprints and faster recharging to operational voltage level. The impact on final performance is striking: with DICE, Hibernus requires one order of magnitude fewer checkpoints and one order of magnitude shorter time to complete a workload in real-world settings.

Transiently powered computers (TPCs) form the foundation of the battery-less Internet of Things, using energy harvesting and small capacitors to power their operation. This kind of power supply is characterized by extreme variations in supply voltage, as capacitors charge when harvesting energy and discharge when computing. We experimentally find that these variations cause marked fluctuations in clock speed and power consumption . Such a deceptively minor observation is overlooked in existing literature. Systems are thus designed and parameterized in overly conservative ways, missing on a number of optimizations. We rather demonstrate that it is possible to accurately model and concretely capitalize on these fluctuations. We derive an energy model as a function of supply voltage and prove its use in two settings. First, we develop EPIC, a compile-time energy analysis tool. We use it to substitute for the constant power assumption in existing analysis techniques, giving programmers accurate information on worst-case energy consumption of programs. When using EPIC with existing TPC system support, run-time energy efficiency drastically improves, eventually leading up to a 350% speedup in the time to complete a fixed workload. Further, when using EPIC with existing debugging tools, it avoids unnecessary program changes that hurt energy efficiency. Next, we extend the MSPsim emulator and explore its use in parameterizing a different TPC system support. The improvements in energy efficiency yield up to more than 1000% time speedup to complete a fixed workload.

Embedded devices running on ambient energy perform computations intermittently, depending upon energy availability. System support ensures forward progress of programs through state checkpointing in non-volatile memory. Checkpointing is, however, expensive in energy and adds to execution times. To reduce this overhead, we present DICE, a system design that efficiently achieves differential checkpointing in intermittent computing. Distinctive traits of DICE are its software-only nature and its ability to only operate in volatile main memory to determine differentials. DICE works with arbitrary programs using automatic code instrumentation, thus requiring no programmer intervention, and can be integrated with both reactive (Hibernus) or proactive (MementOS, HarvOS) checkpointing systems. By reducing the cost of checkpoints, performance markedly improves. For example, using DICE, Hibernus requires one order of magnitude shorter time to complete a fixed workload in real-world settings.

Transiently-powered computers (TPCs) lay the basis for a battery-less Internet of Things, using energy harvesting and small capacitors to power their operation. This power supply is characterized by extreme variations in supply voltage, as capacitors charge when harvesting energy and discharge when computing. We experimentally find that these variations cause marked fluctuations in clock speed and power consumption, which determine energy efficiency. We demonstrate that it is possible to accurately model and concretely capitalize on these fluctuations. We derive an energy model as a function of supply voltage and develop EPIC, a compile-time energy analysis tool. We use EPIC to substitute for the constant power assumption in existing analysis techniques, giving programmers accurate information on worst-case energy consumption of programs. When using EPIC with existing TPC system support, run-time energy efficiency drastically improves, eventually leading up to a 350% speedup in the time to complete a fixed workload. Further, when using EPIC with existing debugging tools, programmers avoid unnecessary program changes that hurt energy efficiency.

The resource-constrained devices of the battery-less Internet of Things are powered off energy harvesting and compute intermittently, as energy is available. Forward progress of programs is ensured by creating persistent state. Mixed-volatile platforms are thus an asset, as they map slices of the address space onto non-volatile memory. However, these platforms also possibly introduce intermittence bugs, where intermittent and continuous executions differ.

FlyZone is a testbed architecture to experiment with aerial drone applications. Unlike most existing drone testbeds that focus on low-level mechanical control, FlyZone offers a high-level API and features geared towards experimenting with application-level functionality. These include the emulation of environment influences, such as wind, and the automatic monitoring of developer-provided safety constraints, for example, to mimic obstacles. We conceive novel solutions to achieve this functionality, including a hardware/software architecture that maximizes decoupling from the main application and a custom visual localization technique expressly designed for testbed operation. We deploy two instances of FlyZone and study performance and effectiveness. We demonstrate that we realistically emulate the environment influence with a positioning error bound by the size of the smallest drone we test, that our localization technique provides a root mean square error of 9.2cm, and that detection of violations to safety constraints happens with a 50ms worst-case latency. We also report on how FlyZone supported developing three real-world drone applications, and discuss a user study demonstrating the benefits of FlyZone compared to drone simulators.

Energy harvesting enables battery-less sensing applications, but causes executions to become intermittent as a result of erratic energy provisioning. Intermittent executions pose challenges to peripheral consistency that threaten to leave peripheral-bound workloads in failed states or to impede forward progress of programs. Intermittent synchronous peripheral operations are supported in existing literature for specific kinds of peripherals. Asynchronous peripheral operations enable reactive concurrency in application implementations, which increases reactivity and improves energy consumption, but lack dedicated support in intermittent settings. We present Karma, the first general abstraction and system design to support both synchronous and asynchronous operations in an intermittent setting. Karma employs a novel combination of peripheral roll-forward and computation roll-back to a rendezvous point guaranteeing consistency. It remains transparent to application programmers and peripheral driver, which favours portability. Our evaluation, based on three applications running on prototype hardware and using diverse energy sources, indicates that intermittent asynchronous peripheral support provided by Karma boosts data throughput by 83% compared to existing literature.

A wide gap exists between the state of the art in developing Wireless Sensor Network (WSN) software and current practices concerning the design, execution, and maintenance of business processes. WSN software is most often developed based on low-level OS abstractions, whereas business process development leverages high-level languages and tools. This state of affairs places WSNs at the fringe of industry. The makeSense system addresses this problem by simplifying the integration of WSNs into business processes. Developers use BPMN models extended with WSN-specific constructs to specify the application behavior across both traditional business process execution environments and the WSN itself, which is to be equipped with application-specific software. We compile these models into a high-level intermediate language-also directly usable by WSN developers-and then into OS-specific deployment-ready binaries. Key to this process is the notion of meta-abstraction, which we define to capture fundamental patterns of interaction with and within the WSN. The concrete realization of meta-abstractions is application-specific; developers tailor the system configuration by selecting concrete abstractions out of the existing codebase or by providing their own. Our evaluation of makeSense shows that i) users perceive our approach as a significant advance over the state of the art, providing evidence of the increased developer productivity when using makeSense; ii) in large-scale simulations, our prototype exhibits an acceptable system overhead and good scaling properties, demonstrating the general applicability of makeSense; and, iii) our prototype-including the complete tool-chain and underlying system support-sustains a real-world deployment where estimates by domain specialists indicate the potential for drastic reductions in the total cost of ownership compared to wired and conventional WSN-based solutions.

We propose a set of differential techniques to allow transientlypowered embedded devices reduce the amount of data written on non-volatile memory during checkpoints used to cross times of energy unavailability. These techniques track modifications in the application state to isolate data from the slice of the previous checkpoint that remains unaltered. At the following checkpoint, our approach may thus only update the parts it detects as modified. This allows us to shift part of the energy budget from checkpointing overhead to useful computations, yielding better overall energy efficiency.

We present 64Key, a hardware/software platform that enables impromptu sensing, data sharing, collaborative working, and social networking among physically co-located users independently of their own hardware platform, operating system, network stack, and of the availability of Internet access. 64Key caters to those scenarios such as computer labs, large conferences, and emergency situations where the network infrastructure is limited in operation or simply not available, and peer-to-peer interactions are prevented or not possible. By plugging a 64Key device in one's mobile device USB port, an independent network is created on the fly, which users access from their own device though a web-based interface. In addition to default apps such as chat, file sharing, and collaborative text editing, 64Key's functionality may be extended through the run-time installation of third-party apps, available at a public app store. We demonstrate our proof-of-concept implementation of 64Key with multiple apps in a set of key scenarios.

We present design concepts, programming constructs, and automatic verification techniques to support the development of adaptive Wireless Sensor Network (WSN) software. WSNs operate at the interface between the physical world and the computing machine and are hence exposed to unpredictable environment dynamics. WSN software must adapt to these dynamics to maintain dependable and efficient operation. However, developers are left without proper support to develop adaptive functionality in WSN software. Our work fills this gap with three key contributions: (i) design concepts help developers organize the necessary adaptive functionality and understand their relations, (ii) dedicated programming constructs simplify the implementations, (iii) custom verification techniques allow developers to check the correctness of their design before deployment. We implement dedicated tool support to tie the three contributions, facilitating their practical application. Our evaluation considers representative WSN applications to analyze code metrics, synthetic simulations, and cycle-accurate emulation of popular WSN platforms. The results indicate that our work is effective in simplifying the development of adaptive WSN software; for example, implementations are provably easier to test and to maintain, the run-time overhead of our dedicated programming constructs is negligible, and our verification techniques return results in a matter of seconds.

We present code instrumentation strategies to allow transiently-powered embedded sensing devices efficiently checkpoint the system's state before energy is exhausted. Our solution, called HarvOS, operates at compile-time with limited developer intervention based on the control-flow graph of a program, while adapting to varying levels of remaining energy and possible program executions at run-time. In addition, the underlying design rationale allows the system to spare the energy-intensive probing of the energy buffer whenever possible. Compared to existing approaches, our evaluation indicates that HarvOS allows transiently-powered devices to complete a given workload with 68% fewer checkpoints, on average. Moreover, our performance in the number of required checkpoints rests only 19% far from that of an "oracle" that represents an ideal solution, yet unfeasible in practice, that knows exactly the last point in time when to checkpoint.

Low-power wireless technology promises greater flexibility and lower costs in cyber-physical systems. To reap these benefits, communication protocols must deliver packets reliably within real-time deadlines across resource-constrained devices , while adapting to changes in application requirements (e.g., traffic demands) and network state (e.g., link qualities). Existing protocols do not solve all these challenges simultaneously, because their operation is either localized or a function of network state, which changes unpredictably over time. By contrast, this article claims a global approach that does not use network state information as input can overcome these limitations. The Blink protocol proves this claim by providing hard guarantees on end-to-end deadlines of received packets in multi-hop low-power wireless networks, while seamlessly handling changes in application requirements and network state. We build Blink on the non-real-time Low-Power Wireless Bus (LWB) and design new scheduling algorithms based on the earliest-deadline-first policy. Using a dedicated priority queue data structure, we demonstrate a viable implementation of our algorithms on resource-constrained devices. Experiments show that Blink (i) meets all deadlines of received packets, (ii) delivers 99.97% of packets on a 94-node testbed, (iii) minimizes communication energy consumption within the limits of the underlying LWB, (iv) supports end-to-end deadlines of 100ms across four hops and nine sources, and (v) runs up to 4.1 × faster than a conventional scheduler implementation on popular microcontrollers.

We present COIN, a system architecture to enable running a slice of a mobile app's logic onto connected devices such as proximity beacons, body-worn sensors, and controllable light bulbs. These are normally shipped as black-boxes: their functionality is fixed by vendors and typically accessed only through low-level APIs. This often limits the flexibility in designing applications and requires intense wireless interactions between mobile and connected devices, which impacts energy consumption particularly on the latter. We overcome the limitations of this design by providing a generic programmable substrate right onto the connected device. Mobile apps can dynamically deploy arbitrary tasks implemented as loosely-coupled actor-like components. The underlying run-time support takes care of the coordination across tasks and of their real-time scheduling.

Directional antennas improve network performance by increasing the communication range and alleviating contention as proven, e.g., in cellular and ad-hoc networks. In principle, one may reap similar benefits in wireless sensor networks (WSNs), where energy concerns and reliability requirements make this antenna technology even more desirable. However, it is unclear how the shortcomings of directional antennas, e.g., increased likelihood of hidden terminals, affect WSNs. We quantitatively study these aspects for convergecast, a staple network functionality popular in WSN applications, e.g., for data collection. The integration of directional communication in convergecast protocols is non-trivial: probing wireless links between neighboring nodes is no longer feasible with single broadcast transmissions, as the antenna configuration depends on the target neighbor. This bears a great impact on the efficiency in building and maintaining the routing topology. We perform our study in simulation, based on an empirical model of an existing antenna prototype. This allows us to explore the parameter space efficiently yet realistically, a goal otherwise impossible without several antenna prototypes that, unlike WSN motes, are not readily available. Our results point to a negative answer, directional antennas, when used for WSN convergecast, provide limited benefits, appreciable only when certain specific conditions are met.

Aerial drones, ground robots, and aquatic rovers enable mobile applications that no other technology can realize with comparable flexibility and costs. In existing platforms, the low-level control enabling a drone's autonomous movement is currently realized in a time-triggered fashion, which simplifies implementations. In contrast, we conceive a notion of reactive control that supersedes the time-triggered approach by leveraging the characteristics of existing control logic and of the hardware it runs on. Using reactive control, control decisions are taken only upon recognizing the need to, based on observed changes in the navigation sensors. As a result, the rate of execution dynamically adapts to the circumstances. Compared to time-triggered control, this allows us to: i) attain more timely control decisions, ii) improve hardware utilization, iii) lessen the need to over-provision control rates. Based on 260+ hours of real-world experiments using three aerial drones, three different control logic, and three hardware platforms, we demonstrate, for example, up to 41% improvements in control accuracy and up to 22% improvements in flight time.

Experimental research in low-power wireless networking lacks a reference benchmark. While other communities such as databases or machine learning have standardized benchmarks, our community still uses ad-hoc setups for its experiments and struggles to provide a fair comparison between communication protocols. Reasons for this include the diversity of network scenarios and the stochastic nature of wireless experiments. Leveraging on the excellent testbeds and tools that have been built to support experimental validation, we make the case for a reference benchmark to promote a fair comparison and reproducibility of results. This abstract describes early design elements and a benchmarking methodology with the goal to gather feedback from the community rather than propose a definite solution.

Advances in micro-electronics and miniaturized mechanical systems are redefining the scope and extent of the energy constraints found in battery-operated wireless sensor networks (WSNs). On one hand, ambient energy harvesting may prolong the systems’ lifetime or possibly enable perpetual operation. On the other hand, wireless energy transfer allows systems to decouple the energy sources from the sensing locations, enabling deployments previously unfeasible. As a result of applying these technologies to WSNs, the assumption of a finite energy budget is replaced with that of potentially infinite , yet intermittent , energy supply, profoundly impacting the design, implementation, and operation of WSNs. This article discusses these aspects by surveying paradigmatic examples of existing solutions in both fields and by reporting on real-world experiences found in the literature. The discussion is instrumental in providing a foundation for selecting the most appropriate energy harvesting or wireless transfer technology based on the application at hand. We conclude by outlining research directions originating from the fundamental change of perspective that energy harvesting and wireless transfer bring about.

Wireless sensor networks (WSNs) are characterized by localized interactions , that is, protocols are often based on message exchanges within a node’s direct radio range. We recognize that for these protocols to work effectively, nodes must have consistent information about their shared neighborhoods. Different types of faults, however, can affect this information, severely impacting a protocol’s performance. We factor this problem out of existing WSN protocols and argue that a notion of neighborhood view consistency (NVC) can be embedded within existing designs to improve their performance. To this end, we study the problem from both a theoretical and a system perspective. We prove that the problem cannot be solved in an asynchronous system using any of Chandra and Toueg’s failure detectors. Because of this, we introduce a new software device called pseudocrash failure detector (PCD), study its properties, and identify necessary and sufficient conditions for solving NVC with PCDs. We prove that, in the presence of transient faults, NVC is impossible to solve with any PCDs, thus define two weaker specifications of the problem. We develop a global algorithm that satisfies both specifications in the presence of unidirectional links, and a localized algorithm that solves the weakest specification in networks of bidirectional links. We implement the latter atop two different WSN operating systems, integrate our implementations with four different WSN protocols, and run extensive micro-benchmarks and full-stack experiments on a real 90-node WSN testbed. Our results show that the performance significantly improves for NVC-equipped protocols; for example, the Collection Tree Protocol (CTP) halves energy consumption with higher data delivery.

We present DPT: a wireless sensor network protocol for bulk traffic that uniquely leverages electronically switchable directional (ESD) antennas. Bulk traffic is found in several scenarios and supporting protocols based on standard antenna technology abound. ESD antennas may improve performance in these scenarios; for example, by reducing channel contention as the antenna can steer the radiated energy only towards the intended receivers, and by extending the communication range at no additional energy cost. The corresponding protocol support, however, is largely missing. DPT addresses precisely this issue. First, while the network is quiescent, we collect link metrics across all possible antenna configurations. We use this information to formulate a constraint satisfaction problem (CSP) that allows us to find two multi-hop disjoint paths connecting source and sink, along with the corresponding antenna configurations. Domain-specific heuristics we conceive ameliorate the processing demands in solving the CSP, improving scalability. Second, the routing configuration we obtain is injected back into the network. During the actual bulk transfer, the source funnels data through the two paths by quickly alternating between them. Packet forwarding occurs deterministically at every hop. This allows the source to implicitly "clock" the entire pipeline, sparing the need of proactively synchronizing the transmissions across the two paths. Our results, obtained in a real testbed using 802.15.4-compliant radios and custom ESD antennas we built, indicate that DPT approaches the maximum throughput supported by the link layer, peaking at 214 kbit/s in the settings we test.

Wireless sensor networks are often deployed indoors where artificial lighting is present. Indoor lighting is increasingly being composed of Light Emitting Diodes (LEDs) that offer the ability to precisely control the intensity and the frequency of the light carrier. This can be used to coordinate wireless sensor networks (WSN). The periodic variations in the light intensity can synchronise the clocks on the sensor nodes, while the ability to modulate the light carrier enables the transmission of control information like channel assignment or transmission schedules.We present Guidelight, a simple mechanism that uses controlled fluctuations in the light intensity to coordinate sensor nodes. Guidelight can wake-up or time synchronise sensor nodes or even send small bits of control information to them. All of these have separate dedicated solutions in WSN. Guidelight aims to provide a single solution to all these problems. Our initial experiments demonstrate the ability of Guidelight to trigger sensor nodes. We demonstrate Guidelight is able to trigger sensor nodes selectively at a mean error of 21 μ s.

We present programming abstractions for implementing adaptive Wireless Sensor Network (WSN) software. The need for adaptability arises in WSNs because of unpredictable environment dynamics, changing requirements, and resource scarcity. However, after about a decade of research in WSN programming, developers are still left with no dedicated support. To address this issue, we bring concepts from Context-Oriented Programming (COP) down to WSN devices. Contexts model the situations that WSN software needs to adapt to. Using COP, programmers use a notion of layered function to implement context-dependent behavioral variations of WSN code. To this end, we provide language-independent design concepts to organize the context-dependent WSN operating modes, decoupling the abstractions from their concrete implementation in a programming language. Our own implementation, called CONESC, extends nesC with COP constructs. Based on three representative applications, we show that CONESC greatly simplifies the resulting code and yields increasingly decoupled implementations compared to nesC. For example, by model-checking every function in either implementations, we show a ~50% reduction in the number of program states that programmers need to deal with, indicating easier debugging. In our tests, this comes at the price of a maximum 2.5% (4.5%) overhead in program (data) memory.

Autonomous drones are a powerful new breed of mobile sensing platform that can greatly extend the capabilities of traditional sensing systems. Unfortunately, it is still non-trivial to coordinate multiple drones to perform a task collaboratively. We present a novel programming model called team-level programming that can express collaborative sensing tasks without exposing the complexity of managing multiple drones, such as concurrent programming, parallel execution, scaling, and failure recovering. We create the Voltron programming system to explore the concept of team-level programming in active sensing applications. Voltron offers programming constructs to create the illusion of a simple sequential execution model while still maximizing opportunities to dynamically re-task the drones as needed. We implement Voltron by targeting a popular aerial drone platform, and evaluate the resulting system using a combination of real deployments, user studies, and emulation. Our results indicate that Voltron enables simpler code and produces marginal overhead in terms of CPU, memory, and network utilization. In addition, it greatly facilitates implementing correct and complete collaborative drone applications, compared to existing drone programming systems.

Wireless sensor networks (WSNs) enable decentralized architectures to monitor the behavior of physical processes and to detect deviations from a specified “safe” behavior, for example, to check the operation of control loops. Such correct behavior is typically expressed by global invariants over the state of different sensors or actuators. Nevertheless, to leverage the computing capabilities of WSN nodes, the application intelligence needs to reside inside the network. The task of ensuring that the monitored processes behave safely thus becomes inherently distributed, and hence more complex. In this article we present DICE, a system enabling WSN-based distributed monitoring of global invariants. A DICE invariant is expressed by predicates defined over the state of multiple WSN nodes, such as the expected state of actuators based on given sensed environmental conditions. Our modular design allows two alternative protocols for detecting invariant violations: both perform in-network aggregation but with different degrees of decentralization, therefore supporting scenarios with different network and data dynamics. We characterize and compare the two protocols using large-scale simulations and a real-world testbed. Our results indicate that invariant violations are detected in a timely and energy-efficient manner. For instance, in a 225-node 15-hop network, invariant violations are detected in less than a second and with only a few packets sent by each node.

Mathematical models play a pivotal role in understanding and designing advanced low-power wireless systems. However, the distributed and uncoordinated operation of traditional multi-hop low-power wireless protocols greatly complicates their accurate modeling. This is mainly because these protocols build and maintain substantial network state to cope with the dynamics of low-power wireless links. Recent protocols depart from this design by leveraging synchronous transmissions (ST), whereby multiple nodes simultaneously transmit towards the same receiver, as opposed to pair wise link-based transmissions (LT). ST improve the one-hop packet reliability to an extent that efficient multi-hop protocols with little network state are feasible. This paper studies whether ST also enable simple yet accurate modeling of these protocols. Our contribution to this end is two-fold. First, we show, through experiments on a 139-node test bed, that characterizing packet receptions and losses as a sequence of independent and identically distributed (i.i.d.) Bernoulli trials-a common assumption in protocol modeling but often illegitimate for LT-is largely valid for ST. We then show how this finding simplifies the modeling of a recent ST-based protocol, by deriving (i) sufficient conditions for probabilistic guarantees on the end-to-end packet reliability, and (ii) a Markovian model to estimate the long-term energy consumption. Validation using test bed experiments confirms that our simple models are also highly accurate, for example, the model error in energy against real measurements is 0.25%, a figure never reported before in the related literature.

We study the benefits of electronically-switched directional (ESD) antennas in wireless sensor networks (WSNs). ESD antennas have proved beneficial in cellular and ad-hoc networks, by increasing the communication range and by alleviating contention in directions other than the destination. The advantages in WSNs are, however, still largely to be quantified. Unlike existing works in this field, we start by characterizing a real-world antenna prototype, and apply this to an existing WSN stack, which we adapt with minimal changes. Our results show that: i) the combination of a low-cost ESD antenna and a mainstream WSN stack already brings significant performance improvements, e.g., nearly halving the radio-on time per delivered packet; ii) the margin of improvement available to alternative clean-slate protocol designs is similarly large and concentrated in the control rather than the data plane; iii) by artificially modifying our antenna's link-layer model, further potential benefits opened by different antenna designs may be available. To the best of our knowledge, this is the first study providing such quantitative insights based on a real ESD antenna prototype and a complete WSN stack.

We present our ongoing work on the design of macroprogramming abstractions to program sensing and actuating applications using robot swarms. Robots can sample the environment and act on it where no other sensor can reach, e.g., to monitor the environment at altitude with aerial robots. Programming the individual behavior of multiple coordinating robots is difficult. We design LiftOff, a macroprogramming abstraction that allows to program robot swarms collectively, by creating the illusion of a single computing device that occupies the entire physical space of interest. We achieve this by giving variables and values in a programming language a spatial semantics. In LiftOff, values may be associated to a location, and programmers use the same variable to access different values at different locations, sparing the need to manually create a mapping from variables to spatial values. LiftOff applications execute synchronously or based on lazy evaluation. The former allows precise program analysis, e.g., using model checking, whilst the latter potentially executes faster. In this paper, we report on LiftOff's initial design and prototypes.

Many sensor network applications generate large amounts of sensed data. These often need to be delivered reliably to the sink node for further processing. In such applications, high communication throughput allows for more data to be sensed. Intra-path interference is a problem in reliable forwarding of data and affects the end-to-end throughput. We show that using antennas that allow directional transmissions and receptions significantly reduces intra-path interference and enables high throughput forwarding of packet bursts over multiple hops using only one wireless channel.

Traditional low-power wireless protocols maintain distributed network state to cope with link dynamics. Modeling the protocol operation as a function of network state is difficult as the state is frequently updated in an uncoordinated fashion. Recent protocols use synchronous transmissions (ST): multiple nodes send simultaneously towards the same receiver, as opposed to pairwise link-based transmissions (LT). ST enable efficient multi-hop protocols with little network state.

By integrating computational and physical elements through feedback loops, CPSs implement a wide range of safety-critical applications, from high-confidence medical systems to critical infrastructure control. Deployed systems must therefore provide highly dependable operation against unpredictable real-world dynamics. However, common CPS hardware-comprising battery-powered and severely resource-constrained devices interconnected via low-power wireless-greatly complicates attaining the required communication guarantees. VIRTUS fills this gap by providing atomic multicast and view management atop resource-constrained devices, which together provide virtually synchronous executions that developers can leverage to apply established concepts from the dependable distributed systems literature. We build VIRTUS upon an existing best-effort communication layer, and formally prove the functional correctness of our mechanisms. We further show, through extensive real-world experiments, that VIRTUS incurs a limited performance penalty compared with best-effort communication. To the best of our knowledge, VIRTUS is the first system to provide virtual synchrony guarantees atop resource-constrained CPS hardware.

The industrial adoption of wireless sensor networks (WSNs) is hampered by two main factors. First, there is a lack of integration of WSNs with business process modeling languages and back-ends. Second, programming WSNs is still challenging as it is mainly performed at the operating system level. To this end, we provide makeSense: a unified programming framework and a compilation chain that, from high-level business process specifications, generates code ready for deployment on WSN nodes.

We present the low-power wireless bus (LWB), a simple yet efficient communication support for low-power wireless networks. The LWB maps different communication demands onto fast Glossy network flooding, effectively turning the wireless network into a bus-like infrastructure. The LWB requires no information of the network topology, thus drastically reducing the control overhead of common solutions such as route maintenance, and natively supports many-to-many communication and mobile nodes in addition to more traditional static, one-to-many scenarios. For instance, experiments on a 90-node testbed show that on average the LWB reduces packet loss by a factor of 231 and energy consumption due to communication by a factor of 11 compared to a state-of-the-art many-to-many routing protocol.

Low-power wireless networks must leverage radio duty cycling to reduce energy consumption, but duty cycling drastically increases the risk of radio collisions, resulting in power-expensive retransmissions or data loss. We present Strawman, a contention resolution mechanism designed for low-power duty-cycled networks that experience traffic bursts. Strawman efficiently resolves network contention, mitigates the hidden terminal problem, and has zero overhead unless activated to resolve data collisions. Our testbed experiments show that Strawman instantaneously provides increased network capacity when needed, allocates the available bandwidth evenly among contenders, and increases energy efficiency in multi-hop collection networks compared to the traditionally used random backoff.

We present pTunes, a framework for runtime adaptation of low-power MAC protocol parameters. The MAC operating parameters bear great influence on the system performance, yet their optimal choice is a function of the current network state. Based on application requirements expressed as network lifetime, end-to-end latency, and end-to-end reliability, pTunes automatically determines optimized parameter values to adapt to link, topology, and traffic dynamics. To this end, we introduce a flexible modeling approach, separating protocol-dependent from protocol-independent aspects, which facilitates using pTunes with different MAC protocols, and design an efficient system support that integrates smoothly with the application. To demonstrate its effectiveness, we apply pTunes to X-MAC and LPP. In a 44-node testbed, pTunes achieves up to three-fold lifetime gains over static MAC parameters optimized for peak traffic, the latter being current - and almost unavoidable - practice in real deployments. pTunes promptly reacts to changes in traffic load and link quality, reducing packet loss by 80% during periods of controlled wireless interference. Moreover, pTunes helps the routing protocol recover quickly from critical network changes, reducing packet loss by 70% in a scenario where multiple core routing nodes fail.

We present the Low-Power Wireless Bus (LWB), a communication protocol that supports several traffic patterns and mobile nodes immersed in static infrastructures. LWB turns a multi-hop low-power wireless network into an infrastructure similar to a shared bus, where all nodes are potential receivers of all data. It achieves this by mapping all traffic demands on fast network floods, and by globally scheduling every flood. As a result, LWB inherently supports one-to-many, many-to-one, and many-to-many traffic. LWB also keeps no topology-dependent state, making it more resilient to link changes due to interference, node failures, and mobility than prior approaches. We compare the same LWB prototype on four testbeds with seven state-of-the-art protocols and show that: (i) LWB performs comparably or significantly better in many-to-one scenarios, and adapts efficiently to varying traffic loads; (ii) LWB outperforms our baselines in many-to-many scenarios, at times by orders of magnitude; (iii) external interference and node failures affect LWB's performance only marginally; (iv) LWB supports mobile nodes acting as sources, sinks, or both without performance loss.

Radio link quality estimation in Wireless Sensor Networks (WSNs) has a fundamental impact on the network performance and also affects the design of higher-layer protocols. Therefore, for about a decade, it has been attracting a vast array of research works. Reported works on link quality estimation are typically based on different assumptions, consider different scenarios, and provide radically different (and sometimes contradictory) results. This article provides a comprehensive survey on related literature, covering the characteristics of low-power links, the fundamental concepts of link quality estimation in WSNs, a taxonomy of existing link quality estimators, and their performance analysis. To the best of our knowledge, this is the first survey tackling in detail link quality estimation in WSNs. We believe our efforts will serve as a reference to orient researchers and system designers in this area.

We describe the motivation, focus, and organization of SESENA11, the 2nd International Workshop on Software Engineering for Sensor Network Applications. The workshop took place under the umbrella of ICSE 2011, the 33rd ACM/IEEE International Conference on Software Engineering, in Honolulu, Hawaii, on May 22, 2011. The aim was to attract researchers belonging to the Software Engineering (SE) and Wireless Sensor Network (WSN) communities, not only to exchange their recent research results on the topic, but also to stimulate discussion on the core open problems and define a shared research agenda. More information can be found at the workshop website: http://www.sesena.info.

HASH(0x3981018)

The Publish-Subscribe (P/S) communication paradigm fosters high decoupling among distributed components. This facilitates the design of dynamic applications, but also impacts negatively on their verification, making it difficult to reason on the overall federation of components. In addition, existing P/S infrastructures offer radically different features to the applications, e.g., in terms of message reliability. This further complicates the verification as its outcome depends on the specific guarantees provided by the underlying P/S system. Although model checking has been proposed as a tool for the verification of P/S architectures, existing solutions overlook many characteristics of the underlying communication infrastructure to avoid state explosion problems. To overcome these limitations, the Loupe domain-specific model checker adopts a different approach. The P/S infrastructure is not modeled on top of a general-purpose model checker. Instead, it is embedded within the checking engine, and the traditional P/S operations become part of the modeling language. In this paper, we describe Loupe's design and the dedicated state abstractions that enable accurate verification without incurring state explosion problems. We also illustrate our use of state-of-the-art software verification tools to assess some key functionality in Loupe's current implementation. A complete case study shows how Loupe eases the verification of P/S architectures. Finally, we quantitatively compare Loupe's performance against alternative approaches. The results indicate that Loupe is effective and efficient in enabling accurate verification of P/S architectures.

We present Squirrel, a stream-oriented programming framework for storage-centric sensor networks. The storage-centric paradigm---where storage operations prevail over communication activity---applies to scenarios such as batch data collection, delay-tolerant mobile applications, and disconnected operations in static networks. Squirrel simplifies developing such applications by decoupling data processing from storage, and by transparently handling the latter. We achieve this through: i) a modular programming abstraction, and ii) a lightweight run-time layer that efficiently allocates data to different storage areas, based on size vs. energy tradeoffs. We demonstrate Squirrel's effectiveness based on three real-world applications, each representing a different storage-centric scenario. The results show that---while relieving programmers from a significant burden---Squirrel achieves efficient utilization of storage areas, enabling energy savings independently of the storage technology.

Smart antennas are a specific type of directional antenna able to dynamically control the gain as a function of direction. This contrasts with more traditional directional antennas, where the dynamic ability is missing, and with omnidirectional antennas, which are designed to have equal gain in all directions.

Wireless sensor networks (WSNs) are envisioned for a number of application scenarios. Nevertheless, the few in-the-field experiences typically focus on the features of a specific system, and rarely report about the characteristics of the target environment, especially with respect to the behavior and performance of low-power wireless communication. The TRITon project, funded by our local administration, aims to improve safety and reduce maintenance costs of road tunnels, using a WSN-based control infrastructure. The access to real tunnels within TRITon gives us the opportunity to experimentally assess the peculiarities of this environment, hitherto not investigated in the WSN field. We report about three deployments: (i) an operational road tunnel, enabling us to assess the impact of vehicular traffic; (ii) a nonoperational tunnel, providing insights into analogous scenarios (e.g., underground mines) without vehicles; (iii) a vineyard, serving as a baseline representative of the existing literature. Our setup, replicated in each deployment, uses mainstream WSN hardware, and popular MAC and routing protocols. We analyze and compare the deployments with respect to reliability, stability, and asymmetry of links, the accuracy of link quality estimators, and the impact of these aspects on MAC and routing layers. Our analysis shows that a number of criteria commonly used in the design of WSN protocols do not hold in tunnels. Therefore, our results are useful for designing networking solutions operating efficiently in similar environments.

Wireless sensor networks (WSNs) are characterized by localized interactions. Indeed, several WSN algorithms and protocols work in a decentralized fashion by coordinating nodes within the wireless communication range, e.g., localization algorithms and MAC protocols. Nevertheless, most often these mechanisms do not address faults that may affect the way wireless neighborhoods are recognized by nodes, e.g., as in the case of data corruption. As the operation of these mechanisms is rooted in the use of topology information, these faults may be a significant detriment to correct and efficient system operation.In this paper, we argue that the above issues are particular instances of a general problem of consistent neighborhood view. We present three increasingly weaker specifications of the problem. Next, we prove the impossibility of solving the two stronger specifications, and provide an algorithm to solve the weakest specification. In addition, we implement our algorithm in a commonly used WSN network stack, and assess its performance both in simulation and in a real-world testbed. The results show that, when possible, our mechanisms efficiently solve the problem of consistent neighborhood view, providing higher-level mechanisms with a re-usable building block to leverage off.

Content-based routing (CBR) provides a powerful and flexible foundation for distributed applications. Its communication model, based on implicit addressing, fosters decoupling among the communicating components, therefore meeting the needs of many dynamic scenarios, including mobile ad hoc networks (MANETs). Unfortunately, the characteristics of the CBR model are only rarely met by available systems, which typically assume that application-level routers are organized in a tree-shaped network with a fixed topology. In this paper, we present COMAN, a protocol to organize the nodes of a MANET in a tree-shaped network able to 1) self- repair to tolerate the frequent topological reconfigurations typical of MANETs and 2) achieve this goal through repair strategies that minimize the changes that may impact the CBR layer exploiting the tree. COMAN is implemented and publicly available. Here, we report about its performance in simulated scenarios, as well as in real-world experiments. The results confirm that its characteristics enable reliable and efficient CBR on MANETs.

The paper presents a novel approach based on Bogor for the accurate verification of applications based on Publish- Subscribe infrastructures. Previous efforts adopted standard model checking techniques to verify the application behavior, but they introduce strong simplifications on the underlying infrastructure to cope with the state space explosion problem and make automatic verification feasible. Instead of building on top of existing model checkers, our proposal embeds the asynchronous communication mechanisms of Publish-Subscribe infrastructures within Bogor. This way, Publish-Subscribe primitives become part of the specification language as additional, domain-specific, constructs. Accurate models become feasible without incurring in state space explosion problems, thus enabling the automated verification of applications on top of realistic communication infrastructures.

Wireless sensor networks are increasingly employed to develop sophisticated applications where heterogeneous nodes are deployed, and multiple parallel activities must be performed. Therefore, application developers require the ability to partition the system based on the node characteristics, and specify complex interactions among different partitions. Existing programming abstractions for sensor networks tackled this problem by providing a notion of scoping. However, this rarely emerges as a first-class programming construct, hence limiting its applicability. To address this issue, in this paper we present a flexible notion of scoping in the context of a sensor network macroprogramming framework. Our approach enables the specification of complex interactions among system partitions, thus greatly simplifying the development process. Moreover, this is not detrimental to performance: our approach results reasonably close to an optimal solution computed with global system knowledge, while exhibiting a 70% gain w.r.t. baseline solutions.

Due to the inherent nature of their heterogeneity, resource scarcity and dynamism, the provision of middleware for future networked embedded environments is a challenging task. In this paper we present a middleware approach that addresses these key challenges; we also discuss its application in a realistic networked embedded environment. Our application scenario involves fire management in a road tunnel that is instrumented with networked sensor and actuator devices. These devices are able to reconfigure their behaviour and their information dissemination strategies as they become damaged under emergency conditions, and firefighters are able to coordinate their operations and manage sensors and actuators through dynamic reprogramming. Our supporting middleware is based on a two-level architecture: the foundation is a language-independent, component-based programming model that is sufficiently minimal to run on any of the devices typically found in networked embedded environments. Above this is a layer of software components that offer the necessary middleware functionality. Rather than providing a monolithic middleware 'layer', we separate orthogonal areas of middleware functionality into self-contained components that can be selectively and individually deployed according to current resource constraints and application needs. Crucially, the set of such components can be updated at runtime to provide the basis of a highly dynamic and reconfigurable system

Wireless sensor networks (WSNs) involving actuation are increasingly envisioned in a range of fields. For instance, there is considerable interest in leveraging off WSNs to improve safety in road tunnels [3]. Researchers are envisioning tunnels equipped with WSN nodes that gather physical readings (e.g., light), monitor the structural integrity of the tunnel, and sense the presence of vehicles to detect a possible traffic congestion. Based on sensed data, the system operates a variety of devices, such as ventilation fans inside the tunnel, and traffic lights at the entrances. For instance, when a sensor detects the presence of a fire in a sector, the fans in the same sector are activated, and the traffic lights are turned red to prevent further vehicles from entering the tunnel.

Next generation embedded systems will be composed of large numbers of heterogeneous devices. These will typically be resource-constrained, will use different operating systems, and will be connected through different types of network interfaces. Additionally, they may be mobile and/or form ad-hoc networks with their peers, and will need to be adaptive to changing conditions based on context-awareness. As an example of these system we consider disaster recovery scenarios where large numbers of different devices need to interconnect in an ad-hoc manner. In this respect, our goal is the provisioning of a middleware framework for such system environments. Our approach is based on a small and efficient middleware kernel supporting highly modularised and customisable component-based middleware services. These services can be tailored for specific embedded environments, and are runtime-reconfigurable to support adaptivity. This paper describes a demonstration that highlights some of the features available in our middleware. In particular, we focus on heterogeneity handling by showing our middleware running on resource-rich as well as resource-constrained devices, and on adaptivity features by demonstrating runtime reprogramming and on-the-fly component deployment