This is an automated email from the ASF dual-hosted git repository.
cdutz pushed a commit to branch feature/c-api
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/feature/c-api by this push:
new e4eb2bc - Made the read operations also have a response-code for
every item.
e4eb2bc is described below
commit e4eb2bc6d9d18d4758c2bafb85334ebc33531d39
Author: Christofer Dutz <christofer.d...@c-ware.de>
AuthorDate: Tue May 5 15:13:48 2020 +0200
- Made the read operations also have a response-code for every item.
---
.../plc4c/drivers/simulated/src/driver_simulated.c | 17 +++--
.../plc4c/examples/hello-world/src/hello_world.c | 85 ++++++++--------------
.../plc4c/spi/include/plc4c/spi/types_private.h | 11 ++-
sandbox/plc4c/spi/src/connection.c | 2 +-
4 files changed, 51 insertions(+), 64 deletions(-)
diff --git a/sandbox/plc4c/drivers/simulated/src/driver_simulated.c
b/sandbox/plc4c/drivers/simulated/src/driver_simulated.c
index 2933eb8..c353128 100644
--- a/sandbox/plc4c/drivers/simulated/src/driver_simulated.c
+++ b/sandbox/plc4c/drivers/simulated/src/driver_simulated.c
@@ -101,8 +101,9 @@ plc4c_return_code
plc4c_driver_simulated_read_machine_function(plc4c_system_task
plc4c_driver_simulated_item *cur_item = cur_element->value;
// Create a new random value.
- plc4c_value_item *value_item =
malloc(sizeof(plc4c_value_item));
+ plc4c_response_value_item *value_item =
malloc(sizeof(plc4c_response_value_item));
value_item->item = (plc4c_item *) cur_item;
+ value_item->response_code = PLC4C_RESPONSE_CODE_OK;
uint32_t *random_value = malloc(sizeof(uint32_t));
*random_value = arc4random();
value_item->value = random_value;
@@ -145,7 +146,7 @@ plc4c_return_code
plc4c_driver_simulated_write_machine_function(plc4c_system_tas
// Process every field in the request.
plc4c_list_element *cur_element =
plc4c_utils_list_head(write_request->items);
while (cur_element != NULL) {
- plc4c_value_item *cur_value_item = cur_element->value;
+ plc4c_request_value_item *cur_value_item = cur_element->value;
plc4c_driver_simulated_item *cur_item =
(plc4c_driver_simulated_item*) cur_value_item->item;
plc4c_response_code response_code = -1;
@@ -332,8 +333,8 @@ plc4c_return_code
plc4c_driver_simulated_write_function(plc4c_system_task **task
return OK;
}
-void free_read_item(plc4c_list_element *read_item_element) {
- plc4c_value_item *value_item = (plc4c_value_item *)
read_item_element->value;
+void free_read_response_item(plc4c_list_element *read_item_element) {
+ plc4c_response_value_item *value_item = (plc4c_response_value_item *)
read_item_element->value;
// do not delete the plc4c_item
// we also, in THIS case don't delete the random value which isn't really
// a pointer
@@ -343,11 +344,11 @@ void free_read_item(plc4c_list_element
*read_item_element) {
void plc4c_driver_simulated_free_read_response(plc4c_read_response *response) {
// the request will be cleaned up elsewhere
- plc4c_utils_list_delete_elements(response->items, &free_read_item);
+ plc4c_utils_list_delete_elements(response->items,
&free_read_response_item);
}
-void free_write_item(plc4c_list_element *write_item_element) {
- plc4c_value_item *value_item = (plc4c_value_item *)
write_item_element->value;
+void free_write_response_item(plc4c_list_element *write_item_element) {
+ plc4c_response_value_item *value_item = (plc4c_response_value_item *)
write_item_element->value;
// do not delete the plc4c_item
// we also, in THIS case don't delete the random value which isn't really
// a pointer
@@ -357,7 +358,7 @@ void free_write_item(plc4c_list_element
*write_item_element) {
void plc4c_driver_simulated_free_write_response(plc4c_write_response
*response) {
// the request will be cleaned up elsewhere
- plc4c_utils_list_delete_elements(response->response_items,
&free_write_item);
+ plc4c_utils_list_delete_elements(response->response_items,
&free_write_response_item);
}
diff --git a/sandbox/plc4c/examples/hello-world/src/hello_world.c
b/sandbox/plc4c/examples/hello-world/src/hello_world.c
index 6396fca..cdbe94e 100644
--- a/sandbox/plc4c/examples/hello-world/src/hello_world.c
+++ b/sandbox/plc4c/examples/hello-world/src/hello_world.c
@@ -44,8 +44,8 @@ void onGlobalDisconnect(plc4c_connection *cur_connection) {
}
void delete_address(plc4c_list_element *address_data_element) {
- // these are not malloc'd, no need to free
- address_data_element->value = NULL;
+ // these are not malloc'd, no need to free
+ address_data_element->value = NULL;
}
void delete_read_response_item(plc4c_list_element *response_read_item_element)
{
@@ -66,10 +66,11 @@ enum plc4c_connection_state_t {
DISCONNECTING,
DISCONNECTED
};
-typedef enum plc4c_connection_state_t plc4c_connection_state ;
+typedef enum plc4c_connection_state_t plc4c_connection_state;
#pragma clang diagnostic push
#pragma ide diagnostic ignored "hicpp-multiway-paths-covered"
+
int main() {
bool loop = true;
plc4c_system *system = NULL;
@@ -161,9 +162,9 @@ int main() {
plc4c_list *address_list = NULL;
plc4c_utils_list_create(&address_list);
- plc4c_utils_list_insert_head_value(address_list,(void
*)"RANDOM/foo:INTEGER");
+ plc4c_utils_list_insert_head_value(address_list, (void *)
"RANDOM/foo:INTEGER");
result = plc4c_connection_create_read_request(connection,
address_list, &read_request);
- if(result != OK) {
+ if (result != OK) {
printf("FAILED\n");
return -1;
}
@@ -177,7 +178,7 @@ int main() {
plc4c_utils_list_delete_elements(address_list,
&delete_address);
free(address_list);
- if(result != OK) {
+ if (result != OK) {
printf("FAILED\n");
return -1;
} else {
@@ -185,12 +186,12 @@ int main() {
}
break;
}
- // Wait until the read-request execution is finished.
+ // Wait until the read-request execution is finished.
case READ_REQUEST_SENT: {
-
if(plc4c_read_request_finished_successfully(read_request_execution)) {
+ if
(plc4c_read_request_finished_successfully(read_request_execution)) {
printf("SUCCESS\n");
state = READ_RESPONSE_RECEIVED;
- } else
if(plc4c_read_request_has_error(read_request_execution)) {
+ } else if
(plc4c_read_request_has_error(read_request_execution)) {
printf("FAILED\n");
return -1;
}
@@ -199,7 +200,7 @@ int main() {
case READ_RESPONSE_RECEIVED: {
// Get the response for the given read-request.
plc4c_read_response *read_response =
plc4c_read_request_get_response(read_request_execution);
- if(read_response == NULL) {
+ if (read_response == NULL) {
printf("FAILED (No Response)\n");
return -1;
}
@@ -207,11 +208,13 @@ int main() {
// Iterate over all returned items.
plc4c_list_element *cur_element =
plc4c_utils_list_head(read_response->items);
while (cur_element != NULL) {
- plc4c_value_item *value_item = cur_element->value;
+ plc4c_response_value_item *value_item = cur_element->value;
// Just cast the value to int for now ...
// TODO: We need to introduce a fully operational
plc_value system later on.
- printf("Value %d\n", (int) value_item->value);
+ printf("- Read Value %d (%s): %d\n", (int)
value_item->value,
+
plc4c_response_code_to_message(value_item->response_code),
+ (int) value_item->value);
cur_element = cur_element->next;
}
@@ -225,10 +228,10 @@ int main() {
printf("Preparing a write-request for 'STDOUT/foo:INTEGER' ...
");
plc4c_list *address_list = NULL;
plc4c_utils_list_create(&address_list);
- plc4c_utils_list_insert_head_value(address_list,(void
*)"STDOUT/foo:STRING");
+ plc4c_utils_list_insert_head_value(address_list, (void *)
"STDOUT/foo:STRING");
plc4c_list *value_list = NULL;
plc4c_utils_list_create(&value_list);
- plc4c_utils_list_insert_head_value(value_list,(void *)"hurz");
+ plc4c_utils_list_insert_head_value(value_list, (void *)
"hurz");
result = plc4c_connection_create_write_request(connection,
address_list, value_list, &write_request);
// As we only used these to create the request, they can now
be released again.
@@ -237,7 +240,7 @@ int main() {
free(address_list);
free(value_list);
- if(result != OK) {
+ if (result != OK) {
printf("FAILED\n");
return -1;
}
@@ -246,7 +249,7 @@ int main() {
// Execute the write-request.
printf("Executing a write-request ... \n");
result = plc4c_write_request_execute(write_request,
&write_request_execution);
- if(result != OK) {
+ if (result != OK) {
printf("FAILED\n");
return -1;
} else {
@@ -254,72 +257,47 @@ int main() {
}
break;
}
- // Wait until the write-request execution is finished.
+ // Wait until the write-request execution is finished.
case WRITE_REQUEST_SENT: {
-
if(plc4c_write_request_finished_successfully(write_request_execution)) {
+ if
(plc4c_write_request_finished_successfully(write_request_execution)) {
printf("SUCCESS\n");
-
- plc4c_write_response *write_response =
plc4c_write_request_get_response(write_request_execution);
-
- // Iterate over the responses ...
- printf("Write Response:\n");
- plc4c_list_element *cur_element =
plc4c_utils_list_head(write_response->response_items);
- while (cur_element != NULL) {
- plc4c_response_item *response_item =
cur_element->value;
- printf(" - %s: %s\n", response_item->item->name,
plc4c_response_code_to_message(response_item->response_code));
- cur_element = cur_element->next;
- }
-
- // Clean up.
- plc4c_connection_write_response_destroy(write_response);
-
plc4c_read_request_execution_destroy(read_request_execution);
- plc4c_read_request_destroy(read_request);
-
state = WRITE_RESPONSE_RECEIVED;
- } else
if(plc4c_write_request_has_error(write_request_execution)) {
+ } else if
(plc4c_write_request_has_error(write_request_execution)) {
printf("FAILED\n");
return -1;
}
break;
}
case WRITE_RESPONSE_RECEIVED: {
- // Get the response for the given write-request.
plc4c_write_response *write_response =
plc4c_write_request_get_response(write_request_execution);
- if(write_response == NULL) {
- printf("FAILED (No Response)\n");
- return -1;
- }
- // Iterate over all returned items.
+ // Iterate over the responses ...
plc4c_list_element *cur_element =
plc4c_utils_list_head(write_response->response_items);
while (cur_element != NULL) {
- plc4c_value_item *value_item = cur_element->value;
-
- // Just cast the value to int for now ...
- // TODO: We need to introduce a fully operational
plc_value system later on.
- printf("Value %d\n", (int) value_item->value);
-
+ plc4c_response_item *response_item = cur_element->value;
+ printf(" - Write Value %s (%s)\n",
response_item->item->name,
+
plc4c_response_code_to_message(response_item->response_code));
cur_element = cur_element->next;
}
// Clean up.
plc4c_connection_write_response_destroy(write_response);
- plc4c_write_request_execution_destroy(write_request_execution);
- plc4c_write_request_destroy(write_request);
+ plc4c_read_request_execution_destroy(read_request_execution);
+ plc4c_read_request_destroy(read_request);
// Disconnect.
printf("Disconnecting ... ");
result = plc4c_connection_disconnect(connection);
- if(result != OK) {
+ if (result != OK) {
printf("FAILED");
return -1;
}
state = DISCONNECTING;
break;
}
- // Wait until the connection is disconnected
+ // Wait until the connection is disconnected
case DISCONNECTING: {
- if(!plc4c_connection_is_connected(connection)) {
+ if (!plc4c_connection_is_connected(connection)) {
printf("SUCCESS\n");
plc4c_connection_destroy(connection);
state = DISCONNECTED;
@@ -345,4 +323,5 @@ int main() {
return 0;
}
+
#pragma clang diagnostic pop
diff --git a/sandbox/plc4c/spi/include/plc4c/spi/types_private.h
b/sandbox/plc4c/spi/include/plc4c/spi/types_private.h
index 5293ec0..274da85 100644
--- a/sandbox/plc4c/spi/include/plc4c/spi/types_private.h
+++ b/sandbox/plc4c/spi/include/plc4c/spi/types_private.h
@@ -28,7 +28,8 @@ typedef struct plc4c_item_t plc4c_item;
typedef struct plc4c_driver_list_item_t plc4c_driver_list_item;
typedef struct plc4c_transport_list_item_t plc4c_transport_list_item;
typedef struct plc4c_connection_list_item_t plc4c_connection_list_item;
-typedef struct plc4c_value_item_t plc4c_value_item;
+typedef struct plc4c_request_value_item_t plc4c_request_value_item;
+typedef struct plc4c_response_value_item_t plc4c_response_value_item;
typedef struct plc4c_response_item_t plc4c_response_item;
typedef plc4c_item *(*plc4c_connection_parse_address_item)(char
*address_string);
@@ -134,11 +135,17 @@ struct plc4c_connection_list_item_t {
};
-struct plc4c_value_item_t {
+struct plc4c_request_value_item_t {
plc4c_item *item;
void *value;
};
+struct plc4c_response_value_item_t {
+ plc4c_item *item;
+ plc4c_response_code response_code;
+ void *value;
+};
+
struct plc4c_response_item_t {
plc4c_item *item;
plc4c_response_code response_code;
diff --git a/sandbox/plc4c/spi/src/connection.c
b/sandbox/plc4c/spi/src/connection.c
index 8cddbdc..5a98c7a 100644
--- a/sandbox/plc4c/spi/src/connection.c
+++ b/sandbox/plc4c/spi/src/connection.c
@@ -111,7 +111,7 @@ plc4c_return_code
plc4c_connection_create_write_request(plc4c_connection *connec
plc4c_item *address_item =
connection->driver->parse_address_function(address);
// Create a new value item, binding an address item to a value.
- plc4c_value_item *value_item = malloc(sizeof(plc4c_value_item));
+ plc4c_request_value_item *value_item =
malloc(sizeof(plc4c_request_value_item));
value_item->item = address_item;
connection->driver->encode_value_function(address_item,
value_element->value, &value_item->value);
