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

supporting now wall thermostat and radiator thermostat (auto device)

Browse Source 
added actions (auto, manuel, eco mode...)
This commit is contained in:
Simon Stürz 2014-08-03 01:18:16 +02:00 committed by Michael Zanetti
parent b283725314
commit 5d69c20d80
5 changed files with 798 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

550
plugins/deviceplugins/eq-3/deviceplugineq-3.cpp
View File

@ -24,12 +24,50 @@
#include <QDebug>
VendorId maxVendorId = VendorId("2cac0645-855e-44fa-837e-1cab0ae4304c");
VendorId eq3VendorId = VendorId("2cac0645-855e-44fa-837e-1cab0ae4304c");
PluginId eq3PluginUuid = PluginId("f324c43c-9680-48d8-852a-93b2227139b9");
DeviceClassId cubeDeviceClassId = DeviceClassId("1e892268-8bd7-442c-a001-bd4e2e6b2949");
StateTypeId connectionStateTypeId = StateTypeId("d0a9a369-cf8c-47c4-a12e-f2d076bf12fd");
StateTypeId portalEnabeldStateTypeId = StateTypeId("2c2367da-c229-40ed-9d47-a6e73cd6dc3b");
DeviceClassId wallThermostateDeviceClassId = DeviceClassId("ffbfec5d-06e8-4082-b62b-92cc5c3e8c4e");
StateTypeId confortTempStateTypeId = StateTypeId("850380ee-a787-43e7-adb8-768a21a6e64d");
StateTypeId ecoTempStateTypeId = StateTypeId("24dfd20d-bc8d-48e4-8162-b20ae0465c41");
StateTypeId maxSetpointTempStateTypeId = StateTypeId("a8536ddf-a6e4-41c2-89c1-e7102608f5f6");
StateTypeId minSetpointTempStateTypeId = StateTypeId("ceb0ad05-37ad-4b79-a4d9-540c34a7e3e4");
StateTypeId errorOccuredStateTypeId = StateTypeId("9880247b-cf9a-453c-b0c3-d910eba8a253");
StateTypeId initializedStateTypeId = StateTypeId("a9e29f03-063e-4686-8aac-2f6d8f8a4937");
StateTypeId batteryLowStateTypeId = StateTypeId("53b89f32-8894-4290-92a0-6a470c6b69ab");
StateTypeId linkStatusOKStateTypeId = StateTypeId("aff38be8-7ea6-4fd8-b0fa-e987ab05c719");
StateTypeId panelLockedStateTypeId = StateTypeId("979df197-09a1-46f9-9217-9d323b1062bd");
StateTypeId gatewayKnownStateTypeId = StateTypeId("1d6bd962-5c31-47ad-80a4-dda87bff98f5");
StateTypeId dtsActiveStateTypeId = StateTypeId("1b402ba6-a8ae-45b1-8acf-2b0a89f71889");
StateTypeId deviceModeStateTypeId = StateTypeId("639360f0-bb65-43e6-b227-50ae0ac39d6c");
StateTypeId deviceModeStringStateTypeId = StateTypeId("ff5194e3-5641-4ac2-92c7-48c431b4a2eb");
StateTypeId setpointTempStateTypeId = StateTypeId("579aa8c6-8814-491b-9e7c-b98108c323d1");
StateTypeId currentTemperatureStateTypeId = StateTypeId("852e7708-db1d-42d1-96e4-19c13598262c");
ActionTypeId setSetpointTemperatureActionTypeId = ActionTypeId("9c1968ba-39f9-493d-9fe2-848fa86bd2f0");
ActionTypeId setAutoModeActionTypeId = ActionTypeId("162b4b3d-9923-4f2c-a755-b50c8a06a6f0");
ActionTypeId setManuelModeActionTypeId = ActionTypeId("8e604437-9f5b-4c17-b5b0-e2db6007af5b");
ActionTypeId setEcoModeActionTypeId = ActionTypeId("27a981e8-ec23-4ba8-921e-33b911a7dd89");
ActionTypeId displayCurrentTempActionTypeId = ActionTypeId("184fb112-7a03-4560-8634-0257c969c26e");
DeviceClassId radiatorThermostateDeviceClassId = DeviceClassId("f80d9481-4827-45ee-a013-b97b22412d92");
StateTypeId valvePositionStateTypeId = StateTypeId("72956000-0203-4c32-a6b6-3bb7e46c03ca");
StateTypeId offsetTempStateTypeId = StateTypeId("576da571-9a65-478f-96bf-19256c8b9ece");
StateTypeId windowOpenDurationStateTypeId = StateTypeId("81c6c74a-b0cd-4daa-9eb9-f1cd68f328af");
StateTypeId boostValueValueStateTypeId = StateTypeId("7c41fa64-b1a1-48d2-9d03-67aa16cd83ad");
StateTypeId boostDurationStateTypeId = StateTypeId("e75c1398-9ad7-466c-b3b9-b03bbb686a30");
StateTypeId discalcWeekDayStateTypeId = StateTypeId("bd6f5947-d4b4-444b-81c8-77eec46957e4");
StateTypeId discalcTimeStateTypeId = StateTypeId("e78235ee-affc-41e3-a463-9f0512b4a6c3");
StateTypeId valveMaximumSettingsStateTypeId = StateTypeId("e367fa3a-b30f-49bd-af3f-cff92360ad32");
StateTypeId valveOffsetStateTypeId = StateTypeId("ffaff87b-b741-4db8-9875-3380af4f1885");
DevicePluginEQ3::DevicePluginEQ3()
{
@ -41,8 +79,8 @@ DevicePluginEQ3::DevicePluginEQ3()
QList<Vendor> DevicePluginEQ3::supportedVendors() const
{
QList<Vendor> ret;
Vendor max(maxVendorId, "Max!");
ret.append(max);
Vendor eq3(eq3VendorId, "eQ-3");
ret.append(eq3);
return ret;
}
@ -50,8 +88,9 @@ QList<DeviceClass> DevicePluginEQ3::supportedDevices() const
{
QList<DeviceClass> ret;
// ===========================================
// Cube
DeviceClass cubeDeviceClass(pluginId(),maxVendorId,cubeDeviceClassId);
DeviceClass cubeDeviceClass(pluginId(),eq3VendorId,cubeDeviceClassId);
cubeDeviceClass.setName("Max! Cube LAN Gateway");
cubeDeviceClass.setCreateMethod(DeviceClass::CreateMethodDiscovery);
cubeDeviceClass.setSetupMethod(DeviceClass::SetupMethodJustAdd);
@ -74,15 +113,277 @@ QList<DeviceClass> DevicePluginEQ3::supportedDevices() const
// States
QList<StateType> states;
StateType connected(connectionStateTypeId);
connected.setName("connected");
connected.setType(QVariant::Bool);
connected.setDefaultValue(false);
states.append(connected);
StateType connectedState(connectionStateTypeId);
connectedState.setName("connected");
connectedState.setType(QVariant::Bool);
connectedState.setDefaultValue(false);
states.append(connectedState);
StateType portalEnabeld(portalEnabeldStateTypeId);
portalEnabeld.setName("portal enabled");
portalEnabeld.setType(QVariant::Bool);
portalEnabeld.setDefaultValue(false);
states.append(portalEnabeld);
cubeDeviceClass.setStateTypes(states);
// ===========================================
// Wall thermostate
DeviceClass wallThermostateDeviceClass(pluginId(), eq3VendorId, wallThermostateDeviceClassId);
wallThermostateDeviceClass.setName("Max! Wall Thermostat");
wallThermostateDeviceClass.setCreateMethod(DeviceClass::CreateMethodAuto);
// Params
QList<ParamType> paramsWallThermostate;
paramsWallThermostate.append(serialNumberParam);
ParamType deviceName("name",QVariant::String);
paramsWallThermostate.append(deviceName);
ParamType parentCube("parent cube",QVariant::String);
paramsWallThermostate.append(parentCube);
ParamType rfAddress("rf address",QVariant::String);
paramsWallThermostate.append(rfAddress);
ParamType roomNumber("room id",QVariant::Int);
paramsWallThermostate.append(roomNumber);
ParamType roomName("room name",QVariant::String);
paramsWallThermostate.append(roomName);
wallThermostateDeviceClass.setParamTypes(paramsWallThermostate);
// Actions
QList<ActionType> actions;
ActionType setSetpointTemp(setSetpointTemperatureActionTypeId);
setSetpointTemp.setName("set setpoint temperature [Celsius]");
QList<ParamType> actionParamsSetSetpointTemp;
ParamType actionParamSetpointTemperature("setpoint temperature", QVariant::Double);
actionParamsSetSetpointTemp.append(actionParamSetpointTemperature);
setSetpointTemp.setParameters(actionParamsSetSetpointTemp);
actions.append(setSetpointTemp);
ActionType setAutoMode(setAutoModeActionTypeId);
setAutoMode.setName("set Auto mode");
actions.append(setAutoMode);
ActionType setManuelMode(setManuelModeActionTypeId);
setManuelMode.setName("set Manuel mode");
actions.append(setAutoMode);
ActionType setEcoMode(setEcoModeActionTypeId);
setEcoMode.setName("set Eco mode");
actions.append(setEcoMode);
ActionType displayCurrentTemp(displayCurrentTempActionTypeId);
displayCurrentTemp.setName("display current temperature");
QList<ParamType> actionParamsDisplayCurrentTemp;
ParamType actionParamDisplayCurrentTemp("display", QVariant::Bool);
actionParamsDisplayCurrentTemp.append(actionParamDisplayCurrentTemp);
displayCurrentTemp.setParameters(actionParamsDisplayCurrentTemp);
actions.append(displayCurrentTemp);
wallThermostateDeviceClass.setActions(actions);
// States
QList<StateType> statesWallThermostat;
StateType confortTemp(confortTempStateTypeId);
confortTemp.setName("confort temperature [Celsius]");
confortTemp.setType(QVariant::Double);
confortTemp.setDefaultValue(0.0);
statesWallThermostat.append(confortTemp);
StateType ecoTemp(ecoTempStateTypeId);
ecoTemp.setName("eco temperature [Celsius]");
ecoTemp.setType(QVariant::Double);
ecoTemp.setDefaultValue(0.0);
statesWallThermostat.append(ecoTemp);
StateType minSetpointTemp(minSetpointTempStateTypeId);
minSetpointTemp.setName("min setpoint temperature [Celsius]");
minSetpointTemp.setType(QVariant::Double);
minSetpointTemp.setDefaultValue(0.0);
statesWallThermostat.append(minSetpointTemp);
StateType maxSetpointTemp(maxSetpointTempStateTypeId);
maxSetpointTemp.setName("max setpoint temperature [Celsius]");
maxSetpointTemp.setType(QVariant::Double);
maxSetpointTemp.setDefaultValue(0.0);
statesWallThermostat.append(maxSetpointTemp);
StateType errorOccured(errorOccuredStateTypeId);
errorOccured.setName("error occured");
errorOccured.setType(QVariant::Bool);
errorOccured.setDefaultValue(false);
statesWallThermostat.append(errorOccured);
StateType initialized(initializedStateTypeId);
initialized.setName("initialized");
initialized.setType(QVariant::Bool);
initialized.setDefaultValue(false);
statesWallThermostat.append(initialized);
StateType batteryLow(batteryLowStateTypeId);
batteryLow.setName("battery low");
batteryLow.setType(QVariant::Bool);
batteryLow.setDefaultValue(false);
statesWallThermostat.append(batteryLow);
StateType linkStatusOK(linkStatusOKStateTypeId);
linkStatusOK.setName("link status to cube");
linkStatusOK.setType(QVariant::Bool);
linkStatusOK.setDefaultValue(false);
statesWallThermostat.append(linkStatusOK);
StateType panelLocked(panelLockedStateTypeId);
panelLocked.setName("pannel locked");
panelLocked.setType(QVariant::Bool);
panelLocked.setDefaultValue(false);
statesWallThermostat.append(panelLocked);
StateType gatewayKnown(gatewayKnownStateTypeId);
gatewayKnown.setName("gateway knows");
gatewayKnown.setType(QVariant::Bool);
gatewayKnown.setDefaultValue(false);
statesWallThermostat.append(gatewayKnown);
StateType dtsActive(dtsActiveStateTypeId);
dtsActive.setName("DTS active");
dtsActive.setType(QVariant::Bool);
dtsActive.setDefaultValue(false);
statesWallThermostat.append(dtsActive);
StateType deviceMode(deviceModeStateTypeId);
deviceMode.setName("device mode");
deviceMode.setType(QVariant::Int);
deviceMode.setDefaultValue(-1);
statesWallThermostat.append(deviceMode);
StateType deviceModeString(deviceModeStringStateTypeId);
deviceModeString.setName("device mode string");
deviceModeString.setType(QVariant::String);
deviceModeString.setDefaultValue("");
statesWallThermostat.append(deviceModeString);
StateType setpointTemp(setpointTempStateTypeId);
setpointTemp.setName("setpoint temperature [Celsius]");
setpointTemp.setType(QVariant::Double);
setpointTemp.setDefaultValue("0.0");
statesWallThermostat.append(setpointTemp);
StateType currentTemp(currentTemperatureStateTypeId);
currentTemp.setName("current temperature [Celsius]");
currentTemp.setType(QVariant::Double);
currentTemp.setDefaultValue(0.0);
statesWallThermostat.append(currentTemp);
wallThermostateDeviceClass.setStateTypes(statesWallThermostat);
// ===========================================
// Radiator thermostat
DeviceClass radiatorThermostateDeviceClass(pluginId(), eq3VendorId, radiatorThermostateDeviceClassId);
radiatorThermostateDeviceClass.setName("Max! Radiator Thermostat");
radiatorThermostateDeviceClass.setCreateMethod(DeviceClass::CreateMethodAuto);
// Params
QList<ParamType> paramsRadiatorThermostate;
paramsRadiatorThermostate.append(serialNumberParam);
paramsRadiatorThermostate.append(deviceName);
paramsRadiatorThermostate.append(parentCube);
paramsRadiatorThermostate.append(rfAddress);
paramsRadiatorThermostate.append(roomNumber);
paramsWallThermostate.append(roomName);
radiatorThermostateDeviceClass.setParamTypes(paramsRadiatorThermostate);
// Actions
QList<ActionType> actionsRadiator;
actionsRadiator.append(setSetpointTemp);
actionsRadiator.append(setAutoMode);
actionsRadiator.append(setManuelMode);
actionsRadiator.append(setEcoMode);
radiatorThermostateDeviceClass.setActions(actionsRadiator);
// States
QList<StateType> statesRadiatorThermostat;
statesRadiatorThermostat.append(confortTemp);
statesRadiatorThermostat.append(ecoTemp);
statesRadiatorThermostat.append(minSetpointTemp);
statesRadiatorThermostat.append(maxSetpointTemp);
statesRadiatorThermostat.append(errorOccured);
statesRadiatorThermostat.append(initialized);
statesRadiatorThermostat.append(batteryLow);
statesRadiatorThermostat.append(linkStatusOK);
statesRadiatorThermostat.append(gatewayKnown);
statesRadiatorThermostat.append(dtsActive);
statesRadiatorThermostat.append(deviceMode);
statesRadiatorThermostat.append(deviceModeString);
statesRadiatorThermostat.append(setpointTemp);
StateType offsetTemp(offsetTempStateTypeId);
offsetTemp.setName("offset temperature [Celsius]");
offsetTemp.setType(QVariant::Double);
offsetTemp.setDefaultValue(0.0);
statesRadiatorThermostat.append(offsetTemp);
StateType windowOpenDuration(windowOpenDurationStateTypeId);
windowOpenDuration.setName("window open duration [Minutes]");
windowOpenDuration.setType(QVariant::Int);
windowOpenDuration.setDefaultValue(0);
statesRadiatorThermostat.append(windowOpenDuration);
StateType boostValveValue(boostValueValueStateTypeId);
boostValveValue.setName("boost valve value [%]");
boostValveValue.setType(QVariant::Int);
boostValveValue.setDefaultValue(0);
statesRadiatorThermostat.append(boostValveValue);
StateType boostDuration(boostDurationStateTypeId);
boostDuration.setName("boost duration [Minutes]");
boostDuration.setType(QVariant::Int);
boostDuration.setDefaultValue(0);
statesRadiatorThermostat.append(boostDuration);
StateType discalcWeekDay(discalcWeekDayStateTypeId);
discalcWeekDay.setName("discalc day");
discalcWeekDay.setType(QVariant::String);
discalcWeekDay.setDefaultValue("");
statesRadiatorThermostat.append(discalcWeekDay);
StateType discalcTime(discalcTimeStateTypeId);
discalcTime.setName("discalc time");
discalcTime.setType(QVariant::String);
discalcTime.setDefaultValue("");
statesRadiatorThermostat.append(discalcTime);
StateType maxValveSettings(valveMaximumSettingsStateTypeId);
maxValveSettings.setName("valve maximum settings");
maxValveSettings.setType(QVariant::Double);
maxValveSettings.setDefaultValue(0.0);
statesRadiatorThermostat.append(maxValveSettings);
StateType valveOffset(valveOffsetStateTypeId);
valveOffset.setName("valve offset [%]");
valveOffset.setType(QVariant::Int);
valveOffset.setDefaultValue(0);
statesRadiatorThermostat.append(valveOffset);
radiatorThermostateDeviceClass.setStateTypes(statesRadiatorThermostat);
ret.append(cubeDeviceClass);
ret.append(wallThermostateDeviceClass);
ret.append(radiatorThermostateDeviceClass);
return ret;
}
@ -117,25 +418,43 @@ QPair<DeviceManager::DeviceError, QString> DevicePluginEQ3::discoverDevices(cons
return report(DeviceManager::DeviceErrorDeviceClassNotFound);
}
void DevicePluginEQ3::startMonitoringAutoDevices()
{
}
QPair<DeviceManager::DeviceSetupStatus, QString> DevicePluginEQ3::setupDevice(Device *device)
{
qDebug() << "setupDevice" << device->params();
foreach (MaxCube *cube, m_cubes.keys()) {
if(cube->serialNumber() == device->paramValue("serial number").toString()){
qDebug() << cube->serialNumber() << " allready exists...";
return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure,QString("Cube allready in added"));
if(device->deviceClassId() == cubeDeviceClassId){
foreach (MaxCube *cube, m_cubes.keys()) {
if(cube->serialNumber() == device->paramValue("serial number").toString()){
qDebug() << cube->serialNumber() << " allready exists...";
return reportDeviceSetup(DeviceManager::DeviceSetupStatusFailure,QString("Cube allready in added"));
}
}
MaxCube *cube = new MaxCube(this,device->paramValue("serial number").toString(),QHostAddress(device->paramValue("host address").toString()),device->paramValue("port").toInt());
m_cubes.insert(cube,device);
connect(cube,SIGNAL(cubeConnectionStatusChanged(bool)),this,SLOT(cubeConnectionStatusChanged(bool)));
connect(cube,SIGNAL(commandActionFinished(bool,ActionId)),this,SLOT(commandActionFinished(bool,ActionId)));
connect(cube,SIGNAL(cubeConfigReady()),this,SLOT(updateCubeConfig()));
connect(cube,SIGNAL(wallThermostatFound()),this,SLOT(wallThermostatFound()));
connect(cube,SIGNAL(wallThermostatDataUpdated()),this,SLOT(wallThermostatDataUpdated()));
connect(cube,SIGNAL(radiatorThermostatFound()),this,SLOT(radiatorThermostatFound()));
connect(cube,SIGNAL(radiatorThermostatDataUpdated()),this,SLOT(radiatorThermostatDataUpdated()));
cube->connectToCube();
return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync);
}
if(device->deviceClassId() == wallThermostateDeviceClassId){
device->setName("Max! Wall Thermostat (" + device->paramValue("serial number").toString() + ")");
}
MaxCube *cube = new MaxCube(this,device->paramValue("serial number").toString(),QHostAddress(device->paramValue("host address").toString()),device->paramValue("port").toInt());
m_cubes.insert(cube,device);
connect(cube,SIGNAL(cubeConnectionStatusChanged(bool)),this,SLOT(cubeConnectionStatusChanged(bool)));
cube->connectToCube();
return reportDeviceSetup(DeviceManager::DeviceSetupStatusAsync);
return reportDeviceSetup();
}
void DevicePluginEQ3::deviceRemoved(Device *device)
@ -153,14 +472,43 @@ void DevicePluginEQ3::deviceRemoved(Device *device)
void DevicePluginEQ3::guhTimer()
{
foreach (MaxCube *cube, m_cubes.keys()) {
cube->refresh();
foreach (MaxCube *cube, m_cubes.keys()){
if(cube->isConnected() && cube->isInitialized()){
cube->refresh();
}
}
}
QPair<DeviceManager::DeviceError, QString> DevicePluginEQ3::executeAction(Device *device, const Action &action)
{
{
if(device->deviceClassId() == wallThermostateDeviceClassId || device->deviceClassId() == radiatorThermostateDeviceClassId){
foreach (MaxCube *cube, m_cubes.keys()){
if(cube->serialNumber() == device->paramValue("parent cube").toString()){
if (action.actionTypeId() == setSetpointTemperatureActionTypeId){
cube->setDeviceSetpointTemp(device->paramValue("rf address").toByteArray(), device->paramValue("room id").toInt(), action.param("setpoint temperature").value().toDouble(), action.id());
return report(DeviceManager::DeviceErrorAsync,QString());
}
if (action.actionTypeId() == setAutoModeActionTypeId){
cube->setDeviceAutoMode(device->paramValue("rf address").toByteArray(), device->paramValue("room id").toInt(), action.id());
return report(DeviceManager::DeviceErrorAsync,QString());
}
if (action.actionTypeId() == setManuelModeActionTypeId){
cube->setDeviceManuelMode(device->paramValue("rf address").toByteArray(), device->paramValue("room id").toInt(), action.id());
return report(DeviceManager::DeviceErrorAsync,QString());
}
if (action.actionTypeId() == setEcoModeActionTypeId){
cube->setDeviceEcoMode(device->paramValue("rf address").toByteArray(), device->paramValue("room id").toInt(), action.id());
return report(DeviceManager::DeviceErrorAsync,QString());
}
if (action.actionTypeId() == displayCurrentTempActionTypeId){
cube->displayCurrentTemperature(device->paramValue("rf address").toByteArray(), device->paramValue("room id").toInt(), action.param("display").value().toBool(), action.id());
return report(DeviceManager::DeviceErrorAsync,QString());
}
}
}
}
return report(DeviceManager::DeviceErrorActionTypeNotFound,QString());
}
void DevicePluginEQ3::cubeConnectionStatusChanged(const bool &connected)
@ -179,7 +527,8 @@ void DevicePluginEQ3::cubeConnectionStatusChanged(const bool &connected)
Device *device;
if (m_cubes.contains(cube)){
device = m_cubes.value(cube);
device->setStateValue(connectionStateTypeId,true);
device->setStateValue(connectionStateTypeId,false);
emit deviceSetupFinished(device, DeviceManager::DeviceSetupStatusFailure, QString("Could not connect to cube."));
}
}
}
@ -204,3 +553,154 @@ void DevicePluginEQ3::discoveryDone(const QList<MaxCube *> &cubeList)
}
emit devicesDiscovered(cubeDeviceClassId,retList);
}
void DevicePluginEQ3::commandActionFinished(const bool &succeeded, const ActionId &actionId)
{
if(succeeded){
emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorNoError,QString());
}else{
emit actionExecutionFinished(actionId, DeviceManager::DeviceErrorSetupFailed,QString("Could not execute action on cube, unknown error"));
}
}
void DevicePluginEQ3::wallThermostatFound()
{
MaxCube *cube = static_cast<MaxCube*>(sender());
QList<DeviceDescriptor> descriptorList;
foreach (WallThermostat *wallThermostat, cube->wallThermostatList()) {
bool allreadyAdded = false;
foreach (Device *device, deviceManager()->findConfiguredDevices(wallThermostateDeviceClassId)){
if(wallThermostat->serialNumber() == device->paramValue("serial number").toString()){
allreadyAdded = true;
break;
}
}
if(!allreadyAdded){
DeviceDescriptor descriptor(wallThermostateDeviceClassId, wallThermostat->serialNumber());
ParamList params;
params.append(Param("name", wallThermostat->deviceName()));
params.append(Param("parent cube", cube->serialNumber()));
params.append(Param("serial number", wallThermostat->serialNumber()));
params.append(Param("rf address", wallThermostat->rfAddress()));
params.append(Param("room id", wallThermostat->roomId()));
params.append(Param("room name", wallThermostat->roomName()));
descriptor.setParams(params);
descriptorList.append(descriptor);
}
}
if(!descriptorList.isEmpty()){
metaObject()->invokeMethod(this, "autoDevicesAppeared", Qt::QueuedConnection, Q_ARG(DeviceClassId, wallThermostateDeviceClassId), Q_ARG(QList<DeviceDescriptor>, descriptorList));
}
}
void DevicePluginEQ3::radiatorThermostatFound()
{
MaxCube *cube = static_cast<MaxCube*>(sender());
QList<DeviceDescriptor> descriptorList;
foreach (RadiatorThermostat *radiatorThermostat, cube->radiatorThermostatList()) {
bool allreadyAdded = false;
foreach (Device *device, deviceManager()->findConfiguredDevices(radiatorThermostateDeviceClassId)){
if(radiatorThermostat->serialNumber() == device->paramValue("serial number").toString()){
allreadyAdded = true;
break;
}
}
if(!allreadyAdded){
DeviceDescriptor descriptor(radiatorThermostateDeviceClassId, radiatorThermostat->serialNumber());
ParamList params;
params.append(Param("name", radiatorThermostat->deviceName()));
params.append(Param("parent cube", cube->serialNumber()));
params.append(Param("serial number", radiatorThermostat->serialNumber()));
params.append(Param("rf address", radiatorThermostat->rfAddress()));
params.append(Param("room id", radiatorThermostat->roomId()));
params.append(Param("room name", radiatorThermostat->roomName()));
descriptor.setParams(params);
descriptorList.append(descriptor);
}
}
if(!descriptorList.isEmpty()){
metaObject()->invokeMethod(this, "autoDevicesAppeared", Qt::QueuedConnection, Q_ARG(DeviceClassId, radiatorThermostateDeviceClassId), Q_ARG(QList<DeviceDescriptor>, descriptorList));
}
}
void DevicePluginEQ3::updateCubeConfig()
{
MaxCube *cube = static_cast<MaxCube*>(sender());
Device *device;
if (m_cubes.contains(cube)) {
device = m_cubes.value(cube);
device->setStateValue(portalEnabeldStateTypeId,cube->portalEnabeld());
return;
}
}
void DevicePluginEQ3::wallThermostatDataUpdated()
{
MaxCube *cube = static_cast<MaxCube*>(sender());
foreach (WallThermostat *wallThermostat, cube->wallThermostatList()) {
foreach (Device *device, deviceManager()->findConfiguredDevices(wallThermostateDeviceClassId)){
if(device->paramValue("serial number").toString() == wallThermostat->serialNumber()){
device->setStateValue(confortTempStateTypeId, wallThermostat->confortTemp());
device->setStateValue(ecoTempStateTypeId, wallThermostat->ecoTemp());
device->setStateValue(maxSetpointTempStateTypeId, wallThermostat->maxSetPointTemp());
device->setStateValue(minSetpointTempStateTypeId, wallThermostat->minSetPointTemp());
device->setStateValue(errorOccuredStateTypeId, wallThermostat->errorOccured());
device->setStateValue(initializedStateTypeId, wallThermostat->initialized());
device->setStateValue(batteryLowStateTypeId, wallThermostat->batteryLow());
device->setStateValue(linkStatusOKStateTypeId, wallThermostat->linkStatusOK());
device->setStateValue(panelLockedStateTypeId, wallThermostat->panelLocked());
device->setStateValue(gatewayKnownStateTypeId, wallThermostat->gatewayKnown());
device->setStateValue(dtsActiveStateTypeId, wallThermostat->dtsActive());
device->setStateValue(deviceModeStateTypeId, wallThermostat->deviceMode());
device->setStateValue(deviceModeStringStateTypeId, wallThermostat->deviceModeString());
device->setStateValue(setpointTempStateTypeId, wallThermostat->setpointTemperature());
device->setStateValue(currentTemperatureStateTypeId, wallThermostat->currentTemperature());
}
}
}
}
void DevicePluginEQ3::radiatorThermostatDataUpdated()
{
MaxCube *cube = static_cast<MaxCube*>(sender());
foreach (RadiatorThermostat *radiatorThermostat, cube->radiatorThermostatList()) {
foreach (Device *device, deviceManager()->findConfiguredDevices(radiatorThermostateDeviceClassId)){
if(device->paramValue("serial number").toString() == radiatorThermostat->serialNumber()){
device->setStateValue(confortTempStateTypeId, radiatorThermostat->confortTemp());
device->setStateValue(ecoTempStateTypeId, radiatorThermostat->ecoTemp());
device->setStateValue(maxSetpointTempStateTypeId, radiatorThermostat->maxSetPointTemp());
device->setStateValue(minSetpointTempStateTypeId, radiatorThermostat->minSetPointTemp());
device->setStateValue(errorOccuredStateTypeId, radiatorThermostat->errorOccured());
device->setStateValue(initializedStateTypeId, radiatorThermostat->initialized());
device->setStateValue(batteryLowStateTypeId, radiatorThermostat->batteryLow());
device->setStateValue(linkStatusOKStateTypeId, radiatorThermostat->linkStatusOK());
device->setStateValue(panelLockedStateTypeId, radiatorThermostat->panelLocked());
device->setStateValue(gatewayKnownStateTypeId, radiatorThermostat->gatewayKnown());
device->setStateValue(dtsActiveStateTypeId, radiatorThermostat->dtsActive());
device->setStateValue(deviceModeStateTypeId, radiatorThermostat->deviceMode());
device->setStateValue(deviceModeStringStateTypeId, radiatorThermostat->deviceModeString());
device->setStateValue(setpointTempStateTypeId, radiatorThermostat->setpointTemperature());
device->setStateValue(offsetTempStateTypeId, radiatorThermostat->offsetTemp());
device->setStateValue(windowOpenDurationStateTypeId, radiatorThermostat->windowOpenDuration());
device->setStateValue(boostValueValueStateTypeId, radiatorThermostat->boostValveValue());
device->setStateValue(boostDurationStateTypeId, radiatorThermostat->boostDuration());
device->setStateValue(discalcWeekDayStateTypeId, radiatorThermostat->discalcingWeekDay());
device->setStateValue(discalcTimeStateTypeId, radiatorThermostat->discalcingTime().toString("HH:mm"));
device->setStateValue(valveMaximumSettingsStateTypeId, radiatorThermostat->valveMaximumSettings());
device->setStateValue(valveOffsetStateTypeId, radiatorThermostat->valveOffset());
device->setStateValue(valvePositionStateTypeId, radiatorThermostat->valvePosition());
}
}
}
}

