Peter M. Groen / libmodbus

Commit 1d058c8e5e5cb268d5f75da26c8ebbc8aa703931

Authored by Stéphane Raimbault
1 parent fa4f566b

Major changes to test-master-random 

- Use only addresses between address_start and address_end
- Better memory usage
Inline Side-by-side
Showing 1 changed file with 133 additions and 128 deletions
tests/test-master-random.c
  View file @1d058c8
@@ -35,25 +35,27 @@ @@ -35,25 +35,27 @@
35 - read_holding_registers 35 - read_holding_registers
36 36
37 All these functions are called with random values on a address 37 All these functions are called with random values on a address
38 - range defined by following defines.  
39 -  
40 - This program is also really useful to test your remote target unit. 38 + range defined by the following defines.
41 */ 39 */
42 -#define LOOP 1  
43 -#define SLAVE 0x11  
44 -#define ADDR_MIN 0  
45 -#define ADDR_MAX 499  
46 -#define FIELDS 500 40 +#define LOOP 1
  41 +#define SLAVE 0x11
  42 +#define ADDRESS_START 0
  43 +#define ADDRESS_END 499
47 44
  45 +/* At each loop, the program works in the range ADDRESS_START to
  46 + * ADDRESS_END then ADDRESS_START + 1 to ADDRESS_END and so on.
  47 + */
