int main(int argc, char *argv[]) { modbus_t *m; uint8_t *q; int header_length; int socket; int rc; m = modbus_new_tcp("127.0.0.1", 1502); q = malloc(MODBUS_TCP_MAX_ADU_LENGTH); header_length = modbus_get_header_length(m); modbus_set_debug(m, TRUE); modbus_set_error_recovery(m, TRUE); socket = modbus_tcp_listen(m, 1); modbus_tcp_accept(m, &socket); while (1) { rc = modbus_receive(m, -1, q); if (rc < 0) { error("modbus_receive() returned %d", rc); } dump_buffer(stdout, q, rc); } }
ModbusClientV1::ModbusClientV1(char* device) { ctx = modbus_new_rtu(device, 115200, 'E', 8, 1); // Port_name, Speed, Parity, Data_bits, Stop_bits if (ctx == NULL) { fprintf(stderr, "Unable to create the libmodbus context\n"); return; } if (verbose > 4) { modbus_set_debug(ctx, 1); } int rc = modbus_set_slave(ctx, 1); // Connecting to existing modbus socket rc = modbus_connect(ctx); if (rc == -1) { fprintf(stderr, "Connection failed [%s]\n", modbus_strerror(errno)); modbus_free(ctx); return; } // Change bytes and response timeouts for connections change_byte_timeout(0, 10000); /* 10 ms */ change_response_timeout(0, 100000); /* 100 ms */ isInitialized = true; }
//open serial port bool EnergyCamOpen(unsigned int dwPort ){ m_dwPort=dwPort; char comDeviceName[100]; sprintf(comDeviceName, "/dev/ttyUSB%d", dwPort); m_ctx = (modbus_t* )modbus_new_rtu(comDeviceName, m_dwBaud, 'E', 8, 1); // parity 'E'ven used by EnergyCam's freemodbus implementation if(NULL == m_ctx) return false; modbus_set_debug( m_ctx, false); modbus_set_slave( m_ctx, 1); if (modbus_connect(m_ctx) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); modbus_free(m_ctx); m_ctx = NULL; return false; } else{ printf,( "Connection OK: \n"); } return true; }
/* Version 2.9.2 */ static int mb_init_connection (mb_host_t *host) /* {{{ */ { int status; if (host == NULL) return (EINVAL); if (host->connection != NULL) return (0); if (host->conntype == MBCONN_TCP) { if ((host->port < 1) || (host->port > 65535)) host->port = MODBUS_TCP_DEFAULT_PORT; DEBUG ("Modbus plugin: Trying to connect to \"%s\", port %i.", host->node, host->port); host->connection = modbus_new_tcp (host->node, host->port); if (host->connection == NULL) { ERROR ("Modbus plugin: Creating new Modbus/TCP object failed."); return (-1); } } else { DEBUG ("Modbus plugin: Trying to connect to \"%s\", baudrate %i.", host->node, host->baudrate); host->connection = modbus_new_rtu (host->node, host->baudrate, 'N', 8, 1); if (host->connection == NULL) { ERROR ("Modbus plugin: Creating new Modbus/RTU object failed."); return (-1); } } #if COLLECT_DEBUG modbus_set_debug (host->connection, 1); #endif /* We'll do the error handling ourselves. */ modbus_set_error_recovery (host->connection, 0); status = modbus_connect (host->connection); if (status != 0) { ERROR ("Modbus plugin: modbus_connect (%s, %i) failed with status %i.", host->node, host->port ? host->port : host->baudrate, status); modbus_free (host->connection); host->connection = NULL; return (status); } return (0); } /* }}} int mb_init_connection */
int main(void) { int s = -1; modbus_t *ctx; modbus_mapping_t *mb_mapping; int rc = -1; pthread_t tId; pthread_attr_t attr; /* Initialize and set thread detached attribute */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); ctx = modbus_new_tcp("127.0.0.1", 1502); modbus_set_debug(ctx, TRUE); mb_mapping = modbus_mapping_new(500, 500, 500, 500); if (mb_mapping == NULL) { fprintf(stderr, "Failed to allocate the mapping: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } s = modbus_tcp_listen(ctx, 1); int id = 0; for (;;) { id++; printf("Waiting for another connection...\n\n"); modbus_tcp_accept(ctx, &s); modbus_t *new_ctx = modbus_clone_tcp(ctx); SA *sa = (SA*)malloc(sizeof(SA)); sa->ctxt = new_ctx; sa->mm = mb_mapping; sa->id = id; rc = pthread_create(&tId, &attr, serveClient, (void *)sa); if (rc) { printf("ERROR; return code from pthread_create() is %d\n", rc); break; } } printf("Quit the loop: %s\n", modbus_strerror(errno)); if (s != -1) { close(s); } modbus_mapping_free(mb_mapping); modbus_close(ctx); modbus_free(ctx); return 0; }
int main(int argc, char *arg[]) { modbus_t *ctx, *dup_ctx; int server_fd; pthread_t tcp_thread; file_read_random_data(RANDOM_DATA_POOL); if ((ctx = modbus_new_tcp("SERVER", MODBUS_TCP_DEFAULT_PORT)) == NULL) { printf("Failied to initialise modbus\n"); return -1; } mb_mapping = modbus_mapping_new(0, 0, file_get_highest_channel(), 0); listen: if ((server_fd = modbus_tcp_listen(ctx, LISTEN_BACKLOG)) < 0) { printf("Failed to initiate modbus_tcp server, %i\n", server_fd); printf("Root permissions are needed to open ports below 1024\n"); printf("Currently configured to open port %i\n", MODBUS_TCP_DEFAULT_PORT); modbus_free(ctx); return -1; } while (1) { modbus_set_debug(ctx, TRUE); if (modbus_tcp_accept(ctx, &server_fd) < 0) { /* libmodbus closes the supplied socket if accept fails - this may * be making new connections impossible */ printf("Accept failed \n"); goto listen; } modbus_set_debug(ctx, FALSE); dup_ctx = malloc(sizeof(struct ctx_data)); memcpy(dup_ctx, ctx, sizeof(struct ctx_data)); pthread_create(&tcp_thread, 0, connection, dup_ctx); } modbus_mapping_free(mb_mapping); close(server_fd); modbus_free(ctx); return 0; }
static int ctx_set_debug(lua_State *L) { ctx_t *ctx = ctx_check(L, 1); bool opt; if (lua_isnil(L, -1)) { opt = true; } else { opt = lua_toboolean(L, -1); } modbus_set_debug(ctx->modbus, opt); return 0; }
static int openSerial(const char *device, int baudrate, char parity, int data_bits, int stop_bits) { int ret = 0; if (!mb) { mb = modbus_new_rtu(device, baudrate, parity, data_bits, stop_bits); struct timeval tv = { 0, 100000 }; modbus_set_response_timeout(mb, &tv); modbus_set_debug(mb, 1); ret = modbus_connect(mb); if (ret < 0) closeSerial(); } return ret; }
/* Version 2.0.3 */ static int mb_init_connection (mb_host_t *host) /* {{{ */ { int status; if (host == NULL) return (EINVAL); #if COLLECT_DEBUG modbus_set_debug (&host->connection, 1); #endif /* We'll do the error handling ourselves. */ modbus_set_error_handling (&host->connection, NOP_ON_ERROR); if (host->conntype == MBCONN_TCP) { if ((host->port < 1) || (host->port > 65535)) host->port = MODBUS_TCP_DEFAULT_PORT; DEBUG ("Modbus plugin: Trying to connect to \"%s\", port %i.", host->node, host->port); modbus_init_tcp (&host->connection, /* host = */ host->node, /* port = */ host->port); } else /* MBCONN_RTU */ { DEBUG ("Modbus plugin: Trying to connect to \"%s\".", host->node); modbus_init_rtu (&host->connection, /* device = */ host->node, /* baudrate = */ host->baudrate, 'N', 8, 1, 0); } status = modbus_connect (&host->connection); if (status != 0) { ERROR ("Modbus plugin: modbus_connect (%s, %i) failed with status %i.", host->node, host->port ? host->port : host->baudrate, status); return (status); } host->is_connected = 1; return (0); } /* }}} int mb_init_connection */
/* Version 2.9.2 */ static int mb_init_connection (mb_host_t *host) /* {{{ */ { int status; if (host == NULL) return (EINVAL); if (host->connection != NULL) return (0); /* Only reconnect once per interval. */ if (host->have_reconnected) return (-1); if ((host->port < 1) || (host->port > 65535)) host->port = MODBUS_TCP_DEFAULT_PORT; DEBUG ("Modbus plugin: Trying to connect to \"%s\", port %i.", host->node, host->port); host->connection = modbus_new_tcp (host->node, host->port); if (host->connection == NULL) { host->have_reconnected = 1; ERROR ("Modbus plugin: Creating new Modbus/TCP object failed."); return (-1); } modbus_set_debug (host->connection, 1); /* We'll do the error handling ourselves. */ modbus_set_error_recovery (host->connection, 0); status = modbus_connect (host->connection); if (status != 0) { ERROR ("Modbus plugin: modbus_connect (%s, %i) failed with status %i.", host->node, host->port, status); modbus_free (host->connection); host->connection = NULL; return (status); } host->have_reconnected = 1; return (0); } /* }}} int mb_init_connection */
static int mb_init_connection (mb_host_t *host) /* {{{ */ { int status; if (host == NULL) return (EINVAL); if (host->is_connected) return (0); /* Only reconnect once per interval. */ if (host->have_reconnected) return (-1); modbus_set_debug (&host->connection, 1); #if 0 /* We'll do the error handling ourselves. */ modbus_set_error_handling (&host->connection, NOP_ON_ERROR); #endif if ((host->port < 1) || (host->port > 65535)) host->port = MODBUS_TCP_DEFAULT_PORT; DEBUG ("Modbus plugin: Trying to connect to \"%s\", port %i.", host->node, host->port); modbus_init_tcp (&host->connection, /* host = */ host->node); #if 0 /* port = */ host->port); #endif status = modbus_connect (&host->connection); if (status != 0) { ERROR ("Modbus plugin: modbus_connect (%s, %i) failed with status %i.", host->node, host->port, status); return (status); } host->is_connected = 1; host->have_reconnected = 1; return (0); } /* }}} int mb_init_connection */
modbus_t * m_connect(char *host, char *port) { modbus_t *ctx; if ((ctx = modbus_new_tcp_pi(host, port)) == NULL) err(1, "ERROR: %s: modbus_new_tcp_pi()", __FUNCTION__); if (f_debug > 2) modbus_set_debug(ctx, TRUE); if (modbus_connect(ctx) < 0) { modbus_free(ctx); errx(1, "ERROR: %s: modbus_connect()", __FUNCTION__); } return ctx; }
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; }
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) { 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; }
retCode get_tx_connection(const int this_mb_tx_num, int *ret_connected) { char *fnct_name = "get_tx_connection"; int ret; mb_tx_t *this_mb_tx; mb_link_t *this_mb_link; int this_mb_link_num; struct timeval timeout; if (this_mb_tx_num < 0 || this_mb_tx_num > gbl.tot_mb_tx) { ERR(gbl.init_dbg, "parameter out of range this_mb_tx_num[%d]", this_mb_tx_num); return retERR; } this_mb_tx = &gbl.mb_tx[this_mb_tx_num]; if (ret_connected == NULL) { ERR(this_mb_tx->cfg_debug, "NULL pointer"); return retERR; } this_mb_link_num = this_mb_tx->mb_link_num; if (this_mb_link_num < 0 || this_mb_link_num >= gbl.tot_mb_links) { ERR(this_mb_tx->cfg_debug, "parameter out of range this_mb_link_num[%d]", this_mb_link_num); return retERR; } this_mb_link = &gbl.mb_links[this_mb_link_num]; *ret_connected = 0; //defaults to not connected if (modbus_get_socket(this_mb_link->modbus) < 0) { ret = modbus_connect(this_mb_link->modbus); if (ret != 0 || modbus_get_socket(this_mb_link->modbus) < 0) { modbus_set_socket(this_mb_link->modbus, -1); //some times ret was < 0 and fd > 0 ERR(this_mb_tx->cfg_debug, "mb_tx_num[%d] mb_links[%d] cannot connect to link, ret[%d] fd[%d]", this_mb_tx_num, this_mb_tx->mb_link_num, ret, modbus_get_socket(this_mb_link->modbus)); return retOK; //not connected } DBG(this_mb_tx->cfg_debug, "mb_tx_num[%d] mb_links[%d] new connection -> fd[%d]", this_mb_tx_num, this_mb_tx->mb_link_num, modbus_get_socket(this_mb_link->modbus)); } else { DBG(this_mb_tx->cfg_debug, "mb_tx_num[%d] mb_links[%d] already connected to fd[%d]", this_mb_tx_num, this_mb_tx->mb_link_num, modbus_get_socket(this_mb_link->modbus)); } //set slave id according to each mb_tx ret = modbus_set_slave(this_mb_link->modbus, this_mb_tx->mb_tx_slave_id); if (ret != 0) { ERR(this_mb_tx->cfg_debug, "mb_tx_num[%d] mb_links[%d] cannot set slave [%d]", this_mb_tx_num, this_mb_tx->mb_link_num, this_mb_tx->mb_tx_slave_id); return retOK; //not connected } //set the low level mb_link debug according to each mb_tx modbus_set_debug(this_mb_link->modbus, this_mb_tx->protocol_debug); //set response and byte timeout according to each mb_tx timeout.tv_sec = this_mb_tx->mb_response_timeout_ms / 1000; timeout.tv_usec = (this_mb_tx->mb_response_timeout_ms % 1000) * 1000; #if (LIBMODBUS_VERSION_CHECK(3, 1, 2)) modbus_set_response_timeout(this_mb_link->modbus, timeout.tv_sec, timeout.tv_usec); #else modbus_set_response_timeout(this_mb_link->modbus, &timeout); #endif //DBG(this_mb_tx->cfg_debug, "mb_tx_num[%d] mb_links[%d] response timeout [%d] ([%d] [%d])", // this_mb_tx_num, this_mb_tx->mb_link_num, this_mb_tx->mb_response_timeout_ms, // (int) timeout.tv_sec, (int) timeout.tv_usec); timeout.tv_sec = this_mb_tx->mb_byte_timeout_ms / 1000; timeout.tv_usec = (this_mb_tx->mb_byte_timeout_ms % 1000) * 1000; #if (LIBMODBUS_VERSION_CHECK(3, 1, 2)) modbus_set_byte_timeout(this_mb_link->modbus, timeout.tv_sec, timeout.tv_usec); #else modbus_set_byte_timeout(this_mb_link->modbus, &timeout); #endif //DBG(this_mb_tx->cfg_debug, "mb_tx_num[%d] mb_links[%d] byte timeout [%d] ([%d] [%d])", // this_mb_tx_num, this_mb_tx->mb_link_num, this_mb_tx->mb_byte_timeout_ms, // (int) timeout.tv_sec, (int) timeout.tv_usec); *ret_connected = 1; //is connected (fd >= 0) return retOK; }
int main(int argc, char *argv[]) { int socket; modbus_t *ctx; modbus_mapping_t *mb_mapping; int rc; int use_backend; int justacounter; justacounter = 0; while (TRUE) { /* 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; printf("bandwidth-server-one:\n Running in tcp mode - Modbus client to measure data bandwith\n\n"); } if (use_backend == TCP) { printf("Waiting for TCP connection\n"); ctx = modbus_new_tcp("127.0.0.1", 502); socket = modbus_tcp_listen(ctx, 1); modbus_tcp_accept(ctx, &socket); modbus_set_debug(ctx, TRUE); printf("TCP connection started!\n"); } else { printf("Waiting for Serial connection\n"); ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1); modbus_set_slave(ctx, 1); modbus_connect(ctx); printf("Serial connection started!\n"); } mb_mapping = modbus_mapping_new(MODBUS_MAX_READ_BITS, 22, MODBUS_MAX_READ_REGISTERS, 22); 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) { mb_mapping->tab_input_registers[0] = justacounter++; printf("Replying to request.\n"); modbus_reply(ctx, query, rc, mb_mapping); } else { /* Connection closed by the client or server */ break; } } printf("Quit the loop: %s\n", modbus_strerror(errno)); modbus_mapping_free(mb_mapping); close(socket); 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[]) { 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; }
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[]) { modbus_t *ctx; uint16_t *tab_reg; int rc; int use_backend; const uint16_t values[] = {5678, 9012}; 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 for unit testing\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); } else { ctx = modbus_new_rtu("/dev/ttyUSB1", 115200, 'N', 8, 1); } 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); if (use_backend == RTU) { 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; } /* Allocate and initialize the memory to store the registers */ tab_reg = (uint16_t *) malloc(10 * sizeof(uint16_t)); /* Single register */ printf("1/2 modbus_write_register"); rc = modbus_write_register(ctx, 0, 1234); if (rc != 1) { goto close; } printf("2/2 modbus_read_registers"); rc = modbus_read_registers(ctx, 0, 1, tab_reg); if (rc != 1) { goto close; } if (tab_reg[0] != 1234) { goto close; } /* Many registers */ printf("1/2 modbus_write_registers"); rc = modbus_write_registers(ctx, 1, 2, values); if (rc != 2) { goto close; } printf("2/2 modbus_read_registers"); rc = modbus_read_registers(ctx, 1, 2, tab_reg); if (rc != 2) { goto close; } close: /* Free the memory */ free(tab_reg); /* Close the connection */ modbus_close(ctx); modbus_free(ctx); return 0; }
int main(int argc, char *argv[]) { modbus_t *ctx; struct timeval timeout; int ret, i, rc, ii; int nb_pointers; //unit16_t *tab_rp_registers; uint16_t regs[MODBUS_MAX_READ_REGISTERS] = {0}; char regs2[MODBUS_MAX_READ_REGISTERS]={0}; FILE *fp = NULL; int err, rows, cols; if(argc != 5){ printf("INsufficient argument"); return -1; } err = opendb(); if(err) { /*Database is not open*/ return err; } 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, strtol(argv[2], NULL, 10)); /* 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("test.txt", "w"); if(fp == NULL) { printf("fail to open file!\n"); return -1; } rc = modbus_read_registers(ctx, strtol(argv[3], NULL, 16), strtol("1", NULL, 10), regs); if (rc < 0) { printf("1234\n"); fprintf(stderr, "%s\n", modbus_strerror(errno)); } else { printf("HOLDING REGISTERS:\n"); for (ii=0; ii < rc; ii++) { sprintf(regs2, "%d", regs[ii]); fputs(regs2, fp); fputs("\n", fp); printf("[%d]=%d\n", ii, regs[ii]); sql_write2(argv[1], argv[2], argv[3], regs2, argv[4]); } if( mysql_query(dp, query)) { fprintf(stderr, "%s\n", mysql_error(dp)); } qp = mysql_store_result(dp); mysql_free_result(qp); mysql_close(dp); } fclose(fp); /* Close the connection */ modbus_close(ctx); modbus_free(ctx); return 0; }
int main(int argc, char*argv[]) { int socket; 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], "rtu") == 0) { use_backend = RTU; } else { printf("Usage:\n %s [tcp|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 { 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); modbus_set_error_recovery(ctx, TRUE); mb_mapping = modbus_mapping_new( UT_BITS_ADDRESS + UT_BITS_NB_POINTS, UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB_POINTS, UT_REGISTERS_ADDRESS + UT_REGISTERS_NB_POINTS, UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB_POINTS); if (mb_mapping == NULL) { fprintf(stderr, "Failed to allocate the mapping: %s\n", modbus_strerror(errno)); 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_POINTS, UT_INPUT_BITS_TAB); /** INPUT REGISTERS **/ for (i=0; i < UT_INPUT_REGISTERS_NB_POINTS; i++) { mb_mapping->tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] = UT_INPUT_REGISTERS_TAB[i];; } if (use_backend == TCP) { socket = modbus_tcp_listen(ctx, 1); modbus_tcp_accept(ctx, &socket); } else { rc = modbus_connect(ctx); if (rc == -1) { fprintf(stderr, "Unable to connect %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } } for (;;) { rc = modbus_receive(ctx, -1, query); if (rc == -1) { /* Connection closed by the client or error */ break; } /* Read holding registers */ if (query[header_length] == 0x03) { if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 3) == UT_REGISTERS_NB_POINTS_SPECIAL) { printf("Set an incorrect number of values\n"); MODBUS_SET_INT16_TO_INT8(query, header_length + 3, UT_REGISTERS_NB_POINTS); } else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1) == UT_REGISTERS_ADDRESS_SPECIAL) { modbus_reply_exception(ctx, query, MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY); 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) { close(socket); } modbus_mapping_free(mb_mapping); free(query); modbus_free(ctx); return 0; }
/* 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; uint8_t *tab_rq_bits; uint8_t *tab_rp_bits; uint16_t *tab_rq_registers; uint16_t *tab_rw_rq_registers; uint16_t *tab_rp_registers; /* RTU */ /* ctx = modbus_new_rtu("/dev/ttyUSB0", 19200, 'N', 8, 1); modbus_set_slave(ctx, SERVER_ID); */ /* TCP */ ctx = modbus_new_tcp("127.0.0.1", 1502); modbus_set_debug(ctx, TRUE); if (modbus_connect(ctx) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } /* Allocate and initialize the different memory spaces */ nb = ADDRESS_END - ADDRESS_START; tab_rq_bits = (uint8_t *) malloc(nb * sizeof(uint8_t)); memset(tab_rq_bits, 0, nb * sizeof(uint8_t)); tab_rp_bits = (uint8_t *) malloc(nb * sizeof(uint8_t)); memset(tab_rp_bits, 0, nb * sizeof(uint8_t)); tab_rq_registers = (uint16_t *) malloc(nb * sizeof(uint16_t)); memset(tab_rq_registers, 0, nb * sizeof(uint16_t)); tab_rp_registers = (uint16_t *) malloc(nb * sizeof(uint16_t)); memset(tab_rp_registers, 0, nb * sizeof(uint16_t)); tab_rw_rq_registers = (uint16_t *) malloc(nb * sizeof(uint16_t)); memset(tab_rw_rq_registers, 0, nb * sizeof(uint16_t)); nb_loop = nb_fail = 0; while (nb_loop++ < LOOP) { for (addr = ADDRESS_START; addr <= ADDRESS_END; addr++) { int i; /* Random numbers (short) */ for (i=0; i<nb; i++) { tab_rq_registers[i] = (uint16_t) (65535.0*rand() / (RAND_MAX + 1.0)); tab_rw_rq_registers[i] = ~tab_rq_registers[i]; tab_rq_bits[i] = tab_rq_registers[i] % 2; } nb = ADDRESS_END - addr; /* WRITE BIT */ rc = modbus_write_bit(ctx, addr, tab_rq_bits[0]); if (rc != 1) { printf("ERROR modbus_write_bit (%d)\n", rc); printf("Address = %d, value = %d\n", addr, tab_rq_bits[0]); nb_fail++; } else { rc = modbus_read_bits(ctx, addr, 1, tab_rp_bits); if (rc != 1 || tab_rq_bits[0] != tab_rp_bits[0]) { printf("ERROR modbus_read_bits single (%d)\n", rc); printf("address = %d\n", addr); nb_fail++; } } /* MULTIPLE BITS */ rc = modbus_write_bits(ctx, addr, nb, tab_rq_bits); if (rc != nb) { printf("ERROR modbus_write_bits (%d)\n", rc); printf("Address = %d, nb = %d\n", addr, nb); nb_fail++; } else { rc = modbus_read_bits(ctx, addr, nb, tab_rp_bits); if (rc != nb) { printf("ERROR modbus_read_bits\n"); printf("Address = %d, nb = %d\n", addr, nb); nb_fail++; } else { for (i=0; i<nb; i++) { if (tab_rp_bits[i] != tab_rq_bits[i]) { printf("ERROR modbus_read_bits\n"); printf("Address = %d, value %d (0x%X) != %d (0x%X)\n", addr, tab_rq_bits[i], tab_rq_bits[i], tab_rp_bits[i], tab_rp_bits[i]); nb_fail++; } } } } /* SINGLE REGISTER */ rc = modbus_write_register(ctx, addr, tab_rq_registers[0]); if (rc != 1) { printf("ERROR modbus_write_register (%d)\n", rc); printf("Address = %d, value = %d (0x%X)\n", addr, tab_rq_registers[0], tab_rq_registers[0]); nb_fail++; } else { rc = modbus_read_registers(ctx, addr, 1, tab_rp_registers); if (rc != 1) { printf("ERROR modbus_read_registers single (%d)\n", rc); printf("Address = %d\n", addr); nb_fail++; } else { if (tab_rq_registers[0] != tab_rp_registers[0]) { printf("ERROR modbus_read_registers single\n"); printf("Address = %d, value = %d (0x%X) != %d (0x%X)\n", addr, tab_rq_registers[0], tab_rq_registers[0], tab_rp_registers[0], tab_rp_registers[0]); nb_fail++; } } } /* MULTIPLE REGISTERS */ rc = modbus_write_registers(ctx, addr, nb, tab_rq_registers); if (rc != nb) { printf("ERROR modbus_write_registers (%d)\n", rc); printf("Address = %d, nb = %d\n", addr, nb); nb_fail++; } else { rc = modbus_read_registers(ctx, addr, nb, tab_rp_registers); if (rc != nb) { printf("ERROR modbus_read_registers (%d)\n", rc); printf("Address = %d, nb = %d\n", addr, nb); nb_fail++; } else { for (i=0; i<nb; i++) { if (tab_rq_registers[i] != tab_rp_registers[i]) { printf("ERROR modbus_read_registers\n"); printf("Address = %d, value %d (0x%X) != %d (0x%X)\n", addr, tab_rq_registers[i], tab_rq_registers[i], tab_rp_registers[i], tab_rp_registers[i]); nb_fail++; } } } } /* R/W MULTIPLE REGISTERS */ rc = modbus_write_and_read_registers(ctx, addr, nb, tab_rw_rq_registers, addr, nb, tab_rp_registers); if (rc != nb) { printf("ERROR modbus_read_and_write_registers (%d)\n", rc); printf("Address = %d, nb = %d\n", addr, nb); nb_fail++; } else { for (i=0; i<nb; i++) { if (tab_rp_registers[i] != tab_rw_rq_registers[i]) { printf("ERROR modbus_read_and_write_registers READ\n"); printf("Address = %d, value %d (0x%X) != %d (0x%X)\n", addr, tab_rp_registers[i], tab_rw_rq_registers[i], tab_rp_registers[i], tab_rw_rq_registers[i]); nb_fail++; } } rc = modbus_read_registers(ctx, addr, nb, tab_rp_registers); if (rc != nb) { printf("ERROR modbus_read_registers (%d)\n", rc); printf("Address = %d, nb = %d\n", addr, nb); nb_fail++; } else { for (i=0; i<nb; i++) { if (tab_rw_rq_registers[i] != tab_rp_registers[i]) { printf("ERROR modbus_read_and_write_registers WRITE\n"); printf("Address = %d, value %d (0x%X) != %d (0x%X)\n", addr, tab_rw_rq_registers[i], tab_rw_rq_registers[i], tab_rp_registers[i], tab_rp_registers[i]); nb_fail++; } } } } } printf("Test: "); if (nb_fail) printf("%d FAILS\n", nb_fail); else printf("SUCCESS\n"); } /* Free the memory */ free(tab_rq_bits); free(tab_rp_bits); free(tab_rq_registers); free(tab_rp_registers); /* Close the connection */ modbus_close(ctx); modbus_free(ctx); return 0; }
int main(int argc, char *argv[]) { modbus_t *ctx_tcp; modbus_t *ctx_serial; uint8_t *query; uint8_t *raw_query; uint8_t *raw_reply; int header_length; int socket; int rc; modbus_mapping_t *mb_mapping; modbus_mapping_t *local_mb_mapping; const int RAW_REQ_LENGTH = 10; int RTU; int exitFlag = 0; // Set to non-zero to exit. // int opt=1; int cnt=1; // int tty_len=0; int baud_rate=9600; char parity='N'; int length=8; int stop_bits=2; char *tty=(char *)NULL; char *ip=(char *)NULL; int port=1502; int verbose=1; int io_address=0; int tmp_address=0; uint16_t *localInputRegisters; int localInputRegistersSize; uint16_t *localHoldingRegisters; int localHoldingRegistersSize; int holdingShmKey=0; int holdingShmId=0; int holdingSemKey=0; int holdingSemId=0; int inputShmKey=0; int inputShmId=0; int inputSemKey=0; int inputSemId=0; int i; unsigned char *tmp; int ch; // for getopt char *iniFile=(char *)NULL; char *ptr; int useSharedInput=0; int useSharedHolding=0; int modbusDebug = 0; int localRTU = 0; int serialRTUenabled = 0; char *iniFileName[] = { "/etc/newServer.ini", "/usr/local/etc/newServer.ini", "./newServer.ini" }; while ((ch = getopt(argc,argv,"b:c:h?i:p:P:t:v")) != -1) { switch (ch) { case 'c': if ( iniFile != (char *)NULL) { free(iniFile); } iniFile = strsave( optarg ); if(verbose) printf("Set ini file to %s\n",iniFile); break; case 'n': // baud rate baud_rate=atoi(optarg); break; case 'h': case '?': usage(); exit(0); break; case 'i': if ( ip != (char *)NULL) { free(ip); } ip=strsave( optarg ); break; case 'p': port=atoi( optarg ); break; case 'P': parity=optarg[0]; if ('E' != parity && 'O' != parity && 'N' != parity) { fprintf(stderr,"Invalid parity %c, exiting.\n",parity); exit(-1); } break; case 't': // serial port if ( tty != (char *)NULL) { free( tty ); } tty=strsave( optarg ); break; case 'v': verbose=1; break; default: break; } } if (iniFile == (char *)NULL) { for(i=0;(i<3 && (iniFile == (char *)NULL)) ;i++) { if ( verbose) { printf("%d:%s\n",i, iniFileName[i]); } if( 0 == access( iniFileName[i],R_OK)) { if(verbose ) { printf("\tFile exists\n"); } iniFile = strsave( iniFileName[i]); } } } if (iniFile == (char *)NULL ) { printf("No existing ini file.\n"); // Create an default file iniFile=strsave("./newServer.ini"); printf("\tCreating new ini file %s\n", iniFile); createIni( iniFile ); // exit(0); } ini = iniparser_load( iniFile ); ptr= iniparser_getstring(ini,"network:IP","127.0.0.1"); if((char *)NULL == ip) { ip=strsave(ptr); } if (0 == port) { port = iniparser_getint(ini,"network:port",1502); } if (-1 == verbose) { verbose = iniparser_getboolean(ini,"system:verbose",0); } localHoldingRegistersSize = iniparser_getint(ini,"system:holding_reg_size", LOCAL_HOLDING_REGISTERS); localInputRegistersSize = iniparser_getint(ini,"system:input_reg_size", LOCAL_INPUT_REGISTERS); useSharedInput = iniparser_getboolean(ini,"system:share_input",0); useSharedHolding = iniparser_getboolean(ini,"system:share_holding",0); modbusDebug = iniparser_getboolean(ini,"modbus:debug",0); localRTU = iniparser_getint(ini,"modbus:LOCAL_RTU",255); serialRTUenabled = iniparser_getboolean(ini,"modbus:RTU",0); if( serialRTUenabled ) { if( (char *) NULL == tty) { tty = iniparser_getstring(ini,"modbus:tty","/dev/ttyUSB0"); } } else { tty = (char *)NULL; } if(verbose) { printf("\n\t\tSettings\n"); printf( "\t\t========\n\n"); printf("\tBuild Date\t:%s\n",__DATE__); printf("\tAddress\t\t:%s\n",ip); printf("\tNetwork port\t:%d\n",port); printf("\tSerial port\t:%s\n",tty); printf("\tBaud rate\t:%d\n",baud_rate); printf("\tParity\t\t:%c\n",parity); } else { printf("\nStarted.\n"); } if (serialRTUenabled ) { if(access(tty,F_OK) == 0) { printf("Serial port %s exists.....\n",tty); // // Now test that it is readable, writable. // } else { printf("Serial port %s does NOT exist\n",tty); printf("Disabling serial RTU.\n"); free( tty ); tty = (char *)NULL; serialRTUenabled=0; } } query = malloc(MODBUS_TCP_MAX_ADU_LENGTH); raw_query = malloc(RAW_REQ_LENGTH); raw_reply = malloc(MODBUS_TCP_MAX_ADU_LENGTH); mb_mapping = modbus_mapping_new( MODBUS_MAX_BITS, // Coils MODBUS_MAX_BITS, // Discrete inputs MODBUS_MAX_REGISTERS, // Holding registers MODBUS_MAX_REGISTERS); // Input registers local_mb_mapping = modbus_mapping_new( NULL, // Coils NULL, // Discrete inputs LOCAL_HOLDING_REGISTERS, // Holding registers LOCAL_INPUT_REGISTERS); // Input registers // // Setup the memory for the holding registers. // if ( useSharedHolding ) { if (verbose) printf("Share the Holding regsisters R/W\n"); localHoldingRegisters = local_mb_mapping->tab_registers; holdingShmKey = iniparser_getint(ini, "system:holding_reg_key",110); holdingSemKey = iniparser_getint(ini, "system:holding_reg_sema",111); holdingShmId = shmget(holdingShmKey, localHoldingRegistersSize, IPC_CREAT | 0600 ); // change to 0400 if (holdingShmId < 0) { perror("Holding Reg shmget"); exit(3); } local_mb_mapping->tab_registers = (uint16_t *)shmat(holdingShmId,NULL,0); if (local_mb_mapping->tab_registers < 0) { perror("Holding Reg shmat"); exit(4); } /* * Create the seamphore */ holdingSemId = semget( holdingSemKey, 1, IPC_CREAT | 0600 ); if (-1 == holdingSemId) { perror("Input reg semaphore"); exit(2); } /* * Shared memory created, semaphore created (default is locked) * release the seamphore ! */ rc = semctl(holdingSemId, 0, SETVAL, 1); } // // Setup the memory for the shared input registers. // if ( useSharedInput ) { if (verbose) printf("Share the Input regsisters R/W\n"); localInputRegisters = local_mb_mapping->tab_input_registers; // Save the current pointer inputShmKey = iniparser_getint(ini, "system:input_reg_key",110); inputSemKey = iniparser_getint(ini, "system:input_reg_sema",111); inputShmId = shmget(inputShmKey, localInputRegistersSize, IPC_CREAT | 0600 ); // change to 0400 if (inputShmId < 0) { perror("Input Reg shmget"); exit(3); } local_mb_mapping->tab_input_registers = (uint16_t *)shmat(inputShmId,NULL,0); if ( local_mb_mapping->tab_input_registers < 0) { perror("Input Reg shmat"); exit(1); } /* * create the seamphore */ inputSemId = semget( inputSemKey, 1, IPC_CREAT | 0600 ); if (-1 == inputSemId) { perror("Input reg semaphore"); exit(2); } /* * Shared memory created, semaphore created (default is locked) * release the seamphore ! */ rc = semctl(inputSemId, 0, SETVAL, 1); } memset( localInputRegisters,0x00, LOCAL_INPUT_REGISTERS); memset( localHoldingRegisters,0x00, LOCAL_HOLDING_REGISTERS); local_mb_mapping->tab_input_registers[0]=0xaa55; ctx_tcp = modbus_new_tcp(ip, port); if ( tty != (char *)NULL ) { ctx_serial = modbus_new_rtu(tty, baud_rate, parity, length, stop_bits); } while ( !exitFlag ) { header_length = modbus_get_header_length(ctx_tcp); if(verbose) { modbus_set_debug(ctx_tcp, TRUE); // modbus_set_debug(ctx_serial, TRUE); } do { socket = modbus_tcp_listen(ctx_tcp, 5); if (socket < 0) { printf("%04d: Socket in use.\n",cnt++); sleep(1); } } while(socket < 0); // printf("modbus_tcp_listen =%d\n",socket); if (socket == -1) { printf("\t: %s\n", modbus_strerror(errno)); } rc=modbus_tcp_accept(ctx_tcp, &socket); // printf("modbus_tcp_accept rc=%d\n",rc); if (rc == -1) { fprintf(stderr,"FATAL ERROR: %s\n", modbus_strerror(errno)); exit(-1); } while ( 1 ) { do { if(verbose) { printf("Recieve.\n"); } rc = modbus_receive(ctx_tcp, query); // printf("rc=%d\n",rc); /* Filtered queries return 0 */ } while (rc == 0); if (-1 == rc) { if( verbose ) { printf("Client disconnected.\n"); } break; } RTU=query[header_length - 1]; io_address= ( query[header_length+1] << 8) + (query[header_length+2] & 0xff); printf("IO Address=%04x\n",io_address); if (verbose) { if( localRTU == RTU ) { printf("It's for me !\n"); } else { printf("RTU Id: %02d\n",RTU); } printf("IO Address=0x%04x\n",io_address); printf("Seq Number=0x%04x\n", query[1]); } if( localRTU == RTU ) { // // Local mapping // int len; uint16_t data; int cnt=0; // Need to add address range checks, and return an error // for an invalid function. switch (query[header_length]) { case 0x03: // read holding registers case 0x04: // read input registers rc = modbus_reply(ctx_tcp, query, rc, local_mb_mapping); break; case 0x06: //write single register swab(&query[8],&len,2); swab(&query[10],&data,2); printf("Data=%02d\n",data); local_mb_mapping->tab_registers[io_address]=data; rc = modbus_reply(ctx_tcp, query, rc, local_mb_mapping); break; case 0x10: // Write multiple registers // len=query[7]; swab(&query[10],&len,2); printf("Length=%02d\n",len); for (i=13; i< (13 + len ); i +=2) { data= (query[i] << 8) + (query[i+1] & 0xff); printf("%04x\n",data); local_mb_mapping->tab_registers[ io_address + cnt++ ] = data; } rc = modbus_reply(ctx_tcp, query, rc, local_mb_mapping); break; default: break; } } else { if(serialRTUenabled) { modbus_set_slave( ctx_serial,RTU); if( -1 == modbus_connect( ctx_serial)) { fprintf(stderr, "Connection failed: %s\n",modbus_strerror(errno)); } switch( query[header_length] ) { case 0x06: printf("Write Single Register %d\n",RTU); memcpy(raw_query,&query[header_length-1], 6); rc=modbus_send_raw_request( ctx_serial,raw_query,6); modbus_receive_confirmation(ctx_serial, raw_reply); rc = modbus_reply(ctx_tcp, query, rc, mb_mapping); break; case 0x03: case 0x04: printf("Read Registers %d\n",RTU); break; case 0x10: { int len=0; // modbus_set_debug(ctx_serial, TRUE); printf("Write multiple registers %d\n",RTU); len=query[header_length - 2]; printf("Length %d\n",len); memcpy(raw_query,&query[header_length-1], len); rc=modbus_send_raw_request( ctx_serial,raw_query,len); if( -1 == rc) { printf("modbus_send_raw_request: %s\n",modbus_strerror(errno)); } else { modbus_receive_confirmation(ctx_serial, raw_reply); rc = modbus_reply(ctx_tcp, query, rc, mb_mapping); printf("rc = %d\n",rc); // modbus_set_debug(ctx_serial, FALSE); } } break; } if( (0x03 == query[header_length]) || (0x04 == query[header_length])) { int len; if(verbose) { switch (query[header_length]) { case 0x03: printf("Read Holding Registers.\n"); break; case 0x04: printf("Read Input Registers.\n"); break; default: break; } } memcpy(raw_query,&query[header_length-1], 6); modbus_set_slave( ctx_serial, query[header_length-1]); if( -1 == modbus_connect( ctx_serial)) { fprintf(stderr, "Connection failed: %s\n",modbus_strerror(errno)); } rc=modbus_send_raw_request( ctx_serial,raw_query,6); if( -1 == rc ) { printf("modbus_send_raw_request: %s\n",modbus_strerror(errno)); } modbus_receive_confirmation(ctx_serial, raw_reply); /* * This next loop swaps bytes in words. * If this is built and running on a little endian * machine (most machines are these days) * Then this needs to be done. * If on a big endian machine (M68000 family) just * comment this out. * * It might be worth having a command line switch, * detect endianness. * */ switch (query[header_length]) { case 0x03: printf("Read Holding Registers.\n"); tmp=(unsigned char *)mb_mapping->tab_registers; break; case 0x04: printf("Read Input Registers.\n"); tmp=(unsigned char *)mb_mapping->tab_input_registers; break; default: break; } tmp_address = (io_address*2); for(i=0;i<raw_reply[2];i=i+2 ) { tmp[tmp_address+i]=raw_reply[i+4]; tmp[tmp_address+i+1]=raw_reply[i+3]; } for(i=0;i<10;i++) { if (verbose) { printf("!%02x!",raw_reply[i]); } } printf("\n"); for(i=0;i<10;i++) { if (verbose) { printf("+%02x+",tmp[i]); } } printf("\n"); // // compute packet length by getting the data length // and then add 2. // Then overwrite the outbound data. // len=raw_reply[2] + 3; rc = modbus_reply(ctx_tcp, query, rc, mb_mapping); // memcpy( mb_mapping->tab_input_registers, &raw_reply[3], raw_reply[2]); // MODBUS_SET_INT16_TO_INT8(query, header_length + 3, UT_REGISTERS_NB_SPECIAL - 1); } } } // printf("Reply with an invalid TID or slave\n"); // rc=modbus_reply_exception(ctx_tcp, query, 1); // rc=modbus_send_raw_request(ctx_tcp, raw_reply, 10 * sizeof(uint8_t)); // rc = modbus_reply(ctx_tcp, query, rc, mb_mapping); } if( verbose ) { printf("Tidying up\n"); } close(socket); usleep( 1000 ); // wait 1 ms } printf("simpleServer exiting.\n"); modbus_close(ctx_tcp); modbus_free(ctx_tcp); free(query); modbus_mapping_free(mb_mapping); return(0); }
int main(int argc, char *argv[]) { modbus_t *ctx; struct timeval timeout; int ret, ii; /*uint8_t bits[MODBUS_MAX_READ_BITS] = {0};*/ uint16_t regs[MODBUS_MAX_READ_REGISTERS] = {0}; char regs2[MODBUS_MAX_READ_REGISTERS]={0}; FILE *fp = NULL; if(argc != 3){ printf("INsufficient argument"); return 1; } ctx = modbus_new_tcp(MODBUS_CLIENT_IP, MODBUS_CLIENT_PORT); /* set device ID */ modbus_set_slave(ctx, MODBUS_DEVICE_ID); /* Debug mode */ modbus_set_debug(ctx, MODBUS_DEBUG); /* set timeout */ timeout.tv_sec = MODBUS_TIMEOUT_SEC; timeout.tv_usec = MODBUS_TIMEOUT_USEC; modbus_get_byte_timeout(ctx, &timeout); timeout.tv_sec = MODBUS_TIMEOUT_SEC; timeout.tv_usec = MODBUS_TIMEOUT_USEC; modbus_set_response_timeout(ctx, &timeout); if (modbus_connect(ctx) == -1) { fprintf(stderr, "Connexion failed: %s\n", modbus_strerror(errno)); modbus_free(ctx); exit(-1); } /* write data in test.txt */ fp = fopen("test.txt", "w"); if(fp == NULL) { printf("fail to open file!\n"); return -1; } /* read holding registers (0x03 function code) */ ret = modbus_read_registers(ctx, strtol(argv[1], NULL, 16), strtol(argv[2], NULL, 10), regs); if (ret < 0) { fprintf(stderr, "%s\n", modbus_strerror(errno)); } else { printf("HOLDING REGISTERS:\n"); for (ii=0; ii < ret; ii++) { sprintf(regs2, "%d", regs[ii]); fputs(regs2, fp); fputs("\n", fp); printf("[%d]=%d\n", ii, regs[ii]); } } fclose(fp); /* Close the connection */ modbus_close(ctx); modbus_free(ctx); exit(0); }
int setdebugmode(){ modbus_set_debug(ctx, TRUE); }
int main(int argc, char **argv) { int c; int ok; int debug = 0; BackendParams *backend = 0; int slaveAddr = 1; int startAddr = 100; int startReferenceAt0 = 0; int readWriteNo = 1; int fType = FuncNone; int timeout_ms = 1000; int hasDevice = 0; int isWriteFunction = 0; enum WriteDataType { DataInt, Data8Array, Data16Array } wDataType = DataInt; union Data { int dataInt; uint8_t *data8; uint16_t *data16; } data; while (1) { int option_index = 0; static struct option long_options[] = { {DebugOpt, no_argument, 0, 0}, {0, 0, 0, 0} }; c = getopt_long(argc, argv, "a:b:d:c:m:r:s:t:p:o:0", long_options, &option_index); if (c == -1) { break; } switch (c) { case 0: if (0 == strcmp(long_options[option_index].name, DebugOpt)) { debug = 1; } break; case 'a': { slaveAddr = getInt(optarg, &ok); if (0 == ok) { printf("Slave address (%s) is not integer!\n\n", optarg); printUsage(argv[0]); exit(EXIT_FAILURE); } } break; case 'c': { readWriteNo = getInt(optarg, &ok); if (0 == ok) { printf("# elements to read/write (%s) is not integer!\n\n", optarg); printUsage(argv[0]); exit(EXIT_FAILURE); } } break; case 'm': if (0 == strcmp(optarg, TcpOptVal)) { backend = createTcpBackend((TcpBackend*)malloc(sizeof(TcpBackend))); } else if (0 == strcmp(optarg, RtuOptVal)) backend = createRtuBackend((RtuBackend*)malloc(sizeof(RtuBackend))); else { printf("Unrecognized connection type %s\n\n", optarg); printUsage(argv[0]); exit(EXIT_FAILURE); } break; case 'r': { startAddr = getInt(optarg, &ok); if (0 == ok) { printf("Start address (%s) is not integer!\n\n", optarg); printUsage(argv[0]); exit(EXIT_FAILURE); } } break; case 't': { fType = getInt(optarg, &ok); if (0 == ok) { printf("Function type (%s) is not integer!\n\n", optarg); printUsage(argv[0]); exit(EXIT_FAILURE); } } break; case 'o': { timeout_ms = getInt(optarg, &ok); if (0 == ok) { printf("Timeout (%s) is not integer!\n\n", optarg); printUsage(argv[0]); exit(EXIT_FAILURE); } printf("Timeout set to %d\r\n", timeout_ms); } break; case '0': startReferenceAt0 = 1; break; //tcp/rtu params case 'p': case 'b': case 'd': case 's': if (0 == backend) { printf("Connection type (-m switch) has to be set before its params are provided!\n"); printUsage(argv[0]); exit(EXIT_FAILURE); } else { if (0 == backend->setParam(backend, c, optarg)) { printUsage(argv[0]); exit(EXIT_FAILURE); } } break; case '?': break; default: printf("?? getopt returned character code 0%o ??\n", c); } } if (0 == backend) { printf("No connection type was specified!\n"); printUsage(argv[0]); exit(EXIT_FAILURE); } if (1 == startReferenceAt0) { startAddr--; } //choose write data type switch (fType) { case(ReadCoils): wDataType = Data8Array; break; case(ReadDiscreteInput): wDataType = DataInt; break; case(ReadHoldingRegisters): case(ReadInputRegisters): wDataType = Data16Array; break; case(WriteSingleCoil): case(WriteSingleRegister): wDataType = DataInt; isWriteFunction = 1; break; case(WriteMultipleCoils): wDataType = Data8Array; isWriteFunction = 1; break; case(WriteMultipleRegisters): wDataType = Data16Array; isWriteFunction = 1; break; default: printf("No correct function type chosen"); printUsage(argv[0]); exit(EXIT_FAILURE); } if (isWriteFunction) { int dataNo = argc - optind - 1; /*if (-1 != readWriteNo && dataNo != readWriteNo) { printf("Write count specified, not equal to data values count!"); printUsage(argv[0]); exit(EXIT_FAILURE); } else*/ readWriteNo = dataNo; } //allocate buffer for data switch (wDataType) { case (DataInt): //no need to alloc anything break; case (Data8Array): data.data8 = malloc(readWriteNo * sizeof(uint8_t)); break; case (Data16Array): data.data16 = malloc(readWriteNo * sizeof(uint16_t)); break; default: printf("Data alloc error!\n"); exit(EXIT_FAILURE); } int wDataIdx = 0; if (1 == debug && 1 == isWriteFunction) printf("Data to write: "); if (optind < argc) { while (optind < argc) { if (0 == hasDevice) { if (0 != backend) { if (Rtu == backend->type) { RtuBackend *rtuP = (RtuBackend*)backend; strcpy(rtuP->devName, argv[optind]); hasDevice = 1; } else if (Tcp == backend->type) { TcpBackend *tcpP = (TcpBackend*)backend; strcpy(tcpP->ip, argv[optind]); hasDevice = 1; } } } else {//setting write data buffer switch (wDataType) { case (DataInt): data.dataInt = getInt(argv[optind], 0); if (debug) printf("0x%x", data.dataInt); break; case (Data8Array): { data.data8[wDataIdx] = getInt(argv[optind], 0); if (debug) printf("0x%02x ", data.data8[wDataIdx]); } break; case (Data16Array): { data.data16[wDataIdx] = getInt(argv[optind], 0); if (debug) printf("0x%04x ", data.data16[wDataIdx]); } break; } wDataIdx++; } optind++; } } if (1 == debug && 1 == isWriteFunction) printf("\n"); //create modbus context, and preapare it modbus_t *ctx = backend->createCtxt(backend); modbus_set_debug(ctx, debug); modbus_set_slave(ctx, slaveAddr); //issue the request int ret = -1; if (modbus_connect(ctx) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } else { switch (fType) { case(ReadCoils): ret = modbus_read_bits(ctx, startAddr, readWriteNo, data.data8); break; case(ReadDiscreteInput): printf("ReadDiscreteInput: not implemented yet!\n"); wDataType = DataInt; break; case(ReadHoldingRegisters): ret = modbus_read_registers(ctx, startAddr, readWriteNo, data.data16); break; case(ReadInputRegisters): ret = modbus_read_input_registers(ctx, startAddr, readWriteNo, data.data16); break; case(WriteSingleCoil): ret = modbus_write_bit(ctx, startAddr, data.dataInt); break; case(WriteSingleRegister): ret = modbus_write_register(ctx, startAddr, data.dataInt); break; case(WriteMultipleCoils): ret = modbus_write_bits(ctx, startAddr, readWriteNo, data.data8); break; case(WriteMultipleRegisters): ret = modbus_write_registers(ctx, startAddr, readWriteNo, data.data16); break; default: printf("No correct function type chosen"); printUsage(argv[0]); exit(EXIT_FAILURE); } } if (ret == readWriteNo) {//success if (isWriteFunction) printf("SUCCESS: written %d elements!\n", readWriteNo); else { printf("SUCCESS: read %d of elements:\n\tData: ", readWriteNo); int i = 0; if (DataInt == wDataType) { printf("0x%04x\n", data.dataInt); } else { const char Format8[] = "0x%02x "; const char Format16[] = "0x%04x "; const char *format = ((Data8Array == wDataType) ? Format8 : Format16); for (; i < readWriteNo; ++i) { printf(format, (Data8Array == wDataType) ? data.data8[i] : data.data16[i]); } printf("\n"); } } } else { printf("ERROR occured!\n"); modbus_strerror(errno); } //cleanup modbus_close(ctx); modbus_free(ctx); backend->del(backend); switch (wDataType) { case (DataInt): //nothing to be done break; case (Data8Array): free(data.data8); break; case (Data16Array): free(data.data16); break; } exit(EXIT_SUCCESS); }
int main( int argc, char **argv ) { int a, rc; int ec = 0; options_t options; modbus_t *ctx; uint8_t *tab_bit; uint16_t *tab_reg; if(argc > 1) { options_init(&options); for (a = 1; a < argc; a++) { options_execute(&options, argv[a], strlen(argv[a])+1); rc = options_finish(&options); DEBUG("argument: '%s' end state: %d\n",argv[a], rc); if (rc == -1) { options_err_disp(&options,argv[a]); ec = 1; goto exit; } } if(rc == 0) { fprintf(stderr, "Missing action argument\n"); ec = 1; goto exit; } if(options.action == _UNDEF) goto exit; // Options are valid options_dump(&options); ctx = modbus_init_con(&options); modbus_set_debug(ctx, options.debug); modbus_set_response_timeout(ctx, &options.timeout); if (modbus_connect(ctx) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); ec = 1; goto destroy; } switch(options.action) { case _RC: case _RD: tab_bit = (uint8_t *) malloc(options.count * sizeof(uint8_t)); DBG_ASSERT(tab_bit != NULL, "Unable to allocate tab_bit!"); memset(tab_bit, 0, options.count * sizeof(uint8_t)); switch(options.action) { case _RC: rc = modbus_read_bits(ctx, options.address, options.count, tab_bit); break; case _RD: rc = modbus_read_input_bits(ctx, options.address, options.count, tab_bit); break; } if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); ec = 1; } else { display_8bit(&options, tab_bit); } free(tab_bit); break; case _RH: case _RI: tab_reg = (uint16_t *) malloc(options.count * sizeof(uint16_t)); DBG_ASSERT(tab_reg != NULL, "Unable to allocate tab_reg!"); switch(options.action) { case _RH: rc = modbus_read_registers(ctx, options.address, options.count, tab_reg); break; case _RI: rc = modbus_read_input_registers(ctx, options.address, options.count, tab_reg); break; } if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); ec = 1; } else { display_16bit(&options, tab_reg); } free(tab_reg); break; case _WC: if(options.count == 1) rc = modbus_write_bit(ctx, options.address, options.coil_values[0]); else { rc = modbus_write_bits(ctx, options.address, options.count, options.coil_values); } if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); ec = 1; } else { printf("Success\n"); } break; case _WH: if(options.count == 1) rc = modbus_write_register(ctx, options.address, options.reg_values[0]); else { rc = modbus_write_registers(ctx, options.address, options.count, options.reg_values); } if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); ec = 1; } else { printf("Success\n"); } break; default: DBG_ASSERT(0,"Unhandled action enum constant!"); } } else { options_help(); ec = 1; goto exit; } close: modbus_close(ctx); destroy: modbus_free(ctx); exit: return ec; }