qptc10device.cpp

Go to the documentation of this file.

#include "qptc10device.h"
#include "qpidcontroller.h"
#include "qextserialport.h"
#include <QTcpSocket>
#include "qcepmutexlocker.h"
#include "qpiddebug.h"
#include "qptc10simulator.h"
#include <QCoreApplication>
#include <QThread>
#include "qpidcommport.h"

QPTC10Device::QPTC10Device(QPidControllerWPtr ctrl, QcepSettingsSaverWPtr saver, QString deviceName) :
  QPidDevice(ctrl, saver, PTC10Device, deviceName, 1000, 2000),
  m_ObjectNamer(this, "ptc10"),
  m_ChannelList(QcepSettingsSaverWPtr(), this, "channelList", "", "Channel List"),
  m_Channels(QcepSettingsSaverWPtr(), this, "channels", QStringList(), "Channel List"),
  m_InputChannels(QcepSettingsSaverWPtr(), this, "inputChannels", QStringList(), "Input Channel List"),
  m_OutputChannels(QcepSettingsSaverWPtr(), this, "outputChannels", QStringList(), "Output Channel List"),
  m_UnitsList(QcepSettingsSaverWPtr(), this, "unitsList", "", "Channel Units List"),
  m_ChannelUnits(QcepSettingsSaverWPtr(), this, "channelUnits", QStringList(), "Channel Units List"),
  m_ChannelValues(QcepSettingsSaverWPtr(), this, "channelValues", QcepDoubleList(), "Channel Values"),
  m_InputChannel(saver, this, "inputChannel", -1, "Input Channel Number"),
  m_InputUnits(QcepSettingsSaverWPtr(), this, "inputUnits", "", "Input Units"),
  m_OutputChannel(saver, this, "outputChannel", -1, "Output Channel Number"),
  m_OutputUnits(QcepSettingsSaverWPtr(), this, "outputUnits", "", "Output Units")
{
  connect(prop_InputChannel(), SIGNAL(valueChanged(int,int)),     this, SLOT(onInputChannelChanged()));
  connect(prop_InputUnits(),   SIGNAL(valueChanged(QString,int)), this, SLOT(onInputChannelChanged()));
  connect(prop_OutputChannel(),SIGNAL(valueChanged(int,int)),     this, SLOT(onOutputChannelChanged()));
  connect(prop_OutputUnits(),  SIGNAL(valueChanged(QString,int)), this, SLOT(onOutputChannelChanged()));
}

void QPTC10Device::start()
{
  QPidDevice::start();

  onInputChannelChanged();
  onOutputChannelChanged();
}

void QPTC10Device::stop()
{
  QPidDevice::stop();
}

void QPTC10Device::onInputChannelChanged()
{
  emit inputChannelChanged(inputChannelName(), inputChannelUnits());
}

void QPTC10Device::onOutputChannelChanged()
{
  emit outputChannelChanged(outputChannelName(), outputChannelUnits());
}

void QPTC10Device::writeSettings(QSettings *set, QString section)
{
  QPidDevice::writeSettings(set, section+"/ptc10");

  QcepProperty::writeSettings(this, &staticMetaObject, section+"/ptc10", set);
}

void QPTC10Device::readSettings(QSettings *set, QString section)
{
  QPidDevice::readSettings(set, section+"/ptc10");

  QcepProperty::readSettings(this, &staticMetaObject, section+"/ptc10", set);
}

void QPTC10Device::configurationDialog()
{
  if (m_DeviceDialog == NULL) {
    m_DeviceDialog = QPTC10DeviceDialogPtr(new QPTC10DeviceDialog(QPTC10DevicePtr(this)));
  }

  if (m_DeviceDialog) {
    m_DeviceDialog->show();
    m_DeviceDialog->raise();
  }
}

QString QPTC10Device::inputChannelName()
{
  QStringList chans = get_InputChannels();

  return chans.value(get_InputChannel());
}

QString QPTC10Device::outputChannelName()
{
  QStringList chans = get_OutputChannels();

  return chans.value(get_OutputChannel());
}

QString QPTC10Device::inputChannelUnits()
{
  QStringList chans = get_Channels();
  QStringList units = get_ChannelUnits();
  QString     chan  = inputChannelName();

  int indx = chans.indexOf(chan);

  return units.value(indx);
}

QString QPTC10Device::outputChannelUnits()
{
  QStringList chans = get_Channels();
  QStringList units = get_ChannelUnits();
  QString     chan  = outputChannelName();

  int indx = chans.indexOf(chan);

  return units.value(indx);
}

void QPTC10Device::readoutInitial()
{
  if (qcepDebug(DEBUG_PTC10)) {
    printMessage("Readout Initial");
  }

//  QString res = immediateQuery("Channel.list");

//  printMessage(tr("Channel List : %1").arg(res));

  sendCommand("system.com.verbose medium");

  updateChannelList();
  onInputChannelChanged();
  onOutputChannelChanged();
}

