placo::humanoid#

class placo.DummyWalk(robot: RobotWrapper, parameters: HumanoidParameters)#

T_world_left: ndarray#: left foot in world, at begining of current step

T_world_next: ndarray#: Target for the current flying foot (given by support_left)

T_world_right: ndarray#: right foot in world, at begining of current step

dtheta: float#: Last requested step dtheta.

dx: float#: Last requested step dx.

dy: float#: Last requested step d-.

lift_spline: CubicSpline#: Cubic splines for the lift trajectory.

next_step(dx: float, dy: float, dtheta: float) → None#

Produce the next step, change support foot.

Parameters:

dx (float) – dx
dy (float) – dy
dtheta (float) – dtheta

parameters: HumanoidParameters#: Humanoid parameters.

reset(support_left: bool = False) → None#

Reset the robot with a given support.

Parameters:: support_left (bool) – whether the first support is left

robot: RobotWrapper#: Robot wrapper.

solver: KinematicsSolver#: Kinematics solver.

support_left: bool#: Whether the current support is left or right.

update(t: float) → None#

Updates the internal IK.

Parameters:: t (float) – phase in step from 0 to 1

update_T_world_support(T_world_support: ndarray) → None#: Update the support to a given world pose.

class placo.Footstep(foot_width: float, foot_length: float)#

foot_length: float#

foot_width: float#

frame: ndarray#

overlap(other: Footstep, margin: float = 0.0) → bool#

static polygon_contains(self, polygon: list[ndarray], point: ndarray) → bool#

set_frame_xy(arg2: float, arg3: float) → None#

side: any#

support_polygon() → list[ndarray]#

class placo.FootstepsPlanner(parameters: HumanoidParameters)#

Initializes the planner.

Parameters:: parameters (HumanoidParameters) – Parameters of the walk

clipped_opposite_footstep(footstep: Footstep, d_x: float = 0.0, d_y: float = 0.0, d_theta: float = 0.0) → Footstep#: Same as opposite_footstep(), but the clipping is applied.

static make_supports(self, footsteps: list[Footstep], t_start: float, start: bool = True, middle: bool = False, end: bool = True) → list[Support]#

Generate the supports from the footsteps.

Parameters:

start (bool) – should we add a double support at the begining of the move?
middle (bool) – should we add a double support between each step ?
end (bool) – should we add a double support at the end of the move?

opposite_footstep(footstep: Footstep, d_x: float = 0.0, d_y: float = 0.0, d_theta: float = 0.0) → Footstep#: Return the opposite footstep in a neutral position (i.e. at a distance parameters.feet_spacing from the given footstep)

truncate_supports(arg2: int, arg3: bool) → Supports#

class placo.FootstepsPlannerNaive(parameters: HumanoidParameters)#

clipped_opposite_footstep(footstep: Footstep, d_x: float = 0.0, d_y: float = 0.0, d_theta: float = 0.0) → Footstep#: Same as opposite_footstep(), but the clipping is applied.

configure(T_world_left_target: ndarray, T_world_right_target: ndarray) → None#

Configure the naive footsteps planner.

Parameters:

T_world_left_target (numpy.ndarray) – Targetted frame for the left foot
T_world_right_target (numpy.ndarray) – Targetted frame for the right foot

static make_supports(self, footsteps: list[Footstep], t_start: float, start: bool = True, middle: bool = False, end: bool = True) → list[Support]#

Generate the supports from the footsteps.

Parameters:

start (bool) – should we add a double support at the begining of the move?
middle (bool) – should we add a double support between each step ?
end (bool) – should we add a double support at the end of the move?

opposite_footstep(footstep: Footstep, d_x: float = 0.0, d_y: float = 0.0, d_theta: float = 0.0) → Footstep#: Return the opposite footstep in a neutral position (i.e. at a distance parameters.feet_spacing from the given footstep)

plan(flying_side: any, T_world_left: ndarray, T_world_right: ndarray) → list[Footstep]#

Generate the footsteps.

Parameters:

flying_side (any) – first step side
T_world_left (numpy.ndarray) – frame of the initial left foot
T_world_right (numpy.ndarray) – frame of the initial right foot

truncate_supports(arg2: int, arg3: bool) → Supports#

class placo.FootstepsPlannerRepetitive(parameters: HumanoidParameters)#

clipped_opposite_footstep(footstep: Footstep, d_x: float = 0.0, d_y: float = 0.0, d_theta: float = 0.0) → Footstep#: Same as opposite_footstep(), but the clipping is applied.

