Autonomous robot coverage control system based on multi-Jetson cooperation

Abstract

The invention belongs to the technical field of robot control and distributed autonomous systems, and particularly relates to an autonomous robot coverage control system based on multi-Jetson collaboration, which is realized based on an ROS2 robot operating system and a multi-Jetson embedded computing platform, and comprises the following steps: multi-sensor data acquisition; carrying out pose fusion and positioning; performing pose processing and neighbor recognition; neighbor detection and event judgment; performing data synchronization and cyclic scheduling; dynamically adjusting the sensing radius; carrying out actuarial calculation and weighted centroid calculation on the Voronoi region; control law calculation and saturation constraint; issuing a target point and executing a path; asynchronous and energy-saving control is realized; wherein the ten stages are independently executed on a local ROS2 node of each Jetson trolley, the whole system operates in an asynchronous distributed mode, and autonomous coverage control can be achieved without a central control node. According to the invention, the problems of complex synchronization, high energy consumption, communication dependence and the like in the existing multi-robot distributed coverage control can be solved.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of robot control and distributed autonomous system, and particularly relates to an autonomous robot coverage control system based on multi-Jetson cooperation. BACKGROUND

[0002] With the development of artificial intelligence, embedded computing platforms and robot operating systems, the research of multi-robot systems (MRS) has attracted extensive attention. Compared with a single robot independently executing a task, a system composed of multiple robots can complete complex tasks such as environmental monitoring, patrol, search and rescue, and area coverage with higher efficiency, stronger robustness and better adaptability. In these systems, multiple robots work cooperatively through perception, communication and local control to jointly complete tasks and solve problems that a single robot cannot independently complete. In fact, multi-robot systems can have different implementations according to task requirements, including centralized and distributed control modes, and can also have both perception and communication functions or rely on only one of them.

[0003] In multi-robot systems, coverage control is a core problem, and the goal is to achieve optimal coverage in the sense of perception or monitoring by reasonably distributing the positions of multiple robots in a given area. In existing research, coverage control is usually based on two main control architectures: centralized control and distributed control.

[0004] Centralized control is a traditional control mode in which all robots rely on a central node or server for decision-making and command. In this mode, each robot transmits the environmental information perceived by itself to the central node, and the central node performs unified calculation and optimization according to the collected global information and issues instructions to each robot for execution. The main advantage of centralized control is that it can fully utilize global information, making the system's decision-making have integrity and consistency, and facilitating the implementation of globally optimal task allocation and path planning. However, this approach also has obvious limitations. As the number of robots increases, the amount of communication data increases rapidly, resulting in increased network load and increased information transmission delay, which affects the real-time performance of the system. In addition, the centralized system relies heavily on the normal operation of the central node, and once the node fails, the coordination and control of the entire system will be unable to proceed, resulting in system paralysis and poor robustness. At the same time, the scalability of the centralized architecture is also insufficient, and as the complexity of the task and the size of the robot increase, the computing pressure of the central node will increase sharply, making it difficult to meet the real-time control requirements of large-scale systems. Therefore, in the case of a large number of robots, fast-changing environments, or tasks requiring high flexibility and high reliability, the centralized control mode is often difficult to adapt.

[0005] In contrast, distributed control does not rely on a single central control node. Instead, each robot makes independent decisions based on its own sensory information, local environmental conditions, and perception or communication information about the states of neighboring robots. The core idea of ​​this control approach is to distribute the decision-making process among each individual robot, enabling the system to achieve overall coordination and optimization even in the absence of global information. Distributed systems do not depend on a single control node; even if some robots malfunction or experience communication interruptions, other robots can continue to perform their tasks, significantly reducing the impact of single-point failures on the overall system operation. Furthermore, distributed control is highly scalable; the system can be flexibly adjusted as the number of robots increases or decreases without requiring major modifications to the overall architecture. Each robot can make decisions through local perception and the acquisition of the states of neighboring robots, reducing communication burden and computational concentration, allowing the system to operate efficiently even in large-scale deployments.

[0006] As the application of multi-robot systems in fields such as inspection, security, emergency response, and environmental monitoring continues to expand, the dynamism and complexity of task scenarios are significantly increasing, placing higher demands on the real-time performance, energy efficiency, and autonomous collaborative capabilities of coverage control systems. While existing distributed coverage algorithms have achieved significant results in theoretical modeling and simulation verification, their engineering implementation on embedded platforms still faces challenges such as multi-source sensing delays, communication imbalances, and insufficient energy consumption optimization.

