636 lines
28 KiB
C++
636 lines
28 KiB
C++
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
*
|
|
* 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 "deviceplugindrexelundweiss.h"
|
|
#include "plugininfo.h"
|
|
#include "modbusdegisterdefinition.h"
|
|
|
|
DevicePluginDrexelUndWeiss::DevicePluginDrexelUndWeiss()
|
|
{
|
|
|
|
}
|
|
|
|
DevicePluginDrexelUndWeiss::~DevicePluginDrexelUndWeiss()
|
|
{
|
|
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::init()
|
|
{
|
|
connect(this, &DevicePluginDrexelUndWeiss::configValueChanged, this, &DevicePluginDrexelUndWeiss::onPluginConfigurationChanged);
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::discoverDevices(DeviceDiscoveryInfo *info)
|
|
{
|
|
// Create the list of available serial interfaces
|
|
QList<DeviceDescriptor> deviceDescriptors;
|
|
|
|
if (info->deviceClassId() == modbusConnectionDeviceClassId) {
|
|
Q_FOREACH(QSerialPortInfo port, QSerialPortInfo::availablePorts()) {
|
|
if (m_usedSerialPorts.contains(port.systemLocation())){
|
|
//device already in use
|
|
qCDebug(dcDrexelUndWeiss()) << "Found serial port that is already used:" << port.portName();
|
|
} else {
|
|
//Serial port is not yet used, create now a new one
|
|
qCDebug(dcDrexelUndWeiss()) << "Found serial port:" << port.portName();
|
|
QString description = port.manufacturer() + " " + port.description();
|
|
DeviceDescriptor descriptor(info->deviceClassId(), port.portName(), description);
|
|
ParamList parameters;
|
|
parameters.append(Param(modbusConnectionDeviceSerialPortParamTypeId, port.systemLocation()));
|
|
descriptor.setParams(parameters);
|
|
info->addDeviceDescriptor(descriptor);
|
|
}
|
|
}
|
|
info->finish(Device::DeviceErrorNoError);
|
|
return;
|
|
}
|
|
|
|
if (info->deviceClassId() == x2luDeviceClassId) {
|
|
info->finish(Device::DeviceErrorNoError);
|
|
return;
|
|
}
|
|
|
|
if (info->deviceClassId() == x2wpDeviceClassId) {
|
|
info->finish(Device::DeviceErrorNoError);
|
|
return;
|
|
}
|
|
|
|
info->finish(Device::DeviceErrorDeviceClassNotFound);
|
|
return;
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::setupDevice(DeviceSetupInfo *info)
|
|
{
|
|
Device *device = info->device();
|
|
|
|
if (device->deviceClassId() == modbusConnectionDeviceClassId) {
|
|
|
|
QString serialPort = device->paramValue(modbusConnectionDeviceSerialPortParamTypeId).toString();
|
|
int baudRate = device->paramValue(modbusConnectionDeviceBaudRateParamTypeId).toInt();
|
|
|
|
ModbusRTUMaster *modbus = new ModbusRTUMaster(serialPort, baudRate, QSerialPort::Parity::NoParity, 8, 1, this);
|
|
connect(modbus, &ModbusRTUMaster::connectionStateChanged, this, &DevicePluginDrexelUndWeiss::onConnectionStateChanged);
|
|
connect(modbus, &ModbusRTUMaster::receivedCoil, this, &DevicePluginDrexelUndWeiss::onReceivedCoil);
|
|
connect(modbus, &ModbusRTUMaster::receivedDiscreteInput, this, &DevicePluginDrexelUndWeiss::onReceivedDiscreteInput);
|
|
connect(modbus, &ModbusRTUMaster::receivedHoldingRegister, this, &DevicePluginDrexelUndWeiss::onReceivedHoldingRegister);
|
|
connect(modbus, &ModbusRTUMaster::receivedInputRegister, this, &DevicePluginDrexelUndWeiss::onReceivedInputRegister);
|
|
|
|
|
|
m_modbusRTUMasters.insert(device, modbus);
|
|
m_usedSerialPorts.append(serialPort);
|
|
info->finish(Device::DeviceErrorNoError);
|
|
return;
|
|
}
|
|
|
|
if (device->deviceClassId() == x2luDeviceClassId) {
|
|
info->finish(Device::DeviceErrorNoError);
|
|
return;
|
|
}
|
|
|
|
if (device->deviceClassId() == x2wpDeviceClassId) {
|
|
info->finish(Device::DeviceErrorNoError);
|
|
return;
|
|
}
|
|
info->finish(Device::DeviceErrorDeviceClassNotFound);
|
|
return;
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::postSetupDevice(Device *device)
|
|
{
|
|
if (!m_refreshTimer) {
|
|
// Refresh timer for TCP read
|
|
int refreshTime = configValue(drexelUndWeissPluginUpdateIntervalParamTypeId).toInt();
|
|
m_refreshTimer = hardwareManager()->pluginTimerManager()->registerTimer(refreshTime);
|
|
connect(m_refreshTimer, &PluginTimer::timeout, this, &DevicePluginDrexelUndWeiss::onRefreshTimer);
|
|
}
|
|
|
|
if (device->deviceClassId() == modbusConnectionDeviceClassId) {
|
|
// read Register 5000 and emit auto-device
|
|
ModbusRTUMaster *modbus = m_modbusRTUMasters.value(device);
|
|
if (!modbus){
|
|
qCWarning(dcDrexelUndWeiss()) << "No modbus master available";
|
|
}
|
|
device->setStateValue(modbusConnectionConnectedStateTypeId, true);
|
|
}
|
|
|
|
if ((device->deviceClassId() == x2luDeviceClassId) || (device->deviceClassId() == x2wpDeviceClassId)) {
|
|
Device *parentDevice = myDevices().findById(device->parentId());
|
|
if (!parentDevice) {
|
|
qWarning(dcDrexelUndWeiss()) << "Could not find the parent device";
|
|
return;
|
|
}
|
|
ModbusRTUMaster *modbus = m_modbusRTUMasters.value(parentDevice);
|
|
if (!modbus){
|
|
qCWarning(dcDrexelUndWeiss()) << "No modbus interface available";
|
|
}
|
|
updateStates(device);
|
|
// Update states
|
|
}
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::executeAction(DeviceActionInfo *info)
|
|
{
|
|
Device *device = info->device();
|
|
Action action = info->action();
|
|
|
|
if (device->deviceClassId() == modbusConnectionDeviceClassId) {
|
|
|
|
ModbusRTUMaster *modbus = m_modbusRTUMasters.value(device);
|
|
if (!modbus){
|
|
qCWarning(dcDrexelUndWeiss()) << "No modbus interface available";
|
|
info->finish(Device::DeviceErrorHardwareFailure);
|
|
return;
|
|
}
|
|
|
|
if (action.actionTypeId() == modbusConnectionDiscoverDevicesActionTypeId) {
|
|
int slave = action.param(modbusConnectionDiscoverDevicesActionSlaveAddressParamTypeId).value().toInt();
|
|
discoverModbusSlaves(modbus, slave);
|
|
info->finish(Device::DeviceErrorNoError);
|
|
return;
|
|
}
|
|
info->finish(Device::DeviceErrorActionTypeNotFound);
|
|
return;
|
|
}
|
|
|
|
if (device->deviceClassId() == x2luDeviceClassId) {
|
|
Device *parentDevice = myDevices().findById(device->parentId());
|
|
if (!parentDevice) {
|
|
qWarning(dcDrexelUndWeiss()) << "Could not find the parent device";
|
|
info->finish(Device::DeviceErrorHardwareFailure);
|
|
return;
|
|
}
|
|
ModbusRTUMaster *modbus = m_modbusRTUMasters.value(parentDevice);
|
|
int slave = device->paramValue(x2luDeviceSlaveAddressParamTypeId).toInt();
|
|
if (!modbus){
|
|
qCWarning(dcDrexelUndWeiss()) << "No modbus interface available";
|
|
info->finish(Device::DeviceErrorHardwareFailure);
|
|
return;
|
|
}
|
|
|
|
if (action.actionTypeId() == x2luVentilationModeActionTypeId) {
|
|
QString mode = action.param(x2luVentilationModeActionVentilationModeParamTypeId).value().toString();
|
|
int data = 0;
|
|
|
|
if (mode == "Manual level 0") {
|
|
data = VentialtionMode::ManuellStufe0;
|
|
} else if(mode == "Manual level 1") {
|
|
data = VentialtionMode::ManuellStufe1;
|
|
} else if(mode == "Manual level 2") {
|
|
data = VentialtionMode::ManuellStufe2;
|
|
}else if(mode == "Manual level 3") {
|
|
data = VentialtionMode::ManuellStufe3;
|
|
} else if(mode == "Automatic") {
|
|
data = VentialtionMode::Automatikbetrieb;
|
|
} else if(mode == "Party") {
|
|
data = VentialtionMode::Party;
|
|
}
|
|
m_pendingActions.insert(modbus->writeHoldingRegister(slave, ModbusRegisterX2::Betriebsart, data), info);
|
|
return;
|
|
}
|
|
info->finish(Device::DeviceErrorActionTypeNotFound);
|
|
return;
|
|
}
|
|
|
|
if (device->deviceClassId() == x2wpDeviceClassId) {
|
|
Device *parentDevice = myDevices().findById(device->parentId());
|
|
if (!parentDevice) {
|
|
qWarning(dcDrexelUndWeiss()) << "Could not find modbus interface";
|
|
info->finish(Device::DeviceErrorHardwareFailure);
|
|
return;
|
|
}
|
|
ModbusRTUMaster *modbus = m_modbusRTUMasters.value(parentDevice);
|
|
int slave = device->paramValue(x2wpDeviceSlaveAddressParamTypeId).toInt();
|
|
if (!modbus){
|
|
qCWarning(dcDrexelUndWeiss()) << "No modbus master available";
|
|
info->finish(Device::DeviceErrorHardwareFailure);
|
|
return;
|
|
}
|
|
|
|
if (action.actionTypeId() == x2wpTargetTemperatureActionTypeId) {
|
|
qreal targetTemp = (action.param(x2wpTargetTemperatureActionTargetTemperatureParamTypeId).value().toDouble());
|
|
int data = static_cast<int>(qRound(targetTemp * 1000));
|
|
m_pendingActions.insert(modbus->writeHoldingRegister(slave,ModbusRegisterX2::RaumSoll, data), info);
|
|
return;
|
|
}
|
|
if (action.actionTypeId() == x2wpTargetWaterTemperatureActionTypeId) {
|
|
qreal targetWaterTemp = action.param(x2wpTargetWaterTemperatureActionTargetWaterTemperatureParamTypeId).value().toDouble();
|
|
int data = static_cast<int>(qRound(targetWaterTemp * 1000));
|
|
m_pendingActions.insert(modbus->writeHoldingRegister(slave, ModbusRegisterX2::BrauchwasserSolltermperatur, data), info);
|
|
return;
|
|
}
|
|
info->finish(Device::DeviceErrorActionTypeNotFound);
|
|
return;
|
|
}
|
|
info->finish(Device::DeviceErrorDeviceClassNotFound);
|
|
return;
|
|
}
|
|
|
|
|
|
void DevicePluginDrexelUndWeiss::deviceRemoved(Device *device)
|
|
{
|
|
if (device->deviceClassId() == modbusConnectionDeviceClassId) {
|
|
|
|
ModbusRTUMaster *modbus = m_modbusRTUMasters.take(device);
|
|
if (!modbus){
|
|
qCWarning(dcDrexelUndWeiss()) << "No modbus interface available";
|
|
return;
|
|
}
|
|
m_usedSerialPorts.removeAll(modbus->serialPort());
|
|
modbus->deleteLater();
|
|
}
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::onRefreshTimer()
|
|
{
|
|
foreach (Device *device, myDevices()) {
|
|
|
|
if (device->deviceClassId() == modbusConnectionDeviceClassId) {
|
|
ModbusRTUMaster *modbus = m_modbusRTUMasters.value(device);
|
|
|
|
if (!modbus) {
|
|
qCWarning(dcDrexelUndWeiss()) << "No modbus master available";
|
|
return;
|
|
}
|
|
} else if (device->deviceClassId() == x2luDeviceClassId || device->deviceClassId() == x2wpDeviceClassId){
|
|
updateStates(device);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::updateStates(Device *device)
|
|
{
|
|
if (device->deviceClassId() == x2luDeviceClassId) {
|
|
Device *parent = myDevices().findById(device->parentId());
|
|
ModbusRTUMaster *modbus = m_modbusRTUMasters.value(parent);
|
|
int slave = device->paramValue(x2luDeviceSlaveAddressParamTypeId).toInt();
|
|
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::AktiveLuefterstufe);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::Betriebsart); // Ventilation mode
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::CO2);
|
|
}
|
|
|
|
if (device->deviceClassId() == x2wpDeviceClassId) {
|
|
Device *parent = myDevices().findById(device->parentId());
|
|
ModbusRTUMaster *modbus = m_modbusRTUMasters.value(parent);
|
|
int slave = device->paramValue(x2wpDeviceSlaveAddressParamTypeId).toInt();
|
|
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::Waermepumpe);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::RaumSoll);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::Raum);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::TemperaturWarmwasserspeicherUnten);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::BrauchwasserSolltermperatur);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::Auszenluft);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::Summenstoerung);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::LeistungKompressor);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::LeistungWarmwasser);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::LeistungRaumheizung);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::LeistungLuftvorwaermung);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::EnergieKompressor);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::EnergieWarmwasser);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::EnergieRaumheizung);
|
|
modbus->readHoldingRegister(slave, ModbusRegisterX2::EnergieLuftvorerwarrmung);
|
|
}
|
|
}
|
|
|
|
|
|
void DevicePluginDrexelUndWeiss::onPluginConfigurationChanged(const ParamTypeId ¶mTypeId, const QVariant &value)
|
|
{
|
|
// Check refresh schedule
|
|
if (paramTypeId == drexelUndWeissPluginUpdateIntervalParamTypeId) {
|
|
if (m_refreshTimer) {
|
|
int refreshTime = value.toInt();
|
|
m_refreshTimer->stop();
|
|
m_refreshTimer->startTimer(refreshTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::onConnectionStateChanged(bool status)
|
|
{
|
|
Q_UNUSED(status)
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::onReceivedCoil(int slaveAddress, int modbusRegister, bool value)
|
|
{
|
|
Q_UNUSED(slaveAddress)
|
|
Q_UNUSED(modbusRegister)
|
|
Q_UNUSED(value)
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::onReceivedDiscreteInput(int slaveAddress, int modbusRegister, bool value)
|
|
{
|
|
Q_UNUSED(slaveAddress)
|
|
Q_UNUSED(modbusRegister)
|
|
Q_UNUSED(value)
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::onReceivedHoldingRegister(int slaveAddress, int modbusRegister, int value)
|
|
{
|
|
ModbusRTUMaster *modbus = static_cast<ModbusRTUMaster *>(sender());
|
|
|
|
if (m_modbusRTUMasters.values().contains(modbus) ){
|
|
Device *parentDevice = m_modbusRTUMasters.key(static_cast<ModbusRTUMaster *>(modbus));
|
|
|
|
foreach(Device *device, myDevices().filterByParentDeviceId(parentDevice->id())) {
|
|
if (device->deviceClassId() == x2luDeviceClassId && device->paramValue(x2luDeviceSlaveAddressParamTypeId) == slaveAddress) {
|
|
switch (modbusRegister) {
|
|
case ModbusRegisterX2::Waermepumpe:
|
|
device->setStateValue(x2wpPowerStateTypeId, value);
|
|
break;
|
|
|
|
case ModbusRegisterX2::RaumSoll:
|
|
device->setStateValue(x2wpTargetTemperatureStateTypeId, value/1000.00);
|
|
break;
|
|
|
|
case ModbusRegisterX2::Raum:
|
|
device->setStateValue(x2wpTemperatureStateTypeId, value/1000.00);
|
|
break;
|
|
|
|
case ModbusRegisterX2::TemperaturWarmwasserspeicherUnten:
|
|
device->setStateValue(x2wpWaterTemperatureStateTypeId, value/1000.00);
|
|
break;
|
|
case ModbusRegisterX2::BrauchwasserSolltermperatur:
|
|
device->setStateValue(x2wpTargetWaterTemperatureStateTypeId, value/1000.00);
|
|
break;
|
|
case ModbusRegisterX2::Auszenluft:
|
|
device->setStateValue(x2wpOutsideAirTemperatureStateTypeId, value/1000.00);
|
|
break;
|
|
|
|
case ModbusRegisterX2::Summenstoerung:
|
|
if (value != 0) {
|
|
//get actual error
|
|
} else {
|
|
device->setStateValue(x2wpErrorStateTypeId, "No Error");
|
|
}
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungAbluftventilator:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Exhaust fan");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungBoilerfuehlerElektroheizstab:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Boiler sensor electric heating element");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungBoilerfuehlerSolar:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Boiler sensor solar");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungBoilerfuehlerWaermepumpe:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Boiler sensor heat pump");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungBoileruebertemperatur:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Boiler overtemperature");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungCO2Sensor:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "CO2-Sensor");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungDruckverlustAbluftZuGrosz:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Pressure loss exhaust air too big");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungDruckverlustZuluftZuGrosz:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Pressure loss supply air too large");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungDurchflussmengeHeizgkreis:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Flow rate of heating circuit");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungDurchflussmengeSolekreis:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Flow rate brine circuit");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungTeilnehmerNichtErreichbar:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Participant not available");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungTemperaturfuehlerAuszenluft:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Temperature sensor outside air");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungTemperaturfuehlerHeizkreisVorlauf:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Temperature sensor heating circuit flow");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungTemperaturfuehlerRaum:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Temperature sensor room");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungTemperaturfuehlerSolarkollektor:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Temperature sensor solar collector");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungTemperaturfuehlerSole:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Temperature sensor brine");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungTemperaturfuehlerSoleAuszenluft:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Temperature sensor brine outside air");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungWaermepumpeHochdruck:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Heat pump high pressure");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungWaermepumpeNiederdruck:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Heat pump low pressure");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungWertNichtZulaessig:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Value not allowed");
|
|
break;
|
|
|
|
case ModbusRegisterX2::StoerungZuluftventilator:
|
|
if (value != 0)
|
|
device->setStateValue(x2wpErrorStateTypeId, "Supply air fan");
|
|
break;
|
|
|
|
case ModbusRegisterX2::LeistungKompressor:
|
|
device->setStateValue(x2wpPowerCompressorStateTypeId, value/1000.00);
|
|
break;
|
|
case ModbusRegisterX2::LeistungWarmwasser:
|
|
device->setStateValue(x2wpPowerWaterHeatingStateTypeId, value/1000.00);
|
|
break;
|
|
|
|
case ModbusRegisterX2::LeistungRaumheizung:
|
|
device->setStateValue(x2wpPowerRoomHeatingStateTypeId, value/1000.00);
|
|
break;
|
|
|
|
case ModbusRegisterX2::LeistungLuftvorwaermung:
|
|
device->setStateValue(x2wpPowerAirPreheatingStateTypeId, value/1000.00);
|
|
break;
|
|
|
|
case ModbusRegisterX2::EnergieKompressor:
|
|
device->setStateValue(x2wpEnergyCompressorStateTypeId, value/1000.00);
|
|
break;
|
|
|
|
case ModbusRegisterX2::EnergieWarmwasser:
|
|
device->setStateValue(x2wpEnergyWaterHeatingStateTypeId, value/1000.00);
|
|
break;
|
|
|
|
case ModbusRegisterX2::EnergieRaumheizung:
|
|
device->setStateValue(x2wpEnergyRoomHeatingStateTypeId, value/1000.00);
|
|
break;
|
|
|
|
case ModbusRegisterX2::EnergieLuftvorerwarrmung:
|
|
device->setStateValue(x2wpEnergyAirPreheatingStateTypeId, value/1000.00);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else if (device->deviceClassId() == x2wpDeviceClassId && device->paramValue(x2wpDeviceSlaveAddressParamTypeId) == slaveAddress) {
|
|
|
|
switch (modbusRegister) {
|
|
case ModbusRegisterX2::Betriebsart:
|
|
if (value == VentialtionMode::ManuellStufe0) {
|
|
device->setStateValue(x2luVentilationModeStateTypeId, "Manual level 0");
|
|
} else if (value == VentialtionMode::ManuellStufe1) {
|
|
device->setStateValue(x2luVentilationModeStateTypeId, "Manual level 1");
|
|
} else if (value == VentialtionMode::ManuellStufe2) {
|
|
device->setStateValue(x2luVentilationModeStateTypeId, "Manual level 2");
|
|
} else if (value == VentialtionMode::ManuellStufe3) {
|
|
device->setStateValue(x2luVentilationModeStateTypeId, "Manual level 3");
|
|
} else if (value == VentialtionMode::Automatikbetrieb) {
|
|
device->setStateValue(x2luVentilationModeStateTypeId, "Automatic");
|
|
} else if (value == VentialtionMode::Party) {
|
|
device->setStateValue(x2luVentilationModeStateTypeId, "Party");
|
|
}
|
|
break;
|
|
case ModbusRegisterX2::AktiveLuefterstufe:
|
|
device->setStateValue(x2luActiveVentilationLevelStateTypeId, value);
|
|
break;
|
|
case ModbusRegisterX2::CO2:
|
|
device->setStateValue(x2luCo2StateTypeId, value);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (modbusRegister == ModbusRegisterX2::Geraetetyp) {
|
|
switch (value) {
|
|
case DeviceType::X2_WP: {
|
|
qDebug(dcDrexelUndWeiss()) << "Discovered X2 heat pump";
|
|
QList<DeviceDescriptor> deviceDescriptors;
|
|
DeviceDescriptor descriptor(x2wpDeviceClassId, "X2 WP", "Drexel und Weiss", parentDevice->id());
|
|
ParamList params;
|
|
|
|
//modbus->readHoldingRegister(slaveAddress, ModbusRegisterX2::SoftwareVersion);
|
|
//params.append(Param(x2wpDeviceSofwareVersionParamTypeId, data));
|
|
params.append(Param(x2wpDeviceSlaveAddressParamTypeId, slaveAddress));
|
|
descriptor.setParams(params);
|
|
deviceDescriptors.append(descriptor);
|
|
emit autoDevicesAppeared(deviceDescriptors);
|
|
break;
|
|
}
|
|
case DeviceType::X2_LU: {
|
|
qDebug(dcDrexelUndWeiss()) << "Discovered X2 ventilation unit";
|
|
QList<DeviceDescriptor> deviceDescriptors;
|
|
DeviceDescriptor descriptor(x2luDeviceClassId, "X2 LU", "Drexel und Weiss", parentDevice->id());
|
|
ParamList params;
|
|
|
|
//modbus->readHoldingRegister(slaveAddress, ModbusRegisterX2::SoftwareVersion);
|
|
//params.append(Param(x2luDeviceSofwareVersionParamTypeId, data));
|
|
params.append(Param(x2luDeviceSlaveAddressParamTypeId, slaveAddress));
|
|
descriptor.setParams(params);
|
|
deviceDescriptors.append(descriptor);
|
|
emit autoDevicesAppeared(deviceDescriptors);
|
|
break;
|
|
}
|
|
case DeviceType::AerosilentBianco:
|
|
//Just a test
|
|
qDebug(dcDrexelUndWeiss()) << "Discovered Aerosilent Bianco";
|
|
break;
|
|
default:
|
|
qDebug(dcDrexelUndWeiss()) << "Unkown Devicetype" << value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::onReceivedInputRegister(int slaveAddress, int modbusRegister, int value)
|
|
{
|
|
Q_UNUSED(slaveAddress)
|
|
Q_UNUSED(modbusRegister)
|
|
Q_UNUSED(value)
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::onWriteRequestFinished(QUuid requestId, bool success)
|
|
{
|
|
DeviceActionInfo *info = m_pendingActions.take(requestId);
|
|
if (!info)
|
|
return;
|
|
|
|
if (success) {
|
|
info->finish(Device::DeviceErrorNoError);
|
|
} else {
|
|
info->finish(Device::DeviceErrorHardwareFailure);
|
|
}
|
|
}
|
|
|
|
void DevicePluginDrexelUndWeiss::discoverModbusSlaves(ModbusRTUMaster *modbus, int slaveAddress)
|
|
{
|
|
foreach (Device *device, myDevices()) {
|
|
if (device->deviceClassId() == x2luDeviceClassId) {
|
|
if (device->paramValue(x2luDeviceSlaveAddressParamTypeId).toInt() == slaveAddress) {
|
|
qWarning(dcDrexelUndWeiss()) << "Device with slave address" << slaveAddress << "already added";
|
|
return;
|
|
}
|
|
}
|
|
if (device->deviceClassId() == x2wpDeviceClassId) {
|
|
if (device->paramValue(x2wpDeviceSlaveAddressParamTypeId).toInt() == slaveAddress) {
|
|
qWarning(dcDrexelUndWeiss()) << "Device with slave address" << slaveAddress << "already added";
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
modbus->readHoldingRegister(slaveAddress, ModbusRegisterX2::Geraetetyp);
|
|
}
|