Physical reservoir computing with origami and its application to robotic crawling

Abstract

A new paradigm called physical reservoir computing has recently emerged, where the nonlinear dynamics of high-dimensional and fixed physical systems are harnessed as a computational resource to achieve complex tasks. Via extensive simulations based on a dynamic truss-frame model, this study shows that an origami structure can perform as a dynamic reservoir with sufficient computing power to emulate high-order nonlinear systems, generate stable limit cycles, and modulate outputs according to dynamic inputs. This study also uncovers the linkages between the origami reservoir’s physical designs and its computing power, offering a guideline to optimize the computing performance. Comprehensive parametric studies show that selecting optimal feedback crease distribution and fine-tuning the underlying origami folding designs are the most effective approach to improve computing performance. Furthermore, this study shows how origami’s physical reservoir computing power can apply to soft robotic control problems by a case study of earthworm-like peristaltic crawling without traditional controllers. These results can pave the way for origami-based robots with embodied mechanical intelligence.

Introduction

The animal kingdom is an endless source of inspiration for soft robotics^1,2. Researchers have constructed compliant robots that can mimic all kinds of animal motions, like octopus locomotion³, elephant trunk grasping⁴, insect flying⁵, jellyfish and fish swimming^6,7,8, as well as snake and insects crawling^9,10,11. These robots share many similarities with animals regarding their shape and motion kinematics; however, their underlying sensing, actuation, and control architectures could be fundamentally different. Our engineered soft robots typically rely on a centralized controller (aka. an “electronic brain”) that takes up all computing work to process sensor information, generate control commands, and make decisions. This approach often struggles to achieve high actuation speed and control effectiveness as soft robots exhibit virtually infinite degrees of freedom and complicated dynamic characteristics. On the other hand, animals have highly interconnected networks of nerves and muscles that can share the workload with the brain^12,13,14. The animal body’s morphology is an integral part of its actuation, control, and ultimately its “brain’s” decision-making process, leading to far superior efficiency than our engineered soft robots.

Motivated by this disparity, an increasing number of researchers have embraced soft bodies’ nonlinear dynamics as a computational resource to create an embodied intelligence and control^{15,16,17,18,19,20,21}. As a result, a new computational paradigm called morphological computation has emerged in which the physical body of the robot itself takes part in performing low-level control tasks, such as locomotion coordination and modulation, to simplify the overall control architecture significantly^{15,16,17,18,22}. The contributions of body morphology to cognition and control involve three major categories²⁰: (1) Morphology facilitating control: wherein the physical design enables certain behaviors such as motion sequencing (e.g., passive dynamic walker²³). (2) Morphology facilitating perception: wherein the physical design enables sensing (e.g., the nonuniform distribution of cells in the compound eyes of fly²⁴). (3) Morphological computation, such as the physical reservoir computing (PRC), wherein a physical body performs genuine computations. Among these, physical reservoir computing shows promising potentials because of its balanced simplicity and versatility to perform applicable computation with encoding and decoding²⁰.

Reservoir computing is a computational framework based on artificial recurrent neural networks (RNNs), which have been used extensively for problems involving time-series prediction like the stock market and weather forecasting, robotic motion planning and control, text and speech recognition^{21,25,26,27,28,29,30,31}. In RNNs, the output of the current time step depends on the results from the previous time step in addition to the current input. Since RNNs involve both forward and back-propagation of input data, training them became a challenging task. To address this difficulty, Jaeger introduced the concept of a fixed recurrent neural network as Echo State Networks (ESNs)²⁵, and Maass introduced Liquid State Machines (LSMs)²⁶. Later, these two concepts merged under the umbrella of reservoir computing (RC). In RC, the neural network (aka. the “reservoir”) has fixed interconnections and input weights, and only the linear output readout weights are trained by simple techniques such as, linear or ridge regression. The reservoir’s dynamics transforms the input data stream into a high-dimensional state space, capturing its nonlinearities and time-dependent information for computation tasks.

More importantly, the reservoir’s fixed nature opens up the possibility of using physical bodies—such as a random network of nonlinear spring and mass oscillators^18,32,33, tensegrity structures^15,16,17,34, and soft robotic arms^19,35,36—to conduct computation, hence the paradigm of Physical Reservoir Computing. These physical systems have been shown to possess sufficient computational power to achieve complex computing tasks e.g. emulating other nonlinear dynamic systems, pattern generation^{17,18,19,21,32,34}, speech recognition³⁷, and machine learning^21,31,33,36. More importantly, robotic bodies with sufficient nonlinear dynamics can also perform like a physical reservoir and directly generate locomotion gait without using the traditional controllers^{17,21,38,39,40}. Despite the recent progress, physical reservoir computing is still a nascent field, and it is worthwhile to examine the computing power of a wide variety of different compliant mechanical systems, especially those with broad application potential in soft robotic locomotion and intelligent structures. These dynamic physical reservoirs with embedded feedback can function as soft robotic skeletons, and simultaneously generate and maintain the periodic trajectories essential for animal-inspired locomotion gait generation.

One such compliant mechanism that has garnered much attention over recent years is Origami – a traditional play of folding paper into sophisticated and three-dimensional shapes. Origami mechanisms are compact, easy to fabricate, and scale-independent (aka. Origami robots can be fabricated at different scales but still follow similar folding principles^41,42,43,44). Origami mechanisms with complex crease folding patterns and integrated actuator-sensor network exhibit many desirable soft body properties. Similar to the soft and compliant biological systems, origami features non-linear kinematics and dynamics, non-linearly varying stiffness, large deformation range, compliance, and shape-morphing capability. The origami mechanisms are stiff enough to be used as structural skeleton for robots, and at the same time are compliant enough to provide large deformation range required for soft robotic locomotion. Over the past decades, origami has evolved into an engineering framework for constructing multi-transformable deployable structures^44,45,46,47, advanced meta-materials and shape morphing structures^{41,43,48,49,50,51,52,53}. It is already a popular engineering platform for constructing soft robotic skeletons that mimic wide range of animal motions, e.g. worm-like crawling, insect-like walking, and octopus arm-inspired manipulation^{9,42,54,55,56,57,58,59,60,61,62,63}. Moreover, the nonlinear mechanics and dynamics induced by folding could also enhance robotic performance^64,65,66. Thus, we investigate the use of origami as a physical reservoir and show that origami based robotic skeleton can indeed generate the periodic patterns for autonomous locomotion gait generation.

