pelcodrs 0.2.1

A library for handling the Pelco D 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

use pelcodrs::*;
use std::convert::TryFrom;

#[test]
fn test_message_new() {
    let msg = Message::new(
        10,
        Command1::SENSE | Command1::CAMERA_ON_OFF,
        Command2::FOCUS_FAR | Command2::DOWN,
        0x00,
        0x20,
    );
    assert_eq!(&[0xFF, 0x0A, 0x88, 0x90, 0x00, 0x20, 0x42], msg.as_ref());

    let msg2 = MessageBuilder::new(10)
        .camera_on()
        .focus_far()
        .down()
        .tilt(Speed::Range(0.5))
        .finalize()
        .unwrap();

    assert_eq!(msg, msg2);
}

#[test]
fn test_new_message_with_try_from() {
    let bytes = [11, 22, 33, 44, 55, 66, 77];
    let msg = Message::try_from(&bytes[..]).expect("Failed creating Message from bytes slice");
    assert_eq!(&bytes, msg.as_ref());

    let few_bytes = [11, 22, 33, 44, 55, 66];
    let _ = Message::try_from(&few_bytes[..])
        .expect_err("Message instantiation with too few bytes should fail");

    let many_bytes = [11, 22, 33, 44, 55, 66, 77, 88];
    let _ = Message::try_from(&many_bytes[..])
        .expect_err("Message instantiation with too many bytes should fail");
}

#[test]
fn test_message_build() {
    let msg = MessageBuilder::new(1).camera_on().finalize().unwrap();
    assert_eq!(&[0xFF, 0x01, 0x88, 0x00, 0x00, 0x00, 0x89], msg.as_ref());

    let msg = MessageBuilder::new(1).camera_off().finalize().unwrap();
    assert_eq!(&[0xFF, 0x01, 0x08, 0x00, 0x00, 0x00, 0x09], msg.as_ref());

    let msg = MessageBuilder::new(2)
        .left()
        .pan(Speed::Range(0.5))
        .finalize()
        .unwrap();
    assert_eq!(&[0xFF, 0x02, 0x00, 0x04, 0x20, 0x00, 0x26], msg.as_ref());

    let msg = MessageBuilder::new(2).stop().finalize().unwrap();
    assert_eq!(&[0xFF, 0x02, 0x00, 0x00, 0x00, 0x00, 0x02], msg.as_ref());

    let msg = MessageBuilder::new(10)
        .camera_on()
        .focus_far()
        .direction(Direction::DOWN)
        .tilt(Speed::Turbo)
        .finalize()
        .expect("Could not finalize message");
    assert_eq!(&[0xFF, 0x0A, 0x88, 0x90, 0x00, 0xFF, 0x21], msg.as_ref());
}

#[test]
fn test_message_from_words() {
    let msg = Message::from_bytes(23, [200, 9, 145, 17]);
    assert_eq!([0xFF, 23, 200, 9, 145, 17, 138], msg.as_ref());
}

#[test]
fn test_invalid_preset() {
    let _ = Message::set_preset(12, 0).expect_err("Preset 0 should fail");
    let _ = Message::clear_preset(12, 0).expect_err("Preset 0 should fail");
    let _ = Message::go_to_preset(12, 0).expect_err("Preset 0 should fail");
}

#[test]
fn test_preset() {
    let msg = Message::set_preset(1, 1).unwrap();
    assert_eq!(&[0xFF, 1, 0, 0x03, 0, 1, 5], msg.as_ref());

    let msg = Message::clear_preset(12, 15).unwrap();
    assert_eq!(&[0xFF, 12, 0, 0x05, 0, 15, 32], msg.as_ref());

    let msg = Message::go_to_preset(255, 255).unwrap();
    assert_eq!(&[0xFF, 255, 0, 0x07, 0, 255, 5], msg.as_ref());

    assert_eq!(
        Message::go_to_preset(34, 0x21).unwrap(),
        Message::flip_180(34).unwrap()
    );
    assert_eq!(
        Message::go_to_preset(84, 0x22).unwrap(),
        Message::go_to_zero_pan(84).unwrap()
    );
}

#[test]
fn test_write_char_to_screen() {
    let msg = Message::write_char_to_screen(11, 32, 'F').unwrap();
    assert_eq!(&[0xFF, 11, 0, 0x15, 32, b'F', 134], msg.as_ref());

    let _ = Message::write_char_to_screen(11, 32, '好').expect_err("Should fail for non-ASCII");
}

#[test]
fn test_zoom_focus_speed() {
    let msg = Message::set_zoom_speed(12, ZoomSpeed::Medium).unwrap();
    assert_eq!(&[0xFF, 12, 0, 0x25, 0, 1, 50], msg.as_ref());

    let msg = Message::set_focus_speed(12, FocusSpeed::Highest).unwrap();
    assert_eq!(&[0xFF, 12, 0, 0x27, 0, 3, 54], msg.as_ref());
}