Esp8266Gpio.hxx

Go to the documentation of this file.

 
#ifndef _DRIVERS_ESP8266_ESP8266GPIO_HXX_
#define _DRIVERS_ESP8266_ESP8266GPIO_HXX_
 
#include "os/Gpio.hxx"
 
extern "C" {
#include <gpio.h>
#include <eagle_soc.h>
 
void gpio16_output_conf(void);
 
void gpio16_output_set(uint8 value);
 
void gpio16_input_conf(void);
 
uint8 gpio16_input_get(void);
 
 
}
 
constexpr uint32_t pinmux_to_gpio_arr[] = {
    PERIPHS_IO_MUX_GPIO0_U,    // 0
    PERIPHS_IO_MUX_U0TXD_U,    // 1
    PERIPHS_IO_MUX_GPIO2_U,    // 2
    PERIPHS_IO_MUX_U0RXD_U,    // 3
    PERIPHS_IO_MUX_GPIO4_U,    // 4
    PERIPHS_IO_MUX_GPIO5_U,    // 5
    PERIPHS_IO_MUX_SD_CLK_U,   // 6
    PERIPHS_IO_MUX_SD_DATA0_U, // 7
    PERIPHS_IO_MUX_SD_DATA1_U, // 8
    PERIPHS_IO_MUX_SD_DATA2_U, // 9
    PERIPHS_IO_MUX_SD_DATA3_U, // 10
    PERIPHS_IO_MUX_SD_CMD_U,   // 11
    PERIPHS_IO_MUX_MTDI_U,     // 12
    PERIPHS_IO_MUX_MTCK_U,     // 13
    PERIPHS_IO_MUX_MTMS_U,     // 14
    PERIPHS_IO_MUX_MTDO_U,     // 15
};
 
constexpr uint32_t gpio_num_to_pinmux_reg(int gpio_pin_num)
{
    return pinmux_to_gpio_arr[gpio_pin_num];
}
 
template <int PIN_NUM, uint32_t MUXREG, uint32_t FUNC_GPIO>
class Esp8266StaticGpio
{
public:
    static constexpr const uint32_t PIN = PIN_NUM;
    static constexpr const uint32_t PIN_BIT = (1 << PIN_NUM);
    static constexpr const uint32_t PIN_MUX_REG = MUXREG;
    static constexpr const uint32_t PIN_MUX_FUNC_GPIO = FUNC_GPIO;
 
    static void set_gpio()
    {
        PIN_FUNC_SELECT(PIN_MUX_REG, PIN_MUX_FUNC_GPIO);
    }
 
    static void set_output()
    {
        GPIO_REG_WRITE(GPIO_ENABLE_W1TS_ADDRESS, PIN_BIT);
    }
 
    static void set_input()
    {
        GPIO_REG_WRITE(GPIO_ENABLE_W1TC_ADDRESS, PIN_BIT);
    }
 
    static void set_pullup_on()
    {
        CLEAR_PERI_REG_MASK(PIN_MUX_REG, PERIPHS_IO_MUX_PULLUP2 | PERIPHS_IO_MUX_SLEEP_PULLUP | PERIPHS_IO_MUX_SLEEP_PULLUP2);
        SET_PERI_REG_MASK(PIN_MUX_REG, PERIPHS_IO_MUX_PULLUP);
    }
 
    static void set_pullup_off()
    {
        CLEAR_PERI_REG_MASK(
            PIN_MUX_REG, PERIPHS_IO_MUX_PULLUP | PERIPHS_IO_MUX_PULLUP2);
    }
 
    static void set_pulldown_on()
    {
        CLEAR_PERI_REG_MASK(PIN_MUX_REG, PERIPHS_IO_MUX_PULLUP | PERIPHS_IO_MUX_SLEEP_PULLUP | PERIPHS_IO_MUX_SLEEP_PULLUP2);
        SET_PERI_REG_MASK(PIN_MUX_REG, PERIPHS_IO_MUX_PULLUP2);
    }
 
    static void set_pulldown_off()
    {
        CLEAR_PERI_REG_MASK(
            PIN_MUX_REG, PERIPHS_IO_MUX_PULLUP | PERIPHS_IO_MUX_PULLUP2);
    }
 
    static void set_on()
    {
        GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, PIN_BIT);
    }
 
    static void set_off()
    {
        GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, PIN_BIT);
    }
 
    static bool get()
    {
        return (GPIO_REG_READ(GPIO_IN_ADDRESS) & PIN_BIT) != 0;
    }
 
    static void set(bool value)
    {
        if (value)
        {
            set_on();
        }
        else
        {
            set_off();
        }
    }
 
    static void toggle()
    {
        set(!get());
    }
 
    static bool is_output()
    {
        return GPIO_REG_READ(GPIO_ENABLE_ADDRESS) & PIN_BIT;
    }
};
 
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_gpio();
        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 Base>
struct GpioPullOutPin : public Base
{
public:
    static void hw_init()
    {
        Base::set_input();
        Base::set_gpio();
        Base::set_pullup_on();
    }
    static void hw_set_to_safe()
    {
        Base::set_pullup_on();
    }
    static void set(bool value)
    {
        if (value) {
            Base::set_pullup_on();
        } else {
            Base::set_pulldown_on();
        }
    }
    static void set_on() {
        Base::set_pullup_on();
    }
    static void set_off() {
        Base::set_pulldown_on();
    }
};
 
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();
        }
        Base::set_gpio();
    }
    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<Esp8266StaticGpio<NUM, gpio_num_to_pinmux_reg(NUM),      \
        FUNC_GPIO##NUM>> NAME##_Pin
 
#endif // _DRIVERS_ESP8266_ESP8266GPIO_HXX_