knx-rust 0.0.1

KNX Library
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

use std::fmt::{Display, Formatter};
use std::ops::Sub;


pub struct IndividualAddress {
    addr: u16
}

impl IndividualAddress {
    pub fn new(area: u8, line: u8,device: u8) -> IndividualAddress{
        return IndividualAddress{addr: ((area as u16) << 12) | (((line & 0xf) as u16) << 8) | (device as u16)}
    }
    pub fn from_u16(addr:u16) -> IndividualAddress{
        return IndividualAddress{addr}
    }
    pub fn to_u16(&self) -> u16 {
        self.addr
    }
    pub fn area(&self) -> u8 {
        return (self.addr >> 12) as u8;
    }
    pub fn line(&self) -> u8  {
        return ((self.addr >> 8) & 0xf) as u8;
    }
    pub fn device(&self) -> u8 {
        return (self.addr & 0xff) as u8;
    }
}

impl Display for IndividualAddress {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}.{}.{}", self.area(), self.line(), self.device())
    }
}



pub struct GroupAddress2 {
    addr: u16
}

impl GroupAddress2 {
    pub fn new(main: u8, sub: u16) -> GroupAddress2{
        return GroupAddress2{addr: ((main as u16) << 11) | (sub & 0x7FF)}
    }
    pub fn from_u16(addr:u16) -> GroupAddress2{
        return GroupAddress2{addr}
    }
    pub fn to_u16(&self) -> u16 {
        self.addr
    }
    pub fn main(&self) -> u8 {
        return (self.addr >> 11) as u8;
    }
    pub fn sub(&self) -> u16 {
        return self.addr & 0x7ff;
    }
}

impl Display for GroupAddress2 {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}/{}", self.main(), self.sub())
    }
}

pub struct GroupAddress3 {
    addr: u16
}
impl GroupAddress3 {
    pub fn new(main: u8, middle: u8, sub: u8) -> GroupAddress3{
        return GroupAddress3{addr: ((main as u16) << 11) | ((middle as u16) << 8) | (sub as u16)}
    }
    pub fn from_u16(addr:u16) -> GroupAddress3{
        return GroupAddress3{addr}
    }
    pub fn to_u16(&self) -> u16 {
        self.addr
    }
    pub fn main(&self) -> u8 {
        return (self.addr >> 11) as u8;
    }
    pub fn middle(&self) -> u8 {
        return ((self.addr >> 8) & 0x7) as u8;
    }
    pub fn sub(&self) -> u8 {
        return (self.addr & 0xff) as u8;
    }
}

impl Display for GroupAddress3 {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}/{}/{}", self.main(), self.middle(), self.sub())
    }
}


#[cfg(test)]
mod tests {
    use crate::address::{GroupAddress2, GroupAddress3, IndividualAddress};

    #[test]
    fn individual_address() {
        let address = IndividualAddress::new(1,2,3);

        assert_eq!(address.area(), 1);
        assert_eq!(address.line(), 2);
        assert_eq!(address.device(), 3);
        assert_eq!("1.2.3", format!("{}", address));

        let from_u16 = IndividualAddress::from_u16(0x1234);
        assert_eq!(from_u16.to_u16(), 0x1234)
    }

    #[test]
    fn group_address3() {
        let address = GroupAddress3::new(1,2,3);

        assert_eq!(address.main(), 1);
        assert_eq!(address.middle(), 2);
        assert_eq!(address.sub(), 3);
        assert_eq!("1/2/3", format!("{}", address));

        let from_u16 = GroupAddress3::from_u16(0x1234);
        assert_eq!(from_u16.to_u16(), 0x1234)
    }


    #[test]
    fn group_address2() {
        let address = GroupAddress2::new(1,3);

        assert_eq!(address.main(), 1);
        assert_eq!(address.sub(), 3);
        assert_eq!("1/3", format!("{}", address));

        let from_u16 = GroupAddress2::from_u16(0x1234);
        assert_eq!(from_u16.to_u16(), 0x1234)
    }
}