Robotic local planner selection

Abstract

The mobile robot includes at least one processor and at least one memory that stores instructions that, when executed by the at least one processor, cause the mobile robot to generate a next set of consecutive waypoints, determine a local planner based on the next set of consecutive waypoints, and determine a local planner based on the local planner. And outputting a speed pair for navigating the mobile robot based on the determined local planner.

Description

Technical Field

[0001] One or more example embodiments relate to automated robotic control. Background Art

[0002] The Robot Operating System (ROS) is the most popular framework for robot control. In ROS, navigation has two main components, a global planner and a local planner. Classical (or traditional) and learning-based approaches are at the extreme ends of local planners for mobile robots. While classical planners are more robust and stable, learning-based planners can be more effective in challenging situations. Summary of the invention

[0003] The scope of protection for various exemplary embodiments is defined by the independent claims. Exemplary embodiments and / or features described in this specification that do not belong to the scope of the independent claims (if any) should be interpreted as examples that help understand the various embodiments.

[0004] At least one example embodiment provides a mobile robot configured to dynamically determine whether to use a traditional local planner or a reinforcement learning local planner based on obstacles currently in the vicinity.

[0005] At least one example embodiment provides a method for navigating a robot, the method comprising: generating a next set of consecutive waypoints, determining a local planner based on the next set of consecutive waypoints, and outputting a velocity pair for navigating the mobile robot based on the determined local planner.

[0006] According to at least one example embodiment, the method further comprises generating a local cost map. Determining the local planner is also based on the local cost map.

[0007] According to at least one example embodiment, the method further comprises: determining a plurality of path clearance states based on the next set of consecutive waypoints, and filtering the plurality of path clearance states. Determining the local planner is based on the filtered path clearance states.

[0008] According to at least one example embodiment, determining the local planner includes determining whether to use a traditional local planner or a reinforcement learning (RL) local planner.

[0009] According to at least one example embodiment, determining the local planner includes: in response to all consecutive waypoints in the next set of consecutive waypoints being clear, determining to use a traditional local planner, and in response to at least one consecutive waypoint in the next set of consecutive waypoints being not clear, determining to use a reinforcement learning (RL) local planner.

[0010] According to at least one example embodiment, the method further includes generating an approximate path based on the global path and the next set of consecutive waypoints, and determining whether all consecutive waypoints in the next set of consecutive waypoints are unobstructed in response to no waypoints in the next set of consecutive waypoints being in the same location as an obstacle based on the local costmap.

[0011] According to at least one example embodiment, generating a next set of continuous waypoints includes discretizing a global path to generate discrete waypoints, and selecting a plurality of next discrete waypoints from a current position of the robot on the global path as a next set of continuous waypoints.

[0012] According to at least one example embodiment, the selecting includes: determining, among the discrete waypoints, a first waypoint after a waypoint closest to the current position of the robot. The selecting selects a plurality of subsequent discrete waypoints starting from the first waypoint.

[0013] At least one example embodiment provides a mobile robot comprising at least one processor and at least one memory, the at least one memory storing instructions that, when executed by the at least one processor, cause the mobile robot to: generate a next set of consecutive waypoints, determine a local planner based on the next set of consecutive waypoints, and output a speed pair for navigating the mobile robot based on the determined local planner.

[0014] According to at least one example embodiment, at least one memory stores instructions that, when executed by at least one processor, cause a mobile robot to: generate a local cost map, and determine a local planner further based on the local cost map.

[0015] According to at least one example embodiment, at least one memory stores instructions that, when executed by at least one processor, cause a mobile robot to: determine a plurality of path-clearance states based on a next set of consecutive waypoints, filter the plurality of path-clearance states, and determine a local planner based on the filtered path-clearance states.

[0016] According to at least one example embodiment, at least one memory stores instructions that, when executed by at least one processor, cause a mobile robot to: determine whether to use a traditional local planner or a reinforcement learning (RL) local planner.

[0017] According to at least one example embodiment, at least one memory stores instructions that, when executed by at least one processor, cause the mobile robot to: in response to all consecutive waypoints in a subsequent set of consecutive waypoints being unobstructed, determine to use a traditional local planner, and in response to at least one consecutive waypoint in a subsequent set of consecutive waypoints being unobstructed, determine to use a reinforcement learning (RL) local planner.

[0018] According to at least one example embodiment, at least one memory stores instructions that, when executed by at least one processor, cause the mobile robot to: generate an approximate path based on a global path and next consecutive waypoints, and determine whether all consecutive waypoints in a next consecutive waypoint set are unobstructed in response to no waypoints in the next consecutive waypoint set being in the same location as an obstacle based on a local cost map.

[0019] According to at least one example embodiment, at least one memory stores instructions that, when executed by at least one processor, cause the mobile robot to: discretize a global path to generate discrete waypoints, and from a current position of the robot on the global path, select a plurality of next discrete waypoints as a next continuous waypoint set.

[0020] According to at least one example embodiment, at least one memory stores instructions that, when executed by at least one processor, cause a mobile robot to: determine, among discrete waypoints, a first waypoint following a waypoint closest to a current position of the robot, and select a plurality of next discrete waypoints starting from the first waypoint.