[0007] To address the aforementioned issues, this invention proposes an autonomous robot coverage control system based on multi-Jetson collaboration. This system leverages the high-performance computing power of the NVIDIA Jetson embedded computing platform and the multi-node communication mechanism of the ROS2 robot operating system to achieve asynchronous distributed coverage control based on local perception. In the system, each Jetson robot divides a local Voronoi region based on its own position and the positions of neighboring robots. The centroid of this region is then calculated, and the movement direction is determined based on the relative relationship between the robot's position and the centroid. This allows for global coverage optimization without centralized control. This method effectively improves the system's adaptability and robustness in dynamic scenarios, reduces communication dependencies, and possesses good scalability, making it suitable for widespread application in large-scale robot swarms. Summary of the Invention

[0008] The purpose of this invention is to provide an autonomous robot coverage control system based on multi-Jetson collaboration, which can solve the problems of complex synchronization, high energy consumption and communication dependence in existing multi-robot distributed coverage control.

[0009] The specific technical solution adopted by this invention is as follows: The autonomous robot coverage control system based on multi-Jetson collaboration is characterized by: implementation based on the ROS2 robot operating system and a multi-Jetson embedded computing platform, including the following ten stages executed sequentially: Phase 1: Multi-sensor data acquisition; Phase 1 includes: acquiring environmental information through multiple sensors such as lidar, depth camera, inertial measurement unit (IMU), and odometer; wherein lidar is used for two-dimensional obstacle and neighbor distance detection, depth camera calculates spatial coordinates through camera intrinsic parameter matrix, inertial measurement unit (IMU) outputs acceleration and angular velocity information, and odometer outputs relative motion increment; Data from each sensor is published in the form of ROS2 topics, providing basic input for subsequent localization and fusion.

[0010] Phase 2: Pose Fusion and Localization; Phase 2 employs the Adaptive Monte Carlo Localization (AMCL) algorithm to fuse data from LiDAR, IMU, and odometry; the algorithm calculates the robot's pose in the global coordinate system based on Bayesian filtering principles and publishes the fusion results via the topic / amcl_pose; the PoseWithCovarianceStamped message output by the fusion contains pose and covariance information, serving as input for subsequent neighbor identification and coverage calculation.

[0011] Phase 3: Pose processing and neighbor identification; Phase 3 performs quaternion-to-Eulerian angle conversion on the pose output by the Adaptive Monte Carlo Localization (AMCL) algorithm and extracts the planar heading angle; The location confidence weights are calculated based on the diagonal elements of the covariance matrix to describe the confidence of neighbor poses. In the ROS2 environment, the system shares pose information via a Wi-Fi local area network. Each Jetson robot publishes the / pose topic and subscribes to the poses of its neighbors to build a neighbor state table.

[0012] Phase 4: Neighbor Detection and Event Determination; Phase 4 utilizes lidar point cloud clustering and depth camera 3D spatial matching to detect nearby targets; When a change in the location of an existing neighbor is detected or a new neighbor enters the sensing range, set the event flag event=true; This event flag is used to trigger the main loop to recalculate and update the coverage area, and the detection process is entirely based on sensor perception and does not rely on wireless communication.

[0013] Phase 5: Data Synchronization and Loop Scheduling; In Phase 5, the monitoring loop runs at a fixed period, and the ROS2 message_filters module is used to perform nearest neighbor matching and interpolation synchronization on multi-source data according to timestamps; This enables the fusion of data from lidar, depth camera, inertial measurement unit (IMU), and odometry at the same time. If no event is triggered within several consecutive monitoring cycles, the node enters a low-power standby mode, retaining only the sensor listening function.

[0014] Phase 6: Dynamic adjustment of the sensing radius; In Phase 6, when the event flag event_i(t) = true or the sensing period expires, the system starts the main loop; The robot calculates a preliminary estimate of the local Voronoi region based on the current perception radius and the neighbor set N_i; If the maximum boundary point distance exceeds the sensing radius, the radius is gradually increased until it includes all neighbors; When communication data is delayed or missing, compensation is made using real-time sensing data from LiDAR and depth cameras to maintain the continuity of topology estimation.

