实现串口监控功能，重构 ComKit::Work 方法以支持指定端口
This commit is contained in:
parent
cea5209222
commit
7316c326d0
@ -38,7 +38,7 @@ class ComKit {
|
||||
static std::vector<ComStruct> *GetAllComPortNames();
|
||||
static void Start(std::string, std::string);
|
||||
static void End();
|
||||
static void Work();
|
||||
static void Work(const std::string& port_name);
|
||||
static bool ChangeComPortNumber(const std::string &oldPortName,
|
||||
const std::string &newPortName);
|
||||
static std::vector<std::string> watchingComPort;
|
||||
|
||||
28
include/ComWatch.h
Normal file
28
include/ComWatch.h
Normal file
@ -0,0 +1,28 @@
|
||||
#ifndef COMWATCH_H
|
||||
#include "serial.h"
|
||||
#include "spdlog/spdlog.h"
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
|
||||
enum class SIGNAL_TYPE{
|
||||
REMOVE_,
|
||||
ADD_,
|
||||
};
|
||||
|
||||
class SerialWatch {
|
||||
private:
|
||||
std::function<void(const std::string&, SIGNAL_TYPE type)> callback;
|
||||
std::jthread work_thread;
|
||||
std::stop_source s;
|
||||
std::mutex m;
|
||||
public:
|
||||
SerialWatch() = default;
|
||||
~SerialWatch();
|
||||
void set_callback(std::function<void(const std::string&, SIGNAL_TYPE type)> func);
|
||||
void work();
|
||||
|
||||
};
|
||||
|
||||
#endif // !COMWATCH_H
|
||||
518
include/serial.h
518
include/serial.h
@ -22,300 +22,298 @@ namespace ranges = std::ranges;
|
||||
namespace views = std::views;
|
||||
|
||||
namespace serial {
|
||||
template <typename... Types> struct _StrongType {};
|
||||
template <typename... Types> struct _StrongType {};
|
||||
|
||||
template <typename T> struct _StrongType<T> {
|
||||
using Type = T;
|
||||
};
|
||||
template <typename T> struct _StrongType<T> {
|
||||
using Type = T;
|
||||
};
|
||||
|
||||
template <typename Ta, typename Tb> struct _StrongType<Ta, Tb> {
|
||||
using Type = decltype(true ? std::declval<Ta>() : std::declval<Tb>());
|
||||
};
|
||||
template <typename Ta, typename Tb> struct _StrongType<Ta, Tb> {
|
||||
using Type = decltype(true ? std::declval<Ta>() : std::declval<Tb>());
|
||||
};
|
||||
|
||||
template <typename T, typename... Types> struct _StrongType<T, Types...> {
|
||||
using Type =
|
||||
typename _StrongType<T, typename _StrongType<Types...>::Type>::Type;
|
||||
};
|
||||
template <typename T, typename... Types> struct _StrongType<T, Types...> {
|
||||
using Type =
|
||||
typename _StrongType<T, typename _StrongType<Types...>::Type>::Type;
|
||||
};
|
||||
|
||||
template <typename... Types>
|
||||
using _strongType_t = typename _StrongType<Types...>::Type;
|
||||
template <typename... Types>
|
||||
using _strongType_t = typename _StrongType<Types...>::Type;
|
||||
|
||||
template <typename... Args> struct _IsCastable {};
|
||||
template <typename... Args> struct _IsCastable {};
|
||||
|
||||
template <typename T> struct _IsCastable<T> {
|
||||
static constexpr bool value = true;
|
||||
using Type = T;
|
||||
};
|
||||
template <typename T> struct _IsCastable<T> {
|
||||
static constexpr bool value = true;
|
||||
using Type = T;
|
||||
};
|
||||
|
||||
template <typename T, typename U> struct _IsCastable<T, U> {
|
||||
using __TRUE = char;
|
||||
using __FALSE = struct {
|
||||
char _[2];
|
||||
};
|
||||
static consteval __TRUE __TEST(U);
|
||||
static consteval __FALSE __TEST(...);
|
||||
static constexpr bool value =
|
||||
sizeof(__TEST(std::declval<T>())) == sizeof(__TRUE);
|
||||
using Type = std::conditional_t<value, U, void>;
|
||||
};
|
||||
template <typename T, typename U> struct _IsCastable<T, U> {
|
||||
using __TRUE = char;
|
||||
using __FALSE = struct {
|
||||
char _[2];
|
||||
};
|
||||
static consteval __TRUE __TEST(U);
|
||||
static consteval __FALSE __TEST(...);
|
||||
static constexpr bool value =
|
||||
sizeof(__TEST(std::declval<T>())) == sizeof(__TRUE);
|
||||
using Type = std::conditional_t<value, U, void>;
|
||||
};
|
||||
|
||||
template <typename T, typename... Args> struct _IsCastable<T, Args...> {
|
||||
static constexpr bool value =
|
||||
_IsCastable<T, typename _IsCastable<Args...>::Type>::value;
|
||||
using Type =
|
||||
std::conditional_t<value, typename _IsCastable<Args...>::Type, void>;
|
||||
};
|
||||
template <typename T, typename... Args> struct _IsCastable<T, Args...> {
|
||||
static constexpr bool value =
|
||||
_IsCastable<T, typename _IsCastable<Args...>::Type>::value;
|
||||
using Type =
|
||||
std::conditional_t<value, typename _IsCastable<Args...>::Type, void>;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
concept _SupportString = requires {
|
||||
_IsCastable<T, const char*, char*, std::string, std::string_view>::value;
|
||||
};
|
||||
template <_SupportString T> [[maybe_unused]] std::string _to_string(T&& str) {
|
||||
if constexpr (std::is_same_v<std::decay_t<T>, std::string>) {
|
||||
return str;
|
||||
}
|
||||
else if constexpr (std::is_same_v<std::decay_t<T>, std::string_view>) {
|
||||
return std::move(std::string(str.data()));
|
||||
}
|
||||
else if constexpr (std::is_same_v<std::decay_t<T>, const char*>) {
|
||||
return std::string(str);
|
||||
}
|
||||
}
|
||||
template <typename T>
|
||||
concept _SupportString = requires {
|
||||
_IsCastable<T, const char *, char *, std::string, std::string_view>::value;
|
||||
};
|
||||
template <_SupportString T> [[maybe_unused]] std::string _to_string(T &&str) {
|
||||
if constexpr (std::is_same_v<std::decay_t<T>, std::string>) {
|
||||
return str;
|
||||
} else if constexpr (std::is_same_v<std::decay_t<T>, std::string_view>) {
|
||||
return std::move(std::string(str.data()));
|
||||
} else if constexpr (std::is_same_v<std::decay_t<T>, const char *>) {
|
||||
return std::string(str);
|
||||
}
|
||||
}
|
||||
|
||||
static std::vector<std::string> GetUsbPorts() {
|
||||
static std::vector<std::string> GetUsbPorts() {
|
||||
#if defined(_WIN32) || defined(_WIN64)
|
||||
std::vector<std::string> portArray;
|
||||
std::string comname;
|
||||
std::string showname;
|
||||
ranges::for_each(views::iota(1, 256), [&](int i) {
|
||||
std::format_to(std::back_inserter(comname), "\\\\.\\COM{}", i);
|
||||
std::format_to(std::back_inserter(showname), "COM{}", i);
|
||||
const HANDLE m_handle = ::CreateFileA(
|
||||
comname.c_str(), static_cast<DWORD>(GENERIC_WRITE) | GENERIC_READ,
|
||||
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;
|
||||
std::vector<std::string> portArray;
|
||||
std::string comname;
|
||||
std::string showname;
|
||||
ranges::for_each(views::iota(1, 256), [&](int i) {
|
||||
std::format_to(std::back_inserter(comname), "\\\\.\\COM{}", i);
|
||||
std::format_to(std::back_inserter(showname), "COM{}", i);
|
||||
const HANDLE m_handle = ::CreateFileA(
|
||||
comname.c_str(), static_cast<DWORD>(GENERIC_WRITE) | GENERIC_READ,
|
||||
0U, nullptr, OPEN_EXISTING, 0U, nullptr);
|
||||
if (m_handle != INVALID_HANDLE_VALUE) {
|
||||
portArray.emplace_back(showname);
|
||||
CloseHandle(m_handle);
|
||||
} else if(GetLastError() == ERROR_ACCESS_DENIED){
|
||||
portArray.emplace_back(showname);
|
||||
}
|
||||
comname.clear();
|
||||
showname.clear();
|
||||
});
|
||||
return portArray;
|
||||
#elif defined(__linux__)
|
||||
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
enum class [[maybe_unused]] SerialErrorCode {
|
||||
SUCCESS,
|
||||
TIMEOUT,
|
||||
SETTIMEOUTERROR,
|
||||
WRITEINGERROR,
|
||||
READINGERROR,
|
||||
};
|
||||
enum class [[maybe_unused]] SerialErrorCode {
|
||||
SUCCESS,
|
||||
TIMEOUT,
|
||||
SETTIMEOUTERROR,
|
||||
WRITEINGERROR,
|
||||
READINGERROR,
|
||||
};
|
||||
|
||||
enum SerialDataBits {
|
||||
DATABIT_5 = 0,
|
||||
DATABIT_6,
|
||||
DATABIT_7,
|
||||
DATABIT_8,
|
||||
DATABIT_16,
|
||||
};
|
||||
enum SerialStopBits {
|
||||
STOPBIT_1 = 0,
|
||||
STOPBIT_1_5,
|
||||
STOPBIT_2,
|
||||
};
|
||||
enum SerialParity {
|
||||
SERIAL_PARITY_NONE = 0,
|
||||
SERIAL_PARITY_EVEN,
|
||||
SERIAL_PARITY_ODD,
|
||||
SERIAL_PARITY_MARK,
|
||||
SERIAL_PARITY_SPACE,
|
||||
};
|
||||
enum SerialDataBits {
|
||||
DATABIT_5 = 0,
|
||||
DATABIT_6,
|
||||
DATABIT_7,
|
||||
DATABIT_8,
|
||||
DATABIT_16,
|
||||
};
|
||||
enum SerialStopBits {
|
||||
STOPBIT_1 = 0,
|
||||
STOPBIT_1_5,
|
||||
STOPBIT_2,
|
||||
};
|
||||
enum SerialParity {
|
||||
SERIAL_PARITY_NONE = 0,
|
||||
SERIAL_PARITY_EVEN,
|
||||
SERIAL_PARITY_ODD,
|
||||
SERIAL_PARITY_MARK,
|
||||
SERIAL_PARITY_SPACE,
|
||||
};
|
||||
|
||||
class Serial {
|
||||
private:
|
||||
serialib ser;
|
||||
const char* endChar = "\r\n";
|
||||
std::function<void(const std::string&)> logCallBack;
|
||||
bool removeEcho = true; // 剔除回显
|
||||
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;
|
||||
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; }
|
||||
auto SetDtr(bool flag) { return flag ? ser.setDTR() : ser.clearDTR(); }
|
||||
auto SetRts(bool flag) { return flag ? ser.setRTS() : ser.clearRTS(); }
|
||||
auto SetRemoveEcho(bool remove) { removeEcho = remove; }
|
||||
auto SetDtr(bool flag) { return flag ? ser.setDTR() : ser.clearDTR(); }
|
||||
auto SetRts(bool flag) { return flag ? ser.setRTS() : ser.clearRTS(); }
|
||||
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
bool IsOpen() { return ser.isDeviceOpen(); }
|
||||
bool IsOpen() { return ser.isDeviceOpen(); }
|
||||
|
||||
template <_SupportString T>
|
||||
bool OpenDevice(T portName, unsigned int bauds = 115200, int delayTime = 0,
|
||||
SerialDataBits dataBits = SerialDataBits::DATABIT_8,
|
||||
SerialStopBits stopBits = SerialStopBits::STOPBIT_1,
|
||||
SerialParity parity = SerialParity::SERIAL_PARITY_NONE) {
|
||||
template <_SupportString T>
|
||||
bool OpenDevice(T portName, unsigned int bauds = 115200, int delayTime = 0,
|
||||
SerialDataBits dataBits = SerialDataBits::DATABIT_8,
|
||||
SerialStopBits stopBits = SerialStopBits::STOPBIT_1,
|
||||
SerialParity parity = SerialParity::SERIAL_PARITY_NONE) {
|
||||
#if defined(_WIN32) || defined(__WIN64)
|
||||
std::string reallyPortName;
|
||||
std::format_to(std::back_inserter(reallyPortName), "\\\\.\\{}",
|
||||
portName);
|
||||
std::string reallyPortName;
|
||||
std::format_to(std::back_inserter(reallyPortName), "\\\\.\\{}",
|
||||
portName);
|
||||
#elif defined(__linux__)
|
||||
std::string reallyPortName = std::string(portName);
|
||||
std::string reallyPortName = std::string(portName);
|
||||
#endif
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
|
||||
if (ser.isDeviceOpen())
|
||||
ser.closeDevice();
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
|
||||
if (ser.isDeviceOpen())
|
||||
ser.closeDevice();
|
||||
|
||||
int code = ser.openDevice(reallyPortName.c_str(), bauds,
|
||||
static_cast<::SerialDataBits>(dataBits),
|
||||
static_cast<::SerialParity>(parity),
|
||||
static_cast<::SerialStopBits>(stopBits));
|
||||
if (code == 1) {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
int code = ser.openDevice(reallyPortName.c_str(), bauds,
|
||||
static_cast<::SerialDataBits>(dataBits),
|
||||
static_cast<::SerialParity>(parity),
|
||||
static_cast<::SerialStopBits>(stopBits));
|
||||
if (code == 1) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
void Log(const std::string& log) const {
|
||||
if (logCallBack) {
|
||||
auto msg = GetTimeNow() + " " + log;
|
||||
logCallBack(msg);
|
||||
}
|
||||
}
|
||||
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();
|
||||
}
|
||||
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>
|
||||
DelayGetResponse(int delayTime, T command, int timeout = 50) {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
|
||||
return GetAtResponse(command, timeout);
|
||||
}
|
||||
|
||||
template <int repeatTime = 5, int delayTime = 200, int timeout = 200,
|
||||
_SupportString T, _SupportString... Args>
|
||||
bool GetAtUntilRepeat(T command, Args... args) {
|
||||
std::stringstream ss;
|
||||
int i = 0;
|
||||
while (i++ < repeatTime) {
|
||||
ss.str("");
|
||||
ss << "Count: " << i << "\n";
|
||||
Log(ss.str());
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
|
||||
if (GetAtUntil<timeout>(command, args...))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
template <int repeatTime = 5, int delayTime = 200, int timeout = 200,
|
||||
_SupportString T, _SupportString... Args>
|
||||
bool GetAtUntilRepeat(T command, Args... args) {
|
||||
std::stringstream ss;
|
||||
int i = 0;
|
||||
while (i++ < repeatTime) {
|
||||
ss.str("");
|
||||
ss << "Count: " << i << "\n";
|
||||
Log(ss.str());
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
|
||||
if (GetAtUntil<timeout>(command, args...))
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <_SupportString T>
|
||||
std::expected<std::string, SerialErrorCode>
|
||||
GetAtResponse(T command, int timeout = 50) {
|
||||
ser.flushReceiver();
|
||||
std::string reallyCommand = std::string(command) + endChar;
|
||||
ser.writeString(reallyCommand.c_str());
|
||||
Log("Send: " + reallyCommand);
|
||||
std::this_thread::sleep_for(10ms);
|
||||
auto availableSize = ser.available();
|
||||
auto buffer = std::make_unique<char[]>(availableSize + 1);
|
||||
std::memset(buffer.get(), 0, availableSize);
|
||||
auto size = ser.readBytes(buffer.get(), availableSize, timeout);
|
||||
template <_SupportString T>
|
||||
std::expected<std::string, SerialErrorCode>
|
||||
GetAtResponse(T command, int timeout = 50) {
|
||||
ser.flushReceiver();
|
||||
std::string reallyCommand = std::string(command) + endChar;
|
||||
ser.writeString(reallyCommand.c_str());
|
||||
Log("Send: " + reallyCommand);
|
||||
std::this_thread::sleep_for(10ms);
|
||||
auto availableSize = ser.available();
|
||||
auto buffer = std::make_unique<char[]>(availableSize + 1);
|
||||
std::memset(buffer.get(), 0, availableSize);
|
||||
auto size = ser.readBytes(buffer.get(), availableSize, timeout);
|
||||
|
||||
if (size > 0) {
|
||||
buffer[size] = '\0';
|
||||
std::string response = std::string(buffer.get());
|
||||
Log("Receive: " + response);
|
||||
if (removeEcho)
|
||||
response.replace(0, reallyCommand.length(), "");
|
||||
return response;
|
||||
}
|
||||
return std::unexpected(SerialErrorCode::TIMEOUT);
|
||||
}
|
||||
if (size > 0) {
|
||||
buffer[size] = '\0';
|
||||
std::string response = std::string(buffer.get());
|
||||
Log("Receive: " + response);
|
||||
if (removeEcho)
|
||||
response.replace(0, reallyCommand.length(), "");
|
||||
return response;
|
||||
}
|
||||
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>
|
||||
auto GetAtResponseRepeat(T command, int timeout = 200, int repeatTime = 1)
|
||||
-> void {
|
||||
for (int i = 0; i <= repeatTime; i++) {
|
||||
auto _ = GetAtResponse(command, timeout);
|
||||
}
|
||||
}
|
||||
|
||||
template <int timeout = 200, _SupportString T, _SupportString... Args>
|
||||
bool GetAtUntil(T command, Args... expect) {
|
||||
auto endTime = std::chrono::system_clock::now() +
|
||||
std::chrono::milliseconds(timeout);
|
||||
ser.flushReceiver();
|
||||
std::string resp;
|
||||
std::string 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 = std::make_unique<char[]>(availableSize + 1);
|
||||
auto size = ser.readBytes(buffer.get(), availableSize, timeout);
|
||||
buffer[size] = '\0';
|
||||
auto str = std::string(buffer.get());
|
||||
if (size > 0){
|
||||
Log("Receive: " + str);
|
||||
resp += str;
|
||||
}
|
||||
if (((str.find(expect) != std::string::npos) && ...)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
template <int timeout = 200, _SupportString T, _SupportString... Args>
|
||||
bool GetAtUntil(T command, Args... expect) {
|
||||
auto endTime = std::chrono::system_clock::now() +
|
||||
std::chrono::milliseconds(timeout);
|
||||
ser.flushReceiver();
|
||||
std::string resp;
|
||||
std::string 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 = std::make_unique<char[]>(availableSize + 1);
|
||||
auto size = ser.readBytes(buffer.get(), availableSize, timeout);
|
||||
buffer[size] = '\0';
|
||||
auto str = std::string(buffer.get());
|
||||
if (size > 0) {
|
||||
Log("Receive: " + str);
|
||||
resp += str;
|
||||
}
|
||||
if (((str.find(expect) != std::string::npos) && ...)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template <int timeout = 200, _SupportString T, _SupportString... Args>
|
||||
std::string GetAtUntilAndReturn(T command, Args... expect)
|
||||
{
|
||||
auto endTime = std::chrono::system_clock::now() +
|
||||
std::chrono::milliseconds(timeout);
|
||||
ser.flushReceiver();
|
||||
std::string resp = "";
|
||||
std::string 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 = std::make_unique<char[]>(availableSize + 1);
|
||||
auto size = ser.readBytes(buffer.get(), availableSize, timeout);
|
||||
buffer[size] = '\0';
|
||||
auto str = std::string(buffer.get());
|
||||
resp += str;
|
||||
if (size > 0)
|
||||
Log("Receive: " + str);
|
||||
if (((resp.find(expect) != std::string::npos) && ...)) {
|
||||
return resp;
|
||||
}
|
||||
}
|
||||
return resp;
|
||||
}
|
||||
};
|
||||
template <int timeout = 200, _SupportString T, _SupportString... Args>
|
||||
std::string GetAtUntilAndReturn(T command, Args... expect) {
|
||||
auto endTime = std::chrono::system_clock::now() +
|
||||
std::chrono::milliseconds(timeout);
|
||||
ser.flushReceiver();
|
||||
std::string resp = "";
|
||||
std::string 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 = std::make_unique<char[]>(availableSize + 1);
|
||||
auto size = ser.readBytes(buffer.get(), availableSize, timeout);
|
||||
buffer[size] = '\0';
|
||||
auto str = std::string(buffer.get());
|
||||
resp += str;
|
||||
if (size > 0)
|
||||
Log("Receive: " + str);
|
||||
if (((resp.find(expect) != std::string::npos) && ...)) {
|
||||
return resp;
|
||||
}
|
||||
}
|
||||
return resp;
|
||||
}
|
||||
};
|
||||
} // namespace serial
|
||||
#endif // SERIAL_H
|
||||
|
||||
@ -136,32 +136,21 @@ void ComKit::Start(std::string watchingPort, std::string input_commands) {
|
||||
commands = std::move(Split(input_commands));
|
||||
isWorking = true;
|
||||
}
|
||||
void ComKit::Work() {
|
||||
void ComKit::Work(const std::string &port_name) {
|
||||
if (isWorking) {
|
||||
std::thread([]() {
|
||||
std::lock_guard<std::mutex> lock(m);
|
||||
auto currentPortStructures = GetAllComPortNames();
|
||||
std::vector<std::string> currentPorts;
|
||||
for (auto s : *currentPortStructures) {
|
||||
currentPorts.emplace_back(s.comPortName);
|
||||
}
|
||||
for (auto &port : watchingComPort) {
|
||||
if (std::find(currentPorts.begin(), currentPorts.end(), port) !=
|
||||
currentPorts.end()) {
|
||||
spdlog::info(
|
||||
std::format("Start Work With Port [{}]", port));
|
||||
device.OpenDevice(port);
|
||||
for (auto &command : commands) {
|
||||
spdlog::info(std::format("Send Command: {}", command));
|
||||
std::this_thread::sleep_for(50ms);
|
||||
auto resp = device.GetAtUntilAndReturn(command, "OK");
|
||||
spdlog::info(std::format("resp: {}", resp));
|
||||
FlushLog();
|
||||
}
|
||||
device.CloseDevice();
|
||||
if (ranges::find(watchingComPort, port_name) != watchingComPort.end())
|
||||
std::thread([&port_name]() {
|
||||
spdlog::info(std::format("start working with [{}]", port_name));
|
||||
device.OpenDevice(port_name);
|
||||
for (auto &command : commands) {
|
||||
spdlog::info(std::format("Send Command: {}", command));
|
||||
std::this_thread::sleep_for(50ms);
|
||||
auto resp = device.GetAtUntilAndReturn(command, "OK");
|
||||
spdlog::info(std::format("resp: {}", resp));
|
||||
FlushLog();
|
||||
}
|
||||
}
|
||||
}).detach();
|
||||
device.CloseDevice();
|
||||
}).detach();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
45
src/ComWatch.cc
Normal file
45
src/ComWatch.cc
Normal file
@ -0,0 +1,45 @@
|
||||
#include "ComWatch.h"
|
||||
#include <algorithm>
|
||||
#include <chrono>
|
||||
#include <ranges>
|
||||
namespace ranges = std::ranges;
|
||||
namespace views = std::ranges::views;
|
||||
using namespace std::literals::chrono_literals;
|
||||
SerialWatch::~SerialWatch() {
|
||||
s.request_stop();
|
||||
if (work_thread.joinable()) {
|
||||
work_thread.join();
|
||||
}
|
||||
}
|
||||
|
||||
void SerialWatch::set_callback(
|
||||
std::function<void(const std::string&, SIGNAL_TYPE type)> func) {
|
||||
this->callback = func;
|
||||
}
|
||||
|
||||
void SerialWatch::work() {
|
||||
this->work_thread = std::jthread(
|
||||
[this](std::stop_token token) {
|
||||
std::vector<std::string> pre_ports;
|
||||
while (!token.stop_requested()) {
|
||||
auto curr_ports = serial::GetUsbPorts();
|
||||
for (auto &&port : pre_ports) {
|
||||
if (ranges::find(curr_ports, port) == curr_ports.end()) {
|
||||
std::lock_guard<std::mutex> lock(m);
|
||||
if (callback)
|
||||
callback(port, SIGNAL_TYPE::REMOVE_);
|
||||
}
|
||||
}
|
||||
for (auto &&port : curr_ports) {
|
||||
if (ranges::find(pre_ports, port) == pre_ports.end()) {
|
||||
std::lock_guard<std::mutex> lock(m);
|
||||
if (callback)
|
||||
callback(port, SIGNAL_TYPE::ADD_);
|
||||
}
|
||||
}
|
||||
pre_ports = std::move(curr_ports);
|
||||
std::this_thread::sleep_for(500ms);
|
||||
}
|
||||
},
|
||||
s.get_token());
|
||||
}
|
||||
20
src/main.cc
20
src/main.cc
@ -1,4 +1,5 @@
|
||||
#include "ComKit.h"
|
||||
#include "ComWatch.h"
|
||||
#include "imgui_helper.h"
|
||||
#include "imgui_stdlib.h"
|
||||
#include "spdlog/sinks/basic_file_sink.h"
|
||||
@ -67,6 +68,25 @@ int main(int argc, char **) {
|
||||
filterComName = config.at("ComPorts").as_string();
|
||||
inputCommands = config.at("Commands").as_string();
|
||||
}
|
||||
SerialWatch watcher;
|
||||
watcher.set_callback([](const std::string &port_name, SIGNAL_TYPE type) {
|
||||
switch (type) {
|
||||
case SIGNAL_TYPE::REMOVE_:
|
||||
spdlog::log(spdlog::level::debug,
|
||||
std::format("port: [{}] removed", port_name));
|
||||
ComKit::FlushLog();
|
||||
ComKit::GetAllComPortNames();
|
||||
break;
|
||||
case SIGNAL_TYPE::ADD_:
|
||||
spdlog::log(spdlog::level::debug,
|
||||
std::format("port: [{}] add", port_name));
|
||||
ComKit::FlushLog();
|
||||
ComKit::GetAllComPortNames();
|
||||
ComKit::Work(port_name);
|
||||
break;
|
||||
}
|
||||
});
|
||||
watcher.work();
|
||||
while (isRunning)
|
||||
helper.Render(
|
||||
[&]() {
|
||||
|
||||
@ -90,34 +90,7 @@ LRESULT ImGuiHelper::WndProc(HWND hWnd, UINT msg, WPARAM wParam,
|
||||
PDEV_BROADCAST_HDR pHdr = reinterpret_cast<PDEV_BROADCAST_HDR>(lParam);
|
||||
switch (wParam) {
|
||||
case DBT_DEVICEARRIVAL:
|
||||
if (pHdr->dbch_devicetype == DBT_DEVTYP_PORT) {
|
||||
PDEV_BROADCAST_PORT pPort =
|
||||
reinterpret_cast<PDEV_BROADCAST_PORT>(pHdr);
|
||||
spdlog::log(spdlog::level::debug,
|
||||
std::format("port: [{}] add", pPort->dbcp_name));
|
||||
ComKit::FlushLog();
|
||||
ComKit::GetAllComPortNames();
|
||||
ComKit::Work();
|
||||
} else {
|
||||
spdlog::log(spdlog::level::debug,
|
||||
std::format("port: other device [{}] add",
|
||||
pHdr->dbch_devicetype));
|
||||
}
|
||||
break;
|
||||
case DBT_DEVICEREMOVECOMPLETE:
|
||||
if (pHdr->dbch_devicetype == DBT_DEVTYP_PORT) {
|
||||
PDEV_BROADCAST_PORT pPort =
|
||||
reinterpret_cast<PDEV_BROADCAST_PORT>(pHdr);
|
||||
spdlog::log(
|
||||
spdlog::level::debug,
|
||||
std::format("port: [{}] removed", pPort->dbcp_name));
|
||||
ComKit::FlushLog();
|
||||
ComKit::GetAllComPortNames();
|
||||
} else {
|
||||
spdlog::log(spdlog::level::debug,
|
||||
std::format("port: other device [{}] add",
|
||||
pHdr->dbch_devicetype));
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user