You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2018/06/29 06:59:07 UTC

[incubator-plc4x] branch master updated (9c57fc4 -> cdddd19)

This is an automated email from the ASF dual-hosted git repository.

sruehl pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-plc4x.git.


    from 9c57fc4  added a todo about chunking and quantity regarding item types
     new 33b8a51  modbus: added basic type encoding and decoding.
     new cdddd19  fixed produce coil value method. Added a basic test

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../java/modbus/netty/Plc4XModbusProtocol.java     | 198 ++++++++++++++++++---
 .../plc4x/java/modbus/ManualPlc4XModbusTest.java   |  16 +-
 .../java/modbus/netty/Plc4XModbusProtocolTest.java |  49 +++++
 3 files changed, 231 insertions(+), 32 deletions(-)
 create mode 100644 plc4j/protocols/modbus/src/test/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocolTest.java


[incubator-plc4x] 02/02: fixed produce coil value method. Added a basic test

Posted by sr...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

sruehl pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-plc4x.git

commit cdddd19e5bef17f4ccdddf9f1cb27b5fc1b69fa3
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Fri Jun 29 08:58:55 2018 +0200

    fixed produce coil value method. Added a basic test
---
 .../java/modbus/netty/Plc4XModbusProtocol.java     |  4 +-
 .../java/modbus/netty/Plc4XModbusProtocolTest.java | 49 ++++++++++++++++++++++
 2 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/plc4j/protocols/modbus/src/main/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocol.java b/plc4j/protocols/modbus/src/main/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocol.java
