3

在半双工串行端口上设计完全异步 IO 时，我需要您的建议。目前我有一个阅读器线程和许多由信号量和互斥锁控制的编写器线程。现在我想通过消除线程来简化同步。主要问题是串口 IO 有一个奇怪的行为。

read我需要做的就是确保write系统调用只阻塞调用线程，直到 IO 操作实际完成。我假设read默认情况下是阻塞系统调用。虽然我得到-1了回报read。有一个奇怪的EBUSY错误，我没有描述。当前代码：

bool SerialManager::initialize(const PortType& portType, const size_t& number)
{
// Open Serial port (/dev/ttyS2 in this case)
fd = open(portName.str().c_str(), O_RDWR ); //O_NOCTTY
if (fd < 0) // if open is not successful
{
    cerr << ERROR << "Unable to open `" << portName << "'." << endl;
    return false;
}
else
{
    cout << INFO << "Port " << portName.str() << " successfully opened."
            << endl;
    cout << INFO << "Configuring port..." << endl;
    fcntl(fd, F_SETFL,~O_NONBLOCK);
    struct termios port_settings; // structure to store the port settings in
    cfsetispeed(&port_settings, B38400); // set baud rate
    cfsetospeed(&port_settings, B38400); // set baud rate
    port_settings.c_cflag |= CLOCAL | CREAD;
    port_settings.c_cflag &= ~CRTSCTS; // disable H/W flow control
    port_settings.c_lflag &= ~( ISIG | // disable SIGxxxx signals
            IEXTEN | // disable extended functions
            ECHO | ECHOE); // disable all auto-echo functions
    port_settings.c_lflag &= ~ICANON ; // raw mode
    port_settings.c_oflag &= ~OPOST; // raw output
    port_settings.c_iflag &= ~(IXON | IXOFF | IXANY); // disable S/W flow control;
    port_settings.c_cc[VTIME] = 20; // wait 0.1 second to get data
    port_settings.c_cc[VMIN] = 0;

    port_settings.c_cflag = (port_settings.c_cflag &= ~CSIZE) | CS8; // set data byte size
    port_settings.c_cflag &= ~CSTOPB; // set stop bit 1
    port_settings.c_cflag &= ~PARENB; // set no parity
    port_settings.c_iflag |= IGNPAR; // ignore parity
    port_settings.c_iflag &= ~(INPCK | ISTRIP | PARMRK);

    // Set
    if (tcsetattr(fd, TCSANOW, &port_settings) < 0)
    {
        cerr << ERROR << "Unable to configure serial port." << endl;
        return false;
    }
    else
    {
        cout << INFO << "Port `" << portName.str()
                << "' configuration was successful." << endl;
            return true;
    }
}
}

写入数据：

int SerialManager::asyncWriteData(const byte* data, const size_t& size)
{
    int writeSize = write(fd, data, size);
    return writeSize;
}

供阅读：

void SerialManager::asyncRead(byte* buffer, const size_t& size, bool& ok)
{
    byte temp[256];
    ssize_t packetSize = read(fd, temp, 256);
    if (packetSize > 0)
    {
        for (size_t i = 0; i < size; ++i)
            buffer[i] = temp[i];
        ok = true;
    }
    cout << errno << endl;
    perror("Error occured: "); // <=== Here I'm getting EBUSY (code 16)
    ok = false;
}

SerialManager在外面使用类：

....
word checksum = this->id + 0x2C;
checksum = ~checksum;
// Send read command
byte command[] =
{ 0xff, // heading
        0xff, // ~
        this->id, // id of actuator
        0x04, // length
        0x02, // instruction: read
        0x24, // start address: present position
        0x02, // data length
        static_cast<byte>(checksum) //checksum
        };
SerialManager::lockPort(); // lock a mutex to avoid collitions
int numbytes = SerialManager::asyncWriteData(command, 8);
if (numbytes < 0)
{
    cerr << ERROR << "Could not write to serial port." << endl;
    return 0;
}
cout << INFO << numbytes << " bytes has been written." << endl;
for (size_t i = 0; i < 8; ++i)
{
    cout << hex << setfill('0') << setw(2) << (int) command[i] << ' ';
}
cout << endl;

byte* data = new byte[8];
bool ok;
// Here I need to make sure data write is completed before start reading
SerialManager::asyncRead(data, 8, ok);
if (ok)
{
    word position = data[5] + (static_cast<word>(data[6]) << 8);
    return position;
}
else
{
    cerr << ERROR << "Unable to read data from serial port..." << endl;
    return -1;
}
SerialManager::unlockPort(); // Unlock previously locked mutex
....

更新：

我删除了没有意义的读者线程。因为我们有一条无法控制传输的半双工线路。同步IO有两个问题：

  1. 从控制器向执行器发送很长的数据，当数据在端口上时，第一个执行器没有响应： 第一的

  2. 一个执行器可能会响应，而另一个执行器的数据未完全传输 第二

也EBUSY可以通过添加fsyncafter来解决问题write。这就是我需要的。（一个阻塞write）：

int SerialManager::asyncWriteData(const byte* data, const size_t& size)
{
    ssize_t packetSize = write(fd, data, size);
    if (packetSize > 0)
    {
        fsync(fd);
    }
    return packetSize;
}

来自人 fsync：

fsync() 将文件描述符 fd 引用的文件的所有修改的内核数据（即修改的缓冲区缓存页面）传输（“刷新”）到该文件所在的磁盘设备（或其他永久存储设备）。呼叫阻塞，直到设备报告传输已完成。它还刷新与文件关联的元数据信息

4

1 回答 1

1

我怀疑这回答了你的问题，但我认为它会有所帮助。

在 void SerialManager::asyncRead(byte*, const size_t&, bool&) 中有两个错误：

  1. 当 read 返回成功时，您正在使用 errno 的值（并使用 perror 基于它打印消息），而不仅仅是当它出错时（返回值 < 0）。成功时，不指定 errno 具有任何特定值。所以你有效地使用了垃圾数据；你得到的 EBUSY 可能没有任何意义。errno 仅在发生特定错误时被定义为具有特定值。请参阅 Linux 系统上的“man errno”，在我的 Debian 系统上的相关部分中说：“它的值仅在调用的返回值指示错误时才有意义（即，大多数系统调用为 -1；-1或大多数库函数中的NULL）；成功的函数允许更改errno。”。注意“被允许”，而不是“必须”。

  2. 您读入临时缓冲区，然后将其逐字节复制到调用者传递的目标缓冲区中。这是对 CPU 周期和内存带宽的毫无意义的浪费。你可以直接读入调用者的缓冲区。即使您必须（出于某种奇怪的原因）读入临时缓冲区然后将其复制到其他地方，您也应该使用 memcpy(3) 或 memmove(3) 将其复制到其他地方，而不是使用您自己的逐字节循环。

关于设计，当只有一个串行端口时，我不明白有多个读取器或写入器的意义。您是否正在尝试实现并行性？我看不出你怎么能，只有一个串口。如果你想要异步而不是并行，你应该研究 fcntl(fd, F_SETFL, existing_flags & O_ASYNC) （尽管信号相当陈旧和丑陋），或者可能只是将 fd 设置为非阻塞，然后在内部事件中调用 select()应用程序的循环并处理任何可用的 I/O（如果有）。

希望这可以帮助！

于 2013-11-28T13:07:12.393 回答