serialinterface.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
#include "serialinterface.h"
#include <xsens/xsportinfo.h>
#include <xsens/xscontrolline.h>

#include <errno.h>
#ifndef _WIN32
#include <unistd.h>  // close
#include <sys/ioctl.h>  // ioctl
#include <fcntl.h>  // open, O_RDWR
#include <string.h>  // strcpy
#include <sys/param.h>
#include <sys/file.h>
#include <stdarg.h>
#else
#include <winbase.h>
#include <io.h>
#endif

#ifndef _CRT_SECURE_NO_DEPRECATE
#define _CRT_SECURE_NO_DEPRECATE
#ifdef _WIN32
#pragma warning(disable : 4996)
#endif
#endif

// lint -emacro(534, FSEEK, FSEEK_R)
// lint -emacro({534}, FSEEK, FSEEK_R)
#ifdef _WIN32
#define FSEEK(x) _fseeki64(m_handle, x, SEEK_SET)
#define FSEEK_R(x) _fseeki64(m_handle, x, SEEK_END)
#define FTELL() _ftelli64(m_handle)
#else
#define FSEEK(x) fseeko(m_handle, x, SEEK_SET)
#define FSEEK_R(x) fseeko(m_handle, x, SEEK_END)
#define FTELL() ftello(m_handle)
#endif

// maybe log to nothing at this level
#ifdef LOG_CMT1
#include "xslog.h"
#define XDA1LOG_OBSOLETE XSENSLOG
#else
#define XDA1LOG_OBSOLETE(...) (void)0
#endif

//////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////// SerialInterface
////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////

//! \brief Default constructor, initializes all members to their default values.
SerialInterface::SerialInterface()
{
    m_port = 0;
    m_lastResult = XRV_OK;
    m_timeout = 0;
    m_endTime = 0;
    m_baudrate = XBR_Invalid;
    m_portname[0] = 0;
#ifdef _WIN32
    m_handle = INVALID_HANDLE_VALUE;
#else
    m_handle = -1;
    memset(&m_commState, 0, sizeof(m_commState));
#endif

    rx_log = nullptr;
    tx_log = nullptr;
}

//! Destructor, de-initializes, frees memory allocated for buffers, etc.
SerialInterface::~SerialInterface()
{
    try
    {
        closeLive();  // lint !e534
    }
    catch (...)
    {
    }
}

//! \brief Close the serial communication port.
XsResultValue SerialInterface::close(void) { return closeLive(); }
//! \brief Close the serial communication port.
XsResultValue SerialInterface::closeLive(void)
{
#ifdef LOG_RX_TX
    if (rx_log != nullptr) fclose(rx_log);
    if (tx_log != nullptr) fclose(tx_log);
    rx_log = nullptr;
    tx_log = nullptr;
#endif
    if (!isOpen()) return m_lastResult = XRV_NOPORTOPEN;

    m_lastResult = XRV_OK;
#ifdef _WIN32
    if (::FlushFileBuffers(m_handle))
    {
        // read all data before closing the handle, a Flush is not enough for
        // FTDI devices unfortunately
        // we first need to set the COMM timeouts to instantly return when no
        // more data is available
        COMMTIMEOUTS cto;
        if (::GetCommTimeouts(m_handle, &cto))
        {
            cto.ReadIntervalTimeout = MAXDWORD;
            cto.ReadTotalTimeoutConstant = 0;
            cto.ReadTotalTimeoutMultiplier = 0;
            if (::SetCommTimeouts(m_handle, &cto))
            {
                char buffer[1024];
                DWORD length;
                do
                {
                    if (!::ReadFile(m_handle, buffer, 1024, &length, nullptr))
                        break;
                } while (length > 0);
            }
            else
                m_lastResult = XRV_ERROR;
        }
        else
            m_lastResult = XRV_ERROR;
    }
    if (!::CloseHandle(m_handle)) m_lastResult = XRV_ERROR;
    m_handle = INVALID_HANDLE_VALUE;
#else
    flushData();
    ::close(m_handle);
    m_handle = -1;
#endif
    m_endTime = 0;

    return m_lastResult;
}

