Satellites, high-altitude drones, and 5 G links in space now support critical services such as air traffic control, financial transactions, and weather alerts. However, most of this equipment was not originally designed to face modern cyber threats. Ground stations connected to the cloud can be breached, GPS signals can be jammed, and some components in the supply chain may include hidden malware. There is still no shared list of known vulnerabilities and no secure environment for testing spacerelated cyber defense. This paper identifies eleven key research gaps. These include secure routing, onboard attack detection, automated recovery, trusted supply chains, post-quantum encryption, zero-trust implementation, and real-time service impact monitoring. For each topic, we describe the challenge, explain why it matters, and propose a guiding research question. We also explore how a team of small, task-specific artificial intelligence agents, what we call an agentic (multi-agent) approach, could improve onboard defense without relying on large hardware.The paper ends with a proposed five-year roadmap. This includes flight tests of post-quantum and quantum key distribution (QKD) links, open-access cyber-ranges for practical testing, better rules for sharing vulnerabilities, and initial deployments of multi-agent security on operational spacecraft. Moving toward these proactive, modular defenses will help prevent outages like the KA-SAT incident.

In this paper, we explore the field of self-reconfigurable modular robots, representing a significant advance in robotic technology. These robots have many capabilities, offering high adaptability and flexibility for a variety of applications. However, computing the stability is challenging as it is computationally intensive, it needs to be distributed and fast, as close as possible of real-time. In this article, we introduce a distributed algorithm designed to overcome these challenges while taking mechanical constraints into account. At the heart of this algorithm is the notion of the "support polygon", which enables the stability of a modular robot to be assessed in real time. The algorithm is based on a fully distributed tree partitioning approach, facilitating efficient communication and collaboration between modules. The algorithm also uses a polygon merging approach to reduce the number of messages when creating the polygon support, thus significantly reducing response time. In fact, the response time of the method used is very small compared to other research. We also present simulation results on a simulator, VisibleSim, as well as experimental validation on real robotic modules, which underlines the practical viability of the approach. Overall, this work lays a solid base for further advances aiming to guarantee the stability of modular robots.

Localizing each module in a modular self-reconfigurable robot (MSR) is of paramount importance. In MSR, the communication graph is directly mapped to the real topology which makes the localization problem easy to solve. However, some types of connectors can lose the orientation of the modules, making the problem intractable. In this work, we propose to build a coordinate system for 3D lattice-based modular robots using a multiagent system. We present DisCo algorithm, that uses one agent per module which can only communicate with its connected neighbors and that does not need a central coordination system. We show that the agents can tackle any kinds of 3D lattice and we illustrate it with a Face Centered Cubic lattice (12 neighbors) and a cubic lattice (6 neighbors). Using communications and only four states, DisCo can also deduce the orientation of modules if the connectors do not provide this information.

Modular robots are defined as autonomous kinematic machines with variable morphology. They are composed of several thousands or even millions of modules that are able to coordinate to behave intelligently. Clustering the modules in modular robots has many benefits, including scalability, energy-efficiency, reducing communication delay, and improving the self-reconfiguration process that focuses on finding a sequence of reconfiguration actions to convert robots from an initial shape to a goal one. The main idea of clustering is to divide the modules in an initial shape into a number of groups based on the final goal shape to enhance the self-reconfiguration process by allowing clusters to reconfigure in parallel. In this work, we prove that the size-constrained clustering problem is NP-complete, and we propose a new tree-based size-constrained clustering algorithm called “SC-Clust.” To show the efficiency of our approach, we implement and demonstrate our algorithm in simulation on networks of up to 30000 modules and on the Blinky Blocks hardware with up to 144 modules.

In this paper, we propose a new self-reconfiguration scheme for modular robots based on a metamodule design that allows to form a 3D porous structure. The porous structure enables a parallel flow of modules inside it without blocking. The metamodule can also be used to fill its internal volume with an additional number of modules allowing the structure to be compressible and expandable. Hence, it is a potential for improving the self-reconfiguration process. We first present the metamodule model and the porous structure built using it. Then, we describe an algorithm to self-reconfigure the structure from an initial shape to a given goal shape. We evaluated the algorithm in simulation on structures composed of up to 2,700 modules. We studied the performance in term of parallelism, showed that the number of communications is proportional to the number of motions and the execution time varies linearly with the diameter of the configuration.

