A same-lane multi-agent warehousing blocking solution method and system

Abstract

The application discloses a same-lane multi-agent warehouse-in solution and system, which comprises the following steps: path planning for multiple RGVs based on a CBS-FOCAL framework, identification of corridor conflicts and generation of a corridor time sequence constraint, marking of an RGV delivering goods to a rack position as a permanent occupancy state, setting of a permanent unavailable state for a neighbor node with a true IsCheckNeighbor attribute and a final point, generation of a conflict-free path, analysis of the path into an event stream and sorting, detection of intrusion, backtracking to a lane outside and iterative convergence according to a lane identifier StackName, construction of an STN directed graph based on the cut path, establishment of a type 2 dependency edge between different RGVs on a shared node, control of path time sequence through topological sorting, and preferential delivery of deep rack position RGVs. Through the cooperation of the three layers of planning, cutting and scheduling, the application realizes 'deep first, shallow later', and efficiently solves the problem of multi-RGV warehouse-in occlusion in the same lane.

Description

Technical Field

[0001] This invention belongs to the field of warehousing and logistics technology, and in particular relates to a solution and system for addressing the obstruction of multiple agents entering the warehouse in the same aisle. Background Technology

[0002] In automated warehousing systems, it is common for multiple RGVs to perform inbound tasks simultaneously. When multiple RGVs need to enter the same racking aisle (with the same StackName) to deliver goods to racking locations at different depths (different StackDepths), a "blocking" problem occurs: the RGV that enters the aisle first and reaches the shallow target location will block the passage path of the RGV that arrives at the deep target location later, preventing the deep RGV from reaching its target.

[0003] Existing multi-agent path planning (MAPF) methods typically employ the CBS (Conflict-Based Search) framework, which replans by adding constraints when a conflict is detected.

[0004] Traditional CBS has the following shortcomings when handling alleyway-type scenarios:

[0005] 1. Rough Corridor Conflict Modeling: Traditional CBS only detects vertex and edge conflicts, without considering the special characteristics of corridor structures, resulting in insufficiently precise constraints. More iterations are needed to resolve conflicts, leading to low planning efficiency.

[0006] 2. Lack of permanent occupancy mechanism: RGVs that deliver goods to the shelf space need to stay for a long time. Traditional methods treat this as temporary occupancy, which cannot accurately constrain the path planning of subsequent RGVs. This may lead to subsequent RGVs planning paths that enter the already occupied area.

[0007] 3. Disconnect between planning and execution: The paths generated at the planning layer may become invalid due to improper subsequent processing, lacking a coordination mechanism for the entire planning-segmentation-deployment chain.

[0008] 4. Lack of depth-first timing guarantee: The physical constraint that deeper shelf locations are delivered first and shallower locations are delivered later cannot be guaranteed, which may lead to RGV waiting for each other or deadlock. Summary of the Invention

[0009] Purpose of the invention: In order to overcome the shortcomings of the existing technology, the present invention provides a solution and system for the problem of multiple agents entering the warehouse in the same lane and blocking. Through a three-layer collaborative mechanism of corridor constraints and permanent occupancy in the planning layer, backtracking and cutting in the post-processing layer, and type 2 dependent edge delivery timing in the scheduling layer, the physical constraint of "deep areas first, shallow areas later" is guaranteed, and the problem of entering the warehouse in the same lane and blocking is efficiently solved.

[0010] Technical Solution: To achieve the above objectives, the present invention provides a solution to the problem of multiple agents blocking entry into a warehouse in the same lane, comprising the following steps:

[0011] Step S1: CBS-FOCAL Planning Layer

[0012] Based on the CBS-FOCAL framework, path planning is performed for multiple RGVs. In the conflict detection, corridor conflicts are identified and corridor timing constraints are generated. At the same time, RGVs that deliver goods to the shelf position are marked as permanently occupied. Within the safe zone, the endpoint of the permanently occupied RGV and the neighbor nodes with the IsCheckNeighbor attribute that are true are set to permanently unavailable, generating a set of conflict-free paths.

[0013] Step S2: StackName backtracks to the cutting layer

[0014] The set of conflict-free paths is post-processed to parse each RGV path into an event stream and sort them according to the arrival time of the target. It is then checked whether a subsequent RGV intrudes into the lane where the RGV that arrived at the target first is located. If so, the path of the subsequent RGV is backtracked and cut to outside the lane according to the lane identifier StackName. This process is iterated until no new cuts are generated.

[0015] Step S3: STN Type 2 Dependency Edge Scheduling Layer

[0016] A simple temporal network (STN) directed graph is constructed based on the set of cut paths. Type 2 dependency edges are established between access events of different RGVs on the same physical node. The type 2 dependency edges indicate that another RGV can only enter after the RGV that leaves first releases the node. The timing of path delivery is controlled by topological sorting, so that RGVs in deep aisle shelving positions are delivered and executed before RGVs in shallow shelving positions.

[0017] Furthermore, the corridor timing constraint mentioned in step S1 generates the earliest time constraint allowing entry into the corridor for RGV-i that has a corridor conflict. The calculation formula is as follows:

[0018] time i = min(bypass_time i , o j + corridor_len i + trans i + turn_cost i );

[0019] Among them, time i The earliest time that RGV-i is allowed to enter the corridor, bypass_time i For the time required for RGV-i to bypass the corridor, o jThe moment when RGV-j completely leaves the corridor, corridor_len i The number of steps required for RGV-i to traverse the corridor, trans i For the transition time of RGV-i, turn_cost i The turning time cost for RGV-i.

[0020] Furthermore, the marking and processing of the permanent occupancy state in step S1 includes:

[0021] When the RGV task type is delivery, and the target node attribute is shelf type, not conveyor belt type, and not elevator type, mark the RGV as permanently occupied.

[0022] The path endpoint of the permanently occupied RGV is repeatedly extended to the maximum planning time. In the safe interval table, the endpoint node and all its neighbor nodes with the IsCheckNeighbor attribute set to true are marked as permanently unavailable for the period from the time the RGV arrives at the target time to the maximum planning time.

[0023] Furthermore, the backtracking cut based on the lane identifier StackName mentioned in step S2 includes:

[0024] All RGV paths are parsed into event streams containing RGV number, current node, current time and next node, and the occupancy history of each physical node and its neighboring nodes with the IsCheckNeighbor property set to true is recorded.

[0025] Filter out the target events where the RGV reaches its destination and arrange them in ascending order of arrival time to form a target event sequence;

