AGV path planning method based on dynamic space-time state expansion Dijkstra

Abstract

The invention relates to the technical field of path planning, in particular to an AGV path planning method based on dynamic space-time state expansion Dijkstra, which comprises the following steps: step 1, modeling a topological map, creating a data model containing nodes and edges, and configuring corresponding attributes for the nodes and the edges; 2, initializing attributes, and calculating an adjacency list of nodes, a direction angle of each edge, an edge length, shortest passing time and acceleration and deceleration loss time; 3, path search planning is carried out based on an improved Dijkstra algorithm, and an optimal path is searched with the total consumed time as the weight through state expansion, cost calculation and state transition in combination with a priority queue and a hash table; 4, according to the planned optimal path, a node sequence from the starting point to the terminal point is obtained, a path is generated, and time optimal path searching in a real scene is achieved.

Description

Technical Field

[0001] The present invention relates to the technical field of path planning, and in particular to an AGV path planning method based on dynamic spatiotemporal state extended Dijkstra. Background Art

[0002] With the rapid development of intelligent manufacturing and logistics automation, automated guided vehicles (AGVs) are increasingly being used in warehouses, factories, and other scenarios. Path planning, as a core technology for efficient AGV operation, directly impacts logistics efficiency and system stability. Traditional path planning methods, such as the Dijkstra algorithm and its improved versions, are often based on the assumption of a static road network, viewing the path as a simple connection of nodes and edges. This ignores the actual motion characteristics of the AGV, such as acceleration and deceleration, and steering time. This can lead to significant discrepancies between the planned path and the actual operation.

[0003] Although some existing technologies take into account the kinematic constraints of AGVs, they use simplified models. For example, they assume that the AGV can reach the target speed instantly and there is no time loss during the turning process, or they only rely on a preset fixed speed to calculate the travel time. This makes it impossible to achieve time optimization in practical applications when planning paths, and may even cause the AGV to start and stop frequently, increase the risk of collisions, and reduce the efficiency and reliability of the system. In addition, when dealing with complex topological networks, traditional methods are prone to "dimensionality disasters" because they do not effectively compress the state space. This leads to high algorithm computational complexity and poor real-time performance, making it difficult to meet the needs of dynamic logistics scenarios. Therefore, there is an urgent need for a planning method that can accurately model the motion characteristics of AGVs and efficiently search for optimal paths. Summary of the Invention

[0004] The technical problem to be solved by the present invention is: to overcome the shortcomings of the existing technology, provide an AGV path planning method based on dynamic spatiotemporal state extended Dijkstra, comprehensively calculate the driving time, rotation time, acceleration and deceleration loss time, and realize the time optimal path search in real scenarios.

[0005] The present invention is implemented by the following technical solution: an AGV path planning method based on dynamic spatiotemporal state extended Dijkstra comprises the following steps: Step 1: Topology map modeling, creating a data model containing nodes and edges, and configuring corresponding attributes for both nodes and edges; Step 2: Initialize the attributes and calculate the node adjacency list, the direction angle of each edge, the edge length, the shortest travel time, and the acceleration and deceleration loss time; Step 3: Path search and planning is performed based on the improved Dijkstra algorithm. Through state expansion, cost calculation, and state transition, combined with priority queues and hash tables, the optimal path is searched with the total time taken as the weight. Step 4: Based on the planned optimal path, obtain the node sequence and generate the planned path.

[0006] The node in step 1 represents the intersection and serves as a rotation time-consuming calculation primitive. The attributes of the node include node ID, node coordinates (x, y), maximum angular velocity, angular acceleration, angular deceleration, and adjacency list. The edge represents a road segment, and the edge incorporates acceleration and deceleration time. The set of edges is recorded as an edge list. The attributes of each edge include road segment ID, starting node ID, ending node ID, starting direction angle, ending direction angle, maximum linear speed, linear acceleration, linear deceleration, shortest travel time and additional acceleration and deceleration loss time.

[0007] The step 2 includes the following sub-steps: Step 2-1: Initialize the adjacency table, traverse the edge list, find the starting node of the edge according to the starting node ID, and add the segment ID of the edge to the corresponding starting node in the adjacency table; Step 2-2: Initialize the direction angle and various time attributes of each edge.

