BLOCK_STATUS *ModBusTCP::ReportSlaveID(quint8 slave) { uint8_t dest[10]; int rc; BLOCK_STATUS *st = new BLOCK_STATUS; modbus_set_slave(ctx, slave); rc = modbus_report_slave_id(ctx, dest); qDebug() << "RC: " << rc; if (rc != -1) { st -> rstatus = true; if (dest[0]) st -> status = true; else st -> status = false; st -> SoftVersion = dest[1]; st -> HardVersion = dest[2]; } else { st -> rstatus = false; } return st; }
//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; }
int setmodbusslave(int id){ modbus_set_slave(ctx,id); qWarning() << "Slave ID:"; qWarning() << id; return 1; }
/********************************************************** * FUNCTION: write_register_handler * * DESCRIPTION: * Handles the write single register request * * PARAMETERS: * int reg_addr - register address to read from * int* reg_val - register value * * RETURN: 0 on success * -1 otherwise *********************************************************/ int write_register_handler(int addr, int reg_val) { int rc=0; int slave_addr, reg_addr; /* Check addr range */ /* TODO */ if (mode == MODE_SINGLESLAVE) { slave_addr = slave_addr_table[0]; reg_addr = addr + reg_offset; } else { slave_addr = slave_addr_table[(addr-1)/NUM_REG_PER_SLAVE]; reg_addr = custom_reg_table[(addr-1)%NUM_REG_PER_SLAVE]; } /* Set slave address */ modbus_set_slave(mb, slave_addr); /* Write specified Modbus register value to RTU device */ rc = modbus_write_register(mb, reg_addr, reg_val); if (rc != 1) { return -1; } /* Assure a minimum bus delay before next request */ usleep(MIN_BUS_DELAY_MS*1000); return 0; }
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 ; }
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; }
char * mbtcp_cmd_hanlder(cJSON *req, mbtcp_fc fc) { BEGIN(enable_syslog); mbtcp_handle_s *handle = NULL; int tid = json_get_int(req, "tid"); if (lazy_init_mbtcp_handle(&handle, req)) { char * reason = NULL; if (lazy_mbtcp_connect(handle, &reason)) { // set slave id int slave = json_get_int(req, "slave"); LOG(enable_syslog, "slave id: %d", slave); modbus_set_slave(handle->ctx, slave); return fc(handle, req); } else { // [enhance]: get reason from modbus response return set_modbus_error_resp(tid, reason); } } else { return set_modbus_error_resp(tid, "init modbus tcp handle fail"); } }
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)); }
static int ctx_set_slave(lua_State *L) { ctx_t *ctx = ctx_check(L, 1); int slave = luaL_checknumber(L, 2); int rc = modbus_set_slave(ctx->modbus, slave); return libmodbus_rc_to_nil_error(L, rc, 0); }
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; }
bool Modbus::poll(int tm) { timeval tv = { 0, tm }; modbus_set_response_timeout(_modbus, &tv); int recv_bytes = modbus_receive(_modbus, _query); if (recv_bytes == -1) { return false; } DeviceModbus* pdev = findDevice(_query[0]); if (!pdev) { LOG_ERROR("Unknown slave ID: %d", _query[0]); return false; } if (pdev->board()) pdev->board()->HandleRequest(_query, recv_bytes, pdev->modbusMap()); modbus_set_slave(_modbus, pdev->slaveId()); switch (_query[modbus_get_header_length(_modbus)]) { case MODBUS_READ_COILS: case MODBUS_READ_DISCRETE_INPUTS: case MODBUS_READ_INPUT_REGISTERS: case MODBUS_READ_HOLDING_REGISTERS: pdev->updateValues(); modbus_reply(_modbus, _query, recv_bytes, pdev->modbusMap()); break; case MODBUS_WRITE_SINGLE_COIL: //LOG_INFO("MODBUS_WRITE_SINGLE_COIL"); modbus_reply(_modbus, _query, recv_bytes, pdev->modbusMap()); break; case MODBUS_WRITE_SINGLE_REGISTER: LOG_INFO("MODBUS_WRITE_SINGLE_REGISTER"); modbus_reply(_modbus, _query, recv_bytes, pdev->modbusMap()); break; case MODBUS_WRITE_MULTIPLE_COILS: LOG_INFO("MODBUS_WRITE_MULTIPLE_COILS"); break; case MODBUS_WRITE_MULTIPLE_REGISTERS: LOG_INFO("MODBUS_WRITE_MULTIPLE_REGISTERS"); break; default: LOG_ERROR("UNKNOWN FUNCTION"); return false; } pdev->updateWidgets(); return true; }
void ModBusTCP::WriteMultipleHoldingRegisters(quint16 slave, quint16 addr, quint16 num, quint16 *data) { quint16 tmp_data[128]; quint16 repeat = NumberOfRepeat; qDebug() << "Write MultiHoldingRegisters from slave: " << slave << " Addr: " << addr << " Number: " << num; while(repeat) { if (modbus_set_slave(ctx, slave) == -1) { if (--repeat == 0) { qDebug() << "Error set slave: " << errno; emit ModBusError(errno); return; } } else { repeat = 0; } } for (int i = 0; i < num; i++) { tmp_data[i] = qToBigEndian<quint16>(data[i]); } repeat = NumberOfRepeat; while(repeat) { if (modbus_write_registers(ctx, addr, num, tmp_data) == -1) { if (--repeat == 0) { qDebug() << "Error write HoldingRegisters: " << errno; emit ModBusError(errno); return; } } else { repeat = 0; } } qDebug() << "Write OK" << repeat; emit ModBusOK(); }
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); }
//========================================================================================== 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; }
/********************************************************** * FUNCTION: read_register_handler * * DESCRIPTION: * Handles the read single register request * * PARAMETERS: * int reg_addr - register address to read from * int* reg_val - pointer to register value * * RETURN: 0 on success * -1 otherwise *********************************************************/ int read_register_handler(int addr, int *reg_val_p) { int retry = NUM_READ_RETRY; int rc=0; int slave_addr, reg_addr; uint16_t modbus_regs[2]; /* Check addr range */ /* TODO */ modbus_regs[0] = 0; modbus_regs[1] = 0; if (mode == MODE_SINGLESLAVE) { slave_addr = slave_addr_table[0]; reg_addr = addr + reg_offset; } else { slave_addr = slave_addr_table[(addr-1)/NUM_REG_PER_SLAVE]; reg_addr = custom_reg_table[(addr-1)%NUM_REG_PER_SLAVE]; } /* Set slave address */ modbus_set_slave(mb, slave_addr); /* Read slave with retry (after delay) */ do { rc = modbus_read_registers(mb, reg_addr, num_regs, modbus_regs); if (rc != num_regs) sleep(2); } while ((rc != num_regs) && retry--); if (rc != num_regs) { return -1; } else { *reg_val_p = (num_regs==1)?modbus_regs[0]:modbus_regs[1]; } /* Assure a minimum bus delay before next request */ usleep(MIN_BUS_DELAY_MS*1000); return 0; }
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; }
void ModBusTCP::WriteHoldingRegister(quint16 slave, quint16 addr, quint16 value) { quint16 repeat = NumberOfRepeat; qDebug() << "Write HoldingRegister from slave: " << slave << "Addr: " << addr; while(repeat) { if (modbus_set_slave(ctx, slave) == -1) { if (--repeat == 0) { qDebug() << "Error set slave: " << errno; emit ModBusError(errno); return; } } else { repeat = 0; } } repeat = NumberOfRepeat; while (repeat) { if (modbus_write_register(ctx, addr, value) == -1) { if (--repeat == 0) { qDebug() << "Error write HoldingRegister: " << errno; emit ModBusError(errno); return; } } else { repeat = 0; } } qDebug() << "Write OK" << repeat; emit ModBusOK(); }
void ModBusTCP::WriteMultipleCoils(quint16 slave, quint16 addr, quint16 num, quint8 *data) { quint16 repeat = NumberOfRepeat; qDebug() << "Write multiCoils from slave: " << slave << "Addr: " << addr << " number: " << num; while(repeat) { if (modbus_set_slave(ctx, slave) == -1) { if (--repeat == 0) { qDebug() << "Error set slave: " << errno; emit ModBusError(errno); return; } } else { repeat = 0; } } repeat = NumberOfRepeat; while (repeat) { qDebug() << Q_FUNC_INFO << repeat; if (modbus_write_bits(ctx, addr, num, data) == -1) { if (--repeat == 0) { qDebug() << "Error write MultiCoils: " << errno; emit ModBusError(errno); return; } } else { repeat = 0; } } qDebug() << "Write OK" << repeat; emit ModBusOK(); }
void ModBusTCP::ReadInputRegisters(quint16 slave, quint16 addr, quint16 size, quint16 *data) { quint16 repeat = NumberOfRepeat; while(repeat) { if (modbus_set_slave(ctx, slave) == -1) { if (--repeat == 0) { qDebug() << "Error set slave: " << errno; emit ModBusError(errno); return; } } else { repeat = 0; } } repeat = NumberOfRepeat; while(repeat) { if (modbus_read_input_registers(ctx, addr, size, data) == -1) { if (--repeat) { qDebug() << "Error read InputRegisters: " << errno; emit ModBusError(errno); return; } } else { repeat = 0; } } qDebug() << "Read OK" << repeat; emit ModBusOK(); }
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; }
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); }
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); } }
/* * @brief Reads a modbus RTU device's registers in an uint16_t array * @param const uint16_t *tab_reg, const unsigned int mb_slave_address, const unsigned int mb_reg_address, const unsigned int mb_reg_count * @return Number of uint16_t registers read, -1 if error */ int read_modbus_rtu_device(uint16_t tab_reg[], const unsigned int mb_slave_address, const unsigned int mb_reg_address, const unsigned int mb_reg_count) { int rc = 0; int ret = -1; if (tab_reg <= 0) return -1; modbus_t *ctx; ctx = modbus_new_rtu(MB_DEVICE_NAME, MB_BITRATE, MB_PARITY, MB_DATABITS, MB_STOPBITS); if (ctx == 0) goto ERROR_DATA; if (modbus_set_slave(ctx,mb_slave_address) != 0) goto ERROR_DATA; if (modbus_connect(ctx) != 0) goto ERROR_CONNECTION; /* since here the modbus connection is established successfully */ rc = modbus_read_registers(ctx,mb_reg_address,mb_reg_count,tab_reg); if (rc > 0) ret = rc; ERROR_CONNECTION: modbus_close(ctx); ERROR_DATA: modbus_free(ctx); return ret; }
//========================================================================================== 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; }
modbus_t* modbus_new_rtu_device(const char* serial_port, int slaveAddr) { modbus_t* context = modbus_new_rtu(serial_port, modbus_baud_rate_device_water_cool_boxihua, modbus_parity_device_water_cool_boxihua, modbus_databit_device_water_cool_boxihua, modbus_stopbit_device_water_cool_boxihua); if (context == NULL) { my_log_error("modbus_new_rtu"); return NULL; } #ifdef HAVE_DECL_TIOCSRS485 if (modbus_rtu_set_serial_mode(context, modbus_serial_mode_device_water_cool_boxihua) < 0) { my_log_error("modbus_rtu_set_serial_mode"); return NULL; } #endif if (modbus_set_slave(context, slaveAddr) < 0) { my_log_error("modbus_set_slave"); return NULL; } if (modbus_connect(context) < 0) { my_log_error("modbus_connect"); return NULL; } return context; }
int open_modbus(unsigned short slave_address, unsigned short baud_rate) { ctx = modbus_new_rtu("/dev/ttyUSB0", baud_rate, 'N', 8, 1); if (ctx == NULL) { fprintf(stderr, "Unable to create the libmodbus context\n"); return -1; } if (modbus_connect(ctx) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } printf("Modbus RTU context created at %u, N, 8bit, 1\n", baud_rate); modbus_set_slave(ctx,slave_address); printf("Set comm slave address: %u\n", slave_address); return 0; } // end open_modbus
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; }
/* At each loop, the program works in the range ADDRESS_START to * ADDRESS_END then ADDRESS_START + 1 to ADDRESS_END and so on. */ int main(void) { modbus_t *ctx; int rc; int nb_fail; int nb_loop; int addr; int nb; uint16_t *tab_rp_registers; char query[100]; int reg_address; /* RTU */ ctx = modbus_new_rtu("/dev/ttyUSB0", 9600, 'N', 8, 1); 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; } MYSQL *con = mysql_init(NULL); if (con == NULL) { fprintf(stderr, "%s\n", mysql_error(con)); exit(1); } if (mysql_real_connect(con, "localhost", "root", "root", NULL, 0, NULL, 0) == NULL) { fprintf(stderr, "%s\n", mysql_error(con)); mysql_close(con); exit(1); } if(mysql_select_db(con, "embedded")==0)/*success*/ printf( "Database Selected\n"); else printf( "Failed to connect to Database: Error: \n"); if (mysql_query(con, "select address from configuration")) { fprintf(stderr, "%s\n", mysql_error(con)); exit(1); } MYSQL_RES * res = mysql_use_result(con); nb = mysql_num_rows(res); tab_rp_registers = (uint16_t *) malloc(nb * sizeof(uint16_t)); memset(tab_rp_registers, 0, nb * sizeof(uint16_t)); MYSQL_ROW row; /* output table name */ printf("Addresses from database:\n"); while ((row = mysql_fetch_row(res)) != NULL) { reg_address = atoi(row[0]); addr = reg_address - 30000; printf("%i \n", addr); rc = modbus_read_input_registers(ctx, addr, 1, tab_rp_registers); if (rc == -1) { printf("ERROR modbus_read_input_registers (%d)\n", rc); nb_fail++; } else{ printf("Address = %d, value %d \n",addr, tab_rp_registers[0]); } sprintf(query, "INSERT INTO solar_panel_data (address, value) VALUES (%i, %d)", reg_address, tab_rp_registers[0]); printf("%s\n", query); /* if (mysql_query(con, "INSERT INTO solar_panel_data (address, value) VALUES (30001, 65273)")) { printf("ERROR writing to database"); } */ } mysql_free_result(res); //do the queries in to matrix if (mysql_query(con, "INSERT INTO solar_panel_data (address, value) VALUES (30001, 65273)")) { printf("ERROR writing to database"); } /* Free the memory */ free(tab_rp_registers); /* Close the connection */ modbus_close(ctx); modbus_free(ctx); mysql_close(con); return 0; }