fastpin.h

Go to the documentation of this file.

#pragma once
 
#ifndef __INC_FASTPIN_H
#define __INC_FASTPIN_H
 
#include "FastLED.h"
#include "fl/compiler_control.h"
 
#include "led_sysdefs.h"
#include "fl/unused.h"
#include "fl/int.h"
#include "fl/register.h"
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wignored-qualifiers"
#ifdef ESP32
// Get rid of the endless volatile warnings in ESP32
#pragma GCC diagnostic ignored "-Wpragmas"
#pragma GCC diagnostic ignored "-Wvolatile"
#endif

 
FASTLED_NAMESPACE_BEGIN

#define NO_PIN 255

//
// Pin access class - needs to tune for various platforms (naive fallback solution?)
//

class Selectable {
public:
    #ifndef __AVR__
    virtual ~Selectable() {}
    #endif
    virtual void select() = 0;      
    virtual void release() = 0;     
    virtual bool isSelected() = 0;  
};
 
#if defined(FASTLED_STUB_IMPL) || defined(__EMSCRIPTEN__)
 
 
class Pin : public Selectable {
 
 
    void _init() {
    }
 
public:
    Pin(int pin) { FL_UNUSED(pin); }
 
 
    void setPin(int pin) { FL_UNUSED(pin); }
 
    typedef volatile RwReg * port_ptr_t;
    typedef RwReg port_t;
 
    inline void setOutput() { /* NOOP */ }
    inline void setInput() { /* NOOP */ }
    inline void setInputPullup() { /* NOOP */ }
 
 
    inline void hi() __attribute__ ((always_inline)) {}
    inline void lo() __attribute__ ((always_inline)) {}
 
 
    inline void strobe() __attribute__ ((always_inline)) {  }
    inline void toggle() __attribute__ ((always_inline)) { }
 
    inline void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { FL_UNUSED(port); }
    inline void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { FL_UNUSED(port); }
    inline void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { FL_UNUSED(val); }
 
    inline void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { FL_UNUSED(port); FL_UNUSED(val); }
 
    port_t hival() __attribute__ ((always_inline)) { return 0; }
    port_t loval() __attribute__ ((always_inline)) { return 0; }
    port_ptr_t  port() __attribute__ ((always_inline)) {
        static volatile RwReg port = 0;
        return &port;
    }
    port_t mask() __attribute__ ((always_inline)) { return 0xff; }
 
    virtual void select() override { hi(); }
    virtual void release() override { lo(); }
    virtual bool isSelected() override { return true; }
};
 
class OutputPin : public Pin {
public:
    OutputPin(int pin) : Pin(pin) { setOutput(); }
};
 
class InputPin : public Pin {
public:
    InputPin(int pin) : Pin(pin) { setInput(); }
};
 
#elif !defined(FASTLED_NO_PINMAP)

class Pin : public Selectable {
    volatile RwReg *mPort;    
    volatile RoReg *mInPort;  
    RwReg mPinMask;  
    fl::u8 mPin;    

    void _init() {
        mPinMask = digitalPinToBitMask(mPin);
        mPort = (volatile RwReg*)portOutputRegister(digitalPinToPort(mPin));
        mInPort = (volatile RoReg*)portInputRegister(digitalPinToPort(mPin));
    }
 
public:
    Pin(int pin) : mPin(pin) { _init(); }
    #ifndef __AVR__
    virtual ~Pin() {}  // Shut up the compiler warning, but don't steal bytes from AVR.
    #endif
 
    typedef volatile RwReg * port_ptr_t;  
    typedef RwReg port_t;  

    inline void setOutput() { pinMode(mPin, OUTPUT); }

    inline void setInput() { pinMode(mPin, INPUT); }
 
    inline void setInputPullup() { pinMode(mPin, INPUT_PULLUP); }

    FL_DISABLE_WARNING_PUSH
    FL_DISABLE_WARNING_NULL_DEREFERENCE
    inline void hi() __attribute__ ((always_inline)) { *mPort |= mPinMask; }
    inline void lo() __attribute__ ((always_inline)) { *mPort &= ~mPinMask; }
    FL_DISABLE_WARNING_POP

    inline void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
    inline void toggle() __attribute__ ((always_inline)) { *mInPort = mPinMask; }

