升级至C++23, 使用std::expected替代std::optional, 用range替代for,

CMakeLists.txt

@@ -3,11 +3,12 @@ cmake_minimum_required(VERSION 3.26)
 set(PROJECT_N demo)
 project(${PROJECT_N} VERSION 1.0)
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-include_directories(${CMAKE_SOURCE_DIR}/include)
+include_directories(${CMAKE_SOURCE_DIR}/include/)
-
+include_directories(${CMAKE_SOURCE_DIR}/third/)
 
 add_executable(${PROJECT_N}
     ${CMAKE_SOURCE_DIR}/third/serialib.cpp

include/serial.h

@@ -1,205 +1,194 @@
 #ifndef SERIAL_H
 #define SERIAL_H
 
-#include <cstring>
-#include <type_traits>
-#include <iostream>
-#include <string>
 #include <chrono>
-#include <optional>
+#include <cstring>
-#include <thread>
-#include <functional>
-#include <vector>
 #include <format>
-#include "../third/serialib.h"
+#include <functional>
+#include <iostream>
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <type_traits>
+#include <vector>
+#include <expected>
+
+#include "serialib.h"
 
 using namespace std::literals::chrono_literals;
+namespace ranges = std::ranges;
+namespace views = std::views;
 
-namespace serial
+namespace serial {
-{
 
-    static std::vector<std::string> GetUsbPorts()
+static std::vector<std::string> GetUsbPorts() {
-    {
+    std::vector<std::string> portArray;
-        std::vector<std::string> portArray;
+    std::string comname;
-        std::string comname;
+    std::string showname;
-        std::string showname;
+    ranges::for_each(views::iota(1, 256), [&](int i) {
-        for (int i = 0; i <= 256; i++)
+        std::format_to(std::back_inserter(comname), "\\\\.\\COM{}", i);
-        {
+        std::format_to(std::back_inserter(showname), "COM{}", i);
-            std::format_to(std::back_inserter(comname), "\\\\.\\COM{}", i);
+        const HANDLE m_handle = ::CreateFileA(
-            std::format_to(std::back_inserter(showname), "COM{}", i);
+            comname.c_str(), static_cast<DWORD>(GENERIC_WRITE) | GENERIC_READ,
-            // 创建或者打开一个文件或者I/O设备，如执行成功，则返回文件句柄 INVALID_HANDLE_VALUE 表示出错
+            0U, nullptr, OPEN_EXISTING, 0U, nullptr);
-            const HANDLE m_handle =
+        if (m_handle != INVALID_HANDLE_VALUE) {
-                ::CreateFileA(comname.c_str(),                                          
+            portArray.push_back(showname);
-                             static_cast<DWORD>(GENERIC_WRITE) | GENERIC_READ, 
+            CloseHandle(m_handle);
-                             0U,                                               
-                             nullptr,
-                             OPEN_EXISTING, 
-                             0U,            
-                             nullptr        
-                );
-
-            if (m_handle != INVALID_HANDLE_VALUE)
-            {
-                portArray.push_back(showname);
-                CloseHandle(m_handle);
-            }
-            comname.clear();
-            showname.clear();
         }
-        return portArray;
+        comname.clear();
+        showname.clear();
+    });
+    return portArray;
+}
+
+template <typename T>
+concept SupportString = requires {
+    std::is_same_v<T, const char *>;
+    std::is_same_v<T, std::string>;
+};
+
+enum class [[maybe_unused]] SerialErrorCode{
+    SUCCESS,
+    TIMEOUT,
+    SETTIMEOUTERROR,
+    WRITEINGERROR,
+    READINGERROR,
+};
+
+class Serial {
+  private:
+    serialib ser;
+    const char *endChar = "\r\n";
+    std::function<void(const std::string &)> logCallBack;
+    bool removeEcho = true;
+
+  public:
+    Serial() = default;
+    ~Serial() { CloseDevice(); }
+    Serial(const Serial &other) = delete;
+    Serial(Serial &&other) = delete;
+    Serial &operator=(const Serial &other) = delete;
+    Serial &operator=(Serial &&other) = delete;
+
+    auto SetRemoveEcho(bool remove) { removeEcho = remove; }
+
+    static std::string GetTimeNow() {
+        auto now = std::chrono::system_clock::now();
+        auto now_c = std::chrono::system_clock::to_time_t(now);
+        char buffer[32];
+        auto _ = ctime_s(buffer, 32, &now_c);
+        return buffer;
     }
 
-    template <typename T>
+    bool IsOpen() { return ser.isDeviceOpen(); }
-    concept SupportString = requires {
-        std::is_same_v<T, const char *>;
-        std::is_same_v<T, std::string>;
-    };
 
-    enum class
+    template <SupportString T>
-        [[maybe_unused]] ErrorCode
+    bool OpenDevice(T portName, unsigned int bauds = 115200) {
-    {
+        std::string reallyPortName;
-        SUCCESS,
+        std::format_to(std::back_inserter(reallyPortName), "\\\\.\\{}",
-        TIMEOUT,
+                       portName);
-        SETTIMEOUTERROR,
+        if (ser.isDeviceOpen())
-        WRITEINGERROR,
+            return true;
-        READINGERROR,
+        int code = ser.openDevice(reallyPortName.c_str(), bauds);
-    };
+        if (code == 1) {
-
+            return true;
-    class Serial
+        } else {
-    {
-    private:
-        serialib ser;
-        const char *endChar = "\r\n";
-        std::function<void(const std::string &)> logCallBack;
-
-    public:
-        Serial() = default;
-
-        std::string GetTimeNow()
-        {
-            auto now = std::chrono::system_clock::now();
-            auto now_c = std::chrono::system_clock::to_time_t(now);
-            char buffer[32];
-            ctime_s(buffer, 32, &now_c);
-            return std::string(buffer);
-        }
-
-        bool IsOpen(){
-            return ser.isDeviceOpen();
-        }
-
-        template <SupportString T>
-        bool OpenDevice(T portName, unsigned int bauds = 115200)
-        {
-            std::string reallyPortName;
-            std::format_to(std::back_inserter(reallyPortName), "\\\\.\\{}", portName);
-            if(ser.isDeviceOpen()) return true;
-            int code;
-            code = ser.openDevice(reallyPortName.c_str(), bauds);
-            if (code == 1)
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        void Log(const std::string &log)
-        {
-            if (logCallBack)
-            {
-                auto msg = GetTimeNow() + " " + log + "\n";
-                logCallBack(msg);
-            }
-        }
-
-        void SetLogCallBack(std::function<void(const std::string &)> callBack)
-        {
-            logCallBack = callBack;
-        }
-        void CloseDevice()
-        {
-            if(!ser.isDeviceOpen()) return;
-            ser.closeDevice();
-        }
-
-        ~Serial() = default;
-
-        template<SupportString T>
-        std::optional<std::string> DelayGetResponse(int delayTime, T command, int timeout = 50){
-            std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
-            return GetAtResponse(command, timeout);
-        }
-
-        template <SupportString T>
-        std::optional<std::string> GetAtResponse(T command, int timeout = 50)
-        {
-            ser.flushReceiver();
-            std::string reallyCommand;
-            std::string response;
-            if constexpr (std::is_same_v<T, std::string>)
-            {
-                reallyCommand = command + endChar;
-            }
-            else
-            {
-                reallyCommand = std::string(command) + endChar;
-            }
-            ser.writeString(reallyCommand.c_str());
-            Log("Send: " + reallyCommand);
-            std::this_thread::sleep_for(10ms);
-            auto availableSize = ser.available();
-            char *buffer = new char[availableSize + 1];
-            std::memset(buffer, 0, availableSize);
-            auto size = ser.readBytes(buffer, availableSize, timeout);
-            if (size > 0)
-            {
-                buffer[size] = '\0';
-                response = std::string(buffer);
-                Log("Receive: " + response);
-                delete[] buffer;
-                return response;
-            }
-            delete[] buffer;
-            return std::nullopt;
-        }
-
-        template <SupportString T>
-        bool GetAtUntil(T command, T expect = "OK", int timeout = 50)
-        {
-            auto endTime = std::chrono::system_clock::now() + std::chrono::milliseconds(timeout);
-            ser.flushReceiver();
-            std::string reallyCommand;
-            if constexpr (std::is_same_v<T, std::string>)
-            {
-                reallyCommand = command + endChar;
-            }
-            else
-            {
-                reallyCommand = std::string(command) + endChar;
-            }
-            ser.writeString(reallyCommand.c_str());
-            Log("Send : " + reallyCommand);
-            while (std::chrono::system_clock::now() < endTime)
-            {
-                std::this_thread::sleep_for(10ms);
-                auto availableSize = ser.available();
-                auto buffer = new char[availableSize + 1];
-                auto size = ser.readBytes(buffer, availableSize, timeout);
-                buffer[size] = '\0';
-                auto str = std::string(buffer);
-                delete[] buffer;
-                if (size > 0)
-                    Log("Receive: " + str);
-                if (str.find(expect) != std::string::npos)
-                {
-                    return true;
-                }
-            }
             return false;
         }
-    };
+    }
-}
+
+    void Log(const std::string &log) const {
+        if (logCallBack) {
+            auto msg = GetTimeNow() + " " + log;
+            logCallBack(msg);
+        }
+    }
+
+    void
+    SetLogCallBack(const std::function<void(const std::string &)> &callBack) {
+        logCallBack = callBack;
+    }
+    void CloseDevice() {
+        if (!ser.isDeviceOpen())
+            return;
+        ser.closeDevice();
+    }
+
+    template <SupportString T>
+    std::expected<std::string, SerialErrorCode> DelayGetResponse(int delayTime, T command,
+                                                int timeout = 50) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
+        return GetAtResponse(command, timeout);
+    }
+
+    template <SupportString T>
+    std::expected<std::string, SerialErrorCode> GetAtResponse(T command, int timeout = 50) {
+        ser.flushReceiver();
+        std::string reallyCommand;
+        if constexpr (std::is_same_v<T, std::string>) {
+            reallyCommand = command + endChar;
+        } else {
+            reallyCommand = std::string(command) + endChar;
+        }
+        ser.writeString(reallyCommand.c_str());
+        Log("Send: " + reallyCommand);
+        std::this_thread::sleep_for(10ms);
+        auto availableSize = ser.available();
+        char *buffer = new char[availableSize + 1];
+        std::memset(buffer, 0, availableSize);
+        auto size = ser.readBytes(buffer, availableSize, timeout);
+
+        if (size > 0) {
+            buffer[size] = '\0';
+            std::string response = std::string(buffer);
+            Log("Receive: " + response);
+            delete[] buffer;
+            if (removeEcho)
+                response.replace(0, reallyCommand.length(), "");
+            return response;
+        }
+        delete[] buffer;
+        return std::unexpected(SerialErrorCode::TIMEOUT);
+    }
+
+    template <SupportString T>
+    auto GetAtResponseRepeat(T command, int timeout = 200, int repeatTime = 1)
+        -> void {
+        for (int i = 0; i <= repeatTime; i++) {
+            auto _ = GetAtResponse(command, timeout);
+        }
+    }
+
+    template <SupportString T>
+    bool GetAtUntil(T command, T expect = "OK", int timeout = 200) {
+        auto endTime = std::chrono::system_clock::now() +
+                       std::chrono::milliseconds(timeout);
+        ser.flushReceiver();
+        std::string reallyCommand;
+        if constexpr (std::is_same_v<T, std::string>) {
+            reallyCommand = command + endChar;
+        } else {
+            reallyCommand = std::string(command) + endChar;
+        }
+        ser.writeString(reallyCommand.c_str());
+        Log("Send : " + reallyCommand);
+        while (std::chrono::system_clock::now() < endTime) {
+            std::this_thread::sleep_for(10ms);
+            auto availableSize = ser.available();
+            auto buffer = new char[availableSize + 1];
+            auto size = ser.readBytes(buffer, availableSize, timeout);
+            buffer[size] = '\0';
+            auto str = std::string(buffer);
+            delete[] buffer;
+            if (size > 0)
+                Log("Receive: " + str);
+            if (str.find(expect) != std::string::npos) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+} // namespace serial
 #endif // SERIAL_H

main.cc

@@ -1,24 +1,59 @@
-#include "include/serial.h"
+#include <algorithm>
-#include <iostream>
 #include <chrono>
+#include <iostream>
+#include <ranges>
+#include <limits>
+#include <string_view>
+
+#include "include/serial.h"
+#undef max
 using namespace std::literals::chrono_literals;
+using namespace serial;
+namespace ranges = std::ranges;
+namespace views = std::views;
 
-void PrintLog(const std::string& msg){
+void PrintLog(const std::string &msg) { std::cout << msg << std::endl; }
-    std::cout<<msg<<std::endl;
-}
 
-int main(int argc, char** const argv){
+int main(int argc, char **const argv) {
     Serial serial;
+    auto ports = serial::GetUsbPorts();
+    ranges::for_each(ports,
+                     [](const auto &port) { std::cout << port << std::endl; });
+    std::string portName;
+    std::string command;
+    std::cin >> portName;
+    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
+    serial.OpenDevice(portName);
     serial.SetLogCallBack(PrintLog);
-    if(!serial.OpenDevice(R"(\\.\COM11)", 115200)){
+    while (true) {
-        std::cout<<"Open device failed"<<std::endl;
+        command.clear();
-        return 0;
+        std::getline(std::cin, command);
+        system("cls");
+        auto startTime = std::chrono::system_clock::now();
+        if (command.find(":") != std::string::npos) {
+            command.erase(std::remove_if(command.begin(), command.end(),
+                                         [](char c) { return c == ':'; }),
+                          command.end());
+            auto reallyCommand = command.substr(0, command.find_first_of(' '));
+            auto expect = command.substr(command.find_first_of(' ') + 1,
+                                         command.length());
+            auto res = serial.GetAtUntil(reallyCommand, expect, 2000);
+            auto endTime = std::chrono::system_clock::now();
+            std::cout << "dura: "
+                      << std::chrono::duration_cast<std::chrono::milliseconds>(
+                             endTime - startTime)
+                             .count()
+                      << std::endl;
+        } else {
+            auto resp = serial.GetAtResponse(command);
+            auto endTime = std::chrono::system_clock::now();
+            std::cout << "dura: "
+                      << std::chrono::duration_cast<std::chrono::milliseconds>(
+                             endTime - startTime)
+                             .count()
+                      << std::endl;
+            std::cout << resp.value_or("Send Command Fail") << std::endl;
+        }
     }
-    auto startTime = std::chrono::system_clock::now();
+    return 0;
-    // auto res = serial.GetAtUntil("AT+CFUN=1","OK", 200);
-    // std::cout<<res.value_or("ERROR")<<std::endl;
-    auto res = serial.GetAtResponse("AT+CGSN=0", 200);
-    std::cout<<res.value_or("ERROR")<<std::endl;
-    auto endTime = std::chrono::system_clock::now();
-    std::cout<<std::chrono::duration_cast<std::chrono::milliseconds>(endTime-startTime).count();
 }