We show that origami’s nonlinear folding dynamics possesses significant computing power, which could add a valuable dimension to the field of origami-based engineering. A mechanical system must exhibit several essential properties to perform as a reservoir²¹. The first one is high-dimensionality, which allows the reservoir to gather as much information possible from the input data stream, separating its spatio-temporal dependencies and projecting it onto a high-dimensional state-space. The second one is nonlinearity so that the reservoir acts as a nonlinear filter to map the information from the input stream. All the computation complexity is associated with this nonlinear mapping, thus training the linear static readout becomes a straightforward task. The third one is fading memory (or short-term memory), ensuring that only the recent input history influences the current output. The fourth one is separation property to classify and segregate different response signals correctly, even with small disturbances or fluctuations. Moreover, if two input time series differed in the past, the reservoir should produce different states at subsequent time points⁶⁷. Our physics-informed numerical simulations prove that origami inherently satisfies these four requirements and can complete computation tasks like emulation, pattern generation, and output modulation.

Moreover, we conduct extensive numerical simulations to uncover the linkage between origami design and its computing power, providing the guideline to optimize computing performance. Finally, we demonstrate how to directly embed reservoir computing in an origami robotic body to generate earthworm-like peristalsis crawling without using any traditional controllers. This study’s results could foster a new family of origami-based soft robots that operate with simple mechatronics, interact with the environment through distributed sensor and actuator networks, and respond to external disturbances by modulating their activities.

Constructing the origami reservoir

In this study, we construct a physical reservoir using the classical Miura-ori sheets. We can easily modify basic Miura-ori geometry to create complex structures such as curved Miura-ori surfaces, stacked Miura-ori, or origami-tubes with various cross sections. We show that origami can indeed act as a reservoir and even simplest of origami pattern can be turned into peristaltic crawling robot powered by reservoir computing. Miura-ori is essentially a periodic tessellation of unit cells, each consisting of four identical quadrilateral facets with crease lengths a, b and an internal sector angle $\gamma$ (Fig. 1a)^48,68. The folded geometry of Miura-ori can be fully defined with a dihedral folding angle $\theta$ ($\in {[0,\pi /2]}$) between the x-y reference plane and its facets (Fig. 1b). The reservoir size is defined as $n \times m$, where n and m are the number of origami nodes (aka. vertices where crease lines meet) in x and y-directions, respectively. N is the total number of creases in the origami reservoir.

Dynamics modeling of the origami

To investigate this origami reservoir’s computing capacity, one must first obtain its time responses under dynamic excitation. To this end, we adopt and expand the lattice framework approach to simulate its nonlinear dynamics^68,69,70. In this approach, origami creases are represented by pin-jointed stretchable truss elements with prescribed spring coefficient $K_{s}$. Folding (or bending) along the crease line is simulated by assigning torsional spring coefficient $K_{b}$. We further triangulate the quadrilateral facets with additional ‘virtual’ truss elements to estimate the facet bending with additional torsional stiffness (typically, $K_{b}$ across the facets is larger than those along the creases). The rationale behind adding these ‘virtual’ facet bending creases can be explained with the example of Miura-ori structure. The ideal Miura-ori structure is rigid foldable when the in-plane folding motion is the primary deformation mode. Meanwhile, Miura-ori also exhibits out-of-plane twisting and saddle-shaped deformations that can be prominent in dynamic responses^48,68. More importantly, these non-rigid folding deformations are desirable for reservoir computing. The presence of two out-of-plane deformation modes depends mainly on the ratio between facet bending stiffness ($k_{b,f}$) and crease folding stiffness ($k_b$). When $k_{b,f}/k_b \gg 1$, we can assume Miura-ori to be rigid-foldable. When $k_{b,f}$ and $k_b$ are comparable, out-of-plane deformation modes can be significant. The non-rigid foldable behavior of many origami mechanisms and metastructures has been studied with this approach, for example, square twist pattern⁷¹, Kresling pattern⁶⁴, and Miura-ori pop-through defect⁶⁹.

In essence, lattice framework approach discretizes the continuous origami sheet into a network of pin-jointed truss elements connected at the nodes (Fig. 1c). A typical reservoir consists of an interconnected network of units governed by nonlinear dynamics. The origami reservoir, in this case, consists of a network of nodes with their interconnections defined by the underlying crease pattern. It’s important to note that our approach does not include the nonlinear/ hyperelastic material constitutive model, the effects due to finite material thickness, viscosity, and nonlinear stiffness changes, etc. The corresponding governing equations of motion, in terms of node #p’s displacement (${\mathbf {x}}_p$) as an example, are:

$$\begin{aligned} m_p\ddot{{\mathbf {x}}}_p^{(j)}={\mathbf {F}}_{p}^{(j)}, \end{aligned}$$

(1)

where the superscript “(j)” represents the jth time step in numerical simulation, and $m_p$ is the equivalent nodal mass. Unless noted otherwise, the mass of the origami sheet is assumed to be equally distributed to all its nodes. ${\mathbf {F}}_{p}^{(j)}$ is the summation of internal and external forces acting on this node in that

$$\begin{aligned} {\mathbf {F}}_{p}^{(j)} = \sum {\mathbf {F}}_{s,p}^{(j)} + \sum {\mathbf {F}}_{b,p}^{(j)} + {\mathbf {F}}_{d,p}^{j}+{\mathbf {F}}_{a,p}^{(j)}+m_p \mathbf{g }, \end{aligned}$$

(2)

where the five terms on the right hand side are the forces from truss stretching, crease/facet bending, equivalent damping, external actuation, and gravity, respectively. The formulation of these forces are detailed below.

Figure 1

The nonlinear Truss-frame approach for simulating the origami dynamics. (a) The crease pattern of the classical Miura-ori, with a unit cell highlighted. (b) The rigid-folding kinematics of the Miura-ori. (c) The truss-frame approach discretizes the Miura-ori unit cell, showing the distribution of truss elements along the creases and across the facets, as well as the nodal masses. (d) Detailed kinematics and mechanics set up to analyze the bending and stretching along the truss #pq. Notice that ${\mathbf {m}}^{(j)}$ and ${\mathbf {n}}^{(j)}$ are the current surface normal vectors defined by triangles #pqr and #pqv, respectively. (e) The bending of the Miura-ori sheet under its weight. This simulation serves to validate appropriate material property assignments.

Truss stretching forces

The truss elements are essentially elastic springs with axial stretching stiffness ($K_{s}^{(j)} = EA/l^{(j)}$). Here, EA is the material constant, and $l^{(j)}$ is the truss element’s length at the current jth time step. Thus, the axial stiffness is updated at each time-step, accommodating the truss element’s increase in stiffness as it is compressed and vice-a-versa. The stretching force from a truss connecting node #p and one of its neighbouring nodes #q is,

$$\begin{aligned} {\mathbf {F}}_{s,p}^{(j)} = -K_{s}^{(j)}\left( l_{pq}^{(j)}-l_{pq}^{(0)}\right) \frac{{\mathbf {r}}_p^{(j)} - {\mathbf {r}}_q^{(j)}}{|{\mathbf {r}}_p^{(j)} - {\mathbf {r}}_q^{(j)}|} \end{aligned}$$

(3)

where $l_{pq}^{(0)}$ is the truss length at its initial resting state. ${\mathbf {r}}_p^{(j)}$ and ${\mathbf {r}}_q^{(j)}$ are the current position vectors of these two nodes, respectively. To calculate the total truss stretching forces acting on node #p, similar equations apply to all of its neighbour nodes through trusses (e.g., node q, r, s, t, u, and v in Fig. 1c).

Crease/facet bending forces

The crease folding and facet bending are simulated with torsional spring coefficient ($K_{b}^{(j)}=k_b l^{(j)}$), where $k_b$ is torsional stiffness per unit length. Here, we adopt the formulation developed by Liu and Paulino⁶⁹. For example, if the stored potential energy due to crease folding along the truss between #p and #q is: ${\mathbf {u}}_{pq}^{(j)} =\frac{1}{2}K_{b}^{(j)}(\varphi _{pq}^{(j)}-\varphi _{pq}^{(0)})^2$, then the force acting on nodes #p is:

$$\begin{aligned} {\mathbf {F}}_{b,p}^{(j)}=-\frac{\partial {\mathbf {u}}_{pq}^{(j)}}{\partial \varphi _{pq}^{(j)}}\frac{\partial \varphi _{pq}^{(j)}}{\partial {\mathbf {r}}_p^{(j)}} =-K_{b}^{(j)}(\varphi _{pq}^{(j)}-\varphi _{pq}^{(0)})\frac{\partial \varphi _{pq}^{(j)}}{\partial {\mathbf {r}}_p^{(j)}} \end{aligned}$$

(4)

