PY_HACKRF_OPERACAKE_MAX_DWELL_TIMES = chackrf.HACKRF_OPERACAKE_MAX_DWELL_TIMES

PY_HACKRF_OPERACAKE_MAX_FREQ_RANGES = chackrf.HACKRF_OPERACAKE_MAX_FREQ_RANGES

class py_rf_path_filter(IntEnum):

RF_PATH_FILTER_BYPASS = chackrf.rf_path_filter.RF_PATH_FILTER_BYPASS

RF_PATH_FILTER_LOW_PASS = chackrf.rf_path_filter.RF_PATH_FILTER_LOW_PASS

def __str__(self) -> str:

return self.name

class py_sweep_style(IntEnum):

LINEAR = chackrf.sweep_style.LINEAR

INTERLEAVED = chackrf.sweep_style.INTERLEAVED

def __str__(self) -> str:

return self.name

class py_operacake_switching_mode(IntEnum):

OPERACAKE_MODE_MANUAL = chackrf.operacake_switching_mode.OPERACAKE_MODE_MANUAL

OPERACAKE_MODE_FREQUENCY = chackrf.operacake_switching_mode.OPERACAKE_MODE_FREQUENCY

def __str__(self) -> str:

return self.name

class py_operacake_ports(IntEnum):

A1: 0

A2: 1

return item in cls

return False

@cython.boundscheck(False)

@cython.wraparound(False)

cdef int __rx_callback(chackrf.hackrf_transfer *transfer) nogil:

return result

@cython.boundscheck(False)

@cython.wraparound(False)

cdef int __tx_callback(chackrf.hackrf_transfer *transfer) nogil:

return result

@cython.boundscheck(False)

@cython.wraparound(False)

cdef int __sweep_callback(chackrf.hackrf_transfer *transfer) nogil:

return result

@cython.boundscheck(False)

@cython.wraparound(False)

cdef void __tx_complete_callback(chackrf.hackrf_transfer *transfer, int success) nogil:

if global_callbacks[<size_t> transfer.device]['__tx_complete_callback'] is not None:

global_callbacks[<size_t> transfer.device]['__tx_complete_callback'](global_callbacks[<size_t> transfer.device]['device'], np_buffer, transfer.buffer_length, transfer.valid_length, success)

cdef void __tx_flush_callback(void *flush_ctx, int success) noexcept nogil:

global global_callbacks

cdef size_t device_ptr = <size_t> flush_ctx

if global_callbacks[device_ptr]['__tx_flush_callback'] is not None:

global_callbacks[device_ptr]['__tx_flush_callback'](global_callbacks[device_ptr]['device'], success)

cdef class PyHackRFDeviceList:

cdef chackrf.hackrf_device_list_t *__hackrf_device_list

if self.__hackrf_device_list is not NULL:

return chackrf.hackrf_board_id_name(self.__hackrf_device_list[0].usb_board_ids[index]).decode('utf-8')

cdef class PyHackrfDevice:

cdef chackrf.hackrf_device *__hackrf_device

raise RuntimeError(f'pyhackrf_operacake_gpio_test() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')

return test_result

# ---- initialization and exit ---- #

def pyhackrf_init() -> None:

result = chackrf.hackrf_init()

if result != chackrf.hackrf_error.HACKRF_SUCCESS:

raise RuntimeError(f'pyhackrf_init() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')

def pyhackrf_exit() -> None:

result = chackrf.hackrf_exit()

if result != chackrf.hackrf_error.HACKRF_SUCCESS:

raise RuntimeError(f'pyhackrf_exit() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')

# ---- version ---- #

def python_hackrf_library_version() -> str:

return __version__

def pyhackrf_library_version() -> str:

return chackrf.hackrf_library_version().decode('utf-8')

def pyhackrf_library_release() -> str:

return chackrf.hackrf_library_release().decode('utf-8')

# ---- device ---- #

def pyhackrf_device_list() -> PyHackRFDeviceList:

return PyHackRFDeviceList()

def pyhackrf_device_list_open(pyhackrf_device_list: PyHackRFDeviceList, index: int) -> PyHackrfDevice | None:

pyhackrf_device = PyHackrfDevice()

result = chackrf.hackrf_device_list_open(pyhackrf_device_list.get_hackrf_device_list_ptr(), index, pyhackrf_device.get_hackrf_device_double_ptr())

raise RuntimeError(f'pyhackrf_device_list_open() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')

def pyhackrf_open() -> PyHackrfDevice | None:

pyhackrf_device = PyHackrfDevice()

raise RuntimeError(f'pyhackrf_open() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')

def pyhackrf_open_by_serial(desired_serial_number: str) -> PyHackrfDevice | None:

if desired_serial_number in (None, ''):

return pyhackrf_open()

raise RuntimeError(f'pyhackrf_open_by_serial() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')

def pyhackrf_compute_baseband_filter_bw_round_down_lt(bandwidth_hz: int) -> int:

return chackrf.hackrf_compute_baseband_filter_bw_round_down_lt(<uint32_t> bandwidth_hz)

def pyhackrf_compute_baseband_filter_bw(bandwidth_hz: int) -> int:

return chackrf.hackrf_compute_baseband_filter_bw(<uint32_t> bandwidth_hz)