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.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         DSCAlarmCode dscAlarmCode = DSCAlarmCode
 104                 .getDSCAlarmCodeValue(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
 105
 106         int bitCount = 8;
 107         int bitField = Integer.decode("0x" + dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA));
 108         int[] masks = { 1, 2, 4, 8, 16, 32, 64, 128 };
 109         int[] bits = new int[bitCount];
 110
 111         for (int i = 0; i < bitCount; i++) {
 112             bits[i] = bitField & masks[i];
 113             ChannelUID channelUID = new ChannelUID(getThing().getUID(), channelTypes[i]);
 114             switch (dscAlarmCode) {
 115                 case KeypadLEDState: /* 510 */
 116                     updateChannel(channelUID, bits[i] != 0 ? 1 : 0, "");
 117                     break;
 118                 case KeypadLEDFlashState: /* 511 */
 119                     if (bits[i] != 0) {
 120                         updateChannel(channelUID, 2, "");
 121                     }
 122                     break;
 123                 default:
 124                     break;
 125             }
 126         }
 127     }
 128
 129     @Override
 130     @SuppressWarnings("PMD.CompareObjectsWithEquals")
 131     public void dscAlarmEventReceived(EventObject event, Thing thing) {
 132         if (thing != null) {
 133             if (getThing() == thing) {
 134                 DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
 135                 DSCAlarmMessage dscAlarmMessage = dscAlarmEvent.getDSCAlarmMessage();
 136
 137                 ChannelUID channelUID = null;
 138                 DSCAlarmCode dscAlarmCode = DSCAlarmCode
 139                         .getDSCAlarmCodeValue(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
 140                 String dscAlarmMessageData = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA);
 141
 142                 logger.debug("dscAlarmEventRecieved(): Thing - {}   Command - {}", thing.getUID(), dscAlarmCode);
 143
 144                 switch (dscAlarmCode) {
 145                     case KeypadLEDState: /* 510 */
 146                     case KeypadLEDFlashState: /* 511 */
 147                         keypadLEDStateEventHandler(event);
 148                         break;
 149                     case LCDUpdate: /* 901 */
 150                         channelUID = new ChannelUID(getThing().getUID(), KEYPAD_LCD_UPDATE);
 151                         updateChannel(channelUID, 0, dscAlarmMessageData);
 152                         break;
 153                     case LCDCursor: /* 902 */
 154                         channelUID = new ChannelUID(getThing().getUID(), KEYPAD_LCD_CURSOR);
 155                         updateChannel(channelUID, 0, dscAlarmMessageData);
 156                         break;
 157                     case LEDStatus: /* 903 */
 158                         int data = Integer.parseInt(dscAlarmMessageData.substring(0, 1));
 159                         int state = Integer
 160                                 .parseInt(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA).substring(1));
 161                         switch (data) {
 162                             case 1:
 163                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_READY_LED);
 164                                 updateChannel(channelUID, state, "");
 165                                 break;
 166                             case 2:
 167                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_ARMED_LED);
 168                                 updateChannel(channelUID, state, "");
 169                                 break;
 170                             case 3:
 171                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_MEMORY_LED);
 172                                 updateChannel(channelUID, state, "");
 173                                 break;
 174                             case 4:
 175                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_BYPASS_LED);
 176                                 updateChannel(channelUID, state, "");
 177                                 break;
 178                             case 5:
 179                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_TROUBLE_LED);
 180                                 updateChannel(channelUID, state, "");
 181                                 break;
 182                             case 6:
 183                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_PROGRAM_LED);
 184                                 updateChannel(channelUID, state, "");
 185                                 break;
 186                             case 7:
 187                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_FIRE_LED);
 188                                 updateChannel(channelUID, state, "");
 189                                 break;
 190                             case 8:
 191                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_BACKLIGHT_LED);
 192                                 updateChannel(channelUID, state, "");
 193                                 break;
 194                             case 9:
 195                                 channelUID = new ChannelUID(getThing().getUID(), KEYPAD_AC_LED);
 196                                 updateChannel(channelUID, state, "");
 197                                 break;
 198                             default:
 199                                 break;
 200                         }
 201                     default:
 202                         break;
 203                 }
 204             }
 205         }
 206     }
 207 }