can_aerospace_lite 0.1.3

A lite version of CAN Aerospace Implementation according to 'Interface specification for airborne CAN applications V 1.7'
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

// #[cfg(feature = "bxcan-support")]
#[cfg(test)]
mod frame {
    use bxcan::{Frame, Id, StandardId};

    use crate::{
        message::{CANAerospaceFrame, Payload, RawMessage},
        types::{DataType, MessageType, ServiceCodeEnum},
    };

    #[test]
    fn test_into_canaerospaceframe() {
        let f = CANAerospaceFrame::from(Frame::new_data(
            StandardId::new(MessageType::NSH(128).id()).unwrap(),
            [
                0xA,
                DataType::ERROR(0).type_id(),
                ServiceCodeEnum::UNKNOWN.as_u8(),
                0x20,
                0xDE,
                0xAD,
                0xBE,
                0xEF,
            ],
        ));

        assert!(matches!(f.message_type, MessageType::NSH(128)));
        assert_eq!(f.message.node_id, 0xA);
        assert_eq!(f.message.data_type, DataType::ERROR(0).type_id());
        assert_eq!(f.message.service_code, ServiceCodeEnum::UNKNOWN.as_u8());
        assert_eq!(f.message.message_code, 0x20);
        assert_eq!(
            f.message.payload.data,
            DataType::ERROR(0xDEADBEEF).to_be_bytes()
        );
    }

    #[test]
    fn test_from_canaerospaceframe() {
        let f = Frame::from(&CANAerospaceFrame {
            message_type: MessageType::UDL(1801),
            message: RawMessage {
                node_id: 0x0,
                data_type: 0x0,
                service_code: 0x3,
                message_code: 0x0,
                payload: Payload::from(DataType::ACHAR(0x55).to_be_bytes()),
            },
        });
        assert!(matches!(f.id(), Id::Standard(_)));
        if let Id::Standard(id) = f.id() {
            assert_eq!(id.as_raw(), MessageType::UDL(1801).id());
        }
    }
}

#[cfg(test)]
mod data {
    use bxcan::Data;

    use crate::{
        message::{Payload, RawMessage},
        types::{DataType, ServiceCodeEnum},
    };

    #[test]
    fn test_from_rawmessage() {
        let data = Data::from(&RawMessage {
            node_id: 0xBB,
            data_type: DataType::ERROR(0xDEADDEAD).type_id(),
            service_code: ServiceCodeEnum::NSS.as_u8(),
            message_code: 0xFD,
            payload: Payload::from(DataType::ERROR(0xDEADDEAD).to_be_bytes()),
        });
        let p = DataType::ERROR(0xDEADDEAD).to_be_bytes();
        assert_eq!(data[0], 0xBB);
        assert_eq!(data[1], DataType::ERROR(0xDEADDEAD).type_id());
        assert_eq!(data[2], ServiceCodeEnum::NSS.as_u8());
        assert_eq!(data[3], 0xFD);
        assert_eq!(data[4], p[0]);
        assert_eq!(data[5], p[1]);
        assert_eq!(data[6], p[2]);
        assert_eq!(data[7], p[3]);
    }
}