AGV path planning method based on dynamic space-time state extended dijkstra

Abstract

The application 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: topological map modeling, a data model containing nodes and edges is created, and the nodes and the edges are both configured with corresponding attributes; step 2: attribute initialization, the adjacency list of the nodes, the directional angle of each edge, the edge length, the shortest passing time and the acceleration and deceleration loss time are calculated; step 3: path search planning based on the improved Dijkstra algorithm, the optimal path is searched with the total time consumption as the weight through state expansion, cost calculation and state transition, in combination with a priority queue and a hash table; and step 4: according to the planned optimal path, the node sequence from the starting point to the ending point is acquired, and the path is generated, so that the time-optimal path search in a real scene is realized.

Description

TECHNICAL FIELD

[0001] The application relates to the technical field of path planning, in particular to an AGV path planning method based on dynamic space-time state expansion Dijkstra. BACKGROUND

[0002] With the rapid development of intelligent manufacturing and logistics automation, the application of automatic guided vehicle (AGV) in warehouse, factory and other scenarios is becoming more and more widespread. As the core technology of AGV efficient operation, path planning directly affects the logistics efficiency and system stability. Traditional path planning methods, such as Dijkstra algorithm and its improved version, are mostly based on the assumption of static road network, and the path is regarded as a simple connection of nodes and edges, ignoring the actual motion characteristics of AGV, such as acceleration and deceleration process and turning time loss, resulting in a large deviation between the planned path and the actual operation.

[0003] Although some existing technologies consider the kinematic constraints of AGV, they use simplified models, such as assuming that AGV can instantly reach the target speed, the turning process has no time loss, or only relying on the preset fixed speed to calculate the passing time. This makes the planned path unable to achieve time optimization in actual application, even leading to frequent start and stop of AGV, increased collision risk, and reduced system operation efficiency and reliability. In addition, traditional methods are prone to "dimension disaster" when dealing with complex topological networks, as the state space is not effectively compressed, resulting in high algorithm calculation complexity and poor real-time performance, which is 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 AGV and efficiently search for the optimal path. SUMMARY

[0004] The technical problem to be solved by the present application is to overcome the shortcomings of the prior art and provide an AGV path planning method based on dynamic space-time state expansion Dijkstra, which comprehensively calculates the driving time, rotation time and acceleration and deceleration loss time to realize time-optimal path search in real scenarios.

[0005] The application is implemented by the following technical scheme: the AGV path planning method based on dynamic space-time state expansion Dijkstra comprises the following steps:

[0006] Step 1: topological map modeling, creating a data model containing nodes and edges, and configuring corresponding attributes for nodes and edges;

[0007] Step 2: attribute initialization, calculating the adjacency list of nodes, the direction angle of each edge, the edge length, the shortest passing time and the acceleration and deceleration loss time;

[0008] Step 3: path search planning based on improved Dijkstra algorithm, searching for the optimal path by state expansion, cost calculation and state transition, combining priority queue and hash table, and taking the total time consumption as the weight.

[0009] Step 4: According to the optimal path planned, the node sequence is obtained, and the planned path is generated.

[0010] The node in the step 1 represents an intersection, and is taken as a rotation time-consuming calculation element. The attributes of the node include a node ID, a node coordinate (x, y), a maximum angular velocity, an angular acceleration, an angular deceleration, and an adjacency list.

[0011] The edge represents a road segment, and the edge is fused with acceleration and deceleration time consumption. The set of edges is denoted as an edge list. The attributes of each edge include a road segment ID, a starting node ID, a terminal node ID, a starting direction angle, a terminal direction angle, a maximum linear velocity, a linear acceleration, a linear deceleration, a shortest travel time, and an acceleration and deceleration additional loss time.

[0012] The step 2 includes the following sub-steps:

[0013] Step 2-1: The adjacency list is initialized, the edge list is traversed, the starting node of the edge is found according to the starting node ID, and the road segment ID of the edge is added to the starting node corresponding to the adjacency list.

[0014] Step 2-2: The direction angle and the time attributes of each edge are initialized.

[0015] The step 2-2 includes the following sub-steps:

