AD框架相关：Apollo技术平台Cyber RT拓扑试验

已于 2022-06-06 22:51:26 修改
阅读量571 收藏
点赞数
分类专栏： 自动驾驶 Linux 文章标签： linux c++
于 2021-04-16 00:01:54 首次发布
本文为博主原创文章，未经博主允许禁止转载。
本文链接：https://blog.youkuaiyun.com/weixin_44808082/article/details/115695448
版权

文章目录

前言

      读书笔记，内容按照百度和北航出版的《自动驾驶平台基础》中的第五章练习，原书代码只给出关键部分，这里补全并提供结果展示。

1 功能介绍

      基于障碍物的距离（Distance）与车速（Speed）的两个部件（Component）作为输入，经过算法cal1和cal2两个部件作算法过程处理，使用Control部件输出到CAN总线（AEB精简版）。
在这里插入图片描述

      每个component连线相当于一个channel，CAN总线报文转换计算提供speed，Radar计算提供distance。speed和distance是基于时间触发的Timercomponent。二者提供cal1和cal2，cal1是当车速大于100时，通过/carstatus/speed2的channel向control发1（制动信号），cal2是当车速大于60且障碍物距离小于80，通过/carstatus/distance2的channel向control发1（否则输出0）。cal1/cal2/control是消息触发型的普通coponent。

2 代码

      使用Apollo 3.5平台（Ubuntu18.04），参考《自动驾驶汽车软件计算框架》第五章的方法，对5个conponent新建文件夹，每个文件夹都包含 .cc源文件/.h头文件/.dag摘要文件/.lanuch启动文件/Build关联文件。五个conponent文件放置在/apollo/cyber/examples/conponent文件夹下。

2.1 speed

      Build文件

load("//tools:cpplint.bzl", "cpplint")

package(default_visibility = ["//visibility:public"])

cc_binary(
    name = "speed.so",
    linkopts = ["-shared"],
    linkstatic = False,
    deps = [":speed_lib"],
)

cc_library(
    name = "speed_lib",
    srcs = [
        "speed.cc",
    ],
    hdrs = [
        "speed.h",
    ],
    deps = [
        "//cyber",
        "//cyber/examples/proto:examples_cc_proto",
    ],
)

cpplint()

      speed.cc文件

#include "cyber/examples/component/speed/speed.h"

#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/examples/proto/examples.pb.h"

bool speed::Init() {
  speed_writer_ = node_->CreateWriter<Chatter_Test>("/carstatus/speed1");
  return true;
}

bool speed::Proc() {
  static int i = 0;
  auto out_msg = std::make_shared<Chatter_Test>();
  out_msg->set_timestamp(i++);
  out_msg->set_content(70);
 //  msg->set_content(content + std::to_string(seq - 1));
  speed_writer_->Write(out_msg);
  AINFO << "speed: Write drivermsg->"
        << out_msg->content();
  return true;
}

      Speed.dag文件

module_config {
    module_library : "/apollo/bazel-bin/cyber/examples/component/speed/speed.so"
    timer_components {
        class_name : "speed"
        config {
            name : "speed"
            interval : 1000
        }
    }    
}

      speed.h文件


#include <memory>

#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/component/timer_component.h"
#include "cyber/examples/proto/examples.pb.h"

using apollo::cyber::examples::proto::Chatter_Test;
using apollo::cyber::Component;
using apollo::cyber::ComponentBase;
using apollo::cyber::TimerComponent;
using apollo::cyber::Writer;

class speed : public TimerComponent {
 public:
  bool Init() override;
  bool Proc() override;

 private:
  std::shared_ptr<Writer<Chatter_Test>> speed_writer_ = nullptr;
};
CYBER_REGISTER_COMPONENT(speed)

      speed.launch文件

<cyber>
    <module>
        <name>speed</name>
        <dag_conf>/apollo/cyber/examples/component/speed/speed.dag</dag_conf>
        <process_name>speed</process_name>
    </module>
