Method for building ROS communication system with distributed architecture

Abstract

The present invention discloses a method for building a ROS communication system with a distributed architecture, which includes the following specific steps: S1: Establishment of an experimental platform: Build a Gazebo simulation platform and create an experimental environment and a robot model; S2: Software design: Start the Gazebo simulation and deploy the robot model in the platform; S3: Operation and debugging: Run the built platform and the designed software and perform debugging; In the above S1, the establishment of the experimental platform includes the following specific steps: S11: Establish a Gazebo simulation platform: Select Gazebo as the robot simulation platform, where the operating system used in the simulation platform is Ubuntu20.04, and the corresponding ROS distribution is Foxy. The method for building a ROS communication system with a distributed architecture disclosed in the present invention can effectively improve the development efficiency and can bring the data exchange ability of the distributed network into full play.

Description

Technical Field

[0001] The present invention relates to the field of communication technologies, and particularly to a method for building a ROS communication system with a distributed architecture. Background Art

[0002] With the increasing development of China's economic level and the continuous improvement of the average consumption level of residents, China's logistics industry is booming. Today, with the gradual advancement of "Industry 4.0", the logistics industry is also keeping pace with the times, and the related concepts of intelligent logistics are becoming increasingly perfect. Looking at the entire logistics industry, the industrial chain has a large demand for human resources, a low level of automation, and relatively complex storage and transportation processes, belonging to a labor-intensive industry. In this context, the use of logistics robots can significantly improve the automation level of the industrial chain and save labor costs. In addition, logistics robots have remarkable characteristics: highly intelligent, highly customizable, and easy to manage and maintain. As an important technical equipment that can promote intelligent logistics to keep up with the pace of the "Industry 4.0" era, and as an important component that can inject fresh blood into the logistics industry, reduce costs, and improve service quality, its development prospect is very broad, with high research value and application value.

[0003] In practical applications, the systematic implementation of a certain type of robot covers a wide range of technical aspects, including but not limited to embedded software design, machining, algorithms, etc. And with the increasing complexity of its functions, the systematic implementation of robots is gradually developing towards multi-robot collaboration, modular design, intelligent control, etc., with a high degree of complexity. Therefore, a more suitable development strategy is needed. Based on the basic concept of "reuse", relevant researchers and developers should be able to focus on the fields they are proficient in, and other modules can directly reuse the implementation methods of professional developer teams and individuals in related fields under open-source or closed-source protocols, thereby improving the efficiency of the entire R & D process. In the above context, a large number of excellent frameworks have emerged for the efficient R & D of robots. The Robot Operating System (ROS) gives developers a usage experience similar to that of an operating system (OS). It has a rich software library, development and debugging tools, and ready-to-use protocols in the software repository, and has an open and active community. With the continuous development and iteration of ROS, it is gradually becoming a perfect and excellent popular development framework and the de facto standard in the field of robot development.

[0004] In production activities, the clustering of logistics robots is an inevitable trend. Clustering makes each robot no longer an independent individual. In a logistics robot cluster, robots have evolved from performing a fixed operation to autonomous perception and autonomous decision-making, which can give full play to the performance of each robot to achieve group collaborative work and converge the cluster to the best state.

[0005] Clustering cannot be separated from the support of distributed communication and distributed computing. How to maximize the use of ROS's original distributed communication performance, improve the real-time and integrity of messages, and strengthen the reliability of message transmission, so as to correctly process the information obtained by other nodes, the results of calculations, and the instructions issued becomes the key. Summary of the invention

[0006] The present invention discloses a method for constructing a distributed ROS communication system, aiming to solve the technical problem of how to maximize the use of the original distributed communication performance of ROS.

[0007] In order to achieve the above object, the present invention adopts the following technical solutions:

[0008] The method for building a distributed ROS communication system includes the following specific steps:

[0009] S1: Experimental platform establishment: build the Gazebo simulation platform and create the experimental environment and robot model;

[0010] S2: Software Design: Start the Gazebo simulation and deploy the robot model in the platform;

