import org.openwebnet4j.message.MalformedFrameException;
import org.openwebnet4j.message.Thermoregulation;
import org.openwebnet4j.message.Thermoregulation.DimThermo;
+import org.openwebnet4j.message.Thermoregulation.Function;
+import org.openwebnet4j.message.Thermoregulation.OperationMode;
import org.openwebnet4j.message.Thermoregulation.WhatThermo;
+import org.openwebnet4j.message.Thermoregulation.WhatThermoType;
import org.openwebnet4j.message.Where;
import org.openwebnet4j.message.WhereThermo;
import org.openwebnet4j.message.Who;
* {@link OpenWebNetThingHandler}.
*
* @author Massimo Valla - Initial contribution. Added support for 4-zones CU.
- * Rafactoring and fixed CU state channels updates.
+ * Rafactoring and fixed CU state channels updates. Completed support
+ * for HOLIDAY/VACATION modes and refactored mode handling.
* @author Gilberto Cocchi - Initial contribution.
* @author Andrea Conte - Added support for 99-zone CU and CU state channels.
*/
private double currentSetPointTemp = 20.0d;
- private Thermoregulation.@Nullable Function currentFunction = null;
- private Thermoregulation.@Nullable OperationMode currentMode = null;
+ private Thermoregulation.@Nullable Function currentFunction = Function.HEATING;
+ private Thermoregulation.@Nullable OperationMode currentMode = OperationMode.PROTECTION;
private int currentWeeklyPrgNum = 1;
private int currentScenarioPrgNum = 1;
+ private int currentVacationDays = 1;
private boolean isStandAlone = true; // true if zone is not associated to a CU
private boolean isCentralUnit = false;
private static final String CU_BATTERY_OK = "OK";
private static final String CU_BATTERY_KO = "KO";
private static final String MODE_WEEKLY = "WEEKLY";
- private static final String MODE_AUTO = "AUTO";
public OpenWebNetThermoregulationHandler(Thing thing) {
super(thing);
case CHANNEL_CU_SCENARIO_PROGRAM_NUMBER:
handleSetProgramNumber(channel, command);
break;
+ case CHANNEL_CU_VACATION_DAYS:
+ handleVacationDays(channel, command);
+ break;
default: {
logger.warn("handleChannelCommand() Unsupported ChannelUID {}", channel.getId());
}
private void handleSetFanSpeed(Command command) {
if (command instanceof StringType) {
Where w = deviceWhere;
- if (w != null) {
- try {
- Thermoregulation.FanCoilSpeed speed = Thermoregulation.FanCoilSpeed.valueOf(command.toString());
- send(Thermoregulation.requestWriteFanCoilSpeed(w.value(), speed));
- } catch (OWNException e) {
- logger.warn("handleSetFanSpeed() {}", e.getMessage());
- } catch (IllegalArgumentException e) {
- logger.warn("handleSetFanSpeed() Unsupported command {} for thing {}", command,
- getThing().getUID());
- return;
- }
+ if (w == null) {
+ logger.warn("handleSetFanSpeed() Where is null for thing {}", getThing().getUID());
+ return;
+ }
+ try {
+ Thermoregulation.FanCoilSpeed speed = Thermoregulation.FanCoilSpeed.valueOf(command.toString());
+ send(Thermoregulation.requestWriteFanCoilSpeed(w.value(), speed));
+ } catch (OWNException e) {
+ logger.warn("handleSetFanSpeed() {}", e.getMessage());
+ } catch (IllegalArgumentException e) {
+ logger.warn("handleSetFanSpeed() Unsupported command {} for thing {}", command, getThing().getUID());
+ return;
}
} else {
logger.warn("handleSetFanSpeed() Unsupported command {} for thing {}", command, getThing().getUID());
logger.warn("handleSetProgramNumber() This command can be sent only for a Central Unit.");
return;
}
+ Where w = deviceWhere;
+ if (w == null) {
+ logger.warn("handleSetProgramNumber() Where is null for thing {}", getThing().getUID());
+ return;
+ }
+
int programNumber = ((DecimalType) command).intValue();
boolean updateOpMode = false;
if (CHANNEL_CU_WEEKLY_PROGRAM_NUMBER.equals(channel.getId())) {
- updateOpMode = currentMode.isWeekly();
+ if (programNumber < 1 || programNumber > 3) {
+ logger.warn("handleSetProgramNumber() Invalid program number {} for thing {}", command,
+ getThing().getUID());
+ return;
+ }
+ updateOpMode = (currentMode == Thermoregulation.OperationMode.WEEKLY);
currentWeeklyPrgNum = programNumber;
logger.debug("handleSetProgramNumber() currentWeeklyPrgNum changed to: {}", programNumber);
} else {
- updateOpMode = currentMode.isScenario();
+ if (programNumber < 1 || programNumber > 16) {
+ logger.warn("handleSetProgramNumber() Invalid program number {} for thing {}", command,
+ getThing().getUID());
+ return;
+ }
+ updateOpMode = (currentMode == Thermoregulation.OperationMode.SCENARIO);
currentScenarioPrgNum = programNumber;
logger.debug("handleSetProgramNumber() currentScenarioPrgNum changed to: {}", programNumber);
}
// force OperationMode update if we are already in SCENARIO or WEEKLY mode
if (updateOpMode) {
try {
- Thermoregulation.OperationMode newMode = Thermoregulation.OperationMode
- .valueOf(currentMode.mode() + "_" + programNumber);
- logger.debug("handleSetProgramNumber() new mode {}", newMode);
- send(Thermoregulation.requestWriteMode(getWhere(deviceWhere.value()), newMode, currentFunction,
- currentSetPointTemp));
+ send(Thermoregulation.requestWriteWeeklyScenarioMode(getWhere(w.value()), currentMode,
+ currentFunction, programNumber));
} catch (OWNException e) {
logger.warn("handleSetProgramNumber() {}", e.getMessage());
- } catch (IllegalArgumentException e) {
- logger.warn("handleSetProgramNumber() Unsupported command {} for thing {}", command,
- getThing().getUID());
}
} else { // just update channel
updateState(channel, new DecimalType(programNumber));
}
}
+ private void handleVacationDays(ChannelUID channel, Command command) {
+ if (command instanceof DecimalType) {
+ Where w = deviceWhere;
+ if (w == null) {
+ logger.warn("handleVacationDays() Where is null for thing {}", getThing().getUID());
+ return;
+ }
+ if (!isCentralUnit) {
+ logger.warn("handleVacationDays() This command can be sent only for a Central Unit.");
+ return;
+ }
+ int vacationDays = ((DecimalType) command).intValue();
+
+ if (vacationDays < 1 || vacationDays > 255) {
+ logger.warn("handleVacationDays() vacation days must be between 1 and 255");
+ return;
+ }
+
+ currentVacationDays = vacationDays;
+ logger.debug("handleVacationDays() currentVacationDays changed to: {}", currentVacationDays);
+
+ // force OperationMode update if we are already in VACATION mode
+ if (currentMode == Thermoregulation.OperationMode.VACATION) {
+ try {
+ send(Thermoregulation.requestWriteVacationMode(getWhere(w.value()), currentFunction,
+ currentVacationDays, currentWeeklyPrgNum));
+ } catch (OWNException e) {
+ logger.warn("handleVacationDays() {}", e.getMessage());
+ } catch (IllegalArgumentException e) {
+ logger.warn("handleVacationDays() Unsupported command {} for thing {}", command,
+ getThing().getUID());
+ }
+ } else { // just update channel
+ updateState(channel, new DecimalType(currentVacationDays));
+ }
+ } else {
+ logger.warn("handleVacationDays() Unsupported command {} for thing {}", command, getThing().getUID());
+ }
+ }
+
private void handleSetpoint(Command command) {
if (command instanceof QuantityType || command instanceof DecimalType) {
Where w = deviceWhere;
- if (w != null) {
- double newTemp = 0;
- if (command instanceof QuantityType) {
- QuantityType<?> tempCelsius = ((QuantityType<?>) command).toUnit(SIUnits.CELSIUS);
- if (tempCelsius != null) {
- newTemp = tempCelsius.doubleValue();
- }
- } else {
- newTemp = ((DecimalType) command).doubleValue();
- }
- try {
- send(Thermoregulation.requestWriteSetpointTemperature(getWhere(w.value()), newTemp,
- currentFunction));
- } catch (MalformedFrameException | OWNException e) {
- logger.warn("handleSetpoint() {}", e.getMessage());
+ if (w == null) {
+ logger.warn("handleSetpoint() Where is null for thing {}", getThing().getUID());
+ return;
+ }
+ double newTemp = 0;
+ if (command instanceof QuantityType) {
+ QuantityType<?> tempCelsius = ((QuantityType<?>) command).toUnit(SIUnits.CELSIUS);
+ if (tempCelsius != null) {
+ newTemp = tempCelsius.doubleValue();
}
+ } else {
+ newTemp = ((DecimalType) command).doubleValue();
+ }
+ try {
+ send(Thermoregulation.requestWriteSetpointTemperature(getWhere(w.value()), newTemp, currentFunction));
+ } catch (MalformedFrameException | OWNException e) {
+ logger.warn("handleSetpoint() {}", e.getMessage());
}
} else {
logger.warn("handleSetpoint() Unsupported command {} for thing {}", command, getThing().getUID());
private void handleMode(Command command) {
if (command instanceof StringType) {
Where w = deviceWhere;
- if (w != null) {
+ if (w == null) {
+ logger.warn("handleMode() Where is null for thing {}", getThing().getUID());
+ return;
+ }
+
+ String whStr = getWhere(w.value());
+ String cmdStr = command.toString().toUpperCase();
+ OperationMode newMode;
+ try {
+ newMode = OperationMode.valueOf(cmdStr);
+ } catch (IllegalArgumentException e) {
+ logger.warn("handleMode() Unsupported command {} for thing {}", command, getThing().getUID());
+ return;
+ }
+ Thermoregulation tMsg = null;
+ if (isCentralUnit) { // CU accepted modes: MANUAL, OFF, PROTECTION, WEEKLY, SCENARIO, HOLIDAY,
+ // VACATION
+ switch (newMode) {
+ case MANUAL:
+ case OFF:
+ case PROTECTION:
+ tMsg = Thermoregulation.requestWriteMode(whStr, newMode, currentFunction, currentSetPointTemp);
+ break;
+ case WEEKLY:
+ case SCENARIO:
+ int programNumber = (MODE_WEEKLY.equals(cmdStr) ? currentWeeklyPrgNum : currentScenarioPrgNum);
+ tMsg = Thermoregulation.requestWriteWeeklyScenarioMode(whStr, newMode, currentFunction,
+ programNumber);
+ break;
+ case HOLIDAY:
+ tMsg = Thermoregulation.requestWriteHolidayMode(whStr, currentFunction, currentWeeklyPrgNum);
+ break;
+ case VACATION:
+ tMsg = Thermoregulation.requestWriteVacationMode(whStr, currentFunction, currentVacationDays,
+ currentWeeklyPrgNum);
+ break;
+ default:
+ logger.warn("handleMode() Unsupported command {} for CU thing {}", command,
+ getThing().getUID());
+ }
+ } else {// Zone accepted modes: MANUAL, OFF, PROTECTION, AUTO
+ switch (newMode) {
+ case MANUAL:
+ tMsg = Thermoregulation.requestWriteMode(whStr, newMode, currentFunction, currentSetPointTemp);
+ break;
+ case OFF:
+ case PROTECTION:
+ case AUTO:
+ tMsg = Thermoregulation.requestWriteMode(whStr, newMode, Function.GENERIC, currentSetPointTemp);
+ break;
+ default:
+ logger.warn("handleMode() Unsupported command {} for ZONE thing {}", command,
+ getThing().getUID());
+ }
+ }
+
+ if (tMsg != null) {
try {
- Thermoregulation.OperationMode newMode = Thermoregulation.OperationMode.OFF;
-
- if (isCentralUnit && WhatThermo.isComplex(command.toString())) {
- int programNumber = 0;
- if (MODE_WEEKLY.equalsIgnoreCase(command.toString())) {
- programNumber = currentWeeklyPrgNum;
- } else {
- programNumber = currentScenarioPrgNum;
- }
- newMode = Thermoregulation.OperationMode.valueOf(command.toString() + "_" + programNumber);
- currentMode = newMode;
- } else {
- if (MODE_AUTO.equalsIgnoreCase(command.toString())) {
- newMode = Thermoregulation.OperationMode.PROGRAM;
- } else {
- newMode = Thermoregulation.OperationMode.valueOf(command.toString());
- }
- }
- send(Thermoregulation.requestWriteMode(getWhere(w.value()), newMode, currentFunction,
- currentSetPointTemp));
+ send(tMsg);
} catch (OWNException e) {
logger.warn("handleMode() {}", e.getMessage());
- } catch (IllegalArgumentException e) {
- logger.warn("handleMode() Unsupported command {} for thing {}", command, getThing().getUID());
- return;
}
+ } else {
+ logger.warn("handleMode() Unsupported command {} for thing {}", command, getThing().getUID());
}
- } else {
- logger.warn("handleMode() Unsupported command {} for thing {}", command, getThing().getUID());
}
}
private void handleFunction(Command command) {
if (command instanceof StringType) {
Where w = deviceWhere;
- if (w != null) {
- try {
- Thermoregulation.Function function = Thermoregulation.Function.valueOf(command.toString());
- send(Thermoregulation.requestWriteFunction(w.value(), function));
- } catch (OWNException e) {
- logger.warn("handleFunction() {}", e.getMessage());
- } catch (IllegalArgumentException e) {
- logger.warn("handleFunction() Unsupported command {} for thing {}", command, getThing().getUID());
- return;
- }
+ if (w == null) {
+ logger.warn("handleFunction() Where is null for thing {}", getThing().getUID());
+ return;
+ }
+ try {
+ Thermoregulation.Function function = Thermoregulation.Function.valueOf(command.toString());
+ send(Thermoregulation.requestWriteFunction(w.value(), function));
+ } catch (OWNException e) {
+ logger.warn("handleFunction() {}", e.getMessage());
+ } catch (IllegalArgumentException e) {
+ logger.warn("handleFunction() Unsupported command {} for thing {}", command, getThing().getUID());
+ return;
}
} else {
logger.warn("handleFunction() Unsupported command {} for thing {}", command, getThing().getUID());
// their values
resetCUState();
}
- switch (tWhat) {
+ switch (tWhat.getType()) {
case AT_LEAST_ONE_PROBE_ANTIFREEZE:
cuAtLeastOneProbeProtection = true;
break;
private void updateModeAndFunction(Thermoregulation tmsg) {
if (tmsg.getWhat() == null) {
- logger.warn("updateModeAndFunction() Could not parse Mode or Function from {} (WHAT is null)",
- tmsg.getFrameValue());
+ logger.warn("updateModeAndFunction() Could not parse What {} (WHAT is null)", tmsg.getFrameValue());
return;
}
- Thermoregulation.WhatThermo w = Thermoregulation.WhatThermo.fromValue(tmsg.getWhat().value());
- if (w.getMode() == null) {
+ Thermoregulation.WhatThermo what = tmsg.new WhatThermo(tmsg.getWhat().value());
+ if (what.getMode() == null) {
logger.warn("updateModeAndFunction() Could not parse Mode from: {}", tmsg.getFrameValue());
return;
}
- if (w.getFunction() == null) {
+ if (what.getFunction() == null) {
logger.warn("updateModeAndFunction() Could not parse Function from: {}", tmsg.getFrameValue());
return;
}
+ // update Function if it's not GENERIC
+ Thermoregulation.Function function = what.getFunction();
+ if (function != Function.GENERIC) {
+ updateState(CHANNEL_FUNCTION, new StringType(function.toString()));
+ currentFunction = function;
+ }
+
+ // then update Mode
Thermoregulation.OperationMode operationMode = null;
- if (w != WhatThermo.HEATING && w != WhatThermo.CONDITIONING) {
+ if (what.getType() != WhatThermoType.HEATING && what.getType() != WhatThermoType.CONDITIONING) {
// *4*1*z## and *4*0*z## do not tell us which mode is the zone now
- operationMode = w.getMode();
+ operationMode = what.getMode();
}
- Thermoregulation.Function function = w.getFunction();
- updateState(CHANNEL_FUNCTION, new StringType(function.toString()));
-
- // must convert from OperationMode to Mode and set ProgramNumber when necessary
+ // set ProgramNumber/vacationDays channels when necessary
if (operationMode != null) {
- String newMode;
- if (operationMode == Thermoregulation.OperationMode.PROGRAM) { // translate PROGRAM -> AUTO
- newMode = MODE_AUTO;
- } else {
- newMode = operationMode.mode();
+ switch (operationMode) {
+ case VACATION:
+ updateVacationDays(tmsg);
+ break;
+ case WEEKLY:
+ case SCENARIO:
+ updateProgramNumber(tmsg);
+ break;
+ default:
+ break;
}
- updateState(CHANNEL_MODE, new StringType(newMode));
- Integer programN = 0;
- try {
- @Nullable
- Integer prNum = operationMode.programNumber();
- if (prNum != null) {
- programN = prNum;
- }
- } catch (Exception e) {
- logger.warn("updateModeAndFunction() Could not parse program number from: {}", tmsg.getFrameValue());
+ if (!isCentralUnit && !(operationMode == OperationMode.AUTO || operationMode == OperationMode.OFF
+ || operationMode == OperationMode.PROTECTION || operationMode == OperationMode.MANUAL)) {
+ logger.warn("updateModeAndFunction() Unsupported mode for zone {} from message: {}",
+ getThing().getUID(), tmsg.getFrameValue());
return;
+ } else {
+ updateState(CHANNEL_MODE, new StringType(operationMode.name()));
+ currentMode = operationMode;
}
- if (operationMode.isScenario()) {
- logger.debug("{} - updateModeAndFunction() set SCENARIO program to: {}", getThing().getUID(), programN);
- updateState(CHANNEL_CU_SCENARIO_PROGRAM_NUMBER, new DecimalType(programN));
- currentScenarioPrgNum = programN;
- }
- if (operationMode.isWeekly()) {
- logger.debug("{} - updateModeAndFunction() set WEEKLY program to: {}", getThing().getUID(), programN);
- updateState(CHANNEL_CU_WEEKLY_PROGRAM_NUMBER, new DecimalType(programN));
- currentWeeklyPrgNum = programN;
- }
+ } else {
+ logger.debug("updateModeAndFunction() Unrecognized mode from message: {}", tmsg.getFrameValue());
}
- // store current function
- currentFunction = function;
- // in case of Central Unit store also current operation mode
- if (isCentralUnit) {
- currentMode = operationMode;
+ }
+
+ private void updateVacationDays(Thermoregulation tmsg) {
+ @Nullable
+ Integer vDays = ((WhatThermo) tmsg.getWhat()).vacationDays();
+ if (vDays != null) {
+ logger.debug("{} - updateVacationDays() set VACATION DAYS to: {}", getThing().getUID(), vDays);
+ updateState(CHANNEL_CU_VACATION_DAYS, new DecimalType(vDays));
+ currentVacationDays = vDays;
+ }
+ }
+
+ private void updateProgramNumber(Thermoregulation tmsg) {
+ @Nullable
+ WhatThermo wt = (WhatThermo) tmsg.getWhat();
+ if (wt == null) {
+ return;
+ }
+ Integer prNum = wt.programNumber();
+ if (prNum != null) {
+ if (wt.getMode() == OperationMode.SCENARIO) {
+ logger.debug("{} - updateProgramNumber() set SCENARIO program to: {}", getThing().getUID(), prNum);
+ updateState(CHANNEL_CU_SCENARIO_PROGRAM_NUMBER, new DecimalType(prNum));
+ currentScenarioPrgNum = prNum;
+ } else if (wt.getMode() == OperationMode.WEEKLY) {
+ logger.debug("{} - updateProgramNumber() set WEEKLY program to: {}", getThing().getUID(), prNum);
+ updateState(CHANNEL_CU_WEEKLY_PROGRAM_NUMBER, new DecimalType(prNum));
+ currentWeeklyPrgNum = prNum;
+ }
}
}
try {
double newTemp = -1;
if (isCentralUnit) {
- if (tmsg.getWhat() == null) {
- logger.warn("updateSetpoint() Could not parse function from {} (what is null)",
- tmsg.getFrameValue());
+ WhatThermo tw = (WhatThermo) tmsg.getWhat();
+ if (tw == null) {
+ logger.warn("updateSetpoint() Could not parse what from {} (what is null)", tmsg.getFrameValue());
return;
}
String[] parameters = tmsg.getWhatParams();
- if (parameters.length > 0) {
- // it should be like *4*WHAT#TTTT*#0##
+ if (parameters.length > 0 && tw.getType() == WhatThermoType.MANUAL) {
+ // it should be like *4*110#TTTT*#0##
newTemp = Thermoregulation.decodeTemperature(parameters[0]);
logger.debug("updateSetpoint() parsed temperature from {}: {} ---> {}", tmsg.toStringVerbose(),
parameters[0], newTemp);
private void updateValveStatus(Thermoregulation tmsg) {
try {
Thermoregulation.ValveOrActuatorStatus cv = Thermoregulation.parseValveStatus(tmsg,
- Thermoregulation.WhatThermo.CONDITIONING);
+ Thermoregulation.WhatThermoType.CONDITIONING);
updateState(CHANNEL_CONDITIONING_VALVES, new StringType(cv.toString()));
Thermoregulation.ValveOrActuatorStatus hv = Thermoregulation.parseValveStatus(tmsg,
- Thermoregulation.WhatThermo.HEATING);
+ Thermoregulation.WhatThermoType.HEATING);
updateState(CHANNEL_HEATING_VALVES, new StringType(hv.toString()));
} catch (FrameException e) {
logger.warn("updateValveStatus() FrameException on frame {}: {}", tmsg, e.getMessage());
}
private void updateCUStateChannels() {
- logger.debug("@@@@ updating CU state channels");
updateState(CHANNEL_CU_AT_LEAST_ONE_PROBE_OFF, OnOffType.from(cuAtLeastOneProbeOff));
updateState(CHANNEL_CU_AT_LEAST_ONE_PROBE_PROTECTION, OnOffType.from(cuAtLeastOneProbeProtection));
updateState(CHANNEL_CU_AT_LEAST_ONE_PROBE_MANUAL, OnOffType.from(cuAtLeastOneProbeManual));
protected void refreshDevice(boolean refreshAll) {
logger.debug("--- refreshDevice() : refreshing SINGLE... ({})", thing.getUID());
- if (deviceWhere != null) {
- String whereStr = deviceWhere.value();
+ Where w = deviceWhere;
+ if (w == null) {
+ logger.warn("refreshDevice() Where is null for thing {}", getThing().getUID());
+ return;
+ }
- if (isCentralUnit) {
- try {
- send(Thermoregulation.requestStatus(getWhere(whereStr)));
- } catch (OWNException e) {
- logger.warn("refreshDevice() central unit returned OWNException {}", e.getMessage());
- }
- return;
- }
+ String whereStr = w.value();
+ if (isCentralUnit) {
try {
- send(Thermoregulation.requestTemperature(whereStr));
-
- if (!((WhereThermo) deviceWhere).isProbe()) {
- // for bus_thermo_zone request also other single channels updates
- send(Thermoregulation.requestSetPointTemperature(whereStr));
- send(Thermoregulation.requestMode(whereStr));
-
- // refresh ONLY subscribed channels
- if (channelExists(CHANNEL_FAN_SPEED)) {
- send(Thermoregulation.requestFanCoilSpeed(whereStr));
- }
- if (channelExists(CHANNEL_CONDITIONING_VALVES) || channelExists(CHANNEL_HEATING_VALVES)) {
- send(Thermoregulation.requestValvesStatus(whereStr));
- }
- if (channelExists(CHANNEL_ACTUATORS)) {
- send(Thermoregulation.requestActuatorsStatus(whereStr));
- }
- if (channelExists(CHANNEL_LOCAL_OFFSET)) {
- send(Thermoregulation.requestLocalOffset(whereStr));
- }
- }
+ send(Thermoregulation.requestStatus(getWhere(whereStr)));
} catch (OWNException e) {
- logger.warn("refreshDevice() where='{}' returned OWNException {}", whereStr, e.getMessage());
+ logger.warn("refreshDevice() central unit returned OWNException {}", e.getMessage());
}
- } else {
- logger.debug("refreshDevice() where is null");
+ return;
+ }
+
+ try {
+ send(Thermoregulation.requestTemperature(whereStr));
+
+ if (!((WhereThermo) w).isProbe()) {
+ // for bus_thermo_zone request also other single channels updates
+ send(Thermoregulation.requestSetPointTemperature(whereStr));
+ send(Thermoregulation.requestMode(whereStr));
+
+ // refresh ONLY subscribed channels
+ if (channelExists(CHANNEL_FAN_SPEED)) {
+ send(Thermoregulation.requestFanCoilSpeed(whereStr));
+ }
+ if (channelExists(CHANNEL_CONDITIONING_VALVES) || channelExists(CHANNEL_HEATING_VALVES)) {
+ send(Thermoregulation.requestValvesStatus(whereStr));
+ }
+ if (channelExists(CHANNEL_ACTUATORS)) {
+ send(Thermoregulation.requestActuatorsStatus(whereStr));
+ }
+ if (channelExists(CHANNEL_LOCAL_OFFSET)) {
+ send(Thermoregulation.requestLocalOffset(whereStr));
+ }
+ }
+ } catch (OWNException e) {
+ logger.warn("refreshDevice() where='{}' returned OWNException {}", whereStr, e.getMessage());
}
}
projects / openhab-addons.git / commitdiff