|
|
#include <algorithm>
|
|
|
|
|
|
#if !defined(_WIN32) && !defined(__OpenBSD__) && !defined(__FreeBSD__)
|
|
|
#include <alloca.h>
|
|
|
#endif
|
|
|
|
|
|
#include "serial/serial.h"
|
|
|
|
|
|
#include "serial/impl/unix.h"
|
|
|
|
|
|
using std::invalid_argument;
|
|
|
using std::min;
|
|
|
using std::numeric_limits;
|
|
|
using std::size_t;
|
|
|
using std::string;
|
|
|
using std::vector;
|
|
|
|
|
|
using serial::bytesize_t;
|
|
|
using serial::flowcontrol_t;
|
|
|
using serial::IOException;
|
|
|
using serial::parity_t;
|
|
|
using serial::Serial;
|
|
|
using serial::SerialException;
|
|
|
using serial::stopbits_t;
|
|
|
|
|
|
class Serial::ScopedReadLock {
|
|
|
public:
|
|
|
// 构造函数，传入串行实现类指针，并获取读锁
|
|
|
ScopedReadLock(SerialImpl *pimpl) : pimpl_(pimpl) {
|
|
|
this->pimpl_->readLock();
|
|
|
}
|
|
|
// 析构函数，释放读锁
|
|
|
~ScopedReadLock() { this->pimpl_->readUnlock(); }
|
|
|
|
|
|
private:
|
|
|
// 禁用复制构造函数
|
|
|
ScopedReadLock(const ScopedReadLock &);
|
|
|
// 禁用赋值操作符
|
|
|
const ScopedReadLock &operator=(ScopedReadLock);
|
|
|
|
|
|
SerialImpl *pimpl_;
|
|
|
};
|
|
|
|
|
|
// 这是一个私有的类定义部分，可能是一个互斥锁封装类
|
|
|
class ScopedWriteLock {
|
|
|
private:
|
|
|
// 禁用拷贝构造函数，避免对象被误拷贝
|
|
|
// Disable copy constructors there
|
|
|
ScopedWriteLock(const ScopedWriteLock &); // 删除此函数或声明为=delete
|
|
|
|
|
|
// 禁用赋值运算符，避免对象被误赋值
|
|
|
const ScopedWriteLock &operator=(ScopedWriteLock); // 缺少引用符号，应改为const ScopedWriteLock& operator=(const ScopedWriteLock&) = delete;
|
|
|
|
|
|
// 指向实现类的指针，使用了Pimpl（Pointer to Implementation）技术
|
|
|
SerialImpl *pimpl_;
|
|
|
};
|
|
|
|
|
|
// Serial类定义，可能是一个串口通信类
|
|
|
class Serial {
|
|
|
public:
|
|
|
// 构造函数，初始化串口设置
|
|
|
Serial(const string &port, uint32_t baudrate, serial::Timeout timeout,
|
|
|
bytesize_t bytesize, parity_t parity, stopbits_t stopbits,
|
|
|
flowcontrol_t flowcontrol)
|
|
|
: pimpl_(new SerialImpl(port, baudrate, bytesize, parity, stopbits,
|
|
|
flowcontrol)) {
|
|
|
pimpl_->setTimeout(timeout); // 设置超时时间
|
|
|
}
|
|
|
|
|
|
// 析构函数，释放资源
|
|
|
~Serial() { delete pimpl_; }
|
|
|
|
|
|
// 打开串口
|
|
|
void open() { pimpl_->open(); }
|
|
|
|
|
|
// 关闭串口
|
|
|
void close() { pimpl_->close(); }
|
|
|
|
|
|
// 检查串口是否打开
|
|
|
bool isOpen() const { return pimpl_->isOpen(); }
|
|
|
|
|
|
// 获取串口上可用的字节数
|
|
|
size_t available() { return pimpl_->available(); }
|
|
|
|
|
|
// 等待串口可读
|
|
|
bool waitReadable() {
|
|
|
serial::Timeout timeout(pimpl_->getTimeout());
|
|
|
return pimpl_->waitReadable(timeout.read_timeout_constant);
|
|
|
}
|
|
|
|
|
|
// 等待特定数量的字节时间（可能是为了同步）
|
|
|
void waitByteTimes(size_t count) { pimpl_->waitByteTimes(count); }
|
|
|
|
|
|
// 从串口读取数据（无锁）
|
|
|
size_t read_(uint8_t *buffer, size_t size) {
|
|
|
return this->pimpl_->read(buffer, size);
|
|
|
}
|
|
|
|
|
|
// 从串口读取数据（使用ScopedReadLock加锁）
|
|
|
size_t read(uint8_t *buffer, size_t size) {
|
|
|
ScopedReadLock lock(this->pimpl_); // 假设ScopedReadLock是一个读取锁类
|
|
|
return this->pimpl_->read(buffer, size);
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
// 指向实现类的指针，使用了Pimpl（Pointer to Implementation）技术
|
|
|
SerialImpl *pimpl_;
|
|
|
};
|
|
|
|
|
|
size_t Serial::read(std::vector<uint8_t> &buffer, size_t size) {
|
|
|
// 创建一个读锁，保证读操作的安全性
|
|
|
ScopedReadLock lock(this->pimpl_);
|
|
|
// 分配一个新的缓冲区来存储读取的数据
|
|
|
uint8_t *buffer_ = new uint8_t[size];
|
|
|
// 初始化已读取的字节数为0
|
|
|
size_t bytes_read = 0;
|
|
|
|
|
|
try {
|
|
|
// 尝试从串行端口读取数据到缓冲区
|
|
|
bytes_read = this->pimpl_->read(buffer_, size);
|
|
|
} catch (const std::exception &e) {
|
|
|
// 如果读取过程中发生异常，删除缓冲区并重新抛出异常
|
|
|
delete[] buffer_;
|
|
|
throw;
|
|
|
}
|
|
|
|
|
|
// 将读取的数据插入到传入的vector中
|
|
|
buffer.insert(buffer.end(), buffer_, buffer_ + bytes_read);
|
|
|
// 删除临时缓冲区
|
|
|
delete[] buffer_;
|
|
|
// 返回实际读取的字节数
|
|
|
return bytes_read;
|
|
|
}
|
|
|
|
|
|
size_t Serial::read(std::string &buffer, size_t size) {
|
|
|
// 创建一个读锁，保证读操作的安全性
|
|
|
ScopedReadLock lock(this->pimpl_);
|
|
|
// 分配一个新的缓冲区来存储读取的数据
|
|
|
uint8_t *buffer_ = new uint8_t[size];
|
|
|
// 初始化已读取的字节数为0
|
|
|
size_t bytes_read = 0;
|
|
|
try {
|
|
|
// 尝试从串行端口读取数据到缓冲区
|
|
|
bytes_read = this->pimpl_->read(buffer_, size);
|
|
|
} catch (const std::exception &e) {
|
|
|
// 如果读取过程中发生异常，删除缓冲区并重新抛出异常
|
|
|
delete[] buffer_;
|
|
|
throw;
|
|
|
}
|
|
|
// 将读取的数据追加到传入的string中
|
|
|
buffer.append(reinterpret_cast<const char *>(buffer_), bytes_read);
|
|
|
// 删除临时缓冲区
|
|
|
delete[] buffer_;
|
|
|
// 返回实际读取的字节数
|
|
|
return bytes_read;
|
|
|
}
|
|
|
|
|
|
|
|
|
// Serial类中的成员函数，用于读取指定字节数并返回字符串
|
|
|
string Serial::read(size_t size) {
|
|
|
std::string buffer; // 创建一个字符串用于存储读取的数据
|
|
|
buffer.resize(size); // 预分配足够的存储空间
|
|
|
this->read(&buffer[0], size); // 调用重载的read函数，将读取的数据填充到buffer中
|
|
|
return buffer; // 返回读取到的字符串
|
|
|
}
|
|
|
|
|
|
// Serial类中的成员函数，用于读取一行数据并返回字符串
|
|
|
size_t Serial::readline(string &buffer, size_t size, string eol) {
|
|
|
ScopedReadLock lock(this->pimpl_); // 使用ScopedReadLock对读取操作进行加锁
|
|
|
size_t eol_len = eol.length(); // 获取行结束符的长度
|
|
|
// 使用alloca函数在栈上动态分配足够大小的字节数组来存储读取的数据
|
|
|
// 注意：alloca函数不是C++标准库的一部分，并且在某些平台上可能不被支持或存在安全问题
|
|
|
// 在实践中，更推荐使用std::vector<uint8_t>或std::array<uint8_t, N>来替代
|
|
|
uint8_t *buffer_ = static_cast<uint8_t *>(alloca(size * sizeof(uint8_t)));
|
|
|
size_t read_so_far = 0; // 记录已经读取的字节数
|
|
|
while (true) {
|
|
|
// 尝试读取一个字节
|
|
|
size_t bytes_read = this->read_(buffer_ + read_so_far, 1);
|
|
|
read_so_far += bytes_read;
|
|
|
// 如果没有读取到任何数据（可能是超时），则退出循环
|
|
|
if (bytes_read == 0) {
|
|
|
break; // 读取1字节时发生超时
|
|
|
}
|
|
|
// 如果已经读取的字节数还不足以构成一个完整的行结束符，则继续读取
|
|
|
if (read_so_far < eol_len)
|
|
|
continue;
|
|
|
// 检查当前读取到的数据是否包含行结束符
|
|
|
if (string(reinterpret_cast<const char *>(buffer_ + read_so_far - eol_len),
|
|
|
eol_len) == eol) {
|
|
|
break; // 找到行结束符
|
|
|
}
|
|
|
// 如果已经读取了最大字节数，则退出循环
|
|
|
if (read_so_far == size) {
|
|
|
break; // 达到最大读取长度
|
|
|
}
|
|
|
}
|
|
|
// 将读取到的数据转换为字符串并追加到传入的buffer中
|
|
|
buffer.append(reinterpret_cast<const char *>(buffer_), read_so_far);
|
|
|
// 返回实际读取的字节数
|
|
|
return read_so_far;
|
|
|
}
|
|
|
|
|
|
// Serial类中的成员函数，读取一行数据并返回字符串（使用临时字符串对象）
|
|
|
string Serial::readline(size_t size, string eol) {
|
|
|
std::string buffer; // 创建一个临时字符串对象
|
|
|
this->readline(buffer, size, eol); // 调用重载的readline函数
|
|
|
return buffer; // 返回读取到的字符串
|
|
|
}
|
|
|
|
|
|
// 中文注释：
|
|
|
// Serial::read函数：
|
|
|
// 读取指定字节数的数据，并将数据转换为字符串返回。
|
|
|
//
|
|
|
// Serial::readline函数（带引用参数）：
|
|
|
// 读取一行数据，直到遇到指定的行结束符或者读取了指定数量的字节或者发生超时。
|
|
|
// 读取到的数据会被追加到传入的字符串buffer中，并返回实际读取的字节数。
|
|
|
// 该函数使用ScopedReadLock进行加锁操作，以确保在多线程环境中线程安全。
|
|
|
//
|
|
|
// Serial::readline函数（返回字符串）：
|
|
|
// 与带引用参数的readline函数功能相同，但返回的是一个新创建的字符串对象。
|
|
|
// 内部使用了一个临时字符串对象来存储读取到的数据。
|
|
|
|
|
|
// Serial类中的成员函数，用于从串口读取多行数据并返回一个string向量
|
|
|
vector<string> Serial::readlines(size_t size, string eol) {
|
|
|
ScopedReadLock lock(this->pimpl_); // 使用ScopedReadLock对读取操作进行加锁
|
|
|
std::vector<std::string> lines; // 创建一个字符串向量来存储读取到的多行数据
|
|
|
size_t eol_len = eol.length(); // 获取行结束符的长度
|
|
|
|
|
|
// 注意：虽然这里使用了alloca来分配内存，但在C++中更推荐使用std::vector或std::array
|
|
|
// 这里为了保持与原始代码的一致性，仍然使用alloca
|
|
|
uint8_t *buffer_ = static_cast<uint8_t *>(alloca(size * sizeof(uint8_t)));
|
|
|
size_t read_so_far = 0; // 记录已经读取的字节数
|
|
|
size_t start_of_line = 0; // 记录当前行的起始位置
|
|
|
|
|
|
// 循环读取数据，直到达到最大读取长度或发生超时
|
|
|
while (read_so_far < size) {
|
|
|
// 尝试读取一个字节
|
|
|
size_t bytes_read = this->read_(buffer_ + read_so_far, 1);
|
|
|
read_so_far += bytes_read;
|
|
|
|
|
|
// 如果读取失败（可能是超时）
|
|
|
if (bytes_read == 0) {
|
|
|
// 如果当前行有数据（即start_of_line不等于当前位置），则添加到lines中
|
|
|
if (start_of_line != read_so_far) {
|
|
|
lines.push_back(
|
|
|
string(reinterpret_cast<const char *>(buffer_ + start_of_line),
|
|
|
read_so_far - start_of_line));
|
|
|
}
|
|
|
break; // 读取1字节时发生超时，退出循环
|
|
|
}
|
|
|
|
|
|
// 如果当前读取的字节数还不足以构成一个完整的行结束符，则继续读取
|
|
|
if (read_so_far < eol_len)
|
|
|
continue;
|
|
|
|
|
|
// 检查当前读取到的数据是否包含行结束符
|
|
|
if (string(reinterpret_cast<const char *>(buffer_ + read_so_far - eol_len),
|
|
|
eol_len) == eol) {
|
|
|
// 发现行结束符，将当前行添加到lines中
|
|
|
lines.push_back(
|
|
|
string(reinterpret_cast<const char *>(buffer_ + start_of_line),
|
|
|
read_so_far - eol_len));
|
|
|
// 更新当前行的起始位置为行结束符之后
|
|
|
start_of_line = read_so_far;
|
|
|
}
|
|
|
|
|
|
// 如果已经读取了最大字节数，则退出循环
|
|
|
if (read_so_far == size) {
|
|
|
// 如果当前行有数据（即start_of_line不等于当前位置），则添加到lines中
|
|
|
if (start_of_line != read_so_far) {
|
|
|
lines.push_back(
|
|
|
string(reinterpret_cast<const char *>(buffer_ + start_of_line),
|
|
|
read_so_far - start_of_line));
|
|
|
}
|
|
|
break; // 达到最大读取长度，退出循环
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 返回读取到的多行数据
|
|
|
return lines;
|
|
|
}
|
|
|
|
|
|
size_t Serial::write(const string &data) {
|
|
|
ScopedWriteLock lock(this->pimpl_);
|
|
|
return this->write_(reinterpret_cast<const uint8_t *>(data.c_str()),
|
|
|
data.length());
|
|
|
}
|
|
|
|
|
|
size_t Serial::write(const std::vector<uint8_t> &data) {
|
|
|
ScopedWriteLock lock(this->pimpl_);
|
|
|
return this->write_(&data[0], data.size());
|
|
|
}
|
|
|
|
|
|
size_t Serial::write(const uint8_t *data, size_t size) {
|
|
|
ScopedWriteLock lock(this->pimpl_);
|
|
|
return this->write_(data, size);
|
|
|
}
|
|
|
|
|
|
size_t Serial::write_(const uint8_t *data, size_t length) {
|
|
|
return pimpl_->write(data, length);
|
|
|
}
|
|
|
|
|
|
void Serial::setPort(const string &port) {
|
|
|
ScopedReadLock rlock(this->pimpl_);
|
|
|
ScopedWriteLock wlock(this->pimpl_);
|
|
|
bool was_open = pimpl_->isOpen();
|
|
|
if (was_open)
|
|
|
close();
|
|
|
pimpl_->setPort(port);
|
|
|
if (was_open)
|
|
|
open();
|
|
|
}
|
|
|
|
|
|
string Serial::getPort() const { return pimpl_->getPort(); }
|
|
|
|
|
|
void Serial::setTimeout(serial::Timeout &timeout) {
|
|
|
pimpl_->setTimeout(timeout);
|
|
|
}
|
|
|
|
|
|
serial::Timeout Serial::getTimeout() const { return pimpl_->getTimeout(); }
|
|
|
|
|
|
void Serial::setBaudrate(uint32_t baudrate) { pimpl_->setBaudrate(baudrate); }
|
|
|
|
|
|
uint32_t Serial::getBaudrate() const { return uint32_t(pimpl_->getBaudrate()); }
|
|
|
|
|
|
void Serial::setBytesize(bytesize_t bytesize) { pimpl_->setBytesize(bytesize); }
|
|
|
|
|
|
bytesize_t Serial::getBytesize() const { return pimpl_->getBytesize(); }
|
|
|
|
|
|
void Serial::setParity(parity_t parity) { pimpl_->setParity(parity); }
|
|
|
|
|
|
parity_t Serial::getParity() const { return pimpl_->getParity(); }
|
|
|
|
|
|
void Serial::setStopbits(stopbits_t stopbits) { pimpl_->setStopbits(stopbits); }
|
|
|
|
|
|
stopbits_t Serial::getStopbits() const { return pimpl_->getStopbits(); }
|
|
|
|
|
|
void Serial::setFlowcontrol(flowcontrol_t flowcontrol) {
|
|
|
pimpl_->setFlowcontrol(flowcontrol);
|
|
|
}
|
|
|
|
|
|
flowcontrol_t Serial::getFlowcontrol() const {
|
|
|
return pimpl_->getFlowcontrol();
|
|
|
}
|
|
|
|
|
|
void Serial::flush() {
|
|
|
ScopedReadLock rlock(this->pimpl_);
|
|
|
ScopedWriteLock wlock(this->pimpl_);
|
|
|
pimpl_->flush();
|
|
|
}
|
|
|
|
|
|
void Serial::flushInput() {
|
|
|
ScopedReadLock lock(this->pimpl_);
|
|
|
pimpl_->flushInput();
|
|
|
}
|
|
|
|
|
|
void Serial::flushOutput() {
|
|
|
ScopedWriteLock lock(this->pimpl_);
|
|
|
pimpl_->flushOutput();
|
|
|
}
|
|
|
|
|
|
void Serial::sendBreak(int duration) { pimpl_->sendBreak(duration); }
|
|
|
|
|
|
void Serial::setBreak(bool level) { pimpl_->setBreak(level); }
|
|
|
|
|
|
void Serial::setRTS(bool level) { pimpl_->setRTS(level); }
|
|
|
|
|
|
void Serial::setDTR(bool level) { pimpl_->setDTR(level); }
|
|
|
|
|
|
bool Serial::waitForChange() { return pimpl_->waitForChange(); }
|
|
|
|
|
|
bool Serial::getCTS() { return pimpl_->getCTS(); }
|
|
|
|
|
|
bool Serial::getDSR() { return pimpl_->getDSR(); }
|
|
|
|
|
|
bool Serial::getRI() { return pimpl_->getRI(); }
|
|
|
|
|
|
bool Serial::getCD() { return pimpl_->getCD(); }
|
