/**
* Devuelve -1 si hay error.
*/
int MODBUSPuerto::leer (int cod, int inicio, int tam,char buffer[]){
log.debug("%s: %s codigo/inicio %d - %d",__FILE__, "Inicio funcion leer",cod, inicio);
int count = 0 ;
switch (cod){
case 0x01:
if ((count = modbus_read_input_bits(ctx,inicio,tam, (unsigned char*) buffer)) == -1){
log.error("%s: %s %s",__FILE__, "Error leyendo modbuss", modbus_strerror(errno));
this->reabrir();
}
break;
case 0x02:
log.warn("%s: %s",__FILE__, "Codigo modbus 0x02 no implementado");
break;
case 0x03:
if ((count = modbus_read_input_registers(ctx,inicio,tam, (unsigned short int*) buffer)) == -1){
log.error("%s: %s %s",__FILE__, "Error leyendo modbuss", modbus_strerror(errno));
if (this->reabrir()!=0)
log.error("%s: %s %s",__FILE__, "Error reabriendo puerto", modbus_strerror(errno));
}
break;
case 0x04:
if ((count = modbus_read_registers(ctx,inicio,tam, (unsigned short int*) buffer)) == -1){
log.error("%s: %s %s",__FILE__, "Error leyendo modbuss", modbus_strerror(errno));
if (this->reabrir()!=0)
log.error("%s: %s %s",__FILE__, "Error reabriendo puerto", modbus_strerror(errno));
}
break;
}
log.debug("%s: %s %d",__FILE__, "Fin funcion leer modbus, resultado:", count);
return count;
}
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;
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 MODBUSPuerto::abrir(){
log.info("%s: %s %s",__FILE__, "Comienza abrir puerto..",this->getName().data());
int res = 1 ;
//struct timeval response_timeout;
//response_timeout.tv_sec = 1;
//response_timeout.tv_usec = 0;
errno= 0;
if ((ctx = modbus_new_rtu(this->getName().data(), baudrate, 'N', 8, 1)) != NULL){
log.error("%s: %s %s",__FILE__, "Set slave error: ",modbus_strerror(errno));
modbus_set_slave(ctx, 0x01);
//log.error("%s: %s %s",__FILE__, "Set slave error: ",modbus_strerror(errno));
//modbus_set_response_timeout(ctx, &response_timeout);
if (errno != 0) log.error("%s: %s %s",__FILE__, "Set timeout error",modbus_strerror(errno));
if (modbus_connect(ctx) == -1) {
log.error("%s: %s %s",__FILE__, "Error al abrir puerto!",modbus_strerror(errno));
modbus_free(ctx);
res = 1;
this->isOpen = false ;
}
else {
this->isOpen = true ;
res = 0 ;
log.info("%s: %s",__FILE__, "Puerto abierto!!");
}
}
return res ;
}
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(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()
{
modbus_t *ctx;
uint16_t tab_reg[64];
int rc;
int i;
ctx = modbus_new_rtu("/dev/ttyUSB0", 9600, 'N', 8,1);
if (modbus_connect(ctx) == -1) {
fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
modbus_free(ctx);
return -1;
}
rc = modbus_set_slave(ctx, 1);
if (rc == -1) {
fprintf(stderr, "%s\n", modbus_strerror(errno));
return -1;
}
struct timeval response_timeout;
response_timeout.tv_sec = 5;
response_timeout.tv_usec = 0;
modbus_set_response_timeout(ctx, &response_timeout);
while(1){
modbus_connect(ctx);
rc = modbus_read_registers(ctx, 13952, 1, &tab_reg[0]);
if (rc == -1) {
fprintf(stderr, "%s\n", modbus_strerror(errno));
return -1;
}
usleep(17000); //max transaction timing.
rc = modbus_read_registers(ctx, 13954, 1, &tab_reg[1]);
if (rc == -1) {
fprintf(stderr, "%s\n", modbus_strerror(errno));
return -1;
}
for (i=0; i < 2; i++) {
printf("reg[%d]=%d (0x%X)\n", i, tab_reg[i], tab_reg[i]);
}
//modbus_flush(ctx);
//modbus_close(ctx);
usleep(10000);
modbus_close(ctx);
}
modbus_free(ctx);
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
}
}
/**
* @brief Generic mbtcp error number handler
*
* @param tid Transaction ID.
* @param handle Mbtcp handle.
* @param errnum Error number from modbus tcp handle.
* @return Modbus error response string in JSON format.
*/
static char * set_modbus_errno_resp(int tid, mbtcp_handle_s *handle, int errnum)
{
BEGIN(enable_syslog);
// [todo][enhance] reconnect proactively?
// ... if the request interval is very large,
// we should try to reconnect automatically
if (errnum == 104) // Connection reset by peer (i.e, tcp connection timeout)
{
handle->connected = false;
}
ERR(enable_syslog, "%s:%d", modbus_strerror(errnum), errnum);
return set_modbus_error_resp(tid, modbus_strerror(errnum));
}
void Proc()
{
uint16_t irs_raw[4];
int rc, i;
rc= modbus_read_registers(ctx, 0, 4, irs_raw);
if (rc == -1) {
fprintf(stderr, "%s\n", modbus_strerror(errno));
return;
}
player_aio_data* data = new player_aio_data();
data->voltages_count = 4;
data->voltages = new float[4];
for (i = 0; i < 4; i++) {
data->voltages[i] = ((float)irs_raw[i]) / 0xffff * 5;
}
Publish(this->aio_addr, PLAYER_MSGTYPE_DATA, PLAYER_AIO_DATA_STATE,
(void*)data, sizeof(uint32_t) + 4 * sizeof(float));
delete [] data->voltages;
delete data;
}
virtual int ProcessMessage(QueuePointer &resp_queue,
player_msghdr* hdr,
void* data)
{
// Process messages here. Send a response if necessary, using Publish().
// If you handle the message successfully, return 0. Otherwise,
// return -1, and a NACK will be sent for you, if a response is required.
printf("Got message for interf=%d type=%d and subtype=%d\n",
hdr->addr.interf, hdr->type, hdr->subtype);
switch (hdr->type) {
case PLAYER_MSGTYPE_CMD:
switch(hdr->subtype) {
case PLAYER_ACTARRAY_CMD_POS:
player_actarray_position_cmd *cmd = (player_actarray_position_cmd*)data;
int degs = (int)round(cmd->position * 57.29);
int joint = cmd->joint;
printf("Pos joint=%d on %d degres\n", joint, degs);
int rc = modbus_write_register(ctx, 4 + joint, degs);
if (rc == -1) {
fprintf(stderr, "%s\n", modbus_strerror(errno));
return -1;
}
break;
}
break;
default:
printf("Message has not been process\n");
}
return(0);
}
int ModbusClientV1::readPacket(RSPacket::PacketStruct * p)
{
if (verbose > 2)
{
printf("READING PACKET\n");
}
uint16_t buffer[RS_MAX_PACKET_SIZE] =
{ 0 };
if (!isInitialized)
{
fprintf(stderr, "readPacket failed! Modbus is not initialized!\n");
return -1;
}
int rc = modbus_read_registers(ctx, 0, RS_MAX_PACKET_SIZE, /*buffer*/
(uint16_t*) p); // Read all registers
if (rc == -1)
{
fprintf(stderr, "Failed to read data [%s]\n", modbus_strerror(errno));
}
else
{
// uint8_t * b = (uint8_t*)b;
// uint8_t * data = &b[3];
// uint8_t size = b[2];
// assert(size % 2 == 0);
// RSPacket::swapWords(data, size/2);
if (verbose > 3)
printPacket(*p);
}
return rc;
}
bool RbCtrlIface::testBoardConnection()
{
// >>>>> Simulation?
if(mSimulActive)
{
ros::Duration(0.001).sleep(); // sleep for a msec
mBoardConnected = true;
return true;
}
// <<<<< Simulation?
uint16_t startAddr = WORD_TEST_BOARD;
uint16_t nReg = 1;
vector<uint16_t> reply = readMultiReg( startAddr, nReg );
if(reply.empty())
{
ROS_ERROR_STREAM( "Board Ping failed!!!" );
ROS_ERROR_STREAM( "modbus_read_input_registers error -> " << modbus_strerror( errno )
<< "[First regAddress: " << WORD_TEST_BOARD << "- #reg: " << nReg << "]" );
mBoardConnected = false;
return false;
}
mBoardConnected = true;
return true;
}
//open serial port
bool EnergyCamOpen(unsigned int dwPort ){
m_dwPort=dwPort;
char comDeviceName[100];
sprintf(comDeviceName, "/dev/ttyUSB%d", dwPort);
m_ctx = (modbus_t* )modbus_new_rtu(comDeviceName, m_dwBaud, 'E', 8, 1); // parity 'E'ven used by EnergyCam's freemodbus implementation
if(NULL == m_ctx)
return false;
modbus_set_debug( m_ctx, false);
modbus_set_slave( m_ctx, 1);
if (modbus_connect(m_ctx) == -1) {
fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
modbus_free(m_ctx);
m_ctx = NULL;
return false;
}
else{
printf,( "Connection OK: \n");
}
return true;
}
void *serveClient(void *threadarg)
{
SA *a;
a = (SA *) threadarg;
modbus_t *ctx = a->ctxt;
modbus_mapping_t *mb_mapping = a->mm;
int id = a->id;
printf("(%d) Serving... %p\n", id, ctx);
for (;;) {
uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH];
int rc;
printf("(%d) receiving...\n", id);
rc = modbus_receive(ctx, query);
if (rc > 0) {
/* rc is the query size */
modbus_reply(ctx, query, rc, mb_mapping);
} else if (rc == -1) {
printf("(%d) Disconnected %s\n", id, modbus_strerror(errno));
/* Connection closed by the client or error */
break;
}
}
//clean-up
free(ctx);
free(a);
}
/* Read values from modbus-register */
int modbus_read_value(modbus_t *ctx, int address, float *value)
{
uint16_t val[2];
/* Check if modbus is set up */
if(ctx == NULL) {
log_entry(APP_NAME, "Modbus: Error, No Context");
printf("Modbus: Error, No Context..\n");
return -1;
}
/* Read data from modbus */
if(modbus_read_registers(ctx, address, 2, val) <= 0) {
fprintf(stderr, "Modbus: Reading error: %s\n", modbus_strerror(errno));
return -1;
}
/* Convert value to float */
*value = modbus_get_float(val);
if(value == NULL) {
return ERROR ;
} else {
return SUCCESS;
}
}
ModbusClientV1::ModbusClientV1(char* device)
{
ctx = modbus_new_rtu(device, 115200, 'E', 8, 1); // Port_name, Speed, Parity, Data_bits, Stop_bits
if (ctx == NULL)
{
fprintf(stderr, "Unable to create the libmodbus context\n");
return;
}
if (verbose > 4)
{
modbus_set_debug(ctx, 1);
}
int rc = modbus_set_slave(ctx, 1);
// Connecting to existing modbus socket
rc = modbus_connect(ctx);
if (rc == -1)
{
fprintf(stderr, "Connection failed [%s]\n", modbus_strerror(errno));
modbus_free(ctx);
return;
}
// Change bytes and response timeouts for connections
change_byte_timeout(0, 10000); /* 10 ms */
change_response_timeout(0, 100000); /* 100 ms */
isInitialized = true;
}
int MODBUSPuerto::setAddress(int a)
{
log.debug("%s: %s %d",__FILE__, "Configured ModBUS address",a);
errno = 0;
modbus_set_slave(ctx, a);
if (errno != 0) log.debug("%s: %s %s",__FILE__, "Set timeout error",modbus_strerror(errno));
}
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 **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;
}
void _error_print(modbus_t *ctx, const char *context)
{
if (ctx->debug) {
fprintf(stderr, "ERROR %s", modbus_strerror(errno));
if (context != NULL) {
fprintf(stderr, ": %s\n", context);
} else {
fprintf(stderr, "\n");
}
}
}
int write_register(uint16_t register_addr, uint16_t value)
{
int rc;
rc = modbus_write_register(ctx, register_addr, value);
if (rc == -1) {
fprintf(stderr, "%s\n", modbus_strerror(errno));
return -1;
}
} // end write_register
virtual int MainSetup()
{
this->ctx = modbus_new_rtu(this->port, this->baud, 'N', 8, 1);
modbus_set_slave(this->ctx, this->uid);
if (modbus_connect(this->ctx) == -1) {
fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno));
return -1;
}
printf("Initialising modbus master on port=%s on speed=%d\n", this->port, this->baud);
return(0);
}
void x_axis_turn_left( modbus_t * ctx)
{
int rc;
rc = modbus_write_register(ctx, P0_ADDRESS, 0x0120); // ^
if (rc != 1) {
fprintf(stderr, "%s\n", modbus_strerror(errno));
printf("ERROR X 연속 드라이브 설정 (%d)\n", rc);
printf("Address = %d, value = %d (0x%X)\n",
P0_ADDRESS, 0x0110, 0x0110);
}
}
/**
* Push either "true" or "nil, errormessage"
* @param L
* @param rc rc from modbus_xxxx function call
* @param expected what rc was meant to be
* @return the count of stack elements pushed
*/
static int libmodbus_rc_to_nil_error(lua_State *L, int rc, int expected)
{
if (rc == expected) {
lua_pushboolean(L, true);
return 1;
} else {
lua_pushnil(L);
// TODO - insert the integer errno code here too?
lua_pushstring(L, modbus_strerror(errno));
return 2;
}
}
void ModBusTCP::Connect()
{
if (ctx != NULL)
{
if (modbus_connect(ctx) == -1)
{
qDebug() << "Connection failed: " << modbus_strerror(errno);
return;
}
}
}
uint16_t read_register(uint16_t register_addr)
{
int rc;
uint16_t registers[4];
rc = modbus_read_registers(ctx, register_addr, 1, registers); // leer registro de conexion ctx
if (rc == -1) {
fprintf(stderr, "%s\n", modbus_strerror(errno));
return -1;
}
return registers[0];
} // end read register
int readaddresses(int initialaddress,int numberofregisters){
int rc;
rc = modbus_read_registers(ctx, initialaddress, numberofregisters, register_buffer);
if (rc == -1) {
fprintf(stderr, "%s\n", modbus_strerror(errno));
return 0;
}else{
// qWarning() << register_buffer[1];
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;
}