configure(x: float, y: float, theta: float, steps: int) → None#

Compute the next footsteps based on coordinates expressed in the support frame laterally translated of +/- feet_spacing.

Parameters:

x (float) – Longitudinal distance
y (float) – Lateral distance
theta (float) – Angle
steps (int) – Number of steps

static make_supports(self, footsteps: list[Footstep], t_start: float, start: bool = True, middle: bool = False, end: bool = True) → list[Support]#

Generate the supports from the footsteps.

Parameters:

start (bool) – should we add a double support at the begining of the move?
middle (bool) – should we add a double support between each step ?
end (bool) – should we add a double support at the end of the move?

opposite_footstep(footstep: Footstep, d_x: float = 0.0, d_y: float = 0.0, d_theta: float = 0.0) → Footstep#: Return the opposite footstep in a neutral position (i.e. at a distance parameters.feet_spacing from the given footstep)

plan(flying_side: any, T_world_left: ndarray, T_world_right: ndarray) → list[Footstep]#

Generate the footsteps.

Parameters:

flying_side (any) – first step side
T_world_left (numpy.ndarray) – frame of the initial left foot
T_world_right (numpy.ndarray) – frame of the initial right foot

truncate_supports(arg2: int, arg3: bool) → Supports#

class placo.HumanoidParameters#

box_clip(step: ndarray) → ndarray#: Applies the box clipping (L1) to a given step size (dx, dy, dtheta)

box_overlap_clip(support_side: any, step: ndarray) → ndarray#: Clips a step using ellipsoid and overlap avoidance.

conic_clip(step: ndarray) → ndarray#: Applies the conic clipping to a given step size (dx, dy, dtheta)

conic_overlap_clip(support_side: any, step: ndarray) → ndarray#: Clips a step using ellipsoid and overlap avoidance.

dcm_offset_polygon: list[ndarray]#

double_support_duration() → float#: Default duration [s] of a double support.

double_support_ratio: float#: Duration ratio between single support and double support.

double_support_timesteps() → int#: Default number of timesteps for one double support.

dt() → float#: Timestep duration for planning [s].

ellipsoid_clip(step: ndarray) → ndarray#: Applies the ellipsoid (L2) clipping to a given step size (dx, dy, dtheta)

ellipsoid_overlap_clip(support_side: any, step: ndarray) → ndarray#: Clips a step using ellipsoid and overlap avoidance.

feet_spacing: float#: Lateral spacing between feet [m].

foot_length: float#: Foot length [m].

foot_width: float#: Foot width [m].

foot_zmp_target_x: float#: Target offset for the ZMP x reference trajectory in the foot frame [m].

foot_zmp_target_y: float#: Target offset for the ZMP x reference trajectory in the foot frame, positive is “outward” [m].

has_double_support() → bool#: Checks if the walk resulting from those parameters will have double supports.

op_space_polygon: list[ndarray]#

planned_timesteps: int#: Planning horizon for the CoM trajectory.

single_support_duration: float#: Single support duration [s].

single_support_timesteps: int#: Number of timesteps for one single support.

startend_double_support_duration() → float#: Default duration [s] of a start/end double support.

startend_double_support_ratio: float#: Duration ratio between single support and start/end double support.

startend_double_support_timesteps() → int#: Default number of timesteps for one start/end double support.

walk_com_height: float#: Target CoM height while walking [m].

walk_dtheta_spacing: float#: How much we need to space the feet per dtheta [m/rad].

walk_foot_height: float#: How height the feet are rising while walking [m].

walk_foot_rise_ratio: float#: ratio of time spent at foot height during the step

walk_max_dtheta: float#: Maximum step (yaw)

walk_max_dx_backward: float#: Maximum step (backward)

walk_max_dx_forward: float#: Maximum step (forward)

walk_max_dy: float#: Maximum step (lateral)

walk_trunk_pitch: float#: Trunk pitch while walking [rad].

zmp_margin: float#: Margin for the ZMP to live in the support polygon [m].

zmp_reference_weight: float#: Weight for ZMP reference in the solver.

class placo.HumanoidRobot(model_directory: str = 'robot', flags: int = 0, urdf_content: str = '')#

add_q_noise(noise: float) → None#: Adds some noise to the configuration.

centroidal_map() → ndarray#: Centroidal map.

collision_model: any#: Pinocchio collision model.

