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.

figs/demo_chain.jpg

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.

figs/TDM_3d_20m_flowgraph.jpg

References

Acknowledgments

Indices and tables