qpidcontroller.cpp

Go to the documentation of this file.

#include "qpidcontroller.h"
#include "qpiddevice.h"
#include "qpidsettings.h"
#include "qpiddevicethread.h"
#include "qpidobjectnamer.h"
#include <stdio.h>
#include "qcepdebug.h"
#include "qpidserverthread.h"
#include "qpidserver.h"
#include "qpidloggerthread.h"
#include "qpidlogger.h"
#include "qpidmainwindow.h"
#include "qextserialenumerator.h"
#include <math.h>
#include <limits>
#include <QDir>
#include "qpidserversession.h"

QPidController::QPidController(QObject *parent) :
  QObject(parent),
  m_ObjectNamer(this, "controller"),
  m_MainWindow(NULL),
  m_Saver(new QcepSettingsSaver(this)),
  m_Debug(m_Saver, this, "debug", 0, "Debug Level"),
  m_ControllerStatus(QcepSettingsSaverPtr(), this, "controllerStatus", Stopped, "Controller Status?"),
  m_Connected(QcepSettingsSaverPtr(), this, "connected", false, "Device Connected?"),
  m_DefaultDeviceNumber(m_Saver, this, "defaultDeviceNumber", 0, "Default Device Number"),
  m_Temperature(QcepSettingsSaverPtr(), this, "temperature", nan(), "Temperature"),
  m_RampPoint(QcepSettingsSaverPtr(), this, "rampPoint", nan(), "Ramp Point (current setpoint during ramp)"),
  m_SetPoint   (m_Saver, this, "setPoint",    nan(), "Target Set Point"),
  m_RampRate   (m_Saver, this, "rampRate",    0, "Set Point Ramping Rate (or 0 for no ramping) in degC/min"),
  m_HeatSetPoint(m_Saver, this, "heatSetPoint", 0, "Set Point for heating phase"),
  m_HeatRampRate(m_Saver, this, "heatRampRate", 0, "Ramp rate for heating phase"),
  m_SoakTime(m_Saver, this, "soakTime", 0, "Soak time"),
  m_CoolRampRate(m_Saver, this, "coolRampRate", 0, "Ramp rate for cooling phase"),
  m_Proportional   (m_Saver, this, "proportional",    0, "Proportional term (%/degC)"),
  m_Integral   (m_Saver, this, "integral",    0, "Integral term"),
  m_Derivative   (m_Saver, this, "derivative",    0, "Derivative term"),
  m_OutputLevel(QcepSettingsSaverPtr(), this, "outputLevel", nan(), "Output Level (%)"),
  m_Enabled(m_Saver, this, "enabled", false, "Output Enabled?"),
  m_LoopEnabled(m_Saver, this, "loopEnabled", false, "PID Loop Enabled?"),
  m_ColumnNames(m_Saver, this, "columnNames", QStringList(), "Graph Column Names"),
  m_SelectionCounter(m_Saver, this, "selectionCounter", 0, "Dummy Property used to force settings to be saved"),
  m_GraphLength(m_Saver, this, "graphLength", 100, "Length of Temperature History"),
  m_GraphInterval(m_Saver, this, "graphInterval", 5, "Update Interval for Temperature History in sec"),
  m_WindowGeometry(m_Saver, this, "windowGeometry", QByteArray(), "Window Geometry Settings"),
  m_WindowState(m_Saver, this, "windowState", QByteArray(), "Window State Settings"),
  m_SettingsPath(QcepSettingsSaverPtr(), this, "settingsPath", "", "Settings saved in"),
  m_SkippedColumns(5)
{
  connect(prop_DefaultDeviceNumber(), SIGNAL(valueChanged(int,int)), this, SLOT(onDefaultDeviceChanged(int)));
}

QPidController::~QPidController()
{
}

double QPidController::nan()
{
  return std::numeric_limits<double>::quiet_NaN();
}

void QPidController::printMessage(QString msg, QDateTime dt)
{
  QPidMainWindowPtr win(m_MainWindow);

  if (win) {
    win -> printMessage(msg, dt);
  }
}

