max11300 0.3.0

A rust-embedded driver for the MAX11300 ADC/DAC
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

```rust
struct Alpha;
struct Beta;
struct Gamma;
struct Delta;

// Pretend I've done the sealed trait thing with the above types...


struct Container<N>
// where N: ...
{
    mode: N,
}

impl<N> Container<N> {
    fn to_alpha(self) -> Container<Alpha> {
        // ...
    }
    
    fn to_beta(self) -> Container<Beta> {
        // ...
    }
    
    fn to_gamma(self) -> Container<Gamma> {
        // ...
    }
    
    fn to_delta(self) -> Container<Delta> {
        // ...
    }
}

impl Container<Gamma> {
    fn do_gamma_things(&mut self, data: &[u8]) {}
}

// Marker trait
trait InputCapable {}
impl InputCapable for Alpha {}
impl InputCapable for Beta {}

impl<N: InputCapable> Container<N> {
    fn get_input(&mut self) -> u16 {}
}
```

```rust
struct Alpha;
struct Beta;
struct Gamma;
struct Delta;

// Pretend I've done the sealed trait thing with the above types...


struct Container<N>
// where N: ...
{
    mode: N,
    port: SPI,
}

impl<N> Container<N> {
    fn to_alpha(self) -> Container<Alpha> {
        // ...
        do_expensive_thing(&mut self.spi, [0x01, 0x02]);
    }
    
    fn to_beta(self) -> Container<Beta> {
        // ...
        do_expensive_thing(&mut self.spi, [0x02, 0x03]);
    }
    
    fn to_gamma(self) -> Container<Gamma> {
        // ...
        do_expensive_thing(&mut self.spi, [0x03, 0x04]);
    }
    
    fn to_delta(self) -> Container<Delta> {
        // ...
        do_expensive_thing(&mut self.spi, [0x04, 0x05]);
    }
}

#[inline(never)]
fn do_expensive_thing<SPI>(spi: &mut SPI) {
    
}
```

Reduce "monomorphization" bloat

for code size bloat it often helps to implement the logic in non-generic, like this

```rust
fn read(&mut self, channel: u32) -> u32;
fn set_state(&mut self, channel: u32, mode: Mode);
```

and then build the public generic typestate API on top of that