【嵌入式系统应用开发第2周作业】----ROS通信模式编程

已于 2023-03-19 15:28:58 修改
阅读量215 收藏 2
点赞数
文章标签： 网络 服务器 python
于 2023-03-19 15:25:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52166467/article/details/129628933
版权

文章目录

1.话题、服务模式的ROS程序设计实践

创建工作空间

  • 先介绍一下工作空间，简单地说吧，ROS workspace （工作空间）就是统一存放 ROS 文件的地方，比如一个项目的所有 ROS 文件最好都放在一个 workspace 中，便于统一管理、编译和调用
  • 创建工作空间的代码：
mkdir -p ~/catkin_ws/src
cd ~/catkin_ws/src
catkin_init_workspace

编译工作空间代码

cd ..
catkin_make
  • 设置检查环境变量代码
source devel/setup.bash
echo $ROS_PACKAGE_PATH
  • 创建功能包代码
cd ~/comm_ws/src
catkin_create_pkg learning_communication std_msgs rospy roscpp

编译功能包代码

cd ~/catkin_ws
catkin_make
source ~/catkin__ws/devel/setup.bash

话题编程

  • 先了解一下话题通讯的流程
    在这里插入图片描述
    其次是话题编程的流程：
    1、创建发布者（talker）;
    2、创建订阅者（listener）;
    3、添加编译选项;
    4、运行可执行文件;

  • 通过例题进行实践：编写代码实现 ROS 中消息的发布与订阅: 创建一个发布者，每隔 100ms 依次发送斐波拉契数列的数字到话题/fibonacci 中;创建一个订阅者，订阅该话题，输出订阅结果。如，订阅者依次输出: 1 1 2 3 5 8 ··

  • 自定义话题消息

先定义msg文件，在工作空间catkin_ws/src内learning_communication的功能包内创建文件夹msg，并在msg内创建文件number.msg文件，在把上面的文件内容复制进文件。

int32 number

在package.xml中添加动态生成message的功能包依赖

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

在这里插入图片描述
在CMakeLists.txt添加编译选项

1.在findpacksge(……)结尾添加messagegeneration

2.在写有关于message内容下面添加

add_message_files(
  FILES
  number.msg
)
generate_messages(
  DEPENDENCIES
  std_msgs
)

在catkinpackage(….)结尾添加messageruntime

回到工作空间的根目录下编译生成相应的头文件

cd catkin_ws
catkin_make
  • 创建发布者和订阅者代码实现（C++）
    在工作空间catkin*_ws/src内的learning_communication功能包src内创建文件编写代码
    number_publisher.cpp：
#include<ros/ros.h>
#include"learning_communication/number.h"
int f(int count) {
    if (count == 1 || count == 2) {
        return 1;
    }
    else {
        return f(count - 2) + f(count - 1);
    }
}
int main(int argc, char** argv) {
     setlocale(LC_ALL,"");
    //ROS节点初始化
    ros::init(argc, argv, "number_publisher");
    //创建节点句柄
    ros::NodeHandle n;
    //创建一个publisher,发布名为/fibonacci的topic，消息类型为std_msgs::Int32,队>列长度为10
    ros::Publisher fibonacci_pub = n.advertise<learning_communication::number>("/fibonacci", 100);
    //设置循环频率
    ros::Rate loop_rate(10);
    int count = 1;
  while (ros::ok()) {
        //初始化geometry_sgs::Twist类型消息
        homework_pkg::number1 msg;
        msg.number = f(count);
        //发布消息
        fibonacci_pub.publish(msg);
        ROS_INFO("%d",msg.number);
        //按循环频率延时
        loop_rate.sleep();
        count++;
    }
    return 0;
}

number_subscriber.cpp：

#include<ros/ros.h>
#include"learning_communication/number.h"
int f(int count) {
    if (count == 1 || count == 2) {
        return 1;
    }
    else {
        return f(count - 2) + f(count - 1);
    }
}
int main(int argc, char** argv) {
     setlocale(LC_ALL,"");
    //ROS节点初始化
    ros::init(argc, argv, "number_publisher");
    //创建节点句柄
    ros::NodeHandle n;
    //创建一个publisher,发布名为/fibonacci的topic，消息类型为std_msgs::Int32,队>列长度为10
    ros::Publisher fibonacci_pub = n.advertise<learning_communication::number>("/fibonacci", 100);
    //设置循环频率
    ros::Rate loop_rate(10);
    int count = 1;
  while (ros::ok()) {
        //初始化geometry_sgs::Twist类型消息
        homework_pkg::number1 msg;
        msg.number = f(count);
        //发布消息
        fibonacci_pub.publish(msg);
        ROS_INFO("%d",msg.number);
        //按循环频率延时
        loop_rate.sleep();
        count++;
    }
    return 0;
}
  • 编译测试

