teensy3 0.2.0

Rust interface layer for the Teensy 3.1/3.2 microcontroller
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

//! Safe bindings for the primary SPI port of the Teensy 3.1/3.2

use bindings;

/// Bit order for SPI data TX/RX
#[derive(Debug, PartialEq)]
pub enum BitOrder {
    MsbFirst,
    LsbFirst,
}

/// Data TX Mode
#[derive(Debug, PartialEq)]
pub enum Mode {
    Mode0,
    Mode1,
    Mode2,
    Mode3
}

/// Settings structure for the SPI peripheral
#[derive(Debug, PartialEq)]
pub struct SpiSettings {
    max_clock: u32,
    order: BitOrder,
    mode: Mode,
    ctar: RenderedSpi,
}

type RenderedSpi = u32;

impl SpiSettings {
    pub fn new(max_clock: u32, order: BitOrder, mode: Mode) -> SpiSettings {
        let mut new = SpiSettings {
            max_clock: max_clock,
            order: order,
            mode: mode,
            ctar: 0
        };
        new.ctar = new.render();
        new
    }

    fn render(&self) -> RenderedSpi {
        let mut t = unsafe {
            let mut t_out: u32 = bindings::SPISettings_ctar_div_table[0] as u32;
            for t in bindings::SPISettings_ctar_div_table.iter() {
                t_out = *t as u32;
                if self.max_clock > (bindings::F_BUS as u32 / t_out) {
                    break;
                }
            }
            t_out
        };

        // uint32_t c = SPI_CTAR_FMSZ(7);
        let mut c: u32 = (7 & 15) << 27;

        // if (bitOrder == LSBFIRST) c |= SPI_CTAR_LSBFE;
        if self.order == BitOrder::LsbFirst {
            c |= 0x01000000;
        }

        // if (dataMode & 0x04) {
        //     c |= SPI_CTAR_CPHA;
        //     t = (t & 0xFFFF0FFF) | ((t & 0xF000) >> 4);
        // }
        // if (dataMode & 0x08) {
        //     c |= SPI_CTAR_CPOL;
        // }
        match self.mode {
            Mode::Mode0 => {},
            Mode::Mode1 => {
                c |= 0x02000000;
                t = (t & 0xFFFF0FFF) | ((t & 0xF000) >> 4);
            },
            Mode::Mode2 => {
                c |= 0x04000000
            },
            Mode::Mode3 => {
                c |= 0x06000000;
                t = (t & 0xFFFF0FFF) | ((t & 0xF000) >> 4);
            },
        }

        c | t
    }
}

#[derive(Copy, Clone)]
pub struct Spi;
use bindings::SPIClass;

impl Spi {
    /// Initialize the SPI peripheral
    pub fn begin(&self) {
        unsafe {
            SPIClass::begin();
        }
    }

    /// Begin a single SPI data transaction
    pub fn begin_transaction(&self, settings: &SpiSettings) {
        unsafe {
            SPIClass::beginTransaction(bindings::SPISettings{
                ctar: settings.ctar,
            });
        }
    }

    /// Finalize a SPI data transaction
    pub fn end_transaction(&self) {
        unsafe {
            SPIClass::endTransaction();
        }
    }

    /// Send N bytes, replacing each input byte with the associated output byte
    ///
    /// TODO: Improve once https://github.com/rust-lang/rfcs/issues/1038 lands
    pub fn transfer_replace(&self, data: &mut [u8]) {
        for mut byte in data.iter_mut() {
            *byte = unsafe {
                SPIClass::transfer(*byte)
            }
        }
    }
}