13
plugins/deviceplugins/eq-3/deviceplugineq-3.h
View File

@ -46,9 +46,10 @@ public:
QList<ParamType> configurationDescription() const override;
QPair<DeviceManager::DeviceError, QString> discoverDevices(const DeviceClassId &deviceClassId, const ParamList &params) override;
void startMonitoringAutoDevices() override;
QPair<DeviceManager::DeviceSetupStatus, QString> setupDevice(Device *device) override;
void deviceRemoved(Device *device) override;
void guhTimer() override;
private:
@ -56,14 +57,20 @@ private:
MaxCubeDiscovery *m_cubeDiscovery;
QHash<MaxCube*, Device*> m_cubes;
public slots:
QPair<DeviceManager::DeviceError, QString> executeAction(Device *device, const Action &action);
void cubeConnectionStatusChanged(const bool &connected);
private slots:
void cubeConnectionStatusChanged(const bool &connected);
void discoveryDone(const QList<MaxCube *> &cubeList);
void commandActionFinished(const bool &succeeded, const ActionId &actionId);
void wallThermostatFound();
void radiatorThermostatFound();
void updateCubeConfig();
void wallThermostatDataUpdated();
void radiatorThermostatDataUpdated();
};

334
plugins/deviceplugins/eq-3/maxcube.cpp
View File

