rodbus.h

Go to the documentation of this file.

// This library is provided under the terms of a non-commercial license.
// 
// Please refer to the source repository for details:
// 
// https://github.com/stepfunc/rodbus/blob/master/LICENSE.txt
// 
// Please contact Step Function I/O if you are interested in commercial license:
// 
// info@stepfunc.io
#pragma once
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define RODBUS_VERSION_MAJOR 1
#define RODBUS_VERSION_MINOR 3
#define RODBUS_VERSION_PATCH 1
#define RODBUS_VERSION_STRING "1.3.1"
 
#include <stdbool.h>
#include <stdint.h>
 
 
typedef enum rodbus_param_error_t
{
    RODBUS_PARAM_ERROR_OK = 0,
    RODBUS_PARAM_ERROR_NO_SUPPORT = 1,
    RODBUS_PARAM_ERROR_NULL_PARAMETER = 2,
    RODBUS_PARAM_ERROR_LOGGING_ALREADY_CONFIGURED = 3,
    RODBUS_PARAM_ERROR_RUNTIME_CREATION_FAILURE = 4,
    RODBUS_PARAM_ERROR_RUNTIME_DESTROYED = 5,
    RODBUS_PARAM_ERROR_RUNTIME_CANNOT_BLOCK_WITHIN_ASYNC = 6,
    RODBUS_PARAM_ERROR_INVALID_IP_ADDRESS = 7,
    RODBUS_PARAM_ERROR_INVALID_RANGE = 8,
    RODBUS_PARAM_ERROR_INVALID_REQUEST = 9,
    RODBUS_PARAM_ERROR_INVALID_INDEX = 10,
    RODBUS_PARAM_ERROR_SERVER_BIND_ERROR = 11,
    RODBUS_PARAM_ERROR_INVALID_UNIT_ID = 12,
    RODBUS_PARAM_ERROR_INVALID_PEER_CERTIFICATE = 13,
    RODBUS_PARAM_ERROR_INVALID_LOCAL_CERTIFICATE = 14,
    RODBUS_PARAM_ERROR_INVALID_PRIVATE_KEY = 15,
    RODBUS_PARAM_ERROR_INVALID_DNS_NAME = 16,
    RODBUS_PARAM_ERROR_BAD_TLS_CONFIG = 17,
    RODBUS_PARAM_ERROR_SHUTDOWN = 18,
    RODBUS_PARAM_ERROR_INVALID_UTF8 = 19,
} rodbus_param_error_t;
 
static const char* rodbus_param_error_to_string(rodbus_param_error_t value)
{
    switch (value)
    {
        case RODBUS_PARAM_ERROR_OK: return "ok";
        case RODBUS_PARAM_ERROR_NO_SUPPORT: return "no_support";
        case RODBUS_PARAM_ERROR_NULL_PARAMETER: return "null_parameter";
        case RODBUS_PARAM_ERROR_LOGGING_ALREADY_CONFIGURED: return "logging_already_configured";
        case RODBUS_PARAM_ERROR_RUNTIME_CREATION_FAILURE: return "runtime_creation_failure";
        case RODBUS_PARAM_ERROR_RUNTIME_DESTROYED: return "runtime_destroyed";
        case RODBUS_PARAM_ERROR_RUNTIME_CANNOT_BLOCK_WITHIN_ASYNC: return "runtime_cannot_block_within_async";
        case RODBUS_PARAM_ERROR_INVALID_IP_ADDRESS: return "invalid_ip_address";
        case RODBUS_PARAM_ERROR_INVALID_RANGE: return "invalid_range";
        case RODBUS_PARAM_ERROR_INVALID_REQUEST: return "invalid_request";
        case RODBUS_PARAM_ERROR_INVALID_INDEX: return "invalid_index";
        case RODBUS_PARAM_ERROR_SERVER_BIND_ERROR: return "server_bind_error";
        case RODBUS_PARAM_ERROR_INVALID_UNIT_ID: return "invalid_unit_id";
        case RODBUS_PARAM_ERROR_INVALID_PEER_CERTIFICATE: return "invalid_peer_certificate";
        case RODBUS_PARAM_ERROR_INVALID_LOCAL_CERTIFICATE: return "invalid_local_certificate";
        case RODBUS_PARAM_ERROR_INVALID_PRIVATE_KEY: return "invalid_private_key";
        case RODBUS_PARAM_ERROR_INVALID_DNS_NAME: return "invalid_dns_name";
        case RODBUS_PARAM_ERROR_BAD_TLS_CONFIG: return "bad_tls_config";
        case RODBUS_PARAM_ERROR_SHUTDOWN: return "shutdown";
        case RODBUS_PARAM_ERROR_INVALID_UTF8: return "invalid_utf8";
        default: return "unknown param_error value";
    }
}
 
 
typedef enum rodbus_nothing_t
{
    RODBUS_NOTHING_NOTHING = 0,
} rodbus_nothing_t;
 
static const char* rodbus_nothing_to_string(rodbus_nothing_t value)
{
    switch (value)
    {
        case RODBUS_NOTHING_NOTHING: return "nothing";
        default: return "unknown nothing value";
    }
}
 
