Several studies have recently explored the development of software infrastructure for the Unitree Robotics’ Go2 Edu robot. Mei et al. (2024) developed a reinforcement learning method to enable the Go2 Edu robot to navigate narrow pipes using visual inputs from a depth camera. The navigation process is relatively straightforward due to the grid-like structure of the pipes, where each pipe is aligned in a straight path, with occasional protrusions serving as obstacles. Guo et al. (2024) developed a high-level path planning using a large language model, namely, OpenAI’s ChatGPT-4o, which allows the interpretation of human verbal commands and translates them into a list of executable instructions. The system integrates a depth camera with a segmentation model to effectively perceive the environment. In addition, Cheng et al. (2024) developed a motion controller for the Go2 Edu robot to traverse complex and unstructured environments using proprioceptive sensing and collision estimation only.

Autonomous navigation using quadrupedal robots is crucial for exploring complex environments; however, research on 2D coverage path planning is limited. Ly et al. (2023) achieved coverage path planning for loco-manipulation through an integrated end-to-end pipeline combining perception, optimization, and whole-body motion planning with RGB-D camera inputs. Bouman et al. (2022) presented a 2D coverage path planner for investigating unknown and unstructured environments while accounting for time-bounded and dynamic constraints and traversability risk. The advantage of these approaches is that they guarantee timely execution when the mission is time-bound, and they find a good optimal tradeoff between the maximum area coverage and the path traveled. The drawback of these approaches is that they are focused on time constraints; therefore, they do not work when the task has a variable execution time and requires time to be defined in advance. In contrast, our approach enables planning for variable times.

Some navigation methods already enable planning for variable times. Recently, Niu et al. (2024) developed a novel autonomous exploration method that uses a topological skeleton of the environment’s geometry via LiDAR, along with a finite state machine (FSM) to enable an exploratory strategy. This was demonstrated on a quadrupedal robot in an unstructured environment. These approaches have the advantage of being very adaptable in an unknown environment due to the use of a state machine that continuously checks for undiscovered areas within the map. The main difference between this work and our approach is that their method for obtaining topological skeletons uses wave propagation and Voronoi diagrams, while our method uses a morphological technique by treating the environment as an image. The impact of this is that the morphological technique simplifies the mapping and is thus computationally more efficient.

Furthermore, all the above methods of coverage path planning have specific map generation algorithms that are an integral part of the whole approach. Therefore, they are less modular, making it difficult to replace them with developing state-of-the-art mapping algorithms. In contrast, our approach can work with different types of mapping algorithms, thus making it more modular.

In this work, we address the gap in the state of the art through the following key contributions.

1. We develop a control framework based on a finite state machine that switches between different operation modes to enable autonomous navigation and environmental inspection.

The Unitree Robotics Go2 Edu features three degrees of freedom (DOFs) per leg, consisting of hip, thigh, and calf hinge joints (from base to foot). It is equipped with an inertial measurement unit (IMU), an HD wide-angle camera, and foot-end force sensors. The robot offers a battery life of 2–4 h and supports fast charging ¹ .

For navigation and perception, the Go2 Edu is fitted with the Unitree L1—a 4D LiDAR (3D position + 1D greyscale) based on laser time-of-flight (TOF)—mounted on its mouth. This LiDAR provides a 360° × 90° field of view (FOV), a measurement accuracy of ± 2.0 cm, and a scanning distance of up to 30 m with 90% reflectivity. It integrates an IMU with a 3-axis accelerometer and 3-axis gyroscope, has a proximal blind spot of 0.05 m, and features a sampling frequency of 43,200 points per second. Additionally, it operates with a circumferential scanning frequency of 11 Hz and a vertical scanning frequency of 180 Hz ² . The integrated LiDAR sensor is also used for collision detection, which facilitates the differentiation between free and occupied spaces in the environment based on height. Additionally, it enables the generation of a 2D map for navigation during run-time and self-localization ability with respect to environmental features and the current state of the map.

Furthermore, the robot includes an expansion dock that houses an NVIDIA Jetson Orin, providing computing power of 40–100 TOPS. It also comes with a manual two-handed joystick controller for user operation. Additionally, in order to monitor the robot remotely, a TP-Link TL-WR802N Nano WLAN Router is added to establish a wireless connection between the robot and the operator’s computer.

Finally, we also integrated external sensors on the robot to measure ambiance characteristics such as temperature, humidity, and light intensity. The integration of these sensors is discussed in Supplementary Material A, but their usage is outside the scope of this work and is, therefore, not detailed in this paper.

