Intelligent warehousing component high-efficiency handling robot scheduling system

Abstract

This invention provides a high-efficiency component handling robot scheduling system for intelligent warehousing, relating to the field of intelligent warehousing and logistics technology. The method includes: parsing handling task instructions, extracting the task start-point coordinates, end-point coordinates, and path constraints; real-time collection of warehousing environment data, including position offset status data, track boundary data, and dynamic obstacle distance data; constructing a grid map model based on the position offset status data, track boundary data, and dynamic obstacle distance data; and iteratively calculating the global final path node sequence on the magnetic strip trajectory using a slime mold algorithm that integrates an oscillation factor perturbation mechanism and an adaptive weight strategy based on the grid map model. This invention solves the problems of poor path flexibility and insufficient control precision in intelligent warehousing component handling systems.

Description

Technical Field

[0001] This invention relates to the field of intelligent warehousing and logistics technology, and in particular to a scheduling system for efficient handling robots for components in intelligent warehousing. Background Technology

[0002] Currently, the scheduling technology for component handling robots faces several technical challenges:

[0003] For example, at the path planning level, traditional algorithms (such as A* and Dijkstra) are prone to getting stuck in local optima in complex warehouse environments and have a lag in response to dynamic obstacles, resulting in high path redundancy and low execution efficiency. While mainstream intelligent optimization algorithms (such as genetic algorithms and particle swarm optimization algorithms) can achieve global optimization, they are difficult to balance convergence speed and path smoothness under magnetic strip trajectory constraints, and are prone to path conflicts, especially in multi-robot collaborative scenarios.

[0004] In terms of path tracking control, existing technologies mostly adopt a single PID control or a feedforward compensation strategy with a simplified model, which is difficult to cope with nonlinear disturbances such as changes in robot load and fluctuations in ground friction coefficient, resulting in an increase in the cumulative path offset. At the same time, the traditional single-loop control architecture has a response delay when adjusting the heading angle, which cannot meet the stringent requirements of high-precision component handling for trajectory tracking error (usually ≤ ±5mm). Summary of the Invention

[0005] The technical problem to be solved by this invention is to provide a scheduling system for efficient handling robots for components in intelligent warehousing, thereby solving the problems of poor path flexibility and insufficient control precision in the component handling system of intelligent warehousing.

[0006] In order to solve the above technical problems, the technical solutions of the present invention are as follows:

[0007] Firstly, a method for scheduling high-efficiency component handling robots in intelligent warehousing, the method comprising:

[0008] Step 1: Parse the handling task instructions, extract the starting point coordinates, ending point coordinates and path constraints, and collect warehouse environment data in real time. The warehouse environment data includes position offset status data, track boundary data and dynamic obstacle distance data.

[0009] Step 2: Based on position offset status data, track boundary data, and dynamic obstacle distance data, construct a grid map model; based on the grid map model, use a slime mold algorithm that integrates oscillation factor perturbation mechanism and adaptive weight strategy to iteratively calculate the global final path node sequence on the magnetic strip track;

[0010] Step 3: Based on the global final path node sequence, the drive motor speed is dynamically adjusted using feedforward compensation and PID control algorithms. Path tracking is achieved through a dual-loop control architecture. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent path nodes. The inner loop uses a sliding mode controller to generate servo steering commands, enabling the robot's actual heading angle to track the target heading angle in order to obtain the path tracking result.

[0011] Step 4: Perform dynamic correction based on path tracking results and real-time acquired data. When the track boundary data is abnormal, trigger feedforward compensation and PID control algorithms to correct the path deviation. When the distance to the dynamic obstacle is lower than the safety threshold, call the slime mold algorithm to generate a detour path and update the global final path node sequence.

[0012] Step 5: Upload the motor speed, servo motor angle, path offset correction results, and obstacle information to the remote monitoring unit in real time, and execute the process repeatedly until the robot reaches the task endpoint.

[0013] Furthermore, the handling task instructions are parsed, the starting point coordinates, ending point coordinates, and path constraints are extracted, and real-time warehouse environment data is collected. This data includes position offset status data, track boundary data, and dynamic obstacle distance data, including:

[0014] Step 1.1: Receive the transport task instruction, parse and extract the task start coordinates, end coordinates and path constraints;

[0015] Step 1.2: Based on the path constraints, send an environmental data acquisition command to the robot's embedded control unit;

[0016] Step 1.3: According to the acquisition instructions, the robot synchronously acquires warehouse environment data through multi-source sensors, including position offset data detected by the magnetic permeability sensor, track boundary data scanned by the lidar, and dynamic obstacle distance data measured by the ultrasonic sensor.

[0017] Furthermore, based on position offset status data, track boundary data, and dynamic obstacle distance data, a raster map model is constructed, including:

[0018] Step 2.1: Receive real-time collected warehouse environment data, parse the original format of position offset status data, track boundary data and dynamic obstacle distance data, and convert the parsing results into digital signals in a rasterized spatial coordinate system.

[0019] Step 2.2: Based on the track boundary data in the digital signal under the rasterized spatial coordinate system, a static constraint raster layer is generated, defining the effective track area as a passable raster and the boundary area as an impassable raster.

[0020] Step 2.3: Based on the static constraint grid layer, a dynamic obstacle grid layer is superimposed on the dynamic obstacle distance data to mark the area occupied by the obstacle as a temporary impassable grid in real time.

[0021] Step 2.4: Based on the marked temporary impassable grid and static constraint grid layer, the robot's current position is dynamically calibrated by fusing position offset state data to construct a composite grid map model that includes static constraints, dynamic obstacles, and position offset compensation.

[0022] Furthermore, based on the grid map model, a slime mold algorithm that integrates an oscillation factor perturbation mechanism and an adaptive weighting strategy is used to iteratively calculate the global final path node sequence on the magnetic stripe trajectory, including:

[0023] Step 2.5: Use the composite raster map model as the environmental topology input to initialize the location of the slime mold population, where each slime mold individual corresponds to a candidate path node sequence from the task start point to the end point;

[0024] Step 2.6: Based on the candidate path node sequence, calculate the fitness value of each path according to the traversable grid distribution in the composite grid map model. The fitness value is generated by weighting the path length and the obstacle avoidance penalty term.

[0025] Step 2.7: Based on the fitness value, execute the oscillation factor perturbation mechanism. For individuals with fitness values ​​lower than the population average, apply high-frequency oscillation perturbation to expand the search range; for individuals with fitness values ​​higher than the population average, apply low-frequency oscillation perturbation to refine the local search, and generate the perturbation-updated slime mold individual locations.

[0026] Step 2.8: Based on the updated positions of slime mold individuals after perturbation, an adaptive weighting strategy is executed. In the early stage of the overall iteration, a position update dominated by global search weights is adopted; in the later stage of the overall iteration, a position update dominated by local development weights is adopted to generate a slime mold population with optimized weights.

[0027] Step 2.9: Re-input the slime mold population after weight optimization to calculate fitness, and repeat the process until the iteration termination condition is met. Select the slime mold individual with the highest fitness from the final population and decode it into the global optimal path node sequence in the raster coordinate system.

[0028] Furthermore, based on the global final path node sequence, feedforward compensation and PID control algorithms are used to dynamically adjust the drive motor speed. Path tracking is achieved through a dual-loop control architecture. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent path nodes; the inner loop uses a sliding mode controller to generate servo steering commands, enabling the robot's actual heading angle to track the target heading angle, thus obtaining the path tracking results, including:

[0029] Step 3.1: The robot's embedded control unit receives the global final path node sequence and parses the coordinate differences between adjacent path nodes;

