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

   1 /**
   2  * Copyright (c) 2010-2023 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.goecharger.internal.handler;
  14
  15 import static org.openhab.binding.goecharger.internal.GoEChargerBindingConstants.*;
  16
  17 import java.util.concurrent.ExecutionException;
  18 import java.util.concurrent.TimeUnit;
  19 import java.util.concurrent.TimeoutException;
  20
  21 import javax.measure.quantity.ElectricCurrent;
  22 import javax.measure.quantity.Energy;
  23
  24 import org.eclipse.jdt.annotation.NonNullByDefault;
  25 import org.eclipse.jdt.annotation.Nullable;
  26 import org.eclipse.jetty.client.HttpClient;
  27 import org.eclipse.jetty.client.api.ContentResponse;
  28 import org.eclipse.jetty.http.HttpMethod;
  29 import org.openhab.binding.goecharger.internal.GoEChargerBindingConstants;
  30 import org.openhab.binding.goecharger.internal.api.GoEStatusResponseBaseDTO;
  31 import org.openhab.binding.goecharger.internal.api.GoEStatusResponseDTO;
  32 import org.openhab.binding.goecharger.internal.api.GoEStatusResponseV2DTO;
  33 import org.openhab.core.library.types.DecimalType;
  34 import org.openhab.core.library.types.OnOffType;
  35 import org.openhab.core.library.types.QuantityType;
  36 import org.openhab.core.library.types.StringType;
  37 import org.openhab.core.library.unit.SIUnits;
  38 import org.openhab.core.library.unit.Units;
  39 import org.openhab.core.thing.ChannelUID;
  40 import org.openhab.core.thing.Thing;
  41 import org.openhab.core.thing.ThingStatus;
  42 import org.openhab.core.thing.ThingStatusDetail;
  43 import org.openhab.core.types.Command;
  44 import org.openhab.core.types.RefreshType;
  45 import org.openhab.core.types.State;
  46 import org.openhab.core.types.UnDefType;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49
  50 import com.google.gson.JsonSyntaxException;
  51
  52 /**
  53  * The {@link GoEChargerHandler} is responsible for handling commands, which are
  54  * sent to one of the channels.
  55  *
  56  * @author Samuel Brucksch - Initial contribution
  57  * @author Reinhard Plaim - Adapt to use API version 2
  58  */
  59 @NonNullByDefault
  60 public class GoEChargerHandler extends GoEChargerBaseHandler {
  61
  62     private final Logger logger = LoggerFactory.getLogger(GoEChargerHandler.class);
  63
  64     public GoEChargerHandler(Thing thing, HttpClient httpClient) {
  65         super(thing, httpClient);
  66     }
  67
  68     @Override
  69     protected State getValue(String channelId, GoEStatusResponseBaseDTO goeResponseBase) {
  70         var state = super.getValue(channelId, goeResponseBase);
  71         if (state != UnDefType.UNDEF) {
  72             return state;
  73         }
  74
  75         var goeResponse = (GoEStatusResponseDTO) goeResponseBase;
  76         switch (channelId) {
  77             case MAX_CURRENT_TEMPORARY:
  78                 if (goeResponse.maxCurrentTemporary == null) {
  79                     return UnDefType.UNDEF;
  80                 }
  81                 return new QuantityType<>(goeResponse.maxCurrentTemporary, Units.AMPERE);
  82             case PWM_SIGNAL:
  83                 if (goeResponse.pwmSignal == null) {
  84                     return UnDefType.UNDEF;
  85                 }
  86                 String pwmSignal = null;
  87                 switch (goeResponse.pwmSignal) {
  88                     case 1:
  89                         pwmSignal = "READY_NO_CAR";
  90                         break;
  91                     case 2:
  92                         pwmSignal = "CHARGING";
  93                         break;
  94                     case 3:
  95                         pwmSignal = "WAITING_FOR_CAR";
  96                         break;
  97                     case 4:
  98                         pwmSignal = "CHARGING_DONE_CAR_CONNECTED";
  99                         break;
 100                     default:
 101                 }
 102                 return new StringType(pwmSignal);
 103             case ERROR:
 104                 if (goeResponse.errorCode == null) {
 105                     return UnDefType.UNDEF;
 106                 }
 107                 String error = null;
 108                 switch (goeResponse.errorCode) {
 109                     case 0:
 110                         error = "NONE";
 111                         break;
 112                     case 1:
 113                         error = "RCCB";
 114                         break;
 115                     case 3:
 116                         error = "PHASE";
 117                         break;
 118                     case 8:
 119                         error = "NO_GROUND";
 120                         break;
 121                     default:
 122                         error = "INTERNAL";
 123                         break;
 124                 }
 125                 return new StringType(error);
 126             case ACCESS_CONFIGURATION:
 127                 if (goeResponse.accessConfiguration == null) {
 128                     return UnDefType.UNDEF;
 129                 }
 130                 String accessConfiguration = null;
 131                 switch (goeResponse.accessConfiguration) {
 132                     case 0:
 133                         accessConfiguration = "OPEN";
 134                         break;
 135                     case 1:
 136                         accessConfiguration = "RFID";
 137                         break;
 138                     case 2:
 139                         accessConfiguration = "AWATTAR";
 140                         break;
 141                     case 3:
 142                         accessConfiguration = "TIMER";
 143                         break;
 144                     default:
 145                 }
 146                 return new StringType(accessConfiguration);
 147             case ALLOW_CHARGING:
 148                 if (goeResponse.allowCharging == null) {
 149                     return UnDefType.UNDEF;
 150                 }
 151                 return goeResponse.allowCharging == 1 ? OnOffType.ON : OnOffType.OFF;
 152             case PHASES:
 153                 if (goeResponse.energy == null) {
 154                     return UnDefType.UNDEF;
 155                 }
 156                 int count = 0;
 157                 if (goeResponse.energy[4] > 0) { // current P1
 158                     count++;
 159                 }
 160                 if (goeResponse.energy[5] > 0) { // current P2
 161                     count++;
 162                 }
 163                 if (goeResponse.energy[6] > 0) { // current P3
 164                     count++;
 165                 }
 166                 return new DecimalType(count);
 167             case TEMPERATURE_CIRCUIT_BOARD:
 168                 if (goeResponse.temperature == null) {
 169                     return UnDefType.UNDEF;
 170                 }
 171                 return new QuantityType<>(goeResponse.temperature, SIUnits.CELSIUS);
 172             case SESSION_CHARGE_CONSUMPTION:
 173                 if (goeResponse.sessionChargeConsumption == null) {
 174                     return UnDefType.UNDEF;
 175                 }
 176                 return new QuantityType<>((Double) (goeResponse.sessionChargeConsumption / 360000d),
 177                         Units.KILOWATT_HOUR);
 178             case SESSION_CHARGE_CONSUMPTION_LIMIT:
 179                 if (goeResponse.sessionChargeConsumptionLimit == null) {
 180                     return UnDefType.UNDEF;
 181                 }
 182                 return new QuantityType<>((Double) (goeResponse.sessionChargeConsumptionLimit / 10d),
 183                         Units.KILOWATT_HOUR);
 184             case TOTAL_CONSUMPTION:
 185                 if (goeResponse.totalChargeConsumption == null) {
 186                     return UnDefType.UNDEF;
 187                 }
 188                 return new QuantityType<>((Double) (goeResponse.totalChargeConsumption / 10d), Units.KILOWATT_HOUR);
 189             case CURRENT_L1:
 190                 if (goeResponse.energy == null) {
 191                     return UnDefType.UNDEF;
 192                 }
 193                 // values come in as A*10, 41 means 4.1A
 194                 return new QuantityType<>((Double) (goeResponse.energy[4] / 10d), Units.AMPERE);
 195             case CURRENT_L2:
 196                 if (goeResponse.energy == null) {
 197                     return UnDefType.UNDEF;
 198                 }
 199                 return new QuantityType<>((Double) (goeResponse.energy[5] / 10d), Units.AMPERE);
 200             case CURRENT_L3:
 201                 if (goeResponse.energy == null) {
 202                     return UnDefType.UNDEF;
 203                 }
 204                 return new QuantityType<>((Double) (goeResponse.energy[6] / 10d), Units.AMPERE);
 205             case POWER_L1:
 206                 if (goeResponse.energy == null) {
 207                     return UnDefType.UNDEF;
 208                 }
 209                 // values come in as kW*10, 41 means 4.1kW
 210                 return new QuantityType<>(goeResponse.energy[7] * 100, Units.WATT);
 211             case POWER_L2:
 212                 if (goeResponse.energy == null) {
 213                     return UnDefType.UNDEF;
 214                 }
 215                 return new QuantityType<>(goeResponse.energy[8] * 100, Units.WATT);
 216             case POWER_L3:
 217                 if (goeResponse.energy == null) {
 218                     return UnDefType.UNDEF;
 219                 }
 220                 return new QuantityType<>(goeResponse.energy[9] * 100, Units.WATT);
 221             case VOLTAGE_L1:
 222                 if (goeResponse.energy == null) {
 223                     return UnDefType.UNDEF;
 224                 }
 225                 return new QuantityType<>(goeResponse.energy[0], Units.VOLT);
 226             case VOLTAGE_L2:
 227                 if (goeResponse.energy == null) {
 228                     return UnDefType.UNDEF;
 229                 }
 230                 return new QuantityType<>(goeResponse.energy[1], Units.VOLT);
 231             case VOLTAGE_L3:
 232                 if (goeResponse.energy == null) {
 233                     return UnDefType.UNDEF;
 234                 }
 235                 return new QuantityType<>(goeResponse.energy[2], Units.VOLT);
 236             case POWER_ALL:
 237                 if (goeResponse.energy == null) {
 238                     return UnDefType.UNDEF;
 239                 }
 240                 return new QuantityType<>(goeResponse.energy[11] * 10, Units.WATT);
 241         }
 242         return UnDefType.UNDEF;
 243     }
 244
 245     @Override
 246     public void handleCommand(ChannelUID channelUID, Command command) {
 247         if (command instanceof RefreshType) {
 248             // we can not update single channels and refresh is triggered automatically
 249             // anyways
 250             return;
 251         }
 252
 253         String key = null;
 254         String value = null;
 255
 256         switch (channelUID.getId()) {
 257             case MAX_CURRENT:
 258                 key = "amp";
 259                 if (command instanceof DecimalType) {
 260                     value = String.valueOf(((DecimalType) command).intValue());
 261                 } else if (command instanceof QuantityType<?>) {
 262                     value = String.valueOf(((QuantityType<ElectricCurrent>) command).toUnit(Units.AMPERE).intValue());
 263                 }
 264                 break;
 265             case MAX_CURRENT_TEMPORARY:
 266                 key = "amx";
 267                 if (command instanceof DecimalType) {
 268                     value = String.valueOf(((DecimalType) command).intValue());
 269                 } else if (command instanceof QuantityType<?>) {
 270                     value = String.valueOf(((QuantityType<ElectricCurrent>) command).toUnit(Units.AMPERE).intValue());
 271                 }
 272                 break;
 273             case SESSION_CHARGE_CONSUMPTION_LIMIT:
 274                 key = "dwo";
 275                 var multiplier = 10;
 276                 if (command instanceof DecimalType) {
 277                     value = String.valueOf(((DecimalType) command).intValue() * multiplier);
 278                 } else if (command instanceof QuantityType<?>) {
 279                     value = String.valueOf(
 280                             ((QuantityType<Energy>) command).toUnit(Units.KILOWATT_HOUR).intValue() * multiplier);
 281                 }
 282                 break;
 283             case ALLOW_CHARGING:
 284                 key = "alw";
 285                 if (command instanceof OnOffType) {
 286                     value = command == OnOffType.ON ? "1" : "0";
 287                 }
 288                 break;
 289             case ACCESS_CONFIGURATION:
 290                 key = "ast";
 291                 if (command instanceof StringType) {
 292                     switch (command.toString().toUpperCase()) {
 293                         case "OPEN":
 294                             value = "0";
 295                             break;
 296                         case "RFID":
 297                             value = "1";
 298                             break;
 299                         case "AWATTAR":
 300                             value = "2";
 301                             break;
 302                         case "TIMER":
 303                             value = "3";
 304                             break;
 305                         default:
 306                     }
 307                 }
 308                 break;
 309         }
 310
 311         if (key != null && value != null) {
 312             sendData(key, value);
 313         } else {
 314             logger.warn("Could not update channel {} with key {} and value {}", channelUID.getId(), key, value);
 315         }
 316     }
 317
 318     @Override
 319     public void initialize() {
 320         super.initialize();
 321     }
 322
 323     private String getReadUrl() {
 324         return GoEChargerBindingConstants.API_URL.replace("%IP%", config.ip.toString());
 325     }
 326
 327     private String getWriteUrl(String key, String value) {
 328         return GoEChargerBindingConstants.MQTT_URL.replace("%IP%", config.ip.toString()).replace("%KEY%", key)
 329                 .replace("%VALUE%", value);
 330     }
 331
 332     private void sendData(String key, String value) {
 333         String urlStr = getWriteUrl(key, value);
 334         logger.trace("GET URL = {}", urlStr);
 335
 336         try {
 337             HttpMethod httpMethod = HttpMethod.GET;
 338             ContentResponse contentResponse = httpClient.newRequest(urlStr).method(httpMethod)
 339                     .timeout(5, TimeUnit.SECONDS).send();
 340             String response = contentResponse.getContentAsString();
 341
 342             logger.trace("{} Response: {}", httpMethod.toString(), response);
 343
 344             var statusCode = contentResponse.getStatus();
 345             if (!(statusCode == 200 || statusCode == 204)) {
 346                 updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR,
 347                         "@text/unsuccessful.communication-error");
 348                 logger.debug("Could not send data, Response {}, StatusCode: {}", response, statusCode);
 349             }
 350         } catch (InterruptedException ie) {
 351             Thread.currentThread().interrupt();
 352             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, ie.toString());
 353             logger.debug("Could not send data: {}, {}", urlStr, ie.toString());
 354         } catch (TimeoutException | ExecutionException | JsonSyntaxException e) {
 355             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, e.toString());
 356             logger.debug("Could not send data: {}, {}", urlStr, e.toString());
 357         }
 358     }
 359
 360     /**
 361      * Request new data from Go-eCharger
 362      *
 363      * @return the Go-eCharger object mapping the JSON response or null in case of
 364      *         error
 365      * @throws ExecutionException
 366      * @throws TimeoutException
 367      * @throws InterruptedException
 368      */
 369     @Nullable
 370     @Override
 371     protected GoEStatusResponseBaseDTO getGoEData()
 372             throws InterruptedException, TimeoutException, ExecutionException, JsonSyntaxException {
 373         String urlStr = getReadUrl();
 374         logger.trace("GET URL = {}", urlStr);
 375
 376         ContentResponse contentResponse = httpClient.newRequest(urlStr).method(HttpMethod.GET)
 377                 .timeout(5, TimeUnit.SECONDS).send();
 378
 379         String response = contentResponse.getContentAsString();
 380         logger.trace("GET Response: {}", response);
 381
 382         if (config.apiVersion == 1) {
 383             return gson.fromJson(response, GoEStatusResponseDTO.class);
 384         }
 385         return gson.fromJson(response, GoEStatusResponseV2DTO.class);
 386     }
 387
 388     @Override
 389     protected void updateChannelsAndStatus(@Nullable GoEStatusResponseBaseDTO goeResponse, @Nullable String message) {
 390         if (goeResponse == null) {
 391             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.OFFLINE.COMMUNICATION_ERROR, message);
 392             allChannels.forEach(channel -> updateState(channel, UnDefType.UNDEF));
 393         } else {
 394             updateStatus(ThingStatus.ONLINE, ThingStatusDetail.NONE);
 395             allChannels.forEach(channel -> updateState(channel, getValue(channel, (GoEStatusResponseDTO) goeResponse)));
 396         }
 397     }
 398 }