/** * @brief Help function. FC5, FC6 request handler * * @fc Function code 5 and 6 only. * @param handle Mbtcp handle. * @param req cJSON request object. * @return Modbus response string in JSON format. */ static char * mbtcp_single_write_req(int fc, mbtcp_handle_s *handle, cJSON *req) { BEGIN(enable_syslog); int addr = json_get_int(req, "addr"); int tid = json_get_int(req, "tid"); int data = json_get_int(req, "data"); int ret = 0; switch (fc) { case 5: ret = modbus_write_bit(handle->ctx, addr, data); break; case 6: ret = modbus_write_register(handle->ctx, addr, data); break; default: return set_modbus_error_resp(tid, "Wrong function code"); } if (ret < 0) { return set_modbus_errno_resp(tid, handle, errno); } else { return set_modbus_no_data_ok_resp(tid); } }
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 != 4) { printf("name ip adress register and value\n"); exit(1); } int setvalue; sscanf(argv[3],"%d",&setvalue); 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; } printf("%d=%d\n",setregister, setvalue); rc = modbus_write_bit(mb,setregister,setvalue); if (rc == -1) { fprintf(stderr, "write registers: %s\n", modbus_strerror(errno)); return -1; } modbus_close(mb); modbus_free(mb); }
int main(int argc, char *argv[]) { modbus_t *mb; uint16_t tab_reg[256]; uint8_t bit_reg[256]; int rc; int i; int actual; mb = modbus_new_tcp("192.168.1.120", 502); if (modbus_connect(mb) == -1) { fprintf(stderr, "modbus connect: %s\n", modbus_strerror(errno)); modbus_free(mb); return -1; } sscanf(getenv("QUERY_STRING"),"%d",&actual); printf("Content-type: text/plain\n\n"); /* Read 5 registers from the address 10 */ //rc = modbus_read_registers(mb, 100, 10, tab_reg); rc = modbus_write_bit(mb,100,actual); if (rc == -1) { fprintf(stderr, "write bit: %s\n", modbus_strerror(errno)); return -1; } modbus_close(mb); modbus_free(mb); }
int write_single_coil(int address, uint8_t data){ int retries = 3; do { if (modbus_write_bit(ctx,address,data)==1){ qWarning() << "Successful Write"; return 1; }else{ retries--; qWarning() << "Failed to Write, re-attempting"; } } while( retries <= 0); qWarning() << "Failed to Write, reached retry limit!"; return 0; }
/* * This Function sends modbus request and returns the response * Arguments: * unsigned char * fn :- Modbus request array. 1st byte is function code, next 2 bytes is address of register * 4th 5th byte is no. of register. 6th 7th byte is data. Modbus response is sent back on * 6th and 7th byte * Return Value :- 0 : On successful * -1 : on error */ int MBSendRequest(unsigned char *fn) { uint16_t address,NIitem,*data,data1 ; int ret=0; address = *(fn+1); address = address<<8; // This is done so that data recieved is in big indian format. address = address | (*(fn+2)); //It should be converted to little indian format NIitem = *(fn+3); NIitem = NIitem<<8; NIitem = NIitem | *(fn+4); data1 = *(fn+5); data1 = data1<<8; data1 = data1 | *(fn+6); data = &data1; printf("Function code = %d \n",*fn); printf("register address = %x \n",address); printf("NIitem = %x \n",NIitem); printf("Data=%d\n",*data); switch(*fn) { case 1:ret = modbus_read_bits(ctx,address,NIitem,(uint8_t*) data); break; case 2:ret = modbus_read_input_bits(ctx,address,NIitem,(uint8_t*) data); break; case 3:ret = modbus_read_registers(ctx,address,NIitem,data); break; case 4:ret = modbus_read_input_registers(ctx,address,NIitem,data); break; case 5:ret = modbus_write_bit(ctx,address,*data); break; case 6:ret = modbus_write_register(ctx,address,*data); break; case 15:ret = modbus_write_bits(ctx,address,NIitem,(uint8_t*) data); break; case 16:ret = modbus_write_registers(ctx,address,NIitem,data); break; } *(fn+6)=((*data) >> 8)& 0x00ff; *(fn+5)= (*data) & 0x00ff; return ret; }
static int ctx_write_bit(lua_State *L) { ctx_t *ctx = ctx_check(L, 1); int addr = luaL_checknumber(L, 2); int val; if (lua_type(L, 3) == LUA_TNUMBER) { val = lua_tonumber(L, 3); } else if (lua_type(L, 3) == LUA_TBOOLEAN) { val = lua_toboolean(L, 3); } else { return luaL_argerror(L, 3, "bit must be numeric or boolean"); } int rc = modbus_write_bit(ctx->modbus, addr, val); return libmodbus_rc_to_nil_error(L, rc, 1); }
int MODBUSPuerto::escribir (int cod , int inicio , int val){ int res = modbus_write_bit(ctx,inicio,val); return res; }
/* Read values from modbus */ uint8_t read_modbus(modbus_t *ctx, uint8_t readOrWrite, uint16_t modbusRegister, GenDataType_t typeOfValue, MoBuRegType_t typeOfReg, uint8_t desiredBit, uint16_t* valueArray) { uint8_t noOfRegisters = 0; uint16_t modbusValueArray[2]; uint16_t modbusTmpValue; //used for bit values read from registers memset(modbusValueArray, 0x00, (sizeof(uint16_t) * 2)); if (readOrWrite > 0) { log_entry(APP_NAME, "invalid parameter in read_modbus: Only reading values supported"); printf("invalid parameter in read_modbus: Only reading values supported"); return -1; } switch (typeOfValue) { case bitCoil: case sint16: // read one address case uint16: //read one address noOfRegisters = 1; break; case sint32: //read 2 registers case uint32: case float32: noOfRegisters = 2; break; default: log_entry(APP_NAME, "MODBUSD; unknown dataType"); printf("MODBUSD; unknown dataType: %d", typeOfValue); } switch (typeOfReg) { case coil: if (0 == readOrWrite) { //read if (1 != modbus_read_bits(ctx, modbusRegister, 1, (uint8_t *) modbusValueArray)) { log_entry(APP_NAME, "MODBUSD: could not read coils"); printf("MODBUSD: could not read coils: %d, %s", modbusRegister, strerror(errno)); return -1; } } else { /* first read the whole unit16 value */ if (1 == modbus_read_bits(ctx, modbusRegister, 1, (uint8_t *) modbusValueArray)) { if (valueArray[0] == 0) { modbusTmpValue = 0; } else if (valueArray[0] == 1) { //setting bit to 1 modbusTmpValue = 1; } else { //toggle the bit if(0 == modbusValueArray[0]){ modbusTmpValue = 1; } else { modbusTmpValue = 0; } } if (1 != modbus_write_bit(ctx, modbusRegister, modbusTmpValue)) { return -1; } } } break; case discrete_input: if (0 == readOrWrite) { //read if (1 != modbus_read_input_bits(ctx, modbusRegister, noOfRegisters, (uint8_t *) &(modbusValueArray[0]))) { log_entry(APP_NAME, "MODBUSD: could not read input"); printf("MODBUSD: could not read input: %d, %s", modbusRegister, strerror(errno)); return -1; } } else { log_entry(APP_NAME, "MODBUSD: illegal operation -> unable to write on discrete input"); printf("MODBUSD: illegal operation -> unable to write on discrete input"); } break; case holding_register: if (0 == readOrWrite) { //read if (1 != modbus_read_registers(ctx, modbusRegister, noOfRegisters, &(modbusValueArray[0]))) { return -1; } } else { if (1 != modbus_write_registers(ctx, modbusRegister, noOfRegisters, &(valueArray[0]))) { return -1; } } break; case input_register: if (0 == readOrWrite) { //read if (1 != modbus_read_input_registers(ctx, modbusRegister, noOfRegisters, &(modbusValueArray[0]))) { log_entry(APP_NAME, "MODBUSD: could not read input registers"); printf("MODBUSD: could not read input registers: %d, %s", modbusRegister, strerror(errno)); return -1; } } else { log_entry(APP_NAME, "unable to write on input register"); printf("unable to write on input register"); } break; case holding_bit: if (0 == readOrWrite) { //read if (1 == modbus_read_registers(ctx, modbusRegister, noOfRegisters, &modbusTmpValue)) { modbusValueArray[0] = modbusTmpValue & (1 << desiredBit); } else { return -1; } } else { /* first read the whole unit16 value */ if (1 == modbus_read_registers(ctx, modbusRegister, noOfRegisters, &modbusTmpValue)) { if (valueArray[0] == 0) { //clearing a bit at postion desired bit modbusTmpValue &= ~(1 << desiredBit); } else if (valueArray[0] == 1) { //setting bit to 1 modbusTmpValue |= 1 << desiredBit; } else { //toggle the bit modbusTmpValue ^= 1 << desiredBit; } if (1 != modbus_write_registers(ctx, modbusRegister, noOfRegisters, &modbusTmpValue)) { return -1; } } else { return -1; } } break; case input_bit: if (0 == readOrWrite) { //read if (1 == modbus_read_input_registers(ctx, modbusRegister, noOfRegisters, &modbusTmpValue)) { modbusValueArray[0] = modbusTmpValue & (1 << desiredBit); } else { return -1; } } else { log_entry(APP_NAME, "MODBUSD; unable to write single bit for input register"); printf("MODBUSD; unable to write single bit for input register"); return -1; } break; default: log_entry(APP_NAME, "MODBUSD; unknown register type"); printf("MODBUSD; unknown register type %d", typeOfReg); } if (0 == readOrWrite) { //read valueArray[0] = modbusValueArray[0]; valueArray[1] = modbusValueArray[1]; } return 1; }
int 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; }
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); }
/* 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) { uint8_t *tab_bit; uint16_t *tab_reg; /* Allocate and initialize the memory to store the status */ tab_bit = (uint8_t *)malloc(MODBUS_MAX_READ_BITS * sizeof(uint8_t)); memset(tab_bit, 0, MODBUS_MAX_READ_BITS * sizeof(uint8_t)); /* Allocate and initialize the memory to store the registers */ tab_reg = (uint16_t *)malloc(MODBUS_MAX_READ_REGISTERS * sizeof(uint16_t)); memset(tab_reg, 0, MODBUS_MAX_READ_REGISTERS * sizeof(uint16_t)); /* Defaults */ char host[1024] = "127.0.0.1"; size_t port = 502; enum mb_operations operation = read_registers; size_t base_addr = 0; // read from address 0 by deafult size_t n_addrs = 10; // read forst 10 addressxes by default. size_t n_times = 1; // one times by default. size_t interval = 0; // no waiting by default. bool quiet = false; // Do not suppress output by default. size_t n_data = 0; // The number of data items from the command line. char **data_items; // Array of data items from the command line. int c; int rc; while (1) { c = getopt(argc, argv, "h:p:o:b:a:n:i:q"); if (c == -1) break; switch (c) { case 'h': printf("Connect to host: '%s'\n", optarg); strncpy(host, optarg, 1024); // Made host str 1024. Should define a constant. break; case 'p': printf("Connect on port: '%s'\n", optarg); port = strtoul(optarg, (void *)0, 10); break; case 'o': printf("Option o with value '%s'\n", optarg); if (!strcmp("read_bits", optarg)) operation = read_bits; if (!strcmp("read_input_bits", optarg)) operation = read_input_bits; if (!strcmp("read_registers", optarg)) operation = read_registers; if (!strcmp("read_input_registers", optarg))operation = read_input_registers; if (!strcmp("write_bit", optarg)) operation = write_bit; if (!strcmp("write_register", optarg)) operation = write_register; if (!strcmp("write_bits", optarg)) operation = write_bits; if (!strcmp("write_registers",optarg)) operation = write_registers; break; case 'b': printf("Base address set to: '%s'\n", optarg); base_addr = strtoul(optarg, (void *)0, 10);; break; case 'a': printf("Number of addresses to read: '%s'\n", optarg); n_addrs = strtoul(optarg, (void *)0, 10); if (n_addrs > MODBUS_MAX_READ_REGISTERS) { printf("Number of addresses to read adjusted to maximum: '%i'\n", MODBUS_MAX_READ_REGISTERS); n_addrs = MODBUS_MAX_READ_REGISTERS; } break; case 'n': printf("Repeat this many times: '%s'\n", optarg); n_times = strtoul(optarg, (void *)0, 10); break; case 'i': printf("Repeat at this interval: '%s'\n", optarg); interval = strtoul(optarg, (void *)0, 10); break; case 'q': printf("option q: supressing output.\n"); quiet = true; break; case '?': printf("option ?: There is not doc only source codes.\n"); break; default: printf("?? getopt returned character code 0%o ??\n", c); } } if (optind < argc) { n_data = argc - optind; data_items = (char **)malloc(n_data * sizeof(char *)); printf("There are %i non-option ARGV-elements: ", (argc-optind)); size_t n = 0; while (optind < argc) { printf("%s ", argv[optind]); data_items[n] = argv[optind]; ++optind; ++n; } printf("\n"); } /* Get show on the road. */ modbus_t *ctx; ctx = modbus_new_tcp(host, port); if (modbus_connect(ctx) == -1) { fprintf(stderr, "Connection failed: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } for (size_t i = 0; i<n_times; i++) { switch (operation) { case read_bits: printf("READ BITS:\n"); rc = modbus_read_bits(ctx, base_addr, n_addrs, tab_bit); if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); return(EXIT_FAILURE); } if (!quiet) { /* What did we read?*/ for (uint8_t *reg_ptr = tab_bit; reg_ptr < tab_bit + n_addrs; reg_ptr++) { printf("%i ", *reg_ptr); } printf("\n"); } break; case read_input_bits: printf("READ INPUT BITS:\n"); rc = modbus_read_input_bits(ctx, base_addr, n_addrs, tab_bit); if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); return(EXIT_FAILURE); } if (!quiet) { /* What did we read?*/ for (uint8_t *reg_ptr = tab_bit; reg_ptr < tab_bit + n_addrs; reg_ptr++) { printf("%i ", *reg_ptr); } printf("\n"); } break; case read_registers: printf("READ REGISTERS:\n"); rc = modbus_read_registers(ctx, base_addr, n_addrs, tab_reg); if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); return(EXIT_FAILURE); } if (!quiet) { /* What did we read?*/ for (uint16_t *reg_ptr = tab_reg; reg_ptr < tab_reg + n_addrs; reg_ptr++) { printf("%i ", *reg_ptr); } printf("\n"); } break; case read_input_registers: printf("READ INPUT REGISTERS\n\n"); rc = modbus_read_input_registers(ctx, base_addr, n_addrs, tab_reg); if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); return(EXIT_FAILURE); } if (!quiet) { /* What did we read?*/ for (uint16_t *reg_ptr = tab_reg; reg_ptr < tab_reg + n_addrs; reg_ptr++) { printf("%i ", *reg_ptr); } printf("\n"); } break; case write_bit: printf("WRITE BIT\n"); n_addrs = 1; if (n_addrs > n_data) { fprintf(stderr, "Not enough data items on command line to write to requested address.\n"); return(EXIT_FAILURE); } for (uint8_t *reg_ptr = tab_bit; reg_ptr < tab_bit + n_addrs; reg_ptr++) { *reg_ptr = strtoul(*data_items++, (void *)0, 10); } rc = modbus_write_bit(ctx, base_addr, tab_bit); if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); return(EXIT_FAILURE); } break; case write_register: printf("WRITE REGISTER\n"); // There is only one register. Almost everything else stays the same as write_registers. n_addrs = 1; if (n_addrs > n_data) { fprintf(stderr, "Not enough data items on command line to write to requested address.\n"); return(EXIT_FAILURE); } for (uint16_t *reg_ptr = tab_reg; reg_ptr < tab_reg + n_addrs; reg_ptr++) { *reg_ptr = strtoul(*data_items++, (void *)0, 10); } rc = modbus_write_register(ctx, base_addr, tab_reg); if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); return(EXIT_FAILURE); } break; case write_bits: printf("WRITE BITS\n"); if (n_addrs > n_data) { fprintf(stderr, "Not enough data items on command line to write to requested addresses.\n"); return(EXIT_FAILURE); } for (uint8_t *reg_ptr = tab_bit; reg_ptr < tab_bit + n_addrs; reg_ptr++) { *reg_ptr = strtoul(*data_items++, (void *)0, 10); } rc = modbus_write_bits(ctx, base_addr, n_addrs, tab_bit); if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); return(EXIT_FAILURE); } break; case write_registers: printf("WRITE REGISTERS\n"); if (n_addrs > n_data) { fprintf(stderr, "Not enough data items on command line to write to requested addresses.\n"); return(EXIT_FAILURE); } for (uint16_t *reg_ptr = tab_reg; reg_ptr < tab_reg + n_addrs; reg_ptr++) { *reg_ptr = strtoul(*data_items++, (void *)0, 10); } rc = modbus_write_registers(ctx, base_addr, n_addrs, tab_reg); if (rc == -1) { fprintf(stderr, "%s\n", modbus_strerror(errno)); return(EXIT_FAILURE); } break; default: break; } sleep(interval); } /* Free the memory */ free(tab_bit); free(tab_reg); //free(data_items); /* Close the connection */ modbus_close(ctx); modbus_free(ctx); exit(EXIT_SUCCESS); }
void TDefaultModbusContext::WriteCoil(int addr, int value) { if (modbus_write_bit(InnerContext, addr, value) < 0) throw TModbusException("failed to write coil @ " + std::to_string(addr)); }