Point cloud data processing methods, equipment and vehicles

By using hardware logic processing with multi-level counter groups and multiplier arrays, invalid data is filtered and addresses are mapped in real time, solving the problem of high latency in point cloud data processing. This enables low-latency direct transmission from sensors to storage, improving data processing efficiency and real-time performance.

CN123114374APending Publication Date: 2026-11-17ZHEJIANG LINGAI FUTURE TECHNOLOGY CO LTD +1
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611339204.7
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-31
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In existing technologies, point cloud data processing has high latency, which cannot take advantage of the high-speed acquisition of solid-state LiDAR and affects the vehicle's real-time decision-making and response capabilities.

Method used

A multi-level counter group and a multiplier array work together to filter invalid data in real time and dynamically map addresses. Combined with a burst transmission mechanism, it realizes low-latency direct transmission of point cloud data. Data filtering, address calculation and transmission control are completed through hardware logic.

Benefits of technology

It enables microsecond-level low-latency direct transmission of point cloud data from sensors to storage, improving data processing efficiency and real-time performance, and reducing latency and resource consumption in the software processing chain.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123114374A_ABST
    Figure CN123114374A_ABST
Patent Text Reader

Abstract

This application provides a method, device, and vehicle for processing point cloud data, relating to the field of vehicle technology. The method includes: acquiring multiple point cloud data sets; wherein the multiple point cloud data sets are obtained by filtering raw point cloud data collected in real-time by the vehicle under driving conditions. Then, a first storage address for each point cloud data set is calculated using a preset first multi-level counter group, and the corresponding point cloud data is written into a dual-port memory based on the first storage address; next, in response to reading point cloud data from the dual-port memory, a second storage address for each point cloud data set is calculated using a preset second multi-level counter group, and the corresponding point cloud data is written into a target requester based on the second storage address for downstream application layer access. Through the above method, low-latency direct transmission of point cloud data from the sensor to the memory is achieved.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This application relates to the field of vehicle technology, and in particular to a method, device and vehicle for processing point cloud data. Background Technology

[0002] LiDAR, as a core sensor in autonomous driving and advanced driver assistance systems, is used to acquire point cloud data of the surrounding environment. However, point cloud data is usually generated in a high-frequency, high-density discrete form, requiring complex packaging, storage, and transmission processes before it can be processed by downstream application layers.

[0003] In existing technologies, software solutions based on system-on-chip (SoC) are commonly used to complete packet assembly and storage. The core idea of ​​this method is to utilize the high integration of SoC chips to run specific software or firmware on them. This relies on software logic to filter invalid data, reassemble multiple packets, and move memory to point cloud data. This results in significant latency, which fails to leverage the high-speed acquisition advantage of solid-state LiDAR and thus restricts the vehicle's real-time decision-making and response capabilities.

[0004] In summary, providing a processing method that enables low-latency direct transmission of point cloud data from sensors to memory is a technical problem that urgently needs to be solved. Summary of the Invention

[0005] This application provides a method, device, and vehicle for processing point cloud data, which enables microsecond-level low-latency direct transmission of point cloud data from acquisition to storage.

[0006] In a first aspect, embodiments of this application provide a method for processing point cloud data, including:

[0007] Multiple point cloud data are acquired; wherein the multiple point cloud data are obtained by filtering the raw point cloud data collected in real time by the vehicle under driving conditions.

[0008] The first storage address of each point cloud data is calculated by using a preset first multi-level counter group, and the corresponding point cloud data is written into the dual-port memory based on the first storage address.

[0009] In response to reading point cloud data from the dual-port memory, the second storage address of each point cloud data is calculated using a preset second multi-level counter group, and the corresponding point cloud data is written to the target requester based on the second storage address so that the downstream application layer can call the multiple point cloud data.

[0010] In one possible implementation, the first multi-level counter group includes two multi-level counter groups, each of which includes a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter.

[0011] The step of calculating the first storage address of each point cloud data through a preset first multi-level counter group includes:

[0012] The multiple point cloud data are split into two data packets to obtain a first point cloud data packet and a second point cloud data packet.

[0013] For each point cloud data in each point cloud data packet, the point cloud data is counted sequentially using the packet counter, the first segment counter, the vertical packet counter, the first subframe counter, and the second subframe counter to obtain the first storage address of the point cloud data.

[0014] In one possible implementation, the step of sequentially counting the point cloud data using the packet counter, the first segment counter, the vertical packet counter, the first subframe counter, and the second subframe counter to obtain the counting result of the point cloud data includes:

[0015] The point cloud data is incremented by the packet counter. When the first count value output by the packet counter reaches the first count range of the packet counter, the first segment counter increments.

[0016] The second count value output by the first segment counter is input into the first multiplier to obtain the first count result, and when the second count value reaches the second count range of the first segment counter, the vertical package counter is started to increment the count;

[0017] The third count value output by the vertical packet counter is input into the second multiplier to obtain the second count result. When the third count value reaches the third count range of the vertical packet counter, the first subframe counter is started to increment.

[0018] The fourth count value output by the first subframe counter is input into the third multiplier to obtain the third count result. When the fourth count value reaches the fourth count range of the first subframe counter, the second subframe counter is started to increment.

[0019] The fifth count value output by the second subframe counter is input into the fourth multiplier to obtain the fourth count result;

[0020] The first storage address is obtained based on the first counting result, the second counting result, the third counting result, and the fourth counting result.

[0021] In one possible implementation, the method further includes:

[0022] When the point cloud data in the first point cloud data packet or the point cloud data in the second point cloud data packet are both written into the dual-port memory, the point cloud data is read out in sequence and written into the pre-configured first data buffer queue.

[0023] And / or,

[0024] The frame information packet data corresponding to the multiple point cloud data are written into the pre-configured second data buffer queue.

[0025] In one possible implementation, the second multi-level counter group includes a line counter, a second segment counter, a third subframe counter, and a frame counter;

[0026] The step of calculating the second storage address of each point cloud data through a preset second multi-level counter group includes:

[0027] When the amount of point cloud data in the first data buffer queue reaches a preset burst transmission length threshold, the point cloud data stored in the first data buffer queue is divided into multiple point cloud data blocks according to the burst transmission length threshold.

[0028] For each point cloud data block, the starting storage address of the first point cloud data in the point cloud data block is calculated sequentially using the row counter, the second segment counter, the third subframe counter, and the frame counter.

[0029] The starting storage address is determined as the second storage address of each point cloud data in the point cloud data block.

[0030] In one possible implementation, the step of calculating the starting storage address of the first point cloud data within the point cloud data block sequentially through the row counter, the second segment counter, the third subframe counter, and the frame counter includes:

[0031] The first point cloud data is incremented by the row counter, and the sixth count value output by the row counter is input into the fifth multiplier to obtain the fifth count result; when the sixth count value reaches the fifth count range of the row counter, the second counter increments.

[0032] The seventh count value output by the second segment counter is added to each count value between the starting value of the seventh count range of the second segment counter to obtain the sixth count result. When the seventh count value reaches the seventh count range, the third subframe counter is started to increment.

[0033] The eighth count value output by the third subframe counter is added to each count value between the starting value of the eighth count range of the third subframe counter to obtain the seventh count result. When the eighth count value reaches the eighth count range, the frame counter is started to increment.

[0034] The ninth count value output by the frame counter is input into the sixth multiplier to obtain the eighth count result;

[0035] The starting storage address is obtained based on the fifth, sixth, seventh, and eighth counting results.

[0036] In one possible implementation, the operation rule of the multiplier is as follows: each count value between the starting value of the counter's counting range and the count value output by the counter is multiplied by the preset weight coefficient corresponding to the multiplier and then accumulated to obtain the operation result of the multiplier.

[0037] In one possible implementation, the method further includes:

[0038] For each point cloud data block, after writing the point cloud data block to the target requester based on the corresponding second storage address, a row interrupt signal is generated;

[0039] After all the point cloud data are written to the target requester, the frame information packet data is read from the second data buffer queue and written to the target requester to generate a frame interruption signal.

[0040] Secondly, embodiments of this application provide a point cloud data processing apparatus, comprising:

[0041] The first processing module is used to acquire multiple point cloud data; wherein, the multiple point cloud data are obtained by filtering the raw point cloud data collected in real time by the vehicle under driving conditions.

[0042] The second processing module is used to calculate the first storage address of each point cloud data through a preset first multi-level counter group, and write the corresponding point cloud data into the dual-port memory based on the first storage address.

[0043] The third processing module is used to respond to reading point cloud data from the dual-port memory, calculate the second storage address of each point cloud data through a preset second multi-level counter group, and write the corresponding point cloud data to the target requester based on the second storage address so that the downstream application layer can call the multiple point cloud data.

[0044] In one possible implementation, the first multi-level counter group includes two multi-level counter groups, each of which includes a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter.

[0045] The second processing module is specifically used for:

[0046] The multiple point cloud data are split into two data packets to obtain a first point cloud data packet and a second point cloud data packet.

[0047] For each point cloud data in each point cloud data packet, the point cloud data is counted sequentially using the packet counter, the first segment counter, the vertical packet counter, the first subframe counter, and the second subframe counter to obtain the first storage address of the point cloud data.

[0048] In one possible implementation, the second processing module is further configured to:

[0049] The point cloud data is incremented by the packet counter. When the first count value output by the packet counter reaches the first count range of the packet counter, the first segment counter increments.

[0050] The second count value output by the first segment counter is input into the first multiplier to obtain the first count result, and when the second count value reaches the second count range of the first segment counter, the vertical package counter is started to increment the count;

[0051] The third count value output by the vertical packet counter is input into the second multiplier to obtain the second count result. When the third count value reaches the third count range of the vertical packet counter, the first subframe counter is started to increment.

[0052] The fourth count value output by the first subframe counter is input into the third multiplier to obtain the third count result. When the fourth count value reaches the fourth count range of the first subframe counter, the second subframe counter is started to increment.

[0053] The fifth count value output by the second subframe counter is input into the fourth multiplier to obtain the fourth count result;

[0054] The first storage address is obtained based on the first counting result, the second counting result, the third counting result, and the fourth counting result.

[0055] In one possible implementation, the device further includes a fourth processing module for:

[0056] When the point cloud data in the first point cloud data packet or the point cloud data in the second point cloud data packet are both written into the dual-port memory, the point cloud data is read out in sequence and written into the pre-configured first data buffer queue.