[0008] The step 2-2 includes the following sub-steps: Step 2-2-1: Find the starting node of the edge according to the starting node ID, find the ending node of the edge according to the ending node ID, and calculate the starting direction angle and the ending direction angle; Step 2-2-2: Calculate the length of the side, and calculate the shortest travel time and acceleration and deceleration loss time based on the side length.

[0009] The step 3 includes the following sub-steps: 3-1: Initialization: Convert static nodes into an expandable state set, create a hash table and priority queue to store relevant state information, configure relevant variables, determine the angle threshold required for parking and turning, and vehicle initialization information; 3-2: Expand the state, traverse the adjacent edges of the current node, calculate the shortest total time to pass through the adjacent edges, generate a new state, and update the hash table and priority queue; 3-3: Perform state transfer and cost update.

[0010] The above 3-1 includes the following sub-steps: 3-1-1: Create hash tables min_cost, prev_line, and prev_state to record the relevant information of each state. The hash table min_cost is used to record the minimum time to reach the state, the hash table prev_line is used to record the previous edge to reach the state, and the hash table prev_state is used to record the previous state to reach the state. Each state includes the node ID and state direction of the state; 3-1-2: Create a priority queue to store the state and its motion information motion_info, which includes the total state time of the state and the road segment ID to reach the state; 3-1-3: Create a variable best_lines_id_list to store the edge IDs of the planned optimal path; Create a variable min_total_time to represent the total time taken to plan the optimal path; 3-1-4: Set the angle threshold required for parking and turning to angle_spin. The vehicle starting point ID is known to be id_point_start, and the initial direction angle is dire_start. The current state includes the current state node ID and the current state direction angle information.

[0011] The 3-2 step includes the following sub-steps: 3-2-1: Traverse the adjacency table corresponding to the node in the current state, obtain each adjacent edge of the node, create a new state corresponding to each adjacent edge, and calculate the total time cost to reach the new state through the adjacent edges; 3-2-2: Calculate the angle difference d_angle between the current state direction angle and the starting direction angle of the adjacent line, and determine whether d_angle is greater than the threshold angle_spin. If so, add the time lost in turning to the total time cost to update the total time cost, and then go to step 3-2-3. Otherwise, go directly to step 3-2-3. 3-2-3: Update the new state and the motion information of the new state; 3-2-4: Determine whether there is a minimum time to reach the new state in the hash table min_cost. If so, go to 3-2-5, otherwise go to 3-2-6; 3-2-5: Determine whether the total time of the new state is less than the minimum time to reach the state recorded in the hash table min_cost. If so, go to 3-2-6, otherwise go to 3-2-7; 3-2-6: Add the new state and its motion information to the priority queue, update the hash tables min_cost, prev_line, and prev_state synchronously, and go to 3-3; 3-2-7: Determine whether the priority queue is empty. If so, proceed to step 4; otherwise, return to 3-2-1.

[0012] The 3-3 step includes the following sub-steps: 3-3-1: Take the state with the smallest total state time from the priority queue and use it as the current state; 3-3-2: Perform pruning to determine whether the total state time of the current state is greater than the minimum time to reach the state recorded in the min_cost hash table. If so, trigger pruning, discard the state, and return to 3-3-1. Otherwise, proceed to 3-3-3. 3-3-3: End point detection, determine whether the node ID of the current state is equal to the node ID of the end point. If so, trigger edge backtracking and enter 3-3-4; otherwise, enter 3-3-5; 3-3-4: Edge backtracking, starting from the end state and tracing back to the starting node, obtain the previous edge that reaches this state through the hash table prev_line, and generate an edge sequence; 3-3-5: Determine whether the priority queue is empty. If so, proceed to step 4; otherwise, return to 3-2-1.

[0013] The 3-3-4 includes the following sub-steps: 3-3-4-1: Determine whether the total state time of the current state is less than min_total_time. If so, it means that the current path is better and proceed to 3-3-4-2; if not, return to 3-3-1; 3-3-4-2: Update the value of min_total_time to the total time of the current state, obtain the segment ID of the previous edge that reaches the current state from the hash table prev_line, and add it to best_lines_id_list; 3-3-4-3: Determine whether the starting node of the current edge is equal to the starting point of the vehicle. If so, go to step 4; otherwise, go to 3-3-4-4; 3-3-4-4: Update the current state cur_state to the previous state recorded in the hash table prev_state, and return to step 3-3-4-2; The step 4 includes the following sub-steps: 4-1: Take the first road segment ID from best_lines_id_list and get the corresponding edge; 4-2: Add the terminal node ID of the corresponding edge to the node sequence; 4-3: Determine whether the segment ID is the last element of best_lines_id_list. If so, add the starting node of the edge to the node sequence and output the node sequence, and go to 4-4; if not, get the next segment ID, get the corresponding edge, and repeat 4-2; 4-4: Reverse the output node sequence to obtain the final planned path.

