qpidcommport.cpp

Go to the documentation of this file.

#include "qpidcommport.h"
#include "qpidcontroller.h"
#include "qextserialport.h"
#include <QTcpSocket>
#include "qpiddebug.h"
#include "qextserialenumerator.h"

QPidCommPort::QPidCommPort(QcepSettingsSaverPtr saver, QPidControllerPtr ctl) :
  QObject(),
  m_CommPortType(saver, this, "commPortType", 0, "Comm Port Type"),
  m_SerialPortName(saver, this, "serialPortName", "", "Serial Port Name"),
  m_SerialPortBaud(saver, this, "serialPortBaud", 0, "Serial Port Baud Rate"),
  m_SerialPortBits(saver, this, "serialPortBits", 1, "Serial Port Data Bits"),
  m_SerialPortParity(saver, this, "serialPortParity", 0, "Serial Port Parity"),
  m_SerialPortStopBits(saver, this, "serialPortStopBits", 0, "Serial Port Stop Bits"),
  m_SerialPortFlowControl(saver, this, "serialPortFlowControl", 0, "Serial Port Flow Control"),
  m_SocketHostAddress(saver, this, "socketHostAddress", "", "Socket Host Address"),
  m_SocketPortNumber(saver, this, "socketPortNumber", 0, "Socket Port Number"),
  m_SocketTimeout(saver, this, "socketTimeout", 5000, "Socket timeout (msec)"),
  m_EpicsPVName(saver, this, "epicsPVName", "", "Epics PV Name"),
  m_Connected(QcepSettingsSaverWPtr(), this, "connected", 0, "Is comm port connected"),
  m_Successful(QcepSettingsSaverWPtr(), this, "successful", 0, "Successful communication taken place"),
  m_Controller(ctl)
{
  if (qcepDebug(DEBUG_CONSTRUCTORS)) {
    printf("QPidCommPort::QPidCommPort(%p)\n", this);
  }
}

QPidCommPort::~QPidCommPort()
{
  if (qcepDebug(DEBUG_CONSTRUCTORS)) {
    printf("QPidCommPort::~QPidCommPort(%p)\n", this);
  }
}

QStringList QPidCommPort::commPortTypes()
{
  QStringList res;

  res << "No Port"
      << "Local Serial Port"
      << "Network Socket"
      << "Epics PV";

  return res;
}

QStringList QPidCommPort::commPortBaudRates()
{
  QStringList res;

  res << "1200 Baud"
      << "2400 Baud"
      << "4800 Baud"
      << "9600 Baud"
      << "19200 Baud";

  return res;
}

BaudRateType QPidCommPort::baudRate(int idx)
{
  switch(idx) {
  case 0:
    return BAUD1200;

  case 1:
    return BAUD2400;

  case 2:
    return BAUD4800;

  case 3:
    return BAUD9600;

  case 4:
    return BAUD19200;

  default:
    return BAUD9600;
  }
}

QStringList QPidCommPort::commPortDataBits()
{
  QStringList res;

  res << "7 Bits"
      << "8 Bits";

  return res;
}

DataBitsType QPidCommPort::dataBits(int idx)
{
  switch (idx) {
  case 0:
    return DATA_7;

  case 1:
    return DATA_8;

  default:
    return DATA_8;
  }
}

QStringList QPidCommPort::commPortFlowControls()
{
  QStringList res;

  res << "None"
      << "Hardware"
      << "XON/XOFF";

  return res;
}

FlowType     QPidCommPort::flowControl(int idx)
{
  switch (idx) {
  case 0:
    return FLOW_OFF;

  case 1:
    return FLOW_HARDWARE;

  case 2:
    return FLOW_XONXOFF;

  default:
    return FLOW_OFF;
  }
}

QStringList QPidCommPort::commPortParitys()
{
  QStringList res;

  res << "None"
      << "Odd"
      << "Even"
      << "Space";

  return res;
}

ParityType   QPidCommPort::parity(int idx)
{
  switch(idx) {
  case 0:
    return PAR_NONE;

  case 1:
    return PAR_ODD;

  case 2:
    return PAR_EVEN;

  case 3:
    return PAR_SPACE;

  default:
    return PAR_NONE;
  }
}

