A Simple Controller for Omnidirectional Trotting of Quadrupedal Robots: Command Following and Waypoint Tracking

Abstract

For autonomous legged robots to be deployed in practical scenarios, they need to perform perception, motion planning, and locomotion control. Since robots have limited computing capabilities, it is important to realize locomotion control with simple controllers that have modest calculations. The goal of this paper is to create computational simple controllers for locomotion control that can free up computational resources for more demanding computational tasks, such as perception and motion planning. The controller consists of a leg scheduler for sequencing a trot gait with a fixed step time; a reference trajectory generator for the feet in the Cartesian space, which is then mapped to the joint space using an analytical inverse; and a joint controller using a combination of feedforward torques based on static equilibrium and feedback torque. The resulting controller enables velocity command following in the forward, sideways, and turning directions. With these three velocity command following-modes, a waypoint tracking controller is developed that can track a curve in global coordinates using feedback linearization. The command following and waypoint tracking controllers are demonstrated in simulation and on hardware.

1. Introduction

For quadrupeds and legged robots to be practical in search and rescue, industrial, and home scenarios, they need to be able to follow high-level commands (e.g., moving forward and sideways as well as turning) and to perform high-fidelity tracking of waypoints for navigation in constrained environments. The availability of limited computational resources complicates on-board control. Although it is possible to add more computing resources, these would consume energy, thus, depleting the charge on the batteries.

There are two broadly used methods. One, use a model to generate controllers offline, save them on the robot hardware, and search and deploy the correct controller based on sensor data. This approach is computationally simple but may not generalize to novel scenarios that have not been tested in simulation. Two, use a numerical approach (e.g., optimization) to generate controllers on the fly. This approach generalizes to novel scenarios but is computationally more challenging.

In this paper, our goal is to create a computational simple trot controller for quadruped robots and demonstrate that it is capable of high-fidelity command following and waypoint tracking. Our trot controller relies on analytical solutions and simple matrix manipulations, thus, enabling quick computations. The controller is able to demonstrate omnidirectional walking (motion in the fore–aft, lateral, and yaw directions) and can be combined with an appropriate model for waypoint tracking (tracking a curve in horizontal space).

The paper is organized as follows. The review of related literature is found in Section 2. The low-level and high-level controllers are presented in Section 3 and Section 4, respectively. The simulation and hardware results are presented in Section 5, followed by the discussion in Section 6, and our conclusions and future work in Section 7.

2. Background and Related Work

One of the first papers on the dynamic movement of quadruped robots considered multi-leg control by extending the controller developed for balancing on one leg [1]. The controller comprises three decoupled modes with each one regulating a different aspect of the balance: (1) a foot-placement control in the flight phase for regulating the speed, (2) thrust in the telescopic leg during the stance phase for regulating the height, and (3) torque between the leg and body during the stance phase for regulating the torso attitude. When this one-legged controller is properly deployed between the four legs, it is possible to generate a trot, pace, and bounding gait. Other have extended these simple heuristics for galloping and bounding gaits [2].

There are various other heuristic approaches that have led to successful locomotion control. In virtual model control, the movement of the body is planned using virtual components, such as springs and dashpots [3]. The resulting forces in Cartesian coordinates are converted to joint torques using the Jacobian of the foot with respect to the joint angle [4]. In central pattern generators, neural networks are used to represent the control policy. The weights of the neural network are then tuned on the system in simulation and hardware to generate various gaits [5,6].

Model-based control approaches for locomotion are based on a simple reduced order model of the system. These models have, as its inputs, the ground reaction forces on the stance legs and foot placement in the swing phase. The ground reaction forces are computed to ensure periodicity [7] or are based on solving a model predictive controller to track a prescribed reference motion [8,9]. They, then, implement the resulting ground reaction force profiles and foot placement on the robot using a combination of feedforward and feedback torques.

The quality of the solution depends on the model simplification used. A simple approach is to linearize the dynamics and use automatic differentiator, such as CasADi, to compute the gradients [10]. Better approaches to linearization using exponential coordinates allow for a better approximation of the linearized dynamics [11]. Another approach is to use full nonlinear dynamics for control but use computationally simple approximations of the derivatives [12]. By adding an event-based model predictive controller, the controller is able to better handle friction constraints [13].

