493 lines
18 KiB
Python
Executable file
493 lines
18 KiB
Python
Executable file
#!/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!" )
|