int read_data(modbus_param_t *param, slavedata_t *slavedata, haldata_t *hal_data_block) {
int receive_data[MAX_READ_HOLD_REGS]; /* a little padding in there */
int retval;
/* can't do anything with a null HAL data block */
if (hal_data_block == NULL)
return -1;
/* but we can signal an error if the other params are null */
if ((param==NULL) || (slavedata == NULL)) {
hal_data_block->errorcount++;
return -1;
}
retval = read_holding_registers(param, slavedata->slave, slavedata->read_reg_start,
slavedata->read_reg_count, receive_data);
if (retval==slavedata->read_reg_count) {
retval = 0;
hal_data_block->retval = retval;
if (retval==0) {
*(hal_data_block->stat1) = receive_data[0];
*(hal_data_block->stat2) = receive_data[1];
*(hal_data_block->freq_cmd) = receive_data[2] * 0.1;
*(hal_data_block->freq_out) = receive_data[3] * 0.1;
if (receive_data[3]==0){ // JET if freq out is 0 then the drive is stopped
*(hal_data_block->is_stopped) = 1;
} else {
*(hal_data_block->is_stopped) = 0;
}
*(hal_data_block->curr_out) = receive_data[4] * 0.1;
*(hal_data_block->DCBusV) = receive_data[5] * 0.1;
*(hal_data_block->outV) = receive_data[6] * 0.1;
*(hal_data_block->RPM) = receive_data[7];
*(hal_data_block->scale_freq) = (receive_data[8] | (receive_data[9] << 16)) * 0.1;
*(hal_data_block->power_factor) = receive_data[10];
*(hal_data_block->load_pct) = receive_data[11] * 0.1;
*(hal_data_block->FW_Rev) = receive_data[12];
retval = 0;
}
} else {
hal_data_block->retval = retval;
hal_data_block->errorcount++;
retval = -1;
}
return retval;
}
int main(void)
{
uint8_t *tab_rp_status;
uint16_t *tab_rp_registers;
modbus_param_t mb_param;
int i;
uint8_t value;
int address;
int nb_points;
int ret;
/* 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);*/
if (modbus_connect(&mb_param) == -1) {
printf("ERROR Connection failed\n");
exit(1);
}
/* 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));
printf("** UNIT TESTING **\n");
printf("\nTEST WRITE/READ:\n");
/** COIL STATUS **/
/* Single */
ret = force_single_coil(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, ON);
printf("1/2 force_single_coil: ");
if (ret == 1) {
printf("OK\n");
} else {
printf("FAILED\n");
goto close;
}
ret = read_coil_status(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, 1,
tab_rp_status);
printf("2/2 read_coil_status: ");
if (ret != 1) {
printf("FAILED (nb points %d)\n", ret);
goto close;
}
if (tab_rp_status[0] != ON) {
printf("FAILED (%0X = != %0X)\n", tab_rp_status[0], ON);
goto close;
}
printf("OK\n");
/* End single */
/* Multiple coils */
{
uint8_t tab_value[UT_COIL_STATUS_NB_POINTS];
set_bits_from_bytes(tab_value, 0, UT_COIL_STATUS_NB_POINTS,
UT_COIL_STATUS_TAB);
ret = force_multiple_coils(&mb_param, SLAVE,
UT_COIL_STATUS_ADDRESS,
UT_COIL_STATUS_NB_POINTS,
tab_value);
printf("1/2 force_multiple_coils: ");
if (ret == UT_COIL_STATUS_NB_POINTS) {
printf("OK\n");
} else {
printf("FAILED\n");
goto close;
}
}
ret = read_coil_status(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS,
UT_COIL_STATUS_NB_POINTS, tab_rp_status);
printf("2/2 read_coil_status: ");
if (ret != UT_COIL_STATUS_NB_POINTS) {
printf("FAILED (nb points %d)\n", ret);
goto close;
}
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("FAILED (%0X != %0X)\n",
value, UT_COIL_STATUS_TAB[i]);
goto close;
}
nb_points -= nb_bits;
i++;
}
printf("OK\n");
/* End of multiple coils */
/** INPUT STATUS **/
ret = read_input_status(&mb_param, SLAVE, UT_INPUT_STATUS_ADDRESS,
UT_INPUT_STATUS_NB_POINTS, tab_rp_status);
printf("1/1 read_input_status: ");
if (ret != UT_INPUT_STATUS_NB_POINTS) {
printf("FAILED (nb points %d)\n", ret);
goto close;
}
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("FAILED (%0X != %0X)\n",
value, UT_INPUT_STATUS_TAB[i]);
goto close;
}
nb_points -= nb_bits;
i++;
}
printf("OK\n");
/** HOLDING REGISTERS **/
/* Single register */
ret = preset_single_register(&mb_param, SLAVE,
UT_HOLDING_REGISTERS_ADDRESS, 0x1234);
printf("1/2 preset_single_register: ");
if (ret == 1) {
printf("OK\n");
} else {
printf("FAILED\n");
goto close;
}
ret = read_holding_registers(&mb_param, SLAVE,
UT_HOLDING_REGISTERS_ADDRESS,
1, tab_rp_registers);
printf("2/2 read_holding_registers: ");
if (ret != 1) {
printf("FAILED (nb points %d)\n", ret);
goto close;
}
if (tab_rp_registers[0] != 0x1234) {
printf("FAILED (%0X != %0X)\n",
tab_rp_registers[0], 0x1234);
goto close;
}
printf("OK\n");
/* End of single register */
/* Many registers */
ret = preset_multiple_registers(&mb_param, SLAVE,
UT_HOLDING_REGISTERS_ADDRESS,
UT_HOLDING_REGISTERS_NB_POINTS,
UT_HOLDING_REGISTERS_TAB);
printf("1/2 preset_multiple_registers: ");
if (ret == UT_HOLDING_REGISTERS_NB_POINTS) {
printf("OK\n");
} else {
printf("FAILED\n");
goto close;
}
ret = read_holding_registers(&mb_param,
SLAVE, UT_HOLDING_REGISTERS_ADDRESS,
UT_HOLDING_REGISTERS_NB_POINTS,
tab_rp_registers);
printf("2/2 read_holding_registers: ");
if (ret != UT_HOLDING_REGISTERS_NB_POINTS) {
printf("FAILED (nb points %d)\n", ret);
goto close;
}
for (i=0; i < UT_HOLDING_REGISTERS_NB_POINTS; i++) {
if (tab_rp_registers[i] != UT_HOLDING_REGISTERS_TAB[i]) {
printf("FAILED (%0X != %0X)\n",
tab_rp_registers[i],
UT_HOLDING_REGISTERS_TAB[i]);
goto close;
}
}
printf("OK\n");
/* End of many registers */
/** INPUT REGISTERS **/
ret = read_input_registers(&mb_param,
SLAVE, UT_INPUT_REGISTERS_ADDRESS,
UT_INPUT_REGISTERS_NB_POINTS,
tab_rp_registers);
printf("1/1 read_input_registers: ");
if (ret != UT_INPUT_REGISTERS_NB_POINTS) {
printf("FAILED (nb points %d)\n", ret);
goto close;
}
for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) {
if (tab_rp_registers[i] != UT_INPUT_REGISTERS_TAB[i]) {
printf("FAILED (%0X != %0X)\n",
tab_rp_registers[i], UT_INPUT_REGISTERS_TAB[i]);
goto close;
}
}
printf("OK\n");
/** ILLEGAL DATA ADDRESS **/
printf("\nTEST ILLEGAL DATA ADDRESS:\n");
/* The mapping begins at 0 and ending at address + nb_points so
* the addresses below are not valid. */
ret = read_coil_status(&mb_param, SLAVE,
UT_COIL_STATUS_ADDRESS,
UT_COIL_STATUS_NB_POINTS + 1,
tab_rp_status);
printf("* read_coil_status: ");
if (ret == ILLEGAL_DATA_ADDRESS)
printf("OK\n");
else
printf("FAILED\n");
ret = read_input_status(&mb_param, SLAVE,
UT_INPUT_STATUS_ADDRESS,
UT_INPUT_STATUS_NB_POINTS + 1,
tab_rp_status);
printf("* read_input_status: ");
if (ret == ILLEGAL_DATA_ADDRESS)
printf("OK\n");
else
printf("FAILED\n");
ret = read_holding_registers(&mb_param, SLAVE,
UT_HOLDING_REGISTERS_ADDRESS,
UT_HOLDING_REGISTERS_NB_POINTS + 1,
tab_rp_registers);
printf("* read_holding_registers: ");
if (ret == ILLEGAL_DATA_ADDRESS)
printf("OK\n");
else
printf("FAILED\n");
ret = read_input_registers(&mb_param, SLAVE,
UT_INPUT_REGISTERS_ADDRESS,
UT_INPUT_REGISTERS_NB_POINTS + 1,
tab_rp_registers);
printf("* read_input_registers: ");
if (ret == ILLEGAL_DATA_ADDRESS)
printf("OK\n");
else
printf("FAILED\n");
ret = force_single_coil(&mb_param, SLAVE,
UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS,
ON);
printf("* force_single_coil: ");
if (ret == ILLEGAL_DATA_ADDRESS) {
printf("OK\n");
} else {
printf("FAILED\n");
}
ret = force_multiple_coils(&mb_param, SLAVE,
UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS,
UT_COIL_STATUS_NB_POINTS,
tab_rp_status);
printf("* force_multiple_coils: ");
if (ret == ILLEGAL_DATA_ADDRESS) {
printf("OK\n");
} else {
printf("FAILED\n");
}
ret = preset_multiple_registers(&mb_param, SLAVE,
UT_HOLDING_REGISTERS_ADDRESS + UT_HOLDING_REGISTERS_NB_POINTS,
UT_HOLDING_REGISTERS_NB_POINTS,
tab_rp_registers);
printf("* preset_multiple_registers: ");
if (ret == ILLEGAL_DATA_ADDRESS) {
printf("OK\n");
} else {
printf("FAILED\n");
}
/** TOO MANY DATA **/
printf("\nTEST TOO MANY DATA ERROR:\n");
ret = read_coil_status(&mb_param, SLAVE,
UT_COIL_STATUS_ADDRESS,
MAX_STATUS + 1,
tab_rp_status);
printf("* read_coil_status: ");
if (ret == TOO_MANY_DATA)
printf("OK\n");
else
printf("FAILED\n");
ret = read_input_status(&mb_param, SLAVE,
UT_INPUT_STATUS_ADDRESS,
MAX_STATUS + 1,
tab_rp_status);
printf("* read_input_status: ");
if (ret == TOO_MANY_DATA)
printf("OK\n");
else
printf("FAILED\n");
ret = read_holding_registers(&mb_param, SLAVE,
UT_HOLDING_REGISTERS_ADDRESS,
MAX_REGISTERS + 1,
tab_rp_registers);
printf("* read_holding_registers: ");
if (ret == TOO_MANY_DATA)
printf("OK\n");
else
printf("FAILED\n");
ret = read_input_registers(&mb_param, SLAVE,
UT_INPUT_REGISTERS_ADDRESS,
MAX_REGISTERS + 1,
tab_rp_registers);
printf("* read_input_registers: ");
if (ret == TOO_MANY_DATA)
printf("OK\n");
else
printf("FAILED\n");
ret = force_multiple_coils(&mb_param, SLAVE,
UT_COIL_STATUS_ADDRESS,
MAX_STATUS + 1,
tab_rp_status);
printf("* force_multiple_coils: ");
if (ret == TOO_MANY_DATA) {
printf("OK\n");
} else {
printf("FAILED\n");
}
ret = preset_multiple_registers(&mb_param, SLAVE,
UT_HOLDING_REGISTERS_ADDRESS,
MAX_REGISTERS + 1,
tab_rp_registers);
printf("* preset_multiple_registers: ");
if (ret == TOO_MANY_DATA) {
printf("OK\n");
} else {
printf("FAILED\n");
}
/** BAD RESPONSE **/
printf("\nTEST BAD RESPONSE ERROR:\n");
/* Allocate only the required space */
uint16_t *tab_rp_registers_bad = (uint16_t *) malloc(
UT_HOLDING_REGISTERS_NB_POINTS_SPECIAL * sizeof(uint16_t));
ret = read_holding_registers(&mb_param,
SLAVE, UT_HOLDING_REGISTERS_ADDRESS,
UT_HOLDING_REGISTERS_NB_POINTS_SPECIAL,
tab_rp_registers_bad);
printf("* read_holding_registers: ");
if (ret > 0) {
/* Error not detected */
printf("FAILED\n");
} else {
printf("OK\n");
}
free(tab_rp_registers_bad);
close:
/* Free the memory */
free(tab_rp_status);
free(tab_rp_registers);
/* Close the connection */
modbus_close(&mb_param);
return 0;
}
int main(void)
{
uint8_t *tab_rp_status;
uint16_t *tab_rp_registers;
modbus_param_t mb_param;
int i;
int ret;
int nb_points;
double elapsed;
uint32_t start;
uint32_t end;
uint32_t bytes;
uint32_t rate;
/* TCP */
modbus_init_tcp(&mb_param, "127.0.0.1", 1502);
if (modbus_connect(&mb_param) == -1) {
printf("ERROR Connection failed\n");
exit(1);
}
/* Allocate and initialize the memory to store the status */
tab_rp_status = (uint8_t *) malloc(MAX_STATUS * sizeof(uint8_t));
memset(tab_rp_status, 0, MAX_STATUS * sizeof(uint8_t));
/* Allocate and initialize the memory to store the registers */
tab_rp_registers = (uint16_t *) malloc(MAX_REGISTERS * sizeof(uint16_t));
memset(tab_rp_registers, 0, MAX_REGISTERS * sizeof(uint16_t));
printf("READ COIL STATUS\n\n");
nb_points = MAX_STATUS;
start = gettime();
for (i=0; i<NB_LOOPS; i++) {
ret = read_coil_status(&mb_param, SLAVE, 0, nb_points, tab_rp_status);
}
end = gettime();
elapsed = (end - start) / 1000;
rate = (NB_LOOPS * nb_points) * G_USEC_PER_SEC / (end - start);
printf("Transfert rate in points/seconds:\n");
printf("* %'d points/s\n", rate);
printf("\n");
bytes = NB_LOOPS * (nb_points / 8) + ((nb_points % 8) ? 1 : 0);
rate = bytes / 1024 * G_USEC_PER_SEC / (end - start);
printf("Values:\n");
printf("* %d x %d values\n", NB_LOOPS, nb_points);
printf("* %.3f ms for %d bytes\n", elapsed, bytes);
printf("* %'d KiB/s\n", rate);
printf("\n");
/* TCP: Query and reponse header and values */
bytes = 12 + 9 + (nb_points / 8) + ((nb_points % 8) ? 1 : 0);
printf("Values and TCP Modbus overhead:\n");
printf("* %d x %d bytes\n", NB_LOOPS, bytes);
bytes = NB_LOOPS * bytes;
rate = bytes / 1024 * G_USEC_PER_SEC / (end - start);
printf("* %.3f ms for %d bytes\n", elapsed, bytes);
printf("* %'d KiB/s\n", rate);
printf("\n\n");
printf("READ HOLDING REGISTERS\n\n");
nb_points = MAX_REGISTERS;
start = gettime();
for (i=0; i<NB_LOOPS; i++) {
ret = read_holding_registers(&mb_param, SLAVE, 0, nb_points, tab_rp_registers);
}
end = gettime();
elapsed = (end - start) / 1000;
rate = (NB_LOOPS * nb_points) * G_USEC_PER_SEC / (end - start);
printf("Transfert rate in points/seconds:\n");
printf("* %'d registers/s\n", rate);
printf("\n");
bytes = NB_LOOPS * nb_points * sizeof(uint16_t);
rate = bytes / 1024 * G_USEC_PER_SEC / (end - start);
printf("Values:\n");
printf("* %d x %d values\n", NB_LOOPS, nb_points);
printf("* %.3f ms for %d bytes\n", elapsed, bytes);
printf("* %'d KiB/s\n", rate);
printf("\n");
/* TCP:Query and reponse header and values */
bytes = 12 + 9 + (nb_points * sizeof(uint16_t));
printf("Values and TCP Modbus overhead:\n");
printf("* %d x %d bytes\n", NB_LOOPS, bytes);
bytes = NB_LOOPS * bytes;
rate = bytes / 1024 * G_USEC_PER_SEC / (end - start);
printf("* %.3f ms for %d bytes\n", elapsed, bytes);
printf("* %'d KiB/s\n", rate);
printf("\n");
/* Free the memory */
free(tab_rp_status);
free(tab_rp_registers);
/* Close the connection */
modbus_close(&mb_param);
return 0;
}
int ModbusSlave232::update(int *regs,
unsigned int regs_size)
{
unsigned char query[MAX_MESSAGE_LENGTH];
unsigned char errpacket[EXCEPTION_SIZE + CHECKSUM_SIZE];
unsigned int start_addr;
int exception;
int length = W232.available();
unsigned long now = millis();
//USB.print("\n");
//USB.print("Datos recibidos : ");
//USB.println(length);
if (length == 0) {
lastBytesReceived = 0;
return 0;
}
if (lastBytesReceived != length) {
lastBytesReceived = length;
Nowdt = now + T35;
return 0;
}
if (now < Nowdt)
return 0;
lastBytesReceived = 0;
length = modbus_request(query);
if (length < 1)
return length;
exception = validate_request(query, length, regs_size);
if (exception) {
build_error_packet( query[FUNC], exception,
errpacket);
send_reply(errpacket, EXCEPTION_SIZE);
return (exception);
}
start_addr =
((int) query[START_H] << 8) +
(int) query[START_L];
switch (query[FUNC]) {
case FC_READ_REGS:
return read_holding_registers(
start_addr,
query[REGS_L],
regs);
break;
case FC_WRITE_REGS:
return preset_multiple_registers(
start_addr,
query[REGS_L],
query,
regs);
break;
case FC_WRITE_REG:
write_single_register(
start_addr,
query,
regs);
break;
}
}
void*
dataacq(void *arg) {
avg.null = average_null;
avg.calculate = average_calculate;
int dev;
// start data acquisition
while (1) {
avg.null(config.samplespercycle);
// start average
for (i_avg = 1; i_avg < config.samplespercycle + 1; i_avg++) {
for (i_dev = 0; i_dev < config.meters; i_dev++) {
dev = config.idvector[i_dev];
//printf("device %d\n", dev);
#ifdef MODE_RELEASE
// reading voltages (3)
ret = read_holding_registers(&mb_param, dev,
ADDR_UL1, 3, &meas[dev].UL1);
// reading currents (3)
ret = read_holding_registers(&mb_param, dev,
ADDR_IL1, 3, &meas[dev].IL1);
// reading powers (3)
ret = read_holding_registers(&mb_param, dev,
ADDR_PSUM, 3, &meas[dev].PSUM);
// reading cosphisum (1)
ret = read_holding_registers(&mb_param, dev,
ADDR_COSPHISUM, 1, &meas[dev].COSPHISUM);
#endif // MODE_RELEASE
#ifdef MODE_TEST
meas[dev].UL1 = test_vector[i_avg - 1];
meas[dev].UL2 = test_vector[i_avg - 1];
meas[dev].UL3 = test_vector[i_avg - 1];
meas[dev].IL1 = test_vector[i_avg - 1];
meas[dev].IL2 = test_vector[i_avg - 1];
meas[dev].IL3 = test_vector[i_avg - 1];
meas[dev].PSUM = test_vector[i_avg - 1];
meas[dev].QSUM = test_vector[i_avg - 1];
meas[dev].SSUM = test_vector[i_avg - 1];
meas[dev].COSPHISUM = test_vector[i_avg - 1];
printf(
"L1 %3.1f V L2 %3.1f L3 V %3.1f V IL1 %d mA IL2 %d mA IL3 %d mA\r\n",
(float) (meas[dev].UL1) / 10, (float) (meas[dev].UL2)
/ 10, (float) (meas[dev].UL3) / 10,
meas[dev].IL1, meas[dev].IL2, meas[dev].IL3);
#endif// MODE_TEST
// average
avg.calculate(i_avg);
} // devices
sem_wait(&scheduler_tick);
} // avg
//printf("upload!\n");
// upload data
for (i_dev = 0; i_dev < config.meters; i_dev++) {
// reading real energy (1)
dev = config.idvector[i_dev];
#ifdef MODE_RELEASE
ret = read_holding_registers(&mb_param, dev, ADDR_REALENERGY, 1,
&meas[dev].REALENERGY);
#endif // MODE_RELEASE
sprintf(
&query[0],
"INSERT INTO %s values (0, NOW(), %.1f, %.1f, %.1f, %d, %d, %d, %d, %d, %d, %d, %d);",
config.table, (avg.UL1[dev]) / 10, (avg.UL2[dev]) / 10,
(avg.UL3[dev]) / 10, (int) avg.IL1[dev],
(int) avg.IL2[dev], (int) avg.IL3[dev],
(int) avg.PSUM[dev], (int) avg.QSUM[dev],
(int) avg.SSUM[dev], (int) avg.COSPHISUM[dev],
meas[dev].REALENERGY);
printf("%s\n", &query[0]);
if (mysql_query(conn, &query[0])) {
printf("error %u: %s\n", mysql_errno(conn), mysql_error(conn));
exit(1);
}
}
} // while 1
pthread_exit(0);
}
static int mb_read_data (mb_host_t *host, mb_slave_t *slave, /* {{{ */
mb_data_t *data)
{
int values[2];
int values_num;
const data_set_t *ds;
int status;
int i;
if ((host == NULL) || (slave == NULL) || (data == NULL))
return (EINVAL);
ds = plugin_get_ds (data->type);
if (ds == NULL)
{
ERROR ("Modbus plugin: Type \"%s\" is not defined.", data->type);
return (-1);
}
if (ds->ds_num != 1)
{
ERROR ("Modbus plugin: The type \"%s\" has %i data sources. "
"I can only handle data sets with only one data source.",
data->type, ds->ds_num);
return (-1);
}
if ((ds->ds[0].type != DS_TYPE_GAUGE)
&& (data->register_type != REG_TYPE_UINT32))
{
NOTICE ("Modbus plugin: The data source of type \"%s\" is %s, not gauge. "
"This will most likely result in problems, because the register type "
"is not UINT32.", data->type, DS_TYPE_TO_STRING (ds->ds[0].type));
}
memset (values, 0, sizeof (values));
if ((data->register_type == REG_TYPE_UINT32)
|| (data->register_type == REG_TYPE_FLOAT))
values_num = 2;
else
values_num = 1;
for (i = 0; i < 2; i++)
{
status = read_holding_registers (&host->connection,
/* slave = */ slave->id, /* start_addr = */ data->register_base,
/* num_registers = */ values_num, /* buffer = */ values);
if (status > 0)
break;
if (host->is_connected)
modbus_close (&host->connection);
host->is_connected = 0;
/* If we already tried reconnecting this round, give up. */
if (host->have_reconnected)
{
ERROR ("Modbus plugin: read_holding_registers (%s) failed. "
"Reconnecting has already been tried. Giving up.", host->host);
return (-1);
}
/* Maybe the device closed the connection during the waiting interval.
* Try re-establishing the connection. */
status = mb_init_connection (host);
if (status != 0)
{
ERROR ("Modbus plugin: read_holding_registers (%s) failed. "
"While trying to reconnect, connecting to \"%s\" failed. "
"Giving up.",
host->host, host->node);
return (-1);
}
DEBUG ("Modbus plugin: Re-established connection to %s", host->host);
/* try again */
continue;
} /* for (i = 0, 1) */
DEBUG ("Modbus plugin: mb_read_data: Success! "
"read_holding_registers returned with status %i.", status);
if (data->register_type == REG_TYPE_FLOAT)
{
float float_value;
value_t vt;
float_value = mb_register_to_float (values[0], values[1]);
DEBUG ("Modbus plugin: mb_read_data: "
"Returned float value is %g", (double) float_value);
CAST_TO_VALUE_T (ds, vt, float_value);
mb_submit (host, slave, data, vt);
}
else if (data->register_type == REG_TYPE_UINT32)
{
uint32_t v32;
value_t vt;
v32 = (values[0] << 16) | values[1];
DEBUG ("Modbus plugin: mb_read_data: "
"Returned uint32 value is %"PRIu32, v32);
CAST_TO_VALUE_T (ds, vt, v32);
mb_submit (host, slave, data, vt);
}
else /* if (data->register_type == REG_TYPE_UINT16) */
{
value_t vt;
DEBUG ("Modbus plugin: mb_read_data: "
"Returned uint16 value is %"PRIu16, values[0]);
CAST_TO_VALUE_T (ds, vt, values[0]);
mb_submit (host, slave, data, vt);
}
return (0);
} /* }}} int mb_read_data */
