Peter M. Groen / libmodbus

Commit fa4f566bf90636cecf5eaae140392683d407b78a

Authored by Stéphane Raimbault
1 parent 1660f894

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)
Inline Side-by-side
Showing 3 changed files with 152 additions and 72 deletions
tests/unit-test-master.c
  View file @fa4f566
... ... @@ -24,49 +24,122 @@
24 24  
25 25 #include <modbus/modbus.h>
26 26  
  27 +#include "unit-test.h"
  28 +
27 29 /* Tests based on PI-MBUS-300 documentation */
28 30 #define SLAVE 0x11
29   -#define FIELDS 500
30 31  
31 32 int main(void)
32 33 {
33   - int *tab_rq;
34   - int *tab_rq_bits;
35   - int *tab_rp;
  34 + uint8_t *tab_rp_status;
  35 + uint16_t *tab_rp_registers;
36 36 modbus_param_t mb_param;
  37 + int i;
  38 + uint8_t value;
  39 + uint16_t address;
  40 + uint16_t nb_points;
37 41  
38 42 /* RTU parity : none, even, odd */
39 43 /* modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, "none", 8, 1); */
40 44  
41 45 /* TCP */
42 46 modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
43   - modbus_set_debug(&mb_param, TRUE);
44 47  
45 48 modbus_connect(&mb_param);
46 49  
47   - /* Allocate and initialize the different memory spaces */
48   - tab_rq = (int *) malloc(FIELDS * sizeof(int));
49   - memset(tab_rq, 0, FIELDS * sizeof(int));
  50 + /* Allocate and initialize the memory to store the status */
  51 + nb_points = (UT_COIL_STATUS_NB_POINTS > UT_INPUT_STATUS_NB_POINTS) ?
  52 + UT_COIL_STATUS_NB_POINTS : UT_INPUT_STATUS_NB_POINTS;
  53 + tab_rp_status = (uint8_t *) malloc(nb_points * sizeof(uint8_t));
  54 + memset(tab_rp_status, 0, nb_points * sizeof(uint8_t));
  55 +
  56 + /* Allocate and initialize the memory to store the registers */
  57 + nb_points = (UT_HOLDING_REGISTERS_NB_POINTS > UT_INPUT_REGISTERS_NB_POINTS) ?
  58 + UT_HOLDING_REGISTERS_NB_POINTS : UT_INPUT_REGISTERS_NB_POINTS;
  59 + tab_rp_registers = (uint16_t *) malloc(nb_points * sizeof(uint16_t));
  60 + memset(tab_rp_registers, 0, nb_points * sizeof(uint16_t));
50 61  
51   - tab_rq_bits = (int *) malloc(FIELDS * sizeof(int));
52   - memset(tab_rq_bits, 0, FIELDS * sizeof(int));
  62 + printf("Unit testing\n");
  63 +
  64 + /** COIL STATUS **/
  65 + read_coil_status(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS,
  66 + UT_COIL_STATUS_NB_POINTS, tab_rp_status);
  67 +
  68 + i = 0;
  69 + address = UT_COIL_STATUS_ADDRESS;
  70 + nb_points = UT_COIL_STATUS_NB_POINTS;
  71 + while (nb_points > 0) {
  72 + int nb_bits = (nb_points > 8) ? 8 : nb_points;
  73 +
  74 + value = get_byte_from_bits(tab_rp_status, i*8, nb_bits);
  75 + if (value != UT_COIL_STATUS_TAB[i]) {
  76 + printf("Coil status: FAILED (%0X != %0X)\n",
  77 + value, UT_COIL_STATUS_TAB[i]);
  78 + goto close;
  79 + }
  80 +
  81 + nb_points -= nb_bits;
  82 + i++;
  83 + }
  84 + printf("Coil status: OK\n");
53 85  
54   - tab_rp = (int *) malloc(FIELDS * sizeof(int));
55   - memset(tab_rp, 0, FIELDS * sizeof(int));
56   -
57   - read_coil_status(&mb_param, SLAVE, 0x13, 0x25, tab_rp);
58   - read_input_status(&mb_param, SLAVE, 0xC4, 0x16, tab_rp);
59   - read_holding_registers(&mb_param, SLAVE, 0x6B, 3, tab_rp);
60   - read_input_registers(&mb_param, SLAVE, 0x8, 1, tab_rp);
61   - force_single_coil(&mb_param, SLAVE, 0xAC, ON);
62 86  
  87 + /** INPUT STATUS **/
  88 + read_input_status(&mb_param, SLAVE, UT_INPUT_STATUS_ADDRESS,
  89 + UT_INPUT_STATUS_NB_POINTS, tab_rp_status);
  90 +
  91 + i = 0;
  92 + address = UT_INPUT_STATUS_ADDRESS;
  93 + nb_points = UT_INPUT_STATUS_NB_POINTS;
  94 + while (nb_points > 0) {
  95 + int nb_bits = (nb_points > 8) ? 8 : nb_points;
  96 +
  97 + value = get_byte_from_bits(tab_rp_status, i*8, nb_bits);
  98 + if (value != UT_INPUT_STATUS_TAB[i]) {
  99 + printf("Input status: FAILED (%0X != %0X)\n",
  100 + value, UT_INPUT_STATUS_TAB[i]);
  101 + goto close;
  102 + }
  103 +
  104 + nb_points -= nb_bits;
  105 + i++;
  106 + }
  107 + printf("Input status: OK\n");
  108 +
  109 + /** HOLDING REGISTERS **/
  110 + read_holding_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS,
  111 + UT_HOLDING_REGISTERS_NB_POINTS, tab_rp_registers);
  112 + for (i=0; i < UT_HOLDING_REGISTERS_NB_POINTS; i++) {
  113 + if (tab_rp_registers[i] != UT_HOLDING_REGISTERS_TAB[i]) {
  114 + printf("Holding registers: FAILED (%0X != %0X)\n",
  115 + tab_rp_registers[i], UT_HOLDING_REGISTERS_TAB[i]);
  116 + goto close;
  117 + }
  118 + }
  119 + printf("Holding registers: OK\n");
  120 +
  121 + /** INPUT REGISTERS **/
  122 + read_input_registers(&mb_param, SLAVE, UT_INPUT_REGISTERS_ADDRESS,
  123 + UT_INPUT_REGISTERS_NB_POINTS, tab_rp_registers);
  124 + for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) {
  125 + if (tab_rp_registers[i] != UT_INPUT_REGISTERS_TAB[i]) {
  126 + printf("Input registers: FAILED (%0X != %0X)\n",
  127 + tab_rp_registers[i], UT_INPUT_REGISTERS_TAB[i]);
  128 + goto close;
  129 + }
  130 + }
  131 + printf("Input registers: OK\n");
  132 +
  133 +close:
63 134 /* Free the memory */
64   - free(tab_rp);
65   - free(tab_rq);
66   - free(tab_rq_bits);
  135 + free(tab_rp_status);
  136 + free(tab_rp_registers);
67 137  
68 138 /* Close the connection */
69 139 modbus_close(&mb_param);
70 140  
71 141 return 0;
  142 +/*
  143 + force_single_coil(&mb_param, SLAVE, 0xAC, ON);
  144 +*/
72 145 }
... ...
tests/unit-test-slave.c
  View file @fa4f566
... ... @@ -24,12 +24,10 @@
24 24  
25 25 #include <modbus/modbus.h>
26 26  
  27 +#include "unit-test.h"
  28 +
27 29 int main(void)
28 30 {
29   - const int nb_coil_status = 500;
30   - const int nb_input_status = 500;
31   - const int nb_input_registers = 500;
32   - const int nb_holding_registers = 500;
33 31 int socket;
34 32 modbus_param_t mb_param;
35 33 modbus_mapping_t mb_mapping;
... ... @@ -37,59 +35,41 @@ int main(void)
37 35 int i;
38 36  
39 37 modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
40   - modbus_set_debug(&mb_param, TRUE);
41 38  
42   - modbus_mapping_new(&mb_mapping,
43   - nb_coil_status, nb_input_status,
44   - nb_input_registers, nb_holding_registers);
  39 + ret = modbus_mapping_new(&mb_mapping,
  40 + UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS,
  41 + UT_INPUT_STATUS_ADDRESS + UT_INPUT_STATUS_NB_POINTS,
  42 + UT_HOLDING_REGISTERS_ADDRESS + UT_HOLDING_REGISTERS_NB_POINTS,
  43 + UT_INPUT_STATUS_ADDRESS + UT_INPUT_REGISTERS_NB_POINTS);
  44 + if (ret == FALSE) {
  45 + printf("Memory allocation failed\n");
  46 + exit(1);
  47 + }
45 48  
46 49 /* Examples from PI_MODBUS_300.pdf */
47 50  
48   - /* Coil status */
49   - mb_mapping.tab_coil_status[26] = ON;
50   - mb_mapping.tab_coil_status[25] = ON;
51   - mb_mapping.tab_coil_status[24] = OFF;
52   - mb_mapping.tab_coil_status[23] = OFF;
53   - mb_mapping.tab_coil_status[22] = ON;
54   - mb_mapping.tab_coil_status[21] = ON;
55   - mb_mapping.tab_coil_status[20] = OFF;
56   - mb_mapping.tab_coil_status[19] = ON;
57   -
58   - /* Input status */
59   - mb_mapping.tab_input_status[203] = ON;
60   - mb_mapping.tab_input_status[202] = OFF;
61   - mb_mapping.tab_input_status[201] = ON;
62   - mb_mapping.tab_input_status[200] = OFF;
63   - mb_mapping.tab_input_status[199] = ON;
64   - mb_mapping.tab_input_status[198] = ON;
65   - mb_mapping.tab_input_status[197] = OFF;
66   - mb_mapping.tab_input_status[196] = OFF;
  51 + /** COIL STATUS **/
  52 + set_bits_from_bytes(mb_mapping.tab_coil_status,
  53 + UT_COIL_STATUS_ADDRESS, UT_COIL_STATUS_NB_POINTS,
  54 + UT_COIL_STATUS_TAB);
67 55  
68   - mb_mapping.tab_input_status[211] = ON;
69   - mb_mapping.tab_input_status[210] = ON;
70   - mb_mapping.tab_input_status[209] = OFF;
71   - mb_mapping.tab_input_status[208] = ON;
72   - mb_mapping.tab_input_status[207] = ON;
73   - mb_mapping.tab_input_status[206] = OFF;
74   - mb_mapping.tab_input_status[205] = ON;
75   - mb_mapping.tab_input_status[204] = ON;
  56 + /** INPUT STATUS **/
  57 + set_bits_from_bytes(mb_mapping.tab_input_status,
  58 + UT_INPUT_STATUS_ADDRESS, UT_INPUT_STATUS_NB_POINTS,
  59 + UT_INPUT_STATUS_TAB);
76 60  
77   - /* Incomplete byte */
78   - mb_mapping.tab_input_status[217] = ON;
79   - mb_mapping.tab_input_status[216] = ON;
80   - mb_mapping.tab_input_status[215] = OFF;
81   - mb_mapping.tab_input_status[214] = ON;
82   - mb_mapping.tab_input_status[213] = OFF;
83   - mb_mapping.tab_input_status[212] = ON;
  61 + /** HOLDING REGISTERS **/
  62 + for (i=0; i < UT_HOLDING_REGISTERS_NB_POINTS; i++) {
  63 + mb_mapping.tab_holding_registers[UT_HOLDING_REGISTERS_ADDRESS+i] =
  64 + UT_HOLDING_REGISTERS_TAB[i];;
  65 + }
84 66  
85   - /* Holding registers */
86   - mb_mapping.tab_holding_registers[107] = 0x022B;
87   - mb_mapping.tab_holding_registers[108] = 0x0000;
88   - mb_mapping.tab_holding_registers[109] = 0x0064;
  67 + /** INPUT REGISTERS **/
  68 + for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) {
  69 + mb_mapping.tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] =
  70 + UT_INPUT_REGISTERS_TAB[i];;
  71 + }