[0014] Compared with the prior art, the present invention has the following beneficial effects: The AGV path planning method proposed in this application is based on the dynamic spatiotemporal state extended Dijkstra. By modeling the path network as a topological graph structure that integrates acceleration and deceleration time and turning time, it accurately quantifies the time loss during the AGV movement process, avoids the "idealized motion" assumption in traditional methods, makes the planned path more in line with the actual operation scenario, and greatly improves the accuracy and reliability of path planning. This method innovatively introduces the "dynamic spatiotemporal state extension" mechanism. By combining hash tables with priority queues, it achieves efficient management and pruning optimization of the state space, reduces the time complexity of the algorithm, and significantly improves the path search efficiency, which can meet the real-time planning needs under large-scale complex topology networks.

[0015] This method separates node and edge attributes and configures rotation performance and motion parameters respectively, so that path planning can flexibly adapt to the motion characteristics of different types of AGVs, enhances the versatility and scalability of the algorithm, and provides more efficient and reliable technical support for intelligent manufacturing and smart logistics. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1 is a flow chart of this method; Figure 2 This is the path search planning flow chart for step 3 of this method; Figure 3 It is the edge backtracking flowchart in step 3; Figure 4 This is a schematic diagram of the AGV route network in Example 2. DETAILED DESCRIPTION

[0017] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. All other embodiments obtained by ordinary technicians in this field based on the embodiments of the present invention without making any creative efforts shall fall within the scope of protection of the present invention.

[0018] Example 1 Reference Figure 1-Figure 3 ,The AGV path planning method based on the dynamic spatiotemporal state extension Dijkstra includes the following steps: Step 1: Topology map modeling, creating a data model containing nodes and edges, and configuring corresponding attributes for both nodes and edges; Step 2: Initialize the attributes, calculate the node adjacency list, the direction angle of each edge, the edge length, the shortest travel time, and the acceleration and deceleration loss time; Step 3: Path search and planning is performed based on the improved Dijkstra algorithm. Through state expansion, cost calculation, and state transition, combined with priority queues and hash tables, the optimal path is searched with the total time taken as the weight. Step 4: Based on the planned optimal path, obtain the node sequence and generate the planned path.

[0019] Furthermore, the node in step 1 represents the intersection and serves as a primitive for calculating the rotation time. The attributes of the node include node ID, node coordinates (x, y), maximum angular velocity, angular acceleration, angular deceleration, and adjacency list, as shown in Table 1: Table 1 Node attribute table

[0020] The edges represent road sections, and the edges are integrated with acceleration and deceleration time. The set of edges is recorded as an edge list. The attributes of each edge include road section ID, starting node ID, ending node ID, starting direction angle, ending direction angle, maximum linear speed, linear acceleration, linear deceleration, shortest travel time and additional acceleration and deceleration loss time, as shown in Table 2.

[0021] Table 2 Edge attribute table

[0022] The step 2 includes the following sub-steps: Step 2-1: Initialize the adjacency table, traverse the edge list, find the starting node of the edge based on the starting node ID, and add the segment ID of the edge to the starting node of the corresponding edge in the adjacency table to indicate that the point can lead to the current edge; Step 2-2: Initialize the direction angle and various time attributes of each edge. Traverse the edge list and calculate the relevant attributes of each edge. Specifically, step 2-2 includes the following sub-steps: Step 2-2-1: Find the starting node of the edge based on the starting node ID, find the ending node of the edge based on the ending node ID, and calculate the starting direction angle and the ending direction angle. The calculation formula is as follows: ; Where dire_start represents the starting direction angle, dire_end represents the ending direction angle, p_end represents the ending node of the edge, p_start represents the starting node of the edge, x and y are coordinates, then p_end.y represents the y coordinate of the ending node of the edge, p_start.y represents the y coordinate of the starting node of the edge, p_end.x represents the x coordinate of the ending node of the edge, and p_start.x represents the x coordinate of the starting node of the edge; Step 2-2-2: Calculate the length of the edge and calculate the shortest travel time based on the edge length -min and acceleration / deceleration loss time. The calculation process in 2-2-2 is as follows: 2-2-2-1: Calculate the length of the side using the following formula: ; 2-2-2-2: Calculate the shortest travel time - min, calculated as: ; 2-2-2-3: Calculate the acceleration and deceleration loss time. Compare the distance required to achieve acceleration or deceleration with the edge length to determine whether the edge can complete the acceleration. Based on the judgment result, different calculation methods are used to calculate the acceleration and deceleration loss time.