[0011] S3: Run and debug: Run the built platform and designed software, and debug;

[0012] In S1, the experimental platform establishment includes the following specific steps:

[0013] S11: Establish Gazebo simulation platform: Gazebo is selected as the robot simulation platform. The operating system used in the simulation platform is Ubuntu 20.04, and the corresponding ROS distribution is Foxy. Through this simulation platform, the focus of work can be focused on the construction and improvement of distributed communication systems, as well as the simulation of multi-robot communication in a simulation environment.

[0014] S12: Create Gazebo experimental environment: Create an experimental environment in the Gazebo simulation platform;

[0015] S13: Create a robot model: Create a robot model that follows the format rules of the Gazebo model database directory structure in the Gazebo simulation platform, and define the robot model through model.config and model.urdf. At the same time, in this robot model, a laser radar and a camera are designed, and the Ackerman motion model is adopted;

[0016] In S12, creating the Gazebo experimental environment includes the following specific steps:

[0017] S121: Create a functional package and import dependencies: Before establishing a simulation project, create a project package through ROS. The creation format is as follows: $ros2 pkg create–build-type ament_cmake mybot;

[0018] S122: Create an experimental environment: Use an xml file to define the simulation world.

[0019] By building a Gazebo simulation platform and simulating multiple different robot terminals, the development efficiency can be effectively improved. At the same time, by adopting the relatively mature Foxy version of ROS2 and using the Fast DDS Discovery Server as the node discovery protocol, a distributed network can be correctly formed, a decentralized topological network node can be built, and the data exchange ability of the distributed network can be brought into full play.

[0020] In a preferred solution, in S2, the software design includes the following specific steps:

[0021] S21: Start the Gazebo simulation: Write a startup file in Python for starting the Gazebo simulation platform, loading the world file, and deploying the robot respectively;

[0022] S22: Deploy the robot: Deploy multiple robots in the simulation platform;

[0023] In S22, deploying the robot includes the following specific steps:

[0024] S221: Define the robot: Define a namespace for the robot and define the position information of the robot in the world;

[0025] S222: Publish its own information: After the robot is deployed, it publishes its own information externally; so that developers can obtain information in the simulation environment in the real world;

[0026] S223: Call the function: Call the function set in publishing its own information;

[0027] S224: Create a loop: Complete the robot deployment by creating a loop.

[0028] By calling different functions of different nodes in the built distributed network, such as command distribution, position sharing, camera image sharing, and neural network operations, the scalability of the distributed architecture is illustrated.

[0029] In a preferred solution, in S3, running and debugging include the following specific steps:

[0030] S31: Debug the code: Build the code and debug it in the Gazebo simulation platform;

[0031] S32: Test the Fast-DDS discovery server: Start the discovery server to manage the discovery process of connected nodes;

[0032] S33: Outline the advanced usage of Fast-DDS;

[0033] S34: Compare the traffic of the simple discovery service and the Fast-DDS service: Compare the normal network traffic with the network traffic when using Fast-DDS;

[0034] S35: Explore the scalability of the distributed communication system: Use yolox to establish an object classification node to simulate the situation where a logistics robot transmits camera images back to a node responsible for complex operations in actual applications;

[0035] In the above S31, the steps for debugging the code include the following specific steps:

[0036] S311: Build the code: In the root directory of the workspace, run the colcon build command for the build operation;

[0037] S312: Start the Gazebo simulation platform: After compilation, run the command in the terminal to start and load the simulation platform of the world file;

[0038] S313: Deploy multiple robot terminals: In this simulation, set the number of robots to two;

[0039] S314: Establish the relationships between various topics.

[0040] By correctly configuring the simulation experiment platform and designing the communication methods between nodes, distributed multi-robot communication is achieved.

[0041] In a preferred solution, in the above S32, the steps for testing the Fast-DDS discovery server include the following specific steps:

[0042] S321: Set up the discovery server: Start a discovery server with an id of 0 and a port of 11811 and listen on all available interfaces;

