TCP server

Each TCP server processes requests for one or more unit IDs from multiple external clients.

The DeviceMap class (ServerHandlerMap in Rust) associates each unit ID with the data and write handling you provide to clients. The server doesn't reply to a request for a unit ID that isn't in the map.

Creating a server

First build a DeviceMap for each unit ID the server must support. Then use the create_tcp static method of the Server class (spawn_tcp_server_task in Rust). The server starts listening immediately, and creation fails if it can't bind the port, for example when another process already uses it.

You also choose the local address to listen on, such as:

• 127.0.0.1 for localhost only
• 0.0.0.0 for all adapters
• The IP address of a particular adapter

The other arguments are the AddressFilter, the maximum number of sessions and the decode level; the API docs describe each one. The AddressFilter limits which client IP addresses may connect; AddressFilter.any() allows all of them, and the filter also accepts IPv4 wildcards such as 192.168.0.*.

When a new connection would exceed the maximum number of sessions, the server closes the oldest session to make room.

Rust

let handler = SimpleHandler::new(POINT_COUNT).wrap();

// map unit ids to a handler for processing requests
let map = ServerHandlerMap::single(UnitId::new(UNIT_ID), handler.clone());

let server = rodbus::server::spawn_tcp_server_task(
    MAX_SESSIONS,
    endpoint,
    map,
    AddressFilter::Any,
    DecodeLevel::new(
        AppDecodeLevel::DataHeaders,
        FrameDecodeLevel::Nothing,
        PhysDecodeLevel::Nothing,
    ),
)
.await?;

C

rodbus_device_map_t *map = rodbus_device_map_create();
rodbus_device_map_add_endpoint(map,
    UNIT_ID,                                                 // unit id
    get_write_handler(),                                     // handler for write requests
    (rodbus_database_callback_t){.callback = &configure_db} // callback for the initial state of the database
);

rodbus_server_t *server = NULL;
rodbus_decode_level_t decode_level = rodbus_decode_level_build(RODBUS_APP_DECODE_LEVEL_DATA_HEADERS, RODBUS_FRAME_DECODE_LEVEL_NOTHING, RODBUS_PHYS_DECODE_LEVEL_NOTHING);
rodbus_address_filter_t *filter = rodbus_address_filter_any();
rodbus_param_error_t err = rodbus_server_create_tcp(runtime, host, port, filter, MAX_SESSIONS, map, decode_level, &server);
rodbus_address_filter_destroy(filter);
rodbus_device_map_destroy(map);
if (err) {
    printf("unable to create server: %s\n", rodbus_param_error_to_string(err));
    return NULL;
}

C++

// POINT_COUNT points of each type, starting at index 0
auto init_transaction = rodbus::functional::database_callback([](rodbus::Database &db) {
    for (uint16_t i = 0; i < POINT_COUNT; ++i) {
        db.add_coil(i, false);
        db.add_discrete_input(i, false);
        db.add_holding_register(i, 0);
        db.add_input_register(i, 0);
    }
});
auto map = rodbus::DeviceMap();
map.add_endpoint(UNIT_ID, create_write_handler(), init_transaction);

auto filter = rodbus::AddressFilter::any();
auto server = rodbus::Server::create_tcp(
    runtime,
    endpoint.host,
    endpoint.port,
    filter,
    MAX_SESSIONS,
    map,
    rodbus::DecodeLevel(rodbus::AppDecodeLevel::data_headers, rodbus::FrameDecodeLevel::nothing, rodbus::PhysDecodeLevel::nothing)
);

Java

DeviceMap map = new DeviceMap();
map.addEndpoint(ubyte(UNIT_ID), new ExampleWriteHandler(), db -> {
    for (int i = 0; i < POINT_COUNT; i++) {
        db.addCoil(ushort(i), false);
        db.addDiscreteInput(ushort(i), false);
        db.addHoldingRegister(ushort(i), ushort(0));
        db.addInputRegister(ushort(i), ushort(0));
    }
});

Server server = Server.createTcp(
        runtime,
        host,
        port,
        AddressFilter.any(),
        ushort(MAX_SESSIONS),
        map,
        new DecodeLevel(AppDecodeLevel.DATA_HEADERS, FrameDecodeLevel.NOTHING, PhysDecodeLevel.NOTHING)
);

C#

var map = new DeviceMap();
map.AddEndpoint(UnitId, new WriteHandler(), db =>
{
    for (ushort i = 0; i < PointCount; ++i)
    {
        db.AddCoil(i, false);
        db.AddDiscreteInput(i, false);
        db.AddHoldingRegister(i, 0);
        db.AddInputRegister(i, 0);
    }
});

var server = Server.CreateTcp(
    runtime,
    address,
    port,
    AddressFilter.Any(),
    MaxSessions,
    map,
    new DecodeLevel(AppDecodeLevel.DataHeaders, FrameDecodeLevel.Nothing, PhysDecodeLevel.Nothing)
);

In Rust, the wrap() method of RequestHandler moves your handler into the Arc<Mutex> that the ServerHandlerMap holds.