</cyber>

2.2 distance

      build文件

load("//tools:cpplint.bzl", "cpplint")

package(default_visibility = ["//visibility:public"])

cc_binary(
    name = "distance.so",
    linkopts = ["-shared"],
    linkstatic = False,
    deps = [":distance_lib"],
)

cc_library(
    name = "distance_lib",
    srcs = [
        "distance.cc",
    ],
    hdrs = [
        "distance.h",
    ],
    deps = [
        "//cyber",
        "//cyber/examples/proto:examples_cc_proto",
    ],
)

cpplint()

      distance.cc文件

#include "cyber/examples/component/distance/distance.h"

#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/examples/proto/examples.pb.h"

bool distance::Init() {
  distance_writer_ = node_->CreateWriter<Chatter_Test>("/carstatus/distance1");
  return true;
}

bool distance::Proc() {
  static int i = 0;
  auto out_msg = std::make_shared<Chatter_Test>();
  out_msg->set_timestamp(i++);
  out_msg->set_content(70);
 //  msg->set_content(content + std::to_string(seq - 1));
 distance_writer_->Write(out_msg);
  AINFO << "distance: Write drivermsg->"
        << out_msg->content();
  return true;
}

      distance.dag文件

module_config {
    module_library : "/apollo/bazel-bin/cyber/examples/component/distance/distance.so"
    timer_components {
        class_name : "distance"
        config {
            name : "distance"
            interval : 1000
        }
    }    
}

      distance.h文件

#include <memory>

#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/component/timer_component.h"
#include "cyber/examples/proto/examples.pb.h"

using apollo::cyber::examples::proto::Chatter_Test;
using apollo::cyber::Component;
using apollo::cyber::ComponentBase;
using apollo::cyber::TimerComponent;
using apollo::cyber::Writer;

class distance : public TimerComponent {
 public:
  bool Init() override;
  bool Proc() override;

 private:
  std::shared_ptr<Writer<Chatter_Test>>distance_writer_ = nullptr;
};
CYBER_REGISTER_COMPONENT(distance)

      launch文件

<cyber>
    <module>
        <name>distance</name>
        <dag_conf>/apollo/cyber/examples/component/distance/distance.dag</dag_conf>
        <process_name>distance</process_name>
    </module>
</cyber>

2.3 cal

      build文件

load("//tools:cpplint.bzl", "cpplint")

package(default_visibility = ["//visibility:public"])

cc_binary(
    name = "cal1.so",
    linkopts = ["-shared"],
    linkstatic = False,
    deps = [":cal1_lib"],
)

cc_library(
    name = "cal1_lib",
    srcs = [
        "cal1.cc",
    ],
    hdrs = [
        "cal1.h",
    ],
    deps = [
        "//cyber",
        "//cyber/examples/proto:examples_cc_proto",
    ],
)

cpplint()

      cal1.cc文件

#include "cyber/examples/component/cal1/cal1.h"
#include "cyber/time/rate.h"
#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/time/time.h"
#include "cyber/cyber.h"
#include "cyber/examples/proto/examples.pb.h"

using apollo::cyber::Rate;
using apollo::cyber::Time;
using apollo::cyber::examples::proto::Chatter_Test;

bool cal1::Init() {
  AINFO << "cal1 component init";
  cal1_writer_ = node_->CreateWriter<Chatter_Test>("/carstatus/speed2");
  return true;
}

bool cal1::Proc(const std::shared_ptr<Chatter_Test>& msg0) {
  AINFO << "Start cal1 component Proc [" << msg0->content() << "]";
  static int i=0;
  auto out_msg = std::make_shared<Chatter_Test>();

  if(msg0->content()>100){
     out_msg->set_content(1);
      }
     else{
     out_msg->set_content(0);
     }


  out_msg->set_timestamp(i++);
  cal1_writer_->Write(out_msg);
  AINFO << "cal1: Write drivermsg->"
        << out_msg->content();
  return true;
}

      cal1.dag文件