The Unitree Robotics Go2 Edu robot has a dedicated software development kit (SDK), which allows custom implementations to be programmed. This SDK uses a data distribution service (DDS) as the networking middleware, which enables reliable and real-time data exchange between the program and the robot ³ .

Using DDS, a ROS application (Macenski et al., 2022) is also implemented to facilitate seamless communication between distributed robotic components, thus ensuring real-time data exchange, scalability, and interoperability across diverse hardware and software platforms.

In particular, we use ROS 2 due to its additional benefits compared to ROS 1, such as decentralization, simplicity, and user-friendliness. We use the ROS 2 Foxy on Ubuntu 20.04 to develop our proposed framework as these specifications are well-established for the Unitree Robotics Go2 Edu robot.

For the robot to determine its location within the environment while simultaneously creating a map, we use simultaneous localization and mapping (SLAM). SLAM allows the robot to dynamically create a map based on the history of information and localize the robot as a function of both the current measurement and the map simultaneously (Stachniss et al., 2016). In our case, a 2D map is sufficient because the robot can only navigate on the ground surface in the x and y directions (excluding orientation in the z direction). It is worth mentioning that Go2 Edu already comes with its own SLAM implementation. However, at the time of the development, it was not readily available due to the lack of documentation. Moreover, we aim to maintain modularity so that this implementation can be applied to other quadruped platforms, with only the software modules bridging the proposed method and the robot needing adaptation. Therefore, we use Macenski’s SLAM_Toolbox to create a 2D map using a sequence of 2D laser scans as input (Macenski and Jambrecic, 2021). A 2D laser scan measures the distance to obstacles based on reflections detected by the robot’s laser scanner at specific angles and time intervals. Using a radial laser scanner, it can measure the layout of the surroundings around the robot simultaneously in one measurement time-step.

Despite the strengths of Macenski’s SLAM implementation, the integrated sensor that measures the geometry of the surroundings is a LiDAR that outputs data as a 3D point cloud. To make these data interpretable by the SLAM_Toolbox, we process the LiDAR measurements to identify the obstacles that the robot cannot navigate through. To achieve this task, we develop a data processing pipeline using the Point Cloud Library (PCL) (Rusu and Cousins, 2011), which transforms the input 3D point cloud/point _cloud/raw into the desired 2D laser scans/scan. An overview of this pipeline is shown in Figure 2. Notably, this pipeline also outputs another point cloud/point_cloud/sampled, which is later used for environment scanning, as described in Supplementary Material C.

We use the Nav2 framework (Macenski et al., 2023) to ensure that the robot can plan and navigate toward a desired pose (position and orientation) in the environment, which is also completely compatible with the SLAM_Toolbox discussed previously. Using the 2D navigation map provided by SLAM, the Nav2 framework can plan and navigate a path as a function of the destination’s pose, the robot’s current pose, and the robot’s kinematic constraints with respect to its surroundings. A 2D pose is defined as x ≔ x y ψ T , where x and y define the longitudinal and lateral displacements, and ψ is the orientation of the robot about the z -axis (vertical displacement).

The Nav2 framework includes an array of tools such as planners, recoveries, and controllers. It is outside the scope of this paper to experiment with different tools. Therefore, we mainly used the default configuration with minor adjustments that correspond to the robot’s kinematics. Since the robot’s movement can be controlled using 2D velocities x ̇ , y ̇ , θ ̇ as inputs, we can consider the robot to behave similarly to a differential wheeled robot. With this in mind, we can use Nav2’s default planner NavFn Planner.

Finally, since the Nav2 framework requires a desired pose as an input, it serves as a local planner and navigator. Therefore, in order to achieve autonomy in the robot, we require a higher-level navigation approach capable of identifying and selecting ROIs to navigate within the environment.

To effectively cover the environment, the robot must follow a path that ensures it traverses every corner of the space. This path should align with the trajectory of the occupied areas, e.g., corridors. This approach is generally effective under the assumption that the environment is confined within a bounded, occupied space, such as an indoor setting. In order to create the path, we process the 2D navigation map as an 8-bit array using the algorithm, as shown in Algorithm 1. M , H , and W denote the map and the map’s height and width, respectively. The map is divided into cells using the map resolution R in m/pixel. Each of these cells is an element in M , m i j , which only contains one of the three types of space: occupied, free, and u n k n o w n , represented by the integers 0, 255, and 128, respectively.

Algorithm 1

The 8-bit 2D navigation map M is processed into an unordered set of waypoints V , where each element is a waypoint v ∈ R 2 .

1: Input: Navigation map, i.e., M ∈ N H × W

