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

   1 /**
   2  * Copyright (c) 2010-2020 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.senechome.internal;
  14
  15 import static org.openhab.core.types.RefreshType.REFRESH;
  16
  17 import java.io.IOException;
  18 import java.math.BigDecimal;
  19 import java.math.RoundingMode;
  20 import java.time.Duration;
  21 import java.util.Date;
  22 import java.util.concurrent.ExecutionException;
  23 import java.util.concurrent.ScheduledFuture;
  24 import java.util.concurrent.TimeUnit;
  25 import java.util.concurrent.TimeoutException;
  26
  27 import javax.measure.quantity.Dimensionless;
  28 import javax.measure.quantity.ElectricCurrent;
  29 import javax.measure.quantity.ElectricPotential;
  30 import javax.measure.quantity.Energy;
  31 import javax.measure.quantity.Frequency;
  32 import javax.measure.quantity.Power;
  33
  34 import org.eclipse.jdt.annotation.NonNullByDefault;
  35 import org.eclipse.jdt.annotation.Nullable;
  36 import org.eclipse.jetty.client.HttpClient;
  37 import org.openhab.binding.senechome.internal.json.SenecHomeResponse;
  38 import org.openhab.core.cache.ExpiringCache;
  39 import org.openhab.core.library.types.DecimalType;
  40 import org.openhab.core.library.types.OnOffType;
  41 import org.openhab.core.library.types.QuantityType;
  42 import org.openhab.core.library.types.StringType;
  43 import org.openhab.core.library.unit.Units;
  44 import org.openhab.core.thing.Channel;
  45 import org.openhab.core.thing.ChannelUID;
  46 import org.openhab.core.thing.Thing;
  47 import org.openhab.core.thing.ThingStatus;
  48 import org.openhab.core.thing.ThingStatusDetail;
  49 import org.openhab.core.thing.binding.BaseThingHandler;
  50 import org.openhab.core.types.Command;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 /**
  55  * The {@link SenecHomeHandler} is responsible for handling commands, which are
  56  * sent to one of the channels.
  57  *
  58  * @author Steven Schwarznau - Initial contribution
  59  */
  60 @NonNullByDefault
  61 public class SenecHomeHandler extends BaseThingHandler {
  62
  63     private final Logger logger = LoggerFactory.getLogger(SenecHomeHandler.class);
  64     private final static String VALUE_TYPE_INT = "u3";
  65     private final static String VALUE_TYPE_UNSIGNED_INT = "u8";
  66     private final static String VALUE_TYPE_FLOAT = "fl";
  67
  68     private @Nullable ScheduledFuture<?> refreshJob;
  69     private @Nullable PowerLimitationStatusDTO limitationStatus = null;
  70     private final @Nullable SenecHomeApi senecHomeApi;
  71     private SenecHomeConfigurationDTO config = new SenecHomeConfigurationDTO();
  72     private final ExpiringCache<Boolean> refreshCache = new ExpiringCache<>(Duration.ofSeconds(5), this::refreshState);
  73
  74     public SenecHomeHandler(Thing thing, HttpClient httpClient) {
  75         super(thing);
  76         this.senecHomeApi = new SenecHomeApi(httpClient);
  77     }
  78
  79     @Override
  80     public void handleRemoval() {
  81         stopJobIfRunning();
  82         super.handleRemoval();
  83     }
  84
  85     @Override
  86     public void handleCommand(ChannelUID channelUID, Command command) {
  87         if (command == REFRESH) {
  88             logger.debug("Refreshing {}", channelUID);
  89             refresh();
  90         } else {
  91             logger.trace("The SenecHome-Binding is a read-only binding and can not handle commands");
  92         }
  93     }
  94
  95     @Override
  96     public void dispose() {
  97         stopJobIfRunning();
  98         super.dispose();
  99     }
 100
 101     protected void stopJobIfRunning() {
 102         final ScheduledFuture<?> refreshJob = this.refreshJob;
 103         if (refreshJob != null && !refreshJob.isCancelled()) {
 104             refreshJob.cancel(true);
 105             this.refreshJob = null;
 106         }
 107     }
 108
 109     @Override
 110     public void initialize() {
 111         config = getConfigAs(SenecHomeConfigurationDTO.class);
 112         senecHomeApi.setHostname(config.hostname);
 113         refreshJob = scheduler.scheduleWithFixedDelay(this::refresh, 0, config.refreshInterval, TimeUnit.SECONDS);
 114         limitationStatus = null;
 115     }
 116
 117     private void refresh() {
 118         refreshCache.getValue();
 119     }
 120
 121     public @Nullable Boolean refreshState() {
 122         try {
 123             SenecHomeResponse response = senecHomeApi.getStatistics();
 124             logger.trace("received {}", response);
 125
 126             BigDecimal pvLimitation = new BigDecimal(100).subtract(getSenecValue(response.limitation.powerLimitation))
 127                     .setScale(0, RoundingMode.HALF_UP);
 128
 129             updateState(SenecHomeBindingConstants.CHANNEL_SENEC_POWER_LIMITATION,
 130                     new QuantityType<Dimensionless>(pvLimitation, Units.PERCENT));
 131
 132             Channel channelLimitationState = getThing()
 133                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_POWER_LIMITATION_STATE);
 134             if (channelLimitationState != null) {
 135                 updatePowerLimitationStatus(channelLimitationState,
 136                         (100 - pvLimitation.intValue()) <= config.limitationTresholdValue, config.limitationDuration);
 137             }
 138
 139             Channel channelConsumption = getThing()
 140                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_POWER_CONSUMPTION);
 141             if (channelConsumption != null) {
 142                 updateState(channelConsumption.getUID(),
 143                         new QuantityType<Power>(
 144                                 getSenecValue(response.energy.homePowerConsumption).setScale(2, RoundingMode.HALF_UP),
 145                                 Units.WATT));
 146             }
 147
 148             Channel channelEnergyProduction = getThing()
 149                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_ENERGY_PRODUCTION);
 150             if (channelEnergyProduction != null) {
 151                 updateState(channelEnergyProduction.getUID(), new QuantityType<Power>(
 152                         getSenecValue(response.energy.inverterPowerGeneration).setScale(0, RoundingMode.HALF_UP),
 153                         Units.WATT));
 154             }
 155
 156             Channel channelBatteryPower = getThing().getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_BATTERY_POWER);
 157             if (channelBatteryPower != null) {
 158                 updateState(channelBatteryPower.getUID(), new QuantityType<Power>(
 159                         getSenecValue(response.energy.batteryPower).setScale(2, RoundingMode.HALF_UP), Units.WATT));
 160             }
 161
 162             Channel channelBatteryFuelCharge = getThing()
 163                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_BATTERY_FUEL_CHARGE);
 164             if (channelBatteryFuelCharge != null) {
 165                 updateState(channelBatteryFuelCharge.getUID(),
 166                         new QuantityType<Dimensionless>(
 167                                 getSenecValue(response.energy.batteryFuelCharge).setScale(0, RoundingMode.HALF_UP),
 168                                 Units.PERCENT));
 169             }
 170
 171             Channel channelGridCurrentPhase1 = getThing()
 172                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_CURRENT_PH1);
 173             updateState(channelGridCurrentPhase1.getUID(), new QuantityType<ElectricCurrent>(
 174                     getSenecValue(response.grid.currentGridCurrentPerPhase[0]).setScale(2, RoundingMode.HALF_UP),
 175                     Units.AMPERE));
 176
 177             Channel channelGridCurrentPhase2 = getThing()
 178                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_CURRENT_PH2);
 179             updateState(channelGridCurrentPhase2.getUID(), new QuantityType<ElectricCurrent>(
 180                     getSenecValue(response.grid.currentGridCurrentPerPhase[1]).setScale(2, RoundingMode.HALF_UP),
 181                     Units.AMPERE));
 182
 183             Channel channelGridCurrentPhase3 = getThing()
 184                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_CURRENT_PH3);
 185             updateState(channelGridCurrentPhase3.getUID(), new QuantityType<ElectricCurrent>(
 186                     getSenecValue(response.grid.currentGridCurrentPerPhase[2]).setScale(2, RoundingMode.HALF_UP),
 187                     Units.AMPERE));
 188
 189             Channel channelGridPowerPhase1 = getThing()
 190                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_POWER_PH1);
 191             updateState(channelGridPowerPhase1.getUID(),
 192                     new QuantityType<Power>(
 193                             getSenecValue(response.grid.currentGridPowerPerPhase[0]).setScale(2, RoundingMode.HALF_UP),
 194                             Units.WATT));
 195
 196             Channel channelGridPowerPhase2 = getThing()
 197                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_POWER_PH2);
 198             updateState(channelGridPowerPhase2.getUID(),
 199                     new QuantityType<Power>(
 200                             getSenecValue(response.grid.currentGridPowerPerPhase[1]).setScale(2, RoundingMode.HALF_UP),
 201                             Units.WATT));
 202
 203             Channel channelGridPowerPhase3 = getThing()
 204                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_POWER_PH3);
 205             updateState(channelGridPowerPhase3.getUID(),
 206                     new QuantityType<Power>(
 207                             getSenecValue(response.grid.currentGridPowerPerPhase[2]).setScale(2, RoundingMode.HALF_UP),
 208                             Units.WATT));
 209
 210             Channel channelGridVoltagePhase1 = getThing()
 211                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_VOLTAGE_PH1);
 212             updateState(channelGridVoltagePhase1.getUID(), new QuantityType<ElectricPotential>(
 213                     getSenecValue(response.grid.currentGridVoltagePerPhase[0]).setScale(2, RoundingMode.HALF_UP),
 214                     Units.VOLT));
 215
 216             Channel channelGridVoltagePhase2 = getThing()
 217                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_VOLTAGE_PH2);
 218             updateState(channelGridVoltagePhase2.getUID(), new QuantityType<ElectricPotential>(
 219                     getSenecValue(response.grid.currentGridVoltagePerPhase[1]).setScale(2, RoundingMode.HALF_UP),
 220                     Units.VOLT));
 221
 222             Channel channelGridVoltagePhase3 = getThing()
 223                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_VOLTAGE_PH3);
 224             updateState(channelGridVoltagePhase3.getUID(), new QuantityType<ElectricPotential>(
 225                     getSenecValue(response.grid.currentGridVoltagePerPhase[2]).setScale(2, RoundingMode.HALF_UP),
 226                     Units.VOLT));
 227
 228             Channel channelGridFrequency = getThing()
 229                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_FREQUENCY);
 230             updateState(channelGridFrequency.getUID(), new QuantityType<Frequency>(
 231                     getSenecValue(response.grid.currentGridFrequency).setScale(2, RoundingMode.HALF_UP), Units.HERTZ));
 232
 233             Channel channelBatteryStateValue = getThing()
 234                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_BATTERY_STATE_VALUE);
 235             updateState(channelBatteryStateValue.getUID(),
 236                     new DecimalType(getSenecValue(response.energy.batteryState).intValue()));
 237
 238             Channel channelLiveBatCharge = getThing()
 239                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_LIVE_BAT_CHARGE);
 240             updateState(channelLiveBatCharge.getUID(),
 241                     new QuantityType<Energy>(
 242                             getSenecValue(response.statistics.liveBatCharge).setScale(2, RoundingMode.HALF_UP),
 243                             Units.WATT_HOUR));
 244
 245             Channel channelLiveBatDischarge = getThing()
 246                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_LIVE_BAT_DISCHARGE);
 247             updateState(channelLiveBatDischarge.getUID(),
 248                     new QuantityType<Energy>(
 249                             getSenecValue(response.statistics.liveBatDischarge).setScale(2, RoundingMode.HALF_UP),
 250                             Units.WATT_HOUR));
 251
 252             Channel channelLiveGridImport = getThing()
 253                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_LIVE_GRID_IMPORT);
 254             updateState(channelLiveGridImport.getUID(),
 255                     new QuantityType<Energy>(
 256                             getSenecValue(response.statistics.liveGridImport).setScale(2, RoundingMode.HALF_UP),
 257                             Units.WATT_HOUR));
 258
 259             Channel channelLiveGridExport = getThing()
 260                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_LIVE_GRID_EXPORT);
 261             updateState(channelLiveGridExport.getUID(),
 262                     new QuantityType<Energy>(
 263                             getSenecValue(response.statistics.liveGridExport).setScale(2, RoundingMode.HALF_UP),
 264                             Units.WATT_HOUR));
 265
 266             Channel channelBatteryVoltage = getThing()
 267                     .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_BATTERY_VOLTAGE);
 268             updateState(channelBatteryVoltage.getUID(), new QuantityType<ElectricPotential>(
 269                     getSenecValue(response.energy.batteryVoltage).setScale(2, RoundingMode.HALF_UP), Units.VOLT));
 270
 271             Channel channelBatteryState = getThing().getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_BATTERY_STATE);
 272             if (channelBatteryState != null) {
 273                 updateBatteryState(channelBatteryState, getSenecValue(response.energy.batteryState).intValue());
 274             }
 275
 276             updateGridPowerValues(getSenecValue(response.grid.currentGridValue));
 277
 278             updateStatus(ThingStatus.ONLINE);
 279         } catch (IOException | InterruptedException | TimeoutException | ExecutionException e) {
 280             logger.warn("Error refreshing source '{}'", getThing().getUID(), e);
 281             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
 282                     "Could not connect to Senec web interface:" + e.getMessage());
 283         }
 284
 285         return Boolean.TRUE;
 286     }
 287
 288     protected BigDecimal getSenecValue(String value) {
 289         String[] type = value.split("_");
 290
 291         if (VALUE_TYPE_INT.equalsIgnoreCase(type[0])) {
 292             return new BigDecimal(Integer.valueOf(type[1], 16));
 293         } else if (VALUE_TYPE_UNSIGNED_INT.equalsIgnoreCase(type[0])) {
 294             return new BigDecimal(Integer.valueOf(type[1], 16));
 295         } else if (VALUE_TYPE_FLOAT.equalsIgnoreCase(type[0])) {
 296             return parseFloatValue(type[1]);
 297         } else {
 298             logger.warn("Unknown value type [{}]", type[0]);
 299         }
 300
 301         return BigDecimal.ZERO;
 302     }
 303
 304     /**
 305      * Parse the hex coded float value of Senec device and return as BigDecimal
 306      *
 307      * @param value String with hex float
 308      * @return BigDecimal with float value
 309      */
 310     private static BigDecimal parseFloatValue(String value) {
 311         // sample: value = 43E26188
 312
 313         float f = Float.intBitsToFloat(Integer.parseUnsignedInt(value, 16));
 314         return new BigDecimal(f);
 315     }
 316
 317     protected void updatePowerLimitationStatus(Channel channel, boolean status, int duration) {
 318         if (this.limitationStatus != null) {
 319             if (this.limitationStatus.state == status) {
 320                 long stateSince = new Date().getTime() - this.limitationStatus.time;
 321
 322                 if (((int) (stateSince / 1000)) < duration) {
 323                     // skip updating state (possible flapping state)
 324                     return;
 325                 } else {
 326                     logger.debug("{} longer than required duration {}", status, duration);
 327                 }
 328             } else {
 329                 this.limitationStatus.state = status;
 330                 this.limitationStatus.time = new Date().getTime();
 331
 332                 // skip updating state (state changed, possible flapping state)
 333                 return;
 334             }
 335         } else {
 336             this.limitationStatus = new PowerLimitationStatusDTO();
 337             this.limitationStatus.state = status;
 338         }
 339
 340         logger.debug("Updating power limitation state {}", status);
 341         updateState(channel.getUID(), status ? OnOffType.ON : OnOffType.OFF);
 342     }
 343
 344     protected void updateBatteryState(Channel channel, int code) {
 345         updateState(channel.getUID(), new StringType(SenecBatteryStatus.descriptionFromCode(code)));
 346     }
 347
 348     protected void updateGridPowerValues(BigDecimal gridTotalValue) {
 349         BigDecimal gridTotal = gridTotalValue.setScale(2, RoundingMode.HALF_UP);
 350
 351         Channel channelGridPower = getThing().getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_POWER);
 352         if (channelGridPower != null) {
 353             updateState(channelGridPower.getUID(), new QuantityType<Power>(gridTotal, Units.WATT));
 354         }
 355
 356         Channel channelGridPowerSupply = getThing()
 357                 .getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_POWER_SUPPLY);
 358         if (channelGridPowerSupply != null) {
 359             BigDecimal gridSupply = gridTotal.compareTo(BigDecimal.ZERO) < 0 ? gridTotal.abs() : BigDecimal.ZERO;
 360             updateState(channelGridPowerSupply.getUID(), new QuantityType<Power>(gridSupply, Units.WATT));
 361         }
 362
 363         Channel channelGridPowerDraw = getThing().getChannel(SenecHomeBindingConstants.CHANNEL_SENEC_GRID_POWER_DRAW);
 364         if (channelGridPowerDraw != null) {
 365             BigDecimal gridDraw = gridTotal.compareTo(BigDecimal.ZERO) < 0 ? BigDecimal.ZERO : gridTotal.abs();
 366             updateState(channelGridPowerDraw.getUID(), new QuantityType<Power>(gridDraw, Units.WATT));
 367         }
 368     }
 369 }