vesc 0.3.0

A no-std/no-alloc implementation of the VESC® firmware communication protocol.
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

use googletest::prelude::*;

use vesc::{self, Command, EncodeError, ValuesMask};

#[test]
fn encode_get_values() {
    let mut buf = [0u8; 16];

    let size = vesc::encode(Command::GetValues, &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 1, 4, 64, 132, 3]));
}

#[test]
fn encode_set_current() {
    let mut buf = [0u8; 16];

    let size = vesc::encode(Command::SetCurrent(0.0), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 6, 0, 0, 0, 0, 205, 133, 3]));

    let size = vesc::encode(Command::SetCurrent(1.0), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 6, 0, 0, 3, 232, 228, 240, 3]));

    let size = vesc::encode(Command::SetCurrent(57.123), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 6, 0, 0, 223, 35, 220, 157, 3]));

    let size = vesc::encode(Command::SetCurrent(-1.0), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 6, 255, 255, 252, 24, 140, 208, 3]));

    let size = vesc::encode(Command::SetCurrent(-57.123), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 6, 255, 255, 32, 221, 85, 115, 3]));
}

#[test]
fn encode_set_rpm() {
    let mut buf = [0u8; 16];

    let size = vesc::encode(Command::SetRpm(0), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 8, 0, 0, 0, 0, 2, 45, 3]));

    let size = vesc::encode(Command::SetRpm(1), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 8, 0, 0, 0, 1, 18, 12, 3]));

    let size = vesc::encode(Command::SetRpm(1234), &mut buf).unwrap();
    assert_that!(buf[..size], eq(&[2, 5, 8, 0, 0, 4, 210, 37, 214, 3]));

    let size = vesc::encode(Command::SetRpm(-1), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 8, 255, 255, 255, 255, 155, 226, 3]));

    let size = vesc::encode(Command::SetRpm(-1234), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 8, 255, 255, 251, 46, 140, 122, 3]));
}

#[test]
fn encode_set_handbrake() {
    let mut buf = [0u8; 16];

    let size = vesc::encode(Command::SetHandbrake(0.0), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 10, 0, 0, 0, 0, 70, 174, 3]));

    let size = vesc::encode(Command::SetHandbrake(1.0), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 10, 0, 0, 3, 232, 111, 219, 3]));

    let size = vesc::encode(Command::SetHandbrake(5.2), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 10, 0, 0, 20, 80, 211, 236, 3]));

    let size = vesc::encode(Command::SetHandbrake(-1.0), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 10, 255, 255, 252, 24, 7, 251, 3]));

    let size = vesc::encode(Command::SetHandbrake(-5.2), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 10, 255, 255, 235, 176, 169, 253, 3]));
}

#[test]
fn encode_forward_can() {
    let mut buf = [0u8; 16];

    let command = Command::ForwardCan(1, &Command::SetRpm(1234));
    let size = vesc::encode(command, &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 7, 34, 1, 8, 0, 0, 4, 210, 110, 99, 3]));

    let command = Command::ForwardCan(7, &Command::SetCurrent(57.123));
    let size = vesc::encode(command, &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 7, 34, 7, 6, 0, 0, 223, 35, 26, 201, 3]));
}

#[test]
fn encode_get_values_selective() {
    let mut buf = [0u8; 16];

    let mask = ValuesMask::TEMP_MOSFET;
    let size = vesc::encode(Command::GetValuesSelective(mask), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 50, 0, 0, 0, 1, 88, 76, 3]));

    let mask = ValuesMask::VOLTAGE_IN;
    let size = vesc::encode(Command::GetValuesSelective(mask), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 50, 0, 0, 1, 0, 123, 92, 3]));

    let mask = ValuesMask::TEMP_MOSFET | ValuesMask::VOLTAGE_IN;
    let size = vesc::encode(Command::GetValuesSelective(mask), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 50, 0, 0, 1, 1, 107, 125, 3]));

    let mask = ValuesMask::RPM | ValuesMask::WATT_HOURS | ValuesMask::CONTROLLER_ID;
    let size = vesc::encode(Command::GetValuesSelective(mask), &mut buf).unwrap();
    assert_that!(buf[..size], eq([2, 5, 50, 0, 2, 8, 128, 62, 44, 3]));
}

#[test]
fn encode_buf_perfect_fit() {
    let mut buf = [0u8; 10];

    let size = vesc::encode(Command::SetRpm(0), &mut buf).unwrap();
    assert_that!(size, eq(buf.len()));
    assert_that!(buf[..size], eq([2, 5, 8, 0, 0, 0, 0, 2, 45, 3]));
}

#[test]
fn encode_buffer_too_small() {
    for n in 0..10 {
        let mut buf = vec![0u8; n];
        let result = vesc::encode(Command::SetRpm(0), &mut buf);
        assert_that!(result, err(eq(&EncodeError::BufferTooSmall)));
    }
}