void QPidController::criticalMessage(QString msg)
{
  QPidMainWindowPtr win(m_MainWindow);

  if (win) {
    win -> criticalMessage(msg);
  }
}

void QPidController::start(QPidMainWindowWPtr window, QPidControllerWPtr ctrl)
{
  m_MainWindow = window;

  m_ServerThread = QPidServerThreadPtr(new QPidServerThread(m_Saver, ctrl));

  if (m_ServerThread) {
    m_ServerThread -> start();
    m_Server = m_ServerThread -> server();
  }

  m_LoggerThread = QPidLoggerThreadPtr(new QPidLoggerThread(m_Saver, ctrl));

  if (m_LoggerThread) {
    m_LoggerThread -> start();
    m_Logger = m_LoggerThread -> logger();
  }

  m_ScriptEngine = QPidScriptEnginePtr(new QPidScriptEngine(ctrl, NULL));

  connect(prop_Debug(), SIGNAL(valueChanged(int,int)), this, SLOT(debugChanged(int)));

  readSettings();

  m_Saver->start();

  m_MainWindow->start();
}

void QPidController::onDeviceReady()
{
}

QcepSettingsSaverPtr QPidController::saver()
{
  return m_Saver;
}

void QPidController::debugChanged(int dbg)
{
  if (g_DebugLevel) {
    g_DebugLevel->setDebugLevel(dbg);
  }
}

void QPidController::startController()
{
  set_ControllerStatus(Starting);

  QPidDevicePtr dev = m_Devices[get_DefaultDeviceNumber()];

  connect(dev.data(), SIGNAL(loggedChannelNames(QStringList)), this, SLOT(onLoggedChannelNames(QStringList)));
  connect(dev.data(), SIGNAL(loggedChannelValues(QcepDoubleList)), this, SLOT(onLoggedChannelValues(QcepDoubleList)));
  connect(dev.data(), SIGNAL(graphedChannelNames(QStringList)), this, SLOT(onGraphedChannelNames(QStringList)));
  connect(dev.data(), SIGNAL(graphedChannelValues(QcepDoubleList)), this, SLOT(onGraphedChannelValues(QcepDoubleList)));

  dev->set_RunState(true);

  set_ControllerStatus(Running);
}

void QPidController::stopController()
{
  set_ControllerStatus(Stopping);

  QPidDevicePtr dev = m_Devices[get_DefaultDeviceNumber()];

  dev->set_RunState(false);

  disconnect(dev.data(), SIGNAL(loggedChannelNames(QStringList)), this, SLOT(onLoggedChannelNames(QStringList)));
  disconnect(dev.data(), SIGNAL(loggedChannelValues(QcepDoubleList)), this, SLOT(onLoggedChannelValues(QcepDoubleList)));
  disconnect(dev.data(), SIGNAL(graphedChannelNames(QStringList)), this, SLOT(onGraphedChannelNames(QStringList)));
  disconnect(dev.data(), SIGNAL(graphedChannelValues(QcepDoubleList)), this, SLOT(onGraphedChannelValues(QcepDoubleList)));

  set_ControllerStatus(Stopped);
}

void QPidController::restartController()
{
  set_ControllerStatus(Restarting);

  m_Devices[get_DefaultDeviceNumber()]->restart();

  set_ControllerStatus(Running);
}

void QPidController::pauseController()
{
  set_ControllerStatus(Paused);
}

void QPidController::resumeController()
{
  set_ControllerStatus(Running);
}

QString QPidController::controllerStatusString(int status)
{
  QString res = "Unknown";

  switch(status) {
  case Stopping:
    res = "Stopping";
    break;

  case Stopped:
    res = "Stopped";
    break;

  case Starting:
    res = "Starting";
    break;

  case Running:
    res = "Running";
    break;

  case Paused:
    res = "Paused";
    break;

  case Restarting:
    res = "Restarting";
    break;

  case Error:
    res = "Error";
    break;
  }

  return res;
}

QPidDevicePtr QPidController::defaultDevice() const
{
  return m_Devices.value(get_DefaultDeviceNumber());
}

