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

   1 /**
   2  * Copyright (c) 2010-2024 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 static org.openhab.binding.rfxcom.internal.RFXComBindingConstants.*;
  16 import static org.openhab.binding.rfxcom.internal.messages.ByteEnumUtil.fromByte;
  17
  18 import org.openhab.binding.rfxcom.internal.config.RFXComDeviceConfiguration;
  19 import org.openhab.binding.rfxcom.internal.exceptions.RFXComException;
  20 import org.openhab.binding.rfxcom.internal.exceptions.RFXComInvalidStateException;
  21 import org.openhab.binding.rfxcom.internal.exceptions.RFXComUnsupportedChannelException;
  22 import org.openhab.binding.rfxcom.internal.exceptions.RFXComUnsupportedValueException;
  23 import org.openhab.binding.rfxcom.internal.handler.DeviceState;
  24 import org.openhab.core.library.types.DecimalType;
  25 import org.openhab.core.types.State;
  26 import org.openhab.core.types.Type;
  27
  28 /**
  29  * RFXCOM data class for energy message.
  30  *
  31  * @author Unknown - Initial contribution
  32  * @author Pauli Anttila
  33  */
  34 public class RFXComEnergyMessage extends RFXComBatteryDeviceMessage<RFXComEnergyMessage.SubType> {
  35
  36     private static final double TOTAL_USAGE_CONVERSION_FACTOR = 223.666d;
  37     private static final double WATTS_TO_AMPS_CONVERSION_FACTOR = 230d;
  38
  39     public enum SubType implements ByteEnumWrapper {
  40         ELEC2(1),
  41         ELEC3(2);
  42
  43         private final int subType;
  44
  45         SubType(int subType) {
  46             this.subType = subType;
  47         }
  48
  49         @Override
  50         public byte toByte() {
  51             return (byte) subType;
  52         }
  53     }
  54
  55     public SubType subType;
  56     public int sensorId;
  57     public byte count;
  58     public double instantAmp;
  59     public double totalAmpHour;
  60     public double instantPower;
  61     public double totalUsage;
  62
  63     public RFXComEnergyMessage() {
  64         super(PacketType.ENERGY);
  65     }
  66
  67     public RFXComEnergyMessage(byte[] data) throws RFXComException {
  68         encodeMessage(data);
  69     }
  70
  71     @Override
  72     public String toString() {
  73         String str = "";
  74
  75         str += super.toString();
  76         str += ", Sub type = " + subType;
  77         str += ", Device Id = " + getDeviceId();
  78         str += ", Count = " + count;
  79         str += ", Instant Amps = " + instantAmp;
  80         str += ", Total Amp Hours = " + totalAmpHour;
  81         str += ", Signal level = " + signalLevel;
  82         str += ", Battery level = " + batteryLevel;
  83         str += ", Instant Power = " + instantPower;
  84         str += ", Total Usage = " + totalUsage;
  85
  86         return str;
  87     }
  88
  89     @Override
  90     public void encodeMessage(byte[] data) throws RFXComException {
  91         super.encodeMessage(data);
  92
  93         subType = fromByte(SubType.class, super.subType);
  94         sensorId = (data[4] & 0xFF) << 8 | (data[5] & 0xFF);
  95         count = data[6];
  96
  97         // all usage is reported in Watts based on 230V
  98         instantPower = ((data[7] & 0xFF) << 24 | (data[8] & 0xFF) << 16 | (data[9] & 0xFF) << 8 | (data[10] & 0xFF));
  99         totalUsage = ((long) (data[11] & 0xFF) << 40 | (long) (data[12] & 0xFF) << 32 | (data[13] & 0xFF) << 24
 100                 | (data[14] & 0xFF) << 16 | (data[15] & 0xFF) << 8 | (data[16] & 0xFF)) / TOTAL_USAGE_CONVERSION_FACTOR;
 101
 102         // convert to amps so external code can determine the watts based on local voltage
 103         instantAmp = instantPower / WATTS_TO_AMPS_CONVERSION_FACTOR;
 104         totalAmpHour = totalUsage / WATTS_TO_AMPS_CONVERSION_FACTOR;
 105
 106         signalLevel = (byte) ((data[17] & 0xF0) >> 4);
 107         batteryLevel = (byte) (data[17] & 0x0F);
 108     }
 109
 110     @Override
 111     public byte[] decodeMessage() {
 112         byte[] data = new byte[18];
 113
 114         data[0] = 0x11;
 115         data[1] = RFXComBaseMessage.PacketType.ENERGY.toByte();
 116         data[2] = subType.toByte();
 117         data[3] = seqNbr;
 118
 119         data[4] = (byte) ((sensorId & 0xFF00) >> 8);
 120         data[5] = (byte) (sensorId & 0x00FF);
 121         data[6] = count;
 122
 123         // convert our 'amp' values back into Watts since this is what comes back
 124         long instantUsage = (long) (instantAmp * WATTS_TO_AMPS_CONVERSION_FACTOR);
 125         long totalUsage = (long) (totalAmpHour * WATTS_TO_AMPS_CONVERSION_FACTOR * TOTAL_USAGE_CONVERSION_FACTOR);
 126
 127         data[7] = (byte) ((instantUsage >> 24) & 0xFF);
 128         data[8] = (byte) ((instantUsage >> 16) & 0xFF);
 129         data[9] = (byte) ((instantUsage >> 8) & 0xFF);
 130         data[10] = (byte) (instantUsage & 0xFF);
 131
 132         data[11] = (byte) ((totalUsage >> 40) & 0xFF);
 133         data[12] = (byte) ((totalUsage >> 32) & 0xFF);
 134         data[13] = (byte) ((totalUsage >> 24) & 0xFF);
 135         data[14] = (byte) ((totalUsage >> 16) & 0xFF);
 136         data[15] = (byte) ((totalUsage >> 8) & 0xFF);
 137         data[16] = (byte) (totalUsage & 0xFF);
 138
 139         data[17] = (byte) (((signalLevel & 0x0F) << 4) | (batteryLevel & 0x0F));
 140
 141         return data;
 142     }
 143
 144     @Override
 145     public String getDeviceId() {
 146         return String.valueOf(sensorId);
 147     }
 148
 149     @Override
 150     public State convertToState(String channelId, RFXComDeviceConfiguration config, DeviceState deviceState)
 151             throws RFXComUnsupportedChannelException, RFXComInvalidStateException {
 152         switch (channelId) {
 153             case CHANNEL_INSTANT_POWER:
 154                 return new DecimalType(instantPower);
 155
 156             case CHANNEL_TOTAL_USAGE:
 157                 return new DecimalType(totalUsage);
 158
 159             case CHANNEL_INSTANT_AMPS:
 160                 return new DecimalType(instantAmp);
 161
 162             case CHANNEL_TOTAL_AMP_HOUR:
 163                 return new DecimalType(totalAmpHour);
 164
 165             default:
 166                 return super.convertToState(channelId, config, deviceState);
 167         }
 168     }
 169
 170     @Override
 171     public void setSubType(SubType subType) {
 172         throw new UnsupportedOperationException();
 173     }
 174
 175     @Override
 176     public void setDeviceId(String deviceId) {
 177         throw new UnsupportedOperationException();
 178     }
 179
 180     @Override
 181     public void convertFromState(String channelId, Type type) {
 182         throw new UnsupportedOperationException();
 183     }
 184
 185     @Override
 186     public SubType convertSubType(String subType) throws RFXComUnsupportedValueException {
 187         return ByteEnumUtil.convertSubType(SubType.class, subType);
 188     }
 189 }