[0026] For each target event, check whether there are other RGVs that accessed the target node or its neighbor node whose IsCheckNeighbor property is true after the target event;

[0027] If the target node exists and is of shelf type, then traverse the path of other RGVs forward from the conflict point until a node with a lane identifier StackName different from the target node is found. Cut off all nodes in the path that have the same StackName as the target node, and select the node of the RGV that was last occupied within the cutting range as the cutting point.

[0028] Furthermore, the construction and distribution control of type 2 dependency edges in step S3 includes:

[0029] For each physical node, extract all RGV access events from its occupancy history and sort them by time;

[0030] For event pairs that are temporally adjacent and belong to different RGVs, the next STN node after the first RGV leaves the node is pointed to the STN node after the second RGV arrives at the node, forming a type 2 directed dependency edge.

[0031] When a node’s IsCheckNeighbor property is true, the event that occupies the node synchronously blocks all its neighboring nodes whose IsCheckNeighbor property is true, and records the event in the occupancy history of the corresponding neighboring node whose IsCheckNeighbor property is true.

[0032] When a path is issued, for any path segment, the path segment is issued only if the physical location represented by the predecessor node of all type 2 incoming edges of its corresponding STN node has been left by the corresponding RGV.

[0033] Furthermore, the rules for collision detection in step S1 include:

[0034] If one RGV waits in place while another RGV enters its location, it is considered a WaitIn conflict;

[0035] If one RGV enters while another RGV waits in place and their target locations overlap, it is considered an InWait conflict.

[0036] If two RGVs enter the same node or adjacent nodes at the same time, it is determined to be an InIn conflict;

[0037] If the position where one RGV leaves is the same as the position where another RGV enters, it is determined to be an OutIn conflict;

[0038] If the position where one RGV enters is the same as the position where another RGV leaves, it is determined to be an InOut conflict;

[0039] Furthermore, when both nodes have the IsCheckNeighbor property true and have a connected edge, they are considered adjacent and conflicting even if the two RGVs are not on the same node.

[0040] Furthermore, the conflict detection in step S1 also includes a permanent occupancy exemption rule: when both RGVs are in a permanent occupancy state and are both at their respective target endpoint nodes, the adjacent conflict detection between the two RGVs is skipped, allowing the two RGVs in a permanent occupancy state to stay at different depth rack positions in the same aisle at the same time.

[0041] Furthermore, the construction of the safe interval in step S1 includes:

[0042] Initialize the safe interval of each node to the full time domain;

[0043] Based on the time window constraints generated by the CBS framework, remove the corresponding time period from the safe interval of the corresponding node;

[0044] Based on the position and time of each step in the planned path of other RGVs, remove the corresponding time from the safe interval of the corresponding node and the neighboring nodes whose IsCheckNeighbor attribute is true;

[0045] Remove the endpoint of the RGV that is in a permanent occupancy state and its neighboring nodes whose IsCheckNeighbor attribute is true from the time period from the time of the target arrival to the maximum planning time.

[0046] Perform a SIPP search within the obtained safe zone to generate a conflict-free path.

[0047] Furthermore, the iteration in step S2 until no new cuts are generated is a loop implemented by setting a change flag:

[0048] In each round of traversal of all target events, when any cut occurs, the change flag is set;

[0049] After the current traversal is completed, if the change flag is set, a new traversal is started using the cut path set, until the change flag is not set at the end of the traversal, at which point the iteration terminates.

[0050] A system for resolving occlusion issues during multi-agent entry into a warehouse via the same lane includes:

[0051] The CBS-FOCAL planning module is used to obtain the warehouse topology map and the origin and destination information of each RGV. It identifies corridor conflicts through conflict detection and generates corridor timing constraints. It marks the RGVs that deliver goods to the shelf position as permanently occupied. Within the safe interval, it sets the destination of the permanently occupied RGV and the neighbor nodes with the IsCheckNeighbor attribute that are true as permanently unavailable, and outputs a set of conflict-free paths.

[0052] The StackName backtracking and cutting module is used to parse the set of conflict-free paths into an event stream, sort them by arrival time, detect intrusion conflicts, backtrack and cut the intruding RGV path to outside the intruded lane according to StackName, and output the set of cut paths through iterative convergence.

[0053] The STN scheduling module is used to construct an STN directed graph based on the cut path set, establish type 2 dependency edges between different RGVs on the shared physical node, and control the path delivery sequence through topological sorting so that RGVs in deep aisle rack positions are delivered and executed before RGVs in shallow rack positions.

[0054] Compared with the prior art, the present invention has the following advantages:

[0055] (1) Precise modeling of corridor-level conflicts: By identifying the corridor structure and calculating parameters such as corridor length, detour time, and turning cost, a precise corridor time-series constraint formula is generated, avoiding the multiple iterations caused by the traditional CBS relying solely on node / edge constraints, and greatly improving planning efficiency.

[0056] (2) Permanent occupancy ensures path safety: The PermanentStay mechanism treats the RGV endpoint of the delivery to the shelf as a permanent obstacle, prohibiting subsequent RGVs from entering the area at the safety zone level, thus fundamentally avoiding the planning of paths that penetrate the occupied area.

[0057] (3) Three-layer collaborative closed loop guarantee: the planning layer generates conflict-free paths, the cutting layer eliminates residual conflicts through post-processing, and the scheduling layer guarantees the execution sequence. The three-layer collaboration ensures a complete closed loop from planning to execution, without relying on the correctness of a single level.

[0058] (4) StackName semantic segmentation is efficient and accurate: by using the StackName attribute in the warehouse topology, the segmentation range is precisely limited to the same lane, avoiding excessive segmentation that affects irrelevant areas, while ensuring the safety of the path within the same lane.

[0059] (5) Depth-first timing guarantee: Type 2 dependent edge combined with STN topology sorting ensures that deep RGV arrives first and shallow RGV enters later from the bottom level, eliminating the risk of deadlock and mutual waiting during runtime. Attached Figure Description

[0060] Figure 1 This is a structural diagram illustrating the scene of shielding the entrance to the warehouse in the same alleyway.

[0061] Figure 2 This is a schematic diagram of the overall architecture of the multi-agent entry occupancy occupancy solution of the present invention.

[0062] Figure 3 The reason for path cutting is to display the scene state structure diagram.

[0063] Figure 4 A schematic diagram of the structure for the construction and reduction process of the SIPP safe zone.

[0064] Figure 5 This is a schematic diagram of the framework for the timing calculation process of corridor constraints.