com_jacobian() → ndarray#: Jacobian of the CoM position expressed in the world.

com_jacobian_time_variation() → ndarray#: Jacobian time variation of the CoM expressed in the world.

com_world() → ndarray#: Gets the CoM position in the world.

compute_hessians() → None#: Compute kinematics hessians.

dcm(omega: float, com_velocity: ndarray) → ndarray#

Compute the Divergent Component of Motion (DCM)

Parameters:

omega (float) – Natural frequency of the LIP (= sqrt(g/h))
com_velocity (numpy.ndarray) – CoM velocity

distances() → list[Distance]#

Computes all minimum distances between current collision pairs.

Returns:: <Element ‘para’ at 0xff424facf150>

ensure_on_floor() → None#: Place the robot on its support on the floor.

ensure_on_floor_oriented(R_world_trunk: ndarray) → None#

Place the robot on its support on the floor according to the trunk orientation and the kinematic configuration.

Parameters:: R_world_trunk (numpy.ndarray) – Orientation of the trunk

frame_jacobian(frame: any, ref: any = None) → ndarray#

Frame jacobian, default reference is LOCAL_WORLD_ALIGNED.

Parameters:: frame (any) – the frame for which we want the jacobian
Returns:: <Element ‘para’ at 0xff424facc7c0>

frame_jacobian_time_variation(frame: any, ref: any = None) → ndarray#

Jacobian time variation $dot J$, default reference is LOCAL_WORLD_ALIGNED.

Parameters:: frame (any) – the frame for which we want the jacobian time variation
Returns:: <Element ‘para’ at 0xff424fc8fa10>

frame_names() → list[str]#: All the frame names.

generalized_gravity() → ndarray#: Computes generalized gravity.

get_T_a_b(index_a: any, index_b: any) → ndarray#

Gets the transformation matrix from frame b to a.

Parameters:

index_a (any) – frame a
index_b (any) – frame b

get_T_world_fbase() → ndarray#: Returns the transformation matrix from the fbase frame (which is the root of the URDF) to the world.

get_T_world_frame(index: any) → ndarray#

Gets the frame to world transformation matrix for a given frame.

Parameters:: index (any) – frame index

get_T_world_left() → ndarray#

get_T_world_right() → ndarray#

get_T_world_support() → object#

get_T_world_trunk() → ndarray#

get_com_velocity(support: any, omega_b: ndarray) → ndarray#

Compute the center of mass velocity from the speed of the motors and the orientation of the trunk.

Parameters:

support (any) – Support side
omega_b (numpy.ndarray) – Trunk angular velocity in the body frame

get_frame_hessian(frame: any, joint_v_index: int) → ndarray#: Get the component for the hessian of a given frame for a given joint.

get_joint(name: str) → float#

Retrieves a joint value from state.q.

Parameters:: name (str) – joint name

get_joint_acceleration(name: str) → float#

Gets the joint acceleration from state.qd.

Parameters:: name (str) – joint name

get_joint_limits(name: str) → any#

Gets the limits for a given joint.

Parameters:: name (str) – joint name

get_joint_offset(name: str) → int#

Gets the offset for a given joint in the state (in State::q)

Parameters:: name (str) – joint name

get_joint_v_offset(name: str) → int#

Gets the offset for a given joint in the state (in State::qd and State::qdd)

Parameters:: name (str) – joint name

get_joint_velocity(name: str) → float#

Gets the joint velocity from state.qd.

Parameters:: name (str) – joint name

get_support_side() → HumanoidRobot_Side#

get_torques(acc_a: ndarray, contact_forces: ndarray, use_non_linear_effects: bool = False) → ndarray#

Compute the torques of the motors from the contact forces.

Parameters:

acc_a (numpy.ndarray) – Accelerations of the actuated DoFs
contact_forces (numpy.ndarray) – Contact forces from the feet (forces are supposed normal to the ground)
use_non_linear_effects (bool) – If true, non linear effects are taken into account (state.qd necessary)

get_torques_dict(arg2: ndarray, arg3: ndarray, arg4: bool) → dict#

integrate(dt: float) → None#

Integrates the internal state for a given dt

Parameters:: dt (float) – delta time for integration expressed in seconds

joint_jacobian(joint: str, reference: str = 'local_world_aligned') → ndarray#: Joint jacobian, default reference is LOCAL_WORLD_ALIGNED.

joint_names(include_floating_base: bool = False) → list[str]#

All the joint names.