[0057] And / or,

[0058] The frame information packet data corresponding to the multiple point cloud data are written into the pre-configured second data buffer queue.

[0059] In one possible implementation, the second multi-level counter group includes a line counter, a second segment counter, a third subframe counter, and a frame counter;

[0060] The third processing module is specifically used for:

[0061] When the amount of point cloud data in the first data buffer queue reaches a preset burst transmission length threshold, the point cloud data stored in the first data buffer queue is divided into multiple point cloud data blocks according to the burst transmission length threshold.

[0062] For each point cloud data block, the starting storage address of the first point cloud data in the point cloud data block is calculated sequentially using the row counter, the second segment counter, the third subframe counter, and the frame counter.

[0063] The starting storage address is determined as the second storage address of each point cloud data in the point cloud data block.

[0064] In one possible implementation, the third processing module is further configured to:

[0065] The first point cloud data is incremented by the row counter, and the sixth count value output by the row counter is input into the fifth multiplier to obtain the fifth count result; when the sixth count value reaches the fifth count range of the row counter, the second counter increments.

[0066] The seventh count value output by the second segment counter is added to each count value between the starting value of the seventh count range of the second segment counter to obtain the sixth count result. When the seventh count value reaches the seventh count range, the third subframe counter is started to increment.

[0067] The eighth count value output by the third subframe counter is added to each count value between the starting value of the eighth count range of the third subframe counter to obtain the seventh count result. When the eighth count value reaches the eighth count range, the frame counter is started to increment.

[0068] The ninth count value output by the frame counter is input into the sixth multiplier to obtain the eighth count result;

[0069] The starting storage address is obtained based on the fifth, sixth, seventh, and eighth counting results.

[0070] In one possible implementation, the operation rule of the multiplier is as follows: each count value between the starting value of the counter's counting range and the count value output by the counter is multiplied by the preset weight coefficient corresponding to the multiplier and then accumulated to obtain the operation result of the multiplier.

[0071] In one possible implementation, the device further includes a fifth processing module for:

[0072] For each point cloud data block, after writing the point cloud data block to the target requester based on the corresponding second storage address, a row interrupt signal is generated;

[0073] After all the point cloud data are written to the target requester, the frame information packet data is read from the second data buffer queue and written to the target requester to generate a frame interruption signal.

[0074] Thirdly, embodiments of this application provide an electronic device, including: a memory and a processor;

[0075] The memory stores computer-executed instructions;

[0076] The processor executes computer execution instructions stored in the memory, causing the processor to perform the first aspect and / or various possible implementations of the first aspect as described above.

[0077] Fourthly, embodiments of this application provide a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the first aspect and / or various possible implementations of the first aspect.

[0078] Fifthly, embodiments of this application provide a computer program product, including a computer program that, when executed by a processor, implements the first aspect and / or various possible implementations of the first aspect.

[0079] In a sixth aspect, embodiments of this application provide a vehicle, including a vehicle body and a controller, the controller being used to perform the first aspect and / or various possible implementations of the first aspect as described above.

[0080] This application provides a method, device, and vehicle for processing point cloud data. First, multiple filtered point cloud data are acquired. Then, the first storage address of each point cloud data in a dual-port memory is calculated in real time using a preset first multi-level counter group and written. In response to reading the point cloud data in the dual-port memory, the second storage address of each point cloud data in the target requester is calculated in real time using a preset second multi-level counter group and written. Finally, the data is provided for downstream application layer to call. Using the above method, the complete storage process of point cloud data from the acquisition end to the target requester is decomposed into a two-stage hardware pipeline. Specifically, the first stage completes the fast buffering of data from the sensor front end to the dual-port RAM, and the second stage completes the reorganization and writing of data from the dual-port RAM to the target memory. The entire process is completed independently by pure hardware logic for address calculation and data transfer, without the need for central processing unit intervention. This fundamentally eliminates the processing latency introduced by interrupt response, context switching, and multiple data copies in the software processing link, enabling point cloud data to be stored in the dual-port RAM and the target requester in a compact and continuous manner. Finally, a complete self-describing data frame is formed in the target requester, providing downstream application layers with high real-time performance, high throughput, and directly callable data support. Attached Figure Description

[0081] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0082] Figure 1 A flowchart illustrating a point cloud data processing method provided in this application. Figure 1 ;

[0083] Figure 2 A flowchart illustrating a point cloud data processing method provided in this application. Figure 2 ;

[0084] Figure 3 A flowchart illustrating a point cloud data processing method provided in this application. Figure 3 ;

[0085] Figure 4 This application provides a logical diagram illustrating the first-stage packaging of multiple point cloud data.

[0086] Figure 5 A flowchart illustrating a point cloud data processing method provided in this application. Figure 4 ;

[0087] Figure 6 A flowchart illustrating a point cloud data processing method provided in this application. Figure 5 ;

[0088] Figure 7This application provides a logical diagram illustrating the second-stage packaging of multiple point cloud data.

[0089] Figure 8 A schematic diagram of the transmission logic of frame information packet data provided in this application;

[0090] Figure 9 A schematic diagram of a point cloud data processing device provided in this application;

[0091] Figure 10 This is a schematic diagram of the structure of an electronic device provided in this application.

[0092] The accompanying drawings illustrate specific embodiments of this application, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concept of this application to those skilled in the art through reference to particular embodiments. Detailed Implementation

[0093] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with some aspects of this application.

[0094] The application background of this application is explained as follows:

[0095] LiDAR, as an advanced active perception sensor, plays an indispensable role in autonomous driving and advanced driver assistance systems (ADAS) for automobiles. Its working principle involves emitting laser pulses and receiving the signals reflected back from the target. By precisely measuring the time or phase change of the laser from emission to return, the distance between the target and the sensor can be calculated. Combined with the scanning angle information of the laser beam, the three-dimensional spatial coordinates of the target can be obtained, generating high-precision environmental point cloud data. LiDAR has significant advantages such as high ranging accuracy, high angular resolution, strong anti-interference capability, and no limitation by lighting conditions. It provides vehicles with precise three-dimensional perception capabilities of their surroundings and is one of the key sensors for achieving high-level autonomous driving.

[0096] After completing environmental scanning, solid-state LiDAR needs to assemble the acquired point cloud data into standardized data packets for transmission and subsequent processing. Essentially, packet assembly involves organizing the point cloud data acquired by the Single-Photon Avalanche Diode (SPAD) sensor according to a pre-defined format and then sending it to the receiving end via an interface. Due to the large volume of point cloud data, to reduce on-chip storage resource overhead, the receiving end needs to write the assembled point cloud data into on-chip memory for caching in a specified format. The quality of the assembled data directly affects the efficiency of data transmission and the accuracy and real-time performance of subsequent processing.

[0097] In existing technologies, solid-state lidar generally employs a system-on-chip (SoC)-based software solution for packet assembly and storage. The core idea of ​​this method is to leverage the high integration of the SoC chip to run specific software or firmware, thereby completing the entire processing flow from raw signals to final point cloud data. Specifically, the SoC chip receives raw point cloud data collected from front-end sensors such as SPADs. Subsequently, the software running on the SoC chip uses preset processing algorithms to filter invalid data, reassemble multiple packets, and move data into memory. Finally, the complete data frame is stored in a designated storage area for downstream application layers to access.

[0098] However, with the continuous increase in solid-state LiDAR beamwidth and the sustained rise in point cloud data output rates, relying solely on software for data filtering, packaging, and transfer faces severe challenges. On the one hand, interrupt requests and data copying operations for massive amounts of raw point cloud data frequently consume central processing unit (CPU) resources, leading to excessive CPU load and affecting the normal execution of other real-time tasks. On the other hand, the software processing chain involves multiple data copies and context switching overheads, introducing uncertain processing delays. This makes it difficult to meet the microsecond-level low-latency direct transmission requirements for point cloud data from sensor acquisition to storage. Especially in high-speed driving scenarios, the accumulation of processing delays will directly affect the input timeliness of downstream perception algorithms, thereby constraining the overall response speed of the autonomous driving system.

[0099] In view of this, a point cloud data processing method is provided to solve the problem of high processing latency caused by frequent interruption response and data copying in the existing pure software processing method. This is an urgent technical problem to be solved in order to meet the requirement of microsecond-level low-latency direct transmission of point cloud data from sensor acquisition to storage.

[0100] Based on the aforementioned technical problems, the inventors, in their research on how to achieve microsecond-level low-latency direct transmission of point cloud data from sensor acquisition to storage, discovered that replacing pure software processing with a pure hardware pipeline architecture can fundamentally eliminate the processing latency introduced by CPU interrupt responses and data copying, thereby reducing system latency while improving storage and transmission efficiency. Specifically, a multi-level cascaded counter and a dedicated multiplication array work together to filter invalid data in real time and dynamically map addresses. Combined with a burst transmission mechanism, this achieves low-latency, high-bandwidth processing of point cloud data. In other words, point cloud data filtering, address calculation, and transmission control are all integrated into hardware logic to eliminate interrupt responses and memory copy overhead from software logic, thus significantly improving data processing efficiency in high real-time scenarios for solid-state LiDAR. Based on this, this application provides a point cloud data processing method, device, and vehicle.

[0101] The technical solution of this application and how it solves the above-mentioned technical problems will be described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will be described below with reference to the accompanying drawings.

[0102] Figure 1 A flowchart illustrating a point cloud data processing method provided in this application. Figure 1 This method is applied to embedded processors deployed in vehicles, such as domain controller processors, etc. Figure 1 As shown, the method includes:

[0103] S101: Acquire multiple point cloud data; wherein, the multiple point cloud data are obtained by filtering the raw point cloud data collected in real time by the vehicle under driving conditions.

[0104] During vehicle operation, the SPAD sensor in the lidar serves as the core of front-end photon detection, relying on the single-photon avalanche effect to complete photon detection and generate raw point cloud data.

[0105] Specifically, the lidar emits laser pulses that illuminate the surface of objects surrounding the vehicle. Upon encountering an object, the laser light is reflected, forming echo photons. Some of these echo photons propagate back to the lidar's receiving optical window, converge, and then enter the photosensitive area of ​​the SPAD pixel unit. When the photons reach the photosensitive area, they trigger an internal avalanche multiplication effect, generating an electrical pulse signal. The time-to-digital converter (TDC) integrated within the SPAD precisely records the laser emission and pulse reception times, calculating the distance between the target and the lidar based on the time-of-flight principle. Simultaneously, by combining the lidar's known pixel spatial pointing or scanning angle information, the distance, horizontal azimuth, and vertical pitch angles are converted into three-dimensional spatial coordinates, forming individual spatial points. The collection of tens of thousands of spatial points constitutes the raw point cloud data reflecting the contours of the surrounding environment.