QStringList QPidCommPort::commPortStopBits()
{
  QStringList res;

  res << "1 Bits"
      << "2 Bits";

  return res;
}

StopBitsType QPidCommPort::stopBits(int idx)
{
  switch(idx) {
  case 0:
    return STOP_1;

  case 1:
    return STOP_2;

  default:
    return STOP_1;
  }
}

void QPidCommPort::printMessage(QString msg, QDateTime ts)
{
  QPidControllerPtr ctl(m_Controller);

  if (ctl) {
    ctl->printMessage(msg, ts);
  }
}

void QPidCommPort::writeSettings(QSettings *set, QString section)
{
  QcepProperty::writeSettings(this, &staticMetaObject, section, set);
}

void QPidCommPort::readSettings(QSettings *set, QString section)
{
  QcepProperty::readSettings(this, &staticMetaObject, section, set);
}

QByteArray QPidCommPort::readAll()
{
  if (openIfNeeded()) {
    QByteArray res = m_IODevice->readAll();

    set_Successful(res.count());

    if (qcepDebug(DEBUG_COMMPORT)) {
      if (qcepDebug(DEBUG_LEVEL1)) {
        printMessage(tr("QPidCommPort::readAll: %1 (%2)").arg((QString) res).arg((QString) res.toHex()));
      } else {
        printMessage(tr("QPidCommPort::readAll: %1").arg((QString) res));
      }
    }
    return res;
  } else {
    return QByteArray();
  }
}

QByteArray QPidCommPort::read(int sz)
{
  if (openIfNeeded()) {
    QByteArray res = m_IODevice->read(sz);

    set_Successful(res.count());

    if (qcepDebug(DEBUG_COMMPORT)) {
      if (qcepDebug(DEBUG_LEVEL1)) {
        printMessage(tr("QPidCommPort::read(%1): %2 (%3)").arg(sz).arg((QString) res).arg((QString) res.toHex()));
      } else {
        printMessage(tr("QPidCommPort::read(%1): %2").arg(sz).arg((QString) res));
      }
    }

    return res;
  } else {
    return QByteArray();
  }
}

QByteArray QPidCommPort::readLine(int maxlen)
{
  if (openIfNeeded()) {
    QByteArray res = m_IODevice->readLine(maxlen);

    set_Successful(res.count());

    if (qcepDebug(DEBUG_COMMPORT)) {
      if (qcepDebug(DEBUG_LEVEL1)) {
        printMessage(tr("QPidCommPort::readLine(%1): %2 (%3)").arg(maxlen).arg((QString) res).arg((QString) res.toHex()));
      } else {
        printMessage(tr("QPidCommPort::readLine(%1): %2").arg(maxlen).arg((QString) res));
      }
    }

    return res;
  } else {
    return QByteArray();
  }
}

bool QPidCommPort::isWritable()
{
  if (openIfNeeded()) {
    bool res = m_IODevice->isWritable();

    if (qcepDebug(DEBUG_COMMPORT) && qcepDebug(DEBUG_LEVEL1)) {
      printMessage(tr("QPidCommPort::isWritable(): %1").arg(res));
    }
    return res;
  } else {
    return false;
  }
}

bool QPidCommPort::successfullyConnected()
{
  return get_Successful();
}

void QPidCommPort::write(QByteArray msg)
{
  if (openIfNeeded()) {
    m_IODevice->write(msg);

    if (qcepDebug(DEBUG_COMMPORT)) {
      if (qcepDebug(DEBUG_LEVEL1)) {
        printMessage(tr("QPidCommPort::write(%1 (%3))").arg((QString) msg).arg((QString) msg.toHex()));
      } else {
        printMessage(tr("QPidCommPort::write(%1)").arg((QString) msg));
      }
    }
  }
}

int QPidCommPort::waitForBytesWritten(int tmout)
{
  if (openIfNeeded()) {
    int res = m_IODevice->waitForBytesWritten(tmout);

    if (qcepDebug(DEBUG_COMMPORT) && qcepDebug(DEBUG_LEVEL1)) {
      printMessage(tr("QPidCommPort::waitForBytesWritten(%1): %2").arg(tmout).arg(res));
    }

    return res;
  } else {
    return false;
  }
}

