Multi-task-oriented cleaning robot autonomous operation system

Abstract

The invention relates to the technical field of cleaning robots, in particular to a multi-task-oriented cleaning robot autonomous operation system, which comprises a main circulation module, a sensing module, a decision module and an execution module, and is characterized in that the main circulation module comprises an information acquisition assembly, a decision assembly and an execution assembly; the main circulation module senses the surrounding environment and then makes a decision to perform a cleaning task; the sensing module comprises a laser radar assembly, a camera assembly and an electric quantity receiving and transmitting assembly. The sensing module analyzes the collected chassis movement and RGB-D images based on an InformedRRT algorithm and a target detection algorithm of a hybrid sampling strategy. According to the invention, the main cycle module, the sensing module, the decision module and the execution module are arranged, and according to the sensing-decision-execution logic, how to see (sense) how to make (decide) and how to do (execute) are mainly realized; wherein the main loop module is connected in series with the sensing module, the decision module and the execution module to form a complete autonomous operation system.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of cleaning robots, in particular to a multi-task-oriented autonomous operation system of a cleaning robot. BACKGROUND

[0002] At present, the autonomy of cleaning robots (such as sweeping robots and washing robots) on the market is limited, and they mostly rely on preset programs or simple environmental responses. When facing complex and dynamic cleaning scenes, such as the need to simultaneously handle global cleaning, spot stain cleaning (such as liquid spilling and stubborn dirt), automatic obstacle avoidance, and charging, etc., the existing robots mainly have the following defects: Task scheduling is rigid: unable to dynamically adjust task priority according to environmental information, for example, unable to intelligently interrupt global cleaning to handle unexpected high-priority stains; Perception and execution are disconnected: the information identified by the perception module (such as stain type and location) is difficult to convert into fine and differentiated mechanical execution actions (such as using different force and cleaning modes for liquid and dust); Low path planning efficiency: in dynamic or complex obstacle environments, traditional path planning algorithms converge slowly, affecting cleaning efficiency and real-time obstacle avoidance ability. SUMMARY

[0003] The present application aims to overcome the shortcomings of the prior art and provide a multi-task-oriented autonomous operation system of a cleaning robot to solve the problems of poor autonomy, inflexible task scheduling, and disconnection between perception and execution of cleaning robots in complex scenes.

[0004] To achieve the above-mentioned purpose, the present application adopts the following technical solutions: The multi-task-oriented autonomous operation system of a cleaning robot comprises a main loop module, a perception module, a decision module, and an execution module: The main loop module comprises an information acquisition component, a decision component, and an execution component. The main loop module first perceives the surrounding environment and then makes decisions to perform cleaning tasks; The perception module comprises a laser radar component, a camera component, and a power receiving component. The perception module analyzes the chassis motion and RGB-D images collected based on the Informed RRT algorithm and target detection algorithm; The decision module comprises a finite state machine. The decision module decides the task to be performed next according to the perception information and its own state; The execution module comprises an exploration component, a stain cleaning component, and a charging component. The execution module selects to perform the exploration, cleaning, and charging tasks based on its own state.

[0005] Preferably, the information collection component includes but is not limited to lidar and camera for collection, obstacle detection and map construction, current position localization, stain identification and area state evaluation.

[0006] Preferably, the decision component is based on path planning superior to state judgment and behavior selection.

[0007] Preferably, the path planning includes avoiding obstacles and covering unclean areas, the state judgment includes charging and cleaning priority selection, and the behavior selection includes advancing, turning, cleaning, and returning to charging.

[0008] Preferably, the main loop module further includes a frequency control component that balances real-time performance and computing power in response to dynamic environmental changes.

[0009] Preferably, the Informed RRT algorithm is: First, modify the sampling function of Informed RRT to use hybrid sampling within the elliptical region; Second, after finding the initial path, establish an elliptical region with the initial point start and the target point goal as the foci, and the length of the major axis as the length of the best path. When sampling, perform Gaussian sampling within the ellipse with a probability of 70%, and uniform sampling with a probability of 30%; Then, uniform sampling within the ellipse is achieved by mapping uniform samples to the ellipse through linear transformation; Finally, the implementation of Gaussian sampling within the ellipse is to randomly select a point on the best path, give the compute_sigma function with the center of the point to generate a Gaussian random point, and judge whether the point is within the ellipse to determine whether to resample.

[0010] Preferably, the target detection algorithm is based on the improved target detection model FA-BIS-YOLO11 of yolo11, and the target detection model FA-BIS-YOLO11 includes: FA module, which refers to feature fusion within and between layers in the backbone network to enhance feature representation; BIFPN module, which fuses features of different scales through bidirectional path to enhance the diversity and semantic information of features; SimAM module, which is a parameter-free attention mechanism that enhances feature maps by calculating the importance of each neuron to highlight important features and suppress unimportant features.

