diff --git a/src/hal/user_comps/mb2hal/mb2hal.c b/src/hal/user_comps/mb2hal/mb2hal.c index ae5f6f1b2d2..0509a459711 100644 --- a/src/hal/user_comps/mb2hal/mb2hal.c +++ b/src/hal/user_comps/mb2hal/mb2hal.c @@ -224,15 +224,15 @@ void *link_loop_and_logic(void *thrd_link_num) } if (ret != retOK && modbus_get_socket(this_mb_link->modbus) < 0) { //link failure - (**this_mb_tx->num_errors)++; + hal_set_ui32(*this_mb_tx->num_errors, hal_get_ui32(*this_mb_tx->num_errors) + 1); ERR(this_mb_tx->cfg_debug, "mb_tx_num[%d] mb_links[%d] thread[%d] fd[%d] link failure, going to close link", this_mb_tx_num, this_mb_tx->mb_link_num, this_mb_link_num, modbus_get_socket(this_mb_link->modbus)); modbus_close(this_mb_link->modbus); } else if (ret != retOK) { //transaction failure but link OK - (**this_mb_tx->num_errors)++; + hal_set_ui32(*this_mb_tx->num_errors, hal_get_ui32(*this_mb_tx->num_errors) + 1); ERR(this_mb_tx->cfg_debug, "mb_tx_num[%d] mb_links[%d] thread[%d] fd[%d] transaction failure, num_errors[%u]", - this_mb_tx_num, this_mb_tx->mb_link_num, this_mb_link_num, modbus_get_socket(this_mb_link->modbus), **this_mb_tx->num_errors); + this_mb_tx_num, this_mb_tx->mb_link_num, this_mb_link_num, modbus_get_socket(this_mb_link->modbus), hal_get_ui32(*this_mb_tx->num_errors)); // Clear any unread data. Otherwise the link might get out of sync modbus_flush(this_mb_link->modbus); } @@ -241,7 +241,7 @@ void *link_loop_and_logic(void *thrd_link_num) this_mb_tx_num, this_mb_tx->mb_link_num, this_mb_link_num, modbus_get_socket(this_mb_link->modbus), 1.0/(get_time()-this_mb_tx->last_time_ok)); this_mb_tx->last_time_ok = get_time(); - (**this_mb_tx->num_errors) = 0; + hal_set_ui32(*this_mb_tx->num_errors, 0); } //set the next (waiting) time for update rate @@ -348,7 +348,7 @@ retCode get_tx_connection(const int this_mb_tx_num, int *ret_connected) ret = modbus_connect(this_mb_link->modbus); if (ret != 0 || modbus_get_socket(this_mb_link->modbus) < 0) { modbus_set_socket(this_mb_link->modbus, -1); //some times ret was < 0 and fd > 0 - (**this_mb_tx->num_errors)++; + hal_set_ui32(*this_mb_tx->num_errors, hal_get_ui32(*this_mb_tx->num_errors) + 1); ERR(this_mb_tx->cfg_debug, "mb_tx_num[%d] mb_links[%d] cannot connect to link, ret[%d] fd[%d]", this_mb_tx_num, this_mb_tx->mb_link_num, ret, modbus_get_socket(this_mb_link->modbus)); return retOK; //not connected diff --git a/src/hal/user_comps/mb2hal/mb2hal.h b/src/hal/user_comps/mb2hal/mb2hal.h index 409c9562005..37edf9fd8f4 100644 --- a/src/hal/user_comps/mb2hal/mb2hal.h +++ b/src/hal/user_comps/mb2hal/mb2hal.h @@ -102,13 +102,13 @@ typedef struct { double last_time_ok; //last OK tx time //HAL related params char hal_tx_name[HAL_NAME_LEN + 1]; - hal_float_t **float_value; - hal_s32_t **int_value; - //hal_float_t *scale; //not yet implemented - //hal_float_t *offset; //not yet implemented - hal_bit_t **bit; - hal_bit_t **bit_inv; - hal_u32_t **num_errors; //num of acummulated errors (0=last tx OK) + hal_real_t *float_value; + hal_sint_t *int_value; + //hal_real_t *scale; //not yet implemented + //hal_real_t *offset; //not yet implemented + hal_bool_t *bit; + hal_bool_t *bit_inv; + hal_uint_t *num_errors; //num of acummulated errors (0=last tx OK) } mb_tx_t; //Modbus link structure (mb_link_t) diff --git a/src/hal/user_comps/mb2hal/mb2hal_hal.c b/src/hal/user_comps/mb2hal/mb2hal_hal.c index a9637c42600..45080fdefb3 100644 --- a/src/hal/user_comps/mb2hal/mb2hal_hal.c +++ b/src/hal/user_comps/mb2hal/mb2hal_hal.c @@ -29,19 +29,18 @@ retCode create_each_mb_tx_hal_pins(mb_tx_t *mb_tx) } //num_errors hal pin - mb_tx->num_errors = hal_malloc(sizeof(hal_u32_t *)); + mb_tx->num_errors = hal_malloc(sizeof(*mb_tx->num_errors)); 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 *)); + memset(mb_tx->num_errors, 0, sizeof(*mb_tx->num_errors)); ret = snprintf(hal_pin_name, HAL_NAME_LEN, "%s.%s.num_errors", gbl.hal_mod_name, mb_tx->hal_tx_name); - if (ret >= HAL_NAME_LEN || ret < 0 || 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); + if (ret >= HAL_NAME_LEN || ret < 0 || 0 != (ret = hal_pin_new_ui32(gbl.hal_mod_id, HAL_OUT, mb_tx->num_errors, 0, "%s", hal_pin_name))) { + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_ui32 failed (ret=%d)", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name, ret); 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); switch (mb_tx->mb_tx_fnct) { @@ -50,26 +49,26 @@ retCode create_each_mb_tx_hal_pins(mb_tx_t *mb_tx) case mbtx_02_READ_DISCRETE_INPUTS: case mbtx_05_WRITE_SINGLE_COIL: case mbtx_15_WRITE_MULTIPLE_COILS: - mb_tx->bit = hal_malloc(sizeof(hal_bit_t *) * mb_tx->mb_tx_nelem); - mb_tx->bit_inv = hal_malloc(sizeof(hal_bit_t *) * mb_tx->mb_tx_nelem); + mb_tx->bit = hal_malloc(sizeof(*mb_tx->bit) * mb_tx->mb_tx_nelem); + mb_tx->bit_inv = hal_malloc(sizeof(*mb_tx->bit_inv) * mb_tx->mb_tx_nelem); if (mb_tx->bit == NULL || mb_tx->bit_inv == 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); - memset(mb_tx->bit_inv, 0, sizeof(hal_bit_t *) * mb_tx->mb_tx_nelem); + memset(mb_tx->bit, 0, sizeof(*mb_tx->bit) * mb_tx->mb_tx_nelem); + memset(mb_tx->bit_inv, 0, sizeof(*mb_tx->bit_inv) * mb_tx->mb_tx_nelem); break; case mbtx_03_READ_HOLDING_REGISTERS: case mbtx_04_READ_INPUT_REGISTERS: case mbtx_06_WRITE_SINGLE_REGISTER: case mbtx_16_WRITE_MULTIPLE_REGISTERS: - mb_tx->float_value= hal_malloc(sizeof(hal_float_t *) * mb_tx->mb_tx_nelem); - mb_tx->int_value = 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); + mb_tx->float_value= hal_malloc(sizeof(*mb_tx->float_value) * mb_tx->mb_tx_nelem); + mb_tx->int_value = hal_malloc(sizeof(*mb_tx->int_value) * mb_tx->mb_tx_nelem); + //mb_tx->scale = hal_malloc(sizeof(*mb_tx->scale ) * mb_tx->mb_tx_nelem); + //mb_tx->offset = hal_malloc(sizeof(*mb_tx->offset) * 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) { @@ -77,10 +76,10 @@ retCode create_each_mb_tx_hal_pins(mb_tx_t *mb_tx) 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); + memset(mb_tx->float_value, 0, sizeof(*mb_tx->float_value) * mb_tx->mb_tx_nelem); + memset(mb_tx->int_value, 0, sizeof(*mb_tx->int_value) * mb_tx->mb_tx_nelem); + //memset(mb_tx->scale, 0, sizeof(*mb_tx->scale ) * mb_tx->mb_tx_nelem); + //memset(mb_tx->offset, 0, sizeof(*mb_tx->offset) * mb_tx->mb_tx_nelem); break; default: @@ -102,115 +101,102 @@ retCode create_each_mb_tx_hal_pins(mb_tx_t *mb_tx) case mbtx_05_WRITE_SINGLE_COIL: case mbtx_15_WRITE_MULTIPLE_COILS: if(gbl.version < 1001){ - if (0 != hal_pin_bit_newf(HAL_IN, mb_tx->bit + pin_counter, gbl.hal_mod_id, + if (0 != hal_pin_new_bool(gbl.hal_mod_id, HAL_IN, mb_tx->bit + pin_counter, 0, "%s", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_bit_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_bool failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); return retERR; } } else { - if (0 != hal_pin_bit_newf(HAL_IN, mb_tx->bit + pin_counter, gbl.hal_mod_id, + if (0 != hal_pin_new_bool(gbl.hal_mod_id, HAL_IN, mb_tx->bit + pin_counter, 0, "%s.bit", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_bit_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_bool 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_01_READ_COILS: case mbtx_02_READ_DISCRETE_INPUTS: if (gbl.version < 1001) { - if (0 != hal_pin_bit_newf(HAL_OUT, mb_tx->bit + pin_counter, gbl.hal_mod_id, + if (0 != hal_pin_new_bool(gbl.hal_mod_id, HAL_OUT, mb_tx->bit + pin_counter, 0, "%s", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_bit_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_bool failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); return retERR; } - *mb_tx->bit[pin_counter] = 0; } else { - if (0 != hal_pin_bit_newf(HAL_OUT, mb_tx->bit + pin_counter, gbl.hal_mod_id, + if (0 != hal_pin_new_bool(gbl.hal_mod_id, HAL_OUT, mb_tx->bit + pin_counter, 0, "%s.bit", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_bit_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_bool failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); return retERR; } - if (0 != hal_pin_bit_newf(HAL_OUT, mb_tx->bit_inv + pin_counter, gbl.hal_mod_id, + if (0 != hal_pin_new_bool(gbl.hal_mod_id, HAL_OUT, mb_tx->bit_inv + pin_counter, 1, "%s.bit-inv", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_bit_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_bool failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); return retERR; } - *mb_tx->bit[pin_counter] = 0; - *mb_tx->bit_inv[pin_counter] = 1; } 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, + if (0 != hal_pin_new_real(gbl.hal_mod_id, HAL_OUT, mb_tx->float_value + pin_counter, 0.0, "%s.float", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_float_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_real 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, + if (0 != hal_pin_new_si32(gbl.hal_mod_id, HAL_OUT, mb_tx->int_value + pin_counter, 0, "%s.int", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_s32_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_si32 failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); return retERR; } - //if (0 != hal_param_float_newf(HAL_RW, mb_tx->scale + pin_counter, gbl.hal_mod_id, + //if (0 != hal_param_new_real(gbl.hal_mod_id, HAL_RW, mb_tx->scale + pin_counter, 1.0, // "%s.scale", hal_pin_name)) { // ERR(gbl.init_dbg, "[%d] [%s] [%s]", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); // return retERR; //} - //if (0 != hal_param_float_newf(HAL_RW, mb_tx->offset + pin_counter, gbl.hal_mod_id, + //if (0 != hal_param_new_real(gbl.hal_mod_id, HAL_RW, mb_tx->offset + pin_counter, 0.0 // "%s.offset", hal_pin_name)) { // ERR(gbl.init_dbg, "[%d] [%s] [%s]", 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; - //mb_tx->scale[pin_counter] = 1; - //mb_tx->offset[pin_counter] = 0; break; case mbtx_06_WRITE_SINGLE_REGISTER: case mbtx_16_WRITE_MULTIPLE_REGISTERS: if (gbl.version < 1001) { - if (0 != hal_pin_float_newf(HAL_IN, mb_tx->float_value + pin_counter, gbl.hal_mod_id, + if (0 != hal_pin_new_real(gbl.hal_mod_id, HAL_IN, mb_tx->float_value + pin_counter, 0.0, "%s", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_float_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_real failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); return retERR; } - *mb_tx->float_value[pin_counter] = 0; } else { - if (0 != hal_pin_float_newf(HAL_IN, mb_tx->float_value + pin_counter, gbl.hal_mod_id, + if (0 != hal_pin_new_real(gbl.hal_mod_id, HAL_IN, mb_tx->float_value + pin_counter, 0.0, "%s.float", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_float_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_real failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); return retERR; } - if (0 != hal_pin_s32_newf(HAL_IN, mb_tx->int_value + pin_counter, gbl.hal_mod_id, + if (0 != hal_pin_new_si32(gbl.hal_mod_id, HAL_IN, mb_tx->int_value + pin_counter, 0, "%s.int", hal_pin_name)) { - ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_s32_newf failed", + ERR(gbl.init_dbg, "[%d] [%s] [%s] hal_pin_new_si32 failed", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); return retERR; } - //if (0 != hal_param_float_newf(HAL_RW, mb_tx->scale + pin_counter, gbl.hal_mod_id, + //if (0 != hal_param_new_real(gbl.hal_mod_id, HAL_RW, mb_tx->scale + pin_counter, 1.0 // "%s.scale", hal_pin_name)) { // ERR(gbl.init_dbg, "[%d] [%s] [%s]", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name, hal_pin_name); // return retERR; //} - //if (0 != hal_param_float_newf(HAL_RW, mb_tx->offset + pin_counter, gbl.hal_mod_id, + //if (0 != hal_param_new_real(gbl.hal_mod_id, HAL_RW, mb_tx->offset + pin_counter, 0.0 // "%s.offset", hal_pin_name)) { // ERR(gbl.init_dbg, "[%d] [%s]", mb_tx->mb_tx_fnct, mb_tx->mb_tx_fnct_name); // return retERR; //} - *mb_tx->float_value[pin_counter] = 0; - *mb_tx->int_value[pin_counter] = 0; - //mb_tx->scale[pin_counter] = 1; - //mb_tx->offset[pin_counter] = 0; } break; default: diff --git a/src/hal/user_comps/mb2hal/mb2hal_modbus.c b/src/hal/user_comps/mb2hal/mb2hal_modbus.c index 40817812a29..b0ba9a7b3d7 100644 --- a/src/hal/user_comps/mb2hal/mb2hal_modbus.c +++ b/src/hal/user_comps/mb2hal/mb2hal_modbus.c @@ -30,8 +30,8 @@ retCode fnct_01_read_coils(mb_tx_t *this_mb_tx, mb_link_t *this_mb_link) } for (counter = 0; counter < this_mb_tx->mb_tx_nelem; counter++) { - *(this_mb_tx->bit[counter]) = bits[counter]; - *(this_mb_tx->bit_inv[counter]) = !bits[counter]; + hal_set_bool(this_mb_tx->bit[counter], bits[counter]); + hal_set_bool(this_mb_tx->bit_inv[counter], !bits[counter]); } return retOK; @@ -66,9 +66,9 @@ retCode fnct_02_read_discrete_inputs(mb_tx_t *this_mb_tx, mb_link_t *this_mb_lin } for (counter = 0; counter < this_mb_tx->mb_tx_nelem; counter++) { - *(this_mb_tx->bit[counter]) = bits[counter]; + hal_set_bool(this_mb_tx->bit[counter], bits[counter]); if (gbl.version > 1000) - *(this_mb_tx->bit_inv[counter]) = !bits[counter]; + hal_set_bool(this_mb_tx->bit_inv[counter], !bits[counter]); } return retOK; @@ -104,10 +104,10 @@ retCode fnct_03_read_holding_registers(mb_tx_t *this_mb_tx, mb_link_t *this_mb_l for (counter = 0; counter < this_mb_tx->mb_tx_nelem; counter++) { float val = data[counter]; - //val *= this_mb_tx->scale[counter]; - //val += this_mb_tx->offset[counter]; - *(this_mb_tx->float_value[counter]) = val; - *(this_mb_tx->int_value[counter]) = data[counter]; + //val *= hal_get_real(this_mb_tx->scale[counter]); + //val += hal_get_real(this_mb_tx->offset[counter]); + hal_set_real(this_mb_tx->float_value[counter], val); + hal_set_si32(this_mb_tx->int_value[counter], data[counter]); } return retOK; @@ -143,10 +143,10 @@ retCode fnct_04_read_input_registers(mb_tx_t *this_mb_tx, mb_link_t *this_mb_lin for (counter = 0; counter < this_mb_tx->mb_tx_nelem; counter++) { float val = data[counter]; - //val += this_mb_tx->offset[counter]; - //val *= this_mb_tx->scale[counter]; - *(this_mb_tx->float_value[counter]) = val; - *(this_mb_tx->int_value[counter]) = data[counter]; + //val += hal_get_real(this_mb_tx->offset[counter]); + //val *= hal_get_real(this_mb_tx->scale[counter]); + hal_set_real(this_mb_tx->float_value[counter], val); + hal_set_si32(this_mb_tx->int_value[counter], data[counter]); } return retOK; @@ -164,7 +164,7 @@ retCode fnct_05_write_single_coil(mb_tx_t *this_mb_tx, mb_link_t *this_mb_link) return retERR; } - bit = *(this_mb_tx->bit[0]); + bit = hal_get_bool(this_mb_tx->bit[0]); DBG(this_mb_tx->cfg_debug, "mb_tx[%d] mb_links[%d] slave[%d] fd[%d] 1st_addr[%d] nelem[%d]", this_mb_tx->mb_tx_num, this_mb_tx->mb_link_num, this_mb_tx->mb_tx_slave_id, @@ -196,9 +196,9 @@ retCode fnct_06_write_single_register(mb_tx_t *this_mb_tx, mb_link_t *this_mb_li return retERR; } - data = *(this_mb_tx->float_value[0]); + data = hal_get_real(this_mb_tx->float_value[0]); if (gbl.version > 1000) - data += *(this_mb_tx->int_value[0]); + data += hal_get_si32(this_mb_tx->int_value[0]); if(data > UINT16_MAX) { // prevent wrap on overflow data = UINT16_MAX; } @@ -235,7 +235,7 @@ retCode fnct_15_write_multiple_coils(mb_tx_t *this_mb_tx, mb_link_t *this_mb_lin } for (counter = 0; counter < this_mb_tx->mb_tx_nelem; counter++) { - bits[counter] = *(this_mb_tx->bit[counter]); + bits[counter] = hal_get_bool(this_mb_tx->bit[counter]); } DBG(this_mb_tx->cfg_debug, "mb_tx[%d] mb_links[%d] slave[%d] fd[%d] 1st_addr[%d] nelem[%d]", @@ -270,11 +270,11 @@ retCode fnct_16_write_multiple_registers(mb_tx_t *this_mb_tx, mb_link_t *this_mb } for (counter = 0; counter < this_mb_tx->mb_tx_nelem; counter++) { - //float val = *(this_mb_tx->float_value[counter]) / this_mb_tx->scale[counter]; - //val -= this_mb_tx->offset[counter]; - int data32 = (uint16_t) *(this_mb_tx->float_value[counter]); + //float val = hal_get_real(this_mb_tx->float_value[counter]) / hal_get_real(this_mb_tx->scale[counter]); + //val -= hal_get_real(this_mb_tx->offset[counter]); + int data32 = (uint16_t) hal_get_real(this_mb_tx->float_value[counter]); if (gbl.version > 1000) - data32 += *(this_mb_tx->int_value[counter]); + data32 += hal_get_si32(this_mb_tx->int_value[counter]); if(data32 > UINT16_MAX) { // prevent wrap on overflow data[counter] = UINT16_MAX; }