diff --git a/fronius/froniusinverter.cpp b/fronius/froniusinverter.cpp
index 46aef31..3f43aed 100644
--- a/fronius/froniusinverter.cpp
+++ b/fronius/froniusinverter.cpp
@@ -56,7 +56,7 @@ QUrl FroniusInverter::updateUrl()
     requestUrl.setHost(hostAddress());
     requestUrl.setPath(baseUrl() + "GetInverterRealtimeData.cgi");
     query.addQueryItem("Scope", "Device");
-    query.addQueryItem("DeviceId", thingId());
+    query.addQueryItem("DeviceId", deviceId());
     query.addQueryItem("DataCollection", "CommonInverterData");
     requestUrl.setQuery(query);
 
diff --git a/fronius/froniusmeter.cpp b/fronius/froniusmeter.cpp
index 1e35ef3..c87520f 100644
--- a/fronius/froniusmeter.cpp
+++ b/fronius/froniusmeter.cpp
@@ -57,7 +57,7 @@ QUrl FroniusMeter::updateUrl()
     requestUrl.setHost(hostAddress());
     requestUrl.setPath(baseUrl() + "GetMeterRealtimeData.cgi");
     query.addQueryItem("Scope", "Device");
-    query.addQueryItem("DeviceId", thingId());
+    query.addQueryItem("DeviceId", deviceId());
     requestUrl.setQuery(query);
     return requestUrl;
 }
diff --git a/fronius/froniusstorage.cpp b/fronius/froniusstorage.cpp
index 3d55688..1567a46 100644
--- a/fronius/froniusstorage.cpp
+++ b/fronius/froniusstorage.cpp
@@ -66,7 +66,7 @@ QUrl FroniusStorage::updateUrl()
     requestUrl.setHost(hostAddress());
     requestUrl.setPath(baseUrl() + "GetStorageRealtimeData.cgi");
     query.addQueryItem("Scope", "Device");
-    query.addQueryItem("DeviceId", thingId());
+    query.addQueryItem("DeviceId", deviceId());
     requestUrl.setQuery(query);
 
     return requestUrl;
diff --git a/fronius/froniusthing.cpp b/fronius/froniusthing.cpp
index fbfe087..af3903c 100644
--- a/fronius/froniusthing.cpp
+++ b/fronius/froniusthing.cpp
@@ -1,22 +1,32 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- *                                                                         *
- *  Copyright (C) 2016 Christian Stachowitz                                *
- *                                                                         *
- *  This file is part of guh.                                              *
- *                                                                         *
- *  Guh is free software: you can redistribute it and/or modify            *
- *  it under the terms of the GNU General Public License as published by   *
- *  the Free Software Foundation, version 2 of the License.                *
- *                                                                         *
- *  Guh is distributed in the hope that it will be useful,                 *
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the           *
- *  GNU General Public License for more details.                           *
- *                                                                         *
- *  You should have received a copy of the GNU General Public License      *
- *  along with guh. If not, see <http://www.gnu.org/licenses/>.            *
- *                                                                         *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+*
+* Copyright 2013 - 2020, nymea GmbH
+* Contact: contact@nymea.io
+*
+* This file is part of nymea.
+* This project including source code and documentation is protected by
+* copyright law, and remains the property of nymea GmbH. All rights, including
+* reproduction, publication, editing and translation, are reserved. The use of
+* this project is subject to the terms of a license agreement to be concluded
+* with nymea GmbH in accordance with the terms of use of nymea GmbH, available
+* under https://nymea.io/license
+*
+* GNU Lesser General Public License Usage
+* Alternatively, this project may be redistributed and/or modified under the
+* terms of the GNU Lesser General Public License as published by the Free
+* Software Foundation; version 3. This project is distributed in the hope that
+* it will be useful, but WITHOUT ANY WARRANTY; without even the implied
+* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public License
+* along with this project. If not, see <https://www.gnu.org/licenses/>.
+*
+* For any further details and any questions please contact us under
+* contact@nymea.io or see our FAQ/Licensing Information on
+* https://nymea.io/license/faq
+*
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include "froniusthing.h"
 
@@ -76,12 +86,12 @@ void FroniusThing::setUniqueId(const QString &uniqueId)
     m_uniqueId = uniqueId;
 }
 
-QString FroniusThing::thingId() const
+QString FroniusThing::deviceId() const
 {
     return m_thingId;
 }
 
-void FroniusThing::setThingId(const QString &thingId)
+void FroniusThing::setDeviceId(const QString &thingId)
 {
     m_thingId = thingId;
 }
diff --git a/fronius/froniusthing.h b/fronius/froniusthing.h
index d277b07..9f7acbd 100644
--- a/fronius/froniusthing.h
+++ b/fronius/froniusthing.h
@@ -60,8 +60,8 @@ public:
     QString uniqueId() const;
     void setUniqueId(const QString &uniqueId);
 
-    QString thingId() const;
-    void setThingId(const QString &thingId);
+    QString deviceId() const;
+    void setDeviceId(const QString &deviceId);
 
     Thing* pluginThing() const;
 
diff --git a/fronius/integrationpluginfronius.cpp b/fronius/integrationpluginfronius.cpp
index a83f8b9..0c777c2 100644
--- a/fronius/integrationpluginfronius.cpp
+++ b/fronius/integrationpluginfronius.cpp
@@ -63,10 +63,14 @@ void IntegrationPluginFronius::setupThing(ThingSetupInfo *info)
         }
 
         // Perform a HTTP request on the given IPv4Address to find things
-        QUrl url(QString("http://%1/solar_api/GetAPIVersion.cgi").arg(thing->paramValue(dataloggerThingLoggerHostParamTypeId).toString()));
-        qCDebug(dcFronius()) << "Search at address" << url.toString();
+        QUrl requestUrl;
+        requestUrl.setScheme("http");
+        requestUrl.setHost(thing->paramValue(dataloggerThingLoggerHostParamTypeId).toString());
+        requestUrl.setPath("/solar_api/GetAPIVersion.cgi");
 