void QPTC10Device::readoutPolling()
{
  if (qcepDebug(DEBUG_PTC10)) {
    printMessage("Readout Polling");
  }

  QPidControllerPtr ctl = controller();

  if (ctl) {
    QString res = sendQuery("getOutput.names");

    if (res != get_ChannelList()) {
      parseChannelList(res);
    }

    res = sendQuery("getOutput.units");

    if (res != get_UnitsList()) {
      parseUnitsList(res);
    }

    res = sendQuery("getOutput");
    parseOutputValues(res);

    if (outputChannelName().length()) {
      queryProperty(tr("\"%1.PID.Mode?\"").arg(this->outputChannelName()),     ctl->prop_LoopEnabled());
      queryProperty(tr("\"%1.PID.Setpoint?\"").arg(this->outputChannelName()), ctl->prop_SetPoint());
      queryProperty(tr("\"%1.PID.RampT?\"").arg(this->outputChannelName()),    ctl->prop_RampPoint());
      queryProperty(tr("\"%1.PID.Ramp?\"").arg(this->outputChannelName()),     ctl->prop_RampRate(), 60.0);
      queryProperty(tr("\"%1?\"").arg(this->outputChannelName()),              ctl->prop_OutputLevel());
      queryProperty(tr("outputEnable?"),                                       ctl->prop_Enabled());
    }

    if (inputChannelName().length()) {
      queryProperty(tr("\"%1?\"").arg(this->inputChannelName()),               ctl->prop_Temperature());
    }
  }
}

void QPTC10Device::readoutTimeout()
{
  printMessage("Readout Timeout");

  flushCommandQueue();
}

void QPTC10Device::parseChannelList(QString chans)
{
  if (qcepDebug(DEBUG_PTC10)) {
    printMessage(tr("parseChannelList(\"%1\")").arg(chans.trimmed()));
  }

  if (chans != get_ChannelList()) {
    set_ChannelList(chans);
  }

  QStringList channels, outputChannels, inputChannels;

  QStringList chs = chans.split(", ", QString::SkipEmptyParts);

  foreach(QString ch, chs) {
    QString cht = ch.trimmed();
    QString res = sendQuery(tr("\"%1.PID.Mode?\"").arg(cht));

    channels.append(ch.trimmed());

    if (res.startsWith("Error")) {
      inputChannels.append(cht);
    } else {
      outputChannels.append(cht);
    }
  }

  set_Channels(channels);
  set_InputChannels(inputChannels);
  set_OutputChannels(outputChannels);

  QStringList res;
  res.append("Epoch");
  res.append("Day");
  res.append("Hours");
  res.append("Minutes");
  res.append("Seconds");
  res.append("Temperature");
  res.append("Output");
  res.append("Set Point");
  res.append("Ramp Point");
  res.append(channels);

  emit graphedChannelNames(res);
  emit loggedChannelNames(res);

  if(qcepDebug(DEBUG_PTC10)) {
    printMessage(chans.trimmed());
  }
}

void QPTC10Device::updateChannelList()
{
  if (QThread::currentThread() != thread()) {
    QMetaObject::invokeMethod(this, "updateChannelList", Qt::BlockingQueuedConnection);
  } else {
    if (commPort()->successfullyConnected()) {
      QString res = sendQuery("getOutput.names");

      parseChannelList(res);

      res = sendQuery("getOutput.units");

      parseUnitsList(res);
    }
  }
}

void QPTC10Device::parseUnitsList(QString str)
{
  if (str != get_UnitsList()) {
    set_UnitsList(str);
  }

  QStringList units;
  QStringList us = str.split(", ");

  foreach(QString u, us) {
    units.append(u.trimmed());
  }

  set_ChannelUnits(units);

  if(qcepDebug(DEBUG_PTC10)) {
    printMessage(tr("parseUnitsList: %1").arg(str.trimmed()));
  }
}

void QPTC10Device::parseOutputValues(QString str)
{
  QcepDoubleList vals;
  QStringList vs = str.split(", ");

  foreach(QString v, vs) {
    vals.append(v.toDouble());
  }

  set_ChannelValues(vals);

  if(qcepDebug(DEBUG_PTC10)) {
    printMessage(tr("parseOutputValues: %1").arg(str.trimmed()));
  }
}

void QPTC10Device::queryProperty(QString qry, QcepDoubleProperty *property, double scale)
{
  if (qcepDebug(DEBUG_PTC10)) {
    printMessage(tr("sendQuery %1").arg(qry));
  }

  QString res = sendQuery(qry);

  if (property) {
    property->setValue(res.toDouble()*scale);
  }
}

void QPTC10Device::queryProperty(QString qry, QcepBoolProperty *property)
{
  if (qcepDebug(DEBUG_PTC10)) {
    printMessage(tr("sendQuery %1").arg(qry));
  }

  QString res = sendQuery(qry);

  if (property) {
    property->setValue(!res.startsWith("Off"));
  }
}

