Dynamic Programming Controller

Abstract

A dynamic programming controller (200) receives a manipulation (210) and a current state (202) and converts the manipulation and the current state into a nonlinear optimization problem (222). The nonlinear optimization problem is configured to optimize an unknown force and an unknown position vector. At a first time instance (Ii, to), the controller linearizes the nonlinear optimization problem into a first linear optimization problem and determines a first solution (232) of the first linear optimization problem using quadratic programming. At a second time instance (h, ti), the controller linearizes the nonlinear optimization problem into a second linear optimization problem based on the first solution and determines a second solution of the second linear optimization problem based on the first solution using quadratic programming. The controller also generates joint commands (204) based on the second solution to control the movement of the robot during the manipulation.

Description

Technical Field

[0001] The present disclosure relates to a dynamic programming controller. Background Art

[0002] A robot is generally defined as a reprogrammable and multifunctional manipulator that is designed to move materials, parts, tools, or specialized equipment for the performance of a task through variable programmed motions. A robot can be a physically anchored manipulator (e.g., an industrial robot arm), a mobile robot that moves throughout an environment (e.g., using legs, wheels, or grip-based machinery), or some combination of a manipulator and a mobile robot. Robots are used in a variety of industries, including, for example, manufacturing, transportation, hazardous environments, exploration, and medical. Therefore, the ability to program robots to perform a variety of behaviors in a fast and efficient manner provides additional benefits to these industries. Summary of the invention

[0003] One aspect of the present disclosure provides a method for a dynamic planner. The method includes receiving a manipulation of a legged robot and a current state of the legged robot at data processing hardware. The manipulation includes one or more movement events to be performed by the legged robot. The method also includes converting the manipulation of the legged robot and the current state of the legged robot into a nonlinear optimization problem by the data processing hardware. The nonlinear optimization problem is configured to optimize unknown forces and unknown position vectors. At a first time instance, the method includes linearizing the nonlinear optimization problem into a first linear optimization problem by the data processing hardware, and determining a first solution to the first linear optimization problem by the data processing hardware using quadratic programming. At a second time instance after the first time instance, the method includes linearizing the nonlinear optimization problem into a second linear optimization problem based on the first solution of the first time instance by the data processing hardware, and determining a second solution to the second linear optimization problem based on the first solution using quadratic programming. The method also includes generating joint commands by the data processing hardware based on the second solution to control the movement of the legged robot during manipulation.

[0004] Embodiments of the present disclosure may include one or more of the following optional features. In some embodiments, the method includes determining a composite solution by data processing hardware based on the second solution and the forward dynamics of the legged robot, and determining by the data processing hardware that a comparison between the composite solution and the second solution satisfies an optimization threshold. In this embodiment, the optimization threshold indicates the accuracy with which the corresponding solution generates joint commands. Comparing the composite solution with the second solution (i.e., the optimized solution) provides a measure of the accuracy of the linearization. That is, whether the solution to the linear problem is also the solution to the original nonlinear problem.

[0005] In some examples, at the second time instance, the method includes determining, by the data processing hardware, that the second solution does not satisfy the nonlinear constraint and generating an iterative constraint for the second linear optimization problem. In this example, the iterative constraint includes a linear constraint based on the second solution not satisfying the nonlinear constraint. Here, at the second time instance, the method also includes updating, by the data processing hardware, the second solution to the second linear optimization problem using a quadratic program that includes the iterative constraint.

[0006] In some configurations, the unknown force corresponds to a force at a foot of the legged robot when the legged robot performs a manipulation. The unknown position vector may correspond to a position of a body of the legged robot relative to a foot of the legged robot when the legged robot performs a manipulation. Each of the first solution and the second solution may include a contact force of one or more legs of the legged robot against a surface, a ground contact position of one or more legs of the legged robot, a ground contact position of one or more legs of the legged robot, a ground contact time of one or more legs of the legged robot, or a ground lift time of one or more legs.

[0007] In some embodiments, the method includes instructing, by data processing hardware, a joint of at least one standing leg of the legged robot based on a joint command, the joint command including a joint torque of the joint of the at least one standing leg. Here, the method may include generating, by the data processing hardware, a joint torque of the joint of the at least one standing leg by determining that a contact force corresponding to a second solution of the at least one standing leg satisfies a torque limit constraint of the at least one standing leg and a friction constraint of the at least one standing leg.

[0008] In some examples, the legged robot corresponds to a quadruped robot.Receiving the manipulation may include receiving the manipulation from a user device in communication with the data processing hardware, and the manipulation may be defined by a user of the user device at a user interface running on the user device.

[0009] Another aspect of the present disclosure provides a robot. The robot includes a body, two or more legs connected to the body, and a control system that communicates with the body and the two or more legs. The control system includes data processing hardware and memory hardware that communicates with the data processing hardware. The memory hardware stores instructions that, when run on the data processing hardware, cause the data processing hardware to perform operations. The operations include receiving a manipulation of the robot and a current state of the robot, the manipulation including one or more movement events to be performed by the robot. The operations also include converting the manipulation and current state of the robot into a nonlinear optimization problem. The nonlinear optimization problem is configured to optimize unknown forces and unknown position vectors. At a first time instance, the operations include linearizing the nonlinear optimization problem into a first linear optimization problem, and using quadratic programming to determine a first solution to the first linear optimization problem. At a second time instance after the first time instance, the operations include linearizing the nonlinear optimization problem into a second linear optimization problem based on the first solution of the first time instance. At a second time instance after the first time instance, the operations also include using quadratic programming to determine a second solution to the second linear optimization problem based on the first solution, and generating joint commands based on the second solution to control the movement of the robot during manipulation.

[0010] This aspect may include one or more of the following optional features. In some configurations, the operations include determining a composite solution based on the second solution and the forward dynamics of the robot, and determining that a comparison between the composite solution and the second solution satisfies an optimization threshold. In this configuration, the optimization threshold indicates the accuracy of the corresponding solution to generate joint commands.

[0011] In some embodiments, at the second time instance, the operations include determining that the second solution does not satisfy the nonlinear constraint and generating an iteration constraint for the second linear optimization problem. Here, the iteration constraint includes a linear constraint based on the second solution not satisfying the nonlinear constraint. In this embodiment, at the second time instance, the operations also include updating the second solution to the second linear optimization problem using a quadratic program, the quadratic program including the iteration constraint.

[0012] In some examples, the unknown force corresponds to a force at a foot of the robot when the robot performs a manipulation. The unknown position vector may correspond to a position of the body of the robot relative to the foot of the robot when the robot performs the manipulation. Each of the first solution and the second solution may include a contact force of one or more legs of the legged robot against a surface, a ground contact position of one or more legs of the legged robot, a ground contact position of one or more legs of the legged robot, a ground contact time of one or more legs of the legged robot, or a ground lift time of one or more legs.

[0013] In some configurations, the operations include instructing a joint of at least one stance leg of the two or more legs of the robot based on a joint command, the joint command including a joint torque of the joint of the at least one stance leg. Here, the operations may include generating a joint torque of the joint of the at least one stance leg by determining that a contact force corresponding to a second solution of the at least one stance leg satisfies a torque limit constraint of the at least one stance leg and a friction constraint of the at least one stance leg.

[0014] In some implementations, the robot corresponds to a quadruped robot. The robot, when receiving the manipulation, may include receiving the manipulation from a user device in communication with the data processing hardware, and the manipulation may be defined by a user of the user device at a user interface running on the user device.

[0015] The details of one or more embodiments of the disclosure are set forth in the accompanying drawings and the description below. Other aspects, features, and advantages will be apparent from the description and drawings, and from the claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1A is a perspective view of an example robot in a robotic environment.

[0017] Figure 1B yes Figure 1A Schematic diagram of an example system of a robot.

[0018] Figure 2A-2G is used for Figure 1A Schematic diagram of an example manipulation controller for a robot.

[0019] Figure 3 is an example arrangement for causing a robot to perform manipulation operations using a manipulation controller.

[0020] Figure 4 is a schematic diagram of an example computing device that can be used to implement the systems and methods described herein.

[0021] Like reference numbers in the various drawings represent like elements. DETAILED DESCRIPTION

[0022] An entity that owns or controls a robot may want to pre-program the robot's movements, such as a repeatable movement routine. Unfortunately, pre-programmed movements may require hard coding to generate the desired movement. Hard coding is often time consuming and may result in a bottleneck, such that only a limited number of people (e.g., coders) may be able to code the robot's movements. Furthermore, modification of the coded movements or debugging of the coded movements may result in lengthy feedback loops to implement the movement routine. In other words, robots often lack the means to quickly author robot behaviors.

[0023] Another potential problem with preprogrammed movement is that it may or may not take into account the environment around the robot and / or the physical characteristics of the robot itself. In other words, the person coding the preprogrammed movement may not be aware that there may be other constraints on the robot during the preprogrammed movement. Without considering these other constraints, the preprogrammed routine may fail or damage the robot or the environment around the robot during operation. For example, the coder of the preprogrammed movement routine may not be aware that the robot will carry an additional 25 pound load during the routine, or that the routine may occur in a dynamic environment with static or dynamic obstacles. This clearly places the burden of considering all or most of the conditions that the robot will experience during the movement routine on the entity or coder in order to achieve a successful movement routine.

