First do not fall: learning to exploit the environment with a damaged humanoid robot

Humanoid robots could replace humans in hazardous situations but most of such situations are equally dangerous for them, which means that they have a high chance of being damaged and fall. We hypothesize that humanoid robots would be mostly used in buildings, which makes them likely to be close to a wall. To avoid a fall, they can therefore lean on the closest wall, like a human would do, provided that they find in a few milliseconds where to put the hand(s). This article introduces a method, called D-Reflex, that learns a neural network that chooses this contact position given the wall orientation, the wall distance, and the posture of the robot. This contact position is then used by a whole-body controller to reach a stable posture. We show that D-Reflex allows a simulated TALOS robot (1.75m, 100kg, 30 degrees of freedom) to avoid more than 75% of the avoidable falls.


I. INTRODUCTION
Humanoid robots are some of the most versatile machines ever designed [1]. They can grasp, pull, push, hold, reach for both low or high places, but they can also walk, climb stairs or crawl in a tunnel. Thanks to their small footprint, they can navigate in narrow spaces, and, more generally in all the environments designed for humans.
This versatility makes humanoids ideal machines to be deployed in risky and complex situations, like industrial disasters or space operations, during which more versatility means a higher probability of having the right set of capabilities to solve the problem at hand [1], [2]. This contrasts with industrial robots, which are designed to perform the same set of tasks continuously in a well-defined environment.
Nevertheless, the versatility of humanoid robots comes at the cost of an increased fragility: they have more joints that most robots and a single joint failure often results in a fall [2]. This fragility is especially concerning because humanoid robots would be the most useful in situations that are too dangerous for humans, which are likely to be equally dangerous for a robot. A deployed humanoid robot is therefore likely to be damaged during some of its missions.
The traditional approach for robot damage recovery is to identify the damage, update the model, then use the updated model to perform the tasks [3]. Unfortunately, a falling humanoid robot has only a few milliseconds to take a decision, whereas identifying the dynamical model of such *Experiments presented in this paper were carried out using the Grid'5000 testbed, supported by a scientific interest group hosted by Inria and including CNRS, RENATER and several Universities as well as other organizations (see https://www.grid5000.fr). This project is supported by the CPER SCIARAT, the CPER CyberEntreprise, the Direction General de l'Armement (convention Inria-DGA "humanoïde résilient"), and the Creativ'Lab platform of Inria/LORIA. 1 Inria Nancy -Grand Est, Université de Lorraine, CNRS. Contact: firstname.name@inria.fr Without reflex the robot falls By putting its hand on the wall the robot avoids the fall

Whole-body controller
We detect an unexpected leg damage (here: lower leg amputation) but we don't know how to update the robot model Fig. 1: A humanoid robot detects an unexpected damage on one of its leg. If it does nothing, it falls; but it can recover its stability by putting its "hand" on the wall at the appropriate location (depending on its posture, the wall distance, and the wall orientation).
a highly redundant robot requires extensive data and specific trajectories [3], [4]. More importantly, an updated model with a control algorithm would make it possible to move the damaged robot to a specific posture, but it would not be able to decide what is the target posture to avoid the fall given the context: this is a search problem that is unlikely to be solved in a few milliseconds. A few learning-based damage recovery algorithms for 2-legged [5], 4-legged [6], [7] or 6legged robots [8]- [10] were recently published, but they all assume that the robot can try a behavior, fall, and try again until it finds a compensatory behavior. Humanoids usually cannot afford falling, and trial-and-error would require an ability to stand-up without a perfect knowledge of the robot model, which is very challenging. Given the envisioned missions, humanoid robots are more likely to be used in indoor environments, for instance in damaged buildings, than in open fields. As a result, these robots are likely to have walls or furniture within reach: taking inspiration from human reflexes, a promising strategy in case of leg damage is therefore to lean on the nearest wall to avoid the fall.
In this article, our main contribution is a method that allows damaged humanoid robots to avoid many falls by leaning on a nearby wall (Fig. 1). Once the robot is stable, another algorithm could update the model and activate compensatory behaviors (e.g., walking on one leg using the wall). Our main assumptions are that (1) we know which joint are not responding but we do not know if the faulty parts are missing or if the actuator is simply disconnected from power; this means that we do not know the exact model of the damaged robot but we know where the damage is located (2) we know the distance and the angle to the nearest wall (for instance with a dedicated sensor on the shoulder), and (3) the robot is controlled with a whole-body controller [11], [12]. With these assumptions, our method, called D-Reflex (for "Damage-Reflex"), finds in a few milliseconds where to put the hand on the wall and reach a stable state.
The main idea of D-reflex is to learn a neural network that predicts the success chance of each potential contact location on the wall given a posture and a wall configuration. This neural network is learned with supervised learning using a dataset created by simulating many situations and many potential contact positions. Splitting the process into these two steps-create a dataset in simulation, then learn a predictormakes it possible to exploit the mature and well-understood supervised learning algorithms while separating the learning process from the simulation process. Once learned, the neural network can be queried in a few millisecond, which is ideal for a fast emergency reflex.

