*4.2. Velocity Planner*

The velocity planner determines the node expansion rule in the time domain and the potential node arrival instants. When one maneuver starts or finishes, the vehicle speed solely falls into one of three determined constants (*vhigh*, *vmid* and *vzero*), which correspond to high speed, mid speed, and zero speed. Figure 10 reports all possible velocity selections linked to the start and end of the maneuvers. *vhigh* can only be selected with the expansion pattern of going straight to fulfill the kinematic constraints given by Equations (1) and (2). The stop maneuver is an expansion of finite value solely on the time domain, it follows that only *vzero* can be applied to this action.

**Figure 10.** Velocity selections when one maneuver starts or ends.

The velocity level over one maneuver can only be linked to itself or an adjacent one, although all maneuvers can be arbitrarily linked along a trajectory. In other words, during one maneuver, the vehicle speed can maintain or alter among those three velocities, but the direct change between *vzero* and *vhigh* is illegal. For instance, if the vehicle finishes a series of going straight actions with speed *vzero*, its ending velocity of the last second action should then be *vmid* or *vzero*. Likewise, if turning follows going straight with an original velocity *vhigh*, the speed of the last going straight maneuver should reduce to *vmid* to gain an initial velocity *vmid* for turning.

Following the velocity selection rules, all possible speed variations through one maneuver are shown in Figure 11. It is noteworthy that the link of *vhigh*→Going straight→*vzero* and the opposite link are infeasible. Thus, 16 connection choices in total are applicable. Furthermore, velocity is merely an intermediate state used to determine a time dimension expansion, although it is a vital parameter for motion planning. The detailed velocity time history during one maneuver can be modeled by applying varied techniques to obtain the required initial and finishing speeds. In the current work, deceleration or acceleration along one action between the same velocity levels is modeled with identical time lengths, with the aim of simple calculation. The number of time expansion selections (cf. *T*<sup>e</sup> with *e* ∈ {1, 2 ··· , 12} in Table 1) thus reduces to 12.

**Figure 11.** Velocity variations through one maneuver.


**Table 1.** Node expansion selections in time domain.

The function FixMovingTime() determines time expansion data based on Table 2, which is elaborated as follows. When planning a trajectory, the maximum feasible velocities are consistently selected for all maneuvers with zero speed supplied to the start and end of the trajectory. With regard to one node expansion, three values of *thigh*,*p*, *tmid*,*<sup>p</sup>* and *tzero*,*<sup>p</sup>* are initially saved in the parent node as the possible start instant of the maneuver, and these respectively correspond to ending velocities of *vhigh*, *vmid*, and *vzero*, if they exist. In the cases where *vhigh* is not reachable, the value stored in *thigh*,*<sup>p</sup>* will be the minimum time length during the maneuver, with ending velocity *vmid*. Consequently, *thigh*,*<sup>p</sup>* = *tmid*,*p*. Similar result of *tmid*,*<sup>p</sup>* = *tzero*,*<sup>p</sup>* is obtained when the maximum realizable ending velocity is *vzero*. As the parent node is initialized, values of *thigh*,*c*, *tmid*,*c*, and *tzero*,*<sup>c</sup>* are derived and saved for the child node with the identical manner for the parent node. Furthermore, the starting velocity of a new expansion may be imposed as *vzero*, combined with the node expansion type of the previous maneuver. A stopping flag *μ* is then set as 1. Such a case happens when an expansion of stop occurs or moving direction of a vehicle is reversed. In the rest of the working conditions, the flag *μ* remains 0. Notably, a node is of four dimensions, *x*, *y*, *θ*, and *t*; among them, *t* is an index used in the graph search, and more than one value stored in one index could complicate the problem. Consequently, only the *vzero*-related time instant *tzero* is stored as the node index.


**Table 2.** Model-based approach for saving time consumption data.