First, an indoor environment is considered. In such cases, most unknown cells inside the map are located outside the boundaries of the occupied area, e.g., beyond the walls. This is because SLAM initially represents the environment as a grid of unknown cells before any exploration occurs. Furthermore, unknown cells often persist between occupied and free regions as a result of occlusions encountered during raycasting-based measurements, such as those performed using LiDAR, as shown in Figure 6a. Consequently, this unknown space cannot be reached by the robot and can be treatedas part of the boundaries—i.e., as occupied space, as shown in Figure 6b.

To establish a smooth connection between occupied cells affected by noise in the map, a Gaussian filter (D’Haeyer, 1989) is applied using a standard deviation parameter σ ∈ N , as shown in Figure 6c. Subsequently, in order to restore the binary representation of the occupied and free cells, the filtered result is binarized using a threshold parameter κ ∈ [ 0,255 ] . A cell with a value greater than κ is classified as a free cell; otherwise, it is designated as an occupied cell.

Due to residual noise and the presence of transparent obstacles, such as windows, there may be free cells that are unreachable to the robot. To mitigate this issue, we assume that the navigable space for the robot corresponds to the largest 2D contour. First, the contours within the map are found using the marching cubes algorithm (Lorensen and Cline, 1998). The map is then reconstructed by filling the largest 2D contour with a value of 255, as shown in Figure 6d. It is worth noting that by filling only the largest contour, obstacles within that contour are not takeninto account.

To ensure that the robot maintains a safe distance from the occupied space during navigation, the free space in the map is reducedusing a morphological filter called erosion (Khosravy et al., 2017), as shown in Figure 6e. Erosion uses a structuring element K , also referred to as a kernel, which determines the width to be removed. For the sake of simplicity, we consider a square matrix of 1s as our structuring element: K = 1 k 1 k T , where k determines the length of the vector and k = 1,2,3 , … . The larger the k value, the larger the safe distance. In addition, the safe distance decreases as R decreases. Therefore, k ∝ R . This also removes narrow passages that prove impassable for the robot.

The remaining free space is reduced to a thin one-pixel-wide representation containing O pixels, which corresponds to the topological skeleton of the map’s geometry, as shown in Figure 6f. In a practical scenario, the time complexity of 2D skeletonization is mainly proportional to the total number of pixels in an image P as it iterates until the object becomes one pixel wide. Therefore, it can be considered O ( P ) (Zhang and Suen, 1984).

The 2D skeleton map M S is then flattened into an unordered set that describes the x - and y -positions of every 2D point by transforming the pixel coordinates into real-world coordinates using the origin o and resolution R of the 2D navigation map. Only those pixels for which m S , i j = 255 are considered in this transformation. Considering that the skeleton contains O pixels, it follows that there are O waypoints in V . We refer to every such 2D point defined by the skeleton as waypoints, which are denoted as v i ∈ R 2 , where 0 ≤ i ≤ O . The waypoints serve as points of interest for the robot to visit.

In order to scan the whole environment, the robot should perform the scanning procedure for each waypoint. Therefore, the objective is to determine a path that includes every waypoint the robot must visit while optimizing for time efficiency. Ultimately, this can be considered a Traveling Salesman Problem (TSP), which we approach by formulating a fast and efficient path-planning algorithm. It takes a connected acyclic graph G as the input and outputs a path P , which is the ordered set of waypoints. In other words, P is a sequence of vertices v i traversed by the robot.

In order to construct the graph G , we treat the unordered set of waypoints V , obtained from the map reader, as the set of vertices. Each vertex in V uniquely corresponds to the coordinate vector of a waypoint and can, for the sake of simplicity, be denoted as v i ∈ R 2 , ∀ i = 1   … , O . Each vertex is then connected to other vertices if they are neighbors around the map’s resolution R . This should resemble the skeleton representation of the map, where the connections define the edges E of the graph G .

Algorithm 2 outlines the procedure for obtaining an efficient path P * for coverage exploration of the whole environment. First, there are dead ends found in the skeleton representation of the map. For the robot to cover the whole environment, we can utilize these dead ends. Each dead end is identified as a leaf vertex v leaf ∈ V leaf and is typically defined with degree 1. Assuming the graph G is connected and acyclic, complete coverage of the map can be achieved by ensuring that the robot visits every leaf vertex in V leaf in sequence. Since all other vertices in the graph lie on the paths connecting the leaves, traversing to each leaf inherently requires passing through the intermediate vertices. As a consequence, visiting all leaf vertices implies that the entire graph has been traversed.