@ -24,8 +24,7 @@ MaxCube::MaxCube(QObject *parent, QString serialNumber, QHostAddress hostAdress,
m_cubeInitialized = false;
connect(this,SIGNAL(connected()),this,SLOT(connected()));
connect(this,SIGNAL(disconnected()),this,SLOT(disconnected()));
connect(this,SIGNAL(stateChanged(QAbstractSocket::SocketState)),this,SLOT(connectionStateChanged(QAbstractSocket::SocketState)));
connect(this,SIGNAL(readyRead()),this,SLOT(readData()));
connect(this,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(error(QAbstractSocket::SocketError)));
@ -131,6 +130,19 @@ bool MaxCube::sendData(QByteArray data)
return true;
}
bool MaxCube::isConnected()
{
if(state() == QAbstractSocket::ConnectedState){
return true;
}
return false;
}
bool MaxCube::isInitialized()
{
return m_cubeInitialized;
}
void MaxCube::decodeHelloMessage(QByteArray data)
{
QList<QByteArray> list = data.split(',');
@ -139,25 +151,25 @@ void MaxCube::decodeHelloMessage(QByteArray data)
m_rfAddress = list.at(1);
m_firmware = list.at(2).toInt();
// qDebug() << "====================================================";
// qDebug() << " HELLO message:";
// qDebug() << "====================================================";
// qDebug() << " serial number | " << m_serialNumber;
// qDebug() << " RF address (hex) | " << m_rfAddress;
// qDebug() << " firmware | " << m_firmware;
// qDebug() << " Cube date | " << m_cubeDateTime.date().toString("dd.MM.yyyy");
// qDebug() << " Cube time | " << m_cubeDateTime.time().toString("HH:mm");
// qDebug() << " State Cube Time | " << list.at(9);
// qDebug() << " NTP counter | " << list.at(10);
// qDebug() << "====================================================";
// qDebug() << " HELLO message:";
// qDebug() << "====================================================";
// qDebug() << " serial number | " << m_serialNumber;
// qDebug() << " RF address (hex) | " << m_rfAddress;
// qDebug() << " firmware | " << m_firmware;
// qDebug() << " Cube date | " << m_cubeDateTime.date().toString("dd.MM.yyyy");
// qDebug() << " Cube time | " << m_cubeDateTime.time().toString("HH:mm");
// qDebug() << " State Cube Time | " << list.at(9);
// qDebug() << " NTP counter | " << list.at(10);
}
void MaxCube::decodeMetadataMessage(QByteArray data)
{
QList<QByteArray> list = data.left(data.length()-2).split(',');
QByteArray dataDecoded = QByteArray::fromBase64(list.at(2));
// qDebug() << "====================================================";
// qDebug() << " METADATA message:";
// qDebug() << "====================================================";
// qDebug() << "====================================================";
// qDebug() << " METADATA message:";
// qDebug() << "====================================================";
// parse room list
int roomCount = dataDecoded.toHex().mid(4,2).toInt(0,16);
@ -174,24 +186,24 @@ void MaxCube::decodeMetadataMessage(QByteArray data)
m_roomList.append(room);
roomRawData = roomRawData.right(roomRawData.length() - ((roomNameLength*2) + 10));
}
// qDebug() << "-------------------------|-------------------------";
// qDebug() << "found " << m_roomList.count() << "rooms";
// qDebug() << "-------------------------|-------------------------";
// qDebug() << "-------------------------|-------------------------";
// qDebug() << "found " << m_roomList.count() << "rooms";
// qDebug() << "-------------------------|-------------------------";
// foreach (Room *room, m_roomList) {
// qDebug() << " Room Name | " << room->roomName();
// qDebug() << " Room ID | " << room->roomId();
// qDebug() << " Group RF Address | " << room->groupRfAddress();
// qDebug() << "-------------------------|-------------------------";
// }
// foreach (Room *room, m_roomList) {
// qDebug() << " Room Name | " << room->roomName();
// qDebug() << " Room ID | " << room->roomId();
// qDebug() << " Group RF Address | " << room->groupRfAddress();
// qDebug() << "-------------------------|-------------------------";
// }
// parse device list
int deviceCount = roomRawData.left(2).toInt(0,16);
QByteArray deviceRawData = roomRawData.right(roomRawData.length() - 2);
// qDebug() << "-------------------------|-------------------------";
// qDebug() << "found " << deviceCount << "devices";
// qDebug() << "-------------------------|-------------------------";
// qDebug() << "-------------------------|-------------------------";
// qDebug() << "found " << deviceCount << "devices";
// qDebug() << "-------------------------|-------------------------";
for(int i = 0; i < deviceCount; i++){
int deviceType = deviceRawData.left(2).toInt(0,16);
@ -214,13 +226,13 @@ void MaxCube::decodeMetadataMessage(QByteArray data)
}
m_radiatorThermostatList.append(device);
// qDebug() << " Device Name | " << device->deviceName();
// qDebug() << " Serial Number| " << device->serialNumber();
// qDebug() << " Device Type String | " << device->deviceTypeString();
// qDebug() << " RF address (hex) | " << device->rfAddress();
// qDebug() << " Room ID | " << device->roomId();
// qDebug() << " Room Name | " << device->roomName();
// qDebug() << "-------------------------|-------------------------";
// qDebug() << " Device Name | " << device->deviceName();
// qDebug() << " Serial Number| " << device->serialNumber();
// qDebug() << " Device Type String | " << device->deviceTypeString();
// qDebug() << " RF address (hex) | " << device->rfAddress();
// qDebug() << " Room ID | " << device->roomId();
// qDebug() << " Room Name | " << device->roomName();
// qDebug() << "-------------------------|-------------------------";
break;
}
case MaxDevice::DeviceWallThermostat:{
@ -241,13 +253,13 @@ void MaxCube::decodeMetadataMessage(QByteArray data)
}
m_wallThermostatList.append(device);
// qDebug() << " Device Name | " << device->deviceName();
// qDebug() << " Serial Number| " << device->serialNumber();
// qDebug() << " Device Type String | " << device->deviceTypeString();
// qDebug() << " RF address (hex) | " << device->rfAddress();
// qDebug() << " Room ID | " << device->roomId();
// qDebug() << " Room Name | " << device->roomName();
// qDebug() << "-------------------------|-------------------------";
// qDebug() << " Device Name | " << device->deviceName();
// qDebug() << " Serial Number| " << device->serialNumber();
// qDebug() << " Device Type String | " << device->deviceTypeString();
// qDebug() << " RF address (hex) | " << device->rfAddress();
// qDebug() << " Room ID | " << device->roomId();
// qDebug() << " Room Name | " << device->roomName();
// qDebug() << "-------------------------|-------------------------";
break;
}
default:
@ -256,7 +268,6 @@ void MaxCube::decodeMetadataMessage(QByteArray data)
}
m_cubeInitialized = true;
emit deviceListsReady();
}
void MaxCube::decodeConfigMessage(QByteArray data)
@ -275,24 +286,24 @@ void MaxCube::decodeConfigMessage(QByteArray data)
//QByteArray unknown = dataRaw.mid(12,6);
QByteArray serialNumber = QByteArray::fromHex(dataRaw.mid(16,20));
// qDebug() << "====================================================";
// qDebug() << " CONFIG message:";
// qDebug() << "====================================================";
// qDebug() << " Serial Number | " << serialNumber;
// qDebug() << " device Type | " << deviceTypeString(deviceType);
// qDebug() << " RF address (hex) | " << rfAddress;
// qDebug() << " data length | " << lengthData;
// qDebug() << "-------------------------|-------------------------";
// qDebug() << "====================================================";
// qDebug() << " CONFIG message:";
// qDebug() << "====================================================";
// qDebug() << " Serial Number | " << serialNumber;
// qDebug() << " device Type | " << deviceTypeString(deviceType);
// qDebug() << " RF address (hex) | " << rfAddress;
// qDebug() << " data length | " << lengthData;
// qDebug() << "-------------------------|-------------------------";
switch (deviceType) {
case MaxDevice::DeviceCube:{
m_portalEnabeld = (bool)dataRaw.mid(36,2).toInt(0,16);
// qDebug() << " portal enabled | " << m_portalEnabeld;
// qDebug() << " portal URL | " << QString(QByteArray::fromHex(dataRaw.mid(170,68)));
// qDebug() << " time zone | " << QString(QByteArray::fromHex(dataRaw.mid(428,6)));
// qDebug() << " summer/winter time | " << QString(QByteArray::fromHex(dataRaw.mid(452,8)));
// qDebug() << " portal enabled | " << m_portalEnabeld;
// qDebug() << " portal URL | " << QString(QByteArray::fromHex(dataRaw.mid(170,68)));
// qDebug() << " time zone | " << QString(QByteArray::fromHex(dataRaw.mid(428,6)));
// qDebug() << " summer/winter time | " << QString(QByteArray::fromHex(dataRaw.mid(452,8)));
emit cubeConfigReady();
break;
}
@ -322,22 +333,23 @@ void MaxCube::decodeConfigMessage(QByteArray data)
device->setValveMaximumSettings((double)dataRaw.mid(54,2).toInt(0,16)*(double)100.0/255.0);
device->setValveOffset((double)dataRaw.mid(56,2).toInt(0,16)*100.0/255.0);
// qDebug() << " Room ID | " << device->roomId();
// qDebug() << " firmware | " << firmware;
// qDebug() << " Confort Temp. | " << device->confortTemp() << "C";
// qDebug() << " Eco Temp. | " << device->ecoTemp() << "C";
// qDebug() << " Max. Set Point Temp. | " << device->maxSetPointTemp() << "C";
// qDebug() << " Min. Set Point Temp. | " << device->minSetPointTemp() << "C";
// qDebug() << " Temp. Offset | " << device->offsetTemp() << "C";
// qDebug() << " Window Open Temp. | " << device->windowOpenTemp() << "C";
// qDebug() << " Window Open Duration | " << device->windowOpenDuration() << "min";
// qDebug() << " Boost Duration | " << device->boostDuration() << "min";
// qDebug() << " Valve value | " << device->boostValveValue() << "%";
// qDebug() << " disclaiming run day | " << device->discalcingWeekDay();
// qDebug() << " disclaiming run time | " << device->discalcingTime().toString("HH:mm");
// qDebug() << " Valve Maximum Settings | " << device->valveMaximumSettings() << "%";
// qDebug() << " Valve Offset | " << device->valveOffset() << "%";
// qDebug() << " Room ID | " << device->roomId();
// qDebug() << " firmware | " << firmware;
// qDebug() << " Confort Temp. | " << device->confortTemp() << "C";
// qDebug() << " Eco Temp. | " << device->ecoTemp() << "C";
// qDebug() << " Max. Set Point Temp. | " << device->maxSetPointTemp() << "C";
// qDebug() << " Min. Set Point Temp. | " << device->minSetPointTemp() << "C";
// qDebug() << " Temp. Offset | " << device->offsetTemp() << "C";
// qDebug() << " Window Open Temp. | " << device->windowOpenTemp() << "C";
// qDebug() << " Window Open Duration | " << device->windowOpenDuration() << "min";
// qDebug() << " Boost Duration | " << device->boostDuration() << "min";
// qDebug() << " Valve value | " << device->boostValveValue() << "%";
// qDebug() << " disclaiming run day | " << device->discalcingWeekDay();
// qDebug() << " disclaiming run time | " << device->discalcingTime().toString("HH:mm");
// qDebug() << " Valve Maximum Settings | " << device->valveMaximumSettings() << "%";
// qDebug() << " Valve Offset | " << device->valveOffset() << "%";
parseWeeklyProgram(dataRaw.right(dataRaw.length() - 58));
emit radiatorThermostatFound();
}
}
break;
@ -354,14 +366,15 @@ void MaxCube::decodeConfigMessage(QByteArray data)
device->setMaxSetPointTemp((double)dataRaw.mid(40,2).toInt(0,16)/2.0);
device->setMinSetPointTemp((double)dataRaw.mid(42,2).toInt(0,16)/2.0);
// qDebug() << " Room ID | " << device->roomId();
// qDebug() << " firmware | " << firmware;
// qDebug() << " Confort Temp. | " << device->confortTemp();
// qDebug() << " Eco Temp. | " << device->ecoTemp();
// qDebug() << " Max. Set Point Temp. | " << device->maxSetPointTemp();
// qDebug() << " Min. Set Point Temp. | " << device->minSetPointTemp();
// qDebug() << " Room ID | " << device->roomId();
// qDebug() << " firmware | " << firmware;
// qDebug() << " Confort Temp. | " << device->confortTemp();
// qDebug() << " Eco Temp. | " << device->ecoTemp();
// qDebug() << " Max. Set Point Temp. | " << device->maxSetPointTemp();
// qDebug() << " Min. Set Point Temp. | " << device->minSetPointTemp();
parseWeeklyProgram(dataRaw.right(dataRaw.length() - 44));
emit wallThermostatFound();
}
}
break;
@ -378,9 +391,9 @@ void MaxCube::decodeConfigMessage(QByteArray data)
void MaxCube::decodeDevicelistMessage(QByteArray data)
{
// qDebug() << "====================================================";
// qDebug() << " LIVE message:";
// qDebug() << "====================================================";
// qDebug() << "====================================================";
// qDebug() << " LIVE message:";
// qDebug() << "====================================================";
QByteArray rawDataAll = QByteArray::fromBase64(data).toHex();
QList<QByteArray> deviceMessageList = splitMessage(rawDataAll);
@ -392,7 +405,7 @@ void MaxCube::decodeDevicelistMessage(QByteArray data)
switch (deviceType) {
case MaxDevice::DeviceWallThermostat:{
foreach (WallThermostat* device, m_wallThermostatList) {
foreach (WallThermostat *device, m_wallThermostatList) {
if(device->rfAddress() == rfAddress){
// init/valid code
@ -438,6 +451,8 @@ void MaxCube::decodeDevicelistMessage(QByteArray data)
// qDebug() << " Temperatur Setpoint | " << device->setpointTemperature();
// qDebug() << " Current Temp | " << device->currentTemperature();
// qDebug() << "-------------------------|-------------------------";
emit wallThermostatDataUpdated();
}
}
break;
@ -479,20 +494,22 @@ void MaxCube::decodeDevicelistMessage(QByteArray data)
// qDebug() << " valve position | " << device->valvePosition() << "%";
// qDebug() << " Temperatur Setpoint | " << device->setpointTemperature() << " deg C";
// qDebug() << "-------------------------|-------------------------";
emit radiatorThermostatDataUpdated();
}
}
break;
}
case MaxDevice::DeviceWindowContact:{
QByteArray windowOpenRawData = fillBin(QByteArray::number(rawData.mid(10,2).toInt(0,16),2),8);
//QByteArray windowOpenRawData = fillBin(QByteArray::number(rawData.mid(10,2).toInt(0,16),2),8);
//bool windowOpen = (bool)windowOpenRawData.mid(5,1).toInt();
// qDebug() << " raw data | " << rawData;
// qDebug() << " device type name | " << "Window Contact";
// qDebug() << " RF address (hex) | " << rfAddress;
// qDebug() << " window open code | " << windowOpenRawData;
// qDebug() << " window open | " << windowOpen;
// qDebug() << "-------------------------|-------------------------";
// qDebug() << " raw data | " << rawData;
// qDebug() << " device type name | " << "Window Contact";
// qDebug() << " RF address (hex) | " << rfAddress;
// qDebug() << " window open code | " << windowOpenRawData;
// qDebug() << " window open | " << windowOpen;
// qDebug() << "-------------------------|-------------------------";
break;
}
default:
@ -501,6 +518,17 @@ void MaxCube::decodeDevicelistMessage(QByteArray data)
}
}
void MaxCube::decodeCommandMessage(QByteArray data)
{
QList<QByteArray> list = data.split(',');
if(list.isEmpty()){
return;
}
bool succeeded = !(bool)list.at(2).toInt(0,10);
emit commandActionFinished(succeeded,m_actionId);
}
void MaxCube::parseWeeklyProgram(QByteArray data)
{
for(int i=0; i < 7; i++){
@ -527,10 +555,10 @@ void MaxCube::decodeNewDeviceFoundMessage(QByteArray data)
return;
}
// qDebug() << "====================================================";
// qDebug() << " NEW DEVICE message:";
// qDebug() << "====================================================";
// qDebug() << " Serial Number | " << QByteArray::fromBase64(data);
// qDebug() << "====================================================";
// qDebug() << " NEW DEVICE message:";
// qDebug() << "====================================================";
// qDebug() << " Serial Number | " << QByteArray::fromBase64(data);
}
@ -715,6 +743,11 @@ void MaxCube::processCubeData(const QByteArray &data)
decodeNewDeviceFoundMessage(data.right(data.length() -2));
return;
}
// COMMAND answere message
if(data.startsWith("S")){
decodeCommandMessage(data.right(data.length() -2));
return;
}
// ACK message
if(data.startsWith("A")){
qDebug() << "cube ACK!";
@ -738,9 +771,10 @@ void MaxCube::disablePairingMode()
void MaxCube::refresh()
{
if(m_cubeInitialized){
write("l:\r\n");
if(!isInitialized() || !isConnected()){
return;
}
write("l:\r\n");
}
void MaxCube::customRequest(QByteArray data)
@ -749,3 +783,119 @@ void MaxCube::customRequest(QByteArray data)
write(data + "\r\n");
}
void MaxCube::setDeviceSetpointTemp(QByteArray rfAddress, int roomId, double temperature, ActionId actionId)
{
m_actionId = actionId;
if(!isConnected() || !isInitialized()){
emit commandActionFinished(false,m_actionId);
return;
}
QByteArray data = "000440000000";
data.append(rfAddress);
// if roomID = 0....means all rooms
data.append(fillBin(QByteArray::number(roomId,16),2));
QByteArray temperatureData;
//temperature in 6 bits
temperatureData = fillBin(QByteArray::number((int)temperature*2,2),6);
// set auto/ permanent/ temp
// 00 = auto (weekly programm...the hole tempererature byte to 0x00
// 01 = Permanent
// 10 = Temporary (date/time has to be set)
data.append(fillBin(QByteArray::number(temperatureData.toInt(0,2),16),2));
temperatureData.append("01");
// add date/time until (000000 = forever)
data.append("000000");
qDebug() << "sending command " << temperatureData << data;
write("s:" + QByteArray::fromHex(data).toBase64() + "\r\n");
}
void MaxCube::setDeviceAutoMode(QByteArray rfAddress, int roomId, ActionId actionId)
{
m_actionId = actionId;
if(!isConnected() || !isInitialized()){
emit commandActionFinished(false,m_actionId);
return;
}
QByteArray data = "000440000000";
data.append(rfAddress);
// if roomID = 0....means all rooms
data.append(fillBin(QByteArray::number(roomId,16),2));
QByteArray temperatureData;
temperatureData.append("00000000");
data.append("000000");
qDebug() << "sending command " << temperatureData << data;
write("s:" + QByteArray::fromHex(data).toBase64() + "\r\n");
}
void MaxCube::setDeviceManuelMode(QByteArray rfAddress, int roomId, ActionId actionId)
{
m_actionId = actionId;
if(!isConnected() || !isInitialized()){
emit commandActionFinished(false,m_actionId);
return;
}
QByteArray data = "000440000000";
data.append(rfAddress);
// if roomID = 0....means all rooms
data.append(fillBin(QByteArray::number(roomId,16),2));
data.append("62");
write("s:" + QByteArray::fromHex(data).toBase64() + "\r\n");
}
void MaxCube::setDeviceEcoMode(QByteArray rfAddress, int roomId, ActionId actionId)
{
m_actionId = actionId;
if(!isConnected() || !isInitialized()){
emit commandActionFinished(false,m_actionId);
return;
}
QByteArray data = "000440000000";
data.append(rfAddress);
// if roomID = 0....means all rooms
data.append(fillBin(QByteArray::number(roomId,16),2));
data.append("6b");
write("s:" + QByteArray::fromHex(data).toBase64() + "\r\n");
}
void MaxCube::displayCurrentTemperature(QByteArray rfAddress, int roomId, bool display, ActionId actionId)
{
m_actionId = actionId;
if(!isConnected() || !isInitialized()){
emit commandActionFinished(false,m_actionId);
return;
}
QByteArray data = "000082000000";
data.append(rfAddress);
if(display){
data.append("0004");
}else{
data.append("0000");
}
write("s:" + QByteArray::fromHex(data).toBase64() + "\r\n");
}

23
plugins/deviceplugins/eq-3/maxcube.h
View File

@ -28,6 +28,7 @@
#include "room.h"
#include "wallthermostat.h"
#include "radiatorthermostat.h"
#include "plugin/deviceplugin.h"
class MaxCube : public QTcpSocket
{
@ -75,6 +76,8 @@ public:
void disconnectFromCube();
bool sendData(QByteArray data);
bool isConnected();
bool isInitialized();
private:
// cube data
@ -96,6 +99,7 @@ private:
void decodeMetadataMessage(QByteArray data);
void decodeConfigMessage(QByteArray data);
void decodeDevicelistMessage(QByteArray data);
void decodeCommandMessage(QByteArray data);
void parseWeeklyProgram(QByteArray data);
void decodeNewDeviceFoundMessage(QByteArray data);
@ -107,16 +111,22 @@ private:
QList<QByteArray> splitMessage(QByteArray data);
int deviceTypeFromRFAddress(QByteArray rfAddress);
ActionId m_actionId;
signals:
void cubeDataAvailable(const QByteArray &data);
void cubeACK();
void cubeConnectionStatusChanged(const bool &connected);
// when things are parsed
void deviceListsReady();
void cubeConfigReady();
void wallThermostatConfigReady();
void radiatorThermostatConfigReady();
void wallThermostatFound();
void radiatorThermostatFound();
void wallThermostatDataUpdated();
void radiatorThermostatDataUpdated();
void commandActionFinished(const bool &succeeded, const ActionId &actionId);
private slots:
void connectionStateChanged(const QAbstractSocket::SocketState &socketState);
@ -131,6 +141,13 @@ public slots:
void refresh();
void customRequest(QByteArray data);
// for actions
void setDeviceSetpointTemp(QByteArray rfAddress, int roomId, double temperature, ActionId actionId);
void setDeviceAutoMode(QByteArray rfAddress, int roomId, ActionId actionId);
void setDeviceManuelMode(QByteArray rfAddress, int roomId, ActionId actionId);
void setDeviceEcoMode(QByteArray rfAddress, int roomId, ActionId actionId);
void displayCurrentTemperature(QByteArray rfAddress, int roomId, bool display, ActionId actionId);
};
#endif // MAXCUBE_H

3
plugins/deviceplugins/openweathermap/devicepluginopenweathermap.cpp
View File

@ -307,7 +307,7 @@ DevicePluginOpenweathermap::DevicePluginOpenweathermap()
QList<Vendor> DevicePluginOpenweathermap::supportedVendors() const
{
QList<Vendor> ret;
Vendor openweathermap(openweathermapVendorId, "openweathermap");
Vendor openweathermap(openweathermapVendorId, "Openweathermap");
ret.append(openweathermap);
return ret;
}
@ -521,7 +521,6 @@ void DevicePluginOpenweathermap::weatherDataReady(const QByteArray &data)
foreach (Device *device, deviceManager()->findConfiguredDevices(openweathermapDeviceClassId)) {
if(device->paramValue("id").toString() == dataMap.value("id").toString()){
device->setName("Weather from openweathermap.org for " + device->paramValue("location").toString());
if(dataMap.contains("clouds")){
int cloudiness = dataMap.value("clouds").toMap().value("all").toInt();