[0106] SPAD sensors have multiple operating modes, including gray, echo, histogram, and ranging. In grayscale mode, the SPAD sensor only counts photons (without recording the precise arrival time of photons), converting the number of photons received per unit time into grayscale output, similar to a regular grayscale image sensor. It is mainly used to generate intensity grayscale images, focusing on reflecting the intensity of reflected light from the target object, and does not output distance information.

[0107] In echo mode, the SPAD sensor can identify multiple echo signals generated when the same emitted laser beam encounters different obstacles. When the laser beam passes through a semi-transparent object or encounters a multi-layered obstructed scene, different echoes will be generated one after another. This mode can output the information of multiple echoes at the same time, which can obtain the intensity of different echoes and also include the corresponding distance information. It is suitable for complex environments with multiple reflections, such as leaves and glass, and can distinguish the echoes of different reflective surfaces.

[0108] In direct ranging mode, the SPAD sensor, based on its integrated digital signal processing unit, directly converts the detected effective echo time information into the final distance value, which is then used as the output for that pixel. Specifically, after completing photon counting and echo peak detection, the SPAD sensor directly calculates the distance based on the half-value relationship between the speed of light and time of flight, and outputs the calculated value through the data interface. This mode minimizes the amount of data output because each pixel corresponds to only one distance value, greatly reducing the pressure on data transmission bandwidth and backend processing resources.

[0109] In histogram mode, the SPAD sensor internally performs cumulative measurements across multiple laser emission cycles, finely dividing the preset ranging time domain into several consecutive time bins. It then accumulates and counts the arrival events of photons received within each time bin, ultimately generating a complete histogram with time on the horizontal axis and photon count on the vertical axis. This mode outputs the largest amount of data among the four modes because it includes statistical information at every point on the time axis, rather than just extracting peak values ​​or calculating the final result. Therefore, it places higher demands on data transmission bandwidth and subsequent storage space.

[0110] Specifically, the SPAD sensor transmits the raw point cloud data it acquires to the embedded processor via a preset bus protocol, such as the transmit (TX) end of the Mobile Industry Processor Interface (MIPI), and the embedded processor receives the raw point cloud data via the receive (RX) end of the MIPI. It should be noted that the MIPI interface used in this application specifically refers to the Camera Serial Interface 2 (CSI-2) protocol and the D-PHY physical layer specification.

[0111] Given that SPAD sensors possess single-photon detection sensitivity, even weak reflected photons can be triggered for detection, enabling long-distance detection. However, stray photons from ambient sunlight can also trigger spurious counts in SPAD sensors. These invalid triggers generate a large number of noise points mixed in with the original point cloud. Further filtering is required to separate the point cloud data reflecting the true environmental information, removing invalid data generated by ambient light noise, dark current interference, and redundant echoes, resulting in multiple point cloud datasets. This process purifies the data at its source, providing a high-quality data source for subsequent storage and retrieval.

[0112] S102: Calculate the first storage address of each point cloud data using a preset first multi-level counter group, and write the corresponding point cloud data into the dual-port memory based on the first storage address.

[0113] In this step, the first multi-level counter group serves as the hardware logic unit for real-time generation of the first storage address of point cloud data, used to perform the first-stage packet assembly of the point cloud data. This counter group consists of cascaded multi-level counters. Compared to ordinary single-level counters, its multi-level architecture is more suitable for high-speed streaming output scenarios of point clouds, and can generate the corresponding continuous storage location number, i.e., the first storage address, in real time for the dual-port memory. The dual-port random access memory (RAM), as a private high-speed cache for the front-end acquisition hardware, has two independent read / write access ports, supporting high access speed and low deterministic latency. Its parallel read / write characteristics allow for simultaneous reading of stored data while receiving data written from the front-end point cloud data processing path, avoiding read / write blocking and meeting the high-speed pipelined processing requirements of vehicle-mounted LiDAR point clouds.

[0114] Specifically, during the initialization phase, the first multi-level counter group is configured to a reset state. During operation, each counter in the first multi-level counter group can count the point cloud data according to a preset counting range and carry logic, continuously accumulating in sync with the point cloud data output cycle. It then calculates the first storage address corresponding to each point cloud data point in real time and writes the current point cloud data to the dual-port RAM based on that address. The dual-port RAM is configured as a high-speed cache supporting simultaneous read and write operations. Once an address calculation is complete, the write control logic immediately takes effect, writing the current point cloud data to the storage unit corresponding to that address.

[0115] Through a hardware pipeline mechanism that counts, calculates, and writes simultaneously, point cloud data is continuously and compactly stored in dual-port RAM without the need for CPU intervention in address management, achieving zero-latency synchronization of data acquisition and storage.

[0116] S103: In response to reading point cloud data from the dual-port memory, the second storage address of each point cloud data is calculated using a preset second multi-level counter group, and the corresponding point cloud data is written to the target requester based on the second storage address so that the downstream application layer can call multiple point cloud data.

[0117] In this step, the second multi-level counter group is used to perform the second-stage packetization of the point cloud data, calculating the second storage address of the point cloud data read from the dual-port RAM in the target requester, thereby enabling data transmission to the target requester. The target requester possesses high bandwidth and large capacity characteristics, such as a fourth-generation Double Data Rate 4 (DDR4) memory, used to store complete frame data for downstream application layer access. The downstream application layer refers to the software algorithm stack running on the embedded processor's main operating system, located at the back end of the entire LiDAR data perception link. After the point cloud data is stored in the target requester at the second storage address, the downstream application layer can directly read the standard point cloud frame containing three-dimensional spatial coordinates and reflection intensity information through the device driver interface or shared memory access mechanism provided by the operating system kernel, supporting the downstream application layer in completing a series of high-level autonomous driving tasks such as environmental perception, target recognition, and driving decision-making.

[0118] Specifically, similar to the first multi-level counter group, the second multi-level counter group is configured to a reset state during the initialization phase. During operation, each counter in the second multi-level counter group counts the point cloud data read from the dual-port RAM according to a preset counting range and carry logic. The counts continuously accumulate following the output rhythm of the point cloud data, and the second storage address corresponding to each point cloud data is calculated in real time. Based on this second storage address, the current point cloud data is written to the target requester via a preset bus protocol. This bus protocol can be the AXI4 bus (Advanced eXtensible Interface 4, AXI4), which supports burst transmission and out-of-order response, possesses high-bandwidth data transmission capabilities, and is suitable for high-speed data paths between embedded processors and DDR4 memory. The entire process is controlled by pure hardware logic; address calculation and data writing are triggered immediately upon responding to a read action, ensuring the compactness and real-time nature of data flow. In one possible implementation, the bus protocol / interface can also be a Peripheral Component Interconnect Express (PCIe) or a Compute Express Link (CXL), etc.

[0119] Ultimately, the originally scattered point cloud data was reorganized into continuous data blocks that conform to the read / write characteristics of the target memory, improving bus transmission efficiency. The point cloud data stored in the target requester can be directly accessed by the downstream application layer for subsequent processing such as environmental perception and path planning, completing an efficient end-to-end flow from raw sensor data to application layer data.

[0120] The point cloud data processing method provided in this application embodiment is applied to an embedded processor deployed in a vehicle. It includes: acquiring multiple point cloud data sets, wherein these multiple point cloud data sets are obtained by filtering raw point cloud data collected by a SPAD sensor using single-photon avalanche effect photon detection; subsequently, performing a first-stage packet processing on the multiple point cloud data sets using a preset first multi-level counter group, accumulating the count in real time as the point cloud data flows in, generating a first storage address for each point cloud data set in real time through multiplication-addition combination operations, and writing the point cloud data into a dual-port RAM based on the first storage address. Next, in response to reading the point cloud data from the dual-port RAM, using a preset second multi-level counter group and the same hardware addressing logic, its second storage address in the target requester (such as a high-capacity, high-bandwidth DDR4 memory) is calculated in real time, and data writing is driven, ultimately reassembling the scattered point cloud data into a continuous data block conforming to the read / write characteristics of the target memory for direct use by the downstream application layer.

[0121] Using the above method, the entire process of point cloud data acquisition, filtering, address calculation, storage and transmission is automatically completed in the underlying logic circuit. This eliminates the need for repeated copying and protocol stack reassembly of point cloud data between multiple scattered memory blocks, fundamentally eliminating the system overhead caused by frequent interrupt responses and address translations. It enables microsecond-level low-latency direct transmission of point cloud data from SPAD sensor acquisition to DDR4 storage, resulting in an order-of-magnitude improvement in system response speed.

[0122] Based on the above embodiments, multiple point cloud data are obtained by filtering the raw point cloud data collected in real time by the vehicle under driving conditions, specifically including:

[0123] The original point cloud data is extracted using packet counters, segment counters, subframe counters, and frame counters. Invalid point cloud data is discarded, resulting in multiple point cloud data sets.

[0124] Specifically, each point cloud data in the raw point cloud data undergoes parallel or pipelined counting and judgment by packet counters, segment counters, subframe counters, and frame counters. Each of these four counters maintains an independent cyclic counting period. For example, the segment counter is set to a modulo-16 counting range of 0 to 15. Raw point cloud data with count values ​​between 0 and 5 are considered valid; conversely, raw point cloud data with count values ​​between 6 and 15 are considered invalid. Each point cloud data in the raw point cloud data passes through the packet counter, segment counter, subframe counter, and frame counter in a pipeline manner. Only when the point cloud data is determined to be valid on all counters (the count value of the point cloud data falls within the preset valid range of each counter) will it be finally confirmed as valid point cloud data and pass the screening process to proceed to the subsequent storage address calculation stage. Conversely, if the count value of the point cloud data falls into an invalid range on any counter, the point cloud data is determined to have failed the screening.

[0125] By using multi-level counters to filter the raw point cloud data and discard invalid point cloud data, invalid point cloud data is automatically identified and stripped at the hardware level, and only the valid point cloud data stream is written to the dual-port RAM, which greatly reduces the bandwidth pressure of subsequent processing.

