int main (int argc, char *argv[]) { ctx = setup_modbus(); /* declare storage types */ /* Arguments from command line returned to application */ gtk_init (&argc,&argv); /* Create the new window as the top level */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* set this window full screen. we shouldn't need otherwise */ gtk_window_fullscreen(GTK_WINDOW(window)); /* connect delete callback to quit gtk on program close */ g_signal_connect (GTK_OBJECT(window), "delete-event", GTK_SIGNAL_FUNC(gtk_exit), NULL); g_signal_connect (GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_exit), NULL); /* create a the main page */ vbox_main = create_button_page(main_page,6); /* show the main page */ gtk_widget_show(vbox_main); /* add the main page to the window */ gtk_container_add (GTK_CONTAINER(window),vbox_main); /* show window last, this way all subsequent widgets pop up * at once. */ gtk_widget_show(window); /* enter the main loop and watch the program go. */ gtk_main(); /* after exit of the main loop we need to free up the * modbus context and close the connection */ modbus_close(ctx); modbus_free(ctx); return 0; }
int schedule_reading() { int *read_schedule,re_try = 0; long read_wait; modbus_t *sdl; double sdl_data; uint16_t *rd_data_registers; modbus_t *rd_ctx; read_schedule = (int*)malloc(6*sizeof(int)); rd_data_registers = (uint16_t*)malloc(2*sizeof(uint16_t)); read_schedule = check_time(read_schedule); if((read_schedule[4]>=3) && (read_schedule[4]<=10)) { enable(0); initbus(1); sleep(1); rd_ctx= modbusconnection(rd_ctx); sleep(1); gotoposition(rd_ctx, 0,rd_data_registers); setconfig(9,0); wait_for_stop(rd_ctx,rd_data_registers); initbus(0); sdl_sample: sdl = sdl_connection(sdl); if(sdl == NULL) { if(re_try < 3){re_try++;goto sdl_sample;} else { login("Failed in connecting in sample duration"); setsdl(30000,-100000); } } else { sdl_read_sensor(sdl,1,0); sleep(30); sample_save_data(sdl); } modbus_close(sdl); } return 1; }
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); }
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; }
modbus_t* RbCtrlIface::initializeSerialModbus( const char *device, int baud, char parity, int data_bit, int stop_bit ) { // >>>>> Simulation? if(mSimulActive) return NULL; // <<<<< Simulation? if( mModbus ) { modbus_close( mModbus ); modbus_free( mModbus ); } mModbus = modbus_new_rtu( device, baud, parity, data_bit, stop_bit ); return mModbus; }
/********************************************************************* * Function: doExit() * * Description: Signal handler function to do a clean shutdown * * Parameters: the received signal * ********************************************************************/ static void doExit(int signum) { pid_t pid=getpid(); syslog(LOG_DAEMON | LOG_NOTICE, "caught signal %d in process %d\n", signum, pid); switch (signum) { case SIGTERM: case SIGINT: /* Clean up and terminate */ modbus_close(mb); modbus_free(mb); syslog(LOG_DAEMON | LOG_NOTICE, "Exiting Modbus RTU daemon\n"); closelog(); kill(pid, SIGKILL); break; default: syslog(LOG_DAEMON | LOG_ERR, "unexpected signal received\n"); } }
/* Sends a request/response */ static int send_msg(modbus_t *ctx, uint8_t *msg, int msg_length) { int rc; int i; msg_length = ctx->backend->send_msg_pre(msg, msg_length); if (ctx->debug) { for (i = 0; i < msg_length; i++) printf("[%.2X]", msg[i]); printf("\n"); } /* In recovery mode, the write command will be issued until to be successful! Disabled by default. */ do { rc = ctx->backend->send(ctx, msg, msg_length); if (rc == -1) { _error_print(ctx, NULL); if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) { int saved_errno = errno; if ((errno == EBADF || errno == ECONNRESET || errno == EPIPE)) { modbus_close(ctx); modbus_connect(ctx); } else { _sleep_and_flush(ctx); } errno = saved_errno; } } } while ((ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) && rc == -1); if (rc > 0 && rc != msg_length) { errno = EMBBADDATA; return -1; } return rc; }
/* * @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 main(void) { int socket; modbus_param_t mb_param; modbus_mapping_t mb_mapping; int ret; modbus_init_tcp(&mb_param, "127.0.0.1", 1502); ret = modbus_mapping_new(&mb_mapping, MAX_STATUS, 0, MAX_REGISTERS, 0); if (ret == FALSE) { printf("Memory allocation failed\n"); exit(1); } socket = modbus_init_listen_tcp(&mb_param); while (1) { uint8_t query[MAX_MESSAGE_LENGTH]; int query_size; ret = modbus_listen(&mb_param, query, &query_size); if (ret == 0) { modbus_manage_query(&mb_param, query, query_size, &mb_mapping); } else if (ret == CONNECTION_CLOSED) { /* Connection closed by the client, end of server */ break; } else { printf("Error in modbus_listen (%d)\n", ret); } } close(socket); modbus_mapping_free(&mb_mapping); modbus_close(&mb_param); return 0; }
/* 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); }
int main(int argc, char *argv[]) { srand((unsigned)time(NULL)); int ctxnum = 0; int i; int sel = 1; modbus_t *ctx[SLAVE_NUM]; // modbus structure, save connect data char portName[SLAVE_NUM][100]; // for save port name int slaveID[SLAVE_NUM]; // for save slave id int bitRate[SLAVE_NUM]; // for save bit rate char parity[SLAVE_NUM]; // for save parity option for ( i=0 ; i<SLAVE_NUM ; i++ ) ctx[i] = NULL; if ( argc != 1 ) { printf("Usage : %s\n", argv[0] ); exit(1); } /* if ( argc == 2 ) if ( !strcmp( argv[1], "ON" )) modbus_set_debug(ctx, TRUE); */ while ( sel != -2 ) { for ( i=0 ; i<ctxnum ; i++ ) printf("%4d. %s %d %d %c\n", i, portName[i], slaveID[i], bitRate[i], parity[i] ); printf(" -1. make new connect\n"); printf(" -2. quit\n"); printf(" sel : "); scanf("%d", &sel); switch ( sel ) { case -1 : { if ( ctxnum == 246 ) printf("\nconnection is full!!!\n\n"); printf("\n\tinput port name : "); scanf("%s", portName[ctxnum]); printf("\tinput slave ID : "); scanf("%d", &slaveID[ctxnum]); printf("\tinput bit rate : "); scanf("%d", &bitRate[ctxnum]); printf("\tinput parity : "); fgetc(stdin); parity[ctxnum] = fgetc(stdin); ctx[ctxnum] = modbus_new_rtu(portName[ctxnum], bitRate[ctxnum], parity[ctxnum], 8, 1); // make rtu connection if (ctx[ctxnum] == NULL) { // error fprintf(stderr, "Unable to allocate libmodbus context\n"); return -1; } modbus_set_error_recovery(ctx[ctxnum], MODBUS_ERROR_RECOVERY_LINK | MODBUS_ERROR_RECOVERY_PROTOCOL); modbus_set_slave(ctx[ctxnum], slaveID[ctxnum]); // set slave number if (modbus_connect(ctx[ctxnum]) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); modbus_free(ctx[ctxnum]); return -1; } ctxnum++; printf("\n"); } break; case -2 : printf("exit client module (master)\n"); break; default : if ( ctx[sel] == NULL || sel <-2 || sel>246 ) printf("\ninput correct number.\n\n"); // error input else connectToSlave(ctx[sel]); // cennect to slave } } /* Close the connection */ for ( i=0 ; i<SLAVE_NUM; i++ ) { if ( ctx[i] != NULL ) { modbus_close(ctx[i]); modbus_free(ctx[i]); } } return 0; }
MeterModbus::~MeterModbus() { if(!_reset_connection){ modbus_close(_mb); modbus_free(_mb); } }
int _modbus_receive_msg(modbus_t *ctx, uint8_t *msg, msg_type_t msg_type) { int rc; fd_set rset; struct timeval tv; struct timeval *p_tv; int length_to_read; int msg_length = 0; _step_t step; if (ctx->debug) { if (msg_type == MSG_INDICATION) { printf("Waiting for a indication...\n"); } else { printf("Waiting for a confirmation...\n"); } } /* Add a file descriptor to the set */ FD_ZERO(&rset); FD_SET(ctx->s, &rset); /* We need to analyse the message step by step. At the first step, we want * to reach the function code because all packets contain this * information. */ step = _STEP_FUNCTION; length_to_read = ctx->backend->header_length + 1; if (msg_type == MSG_INDICATION) { /* Wait for a message, we don't know when the message will be * received */ p_tv = NULL; } else { tv.tv_sec = ctx->response_timeout.tv_sec; tv.tv_usec = ctx->response_timeout.tv_usec; p_tv = &tv; } while (length_to_read != 0) { rc = ctx->backend->select(ctx, &rset, p_tv, length_to_read); if (rc == -1) { _error_print(ctx, "select"); if (ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) { int saved_errno = errno; if (errno == ETIMEDOUT) { _sleep_and_flush(ctx); } else if (errno == EBADF) { modbus_close(ctx); modbus_connect(ctx); } errno = saved_errno; } return -1; } rc = ctx->backend->recv(ctx, msg + msg_length, length_to_read); if (rc == 0) { errno = ECONNRESET; rc = -1; } if (rc == -1) { _error_print(ctx, "read"); if ((ctx->error_recovery & MODBUS_ERROR_RECOVERY_LINK) && (errno == ECONNRESET || errno == ECONNREFUSED || errno == EBADF)) { int saved_errno = errno; modbus_close(ctx); modbus_connect(ctx); /* Could be removed by previous calls */ errno = saved_errno; } return -1; } /* Display the hex code of each character received */ if (ctx->debug) { int i; for (i=0; i < rc; i++) printf("<%.2X>", msg[msg_length + i]); } /* Sums bytes received */ msg_length += rc; /* Computes remaining bytes */ length_to_read -= rc; if (length_to_read == 0) { switch (step) { case _STEP_FUNCTION: /* Function code position */ length_to_read = compute_meta_length_after_function( msg[ctx->backend->header_length], msg_type); if (length_to_read != 0) { step = _STEP_META; break; } /* else switches straight to the next step */ case _STEP_META: length_to_read = compute_data_length_after_meta( ctx, msg, msg_type); if ((msg_length + length_to_read) > ctx->backend->max_adu_length) { errno = EMBBADDATA; _error_print(ctx, "too many data"); return -1; } step = _STEP_DATA; break; default: break; } } if (length_to_read > 0 && ctx->byte_timeout.tv_sec != -1) { /* If there is no character in the buffer, the allowed timeout interval between two consecutive bytes is defined by byte_timeout */ tv.tv_sec = ctx->byte_timeout.tv_sec; tv.tv_usec = ctx->byte_timeout.tv_usec; p_tv = &tv; } } if (ctx->debug) printf("\n"); return ctx->backend->check_integrity(ctx, msg, msg_length); }
static int mb_read_data (mb_host_t *host, mb_slave_t *slave, /* {{{ */ mb_data_t *data) { uint16_t values[2]; int values_num; const data_set_t *ds; int status; int i; if ((host == NULL) || (slave == NULL) || (data == NULL)) return (EINVAL); ds = plugin_get_ds (data->type); if (ds == NULL) { ERROR ("Modbus plugin: Type \"%s\" is not defined.", data->type); return (-1); } if (ds->ds_num != 1) { ERROR ("Modbus plugin: The type \"%s\" has %i data sources. " "I can only handle data sets with only one data source.", data->type, ds->ds_num); return (-1); } if ((ds->ds[0].type != DS_TYPE_GAUGE) && (data->register_type != REG_TYPE_UINT32)) { NOTICE ("Modbus plugin: The data source of type \"%s\" is %s, not gauge. " "This will most likely result in problems, because the register type " "is not UINT32.", data->type, DS_TYPE_TO_STRING (ds->ds[0].type)); } memset (values, 0, sizeof (values)); if ((data->register_type == REG_TYPE_UINT32) || (data->register_type == REG_TYPE_FLOAT)) values_num = 2; else values_num = 1; #if LEGACY_LIBMODBUS /* Version 2.0.3: Pass the connection struct as a pointer and pass the slave * id to each call of "read_holding_registers". */ # define modbus_read_registers(ctx, addr, nb, dest) \ read_holding_registers (&(ctx), slave->id, (addr), (nb), (dest)) #else /* if !LEGACY_LIBMODBUS */ /* Version 2.9.2: Set the slave id once before querying the registers. */ status = modbus_set_slave (host->connection, slave->id); if (status != 0) { ERROR ("Modbus plugin: modbus_set_slave (%i) failed with status %i.", slave->id, status); return (-1); } #endif for (i = 0; i < 2; i++) { status = modbus_read_registers (host->connection, /* start_addr = */ data->register_base, /* num_registers = */ values_num, /* buffer = */ values); if (status > 0) break; if (host->is_connected) { #if LEGACY_LIBMODBUS modbus_close (&host->connection); host->is_connected = 0; #else modbus_close (host->connection); modbus_free (host->connection); host->connection = NULL; #endif } /* If we already tried reconnecting this round, give up. */ if (host->have_reconnected) { ERROR ("Modbus plugin: modbus_read_registers (%s) failed. " "Reconnecting has already been tried. Giving up.", host->host); return (-1); } /* Maybe the device closed the connection during the waiting interval. * Try re-establishing the connection. */ status = mb_init_connection (host); if (status != 0) { ERROR ("Modbus plugin: modbus_read_registers (%s) failed. " "While trying to reconnect, connecting to \"%s\" failed. " "Giving up.", host->host, host->node); return (-1); } DEBUG ("Modbus plugin: Re-established connection to %s", host->host); /* try again */ continue; } /* for (i = 0, 1) */ DEBUG ("Modbus plugin: mb_read_data: Success! " "modbus_read_registers returned with status %i.", status); if (data->register_type == REG_TYPE_FLOAT) { float float_value; value_t vt; float_value = mb_register_to_float (values[0], values[1]); DEBUG ("Modbus plugin: mb_read_data: " "Returned float value is %g", (double) float_value); CAST_TO_VALUE_T (ds, vt, float_value); mb_submit (host, slave, data, vt); } else if (data->register_type == REG_TYPE_UINT32) { uint32_t v32; value_t vt; v32 = (values[0] << 16) | values[1]; DEBUG ("Modbus plugin: mb_read_data: " "Returned uint32 value is %"PRIu32, v32); CAST_TO_VALUE_T (ds, vt, v32); mb_submit (host, slave, data, vt); } else /* if (data->register_type == REG_TYPE_UINT16) */ { value_t vt; DEBUG ("Modbus plugin: mb_read_data: " "Returned uint16 value is %"PRIu16, values[0]); CAST_TO_VALUE_T (ds, vt, values[0]); mb_submit (host, slave, data, vt); } return (0); } /* }}} int mb_read_data */
int main(void) { uint8_t *tab_rp_status; uint16_t *tab_rp_registers; modbus_param_t mb_param; int i; uint8_t value; int address; int nb_points; int ret; /* RTU parity : none, even, odd */ /* modbus_init_rtu(&mb_param, "/dev/ttyS0", 19200, "none", 8, 1); */ /* TCP */ modbus_init_tcp(&mb_param, "127.0.0.1", 1502); /* modbus_set_debug(&mb_param, TRUE);*/ if (modbus_connect(&mb_param) == -1) { printf("ERROR Connection failed\n"); exit(1); } /* Allocate and initialize the memory to store the status */ nb_points = (UT_COIL_STATUS_NB_POINTS > UT_INPUT_STATUS_NB_POINTS) ? UT_COIL_STATUS_NB_POINTS : UT_INPUT_STATUS_NB_POINTS; tab_rp_status = (uint8_t *) malloc(nb_points * sizeof(uint8_t)); memset(tab_rp_status, 0, nb_points * sizeof(uint8_t)); /* Allocate and initialize the memory to store the registers */ nb_points = (UT_HOLDING_REGISTERS_NB_POINTS > UT_INPUT_REGISTERS_NB_POINTS) ? UT_HOLDING_REGISTERS_NB_POINTS : UT_INPUT_REGISTERS_NB_POINTS; tab_rp_registers = (uint16_t *) malloc(nb_points * sizeof(uint16_t)); memset(tab_rp_registers, 0, nb_points * sizeof(uint16_t)); printf("** UNIT TESTING **\n"); printf("\nTEST WRITE/READ:\n"); /** COIL STATUS **/ /* Single */ ret = force_single_coil(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, ON); printf("1/2 force_single_coil: "); if (ret == 1) { printf("OK\n"); } else { printf("FAILED\n"); goto close; } ret = read_coil_status(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, 1, tab_rp_status); printf("2/2 read_coil_status: "); if (ret != 1) { printf("FAILED (nb points %d)\n", ret); goto close; } if (tab_rp_status[0] != ON) { printf("FAILED (%0X = != %0X)\n", tab_rp_status[0], ON); goto close; } printf("OK\n"); /* End single */ /* Multiple coils */ { uint8_t tab_value[UT_COIL_STATUS_NB_POINTS]; set_bits_from_bytes(tab_value, 0, UT_COIL_STATUS_NB_POINTS, UT_COIL_STATUS_TAB); ret = force_multiple_coils(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, UT_COIL_STATUS_NB_POINTS, tab_value); printf("1/2 force_multiple_coils: "); if (ret == UT_COIL_STATUS_NB_POINTS) { printf("OK\n"); } else { printf("FAILED\n"); goto close; } } ret = read_coil_status(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, UT_COIL_STATUS_NB_POINTS, tab_rp_status); printf("2/2 read_coil_status: "); if (ret != UT_COIL_STATUS_NB_POINTS) { printf("FAILED (nb points %d)\n", ret); goto close; } i = 0; address = UT_COIL_STATUS_ADDRESS; nb_points = UT_COIL_STATUS_NB_POINTS; while (nb_points > 0) { int nb_bits = (nb_points > 8) ? 8 : nb_points; value = get_byte_from_bits(tab_rp_status, i*8, nb_bits); if (value != UT_COIL_STATUS_TAB[i]) { printf("FAILED (%0X != %0X)\n", value, UT_COIL_STATUS_TAB[i]); goto close; } nb_points -= nb_bits; i++; } printf("OK\n"); /* End of multiple coils */ /** INPUT STATUS **/ ret = read_input_status(&mb_param, SLAVE, UT_INPUT_STATUS_ADDRESS, UT_INPUT_STATUS_NB_POINTS, tab_rp_status); printf("1/1 read_input_status: "); if (ret != UT_INPUT_STATUS_NB_POINTS) { printf("FAILED (nb points %d)\n", ret); goto close; } i = 0; address = UT_INPUT_STATUS_ADDRESS; nb_points = UT_INPUT_STATUS_NB_POINTS; while (nb_points > 0) { int nb_bits = (nb_points > 8) ? 8 : nb_points; value = get_byte_from_bits(tab_rp_status, i*8, nb_bits); if (value != UT_INPUT_STATUS_TAB[i]) { printf("FAILED (%0X != %0X)\n", value, UT_INPUT_STATUS_TAB[i]); goto close; } nb_points -= nb_bits; i++; } printf("OK\n"); /** HOLDING REGISTERS **/ /* Single register */ ret = preset_single_register(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS, 0x1234); printf("1/2 preset_single_register: "); if (ret == 1) { printf("OK\n"); } else { printf("FAILED\n"); goto close; } ret = read_holding_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS, 1, tab_rp_registers); printf("2/2 read_holding_registers: "); if (ret != 1) { printf("FAILED (nb points %d)\n", ret); goto close; } if (tab_rp_registers[0] != 0x1234) { printf("FAILED (%0X != %0X)\n", tab_rp_registers[0], 0x1234); goto close; } printf("OK\n"); /* End of single register */ /* Many registers */ ret = preset_multiple_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS, UT_HOLDING_REGISTERS_NB_POINTS, UT_HOLDING_REGISTERS_TAB); printf("1/2 preset_multiple_registers: "); if (ret == UT_HOLDING_REGISTERS_NB_POINTS) { printf("OK\n"); } else { printf("FAILED\n"); goto close; } ret = read_holding_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS, UT_HOLDING_REGISTERS_NB_POINTS, tab_rp_registers); printf("2/2 read_holding_registers: "); if (ret != UT_HOLDING_REGISTERS_NB_POINTS) { printf("FAILED (nb points %d)\n", ret); goto close; } for (i=0; i < UT_HOLDING_REGISTERS_NB_POINTS; i++) { if (tab_rp_registers[i] != UT_HOLDING_REGISTERS_TAB[i]) { printf("FAILED (%0X != %0X)\n", tab_rp_registers[i], UT_HOLDING_REGISTERS_TAB[i]); goto close; } } printf("OK\n"); /* End of many registers */ /** INPUT REGISTERS **/ ret = read_input_registers(&mb_param, SLAVE, UT_INPUT_REGISTERS_ADDRESS, UT_INPUT_REGISTERS_NB_POINTS, tab_rp_registers); printf("1/1 read_input_registers: "); if (ret != UT_INPUT_REGISTERS_NB_POINTS) { printf("FAILED (nb points %d)\n", ret); goto close; } for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) { if (tab_rp_registers[i] != UT_INPUT_REGISTERS_TAB[i]) { printf("FAILED (%0X != %0X)\n", tab_rp_registers[i], UT_INPUT_REGISTERS_TAB[i]); goto close; } } printf("OK\n"); /** ILLEGAL DATA ADDRESS **/ printf("\nTEST ILLEGAL DATA ADDRESS:\n"); /* The mapping begins at 0 and ending at address + nb_points so * the addresses below are not valid. */ ret = read_coil_status(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, UT_COIL_STATUS_NB_POINTS + 1, tab_rp_status); printf("* read_coil_status: "); if (ret == ILLEGAL_DATA_ADDRESS) printf("OK\n"); else printf("FAILED\n"); ret = read_input_status(&mb_param, SLAVE, UT_INPUT_STATUS_ADDRESS, UT_INPUT_STATUS_NB_POINTS + 1, tab_rp_status); printf("* read_input_status: "); if (ret == ILLEGAL_DATA_ADDRESS) printf("OK\n"); else printf("FAILED\n"); ret = read_holding_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS, UT_HOLDING_REGISTERS_NB_POINTS + 1, tab_rp_registers); printf("* read_holding_registers: "); if (ret == ILLEGAL_DATA_ADDRESS) printf("OK\n"); else printf("FAILED\n"); ret = read_input_registers(&mb_param, SLAVE, UT_INPUT_REGISTERS_ADDRESS, UT_INPUT_REGISTERS_NB_POINTS + 1, tab_rp_registers); printf("* read_input_registers: "); if (ret == ILLEGAL_DATA_ADDRESS) printf("OK\n"); else printf("FAILED\n"); ret = force_single_coil(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS, ON); printf("* force_single_coil: "); if (ret == ILLEGAL_DATA_ADDRESS) { printf("OK\n"); } else { printf("FAILED\n"); } ret = force_multiple_coils(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS + UT_COIL_STATUS_NB_POINTS, UT_COIL_STATUS_NB_POINTS, tab_rp_status); printf("* force_multiple_coils: "); if (ret == ILLEGAL_DATA_ADDRESS) { printf("OK\n"); } else { printf("FAILED\n"); } ret = preset_multiple_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS + UT_HOLDING_REGISTERS_NB_POINTS, UT_HOLDING_REGISTERS_NB_POINTS, tab_rp_registers); printf("* preset_multiple_registers: "); if (ret == ILLEGAL_DATA_ADDRESS) { printf("OK\n"); } else { printf("FAILED\n"); } /** TOO MANY DATA **/ printf("\nTEST TOO MANY DATA ERROR:\n"); ret = read_coil_status(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, MAX_STATUS + 1, tab_rp_status); printf("* read_coil_status: "); if (ret == TOO_MANY_DATA) printf("OK\n"); else printf("FAILED\n"); ret = read_input_status(&mb_param, SLAVE, UT_INPUT_STATUS_ADDRESS, MAX_STATUS + 1, tab_rp_status); printf("* read_input_status: "); if (ret == TOO_MANY_DATA) printf("OK\n"); else printf("FAILED\n"); ret = read_holding_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS, MAX_REGISTERS + 1, tab_rp_registers); printf("* read_holding_registers: "); if (ret == TOO_MANY_DATA) printf("OK\n"); else printf("FAILED\n"); ret = read_input_registers(&mb_param, SLAVE, UT_INPUT_REGISTERS_ADDRESS, MAX_REGISTERS + 1, tab_rp_registers); printf("* read_input_registers: "); if (ret == TOO_MANY_DATA) printf("OK\n"); else printf("FAILED\n"); ret = force_multiple_coils(&mb_param, SLAVE, UT_COIL_STATUS_ADDRESS, MAX_STATUS + 1, tab_rp_status); printf("* force_multiple_coils: "); if (ret == TOO_MANY_DATA) { printf("OK\n"); } else { printf("FAILED\n"); } ret = preset_multiple_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS, MAX_REGISTERS + 1, tab_rp_registers); printf("* preset_multiple_registers: "); if (ret == TOO_MANY_DATA) { printf("OK\n"); } else { printf("FAILED\n"); } /** BAD RESPONSE **/ printf("\nTEST BAD RESPONSE ERROR:\n"); /* Allocate only the required space */ uint16_t *tab_rp_registers_bad = (uint16_t *) malloc( UT_HOLDING_REGISTERS_NB_POINTS_SPECIAL * sizeof(uint16_t)); ret = read_holding_registers(&mb_param, SLAVE, UT_HOLDING_REGISTERS_ADDRESS, UT_HOLDING_REGISTERS_NB_POINTS_SPECIAL, tab_rp_registers_bad); printf("* read_holding_registers: "); if (ret > 0) { /* Error not detected */ printf("FAILED\n"); } else { printf("OK\n"); } free(tab_rp_registers_bad); close: /* Free the memory */ free(tab_rp_status); free(tab_rp_registers); /* Close the connection */ modbus_close(&mb_param); return 0; }
int _modbus_rtu_select(modbus_t *ctx, fd_set *rfds, struct timeval *tv, int msg_length_computed, int msg_length) { int s_rc; #if defined(_WIN32) s_rc = win32_ser_select(&(((modbus_rtu_t*)ctx->backend_data)->w_ser), msg_length_computed, tv); if (s_rc == 0) { errno = ETIMEDOUT; return -1; } if (s_rc < 0) { _error_print(ctx, "select"); if (ctx->error_recovery && (errno == EBADF)) { modbus_close(ctx); modbus_connect(ctx); errno = EBADF; return -1; } else { return -1; } } #else while ((s_rc = select(ctx->s+1, rfds, NULL, NULL, tv)) == -1) { if (errno == EINTR) { if (ctx->debug) { fprintf(stderr, "A non blocked signal was caught\n"); } /* Necessary after an error */ FD_ZERO(rfds); FD_SET(ctx->s, rfds); } else { _error_print(ctx, "select"); if (ctx->error_recovery && (errno == EBADF)) { modbus_close(ctx); modbus_connect(ctx); errno = EBADF; return -1; } else { return -1; } } } if (s_rc == 0) { /* Timeout */ if (msg_length == (ctx->backend->header_length + 2 + ctx->backend->checksum_length)) { /* Optimization allowed because exception response is the smallest trame in modbus protocol (3) so always raise a timeout error. Temporary error before exception analyze. */ errno = EMBUNKEXC; } else { errno = ETIMEDOUT; _error_print(ctx, "select"); } return -1; } #endif return s_rc; }
/* 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; }
int main(int argc, char **argv) { int retval = 0; modbus_t *mb_ctx; haldata_t *haldata; slavedata_t slavedata; int slave; int hal_comp_id; struct timespec loop_timespec, remaining; int baud, bits, stopbits, verbose; char *device, *endarg; char parity; int opt; int argindex, argvalue; done = 0; // assume that nothing is specified on the command line baud = 38400; bits = 8; stopbits = 1; verbose = 0; device = "/dev/ttyS0"; parity = 'O'; /* slave / register info */ slave = 1; slavedata.read_reg_start = START_REGISTER_R; slavedata.read_reg_count = NUM_REGISTERS_R; slavedata.write_reg_start = START_REGISTER_W; slavedata.write_reg_count = NUM_REGISTERS_R; // process command line options while ((opt=getopt_long(argc, argv, option_string, long_options, NULL)) != -1) { switch(opt) { case 'b': // serial data bits, probably should be 8 (and defaults to 8) argindex=match_string(optarg, bitstrings); if (argindex<0) { printf("gs2_vfd: ERROR: invalid number of bits: %s\n", optarg); retval = -1; goto out_noclose; } bits = atoi(bitstrings[argindex]); break; case 'd': // device name, default /dev/ttyS0 // could check the device name here, but we'll leave it to the library open if (strlen(optarg) > FILENAME_MAX) { printf("gs2_vfd: ERROR: device node name is too long: %s\n", optarg); retval = -1; goto out_noclose; } device = strdup(optarg); break; case 'g': case 'v': verbose = 1; break; case 'n': // module base name if (strlen(optarg) > HAL_NAME_LEN-20) { printf("gs2_vfd: ERROR: HAL module name too long: %s\n", optarg); retval = -1; goto out_noclose; } modname = strdup(optarg); break; case 'p': // parity, should be a string like "even", "odd", or "none" argindex=match_string(optarg, paritystrings); if (argindex<0) { printf("gs2_vfd: ERROR: invalid parity: %s\n", optarg); retval = -1; goto out_noclose; } parity = paritychars[argindex]; break; case 'r': // Baud rate, 38400 default argindex=match_string(optarg, ratestrings); if (argindex<0) { printf("gs2_vfd: ERROR: invalid baud rate: %s\n", optarg); retval = -1; goto out_noclose; } baud = atoi(ratestrings[argindex]); break; case 's': // stop bits, defaults to 1 argindex=match_string(optarg, stopstrings); if (argindex<0) { printf("gs2_vfd: ERROR: invalid number of stop bits: %s\n", optarg); retval = -1; goto out_noclose; } stopbits = atoi(stopstrings[argindex]); break; case 't': // target number (MODBUS ID), default 1 argvalue = strtol(optarg, &endarg, 10); if ((*endarg != '\0') || (argvalue < 1) || (argvalue > 254)) { printf("gs2_vfd: ERROR: invalid slave number: %s\n", optarg); retval = -1; goto out_noclose; } slave = argvalue; break; case 'h': default: usage(argc, argv); exit(0); break; } } printf("%s: device='%s', baud=%d, parity='%c', bits=%d, stopbits=%d, address=%d, verbose=%d\n", modname, device, baud, parity, bits, stopbits, slave, verbose); /* point TERM and INT signals at our quit function */ /* if a signal is received between here and the main loop, it should prevent some initialization from happening */ signal(SIGINT, quit); signal(SIGTERM, quit); /* Assume 38.4k O-8-1 serial settings, device 1 */ mb_ctx = modbus_new_rtu(device, baud, parity, bits, stopbits); if (mb_ctx == NULL) { printf("%s: ERROR: couldn't open modbus serial device: %s\n", modname, modbus_strerror(errno)); goto out_noclose; } /* the open has got to work, or we're out of business */ if (((retval = modbus_connect(mb_ctx))!=0) || done) { printf("%s: ERROR: couldn't open serial device: %s\n", modname, modbus_strerror(errno)); goto out_noclose; } modbus_set_debug(mb_ctx, verbose); modbus_set_slave(mb_ctx, slave); /* create HAL component */ hal_comp_id = hal_init(modname); if ((hal_comp_id < 0) || done) { printf("%s: ERROR: hal_init failed\n", modname); retval = hal_comp_id; goto out_close; } /* grab some shmem to store the HAL data in */ haldata = (haldata_t *)hal_malloc(sizeof(haldata_t)); if ((haldata == 0) || done) { printf("%s: ERROR: unable to allocate shared memory\n", modname); retval = -1; goto out_close; } retval = hal_pin_s32_newf(HAL_OUT, &(haldata->stat1), hal_comp_id, "%s.status-1", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_s32_newf(HAL_OUT, &(haldata->stat2), hal_comp_id, "%s.status-2", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_OUT, &(haldata->freq_cmd), hal_comp_id, "%s.frequency-command", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_OUT, &(haldata->freq_out), hal_comp_id, "%s.frequency-out", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_OUT, &(haldata->curr_out), hal_comp_id, "%s.output-current", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_OUT, &(haldata->DCBusV), hal_comp_id, "%s.DC-bus-volts", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_OUT, &(haldata->outV), hal_comp_id, "%s.output-voltage", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_OUT, &(haldata->RPM), hal_comp_id, "%s.motor-RPM", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_OUT, &(haldata->scale_freq), hal_comp_id, "%s.scale-frequency", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_OUT, &(haldata->power_factor), hal_comp_id, "%s.power-factor", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_OUT, &(haldata->load_pct), hal_comp_id, "%s.load-percentage", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_s32_newf(HAL_OUT, &(haldata->FW_Rev), hal_comp_id, "%s.firmware-revision", modname); if (retval!=0) goto out_closeHAL; retval = hal_param_s32_newf(HAL_RW, &(haldata->errorcount), hal_comp_id, "%s.error-count", modname); if (retval!=0) goto out_closeHAL; retval = hal_param_float_newf(HAL_RW, &(haldata->looptime), hal_comp_id, "%s.loop-time", modname); if (retval!=0) goto out_closeHAL; retval = hal_param_s32_newf(HAL_RW, &(haldata->retval), hal_comp_id, "%s.retval", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_bit_newf(HAL_OUT, &(haldata->at_speed), hal_comp_id, "%s.at-speed", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_bit_newf(HAL_OUT, &(haldata->is_stopped), hal_comp_id, "%s.is-stopped", modname); // JET if (retval!=0) goto out_closeHAL; retval = hal_pin_float_newf(HAL_IN, &(haldata->speed_command), hal_comp_id, "%s.speed-command", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_bit_newf(HAL_IN, &(haldata->spindle_on), hal_comp_id, "%s.spindle-on", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_bit_newf(HAL_IN, &(haldata->spindle_fwd), hal_comp_id, "%s.spindle-fwd", modname); if (retval!=0) goto out_closeHAL; retval = hal_pin_bit_newf(HAL_IN, &(haldata->spindle_rev), hal_comp_id, "%s.spindle-rev", modname); //JET if (retval!=0) goto out_closeHAL; retval = hal_pin_bit_newf(HAL_IN, &(haldata->err_reset), hal_comp_id, "%s.err-reset", modname); if (retval!=0) goto out_closeHAL; retval = hal_param_float_newf(HAL_RW, &(haldata->speed_tolerance), hal_comp_id, "%s.tolerance", modname); if (retval!=0) goto out_closeHAL; retval = hal_param_float_newf(HAL_RW, &(haldata->motor_hz), hal_comp_id, "%s.nameplate-HZ", modname); if (retval!=0) goto out_closeHAL; retval = hal_param_float_newf(HAL_RW, &(haldata->motor_RPM), hal_comp_id, "%s.nameplate-RPM", modname); if (retval!=0) goto out_closeHAL; retval = hal_param_s32_newf(HAL_RW, &(haldata->ack_delay), hal_comp_id, "%s.ack-delay", modname); if (retval!=0) goto out_closeHAL; /* make default data match what we expect to use */ *(haldata->stat1) = 0; *(haldata->stat2) = 0; *(haldata->freq_cmd) = 0; *(haldata->freq_out) = 0; *(haldata->curr_out) = 0; *(haldata->DCBusV) = 0; *(haldata->outV) = 0; *(haldata->RPM) = 0; *(haldata->scale_freq) = 0; *(haldata->power_factor) = 0; *(haldata->load_pct) = 0; *(haldata->FW_Rev) = 0; haldata->errorcount = 0; haldata->looptime = 0.1; haldata->motor_RPM = 1730; haldata->motor_hz = 60; haldata->speed_tolerance = 0.01; haldata->ack_delay = 2; *(haldata->err_reset) = 0; *(haldata->spindle_on) = 0; *(haldata->spindle_fwd) = 1; *(haldata->spindle_rev) = 0; haldata->old_run = -1; // make sure the initial value gets output haldata->old_dir = -1; haldata->old_err_reset = -1; hal_ready(hal_comp_id); /* here's the meat of the program. loop until done (which may be never) */ while (done==0) { read_data(mb_ctx, &slavedata, haldata); write_data(mb_ctx, &slavedata, haldata); /* don't want to scan too fast, and shouldn't delay more than a few seconds */ if (haldata->looptime < 0.001) haldata->looptime = 0.001; if (haldata->looptime > 2.0) haldata->looptime = 2.0; loop_timespec.tv_sec = (time_t)(haldata->looptime); loop_timespec.tv_nsec = (long)((haldata->looptime - loop_timespec.tv_sec) * 1000000000l); nanosleep(&loop_timespec, &remaining); } retval = 0; /* if we get here, then everything is fine, so just clean up and exit */ out_closeHAL: hal_exit(hal_comp_id); out_close: modbus_close(mb_ctx); modbus_free(mb_ctx); out_noclose: return retval; }
int main(int argc, char *argv[]) { extern int errno; modbus_t *ctx; int registers; uint8_t rtu; int addr; int nb; int rc; int ch; int verbose=0; int debug=0; int port=502; char name[255]; addr=0; nb=1; strcpy(name,"127.0.0.1"); // ctx = modbus_new_tcp("192.168.0.143", 1502); // ctx = modbus_new_tcp("127.0.0.1", 1502); // ctx = modbus_new_tcp("10.0.0.101", 502); // ctx = modbus_new_tcp("192.168.100.72", 1502); while((ch = getopt(argc,argv,"dvh?p:i:r:n:c:")) != -1) { switch(ch) { case 'c': sscanf(optarg,"%x",®isters); break; case 'd': debug=1; break; case 'v': verbose=1; break; case 'h': case '?': printf("Usage\n"); exit(1); break; case 'p': port=atoi(optarg); break; case 'i': strcpy(name,optarg); break; case 'r': addr=atoi(optarg); break; case 'n': nb=atoi(optarg); break; } } if (verbose) { printf("Name :%s\n",name); printf("Port :%d\n",port); printf("Register:%d\n",addr); printf("Count :%d\n", nb); printf("Data :%04x\n", registers); printf("==================\n"); } ctx = modbus_new_tcp(name, port); if (ctx == NULL) { fprintf(stderr, "modbus_new_tcp failed.\n"); exit(-1); } if(debug) { modbus_set_debug(ctx, TRUE); } else { modbus_set_debug(ctx, FALSE); } modbus_set_error_recovery(ctx, MODBUS_ERROR_RECOVERY_LINK | MODBUS_ERROR_RECOVERY_PROTOCOL); if (modbus_connect(ctx) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } rc = modbus_write_registers(ctx, addr, nb,(uint16_t *) ®isters); if (rc != nb) { printf("Failed:%d\n",rc); printf("==>%s\n", modbus_strerror(errno)); } // printf("\nData = 0x%04x\n", registers & 0xffff); sleep(1); modbus_close(ctx); modbus_free(ctx); return 0; }
int main(int argc, char*argv[]) { int s = -1; modbus_t *ctx; modbus_mapping_t *mb_mapping; int rc; int i; int use_backend; uint8_t *query; int header_length; if (argc > 1) { if (strcmp(argv[1], "tcp") == 0) { use_backend = TCP; } else if (strcmp(argv[1], "tcppi") == 0) { use_backend = TCP_PI; } else if (strcmp(argv[1], "rtu") == 0) { use_backend = RTU; } else { printf("Usage:\n %s [tcp|tcppi|rtu] - Modbus server for unit testing\n\n", argv[0]); return -1; } } else { /* By default */ use_backend = TCP; } if (use_backend == TCP) { ctx = modbus_new_tcp("127.0.0.1", 1502); query = malloc(MODBUS_TCP_MAX_ADU_LENGTH); } else if (use_backend == TCP_PI) { ctx = modbus_new_tcp_pi("::0", "1502"); query = malloc(MODBUS_TCP_MAX_ADU_LENGTH); } else { ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1); modbus_set_slave(ctx, SERVER_ID); query = malloc(MODBUS_RTU_MAX_ADU_LENGTH); } header_length = modbus_get_header_length(ctx); modbus_set_debug(ctx, TRUE); mb_mapping = modbus_mapping_new( UT_BITS_ADDRESS + UT_BITS_NB, UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB, UT_REGISTERS_ADDRESS + UT_REGISTERS_NB, UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB); if (mb_mapping == NULL) { fprintf(stderr, "Failed to allocate the mapping: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } /* Unit tests of modbus_mapping_new (tests would not be sufficient if two nb_* were identical) */ if (mb_mapping->nb_bits != UT_BITS_ADDRESS + UT_BITS_NB) { printf("Invalid nb bits (%d != %d)\n", UT_BITS_ADDRESS + UT_BITS_NB, mb_mapping->nb_bits); modbus_free(ctx); return -1; } if (mb_mapping->nb_input_bits != UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB) { printf("Invalid nb input bits: %d\n", UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB); modbus_free(ctx); return -1; } if (mb_mapping->nb_registers != UT_REGISTERS_ADDRESS + UT_REGISTERS_NB) { printf("Invalid nb registers: %d\n", UT_REGISTERS_ADDRESS + UT_REGISTERS_NB); modbus_free(ctx); return -1; } if (mb_mapping->nb_input_registers != UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB) { printf("Invalid nb input registers: %d\n", UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB); modbus_free(ctx); return -1; } /* Examples from PI_MODBUS_300.pdf. Only the read-only input values are assigned. */ /** INPUT STATUS **/ modbus_set_bits_from_bytes(mb_mapping->tab_input_bits, UT_INPUT_BITS_ADDRESS, UT_INPUT_BITS_NB, UT_INPUT_BITS_TAB); /** INPUT REGISTERS **/ for (i=0; i < UT_INPUT_REGISTERS_NB; i++) { mb_mapping->tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] = UT_INPUT_REGISTERS_TAB[i];; } if (use_backend == TCP) { s = modbus_tcp_listen(ctx, 1); modbus_tcp_accept(ctx, &s); } else if (use_backend == TCP_PI) { s = modbus_tcp_pi_listen(ctx, 1); modbus_tcp_pi_accept(ctx, &s); } else { rc = modbus_connect(ctx); if (rc == -1) { fprintf(stderr, "Unable to connect %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } } for (;;) { do { rc = modbus_receive(ctx, query); /* Filtered queries return 0 */ } while (rc == 0); /* The connection is not closed on errors which require on reply such as bad CRC in RTU. */ if (rc == -1 && errno != EMBBADCRC) { /* Quit */ break; } /* Special server behavior to test client */ if (query[header_length] == 0x03) { /* Read holding registers */ if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 3) == UT_REGISTERS_NB_SPECIAL) { printf("Set an incorrect number of values\n"); MODBUS_SET_INT16_TO_INT8(query, header_length + 3, UT_REGISTERS_NB_SPECIAL - 1); } else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1) == UT_REGISTERS_ADDRESS_SPECIAL) { printf("Reply to this special register address by an exception\n"); modbus_reply_exception(ctx, query, MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY); continue; } else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1) == UT_REGISTERS_ADDRESS_INVALID_TID_OR_SLAVE) { const int RAW_REQ_LENGTH = 5; uint8_t raw_req[] = { (use_backend == RTU) ? INVALID_SERVER_ID : 0xFF, 0x03, 0x02, 0x00, 0x00 }; printf("Reply with an invalid TID or slave\n"); modbus_send_raw_request(ctx, raw_req, RAW_REQ_LENGTH * sizeof(uint8_t)); continue; } else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1) == UT_REGISTERS_ADDRESS_SLEEP_500_MS) { printf("Sleep 0.5 s before replying\n"); usleep(500000); } else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1) == UT_REGISTERS_ADDRESS_BYTE_SLEEP_5_MS) { /* Test low level only available in TCP mode */ /* Catch the reply and send reply byte a byte */ uint8_t req[] = "\x00\x1C\x00\x00\x00\x05\xFF\x03\x02\x00\x00"; int req_length = 11; int w_s = modbus_get_socket(ctx); /* Copy TID */ req[1] = query[1]; for (i=0; i < req_length; i++) { printf("(%.2X)", req[i]); usleep(5000); send(w_s, (const char*)(req + i), 1, MSG_NOSIGNAL); } continue; } } rc = modbus_reply(ctx, query, rc, mb_mapping); if (rc == -1) { break; } } printf("Quit the loop: %s\n", modbus_strerror(errno)); if (use_backend == TCP) { if (s != -1) { close(s); } } modbus_mapping_free(mb_mapping); free(query); /* For RTU */ modbus_close(ctx); modbus_free(ctx); return 0; }
int main(int argc, char *argv[]) { int s = -1; modbus_t *ctx = NULL; modbus_mapping_t *mb_mapping = NULL; int rc; int use_backend; /* TCP */ if (argc > 1) { if (strcmp(argv[1], "tcp") == 0) { use_backend = TCP; } else if (strcmp(argv[1], "rtu") == 0) { use_backend = RTU; } else { printf("Usage:\n %s [tcp|rtu] - Modbus client to measure data bandwith\n\n", argv[0]); exit(1); } } else { /* By default */ use_backend = TCP; } if (use_backend == TCP) { ctx = modbus_new_tcp("127.0.0.1", 1502); s = modbus_tcp_listen(ctx, 1); modbus_tcp_accept(ctx, &s); } else { ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1); modbus_set_slave(ctx, 1); modbus_connect(ctx); } mb_mapping = modbus_mapping_new(MODBUS_MAX_READ_BITS, 0, MODBUS_MAX_READ_REGISTERS, 0); if (mb_mapping == NULL) { fprintf(stderr, "Failed to allocate the mapping: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } for(;;) { uint8_t query[MODBUS_TCP_MAX_ADU_LENGTH]; rc = modbus_receive(ctx, query); if (rc > 0) { 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)); modbus_mapping_free(mb_mapping); if (s != -1) { close(s); } /* For RTU, skipped by TCP (no TCP connect) */ modbus_close(ctx); modbus_free(ctx); return 0; }
void MODBUSPuerto::cerrar(){ modbus_close(ctx); modbus_free(ctx); this->isOpen = false; }
void ModbusMaster::closePort(modbus_t *connection) { modbus_close(connection); modbus_free(connection); }
ModbusClientV1::~ModbusClientV1() { modbus_close(ctx); modbus_free(ctx); }
int main(int argc, char *argv[]) { uint8_t *tab_bits; uint8_t *tab_input_bits; uint16_t *tab_value_registers; uint16_t *tab_input_value_registers; modbus_t *ctx; int rc; float heaterTemp; float heaterSetPoint; char * heaterEnableState; char * heaterElementState; bool displayCnt = true; char * displayFlag; char * modbusClientIP = DEFAULT_CLIENT_IP; int modbusPort = DEFAULT_PORT; int modbusPollIntervalmSec = DEFAULT_POLL_INTERVAL_MSEC; int argcnt = 1; while(argc > argcnt) { if(strcmp(argv[argcnt], IP_ADDRESS_FLAG) == 0) { argcnt++; if(argcnt < argc) { modbusClientIP = argv[argcnt++]; } else { printf("Illegal command flags\n"); exit(1); } } else if(strcmp(argv[argcnt], IP_PORT_FLAG) == 0) { argcnt++; if(argcnt < argc) { sscanf(argv[argcnt++], "%i", &modbusPort); } else { printf("Illegal command flags\n"); exit(1); } } else if(strcmp(argv[argcnt], POLL_INTERVAL_FLAG) == 0) { argcnt++; if(argcnt < argc) { sscanf(argv[argcnt++], "%i", &modbusPollIntervalmSec); /* interpret command line argument as seconds. Convert to ms. */ modbusPollIntervalmSec *= 1000; } else { printf("Illegal command flags\n"); exit(1); } } else { printf("Illegal command flags\n"); exit(1); } } /* create modbus context structure */ ctx = modbus_new_tcp(modbusClientIP, modbusPort); if (ctx == NULL) { fprintf(stderr, "Unable to allocate libmodbus context\n"); return -1; } /* allocate room to hold water heater register data */ tab_bits = (uint8_t *)malloc(NUM_BIT_REG * sizeof(uint8_t)); memset(tab_bits, 0, NUM_BIT_REG * sizeof(uint8_t)); tab_input_bits = (uint8_t *)malloc(NUM_INPUT_BIT_REG * sizeof(uint8_t)); memset(tab_input_bits, 0, NUM_INPUT_BIT_REG * sizeof(uint8_t)); tab_value_registers = (uint16_t *)malloc(NUM_VALUE_REG * sizeof(uint16_t)); memset(tab_value_registers, 0, NUM_VALUE_REG * sizeof(uint16_t)); tab_input_value_registers = (uint16_t *)malloc(NUM_INPUT_VALUE_REG * sizeof(uint16_t)); memset(tab_input_value_registers, 0, NUM_INPUT_VALUE_REG * sizeof(uint16_t)); /* loop forever */ while(1) { if (modbus_connect(ctx) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); modbus_free(ctx); break; } rc = modbus_read_bits(ctx, HEATER_COIL_ENABLE, NUM_BIT_REG, tab_bits); if (rc != 1) { break; } rc = modbus_read_input_bits(ctx, HEATER_COIL_ENERGIZED, NUM_INPUT_BIT_REG, tab_input_bits); if (rc != 1) { break; } rc = modbus_read_input_registers(ctx, HEATER_WATER_TEMP_REG, NUM_INPUT_VALUE_REG, tab_input_value_registers); if (rc != 1) { break; } rc = modbus_read_registers(ctx, HEATER_WATER_TARGET_TEMP_REG, NUM_VALUE_REG, tab_value_registers); if (rc != 1) { break; } /* close the connection */ modbus_close(ctx); if(tab_bits[0]) { heaterEnableState = "Heater Enabled, "; } else { heaterEnableState = "Heater Disabled, "; } if(tab_input_bits[0]) { heaterElementState = "Heater Element On, "; } else { heaterElementState = "Heater Element Off, "; } heaterSetPoint = ((float)tab_value_registers[0]) / 10.0; heaterTemp = ((float)tab_input_value_registers[0]) / 10.0; if (displayCnt) { displayCnt = false; displayFlag = "+"; } else { displayCnt = true; displayFlag = "-"; } printf("Status(%s): %s%sSet Point: %5.1f, Temp: %5.1f\n", displayFlag, heaterEnableState, heaterElementState, heaterSetPoint, heaterTemp); memset(tab_input_value_registers, 0, NUM_INPUT_VALUE_REG * sizeof(uint16_t)); usleep(modbusPollIntervalmSec * 1000); } printf("Failed modbus read %d\n", rc); printf("Exiting due to read failure.\n"); /* Free the memory */ free(tab_bits); free(tab_input_bits); free(tab_value_registers); free(tab_input_value_registers); /* Close the connection */ modbus_close(ctx); modbus_free(ctx); return 0; }
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); }
int main(void) { uint8_t *tab_rp_status; uint16_t *tab_rp_registers; modbus_param_t mb_param; int i; int ret; int nb_points; double elapsed; uint32_t start; uint32_t end; uint32_t bytes; uint32_t rate; /* TCP */ modbus_init_tcp(&mb_param, "127.0.0.1", 1502); if (modbus_connect(&mb_param) == -1) { printf("ERROR Connection failed\n"); exit(1); } /* Allocate and initialize the memory to store the status */ tab_rp_status = (uint8_t *) malloc(MAX_STATUS * sizeof(uint8_t)); memset(tab_rp_status, 0, MAX_STATUS * sizeof(uint8_t)); /* Allocate and initialize the memory to store the registers */ tab_rp_registers = (uint16_t *) malloc(MAX_REGISTERS * sizeof(uint16_t)); memset(tab_rp_registers, 0, MAX_REGISTERS * sizeof(uint16_t)); printf("READ COIL STATUS\n\n"); nb_points = MAX_STATUS; start = gettime(); for (i=0; i<NB_LOOPS; i++) { ret = read_coil_status(&mb_param, SLAVE, 0, nb_points, tab_rp_status); } end = gettime(); elapsed = (end - start) / 1000; rate = (NB_LOOPS * nb_points) * G_USEC_PER_SEC / (end - start); printf("Transfert rate in points/seconds:\n"); printf("* %'d points/s\n", rate); printf("\n"); bytes = NB_LOOPS * (nb_points / 8) + ((nb_points % 8) ? 1 : 0); rate = bytes / 1024 * G_USEC_PER_SEC / (end - start); printf("Values:\n"); printf("* %d x %d values\n", NB_LOOPS, nb_points); printf("* %.3f ms for %d bytes\n", elapsed, bytes); printf("* %'d KiB/s\n", rate); printf("\n"); /* TCP: Query and reponse header and values */ bytes = 12 + 9 + (nb_points / 8) + ((nb_points % 8) ? 1 : 0); printf("Values and TCP Modbus overhead:\n"); printf("* %d x %d bytes\n", NB_LOOPS, bytes); bytes = NB_LOOPS * bytes; rate = bytes / 1024 * G_USEC_PER_SEC / (end - start); printf("* %.3f ms for %d bytes\n", elapsed, bytes); printf("* %'d KiB/s\n", rate); printf("\n\n"); printf("READ HOLDING REGISTERS\n\n"); nb_points = MAX_REGISTERS; start = gettime(); for (i=0; i<NB_LOOPS; i++) { ret = read_holding_registers(&mb_param, SLAVE, 0, nb_points, tab_rp_registers); } end = gettime(); elapsed = (end - start) / 1000; rate = (NB_LOOPS * nb_points) * G_USEC_PER_SEC / (end - start); printf("Transfert rate in points/seconds:\n"); printf("* %'d registers/s\n", rate); printf("\n"); bytes = NB_LOOPS * nb_points * sizeof(uint16_t); rate = bytes / 1024 * G_USEC_PER_SEC / (end - start); printf("Values:\n"); printf("* %d x %d values\n", NB_LOOPS, nb_points); printf("* %.3f ms for %d bytes\n", elapsed, bytes); printf("* %'d KiB/s\n", rate); printf("\n"); /* TCP:Query and reponse header and values */ bytes = 12 + 9 + (nb_points * sizeof(uint16_t)); printf("Values and TCP Modbus overhead:\n"); printf("* %d x %d bytes\n", NB_LOOPS, bytes); bytes = NB_LOOPS * bytes; rate = bytes / 1024 * G_USEC_PER_SEC / (end - start); printf("* %.3f ms for %d bytes\n", elapsed, bytes); printf("* %'d KiB/s\n", rate); printf("\n"); /* Free the memory */ free(tab_rp_status); free(tab_rp_registers); /* Close the connection */ modbus_close(&mb_param); return 0; }
int main(int argc, char** argv) { modbus_param_t mb_param; int half_duplex = 0; int c; char ** svp; int i; int set_args_index = -1; char set_args[MAX_SETS][MAX_STR]; char *device = NULL; memset(set_args, 0, sizeof(set_args)); while( (c = getopt(argc, argv, "hnvd:s:")) != -1) { switch(c){ case 's': /* NOTE IMPORTANT! This block MUST COME FIRST in the switch, before any opts, otherwise GCC or getopts or something gets the indexes all wrong */ // Thanks to http://stackoverflow.com/questions/3939157/c-getopt-multiple-value // Special case the first arg set_args_index = 0; strcpy(set_args[0], optarg); // Loop the rest i=1; while(optind < argc && *argv[optind] != '-'){ strcpy(set_args[i], argv[optind]); if(debug > 0){ printf("getopts multiopt: %s %s\n", argv[optind], set_args[i] ); } // Ugly but explicit set_args_index++; i++; optind++; } break; case 'h': half_duplex = 1; break; case 'v': debug = 1; break; case 'n': dry = 1; break; case 'd': device = optarg; default: break; } } if(!device){ printf("need to give serial port on command line\n"); usage(); return(1); } /* Setup the serial port parameters */ modbus_init_rtu(&mb_param, device, 9600, "none", 8, 2, half_duplex); if(debug > 0){ modbus_set_debug(&mb_param, TRUE); } /* Open the MODBUS connection */ if (modbus_connect(&mb_param) == -1) { printf("ERROR Connection failed\n"); return(1); } if(debug > 0){ printf("We have %d set args to process...\n", set_args_index + 1); } i = set_args_index; while(i >= 0){ printf("\nSetting values... %s\n", set_args[i]); set_options(&mb_param, set_args[i]); i--; } if(dry < 1 && set_args_index >= 0){ commit_options(&mb_param); } if(dry < 1){ read_values(&mb_param); } /* Close the MODBUS connection */ modbus_close(&mb_param); return(0); }
int main(int argc, char *argv[]) { modbus_t *ctx; struct timeval timeout; int ret, i, rc, ii,iii; int nb_pointers; // unit16_t *tab_rp_registers; uint16_t regs[MODBUS_MAX_READ_REGISTERS] = {0}; uint16_t regs2[MODBUS_MAX_READ_REGISTERS] = {0}; char regs3[MODBUS_MAX_READ_REGISTERS] = {0}; FILE *fp = NULL; if(argc < 3){ printf("INsufficient argument"); return -1; } ctx = modbus_new_rtu(MODBUS_SERIAL_DEV, MODBUS_SERIAL_BAUDRATE, MODBUS_SERIAL_PARITY, MODBUS_SERIAL_DATABITS, MODBUS_SERIAL_STOPBITS); if (ctx == NULL) { fprintf(stderr, "Unable to create the libmodbus context\n"); exit(-1); } i = modbus_rtu_get_serial_mode(ctx); if( i == MODBUS_RTU_RS232) { printf("Serial mode = RS232\n"); ret = modbus_rtu_set_serial_mode(ctx, MODBUS_RTU_RS232); if(ret < 0) fprintf(stderr, "modbus_rtu_set_serial_mode() error: %s\n", strerror(errno)); } else if(i == MODBUS_RTU_RS485) { printf("Serial mode = RS485\n"); ret = modbus_rtu_set_serial_mode(ctx, MODBUS_RTU_RS485); if(ret < 0) fprintf(stderr, "modbus_rtu_set_serial_mode() error: %s\n", strerror(errno)); } else { printf("Serial mode = RS485\n"); ret = modbus_rtu_set_serial_mode(ctx, MODBUS_RTU_RS485); if(ret < 0) fprintf(stderr, "modbus_rtu_set_serial_mode() error: %s\n", strerror(errno)); } /* set slave device ID */ modbus_set_slave(ctx, MODBUS_DEVICE_ID); /* Debug mode */ modbus_set_debug(ctx, MODBUS_DEBUG); if (modbus_connect(ctx) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } /* 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)); */ /* write data in test.txt */ fp = fopen("test2.txt", "w"); if(fp == NULL) { printf("fail to open file!\n"); return -1; } for( iii=1; iii <= strtol(argv[2],NULL, 10);iii++) { regs[iii] = strtol(argv[iii+2], NULL, 10); } rc = modbus_write_registers(ctx, strtol(argv[1], NULL, 16), strtol(argv[2], NULL, 10), ®s[1]); if (rc < 0) { fprintf(stderr, "%s\n", modbus_strerror(errno)); } /* read holding registers (0x03 function code) */ rc = modbus_read_registers(ctx, strtol(argv[1], NULL, 16), strtol(argv[2], NULL, 10), regs2); if (rc < 0) { fprintf(stderr, "%s\n", modbus_strerror(errno)); } else { printf("HOLDING REGISTERS:\n"); for (ii=0; ii < rc; ii++) { sprintf(regs3, "%d", regs2[ii]); fputs(regs3, fp); fputs("\n", fp); printf("[%d]=%d\n", ii, regs2[ii]); } } fclose(fp); /* Close the connection */ modbus_close(ctx); modbus_free(ctx); return 0; }