    inline void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port |= mPinMask; }
    inline void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~mPinMask; }
    inline void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *mPort = val; }

    inline void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port  = val; }

    port_t hival() __attribute__ ((always_inline)) { return *mPort | mPinMask;  }
    port_t loval() __attribute__ ((always_inline)) { return *mPort & ~mPinMask; }
    port_ptr_t  port() __attribute__ ((always_inline)) { return mPort; }
    port_t mask() __attribute__ ((always_inline)) { return mPinMask; }

    virtual void select() override { hi(); }
    virtual void release() override { lo(); }
    virtual bool isSelected() override { return (*mPort & mPinMask) == mPinMask; }
};

class OutputPin : public Pin {
public:
    OutputPin(int pin) : Pin(pin) { setOutput(); }
};

class InputPin : public Pin {
public:
    InputPin(int pin) : Pin(pin) { setInput(); }
};
 
#else
// This is the empty code version of the raw pin class, method bodies should be filled in to Do The Right Thing[tm] when making this
// available on a new platform
 
class Pin : public Selectable {
    volatile RwReg *mPort;
    volatile RoReg *mInPort;
    RwReg mPinMask;
    fl::u8 mPin;
 
    RwReg mPortFake = 0;
    RoReg mInPortFake = 0;
 
 
 
    void _init() {
        // TODO: fill in init on a new platform
        mPinMask = 0;
        mPort = &mPortFake;
        mInPort = &mInPortFake;
    }
 
public:
    Pin(int pin) : mPin(pin) { _init(); }
    #ifndef __AVR__
    virtual ~Pin() {}  // Shut up the compiler warning, but don't steal bytes from AVR.
    #endif
 
    void setPin(int pin) { mPin = pin; _init(); }
 
    typedef volatile RwReg * port_ptr_t;
    typedef RwReg port_t;
 
    inline void setOutput() { /* TODO: Set pin output */ }
    inline void setInput() { /* TODO: Set pin input */ }
    inline void setInputPullup() { /* TODO: Set pin input pullup */ }

    FL_DISABLE_WARNING_PUSH
    FL_DISABLE_WARNING_NULL_DEREFERENCE
    inline void hi() __attribute__ ((always_inline)) { *mPort |= mPinMask; }
    inline void lo() __attribute__ ((always_inline)) { *mPort &= ~mPinMask; }
    FL_DISABLE_WARNING_POP
 
    inline void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
    inline void toggle() __attribute__ ((always_inline)) { *mInPort = mPinMask; }
 
    inline void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port |= mPinMask; }
    inline void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~mPinMask; }
    inline void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *mPort = val; }
 
    inline void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port  = val; }
 
    port_t hival() __attribute__ ((always_inline)) { return *mPort | mPinMask;  }
    port_t loval() __attribute__ ((always_inline)) { return *mPort & ~mPinMask; }
    port_ptr_t  port() __attribute__ ((always_inline)) { return mPort; }
    port_t mask() __attribute__ ((always_inline)) { return mPinMask; }
 
    virtual void select() override { hi(); }
    virtual void release() override { lo(); }
    virtual bool isSelected() override { return (*mPort & mPinMask) == mPinMask; }
};
 
class OutputPin : public Pin {
public:
    OutputPin(int pin) : Pin(pin) { setOutput(); }
};
 
class InputPin : public Pin {
public:
    InputPin(int pin) : Pin(pin) { setInput(); }
};
 
#endif

#ifdef FASTLED_FORCE_SOFTWARE_PINS
template<fl::u8 PIN> class FastPin {
    static RwReg sPinMask;            
    static volatile RwReg *sPort;     
    static volatile RoReg *sInPort;   
    static void _init() {
#if !defined(FASTLED_NO_PINMAP)
        sPinMask = digitalPinToBitMask(PIN);
        sPort = portOutputRegister(digitalPinToPort(PIN));
        sInPort = portInputRegister(digitalPinToPort(PIN));
#endif
    }
 
public:
    typedef volatile RwReg * port_ptr_t;  
    typedef RwReg port_t;  

    inline static void setOutput() { _init(); pinMode(PIN, OUTPUT); }
    inline static void setInput() { _init(); pinMode(PIN, INPUT); }

    inline static void hi() __attribute__ ((always_inline)) { *sPort |= sPinMask; }
    inline static void lo() __attribute__ ((always_inline)) { *sPort &= ~sPinMask; }

    inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }

    inline static void toggle() __attribute__ ((always_inline)) { *sInPort = sPinMask; }

    inline static void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port |= sPinMask; }
    inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~sPinMask; }
    inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *sPort = val; }

    inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port  = val; }

    static port_t hival() __attribute__ ((always_inline)) { return *sPort | sPinMask;  }
    static port_t loval() __attribute__ ((always_inline)) { return *sPort & ~sPinMask; }
    static port_ptr_t  port() __attribute__ ((always_inline)) { return sPort; }
    static port_t mask() __attribute__ ((always_inline)) { return sPinMask; }
};
 