-        QNetworkReply *reply = hardwareManager()->networkManager()->get(QNetworkRequest(url));
+        qCDebug(dcFronius()) << "Search at address" << requestUrl.toString();
+
+        QNetworkReply *reply = hardwareManager()->networkManager()->get(QNetworkRequest(requestUrl));
         connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
         connect(reply, &QNetworkReply::finished, [this, info, thing, reply]() {
             QByteArray data = reply->readAll();
@@ -92,18 +96,14 @@ void IntegrationPluginFronius::setupThing(ThingSetupInfo *info)
             m_froniusLoggers.insert(newLogger, thing);
 
             info->finish(Thing::ThingErrorNoError);
-            // FIX ME: remove after testing
-            //searchNewThings(m_froniusLoggers.key(thing));
-            //updateThingStates(thing);
         });
         //Async Setup
     } else if (thing->thingClassId() == inverterThingClassId) {
 
         FroniusInverter *newInverter = new FroniusInverter(thing,this);
-        newInverter->setThingId(thing->paramValue(inverterThingIdParamTypeId).toString());
+        newInverter->setDeviceId(thing->paramValue(inverterThingIdParamTypeId).toString());
         newInverter->setName(thing->paramValue(inverterThingNameParamTypeId).toString());
         newInverter->setBaseUrl(thing->paramValue(inverterThingBaseParamTypeId).toString());
-        newInverter->setHostId(thing->paramValue(inverterThingHostIdParamTypeId).toString());
         newInverter->setHostAddress(thing->paramValue(inverterThingHostParamTypeId).toString());
 
         m_froniusInverters.insert(newInverter,thing);
@@ -141,9 +141,9 @@ void IntegrationPluginFronius::setupThing(ThingSetupInfo *info)
             // Check reply information
             QVariantMap dataMap = jsonDoc.toVariant().toMap().value("Body").toMap().value("Data").toMap();
             // check for thing id in reply
-            if (dataMap.contains(newInverter->thingId())) {
-                qCDebug(dcFronius()) << "Found Thing with unique:" << dataMap.value(newInverter->thingId()).toMap().value("UniqueID").toString();
-                newInverter->setUniqueId(dataMap.value(newInverter->thingId()).toMap().value("UniqueID").toString());
+            if (dataMap.contains(newInverter->deviceId())) {
+                qCDebug(dcFronius()) << "Found Thing with unique:" << dataMap.value(newInverter->deviceId()).toMap().value("UniqueID").toString();
+                newInverter->setUniqueId(dataMap.value(newInverter->deviceId()).toMap().value("UniqueID").toString());
                 newInverter->pluginThing()->setParamValue(inverterThingUniqueIdParamTypeId,newInverter->uniqueId());
                 qCDebug(dcFronius()) << "Stored unique ID:" << newInverter->uniqueId();
             }
@@ -153,10 +153,9 @@ void IntegrationPluginFronius::setupThing(ThingSetupInfo *info)
     } else if (thing->thingClassId() == storageThingClassId) {
 
         FroniusStorage *newStorage = new FroniusStorage(thing, this);
-        newStorage->setThingId(thing->paramValue(storageThingIdParamTypeId).toString());
+        newStorage->setDeviceId(thing->paramValue(storageThingIdParamTypeId).toString());
         newStorage->setName(thing->paramValue(storageThingNameParamTypeId).toString());
         newStorage->setBaseUrl(thing->paramValue(storageThingBaseParamTypeId).toString());
-        newStorage->setHostId(thing->paramValue(storageThingHostIdParamTypeId).toString());
         newStorage->setHostAddress(thing->paramValue(storageThingHostParamTypeId).toString());
 
         m_froniusStorages.insert(newStorage,thing);
@@ -170,8 +169,8 @@ void IntegrationPluginFronius::setupThing(ThingSetupInfo *info)
         requestUrl.setScheme("http");
         requestUrl.setHost(newStorage->hostAddress());
         requestUrl.setPath(newStorage->baseUrl() + "GetStorageRealtimeData.cgi");
-        query.addQueryItem("Scope","Thing");
-        query.addQueryItem("ThingId",newStorage->thingId());
+        query.addQueryItem("Scope","Device");
+        query.addQueryItem("DeviceId", newStorage->deviceId());
         requestUrl.setQuery(query);
         qCDebug(dcFronius()) << "Get Storage Data at address" << requestUrl.toString();
         QNetworkReply *reply = hardwareManager()->networkManager()->get(QNetworkRequest(requestUrl));
@@ -205,10 +204,9 @@ void IntegrationPluginFronius::setupThing(ThingSetupInfo *info)
     } else if (thing->thingClassId() == meterThingClassId) {
 
         FroniusMeter *newMeter = new FroniusMeter(thing, this);;
-        newMeter->setThingId(thing->paramValue(meterThingIdParamTypeId).toString());
+        newMeter->setDeviceId(thing->paramValue(meterThingIdParamTypeId).toString());
         newMeter->setName(thing->paramValue(meterThingNameParamTypeId).toString());
         newMeter->setBaseUrl(thing->paramValue(meterThingBaseParamTypeId).toString());
-        newMeter->setHostId(thing->paramValue(meterThingHostIdParamTypeId).toString());
         newMeter->setHostAddress(thing->paramValue(meterThingHostParamTypeId).toString());
 
         m_froniusMeters.insert(newMeter,thing);
@@ -227,31 +225,30 @@ void IntegrationPluginFronius::setupThing(ThingSetupInfo *info)
     }
 }
 
