EUSBSerial/EUSBSerial.cpp at main · SARP-ARES/EUSBSerial · GitHub

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
#include "EUSBSerial.h"

//MBED_CONF_EUSBSERIAL_MAX_PACKET_SIZE


EUSBSerial::EUSBSerial(uint16_t vid, uint16_t pid) : pc(false, vid, pid) {

}

EUSBSerial::~EUSBSerial() {
    pc.disconnect();
}

bool EUSBSerial::printf(const char* format, ...) {
    if (!pc.connected()) return false;

    char buffer[MBED_CONF_EUSBSERIAL_MAX_PACKET_SIZE];
    va_list args;
    va_start(args, format);
    int n = vsnprintf(buffer, sizeof(buffer), format, args);
    va_end(args);

    if (n > 0) {
        return pc.write((uint8_t*)buffer, n);
    }
    return false;
}

bool EUSBSerial::write(const char* buf, size_t size) {
    if (!pc.connected())
        return false;

    Thread t1;
    Timer t;

    this->_format = buf;
    this->_size = size;

    t1.start([this]() { _write(); });
    t.start();

    while (!this->_success) {
        if (t.read_ms() > 500) {
            pc.disconnect();
            return false;
        }
    }

    t1.join();
    return true;
}

void EUSBSerial::_write() {
    this->_success = false;

    pc.write(this->_format, this->_size);

    this->_success = true;
}

char EUSBSerial::_getc() {
    return pc._getc();
}

size_t EUSBSerial::available() {
    return pc.available();
}

bool EUSBSerial::connected() {
    return this->write("\n", 1);
}

bool EUSBSerial::readline(char* buf, size_t size) {
    Timer t;
    t.start();

    size_t i = 0;
    while (pc.available()) {
        if (i == size)
            return false;

        buf[i] = this->_getc();
        if (buf[i] == '\n') {
            buf[i] = 0;
            return true;
        }
        i ++;

        if (t.read_ms() > 500)
            return false;
    }

    return false;
}