void read_values(modbus_param_t * mb_param)
{
int ret;
float EV_reg, EV_float, EV_floatlb_trip, EV_float_cancel, EV_eq;
unsigned short Et_float, Et_floatlb, Et_float_exit_cum, Et_eqcalendar, Et_eq_above, Et_eq_reg;
float EV_reg2, EV_float2, EV_floatlb_trip2, EV_float_cancel2, EV_eq2;
unsigned short Et_float2, Et_floatlb2, Et_float_exit_cum2, Et_eqcalendar2, Et_eq_above2, Et_eq_reg2;
float EV_tempcomp, EV_hvd, EV_hvr, Evb_ref_lim;
short ETb_max, ETb_min;
float EV_lvd, EV_lvr, EV_lhvd, EV_lhvr, ER_icomp, Et_lvd_warn;
float EV_soc_y2g, EV_soc_g2y, EV_soc_y2r0, EV_soc_r2y;
unsigned short Emodbus_id, Emeter_id;
float Eic_lim;
unsigned int Ehourmeter;
short Etmr_eqcalendar;
float EAhl_r, EAhl_t, EAhc_r, EAhc_t, EkWhc, EVb_min, EVb_max, EVa_max;
uint16_t data[50];
// TODO: use the dispatch table regs, instead of this cut/paste stuff.
/* Read the 0xE000 EEPROM Registers and convert the results to their proper values */
ret = read_input_registers(mb_param, SUNSAVERMPPT, 0xE000, 11, data);
printf("EEPROM Registers\n\n");
printf("Charge Settings (bank 1)\n");
EV_reg = to_float(data[0]);
printf("EV_reg = %.2f V\n",EV_reg);
EV_float = to_float(data[1]);
printf("EV_float = %.2f V\n",EV_float);
Et_float = data[2];
printf("Et_float = %d s\n",Et_float);
Et_floatlb = data[3];
printf("Et_floatlb = %d s\n",Et_floatlb);
EV_floatlb_trip = to_float(data[4]);
printf("EV_floatlb_trip = %.2f V\n",EV_floatlb_trip);
EV_float_cancel = to_float(data[5]);
printf("EV_float_cancel = %.2f V\n",EV_float_cancel);
Et_float_exit_cum = data[6];
printf("Et_float_exit_cum = %d s\n",Et_float_exit_cum);
EV_eq = to_float(data[7]);
printf("EV_eq = %.2f V\n",EV_eq);
Et_eqcalendar = data[8];
printf("Et_eqcalendar = %d days\n",Et_eqcalendar);
Et_eq_above = data[9];
printf("Et_eq_above = %d s\n",Et_eq_above);
Et_eq_reg = data[10];
printf("Et_eq_reg = %d s\n",Et_eq_reg);
/* Read the 0xE00D EEPROM Registers and convert the results to their proper values */
ret = read_input_registers(mb_param, SUNSAVERMPPT, 0xE00D, 11, data);
printf("\nCharge Settings (bank 2)\n");
EV_reg2 = to_float(data[0]);
printf("EV_reg2 = %.2f V\n",EV_reg2);
EV_float2 = to_float(data[1]);
printf("EV_float2 = %.2f V\n",EV_float2);
Et_float2 = data[2];
printf("Et_float2 = %d s\n",Et_float2);
Et_floatlb2 = data[3];
printf("Et_floatlb2 = %d s\n",Et_floatlb2);
EV_floatlb_trip2 = to_float(data[4]);
printf("EV_floatlb_trip2 = %.2f V\n",EV_floatlb_trip2);
EV_float_cancel2 = to_float(data[5]);
printf("EV_float_cancel2 = %.2f V\n",EV_float_cancel2);
Et_float_exit_cum2 = data[6];
printf("Et_float_exit_cum2 = %d s\n",Et_float_exit_cum2);
EV_eq2 = to_float(data[7]);
printf("EV_eq2 = %.2f V\n",EV_eq2);
Et_eqcalendar2 = data[8];
printf("Et_eqcalendar2 = %d days\n",Et_eqcalendar2);
Et_eq_above2 = data[9];
printf("Et_eq_above2 = %d s\n",Et_eq_above2);
Et_eq_reg2 = data[10];
printf("Et_eq_reg2 = %d s\n",Et_eq_reg2);
/* Read the 0xE01A EEPROM Registers and convert the results to their proper values */
ret = read_input_registers(mb_param, SUNSAVERMPPT, 0xE01A, 6, data);
printf("\nCharge Settings (shared)\n");
EV_tempcomp = unsigned_to_float(data[0]);
printf("EV_tempcomp = %.2f V\n",EV_tempcomp);
EV_hvd = to_float(data[1]);
printf("EV_hvd = %.2f V\n",EV_hvd);
EV_hvr = to_float(data[2]);
printf("EV_hvr = %.2f V\n",EV_hvr);
Evb_ref_lim = to_float(data[3]);
printf("Evb_ref_lim = %.2f V\n",Evb_ref_lim);
ETb_max = data[4];
printf("ETb_max = %d °C\n",ETb_max);
ETb_min = data[5];
printf("ETb_min = %d °C\n",ETb_min);
/* Read the 0xE022 EEPROM Registers and convert the results to their proper values */
ret = read_input_registers(mb_param, SUNSAVERMPPT, 0xE022, 6, data);
printf("\nLoad Settings\n");
EV_lvd = to_float(data[0]);
printf("EV_lvd = %.2f V\n",EV_lvd);
EV_lvr = to_float(data[1]);
printf("EV_lvr = %.2f V\n",EV_lvr);
EV_lhvd = to_float(data[2]);
printf("EV_lhvd = %.2f V\n",EV_lhvd);
EV_lhvr = to_float(data[3]);
printf("EV_lhvr = %.2f V\n",EV_lhvr);
ER_icomp = data[4]*1.263/65536.0;
printf("ER_icomp = %.2f ohms\n",ER_icomp);
Et_lvd_warn = data[5]*0.1;
printf("Et_lvd_warn = %.2f s\n",Et_lvd_warn);
/* Read the 0xE030 EEPROM Registers and convert the results to their proper values */
ret = read_input_registers(mb_param, SUNSAVERMPPT, 0xE030, 6, data);
printf("\nMisc Settings\n");
EV_soc_y2g = to_float(data[0]);
printf("EV_soc_y2g = %.2f V\n",EV_soc_y2g);
EV_soc_g2y = to_float(data[1]);
printf("EV_soc_g2y = %.2f V\n",EV_soc_g2y);
EV_soc_y2r0 = to_float(data[2]);
printf("EV_soc_y2r0 = %.2f V\n",EV_soc_y2r0);
EV_soc_r2y = to_float(data[3]);
printf("EV_soc_r2y = %.2f V\n",EV_soc_r2y);
Emodbus_id = data[4];
printf("Emodbus_id = %d\n",Emodbus_id);
Emeter_id = data[5];
printf("Emeter_id = %d\n",Emeter_id);
/* Read the 0xE038 EEPROM Registers and convert the results to their proper values */
ret = read_input_registers(mb_param, SUNSAVERMPPT, 0xE038, 1, data);
printf("\nPPT Settings\n");
Eic_lim = fl_conv_2(data[0]);
printf("Eic_lim = %.2f A\n",Eic_lim);
/* Read the 0xE040 EEPROM Registers and convert the results to their proper values */
ret = read_input_registers(mb_param, SUNSAVERMPPT, 0xE040, 15, data);
printf("\nRead only section of EEPROM\n");
Ehourmeter = shift_32(data[1], data[0]);
printf("Ehourmeter = %d h\n",Ehourmeter);
EAhl_r = shift_float(data[3], data[2]);
printf("EAhl_r = %.2f Ah\n",EAhl_r);
EAhl_t = shift_float(data[5], data[4]);
printf("EAhl_t = %.2f Ah\n",EAhl_t);
EAhc_r = shift_float(data[7], data[6]);
printf("EAhc_r = %.2f Ah\n",EAhc_r);
EAhc_t = shift_float(data[9], data[8]);
printf("EAhc_t = %.2f Ah\n",EAhc_t);
EkWhc = data[10]*0.1;
printf("EkWhc = %.2f kWh\n",EkWhc);
EVb_min = to_float(data[11]);
printf("EVb_min = %.2f V\n",EVb_min);
EVb_max = to_float(data[12]);
printf("EVb_max = %.2f V\n",EVb_max);
EVa_max = to_float(data[13]);
printf("EVa_max = %.2f V\n",EVa_max);
Etmr_eqcalendar = data[14];
printf("Etmr_eqcalendar = %d days\n",Etmr_eqcalendar);
}
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;
}