Parameters:: include_floating_base (bool) – whether to include the floating base joint (false by default)

load_collision_pairs(filename: str) → None#

Loads collision pairs from a given JSON file.

Parameters:: filename (str) – path to collisions.json file

make_solver() → KinematicsSolver#

mass_matrix() → ndarray#: Computes the mass matrix.

model: any#: Pinocchio model.

neutral_state() → RobotWrapper_State#: builds a neutral state (neutral position, zero speed)

non_linear_effects() → ndarray#: Computes non-linear effects (Corriolis, centrifual and gravitationnal effects)

static other_side(self, side: any) → any#

relative_position_jacobian(frame_a: any, frame_b: any) → ndarray#

Jacobian of the relative position of the position of b expressed in a.

Parameters:

frame_a (any) – frame index A
frame_b (any) – frame index B

reset() → None#: Reset internal states, this sets q to the neutral position, qd and qdd to zero.

self_collisions(stop_at_first: bool = False) → list[Collision]#

Finds the self collision in current state, if stop_at_first is true, it will stop at the first collision found.

Parameters:: stop_at_first (bool) – whether to stop at the first collision found
Returns:: <Element ‘para’ at 0xff424faccdb0>

set_T_world_fbase(T_world_fbase: ndarray) → None#

Updates the floating base to match the given transformation matrix.

Parameters:: T_world_fbase (numpy.ndarray) – transformation matrix

set_T_world_frame(frame: any, T_world_frameTarget: ndarray) → None#

Updates the floating base status so that the given frame has the given transformation matrix.

Parameters:

frame (any) – frame to update
T_world_frameTarget (numpy.ndarray) – transformation matrix

set_T_world_support(arg2: ndarray) → None#

set_gear_ratio(joint_name: str, rotor_gear_ratio: float) → None#: Updates the rotor gear ratio (used for apparent inertia computation in the dynamics)

set_gravity(gravity: ndarray) → None#: Sets the gravity vector.

set_joint(name: str, value: float) → None#

Sets the value of a joint in state.q.

Parameters:

name (str) – joint name
value (float) – joint value (e.g rad for revolute or meters for prismatic)

set_joint_acceleration(name: str, value: float) → None#

Sets the joint acceleration in state.qd.

Parameters:

name (str) – joint name
value (float) – joint acceleration

set_joint_limits(name: str, lower: float, upper: float) → None#

Sets the limits for a given joint.

Parameters:

name (str) – joint name
lower (float) – lower limit
upper (float) – upper limit

set_joint_velocity(name: str, value: float) → None#

Sets the joint velocity in state.qd.

Parameters:

name (str) – joint name
value (float) – joint velocity

set_rotor_inertia(joint_name: str, rotor_inertia: float) → None#: Updates the rotor inertia (used for apparent inertia computation in the dynamics)

set_torque_limit(name: str, limit: float) → None#

Sets the torque limit for a given joint.

Parameters:

name (str) – joint name
limit (float) – torque limit

set_velocity_limit(name: str, limit: float) → None#

Sets the velocity limit for a given joint.

Parameters:

name (str) – joint name
limit (float) – joint limit

set_velocity_limits(limit: float) → None#

Set the velocity limits for all the joints.

Parameters:: limit (float) – limit

state: RobotWrapper_State#: Robot’s current state.

static_gravity_compensation_torques(frameIndex: any) → ndarray#: Computes torques needed by the robot to compensate for the generalized gravity, assuming that the given frame is the (only) contact supporting the robot.

static_gravity_compensation_torques_dict(arg2: str) → dict#

support_is_both: bool#: Are both feet supporting the robot.

support_side: any#: The current side (left or right) associated with T_world_support.

torques_from_acceleration_with_fixed_frame(qdd_a: ndarray, frameIndex: any) → ndarray#

Computes required torques in the robot DOFs for a given acceleration of the actuated DOFs, assuming that the given frame is fixed.

Parameters:: qdd_a (numpy.ndarray) – acceleration of the actuated DOFs

torques_from_acceleration_with_fixed_frame_dict(qdd_a: ndarray, frame: str) → dict#: Computes the torque required to reach given acceleration in fixed frame

total_mass() → float#: Total mass.

update_from_imu(R_world_trunk: ndarray) → None#

Rotate the robot around its support.

Parameters:: R_world_trunk (numpy.ndarray) – Orientation of the trunk from the IMU

update_kinematics() → None#: Update internal computation for kinematics (frames, jacobian). This method should be called when the robot state has changed.

