View source for AI-Based Spectrum Sensing with Nvidia Jetson and USRP

== Application Note Number and Authors ==

'''AN-811'''

== Authors ==

Bharat Agarwal and Neel Pandeya

== Executive Summary ==

This application note presents a complete framework for real-time spectrum sensing using NI Universal Serial Radio Peripheral (USRP) Software-Defined Radios (SDRs) and NVIDIA Jetson or standard x86 compute platforms. The framework is not limited to a single USRP model—the X410, X310, and B2xx series (e.g., B206) can all be used as transmitters or receivers depending on the deployment scenario. The solution leverages the NI-RF Data Recording API to enable scalable RF data acquisition, SigMF-compliant metadata tagging, and seamless integration with machine learning workflows.

The document outlines three core usage scenarios:

# x86-Based Development Workflow: Using a workstation or server-class x86 machine, paired with high-end USRPs such as the X410 or X310, the system supports wideband spectrum sensing (up to 400&nbsp;MHz instantaneous bandwidth per channel). This configuration is ideal for laboratory development, algorithm training, and high-throughput dataset generation.
# Jetson-Based Embedded Sensing (Primary Use Case): Using an NVIDIA Jetson platform as the host (e.g., AGX Orin) with a compact B206 SDR as receiver and an X410 as transmitter, the system delivers efficient edge inference with GPU acceleration. Although the B206 limits the instantaneous bandwidth to 56&nbsp;MHz, this configuration emphasizes portability, low power, and real-time embedded operation.
# User-Defined Dataset Integration: In addition to live spectrum sensing, the framework supports integration and generation of user-defined datasets. This functionality extends the applicability of the system beyond real-time capture, enabling flexible experimentation, reproducibility, and seamless AI/ML dataset preparation. Two complementary capabilities are supported:
## SigMF Dataset Recording
##* All captured RF data is stored in the Signal Metadata Format (SigMF).
##* SigMF pairs raw IQ samples (<code>.sigmf-data</code>) with a corresponding metadata file (<code>.sigmf-meta</code>) in JSON format.
##* Metadata describes acquisition parameters such as frequency, bandwidth, gain, device type, timestamps, and scenario context.
##* Being human-readable and portable, SigMF datasets can be used across a wide range of software environments, making them ideal for wireless research, spectrum monitoring, AI/ML training for 6G, and regulatory validation.
##* Example: A spectrum sensing session at 3.5&nbsp;GHz, 20&nbsp;MHz bandwidth, and 10-second duration will result in a SigMF-compliant dataset ready for further processing or ML-based classification.
## Continuous Waveform Playback with User-Defined Files
##* The platform supports continuous transmission and replay of user-defined waveforms in TDMS or MATLAB (.mat) formats.
##* This allows testing with standard-compliant signals such as 5G NR, LTE, Radar, or Wi-Fi, or custom-designed waveforms.
##* By replaying predefined waveforms, researchers can benchmark algorithms, validate coexistence scenarios, and reproduce experiments consistently across testbeds.
##* Example: A MATLAB-generated LTE downlink frame can be continuously transmitted via an X410 while a B206 or X310 records the received signal in SigMF format for classification.

Together, these capabilities ensure that the NI-RF Data Recording API can handle both dataset creation (SigMF-based recording) and waveform-driven experimentation (TDMS/MAT playback), thereby covering the entire pipeline from signal generation to ML-ready dataset production.

By combining NI's reliable SDR hardware with NVIDIA's efficient edge compute platforms and a unified data interface, this solution supports a wide range of spectrum intelligence applications—from interference detection and dynamic spectrum access to embedded RF analytics. The methodology enables scalable deployment from lab to field, supporting real-time insights and long-term data collection in a streamlined, modular pipeline.


== USRP B206 Overview ==

[[File: USRP-b206_mini_01.jpg|thumb|center|400px|NI USRP B206 Software Defined Radio]]

The USRP B206 is a compact, low-cost SDR developed by NI / Ettus Research. It supports full-duplex operation with one transmit and one receive channel, making it ideal for a variety of wireless communication and sensing applications. The B206 covers a wide RF frequency range from 70&nbsp;MHz to 6&nbsp;GHz and supports up to 56&nbsp;MHz of instantaneous bandwidth. This makes it suitable for applications such as spectrum sensing, dynamic spectrum access, and cognitive radio.

The device connects to a host system via a high-speed USB&nbsp;3.0 interface, which enables data rates sufficient for wideband real-time signal acquisition and transmission. It also supports USB&nbsp;2.0 with reduced performance. The B206 includes a Xilinx Spartan-6 FPGA for onboard signal processing and is powered either through USB or an external DC supply, the latter being preferred for optimal RF performance.

The USRP B206 is compatible with both x86 and ARM-based hosts, including embedded platforms like the NVIDIA Jetson series. This enables portable and energy-efficient deployment of spectrum sensing pipelines at the network edge. It is fully supported by the open-source UHD and integrates with popular SDR development tools such as GNU Radio, MATLAB, and LabVIEW.

Typical use cases for the B206 include real-time spectrum monitoring, wireless signal classification using machine learning, prototyping of 4G/5G systems, and SDR education and training. Its compact size and flexible software support make it an excellent choice for both laboratory research and embedded field deployments.

'''Key Features of the USRP B206:'''
* RF Capabilities: 1 TX, 1 RX, independently tunable, RF transceiver, 70&nbsp;MHz to 6&nbsp;GHz, up to 56&nbsp;MHz bandwidth
* Programmable Logic: FPGA: Xilinx Spartan-6 XC6SLX150
* Software: UHD 4.9 or later, GNU Radio, C/C++ and Python
* Synchronization: REF (external 10&nbsp;MHz or PPS reference)
* Digital Interfaces: USB&nbsp;3.0, GPIO (8 I/O lines with 3.3&nbsp;V I/O voltage), and JTAG
* Power, form factor: 5&nbsp;V&nbsp;DC, 0.9&nbsp;A maximum; Board-only: 84.3&nbsp;mm × 51.0&nbsp;mm × 8.7&nbsp;mm; Enclosed: 84.9&nbsp;mm × 55.7&nbsp;mm × 19.8&nbsp;mm

== NI-RF Data Recording API Overview ==

