一、AEB算法

已于 2024-07-30 13:15:58 修改
阅读量2.5k 收藏 38
点赞数
文章标签： c++
于 2024-07-25 18:16:55 首次发布
原文链接：https://blog.csdn.net/m0_46499664/article/details/135959668
版权

一、AEB算法

1.1 TTC算法

碰撞时间算法TTC是指从当前时刻开始，两车保持当前车速行驶直到发生碰撞所需的时间，两车前后行驶在路上时，只有当后车车速大于前车车车速时才会进入TTC算法。为了避免碰撞，前后车应满足以下关系式：

式中：v1、a1表示前车速度、加速度，v2、a2表示后车速度、加速度，Drel表示两车相对距离，d0表示安全停车距离（一般为2mor3m）。由上述公式得到如下解：

 式中：vrel、arel表示两车相对速度、相对加速度。

然后是TTC的触发逻辑：

在TTC算法中设定时间阈值如下：TTC(预警危险)=2.6s，TTC(部分制动)=1.6s，TTC(全力制动)=0.6s。具体的控制逻辑如下：

1）TTC>2.6s：AEB系统不触发；

2）1.6s<TTC≤2.6s：AEB系统触发→发出警报；

3）0.6s<TTC≤1.6s：AEB系统触发→40%制动；

4）TTC≤0.6s：AEB系统触发→100%制动。

1.2 SeungwukMoon安全距离模型

SeungwukMoon安全距离模型计算公式如下：

 式中：dbr为危险制动距离，Tdelay为系统延迟时间，f(μ)为制动因数，amax为最大制动减速度。参考文献，取Tdelay=1.2s、 f(μ)=0.2、amax=6m/s2。

触发逻辑也很简单，当相对车距小于等于dbr后AEB触发。

以下是实现思路：

  1. 输入和输出：

    • 输入：前车速度和加速度（v1，a1），后车速度和加速度（v2，a2），两车相对距离（Drel）
    • 输出：是否触发AEB，触发类型（警报、部分制动、全力制动）

  2. 步骤：

    • 计算相对速度（vrel）和相对加速度（arel）
    • 根据公式计算TTC
    • 根据TTC值决定AEB触发类型
    • 计算危险制动距离dbr
    • 根据Seungwuk Moon模型触发AEB

下面是具体的C++代码实现：

 

cpp
 

复制代码
 

//3.cpp

#include <ros/ros.h>
#include <common_msgs/CICV_Location.h>
#include <common_msgs/Lane.h>
#include <common_msgs/Lanes.h>
#include <common_msgs/Perceptionobjects.h>
#include <common_msgs/Perceptionobject.h>
#include <std_msgs/String.h>
#include <common_msgs/Control_Test.h>
#include <cmath>
#include <thread>

class SensorData {
public:

    SensorData(ros::NodeHandle& nh) {
        // 初始化订阅器
        pose_subscriber = nh.subscribe("/cicv_location", 10, &SensorData::poseStationCallback, this);
        lane_detection_subscriber = nh.subscribe("/LaneDetection", 10, &SensorData::detectionLanesCallback, this);
        perception_subscriber = nh.subscribe("/tpperception", 10, &SensorData::obstacleCallback, this);
    }

    common_msgs::CICV_Location getCurrentPose() const {
        return current_pose;
    }

    common_msgs::Perceptionobjects getObstacles() const {
        return obstacles;
    }

private:
    ros::Subscriber pose_subscriber;
    ros::Subscriber lane_detection_subscriber;
    ros::Subscriber perception_subscriber;

    common_msgs::CICV_Location current_pose;
    common_msgs::Perceptionobjects obstacles;

    // 处理车辆位置信息的回调函数
    void poseStationCallback(const common_msgs::CICV_Location::ConstPtr& msg) {
        current_pose = *msg;
        double x, y, xv, vy, ax, ay, phi, yaw;
        //ROS_INFO("Header: %d, Frame ID: %s", current_pose.header.seq, current_pose.header.frame_id.c_str());
        x = current_pose.Position_x;
        y = current_pose.Position_y;
        xv = current_pose.Velocity_x;
        vy = current_pose.Velocity_y;
        ax = current_pose.Accel_x;
        ay = current_pose.Accel_y;
        phi = current_pose.Angular_velocity_z;
        yaw = current_pose.Yaw;
        // ROS_INFO("Received pose: x=%8.8f, y=%8.8f, vx=%8.8f, vy=%8.8f, ax=%8.8f, ay=%8.8f, phi=%8.8f, yaw=%8.8f",
        //          current_pose.Position_x, current_pose.Position_y, current_pose.Velocity_x, 
        //          current_pose.Velocity_y, current_pose.Accel_x, current_pose.Accel_y, 
        //          current_pose.Angular_velocity_z, current_pose.Yaw);
    }

