pin.h

Go to the documentation of this file.

 
#pragma once
 
#include <PropWare/PropWare.h>
#include <PropWare/gpio/port.h>
 
namespace PropWare {
 
class Pin: public Port {
    public:
        enum class Channel {
                A,
                B
        };
 
    public:
        static void flash_pin (const Pin::Mask pinMask, const unsigned int iterations = 10) {
            flash_port(pinMask, iterations);
        }
 
    public:
        Pin (const PropWare::Pin::Mask mask = NULL_PIN)
            : Port(mask),
              m_channel(Channel::A) {
            this->update_pin_number();
        }
 
        Pin (const Pin::Mask mask, const Pin::Dir direction)
            : Port(mask, direction),
              m_channel(Channel::A) {
            this->update_pin_number();
        }
 
        void set_mask (const Pin::Mask mask) {
            this->Port::set_mask(mask);
            this->update_pin_number();
        }
 
        void set_pin_number (const uint8_t pinNum) {
            this->set_mask(Pin::to_mask(pinNum));
        }
 
        uint_fast8_t get_pin_number () const {
            return this->m_pinNumber;
        }
 
        Pin::Mask get_mask () const {
            return static_cast<Pin::Mask>(this->m_mask);
        }
 
        Channel get_channel () const {
            return this->m_channel;
        }
 
        void set_channel (const Channel channel) {
            this->m_channel = channel;
        }
 
        void write (const bool value) const {
            if (value)
                this->set();
            else
                this->clear();
        }
 
        bool read () const {
            return static_cast<bool>(this->read_fast());
        }
 
        void wait_until_high () const {
            waitpeq(this->m_mask, this->m_mask);
        }
 
        void wait_until_low () const {
            waitpeq(0, this->m_mask);
        }
 
        void wait_until_toggle () const {
            waitpne(this->read_fast(), this->m_mask);
        }
 
        bool is_switch_low (const uint16_t debounceDelayInMillis = 3) const {
            this->set_dir(Dir::IN);  // Set the pin as input
 
            if (!(this->read())) {   // If pin is grounded (aka, pressed)
                waitcnt(debounceDelayInMillis * MILLISECOND + CNT);
 
                return !(this->read());  // Check if it's still pressed
            }
 
            return false;
        }
 
        int rc_time (const bool state, const uint32_t timeout = SECOND / 4) {
            // Taken from Simple's rc_time(int pin, int state) in rcTime.C
            /*
            if(iodt == 0)                               // If dt not initialized
            {
              set_io_dt(CLKFREQ/1000000);               // Set up timed I/O time increment
              set_io_timeout(CLKFREQ/4);                // Set up timeout
            }
            */
            uint32_t ctr = static_cast<uint32_t>((8 + ((!state & 1) * 4)) << 26);        // POS detector counter setup
            ctr += this->m_pinNumber;                                                    // Add pin to setup
            const uint32_t startTime = CNT;                                              // Mark current time
            if (CTRA == 0) {
                // If CTRA unused
                CTRA = ctr;                                                              // Configure CTRA
                FRQA = 1;                                                                // FRQA increments PHSA by 1
                this->set_dir_in();
                PHSA = 0;                                                                // Clear PHSA
                // Wait for decay or timeout
                while (state == this->read() && (CNT - startTime <= timeout));
                CTRA = 0;                                                                // Stop the counter module
                return PHSA;
            } else if (CTRB == 0) {
                // If CTRA used, try CTRB
                CTRB = ctr;                                                              // Same procedure as for CTRA
                FRQB = 1;
                this->set_dir_in();
                PHSB = 0;
                while (state == this->read() && (CNT - startTime <= timeout));
                CTRB = 0;
                return PHSB;
            } else {
                // If CTRA & CTRB in use
                return -1;
            }
        }
 
        void start_hardware_pwm (const uint32_t frequency) const {
            this->stop_hardware_pwm();
 
            const uint32_t frq = static_cast<uint32_t>((UINT32_MAX + 1ULL) * frequency / CLKFREQ);
            const uint32_t ctr = (4 << 26) | this->m_pinNumber;
            if (Channel::A == this->m_channel) {
                FRQA = frq;
                PHSA = 0;
                CTRA = ctr;
            } else if (Channel::B == this->m_channel) {
                FRQB = frq;
                PHSB = 0;
                CTRB = ctr;
            }
        }
 
        void stop_hardware_pwm () const {
            if (Channel::A == this->m_channel) {
                CTRA = 0;
            } else if (Channel::B == this->m_channel) {
                CTRB = 0;
            }
        }
 
    private:
        void update_pin_number () {
            this->m_pinNumber = Pin::from_mask(static_cast<Mask>(this->m_mask));
        }
 
 
        /****************************************
         *** Nonsensical functions for a pin ***
         ****************************************/
        void set_mask (const uint32_t mask) {
        }
 
        void add_pins (const uint32_t mask) {
        }
 
        uint32_t read_fast () const {
            return this->Port::read_fast();
        }
 
    private:
        Channel      m_channel;
        uint_fast8_t m_pinNumber;
};
 
}