brozek/py-hackrf-ctypes
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
py-hackrf-ctypes/pylibhackrf.py

540 lines
21 KiB
Python
Raw Normal View History

push
2014-12-24 23:04:37 -05:00
from ctypes import *
import logging
fix some bugs
2015-01-02 09:40:05 -05:00
import os
import numpy as np
push
2014-12-24 23:04:37 -05:00
try:
from itertools import izip
except ImportError:
izip = zip
path = os.path.dirname(__file__)
logging.basicConfig()
logger = logging.getLogger('HackRf Core')
logger.setLevel(logging.DEBUG)
libhackrf = CDLL('/usr/local/lib/libhackrf.so')
def enum(*sequential, **named):
enums = dict(zip(sequential, range(len(sequential))), **named)
return type('Enum', (), enums)
HackRfVendorRequest = enum(
HACKRF_VENDOR_REQUEST_SET_TRANSCEIVER_MODE=1,
HACKRF_VENDOR_REQUEST_MAX2837_WRITE=2,
HACKRF_VENDOR_REQUEST_MAX2837_READ=3,
HACKRF_VENDOR_REQUEST_SI5351C_WRITE=4,
HACKRF_VENDOR_REQUEST_SI5351C_READ=5,
HACKRF_VENDOR_REQUEST_SAMPLE_RATE_SET=6,
HACKRF_VENDOR_REQUEST_BASEBAND_FILTER_BANDWIDTH_SET=7,
HACKRF_VENDOR_REQUEST_RFFC5071_WRITE=8,
HACKRF_VENDOR_REQUEST_RFFC5071_READ=9,
HACKRF_VENDOR_REQUEST_SPIFLASH_ERASE=10,
HACKRF_VENDOR_REQUEST_SPIFLASH_WRITE=11,
HACKRF_VENDOR_REQUEST_SPIFLASH_READ=12,
HACKRF_VENDOR_REQUEST_CPLD_WRITE=13,
HACKRF_VENDOR_REQUEST_BOARD_ID_READ=14,
HACKRF_VENDOR_REQUEST_VERSION_STRING_READ=15,
HACKRF_VENDOR_REQUEST_SET_FREQ=16,
HACKRF_VENDOR_REQUEST_AMP_ENABLE=17,
HACKRF_VENDOR_REQUEST_BOARD_PARTID_SERIALNO_READ=18,
HACKRF_VENDOR_REQUEST_SET_LNA_GAIN=19,
HACKRF_VENDOR_REQUEST_SET_VGA_GAIN=20,
HACKRF_VENDOR_REQUEST_SET_TXVGA_GAIN=21)
HackRfConstants = enum(
LIBUSB_ENDPOINT_IN=0x80,
LIBUSB_ENDPOINT_OUT=0x00,
HACKRF_DEVICE_OUT=0x40,
HACKRF_DEVICE_IN=0xC0,
HACKRF_USB_VID=0x1d50,
HACKRF_USB_PID=0x6089)
HackRfError = enum(
HACKRF_SUCCESS=0,
HACKRF_TRUE=1,
HACKRF_ERROR_INVALID_PARAM=-2,
HACKRF_ERROR_NOT_FOUND=-5,
HACKRF_ERROR_BUSY=-6,
HACKRF_ERROR_NO_MEM=-11,
HACKRF_ERROR_LIBUSB=-1000,
HACKRF_ERROR_THREAD=-1001,
HACKRF_ERROR_STREAMING_THREAD_ERR=-1002,
HACKRF_ERROR_STREAMING_STOPPED=-1003,
HACKRF_ERROR_STREAMING_EXIT_CALLED=-1004,
HACKRF_ERROR_OTHER=-9999,
# Python defaults to returning none
HACKRF_ERROR=None)
HackRfTranscieverMode = enum(
HACKRF_TRANSCEIVER_MODE_OFF=0,
HACKRF_TRANSCEIVER_MODE_RECEIVE=1,
HACKRF_TRANSCEIVER_MODE_TRANSMIT=2)
# Data structures
_libusb_device_handle = c_void_p
_pthread_t = c_ulong
class hackrf_device(Structure):
pass
class hackrf_transfer(Structure):
_fields_ = [("hackrf_device", POINTER(hackrf_device)),
("buffer", POINTER(c_uint8)),
("buffer_length", c_int),
("valid_length", c_int),
("rx_ctx", c_void_p),
("tx_ctx", c_void_p) ]
_callback = CFUNCTYPE(c_int, POINTER(hackrf_transfer))
hackrf_device._fields_ = [("usb_device", POINTER(_libusb_device_handle)),
("transfers", POINTER(POINTER(hackrf_transfer))),
("callback", _callback),
("transfer_thread_started", c_int),
("transfer_thread", _pthread_t),
("transfer_count", c_uint32),
("buffer_size", c_uint32),
("streaming", c_int),
("rx_ctx", c_void_p),
("tx_ctx", c_void_p) ]
# extern ADDAPI int ADDCALL hackrf_init();
libhackrf.hackrf_init.restype = c_int
libhackrf.hackrf_init.argtypes = []
# extern ADDAPI int ADDCALL hackrf_exit();
libhackrf.hackrf_exit.restype = c_int
libhackrf.hackrf_exit.argtypes = []
# extern ADDAPI int ADDCALL hackrf_open(hackrf_device** device);
libhackrf.hackrf_open.restype = c_int
libhackrf.hackrf_open.argtypes = [POINTER(POINTER(hackrf_device))]
# extern ADDAPI int ADDCALL hackrf_close(hackrf_device* device);
libhackrf.hackrf_close.restype = c_int
libhackrf.hackrf_close.argtypes = [POINTER(hackrf_device)]
# extern ADDAPI int ADDCALL hackrf_start_rx(hackrf_device* device,
# hackrf_sample_block_cb_fn callback, void* rx_ctx);
libhackrf.hackrf_start_rx.restype = c_int
libhackrf.hackrf_start_rx.argtypes = [POINTER(hackrf_device), _callback, c_void_p]
# extern ADDAPI int ADDCALL hackrf_stop_rx(hackrf_device* device);
libhackrf.hackrf_stop_rx.restype = c_int
libhackrf.hackrf_stop_rx.argtypes = [POINTER(hackrf_device)]
# extern ADDAPI int ADDCALL hackrf_start_tx(hackrf_device* device,
# hackrf_sample_block_cb_fn callback, void* tx_ctx);
libhackrf.hackrf_start_tx.restype = c_int
libhackrf.hackrf_start_tx.argtypes = [POINTER(hackrf_device), _callback, c_void_p]
# extern ADDAPI int ADDCALL hackrf_stop_tx(hackrf_device* device);
libhackrf.hackrf_stop_tx.restype = c_int
libhackrf.hackrf_stop_tx.argtypes = [POINTER(hackrf_device)]
# extern ADDAPI int ADDCALL hackrf_is_streaming(hackrf_device* device);
libhackrf.hackrf_is_streaming.restype = c_int
libhackrf.hackrf_is_streaming.argtypes = [POINTER(hackrf_device)]
# extern ADDAPI int ADDCALL hackrf_max2837_read(hackrf_device* device,
# uint8_t register_number, uint16_t* value);
libhackrf.hackrf_max2837_read.restype = c_int
libhackrf.hackrf_max2837_read.argtypes = [
POINTER(hackrf_device), c_uint8, POINTER(c_uint16)]
# extern ADDAPI int ADDCALL hackrf_max2837_write(hackrf_device* device,
# uint8_t register_number, uint16_t value);
libhackrf.hackrf_max2837_write.restype = c_int
libhackrf.hackrf_max2837_write.argtypes = [POINTER(hackrf_device), c_uint8, c_uint16]
# extern ADDAPI int ADDCALL hackrf_si5351c_read(hackrf_device* device,
# uint16_t register_number, uint16_t* value);
libhackrf.hackrf_si5351c_read.restype = c_int
libhackrf.hackrf_si5351c_read.argtypes = [
POINTER(hackrf_device), c_uint16, POINTER(c_uint16)]
# extern ADDAPI int ADDCALL hackrf_si5351c_write(hackrf_device* device,
# uint16_t register_number, uint16_t value);
libhackrf.hackrf_si5351c_write.restype = c_int
libhackrf.hackrf_si5351c_write.argtypes = [POINTER(hackrf_device), c_uint16, c_uint16]
# extern ADDAPI int ADDCALL
# hackrf_set_baseband_filter_bandwidth(hackrf_device* device, const
# uint32_t bandwidth_hz);
libhackrf.hackrf_set_baseband_filter_bandwidth.restype = c_int
libhackrf.hackrf_set_baseband_filter_bandwidth.argtypes = [
POINTER(hackrf_device), c_uint32]
# extern ADDAPI int ADDCALL hackrf_rffc5071_read(hackrf_device* device,
# uint8_t register_number, uint16_t* value);
libhackrf.hackrf_rffc5071_read.restype = c_int
libhackrf.hackrf_rffc5071_read.argtypes = [
POINTER(hackrf_device), c_uint8, POINTER(c_uint16)]
# extern ADDAPI int ADDCALL hackrf_rffc5071_write(hackrf_device*
# device, uint8_t register_number, uint16_t value);
libhackrf.hackrf_rffc5071_write.restype = c_int
libhackrf.hackrf_rffc5071_write.argtypes = [POINTER(hackrf_device), c_uint8, c_uint16]
# extern ADDAPI int ADDCALL hackrf_spiflash_erase(hackrf_device*
# device);
libhackrf.hackrf_spiflash_erase.restype = c_int
libhackrf.hackrf_spiflash_erase.argtypes = [POINTER(hackrf_device)]
# extern ADDAPI int ADDCALL hackrf_spiflash_write(hackrf_device*
# device, const uint32_t address, const uint16_t length, unsigned char*
# const data);
libhackrf.hackrf_spiflash_write.restype = c_int
libhackrf.hackrf_spiflash_write.argtypes = [
POINTER(hackrf_device), c_uint32, c_uint16, POINTER(c_ubyte)]
# extern ADDAPI int ADDCALL hackrf_spiflash_read(hackrf_device* device,
# const uint32_t address, const uint16_t length, unsigned char* data);
libhackrf.hackrf_spiflash_read.restype = c_int
libhackrf.hackrf_spiflash_read.argtypes = [
POINTER(hackrf_device), c_uint32, c_uint16, POINTER(c_ubyte)]
# extern ADDAPI int ADDCALL hackrf_cpld_write(hackrf_device* device,
# unsigned char* const data, const unsigned int total_length);
libhackrf.hackrf_cpld_write.restype = c_int
libhackrf.hackrf_cpld_write.argtypes = [POINTER(hackrf_device), POINTER(c_ubyte), c_uint]
# extern ADDAPI int ADDCALL hackrf_board_id_read(hackrf_device* device,
# uint8_t* value);
libhackrf.hackrf_board_id_read.restype = c_int
libhackrf.hackrf_board_id_read.argtypes = [POINTER(hackrf_device), POINTER(c_uint8)]
# extern ADDAPI int ADDCALL hackrf_version_string_read(hackrf_device*
# device, char* version, uint8_t length);
libhackrf.hackrf_version_string_read.restype = c_int
libhackrf.hackrf_version_string_read.argtypes = [POINTER(hackrf_device), POINTER(c_char), c_uint8]
# extern ADDAPI int ADDCALL hackrf_set_freq(hackrf_device* device,
# const uint64_t freq_hz);
libhackrf.hackrf_set_freq.restype = c_int
libhackrf.hackrf_set_freq.argtypes = [POINTER(hackrf_device), c_uint64]
# extern ADDAPI int ADDCALL hackrf_set_freq_explicit(hackrf_device* device,
# const uint64_t if_freq_hz, const uint64_t lo_freq_hz,
# const enum rf_path_filter path);,
# libhackrf.hackrf_set_freq_explicit.restype = c_int
# libhackrf.hackrf_set_freq_explicit.argtypes = [c_uint64,
# c_uint64, ]
# extern ADDAPI int ADDCALL
# hackrf_set_sample_rate_manual(hackrf_device* device, const uint32_t
# freq_hz, const uint32_t divider);
libhackrf.hackrf_set_sample_rate_manual.restype = c_int
libhackrf.hackrf_set_sample_rate_manual.argtypes = [
POINTER(hackrf_device), c_uint32, c_uint32]
# extern ADDAPI int ADDCALL hackrf_set_sample_rate(hackrf_device*
# device, const double freq_hz);
libhackrf.hackrf_set_sample_rate.restype = c_int
libhackrf.hackrf_set_sample_rate.argtypes = [POINTER(hackrf_device), c_double]
# extern ADDAPI int ADDCALL hackrf_set_amp_enable(hackrf_device*
# device, const uint8_t value);
libhackrf.hackrf_set_amp_enable.restype = c_int
libhackrf.hackrf_set_amp_enable.argtypes = [POINTER(hackrf_device), c_uint8]
# extern ADDAPI int ADDCALL
# hackrf_board_partid_serialno_read(hackrf_device* device,
# read_partid_serialno_t* read_partid_serialno);
libhackrf.hackrf_board_partid_serialno_read.restype = c_int
libhackrf.hackrf_board_partid_serialno_read.argtypes = [POINTER(hackrf_device)]
# extern ADDAPI int ADDCALL hackrf_set_lna_gain(hackrf_device* device,
# uint32_t value);
libhackrf.hackrf_set_lna_gain.restype = c_int
libhackrf.hackrf_set_lna_gain.argtypes = [POINTER(hackrf_device), c_uint32]
# extern ADDAPI int ADDCALL hackrf_set_vga_gain(hackrf_device* device,
# uint32_t value);
libhackrf.hackrf_set_vga_gain.restype = c_int
libhackrf.hackrf_set_vga_gain.argtypes = [POINTER(hackrf_device), c_uint32]
# extern ADDAPI int ADDCALL hackrf_set_txvga_gain(hackrf_device*
# device, uint32_t value);
libhackrf.hackrf_set_txvga_gain.restype = c_int
libhackrf.hackrf_set_txvga_gain.argtypes = [POINTER(hackrf_device), c_uint32]
# extern ADDAPI int ADDCALL hackrf_set_antenna_enable(hackrf_device*
# device, const uint8_t value);
libhackrf.hackrf_set_antenna_enable.restype = c_int
libhackrf.hackrf_set_antenna_enable.argtypes = [POINTER(hackrf_device), c_uint8]
# extern ADDAPI const char* ADDCALL hackrf_error_name(enum hackrf_error errcode);
# libhackrf.hackrf_error_name.restype = POINTER(c_char)
# libhackrf.hackrf_error_name.argtypes = []
# extern ADDAPI const char* ADDCALL hackrf_board_id_name(enum hackrf_board_id board_id);
# libhackrf.hackrf_board_id_name.restype = POINTER(c_char)
# libhackrf.hackrf_board_id_name.argtypes = []
# extern ADDAPI const char* ADDCALL hackrf_filter_path_name(const enum rf_path_filter path);
# libhackrf.hackrf_filter_path_name.restype = POINTER(c_char)
# libhackrf.hackrf_filter_path_name.argtypes = []
# extern ADDAPI uint32_t ADDCALL
# hackrf_compute_baseband_filter_bw_round_down_lt(const uint32_t
# bandwidth_hz);
libhackrf.hackrf_compute_baseband_filter_bw_round_down_lt.restype = c_uint32
fix some bugs
2015-01-02 09:40:05 -05:00
libhackrf.hackrf_compute_baseband_filter_bw_round_down_lt.argtypes = [c_uint32]
push
2014-12-24 23:04:37 -05:00
# extern ADDAPI uint32_t ADDCALL
# hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz);
libhackrf.hackrf_compute_baseband_filter_bw.restype = c_uint32
fix some bugs
2015-01-02 09:40:05 -05:00
libhackrf.hackrf_compute_baseband_filter_bw.argtypes = [c_uint32]
push
2014-12-24 23:04:37 -05:00
class HackRf(object):
fix some bugs
2015-01-02 09:40:05 -05:00
__JELLYBEAN__ = 'Jellybean'
__JAWBREAKER__ = 'Jawbreaker'
__ONE = 'HackRF ONE'
NAME_LIST = [__JELLYBEAN__, __JAWBREAKER__, __ONE]
push
2014-12-24 23:04:37 -05:00
def __init__(self):
self.device = POINTER(hackrf_device)()
self.callback = None
self.is_open = False
def __del__(self):
if self.is_open == True:
self.exit()
def setup(self):
libhackrf.hackrf_init()
return self.open()
def exit(self):
ret = self.close()
libhackrf.hackrf_exit()
return ret
def open(self):
fix some bugs
2015-01-02 09:40:05 -05:00
ret = libhackrf.hackrf_open(self.device)
push
2014-12-24 23:04:37 -05:00
if ret == HackRfError.HACKRF_SUCCESS:
self.is_open = True
logger.debug('Successfully open HackRf device')
return HackRfError.HACKRF_SUCCESS
else:
logger.error('No Hack Rf Detected!')
def close(self):
ret = libhackrf.hackrf_close(self.device)
if ret == HackRfError.HACKRF_SUCCESS:
self.is_open = False
logger.debug('Successfully close HackRf device')
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Failed to close!')
def start_rx_mode(self, set_callback):
self.callback = _callback(set_callback)
ret = libhackrf.hackrf_start_rx(self.device, self.callback, None)
if ret == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully start HackRf in Recieve Mode')
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Failed to start HackRf in Recieve Mode')
def stop_rx_mode(self):
ret = libhackrf.hackrf_stop_rx(self.device)
if ret == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully stop HackRf in Recieve Mode')
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Failed to stop HackRf in Recieve Mode')
return ret
def start_tx_mode(self, set_callback):
self.callback = _callback(set_callback)
ret = libhackrf.hackrf_start_tx(self.device, self.callback, None)
if ret == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully start HackRf in Transfer Mode')
return HackRfError.HACKRF_SUCCESS
else:
License
2014-12-26 07:29:28 -05:00
logger.error('Failed to start HackRf in Transfer Mode')
push
2014-12-24 23:04:37 -05:00
def stop_tx_mode(self):
ret = libhackrf.hackrf_stop_tx(self.device)
if ret == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully stop HackRf in Transfer Mode')
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Failed to stop HackRf in Transfer Mode')
def board_id_read(self):
value = c_uint8()
ret = libhackrf.hackrf_board_id_read(self.device, byref(value))
if ret == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully got Board Id')
return value.value
else:
logger.error('Failed to get Board Id')
def version_string_read(self): #POINTER(c_char), c_uint8
version = create_string_buffer(20)
lenth = c_uint8(20)
ret = libhackrf.hackrf_version_string_read(self.device, version, lenth)
if ret == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully got HackRf Version String')
return version.value
else:
logger.error('Failed to get Version String')
def set_freq(self, freq_hz):
ret = libhackrf.hackrf_set_freq(self.device, freq_hz)
if ret == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully set frequency with value [%d]', freq_hz)
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Error setting frequency with value [%d]', freq_hz)
def is_streaming(self):
ret = libhackrf.hackrf_is_streaming(self.device)
if(ret == 1):
return True
else:
return False
def set_lna_gain(self, value):
fix some bugs
2015-01-02 09:40:05 -05:00
''' Sets the LNA gain, in 8Db steps, maximum value of 40 '''
push
2014-12-24 23:04:37 -05:00
result = libhackrf.hackrf_set_lna_gain(self.device, value)
if result == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully set LNA gain to [%d]', value)
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Failed to set LNA gain to [%d]', value)
def set_vga_gain(self, value):
fix some bugs
2015-01-02 09:40:05 -05:00
''' Sets the vga gain, in 2db steps, maximum value of 62 '''
push
2014-12-24 23:04:37 -05:00
result = libhackrf.hackrf_set_vga_gain(self.device, value)
if result == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully set VGA gain to [%d]', value)
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Failed to set VGA gain to [%d]', value)
def set_txvga_gain(self, value):
fix some bugs
2015-01-02 09:40:05 -05:00
''' Sets the txvga gain, in 1db steps, maximum value of 47 '''
push
2014-12-24 23:04:37 -05:00
result = libhackrf.hackrf_set_txvga_gain(self.device, value)
if result == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully set TXVGA gain to [%d]', value)
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Failed to set TXVGA gain to [%d]', value)
def set_antenna_enable(self, value):
if value == True:
val = 1
else:
val = 0
result = libhackrf.hackrf_set_antenna_enable(self.device, val)
if result == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully set antenna_enable')
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Failed to set antenna_enable')
def set_sample_rate(self, freq):
result = libhackrf.hackrf_set_sample_rate(self.device, freq)
if result != HackRfError.HACKRF_SUCCESS:
logger.error('Error setting Sample Rate with Frequency [%d]', freq)
else:
logger.debug(
'Successfully set Sample Rate with Frequency [%d]', freq)
return HackRfError.HACKRF_SUCCESS
def set_amp_enable(self, value):
if value == True:
val = 1
else:
val = 0
result = libhackrf.hackrf_set_amp_enable(self.device, val)
if result == HackRfError.HACKRF_SUCCESS:
logger.debug('Successfully set amp')
return HackRfError.HACKRF_SUCCESS
else:
logger.error('Failed to set amp')
def set_baseband_filter_bandwidth(self, bandwidth_hz):
result = libhackrf.hackrf_set_baseband_filter_bandwidth(self.device, bandwidth_hz)
if result != HackRfError.HACKRF_SUCCESS:
logger.error(
'Failed to set Baseband Filter Bandwidth with value [%d]', bandwidth_hz)
else:
logger.debug(
'Successfully set Baseband Filter Bandwidth with value [%d]', bandwidth_hz)
return HackRfError.HACKRF_SUCCESS
def max2837_read(self, register_number, value):
pass
return libhackrf.hackrf_max2837_read(self.device, register_number, value)
def max2837_weite(self, register_number, value):
pass
return libhackrf.hackrf_max2837_weite(self.device, register_number, value)
def si5351c_read(self, register_number, value):
pass
return libhackrf.hackrf_si5351c_read(self.device, register_number, value)
def si5351c_write(self, register_number, value):
pass
return libhackrf.hackrf_si5351c_write(self.device, register_number, value)
def rffc5071_read(self, register_number, value):
pass
return libhackrf.hackrf_rffc5071_read(self.device, register_number, value)
def rffc5071_write(self, register_number, value):
pass
return libhackrf.hackrf_rffc5071_write(self.device, register_number, value)
def spiflash_erase(self):
pass
return libhackrf.hackrf_spiflash_erase(self.device)
def spiflash_write(self, address, length, data):
pass
return libhackrf.hackrf_spiflash_write(self.device, address, length, data)
def spiflash_read(self, address, length, data):
pass
return libhackrf.hackrf_spiflash_read(self.device, address, length, data)
def cpld_write(self, data, total_length):
pass
return libhackrf.hackrf_cpld_write(self.device, data, total_length)
def set_sample_rate_manual(self, freq_hz, divider):
pass
return libhackrf.hackrf_set_sample_rate_manual(self.device, freq_hz, divider)
def compute_baseband_filter_bw_round_down_lt(self, bandwidth_hz):
pass
fix some bugs
2015-01-02 09:40:05 -05:00
return libhackrf.hackrf_compute_baseband_filter_bw_round_down_lt(bandwidth_hz)
push
2014-12-24 23:04:37 -05:00
def compute_baseband_filter_bw(self, bandwidth_hz):
pass
fix some bugs
2015-01-02 09:40:05 -05:00
return libhackrf.hackrf_compute_baseband_filter_bw(bandwidth_hz)
push
2014-12-24 23:04:37 -05:00
# def hackrf_set_freq_explicit(self, if_freq_hz, lo_freq_hz, path):
# pass
# return libhackrf.hackrf_set_freq_explicit(if_freq_hz, lo_freq_hz, path)
# def hackrf_board_partid_serialno_read(self, read_partid_serialno):
# pass
# return libhackrf.hackrf_board_partid_serialno_read(read_partid_serialno)
# def hackrf_error_name(self, errcode):
# pass
# return libhackrf.hackrf_error_name(errcode)
# def hackrf_board_id_name(self, board_id):
# pass
# return libhackrf.hackrf_board_id_name(board_id)
# def hackrf_filter_path_name(self, path):
# pass
# return libhackrf.hackrf_filter_path_name(path)
# out[0] = (out[0] - 127)*(1.0/128);
def packed_bytes_to_iq(self, bytes):
fix some bugs
2015-01-02 09:40:05 -05:00
''' Convenience function to unpack array of bytes to Python list/array
of complex numbers and normalize range. size 16*32*512 262 144
'''
# use NumPy array
iq = np.empty(len(bytes)//2, 'complex')
iq.real, iq.imag = bytes[::2], bytes[1::2]
iq /= (255/2)
iq -= (1 + 1j)
return iq
def packed_bytes_to_iq_withsize(self, bytes, size):
push
2014-12-24 23:04:37 -05:00
''' Convenience function to unpack array of bytes to Python list/array
of complex numbers and normalize range.
'''
fix some bugs
2015-01-02 09:40:05 -05:00
# use NumPy array
iq = np.empty(size , 'complex')
bytes2 = bytes[0:size * 2]
iq.real, iq.imag = bytes2[::2], bytes2[1::2]
iq /= (255/2)
iq -= (1 + 1j)
push
2014-12-24 23:04:37 -05:00
return iq
Reference in a new issue Copy permalink