Model-free methods for locomotion are based on reinforcement learning. The goal is to train a neural network that takes in, as inputs, the position and velocity of the legs and torso and returns outputs of either the joint torques [14] or joint reference angles [15]. However, reinforcement learning is not sample efficient. To overcome this, one can seed the learning with samples from a motion-capture system [16] or learn in a lower-dimensional space, such as in the Cartesian space [17].

Another issue with such approaches is that policies learned in simulation do not transfer well to hardware. This is known as the reality gap. To narrow the reality gap, the system is trained in simulation by randomizing the model and the physical environments, expecting that randomization would capture the physics of the hardware [18]. A variant of this approach is to train two networks, one for the controller and the other for variability in the environment. During the runtime, the second neural network predicts the correct environment variables, which are then used by the first network for control [19].

A combination of model-based and model-free methods can overcome the limitations of both these approaches. One approach is to use reinforcement learning to generate an initial population of solutions for the model predictive controller [20]. This approach has been shown to generalize over a series of legged robots with minimal modification. Another approach is to use experimental data to improve the model, which then updates the model-predictive controller [21].

Using a locomotion control with speed and turning inputs, it is possible to do waypoint tracking. Such a controller would use exteroceptive sensors, which provide global reference positions and then use a simple proportional derivative control for tracking [22,23]. Additional control may add a predictive control layer that corrects the deviations due to process noise (e.g., unmodeled friction) [24]. Learning approaches to waypoint tracking have used a forward dynamics model learned from experiments that works with a sampling-based planner for path following [25].

In the last few years, there has been a spurt in the development of quadrupedal robots. Boston Dynamics SPOT is a commercially available quadruped but lacks an API for low-level control [26]. Anybotics ANYmal [27] and Unitree Robotics Go1, A1, B1, and Aliengo [28] are companies that sell quadrupeds that provide a low-level API for control. Open source quadrupedal platforms include the MIT mini cheetah [29], Stanford pupper [30], Stanford doggo [31], and Open Dynamic Robot Initiative [32]. The availability of highly capable quadrupedal platforms has accelerated the use cases of such robots in industry.

In this paper, a model-based approach is used for command following and waypoint tracking. Based on velocity commands, the controller generates paths for the feet in the Cartesian space. These paths are then mapped to the joint space using an analytical inverse. Using gravity compensation for the legs in swing and stance phases, analytical feedforward torques are obtained. These feedforward torques are combined with feedback torques to generate the trot gait.

With this low-level trot level control, it is shown that the movement of the center of mass of the quadruped and its orientation in the world space can be modeled using a simple high-level model, which can then be used for waypoint tracking. The main contributions of our work are as follows: (1) at the low-level, a simple trot controller based on analytical inverse kinematics and static-based feedforward torques ensures that computations are conducted, on average, in $0.5$ ms on a cheap on-board computer (Raspberry Pi, 2021); (2) at the high-level, a simple model enables high-fidelity waypoint tracking using feedback linearization; and (3) an experimental demonstration of the waypoint tracking controller on the A1 robot.

3. Low-Level Control

3.1. Hardware Platform

The hardware platform used in this work is the quadruped A1 by Unitree Robotics [28]. The robot has four legs, each with 3 degrees of freedom. Each leg has a mass of 2 kg, and the mass of the torso is $4.75$ kg. There is an encoder at each joint, an inertial measurement unit on the torso, and a touch sensor on each foot. The minimum and maximum torques on each joint are $-33.5$ and $33.5$ Nm, respectively. There are sensors to measure the motor current, which are calibrated to compute the joint torque. The control system has two levels: a raspberry pi at the top level and a custom motor controller at the bottom level.

The raspberry pi sends commands at a rate of 500 Hz to the custom motor controller. There are five commands that can be sent, and they include the torque, position gain, velocity gain, position set-point, and velocity set-point. The motor controller on the A1 proprietary controller runs at 10 KHz, and we do not have access to this. The robot uses Lightweight Communications and Marshalling (LCM) and User Datagram Protocol (UDP) for communication. We used a 12 camera Optitrack system that provides localization of the robot. The Optitrack system streams data through WiFi at about 300 Hz.

3.2. Overview

