libbladerf-rs 0.5.1

Fully Rust native BladeRF driver
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

use super::common::*;
use libbladerf_rs::MaybeFuture;
use libbladerf_rs::bladerf1::board::Correction;
use libbladerf_rs::{Channel, Result};

fn roundtrip_correction(type_name: &Correction, values: [i16; 2]) -> Result<()> {
    let mut sdr = sdr();
    let mut rf = sdr.rf_link_session().wait()?;

    for channel in [Channel::Rx, Channel::Tx] {
        let current = rf.get_correction(channel, type_name).wait()?;

        for &desired in &values {
            log::trace!("Channel {channel:?} {type_name:?} Correction (CURRENT):\t{current}");
            log::trace!("Channel {channel:?} {type_name:?} Correction (DESIRED):\t{desired}");

            rf.set_correction(channel, type_name, desired).wait()?;

            let new = rf.get_correction(channel, type_name).wait()?;
            log::trace!("Channel {channel:?} {type_name:?} Correction (NEW):\t{new}");
            assert_eq!(new, desired);
        }

        rf.set_correction(channel, type_name, current).wait()?;
    }

    Ok(())
}

#[test]
fn gain_correction() -> Result<()> {
    logging_init("bladerf1_correction");
    roundtrip_correction(&Correction::Gain, [-4096, 4_096])
}

#[test]
fn phase_correction() -> Result<()> {
    logging_init("bladerf1_correction");
    roundtrip_correction(&Correction::Phase, [-4096, 4_096])
}

#[test]
fn iq_correction() -> Result<()> {
    logging_init("bladerf1_correction");

    let mut sdr = sdr();
    let mut rf = sdr.rf_link_session().wait()?;

    for channel in [Channel::Rx, Channel::Tx] {
        let desired_arr = match channel {
            Channel::Rx => [-2016, -1984, -1952, 0, 1_952, 1_984, 2_016],
            Channel::Tx => [-2032, -2016, -2000, 0, 2_000, 2_016, 2_032],
        };

        for correction_type in &[Correction::DcOffI, Correction::DcOffQ] {
            let current = rf.get_correction(channel, correction_type).wait()?;

            for desired in desired_arr {
                log::trace!(
                    "Channel {channel:?} {correction_type:?} Correction (CURRENT):\t{current}"
                );
                log::trace!(
                    "Channel {channel:?} {correction_type:?} Correction (DESIRED):\t{desired}"
                );

                rf.set_correction(channel, correction_type, desired)
                    .wait()?;

                let new = rf.get_correction(channel, correction_type).wait()?;
                log::trace!("Channel {channel:?} {correction_type:?} Correction (NEW):\t{new}");

                assert_eq!(new, desired);
            }

            rf.set_correction(channel, correction_type, current)
                .wait()?;
        }
    }

    Ok(())
}