[0030] Step 3.2: Based on the coordinate difference, perform feedforward compensation calculation. Calculate the displacement increment based on the difference between the horizontal and vertical coordinates of adjacent nodes. Combine this with the preset moving speed and time step to generate a reference value for the drive motor speed. Detect the position offset between the robot and the magnetic strip trajectory in real time using a magnetic sensor. Input this offset into the PID controller. The PID controller calculates the compensation amounts for the proportional, integral, and derivative terms based on the position offset and its rate of change. These are then superimposed to generate a speed compensation value. Add the speed reference value and the speed compensation value to generate a motor speed control command.

[0031] Step 3.3: Based on the motor speed control command, a dual-loop control architecture is constructed. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent nodes, extracts the lateral and longitudinal coordinate differences between the current node and the next node, and calculates the target heading angle using the arctangent function. The target heading angle is then subtracted from the actual heading angle measured by the gyroscope to generate the heading angle deviation. The heading angle deviation is input into the feedforward-PID composite controller, which outputs the heading angle tracking command.

[0032] Step 3.4: The inner loop processes the heading angle tracking command, designs the sliding surface function of the sliding mode controller with the front wheel deflection angle as the control variable, and constructs the sliding surface with the heading angle deviation and its rate of change; calculates the sliding mode control quantity based on the exponential reaching law, processes the high-frequency component of the heading angle deviation through the sign function, outputs the servo steering angle command, and drives the front wheel steering mechanism.

[0033] Step 3.5: Combine the motor speed control command, servo steering angle command and the current path node coordinates to generate a path tracking result that includes the robot's pose, speed and steering status.

[0034] Furthermore, dynamic corrections are performed based on path tracking results and real-time acquired data. When track boundary data is abnormal, feedforward compensation and PID control algorithms are triggered to correct path deviations. When the distance to dynamic obstacles is below a safety threshold, the slime mold algorithm is invoked to generate a detour path and update the global final path node sequence, including:

[0035] Step 4.1: Receive the path tracking results and synchronously acquire real-time warehouse environment data;

[0036] Step 4.2: Based on the received storage environment data, determine whether the track boundary data is abnormal. If abnormal, trigger the feedforward compensation and PID control algorithm to correct the path offset and generate the first correction command.

[0037] Step 4.3: Based on the received warehouse environment data, detect whether the distance to the dynamic obstacle is lower than the safety threshold. If it is lower than the safety threshold, call the slime mold algorithm to generate a detour path, update the global final path node sequence, and generate a second correction instruction.

[0038] Step 4.4: Based on the first correction instruction or the second correction instruction, merge the path tracking results and the correction instructions, and output the dynamically corrected path control instructions.

[0039] Furthermore, the motor speed, servo motor angle, path offset correction results, and obstacle information are uploaded to the remote monitoring unit in real time and executed cyclically until the robot reaches the task endpoint, including:

[0040] Step 5.1: Receive the dynamically corrected path control command, and parse and extract the motor speed, servo angle, path offset correction results, and obstacle information;

[0041] Step 5.2: Based on the data extracted by parsing, the motor speed, servo angle, path offset correction results and obstacle information are encapsulated into a monitoring data packet and uploaded to the remote monitoring unit in real time.

[0042] Step 5.3: Based on the monitoring data packet, detect the distance between the robot's current position and the coordinates of the task endpoint. If the endpoint has not been reached, return to the execution loop; if the endpoint has been reached, terminate the task flow.

[0043] Secondly, the intelligent warehousing component high-efficiency handling robot scheduling system includes:

[0044] The acquisition module is used to parse the handling task instructions, extract the starting point coordinates, ending point coordinates and path constraints, and collect warehouse environment data in real time. The warehouse environment data includes position offset status data, track boundary data and dynamic obstacle distance data.

[0045] The calculation module constructs a grid map model based on position offset status data, track boundary data, and dynamic obstacle distance data. Based on the grid map model, it uses a slime mold algorithm that integrates an oscillation factor perturbation mechanism and an adaptive weighting strategy to iteratively calculate the global final path node sequence on the magnetic strip track. Based on the global final path node sequence, it dynamically adjusts the drive motor speed using feedforward compensation and PID control algorithms, achieving path tracking through a dual-loop control architecture. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent path nodes; the inner loop uses a sliding mode controller to generate servo steering commands, enabling the robot's actual heading angle to track the target heading angle, thus obtaining the path tracking result. Based on the path tracking result and real-time acquired data, dynamic correction is performed. When track boundary data is abnormal, feedforward compensation and PID control algorithms are triggered to correct the path offset. When the dynamic obstacle distance is below a safety threshold, the slime mold algorithm is invoked to generate a detour path and update the global final path node sequence.

[0046] The processing module is used to upload the motor speed, servo motor angle, path offset correction results, and obstacle information to the remote monitoring unit in real time, and executes the process in a loop until the robot reaches the task endpoint.

[0047] Thirdly, a computing device, comprising:

[0048] one or more processors;

[0049] A storage device for storing one or more programs that, when executed by one or more processors, cause the one or more processors to implement the method.

[0050] Fourthly, a computer-readable storage medium storing a program that, when executed by a processor, implements the method.

[0051] The above-described solution of the present invention has at least the following beneficial effects:

[0052] The path planning is optimized using an oscillation factor perturbation mechanism and an adaptive weight strategy to improve global path optimality and dynamic response speed. A dual-loop architecture combining feedforward compensation and PID control, along with sliding mode control, is used to achieve high-precision path tracking and reduce position deviation and heading angle deviation. Through multi-sensor collaborative acquisition and dynamic correction mechanisms, the system responds to track boundary anomalies and dynamic obstacles in real time, enhancing environmental adaptability and operational safety. At the same time, relying on remote monitoring data upload, the system achieves full-process visualized management. Attached Figure Description

[0053] Figure 1 This is a flowchart illustrating the efficient component handling robot scheduling method in intelligent warehousing provided by an embodiment of the present invention.

[0054] Figure 2 This is a schematic diagram of a high-efficiency component handling robot scheduling system in intelligent warehousing provided by an embodiment of the present invention. Detailed Implementation

[0055] Exemplary embodiments of the present disclosure will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of the disclosure to those skilled in the art.

[0056] like Figure 1 As shown, embodiments of the present invention propose a method for scheduling robots for efficient handling of components in intelligent warehousing, the method comprising the following steps:

[0057] Step 1: Parse the handling task instructions, extract the starting point coordinates, ending point coordinates and path constraints, and collect warehouse environment data in real time. The warehouse environment data includes position offset status data, track boundary data and dynamic obstacle distance data.

[0058] Step 2: Based on position offset status data, track boundary data, and dynamic obstacle distance data, construct a grid map model; based on the grid map model, use a slime mold algorithm that integrates oscillation factor perturbation mechanism and adaptive weight strategy to iteratively calculate the global final path node sequence on the magnetic strip track;

[0059] Step 3: Based on the global final path node sequence, the drive motor speed is dynamically adjusted using feedforward compensation and PID control algorithms. Path tracking is achieved through a dual-loop control architecture. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent path nodes. The inner loop uses a sliding mode controller to generate servo steering commands, enabling the robot's actual heading angle to track the target heading angle in order to obtain the path tracking result.

[0060] Step 4: Perform dynamic correction based on path tracking results and real-time acquired data. When the track boundary data is abnormal, trigger feedforward compensation and PID control algorithms to correct the path deviation. When the distance to the dynamic obstacle is lower than the safety threshold, call the slime mold algorithm to generate a detour path and update the global final path node sequence.

[0061] Step 5: Upload the motor speed, servo motor angle, path offset correction results, and obstacle information to the remote monitoring unit in real time, and execute the process repeatedly until the robot reaches the task endpoint.

