bladeRF/host/libraries/libbladeRF_bindings/python/bladerf/_bladerf.py
Brian Glod 84ea9784ec host: libbladeRF: Rename clock select option
The bladeRF-micro has an option to use either its onboard VCTCXO or an
external 38.4 MHz clock as the clock source for components on the
board. This change addresses some ambiguity in the naming of the onboard
option by renaming it from 'vctcxo' to 'onboard'.

The valid options are now:

1. onboard
2. external
2018-08-23 23:29:56 -04:00

1232 lines
38 KiB
Python

# Copyright (c) 2013-2018 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.
import enum
import collections
import cffi
from ._cdef import header
ffi = cffi.FFI()
ffi.cdef(header)
libbladeRF = ffi.dlopen("libbladeRF.so")
###############################################################################
# Python class wrappers for various structures
class ReturnCode(enum.Enum):
BladeRFError = 0
UnexpectedError = -1
RangeError = -2
InvalError = -3
MemError = -4
IOError = -5
TimeoutError = -6
NoDevError = -7
UnsupportedError = -8
MisalignedError = -9
ChecksumError = -10
NoFileError = -11
UpdateFPGAError = -12
UpdateFWError = -13
TimePastError = -14
QueueFullError = -15
FPGAOpError = -16
PermissionError = -17
WouldBlockError = -18
NotInitError = -19
def __str__(self):
return self.name
class Version(collections.namedtuple("Version", [
"major", "minor", "patch", "describe"])):
@staticmethod
def from_struct(version):
return Version(version.major, version.minor, version.patch,
ffi.string(version.describe).decode())
def __str__(self):
return "v{}.{}.{} (\"{}\")".format(*self)
class RationalRate(collections.namedtuple("RationalRate", [
"integer", "num", "den"])):
@staticmethod
def from_struct(rate):
return RationalRate(rate.integer, rate.num, rate.den)
def to_struct(self):
return ffi.new("struct bladerf_rational_rate *", [
self.integer, self.num, self.den])
struct = property(to_struct)
class Backend(enum.Enum):
Any = libbladeRF.BLADERF_BACKEND_ANY
Linux = libbladeRF.BLADERF_BACKEND_LINUX
LibUSB = libbladeRF.BLADERF_BACKEND_LIBUSB
Cypress = libbladeRF.BLADERF_BACKEND_CYPRESS
Dummy = libbladeRF.BLADERF_BACKEND_DUMMY
def __str__(self):
return ffi.string(libbladeRF.bladerf_backend_str(self.value)).decode()
class DevInfo(collections.namedtuple("DevInfo", [
"backend", "serial", "usb_bus", "usb_addr", "instance"])):
@staticmethod
def from_struct(devinfo):
return DevInfo(Backend(devinfo.backend),
bytes(ffi.string(devinfo.serial)),
devinfo.usb_bus,
devinfo.usb_addr,
devinfo.instance)
def to_struct(self):
return ffi.new("struct bladerf_devinfo *", [
Backend(self.backend).value, self.serial, self.usb_bus,
self.usb_addr, self.instance])
struct = property(to_struct)
@property
def devstr(self):
d = self._asdict()
d['serial'] = self.serial_str
return ("{backend}:device={usb_bus}:{usb_addr} instance={instance}"
" serial={serial}".format(**d))
@property
def serial_str(self):
return self.serial.decode()
def __str__(self):
return ("Device Information\n" +
" backend {}\n".format(self.backend) +
" serial {}\n".format(self.serial_str) +
" usb_bus {}\n".format(self.usb_bus) +
" usb_addr {}\n".format(self.usb_addr) +
" instance {}".format(self.instance))
def __repr__(self):
return '<DevInfo({})>'.format(self.devstr)
class Range(collections.namedtuple("Range", ["min", "max", "step", "scale"])):
@staticmethod
def from_struct(_range):
return Range(_range.min, _range.max, _range.step, _range.scale)
def __str__(self):
return ("Range\n" +
" min {}\n".format(self.min) +
" max {}\n".format(self.max) +
" step {}\n".format(self.step) +
" scale {}\n".format(self.scale))
def __repr__(self):
return '<Range(min={min},max={max},step={step},scale={scale})>'.format(
**self._asdict())
class DeviceSpeed(enum.Enum):
Unknown = libbladeRF.BLADERF_DEVICE_SPEED_UNKNOWN
High = libbladeRF.BLADERF_DEVICE_SPEED_HIGH
Super = libbladeRF.BLADERF_DEVICE_SPEED_SUPER
class GainMode(enum.Enum):
Default = libbladeRF.BLADERF_GAIN_DEFAULT
Manual = libbladeRF.BLADERF_GAIN_MGC
FastAttack_AGC = libbladeRF.BLADERF_GAIN_FASTATTACK_AGC
SlowAttack_AGC = libbladeRF.BLADERF_GAIN_SLOWATTACK_AGC
Hybrid_AGC = libbladeRF.BLADERF_GAIN_HYBRID_AGC
def __str__(self):
return self.name
def __int__(self):
return self.value
class Direction(enum.Enum):
TX = libbladeRF.BLADERF_TX
RX = libbladeRF.BLADERF_RX
class ChannelLayout(enum.Enum):
RX_X1 = libbladeRF.BLADERF_RX_X1
TX_X1 = libbladeRF.BLADERF_TX_X1
RX_X2 = libbladeRF.BLADERF_RX_X2
TX_X2 = libbladeRF.BLADERF_TX_X2
class Correction(enum.Enum):
DCOFF_I = libbladeRF.BLADERF_CORR_DCOFF_I
DCOFF_Q = libbladeRF.BLADERF_CORR_DCOFF_Q
PHASE = libbladeRF.BLADERF_CORR_PHASE
GAIN = libbladeRF.BLADERF_CORR_GAIN
class Format(enum.Enum):
SC16_Q11 = libbladeRF.BLADERF_FORMAT_SC16_Q11
SC16_Q11_META = libbladeRF.BLADERF_FORMAT_SC16_Q11_META
class Loopback(enum.Enum):
Disabled = libbladeRF.BLADERF_LB_NONE
Firmware = libbladeRF.BLADERF_LB_FIRMWARE
BB_TXLPF_RXVGA2 = libbladeRF.BLADERF_LB_BB_TXLPF_RXVGA2
BB_TXVGA1_RXVGA2 = libbladeRF.BLADERF_LB_BB_TXVGA1_RXVGA2
BB_TXLPF_RXLPF = libbladeRF.BLADERF_LB_BB_TXLPF_RXLPF
BB_TXVGA1_RXLPF = libbladeRF.BLADERF_LB_BB_TXVGA1_RXLPF
RF_LNA1 = libbladeRF.BLADERF_LB_RF_LNA1
RF_LNA2 = libbladeRF.BLADERF_LB_RF_LNA2
RF_LNA3 = libbladeRF.BLADERF_LB_RF_LNA3
RFIC_BIST = libbladeRF.BLADERF_LB_RFIC_BIST
def __str__(self):
return self.name
class RXMux(enum.Enum):
Invalid = libbladeRF.BLADERF_RX_MUX_INVALID
Baseband = libbladeRF.BLADERF_RX_MUX_BASEBAND
Counter_12bit = libbladeRF.BLADERF_RX_MUX_12BIT_COUNTER
Counter_32bit = libbladeRF.BLADERF_RX_MUX_32BIT_COUNTER
Digital_Loopback = libbladeRF.BLADERF_RX_MUX_DIGITAL_LOOPBACK
def __str__(self):
return self.name
class ClockSelect(enum.Enum):
Unknown = -99
VCTCXO = libbladeRF.CLOCK_SELECT_ONBOARD
External = libbladeRF.CLOCK_SELECT_EXTERNAL
def __str__(self):
return self.name
class RSSI(collections.namedtuple("RSSI", ["preamble", "symbol"])):
def __str__(self):
return ("RSSI\n" +
" preamble {preamble} dB\n" +
" symbol {symbol} dB\n").format(**self._asdict())
def __repr__(self):
return ("<RSSI(preamble={preamble}," +
"symbol={symbol})>").format(**self._asdict())
class PowerSource(enum.Enum):
Unknown = libbladeRF.BLADERF_UNKNOWN
DC_Barrel = libbladeRF.BLADERF_PS_DC
USB_VBUS = libbladeRF.BLADERF_PS_USB_VBUS
def __str__(self):
return self.name
class PMICRegister(enum.Enum):
Configuration = libbladeRF.BLADERF_PMIC_CONFIGURATION
Voltage_shunt = libbladeRF.BLADERF_PMIC_VOLTAGE_SHUNT
Voltage_bus = libbladeRF.BLADERF_PMIC_VOLTAGE_BUS
Power = libbladeRF.BLADERF_PMIC_POWER
Current = libbladeRF.BLADERF_PMIC_CURRENT
Calibration = libbladeRF.BLADERF_PMIC_CALIBRATION
@property
def ctype(self):
"""C type definition for the pointer to the returned value."""
if self in [self.Configuration, self.Calibration]:
return "uint16_t *"
else:
return "float *"
###############################################################################
class BladeRFError(Exception):
"""A general libbladeRF exception occurred"""
def __init__(self, code=0, msg=None):
if isinstance(code, str):
# SubclassedError("user message")
msg = code
code = 0
if code == 0:
i_am = self.__class__.__name__
code = getattr(ReturnCode, i_am).value
self.errstr = ffi.string(libbladeRF.bladerf_strerror(code)).decode()
if msg is not None:
self.errstr += " (" + msg + ")"
def __str__(self):
return self.errstr
class UnexpectedError(BladeRFError):
"""An unexpected failure occurred"""
class RangeError(BladeRFError):
"""Provided parameter is out of range"""
class InvalError(BladeRFError):
"""Invalid operation/parameter"""
class MemError(BladeRFError):
"""Memory allocation error"""
class IOError(BladeRFError):
"""File/Device I/O error"""
class TimeoutError(BladeRFError):
"""Operation timed out"""
class NoDevError(BladeRFError):
"""No device(s) available"""
class UnsupportedError(BladeRFError):
"""Operation not supported"""
class MisalignedError(BladeRFError):
"""Misaligned flash access"""
class ChecksumError(BladeRFError):
"""Invalid checksum"""
class NoFileError(BladeRFError):
"""File not found"""
class UpdateFPGAError(BladeRFError):
"""An FPGA update is required"""
class UpdateFWError(BladeRFError):
"""A firmware update is required"""
class TimePastError(BladeRFError):
"""Requested timestamp is in the past"""
class QueueFullError(BladeRFError):
"""Could not enqueue data into full queue"""
class FPGAOpError(BladeRFError):
"""An FPGA operation reported failure"""
class PermissionError(BladeRFError):
"""Insufficient permissions for the requested operation"""
class WouldBlockError(BladeRFError):
"""Operation would block, but has been requested to be non-blocking."""
class NotInitError(BladeRFError):
"""Device insufficiently initialized for operation"""
def _check_error(err):
"""If the result code indicates an error, raise an exception"""
if err < 0:
try:
errorval = ReturnCode(err)
except ValueError:
errorval = ReturnCode(0)
raise globals()[errorval.name](err)
###############################################################################
def set_verbosity(level):
libbladeRF.bladerf_log_set_verbosity(level)
def version():
version = ffi.new("struct bladerf_version *")
libbladeRF.bladerf_version(version)
return Version.from_struct(version)
def get_device_list():
devices = ffi.new("struct bladerf_devinfo *[1]")
ret = libbladeRF.bladerf_get_device_list(devices)
_check_error(ret)
devinfos = [DevInfo.from_struct(devices[0][i]) for i in range(ret)]
libbladeRF.bladerf_free_device_list(devices[0])
return devinfos
def get_bootloader_list():
devices = ffi.new("struct bladerf_devinfo *[1]")
ret = libbladeRF.bladerf_get_bootloader_list(devices)
_check_error(ret)
devinfos = [DevInfo.from_struct(devices[0][i]) for i in range(ret)]
libbladeRF.bladerf_free_device_list(devices[0])
return devinfos
def load_fw_from_bootloader(device_identifier=None, backend=0, bus=0, addr=0,
file=None):
ret = libbladeRF.bladerf_load_fw_from_bootloader(
device_identifier.encode(), backend, bus, addr, file.encode())
_check_error(ret)
###############################################################################
RX = 0x0
TX = 0x1
def CHANNEL_RX(ch):
return (ch << 1) | RX
def CHANNEL_TX(ch):
return (ch << 1) | TX
# defaults for PLL on bladeRF 2
BLADERF_VCTCXO_FREQUENCY = 38.4e6
BLADERF_REFIN_DEFAULT = 10.0e6
BLADERF_SERIAL_LENGTH = 33
###############################################################################
class BladeRF:
"""Python class for interacting with bladeRF boards.
Example usage:
>>> d = bladerf.BladeRF()
>>> d.board_name
'bladerf1'
"""
def __init__(self, device_identifier=None, devinfo=None):
self.dev = ffi.new("struct bladerf *[1]")
self.open(device_identifier, devinfo)
def __repr__(self):
return '<BladeRF({!r})>'.format(self.devinfo)
# Open, close, devinfo
def open(self, device_identifier=None, devinfo=None):
if devinfo is not None:
ret = libbladeRF.bladerf_open_with_devinfo(self.dev,
devinfo.struct)
elif device_identifier is not None:
ret = libbladeRF.bladerf_open(self.dev, device_identifier.encode())
else:
ret = libbladeRF.bladerf_open(self.dev, ffi.NULL)
_check_error(ret)
def close(self):
libbladeRF.bladerf_close(self.dev[0])
def get_devinfo(self):
devinfo = ffi.new("struct bladerf_devinfo *")
ret = libbladeRF.bladerf_get_devinfo(self.dev[0], devinfo)
_check_error(ret)
return DevInfo.from_struct(devinfo)
devinfo = property(get_devinfo,
doc="Device information as a DevInfo structure")
# Device properties
def get_device_speed(self):
return DeviceSpeed(libbladeRF.bladerf_device_speed(self.dev[0]))
device_speed = property(get_device_speed,
doc="USB speed of the open device")
def get_serial(self):
serial = ffi.new("char []", BLADERF_SERIAL_LENGTH)
ret = libbladeRF.bladerf_get_serial(self.dev[0], serial)
_check_error(ret)
return ffi.string(serial).decode()
serial = property(get_serial, doc="Serial number of the open device")
def get_fpga_size(self):
fpga_size = ffi.new("bladerf_fpga_size *")
ret = libbladeRF.bladerf_get_fpga_size(self.dev[0], fpga_size)
_check_error(ret)
return fpga_size[0]
fpga_size = property(get_fpga_size, doc="FPGA size in kLE")
def is_fpga_configured(self):
ret = libbladeRF.bladerf_is_fpga_configured(self.dev[0])
_check_error(ret)
return bool(ret)
fpga_configured = property(is_fpga_configured,
doc="True if the device's FPGA is configured")
def get_fpga_version(self):
version = ffi.new("struct bladerf_version *")
ret = libbladeRF.bladerf_fpga_version(self.dev[0], version)
_check_error(ret)
return Version.from_struct(version)
fpga_version = property(get_fpga_version, doc="FPGA version information")
def get_fw_version(self):
version = ffi.new("struct bladerf_version *")
ret = libbladeRF.bladerf_fw_version(self.dev[0], version)
_check_error(ret)
return Version.from_struct(version)
fw_version = property(get_fw_version, doc="Firmware version information")
def get_board_name(self):
board_name = libbladeRF.bladerf_get_board_name(self.dev[0])
return ffi.string(board_name).decode()
board_name = property(get_board_name,
doc="The board model name, as a string")
def trim_dac_write(self, val):
libbladeRF.bladerf_trim_dac_write(self.dev[0], val)
def trim_dac_read(self):
try:
trim_val = ffi.new("uint16_t *")
ret = libbladeRF.bladerf_trim_dac_read(self.dev[0], trim_val)
_check_error(ret)
return trim_val[0]
except UnsupportedError:
return None
def get_channel_count(self, direction):
return libbladeRF.bladerf_get_channel_count(self.dev[0], direction)
@property
def rx_channel_count(self):
"""Number of RX channels on the device"""
return self.get_channel_count(BLADERF_RX)
@property
def tx_channel_count(self):
"""Number of TX channels on the device"""
return self.get_channel_count(BLADERF_TX)
# Enable/Disable
def enable_module(self, ch, enable):
ret = libbladeRF.bladerf_enable_module(self.dev[0], ch, bool(enable))
_check_error(ret)
# Gain
def set_gain(self, ch, gain):
ret = libbladeRF.bladerf_set_gain(self.dev[0], ch, gain)
_check_error(ret)
def get_gain(self, ch):
gain = ffi.new("bladerf_gain *")
ret = libbladeRF.bladerf_get_gain(self.dev[0], ch, gain)
_check_error(ret)
return gain[0]
def set_gain_mode(self, ch, mode):
ret = libbladeRF.bladerf_set_gain_mode(self.dev[0], ch, int(mode))
_check_error(ret)
def get_gain_mode(self, ch):
try:
mode = ffi.new("bladerf_gain_mode *")
ret = libbladeRF.bladerf_get_gain_mode(self.dev[0], ch, mode)
_check_error(ret)
return GainMode(mode[0])
except UnsupportedError:
return None
def get_gain_modes(self, ch):
ret = libbladeRF.bladerf_get_gain_modes(self.dev[0], ch, ffi.NULL)
_check_error(ret)
modes_arr = ffi.new("struct bladerf_gain_modes *[]", ret)
ret = libbladeRF.bladerf_get_gain_modes(self.dev[0], ch, modes_arr)
_check_error(ret)
return [GainMode(modes_arr[0][i].mode) for i in range(ret)]
def get_gain_range(self, ch):
_range = ffi.new("struct bladerf_range *")
_range_ptr = ffi.new("struct bladerf_range **", _range)
ret = libbladeRF.bladerf_get_gain_range(self.dev[0], ch, _range_ptr)
_check_error(ret)
return Range.from_struct(_range)
def set_gain_stage(self, ch, stage, gain):
ret = libbladeRF.bladerf_set_gain_stage(self.dev[0], ch,
stage.encode(), gain)
_check_error(ret)
def get_gain_stage(self, ch, stage):
gain = ffi.new("bladerf_gain *")
ret = libbladeRF.bladerf_get_gain_stage(self.dev[0], ch,
stage.encode(), gain)
_check_error(ret)
return gain[0]
def get_gain_stage_range(self, ch, stage):
_range = ffi.new("struct bladerf_range *")
_range_ptr = ffi.new("struct bladerf_range **", _range)
ret = libbladeRF.bladerf_get_gain_stage_range(self.dev[0], ch,
stage.encode(),
_range_ptr)
_check_error(ret)
return Range.from_struct(_range)
def get_gain_stages(self, ch):
ret = libbladeRF.bladerf_get_gain_stages(self.dev[0], ch, ffi.NULL, 0)
_check_error(ret)
stages_arr = ffi.new("const char *[]", ret)
ret = libbladeRF.bladerf_get_gain_stages(self.dev[0], ch, stages_arr,
ret)
_check_error(ret)
return [ffi.string(stages_arr[i]).decode() for i in range(ret)]
# Sample rate
def set_sample_rate(self, ch, rate):
actual_rate = ffi.new("bladerf_sample_rate *")
ret = libbladeRF.bladerf_set_sample_rate(self.dev[0], ch, int(rate),
actual_rate)
_check_error(ret)
return actual_rate[0]
def set_rational_sample_rate(self, ch, rational_rate):
raise NotImplementedError()
def get_sample_rate(self, ch):
rate = ffi.new("bladerf_sample_rate *")
ret = libbladeRF.bladerf_get_sample_rate(self.dev[0], ch, rate)
_check_error(ret)
return rate[0]
def get_rational_sample_rate(self, ch):
raise NotImplementedError()
def get_sample_rate_range(self, ch):
_range = ffi.new("struct bladerf_range *")
_range_ptr = ffi.new("struct bladerf_range **", _range)
ret = libbladeRF.bladerf_get_sample_rate_range(self.dev[0], ch,
_range_ptr)
_check_error(ret)
return Range.from_struct(_range)
# Bandwidth
def set_bandwidth(self, ch, bandwidth):
actual_bandwidth = ffi.new("bladerf_bandwidth *")
ret = libbladeRF.bladerf_set_bandwidth(self.dev[0], ch, int(bandwidth),
actual_bandwidth)
_check_error(ret)
return actual_bandwidth[0]
def get_bandwidth(self, ch):
bandwidth = ffi.new("bladerf_bandwidth *")
ret = libbladeRF.bladerf_get_bandwidth(self.dev[0], ch, bandwidth)
_check_error(ret)
return bandwidth[0]
def get_bandwidth_range(self, ch):
_range = ffi.new("struct bladerf_range *")
_range_ptr = ffi.new("struct bladerf_range **", _range)
ret = libbladeRF.bladerf_get_bandwidth_range(self.dev[0], ch,
_range_ptr)
_check_error(ret)
return Range.from_struct(_range)
# Frequency
def set_frequency(self, ch, frequency):
ret = libbladeRF.bladerf_set_frequency(self.dev[0], ch, int(frequency))
_check_error(ret)
def get_frequency(self, ch):
frequency = ffi.new("bladerf_frequency *")
ret = libbladeRF.bladerf_get_frequency(self.dev[0], ch, frequency)
_check_error(ret)
return frequency[0]
def select_band(self, ch, frequency):
ret = libbladeRF.bladerf_select_band(self.dev[0], ch, int(frequency))
_check_error(ret)
def get_frequency_range(self, ch):
_range = ffi.new("struct bladerf_range *")
_range_ptr = ffi.new("struct bladerf_range **", _range)
ret = libbladeRF.bladerf_get_frequency_range(self.dev[0], ch,
_range_ptr)
_check_error(ret)
return Range.from_struct(_range)
# RF Ports
def set_rf_port(self, ch, port):
ret = libbladeRF.bladerf_set_rf_port(self.dev[0], ch, port.encode())
_check_error(ret)
def get_rf_port(self, ch):
try:
port = ffi.new("const char *[1]")
ret = libbladeRF.bladerf_get_rf_port(self.dev[0], ch, port)
_check_error(ret)
return ffi.string(port[0]).decode()
except UnsupportedError:
return None
def get_rf_ports(self, ch):
try:
count = libbladeRF.bladerf_get_rf_ports(self.dev[0], ch, ffi.NULL,
0)
_check_error(count)
ports_arr = ffi.new("const char *[]", count)
ret = libbladeRF.bladerf_get_rf_ports(self.dev[0], ch, ports_arr,
count)
_check_error(ret)
return [ffi.string(ports_arr[i]).decode() for i in range(ret)]
except UnsupportedError:
return []
# Sample Loopback
def get_loopback_modes(self):
ret = libbladeRF.bladerf_get_loopback_modes(self.dev[0], ffi.NULL)
_check_error(ret)
modes_arr = ffi.new("struct bladerf_loopback_modes *[]", ret)
ret = libbladeRF.bladerf_get_loopback_modes(self.dev[0], modes_arr)
_check_error(ret)
return [Loopback(modes_arr[0][i].mode) for i in range(ret)]
loopback_modes = property(get_loopback_modes,
doc="Supported loopback modes")
def is_loopback_mode_supported(self, lb):
if isinstance(lb, Loopback):
lb = lb.value
ret = libbladeRF.bladerf_is_loopback_mode_supported(self.dev[0], lb)
_check_error(ret)
return bool(ret)
def get_loopback(self):
lb = ffi.new("bladerf_loopback *")
ret = libbladeRF.bladerf_get_loopback(self.dev[0], lb)
_check_error(ret)
return Loopback(lb[0])
def set_loopback(self, lb):
if isinstance(lb, Loopback):
lb = lb.value
ret = libbladeRF.bladerf_set_loopback(self.dev[0], lb)
_check_error(ret)
loopback = property(get_loopback, set_loopback, doc="Loopback selection")
# Trigger TBD
# Sample RX Mux
def get_rx_mux(self):
mux = ffi.new("bladerf_rx_mux *")
ret = libbladeRF.bladerf_get_rx_mux(self.dev[0], mux)
_check_error(ret)
return RXMux(mux[0])
def set_rx_mux(self, rx_mux):
if isinstance(rx_mux, RXMux):
rx_mux = rx_mux.value
ret = libbladeRF.bladerf_set_rx_mux(self.dev[0], rx_mux)
_check_error(ret)
rx_mux = property(get_rx_mux, set_rx_mux, doc="RX Multiplexer selection")
# DC/Phase/Gain Correction
def get_correction(self, ch, corr):
value = ffi.new("bladerf_correction_value *")
ret = libbladeRF.bladerf_get_correction(self.dev[0], ch, corr.value,
value)
_check_error(ret)
return value[0]
def set_correction(self, ch, corr, value):
ret = libbladeRF.bladerf_set_correction(self.dev[0], ch, corr.value,
value)
_check_error(ret)
# Streaming format
def interleave_stream_buffer(self, layout, format, buffer_size, samples):
raise NotImplementedError()
def deinterleave_stream_buffer(self, layout, format, buffer_size, samples):
raise NotImplementedError()
# Streaming
def sync_config(self, layout, fmt, num_buffers, buffer_size, num_transfers,
stream_timeout):
if fmt != Format.SC16_Q11:
raise NotImplementedError("Format not supported by binding.")
ret = libbladeRF.bladerf_sync_config(self.dev[0],
layout.value,
fmt.value,
num_buffers,
buffer_size,
num_transfers,
stream_timeout)
_check_error(ret)
def sync_tx(self, buf, num_samples, timeout_ms=None):
ret = libbladeRF.bladerf_sync_tx(self.dev[0],
ffi.from_buffer(buf),
num_samples,
ffi.NULL,
timeout_ms or 0)
_check_error(ret)
def sync_rx(self, buf, num_samples, timeout_ms=None):
ret = libbladeRF.bladerf_sync_rx(self.dev[0],
ffi.from_buffer(buf),
num_samples,
ffi.NULL,
timeout_ms or 0)
_check_error(ret)
# FPGA/Firmware Loading/Flashing
def load_fpga(self, image_path):
ret = libbladeRF.bladerf_load_fpga(self.dev[0], image_path.encode())
_check_error(ret)
def flash_fpga(self, image_path):
ret = libbladeRF.bladerf_flash_fpga(self.dev[0], image_path.encode())
_check_error(ret)
def erase_stored_fpga(self):
ret = libbladeRF.bladerf_erase_stored_fpga(self.dev[0])
_check_error(ret)
def flash_firmware(self, image_path):
ret = libbladeRF.bladerf_flash_firmware(self.dev[0],
image_path.encode())
_check_error(ret)
def device_reset(self):
ret = libbladeRF.bladerf_device_reset(self.dev[0])
_check_error(ret)
# VCTCXO Tamer Mode
def set_vctcxo_tamer_mode(self, mode):
raise NotImplementedError()
def get_vctcxo_tamer_mode(self):
raise NotImplementedError()
vctcxo_tamer_mode = property(get_vctcxo_tamer_mode, set_vctcxo_tamer_mode)
def get_vctcxo_trim(self):
raise NotImplementedError()
vctcxo = property(get_vctcxo_trim)
# Tuning Mode
def set_tuning_mode(self, mode):
raise NotImplementedError()
def get_tuning_mode(self):
raise NotImplementedError()
tuning_mode = property(get_tuning_mode, set_tuning_mode)
# Bias tee
def get_bias_tee(self, ch):
try:
state = ffi.new("bool *")
ret = libbladeRF.bladerf_get_bias_tee(self.dev[0], ch, state)
_check_error(ret)
return bool(state[0])
except UnsupportedError:
return None
def set_bias_tee(self, ch, enable):
ret = libbladeRF.bladerf_set_bias_tee(self.dev[0], ch, enable)
_check_error(ret)
# RFIC
def get_rfic_temperature(self):
try:
val = ffi.new("float *")
ret = libbladeRF.bladerf_get_rfic_temperature(self.dev[0], val)
_check_error(ret)
return val[0]
except UnsupportedError:
return None
rfic_temperature = property(get_rfic_temperature,
doc="RFIC internal temperature")
def get_rfic_rssi(self, ch):
try:
preamble = ffi.new("int32_t *")
symbol = ffi.new("int32_t *")
ret = libbladeRF.bladerf_get_rfic_rssi(self.dev[0], ch,
preamble, symbol)
_check_error(ret)
return RSSI(preamble[0], symbol[0])
except UnsupportedError:
return None
def get_rfic_ctrl_out(self):
try:
ctrl_out = ffi.new("uint8_t *")
ret = libbladeRF.bladerf_get_rfic_ctrl_out(self.dev[0], ctrl_out)
_check_error(ret)
return ctrl_out[0]
except UnsupportedError:
return None
rfic_ctrl_out = property(get_rfic_ctrl_out,
doc="RFIC CTRL_OUT status pins")
# Phase Detector/Frequency Synthesizer
def get_pll_lock_state(self):
try:
locked = ffi.new("bool *")
ret = libbladeRF.bladerf_get_pll_lock_state(self.dev[0], locked)
_check_error(ret)
return bool(locked[0])
except UnsupportedError:
return None
pll_locked = property(get_pll_lock_state,
doc="PLL lock indication")
def get_pll_enable(self):
try:
enable = ffi.new("bool *")
ret = libbladeRF.bladerf_get_pll_enable(self.dev[0], enable)
_check_error(ret)
return bool(enable[0])
except UnsupportedError:
return None
def set_pll_enable(self, enable):
ret = libbladeRF.bladerf_set_pll_enable(self.dev[0], enable)
_check_error(ret)
pll_enable = property(get_pll_enable, set_pll_enable,
doc="PLL Enable")
def get_pll_refclk(self):
try:
freq = ffi.new("uint64_t *")
ret = libbladeRF.bladerf_get_pll_refclk(self.dev[0], freq)
_check_error(ret)
return int(freq[0])
except UnsupportedError:
return None
def set_pll_refclk(self, freq):
ret = libbladeRF.bladerf_set_pll_refclk(self.dev[0], freq)
_check_error(ret)
pll_refclk = property(get_pll_refclk, set_pll_refclk,
doc="PLL Reference Clock frequency")
# Power source
def get_power_source(self):
try:
val = ffi.new("bladerf_power_sources *")
ret = libbladeRF.bladerf_get_power_source(self.dev[0], val)
_check_error(ret)
return PowerSource(val[0])
except UnsupportedError:
return PowerSource.Unknown
power_source = property(get_power_source,
doc="Active power source for device")
# Clock select
def get_clock_select(self):
try:
sel = ffi.new("bladerf_clock_select *")
ret = libbladeRF.bladerf_get_clock_select(self.dev[0], sel)
_check_error(ret)
return ClockSelect(sel[0])
except UnsupportedError:
return ClockSelect.Unknown
def set_clock_select(self, sel):
if isinstance(sel, ClockSelect):
sel = sel.value
ret = libbladeRF.bladerf_set_clock_select(self.dev[0], sel)
_check_error(ret)
clock_select = property(get_clock_select, set_clock_select,
doc="System clock input selection")
# Clock output
def get_clock_output(self):
try:
state = ffi.new("bool *")
ret = libbladeRF.bladerf_get_clock_output(self.dev[0], state)
_check_error(ret)
return bool(state[0])
except UnsupportedError:
return None
def set_clock_output(self, enable):
ret = libbladeRF.bladerf_set_clock_output(self.dev[0], enable)
_check_error(ret)
clock_output = property(get_clock_output, set_clock_output,
doc="Clock output enable")
# Current/power monitor IC
def get_pmic_register(self, reg):
try:
if not isinstance(reg, PMICRegister):
reg = PMICRegister(reg)
val = ffi.new(reg.ctype)
ret = libbladeRF.bladerf_get_pmic_register(self.dev[0], reg.value, val)
_check_error(ret)
return val[0]
except UnsupportedError:
return None
@property
def bus_voltage(self):
"""Main power bus voltage, in Volts"""
return self.get_pmic_register(PMICRegister.Voltage_bus)
@property
def bus_current(self):
"""Main power bus current, in Amps"""
return self.get_pmic_register(PMICRegister.Current)
@property
def bus_power(self):
"""Main power bus power, in Watts"""
return self.get_pmic_register(PMICRegister.Power)
# Convenience objects
class _Channel:
"""Container for bladeRF channel properties"""
def __init__(self, dev, channel):
self.dev = dev
self.channel = channel
if (channel >> 1) not in range(dev.get_channel_count(self.is_tx)):
raise UnsupportedError("Invalid channel: " + str(channel))
def __str__(self):
return "Channel {}{}".format(
"TX" if self.is_tx else "RX", (self.channel >> 1) + 1)
def __repr__(self):
return '<Channel({},CHANNEL_{}({}))>'.format(
repr(self.dev), "TX" if self.is_tx else "RX",
self.channel >> 1)
@property
def is_tx(self):
"""Returns True if this is a TX channel, False otherwise"""
return bool(self.channel & TX)
@property
def gain(self):
"""Gain, in dB"""
return self.dev.get_gain(self.channel)
@gain.setter
def gain(self, value):
return self.dev.set_gain(self.channel, value)
@property
def gain_mode(self):
"""Gain mode"""
return self.dev.get_gain_mode(self.channel)
@gain_mode.setter
def gain_mode(self, value):
return self.dev.set_gain_mode(self.channel, value)
@property
def gain_modes(self):
"""List of supported gain modes"""
return self.dev.get_gain_modes(self.channel)
@property
def rssi(self):
"""RSSI report from RFIC"""
return self.dev.get_rfic_rssi(self.channel)
@property
def preamble_rssi(self):
"""Preamble RSSI reading (latched at algorithm reset)"""
if self.rssi is not None:
return self.rssi.preamble
else:
return None
@property
def symbol_rssi(self):
"""Symbol RSSI reading (most recent value)"""
if self.rssi is not None:
return self.rssi.symbol
else:
return None
@property
def sample_rate(self):
"""Sample rate, in samples/second"""
return self.dev.get_sample_rate(self.channel)
@sample_rate.setter
def sample_rate(self, value):
return self.dev.set_sample_rate(self.channel, value)
@property
def sample_rate_range(self):
"""Range of sample rates supported by this channel"""
return self.dev.get_sample_rate_range(self.channel)
@property
def bandwidth(self):
"""Channel bandwidth in Hz"""
return self.dev.get_bandwidth(self.channel)
@bandwidth.setter
def bandwidth(self, value):
return self.dev.set_bandwidth(self.channel, value)
@property
def bandwidth_range(self):
"""Range of bandwidths supported by this channel"""
return self.dev.get_bandwidth_range(self.channel)
@property
def frequency(self):
"""Frequency in Hz"""
return self.dev.get_frequency(self.channel)
@frequency.setter
def frequency(self, value):
return self.dev.set_frequency(self.channel, value)
@property
def frequency_range(self):
"""Range of frequencies supported by this channel"""
return self.dev.get_frequency_range(self.channel)
@property
def rf_port(self):
"""Active RF port"""
return self.dev.get_rf_port(self.channel)
@rf_port.setter
def rf_port(self, value):
return self.dev.set_rf_port(self.channel, value)
@property
def rf_ports(self):
"""List of available RF ports"""
return self.dev.get_rf_ports(self.channel)
@property
def bias_tee(self):
"""Bias-T control"""
return self.dev.get_bias_tee(self.channel)
@bias_tee.setter
def bias_tee(self, value):
return self.dev.set_bias_tee(self.channel, value)
def set_enable(self, value):
return self.dev.enable_module(self.channel, value)
enable = property(fset=set_enable, doc="Enable/disable RF chain")
def Channel(self, ch):
"""Returns an object for a given subchannel.
Usage:
>>> d = bladerf.BladeRF()
>>> rx = d.Channel(bladerf.CHANNEL_RX(0))
See help(bladerf.BladeRF._Channel) or help(rx) for more information.
"""
return self._Channel(self, ch)