# Define all coms in DAG streaming.
    module_config {
    module_library : "/apollo/bazel-bin/cyber/examples/component/cal1/cal1.so"
    components {
        class_name : "cal1"
        config {
            name : "common"
            readers {
                channel: "/carstatus/speed1"
            }
        }
        }
      }

cal1.h

#include <memory>

#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/examples/proto/examples.pb.h"
#include "cyber/component/timer_component.h"

using apollo::cyber::examples::proto::Chatter_Test;
using apollo::cyber::Component;
using apollo::cyber::TimerComponent;
using apollo::cyber::Writer;

class cal1:public Component<Chatter_Test> {
 public:
  bool Init() override;
  bool Proc(const std::shared_ptr<Chatter_Test>& msg0  ) override;
  private:
   std::shared_ptr<Writer<Chatter_Test>>cal1_writer_= nullptr;
};
CYBER_REGISTER_COMPONENT(cal1)

cal1.launch

<cyber>
    <module>
        <name>cal1</name>
        <dag_conf>/apollo/cyber/examples/component/cal1/cal1.dag</dag_conf>
        <process_name>cal1</process_name>
    </module>
</cyber>

2.4 cal2

      build文件

load("//tools:cpplint.bzl", "cpplint")

package(default_visibility = ["//visibility:public"])

cc_binary(
    name = "cal2.so",
    linkopts = ["-shared"],
    linkstatic = False,
    deps = [":cal2_lib"],
)

cc_library(
    name = "cal2_lib",
    srcs = [
        "cal2.cc",
    ],
    hdrs = [
        "cal2.h",
    ],
    deps = [
        "//cyber",
        "//cyber/examples/proto:examples_cc_proto",
    ],
)

cpplint()

      cal2.cc文件

#include "cyber/examples/component/cal2/cal2.h"
#include "cyber/time/rate.h"
#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/time/time.h"
#include "cyber/cyber.h"
#include "cyber/examples/proto/examples.pb.h"

using apollo::cyber::Rate;
using apollo::cyber::Time;
using apollo::cyber::examples::proto::Chatter_Test;

bool cal2::Init() {
  AINFO << "cal2 component init";
  cal2_writer_=node_->CreateWriter<Chatter_Test>("/carstatus/distance2");
  return true;
}

bool cal2::Proc(const std::shared_ptr<Chatter_Test>& msg0 ,
                               const std::shared_ptr<Chatter_Test>& msg1 ) {
  AINFO << "Start cal2 component Proc [" << msg0->content() << "] ["
        << msg1->content() << "]";
 static int i=0;
 auto out_msg = std::make_shared<Chatter_Test>();

 if(msg0->content()>60&&msg1->content()<80){
     out_msg->set_content(1);
     }
     else{
     out_msg->set_content(0);
     }

 out_msg->set_timestamp(i++);
 cal2_writer_->Write(out_msg);
 AINFO<<"cal2:Write drivermsg->"
    <<out_msg->content();

  return true;
}

      cal2.dag文件

# Define all coms in DAG streaming.
    module_config {
    module_library : "/apollo/bazel-bin/cyber/examples/component/cal2/cal2.so"
    components {
        class_name : "cal2"
        config {
            name : "common"
            readers {
                channel: "/carstatus/speed1"
            }
            readers {
                channel: "/carstatus/distance1"
            }
        }
      }
    }

      cal2.h文件

#include <memory>

#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/examples/proto/examples.pb.h"
#include "cyber/component/timer_component.h"

using apollo::cyber::examples::proto::Chatter_Test;
using apollo::cyber::Component;
using apollo::cyber::TimerComponent;
using apollo::cyber::Writer;