89 72  
90   - /* Input registers */
91   - mb_mapping.tab_input_registers[8] = 0x000A;
92   -
93 73 socket = modbus_init_listen_tcp(&mb_param);
94 74  
95 75 i = 0;
... ... @@ -98,10 +78,15 @@ int main(void)
98 78 int query_size;
99 79  
100 80 ret = modbus_listen(&mb_param, query, &query_size);
101   - if (ret == 0)
  81 +
  82 + if (ret == 0) {
102 83 manage_query(&mb_param, query, query_size, &mb_mapping);
103   - else
  84 + } else if (ret == CONNECTION_CLOSED) {
  85 + /* Connection closed by the client, end of server */
  86 + break;
  87 + } else {
104 88 printf("Error in modbus_listen (%d)\n", ret);
  89 + }
105 90 }
106 91  
107 92 close(socket);
... ...
tests/unit-test.h 0 → 100644
  View file @fa4f566
  1 +#ifndef _UNIT_TEST_H_
  2 +#define _UNIT_TEST_H_
  3 +
  4 +#include <stdint.h>
  5 +
  6 +const uint16_t UT_COIL_STATUS_ADDRESS = 0x13;
  7 +const uint16_t UT_COIL_STATUS_NB_POINTS = 0x25;
  8 +const uint8_t UT_COIL_STATUS_TAB[] = { 0xCD, 0x6B, 0xB2, 0x0E, 0x1B };
  9 +
  10 +const uint16_t UT_INPUT_STATUS_ADDRESS = 0xC4;
  11 +const uint16_t UT_INPUT_STATUS_NB_POINTS = 0x16;
  12 +const uint8_t UT_INPUT_STATUS_TAB[] = { 0xAC, 0xDB, 0x35 };
  13 +
  14 +const uint16_t UT_HOLDING_REGISTERS_ADDRESS = 0x6B;
  15 +const uint16_t UT_HOLDING_REGISTERS_NB_POINTS = 0x3;
  16 +const uint16_t UT_HOLDING_REGISTERS_TAB[] = { 0x022B, 0x0000, 0x0064 };
  17 +
  18 +const uint16_t UT_INPUT_REGISTERS_ADDRESS = 0x08;
  19 +const uint16_t UT_INPUT_REGISTERS_NB_POINTS = 0x1;
  20 +const uint16_t UT_INPUT_REGISTERS_TAB[] = { 0x000A };
  21 +
  22 +#endif /* _UNIT_TEST_H_ */
... ...