[0065] Figure 6 This is a schematic diagram of the structure of a directed graph of STN.

[0066] Figure 7 This is a structural diagram illustrating the decision-making and execution sequence.

[0067] Figure 8A schematic diagram of the strategy selection for FOCAL.

[0068] Figure 9 This is a schematic diagram of the CBS iterative loop. Detailed Implementation

[0069] The invention will now be further described with reference to the accompanying drawings.

[0070] The purpose of this invention is to provide a solution and system for addressing the problem of multiple agents blocking entry into the warehouse in the same lane. Through a three-layer collaborative mechanism of corridor constraints and permanent occupancy in the planning layer, backtracking and cutting in the post-processing layer, and type 2 dependent edge delivery timing in the scheduling layer, the physical constraint of "deep areas first, shallow areas later" is guaranteed, thus efficiently solving the problem of blocking entry into the warehouse in the same lane.

[0071] like Figure 1 As shown, the problem is that if RGV-102 arrives at B before RGV-101, it will block the path of RGV-101 to A. Similarly, RGV-103 will also block the paths of RGV-101 and RGV-102.

[0072] The present invention adopts the following technical solution:

[0073] like Figure 2 As shown, a solution to the problem of multiple agents blocking entry into a warehouse in the same lane includes the following steps:

[0074] Step S1: CBS-FOCAL Planning Layer

[0075] CBS-FOCAL-based multi-agent path planning (the planner receives input data: warehouse topology map G and the start and end point information and task type of each RGV).

[0076] Based on the CBS-FOCAL framework, path planning is performed for multiple RGVs. In conflict detection, corridor conflicts are identified and corridor timing constraints are generated. RGVs delivering goods to shelf locations are marked as permanently occupied. Within a safe interval, the endpoint of a permanently occupied RGV and its neighboring nodes with a true IsCheckNeighbor attribute are set to permanently unavailable, generating a set of conflict-free paths. In this step, when performing multi-agent path planning, the CBS-FOCAL framework, in addition to detecting regular vertex and edge conflicts, specifically identifies whether the conflicting nodes are located in a corridor-like topology. When a conflicting node is detected to have exactly two successor nodes in the topology graph, and the node and its successors belong to the same lane, it is determined to be a corridor conflict. For corridor conflicts, the planner no longer adds time window constraints to individual nodes within the lane individually, but instead generates a corridor-level entry time constraint, treating the entire lane as a critical resource with length, thereby significantly reducing the number of iterations in the higher-level CBS. Meanwhile, to ensure that the delivery RGV does not become a false passageway after it arrives, this step introduces a permanent occupancy mechanism: based on the task attributes and target node type, the RGV that has stopped at the shelf position is marked as a permanent occupancy, and when constructing the safe interval used for SIPP search, its endpoint and neighbor nodes with the IsCheckNeighbor attribute set to true are all made unavailable for the time period after the arrival time, forming a permanent obstacle and preventing the RGV from planning a path through the occupied storage space later.

[0077] S1-1: Initialization: Independent Path Search

[0078] For each RGV, the planner independently calls the SIPP searcher under unconstrained conditions to generate an initial path. During this stage, there is a high probability of conflicts between the RGV paths, prompting further iterations.

[0079] S1-2: CBS High-Level Iteration: Collision Detection

[0080] The planner selects the CBS node with the lowest cost from the CBS priority queue and performs pairwise conflict detection on the set of paths in it.

[0081] The conflict detection rules in step S1 include: if one RGV waits in place while another RGV enters its location, it is determined to be a WaitIn conflict; if one RGV enters while another RGV waits in place and their target locations overlap, it is determined to be an InWait conflict; if two RGVs simultaneously enter the same node or adjacent nodes, it is determined to be an InIn conflict; if the position where one RGV leaves is the same as the position where another RGV enters, it is determined to be an OutIn conflict; if the position where one RGV enters is the same as the position where another RGV leaves is the same, it is determined to be an InOut conflict; and, when the IsCheckNeighbor attribute of two nodes is true and they have a connected edge, they are considered to be adjacent conflicts even if the two RGVs are not on the same node. In addition to covering regular vertex conflicts, by introducing five spatiotemporal conflict types—WaitIn, InWait, InIn, OutIn, and InOut—the interaction between RGVs waiting in place and other RGVs entering or leaving is fully considered, enabling the planner to capture more potential dangers. In particular, for topologies with physically adjacent relationships, such as storage aisles, an adjacency conflict detection has been added: if two nodes are both marked as IsCheckNeighbor true and there is a connecting edge between them, then even if the two RGVs are in different nodes at the corresponding time, it is still considered a conflict. The principle is that in narrow aisles, the distance between adjacent storage locations is relatively short, and the presence of one RGV will actually block another RGV from passing through a neighboring node. This blocking relationship is actually a conflict; otherwise, the planned path might not be passable. This extension enables the CBS framework to have aisle spatial awareness capabilities, providing a more accurate triggering basis for subsequent corridor conflict aggregation constraints and exemption processing for permanent occupancy.

[0082] The conflict detection in step S1 also includes a permanent occupancy exemption rule: when both RGVs are in a permanent occupancy state and are both at their respective target endpoints, the adjacent conflict detection between the two RGVs is skipped, allowing two permanently occupancy RGVs to simultaneously remain at different depths of shelving locations in the same aisle. Under the permanent occupancy mechanism, two delivery RGVs may be parked at different depths of storage locations in the same aisle. According to the aforementioned conflict detection rule, since their endpoint IsCheckNeighbor attributes are both true and may have connected edges, the system will continuously report adjacent conflicts, causing path planning to fail to converge. However, this "conflict" is actually safe and permissible because both are already parked and no longer moving. Therefore, the permanent occupancy exemption rule adds a judgment before detecting adjacent conflicts: if both RGVs involved in the conflict are marked as permanently occupancy and are both at their respective target endpoints, then the adjacent conflict detection for that pair of RGVs is skipped. This approach maintains the strict constraints of adjacent conflict detection on dynamically moving RGVs while avoiding false alarms for stationary RGVs, allowing multiple RGVs to occupy different depths in parallel within the same lane, thus making full use of the lane space.

[0083] S1-3: Corridor Conflict Identification and Parameter Calculation

[0084] When the number of successors of a conflicting node is 2, the planner determines it to be a corridor conflict and calculates the following parameters:

[0085] ① Conflict point path index: Locate the position of the conflict node in the RGV path.