[0021] At least one example embodiment provides a non-transitory computer-readable storage medium storing computer-executable instructions that, when executed at a mobile robot, cause the mobile robot to perform a method for navigating the mobile robot, the method comprising: generating a next set of consecutive waypoints, determining a local planner based on the next set of consecutive waypoints, and outputting a velocity pair for navigating the mobile robot based on the determined local planner.

[0022] According to at least one example embodiment, the method further comprises: generating a local cost map. Determining the local planner is also based on the local cost map.

[0023] According to at least one example embodiment, determining the local planner includes determining whether to use a traditional local planner or a reinforcement learning (RL) local planner.

[0024] According to at least one example embodiment, determining the local planner includes: in response to all consecutive waypoints in the next set of consecutive waypoints being unobstructed, determining to use a traditional local planner, and in response to at least one consecutive waypoint in the next set of consecutive waypoints being unobstructed, determining to use a reinforcement learning (RL) local planner.

[0025] At least one example embodiment provides a mobile robot comprising at least one processor and at least one memory, the at least one memory storing instructions that, when executed by the at least one processor, cause the mobile robot to: navigate based on received velocity pairs based on a local planner for the mobile robot, the local planner being determined based on a next set of consecutive waypoints for the mobile robot.

[0026] At least one example embodiment provides a mobile robot comprising components for generating a next set of consecutive waypoints, components for determining a local planner based on the next set of consecutive waypoints, and components for outputting a velocity pair for navigating the mobile robot based on the determined local planner. BRIEF DESCRIPTION OF THE DRAWINGS

[0027] Example embodiments will become more fully understood from the detailed description given below and the accompanying drawings, in which like elements are represented by like reference numerals, which are given by way of illustration only and thus do not limit the present disclosure.

[0028] Figure 1 is a block diagram illustrating a system according to an example embodiment.

[0029] Figure 2 is a flow chart illustrating a method according to an example embodiment.

[0030] Figure 3 is a flow chart illustrating a method according to an example embodiment.

[0031] Figure 4A is an example of a global costmap according to an example embodiment.

[0032] Figure 4B is an example of a local costmap according to an example embodiment.

[0033] Figure 5A and 5B An approximate path according to an example embodiment is shown.

[0034] Fig. 6A An unobstructed approximate path is shown according to an example embodiment.

[0035] Figure 6BAn approximate path of a block according to an example embodiment is shown.

[0036] Figure 7 is a flow chart illustrating a method according to an example embodiment.

[0037] Figure 8 A table showing possible results of a local costmap filter according to an example embodiment is shown.

[0038] Fig. 9A A smooth approximate path using a weighted-box based approach according to an example embodiment is shown.

[0039] Fig. 9B An obstruction approximation path using a weighted box based approach is shown according to an example embodiment. DETAILED DESCRIPTION

[0040] Various example embodiments will now be described more fully with reference to the accompanying drawings, in which some example embodiments are shown.

[0041] Detailed illustrative embodiments are disclosed herein. However, the specific structural and functional details disclosed herein are only representative examples for the purpose of describing the exemplary embodiments. However, the exemplary embodiments can be embodied in many alternative forms and should not be interpreted as being limited to the embodiments described herein.

[0042] It should be understood that there is no intention to limit the exemplary embodiments to the specific forms disclosed. On the contrary, the exemplary embodiments will cover all modifications, equivalents and alternatives that fall within the scope of the present disclosure. Throughout the description of the drawings, like numbers represent like elements.

[0043] As used herein, the terms "one or more" and "at least one" may be used interchangeably.

[0044] Planning is a fundamental part of any mobile robotic setup. A mobile robot must plan a path to successfully move from one location to another. Existing planning methods can be roughly categorized into global planners and local planners, which are often deployed collaboratively.

[0045] Global planners are optimal in known maps because they exploit the global costmap, but become brittle in the presence of unknown obstacles such as dynamic objects.

[0046] Local planners, although often suboptimal, can respond well in this situation. Additionally, as the map size increases, the time to search the global map increases, and local planners are computed more efficiently.

[0047] In modern planner implementations, both local and global planners are used in conjunction, where the global planner runs at a slower speed and computes a path to the destination on the global costmap. The local planner converts this path to near-term goal waypoints and runs at a faster speed in order to react to any unexpected obstacles in a timely manner.

[0048] The global planner calculates a path (e.g., a global plan or a global path) from a starting point of the robot to a target location based on a known fixed obstacle map. For example, the global planner can generate a global cost map based on a known fixed obstacle map, and calculate a global plan for the robot based on the global cost map.

[0049] On the other hand, a local planner considers the local area near the robot and finds feasible paths or controls to move towards the goal. The job of the local planner is to follow the global plan as closely as possible while avoiding unexpected obstacles (e.g., pedestrians walking on the global plan).

[0050] Local planners can be classified as traditional (e.g., classical) local planners or artificial intelligence (AI) local planners.

[0051] Traditional local planners (which do not include learning) are widely used in robotics applications. Reactive replanning, artificial potential fields, and fuzzy logic based planners are some examples of local planner types. The dynamic window approach (DWA) is the most popular among them and is the canonical local planner used by the Robot Operating System (ROS).

