host: examples/python: Add full duplex example

Example usage of the bladeRF in full duplex operation with the Python3
bindings.
This commit is contained in:
Brian Glod 2018-11-30 20:37:09 -05:00 • committed by Rey Tucker
commit 9eaaf77986
3 changed files with 591 additions and 0 deletions

View file

@ -0,0 +1,9 @@
# Python3 TX/RX Example #
This example illustrates how to transmit and receive using the bladeRF Python3
bindings. The example can perform these operations in either full or half
duplex and is configurable with the provided ConfigParser INI file.
In order for this to work, libbladeRF and the
[bladeRF Python3 bindings](../../../libraries/libbladeRF_bindings/python)
must be installed on the host sytem.

View file

@ -0,0 +1,89 @@
###############################################################################
# Python ConfigParser (.ini) configuration file
###############################################################################
# -----------------------------------------------------------------------------
# Common configuration options
# -----------------------------------------------------------------------------
[common]
# Verbosity levels:
# silent, critical, error, warning, info, debug, verbose
libbladerf_verbosity = WARNING
# -----------------------------------------------------------------------------
# bladeRF1 FPGAs
# -----------------------------------------------------------------------------
[bladerf1-load-fpga]
enable = False
image_40kle = ./hostedx40.rbf
image_150kle = ./hostedx115.rbf
# -----------------------------------------------------------------------------
# bladeRF2 FPGAs
# -----------------------------------------------------------------------------
[bladerf2-load-fpga]
enable = False
image_49kle = ./hostedxA4.rbf
image_301kle = ./hostedxA9.rbf
[bladerf2-tx]
enable = False
tx_channel = 0
tx_frequency = 2.350e9
tx_bandwidth = 56.0e6
tx_samplerate = 61.44e6
tx_gain = 30
tx_repeats = 10e6
tx_file = ./tx.bin
[bladerf2-rx]
enable = False
rx_channel = 0
rx_frequency = 2.325e9
rx_bandwidth = 56.0e6
rx_samplerate = 61.44e6
rx_gain = 0
rx_num_samples = 1e6
rx_file = ./rx.bin
[bladerf2-txrx]
enable = True
# tx_channel and rx_channel lists must be equal lengths because each value
# in tx_channel will be matched up with the value at the same index in
# rx_channel. For example, let tx_channel = [x, y] and rx_channel = [p, q].
# During the first iteration, tx_channel will be 'x' and rx_channel will
# be 'p'. On the next iteration, they will be 'y' and 'q', respectively.
tx_channel = 0, 1
rx_channel = 0, 1
# Frequency list. TX and RX must be equal lengths and follows the
# same pattern as above.
tx_frequency = 1535e6, 4500e6
rx_frequency = 1537e6, 4502e6
# TX settings
tx_bandwidth = 56.0e6
tx_samplerate = 61.44e6
tx_gain = 30
tx_repeats = 0
tx_file = /dev/urandom
# RX settings
rx_bandwidth = 56.0e6
rx_samplerate = 61.44e6
rx_gain = 0
rx_gainmode = manual
rx_num_samples = 25e6
# Filename for receive samples may be either explicitly given, or 'auto'. If
# explicitly given, all samples will be concatenated into the one file. If
# 'auto', the filename will be generated automatically based on the enabled
# channels and frequency (e.g. rx_r0t0_2500M.bin).
rx_file = auto

493
host/examples/python/txrx/txrx.py Executable file
View file

