import enum import collections import cffi ffi = cffi.FFI() ffi.cdef(""" /** This structure is an opaque device handle */ struct bladerf; typedef enum { BLADERF_BACKEND_ANY, /**< "Don't Care" -- use any available backend */ BLADERF_BACKEND_LINUX, /**< Linux kernel driver */ BLADERF_BACKEND_LIBUSB, /**< libusb */ BLADERF_BACKEND_CYPRESS, /**< CyAPI */ BLADERF_BACKEND_DUMMY = 100, /**< Dummy used for development purposes */ } bladerf_backend; /** Length of device serial number string, including NUL-terminator */ #define BLADERF_SERIAL_LENGTH 33 struct bladerf_devinfo { bladerf_backend backend; /**< Backend to use when connecting to device */ char serial[BLADERF_SERIAL_LENGTH]; /**< Device serial number string */ uint8_t usb_bus; /**< Bus # device is attached to */ uint8_t usb_addr; /**< Device address on bus */ unsigned int instance; /**< Device instance or ID */ }; int bladerf_open(struct bladerf **device, const char *device_identifier); void bladerf_close(struct bladerf *device); int bladerf_open_with_devinfo(struct bladerf **device, struct bladerf_devinfo *devinfo); int bladerf_get_device_list(struct bladerf_devinfo **devices); void bladerf_free_device_list(struct bladerf_devinfo *devices); void bladerf_init_devinfo(struct bladerf_devinfo *info); int bladerf_get_devinfo(struct bladerf *dev, struct bladerf_devinfo *info); int bladerf_get_devinfo_from_str(const char *devstr, struct bladerf_devinfo *info); bool bladerf_devinfo_matches(const struct bladerf_devinfo *a, const struct bladerf_devinfo *b); bool bladerf_devstr_matches(const char *dev_str, struct bladerf_devinfo *info); const char * bladerf_backend_str(bladerf_backend backend); void bladerf_set_usb_reset_on_open(bool enabled); struct bladerf_version { uint16_t major; /**< Major version */ uint16_t minor; /**< Minor version */ uint16_t patch; /**< Patch version */ const char *describe; /**< Version string */ }; typedef enum { BLADERF_FPGA_UNKNOWN = 0, /**< Unable to determine FPGA variant */ BLADERF_FPGA_40KLE = 40, /**< 40 kLE FPGA */ BLADERF_FPGA_115KLE = 115 /**< 115 kLE FPGA */ } bladerf_fpga_size; typedef enum { BLADERF_DEVICE_SPEED_UNKNOWN, BLADERF_DEVICE_SPEED_HIGH, BLADERF_DEVICE_SPEED_SUPER, } bladerf_dev_speed; int bladerf_get_serial(struct bladerf *dev, char *serial); int bladerf_get_fpga_size(struct bladerf *dev, bladerf_fpga_size *size); int bladerf_fw_version(struct bladerf *dev, struct bladerf_version *version); int bladerf_is_fpga_configured(struct bladerf *dev); int bladerf_fpga_version(struct bladerf *dev, struct bladerf_version *version); bladerf_dev_speed bladerf_device_speed(struct bladerf *dev); const char * bladerf_get_board_name(struct bladerf *dev); typedef int bladerf_channel; struct bladerf_range { int64_t min; /**< Minimum value */ int64_t max; /**< Maximum value */ int64_t step; /**< Step of value */ float scale; /**< Unit scale */ }; int bladerf_set_gain(struct bladerf *dev, bladerf_channel ch, int gain); int bladerf_get_gain(struct bladerf *dev, bladerf_channel ch, int *gain); int bladerf_get_gain_range(struct bladerf *dev, bladerf_channel ch, struct bladerf_range *range); int bladerf_set_gain_stage(struct bladerf *dev, bladerf_channel ch, const char *stage, int gain); int bladerf_get_gain_stage(struct bladerf *dev, bladerf_channel ch, const char *stage, int *gain); int bladerf_get_gain_stage_range(struct bladerf *dev, bladerf_channel ch, const char *stage, struct bladerf_range *range); int bladerf_get_gain_stages(struct bladerf *dev, bladerf_channel ch, const char **stages, unsigned int count); struct bladerf_rational_rate { uint64_t integer; /**< Integer portion */ uint64_t num; /**< Numerator in fractional portion */ uint64_t den; /**< Denominator in fractional portion. This must be > 0. */ }; int bladerf_set_sample_rate(struct bladerf *dev, bladerf_channel ch, unsigned int rate, unsigned int *actual); int bladerf_set_rational_sample_rate(struct bladerf *dev, bladerf_channel ch, struct bladerf_rational_rate *rate, struct bladerf_rational_rate *actual); int bladerf_get_sample_rate(struct bladerf *dev, bladerf_channel ch, unsigned int *rate); int bladerf_get_sample_rate_range(struct bladerf *dev, bladerf_channel ch, struct bladerf_range *range); int bladerf_get_rational_sample_rate(struct bladerf *dev, bladerf_channel ch, struct bladerf_rational_rate *rate); int bladerf_set_bandwidth(struct bladerf *dev, bladerf_channel ch, unsigned int bandwidth, unsigned int *actual); int bladerf_get_bandwidth(struct bladerf *dev, bladerf_channel ch, unsigned int *bandwidth); int bladerf_get_bandwidth_range(struct bladerf *dev, bladerf_channel ch, struct bladerf_range *range); int bladerf_select_band(struct bladerf *dev, bladerf_channel ch, uint64_t frequency); int bladerf_set_frequency(struct bladerf *dev, bladerf_channel ch, uint64_t frequency); int bladerf_get_frequency(struct bladerf *dev, bladerf_channel ch, uint64_t *frequency); int bladerf_get_frequency_range(struct bladerf *dev, bladerf_channel ch, struct bladerf_range *range); int bladerf_set_rf_port(struct bladerf *dev, bladerf_channel ch, const char *port); int bladerf_get_rf_port(struct bladerf *dev, bladerf_channel ch, const char **port); int bladerf_get_rf_ports(struct bladerf *dev, bladerf_channel ch, const char **ports, unsigned int count); typedef enum { BLADERF_LB_FIRMWARE = 1, BLADERF_LB_BB_TXLPF_RXVGA2, BLADERF_LB_BB_TXVGA1_RXVGA2, BLADERF_LB_BB_TXLPF_RXLPF, BLADERF_LB_BB_TXVGA1_RXLPF, BLADERF_LB_RF_LNA1, BLADERF_LB_RF_LNA2, BLADERF_LB_RF_LNA3, BLADERF_LB_NONE, BLADERF_LB_AD9361_BIST, } bladerf_loopback; int bladerf_set_loopback(struct bladerf *dev, bladerf_loopback lb); int bladerf_get_loopback(struct bladerf *dev, bladerf_loopback *lb); typedef enum { BLADERF_TRIGGER_ROLE_INVALID = -1, BLADERF_TRIGGER_ROLE_DISABLED, BLADERF_TRIGGER_ROLE_MASTER, BLADERF_TRIGGER_ROLE_SLAVE, } bladerf_trigger_role; typedef enum { BLADERF_TRIGGER_INVALID = -1, /**< Invalid selection */ BLADERF_TRIGGER_J71_4, /**< J71 pin 4 (mini_exp_1) */ BLADERF_TRIGGER_USER_0 = 128, /**< Reserved for user SW/HW customizations */ BLADERF_TRIGGER_USER_1, /**< Reserved for user SW/HW customizations */ BLADERF_TRIGGER_USER_2, /**< Reserved for user SW/HW customizations */ BLADERF_TRIGGER_USER_3, /**< Reserved for user SW/HW customizations */ BLADERF_TRIGGER_USER_4, /**< Reserved for user SW/HW customizations */ BLADERF_TRIGGER_USER_5, /**< Reserved for user SW/HW customizations */ BLADERF_TRIGGER_USER_6, /**< Reserved for user SW/HW customizations */ BLADERF_TRIGGER_USER_7, /**< Reserved for user SW/HW customizations */ } bladerf_trigger_signal; struct bladerf_trigger { bladerf_channel channel; /**< RX/TX channel associated with trigger */ bladerf_trigger_role role; /**< Role of the device in a trigger chain */ bladerf_trigger_signal signal; /**< Pin or signal being used */ uint64_t options; /**< Reserved field for future options. This * is unused and should be set to 0. */ }; int bladerf_trigger_init(struct bladerf *dev, bladerf_channel ch, bladerf_trigger_signal signal, struct bladerf_trigger *trigger); int bladerf_trigger_arm(struct bladerf *dev, const struct bladerf_trigger *trigger, bool arm, uint64_t resv1, uint64_t resv2); int bladerf_trigger_fire(struct bladerf *dev, const struct bladerf_trigger *trigger); int bladerf_trigger_state(struct bladerf *dev, const struct bladerf_trigger *trigger, bool *is_armed, bool *has_fired, bool *fire_requested, uint64_t *resv1, uint64_t *resv2); typedef enum { BLADERF_RX_MUX_INVALID = -1, BLADERF_RX_MUX_BASEBAND = 0x0, BLADERF_RX_MUX_12BIT_COUNTER = 0x1, BLADERF_RX_MUX_32BIT_COUNTER = 0x2, BLADERF_RX_MUX_DIGITAL_LOOPBACK = 0x4, } bladerf_rx_mux; int bladerf_set_rx_mux(struct bladerf *dev, bladerf_rx_mux mux); int bladerf_get_rx_mux(struct bladerf *dev, bladerf_rx_mux *mode); #define BLADERF_RETUNE_NOW 0 struct bladerf_quick_tune { union { struct { uint8_t freqsel; uint8_t vcocap; uint16_t nint; uint32_t nfrac; uint8_t flags; }; }; }; int bladerf_schedule_retune(struct bladerf *dev, bladerf_channel ch, uint64_t timestamp, uint64_t frequency, struct bladerf_quick_tune *quick_tune); int bladerf_cancel_scheduled_retunes(struct bladerf *dev, bladerf_channel ch); int bladerf_get_quick_tune(struct bladerf *dev, bladerf_channel ch, struct bladerf_quick_tune *quick_tune); typedef enum { BLADERF_CORR_DCOFF_I, BLADERF_CORR_DCOFF_Q, BLADERF_CORR_PHASE, BLADERF_CORR_GAIN } bladerf_correction; int bladerf_set_correction(struct bladerf *dev, bladerf_channel ch, bladerf_correction corr, int16_t value); int bladerf_get_correction(struct bladerf *dev, bladerf_channel ch, bladerf_correction corr, int16_t *value); typedef enum { BLADERF_RX = 0, /**< Receive direction */ BLADERF_TX = 1, /**< Transmit direction */ } bladerf_direction; typedef enum { BLADERF_RX_X1 = 0, /**< x1 RX (SISO) */ BLADERF_TX_X1 = 1, /**< x1 TX (SISO) */ BLADERF_RX_X2 = 2, /**< x2 RX (MIMO) */ BLADERF_TX_X2 = 3, /**< x2 TX (MIMO) */ } bladerf_channel_layout; #define BLADERF_DIRECTION_MASK 0x1 typedef enum { BLADERF_FORMAT_SC16_Q11, BLADERF_FORMAT_SC16_Q11_META, } bladerf_format; #define BLADERF_META_STATUS_OVERRUN 0x1 #define BLADERF_META_STATUS_UNDERRUN 0x2 #define BLADERF_META_FLAG_TX_BURST_START 0x1 #define BLADERF_META_FLAG_TX_BURST_END 0x2 #define BLADERF_META_FLAG_TX_NOW 0x4 #define BLADERF_META_FLAG_TX_UPDATE_TIMESTAMP 0x8 #define BLADERF_META_FLAG_RX_NOW 0x80000000 struct bladerf_metadata { uint64_t timestamp; uint32_t flags; uint32_t status; unsigned int actual_count; uint8_t reserved[32]; }; int bladerf_enable_module(struct bladerf *dev, bladerf_direction dir, bool enable); int bladerf_get_timestamp(struct bladerf *dev, bladerf_direction dir, uint64_t *value); int bladerf_sync_config(struct bladerf *dev, bladerf_channel_layout layout, bladerf_format format, unsigned int num_buffers, unsigned int buffer_size, unsigned int num_transfers, unsigned int stream_timeout); int bladerf_sync_tx(struct bladerf *dev, void *samples, unsigned int num_samples, struct bladerf_metadata *metadata, unsigned int timeout_ms); int bladerf_sync_rx(struct bladerf *dev, void *samples, unsigned int num_samples, struct bladerf_metadata *metadata, unsigned int timeout_ms); #define BLADERF_STREAM_SHUTDOWN 0 #define BLADERF_STREAM_NO_DATA -1 struct bladerf_stream; typedef void *(*bladerf_stream_cb)(struct bladerf *dev, struct bladerf_stream *stream, struct bladerf_metadata *meta, void *samples, size_t num_samples, void *user_data); int bladerf_init_stream(struct bladerf_stream **stream, struct bladerf *dev, bladerf_stream_cb callback, void ***buffers, size_t num_buffers, bladerf_format format, size_t samples_per_buffer, size_t num_transfers, void *user_data); int bladerf_stream(struct bladerf_stream *stream, bladerf_channel_layout layout); int bladerf_submit_stream_buffer(struct bladerf_stream *stream, void *buffer, unsigned int timeout_ms); int bladerf_submit_stream_buffer_nb(struct bladerf_stream *stream, void *buffer); void bladerf_deinit_stream(struct bladerf_stream *stream); int bladerf_set_stream_timeout(struct bladerf *dev, bladerf_direction dir, unsigned int timeout); int bladerf_get_stream_timeout(struct bladerf *dev, bladerf_direction dir, unsigned int *timeout); int bladerf_flash_firmware(struct bladerf *dev, const char *firmware); int bladerf_load_fpga(struct bladerf *dev, const char *fpga); int bladerf_flash_fpga(struct bladerf *dev, const char *fpga_image); int bladerf_erase_stored_fpga(struct bladerf *dev); int bladerf_device_reset(struct bladerf *dev); int bladerf_get_fw_log(struct bladerf *dev, const char *filename); int bladerf_jump_to_bootloader(struct bladerf *dev); int bladerf_get_bootloader_list(struct bladerf_devinfo **list); int bladerf_load_fw_from_bootloader(const char *device_identifier, bladerf_backend backend, uint8_t bus, uint8_t addr, const char *file); typedef enum { BLADERF_IMAGE_TYPE_INVALID = -1, /**< Used to denote invalid value */ BLADERF_IMAGE_TYPE_RAW, /**< Misc. raw data */ BLADERF_IMAGE_TYPE_FIRMWARE, /**< Firmware data */ BLADERF_IMAGE_TYPE_FPGA_40KLE, /**< FPGA bitstream for 40 KLE device */ BLADERF_IMAGE_TYPE_FPGA_115KLE, /**< FPGA bitstream for 115 KLE device */ BLADERF_IMAGE_TYPE_CALIBRATION, /**< Board calibration */ BLADERF_IMAGE_TYPE_RX_DC_CAL, /**< RX DC offset calibration table */ BLADERF_IMAGE_TYPE_TX_DC_CAL, /**< TX DC offset calibration table */ BLADERF_IMAGE_TYPE_RX_IQ_CAL, /**< RX IQ balance calibration table */ BLADERF_IMAGE_TYPE_TX_IQ_CAL, /**< TX IQ balance calibration table */ } bladerf_image_type; #define BLADERF_IMAGE_MAGIC_LEN 7 #define BLADERF_IMAGE_CHECKSUM_LEN 32 #define BLADERF_IMAGE_RESERVED_LEN 128 struct bladerf_image { char magic[BLADERF_IMAGE_MAGIC_LEN + 1]; uint8_t checksum[BLADERF_IMAGE_CHECKSUM_LEN]; struct bladerf_version version; uint64_t timestamp; char serial[BLADERF_SERIAL_LENGTH + 1]; char reserved[BLADERF_IMAGE_RESERVED_LEN]; bladerf_image_type type; uint32_t address; uint32_t length; uint8_t *data; }; struct bladerf_image * bladerf_alloc_image(bladerf_image_type type, uint32_t address, uint32_t length); struct bladerf_image * bladerf_alloc_cal_image(bladerf_fpga_size fpga_size, uint16_t vctcxo_trim); void bladerf_free_image(struct bladerf_image *image); int bladerf_image_write(struct bladerf_image *image, const char *file); int bladerf_image_read(struct bladerf_image *image, const char *file); typedef enum { BLADERF_VCTCXO_TAMER_INVALID = -1, BLADERF_VCTCXO_TAMER_DISABLED = 0, BLADERF_VCTCXO_TAMER_1_PPS = 1, BLADERF_VCTCXO_TAMER_10_MHZ = 2 } bladerf_vctcxo_tamer_mode; int bladerf_set_vctcxo_tamer_mode(struct bladerf *dev, bladerf_vctcxo_tamer_mode mode); int bladerf_get_vctcxo_tamer_mode(struct bladerf *dev, bladerf_vctcxo_tamer_mode *mode); int bladerf_get_vctcxo_trim(struct bladerf *dev, uint16_t *trim); int bladerf_trim_dac_write(struct bladerf *dev, uint16_t val); int bladerf_trim_dac_read(struct bladerf *dev, uint16_t *val); typedef enum { BLADERF_TUNING_MODE_INVALID = -1, BLADERF_TUNING_MODE_HOST, BLADERF_TUNING_MODE_FPGA, } bladerf_tuning_mode; int bladerf_set_tuning_mode(struct bladerf *dev, bladerf_tuning_mode mode); int bladerf_get_tuning_mode(struct bladerf *dev, bladerf_tuning_mode *mode); #define BLADERF_TRIGGER_REG_ARM 0x1 #define BLADERF_TRIGGER_REG_FIRE 0x2 #define BLADERF_TRIGGER_REG_MASTER 0x4 #define BLADERF_TRIGGER_REG_LINE 0x8 int bladerf_read_trigger(struct bladerf *dev, bladerf_channel ch, bladerf_trigger_signal signal, uint8_t *val); int bladerf_write_trigger(struct bladerf *dev, bladerf_channel ch, bladerf_trigger_signal signal, uint8_t val); int bladerf_config_gpio_read(struct bladerf *dev, uint32_t *val); int bladerf_config_gpio_write(struct bladerf *dev, uint32_t val); int bladerf_erase_flash(struct bladerf *dev, uint32_t erase_block, uint32_t count); int bladerf_read_flash(struct bladerf *dev, uint8_t *buf, uint32_t page, uint32_t count); int bladerf_write_flash(struct bladerf *dev, const uint8_t *buf, uint32_t page, uint32_t count); typedef enum { BLADERF_XB_NONE = 0, /**< No expansion boards attached */ BLADERF_XB_100, /**< XB-100 GPIO expansion board. * This device is not yet supported in * libbladeRF, and is here as a placeholder * for future support. */ BLADERF_XB_200, /**< XB-200 Transverter board */ BLADERF_XB_300 /**< XB-300 Amplifier board */ } bladerf_xb; int bladerf_expansion_attach(struct bladerf *dev, bladerf_xb xb); int bladerf_expansion_get_attached(struct bladerf *dev, bladerf_xb *xb); typedef enum { BLADERF_LOG_LEVEL_VERBOSE, /**< Verbose level logging */ BLADERF_LOG_LEVEL_DEBUG, /**< Debug level logging */ BLADERF_LOG_LEVEL_INFO, /**< Information level logging */ BLADERF_LOG_LEVEL_WARNING, /**< Warning level logging */ BLADERF_LOG_LEVEL_ERROR, /**< Error level logging */ BLADERF_LOG_LEVEL_CRITICAL, /**< Fatal error level logging */ BLADERF_LOG_LEVEL_SILENT /**< No output */ } bladerf_log_level; void bladerf_log_set_verbosity(bladerf_log_level level); void bladerf_version(struct bladerf_version *version); #define BLADERF_ERR_UNEXPECTED -1 /**< An unexpected failure occurred */ #define BLADERF_ERR_RANGE -2 /**< Provided parameter is out of range */ #define BLADERF_ERR_INVAL -3 /**< Invalid operation/parameter */ #define BLADERF_ERR_MEM -4 /**< Memory allocation error */ #define BLADERF_ERR_IO -5 /**< File/Device I/O error */ #define BLADERF_ERR_TIMEOUT -6 /**< Operation timed out */ #define BLADERF_ERR_NODEV -7 /**< No device(s) available */ #define BLADERF_ERR_UNSUPPORTED -8 /**< Operation not supported */ #define BLADERF_ERR_MISALIGNED -9 /**< Misaligned flash access */ #define BLADERF_ERR_CHECKSUM -10 /**< Invalid checksum */ #define BLADERF_ERR_NO_FILE -11 /**< File not found */ #define BLADERF_ERR_UPDATE_FPGA -12 /**< An FPGA update is required */ #define BLADERF_ERR_UPDATE_FW -13 /**< A firmware update is requied */ #define BLADERF_ERR_TIME_PAST -14 /**< Requested timestamp is in the past */ #define BLADERF_ERR_QUEUE_FULL -15 /**< Could not enqueue data into * full queue */ #define BLADERF_ERR_FPGA_OP -16 /**< An FPGA operation reported failure */ #define BLADERF_ERR_PERMISSION -17 /**< Insufficient permissions for the * requested operation */ #define BLADERF_ERR_WOULD_BLOCK -18 /**< Operation would block, but has been * requested to be non-blocking. This * indicates to a caller that it may * need to retry the operation later. */ #define BLADERF_ERR_NOT_INIT -19 /**< Device insufficiently initialized * for operation */ const char * bladerf_strerror(int error); """) libbladeRF = ffi.dlopen("libbladeRF.so") ################################################################################ # Python class wrappers for various structures 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]) class DevInfo(collections.namedtuple("DevInfo", ["backend", "serial", "usb_bus", "usb_addr", "instance"])): @staticmethod def from_struct(devinfo): return DevInfo(ffi.string(libbladeRF.bladerf_backend_str(devinfo.backend)).decode(), ffi.string(devinfo.serial).decode(), devinfo.usb_bus, devinfo.usb_addr, devinfo.instance) def __str__(self): s = "Device Information\n" s += " backend {}\n".format(self.backend) s += " serial {}\n".format(self.serial) s += " usb_bus {}\n".format(self.usb_bus) s += " usb_addr {}\n".format(self.usb_addr) s += " instance {}".format(self.instance) return s 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): s = "Range\n" s += " min {}\n".format(self.min) s += " max {}\n".format(self.max) s += " step {}\n".format(self.step) s += " scale {}\n".format(self.scale) return s class DeviceSpeed(enum.Enum): Unknown = libbladeRF.BLADERF_DEVICE_SPEED_UNKNOWN High = libbladeRF.BLADERF_DEVICE_SPEED_HIGH Super = libbladeRF.BLADERF_DEVICE_SPEED_SUPER 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 BladeRFError(Exception): def __init__(self, code): self.code = code self.errstr = ffi.string(libbladeRF.bladerf_strerror(code)).decode() def __str__(self): return self.errstr def _check_error(err): if err < 0: raise BladeRFError(err) ################################################################################ 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 ################################################################################ RX = 0x0 TX = 0x1 def CHANNEL_RX(ch): return (ch << 1) def CHANNEL_TX(ch): return (ch << 1) | 0x1 ################################################################################ class BladeRF: def __init__(self, device_identifier=None): self.dev = ffi.new("struct bladerf *[1]") self.open(device_identifier) # Open, close, devinfo def open(self, device_identifier=None): device_identifier = device_identifier.encode() if device_identifier else ffi.NULL ret = libbladeRF.bladerf_open(self.dev, device_identifier) _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) # Device properties def get_device_speed(self): return DeviceSpeed(libbladeRF.bladerf_device_speed(self.dev[0])) def get_serial(self): serial = ffi.new("char []", libbladeRF.BLADERF_SERIAL_LENGTH) ret = libbladeRF.bladerf_get_serial(self.dev[0], serial) _check_error(ret) return ffi.string(serial).decode() 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] def is_fpga_configured(self): ret = libbladeRF.bladerf_is_fpga_configured(self.dev[0]) _check_error(ret) return bool(ret) 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) 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) def get_board_name(self): board_name = libbladeRF.bladerf_get_board_name(self.dev[0]) return ffi.string(board_name).decode() # Enable/Disable def enable_module(self, direction, enable): ret = libbladeRF.bladerf_enable_module(self.dev[0], direction, 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("int *") ret = libbladeRF.bladerf_get_gain(self.dev[0], ch, gain) _check_error(ret) return gain[0] def get_gain_range(self, ch): gain_range = ffi.new("struct bladerf_range *") ret = libbladeRF.bladerf_get_gain_range(self.dev[0], ch, gain_range) _check_error(ret) return Range.from_struct(gain_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("int *") 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): gain_range = ffi.new("struct bladerf_range *") ret = libbladeRF.bladerf_get_gain_stage_range(self.dev[0], ch, stage.encode(), gain_range) _check_error(ret) return Range.from_struct(gain_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) stages = [ffi.string(stages_arr[i]).decode() for i in range(ret)] return stages # Sample rate def set_sample_rate(self, ch, rate): actual_rate = ffi.new("unsigned int *") 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("unsigned int *") 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): sample_rate_range = ffi.new("struct bladerf_range *") ret = libbladeRF.bladerf_get_sample_rate_range(self.dev[0], ch, sample_rate_range) _check_error(ret) return Range.from_struct(sample_rate_range) # Bandwidth def set_bandwidth(self, ch, bandwidth): actual_bandwidth = ffi.new("unsigned int *") 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("unsigned int *") ret = libbladeRF.bladerf_get_bandwidth(self.dev[0], ch, bandwidth) _check_error(ret) return bandwidth[0] def get_bandwidth_range(self, ch): bandwidth_range = ffi.new("struct bladerf_range *") ret = libbladeRF.bladerf_get_bandwidth_range(self.dev[0], ch, bandwidth_range) _check_error(ret) return Range.from_struct(bandwidth_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("uint64_t *") 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): frequency_range = ffi.new("struct bladerf_range *") ret = libbladeRF.bladerf_get_frequency_range(self.dev[0], ch, frequency_range) _check_error(ret) return Range.from_struct(frequency_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): 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() def get_rf_ports(self, ch): ret = libbladeRF.bladerf_get_rf_ports(self.dev[0], ch, ffi.NULL, 0) _check_error(ret) ports_arr = ffi.new("const char *[]", ret) ret = libbladeRF.bladerf_get_rf_ports(self.dev[0], ch, ports_arr, ret) _check_error(ret) ports = [ffi.string(ports_arr[i]).decode() for i in range(ret)] return ports # Sample RX FPGA Mux def set_loopback(self, lb): raise NotImplementedError() def get_loopback(self): raise NotImplementedError() # Trigger TBD # Sample RX Mux def set_rx_mux(self, rx_mux): raise NotImplementedError() def get_rx_mux(self): raise NotImplementedError() # DC/Phase/Gain Correction def get_correction(self, ch, corr): value = ffi.new("int16_t *") 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 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, 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], image_path.encode()) _check_error(ret) # VCTCXO Tamer Mode def set_vctcxo_tamer_mode(self, mode): raise NotImplementedError() def get_vctcxo_tamer_mode(self): raise NotImplementedError() def get_vctcxo_trim(self): raise NotImplementedError() # Tuning Mode def set_tuning_mode(self, mode): raise NotImplementedError() def get_tuning_mode(self): raise NotImplementedError()