si4703 0.1.0

Platform-agnostic Rust driver for the Si4703 and Si4702 FM radio turners (receivers).
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

use embedded_hal_mock::i2c::{Mock as I2cMock, Transaction as I2cTrans};
use si4703::{ic, Si4703};

pub const DEV_ADDR: u8 = 0x10;

pub struct BitFlags;
#[allow(unused)]
impl BitFlags {
    pub const DSMUTE: u16 = 1 << 15;
    pub const DMUTE: u16 = 1 << 14;
    pub const MONO: u16 = 1 << 13;
    pub const SKMODE: u16 = 1 << 10;
    pub const SEEKUP: u16 = 1 << 9;
    pub const SEEK: u16 = 1 << 8;
    pub const DISABLE: u16 = 1 << 6;
    pub const ENABLE: u16 = 1;
    pub const DE: u16 = 1 << 11;
    pub const RDSIEN: u16 = 1 << 15;
    pub const STCIEN: u16 = 1 << 14;
    pub const RDSR: u16 = 1 << 15;
    pub const STC: u16 = 1 << 14;
    pub const SF_BL: u16 = 1 << 13;
    pub const AFCRL: u16 = 1 << 12;
    pub const RDSS: u16 = 1 << 11;
    pub const ST: u16 = 1 << 8;
    pub const RDS: u16 = 1 << 12;
    pub const AGCD: u16 = 1 << 10;
    pub const RDSM: u16 = 1 << 11;
    pub const VOLEXT: u16 = 1 << 8;
    pub const XOSCEN: u16 = 1 << 15;
    pub const AHIZEN: u16 = 1 << 14;
    pub const TUNE: u16 = 1 << 15;
    pub const BLERA1: u16 = 1 << 10;
    pub const BLERA0: u16 = 1 << 9;
    pub const BLERB1: u16 = 1 << 15;
    pub const BLERB0: u16 = 1 << 14;
    pub const BLERC1: u16 = 1 << 13;
    pub const BLERC0: u16 = 1 << 12;
    pub const BLERD1: u16 = 1 << 11;
    pub const BLERD0: u16 = 1 << 10;
}

#[allow(unused)]
pub fn new_si4703(transactions: &[I2cTrans]) -> Si4703<I2cMock, ic::Si4703> {
    Si4703::new(I2cMock::new(transactions))
}

pub fn destroy<IC>(dev: Si4703<I2cMock, IC>) {
    dev.destroy().done();
}

#[macro_export]
macro_rules! assert_error {
    ($result:expr, $error:ident::$variant:ident) => {
        match $result {
            Err($error::$variant) => (),
            _ => panic!("Error not returned."),
        }
    };
}

#[macro_export]
macro_rules! set_invalid_test {
    ($name:ident, $create_method:ident, $error:ident::$variant:ident, $method:ident $(, $value:expr)*) => {
        #[test]
        fn $name() {
            let mut dev = $create_method(&[]);
            assert_error!(dev.$method($($value),*), $error::$variant);
            destroy(dev);
        }
    };
}

#[macro_export]
macro_rules! write_test {
    ($name:ident, $value:expr, $read_reg_count:expr, $write_reg_count:expr, $method:ident $(, $arg:expr)*) => {
        #[test]
        fn $name() {
            let mut write = [0; $write_reg_count*2];
            write[($write_reg_count-1)*2] = ($value >> 8) as u8;
            write[($write_reg_count-1)*2+1] = $value as u8;
            let transactions = [
                I2cTrans::read(DEV_ADDR, [0;$read_reg_count*2].to_vec()),
                I2cTrans::write(DEV_ADDR, write.to_vec())];
            let mut dev = new_si4703(&transactions);
            dev.$method($($arg),*).unwrap();
            destroy(dev);
        }
    };
    ($name:ident, $read_reg_count:expr, $first_write_reg_index:expr, $first_write_reg_value:expr,
     $second_write_reg_index:expr, $second_write_reg_value:expr, $method:ident $(, $arg:expr)*) => {
        #[test]
        fn $name() {
            let mut write = [0; ($second_write_reg_index+1)*2];
            write[$first_write_reg_index*2] = ($first_write_reg_value >> 8) as u8;
            write[$first_write_reg_index*2+1] = $first_write_reg_value as u8;
            write[$second_write_reg_index*2] = ($second_write_reg_value >> 8) as u8;
            write[$second_write_reg_index*2+1] = $second_write_reg_value as u8;
            let transactions = [
                I2cTrans::read(DEV_ADDR, [0;$read_reg_count*2].to_vec()),
                I2cTrans::write(DEV_ADDR, write.to_vec())];
            let mut dev = new_si4703(&transactions);
            dev.$method($($arg),*).unwrap();
            destroy(dev);
        }
    };
}

#[macro_export]
macro_rules! write_powercfg_test {
    ($name:ident, $value:expr, $method:ident $(, $arg:expr)*) => {
        write_test!($name, $value, 9, 1, $method $(, $arg)*);
    };
}

#[macro_export]
macro_rules! read_test {
    ($name:ident, $value:expr, $read_reg_count:expr, $expected:expr, $method:ident $(, $arg:expr)*) => {
        #[test]
        fn $name() {
            let mut read = [0; $read_reg_count*2];
            read[0] = ($value >> 8) as u8;
            read[1] = $value as u8;
            let transactions = [
                I2cTrans::read(DEV_ADDR, read.to_vec())];
            let mut dev = new_si4703(&transactions);
            assert_eq!($expected, dev.$method($($arg),*).unwrap());
            destroy(dev);
        }
    };
}