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 2022/06/05 17:08:28 UTC
[plc4x] branch develop updated: chore(plc4c): Continued implementing the plc4x (proxy) protocol client in C. Made the S7 and Modbus drivers work again.
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/develop by this push:
new f2a212ad51 chore(plc4c): Continued implementing the plc4x (proxy) protocol client in C. Made the S7 and Modbus drivers work again.
f2a212ad51 is described below
commit f2a212ad519b5b18614374ce97c12d2b66b455bb
Author: cdutz <ch...@c-ware.de>
AuthorDate: Sun Jun 5 19:08:20 2022 +0200
chore(plc4c): Continued implementing the plc4x (proxy) protocol client in C. Made the S7 and Modbus drivers work again.
---
.../plc4x/language/c/CLanguageTemplateHelper.java | 84 ++-
.../templates/c/complex-type-template.c.ftlh | 10 +-
.../resources/templates/c/data-io-template.c.ftlh | 243 +++++++-
.../resources/templates/c/data-io-template.h.ftlh | 6 +-
plc4c/api/include/plc4c/data.h | 140 +++--
plc4c/api/include/plc4c/types.h | 48 +-
.../modbus/include/plc4c/driver_modbus_sm.h | 2 +
plc4c/drivers/modbus/src/driver_modbus.c | 2 +
plc4c/drivers/modbus/src/driver_modbus_packets.c | 2 +-
.../modbus/src/driver_modbus_sm_disconnect.c | 1 -
plc4c/drivers/modbus/src/driver_modbus_sm_read.c | 17 +-
plc4c/drivers/modbus/src/driver_modbus_sm_write.c | 17 +
plc4c/drivers/plc4x/src/driver_plc4x_sm_write.c | 8 +-
plc4c/drivers/plc4x/test/plc4x_test.c | 2 +-
plc4c/drivers/s7/include/plc4c/driver_s7_static.h | 1 +
plc4c/drivers/s7/src/driver_modbus_encode_decode.c | 5 +-
plc4c/drivers/s7/src/driver_s7_packets.c | 49 +-
plc4c/drivers/s7/src/driver_s7_sm_read.c | 8 +-
plc4c/drivers/s7/src/driver_s7_sm_write.c | 24 +-
plc4c/drivers/s7/src/driver_s7_static.c | 3 +
plc4c/drivers/simulated/src/driver_simulated.c | 4 +-
plc4c/examples/hello-world-s7/src/hello_world_s7.c | 4 +-
.../hello-world-s7/src/hello_world_s7_loopback.c | 4 +-
plc4c/generated-sources/modbus/include/data_item.h | 6 +-
plc4c/generated-sources/modbus/src/data_item.c | 438 ++++++++++---
.../generated-sources/plc4x/include/plc4x_value.h | 6 +-
.../plc4x/include/plc4x_value_type.h | 1 +
plc4c/generated-sources/plc4x/src/plc4x_field.c | 4 +-
.../plc4x/src/plc4x_field_value_request.c | 4 +-
.../plc4x/src/plc4x_field_value_response.c | 4 +-
plc4c/generated-sources/plc4x/src/plc4x_message.c | 2 +-
plc4c/generated-sources/plc4x/src/plc4x_value.c | 326 ++++++++--
.../generated-sources/plc4x/src/plc4x_value_type.c | 46 +-
.../plc4x/test/ParserSerializerTestsuite.c | 4 +-
plc4c/generated-sources/s7/include/data_item.h | 6 +-
plc4c/generated-sources/s7/src/data_item.c | 367 ++++++++++-
.../s7/src/s7_payload_user_data_item.c | 2 +-
.../s7/src/s7_var_payload_data_item.c | 4 +-
plc4c/pom.xml | 15 +
plc4c/spi/include/plc4c/spi/types_private.h | 44 +-
plc4c/spi/src/data.c | 692 ++++++++++++---------
plc4c/spi/src/read_buffer.c | 4 +-
plc4c/spi/src/types.c | 104 +++-
plc4c/spi/src/write_buffer.c | 4 +-
plc4c/spi/test/utils/test_utils.c | 2 +-
.../protocols/modbus/readwrite/model/DataItem.go | 66 +-
.../knxnetip/readwrite/model/KnxManufacturer.cs | 27 +-
.../main/resources/protocols/modbus/modbus.mspec | 38 +-
.../main/resources/protocols/plc4x/v0/plc4x.mspec | 16 +-
.../protocols/plc4x/ParserSerializerTestsuite.xml | 59 +-
50 files changed, 2208 insertions(+), 767 deletions(-)
diff --git a/code-generation/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java b/code-generation/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java
index efb04cf942..22390e1beb 100644
--- a/code-generation/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java
+++ b/code-generation/language-c/src/main/java/org/apache/plc4x/language/c/CLanguageTemplateHelper.java
@@ -267,6 +267,75 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
}
}
+ public String getDataIoTypeNameForTypeReference(TypeReference typeReference) {
+ Objects.requireNonNull(typeReference);
+ if (typeReference instanceof SimpleTypeReference) {
+ SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
+ switch (simpleTypeReference.getBaseType()) {
+ case BIT:
+ return "bool";
+ case BYTE:
+ return "byte";
+ case UINT: {
+ IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (integerTypeReference.getSizeInBits() <= 8) {
+ return "usint";
+ }
+ if (integerTypeReference.getSizeInBits() <= 16) {
+ return "uint";
+ }
+ if (integerTypeReference.getSizeInBits() <= 32) {
+ return "udint";
+ }
+ if (integerTypeReference.getSizeInBits() <= 64) {
+ return "ulint";
+ }
+ throw new RuntimeException("Unsupported simple type");
+ }
+ case INT: {
+ IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ if (integerTypeReference.getSizeInBits() <= 8) {
+ return "sint";
+ }
+ if (integerTypeReference.getSizeInBits() <= 16) {
+ return "int";
+ }
+ if (integerTypeReference.getSizeInBits() <= 32) {
+ return "dint";
+ }
+ if (integerTypeReference.getSizeInBits() <= 64) {
+ return "lint";
+ }
+ throw new RuntimeException("Unsupported simple type");
+ }
+ case FLOAT:
+ FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
+ int sizeInBits = floatTypeReference.getSizeInBits();
+ if (sizeInBits <= 32) {
+ return "real";
+ }
+ if (sizeInBits <= 64) {
+ return "lreal";
+ }
+ throw new FreemarkerException("Unsupported real type with " + sizeInBits + " bits.");
+ case UFLOAT:
+ throw new FreemarkerException("Unsupported unsigned real type.");
+ case STRING:
+ case VSTRING:
+ return "char";
+ case TIME:
+ return "time";//throw new FreemarkerException("Unsupported time type.");
+ case DATE:
+ return "date";//throw new FreemarkerException("Unsupported date type.");
+ case DATETIME:
+ return "date_and_time";//throw new FreemarkerException("Unsupported date-time type.");
+ }
+ throw new FreemarkerException("Unsupported simple type. " + simpleTypeReference.getBaseType());
+ } else {
+ return getCTypeName(((NonSimpleTypeReference) typeReference).getName());
+ }
+ }
+
public String getLoopExpressionSuffix(TypedField field) {
if (!(field instanceof ArrayField)) {
return "";
@@ -490,8 +559,7 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
return "plc4c_spi_write_double(writeBuffer, " + floatTypeReference.getSizeInBits() + ", " + fieldName + ")";
}
throw new FreemarkerException("Unsupported float type with " + floatTypeReference.getSizeInBits() + " bits");
- case STRING:
- case VSTRING:
+ case STRING: {
final Term encodingTerm = field.getEncoding().orElse(new DefaultStringLiteral("UTF-8"));
if (!(encodingTerm instanceof StringLiteral)) {
throw new RuntimeException("Encoding must be a quoted string value");
@@ -500,6 +568,18 @@ public class CLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelpe
String length = Integer.toString(simpleTypeReference.getSizeInBits());
return "plc4c_spi_write_string(writeBuffer, " + length + ", \"" +
encoding + "\", " + fieldName + ")";
+ }
+ case VSTRING: {
+ final Term encodingTerm = field.getEncoding().orElse(new DefaultStringLiteral("UTF-8"));
+ if (!(encodingTerm instanceof StringLiteral)) {
+ throw new RuntimeException("Encoding must be a quoted string value");
+ }
+ String encoding = ((StringLiteral) encodingTerm).getValue();
+ // Here we need to use the serialized expression of the length instead.
+ String lengthExpression = toSerializationExpression(thisType, field, simpleTypeReference.asVstringTypeReference().orElseThrow().getLengthExpression(), null);
+ return "plc4c_spi_write_string(writeBuffer, " + lengthExpression + ", \"" +
+ encoding + "\", " + fieldName + ")";
+ }
default:
throw new FreemarkerException("Unsupported type " + simpleTypeReference.getBaseType().name());
}
diff --git a/code-generation/language-c/src/main/resources/templates/c/complex-type-template.c.ftlh b/code-generation/language-c/src/main/resources/templates/c/complex-type-template.c.ftlh
index f5d979e2d6..511ac31fcc 100644
--- a/code-generation/language-c/src/main/resources/templates/c/complex-type-template.c.ftlh
+++ b/code-generation/language-c/src/main/resources/templates/c/complex-type-template.c.ftlh
@@ -561,7 +561,7 @@ plc4c_return_code ${helper.getCTypeName(type.name)}_serialize(plc4c_spi_write_bu
<#if optionalField.type.isSimpleTypeReference()>
_res = ${helper.getWriteBufferWriteMethodCall(optionalField.type.asSimpleTypeReference().orElseThrow(), "*_message->" + helper.getFieldName(baseType, optionalField), optionalField)};
<#else>
- _res = ${helper.getCTypeName(optionalField.type.asNonSimpleTypeReference().orElseThrow().name)}_serialize(writeBuffer, _message-><@fieldName baseType=baseType field=optionalField/>);
+ _res = ${helper.getCTypeName(optionalField.type.asNonSimpleTypeReference().orElseThrow().name)}_serialize(writeBuffer<#if optionalField.type.isDataIoTypeReference() && optionalField.type.asNonSimpleTypeReference().get().getParams().isPresent()>, <#list optionalField.type.asNonSimpleTypeReference().get().getParams().get() as parserTerm>${helper.toSerializationExpression(baseType, optionalField, parserTerm, parserArguments)}<#sep>, </#sep></#list></#if>, <#if optionalField.type.isEnumT [...]
</#if>
if(_res != OK) {
return _res;
@@ -604,7 +604,7 @@ plc4c_return_code ${helper.getCTypeName(type.name)}_serialize(plc4c_spi_write_bu
_res = ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, "_message->" + helper.getFieldName(baseType, simpleField), simpleField)};
<#else>
<#assign nonSimpleTypeRererence = simpleField.type.asNonSimpleTypeReference().orElseThrow()>
- _res = ${helper.getCTypeName(nonSimpleTypeRererence.name)}_serialize(writeBuffer, <#if simpleField.type.isEnumTypeReference()>&</#if>_message-><@fieldName baseType=baseType field=simpleField/>);
+ _res = ${helper.getCTypeName(nonSimpleTypeRererence.name)}_serialize(writeBuffer<#if simpleField.type.isDataIoTypeReference() && simpleField.type.asNonSimpleTypeReference().get().getParams().isPresent()>, <#list simpleField.type.asNonSimpleTypeReference().get().getParams().get() as parserTerm>${helper.toSerializationExpression(baseType, simpleField, parserTerm, parserArguments)}<#sep>, </#sep></#list></#if>, <#if simpleField.type.isEnumTypeReference() || simpleField.type.isDataIoTypeRe [...]
</#if>
if(_res != OK) {
return _res;
@@ -730,7 +730,7 @@ uint16_t ${helper.getCTypeName(type.name)}_length_in_bits(${helper.getCTypeName(
<#assign simpleTypeReference = optionalField.type.asSimpleTypeReference().orElseThrow()>
lengthInBits += ${simpleTypeReference.sizeInBits};
<#else>
- lengthInBits += ${helper.getLengthInBitsFunctionNameForComplexTypedField(optionalField)}(_message-><@fieldName baseType=baseType field=optionalField/>);
+ lengthInBits += ${helper.getLengthInBitsFunctionNameForComplexTypedField(optionalField)}(_message-><@fieldName baseType=baseType field=optionalField/><#if optionalField.type.isDataIoTypeReference() && optionalField.type.asNonSimpleTypeReference().get().getParams().isPresent()>, <#list optionalField.type.asNonSimpleTypeReference().get().getParams().get() as parserTerm>${helper.toSerializationExpression(baseType, optionalField, parserTerm, parserArguments)}<#sep>, </#sep></#list></#if>);
</#if>
}
<#break>
@@ -740,8 +740,8 @@ uint16_t ${helper.getCTypeName(type.name)}_length_in_bits(${helper.getCTypeName(
// Padding Field (padding)
<#-- We're replacing the "lastItem" with 'false' here as the item itself can't know if it is the last -->
- int _needsPadding = (int) (${helper.toSerializationExpression(type, paddingField, paddingField.paddingCondition, parserArguments)?replace("lastItem", "false")});
- while(_needsPadding-- > 0) {
+ int _needsPadding = (int) (${helper.toSerializationExpression(type, paddingField, paddingField.paddingCondition, parserArguments)?replace("lastItem", "false")});
+ while(_needsPadding-- > 0) {
lengthInBits += ${simpleTypeReference.sizeInBits};
}
<#break>
diff --git a/code-generation/language-c/src/main/resources/templates/c/data-io-template.c.ftlh b/code-generation/language-c/src/main/resources/templates/c/data-io-template.c.ftlh
index 176085d867..6b8f6f6383 100644
--- a/code-generation/language-c/src/main/resources/templates/c/data-io-template.c.ftlh
+++ b/code-generation/language-c/src/main/resources/templates/c/data-io-template.c.ftlh
@@ -51,6 +51,7 @@ ${helper.getSourceDirectory()?replace(".", "/")}/${helper.camelCaseToSnakeCase(t
#include <plc4c/data.h>
#include <plc4c/utils/list.h>
#include <plc4c/spi/evaluation_helper.h>
+#include <plc4c/spi/types_private.h>
#include <plc4c/driver_${protocolName}_static.h>
#include "${helper.camelCaseToSnakeCase(type.name)}.h"
@@ -91,7 +92,7 @@ plc4c_return_code ${helper.getCTypeName(type.name)}_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_${helper.getLanguageTypeNameForTypeReference(elementTypeReference)}_data(*_val);
+ plc4c_data* _item = plc4c_data_create_${helper.getDataIoTypeNameForTypeReference(elementTypeReference)}_data(*_val);
plc4c_utils_list_insert_head_value(${arrayField.name}, _item);
}
<#-- In all other cases do we have to work with a list, that is later converted to an array -->
@@ -140,7 +141,7 @@ plc4c_return_code ${helper.getCTypeName(type.name)}_parse(plc4c_spi_read_buffer*
${helper.getLanguageTypeNameForField(arrayField)}[] ${arrayField.name} = _${arrayField.name}List.toArray(new ${helper.getLanguageTypeNameForField(arrayField)}[0]);
</#if-->
</#if>
- *data_item = plc4c_data_create_list_data(*${arrayField.name});
+ *data_item = plc4c_data_create_list_data(${arrayField.name});
<#break>
<#case "const">
@@ -218,16 +219,14 @@ plc4c_return_code ${helper.getCTypeName(type.name)}_parse(plc4c_spi_read_buffer*
return _res;
}
- <#if case.name == "BitString">
- *data_item = plc4c_data_create_${helper.getLanguageTypeNameForField(field)}_bit_string_data(${simpleField.name});
- <#elseif case.name == "STRING">
+ <#if case.name == "STRING">
<#if simpleField.type.isVstringTypeReference()>
*data_item = plc4c_data_create_string_data(stringLength, ${simpleField.name});
<#else>
*data_item = plc4c_data_create_string_data(${simpleField.type.asStringTypeReference().orElseThrow().sizeInBits}, ${simpleField.name});
</#if>
<#else>
- *data_item = plc4c_data_create_${helper.getLanguageTypeNameForField(field)}_data(${simpleField.name});
+ *data_item = plc4c_data_create_${case.name?lower_case}_data(${simpleField.name});
</#if>
<#break>
@@ -238,19 +237,243 @@ plc4c_return_code ${helper.getCTypeName(type.name)}_parse(plc4c_spi_read_buffer*
return OK;
}
-plc4c_return_code ${helper.getCTypeName(type.name)}_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_data** data_item) {
+plc4c_return_code ${helper.getCTypeName(type.name)}_serialize(plc4c_spi_write_buffer* writeBuffer, <#if parserArguments?has_content><#list parserArguments as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type)}<#if !parserArgument.type.isSimpleTypeReference() && !parserArgument.type.isEnumTypeReference()>*</#if> ${parserArgument.name}<#sep>, </#list>, </#if>plc4c_data** data_item) {
plc4c_return_code _res = OK;
+ <#list type.switchField.orElseThrow().cases as case>
+ <#if case.discriminatorValueTerms?has_content>if(<#list case.discriminatorValueTerms as discriminatorValueTerm><#if case.discriminatorValueTerms?size > 1>(</#if><#if helper.discriminatorValueNeedsStringEqualityCheck(type.switchField.orElseThrow().discriminatorExpressions[discriminatorValueTerm?index])>strcmp(${helper.toParseExpression(type, null, type.switchField.orElseThrow().discriminatorExpressions[discriminatorValueTerm?index], parserArguments)}, ${helper.toParseExpression [...]
+ <#list case.fields as field>
+ <#switch field.typeName>
+ <#case "array">
+ <#assign arrayField = field.asArrayField().orElseThrow()>
+ <#assign elementTypeReference=arrayField.type.elementTypeReference>
+
+ // Array field
+ <#break>
+ <#case "checksum">
+ <#assign checksumField = field.asChecksumField().orElseThrow()>
+ <#assign simpleTypeReference = checksumField.type>
+
+ // Checksum Field (checksum)
+ <#break>
+ <#case "const">
+ <#assign constField = field.asConstField().orElseThrow()>
+ <#assign simpleTypeReference = constField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Const Field (${constField.name})
+ <#break>
+ <#case "discriminator">
+ <#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
+
+ // Discriminator Field (${discriminatorField.name})
+ <#break>
+ <#case "enum">
+ <#assign enumField = field.asEnumField().orElseThrow()>
+
+ // Enum Field (${enumField.name})
+ <#break>
+ <#case "implicit">
+ <#assign implicitField = field.asImplicitField().orElseThrow()>
+ <#assign simpleTypeReference = implicitField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Implicit Field (${implicitField.name})
+ <#break>
+ <#case "manualArray">
+ <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
+
+ // Manual Array Field (${manualArrayField.name})
+ <#break>
+ <#case "manual">
+ <#assign manualField = field.asManualField().orElseThrow()>
+
+ // Manual Field (${manualField.name})
+ <#break>
+ <#case "optional">
+ <#assign optionalField = field.asOptionalField().orElseThrow()>
+
+ // Optional Field (${optionalField.name})
+ <#break>
+ <#case "padding">
+ <#assign paddingField = field.asPaddingField().orElseThrow()>
+ <#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Padding Field (padding)
+ <#break>
+ <#case "reserved">
+ <#assign reservedField = field.asReservedField().orElseThrow()>
+ <#assign simpleTypeReference = reservedField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Reserved Field (reserved)
+ <#break>
+ <#case "simple">
+ <#assign simpleField = field.asSimpleField().orElseThrow()>
+ <#assign simpleTypeReference = simpleField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Simple field (${simpleField.name})
+ _res = ${helper.getWriteBufferWriteMethodCall(simpleTypeReference, "(*data_item)->data." + case.name?lower_case + "_value", simpleField)};
+ if(_res != OK) {
+ return _res;
+ }
+ <#break>
+ <#case "virtual">
+ <#assign virtualField = field.asVirtualField().orElseThrow()>
+ // Virtual field (${simpleField.name})
+ <#break>
+ </#switch>
+ </#list>
+ }<#sep> else </#sep></#list>
return OK;
}
-uint16_t ${helper.getCTypeName(type.name)}_length_in_bytes(plc4c_data* data_item) {
- return ${helper.getCTypeName(type.name)}_length_in_bits(data_item) / 8;
+uint16_t ${helper.getCTypeName(type.name)}_length_in_bytes(plc4c_data* data_item<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type)} ${helper.camelCaseToSnakeCase(parserArgument.name)}<#sep>, </#sep></#list></#if>) {
+ return ${helper.getCTypeName(type.name)}_length_in_bits(data_item<#if type.parserArguments.isPresent()>, <#list type.parserArguments.orElseThrow() as parserArgument>${helper.camelCaseToSnakeCase(parserArgument.name)}<#sep>, </#sep></#list></#if>) / 8;
}
-uint16_t ${helper.getCTypeName(type.name)}_length_in_bits(plc4c_data* data_item) {
+uint16_t ${helper.getCTypeName(type.name)}_length_in_bits(plc4c_data* data_item<#if parserArguments?has_content>, <#list parserArguments as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type)}<#if !parserArgument.type.isSimpleTypeReference() && !parserArgument.type.isEnumTypeReference()>*</#if> ${parserArgument.name}<#sep>, </#list></#if>) {
uint16_t lengthInBits = 0;
+ <#list type.switchField.orElseThrow().cases as case>
+ <#if case.discriminatorValueTerms?has_content>if(<#list case.discriminatorValueTerms as discriminatorValueTerm><#if case.discriminatorValueTerms?size > 1>(</#if><#if helper.discriminatorValueNeedsStringEqualityCheck(type.switchField.orElseThrow().discriminatorExpressions[discriminatorValueTerm?index])>strcmp(${helper.toParseExpression(type, null, type.switchField.orElseThrow().discriminatorExpressions[discriminatorValueTerm?index], parserArguments)}, ${helper.toParseExpression(nul [...]
+ <#list case.fields as field>
+ <#switch field.typeName>
+ <#case "array">
+ <#assign arrayField = field.asArrayField().orElseThrow()>
+ <#assign elementTypeReference=arrayField.type.elementTypeReference>
+ // Array field
+ <#if elementTypeReference.isSimpleTypeReference()>
+ <#assign simpleTypeReference = elementTypeReference.asSimpleTypeReference().orElseThrow()>
+ lengthInBits += ${simpleTypeReference.sizeInBits} * plc4c_utils_list_size(data_item->data.list_value);
+ <#else>
+ if(data_item->data.list_value != NULL) {
+ plc4c_list_element* curElement = data_item->data.list_value->tail;
+ while (curElement != NULL) {
+ lengthInBits += ${helper.getLengthInBitsFunctionNameForComplexTypedField(arrayField)}((${helper.getLanguageTypeNameForTypeReference(elementTypeReference)}*) curElement->value);
+ curElement = curElement->next;
+ }
+ }
+ </#if>
+ <#break>
+ <#case "checksum">
+ <#assign checksumField = field.asChecksumField().orElseThrow()>
+ <#assign simpleTypeReference = checksumField.type>
+
+ // Checksum Field (checksum)
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ <#break>
+ <#case "const">
+ <#assign constField = field.asConstField().orElseThrow()>
+ <#assign simpleTypeReference = constField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Const Field (${constField.name})
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ <#break>
+ <#case "discriminator">
+ <#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
+
+ // Discriminator Field (${discriminatorField.name})
+ <#if discriminatorField.type.isSimpleTypeReference()>
+ <#assign simpleTypeReference = discriminatorField.type.asSimpleTypeReference().orElseThrow()>
+ <#if simpleTypeReference.isVstringTypeReference()>
+ <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
+ lengthInBits += ${helper.toParseExpression(type, discriminatorField, vstringTypeReference.lengthExpression, parserArguments)};
+ <#else>
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ </#if>
+ <#elseif helper.isEnumField(field)>
+ <#assign enumTypeReference = discriminatorField.type.asEnumTypeReference().orElseThrow()>
+ lengthInBits += ${enumTypeReference.baseTypeReference.orElseThrow().sizeInBits};
+ <#else>
+ lengthInBits += ${discriminatorField.name}.getLengthInBits();
+ </#if>
+ <#break>
+ <#case "enum">
+ <#assign enumField = field.asEnumField().orElseThrow()>
+
+ // Enum Field (${enumField.name})
+ lengthInBits += ${helper.getEnumBaseTypeReference(enumField.type).sizeInBits};
+ <#break>
+ <#case "implicit">
+ <#assign implicitField = field.asImplicitField().orElseThrow()>
+ <#assign simpleTypeReference = implicitField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Implicit Field (${implicitField.name})
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ <#break>
+ <#case "manualArray">
+ <#assign manualArrayField = field.asManualArrayField().orElseThrow()>
+
+ // Manual Array Field (${manualArrayField.name})
+ lengthInBits += ${helper.toSerializationExpression(type, manualArrayField, manualArrayField.lengthExpression, parserArguments)};
+ <#break>
+ <#case "manual">
+ <#assign manualField = field.asManualField().orElseThrow()>
+
+ // Manual Field (${manualField.name})
+ <#-- if the expression uses the "_value", we need to locally define it so we can access it in the expression -->
+ <#if manualField.lengthExpression.contains("_value")>
+ {
+ ${helper.getLanguageTypeNameForField(manualField)} _value = data_item->data.${case.name?lower_case}_value;
+ lengthInBits += ${helper.toSerializationExpression(type, manualField, manualField.lengthExpression, parserArguments)};
+ }
+ <#else>
+ lengthInBits += ${helper.toSerializationExpression(type, manualField, manualField.lengthExpression, parserArguments)};
+ </#if>
+ <#break>
+ <#case "optional">
+ <#assign optionalField = field.asOptionalField().orElseThrow()>
+
+ // Optional Field (${optionalField.name})
+ if(data_item->${helper.getFieldName(type, optionalField)} != NULL) {
+ <#if optionalField.type.isSimpleTypeReference()>
+ <#assign simpleTypeReference = optionalField.type.asSimpleTypeReference().orElseThrow()>
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ <#else>
+ lengthInBits += ${helper.getLengthInBitsFunctionNameForComplexTypedField(optionalField)}(data_item->${helper.getFieldName(type, optionalField)});
+ </#if>
+ }
+ <#break>
+ <#case "padding">
+ <#assign paddingField = field.asPaddingField().orElseThrow()>
+ <#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Padding Field (padding)
+ <#-- We're replacing the "lastItem" with 'false' here as the item itself can't know if it is the last -->
+ int _needsPadding = (int) (${helper.toSerializationExpression(type, paddingField, paddingField.paddingCondition, parserArguments)?replace("lastItem", "false")});
+ while(_needsPadding-- > 0) {
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ }
+ <#break>
+ <#case "reserved">
+ <#assign reservedField = field.asReservedField().orElseThrow()>
+ <#assign simpleTypeReference = reservedField.type.asSimpleTypeReference().orElseThrow()>
+
+ // Reserved Field (reserved)
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ <#break>
+ <#case "simple">
+ <#assign simpleField = field.asSimpleField().orElseThrow()>
+
+ // Simple field (${simpleField.name})
+ <#if simpleField.type.isSimpleTypeReference()>
+ <#assign simpleTypeReference = simpleField.type.asSimpleTypeReference().orElseThrow()>
+ <#if simpleTypeReference.isVstringTypeReference()>
+ <#assign vstringTypeReference = simpleTypeReference.asVstringTypeReference().orElseThrow()>
+ lengthInBits += ${helper.toSerializationExpression(type, simpleField, vstringTypeReference.lengthExpression, parserArguments)};
+ <#else>
+ lengthInBits += ${simpleTypeReference.sizeInBits};
+ </#if>
+ <#else>
+ lengthInBits += ${helper.getLengthInBitsFunctionNameForComplexTypedField(simpleField)}(<#if simpleField.type.isEnumTypeReference()>&</#if>data_item->${helper.getFieldName(type, simpleField)});
+ </#if>
+ <#break>
+ <#case "virtual">
+ <#assign virtualField = field.asVirtualField().orElseThrow()>
+
+ // A virtual field doesn't have any in- or output.
+ <#break>
+ </#switch>
+ </#list>
+ }<#sep> else </#sep></#list>
return lengthInBits;
}
diff --git a/code-generation/language-c/src/main/resources/templates/c/data-io-template.h.ftlh b/code-generation/language-c/src/main/resources/templates/c/data-io-template.h.ftlh
index a288213703..c5e1aa60e0 100644
--- a/code-generation/language-c/src/main/resources/templates/c/data-io-template.h.ftlh
+++ b/code-generation/language-c/src/main/resources/templates/c/data-io-template.h.ftlh
@@ -79,11 +79,11 @@ plc4c_return_code ${helper.getCTypeName(type.name)}_parse(plc4c_spi_read_buffer*
<#--
Define the serialize-method for elements of this tpye
-->
-plc4c_return_code ${helper.getCTypeName(type.name)}_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_data** data_item);
+plc4c_return_code ${helper.getCTypeName(type.name)}_serialize(plc4c_spi_write_buffer* writeBuffer, <#if parserArguments?has_content><#list parserArguments as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type)}<#if !parserArgument.type.isSimpleTypeReference() && !parserArgument.type.isEnumTypeReference()>*</#if> ${parserArgument.name}<#sep>, </#list>, </#if>plc4c_data** data_item);
-uint16_t ${helper.getCTypeName(type.name)}_length_in_bytes(plc4c_data* data_item);
+uint16_t ${helper.getCTypeName(type.name)}_length_in_bytes(plc4c_data* data_item<#if parserArguments?has_content>, <#list parserArguments as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type)}<#if !parserArgument.type.isSimpleTypeReference() && !parserArgument.type.isEnumTypeReference()>*</#if> ${parserArgument.name}<#sep>, </#list></#if>);
-uint16_t ${helper.getCTypeName(type.name)}_length_in_bits(plc4c_data* data_item);
+uint16_t ${helper.getCTypeName(type.name)}_length_in_bits(plc4c_data* data_item<#if parserArguments?has_content>, <#list parserArguments as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type)}<#if !parserArgument.type.isSimpleTypeReference() && !parserArgument.type.isEnumTypeReference()>*</#if> ${parserArgument.name}<#sep>, </#list></#if>);
<#--#ifdef __cplusplus
}
diff --git a/plc4c/api/include/plc4c/data.h b/plc4c/api/include/plc4c/data.h
index 6b9b6480a6..e90a4f893c 100644
--- a/plc4c/api/include/plc4c/data.h
+++ b/plc4c/api/include/plc4c/data.h
@@ -44,82 +44,91 @@ typedef void (*plc4c_data_custom_printf)(plc4c_data *data);
plc4c_data *plc4c_data_create_bool_data(bool b);
plc4c_data *plc4c_data_create_bool_array(bool *b, int nItem);
/**
- * Creates a plc4c_data with char
- * @param c the char value
+ * Creates a plc4c_data with unsigned 8 bit integer
+ * @param ui the unsigned 8 bit integer value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_int8_t_data(int8_t c);
-plc4c_data *plc4c_data_create_int8_t_array(int8_t *c, int nItem);
+plc4c_data *plc4c_data_create_usint_data(uint8_t ui);
+plc4c_data *plc4c_data_create_usint_array(uint8_t *ui, int nItem);
/**
- * Creates a plc4c_data with unsigned char
- * @param uc the unsigned char value
+ * Creates a plc4c_data with a signed 8 bit integer
+ * @param i signed 8 bit integer
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_uint8_t_data(uint8_t uc);
-plc4c_data *plc4c_data_create_uint8_t_array(uint8_t *uc, int nItem);
+plc4c_data *plc4c_data_create_sint_data(int8_t i);
+plc4c_data *plc4c_data_create_sint_array(int8_t *i, int nItem);
/**
- * Creates a plc4c_data with short
- * @param s the short value
+ * Creates a plc4c_data with unsigned 16 bit integer
+ * @param ui the unsigned short value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_int16_t_data(int16_t s);
-plc4c_data *plc4c_data_create_int16_t_array(int16_t *s, int nItem);
+plc4c_data *plc4c_data_create_uint_data(uint16_t ui);
+plc4c_data *plc4c_data_create_uint_array(uint16_t *ui, int nItem);
/**
- * Creates a plc4c_data with unsigned short
- * @param us the unsigned short value
+ * Creates a plc4c_data with signed 16 bit integer
+ * @param i the short value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_uint16_t_data(uint16_t us);
-plc4c_data *plc4c_data_create_uint16_t_array(uint16_t *us, int nItem);
+plc4c_data *plc4c_data_create_int_data(int16_t i);
+plc4c_data *plc4c_data_create_int_array(int16_t *i, int nItem);
/**
- * Creates a plc4c_data with int
- * @param i the int value
+ * Creates a plc4c_data with unsigned 32 bit integer
+ * @param ui the unsigned 32 bit integer value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_int32_t_data(int32_t i);
-plc4c_data *plc4c_data_create_int32_t_array(int32_t *i, int nItem);
+plc4c_data *plc4c_data_create_udint_data(uint32_t ui);
+plc4c_data *plc4c_data_create_udint_array(uint32_t *ui, int nItem);
/**
- * Creates a plc4c_data with unsigned int
- * @param ui the unsigned int value
+ * Creates a plc4c_data with signed 32 bit integer
+ * @param i the signed 32 bit integer value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_uint32_t_data(uint32_t ui);
-plc4c_data *plc4c_data_create_uint32_t_array(uint32_t *ui, int nItem);
+plc4c_data *plc4c_data_create_dint_data(int32_t i);
+plc4c_data *plc4c_data_create_dint_array(int32_t *i, int nItem);
/**
- * Creates a plc4c_data with int
- * @param i the int value
+ * Creates a plc4c_data with unsigned 64 bit integer
+ * @param ui the 64 bit integer value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_int64_t_data(int64_t i);
-plc4c_data *plc4c_data_create_int64_t_array(int64_t *i, int nItem);
+plc4c_data *plc4c_data_create_ulint_data(uint64_t ui);
+plc4c_data *plc4c_data_create_ulint_array(uint64_t *ui, int nItem);
/**
- * Creates a plc4c_data with unsigned int
- * @param ui the unsigned int value
+ * Creates a plc4c_data with signed 64 bit integer
+ * @param i the signed 64 bit integer value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_uint64_t_data(uint64_t ui);
-plc4c_data *plc4c_data_create_uint64_t_array(uint64_t *ui, int nItem);
-/**
- * Creates a plc4c_data with void*
- * @param v the void* value
- * @return pointer to plc4c_data
- */
-plc4c_data *plc4c_data_create_void_pointer_data(void *v);
+plc4c_data *plc4c_data_create_lint_data(int64_t i);
+plc4c_data *plc4c_data_create_lint_array(int64_t *i, int nItem);
/**
* Creates a plc4c_data with float
* @param f the float value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_float_data(float f);
-plc4c_data *plc4c_data_create_float_array(float *f, int nItem);
+plc4c_data *plc4c_data_create_real_data(float f);
+plc4c_data *plc4c_data_create_real_array(float *f, int nItem);
/**
* Creates a plc4c_data with float
* @param f the float value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_double_data(double d);
-plc4c_data *plc4c_data_create_double_array(double *d, int nItems);
+plc4c_data *plc4c_data_create_lreal_data(double d);
+plc4c_data *plc4c_data_create_lreal_array(double *d, int nItems);
+
+plc4c_data *plc4c_data_create_date_data(uint16_t d);
+plc4c_data *plc4c_data_create_date_array(uint16_t *d, int nItems);
+
+plc4c_data *plc4c_data_create_time_data(uint32_t t);
+plc4c_data *plc4c_data_create_time_array(uint32_t *t, int nItems);
+
+plc4c_data *plc4c_data_create_ltime_data(uint64_t lt);
+plc4c_data *plc4c_data_create_ltime_array(uint64_t *lt, int nItems);
+
+ plc4c_data *plc4c_data_create_time_of_day_data(uint32_t tod);
+plc4c_data *plc4c_data_create_time_of_day_array(uint32_t *tod, int nItems);
+
+plc4c_data *plc4c_data_create_date_and_time_data(uint32_t tad);
+plc4c_data *plc4c_data_create_date_and_time_array(uint32_t *tad, int nItems);
/**
* Creates a plc4c_data with char*
@@ -130,31 +139,54 @@ plc4c_data *plc4c_data_create_double_array(double *d, int nItems);
plc4c_data *plc4c_data_create_string_data(unsigned int size, char *s);
/**
- * Creates a plc4c_data with a constant char*
- * @param size the size of the string
- * @param s the char *value
+ * Creates a plc4c_data with a constant char
+ * @param s the char value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_constant_string_data(unsigned int size, char *s);
+plc4c_data *plc4c_data_create_char_data(char s);
/**
- * Creates a plc4c_data with a constant char
- * @param s the char value
+ * Creates a plc4c_data with a constant 16bit wchar
+ * @param s the wchar value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_char_data(char* s);
+plc4c_data *plc4c_data_create_wchar_data(wchar_t s);
/**
* Creates a plc4c_data which contains a list of values
* @param list the list value
* @return pointer to plc4c_data
*/
-plc4c_data *plc4c_data_create_list_data(plc4c_list list);
+plc4c_data *plc4c_data_create_list_data(plc4c_list* list);
+
+/**
+ * Create a plc4c_data which contains a bit-string of 8 boolean values
+ * @param ui unsigned 8 bit integer value.
+ * @return pointer to plc4c_data
+ */
+plc4c_data *plc4c_data_create_byte_data(uint8_t ui);
+
+/**
+ * Create a plc4c_data which contains a bit-string of 16 boolean values
+ * @param ui unsigned 16 bit integer value.
+ * @return pointer to plc4c_data
+ */
+plc4c_data *plc4c_data_create_word_data(uint16_t ui);
+
+/**
+ * Create a plc4c_data which contains a bit-string of 32 boolean values
+ * @param ui unsigned 32 bit integer value.
+ * @return pointer to plc4c_data
+ */
+plc4c_data *plc4c_data_create_dword_data(uint32_t ui);
+
+/**
+ * Create a plc4c_data which contains a bit-string of 64 boolean values
+ * @param ui unsigned 64 bit integer value.
+ * @return pointer to plc4c_data
+ */
+plc4c_data *plc4c_data_create_lword_data(uint64_t ui);
-plc4c_data *plc4c_data_create_uint8_t_bit_string_data(uint8_t uc);
-plc4c_data *plc4c_data_create_uint16_t_bit_string_data(uint16_t us);
-plc4c_data *plc4c_data_create_uint32_t_bit_string_data(uint32_t ui);
-plc4c_data *plc4c_data_create_uint64_t_bit_string_data(uint64_t ui);
/**
* Set a custom function to call when destroying this data. Typically when the
* type is a PLC4C_VOID_POINTER
diff --git a/plc4c/api/include/plc4c/types.h b/plc4c/api/include/plc4c/types.h
index ad08d2adf2..bc9820e655 100644
--- a/plc4c/api/include/plc4c/types.h
+++ b/plc4c/api/include/plc4c/types.h
@@ -73,20 +73,46 @@ typedef enum plc4c_response_code {
* PLC4C data types
*/
typedef enum plc4c_data_type {
+ // Boolean/Bit-String Types
PLC4C_BOOL,
- PLC4C_CHAR,
- PLC4C_UCHAR,
- PLC4C_SHORT,
- PLC4C_USHORT,
- PLC4C_INT,
+ PLC4C_BYTE,
+ PLC4C_WORD,
+ PLC4C_DWORD,
+ PLC4C_LWORD,
+ // Integer Types (Unsigned/Signed)
+ // 1-byte
+ PLC4C_USINT,
+ PLC4C_SINT,
+ // 2-byte
PLC4C_UINT,
- PLC4C_LINT,
+ PLC4C_INT,
+ // 4-byte
+ PLC4C_UDINT,
+ PLC4C_DINT,
+ // 8-byte
PLC4C_ULINT,
- PLC4C_FLOAT,
- PLC4C_DOUBLE,
- PLC4C_STRING_POINTER,
- PLC4C_CONSTANT_STRING,
- PLC4C_VOID_POINTER,
+ PLC4C_LINT,
+ // Floating-Point Types
+ PLC4C_REAL,
+ PLC4C_LREAL,
+ // Time Types
+ PLC4C_TIME,
+ PLC4C_LTIME,
+ // Date Types
+ PLC4C_DATE,
+ PLC4C_LDATE,
+ // Time of day Types
+ PLC4C_TIME_OF_DAY,
+ PLC4C_LTIME_OF_DAY,
+ // Date and Time Types
+ PLC4C_DATE_AND_TIME,
+ PLC4C_LDATE_AND_TIME,
+ // Char and String Types
+ PLC4C_CHAR,
+ PLC4C_WCHAR,
+ PLC4C_STRING,
+ PLC4C_WSTRING,
+
PLC4C_LIST,
PLC4C_STRUCT
} plc4c_data_type;
diff --git a/plc4c/drivers/modbus/include/plc4c/driver_modbus_sm.h b/plc4c/drivers/modbus/include/plc4c/driver_modbus_sm.h
index faabe84a51..f0125a12d6 100644
--- a/plc4c/drivers/modbus/include/plc4c/driver_modbus_sm.h
+++ b/plc4c/drivers/modbus/include/plc4c/driver_modbus_sm.h
@@ -34,11 +34,13 @@ plc4c_return_code plc4c_driver_modbus_disconnect_function(
plc4c_return_code plc4c_driver_modbus_read_function(
plc4c_read_request_execution* read_request_execution,
plc4c_system_task** task);
+void plc4c_driver_modbus_free_read_request(plc4c_read_request* request);
void plc4c_driver_modbus_free_read_response(plc4c_read_response* response);
plc4c_return_code plc4c_driver_modbus_write_function(
plc4c_write_request_execution* write_request_execution,
plc4c_system_task** task);
+void plc4c_driver_modbus_free_write_request(plc4c_write_request* request);
void plc4c_driver_modbus_free_write_response(plc4c_write_response* response);
#ifdef __cplusplus
diff --git a/plc4c/drivers/modbus/src/driver_modbus.c b/plc4c/drivers/modbus/src/driver_modbus.c
index e0989bcd0a..9b05aa84b2 100644
--- a/plc4c/drivers/modbus/src/driver_modbus.c
+++ b/plc4c/drivers/modbus/src/driver_modbus.c
@@ -52,7 +52,9 @@ plc4c_driver *plc4c_driver_modbus_create() {
driver->write_function = &plc4c_driver_modbus_write_function;
driver->subscribe_function = NULL;
driver->unsubscribe_function = NULL;
+ driver->free_read_request_function = &plc4c_driver_modbus_free_read_request;
driver->free_read_response_function = &plc4c_driver_modbus_free_read_response;
+ driver->free_write_request_function = &plc4c_driver_modbus_free_write_request;
driver->free_write_response_function = &plc4c_driver_modbus_free_write_response;
driver->free_subscription_response_function = NULL;
driver->free_unsubscription_response_function = NULL;
diff --git a/plc4c/drivers/modbus/src/driver_modbus_packets.c b/plc4c/drivers/modbus/src/driver_modbus_packets.c
index e72229d440..2a6ec6faf2 100644
--- a/plc4c/drivers/modbus/src/driver_modbus_packets.c
+++ b/plc4c/drivers/modbus/src/driver_modbus_packets.c
@@ -43,7 +43,7 @@ int16_t plc4c_driver_modbus_select_message_function(uint8_t* buffer_data,
uint16_t packet_length =
((uint16_t)*(buffer_data + 4) << 8) | ((uint16_t)*(buffer_data + 5));
packet_length += 6;
- return packet_length;
+ return (int16_t) packet_length;
}
// In all other cases, we'll just have to wait for the next time.
return 0;
diff --git a/plc4c/drivers/modbus/src/driver_modbus_sm_disconnect.c b/plc4c/drivers/modbus/src/driver_modbus_sm_disconnect.c
index 82070f0fb1..b4f310b8d7 100644
--- a/plc4c/drivers/modbus/src/driver_modbus_sm_disconnect.c
+++ b/plc4c/drivers/modbus/src/driver_modbus_sm_disconnect.c
@@ -19,7 +19,6 @@
#include <plc4c/plc4c.h>
#include <plc4c/spi/types_private.h>
-#include <string.h>
enum plc4c_driver_modbus_disconnect_states {
PLC4C_DRIVER_MODBUS_DISCONNECT_INIT,
diff --git a/plc4c/drivers/modbus/src/driver_modbus_sm_read.c b/plc4c/drivers/modbus/src/driver_modbus_sm_read.c
index a2e59de4df..44cd2685db 100644
--- a/plc4c/drivers/modbus/src/driver_modbus_sm_read.c
+++ b/plc4c/drivers/modbus/src/driver_modbus_sm_read.c
@@ -222,6 +222,21 @@ plc4c_return_code plc4c_driver_modbus_read_function(
return OK;
}
+void plc4c_driver_modbus_free_read_request_item(
+ plc4c_list_element* read_item_element) {
+ plc4c_item* value_item =
+ (plc4c_item*)read_item_element->value;
+ plc4c_driver_modbus_item* modbus_item = (plc4c_driver_modbus_item*) value_item->address;
+ free(modbus_item);
+ value_item->address = NULL;
+}
+
+void plc4c_driver_modbus_free_read_request(plc4c_read_request* request) {
+ // the request will be cleaned up elsewhere
+ plc4c_utils_list_delete_elements(request->items,
+ plc4c_driver_modbus_free_read_request_item);
+}
+
void plc4c_driver_modbus_free_read_response_item(
plc4c_list_element* read_item_element) {
plc4c_response_value_item* value_item =
@@ -233,5 +248,5 @@ void plc4c_driver_modbus_free_read_response_item(
void plc4c_driver_modbus_free_read_response(plc4c_read_response* response) {
// the request will be cleaned up elsewhere
plc4c_utils_list_delete_elements(response->items,
- &plc4c_driver_modbus_free_read_response_item);
+ plc4c_driver_modbus_free_read_response_item);
}
diff --git a/plc4c/drivers/modbus/src/driver_modbus_sm_write.c b/plc4c/drivers/modbus/src/driver_modbus_sm_write.c
index 4c9698bf7f..985478e936 100644
--- a/plc4c/drivers/modbus/src/driver_modbus_sm_write.c
+++ b/plc4c/drivers/modbus/src/driver_modbus_sm_write.c
@@ -100,6 +100,23 @@ plc4c_return_code plc4c_driver_modbus_write_function(
return OK;
}
+void plc4c_driver_modbus_free_write_request_item(
+ plc4c_list_element* write_item_element) {
+ plc4c_request_value_item* value_item =
+ (plc4c_request_value_item*)write_item_element->value;
+ // do not delete the plc4c_item
+ // we also, in THIS case don't delete the random value which isn't really
+ // a pointer
+ // free(value_item->value);
+ value_item->value = NULL;
+}
+
+void plc4c_driver_modbus_free_write_request(plc4c_write_request* request) {
+ // the request will be cleaned up elsewhere
+ plc4c_utils_list_delete_elements(request->items,
+ &plc4c_driver_modbus_free_write_request_item);
+}
+
void plc4c_driver_modbus_free_write_response_item(
plc4c_list_element* write_item_element) {
plc4c_response_value_item* value_item =
diff --git a/plc4c/drivers/plc4x/src/driver_plc4x_sm_write.c b/plc4c/drivers/plc4x/src/driver_plc4x_sm_write.c
index d5a35c15eb..9285508cb3 100644
--- a/plc4c/drivers/plc4x/src/driver_plc4x_sm_write.c
+++ b/plc4c/drivers/plc4x/src/driver_plc4x_sm_write.c
@@ -172,10 +172,10 @@ void plc4c_driver_plc4x_free_write_request(plc4c_write_request *request) {
void plc4c_driver_plc4x_free_write_response_item(
plc4c_list_element* write_item_element) {
- plc4c_response_item* responce_item;
- responce_item = write_item_element->value;
- // dont free responce_item-item->item its managed by the request not responce
- free(responce_item);
+ plc4c_response_item* response_item;
+ response_item = write_item_element->value;
+ // dont free response_item-item->item its managed by the request not response
+ free(response_item);
}
void plc4c_driver_plc4x_free_write_response(plc4c_write_response* response) {
diff --git a/plc4c/drivers/plc4x/test/plc4x_test.c b/plc4c/drivers/plc4x/test/plc4x_test.c
index a51895c40d..b6b8630412 100644
--- a/plc4c/drivers/plc4x/test/plc4x_test.c
+++ b/plc4c/drivers/plc4x/test/plc4x_test.c
@@ -28,7 +28,7 @@ int main(void) {
UNITY_BEGIN();
// Execute the auto-generated serializer/parser tests.
- //parser_serializer_test_plc4x_read_write();
+ parser_serializer_test_plc4x_read_write();
return UNITY_END();
}
\ No newline at end of file
diff --git a/plc4c/drivers/s7/include/plc4c/driver_s7_static.h b/plc4c/drivers/s7/include/plc4c/driver_s7_static.h
index 5b838ace63..aa516d24ab 100644
--- a/plc4c/drivers/s7/include/plc4c/driver_s7_static.h
+++ b/plc4c/drivers/s7/include/plc4c/driver_s7_static.h
@@ -32,6 +32,7 @@ extern "C" {
* Static functions
*
*/
+uint8_t plc4c_spi_evaluation_helper_str_len(char* str);
uint16_t plc4c_s7_read_write_event_item_length(plc4c_spi_read_buffer* io, uint16_t valueLength);
diff --git a/plc4c/drivers/s7/src/driver_modbus_encode_decode.c b/plc4c/drivers/s7/src/driver_modbus_encode_decode.c
index dc90456bbe..4ac282a2cd 100644
--- a/plc4c/drivers/s7/src/driver_modbus_encode_decode.c
+++ b/plc4c/drivers/s7/src/driver_modbus_encode_decode.c
@@ -20,7 +20,6 @@
#include <cotp_protocol_class.h>
#include <ctype.h>
#include <plc4c/driver_s7.h>
-#include <plc4c/spi/types_private.h>
#include <stdlib.h>
#include <string.h>
#include <tpkt_packet.h>
@@ -67,10 +66,10 @@ plc4c_driver_s7_controller_type decode_controller_type(char* article_number) {
int8_t decode_hex_char(char c) {
if (('0' <= c) && (c <= '9')) {
- return c - 48;
+ return (int8_t) (c - 48);
}
if (('A' <= c) && (c <= 'D')) {
- return c - 55;
+ return (int8_t) (c - 55);
}
return -1;
}
diff --git a/plc4c/drivers/s7/src/driver_s7_packets.c b/plc4c/drivers/s7/src/driver_s7_packets.c
index db81811f6d..903eaa2729 100644
--- a/plc4c/drivers/s7/src/driver_s7_packets.c
+++ b/plc4c/drivers/s7/src/driver_s7_packets.c
@@ -18,7 +18,6 @@
*/
#include <cotp_protocol_class.h>
-#include <ctype.h>
#include <plc4c/driver_s7.h>
#include <plc4c/spi/types_private.h>
#include <stdlib.h>
@@ -32,7 +31,7 @@
// probably safe to comment out but on for now.
//#define DEEP_WRITE_DATA_COPY
-// forward delcaration for helper function todo: move to header or relocate
+// forward declaration for helper function todo: move to header or relocate
//plc4c_utils_list_insert_head_value(request_value->data, &parsed_value->data);
void plc4c_add_data_to_request(plc4c_data* parsed_value,
plc4c_s7_read_write_s7_var_payload_data_item* request_value) {
@@ -44,25 +43,25 @@ void plc4c_add_data_to_request(plc4c_data* parsed_value,
plc4c_list_element* list_array;
plc4c_data* the_data;
int i, j;
- int items;
- int item_size;
+ size_t items;
+ size_t item_size;
// If its a list size doesn't really mean anything we care about list len
- if (parsed_value->data_type == PLC4C_LIST)
- items = plc4c_utils_list_size(&parsed_value->data.list_value);
+ if (parsed_value->data_type == PLC4C_LIST)
+ items = plc4c_utils_list_size(parsed_value->data.list_value);
else
items = 1;
for (i = 0 ; i < items ; i++) {
if (parsed_value->data_type == PLC4C_LIST) {
- // will not work with nested lists if thats even a thing
- list_array = (i == 0) ? parsed_value->data.list_value.head : list_array->previous;
+ // will not work with nested lists if that's even a thing
+ list_array = (i == 0) ? parsed_value->data.list_value->head : list_array->previous;
the_data = list_array->value;
item_size = the_data->size;
- data_array = (int8_t*) &the_data->data;
+ data_array = (uint8_t*) &the_data->data;
} else {
item_size = parsed_value->size;
- data_array = (int8_t*) &parsed_value->data;
+ data_array = (uint8_t*) &parsed_value->data;
}
// Now add the bytes to a list
for (j = 0 ; j < item_size ; j++) {
@@ -101,13 +100,13 @@ int16_t plc4c_driver_s7_select_message_function(uint8_t* buffer_data,
buffer_data++;
if ((*buffer_data == 0x03) && (*(buffer_data + 1) == 0x00)) {
// We've found a potential new packet start.
- return -(i - 1);
+ return (int16_t) -(i - 1);
}
}
// We didn't find a new start, delete the entire content except the last
// byte (as this could be the start of the next frame and we couldn't
// confirm this.
- return -(buffer_length - 1);
+ return (int16_t) -(buffer_length - 1);
}
}
// The length information is located in bytes 3 and 4
@@ -116,7 +115,7 @@ int16_t plc4c_driver_s7_select_message_function(uint8_t* buffer_data,
((uint16_t) *(buffer_data + 2) << 8) |
((uint16_t) *(buffer_data + 3));
if (buffer_length >= packet_length) {
- return packet_length;
+ return (int16_t) packet_length;
}
// 8192 is the maximum pdu size, so if the value is larger, the packet is
// probably corrupt.
@@ -125,12 +124,12 @@ int16_t plc4c_driver_s7_select_message_function(uint8_t* buffer_data,
buffer_data++;
if ((*buffer_data == 0x03) && (*(buffer_data + 1) == 0x00)) {
// We've found a potential new packet start.
- return -(i - 1);
+ return (int16_t) -(i - 1);
}
}
- return -(buffer_length - 1);
+ return (int16_t) -(buffer_length - 1);
}
- return packet_length;
+ return (int16_t) packet_length;
}
// In all other cases, we'll just have to wait for the next time.
return 0;
@@ -200,16 +199,17 @@ plc4c_return_code plc4c_driver_s7_receive_packet(plc4c_connection* connection,
}
void delete_byte_list(plc4c_list_element *element) {
- int8_t* item;
+ char* item;
item = element->value;
- free(item);
+ // TODO: Fix this!
+ //free(item);
}
void delete_s7_parameter_list_element(plc4c_list_element *element) {
plc4c_s7_read_write_s7_parameter *item;
item = element->value;
free(item);
}
-void delete_s7_read_responce_payload_list_element(plc4c_list_element *element) {
+void delete_s7_read_response_payload_list_element(plc4c_list_element *element) {
plc4c_s7_read_write_s7_var_payload_data_item *item;
item = element->value;
plc4c_utils_list_delete_elements(item->data, delete_byte_list);
@@ -221,15 +221,16 @@ void delete_s7_write_request_payload_list_element(plc4c_list_element *element) {
item = element->value;
free(item);
}
-void delete_s7_write_responce_payload_list_element(plc4c_list_element *element) {
+void delete_s7_write_response_payload_list_element(plc4c_list_element *element) {
plc4c_s7_read_write_s7_var_payload_status_item *item;
item = element->value;
free(item);
}
void delete_mlfb_list(plc4c_list_element *element) {
- int8_t* item;
+ char* item;
item = element->value;
- free(item);
+ // TODO: Fix this!
+ //free(item);
}
void delete_szl_list(plc4c_list_element *element){
plc4c_s7_read_write_szl_data_tree_item *item;
@@ -338,7 +339,7 @@ void plc4c_driver_s7_destroy_receive_packet(
switch (s7_payload->_type) {
case plc4c_s7_read_write_s7_payload_type_plc4c_s7_read_write_s7_payload_read_var_response:
plc4c_utils_list_delete_elements(s7_payload->s7_payload_read_var_response_items,
- delete_s7_read_responce_payload_list_element);
+ delete_s7_read_response_payload_list_element);
free(s7_payload->s7_payload_read_var_response_items);
break;
case plc4c_s7_read_write_s7_payload_type_plc4c_s7_read_write_s7_payload_write_var_request:
@@ -348,7 +349,7 @@ void plc4c_driver_s7_destroy_receive_packet(
break;
case plc4c_s7_read_write_s7_payload_type_plc4c_s7_read_write_s7_payload_write_var_response:
plc4c_utils_list_delete_elements(s7_payload->s7_payload_write_var_response_items,
- delete_s7_write_responce_payload_list_element);
+ delete_s7_write_response_payload_list_element);
free(s7_payload->s7_payload_write_var_response_items);
break;
case plc4c_s7_read_write_s7_payload_type_plc4c_s7_read_write_s7_payload_user_data:
diff --git a/plc4c/drivers/s7/src/driver_s7_sm_read.c b/plc4c/drivers/s7/src/driver_s7_sm_read.c
index bf306c3bfb..8a3d86aaac 100644
--- a/plc4c/drivers/s7/src/driver_s7_sm_read.c
+++ b/plc4c/drivers/s7/src/driver_s7_sm_read.c
@@ -173,7 +173,7 @@ void plc4c_driver_s7_free_read_response_item(
plc4c_response_value_item* value_item;
value_item = element->value;
plc4c_data_destroy(value_item->value);
- // dont free value_item->item its managed by the request not responce
+ // dont free value_item->item its managed by the request not response
free(value_item);
}
@@ -210,7 +210,7 @@ plc4c_return_code plc4c_driver_s7_parse_read_response(
size_t idx;
enum plc4c_return_code result;
- // Make a new list for holding the responce value items
+ // Make a new list for holding the response value items
plc4c_utils_list_create(&execution->read_response->items);
// Iterate over the request items and use the types to decode the
@@ -254,11 +254,11 @@ plc4c_return_code plc4c_driver_s7_parse_read_response(
plc4c_list *all_list;
plc4c_data* all_data_item;
plc4c_utils_list_create(&all_list);
- all_data_item = plc4c_data_create_list_data(*all_list);
+ all_data_item = plc4c_data_create_list_data(all_list);
free(all_list);
for (idx = 0; idx < num_elements ; idx++) {
plc4c_s7_read_write_data_item_parse(read_buffer, data_protocol_id, string_length, &data_item);
- plc4c_utils_list_insert_head_value(&all_data_item->data.list_value, (void*)data_item);
+ plc4c_utils_list_insert_head_value(all_data_item->data.list_value, (void*)data_item);
}
data_item = all_data_item;
} else {
diff --git a/plc4c/drivers/s7/src/driver_s7_sm_write.c b/plc4c/drivers/s7/src/driver_s7_sm_write.c
index 8ebe1dbbc1..c0f632d8e7 100644
--- a/plc4c/drivers/s7/src/driver_s7_sm_write.c
+++ b/plc4c/drivers/s7/src/driver_s7_sm_write.c
@@ -35,7 +35,7 @@ enum plc4c_driver_s7_write_states {
// Forward declaration of helper function to stop PLC4C_DRIVER_S7_WRITE_FINISHED
// state become too big, TODO: move to some header or inline
-plc4c_return_code plc4c_driver_s7_parse_write_responce(
+plc4c_return_code plc4c_driver_s7_parse_write_response(
plc4c_write_request_execution* execution, plc4c_s7_read_write_tpkt_packet* packet);
@@ -83,15 +83,15 @@ plc4c_return_code plc4c_driver_s7_sm_write_finished(
plc4c_utils_list_size(execution->write_request->items))
return INTERNAL_ERROR;
- // Make a new responce item and bind to the execution, also bind
- // the request to the responce (usefull of parseing)
+ // Make a new response item and bind to the execution, also bind
+ // the request to the response (useful of parsing)
execution->write_response = malloc(sizeof(plc4c_write_response));
if (execution->write_response == NULL)
return NO_MEMORY;
execution->write_response->write_request = execution->write_request;
- // Set the write responce status from the s7 payload responce status
- result = plc4c_driver_s7_parse_write_responce(execution, packet);
+ // Set the write response status from the s7 payload response status
+ result = plc4c_driver_s7_parse_write_response(execution, packet);
if (result != OK)
return result;
@@ -184,10 +184,10 @@ void plc4c_driver_s7_free_write_request(plc4c_write_request *request) {
void plc4c_driver_s7_free_write_response_item(
plc4c_list_element* write_item_element) {
- plc4c_response_item* responce_item;
- responce_item = write_item_element->value;
- // dont free responce_item-item->item its managed by the request not responce
- free(responce_item);
+ plc4c_response_item* response_item;
+ response_item = write_item_element->value;
+ // dont free response_item-item->item its managed by the request not response
+ free(response_item);
}
void plc4c_driver_s7_free_write_response(plc4c_write_response* response) {
@@ -198,7 +198,7 @@ void plc4c_driver_s7_free_write_response(plc4c_write_response* response) {
}
-plc4c_return_code plc4c_driver_s7_parse_write_responce(
+plc4c_return_code plc4c_driver_s7_parse_write_response(
plc4c_write_request_execution *execution,
plc4c_s7_read_write_tpkt_packet* packet) {
@@ -210,7 +210,7 @@ plc4c_return_code plc4c_driver_s7_parse_write_responce(
plc4c_response_item* response_item;
plc4c_return_code result;
- // Make the unfilled responce a list
+ // Make the unfilled response a list
plc4c_utils_list_create(&execution->write_response->response_items);
// Iterate over the request items setting return codes as needed.
@@ -228,7 +228,7 @@ plc4c_return_code plc4c_driver_s7_parse_write_responce(
return NO_MEMORY;
response_item->item = request_item->item;
- // TODO: better map transport error codes to responce error codes
+ // TODO: better map transport error codes to response error codes
if (s7_payload_item->return_code == plc4c_s7_read_write_data_transport_error_code_OK)
response_item->response_code = PLC4C_RESPONSE_CODE_OK;
else
diff --git a/plc4c/drivers/s7/src/driver_s7_static.c b/plc4c/drivers/s7/src/driver_s7_static.c
index f22d8fc69f..a631b92586 100644
--- a/plc4c/drivers/s7/src/driver_s7_static.c
+++ b/plc4c/drivers/s7/src/driver_s7_static.c
@@ -27,6 +27,9 @@
* Static functions
*
*/
+uint8_t plc4c_spi_evaluation_helper_str_len(char* str) {
+ return strlen(str);
+}
uint16_t plc4c_s7_read_write_event_item_length(plc4c_spi_read_buffer* io, uint16_t valueLength) {
return 0;
diff --git a/plc4c/drivers/simulated/src/driver_simulated.c b/plc4c/drivers/simulated/src/driver_simulated.c
index 7abe1573e4..b2c061f951 100644
--- a/plc4c/drivers/simulated/src/driver_simulated.c
+++ b/plc4c/drivers/simulated/src/driver_simulated.c
@@ -133,7 +133,7 @@ plc4c_return_code plc4c_driver_simulated_read_machine_function(
* we can also set a custom printf method
* right , now just create a new random value
*/
- value_item->value = plc4c_data_create_uint32_t_data(rand());
+ value_item->value = plc4c_data_create_dint_data(rand());
// Add the value to the response.
plc4c_utils_list_insert_tail_value(read_response->items, value_item);
@@ -276,7 +276,7 @@ plc4c_item *plc4c_driver_simulated_parse_address(char *address_string) {
if (strcmp(datatype_name, "INTEGER") == 0) {
data_type = PLC4C_INT;
} else if (strcmp(datatype_name, "STRING") == 0) {
- data_type = PLC4C_CONSTANT_STRING;
+ data_type = PLC4C_STRING;
} else {
free(datatype_name);
free(name);
diff --git a/plc4c/examples/hello-world-s7/src/hello_world_s7.c b/plc4c/examples/hello-world-s7/src/hello_world_s7.c
index ca1699dc3a..2e57590fed 100644
--- a/plc4c/examples/hello-world-s7/src/hello_world_s7.c
+++ b/plc4c/examples/hello-world-s7/src/hello_world_s7.c
@@ -230,7 +230,7 @@ int main(int argc, char** argv) {
printf("FAILED\n");
return -1;
}
- result =
+/* result =
plc4c_read_request_add_item(read_request, "TIME", "%DB4:58:TIME");
if (result != OK) {
printf("FAILED\n");
@@ -266,7 +266,7 @@ int main(int argc, char** argv) {
if (result != OK) {
printf("FAILED\n");
return -1;
- }
+ }*/
// UTF-16 doesn't work well in a portable way
printf("SUCCESS\n");
diff --git a/plc4c/examples/hello-world-s7/src/hello_world_s7_loopback.c b/plc4c/examples/hello-world-s7/src/hello_world_s7_loopback.c
index 90f24c5e27..d192a123f0 100644
--- a/plc4c/examples/hello-world-s7/src/hello_world_s7_loopback.c
+++ b/plc4c/examples/hello-world-s7/src/hello_world_s7_loopback.c
@@ -169,7 +169,7 @@ int main(int argc, char** argv) {
if (loopCount == 1 || rtMalloc) {
result = plc4c_connection_create_write_request(connection, &write_request);
CHECK_RESULT(result != OK, result,"plc4c_connection_create_write_request failed\n");
- loopback_data = plc4c_data_create_float_array(valuetowrite,NREAD);
+ loopback_data = plc4c_data_create_real_array(valuetowrite,NREAD);
valuetowrite[(loopCount-1)%NREAD]++;
result = plc4c_write_request_add_item(write_request, ITEM_STR, loopback_data);
} else {
@@ -212,7 +212,7 @@ int main(int argc, char** argv) {
{ // WRITE_RESPONSE_RECEIVED scope
write_response = plc4c_write_request_execution_get_response(write_request_execution);
- CHECK_RESULT(write_response == NULL, -1,"plc4c_write_request_execution_get_response failed (no responce)\n");
+ CHECK_RESULT(write_response == NULL, -1,"plc4c_write_request_execution_get_response failed (no response)\n");
cur_element = plc4c_utils_list_tail(write_response->response_items);
idx = 0;
while (cur_element != NULL) {
diff --git a/plc4c/generated-sources/modbus/include/data_item.h b/plc4c/generated-sources/modbus/include/data_item.h
index e336933dac..b5c1cd3be2 100644
--- a/plc4c/generated-sources/modbus/include/data_item.h
+++ b/plc4c/generated-sources/modbus/include/data_item.h
@@ -30,10 +30,10 @@
plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer* readBuffer, plc4c_modbus_read_write_modbus_data_type dataType, uint16_t numberOfValues, plc4c_data** data_item);
-plc4c_return_code plc4c_modbus_read_write_data_item_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_data** data_item);
+plc4c_return_code plc4c_modbus_read_write_data_item_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_modbus_read_write_modbus_data_type dataType, uint16_t numberOfValues, plc4c_data** data_item);
-uint16_t plc4c_modbus_read_write_data_item_length_in_bytes(plc4c_data* data_item);
+uint16_t plc4c_modbus_read_write_data_item_length_in_bytes(plc4c_data* data_item, plc4c_modbus_read_write_modbus_data_type dataType, uint16_t numberOfValues);
-uint16_t plc4c_modbus_read_write_data_item_length_in_bits(plc4c_data* data_item);
+uint16_t plc4c_modbus_read_write_data_item_length_in_bits(plc4c_data* data_item, plc4c_modbus_read_write_modbus_data_type dataType, uint16_t numberOfValues);
#endif // PLC4C_MODBUS_READ_WRITE_DATA_ITEM_H_
diff --git a/plc4c/generated-sources/modbus/src/data_item.c b/plc4c/generated-sources/modbus/src/data_item.c
index 42bab03534..964d0a2a13 100644
--- a/plc4c/generated-sources/modbus/src/data_item.c
+++ b/plc4c/generated-sources/modbus/src/data_item.c
@@ -23,6 +23,7 @@
#include <plc4c/data.h>
#include <plc4c/utils/list.h>
#include <plc4c/spi/evaluation_helper.h>
+#include <plc4c/spi/types_private.h>
#include <plc4c/driver_modbus_static.h>
#include "data_item.h"
@@ -74,9 +75,9 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
plc4c_data* _item = plc4c_data_create_bool_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
- } else if((dataType == plc4c_modbus_read_write_modbus_data_type_BYTE) && (numberOfValues == 1)) { /* BitString */
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_BYTE) && (numberOfValues == 1)) { /* List */
// Reserved Field (Compartmentalized so the "reserved" variable can't leak)
{
@@ -90,14 +91,21 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
}
}
- // Simple Field (value)
- uint8_t value = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &value);
- if(_res != OK) {
- return _res;
- }
-
- *data_item = plc4c_data_create_uint8_t_bit_string_data(value);
+ // Array field (value)
+ // Count array
+ plc4c_list* value;
+ plc4c_utils_list_create(&value);
+ int itemCount = (int) 8;
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ bool* _val = malloc(sizeof(bool) * 1);
+ _res = plc4c_spi_read_bit(readBuffer, (bool*) _val);
+ if(_res != OK) {
+ return _res;
+ }
+ plc4c_data* _item = plc4c_data_create_bool_data(*_val);
+ plc4c_utils_list_insert_head_value(value, _item);
+ }
+ *data_item = plc4c_data_create_list_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_BYTE) { /* List */
@@ -115,18 +123,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
plc4c_data* _item = plc4c_data_create_bool_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
-
- } else if((dataType == plc4c_modbus_read_write_modbus_data_type_WORD) && (numberOfValues == 1)) { /* BitString */
-
- // Simple Field (value)
- uint16_t value = 0;
- _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &value);
- if(_res != OK) {
- return _res;
- }
-
- *data_item = plc4c_data_create_uint16_t_bit_string_data(value);
+ *data_item = plc4c_data_create_list_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_WORD) { /* List */
@@ -144,18 +141,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
plc4c_data* _item = plc4c_data_create_bool_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
-
- } else if((dataType == plc4c_modbus_read_write_modbus_data_type_DWORD) && (numberOfValues == 1)) { /* BitString */
-
- // Simple Field (value)
- uint32_t value = 0;
- _res = plc4c_spi_read_unsigned_int(readBuffer, 32, (uint32_t*) &value);
- if(_res != OK) {
- return _res;
- }
-
- *data_item = plc4c_data_create_uint32_t_bit_string_data(value);
+ *data_item = plc4c_data_create_list_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_DWORD) { /* List */
@@ -173,18 +159,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
plc4c_data* _item = plc4c_data_create_bool_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
-
- } else if((dataType == plc4c_modbus_read_write_modbus_data_type_LWORD) && (numberOfValues == 1)) { /* BitString */
-
- // Simple Field (value)
- uint64_t value = 0;
- _res = plc4c_spi_read_unsigned_long(readBuffer, 64, (uint64_t*) &value);
- if(_res != OK) {
- return _res;
- }
-
- *data_item = plc4c_data_create_uint64_t_bit_string_data(value);
+ *data_item = plc4c_data_create_list_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_LWORD) { /* List */
@@ -202,7 +177,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
plc4c_data* _item = plc4c_data_create_bool_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_SINT) && (numberOfValues == 1)) { /* SINT */
@@ -225,7 +200,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_int8_t_data(value);
+ *data_item = plc4c_data_create_sint_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_SINT) { /* List */
@@ -240,10 +215,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_int8_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_sint_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_INT) && (numberOfValues == 1)) { /* INT */
@@ -254,7 +229,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_int16_t_data(value);
+ *data_item = plc4c_data_create_int_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_INT) { /* List */
@@ -269,10 +244,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_int16_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_int_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_DINT) && (numberOfValues == 1)) { /* DINT */
@@ -283,7 +258,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_int32_t_data(value);
+ *data_item = plc4c_data_create_dint_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_DINT) { /* List */
@@ -298,10 +273,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_int32_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_dint_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_LINT) && (numberOfValues == 1)) { /* LINT */
@@ -312,7 +287,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_int64_t_data(value);
+ *data_item = plc4c_data_create_lint_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_LINT) { /* List */
@@ -327,10 +302,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_int64_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_lint_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_USINT) && (numberOfValues == 1)) { /* USINT */
@@ -353,7 +328,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(value);
+ *data_item = plc4c_data_create_usint_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_USINT) { /* List */
@@ -368,10 +343,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_uint8_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_usint_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_UINT) && (numberOfValues == 1)) { /* UINT */
@@ -382,7 +357,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_uint16_t_data(value);
+ *data_item = plc4c_data_create_uint_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_UINT) { /* List */
@@ -397,10 +372,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_uint16_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_uint_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_UDINT) && (numberOfValues == 1)) { /* UDINT */
@@ -411,7 +386,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_uint32_t_data(value);
+ *data_item = plc4c_data_create_udint_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_UDINT) { /* List */
@@ -426,10 +401,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_uint32_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_udint_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_ULINT) && (numberOfValues == 1)) { /* ULINT */
@@ -440,7 +415,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_uint64_t_data(value);
+ *data_item = plc4c_data_create_ulint_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_ULINT) { /* List */
@@ -455,10 +430,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_uint64_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_ulint_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_REAL) && (numberOfValues == 1)) { /* REAL */
@@ -469,7 +444,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_float_data(value);
+ *data_item = plc4c_data_create_real_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_REAL) { /* List */
@@ -484,10 +459,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_float_data(*_val);
+ plc4c_data* _item = plc4c_data_create_real_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_LREAL) && (numberOfValues == 1)) { /* LREAL */
@@ -498,7 +473,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_double_data(value);
+ *data_item = plc4c_data_create_lreal_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_LREAL) { /* List */
@@ -513,10 +488,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_double_data(*_val);
+ plc4c_data* _item = plc4c_data_create_lreal_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_CHAR) && (numberOfValues == 1)) { /* CHAR */
@@ -527,7 +502,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(value);
+ *data_item = plc4c_data_create_char_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_CHAR) { /* List */
@@ -542,10 +517,10 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_uint8_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_usint_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if((dataType == plc4c_modbus_read_write_modbus_data_type_WCHAR) && (numberOfValues == 1)) { /* WCHAR */
@@ -556,7 +531,7 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
return _res;
}
- *data_item = plc4c_data_create_uint16_t_data(value);
+ *data_item = plc4c_data_create_wchar_data(value);
} else if(dataType == plc4c_modbus_read_write_modbus_data_type_WCHAR) { /* List */
@@ -571,29 +546,318 @@ plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer*
if(_res != OK) {
return _res;
}
- plc4c_data* _item = plc4c_data_create_uint16_t_data(*_val);
+ plc4c_data* _item = plc4c_data_create_uint_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
}
return OK;
}
-plc4c_return_code plc4c_modbus_read_write_data_item_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_data** data_item) {
+plc4c_return_code plc4c_modbus_read_write_data_item_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_modbus_read_write_modbus_data_type dataType, uint16_t numberOfValues, plc4c_data** data_item) {
plc4c_return_code _res = OK;
+ if((dataType == plc4c_modbus_read_write_modbus_data_type_BOOL) && (numberOfValues == 1)) { /* BOOL */
+
+ // Reserved Field (reserved)
+
+ // Simple field (value)
+ _res = plc4c_spi_write_bit(writeBuffer, (*data_item)->data.bool_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_BOOL) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_BYTE) && (numberOfValues == 1)) { /* List */
+
+ // Reserved Field (reserved)
+
+ // Array field
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_BYTE) { /* List */
+
+ // Array field
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_WORD) { /* List */
+
+ // Array field
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_DWORD) { /* List */
+
+ // Array field
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_LWORD) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_SINT) && (numberOfValues == 1)) { /* SINT */
+ // Reserved Field (reserved)
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_byte(writeBuffer, 8, (*data_item)->data.sint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_SINT) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_INT) && (numberOfValues == 1)) { /* INT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_short(writeBuffer, 16, (*data_item)->data.int_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_INT) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_DINT) && (numberOfValues == 1)) { /* DINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_int(writeBuffer, 32, (*data_item)->data.dint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_DINT) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_LINT) && (numberOfValues == 1)) { /* LINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_long(writeBuffer, 64, (*data_item)->data.lint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_LINT) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_USINT) && (numberOfValues == 1)) { /* USINT */
+
+ // Reserved Field (reserved)
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.usint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_USINT) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_UINT) && (numberOfValues == 1)) { /* UINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_short(writeBuffer, 16, (*data_item)->data.uint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_UINT) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_UDINT) && (numberOfValues == 1)) { /* UDINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_int(writeBuffer, 32, (*data_item)->data.udint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_UDINT) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_ULINT) && (numberOfValues == 1)) { /* ULINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_long(writeBuffer, 64, (*data_item)->data.ulint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_ULINT) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_REAL) && (numberOfValues == 1)) { /* REAL */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_float(writeBuffer, 32, (*data_item)->data.real_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_REAL) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_LREAL) && (numberOfValues == 1)) { /* LREAL */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_double(writeBuffer, 64, (*data_item)->data.lreal_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_LREAL) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_CHAR) && (numberOfValues == 1)) { /* CHAR */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.char_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_CHAR) { /* List */
+
+ // Array field
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_WCHAR) && (numberOfValues == 1)) { /* WCHAR */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_short(writeBuffer, 16, (*data_item)->data.wchar_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_WCHAR) { /* List */
+
+ // Array field
+ }
return OK;
}
-uint16_t plc4c_modbus_read_write_data_item_length_in_bytes(plc4c_data* data_item) {
- return plc4c_modbus_read_write_data_item_length_in_bits(data_item) / 8;
+uint16_t plc4c_modbus_read_write_data_item_length_in_bytes(plc4c_data* data_item, plc4c_modbus_read_write_modbus_data_type data_type, uint16_t number_of_values) {
+ return plc4c_modbus_read_write_data_item_length_in_bits(data_item, data_type, number_of_values) / 8;
}
-uint16_t plc4c_modbus_read_write_data_item_length_in_bits(plc4c_data* data_item) {
+uint16_t plc4c_modbus_read_write_data_item_length_in_bits(plc4c_data* data_item, plc4c_modbus_read_write_modbus_data_type dataType, uint16_t numberOfValues) {
uint16_t lengthInBits = 0;
+ if((dataType == plc4c_modbus_read_write_modbus_data_type_BOOL) && (numberOfValues == 1)) { /* BOOL */
+
+ // Reserved Field (reserved)
+ lengthInBits += 15;
+
+ // Simple field (value)
+ lengthInBits += 1;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_BOOL) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_BYTE) && (numberOfValues == 1)) { /* List */
+
+ // Reserved Field (reserved)
+ lengthInBits += 8;
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_BYTE) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_WORD) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_DWORD) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_LWORD) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_SINT) && (numberOfValues == 1)) { /* SINT */
+
+ // Reserved Field (reserved)
+ lengthInBits += 8;
+
+ // Simple field (value)
+ lengthInBits += 8;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_SINT) { /* List */
+
+ // Array field
+ lengthInBits += 8 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_INT) && (numberOfValues == 1)) { /* INT */
+
+ // Simple field (value)
+ lengthInBits += 16;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_INT) { /* List */
+
+ // Array field
+ lengthInBits += 16 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_DINT) && (numberOfValues == 1)) { /* DINT */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_DINT) { /* List */
+
+ // Array field
+ lengthInBits += 32 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_LINT) && (numberOfValues == 1)) { /* LINT */
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_LINT) { /* List */
+
+ // Array field
+ lengthInBits += 64 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_USINT) && (numberOfValues == 1)) { /* USINT */
+
+ // Reserved Field (reserved)
+ lengthInBits += 8;
+
+ // Simple field (value)
+ lengthInBits += 8;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_USINT) { /* List */
+
+ // Array field
+ lengthInBits += 8 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_UINT) && (numberOfValues == 1)) { /* UINT */
+
+ // Simple field (value)
+ lengthInBits += 16;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_UINT) { /* List */
+
+ // Array field
+ lengthInBits += 16 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_UDINT) && (numberOfValues == 1)) { /* UDINT */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_UDINT) { /* List */
+
+ // Array field
+ lengthInBits += 32 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_ULINT) && (numberOfValues == 1)) { /* ULINT */
+
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_ULINT) { /* List */
+
+ // Array field
+ lengthInBits += 64 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_REAL) && (numberOfValues == 1)) { /* REAL */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_REAL) { /* List */
+
+ // Array field
+ lengthInBits += 32 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_LREAL) && (numberOfValues == 1)) { /* LREAL */
+
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_LREAL) { /* List */
+
+ // Array field
+ lengthInBits += 64 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_CHAR) && (numberOfValues == 1)) { /* CHAR */
+
+ // Simple field (value)
+ lengthInBits += 8;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_CHAR) { /* List */
+
+ // Array field
+ lengthInBits += 8 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if((dataType == plc4c_modbus_read_write_modbus_data_type_WCHAR) && (numberOfValues == 1)) { /* WCHAR */
+
+ // Simple field (value)
+ lengthInBits += 16;
+ } else if(dataType == plc4c_modbus_read_write_modbus_data_type_WCHAR) { /* List */
+
+ // Array field
+ lengthInBits += 16 * plc4c_utils_list_size(data_item->data.list_value);
+ }
return lengthInBits;
}
diff --git a/plc4c/generated-sources/plc4x/include/plc4x_value.h b/plc4c/generated-sources/plc4x/include/plc4x_value.h
index 920e06a708..137657318f 100644
--- a/plc4c/generated-sources/plc4x/include/plc4x_value.h
+++ b/plc4c/generated-sources/plc4x/include/plc4x_value.h
@@ -30,10 +30,10 @@
plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer* readBuffer, plc4c_plc4x_read_write_plc4x_value_type valueType, plc4c_data** data_item);
-plc4c_return_code plc4c_plc4x_read_write_plc4x_value_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_data** data_item);
+plc4c_return_code plc4c_plc4x_read_write_plc4x_value_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_plc4x_read_write_plc4x_value_type valueType, plc4c_data** data_item);
-uint16_t plc4c_plc4x_read_write_plc4x_value_length_in_bytes(plc4c_data* data_item);
+uint16_t plc4c_plc4x_read_write_plc4x_value_length_in_bytes(plc4c_data* data_item, plc4c_plc4x_read_write_plc4x_value_type valueType);
-uint16_t plc4c_plc4x_read_write_plc4x_value_length_in_bits(plc4c_data* data_item);
+uint16_t plc4c_plc4x_read_write_plc4x_value_length_in_bits(plc4c_data* data_item, plc4c_plc4x_read_write_plc4x_value_type valueType);
#endif // PLC4C_PLC4X_READ_WRITE_PLC4X_VALUE_H_
diff --git a/plc4c/generated-sources/plc4x/include/plc4x_value_type.h b/plc4c/generated-sources/plc4x/include/plc4x_value_type.h
index c3ae805369..75edde58d2 100644
--- a/plc4c/generated-sources/plc4x/include/plc4x_value_type.h
+++ b/plc4c/generated-sources/plc4x/include/plc4x_value_type.h
@@ -34,6 +34,7 @@ enum plc4c_plc4x_read_write_plc4x_value_type {
plc4c_plc4x_read_write_plc4x_value_type_BYTE = 0x02,
plc4c_plc4x_read_write_plc4x_value_type_WORD = 0x03,
plc4c_plc4x_read_write_plc4x_value_type_DWORD = 0x04,
+ plc4c_plc4x_read_write_plc4x_value_type_LWORD = 0x05,
plc4c_plc4x_read_write_plc4x_value_type_USINT = 0x11,
plc4c_plc4x_read_write_plc4x_value_type_UINT = 0x12,
plc4c_plc4x_read_write_plc4x_value_type_UDINT = 0x13,
diff --git a/plc4c/generated-sources/plc4x/src/plc4x_field.c b/plc4c/generated-sources/plc4x/src/plc4x_field.c
index 741fe54516..d68d20bf0e 100644
--- a/plc4c/generated-sources/plc4x/src/plc4x_field.c
+++ b/plc4c/generated-sources/plc4x/src/plc4x_field.c
@@ -80,7 +80,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_field_serialize(plc4c_spi_write_b
}
// Simple Field (name)
- _res = plc4c_spi_write_string(writeBuffer, -1, "UTF-8", _message->name);
+ _res = plc4c_spi_write_string(writeBuffer, (plc4c_spi_evaluation_helper_str_len(_message->name)) * (8), "UTF-8", _message->name);
if(_res != OK) {
return _res;
}
@@ -92,7 +92,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_field_serialize(plc4c_spi_write_b
}
// Simple Field (fieldQuery)
- _res = plc4c_spi_write_string(writeBuffer, -1, "UTF-8", _message->field_query);
+ _res = plc4c_spi_write_string(writeBuffer, (plc4c_spi_evaluation_helper_str_len(_message->field_query)) * (8), "UTF-8", _message->field_query);
if(_res != OK) {
return _res;
}
diff --git a/plc4c/generated-sources/plc4x/src/plc4x_field_value_request.c b/plc4c/generated-sources/plc4x/src/plc4x_field_value_request.c
index 2b2df7f8a1..021d9dd5bc 100644
--- a/plc4c/generated-sources/plc4x/src/plc4x_field_value_request.c
+++ b/plc4c/generated-sources/plc4x/src/plc4x_field_value_request.c
@@ -85,7 +85,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_field_value_request_serialize(plc
// Optional Field (value)
if(_message->value != NULL) {
- _res = plc4c_plc4x_read_write_plc4x_value_serialize(writeBuffer, _message->value);
+ _res = plc4c_plc4x_read_write_plc4x_value_serialize(writeBuffer, _message->value_type, &_message->value);
if(_res != OK) {
return _res;
}
@@ -109,7 +109,7 @@ uint16_t plc4c_plc4x_read_write_plc4x_field_value_request_length_in_bits(plc4c_p
// Optional Field (value)
if(_message->value != NULL) {
- lengthInBits += plc4c_plc4x_read_write_plc4x_value_length_in_bits(_message->value);
+ lengthInBits += plc4c_plc4x_read_write_plc4x_value_length_in_bits(_message->value, _message->value_type);
}
return lengthInBits;
diff --git a/plc4c/generated-sources/plc4x/src/plc4x_field_value_response.c b/plc4c/generated-sources/plc4x/src/plc4x_field_value_response.c
index 667c5b0aea..bf7d975418 100644
--- a/plc4c/generated-sources/plc4x/src/plc4x_field_value_response.c
+++ b/plc4c/generated-sources/plc4x/src/plc4x_field_value_response.c
@@ -99,7 +99,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_field_value_response_serialize(pl
// Optional Field (value)
if(_message->value != NULL) {
- _res = plc4c_plc4x_read_write_plc4x_value_serialize(writeBuffer, _message->value);
+ _res = plc4c_plc4x_read_write_plc4x_value_serialize(writeBuffer, _message->value_type, &_message->value);
if(_res != OK) {
return _res;
}
@@ -126,7 +126,7 @@ uint16_t plc4c_plc4x_read_write_plc4x_field_value_response_length_in_bits(plc4c_
// Optional Field (value)
if(_message->value != NULL) {
- lengthInBits += plc4c_plc4x_read_write_plc4x_value_length_in_bits(_message->value);
+ lengthInBits += plc4c_plc4x_read_write_plc4x_value_length_in_bits(_message->value, _message->value_type);
}
return lengthInBits;
diff --git a/plc4c/generated-sources/plc4x/src/plc4x_message.c b/plc4c/generated-sources/plc4x/src/plc4x_message.c
index 1cd0b4c856..14b5a73ca3 100644
--- a/plc4c/generated-sources/plc4x/src/plc4x_message.c
+++ b/plc4c/generated-sources/plc4x/src/plc4x_message.c
@@ -368,7 +368,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_message_serialize(plc4c_spi_write
}
// Simple Field (connectionString)
- _res = plc4c_spi_write_string(writeBuffer, -1, "UTF-8", _message->plc4x_connect_request_connection_string);
+ _res = plc4c_spi_write_string(writeBuffer, (plc4c_spi_evaluation_helper_str_len(_message->plc4x_connect_request_connection_string)) * (8), "UTF-8", _message->plc4x_connect_request_connection_string);
if(_res != OK) {
return _res;
}
diff --git a/plc4c/generated-sources/plc4x/src/plc4x_value.c b/plc4c/generated-sources/plc4x/src/plc4x_value.c
index 886c36e7f0..ba9379a57a 100644
--- a/plc4c/generated-sources/plc4x/src/plc4x_value.c
+++ b/plc4c/generated-sources/plc4x/src/plc4x_value.c
@@ -23,6 +23,7 @@
#include <plc4c/data.h>
#include <plc4c/utils/list.h>
#include <plc4c/spi/evaluation_helper.h>
+#include <plc4c/spi/types_private.h>
#include <plc4c/driver_plc4x_static.h>
#include "plc4x_value.h"
@@ -58,38 +59,77 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
*data_item = plc4c_data_create_bool_data(value);
- } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_BYTE) { /* BitString */
-
- // Simple Field (value)
- uint8_t value = 0;
- _res = plc4c_spi_read_unsigned_byte(readBuffer, 8, (uint8_t*) &value);
- if(_res != OK) {
- return _res;
- }
-
- *data_item = plc4c_data_create_uint8_t_bit_string_data(value);
-
- } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_WORD) { /* BitString */
-
- // Simple Field (value)
- uint16_t value = 0;
- _res = plc4c_spi_read_unsigned_short(readBuffer, 16, (uint16_t*) &value);
- if(_res != OK) {
- return _res;
- }
-
- *data_item = plc4c_data_create_uint16_t_bit_string_data(value);
-
- } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DWORD) { /* BitString */
-
- // Simple Field (value)
- uint32_t value = 0;
- _res = plc4c_spi_read_unsigned_int(readBuffer, 32, (uint32_t*) &value);
- if(_res != OK) {
- return _res;
- }
-
- *data_item = plc4c_data_create_uint32_t_bit_string_data(value);
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_BYTE) { /* List */
+
+ // Array field (value)
+ // Count array
+ plc4c_list* value;
+ plc4c_utils_list_create(&value);
+ int itemCount = (int) 8;
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ bool* _val = malloc(sizeof(bool) * 1);
+ _res = plc4c_spi_read_bit(readBuffer, (bool*) _val);
+ if(_res != OK) {
+ return _res;
+ }
+ plc4c_data* _item = plc4c_data_create_bool_data(*_val);
+ plc4c_utils_list_insert_head_value(value, _item);
+ }
+ *data_item = plc4c_data_create_list_data(value);
+
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_WORD) { /* List */
+
+ // Array field (value)
+ // Count array
+ plc4c_list* value;
+ plc4c_utils_list_create(&value);
+ int itemCount = (int) 16;
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ bool* _val = malloc(sizeof(bool) * 1);
+ _res = plc4c_spi_read_bit(readBuffer, (bool*) _val);
+ if(_res != OK) {
+ return _res;
+ }
+ plc4c_data* _item = plc4c_data_create_bool_data(*_val);
+ plc4c_utils_list_insert_head_value(value, _item);
+ }
+ *data_item = plc4c_data_create_list_data(value);
+
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DWORD) { /* List */
+
+ // Array field (value)
+ // Count array
+ plc4c_list* value;
+ plc4c_utils_list_create(&value);
+ int itemCount = (int) 32;
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ bool* _val = malloc(sizeof(bool) * 1);
+ _res = plc4c_spi_read_bit(readBuffer, (bool*) _val);
+ if(_res != OK) {
+ return _res;
+ }
+ plc4c_data* _item = plc4c_data_create_bool_data(*_val);
+ plc4c_utils_list_insert_head_value(value, _item);
+ }
+ *data_item = plc4c_data_create_list_data(value);
+
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_LWORD) { /* List */
+
+ // Array field (value)
+ // Count array
+ plc4c_list* value;
+ plc4c_utils_list_create(&value);
+ int itemCount = (int) 64;
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ bool* _val = malloc(sizeof(bool) * 1);
+ _res = plc4c_spi_read_bit(readBuffer, (bool*) _val);
+ if(_res != OK) {
+ return _res;
+ }
+ plc4c_data* _item = plc4c_data_create_bool_data(*_val);
+ plc4c_utils_list_insert_head_value(value, _item);
+ }
+ *data_item = plc4c_data_create_list_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_USINT) { /* USINT */
@@ -100,7 +140,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(value);
+ *data_item = plc4c_data_create_usint_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_UINT) { /* UINT */
@@ -111,7 +151,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_uint16_t_data(value);
+ *data_item = plc4c_data_create_uint_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_UDINT) { /* UDINT */
@@ -122,7 +162,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_uint32_t_data(value);
+ *data_item = plc4c_data_create_udint_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_ULINT) { /* ULINT */
@@ -133,7 +173,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_uint64_t_data(value);
+ *data_item = plc4c_data_create_ulint_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_SINT) { /* SINT */
@@ -144,7 +184,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_int8_t_data(value);
+ *data_item = plc4c_data_create_sint_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_INT) { /* INT */
@@ -155,7 +195,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_int16_t_data(value);
+ *data_item = plc4c_data_create_int_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DINT) { /* DINT */
@@ -166,7 +206,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_int32_t_data(value);
+ *data_item = plc4c_data_create_dint_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_LINT) { /* LINT */
@@ -177,7 +217,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_int64_t_data(value);
+ *data_item = plc4c_data_create_lint_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_REAL) { /* REAL */
@@ -188,7 +228,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_float_data(value);
+ *data_item = plc4c_data_create_real_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_LREAL) { /* LREAL */
@@ -199,7 +239,7 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return _res;
}
- *data_item = plc4c_data_create_double_data(value);
+ *data_item = plc4c_data_create_lreal_data(value);
} else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_CHAR) { /* STRING */
@@ -236,19 +276,211 @@ plc4c_return_code plc4c_plc4x_read_write_plc4x_value_parse(plc4c_spi_read_buffer
return OK;
}
-plc4c_return_code plc4c_plc4x_read_write_plc4x_value_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_data** data_item) {
+plc4c_return_code plc4c_plc4x_read_write_plc4x_value_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_plc4x_read_write_plc4x_value_type valueType, plc4c_data** data_item) {
plc4c_return_code _res = OK;
+ if(valueType == plc4c_plc4x_read_write_plc4x_value_type_BOOL) { /* BOOL */
+
+ // Reserved Field (reserved)
+
+ // Simple field (value)
+ _res = plc4c_spi_write_bit(writeBuffer, (*data_item)->data.bool_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_BYTE) { /* List */
+
+ // Array field
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_WORD) { /* List */
+ // Array field
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DWORD) { /* List */
+
+ // Array field
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_LWORD) { /* List */
+
+ // Array field
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_USINT) { /* USINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.usint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_UINT) { /* UINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_short(writeBuffer, 16, (*data_item)->data.uint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_UDINT) { /* UDINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_int(writeBuffer, 32, (*data_item)->data.udint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_ULINT) { /* ULINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_long(writeBuffer, 64, (*data_item)->data.ulint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_SINT) { /* SINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_byte(writeBuffer, 8, (*data_item)->data.sint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_INT) { /* INT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_short(writeBuffer, 16, (*data_item)->data.int_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DINT) { /* DINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_int(writeBuffer, 32, (*data_item)->data.dint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_LINT) { /* LINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_long(writeBuffer, 64, (*data_item)->data.lint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_REAL) { /* REAL */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_float(writeBuffer, 32, (*data_item)->data.real_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_LREAL) { /* LREAL */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_double(writeBuffer, 64, (*data_item)->data.lreal_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_CHAR) { /* STRING */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_string(writeBuffer, 8, "UTF-8", (*data_item)->data.string_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_WCHAR) { /* STRING */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_string(writeBuffer, 16, "UTF-16", (*data_item)->data.string_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_STRING) { /* STRING */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_WSTRING) { /* STRING */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_TIME) { /* TIME */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_TIME_OF_DAY) { /* TIME_OF_DAY */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DATE) { /* DATE */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DATE_AND_TIME) { /* DATE_AND_TIME */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_Struct) { /* Struct */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_List) { /* List */
+ }
return OK;
}
-uint16_t plc4c_plc4x_read_write_plc4x_value_length_in_bytes(plc4c_data* data_item) {
- return plc4c_plc4x_read_write_plc4x_value_length_in_bits(data_item) / 8;
+uint16_t plc4c_plc4x_read_write_plc4x_value_length_in_bytes(plc4c_data* data_item, plc4c_plc4x_read_write_plc4x_value_type value_type) {
+ return plc4c_plc4x_read_write_plc4x_value_length_in_bits(data_item, value_type) / 8;
}
-uint16_t plc4c_plc4x_read_write_plc4x_value_length_in_bits(plc4c_data* data_item) {
+uint16_t plc4c_plc4x_read_write_plc4x_value_length_in_bits(plc4c_data* data_item, plc4c_plc4x_read_write_plc4x_value_type valueType) {
uint16_t lengthInBits = 0;
-
+ if(valueType == plc4c_plc4x_read_write_plc4x_value_type_BOOL) { /* BOOL */
+
+ // Reserved Field (reserved)
+ lengthInBits += 7;
+
+ // Simple field (value)
+ lengthInBits += 1;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_BYTE) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_WORD) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DWORD) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_LWORD) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_USINT) { /* USINT */
+
+ // Simple field (value)
+ lengthInBits += 8;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_UINT) { /* UINT */
+
+ // Simple field (value)
+ lengthInBits += 16;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_UDINT) { /* UDINT */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_ULINT) { /* ULINT */
+
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_SINT) { /* SINT */
+
+ // Simple field (value)
+ lengthInBits += 8;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_INT) { /* INT */
+
+ // Simple field (value)
+ lengthInBits += 16;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DINT) { /* DINT */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_LINT) { /* LINT */
+
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_REAL) { /* REAL */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_LREAL) { /* LREAL */
+
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_CHAR) { /* STRING */
+
+ // Simple field (value)
+ lengthInBits += 8;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_WCHAR) { /* STRING */
+
+ // Simple field (value)
+ lengthInBits += 16;
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_STRING) { /* STRING */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_WSTRING) { /* STRING */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_TIME) { /* TIME */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_TIME_OF_DAY) { /* TIME_OF_DAY */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DATE) { /* DATE */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_DATE_AND_TIME) { /* DATE_AND_TIME */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_Struct) { /* Struct */
+ } else if(valueType == plc4c_plc4x_read_write_plc4x_value_type_List) { /* List */
+ }
return lengthInBits;
}
diff --git a/plc4c/generated-sources/plc4x/src/plc4x_value_type.c b/plc4c/generated-sources/plc4x/src/plc4x_value_type.c
index c8c4c9cec0..f8f99f9660 100644
--- a/plc4c/generated-sources/plc4x/src/plc4x_value_type.c
+++ b/plc4c/generated-sources/plc4x/src/plc4x_value_type.c
@@ -76,6 +76,9 @@ plc4c_plc4x_read_write_plc4x_value_type plc4c_plc4x_read_write_plc4x_value_type_
if(strcmp(value_string, "DWORD") == 0) {
return plc4c_plc4x_read_write_plc4x_value_type_DWORD;
}
+ if(strcmp(value_string, "LWORD") == 0) {
+ return plc4c_plc4x_read_write_plc4x_value_type_LWORD;
+ }
if(strcmp(value_string, "USINT") == 0) {
return plc4c_plc4x_read_write_plc4x_value_type_USINT;
}
@@ -140,7 +143,7 @@ plc4c_plc4x_read_write_plc4x_value_type plc4c_plc4x_read_write_plc4x_value_type_
}
int plc4c_plc4x_read_write_plc4x_value_type_num_values() {
- return 25;
+ return 26;
}
plc4c_plc4x_read_write_plc4x_value_type plc4c_plc4x_read_write_plc4x_value_type_value_for_index(int index) {
@@ -161,63 +164,66 @@ plc4c_plc4x_read_write_plc4x_value_type plc4c_plc4x_read_write_plc4x_value_type_
return plc4c_plc4x_read_write_plc4x_value_type_DWORD;
}
case 5: {
- return plc4c_plc4x_read_write_plc4x_value_type_USINT;
+ return plc4c_plc4x_read_write_plc4x_value_type_LWORD;
}
case 6: {
- return plc4c_plc4x_read_write_plc4x_value_type_UINT;
+ return plc4c_plc4x_read_write_plc4x_value_type_USINT;
}
case 7: {
- return plc4c_plc4x_read_write_plc4x_value_type_UDINT;
+ return plc4c_plc4x_read_write_plc4x_value_type_UINT;
}
case 8: {
- return plc4c_plc4x_read_write_plc4x_value_type_ULINT;
+ return plc4c_plc4x_read_write_plc4x_value_type_UDINT;
}
case 9: {
- return plc4c_plc4x_read_write_plc4x_value_type_SINT;
+ return plc4c_plc4x_read_write_plc4x_value_type_ULINT;
}
case 10: {
- return plc4c_plc4x_read_write_plc4x_value_type_INT;
+ return plc4c_plc4x_read_write_plc4x_value_type_SINT;
}
case 11: {
- return plc4c_plc4x_read_write_plc4x_value_type_DINT;
+ return plc4c_plc4x_read_write_plc4x_value_type_INT;
}
case 12: {
- return plc4c_plc4x_read_write_plc4x_value_type_LINT;
+ return plc4c_plc4x_read_write_plc4x_value_type_DINT;
}
case 13: {
- return plc4c_plc4x_read_write_plc4x_value_type_REAL;
+ return plc4c_plc4x_read_write_plc4x_value_type_LINT;
}
case 14: {
- return plc4c_plc4x_read_write_plc4x_value_type_LREAL;
+ return plc4c_plc4x_read_write_plc4x_value_type_REAL;
}
case 15: {
- return plc4c_plc4x_read_write_plc4x_value_type_CHAR;
+ return plc4c_plc4x_read_write_plc4x_value_type_LREAL;
}
case 16: {
- return plc4c_plc4x_read_write_plc4x_value_type_WCHAR;
+ return plc4c_plc4x_read_write_plc4x_value_type_CHAR;
}
case 17: {
- return plc4c_plc4x_read_write_plc4x_value_type_STRING;
+ return plc4c_plc4x_read_write_plc4x_value_type_WCHAR;
}
case 18: {
- return plc4c_plc4x_read_write_plc4x_value_type_WSTRING;
+ return plc4c_plc4x_read_write_plc4x_value_type_STRING;
}
case 19: {
- return plc4c_plc4x_read_write_plc4x_value_type_TIME;
+ return plc4c_plc4x_read_write_plc4x_value_type_WSTRING;
}
case 20: {
- return plc4c_plc4x_read_write_plc4x_value_type_TIME_OF_DAY;
+ return plc4c_plc4x_read_write_plc4x_value_type_TIME;
}
case 21: {
- return plc4c_plc4x_read_write_plc4x_value_type_DATE;
+ return plc4c_plc4x_read_write_plc4x_value_type_TIME_OF_DAY;
}
case 22: {
- return plc4c_plc4x_read_write_plc4x_value_type_DATE_AND_TIME;
+ return plc4c_plc4x_read_write_plc4x_value_type_DATE;
}
case 23: {
- return plc4c_plc4x_read_write_plc4x_value_type_Struct;
+ return plc4c_plc4x_read_write_plc4x_value_type_DATE_AND_TIME;
}
case 24: {
+ return plc4c_plc4x_read_write_plc4x_value_type_Struct;
+ }
+ case 25: {
return plc4c_plc4x_read_write_plc4x_value_type_List;
}
default: {
diff --git a/plc4c/generated-sources/plc4x/test/ParserSerializerTestsuite.c b/plc4c/generated-sources/plc4x/test/ParserSerializerTestsuite.c
index 53d150a46c..8e114e0776 100644
--- a/plc4c/generated-sources/plc4x/test/ParserSerializerTestsuite.c
+++ b/plc4c/generated-sources/plc4x/test/ParserSerializerTestsuite.c
@@ -337,7 +337,7 @@ void parser_serializer_test_plc4x_read_write(void) {
RUN_TEST(
parser_serializer_test_plc4x_read_write_connection_response);
-/* RUN_TEST(
+ RUN_TEST(
parser_serializer_test_plc4x_read_write_read_request_single_item);
RUN_TEST(
@@ -353,7 +353,7 @@ void parser_serializer_test_plc4x_read_write(void) {
parser_serializer_test_plc4x_read_write_write_request);
RUN_TEST(
- parser_serializer_test_plc4x_read_write_write_response);*/
+ parser_serializer_test_plc4x_read_write_write_response);
}
\ No newline at end of file
diff --git a/plc4c/generated-sources/s7/include/data_item.h b/plc4c/generated-sources/s7/include/data_item.h
index 457cd82f3a..700f3da29f 100644
--- a/plc4c/generated-sources/s7/include/data_item.h
+++ b/plc4c/generated-sources/s7/include/data_item.h
@@ -29,10 +29,10 @@
plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* readBuffer, char* dataProtocolId, int32_t stringLength, plc4c_data** data_item);
-plc4c_return_code plc4c_s7_read_write_data_item_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_data** data_item);
+plc4c_return_code plc4c_s7_read_write_data_item_serialize(plc4c_spi_write_buffer* writeBuffer, char* dataProtocolId, int32_t stringLength, plc4c_data** data_item);
-uint16_t plc4c_s7_read_write_data_item_length_in_bytes(plc4c_data* data_item);
+uint16_t plc4c_s7_read_write_data_item_length_in_bytes(plc4c_data* data_item, char* dataProtocolId, int32_t stringLength);
-uint16_t plc4c_s7_read_write_data_item_length_in_bits(plc4c_data* data_item);
+uint16_t plc4c_s7_read_write_data_item_length_in_bits(plc4c_data* data_item, char* dataProtocolId, int32_t stringLength);
#endif // PLC4C_S7_READ_WRITE_DATA_ITEM_H_
diff --git a/plc4c/generated-sources/s7/src/data_item.c b/plc4c/generated-sources/s7/src/data_item.c
index 38134660b3..71577b0f2b 100644
--- a/plc4c/generated-sources/s7/src/data_item.c
+++ b/plc4c/generated-sources/s7/src/data_item.c
@@ -23,6 +23,7 @@
#include <plc4c/data.h>
#include <plc4c/utils/list.h>
#include <plc4c/spi/evaluation_helper.h>
+#include <plc4c/spi/types_private.h>
#include <plc4c/driver_s7_static.h>
#include "data_item.h"
@@ -74,7 +75,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
plc4c_data* _item = plc4c_data_create_bool_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_WORD") == 0) { /* List */
@@ -92,7 +93,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
plc4c_data* _item = plc4c_data_create_bool_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_DWORD") == 0) { /* List */
@@ -110,7 +111,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
plc4c_data* _item = plc4c_data_create_bool_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_LWORD") == 0) { /* List */
@@ -128,7 +129,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
plc4c_data* _item = plc4c_data_create_bool_data(*_val);
plc4c_utils_list_insert_head_value(value, _item);
}
- *data_item = plc4c_data_create_list_data(*value);
+ *data_item = plc4c_data_create_list_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_SINT") == 0) { /* SINT */
@@ -139,7 +140,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_int8_t_data(value);
+ *data_item = plc4c_data_create_sint_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_USINT") == 0) { /* USINT */
@@ -150,7 +151,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(value);
+ *data_item = plc4c_data_create_usint_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_INT") == 0) { /* INT */
@@ -161,7 +162,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_int16_t_data(value);
+ *data_item = plc4c_data_create_int_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_UINT") == 0) { /* UINT */
@@ -172,7 +173,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint16_t_data(value);
+ *data_item = plc4c_data_create_uint_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_DINT") == 0) { /* DINT */
@@ -183,7 +184,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_int32_t_data(value);
+ *data_item = plc4c_data_create_dint_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_UDINT") == 0) { /* UDINT */
@@ -194,7 +195,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint32_t_data(value);
+ *data_item = plc4c_data_create_udint_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_LINT") == 0) { /* LINT */
@@ -205,7 +206,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_int64_t_data(value);
+ *data_item = plc4c_data_create_lint_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_ULINT") == 0) { /* ULINT */
@@ -216,7 +217,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint64_t_data(value);
+ *data_item = plc4c_data_create_ulint_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_REAL") == 0) { /* REAL */
@@ -227,7 +228,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_float_data(value);
+ *data_item = plc4c_data_create_real_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_LREAL") == 0) { /* LREAL */
@@ -238,7 +239,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_double_data(value);
+ *data_item = plc4c_data_create_lreal_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_CHAR") == 0) { /* CHAR */
@@ -277,7 +278,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint32_t_data(value);
+ *data_item = plc4c_data_create_time_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_LTIME") == 0) { /* LTIME */
@@ -288,7 +289,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint64_t_data(value);
+ *data_item = plc4c_data_create_ltime_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_DATE") == 0) { /* DATE */
@@ -299,7 +300,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint16_t_data(value);
+ *data_item = plc4c_data_create_date_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_TIME_OF_DAY") == 0) { /* TIME_OF_DAY */
@@ -310,7 +311,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint32_t_data(value);
+ *data_item = plc4c_data_create_time_of_day_data(value);
} else if(strcmp(dataProtocolId, "IEC61131_DATE_AND_TIME") == 0) { /* DATE_AND_TIME */
@@ -321,7 +322,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint16_t_data(year);
+ *data_item = plc4c_data_create_date_and_time_data(year);
// Simple Field (month)
@@ -331,7 +332,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(month);
+ *data_item = plc4c_data_create_date_and_time_data(month);
// Simple Field (day)
@@ -341,7 +342,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(day);
+ *data_item = plc4c_data_create_date_and_time_data(day);
// Simple Field (dayOfWeek)
@@ -351,7 +352,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(dayOfWeek);
+ *data_item = plc4c_data_create_date_and_time_data(dayOfWeek);
// Simple Field (hour)
@@ -361,7 +362,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(hour);
+ *data_item = plc4c_data_create_date_and_time_data(hour);
// Simple Field (minutes)
@@ -371,7 +372,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(minutes);
+ *data_item = plc4c_data_create_date_and_time_data(minutes);
// Simple Field (seconds)
@@ -381,7 +382,7 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint8_t_data(seconds);
+ *data_item = plc4c_data_create_date_and_time_data(seconds);
// Simple Field (nanos)
@@ -391,26 +392,332 @@ plc4c_return_code plc4c_s7_read_write_data_item_parse(plc4c_spi_read_buffer* rea
return _res;
}
- *data_item = plc4c_data_create_uint32_t_data(nanos);
+ *data_item = plc4c_data_create_date_and_time_data(nanos);
}
return OK;
}
-plc4c_return_code plc4c_s7_read_write_data_item_serialize(plc4c_spi_write_buffer* writeBuffer, plc4c_data** data_item) {
+plc4c_return_code plc4c_s7_read_write_data_item_serialize(plc4c_spi_write_buffer* writeBuffer, char* dataProtocolId, int32_t stringLength, plc4c_data** data_item) {
plc4c_return_code _res = OK;
+ if(strcmp(dataProtocolId, "IEC61131_BOOL") == 0) { /* BOOL */
+
+ // Reserved Field (reserved)
+
+ // Simple field (value)
+ _res = plc4c_spi_write_bit(writeBuffer, (*data_item)->data.bool_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_BYTE") == 0) { /* List */
+
+ // Array field
+ } else if(strcmp(dataProtocolId, "IEC61131_WORD") == 0) { /* List */
+
+ // Array field
+ } else if(strcmp(dataProtocolId, "IEC61131_DWORD") == 0) { /* List */
+
+ // Array field
+ } else if(strcmp(dataProtocolId, "IEC61131_LWORD") == 0) { /* List */
+
+ // Array field
+ } else if(strcmp(dataProtocolId, "IEC61131_SINT") == 0) { /* SINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_byte(writeBuffer, 8, (*data_item)->data.sint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_USINT") == 0) { /* USINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.usint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_INT") == 0) { /* INT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_short(writeBuffer, 16, (*data_item)->data.int_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_UINT") == 0) { /* UINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_short(writeBuffer, 16, (*data_item)->data.uint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_DINT") == 0) { /* DINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_int(writeBuffer, 32, (*data_item)->data.dint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_UDINT") == 0) { /* UDINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_int(writeBuffer, 32, (*data_item)->data.udint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_LINT") == 0) { /* LINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_signed_long(writeBuffer, 64, (*data_item)->data.lint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_ULINT") == 0) { /* ULINT */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_long(writeBuffer, 64, (*data_item)->data.ulint_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_REAL") == 0) { /* REAL */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_float(writeBuffer, 32, (*data_item)->data.real_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_LREAL") == 0) { /* LREAL */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_double(writeBuffer, 64, (*data_item)->data.lreal_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_CHAR") == 0) { /* CHAR */
+
+ // Manual Field (value)
+ } else if(strcmp(dataProtocolId, "IEC61131_WCHAR") == 0) { /* CHAR */
+
+ // Manual Field (value)
+ } else if(strcmp(dataProtocolId, "IEC61131_STRING") == 0) { /* STRING */
+
+ // Manual Field (value)
+ } else if(strcmp(dataProtocolId, "IEC61131_WSTRING") == 0) { /* STRING */
+
+ // Manual Field (value)
+ } else if(strcmp(dataProtocolId, "IEC61131_TIME") == 0) { /* TIME */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_int(writeBuffer, 32, (*data_item)->data.time_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_LTIME") == 0) { /* LTIME */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_long(writeBuffer, 64, (*data_item)->data.ltime_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_DATE") == 0) { /* DATE */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_short(writeBuffer, 16, (*data_item)->data.date_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_TIME_OF_DAY") == 0) { /* TIME_OF_DAY */
+
+ // Simple field (value)
+ _res = plc4c_spi_write_unsigned_int(writeBuffer, 32, (*data_item)->data.time_of_day_value);
+ if(_res != OK) {
+ return _res;
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_DATE_AND_TIME") == 0) { /* DATE_AND_TIME */
+
+ // Simple field (year)
+ _res = plc4c_spi_write_unsigned_short(writeBuffer, 16, (*data_item)->data.date_and_time_value);
+ if(_res != OK) {
+ return _res;
+ }
+
+ // Simple field (month)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.date_and_time_value);
+ if(_res != OK) {
+ return _res;
+ }
+
+ // Simple field (day)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.date_and_time_value);
+ if(_res != OK) {
+ return _res;
+ }
+
+ // Simple field (dayOfWeek)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.date_and_time_value);
+ if(_res != OK) {
+ return _res;
+ }
+
+ // Simple field (hour)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.date_and_time_value);
+ if(_res != OK) {
+ return _res;
+ }
+
+ // Simple field (minutes)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.date_and_time_value);
+ if(_res != OK) {
+ return _res;
+ }
+ // Simple field (seconds)
+ _res = plc4c_spi_write_unsigned_byte(writeBuffer, 8, (*data_item)->data.date_and_time_value);
+ if(_res != OK) {
+ return _res;
+ }
+
+ // Simple field (nanos)
+ _res = plc4c_spi_write_unsigned_int(writeBuffer, 32, (*data_item)->data.date_and_time_value);
+ if(_res != OK) {
+ return _res;
+ }
+ }
return OK;
}
-uint16_t plc4c_s7_read_write_data_item_length_in_bytes(plc4c_data* data_item) {
- return plc4c_s7_read_write_data_item_length_in_bits(data_item) / 8;
+uint16_t plc4c_s7_read_write_data_item_length_in_bytes(plc4c_data* data_item, char* data_protocol_id, int32_t string_length) {
+ return plc4c_s7_read_write_data_item_length_in_bits(data_item, data_protocol_id, string_length) / 8;
}
-uint16_t plc4c_s7_read_write_data_item_length_in_bits(plc4c_data* data_item) {
+uint16_t plc4c_s7_read_write_data_item_length_in_bits(plc4c_data* data_item, char* dataProtocolId, int32_t stringLength) {
uint16_t lengthInBits = 0;
+ if(strcmp(dataProtocolId, "IEC61131_BOOL") == 0) { /* BOOL */
+ // Reserved Field (reserved)
+ lengthInBits += 7;
+
+ // Simple field (value)
+ lengthInBits += 1;
+ } else if(strcmp(dataProtocolId, "IEC61131_BYTE") == 0) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(strcmp(dataProtocolId, "IEC61131_WORD") == 0) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(strcmp(dataProtocolId, "IEC61131_DWORD") == 0) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(strcmp(dataProtocolId, "IEC61131_LWORD") == 0) { /* List */
+
+ // Array field
+ lengthInBits += 1 * plc4c_utils_list_size(data_item->data.list_value);
+ } else if(strcmp(dataProtocolId, "IEC61131_SINT") == 0) { /* SINT */
+
+ // Simple field (value)
+ lengthInBits += 8;
+ } else if(strcmp(dataProtocolId, "IEC61131_USINT") == 0) { /* USINT */
+
+ // Simple field (value)
+ lengthInBits += 8;
+ } else if(strcmp(dataProtocolId, "IEC61131_INT") == 0) { /* INT */
+
+ // Simple field (value)
+ lengthInBits += 16;
+ } else if(strcmp(dataProtocolId, "IEC61131_UINT") == 0) { /* UINT */
+
+ // Simple field (value)
+ lengthInBits += 16;
+ } else if(strcmp(dataProtocolId, "IEC61131_DINT") == 0) { /* DINT */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(strcmp(dataProtocolId, "IEC61131_UDINT") == 0) { /* UDINT */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(strcmp(dataProtocolId, "IEC61131_LINT") == 0) { /* LINT */
+
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(strcmp(dataProtocolId, "IEC61131_ULINT") == 0) { /* ULINT */
+
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(strcmp(dataProtocolId, "IEC61131_REAL") == 0) { /* REAL */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(strcmp(dataProtocolId, "IEC61131_LREAL") == 0) { /* LREAL */
+
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(strcmp(dataProtocolId, "IEC61131_CHAR") == 0) { /* CHAR */
+
+ // Manual Field (value)
+ lengthInBits += 8;
+ } else if(strcmp(dataProtocolId, "IEC61131_WCHAR") == 0) { /* CHAR */
+
+ // Manual Field (value)
+ lengthInBits += 16;
+ } else if(strcmp(dataProtocolId, "IEC61131_STRING") == 0) { /* STRING */
+
+ // Manual Field (value)
+ {
+ char* _value = data_item->data.string_value;
+ lengthInBits += (plc4c_spi_evaluation_helper_str_len(_value)) + (2);
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_WSTRING") == 0) { /* STRING */
+
+ // Manual Field (value)
+ {
+ char* _value = data_item->data.string_value;
+ lengthInBits += (((plc4c_spi_evaluation_helper_str_len(_value)) * (2))) + (2);
+ }
+ } else if(strcmp(dataProtocolId, "IEC61131_TIME") == 0) { /* TIME */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(strcmp(dataProtocolId, "IEC61131_LTIME") == 0) { /* LTIME */
+
+ // Simple field (value)
+ lengthInBits += 64;
+ } else if(strcmp(dataProtocolId, "IEC61131_DATE") == 0) { /* DATE */
+
+ // Simple field (value)
+ lengthInBits += 16;
+ } else if(strcmp(dataProtocolId, "IEC61131_TIME_OF_DAY") == 0) { /* TIME_OF_DAY */
+
+ // Simple field (value)
+ lengthInBits += 32;
+ } else if(strcmp(dataProtocolId, "IEC61131_DATE_AND_TIME") == 0) { /* DATE_AND_TIME */
+
+ // Simple field (year)
+ lengthInBits += 16;
+
+ // Simple field (month)
+ lengthInBits += 8;
+
+ // Simple field (day)
+ lengthInBits += 8;
+
+ // Simple field (dayOfWeek)
+ lengthInBits += 8;
+
+ // Simple field (hour)
+ lengthInBits += 8;
+
+ // Simple field (minutes)
+ lengthInBits += 8;
+
+ // Simple field (seconds)
+ lengthInBits += 8;
+
+ // Simple field (nanos)
+ lengthInBits += 32;
+ }
return lengthInBits;
}
diff --git a/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c b/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c
index 51b9a74444..00cb62d9cd 100644
--- a/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c
+++ b/plc4c/generated-sources/s7/src/s7_payload_user_data_item.c
@@ -965,7 +965,7 @@ plc4c_return_code plc4c_s7_read_write_s7_payload_user_data_item_serialize(plc4c_
// Optional Field (Alarmtype)
if(_message->s7_payload_user_data_item_cpu_function_msg_subscription_alarmtype != NULL) {
- _res = plc4c_s7_read_write_alarm_state_type_serialize(writeBuffer, _message->s7_payload_user_data_item_cpu_function_msg_subscription_alarmtype);
+ _res = plc4c_s7_read_write_alarm_state_type_serialize(writeBuffer, &_message->s7_payload_user_data_item_cpu_function_msg_subscription_alarmtype);
if(_res != OK) {
return _res;
}
diff --git a/plc4c/generated-sources/s7/src/s7_var_payload_data_item.c b/plc4c/generated-sources/s7/src/s7_var_payload_data_item.c
index 803dec7576..972e737729 100644
--- a/plc4c/generated-sources/s7/src/s7_var_payload_data_item.c
+++ b/plc4c/generated-sources/s7/src/s7_var_payload_data_item.c
@@ -163,8 +163,8 @@ uint16_t plc4c_s7_read_write_s7_var_payload_data_item_length_in_bits(plc4c_s7_re
lengthInBits += 8 * plc4c_utils_list_size(_message->data);
// Padding Field (padding)
- int _needsPadding = (int) ((plc4c_spi_evaluation_helper_count(_message->data)) % (2));
- while(_needsPadding-- > 0) {
+ int _needsPadding = (int) ((plc4c_spi_evaluation_helper_count(_message->data)) % (2));
+ while(_needsPadding-- > 0) {
lengthInBits += 8;
}
diff --git a/plc4c/pom.xml b/plc4c/pom.xml
index c61971b0cc..e185230708 100644
--- a/plc4c/pom.xml
+++ b/plc4c/pom.xml
@@ -211,6 +211,21 @@
<outputDirectory>${project.build.directory}/dependency</outputDirectory>
</configuration>
</execution>
+ <!--
+ Get ClangFormat.cmake
+ -->
+ <!--execution>
+ <id>get-clang-format</id>
+ <phase>generate-sources</phase>
+ <goals>
+ <goal>wget</goal>
+ </goals>
+ <configuration>
+ <url>https://raw.githubusercontent.com/zemasoft/clangformat-cmake/master/cmake/ClangFormat.cmake</url>
+ <unpack>true</unpack>
+ <outputDirectory>${project.build.directory}/dependency/clang-format</outputDirectory>
+ </configuration>
+ </execution-->
</executions>
</plugin>
<!--
diff --git a/plc4c/spi/include/plc4c/spi/types_private.h b/plc4c/spi/include/plc4c/spi/types_private.h
index da4d37812b..fc7d477e15 100644
--- a/plc4c/spi/include/plc4c/spi/types_private.h
+++ b/plc4c/spi/include/plc4c/spi/types_private.h
@@ -229,22 +229,36 @@ struct plc4c_data_t {
plc4c_data_type data_type;
size_t size;
union {
- bool boolean_value;
- int8_t char_value;
- uint8_t uchar_value;
- int16_t short_value;
- uint16_t ushort_value;
- int32_t int_value;
- uint32_t uint_value;
- int64_t lint_value;
+ bool bool_value;
+ uint8_t byte_value;
+ uint16_t word_value;
+ uint32_t dword_value;
+ uint64_t lword_value;
+
+ uint8_t usint_value;
+ int8_t sint_value;
+ uint16_t uint_value;
+ int16_t int_value;
+ uint32_t udint_value;
+ int32_t dint_value;
uint64_t ulint_value;
- /* more */
- float float_value;
- double double_value;
- char *pstring_value;
- char *const_string_value;
- void *pvoid_value;
- plc4c_list list_value;
+ int64_t lint_value;
+
+ float real_value;
+ double lreal_value;
+
+ uint16_t date_value;
+ uint32_t time_value;
+ uint64_t ltime_value;
+ uint32_t time_of_day_value;
+ uint32_t date_and_time_value;
+
+ char char_value;
+ wchar_t wchar_value;
+ char *string_value;
+ wchar_t *wstring_value;
+
+ plc4c_list* list_value;
} data;
plc4c_data_custom_destroy custom_destroy;
diff --git a/plc4c/spi/src/data.c b/plc4c/spi/src/data.c
index 66ec66585d..f2528c366d 100644
--- a/plc4c/spi/src/data.c
+++ b/plc4c/spi/src/data.c
@@ -28,267 +28,315 @@ plc4c_data *plc4c_data_create_bool_data(bool b) {
plc4c_data *data = malloc(sizeof(plc4c_data));
data->data_type = PLC4C_BOOL;
data->size = sizeof(bool);
- data->data.boolean_value = b;
+ data->data.bool_value = b;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_bool_array(bool *b, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
+plc4c_data *plc4c_data_create_bool_array(bool *b, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
elem = plc4c_data_create_bool_data(*(b + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-
-plc4c_data *plc4c_data_create_int8_t_data(int8_t c) {
+plc4c_data *plc4c_data_create_usint_data(uint8_t uc) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_CHAR;
- data->size = sizeof(char);
- data->data.char_value = c;
+ data->data_type = PLC4C_USINT;
+ data->size = sizeof(uint8_t);
+ data->data.usint_value = uc;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_int8_t_array(int8_t *c, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
- elem = plc4c_data_create_int8_t_data(*(c + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+plc4c_data *plc4c_data_create_usint_array(uint8_t *uc, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
+ elem = plc4c_data_create_usint_data(*(uc + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_uint8_t_data(uint8_t uc) {
+plc4c_data *plc4c_data_create_sint_data(int8_t uc) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_UCHAR;
- data->size = sizeof(unsigned char);
- data->data.uchar_value = uc;
+ data->data_type = PLC4C_SINT;
+ data->size = sizeof(int8_t);
+ data->data.usint_value = uc;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_uint8_t_array(uint8_t *uc, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
- elem = plc4c_data_create_uint8_t_data(*(uc + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+plc4c_data *plc4c_data_create_sint_array(int8_t *uc, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
+ elem = plc4c_data_create_sint_data(*(uc + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_int16_t_data(int16_t s) {
+plc4c_data *plc4c_data_create_uint_data(uint16_t us) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_SHORT;
- data->size = sizeof(short);
- data->data.short_value = s;
+ data->data_type = PLC4C_UINT;
+ data->size = sizeof(uint16_t);
+ data->data.uint_value = us;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_int16_t_array(int16_t *s, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
- elem = plc4c_data_create_int16_t_data(*(s + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+plc4c_data *plc4c_data_create_uint_array(uint16_t *us, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
+ elem = plc4c_data_create_uint_data(*(us + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-
-plc4c_data *plc4c_data_create_uint16_t_data(uint16_t us) {
+plc4c_data *plc4c_data_create_int_data(int16_t s) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_USHORT;
- data->size = sizeof(unsigned short);
- data->data.ushort_value = us;
+ data->data_type = PLC4C_INT;
+ data->size = sizeof(int16_t);
+ data->data.int_value = s;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_uint16_t_array(uint16_t *us, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
- elem = plc4c_data_create_uint16_t_data(*(us + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+plc4c_data *plc4c_data_create_int_array(int16_t *s, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
+ elem = plc4c_data_create_int_data(*(s + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_int32_t_data(int32_t i) {
+plc4c_data *plc4c_data_create_udint_data(uint32_t ui) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_INT;
- data->size = sizeof(int);
- data->data.int_value = i;
+ data->data_type = PLC4C_UDINT;
+ data->size = sizeof(uint32_t);
+ data->data.uint_value = ui;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_int32_t_array(int32_t *i, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
- elem = plc4c_data_create_int32_t_data(*(i + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+plc4c_data *plc4c_data_create_udint_array(uint32_t *ui, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
+ elem = plc4c_data_create_udint_data(*(ui + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_uint32_t_data(uint32_t ui) {
+plc4c_data *plc4c_data_create_dint_data(int32_t i) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_UINT;
- data->size = sizeof(unsigned int);
- data->data.uint_value = ui;
+ data->data_type = PLC4C_DINT;
+ data->size = sizeof(int32_t);
+ data->data.dint_value = i;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_uint32_t_array(uint32_t *ui, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
- elem = plc4c_data_create_uint32_t_data(*(ui + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+plc4c_data *plc4c_data_create_dint_array(int32_t *i, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
+ elem = plc4c_data_create_dint_data(*(i + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_int64_t_data(int64_t i) {
+plc4c_data *plc4c_data_create_ulint_data(uint64_t ui) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_LINT;
- data->size = sizeof(int);
- data->data.lint_value = i;
+ data->data_type = PLC4C_ULINT;
+ data->size = sizeof(uint64_t);
+ data->data.ulint_value = ui;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_int64_t_array(int64_t *i, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
- elem = plc4c_data_create_int64_t_data(*(i + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+plc4c_data *plc4c_data_create_ulint_array(uint64_t *ui, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
+ elem = plc4c_data_create_ulint_data(*(ui + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_uint64_t_data(uint64_t ui) {
+plc4c_data *plc4c_data_create_lint_data(int64_t i) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_ULINT;
- data->size = sizeof(unsigned int);
- data->data.ulint_value = ui;
+ data->data_type = PLC4C_LINT;
+ data->size = sizeof(int64_t);
+ data->data.lint_value = i;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_uint64_t_array(uint64_t *ui, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
- elem = plc4c_data_create_uint64_t_data(*(ui + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+plc4c_data *plc4c_data_create_lint_array(int64_t *i, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
+ elem = plc4c_data_create_lint_data(*(i + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_float_data(float f) {
- plc4c_data *data = calloc(1,sizeof(plc4c_data));
- data->data_type = PLC4C_FLOAT;
+plc4c_data *plc4c_data_create_real_data(float f) {
+ plc4c_data *data = malloc(sizeof(plc4c_data));
+ data->data_type = PLC4C_REAL;
data->size = sizeof(float);
- data->data.float_value = f;
+ data->data.real_value = f;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_float_array(float *f, int nItems) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
- for (size_t idx = 0; idx < nItems ; idx++) {
- elem = plc4c_data_create_float_data(*(f + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+plc4c_data *plc4c_data_create_real_array(float *f, int nItems) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
+ for (size_t idx = 0; idx < nItems; idx++) {
+ elem = plc4c_data_create_real_data(*(f + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_double_data(double d) {
+plc4c_data *plc4c_data_create_lreal_data(double d) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_DOUBLE;
- data->size = sizeof(float);
- data->data.double_value = d;
+ data->data_type = PLC4C_LREAL;
+ data->size = sizeof(double);
+ data->data.lreal_value = d;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data* plc4c_data_create_double_array(double *d, int nItem) {
- plc4c_list list;
- plc4c_data* elem;
- plc4c_utils_list_init(&list);
+plc4c_data *plc4c_data_create_lreal_array(double *d, int nItem) {
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_data *elem;
+ plc4c_utils_list_init(list);
for (size_t idx = 0; idx < nItem; idx++) {
- elem = plc4c_data_create_double_data(*(d + idx));
- plc4c_utils_list_insert_head_value(&list, elem);
+ elem = plc4c_data_create_lreal_data(*(d + idx));
+ plc4c_utils_list_insert_head_value(list, elem);
}
return plc4c_data_create_list_data(list);
}
+plc4c_data *plc4c_data_create_date_data(uint16_t d) {
+ // TODO: Implement
+ return NULL;
+}
+
+plc4c_data *plc4c_data_create_date_array(uint16_t *d, int nItems) {
+ // TODO: Implement
+ return NULL;
+}
+
+plc4c_data *plc4c_data_create_time_data(uint32_t t) {
+ // TODO: Implement
+ return NULL;
+}
+
+plc4c_data *plc4c_data_create_time_array(uint32_t *t, int nItems) {
+ // TODO: Implement
+ return NULL;
+}
+
+plc4c_data *plc4c_data_create_ltime_data(uint64_t lt) {
+ // TODO: Implement
+ return NULL;
+}
+
+plc4c_data *plc4c_data_create_ltime_array(uint64_t *lt, int nItems) {
+ // TODO: Implement
+ return NULL;
+}
+
+plc4c_data *plc4c_data_create_time_of_day_data(uint32_t tod) {
+ // TODO: Implement
+ return NULL;
+}
+
+plc4c_data *plc4c_data_create_time_of_day_array(uint32_t *tod, int nItems) {
+ // TODO: Implement
+ return NULL;
+}
+
+plc4c_data *plc4c_data_create_date_and_time_data(uint32_t tad) {
+ // TODO: Implement
+ return NULL;
+}
+
+plc4c_data *plc4c_data_create_date_and_time_array(uint32_t *tad, int nItems) {
+ // TODO: Implement
+ return NULL;
+}
plc4c_data *plc4c_data_create_string_data(unsigned int size, char *s) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_STRING_POINTER;
+ data->data_type = PLC4C_STRING;
data->size = size;
- data->data.pstring_value = s;
+ data->data.string_value = s;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data *plc4c_data_create_constant_string_data(unsigned int size, char *s) {
+plc4c_data *plc4c_data_create_char_data(char s) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_CONSTANT_STRING;
- data->size = size;
- data->data.const_string_value = s;
+ data->data_type = PLC4C_CHAR;
+ data->size = 1;
+ data->data.char_value = s;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data *plc4c_data_create_char_data(char* s) {
+plc4c_data *plc4c_data_create_wchar_data(wchar_t s) {
plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_CONSTANT_STRING;
- data->size = 1;
- data->data.const_string_value = s;
+ data->data_type = PLC4C_CHAR;
+ data->size = 2;
+ data->data.wchar_value = s;
data->custom_destroy = NULL;
data->custom_printf = NULL;
return data;
}
-plc4c_data *plc4c_data_create_list_data(plc4c_list list) {
+plc4c_data *plc4c_data_create_list_data(plc4c_list *list) {
plc4c_data *data = malloc(sizeof(plc4c_data));
data->data_type = PLC4C_LIST;
// TODO: Perhaps the list size makes more sense here
@@ -301,64 +349,54 @@ plc4c_data *plc4c_data_create_list_data(plc4c_list list) {
return data;
}
-plc4c_data *plc4c_data_create_uint8_t_bit_string_data(uint8_t uc) {
- uint8_t cur_bit = ((uint8_t) 1) << 7;
- plc4c_list list ;
- plc4c_utils_list_init(&list);
- for(int i = 0; i < 8; i++) {
+plc4c_data *plc4c_data_create_byte_data(uint8_t uc) {
+ uint8_t cur_bit = ((uint8_t)1) << 7;
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_utils_list_init(list);
+ for (int i = 0; i < 8; i++) {
plc4c_data *item = plc4c_data_create_bool_data((uc & cur_bit) != 0);
- plc4c_utils_list_insert_head_value(&list, item);
+ plc4c_utils_list_insert_head_value(list, item);
cur_bit = cur_bit >> 1;
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_uint16_t_bit_string_data(uint16_t us) {
- uint16_t cur_bit = ((uint16_t) 1) << 15;
- plc4c_list list ;
- plc4c_utils_list_init(&list);
- for(int i = 0; i < 16; i++) {
+plc4c_data *plc4c_data_create_word_data(uint16_t us) {
+ uint16_t cur_bit = ((uint16_t)1) << 15;
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_utils_list_init(list);
+ for (int i = 0; i < 16; i++) {
plc4c_data *item = plc4c_data_create_bool_data((us & cur_bit) != 0);
- plc4c_utils_list_insert_head_value(&list, item);
+ plc4c_utils_list_insert_head_value(list, item);
cur_bit = cur_bit >> 1;
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_uint32_t_bit_string_data(uint32_t ui) {
- uint32_t cur_bit = ((uint32_t) 1) << 31;
- plc4c_list list;
- plc4c_utils_list_init(&list);
- for(int i = 0; i < 32; i++) {
+plc4c_data *plc4c_data_create_dword_data(uint32_t ui) {
+ uint32_t cur_bit = ((uint32_t)1) << 31;
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_utils_list_init(list);
+ for (int i = 0; i < 32; i++) {
plc4c_data *item = plc4c_data_create_bool_data((ui & cur_bit) != 0);
- plc4c_utils_list_insert_head_value(&list, item);
+ plc4c_utils_list_insert_head_value(list, item);
cur_bit = cur_bit >> 1;
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_uint64_t_bit_string_data(uint64_t ui) {
- uint64_t cur_bit = ((uint64_t) 1) << 63;
- plc4c_list list;
- plc4c_utils_list_init(&list);
- for(int i = 0; i < 64; i++) {
+plc4c_data *plc4c_data_create_lword_data(uint64_t ui) {
+ uint64_t cur_bit = ((uint64_t)1) << 63;
+ plc4c_list *list = malloc(sizeof(plc4c_list));
+ plc4c_utils_list_init(list);
+ for (int i = 0; i < 64; i++) {
plc4c_data *item = plc4c_data_create_bool_data((ui & cur_bit) != 0);
- plc4c_utils_list_insert_head_value(&list, item);
+ plc4c_utils_list_insert_head_value(list, item);
cur_bit = cur_bit >> 1;
}
return plc4c_data_create_list_data(list);
}
-plc4c_data *plc4c_data_create_void_pointer_data(void *v) {
- plc4c_data *data = malloc(sizeof(plc4c_data));
- data->data_type = PLC4C_VOID_POINTER;
- data->size = 0;
- data->data.pvoid_value = v;
- data->custom_destroy = NULL;
- data->custom_printf = NULL;
- return data;
-}
-
void plc4c_data_printf(plc4c_data *data) {
if (data == NULL) {
printf("NULL");
@@ -366,48 +404,95 @@ void plc4c_data_printf(plc4c_data *data) {
}
switch (data->data_type) {
case PLC4C_BOOL:
- printf("%s", data->data.boolean_value ? "true" : "false");
+ printf("%s", data->data.bool_value ? "true" : "false");
break;
- case PLC4C_CHAR:
- printf("%d", data->data.char_value);
+ case PLC4C_BYTE:
+ printf("%hhu", data->data.byte_value);
break;
- case PLC4C_UCHAR:
- printf("%u", data->data.uchar_value);
+ case PLC4C_WORD:
+ printf("%d", data->data.word_value);
break;
- case PLC4C_SHORT:
- printf("%d", data->data.short_value);
+ case PLC4C_DWORD:
+ printf("%d", data->data.dword_value);
break;
- case PLC4C_USHORT:
- printf("%u", data->data.ushort_value);
+ case PLC4C_LWORD:
+ printf("%llu", data->data.lword_value);
break;
- case PLC4C_INT:
- printf("%d", data->data.int_value);
+
+ case PLC4C_USINT:
+ printf("%u", data->data.usint_value);
+ break;
+ case PLC4C_SINT:
+ printf("%d", data->data.sint_value);
break;
case PLC4C_UINT:
printf("%u", data->data.uint_value);
break;
- case PLC4C_LINT:
- printf("%ld", data->data.lint_value);
+ case PLC4C_INT:
+ printf("%d", data->data.int_value);
+ break;
+ case PLC4C_UDINT:
+ printf("%u", data->data.udint_value);
+ break;
+ case PLC4C_DINT:
+ printf("%d", data->data.dint_value);
break;
case PLC4C_ULINT:
- printf("%lu", data->data.ulint_value);
+ printf("%llu", data->data.ulint_value);
break;
- case PLC4C_FLOAT:
- printf("%f", data->data.float_value);
+ case PLC4C_LINT:
+ printf("%lld", data->data.lint_value);
break;
- case PLC4C_DOUBLE:
- printf("%.20f", data->data.double_value);
+
+ case PLC4C_REAL:
+ printf("%f", data->data.real_value);
break;
- case PLC4C_STRING_POINTER:
- printf("%s", data->data.pstring_value);
+ case PLC4C_LREAL:
+ printf("%.20f", data->data.lreal_value);
break;
- case PLC4C_CONSTANT_STRING:
- printf("%s", data->data.const_string_value);
+
+ /* case PLC4C_TIME:
+ printf("%d", data->data.time_value);
+ break;
+ case PLC4C_LTIME:
+ printf("%d", data->data.ltime_value);
+ break;
+ case PLC4C_DATE:
+ printf("%d", data->data._value);
+ break;
+ case PLC4C_LDATE:
+ printf("%d", data->data._value);
+ break;
+ case PLC4C_TIME_OF_DAY:
+ printf("%d", data->data._value);
+ break;
+ case PLC4C_LTIME_OF_DAY:
+ printf("%d", data->data._value);
+ break;
+ case PLC4C_DATE_AND_TIME:
+ printf("%d", data->data._value);
+ break;
+ case PLC4C_LDATE_AND_TIME:
+ printf("%d", data->data._value);
+ break;*/
+
+ case PLC4C_CHAR:
+ printf("%d", data->data.char_value);
+ break;
+ case PLC4C_WCHAR:
+ printf("%d", data->data.wchar_value);
break;
+ case PLC4C_STRING:
+ printf("%s", data->data.string_value);
+ break;
+ case PLC4C_WSTRING:
+ printf("%ws", data->data.wstring_value);
+ break;
+
case PLC4C_LIST:
printf("[");
plc4c_list_element *cur_element =
- plc4c_utils_list_tail(&data->data.list_value);
+ plc4c_utils_list_tail(data->data.list_value);
while (cur_element != NULL) {
plc4c_data *data_item = cur_element->value;
plc4c_data_printf(data_item);
@@ -418,16 +503,9 @@ void plc4c_data_printf(plc4c_data *data) {
}
printf("]");
break;
- case PLC4C_VOID_POINTER:
- if (data->custom_printf != NULL) {
- data->custom_printf(data);
- } else {
- printf("%p", data->data.pvoid_value);
- }
- break;
+
default:
printf("unknown");
-
break;
}
}
@@ -443,7 +521,7 @@ void plc4c_data_set_custom_printf(plc4c_data *data,
}
void list_data_rm(plc4c_list_element *elem) {
- plc4c_data* value;
+ plc4c_data *value;
value = elem->value;
plc4c_data_destroy(value);
}
@@ -454,16 +532,12 @@ void plc4c_data_destroy(plc4c_data *data) {
data->custom_destroy(data);
} else {
switch (data->data_type) {
- case PLC4C_VOID_POINTER:
- free(data->data.pvoid_value);
- break;
- case PLC4C_STRING_POINTER:
- free(data->data.pstring_value);
+ case PLC4C_STRING:
+ free(data->data.string_value);
break;
case PLC4C_LIST:
- plc4c_utils_list_delete_elements(&data->data.list_value,
- list_data_rm);
- //free(&data->data.list_value);
+ plc4c_utils_list_delete_elements(data->data.list_value, list_data_rm);
+ // free(&data->data.list_value);
default:
break;
}
@@ -471,82 +545,146 @@ void plc4c_data_destroy(plc4c_data *data) {
free(data);
}
+void *plc4c_data_update_values(plc4c_data *data, void *newData) {
+ switch (data->data_type) {
+ // Boolean/Bit-String Types
+ case PLC4C_BOOL:
+ data->data.bool_value = *(bool *)newData;
+ newData += sizeof(bool);
+ break;
+ case PLC4C_BYTE:
+ data->data.byte_value = *(uint8_t *)newData;
+ newData += sizeof(uint8_t);
+ break;
+ case PLC4C_WORD:
+ data->data.word_value = *(uint16_t *)newData;
+ newData += sizeof(uint16_t);
+ break;
+ case PLC4C_DWORD:
+ data->data.dword_value = *(uint32_t *)newData;
+ newData += sizeof(uint32_t);
+ break;
+ case PLC4C_LWORD:
+ data->data.lword_value = *(uint64_t *)newData;
+ newData += sizeof(uint64_t);
+ break;
+ // Integer Types (Unsigned/Signed)
+ // 1-byte
+ case PLC4C_USINT:
+ data->data.usint_value = *(uint8_t *)newData;
+ newData += sizeof(uint8_t);
+ break;
+ case PLC4C_SINT:
+ data->data.sint_value = *(int8_t *)newData;
+ newData += sizeof(int8_t);
+ break;
+ // 2-byte
+ case PLC4C_UINT:
+ data->data.uint_value = *(uint16_t *)newData;
+ newData += sizeof(uint16_t);
+ break;
+ case PLC4C_INT:
+ data->data.int_value = *(int16_t *)newData;
+ newData += sizeof(int16_t);
+ break;
+ // 4-byte
+ case PLC4C_UDINT:
+ data->data.udint_value = *(uint32_t *)newData;
+ newData += sizeof(uint32_t);
+ break;
+ case PLC4C_DINT:
+ data->data.dint_value = *(int32_t *)newData;
+ newData += sizeof(int32_t);
+ break;
+ // 8-byte
+ case PLC4C_ULINT:
+ data->data.ulint_value = *(uint64_t *)newData;
+ newData += sizeof(uint64_t);
+ break;
+ case PLC4C_LINT:
+ data->data.lint_value = *(int64_t *)newData;
+ newData += sizeof(int64_t);
+ break;
+ // Floating-Point Types
+ case PLC4C_REAL:
+ data->data.real_value = *(float *)newData;
+ newData += sizeof(float);
+ break;
+ case PLC4C_LREAL:
+ data->data.lreal_value = *(double *)newData;
+ newData += sizeof(double);
+ break;
+ // Time Types
+ /* case PLC4C_TIME:
+ data->data.time_value = *(*)newData;
+ newData += sizeof();
+ break;
+ case PLC4C_LTIME:
+ data->data.ltime_value = *(*)newData;
+ newData += sizeof();
+ break;
+ // Date Types
+ case PLC4C_DATE:
+ data->data. = *(*)newData;
+ newData += sizeof();
+ break;
+ case PLC4C_LDATE:
+ data->data. = *(*)newData;
+ newData += sizeof();
+ break;
+ // Time of day Types
+ case PLC4C_TIME_OF_DAY:
+ data->data. = *(*)newData;
+ newData += sizeof();
+ break;
+ case PLC4C_LTIME_OF_DAY:
+ data->data. = *(*)newData;
+ newData += sizeof();
+ break;
+ // Date and Time Types
+ case PLC4C_DATE_AND_TIME:
+ data->data. = *(*)newData;
+ newData += sizeof();
+ break;
+ case PLC4C_LDATE_AND_TIME:
+ data->data. = *(*)newData;
+ newData += sizeof();
+ break;*/
+ // Char and String Types
+ case PLC4C_CHAR:
+ data->data.char_value = *(char *)newData;
+ newData += sizeof(char);
+ break;
+ case PLC4C_WCHAR:
+ data->data.wchar_value = *(wchar_t *)newData;
+ newData += sizeof(char *);
+ break;
+ case PLC4C_STRING:
+ data->data.string_value = *(char **)newData;
+ newData += sizeof(char *);
+ break;
+ case PLC4C_WSTRING:
+ data->data.wstring_value = *(wchar_t **)newData;
+ newData += sizeof(wchar_t *);
+ break;
-#include <string.h>
-void* plc4c_data_update_values(plc4c_data *data, void *newData) {
+ case PLC4C_LIST: {
+ plc4c_list_element *list_element;
+ list_element = plc4c_utils_list_tail(data->data.list_value);
+ do {
+ plc4c_data *list_data = list_element->value;
+ newData = plc4c_data_update_values(list_data, newData);
+ list_element = list_element->next;
+ } while (list_element != NULL);
+ break;
+ }
+ case PLC4C_STRUCT:
+ // TODO
+ break;
- switch (data->data_type) {
- case PLC4C_BOOL:
- data->data.boolean_value = *(bool*)newData;
- newData += sizeof(bool);
- break;
- case PLC4C_CHAR:
- data->data.char_value = *(int8_t*)newData;
- newData += sizeof(int8_t);
- break;
- case PLC4C_UCHAR:
- data->data.char_value = *(int8_t*)newData;
- newData += sizeof(int8_t);
- break;
- case PLC4C_SHORT:
- data->data.short_value = *(int16_t*)newData;
- newData += sizeof(int16_t);
- break;
- case PLC4C_USHORT:
- data->data.ushort_value = *(uint16_t*)newData;
- newData += sizeof(uint16_t);
- break;
- case PLC4C_INT:
- data->data.int_value = *(int32_t*)newData;
- newData += sizeof(int32_t);
- break;
- case PLC4C_UINT:
- data->data.uint_value = *(uint32_t*)newData;
- newData += sizeof(uint32_t);
- break;
- case PLC4C_LINT:
- data->data.lint_value = *(int64_t*)newData;
- newData += sizeof(int64_t);
- break;
- case PLC4C_ULINT:
- data->data.ulint_value = *(uint64_t*)newData;
- newData += sizeof(uint64_t);
- break;
- case PLC4C_FLOAT:
- data->data.float_value = *(float*)newData;
- newData += sizeof(float);
- break;
- case PLC4C_DOUBLE:
- data->data.double_value = *(double*)newData;
- newData += sizeof(double);
- break;
- case PLC4C_STRING_POINTER:
- data->data.pstring_value = (char*) newData;
- newData += strlen(newData) + 1;
- break;
- case PLC4C_CONSTANT_STRING:
- data->data.const_string_value = (char *)newData;
- newData += strlen(newData) + 1;
- break;
- case PLC4C_VOID_POINTER:
- data->data.pvoid_value = newData;
- newData += sizeof(void*);
- break;
- case PLC4C_LIST: {
- plc4c_list_element *list_element;
- plc4c_data *list_data;
- list_element = plc4c_utils_list_tail(&data->data.list_value);
- do {
- plc4c_data *list_data = list_element->value;
- newData = plc4c_data_update_values(list_data, newData);
- list_element = list_element->next;
- } while (list_element != NULL);
- break;
- }
- case PLC4C_STRUCT:
- // TODO
- break;
+ default:
+ printf("unknown");
+ break;
}
return newData;
}
-
diff --git a/plc4c/spi/src/read_buffer.c b/plc4c/spi/src/read_buffer.c
index 471df0b116..b2969325f6 100644
--- a/plc4c/spi/src/read_buffer.c
+++ b/plc4c/spi/src/read_buffer.c
@@ -603,8 +603,8 @@ plc4c_return_code plc4c_spi_read_string(plc4c_spi_read_buffer* buf,
uint8_t num_bits, char* encoding,
char** value) {
- // Right now we only support utf-8.
- if(strcmp(encoding,"UTF-8") != 0) {
+ // Right now we only support utf-8 and utf-16.
+ if((strcmp(encoding,"UTF-8") != 0) && (strcmp(encoding,"UTF-16") != 0)) {
return INVALID_ARGUMENT;
}
diff --git a/plc4c/spi/src/types.c b/plc4c/spi/src/types.c
index 88c25bc0d2..58780f2c3f 100644
--- a/plc4c/spi/src/types.c
+++ b/plc4c/spi/src/types.c
@@ -107,41 +107,79 @@ char *plc4c_response_code_to_message(plc4c_response_code response_code) {
char *plc4c_data_type_name(plc4c_data_type data_type) {
switch (data_type) {
- case PLC4C_CHAR: {
- return "PLC4C_CHAR";
- }
- case PLC4C_UCHAR: {
- return "PLC4C_UCHAR";
- }
- case PLC4C_SHORT: {
- return "PLC4C_SHORT";
- }
- case PLC4C_USHORT: {
- return "PLC4C_USHORT";
- }
- case PLC4C_BOOL: {
+ // Boolean/Bit-String Types
+ case PLC4C_BOOL:
return "PLC4C_BOOL";
- }
- case PLC4C_INT: {
- return "PLC4C_INT";
- }
- case PLC4C_UINT: {
+ case PLC4C_BYTE:
+ return "PLC4C_BYTE";
+ case PLC4C_WORD:
+ return "PLC4C_WORD";
+ case PLC4C_DWORD:
+ return "PLC4C_DWORD";
+ case PLC4C_LWORD:
+ return "PLC4C_LWORD";
+ // Integer Types (Unsigned/Signed)
+ // 1-byte
+ case PLC4C_USINT:
+ return "PLC4C_USINT";
+ case PLC4C_SINT:
+ return "PLC4C_SINT";
+ // 2-byte
+ case PLC4C_UINT:
return "PLC4C_UINT";
- }
- case PLC4C_FLOAT: {
- return "PLC4C_FLOAT";
- }
- case PLC4C_STRING_POINTER: {
- return "PLC4C_STRING_POINTER";
- }
- case PLC4C_CONSTANT_STRING: {
- return "PLC4C_CONSTANT_STRING";
- }
- case PLC4C_VOID_POINTER: {
- return "PLC4C_VOID_POINTER";
- }
- default: {
+ case PLC4C_INT:
+ return "PLC4C_INT";
+ // 4-byte
+ case PLC4C_UDINT:
+ return "PLC4C_UDINT";
+ case PLC4C_DINT:
+ return "PLC4C_DINT";
+ // 8-byte
+ case PLC4C_ULINT:
+ return "PLC4C_ULINT";
+ case PLC4C_LINT:
+ return "PLC4C_LINT";
+ // Floating-Point Types
+ case PLC4C_REAL:
+ return "PLC4C_REAL";
+ case PLC4C_LREAL:
+ return "PLC4C_LREAL";
+ // Time Types
+ case PLC4C_TIME:
+ return "PLC4C_TIME";
+ case PLC4C_LTIME:
+ return "PLC4C_LTIME";
+ // Date Types
+ case PLC4C_DATE:
+ return "PLC4C_DATE";
+ case PLC4C_LDATE:
+ return "PLC4C_LDATE";
+ // Time of day Types
+ case PLC4C_TIME_OF_DAY:
+ return "PLC4C_TIME_OF_DAY";
+ case PLC4C_LTIME_OF_DAY:
+ return "PLC4C_LTIME_OF_DAY";
+ // Date and Time Types
+ case PLC4C_DATE_AND_TIME:
+ return "PLC4C_DATE_AND_TIME";
+ case PLC4C_LDATE_AND_TIME:
+ return "PLC4C_LDATE_AND_TIME";
+ // Char and String Types
+ case PLC4C_CHAR:
+ return "PLC4C_CHAR";
+ case PLC4C_WCHAR:
+ return "PLC4C_WCHAR";
+ case PLC4C_STRING:
+ return "PLC4C_STRING";
+ case PLC4C_WSTRING:
+ return "PLC4C_WSTRING";
+
+ case PLC4C_LIST:
+ return "PLC4C_LIST";
+ case PLC4C_STRUCT:
+ return "PLC4C_STRUCT";
+
+ default:
return "UNKNOWN";
}
}
-}
diff --git a/plc4c/spi/src/write_buffer.c b/plc4c/spi/src/write_buffer.c
index 7277314abe..fbeccdc092 100644
--- a/plc4c/spi/src/write_buffer.c
+++ b/plc4c/spi/src/write_buffer.c
@@ -420,8 +420,8 @@ plc4c_return_code plc4c_spi_write_double(plc4c_spi_write_buffer* buf,
plc4c_return_code plc4c_spi_write_string(plc4c_spi_write_buffer* buf,
uint8_t num_bits, char* encoding,
char* value) {
- // Right now we only support utf-8.
- if(strcmp(encoding,"UTF-8") != 0) {
+ // Right now we only support utf-8 and utf-16.
+ if((strcmp(encoding,"UTF-8") != 0) && (strcmp(encoding,"UTF-16") != 0)) {
return INVALID_ARGUMENT;
}
// Simply output the bytes to the buffer.
diff --git a/plc4c/spi/test/utils/test_utils.c b/plc4c/spi/test/utils/test_utils.c
index f2576f30ab..8b3b42dd4d 100644
--- a/plc4c/spi/test/utils/test_utils.c
+++ b/plc4c/spi/test/utils/test_utils.c
@@ -44,6 +44,6 @@ void internal_assert_arrays_equal(uint8_t* expected_array,
}
printf("\n");
}
- //TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected_value, actual_value, "Byte arrays differ");
+ TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected_value, actual_value, "Byte arrays differ");
}
}
diff --git a/plc4go/protocols/modbus/readwrite/model/DataItem.go b/plc4go/protocols/modbus/readwrite/model/DataItem.go
index b2bc088336..fc0aacaf96 100644
--- a/plc4go/protocols/modbus/readwrite/model/DataItem.go
+++ b/plc4go/protocols/modbus/readwrite/model/DataItem.go
@@ -56,19 +56,23 @@ func DataItemParse(readBuffer utils.ReadBuffer, dataType ModbusDataType, numberO
}
readBuffer.CloseContext("DataItem")
return values.NewPlcList(value), nil
- case dataType == ModbusDataType_BYTE && numberOfValues == uint16(1): // BitString
+ case dataType == ModbusDataType_BYTE && numberOfValues == uint16(1): // List
// Reserved Field (Just skip the bytes)
if _, _err := readBuffer.ReadUint8("reserved", 8); _err != nil {
return nil, errors.Wrap(_err, "Error parsing reserved field")
}
- // Simple Field (value)
- value, _valueErr := readBuffer.ReadUint8("value", 8)
- if _valueErr != nil {
- return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
+ // Array Field (value)
+ var value []api.PlcValue
+ for i := 0; i < int((8)); i++ {
+ _item, _itemErr := readBuffer.ReadBit("value")
+ if _itemErr != nil {
+ return nil, errors.Wrap(_itemErr, "Error parsing 'value' field")
+ }
+ value = append(value, values.NewPlcBOOL(_item))
}
readBuffer.CloseContext("DataItem")
- return values.NewPlcBitString(value), nil
+ return values.NewPlcList(value), nil
case dataType == ModbusDataType_BYTE: // List
// Array Field (value)
var value []api.PlcValue
@@ -81,14 +85,6 @@ func DataItemParse(readBuffer utils.ReadBuffer, dataType ModbusDataType, numberO
}
readBuffer.CloseContext("DataItem")
return values.NewPlcList(value), nil
- case dataType == ModbusDataType_WORD && numberOfValues == uint16(1): // BitString
- // Simple Field (value)
- value, _valueErr := readBuffer.ReadUint16("value", 16)
- if _valueErr != nil {
- return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
- }
- readBuffer.CloseContext("DataItem")
- return values.NewPlcBitString(value), nil
case dataType == ModbusDataType_WORD: // List
// Array Field (value)
var value []api.PlcValue
@@ -101,14 +97,6 @@ func DataItemParse(readBuffer utils.ReadBuffer, dataType ModbusDataType, numberO
}
readBuffer.CloseContext("DataItem")
return values.NewPlcList(value), nil
- case dataType == ModbusDataType_DWORD && numberOfValues == uint16(1): // BitString
- // Simple Field (value)
- value, _valueErr := readBuffer.ReadUint32("value", 32)
- if _valueErr != nil {
- return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
- }
- readBuffer.CloseContext("DataItem")
- return values.NewPlcBitString(value), nil
case dataType == ModbusDataType_DWORD: // List
// Array Field (value)
var value []api.PlcValue
@@ -121,14 +109,6 @@ func DataItemParse(readBuffer utils.ReadBuffer, dataType ModbusDataType, numberO
}
readBuffer.CloseContext("DataItem")
return values.NewPlcList(value), nil
- case dataType == ModbusDataType_LWORD && numberOfValues == uint16(1): // BitString
- // Simple Field (value)
- value, _valueErr := readBuffer.ReadUint64("value", 64)
- if _valueErr != nil {
- return nil, errors.Wrap(_valueErr, "Error parsing 'value' field")
- }
- readBuffer.CloseContext("DataItem")
- return values.NewPlcBitString(value), nil
case dataType == ModbusDataType_LWORD: // List
// Array Field (value)
var value []api.PlcValue
@@ -425,15 +405,18 @@ func DataItemSerialize(writeBuffer utils.WriteBuffer, value api.PlcValue, dataTy
return errors.Wrap(_itemErr, "Error serializing 'value' field")
}
}
- case dataType == ModbusDataType_BYTE && numberOfValues == uint16(1): // BitString
+ case dataType == ModbusDataType_BYTE && numberOfValues == uint16(1): // List
// Reserved Field (Just skip the bytes)
if _err := writeBuffer.WriteUint8("reserved", 8, uint8(0x00)); _err != nil {
return errors.Wrap(_err, "Error serializing reserved field")
}
- // Simple Field (value)
- if _err := writeBuffer.WriteUint8("value", 8, value.GetUint8()); _err != nil {
- return errors.Wrap(_err, "Error serializing 'value' field")
+ // Array Field (value)
+ for i := uint32(0); i < uint32((8)); i++ {
+ _itemErr := writeBuffer.WriteBit("", value.GetIndex(i).GetBool())
+ if _itemErr != nil {
+ return errors.Wrap(_itemErr, "Error serializing 'value' field")
+ }
}
case dataType == ModbusDataType_BYTE: // List
// Array Field (value)
@@ -443,11 +426,6 @@ func DataItemSerialize(writeBuffer utils.WriteBuffer, value api.PlcValue, dataTy
return errors.Wrap(_itemErr, "Error serializing 'value' field")
}
}
- case dataType == ModbusDataType_WORD && numberOfValues == uint16(1): // BitString
- // Simple Field (value)
- if _err := writeBuffer.WriteUint16("value", 16, value.GetUint16()); _err != nil {
- return errors.Wrap(_err, "Error serializing 'value' field")
- }
case dataType == ModbusDataType_WORD: // List
// Array Field (value)
for i := uint32(0); i < uint32((m.NumberOfValues)*(16)); i++ {
@@ -456,11 +434,6 @@ func DataItemSerialize(writeBuffer utils.WriteBuffer, value api.PlcValue, dataTy
return errors.Wrap(_itemErr, "Error serializing 'value' field")
}
}
- case dataType == ModbusDataType_DWORD && numberOfValues == uint16(1): // BitString
- // Simple Field (value)
- if _err := writeBuffer.WriteUint32("value", 32, value.GetUint32()); _err != nil {
- return errors.Wrap(_err, "Error serializing 'value' field")
- }
case dataType == ModbusDataType_DWORD: // List
// Array Field (value)
for i := uint32(0); i < uint32((m.NumberOfValues)*(32)); i++ {
@@ -469,11 +442,6 @@ func DataItemSerialize(writeBuffer utils.WriteBuffer, value api.PlcValue, dataTy
return errors.Wrap(_itemErr, "Error serializing 'value' field")
}
}
- case dataType == ModbusDataType_LWORD && numberOfValues == uint16(1): // BitString
- // Simple Field (value)
- if _err := writeBuffer.WriteUint64("value", 64, value.GetUint64()); _err != nil {
- return errors.Wrap(_err, "Error serializing 'value' field")
- }
case dataType == ModbusDataType_LWORD: // List
// Array Field (value)
for i := uint32(0); i < uint32((m.NumberOfValues)*(64)); i++ {
diff --git a/plc4net/drivers/knxnetip/src/drivers/knxnetip/readwrite/model/KnxManufacturer.cs b/plc4net/drivers/knxnetip/src/drivers/knxnetip/readwrite/model/KnxManufacturer.cs
index 7db7e88bab..3dc124e45b 100644
--- a/plc4net/drivers/knxnetip/src/drivers/knxnetip/readwrite/model/KnxManufacturer.cs
+++ b/plc4net/drivers/knxnetip/src/drivers/knxnetip/readwrite/model/KnxManufacturer.cs
@@ -612,8 +612,9 @@ namespace org.apache.plc4net.drivers.knxnetip.readwrite.model
M_HEFEI_CHUANG_YUE_INTELLIGENT_TECHNOLOGY_CO__LTD = 585,
M_LARFE = 586,
M_DONGGUAN_MUHCCI_ELECTRICAL = 587,
- M_ABB___RESERVED = 588,
- M_BUSCH_JAEGER_ELEKTRO___RESERVED = 589,
+ M_STEC = 588,
+ M_ABB___RESERVED = 589,
+ M_BUSCH_JAEGER_ELEKTRO___RESERVED = 590,
}
public static class KnxManufacturerInfo
@@ -2252,15 +2253,18 @@ namespace org.apache.plc4net.drivers.knxnetip.readwrite.model
case KnxManufacturer.M_DONGGUAN_MUHCCI_ELECTRICAL: { /* '587' */
return 645;
}
- case KnxManufacturer.M_ABB___RESERVED: { /* '588' */
- return 43954;
+ case KnxManufacturer.M_STEC: { /* '588' */
+ return 646;
}
- case KnxManufacturer.M_BUSCH_JAEGER_ELEKTRO___RESERVED: { /* '589' */
- return 43959;
+ case KnxManufacturer.M_ABB___RESERVED: { /* '589' */
+ return 43954;
}
case KnxManufacturer.M_ELECTRAK: { /* '59' */
return 98;
}
+ case KnxManufacturer.M_BUSCH_JAEGER_ELEKTRO___RESERVED: { /* '590' */
+ return 43959;
+ }
case KnxManufacturer.M_BUSCH_JAEGER_ELEKTRO: { /* '6' */
return 7;
}
@@ -4032,15 +4036,18 @@ namespace org.apache.plc4net.drivers.knxnetip.readwrite.model
case KnxManufacturer.M_DONGGUAN_MUHCCI_ELECTRICAL: { /* '587' */
return "Dongguan Muhcci Electrical";
}
- case KnxManufacturer.M_ABB___RESERVED: { /* '588' */
- return "ABB - reserved";
+ case KnxManufacturer.M_STEC: { /* '588' */
+ return "STEC";
}
- case KnxManufacturer.M_BUSCH_JAEGER_ELEKTRO___RESERVED: { /* '589' */
- return "Busch-Jaeger Elektro - reserved";
+ case KnxManufacturer.M_ABB___RESERVED: { /* '589' */
+ return "ABB - reserved";
}
case KnxManufacturer.M_ELECTRAK: { /* '59' */
return "Electrak";
}
+ case KnxManufacturer.M_BUSCH_JAEGER_ELEKTRO___RESERVED: { /* '590' */
+ return "Busch-Jaeger Elektro - reserved";
+ }
case KnxManufacturer.M_BUSCH_JAEGER_ELEKTRO: { /* '6' */
return "Busch-Jaeger Elektro";
}
diff --git a/protocols/modbus/src/main/resources/protocols/modbus/modbus.mspec b/protocols/modbus/src/main/resources/protocols/modbus/modbus.mspec
index 1136df74dd..3145c3b2e2 100644
--- a/protocols/modbus/src/main/resources/protocols/modbus/modbus.mspec
+++ b/protocols/modbus/src/main/resources/protocols/modbus/modbus.mspec
@@ -310,37 +310,31 @@
[dataIo DataItem(ModbusDataType dataType, uint 16 numberOfValues)
[typeSwitch dataType,numberOfValues
- ['BOOL','1' BOOL
- [reserved uint 15 '0x0000']
- [simple bit value ]
+ ['BOOL','1' BOOL
+ // TODO: Possibly change the order of the bit and the reserved part.
+ [reserved uint 15 '0x0000' ]
+ [simple bit value ]
]
- ['BOOL' List
- [array bit value count 'numberOfValues']
+ ['BOOL' List
+ // TODO: Handle adding some reserved bits at the end to fill up the last word.
+ [array bit value count 'numberOfValues' ]
]
- ['BYTE','1' BitString
+ ['BYTE','1' List
[reserved uint 8 '0x00']
- [simple uint 8 value ]
+ [array bit value count '8' ]
]
['BYTE' List
- [array bit value count 'numberOfValues * 8']
- ]
- ['WORD','1' BitString
- [simple uint 16 value]
+ // TODO: If the number of values is odd, add a reserved byte
+ [array bit value count 'numberOfValues * 8' ]
]
- ['WORD' List
- [array bit value count 'numberOfValues * 16']
+ ['WORD' List
+ [array bit value count 'numberOfValues * 16']
]
- ['DWORD','1' BitString
- [simple uint 32 value]
- ]
- ['DWORD' List
- [array bit value count 'numberOfValues * 32']
- ]
- ['LWORD','1' BitString
- [simple uint 64 value]
+ ['DWORD' List
+ [array bit value count 'numberOfValues * 32']
]
['LWORD' List
- [array bit value count 'numberOfValues * 64']
+ [array bit value count 'numberOfValues * 64']
]
['SINT','1' SINT
[reserved uint 8 '0x00']
diff --git a/protocols/plc4x/src/main/resources/protocols/plc4x/v0/plc4x.mspec b/protocols/plc4x/src/main/resources/protocols/plc4x/v0/plc4x.mspec
index f745c74f44..c4c7e31015 100644
--- a/protocols/plc4x/src/main/resources/protocols/plc4x/v0/plc4x.mspec
+++ b/protocols/plc4x/src/main/resources/protocols/plc4x/v0/plc4x.mspec
@@ -119,14 +119,17 @@
[reserved uint 7 '0x00' ]
[simple bit value ]
]
- ['BYTE' BitString
- [simple uint 8 value ]
+ ['BYTE' List
+ [array bit value count '8' ]
]
- ['WORD' BitString
- [simple uint 16 value ]
+ ['WORD' List
+ [array bit value count '16' ]
]
- ['DWORD' BitString
- [simple uint 32 value ]
+ ['DWORD' List
+ [array bit value count '32' ]
+ ]
+ ['LWORD' List
+ [array bit value count '64' ]
]
// Unsigned Integers
@@ -230,6 +233,7 @@
['0x02' BYTE ]
['0x03' WORD ]
['0x04' DWORD ]
+ ['0x05' LWORD ]
// Unsigned Integers
['0x11' USINT ]
diff --git a/protocols/plc4x/src/test/resources/protocols/plc4x/ParserSerializerTestsuite.xml b/protocols/plc4x/src/test/resources/protocols/plc4x/ParserSerializerTestsuite.xml
index 583b69e8d3..dffc880105 100644
--- a/protocols/plc4x/src/test/resources/protocols/plc4x/ParserSerializerTestsuite.xml
+++ b/protocols/plc4x/src/test/resources/protocols/plc4x/ParserSerializerTestsuite.xml
@@ -380,7 +380,14 @@
<Plc4xValueType dataType="uint" bitLength="8" stringRepresentation="BYTE">2</Plc4xValueType>
</valueType>
<value>
- <value dataType="uint" bitLength="8">191</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
</value>
</Plc4xFieldValueResponse>
<Plc4xFieldValueResponse>
@@ -399,7 +406,22 @@
<Plc4xValueType dataType="uint" bitLength="8" stringRepresentation="WORD">3</Plc4xValueType>
</valueType>
<value>
- <value dataType="uint" bitLength="16">10527</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
</value>
</Plc4xFieldValueResponse>
<Plc4xFieldValueResponse>
@@ -418,7 +440,38 @@
<Plc4xValueType dataType="uint" bitLength="8" stringRepresentation="DWORD">4</Plc4xValueType>
</valueType>
<value>
- <value dataType="uint" bitLength="32">2015598905</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">true</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">false</value>
+ <value dataType="bit" bitLength="1">true</value>
</value>
</Plc4xFieldValueResponse>
<Plc4xFieldValueResponse>