Skip to content

Commit

Permalink
MPC: LAND: create "Stop" a utility "motionprimitive" to also be used …
Browse files Browse the repository at this point in the history
…elsewhere
  • Loading branch information
Claudio-Chies committed Oct 18, 2024
1 parent e6923c7 commit 9d90285
Show file tree
Hide file tree
Showing 7 changed files with 245 additions and 140 deletions.
4 changes: 2 additions & 2 deletions src/modules/flight_mode_manager/FlightModeManager.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -153,7 +153,7 @@ void FlightModeManager::start_flight_task()
bool matching_task_running = true;
bool task_failure = false;
const bool nav_state_descend = (_vehicle_status_sub.get().nav_state == vehicle_status_s::NAVIGATION_STATE_DESCEND);
const bool nav_state_land = (_vehicle_status_sub.get().nav_state == vehicle_status_s::NAVIGATION_STATE_LAND);
const bool nav_state_land = (_vehicle_status_sub.get().nav_state == vehicle_status_s::NAVIGATION_STATE_AUTO_LAND);

// Follow me
if (_vehicle_status_sub.get().nav_state == vehicle_status_s::NAVIGATION_STATE_AUTO_FOLLOW_TARGET) {
Expand Down Expand Up @@ -404,7 +404,7 @@ FlightTaskError FlightModeManager::switchTask(FlightTaskIndex new_task_index)

if (!isAnyTaskActive()) {
// no task running
return FlightTaskError::NoE rror;
return FlightTaskError::NoError;
}

// activation failed
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -816,7 +816,7 @@ void FlightTaskAuto::_updateTrajConstraints()
// correction required by the altitude/vertical position controller
_constraints.speed_down = 1.2f * _param_mpc_z_v_auto_dn.get();
_constraints.speed_up = 1.2f * _param_mpc_xy_vel_max.get();
_constraints.speed_xy = 1.2f * _param_mpc_xy_vel_max.get();;
_constraints.speed_xy = 1.2f * _param_mpc_xy_vel_max.get();

if (_is_emergency_braking_active) {
// When initializing with large velocity, allow 1g of
Expand Down
130 changes: 12 additions & 118 deletions src/modules/flight_mode_manager/tasks/Land/FlightTaskLand.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -59,19 +59,14 @@ FlightTaskLand::activate(const trajectory_setpoint_s &last_setpoint)
}

_yaw_setpoint = _land_heading = _yaw; // set the yaw setpoint to the current yaw
_position_smoothing.reset(pos_prev, vel_prev, accel_prev);


_acceleration_setpoint = accel_prev;
_velocity_setpoint = vel_prev;
_position_setpoint = pos_prev;

_stop.initialize(_acceleration_setpoint, _velocity_setpoint, _position, _deltatime);


// Initialize the Landing locations and parameters
// calculate where to land based on the current velocity and acceleration constraints
_CalculateBrakingLocation();
_initial_land_position = _land_position;
_initial_land_position = _land_position = _stop.getStopPosition();

return ret;
}
Expand All @@ -80,29 +75,30 @@ void
FlightTaskLand::reActivate()
{
FlightTask::reActivate();
// On ground, reset acceleration and velocity to zero
_position_smoothing.reset({0.f, 0.f, 0.f}, {0.f, 0.f, 0.7f}, _position);
}

