CPP_Core/Core/Serial/Serial.h

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


// #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 <sys/ioctl.h>
  #include <fcntl.h>
  #include <unistd.h>
#if defined(USE_TERMIOS)
    #include <termios.h>
    #include <linux/serial.h>
    using Serial_Settings = termios;
#elif defined(USE_TERMIOS2)
    //#include <asm-generic/termios.h"
    #include <asm/termbits.h>
    #include <asm/ioctls.h>
    using Serial_Settings = termios2;
#elif defined(USE_SERIAL_STRUCT)
    #include <linux/serial.h>
    #include <asm-generic/termbits.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();
    };

}