[0024] To overcome some of these problems, the robot 100 includes a manipulation controller 200 that is capable of building movements for the robot 100 without significant hard coding. In other words, the manipulation controller 200 is a controller that provides a flexible framework for generating dynamic robot behaviors with minimal user input. Using this flexible framework, the manipulation controller 200 serves as a rapid prototyping assembly line that allows a user (e.g., a robot operator or robot owner) to generate new robot behaviors (e.g., movement routines or movement patterns) with reduced programming and / or engineering labor costs. Here, the manipulation controller 200 receives user readable / writable inputs and converts these inputs into motion commands.

[0025] In some examples, the user 10 generates a manipulation 210 for the manipulation controller 200 on the user device 20. Here, the user device 20 uses computing resources 22, 24 (e.g., data processing hardware 22 and memory hardware 24 in communication with the data processing hardware 22) to run an interface that allows the user 10 to define the manipulation 210. Some examples of the user device 20 include a mobile device (e.g., a mobile phone, a tablet, a laptop, etc.), a personal computer (PC), a workstation, a terminal, or any other computing device with computing capabilities to generate the manipulation 210. The interface accessible at the user device 20 can be web-based (e.g., a web-based application launched from a web browser), local to the user device 20 (e.g., installed on and / or configured to run on the computing resources 22, 24 of the user device 20), or some combination of the two. In some embodiments, the user device 20 uses the interface to communicate the manipulation 210 to the robot 100 using a wired or wireless connection. For example, the interface communicates the manipulation 210 via a network (e.g., Figure 1B The network 150 shown transmits the manipulation 210 communication to the robot 100.

[0026] refer to Figure 1A , the robot 100 includes a body 110 having a locomotion-based structure, such as legs 120a-d coupled to the body 110, so that the robot 100 can move around the environment 30. In some examples, each leg 120 is an articulated structure such that one or more joints J permit a member 122 of the leg 120 to move. For example, each leg 120 includes an upper member 122, 122 of the leg 120. U A hip joint J coupled to the body 110 H and the upper member 122 of the leg 120 U The lower member 122 coupled to the leg 120 L Knee joint J K .although Figure 1A A quadruped robot having four legs 120a - d is depicted, but the robot 100 may include any number of legs or locomotion-based structure (eg, a biped or humanoid robot having two legs) that provides a means of traversing terrain within the environment 30 .

[0027] To traverse terrain, each leg 120 has a distal end 124 that contacts the terrain surface (i.e., a gripping surface). In other words, the distal end 124 of the leg 120 is the end of the leg 120 used by the robot 100 to pivot, implant, or generally provide grip during movement of the robot 100. For example, the distal end 124 of the leg 120 corresponds to the foot of the robot 100. In some examples, although not shown, the distal end 124 of the leg 120 includes an ankle joint J. A , so that the distal end 124 can be relative to the lower member 122 of the leg 120 L Articulated.

[0028] In some examples, the robot 100 includes an arm 126 that functions as a robotic manipulator. The arm 126 can be configured to move about multiple degrees of freedom in order to engage elements of the environment 30 (e.g., objects within the environment 30). In some examples, the arm 126 includes one or more members 128, wherein the members 128 are coupled by joints J so that the arm 126 can pivot or rotate about the joints J. For example, where there is more than one member 128, the arm 126 can be configured to extend or retract. To illustrate, Figure 1A An arm 126 is depicted having three members 128 corresponding to the lower member 128. L 、Upper member 128 U and hand component 128 H Here, the lower member 128 L The first arm joint J located near the body 110 can be A1(e.g., where the arm 126 is connected to the body 110 of the robot 100) to rotate or pivot. L At the second arm joint J A2 is coupled to the upper member 128 U , and the upper member 128 U At the third arm joint J A3 is coupled to the hand member 128 H In some examples, hand member 128 H Additional components are included to enable different types of gripping. These additional components can range from a simple two-component claw-like hand component 128 H To more complex hand components that simulate human fingers 128 H In some embodiments, the arm 126 is connected to the robot 100 at a socket on the body 110 of the robot 100. In some configurations, the socket is configured as a connector so that the arm 126 can be attached to or detached from the robot 100 depending on whether the arm 126 is needed for operation.

[0029] The robot 100 has a vertical gravity axis (eg, shown as a Z-axis A) along the direction of gravity. Z ) and the center of mass CM, which is a position corresponding to the average position of all parts of the robot 100, where the parts are weighted according to their mass (i.e., the point where the sum of the weighted relative positions of the distributed mass of the robot 100 is zero). The robot 100 also has a relative gravity axis A based on the vertical gravity axis A. Z The posture P of the CM of the robot 100 (i.e., a fixed reference frame relative to gravity) is defined to define a particular posture or stance assumed by the robot 100. The posture of the robot 100 may be defined by the orientation or angular position of the robot 100 in space. Movement of the legs 120 relative to the body 110 changes the posture P of the robot 100 (i.e., a combination of the position of the CM of the robot and the posture or orientation of the robot 100). Here, height generally refers to distance along the z-direction. The sagittal plane of the robot 100 corresponds to the sagittal plane of the robot 100 along the y-axis A. Y and z-axis A Z In other words, the sagittal plane divides the robot 100 into a left side and a right side. Generally perpendicular to the sagittal plane, the ground plane (also called the transverse plane) passes through the x-axis A. X and the y-axis A YThe ground plane refers to the ground 12 where the distal ends 124 of the legs 120 of the robot 100 can generate grip to help the robot 100 move around the environment 30. Another anatomical plane of the robot 100 is a frontal plane extending across the body 110 of the robot 100 (e.g., from the left side of the robot 100 with the first leg 120a to the right side of the robot 100 with the second leg 120b). The frontal plane passes through the x-axis A in the x-direction. X and z-axis A Z The XZ plane extends in the direction of the axis.

[0030] When the legged robot moves around the environment 30, each leg 120 of the robot 100 may or may not be in contact with the ground 12. When the leg 120 is in contact with the ground 12, the leg 120 is referred to as a standing leg 120. ST When the leg 120 is not in contact with the ground 12, the leg 120 is referred to as a swing leg 120. SW When the leg 120 is lifted off the ground 12 (LO), the leg 120 is moved from the standing leg 120 ST Transition to swing leg 120 SW Accordingly, when the swing leg 120 touches down (TD) against the ground 12 after it is no longer in contact with the ground 12, the swing leg 120 SW Can also be transformed into standing leg 120 ST Here, when the leg 120 is used as a swing leg 120 SW When the robot 100 is in the state of standing, the other leg 120 can be used as the standing leg 120 ST (For example, to maintain the balance of the robot 100).

[0031] To maneuver around the environment 30, the robot 100 includes a sensor system 130 having one or more sensors 132, 132a-n (e.g., shown as first sensors 132, 132a and second sensors 132, 132b). The sensors 132 may include vision / image sensors, inertial sensors (e.g., inertial measurement units (IMUs)), force sensors, and / or kinematic sensors. Some examples of sensors 132 include cameras, such as stereo cameras, scanning light detection and ranging (LIDAR) sensors, or scanning laser detection and ranging (LADAR) sensors. In some examples, the sensors 132 have corresponding fields of view F that define a sensing range or area corresponding to the sensor 132. v .For example, Figure 1A The field of view F of the robot 100 is depicted VEach sensor 132 may be pivotable and / or rotatable such that the sensor 132 may change its field of view F, for example, about one or more axes (e.g., an x-axis, a y-axis, or a z-axis relative to a ground plane). V .

[0032] When the sensor 132 is used to measure the field of view F V When the sensor system 130 generates a signal corresponding to the field of view F V The sensor data 134 (also referred to as image data) is provided in a manner that corresponds to the three-dimensional volumetric point cloud generated by the three-dimensional volumetric image sensor 132. In some examples, the sensor data 134 is image data corresponding to the three-dimensional volumetric point cloud generated by the three-dimensional volumetric image sensor 132. Additionally or alternatively, the sensor system 130 collects posture data of the robot 100 as the robot 100 maneuvers around the environment 30, the posture data including inertial measurement data (e.g., measured by an IMU). In some examples, the posture data includes kinematic data and / or orientation data about the robot 100, for example, kinematic data and / or orientation data about the joints J or other parts of the legs 120 of the robot 100. By utilizing the sensor data 134, various systems of the robot 100 can use the sensor data 134 to define a current state of the robot 100 (e.g., a current state of the kinematics of the robot 100) and / or a current state of the environment 30 around the robot 100.