[0023] Specifically, an AGV experiences acceleration (from rest to maximum speed) and deceleration (deceleration to zero before turning or stopping) during driving. If the edge length is long enough, the AGV can complete acceleration and maintain a constant speed on the road section. If the edge length is too short, it cannot reach maximum speed, and different formulas are required to calculate the acceleration and deceleration loss time. Taking the acceleration loss time d_time_acc as an example, its calculation formula is as follows: ; Based on this, we must first calculate the time t_acc and distance s_acc required to accelerate to the maximum speed. The calculation formula is: ; The calculation method of the deceleration loss time d_time_dec is similar to that of the acceleration loss time d_time_acc. Replace the linear acceleration line_acc with the linear deceleration line_dec, that is: ; ; t_dec and distance s_dec are the time and distance required to decelerate to 0, respectively. line_dec is the linear deceleration. acc and dec are the acceleration and deceleration, respectively.

[0024] The step 3 includes the following sub-steps: 3-1: Initialization; converting static nodes into an extensible state set, creating a hash table and priority queue to store relevant state information, configuring relevant variables, determining the angle threshold required for parking and steering, and vehicle initialization information; further, 3-1 includes the following sub-steps: 3-1-1: Create hash tables min_cost, prev_line, and prev_state to record the relevant information of each state respectively. min_cost records the minimum time to reach the state; prev_line records the previous edge to reach the state; prev_state records the previous state to reach the state. The state is recorded as state. Each state includes the node ID and state direction of the state. The node ID of the state is recorded as state.point_id, and the state direction is recorded as state.dire. 3-1-2: Create a priority queue pq to store the state state and its motion information. The motion information is recorded as motion_info. The motion information specifically includes the total state time of the corresponding state and the ID of the road segment to reach the state. The total state time is recorded as motion_info.total_time, and its initial value is 0. The ID of the road segment to reach the state is recorded as motion_info.line_id. The state is not fixed, but changes dynamically during the path search process. The total state time represents the total time taken to reach the node corresponding to the state from the starting point. Since there may be multiple paths from the starting point to the node, the total state time corresponding to different paths is also different. In other words, there may be multiple reachable paths to the same state, and each path corresponds to a total state time.

[0025] 3-1-3: Create a variable best_lines_id_list to store the edge IDs of the planned optimal path; Create a variable min_total_time to represent the total time taken to plan the optimal path; 3-1-4: Set the angle threshold for parking and turning to angle_spin. The vehicle starting point ID is known to be id_point_start and the initial direction angle is dire_start. The current state includes the current state node ID and the current state direction angle information; the current state is recorded as cur - state, the current state node ID is recorded as cur_state.point_id, and the current state direction angle is expressed as cur_state.dire, then the following relationship exists: cur_state.point_id=id_point_start; cur_state.dire=dire_start.

[0026] 3-2: Perform state expansion, traverse the adjacent edges of the current node, calculate the shortest total time to pass through the adjacent edges, generate a new state, and update the hash table and priority queue; 3-2 includes the following sub-steps: 3-2-1: Traverse the adjacency table corresponding to the node in the current state, obtain each adjacent edge of the node, create a new state corresponding to each adjacent edge (that is, the next state based on the current state), record the new state as new_state, and calculate the total time cost of reaching the new state through the adjacent edges, record the total time cost as new_state_total_time. When the state is expanded, each new state is generated by adding the time to traverse the new section and various loss times to the total state time of the current state to obtain the total time of the new state. Total time cost = current total time + shortest section travel time + loss time. The shortest section travel time is the time it takes for a vehicle to pass through the section at a constant speed without changing speed. This is the shortest time a vehicle can pass through the section. In reality, vehicles may slow down or accelerate, affecting the time it takes to pass the section. The time loss involved in this process is calculated separately, thus calculating the total time of the new state.