[0052] DWA looks for good velocity candidates in a local area around the robot and identifies the best choice from among them using a score function. DWA uses a simple motion model for the robot and therefore may not work well in situations where a more complex local trajectory is more appropriate. Sometimes this problem can be solved by parameter tuning, which can be cumbersome because DWA depends on a relatively large set of parameters.

[0053] DWA first generates a number of acceptable translation and rotation velocity pairs in a local window and performs forward simulation on them. The method optimizes an objective function that includes progress toward the goal, clearance on the path, and the robot's velocity to search for the most suitable velocity pair. The selected pair is used for a fixed amount of time, and then the search process is run again until the robot reaches within a threshold and / or a predefined distance of the goal.

[0054] DWA takes into account the robot's kinematics, resulting in relatively smooth circular trajectories for the robot at each step. However, DWA does not respond well in cases when more complex velocity profiles are required. Since it is not possible to search all possible velocity pairs, only a few sampled pairs are used in practice. This can result in the robot choosing trajectories that may collide with unexpected obstacles. More complex velocity profiles can be implemented with multi-step forward simulations, but this results in exponentially larger runtimes and relatively large sets of hyperparameters that require some tuning work before the robot can be deployed in the field.

[0055] When discussing conventional local planners herein, DWA will be discussed for simplicity. However, it should be understood that any known conventional local planner may be used.

[0056] The AI ​​local planner uses data to learn a model of the system and fine-tune the learned model in a new environment. A deep reinforcement learning (RL) framework is often used for training in such methods because it allows the robot to interact with the environment without data collection and annotation. Compared to a traditional local planner, an RL local planner can provide faster responses but slower and more unstable robot motion because it tries to move cautiously even if the path ahead is clear. As described in this article, the terms AI and RL can be used interchangeably.

[0057] An example of an RL local planner is the Soft Actor Critic Planner (SACPlanner). SACPlanner uses a neural network to take as input a polarized representation of the local cost map and outputs rotation and translation velocity pairs as actions for the robot.

[0058] The RL local planner effectively keeps the mapping between input and output as network weights. This results in SACPlanner potentially learning how to behave in a conservative way to safely avoid obstacles ahead. Therefore, while DWA is limited to performing motion on arcs, SACPlanner can traverse complex trajectories. However, because SACPlanner only looks at the cost map for a moment, the robot motion is unstable and moves at a slow speed even when there are no obstacles ahead, making it inefficient.

[0059] When discussing AI local planners in this article, SACPlanner will be discussed for simplicity. However, it should be understood that any known AI local planner can be used.

[0060] These two planners represent two seemingly distinct approaches to planning. Choosing a planner from these is essentially a trade-off between smoothness and responsiveness. While DWA is better suited for moving around static maps, SACPlanner is better suited for successfully navigating complex maps.

[0061] Figure 1 1 is a block diagram illustrating an example embodiment of a system according to an example embodiment. The system 10 includes a robot 100 and / or an external device 106. The robot 100 can communicate with the external device 106, for example, through a cloud. (e.g., via the Internet). The robot 100 may also be referred to as a drone, a mobile robot, a ground robot, a navigation robot, etc. For example, the robot 100 may be a warehouse sorting robot, an automatic shopping cart, an automated guided vehicle (AGV), an automated mobile robot (AMR), an automated storage and retrieval system (AS / RS), etc.

[0062] refer to Figure 1 , the robot 100 may include a processing circuit system (e.g., at least one processor 101), a memory 102, a wireless communication interface 103, an obstacle detection unit 104, and / or a propulsion unit 105. The memory 101 may include various dedicated program codes, including computer executable instructions, which may cause the robot 100 to perform one or more methods according to the example embodiments. The communication interface 103 may be a wireless communication interface or a wired communication interface. For example, the communication interface 103 may be an Ethernet interface, an LTE, 5G, 6G, and / or WiFi interface, etc. The obstacle detection unit 104 may detect and / or determine the presence of obstacles near the robot 100. The obstacle detection unit 104 may include, for example, (multiple) odometer sensors, an inertial measurement unit (IMU), a radar, a lidar, a sonar, and / or (multiple) digital cameras, etc. The propulsion unit 105 may include, for example, wheels and / or tracks, etc., at least one motor and / or engine and / or servo, etc.

[0063] In at least one example embodiment, the processing circuit system may include at least one processor (and / or processor core, distributed processor, networked processor, etc.), such as at least one processor 101, which may be configured to control one or more elements of the robot 100, so that the robot 100 performs various operations. The processing circuit system (e.g., at least one processor 101, etc.) is configured to execute a process by acquiring program code (e.g., computer-readable instructions) and data from the memory 102 to process them, thereby performing dedicated control and functions of the entire robot 100. Once the dedicated program instructions are loaded into, for example, at least one processor 101, etc., the at least one processor 101 executes the dedicated program instructions, thereby converting the at least one processor 101 into a dedicated processor.

[0064] In at least one example embodiment, the memory 102 may be a non-transitory computer-readable storage medium and may include a random access memory (RAM), a read-only memory (ROM), and / or a permanent mass storage device such as a disk drive or a solid-state drive. The memory 102 stores program codes (i.e., computer-readable instructions) related to operating the robot 100.