[0033] In some embodiments, the sensor system 130 includes sensors 132 coupled to the joints J. In some examples, these sensors 132 are coupled to motors M (e.g., sensors 132, 132a-b) that operate the joints J of the robot 100. Here, these sensors 132 generate joint dynamics in the form of joint-based sensor data 134. The joint dynamics collected as joint-based sensor data 134 may include joint angles (e.g., upper member 122 U With respect to the lower member 122 L ), joint velocity (e.g., joint angular velocity or joint angular acceleration), and / or force experienced at joint J (also referred to as joint force). Here, the joint-based sensor data 134 generated by the one or more sensors 132 may be raw sensor data, data 134 that is further processed to form different types of joint dynamics, and / or joint velocity (e.g., joint angular velocity or joint angular acceleration). JD , or some combination of the two. For example, the sensor 132 measures the joint position (or the position of the member 122 coupled at the joint J), and the system of the robot 100 performs further processing to derive the velocity and / or acceleration from the position data. In other examples, the sensor 132 is configured to directly measure the velocity and / or acceleration.

[0034] As the sensor system 130 collects sensor data 134, the computing system 140 is configured to store, process, and / or communicate the sensor data 134 to various systems of the robot 100 (e.g., the control system 170 and / or the manipulation system 300). To perform computing tasks related to the sensor data 134, the computing system 140 of the robot 100 includes data processing hardware 142 and memory hardware 144. The data processing hardware 142 is configured to run instructions stored in the memory hardware 144 to perform computing tasks related to the activities (e.g., movement and / or movement-based activities) of the robot 100. In general, the computing system 140 refers to one or more locations of the data processing hardware 142 and / or the memory hardware 144.

[0035] In some examples, the computing system 140 is a local system located on the robot 100. When located on the robot 100, the computing system 140 can be centralized (i.e., in a single location / area on the robot 100, such as the body 110 of the robot 100), distributed (i.e., located in various locations around the robot 100), or a hybrid combination of the two (e.g., with a majority of centralized hardware and a minority of distributed hardware). To illustrate some of the differences, a distributed computing system 140 can allow processing to occur at active locations (e.g., at the motors of the joints that move the legs 120), while a centralized computing system 140 can allow a central processing hub to communicate with systems located at various locations on the robot 100 (e.g., communicating with the motors of the joints that move the legs 120).

[0036] Additionally or alternatively, the computing system 140 includes computing resources located remotely from the robot 100. For example, the computing system 140 communicates with a remote system 160 (e.g., a remote server or a cloud-based environment) via a network 150. Much like the computing system 140, the remote system 160 includes remote computing resources, such as remote data processing hardware 162 and remote memory hardware 164. Here, sensor data 134 or other processed data (e.g., data processed locally by the computing system 140) can be stored in the remote system 160 and can be accessed by the computing system 140. In some examples, the computing system 140 is configured to utilize the remote resources 162, 164 as an extension of the computing resources 142, 144, such that resources of the computing system 140 can reside on resources of the remote system 160.

[0037] In some embodiments, Figure 1A and Figure 1BAs shown, the robot 100 includes a control system 170. The control system 170 can be configured to communicate with the systems of the robot 100 (e.g., at least one sensor system 130). The control system 170 can use the hardware 140 to perform operations and other functions. The control system 170 includes at least one controller 172, which is configured to control the robot 100. For example, the controller 172 controls the movement of the robot 100 to traverse the environment 30 based on input or feedback from the systems of the robot 100 (e.g., the sensor system 130 and / or the control system 170). In some embodiments, the controller 172 controls the movement between postures and / or behaviors of the robot 100.

[0038] In some examples, the controller 172 controls the robot 100 by controlling the movement of one or more joints J around the robot 100. In some configurations, the controller 172 is software with programmed logic that controls at least one joint J or operates the joint J or a motor M coupled to the joint J. For example, the controller 172 controls the amount of force applied to the joint J (e.g., torque at the joint J). As a programmable controller 172, the number of joints J controlled by the controller 172 is scalable and / or customizable for a particular control purpose. The controller 172 can control a single joint J of the robot 100 (e.g., control the torque at a single joint J) or control multiple joints J of the robot 100. When controlling multiple joints J, the controller 172 can apply the same or different torques to each joint J controlled by the controller 172. By controlling multiple joints J, the controller 172 can coordinate the movement of a larger structure (e.g., body 110, one or more legs 120, arm 126) of the robot 100. In other words, for some manipulations 210 , the controller 172 may be configured to control movement of multiple parts of the robot 100 , such as two legs 120 a - b , four legs 120 a - d , or two legs 120 a - b in combination with the arm 126 .

[0039] In some embodiments, one or more controllers 172 of the control system 170 include a manipulation controller 200. The manipulation controller 200 may function like the other controllers 172 of the control system 170, but is additionally capable of providing control for inputs referred to as manipulations 210. In other words, the manipulation controller 200 is a controller 172 capable of dynamically programming a manipulation 210. A manipulation 210 is a control specification that sparsely defines one or more movement events 212. In some examples, the manipulation 210 is user-oriented, such that the user 10 writes a control specification that defines the manipulation 210 (e.g., with some basic coding). Although the control specification may include some degree of coding, the manipulation 210 is generally designed to have minimal specifications. By having minimal specifications, the user 10 may be able to quickly and / or efficiently generate new behaviors for the robot 100 and / or modify old behaviors. As part of the specification, the user 10 describes the behavior that the user 10 wants the robot 100 to perform based on one or more movement events 212, 212a-n. For example, for a legged robot 100, the manipulation 210 generally affects primarily leg movements. Here, some movement events 212 of the legged robot 100 include the ground contact of the foot 124 and / or the ground lift-off of the foot 124. In some examples, the movement events 212 describe in chronological order what the user 10 wants the robot 100 to do behaviorally. In other words, the movement event 212 includes a movement (or no movement) and the duration of the movement. In this regard, the movement event 212 may include a movement pause during which the robot 100 does not perform any movement. For example, if the user 10 wants the robot 100 to perform a handstand as a manipulation 210, the movement event 212 of the handstand manipulation 210 may describe the ground contact of the two front legs 120 of the robot 100, followed by the ground lift-off of the two rear legs 120 of the robot 100, and end with a pause / wait period of a specified duration (e.g., maintaining the handstand position). When the manipulation controller 200 interprets the manipulation 210, the manipulation controller 200 is configured to analyze the manipulation 210 in chronological order from the start of the manipulation 210 to the end of the manipulation 210, so that the manipulation 210 itself does not change dynamically during execution.

[0040] In some embodiments, the manipulation 210 is stateless. In other words, the manipulation 210 only cares about what the user 10 wants the robot 100 to do for the behavior, not what the robot 100 is currently doing. This stateless approach can also simplify the generation of manipulations for the user 10, because the user 10 does not have to worry about the potentially more complex current dynamics of the robot 100 and / or the dynamics of the environment 30 surrounding the robot 100.

[0041] In some examples, the manipulation controller 200 receives more than one manipulation 210. For example, the user 10 generates more than one manipulation 210 and requests the robot 100 to perform two or more manipulations 210 simultaneously. In some embodiments, the robot 100 communicates with an interface that includes a list of pre-programmed or hard-coded manipulations 210 that the user 10 can select to be performed by the robot 100. Here, although the interface includes a limited number of manipulations 210, the interface can allow the user 10 to combine the manipulations 210 in various ways for greater customization. This type of controlled customization may be preferred for users 10 with little or no coding ability, or when the robot owner wants to control the type of manipulations 210 that the robot 100 receives.

[0042] Some manipulations 210 may passively control portions of the robot 100 (e.g., joints J of the robot 100), while other manipulations 210 actively control portions of the robot 100 (e.g., joints J of the robot 100). In other words, passive manipulations 210 refer to behaviors that modify primary behaviors. With respect to joint control, two manipulations 210 may affect similar joints J. For example, in practical terms, movement of the body 110 occurs by changing at least one joint J of at least one leg 120 of the robot 100. However, when joints J of the legs 120 have been assigned to manipulations 210 (e.g., for footstep manipulations 210 or leg manipulations), movement of the body 110 may cause joint control interference. In other words, the body manipulation 210 is a secondary consideration, and it may affect joint control when it does not interfere with, for example, the leg manipulation 210. In some examples, in order to prevent problems caused by joint interference, certain manipulations 210 are designated as passive manipulations 210 or primary manipulations 210 during creation. In some embodiments, the manipulation controller 200 determines whether the manipulation 210 is a passive manipulation 210, and when the manipulation 210 is a passive manipulation 210, a behavior modification to the primary behavior or the manipulation 210 associated with the primary behavior is suggested. Here, the manipulation 210 that can modify the behavior is referred to as a prompt. When the prompt occurs at a particular time instance, each other active controller 172 (e.g., the manipulation controller 200) considers the prompt. When the controller 172 interprets the prompt, the controller 172 can determine that the prompt corresponds to a joint J that is different from the joint J controlled by the controller 172, and ignore modifying its controller behavior for the prompt. When the prompt corresponds to the same joint J, the controller 172 can incorporate the behavior modification of the prompt into its own behavior.