[0016] Step 2-2-1: The starting node of the edge is found according to the starting node ID, the terminal node of the edge is found according to the terminal node ID, and the starting direction angle and the terminal direction angle are calculated.

[0017] Step 2-2-2: The length of the edge is calculated, and the shortest travel time and the acceleration and deceleration loss time are calculated based on the edge length.

[0018] The step 3 includes the following sub-steps:

[0019] 3-1: Initialization, conversion of static nodes to an extensible state set, creation of a hash table and a priority queue for storing related state information, configuration of related variables, determination of an angle threshold value requiring a stop and turn, and vehicle initialization information.

[0020] 3-2: State expansion, traversal of the adjacency edges of the current node, calculation of the shortest total time consumption through the adjacency edges, generation of a new state, and update of the hash table and the priority queue.

[0021] 3-3: State transition and cost update.

[0022] The step 3-1 includes the following sub-steps:

[0023] 3-1-1: Create hash tables min_cost, prev_line, and prev_state to record the relevant information of each state 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 last edge to reach the state, and the hash table prev_state is used to record the last state to reach the state. Each state includes the node ID and state direction of the state;

[0024] 3-1-2: Create a priority queue to store states and their motion information motion_info, which includes the state total time and the road segment ID to reach the state.

[0025] 3-1-3: Create a variable best_lines_id_list to store the edge IDs of the planned optimal path.

[0026] Create a variable min_total_time to represent the total time of the planned optimal path.

[0027] 3-1-4: Set the angle threshold for the need to stop and turn as angle_spin. Given the vehicle start ID as id_point_start and the initial direction angle as dire_start, the current state includes the current state node ID and the current state direction angle information.

[0028] The 3-2 includes the following sub-steps:

[0029] 3-2-1: Traverse the adjacency list corresponding to the node in the current state to obtain each adjacent edge of the node, create a new state corresponding to each adjacent edge, and calculate the total time cost when passing through the adjacent edge to reach the new state.

[0030] 3-2-2: Calculate the angle difference d_angle between the current state direction angle and the adjacent line starting direction angle. If d_angle is greater than the threshold angle_spin, add the time lost by 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.

[0031] 3-2-3: Update the new state and its motion information.

[0032] 3-2-4: Determine whether there is a minimum time to reach the new state in the hash table min_cost. If yes, go to 3-2-5, otherwise go to 3-2-6.

[0033] 3-2-5: judge whether the new state total time of the new state is less than the minimum time recorded in the hash table min_cost to reach the state, if yes, go to 3-2-6, otherwise go to 3-2-7;

[0034] 3-2-6: add the new state and its motion information to the priority queue, and update the hash table min_cost, prev_line and prev_state synchronously, and go to 3-3;

[0035] 3-2-7: judge whether the priority queue is empty, if yes, go to step 4, otherwise return to 3-2-1.

[0036] The 3-3 includes the following sub-steps:

[0037] 3-3-1: take out the state with the minimum state total time from the priority queue as the current state;

[0038] 3-3-2: perform pruning processing, judge whether the state total time of the current state is greater than the minimum time recorded in the hash table min_cost to reach the state, if yes, trigger pruning, discard the state, and return to 3-3-1, otherwise go to 3-3-3;

[0039] 3-3-3: end point detection, judge whether the node ID of the current state is equal to the node ID of the end point, if yes, trigger edge backtracking, and go to 3-3-4, otherwise go to 3-3-5;

[0040] 3-3-4: edge backtracking, start from the end state and trace back to the starting node in reverse, obtain the last edge to reach the state through the hash table prev_line, and generate an edge sequence;

[0041] 3-3-5: judge whether the priority queue is empty, if yes, go to step 4, otherwise return to 3-2-1.

[0042] The 3-3-4 includes the following sub-steps:

[0043] 3-3-4-1: judge whether the state total time of the current state is less than min_total_time, if yes, it means that the current path is better, go to 3-3-4-2, otherwise return to 3-3-1;

[0044] 3-3-4-2: update the value of min_total_time to the state total time of the current state, obtain the road section ID of the last edge to reach the current state from the hash table prev_line, and add it to the best_lines_id_list;

[0045] 3-3-4-3: judge whether the starting node of the current edge is equal to the vehicle starting point, if yes, go to step 4, if not, go to 3-3-4-4;