-void IntegrationPluginFronius::init()
-{
-    m_pluginTimer = hardwareManager()->pluginTimerManager()->registerTimer(30);
-    connect(m_pluginTimer, &PluginTimer::timeout, this, [this]() {
-        foreach (Thing *logger, m_froniusLoggers)
-            updateThingStates(logger);
-
-        foreach (Thing *inverter, m_froniusInverters)
-            updateThingStates(inverter);
-
-        foreach (Thing *meter, m_froniusMeters)
-            updateThingStates(meter);
-
-        foreach (Thing *storage, m_froniusStorages)
-            updateThingStates(storage);
-
-        foreach (SunspecThing *sunspecThing, m_sunspecThings.keys())
-            sunspecThing->update();
-    });
-}
-
 void IntegrationPluginFronius::postSetupThing(Thing *thing)
 {
     qCDebug(dcFronius()) << "Post setup" << thing->name();
 
+    if (!m_pluginTimer) {
+        m_pluginTimer = hardwareManager()->pluginTimerManager()->registerTimer(30);
+        connect(m_pluginTimer, &PluginTimer::timeout, this, [this]() {
+            foreach (Thing *logger, m_froniusLoggers)
+                updateThingStates(logger);
+
+            foreach (Thing *inverter, m_froniusInverters)
+                updateThingStates(inverter);
+
+            foreach (Thing *meter, m_froniusMeters)
+                updateThingStates(meter);
+
+            foreach (Thing *storage, m_froniusStorages)
+                updateThingStates(storage);
+
+            foreach (SunspecThing *sunspecThing, m_sunspecThings.keys())
+                sunspecThing->update();
+        });
+    }
+
     if (thing->thingClassId() == dataloggerThingClassId) {
         searchNewThings(m_froniusLoggers.key(thing));
         updateThingStates(thing);
@@ -271,9 +268,6 @@ void IntegrationPluginFronius::postSetupThing(Thing *thing)
 
 void IntegrationPluginFronius::thingRemoved(Thing *thing)
 {
-    // Remove things
-
-    // Data Logger
     if (thing->thingClassId() == dataloggerThingClassId) {
         FroniusLogger *logger = m_froniusLoggers.key(thing);
         m_froniusLoggers.remove(logger);
@@ -500,26 +494,27 @@ void IntegrationPluginFronius::updateThingStates(Thing *thing)
 void IntegrationPluginFronius::searchNewThings(FroniusLogger *logger)
 {
     QUrl url; QUrlQuery query;
-    query.addQueryItem("ThingClass", "System");
+    query.addQueryItem("DeviceClass", "System");
     url.setScheme("http");
     url.setHost(logger->hostAddress());
-    url.setPath(logger->baseUrl() + "GetActiveThingInfo.cgi");
+    url.setPath(logger->baseUrl() + "GetActiveDeviceInfo.cgi");
     url.setQuery(query);
 
     qCDebug(dcFronius()) << "Search Things at address" << url.toString();
+    QNetworkRequest request = QNetworkRequest(url);
+    request.setHeader(QNetworkRequest::KnownHeaders::ContentTypeHeader, "application/json");
 
-    QNetworkReply *reply = hardwareManager()->networkManager()->get(QNetworkRequest(url));
+    QNetworkReply *reply = hardwareManager()->networkManager()->get(request);
+    connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
     connect(reply, &QNetworkReply::finished, [this, logger, reply]() {
 
-        reply->deleteLater();
-
         if (reply->error() != QNetworkReply::NoError) {
             qCWarning(dcFronius()) << "Network request error:" << reply->error() << reply->errorString();
             return;
         }
 
-        Thing *thing = m_froniusLoggers.value(logger);
-        if (!thing)
+        Thing *loggerThing = m_froniusLoggers.value(logger);
+        if (!loggerThing)
             return;
 
         QByteArray data = reply->readAll();
@@ -543,68 +538,52 @@ void IntegrationPluginFronius::searchNewThings(FroniusLogger *logger)
         foreach (QString inverterId, inverterMap.keys()) {
             //check if thing already connected to logger
             if(!existingThing(inverterThingIdParamTypeId,inverterId)) {
-                QString thingName = thing->name() + " Inverter " + inverterId;
-                ThingDescriptor descriptor(inverterThingClassId, thingName, "Fronius Solar Inverter");
+                QString thingName = loggerThing->name() + " Inverter " + inverterId;
+                ThingDescriptor descriptor(inverterThingClassId, thingName, "Fronius Solar Inverter", loggerThing->id());
                 ParamList params;
                 params.append(Param(inverterThingNameParamTypeId, thingName));
-                params.append(Param(inverterThingHostParamTypeId, m_froniusLoggers.key(thing)->hostAddress()));
-                params.append(Param(inverterThingBaseParamTypeId, m_froniusLoggers.key(thing)->baseUrl()));
+                params.append(Param(inverterThingHostParamTypeId, m_froniusLoggers.key(loggerThing)->hostAddress()));
+                params.append(Param(inverterThingBaseParamTypeId, m_froniusLoggers.key(loggerThing)->baseUrl()));
                 params.append(Param(inverterThingIdParamTypeId, inverterId));
                 params.append(Param(inverterThingUniqueIdParamTypeId, ""));
-                params.append(Param(inverterThingHostIdParamTypeId, thing->id()));
                 descriptor.setParams(params);
                 thingDescriptors.append(descriptor);
             }
         }
 
-        if (!thingDescriptors.empty()) {
-            emit autoThingsAppeared(thingDescriptors);
-            thingDescriptors.clear();
-        }
-
         // parse reply for meter things at the host address
         QVariantMap meterMap = bodyMap.value("Data").toMap().value("Meter").toMap();
         foreach (QString meterId, meterMap.keys()) {
             //check if thing already connected to logger
-            if(!existingThing(meterThingIdParamTypeId,meterId)) {
-                QString thingName = thing->name() + " Meter " + meterId;
-                ThingDescriptor descriptor(meterThingClassId, thingName, "Fronius Solar Meter");
+            if(!existingThing(meterThingIdParamTypeId, meterId)) {
+                QString thingName = loggerThing->name() + " Meter " + meterId;
+                ThingDescriptor descriptor(meterThingClassId, thingName, "Fronius Solar Meter", loggerThing->id());
                 ParamList params;
                 params.append(Param(meterThingNameParamTypeId, thingName));
-                //params.append(Param(meterThingManufParamTypeId, ""));
-                //params.append(Param(meterThingCapacityParamTypeId, ""));
-                params.append(Param(meterThingHostParamTypeId, m_froniusLoggers.key(thing)->hostAddress()));
-                params.append(Param(meterThingBaseParamTypeId, m_froniusLoggers.key(thing)->baseUrl()));
+                params.append(Param(meterThingHostParamTypeId, m_froniusLoggers.key(loggerThing)->hostAddress()));
+                params.append(Param(meterThingBaseParamTypeId, m_froniusLoggers.key(loggerThing)->baseUrl()));
                 params.append(Param(meterThingIdParamTypeId, meterId));
                 params.append(Param(meterThingUniqueIdParamTypeId, meterMap.value(meterId).toMap().value("Serial").toString()));
-                params.append(Param(meterThingHostIdParamTypeId, thing->id()));
                 descriptor.setParams(params);
                 thingDescriptors.append(descriptor);
             }
         }
 
-        if (!thingDescriptors.empty()) {
-            emit autoThingsAppeared(thingDescriptors);
-            thingDescriptors.clear();
-        }
-
-
         // parse reply for storage things at the host address
         QVariantMap storageMap = bodyMap.value("Data").toMap().value("Storage").toMap();
         foreach (QString storageId, storageMap.keys()) {
             //check if thing already connected to logger
             if(!existingThing(storageThingIdParamTypeId,storageId)) {
-                QString thingName = thing->name() + " Storage " + storageId;
-                ThingDescriptor descriptor(storageThingClassId, thingName, "Fronius Solar Storage");
+                QString thingName = loggerThing->name() + " Storage " + storageId;
+                ThingDescriptor descriptor(storageThingClassId, thingName, "Fronius Solar Storage", loggerThing->id());
                 ParamList params;
                 params.append(Param(storageThingNameParamTypeId, thingName));
                 params.append(Param(storageThingManufacturerParamTypeId, ""));
                 params.append(Param(storageThingCapacityParamTypeId, ""));
-                params.append(Param(storageThingHostParamTypeId, m_froniusLoggers.key(thing)->hostAddress()));
-                params.append(Param(storageThingBaseParamTypeId, m_froniusLoggers.key(thing)->baseUrl()));
+                params.append(Param(storageThingHostParamTypeId, m_froniusLoggers.key(loggerThing)->hostAddress()));
+                params.append(Param(storageThingBaseParamTypeId, m_froniusLoggers.key(loggerThing)->baseUrl()));
                 params.append(Param(storageThingIdParamTypeId, storageId));
                 params.append(Param(storageThingUniqueIdParamTypeId, storageMap.value(storageId).toMap().value("Serial").toString()));
-                params.append(Param(storageThingHostIdParamTypeId, thing->id()));
                 descriptor.setParams(params);
                 thingDescriptors.append(descriptor);
             }
@@ -614,9 +593,7 @@ void IntegrationPluginFronius::searchNewThings(FroniusLogger *logger)
             emit autoThingsAppeared(thingDescriptors);
             thingDescriptors.clear();
         }
-
     });
-
 }
 
 bool IntegrationPluginFronius::existingThing(ParamTypeId thingParamId, QString thingId)
diff --git a/fronius/integrationpluginfronius.h b/fronius/integrationpluginfronius.h
index 1b9cccc..0995219 100644
--- a/fronius/integrationpluginfronius.h
+++ b/fronius/integrationpluginfronius.h
@@ -51,14 +51,11 @@ class IntegrationPluginFronius : public IntegrationPlugin
 public:
     explicit IntegrationPluginFronius(QObject *parent = nullptr);
 
-    void init() override;
     void setupThing(ThingSetupInfo *thing) override;
     void postSetupThing(Thing* thing) override;
     void executeAction(ThingActionInfo *info) override;
     void thingRemoved(Thing* thing) override;
 
-    void startMonitoringAutoThings() override;
-
 private:
     PluginTimer *m_pluginTimer = nullptr;
 
diff --git a/fronius/integrationpluginfronius.json b/fronius/integrationpluginfronius.json
index d4b3854..3ed79b5 100644
--- a/fronius/integrationpluginfronius.json
+++ b/fronius/integrationpluginfronius.json
@@ -187,13 +187,6 @@
                             "displayName": "Uique id",
                             "type": "QString",
                             "inputType": "TextLine"
-                        },
-                        {
-                            "id": "e329ecd2-6893-432f-9f14-069593c996e9",
-                            "name": "hostId",
-                            "displayName": "host id",
-                            "type": "QString",
-                            "inputType": "TextLine"
                         }
                     ],
                     "stateTypes": [
@@ -292,13 +285,6 @@
                             "displayName": "uique id",
                             "type": "QString",
                             "inputType": "TextLine"
-                        },
-                        {
-                            "id": "b4b86bfc-598a-4b5c-9350-52b944556ccc",
-                            "name": "hostId",
-                            "displayName": "host id",
-                            "type": "QString",
-                            "inputType": "TextLine"
                         }
                     ],
                     "stateTypes": [
@@ -394,13 +380,6 @@
                             "displayName": "unique id",
                             "type": "QString",
                             "inputType": "TextLine"
-                        },
-                        {
-                            "id": "79daa7f4-2551-4b89-b34a-2d75d1441a55",
-                            "name": "hostId",
-                            "displayName": "Host ID",
-                            "type": "QString",
-                            "inputType": "TextLine"
                         }
                     ],
                     "stateTypes": [
diff --git a/modbus/modbusrtumaster.cpp b/modbus/modbusrtumaster.cpp
index b7b04b1..b3881e7 100644
--- a/modbus/modbusrtumaster.cpp
+++ b/modbus/modbusrtumaster.cpp
@@ -76,6 +76,16 @@ bool ModbusRTUMaster::connectDevice()
     return m_modbusRtuSerialMaster->connectDevice();
 }
 
+void ModbusRTUMaster::setNumberOfRetries(int number)
+{
+    m_modbusRtuSerialMaster->setNumberOfRetries(number);
+}
+
+void ModbusRTUMaster::setTimeout(int timeout)
+{
+    m_modbusRtuSerialMaster->setTimeout(timeout);
+}
+
 QString ModbusRTUMaster::serialPort()
 {
     return m_modbusRtuSerialMaster->connectionParameter(QModbusDevice::SerialPortNameParameter).toString();
@@ -88,14 +98,14 @@ void ModbusRTUMaster::onReconnectTimer()
     }
 }
 