[0015] Phase 7: Voronoi region calculation and weighted centroid calculation; In Phase 7, the system uses the Delaunay triangulation or geometric cutting algorithm to generate a local Voronoi map to achieve non-overlapping division of spatial regions; and calculates the weighted centroid by combining the environmental density function generated by the SLAM mapping module.

[0016] Phase 8: Control Law Calculation and Saturation Constraints; In Phase 8, the robot calculates control commands based on the offset vector of the target's centroid at its current position; The control law adopts a model with saturation constraints to limit the linear velocity and angular velocity from exceeding the set maximum values.

[0017] Phase 9: Target Point Publication and Path Execution; In Phase 9, the control algorithm converts the target point into a target pose (PoseStamped) in the global coordinate system and publishes it to the / goal_pose topic via the ROS2 command-line interface; After receiving this message, the Navigation2 system calls... The global planner and the DWB local planner perform path planning and obstacle avoidance control, enabling the robot to move autonomously to the target centroid position. Phase 10: Asynchronous and Energy-Saving Control; In these 10 phases, each Jetson robot independently runs a monitoring loop and a main loop, which cooperate through event flags without requiring global synchronization; When no event is detected within the set time window and the centroid offset is below the threshold, the robot enters a short-term energy-saving mode to reduce energy consumption. When a change in a neighbor or environment is detected, the main loop is reactivated to implement event-driven asynchronous distributed coverage control.

[0018] The ten stages are executed independently on each Jetson vehicle's local ROS2 node, and the system as a whole operates in an asynchronous distributed manner, achieving autonomous coverage control without the need for a central control node.

[0019] The technical effects achieved by this invention are as follows: This invention utilizes the ROS2 robot operating system and the NVIDIA Jetson embedded computing platform to construct a multi-robot distributed control framework. By introducing an asynchronous control algorithm with a dual-loop structure, it achieves regional coverage optimization and adaptive energy consumption scheduling under conditions without a central node. The system includes a perception module, a localization module, a neighbor identification module, a coverage calculation module, and a motion control module. The perception module uses LiDAR, a depth camera, an inertial measurement unit (IMU), and an odometry to collect environmental information; the localization module uses the AMCL algorithm to fuse multi-source sensor data to obtain the robot's pose in the global coordinate system; the neighbor identification module uses sensor fusion and communication mechanisms to achieve neighbor detection and event determination; the coverage calculation module achieves dynamic coverage through local Voronoi partitioning and weighted centroid calculation; the motion control module generates control commands based on control laws and saturation constraints, and publishes target points through the ROS2 topic mechanism to achieve path planning and navigation execution. This invention, through an event-driven dual-loop asynchronous structure, allows each Jetson robot to operate independently at different times, achieving perception-based distributed coverage control. The system does not require global synchronization and central scheduling, possesses high robustness and scalability, and is suitable for multi-robot autonomous coverage tasks in complex dynamic environments. Attached Figure Description

[0020] Figure 1 This is a block diagram of the overall system structure of the present invention; Figure 2 This is a schematic diagram of the communication and data flow structure of the ROS2 node on the Jetson vehicle.

[0021] Figure 3 The flowchart of the double loop operation logic of the coverage algorithm; Figure 4 The main loop calculation and control execution flowchart; Figure 5 This is a schematic diagram of the overall system operation mechanism. Detailed Implementation

[0022] To make the objectives and advantages of this invention clearer, the invention will be specifically described below with reference to embodiments. It should be understood that the following text is merely used to describe one or more specific embodiments of the invention and does not strictly limit the scope of protection specifically claimed by the invention.

[0023] like Figures 1-5As shown, the present invention provides an autonomous robot coverage control system based on multi-Jetson collaboration. The system execution flow includes the following ten stages performed sequentially: Phase 1: Multi-sensor data acquisition: During this phase, environmental perception data needs to be collected at a fixed frequency using multi-source sensors mounted on each Jetson robot to obtain the environmental features and neighbor status information required for coverage control. The perception module runs on the ROS2 robot operating system and is executed by the Jetson embedded computing module to sample information from multiple sensors, including LiDAR, depth camera, inertial measurement unit (IMU), and odometry.

