include/serial.h

@@ -1,10 +1,8 @@
 #ifndef SERIAL_H
 #define SERIAL_H
 
-#include <algorithm>
 #include <chrono>
 #include <cstring>
-#include <expected>
 #include <format>
 #include <functional>
 #include <iostream>
@@ -14,6 +12,7 @@
 #include <thread>
 #include <type_traits>
 #include <vector>
+#include <expected>
 
 #include "serialib.h"
 
@@ -49,7 +48,7 @@ concept SupportString = requires {
     std::is_same_v<T, std::string>;
 };
 
-enum class [[maybe_unused]] SerialErrorCode {
+enum class [[maybe_unused]] SerialErrorCode{
     SUCCESS,
     TIMEOUT,
     SETTIMEOUTERROR,
@@ -84,19 +83,17 @@ class Serial {
 
     bool IsOpen() { return ser.isDeviceOpen(); }
 
-    template <SupportString T>
+    template<SupportString T>
-    bool OpenDeviceDelay(T portName, unsigned int baudRate, int delay) {
+    bool OpenDeviceDelay(T portName, unsigned int baudRate, int delay){
         std::this_thread::sleep_for(std::chrono::seconds(delay));
         return OpenDevice(portName, baudRate);
     }
 
     template <SupportString T>
-    bool OpenDevice(T portName, unsigned int bauds = 115200,
+    bool OpenDevice(T portName, unsigned int bauds = 115200) {
-                    int delayTime = 0) {
         std::string reallyPortName;
         std::format_to(std::back_inserter(reallyPortName), "\\\\.\\{}",
                        portName);
-        std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
         if (ser.isDeviceOpen())
             return true;
         int code = ser.openDevice(reallyPortName.c_str(), bauds);
@@ -125,15 +122,14 @@ class Serial {
     }
 
     template <SupportString T>
-    std::expected<std::string, SerialErrorCode>
+    std::expected<std::string, SerialErrorCode> DelayGetResponse(int delayTime, T command,
-    DelayGetResponse(int delayTime, T command, int timeout = 50) {
+                                                int timeout = 50) {
         std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
         return GetAtResponse(command, timeout);
     }
 
     template <SupportString T>
-    std::expected<std::string, SerialErrorCode>
+    std::expected<std::string, SerialErrorCode> GetAtResponse(T command, int timeout = 50) {
-    GetAtResponse(T command, int timeout = 50) {
         ser.flushReceiver();
         std::string reallyCommand;
         if constexpr (std::is_same_v<T, std::string>) {
@@ -145,18 +141,20 @@ class Serial {
         Log("Send: " + reallyCommand);
         std::this_thread::sleep_for(10ms);
         auto availableSize = ser.available();
-        auto buffer = std::make_unique<char[]>(availableSize + 1);
+        char *buffer = new char[availableSize + 1];
-        std::memset(buffer.get(), 0, availableSize);
+        std::memset(buffer, 0, availableSize);
-        auto size = ser.readBytes(buffer.get(), availableSize, timeout);
+        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);
     }
 
@@ -168,8 +166,8 @@ class Serial {
         }
     }
 
-    template <int timeout = 200, SupportString T, SupportString... Args>
+    template <SupportString T>
-    bool GetAtUntil(T command, Args... expect) {
+    bool GetAtUntil(T command, T expect = "OK", int timeout = 200) {
         auto endTime = std::chrono::system_clock::now() +
                        std::chrono::milliseconds(timeout);
         ser.flushReceiver();
@@ -184,13 +182,14 @@ class Serial {
         while (std::chrono::system_clock::now() < endTime) {
             std::this_thread::sleep_for(10ms);
             auto availableSize = ser.available();
-            auto buffer = std::make_unique<char[]>(availableSize + 1);
+            auto buffer = new char[availableSize + 1];
-            auto size = ser.readBytes(buffer.get(), availableSize, timeout);
+            auto size = ser.readBytes(buffer, availableSize, timeout);
             buffer[size] = '\0';
-            auto str = std::string(buffer.get());
+            auto str = std::string(buffer);
+            delete[] buffer;
             if (size > 0)
                 Log("Receive: " + str);
-            if (((str.find(expect) != std::string::npos) && ...)) {
+            if (str.find(expect) != std::string::npos) {
                 return true;
             }
         }