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.haywardomnilogic.internal.handler;
  14
  15 import java.math.BigDecimal;
  16 import java.util.ArrayList;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import java.util.Map;
  20
  21 import org.eclipse.jdt.annotation.NonNullByDefault;
  22 import org.openhab.binding.haywardomnilogic.internal.HaywardBindingConstants;
  23 import org.openhab.binding.haywardomnilogic.internal.HaywardException;
  24 import org.openhab.binding.haywardomnilogic.internal.HaywardThingHandler;
  25 import org.openhab.core.library.types.OnOffType;
  26 import org.openhab.core.thing.Bridge;
  27 import org.openhab.core.thing.Channel;
  28 import org.openhab.core.thing.ChannelUID;
  29 import org.openhab.core.thing.Thing;
  30 import org.openhab.core.thing.ThingStatus;
  31 import org.openhab.core.thing.ThingStatusDetail;
  32 import org.openhab.core.types.Command;
  33 import org.openhab.core.types.RefreshType;
  34 import org.openhab.core.types.State;
  35 import org.openhab.core.types.StateDescriptionFragment;
  36 import org.openhab.core.types.StateDescriptionFragmentBuilder;
  37 import org.openhab.core.types.StateOption;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40
  41 /**
  42  * The Pump Handler
  43  *
  44  * @author Matt Myers - Initial contribution
  45  */
  46 @NonNullByDefault
  47 public class HaywardPumpHandler extends HaywardThingHandler {
  48     private final Logger logger = LoggerFactory.getLogger(HaywardPumpHandler.class);
  49     private Map<String, State> channelStates = new HashMap<>();
  50
  51     public HaywardPumpHandler(Thing thing) {
  52         super(thing);
  53     }
  54
  55     @Override
  56     public void initialize() {
  57         try {
  58             setStateDescriptions();
  59             updateStatus(ThingStatus.ONLINE);
  60         } catch (HaywardException e) {
  61             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR,
  62                     "Unable to setPumpHandler StateDescriptions");
  63         }
  64     }
  65
  66     @Override
  67     public void setStateDescriptions() throws HaywardException {
  68         List<StateOption> options = new ArrayList<>();
  69         String option;
  70
  71         Bridge bridge = getBridge();
  72         if (bridge != null) {
  73             HaywardBridgeHandler bridgehandler = (HaywardBridgeHandler) bridge.getHandler();
  74             if (bridgehandler != null) {
  75                 // Set Pump % min and max speeds
  76                 Channel ch = thing.getChannel(HaywardBindingConstants.CHANNEL_PUMP_SPEEDPERCENT);
  77                 if (ch != null) {
  78                     StateDescriptionFragment stateDescriptionFragment = StateDescriptionFragmentBuilder.create()
  79                             .withMinimum(new BigDecimal(
  80                                     getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_MINSPEED)))
  81                             .withMaximum(new BigDecimal(
  82                                     getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_MAXSPEED)))
  83                             .build();
  84                     bridgehandler.updateChannelStateDescriptionFragment(ch, stateDescriptionFragment);
  85                 }
  86
  87                 // Set Pump Speed RPM min and max speeds
  88                 ch = thing.getChannel(HaywardBindingConstants.CHANNEL_PUMP_SPEEDRPM);
  89                 if (ch != null) {
  90                     StateDescriptionFragment stateDescriptionFragment = StateDescriptionFragmentBuilder.create()
  91                             .withMinimum(new BigDecimal(
  92                                     getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_MINRPM)))
  93                             .withMaximum(new BigDecimal(
  94                                     getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_MAXRPM)))
  95                             .build();
  96                     bridgehandler.updateChannelStateDescriptionFragment(ch, stateDescriptionFragment);
  97                 }
  98
  99                 // Set Pump Speed States
 100                 ch = thing.getChannel(HaywardBindingConstants.CHANNEL_PUMP_SPEEDSELECT);
 101                 if (ch != null) {
 102                     options.add(new StateOption("0", "Off"));
 103                     option = getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_LOWSPEED);
 104                     if (option != null) {
 105                         options.add(new StateOption(option, "Low"));
 106                     }
 107                     option = getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_MEDSPEED);
 108                     if (option != null) {
 109                         options.add(new StateOption(option, "Medium"));
 110                     }
 111                     option = getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_HIGHSPEED);
 112                     if (option != null) {
 113                         options.add(new StateOption(option, "High"));
 114                     }
 115                     option = getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_CUSTOMSPEED);
 116                     if (option != null) {
 117                         options.add(new StateOption(option, "Custom"));
 118                     }
 119
 120                     StateDescriptionFragment stateDescriptionFragment = StateDescriptionFragmentBuilder.create()
 121                             .withOptions(options).build();
 122                     bridgehandler.updateChannelStateDescriptionFragment(ch, stateDescriptionFragment);
 123                 }
 124             }
 125         }
 126     }
 127
 128     @Override
 129     public void getTelemetry(String xmlResponse) throws HaywardException {
 130         List<String> systemIDs = new ArrayList<>();
 131         List<String> data = new ArrayList<>();
 132
 133         Bridge bridge = getBridge();
 134         if (bridge != null) {
 135             HaywardBridgeHandler bridgehandler = (HaywardBridgeHandler) bridge.getHandler();
 136             if (bridgehandler != null) {
 137                 systemIDs = bridgehandler.evaluateXPath("//Pump/@systemId", xmlResponse);
 138                 String thingSystemID = getThing().getUID().getId();
 139                 for (int i = 0; i < systemIDs.size(); i++) {
 140                     if (systemIDs.get(i).equals(thingSystemID)) {
 141                         // Speed percent
 142                         data = bridgehandler.evaluateXPath("//Pump/@pumpSpeed", xmlResponse);
 143                         updateData(HaywardBindingConstants.CHANNEL_PUMP_SPEEDPERCENT, data.get(i));
 144
 145                         // Speed rpm
 146                         String pumpMaxRpm = getThing().getProperties()
 147                                 .get(HaywardBindingConstants.PROPERTY_PUMP_MAXRPM);
 148                         if (pumpMaxRpm != null) {
 149                             Integer rpmSpeed = (Integer.parseInt(data.get(i))) * (Integer.parseInt(pumpMaxRpm)) / 100;
 150                             updateData(HaywardBindingConstants.CHANNEL_PUMP_SPEEDRPM, rpmSpeed.toString());
 151                         }
 152
 153                         if (data.get(i).equals("0")) {
 154                             updateData(HaywardBindingConstants.CHANNEL_PUMP_ENABLE, "0");
 155                         } else {
 156                             updateData(HaywardBindingConstants.CHANNEL_PUMP_ENABLE, "1");
 157                         }
 158
 159                         // Speed Select
 160                         data = bridgehandler.evaluateXPath("//Pump/@pumpSpeed", xmlResponse);
 161                         updateData(HaywardBindingConstants.CHANNEL_PUMP_SPEEDSELECT, data.get(i));
 162
 163                         // State
 164                         data = bridgehandler.evaluateXPath("//Pump/@pumpState", xmlResponse);
 165                         updateData(HaywardBindingConstants.CHANNEL_PUMP_STATE, data.get(i));
 166
 167                         // lastSpeed
 168                         data = bridgehandler.evaluateXPath("//Pump/@lastSpeed", xmlResponse);
 169                         updateData(HaywardBindingConstants.CHANNEL_PUMP_LASTSPEED, data.get(i));
 170                         channelStates.putAll(updateData(HaywardBindingConstants.CHANNEL_PUMP_LASTSPEED, data.get(i)));
 171                     }
 172                 }
 173                 this.updateStatus(ThingStatus.ONLINE);
 174             } else {
 175                 this.updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.BRIDGE_UNINITIALIZED);
 176             }
 177         }
 178     }
 179
 180     @Override
 181     public void handleCommand(ChannelUID channelUID, Command command) {
 182         if ((command instanceof RefreshType)) {
 183             return;
 184         }
 185
 186         String systemID = getThing().getProperties().get(HaywardBindingConstants.PROPERTY_SYSTEM_ID);
 187         String poolID = getThing().getProperties().get(HaywardBindingConstants.PROPERTY_BOWID);
 188         String pumpMinSpeed = getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_MINSPEED);
 189         String pumpMaxSpeed = getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_MAXSPEED);
 190         String pumpMaxRpm = getThing().getProperties().get(HaywardBindingConstants.PROPERTY_PUMP_MAXRPM);
 191
 192         Bridge bridge = getBridge();
 193         if (bridge != null) {
 194             HaywardBridgeHandler bridgehandler = (HaywardBridgeHandler) bridge.getHandler();
 195             if (bridgehandler != null) {
 196                 String cmdString = this.cmdToString(command);
 197                 try {
 198                     switch (channelUID.getId()) {
 199                         case HaywardBindingConstants.CHANNEL_PUMP_ENABLE:
 200                             if (command == OnOffType.ON) {
 201                                 cmdString = channelStates.get(HaywardBindingConstants.CHANNEL_PUMP_LASTSPEED)
 202                                         .format("%d");
 203                             } else {
 204                                 cmdString = "0";
 205                             }
 206                             break;
 207                         case HaywardBindingConstants.CHANNEL_PUMP_SPEEDPERCENT:
 208                             if (pumpMinSpeed != null && pumpMaxSpeed != null) {
 209                                 if (Integer.parseInt(cmdString) > 0
 210                                         && Integer.parseInt(cmdString) < Integer.parseInt(pumpMinSpeed)) {
 211                                     cmdString = pumpMinSpeed;
 212                                 } else if (Integer.parseInt(cmdString) > Integer.parseInt(pumpMaxSpeed)) {
 213                                     cmdString = pumpMaxSpeed;
 214                                 }
 215                             }
 216                             break;
 217                         case HaywardBindingConstants.CHANNEL_PUMP_SPEEDRPM:
 218                             // Convert cmdString from RPM to Percent
 219                             if (pumpMaxRpm != null && pumpMaxSpeed != null && pumpMinSpeed != null) {
 220                                 cmdString = Integer
 221                                         .toString((Integer.parseInt(cmdString) * 100 / Integer.parseInt(pumpMaxSpeed)));
 222                                 if (Integer.parseInt(cmdString) > 0
 223                                         && Integer.parseInt(cmdString) < Integer.parseInt(pumpMinSpeed)) {
 224                                     cmdString = pumpMinSpeed;
 225                                 } else if (Integer.parseInt(cmdString) > Integer.parseInt(pumpMaxSpeed)) {
 226                                     cmdString = pumpMaxSpeed;
 227                                 }
 228                             }
 229                             break;
 230                         case HaywardBindingConstants.CHANNEL_PUMP_SPEEDSELECT:
 231                             break;
 232                         default:
 233                             logger.warn("haywardCommand Unsupported type {}", channelUID);
 234                             return;
 235                     }
 236
 237                     String cmdURL = HaywardBindingConstants.COMMAND_PARAMETERS
 238                             + "<Name>SetUIEquipmentCmd</Name><Parameters>"
 239                             + "<Parameter name=\"Token\" dataType=\"String\">" + bridgehandler.account.token
 240                             + "</Parameter>" + "<Parameter name=\"MspSystemID\" dataType=\"int\">"
 241                             + bridgehandler.account.mspSystemID + "</Parameter>"
 242                             + "<Parameter name=\"PoolID\" dataType=\"int\">" + poolID + "</Parameter>"
 243                             + "<Parameter name=\"EquipmentID\" dataType=\"int\">" + systemID + "</Parameter>"
 244                             + "<Parameter name=\"IsOn\" dataType=\"int\">" + cmdString + "</Parameter>"
 245                             + HaywardBindingConstants.COMMAND_SCHEDULE + "</Parameters></Request>";
 246
 247                     // *****Send Command to Hayward server
 248                     String xmlResponse = bridgehandler.httpXmlResponse(cmdURL);
 249                     String status = bridgehandler.evaluateXPath("//Parameter[@name='Status']/text()", xmlResponse)
 250                             .get(0);
 251
 252                     if (!("0".equals(status))) {
 253                         logger.debug("haywardCommand XML response: {}", xmlResponse);
 254                         return;
 255                     }
 256                 } catch (HaywardException e) {
 257                     logger.debug("Unable to send command to Hayward's server {}:{}:{}",
 258                             bridgehandler.config.endpointUrl, bridgehandler.config.username, e.getMessage());
 259                 } catch (InterruptedException e) {
 260                     return;
 261                 }
 262                 this.updateStatus(ThingStatus.ONLINE);
 263             } else {
 264                 this.updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.BRIDGE_UNINITIALIZED);
 265             }
 266         }
 267     }
 268 }