[0043] refer to Figure 2A-2G, the manipulator 200 includes a question generator 220 and a solver 230. The question generator 220 is configured to convert the manipulation 210 received by the manipulator 200 into a format that enables the manipulation system 200 to perform movement control to run or attempt to run the manipulation 210. In some examples, in order to run one or more manipulations 210, the manipulation system 200 considers the current state 202 of the robot 100. More specifically, running the manipulation 210 in an isolated environment without considering the current state 202 of the robot 100 may significantly reduce the ability of the robot 100 to successfully run the manipulation 210. Since the manipulation 210 is stateless, the question generator 220 forms a question 222 for the solver 230 by combining the manipulation 210 with the current state 202 of the robot 100. Here, the question 222 formed by the question generator 220 is solver-oriented. As solver-oriented, in some examples, the question 222 does not have to be in a human-readable format, but can be a machine-readable format. Furthermore, since the question 222 includes the current state 202 of the robot 100 , the question 222 is stateful.

[0044] In some embodiments, the question generator 220 generates a question 222 that includes time divisions. These time divisions are referred to as time steps 224. When comparing the maneuver 210 to the question 222, the maneuver 210 operates in movement events 212, which generally say when the movement changes, while the question 222 describes what to do during the time step 224. In some configurations, the time step 224 is a fixed size (e.g., fifty milliseconds). The size of the time step 224 can correspond to the timing between the movement events 212 of the maneuver 210. For example, the question generator 220 determines the size of the time step 224 by determining the time between each specified movement event 212. Once the question generator 220 determines the time between each adjacent movement event 212, the minimum amount of time between the movement events 212 can become the fixed size of the time step 224, or correspond to a multiple of the fixed size of the time step 224. Generally speaking, question generator 220 partitions maneuver 210 such that move events 212 occur at boundaries 224 b of time steps 224 .

[0045] When the manipulation 210 is divided into time steps 224, the question generator 220 may be configured to realize that too many time steps 224 are computationally expensive. Due to these costs, in some examples, the question generator 220 combines the time steps 224. In one way of combining the time steps 224, the question generator 220 generates the time steps 224 so that the size of the time steps 224 is longer and longer in the future of the manipulation 210. In other words, the time steps 224 are getting longer and longer in duration. In some embodiments, even if the time steps 224 become longer, the longer time steps 224 are integer multiples of the initial time steps 224 (i.e., the shortest basic time step unit). This approach allows the manipulation 210 to have fine-grained time instructions with the shortest basic time step unit in the near future, and to have longer and coarser granularity time instructions in the future of the manipulation 210. In some configurations, the question generator 220 communicates the maximum number of time steps 224 to the solver 230. Here, the maximum number of time steps 224 may be predetermined (e.g., to maintain computational speed of solver 230). Although problem generator 220 may generate more than the maximum number of time steps 224 and solver 230 will still function, the maximum number allows solver 230 to maintain computational efficiency and timely throughput, for example.

[0046] To illustrate, Figure 2AA maneuver 210 is depicted that is divided into time steps 224. Here, the maneuver 210 also includes four events 212, 212a-d, where the first event 212, 212a is the first leg 120, 120a leaving the ground, the second event 212, 212b is the first leg 120, 120a touching the ground, the third event 212, 212c is the second leg 120, 120b leaving the ground, and the fourth event 212, 212d is the second leg 120, 120b touching the ground. In this example, near the current time (as shown by the clock), for four time steps 224, 224a-d, the time step 224 is a single time step unit in length, and then the next two time steps 224, 224e-f are combined into a single time step 224 (e.g., as shown by the dashed line). After the combined two time steps 224e-f, there is another single time step 224, 224g, followed by a set of two combinations of two time steps: a set of first time steps 224, 224h-i and a set of second time steps 224, 224j-k. After the set of second time steps 224j-k, there is another single time step 224, 224l, followed by a set of three time steps 224, 224m-o. After the set of three time steps 224, 224m-o, the manipulation 210 ends with a set of two time steps 224, 224p-q. In this example, the combination of time steps 224 generally follows a pattern of a set of four basic time steps, followed by a set of four two-fold basic time steps, followed by a set of four three-fold basic time steps. Here, this pattern is slightly disrupted by the movement event 212. Even though time steps 224 may be combined, question generator 220 maintains a time step boundary at move event 212. In other words, Figure 2A As shown, single time step 224g will generally be part of larger time step 224, except that second movement event 212b and third movement event 212c form boundary 224b of single time step 224g. In this case, if single time step 224g is combined into larger time step 224, one or both of movement events 212b-c of maneuver 210 may lack important temporal details (e.g., which may be critical to the success of maneuver 210).

[0047] In some examples, unlike maneuver 210, question 222 changes throughout maneuver 210. For example, question 222 changes at each time step 224. Figure 2B2 is an example depicting the question generator 220 generating new questions 222 during the maneuver 210. Here, the question generator 220 generates a first question 222, 222a for the entire maneuver 210. Then, midway through the maneuver 210, the question generator 220 generates a second question 222, 222b for the second half of the maneuver 210. When the solver 230 is through most of the maneuver 210 (e.g., through 90% of the maneuver 210), the question generator 220 generates a third question 222, 222c for the remaining portion of the maneuver 210 (e.g., the remaining 10%). By adapting the question 222 to each change in the time step 224, the question generator 220 ensures that the solver 230 solves the most current question 222.

[0048] In some embodiments, for example Figure 2C , the question generator 220 is configured to determine whether to modify the manipulation 210 based on the prompt received at the manipulation controller 200. For example, when the manipulation controller 200 receives a prompt as a first manipulation 210, 210a and an unprompted second manipulation 210, 210b, the question generator 220 determines whether the prompt 210a corresponds to a joint J different from the joint J controlled by the manipulation controller 200. When the prompt 210a corresponds to a joint J different from the joint J controlled by the manipulation controller 200, the manipulation controller 200 ignores modifying the movement behavior of the unprompted second manipulation 210, 210b (not shown). However, when the prompt corresponds to the same joint J, the question generator 220 may incorporate the behavior modification of the prompt 210a into the behavior of the second manipulation 210b (e.g., shown as a modified manipulation 210ab). In some examples, the question generator 220 identifies the joint J of the manipulation 210 based on the specification of each manipulation 210. Here, the specification may identify which joints J are delegated to the manipulation 210.

[0049] In some examples, the problem generator 220 helps resolve inconsistencies between the current state 202 of the robot 100 and the expected state of the robot 100. In other words, the current state 202 of the robot 100 may be different from the expected state of the robot 100, such that this variation may cause the solver 230 to accurately identify problems with the behavior control of the manipulation controller 200. For example, according to the manipulation 210 of the robot 100 and the clock, the robot 100 should have two legs 120, 120a-b on the ground 12, but the measured state (i.e., the current state 202) reflects that the robot 100 still has the first leg 120, 120a (e.g., as the swing leg 120) SW) is in the air and has not yet touched the ground (i.e., late touchdown). Here, the question generator 220, by incorporating the current state 202 of the robot 100, ensures that the solver 230 does not erroneously determine a solution 232 that does not take into account the late touchdown identified by the current state 202. Similar to the late touchdown, the question generator 220 may also identify (e.g., through the current state 202) that the leg 120 has an early touchdown.

[0050] Continue to refer Figure 2A-2F , the solver 230 receives the problem 222 from the problem generator 220 and outputs a solution 232 to the problem 222. In some examples, the solver 230 identifies an initial state 234 of the robot 100 based on the current state 202 incorporated into the problem 222. For example, when the manipulation controller 200 primarily handles movement of the legged robot 100, the initial state 234 includes which feet 124 are currently in contact with the ground 12 and where these feet 124 are in contact with the ground. The initial state 234 may also include initial dynamics of the body 110 of the robot 100, such as the position of the body 110, the velocity of the body 110, and / or the orientation of the body 110. In some examples, based on the manipulation 210 incorporated into the problem 222, the problem 222 includes a nominal lift-off and / or touchdown time and a nominal lift-off and / or touchdown position (e.g., shown as TD / Lo). x,t ). Here, the term "nominal" means that the lift-off / touchdown time and lift-off / touchdown position are targets specified by the manipulation 210 (e.g., from the user 10 who authored the manipulation 210). In these examples, the manipulation 210 may also specify a contact normal that defines the direction of the contact surface (e.g., the ground 12). Here, with the contact normal, the robot 100 (e.g., at the solver 230) may be able to determine a friction cone that identifies how different forces can be applied to the contact surface without slipping or without a threshold risk of slipping. The solver 230 also receives a cost function 214 (e.g., specified by the manipulation 210) as part of the problem 222. The cost function 214 refers to the final pose P of the manipulation 210. F Identification and / or specification of the final pose P F In some examples, cost function 214 is more complex, such that maneuver 210 has multiple poses P of different importance at different times within maneuver 210 , which are incorporated into problem 222 of solver 230 .