[0086] ② Corridor entrance index: Backtrack from the point of conflict to find the first node where the RGV enters the corridor.

[0087] ③ Corridor traversal time: corridor_len = complete departure index - entry index.

[0088] ④ Bypass time: Search again on the subgraph after removing the corridor area to obtain the bypass cost bypass_time.

[0089] S1-4: Permanent Occupancy Mechanism

[0090] The planner determines the PermanentStay state based on the task type and target node attributes. The marking and processing of the permanent occupancy state in step S1 includes:

[0091] I. Judgment Rules: When the RGV task type is delivery, and the target node attribute is shelf type (IsStorage=True), not conveyor belt type (IsPort=False), and not elevator type (IsElevator=False), the RGV is marked as a permanent occupancy state, i.e., marked as PermanentStay.

[0092] 2. Handling of PermanentStay RGV: Repeatedly extend the path endpoint of the permanently occupied RGV to the maximum planning time, and in the safety interval table, mark the endpoint node and all its neighbor nodes with the IsCheckNeighbor attribute true as permanently unavailable for the period from the time the RGV arrives at the target time to the maximum planning time.

[0093] The permanent occupancy mechanism addresses the safety hazards caused by treating the endpoint as a temporary occupant in traditional path planning. Once a delivery task is completed, the RGV will remain at the target shelf location for an extended period, even permanently, and the space it occupies should not be traversed by other RGVs. To this end, the planner first determines the permanent occupancy status based on the task type (delivery) and the attribute combination of the target node (IsStorage is true, IsPort is false, IsElevator is false), distinguishing these RGVs from those that only pass through temporarily. Then, to reflect this long-term occupancy in the path search space of other RGVs, the path of the RGV is extended, and its endpoint time is repeatedly filled up to the maximum planning time SIPP_MAX_TIME, becoming a fixed obstacle traversing the remaining time domain. When generating the safety interval table, not only are all time intervals after the arrival time of the endpoint node removed, but the time intervals corresponding to neighboring nodes with the IsCheckNeighbor attribute being true are also removed. A true IsCheckNeighbor indicates that these nodes are located at different depths within the same lane and have a physical blocking relationship, therefore they also need to be marked as unavailable, thus forming a complete lane cross-section blockage. This ensures that the RGV cannot plan a path through occupied shelf spaces and its neighbors in the same aisle during subsequent SIPP searches, thus avoiding the risk of the path colliding with obstacles.

[0094] S1-5: Constraint Splitting Strategy

[0095] The planner selects the corresponding constraint splitting strategy based on the conflict type and corridor identifier:

[0096]

[0097] like Figure 5 As shown, the corridor timing constraint mentioned in step S1 generates the earliest time constraint allowing entry into the corridor for RGV-i that has a corridor conflict. The calculation formula is as follows:

[0098] time i = min(bypass_time i , o j + corridor_len i + trans i + turn_cost i ).

[0099] Among them, time i The earliest time that RGV-i is allowed to enter the corridor, bypass_time i For the time required for RGV-i to bypass the corridor, o j The moment when RGV-j completely leaves the corridor, corridor_len i The number of steps required for RGV-i to traverse the corridor, trans i For the transition time of RGV-i, turn_cost i This represents the turning time cost for RGV-i. Furthermore, symmetric constraints are generated for RGV-j, with the same formula structure but interchanged subscripts.

[0100] It is important to note that the corridor timing constraint formula described above is one of the key aspects of this invention. It abstracts and aggregates the iterative process of adding time window constraints to a series of nodes within a corridor in traditional CBS into a single entry time constraint on the corridor entrance node. When CBS detects a conflict between two RGVs in the same corridor, it first calculates the corridor crossing parameters for both conflicting nodes. Among these, bypass_time... i The detour time, obtained by re-searching for a path for RGV-i on the subgraph after removing the corridor region, represents the cost required to avoid the corridor; j It is the moment when the opposing RGV-j completely leaves the corridor, determined by the time step of RGV-j leaving the corridor exit node; corridor_len i It is the number of time steps required for the RGV-i to travel from the corridor entrance to completely exiting the corridor, equivalent to its travel length within the corridor; trans i and turn_cost i These represent the transition time and the potential turning time at the corridor entrance, respectively. The formula means that the earliest time RGV-i is permitted to enter the corridor is either the time required for its detour (if detour is faster), or the total time it takes to traverse the corridor after RGV-j has completely left. By taking the minimum of these two values, the constraint ensures feasibility while allowing room for detour optimization. This one-time constraint directly prohibits RGV-i from entering the corridor at time... iBy entering the corridor entrance earlier, all potential node conflicts within the corridor are avoided, significantly reducing the number of constraint splits and node expansions in the CBS, and improving planning efficiency in multi-vehicle scenarios within the same alley.

[0101] Constraint types: Constraints are stored in a unified data structure and their type is determined based on the relationship between nodes and time window parameters—node constraints (same node, different times), adjacent constraints (different nodes, same time), edge constraints (different nodes, different times), and corridor constraints (including extended time window parameters).

[0102] S1-6: CBS Iterative Loop

[0103] like Figure 8 and Figure 9 As shown, the planner executes high-level iterations of CBS until all conflicts are resolved or the maximum number of iterations is exceeded:

[0104] The planner maintains a CBS priority queue. In each iteration, it selects the CBS node N_c with the lowest current cost from the FOCAL sub-queue as the expanded node. For all RGV paths contained in this node, it performs pairwise conflict detection. Conflict detection is based on conflict detection rules, combined with a permanent occupancy mechanism and a permanent occupancy exemption rule to exclude specific cases.

[0105] If the conflict detection result is empty, it means that there are no conflicts in the path set of the current node, the planning is successful, and the path set is directly returned as the output of conflict-free paths.

[0106] If a conflict exists, a type determination is performed for each detected conflict. A conflict is classified as a corridor conflict if the number of successor nodes of the conflicting node is two and the corridor topology characteristics are satisfied. For corridor conflicts, constraint parameters are calculated according to the corridor temporal constraint formula; for ordinary conflicts that are not corridor types, they are handled using conventional time window constraints.

[0107] After completing the conflict type determination and parameter calculation, constraint splitting is performed. The planner generates two child nodes, N_child1 and N_child2, based on the current CBS node, corresponding to the respective constraints of the conflicting parties. For each constrained RGV-i in the child node, the planner backtracks upwards along the parent node chain of that child node, collecting all historical constraints C_i of that RGV on the entire constraint chain. Simultaneously, it collects the planned paths O_i of other RGVs in the current node; these paths will serve as dynamic obstacles for the SIPP search. Finally, using the warehouse topology G, the starting point s_i and ending point g_i of RGV-i, all constraints C_i, and other RGV paths O_i as input, the SIPP searcher is invoked to replan the optimal path P_i of RGV-i within the safe interval.

