1//
2// impl/serial_port_base.ipp
3// ~~~~~~~~~~~~~~~~~~~~~~~~~
4//
5// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
6// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
7//
8// Distributed under the Boost Software License, Version 1.0. (See accompanying
9// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
10//
11
12#ifndef BOOST_ASIO_IMPL_SERIAL_PORT_BASE_IPP
13#define BOOST_ASIO_IMPL_SERIAL_PORT_BASE_IPP
14
15#if defined(_MSC_VER) && (_MSC_VER >= 1200)
16# pragma once
17#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
18
19#include <boost/asio/detail/config.hpp>
20
21#if defined(BOOST_ASIO_HAS_SERIAL_PORT)
22
23#include <stdexcept>
24#include <boost/asio/error.hpp>
25#include <boost/asio/serial_port_base.hpp>
26#include <boost/asio/detail/throw_exception.hpp>
27
28#if defined(GENERATING_DOCUMENTATION)
29# define BOOST_ASIO_OPTION_STORAGE implementation_defined
30#elif defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
31# define BOOST_ASIO_OPTION_STORAGE DCB
32#else
33# define BOOST_ASIO_OPTION_STORAGE termios
34#endif
35
36#include <boost/asio/detail/push_options.hpp>
37
38namespace boost {
39namespace asio {
40
41boost::system::error_code serial_port_base::baud_rate::store(
42 BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
43{
44#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
45 storage.BaudRate = value_;
46#else
47 speed_t baud;
48 switch (value_)
49 {
50 // Do POSIX-specified rates first.
51 case 0: baud = B0; break;
52 case 50: baud = B50; break;
53 case 75: baud = B75; break;
54 case 110: baud = B110; break;
55 case 134: baud = B134; break;
56 case 150: baud = B150; break;
57 case 200: baud = B200; break;
58 case 300: baud = B300; break;
59 case 600: baud = B600; break;
60 case 1200: baud = B1200; break;
61 case 1800: baud = B1800; break;
62 case 2400: baud = B2400; break;
63 case 4800: baud = B4800; break;
64 case 9600: baud = B9600; break;
65 case 19200: baud = B19200; break;
66 case 38400: baud = B38400; break;
67 // And now the extended ones conditionally.
68# ifdef B7200
69 case 7200: baud = B7200; break;
70# endif
71# ifdef B14400
72 case 14400: baud = B14400; break;
73# endif
74# ifdef B57600
75 case 57600: baud = B57600; break;
76# endif
77# ifdef B115200
78 case 115200: baud = B115200; break;
79# endif
80# ifdef B230400
81 case 230400: baud = B230400; break;
82# endif
83# ifdef B460800
84 case 460800: baud = B460800; break;
85# endif
86# ifdef B500000
87 case 500000: baud = B500000; break;
88# endif
89# ifdef B576000
90 case 576000: baud = B576000; break;
91# endif
92# ifdef B921600
93 case 921600: baud = B921600; break;
94# endif
95# ifdef B1000000
96 case 1000000: baud = B1000000; break;
97# endif
98# ifdef B1152000
99 case 1152000: baud = B1152000; break;
100# endif
101# ifdef B2000000
102 case 2000000: baud = B2000000; break;
103# endif
104# ifdef B3000000
105 case 3000000: baud = B3000000; break;
106# endif
107# ifdef B3500000
108 case 3500000: baud = B3500000; break;
109# endif
110# ifdef B4000000
111 case 4000000: baud = B4000000; break;
112# endif
113 default:
114 ec = boost::asio::error::invalid_argument;
115 return ec;
116 }
117# if defined(_BSD_SOURCE)
118 ::cfsetspeed(&storage, baud);
119# else
120 ::cfsetispeed(&storage, baud);
121 ::cfsetospeed(&storage, baud);
122# endif
123#endif
124 ec = boost::system::error_code();
125 return ec;
126}
127
128boost::system::error_code serial_port_base::baud_rate::load(
129 const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
130{
131#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
132 value_ = storage.BaudRate;
133#else
134 speed_t baud = ::cfgetospeed(&storage);
135 switch (baud)
136 {
137 // First do those specified by POSIX.
138 case B0: value_ = 0; break;
139 case B50: value_ = 50; break;
140 case B75: value_ = 75; break;
141 case B110: value_ = 110; break;
142 case B134: value_ = 134; break;
143 case B150: value_ = 150; break;
144 case B200: value_ = 200; break;
145 case B300: value_ = 300; break;
146 case B600: value_ = 600; break;
147 case B1200: value_ = 1200; break;
148 case B1800: value_ = 1800; break;
149 case B2400: value_ = 2400; break;
150 case B4800: value_ = 4800; break;
151 case B9600: value_ = 9600; break;
152 case B19200: value_ = 19200; break;
153 case B38400: value_ = 38400; break;
154 // Now conditionally handle a bunch of extended rates.
155# ifdef B7200
156 case B7200: value_ = 7200; break;
157# endif
158# ifdef B14400
159 case B14400: value_ = 14400; break;
160# endif
161# ifdef B57600
162 case B57600: value_ = 57600; break;
163# endif
164# ifdef B115200
165 case B115200: value_ = 115200; break;
166# endif
167# ifdef B230400
168 case B230400: value_ = 230400; break;
169# endif
170# ifdef B460800
171 case B460800: value_ = 460800; break;
172# endif
173# ifdef B500000
174 case B500000: value_ = 500000; break;
175# endif
176# ifdef B576000
177 case B576000: value_ = 576000; break;
178# endif
179# ifdef B921600
180 case B921600: value_ = 921600; break;
181# endif
182# ifdef B1000000
183 case B1000000: value_ = 1000000; break;
184# endif
185# ifdef B1152000
186 case B1152000: value_ = 1152000; break;
187# endif
188# ifdef B2000000
189 case B2000000: value_ = 2000000; break;
190# endif
191# ifdef B3000000
192 case B3000000: value_ = 3000000; break;
193# endif
194# ifdef B3500000
195 case B3500000: value_ = 3500000; break;
196# endif
197# ifdef B4000000
198 case B4000000: value_ = 4000000; break;
199# endif
200 default:
201 value_ = 0;
202 ec = boost::asio::error::invalid_argument;
203 return ec;
204 }
205#endif
206 ec = boost::system::error_code();
207 return ec;
208}
209
210serial_port_base::flow_control::flow_control(
211 serial_port_base::flow_control::type t)
212 : value_(t)
213{
214 if (t != none && t != software && t != hardware)
215 {
216 std::out_of_range ex("invalid flow_control value");
217 boost::asio::detail::throw_exception(ex);
218 }
219}
220
221boost::system::error_code serial_port_base::flow_control::store(
222 BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
223{
224#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
225 storage.fOutxCtsFlow = FALSE;
226 storage.fOutxDsrFlow = FALSE;
227 storage.fTXContinueOnXoff = TRUE;
228 storage.fDtrControl = DTR_CONTROL_ENABLE;
229 storage.fDsrSensitivity = FALSE;
230 storage.fOutX = FALSE;
231 storage.fInX = FALSE;
232 storage.fRtsControl = RTS_CONTROL_ENABLE;
233 switch (value_)
234 {
235 case none:
236 break;
237 case software:
238 storage.fOutX = TRUE;
239 storage.fInX = TRUE;
240 break;
241 case hardware:
242 storage.fOutxCtsFlow = TRUE;
243 storage.fRtsControl = RTS_CONTROL_HANDSHAKE;
244 break;
245 default:
246 break;
247 }
248#else
249 switch (value_)
250 {
251 case none:
252 storage.c_iflag &= ~(IXOFF | IXON);
253# if defined(_BSD_SOURCE)
254 storage.c_cflag &= ~CRTSCTS;
255# elif defined(__QNXNTO__)
256 storage.c_cflag &= ~(IHFLOW | OHFLOW);
257# endif
258 break;
259 case software:
260 storage.c_iflag |= IXOFF | IXON;
261# if defined(_BSD_SOURCE)
262 storage.c_cflag &= ~CRTSCTS;
263# elif defined(__QNXNTO__)
264 storage.c_cflag &= ~(IHFLOW | OHFLOW);
265# endif
266 break;
267 case hardware:
268# if defined(_BSD_SOURCE)
269 storage.c_iflag &= ~(IXOFF | IXON);
270 storage.c_cflag |= CRTSCTS;
271 break;
272# elif defined(__QNXNTO__)
273 storage.c_iflag &= ~(IXOFF | IXON);
274 storage.c_cflag |= (IHFLOW | OHFLOW);
275 break;
276# else
277 ec = boost::asio::error::operation_not_supported;
278 return ec;
279# endif
280 default:
281 break;
282 }
283#endif
284 ec = boost::system::error_code();
285 return ec;
286}
287
288boost::system::error_code serial_port_base::flow_control::load(
289 const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
290{
291#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
292 if (storage.fOutX && storage.fInX)
293 {
294 value_ = software;
295 }
296 else if (storage.fOutxCtsFlow && storage.fRtsControl == RTS_CONTROL_HANDSHAKE)
297 {
298 value_ = hardware;
299 }
300 else
301 {
302 value_ = none;
303 }
304#else
305 if (storage.c_iflag & (IXOFF | IXON))
306 {
307 value_ = software;
308 }
309# if defined(_BSD_SOURCE)
310 else if (storage.c_cflag & CRTSCTS)
311 {
312 value_ = hardware;
313 }
314# elif defined(__QNXNTO__)
315 else if (storage.c_cflag & IHFLOW && storage.c_cflag & OHFLOW)
316 {
317 value_ = hardware;
318 }
319# endif
320 else
321 {
322 value_ = none;
323 }
324#endif
325 ec = boost::system::error_code();
326 return ec;
327}
328
329serial_port_base::parity::parity(serial_port_base::parity::type t)
330 : value_(t)
331{
332 if (t != none && t != odd && t != even)
333 {
334 std::out_of_range ex("invalid parity value");
335 boost::asio::detail::throw_exception(ex);
336 }
337}
338
339boost::system::error_code serial_port_base::parity::store(
340 BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
341{
342#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
343 switch (value_)
344 {
345 case none:
346 storage.fParity = FALSE;
347 storage.Parity = NOPARITY;
348 break;
349 case odd:
350 storage.fParity = TRUE;
351 storage.Parity = ODDPARITY;
352 break;
353 case even:
354 storage.fParity = TRUE;
355 storage.Parity = EVENPARITY;
356 break;
357 default:
358 break;
359 }
360#else
361 switch (value_)
362 {
363 case none:
364 storage.c_iflag |= IGNPAR;
365 storage.c_cflag &= ~(PARENB | PARODD);
366 break;
367 case even:
368 storage.c_iflag &= ~(IGNPAR | PARMRK);
369 storage.c_iflag |= INPCK;
370 storage.c_cflag |= PARENB;
371 storage.c_cflag &= ~PARODD;
372 break;
373 case odd:
374 storage.c_iflag &= ~(IGNPAR | PARMRK);
375 storage.c_iflag |= INPCK;
376 storage.c_cflag |= (PARENB | PARODD);
377 break;
378 default:
379 break;
380 }
381#endif
382 ec = boost::system::error_code();
383 return ec;
384}
385
386boost::system::error_code serial_port_base::parity::load(
387 const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
388{
389#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
390 if (storage.Parity == EVENPARITY)
391 {
392 value_ = even;
393 }
394 else if (storage.Parity == ODDPARITY)
395 {
396 value_ = odd;
397 }
398 else
399 {
400 value_ = none;
401 }
402#else
403 if (storage.c_cflag & PARENB)
404 {
405 if (storage.c_cflag & PARODD)
406 {
407 value_ = odd;
408 }
409 else
410 {
411 value_ = even;
412 }
413 }
414 else
415 {
416 value_ = none;
417 }
418#endif
419 ec = boost::system::error_code();
420 return ec;
421}
422
423serial_port_base::stop_bits::stop_bits(
424 serial_port_base::stop_bits::type t)
425 : value_(t)
426{
427 if (t != one && t != onepointfive && t != two)
428 {
429 std::out_of_range ex("invalid stop_bits value");
430 boost::asio::detail::throw_exception(ex);
431 }
432}
433
434boost::system::error_code serial_port_base::stop_bits::store(
435 BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
436{
437#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
438 switch (value_)
439 {
440 case one:
441 storage.StopBits = ONESTOPBIT;
442 break;
443 case onepointfive:
444 storage.StopBits = ONE5STOPBITS;
445 break;
446 case two:
447 storage.StopBits = TWOSTOPBITS;
448 break;
449 default:
450 break;
451 }
452#else
453 switch (value_)
454 {
455 case one:
456 storage.c_cflag &= ~CSTOPB;
457 break;
458 case two:
459 storage.c_cflag |= CSTOPB;
460 break;
461 default:
462 ec = boost::asio::error::operation_not_supported;
463 return ec;
464 }
465#endif
466 ec = boost::system::error_code();
467 return ec;
468}
469
470boost::system::error_code serial_port_base::stop_bits::load(
471 const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
472{
473#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
474 if (storage.StopBits == ONESTOPBIT)
475 {
476 value_ = one;
477 }
478 else if (storage.StopBits == ONE5STOPBITS)
479 {
480 value_ = onepointfive;
481 }
482 else if (storage.StopBits == TWOSTOPBITS)
483 {
484 value_ = two;
485 }
486 else
487 {
488 value_ = one;
489 }
490#else
491 value_ = (storage.c_cflag & CSTOPB) ? two : one;
492#endif
493 ec = boost::system::error_code();
494 return ec;
495}
496
497serial_port_base::character_size::character_size(unsigned int t)
498 : value_(t)
499{
500 if (t < 5 || t > 8)
501 {
502 std::out_of_range ex("invalid character_size value");
503 boost::asio::detail::throw_exception(ex);
504 }
505}
506
507boost::system::error_code serial_port_base::character_size::store(
508 BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec) const
509{
510#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
511 storage.ByteSize = value_;
512#else
513 storage.c_cflag &= ~CSIZE;
514 switch (value_)
515 {
516 case 5: storage.c_cflag |= CS5; break;
517 case 6: storage.c_cflag |= CS6; break;
518 case 7: storage.c_cflag |= CS7; break;
519 case 8: storage.c_cflag |= CS8; break;
520 default: break;
521 }
522#endif
523 ec = boost::system::error_code();
524 return ec;
525}
526
527boost::system::error_code serial_port_base::character_size::load(
528 const BOOST_ASIO_OPTION_STORAGE& storage, boost::system::error_code& ec)
529{
530#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
531 value_ = storage.ByteSize;
532#else
533 if ((storage.c_cflag & CSIZE) == CS5) { value_ = 5; }
534 else if ((storage.c_cflag & CSIZE) == CS6) { value_ = 6; }
535 else if ((storage.c_cflag & CSIZE) == CS7) { value_ = 7; }
536 else if ((storage.c_cflag & CSIZE) == CS8) { value_ = 8; }
537 else
538 {
539 // Hmmm, use 8 for now.
540 value_ = 8;
541 }
542#endif
543 ec = boost::system::error_code();
544 return ec;
545}
546
547} // namespace asio
548} // namespace boost
549
550#include <boost/asio/detail/pop_options.hpp>
551
552#undef BOOST_ASIO_OPTION_STORAGE
553
554#endif // defined(BOOST_ASIO_HAS_SERIAL_PORT)
555
556#endif // BOOST_ASIO_IMPL_SERIAL_PORT_BASE_IPP
557