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/wallbe/integrationpluginwallbe.cpp

304 lines
13 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 "integrationpluginwallbe.h"
#include "plugininfo.h"
#include "types/param.h"
#include <QDebug>
#include <QStringList>
#include <QJsonDocument>
#include <QNetworkInterface>
IntegrationPluginWallbe::IntegrationPluginWallbe()
{
}
void IntegrationPluginWallbe::init() {
m_discovery = new Discover(QStringList("-xO" "-p 502"));
connect(m_discovery, &Discovery::finished, this, [this](const QList<Host> &hosts) {
Q_FOREACH(Thing *existingThing, myThings()) {
if (existingThing->paramValue(wallbeEcoThingMacAddressParamTypeId).toString().isEmpty()) {
//This device got probably manually setup, to enable auto rediscovery the MAC address needs to setup
if (existingThing->paramValue(wallbeEcoThingIpParamTypeId).toString() == host.address()) {
qCDebug(dcWallbe()) << "Wallbe Wallbox MAC Address has been discovered" << existingThing->name() << host.macAddress();
existingThing->setParamValue(wallbeEcoThingMacParamTypeId, host.macAddress());
}
} else if (existingThing->paramValue(wallbeEcoThingMacParamTypeId).toString() == host.macAddress()) {
if (existingThing->paramValue(wallbeEcoThingIpParamTypeId).toString() != host.address()) {
qCDebug(dcWallbe()) << "Wallbe Wallbox IP Address has changed, from" << existingThing->paramValue(wallbeEcoThingIpParamTypeId).toString() << "to" << host.address();
existingThing->setParamValue(wallbeEcoThingIpParamTypeId, host.address());
} else {
qCDebug(dcWallbe()) << "Wallbe Wallbox" << existingThing->name() << "IP address has not changed" << host.address();
}
break;
}
}
});
}
void IntegrationPluginWallbe::discoverThings(ThingDiscoveryInfo *info)
{
if (info->thingClassId() == wallbeEcoThingClassId){
qCDebug(dcWallbe) << "Start Wallbe eco discovery";
m_discovery->discoverHosts(25);
connect(discover, &Discover::devicesDiscovered, this, [info, this](QList<Host> hosts){
foreach (Host host, hosts) {
ThingDescriptor descriptor;
foreach(Thing *thing, myThings().filterByParam(wallbeEcoThingMacParamTypeId, host.macAddress())) {
descriptor.setThingId(thing->id());
break;
}
descriptor.setTitle(host.hostName());
ParamList params;
params.append(Param(wallbeEcoThingIpParamTypeId, host.address()));
params.append(Param(wallbeEcoThingMacParamTypeId, host.macAddress()));
descriptor.setParams(params);
info->addThingDescriptor(descriptor);
}
info->finish(Thing::ThingErrorNoError);
});
} else {
Q_ASSERT_X(false, "discoverThings", QString("Unhandled thingClassId: %1").arg(info->thingClassId().toString()).toUtf8());
}
}
void IntegrationPluginWallbe::setupThing(ThingSetupInfo *info)
{
Thing *thing = info->thing();
qCDebug(dcWallbe) << "Setting up a new device:" << thing->params();
if (info->thingClassId() == wallbeEcoThingClassId) {
QHostAddress address(thing->paramValue(wallbeEcoThingIpParamTypeId).toString());
if (m_connections.contains(thing)) {
qCDebug(dcWallbe()) << "Setup after reconfiguration, cleaning up ...";
m_connnections.take(thing).deleteLater();)
}
if (address.isNull()){
qCWarning(dcWallbe) << "IP address is not valid";
info->finish(Thing::ThingErrorSetupFailed, tr("Invalid IP address"));
return;
}
ModbusTCPMaster *modbusTcpMaster = new ModbusTCPMaster(address, 502, this);
connect(modbusTcpMaster, &ModbusTCPMaster::connectionStateChanged, this, &IntegrationPluginWallbe::onConnectionStateChanged);
connect(modbusTcpMaster, &ModbusTCPMaster::receivedHoldingRegister, this, &IntegrationPluginWallbe::onReceivedHoldingRegister);
connect(modbusTcpMaster, &ModbusTCPMaster::writeRequestExecuted, this, &IntegrationPluginWallbe::onWriteRequestExecuted);
connect(modbusTcpMaster, &ModbusTCPMaster::writeRequestError, this, &IntegrationPluginWallbe::onWriteRequestError);
m_connections.insert(thing, modbusTcpMaster);
connect(modbusTcpMaster, &ModbusTCPMaster::connectionStateChanged, info, [this, info, modbusTcpMaster](bool connected) {
if(connected) {
info->finish(Thing::ThingErrorNoError);
} else {
info->finish(Thing::ThingErrorHardwareNotAvailable);
}
});
}
}
void IntegrationPluginWallbe::postSetupThing(Thing *thing)
{
if (!m_pluginTimer) {
m_pluginTimer = hardwareManager()->pluginTimerManager()->registerTimer(120);
connect(m_pluginTimer, &PluginTimer::timeout, this, [this] {
foreach(Thing *thing, m_connections.keys()) {
update(thing);
}
});
}
if (thing->thingClassId() == wallbeEcoThingClassId){
update(thing);
} else {
Q_ASSERT_X(false, "postSetupThing", QString("Unhandled thingClassId: %1").arg(thing->thingClassId().toString()).toUtf8());
}
}
void IntegrationPluginWallbe::executeAction(ThingActionInfo *info)
{
Thing *thing = info->thing();
Action action = info->action();
ModbusTCPMaster *modbusTcpMaster = m_connections.value(thing);
if (!modbusTcpMaster) {
qCWarning(dcWallbe()) << "Modbus connection not available";
info->finish(Thing::ThingErrorHardwareFailure);
return;
}
if (thing->thingClassId() == wallbeEcoThingClassId){
// check if this is the "set power" action
if (action.actionTypeId() == wallbeEcoPowerActionTypeId) {
// get the param value of the charging action
bool charging = action.param(wallbeEcoPowerActionPowerParamTypeId).value().toBool();
qCDebug(dcWallbe) << "start Charging button" << thing->name() << "set power to" << charging;
QUuid requestId = modbusTcpMaster->writeCoil(0xff, WallbeRegisterAddress::ChargingStatus, charging);
// Set the "power" state
thing->setStateValue(wallbeEcoPowerStateTypeId, charging);
m_asyncActions.insert(requestId, info);
connect(info, &ThingActionInfo::aborted, this, [this, requestId] {m_asyncActions.remove(requestId);});
} else if(action.actionTypeId() == wallbeEcoMaxChargingCurrentActionTypeId){
uint16_t current = action.param(wallbeEcoMaxChargingCurrentEventMaxChargingCurrentParamTypeId).value().toUInt();
qCDebug(dcWallbe) << "Charging power set to" << current;
QUuid requestId = modbusTcpMaster->writeCoil(0xff, WallbeRegisterAddress::ChargingCurrent, current);
thing->setStateValue(wallbeEcoMaxChargingCurrentStateTypeId, current);
m_asyncActions.insert(requestId, info);
connect(info, &ThingActionInfo::aborted, this, [this, requestId] {m_asyncActions.remove(requestId);});
} 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 IntegrationPluginWallbe::thingRemoved(Thing *thing)
{
if (thing->thingClassId() == wallbeEcoThingClassId) {
if (m_connections.contains(thing)) {
ModbusTCPMaster *modbusTcpMaster = m_connections.take(thing);
qCDebug(dcWallbe) << "Remove device" << thing->name();
modbusTcpMaster->deleteLater();
}
}
if (myThings().isEmpty()) {
hardwareManager()->pluginTimerManager()->unregisterTimer(m_pluginTimer);
m_pluginTimer = nullptr;
}
}
void IntegrationPluginWallbe::update(Thing *thing)
{
ModbusTCPMaster *modbusTCPMaster = m_connections.value(thing);
if(!modbusTCPMaster)
return;
modbusTCPMaster->readHoldingRegister(0xff, WallbeRegisterAddress::EVStatus);
modbusTCPMaster->readHoldingRegister(0xff, WallbeRegisterAddress::ChargingCurrent);
modbusTCPMaster->readHoldingRegister(0xff, WallbeRegisterAddress::ChargingStatus);
modbusTCPMaster->readHoldingRegister(0xff, WallbeRegisterAddress::ChargingTime);
}
void IntegrationPluginWallbe::onConnectionStateChanged(bool status)
{
ModbusTCPMaster *modbusTCPMaster = static_cast<ModbusTCPMaster *>(sender());
Thing *thing = m_connections.key(modbusTCPMaster);
if (!thing)
return;
thing->setStateValue(wallbeEcoConnectedStateTypeId, status);
}
void IntegrationPluginWallbe::onReceivedHoldingRegister(int slaveAddress, int modbusRegister, const QVector<quint16> &value)
{
Q_UNUSED(slaveAddress)
ModbusTCPMaster *modbusTCPMaster = static_cast<ModbusTCPMaster *>(sender());
Thing *thing = m_connections.key(modbusTCPMaster);
if (!thing)
return;
switch (WallbeRegisterAddress(modbusRegister)) {
case WallbeRegisterAddress::EVStatus:
//EV state - 16 bit ASCII (8bit)
switch (value[0]) {
case 65:
thing->setStateValue(wallbeEcoEvStatusStateTypeId, "A - No car plugged in");
break;
case 66:
thing->setStateValue(wallbeEcoEvStatusStateTypeId, "B - Supply equipment not yet ready");
break;
case 67:
thing->setStateValue(wallbeEcoEvStatusStateTypeId, "C - Ready to charge");
break;
case 68:
thing->setStateValue(wallbeEcoEvStatusStateTypeId, "D - Ready to charge, ventilation needed");
break;
case 69:
thing->setStateValue(wallbeEcoEvStatusStateTypeId, "E - Short circuit detected");
break;
case 70:
thing->setStateValue(wallbeEcoEvStatusStateTypeId, "F - Supply equipment not available");
break;
default:
thing->setStateValue(wallbeEcoEvStatusStateTypeId, "F - Supply equipment not available");
}
break;
case WallbeRegisterAddress::ChargingStatus:
thing->setStateValue(wallbeEcoPowerStateTypeId, value[0]);
break;
case WallbeRegisterAddress::ChargingTime: {
// Extract Input Register 102 - load time - 32bit integer
int minutes = (((uint32_t)(value[0]<<16)|(uint32_t)(value[1]))/60); //Converts to minutes
thing->setStateValue(wallbeEcoChargeTimeStateTypeId, minutes);
}
break;
case WallbeRegisterAddress::ChargingCurrent:
thing->setStateValue(wallbeEcoMaxChargingCurrentStateTypeId, value[0]);
break;
case WallbeRegisterAddress::ErrorCode:
qCDebug(dcWallbe()) << "Received Error Code modbus register" << value[0];
break;
}
}
void IntegrationPluginWallbe::onWriteRequestExecuted(const QUuid &requestId, bool success)
{
if (m_asyncActions.contains(requestId)) {
ThingActionInfo *info = m_asyncActions.value(requestId);
if (success) {
info->finish(Thing::ThingErrorNoError);
} else {
info->finish(Thing::ThingErrorHardwareFailure);
}
}
}
void IntegrationPluginWallbe::onWriteRequestError(const QUuid &requestId, const QString &error)
{
Q_UNUSED(requestId)
qCWarning(dcWallbe()) << "Could not execute write request" << error;
}
Reference in New Issue View Git Blame Copy Permalink