SerialReaderWriter.h

Go to the documentation of this file.

/* Copyright 2013-2019 Homegear GmbH
 *
 * libhomegear-base is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * libhomegear-base is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with libhomegear-base.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * In addition, as a special exception, the copyright holders give
 * permission to link the code of portions of this program with the
 * OpenSSL library under certain conditions as described in each
 * individual source file, and distribute linked combinations
 * including the two.
 * You must obey the GNU Lesser General Public License in all respects
 * for all of the code used other than OpenSSL.  If you modify
 * file(s) with this exception, you may extend this exception to your
 * version of the file(s), but you are not obligated to do so.  If you
 * do not wish to do so, delete this exception statement from your
 * version.  If you delete this exception statement from all source
 * files in the program, then also delete it here.
*/

#ifndef SERIALREADERWRITER_H_
#define SERIALREADERWRITER_H_

#include "../Exception.h"
#include "../Managers/FileDescriptorManager.h"
#include "../IEvents.h"

#include <thread>
#include <atomic>

#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <signal.h>

namespace BaseLib {
class SerialReaderWriterException : public Exception {
 public:
  SerialReaderWriterException(std::string message) : Exception(message) {}
};

class SerialReaderWriter : public IEventsEx {
 public:
  enum class CharacterSize : tcflag_t {
    Five = CS5,
    Six = CS6,
    Seven = CS7,
    Eight = CS8
  };

  // {{{ Event handling
  class ISerialReaderWriterEventSink : public IEventSinkBase {
   public:
    virtual void lineReceived(const std::string &data) = 0;
  };
  // }}}

  SerialReaderWriter(BaseLib::SharedObjects *baseLib, std::string device, int32_t baudrate, int32_t flags, bool createLockFile, int32_t readThreadPriority, bool writeOnly = false);

  virtual ~SerialReaderWriter();

  bool isOpen() { return _fileDescriptor && _fileDescriptor->descriptor != -1; }
  std::shared_ptr<FileDescriptor> fileDescriptor() { return _fileDescriptor; }

  void openDevice(bool parity, bool oddParity, bool events = true, CharacterSize characterSize = CharacterSize::Eight, bool twoStopBits = false);

  void closeDevice();

  int32_t readLine(std::string &data, uint32_t timeout = 500000, char splitChar = '\n');

  int32_t readChar(char &data, uint32_t timeout = 500000);

  void writeLine(std::string &data);

  void writeData(const std::vector<char> &data);

  void writeData(const std::vector<uint8_t> &data);

  void writeChar(char data);
 protected:
  BaseLib::SharedObjects *_bl = nullptr;
  std::shared_ptr<FileDescriptor> _fileDescriptor;
  std::string _device;
  bool _writeOnly = false;
  struct termios _termios;
  int32_t _baudrate = 0;
  int32_t _flags = 0;
  int32_t _readThreadPriority = 0;
  int32_t _handles = 0;

  std::atomic_bool _stopReadThread;
  std::mutex _readThreadMutex;
  std::thread _readThread;
  std::mutex _sendMutex;
  std::mutex _openDeviceThreadMutex;
  std::thread _openDeviceThread;

  void readThread(bool parity, bool oddParity, CharacterSize characterSize, bool twoStopBits);
};

}
#endif