import java.util.stream.Collectors;
import java.util.stream.Stream;
+import javax.measure.Unit;
+
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.core.library.CoreItemFactory;
private final @Nullable BigDecimal min;
private final @Nullable BigDecimal max;
private final BigDecimal step;
- private final String unit;
+ private final Unit<?> unit;
public NumberValue(@Nullable BigDecimal min, @Nullable BigDecimal max, @Nullable BigDecimal step,
- @Nullable String unit) {
+ @Nullable Unit<?> unit) {
super(CoreItemFactory.NUMBER, Stream.of(QuantityType.class, IncreaseDecreaseType.class, UpDownType.class)
.collect(Collectors.toList()));
this.min = min;
this.max = max;
this.step = step == null ? BigDecimal.ONE : step;
- this.unit = unit == null ? "" : unit;
+ this.unit = unit != null ? unit : Units.ONE;
}
- protected boolean checkConditions(BigDecimal newValue, DecimalType oldvalue) {
+ protected boolean checkConditions(BigDecimal newValue) {
BigDecimal min = this.min;
if (min != null && newValue.compareTo(min) == -1) {
logger.trace("Number not accepted as it is below the configured minimum");
@Override
public void update(Command command) throws IllegalArgumentException {
- DecimalType oldvalue = (state == UnDefType.UNDEF) ? new DecimalType() : (DecimalType) state;
BigDecimal newValue = null;
if (command instanceof DecimalType) {
- if (!checkConditions(((DecimalType) command).toBigDecimal(), oldvalue)) {
- return;
- }
- state = (DecimalType) command;
+ newValue = ((DecimalType) command).toBigDecimal();
} else if (command instanceof IncreaseDecreaseType || command instanceof UpDownType) {
+ BigDecimal oldValue = getOldValue();
if (command == IncreaseDecreaseType.INCREASE || command == UpDownType.UP) {
- newValue = oldvalue.toBigDecimal().add(step);
+ newValue = oldValue.add(step);
} else {
- newValue = oldvalue.toBigDecimal().subtract(step);
- }
- if (!checkConditions(newValue, oldvalue)) {
- return;
+ newValue = oldValue.subtract(step);
}
- state = new DecimalType(newValue);
} else if (command instanceof QuantityType<?>) {
- QuantityType<?> qType = (QuantityType<?>) command;
-
- if (qType.getUnit().isCompatible(Units.ONE)) {
- newValue = qType.toBigDecimal();
- } else {
- qType = qType.toUnit(unit);
- if (qType != null) {
- newValue = qType.toBigDecimal();
- }
- }
- if (newValue != null) {
- if (!checkConditions(newValue, oldvalue)) {
- return;
- }
- state = new DecimalType(newValue);
- }
+ newValue = getQuantityTypeAsDecimal((QuantityType<?>) command);
} else {
newValue = new BigDecimal(command.toString());
- if (!checkConditions(newValue, oldvalue)) {
- return;
- }
+ }
+ if (!checkConditions(newValue)) {
+ return;
+ }
+ // items with units specified in the label in the UI but no unit on mqtt are stored as
+ // DecimalType to avoid conversions (e.g. % expects 0-1 rather than 0-100)
+ if (!Units.ONE.equals(unit)) {
+ state = new QuantityType<>(newValue, unit);
+ } else {
state = new DecimalType(newValue);
}
}
+ private BigDecimal getOldValue() {
+ BigDecimal val = BigDecimal.ZERO;
+ if (state instanceof DecimalType) {
+ val = ((DecimalType) state).toBigDecimal();
+ } else if (state instanceof QuantityType<?>) {
+ val = ((QuantityType<?>) state).toBigDecimal();
+ }
+ return val;
+ }
+
+ private BigDecimal getQuantityTypeAsDecimal(QuantityType<?> qType) {
+ BigDecimal val = qType.toBigDecimal();
+ if (!qType.getUnit().isCompatible(Units.ONE)) {
+ QuantityType<?> convertedType = qType.toUnit(unit);
+ if (convertedType != null) {
+ val = convertedType.toBigDecimal();
+ }
+ }
+ return val;
+ }
+
@Override
public StateDescriptionFragmentBuilder createStateDescription(boolean readOnly) {
StateDescriptionFragmentBuilder builder = super.createStateDescription(readOnly);
if (min != null) {
builder = builder.withMinimum(min);
}
- builder = builder.withStep(step);
- if (this.unit.length() > 0) {
- builder = builder.withPattern("%s " + this.unit.replace("%", "%%"));
- }
- return builder;
+ return builder.withStep(step).withPattern("%s %unit%");
}
}
import org.openhab.binding.mqtt.generic.ChannelConfig;
import org.openhab.binding.mqtt.generic.internal.MqttBindingConstants;
import org.openhab.binding.mqtt.generic.mapping.ColorMode;
+import org.openhab.core.types.util.UnitUtils;
/**
* A factory t
*/
@NonNullByDefault
public class ValueFactory {
+
/**
* Creates a new channel state value.
*
value = new LocationValue();
break;
case MqttBindingConstants.NUMBER:
- value = new NumberValue(config.min, config.max, config.step, config.unit);
+ value = new NumberValue(config.min, config.max, config.step, UnitUtils.parseUnit(config.unit));
break;
case MqttBindingConstants.DIMMER:
value = new PercentageValue(config.min, config.max, config.step, config.on, config.off);
import org.openhab.core.library.types.HSBType;
import org.openhab.core.library.types.RawType;
import org.openhab.core.library.types.StringType;
+import org.openhab.core.library.unit.Units;
import org.openhab.core.thing.ChannelUID;
/**
assertThat(value.getChannelState().toString(), is("16.0"));
}
+ @Test
+ public void receiveDecimalUnitTest() {
+ NumberValue value = new NumberValue(null, null, new BigDecimal(10), Units.WATT);
+ ChannelState c = spy(new ChannelState(config, channelUID, value, channelStateUpdateListener));
+ c.start(connection, mock(ScheduledExecutorService.class), 100);
+
+ c.processMessage("state", "15".getBytes());
+ assertThat(value.getChannelState().toString(), is("15 W"));
+
+ c.processMessage("state", "INCREASE".getBytes());
+ assertThat(value.getChannelState().toString(), is("25 W"));
+
+ c.processMessage("state", "DECREASE".getBytes());
+ assertThat(value.getChannelState().toString(), is("15 W"));
+
+ verify(channelStateUpdateListener, times(3)).updateChannelState(eq(channelUID), any());
+ }
+
+ @Test
+ public void receiveDecimalAsPercentageUnitTest() {
+ NumberValue value = new NumberValue(null, null, new BigDecimal(10), Units.PERCENT);
+ ChannelState c = spy(new ChannelState(config, channelUID, value, channelStateUpdateListener));
+ c.start(connection, mock(ScheduledExecutorService.class), 100);
+
+ c.processMessage("state", "63.7".getBytes());
+ assertThat(value.getChannelState().toString(), is("63.7 %"));
+
+ verify(channelStateUpdateListener, times(1)).updateChannelState(eq(channelUID), any());
+ }
+
@Test
public void receivePercentageTest() {
PercentageValue value = new PercentageValue(new BigDecimal(-100), new BigDecimal(100), new BigDecimal(10), null,
import org.openhab.core.library.types.OnOffType;
import org.openhab.core.library.types.OpenClosedType;
import org.openhab.core.library.types.PercentType;
+import org.openhab.core.library.types.QuantityType;
import org.openhab.core.library.types.StringType;
import org.openhab.core.library.types.UpDownType;
+import org.openhab.core.library.unit.MetricPrefix;
+import org.openhab.core.library.unit.Units;
import org.openhab.core.types.Command;
import org.openhab.core.types.TypeParser;
assertThat(v.getChannelState(), is(OpenClosedType.OPEN));
}
+ @Test
+ public void numberUpdate() {
+ NumberValue v = new NumberValue(null, null, new BigDecimal(10), Units.WATT);
+
+ // Test with command with units
+ v.update(new QuantityType<>(20, Units.WATT));
+ assertThat(v.getMQTTpublishValue(null), is("20"));
+ assertThat(v.getChannelState(), is(new QuantityType<>(20, Units.WATT)));
+ v.update(new QuantityType<>(20, MetricPrefix.KILO(Units.WATT)));
+ assertThat(v.getMQTTpublishValue(null), is("20000"));
+ assertThat(v.getChannelState(), is(new QuantityType<>(20, MetricPrefix.KILO(Units.WATT))));
+
+ // Test with command without units
+ v.update(new QuantityType<>("20"));
+ assertThat(v.getMQTTpublishValue(null), is("20"));
+ assertThat(v.getChannelState(), is(new QuantityType<>(20, Units.WATT)));
+ }
+
+ @Test
+ public void numberPercentageUpdate() {
+ NumberValue v = new NumberValue(null, null, new BigDecimal(10), Units.PERCENT);
+
+ // Test with command with units
+ v.update(new QuantityType<>(20, Units.PERCENT));
+ assertThat(v.getMQTTpublishValue(null), is("20"));
+ assertThat(v.getChannelState(), is(new QuantityType<>(20, Units.PERCENT)));
+
+ // Test with command without units
+ v.update(new QuantityType<>("20"));
+ assertThat(v.getMQTTpublishValue(null), is("20"));
+ assertThat(v.getChannelState(), is(new QuantityType<>(20, Units.PERCENT)));
+ }
+
@Test
public void rollershutterUpdateWithStrings() {
RollershutterValue v = new RollershutterValue("fancyON", "fancyOff", "fancyStop");
import java.util.List;
import java.util.function.Predicate;
+import javax.measure.Unit;
+import javax.measure.quantity.Temperature;
+
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.binding.mqtt.generic.ChannelStateUpdateListener;
import org.openhab.binding.mqtt.homeassistant.internal.ComponentChannel;
import org.openhab.binding.mqtt.homeassistant.internal.config.dto.AbstractChannelConfiguration;
import org.openhab.core.library.types.StringType;
+import org.openhab.core.library.unit.ImperialUnits;
+import org.openhab.core.library.unit.SIUnits;
import org.openhab.core.types.Command;
import org.openhab.core.types.State;
public static final String TEMPERATURE_LOW_CH_ID = "temperatureLow";
public static final String POWER_CH_ID = "power";
- private static final String CELSIUM = "C";
- private static final String FAHRENHEIT = "F";
- private static final float DEFAULT_CELSIUM_PRECISION = 0.1f;
- private static final float DEFAULT_FAHRENHEIT_PRECISION = 1f;
+ public static enum TemperatureUnit {
+ @SerializedName("C")
+ CELSIUS(SIUnits.CELSIUS, new BigDecimal("0.1")),
+ @SerializedName("F")
+ FAHRENHEIT(ImperialUnits.FAHRENHEIT, BigDecimal.ONE);
+
+ private final Unit<Temperature> unit;
+ private final BigDecimal defaultPrecision;
+
+ TemperatureUnit(Unit<Temperature> unit, BigDecimal defaultPrecision) {
+ this.unit = unit;
+ this.defaultPrecision = defaultPrecision;
+ }
+
+ public Unit<Temperature> getUnit() {
+ return unit;
+ }
+
+ public BigDecimal getDefaultPrecision() {
+ return defaultPrecision;
+ }
+ }
private static final String ACTION_OFF = "off";
private static final State ACTION_OFF_STATE = new StringType(ACTION_OFF);
protected Integer initial = 21;
@SerializedName("max_temp")
- protected @Nullable Float maxTemp;
+ protected @Nullable BigDecimal maxTemp;
@SerializedName("min_temp")
- protected @Nullable Float minTemp;
+ protected @Nullable BigDecimal minTemp;
@SerializedName("temperature_unit")
- protected String temperatureUnit = CELSIUM; // System unit by default
+ protected TemperatureUnit temperatureUnit = TemperatureUnit.CELSIUS; // System unit by default
@SerializedName("temp_step")
- protected Float tempStep = 1f;
- protected @Nullable Float precision;
+ protected BigDecimal tempStep = BigDecimal.ONE;
+ protected @Nullable BigDecimal precision;
@SerializedName("send_if_off")
protected Boolean sendIfOff = true;
}
public Climate(ComponentFactory.ComponentConfiguration componentConfiguration) {
super(componentConfiguration, ChannelConfiguration.class);
- BigDecimal minTemp = channelConfiguration.minTemp != null ? BigDecimal.valueOf(channelConfiguration.minTemp)
- : null;
- BigDecimal maxTemp = channelConfiguration.maxTemp != null ? BigDecimal.valueOf(channelConfiguration.maxTemp)
- : null;
- float precision = channelConfiguration.precision != null ? channelConfiguration.precision
- : (FAHRENHEIT.equals(channelConfiguration.temperatureUnit) ? DEFAULT_FAHRENHEIT_PRECISION
- : DEFAULT_CELSIUM_PRECISION);
+ BigDecimal precision = channelConfiguration.precision != null ? channelConfiguration.precision
+ : channelConfiguration.temperatureUnit.getDefaultPrecision();
final ChannelStateUpdateListener updateListener = componentConfiguration.getUpdateListener();
ComponentChannel actionChannel = buildOptionalChannel(ACTION_CH_ID,
channelConfiguration.awayModeStateTopic, commandFilter);
buildOptionalChannel(CURRENT_TEMPERATURE_CH_ID,
- new NumberValue(minTemp, maxTemp, BigDecimal.valueOf(precision), channelConfiguration.temperatureUnit),
+ new NumberValue(channelConfiguration.minTemp, channelConfiguration.maxTemp, precision,
+ channelConfiguration.temperatureUnit.getUnit()),
updateListener, null, null, channelConfiguration.currentTemperatureTemplate,
channelConfiguration.currentTemperatureTopic, commandFilter);
channelConfiguration.swingStateTemplate, channelConfiguration.swingStateTopic, commandFilter);
buildOptionalChannel(TEMPERATURE_CH_ID,
- new NumberValue(minTemp, maxTemp, BigDecimal.valueOf(channelConfiguration.tempStep),
- channelConfiguration.temperatureUnit),
+ new NumberValue(channelConfiguration.minTemp, channelConfiguration.maxTemp,
+ channelConfiguration.tempStep, channelConfiguration.temperatureUnit.getUnit()),
updateListener, channelConfiguration.temperatureCommandTemplate,
channelConfiguration.temperatureCommandTopic, channelConfiguration.temperatureStateTemplate,
channelConfiguration.temperatureStateTopic, commandFilter);
buildOptionalChannel(TEMPERATURE_HIGH_CH_ID,
- new NumberValue(minTemp, maxTemp, BigDecimal.valueOf(channelConfiguration.tempStep),
- channelConfiguration.temperatureUnit),
+ new NumberValue(channelConfiguration.minTemp, channelConfiguration.maxTemp,
+ channelConfiguration.tempStep, channelConfiguration.temperatureUnit.getUnit()),
updateListener, channelConfiguration.temperatureHighCommandTemplate,
channelConfiguration.temperatureHighCommandTopic, channelConfiguration.temperatureHighStateTemplate,
channelConfiguration.temperatureHighStateTopic, commandFilter);
buildOptionalChannel(TEMPERATURE_LOW_CH_ID,
- new NumberValue(minTemp, maxTemp, BigDecimal.valueOf(channelConfiguration.tempStep),
- channelConfiguration.temperatureUnit),
+ new NumberValue(channelConfiguration.minTemp, channelConfiguration.maxTemp,
+ channelConfiguration.tempStep, channelConfiguration.temperatureUnit.getUnit()),
updateListener, channelConfiguration.temperatureLowCommandTemplate,
channelConfiguration.temperatureLowCommandTopic, channelConfiguration.temperatureLowStateTemplate,
channelConfiguration.temperatureLowStateTopic, commandFilter);
import org.openhab.binding.mqtt.generic.values.Value;
import org.openhab.binding.mqtt.homeassistant.internal.config.dto.AbstractChannelConfiguration;
import org.openhab.binding.mqtt.homeassistant.internal.listener.ExpireUpdateStateListener;
+import org.openhab.core.types.util.UnitUtils;
import com.google.gson.annotations.SerializedName;
String uom = channelConfiguration.unitOfMeasurement;
if (uom != null && !uom.isBlank()) {
- value = new NumberValue(null, null, null, uom);
+ value = new NumberValue(null, null, null, UnitUtils.parseUnit(uom));
} else {
value = new TextValue();
}
import org.openhab.binding.mqtt.generic.values.TextValue;
import org.openhab.core.library.types.DecimalType;
import org.openhab.core.library.types.OnOffType;
+import org.openhab.core.library.types.QuantityType;
import org.openhab.core.library.types.StringType;
+import org.openhab.core.library.unit.ImperialUnits;
+import org.openhab.core.library.unit.SIUnits;
/**
* Tests for {@link Climate}
+ "\"current_heating_setpoint\": \"24\"}");
assertState(component, Climate.ACTION_CH_ID, new StringType("off"));
assertState(component, Climate.AWAY_MODE_CH_ID, OnOffType.ON);
- assertState(component, Climate.CURRENT_TEMPERATURE_CH_ID, new DecimalType(22.2));
+ assertState(component, Climate.CURRENT_TEMPERATURE_CH_ID, new QuantityType<>(22.2, SIUnits.CELSIUS));
assertState(component, Climate.HOLD_CH_ID, new StringType("schedule"));
assertState(component, Climate.MODE_CH_ID, new StringType("heat"));
- assertState(component, Climate.TEMPERATURE_CH_ID, new DecimalType(24));
+ assertState(component, Climate.TEMPERATURE_CH_ID, new QuantityType<>(24, SIUnits.CELSIUS));
component.getChannel(Climate.AWAY_MODE_CH_ID).getState().publishValue(OnOffType.OFF);
assertPublished("zigbee2mqtt/th1/set/away_mode", "OFF");
+ "\"current_heating_setpoint\": \"24\"}");
assertState(component, Climate.ACTION_CH_ID, new StringType("off"));
assertState(component, Climate.AWAY_MODE_CH_ID, OnOffType.ON);
- assertState(component, Climate.CURRENT_TEMPERATURE_CH_ID, new DecimalType(22.2));
+ assertState(component, Climate.CURRENT_TEMPERATURE_CH_ID, new QuantityType<>(22.2, SIUnits.CELSIUS));
assertState(component, Climate.HOLD_CH_ID, new StringType("schedule"));
assertState(component, Climate.MODE_CH_ID, new StringType("heat"));
- assertState(component, Climate.TEMPERATURE_CH_ID, new DecimalType(24));
+ assertState(component, Climate.TEMPERATURE_CH_ID, new QuantityType<>(24, SIUnits.CELSIUS));
// Climate is in OFF state
component.getChannel(Climate.AWAY_MODE_CH_ID).getState().publishValue(OnOffType.OFF);
assertState(component, Climate.ACTION_CH_ID, new StringType("fan"));
assertState(component, Climate.AUX_CH_ID, OnOffType.ON);
assertState(component, Climate.AWAY_MODE_CH_ID, OnOffType.OFF);
- assertState(component, Climate.CURRENT_TEMPERATURE_CH_ID, new DecimalType(35.5));
+ assertState(component, Climate.CURRENT_TEMPERATURE_CH_ID, new QuantityType<>(35.5, ImperialUnits.FAHRENHEIT));
assertState(component, Climate.FAN_MODE_CH_ID, new StringType("p2"));
assertState(component, Climate.HOLD_CH_ID, new StringType("u2"));
assertState(component, Climate.MODE_CH_ID, new StringType("B1"));
assertState(component, Climate.SWING_CH_ID, new StringType("G1"));
- assertState(component, Climate.TEMPERATURE_CH_ID, new DecimalType(30));
- assertState(component, Climate.TEMPERATURE_HIGH_CH_ID, new DecimalType(37));
- assertState(component, Climate.TEMPERATURE_LOW_CH_ID, new DecimalType(20));
+ assertState(component, Climate.TEMPERATURE_CH_ID, new QuantityType<>(30, ImperialUnits.FAHRENHEIT));
+ assertState(component, Climate.TEMPERATURE_HIGH_CH_ID, new QuantityType<>(37, ImperialUnits.FAHRENHEIT));
+ assertState(component, Climate.TEMPERATURE_LOW_CH_ID, new QuantityType<>(20, ImperialUnits.FAHRENHEIT));
component.getChannel(Climate.AUX_CH_ID).getState().publishValue(OnOffType.OFF);
assertPublished("zigbee2mqtt/th1/aux", "OFF");
assertPublished("zigbee2mqtt/th1/power", "OFF");
}
+ @Override
protected Set<String> getConfigTopics() {
return Set.of(CONFIG_TOPIC);
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
+import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;
assertThat(config.holdStateTemplate, is("{{ value_json.preset }}"));
assertThat(config.holdStateTopic, is("zigbee2mqtt/th1"));
assertThat(config.jsonAttributesTopic, is("zigbee2mqtt/th1"));
- assertThat(config.maxTemp, is(35f));
- assertThat(config.minTemp, is(5f));
+ assertThat(config.maxTemp, is(new BigDecimal(35)));
+ assertThat(config.minTemp, is(new BigDecimal(5)));
assertThat(config.modeCommandTopic, is("zigbee2mqtt/th1/set/system_mode"));
assertThat(config.modeStateTemplate, is("{{ value_json.system_mode }}"));
assertThat(config.modeStateTopic, is("zigbee2mqtt/th1"));
assertThat(config.modes, is(List.of("heat", "auto", "off")));
assertThat(config.getName(), is("th1"));
- assertThat(config.tempStep, is(0.5f));
+ assertThat(config.tempStep, is(new BigDecimal("0.5")));
assertThat(config.temperatureCommandTopic, is("zigbee2mqtt/th1/set/current_heating_setpoint"));
assertThat(config.temperatureStateTemplate, is("{{ value_json.current_heating_setpoint }}"));
assertThat(config.temperatureStateTopic, is("zigbee2mqtt/th1"));
- assertThat(config.temperatureUnit, is("C"));
+ assertThat(config.temperatureUnit, is(Climate.TemperatureUnit.CELSIUS));
assertThat(config.getUniqueId(), is("0x847127fffe11dd6a_climate_zigbee2mqtt"));
assertThat(config.initial, is(21));
assertThat(config.temperatureLowStateTopic, is("T"));
assertThat(config.powerCommandTopic, is("U"));
assertThat(config.initial, is(10));
- assertThat(config.maxTemp, is(40f));
- assertThat(config.minTemp, is(0f));
- assertThat(config.temperatureUnit, is("F"));
- assertThat(config.tempStep, is(1f));
- assertThat(config.precision, is(0.5f));
+ assertThat(config.maxTemp, is(new BigDecimal(40)));
+ assertThat(config.minTemp, is(BigDecimal.ZERO));
+ assertThat(config.temperatureUnit, is(Climate.TemperatureUnit.FAHRENHEIT));
+ assertThat(config.tempStep, is(BigDecimal.ONE));
+ assertThat(config.precision, is(new BigDecimal("0.5")));
assertThat(config.sendIfOff, is(false));
}
}
import org.junit.jupiter.api.Test;
import org.openhab.binding.mqtt.generic.values.NumberValue;
-import org.openhab.core.library.types.DecimalType;
+import org.openhab.core.library.types.QuantityType;
+import org.openhab.core.library.unit.Units;
import org.openhab.core.types.UnDefType;
/**
NumberValue.class);
publishMessage("zigbee2mqtt/sensor/state", "10");
- assertState(component, Sensor.SENSOR_CHANNEL_ID, DecimalType.valueOf("10"));
+ assertState(component, Sensor.SENSOR_CHANNEL_ID, new QuantityType<>(10, Units.WATT));
publishMessage("zigbee2mqtt/sensor/state", "20");
- assertState(component, Sensor.SENSOR_CHANNEL_ID, DecimalType.valueOf("20"));
+ assertState(component, Sensor.SENSOR_CHANNEL_ID, new QuantityType<>(20, Units.WATT));
assertThat(component.getChannel(Sensor.SENSOR_CHANNEL_ID).getState().getCache().createStateDescription(true)
- .build().getPattern(), is("%s W"));
+ .build().getPattern(), is("%s %unit%"));
waitForAssert(() -> assertState(component, Sensor.SENSOR_CHANNEL_ID, UnDefType.UNDEF), 10000, 200);
}
+ @Override
protected Set<String> getConfigTopics() {
return Set.of(CONFIG_TOPIC);
}
import org.openhab.core.thing.type.ChannelType;
import org.openhab.core.thing.type.ChannelTypeBuilder;
import org.openhab.core.thing.type.ChannelTypeUID;
+import org.openhab.core.types.util.UnitUtils;
import org.openhab.core.util.UIDUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
if (attributes.unit.contains("%") && attributes.settable) {
value = new PercentageValue(min, max, step, null, null);
} else {
- value = new NumberValue(min, max, step, attributes.unit);
+ value = new NumberValue(min, max, step, UnitUtils.parseUnit(attributes.unit));
}
break;
case datetime_:
projects / openhab-addons.git / commitdiff