[0011] Preferably, the mathematical formula in the FA module is expressed as: assuming that the input feature is X, the three multi-scale features are F1, F2 and F3, the attention weights are W1, W2 and W3 (normalized by Softmax), and the output is: Y=Conv(Concat(W1F1,W2F2,W3 F3)) The mathematical formula in the BIFPN module is expressed as: for each node, the output is: O=∑(Wi Ii) / (∑Wj+ε) wherein Ii is the input feature and Wi is the corresponding weight; The mathematical formula in the SimAM module is expressed as: for the feature X, the energy function is: e=(X-μ)^2 / (σ^2+ε)+(X-μ)^2 wherein μ and σ are the mean and variance of the feature map. Then the attention weight is: A=1 / (1+exp(-e)) The output is: X A.

[0012] Preferably, the finite state machine traverses all detected stains, and performs comprehensive scoring on the stains, and finally selects the stain with a higher score as the priority cleaning target.

[0013] Preferably, the execution module is based on a path planning algorithm and a path execution algorithm, the path planning algorithm is specifically an improved random sampling fast path planning algorithm, the sampling range of which is improved so that an optimal path can be quickly found and generated, and the path becomes smoother through continuous iteration, and the path execution algorithm refers to a model predictive control method based on a neural network, which captures the sequence and dynamic mode switching of the task through a neural network model.

[0014] Compared with the prior art, the present application has the following advantages: 1、The present application introduces a decision module based on a finite state machine and a comprehensive scoring mechanism, realizes adaptive dynamic priority scheduling of global cleaning, stain treatment, automatic charging and other tasks, sets a main loop module, a perception module, a decision module and an execution module, and mainly realizes how to look (perception), how to think (decision) and how to do (execution) according to the perception-decision-execution logic, and comprehensively covers (dusting or water absorption), cleans along the edge (water spraying), cleans stains (water spraying->water absorption->drying), and avoids obstacles in emergency.

[0015] 2、The application realizes the closed loop from perception to fine execution by executing the stain cleaning component in the execution module, directly mapping the stain type and position information recognized by the perception module into different force control parameters, motion modes and tool operations; the autonomous operation of the whole system is realized through the communication between each component and each module, wherein the main cycle module connects the perception module, the decision module and the execution module to form a complete autonomous operating system.

[0016] 3、The application adopts the hybrid sampling strategy Informed RRT algorithm in the perception module, which significantly accelerates the convergence speed of the optimal path in the dynamic complex environment by optimizing the sampling process. BRIEF DESCRIPTION OF DRAWINGS

[0017] Figure 1 The structure diagram of the multi-task-oriented cleaning robot autonomous operating system proposed by the application.

[0018] In the figure: 1, main cycle module; 11, information acquisition component; 12, decision component; 13, execution component; 14, frequency control component; 2, perception module; 21, laser radar component; 22, camera component; 23, power receiving component; 3, decision module; 31, finite state machine; 4, execution module; 41, exploration component; 42, stain cleaning component; 43, charging component. DETAILED DESCRIPTION

[0019] The technical solutions in the embodiments of the application will be clearly and completely described below with reference to the drawings in the embodiments of the application. Obviously, the described embodiments are only part of the embodiments of the application, not all the embodiments.

[0020] Referring to Figure 1 , the multi-task-oriented cleaning robot autonomous operating system comprises a main cycle module 1, a perception module 2, a decision module 3 and an execution module 4. The main cycle module 1 comprises an information acquisition component 11, a decision component 12 and an execution component 13, and the main cycle module 1 first perceives the surrounding environment and then makes a decision to perform a cleaning task; the information acquisition component 11 comprises but is not limited to a laser radar and a camera to perform acquisition, obstacle detection and map construction, current position positioning, stain recognition and region state evaluation.

[0021] The decision component 12 is based on path planning, state judgment and behavior selection. The path planning comprises avoiding obstacles and covering uncleaned areas, the state judgment comprises charging and cleaning priority selection, and the behavior selection comprises advancing, turning, cleaning and returning to charging.

[0022] ​In some embodiments, the cleaning task execution actions include motor control (moving the robot or controlling the robotic arm), cleaning device control (suction, mopping), and state feedback monitoring, etc.

[0023] The main loop module 1 further includes a frequency control component 14, which balances real-time performance and computing power in response to dynamic environmental changes, avoiding excessive computation and unnecessary power consumption.

[0024] The perception module 2 includes a laser radar component 21, a camera component 22, and an electric quantity receiving component 23. The perception module 2 uses the Informed RRT algorithm based on a hybrid sampling strategy to analyze the chassis motion and RGB-D images collected by the target detection algorithm.

[0025] It should be noted that: First, the laser radar obtains data related to the chassis motion, which is used to determine whether there are obstacles or pedestrians when the cleaning robot is moving. If there are obstacles or pedestrians, the chassis control algorithm of the robot will be triggered. The chassis control algorithm will calculate an optimal path according to the obstacle situation to ensure that the robot avoids obstacles when moving and performing cleaning tasks. The Informed RRT algorithm based on a hybrid sampling strategy is used. The elliptical constraint of the Informed RRT algorithm limits the sampling range. Within the sampling range, a hybrid sampling method of Gaussian sampling + uniform sampling is used to accelerate the convergence of the path.