[0043] S322: Start the listening node: Set the location of the discovery server in the environment variables;

[0044] S323: Start the publishing node: Receive the messages from the publishing node through the set listening node;

[0045] In the above S33, the steps for outlining the advanced usage of Fast-DDS include the following specific steps:

[0046] S331: Redundant Servers: Create multiple discovery servers through the Fast-DDS command-line tool. The discovery side of ROS nodes connects to any number of discovery servers as needed to form a redundant network.

[0047] S332: Backup Servers: Create servers with backup functions through the Fast-DDS service protocol.

[0048] Through the fastdds command-line tool, multiple discovery servers can be created. The discovery side of ROS nodes connects to any number of discovery servers as needed to form a redundant network, ensuring the stability of the entire communication network even when some discovery servers or nodes are accidentally shut down.

[0049] In a preferred solution, in S34, the comparison between the simple discovery service and the Fast-DDS service traffic includes the following specific steps:

[0050] S341: Write comparison experiment code: Use the simple discovery protocol and the execution nodes of the discovery server to execute a talker and multiple listeners respectively, and analyze the network traffic during this period.

[0051] S342: Draw a bar chart of network traffic: Draw a bar chart comparing the network traffic of the two protocols.

[0052] By drawing a graph and comparing the network traffic, it can be easily seen that when using Fast-DDS, the network traffic is significantly reduced. By using Fast-DDS, a large amount of traffic can be reduced in a large-scale architecture, making the Fast-DDS discovery service more scalable. By creating functional nodes and leveraging the excellent data transmission ability of the distributed communication system, the information processing ability within the system can be greatly improved, and the hardware resources can be reasonably utilized. Assuming limited hardware resources within the system, during complex image processing tasks, the image information can be transmitted to nodes with powerful computing capabilities through the distributed communication framework.

[0053] As can be seen from the above, the method for building a ROS communication system with a distributed architecture includes the following specific steps:

[0054] S1: Establishment of the experimental platform: Build a Gazebo simulation platform and create an experimental environment and a robot model.

[0055] S2: Software design: Start the Gazebo simulation and deploy the robot model in the platform.

[0056] S3: Running and debugging: Run the built platform and the designed software and perform debugging.

[0057] In S1, the establishment of the experimental platform includes the following specific steps:

[0058] S11: Establish the Gazebo simulation platform: Select Gazebo as the robot simulation platform. The operating system used in the simulation platform is Ubuntu 20.04, and the corresponding ROS distribution is Foxy. Through this simulation platform, the focus of work can be concentrated on the construction and improvement process of the distributed communication system, as well as completing the simulation work of multi-robot communication in the simulation environment;

[0059] S12: Create the Gazebo experimental environment: Create an experimental environment in the Gazebo simulation platform;

[0060] S13: Create a robot model: Create a robot model in the Gazebo simulation platform that follows the format rules of the Gazebo model database directory structure, and define the robot model through model.config and model.urdf. At the same time, in this robot model, a lidar and a camera are designed, and the Ackermann motion model is adopted;

[0061] In S12, creating the Gazebo experimental environment includes the following specific steps:

[0062] S121: Create a function package and import dependencies: Create a project package through ROS before establishing the simulation project. The creation format is as follows: $ros2 pkg create –build-type ament_cmake mybot;

[0063] S122: Create the experimental environment: Define the simulation world using an xml file. The method for building the ROS communication system with a distributed architecture provided by the present invention has the technical effects of effectively improving the development efficiency, being able to correctly form a distributed network, construct a decentralized topological network node, and being able to exert the data exchange ability of the distributed network to the best level. Description of the Drawings

[0064] Figure 1 It is a schematic diagram of the overall structure of the method for building a ROS communication system with a distributed architecture proposed by the present invention.

[0065] Figure 2 It is a schematic diagram of the overall process of the method for building a ROS communication system with a distributed architecture proposed by the present invention.

