CPP_Core/Core/Serial/Serial.h

#pragma once
#include <cstdint>
#include <cstring>
#include <functional>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

// #define USE_TERMIOS2
// #define USE_TERMIOS
// 这个不好使
// #define USE_SERIAL_STRUCT
#if !defined(USE_TERMIOS2) && !defined(USE_TERMIOS) &&                         \
    !defined(USE_SERIAL_STRUCT)
#define USE_TERMIOS
#endif
#ifdef _WIN32
#include "../system/windows_include.h"
using Serial_Settings = DCB;
using Serial_FD = HANDLE;
using Baud_Rate_Type = int;
#else
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#if defined(USE_TERMIOS)
#include <linux/serial.h>
#include <termios.h>
using Serial_Settings = termios;
#elif defined(USE_TERMIOS2)
// #include <asm-generic/termios.h"
#include <asm/ioctls.h>
#include <asm/termbits.h>
using Serial_Settings = termios2;
#elif defined(USE_SERIAL_STRUCT)
#include <asm-generic/termbits.h>
#include <linux/serial.h>
using Serial_Settings = serial_struct;
#endif
using Baud_Rate_Type = unsigned int;
using Serial_FD = int;
#ifndef INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE -1
#endif
#endif
#include "../system/export.h"
class BaseLogger;
namespace Psc::serial {
extern BaseLogger *serial_logger;
void set_buffer_byte_size(Serial_FD fd, int byte_size);
int get_buffer_byte_size(Serial_FD fd);
void set_binary_mode(Serial_Settings &serial_info);
Serial_FD open(const std::string &port_name);
void close(Serial_FD fd);
void set_block(Serial_FD fd, bool block);
Serial_Settings get_serial_info(Serial_FD fd);
void reset(Serial_Settings &serial_info);
void set_serial_info(Serial_FD fd, Serial_Settings serial_info);
int get_available_bytes(Serial_FD fd);
int get_written_bytes(Serial_FD fd);
// windows下是阻塞的 怎么设置都是阻塞的
int64_t read_data(Serial_FD fd, char *data, int64_t maxSize);
// 非阻塞的，windows下先获取可读的字符在读取
std::string read_all(Serial_FD fd);
std::string read_block_all(Serial_FD fd, int64_t chunkSize);
int64_t write(Serial_FD fd, const char *data, int64_t size);

// milliseconds == 0 代表非阻塞 最快直接返回
int64_t write_all(Serial_FD fd, const std::string &data, int64_t chunkSize,
                  int64_t milliseconds, int64_t retry_count);

inline int64_t write_all_noblock(Serial_FD fd, const std::string &data,
                                 int64_t chunkSize) {
  return write_all(fd, data, chunkSize, 0, 0);
}
inline int64_t write_all_block(Serial_FD fd, const std::string &data,
                               int64_t chunkSize) {
  return write_all(fd, data, chunkSize, 1, -1);
}
void set_baud_rate(Serial_Settings &serial_info, Serial_FD fd,
                   Baud_Rate_Type baud);
Baud_Rate_Type get_baud_rate(Serial_Settings &serial_info);
std::string get_serial_info_str(std::string serial_name);

enum class DataBits {
  Data5 = 5,
  Data6 = 6,
  Data7 = 7,
  Data8 = 8,
  UnknownDataBits = -1
};

void set_data_bits(Serial_Settings &serial_info, DataBits data_bits);
DataBits get_data_bits(Serial_Settings &serial_info);

enum class StopBits {
  OneStop = 1,
  OneAndHalfStop = 3,
  TwoStop = 2,
  UnknownStopBits = -1
};

void set_stop_bits(Serial_Settings &serial_info, StopBits stop_bits);
StopBits get_stop_bits(Serial_Settings &serial_info);

enum class Parity {
  NoParity = 0,
  EvenParity = 2,
  OddParity = 3,
  SpaceParity = 4,
  MarkParity = 5,
  UnknownParity = -1
};

void set_parity(Serial_Settings &serial_info, Parity parity);
Parity get_parity(Serial_Settings &serial_info);

enum class FlowControl {
  NoFlowControl,
  HardwareControl,
  SoftwareControl,
  UnknownFlowControl = -1
};

void set_flow_control(Serial_Settings &serial_info, FlowControl flow_control);
FlowControl get_flow_control(Serial_Settings &serial_info);
class Serial {
public:
  bool open();
  void close();
  int64_t write(const std::string &data);
  std::string read(int64_t size = -1);
  int get_available_bytes();

protected:
  Baud_Rate_Type baud_rate = -1;
  DataBits dataBits = DataBits::UnknownDataBits;
  StopBits stopBits = StopBits::UnknownStopBits;
  Parity parity = Parity::UnknownParity;
  FlowControl flow_control = FlowControl::UnknownFlowControl;
  Serial_FD fd = INVALID_HANDLE_VALUE;
  Serial_Settings serial_info{};
  std::string serial_name;
  int buffer_byte_size = -1;

public:
  std::string to_string();
  void set_serial_name(const std::string &serial_name);
  std::string get_serial_name();
  void set_baud_rate(Baud_Rate_Type baud_rate);
  Baud_Rate_Type get_baud_rate();
  void set_data_bits(DataBits data_bits);
  DataBits get_data_bits();
  void set_stop_bits(StopBits stop_bits);
  StopBits get_stop_bits();
  void set_parity(Parity parity);
  Parity get_parity();
  void set_flow_control(FlowControl flow_control);
  FlowControl get_flow_control();
  void set_buffer_byte_size(int byte_size);
  int get_buffer_byte_size();
};

}