Overview

RadarStream is a comprehensive real-time raw data acquisition, processing, and visualization system designed for Texas Instruments’ MIMO mmWave radar series. The system features a multi-threaded architecture with C-wrapped data acquisition modules to overcome Python’s GIL limitations, enabling true real-time, frame-loss-free radar data processing.

Key Features ✨

Real-time Multi-threaded Data Acquisition 🧵

• Multi-threaded Architecture: Separate threads for data acquisition and processing
• C-Wrapped Acquisition Module 🚀: Overcomes Python’s Global Interpreter Lock (GIL) for true multi-core processing
• Frame-Loss-Free Operation: Near real-time data capture and handling
• TI MIMO mmWave Radar Support: Compatible with IWR series radar sensors

Multi-dimensional Feature Extraction 📊

The system extracts comprehensive radar features for advanced signal processing:

• RTI - Range-Time Information
• DTI - Doppler-Time Information
• RDI - Range-Doppler Information
• RAI - Range-Azimuth Information
• REI - Range-Elevation Information

Interactive Visualization Interface 🖥️

• PyQt5-based GUI: Modern, intuitive user interface
• Real-time Plotting: PyQtGraph for high-performance visualization
• Multi-view Display: Simultaneous visualization of multiple feature dimensions
• Configuration Management: Easy radar parameter configuration
• Data Recording: Capture training data for machine learning models

Hardware Support

Tested Radar Platforms

The system has been validated with the following TI mmWave radar platforms:

• ✅ IWR6843ISK - 60 GHz Industrial Radar Sensor
• ✅ IWR6843ISK-OBS - Out-of-Box Solution variant
• ✅ IWR1843ISK - 77 GHz Automotive Radar Sensor

Required Hardware

Connection Steps

1. Power Connection: Connect 5V 3A DC power to the radar board
2. Ethernet Connection: Connect DCA1000 EVM to PC via Ethernet cable
3. USB Connection: Connect radar board to PC via micro USB for CLI
4. Network Configuration: Configure IPv4 settings for DCA1000 (similar to mmWaveStudio setup)

Platform Comparison

Software Architecture

Technology Stack

• Python 3.6+ - Main programming language
• PyQt5 - GUI framework
• PyQtGraph - High-performance plotting
• NumPy - Numerical computing
• PyTorch - Machine learning integration
• C Extensions - Performance-critical data acquisition

Project Structure

RadarStream/
├── config/              # Radar configuration files
├── gesture_icons/       # Gesture visualization icons
├── libs/                # Radar communication libraries
├── STL3D/              # 3D printed mount files
├── iwr6843_tlv/        # TLV protocol implementation
├── dsp/                # Digital signal processing modules
├── main.py             # Application entry point
├── real_time_process.py # Real-time processing engine
├── radar_config.py     # Configuration utilities
└── UI_interface.py     # PyQt5 user interface

Multi-threaded Architecture

Main Thread (GUI)
    ↓
Data Acquisition Thread (C-wrapped)
    ↓
Processing Thread (Python)
    ↓
Visualization Thread (PyQtGraph)

Key Design Decisions:

• ✅ C-wrapped acquisition overcomes GIL limitations
• ✅ Separate threads prevent GUI blocking
• ✅ Lock-free queues for inter-thread communication
• ✅ Efficient memory management for continuous operation

Getting Started

Software Requirements

Install the required Python dependencies:

pip install pyqt5 pyqtgraph numpy torch matplotlib pyserial

Dependency List:

• Python 3.6+
• PyQt5 - GUI framework
• PyQtGraph - Real-time plotting
• NumPy - Numerical computing
• PyTorch - Machine learning support
• Matplotlib - Additional visualization
• PySerial - Serial communication

Firmware Requirements

The radar firmware must be selected from the TI mmWave Industrial Toolbox:

Firmware Path: mmwave_industrial_toolbox_4_10_1/labs/Out_Of_Box_Demo/prebuilt_binaries/

Note: Version 4.10.1 is not strictly required - other versions of the mmWave Industrial Toolbox are also compatible.

Installation & Setup

1. Clone the Repository

git clone https://github.com/Tkwer/RadarStream.git
cd RadarStream

2. Hardware Connection

