Grid-Based DBSCAN Clustering Accelerator for LiDAR’s Point Cloud

Abstract

Autonomous robots operate on batteries, rendering power efficiency essential. The substantial computational demands of object detection present a significant burden to the low-power cores employed in these robots. Therefore, we propose a grid-based density-based spatial clustering of applications with a noise (DBSCAN) clustering accelerator for light detection and ranging (LiDAR)’s point cloud to accelerate computational speed and alleviate the operational burden on low-power cores. The proposed method for DBSCAN clustering leverages the characteristics of LiDAR. LiDAR has fixed positions where light is emitted, and the number of points measured per frame is also fixed. These characteristics make it possible to impose grid-based DBSCAN on clustering a LiDAR’s point cloud, mapping the positions and indices where light is emitted to a 2D grid. The designed accelerator with the proposed method lowers the time complexity from $O\left(n^2\right)$ to $O\left(n\right)$. The designed accelerator was implemented on a field programmable gate array (FPGA) and verified by comparing clustering results, speeds, and power consumption across various devices. The implemented accelerator speeded up clustering speeds by 9.54 and 51.57 times compared to the i7-12700 and Raspberry Pi 4, respectively, and recorded a 99% reduction in power consumption compared to the Raspberry Pi 4. Comparisons of clustering results also confirmed that the proposed algorithm performed clustering with high visual similarity. Therefore, the proposed accelerator with a low-power core successfully accelerated speed, reduced power consumption, and effectively conducted clustering.

1. Introduction

With advancements in object detection through various sensors, autonomous driving technology has been studied for driverless driving, anticipated to alleviate human labor in the future [1,2,3,4]. Additionally, with the development of internet of things (IoT) technology, tasks like serving and delivery are now being replaced by autonomous robots [5,6]. These robots recognize objects and avoid obstacles with the help of multiple sensors to reach their destinations. A common characteristic among these autonomous robots is their reliance on batteries. Because of the limited capacity of the batteries, power efficiency becomes crucial for robots. Additionally, applying many sensors or power-intensive cores is a significant burden for the development of autonomous robots [7,8]. Therefore, autonomous robots adopt energy-efficient cores or sensors designed for low-power devices. However, low-power cores generally offer inferior performance compared to standard cores, posing a challenge for executing algorithms that require extensive computation on autonomous robots.

In autonomous driving, sensors employed for object detection include camera sensors, also called image sensors, radio detection and ranging (RADAR) sensors, ultrasonic sensors, and light detection and ranging (LiDAR) sensors. Among them, The camera and LiDAR are sensors that recognize objects on their own without the need for other sensors. These sensors, based on high resolution, allow for the identification of the specific size and shape of objects. Camera sensors recognize objects based on 2D planar RGB images, with artificial intelligence technologies such as regions with convolutional neural networks features (RCNN) and you only look once (YOLO), which is commonly applied in object detection [9,10,11,12]. LiDAR works by emitting light and measuring the time it takes for the reflected light to return, thus determining the location of objects. By emitting and detecting multiple light beams simultaneously, LiDAR identifies the reflected positions of these beams and represents them as points, which collectively form a point cloud. This point cloud consists of three-dimensional data with x, y, and z coordinates. RADAR sensors utilize radio waves for object recognition, offering longer detection distances and greater robustness in adverse weather conditions compared to LiDAR. However, they exhibit lower resolution and a narrower viewing range than LiDAR. Consequently, RADAR is often fused with other sensors to enhance performance in object recognition tasks [13,14,15,16]. Camera sensors struggle with object detection in dark or unlit areas, whereas LiDAR, which measures distance with light, performs better in such environments but experiences issues with light interference in bright conditions. Additionally, both sensors do not function properly when objects are visually obscured or when light is blocked or scattered due to adverse weather conditions. Consequently, cameras, LiDAR, RADAR, and other sensors adopted in autonomous driving work together to complement each other’s weaknesses [16,17].

There are two methods for object detection with LiDAR: one is supervised learning such as deep learning [18] and support vector machine (SVM) [19], and the other relies on unsupervised learning such as clustering [20]. Among various methods, Clustering forms clusters or groups based on the positions of points and the distances between them, allowing for the detection of untrained obstacles.

Object detection through clustering LiDAR’s point clouds has been conducted with various clustering algorithms, including K-means clustering [21], hierarchical clustering [22], and several density-based clustering algorithms [23]. K-means clustering has a relatively low time complexity of $O\left(n\right)$ but requires a predefined number of clusters, which is a hindrance in autonomous driving where the number of objects encountered is unpredictable. Hierarchical clustering allows for easy modification of the number of clusters, but it has a high time complexity of $O\left(n^3\right)$. Among density-based clustering methods, density-based spatial clustering of applications with noise (DBSCAN) is commonly applied for clustering with LiDAR’s point clouds [24,25]. The DBSCAN algorithm clusters based on the density of points, treating areas with sparse points as noise, which means clustering does not include all points in clusters and vary the number of clusters formed. With these characteristics of the algorithm, DBSCAN, an unsupervised learning method, detects untrained objects in varying situations and selectively clusters only obstacles, providing significant advantages in autonomous environments.

