lpwan 0.1.0

An LPWAN Network Stack for rust IoT devices
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
148
149
150
151
152
153
154
155
156
157
158
159
160


use log::{error};

use ieee802154::mac::*;

use heapless::{Vec, consts::U256};

// TODO: fix or remove this?
pub const MAX_PAYLOAD_LEN: usize = 256;

/// Packet object represents an IEEE 802.15.4 object with owned storage.
/// 
/// Based on https://docs.rs/ieee802154/0.3.0/ieee802154/mac/frame/struct.Frame.html
#[derive(Clone, Debug)]
pub struct Packet {
    pub header: Header,

    pub content: FrameContent,

    payload: Vec<u8, U256>,

    pub footer: [u8; 2],
}

impl PartialEq for Packet {
    fn eq(&self, o: &Self) -> bool {
        self.header == o.header &&
        self.content == o.content && 
        self.payload() == o.payload() &&
        self.footer == o.footer
    }
}

impl Packet {

    pub fn data(dest: Address, source: Address, seq: u8, data: &[u8]) -> Packet {
        let mut payload = Vec::new();

        if let Err(e) = payload.extend_from_slice(data) {
            panic!("Error encoding payload: {:?}", e);
        };
        
        Packet {
            header: Header {
                frame_type: FrameType::Data,
                frame_pending: false,
                security: Security::None,
                ack_request: false,
                pan_id_compress: false,
                version: FrameVersion::Ieee802154_2006,
                destination: dest,
                source: source,
                seq: seq,
            },
            content: FrameContent::Data,
            payload,
            footer: [0u8; 2],
        }
    }

    // Generate an ACK for the provided packet
    pub fn ack(request: &Packet) -> Packet {
        Packet {
            header: Header {
                frame_type: FrameType::Acknowledgement,
                frame_pending: false,
                security: Security::None,
                ack_request: false,
                pan_id_compress: false,
                version: FrameVersion::Ieee802154_2006,
                destination: request.header.source,
                source: request.header.destination,
                seq: request.header.seq,
            },
            content: FrameContent::Acknowledgement,
            payload: Vec::new(),
            footer: [0u8; 2],
        }
    }

    // Check whether this packet is an ack for the provided packet
    pub fn is_ack_for(&self, original: &Packet) -> bool {
        self.header.frame_type == FrameType::Acknowledgement &&
        self.header.source == original.header.destination &&
        self.header.destination == original.header.source && 
        self.header.seq == original.header.seq && 
        self.content == FrameContent::Acknowledgement
    }

    // Based on https://docs.rs/ieee802154/0.3.0/ieee802154/mac/frame/struct.Frame.html#method.encode
    pub fn encode(&self, buf: &mut [u8], write_footer: WriteFooter) -> usize {
        let mut len = 0;

        // Write header
        len += self.header.encode(&mut buf[len..]);

        // Write content
        len += self.content.encode(&mut buf[len..]);

        // Write payload
        buf[len .. len+self.payload.len()].copy_from_slice(&self.payload);

        len += self.payload.len();

        // Write footer
        match write_footer {
            WriteFooter::No => (),
        }
        len
    }

    // Based on https://docs.rs/ieee802154/0.3.0/ieee802154/mac/frame/struct.Frame.html#method.decode
    pub fn decode(buf: &[u8], contains_footer: bool) -> Result<Self, DecodeError> {
        let mut remaining = buf.len();

        // First decode header
        let (header, header_len) = Header::decode(buf)?;
        remaining -= header_len;

        // If there's a footer, decode this
        let mut footer = [0; 2];
        if contains_footer {
            if remaining < 2 {
                return Err(DecodeError::NotEnoughBytes);
            }

            let footer_pos = buf.len() - 2;
            footer.copy_from_slice(&buf[footer_pos..]);

            remaining -= 2;
        }

        // Fetch the body subslice
        let body = &buf[header_len..header_len+remaining];

        // Decode the FrameContent
        let (content, used) = FrameContent::decode(body, &header)?;
        remaining -= used;

        // Copy out the payload
        let payload = Vec::from_slice(&body[used..]).map_err(|_e| DecodeError::NotEnoughBytes)?;

        Ok(Packet {
            header,
            content,
            payload,
            footer,
        })
    }

    pub fn payload(&self) -> &[u8] {
        &self.payload
    }

    pub fn set_payload(&mut self, body: &[u8]) -> Result<(), ()> {
        self.payload = Vec::from_slice(body)?;

        Ok(())
    }
}