@ -0,0 +1,493 @@
#!/bin/env python3
###############################################################################
#
# Copyright (c) 2018-present Nuand LLC
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
###############################################################################
#
# Basic example of using bladeRF Python bindings for full duplex TX/RX.
# Review the companion txrx.ini to adjust configuration options.
#
###############################################################################
import sys
import os
import threading
from multiprocessing.pool import ThreadPool
from configparser import ConfigParser
from bladerf import _bladerf
# =============================================================================
# Close the device and exit
# =============================================================================
def shutdown( error = 0, board = None ):
print( "Shutting down with error code: " + str(error) )
if( board != None ):
board.close()
sys.exit(error)
# =============================================================================
# Version information
# =============================================================================
def print_versions( device = None ):
print( "libbladeRF version: " + str(_bladerf.version()) )
if( device != None ):
try:
print( "Firmware version: " + str(device.get_fw_version()) )
except:
print( "Firmware version: " + "ERROR" )
raise
try:
print( "FPGA version: " + str(device.get_fpga_version()) )
except:
print( "FPGA version: " + "ERROR" )
raise
return 0
# =============================================================================
# Search for a bladeRF device attached to the host system
# Returns a bladeRF device handle.
# =============================================================================
def probe_bladerf():
device = None
print( "Searching for bladeRF devices..." )
try:
devinfos = _bladerf.get_device_list()
if( len(devinfos) == 1 ):
device = "{backend}:device={usb_bus}:{usb_addr}".format(**devinfos[0]._asdict())
print( "Found bladeRF device: " + str(device) )
if( len(devinfos) > 1 ):
print( "Unsupported feature: more than one bladeRFs detected." )
print( "\n".join([str(devinfo) for devinfo in devinfos]) )
shutdown( error = -1, board = None )
except _bladerf.BladeRFError:
print( "No bladeRF devices found." )
pass
return device
# =============================================================================
# Load FPGA
# =============================================================================
def load_fpga( device, image ):
image = os.path.abspath( image )
if( not os.path.exists(image) ):
print( "FPGA image does not exist: " + str(image) )
return -1
try:
print( "Loading FPGA image: " + str(image ) )
device.load_fpga( image )
fpga_loaded = device.is_fpga_configured()
fpga_version = device.get_fpga_version()
if( fpga_loaded ):
print( "FPGA successfully loaded. Version: " + str(fpga_version) )
except _bladerf.BladeRFError:
print( "Error loading FPGA." )
raise
return 0
# =============================================================================
# TRANSMIT
# =============================================================================
def transmit( device, channel : int, freq : int, rate : int, gain : int,
tx_start = None, rx_done = None,
txfile : str = '', repeat : int = 1, ):
if( device == None ):
print( "TX: Invalid device handle." )
return -1
if( channel == None ):
print( "TX: Invalid channel." )
return -1
if( (rx_done == None) and (repeat < 1) ):
print( "TX: Configuration settings indicate transmitting indefinitely?" )
return -1
if( tx_start != None ):
print( "TX: waiting until receive thread is ready..." )
if( not tx_start.wait(60.0) ):
print( "TX: Timeout occurred while waiting for receiver to " +
"become ready." )
return -1
# Configure bladeRF
ch = device.Channel(channel)
ch.frequency = freq
ch.sample_rate = rate
ch.gain = gain
# Setup stream
device.sync_config(layout=_bladerf.ChannelLayout.TX_X1,
fmt=_bladerf.Format.SC16_Q11,
num_buffers=16,
buffer_size=8192,
num_transfers=8,
stream_timeout=3500)
# Enable module
print( "TX: Start" )
ch.enable = True
# Create buffer
bytes_per_sample = 4
buf = bytearray(1024*bytes_per_sample)
with open(txfile, 'rb') as infile:
# Read samples from file into buf
num = infile.readinto(buf)
# Convert number of bytes read to samples
num //= bytes_per_sample
if( num > 0 ):
repeats_remaining = repeat - 1
repeat_inf = (repeat < 1)
while True:
# Write to bladeRF
device.sync_tx(buf, num)
if( (rx_done != None) and rx_done.is_set() ):
break
if( not repeat_inf ):
if( repeats_remaining > 0 ):
repeats_remaining -= 1
else:
break
# Disable module
print( "TX: Stop" )
ch.enable = False
return 0
# =============================================================================
# RECEIVE
# =============================================================================
def receive(device, channel : int, freq : int, rate : int, gain : int,
tx_start = None, rx_done = None,
rxfile : str = '', num_samples : int = 1024):
status = 0
if( device == None ):
print( "RX: Invalid device handle." )
return -1
if( channel == None ):
print( "RX: Invalid channel." )
return -1
# Configure BladeRF
ch = device.Channel(channel)
ch.frequency = freq
ch.sample_rate = rate
ch.gain = gain
# Setup synchronous stream
device.sync_config(layout = _bladerf.ChannelLayout.RX_X1,
fmt = _bladerf.Format.SC16_Q11,
num_buffers = 16,
buffer_size = 8192,
num_transfers = 8,
stream_timeout = 3500)
# Enable module
print( "RX: Start" )
ch.enable = True
# Create receive buffer
bytes_per_sample = 4
buf = bytearray(1024*bytes_per_sample)
num_samples_read = 0
# Tell TX thread to begin
if( tx_start != None ):
tx_start.set()
# Save the samples
with open(rxfile, 'wb') as outfile:
while True:
if num_samples > 0 and num_samples_read == num_samples:
break
elif num_samples > 0:
num = min(len(buf)//bytes_per_sample,
num_samples-num_samples_read)
else:
num = len(buf)//bytes_per_sample
# Read into buffer
device.sync_rx(buf, num)
num_samples_read += num
# Write to file
outfile.write(buf[:num*bytes_per_sample])
# Disable module
print( "RX: Stop" )
ch.enable = False
if( rx_done != None ):
rx_done.set()
print( "RX: Done" )
return 0
# =============================================================================
# Load Configuration
# =============================================================================
config = ConfigParser()
config.read('txrx.ini')
# Set libbladeRF verbosity level
verbosity = config.get('common', 'libbladerf_verbosity').upper()
if ( verbosity == "VERBOSE" ): _bladerf.set_verbosity( 0 )
elif( verbosity == "DEBUG" ): _bladerf.set_verbosity( 1 )
elif( verbosity == "INFO" ): _bladerf.set_verbosity( 2 )
elif( verbosity == "WARNING" ): _bladerf.set_verbosity( 3 )
elif( verbosity == "ERROR" ): _bladerf.set_verbosity( 4 )
elif( verbosity == "CRITICAL" ): _bladerf.set_verbosity( 5 )
elif( verbosity == "SILENT" ): _bladerf.set_verbosity( 6 )
else:
print( "Invalid libbladerf_verbosity specified in configuration file:",
verbosity )
shutdown( error = -1, board = None )
# =============================================================================
# BEGIN !!!
# =============================================================================
uut = probe_bladerf()
if( uut == None ):
print( "No bladeRFs detected. Exiting." )
shutdown( error = -1, board = None )
b = _bladerf.BladeRF( uut )
board_name = b.board_name
fpga_size = b.fpga_size
if( config.getboolean(board_name + '-load-fpga', 'enable') ):
print( "Loading FPGA..." )
try:
status = load_fpga( b, config.get(board_name + '-load-fpga',
'image_' + str(fpga_size) + 'kle' ) )
except:
print( "ERROR loading FPGA." )
raise
if( status < 0 ):
print( "ERROR loading FPGA." )
shutdown( error = status, board = b )
else:
print( "Skipping FPGA load due to configuration setting." )
status = print_versions( device = b )
# TODO: can we have >1 rx/tx pool workers because 2x2 MIMO?
rx_pool = ThreadPool(processes=1)
tx_pool = ThreadPool(processes=1)
for s in [ss for ss in config.sections() if board_name + '-' in ss]:
if( s == board_name + "-load-fpga" ):
# Don't re-loading the FPGA!
continue
# Print the section name
print( "{:<35s} : ".format(s), end='' )
if( config.getboolean(s, 'enable') ):
print( "RUNNING" )
if( s == board_name + '-tx' ):
tx_ch = _bladerf.CHANNEL_TX(config.getint(s, 'tx_channel'))
tx_freq = int(config.getfloat(s, 'tx_frequency'))
tx_rate = int(config.getfloat(s, 'tx_samplerate'))
tx_gain = int(config.getfloat(s, 'tx_gain'))
tx_rpt = int(config.getfloat(s, 'tx_repeats'))
tx_file = config.get(s, 'tx_file')
# Make this blocking for now ...
status = tx_pool.apply_async(transmit,
(),
{ 'device' : b,
'channel' : tx_ch,
'freq' : tx_freq,
'rate' : tx_rate,
'gain' : tx_gain,
'tx_start' : None,
'rx_done' : None,
'txfile' : tx_file,
'repeat' : tx_rpt
}).get()
if( status < 0 ):
print( "Transmit operation failed with error " + str(status) )
elif( s == board_name + '-rx' ):
rx_ch = _bladerf.CHANNEL_RX(config.getint(s, 'rx_channel'))
rx_freq = int(config.getfloat(s, 'rx_frequency'))
rx_rate = int(config.getfloat(s, 'rx_samplerate'))
rx_gain = int(config.getfloat(s, 'rx_gain'))
rx_ns = int(config.getfloat(s, 'rx_num_samples'))
rx_file = config.get(s, 'rx_file')
# Make this blocking for now ...
status = rx_pool.apply_async(receive,
(),
{ 'device' : b,
'channel' : rx_ch,
'freq' : rx_freq,
'rate' : rx_rate,
'gain' : rx_gain,
'tx_start' : None,
'rx_done' : None,
'rxfile' : rx_file,
'num_samples' : rx_ns
}).get()
if( status < 0 ):
print( "Receive operation failed with error " + str(status) )
elif( s == board_name + '-txrx' ):
rx_channels = [x.strip() for x in config.get(s, 'rx_channel').split(',')]
tx_channels = [x.strip() for x in config.get(s, 'tx_channel').split(',')]
rx_freqs = [x.strip() for x in config.get(s, 'rx_frequency').split(',')]
tx_freqs = [x.strip() for x in config.get(s, 'tx_frequency').split(',')]
if( len(rx_channels) != len(tx_channels) ):
print( "Configuration error in section " + s + ": "
"rx_channels and tx_channels must be the same length." )
shutdown( error = -1, board = b )
if( len(rx_freqs) != len(tx_freqs) ):
print( "Configuration error in section " + s + ": "
"rx_frequency and tx_frequency must be the same length." )
shutdown( error = -1, board = b )
# Create Events for signaling between RX/TX threads
rx_done = threading.Event()
tx_start = threading.Event()
for ch in range(0, len(rx_channels), 1):
for freq in range(0, len(rx_freqs), 1):
rx_ch = _bladerf.CHANNEL_RX(int(rx_channels[ch]))
rx_freq = int(float(rx_freqs[freq]))
rx_rate = int(config.getfloat(s, 'rx_samplerate'))
rx_gain = int(config.getfloat(s, 'rx_gain'))
rx_ns = int(config.getfloat(s, 'rx_num_samples'))
rx_file = config.get(s, 'rx_file')
if( rx_file == "auto" ):
rx_file = "rx_" + \
"r" + rx_channels[ch] + \
"t" + tx_channels[ch] + "_" + \
str(int(float(rx_freqs[freq])/(1e6))) + "M.bin"
tx_ch = _bladerf.CHANNEL_TX(int(tx_channels[ch]))
tx_freq = int(float(tx_freqs[freq]))
tx_rate = int(config.getfloat(s, 'tx_samplerate'))
tx_gain = int(config.getfloat(s, 'tx_gain'))
tx_rpt = int(config.getfloat(s, 'tx_repeats'))
tx_file = config.get(s, 'tx_file')
print( "rx_ch = {:2d} ".format(int(rx_channels[ch])) +
"tx_ch = {:2d} ".format(int(tx_channels[ch])) +
"rx_freq = {:10d} ".format(rx_freq) +
"tx_freq = {:10d} ".format(tx_freq) +
"rx_file = " + rx_file )
# Start receiver thread
rx_result = rx_pool.apply_async(receive,
(),
{ 'device' : b,
'channel' : rx_ch,
'freq' : rx_freq,
'rate' : rx_rate,
'gain' : rx_gain,
'tx_start' : tx_start,
'rx_done' : rx_done,
'rxfile' : rx_file,
'num_samples' : rx_ns
})
# Start transmitter thread
tx_result = tx_pool.apply_async(transmit,
(),
{ 'device' : b,
'channel' : tx_ch,
'freq' : tx_freq,
'rate' : tx_rate,
'gain' : tx_gain,
'tx_start' : tx_start,
'rx_done' : rx_done,
'txfile' : tx_file,
'repeat' : tx_rpt
})
# Wait for RX thread to finish
rx_result.wait()
status = rx_result.get()
if( status < 0 ):
print( "Receive operation failed with error " +
str(status) )
# Wait for TX thread to finish
tx_result.wait()
status = tx_result.get()
if( status < 0 ):
print( "Transmit operation failed with error " +
str(status) )
tx_start.clear()
rx_done.clear()
else:
print( "SKIPPED [ Disabled ]" )
b.close()
print( "Done!" )