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 2020/10/23 08:20:26 UTC
[plc4x] branch feature/plc4go updated (7b14da8 -> 9bf1659)
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a change to branch feature/plc4go
in repository https://gitbox.apache.org/repos/asf/plc4x.git.
from 7b14da8 - Implemented the Floating-Point handling
new 1dec03b - Renamed the method to get an enum constant from a value from valueOf to enumForValue as for string based enums this was causing problems as enums always automatically have valueOf(String) methods
new 9bf1659 - Fixed the enum support of string-typed-enums in C
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../resources/templates/c/enum-template-c.ftlh | 6 +-
.../resources/templates/c/enum-template-h.ftlh | 2 +-
.../resources/templates/java/enum-template.ftlh | 4 +-
.../main/resources/templates/java/io-template.ftlh | 2 +-
.../plc4x/java/ads/protocol/AdsProtocolLogic.java | 4 +-
.../plc4x/java/modbus/field/ModbusField.java | 2 +-
.../java/modbus/protocol/ModbusProtocolLogic.java | 12 +-
.../java/s7/readwrite/utils/S7TsapIdEncoder.java | 2 +-
.../generated-sources/modbus/include/data_item.h | 2 +-
.../modbus/include/modbus_data_type.h | 77 +++++
.../modbus/include/modbus_data_type_sizes.h | 76 ++++
.../modbus/include/modbus_error_code.h | 57 +++
.../plc4c/generated-sources/modbus/src/data_item.c | 2 +-
.../modbus/src/modbus_data_type.c | 305 ++++++++++++++++
.../modbus/src/modbus_data_type_sizes.c | 296 ++++++++++++++++
.../modbus/src/modbus_error_code.c | 105 ++++++
.../generated-sources/s7/src/cotp_protocol_class.c | 20 +-
.../generated-sources/s7/src/cotp_tpdu_size.c | 42 +--
.../s7/src/data_transport_error_code.c | 24 +-
.../generated-sources/s7/src/data_transport_size.c | 42 +--
.../plc4c/generated-sources/s7/src/device_group.c | 12 +-
.../plc4c/generated-sources/s7/src/memory_area.c | 54 +--
.../s7/src/szl_module_type_class.c | 16 +-
.../plc4c/generated-sources/s7/src/szl_sublist.c | 76 ++--
.../generated-sources/s7/src/transport_size.c | 384 ++++++++++-----------
25 files changed, 1270 insertions(+), 354 deletions(-)
create mode 100644 sandbox/plc4c/generated-sources/modbus/include/modbus_data_type.h
create mode 100644 sandbox/plc4c/generated-sources/modbus/include/modbus_data_type_sizes.h
create mode 100644 sandbox/plc4c/generated-sources/modbus/include/modbus_error_code.h
create mode 100644 sandbox/plc4c/generated-sources/modbus/src/modbus_data_type.c
create mode 100644 sandbox/plc4c/generated-sources/modbus/src/modbus_data_type_sizes.c
create mode 100644 sandbox/plc4c/generated-sources/modbus/src/modbus_error_code.c
[plc4x] 02/02: - Fixed the enum support of string-typed-enums in C
Posted by cd...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch feature/plc4go
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit 9bf1659ff30a4cff980a7b20aa7c0a24289bd68a
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Fri Oct 23 10:20:16 2020 +0200
- Fixed the enum support of string-typed-enums in C
---
.../resources/templates/c/enum-template-c.ftlh | 6 +-
.../resources/templates/c/enum-template-h.ftlh | 2 +-
.../generated-sources/modbus/include/data_item.h | 2 +-
.../modbus/include/modbus_data_type.h | 77 +++++
.../modbus/include/modbus_data_type_sizes.h | 76 ++++
.../modbus/include/modbus_error_code.h | 57 +++
.../plc4c/generated-sources/modbus/src/data_item.c | 2 +-
.../modbus/src/modbus_data_type.c | 305 ++++++++++++++++
.../modbus/src/modbus_data_type_sizes.c | 296 ++++++++++++++++
.../modbus/src/modbus_error_code.c | 105 ++++++
.../generated-sources/s7/src/cotp_protocol_class.c | 20 +-
.../generated-sources/s7/src/cotp_tpdu_size.c | 42 +--
.../s7/src/data_transport_error_code.c | 24 +-
.../generated-sources/s7/src/data_transport_size.c | 42 +--
.../plc4c/generated-sources/s7/src/device_group.c | 12 +-
.../plc4c/generated-sources/s7/src/memory_area.c | 54 +--
.../s7/src/szl_module_type_class.c | 16 +-
.../plc4c/generated-sources/s7/src/szl_sublist.c | 76 ++--
.../generated-sources/s7/src/transport_size.c | 384 ++++++++++-----------
19 files changed, 1257 insertions(+), 341 deletions(-)
diff --git a/build-utils/language-c/src/main/resources/templates/c/enum-template-c.ftlh b/build-utils/language-c/src/main/resources/templates/c/enum-template-c.ftlh
index f8d9d20..2be06b4 100644
--- a/build-utils/language-c/src/main/resources/templates/c/enum-template-c.ftlh
+++ b/build-utils/language-c/src/main/resources/templates/c/enum-template-c.ftlh
@@ -58,7 +58,7 @@ ${helper.getCTypeName(type.name)} ${helper.getCTypeName(type.name)}_null() {
${helper.getCTypeName(type.name)} ${helper.getCTypeName(type.name)}_value_of(char* value_string) {
<#list helper.getUniqueEnumValues(type.enumValues) as enumValue>
if(strcmp(value_string, "${enumValue.name}") == 0) {
- return ${enumValue.value};
+ return ${helper.getCTypeName(type.name)}_${enumValue.name};
}
</#list>
return -1;
@@ -72,7 +72,7 @@ ${helper.getCTypeName(type.name)} ${helper.getCTypeName(type.name)}_value_for_in
switch(index) {
<#list helper.getUniqueEnumValues(type.enumValues) as enumValue>
case ${enumValue?index}: {
- return ${enumValue.value};
+ return ${helper.getCTypeName(type.name)}_${enumValue.name};
}
</#list>
default: {
@@ -91,7 +91,7 @@ ${helper.getCTypeName(type.name)} ${helper.getCTypeName(type.name)}_value_for_in
${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName))} ${helper.getCTypeName(type.name)}_get_${helper.camelCaseToSnakeCase(constantName)}(${helper.getCTypeName(type.name)} value) {
switch(value) {
<#list helper.getUniqueEnumValues(type.enumValues) as enumValue>
- case ${helper.escapeValue(type.type, enumValue.value)}: { /* '${enumValue.value}' */
+ case ${helper.getCTypeName(type.name)}_${enumValue.name}: { /* '${enumValue.value}' */
return ${helper.escapeEnumValue(type.getConstantType(constantName), enumValue.getConstant(constantName))?no_esc};
}<#sep>
</#sep></#list>
diff --git a/build-utils/language-c/src/main/resources/templates/c/enum-template-h.ftlh b/build-utils/language-c/src/main/resources/templates/c/enum-template-h.ftlh
index 223294b..266c39b 100644
--- a/build-utils/language-c/src/main/resources/templates/c/enum-template-h.ftlh
+++ b/build-utils/language-c/src/main/resources/templates/c/enum-template-h.ftlh
@@ -59,7 +59,7 @@ extern "C" {
-->
enum ${helper.getCTypeName(type.name)} {
<#list type.enumValues as enumValue>
- ${helper.getCTypeName(type.name)}_${enumValue.name} = ${enumValue.value}<#sep>,
+ ${helper.getCTypeName(type.name)}_${enumValue.name} = <#if helper.isStringTypeReference(type.type)>${enumValue?index}<#else>${enumValue.value}</#if><#sep>,
</#sep></#list>
};
diff --git a/sandbox/plc4c/generated-sources/modbus/include/data_item.h b/sandbox/plc4c/generated-sources/modbus/include/data_item.h
index d26c489..8b2aa04 100644
--- a/sandbox/plc4c/generated-sources/modbus/include/data_item.h
+++ b/sandbox/plc4c/generated-sources/modbus/include/data_item.h
@@ -29,7 +29,7 @@
extern "C" {
#endif
-plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer* buf, char* dataType, uint8_t numberOfValues, plc4c_data** data_item);
+plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer* buf, char* dataType, uint16_t numberOfValues, plc4c_data** data_item);
plc4c_return_code plc4c_modbus_read_write_data_item_serialize(plc4c_spi_write_buffer* buf, plc4c_data** data_item);
diff --git a/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type.h b/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type.h
new file mode 100644
index 0000000..5430652
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type.h
@@ -0,0 +1,77 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+#ifndef PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_H_
+#define PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum plc4c_modbus_read_write_modbus_data_type {
+ plc4c_modbus_read_write_modbus_data_type_NULL = 00,
+ plc4c_modbus_read_write_modbus_data_type_BOOL = 01,
+ plc4c_modbus_read_write_modbus_data_type_BYTE = 10,
+ plc4c_modbus_read_write_modbus_data_type_WORD = 11,
+ plc4c_modbus_read_write_modbus_data_type_DWORD = 12,
+ plc4c_modbus_read_write_modbus_data_type_LWORD = 13,
+ plc4c_modbus_read_write_modbus_data_type_SINT = 20,
+ plc4c_modbus_read_write_modbus_data_type_INT = 21,
+ plc4c_modbus_read_write_modbus_data_type_DINT = 22,
+ plc4c_modbus_read_write_modbus_data_type_LINT = 23,
+ plc4c_modbus_read_write_modbus_data_type_USINT = 24,
+ plc4c_modbus_read_write_modbus_data_type_UINT = 25,
+ plc4c_modbus_read_write_modbus_data_type_UDINT = 26,
+ plc4c_modbus_read_write_modbus_data_type_ULINT = 27,
+ plc4c_modbus_read_write_modbus_data_type_REAL = 30,
+ plc4c_modbus_read_write_modbus_data_type_LREAL = 31,
+ plc4c_modbus_read_write_modbus_data_type_TIME = 40,
+ plc4c_modbus_read_write_modbus_data_type_LTIME = 41,
+ plc4c_modbus_read_write_modbus_data_type_DATE = 50,
+ plc4c_modbus_read_write_modbus_data_type_LDATE = 51,
+ plc4c_modbus_read_write_modbus_data_type_TIME_OF_DAY = 60,
+ plc4c_modbus_read_write_modbus_data_type_LTIME_OF_DAY = 61,
+ plc4c_modbus_read_write_modbus_data_type_DATE_AND_TIME = 70,
+ plc4c_modbus_read_write_modbus_data_type_LDATE_AND_TIME = 71,
+ plc4c_modbus_read_write_modbus_data_type_CHAR = 80,
+ plc4c_modbus_read_write_modbus_data_type_WCHAR = 81,
+ plc4c_modbus_read_write_modbus_data_type_STRING = 82,
+ plc4c_modbus_read_write_modbus_data_type_WSTRING = 83
+};
+typedef enum plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type;
+
+// Get an empty NULL-struct
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_null();
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_value_of(char* value_string);
+
+int plc4c_modbus_read_write_modbus_data_type_num_values();
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_value_for_index(int index);
+
+uint8_t plc4c_modbus_read_write_modbus_data_type_get_data_type_size(plc4c_modbus_read_write_modbus_data_type value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_H_
diff --git a/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type_sizes.h b/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type_sizes.h
new file mode 100644
index 0000000..945e5e1
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/include/modbus_data_type_sizes.h
@@ -0,0 +1,76 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+#ifndef PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_SIZES_H_
+#define PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_SIZES_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum plc4c_modbus_read_write_modbus_data_type_sizes {
+ plc4c_modbus_read_write_modbus_data_type_sizes_BOOL = 0,
+ plc4c_modbus_read_write_modbus_data_type_sizes_BYTE = 1,
+ plc4c_modbus_read_write_modbus_data_type_sizes_WORD = 2,
+ plc4c_modbus_read_write_modbus_data_type_sizes_DWORD = 3,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LWORD = 4,
+ plc4c_modbus_read_write_modbus_data_type_sizes_SINT = 5,
+ plc4c_modbus_read_write_modbus_data_type_sizes_INT = 6,
+ plc4c_modbus_read_write_modbus_data_type_sizes_DINT = 7,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LINT = 8,
+ plc4c_modbus_read_write_modbus_data_type_sizes_USINT = 9,
+ plc4c_modbus_read_write_modbus_data_type_sizes_UINT = 10,
+ plc4c_modbus_read_write_modbus_data_type_sizes_UDINT = 11,
+ plc4c_modbus_read_write_modbus_data_type_sizes_ULINT = 12,
+ plc4c_modbus_read_write_modbus_data_type_sizes_REAL = 13,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LREAL = 14,
+ plc4c_modbus_read_write_modbus_data_type_sizes_TIME = 15,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LTIME = 16,
+ plc4c_modbus_read_write_modbus_data_type_sizes_DATE = 17,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LDATE = 18,
+ plc4c_modbus_read_write_modbus_data_type_sizes_TIME_OF_DAY = 19,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LTIME_OF_DAY = 20,
+ plc4c_modbus_read_write_modbus_data_type_sizes_DATE_AND_TIME = 21,
+ plc4c_modbus_read_write_modbus_data_type_sizes_LDATE_AND_TIME = 22,
+ plc4c_modbus_read_write_modbus_data_type_sizes_CHAR = 23,
+ plc4c_modbus_read_write_modbus_data_type_sizes_WCHAR = 24,
+ plc4c_modbus_read_write_modbus_data_type_sizes_STRING = 25,
+ plc4c_modbus_read_write_modbus_data_type_sizes_WSTRING = 26
+};
+typedef enum plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes;
+
+// Get an empty NULL-struct
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_null();
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_value_of(char* value_string);
+
+int plc4c_modbus_read_write_modbus_data_type_sizes_num_values();
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_value_for_index(int index);
+
+uint8_t plc4c_modbus_read_write_modbus_data_type_sizes_get_data_type_size(plc4c_modbus_read_write_modbus_data_type_sizes value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PLC4C_MODBUS_READ_WRITE_MODBUS_DATA_TYPE_SIZES_H_
diff --git a/sandbox/plc4c/generated-sources/modbus/include/modbus_error_code.h b/sandbox/plc4c/generated-sources/modbus/include/modbus_error_code.h
new file mode 100644
index 0000000..3a452e6
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/include/modbus_error_code.h
@@ -0,0 +1,57 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+#ifndef PLC4C_MODBUS_READ_WRITE_MODBUS_ERROR_CODE_H_
+#define PLC4C_MODBUS_READ_WRITE_MODBUS_ERROR_CODE_H_
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum plc4c_modbus_read_write_modbus_error_code {
+ plc4c_modbus_read_write_modbus_error_code_ILLEGAL_FUNCTION = 1,
+ plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_ADDRESS = 2,
+ plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_VALUE = 3,
+ plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_FAILURE = 4,
+ plc4c_modbus_read_write_modbus_error_code_ACKNOWLEDGE = 5,
+ plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_BUSY = 6,
+ plc4c_modbus_read_write_modbus_error_code_NEGATIVE_ACKNOWLEDGE = 7,
+ plc4c_modbus_read_write_modbus_error_code_MEMORY_PARITY_ERROR = 8,
+ plc4c_modbus_read_write_modbus_error_code_GATEWAY_PATH_UNAVAILABLE = 10,
+ plc4c_modbus_read_write_modbus_error_code_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 11
+};
+typedef enum plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code;
+
+// Get an empty NULL-struct
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_null();
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_value_of(char* value_string);
+
+int plc4c_modbus_read_write_modbus_error_code_num_values();
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_value_for_index(int index);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PLC4C_MODBUS_READ_WRITE_MODBUS_ERROR_CODE_H_
diff --git a/sandbox/plc4c/generated-sources/modbus/src/data_item.c b/sandbox/plc4c/generated-sources/modbus/src/data_item.c
index a801284..0980c00 100644
--- a/sandbox/plc4c/generated-sources/modbus/src/data_item.c
+++ b/sandbox/plc4c/generated-sources/modbus/src/data_item.c
@@ -26,7 +26,7 @@
#include "data_item.h"
// Parse function.
-plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer* io, char* dataType, uint8_t numberOfValues, plc4c_data** data_item) {
+plc4c_return_code plc4c_modbus_read_write_data_item_parse(plc4c_spi_read_buffer* io, char* dataType, uint16_t numberOfValues, plc4c_data** data_item) {
uint16_t startPos = plc4c_spi_read_get_pos(io);
uint16_t curPos;
plc4c_return_code _res = OK;
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type.c
new file mode 100644
index 0000000..abee4ac
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type.c
@@ -0,0 +1,305 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+#include "modbus_data_type.h"
+#include <string.h>
+
+
+// Create an empty NULL-struct
+static const plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_null_const;
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_null() {
+ return plc4c_modbus_read_write_modbus_data_type_null_const;
+}
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_value_of(char* value_string) {
+ if(strcmp(value_string, "NULL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_NULL;
+ }
+ if(strcmp(value_string, "BOOL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_BOOL;
+ }
+ if(strcmp(value_string, "BYTE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_BYTE;
+ }
+ if(strcmp(value_string, "WORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_WORD;
+ }
+ if(strcmp(value_string, "DWORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_DWORD;
+ }
+ if(strcmp(value_string, "LWORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LWORD;
+ }
+ if(strcmp(value_string, "SINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_SINT;
+ }
+ if(strcmp(value_string, "INT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_INT;
+ }
+ if(strcmp(value_string, "DINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_DINT;
+ }
+ if(strcmp(value_string, "LINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LINT;
+ }
+ if(strcmp(value_string, "USINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_USINT;
+ }
+ if(strcmp(value_string, "UINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_UINT;
+ }
+ if(strcmp(value_string, "UDINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_UDINT;
+ }
+ if(strcmp(value_string, "ULINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_ULINT;
+ }
+ if(strcmp(value_string, "REAL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_REAL;
+ }
+ if(strcmp(value_string, "LREAL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LREAL;
+ }
+ if(strcmp(value_string, "TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_TIME;
+ }
+ if(strcmp(value_string, "LTIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LTIME;
+ }
+ if(strcmp(value_string, "DATE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_DATE;
+ }
+ if(strcmp(value_string, "LDATE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LDATE;
+ }
+ if(strcmp(value_string, "TIME_OF_DAY") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_TIME_OF_DAY;
+ }
+ if(strcmp(value_string, "LTIME_OF_DAY") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LTIME_OF_DAY;
+ }
+ if(strcmp(value_string, "DATE_AND_TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_DATE_AND_TIME;
+ }
+ if(strcmp(value_string, "LDATE_AND_TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_LDATE_AND_TIME;
+ }
+ if(strcmp(value_string, "CHAR") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_CHAR;
+ }
+ if(strcmp(value_string, "WCHAR") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_WCHAR;
+ }
+ if(strcmp(value_string, "STRING") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_STRING;
+ }
+ if(strcmp(value_string, "WSTRING") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_WSTRING;
+ }
+ return -1;
+}
+
+int plc4c_modbus_read_write_modbus_data_type_num_values() {
+ return 28;
+}
+
+plc4c_modbus_read_write_modbus_data_type plc4c_modbus_read_write_modbus_data_type_value_for_index(int index) {
+ switch(index) {
+ case 0: {
+ return plc4c_modbus_read_write_modbus_data_type_NULL;
+ }
+ case 1: {
+ return plc4c_modbus_read_write_modbus_data_type_BOOL;
+ }
+ case 2: {
+ return plc4c_modbus_read_write_modbus_data_type_BYTE;
+ }
+ case 3: {
+ return plc4c_modbus_read_write_modbus_data_type_WORD;
+ }
+ case 4: {
+ return plc4c_modbus_read_write_modbus_data_type_DWORD;
+ }
+ case 5: {
+ return plc4c_modbus_read_write_modbus_data_type_LWORD;
+ }
+ case 6: {
+ return plc4c_modbus_read_write_modbus_data_type_SINT;
+ }
+ case 7: {
+ return plc4c_modbus_read_write_modbus_data_type_INT;
+ }
+ case 8: {
+ return plc4c_modbus_read_write_modbus_data_type_DINT;
+ }
+ case 9: {
+ return plc4c_modbus_read_write_modbus_data_type_LINT;
+ }
+ case 10: {
+ return plc4c_modbus_read_write_modbus_data_type_USINT;
+ }
+ case 11: {
+ return plc4c_modbus_read_write_modbus_data_type_UINT;
+ }
+ case 12: {
+ return plc4c_modbus_read_write_modbus_data_type_UDINT;
+ }
+ case 13: {
+ return plc4c_modbus_read_write_modbus_data_type_ULINT;
+ }
+ case 14: {
+ return plc4c_modbus_read_write_modbus_data_type_REAL;
+ }
+ case 15: {
+ return plc4c_modbus_read_write_modbus_data_type_LREAL;
+ }
+ case 16: {
+ return plc4c_modbus_read_write_modbus_data_type_TIME;
+ }
+ case 17: {
+ return plc4c_modbus_read_write_modbus_data_type_LTIME;
+ }
+ case 18: {
+ return plc4c_modbus_read_write_modbus_data_type_DATE;
+ }
+ case 19: {
+ return plc4c_modbus_read_write_modbus_data_type_LDATE;
+ }
+ case 20: {
+ return plc4c_modbus_read_write_modbus_data_type_TIME_OF_DAY;
+ }
+ case 21: {
+ return plc4c_modbus_read_write_modbus_data_type_LTIME_OF_DAY;
+ }
+ case 22: {
+ return plc4c_modbus_read_write_modbus_data_type_DATE_AND_TIME;
+ }
+ case 23: {
+ return plc4c_modbus_read_write_modbus_data_type_LDATE_AND_TIME;
+ }
+ case 24: {
+ return plc4c_modbus_read_write_modbus_data_type_CHAR;
+ }
+ case 25: {
+ return plc4c_modbus_read_write_modbus_data_type_WCHAR;
+ }
+ case 26: {
+ return plc4c_modbus_read_write_modbus_data_type_STRING;
+ }
+ case 27: {
+ return plc4c_modbus_read_write_modbus_data_type_WSTRING;
+ }
+ default: {
+ return -1;
+ }
+ }
+}
+
+uint8_t plc4c_modbus_read_write_modbus_data_type_get_data_type_size(plc4c_modbus_read_write_modbus_data_type value) {
+ switch(value) {
+ case plc4c_modbus_read_write_modbus_data_type_NULL: { /* '00' */
+ return 0;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_BOOL: { /* '01' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_BYTE: { /* '10' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_WORD: { /* '11' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_DWORD: { /* '12' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LWORD: { /* '13' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_SINT: { /* '20' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_INT: { /* '21' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_DINT: { /* '22' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LINT: { /* '23' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_USINT: { /* '24' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_UINT: { /* '25' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_UDINT: { /* '26' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_ULINT: { /* '27' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_REAL: { /* '30' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LREAL: { /* '31' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_TIME: { /* '40' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LTIME: { /* '41' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_DATE: { /* '50' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LDATE: { /* '51' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_TIME_OF_DAY: { /* '60' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LTIME_OF_DAY: { /* '61' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_DATE_AND_TIME: { /* '70' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_LDATE_AND_TIME: { /* '71' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_CHAR: { /* '80' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_WCHAR: { /* '81' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_STRING: { /* '82' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_WSTRING: { /* '83' */
+ return 2;
+ }
+ default: {
+ return 0;
+ }
+ }
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type_sizes.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type_sizes.c
new file mode 100644
index 0000000..d0eed67
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_data_type_sizes.c
@@ -0,0 +1,296 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+#include "modbus_data_type_sizes.h"
+#include <string.h>
+
+
+// Create an empty NULL-struct
+static const plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_null_const;
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_null() {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_null_const;
+}
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_value_of(char* value_string) {
+ if(strcmp(value_string, "BOOL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_BOOL;
+ }
+ if(strcmp(value_string, "BYTE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_BYTE;
+ }
+ if(strcmp(value_string, "CHAR") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_CHAR;
+ }
+ if(strcmp(value_string, "DATE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DATE;
+ }
+ if(strcmp(value_string, "DATE_AND_TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DATE_AND_TIME;
+ }
+ if(strcmp(value_string, "DINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DINT;
+ }
+ if(strcmp(value_string, "DWORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DWORD;
+ }
+ if(strcmp(value_string, "INT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_INT;
+ }
+ if(strcmp(value_string, "LDATE") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LDATE;
+ }
+ if(strcmp(value_string, "LDATE_AND_TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LDATE_AND_TIME;
+ }
+ if(strcmp(value_string, "LINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LINT;
+ }
+ if(strcmp(value_string, "LREAL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LREAL;
+ }
+ if(strcmp(value_string, "LTIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LTIME;
+ }
+ if(strcmp(value_string, "LTIME_OF_DAY") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LTIME_OF_DAY;
+ }
+ if(strcmp(value_string, "LWORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LWORD;
+ }
+ if(strcmp(value_string, "REAL") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_REAL;
+ }
+ if(strcmp(value_string, "SINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_SINT;
+ }
+ if(strcmp(value_string, "STRING") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_STRING;
+ }
+ if(strcmp(value_string, "TIME") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_TIME;
+ }
+ if(strcmp(value_string, "TIME_OF_DAY") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_TIME_OF_DAY;
+ }
+ if(strcmp(value_string, "UDINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_UDINT;
+ }
+ if(strcmp(value_string, "UINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_UINT;
+ }
+ if(strcmp(value_string, "ULINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_ULINT;
+ }
+ if(strcmp(value_string, "USINT") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_USINT;
+ }
+ if(strcmp(value_string, "WCHAR") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WCHAR;
+ }
+ if(strcmp(value_string, "WORD") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WORD;
+ }
+ if(strcmp(value_string, "WSTRING") == 0) {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WSTRING;
+ }
+ return -1;
+}
+
+int plc4c_modbus_read_write_modbus_data_type_sizes_num_values() {
+ return 27;
+}
+
+plc4c_modbus_read_write_modbus_data_type_sizes plc4c_modbus_read_write_modbus_data_type_sizes_value_for_index(int index) {
+ switch(index) {
+ case 0: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_BOOL;
+ }
+ case 1: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_BYTE;
+ }
+ case 2: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_CHAR;
+ }
+ case 3: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DATE;
+ }
+ case 4: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DATE_AND_TIME;
+ }
+ case 5: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DINT;
+ }
+ case 6: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_DWORD;
+ }
+ case 7: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_INT;
+ }
+ case 8: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LDATE;
+ }
+ case 9: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LDATE_AND_TIME;
+ }
+ case 10: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LINT;
+ }
+ case 11: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LREAL;
+ }
+ case 12: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LTIME;
+ }
+ case 13: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LTIME_OF_DAY;
+ }
+ case 14: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_LWORD;
+ }
+ case 15: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_REAL;
+ }
+ case 16: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_SINT;
+ }
+ case 17: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_STRING;
+ }
+ case 18: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_TIME;
+ }
+ case 19: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_TIME_OF_DAY;
+ }
+ case 20: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_UDINT;
+ }
+ case 21: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_UINT;
+ }
+ case 22: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_ULINT;
+ }
+ case 23: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_USINT;
+ }
+ case 24: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WCHAR;
+ }
+ case 25: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WORD;
+ }
+ case 26: {
+ return plc4c_modbus_read_write_modbus_data_type_sizes_WSTRING;
+ }
+ default: {
+ return -1;
+ }
+ }
+}
+
+uint8_t plc4c_modbus_read_write_modbus_data_type_sizes_get_data_type_size(plc4c_modbus_read_write_modbus_data_type_sizes value) {
+ switch(value) {
+ case plc4c_modbus_read_write_modbus_data_type_sizes_BOOL: { /* 'IEC61131_BOOL' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_BYTE: { /* 'IEC61131_BYTE' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_CHAR: { /* 'IEC61131_CHAR' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_DATE: { /* 'IEC61131_DATE' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_DATE_AND_TIME: { /* 'IEC61131_DATE_AND_TIME' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_DINT: { /* 'IEC61131_DINT' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_DWORD: { /* 'IEC61131_DWORD' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_INT: { /* 'IEC61131_INT' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LDATE: { /* 'IEC61131_LDATE' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LDATE_AND_TIME: { /* 'IEC61131_LDATE_AND_TIME' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LINT: { /* 'IEC61131_LINT' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LREAL: { /* 'IEC61131_LREAL' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LTIME: { /* 'IEC61131_LTIME' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LTIME_OF_DAY: { /* 'IEC61131_LTIME_OF_DAY' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_LWORD: { /* 'IEC61131_LWORD' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_REAL: { /* 'IEC61131_REAL' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_SINT: { /* 'IEC61131_SINT' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_STRING: { /* 'IEC61131_STRING' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_TIME: { /* 'IEC61131_TIME' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_TIME_OF_DAY: { /* 'IEC61131_TIME_OF_DAY' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_UDINT: { /* 'IEC61131_UDINT' */
+ return 4;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_UINT: { /* 'IEC61131_UINT' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_ULINT: { /* 'IEC61131_ULINT' */
+ return 8;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_USINT: { /* 'IEC61131_USINT' */
+ return 1;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_WCHAR: { /* 'IEC61131_WCHAR' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_WORD: { /* 'IEC61131_WORD' */
+ return 2;
+ }
+ case plc4c_modbus_read_write_modbus_data_type_sizes_WSTRING: { /* 'IEC61131_WSTRING' */
+ return 2;
+ }
+ default: {
+ return 0;
+ }
+ }
+}
diff --git a/sandbox/plc4c/generated-sources/modbus/src/modbus_error_code.c b/sandbox/plc4c/generated-sources/modbus/src/modbus_error_code.c
new file mode 100644
index 0000000..6f3a933
--- /dev/null
+++ b/sandbox/plc4c/generated-sources/modbus/src/modbus_error_code.c
@@ -0,0 +1,105 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied. See the License for the
+ specific language governing permissions and limitations
+ under the License.
+*/
+
+#include "modbus_error_code.h"
+#include <string.h>
+
+
+// Create an empty NULL-struct
+static const plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_null_const;
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_null() {
+ return plc4c_modbus_read_write_modbus_error_code_null_const;
+}
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_value_of(char* value_string) {
+ if(strcmp(value_string, "ILLEGAL_FUNCTION") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_FUNCTION;
+ }
+ if(strcmp(value_string, "GATEWAY_PATH_UNAVAILABLE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_GATEWAY_PATH_UNAVAILABLE;
+ }
+ if(strcmp(value_string, "GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND;
+ }
+ if(strcmp(value_string, "ILLEGAL_DATA_ADDRESS") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_ADDRESS;
+ }
+ if(strcmp(value_string, "ILLEGAL_DATA_VALUE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_VALUE;
+ }
+ if(strcmp(value_string, "SLAVE_DEVICE_FAILURE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_FAILURE;
+ }
+ if(strcmp(value_string, "ACKNOWLEDGE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_ACKNOWLEDGE;
+ }
+ if(strcmp(value_string, "SLAVE_DEVICE_BUSY") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_BUSY;
+ }
+ if(strcmp(value_string, "NEGATIVE_ACKNOWLEDGE") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_NEGATIVE_ACKNOWLEDGE;
+ }
+ if(strcmp(value_string, "MEMORY_PARITY_ERROR") == 0) {
+ return plc4c_modbus_read_write_modbus_error_code_MEMORY_PARITY_ERROR;
+ }
+ return -1;
+}
+
+int plc4c_modbus_read_write_modbus_error_code_num_values() {
+ return 10;
+}
+
+plc4c_modbus_read_write_modbus_error_code plc4c_modbus_read_write_modbus_error_code_value_for_index(int index) {
+ switch(index) {
+ case 0: {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_FUNCTION;
+ }
+ case 1: {
+ return plc4c_modbus_read_write_modbus_error_code_GATEWAY_PATH_UNAVAILABLE;
+ }
+ case 2: {
+ return plc4c_modbus_read_write_modbus_error_code_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND;
+ }
+ case 3: {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_ADDRESS;
+ }
+ case 4: {
+ return plc4c_modbus_read_write_modbus_error_code_ILLEGAL_DATA_VALUE;
+ }
+ case 5: {
+ return plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_FAILURE;
+ }
+ case 6: {
+ return plc4c_modbus_read_write_modbus_error_code_ACKNOWLEDGE;
+ }
+ case 7: {
+ return plc4c_modbus_read_write_modbus_error_code_SLAVE_DEVICE_BUSY;
+ }
+ case 8: {
+ return plc4c_modbus_read_write_modbus_error_code_NEGATIVE_ACKNOWLEDGE;
+ }
+ case 9: {
+ return plc4c_modbus_read_write_modbus_error_code_MEMORY_PARITY_ERROR;
+ }
+ default: {
+ return -1;
+ }
+ }
+}
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_protocol_class.c b/sandbox/plc4c/generated-sources/s7/src/cotp_protocol_class.c
index 771d486..015af7c 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_protocol_class.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_protocol_class.c
@@ -30,19 +30,19 @@ plc4c_s7_read_write_cotp_protocol_class plc4c_s7_read_write_cotp_protocol_class_
plc4c_s7_read_write_cotp_protocol_class plc4c_s7_read_write_cotp_protocol_class_value_of(char* value_string) {
if(strcmp(value_string, "CLASS_0") == 0) {
- return 0x00;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_0;
}
if(strcmp(value_string, "CLASS_1") == 0) {
- return 0x10;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_1;
}
if(strcmp(value_string, "CLASS_2") == 0) {
- return 0x20;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_2;
}
if(strcmp(value_string, "CLASS_3") == 0) {
- return 0x30;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_3;
}
if(strcmp(value_string, "CLASS_4") == 0) {
- return 0x40;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_4;
}
return -1;
}
@@ -54,19 +54,19 @@ int plc4c_s7_read_write_cotp_protocol_class_num_values() {
plc4c_s7_read_write_cotp_protocol_class plc4c_s7_read_write_cotp_protocol_class_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x00;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_0;
}
case 1: {
- return 0x10;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_1;
}
case 2: {
- return 0x20;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_2;
}
case 3: {
- return 0x30;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_3;
}
case 4: {
- return 0x40;
+ return plc4c_s7_read_write_cotp_protocol_class_CLASS_4;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/cotp_tpdu_size.c b/sandbox/plc4c/generated-sources/s7/src/cotp_tpdu_size.c
index 7d78bf8..d5deae3 100644
--- a/sandbox/plc4c/generated-sources/s7/src/cotp_tpdu_size.c
+++ b/sandbox/plc4c/generated-sources/s7/src/cotp_tpdu_size.c
@@ -30,25 +30,25 @@ plc4c_s7_read_write_cotp_tpdu_size plc4c_s7_read_write_cotp_tpdu_size_null() {
plc4c_s7_read_write_cotp_tpdu_size plc4c_s7_read_write_cotp_tpdu_size_value_of(char* value_string) {
if(strcmp(value_string, "SIZE_128") == 0) {
- return 0x07;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_128;
}
if(strcmp(value_string, "SIZE_256") == 0) {
- return 0x08;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_256;
}
if(strcmp(value_string, "SIZE_512") == 0) {
- return 0x09;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_512;
}
if(strcmp(value_string, "SIZE_1024") == 0) {
- return 0x0a;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_1024;
}
if(strcmp(value_string, "SIZE_2048") == 0) {
- return 0x0b;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_2048;
}
if(strcmp(value_string, "SIZE_4096") == 0) {
- return 0x0c;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_4096;
}
if(strcmp(value_string, "SIZE_8192") == 0) {
- return 0x0d;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_8192;
}
return -1;
}
@@ -60,25 +60,25 @@ int plc4c_s7_read_write_cotp_tpdu_size_num_values() {
plc4c_s7_read_write_cotp_tpdu_size plc4c_s7_read_write_cotp_tpdu_size_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x07;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_128;
}
case 1: {
- return 0x08;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_256;
}
case 2: {
- return 0x09;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_512;
}
case 3: {
- return 0x0a;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_1024;
}
case 4: {
- return 0x0b;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_2048;
}
case 5: {
- return 0x0c;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_4096;
}
case 6: {
- return 0x0d;
+ return plc4c_s7_read_write_cotp_tpdu_size_SIZE_8192;
}
default: {
return -1;
@@ -88,25 +88,25 @@ plc4c_s7_read_write_cotp_tpdu_size plc4c_s7_read_write_cotp_tpdu_size_value_for_
uint16_t plc4c_s7_read_write_cotp_tpdu_size_get_size_in_bytes(plc4c_s7_read_write_cotp_tpdu_size value) {
switch(value) {
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_128: { /* '0x07' */
return 128;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_256: { /* '0x08' */
return 256;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_512: { /* '0x09' */
return 512;
}
- case 10: { /* '0x0a' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_1024: { /* '0x0a' */
return 1024;
}
- case 11: { /* '0x0b' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_2048: { /* '0x0b' */
return 2048;
}
- case 12: { /* '0x0c' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_4096: { /* '0x0c' */
return 4096;
}
- case 13: { /* '0x0d' */
+ case plc4c_s7_read_write_cotp_tpdu_size_SIZE_8192: { /* '0x0d' */
return 8192;
}
default: {
diff --git a/sandbox/plc4c/generated-sources/s7/src/data_transport_error_code.c b/sandbox/plc4c/generated-sources/s7/src/data_transport_error_code.c
index cb13d9d..4d71dfb 100644
--- a/sandbox/plc4c/generated-sources/s7/src/data_transport_error_code.c
+++ b/sandbox/plc4c/generated-sources/s7/src/data_transport_error_code.c
@@ -30,22 +30,22 @@ plc4c_s7_read_write_data_transport_error_code plc4c_s7_read_write_data_transport
plc4c_s7_read_write_data_transport_error_code plc4c_s7_read_write_data_transport_error_code_value_of(char* value_string) {
if(strcmp(value_string, "RESERVED") == 0) {
- return 0x00;
+ return plc4c_s7_read_write_data_transport_error_code_RESERVED;
}
if(strcmp(value_string, "ACCESS_DENIED") == 0) {
- return 0x03;
+ return plc4c_s7_read_write_data_transport_error_code_ACCESS_DENIED;
}
if(strcmp(value_string, "INVALID_ADDRESS") == 0) {
- return 0x05;
+ return plc4c_s7_read_write_data_transport_error_code_INVALID_ADDRESS;
}
if(strcmp(value_string, "DATA_TYPE_NOT_SUPPORTED") == 0) {
- return 0x06;
+ return plc4c_s7_read_write_data_transport_error_code_DATA_TYPE_NOT_SUPPORTED;
}
if(strcmp(value_string, "NOT_FOUND") == 0) {
- return 0x0A;
+ return plc4c_s7_read_write_data_transport_error_code_NOT_FOUND;
}
if(strcmp(value_string, "OK") == 0) {
- return 0xFF;
+ return plc4c_s7_read_write_data_transport_error_code_OK;
}
return -1;
}
@@ -57,22 +57,22 @@ int plc4c_s7_read_write_data_transport_error_code_num_values() {
plc4c_s7_read_write_data_transport_error_code plc4c_s7_read_write_data_transport_error_code_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x00;
+ return plc4c_s7_read_write_data_transport_error_code_RESERVED;
}
case 1: {
- return 0x03;
+ return plc4c_s7_read_write_data_transport_error_code_ACCESS_DENIED;
}
case 2: {
- return 0x05;
+ return plc4c_s7_read_write_data_transport_error_code_INVALID_ADDRESS;
}
case 3: {
- return 0x06;
+ return plc4c_s7_read_write_data_transport_error_code_DATA_TYPE_NOT_SUPPORTED;
}
case 4: {
- return 0x0A;
+ return plc4c_s7_read_write_data_transport_error_code_NOT_FOUND;
}
case 5: {
- return 0xFF;
+ return plc4c_s7_read_write_data_transport_error_code_OK;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/data_transport_size.c b/sandbox/plc4c/generated-sources/s7/src/data_transport_size.c
index 5b2bf04..14b508d 100644
--- a/sandbox/plc4c/generated-sources/s7/src/data_transport_size.c
+++ b/sandbox/plc4c/generated-sources/s7/src/data_transport_size.c
@@ -30,25 +30,25 @@ plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_data_transport_size_
plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_data_transport_size_value_of(char* value_string) {
if(strcmp(value_string, "NULL") == 0) {
- return 0x00;
+ return plc4c_s7_read_write_data_transport_size_NULL;
}
if(strcmp(value_string, "BIT") == 0) {
- return 0x03;
+ return plc4c_s7_read_write_data_transport_size_BIT;
}
if(strcmp(value_string, "BYTE_WORD_DWORD") == 0) {
- return 0x04;
+ return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
if(strcmp(value_string, "INTEGER") == 0) {
- return 0x05;
+ return plc4c_s7_read_write_data_transport_size_INTEGER;
}
if(strcmp(value_string, "DINTEGER") == 0) {
- return 0x06;
+ return plc4c_s7_read_write_data_transport_size_DINTEGER;
}
if(strcmp(value_string, "REAL") == 0) {
- return 0x07;
+ return plc4c_s7_read_write_data_transport_size_REAL;
}
if(strcmp(value_string, "OCTET_STRING") == 0) {
- return 0x09;
+ return plc4c_s7_read_write_data_transport_size_OCTET_STRING;
}
return -1;
}
@@ -60,25 +60,25 @@ int plc4c_s7_read_write_data_transport_size_num_values() {
plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_data_transport_size_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x00;
+ return plc4c_s7_read_write_data_transport_size_NULL;
}
case 1: {
- return 0x03;
+ return plc4c_s7_read_write_data_transport_size_BIT;
}
case 2: {
- return 0x04;
+ return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
case 3: {
- return 0x05;
+ return plc4c_s7_read_write_data_transport_size_INTEGER;
}
case 4: {
- return 0x06;
+ return plc4c_s7_read_write_data_transport_size_DINTEGER;
}
case 5: {
- return 0x07;
+ return plc4c_s7_read_write_data_transport_size_REAL;
}
case 6: {
- return 0x09;
+ return plc4c_s7_read_write_data_transport_size_OCTET_STRING;
}
default: {
return -1;
@@ -88,25 +88,25 @@ plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_data_transport_size_
bool plc4c_s7_read_write_data_transport_size_get_size_in_bits(plc4c_s7_read_write_data_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_data_transport_size_NULL: { /* '0x00' */
return false;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_data_transport_size_BIT: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_data_transport_size_INTEGER: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_data_transport_size_DINTEGER: { /* '0x06' */
return false;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_data_transport_size_REAL: { /* '0x07' */
return false;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_data_transport_size_OCTET_STRING: { /* '0x09' */
return false;
}
default: {
diff --git a/sandbox/plc4c/generated-sources/s7/src/device_group.c b/sandbox/plc4c/generated-sources/s7/src/device_group.c
index 08fff70..f5bebb4 100644
--- a/sandbox/plc4c/generated-sources/s7/src/device_group.c
+++ b/sandbox/plc4c/generated-sources/s7/src/device_group.c
@@ -30,13 +30,13 @@ plc4c_s7_read_write_device_group plc4c_s7_read_write_device_group_null() {
plc4c_s7_read_write_device_group plc4c_s7_read_write_device_group_value_of(char* value_string) {
if(strcmp(value_string, "PG_OR_PC") == 0) {
- return 0x01;
+ return plc4c_s7_read_write_device_group_PG_OR_PC;
}
if(strcmp(value_string, "OS") == 0) {
- return 0x02;
+ return plc4c_s7_read_write_device_group_OS;
}
if(strcmp(value_string, "OTHERS") == 0) {
- return 0x03;
+ return plc4c_s7_read_write_device_group_OTHERS;
}
return -1;
}
@@ -48,13 +48,13 @@ int plc4c_s7_read_write_device_group_num_values() {
plc4c_s7_read_write_device_group plc4c_s7_read_write_device_group_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x01;
+ return plc4c_s7_read_write_device_group_PG_OR_PC;
}
case 1: {
- return 0x02;
+ return plc4c_s7_read_write_device_group_OS;
}
case 2: {
- return 0x03;
+ return plc4c_s7_read_write_device_group_OTHERS;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/memory_area.c b/sandbox/plc4c/generated-sources/s7/src/memory_area.c
index 6a7fe3a..51a929f 100644
--- a/sandbox/plc4c/generated-sources/s7/src/memory_area.c
+++ b/sandbox/plc4c/generated-sources/s7/src/memory_area.c
@@ -30,31 +30,31 @@ plc4c_s7_read_write_memory_area plc4c_s7_read_write_memory_area_null() {
plc4c_s7_read_write_memory_area plc4c_s7_read_write_memory_area_value_of(char* value_string) {
if(strcmp(value_string, "COUNTERS") == 0) {
- return 0x1C;
+ return plc4c_s7_read_write_memory_area_COUNTERS;
}
if(strcmp(value_string, "TIMERS") == 0) {
- return 0x1D;
+ return plc4c_s7_read_write_memory_area_TIMERS;
}
if(strcmp(value_string, "DIRECT_PERIPHERAL_ACCESS") == 0) {
- return 0x80;
+ return plc4c_s7_read_write_memory_area_DIRECT_PERIPHERAL_ACCESS;
}
if(strcmp(value_string, "INPUTS") == 0) {
- return 0x81;
+ return plc4c_s7_read_write_memory_area_INPUTS;
}
if(strcmp(value_string, "OUTPUTS") == 0) {
- return 0x82;
+ return plc4c_s7_read_write_memory_area_OUTPUTS;
}
if(strcmp(value_string, "FLAGS_MARKERS") == 0) {
- return 0x83;
+ return plc4c_s7_read_write_memory_area_FLAGS_MARKERS;
}
if(strcmp(value_string, "DATA_BLOCKS") == 0) {
- return 0x84;
+ return plc4c_s7_read_write_memory_area_DATA_BLOCKS;
}
if(strcmp(value_string, "INSTANCE_DATA_BLOCKS") == 0) {
- return 0x85;
+ return plc4c_s7_read_write_memory_area_INSTANCE_DATA_BLOCKS;
}
if(strcmp(value_string, "LOCAL_DATA") == 0) {
- return 0x86;
+ return plc4c_s7_read_write_memory_area_LOCAL_DATA;
}
return -1;
}
@@ -66,31 +66,31 @@ int plc4c_s7_read_write_memory_area_num_values() {
plc4c_s7_read_write_memory_area plc4c_s7_read_write_memory_area_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x1C;
+ return plc4c_s7_read_write_memory_area_COUNTERS;
}
case 1: {
- return 0x1D;
+ return plc4c_s7_read_write_memory_area_TIMERS;
}
case 2: {
- return 0x80;
+ return plc4c_s7_read_write_memory_area_DIRECT_PERIPHERAL_ACCESS;
}
case 3: {
- return 0x81;
+ return plc4c_s7_read_write_memory_area_INPUTS;
}
case 4: {
- return 0x82;
+ return plc4c_s7_read_write_memory_area_OUTPUTS;
}
case 5: {
- return 0x83;
+ return plc4c_s7_read_write_memory_area_FLAGS_MARKERS;
}
case 6: {
- return 0x84;
+ return plc4c_s7_read_write_memory_area_DATA_BLOCKS;
}
case 7: {
- return 0x85;
+ return plc4c_s7_read_write_memory_area_INSTANCE_DATA_BLOCKS;
}
case 8: {
- return 0x86;
+ return plc4c_s7_read_write_memory_area_LOCAL_DATA;
}
default: {
return -1;
@@ -100,31 +100,31 @@ plc4c_s7_read_write_memory_area plc4c_s7_read_write_memory_area_value_for_index(
char* plc4c_s7_read_write_memory_area_get_short_name(plc4c_s7_read_write_memory_area value) {
switch(value) {
- case 28: { /* '0x1C' */
+ case plc4c_s7_read_write_memory_area_COUNTERS: { /* '0x1C' */
return "C";
}
- case 29: { /* '0x1D' */
+ case plc4c_s7_read_write_memory_area_TIMERS: { /* '0x1D' */
return "T";
}
- case 128: { /* '0x80' */
+ case plc4c_s7_read_write_memory_area_DIRECT_PERIPHERAL_ACCESS: { /* '0x80' */
return "D";
}
- case 129: { /* '0x81' */
+ case plc4c_s7_read_write_memory_area_INPUTS: { /* '0x81' */
return "I";
}
- case 130: { /* '0x82' */
+ case plc4c_s7_read_write_memory_area_OUTPUTS: { /* '0x82' */
return "Q";
}
- case 131: { /* '0x83' */
+ case plc4c_s7_read_write_memory_area_FLAGS_MARKERS: { /* '0x83' */
return "M";
}
- case 132: { /* '0x84' */
+ case plc4c_s7_read_write_memory_area_DATA_BLOCKS: { /* '0x84' */
return "DB";
}
- case 133: { /* '0x85' */
+ case plc4c_s7_read_write_memory_area_INSTANCE_DATA_BLOCKS: { /* '0x85' */
return "DBI";
}
- case 134: { /* '0x86' */
+ case plc4c_s7_read_write_memory_area_LOCAL_DATA: { /* '0x86' */
return "LD";
}
default: {
diff --git a/sandbox/plc4c/generated-sources/s7/src/szl_module_type_class.c b/sandbox/plc4c/generated-sources/s7/src/szl_module_type_class.c
index 220cea1..6967575 100644
--- a/sandbox/plc4c/generated-sources/s7/src/szl_module_type_class.c
+++ b/sandbox/plc4c/generated-sources/s7/src/szl_module_type_class.c
@@ -30,16 +30,16 @@ plc4c_s7_read_write_szl_module_type_class plc4c_s7_read_write_szl_module_type_cl
plc4c_s7_read_write_szl_module_type_class plc4c_s7_read_write_szl_module_type_class_value_of(char* value_string) {
if(strcmp(value_string, "CPU") == 0) {
- return 0x0;
+ return plc4c_s7_read_write_szl_module_type_class_CPU;
}
if(strcmp(value_string, "IM") == 0) {
- return 0x4;
+ return plc4c_s7_read_write_szl_module_type_class_IM;
}
if(strcmp(value_string, "FM") == 0) {
- return 0x8;
+ return plc4c_s7_read_write_szl_module_type_class_FM;
}
if(strcmp(value_string, "CP") == 0) {
- return 0xC;
+ return plc4c_s7_read_write_szl_module_type_class_CP;
}
return -1;
}
@@ -51,16 +51,16 @@ int plc4c_s7_read_write_szl_module_type_class_num_values() {
plc4c_s7_read_write_szl_module_type_class plc4c_s7_read_write_szl_module_type_class_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x0;
+ return plc4c_s7_read_write_szl_module_type_class_CPU;
}
case 1: {
- return 0x4;
+ return plc4c_s7_read_write_szl_module_type_class_IM;
}
case 2: {
- return 0x8;
+ return plc4c_s7_read_write_szl_module_type_class_FM;
}
case 3: {
- return 0xC;
+ return plc4c_s7_read_write_szl_module_type_class_CP;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/szl_sublist.c b/sandbox/plc4c/generated-sources/s7/src/szl_sublist.c
index b727b2f..46fa12e 100644
--- a/sandbox/plc4c/generated-sources/s7/src/szl_sublist.c
+++ b/sandbox/plc4c/generated-sources/s7/src/szl_sublist.c
@@ -30,61 +30,61 @@ plc4c_s7_read_write_szl_sublist plc4c_s7_read_write_szl_sublist_null() {
plc4c_s7_read_write_szl_sublist plc4c_s7_read_write_szl_sublist_value_of(char* value_string) {
if(strcmp(value_string, "MODULE_IDENTIFICATION") == 0) {
- return 0x11;
+ return plc4c_s7_read_write_szl_sublist_MODULE_IDENTIFICATION;
}
if(strcmp(value_string, "CPU_FEATURES") == 0) {
- return 0x12;
+ return plc4c_s7_read_write_szl_sublist_CPU_FEATURES;
}
if(strcmp(value_string, "USER_MEMORY_AREA") == 0) {
- return 0x13;
+ return plc4c_s7_read_write_szl_sublist_USER_MEMORY_AREA;
}
if(strcmp(value_string, "SYSTEM_AREAS") == 0) {
- return 0x14;
+ return plc4c_s7_read_write_szl_sublist_SYSTEM_AREAS;
}
if(strcmp(value_string, "BLOCK_TYPES") == 0) {
- return 0x15;
+ return plc4c_s7_read_write_szl_sublist_BLOCK_TYPES;
}
if(strcmp(value_string, "STATUS_MODULE_LEDS") == 0) {
- return 0x19;
+ return plc4c_s7_read_write_szl_sublist_STATUS_MODULE_LEDS;
}
if(strcmp(value_string, "COMPONENT_IDENTIFICATION") == 0) {
- return 0x1C;
+ return plc4c_s7_read_write_szl_sublist_COMPONENT_IDENTIFICATION;
}
if(strcmp(value_string, "INTERRUPT_STATUS") == 0) {
- return 0x22;
+ return plc4c_s7_read_write_szl_sublist_INTERRUPT_STATUS;
}
if(strcmp(value_string, "ASSIGNMENT_BETWEEN_PROCESS_IMAGE_PARTITIONS_AND_OBS") == 0) {
- return 0x25;
+ return plc4c_s7_read_write_szl_sublist_ASSIGNMENT_BETWEEN_PROCESS_IMAGE_PARTITIONS_AND_OBS;
}
if(strcmp(value_string, "COMMUNICATION_STATUS_DATA") == 0) {
- return 0x32;
+ return plc4c_s7_read_write_szl_sublist_COMMUNICATION_STATUS_DATA;
}
if(strcmp(value_string, "STATUS_SINGLE_MODULE_LED") == 0) {
- return 0x74;
+ return plc4c_s7_read_write_szl_sublist_STATUS_SINGLE_MODULE_LED;
}
if(strcmp(value_string, "DP_MASTER_SYSTEM_INFORMATION") == 0) {
- return 0x90;
+ return plc4c_s7_read_write_szl_sublist_DP_MASTER_SYSTEM_INFORMATION;
}
if(strcmp(value_string, "MODULE_STATUS_INFORMATION") == 0) {
- return 0x91;
+ return plc4c_s7_read_write_szl_sublist_MODULE_STATUS_INFORMATION;
}
if(strcmp(value_string, "RACK_OR_STATION_STATUS_INFORMATION") == 0) {
- return 0x92;
+ return plc4c_s7_read_write_szl_sublist_RACK_OR_STATION_STATUS_INFORMATION;
}
if(strcmp(value_string, "RACK_OR_STATION_STATUS_INFORMATION_2") == 0) {
- return 0x94;
+ return plc4c_s7_read_write_szl_sublist_RACK_OR_STATION_STATUS_INFORMATION_2;
}
if(strcmp(value_string, "ADDITIONAL_DP_MASTER_SYSTEM_OR_PROFINET_IO_SYSTEM_INFORMATION") == 0) {
- return 0x95;
+ return plc4c_s7_read_write_szl_sublist_ADDITIONAL_DP_MASTER_SYSTEM_OR_PROFINET_IO_SYSTEM_INFORMATION;
}
if(strcmp(value_string, "MODULE_STATUS_INFORMATION_PROFINET_IO_AND_PROFIBUS_DP") == 0) {
- return 0x96;
+ return plc4c_s7_read_write_szl_sublist_MODULE_STATUS_INFORMATION_PROFINET_IO_AND_PROFIBUS_DP;
}
if(strcmp(value_string, "DIAGNOSTIC_BUFFER") == 0) {
- return 0xA0;
+ return plc4c_s7_read_write_szl_sublist_DIAGNOSTIC_BUFFER;
}
if(strcmp(value_string, "MODULE_DIAGNOSTIC_DATA") == 0) {
- return 0xB1;
+ return plc4c_s7_read_write_szl_sublist_MODULE_DIAGNOSTIC_DATA;
}
return -1;
}
@@ -96,61 +96,61 @@ int plc4c_s7_read_write_szl_sublist_num_values() {
plc4c_s7_read_write_szl_sublist plc4c_s7_read_write_szl_sublist_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x11;
+ return plc4c_s7_read_write_szl_sublist_MODULE_IDENTIFICATION;
}
case 1: {
- return 0x12;
+ return plc4c_s7_read_write_szl_sublist_CPU_FEATURES;
}
case 2: {
- return 0x13;
+ return plc4c_s7_read_write_szl_sublist_USER_MEMORY_AREA;
}
case 3: {
- return 0x14;
+ return plc4c_s7_read_write_szl_sublist_SYSTEM_AREAS;
}
case 4: {
- return 0x15;
+ return plc4c_s7_read_write_szl_sublist_BLOCK_TYPES;
}
case 5: {
- return 0x19;
+ return plc4c_s7_read_write_szl_sublist_STATUS_MODULE_LEDS;
}
case 6: {
- return 0x1C;
+ return plc4c_s7_read_write_szl_sublist_COMPONENT_IDENTIFICATION;
}
case 7: {
- return 0x22;
+ return plc4c_s7_read_write_szl_sublist_INTERRUPT_STATUS;
}
case 8: {
- return 0x25;
+ return plc4c_s7_read_write_szl_sublist_ASSIGNMENT_BETWEEN_PROCESS_IMAGE_PARTITIONS_AND_OBS;
}
case 9: {
- return 0x32;
+ return plc4c_s7_read_write_szl_sublist_COMMUNICATION_STATUS_DATA;
}
case 10: {
- return 0x74;
+ return plc4c_s7_read_write_szl_sublist_STATUS_SINGLE_MODULE_LED;
}
case 11: {
- return 0x90;
+ return plc4c_s7_read_write_szl_sublist_DP_MASTER_SYSTEM_INFORMATION;
}
case 12: {
- return 0x91;
+ return plc4c_s7_read_write_szl_sublist_MODULE_STATUS_INFORMATION;
}
case 13: {
- return 0x92;
+ return plc4c_s7_read_write_szl_sublist_RACK_OR_STATION_STATUS_INFORMATION;
}
case 14: {
- return 0x94;
+ return plc4c_s7_read_write_szl_sublist_RACK_OR_STATION_STATUS_INFORMATION_2;
}
case 15: {
- return 0x95;
+ return plc4c_s7_read_write_szl_sublist_ADDITIONAL_DP_MASTER_SYSTEM_OR_PROFINET_IO_SYSTEM_INFORMATION;
}
case 16: {
- return 0x96;
+ return plc4c_s7_read_write_szl_sublist_MODULE_STATUS_INFORMATION_PROFINET_IO_AND_PROFIBUS_DP;
}
case 17: {
- return 0xA0;
+ return plc4c_s7_read_write_szl_sublist_DIAGNOSTIC_BUFFER;
}
case 18: {
- return 0xB1;
+ return plc4c_s7_read_write_szl_sublist_MODULE_DIAGNOSTIC_DATA;
}
default: {
return -1;
diff --git a/sandbox/plc4c/generated-sources/s7/src/transport_size.c b/sandbox/plc4c/generated-sources/s7/src/transport_size.c
index 24505a1..c2e1039 100644
--- a/sandbox/plc4c/generated-sources/s7/src/transport_size.c
+++ b/sandbox/plc4c/generated-sources/s7/src/transport_size.c
@@ -32,52 +32,52 @@ plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_null() {
plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_value_of(char* value_string) {
if(strcmp(value_string, "LWORD") == 0) {
- return 0x00;
+ return plc4c_s7_read_write_transport_size_LWORD;
}
if(strcmp(value_string, "BOOL") == 0) {
- return 0x01;
+ return plc4c_s7_read_write_transport_size_BOOL;
}
if(strcmp(value_string, "BYTE") == 0) {
- return 0x02;
+ return plc4c_s7_read_write_transport_size_BYTE;
}
if(strcmp(value_string, "CHAR") == 0) {
- return 0x03;
+ return plc4c_s7_read_write_transport_size_CHAR;
}
if(strcmp(value_string, "WORD") == 0) {
- return 0x04;
+ return plc4c_s7_read_write_transport_size_WORD;
}
if(strcmp(value_string, "INT") == 0) {
- return 0x05;
+ return plc4c_s7_read_write_transport_size_INT;
}
if(strcmp(value_string, "DWORD") == 0) {
- return 0x06;
+ return plc4c_s7_read_write_transport_size_DWORD;
}
if(strcmp(value_string, "DINT") == 0) {
- return 0x07;
+ return plc4c_s7_read_write_transport_size_DINT;
}
if(strcmp(value_string, "REAL") == 0) {
- return 0x08;
+ return plc4c_s7_read_write_transport_size_REAL;
}
if(strcmp(value_string, "DATE") == 0) {
- return 0x09;
+ return plc4c_s7_read_write_transport_size_DATE;
}
if(strcmp(value_string, "TIME_OF_DAY") == 0) {
- return 0x0A;
+ return plc4c_s7_read_write_transport_size_TIME_OF_DAY;
}
if(strcmp(value_string, "TIME") == 0) {
- return 0x0B;
+ return plc4c_s7_read_write_transport_size_TIME;
}
if(strcmp(value_string, "S5TIME") == 0) {
- return 0x0C;
+ return plc4c_s7_read_write_transport_size_S5TIME;
}
if(strcmp(value_string, "DATE_AND_TIME") == 0) {
- return 0x0F;
+ return plc4c_s7_read_write_transport_size_DATE_AND_TIME;
}
if(strcmp(value_string, "WCHAR") == 0) {
- return 0x13;
+ return plc4c_s7_read_write_transport_size_WCHAR;
}
if(strcmp(value_string, "LREAL") == 0) {
- return 0x30;
+ return plc4c_s7_read_write_transport_size_LREAL;
}
return -1;
}
@@ -89,52 +89,52 @@ int plc4c_s7_read_write_transport_size_num_values() {
plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_value_for_index(int index) {
switch(index) {
case 0: {
- return 0x00;
+ return plc4c_s7_read_write_transport_size_LWORD;
}
case 1: {
- return 0x01;
+ return plc4c_s7_read_write_transport_size_BOOL;
}
case 2: {
- return 0x02;
+ return plc4c_s7_read_write_transport_size_BYTE;
}
case 3: {
- return 0x03;
+ return plc4c_s7_read_write_transport_size_CHAR;
}
case 4: {
- return 0x04;
+ return plc4c_s7_read_write_transport_size_WORD;
}
case 5: {
- return 0x05;
+ return plc4c_s7_read_write_transport_size_INT;
}
case 6: {
- return 0x06;
+ return plc4c_s7_read_write_transport_size_DWORD;
}
case 7: {
- return 0x07;
+ return plc4c_s7_read_write_transport_size_DINT;
}
case 8: {
- return 0x08;
+ return plc4c_s7_read_write_transport_size_REAL;
}
case 9: {
- return 0x09;
+ return plc4c_s7_read_write_transport_size_DATE;
}
case 10: {
- return 0x0A;
+ return plc4c_s7_read_write_transport_size_TIME_OF_DAY;
}
case 11: {
- return 0x0B;
+ return plc4c_s7_read_write_transport_size_TIME;
}
case 12: {
- return 0x0C;
+ return plc4c_s7_read_write_transport_size_S5TIME;
}
case 13: {
- return 0x0F;
+ return plc4c_s7_read_write_transport_size_DATE_AND_TIME;
}
case 14: {
- return 0x13;
+ return plc4c_s7_read_write_transport_size_WCHAR;
}
case 15: {
- return 0x30;
+ return plc4c_s7_read_write_transport_size_LREAL;
}
default: {
return -1;
@@ -144,52 +144,52 @@ plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_value_for_
bool plc4c_s7_read_write_transport_size_get_supported__s7_300(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return false;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return true;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return false;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return false;
}
default: {
@@ -200,52 +200,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__s7_300(plc4c_s7_read_writ
bool plc4c_s7_read_write_transport_size_get_supported__logo(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return false;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return false;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return true;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return false;
}
default: {
@@ -256,52 +256,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__logo(plc4c_s7_read_write_
uint8_t plc4c_s7_read_write_transport_size_get_size_in_bytes(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return 8;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return 1;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return 1;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return 1;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return 2;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return 2;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return 4;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return 4;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return 4;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return 2;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return 4;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return 4;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return 4;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return 12;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return 2;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return 8;
}
default: {
@@ -312,52 +312,52 @@ uint8_t plc4c_s7_read_write_transport_size_get_size_in_bytes(plc4c_s7_read_write
bool plc4c_s7_read_write_transport_size_get_supported__s7_400(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return false;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return true;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return false;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return false;
}
default: {
@@ -368,52 +368,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__s7_400(plc4c_s7_read_writ
bool plc4c_s7_read_write_transport_size_get_supported__s7_1200(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return false;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return false;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return true;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return true;
}
default: {
@@ -424,52 +424,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__s7_1200(plc4c_s7_read_wri
uint8_t plc4c_s7_read_write_transport_size_get_size_code(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return 'X';
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return 'X';
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return 'B';
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return 'B';
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return 'W';
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return 'W';
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return 'D';
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return 'D';
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return 'D';
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return 'X';
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return 'X';
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return 'X';
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return 'X';
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return 'X';
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return 'X';
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return 'X';
}
default: {
@@ -480,52 +480,52 @@ uint8_t plc4c_s7_read_write_transport_size_get_size_code(plc4c_s7_read_write_tra
bool plc4c_s7_read_write_transport_size_get_supported__s7_1500(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return true;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return true;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return true;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return true;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return true;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return true;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return true;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return true;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return true;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return true;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return true;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return true;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return true;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return true;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return true;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return true;
}
default: {
@@ -536,52 +536,52 @@ bool plc4c_s7_read_write_transport_size_get_supported__s7_1500(plc4c_s7_read_wri
plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_transport_size_get_data_transport_size(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return -1;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return plc4c_s7_read_write_data_transport_size_BIT;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return plc4c_s7_read_write_data_transport_size_INTEGER;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return plc4c_s7_read_write_data_transport_size_INTEGER;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return -1;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return -1;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return -1;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return -1;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return -1;
}
default: {
@@ -592,52 +592,52 @@ plc4c_s7_read_write_data_transport_size plc4c_s7_read_write_transport_size_get_d
plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_get_base_type(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return -1;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return -1;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return -1;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return -1;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return -1;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return -1;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return plc4c_s7_read_write_transport_size_WORD;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return plc4c_s7_read_write_transport_size_INT;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return -1;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return -1;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return -1;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return -1;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return -1;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return -1;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return -1;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return plc4c_s7_read_write_transport_size_REAL;
}
default: {
@@ -648,52 +648,52 @@ plc4c_s7_read_write_transport_size plc4c_s7_read_write_transport_size_get_base_t
uint8_t plc4c_s7_read_write_transport_size_get_data_protocol_id(plc4c_s7_read_write_transport_size value) {
switch(value) {
- case 0: { /* '0x00' */
+ case plc4c_s7_read_write_transport_size_LWORD: { /* '0x00' */
return 14;
}
- case 1: { /* '0x01' */
+ case plc4c_s7_read_write_transport_size_BOOL: { /* '0x01' */
return 01;
}
- case 2: { /* '0x02' */
+ case plc4c_s7_read_write_transport_size_BYTE: { /* '0x02' */
return 11;
}
- case 3: { /* '0x03' */
+ case plc4c_s7_read_write_transport_size_CHAR: { /* '0x03' */
return 41;
}
- case 4: { /* '0x04' */
+ case plc4c_s7_read_write_transport_size_WORD: { /* '0x04' */
return 12;
}
- case 5: { /* '0x05' */
+ case plc4c_s7_read_write_transport_size_INT: { /* '0x05' */
return 23;
}
- case 6: { /* '0x06' */
+ case plc4c_s7_read_write_transport_size_DWORD: { /* '0x06' */
return 13;
}
- case 7: { /* '0x07' */
+ case plc4c_s7_read_write_transport_size_DINT: { /* '0x07' */
return 25;
}
- case 8: { /* '0x08' */
+ case plc4c_s7_read_write_transport_size_REAL: { /* '0x08' */
return 31;
}
- case 9: { /* '0x09' */
+ case plc4c_s7_read_write_transport_size_DATE: { /* '0x09' */
return 54;
}
- case 10: { /* '0x0A' */
+ case plc4c_s7_read_write_transport_size_TIME_OF_DAY: { /* '0x0A' */
return 55;
}
- case 11: { /* '0x0B' */
+ case plc4c_s7_read_write_transport_size_TIME: { /* '0x0B' */
return 51;
}
- case 12: { /* '0x0C' */
+ case plc4c_s7_read_write_transport_size_S5TIME: { /* '0x0C' */
return 52;
}
- case 15: { /* '0x0F' */
+ case plc4c_s7_read_write_transport_size_DATE_AND_TIME: { /* '0x0F' */
return 56;
}
- case 19: { /* '0x13' */
+ case plc4c_s7_read_write_transport_size_WCHAR: { /* '0x13' */
return 42;
}
- case 48: { /* '0x30' */
+ case plc4c_s7_read_write_transport_size_LREAL: { /* '0x30' */
return 32;
}
default: {
[plc4x] 01/02: - Renamed the method to get an enum constant from a
value from valueOf to enumForValue as for string based enums this was
causing problems as enums always automatically have valueOf(String) methods
Posted by cd...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch feature/plc4go
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit 1dec03b5b516c19958ec4a3b077f237eaf661e14
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Thu Oct 22 23:16:33 2020 +0200
- Renamed the method to get an enum constant from a value from valueOf to enumForValue as for string based enums this was causing problems as enums always automatically have valueOf(String) methods
---
.../src/main/resources/templates/java/enum-template.ftlh | 4 ++--
.../src/main/resources/templates/java/io-template.ftlh | 2 +-
.../org/apache/plc4x/java/ads/protocol/AdsProtocolLogic.java | 4 ++--
.../java/org/apache/plc4x/java/modbus/field/ModbusField.java | 2 +-
.../plc4x/java/modbus/protocol/ModbusProtocolLogic.java | 12 ++++++------
.../plc4x/java/s7/readwrite/utils/S7TsapIdEncoder.java | 2 +-
6 files changed, 13 insertions(+), 13 deletions(-)
diff --git a/build-utils/language-java/src/main/resources/templates/java/enum-template.ftlh b/build-utils/language-java/src/main/resources/templates/java/enum-template.ftlh
index 6ebc76f..d77e7c8 100644
--- a/build-utils/language-java/src/main/resources/templates/java/enum-template.ftlh
+++ b/build-utils/language-java/src/main/resources/templates/java/enum-template.ftlh
@@ -57,7 +57,7 @@ import java.util.Map;
public enum ${type.name} {
<#list type.enumValues as enumValue>
- ${enumValue.name}(<#if type.type?has_content>(${helper.getLanguageTypeNameForTypeReference(type.type, true)}) ${enumValue.value}</#if><#if type.constantNames?has_content><#if type.type?has_content>, </#if><#list type.constantNames as constantName>(${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true)}) ${helper.escapeValue(type.getConstantType(constantName), enumValue.getConstant(constantName))}<#sep>, </#sep></#list></#if>)<#sep>,
+ ${enumValue.name}(<#if type.type?has_content>(${helper.getLanguageTypeNameForTypeReference(type.type, true)}) <#if helper.isStringTypeReference(type.type)>"${enumValue.value}"<#else>${enumValue.value}</#if></#if><#if type.constantNames?has_content><#if type.type?has_content>, </#if><#list type.constantNames as constantName>(${helper.getLanguageTypeNameForTypeReference(type.getConstantType(constantName), true)}) ${helper.escapeValue(type.getConstantType(constantName), enumValue.getCon [...]
</#sep></#list>;
<#if type.type?has_content>
@@ -103,7 +103,7 @@ public enum ${type.name} {
</#list>
</#if>
<#if type.type?has_content>
- public static ${type.name} valueOf(${helper.getLanguageTypeNameForTypeReference(type.type, true)} value) {
+ public static ${type.name} enumForValue(${helper.getLanguageTypeNameForTypeReference(type.type, true)} value) {
if (!map.containsKey(value)) {
logger.error("No ${type.name} for value {}", value);
}
diff --git a/build-utils/language-java/src/main/resources/templates/java/io-template.ftlh b/build-utils/language-java/src/main/resources/templates/java/io-template.ftlh
index 5b00414..a29c531 100644
--- a/build-utils/language-java/src/main/resources/templates/java/io-template.ftlh
+++ b/build-utils/language-java/src/main/resources/templates/java/io-template.ftlh
@@ -246,7 +246,7 @@ public class ${type.name}IO implements <#if outputFlavor != "passive">MessageIO<
<#assign enumField = field>
// Enum field (${enumField.name})
- ${helper.getLanguageTypeNameForField(field)} ${enumField.name} = ${helper.getLanguageTypeNameForField(field)}.valueOf(${helper.getReadBufferReadMethodCall(helper.getEnumBaseTypeReference(enumField.type))});
+ ${helper.getLanguageTypeNameForField(field)} ${enumField.name} = ${helper.getLanguageTypeNameForField(field)}.enumForValue(${helper.getReadBufferReadMethodCall(helper.getEnumBaseTypeReference(enumField.type))});
<#break>
<#case "implicit">
<#assign implicitField = field>
diff --git a/plc4j/drivers/ads/src/main/java/org/apache/plc4x/java/ads/protocol/AdsProtocolLogic.java b/plc4j/drivers/ads/src/main/java/org/apache/plc4x/java/ads/protocol/AdsProtocolLogic.java
index 69a00ec..a9a1d8c 100644
--- a/plc4j/drivers/ads/src/main/java/org/apache/plc4x/java/ads/protocol/AdsProtocolLogic.java
+++ b/plc4j/drivers/ads/src/main/java/org/apache/plc4x/java/ads/protocol/AdsProtocolLogic.java
@@ -265,7 +265,7 @@ public class AdsProtocolLogic extends Plc4xProtocolBase<AmsTCPPacket> implements
// in sequence and then come the values.
for (String fieldName : readRequest.getFieldNames()) {
try {
- final ReturnCode result = ReturnCode.valueOf(readBuffer.readUnsignedLong(32));
+ final ReturnCode result = ReturnCode.enumForValue(readBuffer.readUnsignedLong(32));
responseCodes.put(fieldName, parsePlcResponseCode(result));
} catch (ParseException e) {
responseCodes.put(fieldName, PlcResponseCode.INTERNAL_ERROR);
@@ -494,7 +494,7 @@ public class AdsProtocolLogic extends Plc4xProtocolBase<AmsTCPPacket> implements
// in sequence and then come the values.
for (String fieldName : writeRequest.getFieldNames()) {
try {
- final ReturnCode result = ReturnCode.valueOf(readBuffer.readUnsignedLong(32));
+ final ReturnCode result = ReturnCode.enumForValue(readBuffer.readUnsignedLong(32));
responseCodes.put(fieldName, parsePlcResponseCode(result));
} catch (ParseException e) {
responseCodes.put(fieldName, PlcResponseCode.INTERNAL_ERROR);
diff --git a/plc4j/drivers/modbus/src/main/java/org/apache/plc4x/java/modbus/field/ModbusField.java b/plc4j/drivers/modbus/src/main/java/org/apache/plc4x/java/modbus/field/ModbusField.java
index 641296e..9a47936 100644
--- a/plc4j/drivers/modbus/src/main/java/org/apache/plc4x/java/modbus/field/ModbusField.java
+++ b/plc4j/drivers/modbus/src/main/java/org/apache/plc4x/java/modbus/field/ModbusField.java
@@ -67,7 +67,7 @@ public abstract class ModbusField implements PlcField {
throw new IllegalArgumentException("quantity must be greater then zero. Was " + this.quantity);
}
this.dataType = dataType != null ? dataType : "INT";
- ModbusDataType.valueOf(this.dataType);
+ ModbusDataTypeSizes.valueOf(this.dataType);
}
public int getAddress() {
diff --git a/plc4j/drivers/modbus/src/main/java/org/apache/plc4x/java/modbus/protocol/ModbusProtocolLogic.java b/plc4j/drivers/modbus/src/main/java/org/apache/plc4x/java/modbus/protocol/ModbusProtocolLogic.java
index 6b4f4ce..9df1bac 100644
--- a/plc4j/drivers/modbus/src/main/java/org/apache/plc4x/java/modbus/protocol/ModbusProtocolLogic.java
+++ b/plc4j/drivers/modbus/src/main/java/org/apache/plc4x/java/modbus/protocol/ModbusProtocolLogic.java
@@ -363,7 +363,7 @@ public class ModbusProtocolLogic extends Plc4xProtocolBase<ModbusTcpADU> impleme
ModbusPDUReadInputRegistersRequest req = (ModbusPDUReadInputRegistersRequest) request;
ModbusPDUReadInputRegistersResponse resp = (ModbusPDUReadInputRegistersResponse) response;
ReadBuffer io = new ReadBuffer(resp.getValue());
- return DataItemIO.staticParse(io, dataType, (short) Math.round(req.getQuantity()/(fieldDataTypeSize/2.0f)));
+ return DataItemIO.staticParse(io, dataType, Math.round(req.getQuantity()/(fieldDataTypeSize/2.0f)));
} else if (request instanceof ModbusPDUReadHoldingRegistersRequest) {
if (!(response instanceof ModbusPDUReadHoldingRegistersResponse)) {
throw new PlcRuntimeException("Unexpected response type. " +
@@ -372,7 +372,7 @@ public class ModbusProtocolLogic extends Plc4xProtocolBase<ModbusTcpADU> impleme
ModbusPDUReadHoldingRegistersRequest req = (ModbusPDUReadHoldingRegistersRequest) request;
ModbusPDUReadHoldingRegistersResponse resp = (ModbusPDUReadHoldingRegistersResponse) response;
ReadBuffer io = new ReadBuffer(resp.getValue());
- return DataItemIO.staticParse(io, dataType, (short) Math.round(req.getQuantity()/(fieldDataTypeSize/2.0f)));
+ return DataItemIO.staticParse(io, dataType, Math.round(req.getQuantity()/(fieldDataTypeSize/2.0f)));
} else if (request instanceof ModbusPDUReadFileRecordRequest) {
if (!(response instanceof ModbusPDUReadFileRecordResponse)) {
throw new PlcRuntimeException("Unexpected response type. " +
@@ -396,7 +396,7 @@ public class ModbusProtocolLogic extends Plc4xProtocolBase<ModbusTcpADU> impleme
"Expected " + req.getItems().length + ", but got " + resp.getItems().length);
}
- return DataItemIO.staticParse(io, dataType, (short) Math.round((dataLength/2.0f)/(fieldDataTypeSize/2.0f)));
+ return DataItemIO.staticParse(io, dataType, Math.round((dataLength/2.0f)/(fieldDataTypeSize/2.0f)));
}
return null;
}
@@ -406,7 +406,7 @@ public class ModbusProtocolLogic extends Plc4xProtocolBase<ModbusTcpADU> impleme
try {
WriteBuffer buffer;
if(plcValue instanceof PlcList) {
- buffer = DataItemIO.staticSerialize(plcValue, fieldDataType, (short) ((PlcList) plcValue).getLength(), false);
+ buffer = DataItemIO.staticSerialize(plcValue, fieldDataType, plcValue.getLength(), false);
byte[] data = buffer.getData();
switch (((ModbusField) field).getDataType()) {
case "BOOL":
@@ -421,7 +421,7 @@ public class ModbusProtocolLogic extends Plc4xProtocolBase<ModbusTcpADU> impleme
return data;
}
} else {
- buffer = DataItemIO.staticSerialize(plcValue, fieldDataType, (short) 1, false);
+ buffer = DataItemIO.staticSerialize(plcValue, fieldDataType, 1, false);
if (buffer != null) {
return buffer.getData();
} else {
@@ -446,7 +446,7 @@ public class ModbusProtocolLogic extends Plc4xProtocolBase<ModbusTcpADU> impleme
private PlcValue readBooleanList(int count, byte[] data) throws ParseException {
ReadBuffer io = new ReadBuffer(data);
if(count == 1) {
- return DataItemIO.staticParse(io, "IEC61131_BOOL", (short) 1);
+ return DataItemIO.staticParse(io, "IEC61131_BOOL", 1);
}
// Make sure we read in all the bytes. Unfortunately when requesting 9 bytes
// they are ordered like this: 8 7 6 5 4 3 2 1 | 0 0 0 0 0 0 0 9
diff --git a/plc4j/drivers/s7/src/main/java/org/apache/plc4x/java/s7/readwrite/utils/S7TsapIdEncoder.java b/plc4j/drivers/s7/src/main/java/org/apache/plc4x/java/s7/readwrite/utils/S7TsapIdEncoder.java
index edd8b3c..5204bdf 100644
--- a/plc4j/drivers/s7/src/main/java/org/apache/plc4x/java/s7/readwrite/utils/S7TsapIdEncoder.java
+++ b/plc4j/drivers/s7/src/main/java/org/apache/plc4x/java/s7/readwrite/utils/S7TsapIdEncoder.java
@@ -34,7 +34,7 @@ public class S7TsapIdEncoder {
public static DeviceGroup decodeDeviceGroup(short tsapId) {
byte deviceGroupCode = (byte) ((tsapId >> 8) & (0xFF));
- return DeviceGroup.valueOf(deviceGroupCode);
+ return DeviceGroup.enumForValue(deviceGroupCode);
}
public static int decodeRack(short tsapId) {