Meanwhile, each node stores three ending time instants. Thus, one algorithm should be applied to select the exact ending instant of each node. This algorithm first chooses the minimum time *thigh* of each maneuver over the path. The deceleration phase is then imposed on the last two nodes of the trajectory, and the corresponding *tmid* and *tzero* are in turn assigned to these two nodes as the maneuver-finishing time instants. As the above methods are implemented from the start to the end of the initialized trajectory, a few modifications are imposed to fix the node time indices *t* in certain circumstances. For instance, when *μ* = 1, the maximum achievable ending time *tp* for the former maneuver node is determined by selecting the value of *tmid*,*p*. In this case, the ending velocity of this maneuver turns to be *vmid*. Meanwhile, in the same combination of maneuvers, if a previous maneuver exists and *tpp* > *tmid*,*pp*, *tmid*,*pp* is assigned to *tpp*, as the prior maneuver cannot achieve a higher velocity.

### *4.3. Collision Detection Strategy*

The pseudocode of the collision detection function DetectCollision() is recorded in Algorithm 3. A variable *γ* is used as a flag to indicate the validity of the node expansion as well as the type of collisions that may have occurred. When the current expansion *Nc* is valid, *γ* is set as 0. *γ* = 1 means that at least the ending pose of the expansion risks colliding, and *γ* = 2 signifies that the invalidity is only found in the link between the starting and final locations. This algorithm consists of two parts, which separately refer to collisions that occurred with ending and intermediate pose of the vehicle. As regards both circumstances, collisions should be avoided throughout *t* ∈ *tmid*,*p*, *tzero*,*<sup>c</sup>* .

**Algorithm 3:** Collision detection algorithm

*γ* ← DetectCollision **T**, *Nc*, *Pp*, *tp*, *Listopen*, *map* 1. Initialize *γ* ← 0 ; 2. *Pc* ← FindEndingPose *Pp*, *Nc* ; 3. *Pin* ← FindIntermediatePose *Pp*, *Nc* ; 4. **if** CheckStaticCollision(*Pc*, *map*) is **true**, **then** 5. *γ* ← 1 ; 6. **return**; 7. **end if** 8. *tzero*,*c*, *tmid*,*<sup>p</sup>* ← FixParkingTime *Pp*, *tp*, *Listopen*, *Nc* ; 9. [*Listcur*,1] ← FindFinalGrids *Pp*, *Nc* ; 10. [*Listother*] <sup>←</sup> FindObstaclesGrids **T**, *tzero*,*c*, *tmid*,*<sup>p</sup>* ; 11. **if** CheckDynamicCollision(*Listcur*,1, *Listother*) is **true**, **then** 12. *γ* ← 1 ; 13. **return**; 14. **end if** 15. **if** CheckStaticCollision(*Pin*, *map*) is **true**, **then** 16. *γ* ← 2 ; 17. **return**; 18. **end if** 19. [*Listcur*,2] ← FindIntermediateGrids *Pp*, *Nc* ; 20. **if** CheckDynamicCollision(*Listcur*,2, *Listother*) is **true**, **then** 21. *γ* ← 2 ; 22. **return**; 23. **end if** 24. **return**;

Static obstacles correspond to the walls of the shelves and warehouse, and the related collision detection method is expressed on lines 4 to 7 in Algorithm 3. FindEndingPose() is used to obtain the current pose *Pc*(*xc*, *yc*, *θc*) based on the parent pose *Pp xp*, *yp*, *θ<sup>p</sup>* and the current expansion manner *Nc*. The function CheckStaticCollision() is applied to check if collisions with static obstacles exist. This check is first judged by identifying the validity of the final pose. When it comes to maneuvers of turning and lane changing, an additional intermediate pose (cf. thick dashed rectangular in Figures 8 and 9), obtained through FindIntermediatePose(), should be further examined (cf. lines 15 to 18 in Algorithm 3). Focusing on the collision avoidance constraints formulation between the point *Qj* (*j* = 1, ··· , Nobs and Nobs denotes the obstacle point number) and the current investigated vehicle featuring vertexes *A*, *B*, *C* and *D*. A collision forms when *Qj* enters the rectangle *ABCD*. The restriction that *Qj* is located outside of the rectangle *ABCD* can be formulated by applying a triangle-area-based criterion [38],

