taptap 0.1.1

An implementation of the Tigo TAP 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
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use schemars::JsonSchema;
use serde::de::Error;
use serde::{Deserialize, Deserializer, Serialize};
use std::convert::TryFrom;

const DIRECTION_BIT: u16 = 0x8000;
const GATEWAY_ID_MASK: u16 = 0x7fff;

/// A gateway link layer address, which is either `To` or `From` a specific `GatewayID`.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum Address {
    /// `From` the indicated gateway, to the controller
    From(GatewayID),
    /// `To` the indicated gateway, from the controller
    To(GatewayID),
}

impl From<u16> for Address {
    fn from(value: u16) -> Self {
        let direction = value & DIRECTION_BIT;
        let id = GatewayID(value & GATEWAY_ID_MASK);

        if direction == 0 {
            Self::To(id)
        } else {
            Self::From(id)
        }
    }
}

impl From<Address> for u16 {
    fn from(value: Address) -> Self {
        match value {
            Address::From(id) => id.0 | DIRECTION_BIT,
            Address::To(id) => id.0,
        }
    }
}

impl From<[u8; 2]> for Address {
    fn from(value: [u8; 2]) -> Self {
        u16::from_be_bytes(value).into()
    }
}

impl From<Address> for [u8; 2] {
    fn from(value: Address) -> Self {
        u16::from(value).to_be_bytes()
    }
}

/// A 15-bit gateway ID.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Serialize, JsonSchema)]
#[serde(transparent)]
pub struct GatewayID(u16);

impl GatewayID {
    /// The all-zeroes gateway address
    pub const ZERO: GatewayID = GatewayID(0);
}

impl std::fmt::Debug for GatewayID {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_tuple("GatewayID")
            .field(&format_args!("{:#04x}", self.0))
            .finish()
    }
}

impl std::fmt::Display for GatewayID {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{:#04x}", self.0)
    }
}

#[derive(thiserror::Error, Debug, Copy, Clone, Eq, PartialEq)]
#[error("invalid gateway ID {0:04x}")]
pub struct InvalidGatewayID(u16);

impl TryFrom<u16> for GatewayID {
    type Error = InvalidGatewayID;

    fn try_from(value: u16) -> Result<Self, Self::Error> {
        if value & GATEWAY_ID_MASK != value {
            Err(InvalidGatewayID(value))
        } else {
            Ok(GatewayID(value))
        }
    }
}

impl From<GatewayID> for u16 {
    fn from(value: GatewayID) -> Self {
        value.0
    }
}

impl<'de> Deserialize<'de> for GatewayID {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let id = u16::deserialize(deserializer)?;
        Self::try_from(id).map_err(D::Error::custom)
    }
}

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

    #[test]
    fn gateway_id() {
        assert_eq!(GatewayID::try_from(0), Ok(GatewayID(0)));
        assert_eq!(GatewayID::try_from(1), Ok(GatewayID(1)));
        assert_eq!(GatewayID::try_from(0x7fff), Ok(GatewayID(0x7fff)));
        assert_eq!(GatewayID::try_from(0x8000), Err(InvalidGatewayID(0x8000)));
        assert_eq!(GatewayID::try_from(0xffff), Err(InvalidGatewayID(0xffff)));

        assert_eq!(u16::from(GatewayID(1)), 1);

        assert_eq!(GatewayID(0x1201).to_string(), "0x1201");
    }

    #[test]
    fn address() {
        assert_eq!(Address::from([0x12, 0x01]), Address::To(GatewayID(0x1201)));
        assert_eq!(
            Address::from([0x92, 0x01]),
            Address::From(GatewayID(0x1201))
        );

        assert_eq!(
            [0x12, 0x01],
            <[u8; 2]>::from(Address::To(GatewayID(0x1201)))
        );
        assert_eq!(
            [0x92, 0x01],
            <[u8; 2]>::from(Address::From(GatewayID(0x1201)))
        );
    }

    #[test]
    fn address_fmt() {
        assert_eq!(format!("{:?}", &GatewayID(0x1201)), "GatewayID(0x1201)");
    }
}