[0062] In this embodiment of the invention, multi-dimensional collaborative optimization is used to achieve efficient and accurate component handling task analysis and multi-source environmental data acquisition to provide precise input for scheduling, ensuring a comprehensive perception of task requirements and environmental conditions. A slime mold algorithm integrating oscillation factor perturbation and adaptive weights, combined with a grid map model, is adopted to achieve rapid planning of the globally optimal path in dynamic environments, solving the problems of local optima and response lag in traditional algorithms. A dual-loop control architecture integrating feedforward compensation, PID, and sliding mode control significantly improves path tracking accuracy and reduces position offset and heading angle deviation. A dynamic correction mechanism can respond in real time to track boundary anomalies and dynamic obstacles, enhancing the system's environmental adaptability and operational safety. Remote monitoring data upload enables full-process visual management.

[0063] In a preferred embodiment of the present invention, step 1 above may include:

[0064] Step 1.1: Receive the transport task instruction, parse and extract the task start coordinates, end coordinates and path constraints;

[0065] Step 1.2: Based on the path constraints, send an environmental data acquisition command to the robot's embedded control unit;

[0066] Step 1.3: According to the acquisition instructions, the robot synchronously acquires warehouse environment data through multi-source sensors, including position offset data detected by the magnetic permeability sensor, track boundary data scanned by the lidar, and dynamic obstacle distance data measured by the ultrasonic sensor.

[0067] In this embodiment of the invention, a hierarchical collaborative approach is used to achieve precise docking between tasks and the environment, which has significant advantages: it accurately analyzes the core elements of the task, providing a clear target benchmark for scheduling; it triggers data acquisition based on path constraints, avoiding redundant and invalid information and improving data processing efficiency; and it accurately captures key data on position offset, track boundaries, and dynamic obstacles through multi-source collaborative acquisition of magnetic permeability sensors, lidar, and ultrasonic sensors, thereby achieving comprehensive and multi-dimensional perception of the warehouse environment.

[0068] In this embodiment of the invention, the specific steps include:

[0069] Step 1.1: The system receives handling task instructions (usually in JSON or custom protocol format) from the warehouse management system via industrial Ethernet or wireless communication modules (such as Wi-Fi or LoRa).

[0070] When parsing instructions, extract three core elements:

[0071] Starting point coordinates and ending point coordinates: These are usually represented by the warehouse global coordinate system (such as physical coordinates of the x and y axes, in meters) or grid map index (such as grid row and column numbers) to clearly define the robot's starting position and final target position;

[0072] Path constraints include task-specific requirements, such as: track priority (e.g., priority to use the main track and prohibition of temporary tracks); motion parameter restrictions (e.g., maximum speed ≤ 1.5m / s, minimum turning radius ≥ 0.8m); and avoidance rules (e.g., robot number AGV-003 must give priority to avoiding manual forklifts).

[0073] Step 1.2: Based on the path constraints analyzed in Step 1.1, the system generates targeted environmental data acquisition commands and sends them to the robot's embedded control unit (e.g., an STM32H7-based main controller) via a serial port (e.g., RS485) or CAN bus. It identifies the sensors that need to be activated (e.g., if only traveling along a fixed track, the LiDAR scanning frequency can be reduced; if complex areas are involved, the ultrasonic sensor sampling rate needs to be increased); for example, sampling at 10Hz on ordinary road sections, increasing to 20Hz on complex curves or areas with high pedestrian traffic; only track boundary data within a 5-meter range from the start to the end point is collected to reduce the amount of invalid data.

[0074] Step 1.3: After receiving the acquisition command, the robot's embedded control unit triggers the multi-source sensors to work synchronously (by generating a synchronization pulse through the controller's timer to ensure that the timestamps of the data from each sensor are consistent, with an error ≤10ms). Specific acquisition content includes:

[0075] The magnetic permeability sensor collects position offset status data:

[0076] The magnetic sensor (installed on the bottom of the robot, close to the ground) detects the magnetic field strength distribution of the pre-embedded magnetic strip and outputs the lateral offset (e.g., +5cm means a 5cm deviation to the right, -3cm means a 3cm deviation to the left) and angular offset (e.g., +2° means a 2° deviation to the right in the heading angle) of the robot's central axis relative to the magnetic strip trajectory, reflecting whether the robot is traveling along the correct magnetic strip track.

[0077] LiDAR scanning orbit boundary data:

[0078] The lidar (installed on top of the robot, with a horizontal scanning angle of 120°) emits tens of thousands of laser beams per second. It calculates the three-dimensional coordinates of the two sides of the track (such as metal railings or walls) by reflecting the signals, generates point cloud data, and outputs the effective width of the track (such as 1.2m), boundary coordinates (such as left boundary x=3.5m, right boundary x=4.7m) and curvature of the curve (such as R=5m) after processing, thus defining the static passable area.

[0079] Ultrasonic sensors measure the distance data of dynamic obstacles:

[0080] Ultrasonic sensors (installed on the front, back, left, and right sides of the robot, with a detection angle of 60°) emit ultrasonic waves and receive echoes to calculate the real-time distance (e.g., if there is an obstacle 1.2m in front) and relative speed (calculated by the difference between two consecutive measurements, e.g., if the obstacle is approaching at 0.5m / s) to surrounding dynamic obstacles (such as other AGVs, workers, or mobile shelves) for dynamic obstacle avoidance.

[0081] In a preferred embodiment of the present invention, step 2 above may include:

[0082] Step 2.1: Receive real-time collected warehouse environment data, parse the original format of position offset status data, track boundary data and dynamic obstacle distance data, and convert the parsing results into digital signals in a rasterized spatial coordinate system.

[0083] Step 2.2: Based on the track boundary data in the digital signal under the rasterized spatial coordinate system, a static constraint raster layer is generated, defining the effective track area as a passable raster and the boundary area as an impassable raster.

[0084] Step 2.3: Based on the static constraint grid layer, a dynamic obstacle grid layer is superimposed on the dynamic obstacle distance data to mark the area occupied by the obstacle as a temporary impassable grid in real time.

[0085] Step 2.4: Based on the marked temporary impassable grid and static constraint grid layer, the robot's current position is dynamically calibrated by fusing position offset state data to construct a composite grid map model that includes static constraints, dynamic obstacles, and position offset compensation.

[0086] In this embodiment of the invention, a precise digital mapping of the warehousing environment is achieved through the collaborative design of data standardization conversion, hierarchical grid construction, and dynamic calibration: heterogeneous data from multiple sources of sensors are uniformly converted into digital signals in a grid coordinate system, ensuring data format compatibility and spatial coordinate alignment; the static constraint grid layer clearly defines the track passage boundary, and the dynamic obstacle grid layer marks temporary obstacles in real time. The combination of the two achieves environmental modeling with a static foundation and dynamic updates; the superimposed position offset data calibrates the robot's own position, further improving the matching degree between the map and the actual environment. This composite grid map model completely preserves the static constraint information of the track and reflects the positional deviation between dynamic obstacles and the robot's own position in real time.

[0087] In this embodiment of the invention, the specific steps include:

[0088] Step 2.1, raw data parsing (converting sensor signals into physical quantities). The raw output is a voltage signal (e.g., 0-5 volts), which needs to be converted into position offset (left and right deviation between the robot's central axis and the magnetic strip, in meters) according to the sensor characteristics.

[0089] Example: The center voltage of the sensor is 2.5 volts (corresponding to an offset of 0 meters). For every 1 volt change in voltage, the offset changes by 0.2 meters. If the detected voltage is 2.8 volts, which is 0.3 volts higher than the center, then the offset = 0.3 × 0.2 = 0.06 meters (i.e., a deviation of 6 centimeters to the right).

[0090] The original output is point cloud data (a large number of 3D coordinate points, recording the position of the scanned object, in meters). Points near the ground (such as points with a height of less than 0.1 meters) need to be filtered out. Then, the orbital boundaries are identified by clustering (grouping points that are close together into one class). Finally, the left and right boundary lines of the orbit are fitted with straight lines.

[0091] Example: The points scanned on the left boundary of the track are concentrated around x=2.1 meters and x=2.2 meters, and the left boundary line is fitted to x=2.15 meters; the points on the right boundary are concentrated around x=2.75 meters, and the right boundary line is fitted to x=2.75 meters.

[0092] The original output is the pulse time (the time from when the ultrasonic wave is emitted to when the echo is received, in microseconds), which needs to be converted into obstacle distance (the straight-line distance from the robot to the obstacle, in meters).

[0093] Example: The speed of sound is about 340 meters per second, and the pulse time is 2000 microseconds (i.e., 0.002 seconds). Then the distance = (340 meters per second × 0.002 seconds) ÷ 2 (round trip distance is taken as one way) = 0.34 meters (i.e. the obstacle is 34 centimeters in front).

[0094] Rasterization coordinate transformation (converting physical coordinates into raster numbers):

[0095] Grid size setting: The storage area is divided into square grids with a side length of 10 cm (1 grid = 10 cm × 10 cm), and each grid is uniquely identified by row number and column number (similar to the rows and columns of a table).

[0096] When converting physical coordinates (x meters, y meters) to raster coordinates, the row number is calculated by dividing the physical x-coordinate by 0.1 meters and then rounding down (for example, if x = 2.35 meters, 2.35 ÷ 0.1 = 23.5, and rounding down gives the row number 23); the column number is calculated by dividing the physical y-coordinate by 0.1 meters and then rounding down (for example, if y = 1.78 meters, 1.78 ÷ 0.1 = 17.8, and rounding down gives the column number 17).

[0097] Example: The lidar detected the physical coordinates of the left boundary of the track as x=2.15 meters. The raster row number is 2.15÷0.1=21.5→row number 21; the right boundary is x=2.75 meters→2.75÷0.1=27.5→row number 27.

[0098] Step 2.2, Extraction of the effective track area (determining which grid cells belong to the passable track):

[0099] Track parameters: The track is a strip-shaped area extending in a straight line, with an effective passage area of ​​0.3 meters on each side of the center line (total width 0.6 meters).

[0100] Grid correspondence: Since 1 grid = 10 centimeters and 0.3 meters = 3 grids, the effective area of ​​the track is a strip of 3 grids on each side of the center line.

[0101] Judgment logic: For each grid, calculate its vertical distance to the center line of the track (in units of grid number). If the distance is ≤3 grids, it belongs to the passable area; if it exceeds 3 grids (e.g., 4 grids or more), it belongs to the non-passable area outside the track (e.g., walls, shelf edges).

[0102] Raster attribute tags (labeling a raster as "accessible / inaccessible"):

[0103] Passable grids: Grids within the effective area of ​​the track (such as the three grids to the left and right of the center line) are marked as "0" (meaning the robot can walk on them).

[0104] Static non-accessible grid: Fixed obstacles outside the track (such as walls or shelves), marked as "1" (meaning the robot cannot move through them).

[0105] Example: If the center line of the track is at grid row number 24, then the grids with row numbers 21-27 (24-3=21, 24+3=27) are passable (marked 0); the grids with row numbers ≤20 or ≥28 are outside the track (marked 1).

[0106] Step 2.3, obstacle position transformation (calculating grid coordinates from distance):

[0107] Logic: After the ultrasonic sensor detects the distance to an obstacle, it combines the detection angle (e.g., 30 degrees directly in front) to first calculate the physical coordinates (x meters, y meters) of the obstacle, and then converts them into grid coordinates (row number, column number).

[0108] Example: The robot's current physical position is (3.0 meters, 2.0 meters). It has detected an obstacle 0.34 meters away in a 30-degree direction directly in front of it.

[0109] First, calculate the physical coordinates of the obstacle: extend 0.34 meters outward from the robot's position along a 30-degree direction to obtain the physical coordinates (3.3 meters, 2.2 meters).

[0110] Convert to grid coordinates: x = 3.3 m ÷ 0.1 m = 33 → row number 33; y = 2.2 m ÷ 0.1 m = 22 → column number 22, that is, the obstacle is at grid (33, 22).

[0111] Obstacle perimeter grid markings (inflated to avoid collisions):

[0112] Logic: If an obstacle has an actual size (e.g., an AGV with a diameter of 0.6 meters), the grid around it and its surrounding area must be marked as "temporarily impassable" (only valid when the obstacle exists).

[0113] Grid range: 0.6 meters in diameter = 6 grids (10 centimeters × 6). Therefore, within a radius of 3 grids (0.3 meters) centered on the grid at the center of the obstacle, all grids are marked as "temporarily impassable".

[0114] Example: If the center of the obstacle is in grid (33,22), then grids within a radius of 3 grids such as (32,21), (33,23), and (34,22) are all marked as "4" (representing dynamic obstacles that are temporarily unwalkable).

[0115] Dynamic layer updates:

[0116] Updated every 50 milliseconds (synchronized with the sensor acquisition frequency): If the obstacle moves, the "4" mark at the old location is deleted and the new location is remarked; if the obstacle leaves, all "4" marks are cleared.

[0117] Step 2.4, Composite Raster Map Fusion (Integrating Static, Dynamic, and Location Compensation):

[0118] Layer blending (determining the final passable area), rule: when static and dynamic layers are superimposed, static impassable (marked 1) has the highest priority (even if the dynamic layer is not marked, it is still impassable); the temporary impassable of the dynamic layer (marked 4) covers the passable of the static layer (marked 0) (that is, if the grid that was originally passable is occupied by dynamic obstacles, it is no longer passable).

[0119] Example: In the static layer, grid (33,22) is passable (marked as 0), but in the dynamic layer it is marked as 4 (there is an obstacle). Therefore, in the composite layer, this grid is marked as 4 (cannot be walked).

[0120] In the static layer, grid (30,20) is impassable (marked 1). Even if the dynamic layer is unmarked, the composite layer is still 1 (impassable).

[0121] Position offset compensation (corrects the robot's position on the map):

[0122] Logic: If the magnetic sensor detects that the robot has deviated from the center line of the track (e.g., 0.1 meters to the right), then in the grid map, the robot's current grid coordinates need to be corrected to the right by 1 grid (because 0.1 meters = 1 grid).

[0123] Example: The robot's ideal position is at grid (24,15), but the sensor detects a deviation of 0.1 meters to the right. The actual position should be corrected to (25,15) (1 grid to the right) to ensure that the robot's position on the map matches the actual position.

[0124] The final composite raster map looks like this (example), assuming a certain part of the warehouse area is a 10×10 raster (rows 21-30, columns 11-20):

[0125] Static layer: Rows 21-27 are passable (0), rows 28-30 are statically impassable (1);

[0126] Dynamic layer: The 3 grids surrounding the grid (24,15) are marked as 4 (there is an obstacle);

[0127] Composite layer: In rows 21-27, except for (24,15) where the 3 surrounding grids are 4, the rest are 0 (passable);

[0128] Rows 28-30 are designated as 1 (cannot proceed);

[0129] The robot's actual position, after offset compensation, is (25, 15) (corrected).

[0130] In a preferred embodiment of the present invention, step 2 above may include:

[0131] Step 2.5: Use the composite raster map model as the environmental topology input to initialize the location of the slime mold population, where each slime mold individual corresponds to a candidate path node sequence from the task start point to the end point;

[0132] Step 2.6: Based on the candidate path node sequence, calculate the fitness value of each path according to the traversable grid distribution in the composite grid map model. The fitness value is generated by weighting the path length and the obstacle avoidance penalty term.

[0133] Step 2.7: Based on the fitness value, execute the oscillation factor perturbation mechanism. For individuals with fitness values ​​lower than the population average, apply high-frequency oscillation perturbation to expand the search range; for individuals with fitness values ​​higher than the population average, apply low-frequency oscillation perturbation to refine the local search, and generate the perturbation-updated slime mold individual locations.

[0134] Step 2.8: Based on the updated positions of slime mold individuals after perturbation, an adaptive weighting strategy is executed. In the early stage of the overall iteration, a position update dominated by global search weights is adopted; in the later stage of the overall iteration, a position update dominated by local development weights is adopted to generate a slime mold population with optimized weights.

[0135] Step 2.9: Re-input the slime mold population after weight optimization to calculate fitness, and repeat the process until the iteration termination condition is met. Select the slime mold individual with the highest fitness from the final population and decode it into the global optimal path node sequence in the raster coordinate system.

[0136] In this embodiment of the invention, by improving the population initialization, fitness evaluation, perturbation mechanism, and weight strategy of the slime mold algorithm, the efficiency and optimality of path planning are achieved: a diverse range of candidate paths are initialized using a composite grid map as input to ensure the comprehensiveness of the search starting point; fitness calculation based on path length and obstacle avoidance penalty balances path efficiency and safety constraints; the oscillation factor perturbation mechanism applies perturbations of different frequencies by distinguishing between high and low fitness, allowing inferior paths to expand their search range to escape local optima, while allowing high-quality paths to be refined and optimized to improve quality; the adaptive weight strategy focuses on global search in the early stage of iteration to discover potential optimal solutions, and focuses on local development in the later stage to accelerate convergence, taking into account both global optimality and real-time planning; finally, the optimal path is selected through iterative iteration.

[0137] In this embodiment of the invention, the specific steps include:

[0138] Step 2.5: The constructed composite grid map (including static passable areas, temporarily impassable areas due to dynamic obstacles, and position offset compensation) is used as the environment input for the algorithm. A certain number of slime mold individuals are initialized to form a population. The position of each slime mold individual corresponds to a sequence of candidate path nodes from the task start point to the end point in the grid coordinate system. That is, the coordinate distribution of the individual is directly mapped to the continuous grid nodes in the path (for example, each dimension parameter of the individual corresponds to the horizontal / vertical coordinate of a node in the path). All nodes are connected in sequence to form a complete candidate path.

[0139] Step 2.6: For each slime mold individual's candidate path, calculate the fitness value (a lower value indicates a better path) based on the traversability rules of the composite raster map. The fitness value is composed of two weighted components:

[0140] Path length item This is the total distance between all nodes in the path (such as the sum of the Euclidean distances between adjacent nodes). The shorter the path, the smaller this value is.

[0141] Obstacle avoidance penalty : ,in, It is the total number of nodes in the path that conflict with impassable areas. Penalty weights for static obstacles (e.g.) =5), because static obstacles cannot be moved, the punishment is more severe. For dynamic obstacle penalty weights (e.g.) =3), Static / Dynamic Marking (Static Obstacles) =1, during dynamic obstacles =0), For the first The distance deviation between each conflict node and the obstacle boundary.

