qwatlowdevice.cpp

Go to the documentation of this file.

#include "qwatlowdevice.h"
#include <QTime>
#include <stdio.h>
#include "qpiddebug.h"
#include "qpidcommport.h"

QWatlowDevice::QWatlowDevice(QPidControllerWPtr ctrl, QcepSettingsSaverWPtr saver, QString deviceName) :
  QPidDevice(ctrl, saver, WatlowDevice, deviceName, 1000, 2000),
  m_ObjectNamer(this, "watlow"),
  m_TimerID(0)
{
}

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

  connect(&m_CommandTimer, SIGNAL(timeout()), this, SLOT(onTimeout()));

  m_TimerID = startTimer(2000);
}

void QWatlowDevice::stop()
{
  if (m_TimerID) {
    killTimer(m_TimerID);
    m_TimerID = 0;
  }

  QPidDevice::stop();
}

void QWatlowDevice::readoutInitial()
{
  QStringList channels;

  channels.append("Epoch");
  channels.append("Day");
  channels.append("Hours");
  channels.append("Minutes");
  channels.append("Seconds");
  channels.append("Temperature");
  channels.append("OutputLevel");
  channels.append("SetPoint");

  emit loggedChannelNames(channels);
  emit graphedChannelNames(channels);
}

void QWatlowDevice::readoutPolling()
{
}

void QWatlowDevice::readoutTimeout()
{
}

void QWatlowDevice::timerEvent(QTimerEvent *)
{
  if (m_CommandQueue.count() > 2) {
    if (qcepDebug(DEBUG_WATLOW)) {
      printMessage(tr("Discarding %1 outstanding commands").arg(m_CommandQueue.count()));
 //     m_CommandQueue.clear();
      printMessage(tr("%1 outstanding commands, skipping polling commands").arg(m_CommandQueue.count()));
    }
  } else {
    getParameter("SP1");
    getParameter("ER2");
    getParameter("C1");
    getParameter("PWR");
  }
}

void QWatlowDevice::onTimeout()
{
  printMessage(tr("Timeout on %1").arg(m_CommandQueue.first()));

  abandonCommand();
}

void QWatlowDevice::onReadyRead()
{
  QByteArray bytes;

  int a = commPort() -> bytesAvailable();

  bytes.resize(a);

  bytes = commPort() -> read(bytes.size());

  m_Reply.append(bytes);

  if (qcepDebug(DEBUG_WATLOW)) {
    printMessage(tr("Bytes received '%1' (%2)").arg(bytes.data()).arg(bytes.size()));
  }

  if (m_CommandQueue.length()) {
    QString cmd = m_CommandQueue.first();

    if (cmd[0] == '?') {
      if (m_Reply.endsWith(QChar(13))) {
        completeCommand();
        m_Reply = "";
      }
    } else if (cmd[0] == '=') {
      if (m_Reply.endsWith(QChar(17))) {
        completeCommand();
        m_Reply = "";
      }
    }
  }
}

void QWatlowDevice::sendCommand(QString cmd)
{
  pushCommand(cmd);
}

void QWatlowDevice::onDsrChanged(bool status)
{
  printMessage(tr("DSR Changed %1").arg(status));
}

