qpiddevice.cpp

Go to the documentation of this file.

#include "qpiddevice.h"
#include "qpidcontroller.h"
#include "qcepmutexlocker.h"
#include "qpiddebug.h"
#include "qpidcommport.h"
#include "qcepproperty.h"
#include "qpidlogger.h"

QPidDevice::QPidDevice(QPidControllerWPtr ctrl,
                       QcepSettingsSaverWPtr saver,
                       int deviceType,
                       QString deviceName,
                       int pollIntervalMsec,
                       int timeoutMsec) :
  QObject(NULL),
  m_DeviceType(saver, this, "deviceType", deviceType, "Device Type"),
  m_DeviceTypeName(saver, this, "deviceTypeName", QPidDevice::deviceTypeName(deviceType), "Device Type Name"),
  m_DeviceLongTypeName(saver, this, "deviceLongTypeName", QPidDevice::deviceLongTypeName(deviceType), "Device Long Type Name"),
  m_DeviceName(saver, this, "deviceName", deviceName, "Device Name"),
  m_RunState(QcepSettingsSaverWPtr(), this, "runState", 0, "Run State"),
  m_PollingInterval(saver, this, "pollingInterval", pollIntervalMsec/1000.0, "Polling Interval (sec)"),
  m_TimeoutInterval(saver, this, "timeoutInterval", timeoutMsec/1000.0, "Timeout Interval (sec)"),
  m_Controller(ctrl),
  m_CommPort(new QPidCommPort(saver, ctrl)),
  m_CommandMutex(QMutex::Recursive)
{
  connect(prop_RunState(), SIGNAL(valueChanged(int,int)), this, SLOT(changeRunState(int)));
  connect(prop_PollingInterval(), SIGNAL(valueChanged(double,int)), this, SLOT(changePollingInterval(double)));
  connect(prop_TimeoutInterval(), SIGNAL(valueChanged(double,int)), this, SLOT(changeTimeoutInterval(double)));

  QPidControllerPtr cntrl(m_Controller);

  if (cntrl) {
    connect(cntrl->prop_GraphInterval(), SIGNAL(valueChanged(double,int)), this, SLOT(changeGraphingInterval(double)));
    connect(cntrl->logger()->prop_UpdateInterval(), SIGNAL(valueChanged(double,int)), this, SLOT(changeLoggingInterval(double)));
  }

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

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

QString QPidDevice::deviceTypeName(int typ)
{
  QString res="Unk";

  switch (typ) {
  case NoDevice:
    res = "None";
    break;

  case WatlowDevice:
    res = "Watlow";
    break;

  case PTC10Device:
    res = "PTC10";
    break;

  case LakeshoreDevice:
    res = "LShore";
    break;

  case CryostreamDevice:
    res = "Crystm";
    break;

  case EurothermDevice:
    res = "Euthrm";
    break;
  }

  return res;
}

QString QPidDevice::deviceLongTypeName(int typ)
{
  QString res="Unk";

  switch (typ) {
  case NoDevice:
    res = "No Device";
    break;

  case WatlowDevice:
    res = "Watlow 988 Series Controller";
    break;

  case PTC10Device:
    res = "Stanford PTC10 Controller";
    break;

  case LakeshoreDevice:
    res = "Lakeshore Cryogenics LS3xx Controller";
    break;

  case CryostreamDevice:
    res = "Oxford Cryostream Controller";
    break;

  case EurothermDevice:
    res = "Eurotherm 2400 Series Controller";
    break;
  }

  return res;
}

int QPidDevice::deviceTypeCount()
{
  return 6;
}

QPidCommPortPtr QPidDevice::commPort()
{
  return m_CommPort;
}

void QPidDevice::changeRunState(int state)
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage(tr("QPidDevice::changeRunState(%1)").arg(state));
  }

  if (state == true) {
    start();
  } else {
    stop();
  }
}

void QPidDevice::start()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    connect(ctrl->prop_SetPoint(), SIGNAL(valueChanged(double,int)), this, SLOT(changeSetPoint(double)));
    connect(ctrl->prop_RampRate(), SIGNAL(valueChanged(double,int)), this, SLOT(changeRampRate(double)));
    connect(ctrl->prop_Proportional(), SIGNAL(valueChanged(double,int)), this, SLOT(changeProportional(double)));
    connect(ctrl->prop_Integral(), SIGNAL(valueChanged(double,int)), this, SLOT(changeIntegral(double)));
    connect(ctrl->prop_Derivative(), SIGNAL(valueChanged(double,int)), this, SLOT(changeDerivative(double)));
    connect(ctrl->prop_Enabled(), SIGNAL(valueChanged(bool,int)), this, SLOT(enable(bool)));
    connect(ctrl->prop_LoopEnabled(), SIGNAL(valueChanged(bool,int)), this, SLOT(loopEnable(bool)));
  }

  readoutInitial();

