ETM-Schurig
/
nymea-plugins-modbus
mirror of https://github.com/nymea/nymea-plugins-modbus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fixed Fronius plug-in

pull/1/head
Boernsman 2020-06-17 16:16:35 +02:00
parent 89df596427
commit 68e38a1eaf
14 changed files with 180 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
fronius/froniusinverter.cpp
View File

@ -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);

2
fronius/froniusmeter.cpp
View File

@ -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;
}

2
fronius/froniusstorage.cpp
View File

@ -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;

52
fronius/froniusthing.cpp
View File

@ -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;
}

4
fronius/froniusthing.h
View File

@ -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;

135
fronius/integrationpluginfronius.cpp
View File

@ -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)

3
fronius/integrationpluginfronius.h
View File

@ -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;

21
fronius/integrationpluginfronius.json
View File

@ -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": [

55
modbus/modbusrtumaster.cpp
View File

@ -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()) {

21
modbus/modbusrtumaster.h
View File

@ -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

29
modbus/modbustcpmaster.cpp
View File

@ -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);

14
modbus/modbustcpmaster.h
View File

@ -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

18
modbuscommander/integrationpluginmodbuscommander.cpp
View File

@ -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;
}

7
modbuscommander/integrationpluginmodbuscommander.h
View File

@ -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