int QPidCommPort::waitForReadyRead(int tmout)
{
  if (openIfNeeded()) {
    int res = m_IODevice->waitForReadyRead(tmout);

    set_Successful(res);

    if (qcepDebug(DEBUG_COMMPORT) && qcepDebug(DEBUG_LEVEL1)) {
      printMessage(tr("QPidCommPort::waitForReadyRead(%1): %2").arg(tmout).arg(res));
    }

    return res;
  } else {
    return false;
  }
}

int QPidCommPort::bytesAvailable()
{
  if (openIfNeeded()) {
    int res = m_IODevice->bytesAvailable();

    if (qcepDebug(DEBUG_COMMPORT) && qcepDebug(DEBUG_LEVEL1)) {
      printMessage(tr("QPidCommPort::bytesAvailable(): %1").arg(res));
    }

    return res;
  } else {
    return 0;
  }
}

int QPidCommPort::canReadLine()
{
  if (openIfNeeded()) {
    int res = m_IODevice->canReadLine();

    if (qcepDebug(DEBUG_COMMPORT) && qcepDebug(DEBUG_LEVEL1)) {
      printMessage(tr("QPidCommPort::canReadLine(): %1").arg(res));
    }

    return res;
  } else {
    return 0;
  }
}

bool QPidCommPort::openLocalSerialPort()
{
  bool res;

  QList<QextPortInfo> ports = QextSerialEnumerator::getPorts();

  QString portName = get_SerialPortName();
  QString deviceName;

  for (int i=0; i<ports.count(); i++) {
    QextPortInfo port = ports.value(i);

    QString aPortName = port.portName;

    if (portName == aPortName) {
      deviceName = port.physName;
    }
  }

  QextSerialPort *dev = new QextSerialPort(deviceName, QextSerialPort::Polling);

  dev->setBaudRate(baudRate(get_SerialPortBaud()));
  dev->setDataBits(dataBits(get_SerialPortBits()));
  dev->setStopBits(stopBits(get_SerialPortStopBits()));
  dev->setFlowControl(flowControl(get_SerialPortFlowControl()));
  dev->setParity(parity(get_SerialPortParity()));

  res = dev->open(QIODevice::ReadWrite);

  if (qcepDebug(DEBUG_SERIAL)) {
    printMessage(tr("New serial port on device %1, port name %2").arg(deviceName).arg(portName));

    if (qcepDebug(DEBUG_LEVEL1)) {
      printMessage(tr("Baud:%1 Bits:%2 Parity:%3 Stop:%4 HShake:%5")
                   .arg(dev->baudRate())
                   .arg(dev->dataBits())
                   .arg(dev->parity())
                   .arg(dev->stopBits())
                   .arg(dev->flowControl()));
    }
  }

//  dev->setQueryMode(QextSerialPort::EventDriven);

  if (!res) {
    printMessage(tr("Serial Port open failed %1").arg(dev->errorString()));
  }

  m_IODevice = dev;

  return res;
}

bool QPidCommPort::openNetworkSocket()
{
  bool res;

  QTcpSocket *sock = new QTcpSocket();
  sock->connectToHost(get_SocketHostAddress(), get_SocketPortNumber());
  res = sock->waitForConnected(get_SocketTimeout());
  m_IODevice = sock;

  if (!res) {
    printMessage(tr("Socket connection failed %1").arg(sock->errorString()));
  }

  return res;
}

bool QPidCommPort::openIfNeeded()
{
  if (get_Connected()) {
    return true;
  } else {
    bool res = false;

    switch (get_CommPortType()) {
    case LocalSerialPort:
      res = openLocalSerialPort();

      if (qcepDebug(DEBUG_SERIAL)) {
        printMessage(tr("Serial Port Opened = %1").arg(res));
      }
      break;

    case NetworkSocket:
      res = openNetworkSocket();

      if (qcepDebug(DEBUG_SOCKET)) {
        printMessage(tr("Socket opened: connected = %1").arg(res));
      }
      break;
    }

    set_Connected(res);

    return res;
  }
}