SerialPort.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_DEVICES_COMMUNICATION_SERIALPORT_HPP_
#define INCLUDE_DISTORTOS_DEVICES_COMMUNICATION_SERIALPORT_HPP_

#include "distortos/devices/communication/UartBase.hpp"
#include "distortos/devices/communication/UartParity.hpp"

#include "distortos/Mutex.hpp"

namespace distortos
{

class Semaphore;

namespace devices
{

class UartLowLevel;

class SerialPort : private UartBase
{
public:

    class CircularBuffer
    {
    public:

        constexpr CircularBuffer(void* const buffer, const size_t size) :
                buffer_{static_cast<uint8_t*>(buffer)},
                size_{size & sizeMask_},
                readPosition_{},
                writePosition_{}
        {

        }

        constexpr CircularBuffer(const void* const buffer, const size_t size) :
                buffer_{static_cast<uint8_t*>(const_cast<void*>(buffer))},
                size_{(size & sizeMask_) | readOnlyMask_},
                readPosition_{},
                writePosition_{}
        {

        }

        void clear()
        {
            readPosition_ = {};
            writePosition_ = {};
        }

        size_t getCapacity() const
        {
            return size_ & sizeMask_;
        }

        std::pair<const uint8_t*, size_t> getReadBlock() const;

        size_t getSize() const
        {
            const auto readPosition = readPosition_ ;
            const auto writePosition = writePosition_;
            if (isEmpty(readPosition, writePosition) == true)
                return 0;
            const auto capacity = getCapacity();
            if (isFull(readPosition, writePosition) == true)
                return capacity;
            return (capacity - (readPosition & positionMask_) + (writePosition & positionMask_)) % capacity;
        }

        std::pair<uint8_t*, size_t> getWriteBlock() const;

        void increaseReadPosition(const size_t value)
        {
            readPosition_ = increasePosition(readPosition_, value);
        }

        void increaseWritePosition(const size_t value)
        {
            writePosition_ = increasePosition(writePosition_, value);
        }

        bool isEmpty() const
        {
            return isEmpty(readPosition_, writePosition_);
        }

        bool isFull() const
        {
            return isFull(readPosition_, writePosition_);
        }

        bool isReadOnly() const
        {
            return (size_ & readOnlyMask_) != 0;
        }

    private:

        std::pair<uint8_t*, size_t> getBlock(const size_t begin, const size_t end) const
        {
            const auto maskedBegin = begin & positionMask_;
            const auto maskedEnd = end & positionMask_;
            return {buffer_ + maskedBegin, (maskedEnd > maskedBegin ? maskedEnd : getCapacity()) - maskedBegin};
        }

        size_t increasePosition(const size_t position, const size_t value)
        {
            const auto maskedPosition = position & positionMask_;
            const auto msb = position & msbMask_;
            // in case of wrap-around MSB is inverted and position is 0
            return maskedPosition + value != getCapacity() ? msb | (maskedPosition + value) : msb ^ msbMask_;
        }

        constexpr static bool isEmpty(const size_t readPosition, const size_t writePosition)
        {
            return readPosition == writePosition;
        }

        constexpr static bool isFull(const size_t readPosition, const size_t writePosition)
        {
            return (readPosition ^ writePosition) == msbMask_;
        }

        constexpr static size_t positionMask_ {SIZE_MAX >> 1};

        constexpr static size_t msbMask_ {~positionMask_};

        constexpr static size_t sizeMask_ {SIZE_MAX >> 1};

        constexpr static size_t readOnlyMask_ {~sizeMask_};

        uint8_t* buffer_;

        size_t size_;

        volatile size_t readPosition_;

        volatile size_t writePosition_;
    };

    constexpr SerialPort(UartLowLevel& uart, void* const readBuffer, const size_t readBufferSize,
            void* const writeBuffer, const size_t writeBufferSize) :
                    readMutex_{Mutex::Protocol::priorityInheritance},
                    writeMutex_{Mutex::Protocol::priorityInheritance},
                    readBuffer_{readBuffer, (readBufferSize / 2) * 2},
                    writeBuffer_{writeBuffer, (writeBufferSize / 2) * 2},
                    currentReadBuffer_{&readBuffer_},
                    currentWriteBuffer_{&writeBuffer_},
                    nextReadBuffer_{},
                    nextWriteBuffer_{},
                    readSemaphore_{},
                    transmitSemaphore_{},
                    writeSemaphore_{},
                    readLimit_{},
                    writeLimit_{},
                    uart_{uart},
                    baudRate_{},
                    characterLength_{},
                    parity_{},
                    _2StopBits_{},
                    openCount_{},
                    readInProgress_{},
                    transmitInProgress_{},
                    writeInProgress_{}
    {

    }

