libhackrf: /tmp/host/libhackrf/src/hackrf.h Source File

libhackrf HackRF SDR platform library

hackrf.h
1/*
2Copyright (c) 2012-2022 Great Scott Gadgets <info@greatscottgadgets.com>
3Copyright (c) 2012, Jared Boone <jared@sharebrained.com>
4Copyright (c) 2013, Benjamin Vernoux <titanmkd@gmail.com>
5
6All rights reserved.
7
8Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
9
10 Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
11 Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the
12 documentation and/or other materials provided with the distribution.
13 Neither the name of Great Scott Gadgets nor the names of its contributors may be used to endorse or promote products derived from this software
14 without specific prior written permission.
15
16THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
21ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22*/
23
24#ifndef __HACKRF_H__
25#define __HACKRF_H__
26
27#include <stdint.h>
28#include <sys/types.h>
29#include <stdbool.h> // for bool
30#ifdef _WIN32
31 #define ADD_EXPORTS
32
33 /* You should define ADD_EXPORTS *only* when building the DLL. */
34 #ifdef ADD_EXPORTS
35 #define ADDAPI __declspec(dllexport)
36 #else
37 #define ADDAPI __declspec(dllimport)
38 #endif
39
40 /* Define calling convention in one place, for convenience. */
41 #define ADDCALL __cdecl
42
43#else /* _WIN32 not defined. */
44
45 #define ADDAPI
46 #define ADDCALL
47
48#endif
49
512#define SAMPLES_PER_BLOCK 8192
513
518#define BYTES_PER_BLOCK 16384
519
524#define MAX_SWEEP_RANGES 10
525
530#define HACKRF_OPERACAKE_ADDRESS_INVALID 0xFF
531
536#define HACKRF_OPERACAKE_MAX_BOARDS 8
537
542#define HACKRF_OPERACAKE_MAX_DWELL_TIMES 16
543
548#define HACKRF_OPERACAKE_MAX_FREQ_RANGES 8
549
556 enum hackrf_error {
560 HACKRF_SUCCESS = 0,
564 HACKRF_TRUE = 1,
568 HACKRF_ERROR_INVALID_PARAM = -2,
572 HACKRF_ERROR_NOT_FOUND = -5,
576 HACKRF_ERROR_BUSY = -6,
580 HACKRF_ERROR_NO_MEM = -11,
584 HACKRF_ERROR_LIBUSB = -1000,
588 HACKRF_ERROR_THREAD = -1001,
592 HACKRF_ERROR_STREAMING_THREAD_ERR = -1002,
596 HACKRF_ERROR_STREAMING_STOPPED = -1003,
600 HACKRF_ERROR_STREAMING_EXIT_CALLED = -1004,
604 HACKRF_ERROR_USB_API_VERSION = -1005,
608 HACKRF_ERROR_NOT_LAST_DEVICE = -2000,
612 HACKRF_ERROR_OTHER = -9999,
613};
614
619#define HACKRF_BOARD_REV_GSG (0x80)
620
625#define HACKRF_PLATFORM_JAWBREAKER (1 << 0)
630#define HACKRF_PLATFORM_HACKRF1_OG (1 << 1)
635#define HACKRF_PLATFORM_RAD1O (1 << 2)
640#define HACKRF_PLATFORM_HACKRF1_R9 (1 << 3)
641
648 enum hackrf_board_id {
652 BOARD_ID_JELLYBEAN = 0,
656 BOARD_ID_JAWBREAKER = 1,
660 BOARD_ID_HACKRF1_OG = 2,
664 BOARD_ID_RAD1O = 3,
668 BOARD_ID_HACKRF1_R9 = 4,
672 BOARD_ID_UNRECOGNIZED = 0xFE,
676 BOARD_ID_UNDETECTED = 0xFF,
677};
678
683#define BOARD_ID_HACKRF_ONE (BOARD_ID_HACKRF1_OG)
688#define BOARD_ID_INVALID (BOARD_ID_UNDETECTED)
689
696 enum hackrf_board_rev {
700 BOARD_REV_HACKRF1_OLD = 0,
704 BOARD_REV_HACKRF1_R6 = 1,
708 BOARD_REV_HACKRF1_R7 = 2,
712 BOARD_REV_HACKRF1_R8 = 3,
716 BOARD_REV_HACKRF1_R9 = 4,
720 BOARD_REV_HACKRF1_R10 = 5,
721
725 BOARD_REV_GSG_HACKRF1_R6 = 0x81,
729 BOARD_REV_GSG_HACKRF1_R7 = 0x82,
733 BOARD_REV_GSG_HACKRF1_R8 = 0x83,
737 BOARD_REV_GSG_HACKRF1_R9 = 0x84,
741 BOARD_REV_GSG_HACKRF1_R10 = 0x85,
742
746 BOARD_REV_UNRECOGNIZED = 0xFE,
750 BOARD_REV_UNDETECTED = 0xFF,
751};
752
760 enum hackrf_usb_board_id {
764 USB_BOARD_ID_JAWBREAKER = 0x604B,
768 USB_BOARD_ID_HACKRF_ONE = 0x6089,
772 USB_BOARD_ID_RAD1O = 0xCC15,
776 USB_BOARD_ID_INVALID = 0xFFFF,
777};
778
786 enum rf_path_filter {
790 RF_PATH_FILTER_BYPASS = 0,
794 RF_PATH_FILTER_LOW_PASS = 1,
798 RF_PATH_FILTER_HIGH_PASS = 2,
799};
800
805 enum operacake_ports {
806 OPERACAKE_PA1 = 0,
807 OPERACAKE_PA2 = 1,
808 OPERACAKE_PA3 = 2,
809 OPERACAKE_PA4 = 3,
810 OPERACAKE_PB1 = 4,
811 OPERACAKE_PB2 = 5,
812 OPERACAKE_PB3 = 6,
813 OPERACAKE_PB4 = 7,
814};
815
820 enum operacake_switching_mode {
824 OPERACAKE_MODE_MANUAL,
828 OPERACAKE_MODE_FREQUENCY,
832 OPERACAKE_MODE_TIME,
833};
834
843 enum sweep_style {
847 LINEAR = 0,
851 INTERLEAVED = 1,
852};
853
858 typedef struct hackrf_device hackrf_device;
859
867 typedef struct {
869 hackrf_device* device;
871 uint8_t* buffer;
873 int buffer_length;
875 int valid_length;
877 void* rx_ctx;
879 void* tx_ctx;
880} hackrf_transfer;
881
886 typedef struct {
890 uint32_t part_id[2];
894 uint32_t serial_no[4];
895} read_partid_serialno_t;
896
901 typedef struct {
905 uint32_t dwell;
909 uint8_t port;
910} hackrf_operacake_dwell_time;
911
916 typedef struct {
920 uint16_t freq_min;
924 uint16_t freq_max;
928 uint8_t port;
929} hackrf_operacake_freq_range;
930
935 typedef struct {
936 bool do_update;
937 bool change_on_mode_entry;
938 bool enabled;
939} hackrf_bool_user_settting;
940
947 typedef struct {
948 hackrf_bool_user_settting tx;
949 hackrf_bool_user_settting rx;
950 hackrf_bool_user_settting off;
951} hackrf_bias_t_user_settting_req;
952
957 typedef struct {
959 uint16_t requested_mode;
961 uint16_t request_flag;
963 uint32_t active_mode;
965 uint32_t m0_count;
967 uint32_t m4_count;
969 uint32_t num_shortfalls;
971 uint32_t longest_shortfall;
973 uint32_t shortfall_limit;
975 uint32_t threshold;
977 uint32_t next_mode;
979 uint32_t error;
980} hackrf_m0_state;
981
988 struct hackrf_device_list {
992 char** serial_numbers;
996 enum hackrf_usb_board_id* usb_board_ids;
1000 int* usb_device_index;
1001
1005 int devicecount;
1006
1010 void** usb_devices;
1014 int usb_devicecount;
1015};
1016
1017typedef struct hackrf_device_list hackrf_device_list_t;
1018
1031 typedef int (*hackrf_sample_block_cb_fn)(hackrf_transfer* transfer);
1032
1039 typedef void (*hackrf_tx_block_complete_cb_fn)(hackrf_transfer* transfer, int);
1040
1047 typedef void (*hackrf_flush_cb_fn)(void* flush_ctx, int);
1048
1049#ifdef __cplusplus
1050extern "C" {
1051#endif
1052
1060 extern ADDAPI int ADDCALL hackrf_init();
1061
1069 extern ADDAPI int ADDCALL hackrf_exit();
1070
1078 extern ADDAPI const char* ADDCALL hackrf_library_version();
1079
1087 extern ADDAPI const char* ADDCALL hackrf_library_release();
1088
1094 extern ADDAPI hackrf_device_list_t* ADDCALL hackrf_device_list();
1095
1104 extern ADDAPI int ADDCALL hackrf_device_list_open(
1105 hackrf_device_list_t* list,
1106 int idx,
1107 hackrf_device** device);
1108
1114 extern ADDAPI void ADDCALL hackrf_device_list_free(hackrf_device_list_t* list);
1115
1122 extern ADDAPI int ADDCALL hackrf_open(hackrf_device** device);
1123
1131 extern ADDAPI int ADDCALL hackrf_open_by_serial(
1132 const char* const desired_serial_number,
1133 hackrf_device** device);
1134
1141 extern ADDAPI int ADDCALL hackrf_close(hackrf_device* device);
1142
1155 extern ADDAPI int ADDCALL hackrf_start_rx(
1156 hackrf_device* device,
1157 hackrf_sample_block_cb_fn callback,
1158 void* rx_ctx);
1159
1167 extern ADDAPI int ADDCALL hackrf_stop_rx(hackrf_device* device);
1168
1183 extern ADDAPI int ADDCALL hackrf_start_tx(
1184 hackrf_device* device,
1185 hackrf_sample_block_cb_fn callback,
1186 void* tx_ctx);
1187
1198 extern ADDAPI int ADDCALL hackrf_set_tx_block_complete_callback(
1199 hackrf_device* device,
1200 hackrf_tx_block_complete_cb_fn callback);
1201
1213 extern ADDAPI int ADDCALL hackrf_enable_tx_flush(
1214 hackrf_device* device,
1215 hackrf_flush_cb_fn callback,
1216 void* flush_ctx);
1217
1225 extern ADDAPI int ADDCALL hackrf_stop_tx(hackrf_device* device);
1226
1236 extern ADDAPI int ADDCALL hackrf_get_m0_state(
1237 hackrf_device* device,
1238 hackrf_m0_state* value);
1239
1251 extern ADDAPI int ADDCALL hackrf_set_tx_underrun_limit(
1252 hackrf_device* device,
1253 uint32_t value);
1254
1266 extern ADDAPI int ADDCALL hackrf_set_rx_overrun_limit(
1267 hackrf_device* device,
1268 uint32_t value);
1269
1277 extern ADDAPI int ADDCALL hackrf_is_streaming(hackrf_device* device);
1278
1290 extern ADDAPI int ADDCALL hackrf_max2837_read(
1291 hackrf_device* device,
1292 uint8_t register_number,
1293 uint16_t* value);
1294
1306 extern ADDAPI int ADDCALL hackrf_max2837_write(
1307 hackrf_device* device,
1308 uint8_t register_number,
1309 uint16_t value);
1310
1322 extern ADDAPI int ADDCALL hackrf_si5351c_read(
1323 hackrf_device* device,
1324 uint16_t register_number,
1325 uint16_t* value);
1326
1338 extern ADDAPI int ADDCALL hackrf_si5351c_write(
1339 hackrf_device* device,
1340 uint16_t register_number,
1341 uint16_t value);
1342
1356 extern ADDAPI int ADDCALL hackrf_set_baseband_filter_bandwidth(
1357 hackrf_device* device,
1358 const uint32_t bandwidth_hz);
1359
1371 extern ADDAPI int ADDCALL hackrf_rffc5071_read(
1372 hackrf_device* device,
1373 uint8_t register_number,
1374 uint16_t* value);
1375
1387 extern ADDAPI int ADDCALL hackrf_rffc5071_write(
1388 hackrf_device* device,
1389 uint8_t register_number,
1390 uint16_t value);
1391
1401 extern ADDAPI int ADDCALL hackrf_spiflash_erase(hackrf_device* device);
1402
1415 extern ADDAPI int ADDCALL hackrf_spiflash_write(
1416 hackrf_device* device,
1417 const uint32_t address,
1418 const uint16_t length,
1419 unsigned char* const data);
1420
1433 extern ADDAPI int ADDCALL hackrf_spiflash_read(
1434 hackrf_device* device,
1435 const uint32_t address,
1436 const uint16_t length,
1437 unsigned char* data);
1438
1450 extern ADDAPI int ADDCALL hackrf_spiflash_status(hackrf_device* device, uint8_t* data);
1451
1462 extern ADDAPI int ADDCALL hackrf_spiflash_clear_status(hackrf_device* device);
1463
1464/* device will need to be reset after hackrf_cpld_write */
1465
1476 extern ADDAPI int ADDCALL hackrf_cpld_write(
1477 hackrf_device* device,
1478 unsigned char* const data,
1479 const unsigned int total_length);
1480
1492 extern ADDAPI int ADDCALL hackrf_board_id_read(hackrf_device* device, uint8_t* value);
1493
1504 extern ADDAPI int ADDCALL hackrf_version_string_read(
1505 hackrf_device* device,
1506 char* version,
1507 uint8_t length);
1508
1527 extern ADDAPI int ADDCALL hackrf_usb_api_version_read(
1528 hackrf_device* device,
1529 uint16_t* version);
1530
1543 extern ADDAPI int ADDCALL hackrf_set_freq(hackrf_device* device, const uint64_t freq_hz);
1544
1557 extern ADDAPI int ADDCALL hackrf_set_freq_explicit(
1558 hackrf_device* device,
1559 const uint64_t if_freq_hz,
1560 const uint64_t lo_freq_hz,
1561 const enum rf_path_filter path);
1562
1577 extern ADDAPI int ADDCALL hackrf_set_sample_rate_manual(
1578 hackrf_device* device,
1579 const uint32_t freq_hz,
1580 const uint32_t divider);
1581
1593 extern ADDAPI int ADDCALL hackrf_set_sample_rate(
1594 hackrf_device* device,
1595 const double freq_hz);
1596
1607 extern ADDAPI int ADDCALL hackrf_set_amp_enable(
1608 hackrf_device* device,
1609 const uint8_t value);
1610
1621 extern ADDAPI int ADDCALL hackrf_board_partid_serialno_read(
1622 hackrf_device* device,
1623 read_partid_serialno_t* read_partid_serialno);
1624
1635 extern ADDAPI int ADDCALL hackrf_set_lna_gain(hackrf_device* device, uint32_t value);
1636
1645 extern ADDAPI int ADDCALL hackrf_set_vga_gain(hackrf_device* device, uint32_t value);
1646
1655 extern ADDAPI int ADDCALL hackrf_set_txvga_gain(hackrf_device* device, uint32_t value);
1656
1669 extern ADDAPI int ADDCALL hackrf_set_antenna_enable(
1670 hackrf_device* device,
1671 const uint8_t value);
1672
1679 extern ADDAPI const char* ADDCALL hackrf_error_name(enum hackrf_error errcode);
1680
1688 extern ADDAPI const char* ADDCALL hackrf_board_id_name(enum hackrf_board_id board_id);
1689
1697 extern ADDAPI uint32_t ADDCALL hackrf_board_id_platform(enum hackrf_board_id board_id);
1698
1699// part of docstring is from hackrf.h
1706 extern ADDAPI const char* ADDCALL hackrf_usb_board_id_name(
1707 enum hackrf_usb_board_id usb_board_id);
1708
1715 extern ADDAPI const char* ADDCALL hackrf_filter_path_name(const enum rf_path_filter path);
1716
1726 extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw_round_down_lt(
1727 const uint32_t bandwidth_hz);
1728
1738 extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw(
1739 const uint32_t bandwidth_hz);
1740
1741/* All features below require USB API version 0x1002 or higher) */
1742
1754 extern ADDAPI int ADDCALL hackrf_set_hw_sync_mode(
1755 hackrf_device* device,
1756 const uint8_t value);
1757
1774 extern ADDAPI int ADDCALL hackrf_init_sweep(
1775 hackrf_device* device,
1776 const uint16_t* frequency_list,
1777 const int num_ranges,
1778 const uint32_t num_bytes,
1779 const uint32_t step_width,
1780 const uint32_t offset,
1781 const enum sweep_style style);
1782
1794 extern ADDAPI int ADDCALL hackrf_get_operacake_boards(
1795 hackrf_device* device,
1796 uint8_t* boards);
1797
1808 extern ADDAPI int ADDCALL hackrf_set_operacake_mode(
1809 hackrf_device* device,
1810 uint8_t address,
1811 enum operacake_switching_mode mode);
1812
1823 extern ADDAPI int ADDCALL hackrf_get_operacake_mode(
1824 hackrf_device* device,
1825 uint8_t address,
1826 enum operacake_switching_mode* mode);
1827
1841 extern ADDAPI int ADDCALL hackrf_set_operacake_ports(
1842 hackrf_device* device,
1843 uint8_t address,
1844 uint8_t port_a,
1845 uint8_t port_b);
1846
1861 extern ADDAPI int ADDCALL hackrf_set_operacake_dwell_times(
1862 hackrf_device* device,
1863 hackrf_operacake_dwell_time* dwell_times,
1864 uint8_t count);
1865
1880 extern ADDAPI int ADDCALL hackrf_set_operacake_freq_ranges(
1881 hackrf_device* device,
1882 hackrf_operacake_freq_range* freq_ranges,
1883 uint8_t count);
1884
1893 extern ADDAPI int ADDCALL hackrf_reset(hackrf_device* device);
1894
1910 extern ADDAPI int ADDCALL hackrf_set_operacake_ranges(
1911 hackrf_device* device,
1912 uint8_t* ranges,
1913 uint8_t num_ranges);
1914
1924 extern ADDAPI int ADDCALL hackrf_set_clkout_enable(
1925 hackrf_device* device,
1926 const uint8_t value);
1927
1939 extern ADDAPI int ADDCALL hackrf_get_clkin_status(hackrf_device* device, uint8_t* status);
1940
1956 extern ADDAPI int ADDCALL hackrf_operacake_gpio_test(
1957 hackrf_device* device,
1958 uint8_t address,
1959 uint16_t* test_result);
1960
1961#ifdef HACKRF_ISSUE_609_IS_FIXED
1973extern ADDAPI int ADDCALL hackrf_cpld_checksum(hackrf_device* device, uint32_t* crc);
1974#endif /* HACKRF_ISSUE_609_IS_FIXED */
1975
1987 extern ADDAPI int ADDCALL hackrf_set_ui_enable(hackrf_device* device, const uint8_t value);
1988
2001 extern ADDAPI int ADDCALL hackrf_start_rx_sweep(
2002 hackrf_device* device,
2003 hackrf_sample_block_cb_fn callback,
2004 void* rx_ctx);
2005
2006// docsstring partly from hackrf.c
2013 extern ADDAPI size_t ADDCALL hackrf_get_transfer_buffer_size(hackrf_device* device);
2014
2015// docsstring partly from hackrf.c
2022 extern ADDAPI uint32_t ADDCALL hackrf_get_transfer_queue_depth(hackrf_device* device);
2023
2033 extern ADDAPI int ADDCALL hackrf_board_rev_read(hackrf_device* device, uint8_t* value);
2034
2042 extern ADDAPI const char* ADDCALL hackrf_board_rev_name(enum hackrf_board_rev board_rev);
2043
2055 extern ADDAPI int ADDCALL hackrf_supported_platform_read(
2056 hackrf_device* device,
2057 uint32_t* value);
2058
2073 extern ADDAPI int ADDCALL hackrf_set_leds(hackrf_device* device, const uint8_t state);
2074
2099 extern ADDAPI int ADDCALL hackrf_set_user_bias_t_opts(
2100 hackrf_device* device,
2101 hackrf_bias_t_user_settting_req* req);
2102
2103#ifdef __cplusplus
2104} // __cplusplus defined.
2105#endif
2106
2107#endif /*__HACKRF_H__*/
hackrf_set_clkout_enable
int hackrf_set_clkout_enable(hackrf_device *device, const uint8_t value)
Enable / disable CLKOUT.
hackrf_set_lna_gain
int hackrf_set_lna_gain(hackrf_device *device, uint32_t value)
Set LNA gain.
hackrf_get_clkin_status
int hackrf_get_clkin_status(hackrf_device *device, uint8_t *status)
Get CLKIN status.
hackrf_filter_path_name
const char * hackrf_filter_path_name(const enum rf_path_filter path)
Convert rf_path_filter into human-readable string.
rf_path_filter
rf_path_filter
RF filter path setting enum.
Definition: hackrf.h:786
hackrf_set_sample_rate_manual
int hackrf_set_sample_rate_manual(hackrf_device *device, const uint32_t freq_hz, const uint32_t divider)
Set sample rate explicitly.
hackrf_set_baseband_filter_bandwidth
int hackrf_set_baseband_filter_bandwidth(hackrf_device *device, const uint32_t bandwidth_hz)
Set baseband filter bandwidth.
hackrf_set_sample_rate
int hackrf_set_sample_rate(hackrf_device *device, const double freq_hz)
Set sample rate.
hackrf_set_amp_enable
int hackrf_set_amp_enable(hackrf_device *device, const uint8_t value)
Enable/disable 14dB RF amplifier.
hackrf_set_freq
int hackrf_set_freq(hackrf_device *device, const uint64_t freq_hz)
Set the center frequency.
hackrf_set_txvga_gain
int hackrf_set_txvga_gain(hackrf_device *device, uint32_t value)
Set RF TX gain of the MAX2837 transceiver IC ("IF" or "VGA" gain setting) in decibels.
hackrf_compute_baseband_filter_bw
uint32_t hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz)
Compute nearest valid baseband filter bandwidth to specified value.
hackrf_set_freq_explicit
int 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)
Set the center frequency via explicit tuning.
hackrf_set_vga_gain
int hackrf_set_vga_gain(hackrf_device *device, uint32_t value)
Set baseband RX gain of the MAX2837 transceier IC ("BB" or "VGA" gain setting) in decibels.
hackrf_set_antenna_enable
int hackrf_set_antenna_enable(hackrf_device *device, const uint8_t value)
Enable / disable bias-tee (antenna port power)
hackrf_compute_baseband_filter_bw_round_down_lt
uint32_t hackrf_compute_baseband_filter_bw_round_down_lt(const uint32_t bandwidth_hz)
Compute nearest valid baseband filter bandwidth lower than a specified value.
RF_PATH_FILTER_HIGH_PASS
@ RF_PATH_FILTER_HIGH_PASS
HPF is selected, .
Definition: hackrf.h:798
RF_PATH_FILTER_BYPASS
@ RF_PATH_FILTER_BYPASS
No filter is selected, the mixer is bypassed, .
Definition: hackrf.h:790
RF_PATH_FILTER_LOW_PASS
@ RF_PATH_FILTER_LOW_PASS
LPF is selected, .
Definition: hackrf.h:794
hackrf_spiflash_erase
int hackrf_spiflash_erase(hackrf_device *device)
Erase firmware image on the SPI flash.
hackrf_max2837_read
int hackrf_max2837_read(hackrf_device *device, uint8_t register_number, uint16_t *value)
Directly read the registers of the MAX2837 transceiver IC.
hackrf_spiflash_write
int hackrf_spiflash_write(hackrf_device *device, const uint32_t address, const uint16_t length, unsigned char *const data)
Write firmware image on the SPI flash.
hackrf_si5351c_write
int hackrf_si5351c_write(hackrf_device *device, uint16_t register_number, uint16_t value)
Directly write the registers of the Si5351 clock generator IC.
hackrf_max2837_write
int hackrf_max2837_write(hackrf_device *device, uint8_t register_number, uint16_t value)
Directly write the registers of the MAX2837 transceiver IC.
hackrf_rffc5071_read
int hackrf_rffc5071_read(hackrf_device *device, uint8_t register_number, uint16_t *value)
Directly read the registers of the RFFC5071/5072 mixer-synthesizer IC.
hackrf_spiflash_read
int hackrf_spiflash_read(hackrf_device *device, const uint32_t address, const uint16_t length, unsigned char *data)
Read firmware image on the SPI flash.
hackrf_spiflash_status
int hackrf_spiflash_status(hackrf_device *device, uint8_t *data)
Read the status registers of the W25Q80BV SPI flash chip.
hackrf_si5351c_read
int hackrf_si5351c_read(hackrf_device *device, uint16_t register_number, uint16_t *value)
Directly read the registers of the Si5351C clock generator IC.
hackrf_spiflash_clear_status
int hackrf_spiflash_clear_status(hackrf_device *device)
Clear the status registers of the W25Q80BV SPI flash chip.
hackrf_cpld_write
int hackrf_cpld_write(hackrf_device *device, unsigned char *const data, const unsigned int total_length)
Write configuration bitstream into the XC2C64A-7VQ100C CPLD.
hackrf_rffc5071_write
int hackrf_rffc5071_write(hackrf_device *device, uint8_t register_number, uint16_t value)
Directly write the registers of the RFFC5071/5072 mixer-synthesizer IC.
hackrf_get_m0_state
int hackrf_get_m0_state(hackrf_device *device, hackrf_m0_state *value)
Get the state of the M0 code on the LPC43xx MCU.
hackrf_close
int hackrf_close(hackrf_device *device)
Close a previously opened device.
hackrf_device_list_open
int hackrf_device_list_open(hackrf_device_list_t *list, int idx, hackrf_device **device)
Open a hackrf_device from a device list.
hackrf_supported_platform_read
int hackrf_supported_platform_read(hackrf_device *device, uint32_t *value)
Read supported platform of device.
hackrf_open_by_serial
int hackrf_open_by_serial(const char *const desired_serial_number, hackrf_device **device)
Open HackRF device by serial number.
hackrf_device_list_free
void hackrf_device_list_free(hackrf_device_list_t *list)
Free a previously allocated hackrf_device_list list.
hackrf_set_ui_enable
int hackrf_set_ui_enable(hackrf_device *device, const uint8_t value)
Enable / disable UI display (RAD1O, PortaPack, etc.)
hackrf_board_id_platform
uint32_t hackrf_board_id_platform(enum hackrf_board_id board_id)
Lookup platform ID (HACKRF_PLATFORM_xxx) from board id (hackrf_board_id)
hackrf_board_partid_serialno_read
int hackrf_board_partid_serialno_read(hackrf_device *device, read_partid_serialno_t *read_partid_serialno)
Read board part ID and serial number.
hackrf_set_leds
int hackrf_set_leds(hackrf_device *device, const uint8_t state)
Turn on or off (override) the LEDs of the HackRF device.
hackrf_board_rev_name
const char * hackrf_board_rev_name(enum hackrf_board_rev board_rev)
Convert board revision name.
hackrf_usb_board_id_name
const char * hackrf_usb_board_id_name(enum hackrf_usb_board_id usb_board_id)
Convert hackrf_usb_board_id into human-readable string.
hackrf_board_id
hackrf_board_id
HACKRF board id enum.
Definition: hackrf.h:648
hackrf_usb_board_id
hackrf_usb_board_id
USB board ID (product ID) enum.
Definition: hackrf.h:760
hackrf_board_rev_read
int hackrf_board_rev_read(hackrf_device *device, uint8_t *value)
Read board revision of device.
hackrf_board_id_name
const char * hackrf_board_id_name(enum hackrf_board_id board_id)
Convert hackrf_board_id into human-readable string.
hackrf_open
int hackrf_open(hackrf_device **device)
Open first available HackRF device.
hackrf_device
struct hackrf_device hackrf_device
Opaque struct for hackrf device info.
Definition: hackrf.h:858
hackrf_version_string_read
int hackrf_version_string_read(hackrf_device *device, char *version, uint8_t length)
Read HackRF firmware version as a string.
hackrf_board_id_read
int hackrf_board_id_read(hackrf_device *device, uint8_t *value)
Read hackrf_board_id from a device.
hackrf_usb_api_version_read
int hackrf_usb_api_version_read(hackrf_device *device, uint16_t *version)
Read HackRF USB API version.
hackrf_board_rev
hackrf_board_rev
Board revision enum.
Definition: hackrf.h:696
hackrf_reset
int hackrf_reset(hackrf_device *device)
Reset HackRF device.
hackrf_device_list
hackrf_device_list_t * hackrf_device_list()
List connected HackRF devices.
hackrf_set_user_bias_t_opts
int hackrf_set_user_bias_t_opts(hackrf_device *device, hackrf_bias_t_user_settting_req *req)
Configure bias tee behavior of the HackRF device when changing RF states.
BOARD_ID_UNDETECTED
@ BOARD_ID_UNDETECTED
Unknown board (detection not yet attempted, should be default value)
Definition: hackrf.h:676
BOARD_ID_HACKRF1_R9
@ BOARD_ID_HACKRF1_R9
HackRF One (rev.
Definition: hackrf.h:668
BOARD_ID_JELLYBEAN
@ BOARD_ID_JELLYBEAN
Jellybean (pre-production revision, not supported)
Definition: hackrf.h:652
BOARD_ID_UNRECOGNIZED
@ BOARD_ID_UNRECOGNIZED
Unknown board (failed detection)
Definition: hackrf.h:672
BOARD_ID_HACKRF1_OG
@ BOARD_ID_HACKRF1_OG
HackRF One (prior to rev 9, same limits: 1-6000MHz, 20MSPS, bias-tee)
Definition: hackrf.h:660
BOARD_ID_RAD1O
@ BOARD_ID_RAD1O
RAD1O (Chaos Computer Club special edition with LCD & other features.
Definition: hackrf.h:664
BOARD_ID_JAWBREAKER
@ BOARD_ID_JAWBREAKER
Jawbreaker (beta platform, 10-6000MHz, no bias-tee)
Definition: hackrf.h:656
USB_BOARD_ID_INVALID
@ USB_BOARD_ID_INVALID
Invalid / unknown USB product id.
Definition: hackrf.h:776
USB_BOARD_ID_RAD1O
@ USB_BOARD_ID_RAD1O
RAD1O (custom version) USB product id.
Definition: hackrf.h:772
USB_BOARD_ID_JAWBREAKER
@ USB_BOARD_ID_JAWBREAKER
Jawbreaker (beta platform) USB product id.
Definition: hackrf.h:764
USB_BOARD_ID_HACKRF_ONE
@ USB_BOARD_ID_HACKRF_ONE
HackRF One USB product id.
Definition: hackrf.h:768
BOARD_REV_GSG_HACKRF1_R7
@ BOARD_REV_GSG_HACKRF1_R7
board revision 7, made by GSG
Definition: hackrf.h:729
BOARD_REV_HACKRF1_R9
@ BOARD_REV_HACKRF1_R9
board revision 9, generic
Definition: hackrf.h:716
BOARD_REV_UNDETECTED
@ BOARD_REV_UNDETECTED
unknown board revision (detection not yet attempted)
Definition: hackrf.h:750
BOARD_REV_GSG_HACKRF1_R8
@ BOARD_REV_GSG_HACKRF1_R8
board revision 8, made by GSG
Definition: hackrf.h:733
BOARD_REV_HACKRF1_R10
@ BOARD_REV_HACKRF1_R10
board revision 10, generic
Definition: hackrf.h:720
BOARD_REV_HACKRF1_R8
@ BOARD_REV_HACKRF1_R8
board revision 8, generic
Definition: hackrf.h:712
BOARD_REV_HACKRF1_R6
@ BOARD_REV_HACKRF1_R6
board revision 6, generic
Definition: hackrf.h:704
BOARD_REV_HACKRF1_OLD
@ BOARD_REV_HACKRF1_OLD
Older than rev6.
Definition: hackrf.h:700
BOARD_REV_GSG_HACKRF1_R9
@ BOARD_REV_GSG_HACKRF1_R9
board revision 9, made by GSG
Definition: hackrf.h:737
BOARD_REV_HACKRF1_R7
@ BOARD_REV_HACKRF1_R7
board revision 7, generic
Definition: hackrf.h:708
BOARD_REV_UNRECOGNIZED
@ BOARD_REV_UNRECOGNIZED
unknown board revision (detection failed)
Definition: hackrf.h:746
BOARD_REV_GSG_HACKRF1_R10
@ BOARD_REV_GSG_HACKRF1_R10
board revision 10, made by GSG
Definition: hackrf.h:741
BOARD_REV_GSG_HACKRF1_R6
@ BOARD_REV_GSG_HACKRF1_R6
board revision 6, made by GSG
Definition: hackrf.h:725
hackrf_error
hackrf_error
error enum, returned by many libhackrf functions
Definition: hackrf.h:556
hackrf_init
int hackrf_init()
Initialize libhackrf.
hackrf_exit
int hackrf_exit()
Exit libhackrf.
hackrf_error_name
const char * hackrf_error_name(enum hackrf_error errcode)
Convert hackrf_error into human-readable string.
hackrf_get_transfer_buffer_size
size_t hackrf_get_transfer_buffer_size(hackrf_device *device)
Get USB transfer buffer size.
hackrf_library_release
const char * hackrf_library_release()
Get library release.
hackrf_get_transfer_queue_depth
uint32_t hackrf_get_transfer_queue_depth(hackrf_device *device)
Get the total number of USB transfer buffers.
hackrf_library_version
const char * hackrf_library_version()
Get library version.
HACKRF_ERROR_THREAD
@ HACKRF_ERROR_THREAD
Error setting up transfer thread (pthread-related error)
Definition: hackrf.h:588
HACKRF_ERROR_NOT_FOUND
@ HACKRF_ERROR_NOT_FOUND
USB device not found, returned at opening.
Definition: hackrf.h:572
HACKRF_ERROR_NO_MEM
@ HACKRF_ERROR_NO_MEM
Memory allocation (on host side) failed.
Definition: hackrf.h:580
HACKRF_SUCCESS
@ HACKRF_SUCCESS
no error happened
Definition: hackrf.h:560
HACKRF_TRUE
@ HACKRF_TRUE
TRUE value, returned by some functions that return boolean value.
Definition: hackrf.h:564
HACKRF_ERROR_USB_API_VERSION
@ HACKRF_ERROR_USB_API_VERSION
The installed firmware does not support this function.
Definition: hackrf.h:604
HACKRF_ERROR_INVALID_PARAM
@ HACKRF_ERROR_INVALID_PARAM
The function was called with invalid parameters.
Definition: hackrf.h:568
HACKRF_ERROR_STREAMING_THREAD_ERR
@ HACKRF_ERROR_STREAMING_THREAD_ERR
Streaming thread could not start due to an error.
Definition: hackrf.h:592
HACKRF_ERROR_STREAMING_EXIT_CALLED
@ HACKRF_ERROR_STREAMING_EXIT_CALLED
Streaming thread exited (normally)
Definition: hackrf.h:600
HACKRF_ERROR_LIBUSB
@ HACKRF_ERROR_LIBUSB
LibUSB error, use hackrf_error_name to get a human-readable error string (using libusb_strerror)
Definition: hackrf.h:584
HACKRF_ERROR_BUSY
@ HACKRF_ERROR_BUSY
Resource is busy, possibly the device is already opened.
Definition: hackrf.h:576
HACKRF_ERROR_OTHER
@ HACKRF_ERROR_OTHER
Unspecified error.
Definition: hackrf.h:612
HACKRF_ERROR_STREAMING_STOPPED
@ HACKRF_ERROR_STREAMING_STOPPED
Streaming thread stopped due to an error.
Definition: hackrf.h:596
HACKRF_ERROR_NOT_LAST_DEVICE
@ HACKRF_ERROR_NOT_LAST_DEVICE
Can not exit library as one or more HackRFs still in use.
Definition: hackrf.h:608
hackrf_get_operacake_mode
int hackrf_get_operacake_mode(hackrf_device *device, uint8_t address, enum operacake_switching_mode *mode)
Query Opera Cake mode.
hackrf_set_operacake_ranges
int hackrf_set_operacake_ranges(hackrf_device *device, uint8_t *ranges, uint8_t num_ranges)
Setup Opera Cake frequency ranges in OPERACAKE_MODE_FREQUENCY mode operation.
hackrf_set_operacake_freq_ranges
int hackrf_set_operacake_freq_ranges(hackrf_device *device, hackrf_operacake_freq_range *freq_ranges, uint8_t count)
Setup Opera Cake frequency ranges in OPERACAKE_MODE_FREQUENCY mode operation.
operacake_switching_mode
operacake_switching_mode
Opera Cake port switching mode.
Definition: hackrf.h:820
hackrf_get_operacake_boards
int hackrf_get_operacake_boards(hackrf_device *device, uint8_t *boards)
Query connected Opera Cake boards.
hackrf_set_operacake_ports
int hackrf_set_operacake_ports(hackrf_device *device, uint8_t address, uint8_t port_a, uint8_t port_b)
Setup Opera Cake ports in OPERACAKE_MODE_MANUAL mode operation.
hackrf_set_operacake_mode
int hackrf_set_operacake_mode(hackrf_device *device, uint8_t address, enum operacake_switching_mode mode)
Setup Opera Cake operation mode.
hackrf_set_operacake_dwell_times
int hackrf_set_operacake_dwell_times(hackrf_device *device, hackrf_operacake_dwell_time *dwell_times, uint8_t count)
Setup Opera Cake dwell times in OPERACAKE_MODE_TIME mode operation.
operacake_ports
operacake_ports
Opera Cake secondary ports (A1-A4, B1-B4)
Definition: hackrf.h:805
hackrf_operacake_gpio_test
int hackrf_operacake_gpio_test(hackrf_device *device, uint8_t address, uint16_t *test_result)
Perform GPIO test on an Opera Cake addon board.
OPERACAKE_MODE_FREQUENCY
@ OPERACAKE_MODE_FREQUENCY
Port connections are switched automatically when the frequency is changed.
Definition: hackrf.h:828
OPERACAKE_MODE_TIME
@ OPERACAKE_MODE_TIME
Port connections are switched automatically over time.
Definition: hackrf.h:832
OPERACAKE_MODE_MANUAL
@ OPERACAKE_MODE_MANUAL
Port connections are set manually using hackrf_set_operacake_ports.
Definition: hackrf.h:824
OPERACAKE_PB4
@ OPERACAKE_PB4
Definition: hackrf.h:813
OPERACAKE_PB2
@ OPERACAKE_PB2
Definition: hackrf.h:811
OPERACAKE_PA1
@ OPERACAKE_PA1
Definition: hackrf.h:806
OPERACAKE_PA2
@ OPERACAKE_PA2
Definition: hackrf.h:807
OPERACAKE_PB1
@ OPERACAKE_PB1
Definition: hackrf.h:810
OPERACAKE_PA4
@ OPERACAKE_PA4
Definition: hackrf.h:809
OPERACAKE_PB3
@ OPERACAKE_PB3
Definition: hackrf.h:812
OPERACAKE_PA3
@ OPERACAKE_PA3
Definition: hackrf.h:808
hackrf_flush_cb_fn
void(* hackrf_flush_cb_fn)(void *flush_ctx, int)
Flush (end of transmission) callback.
Definition: hackrf.h:1047
hackrf_init_sweep
int hackrf_init_sweep(hackrf_device *device, const uint16_t *frequency_list, const int num_ranges, const uint32_t num_bytes, const uint32_t step_width, const uint32_t offset, const enum sweep_style style)
Initialize sweep mode.
hackrf_stop_tx
int hackrf_stop_tx(hackrf_device *device)
Stop transmission.
hackrf_start_rx_sweep
int hackrf_start_rx_sweep(hackrf_device *device, hackrf_sample_block_cb_fn callback, void *rx_ctx)
Start RX sweep.
hackrf_sample_block_cb_fn
int(* hackrf_sample_block_cb_fn)(hackrf_transfer *transfer)
Sample block callback, used in RX and TX (set via hackrf_start_rx, hackrf_start_rx_sweep and hackrf_s...
Definition: hackrf.h:1031
hackrf_tx_block_complete_cb_fn
void(* hackrf_tx_block_complete_cb_fn)(hackrf_transfer *transfer, int)
Block complete callback.
Definition: hackrf.h:1039
hackrf_stop_rx
int hackrf_stop_rx(hackrf_device *device)
Stop receiving.
hackrf_start_rx
int hackrf_start_rx(hackrf_device *device, hackrf_sample_block_cb_fn callback, void *rx_ctx)
Start receiving.
hackrf_enable_tx_flush
int hackrf_enable_tx_flush(hackrf_device *device, hackrf_flush_cb_fn callback, void *flush_ctx)
Setup flush (end-of-transmission) callback.
hackrf_set_hw_sync_mode
int hackrf_set_hw_sync_mode(hackrf_device *device, const uint8_t value)
Set hardware sync mode (hardware triggering)
hackrf_set_tx_underrun_limit
int hackrf_set_tx_underrun_limit(hackrf_device *device, uint32_t value)
Set transmit underrun limit.
hackrf_start_tx
int hackrf_start_tx(hackrf_device *device, hackrf_sample_block_cb_fn callback, void *tx_ctx)
Start transmitting.
hackrf_set_tx_block_complete_callback
int hackrf_set_tx_block_complete_callback(hackrf_device *device, hackrf_tx_block_complete_cb_fn callback)
Setup callback to be called when an USB transfer is completed.
hackrf_set_rx_overrun_limit
int hackrf_set_rx_overrun_limit(hackrf_device *device, uint32_t value)
Set receive overrun limit.
hackrf_is_streaming
int hackrf_is_streaming(hackrf_device *device)
Query device streaming status.
sweep_style
sweep_style
sweep mode enum
Definition: hackrf.h:843
LINEAR
@ LINEAR
step_width is added to the current frequency at each step.
Definition: hackrf.h:847
INTERLEAVED
@ INTERLEAVED
each step is divided into two interleaved sub-steps, allowing the host to select the best portions of...
Definition: hackrf.h:851
hackrf_bias_t_user_settting_req
User settings for user-supplied bias tee defaults.
Definition: hackrf.h:947
hackrf_bias_t_user_settting_req::rx
hackrf_bool_user_settting rx
Definition: hackrf.h:949
hackrf_bias_t_user_settting_req::tx
hackrf_bool_user_settting tx
Definition: hackrf.h:948
hackrf_bias_t_user_settting_req::off
hackrf_bool_user_settting off
Definition: hackrf.h:950
hackrf_bool_user_settting
Helper struct for hackrf_bias_t_user_setting.
Definition: hackrf.h:935
hackrf_bool_user_settting::change_on_mode_entry
bool change_on_mode_entry
Definition: hackrf.h:937
hackrf_bool_user_settting::enabled
bool enabled
Definition: hackrf.h:938
hackrf_bool_user_settting::do_update
bool do_update
Definition: hackrf.h:936
hackrf_device_list
List of connected HackRF devices.
Definition: hackrf.h:988
hackrf_device_list::serial_numbers
char ** serial_numbers
Array of human-readable serial numbers.
Definition: hackrf.h:992
hackrf_device_list::devicecount
int devicecount
Number of connected HackRF devices, the length of arrays serial_numbers, usb_board_ids and usb_device...
Definition: hackrf.h:1005
hackrf_device_list::usb_device_index
int * usb_device_index
USB device index for a given HW entry.
Definition: hackrf.h:1000
hackrf_device_list::usb_board_ids
enum hackrf_usb_board_id * usb_board_ids
ID of each board, based on USB product ID.
Definition: hackrf.h:996
hackrf_device_list::usb_devices
void ** usb_devices
All USB devices (as libusb_device** array)
Definition: hackrf.h:1010
hackrf_device_list::usb_devicecount
int usb_devicecount
Number of all queried USB devices.
Definition: hackrf.h:1014
hackrf_m0_state
State of the SGPIO loop running on the M0 core.
Definition: hackrf.h:957
hackrf_m0_state::longest_shortfall
uint32_t longest_shortfall
Longest shortfall in bytes.
Definition: hackrf.h:971
hackrf_m0_state::requested_mode
uint16_t requested_mode
Requested mode.
Definition: hackrf.h:959
hackrf_m0_state::request_flag
uint16_t request_flag
Request flag, 0 means request is completed, any other value means request is pending.
Definition: hackrf.h:961
hackrf_m0_state::active_mode
uint32_t active_mode
Active mode.
Definition: hackrf.h:963
hackrf_m0_state::m0_count
uint32_t m0_count
Number of bytes transferred by the M0.
Definition: hackrf.h:965
hackrf_m0_state::next_mode
uint32_t next_mode
Mode which will be switched to when threshold is reached.
Definition: hackrf.h:977
hackrf_m0_state::num_shortfalls
uint32_t num_shortfalls
Number of shortfalls.
Definition: hackrf.h:969
hackrf_m0_state::threshold
uint32_t threshold
Threshold m0_count value (in bytes) for next mode change.
Definition: hackrf.h:975
hackrf_m0_state::error
uint32_t error
Error, if any, that caused the M0 to revert to IDLE mode.
Definition: hackrf.h:979
hackrf_m0_state::shortfall_limit
uint32_t shortfall_limit
Shortfall limit in bytes.
Definition: hackrf.h:973
hackrf_m0_state::m4_count
uint32_t m4_count
Number of bytes transferred by the M4.
Definition: hackrf.h:967
hackrf_operacake_dwell_time
Opera Cake port setting in OPERACAKE_MODE_TIME operation.
Definition: hackrf.h:901
hackrf_operacake_dwell_time::port
uint8_t port
Port to connect A0 to (B0 mirrors this choice) Must be one of operacake_ports.
Definition: hackrf.h:909
hackrf_operacake_dwell_time::dwell
uint32_t dwell
Dwell time for port (in number of samples)
Definition: hackrf.h:905
hackrf_operacake_freq_range
Opera Cake port setting in OPERACAKE_MODE_FREQUENCY operation.
Definition: hackrf.h:916
hackrf_operacake_freq_range::port
uint8_t port
Port (A0) to use for that frequency range.
Definition: hackrf.h:928
hackrf_operacake_freq_range::freq_min
uint16_t freq_min
Start frequency (in MHz)
Definition: hackrf.h:920
hackrf_operacake_freq_range::freq_max
uint16_t freq_max
Stop frequency (in MHz)
Definition: hackrf.h:924
hackrf_transfer
USB transfer information passed to RX or TX callback.
Definition: hackrf.h:867
hackrf_transfer::buffer_length
int buffer_length
length of data buffer in bytes
Definition: hackrf.h:873
hackrf_transfer::rx_ctx
void * rx_ctx
User provided RX context.
Definition: hackrf.h:877
hackrf_transfer::device
hackrf_device * device
HackRF USB device for this transfer.
Definition: hackrf.h:869
hackrf_transfer::buffer
uint8_t * buffer
transfer data buffer (interleaved 8 bit I/Q samples)
Definition: hackrf.h:871
hackrf_transfer::valid_length
int valid_length
number of buffer bytes that were transferred
Definition: hackrf.h:875
hackrf_transfer::tx_ctx
void * tx_ctx
User provided TX context.
Definition: hackrf.h:879
read_partid_serialno_t
MCU (LPC43xx) part ID and serial number.
Definition: hackrf.h:886