def txrx_burst(freq, samples): # Set frequency. device.tx.frequency = freq device.rx.frequency = freq - rx_offset # Setup TX and RX metadata structs. metadata_tx = ffi.new("struct bladerf_metadata [1]") metadata_tx[0].flags = bladeRF.BLADERF_META_FLAG_TX_BURST_START | bladeRF.BLADERF_META_FLAG_TX_BURST_END metadata_rx = ffi.new("struct bladerf_metadata [1]") metadata_rx[0].flags = 0 # Get current timestamp current_tx_timestamp = device.tx.timestamp current_rx_timestamp = device.rx.timestamp print "Timestamps: TX %d, RX %d" % (current_tx_timestamp, current_rx_timestamp) # Set scheduled transmit and receive timestamps. metadata_tx[0].timestamp = current_tx_timestamp + device.tx.sample_rate/20 # 10ms into the future metadata_rx[0].timestamp = current_rx_timestamp + device.tx.sample_rate/20 # 10ms into the future # Transmit! device.tx(num_samples,samples=tx_samples, metadata=metadata_tx, timeout_ms=timeout_ms) rx_samples = device.rx(num_samples, metadata=metadata_rx, timeout_ms = timeout_ms) # Wait until all samples have been transmitted. while(device.tx.timestamp < metadata_tx[0].timestamp + 2*num_samples): pass print "RXed %d Samples." % (metadata_rx[0].actual_count) return bladeRF.samples_to_narray(rx_samples, metadata_rx[0].actual_count)
def init_stream(dev, callback, num_buffers, format, num_samples, num_transfers, user_data): stream = ffi.new('struct bladerf_stream*[1]') buffers = ffi.new('void**[1]') err = _cffi.lib.bladerf_init_stream( stream, dev, callback, buffers, num_buffers, format, num_samples, num_transfers, user_data) bladeRF.errors.check_retcode(err) return (stream[0], buffers[0])
def get_fpga_size(dev): size = ffi.new('bladerf_fpga_size *') err = _cffi.lib.bladerf_get_fpga_size(dev, size) bladeRF.errors.check_retcode(err) return int(size[0])
def xb200_get_filterbank(dev,module): filter = ffi.new('bladerf_xb200_filter *') err = _cffi.lib.bladerf_xb200_get_filterbank(dev,module,filter) bladeRF.errors.check_retcode(err) return int(filter[0])
def set_sample_rate(dev, module, rate): actual = ffi.new('unsigned int*') err = _cffi.lib.bladerf_set_sample_rate(dev, module, int(rate), actual) bladeRF.errors.check_retcode(err) return int(actual[0])
def get_lpf_mode(dev, module): mode = ffi.new('bladerf_lpf_mode *') err = _cffi.lib.bladerf_get_lpf_mode(dev, module, mode) bladeRF.errors.check_retcode(err) return int(mode[0])
def set_bandwidth(dev, module, bandwidth): actual = ffi.new('unsigned int *') err = _cffi.lib.bladerf_set_bandwidth(dev, module, bandwidth, actual) bladeRF.errors.check_retcode(err) return int(actual[0])
def get_lna_gain(dev): gain = ffi.new('bladerf_lna_gain *') err = _cffi.lib.bladerf_get_lna_gain(dev, gain) bladeRF.errors.check_retcode(err) return int(gain[0])
def get_sampling(dev): sampling = ffi.new('bladerf_sampling*') err = _cffi.lib.bladerf_get_sampling(dev, sampling) bladeRF.errors.check_retcode(err) return int(sampling[0])
def get_rxvga2(dev): gain = ffi.new('int *') err = _cffi.lib.bladerf_get_rxvga2(dev, gain) bladeRF.errors.check_retcode(err) return int(gain[0])
def get_sample_rate(dev, module): rate = ffi.new('unsigned int *') err = _cffi.lib.bladerf_get_sample_rate(dev, module, rate) bladeRF.errors.check_retcode(err) return int(rate[0])
pg.setConfigOptions(antialias=True) # Graph Area spec_plot = pg.GraphicsLayoutWidget() # Spectrum Plot p1 = spec_plot.addPlot() p1.showGrid(x=True, y=True) p1.setLabel("bottom", "Frequency (Hz)") p1.setLabel("left", "Power (dBFS)") p1_data = p1.plot([0]) p1_freq_range = np.linspace( device.rx.frequency - device.rx.sample_rate / 2.0, device.rx.frequency + device.rx.sample_rate / 2.0, nFFT ) metadata = ffi.new("struct bladerf_metadata [1]") metadata[0].flags = bladeRF.BLADERF_META_FLAG_RX_NOW def update(): global metadata, averaging_buffer samples = device.rx(buffer_size, metadata=metadata, timeout_ms=timeout_ms) num_samples = metadata[0].actual_count metadata[0].timestamp = 0 data = bladeRF.samples_to_narray(samples, num_samples) data = data[:nFFT] try: # For some reason we seem to get a lot of NaNs in our received sample data. # This is a bit of a hack to avoid allowing any NaN values into our averaging array. data_fft = np.fft.fftshift(10 * np.log10(np.abs(np.fft.fft(data ** 2.0)))) if not np.isnan(data_fft).any():
def get_transfer_timeout(dev, module): timeout = ffi.new('unsigned int*') err = _cffi.lib.bladerf_get_transfer_timeout(dev, module, timeout) bladeRF.errors.check_retcode(err) return timeout[0]
def xb200_get_path(dev,module): path = ffi.new('bladerf_xb200_path *') err = _cffi.lib.bladerf_xb200_get_path(dev,module,path) bladeRF.errors.check_retcode(err) return int(path[0])
def get_bandwidth(dev, module): bandwidth = ffi.new('unsigned int *') err = _cffi.lib.bladerf_get_bandwidth(dev, module, bandwidth) bladeRF.errors.check_retcode(err) return int(bandwidth[0])
def get_frequency(dev, module): frequency = ffi.new('unsigned int *') err = _cffi.lib.bladerf_get_frequency(dev, module, frequency) bladeRF.errors.check_retcode(err) return int(frequency[0])
def expansion_get_attached(dev): xb = ffi.new('bladerf_xb *') err = _cffi.lib.bladerf_expansion_get_attached(dev, xb) bladeRF.errors.check_retcode(err) return int(xb[0])