rfly_serial.h

#pragma once
 
#include <algorithm>
#include <cstdint>
#include <vector>
#include <string>
#include <mutex>
#include <thread>
#ifdef _WIN32
#include <windows.h>
#else
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
#include <cstring>
#include <sys/ioctl.h>
#endif
 
#ifndef BUFFER_SIZE_RFLY
#define BUFFER_SIZE_RFLY 65500
#endif
 
#include <functional>
 
 
class SerialCPP
{
public:
 
 // function for calling program
    std::function<void(const char*, size_t)> onRawMessageReceived;
 
 // Constructor: Initializes a new instance of the SerialCPP class.
 SerialCPP();
 
 // Destructor: Closes the serial port if it is open.
 ~SerialCPP();
 
 // Opens the serial port for communication.
 // @param port: The name of the serial port to connect to.
 // @param baudRate: The baud rate at which the communications device operates.
 // @return: true if the port was opened successfully, false otherwise.
 bool open(const std::string &port, size_t baud = 115200);
 
 // Closes the serial port.
 // @return: true if the port was closed successfully, false otherwise.
 bool close();
 
 // Writes data to the serial port.
 // @param data: The data to write to the port.
 // @return: true if the data was written successfully, false otherwise.
 bool writeBytes(const std::vector<uint8_t> &data);
 
 // Writes a string to the serial port, followed by a newline character.
 // @param data: The string to write to the port.
 // @return: true if the string was written successfully, false otherwise.
 bool writeLine(const std::string &data);
 
 // Reads data from the serial port.
 // @param n: The maximum number of bytes to try and read.
 // @return: A vector containing the actual bytes read.
    std::vector<uint8_t> readBytes(size_t n);
 
 // Reads a line of text from the serial port.
 // @return: The line of text read from the port, or an empty string if no data is available.
    std::string readLine();
 
 void StartRecvThread();
 
 // Returns True if the serial port is open, False otherwise.
 // @return: True if the serial port is open, False otherwise.
 bool isDeviceConnected();
 
 int RecvNoblock(char * buf, int maxrecvlen=BUFFER_SIZE_RFLY){
 int readFlag=0;
 
        #ifdef _WIN32
            DWORD bytesRead;
 if (ReadFile(hSerial, buf, maxrecvlen, &bytesRead, NULL) && bytesRead > 0)
            {
                buf[bytesRead]='\0';
                readFlag=bytesRead;
            }else{
                buf[0]='\0';
                readFlag=-1;
            }
        #else
            ssize_t messageLength = ::read(fd, buf, maxrecvlen);
 if (messageLength > 0) // 如果成功读到数据
            {
                buf[messageLength]='\0';
                readFlag=messageLength;
            }else{
                buf[0]='\0';
                readFlag=-1;
            }
        #endif
 
 return readFlag;
    }
 
 
 int SendTo(const char* bytes, size_t byteslength){
 // Lock the mutex to prevent multiple threads from accessing the serial port at the same time.
        std::lock_guard<std::mutex> lock(mutex);
 
#ifdef _WIN32
        DWORD bytesWritten;
 if (!WriteFile(hSerial, bytes, (DWORD)byteslength, &bytesWritten, NULL))
        {
 return -1;
        }else{
 return (int)byteslength;
        }
#else
        ssize_t result = ::write(fd, bytes, byteslength);
 if (result == -1)
        {
 return -1;
        }else{
 return (int)result;
        }
#endif
 
    }
 
 // Overload of the bool operator.
 operator bool()
    {
 return isDeviceConnected();
    }
 
 
 
private:
 
 static void ReceiveThread(SerialCPP *serial){
 char tempBuffer[BUFFER_SIZE_RFLY+1];
 while (true){
            #ifdef _WIN32
                DWORD bytesRead;
 if (ReadFile(serial->hSerial, &tempBuffer, BUFFER_SIZE_RFLY, &bytesRead, NULL) && bytesRead > 0)
                {
                    tempBuffer[bytesRead] = '\0'; 
 if(serial->onRawMessageReceived)
                    {
                        serial->onRawMessageReceived(tempBuffer,bytesRead); 
                    }
                }else{
                    Sleep(2);
                }
            #else
                ssize_t messageLength = ::read(serial->fd, &tempBuffer, BUFFER_SIZE_RFLY);
 if (messageLength > 0) 
                {
                    tempBuffer[messageLength] = '\0'; 
 if(serial->onRawMessageReceived){ 
                        serial->onRawMessageReceived(tempBuffer,bytesRead); 
                    }
                }else{
                    sleep(0.002);
                }
            #endif
        }
 
    }
 
