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; }
static int libmodbus_new_tcp_pi(lua_State *L) { const char *host = luaL_checkstring(L, 1); const char *service = luaL_checkstring(L, 2); // Do we really need any of this? no callbacks in libmodbus? ctx_t *ctx = (ctx_t *) lua_newuserdata(L, sizeof(ctx_t)); ctx->modbus = modbus_new_tcp_pi(host, service); ctx->max_len = MODBUS_TCP_MAX_ADU_LENGTH; if (ctx->modbus == NULL) { return luaL_error(L, modbus_strerror(errno)); } ctx->L = L; luaL_getmetatable(L, MODBUS_META_CTX); // Can I put more functions in for tcp here? maybe? lua_setmetatable(L, -2); return 1; }
bool mbtcp_init_handle(mbtcp_handle_s **ptr_handle, char *ip, char *port) { BEGIN(enable_syslog); // create a mbtcp context modbus_t *ctx = modbus_new_tcp_pi(ip, port); if (ctx == NULL) { ERR(enable_syslog, "Unable to allocate mbtcp context"); return false; // fail to allocate context } // set tcp connection timeout modbus_set_response_timeout(ctx, 0, tcp_conn_timeout_usec); // @add context to mbtcp hashtable mbtcp_handle_s *handle; handle = (mbtcp_handle_s*)malloc(sizeof(mbtcp_handle_s)); // let alignment bytes being set to zero-value!! memset(handle, 0, sizeof(mbtcp_handle_s)); handle->connected = false; strcpy(handle->key.ip, ip); strcpy(handle->key.port, port); handle->ctx = ctx; HASH_ADD(hh, mbtcp_htable, key, sizeof(mbtcp_key_s), handle); LOG(enable_syslog, "Add %s:%s to mbtcp hashtable", handle->key.ip, mbtcp_htable->key.port); // call by reference to `mbtcp handle address` *ptr_handle = handle; // @connect to server char * reason = NULL; mbtcp_do_connect(handle, &reason); return true; }
int main(int argc, char*argv[]) { int s = -1; modbus_t *ctx; modbus_mapping_t *mb_mapping; int rc; int i; int use_backend; uint8_t *query; int header_length; if (argc > 1) { if (strcmp(argv[1], "tcp") == 0) { use_backend = TCP; } else if (strcmp(argv[1], "tcppi") == 0) { use_backend = TCP_PI; } else if (strcmp(argv[1], "rtu") == 0) { use_backend = RTU; } else { printf("Usage:\n %s [tcp|tcppi|rtu] - Modbus server for unit testing\n\n", argv[0]); return -1; } } else { /* By default */ use_backend = TCP; } if (use_backend == TCP) { ctx = modbus_new_tcp("127.0.0.1", 1502); query = malloc(MODBUS_TCP_MAX_ADU_LENGTH); } else if (use_backend == TCP_PI) { ctx = modbus_new_tcp_pi("::0", "1502"); query = malloc(MODBUS_TCP_MAX_ADU_LENGTH); } else { ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1); modbus_set_slave(ctx, SERVER_ID); query = malloc(MODBUS_RTU_MAX_ADU_LENGTH); } header_length = modbus_get_header_length(ctx); modbus_set_debug(ctx, TRUE); mb_mapping = modbus_mapping_new( UT_BITS_ADDRESS + UT_BITS_NB, UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB, UT_REGISTERS_ADDRESS + UT_REGISTERS_NB, UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB); if (mb_mapping == NULL) { fprintf(stderr, "Failed to allocate the mapping: %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } /* Unit tests of modbus_mapping_new (tests would not be sufficient if two nb_* were identical) */ if (mb_mapping->nb_bits != UT_BITS_ADDRESS + UT_BITS_NB) { printf("Invalid nb bits (%d != %d)\n", UT_BITS_ADDRESS + UT_BITS_NB, mb_mapping->nb_bits); modbus_free(ctx); return -1; } if (mb_mapping->nb_input_bits != UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB) { printf("Invalid nb input bits: %d\n", UT_INPUT_BITS_ADDRESS + UT_INPUT_BITS_NB); modbus_free(ctx); return -1; } if (mb_mapping->nb_registers != UT_REGISTERS_ADDRESS + UT_REGISTERS_NB) { printf("Invalid nb registers: %d\n", UT_REGISTERS_ADDRESS + UT_REGISTERS_NB); modbus_free(ctx); return -1; } if (mb_mapping->nb_input_registers != UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB) { printf("Invalid nb input registers: %d\n", UT_INPUT_REGISTERS_ADDRESS + UT_INPUT_REGISTERS_NB); modbus_free(ctx); return -1; } /* Examples from PI_MODBUS_300.pdf. Only the read-only input values are assigned. */ /** INPUT STATUS **/ modbus_set_bits_from_bytes(mb_mapping->tab_input_bits, UT_INPUT_BITS_ADDRESS, UT_INPUT_BITS_NB, UT_INPUT_BITS_TAB); /** INPUT REGISTERS **/ for (i=0; i < UT_INPUT_REGISTERS_NB; i++) { mb_mapping->tab_input_registers[UT_INPUT_REGISTERS_ADDRESS+i] = UT_INPUT_REGISTERS_TAB[i];; } if (use_backend == TCP) { s = modbus_tcp_listen(ctx, 1); modbus_tcp_accept(ctx, &s); } else if (use_backend == TCP_PI) { s = modbus_tcp_pi_listen(ctx, 1); modbus_tcp_pi_accept(ctx, &s); } else { rc = modbus_connect(ctx); if (rc == -1) { fprintf(stderr, "Unable to connect %s\n", modbus_strerror(errno)); modbus_free(ctx); return -1; } } for (;;) { do { rc = modbus_receive(ctx, query); /* Filtered queries return 0 */ } while (rc == 0); /* The connection is not closed on errors which require on reply such as bad CRC in RTU. */ if (rc == -1 && errno != EMBBADCRC) { /* Quit */ break; } /* Special server behavior to test client */ if (query[header_length] == 0x03) { /* Read holding registers */ if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 3) == UT_REGISTERS_NB_SPECIAL) { printf("Set an incorrect number of values\n"); MODBUS_SET_INT16_TO_INT8(query, header_length + 3, UT_REGISTERS_NB_SPECIAL - 1); } else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1) == UT_REGISTERS_ADDRESS_SPECIAL) { printf("Reply to this special register address by an exception\n"); modbus_reply_exception(ctx, query, MODBUS_EXCEPTION_SLAVE_OR_SERVER_BUSY); continue; } else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1) == UT_REGISTERS_ADDRESS_INVALID_TID_OR_SLAVE) { const int RAW_REQ_LENGTH = 5; uint8_t raw_req[] = { (use_backend == RTU) ? INVALID_SERVER_ID : 0xFF, 0x03, 0x02, 0x00, 0x00 }; printf("Reply with an invalid TID or slave\n"); modbus_send_raw_request(ctx, raw_req, RAW_REQ_LENGTH * sizeof(uint8_t)); continue; } else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1) == UT_REGISTERS_ADDRESS_SLEEP_500_MS) { printf("Sleep 0.5 s before replying\n"); usleep(500000); } else if (MODBUS_GET_INT16_FROM_INT8(query, header_length + 1) == UT_REGISTERS_ADDRESS_BYTE_SLEEP_5_MS) { /* Test low level only available in TCP mode */ /* Catch the reply and send reply byte a byte */ uint8_t req[] = "\x00\x1C\x00\x00\x00\x05\xFF\x03\x02\x00\x00"; int req_length = 11; int w_s = modbus_get_socket(ctx); /* Copy TID */ req[1] = query[1]; for (i=0; i < req_length; i++) { printf("(%.2X)", req[i]); usleep(5000); send(w_s, (const char*)(req + i), 1, MSG_NOSIGNAL); } continue; } } rc = modbus_reply(ctx, query, rc, mb_mapping); if (rc == -1) { break; } } printf("Quit the loop: %s\n", modbus_strerror(errno)); if (use_backend == TCP) { if (s != -1) { close(s); } } modbus_mapping_free(mb_mapping); free(query); /* For RTU */ modbus_close(ctx); modbus_free(ctx); return 0; }
int main(int argc, char*argv[]) { int 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], "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) { printf("Modbus TCP server for unit testing.\n"); ctx = modbus_new_tcp("127.0.0.1", 1502); query = (uint8_t *)malloc(MODBUS_TCP_MAX_ADU_LENGTH); } else if (use_backend == TCP_PI) { ctx = modbus_new_tcp_pi("::0", "1502"); query = (uint8_t *)malloc(MODBUS_TCP_MAX_ADU_LENGTH); } else { printf("Modbus RTU server for unit testing.\n"); ctx = modbus_new_rtu("/dev/ttyUSB0", 115200, 'N', 8, 1); modbus_set_slave(ctx, SERVER_ID); query = (uint8_t *)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; } /* 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) { socket = modbus_tcp_listen(ctx, 1); modbus_tcp_accept(ctx, &socket); } else if (use_backend == TCP_PI) { socket = modbus_tcp_pi_listen(ctx, 1); modbus_tcp_pi_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, query); if (rc == -1) { printf("Connection closed by the client or error.\n"); break; } /* Read holding registers */ if (query[header_length] == 0x03) { 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; } } 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; }