[0027] For example, if the current node is at the starting node, the current total time is 0, and the vehicle must have a starting process. The shortest travel time of this section is recorded as time_min, and the loss time including the loss time of starting acceleration is recorded as d_time_acc.

[0028] 3-2-2: Calculate the angle difference d_angle between the current state direction angle and the starting direction angle of the adjacent line. The calculation formula is as follows: ; cur_state.dire is the current state direction angle, and line.dire_start is the starting direction of the adjacent line.

[0029] Determine whether the angle difference d_angle is greater than the threshold angle_spin. If so, the lost time includes the time lost for turning, which is recorded as lost_time. The time lost for turning is added to the total time cost to update the total time cost, and then go to step 3-2-3. Otherwise, go directly to step 3-2-3.

[0030] Furthermore, when d_angle is greater than the threshold angle_spin, the car needs to stop and rotate. The time lost in the process of turning includes the turning time rt_time. The turning time rt_time is calculated as follows: Determine the node based on the node ID in the motion information; Calculate the acceleration time t based on the properties - acc, acceleration angle θ - acc and deceleration time t - dec, deceleration angle θ - dec, calculated as: ; If the total angle θ_total of the acceleration and deceleration phases during the rotation process is greater than d_angle, the rotation process cannot reach the maximum angular velocity. At this time, the turning time rt_time is: ; When the angle is too small, the vehicle cannot reach its maximum speed, and thus there is no uniform speed. In this case, the rotation process becomes an acceleration to an intermediate value, and then a direct deceleration. This intermediate value is an intermediate variable in the calculation process, recorded as actual_speed.

[0031] If θ_total is less than or equal to d_angle, then there is a uniform speed phase in the rotation process, and the turning time rt_time is: ; Among them, θ_const is the angle passed during the uniform velocity phase.

[0032] If the node corresponding to the current state is the starting node, there is no previous segment, and therefore no deceleration. The lost time for turning, lost_time, includes the turning time rt_time and the lost time for starting acceleration, recorded as d_time_acc. The new_state_total_time is updated by adding the turning time rt_time corresponding to this state.

[0033] If the node corresponding to the current state is not the starting node, the lost time for turning, lost_time, includes not only the turning time rt_time and the acceleration loss time d_time_acc of the next road segment, but also the deceleration loss time d_time_dec of the previous road segment.

[0034] 3-2-3: Update the new state and the motion information of the new state. The motion information of the new state is recorded as new_state_motion_info. The specific update is: The node ID of the new state is updated to the end node of the adjacent edge, and the direction of the new state is updated to the end direction angle of the adjacent edge, which is expressed as follows: new_state.point_id=line.id_end; new_state.dire=line.dire_end; new_state.point_id represents the node ID of the new state, line.id_end represents the end node of the adjacent edge, new_state.dire represents the direction of the new state, and line.dire_end represents the end direction angle of the adjacent edge.

[0035] The total time of the state in the new state motion information is updated to the total time cost when reaching the new state through the adjacent edges, and the segment ID of the road to the new state is updated to the segment ID of the adjacent edge passed through. It is expressed as follows: new_state_motion_info.total_time=new_state_total_time; new_state_motion_info.line_id=line.line_id.

[0036] new_state_motion_info.total_time indicates the total time of the new state; new_state_total_time represents the total time cost of reaching the next state through the adjacent edge; new_state_motion_info.line_id indicates the ID of the road segment that reaches the new state; line.line_id represents the segment ID of the adjacent edge passed through.

[0037] 3-2-4: Determine whether there is a minimum time to reach the new state in the hash table min_cost. If so, go to 3-2-5, otherwise go to 3-2-6; 3-2-5: Determine whether the total time of the new state is less than the minimum time to reach the state recorded in the min_cost of the hash table. If so, proceed to 3-2-6, otherwise proceed to 3-2-7; if the total time of the new state is not less than the minimum time to reach the state recorded in the min_cost of the hash table, it means that the state already exists in the min_cost of the hash table, and the total time of the state of the previous path is shorter than the total time of the new state. In other words, the path corresponding to the total time of the new state is not a better path, and there is no need to continue state expansion. Therefore, the current state expansion can be ended.

