autd3-rs-core 0.2.0

Core types and link abstraction shared across the AUTD3 phased-array sdk crates.
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
126

#[repr(u8)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cmd {
    Reset = 0x00,
    Synchronize = 0x01,
    SetMode = 0x02,
    Clear = 0x03,
    Nop = 0x04,

    WritePatternBuffer = 0x10,
    ConfigPattern = 0x11,
    ChangePatternBank = 0x12,
    WritePatternCompressed = 0x13,

    WriteModulationBuffer = 0x20,
    ConfigModulation = 0x21,
    ChangeModulationBank = 0x22,

    SetSilencer = 0x30,

    SetPhaseCorrection = 0x40,
    SetOutputMask = 0x41,
    SetPulseWidthTable = 0x42,

    EmulateGpioIn = 0x50,
    SetGpioOut = 0x52,

    ForceFan = 0x60,

    ReadErrorDetail = 0xE0,
    ReadCpuFwVersionMajor = 0xE1,
    ReadCpuFwVersionMinor = 0xE2,
    ReadCpuFwVersionPatch = 0xE3,
    ReadFpgaFwVersionMajor = 0xE4,
    ReadFpgaFwVersionMinor = 0xE5,
    ReadFpgaFwVersionPatch = 0xE6,
    ReadFpgaState = 0xE7,

    XorHash = 0xF0,
}

impl Cmd {
    #[must_use]
    pub const fn as_u8(self) -> u8 {
        self as u8
    }
}

impl TryFrom<u8> for Cmd {
    type Error = u8;

    fn try_from(value: u8) -> Result<Self, u8> {
        match value {
            0x00 => Ok(Self::Reset),
            0x01 => Ok(Self::Synchronize),
            0x02 => Ok(Self::SetMode),
            0x03 => Ok(Self::Clear),
            0x04 => Ok(Self::Nop),
            0x10 => Ok(Self::WritePatternBuffer),
            0x11 => Ok(Self::ConfigPattern),
            0x12 => Ok(Self::ChangePatternBank),
            0x13 => Ok(Self::WritePatternCompressed),
            0x20 => Ok(Self::WriteModulationBuffer),
            0x21 => Ok(Self::ConfigModulation),
            0x22 => Ok(Self::ChangeModulationBank),
            0x30 => Ok(Self::SetSilencer),
            0x40 => Ok(Self::SetPhaseCorrection),
            0x41 => Ok(Self::SetOutputMask),
            0x42 => Ok(Self::SetPulseWidthTable),
            0x50 => Ok(Self::EmulateGpioIn),
            0x52 => Ok(Self::SetGpioOut),
            0x60 => Ok(Self::ForceFan),
            0xE0 => Ok(Self::ReadErrorDetail),
            0xE1 => Ok(Self::ReadCpuFwVersionMajor),
            0xE2 => Ok(Self::ReadCpuFwVersionMinor),
            0xE3 => Ok(Self::ReadCpuFwVersionPatch),
            0xE4 => Ok(Self::ReadFpgaFwVersionMajor),
            0xE5 => Ok(Self::ReadFpgaFwVersionMinor),
            0xE6 => Ok(Self::ReadFpgaFwVersionPatch),
            0xE7 => Ok(Self::ReadFpgaState),
            0xF0 => Ok(Self::XorHash),
            other => Err(other),
        }
    }
}

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

    #[test]
    fn cmd_round_trips_via_try_from() {
        for c in [
            Cmd::Reset,
            Cmd::Synchronize,
            Cmd::SetMode,
            Cmd::Clear,
            Cmd::Nop,
            Cmd::WritePatternBuffer,
            Cmd::ConfigPattern,
            Cmd::ChangePatternBank,
            Cmd::WritePatternCompressed,
            Cmd::WriteModulationBuffer,
            Cmd::ConfigModulation,
            Cmd::ChangeModulationBank,
            Cmd::SetSilencer,
            Cmd::SetPhaseCorrection,
            Cmd::SetOutputMask,
            Cmd::SetPulseWidthTable,
            Cmd::EmulateGpioIn,
            Cmd::SetGpioOut,
            Cmd::ForceFan,
            Cmd::ReadErrorDetail,
            Cmd::ReadCpuFwVersionMajor,
            Cmd::ReadCpuFwVersionMinor,
            Cmd::ReadCpuFwVersionPatch,
            Cmd::ReadFpgaFwVersionMajor,
            Cmd::ReadFpgaFwVersionMinor,
            Cmd::ReadFpgaFwVersionPatch,
            Cmd::ReadFpgaState,
            Cmd::XorHash,
        ] {
            assert_eq!(Cmd::try_from(c.as_u8()), Ok(c));
        }
    }
}