Impact-resistant, autonomous robots inspired by tensegrity architecture

Advancing beyond what was demonstrated in previous literature  (?, ?, ?), Tribar is capable of reconstructing its state during dynamic locomotion using only on-board sensors. Here state is defined as the robot’s shape plus its orientation relative to a global frame. The robot’s on-board sensors include the nine strain sensors that measure the length of the nine tensegrity tendons and three 9-axis IMUs. Each IMU contains a 3-axis accelerometer, a 3-axis gyroscope, and a 3-axis magnetometer. These three sensors along with the IMU’s on-chip digital motion processor are used to measure the IMU’s orientation relative to Earth’s magnetic and gravitational fields. Two such measurements from IMUs on different bars, estimating each bar’s direction in a global frame, provide enough information for state estimation.

Our state estimation algorithm is a two-step optimization algorithm. The first step is shape estimation where we minimize the squared error from the sensor tendon measurements in a constrained optimization given the known bar lengths, as in   (?). Precisely, shape estimation minimizes the objective

$\frac{\sum^{2}_{i=0}\sum^{2}_{j=0,i\neq j}\left(\left|\left|N_{2i+1}-N_{2j+1}\right|\right|-d_{2i+1,2j+1}\right)^{2}+\left(\left|\left|N_{2i}-N_{2j}\right|\right|-d_{2i,2j}\right)^{2}}{2}+\sum^{2}_{k=0}\left(\left|\left|N_{k}-N_{k+3}\right|\right|-d_{k,k+3}\right)^{2}$

$\textrm{s.t.}\left|\left|N_{2l}-N_{2l+1}\right|\right|-L=0\ \textrm{for}\ l=0,1,2$

where $N_{m}$ is the 3D position of node $m$, $d_{p,q}$ is the sensor measurement between nodes $p$ and $q$, and $L$ is the constant bar length. The node labeling scheme is shown in Fig. S4. Nodes 0 and 1 are on the red bar, 2 and 3 on the green, and 4 and 5 on the blue. The odd numbered nodes are all on one side of the robot while the even numbered nodes are on the opposite side. The output of the shape estimation step is the 3D position vector of each node in an arbitrary frame whose origin, for convenience, is at the centroid of the six nodes.

The second step of the algorithm is orientation estimation where, given the shape of the nodes, we find the rotation that minimizes the squared error between the unit vectors of the estimated and measured directions of the two bars with IMUs relative to the global frame. Precisely, we find the rotation $R$ that minimizes the objective

where $N_{m}$ is again the 3D position of node $m$ and $\hat{a}_{l}$ is the unit vector representing the orientation of bar $l$ as measured by the IMU. Once $R$ is found through the optimization routine, we apply the rotation to the nodes and return the rotated coordinates. These rotated coordinates represent the robot’s state, defined as its shape and orientation relative to a global frame. Note that our algorithm does not estimate the robot’s translation.

The robot’s state reconstruction performance during dynamic locomotion trials in a field environment is shown in Fig. 2 and Fig. S5. A field environment was chosen to avoid magnetic interference from nearby buildings. The magnetic interference disrupts the readings of the IMU’s magnetometer and therefore the output of the orientation estimation. The field experiments were conducted at dusk under artificial lighting from portable LED spotlights so that the sunlight did not interfere with the Intel RealSense L515 depth camera, which we used to track the robot’s position for ground truth  (?).

The tensegrity robot achieves locomotion through extreme deformations that shift its center of mass. Sensor tendons (section M1.3) provide real-time feedback for PID control (described below) so that each of the six actuators can achieve a target length within some small tolerance. A set of six target lengths is a target shape, and a repeating sequence of target shapes defines a gait. The robot has several different gaits (described below) for rolling and turning locomotion.

Shown in Fig. 4, the tensegrity robot can follow prescribed trajectories by selecting actions that minimize a cost function. The actions include the quasistatic rolling gait with different values for the range (every 10 mm from 90 mm to 150 mm), the counterclockwise (ccw) turning gait with a range of 100 mm, the clockwise (cw) turning gait with a range of 100 mm, and modified versions of the quasistatic rolling gait where the range is different on either side of the robot. When one side of the robot has a larger range than the other in the rolling gait, it takes a larger step on one side than the other, and the robot’s behavior is forward motion with gradual turning (in contrast to the cw and ccw “turn in place” gaits) analogous to differential drive in wheeled robots when the wheels on one side spin faster than the other. The following gait parameters are the same for all the actions: a minimum length of 100 mm, a max speed of 99, a tolerance of 20%, $K_{P}=6$, $K_{I}=0.01$, and $K_{D}=0.5$.

