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

   1 /**
   2  * Copyright (c) 2010-2022 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.text.ParseException;
  18 import java.text.SimpleDateFormat;
  19 import java.util.Date;
  20 import java.util.EventObject;
  21 import java.util.List;
  22
  23 import org.openhab.binding.dscalarm.internal.DSCAlarmCode;
  24 import org.openhab.binding.dscalarm.internal.DSCAlarmEvent;
  25 import org.openhab.binding.dscalarm.internal.DSCAlarmMessage;
  26 import org.openhab.binding.dscalarm.internal.DSCAlarmMessage.DSCAlarmMessageInfoType;
  27 import org.openhab.core.library.types.DateTimeType;
  28 import org.openhab.core.library.types.DecimalType;
  29 import org.openhab.core.library.types.OnOffType;
  30 import org.openhab.core.library.types.StringType;
  31 import org.openhab.core.thing.ChannelUID;
  32 import org.openhab.core.thing.Thing;
  33 import org.openhab.core.types.Command;
  34 import org.openhab.core.types.RefreshType;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37
  38 /**
  39  * This is a class for handling a Panel type Thing.
  40  *
  41  * @author Russell Stephens - Initial Contribution
  42  */
  43 public class PanelThingHandler extends DSCAlarmBaseThingHandler {
  44
  45     private static final int PANEL_COMMAND_POLL = 0;
  46     private static final int PANEL_COMMAND_STATUS_REPORT = 1;
  47     private static final int PANEL_COMMAND_LABELS_REQUEST = 2;
  48     private static final int PANEL_COMMAND_DUMP_ZONE_TIMERS = 8;
  49     private static final int PANEL_COMMAND_SET_TIME_DATE = 10;
  50     private static final int PANEL_COMMAND_CODE_SEND = 200;
  51
  52     private final Logger logger = LoggerFactory.getLogger(PanelThingHandler.class);
  53
  54     /**
  55      * Constructor.
  56      *
  57      * @param thing
  58      */
  59     public PanelThingHandler(Thing thing) {
  60         super(thing);
  61         setDSCAlarmThingType(DSCAlarmThingType.PANEL);
  62     }
  63
  64     @Override
  65     public void updateChannel(ChannelUID channelUID, int state, String description) {
  66         logger.debug("updateChannel(): Panel Channel UID: {}", channelUID);
  67
  68         boolean trigger;
  69         boolean trouble;
  70         boolean boolState;
  71         OnOffType onOffType;
  72
  73         if (channelUID != null) {
  74             switch (channelUID.getId()) {
  75                 case PANEL_MESSAGE:
  76                     updateState(channelUID, new StringType(description));
  77                     break;
  78                 case PANEL_SYSTEM_ERROR:
  79                     updateState(channelUID, new StringType(description));
  80                     break;
  81                 case PANEL_TIME:
  82                     Date date = null;
  83                     SimpleDateFormat sdfReceived = new SimpleDateFormat("hhmmMMddyy");
  84
  85                     try {
  86                         date = sdfReceived.parse(description);
  87                     } catch (ParseException e) {
  88                         logger.warn("updateChannel(): Parse Exception occurred while trying to parse date string: {}. ",
  89                                 e.getMessage());
  90                     }
  91
  92                     if (date != null) {
  93                         SimpleDateFormat sdfUpdate = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
  94                         String systemTime = sdfUpdate.format(date);
  95                         updateState(channelUID, new DateTimeType(systemTime));
  96                     }
  97
  98                     break;
  99                 case PANEL_TIME_STAMP:
 100                     boolState = state != 0;
 101                     onOffType = boolState ? OnOffType.ON : OnOffType.OFF;
 102                     updateState(channelUID, onOffType);
 103                     break;
 104                 case PANEL_TIME_BROADCAST:
 105                     boolState = state != 0;
 106                     onOffType = boolState ? OnOffType.ON : OnOffType.OFF;
 107                     updateState(channelUID, onOffType);
 108                     break;
 109                 case PANEL_COMMAND:
 110                     updateState(channelUID, new DecimalType(state));
 111                     break;
 112                 case PANEL_TROUBLE_MESSAGE:
 113                     updateState(channelUID, new StringType(description));
 114                     break;
 115                 case PANEL_TROUBLE_LED:
 116                     boolState = state != 0;
 117                     onOffType = boolState ? OnOffType.ON : OnOffType.OFF;
 118                     updateState(channelUID, onOffType);
 119                     break;
 120                 case PANEL_SERVICE_REQUIRED:
 121                     trouble = state != 0;
 122                     onOffType = trouble ? OnOffType.ON : OnOffType.OFF;
 123                     updateState(channelUID, onOffType);
 124                     break;
 125                 case PANEL_AC_TROUBLE:
 126                     trouble = state != 0;
 127                     onOffType = trouble ? OnOffType.ON : OnOffType.OFF;
 128                     updateState(channelUID, onOffType);
 129                     break;
 130                 case PANEL_TELEPHONE_TROUBLE:
 131                     trouble = state != 0;
 132                     onOffType = trouble ? OnOffType.ON : OnOffType.OFF;
 133                     updateState(channelUID, onOffType);
 134                     break;
 135                 case PANEL_FTC_TROUBLE:
 136                     trouble = state != 0;
 137                     onOffType = trouble ? OnOffType.ON : OnOffType.OFF;
 138                     updateState(channelUID, onOffType);
 139                     break;
 140                 case PANEL_ZONE_FAULT:
 141                     trouble = state != 0;
 142                     onOffType = trouble ? OnOffType.ON : OnOffType.OFF;
 143                     updateState(channelUID, onOffType);
 144                     break;
 145                 case PANEL_ZONE_TAMPER:
 146                     trouble = state != 0;
 147                     onOffType = trouble ? OnOffType.ON : OnOffType.OFF;
 148                     updateState(channelUID, onOffType);
 149                     break;
 150                 case PANEL_ZONE_LOW_BATTERY:
 151                     trouble = state != 0;
 152                     onOffType = trouble ? OnOffType.ON : OnOffType.OFF;
 153                     updateState(channelUID, onOffType);
 154                     break;
 155                 case PANEL_TIME_LOSS:
 156                     trouble = state != 0;
 157                     onOffType = trouble ? OnOffType.ON : OnOffType.OFF;
 158                     updateState(channelUID, onOffType);
 159                     break;
 160                 case PANEL_FIRE_KEY_ALARM:
 161                     trigger = state != 0;
 162                     onOffType = trigger ? OnOffType.ON : OnOffType.OFF;
 163                     updateState(channelUID, onOffType);
 164                     break;
 165                 case PANEL_PANIC_KEY_ALARM:
 166                     trigger = state != 0;
 167                     onOffType = trigger ? OnOffType.ON : OnOffType.OFF;
 168                     updateState(channelUID, onOffType);
 169                     break;
 170                 case PANEL_AUX_KEY_ALARM:
 171                     trigger = state != 0;
 172                     onOffType = trigger ? OnOffType.ON : OnOffType.OFF;
 173                     updateState(channelUID, onOffType);
 174                     break;
 175                 case PANEL_AUX_INPUT_ALARM:
 176                     trigger = state != 0;
 177                     onOffType = trigger ? OnOffType.ON : OnOffType.OFF;
 178                     updateState(channelUID, onOffType);
 179                     break;
 180                 default:
 181                     logger.debug("updateChannel(): Panel Channel not updated - {}.", channelUID);
 182                     break;
 183             }
 184         }
 185     }
 186
 187     @Override
 188     public void handleCommand(ChannelUID channelUID, Command command) {
 189         logger.debug("handleCommand(): Command Received - {} {}.", channelUID, command);
 190
 191         if (command instanceof RefreshType) {
 192             return;
 193         }
 194
 195         if (dscAlarmBridgeHandler != null && dscAlarmBridgeHandler.isConnected()) {
 196             int cmd;
 197
 198             switch (channelUID.getId()) {
 199                 case PANEL_COMMAND:
 200                     cmd = Integer.parseInt(command.toString());
 201                     handlePanelCommand(cmd);
 202                     updateState(channelUID, new StringType(String.valueOf(-1)));
 203                     break;
 204                 case PANEL_TIME_STAMP:
 205                     if (command instanceof OnOffType) {
 206                         cmd = command == OnOffType.ON ? 1 : 0;
 207                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.TimeStampControl, String.valueOf(cmd));
 208                         updateState(channelUID, (OnOffType) command);
 209                     }
 210                     break;
 211                 case PANEL_TIME_BROADCAST:
 212                     if (command instanceof OnOffType) {
 213                         cmd = command == OnOffType.ON ? 1 : 0;
 214                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.TimeDateBroadcastControl, String.valueOf(cmd));
 215                         updateState(channelUID, (OnOffType) command);
 216                     }
 217                     break;
 218                 default:
 219                     break;
 220             }
 221         }
 222     }
 223
 224     /**
 225      * Method to handle PANEL_COMMAND
 226      *
 227      * @param cmd
 228      */
 229     private void handlePanelCommand(int cmd) {
 230         switch (cmd) {
 231             case PANEL_COMMAND_POLL:
 232                 dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.Poll);
 233                 break;
 234             case PANEL_COMMAND_STATUS_REPORT:
 235                 dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.StatusReport);
 236                 break;
 237             case PANEL_COMMAND_LABELS_REQUEST:
 238                 dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.LabelsRequest);
 239                 break;
 240             case PANEL_COMMAND_DUMP_ZONE_TIMERS:
 241                 dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.DumpZoneTimers);
 242                 break;
 243             case PANEL_COMMAND_SET_TIME_DATE:
 244                 dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.SetTimeDate);
 245                 break;
 246             case PANEL_COMMAND_CODE_SEND:
 247                 dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.CodeSend, getUserCode());
 248                 break;
 249             default:
 250                 break;
 251         }
 252     }
 253
 254     /**
 255      * Method to set the time stamp state.
 256      *
 257      * @param timeStamp
 258      */
 259     private void setTimeStampState(String timeStamp) {
 260         if (timeStamp != null) {
 261             ChannelUID channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME_STAMP);
 262             int state = timeStamp.isEmpty() ? 0 : 1;
 263             updateChannel(channelUID, state, "");
 264         }
 265     }
 266
 267     /**
 268      * Method to set Channel PANEL_SYSTEM_ERROR.
 269      *
 270      * @param properties
 271      * @param dscAlarmMessage
 272      */
 273     private void panelSystemError(DSCAlarmMessage dscAlarmMessage) {
 274         ChannelUID channelUID = new ChannelUID(getThing().getUID(), PANEL_SYSTEM_ERROR);
 275         int systemErrorCode = 0;
 276         String systemErrorDescription = "";
 277
 278         if (dscAlarmMessage != null) {
 279             systemErrorCode = Integer.parseInt(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA));
 280             switch (systemErrorCode) {
 281                 case 1:
 282                     systemErrorDescription = "Receive Buffer Overrun";
 283                     break;
 284                 case 2:
 285                     systemErrorDescription = "Receive Buffer Overflow";
 286                     break;
 287                 case 3:
 288                     systemErrorDescription = "Transmit Buffer Overflow";
 289                     break;
 290                 case 10:
 291                     systemErrorDescription = "Keybus Transmit Buffer Overrun";
 292                     break;
 293                 case 11:
 294                     systemErrorDescription = "Keybus Transmit Time Timeout";
 295                     break;
 296                 case 12:
 297                     systemErrorDescription = "Keybus Transmit Mode Timeout";
 298                     break;
 299                 case 13:
 300                     systemErrorDescription = "Keybus Transmit Keystring Timeout";
 301                     break;
 302                 case 14:
 303                     systemErrorDescription = "Keybus Interface Not Functioning";
 304                     break;
 305                 case 15:
 306                     systemErrorDescription = "Keybus Busy - Attempting to Disarm or Arm with user code";
 307                     break;
 308                 case 16:
 309                     systemErrorDescription = "Keybus Busy – Lockout";
 310                     break;
 311                 case 17:
 312                     systemErrorDescription = "Keybus Busy – Installers Mode";
 313                     break;
 314                 case 18:
 315                     systemErrorDescription = "Keybus Busy - General Busy";
 316                     break;
 317                 case 20:
 318                     systemErrorDescription = "API Command Syntax Error";
 319                     break;
 320                 case 21:
 321                     systemErrorDescription = "API Command Partition Error - Requested Partition is out of bounds";
 322                     break;
 323                 case 22:
 324                     systemErrorDescription = "API Command Not Supported";
 325                     break;
 326                 case 23:
 327                     systemErrorDescription = "API System Not Armed - Sent in response to a disarm command";
 328                     break;
 329                 case 24:
 330                     systemErrorDescription = "API System Not Ready to Arm - System is either not-secure, in exit-delay, or already armed";
 331                     break;
 332                 case 25:
 333                     systemErrorDescription = "API Command Invalid Length";
 334                     break;
 335                 case 26:
 336                     systemErrorDescription = "API User Code not Required";
 337                     break;
 338                 case 27:
 339                     systemErrorDescription = "API Invalid Characters in Command - No alpha characters are allowed except for checksum";
 340                     break;
 341                 case 28:
 342                     systemErrorDescription = "API Virtual Keypad is Disabled";
 343                     break;
 344                 case 29:
 345                     systemErrorDescription = "API Not Valid Parameter";
 346                     break;
 347                 case 30:
 348                     systemErrorDescription = "API Keypad Does Not Come Out of Blank Mode";
 349                     break;
 350                 case 31:
 351                     systemErrorDescription = "API IT-100 is Already in Thermostat Menu";
 352                     break;
 353                 case 32:
 354                     systemErrorDescription = "API IT-100 is NOT in Thermostat Menu";
 355                     break;
 356                 case 33:
 357                     systemErrorDescription = "API No Response From Thermostat or Escort Module";
 358                     break;
 359                 case 0:
 360                 default:
 361                     systemErrorDescription = "No Error";
 362                     break;
 363             }
 364
 365         }
 366
 367         String errorMessage = String.format("%03d", systemErrorCode) + ": " + systemErrorDescription;
 368         channelUID = new ChannelUID(getThing().getUID(), PANEL_SYSTEM_ERROR);
 369         updateState(channelUID, new StringType(errorMessage));
 370     }
 371
 372     /**
 373      * Handle Verbose Trouble Status events for the EyezOn Envisalink 3/2DS DSC Alarm Interface.
 374      *
 375      * @param event
 376      */
 377     private void verboseTroubleStatusHandler(EventObject event) {
 378         DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
 379         DSCAlarmMessage dscAlarmMessage = dscAlarmEvent.getDSCAlarmMessage();
 380         String[] channelTypes = { PANEL_SERVICE_REQUIRED, PANEL_AC_TROUBLE, PANEL_TELEPHONE_TROUBLE, PANEL_FTC_TROUBLE,
 381                 PANEL_ZONE_FAULT, PANEL_ZONE_TAMPER, PANEL_ZONE_LOW_BATTERY, PANEL_TIME_LOSS };
 382
 383         String channel;
 384         ChannelUID channelUID = null;
 385
 386         int bitCount = 8;
 387         int bitField = Integer.decode("0x" + dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA));
 388         int[] masks = { 1, 2, 4, 8, 16, 32, 64, 128 };
 389         int[] bits = new int[bitCount];
 390
 391         for (int i = 0; i < bitCount; i++) {
 392             channelUID = new ChannelUID(getThing().getUID(), channelTypes[i]);
 393             bits[i] = bitField & masks[i];
 394             updateChannel(channelUID, bits[i] != 0 ? 1 : 0, "");
 395         }
 396     }
 397
 398     /**
 399      * Restores all partitions that are in alarm after special panel alarm conditions have been restored.
 400      *
 401      * @param dscAlarmCode
 402      */
 403     private void restorePartitionsInAlarm(DSCAlarmCode dscAlarmCode) {
 404         logger.debug("restorePartitionsInAlarm(): DSC Alarm Code: {}!", dscAlarmCode.toString());
 405
 406         ChannelUID channelUID = null;
 407
 408         if (dscAlarmCode == DSCAlarmCode.FireKeyRestored || dscAlarmCode == DSCAlarmCode.AuxiliaryKeyRestored
 409                 || dscAlarmCode == DSCAlarmCode.PanicKeyRestored
 410                 || dscAlarmCode == DSCAlarmCode.AuxiliaryInputAlarmRestored) {
 411             List<Thing> things = dscAlarmBridgeHandler.getThing().getThings();
 412             for (Thing thg : things) {
 413                 if (thg.getThingTypeUID().equals(PARTITION_THING_TYPE)) {
 414                     DSCAlarmBaseThingHandler handler = (DSCAlarmBaseThingHandler) thg.getHandler();
 415                     if (handler != null) {
 416                         channelUID = new ChannelUID(thg.getUID(), PARTITION_IN_ALARM);
 417                         handler.updateChannel(channelUID, 0, "");
 418
 419                         logger.debug("restorePartitionsInAlarm(): Partition In Alarm Restored: {}!", thg.getUID());
 420                     }
 421                 }
 422             }
 423         }
 424     }
 425
 426     @Override
 427     @SuppressWarnings("PMD.CompareObjectsWithEquals")
 428     public void dscAlarmEventReceived(EventObject event, Thing thing) {
 429         if (thing != null) {
 430             DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
 431             DSCAlarmMessage dscAlarmMessage = dscAlarmEvent.getDSCAlarmMessage();
 432             String dscAlarmMessageData = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA);
 433             setTimeStampState(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.TIME_STAMP));
 434
 435             if (getThing() == thing) {
 436                 ChannelUID channelUID = null;
 437                 DSCAlarmCode dscAlarmCode = DSCAlarmCode
 438                         .getDSCAlarmCodeValue(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
 439                 logger.debug("dscAlarmEventRecieved(): Thing - {}   Command - {}", thing.getUID(), dscAlarmCode);
 440
 441                 int state = 0;
 442
 443                 switch (dscAlarmCode) {
 444                     case CommandAcknowledge: /* 500 */
 445                         break;
 446                     case SystemError: /* 502 */
 447                         int errorCode = Integer.parseInt(dscAlarmMessageData);
 448
 449                         if (errorCode == 23 || errorCode == 24) {
 450                             List<Thing> things = dscAlarmBridgeHandler.getThing().getThings();
 451                             for (Thing thg : things) {
 452                                 if (thg.getThingTypeUID().equals(PARTITION_THING_TYPE)) {
 453                                     DSCAlarmBaseThingHandler handler = (DSCAlarmBaseThingHandler) thg.getHandler();
 454                                     if (handler != null) {
 455                                         channelUID = new ChannelUID(thg.getUID(), PARTITION_ARM_MODE);
 456                                         handler.updateChannel(channelUID, 0, "");
 457                                     }
 458                                 }
 459                             }
 460                         }
 461
 462                         panelSystemError(dscAlarmMessage);
 463                         break;
 464                     case TimeDateBroadcast: /* 550 */
 465                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME);
 466                         String panelTime = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA);
 467                         updateChannel(channelUID, state, panelTime);
 468
 469                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME_BROADCAST);
 470                         updateChannel(channelUID, 1, "");
 471                         break;
 472                     case FireKeyAlarm: /* 621 */
 473                         state = 1;
 474                     case FireKeyRestored: /* 622 */
 475                         channelUID = new ChannelUID(getThing().getUID(), PANEL_FIRE_KEY_ALARM);
 476                         updateChannel(channelUID, state, "");
 477                         restorePartitionsInAlarm(dscAlarmCode);
 478                         break;
 479                     case AuxiliaryKeyAlarm: /* 623 */
 480                         state = 1;
 481                     case AuxiliaryKeyRestored: /* 624 */
 482                         channelUID = new ChannelUID(getThing().getUID(), PANEL_AUX_KEY_ALARM);
 483                         updateChannel(channelUID, state, "");
 484                         restorePartitionsInAlarm(dscAlarmCode);
 485                         break;
 486                     case PanicKeyAlarm: /* 625 */
 487                         state = 1;
 488                     case PanicKeyRestored: /* 626 */
 489                         channelUID = new ChannelUID(getThing().getUID(), PANEL_PANIC_KEY_ALARM);
 490                         updateChannel(channelUID, state, "");
 491                         restorePartitionsInAlarm(dscAlarmCode);
 492                         break;
 493                     case AuxiliaryInputAlarm: /* 631 */
 494                         state = 1;
 495                     case AuxiliaryInputAlarmRestored: /* 632 */
 496                         channelUID = new ChannelUID(getThing().getUID(), PANEL_AUX_INPUT_ALARM);
 497                         updateChannel(channelUID, state, "");
 498                         restorePartitionsInAlarm(dscAlarmCode);
 499                         break;
 500                     case TroubleLEDOn: /* 840 */
 501                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_LED);
 502                         updateChannel(channelUID, 1, "");
 503                         break;
 504                     case TroubleLEDOff: /* 841 */
 505                         channelUID = new ChannelUID(getThing().getUID(), PANEL_SERVICE_REQUIRED);
 506                         updateChannel(channelUID, 0, "");
 507
 508                         channelUID = new ChannelUID(getThing().getUID(), PANEL_AC_TROUBLE);
 509                         updateChannel(channelUID, 0, "");
 510
 511                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TELEPHONE_TROUBLE);
 512                         updateChannel(channelUID, 0, "");
 513
 514                         channelUID = new ChannelUID(getThing().getUID(), PANEL_FTC_TROUBLE);
 515                         updateChannel(channelUID, 0, "");
 516
 517                         channelUID = new ChannelUID(getThing().getUID(), PANEL_ZONE_FAULT);
 518                         updateChannel(channelUID, 0, "");
 519
 520                         channelUID = new ChannelUID(getThing().getUID(), PANEL_ZONE_TAMPER);
 521                         updateChannel(channelUID, 0, "");
 522
 523                         channelUID = new ChannelUID(getThing().getUID(), PANEL_ZONE_LOW_BATTERY);
 524                         updateChannel(channelUID, 0, "");
 525
 526                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME_LOSS);
 527                         updateChannel(channelUID, 0, "");
 528
 529                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_LED);
 530                         updateChannel(channelUID, 0, "");
 531                         break;
 532                     case PanelBatteryTrouble: /* 800 */
 533                     case PanelACTrouble: /* 802 */
 534                     case SystemBellTrouble: /* 806 */
 535                     case TLMLine1Trouble: /* 810 */
 536                     case TLMLine2Trouble: /* 812 */
 537                     case FTCTrouble: /* 814 */
 538                     case GeneralDeviceLowBattery: /* 821 */
 539                     case WirelessKeyLowBatteryTrouble: /* 825 */
 540                     case HandheldKeypadLowBatteryTrouble: /* 827 */
 541                     case GeneralSystemTamper: /* 829 */
 542                     case HomeAutomationTrouble: /* 831 */
 543                     case KeybusFault: /* 896 */
 544                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_MESSAGE);
 545                         updateChannel(channelUID, 0,
 546                                 dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DESCRIPTION));
 547                         break;
 548                     case PanelBatteryTroubleRestore: /* 801 */
 549                     case PanelACRestore: /* 803 */
 550                     case SystemBellTroubleRestore: /* 807 */
 551                     case TLMLine1TroubleRestore: /* 811 */
 552                     case TLMLine2TroubleRestore: /* 813 */
 553                     case GeneralDeviceLowBatteryRestore: /* 822 */
 554                     case WirelessKeyLowBatteryTroubleRestore: /* 826 */
 555                     case HandheldKeypadLowBatteryTroubleRestore: /* 828 */
 556                     case GeneralSystemTamperRestore: /* 830 */
 557                     case HomeAutomationTroubleRestore: /* 832 */
 558                     case KeybusFaultRestore: /* 897 */
 559                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_MESSAGE);
 560                         updateChannel(channelUID, 0, "");
 561                         break;
 562                     case VerboseTroubleStatus: /* 849 */
 563                         verboseTroubleStatusHandler(event);
 564                         break;
 565                     case CodeRequired: /* 900 */
 566                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.CodeSend, getUserCode());
 567                         break;
 568                     default:
 569                         break;
 570                 }
 571             }
 572         }
 573     }
 574 }