void QPTC10Device::queryProperty(QString qry, QcepStringProperty *property)
{
  if (qcepDebug(DEBUG_PTC10)) {
    printMessage(tr("sendQuery %1").arg(qry));
  }

  QString res = sendQuery(qry);

  if (property) {
    property->setValue(res.trimmed());
  }
}

QString QPTC10Device::sendQuery(QString cmd)
{
  if (qcepDebug(DEBUG_PTC10)) {
    printMessage(tr("query:%1").arg(cmd.trimmed()));
  }

  if (QThread::currentThread() != thread()) {
    printMessage("Thread error");
  }

  QString res;

  if (commPort()) {
    commPort()->readAll();
    commPort()->write(qPrintable(cmd+"\n"));
    commPort()->waitForBytesWritten(1000);

    while (commPort()->waitForReadyRead(1000)) {
      if (commPort()->canReadLine()) {
        res = commPort()->readLine(10000);

        if (qcepDebug(DEBUG_PTC10)) {
          printMessage(tr("reply:%1").arg(res.trimmed()));
        }

        return res;
      }
    }
  }

  return res;
}

void QPTC10Device::sendCommand(QString cmd)
{
  if (qcepDebug(DEBUG_PTC10)) {
    printMessage(tr("cmmnd:%1").arg(cmd));
  }

  if (QThread::currentThread() != thread()) {
    printMessage("Thread error");
  }

  if (commPort()) {
    commPort()->write(qPrintable(cmd+"\n"));
    commPort()->waitForBytesWritten(1000);
  }
}

void QPTC10Device::changeSetPoint(double setPoint)
{
  sendCommand(tr("\"%1.PID.Setpoint\" %2").arg(this->outputChannelName()).arg(setPoint));
}

void QPTC10Device::changeRampRate(double rate)
{
  sendCommand(tr("\"%1.PID.Ramp\" %2").arg(this->outputChannelName()).arg(rate/60.0)); // Convert ramp rate to degC/sec
}

void QPTC10Device::changeProportional(double /*prop*/)
{
}

void QPTC10Device::changeIntegral(double /*integ*/)
{
}

void QPTC10Device::changeDerivative(double /*deriv*/)
{
}

void QPTC10Device::enable(bool on)
{
  QString onStr = (on ? "On" : "Off");

  printMessage("Outputs "+onStr);

  sendCommand(tr("outputEnable %1").arg(onStr));
}

void QPTC10Device::loopEnable(bool on)
{
  QString onStr = (on ? "On" : "Off");

  printMessage("PID Loop "+onStr);

  sendCommand(tr("\"%1.PID.Mode\" %2").arg(this->outputChannelName()).arg(onStr));
}

bool QPTC10Device::canAutoTune()
{
  return true;
}

void QPTC10Device::autoTune()
{
}

void QPTC10Device::onGraphingTimeout()
{
  QcepDoubleList vals;
  QPidControllerPtr ctl(controller());
  QDateTime      ts(QDateTime::currentDateTime());

  vals.append(ts.toTime_t());
  vals.append(ts.date().day());
  vals.append(ts.time().hour());
  vals.append(ts.time().minute());
  vals.append(ts.time().second());

  if (ctl) {
    vals.append(ctl->get_Temperature());
    vals.append(ctl->get_OutputLevel());
    vals.append(ctl->get_SetPoint());
    vals.append(ctl->get_RampPoint());
  } else {
    vals.append(0);
    vals.append(0);
    vals.append(0);
    vals.append(0);
  }

  vals.append(get_ChannelValues());

  emit graphedChannelValues(vals);
}

void QPTC10Device::onLoggingTimeout()
{
  QcepDoubleList vals;
  QPidControllerPtr ctl(controller());
  QDateTime      ts(QDateTime::currentDateTime());

  vals.append(ts.toTime_t());
  vals.append(ts.date().day());
  vals.append(ts.time().hour());
  vals.append(ts.time().minute());
  vals.append(ts.time().second());

  if (ctl) {
    vals.append(ctl->get_Temperature());
    vals.append(ctl->get_OutputLevel());
    vals.append(ctl->get_SetPoint());
    vals.append(ctl->get_RampPoint());
  } else {
    vals.append(0);
    vals.append(0);
    vals.append(0);
    vals.append(0);
  }

  vals.append(get_ChannelValues());

  emit loggedChannelValues(vals);
}

void QPTC10Device::ptc10test(QString cmd)
{
  printMessage("PTC10 Test");

  commPort()->write(qPrintable(cmd+"\n"));

  while (commPort()->waitForReadyRead(1000)) {
    if (commPort()->canReadLine()) {
      break;
    }
  }

  QString r1 = commPort()->readLine(1000);
}