placo 0.8.0__tar.gz → 0.8.5__tar.gz

{placo-0.8.0 → placo-0.8.5}/.github/workflows/wheels.yml

@@ -6,16 +6,17 @@ on:
       - published
 
 env:
-  CIBW_SKIP: "*musl* *i686"
+  CIBW_SKIP: "*i686 *musl* *armv7* *ppc64* *s390*"
   CIBW_REPAIR_WHEEL_COMMAND: ""
 
 jobs:
   build_wheels:
-    name: Build wheels on ${{ matrix.os }}
+    name: Wheel ${{ matrix.os }}, ${{ matrix.pyver }}
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest, macos-13]
+        os: [macos-latest, ubuntu-latest, ubuntu-24.04-arm, macos-13]
+        pyver: [cp39, cp310, cp311, cp312, cp313]
 
     steps:
       - uses: actions/checkout@v4
@@ -29,13 +30,13 @@ jobs:
       - name: Build wheels
         run: python -m cibuildwheel --output-dir wheelhouse
         # to supply options, put them in 'env', like:
-        # env:
-        #   CIBW_SOME_OPTION: value
+        env:
+          CIBW_BUILD: ${{ matrix.pyver }}-*
         #   ...
 
       - uses: actions/upload-artifact@v4
         with:
-          name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          name: cibw-wheels-${{ matrix.os }}-${{ matrix.pyver }}
           path: ./wheelhouse/*.whl
 
   build_sdist:

{placo-0.8.0 → placo-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: placo
-Version: 0.8.0
+Version: 0.8.5
 Summary: PlaCo: Rhoban Planning and Control
 Requires-Python: >= 3.9
 License-Expression: MIT

{placo-0.8.0 → placo-0.8.5}/bindings/expose-footsteps.cpp

@@ -25,6 +25,10 @@ void exposeFootsteps()
       .add_property("foot_length", &FootstepsPlanner::Footstep::foot_length, &FootstepsPlanner::Footstep::foot_length)
       .add_property("foot_width", &FootstepsPlanner::Footstep::foot_width, &FootstepsPlanner::Footstep::foot_width)
       .add_property("frame", &FootstepsPlanner::Footstep::frame, &FootstepsPlanner::Footstep::frame)
+      .def("set_frame_xy", +[](FootstepsPlanner::Footstep& footstep, double x, double y) {
+        footstep.frame.translation().x() = x;
+        footstep.frame.translation().y() = y;
+      })
       .def("support_polygon", &FootstepsPlanner::Footstep::support_polygon)
       .def("overlap", &FootstepsPlanner::Footstep::overlap)
       .def("polygon_contains", &FootstepsPlanner::Footstep::polygon_contains)

{placo-0.8.0 → placo-0.8.5}/bindings/expose-walk-pattern-generator.cpp

@@ -23,9 +23,9 @@ using namespace placo::humanoid;
 void exposeWalkPatternGenerator()
 {
   class__<WalkPatternGenerator::TrajectoryPart>("WPGTrajectoryPart", init<FootstepsPlanner::Support, double>())
-      .add_property("t_start", &WalkPatternGenerator::TrajectoryPart::t_start)
+      .add_property("t_start", &WalkPatternGenerator::TrajectoryPart::t_start, &WalkPatternGenerator::TrajectoryPart::t_start)
       .add_property("t_end", &WalkPatternGenerator::TrajectoryPart::t_end, &WalkPatternGenerator::TrajectoryPart::t_end)
-      .add_property("support", &WalkPatternGenerator::TrajectoryPart::support);
+      .add_property("support", &WalkPatternGenerator::TrajectoryPart::support, &WalkPatternGenerator::TrajectoryPart::support);
 
   class__<WalkPatternGenerator::Trajectory>("WPGTrajectory", init<double, double, double, double>())
       .add_property("t_start", &WalkPatternGenerator::Trajectory::t_start)
@@ -34,6 +34,7 @@ void exposeWalkPatternGenerator()
       .add_property("trunk_pitch", &WalkPatternGenerator::Trajectory::trunk_pitch)
       .add_property("trunk_roll", &WalkPatternGenerator::Trajectory::trunk_roll)
       .add_property("kept_ts", &WalkPatternGenerator::Trajectory::kept_ts)
+      .add_property("parts", &WalkPatternGenerator::Trajectory::parts)
       .def("get_T_world_left", &WalkPatternGenerator::Trajectory::get_T_world_left)
       .def("get_T_world_right", &WalkPatternGenerator::Trajectory::get_T_world_right)
       .def("get_v_world_right", &WalkPatternGenerator::Trajectory::get_v_world_right)
@@ -65,7 +66,8 @@ void exposeWalkPatternGenerator()
       .def("update_supports", &WalkPatternGenerator::update_supports)
       .def("get_optimal_zmp", &WalkPatternGenerator::get_optimal_zmp)
       .def("support_default_timesteps", &WalkPatternGenerator::support_default_timesteps)
-      .def("support_default_duration", &WalkPatternGenerator::support_default_duration);
+      .def("support_default_duration", &WalkPatternGenerator::support_default_duration)
+      .add_property("soft", &WalkPatternGenerator::soft, &WalkPatternGenerator::soft);
 
   class__<SwingFoot>("SwingFoot", init<>())
       .def("make_trajectory", &SwingFoot::make_trajectory)

{placo-0.8.0 → placo-0.8.5}/pyproject.toml

@@ -23,7 +23,7 @@ description = "PlaCo: Rhoban Planning and Control"
 license = "MIT"
 name = "placo"
 requires-python = ">= 3.9"
-version = "0.8.0"
+version = "0.8.5"
 
 [project.urls]
 changelog = "https://github.com/rhoban/placo/blob/main/CHANGELOG.md"

{placo-0.8.0 → placo-0.8.5}/src/placo/humanoid/walk_pattern_generator.cpp

@@ -376,7 +376,11 @@ void WalkPatternGenerator::constrain_lipm(problem::Problem& problem, LIPM& lipm,
   for (int timestep = 1; timestep < lipm.timesteps+1; timestep++)
   {
     // Ensuring ZMP remains in the support polygon
-    problem.add_constraint(PolygonConstraint::in_polygon_xy(lipm.zmp(timestep, omega_2), support.support_polygon(), parameters.zmp_margin));
+    auto& zmp_constraint = problem.add_constraint(PolygonConstraint::in_polygon_xy(lipm.zmp(timestep, omega_2), support.support_polygon(), parameters.zmp_margin));
+    if (soft)
+    {
+      zmp_constraint.configure(ProblemConstraint::Soft, 1e5);
+    }
 
     // Optional offset for single supports
     double x_offset = 0., y_offset = 0.;
@@ -393,9 +397,16 @@ void WalkPatternGenerator::constrain_lipm(problem::Problem& problem, LIPM& lipm,
     // At the end of an end support, we reach the target with a null speed and a null acceleration
     if (support.end && timestep == lipm.timesteps)
     {
-      problem.add_constraint(lipm.pos(timestep) == Eigen::Vector2d(support.frame().translation().x(), support.frame().translation().y()));
-      problem.add_constraint(lipm.vel(timestep) == Eigen::Vector2d(0., 0.));
-      problem.add_constraint(lipm.acc(timestep) == Eigen::Vector2d(0., 0.));
+      auto& pos_constraint = problem.add_constraint(lipm.pos(timestep) == Eigen::Vector2d(support.frame().translation().x(), support.frame().translation().y()));
+      auto& vel_constraint = problem.add_constraint(lipm.vel(timestep) == Eigen::Vector2d(0., 0.));
+      auto& acc_constraint = problem.add_constraint(lipm.acc(timestep) == Eigen::Vector2d(0., 0.));
+
+      if (soft)
+      {
+        pos_constraint.configure(ProblemConstraint::Soft, 1e3);
+        vel_constraint.configure(ProblemConstraint::Soft, 1e3);
+        acc_constraint.configure(ProblemConstraint::Soft, 1e3);
+      }
     }
   }
 }
@@ -602,19 +613,13 @@ void WalkPatternGenerator::Trajectory::print_parts_timings()
 }
 
 std::vector<FootstepsPlanner::Support> WalkPatternGenerator::update_supports(double t, 
-  std::vector<FootstepsPlanner::Support> supports, Eigen::Vector2d world_measured_dcm)
+  std::vector<FootstepsPlanner::Support> supports, Eigen::Vector2d world_target_zmp, Eigen::Vector2d world_measured_dcm)
 {
   FootstepsPlanner::Support current_support = supports[0];
-  FootstepsPlanner::Support next_support = supports[1];
-
   if (current_support.is_both())
   {
     throw std::runtime_error("Can't modify flying target and step duration if the current support is both");
   }
-  if (next_support.is_both())
-  {
-    throw std::runtime_error("Next support is both, not supported for now");
-  }
 
   placo::problem::Problem problem;
   double w1 = 5;
@@ -638,10 +643,11 @@ std::vector<FootstepsPlanner::Support> WalkPatternGenerator::update_supports(dou
 
   // ZMP Reference (expressed in the world frame)
   Expression world_next_zmp_expr = p_world_support + R_world_support * support_next_zmp->expr();
-  problem.add_constraint(world_next_zmp_expr == next_support.frame().translation().head(2)).configure(ProblemConstraint::Soft, w2);
+  problem.add_constraint(world_next_zmp_expr == world_target_zmp).configure(ProblemConstraint::Soft, w2);
 
   // DCM offset reference (expressed in the world frame)
-  Eigen::Vector2d world_target_dcm_offset = current_support.target_world_dcm - next_support.frame().translation().head(2);
+  // XXX : l'offset doit être calculé par rapport à la cible mise à jour non ?
+  Eigen::Vector2d world_target_dcm_offset = current_support.target_world_dcm - world_target_zmp;
   // Eigen::Vector2d world_target_dcm_offset = world_end_dcm - next_support.frame().translation().head(2);
   // std::cout << "world_target_dcm_offset: " << world_target_dcm_offset.transpose() << std::endl;
 

{placo-0.8.0 → placo-0.8.5}/src/placo/humanoid/walk_pattern_generator.h

@@ -180,21 +180,21 @@ public:
   /**
    * @brief Updates the supports to ensure DCM viability by adjusting the 
    * duration and the target of the current swing trajectory.
-   * @param t The current time
-   * @param supports The planned supports
-   * @param world_measured_dcm The measured DCM in world frame
-   * @param world_end_dcm The desired DCM at the end of the current support phase
+   * @param t Current time
+   * @param supports Planned supports
+   * @param world_target_zmp Target ZMP for the flying foot in world frame
+   * @param world_measured_dcm Measured DCM in world frame
    */
