host_sync.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
 
#include "mcprotocol/serial/client.hpp"
#include "mcprotocol/serial/high_level.hpp"
#include "mcprotocol/serial/posix_serial.hpp"
#include "mcprotocol/serial/string_view_compat.hpp"
 
 
namespace mcprotocol::serial {
 
class PosixSyncClient {
 public:
  PosixSyncClient() = default;
 
  PosixSyncClient(const PosixSyncClient&) = delete;
  PosixSyncClient& operator=(const PosixSyncClient&) = delete;
 
  [[nodiscard]] Status open(
      const PosixSerialConfig& serial_config,
      const ProtocolConfig& protocol_config) noexcept;
 
  void close() noexcept;
 
  [[nodiscard]] bool is_open() const noexcept;
 
  [[nodiscard]] const ProtocolConfig& protocol_config() const noexcept;
 
  [[nodiscard]] Status read_cpu_model(CpuModelInfo& out_info) noexcept;
 
  [[nodiscard]] Status remote_run(
      RemoteOperationMode mode = RemoteOperationMode::DoNotExecuteForcibly,
      RemoteRunClearMode clear_mode = RemoteRunClearMode::DoNotClear) noexcept;
 
  [[nodiscard]] Status remote_stop() noexcept;
 
  [[nodiscard]] Status remote_pause(
      RemoteOperationMode mode = RemoteOperationMode::DoNotExecuteForcibly) noexcept;
 
  [[nodiscard]] Status remote_latch_clear() noexcept;
 
  [[nodiscard]] Status unlock_remote_password(std::string_view remote_password) noexcept;
 
  [[nodiscard]] Status lock_remote_password(std::string_view remote_password) noexcept;
 
  [[nodiscard]] Status clear_error_information() noexcept;
 
  [[nodiscard]] Status remote_reset() noexcept;
 
  [[nodiscard]] Status read_user_frame(
      const UserFrameReadRequest& request,
      UserFrameRegistrationData& out_data) noexcept;
 
  [[nodiscard]] Status write_user_frame(
      const UserFrameWriteRequest& request) noexcept;
 
  [[nodiscard]] Status delete_user_frame(
      const UserFrameDeleteRequest& request) noexcept;
 
  [[nodiscard]] Status control_global_signal(
      const GlobalSignalControlRequest& request) noexcept;
 
  [[nodiscard]] Status initialize_c24_transmission_sequence() noexcept;
 
  [[nodiscard]] Status deregister_cpu_monitoring() noexcept;
 
  [[nodiscard]] Status read_words(
      std::string_view head_device,
      std::uint16_t points,
      std::span<std::uint16_t> out_words) noexcept;
 
  [[nodiscard]] Status read_words(
      std::string_view head_device,
      std::span<std::uint16_t> out_words) noexcept;
 
  [[nodiscard]] Status read_extended_file_register_words(
      const ExtendedFileRegisterBatchReadWordsRequest& request,
      std::span<std::uint16_t> out_words) noexcept;
 
  [[nodiscard]] Status direct_read_extended_file_register_words(
      const ExtendedFileRegisterDirectBatchReadWordsRequest& request,
      std::span<std::uint16_t> out_words) noexcept;
 
  [[nodiscard]] Status read_bits(
      std::string_view head_device,
      std::uint16_t points,
      std::span<BitValue> out_bits) noexcept;
 
  [[nodiscard]] Status read_bits(
      std::string_view head_device,
      std::span<BitValue> out_bits) noexcept;
 
  [[nodiscard]] Status write_words(
      std::string_view head_device,
      std::span<const std::uint16_t> words) noexcept;
 
  [[nodiscard]] Status write_extended_file_register_words(
      const ExtendedFileRegisterBatchWriteWordsRequest& request) noexcept;
 
  [[nodiscard]] Status direct_write_extended_file_register_words(
      const ExtendedFileRegisterDirectBatchWriteWordsRequest& request) noexcept;
 
  [[nodiscard]] Status write_bits(
      std::string_view head_device,
      std::span<const BitValue> bits) noexcept;
 
  [[nodiscard]] Status random_read(
      std::span<const highlevel::RandomReadSpec> items,
      std::span<std::uint32_t> out_values) noexcept;
 
  [[nodiscard]] Status random_read(
      std::string_view device,
      std::uint32_t& out_value,
      bool double_word = false) noexcept;
 
  [[nodiscard]] Status random_write_words(
      std::span<const highlevel::RandomWriteWordSpec> items) noexcept;
 
  [[nodiscard]] Status random_write_extended_file_register_words(
      std::span<const ExtendedFileRegisterRandomWriteWordItem> items) noexcept;
 
  [[nodiscard]] Status random_write_word(
      std::string_view device,
      std::uint32_t value,
      bool double_word = false) noexcept;
 
  [[nodiscard]] Status random_write_bits(
      std::span<const highlevel::RandomWriteBitSpec> items) noexcept;
 
  [[nodiscard]] Status random_write_bit(
      std::string_view device,
      BitValue value) noexcept;
 
  [[nodiscard]] Status register_monitor(
      std::span<const highlevel::RandomReadSpec> items) noexcept;
 
  [[nodiscard]] Status register_monitor(
      std::string_view device,
      bool double_word = false) noexcept;
 
  [[nodiscard]] Status register_extended_file_register_monitor(
      const ExtendedFileRegisterMonitorRegistration& request) noexcept;
 
  [[nodiscard]] Status read_monitor(std::span<std::uint32_t> out_values) noexcept;
 
  [[nodiscard]] Status read_monitor(std::uint32_t& out_value) noexcept;
 
  [[nodiscard]] Status read_extended_file_register_monitor(
      std::span<std::uint16_t> out_words) noexcept;
 
 private:
  struct CompletionState {
    bool done = false;
    Status status {};
  };
 
  static void on_request_complete(void* user, Status status) noexcept;
  [[nodiscard]] Status run_until_complete() noexcept;
 
  PosixSerialPort port_ {};
  MelsecSerialClient client_ {};
  ProtocolConfig protocol_config_ {};
  std::array<std::byte, kMaxResponseFrameBytes> rx_buffer_ {};
  CompletionState completion_ {};
};
 
}  // namespace mcprotocol::serial