A. Multi-contact planning and damage identification
Multi-contact planning, for instance choosing to put a hand on a wall, has been a long-lasting research topic of the humanoid robotics community (e.g., [14], [15]). However, planning algorithms tend to require more than the few milliseconds that a falling humanoid robot can afford. In addition, all planning algorithms assume a known model of the dynamics, which is not the case when the robot is damaged, whereas the dynamics of the fall is typically very different with a damaged robot.
A preliminary step to any planning algorithm is therefore to identify the model of the damaged robot [3]. Unfortunately, identifying the dynamical model of a humanoid requires at least several minutes of data collection and specific "exciting" trajectories. For example, Ramuzat et al. [4] identified the TALOS robot's [13] elbow joint: the identification of only one actuator required 230s of data collection and a well-chosen exciting trajectory. It seems highly optimistic to be able to identify a new model with a few milliseconds of sensor data. Overall, we see the present contribution as a preliminary step to a system identification step: the robot takes an emergency decision, then, once stable, it can get data to identify the new model and rely on model-based planning or control algorithms with an updated model.

B. Fall and damage mitigation
Inspired from how humans react when falling in front of a wall, Cui et al. [16] recently proposed to move the robot arms in a way that maximizes the ellipsoid stiffness, thus increasing stability and shock absorption. Compared to the present work, Cui et al. only worked on collisions with a frontal wall and, more importantly, with an intact robot whose model is known.
When the fall is inevitable, several methods have been demonstrated on different humanoids to mitigate the damage.
During the "pre-impact" phase, the robot adapts its posture by avoiding hand-designed "fall singularities" postures that increase the impact [17], by seeking to take a safe posture when falling on the back [18], or, by performing a rollover strategy [19]. During the "impact-time" phase, the PD-gains are automatically adapted by incorporating them in the QPcontroller to prevent the actuators from reaching their torque limits while still reaching the desired posture [20]. During the "post-impact", a force distribution quadratic-program distributes the exceeding linear momentum gathered during fall into the different body parts [21]. These methods do not try to avoid the fall but mitigate the damage induced by the fall. Overall, this line of work is complementary to ours: while many falls can be avoided by adding a contact to the wall, there are falls that cannot be avoided in that way and the only behavior left is to mitigate the damage.

C. Machine learning for damage recovery and mitigation
A promising approach to allow robots to adapt to unforeseen damage is to learn dynamical models with generic machine learning methods, like neural networks or Gaussian processes. To minimize the amount of data required, current methods leverage a simulation of the intact robot [10] or meta-learning to train the model for fast adaptation [6], [7], [9]. Successful experiments with 4-legged [6], [7] and 6legged [9], [10] have been reported, but, to our knowledge, not with 2-legged robots. One important difference between humanoids and other multi-legged robots is that the latter can afford to fall during learning because getting up is easy.
Spitz et al. [5] investigated how a damaged humanoid robot can adapt its behavior by avoiding states that previously led to a fall. Similarly, Cully et al. [8] designed a learning algorithm that allows a damaged 6-legged robot to find a new behavior that does not rely on the damaged parts. In both cases, the authors used an episodic setup in which the robot can try a behavior, fall, and try again many times. This setup is not applicable when the objective is to avoid the fall immediately after a damage.
To our knowledge, the closest work to ours is for a quadruped robot that performs "cat-like" acrobatics to land on its feet when falling from several meters [22]. To solve this problem, the authors used a trajectory optimization algorithm to generate a dataset of examples in simulation, then they trained a neural network policy that imitates these reflexes but is fast enough to be used on the real robotic platform. Similarly, the D-reflex approach first solves the problem with extensive simulations, then use the results of these simulations to train a fast neural network that selects the most appropriate behavior.