[0051] Based on these inputs, the solver 230 generates a solution 232. As part of the solution 232, the solver 230 determines a contact force 236 to perform the maneuver 210. In some examples, in addition to the contact force 236, the solution 232 includes an actual touchdown / liftoff timing and / or an actual touchdown / liftoff position. Here, the touchdown / liftoff timing and the touchdown / liftoff position are referred to as actual because the solver 230 can adjust the nominal liftoff / touchdown timing and the liftoff / touchdown position based on the optimization of the solver 230. In some cases, the solution 232 includes the touchdown / liftoff timing, but only the touchdown position. By being able to adjust the nominal inputs, the robot 100 can be more robust because the robot 100 can adapt to feedback from the environment 30 (e.g., something hitting the robot 100) or disturbances in behavior (e.g., falling or tripping). Additionally or alternatively, being able to adjust the touchdown timing and / or location allows the movement events 212 of the maneuver 210 to be more easily authored without having to consider precise inputs regarding timing or location (e.g., for the legs 120 of the robot 100). In other words, the user 10 only needs to author an approximately feasible behavior (i.e., create the maneuver 210), and the solver 230 can determine the actual feasible solution 232. Indirectly, the solver 230 can also determine the COM of the robot 100 and the orientation trajectory of the robot 100. Here, the solver 230 indirectly determines the COM and orientation trajectory because these values ​​can be derived from the contact forces 236 and forward dynamics of the solution. Forward dynamics generally refers to using the forces (or torques) of the body to predict the orientation of each part of the body. In other words, by knowing the structural relationships of the robot 100 and determining the contact forces 236 used to perform the maneuver 210, the forward dynamics can predict the dynamics and / or kinematics of the robot 100 during the maneuver 210. Alternatively, the solver 230 may model the robot body 110 as having a single part.

[0052] The solver 230 attempts to determine the orientation of the robot 100, where the orientation is a torque-based solution 232 to the problem 222. By seeking a torque-based solution, the solver 230 focuses on the torque of the robot 100, which is measured as a force multiplied by a position vector. Here, if the solver 230 were trying to determine one of these terms (e.g., either the force or the position vector), the solver 230 would be able to utilize a quadratic program (QP) where the solution process would be linear. Unfortunately, because the solver 230 is trying to optimize both the unknown force term and the unknown position vector term (i.e., the quadratic term), the solver 230 cannot rely on traditional QP in its basic form. Instead, the solver 230 linearizes the problem.

[0053] In some embodiments, the solver 230 attempts to simultaneously determine a solution for the position of the body 110 relative to the foot 124 (i.e., the position vector term) and the force at the foot 124 (i.e., the force term). Here, because the solver 230 attempts to solve for both of these variables, the problem 222 is a nonlinear optimization problem (e.g., a quadratic problem) rather than a linear optimization problem. Typically, this means that the solver 230 cannot optimize with QP. However, other more general optimization methods are not as effective as QP because more general solvers (e.g., sequential quadratic programming) take significantly more time and therefore cannot enable the robot 100 to meet speed requirements that allow the robot 100 to be reactive or even proactive in terms of balance or robot physics when performing the manipulation 210. To overcome this problem, the solver 230 linearizes the dynamics by converting the problem 222 from a nonlinear optimization problem 222 (e.g., a quadratic problem) to a linear optimization problem 222 by making some assumptions. To account for this transformation, the solver 230 wants to determine a torque that is the product of two variables (i.e., the force and position vectors), without actually being able to multiply these variables. In some examples, the solver 230 represents the product of these two variables as an inaccurate linear representation. However, the solver 230 represents this inaccuracy by the product of the degree of error in the guess or estimate for each variable. Therefore, as the guess for each variable improves, the inherent error (i.e., the inaccuracy of the linearization) decreases.

[0054] In some embodiments, the solver 230 is configured to determine a contact force 236 for each leg 120 in contact with the ground 12 at each time step 224. Here, the contact force 236 is a three-dimensional force (e.g., may include force components in the x, y, and / or z directions). For each time step 224, the solver 230 may assume that the contact force 236 is a piecewise constant. In other words, the solver 230 may assume that the contact force 236 is constant during a particular time step 224. In some configurations, the solver 230 defines a body state 238 of the robot 100 as a COM position of the robot 100, a COM velocity of the robot 100, an orientation of the robot 100 (e.g., based on Euler angles or quaternions), and an angular velocity of the robot 100 in a world reference frame. When the solver 230 determines the contact force 236, the solver 230 may use forward dynamics to determine the body state 238 at each time step 224 of the manipulation 210.

[0055] In some examples, the body state 238 of the robot 100 defined by the solver 230 is a simple rigid body model of the robot 100. In other words, the solver 230 does not consider the robot 100 to be a legged robot 100 having articulated jointed legs 120 coupled to the body 110 of the robot 100. By modeling the robot 100 as a simple rigid body, the body state 238 determined by the solver 230 may have some inaccuracies. For example, because the robot 100 is more complex than a simple rigid body, the dynamics of the robot 100 derived from the body state 238 of the robot 100 may have some degree of inaccuracy, while the kinematics of the robot 100 may be quite accurate. In some examples, the orientation of the robot 100 is not defined for the body state 238 in terms of a rigid body, but is defined in terms of a natural pose of the robot 100, where the natural pose takes into account the additional inertial bodies of the robot 100 (e.g., the jointed legs 120, the arms 126, the members 128, etc.). Here, by using natural postures, there is increased accuracy in the dynamics of the robot 100 (e.g., the movement of the legs 120) but decreased accuracy in the kinematics of the robot 100 (e.g., the movement of the hip joints J). H There is a tradeoff between the accuracy of the position of the robot 100 and the accuracy of the position of the robot 100 located on the robot 100). In some configurations, the solver 230 uses machine learning (e.g., a neural network) to blend the advantages of each approach. For example, the solver 230 defines the orientation of the body state 238 of the robot 100 according to the natural posture, but uses machine learning to determine the offset of the kinematics so that the dynamics of the robot 100 are still accurate, and the accuracy of the kinematics of the robot 100 using the natural posture is increased.

[0056] In some examples, solution 232 from solver 230 includes an adjustment to the touchdown timing and / or an adjustment to the touchdown location. For example, at maneuver 210, user 10 specifies whether the touchdown timing and / or the touchdown location may be adjusted. When user 10 specifies that the touchdown timing and / or the touchdown location may be adjusted, solver 230 may determine these adjustments (e.g., if the optimization indicates adjustments) as part of solution 232.

[0057] refer to Figure 2D , in some examples, the solver 230 iteratively generates one or more solutions 232. Here, when the solver 230 iteratively generates solutions 232, the problem 222 changes for each iteration I. This approach is in contrast to more general solvers, such as Sequential QP. When Sequential QP solves a QP, it uses its solution to relinearize and solve the same QP. Although this is an iteration-based approach, Sequential QP does not allow the optimization problem to change between re-solving. In the case of the solver 230, when the solver 230 initially generates the solution 232 in the first iteration I, I 1When solving the QP, the first solution 232, 232a does not correspond to the exact solution 232 because an assumption is made to convert the problem 222 from a nonlinear optimization problem 222 (e.g., a quadratic problem) to a linear optimization problem 222. However, due to the conversion from the nonlinear optimization problem 222 (e.g., a quadratic problem) to the linear optimization problem 222, the linearization error that makes the first solution 232a an inaccurate solution 232 is quadratic, so that the error can be iteratively reduced to converge to the exact solution 232. Therefore, in order to generate a solution 232 that is more accurate than the first solution 232a, the first solution 232a is fed back to the solver 230 as the next iteration I, I of the problem 222. 2 Here, the problem 222 changes at each iteration I because the problem 222 takes into account the current state 202 of the robot 100, and the current state 202 is updated over time. In other words, even when there may be a small amount of time between iterations I of the problem 222 (e.g., for the robot 100, trying to solve the problem 222 at each tick t of the clock), the problem 222 changes for the solver 230. By using the solution 232 of the previous iteration I as the linearized estimate of the current iteration I, the solver 230 reduces the error at each iteration I to converge on an accurate solution 232. The quality of the solution 232 can be measured by comparing the solution 232 (e.g., at each iteration I) to an integrated solution 232i. The solver 230 generates the integrated solution 232i by running the solution 232 through the forward dynamics of the robot 100. To illustrate, the first solution 232a from the solver 230 is typically a poor solution because linearization occurs around an initial point with little or no knowledge of the accuracy of the solution 232 that will be provided to the solver 230. The second solution 232, 232b then becomes more accurate because linearization occurs with known accuracy around the first solution 232a. Typically, the second solution 232b has an accuracy that can be used for behavior control by the steering controller 200, but subsequent solutions, such as the third solution 232, 232c or the fourth solution 232, 232d, are typically more accurate for behavior control by the steering controller 200.

[0058] In some embodiments, the solver 230 linearizes the dynamics, which creates a problem with a quadratic cost function, which the solver 230 can formulate as a QP and solve with a QP solver. If the solver 230 cannot linearize the dynamics, the cost function will be more complex or higher order than quadratic. This cannot be formulated as a QP and therefore cannot be solved with a QP solver. An example of a more general solver that can solve this type of problem is called Sequential Quadratic Programming (SQP). SQP does something similar to solving a QP and using this solution to relinearize a new QP. Therefore, in some cases, the solver 230 runs the SQP solver on the original nonlinear problem while also allowing the nonlinear problem to change between QP iterations. In addition, the relinearized solution is constantly changing rather than starting over once it is completed.

[0059] Alternatively, solver 230 can be configured to determine which solution iteration provides sufficient accuracy to control the movement of maneuver 210 by determining that a comparison between composite solution 232i and any corresponding solution 232 satisfies an optimization threshold. Here, the optimization threshold is a predetermined accuracy that indicates the likelihood that solution 232 will successfully perform maneuver 210. In some examples, the comparison is a different comparison. In other examples, the comparison is a ratio comparison (e.g., much like a percentage yield).