[0126] As an alternative to the multi-level counter-based method for filtering raw point cloud data, hardware-level data filtering can be implemented using a register-configurable threshold comparator group or a programmable finite state machine. Specifically, by pre-writing key parameters such as packet type identifier, segment boundary definition, and subframe length into the hardware configuration register, the state machine performs branch matching and filtering judgments based on the real-time incoming data header identifier when point cloud data flows in, thus achieving a filtering function equivalent to a fixed counter. Furthermore, content-addressable memory can be introduced to perform hardware mask matching for invalid echo features, enabling filtering decisions to be completed in the early stages of point cloud data inflow. Compared to relying on a specific counting range of a counter to filter point cloud data, this alternative is not limited to preset counting boundaries but can adapt to different packet organization formats and filtering rules through flexible rewriting of register parameters, offering stronger mode compatibility and configuration flexibility.

[0127] Figure 2 A flowchart illustrating a point cloud data processing method provided for the application. Figure 2 ,like Figure 2 As shown, based on the above embodiment, the first multi-level counter group includes two multi-level counter groups. Each multi-level counter group includes a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter. In S102: the first storage address of each point cloud data is calculated through the preset first multi-level counter group, specifically including:

[0128] S201: Perform split processing on multiple point cloud data to obtain the first point cloud data packet and the second point cloud data packet.

[0129] Solid-state lidar outputs point cloud data characterized by large data volume and high arrival rate, making it difficult for a single processing path to complete the real-time packetization and storage of all point clouds within a limited clock cycle. Therefore, by splitting the processing of multiple point cloud data streams, each stream is evenly distributed to two independent processing branches, forming a first point cloud data packet and a second point cloud data packet. This allows the two subsequent processing pipelines to handle data throughput in a balanced manner, avoiding latency accumulation caused by overload on one side, thereby ensuring the real-time performance and throughput of the overall processing chain.

[0130] Specifically, each point cloud data point in the incoming stream can be numbered in real time using a packet counter that increments point by point. The packet counter can be set to a range of 0 to 1, meaning it contains only two count values. This implies that the packet counter increments with each arriving point cloud data point and wraps back to 0 after reaching 1, thus cyclically switching between the two states. The packet counter can use the current count value (0 or 1) as a routing identifier to alternately distribute continuously arriving point cloud data to the first processing branch (count value 0) and the second processing branch (count value 1), achieving a uniform polling distribution of point cloud data between the two pipelines.

[0131] For example, whenever a valid point cloud data packet enters the routing module, the packet counter increments by one bit and outputs an alternating binary bit that cycles through 0, 1, 0, 1, serving as the routing identifier for the current point cloud data. When the identifier is logic 0, the corresponding point cloud data is routed to Virtual Channel 0 (VC0) and included in the first point cloud data packet Vc0; when the identifier is logic 1, the corresponding point cloud data is routed to Virtual Channel 1 (VC1) and included in the second point cloud data packet Vc1.

[0132] The entire splitting process is completed by hardware logic within a single clock cycle without any software intervention, effectively ensuring that the data streams are already load-balanced and independent before entering the subsequent parallel packet assembly pipeline.

[0133] S202: For each point cloud data in each point cloud data packet, the point cloud data is counted sequentially using a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter to obtain the first storage address of the point cloud data.

[0134] In this step, the first multi-level counter group is configured to include two sets of symmetrical and parallel multi-level counter architectures to adapt to the high-speed concurrent data flow characteristics of the vehicle-mounted LiDAR sensor, and to achieve real-time synchronous tracking and address mapping of multi-channel data streams. Each multi-level counter group integrates five cascaded counting units of different granularities: a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter. Each counter is configured to increment in each clock cycle or data tick, and adopts cascaded logic of low-bit overflow triggering high-bit increment, together constructing a multi-dimensional counting space for mapping the physical location of point cloud data in the dual-port memory.

[0135] The counting range of each counter indicates the total number of states that the counter can accommodate and traverse before generating an overflow carry and driving the next level counter to increment; that is, the data granularity boundary represented by the counter in one complete counting cycle. For example, the counting range of each counter can be set as follows: the packet counter's counting range can be set to 0~1; the first segment counter is used for segment indexing within a single data packet, and its counting range can be set to 0~15; the vertical packet counter is used for packet sequence numbers corresponding to the vertical scanning direction, and its counting range can be set to 0~5; the first subframe counter and the second subframe counter are used to divide finer-grained subframe intervals, and both can have a counting range set to 0~2.

[0136] During the counting process, point cloud data is input to the packet counter, which accumulates according to the rhythm of the input point cloud data. When the packet counter overflows, it triggers the increment of the first-stage counter. Similarly, the first-stage counter, vertical packet counter, first subframe counter, and second subframe counter are cascaded sequentially. When the current-stage counter reaches its preset final value, it triggers the action of the next-stage counter. Taking continuously input point cloud data as an example, the initial value of the packet counter is 0. When the first point cloud data arrives, the packet counter increments by 1 to become 1. At this point, it has not yet reached its upper limit of 1, so no carry is triggered. When the second point cloud data arrives, the packet counter increments by 1 again. Since the counting range is only 0~1, the packet counter overflows and wraps back to 0, generating an overflow flag. This flag immediately serves as the increment trigger signal for the first-stage counter, causing it to increment from 0 to 1. Subsequently, the third point cloud data makes the packet counter become 1 (without overflow), and the fourth point cloud data causes the packet counter to overflow back to 0 again, triggering the increment of the first-stage counter from 1 to 2. This process repeats continuously. Every two point cloud data points (i.e., every complete 0→1→0 cycle of the packet counter) increments the first segment counter by 1. Once the first segment counter has accumulated from 0 to its final value of 15, the next packet counter overflow not only resets the first segment counter to 0 but also triggers the incrementing of higher-level vertical packet counters, thus forming a complete cascaded counting chain. The overflow event of a lower-level counter acts as a stepping pulse for the higher-level counter, enabling each level of counter to record data grouping information of different granularities in an orderly manner.

[0137] Converting the count values ​​of each counter level into a first memory address recognizable by the dual-port RAM requires a weighted summation operation using a multiplier. For each multi-level counter group, the first memory address corresponding to the current point cloud data is synthesized based on the current count value of each counter and the multiplier. This first memory address is a linear physical address used to indicate the absolute storage location of the point cloud data in the dual-port RAM. Based on the address calculation method using multi-level counter groups, high-speed flowing point cloud data can be mapped to write addresses in the dual-port RAM in real time. Whenever the address calculation for a point cloud data is completed, a write operation is immediately triggered to store it in the dual-port RAM. This streaming processing mechanism does not require central processing unit intervention to manage address pointers; it relies solely on hardware logic to complete the orderly storage of data, thereby ensuring strict synchronization between data acquisition and storage and significantly reducing system latency.

[0138] The point cloud data processing method provided in this application splits multiple point cloud data streams to obtain a first point cloud data packet and a second point cloud data packet. Then, for each point cloud data in each point cloud data packet, a preset first multi-level counter group is sequentially passed through it. Specifically, the first multi-level counter group includes two multi-level counter groups, each including a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter. That is, each point cloud data in the point cloud data packet is sequentially passed through the packet counter, the first segment counter, the vertical packet counter, the first subframe counter, and the second subframe counter to calculate its first storage address.

[0139] Using the above method, the entire process of splitting, counting, and address calculation is completed by hardware logic within a single clock cycle or a very short cycle, without the need for the central processing unit to manage the address pointer. This achieves a zero-latency synchronous pipeline that counts, calculates, and writes simultaneously, significantly reducing system latency and improving storage efficiency. It provides an orderly and compact data foundation for the efficient reading of subsequent point cloud data and the transmission to the target requester, ensuring that the downstream application layer can obtain complete point cloud frame information with minimal access latency.

[0140] Figure 3 A flowchart illustrating a point cloud data processing method provided in this application. Figure 3 , Figure 4 This application provides a logical diagram illustrating the first-stage packet assembly of multiple point cloud data sets, as shown below. Figure 3 and Figure 4 As shown, based on the above embodiment, in S202: for the first point cloud data packet (and similarly for the second point cloud data packet), the point cloud data is sequentially counted using a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter to obtain the first storage address of the point cloud data, specifically including:

[0141] S301: The point cloud data is incremented by a packet counter. When the first count value output by the packet counter reaches the first count range of the packet counter, the first segment of the counter increments.

[0142] As mentioned in S202, the packet counter, as the basic unit of the multi-level counter group, is configured to increment the count for each point cloud data entering the data path. Its counting range can be 0 to 1, that is, the first counting range is 0 to 1. Whenever a filtered point cloud data arrives, the packet counter's first count value increases by 1 until its internal count value fills the preset first counting range, for example, reaching the preset maximum value of 1. When the first count value reaches the upper limit of the first counting range, the packet counter generates a carry signal. This carry signal is directly connected to the clock enable or trigger terminal of the first stage counter, driving the first stage counter to perform one increment counting operation.

