Welcome to PyRAPID¶
Python Radar Advanced Processing Implementation & Demonstration `PyRAPID` library is for speed-efficient implementation of the radar processing chains and demonstration of the analyzed data in real-time. The library creates a parallel processing environment similar to GNURadio, but this is fully in Python. It uses variety of built-in parallel processing tools in Python to enhance and optimize the visualization and processing speeds suited to real-time radar system development for many applications. Currently, most basic functions and processing blocks are compatible with FMCW radars, but some of them could be used for other kinds of radars.
We use PyRAPID for:
fast system development and debugging
platform-independent implementation
capturing real-time data from a radar
intuitive and interactive radar maps demonstration
PyRAPID is not good yet for:
learning very basics of radar processing
simulating radar algorithm performances
radar hardware investigation and optimization
designing arrays
Like for all systems, there are prons and cons for PyRAPID:
- Pros:
easy to use for without a need to know parallel processing concepts
optimized for fast processing to achieve real-time processing
Real-time processing and visualization
compatible with Texas Instruments boards (tested AWR1243, AWR1443, AWR1642)
- Cons:
likely lower speed than C++ counterparts (if any)
higher runtime overhead compared to C++
Why Python for radar processing?¶
We must give reasons for choosing Python as a basis for our implementation. The parallel processing is nowadays realizable by high-speed processors such that different tasks are time-multiplexed such that multiple tasks can be run in an interleaved manner which seem to be run at the same time. To accomplish multiple processing at the same time, in C++ one can use multi-threading with which different functions (or tasks) can be run on parallel. In fact, in multi-core processors, each thread in C++ run on different core gives the ability to run independent threads in parallel. For instance, if the CPU has two cores, two independent threads can be scheduled independently on the two cores and their operations are totally in parallel in time. However, in Python, multi-threading has different concept instead multi-processing can give benefits of parallelism with more overhead comparing to the threading in C++. For the below discussion in this section, we use multi-processing and multi-threading in our program diagram. However, we will explain them later.
There are different parallel processing frameworks such as GNURadio, which is based on C++ and it is wrapped by SWIG to Python. It uses the capability of threading in C++ by defining processing blocks such that each block can be connected to other blocks to transfer data down the signal processing chain. The platform allows users to define their own processing blocks leveraging all capabilities of the libraries in Python and to make a flowgraph containing at least a source and sink to get and output the data, respectively. The framework is very rich with lots of services such as asynchronous message passing between processing block and tagging options on the data stream. However, it is inefficient based on multithreading strategy in Python as it is wrapped from C++ to Python. Indeed, it is complicated to have an interface with other python tools such as multi-processing, and it is mandatory to follow a restricted structure (this is due to being very general rather than application-based structure).
Instead of using GNURadio, we decided to use the basic built-in parallel processing in Python to efficiently implement based on the processing and the power demand for each signal processing task. In addition, the implementation is presented here is platform-independent, i.e. it can be used on operating systems. You could find more details about the processing system structure in Python Radar API.
Real-time detecting and tracking poeple¶
The following video shows people tracking demo with TI AWR1243 and DCA1000 boards (see Texas Instruments radars).
In PyRAPID, it is easy and quick to make a signal processing chain and
demonstrate the radar maps simultaneously in the GUI.
The processing chain in Fig is used to analyze the binray data coming from the radar
down to passing the detected target points to the GUI. The application layer is only responsible for
data representation (see application main window).
In GUI, each target is tracked and illustrated with a specific color.
Real-time 3D detection and tracking demo¶
The following video shows a real-time radar 3D processing by using high-resolution azimuth and elevation
spectrum estimation. Again, TI AWR1243 and DCA1000 were used.
The GUI (see application main window)
then represents the detected points of the targets and assigns a unique
color to each target. The signal processing flow is depicted in Fig1. The radar basic processing
including reading radar bits, range FFT, Doppler FFT, and Doppler compenstation are common to all
processing system. To reduce the data size, the range CFAR detects points in range (or fast-time).
Then the radar cube will be truncated taking only those ranges. Further the signal goes down to the
angle processing where finally angle CFAR finds the target location in
\((azimuth, elevation)=(\theta,\phi)\) .
In the video, two people are walking up to 20 meters. Sometime a target blocks the other and it causes to miss the second target for s short period of time. However, the stable tracking keeps waiting for the reappearance of the target for about 2 seconds. If it will come back near to its previous location, the track remained for the target; otherwise, the track will be released.
Preliminary on FMCW radars
Introduction to PyRAPID API
PyRAPID API
References
Acknowledgments