embedded-nano-mesh 0.1.5

Lightweight mesh communication protocol for embedded devices
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

use platform_serial::PlatformSerial;

use super::constants::{PACKET_START_BYTE, PACKET_START_BYTES_COUNT};
use super::packet::{DataPacker, IdType, Packet, Serializer};
use super::PacketMetaData;

use super::types::PacketQueue;

pub struct Transmitter {
    packet_queue: PacketQueue,
    transit_queue: PacketQueue,
    id_counter: IdType,
}

pub struct PacketQueueIsFull;
pub struct PacketTransitQueueIsFull;

struct QueuePushError;

impl Transmitter {
    pub fn new() -> Transmitter {
        Transmitter {
            packet_queue: PacketQueue::new(),
            transit_queue: PacketQueue::new(),
            id_counter: IdType::default(),
        }
    }

    pub fn send_transit(
        &mut self,
        packet_meta_data: PacketMetaData,
    ) -> Result<(), PacketTransitQueueIsFull> {
        match self._send(packet_meta_data, false) {
            Ok(_) => Ok(()),
            Err(QueuePushError) => Err(PacketTransitQueueIsFull),
        }
    }

    pub fn send(&mut self, packet_meta_data: PacketMetaData) -> Result<(), PacketQueueIsFull> {
        match self._send(packet_meta_data, true) {
            Ok(_) => Ok(()),
            Err(QueuePushError) => Err(PacketQueueIsFull),
        }
    }

    fn _send(
        &mut self,
        mut packet_meta_data: PacketMetaData,
        update_id_counter: bool,
    ) -> Result<(), QueuePushError> {
        if update_id_counter {
            let (new_val, _) = self.id_counter.overflowing_add(1);
            self.id_counter = new_val;
            packet_meta_data.packet_id = self.id_counter;
        }

        let packed_data = <Packet as DataPacker>::pack(packet_meta_data);

        match self.packet_queue.push_back(packed_data) {
            Ok(_) => Ok(()),
            Err(_) => Err(QueuePushError),
        }
    }

    fn send_start_byte_sequence<SERIAL: PlatformSerial<u8>>(&self) {
        for _ in 0..PACKET_START_BYTES_COUNT {
            SERIAL::default()
                .write(PACKET_START_BYTE)
                .unwrap_or_else(|_| {});
        }
    }

    pub fn update<SERIAL: PlatformSerial<u8>>(&mut self) {
        // Send transit queue.
        while let Some(packet) = self.transit_queue.pop_front() {
            self.send_start_byte_sequence::<SERIAL>();
            for serialized_byte in packet.summarized().serialize() {
                SERIAL::default()
                    .write(serialized_byte)
                    .unwrap_or_else(|_| {})
            }
            return;
        }

        // Send packet queue.
        while let Some(packet) = self.packet_queue.pop_front() {
            self.send_start_byte_sequence::<SERIAL>();
            for serialized_byte in packet.summarized().serialize() {
                SERIAL::default()
                    .write(serialized_byte)
                    .unwrap_or_else(|_| {})
            }
            return;
        }
    }
}