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.dscalarm.internal.handler;
  14
  15 import static org.openhab.binding.dscalarm.internal.DSCAlarmBindingConstants.*;
  16
  17 import java.util.EventObject;
  18
  19 import org.openhab.binding.dscalarm.internal.DSCAlarmCode;
  20 import org.openhab.binding.dscalarm.internal.DSCAlarmEvent;
  21 import org.openhab.binding.dscalarm.internal.DSCAlarmMessage;
  22 import org.openhab.binding.dscalarm.internal.DSCAlarmMessage.DSCAlarmMessageInfoType;
  23 import org.openhab.core.library.types.DecimalType;
  24 import org.openhab.core.library.types.OnOffType;
  25 import org.openhab.core.library.types.StringType;
  26 import org.openhab.core.thing.ChannelUID;
  27 import org.openhab.core.thing.Thing;
  28 import org.openhab.core.types.Command;
  29 import org.openhab.core.types.RefreshType;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 /**
  34  * This is a class for handling a Partition type Thing.
  35  *
  36  * @author Russell Stephens - Initial Contribution
  37  */
  38 public class PartitionThingHandler extends DSCAlarmBaseThingHandler {
  39
  40     private final Logger logger = LoggerFactory.getLogger(PartitionThingHandler.class);
  41
  42     /**
  43      * Constructor.
  44      *
  45      * @param thing
  46      */
  47     public PartitionThingHandler(Thing thing) {
  48         super(thing);
  49         setDSCAlarmThingType(DSCAlarmThingType.PARTITION);
  50     }
  51
  52     @Override
  53     public void updateChannel(ChannelUID channelUID, int state, String description) {
  54         logger.debug("updateChannel(): Panel Channel UID: {}", channelUID);
  55
  56         boolean trigger;
  57         OnOffType onOffType;
  58
  59         if (channelUID != null) {
  60             switch (channelUID.getId()) {
  61                 case PARTITION_STATUS:
  62                     updateState(channelUID, new StringType(description));
  63                     break;
  64                 case PARTITION_ARM_MODE:
  65                     updateState(channelUID, new DecimalType(state));
  66                     break;
  67                 case PARTITION_ARMED:
  68                     trigger = state != 0;
  69                     onOffType = trigger ? OnOffType.ON : OnOffType.OFF;
  70                     updateState(channelUID, onOffType);
  71                     break;
  72                 case PARTITION_ENTRY_DELAY:
  73                     trigger = state != 0;
  74                     onOffType = trigger ? OnOffType.ON : OnOffType.OFF;
  75                     updateState(channelUID, onOffType);
  76                     break;
  77                 case PARTITION_EXIT_DELAY:
  78                     trigger = state != 0;
  79                     onOffType = trigger ? OnOffType.ON : OnOffType.OFF;
  80                     updateState(channelUID, onOffType);
  81                     break;
  82                 case PARTITION_IN_ALARM:
  83                     trigger = state != 0;
  84                     onOffType = trigger ? OnOffType.ON : OnOffType.OFF;
  85                     updateState(channelUID, onOffType);
  86                     break;
  87                 case PARTITION_OPENING_CLOSING_MODE:
  88                     updateState(channelUID, new StringType(description));
  89                     break;
  90                 default:
  91                     logger.debug("updateChannel(): Partition Channel not updated - {}.", channelUID);
  92                     break;
  93             }
  94         }
  95     }
  96
  97     @Override
  98     public void handleCommand(ChannelUID channelUID, Command command) {
  99         logger.debug("handleCommand(): Command Received - {} {}.", channelUID, command);
 100
 101         if (command instanceof RefreshType) {
 102             return;
 103         }
 104
 105         if (dscAlarmBridgeHandler != null && dscAlarmBridgeHandler.isConnected()) {
 106             switch (channelUID.getId()) {
 107                 case PARTITION_ARM_MODE:
 108                     int partitionNumber = getPartitionNumber();
 109                     if (command.toString().equals("0")) {
 110                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.PartitionDisarmControl,
 111                                 String.valueOf(partitionNumber));
 112                     } else if (command.toString().equals("1")) {
 113                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.PartitionArmControlAway,
 114                                 String.valueOf(partitionNumber));
 115                     } else if (command.toString().equals("2")) {
 116                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.PartitionArmControlStay,
 117                                 String.valueOf(partitionNumber));
 118                     } else if (command.toString().equals("3")) {
 119                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.PartitionArmControlZeroEntryDelay,
 120                                 String.valueOf(partitionNumber));
 121                     } else if (command.toString().equals("4")) {
 122                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.PartitionArmControlZeroEntryDelay,
 123                                 String.valueOf(partitionNumber));
 124                     } else if (command.toString().equals("5")) {
 125                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.PartitionArmControlWithUserCode,
 126                                 String.valueOf(partitionNumber));
 127                     }
 128                     break;
 129                 default:
 130                     break;
 131             }
 132         }
 133     }
 134
 135     /**
 136      * Method to set Partition Status.
 137      *
 138      * @param message
 139      */
 140     private void partitionStatus(String message) {
 141         updateState(new ChannelUID(getThing().getUID(), PARTITION_STATUS), new StringType(message));
 142     }
 143
 144     /**
 145      * Method to set Partition Close Open Mode.
 146      *
 147      * @param event
 148      */
 149     private void partitionOpenCloseModeEventHandler(EventObject event) {
 150         DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
 151         DSCAlarmMessage dscAlarmMessage = dscAlarmEvent.getDSCAlarmMessage();
 152         DSCAlarmCode dscAlarmCode = DSCAlarmCode
 153                 .getDSCAlarmCodeValue(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
 154         ChannelUID channelUID = null;
 155         int state = 0; /*
 156                         * 0=None, 1=User Closing, 2=Special Closing, 3=Partial Closing, 4=User Opening, 5=Special
 157                         * Opening
 158                         */
 159
 160         String strStatus = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.NAME);
 161
 162         switch (dscAlarmCode) {
 163             case UserClosing: /* 700 */
 164                 state = 1;
 165                 break;
 166             case SpecialClosing: /* 701 */
 167                 state = 2;
 168                 break;
 169             case PartialClosing: /* 702 */
 170                 state = 3;
 171                 break;
 172             case UserOpening: /* 750 */
 173                 state = 4;
 174                 break;
 175             case SpecialOpening: /* 751 */
 176                 state = 5;
 177                 break;
 178             default:
 179                 break;
 180         }
 181
 182         channelUID = new ChannelUID(getThing().getUID(), PARTITION_OPENING_CLOSING_MODE);
 183         updateChannel(channelUID, state, strStatus);
 184     }
 185
 186     @Override
 187     public void dscAlarmEventReceived(EventObject event, Thing thing) {
 188         if (thing != null) {
 189             if (getThing() == thing) {
 190                 DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
 191                 DSCAlarmMessage dscAlarmMessage = dscAlarmEvent.getDSCAlarmMessage();
 192
 193                 ChannelUID channelUID = null;
 194                 DSCAlarmCode dscAlarmCode = DSCAlarmCode
 195                         .getDSCAlarmCodeValue(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
 196                 String dscAlarmMessageName = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.NAME);
 197                 String dscAlarmMessageMode = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.MODE);
 198
 199                 logger.debug("dscAlarmEventRecieved(): Thing - {}   Command - {}", thing.getUID(), dscAlarmCode);
 200
 201                 switch (dscAlarmCode) {
 202                     case PartitionReady: /* 650 */
 203                     case PartitionNotReady: /* 651 */
 204                     case PartitionReadyForceArming: /* 653 */
 205                     case SystemArmingInProgress: /* 674 */
 206                         partitionStatus(dscAlarmMessageName);
 207                         break;
 208                     case PartitionArmed: /* 652 */
 209                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_ARMED);
 210                         updateChannel(channelUID, 1, "");
 211
 212                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_ENTRY_DELAY);
 213                         updateChannel(channelUID, 0, "");
 214
 215                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_EXIT_DELAY);
 216                         updateChannel(channelUID, 0, "");
 217
 218                         /*
 219                          * arm mode:0=disarmed, 1=away armed, 2=stay armed, 3=away no delay, 4=stay no delay, 5=with
 220                          * user code
 221                          */
 222                         int armMode = Integer.parseInt(dscAlarmMessageMode) + 1;
 223                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_ARM_MODE);
 224                         updateChannel(channelUID, armMode, "");
 225
 226                         partitionStatus(dscAlarmMessageName);
 227                         break;
 228                     case PartitionDisarmed: /* 655 */
 229                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_ARMED);
 230                         updateChannel(channelUID, 0, "");
 231
 232                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_ENTRY_DELAY);
 233                         updateChannel(channelUID, 0, "");
 234
 235                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_EXIT_DELAY);
 236                         updateChannel(channelUID, 0, "");
 237
 238                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_IN_ALARM);
 239                         updateChannel(channelUID, 0, "");
 240
 241                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_ARM_MODE);
 242                         updateChannel(channelUID, 0, "");
 243
 244                         partitionStatus(dscAlarmMessageName);
 245                         break;
 246                     case PartitionInAlarm: /* 654 */
 247                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_IN_ALARM);
 248                         updateChannel(channelUID, 1, "");
 249
 250                         partitionStatus(dscAlarmMessageName);
 251                         break;
 252                     case ExitDelayInProgress: /* 656 */
 253                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_EXIT_DELAY);
 254                         updateChannel(channelUID, 1, "");
 255                         break;
 256                     case EntryDelayInProgress: /* 657 */
 257                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_ENTRY_DELAY);
 258                         updateChannel(channelUID, 1, "");
 259                         break;
 260                     case FailureToArm: /* 672 */
 261                         channelUID = new ChannelUID(getThing().getUID(), PARTITION_ARM_MODE);
 262                         updateChannel(channelUID, 0, "");
 263                         partitionStatus(dscAlarmMessageName);
 264                         break;
 265                     case UserClosing: /* 700 */
 266                     case SpecialClosing: /* 701 */
 267                     case PartialClosing: /* 702 */
 268                     case UserOpening: /* 750 */
 269                     case SpecialOpening: /* 751 */
 270                         partitionOpenCloseModeEventHandler(event);
 271                     default:
 272                         break;
 273                 }
 274             }
 275         }
 276     }
 277 }