The low-level controller comprises a scheduler for coordinating the four legs and a torque-based controller for each leg. A finite state machine is used to program the low-level controller.

The legs are labeled as Front Right (FR), Front Left (FL), Rear Right (RR), and Rear Left (RL). For the trot gait, the combinations of FR–RL and FL–RR move together. This combination of legs will transition from swing to stance and stance to swing as a pair. The transitions take place at a fixed time. The low-level controller for a single leg is shown in Figure 1. This is described in detailed over the next few sections.

3.3. Cartesian Kinematics

The Cartesian kinematic block accepts inputs once per step, and it computes the fore–aft and lateral stepping lengths for the robot in the body frame. The body frame is defined as the frame that moves and rotates with the robot. The fore–aft direction is the x-direction, the lateral direction is the y-direction. The inputs to this block are the step time $t_s$, the fore–aft speed in the body frame is $v_x$, the lateral speed in the body frame is $v_y$, and the rotation in the world z-frame is $\omega$ (pointing in the direction opposite of gravity). The step length for each of the diagonal pairs of legs in the fore–aft direction is ${\ell }_x=v_x{t}_s$ and in the lateral direction is ${\ell }_y=v_y{t}_s$. However, for turning, the the rear legs have an additional lateral step length of ${\ell }_y=\omega t_s$.

3.4. Cartesian Reference Trajectory

The Cartesian reference trajectory generator block accepts inputs once per step, and it computes the fore–aft and lateral stepping trajectory as a function of time. The inputs to this block are the step length in the fore–aft direction ${\ell }_x$, step length in the lateral direction ${\ell }_y$, the leg height ${\ell }_z$, and the ground clearance in the z-direction, $h_{cl}$. Using a fifth order polynomial, this block outputs the Cartesian trajectory for the foot as a function of time ${\ell }_x\left(t\right)$, ${\ell }_y\left(t\right)$, and ${\ell }_z\left(t\right)$.

3.5. Inverse Kinematics

The inverse kinematics block takes, as its input, the Cartesian position of the foot in the body frame ${\ell }_x\left(t\right)$, ${\ell }_y\left(t\right)$, and ${\ell }_z\left(t\right)$ and outputs joint reference angles ${\mathbf{q}}_{\mathrm{ref}}\left(t\right)=\left[\begin{array}{c}{q}_0\left(t\right),q_1\left(t\right),q_2\left(t\right)\end{array}\right]$ and angular velocities ${\dot{\mathbf{q}}}_{\mathrm{ref}}\left(t\right)=\left[\begin{array}{c}{\dot{q}}_0\left(t\right),{\dot{q}}_1\left(t\right),{\dot{q}}_2\left(t\right)\end{array}\right]$. These angles are the thigh roll $q_0$, thigh pitch $q_1$, and calf pitch $q_2$ as shown in Figure 2.

If the Cartesian position of the foot is ${\mathbf{X}}_{\mathrm{ref}}=\left[\begin{array}{c}{\ell }_x,{\ell }_y,{\ell }_z\end{array}\right]$, then the forward kinematics model $\mathbf{f}$ may be obtained as ${\mathbf{X}}_{\mathrm{ref}}=\mathbf{f}\left({\mathbf{q}}_{\mathrm{ref}}\right)$. For a given reference position ${\mathbf{X}}_{\mathrm{ref}}$, the joint angle is obtained by inverting $\mathbf{f}$ as ${\mathbf{q}}_{\mathrm{ref}}={\mathbf{f}}^{-1}\left({\mathbf{X}}_{\mathrm{ref}}\right)$. The inverse, ${\mathbf{f}}^{-1}$, is obtained analytically as follows. For a given end-effector position of the foot, ${\ell }_x$, ${\ell }_y$, and ${\ell }_z$, the joint angles $q_0$, $q_1$, and $q_2$ may be found using the variables defined in Figure 2.

$$\begin{array}{c}\hfill \ell =\sqrt{{\ell }_x^2+{\ell }_y^2+{\ell }_z^2},\alpha ={sin}^{-1}\frac{{\ell }_x}{\ell },\end{array}$$

(1)

$$\begin{array}{c}\hfill \beta ={sin}^{-1}\frac{{\ell }_y}{\ell },\gamma ={cos}^{-1}\frac{2L^2-{\ell }^2}{2L^2}\end{array}$$