[0143] Understandably, before the packet counter completes a full overflow cycle—for example, if only sporadic point cloud data arrives and the packet counter's current first count value hasn't reached its upper limit (i.e., it hasn't jumped back from 1 to 0 and generated a carry pulse)—the trigger terminal of the first segment counter remains in an invalid state and will not receive any increment enable signal. Therefore, the first segment counter maintains its initial count value of 0 during this period. Only when the packet counter generates an overflow flag will the first segment counter be activated and incremented; otherwise, its count value will remain zero and will not change due to partial counting by lower-level counters.

[0144] S302: Input the second count value output by the first segment counter into the first multiplier to obtain the first count result, and start the vertical package counter to increment when the second count value reaches the second count range of the first segment counter.

[0145] The first counter records the segment position index of the point cloud data within the current packet, and its output second count value reflects the offset of the point cloud data in the segment dimension. By mapping the count value in this dimension to an offset in the physical address space of the memory, the second count value is input into the first multiplier in real time. The first multiplier is configured to calculate the first count result based on the second count value, the second count range, and the first preset weight coefficient corresponding to the first multiplier. The first preset weight coefficient corresponds to the number of data units contained in each segment, such as the number of point cloud data entries or bytes in each segment, which is determined according to the data packet organization structure and storage granularity of the point cloud data. The first count result is the segment base address offset of the current segment in the overall storage space. This offset (the first count result) is then sent to a subsequent adder and summed with the offsets from other counters (such as the packet counter, vertical packet counter, subframe counter, first subframe counter, and second subframe counter, etc.) after being scaled by the corresponding multipliers, thereby generating the final unique write address of the current point cloud data in the dual-port RAM.

[0146] In one possible implementation, the multiplier's operation rules are as follows:

[0147] Each count value between the starting value of the counter's counting range and the count value output by the counter is multiplied by the preset weight coefficient corresponding to the multiplier and then accumulated to obtain the result of the multiplier's operation.

[0148] The multiplier's operation logic is not simply a scalar multiplication of the single count value output by the counter at the current moment. Instead, it uses an integral logic of interval weighted accumulation to quantify and represent the continuous change process of all historical states from the starting point of counting to the current counting point. By transforming the dynamic accumulation process of the counter into a linear address space increment, it ensures a strict one-to-one correspondence between the storage address and the data stream sequence number, thereby adapting to the linear addressing requirements of dual-port RAM or the target requester.

[0149] For example, assuming the initial value of the first counter's counting range is 0, the current output second count value is N1, and the first preset weight coefficient is w1, then the operation result of the first multiplier, i.e., the first counting result Output1, is:

[0150]

[0151] Where i represents each count value from the initial value 0 to the current output second count value N1. [0, I1] represents the second counting range corresponding to the first counter segment, such as 0~15; the first preset weight coefficient w1 can be set to 1728 for example.

[0152] During the continuous counting process of the first counter, when the output second count value reaches the preset second count range, such as the maximum value of 15, the first counter generates a carry signal. This carry signal triggers the vertical packet counter to start incrementing, thereby switching the counting dimension to the vertical packet level.

[0153] S303: Input the third count value output by the vertical packet counter into the second multiplier to obtain the second count result, and start the first subframe counter to increment when the third count value reaches the third count range of the vertical packet counter.

[0154] The vertical packet counter is used to count the vertical packet numbers within the current segment, and its output third count value is used to locate the vertical arrangement of the point cloud data. To convert the vertical packet count into the corresponding address offset, the third count value N2 is fed into the second multiplier for weighted calculation. The calculation rules of the second multiplier are the same as those of the first multiplier mentioned in S302, and will not be repeated here. The only difference is that the second preset weight coefficient w2 corresponding to the second multiplier corresponds to the storage space occupied by a vertical packet, for example, it can be set to 288.

[0155] Understandably, the second counting result Output2 can be represented as:

[0156]

[0157] When the third count value of the vertical packet counter reaches its preset third count range, such as 0~5 (i.e., full count), the vertical packet counter generates a carry pulse. This carry pulse is sent to the control terminal of the first subframe counter, driving the first subframe counter to perform an increment operation. This process realizes the automatic switching from the vertical packet dimension to the subframe dimension, ensuring that the multi-level counter group can continuously traverse the three-dimensional spatial distribution of the point cloud data.

[0158] S304: Input the fourth count value output by the first subframe counter into the third multiplier to obtain the third count result, and start the second subframe counter to increment when the fourth count value reaches the fourth count range of the first subframe counter.

[0159] The first subframe counter identifies the first-level subframe sequence to which the point cloud data belongs, and its output fourth count value reflects the subframe hierarchy of the point cloud data. To incorporate this hierarchy information into the final storage address calculation, the fourth count value N3 is input to the third multiplier for weighted calculation. The operation rules of the third multiplier are the same as those of the first multiplier mentioned in S302, and will not be repeated here. The only difference is that the third preset weight coefficient w3 corresponding to the third multiplier corresponds to the address span occupied by a subframe in memory, for example, it can be set to 2.

[0160] Understandably, the third counting result, Output3, can be represented as:

[0161]

[0162] When the fourth count value of the first subframe counter accumulates to a preset fourth count range, such as 0~2 (i.e., full count), the first subframe counter outputs a carry signal. This carry signal triggers the second subframe counter to start working, causing its count value to increment. Through this cascading mechanism, the counter group can accurately describe the position of point cloud data in the fine-grained structure of the subframe, providing the necessary subdivision dimension parameters for generating a unique storage address.

[0163] S305: Input the fifth count value output by the second subframe counter into the fourth multiplier to obtain the fourth count result.

[0164] The second subframe counter, as the final unit of this multi-level counter group, is used to count the point cloud data in more subdivided subframe structures (such as sub-blocks of a subframe or specific scan units). Its output fifth count value represents the offset index of the point cloud data at the most subdivided level. This fifth count value N4 is input to the fourth multiplier for weighted operation. The operation rules of the fourth multiplier are the same as those of the first multiplier mentioned in S302, and will not be repeated here. The only difference is that the fourth preset weight coefficient w4 corresponding to the fourth multiplier can be set to, for example, 96, to ensure that even at the most subtle data structure dimension, the address generation logic can accurately reflect the physical location of the point cloud data.

[0165] Understandably, the fourth counting result, Output4, can be represented as:

[0166]

[0167] S306: Based on the first counting result, the second counting result, the third counting result, and the fourth counting result, obtain the first storage address.

[0168] After obtaining the weighted offsets (counting results) corresponding to each counter in the multi-level counter group, the accumulator synthesizes these intermediate calculation results to generate the final linear physical address. The accumulator receives the first counting result output by the first multiplier, the second counting result output by the second multiplier, the third counting result output by the third multiplier, and the fourth counting result output by the fourth multiplier, and performs an addition operation on these four values.

[0169] For example, the first storage address can be represented as:

[0170]

[0171] Among them, Addr total_1 This indicates the first storage address of the point cloud data, which is the absolute physical address of the point cloud data in the dual-port RAM; This represents the address offset of the point cloud data in Vc0 relative to the point cloud data in Vc1 within the dual-port RAM.

[0172] For example, for Vc1, It can be 0, indicating that the offset input is 0, meaning that the point cloud data in Vc1 is written starting from the base address of RAM, which is used as the reference address; for Vc0, It can be 6, which means that the point cloud data in Vc0 is calculated and then overlaid with a fixed offset of 6, so that the two types of point cloud data in Vc0 and Vc1 fall into different address ranges of the dual-port RAM, avoiding the overlap of the storage addresses of the two point cloud computing outputs, and preventing address overwriting when Vc0 and Vc1 are written to RAM.

[0173] Once a first storage address is generated, the write control logic takes effect, writing the current point cloud data into the storage unit of the dual-port RAM corresponding to that first storage address. This achieves a zero-wait synchronization mechanism where data is stored immediately after computation, without requiring additional control signals.

[0174] In one possible implementation, as an alternative to the above-described multiplier schemes involved in address calculation, a shift-accumulate logic unit or a preset address offset lookup table can be used.

[0175] Specifically, the shift-accumulate logic unit is suitable for cases where the constant weight coefficients have binary bit characteristics. By decomposing the multiplication operation into a series of hardware shift and addition operations, and utilizing the shift operation as equivalent to multiplying by a power of 2, and then accumulating the shift results through an addition tree, the multiplication operation between the count value and the weight coefficient can be completed without dedicated multiplier hardware. The preset address offset lookup table pre-stores the target address offsets corresponding to each stage of the counter group in RAM. The count value output by the counter is directly used as the lookup table index, and the pre-calculated physical address offset is read from memory within a single clock cycle, thus completely avoiding the real-time multiplication process. This alternative solution significantly reduces the hardware resource consumption of the multiplier while maintaining the zero-latency characteristic of address calculation, without introducing any additional pipeline delay, providing a more flexible hardware implementation option for resource-constrained embedded platforms.

[0176] The point cloud data processing method provided in this application firstly uses a packet counter to increment the count of each incoming point cloud data, with the counting range set to 0~1. Each time the packet counter completes a full overflow cycle, a carry signal is generated, driving the first segment counter to increment. The count value of the first segment counter is then processed by a first multiplier using integral logic with interval weighted accumulation, outputting the base address offset within the segment. When the first segment counter reaches its full count range of 0~15, a carry is generated, triggering the increment of the vertical packet counter. The count value of the vertical packet counter is then weighted by a second multiplier, outputting the vertical address offset. After the count reaches 0-5, the first subframe counter is incremented. The count value of the first subframe counter is weighted by the third multiplier and outputs the subframe-level address offset. After the count reaches 0-2, the second subframe counter is incremented. The second subframe counter, as the final stage counter, outputs the finest-grained level address offset after the count value is weighted by the fourth multiplier. The preset weight coefficients corresponding to each multiplier are determined based on the number of data units contained in each segment, the storage space occupied by the vertical packet, the address span occupied by the subframe in memory, and the finest level of data granularity, respectively corresponding to the address span of the point cloud data in different dimensions. Finally, the accumulator sums the count results output by the four multipliers and, combined with the preset fixed base address offset for different processing branches, generates a unique linear physical address for each point cloud data in the dual-port RAM.

[0177] Using the above method, each counter operates sequentially according to the cascaded logic of low-order overflow triggering high-order increment. Combined with the interval weighted accumulation operation rules of each multiplier, the dynamic accumulation process of the counter is accurately transformed into a linear address space increment, ensuring a strict one-to-one correspondence between the storage address and the data stream sequence number. The entire address calculation process is completed by hardware logic within a single clock cycle. Each time a first storage address is generated, a write operation is immediately triggered, realizing a zero-latency synchronous pipeline of counting, calculating, and writing simultaneously. This allows massive point cloud data to be continuously, compactly, and orderly mapped to the dual-port RAM without the need for central processing unit intervention, significantly reducing system latency.

[0178] In one possible implementation, when the point cloud data in the first point cloud data packet or the point cloud data in the second point cloud data packet are both written into the dual-port memory, the point cloud data is read out sequentially and written into a pre-configured first data buffer queue.

[0179] Specifically, when the multi-level counter group reaches the preset final state value (i.e., the first point cloud data packet / second point cloud data packet has been fully written), the dual-port memory is controlled to switch to read mode. Following the sequential order of storage addresses, the cached point cloud data is completely read out into the pre-configured first data buffer queue. This readout process acts as a data flow bridge between the first-stage packet assembly and the second-stage packet assembly, aiming to transfer the temporarily cached data in the dual-port memory to a buffer unit with flow control functionality.

[0180] The first data buffer queue is a pre-configured First-In-First-Out (FIFO) storage structure for temporarily storing point cloud data. This first data buffer queue is built on a dual-port random access memory or register file to smooth out the rate difference between upstream data readout and downstream data transmission. Specifically, point cloud data read from the dual-port RAM is continuously written to the write port of the first data buffer queue. When the accumulated data in the queue reaches a preset burst transmission length threshold, a subsequent read transmission request is triggered. Through the buffering effect of the first data buffer queue, the point cloud data is organized into data blocks suitable for bus transmission, thereby eliminating the risk of downstream transmission congestion caused by fluctuations in the upstream readout rate.

[0181] In another possible implementation, the frame information packet data corresponding to multiple point cloud data are written into a pre-configured second data buffer queue.

[0182] Frame information packet data is a set of metadata generated alongside point cloud data, used to describe the attributes of the current frame data (such as frame header, frame number, timestamp, data length, etc.). During point cloud data acquisition and packet assembly, frame identification information is extracted synchronously from the data packet header and encapsulated according to a preset protocol format to generate frame information packet data. This frame information packet data is generated simultaneously with or after the point cloud data is written to the dual-port RAM, and is used by the downstream application layer for data synchronization verification and parsing. The second data buffer queue is an independent storage structure specifically used to temporarily store frame information packet data, and its construction logic is similar to that of the first data buffer queue. Simultaneously with or after reading point cloud data, the generated frame information packet data is written to the pre-configured second data buffer queue, thereby achieving separate caching and independent management of point cloud data and its metadata. This ensures that critical frame control information is not lost due to data congestion during the transmission of large-volume point cloud data streams, guaranteeing that the downstream application layer can accurately reassemble and identify each frame of point cloud data.

[0183] Using the above method, the first data buffer queue provides a data buffering basis for burst transmission of point cloud data, and the second data buffer queue provides an independent channel for the synchronous transmission of frame information. The two work together to enable subsequent data distribution steps to be executed based on a stable buffer queue state, avoiding read-write conflicts that may occur due to direct operation of the dual-port memory, thereby improving the robustness and schedulability of the entire point cloud data processing link.

[0184] Figure 5 A flowchart illustrating a point cloud data processing method provided in this application. Figure 4 ,like Figure 5 As shown, based on the above embodiment, the second multi-level counter group includes a row counter, a second segment counter, a third subframe counter, and a frame counter. In S103: in response to reading point cloud data from the dual-port memory, the second storage address of each point cloud data is calculated using the preset second multi-level counter group, specifically including:

[0185] S501: When the amount of point cloud data in the first data buffer queue reaches the preset burst transmission length threshold, the point cloud data stored in the first data buffer queue is divided into multiple point cloud data blocks according to the burst transmission length threshold.

[0186] As mentioned above, after calculating the first storage address of each point cloud data, it is immediately written into the dual-port RAM based on that first storage address. This continues until all point cloud data in the first or second point cloud data packet has been written. Then, the cached point cloud data is sequentially read from the dual-port RAM and cached in a pre-configured first data buffer queue. When the amount of data in the first data buffer queue reaches a preset burst transmission length threshold, it indicates that the pre-cached data size meets the requirements for efficient burst transmission on the bus. At this point, the point cloud data stored in the first data buffer queue is divided into multiple point cloud data blocks according to the burst transmission length threshold.

[0187] The burst transmission length threshold is not a fixed value, but is dynamically determined based on the characteristics of the bus protocol to which the target requester is connected. Taking the AXI bus as an example, its typical burst transmission length can be configured to 16, 32, or 64 cycles, and the corresponding threshold can be set to 256 bytes or 512 bytes, etc. This is only an example for illustration.

[0188] By aggregating the discrete point cloud data generated by streaming into data block bursts that conform to the characteristics of bus burst transmission, the bus bandwidth can be maximized and the number of handshake interactions during transmission can be significantly reduced, thereby improving the overall throughput of data transfer from dual-port memory to the target requester.

[0189] S502: For each point cloud data block, the starting storage address of the first point cloud data in the point cloud data block is calculated sequentially using the row counter, the second segment counter, the third subframe counter, and the frame counter.

[0190] Similar to the first multi-level counter group, each counter in the second multi-level counter group is configured to increment in each clock cycle or data tick, each has its own corresponding counting range, and adopts cascading logic of low-order overflow triggering high-order increment.

[0191] The counting range and carry conditions of the row counter, the second segment counter, the third subframe counter, and the frame counter are also pre-set based on the frame structure and storage organization format of the point cloud data. In one possible implementation, the counting range of the row counter can be configured to 0~17, the counting range of the second segment counter can be configured to 0~15, the counting range of the third subframe counter can be configured to 0~3, and the counting range of the frame counter can be configured to 0~31. This is only an illustrative example.

[0192] For each segmented point cloud data block, a second multi-level counter group consisting of a row counter, a second segment counter, a third subframe counter, and a frame counter is used to calculate the starting storage address of the first point cloud data within that block. As each level of counter increments, its output count value represents the row index, segment index, subframe index, and frame index of the current point cloud data block within the point cloud frame, respectively. Ultimately, this maps the discrete point cloud data block to a linear starting address in the physical storage space of the target requester.

[0193] S503: The starting storage address is determined as the second storage address of each point cloud data in the point cloud data block.

[0194] After obtaining the starting storage address, it is used as the base address of the second storage address for each point cloud data within the point cloud data block. Since the point cloud data blocks are read and transmitted from the first data buffer queue in a continuous logical order, and the bus burst transmission mechanism supports automatic incremental writing of data within a continuous address space, only the starting storage address of the first point cloud data within the point cloud data block needs to be provided as the base address. Subsequent point cloud data within the data block will be automatically written sequentially into the continuous storage units after the base address. This eliminates the need for reserving a large capacity cache space on-chip to temporarily store invalid data or wait for packet consolidation, significantly reducing storage resource consumption.

[0195] It not only simplifies the address calculation logic, requiring only the generation of the starting address once for each data block to guide the high-speed writing of the entire data block, thus reducing the complexity of hardware control logic, but also ensures the continuity and compactness of data storage in the target requester.

[0196] The point cloud data processing method provided in this application firstly divides the point cloud data in the first data buffer queue into multiple point cloud data blocks according to the burst transmission length threshold when the amount of point cloud data in the first data buffer queue reaches the preset burst transmission length threshold. Then, for each divided point cloud data block, a second multi-level counter group consisting of a row counter, a second segment counter, a third subframe counter, and a frame counter is used to perform counting processing according to the cascading logic of low-bit overflow triggering high-bit increment, and the starting storage address of the first point cloud data in the data block in the target requester is calculated. Finally, the starting storage address is used as the base address of the entire point cloud data block.

[0197] This embodiment significantly improves the utilization rate of the bus's effective data bandwidth by dividing multiple point cloud data into point cloud data blocks and packaging a large amount of scattered point cloud data into large burst transmission data segments. Only the starting storage address needs to be calculated once for each data block to guide the high-speed continuous writing of the entire data block. This not only simplifies the hardware address calculation logic, but also eliminates the need to reserve a large amount of cache space on-chip to temporarily store invalid data or wait for packet consolidation, greatly reducing storage resource consumption. At the same time, the counters operate sequentially according to the cascading logic and the mapping of weight coefficients to ensure the continuity and compactness of point cloud data storage in the target requester, providing the downstream application layer with a complete data frame that can be directly called.

[0198] Figure 6 A flowchart illustrating a point cloud data processing method provided in this application. Figure 5 , Figure 7 This application provides a logical diagram illustrating the second-stage packaging of multiple point cloud data sets, such as... Figure 6 and Figure 7 As shown, based on the above embodiment, in S502: the starting storage address of the first point cloud data in the point cloud data block is calculated sequentially using the row counter, the second segment counter, the third subframe counter, and the frame counter, specifically including:

[0199] S601: The first point cloud data is incremented by the row counter, and the sixth count value output by the row counter is input into the fifth multiplier to obtain the fifth count result; when the sixth count value reaches the fifth count range of the row counter, the second counter increments.

[0200] In determining the starting storage address of a point cloud data block, a row counter is first used to increment the count of the first point cloud data within the currently processed block. This counting process, for example, starts from zero and is used to identify the row offset position of the current point cloud data within its respective burst transport block. The sixth count value N5, output in real time by the row counter, is transmitted to the fifth multiplier. Based on the sixth count value N5 and the fifth preset weight coefficient w5, the fifth count result Output5 is calculated. This fifth count result characterizes the local offset of each point cloud data within the current row relative to the starting address. For example, the fifth preset weight coefficient w5 can be set to 96, corresponding to the number of data points contained in each row, thereby converting the row index into a physical offset address in linear storage space.

[0201] For example, the fifth counting result can be represented as:

[0202]

[0203] When the sixth count value N5 increases to the fifth count range preset by the row counter (e.g., the maximum count value is 17), the row counter generates an overflow signal. This overflow signal serves as a trigger condition to start the second-segment counter to perform an incrementing count, thereby enabling address carry management when data blocks cross segments.

[0204] S602: Add the seventh count value output by the second segment counter to each count value between the starting value of the seventh count range of the second segment counter to obtain the sixth count result, and start the third subframe counter to increment when the seventh count value reaches the seventh count range.

[0205] For the seventh count value output by the second segment counter, a range summation strategy is used: the seventh count value N6 output by the second segment counter is added to every count value between the starting value and the starting value of the seventh count range. Specifically, this involves accumulating all valid state values ​​of the second segment counter from the starting value to the current seventh count value, thus obtaining the sixth count result Output6. This range summation method can accurately reflect the cumulative span of the current segment in the overall address space.

[0206] For example, the sixth counting result Output6 can be represented as:

[0207]

[0208] When the seventh count value reaches the seventh count range preset by the second counter (e.g., 0 to 15), a carry signal is generated and the third subframe counter is started to increment.

[0209] S603: Add the eighth count value output by the third subframe counter to each count value between the starting value of the eighth count range of the third subframe counter to obtain the seventh count result, and start the frame counter to increment when the eighth count value reaches the eighth count range.

[0210] After receiving the carry signal, the third subframe counter begins counting the subframe dimensions of the point cloud data block and outputs the eighth count value. The eighth count value N7 output by the third subframe counter is added to each count value between the starting value of the eighth count range of the third subframe counter. By accumulating all historical count values ​​within this count range, the seventh count result Output7 is obtained, thus accurately mapping the data span of the subframe level.

[0211] For example, the seventh count result Output7 can be represented as:

[0212]

[0213] When the eighth count value reaches N7, which is within the eighth count range of the third subframe counter (e.g., 0 to 3), the frame counter is then started to increment.

[0214] S604: Input the ninth count value output by the frame counter into the sixth multiplier to obtain the eighth count result.

[0215] After receiving the carry signal, the frame counter starts incrementing. The output ninth count value N8 is input to the sixth multiplier. The sixth multiplier calculates the eighth count result Output8 based on the ninth count value N8 and the sixth preset weight coefficient w6. The sixth preset weight coefficient w6 can be set to, for example, 288, to represent the fixed span occupied by each frame of data in the storage space and to map the frame-level index to the high-order address offset.

[0216] For example, the fifth counting result can be represented as:

[0217]

[0218] S605: Based on the fifth, sixth, seventh, and eighth counting results, obtain the starting storage address.

[0219] After obtaining the counting results of each counter in the second multi-level counter group, the fifth, sixth, seventh, and eighth counting results are summed using an adder to calculate the final starting storage address. This starting storage address precisely points to the target storage address of the current point cloud data block in the target requester (such as DDR4 memory), which is also the second storage address.

[0220] For example, the second storage address can be represented as:

[0221]

[0222] Among them, Addr total_2 This indicates the starting storage address of the first point cloud in the point cloud data block, which is also the second storage address of each point cloud data in the point cloud data block, and in other words, the target storage address of each point cloud data in the point cloud data block in the target requester.

[0223] The point cloud data processing method provided in this application embodiment first increments the first point cloud data in the current point cloud data block using a row counter. The output sixth count value is then weighted by a fifth multiplier according to a preset weighting coefficient to obtain a fifth count result representing the local offset within the row. When the sixth count value reaches the preset counting range of the row counter, a carry signal is generated, starting the second-stage counter to increment. The seventh count value output by the second-stage counter uses an interval summation strategy, accumulating each count value between this count value and the starting value of the counting range to obtain the sixth count result, which accurately reflects the cumulative span of the current segment in the overall address space. When the seventh count value reaches the preset counting range... A carry is generated to trigger the increment of the third subframe counter. The eighth count value output by the third subframe counter is also accumulated using an interval summation strategy to obtain the seventh count result, which accurately maps the data span of the subframe level. When the eighth count value reaches the preset counting range, a carry is generated to trigger the increment of the frame counter. As the final counter, the ninth count value output by the frame counter is weighted by the sixth multiplier according to the preset weight coefficient to obtain the eighth count result, which represents the offset of the high-order address of the frame level. Finally, the fifth, sixth, seventh, and eighth count results are accumulated and summed by the adder to obtain the starting storage address of the first point cloud data in the target requester within the point cloud data block.

[0224] This embodiment uses a cascading logic where counters at each level trigger the higher-order increments based on low-order overflow. Combined with the weight mapping of the multiplier and the interval summation strategy of the second-segment counter and the third subframe counter, it accurately transforms the positional information of point cloud data across multiple dimensions (rows, segments, subframes, and frames) into a unique starting address in the linear address space, ensuring a strict correspondence between address calculation and data organization structure. The entire address calculation process is completed by hardware logic within a single clock cycle. Each generated starting storage address serves as the base address for writing the entire data block to the target requester. Combined with the bus burst transmission mechanism, subsequent point cloud data is automatically written to consecutive storage units, achieving close coordination between address generation and burst writing. This significantly simplifies the hardware control logic and improves the overall transmission efficiency of data transfer from the dual-port memory to the target requester.

[0225] Based on the above embodiments, the point cloud data processing method provided in this application further includes:

[0226] In one possible implementation, for each point cloud data block, after writing the point cloud data block to the target requester based on the corresponding second storage address, a row interrupt signal is generated.

[0227] Among them, the row interrupt signal serves as an event triggering identifier during data transmission. Its physical form is a level transition or pulse signal, which is used to notify the downstream application layer that the current batch of point cloud data blocks has been successfully written to the target storage location.

[0228] Similarly, for each second storage address generated, the embedded processor initiates a burst transmission of point cloud data of the corresponding length via the bus. This means that the corresponding point cloud data block is written to the target requester based on the second storage address. When all point cloud data within the block has been received and stored by the target requester, a row interrupt signal is generated and reported. The generation of this row interrupt signal marks the end of a transmission cycle for a complete row or data fragment in the point cloud data stream, providing the downstream application layer with a precise data readiness time point, allowing the downstream application layer to know that the data is readable without polling the storage status.

[0229] Figure 8 This application provides a schematic diagram of the transmission logic for frame information packet data, such as... Figure 8 As shown, the processing method for this point cloud data also includes:

[0230] After multiple point cloud data are written to the target requester, frame information packet data is read from the second data buffer queue and written to the target requester, generating a frame interrupt signal.

[0231] The second data buffer queue serves as a cache container for frame information packet data, pre-storing auxiliary information related to the current frame point cloud data, such as frame headers, timestamps, and frame sequence numbers. When it is detected that all point cloud data blocks have been written to the target requester, meaning that multiple point cloud data have been directly transmitted from the SPAD sensor to DDR4 storage with microsecond-level low latency, the frame information packet data corresponding to these multiple point cloud data is read from the second data buffer queue and written to the target requester.

[0232] Specifically, the frame information packet data is not written independently, but rather continuously following the tail offset of the last point cloud data block. That is, within the same storage address range, the frame information packet data is written to the next storage unit contiguous with the address of the last point cloud data block after all point cloud data rows. This eliminates the need to calculate a new addressing base address separately for the frame information packet data during address generation. After the burst transmission of the last point cloud data block is completed, the address increment logic unit simply increments the existing address to naturally connect to the storage area of ​​the frame information packet. This continuous storage method allows each data frame to form a complete logical unit in the target memory: the front end is the written point cloud data body, and the back end is the written frame information packet data. The two are contiguous and have continuous addresses, facilitating the one-time transfer of the entire frame data in block transmission during subsequent high-speed readings. It also ensures the physical correlation between the information within the frame and the point cloud data, avoiding the additional addressing overhead and management complexity caused by distributed storage.

[0233] After the frame information packet data is completely written to the target requester, a frame interrupt signal is generated. This signal is used to indicate to the downstream application layer that all data in the current frame is ready. By cascading the frame interrupt signal with the aforementioned line interrupt signal, that is, a line interrupt is triggered after each point cloud data block is written, and a frame interrupt is triggered uniformly after all line interrupt signals converge and confirm that all blocks have been written, a hierarchical interrupt mechanism from line-level write confirmation to frame-level completion notification is realized.

[0234] By generating line interrupt signals and frame interrupt signals, downstream processing units can initiate read operations as needed when the point cloud data block is fully in place, without continuously polling or waiting for irrelevant data. This reduces invalid bus accesses and master control interrupt responses at the source, further releasing bus bandwidth and master control computing power, thereby achieving a balance between high real-time performance, low storage overhead, and high transmission bandwidth utilization.

[0235] Building upon the above embodiments, as an advanced alternative to pure hardware processing, the scatter-gather mode of an integrated hardware Direct Memory Access (DMA) controller can be further utilized to optimize point cloud data paths. Specifically, a descriptor linked list of the physical addresses and lengths of each point cloud data block is pre-established in memory. After filtering the point cloud data, the CPU does not need to intervene to execute transport instructions; instead, the DMA controller is directly triggered to start chain-like transport according to the linked list nodes. Even if the point cloud data blocks are fragmented in physical memory, they can be accurately aggregated and directly transferred based on the descriptors. In higher-performance SoC platforms or heterogeneous computing architectures, this alternative can fully leverage the advantages of hardware parallel scheduling and bus matrix, completely bypassing CPU core intervention, and stably controlling end-to-end transmission latency at the microsecond level. Simultaneously, it enables direct placement of point cloud data from dual-port RAM to the target storage area, eliminating the need for secondary transport during downstream application layer reading, further reducing memory access latency, and thus providing more reliable data support for real-time demanding perception and decision-making systems.

[0236] Figure 9 This is a schematic diagram of the structure of a point cloud data processing device provided in this application, as shown below. Figure 9 As shown, the point cloud data processing device 90 provided in this embodiment includes:

[0237] The first processing module 901 is used to acquire multiple point cloud data; wherein, the multiple point cloud data are obtained by filtering the raw point cloud data collected in real time by the vehicle under driving conditions.

[0238] The second processing module 902 is used to calculate the first storage address of each point cloud data through a preset first multi-level counter group, and write the corresponding point cloud data into the dual-port memory based on the first storage address.

[0239] The third processing module 903 is used to respond to reading point cloud data from the dual-port memory, calculate the second storage address of each point cloud data through a preset second multi-level counter group, and write the corresponding point cloud data to the target requester based on the second storage address so that the downstream application layer can call multiple point cloud data.

[0240] In one possible implementation, the first multi-level counter group includes two multi-level counter groups, each of which includes a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter.

[0241] The second processing module 902 is specifically used for:

[0242] Multiple point cloud data are split into two data packets to obtain a first point cloud data packet and a second point cloud data packet.

[0243] For each point cloud data in each point cloud data packet, the point cloud data is counted sequentially using a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter to obtain the first storage address of the point cloud data.

[0244] In one possible implementation, the second processing module 902 is further used for:

[0245] The point cloud data is incremented by a packet counter. When the first count value output by the packet counter reaches the first count range of the packet counter, the first stage of the counter increments.

[0246] The second count value output by the first counter is input into the first multiplier to obtain the first count result. When the second count value reaches the second count range of the first counter, the vertical package counter is started to increment.

[0247] The third count value output by the vertical packet counter is input into the second multiplier to obtain the second count result. When the third count value reaches the third count range of the vertical packet counter, the first subframe counter is started to increment.

[0248] The fourth count value output by the first subframe counter is input into the third multiplier to obtain the third count result. When the fourth count value reaches the fourth count range of the first subframe counter, the second subframe counter is started to increment.

[0249] The fifth count value output from the second subframe counter is input into the fourth multiplier to obtain the fourth count result;

[0250] Based on the first counting result, the second counting result, the third counting result, and the fourth counting result, the first storage address is obtained.

[0251] In one possible implementation, the point cloud data processing device 90 further includes a fourth processing module 904, used for:

[0252] When the point cloud data in the first point cloud data packet or the point cloud data in the second point cloud data packet are both written into the dual-port memory, the point cloud data is read out in sequence and written into the pre-configured first data buffer queue.

[0253] And / or,

[0254] Frame information packet data corresponding to multiple point cloud data are written into a pre-configured second data buffer queue.

[0255] In one possible implementation, the second multi-level counter group includes a line counter, a second segment counter, a third subframe counter, and a frame counter;

[0256] The third processing module 903 is specifically used for:

[0257] When the amount of point cloud data in the first data buffer queue reaches the preset burst transmission length threshold, the point cloud data stored in the first data buffer queue is divided into multiple point cloud data blocks according to the burst transmission length threshold.

[0258] For each point cloud data block, the starting storage address of the first point cloud data in the point cloud data block is calculated sequentially using the row counter, the second segment counter, the third subframe counter, and the frame counter.

[0259] The starting storage address is determined as the second storage address for each point cloud data in the point cloud data block.

[0260] In one possible implementation, the third processing module 903 is further used for:

[0261] The first point cloud data is incremented by a row counter, and the sixth count value output by the row counter is input into the fifth multiplier to obtain the fifth count result; when the sixth count value reaches the fifth count range of the row counter, the second counter increments.

[0262] The seventh count value output by the second segment counter is added to each count value between the starting value of the seventh count range of the second segment counter to obtain the sixth count result. When the seventh count value reaches the seventh count range, the third subframe counter is started to increment.

[0263] The seventh count result is obtained by adding the eighth count value output by the third subframe counter to each count value between the starting value of the eighth count range of the third subframe counter, and the frame counter is started to increment when the eighth count value reaches the eighth count range.

[0264] The ninth count value output by the frame counter is input into the sixth multiplier to obtain the eighth count result;

[0265] Based on the fifth, sixth, seventh, and eighth counting results, the starting storage address is obtained.

[0266] In one possible implementation, the operation rule of the multiplier is as follows: each count value between the starting value of the counter's counting range and the count value output by the counter is multiplied by the preset weight coefficient corresponding to the multiplier and then accumulated to obtain the operation result of the multiplier.

[0267] In one possible implementation, the point cloud data processing device 90 further includes a fifth processing module 905, used for:

[0268] For each point cloud data block, after writing the point cloud data block to the target requester based on the corresponding second storage address, a row interrupt signal is generated;

[0269] After multiple point cloud data are written to the target requester, frame information packet data is read from the second data buffer queue and written to the target requester, generating a frame interrupt signal.

[0270] The point cloud data processing device provided in this embodiment can execute the method provided in the above method embodiment. Its implementation principle and technical effect are similar, and will not be described again in this embodiment.

[0271] Figure 10 A schematic diagram of the structure of an electronic device provided in this application, such as... Figure 10 As shown, the electronic device 100 provided in this embodiment includes at least one processor 1001 and a memory 1002. Optionally, the electronic device 100 further includes a communication component 1003. The processor 1001, memory 1002, and communication component 1003 are connected via a bus 1004.

[0272] In a specific implementation, at least one processor 1001 executes computer execution instructions stored in memory 1002, causing at least one processor 1001 to perform the above-described method.

[0273] The specific implementation process of processor 1001 can be found in the above method embodiments, and its implementation principle and technical effect are similar. It will not be repeated here.

[0274] In the above embodiments, it should be understood that the processor can be a CPU, or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), etc. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the method disclosed in this invention can be directly implemented by a hardware processor, or implemented by a combination of hardware and software modules within the processor.