[0038] 3-2-6: The new state and its motion information are added to the priority queue, and the min_cost, prev_line, and prev_state hash tables are updated synchronously, proceeding to 3-3. In other words, the new state of the previous text in the three hash tables is updated to the current state, and the current state of the previous text is updated to the previous state.

[0039] 3-2-7: Determine whether the priority queue is empty. If so, proceed to step 4; otherwise, return to 3-2-1.

[0040] 3-3: Perform state transfer and cost update.

[0041] The 3-3 step includes the following sub-steps: 3-3-1: Take the state with the smallest total state time from the priority queue and use it as the current state. The current state is recorded as cur_state, and the motion information of the current state is recorded as cur_state_motion_info.

[0042] 3-3-2: Perform pruning to determine whether the total state time of the current state is greater than the minimum time to reach the state recorded in the min_cost hash table. If so, trigger pruning, discard the state, and return to 3-3-1. Otherwise, proceed to 3-3-3. 3-3-3: End point detection, determine whether the node ID of the current state is equal to the node ID of the end point. If so, trigger edge backtracking and enter 3-3-4; otherwise, enter 3-3-5; 3-3-4: Edge backtracking, starting from the end state and tracing back to the starting node, obtains the previous edge that reaches this state through the hash table prev_line, and generates an edge sequence; 3-3-4 includes the following sub-steps: 3-3-4-1: Determine whether the total state time of the current state is less than min_total_time. If so, the current path is better and proceed to 3-3-4-2. If not, return to 3-3-1. The total state time of the current state is the cumulative total time cost from the vehicle's starting point to the current state, which can be recorded as cur_state_motion_info.total_time. 3-3-4-2: Update the value of min_total_time to the total time of the current state, obtain the segment ID of the previous edge that reaches the current state from the hash table prev_line, and add it to best_lines_id_list; 3-3-4-3: Determine whether the starting node of the current edge is equal to the starting point of the vehicle. If so, go to step 4; otherwise, go to 3-3-4-4; 3-3-4-4: Update the current state cur_state to the previous state recorded in the hash table prev_state, and return to step 3-3-4-2; 3-3-5: Determine whether the priority queue is empty. If so, proceed to step 4; otherwise, return to 3-2-1.

[0043] Through orderly state processing, invalid path filtering (i.e. pruning), and optimal path tracing (i.e. edge backtracking), we can efficiently find the path with the "minimum total state time" in complex state space while avoiding invalid calculations and redundant exploration.

[0044] The step 4 includes the following sub-steps: 4-1: Take the first road segment ID from best_lines_id_list and get the corresponding edge; 4-2: Add the terminal node ID of the corresponding edge to the node sequence; 4-3: Determine whether the current segment ID is the last element of best_lines_id_list. If so, add the starting node of the edge to the node sequence and output the node sequence; if not, obtain the next segment ID, obtain the corresponding edge, and repeat 4-2; 4-4: Reverse the output node sequence to obtain the final planned path. Since best_lines_id_list is the reverse order edge sequence from the end point to the starting point obtained by backtracking, the node sequence is reversed to obtain the planned path from the starting point to the end point in the normal order.

[0045] Example 2 The route network in this embodiment is as follows Figure 4 As shown in the figure, 0-6 are node IDs respectively. The known attribute values ​​on the nodes are shown in Table 3, and the known attribute values ​​on the routes are shown in Table 4.

[0046] Table 3 Known attribute values ​​on nodes

[0047] Table 4 Known attribute values ​​on the route

[0048] The initial position of the AGV is at node 0 and the direction is 90 degrees.

[0049] Set the angle threshold for parking and steering to angle_spin=10; At this time, it is necessary to plan the most efficient path from node 0 to node 2.

[0050] Result analysis: The path planning was performed using the present invention and the traditional Dijkstra algorithm, and the comparison results with the two comparison paths are shown in Table 5.

[0051] Table 5 Comparison results

[0052] As can be seen from the table above, the result obtained by the traditional method is the best in terms of distance, but it is affected by parking and turning, resulting in it not being the shortest path. On the other hand, the result obtained by the present invention, although not the shortest in distance, fully considers the influence of turning, acceleration and deceleration, and the result obtained is the shortest in time, which is the most efficient path.

[0053] Based on this, the present invention performs graph search with the goal of minimizing the total time: the AGV direction is incorporated into the state variable, that is, the state space is defined by the <node, direction> tuple to ensure the continuity of the path direction.