After identifying all leaf vertices, the leaf vertex closest to the robot’s current 2D position x 0 is selected as the initial source leaf vertex v leaf,start using Algorithm 3. For every source leaf vertex v leaf,start , we find the next nearest unvisited leaf vertex as the target v leaf,target using FindNearestLeaf, as defined in Algorithm 3. We find the shortest path P ′ between the source v leaf,source and the target v leaf,target given the graph G . To achieve this, we use the method FindShortestPath, which essentially utilizes Dijkstra’s algorithm. This algorithm has a time complexity of O ( | E | + | V | log | V | ) , where | V | and | E | denote the total number of vertices and the total number of edges in the graph, respectively (Barbehenn, 1998).

Algorithm 2

A fast and efficient approach to planning a path P * , with L vertices, using the unordered set of waypoints obtained from the map reader V , map resolution R , waypoint resolution D , and the robot’s starting 2D position x 0 .

1: Input: Define graph G ( V , E )

Once P ′ is found, each vertex v i ′ ∈ P ′ is appended into P . Unless some vertex v i ′ reappears as a path of a different path P ′ , revisiting and scanning this position is unnecessary and should be avoided to conserve time and computational resources. Once iterated over all v i ′ in P ′ , v leaf,start is inserted into a set of visited leaf vertices V leaf,visited , and v leaf,target becomes the next source v leaf,start . Not only is the shortest path useful for appending v i into P but also for ensuring a feasible and unobstructed trajectory through occupied spaces.

This is iterated until all leaf vertices have been added and P is complete. Nevertheless, because the original distance between every two waypoints is approximately equal to the map’s resolution, a significant amountof time is spent on scanning with minimal displacement. Considering that the robot has a large scanning range capability of 30 m, which allows it to scan distances greater than the map resolution, we can increase the distance between every two waypoints to some arbitrary distance D by reducing P by a factor of D / R , where D ≥ R . This is achieved by selecting every D / R th element in P .

To achieve autonomy that enables the robot to visit the waypoints and perform a scanning procedure in succession, an activity diagram is formulated, as shown in Figure 4a. We can group two or more activities as a singular state if the transitions are consecutive without interruptions, e.g., a decision node. This state will perform all activities in their respective order. On the other hand, each decision node becomes a state that checks whether its control variable has reached a specified threshold. Each state has a conditionless trigger that automatically transitions the current state to the next specified state at the end of its action.

Algorithm 3

A method to find the nearest leaf vertex v leaf,target from a set of selected leaf nodes V leaf ′ to a given source x 0 using Euclidean distances.

1: Function FindNearestLeaf

With a FSM, we can achieve the desired autonomous navigation based on the triggers by handling the sequence of actions. The implemented state machine diagram is shown in Figure 4b. Each state is explained as follows:

• In State: Load Map, an existing 2D navigation map is loaded into SLAM, allowing the robot to localize itselfwith respect to the map’s metadata (meter-per-pixel resolution, width and height both in pixels, and origin as ( x , y ) in meters) and the robot’s concurrent surroundings using 2D laser scans. After this map is loaded, it is then analyzed to generate a list of waypoints, each in ( x , y ) coordinates, for the robot to visit using the map reader. An optimal route is then planned to visit all of these waypoints, which reorders the original list using the path planner. Finally, it automatically transitions to the next state, State: Check Waypoints.

To sum up, the proposed framework for navigation consists of three key modules: the map reader to extract POIs using the 2D navigation map as waypoints, the path planner to order the waypoints as an efficient route given the robot’s current position, and the state machine to enable the robot to navigate toward every waypoint and scan consecutively.

Before presenting the main results, we first validate the accuracy of the 2D navigation maps generated by the SLAM module. The average map is derived by normalizing over the five 2D navigation maps obtained from five trials, as illustrated in Figure 5. The width and height of these maps range between [196,225] and [185,231] pixels, respectively. We take the inner corner of the left- wing (upper left triangle of the map) of the room as the origin to align the maps in position and orientation accordingly. Analysis of the averaged map reveals that the right wing exhibits a wider range of shades of gray about the occupied space, suggesting that this part of the environment is slightly tilted relative to its actual orientation. Nonetheless, this does not severely affect the map reader, path planning, and navigation as the robot mainly localizes itself in its immediate surroundings and the topological skeleton of the map can still be found. For instance, as shown in Figure 6, the map reader can still create waypoints mainly using the map’s geometry, which also enables the robot to visit the corners by producing branches from the main path to these corners.