A. Considered Damage Conditions
A robot can be damaged in many ways and we often cannot determine them precisely. In the remainder of the paper, if not specified, we use two kinds of damage conditions: amputation (missing parts) and passive actuators (the actuators do not deliver any torque, i.e., the joints can turn freely in the corresponding axis). These two damage conditions are critical for the stability of the robot and very often result in a fall when applied to one of the leg, but they cannot be distinguished by querying the control board of each joint: in both cases, the control boards do not answer. Other possible damage conditions are a blocked joint, which usually do not make the robot fall (because the humanoid is usually kept in static balance) and bending links (which is very unlikely on current robots).
To show that our method is not specific to one set of faulty joints, we consider two different sets J which are critic to the robot stability: (1) the whole leg (hip to ankle), and (2) the lower leg (knee to ankle). More combination of joints can easily be added, with similar results in our preliminary experiments. We chose these two particular joint sets because actuators are usually chained (e.g., when the knee loses power, the ankle often loses power too) and there is no way to amputate the knee and not the ankle.

B. Formulation
A humanoid robot suffers an unexpected damage on one of its legs which would result in a fall if nothing is done. The goal is to find a contact position on the wall that allows the robot to avoid the fall and stay stable (Fig. 1).
We know: • the set of faulty of joints J: we assume that the faulty joints control boards do not answer; • the presence of a plane wall within arm's reach, its distance d and its orientation α with regard to the robot (this position can be easily known with a RGB-D sensor on the shoulder of the robot and fitting a plane to the point cloud); • the current posture q of the robot when the fault is detected.
We do not know: • the nature of the damage condition: the leg could be fully amputated, but it could also have lost the power; • the successful contact positions on the wall (there are usually several possible successful contact positions).
We want to learn a function f J : (q, d, α) → (x * , y * ) specific to a set of faulty joints J that returns a successful contact position robust to the nature of the damage condition. We assume that the robot has a controller that can make it move to reach this position.

A. Whole-body Control
The humanoid robot is controlled with a whole-body controller (WBC) based on quadratic programming [11], [12]. At each time-step, the robot searches for the acceleration of each joint that minimizes a sum of quadratic cost functions constrained by the dynamical model of the robot (an equality constraint) and other equality/inequality constraints: where τ * andq * are the optimal joint torques and accelerations, w k is the weight of the task k described by A k (q,q) and b k (q,q), M is the joint-space mass matrix and F contains all the non-linear terms (Coriolis, centrifugal, gravity and contacts).
In this work, we used the controller described in Dalin et al. [12]. The main tasks are the Cartesian position and orientation of the hands and feet, the position of the center of mass, and a default postural task which is used to ensure the unicity of the QP problem and bias towards a "neutral" position. The constraints are the contact of the feet with the floor and the joint position, velocity and acceleration bounds.
Once the optimal torque and joint accelerations are computed, we integrate them using the model of the robot to get the desired joint positions, which we pass to the low-level joint controllers. In the real TALOS robot, the joint controller are PID controllers implemented on Ethercat boards [13]. In simulation, we use a Stable-PD controller [23] that leverages the model of the robot to compute torques given a position target, which is in our experience a good approximation of well-tuned PID controllers.
Please note that the model used by the controller is not updated after the damage because we do not know which model to choose between amputation or passive joint. As a result, the controller makes the robot moves in an unexpected way and needs to be simulated in a dynamics simulator.

B. Data Collection
For one set of faulty joints J, the first part of the process consists in generating random configurations of the wall and postures of the robot, and to collect the corresponding truth value of contact positions (Fig. 2, part 1).
1) Sampling random configuration: To randomly sample plausible random postures of the robot, we first randomly sample target hands positions in a cuboid facing the robot. We set these targets in our whole-body controller as Cartesian tasks and let it run for 4s which makes the robot take a posture q. Each random hand position induces a different but feasible posture, such as knee bending to reach lower position or rotated torso with arms raised.
2) Sampling wall positions: We need random wall configurations (distance d and orientation α) that are within arm's reach but that do not collide during the initial motion to reach the target posture (because this would make the robot fall before any damage). To ensure this property, we exclude wall configurations that collide during the first 4s of motion.
3) Construction of contact maps: Once we have the posture of the robot q and the wall configuration (distance d and orientation α), we discretize the wall's plane and run the simulation for each considered contact positions by (1)