A Modular Self-Reconfigurable Robot (MSR) is an Internet of Robotic Things object (IoRT) composed of an ensemble of independent communicating robotic modules that can self-reconfigure to change their initial shape into a goal one. Self-reconfiguration is known to be an intricate and complex task and faults such as broken connections, loss of power, incomplete motions … are likely to occur during the self-reconfiguration process. However, existing work on self-reconfiguration considers fault-free robotic modules and does not apply any fault-tolerance mechanisms. In this paper, we propose a fault-tolerance mechanism that can be applied to a broken interface which results in communication failures in the context of the self-reconfiguration of a 3D Catom robot using the deterministic scaffold assembly algorithm. We introduce a new module role: the Helper module. The Helper module serves as a communication bridge between two modules attached by a broken interface. We showed in simulation the efficiency of our approach dealing with communication failures caused by broken interfaces.

Shape-changing User Interfaces (UIs) explore the ability of a UI to change its physical shape to support multiple interaction modalities for users’ input and/or system’s output. An approach currently studied to implement such interfaces at a high resolution is based on mm-sized, round, and self-actuated modules. The problem we tackle in this paper is to find the range of usable sizes of such modules, to better inform the trade-off between usability and technological feasibility. We assessed four sliders in a controlled user study: a standard slider and three sliders made of mock-up rounded modules of 1 mm, 2.5 mm, and 5 mm. Experimental results show that (1) 5 mm modules significantly impair performance for the pursuit task and subjective perception for both tasks, (2) performance increases when the size of modules decreases, but (3) users reportedly enjoyed the haptic feedback provided by 1 mm to 2.5 mm modules. These results provide deeper understanding on the impact of the size of modules on performance and subjective perception to inform current technological development of physical user interfaces made of small robotic modules.

Programmable matter is a material that can change its physical properties at will, whether it is its shape, density or conductivity. It can be implemented as an ensemble of micro-robots arranged in space to form a specific shape and having their own computing power. This technology behaves as a distributed system. Each micro-robot is called a module and the whole forms a modular robot. This paper tackles the self-reconfiguration problem by presenting a deterministic planning algorithm that can decide which positions can be filled over multiple iterations using virtual forces. The proposed algorithm implements the Hungarian method to optimize the planning by minimizing the total number of movements of the robots and preventing positions from being blocked. Each module embeds the same algorithm and coordinates with the others using neighbor-to-neighbor communications. Simulation results are conducted to show the effectiveness of the proposed approach.

As in all distributed systems, having an accurate access to a global notion of time is vital for a modular robot's modules to coordinate their activities and accomplish their goal. In this paper, we present and compare two methods for clock skew compensation to enhance the performance of network-wide time synchronization in modular robots with neighbor-to-neighbor communication. The first one, Adaptive Rate Search (ARS), uses a light weight adaptive search method to adapt the drift rate of local clocks. The second one, combines Linear Regression with Bayes estimation (LR+) to reduce the accumu-lative error induced during the propagation of synchronization messages on large number of hops. We evaluate both methods with Blinky Block robots: using a real modular robots system and simulation. The results show that both methods LR+ and ARS present a significant error reduction compared to least-square linear regression used in previous state of the art synchronization protocol for modular robots with neighbor-to-neighbor communication.

Shape-changing User Interfaces attract growing interest in Human-Computer Interaction. Modular robotics offer a great opportunity for their implementation. However, the current theoretical and technical advances of modular robotics are fragmented and little centered on the user. To unify existing work and center future research on the user, we perform a systematic literature review enabling us to build a unifying space for the design of modular shape-changing user interfaces.Our aim is to bridge the gap between HCI and robotics. We relate properties of different domains and identify inconsistencies to structure the design space. Towards this aim, we conduct a thorough cross-disciplinary survey to propose: 1) a set of design properties at the scale of the interface (macro-scale) and at the scale of the modules (micro-scale) and 2) the impact of these properties on each other. This paper can be used to describe and compare existing modular shape-changing UIs and generate new design ideas by building upon knowledge from robotics and HCI.

The vision for programmable matter is to create a material that can be reprogrammed to have different shapes and to change its physical properties on demand. They are autonomous systems composed of a huge number of independent connected elements called particles. The connections to one another form the overall shape of the system. These particles are capable of interacting with each other and take decisions based on their environment. Beyond sensing, processing, and communication capabilities, programmable matter includes actuation and motion capabilities. It could be deployed in different domains and will constitute an intelligent component of the IoT. A lot of applications can derive from this technology, such as medical or industrial applications. However, just like any other technology, security is a huge concern. Given its distributed architecture and its processing limitations, programmable matter cannot handle the traditional security protocols and encryption algorithms. This article proposes a new security protocol optimized and dedicated for IoT programmable matter. This protocol is based on lightweight cryptography and uses the same encryption protocol as a hashing function while keeping the distributed architecture in mind. The analysis and simulation results show the efficiency of the proposed method and that a supercomputer will need about 5.93 × 10 25 years to decrypt the message.

