《从0开始搭建实现apollo9.0》系列三 CANBUS模块解读

已于 2024-03-04 21:35:53 修改
阅读量400 收藏 4
点赞数 4
分类专栏： 无人驾驶 文章标签： Apollo 无人驾驶 自动驾驶 Apollo9.0
于 2024-03-02 09:19:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li1886477130/article/details/136410118
版权

二、CANBUS代码

1、canbus模块的软件架构如下：

在这里插入图片描述
主要输入输出
输入：apollo::control::ControlCommand | 控制指令 输出： /apollo/chassis | apollo::canbus::Chassis | 车辆底盘信息接口数据，包括车辆速度、方向盘转角、档位、底盘状态等信息 |
| /apollo/chassis_detail | apollo::${Vehicle_Type} | 车辆底盘详细信息，展示发送和接收底盘报文解析数据 |
其中canbus文件夹是canbus模块的主程序入口，构造函数为周期触发的函数，周期执行。

class CanbusComponent final : public apollo::cyber::TimerComponent {

构造函数后进入init函数

bool CanbusComponent::Init() {
    AINFO << "CanbusComponent init: ";
    // 加载配置文件
    if (!GetProtoConfig(&canbus_conf_)) {
        AERROR << "Unable to load canbus conf file: " << ConfigFilePath();
        return false;
    }
    AINFO << "The canbus conf file is loaded: " << FLAGS_canbus_conf_file;
    ADEBUG << "Canbus_conf:" << canbus_conf_.ShortDebugString();
    //加载车辆类型
    if (!apollo::cyber::common::PathExists(FLAGS_load_vehicle_library)) {
        AERROR << FLAGS_load_vehicle_library << " No such vehicle library";
        return false;
    }
    AINFO << "Load the vehicle factory library: " << FLAGS_load_vehicle_library;
    ClassLoader loader(FLAGS_load_vehicle_library);
    auto vehicle_object = loader.CreateClassObj<AbstractVehicleFactory>(FLAGS_load_vehicle_class_name);
    if (!vehicle_object) {
        AERROR << "Failed to create the vehicle factory: " << FLAGS_load_vehicle_class_name;
        return false;
    }
    AINFO << "Successfully create vehicle factory: " << FLAGS_load_vehicle_class_name;
    vehicle_object_ = vehicle_object;
    if (!vehicle_object_->Init(&canbus_conf_)) {
        AERROR << "Fail to init vehicle factory.";
        return false;
    }
    AINFO << "Vehicle factory is successfully initialized.";
    // cyber::ReaderConfig guardian_cmd_reader_config;
    // guardian_cmd_reader_config.channel_name = FLAGS_guardian_topic;
    // guardian_cmd_reader_config.pending_queue_size = FLAGS_guardian_cmd_pending_queue_size;
    cyber::ReaderConfig control_cmd_reader_config;
    control_cmd_reader_config.channel_name = FLAGS_control_command_topic;
    control_cmd_reader_config.pending_queue_size = FLAGS_control_cmd_pending_queue_size;
    cyber::ReaderConfig chassis_cmd_reader_config;
    chassis_cmd_reader_config.channel_name = FLAGS_chassis_command_topic;
    chassis_cmd_reader_config.pending_queue_size = FLAGS_control_cmd_pending_queue_size;
    // if (FLAGS_receive_guardian) {
    //     guardian_cmd_reader_ = node_->CreateReader<GuardianCommand>(
    //             guardian_cmd_reader_config, [this](const std::shared_ptr<GuardianCommand> &cmd) {
    //                 ADEBUG << "Received guardian data: run canbus callback.";
    //                 OnGuardianCommand(*cmd);
    //             });
    // } else
    {     
        //订阅topic
        control_command_reader_ = node_->CreateReader<ControlCommand>(
                control_cmd_reader_config, [this](const std::shared_ptr<ControlCommand> &cmd) {
                    ADEBUG << "Received control data: run canbus callback.";
                    OnControlCommand(*cmd);
                });
        chassis_command_reader_ = node_->CreateReader<ChassisCommand>(
                chassis_cmd_reader_config, [this](const std::shared_ptr<ChassisCommand> &cmd) {
                    ADEBUG << "Received control data: run canbus callback.";
                    OnChassisCommand(*cmd);
                });
    }
    // 发布topic
    chassis_writer_ = node_->CreateWriter<Chassis>(FLAGS_chassis_topic);
    if (!vehicle_object_->Start()) {
        AERROR << "Fail to start canclient, cansender, canreceiver, canclient, "
                  "vehicle controller.";
        Clear();
        return false;
    }
    AINFO << "Start canclient cansender, canreceiver, canclient, vehicle "
             "controller successfully.";
    monitor_logger_buffer_.INFO("Canbus is started.");
    return true;
}

收到控制指令control_command后调用回调函数，将控制指令中的油门、刹车、档位、灯光等指令，转换成对应的报文下发至底盘。vehicle_object_为实例化车辆类型，UpdateCommand跳转到车型内部的更新命令函数。

void CanbusComponent::OnControlCommand(const ControlCommand &control_command) {
    int64_t current_timestamp = Time::Now().ToMicrosecond();
    // if command coming too soon, just ignore it.
    if (current_timestamp - last_timestamp_ < FLAGS_min_cmd_interval * 1000) {
        ADEBUG << "Control command comes too soon. Ignore.\n Required "
                  "FLAGS_min_cmd_interval["
               << FLAGS_min_cmd_interval << "], actual time interval[" << current_timestamp - last_timestamp_ << "].";
        return;
    }
    last_timestamp_ = current_timestamp;
    ADEBUG << "Control_sequence_number:" << control_command.header().sequence_num() << ", Time_of_delay:"
           << current_timestamp - static_cast<int64_t>(control_command.header().timestamp_sec() * 1e6)
           << " micro seconds";
    vehicle_object_->UpdateCommand(&control_command);
}

回调函数跳转至所选车型的内部更新控制指令。vehicle_controller_->Update为更新控制指令， can_sender_.Update()为can卡将can报文数据发送出去。

void GemVehicleFactory::UpdateCommand(
    const apollo::control::ControlCommand *control_command) {
  if (vehicle_controller_->Update(*control_command) != ErrorCode::OK) {
    AERROR << "Failed to process callback function OnControlCommand because "
              "vehicle_controller_->Update error.";
    return;
  }
  can_sender_.Update();
}

跳转的Update函数，在此将控制指令解析，更新控制指令，赋值自动驾驶模式，并对对加速度、减速度、档位等进行赋值。

ErrorCode VehicleController<SensorType>::Update(const ControlCommand &control_command) {
    if (!is_initialized_) {
        AERROR << "Controller is not initialized.";
        return ErrorCode::CANBUS_ERROR;
    }
	//首先判断初始化
	//再检测是否有pad或teleop脚本测试信息传入
	//并根据传入的指令进行SetDrivingMode的设置。
    // Execute action to transform driving mode
    AINFO << " control_command.has_pad_msg() " << control_command.has_pad_msg();
    AINFO << " control_command.pad_msg().has_action() " << control_command.pad_msg().has_action();
    if (control_command.has_pad_msg() && control_command.pad_msg().has_action()) {
        AINFO << "Canbus received pad msg: " << control_command.pad_msg().ShortDebugString();
        if (control_command.pad_msg().action() == control::DrivingAction::VIN_REQ) {
            if (!VerifyID()) {
                AINFO << "Response vid failed, please request again.";
            } else {
                AINFO << "Response vid success!";
            }
        } else {
            Chassis::DrivingMode mode = Chassis::COMPLETE_MANUAL;
            switch (control_command.pad_msg().action()) {
            case control::DrivingAction::START: {
                mode = Chassis::COMPLETE_AUTO_DRIVE;
                break;
            }
            case control::DrivingAction::RESET: {
                break;
            }
            default: {
                AERROR << "No response for this action.";
                break;
            }
            }
            auto error_code = SetDrivingMode(mode);//判断DrivingMode的模式，下面展开讲解
            if (error_code != ErrorCode::OK) {
                AERROR << "Failed to set driving mode.";
            } else {
                AINFO << "Set driving mode success.";
            }
        }
    }
     //再判断自动驾驶状态，并将控制的指令发送至车型的档位、油门、刹车处理函数内
    //可根据不同的状态，设置不同的自动驾驶模式
    //COMPLETE_AUTO_DRIVE、AUTO_SPEED_ONLY、AUTO_STEER_ONLY
    if (driving_mode() == Chassis::COMPLETE_AUTO_DRIVE || driving_mode() == Chassis::AUTO_SPEED_ONLY) {
        Gear(control_command.gear_location());
        Throttle(control_command.throttle());
        Acceleration(control_command.acceleration());
        Brake(control_command.brake());
        SetEpbBreak(control_command);
        SetLimits();
    }
    if (driving_mode() == Chassis::COMPLETE_AUTO_DRIVE || driving_mode() == Chassis::AUTO_STEER_ONLY) {
        const double steering_rate_threshold = 1.0;
        Steer(control_command.steering_target());
    }
    if ((driving_mode() == Chassis::COMPLETE_AUTO_DRIVE || driving_mode() == Chassis::AUTO_SPEED_ONLY
         || driving_mode() == Chassis::AUTO_STEER_ONLY)
        && control_command.has_signal()) {
        HandleVehicleSignal(ProcessCommandChange(control_command.signal(), &last_control_command_));
    }
    return ErrorCode::OK;
}

SetDrivingMode函数根据传如的DrivingMode的类型进行switch判断，并进行相应的使能

ErrorCode VehicleController<SensorType>::SetDrivingMode(const Chassis::DrivingMode &driving_mode) {
    if (driving_mode == Chassis::EMERGENCY_MODE) {
        AINFO << "Can't set vehicle to EMERGENCY_MODE driving mode.";
        return ErrorCode::CANBUS_ERROR;
    }
    // vehicle in emergency mode only response to manual mode to reset.
    if (this->driving_mode() == Chassis::EMERGENCY_MODE && driving_mode != Chassis::COMPLETE_MANUAL) {
        AINFO << "Vehicle in EMERGENCY_MODE, only response to COMPLETE_MANUAL mode.";
        AINFO << "Only response to RESET ACTION.";
        return ErrorCode::CANBUS_ERROR;
    }
    // if current mode is same as previous, no need to set.
    if (this->driving_mode() == driving_mode) {
        return ErrorCode::OK;
    }
    // if current mode is same as previous, no need to set.
    // if (this->driving_mode() == driving_mode) {
    //     AINFO << "this->driving_mode() == driving_mode";
    //     return ErrorCode::OK;
    // }
    AINFO << " begin  switch driving mode ";
    switch (driving_mode) {
    case Chassis::COMPLETE_AUTO_DRIVE: {
        AINFO << " current is COMPLETE_AUTO_DRIVE ";
        if (EnableAutoMode() != ErrorCode::OK) {
            AERROR << "Failed to enable auto mode.";
            return ErrorCode::CANBUS_ERROR;
        }
        break;
    }
    case Chassis::COMPLETE_MANUAL: {
        if (DisableAutoMode() != ErrorCode::OK) {
            AERROR << "Failed to disable auto mode.";
            return ErrorCode::CANBUS_ERROR;
        }
        break;
    }
    case Chassis::AUTO_STEER_ONLY: {
        if (EnableSteeringOnlyMode() != ErrorCode::OK) {
            AERROR << "Failed to enable steer only mode.";
            return ErrorCode::CANBUS_ERROR;
        }
        break;
    }
    case Chassis::AUTO_SPEED_ONLY: {
        if (EnableSpeedOnlyMode() != ErrorCode::OK) {
            AERROR << "Failed to enable speed only mode";
            return ErrorCode::CANBUS_ERROR;
        }
        break;
    }
    default:
        break;
    }
    return ErrorCode::OK;
}

EnableAutoMode函数确定进入automode后，也会跳转至can_sender_->Update();函数进行can报文数据的发送。

ErrorCode GemController::EnableAutoMode() {
  if (driving_mode() == Chassis::COMPLETE_AUTO_DRIVE) {
    AINFO << "Already in COMPLETE_AUTO_DRIVE mode";
    return ErrorCode::OK;
  }

  global_cmd_69_->set_pacmod_enable(
      Global_cmd_69::PACMOD_ENABLE_CONTROL_ENABLED);
  global_cmd_69_->set_clear_override(
      Global_cmd_69::CLEAR_OVERRIDE_CLEAR_ACTIVE_OVERRIDES);
  can_sender_->Update();
  const int32_t flag =
      CHECK_RESPONSE_STEER_UNIT_FLAG | CHECK_RESPONSE_SPEED_UNIT_FLAG;
  if (!CheckResponse(flag, true)) {
    AERROR << "Failed to switch to COMPLETE_AUTO_DRIVE mode.";
    Emergency();
    set_chassis_error_code(Chassis::CHASSIS_ERROR);
    return ErrorCode::CANBUS_ERROR;
  }
  set_driving_mode(Chassis::COMPLETE_AUTO_DRIVE);
  AINFO << "Switch to COMPLETE_AUTO_DRIVE mode ok.";
  return ErrorCode::OK;
}

进入车型的档位、油门、刹车处理函数内后：

// NEUTRAL, REVERSE, DRIVE
//根据控制指令内部的档位要求，将档位的枚举值赋值至报文内，从而protocol内会将该值转换为CAN格式的数据
void GemController::Gear(Chassis::GearPosition gear_position) {
  if (driving_mode() != Chassis::COMPLETE_AUTO_DRIVE &&
      driving_mode() != Chassis::AUTO_SPEED_ONLY) {
    AINFO << "This drive mode no need to set gear.";
    return;
  }
  switch (gear_position) {
    case Chassis::GEAR_NEUTRAL: {
      shift_cmd_65_->set_shift_cmd(Shift_cmd_65::SHIFT_CMD_NEUTRAL);
      break;
    }
    case Chassis::GEAR_REVERSE: {
      shift_cmd_65_->set_shift_cmd(Shift_cmd_65::SHIFT_CMD_REVERSE);
      break;
    }
    case Chassis::GEAR_DRIVE: {
      shift_cmd_65_->set_shift_cmd(Shift_cmd_65::SHIFT_CMD_FORWARD);
      break;
    }
    case Chassis::GEAR_INVALID: {
      AERROR << "Gear command is invalid!";
      shift_cmd_65_->set_shift_cmd(Shift_cmd_65::SHIFT_CMD_NEUTRAL);
      break;
    }
    default: {
      shift_cmd_65_->set_shift_cmd(Shift_cmd_65::SHIFT_CMD_NEUTRAL);
      break;
    }
  }
}
//刹车有不同的类型，有之间使用减速度实际值控制的刹车，也有使用百分比控制的刹车，具体需要根据自己的控制方式和CAN协议进行选择
// brake with new acceleration
// acceleration:0.00~99.99, unit:
// acceleration:0.0 ~ 7.0, unit:m/s^2
// acceleration_spd:60 ~ 100, suggest: 90
// -> pedal
void GemController::Brake(double pedal) {
  // double real_value = params_.max_acc() * acceleration / 100;
  // TODO(QiL) Update brake value based on mode
  if (driving_mode() != Chassis::COMPLETE_AUTO_DRIVE &&
      driving_mode() != Chassis::AUTO_SPEED_ONLY) {
    AINFO << "The current drive mode does not need to set acceleration.";
    return;
  }
  brake_cmd_6b_->set_brake_cmd(pedal / 100.0);
}
// 油门的控制有两种方式，一种是节气门踏板控制，一种是加速度控制，取决于车辆的控制协议
// 节气门踏板控制方式，按照百分比控制
// drive with old acceleration
// gas:0.00~99.99 unit:
void GemController::Throttle(double pedal) {
  if (driving_mode() != Chassis::COMPLETE_AUTO_DRIVE &&
      driving_mode() != Chassis::AUTO_SPEED_ONLY) {
    AINFO << "The current drive mode does not need to set acceleration.";
    return;
  }
  accel_cmd_67_->set_accel_cmd(pedal / 100.0);
}
//加速度方式控制，正向加速，负向减速
// drive with acceleration/deceleration
// acc:-7.0 ~ 5.0, unit:m/s^2
void GemController::Acceleration(double acc) {
  if (driving_mode() != Chassis::COMPLETE_AUTO_DRIVE &&
      driving_mode() != Chassis::AUTO_SPEED_ONLY) {
    AINFO << "The current drive mode does not need to set acceleration.";
    return;
  }
  // None
}
// 转向角度，可以角度控制，也可以百分比方式控制，但是百分百控制需转换为实际角度，注意方向
// gem default, -470 ~ 470, left:+, right:-
// need to be compatible with control module, so reverse
// steering with old angle speed
// angle:-99.99~0.00~99.99, unit:, left:-, right:+
void GemController::Steer(double angle) {
  if (driving_mode() != Chassis::COMPLETE_AUTO_DRIVE &&
      driving_mode() != Chassis::AUTO_STEER_ONLY) {
    AINFO << "The current driving mode does not need to set steer.";
    return;
  }
  const double real_angle = vehicle_params_.max_steer_angle() * angle / 100.0;
  steering_cmd_6d_->set_position_value(real_angle)->set_speed_limit(9.0);
}
// 根据转向角和转向角速度，来控制车辆，根据实际的协议进行选择
// steering with new angle speed
// angle:-99.99~0.00~99.99, unit:, left:-, right:+
// angle_spd:0.00~99.99, unit:deg/s
void GemController::Steer(double angle, double angle_spd) {
  if (driving_mode() != Chassis::COMPLETE_AUTO_DRIVE &&
      driving_mode() != Chassis::AUTO_STEER_ONLY) {
    AINFO << "The current driving mode does not need to set steer.";
    return;
  }
  const double real_angle = vehicle_params_.max_steer_angle() * angle / 100.0;
  const double real_angle_spd =
      ProtocolData<::apollo::canbus::Gem>::BoundedValue(
          vehicle_params_.min_steer_angle_rate(),
          vehicle_params_.max_steer_angle_rate(),
          vehicle_params_.max_steer_angle_rate() * angle_spd / 100.0);
  steering_cmd_6d_->set_position_value(real_angle)
      ->set_speed_limit(real_angle_spd);
}

转向灯光和灯光可以根据具体的协议进行添加

void GemController::SetBeam(const VehicleSignal& vehicle_signal) {
  if (vehicle_signal.high_beam()) {
    // None
  } else if (vehicle_signal.low_beam()) {
    // None
  } else {
    // None
  }
}
void GemController::SetHorn(const VehicleSignal& vehicle_signal) {
  if (vehicle_signal.horn()) {
    // None
  } else {
    // None
  }
}
void GemController::SetTurningSignal(const VehicleSignal& vehicle_signal) {
  // Set Turn Signal
  auto signal = vehicle_signal.turn_signal();
  if (signal == common::VehicleSignal::TURN_LEFT) {
    turn_cmd_63_->set_turn_signal_cmd(Turn_cmd_63::TURN_SIGNAL_CMD_LEFT);
  } else if (signal == common::VehicleSignal::TURN_RIGHT) {
    turn_cmd_63_->set_turn_signal_cmd(Turn_cmd_63::TURN_SIGNAL_CMD_RIGHT);
  } else {
    turn_cmd_63_->set_turn_signal_cmd(Turn_cmd_63::TURN_SIGNAL_CMD_NONE);
  }
}

chassis函数是解析底盘反馈的报文数据，再赋值至chassis消息内，可在cyber_mointor，上监视chassis内部的消息，details内可看报文的具体信息。

Chassis GemController::chassis() {
  chassis_.Clear();
  Gem chassis_detail;
  message_manager_->GetSensorData(&chassis_detail);
  // 21, 22, previously 1, 2
  if (driving_mode() == Chassis::EMERGENCY_MODE) {
    set_chassis_error_code(Chassis::NO_ERROR);
  }
  chassis_.set_driving_mode(driving_mode());
  chassis_.set_error_code(chassis_error_code());
  // 3
  chassis_.set_engine_started(true);
  // 5
  if (chassis_detail.has_vehicle_speed_rpt_6f() &&
      chassis_detail.vehicle_speed_rpt_6f().has_vehicle_speed()) {
    chassis_.set_speed_mps(static_cast<float>(
        chassis_detail.vehicle_speed_rpt_6f().vehicle_speed()));
  } else {
    chassis_.set_speed_mps(0);
  }
	return chassis_;
}

最后与canbus相关的是drivers内的can驱动，包括了can卡类型，发送的逻辑，可以忽略，后期也可更新上相关的流程。

奔跑的花短裤
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
百度Apollo学习：Canbus模块结构和源码.pdf
04-23
百度Apollo学习：Canbus模块结构和源码
百度Apollo学习：planning规划模块.pdf
04-23
百度Apollo学习：planning规划模块结构，数据，代码介绍
《从0开始搭建实现apollo9.0》系列四 CANBUS模块调用自己的车型
li1886477130的博客
03-02 473
参考案例如上图，其中ge3_controller为之前讲述的canbus/vehicle调用的实例车型的最终函数侧，protocol内为报文的接口函数侧。canbus相关的代码有三个文件夹，分别是canbus（主程序）、canbus_vehicle（车辆类型工厂）、drivers/canbus（硬件驱动）chassis函数为，解析底盘反馈报文，赋值至chassis节点，其中的赋值内容根据chassis的内容定义和报文内的定义进行匹配转换赋值，以上为canbus模块所修改的地方。
《从0开始搭建实现apollo9.0》系列二 从CAN协议到代码
li1886477130的博客
02-28 547
从CAN协议的解读 -> DBC制作 -> CanBus模块构建 -> Control模块构建 -> Planning模块构建 -> Prediction构建 ->Map构建 -> 感知构建。
Apollo环境搭建
攀登Fox的博客
07-22 428
目录一、安装JDK与MySQL二、资源准备2.1、安装包下载2.2、上传至Linux服务器三、configservice安装3.1、解压3.2、脚本初始化3.2.1、解压源码包3.2.2、复制configdb目录下的初始脚本3.2.3、执行脚本3.3、修改配置3.4、启动应用四、portal安装4.1、解压4.2、脚本初始化4.2.1、解压源码包4.2.2、复制configdb目录下的初始脚本4.2.3、执行脚本4.3、修改配置4.4、启动应用五、adminservice安装4.1、解压4.2、修改配置4.
canbus_canbus_apollo_
10-03
百度Apollo自动驾驶系统开源代码Canbus
【项目实战-配置中心】本地搭建阿波罗 Apollo
激流丶的博客
07-05 2998
【项目实战-配置中心】本地搭建阿波罗 Apollo
百度Apollo学习：Control控制模块.pdf
04-23
百度Apollo学习：Control控制模块
百度Apollo学习：Location定位模块.pdf
04-23
百度Apollo学习：Location定位模块
apollo 的planning 模块详解
12-14
planning base是 planning 模块的主要流程和⼊⼝ package ，包含 planning 模块的整体架构和流程。 planning 模块根据上游模块输⼊的感知周围环境信息，地图定位导 航信息，以及全局路径信息，为⾃动驾驶⻋辆规划出⼀条运动轨迹（包含坐标，速度，加速度， jerk 加加速度，时间等信息），然后将这些信息传递给控制模块。
搭建Apollo配置中心
12-14
下载apollo配置中心 https://github.com/nobodyiam/apollo-build-scripts 上传下载的apollo压缩包 到服务器上 apollo-build-scripts-master.zip 解压 unzip apollo-build-scripts-master.zip 安装jdk1.8+ 略 安装mysql数据库5.7+ 略 运行sql文件   apolloconfigdb.sql和apolloportaldb.sql 修改demo.sh     192.168.124.
自动驾驶光学校准反射板
JYGD686868的博客
04-22 479
景颐光电采用自主研发的技术工艺，反射率可从1-99%可选，可定制0.05m-3m或以上的漫反射板尺寸，均具有近完美的朗伯特性和稳定性，让激光雷达标定得到最优的测试效果。它的高反射率和精确的几何特性为光学系统的校准和光学元件的测试提供了可靠的依据。在未来，随着光学技术的不断进步，光学校准反射板的应用将会更加广泛和深入，为光学领域的发展注入新的活力。这使得光学校准反射板在光学领域的应用更加广泛和深入。是一种特殊的交通设施，它的主要作用是提高自动驾驶车辆在道路上的感知能力，增强自动驾驶系统的安全性和可靠性。
自动驾驶传感器篇： GNSS&IMU组合导航
weixin_43180456的博客
04-23 830
全球导航卫星系统（Global Navigation Satellite System, GNSS）是指一系列在地球轨道上运行的空间星座，它们通过向地球表面及近地空间区域发射无线电信号来提供定位、导航和授时服务。GNSS技术使得各类用户在全球范围内实现高精度的三维位置、速度和时间信息的获取，广泛应用于交通运输、测绘、农业、气象预报、科学研究、军事行动等多个领域。美国全球定位系统（Global Positioning System, GPS)
智能汽车：自动驾驶浅谈（入门）
pytorch内部机制解读
04-23 607
自动驾驶算法反应了工程师们根据人的思维模式，对自动驾驶所需处理过程的思考。通常包含感知、预测、规划模块，同时辅助一些地图、定位等模块，实现自动驾驶功能的落地。
【数值优化基础 （自动驾驶）】—— 知识点（方便回顾）
最新发布
BigDavid123的博客
04-26 521
数值优化知识点
机器人&自动驾驶时间同步进阶
weixin_68094467的博客
04-23 748
PTP同步模式采用主从式（master-slave architecture）架构，指每个PTP网域内只有一个主时钟（grandmaster clock），主时钟可直接收到卫星系统的时间，故其最为稳定、精准，在节点底下接收的则为从属时钟，换言之，主时钟与从属时钟同步时间后，后者会再将精确数据送到不同设备。这一块之前在之前的文章中就详细介绍了PPS，虽然PPS精度是要比PTP高的，但是实际上很多传感器是不支持PPS硬触发的，所以PTP和gPTP目前是车规的主流同步方式。，如果是通信设备可以看一下。
UniAD:以规划为导向的端到端自动驾驶
JJ-Li的博客
04-26 312
UniAD:以规划为导向的端到端自动驾驶，Planning-oriented Autonomous Driving
杭州电子科技大学数据结构(题目).pdf
04-26
杭州电子科技大学，期末考试资料，计算机专业期末考试试卷，试卷及答案，数据结构。
apollo9.0交叉编译
02-28
Apollo 9.0是一个自动驾驶开发平台，它提供了一套完整的软硬件解决方案，用于开发和部署自动驾驶系统。交叉编译是在一种平台上生成在另一种平台上运行的可执行文件的过程。在Apollo 9.0中，交叉编译通常用于将代码从开发主机编译为目标平台上的可执行文件。 要进行Apollo 9.0的交叉编译，您需要按照以下步骤进行操作： 1. 配置交叉编译环境：首先，您需要安装目标平台的交叉编译工具链。这些工具链包括交叉编译器、链接器和库文件。您可以从目标平台的官方网站或开发者社区获取这些工具链。 2. 设置环境变量：将交叉编译工具链的路径添加到系统的环境变量中，以便在编译过程中能够正确地找到这些工具。 3. 配置构建系统：Apollo 9.0使用Bazel作为构建系统。您需要根据目标平台的要求，配置Bazel的构建规则和选项。这包括指定目标平台的架构、操作系统和其他相关参数。 4. 编译代码：使用Bazel命令行工具执行编译命令，将代码编译为目标平台上的可执行文件。根据您的需求，您可以选择编译整个Apollo 9.0系统，或者只编译特定的模块或组件。 5. 部署和测试：将编译生成的可执行文件部署到目标平台上，并进行测试和验证。确保代码在目标平台上能够正常运行，并满足性能和功能要求。 请注意，具体的交叉编译步骤可能因为您使用的目标平台和开发环境而有所不同。建议您参考Apollo 9.0的官方文档和开发者社区，以获取更详细和准确的交叉编译指南。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值