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

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