[0065] Figure 2 is a flow chart illustrating a method according to an example embodiment. Figure 2 The method shown in can be executed at the robot 100 to navigate the robot 100.

[0066] refer to Figure 2 At S200, the robot 100 generates a set of k consecutive waypoints W. In this example, k may be any natural number. According to some example embodiments, k may be equal to 8. However, example embodiments are not limited thereto.

[0067] The robot 100 may generate a set of k continuous waypoints based on a global cost map and / or a global path. The global cost map and / or the global path may be generated by a global planner based on a map of known fixed obstacles. The global planner may be executed by the robot 100 or by an external device 106. In the case where the global planner is executed by the external device 106, the global cost map and / or the global path map may be sent to the robot 100 via a communication interface. The global cost map and / or the global path may be stored in the memory 102.

[0068] The robot 100 may generate waypoints W based on the global costmap and / or the global path. The algorithm for generating waypoints may be similar to the waypoint generation algorithm typically associated with the RL local planner. For example, waypoints may be generated according to the method disclosed in R. Güldenring, 2019, "Applying deep reinforcement learning in the navigation of mobile robots in static and dynamic environments", the contents of which are incorporated herein by reference. However, example embodiments are not limited thereto, and any known method for generating waypoints may be used.

[0069] For example, according to some example embodiments, the robot 100 may discretize the global path starting from the current position of the robot to generate a set of k waypoints W. In one example, the robot may select the set of k waypoints W from the discrete waypoints on the global path as the next set of k waypoints W (or the next set of k waypoints W).

[0070] In some other example embodiments, the robot 100 may discretize the entire global path into a set of global waypoints. For example, the set of global waypoints is discretized to be a constant distance apart (equidistant). Alternatively, the discretized global waypoints may be stored in the memory 102 and / or received from the external device 106 via the communication interface 103.

[0071] At any given time, the robot 100 can pick a next set of k waypoints W from the global waypoint set. The first waypoint in the next set can be the waypoint after the waypoint closest to the current position of the robot 100. This can avoid the situation where the first waypoint is behind the robot 100 on the global path. The robot then picks k consecutive waypoints starting from this first waypoint.

[0072] Return to Figure 2 , at S205 , the robot 100 determines from which local planner of the hybrid local planner to obtain the velocity pair (v, w).

[0073] The velocity pair (v, w) can be used to navigate (e.g., move) a robot. The velocity pair (v, w) includes a linear (or translational) velocity (v) and an angular (or rotational) velocity (w). The hybrid local planner may include at least two local planners. For example, the hybrid local planner may include a traditional planner (e.g., DWA) and an RL local planner (e.g., SACPlanner). According to some example embodiments, at least two local planners of the hybrid local planner may each output a velocity pair continuously or periodically. Alternatively, a corresponding local planner of at least two local planners may output a velocity pair (v, w) only in response to a decision to obtain a velocity pair from the corresponding local planner.

[0074] Returning to S205, the robot 100 determines a local cost map via the obstacle detection unit 104. The local cost map is determined by referring to Figure 3 is explained in more detail.

[0075] Based on the local costmap and the next set of k waypoints W, the robot 100 determines whether to use a traditional local planner (e.g., DWA) or an RL local planner (e.g., SACPlanner). For example, if none of the k waypoints W correspond to an obstacle, the robot 100 may determine to use a traditional local planner, and if any of the k waypoints W correspond to an obstacle, the robot 100 may determine to use an RL local planner.

[0076] Therefore, in the case where more response is required to avoid obstacles, the robot 100 uses the RL local planner, and in the case where the path is unobstructed, the robot 100 uses the traditional local planner to produce a smoother path. Step S205 will be referred to later. Figure 3 is described in more detail.

[0077] In some example embodiments, S205 may be performed by the external device 106. In this case, the robot 100 determines a local cost map via the obstacle detection unit 104. Then, the robot 100 may send the local cost map to the external device 106 via the communication interface 103. The external device 106 may perform S205 and send the determination to the robot 100 via the communication interface 103. In another example embodiment, the robot 100 sends the lidar value received from the obstacle detection unit 104 to the external device 106. In this case, the external device 106 determines the local cost map. Determining the local cost map will refer to Figure 3 is explained in more detail.

[0078] Return to Figure 2 At S210, the robot 100 outputs the velocity pair (v, w) obtained from the determined local planner. The local planner of the robot 100 determines the linear (or translational) velocity (v) and the angular (or rotational) velocity (w) at each moment. The robot 100 uses the determined local planner to determine the velocity pair, and then instructs the propulsion unit 105 to control the movement of the robot 100 according to the velocity pair (v, w).

[0079] DWA calculates which velocity pairs (v,w) are feasible for the next time step. Each velocity pair defines an arc. DWA calculates the cost for each arc based on how well it matches the global plan and how close it is to any obstacles.

[0080] The RL planner generates states via the local costmap generated by the obstacle detection unit 104 and the waypoints calculated from the global path. For example, the RL planner can be previously trained to output velocity pairs (v, w) based on the local costmap, as described in Khaled Nakhleh et al., "SACPlanner: Real-World Collision Avoidance with a Soft Actor Critic Local Planner and Polar State Representations", which is incorporated herein by reference. The local costmap will be combined with the Figure 3 is described in more detail.