//  QMetaObject::invokeMethod(this, "readoutInitial", Qt::QueuedConnection);

  connect(&m_PollingTimer, SIGNAL(timeout()), this, SLOT(onPollingTimeout()));

  if (get_PollingInterval() > 0) {
    m_PollingTimer.setSingleShot(true);
    m_PollingTimer.start(get_PollingInterval()*1000.0);
  }

  connect(&m_TimeoutTimer, SIGNAL(timeout()), this, SLOT(onTimeoutTimeout()));

  if (get_TimeoutInterval() > 0) {
    m_TimeoutTimer.setSingleShot(true);
  }

  connect(&m_GraphingTimer, SIGNAL(timeout()), this, SLOT(onGraphingTimeout()));

  if (ctrl && ctrl->get_GraphInterval() > 0) {
    m_GraphingTimer.setSingleShot(false);
    m_GraphingTimer.start(ctrl->get_GraphInterval()*1000.0);
  }

  connect(&m_LoggingTimer, SIGNAL(timeout()), this, SLOT(onLoggingTimeout()));

  QPidLoggerPtr logger(ctrl->logger());

  if (logger && logger->get_UpdateInterval() > 0) {
    m_LoggingTimer.setSingleShot(false);
    m_LoggingTimer.start(logger->get_UpdateInterval()*1000.0);
  }

  connect(m_CommPort.data(), SIGNAL(readyRead()), this, SLOT(readyRead()));
}

void QPidDevice::stop()
{
  QPidControllerPtr ctrl(m_Controller);

  if (ctrl) {
    disconnect(ctrl->prop_SetPoint(), SIGNAL(valueChanged(double,int)), this, SLOT(changeSetPoint(double)));
    disconnect(ctrl->prop_RampRate(), SIGNAL(valueChanged(double,int)), this, SLOT(changeRampRate(double)));
    disconnect(ctrl->prop_Proportional(), SIGNAL(valueChanged(double,int)), this, SLOT(changeProportional(double)));
    disconnect(ctrl->prop_Integral(), SIGNAL(valueChanged(double,int)), this, SLOT(changeIntegral(double)));
    disconnect(ctrl->prop_Derivative(), SIGNAL(valueChanged(double,int)), this, SLOT(changeDerivative(double)));
    disconnect(ctrl->prop_Enabled(), SIGNAL(valueChanged(bool,int)), this, SLOT(enable(bool)));
    disconnect(ctrl->prop_LoopEnabled(), SIGNAL(valueChanged(bool,int)), this, SLOT(loopEnable(bool)));
  }

  disconnect(&m_PollingTimer, SIGNAL(timeout()), this, SLOT(onPollingTimeout()));

  if (get_PollingInterval() > 0) {
    m_PollingTimer.stop();
    m_PollingTimer.setSingleShot(true);
  }

  disconnect(&m_TimeoutTimer, SIGNAL(timeout()), this, SLOT(onTimeoutTimeout()));

  if (get_TimeoutInterval() > 0) {
    m_TimeoutTimer.stop();
  }

  disconnect(&m_GraphingTimer, SIGNAL(timeout()), this, SLOT(onGraphingTimeout()));

  if (ctrl && ctrl->get_GraphInterval() > 0) {
    m_GraphingTimer.stop();
  }

  disconnect(&m_LoggingTimer, SIGNAL(timeout()), this, SLOT(onLoggingTimeout()));

  QPidLoggerPtr logger(ctrl->logger());

  if (logger && logger->get_UpdateInterval() > 0) {
    m_LoggingTimer.stop();
  }

  disconnect(m_CommPort.data(), SIGNAL(readyRead()), this, SLOT(readyRead()));
}

void QPidDevice::changePollingInterval(double interval)
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage(tr("Polling interval changed to %1 seconds").arg(interval));
  }

  if (get_RunState()) {
    if (m_PollingTimer.isActive()) {
      if (interval > 0) {
        m_PollingTimer.setInterval(interval*1000.0);
      } else {
        m_PollingTimer.stop();
      }
    } else if (interval > 0) {
      m_PollingTimer.start(interval*1000.0);
    }
  }
}

void QPidDevice::changeTimeoutInterval(double interval)
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage(tr("Timeout interval changed to %1 seconds").arg(interval));
  }

  if (get_RunState()) {
    m_TimeoutTimer.setInterval(interval*1000.0);
  }
}

void QPidDevice::changeGraphingInterval(double interval)
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage(tr("Graphing interval changed to %1 seconds").arg(interval));
  }

  if (get_RunState()) {
    if (m_GraphingTimer.isActive()) {
      if (interval > 0) {
        m_GraphingTimer.setInterval(interval*1000.0);
      } else {
        m_GraphingTimer.stop();
      }
    } else if (interval > 0) {
      m_GraphingTimer.start(interval*1000.0);
    }
  }
}

void QPidDevice::changeLoggingInterval(double interval)
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage(tr("Logging interval changed to %1 seconds").arg(interval));
  }

  if (get_RunState()) {
    if (m_LoggingTimer.isActive()) {
      if (interval > 0) {
        m_LoggingTimer.setInterval(interval*1000.0);
      } else {
        m_LoggingTimer.stop();
      }
    } else if (interval > 0) {
      m_LoggingTimer.start(interval*1000.0);
    }
  }
}

void QPidDevice::restart()
{
  stop();
  start();
}