[0046] 3-3-4-4: update the current state cur_state to the last state recorded in the hash table prev_state, and return to step 3-3-4-2;

[0047] The step 4 includes the following sub-steps:

[0048] 4-1: take the first road segment ID from the best_lines_id_list, and get the corresponding edge;

[0049] 4-2: add the terminal node ID of the corresponding edge to the node sequence;

[0050] 4-3: judge whether the road segment ID is the last element of the best_lines_id_list, if yes, 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 road segment ID, get the corresponding edge, and repeat 4-2;

[0051] 4-4: perform a reverse operation on the output node sequence to obtain the final planning path.

[0052] Compared with the prior art, the beneficial effects of the present application are:

[0053] The AGV path planning method based on dynamic space-time state expansion Dijkstra proposed in the present application models the path network as a topological graph structure that integrates acceleration and deceleration time consumption and turning time, accurately quantifies the time loss in the AGV movement process, avoids the "ideal movement" assumption in traditional methods, makes the planning path more consistent with the actual running scene, and greatly improves the accuracy and reliability of path planning.

[0054] The method innovatively introduces a "dynamic space-time state expansion" mechanism, combines a hash table with a priority queue to realize efficient management and pruning optimization of the state space, reduces the time complexity of the algorithm, significantly improves the path search efficiency, and can meet the real-time planning requirements under large-scale complex topological networks.

[0055] The method separates the node and edge line attributes, respectively configures the rotation performance and movement parameters, so that the path planning can flexibly adapt to the movement characteristics of different types of AGVs, enhances the universality and expandability of the algorithm, and provides more efficient and reliable technical support for intelligent manufacturing and smart logistics. BRIEF DESCRIPTION OF DRAWINGS

[0056] Figure 1 is a flowchart of the method;

[0057] Figure 2 is a path search planning flowchart of step 3 of the method;

[0058] Figure 3 is a sideline backtracking flowchart in step 3;

[0059] Figure 4 is a schematic diagram of an AGV route network in embodiment 2. DETAILED DESCRIPTION

[0060] The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative labor fall within the scope of protection of the present application.

[0061] Embodiment 1

[0062] Referring to Figures 1-3 The AGV path planning method based on dynamic space-time state expansion Dijkstra includes the following steps:

[0063] Step 1: topological map modeling, creating a data model containing nodes and edges, and configuring corresponding attributes for the nodes and edges;

[0064] Step 2: attribute initialization, calculating the adjacency table of the nodes, the direction angle of each edge, the edge length, the shortest travel time, and the acceleration and deceleration loss time, etc.

[0065] Step 3: path search planning based on improved Dijkstra algorithm, searching the optimal path with total time consumption as the weight through state expansion, cost calculation and state transition, combining priority queue and hash table;

[0066] Step 4: according to the planned optimal path, obtaining the node sequence and generating the planned path.

[0067] Further, the node in step 1 represents an intersection, and is a rotation time consumption calculation primitive. The attributes of the node include node ID, node coordinates (x, y), maximum angular velocity, angular acceleration, angular deceleration, and adjacency table, as shown in Table 1:

[0068] Table 1 Node attribute table

[0069]

[0070] The edge represents a road segment, the edge fusion acceleration and deceleration time consumption, and the set of edges is denoted as an edge list. The attributes of each edge include a road segment ID, a starting node ID, a terminal node ID, a starting direction angle, a terminal direction angle, a maximum linear speed, a linear acceleration, a linear deceleration, a shortest travel time, and an acceleration and deceleration additional time loss. Details are shown in Table 2.

[0071] Table 2 Edge attribute table

[0072]

[0073] The step 2 includes the following sub-steps:

[0074] Step 2-1: Initialize the adjacency list, traverse the edge list, find the starting node of the edge according to the starting node ID, and add the road segment ID of the edge to the starting node of the corresponding edge in the adjacency list to indicate that the node can pass to the current edge.

[0075] Step 2-2: Initialize the direction angle and time attributes of each edge. Traverse the edge list and calculate the relevant attributes of each edge. Specifically, the step 2-2 includes the following sub-steps:

[0076] Step 2-2-1: Find the starting node of the edge according to the starting node ID, find the terminal node of the edge according to the terminal node ID, calculate the starting direction angle and the terminal direction angle, and the calculation formula is as follows:

[0077] ;

[0078] In the formula, dire_start represents the starting direction angle, dire_end represents the terminal direction angle, p_end represents the terminal node of the edge, p_start represents the starting node of the edge, x and y are coordinates, p_end.y represents the y coordinate of the terminal 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 terminal node of the edge, and p_start.x represents the x coordinate of the starting node of the edge.

[0079] Step 2-2-2: Calculate the length of the edge, and calculate the shortest travel time time - min and the acceleration and deceleration time loss based on the length of the edge. The calculation process in the step 2-2-2 is as follows:

[0080] 2-2-2-1: Calculate the length of the edge length, and the calculation formula is as follows:

[0081] ;

[0082] 2-2-2-2: Calculate the shortest travel time time - min, and the calculation formula is as follows:

[0083] ;

[0084] 2-2-2-3: Calculate the acceleration and deceleration time loss, compare the distance required to achieve acceleration or deceleration with the side length, determine whether the side can complete acceleration, and calculate the acceleration and deceleration time loss in different ways according to the determination result.

[0085] Specifically, AGV has an acceleration process (from static to maximum speed) and a deceleration process (deceleration to zero before turning or parking) when driving. If the side length is long enough, the AGV can complete acceleration and maintain uniform speed on the road segment; if the side is too short, it cannot reach the maximum speed, and the acceleration and deceleration time loss needs to be calculated by different formulas. Take the acceleration time loss d_time_acc as an example, the calculation formula is as follows:

[0086] ;

[0087] Based on this, first, the time t_acc and distance s_acc required to accelerate to the maximum speed need to be calculated, and the calculation formula is:

[0088] ;

[0089] The calculation method of deceleration time loss d_time_dec is similar to that of acceleration time loss d_time_acc, replacing the linear acceleration line_acc with the linear deceleration line_dec, that is:

[0090] ;

[0091] ;

[0092] t_dec and distance s_dec are the time and distance required to decelerate to 0, line_dec is the linear deceleration, acc and dec are acceleration and deceleration respectively.

[0093] The step 3 includes the following sub-steps:

[0094] 3-1: initialization; convert static nodes to extensible state set, create hash table and priority queue for storing related state information, configure related variables, determine the angle threshold of parking and turning and vehicle initialization information; further, the 3-1 includes the following sub-steps:

[0095] 3-1-1: Create hash tables min_cost, prev_line, and prev_state to record the relevant information of each state. min_cost records the minimum time to reach the state; prev_line records the last edge to reach the state; prev_state records the last state to reach the state. The state is denoted as state, and each state includes the node ID of the state and the state direction. The node ID of the state is denoted as state.point_id, and the state direction is denoted as state.dire;

[0096] 3-1-2: Create a priority queue pq to store states state and their motion information. The motion information is denoted as motion_info, which includes the total time of the state and the road segment ID to reach the state. The total time of the state is denoted as motion_info.total_time, and its initial value is 0. The road segment ID to reach the state is denoted as motion_info.line_id. The state is not fixed but changes dynamically during the path search process. The total time of the state represents the total time spent from the starting point to the node corresponding to the state. Since there may be multiple paths from the starting point to the node, the total time of the state corresponding to different paths is also different. That is, the same state may have multiple reachable paths, and each path corresponds to a total time of the state.

[0097] 3-1-3: Create a variable best_lines_id_list to store the edge IDs of the planned optimal path;

[0098] Create a variable min_total_time to represent the total time spent on the planned optimal path;

[0099] 3-1-4: Set the angle threshold for parking and turning as angle_spin. Given the starting point ID of the vehicle as id_point_start and the initial direction angle as dire_start, the current state includes the current state node ID and the current state direction angle information. The current state is denoted as cur_state, the current state node ID is denoted as cur_state.point_id, and the current state direction angle is denoted as cur_state.dire. The following relationships hold: -

[0100] cur_state.point_id = id_point_start;

[0101] cur_state.dire = dire_start.

