Fixes #82, adds control channels in ModbusNG

config/Windows/productionroaster.xml

         var window = this;
         var targetOffset = 0;
         var gtrans = 0;
+		var translationdelay = new Timer;
+		translationdelay.interval = 0;
+		translationdelay.singleShot = true;
         var targetDetector = new ThresholdDetector;
         window.targetcolumnname = "";
         var currentDetector = new ThresholdDetector;
                             for(var j = 0; j < device.channelCount(); j++) {
                                 channels.push(device.getChannel(j));
                                 columnNames.push(device.channelColumnName(j));
-                                channelType.push("T");
+                                channelType.push(device.channelType(j));
                                 if(device.isChannelHidden(j)) {
                                     channelVisibility.push(false);
                                 } else {
                                     channelVisibility.push(true);
                                     var indicator = new TemperatureDisplay;
+									if(device.channelType(j) == "C") {
+										indicator.setDisplayUnits(Units.Unitless);
+										indicator.digitCount = 6;
+									}
                                     temperatureDisplays.push(indicator);
                                     var decorator = new WidgetDecorator(indicator, device.channelIndicatorText(j), 2);
                                     device.getChannel(j).newData.connect(indicator.setValue);
 			{
 				var colname = driverReference.column;
 				window.targetcolumnname = colname;
+				if(driverReference.delay)
+				{
+					translationdelay.interval = Number(driverReference.delay) * 1000;
+				}
 				for(var j = 0; j < columnNames.length; j++)
 				{
 					if(columnNames[j] == colname)
 			}
 			return retval;
 		};
+		translationdelay.timeout.connect(function() {
+			offsets[offsetForChannel(translationChannel)].measurement.connect(currentDetector.newMeasurement);
+		});
         start.clicked.connect(function() {
 			start.enabled = false;
 			hasTranslated = false;
             }
 			if(translationChannel >= 0)
 			{
-				offsets[offsetForChannel(translationChannel)].measurement.connect(currentDetector.newMeasurement);
+				translationdelay.start();
 			}
 			if(typeof(externtrans) != 'undefined') {
 				externtrans.display(0);

src/modbus.w

     QComboBox *unit = new QComboBox;
     unit->addItem("Celsius", "C");
     unit->addItem("Fahrenheit", "F");
+    unit->addItem("Control", "Control");
     unit->setCurrentIndex(1);
     layout->addRow(tr("Unit"), unit);
     QLineEdit *column = new QLineEdit;
         case 1:
             updateAttribute("unit", "F");
             break;
+        case 2:
+	        updateAttribute("unit", "Control");
+	        break;
     }
 }
 
         Q_INVOKABLE QString channelColumnName(int);
         Q_INVOKABLE QString channelIndicatorText(int);
         Q_INVOKABLE bool isChannelHidden(int);
+        Q_INVOKABLE QString channelType(int);
     private slots:
         void sendNextMessage();
         void timeout();
         QList<QString> channelNames;
         QList<QString> channelLabels;
         QList<bool> hiddenStates;
+        QList<QString> channelTypeList;
 };
 
 @ One of the things that the old Modbus code got right was in allowing the
     connect(messageDelayTimer, SIGNAL(timeout()), this, SLOT(sendNextMessage()));
     connect(commTimeout, SIGNAL(timeout()), this, SLOT(timeout()));
     connect(port, SIGNAL(readyRead()), this, SLOT(dataAvailable()));
-    port->open(QIODevice::ReadWrite);
+    if(!port->open(QIODevice::ReadWrite))
+    {
+	    qDebug() << "Failed to open serial port";
+    }
     for(int i = 0; i < model->rowCount(index); i++)
     {
         QModelIndex channelIndex = model->index(i, 0, index);
         if(channelAttributes.value("unit").toString() == "C")
         {
             scanItem.unit = Units::Celsius;
+            channelTypeList.append("T");
         }
-        else
+        else if(channelAttributes.value("unit").toString() == "F")
         {
             scanItem.unit = Units::Fahrenheit;
+            channelTypeList.append("T");
+        }
+        else
+        {
+	        scanItem.unit = Units::Unitless;
+	        channelTypeList.append("C");
         }
         scanList.append(scanItem);
         channels.append(new Channel);
         QTime time = QTime::currentTime();
         for(int i = 0; i < scanList.size(); i++)
         {
-            channels.at(i)->input(Measurement(scanList.at(i).lastValue, time, Units::Fahrenheit));
+	        if(scanList.at(scanPosition).unit == Units::Unitless)
+	        {
+		        channels.at(i)->input(Measurement(scanList.at(i).lastValue, time, Units::Unitless));
+	        }
+	        else
+	        {
+	            channels.at(i)->input(Measurement(scanList.at(i).lastValue, time, Units::Fahrenheit));
+            }
         }
     }
     responseBuffer.clear();
     return hiddenStates.at(channel);
 }
 
