/
SerialSLIP.hpp
145 lines (131 loc) · 4.03 KB
/
SerialSLIP.hpp
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
134
135
136
137
138
139
140
141
142
143
144
145
#include <Arduino.h>
namespace SLIP_Constants {
const static uint8_t END = 0300;
const static uint8_t ESC = 0333;
const static uint8_t ESC_END = 0334;
const static uint8_t ESC_ESC = 0335;
} // namespace SLIP_Constants
/// Parses SLIP packets: https://datatracker.ietf.org/doc/html/rfc1055
class SLIPParser {
public:
template <class Callback>
size_t parse(uint8_t c, Callback callback);
void reset() {
size = 0;
escape = false;
}
private:
size_t size = 0;
bool escape = false;
};
template <class Callback>
size_t SLIPParser::parse(uint8_t c, Callback callback) {
using namespace SLIP_Constants;
/*
* handle bytestuffing if necessary
*/
switch (c) {
/*
* if it's an END character then we're done with
* the packet
*/
case END: {
/*
* a minor optimization: if there is no
* data in the packet, ignore it. This is
* meant to avoid bothering IP with all
* the empty packets generated by the
* duplicate END characters which are in
* turn sent to try to detect line noise.
*/
auto packetLen = size;
reset();
if (packetLen) return packetLen;
} break;
/*
* if it's the same code as an ESC character, wait
* and get another character and then figure out
* what to store in the packet based on that.
*/
case ESC: {
escape = true;
} break;
/*
* here we fall into the default handler and let
* it store the character for us
*/
default: {
if (escape) {
/*
* if "c" is not one of these two, then we
* have a protocol violation. The best bet
* seems to be to leave the byte alone and
* just stuff it into the packet
*/
switch (c) {
case ESC_END: c = END; break;
case ESC_ESC: c = ESC; break;
default: break; // LCOV_EXCL_LINE (protocol violation)
}
escape = false;
}
callback(c, size);
++size;
}
}
return 0;
}
/// Sends SLIP packets: https://datatracker.ietf.org/doc/html/rfc1055
class SLIPSender {
public:
SLIPSender(Stream &stream) : stream(stream) {}
size_t beginPacket() { return stream.write(SLIP_Constants::END); }
size_t endPacket() { return stream.write(SLIP_Constants::END); }
size_t write(const uint8_t *data, size_t len);
size_t writePacket(const uint8_t *data, size_t len) {
size_t sent = 0;
sent += beginPacket();
sent += write(data, len);
sent += endPacket();
return sent;
}
private:
Stream &stream;
};
inline size_t SLIPSender::write(const uint8_t *data, size_t len) {
// https://datatracker.ietf.org/doc/html/rfc1055
using namespace SLIP_Constants;
size_t sent = 0;
/*
* for each byte in the packet, send the appropriate character
* sequence
*/
while (len--) {
switch (*data) {
/*
* if it's the same code as an END character, we send a
* special two character code so as not to make the
* receiver think we sent an END
*/
case END:
sent += stream.write(ESC);
sent += stream.write(ESC_END);
break;
/*
* if it's the same code as an ESC character,
* we send a special two character code so as not
* to make the receiver think we sent an ESC
*/
case ESC:
sent += stream.write(ESC);
sent += stream.write(ESC_ESC);
break;
/*
* otherwise, we just send the character
*/
default: sent += stream.write(*data);
}
data++;
}
return sent;
}