 // Reads a byte from the serial port.
 // @return: The byte read, or std::nullopt if no data is available.
 bool read(uint8_t &byte);
 
 // Writes a byte to the serial port.
 // @param data: The byte to write to the port.
 // @return: true if the data was written successfully, false otherwise.
 bool write(const uint8_t byte);
 
    std::string portName; // The name of the serial port.
 size_t baudRate;      // The baud rate at which the communications device operates.
    std::mutex mutex;     // The mutex used to synchronize access to the serial port.
 
#ifdef _WIN32
    HANDLE hSerial; // The handle to the serial port (Windows only).
#else
 int fd; // The file descriptor for the serial port (non-Windows only).
#endif
};
 
 
SerialCPP::SerialCPP()
{
#ifdef _WIN32
    hSerial = INVALID_HANDLE_VALUE;
#else
    fd = -1;
#endif
}
 
 
 
SerialCPP::~SerialCPP()
{
    close();
}
 
bool SerialCPP::open(const std::string &port, size_t baud)
{
    portName=port;
    baudRate=baud;
 
 // Lock the mutex to prevent multiple threads from accessing the serial port at the same time.
    std::lock_guard<std::mutex> lock(mutex);
 
#ifdef _WIN32
    hSerial = CreateFile(portName.c_str(), GENERIC_READ | GENERIC_WRITE, NULL, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 if (hSerial == INVALID_HANDLE_VALUE)
    {
 return false;
    }
 else
    {
        DCB dcbSerialParameters = {0};
 
 if (!GetCommState(hSerial, &dcbSerialParameters))
        {
 return false;
        }
 else
        {
            dcbSerialParameters.BaudRate = (DWORD)baudRate;
            dcbSerialParameters.ByteSize = 8;
            dcbSerialParameters.StopBits = ONESTOPBIT;
            dcbSerialParameters.Parity = NOPARITY;
            dcbSerialParameters.fDtrControl = DTR_CONTROL_ENABLE;
 
 if (!SetCommState(hSerial, &dcbSerialParameters))
            {
 return false;
            }
 else
            {
 // Set The Read Timeouts To Make ReadFile Non-Blocking
                COMMTIMEOUTS timeouts = {0};
                timeouts.ReadIntervalTimeout = MAXDWORD;
                timeouts.ReadTotalTimeoutConstant = 0;
                timeouts.ReadTotalTimeoutMultiplier = 0;
 if (!SetCommTimeouts(hSerial, &timeouts))
                {
 return false;
                }
            }
        }
    }
#else
    fd = ::open(portName.c_str(), O_RDWR | O_NOCTTY /* | O_NONBLOCK*/);
 if (fd < 0)
    {
 return false;
    }
 
 struct termios tty;
    memset(&tty, 0, sizeof(tty));
 
 if (tcgetattr(fd, &tty) != 0)
    {
 return false;
    }
 
    speed_t speed;
 switch (baudRate)
    {
 case 4800:
        speed = B4800;
 break;
 case 9600:
        speed = B9600;
 break;
 case 19200:
        speed = B19200;
 break;
 case 38400:
        speed = B38400;
 break;
 case 57600:
        speed = B57600;
 break;
 case 115200:
        speed = B115200;
 break;
 case 230400:
        speed = B230400;
 break;
 case 460800:
        speed = B460800;
 break;
 case 921600:
        speed = B921600;
 break;             
 default:
 return false; // Unsupported baud rate
    }
 
    tty.c_cflag &= ~PARENB;        // Clear parity bit, disabling parity (most common)
    tty.c_cflag &= ~CSTOPB;        // Clear stop field, only one stop bit used in communication (most common)
    tty.c_cflag |= CS8;            // 8 bits per byte (most common)
    tty.c_cflag &= ~CRTSCTS;       // Disable RTS/CTS hardware flow control (most common)
    tty.c_cflag |= CREAD | CLOCAL; // Turn on READ & ignore ctrl lines (CLOCAL = 1)
 
    tty.c_lflag &= ~ICANON;
    tty.c_lflag &= ~ECHO;   // Disable echo
    tty.c_lflag &= ~ECHOE;  // Disable erasure
    tty.c_lflag &= ~ECHONL; // Disable new-line echo
    tty.c_lflag &= ~ISIG;   // Disable interpretation of INTR, QUIT and SUSP
 
    tty.c_iflag &= ~(IXON | IXOFF | IXANY);                                      // Turn off s/w flow ctrl
    tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL); // Disable any special handling of received bytes
 
    tty.c_oflag &= ~OPOST; // Prevent special interpretation of output bytes (e.g. newline chars)
    tty.c_oflag &= ~ONLCR; // Prevent conversion of newline to carriage return/line feed
 
 // Set in/out baud rate to be speed
    cfsetispeed(&tty, speed);
    cfsetospeed(&tty, speed);
 
 // Save tty settings, also checking for error
 if (tcsetattr(fd, TCSANOW, &tty) != 0)
    {
 return false;
    }
#endif
 
 return true;
}
 