[0060] In some embodiments, the QP of the solver 230 is a cost function and some number of linear constraints. The solver 230 attempts to satisfy these cost constraints in order to achieve an optimization of the problem 222. These cost constraints can be other settings specified by the user at the manipulation 210, general to the solver 230, and / or controllable by an entity (e.g., user 10). In some examples, the solver 230 includes a cost term 240 to minimize the contact force 236. Another example of a cost term 240 is that the solver 230 attempts to achieve the target pose P T , where the target posture P T has an associated value (e.g., an assigned importance cost). T It may only occur at the end of the movement trajectory of the manipulation 210 (ie, as the final pose P F ), or the target pose P Tmay occur at other times within the manipulation 210 (e.g., at each time step 224 or at one or more specified time steps 224). Other potential cost terms 240 for the solver 230 include maximum and / or minimum deviations from nominal contact timing and / or nominal contact location. Here, these cost terms 240 may specify how important the location and timing of contact is to the user 10. Additionally or alternatively, the user 10 may include a cost term 240 that specifies the position of the hip relative to the foot 124. The problem 222 may also be configured such that the user 10 may include a custom cost term 240 (e.g., a custom move). For example, the user 10 specifies a cost term 240 that indicates that the robot 100 should jump as high as possible or lean as far as possible in a particular direction. In some configurations, the solver 230 includes a cost term 240 to minimize the joint torque (or maximize the joint torque) of the joint J used for the manipulation 210. Although each of these cost terms 240 is described individually, the solver 230 may be subject to one or more of these cost terms 240 (eg, in any combination).

[0061] The constraint can be either an inequality constraint or an equality constraint. In some examples, the solver 230 includes a friction constraint 240f (e.g., as an inequality). Since the contact force 236 is an optimization variable of the solver 230, the friction constraint 240f can be directly written as depending on these optimization variables. Here, the configuration of the friction constraint 240f is generally similar to a function having a cone or pyramid shape (e.g., a four-sided three-dimensional pyramid). In order to implement the friction constraint 240f as a cone, the solver 230 can use an iterative constraint (e.g., a leg length constraint). In some of these examples, the function of the friction constraint 240f adapts to the controller 172 with slight inaccuracies (e.g., at small force values) by making the minimum value of the function a positive non-zero number.

[0062] In some embodiments, the solver 230 uses iterative constraints 240, 240i. Iterative constraints 240i refer to constraints 240 that take advantage of a feature of the solver 230 in which the solver 230 can add additional constraints 240 and continue solving or perform a fast solution 232 without restarting the problem 222. Iterative constraints 240i can be useful when the constraints 240 are generally best expressed as nonlinear functions, but this type of constraint 240 is not compatible with the QP of the solver 230. Rather than attempting to express the nonlinear function as an approximation of several separate linear constraints 240, the solver 230 first generates a solution 232 without the iterative constraints 240i. The solution 232 is then checked to determine whether the solution 232 will violate the target nonlinear constraint 240. When the solver 230 identifies that the solution 232 will violate the target nonlinear constraint 240, the solver 230 can generate an iterative constraint 240i. Here, iteration constraints 240i further constrain solution 232 to linear constraints that are compatible with solver 230 as it solves problem 222. By first solving the problem without nonlinear constraints, solver 230 can better determine what linear approximation of the nonlinear constraints will be most accurate.

[0063] For example, Figure 2E A dashed circle representing a leg length constraint 240 is shown, where the length of the leg 120 of the robot 100 may be constrained to be the length of the hip (eg, hip joint J) of the robot 100. H ) is a function of the position of the hip joint. In other words, as long as the hip joint J H 's position is within the dashed circle, the robot 100 will satisfy the leg length constraint 240. Unfortunately, the dashed circle will be the nonlinear constraint 240, 240n1. Here, the solver 230 generates a first solution 232, 232a for the robot 100 (e.g., shown as a first box), and identifies that the first solution 232a will violate the nonlinear constraint 240n1 of the dashed circle representing the hip position of the robot 100. Due to this violation, the solver 230 generates an iteration constraint 240i, which is shown as a line tangent to a point on the circle near the first solution 232a. Using the iteration constraint 240i, the solver 230 generates a second solution 232, 232b (e.g., shown as a second box), where some portions of the second solution 232, 232b are within the nonlinear constraint 240n1 of the dashed circle. Here, the first solution 232a and the second solution 232b appear at the same QP iteration I 1 ,t 0 t, so that solver 230 does not relinearize problem 222 (i.e., solutions 232a-b occur at the same time tick t 0). Iteration constraint 240i is used as a supplementary constraint during linearization iterations. In other words, iteration constraint 240i occurs at an iteration within a given problem 222, and is not applied when solver 230 solves at a new or subsequent future time (e.g., a subsequent time tick t 1 )When solving the problem 222, linearization iterations occur. The solver 230 may include constraints 240 regarding maximum leg length or minimum leg length.

[0064] Another example of a constraint 240 of the solver 230 is a hip constraint 240, 240h. Here, the hip constraint 240h represents the upper member 128 of each leg 120. U Has a limited range of motion to move around the y-axis A in the XZ frontal plane (also called the body plane) Y At the hip joint H The upper member 128 U Excessive rotation of the hip constraint 240h will cause impact or interference to the body 110 of the robot 100. In some embodiments, the hip constraint 240h is represented as a line in the XZ frontal plane that constrains the foot position of the foot 124 of the robot 100, the foot 124 corresponding to the upper member 128. U The legs 120. By constraining the XZ position of the foot position, the upper member 128 U Should not cause over-rotation problems.

[0065] In some examples, there are constraints 240 on the timing and / or location of liftoff / touchdown. Although the user 10 may specify that the solver 230 can adjust the touchdown / liftoff timing and / or the touchdown / liftoff location, these adjustments may include constraints 240 that identify the range or extent of these adjustments. For example, the constraints 240 for the touchdown location are represented as polygonal areas, where the polygonal areas represent legal touchdown areas.

[0066] Using the solution 232, the manipulation controller 200 is configured to perform a behavior (e.g., an optimized version of the behavior) corresponding to the manipulation 210 of the problem 222. In other words, the manipulation controller 200 must actually convert the solution 232 into one or more commands 204 to perform the manipulation 200. For example, the manipulation controller 200 generates a command 204 that (e.g., referred to as a joint command 204) controls one or more joints J corresponding to the manipulation 210 to perform the manipulation 210. Here, the command 204 can be based on the solution 232 from the solver 230. J Assigned to joint J. Additionally or alternatively, command 204 may assign a desired position / velocity to joint J. Typically, the stance leg is torque controlled, but the swing leg is position controlled.

[0067] In some embodiments, for a legged robot 100, the manipulation controller 200 controls the standing leg 120 to move the robot 100 to a certain position. ST and / or swing leg 120 SW To perform the behavior. To perform the processing of the leg 120, the manipulation controller 200 may have a different protocol to apply the solution 232 to the standing leg 120. ST and / or swing leg 120 SW In some configurations, such as Figure 2F-2G In order to convert the solution 232 from the solver 230 into actual movement control, the manipulation controller 200 also includes a processor 250. In some examples, the processor 250 is generally configured to identify the contact force 236, the contact position and / or the contact timing from the solution 232, and implement these parts of the solution 232 to control the stance leg 120. ST and / or swing leg 120 SW In these configurations, the processor 250 receives as input: the contact force 236 from the solution 232, as the stance leg 120 ST Target force; standing leg 120 ST Based on these inputs, the processor 250 determines the torque limit constraints 240, 240t of the joint J; and the friction constraint 240f. ST The joint torque T at the joint J J In some configurations, in order for the processor 250 to control one or more stance legs 120 of the robot 100 based on the solution 232 ST , the processor 250 may include an optimization model 252, such as QP, which receives input and determines the joint torque T J Apply 120 degrees on the standing leg ST At the joint J (for example, Figure 2G By using the processor 250, the control controller 200 can ensure that when controlling one or more standing legs 120 ST 240f), the constraints 240 that may have been violated or partially violated at the solver 230 are actually taken into account (e.g., through a compromise at the solver 230). Otherwise, actual control may be problematic for achieving the maneuver 210 and / or maintaining balance during the maneuver 210. To illustrate, the solver 230 may determine the contact force 236 that obeys the friction constraint 240 but does not obey the torque limit constraint 240t. In this example, if the processor 250 takes into account the torque limit constraint 240t, but does not take into account the friction constraint 240f, the processor 250 may modify the joint torque T J To meet the torque limit constraint of 240t, and on the standing leg 120 STTo overcome these problems, the processing machine 250 is configured to replicate the constraints 240 to ensure optimal actual control of the robot 100. The processing machine 250 may include a separate optimization model for each leg 120 of the robot 100, or may include a larger optimization model for multiple legs 120 that is capable of distributing joint control between more than one leg 120 (e.g., compensating for deficiencies between legs 120).