[0108] When performing path search, the SIPP searcher uses the safe interval construction method to project the time window constraints in C_i, the spatiotemporal occupancy of other RGVs in O_i, and the long-term obstacles of permanently occupied RGVs into a safe interval table for each node. It only expands the state within these safe intervals to ensure that the searched path is fully compatible with all known constraints and obstacles in time and space.

[0109] After each child node completes its constrained RGV path replanning, it is inserted into the CBS priority queue and enters the next iteration. This cycle continues until a set of conflict-free paths is found, or the preset maximum number of iterations is reached.

[0110] S1-7: Low-level SIPP search: Constraint-obstacle dual processing

[0111] In the SIPP search, the planner transforms CBS constraints and other RGV paths into safe interval constraints.

[0112] Correspondingly, such as Figure 4 As shown, the construction of the safe interval in step S1 includes: initializing the safe interval of each node as the full time domain; removing the corresponding time period from the safe interval of the corresponding node according to the time window constraints generated by the CBS framework; removing the corresponding time period from the safe interval of the corresponding node and the neighboring nodes with the IsCheckNeighbor attribute set to true according to the position and time of each step in the planned paths of other RGVs; removing the time period from the target arrival time to the maximum planning time of the endpoint of the RGV in the permanent occupancy state and its neighboring nodes with the IsCheckNeighbor attribute set to true; and performing SIPP search within the obtained safe interval to generate a conflict-free path.

[0113] It's important to note that the safe interval is the foundation for the SIPP searcher's conflict-free path search. First, a fully safe interval covering the time from zero to the maximum planning time is initialized for each node in the topology graph. Then, three types of reduction operations are performed sequentially: First, all time window constraints generated by the CBS higher-level nodes for the RGV during constraint splitting are applied to the corresponding node, removing the specified time periods; second, based on the paths of other planned RGVs, the nodes and times occupied at each step are removed from the safe interval, and neighboring nodes with IsCheckNeighbor set to true are also removed at their corresponding times, ensuring that the entire cross-section is marked as unsafe when other RGVs pass through the alleyway; third, the endpoints of all RGVs marked as permanently occupied and their alleyway neighbors are removed, from the time period from the target arrival time to the maximum time, forming long-term barriers. After these three reductions, the safe interval table for each node accurately describes which time periods the node can be safely occupied. The SIPP searcher extends its state within this safe interval. It only needs to check whether a node is safe within a certain time interval to ensure that the searched path does not conflict with any planned RGV, any CBS constraints, or any permanent occupancy barriers in time and space, thus efficiently generating globally conflict-free paths.

[0114] Before proceeding with step S2, it is necessary to explain, for example... Figure 3 As shown, the reason for path cutting is: when the task in the inner part of the alley is replanned, or due to execution reasons, the path alarm needs to be replanned, which will trigger the path cutting and deletion of the delivery path of the equipment on the outer part of the alley. Otherwise, the task replanning in the inner part of the alley will not have a path, because if there are goods on the outer side, it will block the cargo-carrying equipment from entering the depth of the alley. Figure 3 In Chinese, "taskid" means task number.

[0115] Step S2: StackName backtracks to the cutting layer

[0116] Path cutting based on StackName (after the planning layer outputs a set of conflict-free paths, the planner performs further post-processing to eliminate residual conflicts not covered by the planning layer).

[0117] The set of conflict-free paths undergoes post-processing. Each RGV path is parsed into an event stream and sorted by arrival time. It checks whether subsequent RGVs intrude into the lane where an earlier RGV arrived. If so, the path of the subsequent RGV is cut back to outside the lane according to the lane identifier (StackName). This process iterates until no new cuts are generated. In this step, post-processing cuts resolve potential conflicts remaining from the planning layer, especially covert intrusions caused by execution timing deviations or path replanning. This step expands the planned paths of each RGV into timestamped event streams and records the occupancy history of each physical node and its IsCheckNeighbor neighbor nodes. After sorting the target events in ascending order of arrival time, each event is checked to see if any other RGV accessed the target node or its neighbor nodes in the same lane after the target event, indicating an intrusion. If an intrusion occurs, backtracking and cutting are performed using the StackName attribute of nodes in the warehouse topology: traverse backwards along the path from the intrusion point until a node with a StackName different from the target node is found. Then, all nodes with the same StackName in the RGV path are cut off, causing the RGV to stop outside the alleyway and avoid obstruction. After cutting, iterative convergence is required until no new cuts are generated.

[0118] S2-1: Event Flow Parsing and Target Event Ordering

[0119] The planner parses each path into an event stream, recording the RGV number, current node, current time, and next node for each event. For all events, occupancy history is recorded on each physical node and its neighboring nodes with IsCheckNeighbor=True. Then, the goal events (GoalEvents) that allow RGVs to reach their destination are filtered out and sorted in ascending order of arrival time.

[0120] S2-2: StackName Backtracking Cut

[0121] For each GoalEvent, the planner checks whether there are any intrusive conflicts in subsequent RGVs and performs a cut.

[0122] Correspondingly, the backtracking and cutting by lane identifier StackName in step S2 includes: parsing all RGV paths into an event stream containing RGV number, current node, current time, and next node, and recording the occupancy history of each physical node and its neighboring nodes with a true IsCheckNeighbor attribute; filtering out target events where RGVs reach their destination and arranging them in ascending order of arrival time as a target event sequence; for each target event, checking whether there are other RGVs that have accessed the target node or its neighboring nodes with a true IsCheckNeighbor attribute after the target event; if so, and the target node is a shelf type, then traversing the path of the other RGVs backward from the conflict point until a node with a lane identifier StackName different from the target node is found, cutting off all nodes in the path that have the same StackName as the target node, and selecting the node where the RGV was the last occupant within the cutting range as the cutting point.