[0081] According to some example embodiments, both the traditional local planner and the RL local planner may run simultaneously (e.g., continuously). In this case, both the traditional local planner and the RL local planner may generate velocity pairs (v, w), and the robot 100 may select which velocity pair to use based on the determined local planner.

[0082] According to some other example embodiments, at a given time, only one of the conventional local planner or the RL local planner may generate a velocity pair (v, w) in response to the determined local planner.

[0083] In some example embodiments, the traditional local planner and / or the RL local planner may be implemented at the external device 106. In this case, S210 may be performed by the external device 106, and the velocity pair may be sent to the robot 100 via the communication interface 103. The robot 100 then instructs the propulsion unit 105 to control the movement (e.g., navigation) of the robot 100 according to the velocity pair (v, w).

[0084] Therefore, according to the example embodiment, the robot 100 can adopt a hybrid local planner by dynamically determining to use the RL local planner when more accurate obstacle avoidance is required, and determining to use the traditional local planner when such obstacle avoidance accuracy is not required. Therefore, the robot 100 according to the example embodiment can have a higher level of obstacle avoidance while also maintaining an improved level of smooth navigation.

[0085] Figure 3 is a flow chart illustrating a method according to an example embodiment. Figure 3 The method shown in may be performed at the robot 100 to determine the local planner to use.

[0086] refer to Figure 3At S205_00, the robot 100 generates a local cost map. The local cost map may correspond to an area immediately adjacent to the robot 100. For example, the local cost map may correspond to an area of ​​8 meters x 8 meters around the robot 100. However, example embodiments are not limited thereto, and the local cost map may correspond to an area of ​​any size adjacent to the robot 100. The local cost map may represent a portion of the global cost map.

[0087] Figure 4A is an example of a global costmap according to an example embodiment.

[0088] refer to Figure 4A , the robot 100 may have access to a global costmap 400. For example, the global costmap 400 may be stored in the memory 102. The global costmap 400 may be a Cartesian map of known or fixed obstacles 402a from at least the starting position of the robot 100 to the target. The local costmap 401 may be contained within the global costmap 400.

[0089] Figure 4B is an example of a local costmap according to an example embodiment.

[0090] refer to Figure 4B , the local costmap 401 may be a polarization map including an obstacle 402b. The obstacle 402b may include an obstacle 402a of the global costmap 400 within the area of ​​the local costmap 401. In addition, the obstacle 402b may include a temporary and / or unexpected obstacle not included in the global costmap 400. For example, the obstacle 402b may include a person, a misplaced object, an object newly added after the known fixed obstacle map on which the global costmap 401 is based is generated, and the like.

[0091] The robot 100 can generate a local costmap 401 by capturing a Cartesian map of obstacles adjacent to the robot via the obstacle detection unit 104. For example, the robot 100 can use a lidar, a rangefinder, and / or an IMU sensor, etc. to detect obstacles in an 8m x 8m area around the robot. The robot 100 can convert the Cartesian map into a polar map according to any known method. For example, the horizontal axis of the Cartesian map represents the forward-looking distance (e.g., 4 meters in the case of an 8m x 8m costmap centered on the robot 100). Assuming that the robot's current heading yaw is at 0 in the middle of the vertical axis, the vertical axis matches -\pi (radians) to \pi (radians) from top to bottom.

[0092] like Figure 4B As shown, the local costmap 401 may include at least one of the next k waypoints W.

[0093] Return to Figure 3 , at S205_05, the robot 100 determines whether the next k waypoints are unobstructed.

[0094] The robot 100 uses the next k waypoints W generated on the local costmap 401 and creates a piecewise linear trajectory to generate an approximate path that the robot would follow if there were no dynamic obstacles in the environment. An example of an approximate path is shown in Figures 5A to 5B is shown in .

[0095] Figure 5A An example of an approximate path P generated using a weighted box-based method (e.g., a block-based method) is shown. Figure 5A As shown, in the weighted box-based approach, the approximate path P is represented as a series of boxes. In this way, if the obstacle 402 is within a certain distance from the path P, the obstacle 402 can be determined to be in the same position as the approximate path P. For example, the box can be 6 inches wide or 1 foot wide. Therefore, if the obstacle 402 is within 6 inches or 1 foot of the approximate path P, the obstacle can be determined to be in the same position as the path P.

[0096] Figure 5B An example of an approximate path P generated by a piecewise linear connection of k waypoints is shown. The piecewise linearly connected region can be a subset of the weighted box based approach, but the chance of the approximation being blocked by fixed obstacles on the known map is less (e.g., much less) because the waypoints are already at a distance from the fixed / static obstacles selected from a subset of global paths known in the global costmap. For example, the approximate path P needs to touch obstacle 402 so that obstacle 402 is in the same position as the approximate path P. The beginning of path P passing through obstacle 402c (not obstacle 402 from the known map) is determined to be blocked.

[0097] Fig. 6A shows a smooth approximate path according to an example embodiment, and Figure 6B The blocked approximation path using a piecewise linear method is shown.

[0098] Fig. 9A shows a smooth approximate path, and Fig. 9B An obstruction approximation path using a weighted box based approach is shown according to an example embodiment.