-  std::vector<FootstepsPlanner::Support> update_supports(double t, 
-    std::vector<FootstepsPlanner::Support> supports, Eigen::Vector2d world_measured_dcm);
+  std::vector<FootstepsPlanner::Support> update_supports(double t, std::vector<FootstepsPlanner::Support> supports, 
+    Eigen::Vector2d world_target_zmp, Eigen::Vector2d world_measured_dcm);
 
   /**
    * @brief Computes the best ZMP in the support polygon to move de DCM from 
    * world_dcm_start to world_dcm_end in duration.
-   * @param world_dcm_start The initial DCM position in world frame
-   * @param world_dcm_end The desired final DCM position in world frame
-   * @param duration The duration
-   * @param support The support
+   * @param world_dcm_start Initial DCM position in world frame
+   * @param world_dcm_end Desired final DCM position in world frame
+   * @param duration Duration
+   * @param support Support
    */
   Eigen::Vector2d get_optimal_zmp(Eigen::Vector2d world_dcm_start, Eigen::Vector2d world_dcm_end, 
     double duration, FootstepsPlanner::Support& support);
@@ -202,6 +202,8 @@ public:
   int support_default_timesteps(FootstepsPlanner::Support& support);
   double support_default_duration(FootstepsPlanner::Support& support);
   
+  bool soft = false;
+
 protected:
   // Robot associated to the WPG
   HumanoidRobot& robot;