uart.hpp

Go to the documentation of this file.

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  *  _____.___.                 .___                    .__.__      *
  *  \__  |   | ____   ____   __| _/___________    _____|__|  |     *
  *   /   |   |/ ___\ / ___\ / __ |\_  __ \__  \  /  ___/  |  |     *
  *   \____   / /_/  > /_/  > /_/ | |  | \// __ \_\___ \|  |  |__   *
  *   / ______\___  /\___  /\____ | |__|  (____  /____  >__|____/   *
  *   \/     /_____//_____/      \/            \/     \/            *
  *                          - Asgard -                             *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * This software can be used by students and other personal of the *
  * Bern University of Applied Sciences under the terms of the MIT  *
  * license.                                                        *
  * For other persons this software is under the terms of the GNU   *
  * General Public License version 2.                               *
  *                                                                 *
  * Copyright © 2021, Bern University of Applied Sciences.     *
  * All rights reserved.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#pragma once
 
#include <cpp/common/frontend/uart.hpp>
 
#include <string>
#include <string_view>
#include <array>
 
namespace bsp::asg_coproc::drv {
 
    template<addr_t BaseAddress>
    struct UART {
 
        static bool init() {
            return true;
        }
 
        static bool deinit() {
            return true;
        }
 
        static void receive(std::string &buffer) {
            UE = true;
            while (true) {
                while (!RXNE);
 
                char c = RECV;
 
                if (c == '\n' || c == '\r')
                    break;
                else
                    buffer.push_back(c);
            }
            UE = false;
        }
 
        template<size_t N>
        static void receive(std::array<u8, N> &buffer) {
            u32 index = 0;
            UE = true;
            while (index < N) {
                while (!RXNE);
 
                u8 c = RECV;
 
                buffer[index] = c;
 
                index++;
            }
            UE = false;
        }
 
        static void transmit(std::string_view buffer) {
            UE = true;
            for (char c : buffer) {
                while(!TXE);
 
                TRNS = c;
            }
            while(!TC);
            UE = false;
        }
 
        template<size_t N>
        static void transmit(const std::array<u8, N> &buffer) {
            UE = true;
            for (char c : buffer) {
                while(!TXE);
 
                TRNS = c;
            }
            while(!TC);
            UE = false;
        }
 
    private:
        enum class RegisterMap {
            CR1 = 0x00,         
            CR2 = 0x04,         
            CR3 = 0x08,         
            ISR = 0x1C,         
            ICR = 0x20,         
            RDR = 0x24,         
            TDR = 0x28,         
        };
 
        using CR1 = Register<BaseAddress, RegisterMap::CR1, u32>;
        using CR2 = Register<BaseAddress, RegisterMap::CR2, u32>;
        using CR3 = Register<BaseAddress, RegisterMap::CR3, u32>;
        using ISR = Register<BaseAddress, RegisterMap::ISR, u32>;
        using ICR = Register<BaseAddress, RegisterMap::ICR, u32>;
        using RDR = Register<BaseAddress, RegisterMap::RDR, u32>;
        using TDR = Register<BaseAddress, RegisterMap::TDR, u32>;
 
        static inline auto UE   = typename CR1::template Field<0, 0>();     
        static inline auto RXNE = typename ISR::template Field<5, 5>();     
        static inline auto TXE  = typename ISR::template Field<7, 7>();     
        static inline auto TC   = typename ISR::template Field<6, 6>();     
 
        static inline auto RECV = typename RDR::template Field<0, 7>();     
        static inline auto TRNS = typename TDR::template Field<0, 7>();     
    };
 
}