typedef enum rodbus_app_decode_level_t
{
    RODBUS_APP_DECODE_LEVEL_NOTHING = 0,
    RODBUS_APP_DECODE_LEVEL_FUNCTION_CODE = 1,
    RODBUS_APP_DECODE_LEVEL_DATA_HEADERS = 2,
    RODBUS_APP_DECODE_LEVEL_DATA_VALUES = 3,
} rodbus_app_decode_level_t;
 
static const char* rodbus_app_decode_level_to_string(rodbus_app_decode_level_t value)
{
    switch (value)
    {
        case RODBUS_APP_DECODE_LEVEL_NOTHING: return "nothing";
        case RODBUS_APP_DECODE_LEVEL_FUNCTION_CODE: return "function_code";
        case RODBUS_APP_DECODE_LEVEL_DATA_HEADERS: return "data_headers";
        case RODBUS_APP_DECODE_LEVEL_DATA_VALUES: return "data_values";
        default: return "unknown app_decode_level value";
    }
}
 
typedef enum rodbus_frame_decode_level_t
{
    RODBUS_FRAME_DECODE_LEVEL_NOTHING = 0,
    RODBUS_FRAME_DECODE_LEVEL_HEADER = 1,
    RODBUS_FRAME_DECODE_LEVEL_PAYLOAD = 2,
} rodbus_frame_decode_level_t;
 
static const char* rodbus_frame_decode_level_to_string(rodbus_frame_decode_level_t value)
{
    switch (value)
    {
        case RODBUS_FRAME_DECODE_LEVEL_NOTHING: return "nothing";
        case RODBUS_FRAME_DECODE_LEVEL_HEADER: return "header";
        case RODBUS_FRAME_DECODE_LEVEL_PAYLOAD: return "payload";
        default: return "unknown frame_decode_level value";
    }
}
 
typedef enum rodbus_phys_decode_level_t
{
    RODBUS_PHYS_DECODE_LEVEL_NOTHING = 0,
    RODBUS_PHYS_DECODE_LEVEL_LENGTH = 1,
    RODBUS_PHYS_DECODE_LEVEL_DATA = 2,
} rodbus_phys_decode_level_t;
 
static const char* rodbus_phys_decode_level_to_string(rodbus_phys_decode_level_t value)
{
    switch (value)
    {
        case RODBUS_PHYS_DECODE_LEVEL_NOTHING: return "nothing";
        case RODBUS_PHYS_DECODE_LEVEL_LENGTH: return "length";
        case RODBUS_PHYS_DECODE_LEVEL_DATA: return "data";
        default: return "unknown phys_decode_level value";
    }
}
 
typedef struct rodbus_decode_level_t rodbus_decode_level_t;
 
typedef struct rodbus_decode_level_t
{
    rodbus_app_decode_level_t app;
    rodbus_frame_decode_level_t frame;
    rodbus_phys_decode_level_t physical;
} rodbus_decode_level_t;
 
static rodbus_decode_level_t rodbus_decode_level_build(rodbus_app_decode_level_t app, rodbus_frame_decode_level_t frame, rodbus_phys_decode_level_t physical)
{
    rodbus_decode_level_t _return_value = {
        app,
        frame,
        physical
    };
    return _return_value;
}
 
static rodbus_decode_level_t rodbus_decode_level_nothing()
{
    rodbus_decode_level_t _return_value = {
        RODBUS_APP_DECODE_LEVEL_NOTHING,
        RODBUS_FRAME_DECODE_LEVEL_NOTHING,
        RODBUS_PHYS_DECODE_LEVEL_NOTHING
    };
    return _return_value;
}
 
 
typedef struct rodbus_bit_value_t rodbus_bit_value_t;
 
typedef struct rodbus_bit_value_t
{
    uint16_t index;
    bool value;
} rodbus_bit_value_t;
 
static rodbus_bit_value_t rodbus_bit_value_init(uint16_t index, bool value)
{
    rodbus_bit_value_t _return_value = {
        index,
        value
    };
    return _return_value;
}
 
 
typedef struct rodbus_register_value_t rodbus_register_value_t;
 
typedef struct rodbus_register_value_t
{
    uint16_t index;
    uint16_t value;
} rodbus_register_value_t;
 
static rodbus_register_value_t rodbus_register_value_init(uint16_t index, uint16_t value)
{
    rodbus_register_value_t _return_value = {
        index,
        value
    };
    return _return_value;
}
 
 
typedef struct rodbus_runtime_t rodbus_runtime_t;
 
typedef struct rodbus_runtime_config_t rodbus_runtime_config_t;
 
typedef struct rodbus_runtime_config_t
{
    uint16_t num_core_threads;
} rodbus_runtime_config_t;
 
static rodbus_runtime_config_t rodbus_runtime_config_init()
{
    rodbus_runtime_config_t _return_value = {
        0
    };
    return _return_value;
}
 
 
rodbus_param_error_t rodbus_runtime_create(rodbus_runtime_config_t config, rodbus_runtime_t** out);
 
void rodbus_runtime_destroy(rodbus_runtime_t* instance);
 