Each of these 51 actions was first modeled offline using our simulation based on a differentiable physics engine  (?). The robot’s pose is the 2D position of the centroid of its six end caps and the 2D orientation of the robot given by the unit vector that points from the centroid of nodes 1, 3, and 5 to the centroid of nodes 0, 2, and 4 (see Fig. S4), which we call the robot’s principal axis. Before and after executing each action in simulation, the pose (position and orientation) is extracted from the simulation. The 2D rotation from the pose before to the pose after is calculated based on the angle by which the principal axis rotated about the z-axis. The 2D translation from the pose before to the pose after is calculated relative to the robot’s initial body frame via $t^{0}_{1}=R^{0}_{\mathcal{W}}d^{\mathcal{W}}_{1}$ where $R_{0}^{\mathcal{W}}=\left[\begin{matrix}c_{\theta}&-s_{\theta}\\ s_{\theta}&c_{\theta}\end{matrix}\right]$ is the rotation matrix that describes the robot’s initial body frame with respect to the world frame given the anlge $\theta$ between the robot’s principal axis and the world frame’s x-axis. The 2D rotation and translation relative to the robot’s body frame before the action are stored in a data table, which is searched in real time during trajectory following trials to determine the best sequence of actions to minimize the cost function.

Each trajectory is represented as a series of 2D waypoints in a global frame. An overhead RGB-D camera (Intel RealSense L515) was calibrated using April tags  (?) to measure its extrinsic matrix relative to the global frame. Our previously developed tensegrity pose tracking algorithm  (?) was modified to run in real time as a ROS service. During each planning step, the node that controls the tensegrity robot requests the robot’s current pose from the tracking service and plans a sequence of actions to follow the given trajectory.

The cost function is given by

where $w_{d}$, $w_{a}$, and $w_{p}$ are the hand-tuned weights for distance, angle, and progression, respectively, $\vec{p}_{i}$ is the 2D position vector of waypoint $i$ (the closest waypoint on the trajectory to the robot’s current position), $\vec{x}$ is the robot’s 2D position given by the tracking service, $\vec{h}$ is the robot’s heading (the robot’s principal axis rotated by 90°counterclockwise), and $n$ is the number of waypoints in the trajectory. As in previous work  (?, ?), the three terms in this cost function punish the robot for its 2D Euclidean distance from the trajectory, for the angle between the robot’s heading and the trajectory’s tangent at the robot’s location, and for being closer to the start of the trajectory. The weights used for the experiments are listed in Table S3.

The robot starts the trajectory following task by planning via an exhaustive tree search of all possible actions with a search depth of two. For each action, the rotation and translation tabulated from the simulation are applied to the robot’s current position and orientation to predict the next position and orientation after taking that action. Then, for each prediction, we search the action space again, applying the transformation to each predicted position and orientation. The resulting position $t^{\mathcal{W}}_{2}$ and orientation $R^{\mathcal{W}}_{2}$ with respect to the world frame after applying two actions are given by the equations below.

Having reached the prescribed search depth, the cost function is evaluated, and the sequence of two actions with the lowest cost is returned. The robot executes the first action and then again plans a sequence of two actions, repeating this process until it reaches the end of the trajectory.

Fig. 4 shows the robot’s ability to follow a straight line, a circular arc, and a right triangle. To follow the straight line, the controller usually commands rolling actions, course correcting for any deviations, and occasionally turn in place actions. To follow the circle, gradual turning actions are selected. The triangular trajectory’s sharp corners pose further challenges. To follow the triangle, the controller segments the triangle trajectory into three straight line trajectories. When the robot reaches the end of a segment—defined as being within 27 cm of the last waypoint or if the last waypoint is the nearest point to the robot—the robot moves on to following the next segment. At this juncture, to handle sharp corners, the controller decides if the robot should continue to roll in the same direction or instead, by virtue of its symmetry, roll backward by evaluating

where $\vec{a}$ is the robot’s principal axis, defined above, and $\frac{\vec{p}_{i+1}-\vec{p}_{i}}{\left|\left|\vec{p}_{i+1}-\vec{p}_{i}\right|\right|}$ is the unit vector in the direction of the next trajectory segment. If this inequality is true, the robot rolls in its typical forward direction. Otherwise, if the cross product is negative, the robot rolls in the reverse direction, the gaits are modified via symmetry reduction, and the principal axis and heading are reversed in the robot body frame (SM section S6). When the robot begins subsequent trajectory segments, it doesn’t start with the perfect position and heading like it does for the first segment (and for the straight line and semicircle trajectories). These errors compound, which is why the deviation from the trajectory is greater for the triangle than the other two. However, the robot is still able to recover and reach the desired end point of the trajectory. Plots of the error as a function of distance along the trajectory are shown in Fig. S7.