/*! \brief Manipulate the Serial control lines

    The function manipulates the serial control lines that are indicated by the
    mask parameter. Note that only the DTR and RTS lines can be set by win32.
    \param mask     Indicates which lines are to be manipulated and which
   should be
                    left alone.
    \param state    Contains the new state of the control lines.
    \returns XRV_OK if the function succeeded
*/
XsResultValue SerialInterface::escape(
    const XsControlLine mask, const XsControlLine state)
{
    // lint --e{655} bitwise operations are intended on these enums
    if (!isOpen()) return (m_lastResult = XRV_NOPORTOPEN);
#ifdef _WIN32
    BOOL rv = 0;
    if (mask & XCL_DTR)
    {
        if (state & XCL_DTR)
            rv = EscapeCommFunction(m_handle, SETDTR);
        else
            rv = EscapeCommFunction(m_handle, CLRDTR);
    }

    if (mask & XCL_RTS)
    {
        if (state & XCL_RTS)
            rv = EscapeCommFunction(m_handle, SETRTS);
        else
            rv = EscapeCommFunction(m_handle, CLRRTS);
    }
    if (rv)
        return m_lastResult = XRV_OK;
    else
        return m_lastResult = XRV_ERROR;
#else
    bool rv = true;
    int32_t status;
    if (mask & XCL_DTR)
    {
        if (ioctl(m_handle, TIOCMGET, &status) == -1)
        {
            if (state & XCL_DTR)
                status |= TIOCM_DTR;
            else
                status &= ~TIOCM_DTR;
            rv = (ioctl(m_handle, TIOCMSET, &status) == -1);
        }
        else
            rv = false;
    }
    if (rv && (mask & XCL_RTS))
    {
        if (ioctl(m_handle, TIOCMGET, &status) == -1)
        {
            if (state & XCL_RTS)
                status |= TIOCM_RTS;
            else
                status &= ~TIOCM_RTS;
            rv = (ioctl(m_handle, TIOCMSET, &status) == -1);
        }
        else
            rv = false;
    }
    if (rv)
        return m_lastResult = XRV_OK;
    else
        return m_lastResult = XRV_ERROR;
#endif
}

/*! \copydoc IoInterface::flushData
    \note This function tries to send and receive any remaining data immediately
    and does not return until the buffers are empty.
*/
XsResultValue SerialInterface::flushData(void)
{
    m_lastResult = XRV_OK;
#ifdef _WIN32
    // Remove any 'old' data in buffer
    if (!PurgeComm(m_handle, PURGE_TXCLEAR | PURGE_RXCLEAR))
        m_lastResult = XRV_ERROR;
#else
    tcflush(m_handle, TCIOFLUSH);
#endif
    m_endTime = 0;
    return m_lastResult;
}

//! Return the baudrate that is currently being used by the port
XsBaudRate SerialInterface::getBaudrate(void) const
{
    if (isOpen()) return m_baudrate;
    return XBR_Invalid;
}
//! Return the handle of the port
XsIoHandle SerialInterface::getHandle(void) const { return m_handle; }
//! Retrieve the port number that was last successfully opened.
uint16_t SerialInterface::getPortNumber(void) const { return m_port; }
//! Retrieve the port name that was last successfully opened.
void SerialInterface::getPortName(XsString& portname) const
{
    portname = m_portname;
}
//! Return the error code of the last operation.
XsResultValue SerialInterface::getLastResult(void) const
{
    return m_lastResult;
}
//! Return the current timeout value
uint32_t SerialInterface::getTimeout(void) const { return m_timeout; }
//! Return whether the communication port is open or not.
bool SerialInterface::isOpen(void) const
{
#ifdef _WIN32
    return m_handle != INVALID_HANDLE_VALUE;
#else
    return m_handle >= 0;
#endif
}

