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;
}
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;
}
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;
}
/* 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;
}
}
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;
}
/**
* 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;
}
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
}
}
int
m_read_register_one(modbus_t *ctx, int addr, uint16_t *reg1)
{
int ret;
ret = modbus_read_registers(ctx, addr, 1, reg1);
if (ret != 1) {
warnx("ERROR: modbus_read_registers(addr=%d): %d", addr, ret);
return -1;
}
return ret;
}
//==========================================================================================
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;
}
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;
}
}
/* Checks if the error is a watchdog error
If the error is a watchdog timeout, resets it and returns 0
Otherwise return -1
*/
int check_watchdog(modbus_t *mb) {
if(errno != EMBXSFAIL)
//Not a watchdog error
return -1;
uint16_t wd_status = 0;
int read_status = modbus_read_registers(mb, 4108, 1, &wd_status);
if (read_status == -1)
return -1;
if(modbus_write_register(mb, 4385, 0xBECF) == -1)
return -1;
if(modbus_write_register(mb, 4385, 0xAFFE) == -1)
return -1;
return 0;
}
/**********************************************************
* 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;
}
double ModBusReader::read()
{
int rc;
uint16_t tab_reg[16];
rc = modbus_read_registers(this->mb, this->register_number, 1, tab_reg);
if (rc == -1) {
throw modbus_strerror(errno);
}
if(this->debug == 1) {
std::cout << this->_address << ": " << ((double)tab_reg[0]/10) << std::endl;
}
return (double)((double)tab_reg[0]/10);
}
/**
* @brief Help function. FC3, FC4 request handler
*
* @fc Function code 3 and 4 only.
* @param handle Mbtcp handle.
* @param req cJSON request object.
* @return Modbus response string in JSON format.
*/
static char * mbtcp_read_reg_req(int fc, mbtcp_handle_s *handle, cJSON *req)
{
BEGIN(enable_syslog);
int addr = json_get_int(req, "addr");
int len = json_get_int(req, "len");
int tid = json_get_int(req, "tid");
if (len > MODBUS_MAX_READ_REGISTERS) // 125
{
return set_modbus_error_resp(tid, "Too many registers requested");
}
else
{
uint16_t regs[len];
// memory reset for variable length array
memset(regs, 0, len * sizeof(uint16_t));
int ret = 0;
switch (fc)
{
case 3:
ret = modbus_read_registers(handle->ctx, addr, len, regs);
break;
case 4:
ret = modbus_read_input_registers(handle->ctx, addr, len, regs);
break;
default:
return set_modbus_error_resp(tid, "Wrong function code");
}
if (ret < 0)
{
return set_modbus_errno_resp(tid, handle, errno);
}
else
{
LOG(enable_syslog, "fc:%d, desired length: %d, read length:%d", fc, len, ret);
// [todo]:remove; debug only
for (int ii = 0; ii < ret; ii++)
{
LOG(enable_syslog, "[%d]=%d", ii, regs[ii]);
}
// uint16_t array
return set_modbus_with_data_ok_resp(tid, cJSON_CreateUInt16Array(regs, len));
}
}
}
/*
* This Function sends modbus request and returns the response
* Arguments:
* unsigned char * fn :- Modbus request array. 1st byte is function code, next 2 bytes is address of register
* 4th 5th byte is no. of register. 6th 7th byte is data. Modbus response is sent back on
* 6th and 7th byte
* Return Value :- 0 : On successful
* -1 : on error
*/
int MBSendRequest(unsigned char *fn)
{
uint16_t address,NIitem,*data,data1 ;
int ret=0;
address = *(fn+1);
address = address<<8; // This is done so that data recieved is in big indian format.
address = address | (*(fn+2)); //It should be converted to little indian format
NIitem = *(fn+3);
NIitem = NIitem<<8;
NIitem = NIitem | *(fn+4);
data1 = *(fn+5);
data1 = data1<<8;
data1 = data1 | *(fn+6);
data = &data1;
printf("Function code = %d \n",*fn);
printf("register address = %x \n",address);
printf("NIitem = %x \n",NIitem);
printf("Data=%d\n",*data);
switch(*fn)
{
case 1:ret = modbus_read_bits(ctx,address,NIitem,(uint8_t*) data);
break;
case 2:ret = modbus_read_input_bits(ctx,address,NIitem,(uint8_t*) data);
break;
case 3:ret = modbus_read_registers(ctx,address,NIitem,data);
break;
case 4:ret = modbus_read_input_registers(ctx,address,NIitem,data);
break;
case 5:ret = modbus_write_bit(ctx,address,*data);
break;
case 6:ret = modbus_write_register(ctx,address,*data);
break;
case 15:ret = modbus_write_bits(ctx,address,NIitem,(uint8_t*) data);
break;
case 16:ret = modbus_write_registers(ctx,address,NIitem,data);
break;
}
*(fn+6)=((*data) >> 8)& 0x00ff;
*(fn+5)= (*data) & 0x00ff;
return ret;
}
int read_data(modbus_t *mb_ctx, slavedata_t *slavedata, haldata_t *hal_data_block) {
uint16_t receive_data[MODBUS_MAX_READ_REGISTERS]; /* a little padding in there */
int retval;
/* can't do anything with a null HAL data block */
if (hal_data_block == NULL)
return -1;
/* but we can signal an error if the other params are null */
if ((mb_ctx==NULL) || (slavedata == NULL)) {
hal_data_block->errorcount++;
return -1;
}
retval = modbus_read_registers(mb_ctx, slavedata->read_reg_start,
slavedata->read_reg_count, receive_data);
if (retval==slavedata->read_reg_count) {
retval = 0;
hal_data_block->retval = retval;
if (retval==0) {
*(hal_data_block->stat1) = receive_data[0];
*(hal_data_block->stat2) = receive_data[1];
*(hal_data_block->freq_cmd) = receive_data[2] * 0.1;
*(hal_data_block->freq_out) = receive_data[3] * 0.1;
if (receive_data[3]==0){ // JET if freq out is 0 then the drive is stopped
*(hal_data_block->is_stopped) = 1;
} else {
*(hal_data_block->is_stopped) = 0;
}
*(hal_data_block->curr_out) = receive_data[4] * 0.1;
*(hal_data_block->DCBusV) = receive_data[5] * 0.1;
*(hal_data_block->outV) = receive_data[6] * 0.1;
*(hal_data_block->RPM) = receive_data[7];
*(hal_data_block->scale_freq) = (receive_data[8] | (receive_data[9] << 16)) * 0.1;
*(hal_data_block->power_factor) = receive_data[10];
*(hal_data_block->load_pct) = receive_data[11] * 0.1;
*(hal_data_block->FW_Rev) = receive_data[12];
retval = 0;
}
} else {
hal_data_block->retval = retval;
hal_data_block->errorcount++;
retval = -1;
}
return retval;
}
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);
}
/**
* DOTASK
* Reads classic once per interval. Creates socket if not already open.
* Reads entire modbus range, and writes to data file.
*
* @arg nil
* @return (int) 0 good read, 1 partial read, 2 bad read
*
**/
int dotask(void){
//to allow local app to run:
//presence of DISABLE file disconnects the modbus connection
if (stat(ENABLE_FILE, &st) == -1) {
if (sock) { close(sock); sock=0; } //if still open, disconnect
return(9); //skip this sample regardless
}
//read the entire main register range into the buffer array
//for now ignore the half doz regs at 16385-16390
i=0;
if (!i) i= modbus_read_registers(4101, 50, 0 );
if (!i) i= modbus_read_registers(4151, 50, 50 );
if (!i) i= modbus_read_registers(4201, 50, 100);
if (!i) i= modbus_read_registers(4251, 50, 150);
if (!i) i= modbus_read_registers(4301, 50, 200);
if (!i) i= modbus_read_registers(4351, 44, 250); ///highest reg is currently 4395
//any problems skip write, so the prev entry stands
//however we need to consider pre 1609 firmware, todo
if (i) {
close(sock); sock=0; //this will force a new socket attempt next interval
log_message(LOG_FILE, "Modbus read error");
return(i);
}
//write registers to our data files
for (addr=4101; addr<=4395; addr++) {
i= modbus_register(addr);
//all to 'current' data file
fprintf(fp_t, "%d:%d\n", addr, i);
//write daily log registers
c=0;
while (rs[c]) {
if (addr==rs[c]) {
fprintf(fp_l, "%d:%d\t", addr, i);
break;
}
c++;
}
}
//done
return (0);
}
int PrintAll(modbus_t *ctx, uint16_t *tab_rp_registers, int num)
{
int i,j;
int start_add = 0x00;
int data_num;
int rc;
printf("\t---------------------------------------- Data ----------------------------------------\n");
printf("\t\t 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F\n");
printf("\t----------------------------------------------------------------------------------------");
// modbus library set maximum number of read data 0x125
//
for ( j=num ; j>0 ; j-=0x70 )
{
if ( j >= 0x70 )
data_num = 0x70;
else
data_num = j;
rc = modbus_read_registers(ctx, start_add,
data_num, tab_rp_registers);
if ( rc < 1 )
{
printf("read operation error\n"); // error
break; // for break
}
for (i=0 ; i<data_num ; i++ ) // print readed data
{
if ( i%16 == 0 )
printf("\n\t0x%02X\t", i+start_add);
printf(" %04X", *(tab_rp_registers+i));
}
start_add += 0x70; // move address
}
printf("\n\t----------------------------------------------------------------------------------------\n\n");
return 1;
}
/*
* @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;
}
/* 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);
}
static int _ctx_read_regs(lua_State *L, bool input)
{
ctx_t *ctx = ctx_check(L, 1);
int addr = luaL_checknumber(L, 2);
int count = luaL_checknumber(L, 3);
int rcount = 0;
int rc;
if (count > MODBUS_MAX_READ_REGISTERS) {
return luaL_argerror(L, 3, "requested too many registers");
}
// better malloc as much space as we need to return data here...
uint16_t *buf = malloc(count * sizeof(uint16_t));
assert(buf);
if (input) {
rc = modbus_read_input_registers(ctx->modbus, addr, count, buf);
} else {
rc = modbus_read_registers(ctx->modbus, addr, count, buf);
}
if (rc == count) {
lua_newtable(L);
/* nota bene, lua style offsets! */
for (int i = 1; i <= rc; i++) {
lua_pushnumber(L, i);
lua_pushnumber(L, buf[i-1]);
lua_settable(L, -3);
}
rcount = 1;
} else {
rcount = libmodbus_rc_to_nil_error(L, rc, count);
}
free(buf);
return rcount;
}
qint32 ModbusMaster::readRegisters(modbus_t * pCtx, quint16 startReg, quint32 num, QList<quint16> * pResultList)
{
qint32 rc = 0;
quint16 * aRegister = (quint16 *)malloc(num * sizeof(quint16));
if (modbus_read_registers(pCtx, startReg, num, aRegister) == -1)
{
rc = errno;
qDebug() << "MB: Read failed: " << modbus_strerror(errno) << endl;
}
else
{
pResultList->clear();
for (quint32 i = 0; i < num; i++)
{
pResultList->append(aRegister[i]);
}
}
free(aRegister);
return rc;
}
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);
}
void ThermalDevice::update() {
modbus_read_registers(ctx, 1, 2, regs);
}
ssize_t MeterModbus::read(std::vector<Reading> &rds, size_t max_readings) {
uint16_t in;
double out;
int rc;
const struct addressparam *current_address;
int read_count = 0;
if(_reset_connection) {
int success;
print(log_info, "Resetting Connection to %s because of error", name().c_str(), _ip.c_str());
rc = open();
if(rc == SUCCESS)
_reset_connection = false;
else
return 0;
}
current_address = _addressparams;
unsigned char highest_digit, power;
while((current_address->function_code != 0xFF) && (max_readings > read_count)) {
getHighestDigit(current_address->address, &highest_digit, &power);
switch(current_address->function_code){
case READ_HOLDING_REGISTERS:
print(log_debug, "Accessing Holding Register %u", name().c_str(), current_address->address);
rc = modbus_read_registers(_mb, current_address->address-4*(unsigned int)pow((double)10,(double)power)-1, 1, &in);
break;
case READ_INPUT_REGISTERS:
print(log_debug, "Accessing Input Register %u", name().c_str(), current_address->address);
rc = modbus_read_input_registers(_mb, current_address->address-3*(unsigned int)pow((double)10,(double)power)-1, 1, &in);
break;
case READ_COIL_STATUS:
print(log_debug, "Accessing Coil Status register %u", name().c_str(), current_address->address);
rc = modbus_read_bits(_mb, current_address->address, 1, (uint8_t *)&in);
break;
case READ_INPUT_STATUS:
print(log_debug, "Accessing Input Status register %u", name().c_str(), current_address->address);
rc = modbus_read_input_bits(_mb, current_address->address-2*(unsigned int)pow((double)10,(double)power)-1, 1, (uint8_t *)&in);
break;
}
if (rc == -1 && errno != 112345680) { //Except Illegal Data Address
print(log_error, "Unable to fetch data (FC: %u, ADR: %u): %s", name().c_str(), current_address->function_code, current_address->address, modbus_strerror(errno));
if(errno == 104 || errno == 32){
close();
_reset_connection = true;
}
return read_count;
}
if(rc == -1 && errno == 112345680){
print(log_error, "Unable to fetch data (FC: %u, ADR: %u): %s", name().c_str(), current_address->function_code, current_address->address, modbus_strerror(errno));
current_address++;
continue;
}
print(log_debug, "Got %u via Modbus", "", in);
// TODO ERRORS possible if wrong format string input from config file
char *math_expression;
asprintf(&math_expression, current_address->recalc_str, in);
print(log_debug, "Calulating: %s --> %s", "", current_address->recalc_str, math_expression);
out = parse_expression(math_expression);
if(isnan(out)) {
print(log_error, "Unable to use value read from address %u. Error calculating: %s", name().c_str(), current_address->address, math_expression);
}
else {
rds[read_count].value(out);
rds[read_count].time();
rds[read_count].identifier(new AddressIdentifier(current_address->address));
read_count++;
}
free(math_expression);
current_address++;
}
return read_count;
}
/* Read values from modbus */
uint8_t read_modbus(modbus_t *ctx, uint8_t readOrWrite, uint16_t modbusRegister, GenDataType_t typeOfValue, MoBuRegType_t typeOfReg, uint8_t desiredBit, uint16_t* valueArray)
{
uint8_t noOfRegisters = 0;
uint16_t modbusValueArray[2];
uint16_t modbusTmpValue; //used for bit values read from registers
memset(modbusValueArray, 0x00, (sizeof(uint16_t) * 2));
if (readOrWrite > 0) {
log_entry(APP_NAME, "invalid parameter in read_modbus: Only reading values supported");
printf("invalid parameter in read_modbus: Only reading values supported");
return -1;
}
switch (typeOfValue)
{
case bitCoil:
case sint16: // read one address
case uint16: //read one address
noOfRegisters = 1;
break;
case sint32: //read 2 registers
case uint32:
case float32:
noOfRegisters = 2;
break;
default:
log_entry(APP_NAME, "MODBUSD; unknown dataType");
printf("MODBUSD; unknown dataType: %d", typeOfValue);
}
switch (typeOfReg)
{
case coil:
if (0 == readOrWrite) { //read
if (1 != modbus_read_bits(ctx, modbusRegister, 1, (uint8_t *) modbusValueArray)) {
log_entry(APP_NAME, "MODBUSD: could not read coils");
printf("MODBUSD: could not read coils: %d, %s", modbusRegister, strerror(errno));
return -1;
}
} else {
/* first read the whole unit16 value */
if (1 == modbus_read_bits(ctx, modbusRegister, 1, (uint8_t *) modbusValueArray)) {
if (valueArray[0] == 0) {
modbusTmpValue = 0;
} else if (valueArray[0] == 1) {
//setting bit to 1
modbusTmpValue = 1;
} else {
//toggle the bit
if(0 == modbusValueArray[0]){
modbusTmpValue = 1;
}
else {
modbusTmpValue = 0;
}
}
if (1 != modbus_write_bit(ctx, modbusRegister, modbusTmpValue)) {
return -1;
}
}
}
break;
case discrete_input:
if (0 == readOrWrite) { //read
if (1 != modbus_read_input_bits(ctx, modbusRegister, noOfRegisters, (uint8_t *) &(modbusValueArray[0]))) {
log_entry(APP_NAME, "MODBUSD: could not read input");
printf("MODBUSD: could not read input: %d, %s", modbusRegister, strerror(errno));
return -1;
}
} else {
log_entry(APP_NAME, "MODBUSD: illegal operation -> unable to write on discrete input");
printf("MODBUSD: illegal operation -> unable to write on discrete input");
}
break;
case holding_register:
if (0 == readOrWrite) { //read
if (1 != modbus_read_registers(ctx, modbusRegister, noOfRegisters, &(modbusValueArray[0]))) {
return -1;
}
} else {
if (1 != modbus_write_registers(ctx, modbusRegister, noOfRegisters, &(valueArray[0]))) {
return -1;
}
}
break;
case input_register:
if (0 == readOrWrite) { //read
if (1 != modbus_read_input_registers(ctx, modbusRegister, noOfRegisters, &(modbusValueArray[0]))) {
log_entry(APP_NAME, "MODBUSD: could not read input registers");
printf("MODBUSD: could not read input registers: %d, %s", modbusRegister, strerror(errno));
return -1;
}
} else {
log_entry(APP_NAME, "unable to write on input register");
printf("unable to write on input register");
}
break;
case holding_bit:
if (0 == readOrWrite) { //read
if (1 == modbus_read_registers(ctx, modbusRegister, noOfRegisters, &modbusTmpValue)) {
modbusValueArray[0] = modbusTmpValue & (1 << desiredBit);
} else {
return -1;
}
} else {
/* first read the whole unit16 value */
if (1 == modbus_read_registers(ctx, modbusRegister, noOfRegisters, &modbusTmpValue)) {
if (valueArray[0] == 0) {
//clearing a bit at postion desired bit
modbusTmpValue &= ~(1 << desiredBit);
} else if (valueArray[0] == 1) {
//setting bit to 1
modbusTmpValue |= 1 << desiredBit;
} else {
//toggle the bit
modbusTmpValue ^= 1 << desiredBit;
}
if (1 != modbus_write_registers(ctx, modbusRegister, noOfRegisters, &modbusTmpValue)) {
return -1;
}
} else {
return -1;
}
}
break;
case input_bit:
if (0 == readOrWrite) { //read
if (1 == modbus_read_input_registers(ctx, modbusRegister, noOfRegisters, &modbusTmpValue)) {
modbusValueArray[0] = modbusTmpValue & (1 << desiredBit);
} else {
return -1;
}
} else {
log_entry(APP_NAME, "MODBUSD; unable to write single bit for input register");
printf("MODBUSD; unable to write single bit for input register");
return -1;
}
break;
default:
log_entry(APP_NAME, "MODBUSD; unknown register type");
printf("MODBUSD; unknown register type %d", typeOfReg);
}
if (0 == readOrWrite) { //read
valueArray[0] = modbusValueArray[0];
valueArray[1] = modbusValueArray[1];
}
return 1;
}
int connectToSlave(modbus_t *ctx)
{
uint16_t *tab_rp_registers; // for getting data from server( slave module )
int i,j; // for repeat
int nb_points; // number of register
int rc; // register counter
char query[QUERY_SIZE]; // for getting query
char sSlaveNum[3];
char sFuncCode[3];
char sRegiAdd[5];
char sRegiNum[5];
char sData[5];
char svData[MODBUS_MAX_WRITE_REGISTERS][5];
// MODBUS_MAX_WRITE_REGISTERS : set value in modbus.h
char sWriteNum[3]; // str for read data in query
uint16_t nSlaveNum;
uint16_t nFuncCode;
uint16_t nRegiAdd;
uint16_t nRegiNum;
uint16_t nData;
uint16_t nvData[MODBUS_MAX_WRITE_REGISTERS];
uint8_t nWriteNum; // variable for read data in query
/* Allocate and initialize the memory to store the registers */
nb_points = (UT_REGISTERS_NB > UT_INPUT_REGISTERS_NB) ?
UT_REGISTERS_NB : UT_INPUT_REGISTERS_NB;
tab_rp_registers = (uint16_t *) malloc(nb_points * sizeof(uint16_t));
memset(tab_rp_registers, 0, nb_points * sizeof(uint16_t));
while ( 1 )
{
memset(sSlaveNum, 0, sizeof(sSlaveNum) );
memset(sFuncCode, 0, sizeof(sFuncCode) );
memset(sRegiAdd, 0, sizeof(sRegiAdd) );
memset(sRegiNum, 0, sizeof(sRegiNum) );
memset(sData, 0, sizeof(sData) );
for ( i=0 ; i< MODBUS_MAX_WRITE_REGISTERS ; i++ )
memset(svData[i], 0, sizeof(svData[i]) );
memset(sWriteNum, 0, sizeof(sWriteNum) );
memset(query, 0, QUERY_SIZE);
// memory init
printf("\tinput Query ( \"q\" exit, \"all\" show all data, \"r\" random query )\n");
printf("\tQUERY : ");
scanf( "%s", query );
printf("\n");
if ( !strcmp( query, "q" ) ) // quit message
break; // while break
else if ( !strcmp( query, "all" ) )
{
PrintAll(ctx, tab_rp_registers, UT_REGISTERS_NB); // print all data
continue;
}
else if ( !strcmp( query, "r") ) // random code
{
printf("\t\"r3\" : 0x03 \"r6\" : 0x06 \"r1\" : 0x10\n\n");
continue;
}
else if ( !strcmp( query, "r3") )
RandomQuery( query, FUNC03 ); // make random code 0x03
else if ( !strcmp( query, "r6") )
RandomQuery( query, FUNC06 ); // make random code 0x06
else if ( !strcmp( query, "r1") )
RandomQuery( query, FUNC10 ); // make random code 0x10
else if ( !isHexCode(query) || strlen(query)<12 ) // if incorrect query inputed
{
printf("\tplease input correct query\n\n");
continue;
}
memcpy( sSlaveNum, (char *)&(query[0]), 2 );
memcpy( sFuncCode, (char *)&(query[2]), 2 );
memcpy( sRegiAdd, (char *)&(query[4]), 4 );
// get Slave ID, Function code, Register start address from query
nSlaveNum = strtol( sSlaveNum, NULL, 16 );
nFuncCode = strtol( sFuncCode, NULL, 16 );
nRegiAdd = strtol( sRegiAdd, NULL, 16);
// translate string to uint variable
switch ( nFuncCode )
{
/**/ case 0x03: // 3 read multiple data in RW register
/**/ case 0x04: // 4 read multiple data in RO register
{
if ( strlen(query) != 12 )
// func 0x03, 0x04 must have 16 byte len
// last 4 byte is CRC
// 16 - 4 = 12
{
printf("\tplease input correct query\n\n");
break; // switch break
}
memcpy( sRegiNum, (char *)&(query[8]), 4 );
nRegiNum = strtol( sRegiNum, NULL, 16);
rc = modbus_read_registers(ctx, nRegiAdd, nRegiNum, tab_rp_registers);
// func 0x03 in modbus library
if ( rc < 1 )
{
printf("read operation error\n"); // error
break; // switch break
}
printf("\t---------------------------------------- Data ----------------------------------------\n");
printf("\t\t 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F\n");
printf("\t----------------------------------------------------------------------------------------");
for (i=0 , j=nRegiAdd%0x10; i<nRegiNum+j ; i++ )
{
if ( i%16 == 0 )
printf("\n\t0x%02X\t", nRegiAdd-j+i);
if ( i >= j && i < j+nRegiNum )
printf(" %04X", *(tab_rp_registers+i-j));
else
printf(" ");
}
printf("\n\t----------------------------------------------------------------------------------------\n\n");
}
break; // switch break
/**/ case 0x06: // 6 write one data in RW register
{
if ( strlen(query) != 12 )
// func 0x06 must have 16 byte len
// last 4 byte is CRC
// 16 - 4 = 12
{
printf("\tplease input correct query\n\n");
break; // switch break
}
memcpy( sData, (char *)&(query[8]), 4 );
nData = strtol( sData, NULL, 16);
rc = modbus_write_register(ctx, nRegiAdd, nData);
// func 0x06 in modbus library
if ( rc != 1 )
{
printf("write operation error\n\n");
break; // switch break
}
printf("\n");
}
break;
/**/ case 0x10: // 16 write multiple data in RW register
{
memcpy( sRegiNum, (char *)&(query[8]), 4 );
memcpy( sWriteNum, (char *)&(query[12]), 2 );
nRegiNum = strtol( sRegiNum, NULL, 16);
nWriteNum = strtol( sWriteNum, NULL, 16);
if ( strlen(query) != 14+(nRegiNum*4)
|| nWriteNum != nRegiNum*2 )
{
// func 0x06 must have 16 byte len
// last 4 byte is CRC
// 16 - 4 = 12
printf("\tplease input correct query\n\n");
break; // switch break
}
for ( i=0 ; i< nRegiNum ; i++ )
{
memcpy( svData[i], (char *)&(query[14+(i*4)]), 4 );
nvData[i] = strtol( svData[i], NULL, 16);
}
printf("\n");
modbus_write_registers(ctx, nRegiAdd, nRegiNum, nvData);
// func 0x10 in modbus library
}
break; // switch break;
default :
printf("incorrect Function code.\n\n"); // function code is not 0x03, 0x06, 0x10
} // switch end
} // while end
printf("interface end.\n");
/* Free the memory */
free(tab_rp_registers);
}