Figure 1 illustrates stages of the DBSCAN clustering algorithm. First, a random point is selected, and the distances to nearby points are measured. Based on computed distances, it is determined whether a certain number of points ($MinPts$) exist within a specific radius ($eps$) from the core point. If the number of points within the radius exceeds $MinPts$, the core point and the points within this distance form one group. Once a group is formed, another point within the group is selected and the process repeats, measuring distances to nearby points and deciding whether to form a new group. If a new group is formed, it merges with the existing group to which the core point belongs. If not, another point within the group is chosen to search for possible group formation. This process of checking each point in the group continues until all possible group formations have been searched, concluding the merging for that group. Once one group is fully formed, the process starts again with a random point that has not been included in any group. This continues until all points have been checked for group formation, at which point the clustering process is completed.

The DBSCAN Clustering algorithm, with a time complexity of $O\left(n^2\right)$, combined with the fact that LiDAR’s point cloud data contain numerous 3D points, means that object detection with LiDAR involves substantial computational effort. Consequently, such machine learning-based object detection methods are primarily conducted in environments capable of processing a large number of operations quickly. Moreover, in autonomous driving, object detection methods compute and deliver results quickly based on real-time data, making processing speed even more critical. However, for small autonomous robots like delivery robots that embed low-power cores to conserve battery efficiency, this high volume of computation not only presents a burden in terms of power, but also results in processing speeds slow enough to hinder real-time object detection. Therefore, small delivery robots require a reduction in the amount of computation involved in object detection or need separate accelerators to efficiently speed up processing in terms of power and time.

This paper proposes a LiDAR point cloud DBSCAN clustering accelerator connected to a low-power core. The proposed DBSCAN clustering accelerator integrates the previously mentioned DBSCAN algorithm to enhance computational speed and offloads the computational workload from the core. The DBSCAN algorithm applied in the accelerator employs a method of clustering based on indices, which is optimized for solid-based LiDAR, and the computational load of the accelerator has been reduced through quantization. The DBSCAN clustering accelerator was evaluated by interfacing it with a Cortex-M0 to verify its functionality on low-power cores. This confirmed that the proposed DBSCAN clustering accelerator efficiently recognizes objects through LiDAR’s point cloud without excessive power consumption, even in power-sensitive applications like autonomous robots.

The main contributions of this paper are as follows:

• The DBSCAN algorithm with grid for solid state LiDAR effectively saved computational burden.
• The DBSCAN accelerator significantly decreases computation time of clustering.
• The feasibility of the DBSCAN accelerator in autonomous robots was confirmed by connecting it to a low-power core, demonstrating effective object detection with low power consumption.

The paper is organized as follows: Section 2.1 discusses related work on LiDAR DBSCAN clustering, low-power object detection, and the DBSCAN clustering accelerator. Section 3 describes the architecture and operation of the designed DBSCAN clustering accelerator with a low-power core, with detailed explanations of the structure and operating principles of the included DBSCAN clustering accelerator. Section 4 presents the experimental setup and results for the accelerator. Finally, Section 5 concludes the paper, summarizing the research and contributions.

2. Related Work

2.1. DBSCAN LiDAR Clustering

Attempts to cluster LiDAR data began in 2008, when point cloud data from terrain features like mountains measured by LiDAR were leveraged to differentiate between ground and off-ground [26]. The hierarchical and K-means clustering methods were employed for data mining, and experiments have confirmed the applicability of clustering algorithms to LiDAR’s point cloud data. In 2013, researchers [27] compared different kinds of clustering algorithms applied on LiDAR’s point cloud data for the first time. The study measured the similarity of clusters with adjusted rand index (ARI) compared to manually clustered data from an overhead view of LiDAR data and the time taken for density-based clustering and ordering points to identify the clustering structure (OPTIC) clustering algorithms. DBSCAN clustering results in a slightly better ARI than OPTIC clustering, verifying its suitability for LiDAR’s point cloud. The following describes a study about DBSCAN clustering on LiDAR’s point clouds. The study [28] involves automatic parameter tuning for DBSCAN clustering in autonomous driving scenarios, setting different $eps$ and $MinPts$ for objects at varying distances, achieving comparable accuracy to the original results. Additionally, the study [29] applies automatic $eps$ estimation for DBSCAN segmentation of LiDAR data, employing the average of the maximum distances of k-nearest neighbors, and conducts experiments on mobile and airborne LiDAR data to improve accuracy. The experiments [29] resulted in accuracies of 75%, 74%, and 71%, which are higher than that of experiments with arbitrary parameters. The study in 2019 [30] organized effective DBSCAN clustering in two stages: the first stage involved ground plane fitting to obtain subclusters, then DBSCAN clustering was applied to these subclusters, efficiently avoiding oversegmentation problems. Furthermore, various studies attempt object detection on LiDAR’s point cloud with the DBSCAN clustering algorithm [31,32,33]. Additionally, efforts for precise object detection with DBSCAN clustering include calibrating with camera sensors [34,35] and integrating deep learning [33,36]. Other clustering algorithms are also being adopted for object detection in LiDAR’s point clouds across various studies [20,37].

