Reliable autonomous driving and advanced driver assistance systems (ADAS) depend on repeated evaluation of sensors, algorithms and vehicle behavior. Simulation can shorten development cycles by letting engineering teams test algorithms against data collected in advance, but the results are only useful when that data is both comprehensive and accurately synchronized. An ADAS data logger must therefore do more than store sensor outputs: it must capture many data streams together, preserve their timing and write them fast enough to support demanding test programs.
These requirements create challenges for conventional logging systems, particularly as development vehicles combine camera, radar, LiDAR and vehicle-network data. A logging architecture designed for ADAS development has to manage timing, processing and storage as one integrated problem.
What an ADAS data logger needs to capture
Development follows a repeating cycle. Engineers collect sensor data, use it in simulation to develop algorithms, implement those algorithms on an electronic control unit (ECU), and evaluate the system in a vehicle. Data from real vehicle operation then feeds the next round of simulation and improvement.
To support this cycle, a logger needs to record three related categories of information:
- Sensor data: Inputs such as camera images, millimeter-wave radar and LiDAR.
- Reference data: Information used to assess whether ADAS behavior is valid.
- Operating context: Details such as vehicle position and running status that help describe the conditions in which the data was collected.
Keeping these streams aligned matters. If measurements from different sensors carry inconsistent timestamps, engineers may be unable to reconstruct the precise situation that produced them. The logger described in the technical review was designed to handle at least 30 channels, record all data to HDD storage and achieve timestamp accuracy within 1 millisecond.
Why sensor data synchronization matters
ADAS functions often fuse information from multiple sensors. When engineers compare measurements from two sensors, a timing difference can look like a difference in the measured scene rather than a difference in sensor performance. Vehicle motion makes the effect more significant: data captured at slightly different times may correspond to different vehicle positions.
For example, at 100 km/h a vehicle travels about 3 cm in 1 millisecond; at 180 km/h, it travels about 5 cm. A timestamp offset can therefore complicate sensor-to-sensor measurement matching, especially at highway speeds. In the logger design, the target was to keep timestamp error within 1 millisecond so that timing-related position differences would remain within the stated 5 cm comparison threshold.
Not every part of the end-to-end delay can be controlled by a logger. Processing inside a sensor and transmission time through a communications path occur before data reaches the logger. The engineering focus was therefore on accurate, consistent timestamping within the logger’s own processing.
FPGA timestamping replaces sequential CPU handling
Conventional loggers may rely on a CPU to assign timestamps. But a CPU processes tasks in sequence on each core, so timestamp requests from many channels can be handled at different moments. The technical review notes that a 1 millisecond processing cycle is a practical limit for general CPU-based processing with a real-time operating system, while a general-purpose operating system may have longer cycles. That makes simultaneous, precise handling of dozens of streams difficult.
To avoid this bottleneck, the logger implemented timestamp processing in a field-programmable gate array (FPGA). Its configurable logic allows multiple data paths to be processed in parallel. This approach was selected instead of developing a dedicated semiconductor, taking development time and manufacturing volume into account.
Resolving clock-access contention
Moving timestamp logic into hardware did not immediately guarantee the expected accuracy. Testing revealed random delays of tens of microseconds between interfaces. The cause was contention when multiple FPGA functions and a processor core accessed the same real-time clock (RTC). Requests for time information could be delayed while competing for access.
The design was revised to provide a dedicated clock-access arrangement that allowed simultaneous requests to receive time information with a consistent delay. The revised architecture reduced the time-acquisition delay to about 50 nanoseconds. In measurement, timestamp deviation reached ±6 microseconds—well within the 1 millisecond requirement. The result illustrates an important design point: hardware timestamping needs a clock architecture that avoids contention, not simply faster processing logic.
Parallel processing and high-volume recording
Autonomous-driving development can involve data volumes of about 1.2 GB per second, driven by image streams and substantial LiDAR data. A logger must process those streams without forcing them through a shared bottleneck. The system used FPGA functional blocks for individual data types and input channels, covering processing from data input through output formatting. Their outputs were then brought together for storage.
Testing confirmed that the logger could process input exceeding the anticipated 1.2 GB/s without problems. This parallel architecture addresses a different limit from timestamp accuracy: even correctly timed data is not useful if the system cannot keep pace with incoming streams.
Storage presents another constraint. Image data can remain large even when lossless compression is used; for full-HD images, the review notes that compression may reduce the original data to only about half its size. Solid-state drives offer high-speed writing, but the system described could not use them because available capacity was insufficient for the required recording duration. The design instead used HDDs and an FPGA-based export function that wrote data in RAW format.
By minimizing HDD head seeking, the method sustained writing at about 90% or more of the drive’s theoretical writing speed. The aim was to support long recording sessions—around 16 hours per day in the described use case—while preserving the data needed for development.
Practical implications for development teams
For engineering teams selecting or designing a logger, these findings point to three connected requirements: synchronized timestamps across channels, enough parallel processing capacity for peak data rates, and a storage path that can sustain continuous recording. Optimizing only one area can leave another as the limiting factor.
As vehicle systems and data use evolve, the technical review also identifies data portability, standardization and personal-information protection as considerations for future development. For today’s ADAS testing, the practical priority is a recording system that preserves both the timing and the volume of sensor data needed to reproduce vehicle situations in simulation. A carefully designed combination of hardware timestamping, parallel processing and storage optimization can make that data more useful throughout the development cycle.