(2)

$$\begin{array}{c}\hfill q_0=\beta ,q_1=\alpha +0.5(\pi -\gamma ),q_2=-\pi +\gamma .\end{array}$$

(3)

Note that $\alpha$, $\beta$, and $\gamma$ are intermediate variables for making the formulas short and succinct. The Jacobian of the foot with respect to the joint angles may be computed as follows, $\mathbf{J}\left(\mathbf{q}\right)=\frac{\partial \mathbf{X}}{\partial \mathbf{q}}$. Once the reference joint angle is computed, the reference joint velocity is given as follows ${\dot{\mathbf{q}}}_{\mathrm{ref}}={\mathbf{J}}^{-1}\left({\mathbf{q}}_{\mathrm{ref}}\right){\dot{\mathbf{X}}}_{\mathrm{ref}}$.

3.6. Gravity Torque

The gravity torque compensation is used as a feedforward term for the swinging leg. The equation of motion of a single leg is given by $\mathbf{M}\left(\mathbf{q}\right)\ddot{\mathbf{q}}+\mathbf{N}(\mathbf{q},\dot{\mathbf{q}})+\mathbf{G}\left(\mathbf{q}\right)={Ø}$ where $\mathbf{M}$, $\mathbf{N}$, and $\mathbf{G}$ are the mass matrix, Coriolis term, and gravity torque, respectively. The feedforward torque in the swing phase is given by ${\tau }_{\mathrm{G}}=\mathbf{G}({\mathbf{q}}_{\mathrm{ref}}$).

3.7. Ground Reaction Forces

The ground reaction forces block computes reference reaction forces on the two legs in contact with the ground assuming static equilibrium (i.e., no acceleration). Consider a point-mass model of the robot shown in Figure 3. This model assumes massless legs and that all the mass is concentrated at the torso. The inputs to this block are the torso orientation as a quaternion $quat$ and all joint angles $\mathbf{q}$. The block outputs the reaction forces at the two feet $F_i$ and $F_j$ in the inertial frame (each force has x, y, and z components). Using the free body diagram, we have

$$\begin{array}{cc}\hfill {\mathbf{M}}_{\mathrm{tot}}\ddot{\mathbf{P}}& =F_i+F_j-m_{\mathrm{tot}}\mathbf{g}\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill \frac{d}{dt}\left({\mathbf{I}}_{\mathrm{tot}}\mathsf{\Omega }\right)& =r_i\times F_i+r_j\times F_j={\left[r_i\right]}_{\times }{F}_i+{\left[r_j\right]}_{\times }{F}_j\hfill \end{array}$$

(5)

where $r_i$ and $r_j$ are the position of the foot from the center of mass, and ${[vs.]}_{\times }$ is the vector v written as a skew symmetric matrix. The total mass is $m_{\mathrm{tot}}$, the corresponding mass matrix is ${\mathbf{M}}_{\mathrm{tot}}$, the inertia about the center of mass is ${\mathbf{I}}_{\mathrm{tot}}$, and the gravity vector is $\mathbf{g}$. Assuming that the torso has no linear acceleration, $\ddot{\mathbf{P}}=0$, or angular velocity, $\mathsf{\Omega }=0$, the above equations may be simplified to

$$\begin{array}{c}\hfill \mathbf{A}\mathbf{F}=\mathbf{b}\end{array}$$

(6)

where $\mathbf{A}=\left[\begin{array}{cc}\mathbf{I}& \mathbf{I}\\ {\left[r_i\right]}_{\times }& {\left[r_j\right]}_{\times }\end{array}\right]$ and $\mathbf{b}=\left[\begin{array}{c}{m}_{\mathrm{tot}}\mathbf{g}\\ \mathbf{0}\end{array}\right]$ where $\mathbf{I}$ is a $3\times 3$ identity matrix and $\mathbf{0}$ is a $3\times 1$ vector of zeros, vector $\mathbf{g}=\{0,0,g\}$, and $F=\left[\begin{array}{c}{F}_i,F_j\end{array}\right]$ is the $6\times 1$ unknown force vector. Using the pseudo inverse, ${\mathbf{A}}^{+}$, we solve $\mathbf{F}={\mathbf{A}}^{+}\mathbf{b}$.

