ETM-Schurig
/
powersync-plugins-modbus
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

moved mypv to QModbus

master
Boernsman 2020-06-16 17:32:42 +02:00
parent bd6cfd8b02
commit 05e71c24f6
6 changed files with 105 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modbus/modbustcpmaster.cpp
View File

@ -274,7 +274,7 @@ QUuid ModbusTCPMaster::readInputRegister(uint slaveAddress, uint registerAddress
return requestId; return requestId;
} }
QUuid ModbusTCPMaster::readHoldingRegister(uint slaveAddress, uint registerAddress, uint size = 1) QUuid ModbusTCPMaster::readHoldingRegister(uint slaveAddress, uint registerAddress, uint size)
{ {
if (!m_modbusTcpClient) { if (!m_modbusTcpClient) {
return ""; return "";

2
modbus/modbustcpmaster.h
View File

@ -49,7 +49,7 @@ public:
QUuid readCoil(uint slaveAddress, uint registerAddress); QUuid readCoil(uint slaveAddress, uint registerAddress);
QUuid readDiscreteInput(uint slaveAddress, uint registerAddress); QUuid readDiscreteInput(uint slaveAddress, uint registerAddress);
QUuid readInputRegister(uint slaveAddress, uint registerAddress); QUuid readInputRegister(uint slaveAddress, uint registerAddress);
QUuid readHoldingRegister(uint slaveAddress, uint registerAddress); QUuid readHoldingRegister(uint slaveAddress, uint registerAddress, uint size = 1);
QUuid writeCoil(uint slaveAddress, uint registerAddress, bool status); QUuid writeCoil(uint slaveAddress, uint registerAddress, bool status);
QUuid writeHoldingRegister(uint slaveAddress, uint registerAddress, const QVector<quint16> &values); QUuid writeHoldingRegister(uint slaveAddress, uint registerAddress, const QVector<quint16> &values);

103
mypv/integrationpluginmypv.cpp
View File

@ -123,12 +123,11 @@ void IntegrationPluginMyPv::setupThing(ThingSetupInfo *info)
if(thing->thingClassId() == elwaThingClassId) { if(thing->thingClassId() == elwaThingClassId) {
QHostAddress address = QHostAddress(thing->paramValue(elwaThingIpAddressParamTypeId).toString()); QHostAddress address = QHostAddress(thing->paramValue(elwaThingIpAddressParamTypeId).toString());
ModbusTCPMaster *modbusTcpMaster = new ModbusTCPMaster(address, 502, this); ModbusTCPMaster *modbusTcpMaster = new ModbusTCPMaster(address, 502, this);
connect(modbusTcpMaster, &ModbusTCPMaster::connectionStateChanged, this, &IntegrationPluginMyPv::onConnectionStateChanged);
connect(modbusTcpMaster, &ModbusTCPMaster::receivedHoldingRegister, this, &IntegrationPluginMyPv::onReceivedHoldingRegister);
connect(modbusTcpMaster, &ModbusTCPMaster::writeRequestExecuted, this, &IntegrationPluginMyPv::onWriteRequestExecuted);
connect(modbusTcpMaster, &ModbusTCPMaster::writeRequestError, this, &IntegrationPluginMyPv::onWriteRequestError);
if (!modbusTcpMaster->createInterface()) {
modbusTcpMaster->deleteLater();
return;
}
m_modbusTcpMasters.insert(thing, modbusTcpMaster); m_modbusTcpMasters.insert(thing, modbusTcpMaster);
} else { } else {
Q_ASSERT_X(false, "setupDevice", QString("Unhandled deviceClassId: %1").arg(thing->thingClassId().toString()).toUtf8()); Q_ASSERT_X(false, "setupDevice", QString("Unhandled deviceClassId: %1").arg(thing->thingClassId().toString()).toUtf8());
@ -161,16 +160,12 @@ void IntegrationPluginMyPv::executeAction(ThingActionInfo *info)
if (action.actionTypeId() == elwaHeatingPowerActionTypeId) { if (action.actionTypeId() == elwaHeatingPowerActionTypeId) {
int heatingPower = action.param(elwaHeatingPowerActionHeatingPowerParamTypeId).value().toInt(); int heatingPower = action.param(elwaHeatingPowerActionHeatingPowerParamTypeId).value().toInt();
if(!modbusTCPMaster->writeHoldingRegister(0xff, ElwaModbusRegisters::Power, heatingPower)){ QUuid requestId = modbusTCPMaster->writeHoldingRegister(0xff, ElwaModbusRegisters::Power, QVector<quint16>() << heatingPower));
return info->finish(Thing::ThingErrorHardwareFailure); m_asyncActions.insert(requestId, info);
}
return;
} else if (action.actionTypeId() == elwaPowerActionTypeId) { } else if (action.actionTypeId() == elwaPowerActionTypeId) {
bool power = action.param(elwaHeatingPowerActionHeatingPowerParamTypeId).value().toBool(); bool power = action.param(elwaHeatingPowerActionHeatingPowerParamTypeId).value().toBool();
if(power) { if(power) {
if(!modbusTCPMaster->writeHoldingRegister(0xff, ElwaModbusRegisters::ManuelStart, 1)){ QUuid requestId = modbusTCPMaster->writeHoldingRegister(0xff, ElwaModbusRegisters::ManuelStart, QVector<quint16>() << 1));
return info->finish(Thing::ThingErrorHardwareFailure);
}
} }
} else { } else {
Q_ASSERT_X(false, "executeAction", QString("Unhandled actionTypeId: %1").arg(action.actionTypeId().toString()).toUtf8()); Q_ASSERT_X(false, "executeAction", QString("Unhandled actionTypeId: %1").arg(action.actionTypeId().toString()).toUtf8());
@ -189,80 +184,102 @@ void IntegrationPluginMyPv::onRefreshTimer(){
void IntegrationPluginMyPv::onConnectionStateChanged(bool status) void IntegrationPluginMyPv::onConnectionStateChanged(bool status)
{ {
//TODO set device connected state ModbusTCPMaster *modbusTcpMaster = sender();
Thing *thing = m_modbusTcpMasters.key(modbusTcpMaster);
if (!thing)
return;
thing->setStateValue(elwaConnectedStateTypeId, status);
} }
void IntegrationPluginMyPv::update(Thing *thing) { void IntegrationPluginMyPv::onWriteRequestExecuted(QUuid requestId, bool success)
if (thing->thingClassId() == elwaThingClassId)
{ {
ModbusTCPMaster *modbusTCPMaster = m_modbusTcpMasters.value(thing);
int data; }
if (modbusTCPMaster->readHoldingRegister(0xff, ElwaModbusRegisters::Status, &data)) {
switch (data) { void IntegrationPluginMyPv::onWriteRequestError(QUuid requestId, const QString &error)
case Heating: { {
Q_UNUSED(requestId)
qCWarning(dcMypv()) << "Error "
}
void IntegrationPluginMyPv::onReceivedHoldingRegister(quint32 slaveAddress, quint32 modbusRegister, int value)
{
Q_UNUSED(slaveAddress)
ModbusTCPMaster *modbusTcpMaster = sender();
Thing *thing = m_modbusTcpMasters.key(modbusTcpMaster);
if (!thing)
return;
if(modbusRegister == ElwaModbusRegisters::Status) {
switch (ElwaStatus(value)) {
case ElwaStatus::Heating: {
thing->setStateValue(elwaStatusStateTypeId, "Heating"); thing->setStateValue(elwaStatusStateTypeId, "Heating");
thing->setStateValue(elwaPowerStateTypeId, true); thing->setStateValue(elwaPowerStateTypeId, true);
break; break;
} }
case Standby:{ case ElwaStatus::Standby:{
thing->setStateValue(elwaStatusStateTypeId, "Standby"); thing->setStateValue(elwaStatusStateTypeId, "Standby");
thing->setStateValue(elwaPowerStateTypeId, false); thing->setStateValue(elwaPowerStateTypeId, false);
break; break;
} }
case Boosted:{ case ElwaStatus::Boosted:{
thing->setStateValue(elwaStatusStateTypeId, "Boosted"); thing->setStateValue(elwaStatusStateTypeId, "Boosted");
thing->setStateValue(elwaPowerStateTypeId, true); thing->setStateValue(elwaPowerStateTypeId, true);
break; break;
} }
case HeatFinished:{ case ElwaStatus::HeatFinished:{
thing->setStateValue(elwaStatusStateTypeId, "Heat finished"); thing->setStateValue(elwaStatusStateTypeId, "Heat finished");
thing->setStateValue(elwaPowerStateTypeId, false); thing->setStateValue(elwaPowerStateTypeId, false);
break; break;
} }
case Setup:{ case ElwaStatus::Setup:{
thing->setStateValue(elwaStatusStateTypeId, "Setup"); thing->setStateValue(elwaStatusStateTypeId, "Setup");
thing->setStateValue(elwaPowerStateTypeId, false); thing->setStateValue(elwaPowerStateTypeId, false);
break; break;
} }
case ErrorOvertempFuseBlown:{ case ElwaStatus::ErrorOvertempFuseBlown:{
thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp Fuse blown"); thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp Fuse blown");
break; break;
} }
case ErrorOvertempMeasured:{ case ElwaStatus::ErrorOvertempMeasured:{
thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp measured"); thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp measured");
break; break;
} }
case ErrorOvertempElectronics:{ case ElwaStatus::ErrorOvertempElectronics:{
thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp Electronics"); thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp Electronics");
break; break;
} }
case ErrorHardwareFault:{ case ElwaStatus::ErrorHardwareFault:{
thing->setStateValue(elwaStatusStateTypeId, "Error Hardware Fault"); thing->setStateValue(elwaStatusStateTypeId, "Error Hardware Fault");
break; break;
} }
case ErrorTempSensor:{ case ElwaStatus::ErrorTempSensor:{
thing->setStateValue(elwaStatusStateTypeId, "Error Temp Sensor"); thing->setStateValue(elwaStatusStateTypeId, "Error Temp Sensor");
break; break;
} }
default: default:
thing->setStateValue(elwaStatusStateTypeId, "Unknown"); thing->setStateValue(elwaStatusStateTypeId, "Unknown");
} }
} else if(modbusRegister == ElwaModbusRegisters::WaterTemperature) {
thing->setStateValue(elwaConnectedStateTypeId, true); thing->setStateValue(elwaTemperatureStateTypeId, value[0]/10.00);
} else if(modbusRegister == ElwaModbusRegisters::TargetWaterTemperature) {
thing->setStateValue(elwaTargetWaterTemperatureStateTypeId, value[0]/10.00);
} else if(modbusRegister == ElwaModbusRegisters::Power) {
thing->setStateValue(elwaHeatingPowerStateTypeId, value[0]);
} else { } else {
thing->setStateValue(elwaConnectedStateTypeId, false); qCWarning(dcMypv()) << "Received unhandled modbus register";
} }
}
if (modbusTCPMaster->getRegister(0xff, ElwaModbusRegisters::WaterTemperature, &data)) {
thing->setStateValue(elwaTemperatureStateTypeId, data/10.00); void IntegrationPluginMyPv::update(Thing *thing)
} {
if (modbusTCPMaster->getRegister(0xff, ElwaModbusRegisters::TargetWaterTemperature, &data)) { if (thing->thingClassId() == elwaThingClassId) {
thing->setStateValue(elwaTargetWaterTemperatureStateTypeId, data/10.00); ModbusTCPMaster *modbusTCPMaster = m_modbusTcpMasters.value(thing);
}
if (modbusTCPMaster->getRegister(0xff, ElwaModbusRegisters::Power, &data)) { modbusTCPMaster->readHoldingRegister(0xff, ElwaModbusRegisters::Status);
thing->setStateValue(elwaHeatingPowerStateTypeId, data); modbusTCPMaster->readHoldingRegister(0xff, ElwaModbusRegisters::WaterTemperature);
} modbusTCPMaster->readHoldingRegister(0xff, ElwaModbusRegisters::TargetWaterTemperature);
modbusTCPMaster->readHoldingRegister(0xff, ElwaModbusRegisters::Power);
} }
} }

13
mypv/integrationpluginmypv.h
View File

@ -37,6 +37,7 @@
#include "../modbus/modbustcpmaster.h" #include "../modbus/modbustcpmaster.h"
#include <QUdpSocket> #include <QUdpSocket>
#include <QUuid>
class IntegrationPluginMyPv: public IntegrationPlugin class IntegrationPluginMyPv: public IntegrationPlugin
{ {
@ -80,6 +81,7 @@ private:
PluginTimer *m_refreshTimer = nullptr; PluginTimer *m_refreshTimer = nullptr;
QHash<Thing *, ModbusTCPMaster *> m_modbusTcpMasters; QHash<Thing *, ModbusTCPMaster *> m_modbusTcpMasters;
QHash<QUuid, ThingActionInfo *> m_asyncActions;
void update(Thing *thing); void update(Thing *thing);
@ -89,12 +91,11 @@ private slots:
void onPluginConfigurationChanged(const ParamTypeId &paramTypeId, const QVariant &value); void onPluginConfigurationChanged(const ParamTypeId &paramTypeId, const QVariant &value);
void onConnectionStateChanged(bool status); void onConnectionStateChanged(bool status);
void onRequestExecuted(QUuid requestId, bool success); void onWriteRequestExecuted(QUuid requestId, bool success);
void onRequestError(QUuid requestId, const QString &error); void onWriteRequestError(QUuid requestId, const QString &error);
void onReceivedCoil(quint32 slaveAddress, quint32 modbusRegister, bool value);
void onReceivedDiscreteInput(quint32 slaveAddress, quint32 modbusRegister, bool value); void onReceivedHoldingRegister(quint32 slaveAddress, quint32 modbusRegister, const QVector<quint16> &values);
void onReceivedHoldingRegister(quint32 slaveAddress, quint32 modbusRegister, int value); void onReceivedInputRegister(quint32 slaveAddress, quint32 modbusRegister, const QVector<quint16> &values);
void onReceivedInputRegister(quint32 slaveAddress, quint32 modbusRegister, int value);
}; };
#endif // INTEGRATIONPLUGINMYPV_H #endif // INTEGRATIONPLUGINMYPV_H

2
wallbe/integrationpluginwallbe.cpp
View File

@ -63,7 +63,7 @@ void IntegrationPluginWallbe::setupThing(ThingSetupInfo *info)
connect(modbusTcpMaster, &ModbusTCPMaster::writeRequestError, this, &IntegrationPluginWallbe::onWriteRequestError); connect(modbusTcpMaster, &ModbusTCPMaster::writeRequestError, this, &IntegrationPluginWallbe::onWriteRequestError);
m_connections.insert(thing, modbusTcpMaster); m_connections.insert(thing, modbusTcpMaster);
connect(modbusTcpMaster, &ModbusTCPMaster::connectionStateChanged, info, [this, modbusTcpMaster](bool connected) { connect(modbusTcpMaster, &ModbusTCPMaster::connectionStateChanged, info, [this, info, modbusTcpMaster](bool connected) {
if(connected) { if(connected) {
info->finish(Thing::ThingErrorNoError); info->finish(Thing::ThingErrorNoError);
} else { } else {

4
wallbe/integrationpluginwallbe.h
View File

@ -73,13 +73,9 @@ private:
void update(Thing *thing); void update(Thing *thing);
private slots: private slots:
void onRefreshTimer();
void onConnectionStateChanged(bool status); void onConnectionStateChanged(bool status);
void onReceivedCoil(int slaveAddress, int modbusRegister, bool value); void onReceivedCoil(int slaveAddress, int modbusRegister, bool value);
void onReceivedDiscreteInput(int slaveAddress, int modbusRegister, bool value);
void onReceivedHoldingRegister(int slaveAddress, int modbusRegister, const QVector<quint16> &value); void onReceivedHoldingRegister(int slaveAddress, int modbusRegister, const QVector<quint16> &value);
void onReceivedInputRegister(int slaveAddress, int modbusRegister, int value);
void onWriteRequestExecuted(const QUuid &requestId, bool success); void onWriteRequestExecuted(const QUuid &requestId, bool success);
void onWriteRequestError(const QUuid &requestId, const QString &error); void onWriteRequestError(const QUuid &requestId, const QString &error);