编译前先要在功能包内的CMakeList.txt内配置编译规则
设置需要编译的代码和生成的可执行文件，设置链接库

add_executable(number_publisher src/number_publisher.cpp)
target_link_libraries(number_publisher ${catkin_LIBRARIES})
  
add_executable(number_subscriber src/number_subscriber.cpp)
target_link_libraries(number_subscriber ${catkin_LIBRARIES})

回到根目录进行编译

cd catkin_ws
catkin_make

依次开三个终端跑命令

roscore
rosrun learning_communication number_publisher
rosrun learning_communication number_subscriber

运行结果：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

服务编程

  • 服务编程流程
    1.创建服务器
    2.创建客户端
    3.添加编译选项
    4.运行可执行程序

图示：
在这里插入图片描述

  • 通过例题进行实践：编写代码实现 ROS 中的服务请求与答复: 创建服务端，注册 Service，当服务端收到客户端 Service 请求(携带整型参数 a.b) 后，服务端返回 a.b 的和给客户端，客户端输出结果。如，客户端给服务端 Service 发送参数 3,9，服务端返回 12，客户端输出: 12。
    如何自定义服务数据
  • 自定义服务数据
    先定义srv文件
int32 num1
int32 num2
---
int32 sum

在工作空间catkin_ws/src内learning_communication功能包内创建文件夹srv，并在srv内创建文件number.srv文件，在把上面的文件内容复制进文件。

在package.xml中添加动态生成message的功能包依赖

<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

在CMakeLists.txt添加编译选项

1.在findpacksge(……)结尾添加messagegeneration

2.在写有关于service内容下面添加

add_service_files(
  FILES
  number.srv
)
generate_messages(
  DEPENDENCIES
  std_msgs
)

在catkinpackage(….)结尾添加messageruntime

回到工作空间的根目录下编译生成相应的头文件

cd ~、catkin_ws
catkin_make
  • 创建服务端和客户端代码实现（C++）

在工作空间catkin_ws/src内learning_communication功能包src内创建文件编写代码

number_client.cpp：

#include "ros/ros.h"
#include "learning_communication/number.h"
int main(int argc, char **argv)
{
    // 初始化 ROS 节点
    ros::init(argc, argv, "xiaomei");
    // 创建 ROS 句柄
    ros::NodeHandle n;
    // 创建 客户端 对象
    ros::ServiceClient client = n.serviceClient<learning_communication::number>("number");
    // 提交请求并处理响应
    learning_communication::number a;
    //提交请求
    a.request.num1 = 3;
    a.request.num2 = 9;
    //处理响应
    bool flag = client.call(a);
    if (flag)
    {
        ROS_INFO(" 响应成功！两个数的和为：%d", a.response.sum);
    }
    else
    {
        ROS_INFO("响应失败");
    }
 
    // ros::spin()循环等待回调函数
    ros::spin();
}

number_server.cpp:

#include "ros/ros.h"
#include "learning_communication/number.h"
 
// 回调函数：bool 返回值由于标志是否处理成功
bool Callback(learning_communication::number::Request& req,
    learning_communication::number::Response& resp)
{
    //1处理请求
    int num1 = req.num1;
    int num2 = req.num2;
    ROS_INFO("服务器接收到的请求数据为:num1 = %d, num2 = %d", num1, num2);
    //2组织响应
    int sum = num1 + num2;
    resp.sum = sum;
    ROS_INFO("两个数的和：sum = %d", sum);
    return true;
}
 
int main(int argc, char **argv)
{
 
    // 初始化 ROS 节点
    ros::init(argc, argv, "number_Server");
    // 创建 ROS 句柄
    ros::NodeHandle n;
    // 创建 服务 对象
    ros::ServiceServer server = n.advertiseService("number", Callback);
    ROS_INFO("服务启动....");
    //     回调函数处理请求并产生响应
    //     由于请求有多个，需要调用 ros::spin()
}
  • 编译测试

编译前先要在功能包 learning_communication内的CMakeList.txt内配置编译规则

设置需要编译的代码和生成的可执行文件，设置链接库