-QUuid ModbusRTUMaster::readCoil(uint slaveAddress, uint registerAddress)
+QUuid ModbusRTUMaster::readCoil(uint slaveAddress, uint registerAddress, uint size)
 {
     if (!m_modbusRtuSerialMaster) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::Coils, registerAddress, 1);
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::Coils, registerAddress, size);
 
     if (QModbusReply *reply = m_modbusRtuSerialMaster->sendReadRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
@@ -106,7 +116,7 @@ QUuid ModbusRTUMaster::readCoil(uint slaveAddress, uint registerAddress)
                     requestExecuted(requestId, true);
                     const QModbusDataUnit unit = reply->result();
                     uint modbusAddress = unit.startAddress();
-                    emit receivedCoil(reply->serverAddress(), modbusAddress, unit.value(0));
+                    emit receivedCoil(reply->serverAddress(), modbusAddress, unit.values());
 
                 } else {
                     requestExecuted(requestId, false);
@@ -133,14 +143,20 @@ QUuid ModbusRTUMaster::readCoil(uint slaveAddress, uint registerAddress)
 }
 
 QUuid ModbusRTUMaster::writeCoil(uint slaveAddress, uint registerAddress, bool value)
+{
+    return writeCoils(slaveAddress, registerAddress, QVector<quint16>() << static_cast<quint16>(value));
+}
+
+
+QUuid ModbusRTUMaster::writeCoils(uint slaveAddress, uint registerAddress, const QVector<quint16> &values)
 {
     if (!m_modbusRtuSerialMaster) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::Coils, registerAddress, 1);