We present a distributed framework for predicting whether a planned reconfiguration step of a modular robot will mechanically overload the structure, causing it to break or lose stability under its own weight. The algorithm is executed by the modular robot itself and based on a distributed iterative solution of mechanical equilibrium equations derived from a simplified model of the robot. The model treats intermodular connections as beams and assumes no-sliding contact between the modules and the ground. We also provide a procedure for simplified instability detection. The algorithm is verified in the Programmable Matter simulatorVisibleSim, and in real-life experiments on the modular robotic systemBlinky Blocks.

Modular robots are defined as autonomous kinematic machines with variable morphology. They are composed of several thousands or even millions of modules which are able to coordinate in order to behave intelligently. Clustering the modules in modular robots has many benefits, including scalability, energy-efficiency, reducing communication delay and improving the self-configuration processes that focuses on finding a sequence of reconfiguration actions to convert robots from an initial configuration to a goal one. The main idea is to divide the nodes in an initial shape into some clusters based on the final goal shape in order to reduce the time complexity and enhance the self-reconfiguration tasks. In this paper, we propose a robust clustering approach based on a distributed density-cut graph algorithm to divide the networks into a pre-defined number of clusters based on the final goal shape. The result is an algorithm with linear complexity that scales to large modular robot systems. We implement and demonstrate our algorithm on a real Blinky Blocks system and evaluate it in simulation on networks of up to 30,000 modules.

This paper addresses the self-reconfiguration problem in large-scale modular robots for the purpose of shape formation for object representation. It aims to show that this process can be accelerated without compromising on the visual aspect of the final object, by creating an internal skeleton of the shape using the previously introduced sandboxing and scaffolding techniques, and then coating this skeleton with a layer of modules for higher visual fidelity. We discuss the challenges of the coating problem, introduce a basic method for constructing the coating of a scaffold layer by layer, and show that even with a straightforward algorithm, our scaffolding and coating combo uses much fewer modules than dense shapes and offers attractive reconfiguration times. Finally, we show that it could be a strong alternative to the construction of dense shapes using traditional self-reconfiguration algorithms.

Distributed self-reconfiguration in large-scale modular robots is a slow process and increasing its speed a major challenge. In this article, we propose an improved and asynchronous version of a previously proposed distributed self-reconfiguration algorithm to build a parametric scaffolding structure. This scaffold can then be coated to form the desired final object. The scaffolding is built through a continuous feeding of modules into the growing shape from an underneath reserve of modules which shows a reconfiguration time improved by a factor of 3√N compared to the previous and synchronous version of the algorithm, therefore attaining an O(N1/3) reconfiguration time, with N the number of modules in the system. Our algorithm uses a local motion coordination algorithm and pipelining techniques to ensure that modules can traverse the structure without collisions or creating deadlocks. Last but not least, our algorithm manages uncertainty in the motion duration of modules without negatively impacting reconfiguration time.

Among the diversity of the existing modular robotic systems, we consider in this paper the subset of distributed modular robotic ensembles composed of resource-constrained identical modules that are organized in a lattice structure and which can only communicate with neighboring modules. These modular robotic ensembles form asynchronous distributed embedded systems. In many algorithms dedicated to distributed system coordination, a specific role has to be played by a leader, i.e., a single node in the system. This leader can be elected using various criteria. A possible strategy is to elect a center node, i.e., a node that has the minimum distance to all the other nodes. Indeed, this node is ideally located to communicate with all the others and this leads to better performance in many algorithms. The contribution of this paper is to propose the k-BFS SumSweep algorithm designed to elect an approximate-center node. We evaluated our algorithm both on hardware modular robots and in a simulator for large ensembles of robots. Experimental results show that k-BFS SumSweep is often the most accurate approximation algorithm (with an average relative accuracy between 90% to 100%) while using the fewest messages in large-scale systems, requiring only a modest amount of memory per node, and converging in a reasonable length of time.

Many distributed algorithms require a specific role to be played by a leader, a single node in the system. The choice of this node often has a direct impact on the performance. In particular, selecting a central node as the leader can significantly improve algorithm efficiency. Classical distributed algorithms require global information about the connectivity network to elect a centroid node. Thus, they are not suitable for large-scale distributed embedded systems with scarce computation, memory and energy resources. We present E2ACE, an Effective and Efficient Approximate-Centroid Election algorithm that uses O(1) memory space per node, O(d) time and O(mn^2) messages of size O(1), where n is the number of nodes, m the number of connections and d the diameter of the system. We evaluate our algorithm on the Blinky Blocks system using simulations. Experimental results show that E2ACE scales well in terms of accuracy, execution time and number of messages. We show that E2ACE is more accurate than the only existing algorithm with similar complexity results.

