demus/openhab-addons
1
0
Fork 0
mirror of https://github.com/openhab/openhab-addons.git synced 2025-01-25 14:55:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

[modbus] Modbus register array backed by bytes and other simplifications (#8865)

Browse Source 
Signed-off-by: Sami Salonen <ssalonen@gmail.com>
This commit is contained in:
Sami Salonen 2020-11-26 19:07:49 +02:00 committed by GitHub
parent ff038bc9bb
commit b806ed45d0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
32 changed files with 2140 additions and 655 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
bundles/org.openhab.binding.modbus.e3dc/src/main/java/org/openhab/binding/modbus/e3dc/internal/dto/DataConverter.java
View File

@ -12,11 +12,12 @@
*/
package org.openhab.binding.modbus.e3dc.internal.dto;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.BitSet;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
import org.openhab.io.transport.modbus.ValueBuffer;
/**
* The {@link DataConverter} Helper class to convert bytes from modbus into desired data format
@ -25,27 +26,6 @@ import org.eclipse.jdt.annotation.NonNullByDefault;
*/
@NonNullByDefault
public class DataConverter {
private static final long MAX_INT32 = (long) Math.pow(2, Integer.SIZE);
/**
* Get unit16 value from 2 bytes
*
* @param wrap
* @return int
*/
public static int getUInt16Value(ByteBuffer wrap) {
return Short.toUnsignedInt(wrap.getShort());
}
/**
* Get unit32 value from 4 bytes
*
* @param wrap
* @return long
*/
public static long getLongValue(ByteBuffer wrap) {
return Integer.toUnsignedLong(wrap.getInt());
}
/**
* Get double value from 2 bytes with correction factor
@ -53,28 +33,12 @@ public class DataConverter {
* @param wrap
* @return double
*/
public static double getUDoubleValue(ByteBuffer wrap, double factor) {
return round(getUInt16Value(wrap) * factor, 2);
}
/**
* Conversion done according to E3DC Modbus Specification V1.7
*
* @param wrap
* @return decoded long value, Long.MIN_VALUE otherwise
*/
public static long getInt32Swap(ByteBuffer wrap) {
long a = getUInt16Value(wrap);
long b = getUInt16Value(wrap);
if (b < 32768) {
return b * 65536 + a;
} else {
return (MAX_INT32 - b * 65536 - a) * -1;
}
public static double getUDoubleValue(ValueBuffer wrap, double factor) {
return round(wrap.getUInt16() * factor, 2);
}
public static String getString(byte[] bArray) {
return new String(bArray, StandardCharsets.US_ASCII).trim();
return ModbusBitUtilities.extractStringFromBytes(bArray, 0, bArray.length, StandardCharsets.US_ASCII).trim();
}
public static int toInt(BitSet bitSet) {
@ -93,8 +57,7 @@ public class DataConverter {
}
long factor = (long) Math.pow(10, places);
value = value * factor;
long tmp = Math.round(value);
long tmp = Math.round(value * factor);
return (double) tmp / factor;
}
}

4
bundles/org.openhab.binding.modbus.e3dc/src/main/java/org/openhab/binding/modbus/e3dc/internal/dto/EmergencyBlock.java
View File

@ -14,13 +14,13 @@ package org.openhab.binding.modbus.e3dc.internal.dto;
import static org.openhab.binding.modbus.e3dc.internal.modbus.E3DCModbusConstans.*;
import java.nio.ByteBuffer;
import java.util.BitSet;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.modbus.e3dc.internal.modbus.Data;
import org.openhab.core.library.types.OnOffType;
import org.openhab.core.library.types.StringType;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
/**
* The {@link EmergencyBlock} Data object for E3DC Info Block
@ -55,7 +55,7 @@ public class EmergencyBlock implements Data {
*/
public EmergencyBlock(byte[] bArray) {
// uint16 status register 40084 - possible Status Strings are defined in Constants above
int status = DataConverter.getUInt16Value(ByteBuffer.wrap(bArray));
int status = ModbusBitUtilities.extractUInt16(bArray, 0);
if (status >= 0 && status < 5) {
epStatus = EP_STATUS_ARRAY[status];
} else {

9
bundles/org.openhab.binding.modbus.e3dc/src/main/java/org/openhab/binding/modbus/e3dc/internal/dto/InfoBlock.java
View File

@ -12,13 +12,12 @@
*/
package org.openhab.binding.modbus.e3dc.internal.dto;
import java.nio.ByteBuffer;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.modbus.e3dc.internal.modbus.Data;
import org.openhab.core.library.types.DecimalType;
import org.openhab.core.library.types.StringType;
import org.openhab.core.util.HexUtils;
import org.openhab.io.transport.modbus.ValueBuffer;
/**
* The {@link InfoBlock} Data object for E3DC Info Block
@ -43,7 +42,7 @@ public class InfoBlock implements Data {
*/
public InfoBlock(byte[] bArray) {
// index handling to calculate the correct start index
ByteBuffer wrapper = ByteBuffer.wrap(bArray);
ValueBuffer wrapper = ValueBuffer.wrap(bArray);
// first uint16 = 2 bytes - decode magic byte
byte[] magicBytes = new byte[2];
@ -52,11 +51,11 @@ public class InfoBlock implements Data {
// first uint16 = 2 bytes - decode magic byte
// unit8 (Modbus Major Version) + uint8 Modbus minor Version
String modbusVersion = wrapper.get() + "." + wrapper.get();
String modbusVersion = wrapper.getSInt8() + "." + wrapper.getSInt8();
this.modbusVersion = new StringType(modbusVersion);
// unit16 - supported registers
short supportedRegisters = wrapper.getShort();
short supportedRegisters = wrapper.getSInt16();
this.supportedRegisters = new DecimalType(supportedRegisters);
byte[] buffer = new byte[32];

25
bundles/org.openhab.binding.modbus.e3dc/src/main/java/org/openhab/binding/modbus/e3dc/internal/dto/PowerBlock.java
View File

@ -12,8 +12,6 @@
*/
package org.openhab.binding.modbus.e3dc.internal.dto;
import java.nio.ByteBuffer;
import javax.measure.quantity.Dimensionless;
import javax.measure.quantity.Power;
@ -21,6 +19,7 @@ import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.modbus.e3dc.internal.modbus.Data;
import org.openhab.core.library.types.QuantityType;
import org.openhab.core.library.unit.SmartHomeUnits;
import org.openhab.io.transport.modbus.ValueBuffer;
/**
* The {@link PowerBlock} Data object for E3DC Info Block
@ -49,10 +48,10 @@ public class PowerBlock implements Data {
*/
public PowerBlock(byte[] bArray) {
// index handling to calculate the correct start index
ByteBuffer wrap = ByteBuffer.wrap(bArray);
ValueBuffer wrap = ValueBuffer.wrap(bArray);
// int32_swap value = 4 byte
long pvPowerSupplyL = DataConverter.getInt32Swap(wrap);
long pvPowerSupplyL = wrap.getSInt32Swap();
/*
* int32_swap value don't provide negative values!
@ -60,7 +59,7 @@ public class PowerBlock implements Data {
* Negative value - Battery is discharging = Power supplier
*/
pvPowerSupply = QuantityType.valueOf(pvPowerSupplyL, SmartHomeUnits.WATT);
long batteryPower = DataConverter.getInt32Swap(wrap);
long batteryPower = wrap.getSInt32Swap();
if (batteryPower > 0) {
// Battery is charging so Power is consumed by Battery
batteryPowerSupply = QuantityType.valueOf(0, SmartHomeUnits.WATT);
@ -72,7 +71,7 @@ public class PowerBlock implements Data {
}
// int32_swap value = 4 byte
long householdPowerConsumptionL = DataConverter.getInt32Swap(wrap);
long householdPowerConsumptionL = wrap.getSInt32Swap();
householdPowerConsumption = QuantityType.valueOf(householdPowerConsumptionL, SmartHomeUnits.WATT);
/*
@ -80,7 +79,7 @@ public class PowerBlock implements Data {
* Positive value - Power provided towards Grid = Power consumer
* Negative value - Power requested from Grid = Power supplier
*/
long gridPower = DataConverter.getInt32Swap(wrap);
long gridPower = wrap.getSInt32Swap();
if (gridPower > 0) {
// Power is provided by Grid
gridPowerSupply = QuantityType.valueOf(gridPower, SmartHomeUnits.WATT);
@ -92,19 +91,19 @@ public class PowerBlock implements Data {
}
// int32_swap value = 4 byte
externalPowerSupply = QuantityType.valueOf(DataConverter.getInt32Swap(wrap), SmartHomeUnits.WATT);
externalPowerSupply = QuantityType.valueOf(wrap.getSInt32Swap(), SmartHomeUnits.WATT);
// int32_swap value = 4 byte
wallboxPowerConsumption = QuantityType.valueOf(DataConverter.getInt32Swap(wrap), SmartHomeUnits.WATT);
wallboxPowerConsumption = QuantityType.valueOf(wrap.getSInt32Swap(), SmartHomeUnits.WATT);
// int32_swap value = 4 byte
wallboxPVPowerConsumption = QuantityType.valueOf(DataConverter.getInt32Swap(wrap), SmartHomeUnits.WATT);
wallboxPVPowerConsumption = QuantityType.valueOf(wrap.getSInt32Swap(), SmartHomeUnits.WATT);
// unit8 + uint8 - one register with split value for Autarky & Self Consumption
autarky = QuantityType.valueOf(wrap.get(), SmartHomeUnits.PERCENT);
selfConsumption = QuantityType.valueOf(wrap.get(), SmartHomeUnits.PERCENT);
autarky = QuantityType.valueOf(wrap.getSInt8(), SmartHomeUnits.PERCENT);
selfConsumption = QuantityType.valueOf(wrap.getSInt8(), SmartHomeUnits.PERCENT);
// uint16 for Battery State of Charge
batterySOC = QuantityType.valueOf(wrap.getShort(), SmartHomeUnits.PERCENT);
batterySOC = QuantityType.valueOf(wrap.getSInt16(), SmartHomeUnits.PERCENT);
}
}

17
bundles/org.openhab.binding.modbus.e3dc/src/main/java/org/openhab/binding/modbus/e3dc/internal/dto/StringBlock.java
View File

@ -12,8 +12,6 @@
*/
package org.openhab.binding.modbus.e3dc.internal.dto;
import java.nio.ByteBuffer;
import javax.measure.quantity.ElectricCurrent;
import javax.measure.quantity.ElectricPotential;
import javax.measure.quantity.Power;
@ -22,6 +20,7 @@ import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.modbus.e3dc.internal.modbus.Data;
import org.openhab.core.library.types.QuantityType;
import org.openhab.core.library.unit.SmartHomeUnits;
import org.openhab.io.transport.modbus.ValueBuffer;
/**
* The {@link StringBlock} Data object for E3DC Info Block
@ -46,17 +45,17 @@ public class StringBlock implements Data {
* @param bArray - Modbus Registers as bytes from 40096 to 40104
*/
public StringBlock(byte[] bArray) {
ByteBuffer wrap = ByteBuffer.wrap(bArray);
ValueBuffer wrap = ValueBuffer.wrap(bArray);
// straight forward - for each String the values Volt, Ampere and then Watt. All unt16 = 2 bytes values
string1Volt = QuantityType.valueOf(DataConverter.getUInt16Value(wrap), SmartHomeUnits.VOLT);
string2Volt = QuantityType.valueOf(DataConverter.getUInt16Value(wrap), SmartHomeUnits.VOLT);
string3Volt = QuantityType.valueOf(DataConverter.getUInt16Value(wrap), SmartHomeUnits.VOLT);
string1Volt = QuantityType.valueOf(wrap.getUInt16(), SmartHomeUnits.VOLT);
string2Volt = QuantityType.valueOf(wrap.getUInt16(), SmartHomeUnits.VOLT);
string3Volt = QuantityType.valueOf(wrap.getUInt16(), SmartHomeUnits.VOLT);
// E3DC Modbus Spec chapter 3.1.2, page 16 - Ampere values shall be handled with factor 0.01
string1Ampere = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.01), SmartHomeUnits.AMPERE);
string2Ampere = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.01), SmartHomeUnits.AMPERE);
string3Ampere = QuantityType.valueOf(DataConverter.getUDoubleValue(wrap, 0.01), SmartHomeUnits.AMPERE);
string1Watt = QuantityType.valueOf(DataConverter.getUInt16Value(wrap), SmartHomeUnits.WATT);
string2Watt = QuantityType.valueOf(DataConverter.getUInt16Value(wrap), SmartHomeUnits.WATT);
string3Watt = QuantityType.valueOf(DataConverter.getUInt16Value(wrap), SmartHomeUnits.WATT);
string1Watt = QuantityType.valueOf(wrap.getUInt16(), SmartHomeUnits.WATT);
string2Watt = QuantityType.valueOf(wrap.getUInt16(), SmartHomeUnits.WATT);
string3Watt = QuantityType.valueOf(wrap.getUInt16(), SmartHomeUnits.WATT);
}
}

10
bundles/org.openhab.binding.modbus.e3dc/src/main/java/org/openhab/binding/modbus/e3dc/internal/modbus/Parser.java
View File

@ -25,7 +25,6 @@ import org.openhab.binding.modbus.e3dc.internal.dto.StringBlock;
import org.openhab.binding.modbus.e3dc.internal.dto.WallboxArray;
import org.openhab.binding.modbus.e3dc.internal.modbus.Data.DataType;
import org.openhab.io.transport.modbus.AsyncModbusReadResult;
import org.openhab.io.transport.modbus.ModbusRegister;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -59,17 +58,10 @@ public class Parser {
}
public void handle(AsyncModbusReadResult result) {
byte[] newArray = new byte[size];
long startTime = System.currentTimeMillis();
Optional<ModbusRegisterArray> opt = result.getRegisters();
if (opt.isPresent()) {
ModbusRegisterArray registers = opt.get();
int i = 0;
for (ModbusRegister reg : registers) {
System.arraycopy(reg.getBytes(), 0, newArray, i, 2);
i += 2;
}
setArray(newArray);
setArray(opt.get().getBytes());
long duration = System.currentTimeMillis() - startTime;
avgDuration += duration;

33
bundles/org.openhab.binding.modbus.e3dc/src/test/java/org/openhab/binding/modbus/e3dc/dto/DataBlockTest.java
View File

@ -35,14 +35,26 @@ import org.openhab.core.library.types.OnOffType;
*/
public class DataBlockTest {
private Parser mc;
private Parser mcNegativePVSupply;
@BeforeEach
public void setup() {
byte[] dataBlock = new byte[] { 0, -14, 0, 0, -2, -47, -1, -1, 2, 47, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 99, 99, 0, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
125, 2, 21, 0, 0, 0, 27, 0, 26, 0, 0, 0, 103, 0, -117, 0, 0 };
mc = new Parser(DataType.DATA);
mc.setArray(dataBlock);
{
byte[] dataBlock = new byte[] { 0, -14, 0, 0, -2, -47, -1, -1, 2, 47, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 99, 99, 0, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 125, 2, 21, 0, 0, 0, 27, 0, 26, 0, 0, 0, 103, 0, -117, 0, 0 };
mc = new Parser(DataType.DATA);
mc.setArray(dataBlock);
}
{
// 65098 bytes [-2, 74]
// 65535 bytes [-1, -1]
byte[] dataBlock = new byte[] { -2, -74, -1, -1, -2, -47, -1, -1, 2, 47, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 99, 99, 0, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 125, 2, 21, 0, 0, 0, 27, 0, 26, 0, 0, 0, 103, 0, -117, 0, 0 };
mcNegativePVSupply = new Parser(DataType.DATA);
mcNegativePVSupply.setArray(dataBlock);
}
}
@Test
@ -56,6 +68,17 @@ public class DataBlockTest {
assertEquals("303.0 W", b.batteryPowerSupply.toString(), "Battery Supply");
}
@Test
public void testValidPowerBlockNegativePVSupply() {
Optional<Data> dataOpt = mcNegativePVSupply.parse(DataType.POWER);
assertTrue(dataOpt.isPresent());
PowerBlock b = (PowerBlock) dataOpt.get();
assertEquals("-330.0 W", b.pvPowerSupply.toString(), "PV Supply");
assertEquals("14.0 W", b.gridPowerSupply.toString(), "Grid Supply");
assertEquals("0.0 W", b.gridPowerConsumpition.toString(), "Grid Consumption");
assertEquals("303.0 W", b.batteryPowerSupply.toString(), "Battery Supply");
}
@Test
public void testValidWallboxBlock() {
Optional<Data> wba = mc.parse(DataType.WALLBOX);

16
bundles/org.openhab.binding.modbus.e3dc/src/test/java/org/openhab/binding/modbus/e3dc/internal/handler/E3DCHandlerStateTest.java
View File

@ -14,7 +14,6 @@ package org.openhab.binding.modbus.e3dc.internal.handler;
import static org.mockito.Mockito.*;
import java.nio.ByteBuffer;
import java.util.HashMap;
import org.eclipse.jdt.annotation.NonNullByDefault;
@ -31,7 +30,6 @@ import org.openhab.core.thing.binding.ThingHandlerCallback;
import org.openhab.io.transport.modbus.AsyncModbusFailure;
import org.openhab.io.transport.modbus.AsyncModbusReadResult;
import org.openhab.io.transport.modbus.ModbusReadRequestBlueprint;
import org.openhab.io.transport.modbus.ModbusRegister;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
/**
@ -92,26 +90,16 @@ public class E3DCHandlerStateTest {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 85, 78, 73, 78, 73, 84, 73, 65, 76, 73, 90, 69,
68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83, 49, 48, 95, 50, 48, 50, 48, 95, 48, 52,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
ByteBuffer infoWrap = ByteBuffer.wrap(infoBlockBytes);
ModbusRegister[] infoBlock = new ModbusRegister[infoBlockBytes.length / 2];
for (int i = 0; i < infoBlock.length; i++) {
infoBlock[i] = new ModbusRegister(infoWrap.get(), infoWrap.get());
}
ModbusReadRequestBlueprint readRequest = mock(ModbusReadRequestBlueprint.class);
return new AsyncModbusReadResult(readRequest, new ModbusRegisterArray(infoBlock));
return new AsyncModbusReadResult(readRequest, new ModbusRegisterArray(infoBlockBytes));
}
private AsyncModbusReadResult getDataResult() {
byte[] dataBlockBytes = new byte[] { 0, -14, 0, 0, -2, -47, -1, -1, 2, 47, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 99, 99, 0, 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 125, 2, 21, 0, 0, 0, 27, 0, 26, 0, 0, 0, 103, 0, -117, 0, 0 };
ByteBuffer dataWrap = ByteBuffer.wrap(dataBlockBytes);
ModbusRegister[] dataBlock = new ModbusRegister[dataBlockBytes.length / 2];
for (int i = 0; i < dataBlock.length; i++) {
dataBlock[i] = new ModbusRegister(dataWrap.get(), dataWrap.get());
}
ModbusReadRequestBlueprint readRequest = mock(ModbusReadRequestBlueprint.class);
return new AsyncModbusReadResult(readRequest, new ModbusRegisterArray(dataBlock));
return new AsyncModbusReadResult(readRequest, new ModbusRegisterArray(dataBlockBytes));
}
private AsyncModbusFailure<ModbusReadRequestBlueprint> getFailResult() {

60
bundles/org.openhab.binding.modbus.e3dc/src/test/java/org/openhab/binding/modbus/e3dc/util/DataConverterTest.java
View File

@ -14,12 +14,12 @@ package org.openhab.binding.modbus.e3dc.util;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.nio.ByteBuffer;
import java.util.BitSet;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.junit.jupiter.api.Test;
import org.openhab.binding.modbus.e3dc.internal.dto.DataConverter;
import org.openhab.io.transport.modbus.ValueBuffer;
/**
* The {@link DataConverterTest} Test data conversions
@ -30,17 +30,58 @@ import org.openhab.binding.modbus.e3dc.internal.dto.DataConverter;
public class DataConverterTest {
@Test
public void testE3DCSwapValueNegative() {
// Reg 69 value 65098 bytes [-2, 74]
// Reg 70 value 65535 bytes [-1, -1]
byte[] b = new byte[] { -2, -74, -1, -1 };
assertEquals(-330, DataConverter.getInt32Swap(ByteBuffer.wrap(b)), "Negative Value");
public void testRoundPositive() {
assertEquals(2.3, DataConverter.round(2.34, 1), 0.01);
}
@Test
public void testBitset() {
public void testRoundPositive2() {
assertEquals(2.4, DataConverter.round(2.37, 1), 0.01);
}
@Test
public void testRoundPositive3() {
assertEquals(2.4, DataConverter.round(2.35, 1), 0.01);
}
@Test
public void testRoundNegative() {
assertEquals(-2.3, DataConverter.round(-2.34, 1), 0.01);
}
@Test
public void testRoundNegative2() {
assertEquals(-2.4, DataConverter.round(-2.37, 1), 0.01);
}
@Test
public void testRoundNegative3() {
// rounding towards positive infinity. Note difference to testRoundPositive3
assertEquals(-2.3, DataConverter.round(-2.35, 1), 0.01);
}
@Test
public void testUDoubleValue() {
assertEquals(0.5, DataConverter.getUDoubleValue(ValueBuffer.wrap(new byte[] { 0, 5 }), 0.1), 0.01);
}
@Test
public void testUDoubleValue2() {
assertEquals(6159.9,
DataConverter.getUDoubleValue(ValueBuffer.wrap(new byte[] { (byte) 0xf0, (byte) 0x9f }), 0.1), 0.01);
}
@Test
public void testUDoubleValue3() {
assertEquals(123198,
DataConverter.getUDoubleValue(ValueBuffer.wrap(new byte[] { (byte) 0xf0, (byte) 0x9f }), 2), 0.01);
}
@Test
public void testBitsetToInt() {
byte[] b = new byte[] { 3, 16 };
BitSet s = BitSet.valueOf(b);
// Bit0 is the least significant bit to DataConverter.toInt
assertEquals(true, s.get(0), "Bit0");
assertEquals(true, s.get(1), "Bit1");
assertEquals(false, s.get(2), "Bit2");
@ -57,5 +98,10 @@ public class DataConverterTest {
assertEquals(false, s.get(13), "Bit13");
assertEquals(false, s.get(14), "Bit14");
assertEquals(false, s.get(15), "Bit15");
int bitsAsInt = DataConverter.toInt(s);
int expected = 0b0001000000000011;
assertEquals(Integer.toBinaryString(expected), Integer.toBinaryString(bitsAsInt));
assertEquals(expected, bitsAsInt);
}
}

41
bundles/org.openhab.binding.modbus.helioseasycontrols/src/main/java/org/openhab/binding/modbus/helioseasycontrols/internal/HeliosEasyControlsHandler.java
View File

@ -54,7 +54,6 @@ import org.openhab.io.transport.modbus.ModbusBitUtilities;
import org.openhab.io.transport.modbus.ModbusCommunicationInterface;
import org.openhab.io.transport.modbus.ModbusReadFunctionCode;
import org.openhab.io.transport.modbus.ModbusReadRequestBlueprint;
import org.openhab.io.transport.modbus.ModbusRegister;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
import org.openhab.io.transport.modbus.ModbusWriteRegisterRequestBlueprint;
import org.openhab.io.transport.modbus.endpoint.ModbusSlaveEndpoint;
@ -429,9 +428,8 @@ public class HeliosEasyControlsHandler extends BaseThingHandler {
lock.acquire();
comms.submitOneTimeWrite(
new ModbusWriteRegisterRequestBlueprint(HeliosEasyControlsBindingConstants.UNIT_ID,
HeliosEasyControlsBindingConstants.START_ADDRESS,
new ModbusRegisterArray(preparePayload(payload)), true,
HeliosEasyControlsBindingConstants.MAX_TRIES),
HeliosEasyControlsBindingConstants.START_ADDRESS, preparePayload(payload),
true, HeliosEasyControlsBindingConstants.MAX_TRIES),
result -> {
lock.release();
updateStatus(ThingStatus.ONLINE);
@ -477,8 +475,7 @@ public class HeliosEasyControlsHandler extends BaseThingHandler {
String payload = v.getVariableString();
comms.submitOneTimeWrite(new ModbusWriteRegisterRequestBlueprint(
HeliosEasyControlsBindingConstants.UNIT_ID, HeliosEasyControlsBindingConstants.START_ADDRESS,
new ModbusRegisterArray(preparePayload(payload)), true,
HeliosEasyControlsBindingConstants.MAX_TRIES), result -> {
preparePayload(payload), true, HeliosEasyControlsBindingConstants.MAX_TRIES), result -> {
comms.submitOneTimePoll(
new ModbusReadRequestBlueprint(HeliosEasyControlsBindingConstants.UNIT_ID,
ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS,
@ -690,25 +687,21 @@ public class HeliosEasyControlsHandler extends BaseThingHandler {
* @param payload The String representation of the payload
* @return The Register representation of the payload
*/
private ModbusRegister[] preparePayload(String payload) {
private static ModbusRegisterArray preparePayload(String payload) {
// determine number of registers
int l = (payload.length() + 1) / 2; // +1 because we need to include at least one termination symbol 0x00
if ((payload.length() + 1) % 2 != 0) {
l++;
}
byte[] asciiBytes = payload.getBytes(StandardCharsets.US_ASCII);
int bufferLength = asciiBytes.length // ascii characters
+ 1 // NUL byte
+ ((asciiBytes.length % 2 == 0) ? 1 : 0); // to have even number of bytes
assert bufferLength % 2 == 0; // Invariant, ensured above
ModbusRegister reg[] = new ModbusRegister[l];
byte[] b = payload.getBytes();
int ch = 0;
for (int i = 0; i < reg.length; i++) {
byte b1 = ch < b.length ? b[ch] : (byte) 0x00; // terminate with 0x00 if at the end of the payload
ch++;
byte b2 = ch < b.length ? b[ch] : (byte) 0x00;
ch++;
reg[i] = new ModbusRegister(b1, b2);
byte[] buffer = new byte[bufferLength];
System.arraycopy(asciiBytes, 0, buffer, 0, asciiBytes.length);
// Fill in rest of bytes with NUL bytes
for (int i = asciiBytes.length; i < buffer.length; i++) {
buffer[i] = '\0';
}
return reg;
return new ModbusRegisterArray(buffer);
}
/**
@ -718,8 +711,8 @@ public class HeliosEasyControlsHandler extends BaseThingHandler {
* @return The value or <tt>null</tt> if an error occurred
*/
private void processResponse(HeliosVariable v, ModbusRegisterArray registers) {
String r = ModbusBitUtilities
.extractStringFromRegisters(registers, 0, registers.size() * 2, StandardCharsets.US_ASCII).toString();
String r = ModbusBitUtilities.extractStringFromRegisters(registers, 0, registers.size() * 2,
StandardCharsets.US_ASCII);
String[] parts = r.split("=", 2); // remove the part "vXXXX=" from the string
// making sure we have a proper response and the response matches the requested variable
if ((parts.length == 2) && (v.getVariableString().equals(parts[0]))) {

71
bundles/org.openhab.binding.modbus.helioseasycontrols/src/test/java/org/openhab/binding/modbus/helioseasycontrols/internal/PreparePayloadTest.java Normal file
View File

@ -0,0 +1,71 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.binding.modbus.helioseasycontrols.internal;
import static org.junit.jupiter.api.Assertions.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Collections;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
/**
* @author Sami Salonen - Initial contribution
*/
public class PreparePayloadTest {
private Method preparePayloadMethod;
public PreparePayloadTest() throws NoSuchMethodException, SecurityException {
preparePayloadMethod = HeliosEasyControlsHandler.class.getDeclaredMethod("preparePayload", String.class);
preparePayloadMethod.setAccessible(true);
}
private ModbusRegisterArray preparePayload(String payload) {
try {
return (ModbusRegisterArray) preparePayloadMethod.invoke(null, payload);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
fail("Reflection failure:" + e.getMessage());
throw new RuntimeException(); // to make compiler happy
}
}
public static Collection<Object[]> data() {
return Collections.unmodifiableList(Stream
// Due to nul byte, full register full of nul bytes added
.of(new Object[] { "v00020=a", new ModbusRegisterArray(0x7630, 0x3030, 0x3230, 0x3d61, 0x0000) },
new Object[] { "v00020=aa", new ModbusRegisterArray(0x7630, 0x3030, 0x3230, 0x3d61, 0x6100) })
.collect(Collectors.toList()));
}
@ParameterizedTest
@MethodSource("data")
public void testPreparePayload(String payload, ModbusRegisterArray expectedRegisters) {
ModbusRegisterArray actual = preparePayload(payload);
assertEquals(actual.size(), expectedRegisters.size(), String.format("payload=%s", payload));
for (int i = 0; i < expectedRegisters.size(); i++) {
int expectedRegisterDataUnsigned = expectedRegisters.getRegister(i);
int actualUnsigned = actual.getRegister(i);
assertEquals(expectedRegisterDataUnsigned, actualUnsigned,
String.format("register index i=%d, payload=%s", i, payload));
}
}
}

12
bundles/org.openhab.binding.modbus.stiebeleltron/src/main/java/org/openhab/binding/modbus/stiebeleltron/internal/handler/StiebelEltronHandler.java
View File

@ -14,8 +14,7 @@ package org.openhab.binding.modbus.stiebeleltron.internal.handler;
import static org.openhab.binding.modbus.stiebeleltron.internal.StiebelEltronBindingConstants.*;
import static org.openhab.core.library.unit.SIUnits.CELSIUS;
import static org.openhab.core.library.unit.SmartHomeUnits.KILOWATT_HOUR;
import static org.openhab.core.library.unit.SmartHomeUnits.PERCENT;
import static org.openhab.core.library.unit.SmartHomeUnits.*;
import java.util.Optional;
@ -52,7 +51,6 @@ import org.openhab.io.transport.modbus.AsyncModbusFailure;
import org.openhab.io.transport.modbus.ModbusCommunicationInterface;
import org.openhab.io.transport.modbus.ModbusReadFunctionCode;
import org.openhab.io.transport.modbus.ModbusReadRequestBlueprint;
import org.openhab.io.transport.modbus.ModbusRegister;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
import org.openhab.io.transport.modbus.ModbusWriteRegisterRequestBlueprint;
import org.openhab.io.transport.modbus.ModbusWriteRequestBlueprint;
@ -198,11 +196,9 @@ public class StiebelEltronHandler extends BaseThingHandler {
throw new IllegalStateException("registerPollTask called without proper configuration");
}
// big endian byte ordering
byte b1 = (byte) (shortValue >> 8);
byte b2 = (byte) shortValue;
ModbusRegister register = new ModbusRegister(b1, b2);
ModbusRegisterArray data = new ModbusRegisterArray(new ModbusRegister[] { register });
byte hi = (byte) (shortValue >> 8);
byte lo = (byte) shortValue;
ModbusRegisterArray data = new ModbusRegisterArray(hi, lo);
ModbusWriteRegisterRequestBlueprint request = new ModbusWriteRegisterRequestBlueprint(slaveId, address, data,
false, myconfig.getMaxTries());

24
bundles/org.openhab.binding.modbus.studer/src/main/java/org/openhab/binding/modbus/studer/internal/StuderHandler.java
View File

@ -27,6 +27,7 @@ import org.openhab.binding.modbus.studer.internal.StuderParser.ModeXtender;
import org.openhab.binding.modbus.studer.internal.StuderParser.VSMode;
import org.openhab.binding.modbus.studer.internal.StuderParser.VTMode;
import org.openhab.binding.modbus.studer.internal.StuderParser.VTType;
import org.openhab.core.library.types.DecimalType;
import org.openhab.core.library.types.OnOffType;
import org.openhab.core.library.types.QuantityType;
import org.openhab.core.library.types.StringType;
@ -43,7 +44,9 @@ import org.openhab.core.types.Command;
import org.openhab.core.types.State;
import org.openhab.core.types.UnDefType;
import org.openhab.io.transport.modbus.AsyncModbusFailure;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
import org.openhab.io.transport.modbus.ModbusCommunicationInterface;
import org.openhab.io.transport.modbus.ModbusConstants.ValueType;
import org.openhab.io.transport.modbus.ModbusReadFunctionCode;
import org.openhab.io.transport.modbus.ModbusReadRequestBlueprint;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
@ -303,22 +306,21 @@ public class StuderHandler extends BaseThingHandler {
* @param registers byte array read from the modbus slave
*/
protected void handlePolledData(int registerNumber, ModbusRegisterArray registers) {
String hexString = registers.toHexString().toString();
Float quantity = parser.hexToFloat(hexString);
if (quantity != null) {
Optional<DecimalType> quantity = ModbusBitUtilities.extractStateFromRegisters(registers, 0, ValueType.FLOAT32);
quantity.ifPresent(value -> {
if (type.equals(THING_TYPE_BSP)) {
Unit<?> unit = UNIT_CHANNELS_BSP.get(registerNumber);
if (unit != null) {
internalUpdateState(CHANNELS_BSP.get(registerNumber), new QuantityType<>(quantity, unit));
internalUpdateState(CHANNELS_BSP.get(registerNumber), new QuantityType<>(value, unit));
}
} else if (type.equals(THING_TYPE_XTENDER)) {
handlePolledDataXtender(registerNumber, quantity);
handlePolledDataXtender(registerNumber, value);
} else if (type.equals(THING_TYPE_VARIOTRACK)) {
handlePolledDataVarioTrack(registerNumber, quantity);
handlePolledDataVarioTrack(registerNumber, value);
} else if (type.equals(THING_TYPE_VARIOSTRING)) {
handlePolledDataVarioString(registerNumber, quantity);
handlePolledDataVarioString(registerNumber, value);
}
}
});
resetCommunicationError();
}
@ -327,7 +329,7 @@ public class StuderHandler extends BaseThingHandler {
* The register array is first parsed, then each of the channels are updated
* to the new values
*/
protected void handlePolledDataVarioString(int registerNumber, Float quantity) {
protected void handlePolledDataVarioString(int registerNumber, DecimalType quantity) {
switch (CHANNELS_VARIOSTRING.get(registerNumber)) {
case CHANNEL_PV_OPERATING_MODE:
case CHANNEL_PV1_OPERATING_MODE:
@ -356,7 +358,7 @@ public class StuderHandler extends BaseThingHandler {
* The register array is first parsed, then each of the channels are updated
* to the new values
*/
protected void handlePolledDataVarioTrack(int registerNumber, Float quantity) {
protected void handlePolledDataVarioTrack(int registerNumber, DecimalType quantity) {
switch (CHANNELS_VARIOTRACK.get(registerNumber)) {
case CHANNEL_MODEL_VARIOTRACK:
VTType type = StuderParser.getVTTypeByCode(quantity.intValue());
@ -393,7 +395,7 @@ public class StuderHandler extends BaseThingHandler {
* The register array is first parsed, then each of the channels are updated
* to the new values
*/
protected void handlePolledDataXtender(int registerNumber, Float quantity) {
protected void handlePolledDataXtender(int registerNumber, DecimalType quantity) {
switch (CHANNELS_XTENDER.get(registerNumber)) {
case CHANNEL_OPERATING_STATE:
ModeXtender mode = StuderParser.getModeXtenderByCode(quantity.intValue());

10
bundles/org.openhab.binding.modbus.sunspec/src/main/java/org/openhab/binding/modbus/sunspec/internal/parser/CommonModelParser.java
View File

@ -52,12 +52,10 @@ public class CommonModelParser extends AbstractBaseParser implements SunspecPars
}
// parse manufacturer, model and version
block.manufacturer = ModbusBitUtilities.extractStringFromRegisters(raw, 2, 32, Charset.forName("UTF-8"))
.toString();
block.model = ModbusBitUtilities.extractStringFromRegisters(raw, 18, 32, Charset.forName("UTF-8")).toString();
block.version = ModbusBitUtilities.extractStringFromRegisters(raw, 42, 16, Charset.forName("UTF-8")).toString();
block.serialNumber = ModbusBitUtilities.extractStringFromRegisters(raw, 50, 32, Charset.forName("UTF-8"))
.toString();
block.manufacturer = ModbusBitUtilities.extractStringFromRegisters(raw, 2, 32, Charset.forName("UTF-8"));
block.model = ModbusBitUtilities.extractStringFromRegisters(raw, 18, 32, Charset.forName("UTF-8"));
block.version = ModbusBitUtilities.extractStringFromRegisters(raw, 42, 16, Charset.forName("UTF-8"));
block.serialNumber = ModbusBitUtilities.extractStringFromRegisters(raw, 50, 32, Charset.forName("UTF-8"));
block.deviceAddress = extractUInt16(raw, 66, 1);

686
bundles/org.openhab.io.transport.modbus/src/main/java/org/openhab/io/transport/modbus/ModbusBitUtilities.java
View File

@ -14,8 +14,6 @@ package org.openhab.io.transport.modbus;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.Charset;
import java.util.Optional;
@ -24,8 +22,8 @@ import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.core.library.types.DecimalType;
import org.openhab.core.library.types.OnOffType;
import org.openhab.core.library.types.OpenClosedType;
import org.openhab.core.library.types.StringType;
import org.openhab.core.types.Command;
import org.openhab.io.transport.modbus.ModbusConstants.ValueType;
/**
* Utilities for working with binary data.
@ -101,165 +99,522 @@ public class ModbusBitUtilities {
*/
public static Optional<DecimalType> extractStateFromRegisters(ModbusRegisterArray registers, int index,
ModbusConstants.ValueType type) {
int endBitIndex = (type.getBits() >= 16 ? 16 * index : type.getBits() * index) + type.getBits() - 1;
// each register has 16 bits
int lastValidIndex = registers.size() * 16 - 1;
if (endBitIndex > lastValidIndex || index < 0) {
throw new IllegalArgumentException(
String.format("Index=%d with type=%s is out-of-bounds given registers of size %d", index, type,
registers.size()));
}
byte[] bytes = registers.getBytes();
switch (type) {
case BIT:
return Optional
.of(new DecimalType((registers.getRegister(index / 16).toUnsignedShort() >> (index % 16)) & 1));
case INT8:
return Optional.of(new DecimalType(registers.getRegister(index / 2).getBytes()[1 - (index % 2)]));
case UINT8:
return Optional.of(new DecimalType(
(registers.getRegister(index / 2).toUnsignedShort() >> (8 * (index % 2))) & 0xff));
case INT16: {
ByteBuffer buff = ByteBuffer.allocate(2);
buff.put(registers.getRegister(index).getBytes());
return Optional.of(new DecimalType(buff.order(ByteOrder.BIG_ENDIAN).getShort(0)));
return Optional.of(new DecimalType(extractBit(bytes, index)));
case INT8: {
int registerIndex = index / 2;
boolean hiByte = index % 2 == 1;
return Optional.of(new DecimalType(extractSInt8(bytes, registerIndex, hiByte)));
}
case UINT8: {
int registerIndex = index / 2;
boolean hiByte = index % 2 == 1;
return Optional.of(new DecimalType(extractUInt8(bytes, registerIndex, hiByte)));
}
case INT16:
return Optional.of(new DecimalType(extractSInt16(bytes, index * 2)));
case UINT16:
return Optional.of(new DecimalType(registers.getRegister(index).toUnsignedShort()));
case INT32: {
ByteBuffer buff = ByteBuffer.allocate(4);
buff.put(registers.getRegister(index).getBytes());
buff.put(registers.getRegister(index + 1).getBytes());
return Optional.of(new DecimalType(buff.order(ByteOrder.BIG_ENDIAN).getInt(0)));
}
case UINT32: {
ByteBuffer buff = ByteBuffer.allocate(8);
buff.position(4);
buff.put(registers.getRegister(index).getBytes());
buff.put(registers.getRegister(index + 1).getBytes());
return Optional.of(new DecimalType(buff.order(ByteOrder.BIG_ENDIAN).getLong(0)));
}
case FLOAT32: {
ByteBuffer buff = ByteBuffer.allocate(4);
buff.put(registers.getRegister(index).getBytes());
buff.put(registers.getRegister(index + 1).getBytes());
return Optional.of(new DecimalType(extractUInt16(bytes, index * 2)));
case INT32:
return Optional.of(new DecimalType(extractSInt32(bytes, index * 2)));
case UINT32:
return Optional.of(new DecimalType(extractUInt32(bytes, index * 2)));
case FLOAT32:
try {
return Optional.of(new DecimalType(buff.order(ByteOrder.BIG_ENDIAN).getFloat(0)));
return Optional.of(new DecimalType(extractFloat32(bytes, index * 2)));
} catch (NumberFormatException e) {
// floating point NaN or infinity encountered
return Optional.empty();
}
}
case INT64: {
ByteBuffer buff = ByteBuffer.allocate(8);
buff.put(registers.getRegister(index).getBytes());
buff.put(registers.getRegister(index + 1).getBytes());
buff.put(registers.getRegister(index + 2).getBytes());
buff.put(registers.getRegister(index + 3).getBytes());
return Optional.of(new DecimalType(buff.order(ByteOrder.BIG_ENDIAN).getLong(0)));
}
case UINT64: {
ByteBuffer buff = ByteBuffer.allocate(8);
buff.put(registers.getRegister(index).getBytes());
buff.put(registers.getRegister(index + 1).getBytes());
buff.put(registers.getRegister(index + 2).getBytes());
buff.put(registers.getRegister(index + 3).getBytes());
return Optional.of(
new DecimalType(new BigDecimal(new BigInteger(1, buff.order(ByteOrder.BIG_ENDIAN).array()))));
}
case INT32_SWAP: {
ByteBuffer buff = ByteBuffer.allocate(4);
buff.put(registers.getRegister(index + 1).getBytes());
buff.put(registers.getRegister(index).getBytes());
return Optional.of(new DecimalType(buff.order(ByteOrder.BIG_ENDIAN).getInt(0)));
}
case UINT32_SWAP: {
ByteBuffer buff = ByteBuffer.allocate(8);
buff.position(4);
buff.put(registers.getRegister(index + 1).getBytes());
buff.put(registers.getRegister(index).getBytes());
return Optional.of(new DecimalType(buff.order(ByteOrder.BIG_ENDIAN).getLong(0)));
}
case FLOAT32_SWAP: {
ByteBuffer buff = ByteBuffer.allocate(4);
buff.put(registers.getRegister(index + 1).getBytes());
buff.put(registers.getRegister(index).getBytes());
case INT64:
return Optional.of(new DecimalType(extractSInt64(bytes, index * 2)));
case UINT64:
return Optional.of(new DecimalType(new BigDecimal(extractUInt64(bytes, index * 2))));
case INT32_SWAP:
return Optional.of(new DecimalType(extractSInt32Swap(bytes, index * 2)));
case UINT32_SWAP:
return Optional.of(new DecimalType(extractUInt32Swap(bytes, index * 2)));
case FLOAT32_SWAP:
try {
return Optional.of(new DecimalType(buff.order(ByteOrder.BIG_ENDIAN).getFloat(0)));
return Optional.of(new DecimalType(extractFloat32Swap(bytes, index * 2)));
} catch (NumberFormatException e) {
// floating point NaN or infinity encountered
return Optional.empty();
}
}
case INT64_SWAP: {
ByteBuffer buff = ByteBuffer.allocate(8);
buff.put(registers.getRegister(index + 3).getBytes());
buff.put(registers.getRegister(index + 2).getBytes());
buff.put(registers.getRegister(index + 1).getBytes());
buff.put(registers.getRegister(index).getBytes());
return Optional.of(new DecimalType(buff.order(ByteOrder.BIG_ENDIAN).getLong(0)));
}
case UINT64_SWAP: {
ByteBuffer buff = ByteBuffer.allocate(8);
buff.put(registers.getRegister(index + 3).getBytes());
buff.put(registers.getRegister(index + 2).getBytes());
buff.put(registers.getRegister(index + 1).getBytes());
buff.put(registers.getRegister(index).getBytes());
return Optional.of(
new DecimalType(new BigDecimal(new BigInteger(1, buff.order(ByteOrder.BIG_ENDIAN).array()))));
}
case INT64_SWAP:
return Optional.of(new DecimalType(extractSInt64Swap(bytes, index * 2)));
case UINT64_SWAP:
return Optional.of(new DecimalType(new BigDecimal(extractUInt64Swap(bytes, index * 2))));
default:
throw new IllegalArgumentException(type.getConfigValue());
}
}
private static void assertIndexAndType(byte[] bytes, int index, ValueType type) {
int typeBits = type.getBits();
// for 8-bit types and larger, index specifies the index of the byte. For bits, index specifies the index of the
// bit (of the whole data)
int indexPositionAsBitIndex = Math.min(type.getBits(), 8) * index;
int endBitIndex = indexPositionAsBitIndex + typeBits - 1;
int lastValidIndex = bytes.length * 8 - 1;
if (endBitIndex > lastValidIndex || index < 0) {
throw new IllegalArgumentException(
String.format("Index=%d with type=%s is out-of-bounds given registers of size %d ", index, type,
bytes.length / 2));
}
}
/**
* Read data from registers and convert the result to StringType
* Extract single bit from registers represented by sequence of bytes
*
* - indices between 0...15 (inclusive) represent bits of the first register
* - indices between 16...31 (inclusive) represent bits of the second register, etc.
* - index 0 refers to the least significant bit of the first register
* - index 1 refers to the second least significant bit of the first register, etc.
*
* @param bytes registers represented by sequence of bytes
* @param index index of bit
* @return 0 when bit is set, 1 otherwise
* @throws IllegalArgumentException when index is out of bounds
*/
public static int extractBit(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.BIT);
int registerIndex = index / 16;
int bitIndexWithinRegister = index % 16;
return extractBit(bytes, registerIndex, bitIndexWithinRegister);
}
/**
* Extract single bit from registers represented by sequence of bytes
*
* bitIndexWithinRegister between 0...15 (inclusive) represent bits of the first register, where 0 refers to the
* least significant bit of the register, index 1 refers to the second least significant bit of the register, etc.
*
* @param bytes registers represented by sequence of bytes
* @param registerIndex index of register. First register has index of 0.
* @param bitIndexWithinRegister bit index within the register
* @return 0 when bit is set, 1 otherwise
* @throws IllegalArgumentException when registerIndex and/or bitIndexWithinRegister is out of bounds
*/
public static int extractBit(byte[] bytes, int registerIndex, int bitIndexWithinRegister) {
if (bitIndexWithinRegister < 0 || bitIndexWithinRegister > 15) {
throw new IllegalArgumentException(
String.format("bitIndexWithinRegister=%d is out-of-bounds (max 15)", bitIndexWithinRegister));
} else if (registerIndex < 0) {
throw new IllegalArgumentException(
String.format("registerIndex=%d is out-of-bounds", bitIndexWithinRegister));
}
boolean hiByte = bitIndexWithinRegister >= 8;
int indexWithinByte = bitIndexWithinRegister % 8;
int byteIndex = 2 * registerIndex + (hiByte ? 0 : 1);
if (byteIndex >= bytes.length) {
throw new IllegalArgumentException(String.format(
"registerIndex=%d, bitIndexWithinRegister=%d is out-of-bounds with registers of size %d",
registerIndex, bitIndexWithinRegister, bytes.length / 2));
}
return ((bytes[byteIndex] >>> indexWithinByte) & 1);
}
/**
* Extract signed 8-bit integer (byte) from registers represented by sequence of bytes
*
* @param bytes registers represented by sequence of bytes
* @param registerIndex index of register. First register has index of 0.
* @param hiByte whether to extract hi byte or lo byte
* @return 0 when bit is set, 1 otherwise
* @throws IllegalArgumentException when index is out of bounds
*/
public static byte extractSInt8(byte[] bytes, int registerIndex, boolean hiByte) {
int byteIndex = 2 * registerIndex + (hiByte ? 0 : 1);
byte signed = extractSInt8(bytes, byteIndex);
return signed;
}
/**
* Extract signed 8-bit integer (byte) from registers represented by sequence of bytes
*
* - index 0 refers to low byte of the first register, 1 high byte of first register
* - index 2 refers to low byte of the second register, 3 high byte of second register, etc.
* - it is assumed that each high and low byte is encoded in most significant bit first order
*
* @param bytes registers represented by sequence of bytes
* @param registerIndex index of register. First register has index of 0.
* @param index index of the byte in registers
* @return 0 when bit is set, 1 otherwise
* @throws IllegalArgumentException when index is out of bounds
*/
public static byte extractSInt8(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.INT8);
byte signed = bytes[index];
return signed;
}
/**
* Extract unsigned 8-bit integer (byte) from registers represented by sequence of bytes
*
* @param bytes registers represented by sequence of bytes
* @param registerIndex index of register. First register has index of 0.
* @param hiByte whether to extract hi byte or lo byte
* @return 0 when bit is set, 1 otherwise
* @throws IllegalArgumentException when registerIndex is out of bounds
*/
public static short extractUInt8(byte[] bytes, int registerIndex, boolean hiByte) {
int byteIndex = 2 * registerIndex + (hiByte ? 0 : 1);
short unsigned = extractUInt8(bytes, byteIndex);
return unsigned;
}
/**
* Extract unsigned 8-bit integer (byte) from registers represented by sequence of bytes
*
* - index 0 refers to low byte of the first register, 1 high byte of first register
* - index 2 refers to low byte of the second register, 3 high byte of second register, etc.
* - it is assumed that each high and low byte is encoded in most significant bit first order
*
* @param bytes registers represented by sequence of bytes
* @param registerIndex index of register. First register has index of 0.
* @param index index of the byte in registers
* @return 0 when bit is set, 1 otherwise
* @throws IllegalArgumentException when index is out of bounds
*/
public static short extractUInt8(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.UINT8);
int signed = extractSInt8(bytes, index);
short unsigned = (short) (signed & 0xff);
assert unsigned >= 0;
return unsigned;
}
/**
* Extract signed 16-bit integer (short) from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order
*
* @param bytes registers represented by sequence of bytes
* @param index index of register. First register has index of 0.
* @return register with index interpreted as 16 bit signed integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static short extractSInt16(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.INT16);
int hi = (bytes[index] & 0xff);
int lo = (bytes[index + 1] & 0xff);
short signed = (short) ((hi << 8) | lo);
return signed;
}
/**
* Extract unsigned 16-bit integer from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order
*
* @param bytes registers represented by sequence of bytes
* @param index index of register. First register has index of 0.
* @return register with index interpreted as 16 bit unsigned integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static int extractUInt16(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.UINT16);
int signed = extractSInt16(bytes, index);
int unsigned = signed & 0xffff;
assert unsigned >= 0;
return unsigned;
}
/**
* Extract signed 32-bit integer from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index) and (index+1) interpreted as 32 bit signed integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static int extractSInt32(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.INT32);
int hi1 = bytes[index + 0] & 0xff;
int lo1 = bytes[index + 1] & 0xff;
int hi2 = bytes[index + 2] & 0xff;
int lo2 = bytes[index + 3] & 0xff;
int signed = (hi1 << 24) | (lo1 << 16) | (hi2 << 8) | lo2;
return signed;
}
/**
* Extract unsigned 32-bit integer from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index) and (index+1) interpreted as 32 bit unsigned integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static long extractUInt32(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.UINT32);
long signed = extractSInt32(bytes, index);
long unsigned = signed & 0xffff_ffffL;
assert unsigned >= 0;
return unsigned;
}
/**
* Extract signed 32-bit integer from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order.
*
* This is identical with extractSInt32, but with registers swapped.
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index+1), (index) interpreted as 32 bit signed integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static int extractSInt32Swap(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.INT32_SWAP);
// swapped order of registers, high 16 bits *follow* low 16 bits
int hi1 = bytes[index + 2] & 0xff;
int lo1 = bytes[index + 3] & 0xff;
int hi2 = bytes[index + 0] & 0xff;
int lo2 = bytes[index + 1] & 0xff;
int signed = (hi1 << 24) | (lo1 << 16) | (hi2 << 8) | lo2;
return signed;
}
/**
* Extract unsigned 32-bit integer from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order.
*
* This is identical with extractUInt32, but with registers swapped.
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index+1), (index) interpreted as 32 bit unsigned integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static long extractUInt32Swap(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.UINT32_SWAP);
long signed = extractSInt32Swap(bytes, index);
long unsigned = signed & 0xffff_ffffL;
assert unsigned >= 0;
return unsigned;
}
/**
* Extract signed 64-bit integer from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order.
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index), (index+1), (index+2), (index+3) interpreted as 64 bit signed integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static long extractSInt64(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.INT64);
byte hi1 = (byte) (bytes[index + 0] & 0xff);
byte lo1 = (byte) (bytes[index + 1] & 0xff);
byte hi2 = (byte) (bytes[index + 2] & 0xff);
byte lo2 = (byte) (bytes[index + 3] & 0xff);
byte hi3 = (byte) (bytes[index + 4] & 0xff);
byte lo3 = (byte) (bytes[index + 5] & 0xff);
byte hi4 = (byte) (bytes[index + 6] & 0xff);
byte lo4 = (byte) (bytes[index + 7] & 0xff);
return new BigInteger(new byte[] { hi1, lo1, hi2, lo2, hi3, lo3, hi4, lo4 }).longValue();
}
/**
* Extract unsigned 64-bit integer from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order.
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index), (index+1), (index+2), (index+3) interpreted as 64 bit unsigned integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static BigInteger extractUInt64(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.UINT64);
byte hi1 = (byte) (bytes[index + 0] & 0xff);
byte lo1 = (byte) (bytes[index + 1] & 0xff);
byte hi2 = (byte) (bytes[index + 2] & 0xff);
byte lo2 = (byte) (bytes[index + 3] & 0xff);
byte hi3 = (byte) (bytes[index + 4] & 0xff);
byte lo3 = (byte) (bytes[index + 5] & 0xff);
byte hi4 = (byte) (bytes[index + 6] & 0xff);
byte lo4 = (byte) (bytes[index + 7] & 0xff);
return new BigInteger(1, new byte[] { hi1, lo1, hi2, lo2, hi3, lo3, hi4, lo4 });
}
/**
* Extract signed 64-bit integer from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order.
*
* This is identical with extractInt64, but with registers swapped (registers with higher index before lower index).
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index+3), (index+2), (index+1), (index) interpreted as 64 bit signed integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static long extractSInt64Swap(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.INT64_SWAP);
// Swapped order of registers
byte hi1 = (byte) (bytes[index + 6] & 0xff);
byte lo1 = (byte) (bytes[index + 7] & 0xff);
byte hi2 = (byte) (bytes[index + 4] & 0xff);
byte lo2 = (byte) (bytes[index + 5] & 0xff);
byte hi3 = (byte) (bytes[index + 2] & 0xff);
byte lo3 = (byte) (bytes[index + 3] & 0xff);
byte hi4 = (byte) (bytes[index + 0] & 0xff);
byte lo4 = (byte) (bytes[index + 1] & 0xff);
return new BigInteger(new byte[] { hi1, lo1, hi2, lo2, hi3, lo3, hi4, lo4 }).longValue();
}
/**
* Extract unsigned 64-bit integer from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order.
*
* This is identical with extractUInt64, but with registers swapped (registers with higher index before lower
* index).
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index+3), (index+2), (index+1), (index) interpreted as 64 bit unsigned integer
* @throws IllegalArgumentException when index is out of bounds
*/
public static BigInteger extractUInt64Swap(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.UINT64_SWAP);
// Swapped order of registers
byte hi1 = (byte) (bytes[index + 6] & 0xff);
byte lo1 = (byte) (bytes[index + 7] & 0xff);
byte hi2 = (byte) (bytes[index + 4] & 0xff);
byte lo2 = (byte) (bytes[index + 5] & 0xff);
byte hi3 = (byte) (bytes[index + 2] & 0xff);
byte lo3 = (byte) (bytes[index + 3] & 0xff);
byte hi4 = (byte) (bytes[index + 0] & 0xff);
byte lo4 = (byte) (bytes[index + 1] & 0xff);
return new BigInteger(1, new byte[] { hi1, lo1, hi2, lo2, hi3, lo3, hi4, lo4 });
}
/**
* Extract single-precision 32-bit IEEE 754 floating point from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order.
*
* Note that this method can return floating point NaN and floating point infinity.
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index), (index+1), (index+2), (index+3) interpreted as single-precision 32-bit IEEE 754
* floating point
* @throws IllegalArgumentException when index is out of bounds
*/
public static float extractFloat32(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.FLOAT32);
int hi1 = bytes[index + 0] & 0xff;
int lo1 = bytes[index + 1] & 0xff;
int hi2 = bytes[index + 2] & 0xff;
int lo2 = bytes[index + 3] & 0xff;
int bits32 = (hi1 << 24) | (lo1 << 16) | (hi2 << 8) | lo2;
return Float.intBitsToFloat(bits32);
}
/**
* Extract single-precision 32-bit IEEE 754 floating point from registers represented by sequence of bytes
*
* It is assumed that each register is encoded in most significant bit first order.
*
* This is identical with extractFloat32, but with registers swapped (registers with higher index before lower
* index).
*
* Note that this method can return floating point NaN and floating point infinity.
*
* @param bytes registers represented by sequence of bytes
* @param index index of first register. First register has index of 0.
* @return registers (index+3), (index+2), (index+1), (index) interpreted as single-precision 32-bit IEEE 754
* floating point
* @throws IllegalArgumentException when index is out of bounds
*/
public static float extractFloat32Swap(byte[] bytes, int index) {
assertIndexAndType(bytes, index, ValueType.FLOAT32_SWAP);
// swapped order of registers, high 16 bits *follow* low 16 bits
int hi1 = bytes[index + 2] & 0xff;
int lo1 = bytes[index + 3] & 0xff;
int hi2 = bytes[index + 0] & 0xff;
int lo2 = bytes[index + 1] & 0xff;
int bits32 = (hi1 << 24) | (lo1 << 16) | (hi2 << 8) | lo2;
return Float.intBitsToFloat(bits32);
}
/**
* Read data from registers and convert the result to String
* Strings should start the the first byte of a register, but could
* have an odd number of characters.
* Raw byte array values are converted using the charset parameter
* and a maximum of length bytes are read. However reading stops at the first
* NUL byte encountered.
*
* Registers are read in big-endian order, i.e. two registers consisting 4 bytes (ab, cd) are parsed as sequence of
* bytes (a,b,c,d).
*
* @param registers list of registers, each register represent 16bit of data
* @param index zero based register index. Registers are handled as 16bit registers,
* @param registerIndex zero based register index. Registers are handled as 16bit registers,
* this parameter defines the starting register.
* @param length maximum length of string in 8bit characters.
* @param length maximum length of string in 8bit characters (number of bytes considered)
* @param charset the character set used to construct the string.
* @return string representation queried value
* @throws IllegalArgumentException when <tt>index</tt> is out of bounds of registers
*/
public static StringType extractStringFromRegisters(ModbusRegisterArray registers, int index, int length,
public static String extractStringFromRegisters(ModbusRegisterArray registers, int registerIndex, int length,
Charset charset) {
if (index * 2 + length > registers.size() * 2) {
return extractStringFromBytes(registers.getBytes(), registerIndex * 2, length, charset);
}
/**
* Read data from bytes and convert the result to String
*
* Raw byte array values are converted using the charset parameter
* and a maximum of length bytes are read. However reading stops at the first
* NUL byte encountered.
*
* @param bytes bytes representing the registers
* @param byteIndex zero based byte index
* @param length maximum length of string in 8bit characters (number of bytes considered)
* @param charset the character set used to construct the string.
* @return string representation queried value
* @throws IllegalArgumentException when <tt>index</tt> is out of bounds of registers
*/
public static String extractStringFromBytes(byte[] bytes, int byteIndex, int length, Charset charset) {
if (byteIndex + length > bytes.length) {
throw new IllegalArgumentException(
String.format("Index=%d with length=%d is out-of-bounds given registers of size %d", index, length,
registers.size()));
String.format("byteIndex=%d with length=%d is out-of-bounds given registers of size %d", byteIndex,
length, bytes.length));
}
if (index < 0) {
if (byteIndex < 0) {
throw new IllegalArgumentException("Negative index values are not supported");
}
if (length < 0) {
throw new IllegalArgumentException("Negative string length is not supported");
}
byte[] buff = new byte[length];
int src = index;
int dest;
for (dest = 0; dest < length; dest++) {
int effectiveLength = length;
byte chr;
if (dest % 2 == 0) {
chr = (byte) ((registers.getRegister(src).getValue() >> 8));
} else {
chr = (byte) (registers.getRegister(src).getValue() & 0xff);
src++;
}
if (chr == 0) {
// Find first zero byte in registers and call reduce length such that we stop before it
for (int i = 0; i < length; i++) {
if (bytes[byteIndex + i] == '\0') {
effectiveLength = i;
break;
}
buff[dest] = chr;
}
return new StringType(new String(buff, 0, dest, charset));
return new String(bytes, byteIndex, effectiveLength, charset);
}
/**
@ -292,89 +647,80 @@ public class ModbusBitUtilities {
case UINT16: {
short shortValue = numericCommand.shortValue();
// big endian byte ordering
byte b1 = (byte) (shortValue >> 8);
byte b2 = (byte) shortValue;
ModbusRegister register = new ModbusRegister(b1, b2);
return new ModbusRegisterArray(new ModbusRegister[] { register });
byte hi = (byte) (shortValue >> 8);
byte lo = (byte) shortValue;
return new ModbusRegisterArray(new byte[] { hi, lo });
}
case INT32:
case UINT32: {
int intValue = numericCommand.intValue();
// big endian byte ordering
byte b1 = (byte) (intValue >> 24);
byte b2 = (byte) (intValue >> 16);
byte b3 = (byte) (intValue >> 8);
byte b4 = (byte) intValue;
ModbusRegister register = new ModbusRegister(b1, b2);
ModbusRegister register2 = new ModbusRegister(b3, b4);
return new ModbusRegisterArray(new ModbusRegister[] { register, register2 });
byte hi1 = (byte) (intValue >> 24);
byte lo1 = (byte) (intValue >> 16);
byte hi2 = (byte) (intValue >> 8);
byte lo2 = (byte) intValue;
return new ModbusRegisterArray(new byte[] { hi1, lo1, hi2, lo2 });
}
case INT32_SWAP:
case UINT32_SWAP: {
int intValue = numericCommand.intValue();
// big endian byte ordering
byte b1 = (byte) (intValue >> 24);
byte b2 = (byte) (intValue >> 16);
byte b3 = (byte) (intValue >> 8);
byte b4 = (byte) intValue;
ModbusRegister register = new ModbusRegister(b3, b4);
ModbusRegister register2 = new ModbusRegister(b1, b2);
return new ModbusRegisterArray(new ModbusRegister[] { register, register2 });
byte hi1 = (byte) (intValue >> 24);
byte lo1 = (byte) (intValue >> 16);
byte hi2 = (byte) (intValue >> 8);
byte lo2 = (byte) intValue;
// Swapped order of registers
return new ModbusRegisterArray(new byte[] { hi2, lo2, hi1, lo1 });
}
case FLOAT32: {
float floatValue = numericCommand.floatValue();
int intBits = Float.floatToIntBits(floatValue);
// big endian byte ordering
byte b1 = (byte) (intBits >> 24);
byte b2 = (byte) (intBits >> 16);
byte b3 = (byte) (intBits >> 8);
byte b4 = (byte) intBits;
ModbusRegister register = new ModbusRegister(b1, b2);
ModbusRegister register2 = new ModbusRegister(b3, b4);
return new ModbusRegisterArray(new ModbusRegister[] { register, register2 });
byte hi1 = (byte) (intBits >> 24);
byte lo1 = (byte) (intBits >> 16);
byte hi2 = (byte) (intBits >> 8);
byte lo2 = (byte) intBits;
return new ModbusRegisterArray(new byte[] { hi1, lo1, hi2, lo2 });
}
case FLOAT32_SWAP: {
float floatValue = numericCommand.floatValue();
int intBits = Float.floatToIntBits(floatValue);
// big endian byte ordering
byte b1 = (byte) (intBits >> 24);
byte b2 = (byte) (intBits >> 16);
byte b3 = (byte) (intBits >> 8);
byte b4 = (byte) intBits;
ModbusRegister register = new ModbusRegister(b3, b4);
ModbusRegister register2 = new ModbusRegister(b1, b2);
return new ModbusRegisterArray(new ModbusRegister[] { register, register2 });
byte hi1 = (byte) (intBits >> 24);
byte lo1 = (byte) (intBits >> 16);
byte hi2 = (byte) (intBits >> 8);
byte lo2 = (byte) intBits;
// Swapped order of registers
return new ModbusRegisterArray(new byte[] { hi2, lo2, hi1, lo1 });
}
case INT64:
case UINT64: {
long longValue = numericCommand.longValue();
// big endian byte ordering
byte b1 = (byte) (longValue >> 56);
byte b2 = (byte) (longValue >> 48);
byte b3 = (byte) (longValue >> 40);
byte b4 = (byte) (longValue >> 32);
byte b5 = (byte) (longValue >> 24);
byte b6 = (byte) (longValue >> 16);
byte b7 = (byte) (longValue >> 8);
byte b8 = (byte) longValue;
return new ModbusRegisterArray(new ModbusRegister[] { new ModbusRegister(b1, b2),
new ModbusRegister(b3, b4), new ModbusRegister(b5, b6), new ModbusRegister(b7, b8) });
byte hi1 = (byte) (longValue >> 56);
byte lo1 = (byte) (longValue >> 48);
byte hi2 = (byte) (longValue >> 40);
byte lo2 = (byte) (longValue >> 32);
byte hi3 = (byte) (longValue >> 24);
byte lo3 = (byte) (longValue >> 16);
byte hi4 = (byte) (longValue >> 8);
byte lo4 = (byte) longValue;
return new ModbusRegisterArray(new byte[] { hi1, lo1, hi2, lo2, hi3, lo3, hi4, lo4 });
}
case INT64_SWAP:
case UINT64_SWAP: {
long longValue = numericCommand.longValue();
// big endian byte ordering
byte b1 = (byte) (longValue >> 56);
byte b2 = (byte) (longValue >> 48);
byte b3 = (byte) (longValue >> 40);
byte b4 = (byte) (longValue >> 32);
byte b5 = (byte) (longValue >> 24);
byte b6 = (byte) (longValue >> 16);
byte b7 = (byte) (longValue >> 8);
byte b8 = (byte) longValue;
return new ModbusRegisterArray(new ModbusRegister[] { new ModbusRegister(b7, b8),
new ModbusRegister(b5, b6), new ModbusRegister(b3, b4), new ModbusRegister(b1, b2) });
byte hi1 = (byte) (longValue >> 56);
byte lo1 = (byte) (longValue >> 48);
byte hi2 = (byte) (longValue >> 40);
byte lo2 = (byte) (longValue >> 32);
byte hi3 = (byte) (longValue >> 24);
byte lo3 = (byte) (longValue >> 16);
byte hi4 = (byte) (longValue >> 8);
byte lo4 = (byte) longValue;
// Swapped order of registers
return new ModbusRegisterArray(new byte[] { hi4, lo4, hi3, lo3, hi2, lo2, hi1, lo1 });
}
default:
throw new NotImplementedException(

113
bundles/org.openhab.io.transport.modbus/src/main/java/org/openhab/io/transport/modbus/ModbusRegister.java
View File

@ -1,113 +0,0 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.io.transport.modbus;
import org.eclipse.jdt.annotation.NonNullByDefault;
import net.wimpi.modbus.procimg.SimpleInputRegister;
/**
* Basic {@link ModbusRegister} implementation
*
* @author Sami Salonen - Initial contribution
*/
@NonNullByDefault
public class ModbusRegister {
private final SimpleInputRegister wrapped;
/**
* Constructs a new instance for bytes
*
* @param b1 the first (hi) byte of the word.
* @param b2 the second (low) byte of the word.
*/
public ModbusRegister(byte b1, byte b2) {
wrapped = new SimpleInputRegister(b1, b2);
}
/**
* Construct register for at
*
* @param val value representing register data. The <code>int</code> will be downcasted to <code>short</code>.
*/
public ModbusRegister(int val) {
wrapped = new SimpleInputRegister(val);
}
/**
* Get raw data represented by this register. Since register is 16 bits, array of length 2 will be returned.
*
* @return byte array of length 2, high byte first.
*/
public byte[] getBytes() {
return wrapped.toBytes();
}
/**
* Returns the value of this register as integer representing 16 bit data parsed as signed integer.
*
* @return the register content as unsigned integer
*/
public int getValue() {
return wrapped.getValue();
}
/**
* Returns the value of this register as integer representing 16 bit data parsed as unsigned integer.
*
* @return the register content as unsigned integer
*/
public int toUnsignedShort() {
return wrapped.toUnsignedShort();
}
@Override
public String toString() {
StringBuffer buffer = new StringBuffer("ModbusRegisterImpl(");
buffer.append("uint16=").append(toUnsignedShort()).append(", hex=");
return appendHexString(buffer).append(')').toString();
}
/**
* Returns the register value as hex string
*
* For example, 12 34
*
* @return string representing the register data
*/
public String toHexString() {
StringBuffer buffer = new StringBuffer(5);
return appendHexString(buffer).toString();
}
/**
* Appends the register value as hex string to the given StringBuffer
*
*/
public StringBuffer appendHexString(StringBuffer buffer) {
byte[] bytes = getBytes();
for (int i = 0; i < 2; i++) {
byte b = bytes[i];
String byteHex = Long.toHexString(b & 0xff);
if ((b & 0xff) < 0x10) {
buffer.append('0');
}
buffer.append(byteHex);
if (i == 0) {
buffer.append(' ');
}
}
return buffer;
}
}

110
bundles/org.openhab.io.transport.modbus/src/main/java/org/openhab/io/transport/modbus/ModbusRegisterArray.java
View File

@ -12,10 +12,10 @@
*/
package org.openhab.io.transport.modbus;
import java.util.Iterator;
import java.util.stream.IntStream;
import java.util.Arrays;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.core.util.HexUtils;
/**
* Immutable {@link ModbusRegisterArray} implementation
@ -23,54 +23,60 @@ import org.eclipse.jdt.annotation.NonNullByDefault;
* @author Sami Salonen - Initial contribution
*/
@NonNullByDefault
public class ModbusRegisterArray implements Iterable<ModbusRegister> {
public class ModbusRegisterArray {
private final ModbusRegister[] registers;
private final byte[] bytes;
/**
* Construct plain <code>ModbusRegister[]</code> array from register values
*
* @param registerValues register values, each <code>int</code> corresponding to one register
* @return
*/
public static ModbusRegister[] registersFromValues(int... registerValues) {
ModbusRegister[] registers = new ModbusRegister[registerValues.length];
for (int i = 0; i < registerValues.length; i++) {
registers[i] = new ModbusRegister(registerValues[i]);
public ModbusRegisterArray(byte... bytes) {
if (bytes.length % 2 != 0) {
throw new IllegalArgumentException();
}
return registers;
this.bytes = Arrays.copyOf(bytes, bytes.length);
}
/**
* Construct ModbusRegisterArrayImpl from array of {@link ModbusRegister}
*
* @param registers
*/
public ModbusRegisterArray(ModbusRegister[] registers) {
this.registers = registers;
}
/**
* Construct plain <code>ModbusRegisterArrayImpl</code> array from register values
* Construct plain <code>ModbusRegisterArray</code> array from register values
*
* @param registerValues register values, each <code>int</code> corresponding to one register
* @return
*/
public ModbusRegisterArray(int... registerValues) {
this(registersFromValues(registerValues));
bytes = new byte[registerValues.length * 2];
for (int registerIndex = 0; registerIndex < registerValues.length; registerIndex++) {
int register = registerValues[registerIndex] & 0xffff;
// hi-byte
bytes[registerIndex * 2] = (byte) (register >> 8);
// lo byte
bytes[registerIndex * 2 + 1] = (byte) register;
}
}
/**
* Return register at the given index
* Get register index i as unsigned integer
*
* Index 0 matches first register (lowest register index).
* <p>
*
* @param index the index of the register to be returned.
* @throws IndexOutOfBoundsException if the index is out of bounds.
* @param i register index
* @return register value interpreted as unsigned integer (big-endian byte ordering)
*/
public ModbusRegister getRegister(int index) {
return registers[index];
public int getRegister(int i) {
int hi = bytes[i * 2] & 0xff;
int lo = bytes[i * 2 + 1] & 0xff;
return ((hi << 8) | lo) & 0xffff;
}
/**
* Return bytes representing the registers
*
*
* Index 0: hi-byte of 1st register
* Index 1: low-byte of 1st register
* Index 3: hi-byte of 2nd register
* Index 4: low-byte of 2nd register
* ...
*
* @return set of bytes
*/
public byte[] getBytes() {
return bytes;
}
/**
@ -79,24 +85,16 @@ public class ModbusRegisterArray implements Iterable<ModbusRegister> {
* @return
*/
public int size() {
return registers.length;
return bytes.length / 2;
}
@Override
public String toString() {
if (registers.length == 0) {
return "ModbusRegisterArrayImpl(<empty>)";
if (bytes.length == 0) {
return "ModbusRegisterArray(<empty>)";
}
StringBuffer buffer = new StringBuffer(registers.length * 2).append("ModbusRegisterArrayImpl(");
return appendHexString(buffer).append(')').toString();
}
/**
* Iterator over all the registers
*/
@Override
public Iterator<ModbusRegister> iterator() {
return IntStream.range(0, size()).mapToObj(i -> getRegister(i)).iterator();
return new StringBuilder(bytes.length).append("ModbusRegisterArray(").append(toHexString()).append(')')
.toString();
}
/**
@ -110,22 +108,6 @@ public class ModbusRegisterArray implements Iterable<ModbusRegister> {
if (size() == 0) {
return "";
}
// Initialize capacity to (n*2 + n-1), two chars per byte + spaces in between
StringBuffer buffer = new StringBuffer(size() * 2 + (size() - 1));
return appendHexString(buffer).toString();
}
/**
* Appends the register data as hex string to the given StringBuffer
*
*/
public StringBuffer appendHexString(StringBuffer buffer) {
IntStream.range(0, size()).forEachOrdered(index -> {
getRegister(index).appendHexString(buffer);
if (index < size() - 1) {
buffer.append(' ');
}
});
return buffer;
return HexUtils.bytesToHex(getBytes());
}
}

331
bundles/org.openhab.io.transport.modbus/src/main/java/org/openhab/io/transport/modbus/ValueBuffer.java Normal file
View File

@ -0,0 +1,331 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.io.transport.modbus;
import java.math.BigInteger;
import java.nio.BufferOverflowException;
import java.nio.InvalidMarkException;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
/**
* ByteBuffer-like interface for working with different types of data stored in byte arrays
*
* @author Sami Salonen - Initial contribution
*/
@NonNullByDefault
public class ValueBuffer {
private final byte[] bytes;
private final AtomicInteger byteIndex = new AtomicInteger();
private volatile AtomicReference<@Nullable AtomicInteger> mark = new AtomicReference<>();
/**
* Wrap modbus registers and create a new instance of ValueBuffer
*
* The instance will have position of 0.
*
* @param array set of registers
* @return new instance of ValueBuffer referencing bytes represented by modbus register array
*/
public static ValueBuffer wrap(ModbusRegisterArray array) {
return new ValueBuffer(array.getBytes());
}
/**
* Wrap given bytes and create a new instance of ValueBuffer
*
* The instance will have position of 0.
*
*
* @param array set of bytes to wrap
* @return new instance of ValueBuffer referencing bytes
*/
public static ValueBuffer wrap(byte[] array) {
return new ValueBuffer(array);
}
private ValueBuffer(byte[] bytes) {
this.bytes = bytes;
}
/**
* Returns this buffer's position.
*
* @return The position of this buffer
*/
public int position() {
return byteIndex.get();
}
/**
* Sets this buffer's position. If the mark is defined and larger than the new position then it is discarded.
*
* @return this buffer
*/
public ValueBuffer position(int byteIndex) {
this.mark.getAndUpdate(curMark -> {
if (curMark == null) {
return null;
} else if (curMark.get() > byteIndex) {
return null;
} else {
return curMark;
}
});
this.byteIndex.set(byteIndex);
return this;
}
/**
* Sets this buffer's mark at its position.
*
* @return this buffer
*/
public ValueBuffer mark() {
mark = new AtomicReference<>(new AtomicInteger(byteIndex.get()));
return this;
}
/**
* Resets this buffer's position to the previously-marked position.
* Invoking this method neither changes nor discards the mark's value.
*
* @return this buffer
* @throws InvalidMarkException If the mark has not been set
*/
public ValueBuffer reset() throws InvalidMarkException {
int mark = Optional.ofNullable(this.mark.get()).map(i -> i.get()).orElse(-1);
if (mark < 0) {
throw new InvalidMarkException();
}
byteIndex.set(mark);
return this;
}
/**
* Returns the number of bytes between the current position and the end.
*
* @return The number of bytes remaining in this buffer
*/
public int remaining() {
return bytes.length - byteIndex.get();
}
/**
* Returns underlying bytes
*
* @return reference to underlying bytes
*/
public byte[] array() {
return bytes;
}
/**
* Tells whether there are any bytes left between current position and the end
*
* @return true if, and only if, there is at least one byte remaining in this buffer
*/
public boolean hasRemaining() {
return remaining() > 0;
}
/**
* Starting from current position, read dst.length number of bytes and copy the data to dst
*
* @param dst copied bytes
* @return this buffer
* @throws BufferOverflowException If there is insufficient space in this buffer for the remaining bytes in the
* source buffer
*/
public ValueBuffer get(byte[] dst) {
int start = byteIndex.getAndAdd(dst.length);
try {
System.arraycopy(bytes, start, dst, 0, dst.length);
} catch (IndexOutOfBoundsException e) {
throw new BufferOverflowException();
}
return this;
}
/**
* Extract signed 8-bit integer at current position, and advance position.
*
* @return signed 8-bit integer (byte)
* @see ModbusBitUtilities.extractSInt8
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public byte getSInt8() {
return ModbusBitUtilities.extractSInt8(bytes, byteIndex.getAndAdd(1));
}
/**
* Extract unsigned 8-bit integer at current position, and advance position.
*
* @return unsigned 8-bit integer
* @see ModbusBitUtilities.extractUInt8
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public short getUInt8() {
return ModbusBitUtilities.extractUInt8(bytes, byteIndex.getAndAdd(1));
}
/**
* Extract signed 16-bit integer at current position, and advance position.
*
* @return signed 16-bit integer (short)
* @see ModbusBitUtilities.extractSInt16
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public short getSInt16() {
return ModbusBitUtilities.extractSInt16(bytes, byteIndex.getAndAdd(2));
}
/**
* Extract unsigned 16-bit integer at current position, and advance position.
*
* @return unsigned 16-bit integer
* @see ModbusBitUtilities.extractUInt16
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public int getUInt16() {
return ModbusBitUtilities.extractUInt16(bytes, byteIndex.getAndAdd(2));
}
/**
* Extract signed 32-bit integer at current position, and advance position.
*
* @return signed 32-bit integer
* @see ModbusBitUtilities.extractSInt32
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public int getSInt32() {
return ModbusBitUtilities.extractSInt32(bytes, byteIndex.getAndAdd(4));
}
/**
* Extract unsigned 32-bit integer at current position, and advance position.
*
* @return unsigned 32-bit integer
* @see ModbusBitUtilities.extractUInt32
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public long getUInt32() {
return ModbusBitUtilities.extractUInt32(bytes, byteIndex.getAndAdd(4));
}
/**
* Extract signed 32-bit integer at current position, and advance position.
*
* This is identical with getSInt32, but with registers swapped.
*
* @return signed 32-bit integer
* @see ModbusBitUtilities.extractSInt32Swap
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public int getSInt32Swap() {
return ModbusBitUtilities.extractSInt32Swap(bytes, byteIndex.getAndAdd(4));
}
/**
* Extract unsigned 32-bit integer at current position, and advance position.
*
* This is identical with getUInt32, but with registers swapped.
*
* @return unsigned 32-bit integer
* @see ModbusBitUtilities.extractUInt32Swap
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public long getUInt32Swap() {
return ModbusBitUtilities.extractUInt32Swap(bytes, byteIndex.getAndAdd(4));
}
/**
* Extract signed 64-bit integer at current position, and advance position.
*
* @return signed 64-bit integer
* @see ModbusBitUtilities.extractInt64
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public long getSInt64() {
return ModbusBitUtilities.extractSInt64(bytes, byteIndex.getAndAdd(8));
}
/**
* Extract unsigned 64-bit integer at current position, and advance position.
*
* @return unsigned 64-bit integer
* @see ModbusBitUtilities.extractUInt64
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public BigInteger getUInt64() {
return ModbusBitUtilities.extractUInt64(bytes, byteIndex.getAndAdd(8));
}
/**
* Extract signed 64-bit integer at current position, and advance position.
*
* This is identical with getSInt64, but with registers swapped.
*
* @return signed 64-bit integer
* @see ModbusBitUtilities.extractInt64Swap
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public long getSInt64Swap() {
return ModbusBitUtilities.extractSInt64Swap(bytes, byteIndex.getAndAdd(8));
}
/**
* Extract unsigned 64-bit integer at current position, and advance position.
*
* This is identical with getUInt64, but with registers swapped.
*
* @return unsigned 64-bit integer
* @see ModbusBitUtilities.extractUInt64Swap
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public BigInteger getUInt64Swap() {
return ModbusBitUtilities.extractUInt64Swap(bytes, byteIndex.getAndAdd(8));
}
/**
* Extract single-precision 32-bit IEEE 754 floating point at current position, and advance position.
*
* Note that this method can return floating point NaN and floating point infinity.
*
* @return single-precision 32-bit IEEE 754 floating point
* @see ModbusBitUtilities.extractFloat32
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public float getFloat32() {
return ModbusBitUtilities.extractFloat32(bytes, byteIndex.getAndAdd(4));
}
/**
* Extract single-precision 32-bit IEEE 754 floating point at current position, and advance position.
*
* This is identical with getFloat32, but with registers swapped.
*
* Note that this method can return floating point NaN and floating point infinity.
*
* @return single-precision 32-bit IEEE 754 floating point
* @see ModbusBitUtilities.extractFloat32
* @throws IllegalArgumentException when there are not enough bytes in this ValueBuffer
*/
public float getFloat32Swap() {
return ModbusBitUtilities.extractFloat32Swap(bytes, byteIndex.getAndAdd(4));
}
}

7
bundles/org.openhab.io.transport.modbus/src/main/java/org/openhab/io/transport/modbus/internal/ModbusLibraryWrapper.java
View File

@ -24,7 +24,6 @@ import org.openhab.io.transport.modbus.BitArray;
import org.openhab.io.transport.modbus.ModbusReadCallback;
import org.openhab.io.transport.modbus.ModbusReadFunctionCode;
import org.openhab.io.transport.modbus.ModbusReadRequestBlueprint;
import org.openhab.io.transport.modbus.ModbusRegister;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
import org.openhab.io.transport.modbus.ModbusWriteCoilRequestBlueprint;
import org.openhab.io.transport.modbus.ModbusWriteRegisterRequestBlueprint;
@ -87,9 +86,9 @@ public class ModbusLibraryWrapper {
}
private static ModbusRegisterArray modbusRegisterArrayFromInputRegisters(InputRegister[] inputRegisters) {
ModbusRegister[] registers = new ModbusRegister[inputRegisters.length];
int[] registers = new int[inputRegisters.length];
for (int i = 0; i < inputRegisters.length; i++) {
registers[i] = new ModbusRegister(inputRegisters[i].getValue());
registers[i] = inputRegisters[i].getValue();
}
return new ModbusRegisterArray(registers);
}
@ -270,7 +269,7 @@ public class ModbusLibraryWrapper {
* @return
*/
public static Register[] convertRegisters(ModbusRegisterArray arr) {
return IntStream.range(0, arr.size()).mapToObj(i -> new SimpleInputRegister(arr.getRegister(i).getValue()))
return IntStream.range(0, arr.size()).mapToObj(i -> new SimpleInputRegister(arr.getRegister(i)))
.collect(Collectors.toList()).toArray(new Register[0]);
}

5
bundles/org.openhab.io.transport.modbus/src/main/java/org/openhab/io/transport/modbus/json/WriteRequestJsonUtilities.java
View File

@ -22,7 +22,6 @@ import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.io.transport.modbus.BitArray;
import org.openhab.io.transport.modbus.ModbusConstants;
import org.openhab.io.transport.modbus.ModbusRegister;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
import org.openhab.io.transport.modbus.ModbusWriteCoilRequestBlueprint;
import org.openhab.io.transport.modbus.ModbusWriteFunctionCode;
@ -197,7 +196,7 @@ public final class WriteRequestJsonUtilities {
}
// fall-through to WRITE_MULTIPLE_REGISTERS
case WRITE_MULTIPLE_REGISTERS: {
ModbusRegister[] registers = new ModbusRegister[valuesElem.size()];
int[] registers = new int[valuesElem.size()];
if (registers.length == 0) {
throw new IllegalArgumentException("Must provide at least one register");
} else if (valuesElem.size() > ModbusConstants.MAX_REGISTERS_WRITE_COUNT) {
@ -206,7 +205,7 @@ public final class WriteRequestJsonUtilities {
ModbusConstants.MAX_REGISTERS_WRITE_COUNT));
}
for (int i = 0; i < valuesElem.size(); i++) {
registers[i] = new ModbusRegister(valuesElem.get(i).getAsInt());
registers[i] = valuesElem.get(i).getAsInt();
}
return new ModbusWriteRegisterRequestBlueprint(unitId, address, new ModbusRegisterArray(registers),
!writeSingle.get(), maxTries);

4
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/BitUtilitiesCommandToRegistersTest.java
View File

@ -322,9 +322,9 @@ public class BitUtilitiesCommandToRegistersTest {
is(equalTo(expectedRegisters.length)));
for (int i = 0; i < expectedRegisters.length; i++) {
int expectedRegisterDataUnsigned = expectedRegisters[i] & 0xffff;
int actual = registers.getRegister(i).getValue();
int actualUnsigned = registers.getRegister(i);
assertThat(String.format("register index i=%d, command=%s, type=%s", i, command, type), actual,
assertThat(String.format("register index i=%d, command=%s, type=%s", i, command, type), actualUnsigned,
is(equalTo(expectedRegisterDataUnsigned)));
}
}

135
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/BitUtilitiesExtractBitTest.java Normal file
View File

@ -0,0 +1,135 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.io.transport.modbus.test;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
/**
*
* Tests for extractBit
*
* @author Sami Salonen - Initial contribution
*/
public class BitUtilitiesExtractBitTest {
@Test
public void testExtractBitWithRegisterIndexAndBitIndex() {
byte[] bytes = new byte[] { 0b00100001, // hi byte of 1st register
0b00100101, // lo byte of 1st register
0b00110001, // hi byte of 2nd register
0b00101001 }; // lo byte of 2nd register
{
int registerIndex = 0;
int[] expectedBitsFromLSBtoMSB = new int[] { //
1, 0, 1, 0, 0, 1, 0, 0, // lo byte, with increasing significance
1, 0, 0, 0, 0, 1, 0, 0 // hi byte, with increasing significance
};
for (int bitIndex = 0; bitIndex < expectedBitsFromLSBtoMSB.length; bitIndex++) {
assertEquals(expectedBitsFromLSBtoMSB[bitIndex],
ModbusBitUtilities.extractBit(bytes, registerIndex, bitIndex),
String.format("bitIndex=%d", bitIndex));
}
}
{
int registerIndex = 1;
int[] expectedBitsFromLSBtoMSB = new int[] { //
1, 0, 0, 1, 0, 1, 0, 0, // lo byte, with increasing significance
1, 0, 0, 0, 1, 1, 0, 0 // hi byte, with increasing significance
};
for (int bitIndex = 0; bitIndex < expectedBitsFromLSBtoMSB.length; bitIndex++) {
assertEquals(expectedBitsFromLSBtoMSB[bitIndex],
ModbusBitUtilities.extractBit(bytes, registerIndex, bitIndex),
String.format("bitIndex=%d", bitIndex));
}
}
}
@Test
public void testExtractBitWithRegisterIndexAndBitIndexOOB() {
byte[] bytes = new byte[] { 0b00100001, // hi byte of 1st register
0b00100101, // lo byte of 1st register
0b00110001, // hi byte of 2nd register
0b00101001 }; // lo byte of 2nd register
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractBit(bytes, 3, 0));
}
@Test
public void testExtractBitWithRegisterIndexAndBitIndexOOB2() {
byte[] bytes = new byte[] { 0b00100001, // hi byte of 1st register
0b00100101, // lo byte of 1st register
0b00110001, // hi byte of 2nd register
0b00101001 }; // lo byte of 2nd register
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractBit(bytes, 0, 17));
}
@Test
public void testExtractBitWithRegisterIndexAndBitIndexOOB3() {
byte[] bytes = new byte[] { 0b00100001, // hi byte of 1st register
0b00100101, // lo byte of 1st register
0b00110001, // hi byte of 2nd register
0b00101001 }; // lo byte of 2nd register
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractBit(bytes, 0, -1));
}
@Test
public void testExtractBitWithRegisterIndexAndBitIndexOOB4() {
byte[] bytes = new byte[] { 0b00100001, // hi byte of 1st register
0b00100101, // lo byte of 1st register
0b00110001, // hi byte of 2nd register
0b00101001 }; // lo byte of 2nd register
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractBit(bytes, -1, 0));
}
@Test
public void testExtractBitWithSingleIndex() {
byte[] bytes = new byte[] { 0b00100001, // hi byte of 1st register
0b00100101, // lo byte of 1st register
0b00110001, // hi byte of 2nd register
0b00101001 }; // lo byte of 2nd register
int[] expectedBits = new int[] { //
1, 0, 1, 0, 0, 1, 0, 0, // 1st register: lo byte, with increasing significance
1, 0, 0, 0, 0, 1, 0, 0, // 1st register: hi byte, with increasing significance
1, 0, 0, 1, 0, 1, 0, 0, // 2nd register: lo byte, with increasing significance
1, 0, 0, 0, 1, 1, 0, 0 // 2nd register: hi byte, with increasing significance
};
for (int bitIndex = 0; bitIndex < expectedBits.length; bitIndex++) {
assertEquals(expectedBits[bitIndex], ModbusBitUtilities.extractBit(bytes, bitIndex),
String.format("bitIndex=%d", bitIndex));
assertEquals(expectedBits[bitIndex], ModbusBitUtilities.extractBit(bytes, bitIndex),
String.format("bitIndex=%d", bitIndex));
}
}
@Test
public void testExtractBitWithSingleIndexOOB() {
byte[] bytes = new byte[] { 0b00100001, // hi byte of 1st register
0b00100101, // lo byte of 1st register
0b00110001, // hi byte of 2nd register
0b00101001 }; // lo byte of 2nd register
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractBit(bytes, 32));
}
@Test
public void testExtractBitWithSingleIndexOOB2() {
byte[] bytes = new byte[] { 0b00100001, // hi byte of 1st register
0b00100101, // lo byte of 1st register
0b00110001, // hi byte of 2nd register
0b00101001 }; // lo byte of 2nd register
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractBit(bytes, -1));
}
}

80
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/BitUtilitiesExtractFloat32Test.java Normal file
View File

@ -0,0 +1,80 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.io.transport.modbus.test;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.nio.ByteBuffer;
import org.junit.jupiter.api.Test;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
/**
*
* Tests for 'special' float values such as infinity and NaN. These are not covered in detail in
* {@link BitUtilitiesExtractIndividualMethodsTest} and
* {@link BitUtilitiesExtractStateFromRegistersTest}
*
* @author Sami Salonen - Initial contribution
*/
public class BitUtilitiesExtractFloat32Test {
/**
* Creates a byte array with byteOffset number of zeroes, followed by 32bit of data represented by data
*
* @param data actual data payload
* @param byteOffset number of zeros padded
* @return byte array of size 4 + byteOffset
*/
private static byte[] bytes(int data, int byteOffset) {
ByteBuffer buffer = ByteBuffer.allocate(4 + byteOffset);
for (int i = 0; i < byteOffset; i++) {
buffer.put((byte) 0);
}
buffer.putInt(data);
return buffer.array();
}
private static void testFloat(float number) {
int data = Float.floatToIntBits(number);
for (int byteOffset = 0; byteOffset < 5; byteOffset++) {
byte[] bytes = bytes(data, byteOffset);
float actual = ModbusBitUtilities.extractFloat32(bytes, byteOffset);
float expected = Float.intBitsToFloat(data);
// Strict comparison of the float values with the exception of NaN
assertTrue(Float.isNaN(expected) ? Float.isNaN(actual) : expected == actual,
String.format("Testing %f (%s) with offset %d, got %f (%s)", expected, Integer.toBinaryString(data),
byteOffset, actual, Integer.toBinaryString(Float.floatToRawIntBits(actual))));
}
}
@Test
public void testExtractFloat32Inf() {
testFloat(Float.POSITIVE_INFINITY);
}
@Test
public void testExtractFloat32NegInf() {
testFloat(Float.NEGATIVE_INFINITY);
}
@Test
public void testExtractFloat32NaN() {
testFloat(Float.NaN);
}
@Test
public void testExtractFloat32Regular() {
testFloat(1.3f);
}
}

266
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/BitUtilitiesExtractIndividualMethodsTest.java Normal file
View File

@ -0,0 +1,266 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.io.transport.modbus.test;
import static org.junit.jupiter.api.Assertions.*;
import java.util.Arrays;
import java.util.Collection;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.Stream.Builder;
import org.eclipse.jdt.annotation.Nullable;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.openhab.core.library.types.DecimalType;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
import org.openhab.io.transport.modbus.ModbusConstants.ValueType;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
/**
* @author Sami Salonen - Initial contribution
*/
public class BitUtilitiesExtractIndividualMethodsTest {
public static Collection<Object[]> data() {
// We use test data from BitUtilitiesExtractStateFromRegistersTest
// In BitUtilitiesExtractStateFromRegistersTest the data is aligned to registers
//
// Here (in registerVariations) we generate offsetted variations of the byte data
// to test extractXX which can operate on data aligned on byte-level, not just data aligned on-register level
Collection<Object[]> data = BitUtilitiesExtractStateFromRegistersTest.data();
return data.stream().flatMap(values -> {
Object expectedResult = values[0];
ValueType type = (ValueType) values[1];
ModbusRegisterArray registers = (ModbusRegisterArray) values[2];
int index = (int) values[3];
return registerVariations(expectedResult, type, registers, index);
}).collect(Collectors.toList());
}
public static Stream<Object[]> filteredTestData(ValueType type) {
return data().stream().filter(values -> (ValueType) values[1] == type);
}
/**
* Generate register variations for extractXX functions
*
*
* @return entries of (byte[], byteIndex)
*/
private static Stream<Object[]> registerVariations(Object expectedResult, ValueType type,
ModbusRegisterArray registers, int index) {
byte[] origBytes = registers.getBytes();
int origRegisterIndex = index;
int origByteIndex = origRegisterIndex * 2;
Builder<Object[]> streamBuilder = Stream.builder();
for (int offset = 0; offset < 5; offset++) {
int byteIndex = origByteIndex + offset;
byte[] bytesOffsetted = new byte[origBytes.length + offset];
for (int i = 0; i < bytesOffsetted.length; i++) {
bytesOffsetted[i] = 99;
}
System.arraycopy(origBytes, 0, bytesOffsetted, offset, origBytes.length);
// offsetted:
streamBuilder.add(new Object[] { expectedResult, type, bytesOffsetted, byteIndex });
// offsetted, with no extra bytes following
// (this is only done for successfull cases to avoid copyOfRange padding with zeros
if (!(expectedResult instanceof Class)) {
byte[] bytesOffsettedCutExtra = Arrays.copyOfRange(bytesOffsetted, 0, byteIndex + type.getBits() / 8);
if (bytesOffsettedCutExtra.length != bytesOffsetted.length) {
streamBuilder.add(new Object[] { expectedResult, type, bytesOffsettedCutExtra, byteIndex });
}
}
}
return streamBuilder.build();
}
private void testIndividual(Object expectedResult, ValueType type, byte[] bytes, int byteIndex,
Supplier<Number> methodUnderTest, Function<DecimalType, Number> expectedPrimitive) {
testIndividual(expectedResult, type, bytes, byteIndex, methodUnderTest, expectedPrimitive, null);
}
@SuppressWarnings("unchecked")
private void testIndividual(Object expectedResult, ValueType type, byte[] bytes, int byteIndex,
Supplier<Number> methodUnderTest, Function<DecimalType, Number> expectedPrimitive,
@Nullable Number defaultWhenEmptyOptional) {
String testExplanation = String.format("bytes=%s, byteIndex=%d, type=%s", Arrays.toString(bytes), byteIndex,
type);
final Object expectedNumber;
if (expectedResult instanceof Class && Exception.class.isAssignableFrom((Class<?>) expectedResult)) {
assertThrows((Class<? extends Throwable>) expectedResult, () -> methodUnderTest.get());
} else if (expectedResult instanceof Optional<?>) {
assertTrue(!((Optional<?>) expectedResult).isPresent());
if (defaultWhenEmptyOptional == null) {
fail("Should provide defaultWhenEmptyOptional");
}
return;
} else {
DecimalType expectedDecimal = (DecimalType) expectedResult;
expectedNumber = expectedPrimitive.apply(expectedDecimal);
assertEquals(expectedNumber, methodUnderTest.get(), testExplanation);
}
}
public static Stream<Object[]> filteredTestDataSInt16() {
return filteredTestData(ValueType.INT16);
}
@ParameterizedTest
@MethodSource("filteredTestDataSInt16")
public void testExtractIndividualSInt16(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex, () -> ModbusBitUtilities.extractSInt16(bytes, byteIndex),
decimal -> decimal.shortValue());
}
public static Stream<Object[]> filteredTestDataUInt16() {
return filteredTestData(ValueType.UINT16);
}
@ParameterizedTest
@MethodSource("filteredTestDataUInt16")
public void testExtractIndividualUInt16(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex, () -> ModbusBitUtilities.extractUInt16(bytes, byteIndex),
decimal -> decimal.intValue());
}
public static Stream<Object[]> filteredTestDataSInt32() {
return filteredTestData(ValueType.INT32);
}
@ParameterizedTest
@MethodSource("filteredTestDataSInt32")
public void testExtractIndividualSInt32(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex, () -> ModbusBitUtilities.extractSInt32(bytes, byteIndex),
decimal -> decimal.intValue());
}
public static Stream<Object[]> filteredTestDataUInt32() {
return filteredTestData(ValueType.UINT32);
}
@ParameterizedTest
@MethodSource("filteredTestDataUInt32")
public void testExtractIndividualUInt32(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex, () -> ModbusBitUtilities.extractUInt32(bytes, byteIndex),
decimal -> decimal.longValue());
}
public static Stream<Object[]> filteredTestDataSInt32Swap() {
return filteredTestData(ValueType.INT32_SWAP);
}
@ParameterizedTest
@MethodSource("filteredTestDataSInt32Swap")
public void testExtractIndividualSInt32Swap(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex,
() -> ModbusBitUtilities.extractSInt32Swap(bytes, byteIndex), decimal -> decimal.intValue());
}
public static Stream<Object[]> filteredTestDataUInt32Swap() {
return filteredTestData(ValueType.UINT32_SWAP);
}
@ParameterizedTest
@MethodSource("filteredTestDataUInt32Swap")
public void testExtractIndividualUInt32Swap(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex,
() -> ModbusBitUtilities.extractUInt32Swap(bytes, byteIndex), decimal -> decimal.longValue());
}
public static Stream<Object[]> filteredTestDataSInt64() {
return filteredTestData(ValueType.INT64);
}
@ParameterizedTest
@MethodSource("filteredTestDataSInt64")
public void testExtractIndividualSInt64(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex, () -> ModbusBitUtilities.extractSInt64(bytes, byteIndex),
decimal -> decimal.longValue());
}
public static Stream<Object[]> filteredTestDataUInt64() {
return filteredTestData(ValueType.UINT64);
}
@ParameterizedTest
@MethodSource("filteredTestDataUInt64")
public void testExtractIndividualUInt64(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex, () -> ModbusBitUtilities.extractUInt64(bytes, byteIndex),
decimal -> decimal.toBigDecimal().toBigIntegerExact());
}
public static Stream<Object[]> filteredTestDataSInt64Swap() {
return filteredTestData(ValueType.INT64_SWAP);
}
@ParameterizedTest
@MethodSource("filteredTestDataSInt64Swap")
public void testExtractIndividualSInt64Swap(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex,
() -> ModbusBitUtilities.extractSInt64Swap(bytes, byteIndex), decimal -> decimal.longValue());
}
public static Stream<Object[]> filteredTestDataUInt64Swap() {
return filteredTestData(ValueType.UINT64_SWAP);
}
@ParameterizedTest
@MethodSource("filteredTestDataUInt64Swap")
public void testExtractIndividualUInt64Swap(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex,
() -> ModbusBitUtilities.extractUInt64Swap(bytes, byteIndex),
decimal -> decimal.toBigDecimal().toBigIntegerExact());
}
public static Stream<Object[]> filteredTestDataFloat32() {
return filteredTestData(ValueType.FLOAT32);
}
@ParameterizedTest
@MethodSource("filteredTestDataFloat32")
public void testExtractIndividualFloat32(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex,
() -> ModbusBitUtilities.extractFloat32(bytes, byteIndex), decimal -> decimal.floatValue(), Float.NaN);
}
public static Stream<Object[]> filteredTestDataFloat32Swap() {
return filteredTestData(ValueType.FLOAT32_SWAP);
}
@ParameterizedTest
@MethodSource("filteredTestDataFloat32Swap")
public void testExtractIndividualFloat32Swap(Object expectedResult, ValueType type, byte[] bytes, int byteIndex)
throws InstantiationException, IllegalAccessException {
testIndividual(expectedResult, type, bytes, byteIndex,
() -> ModbusBitUtilities.extractFloat32Swap(bytes, byteIndex), decimal -> decimal.floatValue(),
Float.NaN);
}
}

113
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/BitUtilitiesExtractInt8Test.java Normal file
View File

@ -0,0 +1,113 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.io.transport.modbus.test;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
/**
*
* Tests for extractSInt8 and extractUInt8
*
* @author Sami Salonen - Initial contribution
*/
public class BitUtilitiesExtractInt8Test {
@Test
public void extractSInt8WithSingleIndex() {
byte[] bytes = new byte[] { -1, 2, 3 };
assertEquals(-1, ModbusBitUtilities.extractSInt8(bytes, 0));
assertEquals(2, ModbusBitUtilities.extractSInt8(bytes, 1));
assertEquals(3, ModbusBitUtilities.extractSInt8(bytes, 2));
}
@Test
public void extractSInt8WithSingleIndexOOB() {
byte[] bytes = new byte[] { -1, 2, 3 };
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractSInt8(bytes, 3));
}
@Test
public void extractSInt8WithSingleIndexOOB2() {
byte[] bytes = new byte[] { -1, 2, 3 };
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractSInt8(bytes, -1));
}
@Test
public void extractSInt8WithRegisterIndexAndHiByte() {
byte[] bytes = new byte[] { -1, 2, 3, 4 };
assertEquals(-1, ModbusBitUtilities.extractSInt8(bytes, 0, true));
assertEquals(2, ModbusBitUtilities.extractSInt8(bytes, 0, false));
assertEquals(3, ModbusBitUtilities.extractSInt8(bytes, 1, true));
assertEquals(4, ModbusBitUtilities.extractSInt8(bytes, 1, false));
}
@Test
public void extractSInt8WithRegisterIndexAndHiByteOOB() {
byte[] bytes = new byte[] { -1, 2, 3, 4 };
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractSInt8(bytes, 2, true));
}
@Test
public void extractSInt8WithRegisterIndexAndHiByteOOB2() {
byte[] bytes = new byte[] { -1, 2, 3, 4 };
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractSInt8(bytes, -1, true));
}
//
// unsigned int8 follows
//
@Test
public void extractUInt8WithSingleIndex() {
byte[] bytes = new byte[] { -1, 2, 3 };
assertEquals(255, ModbusBitUtilities.extractUInt8(bytes, 0));
assertEquals(2, ModbusBitUtilities.extractUInt8(bytes, 1));
assertEquals(3, ModbusBitUtilities.extractUInt8(bytes, 2));
}
@Test
public void extractUInt8WithSingleIndexOOB() {
byte[] bytes = new byte[] { -1, 2, 3 };
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractUInt8(bytes, 3));
}
@Test
public void extractUInt8WithSingleIndexOOB2() {
byte[] bytes = new byte[] { -1, 2, 3 };
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractUInt8(bytes, -1));
}
@Test
public void extractUInt8WithRegisterIndexAndHiByte() {
byte[] bytes = new byte[] { -1, 2, 3, 4 };
assertEquals(255, ModbusBitUtilities.extractUInt8(bytes, 0, true));
assertEquals(2, ModbusBitUtilities.extractUInt8(bytes, 0, false));
assertEquals(3, ModbusBitUtilities.extractUInt8(bytes, 1, true));
assertEquals(4, ModbusBitUtilities.extractUInt8(bytes, 1, false));
}
@Test
public void extractUInt8WithRegisterIndexAndHiByteOOB() {
byte[] bytes = new byte[] { -1, 2, 3, 4 };
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractUInt8(bytes, 2, true));
}
@Test
public void extractUInt8WithRegisterIndexAndHiByteOOB2() {
byte[] bytes = new byte[] { -1, 2, 3, 4 };
assertThrows(IllegalArgumentException.class, () -> ModbusBitUtilities.extractUInt8(bytes, 255, true));
}
}

14
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/BitUtilitiesExtractStateFromRegistersTest.java
View File

@ -16,12 +16,10 @@ import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.nio.ByteBuffer;
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNull;
@ -30,7 +28,6 @@ import org.junit.jupiter.params.provider.MethodSource;
import org.openhab.core.library.types.DecimalType;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
import org.openhab.io.transport.modbus.ModbusConstants.ValueType;
import org.openhab.io.transport.modbus.ModbusRegister;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
/**
@ -39,12 +36,7 @@ import org.openhab.io.transport.modbus.ModbusRegisterArray;
public class BitUtilitiesExtractStateFromRegistersTest {
private static ModbusRegisterArray shortArrayToRegisterArray(int... arr) {
ModbusRegister[] tmp = new ModbusRegister[0];
return new ModbusRegisterArray(IntStream.of(arr).mapToObj(val -> {
ByteBuffer buffer = ByteBuffer.allocate(2);
buffer.putShort((short) val);
return new ModbusRegister(buffer.get(0), buffer.get(1));
}).collect(Collectors.toList()).toArray(tmp));
return new ModbusRegisterArray(arr);
}
public static Collection<Object[]> data() {
@ -118,7 +110,7 @@ public class BitUtilitiesExtractStateFromRegistersTest {
new Object[] { new DecimalType("64000"), ValueType.UINT16, shortArrayToRegisterArray(64000), 0 },
new Object[] { new DecimalType("64532"), ValueType.UINT16, shortArrayToRegisterArray(4, -1004), 1 },
new Object[] { new DecimalType("64532"), ValueType.UINT16, shortArrayToRegisterArray(-1004, 4), 0 },
new Object[] { IllegalArgumentException.class, ValueType.INT16, shortArrayToRegisterArray(4, -1004),
new Object[] { IllegalArgumentException.class, ValueType.UINT16, shortArrayToRegisterArray(4, -1004),
2 },
//
// INT32
@ -364,7 +356,7 @@ public class BitUtilitiesExtractStateFromRegistersTest {
@SuppressWarnings({ "unchecked", "rawtypes" })
@ParameterizedTest
@MethodSource("data")
public void testCommandToRegisters(Object expectedResult, ValueType type, ModbusRegisterArray registers,
public void testextractStateFromRegisters(Object expectedResult, ValueType type, ModbusRegisterArray registers,
int index) {
if (expectedResult instanceof Class && Exception.class.isAssignableFrom((Class) expectedResult)) {
assertThrows((Class) expectedResult,

96
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/BitUtilitiesExtractStringFromRegistersTest.java
View File

@ -1,96 +0,0 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.io.transport.modbus.test;
import static org.hamcrest.CoreMatchers.*;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.Collections;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.openhab.core.library.types.StringType;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
import org.openhab.io.transport.modbus.ModbusRegister;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
import io.swagger.v3.oas.annotations.Parameters;
/**
* @author Sami Salonen - Initial contribution
*/
public class BitUtilitiesExtractStringFromRegistersTest {
private static ModbusRegisterArray shortArrayToRegisterArray(int... arr) {
ModbusRegister[] tmp = new ModbusRegister[0];
return new ModbusRegisterArray(IntStream.of(arr).mapToObj(val -> {
ByteBuffer buffer = ByteBuffer.allocate(2);
buffer.putShort((short) val);
return new ModbusRegister(buffer.get(0), buffer.get(1));
}).collect(Collectors.toList()).toArray(tmp));
}
@Parameters
public static Collection<Object[]> data() {
return Collections.unmodifiableList(Stream.of(
new Object[] { new StringType(""), shortArrayToRegisterArray(0), 0, 0, StandardCharsets.UTF_8 },
new Object[] { new StringType("hello"), shortArrayToRegisterArray(0x6865, 0x6c6c, 0x6f00), 0, 5,
StandardCharsets.UTF_8 },
new Object[] { new StringType("hello "), shortArrayToRegisterArray(0, 0, 0x6865, 0x6c6c, 0x6f20, 0, 0),
2, 6, StandardCharsets.UTF_8 },
new Object[] { new StringType("hello"),
shortArrayToRegisterArray(0x6865, 0x6c6c, 0x6f00, 0x0000, 0x0000), 0, 10,
StandardCharsets.UTF_8 },
new Object[] { new StringType("árvíztűrő tükörfúrógép"),
shortArrayToRegisterArray(0xc3a1, 0x7276, 0xc3ad, 0x7a74, 0xc5b1, 0x72c5, 0x9120, 0x74c3,
0xbc6b, 0xc3b6, 0x7266, 0xc3ba, 0x72c3, 0xb367, 0xc3a9, 0x7000),
0, 32, StandardCharsets.UTF_8 },
new Object[] { new StringType("árvíztűrő tükörfúrógép"),
shortArrayToRegisterArray(0xe172, 0x76ed, 0x7a74, 0xfb72, 0xf520, 0x74fc, 0x6bf6, 0x7266,
0xfa72, 0xf367, 0xe970),
0, 22, Charset.forName("ISO-8859-2") },
// Invalid values
new Object[] { IllegalArgumentException.class, shortArrayToRegisterArray(0, 0), 2, 4,
StandardCharsets.UTF_8 },
new Object[] { IllegalArgumentException.class, shortArrayToRegisterArray(0, 0), 0, -1,
StandardCharsets.UTF_8 },
new Object[] { IllegalArgumentException.class, shortArrayToRegisterArray(0, 0), 0, 5,
StandardCharsets.UTF_8 })
.collect(Collectors.toList()));
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@ParameterizedTest
@MethodSource("data")
public void testExtractStringFromRegisters(Object expectedResult, ModbusRegisterArray registers, int index,
int length, Charset charset) {
if (expectedResult instanceof Class && Exception.class.isAssignableFrom((Class) expectedResult)) {
assertThrows((Class) expectedResult,
() -> ModbusBitUtilities.extractStringFromRegisters(registers, index, length, charset));
return;
}
StringType actualState = ModbusBitUtilities.extractStringFromRegisters(registers, index, length, charset);
assertThat(String.format("registers=%s, index=%d, length=%d", registers, index, length), actualState,
is(equalTo(expectedResult)));
}
}

136
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/BitUtilitiesExtractStringTest.java Normal file
View File

@ -0,0 +1,136 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.io.transport.modbus.test;
import static org.junit.jupiter.api.Assertions.*;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.Collections;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.Stream.Builder;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.openhab.io.transport.modbus.ModbusBitUtilities;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
/**
* @author Sami Salonen - Initial contribution
*/
public class BitUtilitiesExtractStringTest {
private static ModbusRegisterArray shortArrayToRegisterArray(int... arr) {
return new ModbusRegisterArray(arr);
}
public static Collection<Object[]> data() {
return Collections.unmodifiableList(Stream.of(
new Object[] { "", shortArrayToRegisterArray(0), 0, 0, StandardCharsets.UTF_8 },
new Object[] { "hello", shortArrayToRegisterArray(0x6865, 0x6c6c, 0x6f00), 0, 5,
StandardCharsets.UTF_8 },
new Object[] { "he", shortArrayToRegisterArray(0x6865, 0x6c6c, 0x6f00), 0, 2, StandardCharsets.UTF_8 }, // limited
// by
// count=2
new Object[] { "hello ", shortArrayToRegisterArray(0, 0, 0x6865, 0x6c6c, 0x6f20, 0, 0), 2, 6,
StandardCharsets.UTF_8 },
new Object[] { "hello", shortArrayToRegisterArray(0x6865, 0x6c6c, 0x6f00, 0x0000, 0x0000), 0, 10,
StandardCharsets.UTF_8 },
new Object[] { "árvíztűrő tükörfúrógép",
shortArrayToRegisterArray(0xc3a1, 0x7276, 0xc3ad, 0x7a74, 0xc5b1, 0x72c5, 0x9120, 0x74c3,
0xbc6b, 0xc3b6, 0x7266, 0xc3ba, 0x72c3, 0xb367, 0xc3a9, 0x7000),
0, 32, StandardCharsets.UTF_8 },
new Object[] { "你好，世界",
shortArrayToRegisterArray(0xe4bd, 0xa0e5, 0xa5bd, 0xefbc, 0x8ce4, 0xb896, 0xe795, 0x8c00), 0,
16, StandardCharsets.UTF_8 },
new Object[] { "árvíztűrő tükörfúrógép",
shortArrayToRegisterArray(0xe172, 0x76ed, 0x7a74, 0xfb72, 0xf520, 0x74fc, 0x6bf6, 0x7266,
0xfa72, 0xf367, 0xe970),
0, 22, Charset.forName("ISO-8859-2") },
// Example where registers contain 0 byte in between -- only the data preceding zero byte is parsed
new Object[] { "hello", shortArrayToRegisterArray(0x6865, 0x6c6c, 0x6f00, 0x776f, 0x726c, 0x64), 0, 10,
StandardCharsets.UTF_8 },
// Invalid values
// 0xe4 = "ä" in extended ascii but not covered by US_ASCII. Will be replaced by <EFBFBD>
new Object[] { "<EFBFBD>", shortArrayToRegisterArray(0xe400), 0, 2, StandardCharsets.US_ASCII },
// out of bounds
new Object[] { IllegalArgumentException.class, shortArrayToRegisterArray(0, 0), 2, 4,
StandardCharsets.UTF_8 },
// negative index
new Object[] { IllegalArgumentException.class, shortArrayToRegisterArray(0, 0), 0, -1,
StandardCharsets.UTF_8 },
// out of bounds
new Object[] { IllegalArgumentException.class, shortArrayToRegisterArray(0, 0), 0, 5,
StandardCharsets.UTF_8 })
.collect(Collectors.toList()));
}
public static Stream<Object[]> dataWithByteVariations() {
return data().stream().flatMap(vals -> {
Object expected = vals[0];
ModbusRegisterArray registers = (ModbusRegisterArray) vals[1];
int index = (int) vals[2];
int length = (int) vals[3];
Charset charset = (Charset) vals[4];
byte[] origBytes = registers.getBytes();
int origRegisterIndex = index;
int origByteIndex = origRegisterIndex * 2;
Builder<Object[]> streamBuilder = Stream.builder();
for (int offset = 0; offset < 5; offset++) {
byte[] bytesOffsetted = new byte[origBytes.length + offset];
System.arraycopy(origBytes, 0, bytesOffsetted, offset, origBytes.length);
streamBuilder.add(
new Object[] { expected, offset, bytesOffsetted, origByteIndex + offset, length, charset });
}
Stream<Object[]> variations = streamBuilder.build();
return variations;
});
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@ParameterizedTest
@MethodSource("data")
public void testExtractStringFromRegisters(Object expectedResult, ModbusRegisterArray registers, int index,
int length, Charset charset) {
if (expectedResult instanceof Class && Exception.class.isAssignableFrom((Class) expectedResult)) {
assertThrows((Class) expectedResult,
() -> ModbusBitUtilities.extractStringFromRegisters(registers, index, length, charset));
return;
} else {
String actualState = ModbusBitUtilities.extractStringFromRegisters(registers, index, length, charset);
assertEquals(actualState, expectedResult,
String.format("registers=%s, index=%d, length=%d", registers, index, length));
}
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@ParameterizedTest
@MethodSource("dataWithByteVariations")
public void testExtractStringFromBytes(Object expectedResult, int byteOffset, byte[] bytes, int byteIndex,
int length, Charset charset) {
if (expectedResult instanceof Class && Exception.class.isAssignableFrom((Class) expectedResult)) {
assertThrows((Class) expectedResult,
() -> ModbusBitUtilities.extractStringFromBytes(bytes, byteIndex, length, charset));
return;
} else {
String actualState = ModbusBitUtilities.extractStringFromBytes(bytes, byteIndex, length, charset);
assertEquals(actualState, expectedResult, String.format("registers=%s, index=%d, length=%d, byteIndex=%d",
bytes, byteIndex, length, byteIndex));
}
}
}

6
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/RegisterMatcher.java
View File

@ -14,9 +14,11 @@ package org.openhab.io.transport.modbus.test;
import java.util.Arrays;
import java.util.Objects;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
import org.hamcrest.Description;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
import org.openhab.io.transport.modbus.ModbusWriteFunctionCode;
import org.openhab.io.transport.modbus.ModbusWriteRegisterRequestBlueprint;
@ -42,7 +44,9 @@ class RegisterMatcher extends AbstractRequestComparer<ModbusWriteRegisterRequest
@Override
protected boolean doMatchData(ModbusWriteRegisterRequestBlueprint item) {
Object[] actual = StreamSupport.stream(item.getRegisters().spliterator(), false).map(r -> r.getValue())
ModbusRegisterArray registers = item.getRegisters();
Object[] actual = StreamSupport
.stream(IntStream.range(0, registers.size()).mapToObj(registers::getRegister).spliterator(), false)
.toArray();
return Objects.deepEquals(actual, expectedRegisterValues);
}

103
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/SmokeTest.java
View File

@ -19,11 +19,14 @@ import static org.junit.jupiter.api.Assumptions.*;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketImpl;
import java.net.SocketImplFactory;
import java.net.SocketOption;
import java.net.StandardSocketOptions;
import java.net.UnknownHostException;
import java.util.BitSet;
import java.util.Optional;
@ -120,16 +123,16 @@ public class SmokeTest extends IntegrationTestSupport {
private void testHoldingValues(ModbusRegisterArray registers, int offsetInRegisters) {
for (int i = 0; i < registers.size(); i++) {
int expected = (i + offsetInRegisters) * HOLDING_REGISTER_MULTIPLIER;
assertThat(String.format("i=%d, expecting %d, got %d", i, registers.getRegister(i).toUnsignedShort(),
expected), registers.getRegister(i).toUnsignedShort(), is(equalTo(expected)));
assertThat(String.format("i=%d, expecting %d, got %d", i, registers.getRegister(i), expected),
registers.getRegister(i), is(equalTo(expected)));
}
}
private void testInputValues(ModbusRegisterArray registers, int offsetInRegisters) {
for (int i = 0; i < registers.size(); i++) {
int expected = (i + offsetInRegisters) * INPUT_REGISTER_MULTIPLIER;
assertThat(String.format("i=%d, expecting %d, got %d", i, registers.getRegister(i).toUnsignedShort(),
expected), registers.getRegister(i).toUnsignedShort(), is(equalTo(expected)));
assertThat(String.format("i=%d, expecting %d, got %d", i, registers.getRegister(i), expected),
registers.getRegister(i), is(equalTo(expected)));
}
}
@ -945,11 +948,7 @@ public class SmokeTest extends IntegrationTestSupport {
} catch (UnknownHostException e) {
throw new RuntimeException(e);
}
return socketSpy.sockets.stream().filter(socketImpl -> {
Socket socket = getSocketOfSocketImpl(socketImpl);
return socket.getPort() == tcpModbusPort && socket.isConnected()
&& socket.getLocalAddress().equals(testServerAddress);
}).count();
return socketSpy.sockets.stream().filter(this::isConnectedToTestServer).count();
}
/**
@ -972,25 +971,87 @@ public class SmokeTest extends IntegrationTestSupport {
private static SocketImpl newSocksSocketImpl() {
try {
Class<?> defaultSocketImpl = Class.forName("java.net.SocksSocketImpl");
Constructor<?> constructor = defaultSocketImpl.getDeclaredConstructor();
constructor.setAccessible(true);
return (SocketImpl) constructor.newInstance();
Class<?> socksSocketImplClass = Class.forName("java.net.SocksSocketImpl");
Class<?> socketImplClass = SocketImpl.class;
// // For Debugging
// for (Method method : socketImplClass.getDeclaredMethods()) {
// LoggerFactory.getLogger("foobar")
// .error("SocketImpl." + method.getName() + Arrays.toString(method.getParameters()));
// }
// for (Constructor constructor : socketImplClass.getDeclaredConstructors()) {
// LoggerFactory.getLogger("foobar")
// .error("SocketImpl." + constructor.getName() + Arrays.toString(constructor.getParameters()));
// }
// for (Method method : socksSocketImplClass.getDeclaredMethods()) {
// LoggerFactory.getLogger("foobar")
// .error("SocksSocketImpl." + method.getName() + Arrays.toString(method.getParameters()));
// }
// for (Constructor constructor : socksSocketImplClass.getDeclaredConstructors()) {
// LoggerFactory.getLogger("foobar").error(
// "SocksSocketImpl." + constructor.getName() + Arrays.toString(constructor.getParameters()));
// }
try {
Constructor<?> constructor = socksSocketImplClass.getDeclaredConstructor();
constructor.setAccessible(true);
return (SocketImpl) constructor.newInstance();
} catch (NoSuchMethodException e) {
// Newer Javas (Java 14->) do not have default constructor 'SocksSocketImpl()'
// Instead we use "static SocketImpl.createPlatformSocketImpl" and "SocksSocketImpl(SocketImpl)
Method socketImplCreateMethod = socketImplClass.getDeclaredMethod("createPlatformSocketImpl",
boolean.class);
socketImplCreateMethod.setAccessible(true);
Object socketImpl = socketImplCreateMethod.invoke(/* null since we deal with static method */ null,
/* server */false);
Constructor<?> socksSocketImplConstructor = socksSocketImplClass
.getDeclaredConstructor(socketImplClass);
socksSocketImplConstructor.setAccessible(true);
return (SocketImpl) socksSocketImplConstructor.newInstance(socketImpl);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* Get Socket corresponding to SocketImpl using reflection
*/
private static Socket getSocketOfSocketImpl(SocketImpl impl) {
private boolean isConnectedToTestServer(SocketImpl impl) {
final InetAddress testServerAddress;
try {
Method getSocket = SocketImpl.class.getDeclaredMethod("getSocket");
getSocket.setAccessible(true);
return (Socket) getSocket.invoke(impl);
} catch (Exception e) {
testServerAddress = localAddress();
} catch (UnknownHostException e) {
throw new RuntimeException(e);
}
final int port;
boolean connected = true;
final InetAddress address;
try {
Method getPort = SocketImpl.class.getDeclaredMethod("getPort");
getPort.setAccessible(true);
port = (int) getPort.invoke(impl);
Method getInetAddressMethod = SocketImpl.class.getDeclaredMethod("getInetAddress");
getInetAddressMethod.setAccessible(true);
address = (InetAddress) getInetAddressMethod.invoke(impl);
// hacky (but java8-14 compatible) way to know if socket is open
// SocketImpl.getOption throws IOException when socket is closed
Method getOption = SocketImpl.class.getDeclaredMethod("getOption", SocketOption.class);
getOption.setAccessible(true);
try {
getOption.invoke(impl, StandardSocketOptions.SO_KEEPALIVE);
} catch (InvocationTargetException e) {
if (e.getTargetException() instanceof IOException) {
connected = false;
} else {
throw e;
}
}
} catch (InvocationTargetException | SecurityException | IllegalArgumentException | IllegalAccessException
| NoSuchMethodException e) {
throw new RuntimeException(e);
}
return port == tcpModbusPort && connected && address.equals(testServerAddress);
}
}

186
bundles/org.openhab.io.transport.modbus/src/test/java/org/openhab/io/transport/modbus/test/ValueBufferTest.java Normal file
View File

@ -0,0 +1,186 @@
/**
* Copyright (c) 2010-2020 Contributors to the openHAB project
*
* See the NOTICE file(s) distributed with this work for additional
* information.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.openhab.io.transport.modbus.test;
import static org.junit.jupiter.api.Assertions.*;
import java.nio.BufferOverflowException;
import java.nio.InvalidMarkException;
import org.junit.jupiter.api.Test;
import org.openhab.io.transport.modbus.ValueBuffer;
/**
* @author Sami Salonen - Initial contribution
*/
public class ValueBufferTest {
@Test
public void testInt32Int8() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFC, 0x14, 3, -1, -2 });
assertEquals(7, wrap.remaining());
assertTrue(wrap.hasRemaining());
assertEquals(-1004, wrap.getSInt32());
assertEquals(3, wrap.remaining());
assertTrue(wrap.hasRemaining());
assertEquals(3, wrap.getSInt8());
assertEquals(2, wrap.remaining());
assertTrue(wrap.hasRemaining());
assertEquals(-1, wrap.getSInt8());
assertEquals(1, wrap.remaining());
assertTrue(wrap.hasRemaining());
assertEquals(254, wrap.getUInt8());
assertEquals(0, wrap.remaining());
assertFalse(wrap.hasRemaining());
}
@Test
public void testOutOfBounds() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFC, 0x14, 3, -1, -2 });
wrap.position(7);
assertThrows(IllegalArgumentException.class, () -> wrap.getSInt8());
}
@Test
public void testOutOfBound2s() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFC, 0x14, 3, -1, -2 });
wrap.position(6);
assertThrows(IllegalArgumentException.class, () -> wrap.getSInt16());
}
@Test
public void testMarkReset() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFC, 0x14, 3, -1, -2 });
wrap.mark();
assertEquals(-1004, wrap.getSInt32());
wrap.reset();
assertEquals(4294966292L, wrap.getUInt32());
wrap.mark();
assertEquals(3, wrap.getSInt8());
wrap.reset();
assertEquals(3, wrap.getSInt8());
assertEquals(-1, wrap.getSInt8());
assertEquals(254, wrap.getUInt8());
}
@Test
public void testMarkHigherThanPosition() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFC, 0x14, 3, -1, -2 });
assertEquals(-1004, wrap.getSInt32());
wrap.position(4);
wrap.mark();
assertEquals(4, wrap.position());
// mark = position
wrap.position(4);
assertEquals(4, wrap.position());
wrap.reset();
assertEquals(4, wrap.position());
// position < mark
wrap.position(3); // Mark is removed here
assertEquals(3, wrap.position());
boolean caughtException = false;
try {
wrap.reset();
} catch (InvalidMarkException e) {
// OK, expected
caughtException = true;
}
assertTrue(caughtException);
assertEquals(3, wrap.position());
// Mark is removed. Reset unaccessible even with original position of 4
wrap.position(4);
assertEquals(4, wrap.position());
caughtException = false;
try {
wrap.reset();
} catch (InvalidMarkException e) {
// OK, expected
caughtException = true;
}
assertTrue(caughtException);
}
@Test
public void testMarkLowerThanPosition() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFC, 0x14, 3, -1, -2 });
assertEquals(-1004, wrap.getSInt32());
wrap.position(4);
wrap.mark();
assertEquals(4, wrap.position());
// mark = position
wrap.position(4);
assertEquals(4, wrap.position());
wrap.reset();
assertEquals(4, wrap.position());
// mark > position
wrap.position(6);
assertEquals(6, wrap.position());
wrap.reset();
assertEquals(4, wrap.position());
}
@Test
public void testPosition() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { 0, 0, 0, 1, 3, -1, -2 });
assertEquals(0, wrap.position());
wrap.position(4);
assertEquals(4, wrap.position());
assertEquals(3, wrap.getSInt8());
assertEquals(5, wrap.position());
}
@Test
public void testBulkGetBufferOverflow() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { 0, 0 });
byte[] threeBytes = new byte[3];
assertThrows(BufferOverflowException.class, () -> wrap.get(threeBytes));
}
@Test
public void testBulkGetAtCapacity() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { 1, 2 });
byte[] twoBytes = new byte[2];
wrap.get(twoBytes);
assertEquals(1, twoBytes[0]);
assertEquals(2, twoBytes[1]);
assertEquals(2, wrap.position());
assertFalse(wrap.hasRemaining());
}
@Test
public void testBulkGet() {
ValueBuffer wrap = ValueBuffer.wrap(new byte[] { 1, 2, 3 });
byte[] onebyte = new byte[1];
wrap.get(onebyte);
assertEquals(1, onebyte[0]);
assertEquals(1, wrap.position());
// non-zero position
byte[] twoBytes = new byte[2];
wrap.position(1);
wrap.get(twoBytes);
assertEquals(2, twoBytes[0]);
assertEquals(3, twoBytes[1]);
assertEquals(3, wrap.position());
}
}

