vex-rt 0.15.1

A Rust runtime for the Vex V5 built on top of PROS.
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

#![no_std]
#![no_main]

extern crate alloc;

use alloc::format;
use array_init::array_init;
use core::time::Duration;
use itertools::Itertools;
use vex_rt::{prelude::*, serial::Serial};

const SINGLE_COUNT: u32 = 100;
const BLOCK_COUNT: u32 = 10;
const BAUDRATES: [i32; 14] = [
    9600, 10800, 12000, 13200, 14400, 15600, 17800, 19200, 38400, 57600, 115200, 230400, 460800,
    921600,
];

struct Interface {
    out_port: Serial,
    in_port: Serial,
}

struct SerialBot {
    interface: Interface,
}

impl Robot for SerialBot {
    fn new(peripherals: Peripherals) -> Self {
        Self {
            interface: Interface {
                out_port: peripherals.port01.into_serial(BAUDRATES[0]).unwrap(),
                in_port: peripherals.port02.into_serial(BAUDRATES[0]).unwrap(),
            },
        }
    }

    fn opcontrol(&mut self, _ctx: Context) {
        // Initialize block to send. Bytes are 00 through FF.
        let block: [u8; 256] = array_init(|i| i as u8);

        // Map baudrates to pair of averages.
        let averages = BAUDRATES.map(|rate| {
            println!("----------");
            println!("Baudrate: {}", rate);

            // Set both ports to the current baudrate.
            self.interface.out_port.set_baudrate(rate).unwrap();
            self.interface.in_port.set_baudrate(rate).unwrap();

            // Time one byte SINGLE_COUNT times.
            let mut total = Duration::from_millis(0);
            for j in 0..SINGLE_COUNT {
                // Write byte.
                self.interface
                    .out_port
                    .write_byte((j & 0xFF) as u8)
                    .unwrap();

                // Record current time.
                let start = time_since_start();

                // Read byte.
                while self.interface.in_port.get_read_avail().unwrap() == 0 {}
                let read = self.interface.in_port.read_byte().unwrap();

                // Compute time delta.
                let diff = time_since_start() - start;
                println!("[{:6}, {:2}] = {:2x}, {:?}", rate, j, read, diff);
                total += diff;
            }

            // Compute statistics.
            let single_average = total / SINGLE_COUNT;
            println!("----------");
            println!("Total: {:?}", total);
            println!("Average: {:?}", single_average);

            println!("----------");

            // Time 256 bytes BLOCK_COUNT times.
            let mut total = Duration::from_millis(0);
            for j in 0..BLOCK_COUNT {
                // Write block.
                self.interface.out_port.write(&block).unwrap();

                // Record current time.
                let start = time_since_start();

                // Read block.
                let mut buffer = [0u8; 256];
                let mut k = 0usize;
                while k < 256 {
                    k += self.interface.in_port.read(&mut buffer[k..256]).unwrap();
                }

                // Compute time delta.
                let diff = time_since_start() - start;
                println!(
                    "[{:6}, {:2}] = {:02x}, {:?}",
                    rate,
                    j,
                    buffer.iter().format(""),
                    diff
                );
                total += diff;
            }

            // Compute statistics.
            let block_average = total / BLOCK_COUNT;
            println!("----------");
            println!("Total: {:?}", total);
            println!("Average: {:?}", block_average);

            (rate, single_average, block_average)
        });

        // Print total table.
        println!("---------+-----------------------+-------------------------");
        println!("Baudrate | Average Time (1 byte) | Average Time (256 bytes)");
        println!("---------+-----------------------+-------------------------");
        for (rate, single_average, block_average) in averages.iter() {
            println!(
                "{:8} | {:<21} | {:?}",
                rate,
                format!("{:?}", single_average),
                block_average
            );
        }
    }
}

entry!(SerialBot);