template<fl::u8 PIN> RwReg FastPin<PIN>::sPinMask;
template<fl::u8 PIN> volatile RwReg *FastPin<PIN>::sPort;
template<fl::u8 PIN> volatile RoReg *FastPin<PIN>::sInPort;
 
#else
 
template<fl::u8 PIN> class FastPin {
    // This is a default implementation. If you are hitting this then FastPin<> is either:
    // 1) Not defined -or-
    // 2) Not part of the set of defined FastPin<> specializations for your platform
    // You need to define a FastPin<> specialization
    // or change what get's included for your particular build target.
    // Keep in mind that these messages are cryptic, so it's best to define an invalid in type.
    constexpr static bool validpin() { return false; }
    constexpr static bool LowSpeedOnlyRecommended() {  // Some implementations assume this exists.
        // Caller must always determine if high speed use if allowed on a given pin,
        // because it depends on more than just the chip packaging ... it depends on entire board (and even system) design.
        return false; // choosing default to be FALSE, to allow users to ATTEMPT to use high-speed on pins where support is not known
    }
 
    static_assert(validpin(), "This pin has been marked as an invalid pin, common reasons includes it being a ground pin, read only, or too noisy (e.g. hooked up to the uart).");
 
    static void _init() { }
 
public:
    typedef volatile RwReg * port_ptr_t;  
    typedef RwReg port_t;  

    inline static void setOutput() { }
    inline static void setInput() { }

    inline static void hi() __attribute__ ((always_inline)) { }
    inline static void lo() __attribute__ ((always_inline)) { }

    inline static void strobe() __attribute__ ((always_inline)) { }

    inline static void toggle() __attribute__ ((always_inline)) { }

    inline static void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) {
        FASTLED_UNUSED(port);
    }
    inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) {
        FASTLED_UNUSED(port);
    }
    inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) {
        FASTLED_UNUSED(val);
    }

    inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) {
        FASTLED_UNUSED(port);
        FASTLED_UNUSED(val);
    }

    static port_t hival() __attribute__ ((always_inline)) { return 0; }
    static port_t loval() __attribute__ ((always_inline)) { return 0;}
    static port_ptr_t  port() __attribute__ ((always_inline)) { return NULL; }
    static port_t mask() __attribute__ ((always_inline)) { return 0; }
};
 
#endif

template<fl::u8 PIN> class FastPinBB : public FastPin<PIN> {};
 
typedef volatile fl::u32 & reg32_t;      
typedef volatile fl::u32 * ptr_reg32_t;  

template<fl::u8 port> struct __FL_PORT_INFO {
    static bool hasPort() { return 0; }
    static const char *portName() { return "--"; }
    static const void *portAddr() { return NULL; }
};
 

#define _FL_DEFINE_PORT(L, BASE) template<> struct __FL_PORT_INFO<L> { \
    static bool hasPort() { return 1; } \
    static const char *portName() { return #L; } \
    typedef BASE __t_baseType;  \
    static const void *portAddr() { return (void*)&__t_baseType::r(); } };

#define _FL_DEFINE_PORT3(L, LC, BASE) template<> struct __FL_PORT_INFO<LC> { \
    static bool hasPort() { return 1; } \
    static const char *portName() { return #L; } \
    typedef BASE __t_baseType;  \
    static const void *portAddr() { return (void*)&__t_baseType::r(); } };
 
FASTLED_NAMESPACE_END
 
#pragma GCC diagnostic pop
 
#endif // __INC_FASTPIN_H