exploringBB::GPIO Class Reference

GPIO class for input and output functionality on a single GPIO pin. More...

#include <GPIO.h>

Public Types
enum	DIRECTION { INPUT, OUTPUT }
enum	VALUE { LOW =0, HIGH =1 }
enum	EDGE { NONE, RISING, FALLING, BOTH }

Public Member Functions
	GPIO (int number)
virtual int	getNumber ()
virtual int	setDirection (GPIO::DIRECTION)
virtual GPIO::DIRECTION	getDirection ()
virtual int	setValue (GPIO::VALUE)
virtual int	toggleOutput ()
virtual GPIO::VALUE	getValue ()
virtual int	setActiveLow (bool isLow=true)
virtual int	setActiveHigh ()
virtual void	setDebounceTime (int time)
virtual int	streamOpen ()
virtual int	streamWrite (GPIO::VALUE)
virtual int	streamClose ()
virtual int	toggleOutput (int time)
virtual int	toggleOutput (int numberOfTimes, int time)
virtual void	changeToggleTime (int time)
virtual void	toggleCancel ()
virtual int	setEdgeType (GPIO::EDGE)
virtual GPIO::EDGE	getEdgeType ()
virtual int	waitForEdge ()
virtual int	waitForEdge (CallbackType callback)
virtual void	waitForEdgeCancel ()
virtual	~GPIO ()

Friends
void *	threadedPoll (void *value)
void *	threadedToggle (void *value)

Detailed Description

GPIO class for input and output functionality on a single GPIO pin.

Member Enumeration Documentation

enum exploringBB::GPIO::DIRECTION

Enumerator
INPUT
OUTPUT

{ INPUT, OUTPUT };

enum exploringBB::GPIO::EDGE

Enumerator
NONE
RISING
FALLING
BOTH

{ NONE, RISING, FALLING, BOTH };

enum exploringBB::GPIO::VALUE

Enumerator
LOW
HIGH

{ LOW=0, HIGH=1 };

Constructor & Destructor Documentation

exploringBB::GPIO::GPIO

(

int

number

)

The constructor will set up the states and export the pin.

Parameters

number

The GPIO number to be exported

                     {
        this->number = number;
        this->debounceTime = 0;
        this->togglePeriod=100;
        this->toggleNumber=-1; //infinite number
        this->callbackFunction = NULL;
        this->threadRunning = false;

        ostringstream s;
        s << "gpio" << number;
        this->name = string(s.str());
        this->path = GPIO_PATH + this->name + "/";
        this->exportGPIO();
        // need to give Linux time to set up the sysfs structure
        usleep(250000); // 250ms delay
}

exploringBB::GPIO::~GPIO ( )

virtual

            {
        this->unexportGPIO();
}

Member Function Documentation

virtual void exploringBB::GPIO::changeToggleTime ( int  time )

inlinevirtual

{ this->togglePeriod = time; }

GPIO::DIRECTION exploringBB::GPIO::getDirection ( )

virtual

                                {
        string input = read(this->path, "direction");
        if (input == "in") return INPUT;
        else return OUTPUT;
}

GPIO::EDGE exploringBB::GPIO::getEdgeType ( )

virtual

                          {
        string input = read(this->path, "edge");
        if (input == "rising") return RISING;
        else if (input == "falling") return FALLING;
        else if (input == "both") return BOTH;
        else return NONE;
}

virtual int exploringBB::GPIO::getNumber ( )

inlinevirtual

Returns the GPIO number as an int.

GPIO::VALUE exploringBB::GPIO::getValue ( )

virtual

                        {
        string input = read(this->path, "value");
        if (input == "0") return LOW;
        else return HIGH;
}

int exploringBB::GPIO::setActiveHigh ( )

virtual

                       {
   return this->setActiveLow(false);
}

int exploringBB::GPIO::setActiveLow ( bool  isLow = true )

virtual

                                {
   if(isLow) return write(this->path, "active_low", "1");
   else return write(this->path, "active_low", "0");
}

virtual void exploringBB::GPIO::setDebounceTime ( int  time )

inlinevirtual

{ this->debounceTime = time; }

int exploringBB::GPIO::setDirection ( GPIO::DIRECTION  dir )

virtual

                                       {
   switch(dir){
   case INPUT: return write(this->path, "direction", "in");
      break;
   case OUTPUT:return write(this->path, "direction", "out");
      break;
   }
   return -1;
}

int exploringBB::GPIO::setEdgeType ( GPIO::EDGE  value )

virtual

                                   {
   switch(value){
   case NONE: return write(this->path, "edge", "none");
      break;
   case RISING: return write(this->path, "edge", "rising");
      break;
   case FALLING: return write(this->path, "edge", "falling");
      break;
   case BOTH: return write(this->path, "edge", "both");
      break;
   }
   return -1;
}