$$\mathcal{S}\_{\triangle P\_i AB} + \mathcal{S}\_{\triangle P\_i BC} + \mathcal{S}\_{\triangle P\_i CD} + \mathcal{S}\_{\triangle P\_i DA} > \mathcal{S}\_{\square ABCD} \tag{11}$$

where *S*<sup>Δ</sup> indicates the triangle area, and ܵሕ refers to the rectangle area. Applying Equation (11) to every node expansion with respect to every obstacle point, the static obstacle collision judgement is yielded.

Dynamic obstacles in the current study are only forklifts, whose motions have been saved in **T**, and the function FixParkingTime() is applied to find *tmid*,*<sup>p</sup>* in *Listopen* and *tzero*,*<sup>c</sup>* by calling Table 2. As reported in Figures 8 and 9, the highlighted grids indicate the approximate area occupied during the movements of turning and lane changing. Similarly, the covered grids pertaining to other maneuvers in the same category can be determined by mirroring or rotating the highlighted grids (cf. Figures 8 and 9). The functions FindFinalGrids() and FindIntermediateGrids() are respectively used to record the covered grids of the final pose *Pc* and the intermediate pose *Pin* for the current node expansion patterns.

Without loss of generality, let us focus on the collision avoidance constraint formulation between the vehicle *ncurrent* and the vehicle *nk* (*ncurrent*, *nk* = 1, ··· , 4 and *ncurrent* = *nk*). The function FindObstaclesGrids() is first utilized to search for the covered grids by the vehicles *nk*, whose trajectories are not being planned, with respect to time. It is possible that no actions of the forklift *nk* have been determined during the period when the current maneuver of vehicle *ncurrent* could occupy. Under such circumstances, the grids that the vehicle *nk* finally parks are treated as the covered ones.

Finally, CheckDynamicCollision() is used to detect if *Listcur*,1 or *Listcur*,2 is going to simultaneously cover the grids already stored in *Listoth* over the valid time. Notably, during the collision detection, the current action is virtually regarded as the final maneuver with *vzero* set as the finishing velocity with *tzero*,*<sup>c</sup>* selected, thus an equal or longer time length of this maneuver in actual operation is considered. This treatment can enhance the safety performance to certain extents.

Notably, referring to Algorithm 3, the types of failure through an expansion have been noticed when one expansion has failed. This provides a tool to distinguish if one child node should be closed or skipped because that failure can be simply due to the intermediate trajectory of the action is interfered, while the corresponding child node could be valid in other situations.

#### *4.4. Trajectory Cost Function*

The function SetCost() is explained in this section. With regard to one node expansion, the cost function *f* is the sum of two parts, as reported in Equation (12),

$$f = \mathcal{g} + \mathcal{C}\_{11}h \tag{12}$$

in which *g* stands for the cumulative cost from the initial pose to the current pose and *h* indicates the estimated cost from the child node of the current expansion to the target node of the trajectory being defined. *C*<sup>11</sup> is a calibrated weighting aimed at achieving a balance between the computational resources used for searching and the resultant trajectory's quality. In total, it is expected that one forklift complete a delivery or return subtasks subjected to the minimum travelling time of *tf* − *ti* . Meanwhile, times of turning, lane changing, and speed inverse maneuvers should be minimized in order to reduce unnecessary movements, which may decrease the traffic capacity of the passages.

As far as the function of trajectory to the goal is concerned, Equation (13) is applied. We used the Manhattan distance plus another function of *θc*. Both the distance and the angle are evaluated in times of certain characteristic dimensions.

$$h = \left| \mathbf{x}\_{\mathcal{S}} - \mathbf{x}\_{\mathcal{c}} \right| / \Delta \mathbf{x} + \left| y\_{\mathcal{S}} - y\_{\mathcal{c}} \right| / \Delta y + \left| \theta\_{\mathcal{S}} - \theta\_{\mathcal{c}} \right| / (\pi / 2) \tag{13}$$