[0024] The data models for the output of various sensors are explained below: LiDAR (Light Detection and Ranging) uses frequency Output 2D point cloud: in Indicates the first The ranging distance of a laser beam This represents the corresponding scanning angle. Point cloud data can be transformed to obtain planar coordinates: The coordinates mentioned above are used to detect the relative distance distribution of obstacles and neighboring robots, enabling real-time perception of the geometric structure of the surrounding environment.

[0025] Depth camera at frame rate (Approximately 30 Hz) Output depth map Through the camera intrinsic parameter matrix Get the camera coordinates: in, For image coordinates, This represents the depth value of the pixel. This transformation yields the three-dimensional coordinates of objects within the camera's field of view, which can be used to identify nearby targets and obstacle structures within a certain range.

[0026] The inertial measurement unit (IMU) outputs linear acceleration and angular velocity information at a fixed period. This data is used to estimate robot posture changes, providing short-term dynamic motion information, and can be fused with odometry data to improve posture estimation accuracy.

[0027] Odom odometers based on wheel encoders measure time steps. The output relative pose increment can be expressed as: in, For linear velocity, Angular velocity. This data reflects the relative displacement of the vehicle on the ground plane. The relative pose increment output by the odometer is used to provide motion observation input for positioning algorithms (such as AMCL or EKF) to be fused with lidar and inertial measurement unit (IMU) data to achieve more stable pose estimation.

[0028] Data from each sensor is published via the ROS2 Topic mechanism, enabling communication between nodes. Key topics include: / scan: LiDAR point cloud data; / camera / depth / image_raw: Depth image data; / odom: Odometry output pose increment; / imu / data: Measurement values ​​from the inertial measurement unit (IMU).

[0029] At the end of this phase, the raw data collected by various sensors is published in a standardized message format through the ROS2 topic mechanism, and is uniformly subscribed to and fused by local sensing nodes. Time synchronization and coordinate alignment of multi-source data are achieved through ROS2 middleware, resulting in unified environmental perception information that provides input support for subsequent detection and event triggering judgments.

[0030] Phase 2: Pose Fusion and Localization In this stage, the system utilizes the Adaptive Monte Carlo Localization (AMCL) algorithm to fuse multi-source sensor data, achieving precise localization of multiple robots in the global coordinate system. This algorithm, based on Bayesian filtering, achieves adaptive localization estimation by continuously updating the posterior probability distribution of the robot pose. Its mathematical model can be expressed as: in: This represents the robot's pose in the global coordinate system. The motion input is obtained by the inertial measurement unit (IMU) and the odometry (Odom). Environmental observation information acquired by lidar sensors; This is the normalization constant.

[0031] The AMCL algorithm uses a particle filtering mechanism to probabilistically estimate the robot's pose. At each time step, the system samples and predicts the particle set based on the latest motion input, and updates the particle weights using LiDAR observations, ultimately obtaining the optimal pose estimate. It is published under the topic / amcl_pose, with the message type geometry_msgs / PoseWithCovarianceStamped, and the format is as follows: It provides pose input support for subsequent path planning and control decisions.

[0032] Phase 3: Pose Processing and Neighbor Recognition In this stage, the system extracts and transforms the global coordinate pose data obtained in the previous stage, and completes neighbor status identification, providing a unified input for subsequent coverage calculation and control decisions.

[0033] First, the system generates the quaternion of the robot's pose. This indicates conversion to Euler angles form: To extract the heading angle component used in planar motion. Since the coverage control algorithm relies only on the robot's position and heading information on the plane, the robot's two-dimensional pose can be represented as follows at this stage: in, , The first The planar coordinates of a robot in the global coordinate system Its heading angle.

[0034] Secondly, the system evaluates location reliability based on the covariance matrix output by the AMCL algorithm. The diagonal elements of the covariance matrix reflect the location uncertainty in various directions, and the system uses this to define the location reliability weights: in, They represent in , The positional variance in the direction. This weight is used in subsequent Voronoi partitioning and weighted centroid calculation to suppress the interference of neighbors with large positioning errors on topology estimation, thereby improving the stability of the global coverage distribution.

