rtlsdr 0.1.4

Rust bindings for librtlsdr
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

// FFI bindings to rtl-sdr.h (librtlsdr)
// Copyright Adam Greig <adam@adamgreig.com> 2014
// Licensed under MIT license

use libc::{c_void, c_int, c_char, c_uchar, uint8_t, uint16_t, uint32_t};

// rtlsdr_tuner enum
pub const RTLSDR_TUNER_UNKNOWN: c_int = 0;
pub const RTLSDR_TUNER_E4000: c_int = 1;
pub const RTLSDR_TUNER_FC0012: c_int = 2;
pub const RTLSDR_TUNER_FC0013: c_int = 3;
pub const RTLSDR_TUNER_FC2580: c_int = 4;
pub const RTLSDR_TUNER_R820T: c_int = 5;
pub const RTLSDR_TUNER_R828D: c_int = 6;

#[allow(non_camel_case_types)]
pub enum rtlsdr_dev {}

#[link(name="rtlsdr")]
extern "C" {
    pub fn rtlsdr_get_device_count() -> uint32_t;
    pub fn rtlsdr_get_device_name(index: uint32_t) -> *const c_char;

    // String buffers must be 256 bytes
    // Returns 0 on success.
    pub fn rtlsdr_get_device_usb_strings(
        index: uint32_t, manufact: *mut c_char,
        product: *mut c_char, serial: *mut c_char) -> c_int;

    // Returns the index of the first matching device on success, -1 if name is
    // NULL, -2 if no devices found, -3 if no matching devices found
    pub fn rtlsdr_get_index_by_serial(serial: *const c_char) -> c_int;

    pub fn rtlsdr_open(dev: *mut *mut rtlsdr_dev, index: uint32_t) -> c_int;
    pub fn rtlsdr_close(dev: *mut rtlsdr_dev) -> c_int;

    // rtl_freq and tuner_freq in Hz
    // Returns 0 on success.
    pub fn rtlsdr_set_xtal_freq(dev: *mut rtlsdr_dev, rtl_freq: uint32_t,
                                tuner_freq: uint32_t) -> c_int;

    // rtl_freq and tuner_freq in Hz
    // Returns 0 on success.
    pub fn rtlsdr_get_xtal_freq(dev: *mut rtlsdr_dev, rtl_freq: *mut uint32_t,
                                tuner_freq: *mut uint32_t) -> c_int;

    // String buffers must be 256 bytes
    // Returns 0 on success.
    pub fn rtlsdr_get_usb_strings(dev: *mut rtlsdr_dev, manufact: *mut c_char,
                                  product: *mut c_char, serial: *mut c_char)
                                  -> c_int;

    // Returns 0 on success, -1 if device handle invalid, -2 if EEPROM size is
    // exceeded, -3 if no EEPROM was found
    pub fn rtlsdr_write_eeprom(dev: *mut rtlsdr_dev, data: *mut uint8_t,
                               offset: uint8_t, len: uint16_t) -> c_int;

    // Returns 0 on success, -1 if device handle invalid, -2 if EEPROM size is
    // exceeded, -3 if no EEPROM was found
    pub fn rtlsdr_read_eeprom(dev: *mut rtlsdr_dev, data: *mut uint8_t,
                              offset: uint8_t, len: uint16_t) -> c_int;

    pub fn rtlsdr_set_center_freq(dev: *mut rtlsdr_dev, freq: uint32_t)
                                  -> c_int;

    // Returns frequency in Hz (or 0 on error)
    pub fn rtlsdr_get_center_freq(dev: *mut rtlsdr_dev) -> uint32_t;

    // Returns 0 on success
    pub fn rtlsdr_set_freq_correction(dev: *mut rtlsdr_dev, ppm: c_int)
                                      -> c_int;

    // Return correction value in ppm
    pub fn rtlsdr_get_freq_correction(dev: *mut rtlsdr_dev) -> c_int;

    // Returns an rtlsdr_tuner enum
    pub fn rtlsdr_get_tuner_type(dev: *mut rtlsdr_dev) -> c_int;

    // Call with `gains=NULL` to return length of `gains`, then allocate and
    // call again to have `gains` populated.
    // Returns number of available gains (<=0 on error)
    pub fn rtlsdr_get_tuner_gains(dev: *mut rtlsdr_dev, gains: *mut c_int)
                                  -> c_int;

    // Returns 0 on success
    pub fn rtlsdr_set_tuner_gain(dev: *mut rtlsdr_dev, gain: c_int) -> c_int;

    // Returns gain (in tengths of dB) (0 on error)
    pub fn rtlsdr_get_tuner_gain(dev: *mut rtlsdr_dev) -> c_int;

    // Returns 0 on sucess
    pub fn rtlsdr_set_tuner_if_gain(dev: *mut rtlsdr_dev, stage: c_int,
                                    gain: c_int) -> c_int;

    // Returns 0 on success
    pub fn rtlsdr_set_tuner_gain_mode(dev: *mut rtlsdr_dev, manual: c_int)
                                      -> c_int;

    // bw=0 means automatic bandwidth selection
    // return 0 on success
    pub fn rtlsdr_set_tuner_bandwidth(dev: *mut rtlsdr_dev, bw: uint32_t) -> c_int;

    pub fn rtlsdr_set_sample_rate(dev: *mut rtlsdr_dev, rate: uint32_t)
                                  -> c_int;

    // Returns sample rate in Hz (0 on error)
    pub fn rtlsdr_get_sample_rate(dev: *mut rtlsdr_dev) -> uint32_t;

    // 1 = enable test
    // 0 = disable test
    // Returns 0 on success
    pub fn rtlsdr_set_testmode(dev: *mut rtlsdr_dev, on: c_int) -> c_int;

    // 1 = enable AGC
    // 0 = disable AGC
    // Returns 0 on success
    pub fn rtlsdr_set_agc_mode(dev: *mut rtlsdr_dev, on: c_int) -> c_int;

    // 0 = disable direct sampling
    // 1 = I-ADC input enabled
    // 2 = Q-ADC input enabled
    // Returns 0 on success
    pub fn rtlsdr_set_direct_sampling(dev: *mut rtlsdr_dev, on: c_int)
                                      -> c_int;
    
    // Returns -1 for error, 0 for disabled, 1 for I-ADC, 2 for Q-ADC
    pub fn rtlsdr_get_direct_sampling(dev: *mut rtlsdr_dev) -> c_int;

    // 1 = enable offset tuning
    // 0 = disable offset tuning
    // Returns 0 for success
    pub fn rtlsdr_set_offset_tuning(dev: *mut rtlsdr_dev, on: c_int) -> c_int;

    // Returns -1 for error, 0 for disabled, 1 for enabled
    pub fn rtlsdr_get_offset_tuning(dev: *mut rtlsdr_dev) -> c_int;

    pub fn rtlsdr_reset_buffer(dev: *mut rtlsdr_dev) -> c_int;
    pub fn rtlsdr_read_sync(dev: *mut rtlsdr_dev, buf: *mut c_void, len: c_int,
                            n_read: *mut c_int) -> c_int;

    // Set `buf_num` to 0 for default of 32
    // Set `buf_len` to 0 for default of 16 * 32 * 512
    // Returns 0 on success
    pub fn rtlsdr_read_async(dev: *mut rtlsdr_dev,
                             cb: extern fn(*mut c_uchar,
                                           uint32_t, *mut c_void),
                             buf_num: uint32_t, buf_len: uint32_t) -> c_int;
    
    // Returns 0 on success
    pub fn rtlsdr_cancel_async(dev: *mut rtlsdr_dev) -> c_int;

}