uartcat 0.1.2

chained uart memory bus protocol strongly inspired from EtherCAT and simplified
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

use bilge::prelude::*;
use packbytes::{FromBytes, ToBytes};

use crate::pack_bilge;


pub const MAX_COMMAND: usize = 4096;

/// memory bus command header
#[derive(Copy, Clone, FromBytes, ToBytes, Debug, Default)]
pub struct Command {
    /// identifier of command
    pub token: u16,
    /// type of memory access
    pub access: Access,
    /// counte the number of times this command has been executed by consecutive slaves
    pub executed: u8,
    /// address, its value depends on whether accessing a particular slave or the bus virtual memory
    pub address: Address,
    /// number of bytes to read/write, following this header
    pub size: u16,
    /// checksum of data
    pub checksum: u8,
}

/// type of memory access
#[bitsize(8)]
#[derive(Copy, Clone, FromBits, DebugBits, PartialEq, Default)]
pub struct Access {
    /// want to read memory
    pub read: bool,
    /// want to write memory, can be enabled along read
    pub write: bool,
    /** which memory to address
        - if False, the bus virtual memory is addressed, all slaves mixed, and a 32bit address is expected
        - if True, an individual slave's registers are addresses, the 32 bit addres concatenates 16bit address of slave and 16bit address of register in this slave
    */
    pub fixed: bool,
    /// if set, the slave address is topological
    pub topological: bool,
    _reserved: u3,
    /// set to True for a command that could not be executed, the error code is instantly set in register `error`
    pub error: bool,
}
pack_bilge!(Access);

#[bitsize(32)]
#[derive(Copy, Clone, FromBits, DebugBits, PartialEq, Default)]
pub struct Address {
    /// slave we are adressing the request to
    pub slave: u16,
    /// register we want to access
    pub register: u16,
}
pack_bilge!(Address);

/// checksum method used for command header and data
pub fn checksum(slice: &[u8]) -> u8 {
    let initial = 0b010110111; // standard neutral value of checksum
    slice.iter().cloned().fold(initial, |a, b|  a.wrapping_add(b)<<1)
}