This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

IWR6843ISK: Validation checkpoints for custom Python raw-ADC people-tracking pipeline

Part Number: IWR6843ISK
Other Parts Discussed in Thread: DCA1000EVM,

Hi Team,

Posting on behalf of our customer.

I am working on a capstone/research project using IWR6843ISK with DCA1000EVM. My goal is to build a host-side Python pipeline that receives raw ADC data from the DCA1000EVM, reconstructs radar frames, generates Range-Doppler and Range-Angle representations, and performs moving-person detection and multi-target tracking.

Hardware / setup:
- Radar EVM: IWR6843ISK
- Capture board: DCA1000EVM
- Host OS: Windows
- Data path: DCA1000 Ethernet UDP raw ADC stream
- Control path: CLI UART
- Processing: Python host-side pipeline
- Frame rate: approximately 10 FPS
- Sensor configuration: attached / linked below

Project summary:
Our current implementation can receive raw ADC data, build the radar cube, generate RDI/RAI outputs, detect moving targets, and track people in simple walking scenarios. However, the system is still at a prototype/research level and is not yet robust enough for production-like use.

The main issues we are trying to understand are:
- Ghost or limb-related angle peaks
- Track instability in multi-person or close-target scenarios
- Merging two nearby people into one detection
- Separating DCA1000 transport-quality problems from actual detection/tracking failures
- Validating whether our intermediate processing stages are aligned with TI reference processing

Our current pipeline design:
1. Receive DCA1000 UDP packets and reconstruct raw ADC frames.
2. Build the radar cube and apply static clutter removal.
3. Generate Range-Doppler Image and Range-Angle Image.
4. Use Range-Doppler CFAR peaks as the first detection anchors.
5. Use Range-Angle information mainly for validation and coordinate refinement, rather than trusting the strongest angle peak directly.
6. Apply local blob-center refinement because the strongest reflection is often not the physical body center.
7. Apply candidate merge / adaptive DBSCAN.
8. Use Kalman-based tracking with policies for birth suppression, soft gating, and display ID stitching.
9. Log stage-wise traces so the same raw capture can be replayed and compared after algorithm changes.

Questions:
1. In our host-side Python pipeline, we use Range-Doppler CFAR peaks as stable anchors and then use Range-Angle information for validation/refinement. For people tracking on IWR6843ISK, under what scenarios would this RD-first approach be expected to fail, especially for slow, near-stationary, or closely spaced people?

2. We observed that a collapsed Range-Angle map can sometimes select a strong limb or ghost peak, while using the Doppler slice associated with the RD seed gives more stable localization. Is this a reasonable diagnostic or processing strategy, or could it hide errors from TDM-MIMO phase compensation, virtual antenna ordering, or angle processing?

3. In our results, the strongest reflection point is often not the body center. We therefore refine the candidate using a local Range-Angle patch and a weighted blob-center estimate. Are there recommended TI validation scenes, reference outputs, or evaluation methods to determine whether this refinement is improving body-center localization rather than simply smoothing an error?

4. We added an object-count estimation step before final merge/DBSCAN to prevent two nearby people from being merged into one detection. What validation scenario would TI recommend to tune the trade-off between suppressing duplicate ghost candidates and preserving two close physical targets?

5. Because we process DCA1000 UDP packets directly on the host, we mark frames with sequence gaps or byte mismatches and block new track births on invalid frames. Is this a reasonable way to separate transport-quality failures from detection/tracking failures? What transport health metrics should be reported when evaluating algorithm performance?

6. To compare our custom Python pipeline with TI reference processing, should we compare only the final point cloud/tracks, or should we also compare intermediate artifacts such as radar cube consistency, RD heatmap peaks, RA heatmap peaks, CFAR candidate counts, and tracker input counts? Which intermediate level is most meaningful for debugging custom raw-ADC processing?

I understand that TI may not be able to debug a full custom algorithm. I am mainly trying to confirm whether our validation approach and failure analysis are reasonable, and which TI reference outputs or test procedures would be best for comparing a custom raw-ADC pipeline against expected behavior.

Links / attachments:
- Sensor configuration file: 
- Short result video:

- GitHub repository : https://github.com/deepblue21zin/radar-DCA1000-refactor
- Example failure case: two nearby people in a close-target / crossing scenario are sometimes merged into one displayed track even when the DCA1000 transport health metrics are clean.

Thank you for your help.

Regards,