void rodbus_runtime_set_shutdown_timeout(rodbus_runtime_t* instance, uint64_t timeout);
 
 
typedef enum rodbus_request_error_t
{
    RODBUS_REQUEST_ERROR_OK = 0,
    RODBUS_REQUEST_ERROR_SHUTDOWN = 1,
    RODBUS_REQUEST_ERROR_NO_CONNECTION = 2,
    RODBUS_REQUEST_ERROR_RESPONSE_TIMEOUT = 3,
    RODBUS_REQUEST_ERROR_BAD_REQUEST = 4,
    RODBUS_REQUEST_ERROR_BAD_RESPONSE = 5,
    RODBUS_REQUEST_ERROR_IO_ERROR = 6,
    RODBUS_REQUEST_ERROR_BAD_FRAMING = 7,
    RODBUS_REQUEST_ERROR_INTERNAL_ERROR = 8,
    RODBUS_REQUEST_ERROR_BAD_ARGUMENT = 9,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 10,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS = 11,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE = 12,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_SERVER_DEVICE_FAILURE = 13,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_ACKNOWLEDGE = 14,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_SERVER_DEVICE_BUSY = 15,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_MEMORY_PARITY_ERROR = 16,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_GATEWAY_PATH_UNAVAILABLE = 17,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 18,
    RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_UNKNOWN = 19,
} rodbus_request_error_t;
 
static const char* rodbus_request_error_to_string(rodbus_request_error_t value)
{
    switch (value)
    {
        case RODBUS_REQUEST_ERROR_OK: return "ok";
        case RODBUS_REQUEST_ERROR_SHUTDOWN: return "shutdown";
        case RODBUS_REQUEST_ERROR_NO_CONNECTION: return "no_connection";
        case RODBUS_REQUEST_ERROR_RESPONSE_TIMEOUT: return "response_timeout";
        case RODBUS_REQUEST_ERROR_BAD_REQUEST: return "bad_request";
        case RODBUS_REQUEST_ERROR_BAD_RESPONSE: return "bad_response";
        case RODBUS_REQUEST_ERROR_IO_ERROR: return "io_error";
        case RODBUS_REQUEST_ERROR_BAD_FRAMING: return "bad_framing";
        case RODBUS_REQUEST_ERROR_INTERNAL_ERROR: return "internal_error";
        case RODBUS_REQUEST_ERROR_BAD_ARGUMENT: return "bad_argument";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_ILLEGAL_FUNCTION: return "modbus_exception_illegal_function";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS: return "modbus_exception_illegal_data_address";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE: return "modbus_exception_illegal_data_value";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_SERVER_DEVICE_FAILURE: return "modbus_exception_server_device_failure";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_ACKNOWLEDGE: return "modbus_exception_acknowledge";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_SERVER_DEVICE_BUSY: return "modbus_exception_server_device_busy";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_MEMORY_PARITY_ERROR: return "modbus_exception_memory_parity_error";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_GATEWAY_PATH_UNAVAILABLE: return "modbus_exception_gateway_path_unavailable";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND: return "modbus_exception_gateway_target_device_failed_to_respond";
        case RODBUS_REQUEST_ERROR_MODBUS_EXCEPTION_UNKNOWN: return "modbus_exception_unknown";
        default: return "unknown request_error value";
    }
}
 
 
typedef struct rodbus_address_range_t rodbus_address_range_t;
 
typedef struct rodbus_address_range_t
{
    uint16_t start;
    uint16_t count;
} rodbus_address_range_t;
 
static rodbus_address_range_t rodbus_address_range_init(uint16_t start, uint16_t count)
{
    rodbus_address_range_t _return_value = {
        start,
        count
    };
    return _return_value;
}
 
 
typedef struct rodbus_request_param_t rodbus_request_param_t;
 
typedef struct rodbus_request_param_t
{
    uint8_t unit_id;
    uint64_t timeout;
} rodbus_request_param_t;
 
static rodbus_request_param_t rodbus_request_param_init(uint8_t unit_id, uint64_t timeout)
{
    rodbus_request_param_t _return_value = {
        unit_id,
        timeout
    };
    return _return_value;
}
 
 
typedef struct rodbus_bit_value_iterator_t rodbus_bit_value_iterator_t;
 
rodbus_bit_value_t* rodbus_bit_value_iterator_next(rodbus_bit_value_iterator_t* iter);
 
 
typedef struct rodbus_register_value_iterator_t rodbus_register_value_iterator_t;
 
rodbus_register_value_t* rodbus_register_value_iterator_next(rodbus_register_value_iterator_t* iter);
 
 
typedef enum rodbus_modbus_exception_t
{
    RODBUS_MODBUS_EXCEPTION_ILLEGAL_FUNCTION = 1,
    RODBUS_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS = 2,
    RODBUS_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE = 3,
    RODBUS_MODBUS_EXCEPTION_SERVER_DEVICE_FAILURE = 4,
    RODBUS_MODBUS_EXCEPTION_ACKNOWLEDGE = 5,
    RODBUS_MODBUS_EXCEPTION_SERVER_DEVICE_BUSY = 6,
    RODBUS_MODBUS_EXCEPTION_MEMORY_PARITY_ERROR = 8,
    RODBUS_MODBUS_EXCEPTION_GATEWAY_PATH_UNAVAILABLE = 10,
    RODBUS_MODBUS_EXCEPTION_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 11,
    RODBUS_MODBUS_EXCEPTION_UNKNOWN = 255,
} rodbus_modbus_exception_t;
 
