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);
}
}
int main(void)
{
int s = -1;
modbus_t *ctx;
modbus_mapping_t *mb_mapping;
int rc = -1;
pthread_t tId;
pthread_attr_t attr;
/* Initialize and set thread detached attribute */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
ctx = modbus_new_tcp("127.0.0.1", 1502);
modbus_set_debug(ctx, TRUE);
mb_mapping = modbus_mapping_new(500, 500, 500, 500);
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
s = modbus_tcp_listen(ctx, 1);
int id = 0;
for (;;) {
id++;
printf("Waiting for another connection...\n\n");
modbus_tcp_accept(ctx, &s);
modbus_t *new_ctx = modbus_clone_tcp(ctx);
SA *sa = (SA*)malloc(sizeof(SA));
sa->ctxt = new_ctx;
sa->mm = mb_mapping;
sa->id = id;
rc = pthread_create(&tId, &attr, serveClient, (void *)sa);
if (rc) {
printf("ERROR; return code from pthread_create() is %d\n", rc);
break;
}
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
if (s != -1) {
close(s);
}
modbus_mapping_free(mb_mapping);
modbus_close(ctx);
modbus_free(ctx);
return 0;
}
int main(void)
{
int s = -1;
modbus_t *ctx;
modbus_mapping_t *mb_mapping;
ctx = modbus_new_tcp("127.0.0.1", 1502);
/* modbus_set_debug(ctx, TRUE); */
mb_mapping = modbus_mapping_new(500, 500, 500, 500);
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
s = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &s);
for (;;) {
uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
int rc;
rc = modbus_receive(ctx, query);
if (rc > 0) {
/* rc is the query size */
modbus_reply(ctx, query, rc, mb_mapping);
} else if (rc == -1) {
/* Connection closed by the client or error */
break;
}
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
if (s != -1) {
close(s);
}
modbus_mapping_free(mb_mapping);
modbus_close(ctx);
modbus_free(ctx);
return 0;
}
int main(int argc, char *arg[]) {
modbus_t *ctx, *dup_ctx;
int server_fd;
pthread_t tcp_thread;
file_read_random_data(RANDOM_DATA_POOL);
if ((ctx = modbus_new_tcp("SERVER", MODBUS_TCP_DEFAULT_PORT)) == NULL) {
printf("Failied to initialise modbus\n");
return -1;
}
mb_mapping = modbus_mapping_new(0, 0, file_get_highest_channel(), 0);
listen:
if ((server_fd = modbus_tcp_listen(ctx, LISTEN_BACKLOG)) < 0) {
printf("Failed to initiate modbus_tcp server, %i\n", server_fd);
printf("Root permissions are needed to open ports below 1024\n");
printf("Currently configured to open port %i\n",
MODBUS_TCP_DEFAULT_PORT);
modbus_free(ctx);
return -1;
}
while (1) {
modbus_set_debug(ctx, TRUE);
if (modbus_tcp_accept(ctx, &server_fd) < 0) {
/* libmodbus closes the supplied socket if accept fails - this may
* be making new connections impossible */
printf("Accept failed \n");
goto listen;
}
modbus_set_debug(ctx, FALSE);
dup_ctx = malloc(sizeof(struct ctx_data));
memcpy(dup_ctx, ctx, sizeof(struct ctx_data));
pthread_create(&tcp_thread, 0, connection, dup_ctx);
}
modbus_mapping_free(mb_mapping);
close(server_fd);
modbus_free(ctx);
return 0;
}
void modbusHandler()
{
if (ctx == NULL)
{
ctx = modbus_new_tcp("127.0.0.1", 502);
socket = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &socket);
mb_mapping = modbus_mapping_new(NULL, // no coils
NULL, // no coils
MODBUS_MAX_READ_REGISTERS, // holding reg
NULL); // no ir's
if (mb_mapping == NULL) {
\\fprintf(stderr, "Failed to allocate the mapping: %s\n", modbus_strerror(errno));
modbus_free(ctx);
return;
}
}
}
int main(int argc, char*argv[])
{
int s = -1;
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], "tcppi") == 0) {
use_backend = TCP_PI;
} else if (strcmp(argv[1], "rtu") == 0) {
use_backend = RTU;
} else {
printf("Usage:\n %s [tcp|tcppi|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 if (use_backend == TCP_PI) {
ctx = modbus_new_tcp_pi("::0", "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);
mb_mapping = modbus_mapping_new(
UT_BITS_ADDRESS + UT_BITS_NB,
UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB,
UT_REGISTERS_ADDRESS + UT_REGISTERS_NB,
UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB);
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
/* Unit tests of modbus_mapping_new (tests would not be sufficient if two
nb_* were identical) */
if (mb_mapping->nb_bits != UT_BITS_ADDRESS + UT_BITS_NB) {
printf("Invalid nb bits (%d != %d)\n", UT_BITS_ADDRESS + UT_BITS_NB, mb_mapping->nb_bits);
modbus_free(ctx);
return -1;
}
if (mb_mapping->nb_input_bits != UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB) {
printf("Invalid nb input bits: %d\n", UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB);
modbus_free(ctx);
return -1;
}
if (mb_mapping->nb_registers != UT_REGISTERS_ADDRESS + UT_REGISTERS_NB) {
printf("Invalid nb registers: %d\n", UT_REGISTERS_ADDRESS + UT_REGISTERS_NB);
modbus_free(ctx);
return -1;
}
if (mb_mapping->nb_input_registers != UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB) {
printf("Invalid nb input registers: %d\n", UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB);
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,
UT_INPUT_BITS_TAB);
/** INPUT REGISTERS **/
for (i=0; i < UT_INPUT_REGISTERS_NB; i++) {
mb_mapping->tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] =
UT_INPUT_REGISTERS_TAB[i];;
}
if (use_backend == TCP) {
s = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &s);
} else if (use_backend == TCP_PI) {
s = modbus_tcp_pi_listen(ctx, 1);
modbus_tcp_pi_accept(ctx, &s);
} else {
rc = modbus_connect(ctx);
if (rc == -1) {
fprintf(stderr, "Unable to connect %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
}
for (;;) {
do {
rc = modbus_receive(ctx, query);
/* Filtered queries return 0 */
} while (rc == 0);
/* The connection is not closed on errors which require on reply such as
bad CRC in RTU. */
if (rc == -1 && errno != EMBBADCRC) {
/* Quit */
break;
}
/* Special server behavior to test client */
if (query[header_length] == 0x03) {
/* Read holding registers */
if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 3)
== UT_REGISTERS_NB_SPECIAL) {
printf("Set an incorrect number of values\n");
MODBUS_SET_INT16_TO_INT8(query, header_length + 3,
UT_REGISTERS_NB_SPECIAL - 1);
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_SPECIAL) {
printf("Reply to this special register address by an exception\n");
modbus_reply_exception(ctx, query,
MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY);
continue;
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_INVALID_TID_OR_SLAVE) {
const int RAW_REQ_LENGTH = 5;
uint8_t raw_req[] = {
(use_backend == RTU) ? INVALID_SERVER_ID : 0xFF,
0x03,
0x02, 0x00, 0x00
};
printf("Reply with an invalid TID or slave\n");
modbus_send_raw_request(ctx, raw_req, RAW_REQ_LENGTH * sizeof(uint8_t));
continue;
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_SLEEP_500_MS) {
printf("Sleep 0.5 s before replying\n");
usleep(500000);
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_BYTE_SLEEP_5_MS) {
/* Test low level only available in TCP mode */
/* Catch the reply and send reply byte a byte */
uint8_t req[] = "\x00\x1C\x00\x00\x00\x05\xFF\x03\x02\x00\x00";
int req_length = 11;
int w_s = modbus_get_socket(ctx);
/* Copy TID */
req[1] = query[1];
for (i=0; i < req_length; i++) {
printf("(%.2X)", req[i]);
usleep(5000);
send(w_s, (const char*)(req + i), 1, MSG_NOSIGNAL);
}
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) {
if (s != -1) {
close(s);
}
}
modbus_mapping_free(mb_mapping);
free(query);
/* For RTU */
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 use_backend;
int justacounter;
justacounter = 0;
while (TRUE) {
/* TCP */
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 to measure data bandwith\n\n", argv[0]);
exit(1);
}
} else {
/* By default */
use_backend = TCP;
printf("bandwidth-server-one:\n Running in tcp mode - Modbus client to measure data bandwith\n\n");
}
if (use_backend == TCP) {
printf("Waiting for TCP connection\n");
ctx = modbus_new_tcp("127.0.0.1", 502);
socket = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &socket);
modbus_set_debug(ctx, TRUE);
printf("TCP connection started!\n");
} else {
printf("Waiting for Serial connection\n");
ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1);
modbus_set_slave(ctx, 1);
modbus_connect(ctx);
printf("Serial connection started!\n");
}
mb_mapping = modbus_mapping_new(MODBUS_MAX_READ_BITS, 22,
MODBUS_MAX_READ_REGISTERS, 22);
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
for(;;) {
uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
rc = modbus_receive(ctx, query);
if (rc >= 0) {
mb_mapping->tab_input_registers[0] = justacounter++;
printf("Replying to request.\n");
modbus_reply(ctx, query, rc, mb_mapping);
} else {
/* Connection closed by the client or server */
break;
}
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
modbus_mapping_free(mb_mapping);
close(socket);
modbus_free(ctx);
}
return 0;
}
int main(int argc, char *argv[])
{
int s = -1;
modbus_t *ctx = NULL;
modbus_mapping_t *mb_mapping = NULL;
int rc;
int use_backend;
/* TCP */
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 to measure data bandwith\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);
s = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &s);
} else {
ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1);
modbus_set_slave(ctx, 1);
modbus_connect(ctx);
}
mb_mapping = modbus_mapping_new(MODBUS_MAX_READ_BITS, 0,
MODBUS_MAX_READ_REGISTERS, 0);
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
for(;;) {
uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
rc = modbus_receive(ctx, query);
if (rc > 0) {
modbus_reply(ctx, query, rc, mb_mapping);
} else if (rc == -1) {
/* Connection closed by the client or error */
break;
}
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
modbus_mapping_free(mb_mapping);
if (s != -1) {
close(s);
}
/* For RTU, skipped by TCP (no TCP connect) */
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;
}
int main(int argc, char *argv[]) {
modbus_t *ctx_tcp;
modbus_t *ctx_serial;
uint8_t *query;
uint8_t *raw_query;
uint8_t *raw_reply;
int header_length;
int socket;
int rc;
modbus_mapping_t *mb_mapping;
modbus_mapping_t *local_mb_mapping;
const int RAW_REQ_LENGTH = 10;
int RTU;
int exitFlag = 0; // Set to non-zero to exit.
// int opt=1;
int cnt=1;
// int tty_len=0;
int baud_rate=9600;
char parity='N';
int length=8;
int stop_bits=2;
char *tty=(char *)NULL;
char *ip=(char *)NULL;
int port=1502;
int verbose=1;
int io_address=0;
int tmp_address=0;
uint16_t *localInputRegisters;
int localInputRegistersSize;
uint16_t *localHoldingRegisters;
int localHoldingRegistersSize;
int holdingShmKey=0;
int holdingShmId=0;
int holdingSemKey=0;
int holdingSemId=0;
int inputShmKey=0;
int inputShmId=0;
int inputSemKey=0;
int inputSemId=0;
int i;
unsigned char *tmp;
int ch; // for getopt
char *iniFile=(char *)NULL;
char *ptr;
int useSharedInput=0;
int useSharedHolding=0;
int modbusDebug = 0;
int localRTU = 0;
int serialRTUenabled = 0;
char *iniFileName[] = {
"/etc/newServer.ini",
"/usr/local/etc/newServer.ini",
"./newServer.ini"
};
while ((ch = getopt(argc,argv,"b:c:h?i:p:P:t:v")) != -1) {
switch (ch) {
case 'c':
if ( iniFile != (char *)NULL) {
free(iniFile);
}
iniFile = strsave( optarg );
if(verbose)
printf("Set ini file to %s\n",iniFile);
break;
case 'n': // baud rate
baud_rate=atoi(optarg);
break;
case 'h':
case '?':
usage();
exit(0);
break;
case 'i':
if ( ip != (char *)NULL) {
free(ip);
}
ip=strsave( optarg );
break;
case 'p':
port=atoi( optarg );
break;
case 'P':
parity=optarg[0];
if ('E' != parity && 'O' != parity && 'N' != parity) {
fprintf(stderr,"Invalid parity %c, exiting.\n",parity);
exit(-1);
}
break;
case 't': // serial port
if ( tty != (char *)NULL) {
free( tty );
}
tty=strsave( optarg );
break;
case 'v':
verbose=1;
break;
default:
break;
}
}
if (iniFile == (char *)NULL) {
for(i=0;(i<3 && (iniFile == (char *)NULL)) ;i++) {
if ( verbose) {
printf("%d:%s\n",i, iniFileName[i]);
}
if( 0 == access( iniFileName[i],R_OK)) {
if(verbose ) {
printf("\tFile exists\n");
}
iniFile = strsave( iniFileName[i]);
}
}
}
if (iniFile == (char *)NULL ) {
printf("No existing ini file.\n");
// Create an default file
iniFile=strsave("./newServer.ini");
printf("\tCreating new ini file %s\n", iniFile);
createIni( iniFile );
// exit(0);
}
ini = iniparser_load( iniFile );
ptr= iniparser_getstring(ini,"network:IP","127.0.0.1");
if((char *)NULL == ip) {
ip=strsave(ptr);
}
if (0 == port) {
port = iniparser_getint(ini,"network:port",1502);
}
if (-1 == verbose) {
verbose = iniparser_getboolean(ini,"system:verbose",0);
}
localHoldingRegistersSize = iniparser_getint(ini,"system:holding_reg_size", LOCAL_HOLDING_REGISTERS);
localInputRegistersSize = iniparser_getint(ini,"system:input_reg_size", LOCAL_INPUT_REGISTERS);
useSharedInput = iniparser_getboolean(ini,"system:share_input",0);
useSharedHolding = iniparser_getboolean(ini,"system:share_holding",0);
modbusDebug = iniparser_getboolean(ini,"modbus:debug",0);
localRTU = iniparser_getint(ini,"modbus:LOCAL_RTU",255);
serialRTUenabled = iniparser_getboolean(ini,"modbus:RTU",0);
if( serialRTUenabled ) {
if( (char *) NULL == tty) {
tty = iniparser_getstring(ini,"modbus:tty","/dev/ttyUSB0");
}
} else {
tty = (char *)NULL;
}
if(verbose) {
printf("\n\t\tSettings\n");
printf( "\t\t========\n\n");
printf("\tBuild Date\t:%s\n",__DATE__);
printf("\tAddress\t\t:%s\n",ip);
printf("\tNetwork port\t:%d\n",port);
printf("\tSerial port\t:%s\n",tty);
printf("\tBaud rate\t:%d\n",baud_rate);
printf("\tParity\t\t:%c\n",parity);
} else {
printf("\nStarted.\n");
}
if (serialRTUenabled ) {
if(access(tty,F_OK) == 0) {
printf("Serial port %s exists.....\n",tty);
//
// Now test that it is readable, writable.
//
} else {
printf("Serial port %s does NOT exist\n",tty);
printf("Disabling serial RTU.\n");
free( tty );
tty = (char *)NULL;
serialRTUenabled=0;
}
}
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
raw_query = malloc(RAW_REQ_LENGTH);
raw_reply = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
mb_mapping = modbus_mapping_new(
MODBUS_MAX_BITS, // Coils
MODBUS_MAX_BITS, // Discrete inputs
MODBUS_MAX_REGISTERS, // Holding registers
MODBUS_MAX_REGISTERS); // Input registers
local_mb_mapping = modbus_mapping_new(
NULL, // Coils
NULL, // Discrete inputs
LOCAL_HOLDING_REGISTERS, // Holding registers
LOCAL_INPUT_REGISTERS); // Input registers
//
// Setup the memory for the holding registers.
//
if ( useSharedHolding ) {
if (verbose)
printf("Share the Holding regsisters R/W\n");
localHoldingRegisters = local_mb_mapping->tab_registers;
holdingShmKey = iniparser_getint(ini, "system:holding_reg_key",110);
holdingSemKey = iniparser_getint(ini, "system:holding_reg_sema",111);
holdingShmId = shmget(holdingShmKey, localHoldingRegistersSize, IPC_CREAT | 0600 ); // change to 0400
if (holdingShmId < 0) {
perror("Holding Reg shmget");
exit(3);
}
local_mb_mapping->tab_registers = (uint16_t *)shmat(holdingShmId,NULL,0);
if (local_mb_mapping->tab_registers < 0) {
perror("Holding Reg shmat");
exit(4);
}
/*
* Create the seamphore
*/
holdingSemId = semget( holdingSemKey, 1, IPC_CREAT | 0600 );
if (-1 == holdingSemId) {
perror("Input reg semaphore");
exit(2);
}
/*
* Shared memory created, semaphore created (default is locked)
* release the seamphore !
*/
rc = semctl(holdingSemId, 0, SETVAL, 1);
}
//
// Setup the memory for the shared input registers.
//
if ( useSharedInput ) {
if (verbose)
printf("Share the Input regsisters R/W\n");
localInputRegisters = local_mb_mapping->tab_input_registers; // Save the current pointer
inputShmKey = iniparser_getint(ini, "system:input_reg_key",110);
inputSemKey = iniparser_getint(ini, "system:input_reg_sema",111);
inputShmId = shmget(inputShmKey, localInputRegistersSize, IPC_CREAT | 0600 ); // change to 0400
if (inputShmId < 0) {
perror("Input Reg shmget");
exit(3);
}
local_mb_mapping->tab_input_registers = (uint16_t *)shmat(inputShmId,NULL,0);
if ( local_mb_mapping->tab_input_registers < 0) {
perror("Input Reg shmat");
exit(1);
}
/*
* create the seamphore
*/
inputSemId = semget( inputSemKey, 1, IPC_CREAT | 0600 );
if (-1 == inputSemId) {
perror("Input reg semaphore");
exit(2);
}
/*
* Shared memory created, semaphore created (default is locked)
* release the seamphore !
*/
rc = semctl(inputSemId, 0, SETVAL, 1);
}
memset( localInputRegisters,0x00, LOCAL_INPUT_REGISTERS);
memset( localHoldingRegisters,0x00, LOCAL_HOLDING_REGISTERS);
local_mb_mapping->tab_input_registers[0]=0xaa55;
ctx_tcp = modbus_new_tcp(ip, port);
if ( tty != (char *)NULL ) {
ctx_serial = modbus_new_rtu(tty, baud_rate, parity, length, stop_bits);
}
while ( !exitFlag ) {
header_length = modbus_get_header_length(ctx_tcp);
if(verbose) {
modbus_set_debug(ctx_tcp, TRUE);
// modbus_set_debug(ctx_serial, TRUE);
}
do {
socket = modbus_tcp_listen(ctx_tcp, 5);
if (socket < 0) {
printf("%04d: Socket in use.\n",cnt++);
sleep(1);
}
} while(socket < 0);
// printf("modbus_tcp_listen =%d\n",socket);
if (socket == -1) {
printf("\t: %s\n", modbus_strerror(errno));
}
rc=modbus_tcp_accept(ctx_tcp, &socket);
// printf("modbus_tcp_accept rc=%d\n",rc);
if (rc == -1) {
fprintf(stderr,"FATAL ERROR: %s\n", modbus_strerror(errno));
exit(-1);
}
while ( 1 ) {
do {
if(verbose) {
printf("Recieve.\n");
}
rc = modbus_receive(ctx_tcp, query);
// printf("rc=%d\n",rc);
/* Filtered queries return 0 */
} while (rc == 0);
if (-1 == rc) {
if( verbose ) {
printf("Client disconnected.\n");
}
break;
}
RTU=query[header_length - 1];
io_address= ( query[header_length+1] << 8) + (query[header_length+2] & 0xff);
printf("IO Address=%04x\n",io_address);
if (verbose) {
if( localRTU == RTU ) {
printf("It's for me !\n");
} else {
printf("RTU Id: %02d\n",RTU);
}
printf("IO Address=0x%04x\n",io_address);
printf("Seq Number=0x%04x\n", query[1]);
}
if( localRTU == RTU ) {
//
// Local mapping
//
int len;
uint16_t data;
int cnt=0;
// Need to add address range checks, and return an error
// for an invalid function.
switch (query[header_length]) {
case 0x03: // read holding registers
case 0x04: // read input registers
rc = modbus_reply(ctx_tcp, query, rc, local_mb_mapping);
break;
case 0x06: //write single register
swab(&query[8],&len,2);
swab(&query[10],&data,2);
printf("Data=%02d\n",data);
local_mb_mapping->tab_registers[io_address]=data;
rc = modbus_reply(ctx_tcp, query, rc, local_mb_mapping);
break;
case 0x10: // Write multiple registers
// len=query[7];
swab(&query[10],&len,2);
printf("Length=%02d\n",len);
for (i=13; i< (13 + len ); i +=2) {
data= (query[i] << 8) + (query[i+1] & 0xff);
printf("%04x\n",data);
local_mb_mapping->tab_registers[ io_address + cnt++ ] = data;
}
rc = modbus_reply(ctx_tcp, query, rc, local_mb_mapping);
break;
default:
break;
}
} else {
if(serialRTUenabled) {
modbus_set_slave( ctx_serial,RTU);
if( -1 == modbus_connect( ctx_serial)) {
fprintf(stderr, "Connection failed: %s\n",modbus_strerror(errno));
}
switch( query[header_length] ) {
case 0x06:
printf("Write Single Register %d\n",RTU);
memcpy(raw_query,&query[header_length-1], 6);
rc=modbus_send_raw_request( ctx_serial,raw_query,6);
modbus_receive_confirmation(ctx_serial, raw_reply);
rc = modbus_reply(ctx_tcp, query, rc, mb_mapping);
break;
case 0x03:
case 0x04:
printf("Read Registers %d\n",RTU);
break;
case 0x10:
{
int len=0;
// modbus_set_debug(ctx_serial, TRUE);
printf("Write multiple registers %d\n",RTU);
len=query[header_length - 2];
printf("Length %d\n",len);
memcpy(raw_query,&query[header_length-1], len);
rc=modbus_send_raw_request( ctx_serial,raw_query,len);
if( -1 == rc) {
printf("modbus_send_raw_request: %s\n",modbus_strerror(errno));
} else {
modbus_receive_confirmation(ctx_serial, raw_reply);
rc = modbus_reply(ctx_tcp, query, rc, mb_mapping);
printf("rc = %d\n",rc);
// modbus_set_debug(ctx_serial, FALSE);
}
}
break;
}
if( (0x03 == query[header_length]) || (0x04 == query[header_length])) {
int len;
if(verbose) {
switch (query[header_length]) {
case 0x03:
printf("Read Holding Registers.\n");
break;
case 0x04:
printf("Read Input Registers.\n");
break;
default:
break;
}
}
memcpy(raw_query,&query[header_length-1], 6);
modbus_set_slave( ctx_serial, query[header_length-1]);
if( -1 == modbus_connect( ctx_serial)) {
fprintf(stderr, "Connection failed: %s\n",modbus_strerror(errno));
}
rc=modbus_send_raw_request( ctx_serial,raw_query,6);
if( -1 == rc ) {
printf("modbus_send_raw_request: %s\n",modbus_strerror(errno));
}
modbus_receive_confirmation(ctx_serial, raw_reply);
/*
* This next loop swaps bytes in words.
* If this is built and running on a little endian
* machine (most machines are these days)
* Then this needs to be done.
* If on a big endian machine (M68000 family) just
* comment this out.
*
* It might be worth having a command line switch,
* detect endianness.
*
*/
switch (query[header_length]) {
case 0x03:
printf("Read Holding Registers.\n");
tmp=(unsigned char *)mb_mapping->tab_registers;
break;
case 0x04:
printf("Read Input Registers.\n");
tmp=(unsigned char *)mb_mapping->tab_input_registers;
break;
default:
break;
}
tmp_address = (io_address*2);
for(i=0;i<raw_reply[2];i=i+2 ) {
tmp[tmp_address+i]=raw_reply[i+4];
tmp[tmp_address+i+1]=raw_reply[i+3];
}
for(i=0;i<10;i++) {
if (verbose) {
printf("!%02x!",raw_reply[i]);
}
}
printf("\n");
for(i=0;i<10;i++) {
if (verbose) {
printf("+%02x+",tmp[i]);
}
}
printf("\n");
//
// compute packet length by getting the data length
// and then add 2.
// Then overwrite the outbound data.
//
len=raw_reply[2] + 3;
rc = modbus_reply(ctx_tcp, query, rc, mb_mapping);
// memcpy( mb_mapping->tab_input_registers, &raw_reply[3], raw_reply[2]);
// MODBUS_SET_INT16_TO_INT8(query, header_length + 3, UT_REGISTERS_NB_SPECIAL - 1);
}
}
}
// printf("Reply with an invalid TID or slave\n");
// rc=modbus_reply_exception(ctx_tcp, query, 1);
// rc=modbus_send_raw_request(ctx_tcp, raw_reply, 10 * sizeof(uint8_t));
// rc = modbus_reply(ctx_tcp, query, rc, mb_mapping);
}
if( verbose ) {
printf("Tidying up\n");
}
close(socket);
usleep( 1000 ); // wait 1 ms
}
printf("simpleServer exiting.\n");
modbus_close(ctx_tcp);
modbus_free(ctx_tcp);
free(query);
modbus_mapping_free(mb_mapping);
return(0);
}
int main(void)
{
int rc;
iolib_init();
iolib_setdir(9,12, DIR_OUT);
int socket;
modbus_t *ctx;
modbus_mapping_t *mb_mapping;
ctx = modbus_new_tcp("192.168.1.100", 502);
modbus_set_debug(ctx, TRUE);
mb_mapping = modbus_mapping_new(10, 10, 10, 10);
if (mb_mapping == NULL) {
fprintf(stderr, "Failed to allocate the mapping: %s\n",
modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
socket = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &socket);
for (;;) {
uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
int rc;
rc = modbus_receive(ctx, query);
if (rc != -1) {
/* rc is the query size */
modbus_reply(ctx, query, rc, mb_mapping);
if((*mb_mapping).tab_bits[1] == 1) {
pin_high(9,12);
}
else if((*mb_mapping).tab_bits[1] == 0) {
pin_low(9,12);
}
} else {
/* Connection closed by the client or error */
break;
}
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
modbus_mapping_free(mb_mapping);
close(socket);
modbus_free(ctx);
return 0;
}
int main(void)
{
int s = -1;
modbus_t *ctx;
modbus_t *ctx_rtu;
ctx = modbus_new_tcp("127.0.0.1", 1502);
/* modbus_set_debug(ctx, TRUE); */
ctx_rtu = modbus_new_rtu("/dev/ttyUSB1", 115200, 'N', 8, 1);
if (modbus_connect(ctx_rtu) == -1) {
fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
modbus_free(ctx_rtu);
modbus_free(ctx);
return -1;
}
s = modbus_tcp_listen(ctx, 1);
modbus_tcp_accept(ctx, &s);
for (;;) {
uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
int query_length;
uint8_t response[MODBUS_RTU_MAX_ADU_LENGTH];
int rc;
int data_start_index;
int raw_length;
int exception;
int slave;
rc = modbus_receive(ctx, query);
if (rc > 0) {
exception = 0;
query_length = rc;
data_start_index = modbus_get_header_length(ctx) - 1;
slave = query[data_start_index];
raw_length = rc - data_start_index - modbus_get_checksum_length(ctx);
modbus_flush(ctx_rtu);
modbus_set_slave(ctx_rtu, slave);
if (modbus_send_raw_request(ctx_rtu, query + data_start_index, raw_length) != -1) {
rc = modbus_receive_confirmation(ctx_rtu, response);
if ( rc != -1) {
/* rc is the response size */
data_start_index = modbus_get_header_length(ctx_rtu) - 1;
raw_length = rc - data_start_index - modbus_get_checksum_length(ctx_rtu);
modbus_reply_raw_response(ctx, query, query_length, response + data_start_index, raw_length);
} else {
exception = errno;
}
} else {
exception = errno;
}
if (exception != 0) {
if (exception > MODBUS_ENOBASE && MODBUS_ENOBASE < (MODBUS_ENOBASE + MODBUS_EXCEPTION_MAX)) {
exception -= MODBUS_ENOBASE;
} else {
exception = EMBXSFAIL;
}
modbus_reply_exception(ctx, query, exception);
}
} else if (rc == -1) {
/* Connection closed by the client or error */
break;
}
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
if (s != -1) {
close(s);
}
modbus_close(ctx_rtu);
modbus_free(ctx_rtu);
modbus_close(ctx);
modbus_free(ctx);
return 0;
}
int main(int argc, char*argv[])
{
int socket,client_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], "utcp") == 0 ) {
use_backend = UNIX_TCP;
} else if (strcmp(argv[1], "tcppi") == 0) {
use_backend = TCP_PI;
} else if (strcmp(argv[1], "rtu") == 0) {
use_backend = RTU;
} else {
printf("Usage:\n %s [tcp|tcppi|rtu] - Modbus server for unit testing\n\n", argv[0]);
return -1;
}
} else {
/* By default */
use_backend = UNIX_TCP;
}
//signal(SIGINT, signal_handler);
if (use_backend == TCP) {
ctx = modbus_new_tcp("127.0.0.1", 502);
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
} else if (use_backend == UNIX_TCP) {
ctx = modbus_new_unix_tcp("/tmp/modbus.sock");
query = malloc(MODBUS_TCP_MAX_ADU_LENGTH);
} else if (use_backend == TCP_PI) {
ctx = modbus_new_tcp_pi("::0", "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);
//by jesse
modbus_init_cb(ctx, &cb);
//end
mb_mapping = modbus_mapping_new(
UT_BITS_ADDRESS + UT_BITS_NB, // read buffer : start address + number
UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB,
UT_REGISTERS_ADDRESS + UT_REGISTERS_NB,
UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB);
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,
UT_INPUT_BITS_TAB);
/** INPUT REGISTERS **/
for (i=0; i < UT_INPUT_REGISTERS_NB; 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);
} else if (use_backend == UNIX_TCP) {
socket = modbus_unix_tcp_listen(ctx, 1);
} else if (use_backend == TCP_PI) {
socket = modbus_tcp_pi_listen(ctx, 1);
} else {
client_socket = modbus_connect(ctx);
if (rc == -1) {
fprintf(stderr, "Unable to connect %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
}
// for unix sock
while (running) {
if (use_backend == TCP) {
client_socket = modbus_tcp_accept(ctx, &socket);
} else if (use_backend == UNIX_TCP) {
client_socket = modbus_unix_tcp_accept(ctx, &socket);
} else if (use_backend == TCP_PI) {
client_socket = modbus_tcp_pi_accept(ctx, &socket);
} else {
// RTU : nothing
}
rc = modbus_receive(ctx, query);
if (rc == -1) {
/* Connection closed by the client or error */
if ( use_backend != RTU)
close(client_socket);
continue;
}
/* Read holding registers */
if (query[header_length] == 0x03) {
if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 3)
== UT_REGISTERS_NB_SPECIAL) {
printf("Set an incorrect number of values\n");
MODBUS_SET_INT16_TO_INT8(query, header_length + 3,
UT_REGISTERS_NB_SPECIAL - 1);
} else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1)
== UT_REGISTERS_ADDRESS_SPECIAL) {
printf("Reply to this special register address by an exception\n");
modbus_reply_exception(ctx, query,
MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY);
continue;
}
}
rc = modbus_reply(ctx, query, rc, mb_mapping);
if ( use_backend != RTU)
close(client_socket);
}
printf("Quit the loop: %s\n", modbus_strerror(errno));
if (use_backend == TCP) {
close(socket);
}
modbus_uninit_cb(ctx, &cb);
modbus_mapping_free(mb_mapping);
free(query);
modbus_free(ctx);
return 0;
}
