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/08/25 15:20:42 UTC
[plc4x] branch feature/plc4c updated: - Implemented the skeleton
for the modbus driver. - Resolved some naming conflicts.
This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch feature/plc4c
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/feature/plc4c by this push:
new df4d588 - Implemented the skeleton for the modbus driver. - Resolved some naming conflicts.
df4d588 is described below
commit df4d58898c5f84918a03ffdda173a50551a5ff90
Author: Christofer Dutz <ch...@c-ware.de>
AuthorDate: Tue Aug 25 17:20:34 2020 +0200
- Implemented the skeleton for the modbus driver.
- Resolved some naming conflicts.
---
.../java/modbus/protocol/ModbusProtocolLogic.java | 4 +-
.../connectionpool/PooledPlcDriverManager.java | 2 +-
sandbox/plc4c/drivers/modbus/CMakeLists.txt | 1 +
.../modbus/include/plc4c/driver_modbus_packets.h | 17 +++
.../drivers/modbus/src/driver_modbus_packets.c | 117 +++++++++++++++++++++
.../drivers/modbus/src/driver_modbus_sm_read.c | 56 ++++++++++
.../drivers/modbus/src/driver_modbus_sm_write.c | 56 ++++++++++
.../drivers/s7/include/plc4c/driver_s7_packets.h | 8 +-
sandbox/plc4c/drivers/s7/src/driver_s7_packets.c | 4 +-
.../plc4c/drivers/s7/src/driver_s7_sm_connect.c | 12 +--
sandbox/plc4c/drivers/s7/src/driver_s7_sm_read.c | 6 +-
sandbox/plc4c/drivers/s7/src/driver_s7_sm_write.c | 6 +-
sandbox/plc4c/drivers/s7/test/s7_test.c | 2 +-
sandbox/plc4c/spi/src/evaluation_helper.c | 4 +
14 files changed, 271 insertions(+), 24 deletions(-)
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 6bf8184..b08698a 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
@@ -233,12 +233,12 @@ public class ModbusProtocolLogic extends Plc4xProtocolBase<ModbusTcpADU> impleme
ModbusPDUReadFileRecordRequestItem[] itemArray;
if ((group1_address + extendedRegister.getQuantity()) < FC_EXTENDED_REGISTERS_FILE_RECORD_LENGTH) {
- //If reuqest doesn't span file records, use a single group
+ //If request doesn't span file records, use a single group
group1_quantity = extendedRegister.getQuantity();
ModbusPDUReadFileRecordRequestItem group1 = new ModbusPDUReadFileRecordRequestItem((short) 6, group1_file_number, group1_address, group1_quantity);
itemArray = new ModbusPDUReadFileRecordRequestItem[] {group1};
} else {
- //If it doesn span a file record. e.g. 609998[10] request 2 words in first group and 8 in second.
+ //If it doesn't span a file record. e.g. 609998[10] request 2 words in first group and 8 in second.
group1_quantity = FC_EXTENDED_REGISTERS_FILE_RECORD_LENGTH - group1_address;
group2_quantity = extendedRegister.getQuantity() - group1_quantity;
group2_file_number = (short) (group1_file_number + 1);
diff --git a/plc4j/tools/connection-pool/src/main/java/org/apache/plc4x/java/utils/connectionpool/PooledPlcDriverManager.java b/plc4j/tools/connection-pool/src/main/java/org/apache/plc4x/java/utils/connectionpool/PooledPlcDriverManager.java
index a88794f..343f805 100644
--- a/plc4j/tools/connection-pool/src/main/java/org/apache/plc4x/java/utils/connectionpool/PooledPlcDriverManager.java
+++ b/plc4j/tools/connection-pool/src/main/java/org/apache/plc4x/java/utils/connectionpool/PooledPlcDriverManager.java
@@ -146,7 +146,7 @@ public class PooledPlcDriverManager extends PlcDriverManager {
KeyedObjectPool<PoolKey, PlcConnection> createPool(PooledPlcConnectionFactory pooledPlcConnectionFactory);
}
- // TODO: maybe export to jmx // generic poolKey has builting jmx too
+ // TODO: maybe export to jmx // generic poolKey has builtin jmx too
public Map<String, Number> getStatistics() {
HashMap<String, Number> statistics = new HashMap<>();
statistics.put("numActive", keyedObjectPool.getNumActive());
diff --git a/sandbox/plc4c/drivers/modbus/CMakeLists.txt b/sandbox/plc4c/drivers/modbus/CMakeLists.txt
index fd1ff88..db9800d 100644
--- a/sandbox/plc4c/drivers/modbus/CMakeLists.txt
+++ b/sandbox/plc4c/drivers/modbus/CMakeLists.txt
@@ -25,6 +25,7 @@ file(GLOB generatedSources "${PLC4C_ROOT_DIR}/generated-sources/modbus/src/*.c")
add_library(plc4c-driver-modbus
src/driver_modbus.c
+ src/driver_modbus_packets.c
src/driver_modbus_sm_connect.c
src/driver_modbus_sm_disconnect.c
src/driver_modbus_sm_read.c
diff --git a/sandbox/plc4c/drivers/modbus/include/plc4c/driver_modbus_packets.h b/sandbox/plc4c/drivers/modbus/include/plc4c/driver_modbus_packets.h
index de90b75..d42a819 100644
--- a/sandbox/plc4c/drivers/modbus/include/plc4c/driver_modbus_packets.h
+++ b/sandbox/plc4c/drivers/modbus/include/plc4c/driver_modbus_packets.h
@@ -22,6 +22,23 @@
extern "C" {
#endif
+#include <plc4c/types.h>
+#include "modbus_tcp_adu.h"
+
+plc4c_return_code plc4c_driver_modbus_send_packet(
+ plc4c_connection* connection,
+ plc4c_modbus_read_write_modbus_tcp_adu* packet);
+plc4c_return_code plc4c_driver_modbus_receive_packet(
+ plc4c_connection* connection,
+ plc4c_modbus_read_write_modbus_tcp_adu** packet);
+
+plc4c_return_code createModbusReadRequest(
+ plc4c_read_request* read_request,
+ plc4c_modbus_read_write_modbus_tcp_adu** modbus_read_request_packet);
+plc4c_return_code createModbusWriteRequest(
+ plc4c_write_request* write_request,
+ plc4c_modbus_read_write_modbus_tcp_adu** modbus_read_request_packet);
+
#ifdef __cplusplus
}
#endif
diff --git a/sandbox/plc4c/drivers/modbus/src/driver_modbus_packets.c b/sandbox/plc4c/drivers/modbus/src/driver_modbus_packets.c
new file mode 100644
index 0000000..6407d95
--- /dev/null
+++ b/sandbox/plc4c/drivers/modbus/src/driver_modbus_packets.c
@@ -0,0 +1,117 @@
+/*
+ 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 <ctype.h>
+#include <plc4c/spi/types_private.h>
+#include <stdlib.h>
+#include <string.h>
+#include "plc4c/driver_modbus.h"
+#include "modbus_tcp_adu.h"
+
+/**
+ * Function used by the driver to tell the transport if there is a full
+ * packet the driver can operate on available.
+ *
+ * @param buffer_data pointer to the buffer
+ * @param buffer_length length of the buffer
+ * @return positive integer = length of the packet, 0 = not enough,
+ * try again later, negative integer = remove the given amount of bytes
+ * from the buffer.
+ */
+int16_t plc4c_driver_modbus_select_message_function(uint8_t* buffer_data,
+ uint16_t buffer_length) {
+ // The length information is located in bytes 5 and 6
+ if (buffer_length >= 6) {
+ uint16_t packet_length =
+ ((uint16_t) (buffer_data + 4) << 8) |
+ ((uint16_t) (buffer_data + 5));
+ packet_length += 6;
+ if (buffer_length >= packet_length) {
+ return packet_length;
+ }
+ }
+ // In all other cases, we'll just have to wait for the next time.
+ return 0;
+}
+
+plc4c_return_code plc4c_driver_modbus_send_packet(plc4c_connection* connection,
+ plc4c_modbus_read_write_modbus_tcp_adu* packet) {
+ // Get the size required to contain the serialized form of this packet.
+ uint16_t packet_size =
+ plc4c_modbus_read_write_modbus_tcp_adu_length_in_bytes(packet);
+
+ // Serialize this message to a byte-array.
+ plc4c_spi_write_buffer* write_buffer;
+ plc4c_return_code return_code =
+ plc4c_spi_write_buffer_create(packet_size, &write_buffer);
+ if (return_code != OK) {
+ return return_code;
+ }
+ plc4c_modbus_read_write_modbus_tcp_adu_serialize(write_buffer, packet);
+
+ // Now send this to the recipient.
+ return_code = connection->transport->send_message(write_buffer);
+ if (return_code != OK) {
+ return return_code;
+ }
+
+ return OK;
+}
+
+plc4c_return_code plc4c_driver_modbus_receive_packet(plc4c_connection* connection,
+ plc4c_modbus_read_write_modbus_tcp_adu** packet) {
+ // Check with the transport if there is a packet available.
+ // If it is, get a read_buffer for reading it.
+ plc4c_spi_read_buffer* read_buffer;
+ plc4c_return_code return_code = connection->transport->select_message(
+ plc4c_driver_modbus_select_message_function, &read_buffer);
+ // OK is only returned if a packet is available.
+ if (return_code != OK) {
+ return return_code;
+ }
+
+ // Parse the packet by consuming the read_buffer data.
+ *packet = NULL;
+ return_code = plc4c_modbus_read_write_modbus_tcp_adu_parse(read_buffer, true, packet);
+ if (return_code != OK) {
+ return return_code;
+ }
+
+ // In this case a packet was available and parsed.
+ return OK;
+}
+
+plc4c_return_code createModbusReadRequest(
+ plc4c_read_request* read_request,
+ plc4c_modbus_read_write_modbus_tcp_adu** modbus_read_request_packet) {
+
+ // TODO: Implement this ...
+
+ return OK;
+}
+
+plc4c_return_code createModbusWriteRequest(
+ plc4c_write_request* write_request,
+ plc4c_modbus_read_write_modbus_tcp_adu** modbus_read_request_packet) {
+
+ // TODO: Implement this ...
+
+ return OK;
+}
+
diff --git a/sandbox/plc4c/drivers/modbus/src/driver_modbus_sm_read.c b/sandbox/plc4c/drivers/modbus/src/driver_modbus_sm_read.c
index 2ff6fb3..9ed5f46 100644
--- a/sandbox/plc4c/drivers/modbus/src/driver_modbus_sm_read.c
+++ b/sandbox/plc4c/drivers/modbus/src/driver_modbus_sm_read.c
@@ -21,6 +21,8 @@
#include <plc4c/spi/types_private.h>
#include <stdlib.h>
#include <string.h>
+#include "plc4c/driver_modbus_packets.h"
+#include "modbus_tcp_adu.h"
enum plc4c_driver_modbus_read_states {
PLC4C_DRIVER_MODBUS_READ_INIT,
@@ -29,7 +31,61 @@ enum plc4c_driver_modbus_read_states {
plc4c_return_code plc4c_driver_modbus_read_machine_function(
plc4c_system_task* task) {
+ plc4c_read_request_execution* read_request_execution = task->context;
+ if (read_request_execution == NULL) {
+ return INTERNAL_ERROR;
+ }
+ plc4c_read_request* read_request = read_request_execution->read_request;
+ if (read_request == NULL) {
+ return INTERNAL_ERROR;
+ }
+ plc4c_connection* connection = task->context;
+ if (connection == NULL) {
+ return INTERNAL_ERROR;
+ }
+ switch (task->state_id) {
+ case PLC4C_DRIVER_MODBUS_READ_INIT: {
+ plc4c_modbus_read_write_modbus_tcp_adu* modbus_read_request_packet;
+ plc4c_return_code return_code =
+ createModbusReadRequest(read_request, &modbus_read_request_packet);
+ if (return_code != OK) {
+ return return_code;
+ }
+
+ // Send the packet to the remote.
+ return_code = plc4c_driver_modbus_send_packet(
+ connection, modbus_read_request_packet);
+ if (return_code != OK) {
+ return return_code;
+ }
+
+ task->state_id = PLC4C_DRIVER_MODBUS_READ_FINISHED;
+ break;
+ }
+ case PLC4C_DRIVER_MODBUS_READ_FINISHED: {
+ // Read a response packet.
+ plc4c_modbus_read_write_modbus_tcp_adu* modbus_read_response_packet;
+ plc4c_return_code return_code =
+ plc4c_driver_modbus_receive_packet(
+ connection, &modbus_read_response_packet);
+ // If we haven't read enough to process a full message, just try again
+ // next time.
+ if (return_code == UNFINISHED) {
+ return OK;
+ } else if (return_code != OK) {
+ return return_code;
+ }
+
+ // TODO: Check the response ...
+ // TODO: Decode the items in the response ...
+ // TODO: Return the results to the API ...
+
+ task->completed = true;
+ break;
+ }
+ }
+ return OK;
}
plc4c_return_code plc4c_driver_modbus_read_function(
diff --git a/sandbox/plc4c/drivers/modbus/src/driver_modbus_sm_write.c b/sandbox/plc4c/drivers/modbus/src/driver_modbus_sm_write.c
index 4ed3da9..bd01902 100644
--- a/sandbox/plc4c/drivers/modbus/src/driver_modbus_sm_write.c
+++ b/sandbox/plc4c/drivers/modbus/src/driver_modbus_sm_write.c
@@ -21,6 +21,8 @@
#include <plc4c/spi/types_private.h>
#include <stdlib.h>
#include <string.h>
+#include "plc4c/driver_modbus_packets.h"
+#include "modbus_tcp_adu.h"
enum plc4c_driver_modbus_write_states {
PLC4C_DRIVER_MODBUS_WRITE_INIT,
@@ -29,7 +31,61 @@ enum plc4c_driver_modbus_write_states {
plc4c_return_code plc4c_driver_modbus_write_machine_function(
plc4c_system_task* task) {
+ plc4c_write_request_execution* write_request_execution = task->context;
+ if (write_request_execution == NULL) {
+ return INTERNAL_ERROR;
+ }
+ plc4c_write_request* write_request = write_request_execution->write_request;
+ if (write_request == NULL) {
+ return INTERNAL_ERROR;
+ }
+ plc4c_connection* connection = task->context;
+ if (connection == NULL) {
+ return INTERNAL_ERROR;
+ }
+ switch (task->state_id) {
+ case PLC4C_DRIVER_MODBUS_WRITE_INIT: {
+ plc4c_modbus_read_write_modbus_tcp_adu* modbus_write_request_packet;
+ plc4c_return_code return_code =
+ createModbusWriteRequest(write_request, &modbus_write_request_packet);
+ if (return_code != OK) {
+ return return_code;
+ }
+
+ // Send the packet to the remote.
+ return_code = plc4c_driver_modbus_send_packet(
+ connection, modbus_write_request_packet);
+ if (return_code != OK) {
+ return return_code;
+ }
+
+ task->state_id = PLC4C_DRIVER_MODBUS_WRITE_FINISHED;
+ break;
+ }
+ case PLC4C_DRIVER_MODBUS_WRITE_FINISHED: {
+ // Read a response packet.
+ plc4c_modbus_read_write_modbus_tcp_adu* modbus_write_response_packet;
+ plc4c_return_code return_code =
+ plc4c_driver_modbus_receive_packet(
+ connection, &modbus_write_response_packet);
+ // If we haven't read enough to process a full message, just try again
+ // next time.
+ if (return_code == UNFINISHED) {
+ return OK;
+ } else if (return_code != OK) {
+ return return_code;
+ }
+
+ // TODO: Check the response ...
+ // TODO: Decode the return codes in the response ...
+ // TODO: Return the results to the API ...
+
+ task->completed = true;
+ break;
+ }
+ }
+ return OK;
}
plc4c_return_code plc4c_driver_modbus_write_function(
diff --git a/sandbox/plc4c/drivers/s7/include/plc4c/driver_s7_packets.h b/sandbox/plc4c/drivers/s7/include/plc4c/driver_s7_packets.h
index 587c75a..f8bf4b6 100644
--- a/sandbox/plc4c/drivers/s7/include/plc4c/driver_s7_packets.h
+++ b/sandbox/plc4c/drivers/s7/include/plc4c/driver_s7_packets.h
@@ -27,10 +27,10 @@ extern "C" {
#include "tpkt_packet.h"
#include "plc4c/driver_s7.h"
-plc4c_return_code send_packet(plc4c_connection* connection,
- plc4c_s7_read_write_tpkt_packet* packet);
-plc4c_return_code receive_packet(plc4c_connection* connection,
- plc4c_s7_read_write_tpkt_packet** packet);
+plc4c_return_code plc4c_driver_s7_send_packet(
+ plc4c_connection* connection, plc4c_s7_read_write_tpkt_packet* packet);
+plc4c_return_code plc4c_driver_s7_receive_packet(
+ plc4c_connection* connection, plc4c_s7_read_write_tpkt_packet** packet);
plc4c_return_code createCOTPConnectionRequest(
plc4c_driver_s7_config* configuration,
diff --git a/sandbox/plc4c/drivers/s7/src/driver_s7_packets.c b/sandbox/plc4c/drivers/s7/src/driver_s7_packets.c
index 7d3bcd1..dbc2e93 100644
--- a/sandbox/plc4c/drivers/s7/src/driver_s7_packets.c
+++ b/sandbox/plc4c/drivers/s7/src/driver_s7_packets.c
@@ -84,7 +84,7 @@ int16_t plc4c_driver_s7_select_message_function(uint8_t* buffer_data,
return 0;
}
-plc4c_return_code send_packet(plc4c_connection* connection,
+plc4c_return_code plc4c_driver_s7_send_packet(plc4c_connection* connection,
plc4c_s7_read_write_tpkt_packet* packet) {
// Get the size required to contain the serialized form of this packet.
uint16_t packet_size =
@@ -108,7 +108,7 @@ plc4c_return_code send_packet(plc4c_connection* connection,
return OK;
}
-plc4c_return_code receive_packet(plc4c_connection* connection,
+plc4c_return_code plc4c_driver_s7_receive_packet(plc4c_connection* connection,
plc4c_s7_read_write_tpkt_packet** packet) {
// Check with the transport if there is a packet available.
// If it is, get a read_buffer for reading it.
diff --git a/sandbox/plc4c/drivers/s7/src/driver_s7_sm_connect.c b/sandbox/plc4c/drivers/s7/src/driver_s7_sm_connect.c
index 4fe2b63..551f985 100644
--- a/sandbox/plc4c/drivers/s7/src/driver_s7_sm_connect.c
+++ b/sandbox/plc4c/drivers/s7/src/driver_s7_sm_connect.c
@@ -89,7 +89,7 @@ plc4c_return_code plc4c_driver_s7_connect_machine_function(
}
// Send the packet to the remote.
- return_code = send_packet(connection, cotp_connect_request_packet);
+ return_code = plc4c_driver_s7_send_packet(connection, cotp_connect_request_packet);
if (return_code != OK) {
return return_code;
}
@@ -102,7 +102,7 @@ plc4c_return_code plc4c_driver_s7_connect_machine_function(
// Read a response packet.
plc4c_s7_read_write_tpkt_packet* cotp_connect_response_packet;
plc4c_return_code return_code =
- receive_packet(connection, &cotp_connect_response_packet);
+ plc4c_driver_s7_receive_packet(connection, &cotp_connect_response_packet);
// If we haven't read enough to process a full message, just try again
// next time.
if (return_code == UNFINISHED) {
@@ -162,7 +162,7 @@ plc4c_return_code plc4c_driver_s7_connect_machine_function(
}
// Send the packet to the remote.
- return_code = send_packet(connection, s7_connect_request_packet);
+ return_code = plc4c_driver_s7_send_packet(connection, s7_connect_request_packet);
if (return_code != OK) {
return return_code;
}
@@ -175,7 +175,7 @@ plc4c_return_code plc4c_driver_s7_connect_machine_function(
// Read a response packet.
plc4c_s7_read_write_tpkt_packet* s7_connect_response_packet;
plc4c_return_code return_code =
- receive_packet(connection, &s7_connect_response_packet);
+ plc4c_driver_s7_receive_packet(connection, &s7_connect_response_packet);
// If we haven't read enough to process a full message, just try again
// next time.
if (return_code == UNFINISHED) {
@@ -231,7 +231,7 @@ plc4c_return_code plc4c_driver_s7_connect_machine_function(
}
// Send the packet to the remote.
- return_code = send_packet(connection, s7_identify_remote_request_packet);
+ return_code = plc4c_driver_s7_send_packet(connection, s7_identify_remote_request_packet);
if (return_code != OK) {
return return_code;
}
@@ -245,7 +245,7 @@ plc4c_return_code plc4c_driver_s7_connect_machine_function(
// Read a response packet.
plc4c_s7_read_write_tpkt_packet* s7_identify_remote_response_packet;
plc4c_return_code return_code =
- receive_packet(connection, &s7_identify_remote_response_packet);
+ plc4c_driver_s7_receive_packet(connection, &s7_identify_remote_response_packet);
// If we haven't read enough to process a full message, just try again
// next time.
if (return_code == UNFINISHED) {
diff --git a/sandbox/plc4c/drivers/s7/src/driver_s7_sm_read.c b/sandbox/plc4c/drivers/s7/src/driver_s7_sm_read.c
index 7dda6f1..5e00a4b 100644
--- a/sandbox/plc4c/drivers/s7/src/driver_s7_sm_read.c
+++ b/sandbox/plc4c/drivers/s7/src/driver_s7_sm_read.c
@@ -50,8 +50,6 @@ plc4c_return_code plc4c_driver_s7_read_machine_function(
switch (task->state_id) {
case PLC4C_DRIVER_S7_READ_INIT: {
- task->completed = true;
-
plc4c_s7_read_write_tpkt_packet* s7_read_request_packet;
plc4c_return_code return_code =
createS7ReadRequest(read_request, &s7_read_request_packet);
@@ -60,7 +58,7 @@ plc4c_return_code plc4c_driver_s7_read_machine_function(
}
// Send the packet to the remote.
- return_code = send_packet(connection, s7_read_request_packet);
+ return_code = plc4c_driver_s7_send_packet(connection, s7_read_request_packet);
if (return_code != OK) {
return return_code;
}
@@ -72,7 +70,7 @@ plc4c_return_code plc4c_driver_s7_read_machine_function(
// Read a response packet.
plc4c_s7_read_write_tpkt_packet* s7_read_response_packet;
plc4c_return_code return_code =
- receive_packet(connection, &s7_read_response_packet);
+ plc4c_driver_s7_receive_packet(connection, &s7_read_response_packet);
// If we haven't read enough to process a full message, just try again
// next time.
if (return_code == UNFINISHED) {
diff --git a/sandbox/plc4c/drivers/s7/src/driver_s7_sm_write.c b/sandbox/plc4c/drivers/s7/src/driver_s7_sm_write.c
index 1630edf..59a1a92 100644
--- a/sandbox/plc4c/drivers/s7/src/driver_s7_sm_write.c
+++ b/sandbox/plc4c/drivers/s7/src/driver_s7_sm_write.c
@@ -50,8 +50,6 @@ plc4c_return_code plc4c_driver_s7_write_machine_function(
switch (task->state_id) {
case PLC4C_DRIVER_S7_WRITE_INIT: {
- task->completed = true;
-
plc4c_s7_read_write_tpkt_packet* s7_write_request_packet;
plc4c_return_code return_code =
createS7WriteRequest(write_request, &s7_write_request_packet);
@@ -60,7 +58,7 @@ plc4c_return_code plc4c_driver_s7_write_machine_function(
}
// Send the packet to the remote.
- return_code = send_packet(connection, s7_write_request_packet);
+ return_code = plc4c_driver_s7_send_packet(connection, s7_write_request_packet);
if (return_code != OK) {
return return_code;
}
@@ -72,7 +70,7 @@ plc4c_return_code plc4c_driver_s7_write_machine_function(
// Read a response packet.
plc4c_s7_read_write_tpkt_packet* s7_write_response_packet;
plc4c_return_code return_code =
- receive_packet(connection, &s7_write_response_packet);
+ plc4c_driver_s7_receive_packet(connection, &s7_write_response_packet);
// If we haven't read enough to process a full message, just try again
// next time.
if (return_code == UNFINISHED) {
diff --git a/sandbox/plc4c/drivers/s7/test/s7_test.c b/sandbox/plc4c/drivers/s7/test/s7_test.c
index aa193e3..4128863 100644
--- a/sandbox/plc4c/drivers/s7/test/s7_test.c
+++ b/sandbox/plc4c/drivers/s7/test/s7_test.c
@@ -39,7 +39,7 @@ void internal_assert_arrays_equal(uint8_t* expected_array,
}
}
-void internal_parse_serialize_test(const uint8_t* payload,
+void internal_parse_serialize_test(uint8_t* payload,
uint8_t payload_size) {
// Create a new read_buffer instance
plc4c_spi_read_buffer* read_buffer;
diff --git a/sandbox/plc4c/spi/src/evaluation_helper.c b/sandbox/plc4c/spi/src/evaluation_helper.c
index a0aff22..04c4197 100644
--- a/sandbox/plc4c/spi/src/evaluation_helper.c
+++ b/sandbox/plc4c/spi/src/evaluation_helper.c
@@ -34,3 +34,7 @@ uint8_t plc4c_spi_evaluation_helper_count(plc4c_list* a) {
return plc4c_utils_list_size(a);
}
+uint8_t plc4c_spi_evaluation_helper_array_size_in_bytes(plc4c_list* a) {
+ // TODO: This sort of can't work in C as we don't have the type information ...
+ return 0;
+}