where Δ*x* = Δ*y*, indicating the grid side length; *xg*, *yg*, and *θ<sup>g</sup>* correspond to the goal space coordinates; *xc*, *yc*, and *θ<sup>c</sup>* refer to the coordinates of the current expansion child node.

The passed trajectory cost function that characterizes the time consumed from the starting pose of the trajectory to the current one writes:

$$\begin{cases} \ g = t\_{\text{zerro},c} - t\_{\text{i}} + p\\ \ p = p\_{\text{turn}} \cdot m\_{\text{turn}} + p\_{\text{lane}} \cdot m\_{\text{lamc}} + p\_{\text{inv}} \cdot m\_{\text{inv}} \end{cases} \tag{14}$$

where *pturn*, *plane*, and *pinv* respectively indicate the predefined penalties pertaining to single time of turning, lane changing, and speed inverse. *mturn*, *mlane*, and *minv* denote the cumulative number of corresponding maneuvers from the initial pose to the current child node along the trajectory being defined.

In addition, if one node originally stored in *Listopen* is reached a second time with a reduced value of *fc* during a node expansion compared to the previous saved *fpre* for the same nodes, the function ReplaceNode() is used to switch the parent node to the parent node of current expansion, with the aim of reducing calculation time length and optimizing the trajectory being planned.

#### **5. Joint Dispatching and Cooperative Trajectory Planning Framework**

The trajectories of forklift vehicles in the warehouse are sequentially determined in the complete cooperative operative algorithm (cf. Algorithm 4). Generally, the dispatching technique is first applied to select the current vehicle index as well as the goal coordinate in the space domain for the current trajectory planning subtask. Subsequently, an improved hybrid A\* search algorithm is used to determine all details pertaining to the newly planned trajectory **T**. The above methods are repeated until all stack locations in the warehouse are filled, as the warehouse filling state **F** is being updated.

The function CheckFilling() is used to derive the number of unfilled stacks. The function FindInitialPose() is then applied to find the parent node *Pp*, *tp* for the next expansion with minimum cost *f* found in *Listopen* and to simultaneously remove this node from *Listopen*.

A maximum number of iterations *itersearch* in the improved hybrid A\* algorithm is induced to break the endless iterations that may derive a trajectory involving an unacceptable waiting period. The improved hybrid A\* search algorithm is finished by satisfying any one of the three criteria, which are, respectively, the goal coordinate reached as a new child node, the iteration number exceeding *itersearch*, and no node saved in *Listopen*. Among them, only the first criterion indicates the trajectory of the current subtask is successfully planned, and a corresponding flag *σ* is thus set as 1 to declare this success.

The function GenerateTraj() is employed to generate the trajectory with the newly planned trajectory by backtracking from *Pf* to *Pi* with *tf* ,*zero* as the ending instants. During the backtracking, the maximum realizable velocities of the intermediate nodes are selected based on the manner depicted in Figure 11 and Table 2.

Finally, the function UpdateFillingState() updates **F** as the stack located at *Pf xf* , *yf* , *θ <sup>f</sup>* has been filled.


#### **6. Numerical Experiments**

Simulations of filling and emptying missions were conducted on the MATLAB 2021b platform, utilizing the parametric settings reported in Table 3. Each warehouse filling or emptying mission began with fully empty or filled initial conditions, respectively. The motion planning for each forklift in the simulation environment solely takes into account obstacles such as warehouse walls and other forklifts.

**Table 3.** Parametric settings regarding model and approach.



**Table 3.** *Cont.*

The simulation results are divided into two parts. The first part focuses on assessing the consistency of the motion planning strategy by presenting three short-time trajectories for multiple forklifts. In the second part, various dispatching strategies were benchmarked using different scores specifically designed for the current warehouse scenario. This evaluation was conducted to determine the performance and efficiency of different dispatching strategies in the given warehouse scenario.

#### *6.1. On the Performance of the Trajectory Planning Technique*