The '''[https://github.com/ni/ni-rf-data-recording-api/blob/main/README.md NI-RF Data Recording API]''' is an open-source, Python-based framework developed by National Instruments (NI) in collaboration with the Genesys Lab at Northeastern University. It is designed to streamline RF data collection using NI USRP SDRs, with support for structured metadata via the '''[https://github.com/sigmf/SigMF Signal Metadata Format (SigMF)]'''.

=== Purpose and Scope ===
This API enables efficient recording, labeling, and replay of real-world RF signals. It is particularly suited for generating datasets used in AI/ML workflows, wireless research, and spectrum monitoring. The framework abstracts low-level UHD interactions, allowing users to define RF parameters through JSON or YAML configuration files.

=== Key Features ===
* Support for both signal transmission and reception using NI USRP hardware.
* Native recording in SigMF format, capturing both IQ samples and rich metadata.
* Python-based, modular architecture supporting custom extensions and automation.
* Multi-SDR support via coordinated configuration files.
* Sample waveform libraries included (e.g., LTE, NR, radar, Wi-Fi) in TDMS/MAT formats.
* Utility scripts for standalone use: transmit, receive, replay, or continuous capture.

=== System Requirements ===
The API has been validated on Ubuntu&nbsp;22.04 systems with the following dependencies:
* At least one compatible NI USRP device (e.g., B206, X310, X410).
* Installed UHD drivers with Python bindings.
* Python&nbsp;3.x and required libraries (e.g., NumPy, PyYAML).
* Optional Docker environment for containerized deployment.

=== Relevance to Our Use Cases ===
In this application note, we explore three deployment scenarios of the NI-RF Data Recording API:

# x86-based Spectrum Sensing: Using the API on a desktop or server-class system, the USRP&nbsp;B206 is configured to perform spectrum capture, and the data is saved in SigMF format. This setup is optimal for high-throughput and lab-based development environments.
# Embedded Jetson Platform: The API is deployed on an NVIDIA Jetson device interfaced with the USRP&nbsp;B206 over USB&nbsp;3.0. This enables compact, power-efficient, and real-time spectrum sensing at the edge. Onboard GPU resources are leveraged for FFT computation and ML inference.
# User-Defined Dataset Integration: The API provides flexible support for user-defined datasets through two complementary capabilities:
## Importing Pre-Generated Data: Users can seamlessly import and tag custom IQ recordings (e.g., SigMF-compliant files or previously captured spectrum data) into the repository. This enables integration of external datasets for benchmarking, anomaly detection, or reproducible research.
## Data Lake Storage for AI/ML Pipelines: All captured and imported datasets can be stored in a structured data lake, significantly simplifying automated dataset selection, management, and preprocessing. This facilitates streamlined workflows for AI/ML model design, training, and validation in spectrum sensing and 6G wireless research.

The NI-RF Data Recording API provides a flexible, hardware-agnostic foundation for both live RF capture and offline dataset handling, making it central to spectrum intelligence and edge-aware signal processing workflows.



== Reference Architecture for Spectrum Sensing ==

To support flexible and scalable RF data collection workflows, we propose a dual-mode reference architecture that demonstrates spectrum sensing using NI USRP hardware with two compute platforms: a high-performance x86 host and an embedded NVIDIA Jetson device. Both configurations utilize the NI-RF Data Recording API to capture, store, and manage RF data in SigMF format. The hardware setup supports real-time signal acquisition, tagging, and streaming for downstream machine learning or signal intelligence tasks.

=== x86-Based High-Performance Architecture ===

[[File: x86.png|thumb|center|900px|x86-based spectrum sensing architecture using NI USRP B206 and X410]]

In this high-performance lab-based deployment, a desktop-class x86 host system is used. The USRP&nbsp;X410 (or alternatively the X310) serves as the receiver, connected to the workstation via a 10&nbsp;GbE Ethernet interface to support high-throughput data streaming. The transmitter is also an NI USRP&nbsp;X410, connected through a 10&nbsp;GbE link via a network switch. A 30&nbsp;dB attenuator is inserted between the TX and RX paths to protect the RF front-end from saturation during close-proximity transmission. 

This configuration demonstrates the full high-performance capability of the platform, enabling wideband spectrum sensing and scalable data capture.

Host System Specifications:
* Operating System: Ubuntu&nbsp;22.04  
* UHD Compatibility: The NI-RF Data Recording API supports UHD&nbsp;≥&nbsp;4.2. Most devices such as the X410 or X310 work with older versions, but the B206 requires UHD&nbsp;≥&nbsp;4.9.  
* Processor: Intel&nbsp;Xeon&nbsp;w7-2495X (24&nbsp;cores, 2.5&nbsp;GHz)

This setup is suited for '''high-throughput spectrum recording, algorithm development, and dataset generation''' in a lab environment. It offers large storage capacity, stable power, and CPU-intensive post-processing capabilities.

=== Jetson-Based Embedded Architecture ===

[[File:SS_with_x86.png|thumb|center|900px|Jetson-based spectrum sensing architecture using NI USRP B2x0 and X410]]

In this configuration, an NVIDIA Jetson module serves as the edge processing unit. The Jetson connects to a USRP&nbsp;B2x0 (e.g., B206) over a USB&nbsp;3.0 interface, acting as the spectrum sensor (receiver). A USRP&nbsp;X410 acts as the transmitter, linked via a LAN switch. A 30&nbsp;dB attenuator is used between the TX and RX paths to prevent RF front-end saturation during close-proximity transmission.

The Jetson executes the RF data acquisition pipeline and leverages onboard GPU resources to perform high-speed FFTs, signal classification, and real-time metadata tagging. A display, keyboard, and mouse connect directly for standalone operation.

'Jetson System Specifications:
* Operating System: Ubuntu&nbsp;22.04 with JetPack&nbsp;6.2.1  
* UHD Version: 4.9  
* Processor: NVIDIA&nbsp;Jetson&nbsp;AGX&nbsp;Orin&nbsp;64&nbsp;GB  

This configuration is ideal for low-power, field-deployable sensing nodes where edge inference, minimal latency, and portability are required. The NI-RF Data Recording API runs natively on ARM-based Jetson, ensuring consistent data acquisition across architectures.

=== Common Features Across Architectures ===
Both architectures support:
* Real-time IQ sample recording and metadata tagging using NI-RF Data Recording API  
* Integration with SigMF-compliant datasets  
* Wideband RF capture across 70&nbsp;MHz–6&nbsp;GHz (with B206)  
* Configurable gain, center frequency, bandwidth, and LO offsets via JSON/YAML files  