    ~SerialPort() override;

    int close();

    int open(uint32_t baudRate, uint8_t characterLength, UartParity parity, bool _2StopBits);

    std::pair<int, size_t> read(void* buffer, size_t size, size_t minSize = 1,
            const TickClock::time_point* timePoint = nullptr);

    std::pair<int, size_t> tryReadFor(const TickClock::duration duration, void* const buffer, const size_t size,
            const size_t minSize = 1)
    {
        return tryReadUntil(TickClock::now() + duration, buffer, size, minSize);
    }

    template<typename Rep, typename Period>
    std::pair<int, size_t> tryReadFor(const std::chrono::duration<Rep, Period> duration, void* const buffer,
            const size_t size, const size_t minSize = 1)
    {
        return tryReadFor(std::chrono::duration_cast<TickClock::duration>(duration), buffer, size, minSize);
    }

    std::pair<int, size_t> tryReadUntil(const TickClock::time_point timePoint, void* const buffer, const size_t size,
            const size_t minSize = 1)
    {
        return read(buffer, size, minSize, &timePoint);
    }

    template<typename Duration>
    std::pair<int, size_t> tryReadUntil(const std::chrono::time_point<TickClock, Duration> timePoint,
            void* const buffer, const size_t size, const size_t minSize = 1)
    {
        return tryReadUntil(std::chrono::time_point_cast<TickClock::duration>(timePoint), buffer, size, minSize);
    }

    std::pair<int, size_t> tryWriteFor(const TickClock::duration duration, const void* const buffer, const size_t size,
            const size_t minSize = SIZE_MAX)
    {
        return tryWriteUntil(TickClock::now() + duration, buffer, size, minSize);
    }

    template<typename Rep, typename Period>
    std::pair<int, size_t> tryWriteFor(const std::chrono::duration<Rep, Period> duration, const void* const buffer,
            const size_t size, const size_t minSize = SIZE_MAX)
    {
        return tryWriteFor(std::chrono::duration_cast<TickClock::duration>(duration), buffer, size, minSize);
    }

    std::pair<int, size_t> tryWriteUntil(const TickClock::time_point timePoint, const void* const buffer,
            const size_t size, const size_t minSize = SIZE_MAX)
    {
        return write(buffer, size, minSize, &timePoint);
    }

    template<typename Duration>
    std::pair<int, size_t> tryWriteUntil(const std::chrono::time_point<TickClock, Duration> timePoint,
            const void* const buffer, const size_t size, const size_t minSize = SIZE_MAX)
    {
        return tryWriteUntil(std::chrono::time_point_cast<TickClock::duration>(timePoint), buffer, size, minSize);
    }

    std::pair<int, size_t> write(const void* buffer, size_t size, size_t minSize = SIZE_MAX,
            const TickClock::time_point* timePoint = nullptr);

protected:

    void readCompleteEvent(size_t bytesRead) override;

    void receiveErrorEvent(ErrorSet errorSet) override;

    void transmitCompleteEvent() override;

    void transmitStartEvent() override;

    void writeCompleteEvent(size_t bytesWritten) override;

private:

    int readFromCircularBufferAndStartRead(CircularBuffer& buffer);

    int readImplementation(CircularBuffer& buffer, size_t minSize, const TickClock::time_point* timePoint);

    int startReadWrapper();

    int startWriteWrapper();

    size_t stopReadWrapper();

    size_t stopWriteWrapper();

    int writeImplementation(CircularBuffer& buffer, size_t minSize, const TickClock::time_point* timePoint);

    int writeToCircularBufferAndStartWrite(CircularBuffer& buffer);

    Mutex readMutex_;

    Mutex writeMutex_;

    CircularBuffer readBuffer_;

    CircularBuffer writeBuffer_;

    CircularBuffer* volatile currentReadBuffer_;

    CircularBuffer* volatile currentWriteBuffer_;

    CircularBuffer* volatile nextReadBuffer_;

    CircularBuffer* volatile nextWriteBuffer_;

    Semaphore* volatile readSemaphore_;

    Semaphore* volatile transmitSemaphore_;

    Semaphore* volatile writeSemaphore_;

    volatile size_t readLimit_;

    volatile size_t writeLimit_;

    UartLowLevel& uart_;

    uint32_t baudRate_;

    uint8_t characterLength_;

    UartParity parity_;

    bool _2StopBits_;

    uint8_t openCount_;

    volatile bool readInProgress_;

    volatile bool transmitInProgress_;

    volatile bool writeInProgress_;
};

}   // namespace devices

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_DEVICES_COMMUNICATION_SERIALPORT_HPP_