    // 处理车道信息的回调函数
    void detectionLanesCallback(const common_msgs::Lanes::ConstPtr& msg) {
        common_msgs::Lanes lanes = *msg;
        // ROS_INFO("Header: %d, Frame ID: %s", lanes.header.seq, lanes.header.frame_id.c_str());
        // ROS_INFO("number of lanes:%d", lanes.num);

        double lane_idx, c_0, c_1, c_2, c_3;
        for (size_t i = 0; i < lanes.lanes.size(); ++i) {
            const common_msgs::Lane& lane = lanes.lanes[i];
            // ROS_INFO("lane_idx:%d, CO:%.8f, C1:%.8f, C2:%.8f, C3:%.8f",
            //          lane.lane_idx, lane.c_0, lane.c_1, lane.c_2, lane.c_3);
            lane_idx = lane.lane_idx;
            c_0 = lane.c_0;
            c_1 = lane.c_1;
            c_2 = lane.c_2;
            c_3 = lane.c_3;
        }
    }

    // 处理障碍物信息的回调函数
    void obstacleCallback(const common_msgs::Perceptionobjects::ConstPtr& msg) {
        obstacles = *msg;
        double object_id , object_x , object_y, object_vx , object_ax, object_vy, object_ay, object_heading, object_length, object_width, object_height;
        // ROS_INFO("Header: %d, Frame ID: %s", obstacles.header.seq, obstacles.header.frame_id.c_str());
        // ROS_INFO("number of obstacles: %d", obstacles.num);

        for (size_t i = 0; i < obstacles.Perceptionobjects.size(); ++i) {
            const common_msgs::Perceptionobject& object = obstacles.Perceptionobjects[i];
            object_id = object.ID;
            object_x = object.x;
            object_y = object.y;
            object_vx = object.v_x;
            object_ax = object.a_x; 
            object_vy = object.v_y;
            object_ay = object.a_y;
            object_heading = object.heading;
            object_length = object.length;
            object_width = object.width;
            object_height = object.height;
            // ROS_INFO("Object ID: %d, X: %.8f, Y: %.8f, vx: %.8f, vy: %.8f, ax:%.8f, ay:%.8f , xg:%.8f, yg:%.8f,"
            //          "vxg:%.8f, vyg:%.8f, heading:%.8f, length: %.8f, width: %.8f, height: %.8f ",
            //          object.ID, object.x, object.y, object.v_x, object.v_y, object.a_x, object.a_y ,object.xg, object.yg, 
            //          object.v_xg, object.v_yg, object.heading, object.length, object.width, object.height);

        }
    }
};

class Control {
public:
    Control(ros::NodeHandle& nh) {
        // 控制信息发布
        control_pub_ = nh.advertise<common_msgs::Control_Test>("/control_test", 10);
    }

    void sendControlCommand(double throttle, double brake, double steer_angle, double gear = 4) {
        common_msgs::Control_Test control_msg;
        // ROS_INFO("Header: %d, Frame ID: %s", control_msg.header.seq, control_msg.header.frame_id.c_str());
        // control_msg.header.stamp = ros::Time::now();
        control_msg.ThrottlePedal = throttle;
        control_msg.BrakePedal = brake;
        control_msg.SteeringAngle = steer_angle;
        control_msg.Gear = gear;
        control_pub_.publish(control_msg);
    }

private:
    ros::Publisher control_pub_;
};

bool braking_ = false;

class AEBSystem {
public:
    AEBSystem(ros::NodeHandle& nh, SensorData& sensor_data, Control& control) : sensor_data_(sensor_data), control_(control) 
    {
        // 初始化发布器
        aeb_pub_ = nh.advertise<std_msgs::String>("aeb_status", 10);
    }