int exploringBB::GPIO::setValue ( GPIO::VALUE  value )

virtual

                                 {
   switch(value){
   case HIGH: return write(this->path, "value", "1");
      break;
   case LOW: return write(this->path, "value", "0");
      break;
   }
   return -1;
}

int exploringBB::GPIO::streamClose ( )

virtual

                     {
        stream.close();
        return 0;
}

int exploringBB::GPIO::streamOpen ( )

virtual

                    {
        stream.open((path + "value").c_str());
        return 0;
}

int exploringBB::GPIO::streamWrite ( GPIO::VALUE  value )

virtual

                                    {
        stream << value << std::flush;
        return 0;
}

virtual void exploringBB::GPIO::toggleCancel ( )

inlinevirtual

{ this->threadRunning = false; }

int exploringBB::GPIO::toggleOutput ( )

virtual

                      {
        this->setDirection(OUTPUT);
        if ((bool) this->getValue()) this->setValue(LOW);
        else this->setValue(HIGH);
    return 0;
}

int exploringBB::GPIO::toggleOutput ( int  time )

virtual

{ return this->toggleOutput(-1, time); }

int exploringBB::GPIO::toggleOutput ( int  numberOfTimes, int  time  )

virtual

                                                 {
        this->setDirection(OUTPUT);
        this->toggleNumber = numberOfTimes;
        this->togglePeriod = time;
        this->threadRunning = true;
    if(pthread_create(&this->thread, NULL, &threadedToggle, static_cast<void*>(this))){
        perror("GPIO: Failed to create the toggle thread");
        this->threadRunning = false;
        return -1;
    }
    return 0;
}

int exploringBB::GPIO::waitForEdge ( )

virtual

                     {
        this->setDirection(INPUT); // must be an input pin to poll its value
        int fd, i, epollfd, count=0;
        struct epoll_event ev;
        epollfd = epoll_create(1);
    if (epollfd == -1) {
           perror("GPIO: Failed to create epollfd");
           return -1;
    }
    if ((fd = open((this->path + "value").c_str(), O_RDONLY | O_NONBLOCK)) == -1) {
       perror("GPIO: Failed to open file");
       return -1;
    }

    //ev.events = read operation | edge triggered | urgent data
    ev.events = EPOLLIN | EPOLLET | EPOLLPRI;
    ev.data.fd = fd;  // attach the file file descriptor

    //Register the file descriptor on the epoll instance, see: man epoll_ctl
    if (epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev) == -1) {
       perror("GPIO: Failed to add control interface");
       return -1;
    }
        while(count<=1){  // ignore the first trigger
                i = epoll_wait(epollfd, &ev, 1, -1);
                if (i==-1){
                        perror("GPIO: Poll Wait fail");
                        count=5; // terminate loop
                }
                else {
                        count++; // count the triggers up
                }
        }
    close(fd);
    if (count==5) return -1;
        return 0;
}

int exploringBB::GPIO::waitForEdge ( CallbackType  callback )

virtual

                                          {
        this->threadRunning = true;
        this->callbackFunction = callback;
    // create the thread, pass the reference, address of the function and data
    if(pthread_create(&this->thread, NULL, &threadedPoll, static_cast<void*>(this))){
        perror("GPIO: Failed to create the poll thread");
        this->threadRunning = false;
        return -1;
    }
    return 0;
}

virtual void exploringBB::GPIO::waitForEdgeCancel ( )

inlinevirtual

{ this->threadRunning = false; }

Friends And Related Function Documentation

void* threadedPoll ( void *  value )

friend

                               {
        GPIO *gpio = static_cast<GPIO*>(value);
        while(gpio->threadRunning){
                gpio->callbackFunction(gpio->waitForEdge());
                usleep(gpio->debounceTime * 1000);
        }
        return 0;
}

void* threadedToggle ( void *  value )

friend

                                 {
        GPIO *gpio = static_cast<GPIO*>(value);
        bool isHigh = (bool) gpio->getValue(); //find current value
        while(gpio->threadRunning){
                if (isHigh)     gpio->setValue(GPIO::HIGH);
                else gpio->setValue(GPIO::LOW);
                usleep(gpio->togglePeriod * 500);
                isHigh=!isHigh;
                if(gpio->toggleNumber>0) gpio->toggleNumber--;
                if(gpio->toggleNumber==0) gpio->threadRunning=false;
        }
        return 0;
}

---

The documentation for this class was generated from the following files:

• /home/molloyd/exploringBB/library/gpio/GPIO.h
• /home/molloyd/exploringBB/library/gpio/GPIO.cpp