Extend scale support

config/Windows/productionroaster.xml

 				scale.setParity(driverReference.parity);
 				scale.setStopBits(driverReference.stopbits);
 				scale.setFlowControl(driverReference.flowcontrol);
+				scale.setWeighCommand(driverReference.weighcommand);
+				scale.setCommandTerminator(driverReference.commandterminator);
 				scale.open(3);
 				window.scales.push(scale);
 			}

src/moc_scale.cpp

        6,       // revision
        0,       // classname
        0,    0, // classinfo
-       4,   14, // methods
+       6,   14, // methods
        0,    0, // properties
        0,    0, // enums/sets
        0,    0, // constructors
  // slots: signature, parameters, type, tag, flags
       60,   12,   12,   12, 0x0a,
       67,   12,   12,   12, 0x0a,
-      75,   12,   12,   12, 0x08,
+      83,   75,   12,   12, 0x0a,
+     119,  108,   12,   12, 0x0a,
+     149,   12,   12,   12, 0x08,
 
        0        // eod
 };
 static const char qt_meta_stringdata_SerialScale[] = {
     "SerialScale\0\0weight,unit\0"
     "newMeasurement(double,Units::Unit)\0"
-    "tare()\0weigh()\0dataAvailable()\0"
+    "tare()\0weigh()\0command\0setWeighCommand(QString)\0"
+    "terminator\0setCommandTerminator(QString)\0"
+    "dataAvailable()\0"
 };
 
 void SerialScale::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
         case 0: _t->newMeasurement((*reinterpret_cast< double(*)>(_a[1])),(*reinterpret_cast< Units::Unit(*)>(_a[2]))); break;
         case 1: _t->tare(); break;
         case 2: _t->weigh(); break;
-        case 3: _t->dataAvailable(); break;
+        case 3: _t->setWeighCommand((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 4: _t->setCommandTerminator((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 5: _t->dataAvailable(); break;
         default: ;
         }
     }
     if (_id < 0)
         return _id;
     if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 4)
+        if (_id < 6)
             qt_static_metacall(this, _c, _id, _a);
-        _id -= 4;
+        _id -= 6;
     }
     return _id;
 }

src/moc_typica.cpp

        6,       // revision
        0,       // classname
        0,    0, // classinfo
-       5,   14, // methods
+       7,   14, // methods
        0,    0, // properties
        0,    0, // enums/sets
-       1,   39, // constructors
+       1,   49, // constructors
        0,       // flags
        0,       // signalCount
 
       86,   80,   22,   22, 0x08,
      104,   80,   22,   22, 0x08,
      127,   80,   22,   22, 0x08,
+     155,  147,   22,   22, 0x08,
+     194,  183,   22,   22, 0x08,
 
  // constructors: signature, parameters, type, tag, flags
-     159,  147,   22,   22, 0x0e,
+     239,  227,   22,   22, 0x0e,
 
        0        // eod
 };
     "updatePort(QString)\0rate\0"
     "updateBaudRate(QString)\0index\0"
     "updateParity(int)\0updateFlowControl(int)\0"
-    "updateStopBits(int)\0model,index\0"
+    "updateStopBits(int)\0command\0"
+    "updateWeighCommand(QString)\0terminator\0"
+    "updateCommandTerminator(QString)\0"
+    "model,index\0"
     "SerialScaleConfWidget(DeviceTreeModel*,QModelIndex)\0"
 };
 
         case 2: _t->updateParity((*reinterpret_cast< int(*)>(_a[1]))); break;
         case 3: _t->updateFlowControl((*reinterpret_cast< int(*)>(_a[1]))); break;
         case 4: _t->updateStopBits((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 5: _t->updateWeighCommand((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 6: _t->updateCommandTerminator((*reinterpret_cast< const QString(*)>(_a[1]))); break;
         default: ;
         }
     }
     if (_id < 0)
         return _id;
     if (_c == QMetaObject::InvokeMetaMethod) {
-        if (_id < 5)
+        if (_id < 7)
             qt_static_metacall(this, _c, _id, _a);
-        _id -= 5;
+        _id -= 7;
     }
     return _id;
 }

src/scale.cpp

 /*1008:*/
-#line 131 "./scales.w"
+#line 135 "./scales.w"
 
 #include "scale.h"
 #include <QStringList> 
 }
 
 /*:1008*//*1009:*/
-#line 149 "./scales.w"
+#line 153 "./scales.w"
 
 void SerialScale::dataAvailable()
 {
 else
 {
 /*1010:*/
-#line 189 "./scales.w"
+#line 193 "./scales.w"
 
 QStringList responseParts= QString(responseBuffer.simplified()).split(' ');
 if(responseParts.size()> 2)
 }
 double weight= responseParts[0].toDouble();
 Units::Unit unit= Units::Unitless;
-if(responseParts[1]=="lb")
+if(responseParts[1].compare("lb",Qt::CaseInsensitive)==0)
 {
 unit= Units::Pound;
 }
-else if(responseParts[1]=="kg")
+else if(responseParts[1].compare("kg",Qt::CaseInsensitive)==0)
 {
 unit= Units::Kilogram;
 }
-else if(responseParts[1]=="g")
+else if(responseParts[1].compare("g",Qt::CaseInsensitive)==0)
 {
 unit= Units::Gram;
 }
-else if(responseParts[1]=="oz")
+else if(responseParts[1].compare("oz",Qt::CaseInsensitive)==0)
 {
 unit= Units::Ounce;
 }
 emit newMeasurement(weight,unit);
 
 /*:1010*/
-#line 161 "./scales.w"
+#line 165 "./scales.w"
 
 responseBuffer.clear();
 }
 }
 
 /*:1009*//*1011:*/