    void checkAEB() 
    {
        const common_msgs::CICV_Location& current_pose = sensor_data_.getCurrentPose();
        const common_msgs::Perceptionobjects& obstacles = sensor_data_.getObstacles();
        if (obstacles.Perceptionobjects.empty()) 
        {
            ROS_WARN("No perception objects available");
            return;
        }
        const common_msgs::Perceptionobject& closest_object = obstacles.Perceptionobjects[0]; // 假设第一个是最近的物体
        double phi1 = closest_object.heading*(180/M_PI);
        // double phi1 = closest_object.heading;
        double phi2 = current_pose.Yaw;  
        double v1 = -closest_object.v_xg/cos(phi1); // 前车速度（车辆坐标）
        double a1 = closest_object.a_x; // 假设前车加速度未知或为0
        double v2 = current_pose.Velocity_x/cos(phi2); // 自车速度（大地坐标转车辆坐标）
        double a2 = current_pose.Accel_x/cos(phi2); // 自车加速度（大地坐标转车辆坐标）
        double x1 = closest_object.xg;
        double y1 = closest_object.yg;
        double x2 = current_pose.Position_x;
        double y2 = current_pose.Position_y;  
        double vel = -closest_object.v_xrel; //  vel为目标物x方向绝对速度减自车x方向绝对速度，单位：m/s          
        double Drel = sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2)); // 相对距离
        double TTC = calculateTTC(v1, a1, v2, a2, Drel);  
        double dbr = calculateSafetyDistance(v2,v1);
        ROS_INFO("TTC:%f, x1:%f, x2:%f, y1:%f, y2:%f, v1:%f, v2:%f, a2:%f, Drel:%f, dbr:%f ", TTC, x1, x2, y1, y1, v1, v2, a2, Drel, dbr);
        
 


        if (TTC < 2.6 && TTC >= 1.6) 
        {

                std::thread([this]() 
                {
                    control_.sendControlCommand(0.0, 0.4, 0.0);
                    ROS_INFO("AEB triggered: Warning");
                    std::this_thread::sleep_for(std::chrono::seconds(3));

                }).detach();

        } 
        else if (TTC < 1.6 && TTC >= 0.6) {

                braking_ = true;
                std::thread([this]() {
                    control_.sendControlCommand(0.0, 0.5, 0.0);
                    ROS_INFO("AEB triggered: 40%% braking");
                    std::this_thread::sleep_for(std::chrono::seconds(5));

                }).detach();

        } 
        else if (TTC < 0.6) 
        {

                std::thread([this]() {
                    control_.sendControlCommand(0.0, 1.0, 0.0);
                    ROS_INFO("AEB triggered: 100%% braking");
                    std::this_thread::sleep_for(std::chrono::seconds(5));

                }).detach();


        }
        // if (TTC<2.6&&TTC>=1.6) 
        // {

        //     control_.sendControlCommand(0.0, 0.4, 0.0);
        //     ROS_INFO("AEB triggered: Warning");
        //     //ROS_INFO("TTC: %f, phi1:%f, phi2:%f, v1:%f, a1:%f, v2:%f, a2:%f, Drel:%f, dbr:%f",TTC, phi1, phi2, v1, a1, v2, a2, Drel, dbr);

        // } 
        // else if (TTC<1.6&&TTC>=0.6) 
        // {

        //     control_.sendControlCommand(0.0, 0.5, 0.0);
        //     ROS_INFO("AEB triggered: 40%% braking");            
        //     //ROS_INFO("TTC: %f, phi1:%f, phi2:%f, v1:%f, a1:%f, v2:%f, a2:%f, Drel:%f, dbr:%f",TTC, phi1, phi2, v1, a1, v2, a2, Drel, dbr);

        // } 
        // else if (TTC<0.6) 
        // {

        //     control_.sendControlCommand(0.0, 1.0, 0.0);
        //     ROS_INFO("AEB triggered: 100%% braking");
        //     //ROS_INFO("TTC: %f, phi1:%f, phi2:%f, v1:%f, a1:%f, v2:%f, a2:%f, Drel:%f, dbr:%f",TTC, phi1, phi2, v1, a1, v2, a2, Drel, dbr);
        //     ROS_INFO("TTC: %f, phi1:%f, phi2:%f, v1:%f, a1:%f, v2:%f, a2:%f, Drel:%f, dbr:%f",TTC, phi1, phi2, v1, a1, v2, a2, Drel, dbr);
            
        // }

    }

// private:
    ros::Publisher aeb_pub_;
    // ros::Publisher aeb_control_pub_;
    SensorData& sensor_data_;
    Control& control_;
    const double d0 = 3.0;  // 安全停车距离，一般取2m或3m
    bool braking_; // 用于跟踪当前制动状态
    // 计算TTC的函数
    double calculateTTC(double v1, double a1, double v2, double a2, double Drel) 
    {
        //double vrel = -closest_object.v_xrel;  //直接获取
        // double vrel = v2 - v1;
        const common_msgs::CICV_Location& current_pose = sensor_data_.getCurrentPose();
        const common_msgs::Perceptionobjects& obstacles = sensor_data_.getObstacles();
        if (obstacles.Perceptionobjects.empty()) 
        {
            ROS_WARN("No perception objects available");
            return 0;
        }
        const common_msgs::Perceptionobject& closest_object = obstacles.Perceptionobjects[0]; // 假设第一个是最近的物体
        double vrel = -closest_object.v_x; //

        double arel = a2 - a1;
        double TTC;
        
        if (arel == 0) 
        {
            if (vrel == 0)
            {
                vrel = 0.000000001;
            }
            else 
            {
                vrel = -closest_object.v_x;

            }
            TTC = (Drel-d0) / vrel;
            TTC = std::abs(TTC);
            return TTC;
        } 
        else 
        {
            if (vrel == 0)
            {
                vrel = 0.000000001;
            }
            else 
            {
                vrel = -closest_object.v_x;

            }
            TTC = (vrel - sqrt(vrel * vrel + 2 * arel * (Drel - d0))) / arel;           
            TTC = std::abs(TTC);
            return TTC;
        }
        // std::cout<<"这里计算TTC"<<std::endl;
        // ROS_INFO("TTC: %f",TTC);
    }

    // // AEB系统触发逻辑
    // std::string AEBSystemLogic(double TTC) {
    //     if (TTC > 2.6) {
    //         return "AEB not triggered";
    //         ROS_INFO("AEB not triggered");
    //     } else if (TTC > 1.6&&TTC < 2.6) {
    //         return "AEB triggered: Warning";
    //         ROS_INFO("AEB triggered: Warning");
    //     } else if (TTC > 0.6&&TTC < 1.6) {
    //         return "AEB triggered: 40% braking";
    //         ROS_INFO("AEB triggered: 40% braking");
    //     } else {
    //         return "AEB triggered: 100% braking";
    //         ROS_INFO("AEB triggered: 100% braking");
    //     }
    // }

    // Seungwuk Moon模型
    double calculateSafetyDistance(double v2,double v1) 
    {
        const double Tdelay = 1.2;
        const double f_mu = 0.2;
        const double amax = 6.0;
        const common_msgs::CICV_Location& current_pose = sensor_data_.getCurrentPose();
        const common_msgs::Perceptionobjects& obstacles = sensor_data_.getObstacles();
        if (obstacles.Perceptionobjects.empty()) 
        {
            ROS_WARN("No perception objects available");
            return 0;
        }
        const common_msgs::Perceptionobject& closest_object = obstacles.Perceptionobjects[0]; // 假设第一个是最近的物体
        double vel = -closest_object.v_x;
        double dbr = vel * Tdelay + f_mu *((2*v2 - vel) / (2 *  amax)); //安全模型计算公式
        // double dbr = (v2-v1) * Tdelay + f_mu *((2*v2 - (v2-v1)) / (2 *  amax)); //安全模型计算公式
        return dbr;
        
    }
    void maintainBraking(Control& control, double throttle, double brake, double steer_angle, double gear, int duration) {
        ros::Rate rate(10);
        for (int i = 0; i < duration * 10; ++i) {
            control.sendControlCommand(throttle, brake, steer_angle, gear);
            rate.sleep();
        }
    }
};

int main(int argc, char **argv) {
    ros::init(argc, argv, "aeb_system_node");
    ros::NodeHandle nh;

    SensorData sensor_data(nh);
    Control control(nh);
    AEBSystem aeb_system(nh, sensor_data,control);
    std::cout << "ok,begin" << std::endl;
    ros::Rate rate(10); // 10 Hz
    while (ros::ok()) {
        ros::spinOnce(); // 处理回调函数
        aeb_system.checkAEB(); // 检查AEB触发逻辑
        rate.sleep();
    }

    return 0;
}

 

说明：
 

  1. calculateTTC函数计算碰撞时间TTC。
  2. AEBSystem函数根据TTC值决定AEB触发类型。
  3. calculateSafetyDistance函数根据Seungwuk Moon模型计算安全距离。
  4. main函数初始化ROS节点并处理传感器输入数据，通过计算TTC和安全距离来触发相应的AEB动作。
 

这个程序是一个基本框架，你可能需要根据实际数据格式和ROS消息类型做相应调整。
 

 

 

#include <ros/ros.h>
#include <common_msgs/CICV_Location.h>
#include <common_msgs/Lane.h>
#include <common_msgs/Lanes.h>
#include <common_msgs/Perceptionobjects.h>
#include <common_msgs/Perceptionobject.h>
#include <std_msgs/String.h>
#include <cmath>

class SensorData {
public:
    SensorData(ros::NodeHandle& nh) {
        // 初始化订阅器
        pose_subscriber = nh.subscribe("/cicv_location", 10, &SensorData::poseStationCallback, this);
        lane_detection_subscriber = nh.subscribe("/LaneDetection", 10, &SensorData::detectionLanesCallback, this);
        perception_subscriber = nh.subscribe("/tpperception", 10, &SensorData::obstacleCallback, this);
    }

    common_msgs::CICV_Location getCurrentPose() const {
        return current_pose;
    }

    common_msgs::Perceptionobjects getObstacles() const {
        return obstacles;
    }

private:
    ros::Subscriber pose_subscriber;
    ros::Subscriber lane_detection_subscriber;
    ros::Subscriber perception_subscriber;

    common_msgs::CICV_Location current_pose;
    common_msgs::Perceptionobjects obstacles;

    // 处理车辆位置信息的回调函数
    void poseStationCallback(const common_msgs::CICV_Location::ConstPtr& msg) {
        current_pose = *msg;
        ROS_INFO("Header: %d, Frame ID: %s", current_pose.header.seq, current_pose.header.frame_id.c_str());
        ROS_INFO("Received pose: x=%8.8f, y=%8.8f, vx=%8.8f, vy=%8.8f, ax=%8.8f, ay=%8.8f, phi=%8.8f, yaw=%8.8f",
                 current_pose.Position_x, current_pose.Position_y, current_pose.Velocity_x, 
                 current_pose.Velocity_y, current_pose.Accel_x, current_pose.Accel_y, 
                 current_pose.Angular_velocity_z, current_pose.Yaw);
    }

    // 处理车道信息的回调函数
    void detectionLanesCallback(const common_msgs::Lanes::ConstPtr& msg) {
        common_msgs::Lanes lanes = *msg;
        ROS_INFO("Header: %d, Frame ID: %s", lanes.header.seq, lanes.header.frame_id.c_str());
        ROS_INFO("number of lanes:%d", lanes.num);

        for (size_t i = 0; i < lanes.lanes.size(); ++i) {
            const common_msgs::Lane& lane = lanes.lanes[i];
            ROS_INFO("lane_idx:%d, CO:%.8f, C1:%.8f, C2:%.8f, C3:%.8f",
                     lane.lane_idx, lane.c_0, lane.c_1, lane.c_2, lane.c_3);
        }
    }

    // 处理障碍物信息的回调函数
    void obstacleCallback(const common_msgs::Perceptionobjects::ConstPtr& msg) {
        obstacles = *msg;
        ROS_INFO("Header: %d, Frame ID: %s", obstacles.header.seq, obstacles.header.frame_id.c_str());
        ROS_INFO("number of obstacles: %d", obstacles.num);

        for (size_t i = 0; i < obstacles.Perceptionobjects.size(); ++i) {
            const common_msgs::Perceptionobject& object = obstacles.Perceptionobjects[i];
            ROS_INFO("Object ID: %d, X: %.8f, Y: %.8f, vx: %.8f, vy: %.8f, xg:%.8f, yg:%.8f,"
                     "vxg:%.8f, vyg:%.8f, heading:%.8f, length: %.8f, width: %.8f, height: %.8f ",
                     object.ID, object.x, object.y, object.v_x, object.v_y, object.xg, object.yg, 
                     object.v_xg, object.v_yg, object.heading, object.length, object.width, object.height);
        }
    }
};

class AEBSystem {
public:
    AEBSystem(ros::NodeHandle& nh, SensorData& sensor_data) : sensor_data_(sensor_data) {
        // 初始化发布器
        aeb_pub_ = nh.advertise<std_msgs::String>("aeb_status", 10);
    }

    void checkAEB() {
        const common_msgs::CICV_Location& current_pose = sensor_data_.getCurrentPose();
        const common_msgs::Perceptionobjects& obstacles = sensor_data_.getObstacles();

        if (obstacles.Perceptionobjects.size() > 0) {
            const common_msgs::Perceptionobject& closest_object = obstacles.Perceptionobjects[0]; // 假设第一个是最近的物体
            double v1 = current_pose.Velocity_x; // 自车速度
            double a1 = current_pose.Accel_x; // 自车加速度
            double v2 = closest_object.v_x; // 前车速度
            double a2 = 0; // 假设前车加速度未知或为0
            double Drel = sqrt(pow(closest_object.x - current_pose.Position_x, 2) + 
                               pow(closest_object.y - current_pose.Position_y, 2)); // 相对距离

            double TTC = calculateTTC(v1, a1, v2, a2, Drel);
            std_msgs::String status_msg;
            status_msg.data = AEBSystemLogic(TTC);
            aeb_pub_.publish(status_msg);

            double safety_distance = calculateSafetyDistance(v2);
            if (Drel <= safety_distance) {
                status_msg.data = "AEB triggered: Safety Distance Breached";
                aeb_pub_.publish(status_msg);
            }
        }
    }

private:
    ros::Publisher aeb_pub_;
    SensorData& sensor_data_;

    const double d0 = 3.0;  // 安全停车距离，一般取2m或3m

    // 计算TTC的函数
    double calculateTTC(double v1, double a1, double v2, double a2, double Drel) {
        double vrel = v2 - v1;
        double arel = a2 - a1;
        
        if (arel == 0) {
            return Drel / vrel;
        } else {
            return (vrel - sqrt(vrel * vrel - 2 * arel * (Drel - d0))) / arel;
        }
    }

    // AEB系统触发逻辑
    std::string AEBSystemLogic(double TTC) {
        if (TTC > 2.6) {
            return "AEB not triggered";
        } else if (TTC > 1.6) {
            return "AEB triggered: Warning";
        } else if (TTC > 0.6) {
            return "AEB triggered: 40% braking";
        } else {
            return "AEB triggered: 100% braking";
        }
    }

    // Seungwuk Moon模型
    double calculateSafetyDistance(double v2) {
        const double Tdelay = 1.2;
        const double f_mu = 0.2;
        const double amax = 6.0;
        return v2 * Tdelay + (v2 * v2) / (2 * f_mu * amax);
    }
};

int main(int argc, char **argv) {
    ros::init(argc, argv, "aeb_system_node");
    ros::NodeHandle nh;

    SensorData sensor_data(nh);
    AEBSystem aeb_system(nh, sensor_data);

    ros::Rate rate(10); // 10 Hz
    while (ros::ok()) {
        ros::spinOnce(); // 处理回调函数
        aeb_system.checkAEB(); // 检查AEB触发逻辑
        rate.sleep();
    }

    return 0;
}

 


                

        

    

  



    



                



	

		

			

				
					
AEB算法：原理与系统组成（基于点云）

				
			

			

				

					QfcaLinux的博客
				

				

					09-26
					
					2058
					
				

			

		

		

			
				
AEB算法通过分析车辆周围环境的点云数据，检测障碍物并评估碰撞风险，从而触发紧急制动以减少碰撞风险。实际的AEB系统可能使用更复杂的算法和传感器，并考虑更多的参数和情况来提高安全性和可靠性。在本文中，我们将介绍AEB算法的原理和系统组成，并提供相应的点云源代码示例。如果算法认为存在潜在碰撞风险，它将向车辆的制动系统发送紧急制动指令，以减少碰撞的严重程度或完全避免碰撞。AEB算法基于车辆周围环境感知和实时监测，通过分析车辆与周围障碍物的相对运动状态，判断是否存在潜在的碰撞风险，并采取相应的紧急制动措施。

			
		

	



                

            
              



	

		

			

				
					
AEB算法模型matlab版本


				
			

			

				

					05-28
				

			

		

		

			
				
AEB算法模型matlab版本

			
		

	



              


  
              

                


	

		

			

				
					
AEB（自动紧急制动）

				
			

			

				

					百态老人的博客
				

				

					02-14
					
					926
					
				

			

		

		

			
				
AEB系统对静止物体的误判率受多种因素影响，包括传感器精度、算法复杂性以及环境条件等。通过多传感器融合、算法优化、硬件升级以及环境适应性增强等技术手段，可以有效减少误判问题。美国和欧洲的AEB法规均强调了技术性能和安全性，但具体要求有所不同。美国的NHTSA规定更注重高速和复杂场景下的紧急制动能力，而欧盟的ECE R152法规则更侧重于基础的AEB功能覆盖范围。

			
		

	





	

		

			

				
					