Figure 12 reports how forklift 1 returns to a picking station from shelf cluster *s*1, where it has just unloaded goods. Before the start of the scenario, forklifts 2 and 4 are in the same state of return, and forklift 3 is unloading in shelf cluster *s*4. When the scene in Figure 12 starts, forklift 1 accelerates and decelerates to reverse to the entrance of shelf cluster *s*1. At the meantime, forklift 4 turns and heads to the picking station *p*4, leaving the crossing of the wide passages empty. With the purple square showing the newly filled stack, forklift 3 leaves shelf cluster *s*<sup>4</sup> and enters *s*<sup>3</sup> to finish turning round. When it is inside of *s*3, forklift 1 goes through the passage between *s*<sup>3</sup> and *s*4. Subsequently, forklift 1 reverses and turns to the picking station *p*2, and forklift 3 then enters the wide passages to return to the assigned picking station, which is *p*3. Finally, forklift 2 is the first vehicle that arrives at the crossing area of wide passages with the goods picked. During the scenario, all trajectories are directly determined by means of the approach elaborated on in Section 4. The least priority is dynamically offered to the newly departed vehicle. For instance, in this scenario, forklift 3 initially has the lowest priority. Thus, it should judge if there is enough time for the vehicle to turn around. Therefore, if the time is limited, vehicle 3 would wait at the entrance of *s*4, until the passing of forklift 1.

Figure 13 shows how the last stack is filled. Because there is nowhere to be filled hereafter, forklift 3 is parked in one picking station, and forklift 1 heads to picking station *s*<sup>4</sup> and stops. Initially, forklift 4 has just finished one unloading process, then it enters shelf cluster *s*<sup>2</sup> to turn over. After forklift 4 leaves *s*2, forklift 2 enters the shelf cluster to complete the last delivery subtask. Meanwhile, forklift 4 accelerates, decelerates, and turns to picking station *s*<sup>3</sup> for final parking.

Figure 14 shows a scenario where the trajectory decision for forklift 3 encounters a failure. In this case, forklift 1 reaches shelf *s*<sup>4</sup> to unload goods, while forklift 3 completes its unloading process earlier than forklift 1. Consequently, forklift 3 should be assigned a higher priority to plan the trajectory based on function rank(). However, at this moment, forklift 1 remains stationed at the entrance of shelf *s*4, obstructing the passage for forklift 3. As a result, a decision failure occurs, leading to an update in the trajectory planning priority stored in **R**. Only after the completion of the trajectory planning for forklift 1 can the trajectory planning for forklift 3 proceed accordingly.

**Figure 12.** Planned trajectories between *t* = 687.25 s and *t* = 715.25 s.

**Figure 13.** Planned trajectories between *t* = 2327.25 s and *t* = 2354.50 s.

**Figure 14.** Planned trajectories between *t* = 284.75 s and *t* = 303.75 s.

#### *6.2. On the Performance of Dispatching Strategies*

Table 4 benchmarks five distinct dispatching strategies for both filling and emptying tasks. It is worth noting that these dispatching methods are applicable only to specific coupling scenarios between grids and vehicle maneuvers, as they incorporate a preliminary A\* search during the dispatching process.


**Table 4.** Benchmark of the different dispatching strategies.

The approaches differ in the assignment methods pertaining to delivering subtasks. While the decision failure times in Table 4 indicate the number of times *ncurrent* or *ti* is changed without a solid trajectory decided throughout the entire warehouse filling mission, the end time is the finishing timing of the same task. Among the strategies, ANN combined determines the goal through arg max(*Sd*) (cf. *Sd* in Equation (9)) when the coefficients of the MLP are determined. Comprehensive strategy applies *Sd*,0 in Equation (3), and the target is determined based on arg max(*Sd*,0). The other three strategies only concern a few parameters in Equation (3). Greedy, traffic jam removal, and balance strategies select the goal pose through arg max(*Id*), arg max(*Jd*,0), and arg max(*Gd*), respectively.