add_executable(number_client src/number_client.cpp)
target_link_libraries(number_client ${catkin_LIBRARIES})
  
add_executable(number_server src/number_server.cpp)
target_link_libraries(number_server ${catkin_LIBRARIES})

addexecutable(numberclient src/numberclient.cpp)，src/numberclient.cpp是指的前面编写代码的文件，numberclient是设置src/numberclient.cpp编译后形成的可执行文件的名字

targetlinklibraries(numberclient ${catkinLIBRARIES})是将可执行文件与对应的链接库链接。

回到catkin_ws工作空间根目录下编译

cd ~/catkin_ws
catkin_make

依次开三个终端跑命令

roscore
rosrun learning_communication number_client
rosrun learning_communication number_server

运行结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.ROS kinetic 动作编程实践

目标：客户端发送一个运动目标，模拟机器人运动到目标位置的过程，带有实时位置反馈

  • 创建工作区间

创建功能包：

mkdir -p ~/catkin_ws/src
cd catkin_ws/src/
catkin_create_pkg learn_action std_msgs rospy roscpp

编译功能包：

cd ~/catkin_ws
catkin_make
source ~/catkin_ws/devel/setup.bash
  • 动作编程

定义action文件

在learn_action文件下创建action文件，在action文件下创建TurtleMove.action文件
在这里插入图片描述
在这里插入图片描述
在TurtleMove.action文件内输入代码:

# Define the goal 
float64 turtle_target_x  
# Specify Turtle's　target position 
float64 turtle_target_y 
float64 turtle_target_theta 
---
# Define the result 
float64 turtle_final_x 
float64 turtle_final_y 
float64 turtle_final_theta 
--- 
# Define a feedback message 
float64 present_turtle_x 
float64 present_turtle_y 
float64 present_turtle_theta

在learn_actTurtleMove_server.cppion的src文件夹下，创建TurtleMove_server.cpp文件，TurtleMove_client.cpp文件
TurtleMove_server.cpp

  /*   　　　此程序通过通过动作编程实现由client发布一个目标位置 　　　然后控制Turtle运动到目标位置的过程  */ 
#include <ros/ros.h> #include <actionlib/server/simple_action_server.h> 
#include "learn_action/TurtleMoveAction.h" 
#include <turtlesim/Pose.h>  
#include <turtlesim/Spawn.h> 
#include <geometry_msgs/Twist.h>   
typedef actionlib::SimpleActionServer<learn_action::TurtleMoveAction> Server;   
struct Myturtle 
{     
     float x;     
     float y;     
     float theta; 
 }turtle_original_pose,turtle_target_pose;   
 ros::Publisher turtle_vel;  
 void posecallback(const turtlesim::PoseConstPtr& msg)  
 {    
 	ROS_INFO("Turtle1_position:(%f,%f,%f)",msg->x,msg->y,msg->theta);   
 	turtle_original_pose.x=msg->x;    
 	turtle_original_pose.y=msg->y;   
 	turtle_original_pose.theta=msg->theta;  
 }   
 // 收到action的goal后调用该回调函数 
 void execute(const learn_action::TurtleMoveGoalConstPtr& goal, Server* as) 
 {     
 	learn_action::TurtleMoveFeedback feedback;       
 	ROS_INFO("TurtleMove is working.");     
 	turtle_target_pose.x=goal->turtle_target_x;     
 	turtle_target_pose.y=goal->turtle_target_y;      
 	turtle_target_pose.theta=goal->turtle_target_theta;          
 	geometry_msgs::Twist vel_msgs;     
 	float break_flag;          
 	while(1)     
 	{           
 		ros::Rate r(10);                  
 		vel_msgs.angular.z = 4.0 * (atan2(turtle_target_pose.y-turtle_original_pose.y,                                    turtle_target_pose.x-turtle_original_pose.x)-turtle_original_pose.theta);         
 		vel_msgs.linear.x = 0.5 * sqrt(pow(turtle_target_pose.x-turtle_original_pose.x, 2) +                                       pow(turtle_target_pose.y-turtle_original_pose.y, 2));          
 		break_flag=sqrt(pow(turtle_target_pose.x-turtle_original_pose.x, 2) +                                         pow(turtle_target_pose.y-turtle_original_pose.y, 2));         
 		turtle_vel.publish(vel_msgs);
 		           
 		feedback.present_turtle_x=turtle_original_pose.x;         
 		feedback.present_turtle_y=turtle_original_pose.y;         
 		feedback.present_turtle_theta=turtle_original_pose.theta;         
 		as->publishFeedback(feedback);         
 		ROS_INFO("break_flag=%f",break_flag);         if(break_flag<0.1) break;         r.sleep();     }         // 当action完成后，向客户端返回结果         ROS_INFO("TurtleMove is finished.");         
 		as->setSucceeded();
}   
int main(int argc, char** argv) 
{     
	ros::init(argc, argv, "TurtleMove_server");     
	ros::NodeHandle n,turtle_node;     
	ros::Subscriber sub =turtle_node.subscribe("turtle1/pose",10,&posecallback);//订阅小乌龟的位置信息     
	turtle_vel = turtle_node.advertise<geometry_msgs::Twist>("turtle1/cmd_vel",10);//发布控制小乌龟运动的速度     
	// 定义一个服务器         
	Server server(n, "TurtleMove", boost::bind(&execute, _1, &server), false);        
	 // 服务器开始运行         
	 server.start();         
	 ROS_INFO("server has started.");     
	 ros::spin();       
	 return 0;
}