AEB&ACC算法

				
			

			

				

					blog
				

				

					07-12
					
					1万+
					
				

			

		

		

			
				
AEB&ACC



			
		

	



		

			
		



	

		

			

				
					
TTC与THW：理解自动驾驶中的两个关键指标

				
			

			

				

					wyhd1998的博客
				

				

					08-24
					
					6681
					
				

			

		

		

			
				
TTC指的是在保持当前速度和方向的情况下，车辆与前方障碍物发生碰撞所需的时间1。TTCDistanceRelativeSpeedTTCRelativeSpeedDistance​其中，Distance表示车辆与障碍物之间的距离，Relative Speed表示车辆与障碍物之间的相对速度。THW指的是车辆与前车之间的时间间隔2。

			
		

	





	

		

			

				
					
一文读懂TTC碰撞时间算法

					
热门推荐

				
			

			

				

					qq_22751305的博客
				

				

					01-28
					
					2万+
					
				

			

		

		

			
				
TTC（Time-to-collision or time-to-contact）为自车与目标碰撞所需的时间。在ADAS中，TTC是一个用来评价行车是否安全的重要指标。基于单目的TTC计算是一个比较具有挑战性的问题。本博文主要介绍论文Time To Contact Estimation Using Interest Points中的方法。



《Time To Contact Estimation Using Interest Points》


...

			
		

	





	

		

			

				
					
AEB算法开发（基于Matlab driving Toolbox）

				
			

			

				

					qq_67958647的博客
				

				

					01-21
					
					5104
					
				

			

		

		

			
				
本节采用matlab自动驾驶工具箱开发AEB算法，首先建立仿真场景并添加传感器，在传感器融合得到障碍物信息之后，搭建AEB算法模块进行仿真测试；

			
		

	





	

		

			

				
					
gsensor 车辆碰撞算法_AEB安全模型（一）——基于碰撞时间的安全模型

				
			

			

				

					weixin_39542710的博客
				

				

					12-27
					
					3663
					
				

			

		

		

			
				
在讨论这些模型之前，我们来了解一些术语和简称：FCW：前向碰撞预警（Forward Collision Warning）AEB：自动紧急制动（Autonomous Emergency Braking）===============================================这种模型的核心在于——碰撞时间TTC(Time-To-Collision)总得来说，这种模型的运作过程如下...

			
		

	





	

		

			

				
					
11-4 AEB 算法原理及系统组成

				
			

			

				

					AIgraphX
				

				

					06-13
					
					6215
					
				

			

		

		

			
				
本专题旨在探讨如何利用仿真软件开发自动紧急制动系统AEB，主要通过整理开发流程，实现从需求到验证的全流程掌握，为后续开发提供支持；同时，研究了如何在汽车自动驾驶仿真工具中开发自己的算法，并解决了从ISO、E-CNAP、GB/T以及交通法规等提炼出功能需求的问题，以快速实现原型模型的开发。本专题重点讲解了AEB的工作原理、系统/软件架构和需求、算法模型及实现、CCRs/CCRb/CCRm建模与仿真、VRU-AEB-B/P/M建模与仿真，同时还提供了测试用例，期待将AEB算法成功地产品化。

			
		

	





	

		

			

				
					
AEB算法可视化（基于m脚本）

				
			

			

				

					qq_67958647的博客
				

				

					01-23
					
					1136
					
				

			

		

		

			
				
本文采用Matlab自动驾驶工具箱与m脚本结合进行可视化，对感知层不采用scenarioReader模块进行融合处理。

			
		

	





	

		

			

				
					
辅助驾驶AEB的控制策略源代码

				
			

			

				

					05-29
				

			

		

		

			
				
源代码来源于辅助驾驶仿真软件Prescan，主要涉及一些AEB的算法，比较基础，属于入门级别

			
		

	





	

		

			

				
					
基于prescan的aeb系统纵向避撞算法及仿真验证.pdf

				
			

			

				

					01-04
				

			

		

		

			
				
基于prescan的aeb系统纵向避撞算法及仿真验证.pdf

			
		

	





	

		

			

				
					
AEB_Function_基本AEB模型_ttc_AEB_AEB距离_

				
			

			

				

					09-29
				

			

		

		

			
				
利用相对速度、相对距离，根据TTC时间模型，可实现基本AEB功能

			
		

	





	

		

			

				
					
swc_aeb_AEBTTC_AEB_aeb中ttc怎么算_AEB自动驾驶_

				
			

			

				

					09-30
				

			

		

		

			
				