void SerialCPP::StartRecvThread(){
    std::thread t(ReceiveThread, this); // usage with Connect()
    t.detach();
}
 
bool SerialCPP::close()
{
 // Lock the mutex to prevent multiple threads from accessing the serial port at the same time.
    std::lock_guard<std::mutex> lock(mutex);
 
#ifdef _WIN32
 if (hSerial != INVALID_HANDLE_VALUE)
    {
 if (!CloseHandle(hSerial))
        {
 return false;
        }
        hSerial = INVALID_HANDLE_VALUE;
    }
#else
 if (fd >= 0)
    {
 if (::close(fd) == -1)
        {
 return false;
        }
        fd = -1;
    }
#endif
 
 return true;
}
 
bool SerialCPP::write(uint8_t byte)
{
#ifdef _WIN32
    DWORD bytesWritten;
 if (!WriteFile(hSerial, &byte, 1, &bytesWritten, NULL))
    {
 return false;
    }
#else
    ssize_t result = ::write(fd, &byte, 1);
 if (result == -1)
    {
 return false;
    }
#endif
 return true;
}
 
bool SerialCPP::writeBytes(const std::vector<uint8_t> &data)
{
 // Lock the mutex to prevent multiple threads from accessing the serial port at the same time.
    std::lock_guard<std::mutex> lock(mutex);
 
 for (const uint8_t &byte : data)
    {
 if (!write(byte))
        {
 return false;
        }
    }
 return true;
}
 
bool SerialCPP::writeLine(const std::string &data)
{
 // Lock the mutex to prevent multiple threads from accessing the serial port at the same time.
    std::lock_guard<std::mutex> lock(mutex);
 
 // Convert string to a byte array
    std::vector<uint8_t> byteData(data.begin(), data.end());
 
 // Append newline character
    byteData.push_back('\n');
 
 // Write the byte array using the write method
 for (size_t i = 0; i < byteData.size(); ++i)
    {
 if (!write(byteData.data()[i]))
        {
 return false;
        }
    }
 return true;
}
 
bool SerialCPP::read(uint8_t &byteR)
{
    uint8_t byte;
#ifdef _WIN32
    DWORD bytesRead;
 if (!ReadFile(hSerial, &byte, 1, &bytesRead, NULL) || bytesRead == 0)
    {
 return false;
    }
#else
    ssize_t result = ::read(fd, &byte, 1);
 if (result <= 0)
    {
 return false;
    }
#endif
    byteR = byte;
 return true;
}
 
std::vector<uint8_t> SerialCPP::readBytes(size_t n)
{
 // Lock the mutex to prevent multiple threads from accessing the serial port at the same time.
    std::lock_guard<std::mutex> lock(mutex);
 
    std::vector<uint8_t> buffer;
    uint8_t byte;
 for (size_t i = 0; i < n && read(byte); ++i)
    {
        buffer.push_back(byte);
    }
 return buffer;
}
 
std::string SerialCPP::readLine()
{
    std::lock_guard<std::mutex> lock(mutex);
 
    std::string line;
    uint8_t byte;
 while (read(byte) && byte != '\n')
    {
        line += static_cast<char>(byte);
    }
 
 // Remove Potential Trailing Newline & Carriage Return Characters
    line.erase(std::remove(line.begin(), line.end(), '\n'), line.end());
    line.erase(std::remove(line.begin(), line.end(), '\r'), line.end());
 
 return line;
}
 
bool SerialCPP::isDeviceConnected()
{
#ifdef _WIN32
 if (hSerial == INVALID_HANDLE_VALUE)
    {
        close();
 return false;
    }
 else
    {
        DWORD errors;
        COMSTAT status;
        ClearCommError(hSerial, &errors, &status);
 return errors == 0;
    }
#else
 if (fd < 0)
    {
        close();
 return false;
    }
 else
    {
 int mcs = 0;
 if (ioctl(fd, TIOCMGET, &mcs) < 0)
        {
            close();
 return false;
        }
 return true;
    }
#endif
}