bool
FlightTaskLand::update()
{
bool ret = FlightTask::update();

if (!_is_initialized) {
_position_smoothing.reset(_acceleration_setpoint, _velocity, _position);
_is_initialized = true;
}

if (_velocity.norm() < 0.1f * _param_mpc_xy_vel_max.get() && !_landing) {
if (!_stop.isActive && !_landing) {
_landing = true;
}

if (_landing) {
_PerformLanding();

} else {
_SmoothBrakingPath();
_stop.getConstraints(_constraints);
_stop.update(_acceleration_setpoint, _velocity_setpoint, _position, _deltatime);

_initial_land_position = _land_position = _stop.getStopPosition();
_jerk_setpoint = _stop.getJerkSetpoint();
_acceleration_setpoint = _stop.getAccelerationSetpoint();
_velocity_setpoint = _stop.getVelocitySetpoint();
_position_setpoint = _stop.getPositionSetpoint();
_yaw_setpoint = _land_heading;
}

return ret;
Expand Down Expand Up @@ -180,108 +176,6 @@ FlightTaskLand::_PerformLanding()
_gear.landing_gear = landing_gear_s::GEAR_DOWN;

}
void
FlightTaskLand::_SmoothBrakingPath()
{
PositionSmoothing::PositionSmoothingSetpoints out_setpoints;

_HandleHighVelocities();

_position_smoothing.generateSetpoints(
_position,
_land_position,
Vector3f{0.f, 0.f, 0.f},
_deltatime,
false,
out_setpoints
);

_jerk_setpoint = out_setpoints.jerk;
_acceleration_setpoint = out_setpoints.acceleration;
_velocity_setpoint = out_setpoints.velocity;
_position_setpoint = out_setpoints.position;
_yaw_setpoint = _land_heading;
}

void
FlightTaskLand::_CalculateBrakingLocation()
{
// Calculate the 3D point where we until where we can slow down smoothly and then land based on the current velocities and system constraints on jerk and acceleration.
_UpdateTrajConstraints();
float delay_scale = 0.4f; // delay scale factor
const float velocity_hor_abs = sqrtf(_velocity(0) * _velocity(0) + _velocity(1) * _velocity(1));
const float braking_dist_xy = math::trajectory::computeBrakingDistanceFromVelocity(velocity_hor_abs,
_param_mpc_jerk_auto.get(), _param_mpc_acc_hor.get(), delay_scale * _param_mpc_jerk_auto.get());
float braking_dist_z = 0.0f;

if (_velocity(2) < -0.1f) {
braking_dist_z = math::trajectory::computeBrakingDistanceFromVelocity(_velocity(2),
_param_mpc_jerk_max.get(), _param_mpc_acc_down_max.get(), 0.f);

} else if (_velocity(2) > 0.1f) {
braking_dist_z = math::trajectory::computeBrakingDistanceFromVelocity(_velocity(2),
_param_mpc_jerk_max.get(), _param_mpc_acc_up_max.get(), 0.f);
}

const Vector3f braking_dir = _velocity.unit_or_zero();
const Vector3f braking_dist = {braking_dist_xy, braking_dist_xy, braking_dist_z};
_land_position = _position + braking_dir.emult(braking_dist);
}


void
FlightTaskLand::_HandleHighVelocities()
{
// This logic here is to fix the problem that the trajectory generator will generate a smoot trajectory from the current velocity to zero velocity,
// but if the velocity is too high, the Position Controller will be able to comand higher accelerations than set by the parameter which means the vehicle will break faster than expected predicted by the trajectory generator.
// But if we then do a reset the deceleration will be smooth again.
const bool _exceeded_vel_z = fabsf(_velocity(2)) > math::max(_param_mpc_z_v_auto_dn.get(),
_param_mpc_z_vel_max_up.get());
const bool _exceeded_vel_xy = _velocity.xy().norm() > _param_mpc_xy_vel_max.get();

if ((_exceeded_vel_xy || _exceeded_vel_z) && !_exceeded_max_vel) {
_exceeded_max_vel = true;

} else if ((!_exceeded_vel_xy && !_exceeded_vel_z) && _exceeded_max_vel) {
// This Reset will be called when the velocity is again in the normal range and will be called only once.
_exceeded_max_vel = false;
_position_smoothing.reset(_acceleration_setpoint, _velocity, _position);
_CalculateBrakingLocation();
_initial_land_position = _land_position;
}
}

void
FlightTaskLand::_UpdateTrajConstraints()
{
// update params of the position smoothing
_position_smoothing.setCruiseSpeed(_param_mpc_xy_vel_max.get());
_position_smoothing.setHorizontalTrajectoryGain(_param_mpc_xy_traj_p.get());
_position_smoothing.setMaxAllowedHorizontalError(_param_mpc_xy_err_max.get());
_position_smoothing.setTargetAcceptanceRadius(_param_nav_mc_alt_rad.get());
_position_smoothing.setVerticalAcceptanceRadius(_param_nav_mc_alt_rad.get());

// Update the constraints of the trajectories
_position_smoothing.setMaxAccelerationXY(_param_mpc_acc_hor.get());
_position_smoothing.setMaxVelocityXY(_param_mpc_xy_vel_max.get());
_position_smoothing.setMaxJerkXY(_param_mpc_jerk_auto.get());
_position_smoothing.setMaxJerkZ(_param_mpc_jerk_max.get());

// set the constraints for the vertical direction
// if moving up, acceleration constraint is always in deceleration direction, eg opposite to the velocity
if (_velocity(2) < 0.0f && !_landing) {
_position_smoothing.setMaxAccelerationZ(_param_mpc_acc_down_max.get());
_position_smoothing.setMaxVelocityZ(_param_mpc_z_v_auto_up.get());

} else if (!_landing) {
_position_smoothing.setMaxAccelerationZ(_param_mpc_acc_up_max.get());
_position_smoothing.setMaxVelocityZ(_param_mpc_z_v_auto_dn.get());

} else {
_position_smoothing.setMaxAccelerationZ(_param_mpc_acc_down_max.get());
_position_smoothing.setMaxVelocityZ(_param_mpc_z_v_auto_dn.get());
}
}

void
FlightTaskLand::updateParams()
Expand Down
23 changes: 4 additions & 19 deletions src/modules/flight_mode_manager/tasks/Land/FlightTaskLand.hpp
Original file line number Diff line number Diff line change
Expand Up @@ -49,6 +49,7 @@
#include "Sticks.hpp"
#include "StickAccelerationXY.hpp"
#include "StickYaw.hpp"
#include "Stop.hpp"

using matrix::Vector3f;
using matrix::Vector2f;
Expand All @@ -66,41 +67,27 @@ class FlightTaskLand : public FlightTask
protected:
void updateParams() override;

PositionSmoothing _position_smoothing;
Sticks _sticks{this};
StickAccelerationXY _stick_acceleration_xy{this};
StickYaw _stick_yaw{this};
Stop _stop{this};

uORB::SubscriptionData<home_position_s> _sub_home_position{ORB_ID(home_position)};
uORB::SubscriptionData<vehicle_status_s> _sub_vehicle_status{ORB_ID(vehicle_status)};
uORB::SubscriptionData<position_setpoint_triplet_s> _sub_triplet_setpoint{ORB_ID(position_setpoint_triplet)};

DEFINE_PARAMETERS_CUSTOM_PARENT(FlightTask,
(ParamFloat<px4::params::MPC_ACC_DOWN_MAX>) _param_mpc_acc_down_max,
(ParamFloat<px4::params::MPC_ACC_HOR>) _param_mpc_acc_hor,
(ParamFloat<px4::params::MPC_ACC_UP_MAX>) _param_mpc_acc_up_max,
(ParamFloat<px4::params::MPC_JERK_AUTO>) _param_mpc_jerk_auto,
(ParamFloat<px4::params::MPC_JERK_MAX>) _param_mpc_jerk_max,

(ParamFloat<px4::params::MPC_LAND_ALT1>) _param_mpc_land_alt1,
(ParamFloat<px4::params::MPC_LAND_ALT2>) _param_mpc_land_alt2,
(ParamFloat<px4::params::MPC_LAND_ALT3>) _param_mpc_land_alt3,
(ParamFloat<px4::params::MPC_LAND_CRWL>) _param_mpc_land_crawl_speed,
(ParamFloat<px4::params::MPC_LAND_RADIUS>) _param_mpc_land_radius,
(ParamInt<px4::params::MPC_LAND_RC_HELP>) _param_mpc_land_rc_help,
(ParamFloat<px4::params::MPC_LAND_SPEED>) _param_mpc_land_speed,
(ParamFloat<px4::params::MPC_XY_ERR_MAX>) _param_mpc_xy_err_max,
(ParamFloat<px4::params::MPC_XY_TRAJ_P>) _param_mpc_xy_traj_p,
(ParamFloat<px4::params::MPC_XY_VEL_MAX>) _param_mpc_xy_vel_max,
(ParamFloat<px4::params::MPC_Z_V_AUTO_DN>) _param_mpc_z_v_auto_dn,
(ParamFloat<px4::params::MPC_Z_V_AUTO_UP>) _param_mpc_z_v_auto_up,
(ParamFloat<px4::params::NAV_MC_ALT_RAD>) _param_nav_mc_alt_rad
(ParamFloat<px4::params::MPC_LAND_SPEED>) _param_mpc_land_speed
);
private:
void _CalculateBrakingLocation();
void _HandleHighVelocities();
void _PerformLanding();
void _SmoothBrakingPath();
void _UpdateTrajConstraints();

bool _landing{false};
bool _is_initialized{false};
Expand All @@ -109,6 +96,4 @@ class FlightTaskLand : public FlightTask
Vector3f _initial_land_position;
Vector3f _land_position;
float _land_heading{0.0f};


};
Original file line number Diff line number Diff line change
Expand Up @@ -36,6 +36,7 @@ px4_add_library(FlightTaskUtility
StickAccelerationXY.cpp
StickTiltXY.cpp
StickYaw.cpp
Stop.cpp
)