static const char* rodbus_modbus_exception_to_string(rodbus_modbus_exception_t value)
{
    switch (value)
    {
        case RODBUS_MODBUS_EXCEPTION_ILLEGAL_FUNCTION: return "illegal_function";
        case RODBUS_MODBUS_EXCEPTION_ILLEGAL_DATA_ADDRESS: return "illegal_data_address";
        case RODBUS_MODBUS_EXCEPTION_ILLEGAL_DATA_VALUE: return "illegal_data_value";
        case RODBUS_MODBUS_EXCEPTION_SERVER_DEVICE_FAILURE: return "server_device_failure";
        case RODBUS_MODBUS_EXCEPTION_ACKNOWLEDGE: return "acknowledge";
        case RODBUS_MODBUS_EXCEPTION_SERVER_DEVICE_BUSY: return "server_device_busy";
        case RODBUS_MODBUS_EXCEPTION_MEMORY_PARITY_ERROR: return "memory_parity_error";
        case RODBUS_MODBUS_EXCEPTION_GATEWAY_PATH_UNAVAILABLE: return "gateway_path_unavailable";
        case RODBUS_MODBUS_EXCEPTION_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND: return "gateway_target_device_failed_to_respond";
        case RODBUS_MODBUS_EXCEPTION_UNKNOWN: return "unknown";
        default: return "unknown modbus_exception value";
    }
}
 
typedef enum rodbus_data_bits_t
{
    RODBUS_DATA_BITS_FIVE = 0,
    RODBUS_DATA_BITS_SIX = 1,
    RODBUS_DATA_BITS_SEVEN = 2,
    RODBUS_DATA_BITS_EIGHT = 3,
} rodbus_data_bits_t;
 
static const char* rodbus_data_bits_to_string(rodbus_data_bits_t value)
{
    switch (value)
    {
        case RODBUS_DATA_BITS_FIVE: return "five";
        case RODBUS_DATA_BITS_SIX: return "six";
        case RODBUS_DATA_BITS_SEVEN: return "seven";
        case RODBUS_DATA_BITS_EIGHT: return "eight";
        default: return "unknown data_bits value";
    }
}
 
typedef enum rodbus_flow_control_t
{
    RODBUS_FLOW_CONTROL_NONE = 0,
    RODBUS_FLOW_CONTROL_SOFTWARE = 1,
    RODBUS_FLOW_CONTROL_HARDWARE = 2,
} rodbus_flow_control_t;
 
static const char* rodbus_flow_control_to_string(rodbus_flow_control_t value)
{
    switch (value)
    {
        case RODBUS_FLOW_CONTROL_NONE: return "none";
        case RODBUS_FLOW_CONTROL_SOFTWARE: return "software";
        case RODBUS_FLOW_CONTROL_HARDWARE: return "hardware";
        default: return "unknown flow_control value";
    }
}
 
typedef enum rodbus_parity_t
{
    RODBUS_PARITY_NONE = 0,
    RODBUS_PARITY_ODD = 1,
    RODBUS_PARITY_EVEN = 2,
} rodbus_parity_t;
 
static const char* rodbus_parity_to_string(rodbus_parity_t value)
{
    switch (value)
    {
        case RODBUS_PARITY_NONE: return "none";
        case RODBUS_PARITY_ODD: return "odd";
        case RODBUS_PARITY_EVEN: return "even";
        default: return "unknown parity value";
    }
}
 
typedef enum rodbus_stop_bits_t
{
    RODBUS_STOP_BITS_ONE = 0,
    RODBUS_STOP_BITS_TWO = 1,
} rodbus_stop_bits_t;
 
static const char* rodbus_stop_bits_to_string(rodbus_stop_bits_t value)
{
    switch (value)
    {
        case RODBUS_STOP_BITS_ONE: return "one";
        case RODBUS_STOP_BITS_TWO: return "two";
        default: return "unknown stop_bits value";
    }
}
 
typedef struct rodbus_serial_port_settings_t rodbus_serial_port_settings_t;
 
typedef struct rodbus_serial_port_settings_t
{
    uint32_t baud_rate;
    rodbus_data_bits_t data_bits;
    rodbus_flow_control_t flow_control;
    rodbus_parity_t parity;
    rodbus_stop_bits_t stop_bits;
} rodbus_serial_port_settings_t;
 
static rodbus_serial_port_settings_t rodbus_serial_port_settings_init()
{
    rodbus_serial_port_settings_t _return_value = {
        9600,
        RODBUS_DATA_BITS_EIGHT,
        RODBUS_FLOW_CONTROL_NONE,
        RODBUS_PARITY_NONE,
        RODBUS_STOP_BITS_ONE
    };
    return _return_value;
}
 
 
typedef enum rodbus_min_tls_version_t
{
    RODBUS_MIN_TLS_VERSION_V12 = 0,
    RODBUS_MIN_TLS_VERSION_V13 = 1,
} rodbus_min_tls_version_t;
 
static const char* rodbus_min_tls_version_to_string(rodbus_min_tls_version_t value)
{
    switch (value)
    {
        case RODBUS_MIN_TLS_VERSION_V12: return "v12";
        case RODBUS_MIN_TLS_VERSION_V13: return "v13";
        default: return "unknown min_tls_version value";
    }
}
 