[0026] The Informed RRT algorithm is as follows: First, modify the sampling function of the Informed RRT algorithm to use hybrid sampling within the elliptical region. Second, after finding the initial path, establish an elliptical region with the initial point start and the target point goal as the foci, and the length of the major axis as the length of the best path. When sampling, perform Gaussian sampling within the ellipse with a probability of 70%, and perform uniform sampling with a probability of 30%. Then, the uniform sampling within the ellipse is achieved by mapping the uniform samples to the ellipse through linear transformation. Finally, the implementation of Gaussian sampling within the ellipse is as follows: randomly select a point on the best path, give the compute_sigma function with the center of the point to generate a Gaussian random point, and judge whether the point is within the ellipse to determine whether to resample.

[0027] Further illustrate that in the mixed sampling, the uniform sampling is to ensure the exploration of the elliptical limited area and avoid falling into local optimum; the Gaussian sampling is to sample near the path by using the best path information, which is beneficial to local optimization. The mixed sampling strategy can ensure the asymptotic optimality of the algorithm while accelerating the convergence, especially in complex or crowded environments. Compared with the traditional Informed RRT algorithm, the sampling quality is improved, the iteration number is reduced, and the overall calculation efficiency is improved.

[0028] Through a large number of simulations and real machine tests, the Gaussian sampling probability of 70% and the uniform sampling probability of 30% in the elliptical region are the optimal scheme. This proportion can achieve the best balance between "using known path information for local optimization" and "maintaining global exploration ability to avoid falling into dead angles". As a comparison, when the Gaussian sampling probability is increased to 90%, it is easy to fail to plan in a complex maze environment due to too concentrated local sampling; when it is reduced to 50%, the convergence speed is significantly reduced.

[0029] A preferred implementation of the compute_sigma function is to associate the variance σ with the current best path length L_best and the elliptical area A_ellipse, for example, set σ = k sqrt(A_ellipse) / L_best, where k is an empirical coefficient (such as 0.1). This makes the sampling have a certain divergence when the path is long or the area is large; when the path is gradually optimized and shortened, the sampling is more concentrated, which is beneficial to fine optimization.

[0030] In the same desktop clutter simulation environment (obstacle density 30%), 100 paths from a fixed starting point to the end point are planned. The average iteration number of the traditional Informed RRT algorithm is 1250 times, and the average planning time is 0.45s; after using the mixed sampling strategy of the application, the average iteration number is reduced to 820 times, the average planning time is reduced to 0.28s, and the tortuosity (smoothness index) of the generated path is optimized by an average of 22%.

[0031] Secondly, the information obtained by the camera is divided into an RGB-D image, wherein the image information can be used for the ground garbage picking task, and an algorithm of a target detection part is used in the execution of the task. The algorithm divides a picture into a plurality of grids, and then predicts whether an object exists in each grid. A special structure of convolutional neural network is used to process the grid information, and the highest confidence prediction box, i.e., the position of the object in the image, is screened and output. After obtaining the position of the object in the image, the coordinate position of the target relative to the base of the cleaning robot is obtained through hand-eye matrix calculation. The position information is input into a robot execution manager, and the execution manager calls relevant algorithm modules to control the six-joint robot to execute garbage picking.

[0032] The target detection algorithm is based on an improved target detection model FA-BIS-YOLO11 of yolo11, and the target detection model FA-BIS-YOLO11 comprises an FA module, a BIFPN module and a SimAM module. The FA module refers to the fusion of features within and between layers in the backbone network to enhance feature representation; different field features are fused through multi-scale pooling and adaptive attention weights, and the attention weights are obtained through global average pooling to obtain global information. Preferably, the FA module receives feature maps from three different scales (such as features down-sampled by 8 times, 16 times and 32 times) in the backbone network CSPDarknet. Multi-view information is extracted through parallel multi-scale pooling layers (such as 1x1, 3x3 and 5x5 pooling), and then a lightweight fully connected layer is used to generate attention weights W1, W2 and W3, which are then normalized by Softmax, and finally weighted splicing and 1x1 convolution fusion are performed. In order to facilitate deployment on a robot embedded processor (such as JetsonNano), the FA-BIS-YOLO11 model is subjected to channel pruning and quantization (INT8 precision) processing. After optimization, the model parameter quantity is reduced from about 42M of the original YOLOv11 to 28M, and the average precision (mAP@0.5) on the COCO-val dataset only decreases by 1.2%, but the inference speed is increased by 60%, meeting the real-time requirements of mobile devices.

[0033] The BIFPN module fuses features of different scales through a bidirectional path to enhance the diversity and semantic information of the features; each input feature has a learnable weight during fusion, which is normalized by Softmax and then weighted summed.

[0034] The SimAM module is a parameter-free attention mechanism that enhances feature maps by calculating the importance of each neuron, highlighting important features and suppressing unimportant features. Based on the theory of neuroscience, an energy function is defined for each neuron, and the attention weight is obtained by taking the reciprocal of the energy function (after Sigmoid activation) and multiplying it with the original feature.

[0035] Mathematical expression in the FA module: Let the input feature be X, the three multi-scale features be F1, F2 and F3, and the attention weights be W1, W2 and W3 (normalized by Softmax), then the output is: Y=Conv(Concat(W1F1,W2F2,W3 F3)) Mathematical expression in the BIFPN module: For each node, the output is: O=∑(Wi Ii) / (∑Wj+ε) where Ii is the input feature, Wi is the corresponding weight; Mathematical expression in SimAM module: for feature X, the energy function is: e=(X-μ)^2 / (σ^2+ε)+(X-μ)^2 Where μ and σ are the mean and variance of the feature map. Then the attention weight is: A=1 / (1+exp(-e)) The output is: X A.

