* host: libbladeRF: add functions to get/set ADF4002 refclk frequency
* host: bladeRF-cli: add print/set adf_refclk
* host: python: add adf4002_refclk functions
This permits getting and setting the ADF4002 reference clock
frequency.
>>> import bladerf
>>> b = bladerf.BladeRF()
ad9361_init : AD936x Rev 2 successfully initialized
>>> b.adf4002_refclk
10000000
>>> b.adf4002_refclk = 9000000
>>> b.adf4002_refclk
9000000
>>> b.adf4002_refclk = 900000000
[ERROR @
"/home/rtucker/dev/privatebladeRF/host/libraries/libbladeRF/src/board/bladerf2/bladerf2.c":4360]
bladerf_adf4002_set_refclk: bladerf_adf4002_calculate_ratio failed:
Provided parameter was out of the allowable range
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File
"/home/rtucker/dev/privatebladeRF/host/libraries/libbladeRF_bindings/python/bladerf.py",
line 1581, in set_adf4002_refclk
_check_error(ret)
File
"/home/rtucker/dev/privatebladeRF/host/libraries/libbladeRF_bindings/python/bladerf.py",
line 998, in _check_error
raise globals()[errorval.name](err)
bladerf.RangeError: Provided parameter was out of the allowable range
>>> b.adf4002_refclk
9000000
>>> b.adf4002_refclk = 10000000
>>> b.adf4002_refclk
10000000
* host: libbladeRF: make ADF convenience functions static
bladerf_adf4002_set_refclk is much nicer (and safer) than calculating
the R/N ratio and then doing a bladerf_adf4002_configure.
* host: python: update cffi header block
1805 lines
60 KiB
Python
1805 lines
60 KiB
Python
import enum
|
|
import collections
|
|
|
|
import cffi
|
|
|
|
ffi = cffi.FFI()
|
|
|
|
# The cdef string is auto-generated by _import_header.py
|
|
ffi.cdef("""
|
|
/* Generated from libbladeRF.h by _import_header.py */
|
|
struct bladerf;
|
|
typedef enum
|
|
{
|
|
BLADERF_BACKEND_ANY,
|
|
BLADERF_BACKEND_LINUX,
|
|
BLADERF_BACKEND_LIBUSB,
|
|
BLADERF_BACKEND_CYPRESS,
|
|
BLADERF_BACKEND_DUMMY = 100
|
|
} bladerf_backend;
|
|
struct bladerf_devinfo
|
|
{
|
|
bladerf_backend backend;
|
|
char serial[33];
|
|
uint8_t usb_bus;
|
|
uint8_t usb_addr;
|
|
unsigned int instance;
|
|
};
|
|
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;
|
|
uint16_t minor;
|
|
uint16_t patch;
|
|
const char *describe;
|
|
};
|
|
typedef enum
|
|
{
|
|
BLADERF_FPGA_UNKNOWN = 0,
|
|
BLADERF_FPGA_40KLE = 40,
|
|
BLADERF_FPGA_115KLE = 115,
|
|
BLADERF_FPGA_A4 = 49,
|
|
BLADERF_FPGA_A9 = 301
|
|
} 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);
|
|
size_t bladerf_get_channel_count(struct bladerf *dev, bool tx);
|
|
typedef int bladerf_channel;
|
|
typedef bladerf_channel bladerf_module;
|
|
struct bladerf_range
|
|
{
|
|
int64_t min;
|
|
int64_t max;
|
|
int64_t step;
|
|
float scale;
|
|
};
|
|
typedef enum
|
|
{
|
|
BLADERF_GAIN_DEFAULT,
|
|
BLADERF_GAIN_MGC,
|
|
BLADERF_GAIN_FASTATTACK_AGC,
|
|
BLADERF_GAIN_SLOWATTACK_AGC,
|
|
BLADERF_GAIN_HYBRID_AGC
|
|
} bladerf_gain_mode;
|
|
struct bladerf_gain_modes
|
|
{
|
|
const char *name;
|
|
bladerf_gain_mode mode;
|
|
};
|
|
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_set_gain_mode(struct bladerf *dev, bladerf_channel ch,
|
|
bladerf_gain_mode mode);
|
|
int bladerf_get_gain_mode(struct bladerf *dev, bladerf_channel ch,
|
|
bladerf_gain_mode *mode);
|
|
int bladerf_get_gain_modes(struct bladerf *dev, bladerf_channel ch,
|
|
const struct bladerf_gain_modes **modes);
|
|
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;
|
|
uint64_t num;
|
|
uint64_t den;
|
|
};
|
|
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;
|
|
struct bladerf_loopback_modes
|
|
{
|
|
const char *name;
|
|
bladerf_loopback mode;
|
|
};
|
|
int bladerf_get_loopback_modes(struct bladerf *dev, const struct
|
|
bladerf_loopback_modes **modes);
|
|
bool bladerf_is_loopback_mode_supported(struct bladerf *dev,
|
|
bladerf_loopback mode);
|
|
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,
|
|
BLADERF_TRIGGER_J71_4,
|
|
BLADERF_TRIGGER_USER_0 = 128,
|
|
BLADERF_TRIGGER_USER_1,
|
|
BLADERF_TRIGGER_USER_2,
|
|
BLADERF_TRIGGER_USER_3,
|
|
BLADERF_TRIGGER_USER_4,
|
|
BLADERF_TRIGGER_USER_5,
|
|
BLADERF_TRIGGER_USER_6,
|
|
BLADERF_TRIGGER_USER_7
|
|
} bladerf_trigger_signal;
|
|
struct bladerf_trigger
|
|
{
|
|
bladerf_channel channel;
|
|
bladerf_trigger_role role;
|
|
bladerf_trigger_signal signal;
|
|
uint64_t options;
|
|
};
|
|
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);
|
|
struct bladerf_quick_tune
|
|
{
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
uint8_t freqsel;
|
|
uint8_t vcocap;
|
|
uint16_t nint;
|
|
uint32_t nfrac;
|
|
uint8_t flags;
|
|
};
|
|
struct
|
|
{
|
|
void *tbd;
|
|
};
|
|
};
|
|
};
|
|
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,
|
|
BLADERF_TX = 1
|
|
} bladerf_direction;
|
|
typedef enum
|
|
{
|
|
BLADERF_RX_X1 = 0,
|
|
BLADERF_TX_X1 = 1,
|
|
BLADERF_RX_X2 = 2,
|
|
BLADERF_TX_X2 = 3
|
|
} bladerf_channel_layout;
|
|
typedef enum
|
|
{
|
|
BLADERF_FORMAT_SC16_Q11,
|
|
BLADERF_FORMAT_SC16_Q11_META
|
|
} bladerf_format;
|
|
struct bladerf_metadata
|
|
{
|
|
uint64_t timestamp;
|
|
uint32_t flags;
|
|
uint32_t status;
|
|
unsigned int actual_count;
|
|
uint8_t reserved[32];
|
|
};
|
|
int bladerf_interleave_stream_buffer(bladerf_channel_layout layout,
|
|
bladerf_format format, unsigned int buffer_size, void *samples);
|
|
int bladerf_deinterleave_stream_buffer(bladerf_channel_layout layout,
|
|
bladerf_format format, unsigned int buffer_size, void *samples);
|
|
int bladerf_enable_module(struct bladerf *dev, bladerf_channel ch,
|
|
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, const 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);
|
|
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,
|
|
BLADERF_IMAGE_TYPE_RAW,
|
|
BLADERF_IMAGE_TYPE_FIRMWARE,
|
|
BLADERF_IMAGE_TYPE_FPGA_40KLE,
|
|
BLADERF_IMAGE_TYPE_FPGA_115KLE,
|
|
BLADERF_IMAGE_TYPE_CALIBRATION,
|
|
BLADERF_IMAGE_TYPE_RX_DC_CAL,
|
|
BLADERF_IMAGE_TYPE_TX_DC_CAL,
|
|
BLADERF_IMAGE_TYPE_RX_IQ_CAL,
|
|
BLADERF_IMAGE_TYPE_TX_IQ_CAL
|
|
} bladerf_image_type;
|
|
struct bladerf_image
|
|
{
|
|
char magic[8]; /* Original: char magic[7 + 1]; */
|
|
uint8_t checksum[32];
|
|
struct bladerf_version version;
|
|
uint64_t timestamp;
|
|
char serial[34]; /* Original: char serial[33 + 1]; */
|
|
char reserved[128];
|
|
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);
|
|
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,
|
|
BLADERF_XB_100,
|
|
BLADERF_XB_200,
|
|
BLADERF_XB_300
|
|
} 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,
|
|
BLADERF_LOG_LEVEL_DEBUG,
|
|
BLADERF_LOG_LEVEL_INFO,
|
|
BLADERF_LOG_LEVEL_WARNING,
|
|
BLADERF_LOG_LEVEL_ERROR,
|
|
BLADERF_LOG_LEVEL_CRITICAL,
|
|
BLADERF_LOG_LEVEL_SILENT
|
|
} bladerf_log_level;
|
|
void bladerf_log_set_verbosity(bladerf_log_level level);
|
|
void bladerf_version(struct bladerf_version *version);
|
|
const char *bladerf_strerror(int error);
|
|
typedef enum
|
|
{
|
|
BLADERF_LNA_GAIN_UNKNOWN,
|
|
BLADERF_LNA_GAIN_BYPASS,
|
|
BLADERF_LNA_GAIN_MID,
|
|
BLADERF_LNA_GAIN_MAX
|
|
} bladerf_lna_gain;
|
|
int bladerf_set_txvga2(struct bladerf *dev, int gain);
|
|
int bladerf_get_txvga2(struct bladerf *dev, int *gain);
|
|
int bladerf_set_txvga1(struct bladerf *dev, int gain);
|
|
int bladerf_get_txvga1(struct bladerf *dev, int *gain);
|
|
int bladerf_set_lna_gain(struct bladerf *dev, bladerf_lna_gain gain);
|
|
int bladerf_get_lna_gain(struct bladerf *dev, bladerf_lna_gain *gain);
|
|
int bladerf_set_rxvga1(struct bladerf *dev, int gain);
|
|
int bladerf_get_rxvga1(struct bladerf *dev, int *gain);
|
|
int bladerf_set_rxvga2(struct bladerf *dev, int gain);
|
|
int bladerf_get_rxvga2(struct bladerf *dev, int *gain);
|
|
typedef enum
|
|
{
|
|
BLADERF_SAMPLING_UNKNOWN,
|
|
BLADERF_SAMPLING_INTERNAL,
|
|
BLADERF_SAMPLING_EXTERNAL
|
|
} bladerf_sampling;
|
|
int bladerf_set_sampling(struct bladerf *dev, bladerf_sampling
|
|
sampling);
|
|
int bladerf_get_sampling(struct bladerf *dev, bladerf_sampling
|
|
*sampling);
|
|
typedef enum
|
|
{
|
|
BLADERF_LPF_NORMAL,
|
|
BLADERF_LPF_BYPASSED,
|
|
BLADERF_LPF_DISABLED
|
|
} bladerf_lpf_mode;
|
|
int bladerf_set_lpf_mode(struct bladerf *dev, bladerf_channel ch,
|
|
bladerf_lpf_mode mode);
|
|
int bladerf_get_lpf_mode(struct bladerf *dev, bladerf_channel ch,
|
|
bladerf_lpf_mode *mode);
|
|
typedef enum
|
|
{
|
|
BLADERF_SMB_MODE_INVALID = -1,
|
|
BLADERF_SMB_MODE_DISABLED,
|
|
BLADERF_SMB_MODE_OUTPUT,
|
|
BLADERF_SMB_MODE_INPUT,
|
|
BLADERF_SMB_MODE_UNAVAILBLE
|
|
} bladerf_smb_mode;
|
|
int bladerf_set_smb_mode(struct bladerf *dev, bladerf_smb_mode mode);
|
|
int bladerf_get_smb_mode(struct bladerf *dev, bladerf_smb_mode *mode);
|
|
int bladerf_set_rational_smb_frequency(struct bladerf *dev, struct
|
|
bladerf_rational_rate *rate, struct bladerf_rational_rate *actual);
|
|
int bladerf_set_smb_frequency(struct bladerf *dev, uint32_t rate,
|
|
uint32_t *actual);
|
|
int bladerf_get_rational_smb_frequency(struct bladerf *dev, struct
|
|
bladerf_rational_rate *rate);
|
|
int bladerf_get_smb_frequency(struct bladerf *dev, unsigned int
|
|
*rate);
|
|
int bladerf_expansion_gpio_read(struct bladerf *dev, uint32_t *val);
|
|
int bladerf_expansion_gpio_write(struct bladerf *dev, uint32_t val);
|
|
int bladerf_expansion_gpio_masked_write(struct bladerf *dev, uint32_t
|
|
mask, uint32_t value);
|
|
int bladerf_expansion_gpio_dir_read(struct bladerf *dev, uint32_t
|
|
*outputs);
|
|
int bladerf_expansion_gpio_dir_write(struct bladerf *dev, uint32_t
|
|
outputs);
|
|
int bladerf_expansion_gpio_dir_masked_write(struct bladerf *dev,
|
|
uint32_t mask, uint32_t outputs);
|
|
typedef enum
|
|
{
|
|
BLADERF_XB200_50M = 0,
|
|
BLADERF_XB200_144M,
|
|
BLADERF_XB200_222M,
|
|
BLADERF_XB200_CUSTOM,
|
|
BLADERF_XB200_AUTO_1DB,
|
|
BLADERF_XB200_AUTO_3DB
|
|
} bladerf_xb200_filter;
|
|
typedef enum
|
|
{
|
|
BLADERF_XB200_BYPASS = 0,
|
|
BLADERF_XB200_MIX
|
|
} bladerf_xb200_path;
|
|
typedef enum
|
|
{
|
|
BLADERF_XB300_TRX_INVAL = -1,
|
|
BLADERF_XB300_TRX_TX = 0,
|
|
BLADERF_XB300_TRX_RX,
|
|
BLADERF_XB300_TRX_UNSET
|
|
} bladerf_xb300_trx;
|
|
typedef enum
|
|
{
|
|
BLADERF_XB300_AMP_INVAL = -1,
|
|
BLADERF_XB300_AMP_PA = 0,
|
|
BLADERF_XB300_AMP_LNA,
|
|
BLADERF_XB300_AMP_PA_AUX
|
|
} bladerf_xb300_amplifier;
|
|
int bladerf_xb200_set_filterbank(struct bladerf *dev, bladerf_channel
|
|
ch, bladerf_xb200_filter filter);
|
|
int bladerf_xb200_get_filterbank(struct bladerf *dev, bladerf_channel
|
|
ch, bladerf_xb200_filter *filter);
|
|
int bladerf_xb200_set_path(struct bladerf *dev, bladerf_channel ch,
|
|
bladerf_xb200_path path);
|
|
int bladerf_xb200_get_path(struct bladerf *dev, bladerf_channel ch,
|
|
bladerf_xb200_path *path);
|
|
int bladerf_xb300_set_trx(struct bladerf *dev, bladerf_xb300_trx trx);
|
|
int bladerf_xb300_get_trx(struct bladerf *dev, bladerf_xb300_trx
|
|
*trx);
|
|
int bladerf_xb300_set_amplifier_enable(struct bladerf *dev,
|
|
bladerf_xb300_amplifier amp, bool enable);
|
|
int bladerf_xb300_get_amplifier_enable(struct bladerf *dev,
|
|
bladerf_xb300_amplifier amp, bool *enable);
|
|
int bladerf_xb300_get_output_power(struct bladerf *dev, float *val);
|
|
typedef enum
|
|
{
|
|
BLADERF_DC_CAL_INVALID = -1,
|
|
BLADERF_DC_CAL_LPF_TUNING,
|
|
BLADERF_DC_CAL_TX_LPF,
|
|
BLADERF_DC_CAL_RX_LPF,
|
|
BLADERF_DC_CAL_RXVGA2
|
|
} bladerf_cal_module;
|
|
int bladerf_calibrate_dc(struct bladerf *dev, bladerf_cal_module
|
|
module);
|
|
int bladerf_dac_write(struct bladerf *dev, uint16_t val);
|
|
int bladerf_dac_read(struct bladerf *dev, uint16_t *val);
|
|
int bladerf_si5338_read(struct bladerf *dev, uint8_t address, uint8_t
|
|
*val);
|
|
int bladerf_si5338_write(struct bladerf *dev, uint8_t address, uint8_t
|
|
val);
|
|
int bladerf_lms_read(struct bladerf *dev, uint8_t address, uint8_t
|
|
*val);
|
|
int bladerf_lms_write(struct bladerf *dev, uint8_t address, uint8_t
|
|
val);
|
|
struct bladerf_lms_dc_cals
|
|
{
|
|
int16_t lpf_tuning;
|
|
int16_t tx_lpf_i;
|
|
int16_t tx_lpf_q;
|
|
int16_t rx_lpf_i;
|
|
int16_t rx_lpf_q;
|
|
int16_t dc_ref;
|
|
int16_t rxvga2a_i;
|
|
int16_t rxvga2a_q;
|
|
int16_t rxvga2b_i;
|
|
int16_t rxvga2b_q;
|
|
};
|
|
int bladerf_lms_set_dc_cals(struct bladerf *dev, const struct
|
|
bladerf_lms_dc_cals *dc_cals);
|
|
int bladerf_lms_get_dc_cals(struct bladerf *dev, struct
|
|
bladerf_lms_dc_cals *dc_cals);
|
|
int bladerf_xb_spi_write(struct bladerf *dev, uint32_t val);
|
|
int bladerf_get_bias_tee(struct bladerf *dev, bladerf_channel ch, bool
|
|
*enable);
|
|
int bladerf_set_bias_tee(struct bladerf *dev, bladerf_channel ch, bool
|
|
enable);
|
|
int bladerf_ad9361_read(struct bladerf *dev, uint16_t address, uint8_t
|
|
*val);
|
|
int bladerf_ad9361_write(struct bladerf *dev, uint16_t address,
|
|
uint8_t val);
|
|
int bladerf_ad9361_temperature(struct bladerf *dev, float *val);
|
|
int bladerf_ad9361_get_rssi(struct bladerf *dev, bladerf_channel ch,
|
|
int32_t *pre_rssi, int32_t *sym_rssi);
|
|
int bladerf_adf4002_get_locked(struct bladerf *dev, bool *locked);
|
|
int bladerf_adf4002_get_enable(struct bladerf *dev, bool *enabled);
|
|
int bladerf_adf4002_set_enable(struct bladerf *dev, bool enable);
|
|
int bladerf_adf4002_get_refclk_range(struct bladerf *dev, struct
|
|
bladerf_range *range);
|
|
int bladerf_adf4002_get_refclk(struct bladerf *dev, uint64_t
|
|
*frequency);
|
|
int bladerf_adf4002_set_refclk(struct bladerf *dev, uint64_t
|
|
frequency);
|
|
int bladerf_adf4002_read(struct bladerf *dev, uint8_t address,
|
|
uint32_t *val);
|
|
int bladerf_adf4002_write(struct bladerf *dev, uint8_t address,
|
|
uint32_t val);
|
|
typedef enum
|
|
{
|
|
BLADERF_UNKNOWN,
|
|
BLADERF_PS_DC,
|
|
BLADERF_PS_USB_VBUS
|
|
} bladerf_power_sources;
|
|
int bladerf_get_power_source(struct bladerf *dev,
|
|
bladerf_power_sources *val);
|
|
typedef enum
|
|
{
|
|
CLOCK_SELECT_VCTCXO,
|
|
CLOCK_SELECT_EXTERNAL
|
|
} bladerf_clock_select;
|
|
int bladerf_get_clock_select(struct bladerf *dev, bladerf_clock_select
|
|
*sel);
|
|
int bladerf_set_clock_select(struct bladerf *dev, bladerf_clock_select
|
|
sel);
|
|
int bladerf_get_clock_output(struct bladerf *dev, bool *state);
|
|
int bladerf_set_clock_output(struct bladerf *dev, bool enable);
|
|
typedef enum
|
|
{
|
|
BLADERF_INA219_CONFIGURATION,
|
|
BLADERF_INA219_VOLTAGE_SHUNT,
|
|
BLADERF_INA219_VOLTAGE_BUS,
|
|
BLADERF_INA219_POWER,
|
|
BLADERF_INA219_CURRENT,
|
|
BLADERF_INA219_CALIBRATION
|
|
} bladerf_ina219_register;
|
|
int bladerf_ina219_read(struct bladerf *dev, bladerf_ina219_register
|
|
reg, void *val);
|
|
typedef struct
|
|
{
|
|
uint32_t tx1_rfic_port;
|
|
uint32_t tx1_spdt_port;
|
|
uint32_t tx2_rfic_port;
|
|
uint32_t tx2_spdt_port;
|
|
uint32_t rx1_rfic_port;
|
|
uint32_t rx1_spdt_port;
|
|
uint32_t rx2_rfic_port;
|
|
uint32_t rx2_spdt_port;
|
|
} bladerf_rf_switch_config;
|
|
int bladerf_get_rf_switch_config(struct bladerf *dev,
|
|
bladerf_rf_switch_config *config);
|
|
""")
|
|
|
|
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):
|
|
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
|
|
Disabled = libbladeRF.BLADERF_LB_NONE
|
|
AD9361_BIST = libbladeRF.BLADERF_LB_AD9361_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_VCTCXO
|
|
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 INA219_Register(enum.Enum):
|
|
Configuration = libbladeRF.BLADERF_INA219_CONFIGURATION
|
|
Voltage_shunt = libbladeRF.BLADERF_INA219_VOLTAGE_SHUNT
|
|
Voltage_bus = libbladeRF.BLADERF_INA219_VOLTAGE_BUS
|
|
Power = libbladeRF.BLADERF_INA219_POWER
|
|
Current = libbladeRF.BLADERF_INA219_CURRENT
|
|
Calibration = libbladeRF.BLADERF_INA219_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 ADF4002 on bladeRF 2
|
|
BLADERF_VCTCXO_FREQUENCY = 38.4e6
|
|
BLADERF_REFIN_DEFAULT = 10.0e6
|
|
|
|
|
|
###############################################################################
|
|
|
|
|
|
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 []", libbladeRF.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 get_channel_count(self, is_tx=False):
|
|
return libbladeRF.bladerf_get_channel_count(self.dev[0], is_tx)
|
|
|
|
@property
|
|
def rx_channel_count(self):
|
|
"""Number of RX channels on the device"""
|
|
return self.get_channel_count(False)
|
|
|
|
@property
|
|
def tx_channel_count(self):
|
|
"""Number of TX channels on the device"""
|
|
return self.get_channel_count(True)
|
|
|
|
# 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("int *")
|
|
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):
|
|
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)
|
|
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("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):
|
|
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("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 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)
|
|
|
|
# AD9361 RFIC
|
|
|
|
def get_ad9361_temperature(self):
|
|
try:
|
|
val = ffi.new("float *")
|
|
ret = libbladeRF.bladerf_ad9361_temperature(self.dev[0], val)
|
|
_check_error(ret)
|
|
return val[0]
|
|
except UnsupportedError:
|
|
return None
|
|
|
|
ad9361_temperature = property(get_ad9361_temperature,
|
|
doc="AD9361 RFIC temperature")
|
|
|
|
def get_ad9361_rssi(self, ch):
|
|
try:
|
|
preamble = ffi.new("int32_t *")
|
|
symbol = ffi.new("int32_t *")
|
|
ret = libbladeRF.bladerf_ad9361_get_rssi(self.dev[0], ch,
|
|
preamble, symbol)
|
|
_check_error(ret)
|
|
return RSSI(preamble[0], symbol[0])
|
|
except UnsupportedError:
|
|
return None
|
|
|
|
# ADF4002 Phase Detector/Frequency Synthesizer
|
|
|
|
def get_adf4002_locked(self):
|
|
try:
|
|
locked = ffi.new("bool *")
|
|
ret = libbladeRF.bladerf_adf4002_get_locked(self.dev[0], locked)
|
|
_check_error(ret)
|
|
return bool(locked[0])
|
|
except UnsupportedError:
|
|
return None
|
|
|
|
adf4002_locked = property(get_adf4002_locked,
|
|
doc="ADF4002 PLL lock indication")
|
|
|
|
def get_adf4002_enable(self):
|
|
try:
|
|
enable = ffi.new("bool *")
|
|
ret = libbladeRF.bladerf_adf4002_get_enable(self.dev[0], enable)
|
|
_check_error(ret)
|
|
return bool(enable[0])
|
|
except UnsupportedError:
|
|
return None
|
|
|
|
def set_adf4002_enable(self, enable):
|
|
ret = libbladeRF.bladerf_adf4002_set_enable(self.dev[0], enable)
|
|
_check_error(ret)
|
|
|
|
adf4002_enable = property(get_adf4002_enable, set_adf4002_enable,
|
|
doc="ADF4002 Enable")
|
|
|
|
def get_adf4002_refclk(self):
|
|
try:
|
|
freq = ffi.new("uint64_t *")
|
|
ret = libbladeRF.bladerf_adf4002_get_refclk(self.dev[0], freq)
|
|
_check_error(ret)
|
|
return int(freq[0])
|
|
except UnsupportedError:
|
|
return None
|
|
|
|
def set_adf4002_refclk(self, freq):
|
|
ret = libbladeRF.bladerf_adf4002_set_refclk(self.dev[0], freq)
|
|
_check_error(ret)
|
|
|
|
adf4002_refclk = property(get_adf4002_refclk, set_adf4002_refclk,
|
|
doc="ADF4002 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")
|
|
|
|
# INA219 current/power monitor
|
|
|
|
def get_ina219_register(self, reg):
|
|
try:
|
|
if not isinstance(reg, INA219_Register):
|
|
reg = INA219_Register(reg)
|
|
val = ffi.new(reg.ctype)
|
|
ret = libbladeRF.bladerf_ina219_read(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_ina219_register(INA219_Register.Voltage_bus)
|
|
|
|
@property
|
|
def bus_current(self):
|
|
"""Main power bus current, in Amps"""
|
|
return self.get_ina219_register(INA219_Register.Current)
|
|
|
|
@property
|
|
def bus_power(self):
|
|
"""Main power bus power, in Watts"""
|
|
return self.get_ina219_register(INA219_Register.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_ad9361_rssi(self.channel)
|
|
|
|
@property
|
|
def preamble_rssi(self):
|
|
"""Preamble RSSI reading (latched at algorithm reset)"""
|
|
return self.rssi.preamble
|
|
|
|
@property
|
|
def symbol_rssi(self):
|
|
"""Symbol RSSI reading (most recent value)"""
|
|
return self.rssi.symbol
|
|
|
|
@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)
|