As reported in Table 4, the end time of the emptying task is approximately 10% longer than that for filling tasks. However, the occurrence of decision failure times is generally lower. This indicates that during emptying tasks, instances of a forklift obstructing routes and blocking other vehicles for extended periods are rare. Yet, with the current configuration of *iterpre* and *itersearch*, all vehicles might experience longer wait times on average during each subtask.

The ANN combined strategy is the optimal method in terms of end time for both filling and emptying tasks, requiring approximately 2% less time than the comprehensive strategy. However, it does exhibit comparable or even slightly greater decision failure times when compared to the comprehensive strategy. In general, a reduction in the first parameter can reduce the computation burden of the hardware by performing fewer useless calculations in searching a trajectory. The second parameter directly shows the efficiency of the cooperative operation of multiple forklifts. Notably, the ANN approach applied to train the dispatching system only concerns the efficiency of planning a trajectory for the current vehicle. Therefore, it is possible that some stacks in only one shelf cluster are left to be filled by selecting the best solution multiple times. In this case, multiple forklifts have to cooperatively fill one shelf cluster, and the waiting period of each vehicle must increase. Therefore, both the decision failure times and the end time may sharply increase.

In Figures 15–18, the sequence in which the warehouse is filled with different methods is reported. The colored blocks plotted in the schematic warehouse stand for the stacks filled during different periods (red for the first quarter of time, blue for the second, green for the third, and cyan for the last). It is observed that the filling of different shelf clusters for the ANN combined strategy (cf. Figure 15) in different quarters of the period is balanced to a certain extent. There are, respectively, 35, 37, 34, and 30 stacks filled during each quarter. Particularly in the last quarter of the period, similar numbers of stacks filled are distributed within all six shelf clusters, and this provides a possibility for a feasible and fast solution to filling the warehouse.

**Figure 15.** Filling sequence of ANN combined strategy.

**Figure 16.** Filling sequence of comprehensive strategy.

**Figure 17.** Filling sequence of traffic jam removing strategy.

**Figure 18.** Filling sequence of balance strategy.

By excluding the MLP of ANN, a comprehensive strategy is also capable of assigning subtasks to each forklift explicitly. Although the performance is slightly worse than the ANN combined one, it does not require the data pertaining to previous cycles. Figure 16 demonstrates the filling sequence for this approach. Similar to that of the ANN combined approach, the filling state of the shelf clusters in the warehouse is relatively balanced throughout the period. A few seconds are added in terms of the end time for this strategy without the fine adjustment of the MLP.

Figure 17 exhibits the filling sequence of the traffic-jam-removing strategy. The difference between this method and the greedy strategy is that the previous one simultaneously considers *H* in Equation (3). One stack in shelf cluster *s*<sup>2</sup> is filled in the first quarter of the period, and both the decision failure times and the end time pertaining to the traffic jam removal approach reduce compared to the greedy strategy. Thus, a simple additional function of *H* can slightly further characterize the difficulty of the trajectory planning. Meanwhile, because the filling sequences of these two strategies are similar, the figure pertaining to the greedy method is omitted. As shown in Figure 17, it basically evenly fills shelf clusters *s*4, *s*5, and *s*<sup>6</sup> in the first quarter of the period. The majority of stacks in *s*<sup>1</sup> and around a third of stacks in *s*<sup>2</sup> are filled in the last quarter. Considering four vehicles cooperatively delivering goods, violations between trajectories evidently arise, and the times of failure in trajectory decisions and the waiting time can increase markedly.