[0036] Through the above improved and innovative target detection algorithm, the detection performance of the model is improved, and the parameter amount of the model is effectively reduced; compared with the improved YOLO11, the improved algorithm can effectively identify different garbage objects, has a higher accuracy for small garbage target detection, and is helpful to keep a low consumption of computing resources, facilitating deployment on mobile devices.

[0037] In some embodiments, information obtained from the camera is used not only for the garbage picking task, but also for the segmentation detection of stains according to different scenes. This algorithm module is different from the garbage picking task, and a self-attention mechanism is specially introduced to adaptively adjust the weights of different feature maps, so that the current layer can effectively learn useful information from other layers, thereby further enhancing the extraction ability of key features and making the algorithm more focused on the stain area.

[0038] The specific implementation process of the algorithm is as follows: input image, the encoder part of the algorithm will perform down-sampling to extract features, and the extracted feature details and feature maps will be passed to the decoder. The decoder will perform accurate positioning and shape recovery. The role of the decoder is to accurately draw the shape of the stain. Finally, a feature map with the same size as the input image, i.e. the predicted image, will be output. The predicted image is sent to the trained model for post-processing and optimization, and the final segmentation result can be obtained.

[0039] The decision module 3 includes a finite state machine 31, and the decision module 3 decides the task to be performed next according to the perception information and the state of the robot.

[0040] The finite state machine 31 traverses all detected stains, and scores the stains comprehensively. Finally, the stain with a higher score is selected as the priority cleaning target.

[0041] In some embodiments, four core states are defined: ① Patrol and global cleaning: this is the initial default state of the cleaning robot, and global cleaning is performed by default when no task is set; ② Stain cleaning: when a stain is found during patrol, the state is switched to this state, and the main cleaning task at this time is stain cleaning; ③Returning to charging and charging: When receiving the low power signal, the decision module will pause all tasks and prioritize returning to the charging base. The cleaning robot will connect to the charging base according to the positioning information and supplement the power.

[0042] The core decision logic is as follows: First, exploration and global cleaning state, which is the default state of the robot. In this state, the decision maker makes judgments according to the following priorities: power safety check (highest priority): immediately check if the power is lower than 20%. If so, immediately interrupt the exploration and switch to the RETURNING_TO_DOCK state.

[0043] Stain detection: If there is no power problem, check if there is a stain in the perception result. If so, call the _select_highest_priority_stain method to select a most important stain and switch to the HANDLING_STAIN state.

[0044] Default task: If there is neither a power problem nor a stain, continue to execute the EXPLORE task for global cleaning and exploration.

[0045] Second, the state of handling stains, in which the robot focuses on cleaning a specific stain.

[0046] Power safety check: Similarly, check the power first. Low power will interrupt the cleaning task and immediately return.

[0047] Cleaning effect evaluation: By perceiving again, determine whether the stain currently being handled has been cleaned up. If it is clean, the cleaning target is reset and the robot switches back to the EXPLORING state.

[0048] Continuous handling: If the stain is still there, continue to execute the HANDLE_STAIN task.

[0049] Third, the state of returning to charging and charging, which is a continuous charging cycle.

[0050] Return state: The only goal of the robot is to reach the charging seat. Once it is confirmed to reach, it switches to the CHARGING state.

[0051] Charging state: The robot will continue to charge until the power is higher than 95% (setting higher than 100% can avoid frequent charge-discharge cycles), and then fully charged and revived, switching back to the EXPLORING state.

[0052] ②Stain priority setting This method assesses the priority of stain handling through a set scoring mechanism and determines the cleaning order according to the score. The following is a simple scoring example: Stain type: colored liquid stain, higher priority (10) because it is more likely to leave a mark if it stays for a long time; dust and colorless liquid, lower priority (6).

[0053] Distance: the distance between the robot and the stain, the closer the higher the score.

[0054] The _select_highest_priority_stain method of the finite state machine 31 can use the following comprehensive scoring function: Score = W_type S_type + W_area (Area / Area_max) + W_dist (1 / Distance) + W_fresh (1-(Δt / T_decay)) Where: S_type: type-based score (liquid stain = 10, grease stain = 8, dust = 5).

[0055] Area: the area of the stain in pixels, Area_max is the normalized maximum area.

[0056] Distance: the Euclidean distance between the robot and the stain.

[0057] Δt: the time elapsed since the stain was detected (simulates the "freshness" of the stain, the longer it is, the harder it is to clean).

[0058] W_type, W_area, W_dist, W_fresh: weight coefficients for type, area, distance, and freshness, respectively, which can be set by experience or learning (e.g., [0.5, 0.2, 0.2, 0.1]).

[0059] In some embodiments, a large (0.8 area ratio) liquid stain that just fell (Δt = 0) 2 meters away from the robot may have a score of: 0.5 10 + 0.2 0.8 + 0.2 0.5 + 0.1 1 = 5 + 0.16 + 0.1 + 0.1 = 5.36. And a small (0.2 area ratio) dust stain that has existed for a while (Δt / T_decay = 0.7) 0.5 meters away from the robot may have a score of: 0.5 5 + 0.2 0.2 + 0.2 2 + 0.1 0.3 = 2.5 + 0.04 + 0.4 + 0.03 = 2.97. The system will prioritize liquid stains with higher scores.