[0275] The memory may include random access memory (RAM) in high-speed memory, and may also include non-volatile memory (NVM), such as at least one disk storage device.

[0276] The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of illustration, the buses shown in the accompanying drawings are not limited to a single bus or a single type of bus.

[0277] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the above-described method.

[0278] This application also provides a vehicle, including a vehicle body and a controller. The controller is used to execute the above-described method. For the specific implementation process, please refer to the above-described method embodiments. The implementation principle and technical effect are similar, and will not be repeated here.

[0279] This application also provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the above-described method.

[0280] The aforementioned readable storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as Static Random-Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read-Only Memory (EPROM), Programmable Read-Only Memory (PROM), Read-Only Memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk. The readable storage medium can be any available medium accessible to a general-purpose or special-purpose computer.

[0281] An exemplary readable storage medium is coupled to a processor, enabling the processor to read information from and write information to the readable storage medium. Of course, the readable storage medium can also be a component of the processor. The processor and the readable storage medium can reside within an ASIC. Alternatively, the processor and the readable storage medium can exist as discrete components in a device.

[0282] The division of units is merely a logical functional division; in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be indirect coupling or communication connection through some interfaces, devices, or units, and may be electrical, mechanical, or other forms.

[0283] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0284] In addition, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0285] If a function is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this invention, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, ROM, RAM, magnetic disks, or optical disks.