2.2. DBSCAN Clustering Accelerator

Since the initial application of the DBSCAN method to LiDAR point cloud data in the 2013 study [26], the necessity to accelerate clustering speeds to enable the use of DBSCAN-based object detection in autonomous driving has emerged. One approach to enhance DBSCAN speed involves parallelizing the process. The study for parallelizing [38] adopted a disjoint-set data structure for parallelization of DBSCAN clustering, which improves memory efficiency and accelerates processing time up to 25.97 times. An advancement of this method, highly parallel DBSCAN, divides the area for local clustering and conducts parallel DBSCAN clustering considering the computation load of each area [39]. During the merging of labeled groups, re-labeling occurs at the boundaries.

Reducing the time complexity of the algorithm also contributes to an increase in the speed of the DBSCAN clustering. In 2013, researchers [40] drew a grid at $eps$ intervals and incorporated the neighboring cells into a range query, applying a grid in partitioning based on 2D clustering. A study in 2020 [41] applies grid-based DBSCAN and a sliding window approach to large datasets, effectively reducing time with $O(n$$\sqrt{n}$) while maintaining accuracy similar to the original DBSCAN algorithm. 3D voxel-based clustering applies grid-based DBSCAN on 3D point clouds [42]. A study [43] adopts grid-based DBSCAN for parallel processing with a tree structure, enabling merge groups for various numbers of clusters, reducing the time complexity to $O(n$$logn$). For efficient DBSCAN clustering, the optimization of the time complexity of algorithms is being studied with various methods [44,45,46].

Table 1. Analysis of related works for efficient DBSCAN clustering in time complexity.

Ref.	Algorithm	Time Complexity	Features
KM Kumar et al., 2016 [44]	G-DBSCAN	$O(n+nd)$	A novel graph-based index structure method that groups data to accelerate the neighbor search operations.
Y Chen et al., 2021 [45]	BLOCK-DBSCAN	$O(n$$logn$)	Approximation algorithm for large-scale data, judging whether two Inner core blocks are density reachable.
Y Wang et al., 2020 [29]	Practical Parallel DBSCAN	$O(n$$logn$)	Grid-based DBSCAN for parallel processing, with tree structure enabling merge groups for a variety # of clusters
N Ohadi et al., 2020 [41]	SW-DBSCAN	$O(n$$\sqrt{n}$)	Grid-based DBSCAN and a sliding window approach to large datasets
N Hanafi et al., 2022 [46]	OP-DBSCAN	$O(nk+nu)$	Using local samples and concept of operational dataset to find neighbors

d = # of dimensions of pattern, k = size of operation (OP), u = # of update operation.

organizes time complexity of each related work.

Other methods propose employing AI chips [47] to accelerate DBSCAN for large datasets. On such study [47] adopts a bitwise method for neighboring identification instead of compare-and-select operations, which are not familiar to AI chips, and two speculative execution strategies to eliminate data overhead. Evaluation of the study [47] shows 2.61 times speedup on NVIDIA RTX 3090. Similarly, ray tracing DBSCAN (RT-DBSCAN) leverages ray-tracing hardware for acceleration by translating fixed-radius nearest neighbor queries to ray-tracing queries [48].

A hardware accelerator is also an effective method for accelerating DBSCAN clustering. Two studies [49,50] implemented parallel DBSCAN on field programmable gate array (FPGA) to enhance clustering speed. One study [49] includes a processing elements (PE) array and collision check system, which is proper for FPGA. The other study [50] performs DBSCAN clustering on a multidimensional dataset and demonstrates a consistently brief execution time, regardless of the number of points. Additionally, studies [51,52] apply DBSCAN to millimeter wave (MMW) and radio frequency (RF) signals on FPGAs, enabling high-speed communications in noisy conditions. Another study [53] performs DBSCAN clustering on FPGAs for knowledge discovery of high-dimensional time series data and proposes the clustering system for high throughput and performance which supports fast machine learning.

