You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by cd...@apache.org on 2018/09/05 20:40:55 UTC

[incubator-plc4x] branch feature/api-redesign-chris-c updated: - Updated several examples and integration modules to be more aligned with the latest refactorings. - Moved the PlcFieldHandler to a separate class. - Disabled all drivers except s7 for now (will re-enable them one by one)

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

cdutz pushed a commit to branch feature/api-redesign-chris-c
in repository https://gitbox.apache.org/repos/asf/incubator-plc4x.git


The following commit(s) were added to refs/heads/feature/api-redesign-chris-c by this push:
     new 483a486  - Updated several examples and integration modules to be more aligned with the latest refactorings. - Moved the PlcFieldHandler to a separate class. - Disabled all drivers except s7 for now (will re-enable them one by one)
483a486 is described below

commit 483a4866b11af22e087e963065438f5a069814da
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Wed Sep 5 22:40:48 2018 +0200

    - Updated several examples and integration modules to be more aligned with the latest refactorings.
    - Moved the PlcFieldHandler to a separate class.
    - Disabled all drivers except s7 for now (will re-enable them one by one)
---
 .../dummydriver/connection/DummyConnection.java    |   5 -
 .../java/examples/kafkabridge/KafkaBridge.java     |   4 +-
 .../apache/plc4x/edgent/PlcConnectionAdapter.java  |   3 -
 .../plc4x/edgent/PlcConnectionAdapterTest.java     |   6 -
 .../apache/plc4x/edgent/mock/MockConnection.java   |  69 ++-
 .../org/apache/plc4x/edgent/mock/MockField.java    |   5 +-
 .../plc4x/java/api/messages/PlcReadResponse.java   |   2 +-
 .../plc4x/java/api/messages/PlcWriteRequest.java   |   8 +-
 .../plc4x/java/api/types/PlcClientDatatype.java    |   2 -
 .../java/base/connection/PlcFieldHandler.java      |  25 +-
 .../java/base/messages/DefaultPlcReadResponse.java |   2 +-
 .../java/base/messages/DefaultPlcWriteRequest.java |  72 ++--
 plc4j/protocols/pom.xml                            |   4 +-
 .../plc4x/java/s7/connection/S7PlcConnection.java  |  33 +-
 .../plc4x/java/s7/netty/Plc4XS7Protocol.java       | 136 +++++-
 .../java/s7/netty/util/S7PlcFieldHandler.java      | 480 +++++++++++++++++++++
 .../org/apache/plc4x/java/s7/types/S7DataType.java |  20 +-
 .../java/s7/netty/util/S7PlcFieldHandlerTest.java  | 349 +++++++++++++++
 18 files changed, 1063 insertions(+), 162 deletions(-)

diff --git a/examples/dummy-driver/src/main/java/org/apache/plc4x/java/examples/dummydriver/connection/DummyConnection.java b/examples/dummy-driver/src/main/java/org/apache/plc4x/java/examples/dummydriver/connection/DummyConnection.java
index 213ee3d..e8441cd 100644
--- a/examples/dummy-driver/src/main/java/org/apache/plc4x/java/examples/dummydriver/connection/DummyConnection.java
+++ b/examples/dummy-driver/src/main/java/org/apache/plc4x/java/examples/dummydriver/connection/DummyConnection.java
@@ -60,11 +60,6 @@ public class DummyConnection extends AbstractPlcConnection implements PlcReader,
     }
 
     @Override