[0060] The execution module 4 includes an exploration component 41, a stain cleaning component 42, and a charging component 43. The execution module 4 selects to perform exploration, cleaning, and charging based on its own state.

[0061] The execution module 4 is based on path planning algorithms and path execution algorithms. The execution manager mainly acts as a bridge, responsible for accepting high-level task instructions from the upper layer and decomposing them into executable bottom-level control instructions, coordinating path planning, motion control, and tool operation to complete the final cleaning goal.

[0062] For different types of stains, the stain cleaning component 42 calls differentiated cleaning parameters, as shown in the following example: When the _plan_path method still cannot find a feasible path after a certain number of iterations (such as 1000 times), the following fallback strategy is triggered: Light disturbance: Control the robot to rotate a small random angle (such as ±30°) in place, or move back 20 cm. This is intended to break the planning deadlock caused by sensor errors or local minima.

[0063] Temporary obstacle marking: The area around the goal point that caused the planning failure is temporarily marked as a "temporary obstacle zone" and is avoided as a path point in the next few planning cycles.

[0064] Switch exploration goal: For the exploration task, abandon the current unreachable frontier point and call _get_next_exploration_goal to select a new goal point.

[0065] Report exceptions: If planning fails continuously, report "environmental exception" information through state feedback monitoring and may enter a suspended state waiting for human intervention.

[0066] The flow of each task in the execution part is as follows: ① Execute exploration and cleaning tasks This is the default working mode of the robot, the goal is to cover unknown areas and perform basic cleaning.

[0067] Get goal point: The _get_next_exploration_goal(perception_result['areas']) method intelligently selects a frontier point as the next exploration destination based on the explored area map to ensure efficient coverage.

[0068] Path planning and movement: Call _plan_path and _execute_path to plan a collision-free path and control the robot to move to the target point.

[0069] Start cleaning: During movement, self.cleaning_actuator.start_sweeping() will start the basic cleaning mechanism (such as a roller brush, vacuum cleaner) to achieve cleaning while walking.

[0070] ② Execute the stain treatment task This task is the most core task, which is divided into two clear sub-phases: Phase 1: Positioning movement Objective: Obtain the position information of the stain from the decision maker, plan and execute a path to the vicinity of the stain.

[0071] Execution: Completed through _plan_path and _execute_path.

[0072] Phase 2: Fine operation Perception-driven: According to the type of stain, call different force control parameters and cleaning modes, which is adaptive control based on perception information.

[0073] Liquid stain: Use small force (5.0N) and circle mode to simulate manual "wiping" to avoid liquid splashing.

[0074] Dust stain: Use large force (8.0N) and back-and-forth mode to ensure firm "pressing" and dust suction.

[0075] Execution: self.force_controller.execute_cleaning_motion() controls the robot arm carrying the cleaning tool head to complete the above fine actions.

[0076] This task combines mobile navigation and fine force control operation, and is the main part of "autonomous operation".

[0077] ③ Execute the return to charge task This task is a high-priority navigation task with high reliability and accuracy requirements.

[0078] Obtain position: Obtain the approximate position of the charging base through the scene map established by the chassis, and then determine the accurate position with the aid of the infrared signal intersection on the charging base.

[0079] Accurate movement: Plan a path and execute it, when the robot moves to the approximate position of the charging base, receive the infrared signal from the charging base for accurate movement, and complete the autonomous docking of the charging interface for charging.

[0080] The path planning algorithm is specifically an improved random sampling fast path planning algorithm. The sampling range is improved to enable the algorithm to quickly find and generate an optimal path. The path is made smoother through continuous iteration. When the robot path planning fails, the robot is slightly moved to adjust the position to get rid of the locked state, and then the path planning is reattempted.

[0081] The path execution algorithm refers to a model predictive control method based on a neural network. The sequence and mode switching dynamics of the task are captured through a neural network model. The next state of the robot motion speed and contact force can be predicted through model prediction. An online optimizer continuously plans a continuous control amount during the execution of the robot, so that the robot can move more smoothly and accurately along the planned path.

[0082] It should be noted that the specific model specification of the finite state machine 31 needs to be determined according to the actual specifications of the device. The specific selection calculation method uses existing technologies in the art, and thus is not described in detail.

[0083] To verify the comprehensive performance of the system, comparative tests were conducted in a simulated home environment (60 square meters, containing various furniture, carpets, and hard floor areas).

[0084] Through the above detailed description of the embodiments, preferred solutions, and comparative tests, it is shown that the specific implementation method, technical advantages, and innovation points of the "multi-task-oriented cleaning robot autonomous operation system" are described. The system realizes closed-loop autonomous control from environment perception to fine mechanical action through deep cooperation of the perception, decision-making, and execution modules and internal algorithm innovation, which helps to improve the intelligence, efficiency, and practicality of the cleaning robot in complex scenarios.