• Connect TI mmWave radar sensor to PC via micro USB
• Connect DCA1000 EVM to PC via Ethernet cable
• Connect 5V 3A DC power supply to radar board
• Configure network IPv4 settings for DCA1000

3. Network Configuration

Configure your PC’s Ethernet adapter with static IP settings (similar to mmWaveStudio setup):

• IP Address: 192.168.33.30
• Subnet Mask: 255.255.255.0
• Default Gateway: 192.168.33.1

Usage

1. Launch the Application

python main.py

2. Configure the Radar

1. Select COM Port: Choose the appropriate COM port for the radar CLI interface
2. Load Configuration: Select a radar configuration file from the config/ directory
3. Send Config: Click “Send Config” to initialize the radar with selected parameters

3. Start Data Acquisition

• Click “Start” to begin real-time data acquisition and visualization
• Use the interface controls to:
  • Visualize radar data in real-time across multiple feature dimensions
  • Adjust visualization parameters
  • Capture training data for machine learning models
  • Record data sessions for offline analysis

4. Gesture Recognition (Optional)

• Load a pre-trained gesture recognition model
• Enable real-time gesture classification
• View recognized gestures with visual feedback

Applications

RadarStream enables a wide range of radar-based applications:

Human-Computer Interaction 🖐️

• Gesture Recognition: Contactless gesture control for smart devices
• Air Writing: Handwriting recognition in 3D space
• Sign Language Recognition: Accessibility applications

Motion Analysis 🏃

• Activity Recognition: Classify human activities (walking, sitting, falling)
• Gait Analysis: Biomechanical movement assessment
• Sports Analytics: Performance monitoring and analysis

Smart Home & IoT 🏠

• Occupancy Detection: Presence sensing for energy management
• Vital Signs Monitoring: Non-contact heart rate and respiration
• Fall Detection: Elderly care and safety monitoring

Research & Development 🔬

• Algorithm Prototyping: Test new signal processing algorithms
• Dataset Collection: Gather training data for machine learning
• Radar Education: Teaching tool for radar signal processing

Technical Highlights

Performance Optimization

C-Wrapped Data Acquisition

The critical data acquisition module is implemented in C and wrapped for Python, providing:

• True Multi-core Processing: Bypasses Python’s GIL limitation
• Near-Zero Latency: Minimal delay between radar and processing
• Frame-Loss-Free: Reliable data capture even at high frame rates
• Memory Efficient: Optimized buffer management

Real-time Processing Pipeline

Radar Hardware → DCA1000 → Ethernet → C Acquisition Module
                                              ↓
                                    Lock-free Queue
                                              ↓
                            Python Processing Thread
                                              ↓
                                    Feature Extraction
                                              ↓
                            PyQtGraph Visualization

Digital Signal Processing

The dsp/ module provides comprehensive radar signal processing:

• Range FFT: Extract range information from ADC data
• Doppler FFT: Compute velocity information
• Angle Estimation: MUSIC/Bartlett beamforming for angle-of-arrival
• CFAR Detection: Constant False Alarm Rate target detection
• Clutter Removal: Static clutter filtering
• Calibration: Phase and amplitude calibration

Acknowledgment: DSP module references OpenRadar by PreSenseRadar.

Acknowledgements

This project builds upon and references:

• real-time-radar by AndyYu0010 - Real-time processing architecture
• OpenRadar by PreSenseRadar - DSP module implementation

Special thanks to the open-source radar community for their contributions and support.

Future Development

Planned Improvements 🚀

• Validate More RF Boards: Test compatibility with additional TI radar platforms (AWR series, etc.)
• Migrate to PySide6: Update from PyQt5 to PySide6 for better licensing and features
• Flexible API: Make the libs/ folder API more modular and extensible
• Enhanced ML Integration: Add more pre-trained models and training utilities
• Cross-platform Support: Improve Linux and macOS compatibility
• Performance Profiling: Add built-in performance monitoring tools

Community Contributions

If you encounter any issues or have suggestions for improvements, please:

• 🐛 Report Bugs: Submit issues on GitHub
• 💡 Feature Requests: Propose new features or enhancements
• 🔧 Pull Requests: Contribute code improvements
• 📖 Documentation: Help improve documentation and tutorials

RadarStream provides a powerful, flexible platform for real-time mmWave radar data acquisition and processing, making advanced radar sensing accessible for research, development, and practical applications.