class cal2:public Component<Chatter_Test, Chatter_Test> {
 public:
  bool Init() override;
  bool Proc(const std::shared_ptr<Chatter_Test>& msg0,
            const std::shared_ptr<Chatter_Test>& msg1 ) override;
  private:
   std::shared_ptr<Writer<Chatter_Test>>cal2_writer_= nullptr;
};
CYBER_REGISTER_COMPONENT(cal2)

      cal2.launch文件

<cyber>
    <module>
        <name>cal2</name>
        <dag_conf>/apollo/cyber/examples/component/cal2/cal2.dag</dag_conf>
        <process_name>cal2</process_name>
    </module>
</cyber>

2.5 control

      bulid文件

load("//tools:cpplint.bzl", "cpplint")

package(default_visibility = ["//visibility:public"])

cc_binary(
    name = "control.so",
    linkopts = ["-shared"],
    linkstatic = False,
    deps = [":control_lib"],
)

cc_library(
    name = "control_lib",
    srcs = [
        "control.cc",
    ],
    hdrs = [
        "control.h",
    ],
    deps = [
        "//cyber",
        "//cyber/examples/proto:examples_cc_proto",
    ],
)

cpplint()

      control.cc文件

#include "cyber/examples/component/control/control.h"
#include "cyber/time/rate.h"
#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/time/time.h"
#include "cyber/cyber.h"
#include "cyber/examples/proto/examples.pb.h"

using apollo::cyber::Rate;
using apollo::cyber::Time;
using apollo::cyber::examples::proto::Chatter_Test;

bool control::Init() {
  AINFO << "control component init";
  control_writer_ = node_->CreateWriter<Chatter_Test>("/carstatus/control1");
  return true;
}

bool control::Proc(const std::shared_ptr<Chatter_Test>& msg0,
                               const std::shared_ptr<Chatter_Test>& msg1 ) {
  AINFO << "Start control component Proc [" << msg0->content() << "] ["
        << msg1->content() << "]";
 static int i=0;
 auto out_msg = std::make_shared<Chatter_Test>();

 if(msg0->content()>0||msg1->content()>0){
     out_msg->set_content(1);
     }
     else{
     out_msg->set_content(0);
     }

 out_msg->set_timestamp(i++);
 control_writer_->Write(out_msg);
 AINFO<<"control:Write drivermsg->"
    <<out_msg->content();

  return true;
}

control.dag

# Define all coms in DAG streaming.
    module_config {
    module_library : "/apollo/bazel-bin/cyber/examples/component/control/control.so"
    components {
        class_name : "control"
        config {
            name : "common"
            readers {
                channel: "/carstatus/speed2"
            }
            readers {
                channel: "/carstatus/distance2"
            }
        }
      }
    }

      control.h文件

#include <memory>
#include "cyber/class_loader/class_loader.h"
#include "cyber/component/component.h"
#include "cyber/examples/proto/examples.pb.h"
#include "cyber/component/timer_component.h"

using apollo::cyber::examples::proto::Chatter_Test;
using apollo::cyber::Component;
using apollo::cyber::TimerComponent;
using apollo::cyber::Writer;

class control:public Component<Chatter_Test, Chatter_Test> {
 public:
  bool Init() override;
  bool Proc(const std::shared_ptr<Chatter_Test>& msg0,
            const std::shared_ptr<Chatter_Test>& msg1 ) override;
  private:
   std::shared_ptr<Writer<Chatter_Test>>control_writer_ = nullptr;
};
CYBER_REGISTER_COMPONENT(control)

      control.launch文件

<cyber>

    <module>
        <name>speed</name>
        <dag_conf>/apollo/cyber/examples/component/speed/speed.dag</dag_conf>
        <process_name>speed</process_name>
    </module>

      <module>
        <name>distance</name>
        <dag_conf>/apollo/cyber/examples/component/distance/distance.dag</dag_conf>
        <process_name>distance</process_name>
    </module>

    <module>
        <name>cal1</name>
        <dag_conf>/apollo/cyber/examples/component/cal1/cal1.dag</dag_conf>
        <process_name>cal1</process_name>
    </module>

    <module>
        <name>cal2</name>
        <dag_conf>/apollo/cyber/examples/component/cal2/cal2.dag</dag_conf>
        <process_name>cal2</process_name>
    </module>

        <module>
        <name>control</name>
        <dag_conf>/apollo/cyber/examples/component/control/control.dag</dag_conf>
        <process_name>control</process_name>
    </module>