Our previous research [54] also verified the operation of a DBSCAN accelerator designed with Verilog and implemented on an FPGA, which successfully accelerated the clustering and demonstrated the feasibility of a DBSCAN clustering accelerator for LiDAR’s point clouds.

2.3. Low-Power Object Detection

As research on object detection progresses, studies on low-power object detection have also commenced. The study [55] investigates real-time object detection methods for low-power embedded platforms and proposes approaches including finding suitable layers for the hardware, recognizing the limitations of processors and memory, identifying blocks with low computational complexity, and considering sparsification and quantization. Another study [56] suggests a high-power efficiency real-time object detection system. Optimization on the CNN algorithm and on the hardware platform achieves high accuracy and low energy consumption when implemented on FPGA.

Similarly, research into clustering for low-power applications has been conducted. The research [57] explored the implementation of clustering algorithms on low-power and high-performance devices, comparing the power efficiency with algorithms run on standard cores. While the clustering speed on low-power cores did not match that of standard cores, it demonstrated significantly better power efficiency.

2.4. Object Detection for Autonomous Driving with Various Sensors

Object detection for autonomous driving is conducted using various sensors, including cameras, LiDAR, and RADAR. These sensors are utilized independently or in combination through sensor fusion to perform object recognition. To achieve object detection for autonomous driving with camera sensors, one approach involves the use of fisheye lenses. While fisheye lenses offer the advantage of a wide field of view, they introduce distortions that affect the accuracy of object recognition. Consequently, research has been conducted to correct these distortions, thereby enhancing the accuracy of object detection [58,59].

Another important sensor is the RADAR sensor using millimeter-wave (mmWave) technology. MmWave utilizes high-frequency radio waves to detect objects, providing longer detection ranges and strong resistance to environmental changes compared to other sensors, although it has the drawback of lower resolution. Object detection using mmWave is typically performed through sensor fusion with cameras, complementing the limitations of visual information provided by cameras. This sensor fusion approach enables more accurate and reliable object detection in autonomous driving systems, contributing to enhanced safety and efficiency [14,60,61].

3. Architecture

3.1. DBSCAN Clustering System with a Low-Power Core

Figure 2 illustrates the block diagram of the system. The proposed design is organized around the advanced high-performance bus (AHB) and the advanced peripheral bus (APB). Modules requiring high-speed bus interfaces for data transfer, such as the Cortex-M0, on-chip memory for code and data, and the DBSCAN clustering accelerator, are connected to the AHB. Peripheral modules that do not necessitate high-speed data communication, such as GPIO, universal asynchronous receiver transmitters (UART), and a timer, utilize the APB interface. The AHB to APB bridge facilitates communication between the two buses by changing bus the signal.

The Cortex-M0, which is a low-power core, functions as the master of the AHB, accessing each module via addresses assigned to each peripheral and module, and reads and executes instructions fetched from on-chip memory, controlling the modules. The on-chip memory comprises two sections: one for storing the instruction codes necessary for program execution and another for storing data required during code execution on the core. The UART communicates with the PC, transmitting the point cloud dataset for clustering to register arrays on the accelerator. Once clustering is complete for all frames, the grouped data stored in register arrays are transmitted to the PC via the UART module. The GPIO module facilitates additional control based on the clustered group data by connecting to extra modules by supporting communication with other sensors or motors.

Figure 3 represents the flow of the DBSCAN clustering system. For executing the Cortex-M0, bit-stream compiled on Keil uVision 5 with C codes is stored on on-chip memory for code. Then x, y, z coordinates data and a list of pixels which is sorted in order to cluster them, defined as a seed-list are then transmitted to register arrays in a clustering accelerator from on-chip memory. With the start signal occurring after the save is finished, the clustering accelerator clusters the frame with the stored data in register memory arrays. When the clustering is finished, the accelerator transmits the group information resulting from the clustering accelerator to the PC via UART.

3.2. DBSCAN Clustering Accelerator

3.2.1. Proposed DBSCAN Algorithm

The clustering algorithm adopted in the proposed DBSCAN clustering accelerator differs from the original DBSCAN algorithm. The original DBSCAN algorithm requires distance information between the core point and all other neighbor points for clustering. However, calculating distances for every point in numerous points during the clustering operation for each core point is computationally intensive and inefficient. The proposed method for the DBSCAN clustering applies the characteristics of LiDAR. LiDAR has fixed positions where light is emitted, and the number of points measured per frame is also fixed. These characteristics make it possible to impose grid-based DBSCAN on clustering LiDAR’s cloud points, mapping the positions where light is emitted to a 2D grid.