The dual-platform design allows researchers to prototype, validate, and deploy spectrum sensing pipelines in a variety of scenarios—from power-constrained edge sensing to scalable, cloud-connected research environments.

== Bill of Materials ==

This section lists the hardware and software components required to replicate the spectrum sensing setup described in the reference architectures.

=== Jetson-Based Embedded Spectrum Sensing Setup ===
* '''NI USRP B206 SDR (Receiver)'''
** Frequency Range: 70&nbsp;MHz – 6&nbsp;GHz  
** Bandwidth: up to 56&nbsp;MHz  
** Interface: USB&nbsp;3.0  

* '''NI USRP X410 SDR (Transmitter)'''
** Frequency Range: up to 7.2&nbsp;GHz  
** Bandwidth: up to 1&nbsp;GHz per channel  
** Interface: 10&nbsp;GbE (SFP+)  

* '''NVIDIA Jetson AGX Orin 64&nbsp;GB Developer Kit (Edge Host)'''
** GPU: 2048-core Ampere GPU  
** Interfaces: USB&nbsp;3.0, 10&nbsp;Gb Ethernet  
** OS: Ubuntu&nbsp;22.04 (ARM64) with JetPack&nbsp;6.2.1  

* '''Display and Input Devices'''
** Monitor (DisplayPort or HDMI)  
** USB Keyboard and Mouse  

* '''30&nbsp;dB RF Attenuator'''
** Protects RX frontend during loopback or close-range transmission  

* '''Network Switch (Gigabit)'''
** Routes LAN traffic between Jetson and X410  

* '''RF Cables and Antennas or Dummy Load'''  
* '''Power Supply for USRP X410 and Jetson'''  
* '''USB&nbsp;3.0 Cable (for Jetson–B206 interface)'''


=== x86-Based Spectrum Sensing Setup ===
* '''NI USRP B206 SDR (Receiver)'''
* '''NI USRP X410 SDR (Transmitter)'''
* '''x86 Workstation or Server (Host PC)'''
** CPU: Intel&nbsp;Xeon&nbsp;w7-2495X, 24&nbsp;cores, 2.5&nbsp;GHz  
** OS: Ubuntu&nbsp;22.04&nbsp;LTS  
** UHD: Version&nbsp;4.8 or newer  
** RAM: Minimum 32&nbsp;GB recommended  
** Storage: SSD for high-speed IQ data logging  

* '''Display and Input Devices'''
** Monitor (DisplayPort or HDMI)  
** USB Keyboard and Mouse  

* '''30&nbsp;dB RF Attenuator'''  
* '''USB&nbsp;3.0 Cable (PC–B206 interface)'''  
* '''Ethernet Cables (PC and X410 to switch)'''  
* '''Network Switch (Gigabit or 10&nbsp;GbE)'''  
* '''Coaxial Cable (RF connection between TX and RX)'''
   

