Correct script running with device id

Author: sanny32

omodsim/controls/scriptcontrol.ui

@@ -47,8 +47,10 @@
        </property>
        <property name="plainText">
         <string>Script.onInit(()=&gt;{
+	let deviceId = 1;
+	let address = 1;
 	Server.addressBase = AddressBase.Base1;
-	Server.onChange(1/* deviceId */, Register.Holding, 1, (value)=&gt;
+	Server.onChange(deviceId, Register.Holding, address, (value)=&gt;
 	{
 		/* write your code on register value change */
 	});

omodsim/jsobjects/server.cpp

@@ -30,6 +30,7 @@ Server::Server(ModbusMultiServer* server, const ByteOrder* order, AddressBase ba
     Q_ASSERT(_mbMultiServer != nullptr);
 
     connect(_mbMultiServer, &ModbusMultiServer::dataChanged, this, &Server::on_dataChanged);
+    connect(_mbMultiServer, &ModbusMultiServer::errorOccured, this, &Server::on_errorOccured);
 }
 
 ///
@@ -367,6 +368,19 @@ void Server::onChange(quint8 deviceId, Register::Type reg, quint16 address, cons
     _mapOnChange[{deviceId, reg, address}] = func;
 }
 
+///
+/// \brief Server::onError
+/// \param deviceId
+/// \param func
+///
+void Server::onError(quint8 deviceId, const QJSValue& func)
+{
+    if(!func.isCallable())
+        return;
+
+    _mapOnError[deviceId] = func;
+}
+
 ///
 /// \brief Server::on_dataChanged
 /// \param data
@@ -383,3 +397,16 @@ void Server::on_dataChanged(quint8 deviceId, const QModbusDataUnit& data)
         }
     }
 }
+
+///
+/// \brief Server::on_errorOccured
+/// \param deviceId
+/// \param error
+///
+void Server::on_errorOccured(quint8 deviceId, const QString& error)
+{
+    if(error.isEmpty())
+        return;
+
+    _mapOnError[deviceId].call(QJSValueList() << error);
+}

omodsim/jsobjects/server.h

@@ -80,12 +80,17 @@ class Server : public QObject
     Q_INVOKABLE void writeDouble(Register::Type reg, quint16 address, double value, bool swapped, quint8 deviceId = 1);
 
     Q_INVOKABLE void onChange(quint8 deviceId, Register::Type reg, quint16 address, const QJSValue& func);
+    Q_INVOKABLE void onError(quint8 deviceId, const QJSValue& func);
+
+signals:
+    void errorOccured(quint8 deviceId, const QString& error);
 
 public slots:
     void setAddressBase(Address::Base base);
     void setUseGlobalUnitMap(bool value);
 
 private slots:
+    void on_errorOccured(quint8 deviceId, const QString& error);
     void on_dataChanged(quint8 deviceId, const QModbusDataUnit& data);
 
 private:
@@ -101,6 +106,8 @@ private slots:
     Address::Base _addressBase;
     const ByteOrder* _byteOrder;
     ModbusMultiServer* _mbMultiServer;
+
+    QHash<int, QJSValue> _mapOnError;
     QHash<KeyOnChange, QJSValue> _mapOnChange;
 
     friend uint qHash(const KeyOnChange &key, uint seed);

omodsim/mainwindow.cpp

@@ -1501,6 +1501,15 @@ void MainWindow::loadSettings()
 
     QSettings m(filepath, QSettings::IniFormat, this);
 
+    const bool isMaximized = m.value("WindowMaximized").toBool();
+    if(isMaximized) {
+        showMaximized();
+    }
+    else {
+        const auto geometry = m.value("WindowGeometry", this->geometry()).toRect();
+        setGeometry(geometry);
+    }
+
     const auto displaybarArea = (Qt::ToolBarArea)qBound(0, m.value("DisplayBarArea", 0x4).toInt(), 0xf);
     const auto displaybarBreak = m.value("DisplayBarBreak").toBool();
     if(displaybarBreak) addToolBarBreak(displaybarArea);
@@ -1567,6 +1576,14 @@ void MainWindow::saveSettings()
     m.clear();
     m.sync();
 
+    if(isMaximized()) {
+        m.setValue("WindowMaximized", true);
+    }
+    else {
+        m.setValue("WindowMaximized", false);
+        m.setValue("WindowGeometry", geometry());
+    }
+
     m.setValue("DisplayBarArea", toolBarArea(ui->toolBarDisplay));
     m.setValue("DisplayBarBreak", toolBarBreak(ui->toolBarDisplay));
     m.setValue("ScriptBarArea", toolBarArea(ui->toolBarScript));

omodsim/modbusmultiserver.cpp

@@ -470,14 +470,28 @@ void ModbusMultiServer::setData(quint8 deviceId, const QModbusDataUnit& data)
         return;
     }
 
+    if(!_modbusDataUnitMaps.contains(deviceId)) {
+        emit errorOccured(deviceId, tr("An incorrect device id was specified (%1)").arg(deviceId));
+        return;
+    }
+
     _modbusDataUnitMaps[deviceId].setData(data);
+
+    QString error;
     for(auto&& s : _modbusServerList)
     {
         s->blockSignals(true);
-        s->setData(data, deviceId);
+
+        if(!s->setData(data, deviceId))
+            error = s->errorString(deviceId);
+
         s->blockSignals(false);
     }
-    emit dataChanged(deviceId, data);
+
+    if(error.isEmpty())
+        emit dataChanged(deviceId, data);
+    else
+        emit errorOccured(deviceId, error);
 }
 
 ///
@@ -929,14 +943,16 @@ void ModbusMultiServer::on_stateChanged(QModbusDevice::State state)
 ///
 void ModbusMultiServer::on_errorOccurred(QModbusDevice::Error error, int deviceId)
 {
-    if(error == QModbusDevice::ConnectionError)
-    {
-        auto server = qobject_cast<ModbusServer*>(sender());
-        const auto errorString = server->errorString(deviceId);
+    auto server = qobject_cast<ModbusServer*>(sender());
+    const auto errorString = server->errorString(deviceId);
 
+    if(error == QModbusDevice::ConnectionError) {
         server->disconnectDevice();
         emit connectionError(QString(tr("Connection error. %1")).arg(errorString));
     }
+    else {
+        emit errorOccured(deviceId, errorString);
+    }
 }
 
 ///

omodsim/modbusmultiserver.h

@@ -71,6 +71,7 @@ class ModbusMultiServer final : public QObject
     void request(quint8 deviceId, const QModbusRequest& req, ModbusMessage::ProtocolType protocol, int transactionId);
     void response(quint8 deviceId, const QModbusRequest& req, const QModbusResponse& resp, ModbusMessage::ProtocolType protocol, int transactionId);
     void connectionError(const QString& error);
+    void errorOccured(quint8 deviceId, const QString& error);
     void dataChanged(quint8 deviceId, const QModbusDataUnit& data);
 
 private slots: