jie/serial
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加相关函数

Browse Source
This commit is contained in:
JIe
2024-11-01 15:22:42 +08:00
parent 6ec5ffd22f
commit 6605f0604a
1 changed files with 258 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

486
include/serial.h
View File

@@ -22,267 +22,297 @@ namespace ranges = std::ranges;
namespace views = std::views; namespace views = std::views;
namespace serial { namespace serial {
template <typename... Types> struct _StrongType {}; template <typename... Types> struct _StrongType {};
template <typename T> struct _StrongType<T> { template <typename T> struct _StrongType<T> {
using Type = T; using Type = T;
}; };
template <typename Ta, typename Tb> struct _StrongType<Ta, Tb> { template <typename Ta, typename Tb> struct _StrongType<Ta, Tb> {
using Type = decltype(true ? std::declval<Ta>() : std::declval<Tb>()); using Type = decltype(true ? std::declval<Ta>() : std::declval<Tb>());
}; };
template <typename T, typename... Types> struct _StrongType<T, Types...> { template <typename T, typename... Types> struct _StrongType<T, Types...> {
using Type = using Type =
typename _StrongType<T, typename _StrongType<Types...>::Type>::Type; typename _StrongType<T, typename _StrongType<Types...>::Type>::Type;
}; };
template <typename... Types> template <typename... Types>
using _strongType_t = typename _StrongType<Types...>::Type; using _strongType_t = typename _StrongType<Types...>::Type;
template <typename... Args> struct _IsCastable {}; template <typename... Args> struct _IsCastable {};
template <typename T> struct _IsCastable<T> { template <typename T> struct _IsCastable<T> {
static constexpr bool value = true; static constexpr bool value = true;
using Type = T; using Type = T;
}; };
template <typename T, typename U> struct _IsCastable<T, U> { template <typename T, typename U> struct _IsCastable<T, U> {
using __TRUE = char; using __TRUE = char;
using __FALSE = struct { using __FALSE = struct {
char _[2]; char _[2];
}; };
static consteval __TRUE __TEST(U); static consteval __TRUE __TEST(U);
static consteval __FALSE __TEST(...); static consteval __FALSE __TEST(...);
static constexpr bool value = static constexpr bool value =
sizeof(__TEST(std::declval<T>())) == sizeof(__TRUE); sizeof(__TEST(std::declval<T>())) == sizeof(__TRUE);
using Type = std::conditional_t<value, U, void>; using Type = std::conditional_t<value, U, void>;
}; };
template <typename T, typename... Args> struct _IsCastable<T, Args...> { template <typename T, typename... Args> struct _IsCastable<T, Args...> {
static constexpr bool value = static constexpr bool value =
_IsCastable<T, typename _IsCastable<Args...>::Type>::value; _IsCastable<T, typename _IsCastable<Args...>::Type>::value;
using Type = using Type =
std::conditional_t<value, typename _IsCastable<Args...>::Type, void>; std::conditional_t<value, typename _IsCastable<Args...>::Type, void>;
}; };
template <typename T> template <typename T>
concept _SupportString = requires { concept _SupportString = requires {
_IsCastable<T, const char *, char *, std::string, std::string_view>::value; _IsCastable<T, const char*, char*, std::string, std::string_view>::value;
}; };
template <_SupportString T> [[maybe_unused]] std::string _to_string(T &&str) { template <_SupportString T> [[maybe_unused]] std::string _to_string(T&& str) {
if constexpr (std::is_same_v<std::decay_t<T>, std::string>) { if constexpr (std::is_same_v<std::decay_t<T>, std::string>) {
return str; 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>, std::string_view>) {
} else if constexpr (std::is_same_v<std::decay_t<T>, const char *>) { return std::move(std::string(str.data()));
return std::string(str); }
} 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) #if defined(_WIN32) || defined(_WIN64)
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) { ranges::for_each(views::iota(1, 256), [&](int i) {
std::format_to(std::back_inserter(comname), "\\\\.\\COM{}", 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(showname), "COM{}", i);
const HANDLE m_handle = ::CreateFileA( const HANDLE m_handle = ::CreateFileA(
comname.c_str(), static_cast<DWORD>(GENERIC_WRITE) | GENERIC_READ, comname.c_str(), static_cast<DWORD>(GENERIC_WRITE) | GENERIC_READ,
0U, nullptr, OPEN_EXISTING, 0U, nullptr); 0U, nullptr, OPEN_EXISTING, 0U, nullptr);
if (m_handle != INVALID_HANDLE_VALUE) { if (m_handle != INVALID_HANDLE_VALUE) {
portArray.push_back(showname); portArray.push_back(showname);
CloseHandle(m_handle); CloseHandle(m_handle);
} }
comname.clear(); comname.clear();
showname.clear(); showname.clear();
}); });
return portArray; return portArray;
#elif defined(__linux__) #elif defined(__linux__)
#endif #endif
} }
enum class [[maybe_unused]] SerialErrorCode { enum class [[maybe_unused]] SerialErrorCode {
SUCCESS, SUCCESS,
TIMEOUT, TIMEOUT,
SETTIMEOUTERROR, SETTIMEOUTERROR,
WRITEINGERROR, WRITEINGERROR,
READINGERROR, READINGERROR,
}; };
enum SerialDataBits { enum SerialDataBits {
DATABIT_5 = 0, DATABIT_5 = 0,
DATABIT_6, DATABIT_6,
DATABIT_7, DATABIT_7,
DATABIT_8, DATABIT_8,
DATABIT_16, DATABIT_16,
}; };
enum SerialStopBits { enum SerialStopBits {
STOPBIT_1 = 0, STOPBIT_1 = 0,
STOPBIT_1_5, STOPBIT_1_5,
STOPBIT_2, STOPBIT_2,
}; };
enum SerialParity { enum SerialParity {
SERIAL_PARITY_NONE = 0, SERIAL_PARITY_NONE = 0,
SERIAL_PARITY_EVEN, SERIAL_PARITY_EVEN,
SERIAL_PARITY_ODD, SERIAL_PARITY_ODD,
SERIAL_PARITY_MARK, SERIAL_PARITY_MARK,
SERIAL_PARITY_SPACE, SERIAL_PARITY_SPACE,
}; };
class Serial { class Serial {
private: private:
serialib ser; serialib ser;
const char *endChar = "\r\n"; const char* endChar = "\r\n";
std::function<void(const std::string &)> logCallBack; std::function<void(const std::string&)> logCallBack;
bool removeEcho = true; // 剔除回显 bool removeEcho = true; // 剔除回显
public: public:
Serial() = default; Serial() = default;
~Serial() { CloseDevice(); } ~Serial() { CloseDevice(); }
Serial(const Serial &other) = delete; Serial(const Serial& other) = delete;
Serial(Serial &&other) = delete; Serial(Serial&& other) = delete;
Serial &operator=(const Serial &other) = delete; Serial& operator=(const Serial& other) = delete;
Serial &operator=(Serial &&other) = delete; Serial& operator=(Serial&& other) = delete;
auto SetRemoveEcho(bool remove) { removeEcho = remove; } auto SetRemoveEcho(bool remove) { removeEcho = remove; }
auto SetDtr(bool flag) { return flag ? ser.setDTR() : ser.clearDTR(); } auto SetDtr(bool flag) { return flag ? ser.setDTR() : ser.clearDTR(); }
auto SetRts(bool flag) { return flag ? ser.setRTS() : ser.clearRTS(); } auto SetRts(bool flag) { return flag ? ser.setRTS() : ser.clearRTS(); }
static std::string GetTimeNow() { static std::string GetTimeNow() {
auto now = std::chrono::system_clock::now(); auto now = std::chrono::system_clock::now();
auto now_c = std::chrono::system_clock::to_time_t(now); auto now_c = std::chrono::system_clock::to_time_t(now);
char buffer[32]; char buffer[32];
auto _ = ctime_s(buffer, 32, &now_c); auto _ = ctime_s(buffer, 32, &now_c);
return buffer; return buffer;
} }
bool IsOpen() { return ser.isDeviceOpen(); } bool IsOpen() { return ser.isDeviceOpen(); }
template <_SupportString T> template <_SupportString T>
bool OpenDevice(T portName, unsigned int bauds = 115200, int delayTime = 0, bool OpenDevice(T portName, unsigned int bauds = 115200, int delayTime = 0,
SerialDataBits dataBits = SerialDataBits::DATABIT_8, SerialDataBits dataBits = SerialDataBits::DATABIT_8,
SerialStopBits stopBits = SerialStopBits::STOPBIT_1, SerialStopBits stopBits = SerialStopBits::STOPBIT_1,
SerialParity parity = SerialParity::SERIAL_PARITY_NONE) { SerialParity parity = SerialParity::SERIAL_PARITY_NONE) {
#if defined(_WIN32) || defined(__WIN64) #if defined(_WIN32) || defined(__WIN64)
std::string reallyPortName; std::string reallyPortName;
std::format_to(std::back_inserter(reallyPortName), "\\\\.\\{}", std::format_to(std::back_inserter(reallyPortName), "\\\\.\\{}",
portName); portName);
#elif defined(__linux__) #elif defined(__linux__)
std::string reallyPortName = std::string(portName); std::string reallyPortName = std::string(portName);
#endif #endif
std::this_thread::sleep_for(std::chrono::milliseconds(delayTime)); std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
if (ser.isDeviceOpen()) if (ser.isDeviceOpen())
ser.closeDevice(); ser.closeDevice();
int code = ser.openDevice(reallyPortName.c_str(), bauds, int code = ser.openDevice(reallyPortName.c_str(), bauds,
static_cast<::SerialDataBits>(dataBits), static_cast<::SerialDataBits>(dataBits),
static_cast<::SerialParity>(parity), static_cast<::SerialParity>(parity),
static_cast<::SerialStopBits>(stopBits)); static_cast<::SerialStopBits>(stopBits));
if (code == 1) { if (code == 1) {
return true; return true;
} else { }
return false; else {
} return false;
} }
}
void Log(const std::string &log) const { void Log(const std::string& log) const {
if (logCallBack) { if (logCallBack) {
auto msg = GetTimeNow() + " " + log; auto msg = GetTimeNow() + " " + log;
logCallBack(msg); logCallBack(msg);
} }
} }
void void
SetLogCallBack(const std::function<void(const std::string &)> &callBack) { SetLogCallBack(const std::function<void(const std::string&)>& callBack) {
logCallBack = callBack; logCallBack = callBack;
} }
void CloseDevice() { void CloseDevice() {
if (!ser.isDeviceOpen()) if (!ser.isDeviceOpen())
return; return;
ser.closeDevice(); ser.closeDevice();
} }
template <_SupportString T> template <_SupportString T>
std::expected<std::string, SerialErrorCode> std::expected<std::string, SerialErrorCode>
DelayGetResponse(int delayTime, T command, int timeout = 50) { DelayGetResponse(int delayTime, T command, int timeout = 50) {
std::this_thread::sleep_for(std::chrono::milliseconds(delayTime)); std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
return GetAtResponse(command, timeout); return GetAtResponse(command, timeout);
} }
template <int repeatTime = 5, int delayTime = 200, int timeout = 200, template <int repeatTime = 5, int delayTime = 200, int timeout = 200,
_SupportString T, _SupportString... Args> _SupportString T, _SupportString... Args>
bool GetAtUntilRepeat(T command, Args... args) { bool GetAtUntilRepeat(T command, Args... args) {
std::stringstream ss; std::stringstream ss;
int i = 0; int i = 0;
while (i++ < repeatTime) { while (i++ < repeatTime) {
ss.str(""); ss.str("");
ss << "Count: " << i << "\n"; ss << "Count: " << i << "\n";
Log(ss.str()); Log(ss.str());
std::this_thread::sleep_for(std::chrono::milliseconds(delayTime)); std::this_thread::sleep_for(std::chrono::milliseconds(delayTime));
if (GetAtUntil<timeout>(command, args...)) if (GetAtUntil<timeout>(command, args...))
return true; return true;
} }
return false; return false;
} }
template <_SupportString T> 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(); ser.flushReceiver();
std::string reallyCommand = std::string(command) + endChar; std::string reallyCommand = std::string(command) + endChar;
ser.writeString(reallyCommand.c_str()); ser.writeString(reallyCommand.c_str());
Log("Send: " + reallyCommand); Log("Send: " + reallyCommand);
std::this_thread::sleep_for(10ms); std::this_thread::sleep_for(10ms);
auto availableSize = ser.available(); auto availableSize = ser.available();
auto buffer = std::make_unique<char[]>(availableSize + 1); auto buffer = std::make_unique<char[]>(availableSize + 1);
std::memset(buffer.get(), 0, availableSize); std::memset(buffer.get(), 0, availableSize);
auto size = ser.readBytes(buffer.get(), availableSize, timeout); auto size = ser.readBytes(buffer.get(), availableSize, timeout);
if (size > 0) { if (size > 0) {
buffer[size] = '\0'; buffer[size] = '\0';
std::string response = std::string(buffer.get()); std::string response = std::string(buffer.get());
Log("Receive: " + response); Log("Receive: " + response);
if (removeEcho) if (removeEcho)
response.replace(0, reallyCommand.length(), ""); response.replace(0, reallyCommand.length(), "");
return response; return response;
} }
return std::unexpected(SerialErrorCode::TIMEOUT); return std::unexpected(SerialErrorCode::TIMEOUT);
} }
template <_SupportString T> template <_SupportString T>
auto GetAtResponseRepeat(T command, int timeout = 200, int repeatTime = 1) auto GetAtResponseRepeat(T command, int timeout = 200, int repeatTime = 1)
-> void { -> void {
for (int i = 0; i <= repeatTime; i++) { for (int i = 0; i <= repeatTime; i++) {
auto _ = GetAtResponse(command, timeout); auto _ = GetAtResponse(command, timeout);
} }
} }
template <int timeout = 200, _SupportString T, _SupportString... Args> template <int timeout = 200, _SupportString T, _SupportString... Args>
bool GetAtUntil(T command, Args... expect) { bool GetAtUntil(T command, Args... expect) {
auto endTime = std::chrono::system_clock::now() + auto endTime = std::chrono::system_clock::now() +
std::chrono::milliseconds(timeout); std::chrono::milliseconds(timeout);
ser.flushReceiver(); ser.flushReceiver();
std::string reallyCommand = std::string(command) + endChar; std::string reallyCommand = std::string(command) + endChar;
ser.writeString(reallyCommand.c_str()); ser.writeString(reallyCommand.c_str());
Log("Send : " + reallyCommand); Log("Send : " + reallyCommand);
while (std::chrono::system_clock::now() < endTime) { while (std::chrono::system_clock::now() < endTime) {
std::this_thread::sleep_for(10ms); std::this_thread::sleep_for(10ms);
auto availableSize = ser.available(); auto availableSize = ser.available();
auto buffer = std::make_unique<char[]>(availableSize + 1); auto buffer = std::make_unique<char[]>(availableSize + 1);
auto size = ser.readBytes(buffer.get(), availableSize, timeout); auto size = ser.readBytes(buffer.get(), availableSize, timeout);
buffer[size] = '\0'; buffer[size] = '\0';
auto str = std::string(buffer.get()); auto str = std::string(buffer.get());
if (size > 0) if (size > 0)
Log("Receive: " + str); Log("Receive: " + str);
if (((str.find(expect) != std::string::npos) && ...)) { if (((str.find(expect) != std::string::npos) && ...)) {
return true; return true;
} }
} }
return false; 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 (((str.find(expect) != std::string::npos) && ...)) {
return resp;
}
}
return resp;
}
};
} // namespace serial } // namespace serial
#endif // SERIAL_H #endif // SERIAL_H