3.8. Ground Reaction Torques

The ground reaction torque is used as a feedforward term to the leg on the ground. This block computes joint torques based on the ground reaction forces computed earlier. The ground reaction torque is given by ${\tau }_{GRF}={\mathbf{J}}^{T}F$ where $\mathbf{J}$ is the $6\times 6$ Jacobian.

3.9. Feedback Torque

The feedforward torques are supplemented with a feedback torque to achieve position control. This torque is given by ${\tau }_{\mathrm{fb}}=-{\mathbf{K}}_p(\mathbf{q}-{\mathbf{q}}_{\mathrm{ref}})-{\mathbf{K}}_d(\dot{\mathbf{q}}-{\dot{\mathbf{q}}}_{\mathrm{ref}})$ where ${\mathbf{K}}_p$ and ${\mathbf{K}}_d$ are the user-chosen position and derivative gains. These gains were manually tuned in the following fashion. We set $K_d=0.1K_p$. Then, we ramped up $K_p$ until we obtained a sufficiently fast response. This led to an overshoot of the position. Then, the derivative gain $K_d$ was independently increased to avoid the overshoot and to ensure critical damping.

3.10. Single Leg Implementation

The finite state machine keeps track of the stance and swing legs. For the trot gait, the diagonal legs coordinate together and switch between being the stance and swing legs based on a fixed step time $t_s$. This information is fed to the Cartesian trajectory generator to choose appropriate profiles for the legs and to the torque blocks to choose an appropriate torque. For the stance legs, the torque is given by $\tau ={\tau }_{\mathrm{grf}}+{\tau }_{\mathrm{fb}}$, and for the swing legs, the torque is given by $\tau ={\tau }_{\mathrm{G}}+{\tau }_{\mathrm{fb}}$.

4. High-Level Control

4.1. Overview

The high-level control runs at the frequency of a step, $t_s^{-1}$. The velocity inputs are in the frame of the torso, the body frame. The inputs to the high-level control are the fore–aft speed in the body frame $v_x$, the lateral speed in the body frame $v_y$, the angular speed in the world frame $\omega$, the leg height ${\ell }_z$, and the ground clearance $h_{cl}$.

In open spaces, the robot is ideally operated in the velocity command mode where $v_x$ and $v_y$ or $\omega$ are set by the operator (${\ell }_z$ and $h_{cl}$ are fixed). This allows the operator to intuitively control the robot. In constrained spaces, the robot needs to track suitable waypoints. These waypoints may be generated by the user or by a planner (e.g., A-star and RRT). Waypoint tracking takes place using feedback from the world coordinates of a suitable point on the robot ($x,y$) and the yaw angle of the torso ($\theta$). Using the commands $v_x$, $v_y$, and $\omega$, the controller can generate omnidirectional trotting.

4.2. High-Level Model

The robot has the ability to move in the fore–aft direction using $v_x$, in the lateral direction using $v_y$, and in the yaw direction using $\omega$. This enables omnidirectional movement. The equations for the combined motion are the combination of the differential drive car motion ($v_x-\omega$) [33,34] and puck motion ($v_x-v_y$) [35] and are derived next.

The overall movement of the robot in the world frame may be described by the position of a point mid-way between the rear two legs in the world frame $C\equiv (x_c$, $y_c$) and the orientation of the robot torso $\theta$ with respect to a suitably chosen reference x-axis in the world frame. Then,

$$\begin{array}{c}\hfill {\dot{x}}_c=v_{x}cos\theta -v_{y}sin\theta ,{\dot{y}}_c=v_{x}sin\theta +v_{y}cos\theta ,\dot{\theta }=\omega .\end{array}$$

(7)

We consider the user-chosen coordinates $X=(x,y,\theta )$. The coordinate C has to trace a given reference trajectory $(x_{\mathrm{ref}},y_{\mathrm{ref}},{\theta }_{\mathrm{ref}})$. This point is at a distance of $c_x$ and $c_y$ from C. Thus,