[0123] This step leverages the StackName semantics within the warehouse topology to achieve precise post-processing segmentation. First, each RGV path is parsed as an event stream with time information, and a complete occupancy history is built for each physical node and its aisle neighbors (IsCheckNeighbor is true). Therefore, occupancy of a node is simultaneously reflected across the entire aisle cross-section. Subsequently, all RGV arrival events are arranged in ascending chronological order to form a processing sequence. For each arrived target event, it is checked whether any other RGV has planned to access the target node or its aisle neighbors after its occurrence time. This access is considered an intrusion and will block subsequent RGVs from entering deeper into the aisle. Once an intrusion is detected and the target is a shelf type, the segmentation logic is initiated: tracing back from the conflicting nodes on the intrusion path, the StackName attribute of each node is checked until the first node with a StackName different from the target node is found. StackName is the unique identifier of an aisle in the warehouse topology; all storage location nodes within the same aisle share the same StackName. Therefore, tracing back to a node with a different StackName means that the node has exited the aisle's range. Cutting off all nodes with the same StackName as the target node in the path is equivalent to truncating the path of the intruding RGV outside the alleyway, completely eliminating its obstruction. The selection of a safe cut point further ensures the stability of the path's end after the cut: within the cutting range, the node where the RGV was last occupied is chosen as the cut endpoint, ensuring that the RGV's stopping position after the cut will not create new conflicts with the planned paths of other RGVs. Utilizing StackName semantics to limit the cutting range to the same alleyway avoids blindly cutting across the entire area, affecting conflict-free areas and ensuring cutting accuracy and efficiency.

[0124] S2-3: Iterative convergence

[0125] The planner sets a change flag after each cut and reprocesses all GoalEvents. The iteration terminates when no new cuts are generated in a complete traversal.

[0126] Correspondingly, the iteration in step S2 until no new cuts are generated is a loop implemented by setting a change flag: in each round of traversal of all target events, when any cut occurs, the change flag is set; after the end of the round of traversal, if the change flag is set, a new round of traversal is started using the set of cut paths, until the change flag is not set at the end of a round of traversal, and the iteration is terminated.

[0127] Step S3: STN Type 2 Dependency Edge Scheduling Layer

[0128] The timing control of path delivery based on STN type 2 dependent edges (the set of cut paths is used as input, the planner constructs a directed graph of STN (Simple Temporal Network), and controls the timing of path delivery through topology sorting to ensure that deep RGV is executed first).

[0129] A Simple Temporal Network (STN) directed graph is constructed based on the set of cut paths. Type 2 dependency edges are established between access events of different RGVs on the same physical node. These Type 2 dependency edges indicate that another RGV can only enter after the first RGV leaves the node and releases its space. The path distribution sequence is controlled through topological sorting, ensuring that RGVs in deeper aisle shelving locations are executed before those in shallower shelving locations. In this step, the STN scheduling layer is responsible for safely and orderly distributing the cut, conflict-free paths to each RGV for execution. The STN directed graph constructed in this step contains two types of edges: natural temporal order edges (Type 1) indicating the path order within the same RGV, and cross-RGV space mutually exclusive dependency edges (Type 2) established based on shared node occupancy history. Type 2 edges explicitly express the premise that "an RGV arriving later can only enter after the first RGV leaves the node and releases its space." By calculating the topological order of STN and issuing the corresponding path segment only when all type 2 predecessor dependencies are satisfied, the system automatically ensures that deep RGVs are issued first because they occupy the roadway entrance earlier, while shallow RGVs must wait for deep RGVs to release the roadway space before they can act, thus achieving the anti-occlusion execution sequence of "deep areas first, shallow areas last".

[0130] S3-1: Constructing a Directed STN Graph

[0131] like Figure 6 As shown, the STN directed graph contains two types of edges: type 1 dependency edges and type 2 dependency edges. The specific construction process is as follows:

[0132] First, Type 1 edges are established to express the temporal constraints between path nodes within the same RGV. Specifically, for each RGV, its segmented path P' is obtained. This path consists of a series of ordered STN nodes, each STN node corresponding to a physical location in the path and its arrival and departure times. Starting from the second node of the path, the process is traversed sequentially, and for each pair of adjacent STN nodes, a directed edge is added from the previous node to the next node. The semantics of this directed edge are: the RGV must first arrive at and leave the physical location represented by the previous node before it can begin moving to the next node. Through this process, the path of each RGV is transformed into a strictly temporally ordered chain of nodes, forming an irreversible temporal dependency of actions within the RGV, laying the foundation for subsequent collaborative scheduling with Type 2 edges. The dependencies within the same RGV expressed by Type 1 edges are naturally satisfied during execution, requiring no additional condition checks when the path is issued.

[0133] After constructing Type 1 edges, Type 2 edges are further established to express the mutual exclusion dependency between different RGVs due to shared physical space. Specifically, the construction and distribution control of Type 2 dependency edges in step S3 includes: for each physical node, extracting all RGV access events from its occupancy history and sorting them by time; for event pairs that are temporally adjacent and belong to different RGVs, pointing the next STN node after the first RGV leaves the node to the STN node after the second RGV arrives at the node, forming a Type 2 directed dependency edge; when the IsCheckNeighbor attribute of a node is true, the event occupying the node synchronously blocks all its neighboring nodes with true IsCheckNeighbor attributes, and records this in the occupancy history of the corresponding neighboring nodes with true IsCheckNeighbor attributes; when distributing paths, for any path segment, the path segment is only distributed if the physical location represented by the predecessor node of all Type 2 incoming edges of its corresponding STN node has been left by the corresponding RGV.

[0134] In constructing Type 2 edges, for each physical node v, all RGV access events are extracted from its occupancy history and sorted by time. For each pair of time-adjacent events belonging to different RGVs, a Type 2 directed edge is added, starting at the next STN node after the first arriving RGV leaves node v, and ending at the STN node where the second arriving RGV arrives at node v. The semantics of this edge are: a subsequent RGV can only enter after the previous RGV leaves the node. When the IsCheckNeighbor property of node v is true, the occupancy event of v is synchronously recorded in the occupancy history of all its neighboring nodes with a true IsCheckNeighbor property, thus extending single-point mutual exclusion to lane cross-section-level mutual exclusion, enabling Type 2 dependency edges to be established between RGVs using different depths within the same lane.

[0135] S3-2: Path Distribution Control

[0136] like Figure 7 As shown, the planner performs a topological sort on the STN directed graph and determines the timing of path distribution according to the following rules:

[0137] After performing topological sorting on the STN directed graph, each STN node is checked sequentially. During the check, all incoming edges of the node are traversed: if the incoming edge is a Type 1 edge (i.e., a dependency edge between sequential actions within the same RGV), no blocking occurs because the execution of the same RGV naturally satisfies the order constraint; if the incoming edge is a Type 2 edge (i.e., a spatially mutually exclusive dependency edge between different RGVs), it is checked whether the starting RGV of the edge has actually reached the corresponding physical location and left. If not, the STN node is not ready, and the current check is stopped. Only when the predecessor conditions of all Type 2 incoming edges are satisfied is the node considered ready, and a path segment starting from this node is immediately issued to the corresponding RGV. Under this mechanism, deeper RGVs are prioritized in the topological order because they occupy the lane entrance first, thus satisfying the issuance conditions first; shallower RGVs, because they have Type 2 incoming edges pointing to the departure actions of deeper RGVs, must wait for the lane space to be released before they can be ready, thus naturally achieving priority execution for deeper RGVs.

[0138] Issue the decision logic table

[0139]

[0140] This mechanism ensures that: deep RGVs are issued and executed first and reach the shelf first, while shallow RGVs are issued only after the type 2 precursor conditions are met, thus achieving the execution sequence of "deep first, shallow last".

[0141] In summary, the method of this invention combines corridor structure identification with entry time constraints, directly generating a one-time temporal constraint for the entire corridor. This replaces the traditional node-by-node conflict resolution method, significantly reducing the number of planning iterations and improving path planning efficiency in multi-vehicle scenarios within the same aisle. Simultaneously, the permanent occupancy mechanism disables the RGV endpoint and neighboring nodes within the same aisle for an extended period within a safe zone, preventing subsequent RGV paths from intruding into already occupied storage locations from a spatial planning perspective, ensuring path security. The post-processing layer utilizes the StackName aisle identifier for precise path cutting, only removing intrusive segments within the same aisle to avoid over-cutting and ensure the global availability of the corrected path. Execution scheduling explicitly establishes cross-RGV node release dependencies through STN type 2 dependency edges, naturally achieving priority delivery of deep RGVs and delayed entry of shallow RGVs through topological sorting, eliminating deadlocks and mutual waiting within the aisle during runtime, and ensuring smooth execution of the inbound task. The three-layer collaborative closed loop ensures that the physical constraint of "deep areas first, shallow areas last" is met from path search and correction to instruction issuance, thereby improving the efficiency and reliability of warehousing operations as a whole.

[0142] A multi-agent occupancy obstruction resolution system for warehouses in the same aisle, characterized by comprising: a CBS-FOCAL planning module, used to acquire the warehouse topology map and the origin and destination information of each RGV, identify corridor conflicts through conflict detection and generate corridor timing constraints, mark RGVs delivered to the shelf location as permanently occupied, and set the destination of the permanently occupied RGV and neighbor nodes with the IsCheckNeighbor attribute true as permanently unavailable within a safe interval, outputting a set of conflict-free paths; a StackName backtracking and cutting module, used to parse the set of conflict-free paths into an event stream, sort them by arrival time and detect intrusion conflicts, backtrack and cut the path of the intruding RGV to outside the aisle according to StackName for the intruded aisle, and output a set of cut paths through iterative convergence; and an STN scheduling module, used to construct an STN directed graph based on the set of cut paths, establish type 2 dependency edges between different RGVs on shared physical nodes, control the path delivery timing through topological sorting, so that RGVs in deeper aisle shelf locations are delivered and executed before RGVs in shallower shelf locations.

[0143] More specifically, the CBS-FOCAL planning module includes: a conflict detection unit, used to detect vertex conflicts, edge conflicts, adjacent conflicts, and corridor conflicts in the RGV path set; a corridor parameter calculation unit, used to identify corridor conflicts and calculate corridor length, detour time, and turning cost, generating corridor temporal constraints; a permanent occupancy processing unit, used to mark permanent occupancy status according to task type and target node attributes, and update the safe interval table; and a SIPP search unit, used to search for the optimal path of each RGV within the safe interval after constraints, other RGV paths, and permanent occupancy reduction.

[0144] The present invention also has the following advantages:

[0145] (1) Precise modeling of corridor-level conflicts: By identifying the corridor structure and calculating parameters such as corridor length, detour time, and turning cost, a precise corridor time-series constraint formula is generated, avoiding the multiple iterations caused by the traditional CBS relying solely on node / edge constraints, and greatly improving planning efficiency.

[0146] (2) Permanent occupancy ensures path safety: The PermanentStay mechanism treats the RGV endpoint of the delivery to the shelf as a permanent obstacle, prohibiting subsequent RGVs from entering the area at the safety zone level, thus fundamentally avoiding the planning of paths that penetrate the occupied area.

[0147] (3) Three-layer collaborative closed loop guarantee: the planning layer generates conflict-free paths, the cutting layer eliminates residual conflicts through post-processing, and the scheduling layer guarantees the execution sequence. The three-layer collaboration ensures a complete closed loop from planning to execution, without relying on the correctness of a single level.

[0148] (4) StackName semantic segmentation is efficient and accurate: by using the StackName attribute in the warehouse topology, the segmentation range is precisely limited to the same lane, avoiding excessive segmentation that affects irrelevant areas, while ensuring the safety of the path within the same lane.

[0149] (5) Depth-first timing guarantee: Type 2 dependent edge combined with STN topology sorting ensures that deep RGV arrives first and shallow RGV enters later from the bottom level, eliminating the risk of deadlock and mutual waiting during runtime.

[0150] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the principle 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 solution to the problem of multiple agents blocking entry into a warehouse in the same lane, characterized in that: Includes the following steps: Step S1: Based on the CBS-FOCAL framework, perform path planning for multiple RGVs, identify corridor conflicts and generate corridor timing constraints in conflict detection, and mark RGVs delivering goods to the shelf location as permanently occupied. Within the safe zone, set the endpoint of the permanently occupied RGV and the neighbor nodes with the IsCheckNeighbor attribute that are true as permanently unavailable, and generate a set of conflict-free paths. Step S2: Post-process the set of conflict-free paths, parse each RGV path into an event stream and sort them according to the arrival time of the target, detect whether the subsequent RGV intrudes into the lane where the RGV that arrived at the target first is located, if so, backtrack and cut the path of the subsequent RGV to outside the lane according to the lane identifier StackName, iterate until no new cuts are generated. Step S3: Construct a directed graph of a simple temporal network (STN) based on the set of cut paths, wherein type 2 dependency edges are established between access events of different RGVs on the same physical node, and the type 2 dependency edges indicate that another RGV can only enter after the RGV that leaves first releases the node; control the timing of path delivery through topological sorting so that RGVs in deep aisle shelving positions are delivered and executed before RGVs in shallow shelving positions.