[0066] Figure 3 It is a schematic diagram of the process of creating the Gazebo experimental environment of the method for building a ROS communication system with a distributed architecture proposed by the present invention.

[0067] Figure 4Schematic diagram of the software design process for the method of building a ROS communication system with a distributed architecture proposed by the present invention.

[0068] Figure 5 Schematic diagram of the process of deploying a robot for the method of building a ROS communication system with a distributed architecture proposed by the present invention.

[0069] Figure 6 Schematic diagram of the operation and debugging process for the method of building a ROS communication system with a distributed architecture proposed by the present invention.

[0070] Figure 7 Schematic diagram of the debugging code process for the method of building a ROS communication system with a distributed architecture proposed by the present invention.

[0071] Figure 8 Schematic diagram of the process of testing the Fast-DDS discovery server for the method of building a ROS communication system with a distributed architecture proposed by the present invention.

[0072] Figure 9 Schematic diagram of the process of outlining the advanced usage of Fast-DDS for the method of building a ROS communication system with a distributed architecture proposed by the present invention.

[0073] Figure 10 Schematic diagram of the process of comparing the simple discovery service and the Fast-DDS service traffic for the method of building a ROS communication system with a distributed architecture proposed by the present invention. Detailed implementation manners

[0074] Next, the technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all of the embodiments.

[0075] The method of building a ROS communication system with a distributed architecture disclosed by the present invention is mainly applied to the scenario of building a communication architecture.

[0076] Refer to Figures 1 - 3 , the method of building a ROS communication system with a distributed architecture includes the following specific steps:

[0077] S1: Establish an experimental platform: Build a Gazebo simulation platform and create an experimental environment and a robot model;

[0078] S2: Software design: Start the Gazebo simulation and deploy the robot model in the platform;

[0079] S3: Run and debug: Run the built platform and the designed software and perform debugging;

[0080] In S1, the establishment of the experimental platform includes the following specific steps:

[0081] S11: Establish the Gazebo simulation platform: Select Gazebo as the robot simulation platform. The operating system used in the simulation platform is Ubuntu 20.04, and the corresponding ROS distribution is Foxy. Through this simulation platform, the focus of work can be concentrated on the construction and improvement process of the distributed communication system, as well as completing the simulation work of multi-robot communication in the simulation environment;

[0082] S12: Create a Gazebo experimental environment: Create an experimental environment in the Gazebo simulation platform;

[0083] S13: Create a robot model: Create a robot model in the Gazebo simulation platform that follows the format rules of the Gazebo model database directory structure, and define the robot model through model.config and model.urdf. At the same time, in this robot model, a lidar and a camera are designed, and the Ackermann motion model is adopted. The code example of model.config is as follows:

[0084] <?xml version="1.0"?>

[0085] <model>

[0086] <name>Mybot< / name>

[0087] <version> 1.0< / version>

[0088] <sdf version="1.6">model.urdf

[0089] <author>

[0090] <name>xxx< / name>

[0091] <email>xxx@xxxx< / email>

[0092] < / author>

[0093] <description>

[0094] Mybot

[0095] < / description>

[0096] < / model> ;

[0097] In S12, creating the Gazebo experimental environment includes the following specific steps:

[0098] S121: Create a function package and import dependencies: Create a project package through ROS before establishing the simulation project. The creation format is as follows: $ros2 pkg create –build-type ament_cmake mybot;

[0099] S122: Create an experimental environment: Define the simulation world using an xml file. The basic format is as follows:

[0100]

[0101]

[0102] Refer to Figure 4 , in a preferred implementation, in S2, the software design includes the following specific steps:

[0103] S21: Start the Gazebo simulation: Write startup files in Python for starting the Gazebo simulation platform, loading the world file, and deploying the robot respectively. The code is as follows:

[0104]

[0105]

[0106]

[0107] S22: Deploy robots: Deploy multiple robots in the simulation platform.

[0108] Refer to Figure 5 , in a preferred embodiment, in S22, deploying robots includes the following specific steps:

[0109] S221: Define the robot: Define the namespace for the robot and define the position information of the robot in the world. The code implementation is as follows:

[0110]

[0111]

[0112]

[0113] S222: Publish its own information: After the robot is deployed, it publishes its own information outward so that developers can obtain information in the simulation environment in the real world. The core code is as follows:

[0114]

[0115] S223: Call the function: Call the function set in publishing its own information. The call implementation code is as follows:

[0116]

[0117]

[0118] S224: Create a loop: Complete the robot deployment by creating a loop. The core code is as follows:

[0119]

[0120]

[0121] Refer to Figure 6 , in a preferred embodiment, in S3, running and debugging includes the following specific steps:

[0122] S31: Debug the code: Build the code and debug it in the Gazebo simulation platform;

[0123] S32: Test the Fast-DDS discovery server: Start the discovery server to manage the discovery process of connected nodes;

[0124] S33: Outline the advanced usage of Fast-DDS;

[0125] S34: Compare the simple discovery service with the Fast-DDS service traffic: Compare the normal network traffic with the network traffic when using Fast-DDS;

[0126] S35: Explore the scalability of the distributed communication system: Use yolox to establish an item classification node, simulating the situation where a logistics robot transmits camera images back to the node responsible for complex operations in actual applications. The core code is as follows:

[0127]

[0128]

[0129] Refer to Figure 7 , in a preferred embodiment, in S31, the debugging code includes the following specific steps:

[0130] S311: Build the code: In the root directory of the workspace, run the colcon build command to perform the build operation;

[0131] S312: Start the Gazebo simulation platform: After compilation, run the command in the terminal to start the simulation platform that loads the world file;

[0132] S313: Deploy multiple robot terminals: In this simulation, set the number of robots to two;

[0133] S314: Establish the relationships between topics.

[0134] Refer to Figure 8 , in a preferred embodiment, in S32, testing the Fast-DDS discovery server includes the following specific steps:

[0135] S321: Set up the discovery server: Start a discovery server with an id of 0 and a port of 11811 and listen on all available interfaces;

[0136] S322: Start the listening node: Set the location of the discovery server in the environment variables;

[0137] S323: Start the publishing node: Receive the messages from the publishing node through the set listening node.

[0138] Refer to Figure 9 , in a preferred embodiment, in S33, outlining the advanced usage of Fast-DDS includes the following specific steps:

[0139] S331: Redundant Servers: Create multiple discovery servers through the Fast-DDS command-line tool. The discovery side of ROS nodes connects to any number of discovery servers as needed to form a redundant network.

[0140] S332: Backup Servers: Create a server with backup capabilities through the Fast-DDS service protocol.

[0141] Refer to Figure 10 , in a preferred embodiment, in S34, the comparison between the simple discovery service and the Fast-DDS service traffic includes the following specific steps:

[0142] S341: Write comparison experiment code: Use the simple discovery protocol and the execution nodes of the discovery server to execute a talker and multiple listeners respectively, and analyze the network traffic during this period. The core code is as follows:

[0143]

[0144]

[0145] S342: Draw a bar chart of network traffic: Draw a bar chart comparing the network traffic of the two protocols.

[0146] Working principle: When in use, by building a Gazebo simulation platform and simulating multiple different robot terminals, the development efficiency can be effectively improved. At the same time, using the relatively mature Foxy version of ROS2 and the Fast DDS DiscoveryServer as the node discovery protocol can correctly form a distributed network, build a decentralized topological network node, and bring the data exchange ability of the distributed network into full play.

[0147] The above is only a preferred specific embodiment of the present invention, but the protection scope of the present invention is not limited thereto. Any person skilled in the art within the technical scope disclosed by the present invention, according to the technical solution and inventive concept of the present invention, makes equivalent replacements or changes, and all should be covered within the protection scope of the present invention.

Claims