[0035] Subsequently, the system establishes a communication mechanism between multiple robots through ROS2 middleware. All Jetson robots operate within the same ROS2 communication domain, using a Wi-Fi local area network to allow each robot node to publish its own pose information at a fixed frequency while subscribing to the pose data of its neighbors. The ROS2 middleware automatically handles message distribution, timestamp synchronization, and state updates, thereby creating an updated neighbor state table in each robot's local node. At the end of this phase, each Jetson robot maintains a local neighbor state table, which records the 2D poses (position and heading angles) of itself and its neighboring robots, as well as the corresponding position confidence weights. This neighbor state table is updated periodically by the ROS2 middleware and reflects the spatial distribution of the multi-robot system in the global coordinate system, providing input data support for subsequent Voronoi region partitioning and weighted centroid calculation.

[0036] Phase 4: Neighbor Detection and Event Judgment In this phase, the sensing and monitoring nodes simultaneously use lidar and depth cameras to identify targets and verify neighbors in the surrounding environment.

[0037] The two-dimensional point cloud data output by the lidar module is first processed by a Euclidean clustering algorithm, based on a distance threshold. Based on this, the continuous point cloud is divided into several target sets: in, Let be the planar coordinates of any point in the point cloud. For the first Cluster centers.

[0038] Subsequently, the system retrieves the 3D point cloud data output by the depth camera and transforms it to the LiDAR coordinate system using an extrinsic parameter matrix for spatial matching. If depth camera points exist... satisfy The target is then considered a neighbor based on visual verification. This matching process is executed in real time within the ROS2 callback function to ensure time synchronization between the LiDAR and camera observation data.

[0039] After completing neighbor detection, the system determines whether there are any events that need to trigger the main loop based on the neighbor status table and the current sensing results. Event triggering conditions include, but are not limited to, the following two situations: The relative positions or movement states of existing neighbors have changed significantly, i.e. A new neighboring target was detected within the perception range, i.e. When any one of the conditions is met, the system sets the event flag. : Once the ROS2 monitoring node detects that the event flag is true, it immediately triggers the execution of the main loop of the overlay algorithm through an internal callback to perform region re-division and control update.

[0040] At the end of this phase, the system completes a full neighbor state update and event determination process, providing a trigger signal for the start of the main loop and realizing an event-driven distributed control mechanism.

[0041] Phase 5: Data Synchronization and Circular Scheduling In this phase, the system monitoring cycle is performed at a fixed period. It is used to achieve time synchronization and cyclic scheduling management of multi-source sensor data.

[0042] To ensure the consistency of sampling time among different sensors such as LiDAR, depth camera, inertial measurement unit (IMU), and odometry, the system employs the `message_filters` module in the ROS2 framework, using a timestamp alignment mechanism to synchronize sensor messages. This module receives the latest messages from each sensor in real time within a ROS2 callback function and performs multi-source data synchronization based on timestamp information: it selects the closest frames from different sensor data streams using a nearest neighbor matching algorithm; when the time difference exceeds a threshold, it estimates the data value at the target time using linear interpolation, thus forming a time-consistent multi-source fusion dataset. in, For lidar point clouds, For depth images, For inertial measurement unit (IMU) measurement data, This data set is used for odometer information. It is encapsulated as a unified environmental perception input and fed into the processing queue of the monitoring loop to achieve time-series alignment and preparation for fusion of multi-sensor information.

[0043] In terms of loop scheduling, the system uses the ROS2 timer mechanism to control the monitoring loop to trigger execution at a fixed frequency. When the monitoring loop runs, the node first obtains time-aligned multi-source sensor data through a message synchronization mechanism (such as ApproximateTimeSynchronizer), and then executes neighbor detection and event determination logic. If continuous... No event flag was detected within the cycle. When the system enters a low-power standby mode, it retains only sensor listening and minimizes computational processes to reduce energy consumption and communication load. When any sensor detects a new nearby target or environmental disturbance, the system automatically wakes up the main loop, resumes normal monitoring frequency, and re-enters the event-driven control flow.

[0044] At the end of this phase, the system achieved precise time synchronization and cyclic-level energy consumption scheduling of multi-source sensor data, enabling the monitoring cycle to have adaptive power consumption management capabilities while ensuring real-time performance.

[0045] Phase 6: Dynamic adjustment of sensing radius: When any robot node detects the event flag Or the time interval exceeds the preset sensing period. When the time comes, the system automatically starts the overriding control main loop. The main loop runs on the local ROS2 node of each Jetson robot and is triggered by a timer or event callback mechanism.

[0046] After the main loop starts, the robot first determines the current sensing radius. Gather with neighbors Calculate its local Voronoi region estimate.