2. The solution to the problem of multiple agents blocking entry into a warehouse in the same lane as described in claim 1, characterized in that: The corridor timing constraint mentioned in step S1 is to generate the earliest time constraint allowing entry into the corridor for RGV-i that have a corridor conflict. The calculation formula is as follows: time i = min(bypass_time i , o j + corridor_len i + trans i + turn_cost i ); Among them, time i The earliest time that RGV-i is allowed to enter the corridor, bypass_time i For the time required for RGV-i to bypass the corridor, o j The moment when RGV-j completely leaves the corridor, corridor_len i The number of steps required for RGV-i to traverse the corridor, trans i For the transition time of RGV-i, turn_cost i The turning time cost for RGV-i.

3. The solution to the problem of multiple agents blocking entry into a warehouse in the same lane as described in claim 1, characterized in that: The marking and processing of the permanent occupancy state in step S1 includes: When the RGV task type is delivery, and the target node attribute is shelf type, not conveyor belt type, and not elevator type, mark the RGV as permanently occupied. The path endpoint of the permanently occupied RGV is repeatedly extended to the maximum planning time. In the safe interval table, the endpoint node and all its neighbor nodes with the IsCheckNeighbor attribute set to true are marked as permanently unavailable for the period from the time the RGV arrives at the target time to the maximum planning time.

4. The solution to the problem of multiple agents blocking entry into a warehouse in the same lane as described in claim 1, characterized in that: The backtracking cut based on the lane identifier StackName mentioned in step S2 includes: All RGV paths are parsed into event streams containing RGV number, current node, current time and next node, and the occupancy history of each physical node and its neighboring nodes with the IsCheckNeighbor property set to true is recorded. Filter out the target events where the RGV reaches its destination and arrange them in ascending order of arrival time to form a target event sequence; For each target event, check whether there are other RGVs that accessed the target node or its neighbor node whose IsCheckNeighbor property is true after the target event; If the target node exists and is of shelf type, then traverse the path of other RGVs forward from the conflict point until a node with a lane identifier StackName different from the target node is found. Cut off all nodes in the path that have the same StackName as the target node, and select the node of the RGV that was last occupied within the cutting range as the cutting point.

5. The solution to the problem of multiple agents blocking entry into a warehouse in the same lane as described in claim 1, characterized in that: The construction and distribution control of type 2 dependency edges in step S3 includes: For each physical node, extract all RGV access events from its occupancy history and sort them by time; For event pairs that are temporally adjacent and belong to different RGVs, the next STN node after the first RGV leaves the node is pointed to the STN node after the second RGV arrives at the node, forming a type 2 directed dependency edge. When a node’s IsCheckNeighbor property is true, the event that occupies the node synchronously blocks all its neighboring nodes whose IsCheckNeighbor property is true, and records the event in the occupancy history of the corresponding neighboring node whose IsCheckNeighbor property is true. When a path is issued, for any path segment, the path segment is issued only if the physical location represented by the predecessor node of all type 2 incoming edges of its corresponding STN node has been left by the corresponding RGV.

6. The solution to the problem of multiple agents blocking entry into a warehouse in the same lane as described in claim 1, characterized in that: The rules for collision detection in step S1 include: If one RGV waits in place while another RGV enters its location, it is considered a WaitIn conflict; If one RGV enters while another RGV waits in place and their target locations overlap, it is considered an InWait conflict. If two RGVs enter the same node or adjacent nodes at the same time, it is determined to be an InIn conflict; If the position where one RGV leaves is the same as the position where another RGV enters, it is determined to be an OutIn conflict; If the position where one RGV enters is the same as the position where another RGV leaves, it is determined to be an InOut conflict; Furthermore, when both nodes have the IsCheckNeighbor property true and have a connected edge, they are considered adjacent and conflicting even if the two RGVs are not on the same node.

7. A solution to the problem of multiple agents blocking entry into a warehouse in the same lane, as described in claim 6, is characterized in that: The conflict detection in step S1 also includes a permanent occupancy exemption rule: when both RGVs are in a permanent occupancy state and are both at their respective target endpoint nodes, the adjacent conflict detection between the two RGVs is skipped, allowing the two RGVs in a permanent occupancy state to stay at different depth rack positions in the same aisle at the same time.

8. The solution to the problem of multiple agents blocking entry into a warehouse in the same lane as described in claim 1, characterized in that: The construction of the safe interval in step S1 includes: Initialize the safe interval of each node to the full time domain; Based on the time window constraints generated by the CBS framework, remove the corresponding time period from the safe interval of the corresponding node; Based on the position and time of each step in the planned path of other RGVs, remove the corresponding time from the safe interval of the corresponding node and the neighboring nodes whose IsCheckNeighbor attribute is true; Remove the endpoint of the RGV that is in a permanent occupancy state and its neighboring nodes whose IsCheckNeighbor attribute is true from the time period from the time of the target arrival to the maximum planning time. Perform a SIPP search within the obtained safe zone to generate a conflict-free path.

9. The solution to the problem of multiple agents blocking entry into a warehouse in the same lane as described in claim 1, characterized in that: The iteration in step S2 until no new cuts are generated is achieved by setting a change flag: In each round of traversal of all target events, when any cut occurs, the change flag is set; After the current traversal is completed, if the change flag is set, a new traversal is started using the cut path set, until the change flag is not set at the end of the traversal, at which point the iteration terminates.

10. A system for resolving occupancy obstructions by multiple agents entering a warehouse in the same lane, characterized in that: include: The CBS-FOCAL planning module is used to obtain the warehouse topology map and the origin and destination information of each RGV. It identifies corridor conflicts through conflict detection and generates corridor timing constraints. It marks the RGVs that deliver goods to the shelf position as permanently occupied. Within the safe interval, it sets the destination of the permanently occupied RGV and the neighbor nodes with the IsCheckNeighbor attribute that are true as permanently unavailable, and outputs a set of conflict-free paths. The StackName backtracking and cutting module is used to parse the set of conflict-free paths into an event stream, sort them by arrival time, detect intrusion conflicts, backtrack and cut the intruding RGV path to outside the intruded lane according to StackName, and output the set of cut paths through iterative convergence. The STN scheduling module is used to construct an STN directed graph based on the cut path set, establish type 2 dependency edges between different RGVs on the shared physical node, and control the path delivery sequence through topological sorting so that RGVs in deep aisle rack positions are delivered and executed before RGVs in shallow rack positions.

Images