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;
}
