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
pub trait Transfer<W> {
type Error;
fn transfer<'w>(&mut self, words: &'w mut [W]) -> Result<&'w [W], Self::Error>;
}
pub trait Write<W> {
type Error;
fn write(&mut self, words: &[W]) -> Result<(), Self::Error>;
}
#[cfg(feature = "unproven")]
pub trait WriteIter<W> {
type Error;
fn write_iter<WI>(&mut self, words: WI) -> Result<(), Self::Error>
where
WI: IntoIterator<Item = W>;
}
pub mod transfer {
pub trait Default<W>: ::spi::FullDuplex<W> {}
impl<W, S> ::blocking::spi::Transfer<W> for S
where
S: Default<W>,
W: Clone,
{
type Error = S::Error;
fn transfer<'w>(&mut self, words: &'w mut [W]) -> Result<&'w [W], S::Error> {
for word in words.iter_mut() {
block!(self.send(word.clone()))?;
*word = block!(self.read())?;
}
Ok(words)
}
}
}
pub mod write {
pub trait Default<W>: ::spi::FullDuplex<W> {}
impl<W, S> ::blocking::spi::Write<W> for S
where
S: Default<W>,
W: Clone,
{
type Error = S::Error;
fn write(&mut self, words: &[W]) -> Result<(), S::Error> {
for word in words {
block!(self.send(word.clone()))?;
block!(self.read())?;
}
Ok(())
}
}
}
#[cfg(feature = "unproven")]
pub mod write_iter {
pub trait Default<W>: ::spi::FullDuplex<W> {}
impl<W, S> ::blocking::spi::WriteIter<W> for S
where
S: Default<W>,
W: Clone,
{
type Error = S::Error;
fn write_iter<WI>(&mut self, words: WI) -> Result<(), S::Error>
where
WI: IntoIterator<Item = W>,
{
for word in words.into_iter() {
block!(self.send(word.clone()))?;
block!(self.read())?;
}
Ok(())
}
}
}
#[derive(Debug, PartialEq)]
pub enum Operation<'a, W: 'static> {
Write(&'a [W]),
Transfer(&'a mut [W]),
}
pub trait Transactional<W: 'static> {
type Error;
fn exec<'a>(&mut self, operations: &mut [Operation<'a, W>]) -> Result<(), Self::Error>;
}