[0102] ​3-2: State expansion is performed, adjacent edges of the current node are traversed, the shortest total time consumption through the adjacent edges is calculated, a new state is generated, and a hash table and a priority queue are updated; 3-2 includes the following sub-steps:

[0103] 3-2-1: The adjacent table corresponding to the node in the current state is traversed, each adjacent edge of the node is obtained, a new state corresponding to each adjacent edge (that is, the next state based on the current state) is created, the new state is recorded as new_state, and the total time cost when the adjacent edge is reached is calculated. The total time cost is recorded as new_state_total_time. When the state is expanded, the total time of the new state is obtained by adding the time of the new road section and the loss time based on the total time of the current state. Total time cost = current total time + road section shortest travel time + loss time. The road section shortest travel time is the time when the vehicle maintains a uniform speed through the road section without changing speed, which is the shortest time for the vehicle to pass through the road section. In fact, the vehicle may slow down or speed up during the process, which affects the time of passing through the road section. The time loss involved in this process is calculated separately, thereby realizing the calculation of the total time of the new state.

[0104] For example, 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 the road section is recorded as time_min, and the loss time includes the loss time of starting acceleration, which is recorded as d_time_acc.

[0105] 3-2-2: Calculate the angle difference d_angle between the current state direction angle and the adjacent line starting direction angle, and the calculation formula is as follows:

[0106] ;

[0107] cur_state.dire is the current state direction angle, and line.dire_start is the adjacent line starting direction.

[0108] Determine whether the angle difference d_angle is greater than the threshold angle_spin. If yes, the loss time includes the time lost during turning, and the time lost during turning is recorded as lost_time. The time lost during turning is added to the total time cost to update the total time cost, and then step 3-2-3 is entered. Otherwise, step 3-2-3 is directly entered.

[0109] Further, when d_angle is greater than threshold angle_spin, the vehicle needs to be parked and rotated in direction. The time lost during turning lost_time includes turning time rt_time, and the turning time rt_time is calculated as follows:

[0110] Determine the node according to the node ID in the motion information

[0111] Calculate the acceleration time t according to the attribute - acc, acceleration angle θ - acc and deceleration time t - dec, deceleration angle θ - dec, the calculation formula is:

[0112] ;

[0113] If the total angle of the acceleration stage and the deceleration stage during the rotation process is greater than d_angle, the rotation process cannot reach the maximum angular velocity, and the steering time rt_time is:

[0114] ;

[0115] When the angle is too small, the vehicle cannot reach the maximum speed, and there is no uniform speed, in which case the rotation process becomes accelerating to a certain intermediate value, and then directly starting to decelerate. The intermediate value is an intermediate variable in the calculation process, denoted as actual_speed.

[0116] If θ_total is less than or equal to d_angle, the rotation process has a uniform speed stage, and the steering time rt_time is:

[0117] ;

[0118] Where θ_const is the angle passed through the uniform speed stage.

[0119] If the node corresponding to the current state is the starting node, there is no previous section, and there is no problem of deceleration in the previous section. The time lost during steering lost_time includes the steering time rt_time and the loss time of starting acceleration denoted as d_time_acc. The new_state_total_time is updated by adding the steering time rt_time corresponding to the state.

[0120] If the node corresponding to the current state is not the starting node, the time lost during steering lost_time includes the steering time rt_time and the acceleration loss time d_time_acc of the next section, and also includes the deceleration loss time d_time_dec of the previous section.

[0121] 3-2-3: Update the new state and the motion information of the new state, denoted as new_state_motion_info, and the specific update is:

[0122] The node ID of the new state is updated as the end node of the adjacent edge, and the direction of the new state is updated as the end direction angle of the adjacent edge, which is represented as follows:

[0123] new_state.point_id = line.id_end;

[0124] new_state.dire = line.dire_end;

[0125] 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.

[0126] The total time of the new state motion information is updated as the total time cost when reaching the new state through the adjacent edge, and the road segment ID reaching the new state is updated as the road segment ID of the adjacent edge passed. It is represented as follows:

[0127] new_state_motion_info.total_time = new_state_total_time;

[0128] new_state_motion_info.line_id = line.line_id.

[0129] new_state_motion_info.total_time represents the total time of the new state;