TurtleMove_client.cpp

#include <actionlib/client/simple_action_client.h> 
#include "learn_action/TurtleMoveAction.h" 
#include <turtlesim/Pose.h>  
#include <turtlesim/Spawn.h> 
#include <geometry_msgs/Twist.h>   
typedef actionlib::SimpleActionClient<learn_action::TurtleMoveAction> Client;   
struct Myturtle 
{     
	float x;     
	float y;   
	float theta; 
}turtle_present_pose;   
// 当action完成后会调用该回调函数一次 
void doneCb(const actionlib::SimpleClientGoalState& state,         const learn_action::TurtleMoveResultConstPtr& result) 
{     
	ROS_INFO("Yay! The TurtleMove is finished!");     
	ros::shutdown(); 
}   
// 当action激活后会调用该回调函数一次 
void activeCb() 
{     
	ROS_INFO("Goal just went active"); 
}   
// 收到feedback后调用该回调函数 
void feedbackCb(const learn_action::TurtleMoveFeedbackConstPtr& feedback) 
{     
	ROS_INFO(" present_pose : %f  %f  %f", feedback->present_turtle_x,                    feedback->present_turtle_y,feedback->present_turtle_theta); 
}   
int main(int argc, char** argv) 
{     
	ros::init(argc, argv, "TurtleMove_client");       
	// 定义一个客户端     
	Client client("TurtleMove", true);       
	// 等待服务器端     
	ROS_INFO("Waiting for action server to start.");     
	client.waitForServer();     
	ROS_INFO("Action server started, sending goal.");      
	 // 创建一个action的goal     
	 learn_action::TurtleMoveGoal goal;    
	 goal.turtle_target_x = 1;     
	 goal.turtle_target_y = 1;     
	 goal.turtle_target_theta = 0;       
	 // 发送action的goal给服务器端，并且设置回调函数     
	 client.sendGoal(goal,  &doneCb, &activeCb, &feedbackCb);       
	 ros::spin();      
	 return 0; 
}

修改package.xml文件：

<build_depend>message_generation</build_depend>  
<build_depend>actionlib</build_depend>  
<build_depend>actionlib_msgs</build_depend>
<exec_depend>message_runtime</exec_depend>  
<exec_depend>actionlib</exec_depend>  
<exec_depend>actionlib_msgs</exec_depend>

修改 ~/catkin_ws/src/learn_action/CMakeLists.txt
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
继续在末尾添加

add_executable(TurtleMove_client src/TurtleMove_client.cpp)
target_link_libraries(TurtleMove_client ${catkin_LIBRARIES})
add_dependencies(TurtleMove_client ${PROJECT_NAME}_gencpp)  

add_executable(TurtleMove_server src/TurtleMove_server.cpp)
target_link_libraries(TurtleMove_server ${catkin_LIBRARIES})
add_dependencies(TurtleMove_server ${PROJECT_NAME}_gencpp)
  • 编译测试
    在这里插入图片描述在这里插入图片描述

设置环境变量

source ~/catkin_ws/devel/setup.bash

分别新建4个终端，运行如下代码

roscore


source ~/catkin_ws/devel/setup.bash
rosrun turtlesim turtlesim_node


source ~/catkin_ws/devel/setup.bash
rosrun learn_action TurtleMove_server

source ~/catkin_ws/devel/setup.bash
rosrun learn_action TurtleMove_client
  • 运行结果

