wasm-embedded-rt 0.4.0

Runtime for embedded-wasm applications
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



use log::debug;

use crate::api::{Spi, Error};
use super::{MockCtx, Op, Kind};


impl Spi for MockCtx {
    fn init(&mut self, port: u32, baud: u32, mosi: i32, miso: i32, sck: i32, cs: i32) -> Result<i32, Error> {
        debug!("Opening SPI port: {} (baud: {} mosi: {} miso: {} sck: {} cs: {})", port, baud, mosi, miso, sck, cs);

        let op = Kind::SpiInit{port, baud, mosi, miso, sck, cs};
        let Op{kind, res} = &self.expected[self.index];

        assert_eq!(&op, kind);

        self.actual.push(op);
        self.index += 1;

        Ok(*res)
    }

    fn deinit(&mut self, handle: i32) -> Result<(), Error> {
        debug!("Closing SPI handle: {}", handle);
        let op = Kind::SpiDeinit{handle};
        let Op{kind, ..} = &self.expected[self.index];

        assert_eq!(&op, kind);

        self.actual.push(op);
        self.index += 1;

        Ok(())
    }

    fn read<'a>(&mut self, handle: i32, data: &mut [u8]) -> Result<(), Error> {
        let Op{kind, ..} = &self.expected[self.index];

        if let Kind::SpiRead{data_in, ..} = kind {
            data.copy_from_slice(&data_in);
        }

        debug!("SPI write read: {} data: {:02x?}", handle, data);

        let op = Kind::SpiRead{handle, data_in: data.to_vec()};
        assert_eq!(&op, kind);

        self.actual.push(op);
        self.index += 1;

        Ok(())
    }

    fn write<'a>(&mut self, handle: i32, data: &[u8]) -> Result<(), Error> {
        let op = Kind::SpiWrite{handle, data_out: data.to_vec()};
        let Op{kind, ..} = &self.expected[self.index];

        debug!("SPI write handle: {} data: {:02x?}", handle, data);

        assert_eq!(&op, kind);

        self.actual.push(op);
        self.index += 1;

        Ok(())
    }

    fn transfer_inplace<'a>(&mut self, handle: i32, data: &mut [u8]) -> Result<(), Error> {
        let Op{kind, ..} = &self.expected[self.index];

        let d = data.to_vec();

        if let Kind::SpiTransfer{data_in, ..} = kind {
            data.copy_from_slice(&data_in);
        }

        debug!("SPI transfer handle: {} write: {:02x?} read: {:02x?}", handle, d, data);

        let op = Kind::SpiTransfer{handle, data_out: d, data_in: data.to_vec()};
        assert_eq!(&op, kind);

        self.actual.push(op);
        self.index += 1;
        
        Ok(())
    }

    fn transfer<'a>(&mut self, handle: i32, read: &mut [u8], write: &[u8]) -> Result<(), Error> {
        let Op{kind, ..} = &self.expected[self.index];

        if let Kind::SpiTransfer{data_in, ..} = kind {
            read.copy_from_slice(&data_in);
        }

        debug!("SPI transfer handle: {} write: {:02x?} read: {:02x?}", handle, write, read);

        let op = Kind::SpiTransfer{handle, data_out: write.to_vec(), data_in: read.to_vec()};
        assert_eq!(&op, kind);

        self.actual.push(op);
        self.index += 1;
        
        Ok(())
    }

}