[0142] The two terms are weighted and summed using preset weighting coefficients (e.g., path length weight 0.6, penalty term weight 0.4). ,in, The path length weighting coefficient (0 < <1, can be dynamically adjusted according to task requirements, such as when efficiency is prioritized. =0.7, when safety takes priority =0.3), Penalties for avoiding obstacles The path length term is used to obtain the fitness value for each path.

[0143] Step 2.7: Calculate the average fitness value of all individuals in the population, apply differentiated perturbations to paths of different qualities, and balance global exploration with local optimization.

[0144] For individuals with fitness values ​​lower than the population average (poor path quality): apply high-frequency oscillation perturbations by superimposing high-frequency small fluctuations (such as random adjustments within ±3 range of grid coordinates) on the coordinates of their corresponding path nodes to expand the search range and avoid the algorithm getting stuck in local optima (i.e., break out of the limitations of the current poor path and explore more potential feasible paths).

[0145] For individuals with fitness values ​​higher than the population average (good path quality): apply low-frequency oscillation perturbation, superimpose low-frequency small fluctuations (such as fine-tuning within ±1 range of grid coordinates) only on the path node coordinates, refine the path details (such as shortening the node spacing and avoiding nearby obstacles), improve path accuracy, and generate updated slime mold individual positions (i.e., optimized candidate paths) through the above perturbation.

[0146] The oscillation factor is a core mechanism for improving the algorithm's ability to escape local optima and enhance global search capabilities. It simulates the exploration behavior of biological groups by applying periodic perturbations to candidate paths, enabling the algorithm to dynamically balance local search and global exploration.

[0147] Step 2.8: Based on the perturbed and updated positions of slime mold individuals, dynamically adjust the weight ratio of global search and local exploration according to the algorithm iteration stage to optimize the path iteration direction:

[0148] In the early stages of the overall iteration (e.g., the first 30% of iterations): global search weights are used as the main factor. When updating individual positions, the global distribution trend of individuals with better fitness in the population (e.g., shifting towards unexplored traversable areas) is taken into account more. Global coverage of the path is prioritized to avoid missing better paths.

[0149] In the later stages of the overall iteration (e.g., the last 70% of iterations): local development weights are adopted. When updating individual positions, the focus is on local areas of the current better path (e.g., fine-tuning points within passable grids near existing paths). Priority is given to improving the fineness of the path (e.g., shortening the length and reducing the number of turns). Through weight adjustments, a further optimized slime mold population (i.e., a better set of candidate paths) is generated.

[0150] Step 2.9: Re-input the slime mold population with optimized weights into Step 2.6, recalculate the fitness value of each path, and repeat the cycle of fitness calculation → oscillation perturbation → weight optimization until the iteration termination condition is met (such as reaching the preset maximum number of iterations, or the optimal fitness value of the population showing no significant change after N consecutive iterations).

[0151] After the iteration terminates, the slime mold individual with the lowest fitness value (shortest path and no obstacle intrusion) is selected from the final population, and its corresponding node sequence is converted into a set of coordinate points in the grid coordinate system, which is the global final path node sequence (the optimal driving path of the robot from the starting point to the end point).

[0152] In a preferred embodiment of the present invention, step 3 above may include:

[0153] Step 3.1: The robot's embedded control unit receives the global final path node sequence and parses the coordinate differences between adjacent path nodes;

[0154] Step 3.2: Based on the coordinate difference, perform feedforward compensation calculation. Calculate the displacement increment based on the difference between the horizontal and vertical coordinates of adjacent nodes. Combine this with the preset moving speed and time step to generate a reference value for the drive motor speed. Detect the position offset between the robot and the magnetic strip trajectory in real time using a magnetic sensor. Input this offset into the PID controller. The PID controller calculates the compensation amounts for the proportional, integral, and derivative terms based on the position offset and its rate of change. These are then superimposed to generate a speed compensation value. Add the speed reference value and the speed compensation value to generate a motor speed control command.

[0155] Step 3.3: Based on the motor speed control command, a dual-loop control architecture is constructed. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent nodes, extracts the lateral and longitudinal coordinate differences between the current node and the next node, and calculates the target heading angle using the arctangent function. The target heading angle is then subtracted from the actual heading angle measured by the gyroscope to generate the heading angle deviation. The heading angle deviation is input into the feedforward-PID composite controller, which outputs the heading angle tracking command.

[0156] Step 3.4: The inner loop processes the heading angle tracking command, designs the sliding surface function of the sliding mode controller with the front wheel deflection angle as the control variable, and constructs the sliding surface with the heading angle deviation and its rate of change; calculates the sliding mode control quantity based on the exponential reaching law, processes the high-frequency component of the heading angle deviation through the sign function, outputs the servo steering angle command, and drives the front wheel steering mechanism.

[0157] Step 3.5: Combine the motor speed control command, servo steering angle command and the current path node coordinates to generate a path tracking result that includes the robot's pose, speed and steering status.