C. Training
Once we have a dataset D J of samples (q, d, α, M), we want to learn the function where (x * , y * ) is a successful contact position in the wall referential. As the contact map M often contains several successful contact positions, we cannot directly learn f J .
Instead, we learn the classification function that predict the success of each input point: where c ∈ [0, 1] represents the confidence of the contact position (x, y) to be a successful contact position.
To estimate this classification function C J , we train a neural networkĈ J θ parameterized by the set of weights θ using PyTorch with Cross-Entropy error and the Adam optimizer. After performing extensive random search on the hyper-parameters, we have selected a fully-connected feed-forward neural network with 2 hidden layers of 1024 units with ReLU activation function, a dropout of 0.2 and a learning rate of 10 −5 . We obtained similar results with other combinations of network architecture, cost function, and optimizer.
To get an estimation of the function f , we query the neural network with points (x, y) ∈ (X,Y ) on the wall and select the point with the highest activation: Since the points are 2-dimensional and there is no need for a millimeter-scale precision, this optimization can be effectively performed using a straightforward grid search. In that case, it typically requires a few hundreds calls to the neural network (e.g., 441 calls for a 21 × 21 grid), which is easily done in parallel on modern GPUs (about 4ms for 441 queries on a Nvidia RTX 2080).
In supervised learning, we would periodically evaluate the prediction score of the neural network on the validation set to avoid overfitting and select the final set of weights. Here, the utility of our learned neural-network is measured by the effectiveness of the selected contact position, which we evaluate by running a simulation with a damaged robot. In other words, we evaluate the neural network by looking atf J (q, d, α) on the validation set instead of the traditional C J θ (q, d, α, x, y) because we want to evaluate the "end product" and not the neural network itself. At the end of the optimization, we select the set of weights θ that corresponds to the highest success rate on the validation set (Figure 2.2).

D. Inference
During its mission, the robot performs its tasks and detects a damage in one of its leg by querying the boards periodically. We get the last known posture of the robot q, the distance d, and orientation α to the closest wall. For this preliminary work, we hypothesize that the robot can evaluate α and d with a dedicated sensor.
We query the learned modelĈ J θ for a grid of points to estimate the best contact position (x * , y * ) =f J (q, d, α). Fig 3 shows examples of predicted contact maps. We then add a contact constraint in the whole-body controller at that position so that it puts its hand on the wall to recover its balance (Fig. 2.3).
E. Implementation 1) Triggering the reflex: We assume that the robot knows when an actuator is faulty so that we can instantly trigger the reflex. We remove the foot contact constraint and foot position task of the faulty leg, so that the controller does not put the weight of the robot on it. We also put the robot in an "urgent mode" that removes the non-essentials tasks: we only keep the foot contact constraint of the other leg, the bounds constraints, the position task of the Center of Mass (CoM), and the postural task. Finally, we add the hand contact constraint at the selected location on the wall.
The CoM task requires a Cartesian position. By default the target position is between the two feet. In our case, we hypothesize that a single leg is working, but, since we want a contact on the wall, the new CoM target should be somewhere between the remaining foot and the contact point. However we do not know the real contact position because the model is incorrect. After some preliminary experiments, we have decided to not change the CoM target as it has shown good result: if we put the CoM target on the remaining foot or too close to the wall the success rate declined significantly. A better solution would be to learn the CoM target in addition to the hand contact position, which we will explore in future work.
2) Post-contact updates: We empirically found that, due to the mismatch between the incorrect model and the simulated damaged robot, the desired contact point is rarely the real contact point attained by the hand. To take this into account, we use the force sensor of the wrist to detect the contact between the hand and the wall, then we update the contact constraint to stop the robot from moving its hand further, which would result in the robot pushing on the wall, bouncing back and more likely to fall.
To absorb the shock of the impact, we adjust the K p parameters of the arm in our Stable-PD controller so that the robot is less stiff. We use a exponential law that decreases the kp to a low value instantly when the contact is detected and then exponentially increases it back to its default value. We decrease the kp at when the contact is detected instead of when damage is detected because otherwise the motion of the arm is slower and, consequently, the robot falls for a longer time. If we let the kp too low afterward the arm doesn't hold under the robot weight and the robot falls against the wall.
We found empirically that these two implementation details only slightly increase the success rate of our method (a few percents). We kept them because they are straightforward to implement. On the real TALOS robot, we cannot change the PID coefficients online and the robot will have to stay stiff.