-    request.setValue(0, static_cast<uint16_t>(value));
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::Coils, registerAddress, values.length());
+    request.setValues(values);
 
     if (QModbusReply *reply = m_modbusRtuSerialMaster->sendWriteRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
@@ -151,7 +167,7 @@ QUuid ModbusRTUMaster::writeCoil(uint slaveAddress, uint registerAddress, bool v
                     requestExecuted(requestId, true);
                     const QModbusDataUnit unit = reply->result();
                     uint modbusAddress = unit.startAddress();
-                    emit receivedCoil(reply->serverAddress(), modbusAddress, unit.value(0));
+                    emit receivedCoil(reply->serverAddress(), modbusAddress, unit.values());
 
                 } else {
                     requestExecuted(requestId, false);
@@ -176,15 +192,20 @@ QUuid ModbusRTUMaster::writeCoil(uint slaveAddress, uint registerAddress, bool v
     return requestId;
 }
 
-QUuid ModbusRTUMaster::writeHoldingRegister(uint slaveAddress, uint registerAddress, uint value)
+QUuid ModbusRTUMaster::writeHoldingRegister(uint slaveAddress, uint registerAddress, quint16 value)
+{
+    return writeHoldingRegisters(slaveAddress, registerAddress, QVector<quint16>() << value);
+}
+
+QUuid ModbusRTUMaster::writeHoldingRegisters(uint slaveAddress, uint registerAddress, const QVector<quint16> &values)
 {
     if (!m_modbusRtuSerialMaster) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, registerAddress, 1);
-    request.setValue(0, static_cast<uint16_t>(value));
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, registerAddress, values.length());
+    request.setValues(values);
 
     if (QModbusReply *reply = m_modbusRtuSerialMaster->sendWriteRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
@@ -220,14 +241,14 @@ QUuid ModbusRTUMaster::writeHoldingRegister(uint slaveAddress, uint registerAddr
     return requestId;
 }
 
-QUuid ModbusRTUMaster::readDiscreteInput(uint slaveAddress, uint registerAddress)
+QUuid ModbusRTUMaster::readDiscreteInput(uint slaveAddress, uint registerAddress, uint size)
 {
     if (!m_modbusRtuSerialMaster) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::DiscreteInputs, registerAddress, 1);
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::DiscreteInputs, registerAddress, size);
 
     if (QModbusReply *reply = m_modbusRtuSerialMaster->sendReadRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
@@ -238,7 +259,7 @@ QUuid ModbusRTUMaster::readDiscreteInput(uint slaveAddress, uint registerAddress
                     requestExecuted(requestId, true);
                     const QModbusDataUnit unit = reply->result();
                     uint modbusAddress = unit.startAddress();
-                    emit receivedDiscreteInput(reply->serverAddress(), modbusAddress, unit.value(0));
+                    emit receivedDiscreteInput(reply->serverAddress(), modbusAddress, unit.values());
 
                 } else {
                     requestExecuted(requestId, false);
@@ -264,14 +285,14 @@ QUuid ModbusRTUMaster::readDiscreteInput(uint slaveAddress, uint registerAddress
     return requestId;
 }
 
-QUuid ModbusRTUMaster::readInputRegister(uint slaveAddress, uint registerAddress)
+QUuid ModbusRTUMaster::readInputRegister(uint slaveAddress, uint registerAddress, uint size)
 {
     if (!m_modbusRtuSerialMaster) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::InputRegisters, registerAddress, 1);
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::InputRegisters, registerAddress, size);
 
     if (QModbusReply *reply = m_modbusRtuSerialMaster->sendReadRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
@@ -283,7 +304,7 @@ QUuid ModbusRTUMaster::readInputRegister(uint slaveAddress, uint registerAddress
                     requestExecuted(requestId, true);
                     const QModbusDataUnit unit = reply->result();
                     uint modbusAddress = unit.startAddress();
-                    emit receivedInputRegister(reply->serverAddress(), modbusAddress, unit.value(0));
+                    emit receivedInputRegister(reply->serverAddress(), modbusAddress, unit.values());
 
                 } else {
                     requestExecuted(requestId, false);
@@ -309,14 +330,14 @@ QUuid ModbusRTUMaster::readInputRegister(uint slaveAddress, uint registerAddress
     return requestId;
 }
 
-QUuid ModbusRTUMaster::readHoldingRegister(uint slaveAddress, uint registerAddress)
+QUuid ModbusRTUMaster::readHoldingRegister(uint slaveAddress, uint registerAddress, uint size)
 {
     if (!m_modbusRtuSerialMaster) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, registerAddress, 1);
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::HoldingRegisters, registerAddress, size);
 
     if (QModbusReply *reply = m_modbusRtuSerialMaster->sendReadRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
diff --git a/modbus/modbusrtumaster.h b/modbus/modbusrtumaster.h
index 9218ac5..3a9b04c 100644
--- a/modbus/modbusrtumaster.h
+++ b/modbus/modbusrtumaster.h
@@ -45,14 +45,19 @@ public:
     ~ModbusRTUMaster();
 
     bool connectDevice();
+    void setNumberOfRetries(int number);
+    void setTimeout(int timeout);
 
-    QUuid readCoil(uint slaveAddress, uint registerAddress);
-    QUuid readDiscreteInput(uint slaveAddress, uint registerAddress);
-    QUuid readInputRegister(uint slaveAddress, uint registerAddress);
-    QUuid readHoldingRegister(uint slaveAddress, uint registerAddress);
+    QUuid readCoil(uint slaveAddress, uint registerAddress, uint size = 1);
+    QUuid readDiscreteInput(uint slaveAddress, uint registerAddress, uint size = 1);
+    QUuid readInputRegister(uint slaveAddress, uint registerAddress, uint size = 1);
+    QUuid readHoldingRegister(uint slaveAddress, uint registerAddress, uint size = 1);
 
     QUuid writeCoil(uint slaveAddress, uint registerAddress, bool status);
-    QUuid writeHoldingRegister(uint slaveAddress, uint registerAddress, uint data);
+    QUuid writeCoils(uint slaveAddress, uint registerAddress, const QVector<quint16> &values);
+
+    QUuid writeHoldingRegister(uint slaveAddress, uint registerAddress, quint16 value);
+    QUuid writeHoldingRegisters(uint slaveAddress, uint registerAddress, const QVector<quint16> &values);
 
     QString serialPort();
 
@@ -72,10 +77,10 @@ signals:
     void requestExecuted(QUuid requestId, bool success);
     void requestError(QUuid requestId, const QString &error);
 
-    void receivedCoil(uint slaveAddress, uint modbusRegister, bool value);
-    void receivedDiscreteInput(uint slaveAddress, uint modbusRegister, bool value);
+    void receivedCoil(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values);
+    void receivedDiscreteInput(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values);
     void receivedHoldingRegister(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values);
-    void receivedInputRegister(uint slaveAddress, uint modbusRegister, uint value);
+    void receivedInputRegister(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values);
 };
 
 #endif // MODBUSRTUMASTER_H
diff --git a/modbus/modbustcpmaster.cpp b/modbus/modbustcpmaster.cpp
index 7b92999..c7675e5 100644
--- a/modbus/modbustcpmaster.cpp
+++ b/modbus/modbustcpmaster.cpp
@@ -110,14 +110,14 @@ QHostAddress ModbusTCPMaster::hostAddress()
     return QHostAddress(m_modbusTcpClient->connectionParameter(QModbusDevice::NetworkAddressParameter).toString());
 }
 
-QUuid ModbusTCPMaster::readCoil(uint slaveAddress, uint registerAddress)
+QUuid ModbusTCPMaster::readCoil(uint slaveAddress, uint registerAddress, uint size)
 {
     if (!m_modbusTcpClient) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::Coils, registerAddress, 1);
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::Coils, registerAddress, size);
 
     if (QModbusReply *reply = m_modbusTcpClient->sendReadRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
@@ -128,7 +128,7 @@ QUuid ModbusTCPMaster::readCoil(uint slaveAddress, uint registerAddress)
                     writeRequestExecuted(requestId, true);
                     const QModbusDataUnit unit = reply->result();
                     uint modbusAddress = unit.startAddress();
-                    emit receivedCoil(reply->serverAddress(), modbusAddress, unit.value(0));
+                    emit receivedCoil(reply->serverAddress(), modbusAddress, unit.values());
 
                 } else {
                     writeRequestExecuted(requestId, false);
@@ -197,14 +197,14 @@ QUuid ModbusTCPMaster::writeHoldingRegisters(uint slaveAddress, uint registerAdd
     return requestId;
 }
 
-QUuid ModbusTCPMaster::readDiscreteInput(uint slaveAddress, uint registerAddress)
+QUuid ModbusTCPMaster::readDiscreteInput(uint slaveAddress, uint registerAddress, uint size)
 {
     if (!m_modbusTcpClient) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::DiscreteInputs, registerAddress, 1);
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::DiscreteInputs, registerAddress, size);
 
     if (QModbusReply *reply = m_modbusTcpClient->sendReadRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
@@ -215,7 +215,7 @@ QUuid ModbusTCPMaster::readDiscreteInput(uint slaveAddress, uint registerAddress
                     writeRequestExecuted(requestId, true);
                     const QModbusDataUnit unit = reply->result();
                     uint modbusAddress = unit.startAddress();
-                    emit receivedDiscreteInput(reply->serverAddress(), modbusAddress, unit.value(0));
+                    emit receivedDiscreteInput(reply->serverAddress(), modbusAddress, unit.values());
 
                 } else {
                     writeRequestExecuted(requestId, false);
@@ -241,14 +241,14 @@ QUuid ModbusTCPMaster::readDiscreteInput(uint slaveAddress, uint registerAddress
     return requestId;
 }
 
-QUuid ModbusTCPMaster::readInputRegister(uint slaveAddress, uint registerAddress)
+QUuid ModbusTCPMaster::readInputRegister(uint slaveAddress, uint registerAddress, uint size)
 {
     if (!m_modbusTcpClient) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::InputRegisters, registerAddress, 1);
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::InputRegisters, registerAddress, size);
 
     if (QModbusReply *reply = m_modbusTcpClient->sendReadRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
@@ -259,7 +259,7 @@ QUuid ModbusTCPMaster::readInputRegister(uint slaveAddress, uint registerAddress
                     writeRequestExecuted(requestId, true);
                     const QModbusDataUnit unit = reply->result();
                     uint modbusAddress = unit.startAddress();
-                    emit receivedInputRegister(reply->serverAddress(), modbusAddress, unit.value(0));
+                    emit receivedInputRegister(reply->serverAddress(), modbusAddress, unit.values());
 
                 } else {
                     writeRequestExecuted(requestId, false);
@@ -330,13 +330,18 @@ QUuid ModbusTCPMaster::readHoldingRegister(uint slaveAddress, uint registerAddre
 
 QUuid ModbusTCPMaster::writeCoil(uint slaveAddress, uint registerAddress, bool value)
 {
+    return writeCoils(slaveAddress, registerAddress, QVector<quint16>() << static_cast<quint16>(value));
+}
+
+QUuid ModbusTCPMaster::writeCoils(uint slaveAddress, uint registerAddress, const QVector<quint16> &values)
+    {
     if (!m_modbusTcpClient) {
         return "";
     }
     QUuid requestId = QUuid::createUuid();
 
-    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::Coils, registerAddress, 1);
-    request.setValue(0, static_cast<uint16_t>(value));
+    QModbusDataUnit request = QModbusDataUnit(QModbusDataUnit::RegisterType::Coils, registerAddress, values.length());
+    request.setValues(values);
 
     if (QModbusReply *reply = m_modbusTcpClient->sendWriteRequest(request, slaveAddress)) {
         if (!reply->isFinished()) {
@@ -347,7 +352,7 @@ QUuid ModbusTCPMaster::writeCoil(uint slaveAddress, uint registerAddress, bool v
                     writeRequestExecuted(requestId, true);
                     const QModbusDataUnit unit = reply->result();
                     uint modbusAddress = unit.startAddress();
-                    emit receivedCoil(reply->serverAddress(), modbusAddress, unit.value(0));
+                    emit receivedCoil(reply->serverAddress(), modbusAddress, unit.values());
 
                 } else {
                     writeRequestExecuted(requestId, false);
diff --git a/modbus/modbustcpmaster.h b/modbus/modbustcpmaster.h
index c0312ee..0166c88 100644
--- a/modbus/modbustcpmaster.h
+++ b/modbus/modbustcpmaster.h
@@ -48,12 +48,13 @@ public:
     void setNumberOfRetries(int number);
     void setTimeout(int timeout);
 
-    QUuid readCoil(uint slaveAddress, uint registerAddress);
-    QUuid readDiscreteInput(uint slaveAddress, uint registerAddress);
-    QUuid readInputRegister(uint slaveAddress, uint registerAddress);
+    QUuid readCoil(uint slaveAddress, uint registerAddress, uint size = 1);
+    QUuid readDiscreteInput(uint slaveAddress, uint registerAddress, uint size = 1);
+    QUuid readInputRegister(uint slaveAddress, uint registerAddress, uint size = 1);
     QUuid readHoldingRegister(uint slaveAddress, uint registerAddress, uint size = 1);
 
     QUuid writeCoil(uint slaveAddress, uint registerAddress, bool status);
+    QUuid writeCoils(uint slaveAddress, uint registerAddress, const QVector<quint16> &values);
 
     QUuid writeHoldingRegister(uint slaveAddress, uint registerAddress, quint16 value);
     QUuid writeHoldingRegisters(uint slaveAddress, uint registerAddress, const QVector<quint16> &values);
@@ -63,7 +64,6 @@ public:
     bool setHostAddress(const QHostAddress &hostAddress);
     bool setPort(uint port);
 
-
 private:
     QTimer *m_reconnectTimer = nullptr;
     QModbusTcpClient *m_modbusTcpClient;
@@ -80,10 +80,10 @@ signals:
     void writeRequestExecuted(const QUuid &requestId, bool success);
     void writeRequestError(const QUuid &requestId, const QString &error);
 
-    void receivedCoil(uint slaveAddress, uint modbusRegister, bool value);
-    void receivedDiscreteInput(uint slaveAddress, uint modbusRegister, bool value);
+    void receivedCoil(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values);
+    void receivedDiscreteInput(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values);
     void receivedHoldingRegister(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values);
-    void receivedInputRegister(uint slaveAddress, uint modbusRegister, uint value);
+    void receivedInputRegister(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values);
 };
 
 #endif // MODBUSTCPMASTER_H
diff --git a/modbuscommander/integrationpluginmodbuscommander.cpp b/modbuscommander/integrationpluginmodbuscommander.cpp
index fffca4b..847ea42 100644
--- a/modbuscommander/integrationpluginmodbuscommander.cpp
+++ b/modbuscommander/integrationpluginmodbuscommander.cpp
@@ -358,7 +358,7 @@ void IntegrationPluginModbusCommander::onRequestError(QUuid requestId, const QSt
     }
 }
 
-void IntegrationPluginModbusCommander::onReceivedCoil(quint32 slaveAddress, quint32 modbusRegister, bool value)
+void IntegrationPluginModbusCommander::onReceivedCoil(quint32 slaveAddress, quint32 modbusRegister, const QVector<quint16> &values)
 {
     auto modbus = sender();
 
@@ -368,7 +368,7 @@ void IntegrationPluginModbusCommander::onReceivedCoil(quint32 slaveAddress, quin
             if (thing->thingClassId() == coilThingClassId) {
                 if ((thing->paramValue(m_slaveAddressParamTypeId.value(thing->thingClassId())) == slaveAddress)
                         && (thing->paramValue(m_registerAddressParamTypeId.value(thing->thingClassId())) == modbusRegister)) {
-                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), value);
+                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), values[0]);
                     thing->setStateValue(m_connectedStateTypeId.value(thing->thingClassId()), true);
                     return;
                 }
@@ -380,7 +380,7 @@ void IntegrationPluginModbusCommander::onReceivedCoil(quint32 slaveAddress, quin
             if (thing->thingClassId() == coilThingClassId) {
                 if ((thing->paramValue(m_slaveAddressParamTypeId.value(thing->thingClassId())) == slaveAddress)
                         && (thing->paramValue(m_registerAddressParamTypeId.value(thing->thingClassId())) == modbusRegister)) {
-                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), value);
+                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), values[0]);
                     thing->setStateValue(m_connectedStateTypeId.value(thing->thingClassId()), true);
                     return;
                 }
@@ -389,7 +389,7 @@ void IntegrationPluginModbusCommander::onReceivedCoil(quint32 slaveAddress, quin
     }
 }
 
-void IntegrationPluginModbusCommander::onReceivedDiscreteInput(quint32 slaveAddress, quint32 modbusRegister, bool value)
+void IntegrationPluginModbusCommander::onReceivedDiscreteInput(quint32 slaveAddress, quint32 modbusRegister, const QVector<quint16> &values)
 {
     auto modbus = sender();
 
@@ -399,7 +399,7 @@ void IntegrationPluginModbusCommander::onReceivedDiscreteInput(quint32 slaveAddr
             if (thing->thingClassId() == discreteInputThingClassId) {
                 if ((thing->paramValue(m_slaveAddressParamTypeId.value(thing->thingClassId())) == slaveAddress)
                         && (thing->paramValue(m_registerAddressParamTypeId.value(thing->thingClassId())) == modbusRegister)) {
-                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), value);
+                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), values[0]);
                     thing->setStateValue(m_connectedStateTypeId.value(thing->thingClassId()), true);
                     return;
                 }
@@ -411,7 +411,7 @@ void IntegrationPluginModbusCommander::onReceivedDiscreteInput(quint32 slaveAddr
             if (thing->thingClassId() == discreteInputThingClassId) {
                 if ((thing->paramValue(m_slaveAddressParamTypeId.value(thing->thingClassId())) == slaveAddress)
                         && (thing->paramValue(m_registerAddressParamTypeId.value(thing->thingClassId())) == modbusRegister)) {
-                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), value);
+                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), values[0]);
                     thing->setStateValue(m_connectedStateTypeId.value(thing->thingClassId()), true);
                     return;
                 }