Modular self-reconfigurable robots are composed of independent connected modules which can self-rearrange their connectivity using processing, communication and motion capabilities, in order to change the overall robot structure. In this paper, we consider rolling cylindrical modules arranged in a two-dimensional vertical hexagonal lattice. We propose a parallel, asynchronous and fully decentralized distributed algorithm to self-reconfigure robots from an initial configuration to a goal one. We evaluate our algorithm on the millimeter-scale cylindrical robots, developed in the Claytronics project, through simulation of large ensembles composed of up to ten thousand modules. We show the effectiveness of our algorithm and study its performance in terms of communications, movements and execution time. Our observations indicate that the number of communications, the number of movements and the execution time of our algorithm is highly predictable. Furthermore, we observe execution times that are linear in the size of the goal shape.

In this paper, we propose the Modular Robot Time Protocol (MRTP), a network-wide time synchronization protocol for modular robots. Our protocol achieves its performance by combining several mechanisms: central time master election, low-level time-stamping and clock skew compensation using linear regression. We evaluate our protocol on the Blinky Blocks hardware. Experimental results show that MRTP can potentially manage real systems composed of up to 27,775 Blinky Blocks. We observe that the synchronization precision depends on the hardware, the hop distance to the time master, the synchronization periods and the number of synchronization points used for the linear regressions. Furthermore, we show that our protocol is able to keep a Blinky Blocks system synchronized to a few milliseconds, using few network resources at runtime, even-though the Blinky Blocks hardware clocks exhibit very poor accuracy and resolution.

A modular robots is composed of many independent connected modules which are able to achieve common goals through communications. A modular self-reconfigurable robot can move and reorganize its modules to modify its shape. In this paper, we consider a modular self-reconfigurable robot made from cubic modules (blocks) that are able to slide along their faces. Sliding motions imply complex cooperations, for example, crossing an angle needs at least three synchronized blocks. Based on this kind of hardware, we propose a distributed rule-based algorithm which plans and moves the blocks to reach a final configuration. We propose the use of motion rules that drastically simplify the complexity of the sliding movements and we define a special kind of metamodule to fasten the reconfiguration. We evaluate our algorithm in a simulator in order to study its behavior in the case of large modular robots composed of more than 10,000 modules. We test its robustness with more than 120 different kinds reconfigurations scenarii, representing more than 338 millions of movements for the blocks without any problem.

Programmable matter i.e. matter that can change its physical properties, more likely its shape according to an internal or an external action is a good example of a cybermatics component. As it links a cyberized shape to real matter, it is a straight example of cyber-physical conjugation. But, this interaction between virtual and real worlds needs two elements. The first one is to find a way to represent the cyberized object using programmable matter and the second is to be able to adapt the matter to the cyberized changes. This article presents the progresses made in these two topics within the Claytronics project.

Modular robots are composed of many independent connected modules which are able to achieve common goals through communications. Many distributed algorithms have better performance if the modules that have to communicate with all the others, are placed at the center of the system. In this paper, we propose ABC-Center, an iterative algorithm for electing an approximate-center module in modular robots. ABC-Center uses O(1) space per module and O(kd) time, where k is the number of iterations required to terminate and d the diameter of the system. We evaluated our algorithm both on hardware modular robots and in a simulator for large ensemble of robots. The average expected eccentricity of the module elected by ABC-Center is less than 1.25 blocks off for random systems composed of up to 1000 modules. Furthermore, experiments show that our algorithm terminates after a few iterations. Hence, ABC-Center is scalable and adapted to modular robots with low memory resources.

Over the last decades, research on microelectromechanical systems (MEMS) has focused on the engineering process which has led to major advances. Future challenges will consist in adding embedded intelligence to MEMS systems to obtain distributed intelligent MEMS. One intrinsic characteristic of MEMS is their ability to be mass-produced. This, however, poses scalability problems because a significant number of MEMS can be placed in a small volume. Managing this scalability requires paradigm-shifts both in hardware and software parts. Furthermore, the need for actuated synchronization, programming, communication and mobility management raises new challenges in both control and programming. Finally, MEMS are prone to faulty behaviors as they are mechanical systems and they are issued from a batch fabrication process. A new programming paradigm which can meet these challenges is therefore needed. In this article, we present CO2Dim, which stands for Coordination and Computation in Distributed Intelligent MEMS. CO2DIM is a common project between France and Hong-Kong building a new programming environment which includes a language, based on a joint development of programming and control capabilities, a simulator and real hardware.

This paper presents the architecture of a multimedia sensor network, especially dedicated to video surveillance. The founding ideas of our architecture are: (a) continuous 3D real-time reconstruction of the monitored area in which streams originated form video sensors are merged. (b) locating parts of data analysis/extraction tasks on the sensors themselves in a way to reduce drastically the network bandwidth usage, traditionally consumed by video stream. Hence video sensors perform in addition to capturing tasks, data analysis and extraction of features needed for the 3D reconstruction. We validated our approach through real experimentations, in particular on the video sensor.