LinuxGpio.hxx

Go to the documentation of this file.

 
#ifndef __LINUXGPIO_HXX
#define __LINUXGPIO_HXX
 
#include "freertos_drivers/common/GpioWrapper.hxx"
#include "os/Gpio.hxx"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
 
template <int PIN_NUM> class LinuxGpio
{
public:
    static constexpr const uint32_t PIN = PIN_NUM;
    
    static void export_pin()
    {
        FILE *fp = fopen("/sys/class/gpio/export","w");
        fprintf(fp,"%d\n",PIN);
        fclose(fp);
        // 50ms delay IS needed while kernel changes ownership of created GPIO directory
        usleep(50000); 
    }
    
    static void set_output()
    {
        char dirname[40];
        snprintf(dirname,sizeof(dirname),"/sys/class/gpio/gpio%d/direction",PIN);
        int dfd = -1;
        while ((dfd = open(dirname,O_WRONLY)) < 0) {
            export_pin();
        }
        write(dfd,"out\n",4);
        close(dfd);
    }
    static void set_input()
    {
        char dirname[40];
        snprintf(dirname,sizeof(dirname),"/sys/class/gpio/gpio%d/direction",PIN);
        int dfd = -1;
        while ((dfd = open(dirname,O_WRONLY)) < 0) {
            export_pin();
        }
        write(dfd,"in\n",3);
        close(dfd);
    }
    static void set_on()
    {
        char valname[40];
        snprintf(valname,sizeof(valname),"/sys/class/gpio/gpio%d/value",PIN);
        int vfd = open(valname,O_WRONLY);
        write(vfd,"1\n",2);
        close(vfd);
    }
    static void set_off()
    {
        char valname[40];
        snprintf(valname,sizeof(valname),"/sys/class/gpio/gpio%d/value",PIN);
        int vfd = open(valname,O_WRONLY);
        write(vfd,"0\n",2);
        close(vfd);
    }
    static bool get()
    {
        char valname[40], c;
        snprintf(valname,sizeof(valname),"/sys/class/gpio/gpio%d/value",PIN);
        int vfd = open(valname,O_RDONLY);
        read(vfd,&c,1);
        close(vfd);
        return (c != '0');
    }
    static void set(bool value)
    {
        if (value)
        {
            set_on();
        }
        else
        {
            set_off();
        }
    }
 
    static void toggle()
    {
        set(!get());
    }
 
    static bool is_output()
    {
        char dirname[40], c;
        snprintf(dirname,sizeof(dirname),"/sys/class/gpio/gpio%d/direction",PIN);
        int dfd = open(dirname,O_RDONLY);
        read(dfd,&c,1);
        close(dfd);
        return (c == 'o');
    }
};
 
 
template <class Base, bool SAFE_VALUE, bool INVERT = false> 
struct GpioOutputPin : public Base
{
public:
    static void hw_init()
    {
        Base::export_pin();
        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);
        }
    }
    static constexpr const Gpio *instance()
    {
        return GpioWrapper<GpioOutputPin<Base,SAFE_VALUE,INVERT>>::instance();
    }
};
 
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 ACTIVE_HIGH = true> 
struct GpioInputPin : public Base
{
public:
    static void hw_init()
    {
        Base::export_pin();
        Base::set_input();
    }
    static void hw_set_to_safe()
    {
        hw_init();
    }
    static const Gpio *instance()
    {
        return GpioWrapper<GpioInputPin<Base>>::instance();
    }
    static bool get()
    {
        if (ACTIVE_HIGH)
        {
            return Base::get();
        }
        else
        {
            return !Base::get();
        }
    }
};
 
template <class Defs>
struct GpioInputActiveHigh : public GpioInputPin<Defs, true>
{
};
 
template <class Defs>
struct GpioInputActiveLow : public GpioInputPin<Defs, false>
{
};
 
 
 
#define GPIO_PIN(NAME, BaseClass, NUM) \
    typedef BaseClass<LinuxGpio<NUM>> NAME##_Pin
 
#endif // __LINUXGPIO_HXX