[0286] Those skilled in the art will understand that all or part of the steps of the above-described method embodiments can be implemented by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When executed, the program performs the steps of the above-described method embodiments; and the aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks.

[0287] Finally, it should be noted that other embodiments of the invention will readily occur to those skilled in the art upon consideration of the specification and practice of the invention disclosed herein. This invention is intended to cover any variations, uses, or adaptations of the invention that follow the general principles of the invention and include common knowledge or customary techniques in the art not disclosed herein, and is not limited to the precise structures described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope.

Claims

1. A method for processing point cloud data, characterized in that, include: Multiple point cloud data are acquired; wherein the multiple point cloud data are obtained by filtering the raw point cloud data collected in real time by the vehicle under driving conditions. The first storage address of each point cloud data is calculated by using a preset first multi-level counter group, and the corresponding point cloud data is written into the dual-port memory based on the first storage address. In response to reading point cloud data from the dual-port memory, the second storage address of each point cloud data is calculated using a preset second multi-level counter group, and the corresponding point cloud data is written to the target requester based on the second storage address so that the downstream application layer can call the multiple point cloud data.

2. The method according to claim 1, characterized in that, The first multi-level counter group includes two multi-level counter groups, each of which includes a packet counter, a first segment counter, a vertical packet counter, a first subframe counter, and a second subframe counter. The step of calculating the first storage address of each point cloud data through a preset first multi-level counter group includes: The multiple point cloud data are split into two data packets to obtain a first point cloud data packet and a second point cloud data packet. For each point cloud data in each point cloud data packet, the point cloud data is counted sequentially using the packet counter, the first segment counter, the vertical packet counter, the first subframe counter, and the second subframe counter to obtain the first storage address of the point cloud data.