To enable Tribar to play limbo autonomously, the pose tracking service was further augmented to perceive the height of the yellow limbo bar (SM section S4). The robot first shrinks to the proper height, setting its range to the measured bar height minus 120 mm (100 mm accounting for the minimum length of the tendon and 20 mm for the diameter of the bar) with a maximum range of 140 mm and rounded down to the nearest 10 mm. Then, the robot executes its quasistatic rolling gait at that range with a max speed of 99, a tolerance of 20%, $K_{P}=6$, $K_{I}=0.01$, and $K_{D}=0.5$. When the robot has reached (within 27 cm) the endpoint of its 70-cm path under the limbo bar, as measured by the tracking service (SM section S4), the robot returns to its maximum height (at a range of 140 mm) and waits for the limbo bar to lower. A stepper motor lowers the bar height by 40 mm; when the lowering of the bar is complete, the robot is manually commanded to resume the limbo demonstration with the newly lowered bar in the reverse direction, autonomously modifying its gait by symmetry reduction (SM section S6) and the gait’s range based on the perceived bar height (SM section S4).

To survive the harsh impacts from rolling off the cliff (Fig. 1) and the bridge (Fig. 5), the design of the end caps had to be modified. As shown in Fig. S1, the depth of the central hole through the end cap was increased so that the carbon fiber rod reinforced the stress concentration where the hemisphere meets the cylinder. Also, the end caps were 3D printed from a stronger material (Tough 1500 Resin on a Form 3; Formlabs). The quasistatic rolling gait was modified to be

with the robot returning to its rest shape immediately after the rolling step because it is more capable of absorbing impact in that shape (i.e., more energy is absorbed through deformation before the rigid components contact each other). For this gait, the minimum length is 100 mm, the range is 100 mm, the tolerance is 12%, $K_{P}=6$, $K_{I}=0.01$, and $K_{D}=0.5$.

The cliff dive demonstration, shown in Fig. 1 and movie S1, is autonomous. Sensor information is received over Bluetooth, and state estimation is calculated in real time. The robot’s initial heading is recorded based on the state estimation result at the beginning of the trial. After each cycle of the modified quasistatic rolling gait, when the robot returns to its rest shape, the most recent state estimation result is analyzed to determine the robot’s heading and which three nodes define the downward face. The quasistatic gait is then modified with symmetry reduction (SM section S6), including reversing the gait if necessary, to ensure the gait is correct for the next cycle.

The bridge dive demonstration, shown in Fig. 5 and movie S8, uses the same gait, but the demonstration is not fully autonomous. The state estimation algorithm relies on absolute orientations from the 9-axis IMUs, and the magnetic interference from the nearby buildings causes the magnetometer readings to drift. For that reason, the robot is programmed to briefly pause after one gait cycle, and then the correct heading and downward face are manually entered depending on how the robot lands. Afterward, the modified quasistatic rolling gait is executed continuously.

In an additional field test, shown in movie S11, we demonstrate the robot rolling off a large cliff, about 12 m high, and recovering its shape at the bottom. The height of the large cliff does not represent the greatest survivable drop height of the robot since it was not a shear drop: the robot was buffeted by the cliff side and vegetation on its way down. This experiment was conducted for the lack of controls in an unpredictable, authentic field environment. The drop was high enough that our Bluetooth communication was out of range, so the long delay in the video is due to the time it took to walk to the bottom of the cliff and reconnect to the robot.

Tensegrity robotics researchers have built many innovative robots and characterized their advantages of impact resistance, light weight, and versatility. As we work toward fully autonomous tensegrity robots that can navigate unstructured environments, it is important to measure the progress of our field with quantitative metrics  (?). In this section, we report the critical performance metrics of Tribar that enable its key achievements of autonomy, versatility, and impact resistance and compare them to prominent examples of the state of the art. This list is not meant to be exhaustive, in part because there are not universally agreed upon metrics for tensegrity robots that all studies report  (?). A more comprehensive discussion of the state of the art can be found in recent review articles  (?, ?).

To understand the effect of the robot’s shape morphing on its locomotion, we characterized the quasistatic rolling gait with a varying range (90 mm to 180 mm). The experiments are shown in Fig. S8, and the gait parameters are given in Table S9. The robot’s velocity decreases as the range increases. Although a larger range results in bigger steps each time the robot rolls, contracting a longer cable takes more time for the motors, resulting in a lower frequency of rolls and a slower overall speed.

