lrwn 4.13.0

Library for encoding / decoding LoRaWAN frames.
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

use std::fmt;

use anyhow::Result;
#[cfg(feature = "serde")]
use serde::Serialize;

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(Serialize))]
pub enum FType {
    JoinRequest,
    JoinAccept,
    UnconfirmedDataUp,
    UnconfirmedDataDown,
    ConfirmedDataUp,
    ConfirmedDataDown,
    RejoinRequest,
    Proprietary,
}

impl fmt::Display for FType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[cfg_attr(feature = "serde", derive(Serialize))]
pub enum Major {
    LoRaWANR1,
}

#[derive(Debug, PartialEq, Eq, Clone)]
#[cfg_attr(feature = "serde", derive(Serialize))]
pub struct MHDR {
    pub f_type: FType,
    pub major: Major,
}

impl MHDR {
    pub fn from_le_bytes(b: [u8; 1]) -> Result<Self> {
        Ok(MHDR {
            f_type: match b[0] >> 5 {
                0x00 => FType::JoinRequest,
                0x01 => FType::JoinAccept,
                0x02 => FType::UnconfirmedDataUp,
                0x03 => FType::UnconfirmedDataDown,
                0x04 => FType::ConfirmedDataUp,
                0x05 => FType::ConfirmedDataDown,
                0x06 => FType::RejoinRequest,
                0x07 => FType::Proprietary,
                _ => return Err(anyhow!("unexpected mtype")),
            },
            major: match b[0] & 0x03 {
                0x00 => Major::LoRaWANR1,
                _ => return Err(anyhow!("unexpected major")),
            },
        })
    }

    pub fn to_le_bytes(&self) -> [u8; 1] {
        let mut mhdr = match self.f_type {
            FType::JoinRequest => 0x00,
            FType::JoinAccept => 0x01,
            FType::UnconfirmedDataUp => 0x02,
            FType::UnconfirmedDataDown => 0x03,
            FType::ConfirmedDataUp => 0x04,
            FType::ConfirmedDataDown => 0x05,
            FType::RejoinRequest => 0x06,
            FType::Proprietary => 0x07,
        };

        mhdr = (mhdr << 5)
            | match self.major {
                Major::LoRaWANR1 => 0x00,
            };

        [mhdr]
    }
}

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

    #[test]
    fn test_to_le_bytes() {
        let mhdr = MHDR {
            f_type: FType::Proprietary,
            major: Major::LoRaWANR1,
        };

        assert_eq!(mhdr.to_le_bytes(), [0xe0]);
    }

    #[test]
    fn test_from_le_bytes() {
        let mhdr = MHDR::from_le_bytes([0xe0]).unwrap();
        assert_eq!(
            mhdr,
            MHDR {
                f_type: FType::Proprietary,
                major: Major::LoRaWANR1,
            }
        );
    }
}