rodbus.h

Go to the documentation of this file.

#ifndef RODBUS_FFI_H
#define RODBUS_FFI_H

/* Generated with cbindgen:0.14.4 */

/* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */

#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include "prelude.h"

#define MAX_READ_COILS_COUNT 2000

#define MAX_READ_REGISTERS_COUNT 125

#define MAX_WRITE_COILS_COUNT 1968

#define MAX_WRITE_REGISTERS_COUNT 123

enum Exception {
  EXCEPTION_ILLEGAL_FUNCTION = 1,
  EXCEPTION_ILLEGAL_DATA_ADDRESS = 2,
  EXCEPTION_ILLEGAL_DATA_VALUE = 3,
  EXCEPTION_SERVER_DEVICE_FAILURE = 4,
  EXCEPTION_ACKNOWLEDGE = 5,
  EXCEPTION_SERVER_DEVICE_BUSY = 6,
  EXCEPTION_MEMORY_PARITY_ERROR = 8,
  EXCEPTION_GATEWAY_PATH_UNAVAILABLE = 10,
  EXCEPTION_GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND = 11,
};
typedef uint8_t Exception;

enum Level {
  LEVEL_ERROR,
  LEVEL_WARN,
  LEVEL_INFO,
  LEVEL_DEBUG,
  LEVEL_TRACE,
};
typedef uint8_t Level;

enum Status {
  STATUS_OK,
  STATUS_SHUTDOWN,
  STATUS_NO_CONNECTION,
  STATUS_RESPONSE_TIMEOUT,
  STATUS_BAD_REQUEST,
  STATUS_BAD_RESPONSE,
  STATUS_IO_ERROR,
  STATUS_BAD_FRAMING,
  STATUS_EXCEPTION,
  STATUS_INTERNAL_ERROR,
};
typedef uint8_t Status;

typedef struct BitIterator BitIterator;

typedef struct Handler Handler;

typedef struct RegisterIterator RegisterIterator;

typedef struct ServerHandle ServerHandle;

typedef struct Updater Updater;

typedef struct Session {
  Runtime *runtime;
  Channel *channel;
  uint8_t unit_id;
  uint32_t timeout_ms;
} Session;

typedef bool (*WriteSingleCallback_bool)(bool, uint16_t, void*);

typedef bool (*WriteSingleCallback_u16)(uint16_t, uint16_t, void*);

typedef bool (*WriteMultipleCallback_bool)(const bool*, uint16_t, uint16_t, void*);

typedef bool (*WriteMultipleCallback_u16)(const uint16_t*, uint16_t, uint16_t, void*);

typedef struct Callbacks {
  WriteSingleCallback_bool write_single_coil_cb;
  WriteSingleCallback_u16 write_single_register_cb;
  WriteMultipleCallback_bool write_multiple_coils;
  WriteMultipleCallback_u16 write_multiple_registers;
} Callbacks;

typedef struct Sizes {
  uint16_t num_coils;
  uint16_t num_discrete_inputs;
  uint16_t num_holding_registers;
  uint16_t num_input_registers;
} Sizes;

typedef struct RuntimeConfig {
  uint16_t num_core_threads;
} RuntimeConfig;

typedef struct Bit {
  bool value;
  uint16_t index;
} Bit;

typedef struct Register {
  uint16_t value;
  uint16_t index;
} Register;

typedef struct Result {
  Status status;
  uint8_t exception;
} Result;

Updater *acquire_updater(Handler *handler);

Session build_session(Runtime *runtime,
                      Channel *channel,
                      uint8_t unit_id,
                      uint32_t timeout_ms);

Callbacks create_callbacks(WriteSingleCallback_bool write_single_coil_cb,
                           WriteSingleCallback_u16 write_single_register_cb,
                           WriteMultipleCallback_bool write_multiple_coils,
                           WriteMultipleCallback_u16 write_multiple_registers);

Handler *create_handler(Runtime *runtime, Sizes sizes, Callbacks callbacks, void *user_data);

ServerHandle *create_server(Runtime *runtime,
                            const char *address,
                            uint8_t unit_id,
                            Handler *handler);

Sizes create_sizes(uint16_t num_coils,
                   uint16_t num_discrete_inputs,
                   uint16_t num_holding_registers,
                   uint16_t num_input_registers);

Channel *create_tcp_client(Runtime *runtime,
                           const char *address,
                           uint16_t max_queued_requests);

Runtime *create_threaded_runtime(const RuntimeConfig *config);

void destroy_channel(Channel *channel);

void destroy_handler(Handler *handler);

void destroy_runtime(Runtime *runtime);

void destroy_server(ServerHandle *handle);

bool get_next_bit(BitIterator *iterator, Bit *value);

bool get_next_register(RegisterIterator *iterator, Register *value);

Result read_coils(Session *session,
                  uint16_t start,
                  uint16_t count,
                  bool *output);

void read_coils_cb(Session *session,
                   uint16_t start,
                   uint16_t count,
                   void (*callback)(Result, BitIterator*, void*),
                   void *user_data);

Result read_discrete_inputs(Session *session,
                            uint16_t start,
                            uint16_t count,
                            bool *output);

void read_discrete_inputs_cb(Session *session,
                             uint16_t start,
                             uint16_t count,
                             void (*callback)(Result, BitIterator*, void*),
                             void *user_data);

Result read_holding_registers(Session *session,
                              uint16_t start,
                              uint16_t count,
                              uint16_t *output);

void read_holding_registers_cb(Session *session,
                               uint16_t start,
                               uint16_t count,
                               void (*callback)(Result, RegisterIterator*, void*),
                               void *user_data);

Result read_input_registers(Session *session,
                            uint16_t start,
                            uint16_t count,
                            uint16_t *output);

void read_input_registers_cb(Session *session,
                             uint16_t start,
                             uint16_t count,
                             void (*callback)(Result, RegisterIterator*, void*),
                             void *user_data);

void release_updater(Updater *updater);

bool set_log_callback(void (*callback)(Level level, const char *message));

void set_max_level(Level level);

bool update_coil(Updater *updater, bool value, uint16_t index);

void update_handler(Handler *handler, void *user_data, void (*callback)(Updater*, void*));

Result write_multiple_coils(Session *session, uint16_t start, const bool *values, uint16_t count);

void write_multiple_coils_cb(Session *session,
                             uint16_t start,
                             const bool *values,
                             uint16_t count,
                             void (*callback)(Result, void*),
                             void *user_data);

Result write_multiple_registers(Session *session,
                                uint16_t start,
                                const uint16_t *values,
                                uint16_t count);

void write_multiple_registers_cb(Session *session,
                                 uint16_t start,
                                 const uint16_t *values,
                                 uint16_t count,
                                 void (*callback)(Result, void*),
                                 void *user_data);

Result write_single_coil(Session *session, uint16_t index, bool value);

void write_single_coil_cb(Session *session,
                          uint16_t index,
                          bool value,
                          void (*callback)(Result, void*),
                          void *user_data);

Result write_single_register(Session *session, uint16_t index, uint16_t value);

void write_single_register_cb(Session *session,
                              uint16_t index,
                              uint16_t value,
                              void (*callback)(Result, void*),
                              void *user_data);

#endif /* RODBUS_FFI_H */