ft260hid 0.1.0

Library to control FT260 USB-I2C/UART bridge IC
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

use std::thread;
use std::time::Duration;

use ft260hid::device;
use ft260hid::io::uart;

use rand::prelude::*;
use serial_test::serial;

#[test]
#[serial]
fn test_uart_cfg() {
    let dev = device::open(1).unwrap();
    let mut uart = dev.uart();

    assert!(uart.init().is_ok());
    let cfg = uart::Config::default();
    assert!(uart.set_config(&cfg).is_ok());
    let res = uart.get_config();
    assert!(res.is_ok());
    let cfg_read = res.unwrap();
    assert_eq!(cfg, cfg_read);

    let cfg = uart::Config {
        mode: uart::Mode::RtsCts,
        baud: 57600,
        data_bits: uart::DataBits::Eight,
        stop_bit: uart::StopBit::One,
        parity: uart::Parity::None,
        breaking: uart::Breaking::Break,
    };
    assert!(uart.set_config(&cfg).is_ok());
    let res = uart.get_config();
    assert!(res.is_ok());
    let cfg_read = res.unwrap();
    assert_eq!(cfg, cfg_read);
}

#[test]
#[serial]
fn test_uart_tx_rx() {
    let mut buf_tx = [0u8; 256];

    let dev = device::open(1).unwrap();
    let mut uart = dev.uart();

    assert!(uart.init().is_ok());
    assert!(uart.set_config(&uart::Config::default()).is_ok());

    let len_list = [8usize, 32, 128, 256];
    for len in len_list {
        thread_rng().fill(&mut buf_tx);

        let size_in_fifo = uart.size_to_read();
        assert_eq!(0usize, size_in_fifo);

        let res = uart.write(&buf_tx, len);
        assert!(res.is_ok());
        let size_sent = res.unwrap();
        assert_eq!(len, size_sent);

        // to wait enqueuing RX data buffer via shorted TXD pin
        thread::sleep(Duration::from_millis(len as u64));
        let size_in_fifo = uart.size_to_read();
        assert_eq!(len, size_in_fifo);

        let mut buf_rx = [0u8; 256];
        let res = uart.read(&mut buf_rx, len, uart::DURATION_WAIT_DEFAULT);
        assert!(res.is_ok());
        let size_rec = res.unwrap();
        assert_eq!(len, size_rec);

        for i in 0..len {
            assert_eq!(buf_rx[i], buf_tx[i]);
        }
    }
}