V. EXPERIMENTS
We control 30 degrees of freedom of the TALOS robot [13]: 7 for each arm, 6 for each leg, 2 for the torso, and 2 for the head. We replaced the gripper with a ball in our simulation to be close to the future experiments on the real robot (to avoid breaking the gripper), but similar results are obtained with a simulated gripper. The robot is simulated using the DART physics library [24] through the RobotDART simulator 1 .
The initial posture of the robot is obtained by selecting random target positions for the hands and letting the wholebody controller reach this target in 4s. The target positions are inside the cuboid: [−0.1m, +0.2m] in the sagittal axis, [−0.4m, +0.4m] on the frontal axis and [−0.5m, +0.4m] on the longitudinal axis. The wall distance is sampled between 0.4m and 1m. The orientation is sampled between −1rad and 1rad.
The contact maps of the dataset uses 21 positions in the horizontal and vertical axis, which results in 441 positions. They range from −0.75m and +0.75m in the horizontal axis and −0.5m and +0.75m in the vertical axis. Fig. 3 shows examples of contact maps.
We select a set of faulty joints J, either the whole leg or the lower leg. A different network is learned for each of the two sets J. We only perform the experiments on the right side of the robot (damaging the right leg and seeking contact with the right hand). The robot being perfectly symmetrical, the data and the same neural network can be used for the other side.
For each set of faulty joints, we sample 1000 different combinations of wall configuration and robot posture. We let the simulation run for 4s, after which we trigger one of the two damages: passive or amputation. We stop the simulation after 15s or until a fall is detected. This gives us 2000 different combinations. For each combination, we create a discretized contact map. This dataset requires thus 882,000 simulations of 15s, which we run in parallel on a multicore computer in less than 3 days.
The source code to reproduce the experiments is available online 2 .

A. Baselines
We compare against two baselines: • No Reflex: we do nothing, to highlight the importance of a reflex strategy; • Random Reflex: we select at random the contact position on the wall, to highlight the difficulty of the problem and the necessity of learning.  Fig. 3: Examples of damaged configurations and corresponding contact or falling postures using D-Reflex on the TALOS [13] humanoid platform. We also show the contact map estimated by our neural network and the true contact map measured but unknown during training. We present two damage conditions: passive (left) and amputation (right), on two set of faulty joints: the lower leg (top) and the whole leg (middle). We distinguished two kinds of unsuccessful recoveries: when the predicted contact map is two smooth and optimistic compared to the truth (left), and when there is no successful contact point, i.e., the fall is unavoidable by seeking a contact on the wall, due to the particular wall configuration and robot posture (right).

B. Ablations
To understand the contribution of each part we also compare against 3 "ablation experiments": • Posture Ablation: we remove the posture q from the neural network inputs and re-train the network (this allows us to answer the question: "does the contact position depend on the posture?"); • Wall Ablation: we remove the wall configuration (distance d and orientation α) from the neural network inputs and re-train the network ("does the contact position depends on the wall position?"); • Both Ablations: the contact point is independent from both the robot posture and the wall configuration ("is there a solution that works for any wall configuration and robot posture?"). In this case, we do not train a neural network but instead we use the training data to select the average best contact position.

C. Evaluation
By analysing the the contact maps, we found that for about 50% of the conditions of the dataset (50.6% for the whole leg and 45.1% for the lower leg), there is no position of the hand on the wall that prevents the fall. of such unavoidable situations, which are mostly caused by postures close to the floor and a wall being behind the robot. Moreover, in many cases, only a few sparse contact positions of the 21 × 21 grid allow the robot to avoid the fall. We consider that these contact positions are unlikely to exist with a real robot and are most likely to be due to a combination of "chance events" that is very sensitive to simulation details. Overall, only 29% of the simulated falls are realistically avoidable for the whole leg and 31% for the lower leg. As a consequence, we define a fall as "avoidable" if and only if the corresponding combination of wall configuration and robot posture leads to at least 9 (one position and its 8 neighbors on a grid) contiguous successful contact positions. Our analysis is focused on these "avoidable situations" because it is straightforward to generate an arbitrarily high number of non-avoidable situations and thus make the avoided fall rates arbitrarily low.
We randomly split this dataset into training (37.5%), validation (12.5%) and evaluation (50%). To ensure that our results do not depend on a single, lucky run of the learning algorithms, we replicated the learning algorithm 25 times using 25 different splits of our dataset and different seeds. 1) Our method: D-Reflex allows the TALOS robot to successful recover from the fall for about 75-80% of the avoidable conditions (medians: 81% for the whole leg damage, 77% for the lower leg, Fig. 4). Fig. 3 showcases some examples of successful recoveries as well as some typical failures. Failure cases mostly happen when the neural network overestimates the size and the smoothness of the possible contact zone (Fig. 3, bottom); more tuning of the learning process or using another regression technique (e.g., random forests) could lead to successful contact zones that are less smooth and more accurate, with the same training data. Overall, our approach significantly increases the likelihood of avoiding the fall and thus prevents the robot from being more damaged (which could be very costly) and allows it to finish its mission in spite of the damage (especially if the robot has access to a walking strategy that uses the wall to walk with a missing leg).