[0130] new_state_total_time represents the total time cost when reaching the next state through the adjacent edge;

[0131] new_state_motion_info.line_id represents the road segment ID reaching the new state;

[0132] line.line_id represents the road segment ID of the adjacent edge passed.

[0133] 3-2-4: Determine whether there is a minimum time to reach the new state in the hash table min_cost. If yes, go to 3-2-5, otherwise go to 3-2-6;

[0134] 3-2-5: judging whether the new state total time of the new state is less than the minimum time recorded in the hash table min_cost to reach the state, if yes, entering 3-2-6, otherwise entering 3-2-7; if the new state total time of the new state is not less than the minimum time recorded in the hash table min_cost to reach the state, it is indicated that the hash table min_cost has the state, and the state total time of the previous path is shorter than the new state total time, that is, the path corresponding to the new state total time is not the optimal path, and there is no need to continue state expansion, so the current state expansion can be ended.

[0135] 3-2-6: adding the new state and its motion information to the priority queue, synchronously updating the hash table min_cost, prev_line and prev_state, and entering 3-3. That is, the new state new_state in the three hash tables is updated to the current state, and the current state is updated to the previous state.

[0136] 3-2-7: judging whether the priority queue is empty, if yes, entering step 4, otherwise returning to 3-2-1.

[0137] 3-3: performing state transition and cost update.

[0138] The 3-3 includes the following sub-steps:

[0139] 3-3-1: taking out the state with the minimum state total time from the priority queue as the current state, and recording the current state as cur_state and the motion information of the current state as cur_state_motion_info.

[0140] 3-3-2: performing pruning processing, judging whether the state total time of the current state is greater than the minimum time recorded in the hash table min_cost to reach the state, if yes, triggering pruning, discarding the state, and returning to 3-3-1, otherwise entering 3-3-3;

[0141] 3-3-3: end point detection, judging whether the node ID of the current state is equal to the node ID of the end point, if yes, triggering edge backtracking, and entering 3-3-4, otherwise entering 3-3-5;

[0142] 3-3-4: edge backtracking, starting from the end state and tracing back to the starting node in reverse, obtaining the previous edge to reach the state through the hash table prev_line, and generating an edge sequence; 3-3-4 includes the following sub-steps:

[0143] 3-3-4-1: judge whether the state total time of the current state is less than min_total_time, if yes, it means that the current path is better, go to 3-3-4-2; if no, return to 3-3-1; the state total time of the current state is the cumulative total time cost from the start point of the vehicle to the current state, which can be recorded as cur_state_motion_info.total_time;

[0144] 3-3-4-2: update the value of min_total_time as the state total time of the current state, get the road segment ID of the last edge reaching the current state from the hash table prev_line, and add it to best_lines_id_list;

[0145] 3-3-4-3: judge whether the start node of the current edge is equal to the start point of the vehicle, if yes, go to step 4; if no, go to 3-3-4-4;

[0146] 3-3-4-4: update the current state cur_state to the last state recorded in the hash table prev_state, and return to step 3-3-4-2;

[0147] 3-3-5: judge whether the priority queue is empty, if yes, go to step 4; if no, return to 3-2-1.

[0148] Through ordered state processing, invalid path filtering (i.e. pruning processing), optimal path tracing (i.e. edge backtracking), the path with the minimum state total time is efficiently found in a complex state space, while avoiding invalid calculation and redundant exploration.

[0149] The step 4 includes the following sub-steps:

[0150] 4-1: take out the first road segment ID from best_lines_id_list, and get the corresponding edge;

[0151] 4-2: add the terminal node ID of the corresponding edge to the node sequence;

[0152] 4-3: judge whether the current road segment ID is the last element of best_lines_id_list, if yes, add the start node of the edge to the node sequence and output the node sequence; if no, get the next road segment ID, get the corresponding edge, and repeat 4-2;

[0153] 4-4: perform reverse operation on the output node sequence, thereby obtaining the final planning path. Since best_lines_id_list is the reverse edge sequence from the end point to the start point obtained by edge backtracking, the node sequence is reversed to obtain the forward planning path from the start point to the end point.

[0154] Example 2