+QString ModbusNG::channelType(int channel)
+{
+	return channelTypeList.at(channel);
+}
+
 @ This class must be exposed to the host environment.
 
 @<Function prototypes for scripting@>=

src/typica.w

     /* Nothing needs to be done here. */
 }
 
+@* Timers.
+
+\noindent Some features in Typica require access to functionality similar to
+what |QTimer| provides from the host environment. This includes allowing
+script devices to periodically poll connected hardware and allowing a safety
+delay on profile translation.
+
+<@Function prototypes for scripting@>=
+void setQTimerProperties(QScriptValue value, QScriptEngine *engine);
+QScriptValue constructQTimer(QScriptContext *context, QScriptEngine *engine);
+
+@ The host environment is informed of the constructor.
+
+@<Set up the scripting engine@>=
+constructor = engine->newFunction(constructQTimer);
+value = engine->newQMetaObject(&QTimer::staticMetaObject, constructor);
+engine->globalObject().setProperty("Timer", value);
+
+@ Everything that we are interested in here is a signal, slot, or property so
+there is little else to do.
+
+@<Functions for scripting@>=
+void setQTimerProperties(QScriptValue value, QScriptEngine *engine)
+{
+	setQObjectProperties(value, engine);
+}
+
+QScriptValue constructQTimer(QScriptContext *, QScriptEngine *engine)
+{
+	QScriptValue object = engine->newQObject(new QTimer);
+	setQTimerProperties(object, engine);
+	return object;
+}
+
+
 @* Scripting QWidget.
 
 \noindent The first interesting class in this hierarchy is |QWidget|. This is
     @[private slots@]:@/
         void updateMatchingColumn(const QString &column);
         void updateTemperature();
+        void updateDelay();
     private:@/
         QDoubleSpinBox *temperatureValue;
         QComboBox *unitSelector;
+        QSpinBox *delaySelector;
 };
 
 @ The constructor sets up our user interface.
 @<TranslationConfWidget implementation@>=
 TranslationConfWidget::TranslationConfWidget(DeviceTreeModel *model, const QModelIndex &index)
 : BasicDeviceConfigurationWidget(model, index),
-    temperatureValue(new QDoubleSpinBox), unitSelector(new QComboBox)
+    temperatureValue(new QDoubleSpinBox), unitSelector(new QComboBox),
+    delaySelector(new QSpinBox)
 {
     unitSelector->addItem("Fahrenheit");
     unitSelector->addItem("Celsius");
     layout->addRow(tr("Column to match:"), column);
     layout->addRow(tr("Unit:"), unitSelector);
     layout->addRow(tr("Value:"), temperatureValue);
+    layout->addRow(tr("Start of batch safety delay:"), delaySelector);
     @<Get device configuration data for current node@>@;
     for(int i = 0; i < configData.size(); i++)
     {
         {
             temperatureValue->setValue(node.attribute("value").toDouble());
         }
+        else if(node.attribute("name") == "delay")
+        {
+	        delaySelector->setValue(node.attribute("value").toInt());
+        }
     }
     updateMatchingColumn(column->text());
     updateTemperature();
+    updateDelay();
     connect(column, SIGNAL(textEdited(QString)), this, SLOT(updateMatchingColumn(QString)));
     connect(unitSelector, SIGNAL(currentIndexChanged(QString)), this, SLOT(updateTemperature()));
     connect(temperatureValue, SIGNAL(valueChanged(double)), this, SLOT(updateTemperature()));
+    connect(delaySelector, SIGNAL(valueChanged(int)), this, SLOT(updateDelay()));
     setLayout(layout);
 }
 
     updateAttribute("column", column);
 }
 
+void TranslationConfWidget::updateDelay()
+{
+	updateAttribute("delay", QString("%1").arg(delaySelector->value()));
+}
+
 @ This is registered with the configuration system.
 
 @<Register device configuration widgets@>=