sam_usart.h

Go to the documentation of this file.

// Copyright 2024-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <hal_samv71/interrupt_handler.h>
#include <satcat5/io_buffer.h>
#include <satcat5/polling.h>
#ifdef __FREERTOS__
#include <hal_freertos/task.h>
#include <satcat5/utils.h>
#endif
 
// ASF3 includes
extern "C"{
#include <usart.h>
#include <xdmac.h>
}
 
// Default buffer size for UsartSamv71Static
#ifndef SATCAT5_SAMV71_UART_BUFFSIZE
#define SATCAT5_SAMV71_UART_BUFFSIZE 1600
#endif
 
// Enable data cache flushing and invalidation for the DMA controller?
// When disabled (default, safe), SCB_DisableDCache() must be called at init.
#ifndef SATCAT5_SAMV71_UART_DCACHE
#define SATCAT5_SAMV71_UART_DCACHE 0
#endif
 
namespace satcat5 {
    namespace sam {
        class UsartSamv71
            : public satcat5::io::BufferedIO
            , public satcat5::poll::Timer
            , public satcat5::poll::Always
            , public satcat5::sam::HandlerSAMV71
        {
        public:
            UsartSamv71(
                Usart* usart, unsigned baud_hz, unsigned poll_ms,
                u8* txbuff, unsigned txbytes, u8* rxbuff, unsigned rxbytes,
                u8* rxdma0, u8* rxdma1, unsigned rxdmabytes,
                bool fc_on=false);
 
            void configure(unsigned baud_hz, bool rts_en, bool cts_en);
 
            inline void configure(unsigned baud_hz, bool fc_on=false)
                { configure(baud_hz, fc_on, fc_on); }
 
        protected:
            void data_rcvd(satcat5::io::Readable* src) override
                { poll_tx_dma(); }
 
            void timer_event() override { poll_rx_dma(); poll_tx_dma(); }
            void poll_always() override { poll_rx_dma(); poll_tx_dma(); }
 
            void irq_event() override;
 
            u8* get_rxdma_buff()
                { return m_rxdma_buffidx == 0 ? m_rxdma0 : m_rxdma1; }
 
            void poll_tx_dma();
 
            void poll_rx_dma();
 
            void configure_xdmac(u32 tx_dma_ch, u32 rx_dma_ch);
 
            void rts_high();
            void rts_low();
 
        private:
            // Member variables.
            Usart*          m_usart;
            unsigned        m_txdma_nbytes;
            u8* const       m_rxdma0;
            u8* const       m_rxdma1;
            const unsigned  m_rxdma_nbytes;
            unsigned        m_rxdma_buffidx;
            bool            m_rts_en;
            bool            m_cts_en;
            u8              m_tx_dma_ch;
            u8              m_rx_dma_ch;
        };
 
        template <unsigned SIZE = SATCAT5_SAMV71_UART_BUFFSIZE>
        class UsartSamv71Static : public UsartSamv71 {
        public:
            UsartSamv71Static(
                Usart* usart, unsigned baud_hz,
                unsigned poll_ms, bool fc_on=false)
            : UsartSamv71(usart, baud_hz, poll_ms,
                m_txbuff, SIZE, m_rxbuff, SIZE,
                m_rxdma0, m_rxdma1, SIZE, fc_on) {}
 
        private:
            u8 m_txbuff[SIZE];
            u8 m_rxbuff[SIZE];
            u8 m_rxdma0[SIZE];
            u8 m_rxdma1[SIZE];
        };
 
#ifdef __FREERTOS__
        template <
            unsigned TASK_PRIORITY,
            unsigned SIZE = SATCAT5_SAMV71_UART_BUFFSIZE,
            configSTACK_DEPTH_TYPE TASK_SIZE = 1024>
        class UsartSamv71Preempt
            : public satcat5::freertos::StaticTask<TASK_SIZE, TASK_PRIORITY>
            , public UsartSamv71Static<SIZE> {
        public:
            UsartSamv71Preempt(
                Usart* usart, unsigned baud_hz, unsigned poll_ms,
                bool poll_always=false, bool fc_on=false)
            : satcat5::freertos::StaticTask<TASK_SIZE, TASK_PRIORITY>(
                "UsartSamv71Preempt", task, this)
            , UsartSamv71Static<SIZE>(usart, baud_hz, 0, fc_on) // poll_ms = 0
            , m_poll_ms(satcat5::util::max_unsigned(1, poll_ms)) // Must be > 0
            {
                // Unregister the poll_always() call if requested.
                if (!poll_always) { this->poll_unregister(); }
            }
 
            static void task(void* pvParams) {
                UsartSamv71Preempt* arg = (UsartSamv71Preempt*) pvParams;
                const TickType_t poll_rate = pdMS_TO_TICKS(arg->m_poll_ms);
                TickType_t last_wake_time = xTaskGetTickCount();
                for (;;) {
                    vTaskDelayUntil(&last_wake_time, poll_rate);
                    arg->poll_rx_dma();
                    arg->poll_tx_dma();
                }
            }
 
        protected:
            // Member variables
            const unsigned m_poll_ms;
        };
#endif
 
    } // namespace sam
} // namespace satcat5