update_support_side(new_side: any) → None#: Updates which frame should be the current support.

visual_model: any#: Pinocchio visual model.

zmp(omega: float, com_acceleration: ndarray) → ndarray#

Compute the Zero-tilting Moment Point (ZMP)

Parameters:

omega (float) – Natural frequency of the LIP (= sqrt(g/h))
com_acceleration (numpy.ndarray) – CoM acceleration

class placo.LIPM#

LIPM is an helper that can be used to build problem involving LIPM dynamics. The decision variables introduced here are jerks, which is piecewise constant.

acc(timestep: int) → Expression#

static build_LIPM_from_previous(self, problem: Problem, dt: float, timesteps: int, t_start: float, previous: LIPM) → LIPM#

static compute_omega(self, com_height: float) → float#: Compute the natural frequency of a LIPM given its height (omega = sqrt(g / h))

dcm(timestep: int, omega: float) → Expression#

dt: float#

dzmp(timestep: int, omega_2: float) → Expression#

get_trajectory() → LIPMTrajectory#: Get the LIPM trajectory. Should be used after solving the problem.

jerk(timestep: int) → Expression#

pos(timestep: int) → Expression#

t_end: any#

t_start: float#

timesteps: int#

vel(timestep: int) → Expression#

x: Integrator#

x_var: Variable#

y: Integrator#

y_var: Variable#

zmp(timestep: int, omega_2: float) → Expression#

class placo.LIPMTrajectory#

acc(t: float) → ndarray#

dcm(t: float, omega: float) → ndarray#

dzmp(t: float, omega_2: float) → ndarray#

jerk(t: float) → ndarray#

pos(t: float) → ndarray#

vel(t: float) → ndarray#

zmp(t: float, omega_2: float) → ndarray#

class placo.Support#

apply_offset(offset: ndarray) → None#

elapsed_ratio: float#

end: bool#

footstep_frame(side: any) → ndarray#

Returns the frame for a given side (if present)

Parameters:: side (any) – the side we want the frame (left or right foot)

footsteps: list[Footstep]#

frame() → ndarray#: Returns the frame for the support. It will be the (interpolated) average of footsteps frames.

is_both() → bool#: Checks whether this support is a double support.

set_end(arg2: bool) → None#

set_start(arg2: bool) → None#

side() → any#: The support side (you should call is_both() to be sure it’s not a double support before)

start: bool#

support_polygon() → list[ndarray]#

t_start: float#

target_world_dcm: ndarray#

time_ratio: float#

class placo.SwingFoot#

A cubic fitting of swing foot, see: https://scaron.info/doc/pymanoid/walking-pattern-generation.html#pymanoid.swing_foot.SwingFoot.

static make_trajectory(self, t_start: float, t_end: float, height: float, start: ndarray, target: ndarray) → SwingFootTrajectory#

static remake_trajectory(self, old_trajectory: SwingFootTrajectory, t: float, target: ndarray) → SwingFootTrajectory#

class placo.SwingFootCubic#

static make_trajectory(self, t_start: float, virt_duration: float, height: float, rise_ratio: float, start: ndarray, target: ndarray, elapsed_ratio: float = 0.0, start_vel: ndarray = None) → SwingFootCubicTrajectory#

class placo.SwingFootCubicTrajectory#

pos(t: float) → ndarray#

vel(t: float) → ndarray#

class placo.SwingFootQuintic#

static make_trajectory(self, t_start: float, t_end: float, height: float, start: ndarray, target: ndarray) → SwingFootQuinticTrajectory#

class placo.SwingFootQuinticTrajectory#

pos(t: float) → ndarray#

vel(t: float) → ndarray#

class placo.SwingFootTrajectory#

pos(t: float) → ndarray#

vel(t: float) → ndarray#

class placo.WPGTrajectory(arg2: float, arg3: float, arg4: float, arg5: float)#

apply_transform(T: ndarray) → None#: Applies a given transformation to the left of all values issued by the trajectory.

com_target_z: float#

get_R_world_trunk(t: float) → ndarray#

get_T_world_left(t: float) → ndarray#

get_T_world_right(t: float) → ndarray#

get_a_world_CoM(t: float) → ndarray#

get_j_world_CoM(t: float) → ndarray#

get_next_support(t: float, n: int = 1) → Support#: Returns the nth next support corresponding to the given time in the trajectory. If n is greater than the number of remaining supports, the last support is returned.