[0099] refer to Figure 6A-6B , the robot 100 generates an approximate path P passing through the next k waypoints W.

[0100] refer to Figures 9A-9B , the robot 100 generates an approximate path P passing through the next k waypoints W as a weighted box.

[0101] If any portion of the approximated path is not at the same location (or within a certain distance) as obstacle 402, such as Fig. 6A and 9A As shown, the robot 100 determines that the next k waypoints W are clear (eg, determines that the path clearing state is clear) (Y at S205_05). The method then proceeds to S205_10.

[0102] At S205_10, the robot 100 determines the velocity pair (v, w) obtained from the conventional local planner. The method then proceeds to S210 and continues as described herein.

[0103] Returning to S205_05, if any part of the approximate path is at the same position (or within a certain distance) as the obstacle 402, such as Figure 6B and 9B As shown, the robot 100 determines that the next k waypoints W are not clear (eg, determines that the path clearing state is blocked) (N at S205_05). The method then proceeds to S205_15.

[0104] At S205_15, the robot 100 determines the velocity pair (v, w) obtained from the RL local planner. The method then proceeds to S210 and continues as described herein.

[0105] If a waypoint W among the next k waypoints W is located outside the area covered by the local costmap 401 , the robot 100 may determine that such waypoint W is not at the same location as an obstacle.

[0106] Figure 7 is a flow chart illustrating a method according to an example embodiment. Figure 7 The method shown in may be performed at the robot 100 to determine the local planner to use. Figure 7 The steps shown in Figure 3 The steps in are the same as in , except that step S205_05 is replaced by steps S205_05_01 and S205_05_02. In order to avoid duplication of disclosure, only these steps will be described.

[0107] refer to Figure 7 , at S205_05_01 , the robot 100 filters the path clearing status.

[0108] Figure 2The method shown in can be performed by the robot 100 multiple times per second (e.g., 5 times per second). Therefore, if only the most recent clear state is used for planner selection, noise in the sensor data may cause the robot 100 to quickly flip-flop between a traditional local planner and an RL local planner. According to some example embodiments, the robot 100 may determine a local planner after filtering the path clear state for noise from the sensors.

[0109] To filter the path clearing state, the robot 100 may keep track of the number n of previous path clearing states. The method for determining the path clearing state is described in step S205_05 above. For ease of illustration, the example embodiment will use n=3 path clearing states. However, the example embodiment is not limited thereto, and more or fewer path clearing states may be used.

[0110] Figure 8 A table showing possible results for a path clearing status filter according to an example embodiment is shown.

[0111] refer to Figure 8 , all possible results for the determination of path clearness for times t=-2, t=-1, and t=0 are displayed. For example, t=0 may represent the current path clear state, t=-1 may represent the latest path clear state, and t=-2 may represent the path clear state immediately before t=-1.

[0112] For example, Figure 8 The first row in indicates the case where t=-2, t=-1, and t=0 are all determined to be clear paths. Figure 8 The fourth row in indicates the case where t=-2 is determined as a blocked path, while t=-1 and t=0 are determined as clear paths. The last row indicates the case where t=-2, t=-1, t=0 are all determined as blocked paths.

[0113] Return to Figure 7 At S205_05_02, the robot 100 may determine whether the next k waypoints W are clear based on the filtered local cost map. For example, the robot 100 may determine that the next k waypoints W are clear in response to the number of clear states of the previous n path clear states being equal to or higher than a threshold τ.

[0114] For example, Figure 8 As shown, the threshold τ can be equal to 1. Therefore, Figure 8As shown, if any one of the previous three clear states is unblocked, the robot 100 can determine that the next k waypoints W are unblocked. If all of the previous three clear states are blocked (as shown in the last row), the robot 100 can determine that the next k waypoints W are blocked. However, example embodiments are not limited thereto, and the threshold τ can be any number between 1 and n.

[0115] Returning to S205_05_02, if the number of clear states of the previous n path clear states is equal to or higher than the threshold τ, the robot 100 determines that the next k paths are clear (Y at S205_05_02), and the method continues to S205_10 and proceeds as described herein.

[0116] Returning to S205_05_02, if the number of clear states of the previous n path clear states is less than the threshold τ, the robot 100 determines that the next k paths are not clear (N at S205_05_02), and the method proceeds to S205_15 and proceeds as described herein.

[0117] Although the terms first, second, etc. can be used in this article to describe various elements, these elements should not be limited by these terms. These terms are only used to distinguish one element from another element. For example, the first element can be referred to as the second element, and similarly, the second element can be referred to as the first element without departing from the scope of this disclosure. As used herein, the term "and / or" includes any and all combinations of one or more associated listed items.

[0118] When an element is referred to as being "connected" or "coupled" to another element, it may be directly connected or coupled to the other element, or there may be intervening elements. In contrast, when an element is referred to as being "directly connected" or "directly coupled" to another element, there are no intervening elements. Other words used to describe the relationship between elements should be interpreted in a similar manner (e.g., "between" versus "directly between," "adjacent" versus "directly adjacent," etc.).

[0119] The terms used herein are used only to describe specific embodiments and are not intended to be limiting. As used herein, the singular forms "a", "an", and "the" are also intended to include the plural forms, unless the context clearly indicates otherwise. It should also be understood that the terms "comprises", "comprisign", "includes", and / or "including" when used herein specify the presence of the features, integers, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.