[0047] Each robot receives a set of pose messages from its neighboring nodes via the ROS2 topic mechanism: And based on its own pose Calculate the initial set of Voronoi boundary points: The system then calculates the maximum distance from a vertex in the current region to its own position: If detected The robot then gradually increases its perception radius, adaptively expanding according to the following rules: Until the convergence condition is met: When communication delays cause incomplete or temporarily missing neighbor data, the system compensates by accessing local sensor data. At this point, the robot constructs a local neighborhood observation set using real-time point cloud data output from LiDAR and depth cameras. Spatial matching and supplementation with the known set of neighbor locations are performed to ensure the integrity and continuity of Voronoi boundary estimation and prevent topological breaks or overlaps caused by information delays.

[0048] At the end of this stage, the system obtains the dynamic Voronoi region division of each robot in the local coordinate system, providing a geometric basis for subsequent weighted centroid calculation and control command generation.

[0049] Phase 7: Voronoi Area Calculation and Weighted Centroid Calculation After determining the adaptive sensing radius, each Jetson robot calculates its precise Voronoi unit based on the fused set of neighbor poses. This calculation is performed by the overlay algorithm nodes and updated once per control iteration cycle.

[0050] First, regarding robots Its Voronoi unit Defined as: in, For the robot's own position, This represents the neighbor set. Based on the spatial relationships between robots, the system generates a local Voronoi diagram using Delaunay triangulation or geometric cutting algorithms, achieving non-overlapping partitioning of spatial regions.

[0051] To achieve weighted coverage of different environmental regions, the system introduces an environmental density function based on Voronoi partitioning. This function originates from the two-dimensional cost map output by the SLAM mapping module. Its value is inversely proportional to the accessibility or importance of a region, and can be defined as: in The cost is the value of the corresponding grid in the cost map.

[0052] Based on this, the robot calculates the weighted Voronoi centroid to obtain the optimal local coverage control target point. The continuous form of the weighted centroid is defined as: In the discretization implementation, the system divides the Voronoi element into a finite number of grid elements, and uses the environmental density value of each grid center point as a weight to approximate the integral operation using a weighted average method, thereby obtaining the weighted centroid coordinates: in These are the coordinates of the center points of each grid within the Voronoi cell.

[0053] This calculation process is periodically executed by the ROS2 coverage control node, combining the current local costmap update result with the neighbor pose information to complete a centroid update. The final weighted centroid is then obtained. This will serve as the target point input for the subsequent control command generation stage, providing a precise basis for the multi-robot system to achieve dynamic coverage based on environmental features.

[0054] Phase 8: Control Law Calculation and Saturation Constraints Obtaining the weighted centroid Afterward, the system enters the control law calculation stage. This stage is executed by the overlay control nodes on each Jetson robot. Their task is to generate motion control commands that conform to mechanical constraints based on the offset relationship between the current position and the target centroid, and publish them to the underlying motion control module through the ROS2 topic.

[0055] First, define the offset vector between the robot's current position and the target's centroid as: in, The coordinates of the robot's current position. The target weighted centroid is calculated from stage 7.

[0056] To ensure smooth motion and safety, the system employs a velocity control law based on saturation constraints. The linear velocity command is defined as: The angular velocity command is calculated based on the difference between the offset direction and the current heading angle: in: This is the proportional gain coefficient; The maximum linear velocity set for the system; function This represents a saturation function, which is applied when the input exceeds... Take the maximum value.

[0057] This control law ensures that the robot moves at maximum speed when the distance between it and the target's center of mass is large, and automatically decelerates when approaching the target position, achieving a smooth speed transition and energy consumption optimization.

[0058] The ROS2 control node encapsulates the generated linear and angular velocities into a message type geometry_msgs / msg / Twist and publishes it to the underlying motion controller via the topic / cmd_vel to drive the Jetson car to perform navigation actions.

[0059] When the following equation is satisfied: The system determines that the robot has converged to a locally optimal coverage position, and the vehicle enters a stable coverage state. In this state, the monitoring loop continues to run, waiting for new events to be triggered or for neighboring states to change before restarting the main loop, thus achieving adaptive closed-loop scheduling of coverage control.