[0158] In this embodiment of the invention, multi-dimensional path tracking optimization is achieved by integrating motor speed regulation with feedforward compensation and PID control, heading angle tracking with a dual-loop control architecture, and servo steering command generation with sliding mode control. Feedforward compensation pre-plans the speed reference value based on the path coordinate difference, and combines it with real-time compensation for position offset by PID, effectively reducing steady-state error. In the dual-loop control architecture, the outer loop accurately calculates the target heading angle through the coordinate difference and combines it with feedforward-PID to correct the deviation, while the inner loop uses the strong robustness of sliding mode control to disturbances to achieve high-precision tracking of the heading angle, reducing heading angle deviation. The overall integration of motor and servo control commands and pose information enables the robot to move stably and accurately along the planned path in a dynamic warehousing environment.

[0159] In this embodiment of the invention, the specific steps include:

[0160] Step 3.1: The robot's embedded control unit receives the global final path node sequence (i.e., the set of continuous grid coordinate points from the starting point to the ending point), parses the coordinate information of two adjacent path nodes one by one (such as the coordinates of the current node and the coordinates of the next node), and calculates and extracts the difference between the horizontal and vertical coordinates of the two.

[0161] Step 3.2, Displacement increment calculation: The displacement increment of adjacent path nodes is equal to the square root of the sum of the squares of the difference in the horizontal coordinates and the squares of the difference in the vertical coordinates (i.e., the straight-line distance between two points is calculated using the Pythagorean theorem).

[0162] Speed ​​reference value calculation: The speed reference value of the drive motor is equal to the transmission coefficient multiplied by the displacement increment, and then divided by the product of the time step and the wheel radius (used to determine the basic speed that the motor should reach based on the preset speed and path distance).

[0163] PID compensation value calculation:

[0164] The proportional compensation value is equal to the proportional coefficient multiplied by the current position offset (directly responding to real-time offset).

[0165] Integral term compensation value: equal to the integral coefficient multiplied by the cumulative integral of the position offset over time (eliminating long-term offset errors); Derivative term compensation value: equal to the derivative coefficient multiplied by the rate of change of the position offset (suppressing rapid fluctuations in offset and avoiding oscillations); Speed ​​compensation value is the sum of the above proportional, integral, and derivative term compensation values ​​(used to correct speed deviations in actual operation).

[0166] The final speed control command for the drive motor is equal to the sum of the speed reference value and the speed compensation value (taking into account both preset speed and real-time deviation correction).

[0167] Step 3.3, Target heading angle calculation: The real-time target heading angle is equal to the arctangent of the ratio of the longitudinal coordinate difference to the lateral coordinate difference (that is, the direction angle that the robot should face is determined by the ratio of the coordinate differences between the two points).

[0168] Heading angle deviation calculation: Heading angle deviation equals the target heading angle minus the actual heading angle (reflecting the difference between the current heading and the target heading).

[0169] Feedforward-PID composite control output tracking command: The heading angle deviation is input into the feedforward-PID composite controller. The feedforward part presets the turning trend according to the rate of change of the target heading angle, and the PID part (the same proportional, integral, and derivative logic as in step 3.2) corrects the real-time deviation. The two are superimposed to output the heading angle tracking command (i.e., the target turning amplitude) to ensure that the robot's turning direction is consistent with the target.

