Function open

pub fn open(index: i32) -> (Arc<Device>, Error)

Returns an opened device by index.

Examples found in repository

examples/ex1.rs (line 192)

fn main() {
    // ---------- Device Check ----------
    let count = rtlsdr::get_device_count();
    if count == 0 {
        println!("No devices found, exiting.");
        return;
    }

    for i in 0..count {
        let (m, p, s, err) = rtlsdr::get_device_usb_strings(i);
        println!("get_device_usb_strings: {:?} - {} {} {}", err, m, p, s);
    }

    let index = 0;
    println!("===== Device name, index {}: {} =====",
             index,
             rtlsdr::get_device_name(0));
    println!("===== Running tests using device indx: 0 =====\n");

    let (dev, mut err) = rtlsdr::open(index);
    match err {
        Error::NoError => println!("open successful"),
        _ => return,
    }

    err = sdr_config(&dev);
    match err {
        Error::NoError => println!("sdr_config successful..."),
        _ => return,
    }

    println!("calling read_sync...");
    for i in 0..10 {
        let (_, read_count, err) = dev.read_sync(rtlsdr::DEFAULT_BUF_LENGTH);
        println!("----- read_sync requested iteration {} -----", i);
        println!("\tread_sync requested - {}", rtlsdr::DEFAULT_BUF_LENGTH);
        println!("\tread_sync received  - {}", read_count);
        println!("\tread_sync err msg   - {:?}", err);
    }

    dev.reset_buffer();

    // read_async is a blocking call and doesn't return until
    // async_stop is called , so we spawn a thread that sleeps
    // for a bit while our async callback is called...
    let d = dev.clone();
    thread::spawn(move || {
        println!("async_stop thread sleeping for 5 seconds...");
        thread::sleep(Duration::from_millis(5000));
        println!("async_stop thread awake, canceling read async...");
        d.cancel_async();
    });

    println!("calling read_async...");
    err = dev.read_async(Some(read_async_callback),
                         ptr::null_mut(),
                         rtlsdr::DEFAULT_ASYNC_BUF_NUMBER,
                         rtlsdr::DEFAULT_BUF_LENGTH);
    match err {
        Error::NoError => println!("device close successful..."),
        _ => println!("dev close error - {:?}", err),
    }

    err = dev.close();
    match err {
        Error::NoError => println!("device close successful..."),
        _ => println!("dev close error - {:?}", err),
    }
}