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.caddx.internal;
  14
  15 import java.io.PrintWriter;
  16 import java.io.StringWriter;
  17 import java.nio.charset.StandardCharsets;
  18 import java.text.CharacterIterator;
  19 import java.text.StringCharacterIterator;
  20 import java.util.Arrays;
  21
  22 import org.eclipse.jdt.annotation.NonNullByDefault;
  23
  24 /**
  25  * Panel message property class
  26  *
  27  * @author Georgios Moutsos - Initial contribution
  28  */
  29 @NonNullByDefault
  30 public class CaddxProperty {
  31     // private
  32     private final String name;
  33     private final CaddxPropertyType type; // 'Int', 'String', 'Bit'
  34     private final int byteFrom;
  35     private final int byteLength;
  36     private final int bitFrom;
  37     private final int bitLength;
  38     private final boolean external;
  39     private final String id;
  40
  41     public CaddxProperty(String id, int byteFrom, int byteLength, int bitFrom, int bitLength, CaddxPropertyType type,
  42             String name, boolean external) {
  43         this.id = id;
  44         this.name = name;
  45         this.type = type;
  46         this.byteFrom = byteFrom;
  47         this.byteLength = byteLength;
  48         this.bitFrom = bitFrom;
  49         this.bitLength = bitLength;
  50         this.external = external;
  51     }
  52
  53     public String getName() {
  54         return name;
  55     }
  56
  57     public CaddxPropertyType getType() {
  58         return type;
  59     }
  60
  61     public boolean getExternal() {
  62         return external;
  63     }
  64
  65     public String getId() {
  66         return id;
  67     }
  68
  69     public String getValue(byte[] message) {
  70         int mask;
  71         int val;
  72
  73         switch (type) {
  74             case INT:
  75                 if (bitFrom == 0 && bitLength == 0) {
  76                     mask = 255;
  77                     val = message[byteFrom - 1] & mask;
  78                 } else {
  79                     mask = ((1 << ((bitLength - bitFrom))) - 1) << bitFrom;
  80                     val = (message[byteFrom - 1] & mask) >> bitFrom;
  81                 }
  82
  83                 return Integer.toString(val);
  84             case STRING:
  85                 byte[] str = Arrays.copyOfRange(message, byteFrom - 1, byteFrom + byteLength - 1);
  86                 return mapCaddxString(new String(str, StandardCharsets.US_ASCII));
  87             case BIT:
  88                 return (((message[byteFrom - 1] & (1 << bitFrom)) > 0) ? "true" : "false");
  89             default:
  90                 throw new IllegalArgumentException("type is unknown.");
  91         }
  92     }
  93
  94     public String toString(byte[] message) {
  95         int mask;
  96         int val;
  97         StringWriter sWriter = new StringWriter();
  98         PrintWriter pWriter = new PrintWriter(sWriter);
  99
 100         switch (type) {
 101             case INT:
 102                 if (bitFrom == 0 && bitLength == 0) {
 103                     mask = 255;
 104                     val = message[byteFrom - 1];
 105                 } else {
 106                     mask = ((1 << ((bitLength - bitFrom) + 1)) - 1) << bitFrom;
 107                     val = (message[byteFrom - 1] & mask) >> bitFrom;
 108                 }
 109
 110                 pWriter.printf("%s: %02x - %d - %c", name, val, val, Character.isValidCodePoint(val) ? val : 32);
 111                 pWriter.flush();
 112
 113                 return sWriter.toString();
 114             case STRING:
 115                 pWriter.print(name);
 116                 pWriter.print(": ");
 117
 118                 byte[] a = Arrays.copyOfRange(message, byteFrom - 1, byteFrom + byteLength);
 119                 pWriter.println(mapCaddxString(new String(a, StandardCharsets.US_ASCII)));
 120                 pWriter.println();
 121                 for (int i = 0; i < byteLength; i++) {
 122                     pWriter.printf("%02x", message[byteFrom - 1 + i]);
 123                     pWriter.print(" - ");
 124                     pWriter.println((char) message[byteFrom - 1 + i]);
 125                 }
 126                 pWriter.flush();
 127
 128                 return sWriter.toString();
 129             case BIT:
 130                 pWriter.print(name);
 131                 pWriter.print(": ");
 132                 pWriter.print(((message[byteFrom - 1] & (1 << bitFrom)) > 0));
 133                 pWriter.flush();
 134
 135                 return sWriter.toString();
 136             default:
 137                 pWriter.print("Unknown type: ");
 138                 pWriter.print(type.toString());
 139                 pWriter.flush();
 140
 141                 return sWriter.toString();
 142         }
 143     }
 144
 145     private String mapCaddxString(String str) {
 146         StringBuilder s = new StringBuilder(str.length());
 147
 148         CharacterIterator it = new StringCharacterIterator(str);
 149         for (char ch = it.first(); ch != CharacterIterator.DONE; ch = it.next()) {
 150             switch (ch) {
 151                 case 0xb7:
 152                     s.append('Γ');
 153                     break;
 154                 case 0x10:
 155                     s.append('Δ');
 156                     break;
 157                 case 0x13:
 158                     s.append('Θ');
 159                     break;
 160                 case 0x14:
 161                     s.append('Λ');
 162                     break;
 163                 case 0x12:
 164                     s.append('Ξ');
 165                     break;
 166                 case 0xc8:
 167                     s.append('Π');
 168                     break;
 169                 case 0x16:
 170                     s.append('Σ');
 171                     break;
 172                 case 0xcc:
 173                     s.append('Φ');
 174                     break;
 175                 case 0x17:
 176                     s.append('Ψ');
 177                     break;
 178                 case 0x15:
 179                     s.append('Ω');
 180                     break;
 181                 default:
 182                     s.append(ch);
 183                     break;
 184             }
 185         }
 186
 187         return s.toString();
 188     }
 189 }