stm32f1-hal 0.12.2

HAL for the STM32F1 family
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use super::*;
use crate::common::{atomic_cell::AtomicCellMember, ringbuf::PushError};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Work {
    Start = 0,
    Addr,
    Data,
    Success,
    Stop,
}

impl AtomicCellMember for Work {
    #[inline]
    fn to_num(self) -> usize {
        self as usize
    }

    #[inline]
    unsafe fn from_num(val: usize) -> Self {
        unsafe { core::mem::transmute(val as u8) }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Command {
    SlaveAddr(u8),
    SlaveAddr10(u16),
    Write(*const u8, usize),
    WriteEnd,
    /// With length
    Read(usize),
    ReadBuf(*mut u8, usize),
}

impl AtomicCellMember for Option<Error> {
    #[inline]
    fn to_num(self) -> usize {
        match self {
            None => 0,
            Some(err) => match err {
                Error::ArbitrationLoss => 1,
                Error::Bus => 2,
                Error::Crc => 3,
                Error::NoAcknowledge(nack) => match nack {
                    NoAcknowledgeSource::Unknown => 4,
                    NoAcknowledgeSource::Address => 4 | (1 << 8),
                    NoAcknowledgeSource::Data => 4 | (2 << 8),
                },
                Error::Overrun => 5,
                Error::Pec => 6,
                Error::SMBusAlert => 7,
                Error::Timeout => 8,
                Error::SMBusTimeout => 9,
                Error::Busy => 10,
                Error::Buffer => 11,
                Error::Other => 12,
            },
        }
    }

    #[inline]
    unsafe fn from_num(val: usize) -> Self {
        let nack = (val >> 8) as u8;
        let err = val as u8;

        if err == 0 {
            None
        } else {
            Some(match err {
                1 => Error::ArbitrationLoss,
                2 => Error::Bus,
                3 => Error::Crc,
                4 => match nack {
                    0 => Error::NoAcknowledge(NoAcknowledgeSource::Unknown),
                    1 => Error::NoAcknowledge(NoAcknowledgeSource::Address),
                    _ => Error::NoAcknowledge(NoAcknowledgeSource::Data),
                },
                5 => Error::Overrun,
                6 => Error::Pec,
                7 => Error::SMBusAlert,
                8 => Error::Timeout,
                9 => Error::SMBusTimeout,
                10 => Error::Busy,
                11 => Error::Buffer,
                _ => Error::Other,
            })
        }
    }
}

impl<T> From<PushError<T>> for Error {
    fn from(_value: PushError<T>) -> Self {
        Self::Buffer
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn compare_error(err: Option<Error>) {
        let i: usize = err.to_num();
        assert_eq!(err, unsafe { Option::<Error>::from_num(i) });
    }

    #[test]
    fn teat_error() {
        compare_error(None);
        compare_error(Some(Error::NoAcknowledge(NoAcknowledgeSource::Unknown)));
        compare_error(Some(Error::NoAcknowledge(NoAcknowledgeSource::Address)));
        compare_error(Some(Error::NoAcknowledge(NoAcknowledgeSource::Data)));
        compare_error(Some(Error::SMBusAlert));
        compare_error(Some(Error::Busy));
        compare_error(Some(Error::Overrun));
        compare_error(Some(Error::Timeout));
        compare_error(Some(Error::Bus));
        compare_error(Some(Error::Crc));
        compare_error(Some(Error::ArbitrationLoss));
        compare_error(Some(Error::Pec));
        compare_error(Some(Error::SMBusTimeout));
        compare_error(Some(Error::Buffer));
        compare_error(Some(Error::Other));
    }
}