[0085] In some embodiments, the overall architecture is set by setting the pseudo code of each algorithm: perception-decision-making-execution.

[0086] 1. Main loop pseudo code This part is the overall controller of the entire system, which is an important part of the specific implementation of the "autonomous operation process".

[0087] / / ===Main system loop=== Class AutonomousCleaningRobot: Method__init__(): self.perception_manager=PerceptionManager() self.decision_maker=DecisionMaker() self.execution_manager=ExecutionManager() self.is_running=True Methodmain_loop(): Whileself.is_running: / / Step 1: Perceiving the World perception_result=self.perception_manager.run_perception_cycle() Step 2: Making decisions based on perception current_task=self.decision_maker.make_decision(perception_result) Step 3: Execute the decision self.execution_manager.execute_task(current_task,perception_result) / / Loop delay, frequency control sleep(0.1) / / 10Hz / / Start the robot robot=AutonomousCleaningRobot() robot.main_loop() 2. Perception part pseudocode: This section is primarily responsible for receiving and processing raw data, providing structured information for the decision-making process.

[0088] / / ===Module 1: Perception Manager=== ClassPerceptionManager: Method__init__(): self.yolo_model=Load_YOLO_Model("yolo_weights.pth") / / Load the object detection model self.unet_model=Load_UNet_Model("unet_weights.pth") / / Load the target segmentation model self.camera=Camera() self.lidar = Lidar() Method run_perception_cycle(): / / 1. Get sensor data rgb_image = self.camera.get_color_image() depth_image = self.camera.get_depth_image() lidar_scan = self.lidar.get_scan() / / 2. Run detection and segmentation algorithms in parallel stain_detections = self._detect_stains(rgb_image) area_segmentation = self._segment_cleaning_areas(rgb_image) / / 3. Fuse results and publish perception_result = { 'stains': stain_detections, 'areas': area_segmentation, 'robot_pose': self._get_robot_pose(lidar_scan), / / SLAM-based localization 'obstacles': self._get_obstacles(lidar_scan) } Return perception_result Method detect_stains(rgb_image): / / YOLO stain detection detections = self.yolo_model.predict(rgb_image) filtered_stains = [] Foreach det in detections: If det.confidence > 0.7 and det.class in ['liquid', 'dust']: / / Filter low confidence and non-stain classes stain_info={ 'bbox': det.bbox, / / bounding box [x, y, w, h] 'class': det.class, / / stain type 'confidence': det.confidence, 'location': self._calculate_stain_location(det.bbox, depth_image) # convert to map coordinates } filtered_stains.append(stain_info) Return filtered_stains Method_segment_cleaning_areas(rgb_image): / / region segmentation segmentation_map = self.unet_model.predict(rgb_image) / / convert pixel-level segmentation to semantic information areas = { 'carpet': extract_region_mask(segmentation_map, 'carpet'), 'hard_floor': extract_region_mask(segmentation_map, 'hard_floor'), 'no_go_zone': extract_region_mask(segmentation_map, 'no_go_zone') } Return areas 3、Decision-making part code This part is the brain of the cleaning robot, responsible for analyzing sensory information to determine which cleaning task to perform and selecting the corresponding cleaning tool.

[0089] / / === Module 2: Decision Maker based on Finite State Machine 31 === Class DecisionMaker: / / Define state enumeration Enum State: EXPLORING, / / Exploring and global cleaning HANDLING_STAIN, / / Handling a stain RETURNING_TO_DOCK, / / Returning to the dock CHARGING / / Charging Method __init__(): self.current_state = State.EXPLORING self.current_stain_target = None / / Current stain being handled self.battery_level = 100.0 Method make_decision(perception_result): / / FSM core: decide next state based on current state and perception input Switch(self.current_state): Case State.EXPLORING: / / Rule 1: Check battery level first If self.battery_level < 20.0: self.current_state = State.RETURNING_TO_DOCK ReturnTask('DOCKING') / / Rule 2: Check if there is a stain to handle stains = perception_result['stains'] If stains is not empty: target_stain = self._select_highest_priority_stain(stains) self.current_stain_target = target_stain self.current_state = State.HANDLING_STAIN ReturnTask('HANDLE_STAIN', target_stain) / / Default rule: Continue exploring / cleaning ReturnTask('EXPLORE') Case State.HANDLE_STAIN: / / Rule 1: Check battery level during handling process as well If self.battery_level < 20.0: self.current_state = State.RETURNING_TO_DOCK ReturnTask('DOCKING') / / Rule 2: Check if stain is cleaned (e.g., by sensing again) If self._is_stain_cleaned(self.current_stain_target): self.current_stain_target = None self.current_state = State.EXPLORING / / Return to exploring state ReturnTask('EXPLORE') / / Rule 3: If stain is still present, continue handling task ReturnTask('HANDLE_STAIN', self.current_stain_target) Case State.RETURNING_TO_DOCK: If self._is_at_docking_station(): self.current_state = State.CHARGING ReturnTask('DOCKING') / / Continue charging task Case State.CHARGING: If self.battery_level > 95.0: self.current_state = State.EXPLORING ReturnTask('EXPLORE') Else: ReturnTask('CHARGING') Method_select_highest_priority_stain(stains): / / Decision logic: Determine handling priority based on stain type, size, and distance highest_priority_stain=None max_priority_score=-1 ForeachStainInstains: score=0 If stain.class=='liquid':score+=10 Else If stain.class=='dust':score+=5 score+=(1 / distance(robot_pose,stain.location)) 2 / / The closer the distance, the higher the score. If score > max_priority_score: max_priority_score=score highest_priority_stain=stain Returnhighest_priority_stain 4. Execute part of the pseudocode This part is responsible for translating decisions into specific actions that the robot will perform.

[0090] / / ===Module 3: Execution Manager=== ClassExecutionManager: Method__init__(): self.path_planner=RRTStarPlanner() self.force_controller=ForcePositionController() self.motor_driver=MotorDriver() self.cleaning_actuator=CleaningActuator() Methodexecute_task(task,perception_result): / / Based on the type of decision task, different underlying executors are invoked. Switch(task.type): Case 'EXPLORE': goal_pose=self._get_next_exploration_goal(perception_result['areas']) Path=self._plan_path(perception_result['robot_pose'],goal_pose,perception_result['obstacles']) self._execute_path(path) self.cleaning_actuator.start_sweeping() / / Start cleaning simultaneously Case 'HANDLE_STAIN': stain_location=task.data['location'] / / Get the stain location from the decision. stain_type=task.data['class'] / / Step 1: Plan the path to the stain and move it path=self._plan_path(perception_result['robot_pose'],stain_location,perception_result['obstacles']) self._execute_path(path) Step 2: Perform fine cleaning operation based on force-position mixing control If stain_type=='liquid': self.force_controller.set_parameters(force=5.0, wiping_pattern='circular') / / Uses less force to mop in circular motions. Else If stain_type=='dust': self.force_controller.set_parameters(force=8.0,wiping_pattern='back_forth') / / Apply strong suction, back and forth. self.force_controller.execute_cleaning_motion() Case 'DOCKING': dock_pose=self._get_dock_pose() path=self._plan_path(perception_result['robot_pose'],dock_pose,perception_result['obstacles']) self._execute_path(path) Method_plan_path(start_pose,goal_pose,obstacles): / / Use improved real-time path planning path = self.path_planner.plan( start=start_pose, goal=goal_pose, obstacles = obstacles max_iterations=1000 ) If path is None: / / Planning failed, triggering a rollback action (such as moving randomly). path = self._get_escape_path() Returnpath Method_execute_path(path): / / Path tracking control For each waypoint in path: While distance(robot_pose,waypoint)>threshold: linear_vel,angular_vel=calculate_control_output(robot_pose,waypoint) self.motor_driver.set_velocity(linear_vel,angular_vel) The following steps can be used to explain the principle and function: Initialization: The robot is powered on, and the main loop module 1 is started. The frequency control component 14 sets the main loop frequency to 10 Hz to balance real-time response and computational power consumption. The information acquisition component 11, the decision component 12, and the execution component 13 are initialized in turn. The laser radar component 21 and the camera component 22 in the perception module 2 start collecting data, and the power receiving component 23 starts monitoring the battery status.

[0091] First perception: The laser radar component 21 scans the environment, and an initial environment map is generated through the simultaneous localization and mapping algorithm, and the robot self-localization is completed. The camera component 22 takes an RGB-D image, and the target detection algorithm unit does not find any garbage to be picked up. The stain segmentation algorithm detects a liquid stain A (coffee stain) about 1.5 m in front, with an area of about 20 cm².

[0092] First decision: The finite state machine 31 in the decision module 3 is in the initial state of “exploration and global cleaning”. It receives the perception results: sufficient power (95%), and there is a high-priority stain (liquid stain A). According to the decision logic, after the power safety check is passed, the stain detection is immediately performed. The finite state machine 31 calls the _select_highest_priority_stain method to score the liquid stain A (type score 10, distance close bonus score 5, total score 15), and determines it as the highest priority task. The state is immediately switched to “stain processing”, and the coordinates and type information of the liquid stain A are packaged as a task instruction.

[0093] First execution: The stain processing component 42 of the execution module 4 receives the “handle liquid stain A” instruction.

[0094] Phase one (moving positioning): The stain processing component 42 calls the _plan_path method. The hybrid sampling InformedRRT Algorithm unit starts working: An elliptical sampling area is established with the robot and the stain position as the focus, and a hybrid strategy of 70% Gaussian sampling and 30% uniform sampling is adopted to plan a smooth path that avoids the chair in the middle within 0.1 s. Subsequently, the _execute_path method is started, and the model predictive controller based on the neural network outputs smooth speed instructions to control the chassis drive motor to move to about 10 cm beside the stain.

[0095] Stage two (fine operation): after the robot is in place, the stain processing component 42 calls the preset "liquid cleaning mode" from the parameter library according to the stain type "liquid". The force position controller 421 sets the contact force to 5.0N and the motion mode to "circling wiping". The cleaning tool head 423 (wet cloth) at the end of the six-joint robot arm 422 is controlled to reciprocally wipe the stain area in a circular trajectory with a diameter of about 15 cm at a constant pressure of 5.0N. At the same time, the micro water suction pump near the cleaning tool head 423 is started to synchronously suck away the dissolved stain liquid.

[0096] It should be noted that after completing 3 wiping cycles, the main loop enters the next period. The perception module 2 again takes a picture of the original area and performs segmentation detection to confirm that the liquid stain A is no longer visible. The finite state machine 31 of the decision module 3 confirms the completion of cleaning through the _is_stain_cleaned method, and then clears the target, and the state is automatically switched back to "exploration and global cleaning". The execution module 4 starts the exploration cleaning component 41 to control the robot to continue to perform the global coverage cleaning task.

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

Claims

1. An autonomous operating system for a multi-task cleaning robot, comprising a main loop module (1), a perception module (2), a decision-making module (3), and an execution module (4), characterized in that: The main loop module (1) includes an information acquisition component (11), a decision-making component (12) and an execution component (13). The main loop module (1) first senses the surrounding environment and then makes a decision to carry out the cleaning task. The sensing module (2) includes a lidar component (21), a camera component (22), and a power receiving component (23). The sensing module (2) is based on the Informed RRT with a hybrid sampling strategy. Algorithms and target detection algorithms are used to analyze the acquired chassis motion and RGB-D images; The decision module (3) includes a finite state machine (31), and the decision module (3) determines the next task to be done based on the perceived information and its own state. The execution module (4) includes an exploration component (41), a stain cleaning component (42), and a charging component (43). The execution module (4) selects to perform three tasks: exploration, cleaning, and charging based on its own state.

2. The autonomous operating system for multi-task cleaning robots according to claim 1, characterized in that, The information acquisition component (11) includes, but is not limited to, lidar and cameras, for data acquisition, obstacle detection and map building, current location positioning, stain identification and area status assessment.

3. The autonomous operating system for multi-task cleaning robots according to claim 2, characterized in that, The decision component (12) is based on the principle that path planning is superior to state judgment and behavior selection.

4. The autonomous operating system for multi-task cleaning robots according to claim 3, characterized in that, The path planning includes avoiding obstacles and covering uncleaned areas; the status judgment includes prioritizing charging and cleaning; and the behavior selection includes moving forward, turning, cleaning, and returning to charging.

5. The autonomous operating system for multi-task cleaning robots according to claim 4, characterized in that, The main loop module (1) also includes a frequency control component (14), which refers to the balance between real-time performance and computing power in response to dynamic environmental changes.

6. The autonomous operating system for multi-task cleaning robots according to claim 5, characterized in that, The Informationd RRT The algorithm is as follows: First, modify Informed RRT The sampling function uses mixed sampling within the elliptical region; Secondly, after finding the initial path, an elliptical region is established with the initial point start and the target point goal as the focus, and the length of the major axis is used as the optimal path length. During sampling, Gaussian sampling is performed within the ellipse with a 70% probability, and uniform sampling is performed with a 30% probability. Then, uniform sampling within the ellipse is achieved by mapping uniform samples to the ellipse through a linear transformation. Finally, the implementation of Gaussian sampling within the ellipse involves randomly selecting a point on the optimal path, using that point as the center, and generating a random Gaussian point using the compute_sigma function. The decision to resample is then made based on whether the point is within the ellipse.

7. The autonomous operating system for multi-task cleaning robots according to claim 6, characterized in that, The target detection algorithm is based on the FA-BIS-YOLO11 target detection model, which is an improvement on YOLO11. The FA-BIS-YOLO11 target detection model includes: The FA module refers to the feature fusion within and between layers of the backbone network to enhance feature representation. The BIFPN module enhances feature diversity and semantic information by fusing features at different scales through bidirectional paths. The SimAM module is a parameter-free attention mechanism that enhances the feature map by calculating the importance of each neuron, highlighting important features and suppressing unimportant features.

8. The autonomous operating system for multi-task cleaning robots according to claim 7, characterized in that: The mathematical formula in the FA module is as follows: Let the input feature be X, the three multi-scale features be F1, F2, and F3, and the attention weights be W1, W2, and W3 (normalized using Softmax). Then the output is: Y=Conv(Concat(W1F1,W2F2,W3 F3)) The mathematical formula in the BIFPN module expresses the following: For each node, the output is: O=∑(Wi Ii) / (∑Wj+ε) where Ii is the input feature and Wi is the corresponding weight; The mathematical formula in the SimAM module expresses the energy function as follows: For feature X, the energy function is: e=(X-μ)^2 / (σ^2+ε)+(X-μ)^2 Where μ and σ are the mean and variance of the feature map. Then the attention weights are: A = 1 / (1 + exp(-e)). The output is: X A.

9. The autonomous operating system for multi-task cleaning robots according to claim 8, characterized in that, The finite state machine (31) traverses all detected stains, scores the stains comprehensively, and finally selects the one with the higher score as the priority cleaning target.

10. The autonomous operating system for multi-task cleaning robots according to claim 9, characterized in that, The execution module (4) is based on a path planning algorithm and a path execution algorithm. The path planning algorithm is specifically based on an improved random sampling fast path planning algorithm. By improving the sampling range, it can quickly find and generate an optimal path, and by iterating continuously, the path becomes smoother. The path execution algorithm refers to the model prediction control method based on neural networks, which captures the sequence of tasks and the dynamics of mode switching through a neural network model.

Images