[0170] Step 3.4, Sliding surface function: ,in, It is the heading angle deviation. It is a weighting coefficient (a positive number used to adjust the fusion ratio of heading angle deviation and deviation change rate, which needs to be preset according to the robot's steering characteristics). It is the differential symbol in calculus. It's time.

[0171] Exponential approach law: The rate of change of the sliding surface is equal to the negative proportional coefficient multiplied by the sliding surface, minus the sign function value of the approach coefficient multiplied by the sliding surface (by controlling the rate of change of the sliding surface, the system is ensured to quickly and stably approach the zero deviation state, where the sign function is used to handle the direction of the deviation).

[0172] Step 3.5: The motor speed control command (speed status), servo steering angle command (steering status) and the coordinates (position information) of the current path node are fused to generate a path tracking result that includes the robot's real-time pose (coordinates, heading angle), movement speed and steering angle.

[0173] In a preferred embodiment of the present invention, step 4 above may include:

[0174] Step 4.1: Receive the path tracking results and synchronously acquire real-time warehouse environment data;

[0175] Step 4.2: Based on the received storage environment data, determine whether the track boundary data is abnormal. If abnormal, trigger the feedforward compensation and PID control algorithm to correct the path offset and generate the first correction command.

[0176] Step 4.3: Based on the received warehouse environment data, detect whether the distance to the dynamic obstacle is lower than the safety threshold. If it is lower than the safety threshold, call the slime mold algorithm to generate a detour path, update the global final path node sequence, and generate a second correction instruction.

[0177] Step 4.4: Based on the first correction instruction or the second correction instruction, merge the path tracking results and the correction instructions, and output the dynamically corrected path control instructions.

[0178] In this embodiment of the invention, a targeted dynamic correction mechanism is constructed by fusing path tracking results with warehouse environment data in real time, which improves the robot's adaptability and safety in complex environments: In the case of abnormal track boundary data, feedforward compensation and PID control are triggered to quickly correct path deviations, which can promptly correct deviations caused by track deformation, sensor errors, etc., and ensure the stability of path tracking; In scenarios where the distance to dynamic obstacles is lower than the safety threshold, the slime mold algorithm is called to generate detour paths and update the node sequence, which can flexibly avoid sudden obstacles and avoid collision risks; Finally, by fusing correction instructions and tracking results to output control instructions, a closed-loop response of anomaly detection-precise correction-instruction update is realized.

[0179] In this embodiment of the invention, the specific steps include:

[0180] Step 4.1: The robot control system receives the path tracking results (including current pose, speed, and turning status) and simultaneously acquires real-time warehouse environment data (track boundary information, dynamic obstacle positions and distances) collected by multi-source sensors (LiDAR, ultrasonic sensors, etc.).

[0181] Step 4.2: Based on real-time environmental data, the system first determines whether there are any anomalies at the track boundaries (such as track deformation, loss of magnetic stripe signal, etc.):

[0182] Anomaly detection logic: Compare the currently collected track boundary data with preset standard values ​​(such as track width threshold, magnetic stripe signal strength threshold). If the deviation exceeds the allowable range, it is determined that the track boundary is abnormal.

[0183] Correction Trigger: Once an anomaly is detected, the feedforward compensation + PID control algorithm in step 3.2 is immediately triggered. PID compensation value calculation:

[0184] The proportional term compensation value is equal to the proportional coefficient multiplied by the current position offset (directly responding to real-time offset); the integral term compensation value is equal to the integral coefficient multiplied by the cumulative integral of the position offset over time (eliminating long-term offset errors); the derivative term compensation value is equal to the derivative coefficient multiplied by the rate of change of the position offset (suppressing rapid fluctuations in offset and avoiding oscillations); the speed compensation value is the sum of the above proportional, integral, and derivative term compensation values ​​(used to correct speed deviations in actual operation). The compensation amount is calculated based on the position offset (such as the distance the robot deviates from the center line of the track), and the first correction command is generated (such as adjusting the speed difference between the left and right wheels to return to the correct trajectory).

[0185] Step 4.3: The system synchronously detects the distance between dynamic obstacles and the robot.

[0186] Safety threshold comparison: The distance to the obstacle is compared with a preset safety threshold (e.g., 0.5 meters). If the actual distance is lower than the threshold, a collision risk is determined.

[0187] Detour path planning: When a collision risk is detected, pause the current path tracking, re-invoke the improved slime mold algorithm in step 2 (integrating oscillation factor perturbation and adaptive weight strategy), take the current position as the starting point and the original end point as the target, combine the real-time obstacle distribution to generate a new detour path, update the global path node sequence, and generate a second correction instruction (including new path nodes and turning instructions).

[0188] Step 4.4: Based on the judgment results of steps 4.2 and 4.3, select the corresponding correction instruction and merge it with the original path tracking result:

[0189] Single anomaly handling: If only a track boundary anomaly is triggered (first correction command), the original path direction remains unchanged, and the offset is corrected only by adjusting the wheel speed; if only obstacle avoidance is triggered (second correction command), the newly generated detour path is switched.

[0190] Combined anomaly handling: If two anomalies are triggered simultaneously, obstacle avoidance (path switching) is handled first, and then the track offset is corrected on the new path;

[0191] Output final control command: Integrate the corrected path nodes, speed, and steering information into a dynamically corrected path control command, and send it to the robot actuators (drive motors and servo motors) to ensure that the robot can still safely and efficiently complete the handling task under abnormal conditions.

[0192] In a preferred embodiment of the present invention, step 5 above may include:

[0193] Step 5.1: Receive the dynamically corrected path control command, and parse and extract the motor speed, servo angle, path offset correction results, and obstacle information;

[0194] Step 5.2: Based on the data extracted by parsing, the motor speed, servo angle, path offset correction results and obstacle information are encapsulated into a monitoring data packet and uploaded to the remote monitoring unit in real time.

[0195] Step 5.3: Based on the monitoring data packet, detect the distance between the robot's current position and the coordinates of the task endpoint. If the endpoint has not been reached, return to the execution loop; if the endpoint has been reached, terminate the task flow.

[0196] In this embodiment of the invention, by extracting and uploading key robot operation data (motor speed, servo motor angle, etc.) to the remote monitoring unit in real time, full-process visual tracking and status control of the handling process are realized, which facilitates timely understanding of robot operation dynamics and environmental anomalies. At the same time, by continuously detecting the distance between the current position and the destination and cyclically executing the process, the continuity and closed-loop nature of the task are ensured, avoiding task delays caused by interruptions, ensuring the traceability and controllability of the handling process, and ensuring efficient task completion through the cyclic mechanism, thereby improving the overall reliability of the intelligent warehouse scheduling system.

[0197] In this embodiment of the invention, the specific steps include:

[0198] Step 5.1: The robot control system receives the dynamically corrected path control command (including real-time corrected motion parameters), parses the command, and extracts four types of key information:

[0199] Real-time rotational speed of the drive motor (reflecting the robot's current moving speed); actual rotation angle of the servo motor (reflecting the front wheel steering angle); correction results for path offset (such as the reduction in offset after this correction, reflecting the correction effect); real-time detected obstacle information (such as obstacle position and distance, reflecting the current environmental risk).

[0200] Step 5.2: Encapsulate the four types of key data in a preset format (such as JSON or a custom protocol) and integrate them into a structured monitoring data packet (including data identifier, timestamp, and specific parameter values) to ensure the integrity and readability of data transmission. Upload the data packet to a remote monitoring unit (such as the monitoring terminal of a warehouse management system) in real time via a wireless communication module (such as Wi-Fi, Bluetooth, or industrial Ethernet). The robot's position, speed, turning status, offset correction effect, and obstacle dynamics can be viewed remotely in real time, realizing full-process visual supervision.

[0201] Step 5.3: Based on the robot's current position coordinates (extracted from the path control instructions) in the uploaded monitoring data packet, compare them with the endpoint coordinates initially parsed for the task, and calculate the straight-line distance between the two:

[0202] If the distance is greater than the preset endpoint determination threshold (e.g., 5 cm, allowing for minor errors), it is determined that the endpoint has not been reached, and the control system returns to the loop process of step 1 (re-analyzing the task progress, collecting environmental data, updating the path planning, executing tracking and correction), and continues to propel the robot toward the endpoint.

[0203] If the distance is less than or equal to the endpoint determination threshold, the endpoint is determined to have been reached. The control system terminates the current task flow, outputs a task completion signal (such as sending a task end command to the monitoring unit), and the robot stops moving and waits for the next task command.

[0204] like Figure 2 As shown, embodiments of the present invention also provide a scheduling system for efficient component handling robots in intelligent warehousing, including:

[0205] The acquisition module is used to parse the handling task instructions, extract the starting point coordinates, ending point coordinates and path constraints, and collect warehouse environment data in real time. The warehouse environment data includes position offset status data, track boundary data and dynamic obstacle distance data.

[0206] The calculation module constructs a grid map model based on position offset status data, track boundary data, and dynamic obstacle distance data. Based on the grid map model, it uses a slime mold algorithm that integrates an oscillation factor perturbation mechanism and an adaptive weighting strategy to iteratively calculate the global final path node sequence on the magnetic strip track. Based on the global final path node sequence, it dynamically adjusts the drive motor speed using feedforward compensation and PID control algorithms, achieving path tracking through a dual-loop control architecture. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent path nodes; the inner loop uses a sliding mode controller to generate servo steering commands, enabling the robot's actual heading angle to track the target heading angle, thus obtaining the path tracking result. Based on the path tracking result and real-time acquired data, dynamic correction is performed. When track boundary data is abnormal, feedforward compensation and PID control algorithms are triggered to correct the path offset. When the dynamic obstacle distance is below a safety threshold, the slime mold algorithm is invoked to generate a detour path and update the global final path node sequence.

[0207] The processing module is used to upload the motor speed, servo motor angle, path offset correction results, and obstacle information to the remote monitoring unit in real time, and executes the process in a loop until the robot reaches the task endpoint.

[0208] The above description represents the preferred embodiments 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.

Claims

1. A method for scheduling robots for efficient handling of components in intelligent warehousing, characterized in that, The method comprises: Step 1: Parse the handling task instructions, extract the starting point coordinates, ending point coordinates and path constraints, and collect warehouse environment data in real time. The warehouse environment data includes position offset status data, track boundary data and dynamic obstacle distance data. Step 2: Based on position offset status data, track boundary data, and dynamic obstacle distance data, construct a grid map model; based on the grid map model, use a slime mold algorithm that integrates oscillation factor perturbation mechanism and adaptive weight strategy to iteratively calculate the global final path node sequence on the magnetic strip track; Step 3: Based on the global final path node sequence, the drive motor speed is dynamically adjusted using feedforward compensation and PID control algorithms. Path tracking is achieved through a dual-loop control architecture. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent path nodes. The inner loop uses a sliding mode controller to generate servo steering commands, enabling the robot's actual heading angle to track the target heading angle in order to obtain the path tracking result. Step 4: Perform dynamic correction based on path tracking results and real-time acquired data. When the track boundary data is abnormal, trigger feedforward compensation and PID control algorithms to correct the path deviation. When the distance to the dynamic obstacle is lower than the safety threshold, call the slime mold algorithm to generate a detour path and update the global final path node sequence. Step 5: Upload the motor speed, servo motor angle, path offset correction results, and obstacle information to the remote monitoring unit in real time, and execute the process repeatedly until the robot reaches the task endpoint.

2. The method for scheduling high-efficiency component handling robots in intelligent warehousing according to claim 1, characterized in that, Parse the handling task instructions, extract the task start coordinates, end coordinates, and path constraints, and collect real-time warehouse environment data, including position offset status data, track boundary data, and dynamic obstacle distance data, including: Step 1.1: Receive the transport task instruction, parse and extract the task start coordinates, end coordinates and path constraints; Step 1.2: Based on the path constraints, send an environmental data acquisition command to the robot's embedded control unit; Step 1.3: According to the acquisition instructions, the robot synchronously acquires warehouse environment data through multi-source sensors, including position offset data detected by the magnetic permeability sensor, track boundary data scanned by the lidar, and dynamic obstacle distance data measured by the ultrasonic sensor.

3. The method for scheduling high-efficiency component handling robots in intelligent warehousing according to claim 2, characterized in that, Based on position offset status data, track boundary data, and dynamic obstacle distance data, a raster map model is constructed, including: Step 2.1: Receive real-time collected warehouse environment data, parse the original format of position offset status data, track boundary data and dynamic obstacle distance data, and convert the parsing results into digital signals in a rasterized spatial coordinate system. Step 2.2: Based on the track boundary data in the digital signal under the rasterized spatial coordinate system, a static constraint raster layer is generated, defining the effective track area as a passable raster and the boundary area as an impassable raster. Step 2.3: Based on the static constraint grid layer, a dynamic obstacle grid layer is superimposed on the dynamic obstacle distance data to mark the area occupied by the obstacle as a temporary impassable grid in real time. Step 2.4: Based on the marked temporary impassable grid and static constraint grid layer, the robot's current position is dynamically calibrated by fusing position offset state data to construct a composite grid map model that includes static constraints, dynamic obstacles, and position offset compensation.

4. The method for scheduling high-efficiency component handling robots in intelligent warehousing according to claim 3, characterized in that, Based on a grid map model, a slime mold algorithm that integrates an oscillation factor perturbation mechanism and an adaptive weighting strategy is used to iteratively calculate the global final path node sequence on the magnetic stripe trajectory, including: Step 2.5: Use the composite raster map model as the environmental topology input to initialize the location of the slime mold population, where each slime mold individual corresponds to a candidate path node sequence from the task start point to the end point; Step 2.6: Based on the candidate path node sequence, calculate the fitness value of each path according to the traversable grid distribution in the composite grid map model. The fitness value is generated by weighting the path length and the obstacle avoidance penalty term. Step 2.7: Based on the fitness value, execute the oscillation factor perturbation mechanism. For individuals with fitness values ​​lower than the population average, apply high-frequency oscillation perturbation to expand the search range; for individuals with fitness values ​​higher than the population average, apply low-frequency oscillation perturbation to refine the local search, and generate the perturbation-updated slime mold individual locations. Step 2.8: Based on the updated positions of slime mold individuals after perturbation, an adaptive weighting strategy is executed. In the early stage of the overall iteration, a position update dominated by global search weights is adopted; in the later stage of the overall iteration, a position update dominated by local development weights is adopted to generate a slime mold population with optimized weights. Step 2.9: Re-input the slime mold population after weight optimization to calculate fitness, and repeat the process until the iteration termination condition is met. Select the slime mold individual with the highest fitness from the final population and decode it into the global optimal path node sequence in the raster coordinate system.

5. The method for scheduling high-efficiency component handling robots in intelligent warehousing according to claim 4, characterized in that, Based on the global final path node sequence, the drive motor speed is dynamically adjusted using feedforward compensation and PID control algorithms. Path tracking is achieved through a dual-loop control architecture, with the outer loop calculating the real-time target heading angle based on the coordinate difference between adjacent path nodes. The inner loop uses a sliding mode controller to generate servo steering commands, enabling the robot's actual heading angle to track the target heading angle, thus obtaining path tracking results, including: Step 3.1: The robot's embedded control unit receives the global final path node sequence and parses the coordinate differences between adjacent path nodes; Step 3.2: Based on the coordinate difference, perform feedforward compensation calculation. Calculate the displacement increment based on the difference between the horizontal and vertical coordinates of adjacent nodes. Combine this with the preset moving speed and time step to generate a reference value for the drive motor speed. Detect the position offset between the robot and the magnetic strip trajectory in real time using a magnetic sensor. Input this offset into the PID controller. The PID controller calculates the compensation amounts for the proportional, integral, and derivative terms based on the position offset and its rate of change. These are then superimposed to generate a speed compensation value. Add the speed reference value and the speed compensation value to generate a motor speed control command. Step 3.3: Based on the motor speed control command, a dual-loop control architecture is constructed. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent nodes, extracts the lateral and longitudinal coordinate differences between the current node and the next node, and calculates the target heading angle using the arctangent function. The target heading angle is then subtracted from the actual heading angle measured by the gyroscope to generate the heading angle deviation. The heading angle deviation is input into the feedforward-PID composite controller, which outputs the heading angle tracking command. Step 3.4: The inner loop processes the heading angle tracking command, designs the sliding surface function of the sliding mode controller with the front wheel deflection angle as the control variable, and constructs the sliding surface with the heading angle deviation and its rate of change; calculates the sliding mode control quantity based on the exponential reaching law, processes the high-frequency component of the heading angle deviation through the sign function, outputs the servo steering angle command, and drives the front wheel steering mechanism. Step 3.5: Combine the motor speed control command, servo steering angle command and the current path node coordinates to generate a path tracking result that includes the robot's pose, speed and steering status.

6. The method for scheduling high-efficiency component handling robots in intelligent warehousing according to claim 5, characterized in that, Dynamic correction is performed based on path tracking results and real-time acquired data. When the track boundary data is abnormal, feedforward compensation and PID control algorithms are triggered to correct the path deviation. When the distance to a dynamic obstacle is below a safe threshold, the slime mold algorithm is invoked to generate a detour path and update the global final path node sequence, including: Step 4.1: Receive the path tracking results and synchronously acquire real-time warehouse environment data; Step 4.2: Based on the received storage environment data, determine whether the track boundary data is abnormal. If abnormal, trigger the feedforward compensation and PID control algorithm to correct the path offset and generate the first correction command. Step 4.3: Based on the received warehouse environment data, detect whether the distance to the dynamic obstacle is lower than the safety threshold. If it is lower than the safety threshold, call the slime mold algorithm to generate a detour path, update the global final path node sequence, and generate a second correction instruction. Step 4.4: Based on the first correction instruction or the second correction instruction, merge the path tracking results and the correction instructions, and output the dynamically corrected path control instructions.

7. The method for scheduling high-efficiency component handling robots in intelligent warehousing according to claim 6, characterized in that, The motor speed, servo motor angle, path offset correction results, and obstacle information are uploaded to the remote monitoring unit in real time and executed cyclically until the robot reaches the task endpoint, including: Step 5.1: Receive the dynamically corrected path control command, and parse and extract the motor speed, servo angle, path offset correction results, and obstacle information; Step 5.2: Based on the data extracted by parsing, the motor speed, servo angle, path offset correction results and obstacle information are encapsulated into a monitoring data packet and uploaded to the remote monitoring unit in real time. Step 5.3: Based on the monitoring data packet, detect the distance between the robot's current position and the coordinates of the task endpoint. If the endpoint has not been reached, return to the execution loop; if the endpoint has been reached, terminate the task flow.

8. A high-efficiency component handling robot scheduling system for intelligent warehousing, wherein the system implements the method as described in any one of claims 1 to 7, characterized in that, include: The acquisition module is used to parse the handling task instructions, extract the starting point coordinates, ending point coordinates and path constraints, and collect warehouse environment data in real time. The warehouse environment data includes position offset status data, track boundary data and dynamic obstacle distance data. The calculation module constructs a grid map model based on position offset status data, track boundary data, and dynamic obstacle distance data. Based on the grid map model, iteratively calculates the global final path node sequence on the magnetic strip track using a slime mold algorithm that integrates an oscillation factor perturbation mechanism and an adaptive weighting strategy. Based on the global final path node sequence, it dynamically adjusts the drive motor speed using feedforward compensation and PID control algorithms, achieving path tracking through a dual-loop control architecture. The outer loop calculates the real-time target heading angle based on the coordinate difference between adjacent path nodes; the inner loop uses a sliding mode controller to generate servo steering commands, enabling the robot's actual heading angle to track the target heading angle, thus obtaining the path tracking result. Dynamic correction is performed based on the path tracking result and real-time acquired data. When track boundary data is abnormal, feedforward compensation and PID control algorithms are triggered to correct the path offset. When the distance to a dynamic obstacle is lower than the safety threshold, the slime mold algorithm is invoked to generate a detour path and update the global final path node sequence. The processing module is used to upload the motor speed, servo motor angle, path offset correction results, and obstacle information to the remote monitoring unit in real time, and executes the process in a loop until the robot reaches the task endpoint.

9. A computing device, characterized in that, include: one or more processors; A storage device for storing one or more programs, which, when executed by one or more processors, cause the one or more processors to implement the method as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a program that, when executed by a processor, implements the method as described in any one of claims 1 to 7.

Images