Figure 4 is a 2D-mapped solid-state LiDAR point cloud. The proposed algorithm is designed based on the hardware specifications of LeddarTech’s Pixell LiDAR. LeddarTech’s Pixell covers approximately 180 degrees and emits light from 768 points, distributed across eight vertical and ninety-six horizontal positions, after which, it measures the distance. Thus, indices are mapped to 768 pixels for the proposed clustering algorithm. Figure 5 illustrates the horizontal angle of the field and positions.

Assigning indices reduces computational load since point information is stored and retrieved with index IDs. Furthermore, the accelerator minimizes the number of operations for clustering. Additionally, instead of measuring distances between a core point and all other points or having a pre-measured distance map for clustering, the proposed algorithm measures distances only for the eight pixels surrounding the core index pixel shown as Algorithms 1,  2 and Figure 4. In the figure, the core pixel is indicated by a black box, and the surrounding pixels are indicated by a red box. This method clusters by measuring distances only for these eight mapped indices, checking if the distances are smaller than $eps$. This approach reduces the time complexity from $O\left(n^2\right)$ in traditional DBSCAN to $O\left(n\right)$ in the proposed method. A pixel becomes a core pixel either by being added to a group or selected as a seed pixel. Each pixel only becomes a core pixel once during the entire clustering process. The number of distance calculations when a pixel becomes a core is limited to a maximum of eight, resulting in a total of $8n$ times distance measuring operations per frame. In contrast, the original DBSCAN requires each of n pixels to measure distances n times, each with a more numerous computational load than the suggested algorithm. Therefore, the designed DBSCAN clustering accelerator aims to alleviate the number of operations performed with the proposed DBSCAN algorithm.

Algorithm 1 Proposed grid-based DBSCAN algorithm

Require: $eps,$ $MinPts,$ $SeedList$ 1: $PosPixel\leftarrow \varnothing$ 2: for $seed$ $point$ $s\in SeedList$ do 3:     if $AlreadyInGroup\left(s\right)$ then 4:         Continue 5:     end if 6:     while $PosPixel\ne \varnothing$ do 7:         $core$ $point$ $c=p\in PosPixel$ 8:         if $AlreadyInGroup\left(p\right)$ then 9:            Continue 10:         end if 11:         $Group$ ∪ $Clustering(c,eps,MinPts)$ 12:         $PosPixel$ ∪ $Clustering(c,eps,MinPts)$ 13:     end while 14:     $Grouplist$ append $Group$ 15:     $PosPixel,$ $Group\leftarrow \varnothing$ 16:     $core$ $point$ $c=seed$ $point$ s 17:     $Group$ ∪ $Clustering(c,eps,MinPts)$ 18:     $PosPixel$ ∪ $Clustering(c,eps,MinPts)$ 19: end for

Algorithm 2 Clustering(c, $eps$, $MinPts$)

Require: $c,$ $eps,$ $MinPts$ 1: for $i\in SurroundPixels$ do        ▹ maximum 8 iterations 2:     if $Dist(c,i)>eps$ then 3:         $Group3x3\leftarrow i$ 4:     end if 5: end for 6: if # $of$ $Group3x3>MinPts$ then 7:     return $Group3x3$ 8: else 9:     return ∅ 10: end if

3.2.2. Architecture

Figure 6 illustrates the structure of the DBSCAN clustering accelerator. The DBSCAN clustering accelerator consists of a grouping core and various register arrays such as pix use, seed list, xyz-list, and group-list. The pix-use array contains 768 1-bit signals, indicating whether a pixel index is included in a group (signaled by 1) or not yet grouped (signaled by 0) during clustering for a frame. The seed-list array and grouping core reference the pix-use array to determine if a seed pixel is already contained in a group or if a new pixel to be stored is already part of another group. The seed-list stores the index order of pixels to be clustered and xyz-list stores the x, y, z coordinate data corresponding to each index. Original DBSCAN clustering begins by selecting a core point from random points. However, as a random generator is difficult to implement in hardware environments, seed-list provides an index order of pixels. This order prioritizes pixels likely to form groups for each frame to facilitate clustering. The seed-list sequentially provides seed pixels upon request, checking via the pix-use array whether the seed pixel is part of a group before providing the seed pixel index to the grouping core. The xyz-list stores 24-bit data for each index, with x, y, z coordinate data occupying 8 bits each. Upon receiving a signal with a specific pixel index, the xyz-list provides the x, y, z coordinate data after one clock cycle. The group-list receives signals from the grouping core when a group is fully formed, and sequentially stores the indices of pixels included in the group. When clustering for all pixels is complete, the grouping core sends a frame-cplt signal, prompting the group-list to transmit the group information for the frame externally. Thus, each register array stores information about each pixel and connects to the grouping core, aiding in the clustering process.