@@ -451,7 +451,7 @@ void IntegrationPluginModbusCommander::onReceivedHoldingRegister(uint slaveAddre
     }
 }
 
-void IntegrationPluginModbusCommander::onReceivedInputRegister(uint slaveAddress, uint modbusRegister, int value)
+void IntegrationPluginModbusCommander::onReceivedInputRegister(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values)
 {
     auto modbus = sender();
 
@@ -461,7 +461,7 @@ void IntegrationPluginModbusCommander::onReceivedInputRegister(uint slaveAddress
             if (thing->thingClassId() == inputRegisterThingClassId) {
                 if ((thing->paramValue(m_slaveAddressParamTypeId.value(thing->thingClassId())) == slaveAddress)
                         && (thing->paramValue(m_registerAddressParamTypeId.value(thing->thingClassId())) == modbusRegister)) {
-                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), value);
+                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), values[0]);
                     thing->setStateValue(m_connectedStateTypeId.value(thing->thingClassId()), true);
                     return;
                 }
@@ -473,7 +473,7 @@ void IntegrationPluginModbusCommander::onReceivedInputRegister(uint slaveAddress
             if (thing->thingClassId() == inputRegisterThingClassId) {
                 if ((thing->paramValue(m_slaveAddressParamTypeId.value(thing->thingClassId())) == slaveAddress)
                         && (thing->paramValue(m_registerAddressParamTypeId.value(thing->thingClassId())) == modbusRegister)) {
-                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), value);
+                    thing->setStateValue(m_valueStateTypeId.value(thing->thingClassId()), values[0]);
                     thing->setStateValue(m_connectedStateTypeId.value(thing->thingClassId()), true);
                     return;
                 }