D. Results
2) Baselines: Doing nothing (stopping the robot) results in a low success rate (between 20% and 40% of the avoidable falls). It is not zero because the wall is on the same side as the damaged leg, therefore the robot can sometimes fall directly on the wall, on its arm or shoulder, and end in a stable position. Using a random contact position results in a lower success rate (between 15% and 25% of the avoidable falls) because moving the arm randomly creates unnecessary motions that decrease the stability of the robot. This two cases shows the need for a reflex.
3) Ablations: When both the wall configuration and the robot posture are ignored to choose the contact point ("Both Ablations"), the robot avoids between 40% and 50% of the avoidable falls. This corresponds to choosing the best point on average of the wall training set, which is on the middle of the wall. This demonstrates that the neural network does more than choosing the same "average position". Between the wall configuration and the robot posture, the wall configuration is more important than the posture (Fig. 4). The posture might, however, be critical to choose between leaning on the wall and activating an alternative strategy, for instance to limit the damage of the fall [17], [20].

4) Damaged Body parts:
In all the considered cases, the robot recovers more often when the whole leg is removed than when it is only the lower leg (an increase of the success rate of about 5%). This can be explained by the fact that the robot's center of mass shifts more towards the remaining foot when the whole leg is amputated, which decreases the speed of the fall and reduces the impact.

E. Use of the updated model in the whole-body controller
In these experiments, the whole-body controller uses the model of the intact robot to compute the joint angles of the damaged one: we assumed that the model of the damaged robot was not known during the fall avoidance phase and therefore we could not use an updated model. Nevertheless, as a baseline, we checked what happens when we use the model of the damaged robot when generating the dataset; we replicated the learning 25 times, but we only considered the amputated lower leg damage condition.
The results show that the results are statistically equivalent to those obtained when the controller uses the model of the intact robot (median fall avoidance rate: 80.7%[77.8%, 82.7%] for the intact model versus 82.3%[78.5%, 83.8%] with the updated model). This lack of difference is due to the fact that our method looks at the result of a simulation to decide on the success of a particular location on the wall, and not at how well the robot performs an expected motion. Put differently, a controller with an updated model is likely to put the robot's hand closer to the target location, whereas it often misses this target when using the model of the intact robot; but this does not matter because what is stored is the success (fall avoidance) for a target, regardless of where this target actually leads on the wall. This means that the whole-body controller is used to generate a trajectory and the simulator tells the algorithm whether this trajectory is successful or not: generating this trajectory differently does not fundamentally changes the result. Similarly, a planning or model-predictive control algorithm [22], [25] could be used instead of our whole-body controller to generate these trajectories: we do not expect any significant change in the result because an algorithm will still be needed to choose where to put the hand, which is the problem solved by D-reflex.

VI. CONCLUSION
Given the robot posture and the configuration (distance and orientation) of a wall within arm's reach, our method, D-Reflex, uses a trained neural-network classifier to estimate a contact position that allows the robot to avoid the fall in more than 75% of the avoidable cases. Our method is robust to two different damage conditions (passive actuators and amputation), and does not require the knowledge of the correct damaged model of the robot. It relies on a wholebody controller that is already working in the TALOS robot [12] and sensory information that is easy to acquire, therefore it should be able to work on a real damaged TALOS.
Once stabilized, the robot will need to update its model and its position so that it can be controlled again. Numerous model identification methods can be investigated [3]. The robot can then continue its mission in spite of the damage.
The main assumption of this work is that there exists a wall next to the robot. In future work, we will extend our method to select target contact positions for the hands in more complex environments (other walls, furniture, ...). In that case, we would not be able to cover the possible contact positions with a simple 2D grid: the main challenge will be to build a dataset that includes successful contact positions.