git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2024 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.knx.internal.dpt;
  14
  15 import static org.openhab.binding.knx.internal.dpt.DPTUtil.NORMALIZED_DPT;
  16
  17 import java.math.BigDecimal;
  18 import java.math.RoundingMode;
  19 import java.text.DecimalFormat;
  20 import java.util.Locale;
  21 import java.util.regex.Matcher;
  22
  23 import org.eclipse.jdt.annotation.NonNullByDefault;
  24 import org.eclipse.jdt.annotation.Nullable;
  25 import org.openhab.core.library.types.DateTimeType;
  26 import org.openhab.core.library.types.DecimalType;
  27 import org.openhab.core.library.types.HSBType;
  28 import org.openhab.core.library.types.IncreaseDecreaseType;
  29 import org.openhab.core.library.types.OnOffType;
  30 import org.openhab.core.library.types.OpenClosedType;
  31 import org.openhab.core.library.types.PercentType;
  32 import org.openhab.core.library.types.QuantityType;
  33 import org.openhab.core.library.types.StopMoveType;
  34 import org.openhab.core.library.types.StringType;
  35 import org.openhab.core.library.types.UpDownType;
  36 import org.openhab.core.library.unit.SIUnits;
  37 import org.openhab.core.library.unit.Units;
  38 import org.openhab.core.types.Type;
  39 import org.openhab.core.util.ColorUtil;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 import tuwien.auto.calimero.KNXException;
  44 import tuwien.auto.calimero.dptxlator.DPT;
  45 import tuwien.auto.calimero.dptxlator.DPTXlator;
  46 import tuwien.auto.calimero.dptxlator.DPTXlator1BitControlled;
  47 import tuwien.auto.calimero.dptxlator.DPTXlator2ByteFloat;
  48 import tuwien.auto.calimero.dptxlator.DPTXlator3BitControlled;
  49 import tuwien.auto.calimero.dptxlator.DPTXlator4ByteFloat;
  50 import tuwien.auto.calimero.dptxlator.DPTXlatorBoolean;
  51 import tuwien.auto.calimero.dptxlator.DPTXlatorDate;
  52 import tuwien.auto.calimero.dptxlator.DPTXlatorDateTime;
  53 import tuwien.auto.calimero.dptxlator.DPTXlatorTime;
  54 import tuwien.auto.calimero.dptxlator.TranslatorTypes;
  55
  56 /**
  57  * This class encodes openHAB data types to strings for sending via Calimero
  58  *
  59  * Parts of this code are based on the openHAB KNXCoreTypeMapper by Kai Kreuzer et al.
  60  *
  61  * @author Jan N. Klug - Initial contribution
  62  */
  63 @NonNullByDefault
  64 public class ValueEncoder {
  65     private static final Logger LOGGER = LoggerFactory.getLogger(ValueEncoder.class);
  66
  67     private ValueEncoder() {
  68         // prevent instantiation
  69     }
  70
  71     /**
  72      * Formats the given value as String for outputting via Calimero.
  73      *
  74      * @param value the value
  75      * @param dptId the DPT id to use for formatting the string (e.g. 9.001)
  76      * @return the value formatted as String
  77      */
  78     public static @Nullable String encode(Type value, String dptId) {
  79         Matcher m = DPTUtil.DPT_PATTERN.matcher(dptId);
  80         if (!m.matches() || m.groupCount() != 2) {
  81             LOGGER.warn("Couldn't identify main/sub number in dptId '{}'", dptId);
  82             return null;
  83         }
  84
  85         String mainNumber = m.group("main");
  86
  87         try {
  88             DPTXlator translator = TranslatorTypes.createTranslator(Integer.parseInt(mainNumber),
  89                     NORMALIZED_DPT.getOrDefault(dptId, dptId));
  90             DPT dpt = translator.getType();
  91
  92             // check for HSBType first, because it extends PercentType as well
  93             if (value instanceof HSBType type) {
  94                 return handleHSBType(dptId, type);
  95             } else if (value instanceof OnOffType) {
  96                 return OnOffType.OFF == value ? dpt.getLowerValue() : dpt.getUpperValue();
  97             } else if (value instanceof UpDownType) {
  98                 return UpDownType.UP == value ? dpt.getLowerValue() : dpt.getUpperValue();
  99             } else if (value instanceof IncreaseDecreaseType) {
 100                 DPT valueDPT = ((DPTXlator3BitControlled.DPT3BitControlled) dpt).getControlDPT();
 101                 return IncreaseDecreaseType.DECREASE == value ? valueDPT.getLowerValue() + " 5"
 102                         : valueDPT.getUpperValue() + " 5";
 103             } else if (value instanceof OpenClosedType) {
 104                 return OpenClosedType.CLOSED == value ? dpt.getLowerValue() : dpt.getUpperValue();
 105             } else if (value instanceof StopMoveType) {
 106                 return StopMoveType.STOP == value ? dpt.getLowerValue() : dpt.getUpperValue();
 107             } else if (value instanceof PercentType type) {
 108                 int intValue = type.intValue();
 109                 return "251.600".equals(dptId) ? String.format("- - - %d %%", intValue) : String.valueOf(intValue);
 110             } else if (value instanceof DecimalType || value instanceof QuantityType<?>) {
 111                 return handleNumericTypes(dptId, mainNumber, dpt, value);
 112             } else if (value instanceof StringType) {
 113                 if ("243.600".equals(dptId) || "249.600".equals(dptId)) {
 114                     return value.toString().replace('.', ((DecimalFormat) DecimalFormat.getInstance())
 115                             .getDecimalFormatSymbols().getDecimalSeparator());
 116                 }
 117                 return value.toString();
 118             } else if (value instanceof DateTimeType type) {
 119                 return handleDateTimeType(dptId, type);
 120             }
 121         } catch (KNXException e) {
 122             return null;
 123         } catch (Exception e) {
 124             LOGGER.warn("An exception occurred converting value {} to dpt id {}: error message={}", value, dptId,
 125                     e.getMessage());
 126             return null;
 127         }
 128
 129         LOGGER.debug("formatAsDPTString: Couldn't convert value {} to dpt id {} (no mapping).", value, dptId);
 130         return null;
 131     }
 132
 133     /**
 134      * Formats the given internal <code>dateType</code> to a knx readable String
 135      * according to the target datapoint type <code>dpt</code>.
 136      *
 137      * @param value the input value
 138      * @param dptId the target datapoint type
 139      *
 140      * @return a String which contains either an ISO8601 formatted date (yyyy-mm-dd),
 141      *         a formatted 24-hour clock with the day of week prepended (Mon, 12:00:00) or
 142      *         a formatted 24-hour clock (12:00:00)
 143      */
 144     private static @Nullable String handleDateTimeType(String dptId, DateTimeType value) {
 145         if (DPTXlatorDate.DPT_DATE.getID().equals(dptId)) {
 146             return value.format("%tF");
 147         } else if (DPTXlatorTime.DPT_TIMEOFDAY.getID().equals(dptId)) {
 148             return value.format(Locale.US, "%1$ta, %1$tT");
 149         } else if (DPTXlatorDateTime.DPT_DATE_TIME.getID().equals(dptId)) {
 150             return value.format(Locale.US, "%tF %1$tT");
 151         }
 152         LOGGER.warn("Could not format DateTimeType for datapoint type '{}'", dptId);
 153         return null;
 154     }
 155
 156     private static String handleHSBType(String dptId, HSBType hsb) {
 157         switch (dptId) {
 158             case "232.600":
 159                 int[] rgb = ColorUtil.hsbToRgb(hsb);
 160                 return String.format("r:%d g:%d b:%d", rgb[0], rgb[1], rgb[2]);
 161             case "232.60000":
 162                 // MDT specific: mis-use 232.600 for hsv instead of rgb
 163                 int hue = hsb.getHue().toBigDecimal().multiply(BigDecimal.valueOf(255))
 164                         .divide(BigDecimal.valueOf(360), 0, RoundingMode.HALF_UP).intValue();
 165                 return "r:" + hue + " g:" + convertPercentToByte(hsb.getSaturation()) + " b:"
 166                         + convertPercentToByte(hsb.getBrightness());
 167             case "242.600":
 168                 double[] xyY = ColorUtil.hsbToXY(hsb);
 169                 return String.format("(%,.4f %,.4f) %,.1f %%", xyY[0], xyY[1], xyY[2] * 100.0);
 170             case "251.600":
 171                 PercentType[] rgbw = ColorUtil.hsbToRgbPercent(hsb);
 172                 return String.format("%,.1f %,.1f %,.1f - %%", rgbw[0].doubleValue(), rgbw[1].doubleValue(),
 173                         rgbw[2].doubleValue());
 174             case "251.60600":
 175                 PercentType[] rgbw2 = ColorUtil.hsbToRgbwPercent(hsb);
 176                 return String.format("%,.1f %,.1f %,.1f %,.1f %%", rgbw2[0].doubleValue(), rgbw2[1].doubleValue(),
 177                         rgbw2[2].doubleValue(), rgbw2[3].doubleValue());
 178             case "5.003":
 179                 return hsb.getHue().toString();
 180             default:
 181                 return hsb.getBrightness().toString();
 182         }
 183     }
 184
 185     private static String handleNumericTypes(String dptId, String mainNumber, DPT dpt, Type value) {
 186         BigDecimal bigDecimal;
 187         if (value instanceof DecimalType decimalType) {
 188             bigDecimal = decimalType.toBigDecimal();
 189         } else {
 190             String unit = DPTUnits.getUnitForDpt(dptId);
 191
 192             // exception for DPT using temperature differences
 193             // - conversion °C or °F to K is wrong for differences,
 194             // - stick to the unit given, fix the scaling for °F
 195             // 9.002 DPT_Value_Tempd
 196             // 9.003 DPT_Value_Tempa
 197             // 9.023 DPT_KelvinPerPercent
 198             if (DPTXlator2ByteFloat.DPT_TEMPERATURE_DIFFERENCE.getID().equals(dptId)
 199                     || DPTXlator2ByteFloat.DPT_TEMPERATURE_GRADIENT.getID().equals(dptId)
 200                     || DPTXlator2ByteFloat.DPT_KELVIN_PER_PERCENT.getID().equals(dptId)) {
 201                 // match unicode character or °C
 202                 if (value.toString().contains(SIUnits.CELSIUS.getSymbol()) || value.toString().contains("°C")) {
 203                     if (unit != null) {
 204                         unit = unit.replace("K", "°C");
 205                     }
 206                 } else if (value.toString().contains("°F")) {
 207                     // an new approach to handle temperature differences was introduced to core
 208                     // after 4.0, stripping the unit and and creating a new QuantityType works
 209                     // both with core release 4.0 and current snapshot
 210                     boolean perPercent = value.toString().contains("/%");
 211                     value = new QuantityType<>(((QuantityType<?>) value).doubleValue() * 5.0 / 9.0, Units.KELVIN);
 212                     // PercentType needs to be adapted
 213                     if (perPercent) {
 214                         value = ((QuantityType<?>) value).multiply(BigDecimal.valueOf(100));
 215                     }
 216                 }
 217             } else if (DPTXlator4ByteFloat.DPT_LIGHT_QUANTITY.getID().equals(dptId)) {
 218                 if (!value.toString().contains("J")) {
 219                     if (unit != null) {
 220                         unit = unit.replace("J", "lm*s");
 221                     }
 222                 }
 223             } else if (DPTXlator4ByteFloat.DPT_ELECTRIC_FLUX.getID().equals(dptId)) {
 224                 // use alternate definition of flux
 225                 if (value.toString().contains("C")) {
 226                     unit = "C";
 227                 }
 228             }
 229
 230             if (unit != null) {
 231                 QuantityType<?> converted = ((QuantityType<?>) value).toUnit(unit);
 232                 if (converted == null) {
 233                     LOGGER.warn("Could not convert {} to unit {}, stripping unit only. Check your configuration.",
 234                             value, unit);
 235                     bigDecimal = ((QuantityType<?>) value).toBigDecimal();
 236                 } else {
 237                     bigDecimal = converted.toBigDecimal();
 238                 }
 239             } else {
 240                 bigDecimal = ((QuantityType<?>) value).toBigDecimal();
 241             }
 242         }
 243         switch (mainNumber) {
 244             case "1":
 245                 if (DPTXlatorBoolean.DPT_SCENE_AB.getID().equals(dptId)) {
 246                     return (bigDecimal.intValue() == 0) ? dpt.getLowerValue() : dpt.getUpperValue();
 247                 }
 248                 return bigDecimal.stripTrailingZeros().toPlainString();
 249             case "2":
 250                 DPT valueDPT = ((DPTXlator1BitControlled.DPT1BitControlled) dpt).getValueDPT();
 251                 switch (bigDecimal.intValue()) {
 252                     case 0:
 253                         return "0 " + valueDPT.getLowerValue();
 254                     case 1:
 255                         return "0 " + valueDPT.getUpperValue();
 256                     case 2:
 257                         return "1 " + valueDPT.getLowerValue();
 258                     default:
 259                         return "1 " + valueDPT.getUpperValue();
 260                 }
 261             case "18":
 262                 int intVal = bigDecimal.intValue();
 263                 if (intVal > 63) {
 264                     return "learn " + (intVal - 0x80);
 265                 } else {
 266                     return "activate " + intVal;
 267                 }
 268             case "8":
 269                 if ("8.010".equals(dptId)) {
 270                     // 8.010 has a resolution of 0.01 and will be scaled. Calimero expects locale-specific separator.
 271                     return bigDecimal.stripTrailingZeros().toPlainString().replace('.',
 272                             ((DecimalFormat) DecimalFormat.getInstance()).getDecimalFormatSymbols()
 273                                     .getDecimalSeparator());
 274                 }
 275                 // fallthrough
 276             default:
 277                 return bigDecimal.stripTrailingZeros().toPlainString();
 278         }
 279     }
 280
 281     /**
 282      * convert 0...100% to 1 byte 0..255
 283      *
 284      * @param percent
 285      * @return int 0..255
 286      */
 287     private static int convertPercentToByte(PercentType percent) {
 288         return percent.toBigDecimal().multiply(BigDecimal.valueOf(255))
 289                 .divide(BigDecimal.valueOf(100), 0, RoundingMode.HALF_UP).intValue();
 290     }
 291 }