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.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 = OnOffType.from(boolState);
 102                     updateState(channelUID, onOffType);
 103                     break;
 104                 case PANEL_TIME_BROADCAST:
 105                     boolState = state != 0;
 106                     onOffType = OnOffType.from(boolState);
 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 = OnOffType.from(boolState);
 118                     updateState(channelUID, onOffType);
 119                     break;
 120                 case PANEL_SERVICE_REQUIRED:
 121                     trouble = state != 0;
 122                     onOffType = OnOffType.from(trouble);
 123                     updateState(channelUID, onOffType);
 124                     break;
 125                 case PANEL_AC_TROUBLE:
 126                     trouble = state != 0;
 127                     onOffType = OnOffType.from(trouble);
 128                     updateState(channelUID, onOffType);
 129                     break;
 130                 case PANEL_TELEPHONE_TROUBLE:
 131                     trouble = state != 0;
 132                     onOffType = OnOffType.from(trouble);
 133                     updateState(channelUID, onOffType);
 134                     break;
 135                 case PANEL_FTC_TROUBLE:
 136                     trouble = state != 0;
 137                     onOffType = OnOffType.from(trouble);
 138                     updateState(channelUID, onOffType);
 139                     break;
 140                 case PANEL_ZONE_FAULT:
 141                     trouble = state != 0;
 142                     onOffType = OnOffType.from(trouble);
 143                     updateState(channelUID, onOffType);
 144                     break;
 145                 case PANEL_ZONE_TAMPER:
 146                     trouble = state != 0;
 147                     onOffType = OnOffType.from(trouble);
 148                     updateState(channelUID, onOffType);
 149                     break;
 150                 case PANEL_ZONE_LOW_BATTERY:
 151                     trouble = state != 0;
 152                     onOffType = OnOffType.from(trouble);
 153                     updateState(channelUID, onOffType);
 154                     break;
 155                 case PANEL_TIME_LOSS:
 156                     trouble = state != 0;
 157                     onOffType = OnOffType.from(trouble);
 158                     updateState(channelUID, onOffType);
 159                     break;
 160                 case PANEL_FIRE_KEY_ALARM:
 161                     trigger = state != 0;
 162                     onOffType = OnOffType.from(trigger);
 163                     updateState(channelUID, onOffType);
 164                     break;
 165                 case PANEL_PANIC_KEY_ALARM:
 166                     trigger = state != 0;
 167                     onOffType = OnOffType.from(trigger);
 168                     updateState(channelUID, onOffType);
 169                     break;
 170                 case PANEL_AUX_KEY_ALARM:
 171                     trigger = state != 0;
 172                     onOffType = OnOffType.from(trigger);
 173                     updateState(channelUID, onOffType);
 174                     break;
 175                 case PANEL_AUX_INPUT_ALARM:
 176                     trigger = state != 0;
 177                     onOffType = OnOffType.from(trigger);
 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 onOffCommand) {
 206                         cmd = command == OnOffType.ON ? 1 : 0;
 207                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.TimeStampControl, String.valueOf(cmd));
 208                         updateState(channelUID, onOffCommand);
 209                     }
 210                     break;
 211                 case PANEL_TIME_BROADCAST:
 212                     if (command instanceof OnOffType onOffCommand) {
 213                         cmd = command == OnOffType.ON ? 1 : 0;
 214                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.TimeDateBroadcastControl, String.valueOf(cmd));
 215                         updateState(channelUID, onOffCommand);
 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         ChannelUID channelUID = null;
 384
 385         int bitCount = 8;
 386         int bitField = Integer.decode("0x" + dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA));
 387         int[] masks = { 1, 2, 4, 8, 16, 32, 64, 128 };
 388         int[] bits = new int[bitCount];
 389
 390         for (int i = 0; i < bitCount; i++) {
 391             channelUID = new ChannelUID(getThing().getUID(), channelTypes[i]);
 392             bits[i] = bitField & masks[i];
 393             updateChannel(channelUID, bits[i] != 0 ? 1 : 0, "");
 394         }
 395     }
 396
 397     /**
 398      * Restores all partitions that are in alarm after special panel alarm conditions have been restored.
 399      *
 400      * @param dscAlarmCode
 401      */
 402     private void restorePartitionsInAlarm(DSCAlarmCode dscAlarmCode) {
 403         logger.debug("restorePartitionsInAlarm(): DSC Alarm Code: {}!", dscAlarmCode.toString());
 404
 405         ChannelUID channelUID = null;
 406
 407         if (dscAlarmCode == DSCAlarmCode.FireKeyRestored || dscAlarmCode == DSCAlarmCode.AuxiliaryKeyRestored
 408                 || dscAlarmCode == DSCAlarmCode.PanicKeyRestored
 409                 || dscAlarmCode == DSCAlarmCode.AuxiliaryInputAlarmRestored) {
 410             List<Thing> things = dscAlarmBridgeHandler.getThing().getThings();
 411             for (Thing thg : things) {
 412                 if (thg.getThingTypeUID().equals(PARTITION_THING_TYPE)) {
 413                     DSCAlarmBaseThingHandler handler = (DSCAlarmBaseThingHandler) thg.getHandler();
 414                     if (handler != null) {
 415                         channelUID = new ChannelUID(thg.getUID(), PARTITION_IN_ALARM);
 416                         handler.updateChannel(channelUID, 0, "");
 417
 418                         logger.debug("restorePartitionsInAlarm(): Partition In Alarm Restored: {}!", thg.getUID());
 419                     }
 420                 }
 421             }
 422         }
 423     }
 424
 425     @Override
 426     @SuppressWarnings("PMD.CompareObjectsWithEquals")
 427     public void dscAlarmEventReceived(EventObject event, Thing thing) {
 428         if (thing != null) {
 429             DSCAlarmEvent dscAlarmEvent = (DSCAlarmEvent) event;
 430             DSCAlarmMessage dscAlarmMessage = dscAlarmEvent.getDSCAlarmMessage();
 431             String dscAlarmMessageData = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA);
 432             setTimeStampState(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.TIME_STAMP));
 433
 434             if (getThing() == thing) {
 435                 ChannelUID channelUID = null;
 436                 DSCAlarmCode dscAlarmCode = DSCAlarmCode
 437                         .getDSCAlarmCodeValue(dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.CODE));
 438                 logger.debug("dscAlarmEventRecieved(): Thing - {}   Command - {}", thing.getUID(), dscAlarmCode);
 439
 440                 int state = 0;
 441
 442                 switch (dscAlarmCode) {
 443                     case CommandAcknowledge: /* 500 */
 444                         break;
 445                     case SystemError: /* 502 */
 446                         int errorCode = Integer.parseInt(dscAlarmMessageData);
 447
 448                         if (errorCode == 23 || errorCode == 24) {
 449                             List<Thing> things = dscAlarmBridgeHandler.getThing().getThings();
 450                             for (Thing thg : things) {
 451                                 if (thg.getThingTypeUID().equals(PARTITION_THING_TYPE)) {
 452                                     DSCAlarmBaseThingHandler handler = (DSCAlarmBaseThingHandler) thg.getHandler();
 453                                     if (handler != null) {
 454                                         channelUID = new ChannelUID(thg.getUID(), PARTITION_ARM_MODE);
 455                                         handler.updateChannel(channelUID, 0, "");
 456                                     }
 457                                 }
 458                             }
 459                         }
 460
 461                         panelSystemError(dscAlarmMessage);
 462                         break;
 463                     case TimeDateBroadcast: /* 550 */
 464                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME);
 465                         String panelTime = dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DATA);
 466                         updateChannel(channelUID, state, panelTime);
 467
 468                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME_BROADCAST);
 469                         updateChannel(channelUID, 1, "");
 470                         break;
 471                     case FireKeyAlarm: /* 621 */
 472                         state = 1;
 473                     case FireKeyRestored: /* 622 */
 474                         channelUID = new ChannelUID(getThing().getUID(), PANEL_FIRE_KEY_ALARM);
 475                         updateChannel(channelUID, state, "");
 476                         restorePartitionsInAlarm(dscAlarmCode);
 477                         break;
 478                     case AuxiliaryKeyAlarm: /* 623 */
 479                         state = 1;
 480                     case AuxiliaryKeyRestored: /* 624 */
 481                         channelUID = new ChannelUID(getThing().getUID(), PANEL_AUX_KEY_ALARM);
 482                         updateChannel(channelUID, state, "");
 483                         restorePartitionsInAlarm(dscAlarmCode);
 484                         break;
 485                     case PanicKeyAlarm: /* 625 */
 486                         state = 1;
 487                     case PanicKeyRestored: /* 626 */
 488                         channelUID = new ChannelUID(getThing().getUID(), PANEL_PANIC_KEY_ALARM);
 489                         updateChannel(channelUID, state, "");
 490                         restorePartitionsInAlarm(dscAlarmCode);
 491                         break;
 492                     case AuxiliaryInputAlarm: /* 631 */
 493                         state = 1;
 494                     case AuxiliaryInputAlarmRestored: /* 632 */
 495                         channelUID = new ChannelUID(getThing().getUID(), PANEL_AUX_INPUT_ALARM);
 496                         updateChannel(channelUID, state, "");
 497                         restorePartitionsInAlarm(dscAlarmCode);
 498                         break;
 499                     case TroubleLEDOn: /* 840 */
 500                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_LED);
 501                         updateChannel(channelUID, 1, "");
 502                         break;
 503                     case TroubleLEDOff: /* 841 */
 504                         channelUID = new ChannelUID(getThing().getUID(), PANEL_SERVICE_REQUIRED);
 505                         updateChannel(channelUID, 0, "");
 506
 507                         channelUID = new ChannelUID(getThing().getUID(), PANEL_AC_TROUBLE);
 508                         updateChannel(channelUID, 0, "");
 509
 510                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TELEPHONE_TROUBLE);
 511                         updateChannel(channelUID, 0, "");
 512
 513                         channelUID = new ChannelUID(getThing().getUID(), PANEL_FTC_TROUBLE);
 514                         updateChannel(channelUID, 0, "");
 515
 516                         channelUID = new ChannelUID(getThing().getUID(), PANEL_ZONE_FAULT);
 517                         updateChannel(channelUID, 0, "");
 518
 519                         channelUID = new ChannelUID(getThing().getUID(), PANEL_ZONE_TAMPER);
 520                         updateChannel(channelUID, 0, "");
 521
 522                         channelUID = new ChannelUID(getThing().getUID(), PANEL_ZONE_LOW_BATTERY);
 523                         updateChannel(channelUID, 0, "");
 524
 525                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TIME_LOSS);
 526                         updateChannel(channelUID, 0, "");
 527
 528                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_LED);
 529                         updateChannel(channelUID, 0, "");
 530                         break;
 531                     case PanelBatteryTrouble: /* 800 */
 532                     case PanelACTrouble: /* 802 */
 533                     case SystemBellTrouble: /* 806 */
 534                     case TLMLine1Trouble: /* 810 */
 535                     case TLMLine2Trouble: /* 812 */
 536                     case FTCTrouble: /* 814 */
 537                     case GeneralDeviceLowBattery: /* 821 */
 538                     case WirelessKeyLowBatteryTrouble: /* 825 */
 539                     case HandheldKeypadLowBatteryTrouble: /* 827 */
 540                     case GeneralSystemTamper: /* 829 */
 541                     case HomeAutomationTrouble: /* 831 */
 542                     case KeybusFault: /* 896 */
 543                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_MESSAGE);
 544                         updateChannel(channelUID, 0,
 545                                 dscAlarmMessage.getMessageInfo(DSCAlarmMessageInfoType.DESCRIPTION));
 546                         break;
 547                     case PanelBatteryTroubleRestore: /* 801 */
 548                     case PanelACRestore: /* 803 */
 549                     case SystemBellTroubleRestore: /* 807 */
 550                     case TLMLine1TroubleRestore: /* 811 */
 551                     case TLMLine2TroubleRestore: /* 813 */
 552                     case GeneralDeviceLowBatteryRestore: /* 822 */
 553                     case WirelessKeyLowBatteryTroubleRestore: /* 826 */
 554                     case HandheldKeypadLowBatteryTroubleRestore: /* 828 */
 555                     case GeneralSystemTamperRestore: /* 830 */
 556                     case HomeAutomationTroubleRestore: /* 832 */
 557                     case KeybusFaultRestore: /* 897 */
 558                         channelUID = new ChannelUID(getThing().getUID(), PANEL_TROUBLE_MESSAGE);
 559                         updateChannel(channelUID, 0, "");
 560                         break;
 561                     case VerboseTroubleStatus: /* 849 */
 562                         verboseTroubleStatusHandler(event);
 563                         break;
 564                     case CodeRequired: /* 900 */
 565                         dscAlarmBridgeHandler.sendCommand(DSCAlarmCode.CodeSend, getUserCode());
 566                         break;
 567                     default:
 568                         break;
 569                 }
 570             }
 571         }
 572     }
 573 }