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
nymea-plugins-modbus/fronius/integrationpluginfronius.cpp

609 lines
30 KiB
C++
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* 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 "integrationpluginfronius.h"
#include "plugintimer.h"
#include "network/networkaccessmanager.h"
#include <QUrl>
#include <QUrlQuery>
#include <QJsonDocument>
#include <QPointer>
#include "plugininfo.h"
#include <QDebug>
// Notes: Test IPs: 93.82.221.82 | 88.117.152.99
IntegrationPluginFronius::IntegrationPluginFronius(QObject *parent): IntegrationPlugin(parent){
}
void IntegrationPluginFronius::setupThing(ThingSetupInfo *info)
{
qCDebug(dcFronius()) << "Setting up a new thing:" << info->thing()->name();
Thing *thing = info->thing();
if (thing->thingClassId() == dataloggerThingClassId) {
//check if a data logger is already added with this IPv4Address
foreach(FroniusLogger *logger, m_froniusLoggers.keys()){
if(logger->hostAddress() == thing->paramValue(dataloggerThingLoggerHostParamTypeId).toString()){
//this logger at this IPv4 address is already added
qCWarning(dcFronius()) << "thing at " << thing->paramValue(dataloggerThingLoggerHostParamTypeId).toString() << " already added!";
info->finish(Thing::ThingErrorThingInUse);
return;
}
}
// Perform a HTTP request on the given IPv4Address to find things
QUrl requestUrl;
requestUrl.setScheme("http");
requestUrl.setHost(thing->paramValue(dataloggerThingLoggerHostParamTypeId).toString());
requestUrl.setPath("/solar_api/GetAPIVersion.cgi");
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();
if (reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Fronius: Network request error:" << reply->error() << reply->errorString();
info->finish(Thing::ThingErrorHardwareNotAvailable, tr("Device not reachable"));
return;
}
// Convert the rawdata to a JSON document
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qCWarning(dcFronius()) << "Fronius: Failed to parse JSON data" << data << ":" << error.errorString() << data;
info->finish(Thing::ThingErrorHardwareFailure, tr("Please try again"));
return;
}
FroniusLogger *newLogger = new FroniusLogger(thing, this);
newLogger->setBaseUrl(jsonDoc.toVariant().toMap().value("BaseURL").toString());
newLogger->setHostAddress(thing->paramValue(dataloggerThingLoggerHostParamTypeId).toString());
m_froniusLoggers.insert(newLogger, thing);
info->finish(Thing::ThingErrorNoError);
});
//Async Setup
} else if (thing->thingClassId() == inverterThingClassId) {
FroniusInverter *newInverter = new FroniusInverter(thing,this);
newInverter->setDeviceId(thing->paramValue(inverterThingIdParamTypeId).toString());
newInverter->setName(thing->paramValue(inverterThingNameParamTypeId).toString());
newInverter->setBaseUrl(thing->paramValue(inverterThingBaseParamTypeId).toString());
newInverter->setHostAddress(thing->paramValue(inverterThingHostParamTypeId).toString());
m_froniusInverters.insert(newInverter,thing);
thing->setParentId(ThingId(newInverter->hostId()));
thing->setName(newInverter->name());
// get inverter unique ID
QUrl requestUrl;
requestUrl.setScheme("http");
requestUrl.setHost(newInverter->hostAddress());
requestUrl.setPath(newInverter->baseUrl() + "GetInverterInfo.cgi");
QNetworkReply *reply = hardwareManager()->networkManager()->get(QNetworkRequest(requestUrl));
connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, [this, info, newInverter, reply]() {
QByteArray data = reply->readAll();
reply->deleteLater();
if (reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Fronius: Network request error:" << reply->error() << reply->errorString();
info->finish(Thing::ThingErrorHardwareNotAvailable, "Device not reachable");
return;
}
// Convert the rawdata to a json document
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qCWarning(dcFronius()) << "Fronius: Failed to parse JSON data" << data << ":" << error.errorString();
info->finish(Thing::ThingErrorHardwareNotAvailable, "Please try again");
return;
}
// Check reply information
QVariantMap dataMap = jsonDoc.toVariant().toMap().value("Body").toMap().value("Data").toMap();
// check for thing id in reply
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();
}
info->finish(Thing::ThingErrorNoError);
});
// Async Setup
} else if (thing->thingClassId() == storageThingClassId) {
FroniusStorage *newStorage = new FroniusStorage(thing, this);
newStorage->setDeviceId(thing->paramValue(storageThingIdParamTypeId).toString());
newStorage->setName(thing->paramValue(storageThingNameParamTypeId).toString());
newStorage->setBaseUrl(thing->paramValue(storageThingBaseParamTypeId).toString());
newStorage->setHostAddress(thing->paramValue(storageThingHostParamTypeId).toString());
m_froniusStorages.insert(newStorage,thing);
thing->setParentId(ThingId(newStorage->hostId()));
thing->setName(newStorage->name());
// Get storage manufacturer and maximum capacity
QUrlQuery query;
QUrl requestUrl;
requestUrl.setScheme("http");
requestUrl.setHost(newStorage->hostAddress());
requestUrl.setPath(newStorage->baseUrl() + "GetStorageRealtimeData.cgi");
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));
connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, [this, info, newStorage, reply]() {
QByteArray data = reply->readAll();
if (reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Fronius: Network request error:" << reply->error() << reply->errorString();
info->finish(Thing::ThingErrorNoError);
return;
}
// Convert the rawdata to a json document
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qCWarning(dcFronius()) << "Fronius: Failed to parse JSON data" << data << ":" << error.errorString();
info->finish(Thing::ThingErrorHardwareFailure, tr("Please try again"));
return;
}
// Create StorageInfo list map
QVariantMap storageInfoMap = jsonDoc.toVariant().toMap().value("Body").toMap().value("Data").toMap().value("Controller").toMap();
newStorage->pluginThing()->setParamValue(storageThingManufacturerParamTypeId, storageInfoMap.value("Details").toMap().value("Manufacturer").toString());
newStorage->pluginThing()->setParamValue(storageThingCapacityParamTypeId, storageInfoMap.value("Capacity_Maximum").toInt());
info->finish(Thing::ThingErrorNoError);
});
//Async Setup
} else if (thing->thingClassId() == meterThingClassId) {
FroniusMeter *newMeter = new FroniusMeter(thing, this);;
newMeter->setDeviceId(thing->paramValue(meterThingIdParamTypeId).toString());
newMeter->setName(thing->paramValue(meterThingNameParamTypeId).toString());
newMeter->setBaseUrl(thing->paramValue(meterThingBaseParamTypeId).toString());
newMeter->setHostAddress(thing->paramValue(meterThingHostParamTypeId).toString());
m_froniusMeters.insert(newMeter,thing);
thing->setParentId(ThingId(newMeter->hostId()));
thing->setName(newMeter->name());
info->finish(Thing::ThingErrorNoError);
//Async setup
} else if (thing->thingClassId() == sunspecStorageThingClassId) {
SunspecThing *sunspecThings = new SunspecThing(thing, this);
m_sunspecThings.insert(sunspecThings, thing);
info->finish(Thing::ThingErrorNoError);
} else {
Q_ASSERT_X(false, "setupThing", QString("Unhandled thingClassId: %1").arg(thing->thingClassId().toString()).toUtf8());
}
}
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);
} else if (thing->thingClassId() == inverterThingClassId) {
updateThingStates(thing);
} else if (thing->thingClassId() == meterThingClassId) {
updateThingStates(thing);
} else if (thing->thingClassId() == storageThingClassId) {
updateThingStates(thing);
} else if (thing->thingClassId() == sunspecStorageThingClassId) {
SunspecThing *sunspecThing = m_sunspecThings.key(thing);
sunspecThing->update();
} else {
Q_ASSERT_X(false, "postSetupThing", QString("Unhandled thingClassId: %1").arg(thing->thingClassId().toString()).toUtf8());
}
}
void IntegrationPluginFronius::thingRemoved(Thing *thing)
{
if (thing->thingClassId() == dataloggerThingClassId) {
FroniusLogger *logger = m_froniusLoggers.key(thing);
m_froniusLoggers.remove(logger);
logger->deleteLater();
return;
} else if (thing->thingClassId() == inverterThingClassId) {
FroniusInverter *inverter = m_froniusInverters.key(thing);
m_froniusInverters.remove(inverter);
inverter->deleteLater();
return;
} else if (thing->thingClassId() == meterThingClassId) {
FroniusMeter *meter = m_froniusMeters.key(thing);
m_froniusMeters.remove(meter);
meter->deleteLater();
return;
} else if (thing->thingClassId() == storageThingClassId) {
FroniusStorage *storage = m_froniusStorages.key(thing);
m_froniusStorages.remove(storage);
storage->deleteLater();
return;
} else if (thing->thingClassId() == sunspecStorageThingClassId) {
qCDebug(dcFronius()) << "Remove sunspec thing";
SunspecThing *sunspecThing = m_sunspecThings.key(thing);
m_sunspecThings.remove(sunspecThing);
delete sunspecThing;
qCDebug(dcFronius()) << "Sunspec thing deleted";
return;
} else {
Q_ASSERT_X(false, "thingRemoved", QString("Unhandled thingClassId: %1").arg(thing->thingClassId().toString()).toUtf8());
}
if (myThings().isEmpty()) {
hardwareManager()->pluginTimerManager()->unregisterTimer(m_pluginTimer);
m_pluginTimer = nullptr;
}
}
void IntegrationPluginFronius::executeAction(ThingActionInfo *info)
{
Action action = info->action();
Thing *thing = info->thing();
qCDebug(dcFronius()) << "Execute action" << thing->name() << action.actionTypeId().toString();
if (thing->thingClassId() == dataloggerThingClassId) {
if (action.actionTypeId() == dataloggerSearchDevicesActionTypeId) {
searchNewThings(m_froniusLoggers.key(thing));
info->finish(Thing::ThingErrorNoError);
} else {
Q_ASSERT_X(false, "executeAction", QString("Unhandled action: %1").arg(action.actionTypeId().toString()).toUtf8());
}
} else if (thing->thingClassId() == sunspecStorageThingClassId) {
SunspecThing *sunspecThing = m_sunspecThings.key(thing);
if (!sunspecThing) {
qWarning(dcFronius()) << "Could not find sunspec instance for thing";
info->finish(Thing::ThingErrorHardwareNotAvailable);
return;
}
if (action.actionTypeId() == sunspecStorageGridChargingActionTypeId) {
QUuid requestId = sunspecThing->setGridCharging(action.param(sunspecStorageGridChargingActionGridChargingParamTypeId).value().toBool());
if (requestId.isNull()) {
info->finish(Thing::ThingErrorHardwareFailure);
} else {
m_asyncActions.insert(requestId, info);
}
} else if (action.actionTypeId() == sunspecStorageEnableChargingLimitActionTypeId) {
int value = (action.param(sunspecStorageEnableChargingLimitActionEnableChargingLimitParamTypeId).value().toBool() << 1) | thing->stateValue(sunspecStorageEnableDischargingLimitStateTypeId).toBool();
QUuid requestId = sunspecThing->setStorageControlMode(value);
if (requestId.isNull()) {
info->finish(Thing::ThingErrorHardwareFailure);
} else {
m_asyncActions.insert(requestId, info);
}
} else if (action.actionTypeId() == sunspecStorageChargingRateActionTypeId) {
QUuid requestId = sunspecThing->setChargingRate(action.param(sunspecStorageChargingRateActionChargingRateParamTypeId).value().toInt());
if (requestId.isNull()) {
info->finish(Thing::ThingErrorHardwareFailure);
} else {
m_asyncActions.insert(requestId, info);
}
} else if (action.actionTypeId() == sunspecStorageEnableDischargingLimitActionTypeId) {
int value = (action.param(sunspecStorageEnableDischargingLimitActionEnableDischargingLimitParamTypeId).value().toBool() << 1) | thing->stateValue(sunspecStorageEnableChargingLimitStateTypeId).toBool();
QUuid requestId = sunspecThing->setStorageControlMode(value);
if (requestId.isNull()) {
info->finish(Thing::ThingErrorHardwareFailure);
} else {
m_asyncActions.insert(requestId, info);
}
} else if (action.actionTypeId() == sunspecStorageDischargingRateActionTypeId) {
QUuid requestId = sunspecThing->setDischargingRate(action.param(sunspecStorageDischargingRateActionDischargingRateParamTypeId).value().toInt());
if (requestId.isNull()) {
info->finish(Thing::ThingErrorHardwareFailure);
} else {
m_asyncActions.insert(requestId, info);
}
} else {
Q_ASSERT_X(false, "executeAction", QString("Unhandled action: %1").arg(action.actionTypeId().toString()).toUtf8());
}
} else {
Q_ASSERT_X(false, "executeAction", QString("Unhandled thingClassId: %1").arg(thing->thingClassId().toString()).toUtf8());
}
}
void IntegrationPluginFronius::updateThingStates(Thing *thing)
{
qCDebug(dcFronius()) << "Update thing values for" << thing->name();
if(thing->thingClassId() == inverterThingClassId) {
QNetworkReply *reply = hardwareManager()->networkManager()->get(QNetworkRequest(m_froniusInverters.key(thing)->updateUrl()));
connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, [this, thing, reply]() {
if (reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Network request error:" << reply->error() << reply->errorString();
return;
}
QByteArray data = reply->readAll();
if(m_froniusInverters.values().contains(thing)){ // check if thing was not removed before reply was received
m_froniusInverters.key(thing)->updateThingInfo(data);
}
});
QNetworkReply *next_reply = hardwareManager()->networkManager()->get(QNetworkRequest(m_froniusInverters.key(thing)->activityUrl()));
connect(next_reply, &QNetworkReply::finished, next_reply, &QNetworkReply::deleteLater);
connect(next_reply, &QNetworkReply::finished, [this, thing, next_reply]() {
if (next_reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Network request error:" << next_reply->error() << next_reply->errorString();
return;
}
QByteArray data = next_reply->readAll();
if(m_froniusInverters.values().contains(thing)){ // check if thing was not removed before reply was received
m_froniusInverters.key(thing)->updateActivityInfo(data);
}
});
} else if (thing->thingClassId() == dataloggerThingClassId) {
QNetworkReply *reply = hardwareManager()->networkManager()->get(QNetworkRequest(m_froniusLoggers.key(thing)->updateUrl()));
connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, [this, thing, reply]() {
if (reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Network request error:" << reply->error() << reply->errorString();
return;
}
QByteArray data = reply->readAll();
if(m_froniusLoggers.values().contains(thing)){ // check if thing was not removed before reply was received
m_froniusLoggers.key(thing)->updateThingInfo(data);
}
});
reply = hardwareManager()->networkManager()->get(QNetworkRequest(m_froniusLoggers.key(thing)->updateRelayStateUrl()));
connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, [this, thing, reply]() {
if (reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Network request error:" << reply->error() << reply->errorString();
return;
}
QByteArray data = reply->readAll();
if(m_froniusLoggers.values().contains(thing)){ // check if thing was not removed before reply was received
m_froniusLoggers.key(thing)->updatePowerRelayState(data);
}
});
} else if (thing->thingClassId() == meterThingClassId) {
QNetworkReply *reply = hardwareManager()->networkManager()->get(QNetworkRequest(m_froniusMeters.key(thing)->updateUrl()));
connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, [this, thing, reply]() {
if (reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Network request error:" << reply->error() << reply->errorString();
return;
}
QByteArray data = reply->readAll();
if(m_froniusMeters.values().contains(thing)){ // check if thing was not removed before reply was received
m_froniusMeters.key(thing)->updateThingInfo(data);
}
});
QNetworkReply *next_reply = hardwareManager()->networkManager()->get(QNetworkRequest(m_froniusMeters.key(thing)->activityUrl()));
connect(next_reply, &QNetworkReply::finished, next_reply, &QNetworkReply::deleteLater);
connect(next_reply, &QNetworkReply::finished, [this, thing, next_reply]() {
if (next_reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Network request error:" << next_reply->error() << next_reply->errorString();
return;
}
QByteArray data = next_reply->readAll();
if(m_froniusMeters.values().contains(thing)){ // check if thing was not removed before reply was received
m_froniusMeters.key(thing)->updateActivityInfo(data);
}
});
} else if (thing->thingClassId() == storageThingClassId) {
QNetworkReply *reply = hardwareManager()->networkManager()->get(QNetworkRequest(m_froniusStorages.key(thing)->updateUrl()));
connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, [this, thing, reply]() {
if (reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Network request error:" << reply->error() << reply->errorString();
return;
}
QByteArray data = reply->readAll();
if(m_froniusStorages.values().contains(thing)){ // check if thing was not removed before reply was received
m_froniusStorages.key(thing)->updateThingInfo(data);
}
});
QNetworkReply *next_reply = hardwareManager()->networkManager()->get(QNetworkRequest(m_froniusStorages.key(thing)->activityUrl()));
connect(next_reply, &QNetworkReply::finished, next_reply, &QNetworkReply::deleteLater);
connect(next_reply, &QNetworkReply::finished, [this, thing, next_reply]() {
next_reply->deleteLater();
if (next_reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Network request error:" << next_reply->error() << next_reply->errorString();
return;
}
QByteArray data = next_reply->readAll();
if(m_froniusStorages.values().contains(thing)){ // check if thing was not removed before reply was received
m_froniusStorages.key(thing)->updateActivityInfo(data);
}
});
} else {
Q_ASSERT_X(false, "updateThingState", QString("Unhandled thingClassId: %1").arg(thing->thingClassId().toString()).toUtf8());
}
}
void IntegrationPluginFronius::searchNewThings(FroniusLogger *logger)
{
QUrl url; QUrlQuery query;
query.addQueryItem("DeviceClass", "System");
url.setScheme("http");
url.setHost(logger->hostAddress());
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(request);
connect(reply, &QNetworkReply::finished, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, [this, logger, reply]() {
if (reply->error() != QNetworkReply::NoError) {
qCWarning(dcFronius()) << "Network request error:" << reply->error() << reply->errorString();
return;
}
Thing *loggerThing = m_froniusLoggers.value(logger);
if (!loggerThing)
return;
QByteArray data = reply->readAll();
// Convert the rawdata to a json document
QJsonParseError error;
QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &error);
if (error.error != QJsonParseError::NoError) {
qCWarning(dcFronius()) << "Fronius: Failed to parse JSON data" << data << ":" << error.errorString();
return;
}
// Parse the data for thing information
QList<ThingDescriptor> thingDescriptors;
// Check reply information
QVariantMap bodyMap = jsonDoc.toVariant().toMap().value("Body").toMap();
// Parse reply for inverters at the host address
QVariantMap inverterMap = bodyMap.value("Data").toMap().value("Inverter").toMap();
foreach (QString inverterId, inverterMap.keys()) {
//check if thing already connected to logger
if(!existingThing(inverterThingIdParamTypeId,inverterId)) {
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(loggerThing)->hostAddress()));
params.append(Param(inverterThingBaseParamTypeId, m_froniusLoggers.key(loggerThing)->baseUrl()));
params.append(Param(inverterThingIdParamTypeId, inverterId));
params.append(Param(inverterThingUniqueIdParamTypeId, ""));
descriptor.setParams(params);
thingDescriptors.append(descriptor);
}
}
// 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 = loggerThing->name() + " Meter " + meterId;
ThingDescriptor descriptor(meterThingClassId, thingName, "Fronius Solar Meter", loggerThing->id());
ParamList params;
params.append(Param(meterThingNameParamTypeId, thingName));
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()));
descriptor.setParams(params);
thingDescriptors.append(descriptor);
}
}
// 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 = 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(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()));
descriptor.setParams(params);
thingDescriptors.append(descriptor);
}
}
if (!thingDescriptors.empty()) {
emit autoThingsAppeared(thingDescriptors);
thingDescriptors.clear();
}
});
}
bool IntegrationPluginFronius::existingThing(ParamTypeId thingParamId, QString thingId)
{
foreach(Thing *thing, myThings()) {
if(thing->paramValue(thingParamId).toString() == thingId) {
return true;
}
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink