💻 computer science

Scalable Surface-Based Manipulation Through Modularity and Inter-Module Object Transfer

This paper presents a scalable, modular robotic manipulation platform that overcomes the tradeoff between control precision and system size by employing shared-boundary actuation and a hierarchical control framework to achieve precise, coordinated inter-module object transfer of fragile items while systematically characterizing and compensating for mechanical coupling interference.

Original authors: Pratik Ingle, Jørn Lambertsen, Kasper Støy, Andres Faina

Published 2026-03-13

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Pratik Ingle, Jørn Lambertsen, Kasper Støy, Andres Faina

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to move a delicate egg and a heavy apple across a long table without picking them up. If you use a standard robot arm, you have to grab the egg, move it, put it down, then grab the apple. It's slow, and you might accidentally crush the egg. If you use a conveyor belt, you can move many things at once, but you can only move them in one direction, like a river flowing downstream. You can't steer the apple to the left or the egg to the right.

This paper introduces a clever solution: A "Magic Trampoline" Table.

Instead of grabbing objects, this robot table is covered in a soft, stretchy fabric. Underneath the fabric are motors (actuators) that can push the fabric up or pull it down. By tilting the fabric, the robot creates a gentle slope, causing the egg or apple to roll or slide exactly where it needs to go. It's like a human hand gently tilting a tray to slide a cookie across it, but the tray is made of stretchy cloth and controlled by a computer.

The Big Problem: Scaling Up

The researchers had a great single-table design (called MANTA-RAY), but it was small (about 2 feet by 2 feet). To make it useful for a warehouse or a factory, they needed to make it huge.

If they just glued four of these small tables together, they would need 16 motors (4 for each table). That's expensive, heavy, and complicated. It's like trying to build a giant wall by stacking four separate brick towers; you end up with too much mortar and not enough wall.

The Smart Solution: Sharing the "Muscles"

The team came up with a brilliant idea: Share the muscles.

Imagine four friends standing in a square, each holding a corner of a large blanket.

Old Way: Each friend holds their own four ropes. Total ropes = 16.
New Way: The friends stand closer together and share the ropes in the middle. The friend in the top-left and the friend in the top-right both hold the same rope in the middle.

By sharing the ropes (motors) on the edges where the tables meet, they built a 2x2 grid using only 9 motors instead of 16. This is a huge saving (44% fewer motors!), and it scales beautifully. If you made a 10x10 grid, you'd save even more.

The Challenge: The "Butterfly Effect"

Here is the tricky part. Because the motors are shared, when you move an object on the left table, the shared motor moves, which accidentally wiggles the table on the right.

Think of it like a mattress. If you and your partner are sleeping on a mattress with a shared spring in the middle, and you roll over to the left, your partner might roll to the right because the mattress tilted. In a robot factory, if you roll an apple to the left, you don't want a fragile egg on the next table to accidentally roll off the edge.

How They Fixed It

The researchers solved this with two main tricks:

The Traffic Cop (Path Planning): They programmed the robot to be a strict traffic cop. It plans routes so that two objects never try to use the same "lane" (module) at the same time. This prevents a traffic jam.
The Counter-Balance (Compensation): When the robot needs to tilt the left table to move an apple, it knows this will wiggle the right table. So, it secretly adjusts the other motors on the right table to push back up, keeping the right table flat. It's like a tightrope walker using a balancing pole; if they lean left, they shift the pole right to stay steady.

What They Found

It Works: They tested it with eggs, apples, dice, and cylinders. They could move an egg from one side of the 1-meter table to the other with incredible precision (within a centimeter).
Shape Matters: Round things (like eggs) roll easily but are sensitive to tiny bumps. Flat things (like a puck) slide well but, once they start sliding, they don't stop easily. The robot learned to treat them differently.
The Fix Works: Without the "counter-balance" trick, a stationary object on a neighbor's table would move wildly (sometimes falling off). With the trick, that movement was reduced by 59% to 78%.

Why This Matters

This technology is a game-changer for places like food processing (moving eggs, fruits, and bread without bruising them) and logistics (sorting packages). It allows robots to handle many fragile items at once, safely and efficiently, without needing a complex, expensive army of robot arms.

In short, they built a smart, stretchy table that can move many objects at once by sharing its motors and balancing itself, solving the problem of how to make soft robots big enough to be useful in the real world.

1. Problem Statement

Robotic Manipulation Surfaces (RMS) offer a safe, parallel method for handling diverse and fragile objects by deforming the surface they rest on, rather than grasping them. However, existing RMS designs face a fundamental trade-off:

Scalability vs. Control: Achieving fine-grained control typically requires dense arrays of actuators (e.g., 256 actuators for a 16×16 grid), which makes scaling to large workspaces mechanically complex and expensive.
Modularity Challenges: While modular architectures can extend workspace size, reliably transferring objects across module boundaries on soft, continuously deformable surfaces remains an open challenge.
Mechanical Coupling: Extending single-module designs (like MANTA-RAY) to multiple modules naively reintroduces high actuator density. Conversely, sharing actuators between modules to save hardware introduces mechanical coupling, where manipulating an object on one module unintentionally displaces objects on neighboring modules.

2. Methodology

A. Hardware Architecture: Shared-Boundary Modularity