index bc2ab24..8cbce82 100644
--- a/plc4j/protocols/modbus/src/main/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocol.java
+++ b/plc4j/protocols/modbus/src/main/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocol.java
@@ -249,7 +249,7 @@ public class Plc4XModbusProtocol extends MessageToMessageCodec<ModbusTcpPayload,
     private byte[] produceCoilValue(List<?> values) throws PlcProtocolException {
         List<Byte> coils = new LinkedList<>();
         Byte actualCoil = 0;
-        int i = 8;
+        int i = 7;
         for (Object value : values) {
             boolean coilSet = false;
             if (value.getClass() == Boolean.class) {
@@ -282,7 +282,7 @@ public class Plc4XModbusProtocol extends MessageToMessageCodec<ModbusTcpPayload,
             }
             byte coilToSet = (coilSet ? (byte) 1 : (byte) 0);
             actualCoil = (byte) (actualCoil | coilToSet << i);
-            i++;
+            i--;
             if (i < 0) {
                 coils.add(actualCoil);
                 actualCoil = 0;
diff --git a/plc4j/protocols/modbus/src/test/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocolTest.java b/plc4j/protocols/modbus/src/test/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocolTest.java
new file mode 100644
index 0000000..5926373
--- /dev/null
+++ b/plc4j/protocols/modbus/src/test/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocolTest.java
@@ -0,0 +1,49 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+ */
+package org.apache.plc4x.java.modbus.netty;
+
+import org.apache.commons.lang3.reflect.MethodUtils;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.BitSet;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+public class Plc4XModbusProtocolTest {
+
+    @Test
+    public void coilEncoding() throws Exception {
+        byte[] bytes = (byte[]) MethodUtils.invokeMethod(new Plc4XModbusProtocol(), true, "produceCoilValue", Arrays.asList(false, false, true, false, false, false, true, false));
+        assertSame(1, bytes.length);
+        String s1 = String.format("%8s", Integer.toBinaryString(bytes[0] & 0xFF)).replace(' ', '0');
+        assertEquals("00100010", s1);
+
+        // TODO: just for reference we could use a bitset too
+        BitSet bitSet = new BitSet(8);
+        bitSet.set(1);
+        bitSet.set(5);
+        byte[] bytes1 = bitSet.toByteArray();
+        assertSame(1, bytes1.length);
+
+        String s2 = String.format("%8s", Integer.toBinaryString(bytes1[0] & 0xFF)).replace(' ', '0');
+        assertEquals("00100010", s2);
+    }
+}
\ No newline at end of file


[incubator-plc4x] 01/02: modbus: added basic type encoding and decoding.

Posted by sr...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

sruehl pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-plc4x.git

commit 33b8a51774f209c7738b357e5a5176cbf2189521
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Thu Jun 28 19:21:52 2018 +0200

    modbus: added basic type encoding and decoding.
---
 .../java/modbus/netty/Plc4XModbusProtocol.java     | 198 ++++++++++++++++++---
 .../plc4x/java/modbus/ManualPlc4XModbusTest.java   |  16 +-
 2 files changed, 182 insertions(+), 32 deletions(-)

diff --git a/plc4j/protocols/modbus/src/main/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocol.java b/plc4j/protocols/modbus/src/main/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocol.java
index 1c4034b..bc2ab24 100644
--- a/plc4j/protocols/modbus/src/main/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocol.java
+++ b/plc4j/protocols/modbus/src/main/java/org/apache/plc4x/java/modbus/netty/Plc4XModbusProtocol.java
@@ -23,10 +23,13 @@ import com.digitalpetri.modbus.codec.ModbusTcpPayload;
 import com.digitalpetri.modbus.requests.*;
 import com.digitalpetri.modbus.responses.*;
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.MessageToMessageCodec;
+import org.apache.commons.lang3.ArrayUtils;
 import org.apache.plc4x.java.api.exceptions.PlcException;
 import org.apache.plc4x.java.api.exceptions.PlcProtocolException;
+import org.apache.plc4x.java.api.exceptions.PlcRuntimeException;
 import org.apache.plc4x.java.api.messages.*;
 import org.apache.plc4x.java.api.messages.items.*;
 import org.apache.plc4x.java.api.types.ResponseCode;
@@ -34,6 +37,7 @@ import org.apache.plc4x.java.modbus.model.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
@@ -71,27 +75,28 @@ public class Plc4XModbusProtocol extends MessageToMessageCodec<ModbusTcpPayload,
         // TODO: for higher datatypes float, double etc we might need to split the bytes into chunks
         int quantity = writeRequestItem.getSize();
         short unitId = 0;
+        checkSupportedDataType(writeRequestItem.getValues());
 
         ModbusAddress address = (ModbusAddress) writeRequestItem.getAddress();
         ModbusPdu modbusRequest;
         if (address instanceof RegisterAddress) {
             RegisterAddress registerAddress = (RegisterAddress) address;
             if (quantity > 1) {
-                // TODO: ensure we have a least quantity * 2 = N bytes
-                byte[] bytesToWrite = (byte[]) writeRequestItem.getValues().get(0);
+                byte[] bytesToWrite = produceRegisterValue(writeRequestItem.getValues());
                 modbusRequest = new WriteMultipleRegistersRequest(registerAddress.getAddress(), quantity, bytesToWrite);
             } else {
-                int intToWrite = (Integer) writeRequestItem.getValues().get(0);
+                byte[] register = produceRegisterValue(writeRequestItem.getValues());
+                int intToWrite = register[0] << 8 | register[1];
                 modbusRequest = new WriteSingleRegisterRequest(registerAddress.getAddress(), intToWrite);
             }
         } else if (address instanceof CoilAddress) {
             CoilAddress coilAddress = (CoilAddress) address;
             if (quantity > 1) {
-                // TODO: ensure we have a least (quantity + 7) / 8 = N bytes
-                byte[] bytesToWrite = (byte[]) writeRequestItem.getValues().get(0);
+                byte[] bytesToWrite = produceCoilValue(writeRequestItem.getValues());
                 modbusRequest = new WriteMultipleCoilsRequest(coilAddress.getAddress(), quantity, bytesToWrite);
             } else {
-                boolean booleanToWrite = (Boolean) writeRequestItem.getValues().get(0);
+                byte[] coil = produceCoilValue(writeRequestItem.getValues());
+                boolean booleanToWrite = (coil[0] >> 8) == 1;
                 modbusRequest = new WriteSingleCoilRequest(coilAddress.getAddress(), booleanToWrite);
             }
         } else {
@@ -152,6 +157,7 @@ public class Plc4XModbusProtocol extends MessageToMessageCodec<ModbusTcpPayload,
         // TODO: only single Item supported for now
         PlcRequest request = plcRequestContainer.getRequest();
         RequestItem requestItem = (RequestItem) request.getRequestItem().get();
+        Class datatype = requestItem.getDatatype();
 
         ModbusPdu modbusPdu = msg.getModbusPdu();
         short unitId = msg.getUnitId();
@@ -160,54 +166,52 @@ public class Plc4XModbusProtocol extends MessageToMessageCodec<ModbusTcpPayload,
             // TODO: finish implementation
             WriteMultipleCoilsResponse writeMultipleCoilsResponse = (WriteMultipleCoilsResponse) modbusPdu;
             LOGGER.debug("{}: address:{}, quantity:{}", writeMultipleCoilsResponse, writeMultipleCoilsResponse.getAddress(), writeMultipleCoilsResponse.getQuantity());
-            plcRequestContainer.getResponseFuture().complete(new PlcWriteResponse((PlcWriteRequest) request, new WriteResponseItem<>((WriteRequestItem<? extends Object>) requestItem, ResponseCode.OK)));
+            plcRequestContainer.getResponseFuture().complete(new PlcWriteResponse((PlcWriteRequest) request, new WriteResponseItem<>((WriteRequestItem) requestItem, ResponseCode.OK)));
         } else if (modbusPdu instanceof WriteMultipleRegistersResponse) {
             // TODO: finish implementation
             WriteMultipleRegistersResponse writeMultipleRegistersResponse = (WriteMultipleRegistersResponse) modbusPdu;
             LOGGER.debug("{}: address:{}, quantity:{}", writeMultipleRegistersResponse, writeMultipleRegistersResponse.getAddress(), writeMultipleRegistersResponse.getQuantity());
-            plcRequestContainer.getResponseFuture().complete(new PlcWriteResponse((PlcWriteRequest) request, new WriteResponseItem<>((WriteRequestItem<? extends Object>) requestItem, ResponseCode.OK)));
+            plcRequestContainer.getResponseFuture().complete(new PlcWriteResponse((PlcWriteRequest) request, new WriteResponseItem<>((WriteRequestItem) requestItem, ResponseCode.OK)));
         } else if (modbusPdu instanceof WriteSingleCoilResponse) {
             // TODO: finish implementation
             WriteSingleCoilResponse writeSingleCoilResponse = (WriteSingleCoilResponse) modbusPdu;
             LOGGER.debug("{}: address:{}, value:{}", writeSingleCoilResponse, writeSingleCoilResponse.getAddress(), writeSingleCoilResponse.getValue());
-            plcRequestContainer.getResponseFuture().complete(new PlcWriteResponse((PlcWriteRequest) request, new WriteResponseItem<>((WriteRequestItem<? extends Object>) requestItem, ResponseCode.OK)));
+            plcRequestContainer.getResponseFuture().complete(new PlcWriteResponse((PlcWriteRequest) request, new WriteResponseItem<>((WriteRequestItem) requestItem, ResponseCode.OK)));
         } else if (modbusPdu instanceof WriteSingleRegisterResponse) {
             // TODO: finish implementation
             WriteSingleRegisterResponse writeSingleRegisterResponse = (WriteSingleRegisterResponse) modbusPdu;
             LOGGER.debug("{}: address:{}, value:{}", writeSingleRegisterResponse, writeSingleRegisterResponse.getAddress(), writeSingleRegisterResponse.getValue());
-            plcRequestContainer.getResponseFuture().complete(new PlcWriteResponse((PlcWriteRequest) request, new WriteResponseItem<>((WriteRequestItem<? extends Object>) requestItem, ResponseCode.OK)));
+            plcRequestContainer.getResponseFuture().complete(new PlcWriteResponse((PlcWriteRequest) request, new WriteResponseItem<>((WriteRequestItem) requestItem, ResponseCode.OK)));
         } else if (modbusPdu instanceof ReadCoilsResponse) {
             // TODO: finish implementation
             ReadCoilsResponse readCoilsResponse = (ReadCoilsResponse) modbusPdu;
             LOGGER.debug("{}: Nothing", readCoilsResponse);
             ByteBuf byteBuf = readCoilsResponse.getCoilStatus();
-            byte[] bytes = new byte[byteBuf.readableBytes()];
-            byteBuf.readBytes(bytes);
-            plcRequestContainer.getResponseFuture().complete(new PlcReadResponse((PlcReadRequest) request, new ReadResponseItem((ReadRequestItem<? extends Object>) requestItem, ResponseCode.OK, (Object) bytes)));
+            List data = produceCoilValueList(requestItem, datatype, byteBuf);
+            plcRequestContainer.getResponseFuture().complete(new PlcReadResponse((PlcReadRequest) request, new ReadResponseItem((ReadRequestItem) requestItem, ResponseCode.OK, data)));
         } else if (modbusPdu instanceof ReadDiscreteInputsResponse) {
             // TODO: finish implementation
             ReadDiscreteInputsResponse readDiscreteInputsResponse = (ReadDiscreteInputsResponse) modbusPdu;
             LOGGER.debug("{}: Nothing", readDiscreteInputsResponse);
             ByteBuf byteBuf = readDiscreteInputsResponse.getInputStatus();
-            byte[] bytes = new byte[byteBuf.readableBytes()];
-            byteBuf.readBytes(bytes);
-            plcRequestContainer.getResponseFuture().complete(new PlcReadResponse((PlcReadRequest) request, new ReadResponseItem((ReadRequestItem<? extends Object>) requestItem, ResponseCode.OK, (Object) bytes)));
+            List data = produceCoilValueList(requestItem, datatype, byteBuf);
+            plcRequestContainer.getResponseFuture().complete(new PlcReadResponse((PlcReadRequest) request, new ReadResponseItem((ReadRequestItem) requestItem, ResponseCode.OK, data)));
         } else if (modbusPdu instanceof ReadHoldingRegistersResponse) {
             // TODO: finish implementation
             ReadHoldingRegistersResponse readHoldingRegistersResponse = (ReadHoldingRegistersResponse) modbusPdu;
             LOGGER.debug("{}: Nothing", readHoldingRegistersResponse);
             ByteBuf byteBuf = readHoldingRegistersResponse.getRegisters();
-            byte[] bytes = new byte[byteBuf.readableBytes()];
-            byteBuf.readBytes(bytes);
-            plcRequestContainer.getResponseFuture().complete(new PlcReadResponse((PlcReadRequest) request, new ReadResponseItem((ReadRequestItem<? extends Object>) requestItem, ResponseCode.OK, (Object) bytes)));
+            // TODO: use register method
+            List data = produceRegisterValueList(requestItem, datatype, byteBuf);
+            plcRequestContainer.getResponseFuture().complete(new PlcReadResponse((PlcReadRequest) request, new ReadResponseItem((ReadRequestItem) requestItem, ResponseCode.OK, data)));
         } else if (modbusPdu instanceof ReadInputRegistersResponse) {
             // TODO: finish implementation
             ReadInputRegistersResponse readInputRegistersResponse = (ReadInputRegistersResponse) modbusPdu;
             LOGGER.debug("{}: Nothing", readInputRegistersResponse);
             ByteBuf byteBuf = readInputRegistersResponse.getRegisters();
-            byte[] bytes = new byte[byteBuf.readableBytes()];
-            byteBuf.readBytes(bytes);
-            plcRequestContainer.getResponseFuture().complete(new PlcReadResponse((PlcReadRequest) request, new ReadResponseItem((ReadRequestItem<? extends Object>) requestItem, ResponseCode.OK, (Object) bytes)));
+            // TODO: use register method
+            List data = produceRegisterValueList(requestItem, datatype, byteBuf);
+            plcRequestContainer.getResponseFuture().complete(new PlcReadResponse((PlcReadRequest) request, new ReadResponseItem((ReadRequestItem) requestItem, ResponseCode.OK, data)));
         } else if (modbusPdu instanceof ExceptionResponse) {
             ExceptionResponse exceptionResponse = (ExceptionResponse) modbusPdu;
             throw new PlcProtocolException("Error received " + exceptionResponse.getExceptionCode());
@@ -222,14 +226,164 @@ public class Plc4XModbusProtocol extends MessageToMessageCodec<ModbusTcpPayload,
         super.exceptionCaught(ctx, cause);
     }
 
+    private void checkSupportedDataType(List<?> values) {
+        if (values == null || values.size() == 0) {
+            return;
+        }
+        for (Object value : values) {
+            if (
+                !(value instanceof Boolean)
+                    && !(value instanceof Byte)
+                    && !(value instanceof byte[])
+                    && !(value instanceof Short)
+                    && !(value instanceof Integer)
+                ) {
+                throw new PlcRuntimeException("Unsupported datatype detected " + value.getClass());
+            }
+        }
+    }
+
     ////////////////////////////////////////////////////////////////////////////////
     // Encoding helpers.
     ////////////////////////////////////////////////////////////////////////////////
+    private byte[] produceCoilValue(List<?> values) throws PlcProtocolException {
+        List<Byte> coils = new LinkedList<>();
+        Byte actualCoil = 0;
+        int i = 8;
+        for (Object value : values) {
+            boolean coilSet = false;
+            if (value.getClass() == Boolean.class) {
+                coilSet = (Boolean) value;
+            } else if (value.getClass() == Byte.class) {
+                if ((byte) value > 1) {
+                    throw new PlcProtocolException("Value to high to fit into Byte: " + value);
+                }
+                coilSet = (byte) value == 1;
+            } else if (value.getClass() == byte[].class) {
+                byte[] bytes = (byte[]) value;
+                if (bytes.length != 1) {
+                    throw new PlcProtocolException("Only exactly one byte is allowed: " + bytes.length);
+                }
+                byte byteValue = bytes[1];
+                if (byteValue > 1) {
+                    throw new PlcProtocolException("Value to high to fit into Byte: " + value);
+                }
+                coilSet = byteValue == 1;
+            } else if (value.getClass() == Short.class) {
+                if ((short) value > 1) {
+                    throw new PlcProtocolException("Value to high to fit into Byte: " + value);
+                }
+                coilSet = (Short) value == 1;
+            } else if (value.getClass() == Integer.class) {
+                if ((int) value > 1) {
+                    throw new PlcProtocolException("Value to high to fit into Byte: " + value);
+                }
+                coilSet = (int) value == 1;
+            }
+            byte coilToSet = (coilSet ? (byte) 1 : (byte) 0);
+            actualCoil = (byte) (actualCoil | coilToSet << i);
+            i++;
+            if (i < 0) {
+                coils.add(actualCoil);
+                actualCoil = 0;
+                i = 8;
+            }
+        }
+        // TODO: ensure we have a least (quantity + 7) / 8 = N bytes
+        return ArrayUtils.toPrimitive(coils.toArray(new Byte[0]));
+    }
 
+    private byte[] produceRegisterValue(List<?> values) throws PlcProtocolException {
+        ByteBuf buffer = Unpooled.buffer();
+        for (Object value : values) {
+            if (value.getClass() == Boolean.class) {
+                buffer.writeByte(0);
+                buffer.writeByte((boolean) value ? 1 : 0);
+            } else if (value.getClass() == Byte.class) {
+                buffer.writeByte(0);
+                buffer.writeByte((byte) value);
+            } else if (value.getClass() == byte[].class) {
+                byte[] bytes = (byte[]) value;
+                if (bytes.length != 2) {
+                    throw new PlcProtocolException("Only exactly two bytes are allowed: " + bytes.length);
+                }
+                buffer.writeBytes(bytes);
+            } else if (value.getClass() == Short.class) {
+                buffer.writeShort((int) value);
+            } else if (value.getClass() == Integer.class) {
+                if ((int) value > Integer.MAX_VALUE) {
+                    throw new PlcProtocolException("Value to high to fit into register: " + value);
+                }
+                buffer.writeShort((int) value);
+            }
+        }
+        // TODO: ensure we have a least quantity * 2 = N bytes
+        byte[] result = new byte[buffer.writerIndex()];
+        buffer.readBytes(result);
+        return result;
+    }
 
     ////////////////////////////////////////////////////////////////////////////////
     // Decoding helpers.
     ////////////////////////////////////////////////////////////////////////////////
 
+    @SuppressWarnings("unchecked")
+    private List produceCoilValueList(RequestItem requestItem, Class datatype, ByteBuf byteBuf) {
+        ReadRequestItem readRequestItem = (ReadRequestItem) requestItem;
+        byte[] bytes = new byte[byteBuf.readableBytes()];
+        byteBuf.readBytes(bytes);
+        List data = new LinkedList();
+        for (int i = 0, j = 0; i < readRequestItem.getSize(); i++) {
+            if (i != 0 && i % 8 == 0) {
+                // Every 8 Coils we need to increase the access
+                j++;
+            }
+            Boolean coilValue = (1 << i & bytes[j]) == 1;
+            if (datatype == Boolean.class) {
+                data.add(coilValue);
+            } else if (datatype == Byte.class) {
+                data.add((byte) (coilValue ? 1 : 0));
+            } else if (datatype == byte[].class) {
+                data.add(new byte[]{(byte) (coilValue ? 1 : 0)});
+            } else if (datatype == Short.class) {
+                data.add((short) (coilValue ? 1 : 0));
+            } else if (datatype == Integer.class) {
+                data.add(coilValue ? 1 : 0);
+            }
+        }
+        return data;
+    }
 
+    @SuppressWarnings("unchecked")
+    private List produceRegisterValueList(RequestItem requestItem, Class datatype, ByteBuf byteBuf) throws PlcProtocolException {
+        ReadRequestItem readRequestItem = (ReadRequestItem) requestItem;
+        int readableBytes = byteBuf.readableBytes();
+        if (readableBytes % 2 != 0) {
+            throw new PlcProtocolException("Readables bytes should even: " + readableBytes);
+        }
+        List data = new LinkedList();
+        for (int i = 0; i < readRequestItem.getSize(); i++) {
+            byte[] register = new byte[2];
+            byteBuf.readBytes(register);
+            int intValue = register[0] << 8 | register[1];
+            if (datatype == Boolean.class) {
+                data.add(intValue == 1);
+            } else if (datatype == Byte.class) {
+                if (intValue > Byte.MAX_VALUE) {
+                    throw new PlcProtocolException("Value to high to fit into Byte: " + intValue);
+                }
+                data.add((byte) intValue);
+            } else if (datatype == byte[].class) {
+                data.add(register);
+            } else if (datatype == Short.class) {
+                if (intValue > Short.MAX_VALUE) {
+                    throw new PlcProtocolException("Value to high to fit into Short: " + intValue);
+                }
+                data.add((short) intValue);
+            } else if (datatype == Integer.class) {
+                data.add(intValue);
+            }
+        }
+        return data;
+    }
 }
diff --git a/plc4j/protocols/modbus/src/test/java/org/apache/plc4x/java/modbus/ManualPlc4XModbusTest.java b/plc4j/protocols/modbus/src/test/java/org/apache/plc4x/java/modbus/ManualPlc4XModbusTest.java
index bff08d6..36c5ff8 100644
--- a/plc4j/protocols/modbus/src/test/java/org/apache/plc4x/java/modbus/ManualPlc4XModbusTest.java
+++ b/plc4j/protocols/modbus/src/test/java/org/apache/plc4x/java/modbus/ManualPlc4XModbusTest.java
@@ -18,7 +18,6 @@
  */
 package org.apache.plc4x.java.modbus;
 
-import org.apache.commons.io.HexDump;
 import org.apache.plc4x.java.PlcDriverManager;
 import org.apache.plc4x.java.api.connection.PlcConnection;
 import org.apache.plc4x.java.api.connection.PlcReader;
@@ -27,7 +26,6 @@ import org.apache.plc4x.java.api.messages.specific.TypeSafePlcReadRequest;
 import org.apache.plc4x.java.api.messages.specific.TypeSafePlcReadResponse;
 import org.apache.plc4x.java.api.model.Address;
 
-import java.io.ByteArrayOutputStream;
 import java.util.concurrent.CompletableFuture;
 
 public class ManualPlc4XModbusTest {
@@ -46,16 +44,14 @@ public class ManualPlc4XModbusTest {
 
             PlcReader reader = plcConnection.getReader().orElseThrow(() -> new RuntimeException("No Reader found"));
 
-            Address address = plcConnection.parseAddress("register:2");
-            CompletableFuture<TypeSafePlcReadResponse<byte[]>> response = reader
-                .read(new TypeSafePlcReadRequest<>(byte[].class, address));
-            TypeSafePlcReadResponse<byte[]> readResponse = response.get();
+            Address address = plcConnection.parseAddress("register:7");
+            CompletableFuture<TypeSafePlcReadResponse<Integer>> response = reader
+                .read(new TypeSafePlcReadRequest<>(Integer.class, address));
+            TypeSafePlcReadResponse<Integer> readResponse = response.get();
             System.out.println("Response " + readResponse);
-            ReadResponseItem<byte[]> responseItem = readResponse.getResponseItem().orElseThrow(() -> new RuntimeException("No Item found"));
+            ReadResponseItem<Integer> responseItem = readResponse.getResponseItem().orElseThrow(() -> new RuntimeException("No Item found"));
             System.out.println("ResponseItem " + responseItem);
-            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
-            HexDump.dump(responseItem.getValues().get(0), 0, byteArrayOutputStream, 0);
-            responseItem.getValues().stream().map(integer -> "Value: " + byteArrayOutputStream).forEach(System.out::println);
+            responseItem.getValues().stream().map(integer -> "Value: " + integer).forEach(System.out::println);
         } catch (Exception e) {
             e.printStackTrace();
             System.exit(1);