Spectric’s VISSERI project demonstrates our LPI/LPD waveform capabilities using Commercial-Off-the-Shelf (COTS) Software Defined Radios (SDR) with a 100% software-only implementation without the need for custom field-programmable gate array (FPGA) development. A software-only implementation supports rapid experimentation and quick changes to respond to rapidly emerging requirements. In contrast, FPGA development is more complex and labor intensive but better suited to systems that require low Size, Weight, and Power (SWaP) requirements.
There are multiple SDR hardware devices that support software development of waveforms, ranging from low-cost receive only devices (e.g. RTL-SDR) to high-end full transceiver devices (e.g. USRP N210). A major benefit of software-only implementation is that, to a degree, the implementation can be easily ported between devices. This is especially true when a middleware library, such as SoapySDR, is utilized.
In this article, we discuss our implementation of the Deepwave AIR-T, a flexible SDR device housed in a rugged outdoor-rated enclosure with integrated multi-core ARM CPU, NVIDIA GPU, and FPGA support. The objective of our effort was to demonstrate the AIR-T as a bidirectional messaging capability using our custom LPI/LPD waveforms that were demonstrated at NetModX (read our previous post). This required the development of Python/C++ software to generate long duration continuous transmissions 60 seconds or more. Because there is no real-time requirement for this application our approach was to generate transmission samples asynchronously and write them to a file. This file was processed and sent to the AIR-T SDR for transmission. A 5.8 GB complex 16-bit integer file was produced at a sample rate of 25.6 Msps, resulting in a 60 second transmission.
Our original implementation processed this intermediate file using a single processing thread operating on the entire file. Given the limitations of the AIR-T ARM CPU this approach resulted in significant latency (164 seconds) between the time the transmission was requested until the transmission started. Once the data was prepared; the samples are broken into chunks which are passed into the AIR-T SDR until no data remains. Therefore, the total time from transmission request until transmission completion was 224 seconds, as shown in Figure 1.
To reduce the latency for transmission, we needed to refactor the software to work with smaller chunks of data in a multi-threaded pipeline. Chunks of data were read in from the file, prepared for transmission, and finally passed to the AIR-T SDR using different threads for each processing stage. Each processing stage is connected by a First-In First-Out (FIFO) queue. By eliminating the bottleneck of sequential processing through parallelization, these smaller chunks are processed and transmitted with less end-to-end latency.
Figure 2 outlines the system assuming the following parameters: chunk size of 262,144 samples, sample rate of 25.6 Msps. At this sample rate and chunk size, the transmission of each chunk lasts roughly 10.24 milliseconds. The read and processing times for each chunk respectively are 4.5 and 5 milliseconds on average. Thus, at a total of 9.5 milliseconds on average, our system can prepare a new chunk for transmission and place it onto the queue before the previous is finished transmitting ensuring continuous transmission.
We have shown that pipelining of the data is required for hardware with lightweight compute resources on an SDR. Pipelining our data significantly reduced latency, transforming read times from seconds to milliseconds and enabling the transmission of gigabyte-sized files. As a result, we can now efficiently transmit large amounts of data in near-real time, even on hardware-limited SDRs.
Heading Image created using Bing AI Image Creator
For more information/questions contact info@spectric.com