3. The method according to claim 2, characterized in that, The point cloud data is sequentially counted using the packet counter, the first segment counter, the vertical packet counter, the first subframe counter, and the second subframe counter to obtain the counting result of the point cloud data, including: The point cloud data is incremented by the packet counter. When the first count value output by the packet counter reaches the first count range of the packet counter, the first segment counter increments. The second count value output by the first segment counter is input into the first multiplier to obtain the first count result, and when the second count value reaches the second count range of the first segment counter, the vertical package counter is started to increment the count; The third count value output by the vertical packet counter is input into the second multiplier to obtain the second count result. When the third count value reaches the third count range of the vertical packet counter, the first subframe counter is started to increment. The fourth count value output by the first subframe counter is input into the third multiplier to obtain the third count result. When the fourth count value reaches the fourth count range of the first subframe counter, the second subframe counter is started to increment. The fifth count value output by the second subframe counter is input into the fourth multiplier to obtain the fourth count result; The first storage address is obtained based on the first counting result, the second counting result, the third counting result, and the fourth counting result.

4. The method according to claim 2 or 3, characterized in that, The method further includes: When the point cloud data in the first point cloud data packet or the point cloud data in the second point cloud data packet are both written into the dual-port memory, the point cloud data is read out in sequence and written into the pre-configured first data buffer queue. And / or, The frame information packet data corresponding to the multiple point cloud data are written into the pre-configured second data buffer queue.

5. The method according to claim 4, characterized in that, The second multi-level counter group includes a line counter, a second segment counter, a third subframe counter, and a frame counter; The step of calculating the second storage address of each point cloud data through a preset second multi-level counter group includes: When the amount of point cloud data in the first data buffer queue reaches a preset burst transmission length threshold, the point cloud data stored in the first data buffer queue is divided into multiple point cloud data blocks according to the burst transmission length threshold. For each point cloud data block, the starting storage address of the first point cloud data in the point cloud data block is calculated sequentially using the row counter, the second segment counter, the third subframe counter, and the frame counter. The starting storage address is determined as the second storage address of each point cloud data in the point cloud data block.

6. The method according to claim 5, characterized in that, The process of calculating the starting storage address of the first point cloud data within the point cloud data block sequentially using the row counter, the second segment counter, the third subframe counter, and the frame counter includes: The first point cloud data is incremented by the row counter, and the sixth count value output by the row counter is input into the fifth multiplier to obtain the fifth count result; when the sixth count value reaches the fifth count range of the row counter, the second counter increments. The seventh count value output by the second segment counter is added to each count value between the starting value of the seventh count range of the second segment counter to obtain the sixth count result. When the seventh count value reaches the seventh count range, the third subframe counter is started to increment. The eighth count value output by the third subframe counter is added to each count value between the starting value of the eighth count range of the third subframe counter to obtain the seventh count result. When the eighth count value reaches the eighth count range, the frame counter is started to increment. The ninth count value output by the frame counter is input into the sixth multiplier to obtain the eighth count result; The starting storage address is obtained based on the fifth, sixth, seventh, and eighth counting results.

7. The method according to claim 6, characterized in that, The operation rule of the multiplier is as follows: each count value between the starting value of the counter's counting range and the count value output by the counter is multiplied by the preset weight coefficient corresponding to the multiplier and then accumulated to obtain the operation result of the multiplier.

8. The method according to claim 5, characterized in that, The method further includes: For each point cloud data block, after writing the point cloud data block to the target requester based on the corresponding second storage address, a row interrupt signal is generated; After all the point cloud data are written to the target requester, the frame information packet data is read from the second data buffer queue and written to the target requester to generate a frame interruption signal.

9. An electronic device, characterized in that, include: Memory, processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory, causing the processor to perform the method as described in any one of claims 1 to 8.

10. A vehicle, characterized in that, It includes a vehicle body and a controller, the controller being used to perform the method as described in any one of claims 1 to 8.