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.rfxcom.internal.messages;
  14
  15 import org.openhab.binding.rfxcom.internal.config.RFXComDeviceConfiguration;
  16 import org.openhab.binding.rfxcom.internal.exceptions.RFXComException;
  17 import org.openhab.binding.rfxcom.internal.exceptions.RFXComUnsupportedValueException;
  18 import org.openhab.core.util.HexUtils;
  19
  20 /**
  21  * Base class for RFXCOM data classes. All other data classes should extend this class.
  22  *
  23  * @author Pauli Anttila - Initial contribution
  24  */
  25 public abstract class RFXComBaseMessage implements RFXComMessage {
  26
  27     public static final String ID_DELIMITER = ".";
  28
  29     public enum PacketType implements ByteEnumWrapper {
  30         INTERFACE_CONTROL(0),
  31         INTERFACE_MESSAGE(1),
  32         TRANSMITTER_MESSAGE(2),
  33         UNDECODED_RF_MESSAGE(3),
  34         LIGHTING1(16),
  35         LIGHTING2(17),
  36         LIGHTING3(18),
  37         LIGHTING4(19),
  38         LIGHTING5(20),
  39         LIGHTING6(21),
  40         CHIME(22),
  41         FAN(23, RFXComFanMessage.SubType.LUCCI_AIR_FAN, RFXComFanMessage.SubType.WESTINGHOUSE_7226640,
  42                 RFXComFanMessage.SubType.CASAFAN),
  43         FAN_SF01(23, RFXComFanMessage.SubType.SF01),
  44         FAN_ITHO(23, RFXComFanMessage.SubType.CVE_RFT),
  45         FAN_LUCCI_DC(23, RFXComFanMessage.SubType.LUCCI_AIR_DC),
  46         FAN_LUCCI_DC_II(23, RFXComFanMessage.SubType.LUCCI_AIR_DC_II),
  47         FAN_SEAV(23, RFXComFanMessage.SubType.SEAV_TXS4),
  48         FAN_FT1211R(23, RFXComFanMessage.SubType.FT1211R),
  49         FAN_FALMEC(23, RFXComFanMessage.SubType.FALMEC),
  50         FAN_ITHO_CVE_ECO_RFT(23, RFXComFanMessage.SubType.ITHO_CVE_ECO_RFT),
  51         FAN_NOVY(23, RFXComFanMessage.SubType.NOVY),
  52         CURTAIN1(24),
  53         BLINDS1(25),
  54         RFY(26),
  55         HOME_CONFORT(27),
  56         EDISIO(28),
  57         SECURITY1(32),
  58         SECURITY2(33),
  59         CAMERA1(40),
  60         REMOTE_CONTROL(48),
  61         THERMOSTAT1(64),
  62         THERMOSTAT2(65),
  63         THERMOSTAT3(66),
  64         THERMOSTAT4(67),
  65         RADIATOR1(72),
  66         BBQ(78),
  67         TEMPERATURE_RAIN(79),
  68         TEMPERATURE(80),
  69         HUMIDITY(81),
  70         TEMPERATURE_HUMIDITY(82),
  71         BAROMETRIC(83),
  72         TEMPERATURE_HUMIDITY_BAROMETRIC(84),
  73         RAIN(85),
  74         WIND(86),
  75         UV(87),
  76         DATE_TIME(88),
  77         CURRENT(89),
  78         ENERGY(90),
  79         CURRENT_ENERGY(91),
  80         POWER(92),
  81         WEIGHT(93),
  82         GAS(94),
  83         WATER(95),
  84         CARTELECTRONIC(96),
  85         RFXSENSOR(112),
  86         RFXMETER(113),
  87         FS20(114),
  88         RAW(127),
  89         IO_LINES(128);
  90
  91         private final int packetType;
  92         private final ByteEnumWrapper[] subTypes;
  93
  94         PacketType(int packetType, ByteEnumWrapper... subTypes) {
  95             this.packetType = packetType;
  96             this.subTypes = subTypes;
  97         }
  98
  99         @Override
 100         public byte toByte() {
 101             return (byte) packetType;
 102         }
 103     }
 104
 105     public byte[] rawMessage;
 106     private PacketType packetType;
 107     public byte packetId;
 108     public byte subType;
 109     public byte seqNbr;
 110     public byte id1;
 111     public byte id2;
 112
 113     public RFXComBaseMessage() {
 114     }
 115
 116     public RFXComBaseMessage(PacketType packetType) {
 117         this.packetType = packetType;
 118     }
 119
 120     @Override
 121     public void encodeMessage(byte[] data) throws RFXComException {
 122         rawMessage = data;
 123
 124         packetId = data[1];
 125         packetType = fromByte(data[1], data[2]);
 126         subType = data[2];
 127         seqNbr = data[3];
 128         id1 = data[4];
 129
 130         if (data.length > 5) {
 131             id2 = data[5];
 132         }
 133     }
 134
 135     private PacketType fromByte(byte packetId, byte subType) throws RFXComUnsupportedValueException {
 136         for (PacketType enumValue : PacketType.values()) {
 137             if (enumValue.toByte() == packetId) {
 138                 // if there are no subtypes?
 139                 if (enumValue.subTypes.length == 0) {
 140                     return enumValue;
 141                 }
 142                 // otherwise check for the matching subType
 143                 for (ByteEnumWrapper e : enumValue.subTypes) {
 144                     if (e.toByte() == subType) {
 145                         return enumValue;
 146                     }
 147                 }
 148             }
 149         }
 150
 151         throw new RFXComUnsupportedValueException(PacketType.class, packetId);
 152     }
 153
 154     public PacketType getPacketType() {
 155         return packetType;
 156     }
 157
 158     @Override
 159     public String toString() {
 160         String str;
 161
 162         if (rawMessage == null) {
 163             str = "Raw data = unknown";
 164         } else {
 165             str = "Raw data = " + HexUtils.bytesToHex(rawMessage);
 166         }
 167
 168         str += ", Packet type = " + packetType;
 169         str += ", Seq number = " + Byte.toUnsignedInt(seqNbr);
 170
 171         return str;
 172     }
 173
 174     @Override
 175     public void setConfig(RFXComDeviceConfiguration deviceConfiguration) throws RFXComException {
 176         // noop
 177     }
 178 }