QPidDevicePtr QPidController::getDevice(int dev) const
{
  return m_Devices.value(dev);
}

QScriptValue QPidController::device(int i) const
{
  QPidDevicePtr dev = m_Devices.value(i);

  return m_ScriptEngine->newQObject(dev.data(), QScriptEngine::QtOwnership);
}

void QPidController::setDefaultDevice(int dev)
{
  stopController();

  set_DefaultDeviceNumber(dev);

  emit deviceListChanged();
}

void QPidController::onDefaultDeviceChanged(int dev)
{
  m_ScriptEngine->setDefaultDevice(getDevice(dev));
}

void QPidController::setDeviceName(int dev, QString name)
{
  QPidDevicePtr devp = m_Devices.value(dev);

  if (devp) {
    devp -> set_DeviceName(name);
  }

  emit deviceListChanged();
}

void QPidController::configurationDialog(int dev)
{
  QPidDevicePtr devp = m_Devices.value(dev);

  if (devp) {
    devp -> configurationDialog();
  }
}

int QPidController::defaultDeviceNumber() const
{
  return get_DefaultDeviceNumber();
}

void QPidController::writeSettings()
{
  if (get_SettingsPath() == "") {
    QPidSettings settings;

    writeSettings(&settings);
  } else {
    saveSettings(get_SettingsPath());
  }
}

void QPidController::writeSettings(QPidSettings *settings)
{
  if (qcepDebug(DEBUG_PREFS)) {
    printMessage("QPidController::writeSettings()");
  }

  QPidMainWindowPtr win(m_MainWindow);

  if (win) {
    set_WindowGeometry(win->saveGeometry());
    set_WindowState(win->saveState(2));

    win->saveSplitterState(settings);
  }

  QcepProperty::writeSettings(this, &staticMetaObject, "controller", settings);

  settings->beginWriteArray("selection");
  int i=0;

  QMapIterator<QString,int> iter(m_ColumnSelections);

  while(iter.hasNext()) {
    iter.next();

    settings->setArrayIndex(i++);
    settings->setValue("name", iter.key());
    settings->setValue("selection",iter.value());
  }

  settings->endArray();

  settings->beginWriteArray("devices");

  for (int i=0; i<m_Devices.count(); i++) {
    settings->setArrayIndex(i);
    if (m_Devices.value(i)) {
      QPidDevicePtr dev(m_Devices.value(i));

      settings->setValue("type", dev->get_DeviceType());
      settings->setValue("name", dev->get_DeviceName());

      m_Devices.value(i)->writeSettings(settings, "device");
    }
  }

  settings->endArray();

  if (m_Server) {
    m_Server->writeSettings(settings, "socketServer");
  }

  if (m_Logger) {
    m_Logger->writeSettings(settings, "logger");
  }
}

void QPidController::readSettings()
{
  if (get_SettingsPath() == "") {
    QPidSettings settings;

    readSettings(&settings);
  } else {
    loadSettings(get_SettingsPath());
  }
}

void QPidController::readSettings(QPidSettings *settings)
{
  clearDevices();

  QcepProperty::readSettings(this, &staticMetaObject, "controller", settings);

  int nd = settings->beginReadArray("devices");

  for (int i=0; i<nd; i++) {
    settings->setArrayIndex(i);

    int type = settings->value("type").toInt();
    QString name = settings->value("name").toString();

    appendDevice(type, name);

    QPidDevicePtr dev = m_Devices.value(i);

    if (dev) {
      dev->readSettings(settings, "device");
    }
  }

  settings->endArray();

  if (m_Server) {
    m_Server->readSettings(settings, "socketServer");
  }

  if (m_Logger) {
    m_Logger->readSettings(settings, "logger");
  }

  m_ColumnSelections.clear();

  int sz = settings->beginReadArray("selection");

  for (int i=0; i<sz; i++) {
    settings->setArrayIndex(i);

    QString name = settings->value("name").toString();
    int     val  = settings->value("selection").toInt();

    m_ColumnSelections[name] = val;
  }

  settings->endArray();

  QPidMainWindowPtr win(m_MainWindow);

  if (win) {
    QByteArray geometry = get_WindowGeometry();
    QByteArray winstate = get_WindowState();

    if (!win->restoreGeometry(geometry)) {
      printMessage("Restore geometry failed");
    }

    if (!win->restoreState(winstate,2)) {
      printMessage("Restore state failed");
    }

    win->restoreSplitterState(settings);
  }

  onDefaultDeviceChanged(get_DefaultDeviceNumber());
}

