port.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/PropWare.h>
 
namespace PropWare {
 
class Port {
    public:
        typedef enum {                      P0       = BIT_0,                      P1       = BIT_1,                      P2       = BIT_2,                      P3       = BIT_3,                      P4       = BIT_4,                      P5       = BIT_5,                      P6       = BIT_6,                      P7       = BIT_7,                      P8       = BIT_8,                      P9       = BIT_9,                      P10      = BIT_10,                      P11      = BIT_11,                      P12      = BIT_12,                      P13      = BIT_13,                      P14      = BIT_14,                      P15      = BIT_15,                      P16      = BIT_16,                      P17      = BIT_17,                      P18      = BIT_18,                      P19      = BIT_19,                      P20      = BIT_20,                      P21      = BIT_21,                      P22      = BIT_22,                      P23      = BIT_23,                      P24      = BIT_24,                      P25      = BIT_25,                      P26      = BIT_26,                      P27      = BIT_27,                      P28      = BIT_28,                      P29      = BIT_29,                      P30      = BIT_30,                      P31      = BIT_31,NULL_PIN = 0
        } Mask;
 
        enum class Dir { IN  = 0,OUT = -1
        };
 
    public:
        static uint8_t from_mask (const Mask mask) {
            uint8_t  retVal  = 0;
            uint32_t maskInt = mask;
 
            while (maskInt >>= 1)
                ++retVal;
 
            return retVal;
        }
 
        static Mask to_mask (const uint8_t pinNum) {
            if (31 < pinNum)
                return Mask::NULL_PIN;
            else
                return static_cast<Mask>(1 << pinNum);
        }
 
        static void flash_port (const uint32_t pinMask, unsigned int iterations = 10) {
            const Port port(pinMask, Dir::OUT);
 
            const unsigned int delay = MILLISECOND << 7; // MILLISECOND * 64
            unsigned int       timer = delay + CNT;
            iterations <<= 1;
            for (uint32_t i = 0; i < iterations; ++i) {
                port.toggle();
                timer = waitcnt2(timer, delay);
            }
        }
 
    public:
        Port (const uint32_t portMask = Mask::NULL_PIN) {
            this->m_mask = portMask;
        }
 
        Port (const uint32_t portMask, const PropWare::Port::Dir direction) {
            this->m_mask = portMask;
            this->set_dir(direction);
        }
 
        void set_mask (const uint32_t mask) {
            this->m_mask = mask;
        }
 
        uint32_t get_mask () const {
            return this->m_mask;
        }
 
        void add_pins (const uint32_t mask) {
            this->m_mask |= mask;
        }
 
        void set_dir (const PropWare::Port::Dir direction) const {
            DIRA = (DIRA & ~(this->m_mask)) | (this->m_mask & static_cast<uint32_t>(direction));
        }
 
        PropWare::Port::Dir get_dir () const {
            if (DIRA & this->m_mask)
                return Dir::OUT;
            else
                return Dir::IN;
        }
 
        inline void set_dir_out () const {
            __asm__ volatile ("or dira, %0" : : "r" (this->m_mask));
        }
 
        inline void set_dir_in () const {
            __asm__ volatile ("andn dira, %0" : : "r" (this->m_mask));
        }
 
        void set () const {
            __asm__ volatile ("or outa, %0" : : "r" (this->m_mask));
        }
 
        void high () const {
            this->set();
        }
 
        void on () const {
            this->set();
        }
 
        void clear () const {
            __asm__ volatile ("andn outa, %0" : : "r" (this->m_mask));
        }
 
        void low () const {
            this->clear();
        }
 
        void off () const {
            this->clear();
        }
 
        void toggle () const {
            __asm__ volatile ("xor outa, %0" : : "r" (this->m_mask));
        }
 
        void write_fast (const uint32_t value) const {
            OUTA = ((OUTA & ~(this->m_mask)) | (value & this->m_mask));
        }
 
        uint32_t read_fast () const {
            return INA & this->m_mask;
        }
 
    protected:
        uint32_t m_mask;
};
 
}