Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
#include "mb2hal.h"
retCode create_HAL_pins()
{
const char *fnct_name = "create_HAL_pins";
int tx_counter;
for (tx_counter = 0; tx_counter < gbl.tot_mb_tx; tx_counter++) {
if (create_each_mb_tx_hal_pins(&gbl.mb_tx[tx_counter]) != retOK) {
ERR(gbl.init_dbg, "failed to initialize hal pins in tx_num[%d] [%d] [%s]",
tx_counter, gbl.mb_tx[tx_counter].mb_tx_fnct, gbl.mb_tx[tx_counter].mb_tx_fnct_name);
return retERR;
}
}
return retOK;
}
#define CREATE_PIN(C, T, F)\
mb_tx->C = (T **)hal_malloc(sizeof(T *));\
if (mb_tx->C == NULL) {\
ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc num_errors",\
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name);\
return retERR;\
}\
memset(mb_tx->C, 0, sizeof(T *));\
snprintf(hal_pin_name, HAL_NAME_LEN, "%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, #C);\
if (0 != F(HAL_OUT, mb_tx->C, gbl.hal_mod_id, "%s", hal_pin_name)) {\
ERR(gbl.init_dbg, "[%d] [%s] [%s] " #F " pin failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);\
return retERR;\
}\
**(mb_tx->num_errors) = 0;\
DBG(gbl.init_dbg, "mb_tx_num [%d] pin_name [%s]", mb_tx->mb_tx_num, hal_pin_name);
retCode create_each_mb_tx_hal_pins(mb_tx_t *mb_tx)
{
const char *fnct_name = "create_each_mb_tx_hal_pins";
char hal_pin_name[HAL_NAME_LEN + 1];
int pin_counter;
if (mb_tx == NULL) {
ERR(gbl.init_dbg, "NULL pointer");
return retERR;
}
//num_errors hal pin
mb_tx->num_errors = (hal_u32_t**)hal_malloc(sizeof(hal_u32_t *));
if (mb_tx->num_errors == NULL) {
ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc num_errors",
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name);
return retERR;
}
memset(mb_tx->num_errors, 0, sizeof(hal_u32_t *));
snprintf(hal_pin_name, HAL_NAME_LEN, "%s.%s.num_errors", gbl.hal_mod_name, mb_tx->hal_tx_name);
if (0 != hal_pin_u32_newf(HAL_OUT, mb_tx->num_errors, gbl.hal_mod_id, "%s", hal_pin_name)) {
ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_u32_newf failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
return retERR;
}
**(mb_tx->num_errors) = 0;
DBG(gbl.init_dbg, "mb_tx_num [%d] pin_name [%s]", mb_tx->mb_tx_num, hal_pin_name);
// modbus_ok hal pin
CREATE_PIN(modbus_ok, hal_bit_t, hal_pin_bit_newf);
CREATE_PIN(cumul_errors, hal_s32_t, hal_pin_s32_newf);
CREATE_PIN(cumul_transactions, hal_s32_t, hal_pin_s32_newf);
if (!mb_tx->nb_hal_map_pin) { // Old fashioned pin management
switch (mb_tx->mb_tx_fnct) {
case mbtx_02_READ_DISCRETE_INPUTS:
case mbtx_15_WRITE_MULTIPLE_COILS:
case mbtx_05_WRITE_SINGLE_COIL:
mb_tx->bit = (hal_bit_t **)hal_malloc(sizeof(hal_bit_t *) * mb_tx->mb_tx_nelem);
if (mb_tx->bit == NULL) {
ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc [%d] elements",
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, mb_tx->mb_tx_nelem);
return retERR;
}
memset(mb_tx->bit, 0, sizeof(hal_bit_t *) * mb_tx->mb_tx_nelem);
break;
case mbtx_03_READ_HOLDING_REGISTERS:
case mbtx_04_READ_INPUT_REGISTERS:
case mbtx_16_WRITE_MULTIPLE_REGISTERS:
mb_tx->float_value= (hal_float_t **)hal_malloc(sizeof(hal_float_t *) * mb_tx->mb_tx_nelem);
mb_tx->int_value = (hal_s32_t **)hal_malloc(sizeof(hal_s32_t *) * mb_tx->mb_tx_nelem);
//mb_tx->scale = hal_malloc(sizeof(hal_float_t) * mb_tx->mb_tx_nelem);
//mb_tx->offset = hal_malloc(sizeof(hal_float_t) * mb_tx->mb_tx_nelem);
//if (mb_tx->float_value == NULL || mb_tx->int_value == NULL
// || mb_tx->scale == NULL || mb_tx->offset == NULL) {
if (mb_tx->float_value == NULL || mb_tx->int_value == NULL) {
ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc [%d] elements",
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, mb_tx->mb_tx_nelem);
return retERR;
}
memset(mb_tx->float_value, 0, sizeof(hal_float_t *) * mb_tx->mb_tx_nelem);
memset(mb_tx->int_value, 0, sizeof(hal_s32_t *) * mb_tx->mb_tx_nelem);
//memset((void *) mb_tx->scale, 0, sizeof(hal_float_t) * mb_tx->mb_tx_nelem);
//memset((void *) mb_tx->offset, 0, sizeof(hal_float_t) * mb_tx->mb_tx_nelem);
break;
default:
ERR(gbl.init_dbg, "[%d] wrong mb_tx_fnct", mb_tx->mb_tx_fnct);
return retERR;
break;
}
for (pin_counter = 0; pin_counter < mb_tx->mb_tx_nelem; pin_counter++) {
snprintf(hal_pin_name, HAL_NAME_LEN, "%s.%s.%02d", gbl.hal_mod_name, mb_tx->hal_tx_name, pin_counter);
DBG(gbl.init_dbg, "mb_tx_num [%d] pin_name [%s]", mb_tx->mb_tx_num, hal_pin_name);
switch (mb_tx->mb_tx_fnct) {
case mbtx_15_WRITE_MULTIPLE_COILS:
case mbtx_05_WRITE_SINGLE_COIL:
if (0 != hal_pin_bit_newf(HAL_IN, mb_tx->bit + pin_counter, gbl.hal_mod_id,
"%s", hal_pin_name)) {
ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_bit_newf failed",
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
return retERR;
}
*mb_tx->bit[pin_counter] = 0;
break;
case mbtx_02_READ_DISCRETE_INPUTS:
if (0 != hal_pin_bit_newf(HAL_OUT, mb_tx->bit + pin_counter, gbl.hal_mod_id,
"%s", hal_pin_name)) {
ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_bit_newf failed",
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
return retERR;
}
*mb_tx->bit[pin_counter] = 0;
break;
case mbtx_04_READ_INPUT_REGISTERS:
case mbtx_03_READ_HOLDING_REGISTERS:
if (0 != hal_pin_float_newf(HAL_OUT, mb_tx->float_value + pin_counter, gbl.hal_mod_id,
"%s.float", hal_pin_name)) {
ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_float_newf failed",
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
return retERR;
}
if (0 != hal_pin_s32_newf(HAL_OUT, mb_tx->int_value + pin_counter, gbl.hal_mod_id,
"%s.int", hal_pin_name)) {
ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_s32_newf failed",
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
return retERR;
}
*mb_tx->float_value[pin_counter] = 0;
*mb_tx->int_value[pin_counter] = 0;
break;
case mbtx_16_WRITE_MULTIPLE_REGISTERS:
if (0 != hal_pin_float_newf(HAL_IN, mb_tx->float_value + pin_counter, gbl.hal_mod_id,
"%s", hal_pin_name)) {
ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_float_newf failed",
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name);
return retERR;
}
*mb_tx->float_value[pin_counter] = 0;
break;
default:
ERR(gbl.init_dbg, "[%d]", mb_tx->mb_tx_fnct);
return retERR;
break;
}
}
}
else { // We are using enhanced pin mapping
hal_pin_dir_t dir;
switch (mb_tx->mb_tx_fnct) {
case mbtx_15_WRITE_MULTIPLE_COILS:
case mbtx_16_WRITE_MULTIPLE_REGISTERS:
case mbtx_05_WRITE_SINGLE_COIL:
dir = HAL_IN;
break;
case mbtx_02_READ_DISCRETE_INPUTS:
case mbtx_04_READ_INPUT_REGISTERS:
case mbtx_03_READ_HOLDING_REGISTERS:
dir = HAL_OUT;
break;
default:
ERR(gbl.init_dbg, "[%d]", mb_tx->mb_tx_fnct);
return retERR;
break;
}
mb_tx->pin_value = (hal_data_u **)hal_malloc(sizeof(hal_data_u *) * mb_tx->nb_hal_map_pin);
if (mb_tx->pin_value == NULL) {
ERR(gbl.init_dbg, "[%d] [%s] NULL hal_malloc [%d] pins",
mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, mb_tx->nb_hal_map_pin);
return retERR;
}
memset(mb_tx->pin_value, 0, sizeof(hal_data_u *) * mb_tx->nb_hal_map_pin);
for (int index=0; index<mb_tx->nb_hal_map_pin; index++) {
hal_map_pin_t *m = &mb_tx->hal_map_pin[index];
int rc = 1;
switch (m->type) {
case HAL_BIT:
rc = hal_pin_bit_newf(dir, (hal_bit_t **)mb_tx->pin_value + index, gbl.hal_mod_id,
"%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
break;
case HAL_FLOAT:
rc = hal_pin_float_newf(dir, (hal_float_t **)mb_tx->pin_value + index, gbl.hal_mod_id,
"%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
break;
case HAL_S32:
rc = hal_pin_s32_newf(dir, (hal_s32_t **)mb_tx->pin_value + index, gbl.hal_mod_id,
"%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
break;
case HAL_U32:
rc = hal_pin_u32_newf(dir, (hal_u32_t **)mb_tx->pin_value + index, gbl.hal_mod_id,
"%s.%s.%s", gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
break;
}
if (0 != rc) {
ERR(gbl.init_dbg, "hal_pin_xxx_newf(type=%d, name=%s.%s.%s) error",
m->type, gbl.hal_mod_name, mb_tx->hal_tx_name, m->name);
return retERR;
}
}
}
return retOK;
}