get_p_support_CoM(t: float) → ndarray#

get_p_support_DCM(t: float, omega: float) → ndarray#

get_p_world_CoM(t: float) → ndarray#

get_p_world_DCM(t: float, omega: float) → ndarray#

get_p_world_ZMP(t: float, omega: float) → ndarray#

get_part_end_dcm(t: float, omega: float) → ndarray#: Returns the DCM at the end of the trajectory part corresponding to the given time.

get_part_t_end(t: float) → float#: Returns the end time of the trajectory part corresponding to the given time.

get_part_t_start(t: float) → float#: Returns the start time of the trajectory part corresponding to the given time.

get_prev_support(t: float, n: int = 1) → Support#: Returns the nth previous support corresponding to the given time in the trajectory. If n is greater than the number of previous supports, the first support is returned.

get_support(t: float) → Support#: Returns the support corresponding to the given time in the trajectory.

get_supports() → list[Support]#

get_v_support_CoM(t: float) → ndarray#

get_v_world_CoM(t: float) → ndarray#

get_v_world_foot(side: any, t: float) → ndarray#

get_v_world_right(t: float) → ndarray#

parts: list[WPGTrajectoryPart]#

print_parts_timings() → None#

replan_success: bool#

support_is_both(t: float) → bool#

support_side(t: float) → any#

t_end: float#

t_start: float#

trunk_pitch: float#

trunk_roll: float#

class placo.WPGTrajectoryPart(arg2: Support, arg3: float)#

support: Support#

t_end: float#

t_start: float#

class placo.WalkPatternGenerator(robot: HumanoidRobot, parameters: HumanoidParameters)#

can_replan_supports(trajectory: WPGTrajectory, t_replan: float) → bool#: Checks if a trajectory can be replanned for supports.

get_optimal_zmp(world_dcm_start: ndarray, world_dcm_end: ndarray, duration: float, support: Support) → ndarray#

Computes the best ZMP in the support polygon to move de DCM from world_dcm_start to world_dcm_end in duration.

Parameters:

world_dcm_start (numpy.ndarray) – Initial DCM position in world frame
world_dcm_end (numpy.ndarray) – Desired final DCM position in world frame
duration (float) – Duration
support (Support) – Support

plan(supports: list[Support], initial_com_world: ndarray, t_start: float = 0.0) → WPGTrajectory#

Plans a walk trajectory following given footsteps based on the parameters of the WPG.

Parameters:: supports (list[Support]) – Supports generated from the foosteps to follow

replan(supports: list[Support], old_trajectory: WPGTrajectory, t_replan: float) → WPGTrajectory#

Updates the walk trajectory to follow given footsteps based on the parameters of the WPG.

Parameters:

supports (list[Support]) – Supports generated from the current foosteps or the new ones to follow. Contain the current support
old_trajectory (WPGTrajectory) – Current walk trajectory
t_replan (float) – The time (in the original trajectory) where the replan happens

replan_supports(planner: FootstepsPlanner, trajectory: WPGTrajectory, t_replan: float, t_last_replan: float) → list[Support]#: Replans the supports for a given trajectory given a footsteps planner.

soft: bool#

stop_end_support_weight: float#

support_default_duration(support: Support) → float#

support_default_timesteps(support: Support) → int#

update_supports(t: float, supports: list[Support], world_measured_dcm: ndarray) → list[Support]#

Updates the supports to ensure DCM viability by adjusting the duration and the target of the current swing trajectory.

Parameters:

t (float) – Current time
supports (list[Support]) – Planned supports
world_measured_dcm (numpy.ndarray) – Measured DCM in world frame

zmp_in_support_weight: float#

class placo.WalkTasks#

com_task: CoMTask#

com_x: float#

com_y: float#

get_tasks_error() → dict[str, ndarray]#

initialize_tasks(solver: KinematicsSolver, robot: HumanoidRobot) → None#

left_foot_task: FrameTask#

reach_initial_pose(T_world_left: ndarray, feet_spacing: float, com_height: float, trunk_pitch: float) → None#

remove_tasks() → None#

right_foot_task: FrameTask#

scaled: bool#

solver: KinematicsSolver#

trunk_mode: bool#

trunk_orientation_task: OrientationTask#

trunk_task: PositionTask#

update_tasks(trajectory: WPGTrajectory, t: float) → None#

update_tasks_from_trajectory(arg2: WPGTrajectory, arg3: float) → None#

placo::humanoid#

This Page