void QWatlowDevice::pushCommand(QString cmd)
{
  m_CommandQueue.append(cmd);

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

void QWatlowDevice::issueCommand()
{
  if (m_CommandQueue.length() > 0) {
    m_CommandTimer.setSingleShot(true);
    m_CommandTimer.start(2000);

    QString cmd = m_CommandQueue[0];

    if (cmd[0] == '=') {
      printMessage(tr("Set: %1").arg(cmd));
    }

    if (commPort()) {
      if (qcepDebug(DEBUG_WATLOW)) {
        printMessage(tr("Sent command: %1").arg(cmd));
      }

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

void QWatlowDevice::completeCommand()
{
  if (m_CommandQueue.length() > 0) {
    m_CommandTimer.stop();

    QString cmd = m_CommandQueue.takeFirst();
    QPidControllerPtr ctl(controller());

    if (cmd[0] == '?') {
      QString parm = cmd.mid(2);
      bool ok;
      double val  = m_Reply.mid(2).toDouble(&ok);

      if (ok) {
        if (parm == "SP1") {
          if (ctl) {
            ctl->set_RampPoint(val);
          }
        } else if (parm == "PWR") {
          if (ctl) {
            ctl->set_OutputLevel(val);
          }
        } else if (parm == "C1") {
          if (ctl) {
            ctl->set_Temperature(val);
          }
        } else if (parm == "RATE") {
          if (ctl) {
            ctl->set_RampRate(val);
          }
        } else if (parm == "ER2") {
          if (val != 0) {
            printMessage(tr("ER2 = %1 : %2").arg(val).arg(errorMessage(val)));
          }
        }

        emit newParameterValue(cmd.mid(2), val);
      }
    }

    issueCommand();
  }
}

void QWatlowDevice::abandonCommand()
{
  if (m_CommandQueue.length() > 0) {
    m_CommandTimer.stop();

    QString cmd = m_CommandQueue.takeFirst();

    issueCommand();
  }
}

void QWatlowDevice::setParameter(QString param, double val)
{
  pushCommand(tr("= %1 %2").arg(param).arg(val));
}

void QWatlowDevice::getParameter(QString param)
{
  pushCommand(tr("? %1").arg(param));
}

QString QWatlowDevice::errorMessage(int code)
{
  switch (code) {
  case 0: return "No error";
  case 1: return "Transmit buffer overflow";
  case 2: return "Receive buffer overflow";
  case 3: return "Framing error";
  case 4: return "Overrun error";
  case 5: return "Parity error";
  case 6: return "Talking out of turn";
  case 7: return "Invalid reply error";
  case 8: return "Noise error";
  case 20: return "Command not found";
  case 21: return "Prompt not found";
  case 22: return "Incomplete command line";
  case 23: return "Invalid character";
  case 24: return "Number of chars. overflow";
  case 25: return "Input out of limit";
  case 26: return "Read only command";
  case 27: return "Write allowed only";
  case 28: return "Prompt not active";
  case 30: return "Request to RUN invalid";
  case 31: return "Request to HOLD invalid";
  case 32: return "Command invalid in RUN Mode";
  case 33: return "Command invalid in HOLD Mode";
  case 34: return "Output 3 is not an Event";
  case 35: return "Output 4 is not an Event";
  case 38: return "Asterisk not allowed";
  case 39: return "Infinite loop error";
  default:
    return "Unkown Error";
  }
}

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

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

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

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

void QWatlowDevice::configurationDialog()
{
  if (m_DeviceDialog == NULL) {
    m_DeviceDialog = QWatlowDeviceDialogPtr(new QWatlowDeviceDialog(QWatlowDevicePtr(this)));
  }

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

void QWatlowDevice::changeSetPoint(double setPoint)
{
  setParameter("SP1", setPoint);
}

void QWatlowDevice::changeRampRate(double rate)
{
    if (rate <= 0) {
        setParameter("RP", 0);
    } else {
        setParameter("RP", 2);
        setParameter("RATE", rate);
    }
}

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

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

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

void QWatlowDevice::enable(bool /*on*/)
{
  printMessage("<i>Enable not implemented</i>");
}

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

void QWatlowDevice::autoTune()
{
  setParameter("AUT", 1);
}

void QWatlowDevice::writeOutput(QString /*cmd*/)
{
}

template <class T>
QWatlowCommand<T>::QWatlowCommand(QWatlowDevice *device, QString cmd, T *property) :
  m_Device(device),
  m_Command(cmd),
  m_Property(property)
{
}

template <class T>
bool QWatlowCommand<T>::replyExpected() const
{
  return m_Property;
}

template<>
bool QWatlowCommand<void>::processReply(QString /*reply*/)
{
  return false;
}

template<>
bool QWatlowCommand<QcepDoubleProperty>::processReply(QString reply)
{
  bool ok;
  double value = reply.toDouble(&ok);

  if (ok && m_Property) {
    m_Property->setValue(value);
  }

  return (ok && m_Property);
}

template<>
bool QWatlowCommand<QcepBoolProperty>::processReply(QString reply)
{
  bool value = reply.startsWith("On");

  if (m_Property) {
    m_Property->setValue(value);
  }

  return (value && m_Property);
}

template <class T>
QString QWatlowCommand<T>::cmd() const
{
  return m_Command;
}

template <class T>
void QWatlowCommand<T>::issueCommand()
{
  m_Device->writeOutput(cmd());
}

void QWatlowDevice::onGraphingTimeout()
{
  QcepDoubleList res;

  QPidControllerPtr ctl(controller());
  QDateTime      ts(QDateTime::currentDateTime());

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

  res.append(ctl->get_Temperature());
  res.append(ctl->get_OutputLevel());
  res.append(ctl->get_RampPoint());

  emit graphedChannelValues(res);
}

void QWatlowDevice::onLoggingTimeout()
{
  QcepDoubleList res;

  QPidControllerPtr ctl(controller());
  QDateTime      ts(QDateTime::currentDateTime());

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

  res.append(ctl->get_Temperature());
  res.append(ctl->get_OutputLevel());
  res.append(ctl->get_RampPoint());

  emit loggedChannelValues(res);
}