23
itests/org.openhab.binding.modbus.tests/src/main/java/org/openhab/binding/modbus/tests/ModbusDataHandlerTest.java
View File

@ -68,7 +68,6 @@ import org.openhab.io.transport.modbus.ModbusConstants;
import org.openhab.io.transport.modbus.ModbusConstants.ValueType;
import org.openhab.io.transport.modbus.ModbusReadFunctionCode;
import org.openhab.io.transport.modbus.ModbusReadRequestBlueprint;
import org.openhab.io.transport.modbus.ModbusRegister;
import org.openhab.io.transport.modbus.ModbusRegisterArray;
import org.openhab.io.transport.modbus.ModbusResponse;
import org.openhab.io.transport.modbus.ModbusWriteCoilRequestBlueprint;
@ -517,7 +516,7 @@ public class ModbusDataHandlerTest extends AbstractModbusOSGiTest {
public void testOnRegistersInt16StaticTransformation() {
ModbusDataThingHandler dataHandler = testReadHandlingGeneric(ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS,
"0", "-3", ModbusConstants.ValueType.INT16, null,
new ModbusRegisterArray(new ModbusRegister[] { new ModbusRegister((byte) 0xff, (byte) 0xfd) }), null);
new ModbusRegisterArray(new byte[] { (byte) 0xff, (byte) 0xfd }), null);
assertSingleStateUpdate(dataHandler, CHANNEL_LAST_READ_SUCCESS, is(notNullValue(State.class)));
assertSingleStateUpdate(dataHandler, CHANNEL_LAST_READ_ERROR, is(nullValue(State.class)));
@ -538,8 +537,7 @@ public class ModbusDataHandlerTest extends AbstractModbusOSGiTest {
mockTransformation("MULTIPLY", new MultiplyTransformation());
ModbusDataThingHandler dataHandler = testReadHandlingGeneric(ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS,
"0", "MULTIPLY(10)", ModbusConstants.ValueType.INT16, null,
new ModbusRegisterArray(new ModbusRegister[] { new ModbusRegister((byte) 0xff, (byte) 0xfd) }), null,
bundleContext);
new ModbusRegisterArray(new byte[] { (byte) 0xff, (byte) 0xfd }), null, bundleContext);
assertSingleStateUpdate(dataHandler, CHANNEL_LAST_READ_SUCCESS, is(notNullValue(State.class)));
assertSingleStateUpdate(dataHandler, CHANNEL_LAST_READ_ERROR, is(nullValue(State.class)));
@ -561,8 +559,7 @@ public class ModbusDataHandlerTest extends AbstractModbusOSGiTest {
ModbusDataThingHandler dataHandler = testReadHandlingGeneric(ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS,
"0", "default", ModbusConstants.ValueType.FLOAT32, null, new ModbusRegisterArray(
// equivalent of floating point NaN
new ModbusRegister[] { new ModbusRegister((byte) 0x7f, (byte) 0xc0),
new ModbusRegister((byte) 0x00, (byte) 0x00) }),
new byte[] { (byte) 0x7f, (byte) 0xc0, (byte) 0x00, (byte) 0x00 }),
null, bundleContext);
assertSingleStateUpdate(dataHandler, CHANNEL_LAST_READ_SUCCESS, is(notNullValue(State.class)));
@ -588,8 +585,7 @@ public class ModbusDataHandlerTest extends AbstractModbusOSGiTest {
});
ModbusDataThingHandler dataHandler = testReadHandlingGeneric(ModbusReadFunctionCode.READ_MULTIPLE_REGISTERS,
"0", "ONOFF(10)", ModbusConstants.ValueType.INT16, null,
new ModbusRegisterArray(new ModbusRegister[] { new ModbusRegister((byte) 0xff, (byte) 0xfd) }), null,
bundleContext);
new ModbusRegisterArray(new byte[] { (byte) 0xff, (byte) 0xfd }), null, bundleContext);
assertSingleStateUpdate(dataHandler, CHANNEL_LAST_READ_SUCCESS, is(notNullValue(State.class)));
assertSingleStateUpdate(dataHandler, CHANNEL_LAST_READ_ERROR, is(nullValue(State.class)));
@ -667,8 +663,7 @@ public class ModbusDataHandlerTest extends AbstractModbusOSGiTest {
assertThat(writeRequest.getFunctionCode(), is(equalTo(ModbusWriteFunctionCode.WRITE_SINGLE_REGISTER)));
assertThat(writeRequest.getReference(), is(equalTo(50)));
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().size(), is(equalTo(1)));
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(0).getValue(),
is(equalTo(5)));
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(0), is(equalTo(5)));
}
@Test
@ -702,11 +697,11 @@ public class ModbusDataHandlerTest extends AbstractModbusOSGiTest {
assertThat(writeRequest.getFunctionCode(), is(equalTo(ModbusWriteFunctionCode.WRITE_MULTIPLE_REGISTERS)));
assertThat(writeRequest.getReference(), is(equalTo(5412)));
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().size(), is(equalTo(3)));
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(0).getValue(),
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(0),
is(equalTo(1)));
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(1).getValue(),
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(1),
is(equalTo(0)));
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(2).getValue(),
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(2),
is(equalTo(5)));
}
{
@ -714,7 +709,7 @@ public class ModbusDataHandlerTest extends AbstractModbusOSGiTest {
assertThat(writeRequest.getFunctionCode(), is(equalTo(ModbusWriteFunctionCode.WRITE_SINGLE_REGISTER)));
assertThat(writeRequest.getReference(), is(equalTo(555)));
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().size(), is(equalTo(1)));
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(0).getValue(),
assertThat(((ModbusWriteRegisterRequestBlueprint) writeRequest).getRegisters().getRegister(0),
is(equalTo(3)));
}
}