The grouping core performs DBSCAN clustering based on LiDAR’s point cloud data. The clustering process is divided into five main stages, shown as Figure 7, starting after the data are stored in the xyz-list and seed-list. These stages are seed-chk, pix-avl, group3x3, group-add, and save-group and the flow of the stages in the grouping core is illustrated in Figure 8. In the seed-chk stage, the grouping core sends a signal to the seed-list to get a seed pixel. If seed finding is complete, it goes to pix-avl stage. In the pix-avl stage, clustering determines which pixel is a core point, seed pixel or pos pixel. Pos-pixel comprises pixels included in the forming group. If the selected core pixel’s x, y, z coordinates are not dummy data, a calculating neighbor pixel is applied in stage group3x3. In group3x3, the distance is computed from the core pixel indicated as a red box in Figure 8 to up to eight surrounding pixels to determine if the number of points within the $eps$ and compared with the number of pixels in group3x3, including the core pixel whether number meets or exceeds $MinPts$. If no group has formed, it goes to seed-chk and a seed-pixel is brought in as the new core pixel. If a group is forming, the group-add stage merges a newly formed small group to an existing group if one exists, or creates a new group if none exists. Once the group-add process is completed, it returns to the pix-avl stage and a pixel index from the pos-pixel group is designated as the core pixel. If no pos pixels remain for further core pixel evaluation after a group is formed, the process transitions to the save-group stage where the newly formed group is saved to the group-list. After the save-group is completed, the entire process is repeated until all pixels have undergone the grouping process. When clustering ends, a frame completion signal is sent to the group-list. Subsequently, the group-list is transmitted as per the core’s request.

4. Implementation and Analysis

4.1. Environment Setup

The dataset for validating the DBSCAN clustering accelerator is Pixset [62]. Released by LeddarTech in 2021, the Pixset dataset encompasses data from a combination of sensors, including cameras, LiDAR, RADAR, and IMUs. Each piece of data extracted from these sensors is timestamped with synchronized timing, which helps with object detection through sensor calibration. The Pixset dataset includes measurements from various urban environments such as highways, city streets, suburban areas, and boulevards, and also covers a range of weather conditions, including cloudy, snowy and rainy at various times of day. Thus, the Pixset dataset provides point cloud data that closely reflect real-world driving environments and include realistically occurring obstacles.

The LiDAR equipment hired in the Pixset dataset [62] is LeddarTech’s Pixell LiDAR, which refreshes frames at a rate of 20 Hz and measures up to 768 points per frame across a grid of ninety-six horizontal and eight vertical lines, with a field of view spanning 177.5 degrees horizontally and 16.0 degrees vertically. This wide coverage makes the Pixell suitable for experiments that cover large areas with a single LiDAR unit. The detection range of the Pixell is up to 56 m for an object which has 80% reflectivity, with a maximum detection range of 32 m for pedestrians. The proposed clustering accelerator is designed to perform object detection solely based on LiDAR point clouds. Additionally, for object detection on low-power cores, it is crucial to reduce computational load with a modest dataset. Pixell’s relatively low number of 768 points per frame makes it well-suited for experiments involving accelerators connected to low-power cores. The designed accelerator is optimized for the size of the Pixell dataset, enhancing area efficiency.

The point cloud data from the Pixset dataset are not immediately suitable for the accelerator and need several modifications. First, dummy data padding is applied for indexing. The LiDAR data in the Pixset dataset consist of raw data measured by the light emitted and received by the LiDAR, not x, y, z coordinate data. As distance calculations in clustering relies on differences in x, y, z coordinates, the application programming interface (API) provided by LeddarTech is imported on raw data [62]. The API synchronizes data from multiple sensors via timestamps and extracts available data from raw data with the Pixset dataset. The API also provides a function to extract x, y, z coordinates from raw LiDAR data. However, the extracted coordinates do not cover indices for all pixels, meaning not all points in a frame are represented in the data. This is because points that are not measured are omitted from the frame. To proceed with the proposed clustering method, indices for each point in the dataset are necessary. Therefore, based on the extracted x, y, z coordinates, angles were measured with the specification of the angle of the field of the LiDAR and indices were assigned to each point. Indices that were not assigned are padded with designated dummy values, which does not affect clustering. Consequently, each frame contains x, y, z coordinates for 768 indexed points. The extracted x, y, z coordinates were quantized to be optimized in hardware environments. Since the Pixell LiDAR detects pedestrians up to 32 m away, points exceeding 30 m were designated as noise. Furthermore, as floating-point operations consume significant computational resources in hardware environments, x, y, z coordinates are quantized to 8-bit values, ranging from 0 to 255 for each x, y, and z. By applying two modifications of the dataset, the experiment is implemented with a lightweight dataset.

4.2. Experiments