[0068] Based on the solution 232 from the solver 230 (eg, the contact position and / or contact timing based on the solution 232), the swing leg 120 SW The manipulation controller 210 may be controlled in a variety of ways (eg, by the processor 250). In some examples, the manipulation controller 210 controls the swing leg 120 according to the specification of the manipulation 210. SW For example, user 10 specifies a waypoint in maneuver 210 where swing leg 120 aims to touch the ground. Here, the waypoint specified by maneuver 210 may be specified in terms of time or in terms of position. In the case where user 10 specifies the position of the waypoint in terms of position, maneuver controller 200 may determine the timing corresponding to this position. In some special cases, maneuver controller 200 is configured to use solution 232 to command the swing leg to move so that swing leg 120 SW The robot 100 is configured to touch a vertical surface (i.e., a surface with a significant non-vertical normal) rather than a relatively horizontal surface (e.g., the ground 12). In some configurations, the manipulation controller 200 employs a swing leg control technique, such as described in U.S. Application No. 62 / 883,502, filed on August 6, 2019, entitled “Leg Swing Trajectories,” which is incorporated herein by reference, to control one or more swing legs 120 of the robot 100 based on the solution 232 from the solver 230. SW .

[0069] In some embodiments, the solver 230 may take a variable amount of time to complete. In addition, if there are many active constraints 240, the solver may take a particularly long time, which generally means that it is doing something difficult. The steering controller 200 may handle this problem by canceling the solver 230's run on the solution 232 and using a only partially optimized solution 232 with a shorter run time. In addition, since the solver 230 may rely on linearization around the previous solution, the solver 230 may take several iterations to converge, during which a bad solution 232 may occur. However, the solver 230 knows when this occurs by using a measure of how well the linearization is going. In response, the control system 170 may designate a backup controller 172, 200 that may not be very optimal, but is acceptable for the few time steps (e.g., typically <10ms) required for the desired controller 172, 200 to converge. By designating this controller 172 as the backup controller 172, the control system 170 can continue to do whatever it was doing before.

[0070] Figure 3 is an example arrangement of operations of a method 300 for dynamically programming at least one manipulation 210. At operation 302, the method 300 receives a manipulation 210 of the robot 100 and a current state 202 of the robot 100, wherein the manipulation 210 includes one or more movement events 212 to be performed by the robot 100. At operation 304, the method 300 converts the manipulation 210 and the current state 202 of the robot 100 into a nonlinear optimization problem 222, wherein the nonlinear optimization problem 222 is configured to optimize an unknown force and an unknown position vector. At operation 306, the method 300 performs a first time instance I 1 ,t 0 Two sub-operations 306, 306a-b are performed. In sub-operation 306a, the method 300 linearizes the nonlinear optimization problem 222 into a first linear optimization problem 222, 222a. In sub-operation 306b, the method 300 determines a first solution 232, 232a of the first linear optimization problem 222a using quadratic programming. In operation 308, the method 300 performs the first linear optimization problem 222a at a second time instance I. 1 ,t 0 Two sub-operations 308, 308a-b are performed, wherein the second time instance I 2 ,t 1 In the first instance I 1 ,t 0 Then, at sub-operation 308a, method 300 performs the following operations based on the first time instance t 0The first solution 232a of the nonlinear optimization problem 222 is linearized into a second linear optimization problem 222, 222b. At sub-operation 308b, the method 300 uses quadratic programming to determine a second solution 232, 232b of the second linear optimization problem 222b based on the first solution 232a. At operation 310, the method 300 generates joint commands 204 based on the second solution 232b to control the movement of the robot 100 during manipulation 210.

[0071] In some examples, the method 300 also determines a comprehensive solution 232i based on the second solution 232b and the forward dynamics of the robot 100, and determines that a comparison between the comprehensive solution 232i and the second solution 232b satisfies an optimization threshold, wherein the optimization threshold indicates the accuracy of the corresponding solution 232 to generate the joint command 204. In some embodiments, the method 300 further determines that the second solution 232b does not satisfy the nonlinear constraints 240, 240n1, and generates iteration constraints 240, 240i for the second linear optimization problem 222b, wherein the iteration constraints 240i include linear constraints based on the second solution 232b not satisfying the nonlinear constraints 240n1. Here, the method 300 also updates the second solution 232b of the second linear optimization problem 222b using quadratic programming, wherein the quadratic programming includes the iteration constraints 240i.

[0072] Figure 4 is a schematic diagram of an example computing device 400 that can be used to implement the systems (e.g., manipulation controller 200) and methods (e.g., method 300) described herein. Computing device 400 is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframes, and other appropriate computers. The components shown here, their connections and relationships, and their functions are merely exemplary and are not meant to limit the implementation of the inventions described and / or claimed in this document.

[0073] The computing device 400 includes a processor 410 (e.g., data processing hardware), a memory 420 (e.g., memory hardware), a storage device 430, a high-speed interface / controller 440 connected to the memory 420 and a high-speed expansion port 450, and a low-speed interface / controller 460 connected to a low-speed bus 470 and the storage device 430. Each of the components 410, 420, 430, 440, 450, and 460 are interconnected using various buses and can be mounted on a common motherboard or in other appropriate ways. The processor 410 can process instructions for running within the computing device 400, including instructions stored in the memory 420 or on the storage device 430, to display graphical information of a graphical user interface (GUI) on an external input / output device (e.g., a display 480 coupled to the high-speed interface 440). In other embodiments, multiple processors and / or multiple buses, as well as multiple memories and multiple types of memories, can be used appropriately. Furthermore, multiple computing devices 400 may be connected, with each device providing portions of the necessary operations (eg, as a server bank, a group of blade servers, or a multi-processor system).

[0074] Memory 420 stores information non-temporarily within computing device 400. Memory 420 may be a computer-readable medium, a volatile memory unit, or a non-volatile memory unit. Non-temporary memory 420 may be a physical device used to temporarily or permanently store programs (e.g., sequences of instructions) or data (e.g., program state information) for use by computing device 400. Examples of non-volatile memory include, but are not limited to, flash memory and read-only memory (ROM) / programmable read-only memory (PROM) / erasable programmable read-only memory (EPROM) / electrically erasable programmable read-only memory (EEPROM) (e.g., commonly used for firmware, such as bootloaders). Examples of volatile memory include, but are not limited to, random access memory (RAM), dynamic random access memory (DRAM), static random access memory (SRAM), phase change memory (PCM), and disk or tape.

[0075] The storage device 430 can provide mass storage for the computing device 400. In some embodiments, the storage device 430 is a computer-readable medium. In various embodiments, the storage device 430 can be a floppy disk device, a hard disk device, an optical disk device or a tape device, a flash memory or other similar solid-state memory device, or an array of devices, including devices in a storage area network or other configuration. In additional embodiments, a computer program product is tangibly embodied in an information carrier. The computer program product includes instructions that, when executed, perform one or more methods, such as those described above. The information carrier is a computer or machine-readable medium, such as a memory 420, a storage device 430, or a memory on a processor 410.

[0076] The high-speed controller 440 manages bandwidth-intensive operations of the computing device 400, while the low-speed controller 460 manages less bandwidth-intensive operations. This allocation of responsibilities is exemplary only. In some embodiments, the high-speed controller 440 is coupled to the memory 420, the display 480 (e.g., through a graphics processor or accelerator), and to the high-speed expansion port 450, which can accept various expansion cards (not shown). In some embodiments, the low-speed controller 460 is coupled to the storage device 430 and the low-speed expansion port 490. The low-speed expansion port 490, which can include various communication ports (e.g., USB, Bluetooth, Ethernet, wireless Ethernet), can be coupled to one or more input / output devices, such as a keyboard, a pointing device, a scanner, or a network device such as a switch or router, through, for example, a network adapter.

[0077] As shown, computing device 400 can be implemented in many different forms. For example, it can be implemented as a standard server 400a or multiple times in a group of such servers 400a as a laptop 400b, part of a rack server system 400c, or part of a robot 100.

[0078] Various implementations of the systems and techniques described herein can be realized in digital electronic and / or optical circuits, integrated circuits, specially designed ASICs (application specific integrated circuits), computer hardware, firmware, software, and / or combinations thereof. These various implementations may include implementations in one or more computer programs executable and / or interpretable on a programmable system that includes at least one programmable processor, which may be special purpose or general purpose, coupled to receive data and instructions from and send data and instructions to a storage system, at least one input device, and at least one output device.

[0079] These computer programs (also referred to as programs, software, software applications, or code) include machine instructions for a programmable processor and may be implemented in high-level procedural and / or object-oriented programming languages ​​and / or assembly / machine languages. As used herein, the terms "machine-readable medium" and "computer-readable medium" refer to any computer program product, non-transitory computer-readable medium, apparatus, and / or device (e.g., disk, optical disk, memory, programmable logic device (PLD)) for providing machine instructions and / or data to a programmable processor, including a machine-readable medium that receives machine instructions as a machine-readable signal. The term "machine-readable signal" refers to any signal for providing machine instructions and / or data to a programmable processor.

