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
|
//! I2C/SPI interfaces
extern crate embedded_hal as hal;
use hal::blocking;
use { private, Error };
/// I2C interface
#[derive(Debug, Default)]
pub struct I2cInterface<I2C> {
pub(crate) i2c: I2C,
pub(crate) address : u8,
}
/// SPI interface
#[derive(Debug, Default)]
pub struct SpiInterface<SPI, CS> {
pub(crate) spi: SPI,
pub(crate) cs: CS
}
/// Write data
pub trait WriteData : private::Sealed {
/// Error type
type Error;
/// Write to an u8 register
fn write_register(&mut self, register: u8, data: u16) -> Result<(), Error<Self::Error>>;
}
impl<I2C, E> WriteData for I2cInterface<I2C>
where
I2C: blocking::i2c::Write<Error = E>
{
type Error = E;
fn write_register(&mut self, register: u8, data: u16) -> Result<(), Error<E>> {
let payload: [u8; 3] = [register, (data >> 8) as u8, data as u8];
self.i2c
.write(self.address, &payload)
.map_err(Error::Comm)
}
}
impl<SPI, CS, E> WriteData for SpiInterface<SPI, CS>
where
SPI: blocking::spi::Write<u8, Error = E>,
CS: hal::digital::OutputPin
{
type Error = E;
fn write_register(&mut self, register: u8, data: u16) -> Result<(), Error<E>> {
self.cs.set_low();
let payload: [u8; 3] = [register + 0x80, (data >> 8) as u8, data as u8];
let result = self.spi
.write(&payload)
.map_err(Error::Comm);
self.cs.set_high();
result
}
}
/// Read data
pub trait ReadData : private::Sealed {
/// Error type
type Error;
/// Read an u8 register
fn read_register(&mut self, register: u8) -> Result<u16, Error<Self::Error>>;
}
impl<I2C, E> ReadData for I2cInterface<I2C>
where
I2C: blocking::i2c::WriteRead<Error = E>
{
type Error = E;
fn read_register(&mut self, register: u8) -> Result<u16, Error<E>> {
let mut data = [0, 0];
self.i2c
.write_read(self.address, &[register], &mut data)
.map_err(Error::Comm)
.and(Ok((u16::from(data[0]) << 8) | u16::from(data[1])))
}
}
impl<SPI, CS, E> ReadData for SpiInterface<SPI, CS>
where
SPI: blocking::spi::Transfer<u8, Error = E>,
CS: hal::digital::OutputPin
{
type Error = E;
fn read_register(&mut self, register: u8) -> Result<u16, Error<E>> {
self.cs.set_low();
let mut data = [register, 0, 0];
let result = self.spi
.transfer(&mut data)
.map_err(Error::Comm);
self.cs.set_high();
let result = result?;
Ok((u16::from(result[0]) << 8) | u16::from(result[1]))
}
}
|
