FL_DISABLE_WARNING()

FL_DISABLE_WARNING_PUSH FL_DISABLE_WARNING_DEPRECATED_REGISTER FL_DISABLE_WARNING_VOLATILE FL_DISABLE_WARNING_PUSH FL_DISABLE_WARNING

(

ignored-

qualifiers

)

Mixin base class that provides the default validpin() implementation for explicitly declared pins. All platform-specific pin classes (_ARMPIN, _ESPPIN, etc.) should inherit from this to indicate that explicitly defined pins are valid by default. Undefined pins use the default FastPin<> template which returns false.

All explicitly declared pins are valid by default Platforms can override this in specific cases to mark pins as invalid (e.g., ground pins, UART pins)

Abstract class for "selectable" things

< Select this object

< Release this object

< Check if this object is currently selected

The simplest level of Pin class. This relies on runtime functions during initialization to get the port/pin mask for the pin. Most of the accesses involve references to these static globals that get set up. This won't be the fastest set of pin operations, but it will provide pin level access on pretty much all Arduino environments. In addition, it includes some methods to help optimize access in various ways. Namely, the versions of hi(), lo(), and fastset() that take the port register as a passed in register variable (saving a global dereference), since these functions are aggressively inlined, that can help collapse out a lot of extraneous memory loads/dereferences.

In addition, if, while writing a bunch of data to a pin, you know no other pins will be getting written to, you can get/cache a value of the pin's port register and use that to do a full set to the register. This results in one being able to simply do a store to the register, vs. the load, and/or, and store that would be done normally.

There are platform specific instantiations of this class that provide direct i/o register access to pins for much higher speed pin twiddling.

Note that these classes are all static functions. So the proper usage is Pin<13>::hi(); or such. Instantiating objects is not recommended, as passing Pin objects around will likely -not- have the effect you're expecting.

<

<

FastPin implementation for bit-banded access. Only for MCUs that support bitbanding.

Note

This bitband class is optional!

< Reference to a 32-bit register, volatile

< Pointer to a 32-bit register, volatile

Utility template for tracking down information about pins and ports

Template Parameters

port	the port to check information for

Checks whether a port exists

Gets the name of the port, as a C-string

Gets the raw address of the port

Macro to create the instantiations for defined ports. We're going to abuse this later for auto discovery of pin/port mappings for new variants. Use this for ports that are numeric in nature, e.g. GPIO0, GPIO1, etc.

Parameters

L	the number of the port
BASE	the data type for the register

Macro to create the instantiations for defined ports. We're going to abuse this later for auto discovery of pin/port mappings for new variants. Use this for ports that are letters. The first parameter will be the letter, the second parameter will be an integer/counter of some kind. This is because attempts to turn macro parameters into character constants break in some compilers.

Parameters

L	the letter of the port
LC	an integer counter
BASE	the data type for the register

Definition at line 19 of file fastpin_base.h.

             {

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

struct ValidPinBase {
    static constexpr bool validpin() FL_NOEXCEPT { return true; }
};

class Selectable {
public:
    #ifndef FL_IS_AVR
    virtual ~Selectable() FL_NOEXCEPT {}
    #endif
    virtual void select() FL_NOEXCEPT = 0;      
    virtual void release() FL_NOEXCEPT = 0;     
    virtual bool isSelected() FL_NOEXCEPT = 0;  
};

#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, PinMode::Output); }
    inline static void setInput() { _init(); pinMode(PIN, PinMode::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.
#ifdef FASTLED_ALL_PINS_VALID
    constexpr static bool validpin() FL_NOEXCEPT { return true; }
#else
    constexpr static bool validpin() { return false; }
#endif
    constexpr static bool LowSpeedOnlyRecommended() FL_NOEXCEPT {  // 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
    }
 
    FL_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() FL_NOEXCEPT { }
 
public:
    typedef volatile RwReg * port_ptr_t;  
    typedef RwReg port_t;  

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

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

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

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

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

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

    static port_t hival() FL_NOEXCEPT __attribute__ ((always_inline)) { return 0; }
    static port_t loval() FL_NOEXCEPT __attribute__ ((always_inline)) { return 0;}
    static port_ptr_t  port() FL_NOEXCEPT __attribute__ ((always_inline)) { return nullptr; }
    static port_t mask() FL_NOEXCEPT __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() FL_NOEXCEPT { return 0; }
    static const char *portName() FL_NOEXCEPT { return "--"; }
    static const void *portAddr() FL_NOEXCEPT { return nullptr; }
};
 

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

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

References FASTLED_REGISTER, FASTLED_UNUSED, FL_DISABLE_WARNING_VOLATILE, FL_NOEXCEPT, FL_STATIC_ASSERT, PIN, and toggle.