[0155] The route network of this example is shown in Figure 4 Table 3 Known attribute values on nodes

[0156] Table 3 Known attribute values on nodes

[0157]

[0158] Table 4 Known attribute values on routes

[0159]

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

[0161] The angle threshold value for parking and turning is set to angle_spin = 10;

[0162] At this time, a most efficient path from node 0 to node 2 needs to be planned.

[0163] Result analysis:

[0164] The path planning is performed using the present application and the traditional Dijkstra respectively, and the comparison results of the two paths are shown in Table 5.

[0165] Table 5 Comparison results

[0166]

[0167] As can be seen from the above table, the result obtained by the traditional method is optimal in distance, but is affected by parking and turning, resulting in a path that is not the shortest in time consumption. The result obtained by the present application, although not the shortest in distance, fully considers the effects of turning and acceleration and deceleration, and is the shortest in time consumption, which is the most efficient path.

[0168] Based on this, the present application performs graph search with the goal of minimizing total time: the direction of the AGV is included in the state variable, i.e., the state space is defined by a <node, direction> binary tuple, to ensure the continuity of the path direction.

[0169] When searching for a path, if the change in direction at a node exceeds the threshold value, the calculation of the time loss is triggered. The rotation time is dynamically calculated based on the node rotation performance parameters (such as maximum angular velocity, angular acceleration, and angular deceleration).

[0170] The acceleration and deceleration time loss includes the deceleration time of the previous section before the node and the acceleration time of the next section after the node, and the specific values are dynamically calculated based on the section length and linear acceleration constraints.

[0171] Taking total time consumption as the weight of path searching, the total time consumption = full uniform speed travel time + loss time.

[0172] The application quantifies rotation and acceleration / deceleration loss, the total path time is more in line with the actual situation, and the time estimation accuracy is higher; the application supports different vehicle / node rotation performance parameters, has strong universality, and has dynamic adaptability; compared with the traditional algorithm, the application takes time consumption as the weight, the planned path has short time consumption, and the actual operation is more efficient.

[0173] The above is only an optional embodiment of the application, and does not limit the patent range of the application, and any equivalent structural transformation, direct / indirect application in other related technical fields made by using the content of the application specification within the concept of the application are included in the patent protection range of the application.

Claims

1. A method for AGV path planning based on dynamic space-time state extended Dijkstra, characterized in that, Comprising the following steps: Step 1: topological map modeling, creating a data model containing nodes and edges, both of which are configured with corresponding attributes; the nodes in the step 1 represent intersections, serving as rotation time-consuming calculation primitives, and the attributes of the nodes include node ID, node coordinates (x, y), maximum angular velocity, angular acceleration, angular deceleration, and adjacency table; The edges represent road segments, and the edges are fused with acceleration and deceleration time consumption; the set of edges is denoted as an edge list, and the attributes of each edge include road segment ID, starting node ID, ending node ID, starting direction angle, ending direction angle, maximum linear velocity, linear acceleration, linear deceleration, shortest travel time, and acceleration and deceleration additional loss time; Step 2: attribute initialization, calculating the adjacency table of the nodes, the direction angle of each edge, the edge length, the shortest travel time, and the acceleration and deceleration loss time; Step 3: path search planning based on the improved Dijkstra algorithm, searching for the optimal path with total time consumption as the weight through state expansion, cost calculation, and state transition, combining priority queue and hash table; The step 3 comprises the following sub-steps: 3-1: initialization, converting static nodes into an expandable state set, creating hash tables min_cost, prev_line, prev_state, and a priority queue for storing related state information, configuring related variables, determining the angle threshold for stopping and turning, and vehicle initialization information; 3-2: state expansion, traversing the adjacency edges of the current node, calculating the shortest total time consumption through the adjacency edges, generating new states, and updating the hash table and the priority queue; 3-3: state transition and cost update; the 3-3 comprises the following sub-steps: 3-3-1: taking the state with the minimum state total time from the priority queue as the current state; 3-3-2: pruning processing, judging whether the state total time of the current state is greater than the minimum time recorded in the hash table min_cost to reach the state, if yes, triggering pruning, discarding the state, and returning to 3-3-1, otherwise, entering 3-3-3; 3-3-3: end point detection, judging whether the node ID of the current state is equal to the node ID of the end point, if yes, triggering edge backtracking, and entering 3-3-4; otherwise, entering 3-3-5; 3-3-4: edge backtracking, starting from the end state and reversing to the starting node, obtaining the previous edge to reach the state through the hash table prev_line, and generating an edge sequence; 3-3-5: judging whether the priority queue is empty, if yes, entering step 4; if not, returning to 3-2-1; Step 4: obtaining the node sequence and generating the planned path according to the planned optimal path. 2.The AGV path planning method based on dynamic space-time state expansion Dijkstra according to claim 1, wherein, The step 2 comprises the following sub-steps: Step 2-1: initializing the adjacency table, traversing the edge list, finding the starting node of the edge according to the starting node ID, and adding the road segment ID of the edge to the starting node of the adjacency table; Step 2-2: initializing the direction angle and time attributes of each edge. 3.The AGV path planning method based on dynamic space-time state expansion Dijkstra of claim 2, wherein, The step 2-2 comprises the following sub-steps: Step 2-2-1: find the start node of the edge according to the start node ID, find the end node of the edge according to the end node ID, calculate the start direction angle and the end direction angle; Step 2-2-2: calculate the length of the edge, calculate the shortest travel time and acceleration / deceleration loss time based on the length of the edge.

