From fa4f566bf90636cecf5eaae140392683d407b78a Mon Sep 17 00:00:00 2001 From: Stéphane Raimbault Date: Sun, 6 Apr 2008 18:01:59 +0200 Subject: [PATCH] Unit testing - Major changes to unit-test-master/slave to add 4 tests - Use new functions to manipulate bits - Reduce memory usage (allocate only the required space and use uint[8|16]_t pointers) --- tests/unit-test-master.c | 115 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------- tests/unit-test-slave.c | 87 ++++++++++++++++++++++++++++++++++++--------------------------------------------------- tests/unit-test.h | 22 ++++++++++++++++++++++ 3 files changed, 152 insertions(+), 72 deletions(-) create mode 100644 tests/unit-test.h diff --git a/tests/unit-test-master.c b/tests/unit-test-master.c index e76ddab..c138853 100644 --- a/tests/unit-test-master.c +++ b/tests/unit-test-master.c @@ -24,49 +24,122 @@ #include +#include "unit-test.h" + /* Tests based on PI-MBUS-300 documentation */ #define SLAVE 0x11 -#define FIELDS 500 int main(void) { - int *tab_rq; - int *tab_rq_bits; - int *tab_rp; + uint8_t *tab_rp_status; + uint16_t *tab_rp_registers; modbus_param_t mb_param; + int i; + uint8_t value; + uint16_t address; + uint16_t nb_points; /* RTU parity : none, even, odd */ /* modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, "none", 8, 1); */ /* TCP */ modbus_init_tcp(&mb_param, "127.0.0.1", 1502); - modbus_set_debug(&mb_param, TRUE); modbus_connect(&mb_param); - /* Allocate and initialize the different memory spaces */ - tab_rq = (int *) malloc(FIELDS * sizeof(int)); - memset(tab_rq, 0, FIELDS * sizeof(int)); + /* Allocate and initialize the memory to store the status */ + nb_points = (UT_COIL_STATUS_NB_POINTS > UT_INPUT_STATUS_NB_POINTS) ? + UT_COIL_STATUS_NB_POINTS : UT_INPUT_STATUS_NB_POINTS; + tab_rp_status = (uint8_t *) malloc(nb_points * sizeof(uint8_t)); + memset(tab_rp_status, 0, nb_points * sizeof(uint8_t)); + + /* Allocate and initialize the memory to store the registers */ + nb_points = (UT_HOLDING_REGISTERS_NB_POINTS > UT_INPUT_REGISTERS_NB_POINTS) ? + UT_HOLDING_REGISTERS_NB_POINTS : UT_INPUT_REGISTERS_NB_POINTS; + tab_rp_registers = (uint16_t *) malloc(nb_points * sizeof(uint16_t)); + memset(tab_rp_registers, 0, nb_points * sizeof(uint16_t)); - tab_rq_bits = (int *) malloc(FIELDS * sizeof(int)); - memset(tab_rq_bits, 0, FIELDS * sizeof(int)); + printf("Unit testing\n"); + + /** COIL STATUS **/ + read_coil_status(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, + UT_COIL_STATUS_NB_POINTS, tab_rp_status); + + i = 0; + address = UT_COIL_STATUS_ADDRESS; + nb_points = UT_COIL_STATUS_NB_POINTS; + while (nb_points > 0) { + int nb_bits = (nb_points > 8) ? 8 : nb_points; + + value = get_byte_from_bits(tab_rp_status, i*8, nb_bits); + if (value != UT_COIL_STATUS_TAB[i]) { + printf("Coil status: FAILED (%0X != %0X)\n", + value, UT_COIL_STATUS_TAB[i]); + goto close; + } + + nb_points -= nb_bits; + i++; + } + printf("Coil status: OK\n"); - tab_rp = (int *) malloc(FIELDS * sizeof(int)); - memset(tab_rp, 0, FIELDS * sizeof(int)); - - read_coil_status(&mb_param, SLAVE, 0x13, 0x25, tab_rp); - read_input_status(&mb_param, SLAVE, 0xC4, 0x16, tab_rp); - read_holding_registers(&mb_param, SLAVE, 0x6B, 3, tab_rp); - read_input_registers(&mb_param, SLAVE, 0x8, 1, tab_rp); - force_single_coil(&mb_param, SLAVE, 0xAC, ON); + /** INPUT STATUS **/ + read_input_status(&mb_param, SLAVE, UT_INPUT_STATUS_ADDRESS, + UT_INPUT_STATUS_NB_POINTS, tab_rp_status); + + i = 0; + address = UT_INPUT_STATUS_ADDRESS; + nb_points = UT_INPUT_STATUS_NB_POINTS; + while (nb_points > 0) { + int nb_bits = (nb_points > 8) ? 8 : nb_points; + + value = get_byte_from_bits(tab_rp_status, i*8, nb_bits); + if (value != UT_INPUT_STATUS_TAB[i]) { + printf("Input status: FAILED (%0X != %0X)\n", + value, UT_INPUT_STATUS_TAB[i]); + goto close; + } + + nb_points -= nb_bits; + i++; + } + printf("Input status: OK\n"); + + /** HOLDING REGISTERS **/ + read_holding_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS, + UT_HOLDING_REGISTERS_NB_POINTS, tab_rp_registers); + for (i=0; i < UT_HOLDING_REGISTERS_NB_POINTS; i++) { + if (tab_rp_registers[i] != UT_HOLDING_REGISTERS_TAB[i]) { + printf("Holding registers: FAILED (%0X != %0X)\n", + tab_rp_registers[i], UT_HOLDING_REGISTERS_TAB[i]); + goto close; + } + } + printf("Holding registers: OK\n"); + + /** INPUT REGISTERS **/ + read_input_registers(&mb_param, SLAVE, UT_INPUT_REGISTERS_ADDRESS, + UT_INPUT_REGISTERS_NB_POINTS, tab_rp_registers); + for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) { + if (tab_rp_registers[i] != UT_INPUT_REGISTERS_TAB[i]) { + printf("Input registers: FAILED (%0X != %0X)\n", + tab_rp_registers[i], UT_INPUT_REGISTERS_TAB[i]); + goto close; + } + } + printf("Input registers: OK\n"); + +close: /* Free the memory */ - free(tab_rp); - free(tab_rq); - free(tab_rq_bits); + free(tab_rp_status); + free(tab_rp_registers); /* Close the connection */ modbus_close(&mb_param); return 0; +/* + force_single_coil(&mb_param, SLAVE, 0xAC, ON); +*/ } diff --git a/tests/unit-test-slave.c b/tests/unit-test-slave.c index bc6e348..66f0e29 100644 --- a/tests/unit-test-slave.c +++ b/tests/unit-test-slave.c @@ -24,12 +24,10 @@ #include +#include "unit-test.h" + int main(void) { - const int nb_coil_status = 500; - const int nb_input_status = 500; - const int nb_input_registers = 500; - const int nb_holding_registers = 500; int socket; modbus_param_t mb_param; modbus_mapping_t mb_mapping; @@ -37,59 +35,41 @@ int main(void) int i; modbus_init_tcp(&mb_param, "127.0.0.1", 1502); - modbus_set_debug(&mb_param, TRUE); - modbus_mapping_new(&mb_mapping, - nb_coil_status, nb_input_status, - nb_input_registers, nb_holding_registers); + ret = modbus_mapping_new(&mb_mapping, + UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS, + UT_INPUT_STATUS_ADDRESS + UT_INPUT_STATUS_NB_POINTS, + UT_HOLDING_REGISTERS_ADDRESS + UT_HOLDING_REGISTERS_NB_POINTS, + UT_INPUT_STATUS_ADDRESS + UT_INPUT_REGISTERS_NB_POINTS); + if (ret == FALSE) { + printf("Memory allocation failed\n"); + exit(1); + } /* Examples from PI_MODBUS_300.pdf */ - /* Coil status */ - mb_mapping.tab_coil_status[26] = ON; - mb_mapping.tab_coil_status[25] = ON; - mb_mapping.tab_coil_status[24] = OFF; - mb_mapping.tab_coil_status[23] = OFF; - mb_mapping.tab_coil_status[22] = ON; - mb_mapping.tab_coil_status[21] = ON; - mb_mapping.tab_coil_status[20] = OFF; - mb_mapping.tab_coil_status[19] = ON; - - /* Input status */ - mb_mapping.tab_input_status[203] = ON; - mb_mapping.tab_input_status[202] = OFF; - mb_mapping.tab_input_status[201] = ON; - mb_mapping.tab_input_status[200] = OFF; - mb_mapping.tab_input_status[199] = ON; - mb_mapping.tab_input_status[198] = ON; - mb_mapping.tab_input_status[197] = OFF; - mb_mapping.tab_input_status[196] = OFF; + /** COIL STATUS **/ + set_bits_from_bytes(mb_mapping.tab_coil_status, + UT_COIL_STATUS_ADDRESS, UT_COIL_STATUS_NB_POINTS, + UT_COIL_STATUS_TAB); - mb_mapping.tab_input_status[211] = ON; - mb_mapping.tab_input_status[210] = ON; - mb_mapping.tab_input_status[209] = OFF; - mb_mapping.tab_input_status[208] = ON; - mb_mapping.tab_input_status[207] = ON; - mb_mapping.tab_input_status[206] = OFF; - mb_mapping.tab_input_status[205] = ON; - mb_mapping.tab_input_status[204] = ON; + /** INPUT STATUS **/ + set_bits_from_bytes(mb_mapping.tab_input_status, + UT_INPUT_STATUS_ADDRESS, UT_INPUT_STATUS_NB_POINTS, + UT_INPUT_STATUS_TAB); - /* Incomplete byte */ - mb_mapping.tab_input_status[217] = ON; - mb_mapping.tab_input_status[216] = ON; - mb_mapping.tab_input_status[215] = OFF; - mb_mapping.tab_input_status[214] = ON; - mb_mapping.tab_input_status[213] = OFF; - mb_mapping.tab_input_status[212] = ON; + /** HOLDING REGISTERS **/ + for (i=0; i < UT_HOLDING_REGISTERS_NB_POINTS; i++) { + mb_mapping.tab_holding_registers[UT_HOLDING_REGISTERS_ADDRESS+i] = + UT_HOLDING_REGISTERS_TAB[i];; + } - /* Holding registers */ - mb_mapping.tab_holding_registers[107] = 0x022B; - mb_mapping.tab_holding_registers[108] = 0x0000; - mb_mapping.tab_holding_registers[109] = 0x0064; + /** INPUT REGISTERS **/ + for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) { + mb_mapping.tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] = + UT_INPUT_REGISTERS_TAB[i];; + } - /* Input registers */ - mb_mapping.tab_input_registers[8] = 0x000A; - socket = modbus_init_listen_tcp(&mb_param); i = 0; @@ -98,10 +78,15 @@ int main(void) int query_size; ret = modbus_listen(&mb_param, query, &query_size); - if (ret == 0) + + if (ret == 0) { manage_query(&mb_param, query, query_size, &mb_mapping); - else + } else if (ret == CONNECTION_CLOSED) { + /* Connection closed by the client, end of server */ + break; + } else { printf("Error in modbus_listen (%d)\n", ret); + } } close(socket); diff --git a/tests/unit-test.h b/tests/unit-test.h new file mode 100644 index 0000000..576be40 --- /dev/null +++ b/tests/unit-test.h @@ -0,0 +1,22 @@ +#ifndef _UNIT_TEST_H_ +#define _UNIT_TEST_H_ + +#include + +const uint16_t UT_COIL_STATUS_ADDRESS = 0x13; +const uint16_t UT_COIL_STATUS_NB_POINTS = 0x25; +const uint8_t UT_COIL_STATUS_TAB[] = { 0xCD, 0x6B, 0xB2, 0x0E, 0x1B }; + +const uint16_t UT_INPUT_STATUS_ADDRESS = 0xC4; +const uint16_t UT_INPUT_STATUS_NB_POINTS = 0x16; +const uint8_t UT_INPUT_STATUS_TAB[] = { 0xAC, 0xDB, 0x35 }; + +const uint16_t UT_HOLDING_REGISTERS_ADDRESS = 0x6B; +const uint16_t UT_HOLDING_REGISTERS_NB_POINTS = 0x3; +const uint16_t UT_HOLDING_REGISTERS_TAB[] = { 0x022B, 0x0000, 0x0064 }; + +const uint16_t UT_INPUT_REGISTERS_ADDRESS = 0x08; +const uint16_t UT_INPUT_REGISTERS_NB_POINTS = 0x1; +const uint16_t UT_INPUT_REGISTERS_TAB[] = { 0x000A }; + +#endif /* _UNIT_TEST_H_ */ -- libgit2 0.21.4