Danilo

  • Hi Danilo,

    Question 1: Your RD-first strategy has a known limitation: near-stationary or very slow-moving targets.

    TI's people counting demo actually uses the opposite order: Range → Static Clutter Removal → Angle of Arrival (Capon) → CFAR → Doppler Estimation; specifically, because Capon beamforming provides superior localization for slower targets like people. The rationale is that for the same range bin, multiple targets may exist at different angles and Doppler velocities; estimating angle first (via Capon) and then extracting Doppler per (range, angle) peak gives better separation.

    Your RD-first approach will struggle when:

    • Targets are near-stationary (sitting, standing still): They fall into or near the zero-Doppler bin, where static clutter removal may suppress them, leaving no stable RD anchor.
    • Two people are at the same range and similar velocity but different angles: RD CFAR will see one merged peak; only angle processing can separate them.
    • Closely spaced people with similar Doppler: The RD map cannot resolve them, and your RA refinement step becomes the only discriminator rather than a validator.

    For your use case at ~10 FPS with walking people, the RD-first approach should work well for normal walking speeds. The failure edge cases are slow/stationary targets and same-range-same-Doppler crossings.

    Question 2: This strategy can mask TDM-MIMO phase compensation errors. Key considerations:

    • In TDM-MIMO, a Doppler correction step must be performed before angle-FFT to compensate for velocity-induced phase changes between TX time slots. If this correction is wrong, the angle estimate will be incorrect—but only for moving targets. By restricting to a single Doppler slice, you might get consistent (but systematically biased) angle estimates that appear stable.
    • G-track (TI's tracker) assumes the point cloud azimuth is already correct and does NOT compensate for TDM-MIMO phase errors. So, if your Doppler compensation is wrong, the tracker will faithfully track incorrect positions.
    • Strong zero-Doppler clutter from antenna sidelobes is a known issue with 2Tx/4Rx TDM-MIMO on the IWR6843ISK, significantly worse than 1Tx/4Rx configurations.

    Validation recommendation: Aim the sensor at a single corner reflector at a known angle. Compare your angle estimate against ground truth across different Doppler bins. If the angle estimate shifts with Doppler, your TDM-MIMO phase compensation has an error.

    Question 3: TI's approach in the people counting demo handles this differently: no peak grouping is applied after CFAR; instead, the full point cloud is passed to the tracker, which performs clustering. The tracker itself finds the centroid.

    For validation:

    • TI's "Sense and Direct: HVAC Control" demo includes a classifier that uses micro-Doppler features from the point cloud for activity classification, demonstrating how point-cloud-level features (not raw ADC heatmap patches) can characterize human targets.
    • Recommended validation scene: Place a single person walking at a known path (e.g., along a tape line on the floor). Compare your refined blob-center output against the known ground-truth path. If your refinement reduces the lateral scatter of the track relative to the ground truth, it's helping. If it introduces a systematic offset, it may be smoothing an angle processing error.
    • Compare against TI's OOB_parser.py from the 3D people counting visualizer source code, which provides a validated TLV parsing baseline. Run the on-chip people counting demo simultaneously and compare its point cloud centroids against your blob-center estimates for the same scene.

    TI does not publish specific reference datasets with ground-truth body-center annotations for the IWR6843ISK, so controlled single-person path tests are your best available validation method.

    Question 4: For the specific trade-off between suppressing ghost duplicates and preserving two close physical targets, TI recommends:
    • Decrease gating parameters to limit the size of a single track, which forces leftover points to form new tracks rather than being absorbed.
    • Increase allocation thresholds to suppress ghost tracks from spawning on noise or sidelobe detections.
    • TI's people counting design expects accuracy of ±0 for <5 people and ±1 for 6-7 people, 90% of the time, with a maximum assumed density of 3 people per square meter.

    Recommended validation scenario: Two people walking parallel paths at decreasing lateral separation (start at 1.5m apart, decrease to 0.3m). Record at each separation. Your merge/DBSCAN should:

    • Consistently report 2 targets at separations above the angular resolution limit (~15° for IWR6843ISK at typical ranges)
    • Gracefully degrade (not oscillate between 1 and 2) at the resolution boundary

    Question 5: The DCA1000 UDP packet includes a 10-byte header with a 4-byte sequence number and 6-byte running byte count, specifically designed for detecting packet loss and maintaining frame synchronization.

    Transport health metrics you should report:

    Metric
    Purpose
    Sequence number gaps
    Dropped packets
    Out-of-order packet count
    Network congestion/reordering
    Byte count mismatches
    Partial frame corruption
    Frames discarded (total & rate)
    Overall transport quality
    Zero-chirp frame count
    Known DCA1000 bug (~20% frame corruption in some setups) 

    Additional considerations:

    • The DCA1000 has a known, unpatched bug where some chirps contain all-zero ADC samples, causing high-intensity artifacts at close range in the RD map. Detect frames with zero-value chirps and discard them.
    • If you experience packet loss, increase the DCA1000 packet delay parameter (configurable 5–500 µs) to reduce drops—this is a network/PC-side issue, not a radar hardware problem.
    • Monitor the DCA1000 hardware LEDs: FPGA_ERR_LED (LVDS buffer overflow), DDR_FULL_LED (DDR3 saturation), HEADER_ERR_LED (missing LVDS headers).

    Question 6: Compare intermediate artifacts, not just final tracks. This is the most effective debugging strategy for custom raw-ADC pipelines.

    TI's on-chip processing splits across cores:

    • HWA: Range-FFT (1D FFT, performed inline during chirp arrival)
    • DSP: Doppler-FFT, CFAR detection, Angle-of-Arrival estimation
    • R4F (Cortex-R4F): Tracker (clustering, Kalman filtering)

    The most meaningful intermediate checkpoint for debugging custom raw-ADC processing is the CFAR candidate list (post-detection, pre-tracker).

    1. Radar cube consistency: Validates your frame reconstruction and sample ordering are correct.
    2. RD heatmap peaks: Validates your FFT windowing, static clutter removal, and Doppler processing.
    3. CFAR candidate counts ← Most diagnostic level: The HWA's CFAR engine outputs a FFTPEAKCNT register with the detected peak count [16]. If your CFAR candidate count per frame diverges significantly from TI's on-chip demo output for the same scene, the error is in your signal processing chain (not tracking).
    4. RA heatmap / angle estimates: Validates your TDM-MIMO phase compensation and virtual antenna ordering.
    5. Tracker inputs: Validates your clustering/merge logic.

    Practical comparison method: Run the on-chip OOB demo with LVDS streaming enabled simultaneously. The UART output gives you TI's point cloud (range, azimuth, Doppler, SNR per point). Compare:

    • Your CFAR candidate count vs. TI's point count per frame
    • Your angle estimates vs. TI's azimuth values for the same detected range bins
    • Your detection SNR distribution vs. TI's reported SNR

    The OOB_parser.py in the 3D people counting visualizer provides the reference parsing format.



    I hope this helps.

    Best,

    David