ezsp 6.0.1

Ember ZNet Serial Protocol
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

use core::error::Error;
use core::fmt::{Display, Formatter};

use num_traits::FromPrimitive;

use super::values::Values;

/// Ember ADC status.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum Adc {
    /// Conversion is complete.
    ConversionDone,

    /// Conversion cannot be done because a request is being processed.
    ConversionBusy,

    /// Conversion is deferred until the current request has been processed.
    ConversionDeferred,

    /// No results are pending.
    NoConversionPending,
}

impl Display for Adc {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ConversionDone => write!(f, "conversion done"),
            Self::ConversionBusy => write!(f, "conversion busy"),
            Self::ConversionDeferred => write!(f, "conversion deferred"),
            Self::NoConversionPending => write!(f, "no conversion pending"),
        }
    }
}

impl Error for Adc {}

impl From<Adc> for Values {
    fn from(adc: Adc) -> Self {
        match adc {
            Adc::ConversionDone => Self::AdcConversionDone,
            Adc::ConversionBusy => Self::AdcConversionBusy,
            Adc::ConversionDeferred => Self::AdcConversionDeferred,
            Adc::NoConversionPending => Self::AdcNoConversionPending,
        }
    }
}

impl From<Adc> for u8 {
    fn from(adc: Adc) -> Self {
        Values::from(adc).into()
    }
}

impl TryFrom<Values> for Adc {
    type Error = Values;

    fn try_from(value: Values) -> Result<Self, Self::Error> {
        match value {
            Values::AdcConversionDone => Ok(Self::ConversionDone),
            Values::AdcConversionBusy => Ok(Self::ConversionBusy),
            Values::AdcConversionDeferred => Ok(Self::ConversionDeferred),
            Values::AdcNoConversionPending => Ok(Self::NoConversionPending),
            _ => Err(value),
        }
    }
}

impl FromPrimitive for Adc {
    fn from_i64(n: i64) -> Option<Self> {
        Values::from_i64(n).and_then(|value| Self::try_from(value).ok())
    }

    fn from_u8(n: u8) -> Option<Self> {
        Values::from_u8(n).and_then(|value| Self::try_from(value).ok())
    }

    fn from_u64(n: u64) -> Option<Self> {
        Values::from_u64(n).and_then(|value| Self::try_from(value).ok())
    }
}