ArduinoGpio.hxx

Go to the documentation of this file.

 
#ifndef _DRIVERS_ARDUINOGPIO_HXX_
#define _DRIVERS_ARDUINOGPIO_HXX_
 
#include "os/Gpio.hxx"
#include "GpioWrapper.hxx"
#if defined(ESP32)
#include <esp32-hal.h>
#include <driver/gpio.h>
#else
#include <Arduino.h>
#endif
 
template <int PIN_NUM>
class ArduinoStaticGpio
{
public:
    static void set_output()
    {
        pinMode(PIN_NUM, OUTPUT);
    }
 
    static void set_input()
    {
        pinMode(PIN_NUM, INPUT);
    }
 
    static void set_pullup_on()
    {
        digitalWrite(PIN_NUM, HIGH);
    }
 
    static void set_pullup_off()
    {
        digitalWrite(PIN_NUM, LOW);
    }
 
    static void set_on()
    {
        digitalWrite(PIN_NUM, HIGH);
    }
 
    static void set_off()
    {
        digitalWrite(PIN_NUM, LOW);
    }
 
    static bool get()
    {
        return digitalRead(PIN_NUM);
    }
 
    static void set(bool value)
    {
        if (value)
        {
            set_on();
        }
        else
        {
            set_off();
        }
    }
 
    static void toggle()
    {
        set(!get());
    }
 
    static bool is_output()
    {
#if defined(ESP32)
        if(digitalPinIsValid(PIN_NUM) && digitalPinCanOutput(PIN_NUM))
        {
            // pins 32 and below use the first GPIO controller
            if(PIN_NUM < 32)
            {
                return GPIO.enable_w1ts & ((uint32_t)1 << (PIN_NUM & 31));
            }
            else
            {
                return GPIO.enable1_w1ts.val & ((uint32_t)1 << (PIN_NUM & 31));
            }
        }
#endif
        return false;
    }
 
    static constexpr const Gpio *instance()
    {
        return GpioWrapper<ArduinoStaticGpio<PIN_NUM>>::instance();
    }
};
 
template <class Base, bool SAFE_VALUE, bool INVERT = false>
struct GpioOutputPin : public Base
{
public:
    static void hw_init()
    {
        Base::set(SAFE_VALUE);
        Base::set_output();
        Base::set(SAFE_VALUE);
    }
    static void hw_set_to_safe()
    {
        Base::set(SAFE_VALUE);
    }
    static void set(bool value)
    {
        if (INVERT)
        {
            Base::set(!value);
        }
        else
        {
            Base::set(value);
        }
    }
};
 
template <class Defs>
struct GpioOutputSafeLow : public GpioOutputPin<Defs, false>
{
};
 
template <class Defs>
struct GpioOutputSafeLowInvert : public GpioOutputPin<Defs, false, true>
{
};
 
template <class Defs>
struct GpioOutputSafeHigh : public GpioOutputPin<Defs, true>
{
};
 
template <class Defs>
struct GpioOutputSafeHighInvert : public GpioOutputPin<Defs, true, true>
{
};
 
template <class Base, bool PUEN> struct GpioInputPar : public Base
{
public:
    static void hw_init()
    {
        Base::set_input();
        if (PUEN)
        {
            Base::set_pullup_on();
        }
        else
        {
            Base::set_pullup_off();
        }
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
};
 
template <class Defs> struct GpioInputNP : public GpioInputPar<Defs, false>
{
};
 
template <class Defs> struct GpioInputPU : public GpioInputPar<Defs, true>
{
};
 
#define GPIO_PIN(NAME, BaseClass, NUM)                                         \
    typedef BaseClass<ArduinoStaticGpio<NUM>> NAME##_Pin
 
#endif // _DRIVERS_ARDUINOGPIO_HXX_