/*! \brief Open a communication channel to the given port info.
    \details If the baudrate in \a portInfo is set to XBR_Invalid, the baud rate
   is automatically
                detected if possible.
    \param portInfo The details of the port that should be opened. Depending on
   the type of interface,
                parts of this parameter may be ignored.
    \param readBufSize The size of the read buffer in bytes (if appliccable to
   the device)
    \param writeBufSize The size of the write buffer in bytes (if appliccable to
   the device)
    \returns XRV_OK if the device was opened successfully
*/
XsResultValue SerialInterface::open(
    const XsPortInfo& portInfo, uint32_t readBufSize, uint32_t writeBufSize)
{
    m_endTime = 0;

    JLDEBUG(
        gJournal, "port " << portInfo.portName().toStdString() << " at "
                          << portInfo.baudrate() << " baud");

    if (isOpen())
    {
        JLALERT(
            gJournal, "Port " << portInfo.portName().toStdString()
                              << " is already open");
        return (m_lastResult = XRV_ALREADYOPEN);
    }
    m_baudrate = portInfo.baudrate();

#ifdef _WIN32
    XsResultValue fail = XRV_OK;
    char winPortName[256];

    // Open port
    sprintf(winPortName, "\\\\.\\%s", portInfo.portName().c_str());
    m_handle = CreateFileA(
        winPortName, GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0,
        nullptr);
    if (m_handle == INVALID_HANDLE_VALUE)
    {
        JLDEBUG(
            gJournal, "Port " << portInfo.portName().toStdString()
                              << " cannot be opened");
        return (m_lastResult = XRV_INPUTCANNOTBEOPENED);
    }

    /** Stored settings about the serial port */
    DCB commState;

    commState.DCBlength = sizeof(DCB);

    // Get the current state & then change it
    if (!GetCommState(m_handle, &commState))  // Get current state
        fail = XRV_ERROR;

    commState.BaudRate = (int)portInfo.baudrate();  // Setup the baud rate
    commState.Parity = NOPARITY;  // Setup the Parity
    commState.ByteSize = 8;  // Setup the data bits
    commState.StopBits = TWOSTOPBITS;  // Setup the stop bits
    commState.fDsrSensitivity = FALSE;  // Setup the flow control
    commState.fOutxCtsFlow = FALSE;  // NoFlowControl:
    commState.fOutxDsrFlow = FALSE;
    commState.fOutX = FALSE;
    commState.fInX = FALSE;
    commState.fRtsControl = RTS_CONTROL_ENABLE;
    if (!SetCommState(m_handle, (LPDCB)&commState))  // Set new state
    {
        // Bluetooth ports cannot always be opened with 2 stopbits
        // Now try to open port with 1 stopbit.
        commState.StopBits = ONESTOPBIT;
        if (!SetCommState(m_handle, (LPDCB)&commState))
            fail = XRV_INPUTCANNOTBEOPENED;
    }
    std::string tmp = portInfo.portName().toStdString();
    m_port = atoi(&tmp.c_str()[3]);
    sprintf(m_portname, "%s", tmp.c_str());

    if (setTimeout(20)) fail = m_lastResult;

    // Other initialization functions
    if (!EscapeCommFunction(m_handle, SETDTR))  // Set DTR (Calibration sensors
        // need DTR to startup, won't
        // hurt otherwise
        fail = XRV_ERROR;
    if (!SetupComm(m_handle, readBufSize, writeBufSize))  // Set queue size
        fail = XRV_ERROR;

    // Remove any 'old' data in buffer
    // PurgeComm(m_handle, PURGE_TXCLEAR | PURGE_RXCLEAR);
    if (!PurgeComm(
            m_handle,
            PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR))
        fail = XRV_ERROR;

    if (fail != XRV_OK)
    {
        CloseHandle(m_handle);  // lint !e534
        m_handle = INVALID_HANDLE_VALUE;
        return (m_lastResult = fail);
    }

#else  // !_WIN32
    (void)readBufSize;
    (void)writeBufSize;
    // Open port
    std::string pn = portInfo.portName().toStdString();
    m_handle = ::open(pn.c_str(), O_RDWR | O_NOCTTY);

    // O_RDWR: Read+Write
    // O_NOCTTY: Raw input, no "controlling terminal"
    // O_NDELAY: Don't care about DCD signal

    if (m_handle < 0)
    {
        // Port not open
        return m_lastResult = XRV_INPUTCANNOTBEOPENED;
    }

    // Check if the file is already opened by someome else (other
    // thread/process)
    if (flock(m_handle, LOCK_EX | LOCK_NB))
    {
        closeLive();
        return m_lastResult = XRV_INPUTCANNOTBEOPENED;
    }

    /* Start configuring of port for non-canonical transfer mode */
    // Get current options for the port
    if (tcgetattr(m_handle, &m_commState) != 0) return XRV_ERROR;

    // Set baudrate.
    if (cfsetispeed(&m_commState, portInfo.baudrate()) != 0) return XRV_ERROR;

    if (cfsetospeed(&m_commState, portInfo.baudrate()) != 0) return XRV_ERROR;

    // Enable the receiver and set local mode
    m_commState.c_cflag |= (CLOCAL | CREAD);
    // Set character size to data bits and set no parity Mask the characte size
    // bits
    m_commState.c_cflag &= ~(CSIZE | PARENB);
    m_commState.c_cflag |= CS8;  // Select 8 data bits
    m_commState.c_cflag |= CSTOPB;  // send 2 stop bits
    // Disable hardware flow control
    m_commState.c_cflag &= ~CRTSCTS;
    m_commState.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
    // Disable software flow control
    m_commState.c_iflag &=
        ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
    // Set Raw output
    m_commState.c_oflag &= ~OPOST;
    // Timeout 0.001 sec for first byte, read minimum of 0 bytes
    m_commState.c_cc[VMIN] = 0;
    m_commState.c_cc[VTIME] = (m_timeout + 99) / 100;  // 1

    // Set the new options for the port
    if (tcsetattr(m_handle, TCSANOW, &m_commState) != 0)
        return XRV_INPUTCANNOTBEOPENED;

    termios checkCommState;
    if (tcgetattr(m_handle, &checkCommState) != 0) return XRV_ERROR;

    if ((m_commState.c_cflag != checkCommState.c_cflag) ||
        (m_commState.c_iflag != checkCommState.c_iflag) ||
        (m_commState.c_oflag != checkCommState.c_oflag) ||
        (m_commState.c_cc[VMIN] != checkCommState.c_cc[VMIN]) ||
        (m_commState.c_cc[VTIME] != checkCommState.c_cc[VTIME]))
    {
        JLDEBUG(
            gJournal,
            "commstates do not match, which is OK for USB connected MkIV "
            "devices");
    }

    m_port = 1;
    sprintf(m_portname, "%s", pn.c_str());

    tcflush(m_handle, TCIOFLUSH);

    // setting RTS and DTR; RTS for Xbus Master, DTR for calibration sensors
    int cmbits;
    if (ioctl(m_handle, TIOCMGET, &cmbits) < 0)
    {
        JLDEBUG(
            gJournal,
            "TIOCMGET failed, which is OK for USB connected MkIV devices");
    }

    cmbits |= TIOCM_RTS | TIOCM_DTR;

    if (ioctl(m_handle, TIOCMSET, &cmbits) < 0)
    {
        JLDEBUG(
            gJournal,
            "TIOCMSET failed, which is OK for USB connected MkIV devices");
    }
#endif  // !_WIN32

    JLDEBUG(
        gJournal, "Port " << portInfo.portName().toStdString() << " opened");
    return (m_lastResult = XRV_OK);
}