$$\begin{array}{cc}\hfill \mathbf{X}=\left[\begin{array}{c}x\\ y\\ \theta \end{array}\right]& =\left[\begin{array}{c}{x}_c\\ y_c\\ \theta \end{array}\right]+\left[\begin{array}{ccc}cos\theta & -sin\theta & 0\\ sin\theta & cos\theta & 0\\ 0& 0& 0\end{array}\right]\left[\begin{array}{c}{c}_x\\ c_y\\ 0\end{array}\right]\hfill \end{array}$$

(8)

taking the derivative of Equation (8) and then substituting values from Equation (7).

$$\begin{array}{cc}\hfill \dot{\mathbf{X}}=\left[\begin{array}{c}\dot{x}\\ \dot{y}\\ \dot{\theta }\end{array}\right]& =\left[\begin{array}{ccc}cos\theta & -sin\theta & -c_{x}sin\theta -c_{y}cos\theta \\ sin\theta & cos\theta & c_{x}cos\theta -c_{y}sin\theta \\ 0& 0& 1\end{array}\right]\left[\begin{array}{c}{v}_x\\ v_y\\ \omega \end{array}\right]=\mathbf{B}\mathbf{U}\hfill \end{array}$$

(9)

where $\mathbf{B}=\left[\begin{array}{cc}{R}_{\theta }& R_{0.5\pi +\theta }c\\ 0& 1\end{array}\right]$, $\mathbf{U}=\left[\begin{array}{c}{v}_x\\ v_y\\ \omega \end{array}\right]$, $R_{\theta }=\left[\begin{array}{cc}cos\theta & -sin\theta \\ sin\theta & cos\theta \end{array}\right]$, and $c=\left[\begin{array}{c}{c}_x\\ c_y\end{array}\right]$.

4.3. High-Level Control

The feedback linearization control is given by $\dot{\mathbf{X}}={\dot{\mathbf{X}}}_{\mathrm{ref}}+\mathbf{K}({\mathbf{X}}_{\mathrm{ref}}-\mathbf{X})$ where $\mathbf{X}=\left[\begin{array}{c}x,y,\theta \end{array}\right]$, $\mathbf{U}=\left[\begin{array}{c}{v}_x,v_y,\omega \end{array}\right]$, ${\mathbf{X}}_{\mathrm{ref}}=\left[\begin{array}{c}{x}_{\mathrm{ref}},y_{\mathrm{ref}},{\theta }_{\mathrm{ref}}\end{array}\right]$, and $\mathbf{K}$ is a $3\times 3$ user-chosen gain matrix. Solving for the control

$$\begin{array}{c}\hfill \mathbf{U}={\mathbf{B}}^{-1}\left({\dot{\mathbf{X}}}_{\mathrm{ref}}+\mathbf{K}({\mathbf{X}}_{\mathrm{ref}}-\mathbf{X})\right)\end{array}$$

(10)

5. Results

5.1. Command following

Figure 4a shows the robot-tracking reference velocities $v_x$ and $\omega$ similar to a differential drive car [33,34], and Figure 4b shows the robot-tracking reference velocities $v_x$ and $v_y$ similar to a puck [35] as a function of the step number in simulation. The actual velocity is shown as solid red continuous line, and the reference velocity is shown as a dashed black line.

5.2. Waypoint Tracking

The leminscate (infinity symbol) is used as the reference trajectory.

$$\begin{array}{c}\hfill x_{\mathrm{ref}}\left(\widehat{t}\right)=x_0+a\frac{cos\widehat{t}}{1+{sin}^2\widehat{t}}\end{array}$$

(11)

$$\begin{array}{c}\hfill y_{\mathrm{ref}}\left(\widehat{t}\right)=y_0+a\frac{cos\widehat{t}sin\widehat{t}}{1+{sin}^2\widehat{t}}\end{array}$$

(12)