[0054] During path search, when the direction change at a node exceeds a threshold, the loss time calculation is triggered. The rotation time is dynamically calculated based on the node's rotation performance parameters (such as maximum angular velocity, angular acceleration, and angular deceleration).

[0055] The acceleration and deceleration loss time includes the deceleration time of the road section before the node and the acceleration time of the road section after the node. The specific value is dynamically calculated based on the road section length and linear acceleration constraints.

[0056] The total time consumed is used as the weight of the path search, and the total time consumed = the full uniform speed driving time + the loss time.

[0057] This application quantifies rotation and acceleration / deceleration losses, making the total path time more realistic and the time estimation more accurate. This application supports rotation performance parameters for different vehicles / nodes, is highly versatile, and has dynamic adaptability. Compared with traditional algorithms, this invention uses time consumption as a weight, and the planned path consumes less time, making actual operation more efficient.

[0058] The above descriptions are merely optional embodiments of the present invention and do not limit the patent scope of the present invention. All equivalent structural transformations made using the contents of the present invention specification under the concept of the present invention, or direct / indirect applications in other related technical fields are included in the patent protection scope of the present invention.

Claims

1. The AGV path planning method based on dynamic spatiotemporal state extension Dijkstra is characterized by: The steps include: Step 1: Topology map modeling, creating a data model containing nodes and edges, and configuring corresponding attributes for both nodes and edges; Step 2: Initialize the attributes and calculate the node adjacency list, the direction angle of each edge, the edge length, the shortest travel time, and the acceleration and deceleration loss time; Step 3: Path search and planning is performed based on the improved Dijkstra algorithm. Through state expansion, cost calculation, and state transition, combined with priority queues and hash tables, the optimal path is searched with the total time taken as the weight. Step 4: Based on the planned optimal path, obtain the node sequence and generate the planned path.

2. The AGV path planning method based on dynamic spatiotemporal state extended Dijkstra according to claim 1 is characterized in that: The node in step 1 represents the intersection and serves as a rotation time-consuming calculation primitive. The attributes of the node include node ID, node coordinates (x, y), maximum angular velocity, angular acceleration, angular deceleration, and adjacency list. The edge represents a road segment, and the edge incorporates acceleration and deceleration time. The set of edges is recorded as an edge list. The attributes of each edge include road segment ID, starting node ID, ending node ID, starting direction angle, ending direction angle, maximum linear speed, linear acceleration, linear deceleration, shortest travel time and additional acceleration and deceleration loss time.

3. The AGV path planning method based on dynamic spatiotemporal state extended Dijkstra according to claim 2 is characterized in that: The step 2 includes the following sub-steps: Step 2-1: Initialize the adjacency table, traverse the edge list, find the starting node of the edge according to the starting node ID, and add the segment ID of the edge to the corresponding starting node in the adjacency table; Step 2-2: Initialize the direction angle and various time attributes of each edge.

4. The AGV path planning method based on dynamic spatiotemporal state extended Dijkstra according to claim 3 is characterized in that: The step 2-2 includes the following sub-steps: Step 2-2-1: Find the starting node of the edge according to the starting node ID, find the ending node of the edge according to the ending node ID, and calculate the starting direction angle and the ending direction angle; Step 2-2-2: Calculate the length of the side, and calculate the shortest travel time and acceleration and deceleration loss time based on the side length.

5. The AGV path planning method based on dynamic spatiotemporal state extended Dijkstra according to claim 4 is characterized in that: The step 3 includes the following sub-steps: 3-1: Initialization: Convert static nodes into an expandable state set, create a hash table and priority queue to store relevant state information, configure relevant variables, determine the angle threshold required for parking and turning, and vehicle initialization information; 3-2: Expand the state, traverse the adjacent edges of the current node, calculate the shortest total time to pass through the adjacent edges, generate a new state, and update the hash table and priority queue; 3-3: Perform state transfer and cost update.

