apollo::planning::STDrivingLimits类 参考

#include <st_driving_limits.h>

apollo::planning::STDrivingLimits 的协作图:

Public 成员函数
	STDrivingLimits ()
void	Init (const double max_acc, const double max_dec, const double max_v, double curr_v)
virtual	~STDrivingLimits ()=default
std::pair< double, double >	GetVehicleDynamicsLimits (const double t) const
	Given time t, calculate the driving limits in s due to vehicle's dynamics.
void	UpdateBlockingInfo (const double t, const double lower_s, const double lower_v, const double upper_s, const double upper_v)
	Update the anchoring of the vehicle dynamics limits.

详细描述

在文件 st_driving_limits.h 第 39 行定义.

构造及析构函数说明

STDrivingLimits()

apollo::planning::STDrivingLimits::STDrivingLimits ( )

inline

在文件 st_driving_limits.h 第 41 行定义.

{}

~STDrivingLimits()

virtual apollo::planning::STDrivingLimits::~STDrivingLimits ( )

virtualdefault

成员函数说明

GetVehicleDynamicsLimits()

std::pair< double, double > apollo::planning::STDrivingLimits::GetVehicleDynamicsLimits

(

const double

t

)

const

Given time t, calculate the driving limits in s due to vehicle's dynamics.

参数

Timestamp

t.

返回

The lower and upper bounds.

在文件 st_driving_limits.cc 第 39 行定义.

                          {
  std::pair<double, double> dynamic_limits;
  // Process lower bound: (constant deceleration)
  double dec_time = lower_v0_ / max_dec_;
  if (t - lower_t0_ < dec_time) {
    dynamic_limits.first =
        lower_s0_ + (lower_v0_ - max_dec_ * (t - lower_t0_) + lower_v0_) *
                        (t - lower_t0_) * 0.5;
  } else {
    dynamic_limits.first = lower_s0_ + (lower_v0_ * dec_time) * 0.5;
  }
 
  // Process upper bound: (constant acceleration)
  double acc_time = (max_v_ - upper_v0_) / max_acc_;
  if (t - upper_t0_ < acc_time) {
    dynamic_limits.second =
        upper_s0_ + (upper_v0_ + max_acc_ * (t - upper_t0_) + upper_v0_) *
                        (t - upper_t0_) * 0.5;
  } else {
    dynamic_limits.second = upper_s0_ + (upper_v0_ + max_v_) * acc_time * 0.5 +
                            (t - upper_t0_ - acc_time) * max_v_;
  }
 
  return dynamic_limits;
}

Init()

void apollo::planning::STDrivingLimits::Init	(	const double	max_acc,
		const double	max_dec,
		const double	max_v,
		double	curr_v
	)

在文件 st_driving_limits.cc 第 26 行定义.

                                                              {
  max_acc_ = max_acc;
  max_dec_ = max_dec;
  max_v_ = max_v;
  upper_t0_ = 0.0;
  upper_v0_ = curr_v;
  upper_s0_ = 0.0;
  lower_t0_ = 0.0;
  lower_v0_ = curr_v;
  lower_s0_ = 0.0;
}

UpdateBlockingInfo()

void apollo::planning::STDrivingLimits::UpdateBlockingInfo	(	const double	t,
		const double	lower_s,
		const double	lower_v,
		const double	upper_s,
		const double	upper_v
	)

Update the anchoring of the vehicle dynamics limits.

For example, when ADC is blocked by some obstacle, its max. drivable area, max. speed, etc. are also limited subsequently.

参数

Time	t
lower	bound in s
lower	bound's corresponding speed.
upper	bound in s
upper	bound's corresponding speed.

在文件 st_driving_limits.cc 第 66 行定义.

                                                               {
  auto curr_bounds = GetVehicleDynamicsLimits(t);
  if (curr_bounds.first < lower_s) {
    // lower_v0_ = std::fmax(lower_v, 0.0);
    lower_v0_ = std::fmax(0.0, lower_v0_ - max_dec_ * (t - lower_t0_));
    lower_t0_ = t;
    lower_s0_ = lower_s;
  }
  if (curr_bounds.second > upper_s) {
    // upper_v0_ = std::fmax(upper_v, 0.0);
    upper_v0_ = std::fmin(max_v_, upper_v0_ + max_acc_ * (t - upper_t0_));
    upper_t0_ = t;
    upper_s0_ = upper_s;
  }
}

---

该类的文档由以下文件生成:

• modules/planning/tasks/st_bounds_decider/st_driving_limits.h
• modules/planning/tasks/st_bounds_decider/st_driving_limits.cc