diff --git a/modbuscommander/integrationpluginmodbuscommander.h b/modbuscommander/integrationpluginmodbuscommander.h
index 45b393e..7fed22f 100644
--- a/modbuscommander/integrationpluginmodbuscommander.h
+++ b/modbuscommander/integrationpluginmodbuscommander.h
@@ -84,10 +84,11 @@ private slots:
     void onConnectionStateChanged(bool status);
     void onRequestExecuted(QUuid requestId, bool success);
     void onRequestError(QUuid requestId, const QString &error);
-    void onReceivedCoil(quint32 slaveAddress, quint32 modbusRegister, bool value);
-    void onReceivedDiscreteInput(quint32 slaveAddress, quint32 modbusRegister, bool value);
+
+    void onReceivedCoil(quint32 slaveAddress, quint32 modbusRegister, const QVector<quint16> &values);
+    void onReceivedDiscreteInput(quint32 slaveAddress, quint32 modbusRegister, const QVector<quint16> &values);
     void onReceivedHoldingRegister(uint slaveAddress, uint modbusRegister, const QVector<quint16> &values);
-    void onReceivedInputRegister(quint32 slaveAddress, quint32 modbusRegister, int value);
+    void onReceivedInputRegister(quint32 slaveAddress, quint32 modbusRegister, const QVector<quint16> &values);
 };
 
 #endif // INTEGRATIONPLUGINMODBUSCOMMANDER_H