The experiments were conducted in three scenarios. Initially, clustering is performed on a software program of an original DBSCAN algorithm and a software program of a proposed grid-based DBSCAN algorithm, written in python code, implemented on standard core with a quantized dataset. Next, Raspberry Pi 4 model B as a low-power device implements Python-coded software using version 3.12.2 of proposed algorithm on the quantized dataset. Lastly, the proposed DBSCAN clustering accelerator, which is connected to a low-power core, is designed with Verilog and implemented on an FPGA. The standard core applied in experiments to compare the results of the core that consumes normal power is an Intel’s i7-12700 CPU, which operates on 2.1 GHz. The Raspberry pi 4 model B operates on 1.5 GHz and an embedded ARM Cortex-A72 microprocessor and results in efficient power consumption. The experiments compared the power consumption and processing time on clustering across three platforms. Groups formed through clustering were visually compared to confirm the successful implementation and operation of the algorithm.

The experimental setup for validating the proposed accelerator and details about the FPGA board are depicted in Figure 9. The FPGA board is a custom-designed board for verifying the accelerator. The FPGA includes a low-power core, which is the Cortex-M0, and a proposed accelerator. The main FPGA is Altera’s MAX 10 (10M50SCE114C8G). The FPGA board has a UART port to receive the bit-stream containing the code to be executed on the core and to transmit the clustering results, a JTAG for uploading the proposed design to the MAX 10, and GPIOs to connect various sensors on Cortex-M0 for the future work. The FPGA receives the code to be executed and the dataset of the frame via UART, performs clustering via a reset button, and then sends the clustering results back through UART. The proposed design with the Max 10 FPGA operates on 50 MHz, which is relatively slow and consumes less power.

Table 2. The hardware resources of the Acc. with Cortex-M0 and only Acc.

	LUTs	Registers	BRAMs	Logic Elements
Max 10	-	-	1,677,321	49,760
Acc. with Cortex-M0.	24,806	16,170	296,996 (18%)	30,533 (61%)
Only Acc.	17,648	13,687	34,816 (2%)	22,972 (45%)

represents the hardware resources of the proposed accelerator with Cortex-M0 and only one accelerator. The hardware resources are analyzed with the number of look-up tables (LUTs), Registers, and block random access memories (BRAMs). The hardware implementation uses 17,648 LUTs, 13,687 Registers and 34,816 BRAMs when only DBSCAN accelerator is synthesized, utilizing and 24,806 LUTs, 16,170 Registers, 296,996 BRAMs when the proposed accelerator with Cortex-M0 is synthesized. Each employs 61% and 45% logic elements, and 18% and 2% BRAMs of MAX 10, demonstrating the proposed accelerator with a low-power core runs on MAX 10 FPGA without hardware overhead.

The experiments were conducted on a total of 3806 frames recorded in various conditions such as downtown, suburban, and main roads during clear, cloudy, rainy weather, at both day and night.

Table 3. Specification of each dataset in Pixset.

	Dataset (a)	Dataset (b)	Dataset (c)	Dataset (d)	Dataset (e)
Time	day	day	night	day	day
Weather	clouds	clouds	clouds	clouds	rain
Location	downtown	suburban	boulevard	highway	boulevard
# of frames	2929	290	275	190	122

shows the information of each dataset. The proposed accelerator was tested on 20 frames from each dataset, a total of 100 frames.

Table 4. Average Processing times per frame on each platform.

Platform	Dataset (a)	Dataset (b)	Dataset (c)	Dataset (d)	Dataset (e)	Average
Original DBSCAN, i7-12700	220.35	253.8	220.4	245.8	230.07	224.48
Proposed algorithm, i7-12700	7.87	14.91	8.29	7.24	7.24	8.45
Raspberry Pi 4	43.87	63.85	46.27	44.74	44.74	45.69
Proposed Accelerator *	0.89	0.88	0.89	0.87	0.9	0.886

All results are expressed in milliseconds [ms]. * Proposed accelerator is tested by 20 frames on each dataset.

measures the average clustering processing time per frame on different platforms. For the original DBSCAN algorithm clustered on the i7-12700, the average processing time per frame was recorded at 224.48 ms, while for the proposed grid-based algorithm, the processing time was reduced to 8.45 ms, demonstrating that quantization, which optimizes the clustering process for LiDAR, effectively shortens processing times. Clustering on the Raspberry Pi 4, which adopts quantized data, resulted in a comparatively slower average processing time of 45.69 ms relative to other platforms. On the other hand, the proposed accelerator recorded an average processing time of just 0.886 ms per frame. Thus, the proposed algorithm speeds up the clustering process by 21.88 times compared to the original DBSCAN algorithm, and the proposed accelerator speeds up the clustering process by 51.57 and 9.54 times each compared to the low-power device, Raspberry Pi 4 and a standard core i7-12700, which used quantized data, showing significant improvements on processing time.

