uart_commons.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef UARTCOMMONS_HH
#define UARTCOMMONS_HH
 
#include <stdint.h>
 
namespace serial
{
    enum class Parity : uint8_t
    {
        NONE = 0,
        EVEN = 1,
        ODD = 3
    };
 
    enum class StopBits : uint8_t
    {
        ONE = 1,
        TWO = 2
    };
 
    enum class BufferHandling : uint8_t
    {
        KEEP = 0x00,
        CLEAR = 0x01,
        FLUSH = 0x02
    };
 
    union Errors
    {
        Errors() = default;
 
        uint8_t has_errors = 0;
        struct
        {
            bool frame_error : 1;
            bool data_overrun : 1;
            bool queue_overflow : 1;
            bool parity_error : 1;
        };
    };
 
    class UARTErrors
    {
    public:
        UARTErrors() : errors_{} {}
        UARTErrors(const UARTErrors& that) = default;
        UARTErrors& operator=(const UARTErrors& that) = default;
 
        void clear_errors()
        {
            errors_.has_errors = 0;
        }
 
        uint8_t has_errors() const
        {
            return errors_.has_errors;
        }
 
        bool frame_error() const
        {
            return errors_.frame_error;
        }
 
        bool data_overrun() const
        {
            return errors_.data_overrun;
        }
 
        bool queue_overflow() const
        {
            return errors_.queue_overflow;
        }
 
        bool parity_error() const
        {
            return errors_.parity_error;
        }
    
    protected:
        Errors& errors()
        {
            return errors_;
        }
 
    private:
        Errors errors_;
    };
 
    // Useful traits for checking a provided type (in template) is an UART and what traits it supports
    template<typename> struct UART_trait
    {
        static constexpr bool IS_UART = false;
        static constexpr bool IS_HW_UART = false;
        static constexpr bool IS_SW_UART = false;
        static constexpr bool HAS_TX = false;
        static constexpr bool HAS_RX = false;
    };
};
 
#endif /* UARTCOMMONS_HH */