typedef enum rodbus_certificate_mode_t
{
    RODBUS_CERTIFICATE_MODE_AUTHORITY_BASED = 0,
    RODBUS_CERTIFICATE_MODE_SELF_SIGNED = 1,
} rodbus_certificate_mode_t;
 
static const char* rodbus_certificate_mode_to_string(rodbus_certificate_mode_t value)
{
    switch (value)
    {
        case RODBUS_CERTIFICATE_MODE_AUTHORITY_BASED: return "authority_based";
        case RODBUS_CERTIFICATE_MODE_SELF_SIGNED: return "self_signed";
        default: return "unknown certificate_mode value";
    }
}
 
typedef struct rodbus_retry_strategy_t rodbus_retry_strategy_t;
 
typedef struct rodbus_retry_strategy_t
{
    uint64_t min_delay;
    uint64_t max_delay;
} rodbus_retry_strategy_t;
 
static rodbus_retry_strategy_t rodbus_retry_strategy_init()
{
    rodbus_retry_strategy_t _return_value = {
        1000,
        10000
    };
    return _return_value;
}
 
 
typedef enum rodbus_log_level_t
{
    RODBUS_LOG_LEVEL_ERROR = 0,
    RODBUS_LOG_LEVEL_WARN = 1,
    RODBUS_LOG_LEVEL_INFO = 2,
    RODBUS_LOG_LEVEL_DEBUG = 3,
    RODBUS_LOG_LEVEL_TRACE = 4,
} rodbus_log_level_t;
 
static const char* rodbus_log_level_to_string(rodbus_log_level_t value)
{
    switch (value)
    {
        case RODBUS_LOG_LEVEL_ERROR: return "error";
        case RODBUS_LOG_LEVEL_WARN: return "warn";
        case RODBUS_LOG_LEVEL_INFO: return "info";
        case RODBUS_LOG_LEVEL_DEBUG: return "debug";
        case RODBUS_LOG_LEVEL_TRACE: return "trace";
        default: return "unknown log_level value";
    }
}
 
typedef struct rodbus_logging_config_t rodbus_logging_config_t;
 
typedef enum rodbus_log_output_format_t
{
    RODBUS_LOG_OUTPUT_FORMAT_TEXT = 0,
    RODBUS_LOG_OUTPUT_FORMAT_JSON = 1,
} rodbus_log_output_format_t;
 
static const char* rodbus_log_output_format_to_string(rodbus_log_output_format_t value)
{
    switch (value)
    {
        case RODBUS_LOG_OUTPUT_FORMAT_TEXT: return "text";
        case RODBUS_LOG_OUTPUT_FORMAT_JSON: return "json";
        default: return "unknown log_output_format value";
    }
}
 
typedef enum rodbus_time_format_t
{
    RODBUS_TIME_FORMAT_NONE = 0,
    RODBUS_TIME_FORMAT_RFC_3339 = 1,
    RODBUS_TIME_FORMAT_SYSTEM = 2,
} rodbus_time_format_t;
 
static const char* rodbus_time_format_to_string(rodbus_time_format_t value)
{
    switch (value)
    {
        case RODBUS_TIME_FORMAT_NONE: return "none";
        case RODBUS_TIME_FORMAT_RFC_3339: return "rfc_3339";
        case RODBUS_TIME_FORMAT_SYSTEM: return "system";
        default: return "unknown time_format value";
    }
}
 
typedef struct rodbus_logging_config_t
{
    rodbus_log_level_t level;
    rodbus_log_output_format_t output_format;
    rodbus_time_format_t time_format;
    bool print_level;
    bool print_module_info;
} rodbus_logging_config_t;
 