1. A method for building a ROS communication system with a distributed architecture, characterized in that, It includes the following specific steps: S1: Establishment of the experimental platform: Build a Gazebo simulation platform and create an experimental environment and a robot model; S2: Software design: Start the Gazebo simulation and deploy the robot model in the platform; S3: Operation and debugging: Run the built platform and the designed software and conduct debugging; In the above S1, the establishment of the experimental platform includes the following specific steps: S11: Establish the Gazebo simulation platform: Select Gazebo as the robot simulation platform, where the operating system used in the simulation platform is Ubuntu 20.04, and the corresponding ROS distribution is Foxy; S12: Create the Gazebo experimental environment: Create an experimental environment in the Gazebo simulation platform; S13: Create a robot model: Create a robot model in the Gazebo simulation platform that follows the format rules of the Gazebo model database directory structure, and define the robot model through model.config and model.urdf; In the above S12, the creation of the Gazebo experimental environment includes the following specific steps: S121: Create a function package and import dependencies: Create a project package through ROS before establishing the simulation project, and the creation format is as follows: $ros2 pkg create–build-type ament_cmake mybot; S122: Create an experimental environment: Define the simulation world using an xml file; In the above S3, the operation and debugging include the following specific steps: S31: Debug the code: Build the code and conduct debugging in the Gazebo simulation platform; S32: Test the Fast-DDS discovery server: Start the discovery server to manage the discovery process of connected nodes; S33: Outline the advanced usage of Fast-DDS; S34: Compare the traffic of the simple discovery service and the Fast-DDS service: Compare the normal network traffic with the network traffic when using Fast-DDS; S35: Explore the scalability of the distributed communication system: Build an object classification node with yolox to simulate the situation where a logistics robot transmits camera images back to a node responsible for complex operations in actual applications; In the above S34, the comparison of the traffic of the simple discovery service and the Fast-DDS service includes the following specific steps: S341: Write comparison experiment code: Execute a talker and multiple listeners using the execution nodes of the simple discovery protocol and the discovery server respectively, and analyze the network traffic during this period; S342: Draw a bar chart of network traffic: Draw a bar chart comparing the network traffic of the two protocols.

2. The method for building a ROS communication system with a distributed architecture according to claim 1, characterized in that, In the above S2, the software design includes the following specific steps: S21: Start the Gazebo simulation: Write a startup file in Python to start the Gazebo simulation platform, load the world file, and deploy the robot respectively; S22: Deploy robots: Deploy multiple robots in the simulation platform.

3. The method for building a ROS communication system with a distributed architecture according to claim 2, characterized in that In the above S22, the deployment of robots includes the following specific steps: S221: Define the robot: Define the namespace for the robot and define the position information of the robot in the world; S222: Publish its own information: After the robot is deployed, it publishes its own information externally; S223: Call the function: Call the function set in publishing its own information; S224: Create a loop: Complete the robot deployment by creating a loop.

4. The method for building a ROS communication system with a distributed architecture according to claim 1, characterized in that In the above S31, the debugging code includes the following specific steps: S311: Build the code: In the root directory of the workspace, run the colcon build command for the build operation; S312: Start the Gazebo simulation platform: After compilation, run the command in the terminal to start and load the simulation platform of the world file; S313: Deploy multiple robot terminals: Set the number of robots to two; S314: Establish the relationships between topics.

5. The method for building a ROS communication system with a distributed architecture according to claim 1, characterized in that In the above S32, testing the Fast-DDS discovery server includes the following specific steps: S321: Set up the discovery server: Start a discovery server with an id of 0 and a port of 11811 and listen on all available interfaces; S322: Start the listening node: Set the location of the discovery server in the environment variable; S323: Start the publishing node: Receive the messages from the publishing node through the set listening node.

6. The method for building a ROS communication system with a distributed architecture according to claim 1, characterized in that, In the above S33, an overview of the advanced usage of Fast-DDS includes the following specific steps: S331: Redundant servers: Through the Fast-DDS command-line tool, create multiple discovery servers, and the ROS node discovery end connects to any number of discovery servers as needed to form a redundant network; S332: Backup servers: Create a server with backup capabilities through the Fast-DDS service protocol.

Images