cyber_back

这篇具有很好参考价值的文章主要介绍了cyber_back。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1.1 话题通信

模式:
以发布订阅的方式实现不同节点之间数据交互的通信模式。
如图1-1所示,Listener-Talker通信首先创建了两个Node,分别是Talker Node和 Listener Node。
每个Node实例化Writer类和Reader类对Channel进行消息的读写。
Writer和Reader通过Topic连接,对同一块共享内存(Channel)进行读写处理。
Talker Node 为了实现其“诉说”的功能,实例化Writer,通过Writer来对Channel进行消息写操作。
Listener Node为了实现其“聆听”功能,实例化reader类,通过Reader来对channel进行读操作。
场景:
话题通信方式适合于持续性通信的应用场景,比如雷达信号,摄像头图像信息这类数据的传输。
使用:
Listener-Talker通信一方主动送消息,一方被动接收。
我们想要一直获取车的速度,该需求不需要向发送方返回什么消息,也不需要发送方对消息进行进一步处理。所以我们选择了Listener-Talker通信方式实现该功能。
数据定义:
话题通信中用的的数据格式的定义car message 定义在car.proto中。
1.2 服务通信

模式:
以请求响应的方式实现不同节点之间数据交互的通信模式。
如图1-2所示,Server-Client通信可以在客户端发出消息请求时,服务端才进⾏请求回应,并将客户端所需的数据返回给客户端。
场景:
我们想要获得⼩⻋的详细信息,⽐如⻋牌这些,但是⼜不需要⼀直获得该信息,想要在需要知道这些信息的时候请求⼀下就好,于是考虑⽤Server- Client通信实现该功能。

使用:
该通信模式适合临时的消息传输,适⽤于不需要持续性发送数据的场景。
数据定义:
其传输的数据定义依然在对应的proto⽂件中。
1.3 参数通信

模式:
以共享的方式实现不同节点之间数据交互的通信模式。
参数服务器是基于服务实现的,包含客户端和服务器端,服务端节点可以存储数据,客户端节点可以访问服务端节点操作数据,这个过程虽然基于请求响应的,但是无需自己实现请求与响应,此过程已经被封装,调用者只需要通过比较简单友好的API就可以实现参数操作。
场景:
自动驾驶场景中有一些参数比如该车的最高限速、最多乘客以及是否自动驾驶等需要被各个模块使用数据,比如是否自动驾驶这个参数可能同时影响这很多模块,也可能被很多模块运行时所更改。
这些数据如何实现在不同模块之间的共享呢?
使用:
类似于“全局变量”的方式来存储这些参数,并定义一些自定义参数来进行使用。
数据定义:
Cyber中设计了全局参数服务器来实现这个功能,其通信基于RTPS协议。该通信方式服务端和客户端都可以设置参数和更改参数。

第二节:数据通信基础Protobuf
1.3 Protobuf简介
2.1 Protobuf简介
Protobuf 是 Google 公司开发的一种跨语言和平台的序列化数据结构的方式,是一个灵活的、高效的用于序列化数据的协议,与 XML 和 JSON 格式相比,Protobuf 更小、更快、更便捷。
Protobuf 是跨语言的,并且自带一个编译器( protoc ),只需要用protoc进行编译,就可以编译成 Java、Python、C++、C#、Go 等多种语言代码,然后可以直接使用,不需要再写其它代码,自带有解析的代码。只需要将要被序列化的结构化数据定义一次(在 .proto 文件定义),便可以使用特别生成的源代码(使用protobuf提供的生成工具)轻松的使用不同的数据流完成对结构数据的读写操作。甚至可以更新 .proto 文件中对数据结构的定义而不会破坏依赖旧格式编译出来的程序。其优点如下:

  • 性能效率高:序列化后字节占用空间比 XML 少3-10倍,序列化的时间效率比 XML 快20-100倍。
  • 使用便捷便捷:将对结构化数据的操作封装成一个类,便于使用。
  • 兼容性高:通信两方使用同一数据协议,当有一方修改了数据结构,不会影响另一方的使用。
  • 跨语言:支持 Java,C++,Python、Go、Ruby 等多种语言。
    2.2 Protobuf 文件编写
    为了方便讲解,使用cyber/examples/proto/examples.proto文件来讲解Protobuf的结构:
    Protobuf有几个部分构成:
  • syntax :表示使用Protobuf的版本,目前Protobuf支持proto3,但在Apollo中使用的是proto2;
  • package: 表示该文件的路径;
  • message:表示一种数据结构,message后面跟的是数据结构名字,括号里的字段定义格式为:字段规则 数据类型 字段名称 字段编号。
    字段规则主要有三种
  • required:调用时必须提供该字段的值,否则该消息被视为“未初始化”,官方不建议使用,当把字段规则改为其他规则会存在兼容性问题。
  • optional:该字段的值可以设置也可以不设置,会根据数据类型生成一个默认的值。
  • repeated:类似于动态数组,可以存储多个同类型的数据。