-    public PlcField prepareField(String fieldString) {
-        return new DummyField(Integer.parseInt(fieldString));
-    }
-
-    @Override
     public PlcReadRequest.Builder readRequestBuilder() {
         // TODO: Implement this ...
         return null;
diff --git a/examples/kafka-bridge/src/main/java/org/apache/plc4x/java/examples/kafkabridge/KafkaBridge.java b/examples/kafka-bridge/src/main/java/org/apache/plc4x/java/examples/kafkabridge/KafkaBridge.java
index 2c8df14..5b62dbf 100644
--- a/examples/kafka-bridge/src/main/java/org/apache/plc4x/java/examples/kafkabridge/KafkaBridge.java
+++ b/examples/kafka-bridge/src/main/java/org/apache/plc4x/java/examples/kafkabridge/KafkaBridge.java
@@ -94,9 +94,9 @@ public class KafkaBridge {
         TStream<String> jsonSource = source.map(value -> {
             JsonObject jsonObject = new JsonObject();
             value.getFieldNames().forEach(fieldName -> {
-                if(value.getNumValues(fieldName) == 1) {
+                if(value.getNumberOfValues(fieldName) == 1) {
                     jsonObject.addProperty(fieldName, Byte.toString(value.getByte(fieldName)));
-                } else if (value.getNumValues(fieldName) > 1) {
+                } else if (value.getNumberOfValues(fieldName) > 1) {
                     JsonArray values = new JsonArray();
                     value.getAllBytes(fieldName).forEach(values::add);
                     jsonObject.add(fieldName, values);
diff --git a/integrations/apache-edgent/src/main/java/org/apache/plc4x/edgent/PlcConnectionAdapter.java b/integrations/apache-edgent/src/main/java/org/apache/plc4x/edgent/PlcConnectionAdapter.java
index 9e76e2a..483db03 100644
--- a/integrations/apache-edgent/src/main/java/org/apache/plc4x/edgent/PlcConnectionAdapter.java
+++ b/integrations/apache-edgent/src/main/java/org/apache/plc4x/edgent/PlcConnectionAdapter.java
@@ -160,9 +160,6 @@ public class PlcConnectionAdapter implements AutoCloseable {
                 PlcReadResponse readResponse = reader.read(readRequest).get();
                 Object value = null;
                 switch (clientDatatype) {
-                    case RAW:
-                        value = readResponse.getRaw(FIELD_NAME);
-                        break;
                     case OBJECT:
                         value = readResponse.getObject(FIELD_NAME);
                         break;
diff --git a/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/PlcConnectionAdapterTest.java b/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/PlcConnectionAdapterTest.java
index cd903f3..011b271 100644
--- a/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/PlcConnectionAdapterTest.java
+++ b/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/PlcConnectionAdapterTest.java
@@ -41,12 +41,6 @@ import org.apache.plc4x.edgent.mock.MockConnection;
 import org.apache.plc4x.java.PlcDriverManager;
 import org.apache.plc4x.java.api.exceptions.PlcConnectionException;
 import org.apache.plc4x.java.api.messages.PlcWriteResponse;
-import org.apache.plc4x.java.api.messages.items.PlcReadRequestItem;
-import org.apache.plc4x.java.api.messages.items.PlcWriteRequestItem;
-import org.apache.plc4x.java.api.messages.specific.TypeSafePlcReadRequest;
-import org.apache.plc4x.java.api.messages.specific.TypeSafePlcReadResponse;
-import org.apache.plc4x.java.api.messages.specific.TypeSafePlcWriteRequest;
-import org.apache.plc4x.java.api.messages.specific.TypeSafePlcWriteResponse;
 import org.apache.plc4x.java.api.model.PlcField;
 import org.apache.plc4x.test.FastTests;
 import org.junit.Test;
diff --git a/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/mock/MockConnection.java b/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/mock/MockConnection.java
index 0357bfd..71cd1a3 100644
--- a/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/mock/MockConnection.java
+++ b/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/mock/MockConnection.java
@@ -18,13 +18,11 @@ under the License.
 */
 package org.apache.plc4x.edgent.mock;
 
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
 import org.apache.plc4x.java.api.authentication.PlcAuthentication;
 import org.apache.plc4x.java.api.connection.PlcReader;
 import org.apache.plc4x.java.api.connection.PlcWriter;
@@ -35,12 +33,16 @@ import org.apache.plc4x.java.api.messages.PlcWriteRequest;
 import org.apache.plc4x.java.api.messages.PlcWriteResponse;
 import org.apache.plc4x.java.api.model.PlcField;
 import org.apache.plc4x.java.api.types.PlcResponseCode;
+import org.apache.plc4x.java.base.messages.DefaultPlcReadResponse;
+import org.apache.plc4x.java.base.messages.DefaultPlcWriteRequest;
+import org.apache.plc4x.java.base.messages.DefaultPlcWriteResponse;
+import org.apache.plc4x.java.base.messages.items.FieldItem;
 
 public class MockConnection extends org.apache.plc4x.java.base.connection.MockConnection implements PlcReader, PlcWriter {
 
     private final String url;
     private final PlcAuthentication authentication;
-    private final Map<PlcField, Object> dataValueMap = new HashMap<>();
+    private final Map<PlcField, FieldItem<Long>> dataValueMap = new HashMap<>();
     private long curReadCnt;
     private int readExceptionTriggerCount;
     private String readExceptionMsg;
@@ -65,11 +67,6 @@ public class MockConnection extends org.apache.plc4x.java.base.connection.MockCo
     }
 
     @Override
-    public PlcField prepareField(String fieldString) {
-        return new MockField(fieldString);
-    }
-
-    @Override
     public PlcReadRequest.Builder readRequestBuilder() {
         return null;
     }
@@ -83,22 +80,12 @@ public class MockConnection extends org.apache.plc4x.java.base.connection.MockCo
             cf.completeExceptionally(new PlcIoException(readExceptionMsg));
             return cf;
         }
-        List<PlcReadResponseItem<Object>> responseItems = new LinkedList<>();
-        for (PlcReadRequestItem<?> reqItem : readRequest.getRequestItems()) {
-            @SuppressWarnings("unchecked")
-            PlcReadRequestItem<Object> requestItem = reqItem;
-            PlcReadResponseItem<Object> responseItem = new PlcReadResponseItem<>(requestItem, PlcResponseCode.OK,
-                Collections.singletonList(getDataValue(requestItem.getField())));
-            responseItems.add(responseItem);
-        }
-        PlcReadResponse response;
-        if (readRequest instanceof TypeSafePlcReadRequest) {
-            @SuppressWarnings("unchecked")
-            TypeSafePlcReadRequest<Object> readReq = (TypeSafePlcReadRequest<Object>) readRequest;
-            response = new TypeSafePlcReadResponse<>(readReq, responseItems);
-        } else {
-            response = new PlcReadResponse(readRequest, responseItems);
+        Map<String, Pair<PlcResponseCode, FieldItem>> fields = new LinkedHashMap<>();
+        for (String fieldName : readRequest.getFieldNames()) {
+            PlcField field = readRequest.getField(fieldName);
+            fields.put(fieldName, new ImmutablePair<>(PlcResponseCode.OK, getFieldItem(field)));
         }
+        PlcReadResponse response = new DefaultPlcReadResponse(readRequest, fields);
         return CompletableFuture.completedFuture(response);
     }
 
@@ -110,6 +97,7 @@ public class MockConnection extends org.apache.plc4x.java.base.connection.MockCo
     @SuppressWarnings("unchecked")
     @Override
     public CompletableFuture<PlcWriteResponse> write(PlcWriteRequest writeRequest) {
+        DefaultPlcWriteRequest defaultPlcWriteRequest = (DefaultPlcWriteRequest) writeRequest;
         curWriteCnt++;
         if (writeExceptionTriggerCount > 0 && curWriteCnt == writeExceptionTriggerCount) {
             curWriteCnt = 0;
@@ -117,37 +105,30 @@ public class MockConnection extends org.apache.plc4x.java.base.connection.MockCo
             cf.completeExceptionally(new PlcIoException(writeExceptionMsg));
             return cf;
         }
-        List<PlcWriteResponseItem<Object>> responseItems = new LinkedList<>();
-        for (PlcWriteRequestItem<?> reqItem : writeRequest.getRequestItems()) {
-            PlcWriteRequestItem<Object> requestItem = reqItem;
-            setDataValue(requestItem.getField(), requestItem.getValues());
-            PlcWriteResponseItem<Object> responseItem = new PlcWriteResponseItem<>(requestItem, PlcResponseCode.OK);
-            responseItems.add(responseItem);
-        }
-        PlcWriteResponse response;
-        if (writeRequest instanceof TypeSafePlcWriteRequest) {
-            TypeSafePlcWriteRequest<Object> writeReq = (TypeSafePlcWriteRequest<Object>) writeRequest;
-            response = new TypeSafePlcWriteResponse<>(writeReq, responseItems);
-        } else {
-            response = new PlcWriteResponse(writeRequest, responseItems);
+        Map<String, PlcResponseCode> fields = new LinkedHashMap<>();
+        for (String fieldName : defaultPlcWriteRequest.getFieldNames()) {
+            PlcField field = defaultPlcWriteRequest.getField(fieldName);
+            setFieldItem(field, defaultPlcWriteRequest.getFieldItem(fieldName));
+            fields.put(fieldName, PlcResponseCode.OK);
         }
+        PlcWriteResponse response = new DefaultPlcWriteResponse(defaultPlcWriteRequest, fields);
 
         return CompletableFuture.completedFuture(response);
     }
 
-    public void setDataValue(PlcField field, Object o) {
-        dataValueMap.put(field, o);
+    public void setFieldItem(PlcField field, FieldItem<Long> fieldItem) {
+        dataValueMap.put(field, fieldItem);
     }
 
-    public Object getDataValue(PlcField field) {
+    public FieldItem<Long> getFieldItem(PlcField field) {
         return dataValueMap.get(field);
     }
 
-    public Map<PlcField, Object> getAllDataValues() {
+    public Map<PlcField, FieldItem<Long>> getAllFieldItems() {
         return dataValueMap;
     }
 
-    public void clearAllDataValues() {
+    public void clearAllFieldItems() {
         dataValueMap.clear();
     }
 
diff --git a/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/mock/MockField.java b/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/mock/MockField.java
index c735c58..a8ea04a 100644
--- a/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/mock/MockField.java
+++ b/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/mock/MockField.java
@@ -39,9 +39,8 @@ public class MockField implements PlcField {
   
   @Override
   public boolean equals(Object o) {
-    return o != null
-        && o instanceof MockField
-        && ((MockField)o).address.equals(this.address);
+    return o instanceof MockField
+        && ((MockField) o).address.equals(this.address);
   }
 
   @Override
diff --git a/plc4j/api/src/main/java/org/apache/plc4x/java/api/messages/PlcReadResponse.java b/plc4j/api/src/main/java/org/apache/plc4x/java/api/messages/PlcReadResponse.java
index 661e04f..fa3f35c 100644
--- a/plc4j/api/src/main/java/org/apache/plc4x/java/api/messages/PlcReadResponse.java
+++ b/plc4j/api/src/main/java/org/apache/plc4x/java/api/messages/PlcReadResponse.java
@@ -28,7 +28,7 @@ import java.util.Collection;
  */
 public interface PlcReadResponse extends PlcFieldResponse<PlcReadRequest> {
 
-    int getNumValues(String name);
+    int getNumberOfValues(String name);
 
     boolean isValidObject(String name);
     boolean isValidObject(String name, int index);
diff --git a/plc4j/api/src/main/java/org/apache/plc4x/java/api/messages/PlcWriteRequest.java b/plc4j/api/src/main/java/org/apache/plc4x/java/api/messages/PlcWriteRequest.java
index 7d3985c..a53d421 100644
--- a/plc4j/api/src/main/java/org/apache/plc4x/java/api/messages/PlcWriteRequest.java
+++ b/plc4j/api/src/main/java/org/apache/plc4x/java/api/messages/PlcWriteRequest.java
@@ -24,16 +24,10 @@ import java.time.LocalTime;
 
 public interface PlcWriteRequest extends PlcFieldRequest {
 
-    int getNumValues(String name);
-
-    byte[][] getValues(String name);
+    int getNumberOfValues(String name);
 
     interface Builder extends PlcMessageBuilder<PlcWriteRequest> {
 
-        PlcWriteRequest.Builder addItem(String name, String fieldQuery, byte[]... values);
-
-        PlcWriteRequest.Builder addItem(String name, String fieldQuery, Object... values);
-
         PlcWriteRequest.Builder addItem(String name, String fieldQuery, Boolean... values);
 
         PlcWriteRequest.Builder addItem(String name, String fieldQuery, Byte... values);
diff --git a/plc4j/api/src/main/java/org/apache/plc4x/java/api/types/PlcClientDatatype.java b/plc4j/api/src/main/java/org/apache/plc4x/java/api/types/PlcClientDatatype.java
index 0c66bc0..ed36ad5 100644
--- a/plc4j/api/src/main/java/org/apache/plc4x/java/api/types/PlcClientDatatype.java
+++ b/plc4j/api/src/main/java/org/apache/plc4x/java/api/types/PlcClientDatatype.java
@@ -20,8 +20,6 @@ package org.apache.plc4x.java.api.types;
 
 public enum PlcClientDatatype {
 
-    RAW,
-    OBJECT,
     BOOLEAN,
     BYTE,
     SHORT,
diff --git a/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/connection/PlcFieldHandler.java b/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/connection/PlcFieldHandler.java
index 7bfc80b..d400b5b 100644
--- a/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/connection/PlcFieldHandler.java
+++ b/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/connection/PlcFieldHandler.java
@@ -20,13 +20,32 @@ package org.apache.plc4x.java.base.connection;
 
 import org.apache.plc4x.java.api.exceptions.PlcInvalidFieldException;
 import org.apache.plc4x.java.api.model.PlcField;
-import org.apache.plc4x.java.api.types.PlcClientDatatype;
+import org.apache.plc4x.java.base.messages.items.FieldItem;
 
 public interface PlcFieldHandler {
 
     PlcField createField(String fieldQuery) throws PlcInvalidFieldException;
 
-    byte[][] encode(PlcField field, PlcClientDatatype clientDatatype, Object[] values);
-    Object[] decode(PlcField field, PlcClientDatatype clientDatatype, byte[][] rawData);
+    FieldItem encodeBoolean(PlcField field, Object[] values);
+
+    FieldItem encodeByte(PlcField field, Object[] values);
+
+    FieldItem encodeShort(PlcField field, Object[] values);
+
+    FieldItem encodeInteger(PlcField field, Object[] values);
+
+    FieldItem encodeLong(PlcField field, Object[] values);
+
+    FieldItem encodeFloat(PlcField field, Object[] values);
+
+    FieldItem encodeDouble(PlcField field, Object[] values);
+
+    FieldItem encodeString(PlcField field, Object[] values);
+
+    FieldItem encodeTime(PlcField field, Object[] values);
+
+    FieldItem encodeDate(PlcField field, Object[] values);
+
+    FieldItem encodeDateTime(PlcField field, Object[] values);
 
 }
diff --git a/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/messages/DefaultPlcReadResponse.java b/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/messages/DefaultPlcReadResponse.java
index 7843634..90654f8 100644
--- a/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/messages/DefaultPlcReadResponse.java
+++ b/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/messages/DefaultPlcReadResponse.java
@@ -46,7 +46,7 @@ public class DefaultPlcReadResponse implements PlcReadResponse {
     }
 
     @Override
-    public int getNumValues(String name) {
+    public int getNumberOfValues(String name) {
         FieldItem fieldInternal = getFieldInternal(name);
         if(fieldInternal != null) {
             return fieldInternal.getNumValues();
diff --git a/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/messages/DefaultPlcWriteRequest.java b/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/messages/DefaultPlcWriteRequest.java
index c5d2c4b..a97386b 100644
--- a/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/messages/DefaultPlcWriteRequest.java
+++ b/plc4j/protocols/driver-bases/base/src/main/java/org/apache/plc4x/java/base/messages/DefaultPlcWriteRequest.java
@@ -23,19 +23,20 @@ import org.apache.commons.lang3.tuple.Pair;
 import org.apache.plc4x.java.api.exceptions.PlcRuntimeException;
 import org.apache.plc4x.java.api.messages.PlcWriteRequest;
 import org.apache.plc4x.java.api.model.PlcField;
-import org.apache.plc4x.java.api.types.PlcClientDatatype;
 import org.apache.plc4x.java.base.connection.PlcFieldHandler;
+import org.apache.plc4x.java.base.messages.items.FieldItem;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.util.*;
+import java.util.function.BiFunction;
 
 public class DefaultPlcWriteRequest implements PlcWriteRequest {
 
-    private final LinkedHashMap<String, Pair<PlcField, byte[][]>> fields;
+    private final LinkedHashMap<String, Pair<PlcField, FieldItem>> fields;
 
-    private DefaultPlcWriteRequest(LinkedHashMap<String, Pair<PlcField, byte[][]>> fields) {
+    private DefaultPlcWriteRequest(LinkedHashMap<String, Pair<PlcField, FieldItem>> fields) {
         this.fields = fields;
     }
 
@@ -55,20 +56,19 @@ public class DefaultPlcWriteRequest implements PlcWriteRequest {
         return fields.get(name).getKey();
     }
 
-    @Override
-    public byte[][] getValues(String name) {
+    public FieldItem getFieldItem(String name) {
         return fields.get(name).getValue();
     }
 
     @Override
-    public int getNumValues(String name) {
-        return fields.get(name).getValue().length;
+    public int getNumberOfValues(String name) {
+        return fields.get(name).getValue().getNumValues();
     }
 
     public static class Builder implements PlcWriteRequest.Builder {
 
         private final PlcFieldHandler fieldHandler;
-        private final Map<String, BuilderItem> fields;
+        private final Map<String, BuilderItem<Object>> fields;
 
         public Builder(PlcFieldHandler fieldHandler) {
             this.fieldHandler = fieldHandler;
@@ -76,103 +76,91 @@ public class DefaultPlcWriteRequest implements PlcWriteRequest {
         }
 
         @Override
-        public PlcWriteRequest.Builder addItem(String name, String fieldQuery, byte[]... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.RAW);
-        }
-
-        @Override
-        public PlcWriteRequest.Builder addItem(String name, String fieldQuery, Object... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.OBJECT);
-        }
-
-        @Override
         public Builder addItem(String name, String fieldQuery, Boolean... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.BOOLEAN);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeBoolean);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, Byte... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.BYTE);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeByte);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, Short... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.SHORT);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeShort);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, Integer... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.INTEGER);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeInteger);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, Long... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.LONG);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeLong);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, Float... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.FLOAT);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeFloat);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, Double... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.DOUBLE);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeDouble);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, String... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.STRING);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeString);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, LocalTime... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.TIME);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeTime);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, LocalDate... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.DATE);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeDate);
         }
 
         @Override
         public Builder addItem(String name, String fieldQuery, LocalDateTime... values) {
-            return addItem(name, fieldQuery, values, PlcClientDatatype.DATE_TIME);
+            return addItem(name, fieldQuery, values, fieldHandler::encodeDateTime);
         }
 
         @Override
         public PlcWriteRequest build() {
-            LinkedHashMap<String, Pair<PlcField, byte[][]>> parsedFields = new LinkedHashMap<>();
+            LinkedHashMap<String, Pair<PlcField, FieldItem>> parsedFields = new LinkedHashMap<>();
             fields.forEach((name, builderItem) -> {
                 // Compile the query string.
                 PlcField parsedField = fieldHandler.createField(builderItem.fieldQuery);
                 // Encode the payload.
-                byte[][] rawData = fieldHandler.encode(parsedField, builderItem.clientDatatype, builderItem.values);
-                parsedFields.put(name, new ImmutablePair<>(parsedField, rawData));
+                // TODO: Depending on the field type, handle the FieldItem creation differently.
+                FieldItem fieldItem = builderItem.encoder.apply(parsedField, builderItem.values);
+                parsedFields.put(name, new ImmutablePair<>(parsedField, fieldItem));
             });
             return new DefaultPlcWriteRequest(parsedFields);
         }
 
-        private Builder addItem(String name, String fieldQuery, Object[] values, PlcClientDatatype clientDatatype) {
+        private Builder addItem(String name, String fieldQuery, Object[] values, BiFunction<PlcField, Object[], FieldItem> encoder) {
             if(fields.containsKey(name)) {
                 throw new PlcRuntimeException("Duplicate field definition '" + name + "'");
             }
-            fields.put(name, new BuilderItem(fieldQuery, clientDatatype, values));
+            fields.put(name, new BuilderItem<>(fieldQuery, values, encoder));
             return this;
         }
 
-        private static class BuilderItem {
-
+        private static class BuilderItem<T> {
             private final String fieldQuery;
-            private final PlcClientDatatype clientDatatype;
-            private final Object[] values;
-
-            private BuilderItem(String fieldQuery, PlcClientDatatype clientDatatype, Object[] values) {
+            private final T[] values;
+            private final BiFunction<PlcField, T[], FieldItem> encoder;
+            private BuilderItem(String fieldQuery, T[] values, BiFunction<PlcField, T[], FieldItem> encoder) {
                 this.fieldQuery = fieldQuery;
-                this.clientDatatype = clientDatatype;
                 this.values = values;
+                this.encoder = encoder;
             }
-
         }
 
     }
diff --git a/plc4j/protocols/pom.xml b/plc4j/protocols/pom.xml
index 0fca4a1..7e53016 100644
--- a/plc4j/protocols/pom.xml
+++ b/plc4j/protocols/pom.xml
@@ -37,9 +37,9 @@
   <modules>
     <module>driver-bases</module>
 
-    <module>ads</module>
+    <!--module>ads</module>
     <module>ethernetip</module>
-    <module>modbus</module>
+    <module>modbus</module-->
     <module>s7</module>
 
     <module>benchmarks</module>
diff --git a/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/connection/S7PlcConnection.java b/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/connection/S7PlcConnection.java
index 6025358..2b61210 100644
--- a/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/connection/S7PlcConnection.java
+++ b/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/connection/S7PlcConnection.java
@@ -21,21 +21,16 @@ package org.apache.plc4x.java.s7.connection;
 import io.netty.channel.*;
 import org.apache.commons.configuration2.Configuration;
 import org.apache.commons.configuration2.SystemConfiguration;
-import org.apache.commons.lang3.NotImplementedException;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.plc4x.java.api.connection.PlcReader;
 import org.apache.plc4x.java.api.connection.PlcWriter;
 import org.apache.plc4x.java.api.exceptions.PlcConnectionException;
-import org.apache.plc4x.java.api.exceptions.PlcInvalidFieldException;
 import org.apache.plc4x.java.api.messages.PlcReadRequest;
 import org.apache.plc4x.java.api.messages.PlcReadResponse;
 import org.apache.plc4x.java.api.messages.PlcWriteRequest;
 import org.apache.plc4x.java.api.messages.PlcWriteResponse;
-import org.apache.plc4x.java.api.model.PlcField;
-import org.apache.plc4x.java.api.types.PlcClientDatatype;
 import org.apache.plc4x.java.base.connection.AbstractPlcConnection;
 import org.apache.plc4x.java.base.connection.ChannelFactory;
-import org.apache.plc4x.java.base.connection.PlcFieldHandler;
 import org.apache.plc4x.java.base.connection.TcpSocketChannelFactory;
 import org.apache.plc4x.java.base.events.ConnectEvent;
 import org.apache.plc4x.java.base.events.ConnectedEvent;
@@ -48,10 +43,10 @@ import org.apache.plc4x.java.isotp.netty.model.tpdus.DisconnectRequestTpdu;
 import org.apache.plc4x.java.isotp.netty.model.types.DeviceGroup;
 import org.apache.plc4x.java.isotp.netty.model.types.DisconnectReason;
 import org.apache.plc4x.java.isotp.netty.model.types.TpduSize;
-import org.apache.plc4x.java.s7.model.S7Field;
 import org.apache.plc4x.java.s7.netty.Plc4XS7Protocol;
 import org.apache.plc4x.java.s7.netty.S7Protocol;
 import org.apache.plc4x.java.s7.netty.model.types.MemoryArea;
+import org.apache.plc4x.java.s7.netty.util.S7PlcFieldHandler;
 import org.apache.plc4x.java.s7.utils.S7TsapIdEncoder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -81,7 +76,7 @@ import java.util.concurrent.TimeoutException;
  * where the {bit-offset} is optional.
  * All Available Memory Areas for this mode are defined in the {@link MemoryArea} enum.
  */
-public class S7PlcConnection extends AbstractPlcConnection implements PlcReader, PlcWriter, PlcFieldHandler {
+public class S7PlcConnection extends AbstractPlcConnection implements PlcReader, PlcWriter {
 
     private static final int ISO_ON_TCP_PORT = 102;
 
@@ -244,28 +239,8 @@ public class S7PlcConnection extends AbstractPlcConnection implements PlcReader,
     }
 
     @Override
-    public PlcField createField(String fieldQuery) throws PlcInvalidFieldException {
-        if(S7Field.matches(fieldQuery)) {
-            return S7Field.of(fieldQuery);
-        }
-        throw new PlcInvalidFieldException(fieldQuery);
-    }
-
-    @Override
-    public byte[][] encode(PlcField field, PlcClientDatatype clientDatatype, Object[] values) {
-        // TODO: Implement this ...
-        throw new NotImplementedException("Not implemented ...");
-    }
-
-    @Override
-    public Object[] decode(PlcField field, PlcClientDatatype clientDatatype, byte[][] rawData) {
-        // TODO: Implement this ...
-        throw new NotImplementedException("Not implemented ...");
-    }
-
-    @Override
     public PlcReadRequest.Builder readRequestBuilder() {
-        return new DefaultPlcReadRequest.DefaultPlcReadRequestBuilder(this);
+        return new DefaultPlcReadRequest.DefaultPlcReadRequestBuilder(new S7PlcFieldHandler());
     }
 
     @Override
@@ -281,7 +256,7 @@ public class S7PlcConnection extends AbstractPlcConnection implements PlcReader,
 
     @Override
     public PlcWriteRequest.Builder writeRequestBuilder() {
-        return new DefaultPlcWriteRequest.Builder(this);
+        return new DefaultPlcWriteRequest.Builder(new S7PlcFieldHandler());
     }
 
     @Override
diff --git a/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/netty/Plc4XS7Protocol.java b/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/netty/Plc4XS7Protocol.java
index 50cdf83..6f1fab8 100644
--- a/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/netty/Plc4XS7Protocol.java
+++ b/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/netty/Plc4XS7Protocol.java
@@ -185,7 +185,7 @@ public class Plc4XS7Protocol extends PlcMessageToMessageCodec<S7Message, PlcRequ
 
             // The number of elements provided in the request must match the number defined in the field, or
             // bad things are going to happen.
-            if(writeRequest.getNumValues(fieldName) != s7Field.getNumElements()) {
+            if(writeRequest.getNumberOfValues(fieldName) != s7Field.getNumElements()) {
                 throw new PlcException("The number of values provided doesn't match the number specified by the field.");
             }
             VarParameterItem varParameterItem = new S7AnyVarParameterItem(
@@ -197,11 +197,143 @@ public class Plc4XS7Protocol extends PlcMessageToMessageCodec<S7Message, PlcRequ
             DataTransportSize dataTransportSize = s7Field.getDataType().getDataTransportSize();
 
             // TODO: Checkout if the payload items are sort of a flatMap of all request items.
+            byte[] byteData;
+            /*switch(s7Field.getDataType()) {
+                // -----------------------------------------
+                // Bit
+                // -----------------------------------------
+                case BOOL: {
+                    if()
+                    byte byteValue = data.readByte();
+                    fieldItem = new BooleanFieldItem(byteValue != 0x00);
+                    break;
+                }
+                // -----------------------------------------
+                // Bit-strings
+                // -----------------------------------------
+                case BYTE: { // 1 byte
+                    Long longValue = (long) data.readByte();
+                    // TODO: Implement this ...
+                    break;
+                }
+                case WORD: { // 2 byte (16 bit)
+                    Long longValue = (long) data.readShort();
+                    // TODO: Implement this ...
+                    break;
+                }
+                case DWORD: { // 4 byte (32 bit)
+                    Long longValue = (long) data.readInt();
+                    // TODO: Implement this ...
+                    break;
+                }
+                case LWORD: { // 8 byte (64 bit)
+                    Long longValue = data.readLong();
+                    // TODO: Implement this ...
+                    break;
+                }
+                // -----------------------------------------
+                // Integers
+                // -----------------------------------------
+                // 8 bit:
+                case SINT: {
+                    Long longValue = (long) data.readShort();
+                    fieldItem = new IntegerFieldItem(longValue);
+                    break;
+                }
+                case USINT: {
+                    Long longValue = (long) data.readUnsignedShort();
+                    fieldItem = new IntegerFieldItem(longValue);
+                    break;
+                }
+                // 16 bit:
+                case INT: {
+                    Long longValue = (long) data.readInt();
+                    fieldItem = new IntegerFieldItem(longValue);
+                    break;
+                }
+                case UINT: {
+                    Long longValue = data.readUnsignedInt();
+                    fieldItem = new IntegerFieldItem(longValue);
+                    break;
+                }
+                // 32 bit:
+                case DINT: {
+                    Long longValue = data.readLong();
+                    fieldItem = new IntegerFieldItem(longValue);
+                    break;
+                }
+
+                case UDINT: {
+                    BigInteger bigIntegerValue = readUnsignedLong(data);
+                    fieldItem = new BigIntegerFieldItem(bigIntegerValue);
+                    break;
+                }
+                // 64 bit:
+                case LINT: {
+                    BigInteger bigIntegerValue = readSigned64BitInteger(data);
+                    fieldItem = new BigIntegerFieldItem(bigIntegerValue);
+                    break;
+                }
+                case ULINT: {
+                    BigInteger bigIntegerValue = readUnsigned64BitInteger(data);
+                    fieldItem = new BigIntegerFieldItem(bigIntegerValue);
+                    break;
+                }
+                // -----------------------------------------
+                // Floating point values
+                // -----------------------------------------
+                case REAL: {
+                    double doubleValue = data.readFloat();
+                    fieldItem = new FloatingPointFieldItem(doubleValue);
+                    break;
+                }
+                case LREAL: {
+                    double doubleValue = data.readDouble();
+                    fieldItem = new FloatingPointFieldItem(doubleValue);
+                    break;
+                }
+                // -----------------------------------------
+                // Characters & Strings
+                // -----------------------------------------
+                case CHAR: { // 1 byte (8 bit)
+                    // TODO: Double check, if this is ok?
+                    String stringValue = data.readCharSequence(1, Charset.forName("UTF-8")).toString();
+                    fieldItem = new StringFieldItem(stringValue);
+                    break;
+                }
+                case WCHAR: { // 2 byte
+                    // TODO: Double check, if this is ok?
+                    String stringValue = data.readCharSequence(2, Charset.forName("UTF-16")).toString();
+                    fieldItem = new StringFieldItem(stringValue);
+                    break;
+                }
+                case STRING: {
+                    // Max length ... ignored.
+                    data.readByte();
+                    byte actualLength = data.readByte();
+                    // TODO: Double check, if this is ok?
+                    String stringValue = data.readCharSequence(actualLength, Charset.forName("UTF-8")).toString();
+                    fieldItem = new StringFieldItem(stringValue);
+                    break;
+                }
+                case WSTRING: {
+                    // Max length ... ignored.
+                    data.readByte();
+                    byte actualLength = data.readByte();
+                    // TODO: Double check, if this is ok?
+                    String stringValue = data.readCharSequence(
+                        actualLength * 2, Charset.forName("UTF-16")).toString();
+                    fieldItem = new StringFieldItem(stringValue);
+                    break;
+                }
+                default:
+                    throw new PlcProtocolException("Unsupported type " + field.getDataType());
+            }
 
             VarPayloadItem varPayloadItem = new VarPayloadItem(
                 DataTransportErrorCode.RESERVED, dataTransportSize, writeRequest.getValues(fieldName)[0]);
 
-            payloadItems.add(varPayloadItem);
+            payloadItems.add(varPayloadItem);*/
         }
         VarParameter writeVarParameter = new VarParameter(ParameterType.WRITE_VAR, parameterItems);
         VarPayload writeVarPayload = new VarPayload(ParameterType.WRITE_VAR, payloadItems);
diff --git a/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/netty/util/S7PlcFieldHandler.java b/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/netty/util/S7PlcFieldHandler.java
new file mode 100644
index 0000000..d8dc40e
--- /dev/null
+++ b/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/netty/util/S7PlcFieldHandler.java
@@ -0,0 +1,480 @@
+/*
+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.s7.netty.util;
+
+import org.apache.plc4x.java.api.exceptions.PlcInvalidFieldException;
+import org.apache.plc4x.java.api.exceptions.PlcRuntimeException;
+import org.apache.plc4x.java.api.model.PlcField;
+import org.apache.plc4x.java.base.connection.PlcFieldHandler;
+import org.apache.plc4x.java.base.messages.items.*;
+import org.apache.plc4x.java.s7.model.S7Field;
+import org.apache.plc4x.java.s7.types.S7DataType;
+
+import java.math.BigInteger;
+import java.nio.charset.Charset;
+import java.util.BitSet;
+import java.util.LinkedList;
+import java.util.List;
+
+public class S7PlcFieldHandler implements PlcFieldHandler {
+
+    @Override
+    public PlcField createField(String fieldQuery) throws PlcInvalidFieldException {
+        if(S7Field.matches(fieldQuery)) {
+            return S7Field.of(fieldQuery);
+        }
+        throw new PlcInvalidFieldException(fieldQuery);
+    }
+
+    @Override
+    public FieldItem encodeBoolean(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        // All of these types are declared as Bit or Bit-String types.
+        if((s7Field.getDataType() == S7DataType.BOOL) || (s7Field.getDataType() == S7DataType.BYTE) ||
+            (s7Field.getDataType() == S7DataType.WORD) || (s7Field.getDataType() == S7DataType.DWORD) ||
+            (s7Field.getDataType() == S7DataType.LWORD)) {
+            return internalEncodeBoolean(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeByte(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if((s7Field.getDataType() == S7DataType.BYTE) || (s7Field.getDataType() == S7DataType.SINT) ||
+            (s7Field.getDataType() == S7DataType.USINT) || (s7Field.getDataType() == S7DataType.CHAR)) {
+            return internalEncodeInteger(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeShort(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if((s7Field.getDataType() == S7DataType.WORD) || (s7Field.getDataType() == S7DataType.INT) ||
+            (s7Field.getDataType() == S7DataType.UINT)) {
+            return internalEncodeInteger(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeInteger(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if((s7Field.getDataType() == S7DataType.DWORD) || (s7Field.getDataType() == S7DataType.DINT) ||
+            (s7Field.getDataType() == S7DataType.UDINT)) {
+            return internalEncodeInteger(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeLong(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if((s7Field.getDataType() == S7DataType.LWORD) || (s7Field.getDataType() == S7DataType.LINT) ||
+            (s7Field.getDataType() == S7DataType.ULINT)) {
+            return internalEncodeInteger(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeFloat(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if(s7Field.getDataType() == S7DataType.REAL) {
+            return internalEncodeFloatingPoint(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeDouble(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if(s7Field.getDataType() == S7DataType.LREAL) {
+            return internalEncodeFloatingPoint(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeString(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if((s7Field.getDataType() == S7DataType.CHAR) || (s7Field.getDataType() == S7DataType.WCHAR) ||
+            (s7Field.getDataType() == S7DataType.STRING) || (s7Field.getDataType() == S7DataType.WSTRING)) {
+            return internalEncodeString(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeTime(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if(s7Field.getDataType() == S7DataType.TIME) {
+            return internalEncodeTemporal(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeDate(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if(s7Field.getDataType() == S7DataType.DATE) {
+            return internalEncodeTemporal(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    @Override
+    public FieldItem encodeDateTime(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        if(s7Field.getDataType() == S7DataType.DATE_AND_TIME) {
+            return internalEncodeTemporal(field, values);
+        }
+        throw new PlcRuntimeException("Invalid encoder for type " + s7Field.getDataType().name());
+    }
+
+    private FieldItem internalEncodeBoolean(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        switch (s7Field.getDataType()) {
+            case BOOL:
+            case BYTE:
+            case WORD:
+            case DWORD:
+            case LWORD:
+                break;
+            default:
+                throw new IllegalArgumentException(
+                    "Cannot assign boolean values to " + s7Field.getDataType().name() + " fields.");
+        }
+        List<Boolean> booleanValues = new LinkedList<>();
+        for (Object value : values) {
+            if(value instanceof Boolean) {
+                Boolean booleanValue = (Boolean) value;
+                booleanValues.add(booleanValue);
+            } else if(value instanceof Byte) {
+                Byte byteValue = (Byte) value;
+                BitSet bitSet = BitSet.valueOf(new byte[]{byteValue});
+                for(int i = 0; i < 8; i++) {
+                    booleanValues.add(bitSet.get(i));
+                }
+            } else if(value instanceof Short) {
+                Short shortValue = (Short) value;
+                BitSet bitSet = BitSet.valueOf(new long[]{shortValue});
+                for(int i = 0; i < 16; i++) {
+                    booleanValues.add(bitSet.get(i));
+                }
+            } else if(value instanceof Integer) {
+                Integer integerValue = (Integer) value;
+                BitSet bitSet = BitSet.valueOf(new long[]{integerValue});
+                for(int i = 0; i < 32; i++) {
+                    booleanValues.add(bitSet.get(i));
+                }
+            } else if(value instanceof Long) {
+                long longValue = (Long) value;
+                BitSet bitSet = BitSet.valueOf(new long[]{longValue});
+                for(int i = 0; i < 64; i++) {
+                    booleanValues.add(bitSet.get(i));
+                }
+            } else {
+                throw new IllegalArgumentException(
+                    "Value of type " + value.getClass().getName() +
+                        " is not assignable to " + s7Field.getDataType().name() + " fields.");
+            }
+        }
+        return new BooleanFieldItem(booleanValues.toArray(new Boolean[0]));
+    }
+
+    private FieldItem internalEncodeInteger(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        BigInteger minValue;
+        BigInteger maxValue;
+        Class<? extends FieldItem> fieldType;
+        switch (s7Field.getDataType()) {
+            case BYTE:
+                minValue = BigInteger.valueOf((long) Byte.MIN_VALUE);
+                maxValue = BigInteger.valueOf((long) Byte.MAX_VALUE);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case WORD:
+                minValue = BigInteger.valueOf((long) Short.MIN_VALUE);
+                maxValue = BigInteger.valueOf((long) Short.MAX_VALUE);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case DWORD:
+                minValue = BigInteger.valueOf((long) Integer.MIN_VALUE);
+                maxValue = BigInteger.valueOf((long) Integer.MAX_VALUE);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case LWORD:
+                minValue = BigInteger.valueOf(Long.MIN_VALUE);
+                maxValue = BigInteger.valueOf(Long.MAX_VALUE);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case SINT:
+                minValue = BigInteger.valueOf((long) Byte.MIN_VALUE);
+                maxValue = BigInteger.valueOf((long) Byte.MAX_VALUE);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case USINT:
+                minValue = BigInteger.valueOf((long) 0);
+                maxValue = BigInteger.valueOf((long) Byte.MAX_VALUE * 2);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case INT:
+                minValue = BigInteger.valueOf((long) Short.MIN_VALUE);
+                maxValue = BigInteger.valueOf((long) Short.MAX_VALUE);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case UINT:
+                minValue = BigInteger.valueOf((long) 0);
+                maxValue = BigInteger.valueOf(((long) Short.MAX_VALUE) * 2);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case DINT:
+                minValue = BigInteger.valueOf((long) Integer.MIN_VALUE);
+                maxValue = BigInteger.valueOf((long) Integer.MAX_VALUE);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case UDINT:
+                minValue = BigInteger.valueOf((long) 0);
+                maxValue = BigInteger.valueOf(((long) Integer.MAX_VALUE) * 2);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case LINT:
+                minValue = BigInteger.valueOf(Long.MIN_VALUE);
+                maxValue = BigInteger.valueOf(Long.MAX_VALUE);
+                fieldType = IntegerFieldItem.class;
+                break;
+            case ULINT:
+                minValue = BigInteger.valueOf((long) 0);
+                maxValue = BigInteger.valueOf(Long.MAX_VALUE).multiply(BigInteger.valueOf((long) 2));
+                fieldType = BigIntegerFieldItem.class;
+                break;
+            default:
+                throw new IllegalArgumentException(
+                    "Cannot assign integer values to " + s7Field.getDataType().name() + " fields.");
+        }
+        if(fieldType == IntegerFieldItem.class) {
+            Long[] longValues = new Long[values.length];
+            for (int i = 0; i < values.length; i++) {
+                if(!((values[i] instanceof Byte) || (values[i] instanceof Short) ||
+                    (values[i] instanceof Integer) || (values[i] instanceof Long))) {
+                    throw new IllegalArgumentException(
+                        "Value of type " + values[i].getClass().getName() +
+                            " is not assignable to " + s7Field.getDataType().name() + " fields.");
+                }
+                BigInteger value = BigInteger.valueOf(((Number) values[i]).longValue());
+                if(minValue.compareTo(value) > 0) {
+                    throw new IllegalArgumentException(
+                        "Value of " + value.toString() + " exceeds allowed minimum for type "
+                            + s7Field.getDataType().name() + " (min " + minValue.toString() + ")");
+                }
+                if(maxValue.compareTo(value) < 0) {
+                    throw new IllegalArgumentException(
+                        "Value of " + value.toString() + " exceeds allowed maximum for type "
+                            + s7Field.getDataType().name() + " (max " + maxValue.toString() + ")");
+                }
+                longValues[i] = value.longValue();
+            }
+            return new IntegerFieldItem(longValues);
+        } else {
+            BigInteger[] bigIntegerValues = new BigInteger[values.length];
+            for (int i = 0; i < values.length; i++) {
+                BigInteger value;
+                if(values[i] instanceof BigInteger) {
+                    value = (BigInteger) values[i];
+                } else if(((values[i] instanceof Byte) || (values[i] instanceof Short) ||
+                    (values[i] instanceof Integer) || (values[i] instanceof Long))) {
+                    value = BigInteger.valueOf(((Number) values[i]).longValue());
+                } else {
+                    throw new IllegalArgumentException(
+                        "Value of type " + values[i].getClass().getName() +
+                            " is not assignable to " + s7Field.getDataType().name() + " fields.");
+                }
+                if(minValue.compareTo(value) > 0) {
+                    throw new IllegalArgumentException(
+                        "Value of " + value.toString() + " exceeds allowed minimum for type "
+                            + s7Field.getDataType().name() + " (min " + minValue.toString() + ")");
+                }
+                if(maxValue.compareTo(value) < 0) {
+                    throw new IllegalArgumentException(
+                        "Value of " + value.toString() + " exceeds allowed maximum for type "
+                            + s7Field.getDataType().name() + " (max " + maxValue.toString() + ")");
+                }
+                bigIntegerValues[i] = value;
+            }
+            return new BigIntegerFieldItem(bigIntegerValues);
+        }
+    }
+
+    private FieldItem internalEncodeFloatingPoint(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        Double minValue;
+        Double maxValue;
+        switch (s7Field.getDataType()) {
+            case REAL:
+                // Yes this is actually correct, if I set min to Float.MIN_VALUE (0.0 < Float.MIN_VALUE = true)
+                minValue = (double) -Float.MAX_VALUE;
+                maxValue = (double) Float.MAX_VALUE;
+                break;
+            case LREAL:
+                // Yes this is actually correct, if I set min to Double.MIN_VALUE (0.0 < Double.MIN_VALUE = true)
+                minValue = -Double.MAX_VALUE;
+                maxValue = Double.MAX_VALUE;
+                break;
+            default:
+                throw new IllegalArgumentException(
+                    "Cannot assign floating point values to " + s7Field.getDataType().name() + " fields.");
+        }
+        Double[] floatingPointValues = new Double[values.length];
+        for (int i = 0; i < values.length; i++) {
+            if(values[i] instanceof Float) {
+                floatingPointValues[i] = ((Float) values[i]).doubleValue();
+            } else if(values[i] instanceof Double) {
+                floatingPointValues[i] = (Double) values[i];
+            } else {
+                throw new IllegalArgumentException(
+                    "Value of type " + values[i].getClass().getName() +
+                        " is not assignable to " + s7Field.getDataType().name() + " fields.");
+            }
+            if(floatingPointValues[i] < minValue) {
+                throw new IllegalArgumentException(
+                    "Value of " + floatingPointValues[i] + " exceeds allowed minimum for type "
+                        + s7Field.getDataType().name() + " (min " + minValue.toString() + ")");
+            }
+            if(floatingPointValues[i] > maxValue) {
+                throw new IllegalArgumentException(
+                    "Value of " + floatingPointValues[i] + " exceeds allowed maximum for type "
+                        + s7Field.getDataType().name() + " (max " + maxValue.toString() + ")");
+            }
+        }
+        return new FloatingPointFieldItem(floatingPointValues);
+    }
+
+    private FieldItem internalEncodeString(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        int maxLength;
+        boolean encoding16Bit;
+        switch (s7Field.getDataType()) {
+            case CHAR:
+                maxLength = 1;
+                encoding16Bit = false;
+                break;
+            case WCHAR:
+                maxLength = 1;
+                encoding16Bit = true;
+                break;
+            case STRING:
+                maxLength = 254;
+                encoding16Bit = false;
+                break;
+            case WSTRING:
+                maxLength = 254;
+                encoding16Bit = true;
+                break;
+            default:
+                throw new IllegalArgumentException(
+                    "Cannot assign string values to " + s7Field.getDataType().name() + " fields.");
+        }
+
+        List<String> stringValues = new LinkedList<>();
+        for (Object value : values) {
+            if(value instanceof String) {
+                String stringValue = (String) value;
+                if(stringValue.length() > maxLength) {
+                    throw new IllegalArgumentException(
+                        "String length " + stringValue.length() + " exceeds allowed maximum for type "
+                            + s7Field.getDataType().name() + " (max " + maxLength + ")");
+                }
+                stringValues.add(stringValue);
+            }
+            // All other types just translate to max one String character.
+            else if(value instanceof Byte) {
+                Byte byteValue = (Byte) value;
+                byte[] stringBytes = new byte[]{byteValue};
+                if(encoding16Bit) {
+                    stringValues.add(new String(stringBytes, Charset.forName("UTF-16")));
+                } else {
+                    stringValues.add(new String(stringBytes, Charset.forName("UTF-8")));
+                }
+            }
+            else if(value instanceof Short) {
+                Short shortValue = (Short) value;
+                byte[] stringBytes = new byte[2];
+                stringBytes[0] = (byte) (shortValue >> 8);
+                stringBytes[1] = (byte) (shortValue & 0xFF);
+                if(encoding16Bit) {
+                    stringValues.add(new String(stringBytes, Charset.forName("UTF-16")));
+                } else {
+                    stringValues.add(new String(stringBytes, Charset.forName("UTF-8")));
+                }
+            }
+            else if(value instanceof Integer) {
+                Integer integerValue = (Integer) value;
+                byte[] stringBytes = new byte[4];
+                stringBytes[0] = (byte) ((integerValue >> 24) & 0xFF);
+                stringBytes[1] = (byte) ((integerValue >> 16) & 0xFF);
+                stringBytes[2] = (byte) ((integerValue >> 8) & 0xFF);
+                stringBytes[3] = (byte) (integerValue & 0xFF);
+                if(encoding16Bit) {
+                    stringValues.add(new String(stringBytes, Charset.forName("UTF-16")));
+                } else {
+                    stringValues.add(new String(stringBytes, Charset.forName("UTF-8")));
+                }
+            }
+            else if(value instanceof Long) {
+                Long longValue = (Long) value;
+                byte[] stringBytes = new byte[8];
+                stringBytes[0] = (byte) ((longValue >> 56) & 0xFF);
+                stringBytes[1] = (byte) ((longValue >> 48) & 0xFF);
+                stringBytes[2] = (byte) ((longValue >> 40) & 0xFF);
+                stringBytes[3] = (byte) ((longValue >> 32) & 0xFF);
+                stringBytes[4] = (byte) ((longValue >> 24) & 0xFF);
+                stringBytes[5] = (byte) ((longValue >> 16) & 0xFF);
+                stringBytes[6] = (byte) ((longValue >> 8) & 0xFF);
+                stringBytes[7] = (byte) (longValue & 0xFF);
+                if(encoding16Bit) {
+                    stringValues.add(new String(stringBytes, Charset.forName("UTF-16")));
+                } else {
+                    stringValues.add(new String(stringBytes, Charset.forName("UTF-8")));
+                }
+            }
+            else {
+                throw new IllegalArgumentException(
+                    "Value of type " + value.getClass().getName() +
+                        " is not assignable to " + s7Field.getDataType().name() + " fields.");
+            }
+        }
+        return new StringFieldItem(stringValues.toArray(new String[0]));
+    }
+
+    private FieldItem internalEncodeTemporal(PlcField field, Object[] values) {
+        S7Field s7Field = (S7Field) field;
+        switch (s7Field.getDataType()) {
+            case TIME:
+            case DATE:
+            case DATE_AND_TIME:
+                return new TimeFieldItem();
+            default:
+                throw new IllegalArgumentException(
+                    "Cannot assign temporal values to " + s7Field.getDataType().name() + " fields.");
+        }
+    }
+
+}
diff --git a/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/types/S7DataType.java b/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/types/S7DataType.java
index 8ffd647..fadea90 100644
--- a/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/types/S7DataType.java
+++ b/plc4j/protocols/s7/src/main/java/org/apache/plc4x/java/s7/types/S7DataType.java
@@ -39,7 +39,7 @@ public enum S7DataType {
     WORD(0x04, "W", 2, null, DataTransportSize.BYTE_WORD_DWORD, S7ControllerType.S7_ANY),
     DWORD(0x06, "D", 4, WORD, DataTransportSize.BYTE_WORD_DWORD, S7ControllerType.S7_ANY),
     // Only got a basic TIA license (S7-1500 needed to find this out)
-    LWORD(0x00, null, 8, null, null, S7ControllerType.S7_1200, S7ControllerType.S7_1500),
+    LWORD(0x00, "X", 8, null, null, S7ControllerType.S7_1200, S7ControllerType.S7_1500),
 
     // -----------------------------------------
     // Integers
@@ -56,9 +56,9 @@ public enum S7DataType {
     // Unsigned Double Precision Int
     UDINT(0x00, "D", 4, INT, DataTransportSize.BYTE_WORD_DWORD, S7ControllerType.S7_1200, S7ControllerType.S7_1500),
     // Only got a basic TIA license (S7-1500 needed to find this out)
-    LINT(0x00, null, 8, INT, null, S7ControllerType.S7_1500),
+    LINT(0x00, "X", 8, INT, null, S7ControllerType.S7_1500),
     // Only got a basic TIA license (S7-1500 needed to find this out)
-    ULINT(0x00, null, 16, INT, null, S7ControllerType.S7_1500),
+    ULINT(0x00, "X", 16, INT, null, S7ControllerType.S7_1500),
 
     // -----------------------------------------
     // Reals
@@ -70,24 +70,24 @@ public enum S7DataType {
     // Durations
     // -----------------------------------------
     // IEC time
-    TIME(0x0B, "", 4, null, null, S7ControllerType.S7_ANY),
+    TIME(0x0B, "X", 4, null, null, S7ControllerType.S7_ANY),
 
     // -----------------------------------------
     // Date
     // -----------------------------------------
     // IEC date (yyyy-m-d)
-    DATE(0x00, "", 2, null, null, S7ControllerType.S7_ANY),
+    DATE(0x00, "X", 2, null, null, S7ControllerType.S7_ANY),
 
     // -----------------------------------------
     // Time of day
     // -----------------------------------------
     // Time (hh:mm:ss.S)
-    TIME_OF_DAY(0x0A, "", 4, null, null, S7ControllerType.S7_ANY),
+    TIME_OF_DAY(0x0A, "X", 4, null, null, S7ControllerType.S7_ANY),
 
     // -----------------------------------------
     // Date and time of day
     // -----------------------------------------
-    DATE_AND_TIME(0x0F, "", 8, null, null, S7ControllerType.S7_ANY),
+    DATE_AND_TIME(0x0F, "X", 8, null, null, S7ControllerType.S7_ANY),
 
     // -----------------------------------------
     // ASCII Strings
@@ -95,11 +95,11 @@ public enum S7DataType {
     // Single-byte character
     CHAR(0x03, "B", 1, null, DataTransportSize.BYTE_WORD_DWORD, S7ControllerType.S7_ANY),
     // Double-byte character
-    WCHAR(0x00, "", 2, null, null, S7ControllerType.S7_ANY),
+    WCHAR(0x00, "X", 2, null, null, S7ControllerType.S7_ANY),
     // Variable-length single-byte character string
-    STRING(0x00, "", -1, null, null, S7ControllerType.S7_ANY),
+    STRING(0x00, "X", -1, null, null, S7ControllerType.S7_ANY),
     // Variable-length double-byte character string
-    WSTRING(0x00, "", -1, null, null, S7ControllerType.S7_ANY);
+    WSTRING(0x00, "X", -1, null, null, S7ControllerType.S7_ANY);
 
     /* TO BE CONTINUED */
 
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/util/S7PlcFieldHandlerTest.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/util/S7PlcFieldHandlerTest.java
new file mode 100644
index 0000000..e273c4a
--- /dev/null
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/util/S7PlcFieldHandlerTest.java
@@ -0,0 +1,349 @@
+/*
+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.s7.netty.util;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.apache.plc4x.java.api.model.PlcField;
+import org.apache.plc4x.java.base.messages.items.FieldItem;
+import org.apache.plc4x.java.s7.types.S7DataType;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+class S7PlcFieldHandlerTest {
+
+    private static S7PlcFieldHandler SUT = new S7PlcFieldHandler();
+
+    @ParameterizedTest
+    @ValueSource(strings = {
+        "%DB1.DBX1.0:BOOL",
+        "%DB1.DBW1.0:WORD"
+    })
+    void createField(String fieldQuery) {
+        SUT.createField(fieldQuery);
+    }
+
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeOneBitTypes(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+            "BOOL-BOOLEAN-MIN", "BOOL-BOOLEAN-MAX",
+            "BOOL-BYTE-MIN", "BOOL-BYTE-NIL", "BOOL-BYTE-VAL", "BOOL-BYTE-MAX",
+            "BOOL-SHORT-MIN", "BOOL-SHORT-NIL", "BOOL-SHORT-VAL", "BOOL-SHORT-MAX",
+            "BOOL-INTEGER-MIN", "BOOL-INTEGER-NIL", "BOOL-INTEGER-VAL", "BOOL-INTEGER-MAX",
+            "BOOL-LONG-MIN", "BOOL-LONG-NIL", "BOOL-LONG-VAL", "BOOL-LONG-MAX",
+
+            "BYTE-BOOLEAN-MIN", "BYTE-BOOLEAN-MAX",
+            "BYTE-BYTE-MIN", "BYTE-BYTE-NIL", "BYTE-BYTE-VAL", "BYTE-BYTE-MAX",
+            "BYTE-SHORT-MIN", "BYTE-SHORT-NIL", "BYTE-SHORT-VAL", "BYTE-SHORT-MAX",
+            "BYTE-INTEGER-MIN", "BYTE-INTEGER-NIL", "BYTE-INTEGER-VAL", "BYTE-INTEGER-MAX",
+            "BYTE-LONG-MIN", "BYTE-LONG-NIL", "BYTE-LONG-VAL", "BYTE-LONG-MAX",
+
+            "WORD-BOOLEAN-MIN", "WORD-BOOLEAN-MAX",
+            "WORD-BYTE-MIN", "WORD-BYTE-NIL", "WORD-BYTE-VAL", "WORD-BYTE-MAX",
+            "WORD-SHORT-MIN", "WORD-SHORT-NIL", "WORD-SHORT-VAL", "WORD-SHORT-MAX",
+            "WORD-INTEGER-MIN", "WORD-INTEGER-NIL", "WORD-INTEGER-VAL", "WORD-INTEGER-MAX",
+            "WORD-LONG-MIN", "WORD-LONG-NIL", "WORD-LONG-VAL", "WORD-LONG-MAX",
+
+            "DWORD-BOOLEAN-MIN", "DWORD-BOOLEAN-MAX",
+            "DWORD-BYTE-MIN", "DWORD-BYTE-NIL", "DWORD-BYTE-VAL", "DWORD-BYTE-MAX",
+            "DWORD-SHORT-MIN", "DWORD-SHORT-NIL", "DWORD-SHORT-VAL", "DWORD-SHORT-MAX",
+            "DWORD-INTEGER-MIN", "DWORD-INTEGER-NIL", "DWORD-INTEGER-VAL", "DWORD-INTEGER-MAX",
+            "DWORD-LONG-MIN", "DWORD-LONG-NIL", "DWORD-LONG-VAL", "DWORD-LONG-MAX",
+
+            "LWORD-BOOLEAN-MIN", "LWORD-BOOLEAN-MAX",
+            "LWORD-BYTE-MIN", "LWORD-BYTE-NIL", "LWORD-BYTE-VAL", "LWORD-BYTE-MAX",
+            "LWORD-SHORT-MIN", "LWORD-SHORT-NIL", "LWORD-SHORT-VAL", "LWORD-SHORT-MAX",
+            "LWORD-INTEGER-MIN", "LWORD-INTEGER-NIL", "LWORD-INTEGER-VAL", "LWORD-INTEGER-MAX",
+            "LWORD-LONG-MIN", "LWORD-LONG-NIL", "LWORD-LONG-VAL", "LWORD-LONG-MAX"
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeBoolean);
+    }
+
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeOneByteIntegerTypes(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+            "BYTE-BYTE-MIN", "BYTE-BYTE-NIL", "BYTE-BYTE-VAL", "BYTE-BYTE-MAX",
+            "BYTE-SHORT-NIL", "BYTE-SHORT-VAL",
+            "BYTE-INTEGER-NIL", "BYTE-INTEGER-VAL",
+            "BYTE-LONG-NIL", "BYTE-LONG-VAL",
+
+            "SINT-BYTE-MIN", "SINT-BYTE-NIL", "SINT-BYTE-VAL", "SINT-BYTE-MAX",
+            "SINT-SHORT-NIL", "SINT-SHORT-VAL",
+            "SINT-INTEGER-NIL", "SINT-INTEGER-VAL",
+            "SINT-LONG-NIL", "SINT-LONG-VAL",
+
+            // If it's a unsigned small int field, then any negative number is out of scope.
+            "USINT-BYTE-NIL", "USINT-BYTE-VAL", "USINT-BYTE-MAX",
+            "USINT-SHORT-NIL", "USINT-SHORT-VAL",
+            "USINT-INTEGER-NIL", "USINT-INTEGER-VAL",
+            "USINT-LONG-NIL", "USINT-LONG-VAL"
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeByte);
+    }
+
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeTwoByteIntegerTypes(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+            "WORD-BYTE-MIN", "WORD-BYTE-NIL", "WORD-BYTE-VAL", "WORD-BYTE-MAX",
+            "WORD-SHORT-MIN", "WORD-SHORT-NIL", "WORD-SHORT-VAL", "WORD-SHORT-MAX",
+            "WORD-INTEGER-NIL", "WORD-INTEGER-VAL",
+            "WORD-LONG-NIL", "WORD-LONG-VAL",
+
+            "INT-BYTE-MIN", "INT-BYTE-NIL", "INT-BYTE-VAL", "INT-BYTE-MAX",
+            "INT-SHORT-MIN", "INT-SHORT-NIL", "INT-SHORT-VAL", "INT-SHORT-MAX",
+            "INT-INTEGER-NIL", "INT-INTEGER-VAL",
+            "INT-LONG-NIL", "INT-LONG-VAL",
+
+            "UINT-BYTE-NIL", "UINT-BYTE-VAL", "UINT-BYTE-MAX",
+            "UINT-SHORT-NIL", "UINT-SHORT-VAL", "UINT-SHORT-MAX",
+            "UINT-INTEGER-NIL", "UINT-INTEGER-VAL",
+            "UINT-LONG-NIL", "UINT-LONG-VAL"
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeShort);
+    }
+
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeFourByteIntegerTypes(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+            "DWORD-BYTE-MIN", "DWORD-BYTE-NIL", "DWORD-BYTE-VAL", "DWORD-BYTE-MAX",
+            "DWORD-SHORT-MIN", "DWORD-SHORT-NIL", "DWORD-SHORT-VAL", "DWORD-SHORT-MAX",
+            "DWORD-INTEGER-MIN", "DWORD-INTEGER-NIL", "DWORD-INTEGER-VAL", "DWORD-INTEGER-MAX",
+            "DWORD-LONG-NIL", "DWORD-LONG-VAL",
+
+            "DINT-BYTE-MIN", "DINT-BYTE-NIL", "DINT-BYTE-VAL", "DINT-BYTE-MAX",
+            "DINT-SHORT-MIN", "DINT-SHORT-NIL", "DINT-SHORT-VAL", "DINT-SHORT-MAX",
+            "DINT-INTEGER-MIN", "DINT-INTEGER-NIL", "DINT-INTEGER-VAL", "DINT-INTEGER-MAX",
+            "DINT-LONG-NIL", "DINT-LONG-VAL",
+
+            "UDINT-BYTE-NIL", "UDINT-BYTE-VAL", "UDINT-BYTE-MAX",
+            "UDINT-SHORT-NIL", "UDINT-SHORT-VAL", "UDINT-SHORT-MAX",
+            "UDINT-INTEGER-NIL", "UDINT-INTEGER-VAL", "UDINT-INTEGER-MAX",
+            "UDINT-LONG-NIL", "UDINT-LONG-VAL"
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeInteger);
+    }
+
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeEightByteIntegerTypes(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+            "LINT-BYTE-MIN", "LINT-BYTE-NIL", "LINT-BYTE-VAL", "LINT-BYTE-MAX",
+            "LINT-SHORT-MIN", "LINT-SHORT-NIL", "LINT-SHORT-VAL", "LINT-SHORT-MAX",
+            "LINT-INTEGER-MIN", "LINT-INTEGER-NIL", "LINT-INTEGER-VAL", "LINT-INTEGER-MAX",
+            "LINT-LONG-MIN", "LINT-LONG-NIL", "LINT-LONG-VAL", "LINT-LONG-MAX",
+
+            "ULINT-BYTE-NIL", "ULINT-BYTE-VAL", "ULINT-BYTE-MAX",
+            "ULINT-SHORT-NIL", "ULINT-SHORT-VAL", "ULINT-SHORT-MAX",
+            "ULINT-INTEGER-NIL", "ULINT-INTEGER-VAL", "ULINT-INTEGER-MAX",
+            "ULINT-LONG-NIL", "ULINT-LONG-VAL", "ULINT-LONG-MAX",
+
+            "LWORD-BYTE-MIN", "LWORD-BYTE-NIL", "LWORD-BYTE-VAL", "LWORD-BYTE-MAX",
+            "LWORD-SHORT-MIN", "LWORD-SHORT-NIL", "LWORD-SHORT-VAL", "LWORD-SHORT-MAX",
+            "LWORD-INTEGER-MIN", "LWORD-INTEGER-NIL", "LWORD-INTEGER-VAL", "LWORD-INTEGER-MAX",
+            "LWORD-LONG-MIN", "LWORD-LONG-NIL", "LWORD-LONG-VAL", "LWORD-LONG-MAX"
+
+            // TODO: Somehow test ULWORD too ...
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeLong);
+    }
+
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeFourByteFloatTypes(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+            "REAL-FLOAT-MIN", "REAL-FLOAT-NIL", "REAL-FLOAT-VAL", "REAL-FLOAT-MAX",
+            "REAL-DOUBLE-NIL", "REAL-DOUBLE-VAL"
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeFloat);
+    }
+
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeEightByteFloatTypes(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+            "LREAL-FLOAT-MIN", "LREAL-FLOAT-NIL", "LREAL-FLOAT-VAL", "LREAL-FLOAT-MAX",
+            "LREAL-DOUBLE-MIN", "LREAL-DOUBLE-NIL", "LREAL-DOUBLE-VAL", "LREAL-DOUBLE-MAX"
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeDouble);
+    }
+
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeString(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+            "CHAR-BYTE-MIN", "CHAR-BYTE-NIL", "CHAR-BYTE-VAL", "CHAR-BYTE-MAX",
+            "CHAR-SHORT-MIN", "CHAR-SHORT-NIL", "CHAR-SHORT-VAL", "CHAR-SHORT-MAX",
+            "CHAR-INTEGER-MIN", "CHAR-INTEGER-NIL", "CHAR-INTEGER-VAL", "CHAR-INTEGER-MAX",
+            "CHAR-LONG-MIN", "CHAR-LONG-NIL", "CHAR-LONG-VAL", "CHAR-LONG-MAX",
+            "CHAR-STRING-MIN",
+            "WCHAR-BYTE-MIN", "WCHAR-BYTE-NIL", "WCHAR-BYTE-VAL", "WCHAR-BYTE-MAX",
+            "WCHAR-SHORT-MIN", "WCHAR-SHORT-NIL", "WCHAR-SHORT-VAL", "WCHAR-SHORT-MAX",
+            "WCHAR-INTEGER-MIN", "WCHAR-INTEGER-NIL", "WCHAR-INTEGER-VAL", "WCHAR-INTEGER-MAX",
+            "WCHAR-LONG-MIN", "WCHAR-LONG-NIL", "WCHAR-LONG-VAL", "WCHAR-LONG-MAX",
+            "WCHAR-STRING-MIN",
+            "STRING-BYTE-MIN", "STRING-BYTE-NIL", "STRING-BYTE-VAL", "STRING-BYTE-MAX",
+            "STRING-SHORT-MIN", "STRING-SHORT-NIL", "STRING-SHORT-VAL", "STRING-SHORT-MAX",
+            "STRING-INTEGER-MIN", "STRING-INTEGER-NIL", "STRING-INTEGER-VAL", "STRING-INTEGER-MAX",
+            "STRING-LONG-MIN", "STRING-LONG-NIL", "STRING-LONG-VAL", "STRING-LONG-MAX",
+            "STRING-STRING-MIN", "STRING-STRING-VAL", "STRING-STRING-MAX",
+            "WSTRING-BYTE-MIN", "WSTRING-BYTE-NIL", "WSTRING-BYTE-VAL", "WSTRING-BYTE-MAX",
+            "WSTRING-SHORT-MIN", "WSTRING-SHORT-NIL", "WSTRING-SHORT-VAL", "WSTRING-SHORT-MAX",
+            "WSTRING-INTEGER-MIN", "WSTRING-INTEGER-NIL", "WSTRING-INTEGER-VAL", "WSTRING-INTEGER-MAX",
+            "WSTRING-LONG-MIN", "WSTRING-LONG-NIL", "WSTRING-LONG-VAL", "WSTRING-LONG-MAX",
+            "WSTRING-STRING-MIN", "WSTRING-STRING-VAL", "WSTRING-STRING-MAX"
+            ));
+        encode(name, field, values, expectedSuccess, SUT::encodeString);
+    }
+
+    @Disabled("Not implemented yet")
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeTime(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeTime);
+    }
+
+    @Disabled("Not implemented yet")
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeDate(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeDate);
+    }
+
+    @Disabled("Not implemented yet")
+    @ParameterizedTest
+    @MethodSource("createInputArrays")
+    void encodeDateTime(String name, PlcField field, Object[] values) {
+        Set<String> expectedSuccess = new HashSet<>(Arrays.asList(
+        ));
+        encode(name, field, values, expectedSuccess, SUT::encodeDateTime);
+    }
+
+    private static Stream<Arguments> createInputArrays() {
+        // Generate valid fields for each s7 type.
+        Map<S7DataType, PlcField> fields = new HashMap<>();
+        for (S7DataType s7Type : S7DataType.values()) {
+            String sizeCode = (s7Type.getSizeCode() != null) ? s7Type.getSizeCode() : "X";
+            String fieldQuery = "%DB1.DB" + sizeCode + "1";
+            if(s7Type == S7DataType.BOOL) {
+                fieldQuery += ".0";
+            }
+            fieldQuery += ":" + s7Type.name();
+            fields.put(s7Type, SUT.createField(fieldQuery));
+        }
+        // Generate output for each combination of S7 and Java type.
+        Stream<Arguments> values = null;
+        for (S7DataType s7Type : S7DataType.values()) {
+            PlcField field = fields.get(s7Type);
+            for (JavaTypes javaType : JavaTypes.values()) {
+                Object[] testValues = javaType.values;
+
+                Stream<Arguments> curValues;
+                // Min, Max
+                if(testValues.length == 2) {
+                    curValues = Stream.of(
+                        Arguments.of(s7Type.name() + "-" + javaType.name() + "-MIN", field, new Object[]{testValues[0]}),
+                        Arguments.of(s7Type.name() + "-" + javaType.name() + "-MAX", field, new Object[]{testValues[1]}));
+                }
+                // Value, Min, Max
+                else if(testValues.length == 3) {
+                    curValues = Stream.of(
+                        Arguments.of(s7Type.name() + "-" + javaType.name() + "-MIN", field, new Object[]{testValues[1]}),
+                        Arguments.of(s7Type.name() + "-" + javaType.name() + "-VAL", field, new Object[]{testValues[0]}),
+                        Arguments.of(s7Type.name() + "-" + javaType.name() + "-MAX", field, new Object[]{testValues[2]}));
+                }
+                // Zero, Value, Min, Max
+                else if(testValues.length == 4) {
+                    curValues = Stream.of(
+                        Arguments.of(s7Type.name() + "-" + javaType.name() + "-MIN", field, new Object[]{testValues[2]}),
+                        Arguments.of(s7Type.name() + "-" + javaType.name() + "-NIL", field, new Object[]{testValues[0]}),
+                        Arguments.of(s7Type.name() + "-" + javaType.name() + "-VAL", field, new Object[]{testValues[1]}),
+                        Arguments.of(s7Type.name() + "-" + javaType.name() + "-MAX", field, new Object[]{testValues[3]}));
+                } else {
+                    throw new RuntimeException("Expecting 2, 3 or 4 valued test-input");
+                }
+                if(values == null) {
+                    values = curValues;
+                } else {
+                    values = Stream.concat(values, curValues);
+                }
+            }
+        }
+        return values;
+    }
+
+    enum JavaTypes {
+        BOOLEAN(new Object[]{false, true}),
+        BYTE(new Object[]{(byte) 0, (byte) 42, Byte.MIN_VALUE, Byte.MAX_VALUE}),
+        SHORT(new Object[]{(short) 0, (short) 42, Short.MIN_VALUE, Short.MAX_VALUE}),
+        INTEGER(new Object[]{0, 42, Integer.MIN_VALUE, Integer.MAX_VALUE}),
+        LONG(new Object[]{(long) 0, (long) 42, Long.MIN_VALUE, Long.MAX_VALUE}),
+        FLOAT(new Object[]{(float) 0.0, (float) 42.23, -Float.MAX_VALUE, Float.MAX_VALUE}),
+        DOUBLE(new Object[]{0.0, 42.23, -Double.MAX_VALUE, Double.MAX_VALUE}),
+        // Creates an empty sting as min and a 254 char long string as max.
+        STRING(new Object[]{"Hurz", "", IntStream.range(0, 254).mapToObj(i -> "a").collect(Collectors.joining(""))}),
+        TIME(new Object[]{LocalTime.now(), LocalTime.MIDNIGHT, LocalTime.MIN, LocalTime.MAX}),
+        DATE(new Object[]{LocalDate.now(), LocalDate.MIN, LocalDate.MAX}),
+        DATETIME(new Object[]{LocalDateTime.now(), LocalDateTime.MIN, LocalDateTime.MAX});
+
+        private final Object[] values;
+
+        JavaTypes(Object[] values) {
+            this.values = values;
+        }
+
+    }
+
+    private void encode(String name, PlcField field, Object[] values, Set<String> expectedSuccess,
+                        BiFunction<PlcField, Object[], FieldItem> encoder) {
+        boolean success = expectedSuccess.contains(name);
+        try {
+            FieldItem fieldItem = encoder.apply(field, values);
+            assertNotNull(fieldItem, "A FieldItem instance should have been returned for testcase " + name);
+            if(!success) {
+                fail("Expected to fail for testcase " + name);
+            }
+        } catch (Exception e) {
+            if(success) {
+                fail("Expected to succeed for testcase " + name + " got exception " + e.getMessage());
+            }
+        }
+    }
+
+}
\ No newline at end of file