emcyphal 0.1.0

Async Cyphal/CAN network stack for no_std environments
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

use crate::utils::DuplexArray;

struct Node {
    next: u8,
    prev: u8,
}

pub const MAX_CAPACITY: usize = u8::MAX as usize + 1;

struct MultiCycleList<const N1: usize, const N2: usize> {
    nodes: DuplexArray<Node, N1, N2>,
}

impl<const N1: usize, const N2: usize> MultiCycleList<N1, N2> {
    const _ASSERT: usize = MAX_CAPACITY - N1 - N2;

    pub fn new() -> Self {
        Self {
            nodes: DuplexArray::from_fn(|i| {
                let node = unwrap!(u8::try_from(i));
                Node {
                    next: node,
                    prev: node,
                }
            }),
        }
    }

    pub fn next(&self, node: u8) -> u8 {
        self.nodes[usize::from(node)].next
    }

    pub fn prev(&self, node: u8) -> u8 {
        self.nodes[usize::from(node)].prev
    }

    pub fn is_bound(&self, node: u8) -> bool {
        self.nodes[usize::from(node)].next != node
    }

    pub fn unbind(&mut self, node: u8) {
        let next = self.nodes[usize::from(node)].next;
        let prev = self.nodes[usize::from(node)].prev;
        self.nodes[usize::from(node)].prev = node;
        self.nodes[usize::from(node)].next = node;
        self.nodes[usize::from(next)].prev = prev;
        self.nodes[usize::from(prev)].next = next;
    }

    pub fn move_after(&mut self, node: u8, prev: u8) {
        self.unbind(node);

        let next = self.nodes[usize::from(prev)].next;
        self.nodes[usize::from(node)].next = next;
        self.nodes[usize::from(node)].prev = prev;
        self.nodes[usize::from(next)].prev = node;
        self.nodes[usize::from(prev)].next = node;
    }

    pub fn move_before(&mut self, node: u8, next: u8) {
        self.unbind(node);

        let prev = self.nodes[usize::from(next)].prev;
        self.nodes[usize::from(node)].next = next;
        self.nodes[usize::from(node)].prev = prev;
        self.nodes[usize::from(next)].prev = node;
        self.nodes[usize::from(prev)].next = node;
    }
}

pub struct MultiClassQueue<const CLASS_COUNT: usize, const ENTRY_COUNT: usize> {
    nodes: MultiCycleList<CLASS_COUNT, ENTRY_COUNT>,
}

impl<const CLASS_COUNT: usize, const ENTRY_COUNT: usize> MultiClassQueue<CLASS_COUNT, ENTRY_COUNT> {
    const _ASSERT: usize = MAX_CAPACITY - CLASS_COUNT - ENTRY_COUNT;
    const ENTRY_OFFSET: u8 = CLASS_COUNT as u8;

    pub fn new() -> Self {
        Self {
            nodes: MultiCycleList::new(),
        }
    }

    pub fn front(&self, class: u8) -> Option<u8> {
        assert!(usize::from(class) < CLASS_COUNT);
        self.nodes.next(class).checked_sub(Self::ENTRY_OFFSET)
    }

    pub fn back(&self, class: u8) -> Option<u8> {
        assert!(usize::from(class) < CLASS_COUNT);
        self.nodes.prev(class).checked_sub(Self::ENTRY_OFFSET)
    }

    pub fn is_empty(&self, class: u8) -> bool {
        assert!(usize::from(class) < CLASS_COUNT);
        self.front(class).is_none()
    }

    pub fn is_front(&self, entry: u8) -> Option<u8> {
        assert!(usize::from(entry) < ENTRY_COUNT);
        let prev = self.nodes.prev(Self::ENTRY_OFFSET + entry);
        if prev < Self::ENTRY_OFFSET {
            Some(prev)
        } else {
            None
        }
    }

    pub fn is_back(&self, entry: u8) -> Option<u8> {
        assert!(usize::from(entry) < ENTRY_COUNT);
        let next = self.nodes.next(Self::ENTRY_OFFSET + entry);
        if next < Self::ENTRY_OFFSET {
            Some(next)
        } else {
            None
        }
    }

    pub fn remove(&mut self, entry: u8) {
        assert!(usize::from(entry) < ENTRY_COUNT);
        self.nodes.unbind(Self::ENTRY_OFFSET + entry);
    }

    pub fn move_front(&mut self, class: u8, entry: u8) {
        assert!(usize::from(class) < CLASS_COUNT);
        assert!(usize::from(entry) < ENTRY_COUNT);
        self.nodes.move_after(Self::ENTRY_OFFSET + entry, class);
    }

    pub fn move_back(&mut self, class: u8, entry: u8) {
        assert!(usize::from(class) < CLASS_COUNT);
        assert!(usize::from(entry) < ENTRY_COUNT);
        self.nodes.move_before(Self::ENTRY_OFFSET + entry, class);
    }
}