</cyber>

2.6 proto

      更新/apollo/cyber/examples/proto/examples.proto文件，增加message Chatter_Test （解决int和String转换问题）。

syntax = "proto2";

package apollo.cyber.examples.proto;

message SamplesTest1 {
    optional string class_name = 1;
    optional string case_name = 2;
};

message Chatter {
    optional uint64 timestamp = 1;
    optional uint64 lidar_timestamp = 2;
    optional uint64 seq = 3;
    optional bytes content = 4;
};

message Driver {
    optional string content = 1;
    optional uint64 msg_id = 2;
    optional uint64 timestamp = 3;
};

message Chatter_Test {
    optional uint64 timestamp = 1;
    optional uint64 lidar_timestamp = 2;
    optional uint64 seq = 3;
    optional uint64 content = 4;
};

在这里插入图片描述

3 Apollo 运行

      使用VS code 运行Docker，可参考优快云_知行合一2018
:使用Visual Studio Code编译、调试Apollo项目介绍的方法，只用到终端-运行生成任务这一步。

在这里插入图片描述
      Apollo 运行相关步骤如下（在此之前已经使用Ubuntu终端正常运行Apollo）：

// VS code 使用Docker运行Apollo(含root)
$ bash docker/scripts/dev_start.sh
$ bash docker/scripts/dev_into.sh
$ bash apollo.sh clean
$ cd ..
$ sudo passwd
$ su root
$ cd apollo
$  ./apollo.sh build cyber

//bash: cyber_launch: command not found, so I added “ source cyber/setup.bash”
$ source cyber/setup.bash
$ cyber_launch start cyber/examples/component/control/control.launch

4 结果展示

      在VS code中新建终端，使用Cyber_monitor查看channel

$ cd ..
$ sudo passwd
$ su root
$ cd apollo
$ bash docker/scripts/dev_start.sh
$ bash docker/scripts/dev_into.sh
//$ source cyber/setup.bash
$ cyber_monitor -h
$ cyber_monitor

在这里插入图片描述
      运行结果（提示通道命名重复，待优化）：
在这里插入图片描述

5 Apollo 6.0平台代码更新方法

      1)增加proto_test文件夹，更改examples.proto内容。在这里插入图片描述

      2）更改5个component涉及proto文件夹位置，例如BUILD。

load("//tools:cpplint.bzl", "cpplint")

package(default_visibility = ["//visibility:public"])

cc_binary(
    name = "cal1.so",
    linkopts = ["-shared"],
    linkstatic = False,
    deps = [":cal1_lib"],
)

cc_library(
    name = "cal1_lib",
    srcs = [
        "cal1.cc",
    ],
    hdrs = [
        "cal1.h",
    ],
    deps = [
        "//cyber",
        "//cyber/examples/proto_test:examples_cc_proto",
    ],
)

cpplint()

      按照3.5的步骤运行即可。

>> 更多相关内容，点击Morven_Xie博客概览

