// Function for changing Modbus response timeout
void ModbusClientV1::change_response_timeout(int sec, int usec)
{
struct timeval t;
modbus_get_response_timeout(ctx, &t);
printTimeTV("Initial response timeout", &t);
t.tv_sec = sec;
t.tv_usec = usec;
modbus_set_response_timeout(ctx, &t);
modbus_get_response_timeout(ctx, &t);
printTimeTV("New response timeout", &t);
}
modbus_ctrl::modbus_ctrl(modbus_t* context) :
next_write_time(0),
shadow_registers()
{
this->context = context;
if(context == NULL)
{
throw modbus_exception();
}
//set timeout
struct timeval timeout_end;
struct timeval timeout_begin;
modbus_get_byte_timeout(context, &timeout_end);
timeout_end.tv_usec = TIMEOUT_END;
modbus_set_byte_timeout(context, &timeout_end);
modbus_get_response_timeout(context, &timeout_begin);
timeout_begin.tv_usec = TIMEOUT_BEGIN;
modbus_set_response_timeout(context, &timeout_begin);
//connect
if(modbus_connect(context) == -1)
{
throw modbus_exception();
}
}
static int ctx_get_response_timeout(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
uint32_t opt1, opt2;
#if LIBMODBUS_VERSION_CHECK(3,1,0)
modbus_get_response_timeout(ctx->modbus, &opt1, &opt2);
#else
struct timeval t;
modbus_get_response_timeout(ctx->modbus, &t);
opt1 = t.tv_sec;
opt2 = t.tv_usec;
#endif
lua_pushnumber(L, opt1);
lua_pushnumber(L, opt2);
return 2;
}
int main(int argc, char *argv[])
{
uint16_t *tab_rp_registers = NULL;
modbus_t *ctx = NULL;
uint32_t sec_to = 1;
uint32_t usec_to = 0;
int i;
int rc;
int nb_points = 1;
ctx = modbus_new_rtu(SERIAL_PORT, BAUD_RATE, PARITY, BYTE_SIZE, STOP_BITS);
if (ctx == NULL) {
fprintf(stderr, "Unable to allocate libmodbus context\n");
return -1;
}
modbus_set_debug(ctx, TRUE);
modbus_set_error_recovery(ctx, MODBUS_ERROR_RECOVERY_LINK | MODBUS_ERROR_RECOVERY_PROTOCOL);
modbus_set_slave(ctx, SERVER_ID);
modbus_get_response_timeout(ctx, &sec_to, &usec_to);
modbus_enable_rpi(ctx,TRUE);
modbus_configure_rpi_bcm_pin(ctx,RPI_PIN);
modbus_rpi_pin_export_direction(ctx);
//modbus_get_response_timeout(ctx, &old_response_to_sec, &old_response_to_usec);
if (modbus_connect(ctx) == -1)
{
fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
// modbus_get_response_timeout(ctx, &new_response_to_sec, &new_response_to_usec);
/* Allocate and initialize the memory to store the registers */
tab_rp_registers = (uint16_t *) malloc(nb_points * sizeof(uint16_t));
memset(tab_rp_registers, 0, nb_points * sizeof(uint16_t));
rc = modbus_read_registers(ctx, 97,1, tab_rp_registers);
printf("Date received is : %d\n",tab_rp_registers[0]);
free(tab_rp_registers);
/* Close the connection */
modbus_rpi_pin_unexport_direction(ctx);
modbus_close(ctx);
modbus_free(ctx);
}
uint8_t *raw_data_command(int *re_size,int size,uint8_t *raw_req)
{
modbus_t *sdl;
int req_length,re_try = 0;
//int rc;
uint8_t *rsp;
//raw_req = malloc(MODBUS_RTU_MAX_ADU_LENGTH);
rsp = malloc(MODBUS_RTU_MAX_ADU_LENGTH);
sdl_wifi:
sdl = modbus_new_tcp("169.254.114.25",502);
//sdl = modbus_new_tcp("192.168.1.25",502);
struct timeval old_response_timeout;
struct timeval response_timeout;
/* Save original timeout */
modbus_get_response_timeout(sdl, &old_response_timeout);
/* Define a new and too short timeout! */
response_timeout.tv_sec = 2;
response_timeout.tv_usec = 0;
modbus_set_response_timeout(sdl, &response_timeout);
modbus_set_debug(sdl, TRUE);
modbus_set_error_recovery(sdl,
MODBUS_ERROR_RECOVERY_LINK |
MODBUS_ERROR_RECOVERY_PROTOCOL);
modbus_set_slave(sdl,1);
if (modbus_connect(sdl) == -1)
{
if(re_try < 2){re_try++; sleep(2);goto sdl_wifi;}
return NULL;
}
req_length = modbus_send_raw_request(sdl, raw_req, size*sizeof(uint8_t));
//rc = modbus_receive_confirmation(sdl, rsp);
*re_size = modbus_receive_confirmation(sdl, rsp);
//printf("%s\n",rsp);
//printf("%d\n",*re_size);
modbus_close(sdl);
modbus_free(sdl);
return rsp;
}
uint8_t * sdl_read_buffsize(int *size)
{
int resend=0,re_con=0;
int rc, size_per_record,num_parameter,i,j;
unsigned long num_record, num_byte;
modbus_t *sdl;
uint16_t * SDL_DATA_BUFF;
uint8_t * rsp = malloc(MODBUS_RTU_MAX_ADU_LENGTH);
reconnect:
sdl = modbus_new_tcp("169.254.114.25",502);
struct timeval old_response_timeout;
struct timeval response_timeout;
/* Save original timeout */
modbus_get_response_timeout(sdl, &old_response_timeout);
/* Define a new and too short timeout! */
response_timeout.tv_sec = 2;
response_timeout.tv_usec = 0;
modbus_set_response_timeout(sdl, &response_timeout);
modbus_set_debug(sdl, TRUE);
modbus_set_error_recovery(sdl,
MODBUS_ERROR_RECOVERY_LINK |
MODBUS_ERROR_RECOVERY_PROTOCOL);
modbus_set_slave(sdl,1);
if (modbus_connect(sdl) == -1)
{
if(re_con < 3)
{
re_con++;
sleep(2);
goto reconnect;
}
else return NULL;
}
tryagain:
SDL_DATA_BUFF = (uint16_t*)malloc(4*sizeof(uint16_t));
rc = modbus_read_input_registers(sdl,UT_REGISTERS_RD_DATA_BUFFSIZE_ADDRESS,2,SDL_DATA_BUFF);
if (rc != 2)
{
if(resend < 3)
{
resend++;
sleep(2);
goto tryagain;
}
else return -100000;
}
i = 0;
for(j=0;j<rc;j++)
{
rsp[i+1] = SDL_DATA_BUFF[j] & 0x00ff;
rsp[i] = SDL_DATA_BUFF[j]>>8;
i = i+2;
}
*size = 2*rc;
return rsp;
}
uint8_t *sdl_read_data(int *size,int register_num)
{
int retry=0;
int rc,read_num,i,j;
int created_time;
float parameter;
long long_value;
uint16_t *SDL_Paramenters;
read_num = 2*register_num;
modbus_t *sdl;
uint8_t * rsp = malloc(MODBUS_RTU_MAX_ADU_LENGTH);
sdl = modbus_new_tcp("169.254.114.25",502);
struct timeval old_response_timeout;
struct timeval response_timeout;
/* Save original timeout */
modbus_get_response_timeout(sdl, &old_response_timeout);
/* Define a new and too short timeout! */
response_timeout.tv_sec = 2;
response_timeout.tv_usec = 0;
modbus_set_response_timeout(sdl, &response_timeout);
modbus_set_debug(sdl, TRUE);
modbus_set_error_recovery(sdl,
MODBUS_ERROR_RECOVERY_LINK |
MODBUS_ERROR_RECOVERY_PROTOCOL);
modbus_set_slave(sdl,1);
if (modbus_connect(sdl) == -1)
{
return NULL;
}
try_more:
// The number 6 is the extra bytes that we need to store the data such as checksum
SDL_Paramenters = (uint16_t*)malloc(read_num*sizeof(uint16_t));
rc = modbus_read_input_registers(sdl,UT_REGISTERS_RD_DATA_BUFF_ADDRESS,read_num,SDL_Paramenters);
//*size = modbus_receive_confirmation(sdl, rsp);
if (rc != read_num)
{
if(retry < 3)
{
retry++;
sleep(2);
goto try_more;
}
else return -100000;
}
i = 0;
for(j=0;j<rc;j++)
{
rsp[i+1] = SDL_Paramenters[j] & 0x00ff;
rsp[i] = SDL_Paramenters[j]>>8;
i = i+2;
//printf("%x %x\n",rsp[i+1],rsp[i]);
}
*size = 2*rc;
return rsp;
}