-#line 220 "./scales.w"
+#line 224 "./scales.w"
 
 void SerialScale::tare()
 {
 
 void SerialScale::weigh()
 {
-write("!KP\x0D");
+
+write(weighCommand+commandTerminator);
+}
+
+void SerialScale::setWeighCommand(const QString&command)
+{
+weighCommand= command.toAscii();
+}
+
+void SerialScale::setCommandTerminator(const QString&terminator)
+{
+if(terminator=="CRLF")
+{
+commandTerminator= "\x0D\x0A";
+}
+else if(terminator=="CR")
+{
+commandTerminator= "\x0D";
+}
+else if(terminator=="LF")
+{
+commandTerminator= "\x0A";
+}
 }
 
 /*:1011*/

src/scales.w

 	public slots:
 		void tare();
 		void weigh();
+		void setWeighCommand(const QString &command);
+		void setCommandTerminator(const QString &terminator);
 	signals:
 		void newMeasurement(double weight, Units::Unit unit);
 	private slots:
 		void dataAvailable();
 	private:
 		QByteArray responseBuffer;
+		QByteArray weighCommand;
+		QByteArray commandTerminator;
 };
 
 #endif
 }
 double weight = responseParts[0].toDouble();
 Units::Unit unit = Units::Unitless;
-if(responseParts[1] == "lb")
+if(responseParts[1].compare("lb", Qt::CaseInsensitive) == 0)
 {
 	unit = Units::Pound;
 }
-else if(responseParts[1] == "kg")
+else if(responseParts[1].compare("kg", Qt::CaseInsensitive) == 0)
 {
 	unit = Units::Kilogram;
 }
-else if(responseParts[1] == "g")
+else if(responseParts[1].compare("g", Qt::CaseInsensitive) == 0)
 {
 	unit = Units::Gram;
 }
-else if(responseParts[1] == "oz")
+else if(responseParts[1].compare("oz", Qt::CaseInsensitive) == 0)
 {
 	unit = Units::Ounce;
 }
 
 void SerialScale::weigh()
 {
-	write("!KP\x0D");
+	//write("!KP\x0D");
+	write(weighCommand + commandTerminator);
+}
+
+void SerialScale::setWeighCommand(const QString &command)
+{
+	weighCommand = command.toAscii();
+}
+
+void SerialScale::setCommandTerminator(const QString &terminator)
+{
+	if(terminator == "CRLF")
+	{
+		commandTerminator = "\x0D\x0A";
+	}
+	else if(terminator == "CR")
+	{
+		commandTerminator = "\x0D";
+	}
+	else if(terminator == "LF")
+	{
+		commandTerminator = "\x0A";
+	}
 }
 
 @ This must be available to the host environment.
 		void updateParity(int index);
 		void updateFlowControl(int index);
 		void updateStopBits(int index);
+		void updateWeighCommand(const QString &command);
+		void updateCommandTerminator(const QString &terminator);
 	private:
 		PortSelector *port;
 		BaudSelector *baud;
 		ParitySelector *parity;
 		FlowSelector *flow;
 		StopSelector *stop;
+		QLineEdit *weighcommand;
+		QComboBox *commandterminator;
 };
 
 @ This is very similar to other configuration widgets.
                                              const QModelIndex &index)
 : BasicDeviceConfigurationWidget(model, index),
   port(new PortSelector), baud(new BaudSelector), parity(new ParitySelector),
-  flow(new FlowSelector), stop(new StopSelector)
+  flow(new FlowSelector), stop(new StopSelector),
+  weighcommand(new QLineEdit("!KP")), commandterminator(new QComboBox)
 {
 	QFormLayout *layout = new QFormLayout;
 	layout->addRow(tr("Port:"), port);
 	layout->addRow(tr("Stop Bits:"), stop);
 	connect(stop, SIGNAL(currentIndexChanged(int)),
 	        this, SLOT(updateStopBits(int)));
+	layout->addRow(tr("Weigh Command:"), weighcommand);
+	connect(weighcommand, SIGNAL(textChanged(QString)),
+	        this, SLOT(updateWeighCommand(QString)));
+	commandterminator->addItem("CRLF");
+	commandterminator->addItem("CR");
+	commandterminator->addItem("LF");
+	layout->addRow(tr("Command Terminator:"), commandterminator);
+	connect(commandterminator, SIGNAL(currentIndexChanged(QString)),
+	        this, SLOT(updateCommandTerminator(QString)));
+	
 	@<Get device configuration data for current node@>@;
 	for(int i = 0; i < configData.size(); i++)
 	{
 		{
 			stop->setCurrentIndex(stop->findData(node.attribute("value")));
 		}
+		else if(node.attribute("name") == "weighcommand")
+		{
+			weighcommand->setText(node.attribute("value"));
+		}
+		else if(node.attribute("name") == "commandterminator")
+		{
+			commandterminator->setCurrentIndex(
+				commandterminator->findText(node.attribute("value")));
+		}
 	}
 	updatePort(port->currentText());
 	updateBaudRate(baud->currentText());
 	updateParity(parity->currentIndex());
 	updateFlowControl(flow->currentIndex());
 	updateStopBits(stop->currentIndex());
+	updateWeighCommand(weighcommand->text());
+	updateCommandTerminator(commandterminator->currentText());
 	setLayout(layout);
 }
 
 	updateAttribute("stopbits", stop->itemData(index).toString());
 }
 
+void SerialScaleConfWidget::updateWeighCommand(const QString &command)
+{
+	updateAttribute("weighcommand", command);
+}
+
+void SerialScaleConfWidget::updateCommandTerminator(const QString &terminator)
+{
+	updateAttribute("commandterminator", terminator);
+}
+
 @ The configuration widget is registered with the configuration system.
 
 @<Register device configuration widgets@>=