The authors propose a multi-modular platform that scales efficiently by sharing actuators between adjacent modules.

Architecture: Instead of $4n^2$ $4 n^{2}$ actuators for an $n \times n$ $n \times n$ grid of independent modules, the system uses a shared-boundary grid requiring only $(n + 1)^2$ actuators.
- Example: A $2 \times 2$ prototype covers a $1 \times 1$ m workspace using only 9 actuators (a 44% reduction compared to 16 independent actuators).
Physical Implementation:
- Actuators: Nine linear actuators (stepper motors with pulley-belt mechanisms) arranged in a $3 \times 3$ grid.
- Surface: A $1.2 \times 1.2$ m sheet of 100% polyester fabric draped over the actuators.
- Control: Each actuator is controlled by an Arduino Uno with real-time feedback from AS5600 magnetic encoders.
- Sensing: Object tracking is performed via a 6-camera OptiTrack system (up to 120 Hz).

B. Hierarchical Control Framework

The system employs a two-layer control strategy to manage object motion without learning-based methods:

High-Level: Conflict-Free Manhattan Path Planning
- Determines the sequence of modules an object must traverse to reach a target.
- Ensures conflict-free paths for multi-object manipulation, guaranteeing that simultaneously manipulated objects do not occupy the same module, thereby preventing collisions.
Low-Level: Directional Passing & Geometric PID Control
- Inter-Module Transfer: Objects are moved between modules by creating temporary local slopes. The controller selectively raises specific actuators (exclusive or shared) to induce rolling or sliding.
  - Directional Control: By raising inner vs. outer shared actuators, the system can steer objects along Left, Center, or Right paths relative to the module boundary.
- Intra-Module Positioning: Once an object is within a target module, a geometric PID controller adjusts the four supporting actuators to create a surface normal vector that guides the object to the precise $(x, y)$ target.
- Friction Mitigation: Small random noise is added to actuator commands to break static friction.

C. Interference Compensation Strategy

To address the mechanical coupling caused by shared actuators, the authors propose a stabilization strategy:

When an active module manipulates an object, the shared actuators tilt the surface of the neighboring (passive) module, potentially displacing stationary objects.
Solution: The non-shared actuators of the passive module are raised to create a "counter-tilt," maintaining a locally level surface and neutralizing the disturbance.

3. Key Contributions

Scalable Hardware Design: A shared-boundary architecture that reduces actuator count from $4n^2$ to $(n+1)^2$ , enabling large workspaces with minimal hardware.
Hierarchical Control Framework: A novel system combining Manhattan-based path planning with directional object passing and geometric PID control, enabling reliable transfer of heterogeneous objects across soft, deformable surfaces.
Systematic Characterization of Coupling: A comprehensive experimental study quantifying how shared actuators cause interference in neighboring modules and proposing compensation strategies that significantly reduce passive displacement.

4. Experimental Results

A. Object Passing and Target Reaching

Heterogeneous Objects: The system successfully manipulated seven distinct objects (including fragile eggs, apples, dice, and spheres) with varying shapes, weights, and friction properties.
Transfer Reliability: Objects were successfully transferred between modules (M0 $\to$ M2 and back) with a mean positional deviation of < 0.03 m.
Precision: The system achieved sub-centimeter positioning accuracy (mean error < 0.02 m) for target reaching.
Directional Control: The system successfully steered objects along Left, Center, and Right paths during inter-module transfer.

B. Multi-Object Manipulation

The platform demonstrated parallel manipulation of two objects (a disk and a sphere) on different modules simultaneously.
The conflict-free path planner ensured the objects never occupied the same module, maintaining synchronized motion without interference.

C. Interference and Compensation

The study quantified the displacement of stationary objects when neighbors were active:

Without Compensation: Adjacent modules caused severe displacement (e.g., a sphere drifted 0.46 m, often leaving the module).
With Compensation:
- Target Reaching: Compensation reduced passive displacement by 59–78% (e.g., sphere RMS displacement dropped from 0.217 m to 0.047 m).
- Object Passing: Compensation prevented object loss in "Opposite Passing" scenarios where objects would otherwise fall off the module.
Scaling Insight: Interference scales with the number of shared actuators (Adjacent modules share 2; Diagonal share 1). Diagonal neighbors showed minimal coupling even without compensation.

D. Simulation

MuJoCo simulations validated the approach on a $3 \times 3$ module configuration, confirming that the control strategies scale to larger grids.

5. Significance and Future Work

Impact: This work establishes a scalable foundation for soft manipulation surfaces in applications requiring high throughput and gentle handling, such as food processing (eggs, fruits) and logistics.
Novelty: It is the first demonstration of reliable inter-module object transfer on soft, deformable surfaces without relying on learning-based methods.
Future Directions:
- Building a physical $3 \times 3$ prototype.
- Implementing closed-loop control during the transfer phase (currently open-loop timed).
- Integrating embedded sensing to replace external motion capture.
- Developing object-aware policies to handle orientation control for high-aspect-ratio objects.

In conclusion, the paper successfully decouples manipulation capability from actuator complexity through a shared-boundary modular design, proving that large-scale, safe, and precise soft manipulation is achievable through coordinated control and mechanical compensation.