[0060] Phase 9: Target Point Deployment and Path Execution After completing the control law calculation, the overlay algorithm node will control the target point output by the algorithm. Convert the target pose to the global coordinate system. This target pose consists of two parts: position and orientation, which constitute the ROS2 standard message type geometry_msgs / msg / PoseStamped.

[0061] Unlike conventional nodes that directly call the Publisher, the coverage algorithm nodes in this system publish target point information to the topic / goal_pose via the ROS2 command-line interface (CLI) to decouple from the underlying path planning and navigation system. The command format is as follows:

[0062] Here, frame_id:'map' indicates that the target pose is defined in the global map coordinate system; position is the target position coordinate that the robot should reach; orientation indicates the orientation angle of the target point, which usually maintains the default direction in a planar motion scene; all values ​​are generated and updated in real time by the coverage algorithm calculation module.

[0063] After the message is published, the Navigation2 system automatically receives the / goal_pose topic and initiates the path planning process. Internally, it first calls the global planning module ( The algorithm generates a feasible path from the current position to the target point, and then the local planning module (DWB: Dynamic Window Approach) performs dynamic obstacle avoidance and path tracking control.

[0064] The mathematical model of the control law in the Navigation2 system can be described as follows: in, For the current pose, For the target pose, This represents the linear and angular velocity control commands output by the system. This control law is implemented internally by Navigation2 to ensure the stability of path tracking and obstacle avoidance safety.

[0065] It should be noted that the overlay algorithm module of this invention is only responsible for calculating and publishing the target pose, and does not directly participate in path planning and low-level motion control, thus realizing a modular decoupling design between the algorithm layer and the navigation layer. When the Navigation2 system detects that the robot has reached the target point (i.e., After that, the robot automatically stops moving, and the system re-enters the monitoring cycle (stages 1-5), waiting for new events to trigger and executing the next round of coverage calculation.

[0066] Phase 10: Asynchronous and Energy-Saving Control In this phase, each Jetson robot runs its monitoring loop and main loop independently, and the two are coordinated and triggered by event flags, without relying on a global synchronization clock.

[0067] This asynchronous mechanism enables each robot to independently initiate coverage calculations based on changes in the environment or changes in the state of its neighbors, thereby improving the system's response speed and computational efficiency.

[0068] When within the set time window No new events were detected, and the robot meets the convergence criteria: Once the robot meets the convergence criteria, the system switches it to energy-saving mode. In energy-saving mode, the operating frequency and communication volume of non-critical modules are reduced, and only the data acquisition and processing functions related to perception and event determination are maintained to continuously monitor the pose of neighbors and environmental changes. Once a trigger condition is detected, the system immediately exits the energy-saving mode and resumes the main loop execution.

[0069] Once the monitoring loop detects a new neighbor entering, leaving, or a change in environmental barriers, an event flag is triggered. When the overlay is reset, the system automatically wakes up the main loop to perform new overlay recalculation and control updates, thereby realizing a distributed, self-activating, asynchronous overlay mechanism.

[0070] This design effectively reduces redundant energy consumption caused by global synchronous computing, and significantly improves the system's energy efficiency and real-time performance while maintaining coverage performance.

[0071] The above description is merely a preferred embodiment of the present invention. It should be noted that those skilled in the art can make various improvements and modifications without departing from the principles of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention. Structures, devices, and operating methods not specifically described or explained in this invention are implemented according to conventional methods in the art unless otherwise specified or limited.

Claims

1. An autonomous robot coverage control system based on multi-Jetson collaboration, characterized in that: Based on ROS2 robot operating system and multi-Jetson embedded computing platform implementation, including the following ten stages executed in order: Stage 1: Multi-sensor data acquisition; Stage 2: Pose fusion and positioning; Stage 3: Pose processing and neighbor identification; Stage 4: Neighbor detection and event determination; Stage 5: Data synchronization and cyclic scheduling; Stage 6: Perception radius dynamic adjustment; Stage 7: Voronoi region calculation and weighted centroid calculation; Stage 8: Control law calculation and saturation constraint; Stage 9: Target point release and path execution; Stage 10: Asynchronous and energy-saving control; Among them, the ten stages are independently executed on each Jetson car local ROS2 node, and the system as a whole runs in an asynchronous distributed manner, without the need for a central control node to achieve autonomous coverage control.

2. The multi-Jetson-collaboration-based autonomous robot coverage control system of claim 1, wherein: Stage 1 includes: collecting environmental information through multi-source sensors such as lidar, depth camera, inertial measurement unit IMU and odometry; among them, the lidar is used for two-dimensional obstacle and neighbor distance detection, the depth camera calculates the spatial coordinates through the camera intrinsic matrix, the inertial measurement unit IMU outputs acceleration and angular velocity information, and the odometry outputs the relative motion increment; Each sensor data is published in the form of ROS2 topic, providing basic input for subsequent positioning and fusion.

3. The multi-Jetson-collaboration-based autonomous robot coverage control system of claim 1, wherein: Stage 2 uses an adaptive Monte Carlo localization algorithm to fuse lidar, inertial measurement unit IMU and odometry data; the algorithm calculates the pose of the robot in the global coordinate system based on the principle of Bayesian filtering, and publishes the fusion results through the topic / amcl_pose; the PoseWithCovarianceStamped message output by the fusion contains pose and covariance information, which is used as input for subsequent neighbor identification and coverage calculation.

4. The multi-Jetson-collaboration-based autonomous robot coverage control system of claim 1, wherein: Stage 3 converts the pose output by the adaptive Monte Carlo localization algorithm from quaternion to Euler angle, and extracts the plane heading angle; And calculate the position confidence weight according to the diagonal elements of the covariance matrix, which is used to describe the neighbor pose confidence; The system shares the pose information through the Wi-Fi local area network in the ROS2 environment, and each Jetson car publishes / pose topic and subscribes to neighbor poses to establish a neighbor state table.

5. The multi-Jetson-collaboration-based autonomous robot coverage control system of claim 1, wherein: Stage 4 uses lidar point cloud clustering and depth camera three-dimensional space matching to detect nearby targets; When detecting that the position of an existing neighbor has changed or a new neighbor has entered the perception range, set the event flag event=true; This event flag is used to trigger the main loop to perform coverage area recalculation and control update, and the detection process is completely based on sensor perception and does not rely on wireless communication.

6. The multi-Jetson-collaboration-based autonomous robot coverage control system of claim 1, wherein: In stage 5, the monitoring loop runs at a fixed period, and uses the message_filters module of ROS2 to perform nearest neighbor matching and interpolation synchronization on multi-source data according to the timestamp; So that the lidar, depth camera, inertial measurement unit IMU and odometry data are fused at the same time; If the event is not triggered for a continuous number of monitoring periods, the node enters a low-power standby mode, retaining only the sensor listening function.

7. The multi-Jetson-collaboration-based autonomous robot coverage control system of claim 1, wherein: In phase 6, the system starts the main loop when event flag event_i(t)=true or the sensing period expires; The robot calculates the preliminary estimation of local Voronoi region according to the current sensing radius and neighbor set N_i; If the maximum distance of boundary points exceeds the sensing radius, the radius is gradually increased until all neighbors are included; When communication data is delayed or missing, the real-time sensing data from laser radar and depth camera is used for compensation to maintain the continuity of the topology estimation.

8. The multi-Jetson-collaboration-based autonomous robot coverage control system of claim 1, wherein: In phase 7, the system generates the local Voronoi diagram using Delaunay triangulation or geometric cutting algorithm to achieve non-overlapping division of the space region; and calculates the weighted centroid combined with the environment density function generated by the SLAM mapping module.

9. The multi-Jetson-collaboration-based autonomous robot coverage control system of claim 1, wherein: In phase 8, the robot calculates the control command according to the offset vector of the target centroid at the current position; the control law uses a model with saturation constraint to limit the linear and angular velocities within the set maximum values.

10. The multi-Jetson-collaboration-based autonomous robot coverage control system of claim 1, wherein: In the stage 9, the control algorithm converts the target point into a target pose PoseStamped in the global coordinate system, and publishes it to the / goal_pose topic through the ROS2 command line interface; after receiving the message, the Navigation2 system calls The global planner and the DWB local planner perform path planning and obstacle avoidance control to realize autonomous movement of the robot to the target centroid position. In phase 10, each Jetson car runs the monitoring loop and the main loop independently, and they cooperate through event flags without global synchronization; When no event is detected within the set time window and the centroid offset is below the threshold, the robot enters the short-time energy-saving mode to reduce energy consumption; When a neighbor or environmental change is detected, the main loop is reactivated to achieve event-driven asynchronous distributed coverage control.

Images