In addition to rolling forward, we demonstrate different turning gaits for the tensegrity robot. The two most reliable gaits for turning in place were discovered by our simulator (SM section S5). The counterclockwise turning gait is $[[1,1,1,0,1,1],[1,0,1,0,1,1],[0,0,0,0,0,0],[1,1,1,1,1,1]]$, and the clockwise turning gait is $[[0,0,0,1,0,1],[0,0,0,0,0,1],[0,0,0.8,0,1,1],[1,1,1,1,1,1]]$. In the counterclockwise gait, the robot shifts its weight during the cycle to rotate its body, maintaining the same nodes on the bottom for the duration of the gait. In the clockwise gait, like the rolling gaits, the robot flips over onto a new face. Therefore, for the clockwise gait to be repeatedly executed, it is extended by symmetry reduction as described below. The results of the experiments with these “turn in place” gaits are shown in Fig. 3, and the gait parameters are listed in Table S10.

The robot is also capable of a crawling-based turning gait where it uses one side of its body as a pivot while the other side crawls along using friction. Experiments, shown in Fig. S9, characterize the robot turning clockwise and counterclockwise while using each side as the pivot. Here, “left” refers to using the left side of the robot (with nodes 1, 3, and 5) as the pivot while “right” refers to using the right side (with nodes 0, 2, and 4) as the pivot. “Left” and “right” are defined with respect to the robot’s locomotion direction during the quasistatic rolling gait from its rest state (Fig. S4). The gait for crawling-based turning with the left pivot is given by

for turning clockwise and

for turning counterclockwise. The gait can be adapted to use the right pivot by symmetry reduction as described below. The gait parameters for these experiments are listed in Table S10.

Finally, the robot can also turn using the quasistatic rolling gait by using a different value for the range on each side of its body, analogous to differential drive on wheeled vehicles. Just as spinning the left and right wheels at different speeds leads to a gradual turning motion on a wheeled robot, our robot can turn while rolling forward. Experiments (Fig. S9) show the robot gradually turning counterclockwise by employing the quasistaic rolling gait with a range of 80 mm on the left side and 160 mm on the right side. Then, it can turn clockwise using the same gait by switching the range values. Gait parameters for these gradual turning experiments are listed in Table S10. This gradual turning gait and its variations are used in the control strategy for the trajectory following task shown in Fig. 4.

All the plots in this paper that track the robot’s CoM are produced using a tensegrity pose tracking algorithm we previously published  (?). This pose tracking algorithm also provides the ground truth for evaluating our state estimation experiments (Fig. 2 and Fig. S5). For the trajectory following experiments and the limbo demonstration, the algorithm was modified to run as a ROS service so it could be used online.

The pose tracking algorithm fuses sensor inputs from an RGB-D camera (Intel RealSense L515) and the on-board capacitive strain sensors described in section M1.3. The algorithm tracks the pose of the three tensegrity rods by observing the red, green, and blue colors of the end caps in the camera data. Information from the on-board sensors is weighted more by the algorithm when the end caps are heavily occluded, usually due to self-occlusions with the other rods. We manually give the algorithm the initial positions of the end caps by clicking on them in numerical order (0-5 in Fig. S4) on an image of the first frame of the RGB-D video. The pose tracking for all the locomotion trials was done offline so we could plot the CoM and calculate the speed.

For the trajectory following experiments and the limbo demonstration, the pose tracking service was run online in real time. The pose estimate was updated whenever the service received synchronized data from the ROS nodes publishing the RGB-D data and the robot’s on-board sensor data. After each gait cycle, the node controlling the robot requested the robot’s current pose from the tracking service. The robot’s pose was used to modify the next cycle of the gait appropriately based on the bottom face of the robot (SM section S6). The pose was also used for motion planning in the trajectory following experiments and to determine if the robot had gone past its endpoint on the other side of the bar in the limbo demonstration.

For the limbo demonstration, the pose tracking service is further augmented to perceive the height of the yellow bar. Each time the robot begins a segment of limbo, the robot control node sends a request to the tracking service for the bar height. The tracking service filters the latest RGB-D data for the yellow color of the bar and estimates the height with RANSAC. After the bar height is received from the tracking service, the robot shrinks to the appropriate size and adjusts the range of its gait (section M5) before beginning the limbo segment. All the pose tracking code can be found in the GitHub repository linked in our previous work  (?).

