Aruna
POSIX_UART.cpp
Go to the documentation of this file.
1 //
2 // Created by noeel on 2-7-19.
3 //
4 
5 #include <termios.h>
6 #include <fcntl.h>
7 #include <unistd.h>
8 #include "aruna/arunaTypes.h"
10 #include <aruna/log.h>
11 #include <errno.h>
12 
13 namespace aruna::driver {
14 // cheatcheet: https://www.cmrr.umn.edu/~strupp/serial.html#config
15 
16  size_t POSIX_UART::_write(uint8_t *package, size_t package_size) {
17  return ::write(file_description, package, package_size);
18  }
19 
20  size_t POSIX_UART::_read(uint8_t *buffer, size_t buffer_size) {
21  return ::read(file_description, buffer, buffer_size);
22  }
23 
24  POSIX_UART::POSIX_UART(char *port, uint32_t baudrate) : PORT(port) {
25  this->log = new aruna::log::channel_t("POSIX_UART");
26 
27  file_description = open(PORT, O_RDWR | O_NOCTTY | O_NDELAY);
28 
29  if (file_description == -1) {
30  /*
31  * Could not open the port.
32  */
33  log->error("Unable to open port \"%s\": %s", PORT, strerror(errno));
34  }
35  fcntl(file_description, F_SETFL, 0);
36 
37  // Read the conf of the port
38 
39  struct termios options;
40  if ((int)get_options(&options))
41  log->error("failed to read config of %s", PORT);
42 
43  options.c_cflag |= (CLOCAL | CREAD);
44 
45  if ((int)set_options(&options))
46  log->error("failed to write options");
47 
48  set_baudrate(baudrate);
51  raw_input();
52  raw_output();
54 
55  }
56 
58  close(file_description);
59  }
60 
61  uint32_t POSIX_UART::_set_baudrate(uint32_t new_baudrate) {
62  switch (new_baudrate) {
63  case 0000000:
64  new_baudrate = B0;
65  break;
66  case 50:
67  new_baudrate = B50;
68  break;
69  case 75:
70  new_baudrate = B75;
71  break;
72  case 110:
73  new_baudrate = B110;
74  break;
75  case 134:
76  new_baudrate = B134;
77  break;
78  case 150:
79  new_baudrate = B150;
80  break;
81  case 200:
82  new_baudrate = B200;
83  break;
84  case 300:
85  new_baudrate = B300;
86  break;
87  case 600:
88  new_baudrate = B600;
89  break;
90  case 1200:
91  new_baudrate = B1200;
92  break;
93  case 1800:
94  new_baudrate = B1800;
95  break;
96  case 2400:
97  new_baudrate = B2400;
98  break;
99  case 4800:
100  new_baudrate = B4800;
101  break;
102  case 9600:
103  new_baudrate = B9600;
104  break;
105  case 19200:
106  new_baudrate = B19200;
107  break;
108  case 38400:
109  new_baudrate = B38400;
110  break;
111  case 57600 :
112  new_baudrate = B57600;
113  break;
114  case 115200 :
115  new_baudrate = B115200;
116  break;
117  case 230400 :
118  new_baudrate = B230400;
119  break;
120  case 460800 :
121  new_baudrate = B460800;
122  break;
123  case 500000 :
124  new_baudrate = B500000;
125  break;
126  case 576000 :
127  new_baudrate = B576000;
128  break;
129  case 921600 :
130  new_baudrate = B921600;
131  break;
132  case 1000000:
133  new_baudrate = B1000000;
134  break;
135  case 1152000:
136  new_baudrate = B1152000;
137  break;
138  case 1500000:
139  new_baudrate = B1500000;
140  break;
141  case 2000000:
142  new_baudrate = B2000000;
143  break;
144  case 2500000:
145  new_baudrate = B2500000;
146  break;
147  case 3000000:
148  new_baudrate = B3000000;
149  break;
150  case 3500000:
151  new_baudrate = B3500000;
152  break;
153  case 4000000:
154  new_baudrate = B4000000;
155  break;
156  default:
157  new_baudrate = 0;
158  break;
159  }
160 
161  struct termios options;
162 
163  if ((int)get_options(&options))
164  log->error("failed to read config of %s", PORT);
165 
166  cfsetispeed(&options, new_baudrate);
167  cfsetospeed(&options, new_baudrate);
168 
169  if ((int)set_options(&options))
170  log->error("failed to write baudrate %i", new_baudrate);
171 
172  return new_baudrate;
173  }
174 
176  uint32_t character_size;
177  switch (word_length) {
179  character_size = CS5;
180  break;
182  character_size = CS6;
183  break;
185  character_size = CS7;
186  break;
187  default:
189  character_size = CS8;
190  break;
191  }
192 
193  struct termios options;
194 
195  err_t err = get_options(&options);
196  if ((int) err)
197  return err;
198 
199  options.c_cflag &= ~CSIZE; /* Mask the character size bits */
200  options.c_cflag |= character_size; /* Select data bits */
201 
202  return set_options(&options);
203 
204  }
205 
207  struct termios options;
208 
209  err_t err = get_options(&options);
210  if ((int) err)
211  return err;
212 
213  switch (parity_bit) {
215  options.c_cflag |= PARENB;
216  options.c_cflag &= ~PARODD;
217  options.c_cflag &= ~CSTOPB;
218  options.c_iflag |= (INPCK | ISTRIP);
219  break;
220  case UART::parity_t::ODD:
221  options.c_cflag |= PARENB;
222  options.c_cflag |= PARODD;
223  options.c_cflag &= ~CSTOPB;
224  options.c_iflag |= (INPCK | ISTRIP);
225  break;
226  default:
228  options.c_cflag &= ~PARENB;
229  options.c_cflag &= ~CSTOPB;
230  break;
231  }
232 
233  return set_options(&options);
234 
235  }
236 
238  struct termios options;
239 
240  err_t err = get_options(&options);
241  if ((int) err)
242  return err;
243  switch (new_flowcontrol) {
245 #ifdef CNEW_RTSCTS
246  options.c_cflag |= CNEW_RTSCTS; /* Also called CRTSCTS */
247 #else
248  return err_t::NOT_SUPPORTED;
249 #endif
250  options.c_iflag &= ~(IXON | IXOFF | IXANY);
251  break;
253  options.c_iflag |= (IXON | IXOFF | IXANY);
254  options.c_cc[VSTART] = XON;
255  options.c_cc[VSTOP] = XOFF;
256 #ifdef CNEW_RTSCTS
257  options.c_cflag &= ~CNEW_RTSCTS;
258 #endif
259  break;
261  options.c_iflag |= (IXON | IXOFF | IXANY);
262  options.c_cc[VSTART] = XON;
263  options.c_cc[VSTOP] = XOFF;
264 #ifdef CNEW_RTSCTS
265  options.c_cflag |= CNEW_RTSCTS; /* Also called CRTSCTS */
266 #else
267  return err_t::NOT_SUPPORTED;
268 #endif
269  break;
270  default:
272 #ifdef CNEW_RTSCTS
273  options.c_cflag &= ~CNEW_RTSCTS;
274 #endif
275  options.c_iflag &= ~(IXON | IXOFF | IXANY);
276  break;
277 
278  }
279 
280  return set_options(&options);
281  }
282 
284  struct termios options;
285 
286  err_t err = get_options(&options);
287  if ((int) err)
288  return err;
289  switch (stop_bit) {
291  options.c_cflag &= ~CSTOPB;
292  break;
294  options.c_cflag |= CSTOPB;
295  break;
296  default:
298  return err_t::NOT_SUPPORTED;
299  break;
300  }
301 
302 
303  return set_options(&options);
304  }
305 
307  struct termios options;
308 
309  err_t err = get_options(&options);
310  if ((int) err)
311  return err;
312 
313  options.c_lflag |= (ICANON | ECHO | ECHOE);
314 
315  return set_options(&options);
316 
317  }
318 
320  struct termios options;
321 
322  err_t err = get_options(&options);
323  if ((int) err)
324  return err;
325 
326  options.c_oflag |= OPOST;
327 
328  return set_options(&options);
329 
330  }
331 
333  struct termios options;
334 
335  err_t err = get_options(&options);
336  if ((int) err)
337  return err;
338 
339  options.c_oflag &= ~OPOST;
340 
341  return set_options(&options);
342 
343  }
344 
346  struct termios options;
347 
348  err_t err = get_options(&options);
349  if ((int) err)
350  return err;
351 
352  options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
353  /*
354  * Set the new options for the port...
355  */
356  return set_options(&options);
357 
358  }
359 
361  struct termios options;
362 
363  err_t err = get_options(&options);
364  if ((int) err)
365  return err;
366 
367  options.c_oflag |= OPOST;
368  options.c_oflag |= ONLCR;
369 
370  return set_options(&options);
371  }
372 
373  err_t POSIX_UART::set_options(struct termios *options) {
374  /*
375  * Set the new options for the port...
376  */
377  if (tcsetattr(file_description, TCSADRAIN, options) == -1) {
378  log->error("Error with tcsetattr = %s", strerror(errno));
380  }
381  return err_t::OK;
382  }
383 
384  err_t POSIX_UART::get_options(struct termios *options) {
385  /*
386  * Get the current options for the port...
387  */
388  if (tcgetattr(file_description, options) == -1) {
389  log->error("Error with tcgetattr = %s", strerror(errno));
391  }
392  return err_t::OK;
393  }
394 
395 // TODO set_options with lamba as paremeter
396 
397 }
uint32_t set_baudrate(uint32_t new_baudrate)
Set baudrate of the UART.
Definition: UART.cpp:27
err_t set_options(struct termios *options)
Set options to the file description of the UART.
Definition: POSIX_UART.cpp:373
err_t canonical_input()
Set input to Canonical.
Definition: POSIX_UART.cpp:306
err_t set_word_length(word_length_t word_length)
Set UART data bits length.
Definition: UART.cpp:107
err_t processed_output()
Process output before sending it (enabled c_oflag)
Definition: POSIX_UART.cpp:319
err_t _set_word_length(word_length_t word_length) override
Set UART data bits length.
Definition: POSIX_UART.cpp:175
err_t _set_parity(parity_t parity_bit) override
Set parity bit.
Definition: POSIX_UART.cpp:206
uint32_t _set_baudrate(uint32_t new_baudrate) override
Set baudrate of the UART.
Definition: POSIX_UART.cpp:61
err_t set_parity(parity_t parity_bit)
Set parity bit.
Definition: UART.cpp:49
uint32_t baudrate
Definition: UART.h:44
size_t _write(uint8_t *data, size_t dataSize) override
write data to the link/bus.
Definition: POSIX_UART.cpp:16
aruna::log::channel_t * log
Definition: POSIX_UART.h:71
static const uint8_t XON
Definition: UART.h:90
size_t _read(uint8_t *buffer, size_t buffer_size) override
Read bytes and out them in the buffer.
Definition: POSIX_UART.cpp:20
POSIX_UART(char *port, uint32_t baudrate)
Definition: POSIX_UART.cpp:24
err_t get_options(struct termios *options)
Get options of the file description UART device.
Definition: POSIX_UART.cpp:384
err_t raw_output()
Disabled output processing (disabled c_oflag)
Definition: POSIX_UART.cpp:332
err_t _set_stop_bit(stop_bit_t stop_bit) override
set stop bit
Definition: POSIX_UART.cpp:283
int error(const char *format,...)
log error message
Definition: log.cpp:90
err_t map_NL_to_CRNL()
Map Newline to CR-NL for output.
Definition: POSIX_UART.cpp:360
err_t _set_flowcontrol(flowcontrol_t new_flowcontrol) override
Set software or hardware flowcontrol.
Definition: POSIX_UART.cpp:237
err_t set_flowcontrol(flowcontrol_t new_flowcontrol)
Set software or hardware flowcontrol.
Definition: UART.cpp:38
static const comm::port_t port
Definition: reporter.h:15
static const uint8_t XOFF
Definition: UART.h:91
err_t raw_input()
Set input to raw.
Definition: POSIX_UART.cpp:345