在这里插入图片描述

3.ROS实现多机通讯实践

  • 主机配置

查看主机地址

ifconfig

输入

export ROS_IP=192.168.182.139

开启

rocore

开启一个新的终端

export ROS_IP=192.168.182.139
export ROS_MASTER_URI=http://192.168.183.128:11311/
rosrun turtlesim turtlesim_node __name:=my_turtle
  • 从机配置

开启一个终端，输入

export ROS_IP= 192.168.182.126
export ROS_MASTER_URI=http://192.168.183.128:11311/

继续输入

rosnode ping my_turtle
rosrun turtlesim turtle_teleop_key

遥控结果：
在这里插入图片描述

4.总结

在ROS程序设计实践中，需要掌握ROS节点、话题和服务的定义和使用方法，了解ROS的消息传递机制和服务调用机制，同时还需要掌握编写ROS程序的基本方法和技巧，才能实现机器人的各项功能，然后就是ROS Kinetic动作编程实践的代码结构比较复杂，包含了多个ROS节点和多个源文件。因此，需要仔细学习其代码结构，并了解每个源文件和ROS节点的作用和功能，最后多机通讯最基本的则是搞正确主从机的ip地址。

5.参考

https://blog.csdn.net/qq_42585108/article/details/104852100?

@aln
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
罗德尼-长期以来的自主机器人（第3部分）
04-11
在“罗德尼-长期以来的自主机器人（第3部分）”这一主题中，我们深入探讨了ROS（Robot Operating System，机器人操作系统）在构建House Bot这一系列项目中的应用。ROS是机器人学领域的一个核心软件框架，它允许...
练习ROS动作编程
m0_72668380的博客
03-19 320
1.完成话题、服务模式的ROS程序设计，并实践； 2、练习ROS动作编程：客户端发送一个运动坐标，模拟机器人运动到目标位置的过程。包括服务端和客户端的代码实现，要求带有实时位置反馈。同时注意学习cmakelists 的使用方法。
【嵌入式系统应用开发第1周作业】----ROS环境安装与配置
weixin_52166467的博客
03-04 264
【嵌入式系统应用开发第1周作业】----ROS环境安装与配置
ROS2 嵌入式开发 学习笔记(一)
yxn4065的博客
10-31 877
学习笔记之ROS嵌入式开发,参考古月居老师源码
关于嵌入式开发
m0_64944622的博客
04-02 451
无论何时，就业形势永远是复杂的，ChatGPT4 已经问世，AI迅速发展，我们能做的就是跟上时代节奏，抓住机遇勇敢面对挑战，如今大环境骤变，新的一百年充满着为什么，我们无法改变它，我们能做的只有尽量适应它然后调整自己，这可能听起来很残酷，但这是真的。心灵鸡汤听听就好，但内心应当提高觉悟，努力学习不断提高自身能力，提高竞争力是关键。加油吧，各位！请保持热爱，如果有喜欢的东西，那就努力去争取！
罗德尼-长期以来的自主机器人（第8部分）
04-05
在“罗德尼-长期以来的自主机器人（第8部分）”这一主题中，我们探讨了ROS（Robot Operating System，机器人操作系统）在House Bot项目中的应用。ROS是一个开源操作系统，专为设计和开发智能机器人系统而创建。它...
罗德尼-长期以来的自主机器人（第5部分）
04-08
在“罗德尼-长期以来的自主机器人（第5部分）”这一主题中，我们深入了解了ROS（Robot Operating System，机器人操作系统）在构建House Bot这一家庭服务机器人中的应用。ROS是机器人学领域的一个核心软件框架，它...
Alpen-Adria-UniversitätKlagenfurt的多机器人探索_C++_Python_下载.zip
04-25
C++是一种高效且灵活的编程语言，常用于实时系统和嵌入式系统开发。在多机器人系统中，C++可以用于构建底层的控制算法、实时通信协议以及硬件驱动程序。其面向对象的特性使得设计模块化、可扩展的系统变得容易。此外...
ROS机器人程序设计
11-29
, 本书第2版概括性地介绍了ROS系统的各种工具。ROS是一个先进的机器人操作系统框架，现今已有数百个研究团体和公司将其应用在机器人行业中。对于机器人技术的非专业人士来说，它也相对容易上手。在本书中，你将了解...
hmallox勒索病毒科普：了解其威胁与防御策略
safe130_的博客
07-14 966
halo，.360，.faust，.2700, .eking，elbie, .wis，.mkp，.malox，.rmallox，.mallox，.hmallox, .anony, .ma1x0，.live，.carver，.locked，_locked，.locked1，.svh , lockbit, .src, .secret , .datah, .BEAST,.DevicData-P, .kat6.l6st6r 等等，：用户从非官方或不受信任的源下载软件时，可能会无意中安装带有勒索病毒的软件包。
【windows|014】TCP协议详解
小鹏linux的博客
07-15 958
TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。它工作在OSI模型的第四层，即传输层，为用户提供可靠的、有序的和无差错的数据传输服务。TCP协议与UDP协议是传输层的两大主要协议，但两者在设计上有明显的不同：TCP提供的是可靠的数据传输服务，而UDP则更注重传输的速度和效率
AI基于大模型语言存在的网络安全风险
yh
07-16 254
AI网络安全
智能车存在网络安全隐患，如何应设计出更好的安全防护技术？
tigerman20201的博客
07-13 276
然而，高度的网络化和智能化也使智能车面临着严峻的网络安全挑战，如远程攻击、数据泄露和恶意控制等。未来，随着技术的不断发展，应持续加强对智能车网络安全的研究和创新，以应对不断变化的安全威胁。摘要：随着智能车技术的迅速发展，车辆的网络连接性不断增强，然而这也带来了诸多网络安全隐患。本文深入探讨了智能车面临的网络安全威胁，并提出了一系列创新的安全防护技术设计，旨在为智能车的安全运行提供更可靠的保障。黑客可以通过公共网络对智能车的通信系统进行攻击，干扰车辆的正常运行，甚至获取车辆的控制权。
RIP路由协议概述
张海涛的专栏
07-12 258
若该条路由在被记为16跳后，120s内还没有收到更新，则将这条路由从路由表中删除。发送路由更新时，目标地址为广播地址：255.255.255.255。路由器每隔30s从每个启动RIP协议的接口发送出路由更新信息。若一条路由在180s内没有收到更新，这条路由的跳数将记为16。发送路由更新时，目标地址为组播地址224.0.0.9。RIP是一个【距离——矢量】路由选择协议。发送路由更新时【不携带】子网掩码，属于。发送路由更新时【携带】子网掩码，属于。当路由器的更新周期为30s到来时，向邻居发送路由表。
计算机网络复习笔记【面向考纲整理】
无
07-13 375
计算机网络（简称网络）由若干结点（node，节点）和连接这些结点的链路（link）组成。
H3C Intelligent Management Center无线认证新增设备如何配置
大鹏的博客
07-12 891
因为出口有多条宽带，所以静态路由要配置目的地址和下一跳，我太相信分公司的工程师了，导致一直有问题，没有正确指下一跳，然后一直通信单向可以，双向不行。下面有监控信息说明配置成功，配置的时候需要信息一致，包括高级设置重点安全提议，共享密钥等等。创建接入服务，调用接入策略，由于接入设备上配置带域名发送，则此处需配置服务后缀，与域名相同。选择手工增加设备，添加设备ip，若设备上配置nas ip，此处填nas ip地址。#// 配置portal服务器ip，共享密钥，重定向url。：共享密钥与设备侧填写的要一致，
计网（1.1~1.4）
2301_76590691的博客
07-12 563
网络:由若干结点和连接这些结点的链路组成互联网:多个网络还可以通过路由器互连起来，这样就构成了一个覆盖范围更大的网络，也可 被称为“网络中的网络因特网是世界上最大的互连网络计算机网络的精确定义并未统一计算机网络的简单定义：一些互相连接的、自治的计算机的集合互连是指计算机之间可以通过有线或无线的方式进行数据通信自治是指独立的计算机，它有自己的硬件和软件，可以单独运行使用集合是指至少需要两台计算机。
Linux系统
Baizeh的博客
07-16 765
把windows开发好的程序部署到linux操作系统上，因为windows操作系统漏洞太多容易被攻击。
linux学习笔记整理: 关于linux系统介绍 2024/7/16；
最新发布
gzx233的博客
07-16 707
linux基础介绍和指令
基于ORB-SLAM3库搭建SLAM系统
07-09
"基于ORB-SLAM3库搭建...这个过程需要对计算机视觉、传感器数据处理和机器人操作系统有深入的理解，但ORB-SLAM3的开源性质使得这个复杂的任务变得相对容易，为研究者和开发者提供了便利的工具来实现自己的SLAM应用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值