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

   1 /**
   2  * Copyright (c) 2010-2021 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.wlanthermo.internal.api.nano;
  14
  15 import static org.openhab.binding.wlanthermo.internal.WlanThermoBindingConstants.*;
  16 import static org.openhab.binding.wlanthermo.internal.WlanThermoUtil.requireNonNull;
  17
  18 import java.awt.*;
  19 import java.math.BigInteger;
  20 import java.util.List;
  21
  22 import javax.measure.Unit;
  23 import javax.measure.quantity.Temperature;
  24
  25 import org.eclipse.jdt.annotation.NonNullByDefault;
  26 import org.openhab.binding.wlanthermo.internal.WlanThermoInputException;
  27 import org.openhab.binding.wlanthermo.internal.WlanThermoUnknownChannelException;
  28 import org.openhab.binding.wlanthermo.internal.api.nano.dto.data.Channel;
  29 import org.openhab.binding.wlanthermo.internal.api.nano.dto.data.Data;
  30 import org.openhab.binding.wlanthermo.internal.api.nano.dto.data.Pm;
  31 import org.openhab.binding.wlanthermo.internal.api.nano.dto.data.System;
  32 import org.openhab.binding.wlanthermo.internal.api.nano.dto.settings.Settings;
  33 import org.openhab.core.library.types.*;
  34 import org.openhab.core.library.unit.ImperialUnits;
  35 import org.openhab.core.library.unit.SIUnits;
  36 import org.openhab.core.library.unit.Units;
  37 import org.openhab.core.thing.ChannelUID;
  38 import org.openhab.core.types.Command;
  39 import org.openhab.core.types.State;
  40 import org.openhab.core.types.UnDefType;
  41
  42 /**
  43  * The {@link WlanThermoNanoV1CommandHandler} is responsible for mapping the Commands to the respective data fields
  44  * of the API.
  45  *
  46  * @author Christian Schlipp - Initial contribution
  47  */
  48 @NonNullByDefault
  49 public class WlanThermoNanoV1CommandHandler {
  50
  51     public static State getState(ChannelUID channelUID, Data data, Settings settings)
  52             throws WlanThermoUnknownChannelException, WlanThermoInputException {
  53         String groupId = requireNonNull(channelUID.getGroupId());
  54         System system = data.getSystem();
  55         Unit<Temperature> unit = "F".equals(system.getUnit()) ? ImperialUnits.FAHRENHEIT : SIUnits.CELSIUS;
  56         List<Channel> channelList = data.getChannel();
  57
  58         if (SYSTEM.equals(groupId)) {
  59             switch (channelUID.getIdWithoutGroup()) {
  60                 case SYSTEM_SOC:
  61                     return new DecimalType(system.getSoc());
  62                 case SYSTEM_CHARGE:
  63                     return OnOffType.from(system.getCharge());
  64                 case SYSTEM_RSSI_SIGNALSTRENGTH:
  65                     int dbm = system.getRssi();
  66                     if (dbm >= -80) {
  67                         return SIGNAL_STRENGTH_4;
  68                     } else if (dbm >= -95) {
  69                         return SIGNAL_STRENGTH_3;
  70                     } else if (dbm >= -105) {
  71                         return SIGNAL_STRENGTH_2;
  72                     } else {
  73                         return SIGNAL_STRENGTH_1;
  74                     }
  75                 case SYSTEM_RSSI:
  76                     return new QuantityType<>(system.getRssi(), Units.DECIBEL_MILLIWATTS);
  77             }
  78         } else if (channelUID.getId().startsWith(CHANNEL_PREFIX)) {
  79             int channelId = Integer.parseInt(groupId.substring(CHANNEL_PREFIX.length())) - 1;
  80             if (channelList.size() > 0 && channelId < channelList.size()) {
  81                 Channel channel = channelList.get(channelId);
  82                 switch (channelUID.getIdWithoutGroup()) {
  83                     case CHANNEL_NAME:
  84                         return new StringType(channel.getName());
  85                     case CHANNEL_TYP:
  86                         return new StringType(settings.sensors.get(channel.getTyp()));
  87                     case CHANNEL_TEMP:
  88                         return channel.getTemp() == 999.0 ? UnDefType.UNDEF
  89                                 : new QuantityType<>(channel.getTemp(), unit);
  90                     case CHANNEL_MIN:
  91                         return new QuantityType<>(channel.getMin(), unit);
  92                     case CHANNEL_MAX:
  93                         return new QuantityType<>(channel.getMax(), unit);
  94                     case CHANNEL_ALARM_DEVICE:
  95                         return OnOffType.from(BigInteger.valueOf(channel.getAlarm()).testBit(1));
  96                     case CHANNEL_ALARM_PUSH:
  97                         return OnOffType.from(BigInteger.valueOf(channel.getAlarm()).testBit(0));
  98                     case CHANNEL_ALARM_OPENHAB_HIGH:
  99                         if (channel.getTemp() != 999 && channel.getTemp() > channel.getMax()) {
 100                             return OnOffType.ON;
 101                         } else {
 102                             return OnOffType.OFF;
 103                         }
 104                     case CHANNEL_ALARM_OPENHAB_LOW:
 105                         if (channel.getTemp() != 999 && channel.getTemp() < channel.getMin()) {
 106                             return OnOffType.ON;
 107                         } else {
 108                             return OnOffType.OFF;
 109                         }
 110                     case CHANNEL_COLOR:
 111                         String color = channel.getColor();
 112                         if (color != null && !color.isEmpty()) {
 113                             Color c = Color.decode(color);
 114                             return HSBType.fromRGB(c.getRed(), c.getGreen(), c.getBlue());
 115                         } else {
 116                             return UnDefType.UNDEF;
 117                         }
 118                     case CHANNEL_COLOR_NAME:
 119                         String colorHex = channel.getColor();
 120                         if (colorHex != null && !colorHex.isEmpty()) {
 121                             return new StringType(WlanThermoNanoV1Util.toColorName(colorHex));
 122                         } else {
 123                             return UnDefType.UNDEF;
 124                         }
 125                 }
 126             }
 127         } else if (channelUID.getId().startsWith(CHANNEL_PITMASTER_1)) {
 128             if (data.getPitmaster() != null && data.getPitmaster().getPm() != null
 129                     && data.getPitmaster().getPm().size() > 0) {
 130                 Pm pm = data.getPitmaster().getPm().get(0);
 131                 switch (channelUID.getIdWithoutGroup()) {
 132                     case CHANNEL_PITMASTER_CHANNEL_ID:
 133                         return new DecimalType(pm.getChannel());
 134                     case CHANNEL_PITMASTER_PIDPROFILE:
 135                         return new DecimalType(pm.getPid());
 136                     case CHANNEL_PITMASTER_DUTY_CYCLE:
 137                         return new DecimalType(pm.getValue());
 138                     case CHANNEL_PITMASTER_SETPOINT:
 139                         return new QuantityType<>(pm.getSet(), unit);
 140                     case CHANNEL_PITMASTER_STATE:
 141                         return new StringType(pm.getTyp());
 142                 }
 143             } else {
 144                 return UnDefType.UNDEF;
 145             }
 146         }
 147         throw new WlanThermoUnknownChannelException(channelUID);
 148     }
 149
 150     public static boolean setState(ChannelUID channelUID, Command command, Data data) {
 151         String groupId;
 152         try {
 153             groupId = requireNonNull(channelUID.getGroupId());
 154         } catch (WlanThermoInputException e) {
 155             return false;
 156         }
 157
 158         List<Channel> channelList = data.getChannel();
 159         System system = data.getSystem();
 160         Unit<Temperature> unit = "F".equals(system.getUnit()) ? ImperialUnits.FAHRENHEIT : SIUnits.CELSIUS;
 161
 162         if (channelUID.getId().startsWith(CHANNEL_PREFIX)) {
 163             int channelId = Integer.parseInt(groupId.substring(CHANNEL_PREFIX.length())) - 1;
 164             if (channelList.size() > 0 && channelId < channelList.size()) {
 165                 Channel channel = channelList.get(channelId);
 166                 switch (channelUID.getIdWithoutGroup()) {
 167                     case CHANNEL_NAME:
 168                         if (command instanceof StringType) {
 169                             channel.setName(command.toFullString());
 170                             return true;
 171                         }
 172                         return false;
 173                     case CHANNEL_MIN:
 174                         if (command instanceof QuantityType) {
 175                             try {
 176                                 channel.setMin(requireNonNull(((QuantityType<?>) command).toUnit(unit)).doubleValue());
 177                                 return true;
 178                             } catch (WlanThermoInputException ignore) {
 179                                 return false;
 180                             }
 181                         }
 182                         return false;
 183                     case CHANNEL_MAX:
 184                         if (command instanceof QuantityType) {
 185                             try {
 186                                 channel.setMax(requireNonNull(((QuantityType<?>) command).toUnit(unit)).doubleValue());
 187                                 return true;
 188                             } catch (WlanThermoInputException ignore) {
 189                                 return false;
 190                             }
 191                         }
 192                         return false;
 193                     case CHANNEL_ALARM_DEVICE:
 194                         if (command instanceof OnOffType) {
 195                             BigInteger value;
 196                             if (command == OnOffType.ON) {
 197                                 value = BigInteger.valueOf(channel.getAlarm()).setBit(1);
 198                             } else {
 199                                 value = BigInteger.valueOf(channel.getAlarm()).clearBit(1);
 200                             }
 201                             channel.setAlarm(value.intValue());
 202                             return true;
 203                         }
 204                         return false;
 205                     case CHANNEL_ALARM_PUSH:
 206                         if (command instanceof OnOffType) {
 207                             BigInteger value;
 208                             if (command == OnOffType.ON) {
 209                                 value = BigInteger.valueOf(channel.getAlarm()).setBit(0);
 210                             } else {
 211                                 value = BigInteger.valueOf(channel.getAlarm()).clearBit(0);
 212                             }
 213                             channel.setAlarm(value.intValue());
 214                             return true;
 215                         }
 216                         return false;
 217                     case CHANNEL_COLOR_NAME:
 218                         if (command instanceof StringType) {
 219                             channel.setColor(WlanThermoNanoV1Util.toHex(((StringType) command).toString()));
 220                             return true;
 221                         }
 222                         return false;
 223                 }
 224             }
 225         } else if (channelUID.getId().startsWith(CHANNEL_PITMASTER_1)) {
 226             if (data.getPitmaster() != null && data.getPitmaster().getPm() != null
 227                     && data.getPitmaster().getPm().size() > 0) {
 228                 Pm pm = data.getPitmaster().getPm().get(0);
 229                 switch (channelUID.getIdWithoutGroup()) {
 230                     case CHANNEL_PITMASTER_CHANNEL_ID:
 231                         pm.setChannel(((DecimalType) command).intValue());
 232                         return true;
 233                     case CHANNEL_PITMASTER_PIDPROFILE:
 234                         pm.setPid(((DecimalType) command).intValue());
 235                         return true;
 236                     case CHANNEL_PITMASTER_SETPOINT:
 237                         try {
 238                             pm.setSet(requireNonNull(((QuantityType<?>) command).toUnit(unit)).doubleValue());
 239                             return true;
 240                         } catch (WlanThermoInputException ignore) {
 241                             return false;
 242                         }
 243                     case CHANNEL_PITMASTER_STATE:
 244                         String state = ((StringType) command).toString();
 245                         if (state.equalsIgnoreCase("off") || state.equalsIgnoreCase("manual")
 246                                 || state.equalsIgnoreCase("auto")) {
 247                             pm.setTyp(state);
 248                             return true;
 249                         }
 250                         return false;
 251                 }
 252             }
 253         }
 254         return false;
 255     }
 256
 257     public static String getTrigger(ChannelUID channelUID, Data data)
 258             throws WlanThermoUnknownChannelException, WlanThermoInputException {
 259
 260         String groupId = requireNonNull(channelUID.getGroupId());
 261         List<Channel> channelList = data.getChannel();
 262
 263         if (channelUID.getId().startsWith(CHANNEL_PREFIX)) {
 264             int channelId = Integer.parseInt(groupId.substring(CHANNEL_PREFIX.length())) - 1;
 265             if (channelList.size() > 0 && channelId < channelList.size()) {
 266                 Channel channel = channelList.get(channelId);
 267                 if (CHANNEL_ALARM_OPENHAB.equals(channelUID.getIdWithoutGroup())) {
 268                     if (channel.getTemp() != 999) {
 269                         if (channel.getTemp() > channel.getMax()) {
 270                             return TRIGGER_ALARM_MAX;
 271                         } else if (channel.getTemp() < channel.getMin()) {
 272                             return TRIGGER_ALARM_MIN;
 273                         } else {
 274                             return TRIGGER_NONE;
 275                         }
 276                     }
 277                 }
 278             }
 279         }
 280         throw new WlanThermoUnknownChannelException(channelUID);
 281     }
 282 }