48 int main(void) 48 int main(void)
49 { 49 {
50 - int ok, fail;  
51 - int loop_nb; 50 + int ret;
  51 + int nb_fail;
  52 + int nb_loop;
52 int addr; 53 int addr;
53 - int field_nb;  
54 - int *tab_rq;  
55 - int *tab_rq_bits;  
56 - int *tab_rp; 54 + int nb_points_total;
  55 + uint8_t *tab_rq_status;
  56 + uint8_t *tab_rp_status;
  57 + uint16_t *tab_rq_registers;
  58 + uint16_t *tab_rp_registers;
57 modbus_param_t mb_param; 59 modbus_param_t mb_param;
58 60
59 /* RTU parity : none, even, odd */ 61 /* RTU parity : none, even, odd */
@@ -66,141 +68,144 @@ int main(void) @@ -66,141 +68,144 @@ int main(void)
66 modbus_connect(&mb_param); 68 modbus_connect(&mb_param);
67 69
68 /* Allocate and initialize the different memory spaces */ 70 /* Allocate and initialize the different memory spaces */
69 - tab_rq = (int *) malloc(FIELDS * sizeof(int));  
70 - memset(tab_rq, 0, FIELDS * sizeof(int));  
71 -  
72 - tab_rq_bits = (int *) malloc(FIELDS * sizeof(int));  
73 - memset(tab_rq_bits, 0, FIELDS * sizeof(int));  
74 -  
75 - tab_rp = (int *) malloc(FIELDS * sizeof(int));  
76 - memset(tab_rp, 0, FIELDS * sizeof(int));  
77 -  
78 - loop_nb = ok = fail = 0;  
79 - while (loop_nb++ < LOOP) {  
80 - for (addr=ADDR_MIN; addr <= ADDR_MAX; addr++) {  
81 - for (field_nb=1; field_nb<=FIELDS; field_nb++) {  
82 - int i;  
83 -  
84 - /* Random numbers (short) */  
85 - for (i=0; i<field_nb; i++) {  
86 - tab_rq[i] = (int) (16536.0*rand()/(RAND_MAX+1.0));  
87 - tab_rq_bits[i] = (i) % 2; 71 + nb_points_total = ADDRESS_END - ADDRESS_START;
  72 +
  73 + tab_rq_status = (uint8_t *) malloc(nb_points_total * sizeof(uint8_t));
  74 + memset(tab_rq_status, 0, nb_points_total * sizeof(uint8_t));
  75 + tab_rp_status = (uint8_t *) malloc(nb_points_total * sizeof(uint8_t));
  76 + memset(tab_rp_status, 0, nb_points_total * sizeof(uint8_t));
  77 +
  78 + tab_rq_registers = (uint16_t *) malloc(nb_points_total * sizeof(uint16_t));
  79 + memset(tab_rq_registers, 0, nb_points_total * sizeof(uint16_t));
  80 + tab_rp_registers = (uint16_t *) malloc(nb_points_total * sizeof(uint16_t));
  81 + memset(tab_rp_status, 0, nb_points_total * sizeof(uint16_t));
  82 +
  83 + nb_loop = nb_fail = 0;
  84 + while (nb_loop++ < LOOP) {
  85 + for (addr = ADDRESS_START; addr <= ADDRESS_END; addr++) {
  86 + int i;
  87 + int nb_points;
  88 +
  89 + /* Random numbers (short) */
  90 + for (i=0; i<nb_points_total; i++) {
  91 + tab_rq_registers[i] = (uint16_t) (65535.0*rand() / (RAND_MAX + 1.0));
  92 + tab_rq_status[i] = tab_rq_registers[i] % 2;
  93 + }
  94 + nb_points = ADDRESS_END - addr;
  95 +
  96 + /* SINGLE COIL */
  97 + ret = force_single_coil(&mb_param, SLAVE, addr, tab_rq_status[0]);
  98 + if (ret != 1) {
  99 + printf("ERROR force_single_coil (%d)\n", ret);
  100 + printf("Slave = %d, address = %d, value = %d\n",
  101 + SLAVE, addr, tab_rq_status[0]);
  102 + nb_fail++;
  103 + } else {
  104 + ret = read_coil_status(&mb_param, SLAVE, addr, 1, tab_rp_status);
  105 + if (ret != 1 || tab_rq_status[0] != tab_rp_status[0]) {
  106 + printf("ERROR read_coil_status single (%d)\n", ret);
  107 + printf("Slave = %d, address = %d\n",
  108 + SLAVE, addr);
  109 + nb_fail++;
88 } 110 }
  111 + }
89 112
90 - /* SINGLE COIL */  
91 - ok = force_single_coil(&mb_param, SLAVE, addr, tab_rq_bits[0]);  
92 - if (ok != 1) {  
93 - printf("ERROR force_single_coil (%d)\n", ok);  
94 - printf("Slave = %d, address = %d, value = %d\n",  
95 - SLAVE, addr, tab_rq_bits[0]);  
96 - fail++; 113 + /* MULTIPLE COILS */
  114 + ret = force_multiple_coils(&mb_param, SLAVE, addr, nb_points, tab_rq_status);
  115 + if (ret != nb_points) {
  116 + printf("ERROR force_multiple_coils (%d)\n", ret);
  117 + printf("Slave = %d, address = %d, nb_points = %d\n",
  118 + SLAVE, addr, nb_points);
  119 + nb_fail++;
  120 + } else {
  121 + ret = read_coil_status(&mb_param, SLAVE, addr, nb_points, tab_rp_status);
  122 + if (ret != nb_points) {
  123 + printf("ERROR read_coil_status\n");
  124 + printf("Slave = %d, address = %d, nb_points = %d\n",
  125 + SLAVE, addr, nb_points);
  126 + nb_fail++;
97 } else { 127 } else {
98 - ok = read_coil_status(&mb_param, SLAVE, addr, 1, tab_rp);  
99 - if (ok != 1 || tab_rq_bits[0] != tab_rp[0]) {  
100 - printf("ERROR read_coil_status single (%d)\n", ok);  
101 - printf("Slave = %d, address = %d\n",  
102 - SLAVE, addr);  
103 - fail++; 128 + for (i=0; i<nb_points; i++) {
  129 + if (tab_rp_status[i] != tab_rq_status[i]) {
  130 + printf("ERROR read_coil_status ");
  131 + printf("(%d != %d)\n", tab_rp_status[i], tab_rq_status[i]);
  132 + printf("Slave = %d, address = %d\n",
  133 + SLAVE, addr);
  134 + nb_fail++;
  135 + }
104 } 136 }
105 } 137 }
  138 + }
106 139
107 - /* MULTIPLE COILS */  
108 - ok = force_multiple_coils(&mb_param, SLAVE, addr, field_nb, tab_rq_bits);  
109 - if (ok != field_nb) {  
110 - printf("ERROR force_multiple_coils (%d)\n", ok);  
111 - printf("Slave = %d, address = %d, field_nb = %d\n",  
112 - SLAVE, addr, field_nb);  
113 - fail++; 140 + /* SINGLE REGISTER */
  141 + ret = preset_single_register(&mb_param, SLAVE, addr, tab_rq_registers[0]);
  142 + if (ret != 1) {
  143 + printf("ERROR preset_single_register (%d)\n", ret);
  144 + printf("Slave = %d, address = %d, value = %d\n",
  145 + SLAVE, addr, tab_rq_registers[0]);
  146 + nb_fail++;
  147 + } else {
  148 + ret = read_holding_registers(&mb_param, SLAVE,
  149 + addr, 1, tab_rp_registers);
  150 + if (ret != 1) {
  151 + printf("ERROR read_holding_registers single (%d)\n", ret);
  152 + printf("Slave = %d, address = %d\n",
  153 + SLAVE, addr);
  154 + nb_fail++;
114 } else { 155 } else {
115 - ok = read_coil_status(&mb_param, SLAVE, addr,  
116 - field_nb, tab_rp);  
117 - if (ok != field_nb) {  
118 - printf("ERROR read_coil_status\n");  
119 - printf("Slave = %d, address = %d, field_nb = %d\n",  
120 - SLAVE, addr, field_nb);  
121 - fail++;  
122 - } else {  
123 - for (i=0; i<field_nb; i++) {  
124 - if (tab_rp[i] != tab_rq_bits[i]) {  
125 - printf("ERROR read_coil_status ");  
126 - printf("(%d != %d)\n", tab_rp[i], tab_rq_bits[i]);  
127 - printf("Slave = %d, address = %d\n",  
128 - SLAVE, addr);  
129 - fail++;  
130 - }  
131 - } 156 + if (tab_rq_registers[0] != tab_rp_registers[0]) {
  157 + printf("ERROR read_holding_registers single ");
  158 + printf("(%d != %d)\n",
  159 + tab_rq_registers[0], tab_rp_registers[0]);
  160 + printf("Slave = %d, address = %d\n",
  161 + SLAVE, addr);
  162 + nb_fail++;
132 } 163 }
133 } 164 }
134 -  
135 - /* SINGLE REGISTER */  
136 - ok = preset_single_register(&mb_param, SLAVE, addr, tab_rq[0]);  
137 - if (ok != 1) {  
138 - printf("ERROR preset_single_register (%d)\n", ok);  
139 - printf("Slave = %d, address = %d, value = %d\n",  
140 - SLAVE, addr, tab_rq[0]);  
141 - fail++; 165 + }
  166 +
  167 + /* MULTIPLE REGISTERS */
  168 + ret = preset_multiple_registers(&mb_param, SLAVE,
  169 + addr, nb_points, tab_rq_registers);
  170 + if (ret != nb_points) {
  171 + printf("ERROR preset_multiple_registers (%d)\n", ret);
  172 + printf("Slave = %d, address = %d, nb_points = %d\n",
  173 + SLAVE, addr, nb_points);
  174 + nb_fail++;
  175 + } else {
  176 + ret = read_holding_registers(&mb_param, SLAVE,
  177 + addr, nb_points, tab_rp_registers);
  178 + if (ret != nb_points) {
  179 + printf("ERROR read_holding_registers (%d)\n", ret);
  180 + printf("Slave = %d, address = %d, nb_points = %d\n",
  181 + SLAVE, addr, nb_points);
  182 + nb_fail++;
142 } else { 183 } else {
143 - ok = read_holding_registers(&mb_param, SLAVE,  
144 - addr, 1, tab_rp);  
145 - if (ok != 1) {  
146 - printf("ERROR read_holding_registers single (%d)\n", ok);  
147 - printf("Slave = %d, address = %d\n",  
148 - SLAVE, addr);  
149 - fail++;  
150 - } else {  
151 - if (tab_rq[0] != tab_rp[0]) {  
152 - printf("ERROR read_holding_registers single "); 184 + for (i=0; i<nb_points; i++) {
  185 + if (tab_rq_registers[i] != tab_rp_registers[i]) {
  186 + printf("ERROR read_holding_registers ");
153 printf("(%d != %d)\n", 187 printf("(%d != %d)\n",
154 - tab_rq[0], tab_rp[0]); 188 + tab_rq_registers[i], tab_rp_registers[i]);
155 printf("Slave = %d, address = %d\n", 189 printf("Slave = %d, address = %d\n",
156 SLAVE, addr); 190 SLAVE, addr);
157 - fail++;  
158 - }  
159 - }  
160 - }  
161 -  
162 - /* MULTIPLE REGISTERS */  
163 - ok = preset_multiple_registers(&mb_param, SLAVE,  
164 - addr, field_nb, tab_rq);  
165 - if (ok != field_nb) {  
166 - printf("ERROR preset_multiple_registers (%d)\n", ok);  
167 - printf("Slave = %d, address = %d, field_nb = %d\n",  
168 - SLAVE, addr, field_nb);  
169 - fail++;  
170 - } else {  
171 - ok = read_holding_registers(&mb_param, SLAVE,  
172 - addr, field_nb, tab_rp);  
173 - if (ok != field_nb) {  
174 - printf("ERROR read_holding_registers (%d)\n", ok);  
175 - printf("Slave = %d, address = %d, field_nb = %d\n",  
176 - SLAVE, addr, field_nb);  
177 - fail++;  
178 - } else {  
179 - for (i=0; i<field_nb; i++) {  
180 - if (tab_rq[i] != tab_rp[i]) {  
181 - printf("ERROR read_holding_registers ");  
182 - printf("(%d != %d)\n",  
183 - tab_rq[i], tab_rp[i]);  
184 - printf("Slave = %d, address = %d\n",  
185 - SLAVE, addr);  
186 - fail++;  
187 - } 191 + nb_fail++;
188 } 192 }
189 } 193 }
190 } 194 }
191 } 195 }
192 -  
193 - if (fail)  
194 - printf("Address : %d - Fails sum : %d\n", addr, fail);  
195 - else  
196 - printf("Address : %d - OK\n", addr);  
197 } 196 }
  197 +
  198 + if (nb_fail)
  199 + printf("Address: %d - nb of fails: %d\n", addr, nb_fail);
  200 + else
  201 + printf("Address: %d - OK\n", addr);
198 } 202 }
199 203
200 /* Free the memory */ 204 /* Free the memory */
201 - free(tab_rp);  
202 - free(tab_rq);  
203 - free(tab_rq_bits); 205 + free(tab_rp_status);
  206 + free(tab_rq_status);
  207 + free(tab_rp_registers);
  208 + free(tab_rq_registers);
204 209
205 /* Close the connection */ 210 /* Close the connection */
206 modbus_close(&mb_param); 211 modbus_close(&mb_param);