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