examples.proto

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;
};
2.3 Protobuf编译
Protobuf的编译要分为两个步骤:

  • 首先要根据.proto文件生成proto库;
  • 然后再根据生产的proto库生成C++相关的源文件。
    这个源文件是C++语言自动编写的,可以被C++程序自动识别。每一个message会被解析生一个类,里面的字段就相当于这个类的属性。在源文件中也会根据属性生成额外的成员,如获取和设置属性的函数。
    package(default_visibility = [“//visibility:public”])
    #1、生成proto库
    proto_library(
    name = “examples_proto”,
    srcs = [“examples.proto”],
    )
    #2、生成源文件
    cc_proto_library(
    name = “examples_cc_proto”,
    deps = [
    “:examples_proto”,
    ],
    )
    代码解析:
  • 我们使用Bazel构建系统的BUILD文件,用于生成proto库和相关的源文件。
  • 首先,通过proto_library规则定义了一个名为"examples_proto"的proto库,它使用"examples.proto"作为源文件。
  • 然后,通过cc_proto_library规则定义了一个名为"examples_cc_proto"的源文件生成规则。它依赖于"examples_proto"库,并使用该库生成相关的C++源文件。
  • 这些规则中的名称是任意定义的,您可以根据需要进行更改。
    2.4 小案例
    目的:使用Protobuf来定义数据格式,在main程序中设置数据值并输出。
    流程:
    <1> 创建本节实验工程目录
    <2> 编写Apollo包管理相关的BUILD和cyberfile.xml文件文件
    <3> 编写proto文件及BUILD文件;
    <4> 编写主代码及BUILD文件:
    <5> 编译代码目录
    <6> 运行可执行文件
    <1> 创建本节实验工程目录:
    cyber_demo
    |-- cyber_03
    |-- proto
    |-- BUILD
    |-- car_msg.proto
    |-- test_proto
    |-- BUILD
    |-- car.cc
    |–BUILD
    |–cyberfile.xml
    |–cyber_demo.BUILD
    <2> 编写Apollo包管理相关的BUILD和cyberfile.xml文件
  • BUILD文件内容:

load(“//tools/install:install.bzl”, “install”, “install_src_files”)

install(
name = “install”,
data = [
“cyber_demo.BUILD”,
“cyberfile.xml”,
],
deps = [
“//cyber_demo/cyber_03/test_proto:install”,
],
)

install_src_files(
name = “install_src”,
src_dir = [“.”],
dest = “cyber_demo/src”,
filter = “*”,
deps = [
“//cyber_demo/cyber_03/test_proto:install_src”,
]
)
编写cyberfile文件:

cyber_demo
1.0.0

cyber_demo

AD-platform@baidu.com
module
<src_path>//cyber_demo</src_path>
BSD
Apollo
cyber-dev
3rd-protobuf-dev
bazel

<3> 编写proto源文件及BUILD文件;
编写proto文件,文件中定义了车辆的信息:
syntax = “proto2”;

package apollo.cyber.test.proto;
message CarMsg {
required string owner = 1;
optional string license_plate = 2;
optional uint64 max_passenger = 3;
repeated string car_info = 4;
}
编写proto的BUILD文件:
load(“@rules_proto//proto:defs.bzl”, “proto_library”)
load(“@rules_cc//cc:defs.bzl”, “cc_proto_library”)
load(“//tools:python_rules.bzl”, “py_proto_library”)

package(default_visibility = [“//visibility:public”])

proto_library(
name = “car_msg_proto”,
srcs = [“car_msg.proto”],
)

cc_proto_library(
name = “car_msg_cc_proto”,
deps = [“:car_msg_proto”],
)
<4> 编写主代码及BUILD文件
通过car.cc输出车辆基本信息:
#include “test/proto/car_msg.pb.h”
using namespace std;

int main()
{
apollo::cyber::test::proto::CarMsg car;

car.set_owner("apollo");
car.set_license_plate("京A88888");
car.set_max_passenger(6);
car.add_car_info("SUV"); //车型
car.add_car_info("Red"); //车身颜色
car.add_car_info("electric"); //电动

string owner = car.owner();
string license_plate = car.license_plate();
uint64_t max_passenger = car.max_passenger();

cout << "owner:" << owner << endl;
cout << "license_plate:" << license_plate << endl;
cout << "max_passenger:" << max_passenger << endl;

for (int i = 0; i < car.car_info_size(); ++i){
    string info = car.car_info(i);
    cout << info << " ";
}
cout << endl;
return 0;

}
注意
本段代码中内容需要进行
#include “test/proto/car_msg.pb.h”

--------------------需要替换为---------------------------

#include “cyber_demo/cyber_03/proto/car_msg.pb.h”

编辑car.cc的BUILD文件:
load(“@rules_cc//cc:defs.bzl”, “cc_binary”, “cc_library”)
load(“//tools/install:install.bzl”, “install”, “install_src_files”)
load(“//tools:cpplint.bzl”, “cpplint”)

package(default_visibility = [“//visibility:public”])

cc_binary(
name = “car”,
srcs = [“car.cc”],
deps = [“//test/proto:car_msg_cc_proto”],
)

install(
name = “install”,
runtime_dest = “test/bin”,
targets = [
“:car”
],
)

install_src_files(
name = “install_src”,
src_dir = [“.”],
dest = “test/src/cyberatest”,
filter = “*”,
)

注意
本段BUILD代码中内容需要进行修改
cc_binary(
name = “car”,
srcs = [“car.cc”],
deps = [“//test/proto:car_msg_cc_proto”],
)

--------------------需要替换为---------------------------

cc_binary(
name = “car”,
srcs = [“car.cc”],
deps = [“//cyber_demo/cyber_03/proto:car_msg_cc_proto”],
)

<5> 编译代码
cd /apollo_workspace
buildtool build -p cyber_demo/
编译结果如图所示:

编译完成后会在 /opt/apollo/neo/bin/的目录下生成可执行文件car,如下图所示:

<6> 运行可执行文件
cd /opt/apollo/neo/bin/
./car
运行结果如下图:

所有者:apollo
车牌号:京A88888
最大乘客人数:6
SUV 红色 电动
内容导入:
第三节:Cyber RT通信机制解析与实践

  1. 实践简介
    在第一章中,鹏飞老师已经说明了Node、Channel等Cyber的基础概念,本节我们基于这些基础概念,重点介绍 cyber 中的三种通信方式之一 - Listener 和 Talker通讯原理。为了更好的说明 Listener 和 Talker通信机制的用法,本节我们通过实现一个案例来说明该部分内容。
    案例如下,假设我们拥有了一辆自己的“无人车“,apollo号,现在我们想通过通信,获得该车辆的“实时”速度、车的详细信息以及车的通用参数。那么现在会有几个问题:
  • 车本身有的变量有哪些,应该在哪里定义?
  • 实现“实时”车速的获取和实现车的详细信息等应该用什么通信方式?在哪里实现?
  • 实现的代码应该如何运行起来?
    不要着急,接来下我们就开始用Cyber实现这个小demo,并一一解答以上疑问。该案例我们创建在/apollo/workspace/test文件下,命名为communication整体目录结构如下:
    /apollo_workspace/
    |–test
    | |–communication
    | | |–BUILD //cyber_test编译文件
    | |–talker.cc //talker-listener通信实现
    | |–listener.cc
    | |–server.cc //server-client通信实现
    | |–client.cc
    | |–param_server.cc //parameter server-client通信实现
    | |–param_client.cc
    |–proto
    |–BUILD //car.proto 编译文件
    |–car.proto //小车数据定义的文件ß
  1. 编写C++话题通信实践案例
  2. proto文件编写
    通过第一节内容,我们知道了proto文件的使用方法,那么这一章,我们来自己编写一个proto文件,来实现我们“车”的变量定义,在后续的三种通信方式的案例中都是用这一数据定义。
    对car.proto文件进行编写,其内容如下:
    // 定义proto使用的版本
    syntax = “proto2”;

//定义包名,在cc文件中调用
package apollo.cyber.test.proto;

//定义一个车的消息,车的型号,车主,车的车牌号,已跑公里数,车速
message Car{
optional string plate = 1;
optional string type = 2;
optional string owner = 3;
optional uint64 kilometers = 4;
optional uint64 speed = 5;
};
2.1 实现小车的实时速度获取——Listener-Talker通信

  1. talker.cc 文件编写
  • 我们来编写一个talker.cc来实现主动对话。
    //头文件引用
    #include “test/proto/car.pb.h”
    #include “cyber/cyber.h”
    #include “cyber/time/rate.h”

//car数据定义的引用,可以看出其定义来源于一个proto
using apollo::cyber::examples::cyber_test_proto::Car;

int main(int argc, char *argv[]) {
// 初始化一个cyber框架
apollo::cyber::Init(argv[0]);

// 创建talker节点
auto talker_node = apollo::cyber::CreateNode(“talker”);

// 从节点创建一个Topic,来实现对车速的查看
auto talker = talker_node->CreateWriter<Car>("car_speed");
AINFO << "I'll start telling you the current speed of the car.";

//设置初始速度为0,然后速度每秒增加5km/h
uint64_t speed = 0;
while (apollo::cyber::OK()) {
    auto msg = std::make_shared<Car>();
    msg->set_speed(speed);
    //假设车速持续增加
    speed += 5;
    talker->Write(msg);
    sleep(1);
}
return 0;

}

  1. listener.cc 文件编写
  • 编写一个listener来实现对talker发送过来的内容进行接收。
    #include “test/proto/car.pb.h”
    #include “cyber/cyber.h”

using apollo::cyber::examples::cyber_test_proto::Car;

//接收到消息后的响应函数
void message_callback(
const std::shared_ptr& msg) {
AINFO << "now speed is: " << msg->speed();
}

int main(int argc, char* argv[]) {
//初始化cyber框架
apollo::cyber::Init(argv[0]);

//创建监听节点
auto listener_node = apollo::cyber::CreateNode("listener");

//创建监听响应进行消息读取
auto listener = listener_node->CreateReader<Car>(
        "car_speed", message_callback);
apollo::cyber::WaitForShutdown();
return 0;

}

  1. 运行与测试
  2. bazel 编译文件编写
    编写bazel编译文件(编写在cyber/examples/cyber_test/BUILD中)。
    load(“@rules_cc//cc:defs.bzl”, “cc_binary”, “cc_library”)
    load(“//tools/install:install.bzl”, “install”, “install_src_files”)
    load(“//tools:cpplint.bzl”, “cpplint”)

package(default_visibility = [“//visibility:public”])

cc_binary(
name = “talker”,
srcs = [“talker.cc”],
deps = [
“//cyber”,
“//test/proto:car_cc_proto”,
],
linkstatic = True,
)

cc_binary(
name = “listener”,
srcs = [“listener.cc”],
deps = [
“//cyber”,
“//test/proto:car_cc_proto”,
],
linkstatic = True,
)
2. 编译:
使用apollo 包管理开发方式提供的buildtool工具
buildtool build -p test/communication/
如下图所示,则编译成功。

  1. 运行案例
    首先,先将输出方法改为控制台输出。
    export GLOG_alsologtostderr=1
    打开两个终端,都进入Apollo的docker环境,一个终端运行talker,另一个运行listener,会发现listener运行后开始接收talker发送的小车速度的消息。
    ./bazel-bin/test/communication/talker
    结果显示:

./bazel-bin/test/communication/listener
结果显示:

总体运行效果如下图所示。

第四节:Cyber RT 本地部署之话题通信实践案例

  1. Apollo 本地安装部署
    Apollo 本地部署安装方式

  2. 创建和进入 Apollo 环境容器

  3. 创建工作空间
    创建并进入目录
    mkdir application-demo
    cd application-demo

  4. 启动 apollo 环境容器
    aem start
    如果一切正常,将会见到类似下图的提示:

  5. 进入 apollo 环境容器
    aem enter
    脚本执行成功后,将显示以下信息,您将进入 Apollo 的运行容器:

工作空间文件夹将被挂载到容器的 /apollo_workspace 中。

  1. 初始化工作空间
    aem init

至此 Apollo 环境管理工具及容器已经安装完成。
3. Protobuf、talker-listener实践案例演示

  1. Protobuf 案例:
    打印日志
    export GLOG_alsologtostderr=1
    运行car:
    cd /apollo_workspace/bazel-bin/test_proto/
    ./car
    car 运行结果如图所示

  2. talker-listener 案例:
    talker进入环境配置打印日志:
    aem start
    aem enter
    export GLOG_alsologtostderr=1
    运行talker:
    cd /apollo_workspace/bazel-bin/test/communication/
    ./talker
    talker 运行结果如图所示

listener进入环境配置打印日志:
aem start
aem enter
export GLOG_alsologtostderr=1
运行listener:
cd /apollo_workspace/bazel-bin/test/communication/
./listener
listener 运行结果如图所示

课后学习内容:
作业:
编写Python话题通信实现。
练习一: 实现小车详细信息的获取——Server-Client通信
1.1 Server-Client 简介

我们想要获得小车的详细信息,比如车牌这些,但是又不需要一直获得该信息,想要在需要知道这些信息的时候请求一下就好,于是考虑用Server- Client通信实现该功能。如图2-1所示,Server-Client通信可以在客户端发出消息请求时,服务端才进行请求回应,并将客户端所需的数据返回给客户端。该通信模式适合临时的消息传输,适用于不需要持续性发送数据的场景。其传输的数据定义依然在对应的proto文件中。
1.2 Server-Client 案例实现
编写一个Server来对Client请求的消息进行回应,这里我们返回车的车牌号、车主、已行驶公里数等信息。
#include “test/proto/car.pb.h”

#include “cyber/cyber.h”
//使用proto中定义好的car数据结构,还记得这个数据结构在那定义的吗?
using apollo::cyber::test::proto::Car;

int main(int argc, char* argv[]) {
apollo::cyber::Init(argv[0]);
std::shared_ptrapollo::cyber::Node node(
apollo::cyber::CreateNode(“server”));

//创建server node并设置topic名称,定义响应函数
auto server = node->CreateService<Car, Car>("service_client", 
[](const std::shared_ptr<Car>& request,std::shared_ptr<Car>& response) {
    AINFO << "Hi, I am your car's server.";
    response->set_type("apollo");
    response->set_plate("京A8888888");
    response->set_owner("xxx");
    response->set_kilometers(5);
  });
  
apollo::cyber::WaitForShutdown();
return 0;

}
编写一个Client来请求车的详细信息,并获取数据。
#include “test/proto/car.pb.h”

#include “cyber/cyber.h”

//使用proto中定义好的car数据结构
using apollo::cyber::examples::cyber_test_proto::Car;

int main(int argc, char* argv[]){
//初始化cyber框架
apollo::cyber::Init(argv[0]);

//创建client node
std::shared_ptr<apollo::cyber::Node> node(
  apollo::cyber::CreateNode("client"));
auto client = node->CreateClient<Car, Car>("service_client");

AINFO << "Hi server, I want to know car's information";

//创建一个请求
auto request = std::make_shared<Car>();

//发送请求并获得回应数据
auto response = client->SendRequest(request);
if(apollo::cyber::OK){
    if (response != nullptr) {
        AINFO << "this car owner is : " << response->owner();
        AINFO << "this car plate is : " << response->plate();
        AINFO << "this car type is : " << response->type();
        AINFO << "this car has run : " << response->kilometers()<<"kilometers";
    } else {
        AINFO << "service may not ready.";
    }
}

apollo::cyber::WaitForShutdown();
return 0;

}
编写bazel编译文件(编写在cyber/examples/cyber_test/BUILD中)。
cc_binary(
name = “server”,
srcs = [“server.cc”],
deps = [
“//cyber”,
“//test/proto:car_cc_proto”,
],
linkstatic = True,
)

cc_binary(
name = “client”,
srcs = [“client.cc”],
deps = [
“//cyber”,
“//test/proto:car_cc_proto”,
],
linkstatic = True,
)

  • 编译:
    仍然打开两个终端,进入apollo的docker环境后,进行编译,其BUILD文件和talker.cc等为同一个文件,所以编译语句相同,也可以精准编译,先编译server再编译client, 这里为了方便整体编译了。
    buildtool build test/communication/

  • 运行:
    ./bazel-bin/test/communication/server
    ./bazel-bin/test/communication/client
    运行成功后结果如下:

练习二: 实现小车通用参数的设置——Parameter Server-Client
2.1 Parameter Server-Client 简介

有一些参数比如该车的最高限速,最多乘客以及是否自动驾驶等需要被各个模块所使用,比如是否自动驾驶这个参数可能同时影响这很多模块,也可能被很多模块运行时所更改。我们希望有一个类似于“全局变量”的方式来存储这些参数,并定义一些自定义参数来进行使用。Cyber中设计了全局参数服务器来实现这个功能,其通信依然基于RTPS协议,如图2-8所示。该通信方式服务端和客户端都可以设置参数和更改参数。
2.2 Parameter Server-Client 案例实现
#include “cyber/cyber.h”
#include “cyber/parameter/parameter_client.h”
#include “cyber/parameter/parameter_server.h”

using apollo::cyber::Parameter;
using apollo::cyber::ParameterServer;

int main(int argc, char** argv) {
//初始化cyber框架
//创建一个node,该node的名字和Topic名字同名
apollo::cyber::Init(*argv);
std::shared_ptrapollo::cyber::Node server_node =
apollo::cyber::CreateNode(“parameters_server”);
AINFO << “Hi,I’am your car’s parameter server.”;

//从该node创建参数服务器
auto param_server = std::make_shared(server_node);

//服务端进行参数设置,对小车的最高速度、最大人数、是否自动驾驶等参数进行了设置
param_server->SetParameter(Parameter("max_speed", 120));
param_server->SetParameter(Parameter("max_people", 5));
param_server->SetParameter(Parameter("if_auto", true));

//尝试客户端修改一个参数,如max_speed,查看服务端目前的值
Parameter car_parameter;
param_server->GetParameter("max_speed", &car_parameter);
AINFO << "origin max_speed " << car_parameter.AsInt64();

apollo::cyber::WaitForShutdown();
return 0;

}

编写param_client.cc。
#include “cyber/cyber.h”
#include “cyber/parameter/parameter_client.h”

using apollo::cyber::Parameter;
using apollo::cyber::ParameterClient;

using apollo::cyber::Parameter;
using apollo::cyber::ParameterClient;

int main(int argc, char** argv){
apollo::cyber::Init(*argv);
std::shared_ptrapollo::cyber::Node client_node =
apollo::cyber::CreateNode(“parameters_client”);
auto param_client = std::make_shared(client_node,“parameters_server”);
AINFO<<“Hi, I’m car’s parameters client!”;

//获取所有参数,用vector获取所有参数
std::vector<Parameter> car_parameters;
param_client->ListParameters(&car_parameters);
//遍历获取的参数,显示参数的名字以及参数的类型
for(auto &&parameter : car_parameters){
    AINFO << parameter.Name() <<" is " << parameter.TypeName();
}


//客户端选择一个参数进行修改,比如修改max_speed
param_client->SetParameter(Parameter("max_speed",180));

//获取修改后的max_speed
Parameter car_parameter;
param_client->GetParameter("max_speed", &car_parameter);
AINFO << "now max_speed " << car_parameter.AsInt64();

apollo::cyber::WaitForShutdown();
return 0;

}
编写编译文件(编写在cyber/examples/cyber_test/BUILD中)。

deps = [
    "//cyber",
    "//cyber/parameter",
],
linkstatic = True,

)

cc_binary(
name = “param_server”,
srcs = [“param_server.cc”],
deps = [
“//cyber”,
“//cyber/parameter”,
],
linkstatic = True,
)

install(
name = “install”,
runtime_dest = “test/bin”,
targets = [
“:talker”,
“:listener”,
“:server”,
“:client”,
“:param_client”,
“:param_server”
],
)

install_src_files(
name = “install_src”,
src_dir = [“.”],
dest = “test/src/cyberatest”,
filter = “*”,
)

  • 编译:
    还是打开两个终端,进入apollo的docker环境后,先进行编译。
    buildtool build test/communication/

  • 运行:
    ./bazel-bin/test/communication/server/param_server
    ./bazel-bin/test/communication/server/param_client

好啦,至此通过“小车”案例已经介绍完了Cyber三种通信方式的简单用法,快动起手来试试吧~文章来源地址https://www.toymoban.com/news/detail-621456.html

到了这里,关于cyber_back的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【威胁情报挖掘-论文阅读】学习图表绘制 基于多实例学习的网络行为提取 SeqMask: Behavior Extraction Over Cyber Threat Intelligence

    🌈你好呀!我是 是Yu欸 🌌 2024每日百字篆刻时光,感谢你的陪伴与支持 ~ 🚀 欢迎一起踏上探险之旅,挖掘无限可能,共同成长! 前些天发现了一个人工智能学习网站,内容深入浅出、易于理解。如果对人工智能感兴趣,不妨点击查看。 论文涉及7位专家的评估,不方便模仿

    2024年03月20日
    浏览(50)
  • sql server导入.back文件

    使用SQL server官方的连接工具 SQL server Management studio 有两种方式 第一种: 前提是,提前知道数据库名称,建好数据库 以数据库 TEST为例子 右键数据库选型,选择新建数据库 输入数据库名字,点击确定 创建完成之后,右键对应的数据库任务还原数据库 但是这样导入一般会报错

    2024年02月15日
    浏览(41)
  • C++——Vector:push_back和emplace_back的区别,测试写入1GB大数据时的性能差距

    emplace_back是C++11引入的STL容器成员函数。emplace操作只执行构造而不执行拷贝构造。 如何理解上面这句话?先来看一个场景。 test类显式写出了三个构造函数,分别是无参构造、单参数构造、拷贝构造。因为C++中单参数的构造函数支持隐式类型转换,因此可以拿一个整型构造一

    2024年02月10日
    浏览(41)
  • .NET个人博客-使用Back进行消息推送

    我的好友看了我的博客,给我提了个需求,让我搞个网站通知,我开始以为就是评论回复然后发送邮件通知。不过他告诉我网站通知是,当有人评论或者留言后,会通知到我这边来,消息是实时通知的,他说用的是Back,不需要发邮件,然后发了个GitHub链接给我,我觉得还不错

    2024年02月16日
    浏览(35)
  • 【C++】STL——list的介绍和使用、list增删查改函数的介绍和使用、push_back、pop_back

    list构造函数的介绍和使用      push_front()函数用于将一个新的元素插入到链表的开头位置。 通过调用push_front()函数并将待插入的元素作为参数传递给该函数,即可实现在链表开头插入新元素的操作。   和链表的插入一样,push_front()函数的时间复杂度为O(1),因为在双向链

    2024年02月15日
    浏览(56)
  • Cinder — back-end storage pools

    Cinder 自身不提供存储技术,而是作为一个抽象的中间管理层,北向提供稳定而统一的 Block Storage 资源模型、南向通过 Plug-in 和 Drivers 模型对接多样化的后端存储设备(e.g. LVM、CEPH、NetApp、Datastore etc.)。 对于后端存储池信息,OpenStack为我们提供了接口进行查询。 仅管理员。

    2024年02月09日
    浏览(34)
  • Back-off restarting failed container报错

    我的配置文件中有这样一小段 来测试配置清单是否可用。 出现错误时: kubectl logs busybox -p 这时候因为没有访问 是看不到日志的 kubectl describe pod busybox 看到了问题所在: Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal Scheduled 87s default-scheduler Successfully assigned default/bu

    2024年01月23日
    浏览(31)
  • 详细解释C++中.push_back的用法

    在 C++ 中, push_back 是一个用于在容器的末尾添加元素的成员函数,常用于向容器(例如向量、列表、队列等)添加新的元素。对于标准库中的容器, push_back 主要用于 std::vector 和 std::deque 。 以下是 push_back 的基本用法和解释: 在这个例子中, push_back 用于将整数元素添加到

    2024年03月15日
    浏览(30)
  • 深度解析window.history.go()和history.back()

    深度解析window.history.go()和history.back() 大家好,我是免费搭建查券返利机器人赚佣金就用微赚淘客系统3.0的小编,也是冬天不穿秋裤,天冷也要风度的程序猿!在今天的文章中,我们将深入研究前端开发中两个非常重要的历史记录管理方法—— window.history.go() 和 history.back() 。

    2024年01月21日
    浏览(34)
  • Back-off restarting failed container 问题解决

    问题: 通过yaml文件创建pod时,执行完yaml文件,过一会就开始报错说 Back-off restarting failed container 。 查看pod状态一致处于 CrashLoopBackOff 原理: Back-off restarting failed container的Warning事件,一般是由于通过指定的镜像启动容器后,容器内部没有常驻进程,导致容器启动成功后即退

    2024年02月05日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包