qptc10simulator.cpp

Go to the documentation of this file.

#include "qptc10simulator.h"
#include <stdio.h>
#include <QWaitCondition>
#include <QMutex>
#include "qptc10device.h"
#include "qpiddebug.h"

QPTC10Simulator::QPTC10Simulator(QPTC10DeviceWPtr device) :
  QPidSimulator(NULL),
  m_Device(device),
  m_OutputLevel("75"),
  m_Temperature("23"),
  m_SetPoint("42"),
  m_RampPoint("42"),
  m_RampRate("10"),
  m_CtrlMode("Off"),
  m_Enabled("Off"),
  m_LoopEnabled("Off")
{
}

QPTC10Simulator::~QPTC10Simulator()
{
}

qint64 QPTC10Simulator::readData(char *data, qint64 maxlen)
{
  if (m_Replies.count() > 0) {
    strncpy(data, qPrintable(m_Replies.takeFirst()), maxlen);

    return strlen(data);
  } else {
    return -1;
  }
}

qint64 QPTC10Simulator::readLineData(char *data, qint64 maxlen)
{
  return readData(data, maxlen);
}

qint64 QPTC10Simulator::writeData(const char *data, qint64 len)
{
  QString cmd(data);

  if (qcepDebug(DEBUG_PTC10SIM)) {
    printMessage(tr("QPTC10Simulator::writeData %1, %2, %3").arg(data).arg(strlen(data)).arg(len));
  }

  if (cmd == "\"Control.PID.Mode?\"\n") {
    reply(m_LoopEnabled);
  } else if (cmd == "\"Control.PID.Setpoint?\"\n") {
      reply(m_SetPoint);
  } else if (cmd == "\"Control.PID.RampT?\"\n") {
    reply(m_RampPoint);
  } else if (cmd == "\"Control.PID.Ramp?\"\n") {
    reply(m_RampRate);
  } else if (cmd == "outputEnable?\n") {
    reply(m_Enabled);
  } else if (cmd == "\"Control?\"\n") {
    reply(m_OutputLevel);
  } else if (cmd == "\"TC?\"\n") {
    reply(m_Temperature);
  } else if (cmd == "getOutput\n") {
    reply(tr("%1, %2, 0, 0").arg(m_OutputLevel).arg(m_Temperature));
  } else if (cmd == "getOutput.names\n") {
    reply("Control, TC, Chan C, Chan D");
  } else if (cmd == "getOutput.units\n") {
    reply("%, degC, V, W");
  } else if (cmd == "system.com.verbose medium\n") {
  } else if (cmd == "\"TC.PID.Mode?\"\n") {
    reply("Error: non-exist");
  } else if (cmd == "\"Chan C.PID.Mode?\"\n") {
    reply("Error: non-exist");
  } else if (cmd == "\"Chan D.PID.Mode?\"\n") {
    reply("Off");
  } else {
    QRegExp regex("\"Control\\.PID\\.Setpoint\"\\s+(\\S*)\\n");

    if (regex.exactMatch(cmd)) {
      m_SetPoint = regex.capturedTexts()[1];

      return len;
    } else {
      QRegExp regex("\"Control\\.PID\\.Ramp\"\\s+(\\S*)\\n");

      if (regex.exactMatch(cmd)) {
        m_RampRate = regex.capturedTexts()[1];

        return len;
      } else {
        QRegExp regex("\"Control\\.PID\\.Mode\"\\s+(\\S*)\\n");

        if (regex.exactMatch(cmd)) {
          m_LoopEnabled = regex.capturedTexts()[1];

          return len;
        } else {
          QRegExp regex("outputEnable\\s+(\\S*)\\n");

          if (regex.exactMatch(cmd)) {
            m_Enabled = regex.capturedTexts()[1];

            return len;
          }
        }
      }
    }

    printMessage(tr("Unrecognized PTC10 Command %1").arg(cmd));

    reply(tr("Error: %1").arg(cmd));
  }

  return len;
}

void QPTC10Simulator::reply(QString rply)
{
  if (qcepDebug(DEBUG_PTC10SIM)) {
    printMessage(tr("QPTC10Simulator::reply %1").arg(rply));
  }

  m_Replies.append(rply+"\n");

  emit readyRead();
}

bool QPTC10Simulator::canReadLine() const
{
  if (qcepDebug(DEBUG_PTC10SIM)) {
    printMessage(tr("QPTC10Simulator::canReadLine %1").arg(m_Replies.count()));
  }

  return m_Replies.count();
}

bool QPTC10Simulator::waitForReadyRead(int msecs)
{
  if (m_Replies.count()) {
    return true;
  } else {
    QWaitCondition waitCondition;
    QMutex mutex;

    waitCondition.wait(&mutex, msecs);

    return m_Replies.count();
  }
}

void QPTC10Simulator::printMessage(QString msg, QDateTime ts) const
{
  QPTC10DevicePtr dev(m_Device);

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