void QPidController::loadSettings(QString filePath)
{
  QPidSettings settings(filePath);

  readSettings(&settings);

  setSettingsFilePath(filePath);
}

void QPidController::saveSettings(QString filePath)
{
  QPidSettings settings(filePath);

  writeSettings(&settings);

  setSettingsFilePath(filePath);
}

QString QPidController::settingsFilePath() const
{
  if (m_SettingsFilePath == "") {
    return QDir::homePath();
  } else {
    return m_SettingsFilePath;
  }
}

void QPidController::setSettingsFilePath(QString filePath)
{
  m_SettingsFilePath = filePath;
}

void QPidController::appendDevice(int deviceKind, QString deviceName)
{
  QPidDeviceThreadPtr thread = QPidDeviceThread::createDevice(QPidControllerWPtr(this), deviceKind, deviceName);

  if (thread) {
    thread->start();

    QPidDevicePtr dev = thread->waitForDevice();

    if (dev) {
      m_DeviceThreads.append(thread);
      m_Devices.append(dev);

      emit deviceListChanged();
    }
  }
}

void QPidController::clearDevices()
{
  m_DeviceThreads.clear();
  m_Devices.clear();

  emit deviceListChanged();
}

void QPidController::deleteDevices(QVector<int> devList)
{
  while (devList.count()) {
    m_Devices.remove(devList.last());
    m_DeviceThreads.remove(devList.last());
    devList.pop_back();
  }

  emit deviceListChanged();
}

int QPidController::countDevices()
{
  return m_Devices.count();
}

QPidServerPtr QPidController::server()
{
  return m_Server;
}

QPidLoggerPtr QPidController::logger()
{
  return m_Logger;
}

void QPidController::updateConnected(bool newConnected)
{
  set_Connected(newConnected);

  if (!get_Connected()) {
    set_Temperature(nan());
    set_OutputLevel(nan());
    set_RampPoint(nan());
  }
}

void QPidController::updateTemperature(double newTemperature)
{
  set_Connected(true);
  set_Temperature(newTemperature);
}

void QPidController::updateRampPoint(double newRampPoint)
{
  set_Connected(true);
  set_RampPoint(newRampPoint);
}

void QPidController::updateOutputLevel(double newOutputLevel)
{
  set_Connected(true);
  set_OutputLevel(newOutputLevel);
}

void QPidController::executeCommand(QString cmd)
{
  QScriptValue result = m_ScriptEngine->evaluate(cmd);

  printMessage(result.toString());
}

void QPidController::executeServerCommand(QPidServerSessionWPtr wksess, QString cmd)
{
  QScriptValue result = m_ScriptEngine->evaluate(cmd);

  QPidServerSessionPtr sess(wksess);

  if (sess) {
    QMetaObject::invokeMethod(sess.data(), "finishedCommand", Q_ARG(QScriptValue, result));
  }
}

void QPidController::listSerialPorts()
{
  printMessage("Available Serial Ports:");

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

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

    printMessage(tr("Port %1").arg(i));
    printMessage(tr("Port Name: %1").arg(port.portName));
    printMessage(tr("Phys Name: %1").arg(port.physName));
    printMessage(tr("Frnd Name: %1").arg(port.friendName));
    printMessage(tr("Enum Name: %1").arg(port.enumName));
    printMessage("");
  }
}