/*! \brief Helper function for making filename of log file unique
*/
bool doesFileExist(char* filename)
{
    FILE* pf = fopen(filename, "r");
    if (pf == nullptr) return false;
    fclose(pf);
    return true;
}

/*! \brief Helper function for making filename of log file unique
*/
void makeFilenameUnique(char* filename)
{
    if (doesFileExist(filename))  // if a file already exist with the same name,
    {
        // create a unique filename by adding a counter:
        char filename2[XS_MAX_FILENAME_LENGTH];
        char basename[XS_MAX_FILENAME_LENGTH];
        strcpy(basename, filename);
        basename[strlen(basename) - 4] = 0;  // remove .log extension
        int counter = 1;
        do
        {
            sprintf(filename2, "%s_%d.log", basename, counter++);
            if (counter > 10)  // don't count further than 10
            {
                sprintf(filename2, "%s_n.log", basename);
                break;
            }
        } while (doesFileExist(filename2));
        strcpy(filename, filename2);
    }
}

/*! \brief Read data from the serial port and put it into the data buffer.
    \details This function reads up to \a maxLength bytes from the port
   (non-blocking) and
    puts it into the \a data buffer.
    \param maxLength The maximum amount of data read.
    \param data The buffer that will store the received data.
    \returns XRV_OK if no error occurred. It can be that no data is available
   and XRV_OK will be
            returned. Check data.size() for the number of bytes that were read.
*/
XsResultValue SerialInterface::readData(XsSize maxLength, XsByteArray& data)
{
    if (!isOpen()) return (m_lastResult = XRV_NOPORTOPEN);

#ifdef _WIN32
    DWORD length;
    data.setSize(maxLength);
    BOOL rres =
        ::ReadFile(m_handle, data.data(), (DWORD)maxLength, &length, nullptr);
    data.pop_back(maxLength - length);
    JLTRACE(gJournal, "ReadFile result " << rres << ", length " << length);

    if (!rres)
    {
        DWORD wErr = ::GetLastError();
        JLALERT(gJournal, "ReadFile returned windows error " << wErr);
        if (wErr >= ERROR_INVALID_FUNCTION && wErr <= ERROR_INVALID_HANDLE)
            return (m_lastResult = XRV_NOFILEORPORTOPEN);
        return (m_lastResult = XRV_ERROR);
    }

    if (length == 0) return (m_lastResult = XRV_TIMEOUT);
#else
    fd_set fd;
    fd_set err;
    timeval timeout;
    FD_ZERO(&fd);
    FD_ZERO(&err);
    FD_SET(m_handle, &fd);
    FD_SET(m_handle, &err);

    timeout.tv_sec = m_timeout / 1000;
    timeout.tv_usec = (m_timeout - (timeout.tv_sec * 1000)) * 1000;

    int res = select(FD_SETSIZE, &fd, nullptr, &err, &timeout);
    if (res < 0 || FD_ISSET(m_handle, &err))
    {
        data.clear();
        return (m_lastResult = XRV_ERROR);
    }
    else if (res == 0)
    {
        data.clear();
        return (m_lastResult = XRV_TIMEOUT);
    }

    data.setSize(maxLength);
    int length = read(m_handle, (void*)data.data(), maxLength);
    data.pop_back(maxLength - length);
#endif

#ifdef LOG_RX_TX
    if (length > 0)
    {
        if (rx_log == nullptr)
        {
            char fname[XS_MAX_FILENAME_LENGTH];
#ifdef _WIN32
            sprintf(fname, "rx_%03d_%d.log", (int32_t)m_port, m_baudrate);
#else
            char* devname = strrchr(m_portname, '/');
            sprintf(
                fname, "rx_%s_%d.log", devname + 1,
                XsBaud::rateToNumeric(m_baudrate));
#endif
            makeFilenameUnique(fname);

            rx_log = fopen(fname, "wb");
        }
        fwrite(data.data(), 1, length, rx_log);
#ifdef LOG_RX_TX_FLUSH
        fflush(rx_log);
#endif
    }
#endif

    JLTRACE(
        gJournal, "returned success, read "
                      << length << " of " << maxLength
                      << " bytes, first: " << JLHEXLOG(data[0]));
    return (m_lastResult = XRV_OK);
}