=== Software Requirements (Common) ===
* '''NI-RF Data Recording API'''
** GitHub: [https://github.com/ni/ni-rf-data-recording-api https://github.com/ni/ni-rf-data-recording-api]  
** Supports SigMF format, YAML/JSON configuration, UHD interface  

* '''UHD (USRP Hardware Driver)'''
** Version&nbsp;4.9 recommended  
** Installed natively  

* '''Python&nbsp;3.x Environment'''
** Required packages: numpy, pyyaml, sigmf, uhd, etc.


== Hardware Requirements ==

To implement the proposed spectrum sensing architecture, the following hardware components are required. The selected devices are chosen for their compatibility with the NI-RF Data Recording API, support for UHD drivers, and ability to perform high-speed RF acquisition and processing.

=== NI USRP B206 (Receiver SDR) ===
The USRP&nbsp;B206 is a low-cost, full-duplex software-defined radio with wide RF coverage and USB&nbsp;3.0 connectivity, making it ideal for spectrum sensing tasks.

* '''Frequency Range:''' 70&nbsp;MHz&nbsp;–&nbsp;6&nbsp;GHz  
* '''Bandwidth:''' Up to 56&nbsp;MHz  
* '''Interface:''' USB&nbsp;3.0  
* '''Form Factor:''' Compact, bus-powered or DC-powered  
* '''Purchase Link:''' [https://www.ettus.com/all-products/usrp-b200/ https://www.ettus.com/all-products/usrp-b200/]


=== NI USRP X410 (Transmitter SDR) ===
The USRP&nbsp;X410 is a high-performance, 4-channel SDR capable of wideband signal transmission and reception. It supports 10&nbsp;GbE connectivity and real-time FPGA processing.

* '''Frequency Range:''' Up to 7.2&nbsp;GHz  
* '''Bandwidth:''' Up to 1&nbsp;GHz per channel  
* '''Interface:''' 10&nbsp;GbE&nbsp;(SFP+), PCIe&nbsp;(optional)  
* '''FPGA:''' Xilinx Zynq Ultrascale+ RFSoC  
* '''Purchase Link:''' [https://www.ettus.com/all-products/usrp-x410/ https://www.ettus.com/all-products/usrp-x410/]


=== NVIDIA Jetson AGX Orin 64&nbsp;GB Developer Kit (Edge Host) ===
The Jetson&nbsp;AGX&nbsp;Orin series provides a powerful embedded GPU platform for edge AI and RF signal processing.

* '''GPU:''' NVIDIA Ampere architecture  
* '''RAM:''' 32&nbsp;GB&nbsp;/&nbsp;64&nbsp;GB LPDDR4/5  
* '''Connectivity:''' USB&nbsp;3.0, Ethernet, GPIO  
* '''OS Support:''' Ubuntu&nbsp;20.04&nbsp;/&nbsp;22.04&nbsp;(ARM64)  
* '''Purchase Link:''' [https://store.nvidia.com/jetson/store/ https://store.nvidia.com/jetson/store/]


=== Network Switch (Gigabit or 10&nbsp;GbE) ===
A managed or unmanaged Ethernet switch is required to route LAN traffic between the Jetson or x86 host and the USRP&nbsp;X410.

* '''Recommended:''' Netgear&nbsp;GS108, Mikrotik&nbsp;CRS305, or Cisco&nbsp;CBS350  
* '''Typical Ports:''' 8+ (Gigabit or 10&nbsp;GbE&nbsp;SFP+)  
* '''Example Link:''' [https://www.netgear.com/business/wired/switches/smart/gs108/ https://www.netgear.com/business/wired/switches/smart/gs108/]


=== High-Performance x86 Host (Optional for Lab Use) ===
An x86 workstation is recommended for development, high-throughput data collection, or as an alternative to Jetson in a lab environment.

* '''Processor:''' Minimum specification of an 8-core CPU at 3&nbsp;GHz or higher (e.g., Intel&nbsp;Xeon or equivalent). Higher core counts (e.g., 24-core&nbsp;Xeon&nbsp;W7-2495X) can improve throughput and parallel data processing but are not mandatory.  
* '''RAM:''' 64&nbsp;GB or more  
* '''Storage:''' NVMe SSD for high-speed data logging  
* '''Operating System:''' Ubuntu&nbsp;22.04&nbsp;LTS  
* '''Form Factor:''' Tower workstation or server


=== RF Accessories ===
* '''RF Coaxial Cables (SMA)'''  
* '''30&nbsp;dB Attenuator''' – Protects RX during close TX–RX loopback tests  
* '''Antennas''' (Wideband or band-specific)  
* '''Dummy Load''' (for isolated lab TX tests)  
* '''USB&nbsp;3.0 Cable''' (for USRP&nbsp;B206)  
* '''Ethernet Cables''' (Cat&nbsp;6 or SFP+ DAC for X410)  
* '''Power Supplies:'''
** Jetson: 19&nbsp;V&nbsp;/&nbsp;4.74&nbsp;A adapter (usually included)  
** X410: External DC or rack supply per specifications


== Software Requirements ==

This section outlines the required software components for enabling spectrum sensing using the NI-RF Data Recording API with USRP&nbsp;B206/X410 and NVIDIA Jetson or x86 hosts. These tools are compatible across both embedded and desktop-class platforms and support real-time signal acquisition and metadata tagging in SigMF format.

=== Ubuntu Operating System ===
* '''Version:''' Ubuntu&nbsp;22.04&nbsp;LTS (Jetson) / Ubuntu&nbsp;22.04&nbsp;LTS (x86 recommended)
* '''Download Link:''' [https://ubuntu.com/download https://ubuntu.com/download]
* '''Jetson OS Image:''' JetPack&nbsp;SDK includes Ubuntu and NVIDIA drivers  
* '''JetPack Link:''' [https://developer.nvidia.com/embedded/jetpack https://developer.nvidia.com/embedded/jetpack]


=== NI-RF Data Recording API ===
* '''Description:''' Open-source Python API developed by NI and the Genesys Lab (Northeastern University) for recording and labeling RF data in SigMF format using USRP devices.  
* '''Features:''' Configurable YAML/JSON setups, multi-SDR coordination, SigMF conversion, supports transmission/reception workflows.  
* '''Repository:''' [https://github.com/ni/ni-rf-data-recording-api https://github.com/ni/ni-rf-data-recording-api]


=== UHD – USRP Hardware Driver ===
* '''Description:''' The official driver and API library for controlling and interfacing with all NI/Ettus USRP SDR hardware. Required for low-level communication between Python and the hardware.  
* '''Version:''' The NI-RF Data Recording API requires a UHD version that supports the selected USRP device:  
** For X410 (and other X-Series): UHD&nbsp;≥&nbsp;4.2 (first stable release UHD&nbsp;4.4 recommended)  
** For B206: UHD&nbsp;≥&nbsp;4.9 required  
* '''Repository:''' [https://github.com/EttusResearch/uhd https://github.com/EttusResearch/uhd]  
* '''Install Guide:''' [https://kb.ettus.com/Building_and_Installing_the_USRP_Open-Source_Toolchain_(UHD_and_GNU_Radio)_on_Linux UHD and GNU&nbsp;Radio Install Guide]


=== Python Environment ===
* '''Version:''' Python&nbsp;3.10.12 or newer  
* '''Required Packages:'''  
** <code>numpy</code>, <code>pyyaml</code>, <code>sigmf</code>, <code>uhd</code>, <code>scipy</code>, <code>matplotlib</code>, etc.  
* '''Package Manager:''' <code>pip</code> or <code>conda</code>  
* '''Recommended Setup:''' Create a Python virtual environment for isolation and reproducibility.  
* '''Download Link:''' [https://www.python.org/ https://www.python.org/]


=== SigMF Library (Python) ===
* '''Description:''' Used for generating and parsing metadata in the Signal Metadata Format (SigMF), enabling dataset interoperability and ML dataset labeling.  
* '''Supported Version:''' Validated with '''SigMF&nbsp;1.0.0''' (later versions such as&nbsp;1.1.x or&nbsp;1.2.x introduce major changes and have not been validated).  
* '''Repository:''' [https://github.com/gnuradio/sigmf-numpy https://github.com/gnuradio/sigmf-numpy]  
* '''Installation Command:''' <code>pip install sigmf==1.0.0</code>  
* '''Reference:''' For more details, see the [https://github.com/ni/ni-rf-data-recording-api/tree/main/docs NI RF Data Recording API Getting Started Guide].


== Installing and Configuring the UHD Software ==

This section explains how to build and install the USRP Hardware Driver (UHD) from source code. At the time of this writing, the recommended version is '''UHD&nbsp;4.9'''.

* It is strongly recommended to build UHD from source rather than installing from binary packages to ensure compatibility and access to the latest updates.  
* For x86/64 Ubuntu systems with released UHD versions available, you may install via APT Debian packages.  
* For Jetson (ARM64) systems, UHD must be built from source since no binary packages are provided.


Before building UHD, install all required dependencies (Ubuntu&nbsp;22.04):

'''Note:''' If your system already has another UHD version installed, remove it first:

<syntaxhighlight lang="bash">
sudo apt remove libuhd* uhd-host
sudo rm -rf /usr/lib/uhd /usr/include/uhd /usr/local/lib/uhd /usr/local/include/uhd
</syntaxhighlight>

Then install build dependencies:

<syntaxhighlight lang="bash">
sudo apt update && sudo apt install -y \
  cmake g++ libboost-all-dev libusb-1.0-0-dev \
  libuhd-dev python3 python3-mako python3-numpy \
  python3-requests python3-ruamel.yaml libfftw3-dev \
  libqt5opengl5-dev qtbase5-dev qtchooser qt5-qmake \
  qtbase5-dev-tools doxygen
</syntaxhighlight>

Clone the UHD repository and check out version '''v4.9.0.0''':

<syntaxhighlight lang="bash">
git clone https://github.com/EttusResearch/uhd.git
cd uhd
git checkout v4.9.0.0
</syntaxhighlight>

Build and install UHD:

<syntaxhighlight lang="bash">
cd host
mkdir build && cd build
cmake ..
make -j$(nproc)
sudo make install
sudo ldconfig
export LD_LIBRARY_PATH=/usr/local/lib
sudo usrp_images_downloader
</syntaxhighlight>

Verify the installation:

<syntaxhighlight lang="bash">
uhd_usrp_probe
uhd_find_devices
</syntaxhighlight>

For more details, see the official UHD GitHub page:  
[https://github.com/EttusResearch/uhd https://github.com/EttusResearch/uhd]

[[File:uhd_usrp_probe_output.png|thumb|400px|center|uhd_usrp_probe output for B206]]
[[File:uhd_find_devices_output.png|thumb|400px|center|uhd_find_devices output for N310 and X410]]

'''Figure:''' Examples of UHD utilities used for USRP probing and device discovery.


=== Post UHD Installation Tasks ===
* '''Download USRP images'''
<syntaxhighlight lang="bash">
sudo /usr/local/bin/uhd_images_downloader
</syntaxhighlight>

* '''Add USB udev rule''' (can be limited to specific vendor/device IDs)
<syntaxhighlight lang="bash">
sudo nano /etc/udev/rules.d/99-usb.rules
# Add this line:
# SUBSYSTEM=="usb",MODE="0666"
sudo udevadm control --reload-rules
sudo udevadm trigger
</syntaxhighlight>

* Unplug and replug the USB device if it was already connected.

* '''Enable Python UHD API visibility'''
<syntaxhighlight lang="bash">
echo "/usr/local/lib/python3.10/site-packages" | \
sudo tee /usr/local/lib/python3.10/dist-packages/local-site-packages.pth
</syntaxhighlight>

=== UHD Installation Verification ===
* '''Find connected USRP devices'''
<syntaxhighlight lang="bash">
uhd_find_devices
</syntaxhighlight>

* '''Run throughput benchmark on the B2x0 device'''
<syntaxhighlight lang="bash">
/usr/local/lib/uhd/examples/benchmark_rate --args "type=b200" --rx_rate 10e6
</syntaxhighlight>

* '''Run Python throughput benchmark'''
<syntaxhighlight lang="bash">
python3.10 /usr/local/lib/uhd/examples/python/benchmark_rate.py --args "type=b200" --rx_rate 10e6
</syntaxhighlight>

== Installing and Configuring the USRP X410 Radio ==

For detailed documentation, see the official Ettus manual:  
[https://files.ettus.com/manual/page_usrp_x4xx.html https://files.ettus.com/manual/page_usrp_x4xx.html]


=== Connecting to the X410 ===
You can connect to the USRP X410 using either of the following interfaces:
* Ethernet (RJ45)
* USB-C JTAG Console

If you cannot connect to the X410 (e.g., because it has a static IP address):

* Connect the USRP to your PC using a USB-C ↔ USB cable.  
  See the '''Serial connection''' section in the Ettus manual: [https://files.ettus.com/manual/page_usrp_x4xx.html]
* Change the static IP to a DHCP-assigned IP.  
  See the '''Network interfaces''' section: [https://files.ettus.com/manual/page_usrp_x4xx.html]

=== Updating the Filesystem ===
For full details, refer to the Ettus manual section: [https://files.ettus.com/manual/page_usrp_x4xx.html Updating Filesystems].

The easiest method is to perform the update directly on the X410 using the built-in <code>usrp_update_fs</code> utility:

<syntaxhighlight lang="bash">
# Login to the USRP
ssh root@usrp_ip

# Update filesystem to UHD 4.9
usrp_update_fs -t UHD-4.9

# Or install the UHD master version
usrp_update_fs -t master

# Reboot the USRP
reboot

# If the reboot works and the device is functional, commit the changes
mender commit
</syntaxhighlight>


=== Updating the FPGA Image ===
For details, see: [https://files.ettus.com/manual/page_usrp_x4xx.html Updating the FPGA].

You can verify and benchmark the X410 performance using the UHD example utility:

<syntaxhighlight lang="bash">
./benchmark_rate --args="mgmt_addr=10.89.12.177,addr=192.168.10.2,\
second_addr=192.168.11.2,clock_source=internal,time_source=internal" \
--rx_rate 200e6 --channels 0 --rx_channels 0
</syntaxhighlight>


== Installing Spectrum Sensing Example on x86 Architecture ==

This section provides a detailed procedure for installing and running the Spectrum Sensing example on an x86 architecture.  
The '''spectrum_sensing''' folder within the NI-RF Data Recording API repository provides a ready-to-run demonstration of live RF spectrum sensing using a single receiver (e.g., USRP&nbsp;B206/X410) connected to an x86 host.


=== Setup Instructions ===
* '''Clone the repository:'''
<syntaxhighlight lang="bash">
git clone https://github.com/ni/ni-rf-data-recording-api.git
</syntaxhighlight>

* '''Clone the YOLOv5 repository:'''
<syntaxhighlight lang="bash">
git clone https://github.com/ultralytics/yolov5
</syntaxhighlight>

* '''Install dependencies for NI RF Data Recording API:'''
<syntaxhighlight lang="bash">
cd ni-rf-data-recording-api
pip install -r requirements.txt
</syntaxhighlight>

=== Python Package Dependencies ===
The following Python packages are required to run the spectrum sensing pipeline using the NI-RF Data Recording API.  

* '''termcolor''' – Prints colored text in terminal for log readability.  
* '''numpy&nbsp;(>=1.23.5,&nbsp;<2.0.0)''' – Core numerical library for IQ array operations, FFTs, and signal processing.  
* '''scipy&nbsp;(>=1.4.1)''' – Used for filtering, spectral analysis, and mathematical routines.  
* '''matplotlib&nbsp;(>=3.3)''' – Generates spectrum plots, spectrograms, and PSD visualizations.  
* '''pandas&nbsp;(>=1.1.4)''' – Handles RF metadata and experiment logs.  
* '''pyyaml&nbsp;(>=5.3.1)''' – Loads YAML configuration files for USRP setup parameters.  
* '''nptdms''' – Enables reading and writing NI TDMS waveform files.  
* '''sigmf''' – Implements Signal Metadata Format for storing IQ recordings with metadata.  


* '''Install dependencies for the example:'''
<syntaxhighlight lang="bash">
cd ni-rf-data-recording-api/examples/spectrum_sensing
pip install -r requirements.txt
</syntaxhighlight>

=== Advanced Python Dependencies for Spectrum Sensing and ML Integration ===
These additional libraries enable advanced visualization, AI/ML inference, and web dashboard integration.

* '''dash''' – Web-based dashboard framework for real-time spectrum visualization.  
* '''dash-daq''' – Adds instrumentation UI components for live control.  
* '''dash-bootstrap-components''' – Provides responsive Bootstrap layouts for Dash apps.  
* '''pillow&nbsp;(>=10.3.0)''' – Handles image saving and processing of spectrograms.  
* '''torch&nbsp;(>=1.8.0)''' – PyTorch deep learning framework for inference/training.  
* '''torchvision&nbsp;(>=0.9.0)''' – Vision utilities for preprocessing spectrograms.  
* '''ultralytics&nbsp;(>=8.2.34)''' – YOLOv8 utilities for signal classification.  
* '''gitpython&nbsp;(>=3.1.30)''' – Enables automated Git repository handling.  
* '''opencv-python&nbsp;(>=4.1.1)''' – Performs spectrogram image manipulation.  
* '''seaborn&nbsp;(>=0.11.0)''' – Provides data visualization and heatmaps.  
* '''tqdm&nbsp;(>=4.66.3)''' – Adds progress bars during capture or inference.  
* '''requests&nbsp;(>=2.32.2)''' – Handles model downloads and HTTP requests.  
* '''setuptools&nbsp;(>=70.0.0,&nbsp;<80.9.0)''' – Ensures consistent Python packaging.  


=== Configuring the Example ===
The configuration files are located at:  
<code>~/ni-rf-data-recording-api/examples/spectrum_sensing/config/</code>

They define:
* RF parameters: center frequency, gain, bandwidth, sample rate  
* Device type (e.g., B206) and connection interface  
* Capture duration and number of records  
* Output directory and naming conventions  


=== Key Configuration Parameters ===
{| class="wikitable"
! Parameter !! Description !! Example
|-
| <code>rx_recorded_data_path</code> || Path to store captured IQ data || <code>datasets/records/</code>
|-
| <code>nrecords</code> || Number of snapshots to capture || <code>10</code>
|-
| <code>freq</code> || Center frequency (Hz) || <code>3.6e9</code>
|-
| <code>rate</code> || IQ sample rate (Sps) || <code>50e6</code>
|-
| <code>bandwidth</code> || Analog bandwidth || <code>20e6</code>
|-
| <code>gain</code> || RX gain (dB) || <code>40</code>
|-
| <code>duration</code> || Recording duration (s) || <code>0.04</code>
|-
| <code>rate_source</code> || Sample rate mode || <code>user_defined</code>
|-
| <code>captured_data_file_name</code> || Prefix for SigMF files || <code>rx-waveform-td-rec-</code>
|-
| <code>antenna</code> || Antenna port || <code>TX/RX</code>
|-
| <code>clock_reference</code> || Reference clock || <code>internal</code>
|}

=== Execution ===
(a) Run the UI application:
<syntaxhighlight lang="bash">
cd ~/ni-rf-data-recording-api/examples/spectrum_sensing
python spectrum_sensing.py
</syntaxhighlight>

After launching, you’ll see:
<code>Dash is running on http://127.0.0.1:8050/</code>  
Open this link in your browser to access the dashboard.

* Load a configuration file from the dashboard.
* Click '''Start''' to begin sensing.
* IQ samples will be captured and saved in SigMF format at:
<code>~/ni-rf-data-recording-api/examples/spectrum_sensing/datasets/records</code>

[[File:Dashboard.png|thumb|800px|center|AI-based spectrum sensing dashboard using NI USRP SDRs and NI RF Data Recording API]]

'''Figure:''' AI-based spectrum sensing system using NI USRP SDRs, the NI RF Data Recording API, and a web-based control dashboard.

=== System Workflow Description ===
The figure above shows the end-to-end architecture for AI-driven spectrum sensing with NI USRPs.

* '''TX Configuration:''' User selects the waveform to transmit; it can be sent over-the-air or via RF cable.  
* '''Start/Stop Control:''' Clicking '''Start''' launches the sensing and recording pipeline with live indicators for SDR initialization and capture status.


(b) Run the inference script:
<syntaxhighlight lang="bash">
cd ~/ni-rf-data-recording-api/examples/spectrum_sensing
python inference.py
</syntaxhighlight>

The inference script processes IQ recordings stored in:
<code>~/ni-rf-data-recording-api/examples/spectrum_sensing/datasets/records</code>

It converts each dataset into a spectrogram image saved at:
<code>~/ni-rf-data-recording-api/examples/spectrum_sensing/datasets/images</code>

The spectrograms are passed to a pre-trained '''YOLOv5''' model for signal classification.

[[File:inference_running.png|thumb|800px|center|YOLOv5-based live inference detecting a 5G NR signal with 96% confidence]]

'''Figure:''' Real-time inference output showing successful detection of a 5G&nbsp;NR waveform using a pre-trained YOLOv5 model.

=== Live Inference Visualization ===
After IQ samples are captured and stored, <code>inference.py</code> generates spectrograms and classifies signals.  
In the shown example, the YOLOv5 model identifies a 5G&nbsp;NR waveform (<code>5GNR</code>) with a confidence score of '''0.96'''.  
Detected signals show high classification accuracy and clear time-frequency boundaries.

== Spectrum Sensing Application with NI USRP and NVIDIA Jetson ==

This section summarizes the official documentation for running the <code>spectrum_sensing</code> application using NI USRP SDR hardware on NVIDIA Jetson platforms.

=== Overview ===
The application demonstrates real-time spectrum sensing by interfacing a NI USRP SDR (e.g., B206) with an NVIDIA Jetson device over USB&nbsp;3.0. The Jetson hosts the NI RF Data Recording API and executes the entire data acquisition pipeline — including RF configuration, signal capture, visualization, and data formatting into SigMF files.  
Because Jetson devices are ARM-based, a Jetson-specific PyTorch package is available from NVIDIA, while TorchVision must be built from source.


=== PyTorch Installation ===
* Install required dependencies:
<syntaxhighlight lang="bash">
sudo apt update
sudo apt install python3-pip libopenblas-base libopenmpi-dev
sudo pip3 install --upgrade pip
</syntaxhighlight>

* For Python&nbsp;3.10 and JetPack&nbsp;6.2.1, install PyTorch&nbsp;2.5:
<syntaxhighlight lang="bash">
wget https://developer.download.nvidia.com/compute/redist/jp/v61/pytorch/torch-2.5.0a0+872d972e41.nv24.08.17622132-cp310-cp310-linux_aarch64.whl
pip3 install torch-2.5.0a0+872d972e41.nv24.08.17622132-cp310-cp310-linux_aarch64.whl
</syntaxhighlight>

* Fix libcusparse-related errors (if any):
<syntaxhighlight lang="bash">
mkdir -p ~/tmp_cusparselt && cd ~/tmp_cusparselt
wget https://developer.download.nvidia.com/compute/cusparselt/redist/libcusparse_lt/linux-aarch64/libcusparse_lt-linux-aarch64-0.7.0.0-archive.tar.xz

tar xf *.tar.xz
sudo cp -a libcusparse_lt-linux-aarch64-0.7.0.0-archive/include/* /usr/local/cuda/include/
sudo cp -a libcusparse_lt-linux-aarch64-0.7.0.0-archive/lib/* /usr/local/cuda/lib64/
sudo ldconfig
cd ~ && rm -rf ~/tmp_cusparselt

* Verify installation
python3 -c "import torch; print(torch.__version__); print(torch.cuda.is_available())"
# Output should show:
# 2.5.0a0+872 and True
</syntaxhighlight>

=== PyTorch Vision (torchvision) ===
* Install dependencies:
<syntaxhighlight lang="bash">
sudo apt-get install libjpeg-dev zlib1g-dev libpython3-dev libopenblas-dev \
libavcodec-dev libavformat-dev libswscale-dev
</syntaxhighlight>

* Clone the source repository:
<syntaxhighlight lang="bash">
git clone --branch v0.20.0 https://github.com/pytorch/vision.git
</syntaxhighlight>

* Build and install:
<syntaxhighlight lang="bash">
cd vision
export BUILD_VERSION=0.20.0
python3 setup.py build
python3 setup.py install
</syntaxhighlight>

=== Python Virtual Environment (Optional) ===
To isolate the working environment from the system:
* Install <code>venv</code> support:
<syntaxhighlight lang="bash">
sudo apt-get install python3.10-venv
</syntaxhighlight>

* Create and activate environment:
<syntaxhighlight lang="bash">
python3.10 -m venv .venv --system-site-packages --prompt demo
source .venv/bin/activate
</syntaxhighlight>

=== Python Requirements ===
* Install SigMF:
<syntaxhighlight lang="bash">
pip install sigmf
</syntaxhighlight>

* Install npTDMS:
<syntaxhighlight lang="bash">
pip install npTDMS
</syntaxhighlight>

* Colored terminal output:
<syntaxhighlight lang="bash">
pip install colored termcolor
</syntaxhighlight>

* Dash and dashboard components:
<syntaxhighlight lang="bash">
pip install dash dash_daq dash_bootstrap_components
</syntaxhighlight>

* YOLOv5 pre-requirements:
<syntaxhighlight lang="bash">
pip install -U "gitpython>=3.1.30" "matplotlib>=3.3" "numpy>=1.23.5" \
"opencv-python>=4.1.1" "pillow>=10.3.0" psutil "PyYAML>=5.3.1" \
"requests>=2.32.2" "scipy>=1.4.1" "thop>=0.1.1" "tqdm>=4.66.3" \
"ultralytics>=8.2.34" "setuptools>=70.0.0" "seaborn>=0.11.0"
</syntaxhighlight>

=== YOLOv5 Model ===
The demo application uses the YOLOv5 image detection model from Ultralytics (AGPL-3.0 license).

<syntaxhighlight lang="bash">
git clone https://github.com/ultralytics/yolov5
</syntaxhighlight>


=== Demo Code and Data Recording API ===
Clone the NI RF Data Recording API repository:
<syntaxhighlight lang="bash">
git clone https://github.com/ni/ni-rf-data-recording-api.git
</syntaxhighlight>

After all dependencies are installed, the Spectrum Sensing use case can be executed on Jetson following the same procedure as described for the x86 system.


== Waveform Creation and Signal Recording Pipeline ==

This section outlines the process for generating waveforms, capturing RF data using the NI-RF Data Recording API, and producing spectrogram images for machine learning applications.

=== Waveform Repository ===
The <code>src/waveforms/</code> directory contains all pre-generated test signals used with the NI RF Data Recording API.  
It includes four subfolders: '''5G&nbsp;NR''', '''LTE''', '''Wi-Fi''', and '''Radar'''.

Each waveform consists of:
* '''IQ Data File''' (<code>.tdms</code> or <code>.mat</code>) — contains complex baseband samples.  
* '''Configuration File''' (<code>.rfws</code>, <code>.yaml</code>, or <code>.csv</code>) — describes waveform parameters such as bandwidth and sampling rate.

'''Examples:'''
* LTE: <code>LTE_TDD_DL_20MHz_....tdms</code> + <code>...rfws</code>  
* Radar: <code>Radar_Waveform_BW_2M.mat</code> + <code>Radar_Waveform_BW_2M.yaml</code>

[[File:waveform_repository_small_dimensions.png|thumb|800px|center|Waveform repository flow]]

'''Figure:''' Waveform repository structure showing pre-generated 5G&nbsp;NR, LTE, Wi-Fi, and Radar signals mapped through the Wireless Link Parameter Dictionary.

=== Waveform Sources ===
* '''RFmx Waveform Creator:''' Used for generating 5G&nbsp;NR and LTE waveforms (<code>.tdms</code> + <code>.rfws</code>).  
* '''IEEE MATLAB Wi-Fi Generator:''' Used for Wi-Fi test signals (<code>.mat</code> + <code>.csv</code>).  
* '''Simulated Radar Generator (MATLAB):''' Used for radar signals (<code>.mat</code> + <code>.yaml</code>).  


=== Usage in the API ===
During recording, JSON/YAML configuration files in <code>src/config/</code> reference these waveform paths.  
The <code>wireless_link_parameter_map.yaml</code> dictionary maps waveform configuration fields (e.g., bandwidth, sampling rate, standard) to the SigMF metadata format — ensuring standardized dataset descriptions.


=== Recording IQ Data and Metadata via API ===
Once waveforms are prepared:

* Edit the configuration file (YAML/JSON) with your TX/RX parameters such as frequency, gain, and waveform paths.  
* Run the recording:
<syntaxhighlight lang="bash">
python3 main_rf_data_recording_api.py --config path/to/your_config.yaml
</syntaxhighlight>
* The API maps parameters to SigMF metadata, controls USRP Tx/Rx via UHD, and writes:
** <code>.sigmf-data</code> (binary IQ samples)
** <code>.sigmf-meta</code> (JSON metadata)

=== Spectrogram Image Generation via Preprocessing ===
After dataset generation:

* Run preprocessing scripts (e.g., <code>rf_data_pre_processing_plot.py</code>) to visualize or convert SigMF recordings into time/frequency plots.  
* Generate and crop spectrograms, partitioning them into training and validation sets for ML workflows.  
* The structured image datasets form the foundation for AI-based spectrum classification and detection.

This end-to-end pipeline — from waveform generation to SigMF-formatted capture and spectrogram creation — enables reproducible, metadata-rich dataset production for AI-driven spectrum sensing research.

== How to use RF Data Recording API with user defined dataset? ==
To use the NI RF Data Recording API with a user-defined dataset for training and inference using YOLOv8, follow this multi-step process covering signal generation, data preprocessing, model training, and inference.

---

=== SigMF Data and Metadata Generation ===
Once the transmission signal is configured, stream IQ samples and record them in '''SigMF''' format by running <code>data_recording.py</code>:

* Location of the script:
: <code>/ni-rf-data-recording-api/examples/spectrum_sensing</code>

* SigMF outputs:
** <code>.sigmf-data</code>: Binary file with raw IQ samples.  
** <code>.sigmf-meta</code>: JSON metadata (frequency, sample rate, gain, antenna, timestamps, etc.).

The script uses your YAML/JSON control file for parameters (center frequency, sample rate, bandwidth, gain, capture duration, number of records).

* Output directory:
: <code>/ni-rf-data-recording-api/examples/spectrum_sensing/datasets/records</code>

These SigMF files become the primary dataset for later analysis, visualization, and ML-based classification (e.g., spectrogram-based YOLO).

---

=== Spectrogram Generation and Dataset Preprocessing ===
Convert SigMF recordings into labeled spectrogram images using <code>pre-processing.py</code>. It orchestrates:

# <code>spectrogram_creator.py</code> – Reads <code>.sigmf-data</code>, applies STFT, saves spectrogram images (e.g., in <code>datasets/images</code>).
# <code>image_cropper.py</code> – Removes non-signal plot artifacts (axes, labels, borders) to produce clean images for detection models.
# <code>dataset_partitioner.py</code> – Splits dataset into train/val (e.g., 80/20) with balanced classes.
# <code>label_maker.py</code> – Creates YOLO-compatible label files for each image in the format:
: <code>&lt;class_id&gt; &lt;x_center&gt; &lt;y_center&gt; &lt;image_width&gt; &lt;image_height&gt;</code>

'''Resulting structure:'''
* Cleaned spectrogram images: <code>datasets/images</code>  
* YOLO labels: <code>datasets/labels</code>  
* Splits: <code>datasets/train</code>, <code>datasets/val</code>

This pipeline yields a model-ready dataset for accurate training and inference.

---

=== Dataset Configuration: <code>data.yaml</code> for YOLO Training ===
'''Fields:'''
* <code>train</code> – Path to training images  
* <code>val</code> – Path to validation images  
* <code>nc</code> – Number of classes  
* <code>names</code> – List of class names in class-id order

'''Example:'''
<syntaxhighlight lang="yaml">
train: datasets/train/images
val: datasets/val/images

nc: 3
names: ['5gnr', 'wifi', 'lte']
</syntaxhighlight>

Use this file with YOLOv5/YOLOv8 training commands. Store it in the project root or inside the dataset folder.

---

=== Model Training Using YOLOv8 (Example) ===

==== Cloning YOLOv8 from Source ====
<syntaxhighlight lang="bash">
# Clone Ultralytics YOLOv8
git clone https://github.com/ultralytics/ultralytics.git
cd ultralytics

# (Optional) Virtual environment
python3 -m venv .venv
source .venv/bin/activate   # Linux/macOS
# .venv\Scripts\activate    # Windows PowerShell

# Install in editable mode
pip install --upgrade pip
pip install -e .
</syntaxhighlight>

Verify:
<syntaxhighlight lang="bash">
yolo help
</syntaxhighlight>

==== YOLOv8 Training Command ====
Train the nano model on your spectrogram dataset:
<syntaxhighlight lang="bash">
yolo detect train \
  model=yolov8n.pt \
  data=/content/dataset/data.yaml \
  epochs=50 \
  imgsz=640 \
  batch=16 \
  project=burst_train \
  name=yolov8n_spectrogram
</syntaxhighlight>

'''Parameter notes:'''
* <code>model=yolov8n.pt</code> – Base architecture (nano).  
* <code>data=...</code> – Path to <code>data.yaml</code>.  
* <code>epochs=50</code> – Training epochs.  
* <code>imgsz=640</code> – Input resolution.  
* <code>batch=16</code> – Batch size.  
* <code>project</code>/<code>name</code> – Output directories for logs/artifacts.

'''Outputs:'''
: <code>burst_train/yolov8n_spectrogram</code>  
(Weights, logs, confusion matrices, PR curves, etc.)


== Conclusion ==
The NI RF Data Recording API provides a powerful and flexible framework for real-time spectrum sensing, dataset generation, and AI-driven signal classification across both x86 and embedded platforms such as NVIDIA Jetson.  
By leveraging standardized formats like SigMF and integrating deep learning models such as YOLOv8, the framework enables a complete end-to-end workflow—from RF signal acquisition and metadata tagging to spectrogram creation, training, and live inference.  

This modular approach allows researchers and engineers to rapidly prototype, evaluate, and deploy intelligent wireless sensing systems that bridge the gap between traditional SDR experimentation and modern AI-based spectrum analytics.  
The same unified methodology can be extended to multi-band sensing, interference detection, cognitive radio, and 6G spectrum intelligence research, ensuring scalability and reproducibility in both laboratory and field environments.

[[Category:Application Notes]]