int QPidDevice::slowly(int msec)
{
  if (qcepDebug(DEBUG_SLOWLY)) {
    return msec*20;
  } else {
    return msec;
  }
}

QPidControllerWPtr QPidDevice::controller() const
{
  return m_Controller;
}

void QPidDevice::printMessage(QString msg, QDateTime ts)
{
  QPidControllerPtr ctl(controller());

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

void QPidDevice::updateConnected(double newConnected)
{
  QPidControllerPtr ctl(controller());

  if (ctl) {
    ctl->updateConnected(newConnected);
  }
}

void QPidDevice::updateTemperature(double newTemperature)
{
  QPidControllerPtr ctl(controller());

  if (ctl) {
    ctl->updateTemperature(newTemperature);
  }
}

void QPidDevice::updateRampPoint(double newRampPoint)
{
  QPidControllerPtr ctl(controller());

  if (ctl) {
    ctl->updateRampPoint(newRampPoint);
  }
}

void QPidDevice::updateOutputLevel(double newOutputLevel)
{
  QPidControllerPtr ctl(controller());

  if (ctl) {
    ctl->updateOutputLevel(newOutputLevel);
  }
}

void QPidDevice::writeSettings(QSettings *set, QString section)
{
  if (m_CommPort) {
    m_CommPort -> writeSettings(set, section + "/commPort");
  }

  QcepProperty::writeSettings(this, &staticMetaObject, section, set);
}

void QPidDevice::readSettings(QSettings *set, QString section)
{
  if (m_CommPort) {
    m_CommPort -> readSettings(set, section + "/commPort");
  }

  QcepProperty::readSettings(this, &staticMetaObject, section, set);
}

double QPidDevice::cK2K(double cK)
{
  return cK/100.0;
}

double QPidDevice::K2cK(double K)
{
  return K*100.0;
}

double QPidDevice::K2degC(double K)
{
  return K-273.15;
}

double QPidDevice::degC2K(double degC)
{
  return degC+273.15;
}

void QPidDevice::resetTimeout()
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage("resetTimeout()");
  }

  m_TimeoutTimer.start(slowly(get_TimeoutInterval()*1000.0));
}

void QPidDevice::onPollingTimeout()
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage(tr("QPidDevice::onPollingTimeout"));
  }

  readoutPolling();

  m_PollingTimer.start(slowly(get_PollingInterval()*1000.0));
}

void QPidDevice::onTimeoutTimeout()
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage(tr("QPidDevice::onTimeoutTimeout"));
  }

  readoutTimeout();

  updateConnected(false);

  resetTimeout();
}

void QPidDevice::pushCommand(QPidDeviceCommandPtr cmd)
{
  QcepMutexLocker lock(__FILE__, __LINE__, &m_CommandMutex);

  m_CommandQueue.append(cmd);

  if (m_CommandQueue.count() == 1) {
    issueCommand();
  }
}

void QPidDevice::issueCommand()
{
  QcepMutexLocker lock(__FILE__, __LINE__, &m_CommandMutex);

  while (m_CommandQueue.length() > 0) {
    QPidDeviceCommandPtr cmd = m_CommandQueue[0];

    if (cmd) {
      cmd->issueCommand();

      if (cmd->replyExpected()) {
        resetTimeout();
        break;
      } else {
        QPidDeviceCommandPtr cmd = m_CommandQueue.takeFirst();

        delete cmd;
      }
    } else {
      break;
    }
  }
}

void QPidDevice::flushCommandQueue()
{
  QcepMutexLocker lock(__FILE__, __LINE__, &m_CommandMutex);

  while (m_CommandQueue.length() > 0) {
    QPidDeviceCommandPtr cmd = m_CommandQueue.takeFirst();

    delete cmd;
  }
}

void QPidDevice::completeCommand(QByteArray response)
{
  QcepMutexLocker lock(__FILE__, __LINE__, &m_CommandMutex);

  if (m_CommandQueue.length() > 0) {
    QPidDeviceCommandPtr cmd = m_CommandQueue.first();

    if (cmd) {
      cmd->processReply(response);

      updateConnected(true);

      cmd = m_CommandQueue.takeFirst();
      delete cmd;

      issueCommand();
    }
  }
}

void QPidDevice::onGraphingTimeout()
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage(tr("QPidDevice::onGraphingTimeout"));
  }
}

void QPidDevice::onLoggingTimeout()
{
  if (qcepDebug(DEBUG_PIDDEVICE)) {
    printMessage(tr("QPidDevice::onLoggingTimeout"));
  }
}

void QPidDevice::loopEnable(bool /*on*/)
{
}

void QPidDevice::readyRead()
{
}

void QPidDevice::write(QString cmd)
{
  commPort()->write(qPrintable(cmd));
}

QString QPidDevice::readLine(int sz)
{
  return commPort()->readLine(sz);
}

int QPidDevice::waitForReadyRead(int tmout)
{
  return commPort()->waitForReadyRead(tmout);
}

int QPidDevice::bytesAvailable()
{
  return commPort()->bytesAvailable();
}

int QPidDevice::canReadLine()
{
  return commPort()->canReadLine();
}