/*! \brief Set the default timeout value to use in blocking operations.
    \details This function sets the value of m_timeout. There is no infinity
   value. The value 0
    means that all blocking operations now become polling (non-blocking)
   operations.
    If the value is set to or from 0, the low-level serial port settings may be
    changed in addition to the m_timeout value.
    \param ms The new timeout in milliseconds
    \returns XRV_OK if the function succeeded
*/
XsResultValue SerialInterface::setTimeout(const uint32_t ms)
{
    JLDEBUG(gJournal, "Setting timeout to " << ms << " ms");

    m_timeout = ms;
#ifdef _WIN32
    // Set COM timeouts
    COMMTIMEOUTS commTimeouts;

    if (!GetCommTimeouts(
            m_handle, &commTimeouts))  // Fill CommTimeouts structure
        return m_lastResult = XRV_ERROR;

    // immediate return if data is available, wait 1ms otherwise
    if (m_timeout > 0)
    {
        commTimeouts.ReadIntervalTimeout = 0;
        commTimeouts.ReadTotalTimeoutConstant = m_timeout;  // ms time
        commTimeouts.ReadTotalTimeoutMultiplier = 0;
        commTimeouts.WriteTotalTimeoutConstant = m_timeout;
        commTimeouts.WriteTotalTimeoutMultiplier = 0;
    }
    else
    {
        // immediate return whether data is available or not
        commTimeouts.ReadIntervalTimeout = MAXDWORD;
        commTimeouts.ReadTotalTimeoutConstant = 0;
        commTimeouts.ReadTotalTimeoutMultiplier = 0;
        commTimeouts.WriteTotalTimeoutConstant = 0;
        commTimeouts.WriteTotalTimeoutMultiplier = 0;
    }

    if (!SetCommTimeouts(
            m_handle, &commTimeouts))  // Set CommTimeouts structure
        return m_lastResult = XRV_ERROR;
#else
    // Timeout 0.1 sec for first byte, read minimum of 0 bytes
    m_commState.c_cc[VMIN] = 0;
    m_commState.c_cc[VTIME] = (m_timeout + 99) / 100;  // ds time

    // Set the new options for the port if it is open
    if (isOpen()) tcsetattr(m_handle, TCSANOW, &m_commState);
#endif
    return (m_lastResult = XRV_OK);
}

