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.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.StringType;
  25 import org.openhab.core.thing.ChannelUID;
  26 import org.openhab.core.thing.Thing;
  27 import org.slf4j.Logger;
  28 import org.slf4j.LoggerFactory;
  29
  30 /**
  31  * This is a class for handling a Zone type Thing.
  32  *
  33  * @author Russell Stephens - Initial Contribution
  34  */
  35 public class KeypadThingHandler extends DSCAlarmBaseThingHandler {
  36
  37     private final Logger logger = LoggerFactory.getLogger(KeypadThingHandler.class);
  38
  39     /**
  40      * Constructor.
  41      *
  42      * @param thing
  43      */
  44     public KeypadThingHandler(Thing thing) {
  45         super(thing);
  46         setDSCAlarmThingType(DSCAlarmThingType.KEYPAD);
  47     }
  48
  49     @Override
  50     public void updateChannel(ChannelUID channelUID, int state, String description) {
  51         logger.debug("updateChannel(): Keypad Channel UID: {}", channelUID);
  52         if (channelUID != null) {
  53             switch (channelUID.getId()) {
  54                 case KEYPAD_READY_LED:
  55                     updateState(channelUID, new DecimalType(state));
  56                     break;
  57                 case KEYPAD_ARMED_LED:
  58                     updateState(channelUID, new DecimalType(state));
  59                     break;
  60                 case KEYPAD_MEMORY_LED:
  61                     updateState(channelUID, new DecimalType(state));
  62                     break;
  63                 case KEYPAD_BYPASS_LED:
  64                     updateState(channelUID, new DecimalType(state));
  65                     break;
  66                 case KEYPAD_TROUBLE_LED:
  67                     updateState(channelUID, new DecimalType(state));
  68                     break;
  69                 case KEYPAD_PROGRAM_LED:
  70                     updateState(channelUID, new DecimalType(state));
  71                     break;
  72                 case KEYPAD_FIRE_LED:
  73                     updateState(channelUID, new DecimalType(state));
  74                     break;
  75                 case KEYPAD_BACKLIGHT_LED:
  76                     updateState(channelUID, new DecimalType(state));
  77                     break;
  78                 case KEYPAD_AC_LED:
  79                     updateState(channelUID, new DecimalType(state));
  80                     break;
  81                 case KEYPAD_LCD_UPDATE:
  82                 case KEYPAD_LCD_CURSOR:
  83                     updateState(channelUID, new StringType(description));
  84                     break;
  85                 default:
  86                     logger.debug("updateChannel(): Keypad Channel not updated - {}.", channelUID);
  87                     break;
  88             }
  89         }
  90     }
  91
  92     /**
  93      * Handle Keypad LED events for the EyezOn Envisalink 3/2DS DSC Alarm Interface
  94      *
  95      * @param event
  96      */
  97     private void keypadLEDStateEventHandler(EventObject event) {
  98         DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
  99         DSCAlarmMessage dscAlarmMessage = dscAlarmEvent.getDSCAlarmMessage();
 100         String[] channelTypes = { KEYPAD_READY_LED, KEYPAD_ARMED_LED, KEYPAD_MEMORY_LED, KEYPAD_BYPASS_LED,
 101                 KEYPAD_TROUBLE_LED, KEYPAD_PROGRAM_LED, KEYPAD_FIRE_LED, KEYPAD_BACKLIGHT_LED };
 102
 103         String channel;
 104         ChannelUID channelUID = null;
 105         DSCAlarmCode dscAlarmCode = DSCAlarmCode
 106                 .getDSCAlarmCodeValue(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
 107
 108         int bitField = Integer.decode("0x" + dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA));
 109         int[] masks = { 1, 2, 4, 8, 16, 32, 64, 128 };
 110         int[] bits = new int[8];
 111
 112         for (int i = 0; i < 8; i++) {
 113             bits[i] = bitField & masks[i];
 114
 115             channel = channelTypes[i];
 116
 117             if (channel != "") {
 118                 channelUID = new ChannelUID(getThing().getUID(), channel);
 119
 120                 switch (dscAlarmCode) {
 121                     case KeypadLEDState: /* 510 */
 122                         updateChannel(channelUID, bits[i] != 0 ? 1 : 0, "");
 123                         break;
 124                     case KeypadLEDFlashState: /* 511 */
 125                         if (bits[i] != 0) {
 126                             updateChannel(channelUID, 2, "");
 127                         }
 128                         break;
 129                     default:
 130                         break;
 131                 }
 132             }
 133         }
 134     }
 135
 136     @Override
 137     public void dscAlarmEventReceived(EventObject event, Thing thing) {
 138         if (thing != null) {
 139             if (getThing() == thing) {
 140                 DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
 141                 DSCAlarmMessage dscAlarmMessage = dscAlarmEvent.getDSCAlarmMessage();
 142
 143                 ChannelUID channelUID = null;
 144                 DSCAlarmCode dscAlarmCode = DSCAlarmCode
 145                         .getDSCAlarmCodeValue(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
 146                 String dscAlarmMessageData = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA);
 147
 148                 logger.debug("dscAlarmEventRecieved(): Thing - {}   Command - {}", thing.getUID(), dscAlarmCode);
 149
 150                 switch (dscAlarmCode) {
 151                     case KeypadLEDState: /* 510 */
 152                     case KeypadLEDFlashState: /* 511 */
 153                         keypadLEDStateEventHandler(event);
 154                         break;
 155                     case LCDUpdate: /* 901 */
 156                         channelUID = new ChannelUID(getThing().getUID(), KEYPAD_LCD_UPDATE);
 157                         updateChannel(channelUID, 0, dscAlarmMessageData);
 158                         break;
 159                     case LCDCursor: /* 902 */
 160                         channelUID = new ChannelUID(getThing().getUID(), KEYPAD_LCD_CURSOR);
 161                         updateChannel(channelUID, 0, dscAlarmMessageData);
 162                         break;
 163                     case LEDStatus: /* 903 */
 164                         int data = Integer.parseInt(dscAlarmMessageData.substring(0, 1));
 165                         int state = Integer
 166                                 .parseInt(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA).substring(1));
 167                         switch (data) {
 168                             case 1:
 169                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_READY_LED);
 170                                 updateChannel(channelUID, state, "");
 171                                 break;
 172                             case 2:
 173                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_ARMED_LED);
 174                                 updateChannel(channelUID, state, "");
 175                                 break;
 176                             case 3:
 177                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_MEMORY_LED);
 178                                 updateChannel(channelUID, state, "");
 179                                 break;
 180                             case 4:
 181                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_BYPASS_LED);
 182                                 updateChannel(channelUID, state, "");
 183                                 break;
 184                             case 5:
 185                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_TROUBLE_LED);
 186                                 updateChannel(channelUID, state, "");
 187                                 break;
 188                             case 6:
 189                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_PROGRAM_LED);
 190                                 updateChannel(channelUID, state, "");
 191                                 break;
 192                             case 7:
 193                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_FIRE_LED);
 194                                 updateChannel(channelUID, state, "");
 195                                 break;
 196                             case 8:
 197                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_BACKLIGHT_LED);
 198                                 updateChannel(channelUID, state, "");
 199                                 break;
 200                             case 9:
 201                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_AC_LED);
 202                                 updateChannel(channelUID, state, "");
 203                                 break;
 204                             default:
 205                                 break;
 206                         }
 207                     default:
 208                         break;
 209                 }
 210             }
 211         }
 212     }
 213 }