int main(int argc, char *argv[])
{
uint16_t regs[1];
float heaterTemp;
float heaterSetPoint;
char * heaterEnableState;
char * heaterElementState;
char * modbusClientIP = DEFAULT_CLIENT_IP;
int modbusPort = DEFAULT_PORT;
int packet_counter = 0;
uint8_t *tab_bits;
uint16_t *tab_input_value_registers;
tab_bits = (uint8_t *)malloc(NO_BITS * sizeof(uint8_t));
memset(tab_bits, 0, NO_BITS * sizeof(uint8_t));
tab_input_value_registers = (uint16_t *)malloc(NO_REGS* sizeof(uint16_t));
memset(tab_input_value_registers, 0, NO_REGS * sizeof(uint16_t));
bool sts;
int rc;
uint8_t coils[2];
ctx = modbus_new_tcp(modbusClientIP, modbusPort);
if (ctx == NULL) {
fprintf(stderr, "Unable to allocate libmodbus context\n");
return -1;
}
if (modbus_connect(ctx) == -1) {
sts = false;
}
rc = modbus_read_input_registers(ctx,0,1, regs);
packet_counter++;
printf("Packet No: %d, Value of current:%d\n",packet_counter, regs[0]);
modbus_close(ctx);
ctx = modbus_new_tcp(modbusClientIP, modbusPort);
if (ctx == NULL) {
fprintf(stderr, "Unable to allocate libmodbus context\n");
return -1;
}
if (modbus_connect(ctx) == -1) {
sts = false;
}
modbus_close(ctx);
modbus_free(ctx);
return 0;
}
modbus_t * ModbusMaster::openPort(QString ip, quint16 port)
{
modbus_t * conn;
conn = modbus_new_tcp(ip.toStdString().c_str(), port);
if (conn)
{
if (modbus_connect(conn) == -1)
{
#ifdef QT_DEBUG_OUTPUT
qDebug() << "Connection failed: " << modbus_strerror(errno) << endl;
#endif
modbus_free(conn);
conn = 0;
}
}
else
{
#ifdef QT_DEBUG_OUTPUT
qDebug() << "New TCP failed: " << modbus_strerror(errno) << endl;
#endif
conn = 0;
}
return conn;
}
int main(int argc, char *argv[])
{
modbus_t *mb;
uint16_t tab_reg[256];
uint8_t bit_reg[256];
int rc;
int i;
if (argc != 4)
{
printf("name ip adress register and value\n");
exit(1);
}
int setvalue;
sscanf(argv[3],"%d",&setvalue);
int setregister;
sscanf(argv[2],"%d",&setregister);
mb = modbus_new_tcp(argv[1], 502);
if (modbus_connect(mb) == -1)
{
fprintf(stderr, "modbus connect: %s\n", modbus_strerror(errno));
modbus_free(mb);
return -1;
}
printf("%d=%d\n",setregister, setvalue);
rc = modbus_write_bit(mb,setregister,setvalue);
if (rc == -1) {
fprintf(stderr, "write registers: %s\n", modbus_strerror(errno));
return -1;
}
modbus_close(mb);
modbus_free(mb);
}
int main(int argc, char *argv[])
{
modbus_t *mb;
uint16_t tab_reg[256];
uint8_t bit_reg[256];
int rc;
int i;
int actual;
mb = modbus_new_tcp("192.168.1.120", 502);
if (modbus_connect(mb) == -1)
{
fprintf(stderr, "modbus connect: %s\n", modbus_strerror(errno));
modbus_free(mb);
return -1;
}
sscanf(getenv("QUERY_STRING"),"%d",&actual);
printf("Content-type: text/plain\n\n");
/* Read 5 registers from the address 10 */
//rc = modbus_read_registers(mb, 100, 10, tab_reg);
rc = modbus_write_bit(mb,100,actual);
if (rc == -1) {
fprintf(stderr, "write bit: %s\n", modbus_strerror(errno));
return -1;
}
modbus_close(mb);
modbus_free(mb);
}
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)
{
modbus_t *ctx;
ctx = modbus_new_tcp("127.0.0.1", 1502);
printf("modified text\n");
return 0;
}
/* 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 */
modbus_t * ConnectionModbusPoint::createPoint(TypeConnection type, void *data)
{
if (type == tcp) {
TCPData *tcpData = (TCPData *) data;
return modbus_new_tcp(tcpData->host, tcpData->port);
}
return NULL;
}
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() {
modbus_t *ctx;
uint16_t tab_reg[numero];
int rc;
int i;
ctx = modbus_new_tcp("192.168.2.18", 502);
if (modbus_connect(ctx) == -1) {
fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
struct timeval old_response_timeout;
struct timeval response_timeout;
/* Save original timeout */
//modbus_get_response_timeout(ctx, &old_response_timeout);
/* Define a new and too short timeout! */
//response_timeout.tv_sec = 2;
//response_timeout.tv_usec = 500000;
//modbus_set_response_timeout(ctx, &response_timeout);
//rc = modbus_set_slave(ctx, 49);
if (rc == -1) {
fprintf(stderr, "SET: %s\n", modbus_strerror(errno));
if (ctx!=NULL) {
fprintf(stderr,"CLOSE\n");
modbus_close(ctx);
modbus_free(ctx);
}
return -1;
}
rc = modbus_read_input_registers(ctx, direccion, numero, tab_reg);
if (rc == -1) {
fprintf(stderr, "HOLA: %s\n", modbus_strerror(errno));
if (ctx!=NULL) {
fprintf(stderr,"CLOSE\n");
modbus_close(ctx);
modbus_free(ctx);
}
return -1;
}
for (i=0; i < rc; i++) {
printf("reg[%d]=%d (0x%X)\n", i, tab_reg[i], tab_reg[i]);
}
modbus_close(ctx);
modbus_free(ctx);
}
int main(int argc, char **argv) {
if (argc != 3) {
fprintf(stdout, "\nUsage: %s <ip> <port>\n\n", argv[0]);
return -1;
}
char *ip = argv[1];
int port = atoi(argv[2]);
int rc;
uint16_t *register_values = malloc(sizeof(*register_values));
modbus_t *ctx = modbus_new_tcp(ip, port);
if (modbus_connect(ctx) == -1) {
fprintf(stderr, "Connection to %s port %d failed: %s\n", ip, port, modbus_strerror(errno));
modbus_end(ctx);
return -1;
}
/* generate exception 02 (starting address out of range) */
fprintf(stdout, "Test #1: Asking for out of bounds register (expected exception number 02)\n");
rc = modbus_read_registers(ctx, MODBUS_MAX_READ_REGISTERS+1, 1, register_values);
if (-1 == rc) {
fprintf(stderr, "Reading registers failed (modbus protocol exception number = %d). %s\n", errno - MODBUS_ENOBASE, modbus_strerror(errno));
}
sleep(1);
/* generate exception 02 (range of addresses requested out of range) */
/* Note: if the range goes beyond the protocol maximum, the returned errno will be 16, which is not a
* protocol exception code */
fprintf(stdout, "Test #2: Asking for out of bounds range of registers (expected exception number 02)\n");
rc = modbus_read_registers(ctx, 0, MODBUS_MAX_READ_REGISTERS-1, register_values);
if (-1 == rc) {
fprintf(stderr, "Reading registers failed (modbus protocol exception number = %d). %s\n", errno - MODBUS_ENOBASE, modbus_strerror(errno));
}
sleep(1);
/* generate exception 03 (quantity of registers out of bounds) */
fprintf(stdout, "Test #3: Asking for zero registers (expected exception number 03)\n");
rc = modbus_read_registers(ctx, 0, 0, register_values);
if (-1 == rc) {
fprintf(stderr, "Reading registers failed (modbus protocol exception number = %d). %s\n", errno - MODBUS_ENOBASE, modbus_strerror(errno));
}
sleep(1);
modbus_end(ctx);
free(register_values);
return 0;
}
static void *modbus_side (void *arg)
{
modbus_t *ctx;
uint16_t tab_reg[64];
int rc;
int i;
modbus_side_restart:
//ctx = modbus_new_tcp("127.0.0.1", 502);
ctx = modbus_new_tcp("140.159.153.159", 502);
// Use 140.159.153.159 for uni, 127.0.0.1 for home. Server port remains as 502 for both cases
// Initialize connection to modbus server
if(modbus_connect(ctx) == -1) // Connection to server failed
{
fprintf(stderr, "Connection to server failed: %s\n", modbus_strerror(errno));
modbus_free(ctx);
modbus_close(ctx);
usleep(100000); // Sleep for suggested delay time of 100ms
// Closing connection to retry again
goto modbus_side_restart;
}
else // Connection to server successful
{
fprintf(stderr, "Connection to server successful\n");
}
// Read registers
while(1)
{
rc = modbus_read_registers(ctx, 48, 2, tab_reg); // Device 48 allocated for Nick Hodson
if(rc == -1) // Read of registers failed
{
fprintf(stderr, "Reading of registers has failed: %s\n", modbus_strerror(errno));
// CLose modbus connection and start again (retry)
modbus_free(ctx);
modbus_close(ctx);
goto modbus_side_restart;
}
// not putting an else statement for succcessful read register as it will clog up the terminal window
for(i = 0; i < rc; i++) // Register display
{
add_to_list(&list_heads[i], tab_reg[i]); // replacement for printf statement
printf("register[%d] = %d (0x%X)\n", i, tab_reg[i], tab_reg[i]);
}
usleep(100000); // Sleep for suggested delay time of 100ms
}
}
void TcpIpSettingsWidget::changeModbusInterface(const QString &address, int portNbr)
{
releaseTcpModbus();
m_tcpModbus = modbus_new_tcp( address.toLatin1().constData(), portNbr );
if( modbus_connect( m_tcpModbus ) == -1 )
{
QMessageBox::critical( this, tr( "Connection failed" ),
tr( "Could not connect tcp/ip port!" ) );
ui->btnApply->setEnabled(true);
}
}
ModBusTCP::ModBusTCP(QObject *parent) :
QObject(parent)
{
ctx = modbus_new_tcp("192.168.3.236", 1502);
if (ctx == NULL)
{
qDebug() << "Unable to allocate libmodbus context";
return;
}
}
//==========================================================================================
int MainWindow::ReadTimeFromICPDAS(QString IPaddr, QDateTime *icpDT)
{
int res;
modbus_t *mb;
uint16_t tab_reg[200];
const uint number_readed_registers=6;
uint year=0;
uint month=0;
uint day=0;
uint hour=0;
uint minute=0;
uint second=0;
//inialized context
mb = modbus_new_tcp(IPaddr.toStdString().c_str(), 502);
if (mb==NULL) {return -1;}
res=modbus_connect(mb);
modbus_set_slave(mb, 1);
if (res==-1) {modbus_free(mb); return -2;}
res=modbus_read_registers(mb, 1, number_readed_registers, tab_reg);// 6 reg from 40002
if (res!=number_readed_registers){modbus_close(mb);modbus_free(mb); return -3;}
year=tab_reg[0];
month=tab_reg[1];
day=tab_reg[2];
hour=tab_reg[3];
minute=tab_reg[4];
second=tab_reg[5];
QDate dt;
dt.setDate(year,month,day);
QTime tm;
tm.setHMS(hour,minute,second);
icpDT->setDate(dt);
icpDT->setTime(tm);
modbus_close(mb);
modbus_free(mb);
return 1;
}
/*
* This Function establishes modbus tcp/ip connection
* Arguments:
* char * ip :- IP address of modbus tcp/ip client
* port :- Port on which modbus server is running
* slave :- Slave no. of Modbus client
* Return Value 1:- return successful
* 0 :- Error
*/
int init_modbus(const char *ip, int port,int slave)
{
ctx = modbus_new_tcp(ip, port);
printf("after ctx \n");
printf("before modbus_set_slave\n");
rc = modbus_set_slave(ctx,slave);
if(rc == 0)printf("slave address set correctly");
if (rc == -1) {
printf("modbus_set_slave error\n");
fprintf(stderr, "%s\n", modbus_strerror(errno));
return 0;
}
return 1;
}
modbus_t* modbus_new_tcp_device()
{
// ignore this. IP address.
modbus_t* pContext = modbus_new_tcp("192.168.1.12", 502);
modbus_set_slave(pContext, 2);
if (modbus_connect(pContext) < 0)
{
my_log_error("modbus_connect");
return NULL;
}
return pContext;
}
/* Initializing and connecting modbus */
modbus_t *modbus_init(char *path_to_config)
{
char ip[BUFFER_SIZE];
int port;
modbus_t *ctx = (modbus_t *) malloc(1);
/* Set default values */
sprintf(ip, "127.0.0.1");
port = 502;
/* Read Configuration */
log_entry(APP_NAME, "Reading Modbus - Configuration");
printf("\nReading Modbus - Configuration..\n");
port = getIntFromFile(path_to_config, "modbus_port");
if(getStringFromFile_n(path_to_config, "modbus_address", ip, BUFFER_SIZE) == -1) {
log_entry(APP_NAME, "Error reading modbus address");
printf("Error reading modbus_address..\n");
}
printf("IP-Address: %s\nport: %d\n", ip, port);
/* Set up modbus */
log_entry(APP_NAME, "Setting up and connecting Modbus");
printf("\nSetting up and connecting Modbus..\n");
ctx = modbus_new_tcp(ip, port);
/* Check Setup */
if(ctx == NULL) {
log_entry(APP_NAME, "Error setting up modbus");
printf("Error setting up modbus.\n");
return NULL;
}
/* Connect and set slave */
if(modbus_connect(ctx) != 0 || modbus_set_slave(ctx, MODBUS_SLAVE_ADDRESS) != 0) {
log_entry(APP_NAME, "Error connecting modbus");
printf("Error connecting modbus.\n");
return NULL;
}
/* Message to user */
log_entry(APP_NAME, "Setup and Connection successful");
printf("Setup and Connection successful.\n\n");
return ctx;
}
int MeterModbus::open() {
_mb = NULL;
_mb = modbus_new_tcp(ip(), _port);
if (_mb == NULL) {
print(log_error, "Unable to allocate libmodbus context: %s, %i", ip(), _port);
return ERR;
}
print(log_debug, "Connecting to %s:%i", name().c_str(), _ip.c_str(), _port);
if (modbus_connect(_mb) == -1) {
print(log_error, "Connection failed: %s",name().c_str(), modbus_strerror(errno));
modbus_free(_mb);
return ERR;
}
_reset_connection = false;
return SUCCESS;
}
/* 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 */
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;
}
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 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 MainWindow::SetTimeToICPDAS(QString IPaddr,QDateTime icpNewDT)
{
int res;
modbus_t *mb;
uint16_t tab_reg[200];
const uint number_write_registers=7;
tab_reg[0]=icpNewDT.date().year();
tab_reg[1]=icpNewDT.date().month();
tab_reg[2]=icpNewDT.date().day();
tab_reg[3]=icpNewDT.time().hour();
tab_reg[4]=icpNewDT.time().minute();
tab_reg[5]=icpNewDT.time().second();
tab_reg[6]=1; //flag
//inialized context
mb = modbus_new_tcp(IPaddr.toStdString().c_str(), 502);
if (mb==NULL) {return -1;}
res=modbus_connect(mb);
modbus_set_slave(mb, 1);
if (res==-1) {modbus_free(mb); return -2;}
res=modbus_write_registers(mb, 11, number_write_registers, tab_reg);// 7 reg from 40012
if (res!=number_write_registers){modbus_close(mb);modbus_free(mb); return -3;}
modbus_close(mb);
modbus_free(mb);
return 1;
}
void create_modbus_context(char *con_string, modbus_t **ctx_out, int *lock_required_out) {
char first_char = con_string[0];
if (first_char == '/') {//then its rtu(serial con)
// -- next code is to parse first arg and find all required to connect to rtu successfully
char rtu_port[100];
int rtu_speed = 9600;
char rtu_parity = 'N';
int rtu_bits = 8;
int rtu_stop_bit = 1;
sscanf(con_string,"%s %d %c %d %d",rtu_port,&rtu_speed,&rtu_parity,&rtu_bits,&rtu_stop_bit);
*lock_required_out = 1;
*ctx_out = modbus_new_rtu(rtu_port, rtu_speed, rtu_parity, rtu_bits, rtu_stop_bit);
}
else {//try modbus_tcp
*lock_required_out = 0;
*ctx_out = modbus_new_tcp(con_string, MODBUS_TCP_DEFAULT_PORT );
}
return;
}
/* bacnet_Analog_Input_Present_Value_Set(2, test_data[index++]); */
if (index == NUM_TEST_DATA) index = 0;
not_pv:
return bacnet_Analog_Input_Read_Property(rpdata);
}
static bacnet_object_functions_t server_objects[] = {
{bacnet_OBJECT_DEVICE,
NULL,
bacnet_Device_Count,
bacnet_Device_Index_To_Instance,
bacnet_Device_Valid_Object_Instance_Number,
bacnet_Device_Object_Name,
bacnet_Device_Read_Property_Local,
bacnet_Device_Write_Property_Local,
bacnet_Device_Property_Lists,
bacnet_DeviceGetRRInfo,
NULL, /* Iterator */
NULL, /* Value_Lists */
NULL, /* COV */
NULL, /* COV Clear */
NULL /* Intrinsic Reporting */
},int main (void) {
modbus_t *mb;
uint16_t tab_reg[32];
mb = modbus_new_tcp("127.0.0.1", 502);
modbus_connect(mb);
//check connection
if (modbus_connect(mb) == -1) {
fprintf(stderr, "Connection failed: %s\n", modbus_strerror (errno));
modbus_free(mb);
return -1;
}
/* Read 5 registers from the address 0 */
modbus_read_registers(mb, 0, 5, tab_reg);
modbus_close(mb);
modbus_free(mb);
return 0;
}
int main(int argc, char *argv[])
{
modbus_t *mb;
uint16_t tab_reg[256];
uint8_t bit_reg[256];
int rc;
int i;
if (argc != 3)
{
printf("name ip adress and register\n");
exit(1);
}
int setvalue = 0;
int setregister;
sscanf(argv[2], "%d", &setregister);
mb = modbus_new_tcp(argv[1], 502);
if (modbus_connect(mb) == -1)
{
fprintf(stderr, "modbus connect: %s\n", modbus_strerror(errno));
modbus_free(mb);
return -1;
}
/* Read 5 registers from the address 10 */
rc = modbus_read_registers(mb, setregister, 1, tab_reg);
if (rc == -1) {
fprintf(stderr, "read registers: %s\n", modbus_strerror(errno));
return -1;
}
printf("%d (0x%X)\n", tab_reg[0], tab_reg[0]);
modbus_close(mb);
modbus_free(mb);
}
modbus_t* modbus_init_con(options_t *opt)
{
modbus_t *ctx;
switch(opt->connection_type)
{
case _TCP:
ctx = modbus_new_tcp(opt->ip, opt->port);
DBG_ASSERT(ctx != NULL,"Unable to allocate libmodbus TCP context");
modbus_set_slave(ctx, 1);
break;
case _RTU:
ctx = modbus_new_rtu(opt->device, opt->baud, opt->parity, opt->data_bit, opt->stop_bit);
DBG_ASSERT(ctx != NULL,"Unable to allocate libmodbus RTU context");
break;
default:
DBG_ASSERT(0,"Unhandled connection type %d", opt->connection_type);
}
return ctx;
}
int main(void) // the program returns nothing
{
FILE* fichier_sortie = NULL;
int i,j;
int temp;
float data = 28.0;
float pas = 0.0;
int rc,connect ; //received
modbus_t *ctx; //initialisation context modbus
uint16_t tab_reg[32];
uint8_t dest[8];
/* we use TCP */
ctx = modbus_new_tcp("192.168.1.100", 502); // normally modbus connexions are on port 502 but port 1502 can be used by a normal user
printf("ctx = %d \n",ctx);
connect = modbus_connect(ctx);
//on indique quelle fonction on veut utiliser : 3
modbus_write_register(ctx,3,3);
printf("connect = %d \n",connect);
fichier_sortie = fopen("temperature.dat", "w");
fprintf(fichier_sortie, "%f %f \n", pas, data);
fclose(fichier_sortie);
system("gnuplot -p -e \"plot 'temperature.dat'\" loop.plt &");
for(j=0; j<300; j++){
//modbus_write_register(ctx, 3, 5 ); // ecrit 5 dans le registre 3
rc = modbus_read_registers(ctx, 0, 2,tab_reg); // lit
printf("rc = %d \n",rc);
//modbus_write_bit(ctx, 3, 1); //write 1 in coil 3
//modbus_read_bits(ctx,0,8,dest);
//printf("coil[%d] is at %d \n ", 3,dest[3]);
pas = pas +1.0;
for (i=0; i < rc; i++) {
printf("reg[%d]=%d (0x%X)\n", i, tab_reg[i], tab_reg[i]); }
temp = ((tab_reg[0] <<8) |( tab_reg[1]));
temp >>=4;
if (temp & (1 << 11)){
temp |= 0xF800;
}
data = temp * 0.0625;
printf("%04f \n",data);
fichier_sortie = fopen("temperature.dat", "a");
fprintf(fichier_sortie, "%f %f \n", pas, data);
fclose(fichier_sortie);
usleep(1000000);
}
fichier_sortie = fopen("temperature.dat", "a");
fprintf(fichier_sortie, "&");
fclose(fichier_sortie);
//scanf("%d", &fin);
modbus_close(ctx);
modbus_free(ctx);
}