[0120] It should also be noted that in some alternative implementations, the functions / actions may not occur in the order shown in the figures. For example, two figures shown in succession may actually be executed substantially concurrently, or may sometimes be executed in the reverse order, depending on the functions / actions involved.

[0121] Specific details are provided in the following description in order to provide a comprehensive understanding of the example embodiments. However, it will be understood by one of ordinary skill in the art that the example embodiments may be practiced without these specific details. For example, the system may be shown in the form of a block diagram so as not to obscure the example embodiments in unnecessary detail. In other cases, well-known processes, structures, and techniques may be shown without unnecessary detail so as not to obscure the example embodiments.

[0122] As discussed herein, the illustrative embodiments will be described with reference to symbolic representations of actions and operations that may be implemented as program modules or functional processes (e.g., in the form of flow charts, flowcharts, data flow diagrams, structure diagrams, block diagrams, etc.), including routines, programs, objects, components, data structures, etc. that perform specific tasks or implement specific abstract data types, and may be implemented using existing hardware, such as at existing user equipment, base stations, eNBs, RRHs, gNBs, femto base stations, network controllers, computers, etc. Such existing hardware may be a processing or control circuit system such as, but not limited to, one or more processors, one or more central processing units (CPUs), one or more controllers, one or more arithmetic logic units (ALUs), one or more digital signal processors (DSPs), one or more microcomputers, one or more field programmable gate arrays (FPGAs), one or more systems on chips (SoCs), one or more programmable logic units (PLUs), one or more microprocessors, one or more application specific integrated circuits (ASICs), or any other device or devices capable of responding to and executing instructions in a defined manner.

[0123] Although a flow chart may describe operations as a sequential process, many operations may be performed in parallel, concurrently, or simultaneously. In addition, the order of the operations may be rearranged. A process may be terminated when its operations are completed, but may also have additional steps not included in the diagram. A process may correspond to a method, function, procedure, subroutine, subprogram, etc. When a process corresponds to a function, its termination may correspond to the function returning to the calling function or the main function.

[0124] As disclosed herein, the term "storage medium", "computer-readable storage medium" or "non-transitory computer-readable storage medium" may refer to one or more devices for storing data, including read-only memory (ROM), random access memory (RAM), magnetic RAM, core memory, magnetic disk storage media, optical storage media, flash memory devices and / or other tangible machine-readable media for storing information. The term "computer-readable medium" may include, but is not limited to, portable or fixed storage devices, optical storage devices, and various other media capable of storing, containing or carrying (multiple) instructions and / or data.

[0125] In addition, the example embodiments may be implemented by hardware, software, firmware, middleware, microcode, hardware description language, or any combination thereof. When implemented in software, firmware, middleware, or microcode, the program code or code segments that perform the necessary tasks may be stored in a machine or computer readable medium, such as a computer readable storage medium. When implemented in software, one or more processors will perform the necessary tasks. For example, as described above, according to one or more example embodiments, at least one memory may include or store computer program code, and at least one memory and computer program code may be configured to enable a network element or network device to perform necessary tasks together with at least one processor. In addition, processors, memories, and example algorithms encoded as computer program codes are used as components for providing or causing the execution of the operations discussed herein.

[0126] The code segment of a computer program code can represent any combination of a process, function, subprogram, program, routine, subroutine, module, software package, class or instruction, data structure or program statement. A code segment can be coupled to another code segment or hardware circuit by transmitting and / or receiving information, data, arguments, parameters or memory contents. Information, arguments, parameters, data, etc. can be transmitted, forwarded or generated via any suitable technology, including memory sharing, message passing, token passing, network transmission, etc.

[0127] As used herein, the terms "including" and / or "having" are defined as comprising (i.e., open language). As used herein, the term "coupled" is defined as connected, although not necessarily directly connected and not necessarily mechanically connected. Terms derived from the word "indicating" (e.g., "indicates" and "indication") are intended to cover all of the various techniques that can be used to transmit or reference the indicated object / information. Examples of some (but not all) techniques that can be used to transmit or reference the indicated object / information include communication of the indicated object / information, communication of an identifier of the indicated object / information, communication of information used to generate the indicated object / information, communication of some part or portion of the indicated object / information, communication of some derivative of the indicated object / information, and communication of some symbols representing the indicated object / information.

[0128] According to example embodiments, user equipment, base stations, eNBs, RRHs, gNBs, femto base stations, network controllers, computers, etc. may be (or include) hardware, firmware, hardware executing software, or any combination thereof. Such hardware may include processing or control circuit systems, such as but not limited to one or more processors, one or more CPUs, one or more controllers, one or more ALUs, one or more DSPs, one or more microcomputers, one or more FPGAs, one or more SoCs, one or more PLUs, one or more microprocessors, one or more ASICs, or any other one or more devices capable of responding to and executing instructions in a defined manner.

[0129] Benefits, other advantages and solutions to problems have been described above with respect to specific embodiments of the present invention. However, the benefits, advantages, solutions to problems, and any elements that may cause or bring about such benefits, advantages or solutions or make such benefits, advantages or solutions more obvious should not be construed as key, required or essential features or elements of any or all claims.

