win32/net_serial.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2017, 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 |
   +------------------------------------------------------------------------+ */
/*
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "sdkcommon.h"
#include "net_serial.h"

namespace rp
{
namespace arch
{
namespace net
{
raw_serial::raw_serial()
        : rp::hal::serial_rxtx(), _serial_handle(nullptr), _baudrate(0), _flags(0)
{
        _init();
}

raw_serial::~raw_serial()
{
        close();

        CloseHandle(_ro.hEvent);
        CloseHandle(_wo.hEvent);
        CloseHandle(_wait_o.hEvent);
}

bool raw_serial::open() { return open(_portName, _baudrate, _flags); }
bool raw_serial::bind(const char* portname, _u32 baudrate, _u32 flags)
{
        strncpy(_portName, portname, sizeof(_portName));
        _baudrate = baudrate;
        _flags = flags;
        return true;
}

bool raw_serial::open(const char* portname, _u32 baudrate, _u32 flags)
{
        if (isOpened()) close();

        _serial_handle = CreateFileA(
                portname, GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING,
                FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);

        if (_serial_handle == INVALID_HANDLE_VALUE) return false;

        if (!SetupComm(
                        _serial_handle, SERIAL_RX_BUFFER_SIZE, SERIAL_TX_BUFFER_SIZE))
        {
                close();
                return false;
        }

        _dcb.BaudRate = baudrate;
        _dcb.ByteSize = 8;
        _dcb.Parity = NOPARITY;
        _dcb.StopBits = ONESTOPBIT;
        _dcb.fDtrControl = DTR_CONTROL_ENABLE;

        if (!SetCommState(_serial_handle, &_dcb))
        {
                close();
                return false;
        }

        if (!SetCommTimeouts(_serial_handle, &_co))
        {
                close();
                return false;
        }

        if (!SetCommMask(_serial_handle, EV_RXCHAR | EV_ERR))
        {
                close();
                return false;
        }

        if (!PurgeComm(
                        _serial_handle,
                        PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR))
        {
                close();
                return false;
        }

        Sleep(30);
        _is_serial_opened = true;

        // Clear the DTR bit set DTR=high
        clearDTR();

        return true;
}

void raw_serial::close()
{
        SetCommMask(_serial_handle, 0);
        ResetEvent(_wait_o.hEvent);

        CloseHandle(_serial_handle);
        _serial_handle = INVALID_HANDLE_VALUE;

        _is_serial_opened = false;
}

int raw_serial::senddata(const unsigned char* data, size_t size)
{
        DWORD error;
        DWORD w_len = 0, o_len = -1;
        if (!isOpened()) return ANS_DEV_ERR;

        if (data == nullptr || size == 0) return 0;

        if (ClearCommError(_serial_handle, &error, nullptr) && error > 0)
                PurgeComm(_serial_handle, PURGE_TXABORT | PURGE_TXCLEAR);

        if (!WriteFile(_serial_handle, data, size, &w_len, &_wo))
                if (GetLastError() != ERROR_IO_PENDING) w_len = ANS_DEV_ERR;

        return w_len;
}

int raw_serial::recvdata(unsigned char* data, size_t size)
{
        if (!isOpened()) return 0;
        DWORD r_len = 0;

        if (!ReadFile(_serial_handle, data, size, &r_len, &_ro))
        {
                if (GetLastError() == ERROR_IO_PENDING)
                {
                        if (!GetOverlappedResult(_serial_handle, &_ro, &r_len, FALSE))
                        {
                                if (GetLastError() != ERROR_IO_INCOMPLETE) r_len = 0;
                        }
                }
                else
                        r_len = 0;
        }

        return r_len;
}

void raw_serial::flush(_u32 flags)
{
        PurgeComm(
                _serial_handle,
                PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
}

int raw_serial::waitforsent(_u32 timeout, size_t* returned_size)
{
        if (!isOpened()) return ANS_DEV_ERR;
        DWORD w_len = 0;
        _word_size_t ans = 0;

        if (WaitForSingleObject(_wo.hEvent, timeout) == WAIT_TIMEOUT)
        {
                ans = ANS_TIMEOUT;
                goto _final;
        }
        if (!GetOverlappedResult(_serial_handle, &_wo, &w_len, FALSE))
        {
                ans = ANS_DEV_ERR;
        }
_final:
        if (returned_size) *returned_size = w_len;
        return ans;
}

int raw_serial::waitforrecv(_u32 timeout, size_t* returned_size)
{
        if (!isOpened()) return -1;
        DWORD r_len = 0;
        _word_size_t ans = 0;

        if (WaitForSingleObject(_ro.hEvent, timeout) == WAIT_TIMEOUT)
        {
                ans = ANS_TIMEOUT;
        }
        if (!GetOverlappedResult(_serial_handle, &_ro, &r_len, FALSE))
        {
                ans = ANS_DEV_ERR;
        }
        if (returned_size) *returned_size = r_len;
        return ans;
}

int raw_serial::waitfordata(
        size_t data_count, _u32 timeout, size_t* returned_size)
{
        COMSTAT stat;
        DWORD error;
        DWORD msk, length;
        size_t dummy_length;

        if (returned_size == nullptr) returned_size = (size_t*)&dummy_length;

        if (isOpened())
        {
                size_t rxqueue_remaining = rxqueue_count();
                if (rxqueue_remaining >= data_count)
                {
                        *returned_size = rxqueue_remaining;
                        return 0;
                }
        }

        while (isOpened())
        {
                msk = 0;
                SetCommMask(_serial_handle, EV_RXCHAR | EV_ERR);
                if (!WaitCommEvent(_serial_handle, &msk, &_wait_o))
                {
                        if (GetLastError() == ERROR_IO_PENDING)
                        {
                                if (WaitForSingleObject(_wait_o.hEvent, timeout) ==
                                        WAIT_TIMEOUT)
                                {
                                        *returned_size = 0;
                                        return ANS_TIMEOUT;
                                }

                                GetOverlappedResult(_serial_handle, &_wait_o, &length, TRUE);

                                ::ResetEvent(_wait_o.hEvent);
                        }
                        else
                        {
                                ClearCommError(_serial_handle, &error, &stat);
                                *returned_size = stat.cbInQue;
                                return ANS_DEV_ERR;
                        }
                }

                if (msk & EV_ERR)
                {
                        // FIXME: may cause problem here
                        ClearCommError(_serial_handle, &error, &stat);
                }

                if (msk & EV_RXCHAR)
                {
                        ClearCommError(_serial_handle, &error, &stat);
                        if (stat.cbInQue >= data_count)
                        {
                                *returned_size = stat.cbInQue;
                                return 0;
                        }
                }
        }
        *returned_size = 0;
        return ANS_DEV_ERR;
}

size_t raw_serial::rxqueue_count()
{
        if (!isOpened()) return 0;
        COMSTAT com_stat;
        DWORD error;
        DWORD r_len = 0;

        if (ClearCommError(_serial_handle, &error, &com_stat) && error > 0)
        {
                PurgeComm(_serial_handle, PURGE_RXABORT | PURGE_RXCLEAR);
                return 0;
        }
        return com_stat.cbInQue;
}

void raw_serial::setDTR()
{
        if (!isOpened()) return;

        EscapeCommFunction(_serial_handle, SETDTR);
}

void raw_serial::clearDTR()
{
        if (!isOpened()) return;

        EscapeCommFunction(_serial_handle, CLRDTR);
}

void raw_serial::_init()
{
        memset(&_dcb, 0, sizeof(_dcb));
        _dcb.DCBlength = sizeof(_dcb);
        _serial_handle = INVALID_HANDLE_VALUE;
        memset(&_co, 0, sizeof(_co));
        _co.ReadIntervalTimeout = 0;
        _co.ReadTotalTimeoutMultiplier = 0;
        _co.ReadTotalTimeoutConstant = 0;
        _co.WriteTotalTimeoutMultiplier = 0;
        _co.WriteTotalTimeoutConstant = 0;

        memset(&_ro, 0, sizeof(_ro));
        memset(&_wo, 0, sizeof(_wo));
        memset(&_wait_o, 0, sizeof(_wait_o));

        _ro.hEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
        _wo.hEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
        _wait_o.hEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);

        _portName[0] = 0;
}
}
}
}  // end rp::arch::net

// begin rp::hal
namespace rp
{
namespace hal
{
serial_rxtx* serial_rxtx::CreateRxTx()
{
        return new rp::arch::net::raw_serial();
}

void serial_rxtx::ReleaseRxTx(serial_rxtx* rxtx) { delete rxtx; }
}
}  // end rp::hal