The filling sequence of the balance strategy is plotted in Figure 18. The filling of different shelf clusters is nearly perfectly balanced. Evidently, this strategy can better arrange the trajectories to fill the last few stacks of the warehouse compared to any other approach. Therefore, the number of stacks filled during the last quarter of the warehouse filling cycle is comparable to that during other periods. In particular, when the 5th, 14th, and 23rd stacks of shelf clusters *s*<sup>3</sup> and *s*<sup>4</sup> (cf. Figure 2) are being filled, the paths between the shelf clusters (*s*<sup>1</sup> and *s*2) in the left side of the warehouse (cf. Figure 1) and picking stations are cut. Meanwhile, the first delivery vehicle reaching these certain stack locations between shelf clusters *s*<sup>3</sup> and *s*<sup>4</sup> can simultaneously block the routes to certain shelf clusters. This phenomenon also appears in shelf clusters *s*<sup>5</sup> and *s*<sup>6</sup> when the identical stack indexes are considered. Those are the unique conflicts that arose to cause the failure decisions and the lengthening of the end time for the balance strategy.

#### **7. Conclusions**

This study presents a joint dispatching and cooperative trajectory planning framework. In this framework, the dispatching method applies a time dimension involved A\* search, which is used to score different goal poses during a delivery subtask. ANN is simultaneously implemented to evaluate the difficulties for a forklift to arrive at a goods unloading pose from a picking station. In addition, the stacks to be filled pertaining to different shelf

clusters are used as the third parameter to balance the shelf filling states, with the aim of avoiding deadlocks at the final stage of the mission.

As far as the trajectory planning approach within the framework is concerned, a modelbased improved A\* search algorithm is used to sequentially determine the trajectory of each vehicle without further optimization-based techniques. The node expansion manners are determined on the basis of the purpose of a maneuver, and the speed pertaining to the start and end of a maneuver is divided into stages.

Different dispatching strategies are benchmarked. The ANN combined strategy shows the best performance in warehouse filling efficiency, but the decision failure times of this method are comparable to those of the comprehensive strategy. Meanwhile, it is observed that the balance of the filling state pertaining to shelf clusters is as important as the evaluation of the goal-reaching difficulties. Furthermore, the trajectories of multiple vehicles in a short time are presented. It is shown that although the priority of a vehicle during one subtask is predefined, the vehicles are capable of cooperatively and continuously finding feasible trajectories.

In the future, our joint strategy will be tested in a downsized unmanned warehouse setup. Additionally, we aim to implement a zonal shutdown feature for enhanced safety in case pedestrians enter the area. We also plan to integrate a forklift failure detection mechanism to enable uninterrupted warehouse operations even in the presence of a few malfunctioning forklifts.

**Author Contributions:** Conceptualization, T.Z., M.L. and K.C.; methodology, H.L. and Y.F.; validation, T.Z., Y.F. and K.C. All authors have read and agreed to the published version of the manuscript.

**Funding:** This research was funded by Fundamental Research Funds for the Central Universities: 531118010692; National Natural Science Foundation of China: 62103139; Fundamental Research Funds for the Central Universities: 531118010509; Natural Science Foundation of Hunan Province, China: 2021JJ40114.

**Conflicts of Interest:** The authors declare no conflict of interest.

#### **References**


**Disclaimer/Publisher's Note:** The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

**Yuheng Chen <sup>1</sup> and Yougang Bian 1,2,\***


**Abstract:** In order to enhance the performance of disturbance rejection in AUV's path tracking, this paper proposes a novel tube-based event-triggered path-tracking strategy. The proposed tracking strategy consists of a speed control law and an event-triggered tube model predictive control (tube MPC) scheme. Firstly, the speed control law using linear model predictive control (LMPC) technology is obtained to converge the nominal path-tracking deviation. Secondly, the event-triggered tube MPC scheme is used to calculate the optimal control input, which can enhance the performance of disturbance rejection. Considering the nonlinear hydrodynamic characteristics of AUV, a linear matrix inequality (LMI) is formulated to obtain tight constraints on the AUV and the feedback matrix. Moreover, to enhance real-time performance, tight constraints and the feedback matrix are all calculated offline. An event-triggering mechanism is used. When the surge speed change command does not exceed the upper bound, adaptive tight constraints are obtained. Finally, numerical simulation results show that the proposed tube-based event-triggered path-tracking strategy can enhance the performance of disturbance rejection and ensure good real-time performance.

**Keywords:** autonomous underwater vehicle; tube model predictive control; path tracking
