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;
}
QUuid ModbusTCPMaster::readHoldingRegister(uint slaveAddress, uint registerAddress, uint size = 1)
QUuid ModbusTCPMaster::readHoldingRegister(uint slaveAddress, uint registerAddress, uint size)
{
if (!m_modbusTcpClient) {
return "";

2
modbus/modbustcpmaster.h
View File

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

173
mypv/integrationpluginmypv.cpp
View File

@ -123,12 +123,11 @@ void IntegrationPluginMyPv::setupThing(ThingSetupInfo *info)
if(thing->thingClassId() == elwaThingClassId) {
QHostAddress address = QHostAddress(thing->paramValue(elwaThingIpAddressParamTypeId).toString());
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);
} else {
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) {
int heatingPower = action.param(elwaHeatingPowerActionHeatingPowerParamTypeId).value().toInt();
if(!modbusTCPMaster->writeHoldingRegister(0xff, ElwaModbusRegisters::Power, heatingPower)){
return info->finish(Thing::ThingErrorHardwareFailure);
}
return;
QUuid requestId = modbusTCPMaster->writeHoldingRegister(0xff, ElwaModbusRegisters::Power, QVector<quint16>() << heatingPower));
m_asyncActions.insert(requestId, info);
} else if (action.actionTypeId() == elwaPowerActionTypeId) {
bool power = action.param(elwaHeatingPowerActionHeatingPowerParamTypeId).value().toBool();
if(power) {
if(!modbusTCPMaster->writeHoldingRegister(0xff, ElwaModbusRegisters::ManuelStart, 1)){
return info->finish(Thing::ThingErrorHardwareFailure);
}
QUuid requestId = modbusTCPMaster->writeHoldingRegister(0xff, ElwaModbusRegisters::ManuelStart, QVector<quint16>() << 1));
}
} else {
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)
{
//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) {
if (thing->thingClassId() == elwaThingClassId)
{
ModbusTCPMaster *modbusTCPMaster = m_modbusTcpMasters.value(thing);
void IntegrationPluginMyPv::onWriteRequestExecuted(QUuid requestId, bool success)
{
int data;
if (modbusTCPMaster->readHoldingRegister(0xff, ElwaModbusRegisters::Status, &data)) {
switch (data) {
case Heating: {
thing->setStateValue(elwaStatusStateTypeId, "Heating");
thing->setStateValue(elwaPowerStateTypeId, true);
break;
}
case Standby:{
thing->setStateValue(elwaStatusStateTypeId, "Standby");
thing->setStateValue(elwaPowerStateTypeId, false);
break;
}
case Boosted:{
thing->setStateValue(elwaStatusStateTypeId, "Boosted");
thing->setStateValue(elwaPowerStateTypeId, true);
break;
}
case HeatFinished:{
thing->setStateValue(elwaStatusStateTypeId, "Heat finished");
thing->setStateValue(elwaPowerStateTypeId, false);
break;
}
case Setup:{
thing->setStateValue(elwaStatusStateTypeId, "Setup");
thing->setStateValue(elwaPowerStateTypeId, false);
break;
}
case ErrorOvertempFuseBlown:{
thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp Fuse blown");
break;
}
case ErrorOvertempMeasured:{
thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp measured");
break;
}
case ErrorOvertempElectronics:{
thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp Electronics");
break;
}
case ErrorHardwareFault:{
thing->setStateValue(elwaStatusStateTypeId, "Error Hardware Fault");
break;
}
case ErrorTempSensor:{
thing->setStateValue(elwaStatusStateTypeId, "Error Temp Sensor");
break;
}
default:
thing->setStateValue(elwaStatusStateTypeId, "Unknown");
}
}
thing->setStateValue(elwaConnectedStateTypeId, true);
} else {
thing->setStateValue(elwaConnectedStateTypeId, false);
}
void IntegrationPluginMyPv::onWriteRequestError(QUuid requestId, const QString &error)
{
Q_UNUSED(requestId)
qCWarning(dcMypv()) << "Error "
}
if (modbusTCPMaster->getRegister(0xff, ElwaModbusRegisters::WaterTemperature, &data)) {
thing->setStateValue(elwaTemperatureStateTypeId, data/10.00);
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(elwaPowerStateTypeId, true);
break;
}
if (modbusTCPMaster->getRegister(0xff, ElwaModbusRegisters::TargetWaterTemperature, &data)) {
thing->setStateValue(elwaTargetWaterTemperatureStateTypeId, data/10.00);
case ElwaStatus::Standby:{
thing->setStateValue(elwaStatusStateTypeId, "Standby");
thing->setStateValue(elwaPowerStateTypeId, false);
break;
}
if (modbusTCPMaster->getRegister(0xff, ElwaModbusRegisters::Power, &data)) {
thing->setStateValue(elwaHeatingPowerStateTypeId, data);
case ElwaStatus::Boosted:{
thing->setStateValue(elwaStatusStateTypeId, "Boosted");
thing->setStateValue(elwaPowerStateTypeId, true);
break;
}
case ElwaStatus::HeatFinished:{
thing->setStateValue(elwaStatusStateTypeId, "Heat finished");
thing->setStateValue(elwaPowerStateTypeId, false);
break;
}
case ElwaStatus::Setup:{
thing->setStateValue(elwaStatusStateTypeId, "Setup");
thing->setStateValue(elwaPowerStateTypeId, false);
break;
}
case ElwaStatus::ErrorOvertempFuseBlown:{
thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp Fuse blown");
break;
}
case ElwaStatus::ErrorOvertempMeasured:{
thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp measured");
break;
}
case ElwaStatus::ErrorOvertempElectronics:{
thing->setStateValue(elwaStatusStateTypeId, "Error Overtemp Electronics");
break;
}
case ElwaStatus::ErrorHardwareFault:{
thing->setStateValue(elwaStatusStateTypeId, "Error Hardware Fault");
break;
}
case ElwaStatus::ErrorTempSensor:{
thing->setStateValue(elwaStatusStateTypeId, "Error Temp Sensor");
break;
}
default:
thing->setStateValue(elwaStatusStateTypeId, "Unknown");
}
} else if(modbusRegister == ElwaModbusRegisters::WaterTemperature) {
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 {
qCWarning(dcMypv()) << "Received unhandled modbus register";
}
}
void IntegrationPluginMyPv::update(Thing *thing)
{
if (thing->thingClassId() == elwaThingClassId) {
ModbusTCPMaster *modbusTCPMaster = m_modbusTcpMasters.value(thing);
modbusTCPMaster->readHoldingRegister(0xff, ElwaModbusRegisters::Status);
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 <QUdpSocket>
#include <QUuid>
class IntegrationPluginMyPv: public IntegrationPlugin
{
@ -80,6 +81,7 @@ private:
PluginTimer *m_refreshTimer = nullptr;
QHash<Thing *, ModbusTCPMaster *> m_modbusTcpMasters;
QHash<QUuid, ThingActionInfo *> m_asyncActions;
void update(Thing *thing);
@ -89,12 +91,11 @@ private slots:
void onPluginConfigurationChanged(const ParamTypeId &paramTypeId, const QVariant &value);
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 onReceivedHoldingRegister(quint32 slaveAddress, quint32 modbusRegister, int value);
void onReceivedInputRegister(quint32 slaveAddress, quint32 modbusRegister, int value);
void onWriteRequestExecuted(QUuid requestId, bool success);
void onWriteRequestError(QUuid requestId, const QString &error);
void onReceivedHoldingRegister(quint32 slaveAddress, quint32 modbusRegister, const QVector<quint16> &values);
void onReceivedInputRegister(quint32 slaveAddress, quint32 modbusRegister, const QVector<quint16> &values);
};
#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);
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) {
info->finish(Thing::ThingErrorNoError);
} else {

4
wallbe/integrationpluginwallbe.h
View File

@ -73,13 +73,9 @@ private:
void update(Thing *thing);
private slots:
void onRefreshTimer();
void onConnectionStateChanged(bool status);
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 onReceivedInputRegister(int slaveAddress, int modbusRegister, int value);
void onWriteRequestExecuted(const QUuid &requestId, bool success);
void onWriteRequestError(const QUuid &requestId, const QString &error);