Ubuntu 18.04安装Apollo 6.0：从零开始到启动Demo（超多细节）
shao918516的博客
08-28 1万+
最近在以Apollo平台为模板学习无人驾驶系统，在安装Apollo时遇到一些小问题，故写一篇文章作总结，初步介绍Apollo平台，并详解安装过程。
自动驾驶Apollo源码分析系统,CyberRT篇(一):简述CyberRT框架基础概念
frank 的专栏
03-11 1万+
1. CyberRT 是什么？ Apollo Cyber RT 是专为自动驾驶场景设计的开源、高性能运行时框架。 基于中心化计算模型，主要价值是提升自动驾驶系统的高并发、低延迟、高吞吐。 Apollo 并不是一开始就使用 CyberRT，在 v3.0 之前用的都是基于 ROS 框架进行开发。但在之前的版本中发现了很多问题，随着 Apollo 的发展，对最高水平的稳健性和性能的需求， Apollo Cyber RT 应运而生，它满足了一个面向商业化的自动驾驶解决方案的基础需求。 CyberRT 最明显的 3
Apollo：Cyber RT拓扑发现概述
OceanStar的博客
03-09 810
是网络中各个站点相互连接的形式，在中明确一点讲就是文件服务器、工作站等的连接方式。反映出网络中各实体的结构关系，是建设计算机网络的第一步，是实现各种网络协议的基础，它对网络的性能，系统的可靠性与通信费用都有很大的营销。在P2P网络通信中，我们需要解决的两个首要问题就是——和谁进行通信以及如何进行通信。不管通信方式是选择TCP还是UDP，我们都需要获取对端的一些标识，如IP和端口号等，从而建立连接。本文我们主要研究第一个问：参与者的标志以及参与者的相互发现。
自动驾驶单节点通信中间件探索
qq_25762163的博客
03-11 2798
该工作《Oops! It's Too Late. Your Autonomous Driving System Needs a Faster Middleware》于2021年7月已经被IEEE Robotics and Automation Letters (RA-L)接收。 文章主要讨论了当前自动驾驶领域流行的通信中间件是否能够满足自动驾驶场景的通信需求，并且开源了一个自动驾驶端到端测试工具：ComP。
百度Apollo系统学习-Cyber RT 注册启动模块
qq_25762163的博客
12-27 5895
精读Cyber RT源码，理解CyberRT模块管理架构与注册启动流程
【Apollo自动驾驶-从理论到代码】cyber/component模块
RomeoLikeJuliet的博客
01-29 1840
/* 作者水平有限，欢迎批评指正，内容持续完善中！！*/ Apollo Cyber Component主要文件处理流程代码详解 主要文件 文件名 描述 作用 component_base.h 组件代码基类 component.h 常规组件基类 timer_component.h 定时器组件基类 timer_component.cc 处理流程 代码详解 ...
Apollo星火计划学习笔记——第三讲Apollo Cyber RT模块详解与实践
m0_51902001的博客
10-03 1568
学习Apollo中Cyber RT的诞生背景以及在Apollo及自动驾驶中的作用，最后通过实验操作来进行实践学习。
自动驾驶平台Apollo 5.5阅读手记：Cyber RT中的通信传输
世事难料，保持低调
09-12 1万+
前言 计算框架是自动驾驶系统中的重中之重，也是整个系统得以高效稳定运行的基础。为了实时地完成感知、决策和执行，系统需要一系列的模块相互紧密配合，高效地执行任务流。由于各种原因，这些模块可能位于不同进程，也可能位于不同机器。这就要求计算框架中具有灵活的、高性能的通信机制。我们知道，Apollo在3.5版本中推出了Cyber RT替代了原先的ROS。之前写过两篇相关的文章介绍了其中的调度部分：自动驾驶平台Apollo 3.5阅读手记：Cyber RT中的协程（Coroutine）和自动驾驶平台Apollo 5.
[Apollo Cyber RT] Timer实现
11-20 1393
Apollo Cyber Timer的实现详解
Apollo：源码分析之cyber/component组件
OceanStar的博客
03-07 830
Component的基类是ComponentBase（位于cyber/component/component_base.h），它有两个子类Component和TimerComponent，用户定义的组件都是继承这两个子类，然后需要实现其中的Init() & Proc()函数。
Apollo 应用与源码分析：CyberRT-组件（component）
阿呆的隐秘角落
11-23 1332
Apollo 应用与源码分析：CyberRT-组件（component）
Cpplint源码
12-14
这是Google C++代码静态检测工具Cpplint源码，亲测可用。
学习Apollo cyberRT时遇到的一些报错及解决方法
Chloe0333的博客
01-20 2061
学习ApollocyberRT时遇到的一些报错及解决方法
Apollo Cyber_launch启动提示“未找到命令”
qq_42119367的博客
05-20 2102
cyber_launch start capture.launch 找不到命令时执行下面语句 cd 项目/release/cyber/ source setup.bash 再次执行cyber_launch
apollo中两种writer的代码分析
tony9006的博客
05-14 1184
# 两种writer的代码分析 分析module/perception里面的segmentation和fusion组件都发出了消息，都调用了writer->Write()，但是前者的消息并没有发出来，后者的消息可以在Cyber_monitor中收到。不仅这两个，apollo中凡是channel name带了inner的都属于前者。 两者的writer定义分别如下： > segmentation: ``` c++ writer_ = node_->CreateWriter<L
CyberRT源码剖析
最新发布
保持学习
06-11 1015
Cyber应用程序由mainboard作为入口进行启动，启动时需要通过ClassLoaderManager，通过反射机制，按照类名，加载各个动态库至内存中的类，并初始化各个component。初始化component会定义和msg相关联的回调函数func，func会在收到msg的时候执行。创建消息缓冲区，即Datavisitor。创建协程，该协程主要用于对消息的处理以及func的调度。具体调度逻辑将由调度器Scheduler实现。
百度 Apollo Cyber RT简介、基本概念以及与 ROS 对照
热门推荐
罗朝辉（飘飘白云）
03-30 3万+
一，背景 ROS 应用于自动驾驶领域的不足： 调度的不确定性：各节点以独立进程运行，节点运行顺序无法确定，因而业务逻辑的调度顺序无法保证； 运行效率：ROS 为分布式系统，存在通信开销 二，Cyber RT 框架 从下到上依次为： 基础库：高性能，无锁队列； 通信层：Publish/Subscribe机制，Service/Client机制，服务自发现，自适应的通信机制（共享内存、Socke...
Apollo Cyber RT学习日记 (二)
Charles的博客
02-20 2300
ROS学习日记 （二）3.Cyber RT API for Developers3.1 Talker-Listener（Like Chatter/Topic in ROS）3.1.1 Create a node3.1.2 Create a writer3.1.3 Create a reader3.2 Code Example3.2.1 Talker (cyber/examples/talker.c...
Apollo Cyber RT学习日记 (一)
Charles的博客
02-17 4966
Apollo Cyber RT学习 在前文Apollo学习笔记中提到，此篇为专门介绍百度Apollo Cyber RT的Blog。
apollo::cyber 通信 如果消息不为空，则按照一定的频率发消息
05-12
在apollo::cyber通信中，可以使用定时器Timer和回调函数来实现按照一定频率发送消息的功能。 首先，需要在节点的初始化函数中创建一个定时器Timer，设置定时器的时间间隔和回调函数。回调函数中可以编写发送消息的代码。 示例代码如下： ``` #include "cyber/cyber.h" using apollo::cyber::Node; using apollo::cyber::Timer; using apollo::cyber::Time; void sendMessage(const std::shared_ptr<Node>& node) { // 编写发送消息的代码 } int main(int argc, char** argv) { apollo::cyber::Init(argv[0]); // 创建节点 auto node = std::make_shared<Node>("node_name"); // 创建定时器 auto timer = node->CreateTimer( Time(1.0 / 10), // 时间间隔，这里是10Hz std::bind(&sendMessage, node)); // 回调函数 apollo::cyber::WaitForShutdown(); return 0; } ``` 在上述代码中，定时器的时间间隔设置为1秒钟除以10，即10Hz。回调函数为sendMessage函数，当定时器时间到达时，会自动调用sendMessage函数，发送消息。 需要注意的是，sendMessage函数中应该先判断消息是否为空，以免发送空消息。同时，发送消息的频率应该考虑到系统的实际处理能力和带宽限制，不建议设置太快的频率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值