cc_talk_host 0.0.5

ccTalk host crate based on cc_talk_core
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

use cc_talk_core::cc_talk::{Address, Header};

use super::super::command::{Command, ParseResponseError};

/// Address poll is a MDCES command.
///
/// Your transport should be able to handle response with ~3ms space between packets.
/// And will receive as many response as there are devices connected to the bus up to 255 devices.
pub struct AddressPollCommand;
impl Command for AddressPollCommand {
    type Response = u8;

    fn header(&self) -> Header {
        Header::AddressPoll
    }

    fn data(&self) -> &[u8] {
        &[]
    }

    /// Returns the address of the device that responded to the poll.
    fn parse_response(
        &self,
        response_payload: &[u8],
    ) -> Result<Self::Response, ParseResponseError> {
        if response_payload.len() != 1 {
            return Err(ParseResponseError::DataLengthMismatch(
                1,
                response_payload.len(),
            ));
        }
        Ok(response_payload[0])
    }
}

/// Address clash is a MDCES command.
pub struct AddressClashCommand;
impl Command for AddressClashCommand {
    type Response = u8;

    fn header(&self) -> Header {
        Header::AddressClash
    }

    fn data(&self) -> &[u8] {
        &[]
    }

    /// Returns the address of the device that responded to the clash.
    fn parse_response(
        &self,
        response_payload: &[u8],
    ) -> Result<Self::Response, ParseResponseError> {
        if response_payload.len() != 1 {
            return Err(ParseResponseError::DataLengthMismatch(
                1,
                response_payload.len(),
            ));
        }
        Ok(response_payload[0])
    }
}

/// Address change is a MDCES command.
#[derive(Debug)]
pub struct AddressChangeCommand {
    buffer: [u8; 1],
}
impl AddressChangeCommand {
    /// Creates a new address change command.
    /// If a [Address::SingleAndRange] is provided, the single address will be used.
    pub fn new(new_address: Address) -> Self {
        AddressChangeCommand {
            buffer: [match new_address {
                Address::SingleAndRange(addr, _) => addr,
                Address::Single(addr) => addr,
            }; 1],
        }
    }
}
impl Command for AddressChangeCommand {
    type Response = ();

    fn header(&self) -> Header {
        Header::AddressChange
    }

    fn data(&self) -> &[u8] {
        &self.buffer
    }

    /// Returns an ack
    fn parse_response(
        &self,
        response_payload: &[u8],
    ) -> Result<Self::Response, ParseResponseError> {
        match response_payload.is_empty() {
            true => Ok(()),
            false => Err(ParseResponseError::DataLengthMismatch(
                0,
                response_payload.len(),
            )),
        }
    }
}

/// Address random is a MDCES command.
pub struct AddressRandomCommand;
impl Command for AddressRandomCommand {
    type Response = ();

    fn header(&self) -> Header {
        Header::AddressRandom
    }

    fn data(&self) -> &[u8] {
        &[]
    }

    /// Returns an ack
    fn parse_response(
        &self,
        response_payload: &[u8],
    ) -> Result<Self::Response, ParseResponseError> {
        match response_payload.is_empty() {
            true => Ok(()),
            false => Err(ParseResponseError::DataLengthMismatch(
                0,
                response_payload.len(),
            )),
        }
    }
}