int main(int argc, char *argv[])
{
modbus_t *m;
uint8_t *q;
int header_length;
int socket;
int rc;
m = modbus_new_tcp("127.0.0.1", 1502);
q = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
header_length = modbus_get_header_length(m);
modbus_set_debug(m, TRUE);
modbus_set_error_recovery(m, TRUE);
socket = modbus_tcp_listen(m, 1);
modbus_tcp_accept(m, &socket);
while (1) {
rc = modbus_receive(m, -1, q);
if (rc < 0) {
error("modbus_receive() returned %d", rc);
}
dump_buffer(stdout, q, rc);
}
}
/* Version 2.9.2 */
static int mb_init_connection (mb_host_t *host) /* {{{ */
{
int status;
if (host == NULL)
return (EINVAL);
if (host->connection != NULL)
return (0);
if (host->conntype == MBCONN_TCP)
{
if ((host->port < 1) || (host->port > 65535))
host->port = MODBUS_TCP_DEFAULT_PORT;
DEBUG ("Modbus plugin: Trying to connect to \"%s\", port %i.",
host->node, host->port);
host->connection = modbus_new_tcp (host->node, host->port);
if (host->connection == NULL)
{
ERROR ("Modbus plugin: Creating new Modbus/TCP object failed.");
return (-1);
}
}
else
{
DEBUG ("Modbus plugin: Trying to connect to \"%s\", baudrate %i.",
host->node, host->baudrate);
host->connection = modbus_new_rtu (host->node, host->baudrate, 'N', 8, 1);
if (host->connection == NULL)
{
ERROR ("Modbus plugin: Creating new Modbus/RTU object failed.");
return (-1);
}
}
#if COLLECT_DEBUG
modbus_set_debug (host->connection, 1);
#endif
/* We'll do the error handling ourselves. */
modbus_set_error_recovery (host->connection, 0);
status = modbus_connect (host->connection);
if (status != 0)
{
ERROR ("Modbus plugin: modbus_connect (%s, %i) failed with status %i.",
host->node, host->port ? host->port : host->baudrate, status);
modbus_free (host->connection);
host->connection = NULL;
return (status);
}
return (0);
} /* }}} int mb_init_connection */
static int ctx_set_error_recovery(lua_State *L)
{
ctx_t *ctx = ctx_check(L, 1);
int opt = luaL_checkinteger(L, 2);
int opt2 = luaL_optinteger(L, 3, 0);
int rc = modbus_set_error_recovery(ctx->modbus, opt | opt2);
return libmodbus_rc_to_nil_error(L, rc, 0);
}
int RTU_connect(void){
modbus_set_error_recovery(ctx, MODBUS_ERROR_RECOVERY_PROTOCOL);
if (modbus_connect(ctx)==0){
return 1;
}else{
#ifdef DEBUG_ENABLED
qWarning() << "Failed to Connect";
#endif
return 0;
}
}
TLibModbusContext::TLibModbusContext(const TSerialPortSettings& settings)
: Inner(modbus_new_rtu(settings.Device.c_str(), settings.BaudRate,
settings.Parity, settings.DataBits, settings.StopBits))
{
modbus_set_error_recovery(Inner, MODBUS_ERROR_RECOVERY_PROTOCOL); // FIXME
if (settings.ResponseTimeout.count() > 0) {
std::chrono::milliseconds response_timeout = settings.ResponseTimeout;
struct timeval tv;
tv.tv_sec = response_timeout.count() / 1000;
tv.tv_usec = (response_timeout.count() % 1000) * 1000;
modbus_set_response_timeout(Inner, &tv);
}
}
TDefaultModbusContext::TDefaultModbusContext(const TModbusConnectionSettings& settings)
{
InnerContext = modbus_new_rtu(settings.Device.c_str(), settings.BaudRate,
settings.Parity, settings.DataBits, settings.StopBits);
if (!InnerContext)
throw TModbusException("failed to create modbus context");
modbus_set_error_recovery(InnerContext, MODBUS_ERROR_RECOVERY_PROTOCOL); // FIXME
if (settings.ResponseTimeoutMs > 0) {
struct timeval tv;
tv.tv_sec = settings.ResponseTimeoutMs / 1000;
tv.tv_usec = (settings.ResponseTimeoutMs % 1000) * 1000;
modbus_set_response_timeout(InnerContext, &tv);
}
}
/* Version 2.9.2 */
static int mb_init_connection (mb_host_t *host) /* {{{ */
{
int status;
if (host == NULL)
return (EINVAL);
if (host->connection != NULL)
return (0);
/* Only reconnect once per interval. */
if (host->have_reconnected)
return (-1);
if ((host->port < 1) || (host->port > 65535))
host->port = MODBUS_TCP_DEFAULT_PORT;
DEBUG ("Modbus plugin: Trying to connect to \"%s\", port %i.",
host->node, host->port);
host->connection = modbus_new_tcp (host->node, host->port);
if (host->connection == NULL)
{
host->have_reconnected = 1;
ERROR ("Modbus plugin: Creating new Modbus/TCP object failed.");
return (-1);
}
modbus_set_debug (host->connection, 1);
/* We'll do the error handling ourselves. */
modbus_set_error_recovery (host->connection, 0);
status = modbus_connect (host->connection);
if (status != 0)
{
ERROR ("Modbus plugin: modbus_connect (%s, %i) failed with status %i.",
host->node, host->port, status);
modbus_free (host->connection);
host->connection = NULL;
return (status);
}
host->have_reconnected = 1;
return (0);
} /* }}} int mb_init_connection */
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;
}
void ModBusReader::connect()
{
this->mb = modbus_new_rtu(this->_address, this->baud, 'N', 8, 2);
if (this->mb == NULL) {
throw "Unable to allocate libmodbus context";
}
//modbus_set_debug(this->mb, TRUE);
modbus_set_error_recovery(this->mb,
(modbus_error_recovery_mode)(MODBUS_ERROR_RECOVERY_LINK |
MODBUS_ERROR_RECOVERY_PROTOCOL));
modbus_set_slave(mb, this->slave_id);
if (modbus_connect(mb) == -1) {
modbus_free(mb);
throw modbus_strerror(errno);
}
}
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);
}
int main(int argc, char *argv[]) {
extern int errno;
modbus_t *ctx;
int registers;
uint8_t rtu;
int addr;
int nb;
int rc;
int ch;
int verbose=0;
int debug=0;
int port=502;
char name[255];
addr=0;
nb=1;
strcpy(name,"127.0.0.1");
// ctx = modbus_new_tcp("192.168.0.143", 1502);
// ctx = modbus_new_tcp("127.0.0.1", 1502);
// ctx = modbus_new_tcp("10.0.0.101", 502);
// ctx = modbus_new_tcp("192.168.100.72", 1502);
while((ch = getopt(argc,argv,"dvh?p:i:r:n:c:")) != -1) {
switch(ch) {
case 'c':
sscanf(optarg,"%x",®isters);
break;
case 'd':
debug=1;
break;
case 'v':
verbose=1;
break;
case 'h':
case '?':
printf("Usage\n");
exit(1);
break;
case 'p':
port=atoi(optarg);
break;
case 'i':
strcpy(name,optarg);
break;
case 'r':
addr=atoi(optarg);
break;
case 'n':
nb=atoi(optarg);
break;
}
}
if (verbose) {
printf("Name :%s\n",name);
printf("Port :%d\n",port);
printf("Register:%d\n",addr);
printf("Count :%d\n", nb);
printf("Data :%04x\n", registers);
printf("==================\n");
}
ctx = modbus_new_tcp(name, port);
if (ctx == NULL) {
fprintf(stderr, "modbus_new_tcp failed.\n");
exit(-1);
}
if(debug) {
modbus_set_debug(ctx, TRUE);
} else {
modbus_set_debug(ctx, FALSE);
}
modbus_set_error_recovery(ctx,
MODBUS_ERROR_RECOVERY_LINK |
MODBUS_ERROR_RECOVERY_PROTOCOL);
if (modbus_connect(ctx) == -1) {
fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
rc = modbus_write_registers(ctx, addr, nb,(uint16_t *) ®isters);
if (rc != nb) {
printf("Failed:%d\n",rc);
printf("==>%s\n", modbus_strerror(errno));
}
// printf("\nData = 0x%04x\n", registers & 0xffff);
sleep(1);
modbus_close(ctx);
modbus_free(ctx);
return 0;
}
int main(int argc, char *argv[])
{
srand((unsigned)time(NULL));
int ctxnum = 0;
int i;
int sel = 1;
modbus_t *ctx[SLAVE_NUM]; // modbus structure, save connect data
char portName[SLAVE_NUM][100]; // for save port name
int slaveID[SLAVE_NUM]; // for save slave id
int bitRate[SLAVE_NUM]; // for save bit rate
char parity[SLAVE_NUM]; // for save parity option
for ( i=0 ; i<SLAVE_NUM ; i++ )
ctx[i] = NULL;
if ( argc != 1 )
{
printf("Usage : %s\n", argv[0] );
exit(1);
}
/*
if ( argc == 2 )
if ( !strcmp( argv[1], "ON" ))
modbus_set_debug(ctx, TRUE);
*/
while ( sel != -2 )
{
for ( i=0 ; i<ctxnum ; i++ )
printf("%4d. %s %d %d %c\n", i, portName[i], slaveID[i], bitRate[i], parity[i] );
printf(" -1. make new connect\n");
printf(" -2. quit\n");
printf(" sel : ");
scanf("%d", &sel);
switch ( sel )
{
case -1 :
{
if ( ctxnum == 246 )
printf("\nconnection is full!!!\n\n");
printf("\n\tinput port name : ");
scanf("%s", portName[ctxnum]);
printf("\tinput slave ID : ");
scanf("%d", &slaveID[ctxnum]);
printf("\tinput bit rate : ");
scanf("%d", &bitRate[ctxnum]);
printf("\tinput parity : ");
fgetc(stdin);
parity[ctxnum] = fgetc(stdin);
ctx[ctxnum] = modbus_new_rtu(portName[ctxnum], bitRate[ctxnum], parity[ctxnum], 8, 1);
// make rtu connection
if (ctx[ctxnum] == NULL) { // error
fprintf(stderr, "Unable to allocate libmodbus context\n");
return -1;
}
modbus_set_error_recovery(ctx[ctxnum],
MODBUS_ERROR_RECOVERY_LINK |
MODBUS_ERROR_RECOVERY_PROTOCOL);
modbus_set_slave(ctx[ctxnum], slaveID[ctxnum]); // set slave number
if (modbus_connect(ctx[ctxnum]) == -1) {
fprintf(stderr, "Connection failed: %s\n",
modbus_strerror(errno));
modbus_free(ctx[ctxnum]);
return -1;
}
ctxnum++;
printf("\n");
}
break;
case -2 :
printf("exit client module (master)\n");
break;
default :
if ( ctx[sel] == NULL || sel <-2 || sel>246 )
printf("\ninput correct number.\n\n"); // error input
else
connectToSlave(ctx[sel]); // cennect to slave
}
}
/* Close the connection */
for ( i=0 ; i<SLAVE_NUM; i++ )
{
if ( ctx[i] != NULL )
{
modbus_close(ctx[i]);
modbus_free(ctx[i]);
}
}
return 0;
}
int main(int argc, char *argv[])
{
modbus_t *ctx;
uint16_t *tab_reg;
int rc;
int use_backend;
const uint16_t values[] = {5678, 9012};
if (argc > 1) {
if (strcmp(argv[1], "tcp") == 0) {
use_backend = TCP;
} else if (strcmp(argv[1], "rtu") == 0) {
use_backend = RTU;
} else {
printf("Usage:\n %s [tcp|rtu] - Modbus client for unit testing\n\n", argv[0]);
exit(1);
}
} else {
/* By default */
use_backend = TCP;
}
if (use_backend == TCP) {
ctx = modbus_new_tcp("127.0.0.1", 1502);
} else {
ctx = modbus_new_rtu("/dev/ttyUSB1", 115200, 'N', 8, 1);
}
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);
if (use_backend == RTU) {
modbus_set_slave(ctx, SERVER_ID);
}
if (modbus_connect(ctx) == -1) {
fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
/* Allocate and initialize the memory to store the registers */
tab_reg = (uint16_t *) malloc(10 * sizeof(uint16_t));
/* Single register */
printf("1/2 modbus_write_register");
rc = modbus_write_register(ctx, 0, 1234);
if (rc != 1) {
goto close;
}
printf("2/2 modbus_read_registers");
rc = modbus_read_registers(ctx, 0, 1, tab_reg);
if (rc != 1) {
goto close;
}
if (tab_reg[0] != 1234) {
goto close;
}
/* Many registers */
printf("1/2 modbus_write_registers");
rc = modbus_write_registers(ctx, 1, 2, values);
if (rc != 2) {
goto close;
}
printf("2/2 modbus_read_registers");
rc = modbus_read_registers(ctx, 1, 2, tab_reg);
if (rc != 2) {
goto close;
}
close:
/* Free the memory */
free(tab_reg);
/* Close the connection */
modbus_close(ctx);
modbus_free(ctx);
return 0;
}
int main(int argc, char*argv[])
{
int socket;
modbus_t *ctx;
modbus_mapping_t *mb_mapping;
int rc;
int i;
int use_backend;
uint8_t *query;
int header_length;
if (argc > 1) {
if (strcmp(argv[1], "tcp") == 0) {
use_backend = TCP;
} else if (strcmp(argv[1], "rtu") == 0) {
use_backend = RTU;
} else {
printf("Usage:\n %s [tcp|rtu] - Modbus server for unit testing\n\n", argv[0]);
return -1;
}
} else {
/* By default */
use_backend = TCP;
}
if (use_backend == TCP) {
ctx = modbus_new_tcp("127.0.0.1", 1502);
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
} else {
ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1);
modbus_set_slave(ctx, SERVER_ID);
query = malloc(MODBUS_RTU_MAX_ADU_LENGTH);
}
header_length = modbus_get_header_length(ctx);
modbus_set_debug(ctx, TRUE);
modbus_set_error_recovery(ctx, TRUE);
mb_mapping = modbus_mapping_new(
UT_BITS_ADDRESS + UT_BITS_NB_POINTS,
UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB_POINTS,
UT_REGISTERS_ADDRESS + UT_REGISTERS_NB_POINTS,
UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB_POINTS);
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
/* Examples from PI_MODBUS_300.pdf.
Only the read-only input values are assigned. */
/** INPUT STATUS **/
modbus_set_bits_from_bytes(mb_mapping->tab_input_bits,
UT_INPUT_BITS_ADDRESS, UT_INPUT_BITS_NB_POINTS,
UT_INPUT_BITS_TAB);
/** INPUT REGISTERS **/
for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) {
mb_mapping->tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] =
UT_INPUT_REGISTERS_TAB[i];;
}
if (use_backend == TCP) {
socket = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &socket);
} else {
rc = modbus_connect(ctx);
if (rc == -1) {
fprintf(stderr, "Unable to connect %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
}
for (;;) {
rc = modbus_receive(ctx, -1, query);
if (rc == -1) {
/* Connection closed by the client or error */
break;
}
/* Read holding registers */
if (query[header_length] == 0x03) {
if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 3)
== UT_REGISTERS_NB_POINTS_SPECIAL) {
printf("Set an incorrect number of values\n");
MODBUS_SET_INT16_TO_INT8(query, header_length + 3,
UT_REGISTERS_NB_POINTS);
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_SPECIAL) {
modbus_reply_exception(ctx, query,
MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY);
continue;
}
}
rc = modbus_reply(ctx, query, rc, mb_mapping);
if (rc == -1) {
break;
}
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
if (use_backend == TCP) {
close(socket);
}
modbus_mapping_free(mb_mapping);
free(query);
modbus_free(ctx);
return 0;
}
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;
}
int main(int argc, char *argv[])
{
modbus_t *mb;
int16_t tab_reg[100]={0};
int tty_fd,key_fd,led_fd;
int i = 0, count,regs;
int mode;
struct input_event ev_key;
if (argc < 3) {
fprintf(stdout, "Usage: [ UART device ] [ key device ]\n");
exit(0);
}
mb = modbus_new_rtu(argv[1],115200,'N',8,1);//open port
key_fd=open(argv[2],O_RDWR);
if (key_fd < 0) {
perror("open key device error!\n");
close(key_fd);
exit(1);
}
modbus_set_debug(mb, FALSE);
modbus_set_error_recovery(mb,
MODBUS_ERROR_RECOVERY_LINK |
MODBUS_ERROR_RECOVERY_PROTOCOL);
modbus_set_slave(mb,5);//set slave address
if(mode=modbus_rtu_get_serial_mode(mb)<0){
printf("get 1 serial mode faild\n");
return -1;
}
mb=modbus_rtu_set_serial_mode(mb,MODBUS_RTU_RS485);
if(mode=modbus_rtu_get_serial_mode(mb)<0){
printf("get 2 serial mode faild\n");
return -1;
}
if(mode==1)
printf("mode:RS485 %d\n",mode);
else
printf("mode:RS232 %d\n",mode);
//modbus_rtu_open_485de(mb,"/sys/class/leds/RS485_TX_RX/brightness");
modbus_connect(mb);
led_fd = open("/sys/class/leds/sys_led/brightness", O_RDWR);
if (led_fd < 0) {
perror("open led device error!\n");
close(led_fd);
exit(1);
}
write(led_fd, "0", 1);
for ( ; ; ) {
count = read(key_fd, &ev_key, sizeof(struct input_event));
if (count > 0){
if (EV_KEY == ev_key.type){
printf("type:%d, code:%d, value:%d\n", ev_key.type, ev_key.code, ev_key.value);
switch(ev_key.code){
case 22:
if (0 == ev_key.value) {
//modbus_set_slave(mb,5);//set slave address
regs=modbus_read_registers(mb, 0x000B,1, tab_reg);
// for(i=0;i<regs;i++)
// printf("异常光路:[%d]=%d\n",i,tab_reg[i]);
// printf("----------------------------------->发出切换指令 A\n");
write(led_fd, "1", 1);
sleep(1);
// printf("----------------------------------->发出切换指令 B\n");
write(led_fd, "0", 1);
//sleep(1);
// printf("----------------------------------->发出切换指令 C\n");
}
break;
case 16: {
if (0 == ev_key.value) {
modbus_set_slave(mb,2);//set slave address
regs=modbus_read_registers(mb, 0x000B,1, tab_reg);
for(i=0;i<regs;i++)
printf("异常光路:[%d]=%d\n",i,tab_reg[i]);
}
break;
case 17:
if (0 == ev_key.value) {
modbus_set_slave(mb,3);//set slave address
regs=modbus_read_registers(mb, 0x000B,1, tab_reg);
for(i=0;i<regs;i++)
printf("异常光路:[%d]=%d\n",i,tab_reg[i]);
}
break;
case 18:
if (0 == ev_key.value) {
modbus_set_slave(mb,4);//set slave address
regs=modbus_read_registers(mb, 0x000B,1, tab_reg);
for(i=0;i<regs;i++)
printf("异常光路:[%d]=%d\n",i,tab_reg[i]);
}
break;
case 19:
if (0 == ev_key.value) {
modbus_set_slave(mb,1);//set slave address
regs=modbus_read_registers(mb, 0x000B,1, tab_reg);
for(i=0;i<regs;i++)
printf("异常光路:[%d]=%d\n",i,tab_reg[i]);
}
break;
case 20:
if (0 == ev_key.value) {
modbus_set_slave(mb,6);//set slave address
regs=modbus_read_registers(mb, 0x000B,1, tab_reg);
for(i=0;i<regs;i++)
printf("异常光路:[%d]=%d\n",i,tab_reg[i]);
}
break;
case 21:
if (0 == ev_key.value) {
modbus_set_slave(mb,7);//set slave address
regs=modbus_read_registers(mb, 0x000B,1, tab_reg);
for(i=0;i<regs;i++)
printf("异常光路:[%d]=%d\n",i,tab_reg[i]);
}
break;
case 15:
if (0 == ev_key.value) {
modbus_set_slave(mb,8);//set slave address
regs=modbus_read_registers(mb, 0x000B,1, tab_reg);
for(i=0;i<regs;i++)
printf("异常光路:[%d]=%d\n",i,tab_reg[i]);
}
break;
default:
printf("无效中断");
break;
}
}
}
}
}
close(key_fd);
modbus_close(mb);
modbus_free(mb);
return 0;
}
modbus_set_byte_timeout((modbus_t *)(SYS_INT)PARAM(0), &local_parameter_1);
RETURN_NUMBER(0)
END_IMPL
//------------------------------------------------------------------------
CONCEPT_FUNCTION_IMPL(modbus_set_slave, 2)
T_HANDLE(modbus_set_slave, 0) // modbus_t*
T_NUMBER(modbus_set_slave, 1) // int
RETURN_NUMBER(modbus_set_slave((modbus_t *)(SYS_INT)PARAM(0), (int)PARAM(1)))
END_IMPL
//------------------------------------------------------------------------
CONCEPT_FUNCTION_IMPL(modbus_set_error_recovery, 2)
T_HANDLE(modbus_set_error_recovery, 0) // modbus_t*
T_NUMBER(modbus_set_error_recovery, 1) // modbus_error_recovery_mode
RETURN_NUMBER(modbus_set_error_recovery((modbus_t *)(SYS_INT)PARAM(0), (modbus_error_recovery_mode)PARAM(1)))
END_IMPL
//------------------------------------------------------------------------
CONCEPT_FUNCTION_IMPL(modbus_set_socket, 2)
T_HANDLE(modbus_set_socket, 0) // modbus_t*
T_NUMBER(modbus_set_socket, 1) // int
modbus_set_socket((modbus_t *)(SYS_INT)PARAM(0), (int)PARAM(1));
RETURN_NUMBER(0)
END_IMPL
//------------------------------------------------------------------------
CONCEPT_FUNCTION_IMPL(modbus_get_socket, 1)
T_HANDLE(modbus_get_socket, 0) // modbus_t*
RETURN_NUMBER(modbus_get_socket((modbus_t *)(SYS_INT)PARAM(0)))
END_IMPL