4. The AGV path planning method based on dynamic space-time state expansion Dijkstra according to claim 1, characterized in that, The 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 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 last edge to reach the state, and the hash table prev_state is used to record the last 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 states and their motion information motion_info, the motion information includes the state total 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 ID of the planned optimal path; Create a variable min_total_time to represent the total time of the planned optimal path; 3-1-4: set the angle threshold for the need to stop and turn as angle_spin, and the vehicle starting point ID as id_point_start and the initial direction angle as dire_start, then the current state includes the current state node ID and the current state direction angle information.

5. The AGV path planning method based on dynamic space-time state expansion Dijkstra according to claim 4, characterized in that, The 3-2 includes the following sub-steps: 3-2-1: traverse the adjacency list corresponding to the node in the current state to obtain each adjacent edge of the node, create a new state corresponding to each adjacent edge, and calculate the new state total time when passing through the adjacent edge to reach the new state; 3-2-2: calculate the angle difference d_angle between the current state direction angle and the start direction angle of the adjacent edge, and determine whether d_angle is greater than the threshold angle_spin, if yes, add the time lost by turning to the new state total time to update the new state total time, and then enter step 3-2-3, otherwise directly enter 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 yes, enter 3-2-5, otherwise enter 3-2-6; 3-2-5: determine whether the new state total time of the new state is less than the minimum time to reach the state recorded in the hash table min_cost, if yes, enter 3-2-6, otherwise enter 3-2-7; 3-2-6: add the new state and its motion information to the priority queue, and update the hash tables min_cost, prev_line and prev_state synchronously, and enter 3-3; 3-2-7: determine whether the priority queue is empty, if yes, enter step 4; if not, return to 3-2-1. 6.The AGV path planning method based on dynamic space-time state expansion Dijkstra of claim 4, wherein, The 3-3-4 includes the following sub-steps: 3-3-4-1: judge whether the state total time of the current state is less than min_total_time, if yes, it means that the current path is better, go to 3-3-4-2; if not, return to 3-3-1; 3-3-4-2: update the value of min_total_time as the state total time of the current state, get the road segment ID of the last edge to the current state from the hash table prev_line, and add it to best_lines_id_list; 3-3-4-3: judge whether the starting node of the current edge is equal to the vehicle starting point, if yes, go to step 4; if not, go to 3-3-4-4; 3-3-4-4: update the current state as the last state recorded in the hash table prev_state, and return to step 3-3-4-2.

7. The AGV path planning method based on dynamic space-time state expansion Dijkstra of claim 4, wherein, The step 4 includes the following sub-steps: 4-1: take out 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: judge whether the road segment ID is the last element of best_lines_id_list, if yes, 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 road segment ID, get the corresponding edge, and repeat 4-2; 4-4: perform reverse operation on the output node sequence to obtain the final planning path.

Images