Table 5. LiDAR’s point cloud clustering results compared to raw pictures from a camera sensor on same frames.

Dataset	Raw Picture	Original DBSCAN SW	Proposed Algorithm SW	Proposed Acc.
Dataset (a), frame 997
Dataset (b), frame 24
Dataset (c), frame 166
Dataset (d), frame 41
Dataset (e), frame 37

presents a visual comparison of LiDAR’s clustering results involving the original DBSCAN algorithm, proposed algorithm, and the proposed accelerator, alongside the raw pictures from a camera sensor included in the Pixset on same frames. Clustering of the original DBSCAN algorithm and proposed grid-based DBSCAN algorithm was performed on a standard core through Python, while the proposed accelerator employed a low-power core. Through the visual comparison of clustering results for each frame, the clustering involving the proposed algorithm and the accelerator proceeded correctly without significant differences compared to the clustering involving the original DBSCAN algorithm in visual.

To compare the power consumption of the clustering accelerator with a low-power core implemented on MAX 10, the power consumed during clustering on each platform was analyzed. Power consumption is calculated based on the formula from [57]. The formula produces the execution time (T) and thermal design power (TDP) to obtain power consumption information on the system for executing clustering. More precisely,

$$H=T·TDP=\left[second\right]·{\displaystyle \frac{\left[Joule\right]}{\left[second\right]}}$$

(1)

Table 6. Power consumption of clustering on each platforms.

	Quantized, i7-12700	Raspberry Pi 4	FPGA
TDP (W)	65	2.7	1.035
$H\left(J\right)$	0.54925	0.12336	0.00092

presents the TDP and power consumption of the system during clustering of the Pixset dataset for three different clustering platforms. The TDP for the i7-12700 is based on processor base power data provided by Intel, while for the Raspberry Pi 4, TDP is based on idle power consumption from power consumption benchmarks. The power consumed by the FPGA is based on power estimation performed through Quartus for a MAX 10 FPGA running at 50 MHz. The i7-12700’s TDP is 65 W, which is common to CPU for a desktop. And Raspberry Pi 4 and FPGA’s TDP are each 2.7 W and 1.035 W, which indicates the feature of a low-power device. The H, computed for power consumption, of i7-12700 is 0.54925 J, which is higher, despite the fast speed of clustering. The Raspberry Pi 4’s H is computed as 0.12336 J, which is low, despite Raspberry Pi 4’s low speed of clustering. However, the FPGA’s H is recorded as 0.00092 J, which is very low value compared to Raspberry Pi 4’s H, which is also a low-power device, showing a 99% reduction rate on power consumption. As a result, the FPGA, on which the proposed accelerator is implemented, effectively lessens the power consumption compared to other platforms.

5. Conclusions

Research on autonomous robots has continued to progress and commercial attempts at developing object detection technology, essential for autonomous navigation, have been made. However, object detection in autonomous robots equipped with batteries considers power efficiency and is thus capable of operating on low-power cores. To execute object detection in autonomous robots, we propose a grid-based DBSCAN clustering accelerator for LiDAR’s point cloud.

The proposed accelerator employs an algorithm adapted to the characteristics of LiDAR, using grid-based DBSCAN clustering. The algorithm performs 2D mapping based on the emission points of LiDAR light and assigns indices to each location. By bounding distance calculations to adjacent indices, the proposed algorithm decreases the algorithm’s time complexity from $O\left(n^2\right)$ to $O\left(n\right)$. The accelerator is connected to the Cortex-M0 through AHB, allowing operation within a low-power environment.

Experiments of clustering were executed on quantized data with original DBSCAN algorithm through the i7-12700 and the proposed DBSCAN algorithm through i7-12700, Raspberry Pi 4, and the proposed accelerator with a low-power core implemented on an FPGA, with outcomes compared across these platforms. The proposed algorithm revealed a reduction in time due to streamlined computations, and the proposed accelerator exhibited faster clustering speeds than other platforms. Power efficiency assessments further indicated that the proposed accelerator with a low-power core surpassed the Raspberry Pi 4 in performance. Visually comparing the clustering results across platforms confirmed that the proposed algorithm successfully conducts clustering and that the results from the proposed accelerator are consistent with those from other platforms.

This research verifies the feasibility of the a proposed DBSCAN clustering accelerator with a low-power core and the proposed accelerator with a general purpose core has scalability to connect other various sensors, especially a LiDAR. Attaching the LiDAR on the core allows real-time object detection with the proposed accelerator, and diverse applications for autonomous robots. To be applied in diverse applications, verifying the operation with various LiDAR specifications is essential to enhance the algorithm.