void QPidController::startRampSoakCool()
{
  if (get_SoakTime() > 0) {
    double soakTime = get_SoakTime();

    if (get_HeatRampRate() > 0) {
      soakTime += fabs((get_HeatSetPoint() - get_SetPoint())/get_HeatRampRate());
    }

    connect(&m_RampSoakTimer, SIGNAL(timeout()), this, SLOT(onRampSoakTimer()));

    printMessage(tr("Ramping from %1 to %2 at %3 / min")
                 .arg(get_SetPoint()).arg(get_HeatSetPoint()).arg(get_HeatRampRate()));

    m_RampSoakTimer.start(soakTime*60.0*1000.0);
  }
}

void QPidController::cancelRampSoakCool()
{
  disconnect(&m_RampSoakTimer, SIGNAL(timeout()), this, SLOT(onRampSoakTimer()));
}

void QPidController::onRampSoakTimer()
{
  printMessage(tr("Cooling from %1 to %2 at %3 / min")
               .arg(get_HeatSetPoint()).arg(get_SetPoint()).arg(get_CoolRampRate()));

  disconnect(&m_RampSoakTimer, SIGNAL(timeout()), this, SLOT(onRampSoakTimer()));
}

void QPidController::sendCommand(QString cmd)
{
  QPidDevicePtr dev(defaultDevice());

  if (dev) {
    dev->sendCommand(cmd);
  }
}

void QPidController::autoTune()
{
  QPidDevicePtr dev(defaultDevice());

  if (dev) {
    dev->autoTune();
  }
}

void QPidController::onLoggedChannelNames(QStringList names)
{
  QPidLoggerPtr logger(m_Logger);

  if (logger) {
    logger->logChannelNames(names);
  }
}

void QPidController::onLoggedChannelValues(QcepDoubleList values)
{
  QPidLoggerPtr logger(m_Logger);

  if (logger) {
    logger->logChannelValues(values);
  }
}

void QPidController::onGraphedChannelNames(QStringList names)
{
  set_ColumnNames(names);

  int n=names.length();

  for (int i=m_PlottedValues.length(); i<n; i++) {
    m_PlottedValues.append(QVector<double>());
  }

  QPidMainWindowPtr window(m_MainWindow);

  if (window) {
    window->graphChannelNames(names);
  }
}

void QPidController::onGraphedChannelValues(QcepDoubleList values)
{
  int n = values.length();
  int np = get_GraphLength();

  for (int i=m_PlottedValues.length(); i<n; i++) {
    m_PlottedValues.append(QVector<double>());
  }

  for (int i=0; i<n; i++) {
    m_PlottedValues[i].append(values[i]);

    int l = m_PlottedValues[i].count();

    if (l > np) {
      m_PlottedValues[i].remove(0, l-np);
    }
  }

  QPidMainWindowPtr window(m_MainWindow);

  if (window) {
    window->graphChannelValues(values);
  }
}

Qt::CheckState QPidController::yChecked(int col)
{
  QString name = get_ColumnNames().value(col);

  int sel = m_ColumnSelections.value(name);

  return (sel & 1 ? Qt::Checked : Qt::Unchecked);
}

Qt::CheckState QPidController::y2Checked(int col)
{
  QString name = get_ColumnNames().value(col);

  int sel = m_ColumnSelections.value(name);

  return (sel & 2 ? Qt::Checked : Qt::Unchecked);
}

void QPidController::setYChecked(int col, Qt::CheckState state)
{
  QString name = get_ColumnNames().value(col);

  if (name.length()) {
    int val = m_ColumnSelections.value(name);

    if (state == Qt::Checked) {
      val |= 1;
    } else if (state == Qt::Unchecked) {
      val &= ~1;
    }

    m_ColumnSelections[name] = val;

    prop_SelectionCounter()->incValue(1);
  }
}

void QPidController::setY2Checked(int col, Qt::CheckState state)
{
  QString name = get_ColumnNames().value(col);

  if (name.length()) {
    int val = m_ColumnSelections.value(name);

    if (state == Qt::Checked) {
      val |= 2;
    } else if (state == Qt::Unchecked) {
      val &= ~2;
    }

    m_ColumnSelections[name] = val;

    prop_SelectionCounter()->incValue(1);
  }
}