[0080] The processes and logic flows described in this specification can be performed by one or more programmable processors running one or more computer programs to perform functions by operating on input data and generating outputs. These processes and logic flows can also be performed by special logic circuits (such as FPGA (field programmable gate array) or ASIC (application-specific integrated circuit)). For example, processors suitable for running computer programs include general and special microprocessors, and any one or more processors of any kind of digital computer. Usually, the processor will receive instructions and data from a read-only memory or a random access memory or both. The basic elements of a computer are a processor for executing instructions and one or more storage devices for storing instructions and data. Usually, a computer will also include or be operably coupled to one or more large-capacity storage devices for storing data, such as a disk, a magneto-optical disk or an optical disk, to receive data from the large-capacity storage device or to transmit data to it, or both. However, a computer does not need to have such a device. Computer-readable media suitable for storing computer program instructions and data include all forms of non-volatile memory, media and memory devices, including, for example, semiconductor memory devices such as EPROM, EEPROM and flash memory devices; magnetic disks, such as internal hard disks or removable disks; magneto-optical disks; and CD ROM and DVD-ROM disks. The processor and memory may be supplemented by or incorporated in special purpose logic circuitry.

[0081] To provide interaction with a user, one or more aspects of the present disclosure may be implemented on a computer having a display device for displaying information to the user, such as a CRT (cathode ray tube), LCD (liquid crystal display) monitor, or touch screen, and an optional keyboard and pointing device, such as a mouse or trackball, through which the user can provide input to the computer. Other types of devices may also be used to provide interaction with the user; for example, the feedback provided to the user may be any form of sensory feedback, such as visual feedback, auditory feedback, or tactile feedback; and input from the user may be received in any form, including sound, voice, or tactile input. In addition, the computer may interact with the user by sending documents to and receiving documents from a device used by the user; for example, by sending a web page to a web browser on a user's client device in response to a request received from the web browser.

[0082] Many embodiments have been described. However, it should be understood that various modifications can be made without departing from the spirit and scope of the present disclosure. Therefore, other embodiments are also within the scope of the following claims.

Claims

1. A method (300), comprising: Receiving, at data processing hardware, a manipulation (210) of a legged robot (100) and a current state (202) of the legged robot (100), the manipulation (210) comprising one or more movement events (212) to be performed by the legged robot (100); converting, by the data processing hardware, the manipulation (210) of the legged robot (100) and the current state (202) of the legged robot (100) into a nonlinear optimization problem (222); Using the first solution (232a) of the first linear optimization problem (222a), linearizing the nonlinear optimization problem (222) into a second linear optimization problem (222b); determining, by the data processing hardware, a second solution (232b) to the second linear optimization problem (222b); as well as A command (204) is generated by the data processing hardware based on the second solution (232b) to perform the manipulation (210).

2. The method (300) of claim 1, further comprising: determining, by the data processing hardware, a combined solution (232i) based on the second solution (232b) and the forward dynamics of the legged robot (100); and A determination is made by the data processing hardware that a comparison between the composite solution (232i) and the second solution (232b) satisfies an optimization threshold, the optimization threshold indicating an accuracy with which the respective solutions (232) generated the command (204).

3. The method (300) of claim 1, further comprising: Determining, by the data processing hardware, that the second solution (232b) does not satisfy a nonlinear constraint (240nl); generating, by the data processing hardware, an iterative constraint (240i) for the second linear optimization problem (222b), the iterative constraint (240i) comprising a linear constraint (240) based on the second solution (232b) not satisfying the nonlinear constraint (240nl); and The second solution (232b) is updated by the data processing hardware using the iteration constraints (240i).

4. The method (300) of claim 1, wherein each of the first solution (232a) and the second solution (232b) comprises at least one of: a contact force (236) of one or more legs (120) of the legged robot (100) against a surface, a ground contact position of one or more legs (120) of the legged robot (100), a ground contact time of one or more legs (120) of the legged robot (100), or a ground lift time of one or more legs (120) of the legged robot (100).

5. The method (300) of claim 1, wherein: The legged robot (100) corresponds to a quadruped robot.

6. The method (300) according to any one of claims 1 to 5, wherein: The nonlinear optimization problem is configured to optimize a contact force (236) at a foot (124) of the legged robot (100) based on performance of the manipulation (210) by the legged robot (100).

7. The method (300) according to any one of claims 1 to 5, wherein: The nonlinear optimization problem is configured to optimize a position vector based on the legged robot's (100) performance of the manipulation (210), wherein the position vector corresponds to a position of the legged robot's (100) body (110) relative to a foot (124) of the legged robot (100).

8. The method (300) according to any one of claims 1 to 5, further comprising instructing, by the data processing hardware, at least one standing leg (120) of the legged robot (100) based on the command (204). ST ) of a joint (J), the command (204) including the at least one standing leg (120 ST ) of the joint (J) and the joint torque (T J ).

9. The method (300) of claim 8, further comprising: determining, by the data processing hardware, a position corresponding to the at least one stance leg (120 ST ) of the second solution (232b) satisfies the contact force (236) of the at least one standing leg (120 ST ) of the torque limiting constraint (240t) and the at least one standing leg (120 ST ) friction constraint (240f) to generate the at least one standing leg (120 ST ) of the joint (J) and the joint torque (T J ).

10. The method (300) according to any one of claims 1 to 5, wherein: Receiving the manipulation (210) includes receiving the manipulation (210) from a user device (20) in communication with the data processing hardware, and wherein the manipulation (210) is defined by a user (10) of the user device (20) at a user interface running on the user device (20).

11. A legged robot (100), comprising: body (110); two or more legs (120) coupled to the body (110); as well as a control system (170) in communication with the body (110) and the two or more legs (120), the control system (170) comprising data processing hardware (410) and memory hardware (420) in communication with the data processing hardware (410), the memory hardware (420) storing instructions which, when executed on the data processing hardware (410), cause the data processing hardware (410) to perform operations comprising: Receiving a manipulation (210) of a legged robot (100) and a current state (202) of the legged robot (100), the manipulation (210) comprising one or more movement events (212) to be performed by the legged robot (100); Converting the manipulation (210) of the legged robot (100) and the current state (202) of the legged robot (100) into a nonlinear optimization problem (222); Using the first solution (232a) of the first linear optimization problem (222a), linearizing the nonlinear optimization problem (222) into a second linear optimization problem (222b); determining a second solution (232b) to the second linear optimization problem (222b); and A command (204) is generated based on the second solution (232b) to perform the maneuver (210).

12. The legged robot (100) according to claim 11, wherein: The operations also include: determining a composite solution (232i) based on the second solution (232b) and the forward dynamics of the legged robot (100); and A comparison between the composite solution (232i) and the second solution (232b) is determined to satisfy an optimization threshold, the optimization threshold indicating an accuracy with which the respective solutions (232) generate the command (204).

13. The legged robot (100) according to claim 11, wherein: The operations also include: Determining that the second solution (232b) does not satisfy the nonlinear constraint (240nl); generating an iteration constraint (240i) for the second linear optimization problem (222b), the iteration constraint (240i) comprising a linear constraint (240) based on the second solution (232b) not satisfying the nonlinear constraint (240nl); and The second solution (232b) is updated using the iteration constraints (240i).

14. The legged robot (100) according to claim 11, wherein: Each of the first solution (232a) and the second solution (232b) includes at least one of the following: a contact force (236) of one or more legs (120) of the legged robot (100) against a surface, a ground contact position of one or more legs (120) of the legged robot (100), a ground contact time of one or more legs (120) of the legged robot (100), or a ground lift time of one or more legs (120) of the legged robot (100).

15. The legged robot (100) according to claim 11, wherein: The two or more legs (120) include at least four legs (120).

16. The legged robot (100) according to any one of claims 11 to 15, wherein: The nonlinear optimization problem is configured to optimize a contact force (236) at a foot (124) of the legged robot (100) based on performance of the manipulation (210) by the legged robot (100).

17. The legged robot (100) according to any one of claims 11 to 15, wherein: The nonlinear optimization problem is configured to optimize a position vector based on the legged robot's (100) performance of the manipulation (210), wherein the position vector corresponds to a position of the legged robot's (100) body (110) relative to a foot (124) of the legged robot (100).

18. The legged robot (100) according to any one of claims 11 to 15, wherein: The operation also includes instructing at least one standing leg (120) of the legged robot (100) based on the command (204) ST ) of a joint (J), the command (204) including the at least one standing leg (120 ST ) of the joint (J) and the joint torque (T J ).

19. The legged robot (100) according to claim 18, wherein: The operation also includes determining a position corresponding to the at least one standing leg (120 ST ) of the second solution (232b) satisfies the contact force (236) of the at least one standing leg (120 ST ) of the torque limiting constraint (240t) and the at least one standing leg (120 ST ) friction constraint (240f) to generate the at least one standing leg (120 ST ) of the joint (J) and the joint torque (T J ).

20. The legged robot (100) according to any one of claims 11 to 15, wherein: Receiving the manipulation (210) includes receiving the manipulation (210) from a user device (20) in communication with the data processing hardware, and wherein the manipulation (210) is defined by a user (10) of the user device (20) at a user interface running on the user device (20).

Images