6. The AGV path planning method based on dynamic spatiotemporal state extended Dijkstra according to claim 5 is characterized in that: The above 3-1 includes the following sub-steps: 3-1-1: Create hash tables min_cost, prev_line, and prev_state to record the relevant information of each state. The hash table min_cost is used to record the minimum time to reach the state, the hash table prev_line is used to record the previous edge to reach the state, and the hash table prev_state is used to record the previous state to reach the state. Each state includes the node ID and state direction of the state; 3-1-2: Create a priority queue to store the state and its motion information motion_info, which includes the total state time of the state and the road segment ID to reach the state; 3-1-3: Create a variable best_lines_id_list to store the edge IDs of the planned optimal path; Create a variable min_total_time to represent the total time taken to plan the optimal path; 3-1-4: Set the angle threshold required for parking and turning to angle_spin. The vehicle starting point ID is known to be id_point_start, and the initial direction angle is dire_start. The current state includes the current state node ID and the current state direction angle information.

7. The AGV path planning method based on dynamic spatiotemporal state extended Dijkstra according to claim 6, characterized in that: The 3-2 step includes the following sub-steps: 3-2-1: Traverse the adjacency table corresponding to the node in the current state, obtain each adjacent edge of the node, create a new state corresponding to each adjacent edge, and calculate the total time to reach the new state through the adjacent edges; 3-2-2: Calculate the angle difference d_angle between the current state direction angle and the starting direction angle of the adjacent edge, and determine whether d_angle is greater than the threshold angle_spin. If so, add the time consumed by the turn to the total time of the new state to update the total time of the new state, and then go to step 3-2-3. Otherwise, go directly to step 3-2-3. 3-2-3: Update the new state and the motion information of the new state; 3-2-4: Determine whether there is a minimum time to reach the new state in the hash table min_cost. If so, go to 3-2-5, otherwise go to 3-2-6; 3-2-5: Determine whether the total time of the new state is less than the minimum time to reach the state recorded in the hash table min_cost. If so, go to 3-2-6, otherwise go to 3-2-7; 3-2-6: Add the new state and its motion information to the priority queue, update the hash tables min_cost, prev_line, and prev_state synchronously, and go to 3-3; 3-2-7: Determine whether the priority queue is empty. If so, proceed to step 4; otherwise, return to 3-2-1.

8. The AGV path planning method based on dynamic spatiotemporal state extended Dijkstra according to claim 7 is characterized in that: The 3-3 step includes the following sub-steps: 3-3-1: Take the state with the smallest total state time from the priority queue and use it as the current state; 3-3-2: Perform pruning to determine whether the total state time of the current state is greater than the minimum time to reach the state recorded in the min_cost hash table. If so, trigger pruning, discard the state, and return to 3-3-1. Otherwise, proceed to 3-3-3. 3-3-3: End point detection, determine whether the node ID of the current state is equal to the node ID of the end point. If so, trigger edge backtracking and enter 3-3-4; otherwise, enter 3-3-5; 3-3-4: Edge backtracking, starting from the end state and tracing back to the starting node, obtain the previous edge that reaches this state through the hash table prev_line, and generate an edge sequence; 3-3-5: Determine whether the priority queue is empty. If so, proceed to step 4; otherwise, return to 3-2-1.

9. The AGV path planning method based on dynamic spatiotemporal state extended Dijkstra according to claim 8, characterized in that: The 3-3-4 includes the following sub-steps: 3-3-4-1: Determine whether the total state time of the current state is less than min_total_time. If so, it means that the current path is better and proceed to 3-3-4-2; if not, return to 3-3-1; 3-3-4-2: Update the value of min_total_time to the total time of the current state, obtain the segment ID of the previous edge that reaches the current state from the hash table prev_line, and add it to best_lines_id_list; 3-3-4-3: Determine whether the starting node of the current edge is equal to the starting point of the vehicle. If so, go to step 4; otherwise, go to 3-3-4-4; 3-3-4-4: Update the current state cur_state to the previous state recorded in the hash table prev_state and return to step 3-3-4-2.

10. The AGV path planning method based on dynamic spatiotemporal state extended Dijkstra according to claim 9, characterized in that: The step 4 includes the following sub-steps: 4-1: Take the first road segment ID from best_lines_id_list and get the corresponding edge; 4-2: Add the terminal node ID of the corresponding edge to the node sequence; 4-3: Determine whether the segment ID is the last element of best_lines_id_list. If so, add the starting node of the edge to the node sequence and output the node sequence, and go to 4-4; if not, get the next segment ID, get the corresponding edge, and repeat 4-2; 4-4: Reverse the output node sequence to obtain the final planned path.

Images