To evaluate the time efficiency of the map reader, we record the duration required to process each map across five trials, considering a total of N = 100 instances. We vary the weights in terms of the dimension per map. To facilitate a clearer representation in the plot, we use the product of the dimensions, H × W , in pixels. As shown in Figure 7a, we can observe that the average time taken for the map reader ranges from 2.34 ms to 2.70 ms over the five trials, with an average standard deviation of approximately 0.30 ms. We can also observe that the mean time increases by 22.0 ns for every additional pixel in the map. For instance, with a map of size H × W = 1 0 6 pixels, the expected mean time is T read ≈ 23.6 ms.

To remain within a maximum time taken of 1.0 s, the map should not be larger than the size of H × W = 45.4 × 1 0 6 pixels. Assuming a square map with a map resolution of 0.10 m, this maximum map has a length of 673.4 m. Hence, our proposed map reader is fast for relatively small to large map sizes (ranging up to 45.4 × 1 0 6 pixels) within a lead time of T read = 1.0 s, especially when the map reader is only run once to produce the waypoints given the map’s geometry.

To determine the path planner’s time efficiency, we repeat the same process with the evaluation of the map reader over N = 500 iterations per trial. Instead, we vary the weights in terms of the number of waypoints per map. In Figure 7b, we can observe that the mean time taken ranges between 1.40 ms and 2.00 ms. The variances can be explained by the additional time required to find the next nearest leaf vertex from a source vertex as it searches the list sequentially. According to the trend line, the lead time increases by 8.17 μs for every additional waypoint. Therefore, according to the trend line, it means that for a map with 1,000 waypoints, the planning time becomes T plan ≈ 6.18 ms, and for a map of 1 0 6 waypoints, the planning time is T plan ≈ 8.17 s.

To stay within a lead time of 1.0 s, the number of waypoints should not be larger than 1.219 × 1 0 5 . The bottleneck appears if the map resolution R becomes small as it increases the number of pixels per meter in a map. This can substantially increase the number of waypoints by a factor of R / R ′ , where R ′ is the new map resolution and R ′ < R . Nonetheless, the path planner can be considered fast for a small to large number of waypoints, given a reasonable map resolution R . It is also worth noting that it also runs only once to produce the necessary path.

To verify the path planner’s performance, we first evaluate the logic of whether it works as intended. Using one trial as an example, we observe that the path planner has created an optimal path in terms of time, based on the given waypoints and the robot’s current 2D position, as shown in Figure 8a. Furthermore, according to Figure 8b, we can observe that the mean waypoint–waypoint distance is approximately 1.00 m, given the previously set waypoint resolution D . The variance can be explained by the fact that the robot skips waypoints that have already been visited as it is unnecessary to scan the same position twice. This results in the robot having to travel distances of 1.00 m or more for some intervals. In contrast to traveling a longer distance, the robot can also visit the next waypoint in a shorter distance. This is because the path splicing happens at the end of the algorithm, whereby it results in a probability that two waypoints are less than the set waypoint resolution. Nevertheless, this does not heavily affect navigation, and the average waypoint distance is almost identical to the set waypoint resolution D .

To determine the robot’s navigational performance, we evaluate it according to the two aforementioned metrics, as shown in Table 2. In addition, Figure 9 shows the time taken for each waypoint over all trials. We can observe that the robot is able to reach 86.5% of the total waypoints across all trials, with a median time of 5.38 s per waypoint. As shown in Figure 9, this was achieved in an average time of 8.525 s, with a standard deviation of 11.4 s.

We can see several outliers where the robot took time ranging from 10.0 s to a few minutes to complete the navigation to the adjacent waypoint, for instance, at waypoint 17 in trial 1. This can be explained by Nav2 trying to create a local path that ends precisely within the desired tolerances in position and orientation, and because the robot requires a minimal input velocity in order to move, it overshoots the target, causing Nav2 to replan the local path. This can result in the robot becoming stuck indefinitely and requires assistance from a human operator. For some of these outliers, ranging from 30 s, human assistance is eventually required to reposition the robot correctly within the desired position and orientation tolerance.

Furthermore, Table 2 shows that in trials 3 and 5, the robot failed to reach all of the waypoints. This is mainly due to map drifts that occur over time and the fact that the SLAM module was still operating by mapping the robot’s surroundings online. This can be recognized, e.g., as two identical hallways slightly tilted relative to one another, as shown in Figure 10. Due to the drift in the navigation map, since the coordinates of the waypoints remain the same, SLAM adjusts the 2D navigation map such that the later waypoints appear in places that the robot cannot reach, such as in the walls. Drift usually occurs because we only use relative sensors to localize itself with respect to the surroundings, e.g., IMU, leg encoders, and LiDAR. This can cause the uncertainty to increase over time, which is inherent in odometry.