static rodbus_logging_config_t rodbus_logging_config_init()
{
    rodbus_logging_config_t _return_value = {
        RODBUS_LOG_LEVEL_INFO,
        RODBUS_LOG_OUTPUT_FORMAT_TEXT,
        RODBUS_TIME_FORMAT_SYSTEM,
        true,
        false
    };
    return _return_value;
}
 
 
typedef struct rodbus_logger_t
{
    
    void (*on_message)(rodbus_log_level_t, const char*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} rodbus_logger_t;
 
rodbus_param_error_t rodbus_configure_logging(rodbus_logging_config_t config, rodbus_logger_t logger);
 
 
typedef struct rodbus_client_channel_t rodbus_client_channel_t;
 
typedef struct rodbus_tls_client_config_t rodbus_tls_client_config_t;
 
typedef struct rodbus_tls_client_config_t
{
    const char* dns_name;
    const char* peer_cert_path;
    const char* local_cert_path;
    const char* private_key_path;
    const char* password;
    rodbus_min_tls_version_t min_tls_version;
    rodbus_certificate_mode_t certificate_mode;
    bool allow_server_name_wildcard;
} rodbus_tls_client_config_t;
 
static rodbus_tls_client_config_t rodbus_tls_client_config_init(const char* dns_name, const char* peer_cert_path, const char* local_cert_path, const char* private_key_path, const char* password)
{
    rodbus_tls_client_config_t _return_value = {
        dns_name,
        peer_cert_path,
        local_cert_path,
        private_key_path,
        password,
        RODBUS_MIN_TLS_VERSION_V12,
        RODBUS_CERTIFICATE_MODE_AUTHORITY_BASED,
        false
    };
    return _return_value;
}
 
 
typedef enum rodbus_client_state_t
{
    RODBUS_CLIENT_STATE_DISABLED = 0,
    RODBUS_CLIENT_STATE_CONNECTING = 1,
    RODBUS_CLIENT_STATE_CONNECTED = 2,
    RODBUS_CLIENT_STATE_WAIT_AFTER_FAILED_CONNECT = 3,
    RODBUS_CLIENT_STATE_WAIT_AFTER_DISCONNECT = 4,
    RODBUS_CLIENT_STATE_SHUTDOWN = 5,
} rodbus_client_state_t;
 
static const char* rodbus_client_state_to_string(rodbus_client_state_t value)
{
    switch (value)
    {
        case RODBUS_CLIENT_STATE_DISABLED: return "disabled";
        case RODBUS_CLIENT_STATE_CONNECTING: return "connecting";
        case RODBUS_CLIENT_STATE_CONNECTED: return "connected";
        case RODBUS_CLIENT_STATE_WAIT_AFTER_FAILED_CONNECT: return "wait_after_failed_connect";
        case RODBUS_CLIENT_STATE_WAIT_AFTER_DISCONNECT: return "wait_after_disconnect";
        case RODBUS_CLIENT_STATE_SHUTDOWN: return "shutdown";
        default: return "unknown client_state value";
    }
}
 
typedef struct rodbus_client_state_listener_t
{
    
    void (*on_change)(rodbus_client_state_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} rodbus_client_state_listener_t;
 
typedef enum rodbus_port_state_t
{
    RODBUS_PORT_STATE_DISABLED = 0,
    RODBUS_PORT_STATE_WAIT = 1,
    RODBUS_PORT_STATE_OPEN = 2,
    RODBUS_PORT_STATE_SHUTDOWN = 3,
} rodbus_port_state_t;
 
static const char* rodbus_port_state_to_string(rodbus_port_state_t value)
{
    switch (value)
    {
        case RODBUS_PORT_STATE_DISABLED: return "disabled";
        case RODBUS_PORT_STATE_WAIT: return "wait";
        case RODBUS_PORT_STATE_OPEN: return "open";
        case RODBUS_PORT_STATE_SHUTDOWN: return "shutdown";
        default: return "unknown port_state value";
    }
}
 
typedef struct rodbus_port_state_listener_t
{
    
    void (*on_change)(rodbus_port_state_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} rodbus_port_state_listener_t;
 
rodbus_param_error_t rodbus_client_channel_create_tcp(rodbus_runtime_t* runtime, const char* host, uint16_t port, uint16_t max_queued_requests, rodbus_retry_strategy_t retry_strategy, rodbus_decode_level_t decode_level, rodbus_client_state_listener_t listener, rodbus_client_channel_t** out);
 
rodbus_param_error_t rodbus_client_channel_create_rtu(rodbus_runtime_t* runtime, const char* path, rodbus_serial_port_settings_t serial_params, uint16_t max_queued_requests, rodbus_retry_strategy_t retry_strategy, rodbus_decode_level_t decode_level, rodbus_port_state_listener_t listener, rodbus_client_channel_t** out);
 
rodbus_param_error_t rodbus_client_channel_create_tls(rodbus_runtime_t* runtime, const char* host, uint16_t port, uint16_t max_queued_requests, rodbus_retry_strategy_t retry_strategy, rodbus_tls_client_config_t tls_config, rodbus_decode_level_t decode_level, rodbus_client_state_listener_t listener, rodbus_client_channel_t** out);
 
void rodbus_client_channel_destroy(rodbus_client_channel_t* instance);
 
typedef struct rodbus_bit_read_callback_t
{
    
    void (*on_complete)(rodbus_bit_value_iterator_t*, void*);
    
    void (*on_failure)(rodbus_request_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} rodbus_bit_read_callback_t;
 
typedef struct rodbus_register_read_callback_t
{
    
    void (*on_complete)(rodbus_register_value_iterator_t*, void*);
    
    void (*on_failure)(rodbus_request_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} rodbus_register_read_callback_t;
 
typedef struct rodbus_write_callback_t
{
    
    void (*on_complete)(rodbus_nothing_t, void*);
    
    void (*on_failure)(rodbus_request_error_t, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} rodbus_write_callback_t;
 
rodbus_param_error_t rodbus_client_channel_read_coils(rodbus_client_channel_t* instance, rodbus_request_param_t param, rodbus_address_range_t range, rodbus_bit_read_callback_t callback);
 
rodbus_param_error_t rodbus_client_channel_read_discrete_inputs(rodbus_client_channel_t* instance, rodbus_request_param_t param, rodbus_address_range_t range, rodbus_bit_read_callback_t callback);
 
rodbus_param_error_t rodbus_client_channel_read_holding_registers(rodbus_client_channel_t* instance, rodbus_request_param_t param, rodbus_address_range_t range, rodbus_register_read_callback_t callback);
 
rodbus_param_error_t rodbus_client_channel_read_input_registers(rodbus_client_channel_t* instance, rodbus_request_param_t param, rodbus_address_range_t range, rodbus_register_read_callback_t callback);
 
rodbus_param_error_t rodbus_client_channel_write_single_coil(rodbus_client_channel_t* instance, rodbus_request_param_t param, rodbus_bit_value_t value, rodbus_write_callback_t callback);
 
rodbus_param_error_t rodbus_client_channel_write_single_register(rodbus_client_channel_t* instance, rodbus_request_param_t param, rodbus_register_value_t value, rodbus_write_callback_t callback);
 
typedef struct rodbus_bit_list_t rodbus_bit_list_t;
 
rodbus_bit_list_t* rodbus_bit_list_create(uint32_t reserve_size);
 
void rodbus_bit_list_destroy(rodbus_bit_list_t* instance);
 
void rodbus_bit_list_add(rodbus_bit_list_t* instance, bool value);
 
 
rodbus_param_error_t rodbus_client_channel_write_multiple_coils(rodbus_client_channel_t* instance, rodbus_request_param_t param, uint16_t start, rodbus_bit_list_t* items, rodbus_write_callback_t callback);
 
typedef struct rodbus_register_list_t rodbus_register_list_t;
 
rodbus_register_list_t* rodbus_register_list_create(uint32_t reserve_size);
 
void rodbus_register_list_destroy(rodbus_register_list_t* instance);
 
void rodbus_register_list_add(rodbus_register_list_t* instance, uint16_t value);
 
 
rodbus_param_error_t rodbus_client_channel_write_multiple_registers(rodbus_client_channel_t* instance, rodbus_request_param_t param, uint16_t start, rodbus_register_list_t* items, rodbus_write_callback_t callback);
 
rodbus_param_error_t rodbus_client_channel_set_decode_level(rodbus_client_channel_t* instance, rodbus_decode_level_t level);
 
rodbus_param_error_t rodbus_client_channel_enable(rodbus_client_channel_t* instance);
 
rodbus_param_error_t rodbus_client_channel_disable(rodbus_client_channel_t* instance);
 
 
typedef struct rodbus_database_t rodbus_database_t;
 
bool rodbus_database_add_coil(rodbus_database_t* instance, uint16_t index, bool value);
 
bool rodbus_database_add_discrete_input(rodbus_database_t* instance, uint16_t index, bool value);
 
bool rodbus_database_add_holding_register(rodbus_database_t* instance, uint16_t index, uint16_t value);
 
bool rodbus_database_add_input_register(rodbus_database_t* instance, uint16_t index, uint16_t value);
 
rodbus_param_error_t rodbus_database_get_coil(rodbus_database_t* instance, uint16_t index, bool* out);
 
rodbus_param_error_t rodbus_database_get_discrete_input(rodbus_database_t* instance, uint16_t index, bool* out);
 
rodbus_param_error_t rodbus_database_get_holding_register(rodbus_database_t* instance, uint16_t index, uint16_t* out);
 
rodbus_param_error_t rodbus_database_get_input_register(rodbus_database_t* instance, uint16_t index, uint16_t* out);
 
bool rodbus_database_update_coil(rodbus_database_t* instance, uint16_t index, bool value);
 
bool rodbus_database_update_discrete_input(rodbus_database_t* instance, uint16_t index, bool value);
 
bool rodbus_database_update_holding_register(rodbus_database_t* instance, uint16_t index, uint16_t value);
 
bool rodbus_database_update_input_register(rodbus_database_t* instance, uint16_t index, uint16_t value);
 
bool rodbus_database_delete_coil(rodbus_database_t* instance, uint16_t index);
 
bool rodbus_database_delete_discrete_input(rodbus_database_t* instance, uint16_t index);
 
bool rodbus_database_delete_holding_register(rodbus_database_t* instance, uint16_t index);
 
bool rodbus_database_delete_input_register(rodbus_database_t* instance, uint16_t index);
 
 
typedef struct rodbus_database_callback_t
{
    
    void (*callback)(rodbus_database_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} rodbus_database_callback_t;
 
typedef struct rodbus_write_result_t rodbus_write_result_t;
 
typedef struct rodbus_write_result_t
{
    bool success;
    rodbus_modbus_exception_t exception;
    uint8_t raw_exception;
} rodbus_write_result_t;
 
static rodbus_write_result_t rodbus_write_result_success_init()
{
    rodbus_write_result_t _return_value = {
        true,
        RODBUS_MODBUS_EXCEPTION_UNKNOWN,
        0
    };
    return _return_value;
}
 
static rodbus_write_result_t rodbus_write_result_exception_init(rodbus_modbus_exception_t exception)
{
    rodbus_write_result_t _return_value = {
        false,
        exception,
        0
    };
    return _return_value;
}
 
static rodbus_write_result_t rodbus_write_result_raw_exception_init(uint8_t raw_exception)
{
    rodbus_write_result_t _return_value = {
        false,
        RODBUS_MODBUS_EXCEPTION_UNKNOWN,
        raw_exception
    };
    return _return_value;
}
 
 
typedef struct rodbus_write_handler_t
{
    
    rodbus_write_result_t (*write_single_coil)(uint16_t, bool, rodbus_database_t*, void*);
    
    rodbus_write_result_t (*write_single_register)(uint16_t, uint16_t, rodbus_database_t*, void*);
    
    rodbus_write_result_t (*write_multiple_coils)(uint16_t, rodbus_bit_value_iterator_t*, rodbus_database_t*, void*);
    
    rodbus_write_result_t (*write_multiple_registers)(uint16_t, rodbus_register_value_iterator_t*, rodbus_database_t*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} rodbus_write_handler_t;
 
typedef struct rodbus_device_map_t rodbus_device_map_t;
 
rodbus_device_map_t* rodbus_device_map_create();
 
void rodbus_device_map_destroy(rodbus_device_map_t* instance);
 
bool rodbus_device_map_add_endpoint(rodbus_device_map_t* instance, uint8_t unit_id, rodbus_write_handler_t handler, rodbus_database_callback_t configure);
 
 
typedef struct rodbus_tls_server_config_t rodbus_tls_server_config_t;
 
typedef struct rodbus_tls_server_config_t
{
    const char* peer_cert_path;
    const char* local_cert_path;
    const char* private_key_path;
    const char* password;
    rodbus_min_tls_version_t min_tls_version;
    rodbus_certificate_mode_t certificate_mode;
} rodbus_tls_server_config_t;
 
static rodbus_tls_server_config_t rodbus_tls_server_config_init(const char* peer_cert_path, const char* local_cert_path, const char* private_key_path, const char* password)
{
    rodbus_tls_server_config_t _return_value = {
        peer_cert_path,
        local_cert_path,
        private_key_path,
        password,
        RODBUS_MIN_TLS_VERSION_V12,
        RODBUS_CERTIFICATE_MODE_AUTHORITY_BASED
    };
    return _return_value;
}
 
 
typedef enum rodbus_authorization_t
{
    RODBUS_AUTHORIZATION_ALLOW = 0,
    RODBUS_AUTHORIZATION_DENY = 1,
} rodbus_authorization_t;
 
static const char* rodbus_authorization_to_string(rodbus_authorization_t value)
{
    switch (value)
    {
        case RODBUS_AUTHORIZATION_ALLOW: return "allow";
        case RODBUS_AUTHORIZATION_DENY: return "deny";
        default: return "unknown authorization value";
    }
}
 
typedef struct rodbus_authorization_handler_t
{
    
    rodbus_authorization_t (*read_coils)(uint8_t, rodbus_address_range_t, const char*, void*);
    
    rodbus_authorization_t (*read_discrete_inputs)(uint8_t, rodbus_address_range_t, const char*, void*);
    
    rodbus_authorization_t (*read_holding_registers)(uint8_t, rodbus_address_range_t, const char*, void*);
    
    rodbus_authorization_t (*read_input_registers)(uint8_t, rodbus_address_range_t, const char*, void*);
    
    rodbus_authorization_t (*write_single_coil)(uint8_t, uint16_t, const char*, void*);
    
    rodbus_authorization_t (*write_single_register)(uint8_t, uint16_t, const char*, void*);
    
    rodbus_authorization_t (*write_multiple_coils)(uint8_t, rodbus_address_range_t, const char*, void*);
    
    rodbus_authorization_t (*write_multiple_registers)(uint8_t, rodbus_address_range_t, const char*, void*);
    void (*on_destroy)(void* arg);
    void* ctx;
} rodbus_authorization_handler_t;
 
typedef struct rodbus_address_filter_t rodbus_address_filter_t;
 
rodbus_address_filter_t* rodbus_address_filter_any();
 
rodbus_param_error_t rodbus_address_filter_create(const char* address, rodbus_address_filter_t** out);
 
rodbus_param_error_t rodbus_address_filter_add(rodbus_address_filter_t* instance, const char* address);
 
void rodbus_address_filter_destroy(rodbus_address_filter_t* instance);
 
 
typedef struct rodbus_server_t rodbus_server_t;
 
rodbus_param_error_t rodbus_server_create_tcp(rodbus_runtime_t* runtime, const char* address, uint16_t port, rodbus_address_filter_t* filter, uint16_t max_sessions, rodbus_device_map_t* endpoints, rodbus_decode_level_t decode_level, rodbus_server_t** out);
 
rodbus_param_error_t rodbus_server_create_rtu(rodbus_runtime_t* runtime, const char* path, rodbus_serial_port_settings_t serial_params, rodbus_retry_strategy_t retry, rodbus_device_map_t* endpoints, rodbus_decode_level_t decode_level, rodbus_server_t** out);
 
rodbus_param_error_t rodbus_server_create_tls_with_authz(rodbus_runtime_t* runtime, const char* address, uint16_t port, rodbus_address_filter_t* filter, uint16_t max_sessions, rodbus_device_map_t* endpoints, rodbus_tls_server_config_t tls_config, rodbus_authorization_handler_t authorization_handler, rodbus_decode_level_t decode_level, rodbus_server_t** out);
 
rodbus_param_error_t rodbus_server_create_tls(rodbus_runtime_t* runtime, const char* address, uint16_t port, rodbus_address_filter_t* filter, uint16_t max_sessions, rodbus_device_map_t* endpoints, rodbus_tls_server_config_t tls_config, rodbus_decode_level_t decode_level, rodbus_server_t** out);
 
void rodbus_server_destroy(rodbus_server_t* instance);
 
rodbus_param_error_t rodbus_server_update_database(rodbus_server_t* instance, uint8_t unit_id, rodbus_database_callback_t transaction);
 
rodbus_param_error_t rodbus_server_set_decode_level(rodbus_server_t* instance, rodbus_decode_level_t level);
 
 
const char* rodbus_version();
 
#ifdef __cplusplus
}
#endif