fastpin_base.h

Go to the documentation of this file.

 
#pragma once
 
#include "platforms/is_platform.h"
#include "fl/stl/compiler_control.h"
#include "fl/stl/noexcept.h"
#include "fl/stl/static_assert.h"
 
FL_DISABLE_WARNING_PUSH
FL_DISABLE_WARNING_DEPRECATED_REGISTER
FL_DISABLE_WARNING_VOLATILE
 
FL_DISABLE_WARNING_PUSH
FL_DISABLE_WARNING(ignored-qualifiers)
#ifdef FL_IS_ESP32
// Get rid of the endless volatile warnings in ESP32
FL_DISABLE_WARNING(pragmas)
FL_DISABLE_WARNING_VOLATILE
#endif
 
namespace fl {

//
// 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
 
FL_DISABLE_WARNING_POP
 
FL_DISABLE_WARNING_POP