/*! \brief Wait for data to arrive or a timeout to occur.
    \details The function waits until \c maxLength data is available or until a
   timeout occurs.
    The function returns success if data is available or XsResultValue::TIMEOUT
   if a
    timeout occurred. A timeout value of 0 indicates that the default timeout
   stored
    in the class should be used.
    \param maxLength The maximum number of bytes to read before returning
    \param data The buffer to put the read data in.
    \returns XRV_OK if \a maxLength bytes were read, XRV_TIMEOUT if less was
   read, XRV_TIMEOUTNODATA if nothing was read
*/
XsResultValue SerialInterface::waitForData(XsSize maxLength, XsByteArray& data)
{
    data.clear();
    data.reserve(maxLength);

    // char *data = (char *)&_data[0];
    JLTRACE(gJournal, "timeout=" << m_timeout << ", maxLength=" << maxLength);
    uint32_t timeout = m_timeout;

    uint32_t eTime = XsTime_getTimeOfDay(nullptr, nullptr) + timeout;
    //  uint32_t newLength = 0;

    while ((data.size() < maxLength) &&
           (XsTime_getTimeOfDay(nullptr, nullptr) <= eTime))
    {
        XsByteArray raw;

        if (readData(maxLength - data.size(), raw) != XRV_OK)
            return m_lastResult;
        data.append(raw);
    }
    JLTRACE(
        gJournal, "Read " << data.size() << " of " << maxLength << " bytes");

    if (data.size() < maxLength)
        return (m_lastResult = XRV_TIMEOUT);
    else
        return (m_lastResult = XRV_OK);
}

/*! \copydoc IoInterface::writeData
    \note The default timeout is respected in this operation.
*/
XsResultValue SerialInterface::writeData(
    const XsByteArray& data, XsSize* written)
{
    XsSize bytes;
    if (written == nullptr) written = &bytes;

    if (!isOpen()) return (m_lastResult = XRV_NOPORTOPEN);

    *written = 0;

#ifdef _WIN32
    DWORD lwritten = 0;
    if (WriteFile(
            m_handle, data.data(), (DWORD)data.size(), &lwritten, nullptr) == 0)
        return (m_lastResult = XRV_ERROR);

    *written = lwritten;
#else
    ssize_t result = write(m_handle, (const void*)data.data(), data.size());
    if (result < 0) return (m_lastResult = XRV_ERROR);

    *written = result;
#endif

#ifdef LOG_RX_TX
    if (written[0] > 0)
    {
        if (tx_log == nullptr)
        {
            char fname[XS_MAX_FILENAME_LENGTH];
#ifdef _WIN32
            sprintf(fname, "tx_%03d_%d.log", (int32_t)m_port, m_baudrate);
#else
            char* devname = strrchr(m_portname, '/');
            sprintf(
                fname, "tx_%s_%d.log", devname + 1,
                XsBaud::rateToNumeric(m_baudrate));
#endif
            makeFilenameUnique(fname);

            tx_log = fopen(fname, "wb");
        }
        fwrite(data.data(), 1, *written, tx_log);
#ifdef LOG_RX_TX_FLUSH
        fflush(tx_log);
#endif
    }
#endif

    return (m_lastResult = XRV_OK);
}

/*! \brief Cancel any pending io requests */
void SerialInterface::cancelIo() const
{
#ifdef _WIN32
/* This function is only available on Windows Vista and higher.
   When a read action hangs, this function can cancel IO operations from another
   thread.
*/
// CancelIoEx(m_handle, nullptr);
#endif
}