+
+
Constructor & Destructor Documentation
+
+
+
+
+
: pimpl_(pimpl) {
+ this->pimpl_->readLock();
+ }
+
+
+
+
+
+
+
+
{
+ this->pimpl_->readUnlock();
+ }
+
+
+
+
The documentation for this class was generated from the following file:
+
+
+
Constructor & Destructor Documentation
+
+
+
+
+
: pimpl_(pimpl) {
+ this->pimpl_->writeLock();
+ }
+
+
+
+
+
+
+
+
{
+ this->pimpl_->writeUnlock();
+ }
+
+
+
+
The documentation for this class was generated from the following file:
+
+
+
#include <serial.h>
+
+
Constructor & Destructor Documentation
+
+
+
+
+
: file_(file), line_(line), e_what_ (strerror (errnum)), errno_(errnum) {}
+
+
+
+
+
+
+
+
: file_(file), line_(line), e_what_ (description), errno_(0) {}
+
+
+
+
+
+
Member Function Documentation
+
+
+
+
+
+
+
{
+ std::stringstream ss;
+ if (errno_ == 0)
+ ss << "IO Exception: " << e_what_;
+ else
+ ss << "IO Exception (" << errno_ << "): " << e_what_;
+ ss << ", file " << file_ << ", line " << line_ << ".";
+ return ss.str ().c_str ();
+ }
+
+
+
+
The documentation for this class was generated from the following file:
+
+
+
#include <serial.h>
+
+
Constructor & Destructor Documentation
+
+
+
+
+
: e_what_ (description) {}
+
+
+
+
Member Function Documentation
+
+
+
+
+
{
+ std::stringstream ss;
+ ss << e_what_ << " called before port was opened.";
+ return ss.str ().c_str ();
+ }
+
+
+
+
The documentation for this class was generated from the following file:
+
+
+
#include <serial.h>
+
+
+Data Structures |
+| class | ScopedReadLock |
+| class | ScopedWriteLock |
+
+Public Member Functions |
+| | Serial (const std::string &port="", unsigned long baudrate=9600, bytesize_t bytesize=eightbits, parity_t parity=parity_none, stopbits_t stopbits=stopbits_one, flowcontrol_t flowcontrol=flowcontrol_none) |
+| virtual | ~Serial () |
+| void | open () |
+| bool | isOpen () const |
+| void | close () |
+| size_t | available () |
+| size_t | read (unsigned char *buffer, size_t size) |
+| size_t | read (std::vector< unsigned char > &buffer, size_t size=1) |
+| size_t | read (std::string &buffer, size_t size=1) |
+| std::string | read (size_t size=1) |
+| size_t | readline (std::string &buffer, size_t size=65536, std::string eol="\n") |
+| std::string | readline (size_t size=65536, std::string eol="\n") |
+| std::vector< std::string > | readlines (size_t size=65536, std::string eol="\n") |
+| size_t | write (const unsigned char *data, size_t size) |
+| size_t | write (const std::vector< unsigned char > &data) |
+| size_t | write (const std::string &data) |
+| void | setPort (const std::string &port) |
+| std::string | getPort () const |
+| void | setTimeout (timeout_t &timeout) |
+| void | setTimeout (long inter_byte_timeout, long read_timeout_constant, long read_timeout_multiplier, long write_timeout_constant, long write_timeout_multiplier) |
+| timeout_t | getTimeout () const |
+| void | setBaudrate (unsigned long baudrate) |
+| unsigned long | getBaudrate () const |
+| void | setBytesize (bytesize_t bytesize) |
+| bytesize_t | getBytesize () const |
+| void | setParity (parity_t parity) |
+| parity_t | getParity () const |
+| void | setStopbits (stopbits_t stopbits) |
+| stopbits_t | getStopbits () const |
+| void | setFlowcontrol (flowcontrol_t flowcontrol) |
+| flowcontrol_t | getFlowcontrol () const |
+| void | flush () |
+| void | flushInput () |
+| void | flushOutput () |
+| void | sendBreak (int duration) |
+| void | setBreak (bool level=true) |
+| void | setRTS (bool level=true) |
+| void | setDTR (bool level=true) |
+| bool | waitForChange () |
+| bool | getCTS () |
+| bool | getDSR () |
+| bool | getRI () |
+| bool | getCD () |
+
+
Detailed Description
+
Class that provides a portable serial port interface.
+
Constructor & Destructor Documentation
+
+
+
+
+
Creates a Serial object and opens the port if a port is specified, otherwise it remains closed until serial::Serial::open is called.
+
- Parameters:
-
+
+ | port | A std::string containing the address of the serial port, which would be something like 'COM1' on Windows and '/dev/ttyS0' on Linux. |
+ | baudrate | An integer that represents the baudrate |
+ | bytesize | Size of each byte in the serial transmission of data, default is eightbits, possible values are: fivebits, sixbits, sevenbits, eightbits |
+ | parity | Method of parity, default is parity_none, possible values are: parity_none, parity_odd, parity_even |
+ | stopbits | Number of stop bits used, default is stopbits_one, possible values are: stopbits_one, stopbits_one_point_five, stopbits_two |
+ | flowcontrol | Type of flowcontrol used, default is flowcontrol_none, possible values are: flowcontrol_none, flowcontrol_software, flowcontrol_hardware |
+
+
+
+
- Exceptions:
-
+
+
+
+
+
+
+
+
+
Member Function Documentation
+
+
+
+
+
Return the number of characters in the buffer.
+
+
+
+
+
+
+
+
Closes the serial port.
+
{
+ pimpl_->close ();
+}
+
+
+
+
+
+
+
+
Flush the input and output buffers
+
{
+ ScopedReadLock(this->pimpl_);
+ ScopedWriteLock(this->pimpl_);
+ pimpl_->flush ();
+ read_cache_.clear ();
+}
+
+
+
+
+
+
+
+
Flush only the input buffer
+
{
+ ScopedReadLock(this->pimpl_);
+ pimpl_->flushInput ();
+}
+
+
+
+
+
+
+
+
Flush only the output buffer
+
{
+ ScopedWriteLock(this->pimpl_);
+ pimpl_->flushOutput ();
+ read_cache_.clear ();
+}
+
+
+
+
+
+
+
+
Gets the baudrate for the serial port.
+
- Returns:
- An integer that sets the baud rate for the serial port.
+
- See also:
- Serial::setBaudrate
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Gets the bytesize for the serial port.
+
- See also:
- Serial::setBytesize
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Returns the current status of the CD line.
+
{
+ return pimpl_->getCD ();
+}
+
+
+
+
+
+
+
+
Returns the current status of the CTS line.
+
{
+ return pimpl_->getCTS ();
+}
+
+
+
+
+
+
+
+
Returns the current status of the DSR line.
+
{
+ return pimpl_->getDSR ();
+}
+
+
+
+
+
+
+
+
Gets the flow control for the serial port.
+
- See also:
- Serial::setFlowcontrol
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Gets the parity for the serial port.
+
- See also:
- Serial::setParity
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Gets the serial port identifier.
+
- See also:
- Serial::setPort
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
{
+ return pimpl_->getPort ();
+}
+
+
+
+
+
+
+
+
Returns the current status of the RI line.
+
{
+ return pimpl_->getRI ();
+}
+
+
+
+
+
+
+
+
Gets the stopbits for the serial port.
+
- See also:
- Serial::setStopbits
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Gets the timeout for reads in seconds.
+
- Returns:
- A timeout_t struct containing the inter_byte_timeout, and read and write timeout constants and multipliers.
+
- See also:
- Serial::setTimeout
+
+
+
+
+
+
+
+
Gets the open status of the serial port.
+
- Returns:
- Returns true if the port is open, false otherwise.
+
{
+ return pimpl_->isOpen ();
+}
+
+
+
+
+
+
+
+
Opens the serial port as long as the port is set and the port isn't already open.
+
If the port is provided to the constructor then an explicit call to open is not needed.
+
- See also:
- Serial::Serial
+
- Exceptions:
-
+
+
+
+
{
+ pimpl_->open ();
+}
+
+
+
+
+
+
+
+
+ | size_t Serial::read |
+ ( |
+ unsigned char * |
+ buffer, |
+
+
+ |
+ |
+ size_t |
+ size |
+
+
+ |
+ ) |
+ | |
+
+
+
+
+
Read a given amount of bytes from the serial port into a given buffer.
+
The read function will return in one of three cases:
+
+- The number of requested bytes was read.
+- In this case the number of bytes requested will match the size_t returned by read.
+
+
+- A timeout occurred, in this case the number of bytes read will not match the amount requested, but no exception will be thrown. One of two possible timeouts occurred:
+- The inter byte timeout expired, this means that number of milliseconds elapsed between receiving bytes from the serial port exceeded the inter byte timeout.
+- The total timeout expired, which is calculated by multiplying the read timeout multiplier by the number of requested bytes and then added to the read timeout constant. If that total number of milliseconds elapses after the initial call to read a timeout will occur.
+
+
+- An exception occurred, in this case an actual exception will be thrown.
+
+
- Parameters:
-
+
+ | buffer | An unsigned char array of at least the requested size. |
+ | size | A size_t defining how many bytes to be read. |
+
+
+
+
- Returns:
- A size_t representing the number of bytes read as a result of the call to read.
+
{
+ ScopedReadLock (this->pimpl_);
+ return this->pimpl_->read (buffer, size);
+}
+
+
+
+
+
+
+
+
+ | size_t Serial::read |
+ ( |
+ std::vector< unsigned char > & |
+ buffer, |
+
+
+ |
+ |
+ size_t |
+ size = 1 |
+
+
+ |
+ ) |
+ | |
+
+
+
+
+
Read a given amount of bytes from the serial port into a give buffer.
+
- Parameters:
-
+
+ | buffer | A reference to a std::vector of unsigned char. |
+ | size | A size_t defining how many bytes to be read. |
+
+
+
+
- Returns:
- A size_t representing the number of bytes read as a result of the call to read.
+
{
+ ScopedReadLock (this->pimpl_);
+ unsigned char *buffer_ = new unsigned char[size];
+ size_t bytes_read = this->pimpl_->read (buffer_, size);
+ buffer.insert (buffer.end (), buffer_, buffer_+bytes_read);
+ delete[] buffer_;
+ return bytes_read;
+}
+
+
+
+
+
+
+
+
+ | size_t Serial::read |
+ ( |
+ std::string & |
+ buffer, |
+
+
+ |
+ |
+ size_t |
+ size = 1 |
+
+
+ |
+ ) |
+ | |
+
+
+
+
+
Read a given amount of bytes from the serial port into a give buffer.
+
- Parameters:
-
+
+ | buffer | A reference to a std::string. |
+ | size | A size_t defining how many bytes to be read. |
+
+
+
+
- Returns:
- A size_t representing the number of bytes read as a result of the call to read.
+
{
+ ScopedReadLock (this->pimpl_);
+ unsigned char *buffer_ = new unsigned char[size];
+ size_t bytes_read = this->pimpl_->read (buffer_, size);
+ buffer.append (reinterpret_cast<const char*>(buffer_), bytes_read);
+ delete[] buffer_;
+ return bytes_read;
+}
+
+
+
+
+
+
+
+
Read a given amount of bytes from the serial port and return a string containing the data.
+
- Parameters:
-
+
+ | size | A size_t defining how many bytes to be read. |
+
+
+
+
- Returns:
- A std::string containing the data read from the port.
+
{
+ std::string buffer;
+ this->read (buffer, size);
+ return buffer;
+}
+
+
+
+
+
+
+
+
+ | size_t serial::Serial::readline |
+ ( |
+ std::string & |
+ buffer, |
+
+
+ |
+ |
+ size_t |
+ size = 65536, |
+
+
+ |
+ |
+ std::string |
+ eol = "\n" |
+
+
+ |
+ ) |
+ | |
+
+
+
+
+
Reads in a line or until a given delimiter has been processed.
+
Reads from the serial port until a single line has been read.
+
- Parameters:
-
+
+ | buffer | A std::string reference used to store the data. |
+ | size | A maximum length of a line, defaults to 65536 (2^16) |
+ | eol | A string to match against for the EOL. |
+
+
+
+
- Returns:
- A size_t representing the number of bytes read.
+
+
+
+
+
+
+
+
+ | std::string serial::Serial::readline |
+ ( |
+ size_t |
+ size = 65536, |
+
+
+ |
+ |
+ std::string |
+ eol = "\n" |
+
+
+ |
+ ) |
+ | |
+
+
+
+
+
Reads in a line or until a given delimiter has been processed.
+
Reads from the serial port until a single line has been read.
+
- Parameters:
-
+
+ | size | A maximum length of a line, defaults to 65536 (2^16) |
+ | eol | A string to match against for the EOL. |
+
+
+
+
- Returns:
- A std::string containing the line.
+
+
+
+
+
+
+
+
+ | vector< string > Serial::readlines |
+ ( |
+ size_t |
+ size = 65536, |
+
+
+ |
+ |
+ std::string |
+ eol = "\n" |
+
+
+ |
+ ) |
+ | |
+
+
+
+
+
Reads in multiple lines until the serial port times out.
+
This requires a timeout > 0 before it can be run. It will read until a timeout occurs and return a list of strings.
+
- Parameters:
-
+
+ | size | A maximum length of combined lines, defaults to 65536 (2^16) |
+ | eol | A string to match against for the EOL. |
+
+
+
+
- Returns:
- A vector<string> containing the lines.
+
{
+ ScopedReadLock (this->pimpl_);
+ std::vector<std::string> lines;
+ size_t eol_len = eol.length ();
+ unsigned char *buffer_ = static_cast<unsigned char*>
+ (alloca (size * sizeof (unsigned char)));
+ size_t read_so_far = 0;
+ size_t start_of_line = 0;
+ while (read_so_far < size) {
+ size_t bytes_read = this->read_ (buffer_+read_so_far, 1);
+ read_so_far += bytes_read;
+ if (bytes_read == 0) {
+ if (start_of_line != read_so_far) {
+ lines.push_back (
+ string (reinterpret_cast<const char*> (buffer_ + start_of_line),
+ read_so_far - start_of_line));
+ }
+ break;
+ }
+ if (string (reinterpret_cast<const char*>
+ (buffer_ + read_so_far - eol_len), eol_len) == eol) {
+
+ lines.push_back(
+ string(reinterpret_cast<const char*> (buffer_ + start_of_line),
+ read_so_far - start_of_line));
+ start_of_line = read_so_far;
+ }
+ if (read_so_far == size) {
+ if (start_of_line != read_so_far) {
+ lines.push_back(
+ string(reinterpret_cast<const char*> (buffer_ + start_of_line),
+ read_so_far - start_of_line));
+ }
+ break;
+ }
+ }
+ return lines;
+}
+
+
+
+
+
+
+
+
Sends the RS-232 break signal. See tcsendbreak(3).
+
+
+
+
+
+
+
+
Sets the baudrate for the serial port.
+
Possible baudrates depends on the system but some safe baudrates include: 110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 56000, 57600, 115200 Some other baudrates that are supported by some comports: 128000, 153600, 230400, 256000, 460800, 921600
+
- Parameters:
-
+
+ | baudrate | An integer that sets the baud rate for the serial port. |
+
+
+
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Set the break condition to a given level. Defaults to true.
+
+
+
+
+
+
+
+
Sets the bytesize for the serial port.
+
- Parameters:
-
+
+ | bytesize | Size of each byte in the serial transmission of data, default is eightbits, possible values are: fivebits, sixbits, sevenbits, eightbits |
+
+
+
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Set the DTR handshaking line to the given level. Defaults to true.
+
{
+ pimpl_->setDTR (level);
+}
+
+
+
+
+
+
+
+
Sets the flow control for the serial port.
+
- Parameters:
-
+
+ | flowcontrol | Type of flowcontrol used, default is flowcontrol_none, possible values are: flowcontrol_none, flowcontrol_software, flowcontrol_hardware |
+
+
+
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Sets the parity for the serial port.
+
- Parameters:
-
+
+ | parity | Method of parity, default is parity_none, possible values are: parity_none, parity_odd, parity_even |
+
+
+
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Sets the serial port identifier.
+
- Parameters:
-
+
+ | port | A const std::string reference containing the address of the serial port, which would be something like 'COM1' on Windows and '/dev/ttyS0' on Linux. |
+
+
+
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
{
+ ScopedReadLock(this->pimpl_);
+ ScopedWriteLock(this->pimpl_);
+ bool was_open = pimpl_->isOpen ();
+ if (was_open) close();
+ pimpl_->setPort (port);
+ if (was_open) open ();
+}
+
+
+
+
+
+
+
+
Set the RTS handshaking line to the given level. Defaults to true.
+
{
+ pimpl_->setRTS (level);
+}
+
+
+
+
+
+
+
+
Sets the stopbits for the serial port.
+
- Parameters:
-
+
+ | stopbits | Number of stop bits used, default is stopbits_one, possible values are: stopbits_one, stopbits_one_point_five, stopbits_two |
+
+
+
+
- Exceptions:
-
+
+ | InvalidConfigurationException | |
+
+
+
+
+
+
+
+
+
+
+
Sets the timeout for reads and writes using the timeout_t struct.
+
There are two basic conditions for timeout described here, the inter byte timeout is the maximum amount of time in milliseconds allowed between receiving bytes from the serial port. The second condition is where the total timeout expires during a read or write. The total timeout can be calculated as the multiplier times the number of requested bytes plus the constant. In this way a single constant time timeout can be specified with zero for the inter byte timeout and zero for the multiplier. Alternatively, you could have only an inter byte timeout and zero for both the constant and multiplier to prevent a total time timeout from occurring.You can use the multiplier to increase the total time timeout based on the number of bytes requested. The user can combine any of these timeout metrics in order to achieve the desired trade-off between efficiency and responsiveness.
+
- Parameters:
-
+
+ | timeout | A timeout_t struct containing the inter byte timeout, and the read and write timeout constants and multipliers. |
+
+
+
+
- See also:
- serial::timeout_t
+
+
+
+
+
+
+
+
+ | void serial::Serial::setTimeout |
+ ( |
+ long |
+ inter_byte_timeout, |
+
+
+ |
+ |
+ long |
+ read_timeout_constant, |
+
+
+ |
+ |
+ long |
+ read_timeout_multiplier, |
+
+
+ |
+ |
+ long |
+ write_timeout_constant, |
+
+
+ |
+ |
+ long |
+ write_timeout_multiplier |
+
+
+ |
+ ) |
+ | [inline] |
+
+
+
+
+
Sets the timeout for reads and writes.
+
{
+ timeout_t timeout(inter_byte_timeout, read_timeout_constant,
+ read_timeout_multiplier, write_timeout_constant,
+ write_timeout_multiplier);
+ return setTimeout(timeout);
+ }
+
+
+
+
+
+
+
+
Returns true on CTS, DSR, RI, or CD changing.
+
Can throw an exception if an error occurs while waiting. You can check the status of CTS, DSR, RI, and CD once this returns. Uses TIOCMIWAIT via ioctl if available (mostly only on Linux) with a resolution of less than +-1ms and as good as +-0.2ms. Otherwise a polling method is used which can give +-2ms.
+
- Exceptions:
-
+
+
+
+
+
+
+
+
+
+
+
+ | size_t serial::Serial::write |
+ ( |
+ const unsigned char * |
+ data, |
+
+
+ |
+ |
+ size_t |
+ size |
+
+
+ |
+ ) |
+ | |
+
+
+
+
+
Write a string to the serial port.
+
- Parameters:
-
+
+ | data | A const reference containing the data to be written to the serial port. |
+ | size | A size_t that indicates how many bytes should be written from the given data buffer. |
+
+
+
+
- Returns:
- A size_t representing the number of bytes actually written to the serial port.
+
+
+
+
+
+
+
+
Write a string to the serial port.
+
- Parameters:
-
+
+ | data | A const reference containing the data to be written to the serial port. |
+
+
+
+
- Returns:
- A size_t representing the number of bytes actually written to the serial port.
+
+
+
+
+
+
+
+
Write a string to the serial port.
+
- Parameters:
-
+
+ | data | A const reference containing the data to be written to the serial port. |
+
+
+
+
- Returns:
- A size_t representing the number of bytes actually written to the serial port.
+
+
+
+
The documentation for this class was generated from the following files:
+
+
+
#include <serial.h>
+
The documentation for this class was generated from the following file:
+
+
+
#include <serial.h>
+
+
+Public Member Functions |
+| | SerialExecption (const char *description) |
+| virtual const char * | what () const throw () |
+
+
Constructor & Destructor Documentation
+
+
+
+
+
: e_what_ (description) {}
+
+
+
+
Member Function Documentation
+
+
+
+
+
{
+ std::stringstream ss;
+ ss << "SerialException " << e_what_ << " failed.";
+ return ss.str ().c_str ();
+ }
+
+
+
+
The documentation for this class was generated from the following file:
+
+
+
#include <unix.h>
+
+
+Public Member Functions |
+| | SerialImpl (const string &port, unsigned long baudrate, bytesize_t bytesize, parity_t parity, stopbits_t stopbits, flowcontrol_t flowcontrol) |
+| virtual | ~SerialImpl () |
+| void | open () |
+| void | close () |
+| bool | isOpen () const |
+| size_t | available () |
+| size_t | read (unsigned char *buf, size_t size=1) |
+| size_t | write (const string &data) |
+| void | flush () |
+| void | flushInput () |
+| void | flushOutput () |
+| void | sendBreak (int duration) |
+| void | setBreak (bool level) |
+| void | setRTS (bool level) |
+| void | setDTR (bool level) |
+| bool | waitForChange () |
+| bool | getCTS () |
+| bool | getDSR () |
+| bool | getRI () |
+| bool | getCD () |
+| void | setPort (const string &port) |
+| string | getPort () const |
+| void | setTimeout (timeout_t &timeout) |
+| timeout_t | getTimeout () const |
+| void | setBaudrate (unsigned long baudrate) |
+| unsigned long | getBaudrate () const |
+| void | setBytesize (bytesize_t bytesize) |
+| bytesize_t | getBytesize () const |
+| void | setParity (parity_t parity) |
+| parity_t | getParity () const |
+| void | setStopbits (stopbits_t stopbits) |
+| stopbits_t | getStopbits () const |
+| void | setFlowcontrol (flowcontrol_t flowcontrol) |
+| flowcontrol_t | getFlowcontrol () const |
+| void | readLock () |
+| void | readUnlock () |
+| void | writeLock () |
+| void | writeUnlock () |
+| | SerialImpl (const string &port, unsigned long baudrate, long timeout, bytesize_t bytesize, parity_t parity, stopbits_t stopbits, flowcontrol_t flowcontrol) |
+| virtual | ~SerialImpl () |
+| void | open () |
+| void | close () |
+| bool | isOpen () const |
+| size_t | available () |
+| size_t | read (char *buf, size_t size=1) |
+| size_t | write (const string &data) |
+| void | flush () |
+| void | flushInput () |
+| void | flushOutput () |
+| void | sendBreak (int duration) |
+| void | setBreak (bool level) |
+| void | setRTS (bool level) |
+| void | setDTR (bool level) |
+| bool | getCTS () |
+| bool | getDSR () |
+| bool | getRI () |
+| bool | getCD () |
+| void | setPort (const string &port) |
+| string | getPort () const |
+| void | setTimeout (long timeout) |
+| long | getTimeout () const |
+| void | setBaudrate (unsigned long baudrate) |
+| unsigned long | getBaudrate () const |
+| void | setBytesize (bytesize_t bytesize) |
+| bytesize_t | getBytesize () const |
+| void | setParity (parity_t parity) |
+| parity_t | getParity () const |
+| void | setStopbits (stopbits_t stopbits) |
+| stopbits_t | getStopbits () const |
+| void | setFlowcontrol (flowcontrol_t flowcontrol) |
+| flowcontrol_t | getFlowcontrol () const |
+
+Protected Member Functions |
+| void | reconfigurePort () |
+| void | reconfigurePort () |
+
+
Constructor & Destructor Documentation
+
+
+
+
+
: port_ (port), fd_ (-1), is_open_ (false), xonxoff_ (true), rtscts_ (false),
+ baudrate_ (baudrate), parity_ (parity),
+ bytesize_ (bytesize), stopbits_ (stopbits), flowcontrol_ (flowcontrol)
+{
+ pthread_mutex_init(&this->read_mutex, NULL);
+ pthread_mutex_init(&this->write_mutex, NULL);
+ if (port_.empty () == false)
+ open ();
+}
+
+
+
+
+
+
+
+
+
+
: port_ (port), fd_ (-1), isOpen_ (false), xonxoff_ (true), rtscts_ (false),
+ timeout_ (timeout), baudrate_ (baudrate), parity_ (parity), bytesize_ (bytesize),
+ stopbits_ (stopbits), flowcontrol_ (flowcontrol)
+{
+ if (port_.empty () == false)
+ open ();
+}
+
+
+
+
+
+
+
+
{
+ close();
+ pthread_mutex_destroy(&this->read_mutex);
+ pthread_mutex_destroy(&this->write_mutex);
+}
+
+
+
+
Member Function Documentation
+
+
+
+
+
{
+ if (!is_open_) {
+ return 0;
+ }
+ int count = 0;
+ int result = ioctl (fd_, TIOCINQ, &count);
+ if (result == 0) {
+ return static_cast<size_t> (count);
+ } else {
+ THROW (IOException, errno);
+ }
+}
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == true) {
+ if (fd_ != -1) {
+ ::close (fd_);
+ fd_ = -1;
+ }
+ is_open_ = false;
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::flushInput");
+ }
+ tcflush (fd_, TCIFLUSH);
+}
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::flushOutput");
+ }
+ tcflush (fd_, TCOFLUSH);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::getCD");
+ }
+ int s = ioctl (fd_, TIOCMGET, 0);
+ return (s & TIOCM_CD) != 0;
+}
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::getCTS");
+ }
+ int s = ioctl (fd_, TIOCMGET, 0);
+ return (s & TIOCM_CTS) != 0;
+}
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::getDSR");
+ }
+ int s = ioctl (fd_, TIOCMGET, 0);
+ return (s & TIOCM_DSR) != 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::getRI");
+ }
+ int s = ioctl (fd_, TIOCMGET, 0);
+ return (s & TIOCM_RI) != 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{
+ if (port_.empty ()) {
+ throw invalid_argument ("Empty port is invalid.");
+ }
+ if (is_open_ == true) {
+ throw SerialExecption ("Serial port already open.");
+ }
+
+ fd_ = ::open (port_.c_str(), O_RDWR | O_NOCTTY | O_NONBLOCK);
+
+ if (fd_ == -1) {
+ switch (errno) {
+ case EINTR:
+
+ open ();
+ return;
+ case ENFILE:
+ case EMFILE:
+ THROW (IOException, "Too many file handles open.");
+ default:
+ THROW (IOException, errno);
+ }
+ }
+
+ reconfigurePort();
+ is_open_ = true;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{
+ int result = pthread_mutex_lock(&this->read_mutex);
+ if (result) {
+ THROW (IOException, result);
+ }
+}
+
+
+
+
+
+
+
+
{
+ int result = pthread_mutex_unlock(&this->read_mutex);
+ if (result) {
+ THROW (IOException, result);
+ }
+}
+
+
+
+
+
+
+
+
{
+ if (fd_ == -1) {
+
+ THROW (IOException, "Invalid file descriptor, is the serial port open?");
+ }
+
+ struct termios options;
+
+ if (tcgetattr(fd_, &options) == -1) {
+ THROW (IOException, "::tcgetattr");
+ }
+
+
+ options.c_cflag |= (unsigned long) (CLOCAL | CREAD);
+ options.c_lflag &= (unsigned long) ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL |
+ ISIG | IEXTEN);
+
+ options.c_oflag &= (unsigned long) ~(OPOST);
+ options.c_iflag &= (unsigned long) ~(INLCR | IGNCR | ICRNL | IGNBRK);
+#ifdef IUCLC
+ options.c_iflag &= (unsigned long) ~IUCLC;
+#endif
+#ifdef PARMRK
+ options.c_iflag &= (unsigned long) ~PARMRK;
+#endif
+
+
+ bool custom_baud = false;
+ speed_t baud;
+ switch (baudrate_) {
+#ifdef B0
+ case 0: baud = B0; break;
+#endif
+#ifdef B50
+ case 50: baud = B50; break;
+#endif
+#ifdef B75
+ case 75: baud = B75; break;
+#endif
+#ifdef B110
+ case 110: baud = B110; break;
+#endif
+#ifdef B134
+ case 134: baud = B134; break;
+#endif
+#ifdef B150
+ case 150: baud = B150; break;
+#endif
+#ifdef B200
+ case 200: baud = B200; break;
+#endif
+#ifdef B300
+ case 300: baud = B300; break;
+#endif
+#ifdef B600
+ case 600: baud = B600; break;
+#endif
+#ifdef B1200
+ case 1200: baud = B1200; break;
+#endif
+#ifdef B1800
+ case 1800: baud = B1800; break;
+#endif
+#ifdef B2400
+ case 2400: baud = B2400; break;
+#endif
+#ifdef B4800
+ case 4800: baud = B4800; break;
+#endif
+#ifdef B7200
+ case 7200: baud = B7200; break;
+#endif
+#ifdef B9600
+ case 9600: baud = B9600; break;
+#endif
+#ifdef B14400
+ case 14400: baud = B14400; break;
+#endif
+#ifdef B19200
+ case 19200: baud = B19200; break;
+#endif
+#ifdef B28800
+ case 28800: baud = B28800; break;
+#endif
+#ifdef B57600
+ case 57600: baud = B57600; break;
+#endif
+#ifdef B76800
+ case 76800: baud = B76800; break;
+#endif
+#ifdef B38400
+ case 38400: baud = B38400; break;
+#endif
+#ifdef B115200
+ case 115200: baud = B115200; break;
+#endif
+#ifdef B128000
+ case 128000: baud = B128000; break;
+#endif
+#ifdef B153600
+ case 153600: baud = B153600; break;
+#endif
+#ifdef B230400
+ case 230400: baud = B230400; break;
+#endif
+#ifdef B256000
+ case 256000: baud = B256000; break;
+#endif
+#ifdef B460800
+ case 460800: baud = B460800; break;
+#endif
+#ifdef B921600
+ case 921600: baud = B921600; break;
+#endif
+ default:
+ custom_baud = true;
+
+#if defined(__APPLE__) && defined(__MACH__)
+#define IOSSIOSPEED _IOW('T', 2, speed_t)
+ int new_baud = static_cast<int> (baudrate_);
+ if (ioctl (fd_, IOSSIOSPEED, &new_baud, 1) < 0) {
+ THROW (IOException, errno);
+ }
+
+#elif defined(__linux__)
+ struct serial_struct ser;
+ ioctl (fd_, TIOCGSERIAL, &ser);
+
+ ser.custom_divisor = ser.baud_base / baudrate_;
+
+ ser.flags &= ~ASYNC_SPD_MASK;
+ ser.flags |= ASYNC_SPD_CUST;
+
+ if (ioctl (fd_, TIOCSSERIAL, ser) < 0) {
+ THROW (IOException, errno);
+ }
+#else
+ throw invalid_argument ("OS does not currently support custom bauds");
+#endif
+ }
+ if (custom_baud == false) {
+#ifdef _BSD_SOURCE
+ ::cfsetspeed(&options, baud);
+#else
+ ::cfsetispeed(&options, baud);
+ ::cfsetospeed(&options, baud);
+#endif
+ }
+
+
+ options.c_cflag &= (unsigned long) ~CSIZE;
+ if (bytesize_ == eightbits)
+ options.c_cflag |= CS8;
+ else if (bytesize_ == sevenbits)
+ options.c_cflag |= CS7;
+ else if (bytesize_ == sixbits)
+ options.c_cflag |= CS6;
+ else if (bytesize_ == fivebits)
+ options.c_cflag |= CS5;
+ else
+ throw invalid_argument ("invalid char len");
+
+ if (stopbits_ == stopbits_one)
+ options.c_cflag &= (unsigned long) ~(CSTOPB);
+ else if (stopbits_ == stopbits_one_point_five)
+
+ options.c_cflag |= (CSTOPB);
+ else if (stopbits_ == stopbits_two)
+ options.c_cflag |= (CSTOPB);
+ else
+ throw invalid_argument ("invalid stop bit");
+
+ options.c_iflag &= (unsigned long) ~(INPCK | ISTRIP);
+ if (parity_ == parity_none) {
+ options.c_cflag &= (unsigned long) ~(PARENB | PARODD);
+ } else if (parity_ == parity_even) {
+ options.c_cflag &= (unsigned long) ~(PARODD);
+ options.c_cflag |= (PARENB);
+ } else if (parity_ == parity_odd) {
+ options.c_cflag |= (PARENB | PARODD);
+ } else {
+ throw invalid_argument ("invalid parity");
+ }
+
+
+#ifdef IXANY
+ if (xonxoff_)
+ options.c_iflag |= (IXON | IXOFF);
+ else
+ options.c_iflag &= (unsigned long) ~(IXON | IXOFF | IXANY);
+#else
+ if (xonxoff_)
+ options.c_iflag |= (IXON | IXOFF);
+ else
+ options.c_iflag &= (unsigned long) ~(IXON | IXOFF);
+#endif
+
+#ifdef CRTSCTS
+ if (rtscts_)
+ options.c_cflag |= (CRTSCTS);
+ else
+ options.c_cflag &= (unsigned long) ~(CRTSCTS);
+#elif defined CNEW_RTSCTS
+ if (rtscts_)
+ options.c_cflag |= (CNEW_RTSCTS);
+ else
+ options.c_cflag &= (unsigned long) ~(CNEW_RTSCTS);
+#else
+#error "OS Support seems wrong."
+#endif
+
+
+
+
+
+ options.c_cc[VMIN] = 0;
+ options.c_cc[VTIME] = 0;
+
+
+ ::tcsetattr (fd_, TCSANOW, &options);
+}
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::sendBreak");
+ }
+ tcsendbreak (fd_, static_cast<int> (duration / 4));
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::setBreak");
+ }
+ if (level) {
+ ioctl (fd_, TIOCSBRK);
+ } else {
+ ioctl (fd_, TIOCCBRK);
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::setDTR");
+ }
+ if (level) {
+ ioctl (fd_, TIOCMBIS, TIOCM_DTR);
+ } else {
+ ioctl (fd_, TIOCMBIC, TIOCM_DTR);
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::setRTS");
+ }
+ if (level) {
+ ioctl (fd_, TIOCMBIS, TIOCM_RTS);
+ } else {
+ ioctl (fd_, TIOCMBIC, TIOCM_RTS);
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{
+ timeout_ = timeout;
+}
+
+
+
+
+
+
+
+
+
+
{
+#ifndef TIOCMIWAIT
+ while (is_open_ == true) {
+ int s = ioctl (fd_, TIOCMGET, 0);
+ if ((s & TIOCM_CTS) != 0) return true;
+ if ((s & TIOCM_DSR) != 0) return true;
+ if ((s & TIOCM_RI) != 0) return true;
+ if ((s & TIOCM_CD) != 0) return true;
+ usleep(1000);
+ }
+#else
+ if (ioctl(fd_, TIOCMIWAIT, (TIOCM_CD|TIOCM_DSR|TIOCM_RI|TIOCM_CTS)) != 0) {
+ stringstream ss;
+ ss << "waitForDSR failed on a call to ioctl(TIOCMIWAIT): "
+ << errno << " " << strerror(errno);
+ throw(SerialExecption(ss.str().c_str()));
+ return false;
+ }
+ return true;
+#endif
+ return false;
+}
+
+
+
+
+
+
+
+
{
+ if (is_open_ == false) {
+ throw PortNotOpenedException ("Serial::write");
+ }
+ return static_cast<size_t> (::write (fd_, data.c_str (), data.length ()));
+}
+
+
+
+
+
+
+
+
+
+
{
+ int result = pthread_mutex_lock(&this->write_mutex);
+ if (result) {
+ THROW (IOException, result);
+ }
+}
+
+
+
+
+
+
+
+
{
+ int result = pthread_mutex_unlock(&this->write_mutex);
+ if (result) {
+ THROW (IOException, result);
+ }
+}
+
+
+
+
The documentation for this class was generated from the following files:
+
+
Here is a list of all files with brief descriptions:
+
+
Here is a list of all struct and union fields with links to the structures/unions they belong to:
+
+
- a -
+
+
+
- c -
+
+
+
- f -
+
+
+
- g -
+- getBaudrate()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- getBytesize()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- getCD()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+
+- getCTS()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- getDSR()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- getErrorNumber()
+: serial::IOException
+
+- getFlowcontrol()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- getParity()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- getPort()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+
+- getRI()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+
+- getStopbits()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- getTimeout()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+, serial::serial::Serial::SerialImpl
+
+
+
+
+
- i -
+
+
+
- o -
+
+
+
- p -
+
+
+
- r -
+
+
+
- s -
+- ScopedReadLock()
+: serial::Serial::ScopedReadLock
+
+- ScopedWriteLock()
+: serial::Serial::ScopedWriteLock
+
+- sendBreak()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+
+- Serial()
+: serial::Serial
+
+- SerialExecption()
+: serial::SerialExecption
+
+- SerialImpl()
+: serial::serial::Serial::SerialImpl
+
+- setBaudrate()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- setBreak()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- setBytesize()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- setDTR()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- setFlowcontrol()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- setParity()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- setPort()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+
+- setRTS()
+: serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- setStopbits()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+, serial::serial::Serial::SerialImpl
+
+- setTimeout()
+: serial::serial::Serial::SerialImpl
+, serial::Serial
+
+
+
+
+
- t -
+
+
+
- w -
+
+
+
- ~ -
+
+
Here is a list of all functions, variables, defines, enums, and typedefs with links to the files they belong to:
+
+
This page explains how to interpret the graphs that are generated by doxygen.
+
Consider the following example:
+
+class Invisible { };
+
+
+class Truncated : public Invisible { };
+
+
+class Undocumented { };
+
+
+class PublicBase : public Truncated { };
+
+
+template<class T> class Templ { };
+
+
+class ProtectedBase { };
+
+
+class PrivateBase { };
+
+
+class Used { };
+
+
+class Inherited : public PublicBase,
+ protected ProtectedBase,
+ private PrivateBase,
+ public Undocumented,
+ public Templ<int>
+{
+ private:
+ Used *m_usedClass;
+};
+ This will result in the following graph:
+
+
+
The boxes in the above graph have the following meaning:
+
+-
+A filled gray box represents the struct or class for which the graph is generated.
+-
+A box with a black border denotes a documented struct or class.
+-
+A box with a grey border denotes an undocumented struct or class.
+-
+A box with a red border denotes a documented struct or class forwhich not all inheritance/containment relations are shown. A graph is truncated if it does not fit within the specified boundaries.
+
+
The arrows have the following meaning:
+
+-
+A dark blue arrow is used to visualize a public inheritance relation between two classes.
+-
+A dark green arrow is used for protected inheritance.
+-
+A dark red arrow is used for private inheritance.
+-
+A purple dashed arrow is used if a class is contained or used by another class. The arrow is labeled with the variable(s) through which the pointed class or struct is accessible.
+-
+A yellow dashed arrow denotes a relation between a template instance and the template class it was instantiated from. The arrow is labeled with the template parameters of the instance.
+
+
+
+
+ 
+
+ 
+ 1.8.0
+
+
+
+
diff --git a/docs/v1.0/bc_s.png b/docs/v1.0/bc_s.png
new file mode 100644
index 0000000..51ba006
Binary files /dev/null and b/docs/v1.0/bc_s.png differ
diff --git a/docs/v1.0/bdwn.png b/docs/v1.0/bdwn.png
new file mode 100644
index 0000000..d0b575b
Binary files /dev/null and b/docs/v1.0/bdwn.png differ
diff --git a/docs/v1.0/class_serial_1_1_scoped_read_lock.html b/docs/v1.0/class_serial_1_1_scoped_read_lock.html
new file mode 100644
index 0000000..bb099ac
--- /dev/null
+++ b/docs/v1.0/class_serial_1_1_scoped_read_lock.html
@@ -0,0 +1,166 @@
+
+
+
+
+
+