Claims

1. A method for navigating a robot, the method comprising: Generate the next set of continuous waypoints; Determining a local planner based on the next set of consecutive waypoints; as well as Based on the determined local planner, a velocity pair for navigating the robot is output.

2. The method according to claim 1, further comprising: Generate a local costmap, and Wherein determining the local planner is also based on the local cost map.

3. The method according to claim 1, further comprising: determining a plurality of path clearing states based on the next set of consecutive waypoints; filtering the plurality of paths to clear the state, and Wherein determining the local planner is based on the filtered path clearing status.

4. The method of claim 1 , wherein determining the local planner comprises: Determines whether to use a traditional local planner or a reinforcement learning (RL) local planner.

5. The method of claim 1 , wherein determining the local planner comprises: In response to all consecutive waypoints in the next set of consecutive waypoints being unobstructed, determining to use a conventional local planner; as well as In response to at least one consecutive waypoint in the next set of consecutive waypoints being not unobstructed, it is determined to use a reinforcement learning (RL) local planner.

6. The method according to claim 5, further comprising: generating an approximate path based on the global path and the next set of continuous waypoints; as well as In response to no waypoint in the next set of consecutive waypoints being co-located with an obstacle based on the local costmap, determining whether all consecutive waypoints in the next set of consecutive waypoints are unobstructed.

7. The method of claim 1 , wherein generating the next set of consecutive waypoints comprises: discretize the global path to generate discrete waypoints; as well as From the current position of the robot on the global path, a plurality of next discrete waypoints are selected as the next continuous waypoint set.

8. The method of claim 7, wherein the selecting comprises: Among the discrete waypoints, a first waypoint after the waypoint closest to the current position of the robot is determined, and wherein The selecting selects the plurality of next discrete waypoints starting from the first waypoint.

9. A mobile robot comprising: at least one processor; as well as at least one memory storing instructions that, when executed by the at least one processor, cause the mobile robot to: Generate the next set of continuous waypoints; Determining a local planner based on the next set of consecutive waypoints; and Based on the determined local planner, a velocity pair for navigating the mobile robot is output.

10. The mobile robot of claim 9, wherein the at least one memory stores instructions that, when executed by at least one processor, cause the mobile robot to: Generate a local costmap; and The local planner is further determined based on the local costmap.

11. The mobile robot of claim 9, wherein the at least one memory stores instructions that, when executed by the at least one processor, cause the mobile robot to: determining a plurality of path clearing states based on the next set of consecutive waypoints; filtering the plurality of path clear states; and The local planner is determined based on the filtered path clearing status.

12. The mobile robot of claim 9, wherein the at least one memory stores instructions that, when executed by the at least one processor, cause the mobile robot to: determine whether to use a traditional local planner or a reinforcement learning (RL) local planner.

13. The mobile robot of claim 9, wherein the at least one memory stores instructions that, when executed by the at least one processor, cause the mobile robot to: In response to all consecutive waypoints in the next set of consecutive waypoints being unobstructed, determining to use a conventional local planner; and In response to at least one consecutive waypoint in the next set of consecutive waypoints being not unobstructed, it is determined to use a reinforcement learning (RL) local planner.

14. The mobile robot of claim 13, wherein the at least one memory stores instructions that, when executed by the at least one processor, cause the mobile robot to: generating an approximate path based on the global path and the next consecutive waypoints; and In response to no waypoint in the next set of consecutive waypoints being co-located with an obstacle based on the local costmap, determining whether all consecutive waypoints in the next set of consecutive waypoints are unobstructed.

15. The mobile robot of claim 9, wherein the at least one memory stores instructions that, when executed by the at least one processor, cause the mobile robot to: discretizing the global path to generate discrete waypoints; and From the current position of the robot on the global path, a plurality of next discrete waypoints are selected as the next continuous waypoint set.

16. The mobile robot of claim 15, wherein the at least one memory stores instructions that, when executed by the at least one processor, cause the apparatus to: Among the discrete waypoints, determining a first waypoint after the waypoint closest to the current position of the robot; and The plurality of next discrete waypoints are selected starting from the first waypoint.

17. A non-transitory computer-readable storage medium storing computer-executable instructions which, when executed at a mobile robot, cause the mobile robot to perform a method for navigating the mobile robot, the method comprising: Generate the next set of continuous waypoints; Determining a local planner based on the next set of consecutive waypoints; as well as Based on the determined local planner, a velocity pair for navigating the robot is output.

18. The non-transitory computer-readable storage medium of claim 15, the method further comprising: Generate a local costmap, and Wherein determining the local planner is also based on the local cost map.

19. The non-transitory computer-readable storage medium of claim 15, wherein determining the local planner comprises: Determines whether to use a traditional local planner or a reinforcement learning (RL) local planner.

20. The non-transitory computer-readable storage medium of claim 15, wherein determining the local planner comprises: In response to all consecutive waypoints in the next set of consecutive waypoints being unobstructed, determining to use a conventional local planner; as well as In response to at least one consecutive waypoint in the next set of consecutive waypoints being not unobstructed, it is determined to use a reinforcement learning (RL) local planner.

Images