PDC.hpp

Go to the documentation of this file.

 
#ifndef PDC_HPP
#define PDC_HPP
#include <Arduino.h>
 
// Defining relevant UART registers
#define UART_BASE 0x400E0800
#define UART_PERIPH_TPR_ADDR (UART_BASE + 0x108) // Transmit pointer register
#define UART_PERIPH_TCR_ADDR (UART_BASE + 0x10C) // Transmit counter register
#define UART_PERIPH_TNPR_ADDR (UART_BASE + 0x118) // Transmit next pointer register
#define UART_PERIPH_TNCR_ADDR (UART_BASE + 0x11C) // Transmit next counter register
#define UART_PERIPH_PTCR_ADDR (UART_BASE + 0x120) // Peripheral transfer control register
#define UART_PERIPH_PTSR_ADDR (UART_BASE + 0x124) // Peripheral transfer status register
#define UART_SR (UART_BASE + 0x0014) // Status register
 
#define TXTEN (1<<8) //mask used to enable UART transmitter
#define TXBUFE (1<<11) //check if UART is ready
class PDC {
private:
    // pointers to UART registers
    volatile uint32_t* const p_UART_TPR;
    volatile uint32_t* const p_UART_TCR;
    volatile uint32_t* const p_UART_TNPR;
    volatile uint32_t* const p_UART_TNCR;
    volatile uint32_t* const p_UART_PTCR;
    volatile uint32_t* const p_UART_PTSR;
    volatile uint32_t* const p_UART_SR;
 
    uint8_t backup_buffer[294];
 
 
    
 
public:
    PDC()
        : p_UART_TPR((uint32_t*)UART_PERIPH_TPR_ADDR),
          p_UART_TCR((uint32_t*)UART_PERIPH_TCR_ADDR),
          p_UART_TNPR((uint32_t*)UART_PERIPH_TNPR_ADDR),
          p_UART_TNCR((uint32_t*)UART_PERIPH_TNCR_ADDR),
          p_UART_PTCR((uint32_t*)UART_PERIPH_PTCR_ADDR),
          p_UART_PTSR((uint32_t*)UART_PERIPH_PTSR_ADDR),
          p_UART_SR((uint32_t*)UART_SR)
    {}
 
 
    void init(){
    //enable pdc transmitter
    *p_UART_PTCR |= TXTEN;
    //wait until ready
    while(! PDC::is_on()){
        ;
    }
 
    }
    template <typename T>
    void send(T* buffer, int size){
        //check if UART is ready for transmit
        if(*p_UART_SR & TXBUFE){
                //set buffer and size
                *(volatile uint32_t*)p_UART_TPR = (uint32_t)buffer;
                *p_UART_TCR = size;
           
        } else{
            memcpy(backup_buffer, buffer, size);
            enableUARTInterrupt();
            /* //wait until ready
            //digitalWrite(7, HIGH);
            while(!(*p_UART_SR & TXBUFE)){
                ;
            }
            //digitalWrite(7, LOW);
            //same as above
                *(volatile uint32_t*)p_UART_TPR = (uint32_t)buffer;
                *p_UART_TCR = size; */
        }
        
    }
    template <typename T>
    void send_next(T* buffer, int size){
                //set buffer and size
            if(*p_UART_SR & TXBUFE){
                send(buffer, size);
            } else if (*p_UART_TNCR==0){
                *(volatile uint32_t*)p_UART_TNPR = (uint32_t)buffer;
                *p_UART_TNCR = size;
            }
           
            else if (!(*p_UART_SR & TXBUFE)&&(*p_UART_TNCR!=1)){
                while(*p_UART_TNCR!=0){
                    ;
                }
                *(volatile uint32_t*)p_UART_TNPR = (uint32_t)buffer;
                *p_UART_TNCR = size;
            } else{
                send(buffer, size);
            }
        
    }
    bool is_on(){
        return (*p_UART_PTSR & (1<<8));
    }
 
    void enableUARTInterrupt(){
        //enable UART interrupt
        NVIC_EnableIRQ(UART_IRQn);
        //interrupt on TXBUFE
        UART->UART_IER = UART_IER_TXBUFE;
        UART->UART_IDR = ~UART_IER_TXBUFE;
    }
 
    void UART_Handler(){
        send(backup_buffer, sizeof(backup_buffer));
        NVIC_DisableIRQ(UART_IRQn);
    }
};
#endif