where $\varphi _{pq}^{(j)}$ is the current dihedral angle along truss pq (aka. the dihedral angle between the triangles #pqr and #pqv in Fig. 1d), and $\varphi _{pq}^{(0)}$ is the corresponding initial value. $\varphi _{pq}^{(j)}$ can be calculated as

$$\begin{aligned} \varphi _{pq}^{(j)}&= \eta \arccos \left( \frac{{\mathbf {m}}^{(j)} \cdot {\mathbf {n}}^{(j)}}{|{\mathbf {m}}^{(j)}| |{\mathbf {n}}^{(j)}|}\right) \text { modulo } 2\pi \end{aligned}$$

(5)

$$\begin{aligned} \eta&= {\left\{ \begin{array}{ll} \text {sign} \left( {\mathbf {m}}^{(j)} \cdot {\mathbf {r}}_{pv}^{(j)} \right) ,&{}\quad {\mathbf {m}}^{(j)} \cdot {\mathbf {r}}_{pv}^{(j)} \ne 0\\ 1. &{}\quad {\mathbf {m}}^{(j)} \cdot {\mathbf {r}}_{pv}^{(j)} = 0 \end{array}\right. } \end{aligned}$$

(6)

Here, ${\mathbf {m}}^{(j)}$ and ${\mathbf {n}}^{(j)}$ are current surface normal vector of the triangles #pqr and #pqv, respectively, in that ${\mathbf {m}}^{(j)} = {\mathbf {r}}_{rq}^{(j)} \times {\mathbf {r}}_{pq}^{(j)}$ and ${\mathbf {n}}^{(j)} = {\mathbf {r}}_{pq}^{(j)} \times {\mathbf {r}}_{pv}^{(j)}$. In addition, ${\mathbf {r}}_{pq}^{(j)}={\mathbf {r}}_p^{(j)}-{\mathbf {r}}_q^{(j)}$, ${\mathbf {r}}_{rq}^{(j)}={\mathbf {r}}_r^{(j)}-{\mathbf {r}}_q^{(j)}$, and ${\mathbf {r}}_{pv}^{(j)}={\mathbf {r}}_p^{(j)}-{\mathbf {r}}_v^{(j)}$. This definition of $\varphi _{pq}^{(j)}$ ensures that the folding angle for valley crease lies in $(0,\pi ]$ and the folding angle for mountain crease lies in $(\pi ,2\pi ]$. The derivative between folding angle $\varphi _{pq}^{(j)}$ and the nodal #p’s current position vector is

$$\begin{aligned} \frac{\partial \varphi _{pq}^{(j)}}{\partial {\mathbf {r}}_p^{(j)}}=\left( \frac{{\mathbf {r}}_{pv}^{(j)} \cdot {\mathbf {r}}_{pq}^{(j)}}{|{\mathbf {r}}_{pq}^{(j)}|^2}-1 \right) \frac{\partial \varphi _{pq}^{(j)}}{\partial {\mathbf {r}}_v^{(j)}}-\left( \frac{{\mathbf {r}}_{rq}^{(j)} \cdot {\mathbf {r}}_{pq}^{(j)}}{|{\mathbf {r}}_{pq}^{(j)}|^2} \right) \frac{\partial \varphi _{pq}^{(j)}}{\partial {\mathbf {r}}_r^{(j)}} \end{aligned}$$

(7)

where

$$\begin{aligned} \frac{\partial \varphi _{pq}^{(j)}}{\partial {\mathbf {r}}_r^{(j)}}&= \frac{|{\mathbf {r}}_{pq}^{(j)}|}{|{\mathbf {m}}^{(j)}|^2}{\mathbf {m}}^{(j)}, \end{aligned}$$

(8)

$$\begin{aligned} \frac{\partial \varphi _{pq}^{(j)}}{\partial {\mathbf {r}}_v^{(j)}}&= -\frac{|{\mathbf {r}}_{pq}^{(j)}|}{|{\mathbf {n}}^{(j)}|^2}{\mathbf {n}}^{(j)}. \end{aligned}$$

(9)

Again, to calculate the total crease folding and facet bending forces acting on node #q, similar equations apply to trusses connected to this node (e.g., truss pq, pr, ps, pt, pu, and pv in Fig. 1d).

Damping forces

Estimating damping ratio and damping force is essential to achieve realistic dynamic responses and reduce numerical simulation error accumulation. In this study, we follow the formulation developed in^70,72. This formulation first calculates the average velocity of a node with respect to its neighboring nodes (${\mathbf {v}}_\text {avg}^{(j)}$) to effectively remove the rigid body motion components from the relative velocities and ensure that these components are not damped. Then damping force ${\mathbf {F}}_{d,p}^{(j)}$ applied on node #p is given by

$$\begin{aligned} {\mathbf {F}}_{d,p}^{(j)}&= -c_{d}^{(j)}({\mathbf {v}}_{p}^{(j)} - {\mathbf {v}}_\text {avg}^{(j)}) \end{aligned}$$

(10)

$$\begin{aligned} c_{d}^{(j)}&= 2\zeta \sqrt{K_{s}^{(j)} m_p} \end{aligned}$$

(11)

where $c_d^{(j)}$ is the equivalent damping coefficient, and $\zeta$ is the damping ratio.

Actuation force

In the origami reservoir, two types of creases receive actuation. The first type is “input creases,” and they receive input signal u(t) required for emulation and output modulation tasks. The second type is “feedback creases,” and they receive reference or current output signal z(t) required by all computing tasks in this study except for the emulation task. In the case of multiple outputs, different groups of feedback creases are present. Here, the selection of input and feedback creases are random. There are many methods to implement actuation to deliver input u(t) and reference/feedback signal z(t) to the reservoir. For example, the actuation can take the form of nodal forces on a mass-spring-damper network^18,32, motor generated base rotation on octopus-inspired soft arm¹⁹, or spring resting length changes in a tensegrity structure³⁴. In origami, the actuation can take the form of moments that can fold or unfold the selected creases. We assume that the resting angle $\varphi ^{(0)}$ of the input and feedback creases will change—in response to the actuation at every time step—to a new equilibrium $\varphi _{a,0}^{(j)}$ in that^34,73

$$\begin{aligned} \varphi _{a,0}^{(j)}&= W_\text {in}\tanh (u^{(j)} )+\varphi ^{(0)} \quad \text {for input creases;} \end{aligned}$$

(12)

$$\begin{aligned} \varphi _{a,0}^{(j)}&= W_\text {fb}\tanh (z^{(j)} )+\varphi ^{(0)} \quad \text {for feedback creases.} \end{aligned}$$

(13)

where $W_\text {in}$ and $W_\text {fb}$ are the input and feedback weight associated with these actuated creases. They are assigned before the training and remain unchanged after that. $u^{(j)}$ and $z^{(j)}$ are the input and feedback signal at the jth time step. The magnitude of $W_\text {in}$ and $W_\text {fb}$ are selected such that $\varphi _{a,0}^{(j)} \in [0,2\pi )$ and consistent with the folding angle assignment. This approach of assigning new equilibrium folding angles is similar to traditional neural network studies that use $\tanh$ as a nonlinear activation function to transform function z(t) into a new one with magnitudes between $[-1,1]$. Additionally, it prevents actuator saturation due to spurious extreme values of z(t). Denote the torsional stiffness of actuated creases by $K_{b,a}^{(j)}$, and we can update Equation (4) for the actuated creases (using node #p as an example)

$$\begin{aligned} {\mathbf {F}}_{a,p}^{(j)} = -K_{b,a}^{(j)}\left( \varphi _{pq}^{(j)}-\varphi _{a,0,pq}^{(j)}\right) \frac{\partial \varphi _{pq}^{(j)}}{\partial {\mathbf {r}}_p^{(j)}}, \end{aligned}$$

(14)

The calculation of other terms in this equation are the same as those in the force from crease folding and facet bending. In this work, we focus on compliant sheet materials that can easily fold into origami shapes and provide sufficient compliance for soft robotic motions. We also want to ensure that our numerical simulation results are applicable to different material selections. The range of material parameters in aforementioned equations is set according to such considerations. For example, the $k_s$ and $k_b$ values in the baseline designs come from (1) averaged results from our prior experiments using folded thick paper and PET polymer sheets^63,66, and (2) a careful survey of relevant literature^{45,48,49,68,69,71,74}. It is worth noting that obtaining the equivalent $k_s$ and $k_b$ values is not trivial, and it depends on many material and geometric factors, including the origami facets’ size and sheet material thickness, etc. Later in the parametric studies, we choose a relatively wide range of material properties to accommodate for such complexity. More importantly, we can also ensure the reservoir computing result can apply to origami reservoirs with different polymer/plastic-like material selections.

Once the governing equations of motion are formulated with above considerations, they are solved using MATLAB’s ode45 solver with $10^{-3}$ second time-steps. As an example, we show a simulation of the Miura-ori sheet deformation under its own weight (Fig. 1e). Although the governing equation of motions use nodal displacement ${\mathbf {x}}^{(j)}$ as the independent variables, we use the dihedral crease angles $\varphi ^{(j)}$ as the reservoir state variables to characterize the origami’s time responses. This is because measuring crease angles is easier to implement by embedded sensors, and $\varphi ^{(j)}$ can be directly calculated from ${\mathbf {x}}^{(j)}$ via the Equations 5 and 6.

Setting up reservoir computing

Similar to the actuated creases (aka. input creases and feedback creases), we designate “sensor creases” for measuring the reservoir states. We denote $N_a$ as the number of actuated creases, and $N_s$ for sensor creases. It is worth noting that, the actuated creases are typically small subset of all origami creases (i.e., $N_a < N$). The sensor creases, on the other hand, can be all of the origami creases ($N_s = N$) or a small subset as well ($N_s<N$).

Once the selection of input, feedback, and sensor creases is completed, one can proceed to the computing. Physical reservoir computing for tasks that require feedback, and output modulation consists of two phases: The “training phase” and “closed-loop phase.” While the emulation tasks require the training phase only.

Figure 2

The setup of physical reservoir computing with origami. (a) The training phase. The feedback creases receive the reference (or targeted) output z(t); while white noise is added to the reservoir state matrix ${\bar{\varvec{\Phi }}}$ before calculating output weights ${\mathbf {W}}_\text {out}$; (b) The closed-loop phase. The output weights obtained in the training phase are used to calculate the current output, which is fed back to the feedback creases.

Training phase

In this phase, we use the teacher forcing to obtain the readout weights ${\mathbf {W}}_\text {out}$ corresponding to every reservoir state (aka. the dihedral angles of the sensor creases). Suppose one wants to train the reservoir to generate a nonlinear time series z(t) (aka. the reference output). The feedback creases receive the reference output and it dynamically excites the origami reservoir under an open-loop condition without feedback (Fig. 2a). The reservoir states $\varphi ^{(j)}$ at every time step are measured and then compiled into a matrix ${\varvec{\Phi }}$.

Once the numerical simulation is over, we segregate the reservoir state matrix ${\varvec{\Phi }}$ into the washout step, training step, and testing step. The washout step data is discarded to eliminate the initial transient responses. We then calculate the output readout weights ${\mathbf {W}}_\text {out}$ using the training step data via simple linear regression:

$$\begin{aligned} {\mathbf {W}}_\text {out}= [{\mathbf {1}} \; {\varvec{\Phi }}]^{+} {\mathbf {Z}}= {\bar{\varvec{\Phi }}} ^{+} {\mathbf {Z}} \end{aligned}$$

(15)

where, $[.]^{+}$ refers to the Moore–Penrose pseudo-inverse to accommodate non-square matrix. ${\mathbf {1}}$ is a column of ones for calculating the bias term $W_{\text {out},0}$ to shift the fitted function when necessary. ${\mathbf {Z}}$ contains the reference signals at each time step, and it is a matrix if more than one references are present. Lastly, we use testing step data to verify reservoir performance. It is worth noting that white noise of amplitude $10^{-3}$ is superimposed on the reservoir state matrix during training to ensure the robustness of the readout result against numerical imperfections, external perturbations³², and instrument noise in “real-world” applications.

Table 1 Design of a baseline origami reservoir in this study.

Closed-loop phase

Once the training phase is over and readout weights are obtained, we run the reservoir in the closed-loop condition. That is, instead of using the reference output z(t), the current output $z^*(t)$ is sent to the feedback creases (Fig. 2b), and

$$\begin{aligned} z^*(t) = W_{\text {out},0}+\sum _{i=1}^{N_s} W_{\text {out},i}\varphi _i(t)= {\mathbf {W}}_{\text {out}}^T {\bar{{\varvec{\Phi }}}} \end{aligned}$$

(16)

where, $N_s$ is the number of sensor creases, and ${\bar{{\varvec{\Phi }}}}= [{\mathbf {1}} \; {\varvec{\Phi }}]$. Thus, the reservoir runs autonomously in the closed-loop phase without any external interventions.

We study the closed loop performance of reservoir by calculating the Mean Squared Error (MSE) using M time-steps as follows:

$$\begin{aligned} \text {MSE} = \frac{1}{M} \sum _{j=1}^{M} \left( z(j)-z^*(j) \right) ^2 \end{aligned}$$

(17)

To estimate performance when multiple reference outputs are present, we combine the MSEs by taking a norm over the individual MSEs.

Computation tasks by the origami reservoir

In this section, we use the origami reservoir to emulate multiple nonlinear filters simultaneously, perform pattern generation, and modulate outputs. The baseline variables for the origami geometric design, material properties, and reservoir parameters are given in Table 1.

Figure 3

Emulation tasks with the origami reservoir. (a) The Miura-ori reservoir used for this task with input creases highlighted. Appropriate boundary conditions are also necessary. (b) Examples of trajectories generated in the emulation task including (from top to bottom) input signal u(t), 2nd order, 10th order system, and Volterra series. Dashed curves are the targeted trajectories, and solid curves are the result of the reservoir. (c) Error analysis of the emulation tasks. Circles are the standard deviation of MSE, and horizontal bars are the corresponding extreme values.

Figure 4

Proof-of-concept experiment showing the emulation task with the origami reservoir. (a) The experimental setup depicting the excitation table and paper-based Miura-ori reservoir with sensor node markers attached. The base of the reservoir is fixed to the base plate of the exciter. Notice that additional mass are added at random locations to break the origami’s symmetry. (b) The base-plate displacement/input signal (u(t)) and recorded nodal displacements in y-direction. (c) Examples of trajectories generated in the emulation task including (from top to bottom) input signal u(t), 2nd-order, 10th-order system, and Volterra series. Dashed curves are the targeted trajectories, and solid curves are the result of the reservoir.

Table 2 Emulation task functions.

Emulation task

This sub-section shows that the origami reservoir can emulate multiple nonlinear filters simultaneously using a single input. Such emulation is a benchmark task for evaluating the performance in RNN training⁷⁵ and prove the multi-tasking capability of physical reservoirs^18,19. Note that the emulation task involves only the training phase, so there are no feedback creases in this case. Consequently, we excite the reservoir by sending the input function u(t) to the input creases and train it to find three sets of readout weights in parallel via linear regression. Here, u(t) is a product of three sinusoidal functions with different frequencies, and the three target nonlinear filters are 2nd-order nonlinear dynamic system $z_1(t)$, a 10th-order nonlinear dynamic system $z_2(t)$, and discrete Volterra series $z_3(n)$ (detailed in Table 2).

We use a $9\times 9$ Miura-ori reservoir shown in Fig. 3a in this task, exciting the reservoir from complete rest and training it for 100 seconds. We discard the first 50 seconds of data as the washout step, use the data from the next 45 seconds to calculate the optimum static readout weights, and then use the last 5 seconds of data to calculate the MSE for performance assessments. Results in Fig. 3b show that the origami reservoir can emulate these three nonlinear filters. As the nonlinearity and complexity of the nonlinear filter increases, MSE also increases (Fig. 3c).

Moreover, we compare the emulation performance when all N creases are used as sensor creases versus when only actuated creases are used as sensors ($N_s = N_a = pN$). The increase in MSE is marginal in the latter case. Therefore, the origami satisfies the previously mentioned nonlinearity and fading memory requirements to be a physical reservoir, and one only needs to use the input creases angles as the reservoir states to simplify the reservoir setup.

We also experimentally demonstrate the emulation task using a paper-based origami reservoir (Fig. 4 and Supplemental Video B). Details of this experiment are summarized in “Methods and materials”.

Pattern generation task

Pattern generation tasks are essential for achieving periodic activities such as robotic locomotion gait generation and manipulator control where persistent memory is required. That is, by embedding these patterns (or limit cycles) in the origami reservoir, one can generate periodic trajectories in the closed-loop. We again use a $9 \times 9$ Miura-ori reservoir and randomly select $30\%$ of its creases as the feedback creases (Fig. 5a). This task does not require input creases. These feedback creases are divided into two groups for the two components of 2D trajectories. We run the training phase for 100 seconds for each pattern, discard the initial 15 seconds of data as the washout step and use the next 51 seconds’ data to calculate the optimum output readout weights.

Generating nonlinear limit cycles

In the following results, the origami reservoir demonstrates its computation capability via generating quadratic limit cycle, Van der Pol oscillator, and the Lissajous curve in closed-loop. The quadratic limit cycle is defined by two differential equations:

$$\begin{aligned} {\dot{x}}_1&= x_1 + x_2 - \epsilon (t) x_1 \left( x_1^2 + x_2^2 \right) , \end{aligned}$$

(18)

$$\begin{aligned} {\dot{x}}_2&= -2x_1+x_2-x_2 \left( x_1^2 + x_2^2 \right) , \end{aligned}$$

(19)

where the parameter $\epsilon (t)$ determines the shape of the limit cycle ($\epsilon (t)=1$ in this case). The Van der Pol oscillator is defined by:

$$\begin{aligned} {\dot{x}}_1&= x_2, \end{aligned}$$

(20)

$$\begin{aligned} {\dot{x}}_2&= -x_1 + \left( 1-x_1^2 \right) x_2. \end{aligned}$$

(21)

The Lissajous curve is a graph of two sinusoidal signals parameterized by their frequency ratio ($f_1/f_2=0.5$) and phase difference ($\delta =\pi /2$):

$$\begin{aligned} x_1&= \sin \left( f_1 t + \delta \right) \end{aligned}$$

(22)

$$\begin{aligned} x_2&= \sin \left( f_2 t \right) \end{aligned}$$

(23)

Figure 5

Stable pattern generation under closed-loop using the Miura-ori reservoir. (a) This task’s origami reservoir includes two groups of feedback creases required to generate 2D limit cycles. (b–d) The closed-loop trajectories of quadratic limit cycle, Van der Pol oscillator, and the Lissajous curve, respectively. In these plots, the first row of time responses shows the closed-loop output after 100s of training. The third row of time responses shows how the trained reservoir can recover the targeted limit cycles from an initial resting condition. The corresponding phase portraits are as shown in the second row. Here, the dashed curves are targeted trajectories, and the solid curves are the reservoir’s outputs. (e) Van der Pol limit cycle recovery after the temporary failure of sensor and actuator creases. The two simulations are the same except for the number of sensor creases ($N_s=N$ for the first test, $N_s=0.3N$ for the second). The insert figures show the corresponding phase-portraits.

Figure 5b–d show the results of Quadratic limit cycle, Van der Pol oscillator and Lissajous curve generation task, respectively. The origami reservoir can generate all three periodic trajectories just by changing the output readout weights. The MSE for Quadratic limit cycle, Van der Pol oscillator, and Lissajous curves, calculated using the data for first 10 seconds’ closed-loop run (M = 10000), are $3.28 \times 10^{-7}$, $2.03 \times 10^{-5}$, and $5.5 \times 10^{-4}$, respectively. As expected, MSE increases as the complexity of the curve increases.

Stability and robustness of the pattern generation

After finding the readout weights, we test the stability of these three limit cycles by starting the origami reservoir from total rest in the close-loop and running it for more than 1000 seconds. The limit cycle is stable if and only it can recover the pattern from zero initial conditions and stays on target for at least 1000 seconds of simulation^19,32. The results in Fig. 5 indicate that the torsional moments generated from the feedback signals on the feedback creases are sufficient to recover and maintain the three limit cycles from total rest. Small phase differences occur between generated trajectories and the targets because the reservoir takes a slightly different path than the target, and the Lissajous curve takes more than 15 seconds to recover fully. Nonetheless, the origami reservoir successfully passes this test.

To further analyze the robustness of reservoir-generated limit cycles, we simulate actuator and sensor failures. As the origami reservoir generates the Van der Pol limit cycles in these tests, all feedback and sensor creases stop working (aka. their signals set to zero) for 10 seconds. We conduct these tests when all creases are used as sensor creases ($N_s=N$) and when only feedback creases are sensor creases ($N_s=N_a=0.3N$). The simulation results in Fig. 5e show that, although the reservoir diverges to a trajectory far away from the target during the actuator and sensor failure, it can immediately recover the Van der Pol limit cycles after the end of these failures.

Figure 6

Results of modulation task under closed-loop using The Miura-ori reservoir. (a) This task’s origami reservoir includes two groups of feedback creases and input creases. (b) The phase-portraits, where the targeted trajectories are overlaid on top of the reservoir output. (c) Quadratic limit cycle trajectories under closed-loop and the corresponding input signal $\epsilon (t)$. The results are obtained after 500 seconds of training. (d) Closed-loop trajectory recovery from the initial resting conditions.

Output modulation task

Output modulation capability allows the reservoir to adjust its output according to a randomly varying input signal without changing the readout weights. This ability is also essential for soft robotic control applications because it allows the robot to switch behaviors according to external stimuli or environmental changes. In this task, we randomly select input creases, which account for $15\%$ of the total creases, in addition to the feedback creases (Fig. 6a). Moreover, all creases are used as sensor creases ($N_s=N$). The simulation results in Fig. 6b shows the generated quadratic limit cycles with modulated input (Eqs. (18, 19)). We are also able to recover the closed-loop trajectory from the initial resting conditions, as shown in Fig. 6c. The phase portraits for the two tasks are depicted in Fig. 6d. The origami reservoir can react to the input and modulate the magnitude of the quadratic limit cycles. The MSE is $3.8 \times 10^{-4}$, which is remarkably small, considering this task’s complexity.

Correlating physical design and computing performance

In this section, we use the mean squared error (MSE) as the metric to examine the connections between the origami reservoir’s design and computing performance. In particular, This analysis aims to investigate the sensitivity of MSE to different parameter changes and identify the optimal origami designs. To this end, in-depth parametric analyses are conducted to examine the effect of (1) reservoir size and material properties, (2) crease pattern geometry, and (3) feedback and sensor crease distribution. We use both Van der Pol and quadratic limit cycle generation tasks to ensure the broad applicability of parametric study results.

Table 3 Variables for reservoir size and material properties parametric study.

Reservoir size, material properties, and vertices perturbation

Figure 7

Effect of reservoir size and material properties on the reservoir computing performance. (a) The distribution of MSE from the Quadratic limit cycle simulations using random feedback crease distributions and different design parameter distributions. Here “FB” stands for feedback crease distribution, “M” stands for nodal mass distribution, “V” stands for origami vertices geometry perturbation, and “$K_f$” stands for crease torsional stiffness distribution. It is worth emphasizing that the “FB” results come from one parametric study of 72 unique designs, and the “M,” “V,” and “$K_f$” are results of the subsequent simulation. The bar charts depict the average value, standard deviation (circles), and extreme values (horizontal bars) of MSE. (b) A similar result from the Van der Pol limit cycle generation task. (c) The feedback crease distributions of the four different baseline designs used in this parametric study.

Figure 7a,b show the results of parametric analyses for Quadratic limit cycle and Van der Pol oscillator limit cycle generation, respectively. We observe that feedback crease distribution affects reservoir computing performance quite significantly. In particular, poorly distributed feedback creases might result in failed pattern generating tasks. Therefore, we first conduct numerical simulations by randomly changing the feedback crease distributions (72 unique designs in total) and identifying the best performing one (with the least MSE). We refer to this best performing feedback crease distribution as the base design (Fig. 7c) for the following parametric studies. Then, we conduct another parametric study regarding the nodal mass, crease stiffness, and vertices perturbation. We vary these three parameters, one at a time, for 72 randomly selected designs (six batches of jobs in parallel on a computer with 12 cores). The baseline values and range of the parameters are in Table 3.

The origami reservoir performance turns out to be highly sensitive to the nodal mass variation. As opposed to the uniform nodal mass in base design, a randomly distributed nodal mass can significantly increase or decrease the MSE for both pattern generation tasks. However, randomly distributing mass in an origami sheet is quite challenging in practical applications. So the use of varying mass distribution should be judicially done based on the particular application at hand. On the other hand, the origami performance is much less sensitive to the crease torsional stiffness. By randomly changing the stiffness, one can achieve performance at par with the base design.

Moreover, we investigate the effects of random geometric imperfection in the base designs of origami reservoir. To this end, we adopt the formulation introduced by Liu et al.⁷⁴, which introduce small perturbations to the nodal positions in folded origami. Such imperfections are inevitable in practice due to various manufacturing defects. It is found that these small imperfections do not worsen the MSE significantly and in fact could reduce the MSE by a moderate degree.

It is also worth noting that the larger $9 \times 9$ Miura origami reservoir performs better than the smaller one because larger origami contains more folding angles to constitute the reservoir state matrix. Therefore, the high-dimensionality of a reservoir is desirable to produce smaller MSE.

Origami design

Figure 8

Effect of Miura-ori geometric design on the reservoir performance. (a–c) The Miura-ori geometry and the corresponding landscape of MSE distribution when $\theta =50^\circ$, $60^\circ$, and $70^\circ$, respectively for Quadratic and Van der Pol limit cycle generation. The lighter and darker regions correspond to larger and smaller errors, respectively, while the white regions depict origami designs that failed the computing task. (d) The unit cell geometry of four representative designs with the same crease a length but different sector angles $\gamma$ and crease length ratios a/b.

A unique advantage of origami based structures and materials is their considerable freedom to tailor the geometric design. To this end, we start from the Base Design IIa and IIb of $9 \times 9$ Miura-ori reservoir, vary its crease length ratio (a/b) and internal sector angle $(\gamma )$, and then run the quadratic limit cycle and Van der Pol limit cycle tasks with 100 crease length and sector angle combinations at three folding angles. The results of the parametric analysis for $\theta =50^\circ$, $\theta =60^\circ$,and $\theta =70^\circ$ are shown in Fig. 8a–c, respectively. We observe that, at lower folding angles (flatter origami), the origami reservoir has a higher possibility to fail the pattern generation tasks. The computing performance improves significantly with a reduced MSE as the origami folds more (or as $\theta$ increases). This trend is probably because highly folded origami offers an increased range of folding motion.

Moreover, there are two design sets with the lowest MSE: $a/b \approx 1.5$, $\gamma \approx 45^\circ$, and $a/b \approx 2.5$, $\gamma \approx 60^\circ$. Figure 8d shows unit cell geometry of four representative designs in this range. Generally speaking, a moderate to high crease-length ratio and small sector angles can create “skewed” origami patterns that appear to give better computing performance across all values of folding angles. The best designs here have MSEs at the order of $10^{-7}$, which is of the same magnitude as we found previously by tailoring the nodal mass and crease stiffness.

Figure 9

Effect of varying the number of actuator and sensor creases.

Actuator and sensors distribution

Finally, it is important, for practical applications, to find the minimum amount of input/feedback and sensor creases required for achieving acceptable computing performance. To this end, we start with the $9 \times 9$ Miura-ori reservoir and conduct two tests. In the first test, we vary the percentage of feedback creases ($N_a = 0.2N, 0.3N, 0.4N, 0.5N$, each with 24 randomly generated crease distributions) while using all crease dihedral angles to constitute the reservoir state matrix (i.e., $N_s = N$). In the second test, we use the same feedback crease design and only use these feedback creases’ dihedral angles to formulate the reservoir state matrix (i.e., $N_s = N_a$).

We find that if only $20\%$ of crease are used for feedback, the origami reservoir might fail the quadratic limit cycle task. On the other hand, the MSE reduces only marginally as we increase the percentage of feedback creases beyond $30\%$ (Fig. 9). Therefore, we can conclude that using only 30–40% of total creases as the feedback and sensors crease will provide us an adequate computing performance. This result is significant because it shows that, even though a large size (high-dimensionality) of the reservoir is essential for computing performance, one does not need to measure (readout) every reservoir state. In this way, the practical implementation of the origami reservoir can be significantly simplified.

In conclusion, the parametric analyses lay out the strategy to optimize the origami reservoir performance by tailoring the underlying physical and computational design. A larger origami with a higher-dimension can ensure low computational error, but one only needs to use $30\%$ $40\%$ of its creases as the feedback and sensor creases to tap into the origami’s computing capacity. Meanwhile, the distribution of these feedback and sensor creases must be carefully chosen with extensive simulations. To further improve computing performance, one can tailor the origami’s mass distribution, crease stiffness, and geometric design. Among these options, optimizing the folding geometry should be the most effective because it is easy to implement in practical applications.

Figure 10

Reservoir computing powered crawling origami robot. (a) The kinematics of a peristaltic locomotion cycle in an earthworm. For clarity, the earthworm body is simplified and consists of six identical segments organized into two driving modules. The earthworm body moves forward while the peristaltic wave of anchoring segments (or driving modules) propagates backward. (b) The design of an earthworm inspired origami crawling robot that features two stripes of Miura-ori connected by a zig-zag shaped “ridge.” This robot has four groups of feedback creases. (c) The closed-loop trajectory generated by the feedback creases after training (shown in solid lines) superimposed with the targetted trajectory (shown in dashed lines). (d) Peristaltic locomotion cycle in the origami robot as a result of the generated trajectory.

Application to soft robotic crawling

This section demonstrates the application of origami reservoir computing to generate an earthworm-inspired peristaltic crawling gait in a robotic system. The earthworm uses peristalsis to navigate uneven terrain, burrow through soil, and move in confined spaces. The lack of complex external appendages (aka., legs or wings) makes earthworm-inspired robots ideal for field exploration, disaster relief, or tunnel drilling^61,76,77. The body of an earthworm consists of segments (metamerism) grouped into multiple “driving modules”^64,78. Each driving module includes contracting, anchoring, and extending segments actuated by antagonistic muscles (Fig. 10a). During peristaltic locomotion, these segments alternately contract, anchor (to the environment with the help of setae), and extend to create a propagating peristalsis wave, thus moving the body forward.

We design an earthworm-inspired origami robot consisting of two $3 \times 9$ Miura-ori sheets connected via a stiff central bridge (Fig. 10b). The left and right half of the robots are symmetric in design, and the central bridge design allows differential motion between the two halves to facilitate turning in response to the external input. In each half of the origami, we embed two groups of feedback creases (Fig. 10b) with feedback weights assigned such that their values for the front and back-half are equal but opposite to each other. This arrangement reduces the number of reference outputs needed to generate a crawling gait. To create a peristalsis locomotion gait, we train the origami reservoir to generate multiple harmonic signals with a phase difference of $\pi /2$ among them (aka. a pattern generation task). We train the robot for 100 seconds and discard the first 15 seconds of data as the washout step.

The ground reactions are modeled by setting the vertical velocity of masses (i.e. point contact with node) touching the ground to zero and the horizontal friction coefficient to be infinite. Inspired from the setae in earthworm, we assume presence of passive foldable anchors that lose/grip anchoring to the ground periodically. We apply ideal anchors to the bottom origami creases that are in contact with the surface below. These anchors are assumed to be kinematically attached to the ground when the associated origami crease folds and relaxed as the crease unfolds (or flattens). Such anchor design is feasible by leveraging the origami facets’ folding motion, as shown in the author’s previous study⁶⁴. This is a hard constraint that can impact the nature and the performance of locomotion. However, it simplifies the study of the body influence by assuming perfect friction conditions in every simulation.

Figure 10c depicts the closed-loop response and the limit cycle recovery from total rest (MSE is $3.9 \times 10^{-04})$. Figure 10d (and Supplemental Video A) illustrates the robotic locomotion generated by reservoir computing. As the origami reservoir generates the multiple harmonic signals with a phase difference, its folding motion naturally “synchronizes” to these signals, generating a peristaltic wave of folding and unfolding. As a result, the robot crawls forward like an earthworm, without using any traditional controllers.

Summary and conclusion

We demonstrate the physical reservoir computing capability of origami via extensive benchmark simulations and parametric studies. First, we develop a simulation environment to study the nonlinear origami dynamics and detail the origami reservoir setup. This reservoir successfully achieves many computing tasks such as emulation, pattern generation, and modulation, all of which are relevant to robotic applications. We also conduct comprehensive parametric analysis to uncover the linkage between origami reservoir design and its computing performance. This new knowledge base offers us a guideline to optimize computing performance. To the authors’ best knowledge, this is the first study to rigorously examine the performance of physical reservoir computer from the lens of the physical design. Finally, we demonstrate how to embed reservoir computing into an origami robot for control without traditional controllers through the example of peristaltic crawling.

We list four requirements for a mechanical system to be a reservoir in the introduction, and origami satisfies all these requirements. The tessellated origami structures are inherently high-dimensional. For example, a $7 \times 7$ Miura-ori with 49 nodes contains $N = 60$ crease dihedral angles, all or a small portion of them can serve as the reservoir states. The nonlinearity of origami partly originates from the nonlinear kinematic relationships between these crease angles and external geometry. Also, since origami patterns are highly structured (ordered), small perturbations in the material properties, imperfections of crease geometry, and the introduction of local actuation are sufficient to destroy the regularity and create disorder. These properties make origami highly nonlinear dynamic reservoirs. The origami reservoir’s performance in the emulation task proves that it can act as a nonlinear filter and satisfies fading memory property. Nonlinear patterns can be embedded into the origami reservoir, and the resulting pattern generation is robust against external disturbances and recoverable under different initial conditions, proving separation property. Finally, adding the feedback can create persistent memory, which is conducive to learning new tasks.

For future robots to work autonomously in unstructured and dynamic environments, the robot body and brain have to work together by continuously exchanging information about the current condition, processing this information, and taking appropriate actions. The physical reservoir computing embodied robot shown in this study presents a step toward this vision. The reservoir embedded in the robot body directly gathers information from the distributed sensor-actuator network to perform low-level control tasks like locomotion generation. The resulting soft robot can generate the global target behavior autonomously without controlling every element individually. Moreover, the generated trajectories could be robust against external disturbances and modulated according to changing working conditions.

A challenge in implementing physical reservoir computing is that many sensors and actuators are required, even though these sensors and actuators can be simple individually. Our results contribute in this regard by showing that only a small portion of origami creases are required to be equipped with sensors and actuators to tap into the reservoir computing power. The essential advantage of an origami reservoir compared to a typical neural reservoir is that it can serve as the physical body of the robot and at the same time perform nonlinear computation for control tasks. Meanwhile, it will be imprudent to directly compare origami reservoirs’ computing performance with other physical reservoirs. Only a handful of studies examined the use of soft physical bodies for reservoir computing (e.g., soft silicone arms, tensegrity structures, compliant spine robot). And these systems are often constrained by other non-computing-related requirements. Thus, a comparative study between different physical reservoirs is a worthy topic for future research.

In summary, origami reservoir computing provides an attractive pathway for facilitating synergistic collaboration between the soft robot’s body and the brain. The reservoir computing, coupled with unique mechanical properties that origami can offer—multi-stability^51,53,79, nonlinear stiffness^48,49,51,53, and negative Poisson’s ratio^48,51,53—opens up new avenues to the next generation of soft robots with embedded mechanical intelligence.

Methods and materials

We demonstrate the origami reservoir’s computational power through a simple experiment of the emulation task described earlier. The experimental setup consists of an APS Dynamics vibration exciter (shaker), power amplifier, National Instruments DAQ, a laptop to generate input command, and a camera to capture the vertical vertices displacements. Detailed origami reservoir design parameters are in Table 4. The reservoir is placed vertically on the vibration exciter and fixed rigidly to its base plate, as shown in Fig. 4a. The external input (u(t)) is provided to the base of origami. To experimentally demonstrate the origami reservoir’s computing power without unnecessary hardware complexities, we use the vertical (y-direction) displacement of origami nodes as the reservoir state vector. We capture the deformation of origami through a slow-motion video camera at 480 fps with 720p resolution. The nodal displacement in the y-direction is measured through post-processing of the video data in MATLAB. The training procedures for the emulation task remain the same. The results in Fig. 4 clearly show that the physical origami reservoir can indeed emulate the three non-linear systems described in Table 2.

It is worth emphasizing that using a single base excitation as external input and the vertical nodal displacements as the reservoir states only taps into a part of the origami’s high dimensional dynamics. Therefore, the mean square error in the experiment is more significant than those with embedded sensors and actuators (Fig. 3). Distributing sensors and actuators on the origami creases will provide better control over the shape of origami, as shown in the example of soft robotic crawling. Nevertheless, this experiment serves as physical proof that the Miura-ori based reservoir can perform complex computational tasks.

Table 4 Design of the origami reservoir in the emulation task experiment.