fix to offsetting of var paload and some exra fetures on loopback tests

sandbox/plc4c/drivers/s7/src/driver_s7_packets.c

@@ -487,47 +487,48 @@ plc4c_return_code plc4c_driver_s7_create_s7_write_request(
 
 
   plc4c_driver_s7_config* configuration;
-  plc4c_s7_read_write_cotp_packet *payload;
+  plc4c_s7_read_write_cotp_packet *cotp_packet;
+  plc4c_s7_read_write_s7_message *s7_packet;
   plc4c_list_element* list_item;
   plc4c_s7_read_write_s7_parameter* s7_parameters;
   plc4c_s7_read_write_s7_payload* s7_payload;
 
   configuration = request->connection->configuration;
 
-  *request_packet = malloc(sizeof(request_packet));
+  *request_packet = malloc(sizeof(plc4c_s7_read_write_tpkt_packet));
   if (*request_packet == NULL) 
     return NO_MEMORY;
 
-
   (*request_packet)->payload = malloc(sizeof(plc4c_s7_read_write_cotp_packet));
   if ((*request_packet)->payload == NULL) 
     return NO_MEMORY;
 
   // Terse local variable for clarity
-  payload = (*request_packet)->payload;
+  cotp_packet = (*request_packet)->payload;
 
-  payload->_type = plc4c_s7_read_write_cotp_packet_type_plc4c_s7_read_write_cotp_packet_data;
-  payload->cotp_packet_data_tpdu_ref = configuration->pdu_id++;
-  payload->cotp_packet_data_eot = true;
-  payload->parameters = NULL;
+  cotp_packet->_type = plc4c_s7_read_write_cotp_packet_type_plc4c_s7_read_write_cotp_packet_data;
+  cotp_packet->cotp_packet_data_tpdu_ref = configuration->pdu_id++;
+  cotp_packet->cotp_packet_data_eot = true;
+  cotp_packet->parameters = NULL;
 
   // Allocate and initalise payload->payload 
-  payload->payload = malloc(sizeof(plc4c_s7_read_write_s7_message));
-  if (payload->payload == NULL)
+  cotp_packet->payload = malloc(sizeof(plc4c_s7_read_write_s7_message));
+  s7_packet = cotp_packet->payload;
+  if (s7_packet == NULL)
     return NO_MEMORY;
-  payload->payload->_type = plc4c_s7_read_write_s7_message_type_plc4c_s7_read_write_s7_message_request;
+  s7_packet->_type = plc4c_s7_read_write_s7_message_type_plc4c_s7_read_write_s7_message_request;
 
   // Allocate and initalise payload->payload->parameter
-  payload->payload->parameter = malloc(sizeof(plc4c_s7_read_write_s7_parameter));
-  s7_parameters = payload->payload->parameter;
+  s7_packet->parameter = malloc(sizeof(plc4c_s7_read_write_s7_parameter));
+  s7_parameters = s7_packet->parameter;
   if (s7_parameters == NULL)
     return NO_MEMORY;
   s7_parameters->_type = plc4c_s7_read_write_s7_parameter_type_plc4c_s7_read_write_s7_parameter_write_var_request;
   plc4c_utils_list_create(&s7_parameters->s7_parameter_write_var_request_items);
 
   //  Allocate and initalise payload->payload->payload
-  payload->payload->payload = malloc(sizeof(plc4c_s7_read_write_s7_payload));
-  s7_payload = payload->payload->payload;
+  s7_packet->payload = malloc(sizeof(plc4c_s7_read_write_s7_payload));
+  s7_payload = s7_packet->payload;
   if (s7_payload == NULL) 
     return NO_MEMORY;
   s7_payload->_type = plc4c_s7_read_write_s7_payload_type_plc4c_s7_read_write_s7_payload_write_var_request;
@@ -577,7 +578,7 @@ plc4c_return_code plc4c_driver_s7_create_s7_write_request(
     request_value = malloc(sizeof(plc4c_s7_read_write_s7_var_payload_data_item));
     request_value->transport_size = plc4c_s7_read_write_data_transport_size_BYTE_WORD_DWORD;
     plc4c_utils_list_create(&request_value->data);
-    plc4c_utils_list_insert_head_value(request_value->data, parsed_value);
+    plc4c_utils_list_insert_head_value(request_value->data, &parsed_value->data);
 
     // Add the new parameter to the request
     plc4c_utils_list_insert_head_value(s7_parameters->s7_parameter_write_var_request_items, request_param);

sandbox/plc4c/examples/hello-world-s7/src/hello_world_s7_loopback.c

@@ -28,6 +28,12 @@
 
 int numOpenConnections = 0;
 
+#ifndef _WIN32
+  #include <unistd.h>
+  #include <time.h>
+  #define S7_LOOPBACK_TIME_IO
+#endif
+
 /**
  * Here we could implement something that keeps track of all open connections.
  * For example on embedded devices using the W5100 SPI Network device, this can
@@ -62,12 +68,23 @@ typedef enum plc4c_connection_state_t plc4c_connection_state;
 
 //#pragma clang diagnostic push
 //#pragma ide diagnostic ignored "hicpp-multiway-paths-covered"
-#include <unistd.h>
+
 
 #define CHECK_RESULT(chk, ret, fs) do {if (chk) {printf(fs); return(ret);}} while(0)
 
+void get_user_loopback_values(int argc, char **argv, long *value) {
+  int count = 0;
+  while (count < argc)
+    value[count++] = atol(argv[count]);
+}
+
 int main(int argc, char** argv) {
 
+#ifdef S7_LOOPBACK_TIME_IO
+  struct timespec start, finish;
+  long delta_us, diff_s, diff_ns;
+#endif
+
   char* connection_test_string;
   plc4c_return_code result;
   plc4c_connection_state state;
@@ -86,7 +103,7 @@ int main(int argc, char** argv) {
   plc4c_list_element *cur_element;
   plc4c_response_value_item *value_item;
 
-  int8_t loopback_value;
+  long loopback_value[5] = {0,0,0,0,0};
   plc4c_data *loopback_data;
 
   // Connection string argument and do_write test arg (defaults to off as
@@ -96,10 +113,15 @@ int main(int argc, char** argv) {
   else
     connection_test_string = argv[1];
 
-  if (argc < 3)
-    loopback_value = 12;
-  else
-    loopback_value = atoi(argv[2]);
+  if (argc < 3) {
+    loopback_value[0] = 0; // bool
+    loopback_value[1] = 123; // uint8
+    loopback_value[2] = -123; // int8
+    loopback_value[3] = 2545; // uint16
+    loopback_value[4] = -2545; //int16
+  } else {
+    get_user_loopback_values(argc - 2, &argv[2], loopback_value);
+  }
 
   // Initialisation and startup sequence
   result = plc4c_system_create(&system);
@@ -126,8 +148,7 @@ int main(int argc, char** argv) {
   state = CONNECTING;
 
   while (loop) {
-
-    usleep(1000*100);
+
     // Give plc4c a chance to do something. This is where all I/O is done.
     if (plc4c_system_loop(system) != OK) {
       printf("ERROR in the system loop\n");
@@ -152,10 +173,13 @@ int main(int argc, char** argv) {
         result = plc4c_connection_create_write_request(connection, &write_request);
         CHECK_RESULT(result != OK, result,"plc4c_connection_create_write_request failed\n");
 
-        printf("Writing %d to %%DB4:0.0:SINT ...", loopback_value);
-        loopback_data = plc4c_data_create_int8_t_data(loopback_value);
+        printf("Writing %d to %%DB4:0.0:SINT ...", (uint8_t) loopback_value[1]);
+        loopback_data = plc4c_data_create_int8_t_data((uint8_t) loopback_value[1]);
         result = plc4c_write_request_add_item(write_request, "%DB4:0.0:SINT", loopback_data);
 
+#ifdef S7_LOOPBACK_TIME_IO
+        clock_gettime(CLOCK_MONOTONIC,&start);
+#endif
         result = plc4c_write_request_execute(write_request, &write_request_execution);
         CHECK_RESULT(result != OK, result,"plc4c_write_request_execute failed\n");
 
@@ -182,6 +206,14 @@ int main(int argc, char** argv) {
           cur_element = cur_element->next;
           // todo: check responce is error free
         }
+
+#ifdef S7_LOOPBACK_TIME_IO
+        clock_gettime(CLOCK_MONOTONIC,&finish);
+        diff_s = finish.tv_sec - start.tv_sec;
+        diff_ns = finish.tv_nsec - start.tv_nsec;
+        delta_us = (diff_s * 1000000L) + (diff_ns / 1000L);
+        printf("Write took %ld us\n", delta_us);
+#endif
         state = READ_REQUEST_CREATE;
         plc4c_write_destroy_write_response(write_response);
         plc4c_write_request_execution_destroy(write_request_execution);
@@ -198,13 +230,23 @@ int main(int argc, char** argv) {
         result = plc4c_read_request_execute(read_request, &read_request_execution);
         CHECK_RESULT(result != OK, result, "plc4c_read_request_execute failed\n");
         state = READ_REQUEST_SENT;
+#ifdef S7_LOOPBACK_TIME_IO
+        clock_gettime(CLOCK_MONOTONIC,&start);
+#endif
         break;
       }
 
       // Wait until the read-request execution is finished
       case READ_REQUEST_SENT: {
         if (plc4c_read_request_execution_check_finished_successfully(read_request_execution)) {
           state = READ_RESPONSE_RECEIVED;
+#ifdef S7_LOOPBACK_TIME_IO
+          clock_gettime(CLOCK_MONOTONIC,&finish);
+          diff_s = finish.tv_sec - start.tv_sec;
+          diff_ns = finish.tv_nsec - start.tv_nsec;
+          delta_us = (diff_s * 1000000L) + (diff_ns / 1000L);
+          printf("Write took %ld us\n", delta_us);
+#endif
         } else if (plc4c_read_request_execution_check_finished_with_error(read_request_execution)) {
           printf("plc4c_read_request_execution_check_finished_with_error FAILED\n");
           return -1;

sandbox/plc4c/generated-sources/s7/src/s7_var_payload_data_item.c

@@ -122,7 +122,7 @@ plc4c_return_code plc4c_s7_read_write_s7_var_payload_data_item_serialize(plc4c_s
 
       int8_t* _value = (int8_t*) plc4c_utils_list_get_value(_message->data, curItem);
       // TODO: fix this brutal hack gets us from data_item to data_item->data
-      plc4c_spi_write_signed_byte(io, 8, *(_value+=16)); 
+      plc4c_spi_write_signed_byte(io, 8, *(_value+0)); 
     }
   }