TTC计算 横偏距离计算

			
		

	





	

		

			

				
					
自动驾驶领域基于TTC和驾驶员安全距离模型的AEB算法Carsim与Simulink联合仿真研究

					
最新发布

				
			

			

				

					03-30
				

			

		

		

			
				
文中介绍了AEB算法的核心模块，包括CCR M、CCRS、CCRB模型，以及二级制动策略和逆制动器模型的设计思路。同时，还讨论了控制模糊PID模型的应用及其参数调整方法。此外，文章强调了联合仿真过程中Carsim和Simulink...

			
		

	





	

		

			

				
					
AEB算法仿真-matlab+prescan

				
			

			

				

					08-10
				

			

		

		

			
				
大厂量产方案仿真TTC求解

			
		

	





	

		

			

				
					
描述AEB中TTC算法

				
			

			

				

					m0_46499664的博客
				

				

					01-31
					
					3317
					
				

			

		

		

			
				
最近在做关于AEB的联合仿真，做一个简单的记录以及教学。Carisim版本：Carsim2019.0。

			
		

	





	

		

			

				
					
辅助驾驶功能开发-功能算法篇(1)-AEB-自车轨迹预测

				
			

			

				

					2301_78837294的博客
				

				

					09-15
					
					955
					
				

			

		

		

			
				
如果按照100km/h车速，8m/s^2减速度计算，需要3.5s的时间，所以需要对车辆进行至少3.5s的轨迹预估，一段Bezier曲线无法满足当前需求，采用四段Bezier曲线即可实现未来4s的估计预估，在这未来4s里，控制器需要对本车车辆进行轨迹的预测、速度加速度的估计，且同时对威胁目标进行4s内的状态估计，对目标估计采用的时间是TTI时间，该时间也是根据本车与目标状态估算的，所以只要保证TTI时间小于4s就是满足预测需求的；

			
		

	





	

		

			

				
					
Carsim联合Simulink的车辆AEB仿真（时间、距离算法）

				
			

			

				

					qq_63303818的博客
				

				

					08-29
					
					1万+
					
				

			

		

		

			
				
最近在做关于AEB的联合仿真，做一个简单的记录以及教学。Carisim版本：Carsim2019.0Matlab版本：Matlab2021b。

			
		

	





	

		

			

				
					
aeb算法模型prescan

				
			

			

				

					12-31
				

			

		

		

			
				
### AEB算法模型在Prescan中的实现与应用

#### 1. AEB算法概述
自动紧急制动(Autonomous Emergency Braking, AEB)系统能够在检测到潜在碰撞风险时自动采取减速措施，从而减轻或避免事故的发生。AEB系统的开发涉及多个方面的工作，包括但不限于工作原理的理解、系统/软件架构的设计以及需求分析等[^1]。

#### 2. 使用PreScan进行环境及感知系统构建
对于希望深入了解并实践AEB算法的同学来说，可以利用PreScan这一强大的工具来创建逼真的测试环境。通过它不仅可以建立各种复杂的道路状况（如环岛、十字路口），还能加入额外的对象比如建筑物和自然景观元素，使得整个场景更加贴近真实世界的情况。这有助于提高后续仿真的准确性[^4]。

#### 3. Simulink中基于安全距离模型的AEB算法搭建
当涉及到具体的技术细节时，则可以在MATLAB/Simulink环境中完成核心逻辑部分——即所谓的“基于安全距离”的控制策略。此过程通常会围绕着定义合理的跟车间距展开讨论，并据此制定相应的决策流程图；之后再将其转换成易于理解和操作的形式化表达方式以便编程实现。值得注意的是，在这里所提到的安全距离并非固定不变而是动态调整的，其计算依据车辆当前的速度以及其他因素共同决定[^2]。

```matlab
function [brakeCmd] = aebControl(vEgo,vTar,dist)
    % 定义参数
    safeDist = vEgo * 0.8; % 计算安全距离
    
    if dist < safeDist && vTar < vEgo
        brakeCmd = true;
    else
        brakeCmd = false;
    end
end
```

#### 4. 联合仿真验证AEB性能
最后一步就是将上述两部分内容结合起来做进一步的研究了。借助于PreScan提供的接口支持，能够轻松地把之前编写的Simulink模块导入进来并与之交互运行。这样一来就可以方便快捷地观察不同条件下AEB的表现效果，进而找出可能存在的问题所在并对原有方案做出适当改进直至满足预期目标为止[^3]。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 2

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值