The simulation used in this work is a differentiable physics engine that we previously published  (?). The simulation was used to generate the clockwise and counterclockwise turning gaits discussed in section M3.2 and characterized in Fig. 3. It was also used to model all of the possible actions for the trajectory following experiments discussed in section M4 and shown in Fig. 4.

The clockwise and counterclockwise gaits were generated using a graph search with the principal axis rotation as the reward function  (?). To simplify the search, the targets lengths were constrained to either fully extended or fully contracted (i.e., $1$ or $0$). The gaits generated in simulation transferred to the real robot with only one modification to the third step in the clockwise turning gait. The simulation output was $[0,0,1,0,1,1]$, but for the gait to execute more reliably, it was changed to $[0,0,0.8,0,1,1]$. To achieve $[0,0,1,0,1,1]$, tendons A and B (see Fig. S4) would go to the minimum length (e.g., 100 mm) and tendon C would have to reach full extension (e.g., 200 mm). Depending on the range and tolerance used, these commands could produce a triangle inequality, which the robot could not possibly achieve. The modification, changing C’s target from $1$ to $0.8$, is designed to mitigate this issue.

The Real2Sim2Real pipeline we use with our differentiable simulator involves recording a trajectory on the real robot in order to perform system identification (sysID). Therefore, prior to the trajectory following experiments, we recorded a simple, open-loop locomotion trajectory on the substrate where the experiments would be conducted (vinyl dance floor; VEVOR) to identify the friction parameters for the robot on this substrate. More details about the sysID process can be found in our previous work  (?). After sysID, we modeled the robot’s full action space in the simulator and recorded the robot’s 2D transformations in a data table as described in section M4. The data table used for the trajectory following task is available in the supplementary data.

Throughout this manuscript, the robot’s locomotion gaits have been given based on its initial position with nodes 0, 2, and 5 touching the ground. However, when another face is downward, the gaits can be adapted using the robot’s symmetry. For example, the quasistatic rolling gait is given as $[[1,1,0.1,1,1,0.1],[0,1,1,0,1,0.1]]$ for when nodes 0, 2, and 5 are on the ground. In the second step—the rolling step—of the gait, the bottom two tendons (A and D) are fully contracted at 0, shrinking the polygon of stability to allow a roll. After one gait cycle where the robot rolls over, nodes 1, 2, and 5 will be touching the ground, and tendons C and F will be the bottom two. Therefore, the next two steps in the gait should be $[[1,0.1,1,1,0.1,1],[1,1,0,1,0.1,0]]$. The full quasistatic rolling gait is therefore

after which the robot has the same orientation since three rolls have been completed, and therefore this six-step gait can be repeated from the beginning.

In this way, any gait can be adapted to a different bottom face. This mapping is shown in Fig. S10A. As the robot rolls to the next face, the target lengths on each side (ABC vs. DEF) should be left-shifted by one. For example, if the gait is $[0,1,2,3,4,5]$ when the bottom nodes are 0, 2, 3, and 5, then that gait should be translated to $[1,2,0,4,5,3]$ when the robot is on the next face with nodes 1, 2, 4 and 5 closest to the ground. For the last face (nodes 0, 1, 3 and 4), the same gait would be $[2,0,1,5,3,4]$.

Using the same strategy, we can extend the clockwise turning gait from above, adapting it to the new faces in sequence after the robot rolls over. Therefore, the full clockwise turn in place gait (starting with nodes 0, 2, and 5 on the ground) is

after which the robot has rolled back onto its original face. Note that the clockwise gait rolls onto new faces in the opposite sequence compared to the quasistatic rolling gait, which is why the target lengths are right-shifted instead of left-shifted. The counterclockwise turning gait does not cause the robot to roll onto a new face, but it can still be adapted to different bottom faces via the same strategy.

The quasistatic rolling gait can also be modified so that the robot rolls in the opposite direction (Fig. S10B). The full gait to roll backward is

when starting with nodes 0, 2, 3, and 5 closest to the ground. The general mapping to reverse the quasistatic rolling gait is a function of the bottom nodes; the mapping can be found in the supplementary code.

The crawling-based turning gaits can be adapted to use the other side of the robot as the pivot foot. Using the right pivot, the crawling-based turning gaits are

for turning clockwise and

for turning counterclockwise. This reverse mapping for the crawling-based turning gaits is the same mapping for reversing the quasistatic rolling gait. Notably, the clockwise and counterclockwise turn in place gaits can also be reversed, and they still yield clockwise and counterclockwise turning, respectively.