where $x_0$, $y_0$, and a are suitable constants corresponding to the center and size of the lemniscate. The parameter $\widehat{t}=\frac{2\pi t}{t_f}$, where t is the time, and $t_f$ is the end time. From these equations, one can compute ${\dot{x}}_{\mathrm{ref}}\left(\widehat{t}\right)$ and ${\dot{y}}_{\mathrm{ref}}\left(\widehat{t}\right)$. The parameters were chosen as: $x_0=-2$ m, $y_0=0$, $a=2$ m, $c_x=0.05$ m, $c_y=0$, and $t_f=90$ s. We consider two cases: (1) varying yaw: ${\theta }_{\mathrm{ref}}\left(\widehat{t}\right)={tan}^{-1}\frac{{\dot{y}}_{\mathrm{ref}}\left(\widehat{t}\right)}{{\dot{x}}_{\mathrm{ref}}\left(\widehat{t}\right)}$ and (2) constant yaw ${\theta }_{\mathrm{ref}}\left(\widehat{t}\right)=\frac{\pi }{2}$. From these equations, the rate of change of the yaw can be computed as ${\dot{\theta }}_{\mathrm{ref}}\left(\widehat{t}\right)$.

Figure 5 shows the results for varying yaw, where (a) is the simulation and (b) is the experiment, and the results for constant yaw, where (c) is the simulation and (d) is the experiment. These results were generated using a gain ${\mathbf{K}}_{\mathrm{sim}}=3\mathbf{I}$ in simulation and ${\mathbf{K}}_{\mathrm{expt}}=1.5\mathbf{I}$ in hardware, where $\mathbf{I}$ is the $3\times 3$ identity matrix. We used an Optitrack motion-capture system consisting of 12 cameras to provide robot localization. The motion-capture system streams data at 300 Hz; however, we only need data at $t_s^{-1}=10$ Hz.

From (a) and (b), it can be seen that the tracking errors in simulation and experiments in $x-$, $y-$, and $\theta -$ are similar and within $\pm 0.05$. From (c) and (d), it can be see that the tracking errors in simulation and experiments in $x-$ and $y-$ are similar and within $\pm 0.025$, while those in $\theta -$ are marginally higher in simulation compared with in experiments. There is ringing in the $\omega$ command in simulations, which shows up as ringing in the tracking of $\theta -$. The differences in the simulation/experiments are likely due to modeling errors, including friction. Please see the video (Figure 6) that compares the experiments with simulations [36].

6. Discussion

This paper presented a computationally simple trot controller that uses analytical solutions for inverse kinematics and feedforward torques. The resulting controller enabled omnidirectional trotting: forward/backward ($v_x$), sideways ($v_y$), and angular or turning motion ($\omega$). Then, using the the three input commands ($v_x$, $v_y$, and $\omega$) and feedback linearization enabled waypoint tracking.

One of the advantages of legged locomotion over wheeled locomotion is the ability of legged robots to perform omnidirectional movement. Wheeled robots based on a steering drive and a differential wheel drive are subject to non-holonomic constraints, which prevent them from making sideways movements. In wheeled robots, this is overcome by using omni-directional wheels, which have rollers mounted on the wheels for sideways movement.

The morphology of the quadruped and the joint limits enable it to take larger steps and, consequently, to trot faster in the fore–aft direction compared with in the sideways direction. Thus, in order to move faster, it is more advantageous to turn in the direction of motion and use the fore–aft velocity command then to use the sideways mode of locomotion. However, in constrained spaces, it might be more advantageous to use the sideways mode of locomotion.

The low-level trot controller was based on analytical inverse kinematics, static-equilibrium-based feedforward compensation, and a simple proportional derivative position controller. This simple controller enabled fast computations on the hardware (worst case time of 2 ms but an average of $0.5$ ms on Raspberry PI). However, the use of static-equilibrium conditions to derive the controller also limited the speed of the robot to about 1 m/s in the fore–aft direction and $0.2$ m/s in the sideways direction with a 1 rad/s turning speed.

In order to increase the speed of the robot while using the same static-equilibrium conditions, one could change the step-level input $X_{\mathrm{ref}}$ from once per step to multiple times a step. This would enable increasing the feedback gain K and, hence, increase the speed of the robot.

7. Conclusions and Future Work

This paper demonstrated a simple trot controller with an analytical inverse and a combination of a static-equilibrium-based feedforward term and a position-velocity-based feedback term. The controller enabled versatile trot behaviors in the forward, backward, sideways, and turning directions, and all computations were conducted with an average time of $0.5$ ms. These trot behaviors—when suitably combined—can enable waypoint tracking. Future work will extend this to motion planning in constrained environments and to modifying the stepping control for disturbance rejection and high-speed navigation, including quick turning and quick acceleration.