target_link_libraries(FlightTaskUtility PUBLIC FlightTask hysteresis bezier SlewRate motion_planning mathlib)
Expand Down
122 changes: 122 additions & 0 deletions src/modules/flight_mode_manager/tasks/Utility/Stop.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,122 @@
/****************************************************************************
*
* Copyright (c) 2024 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#include "Stop.hpp"

Stop::Stop(ModuleParams *parent) :
ModuleParams(parent)
{
// update params of the position smoothing
_position_smoothing.setCruiseSpeed(_param_mpc_xy_vel_max.get());
_position_smoothing.setHorizontalTrajectoryGain(_param_mpc_xy_traj_p.get());
_position_smoothing.setMaxAllowedHorizontalError(_param_mpc_xy_err_max.get());
_position_smoothing.setTargetAcceptanceRadius(_param_nav_mc_alt_rad.get());
_position_smoothing.setVerticalAcceptanceRadius(_param_nav_mc_alt_rad.get());

// Update the constraints of the trajectories
_position_smoothing.setMaxVelocityXY(_param_mpc_xy_vel_max.get());
_position_smoothing.setMaxVelocityZ(math::max(_param_mpc_z_v_auto_up.get(), _param_mpc_z_v_auto_dn.get()));
_position_smoothing.setMaxAccelerationXY(_param_mpc_acc_hor.get());
_position_smoothing.setMaxAccelerationZ(math::max(_param_mpc_acc_down_max.get(), _param_mpc_acc_up_max.get()));
_position_smoothing.setMaxJerkXY(_param_mpc_jerk_auto.get());
_position_smoothing.setMaxJerkZ(_param_mpc_jerk_max.get());
}

void Stop::getConstraints(vehicle_constraints_s &constraints)
{
constraints.speed_down = 1.2f * _param_mpc_z_v_auto_dn.get();
constraints.speed_up = 1.2f * _param_mpc_xy_vel_max.get();
constraints.speed_xy = 1.2f * _param_mpc_xy_vel_max.get();
_position_smoothing.setMaxJerkXY(_param_mpc_jerk_auto.get());
_position_smoothing.setMaxJerkZ(_param_mpc_jerk_max.get());

if (_exceeded_max_vel) {
constraints.speed_down = math::max(fabsf(_position_smoothing.getCurrentVelocityZ()), constraints.speed_down);
constraints.speed_up = math::max(fabsf(_position_smoothing.getCurrentVelocityZ()), constraints.speed_up);
constraints.speed_xy = math::max(_position_smoothing.getCurrentVelocityXY().norm(), constraints.speed_xy);

_position_smoothing.setMaxAccelerationXY(CONSTANTS_ONE_G);
_position_smoothing.setMaxAccelerationZ(2 * CONSTANTS_ONE_G);
_position_smoothing.setMaxJerk(CONSTANTS_ONE_G);
_position_smoothing.setMaxJerkZ(10.f * CONSTANTS_ONE_G); // Jerk in Z direction is only limited by motor inertia.
}
}

void
Stop::initialize(const Vector3f &acceleration, const Vector3f &velocity, const Vector3f &position,
const float &deltatime)
{
isActive = true;
_position_smoothing.reset(acceleration, velocity, position);
update(acceleration, velocity, position, deltatime);

}

void
Stop::update(const Vector3f &acceleration, const Vector3f &velocity, const Vector3f &position, const float &deltatime)
{
const bool exceeded_vel_z = fabsf(velocity(2)) > math::max(_param_mpc_z_v_auto_dn.get(),
_param_mpc_z_v_auto_up.get());
const bool exceeded_vel_xy = velocity.xy().norm() > _param_mpc_xy_vel_max.get();

if ((exceeded_vel_xy
|| exceeded_vel_z)) { // If we exceed the velocity limits, set the flag so we adjust the constraints for faster breaking.
_exceeded_max_vel = true;

} else if (!(exceeded_vel_xy && exceeded_vel_z)
&& _exceeded_max_vel) { // If we are back in the allowed range, reset the position_smooting and reset the constrants.
_position_smoothing.reset(acceleration, velocity, position);
_exceeded_max_vel = false;

} else if (_position_smoothing.getCurrentVelocityZ() < 0.01f
&& _position_smoothing.getCurrentVelocityZ() > -0.01f
&& !_position_smoothing.getCurrentVelocityXY().longerThan(0.01f)) {
isActive = false;
_stop_position = position;
}

PositionSmoothing::PositionSmoothingSetpoints out_setpoints;
// Generate the setpoints
// the _stop_position is not considered, as we are only forcing a zero velocity setpoint.
_position_smoothing.generateSetpoints(
position,
_stop_position,
Vector3f{0.f, 0.f, 0.f},
deltatime,
true,
out_setpoints
);
_jerk_setpoint = out_setpoints.jerk;
_acceleration_setpoint = out_setpoints.acceleration;
_velocity_setpoint = out_setpoints.velocity;
_position_setpoint = out_setpoints.position;
}
Loading

0 comments on commit 9d90285

Please sign in to comment.