gpiopin.h

#ifndef _SYSIO_GPIO_PIN_H_
#define _SYSIO_GPIO_PIN_H_

#include <string>
#include <vector>
#include <map>
#include <memory>
#include <atomic>
#include <thread>
#include <mutex>

namespace Sysio {

  class Gpio;
  class Device;
  class Connector;

  enum AccessLayer {
    AccessLayerAuto  = 0, //< Choix automatique (à utiliser la plupart du temps), c'est la plateforme qui choisit par le GpioDevice
    AccessLayerIoMap = 0x0001, 
    AccessLayerSysFs = 0x0002, 
    AccessLayerAll = AccessLayerIoMap + AccessLayerSysFs 
  };
  class Pin {

    public:
      friend class Connector;

      enum Mode {
        ModeInput = 0, 
        ModeOutput, 
        ModeDisabled, 
        ModePwm, 
        ModeAlt0, 
        ModeAlt1, 
        ModeAlt2, 
        ModeAlt3, 
        ModeAlt4, 
        ModeAlt5, 
        ModeAlt6, 
        ModeAlt7, 
        ModeAlt8, 
        ModeAlt9, 
        ModeUnknown = -1
      };

      enum Pull {
        PullOff = 0, 
        PullDown, 
        PullUp, 
        PullUnknown = -1
      };

      enum Edge {
        EdgeNone = 0, 
        EdgeRising,   
        EdgeFalling,  
        EdgeBoth,     
        EdgeUnknown = -1
      };

      enum Numbering {
        NumberingLogical = 0, 
        NumberingMcu, 
        NumberingSystem, 
        NumberingUnknown = -1
      };

      enum  Type {
        TypeGpio = 0, 
        TypePower, 
        TypeUsb, 
        TypeSound, 
        TypeVideo, 
        TypeNotConnected, 
        TypeUnknown = -1
      };

      class Number {
        public:
          int logical; 
          int mcu; 
          int system; 
          int row; 
          int column; 
      };

      class Descriptor {
        public:
          Type type; 
          Number num; 
          std::map<Mode, std::string> name; 
      };


      //------------------------------------------------------------------------
      //                          Opérations
      //------------------------------------------------------------------------

      Mode mode();

      void setMode (Mode mode);

      Pull pull();

      void setPull (Pull pull);

      Edge edge();

      void setEdge (Edge edge);

      void write (bool value);

      void toggle();

      bool read() const;

      void release();

      void waitForInterrupt (Edge edge, int timeout_ms = -1);

      typedef void (* Isr) (void);

      void attachInterrupt (Isr isr, Edge edge);

      void detachInterrupt();

      //------------------------------------------------------------------------
      //                          Propriétés
      //------------------------------------------------------------------------

      Type type() const;

      int logicalNumber () const;

      int mcuNumber () const;

      int systemNumber () const;

      int physicalNumber () const;

      int number (Numbering numbering) const;

      int row() const;

      int column() const;

      const std::string & name();

      bool useSysFs() const;

      bool forceUseSysFs (bool enable);

      Connector * connector() const;

      Gpio * gpio() const;

      AccessLayer accessLayer() const;

      bool isOpen() const;

      bool isDebug() const;

      void setDebug (bool enable);

      const std::string & name (Mode mode) const;

      const std::string & modeName();

      const std::string & modeName (Mode mode) const;

      const std::string & pullName ();

      static const std::string & pullName (Pull n);

      const std::string & typeName() const;

      static const std::string & typeName (Type t);

      static const std::string & numberingName (Numbering n);

      static const std::string & edgeName (Edge e);

      const std::map<Mode, std::string> & modes () const;

      static const std::map<Pull, std::string> & pulls ();

      static const std::map<Type, std::string> & types ();

      static const std::map<Numbering, std::string> & numberings ();

      static const std::map<Edge, std::string> & edges ();

      Pin (Connector * parent, const Descriptor * desc);

      virtual ~Pin();

    protected:
      Device * device() const;

      bool open();

      void close();

    private:
      bool _isopen;
      Connector * _parent;
      const Descriptor * _descriptor;
      Mode _holdMode;
      Pull _holdPull;
      bool _holdState;
      bool _useSysFs;
      int _valueFd;
      bool _firstPolling;

      Edge _edge;
      Mode _mode;
      Pull _pull;

      std::atomic<int> _run;  // indique au thread de continuer
      std::thread _thread;

      static const std::map<Pull, std::string> _pulls;
      static const std::map<Type, std::string> _types;
      static const std::map<Numbering, std::string> _numberings;
      static const std::map<Mode, std::string> _sysfsmodes;
      static const std::map<Edge, std::string> _edges;
      static const std::map<std::string, Edge> _str2edge;
      static const std::map<std::string, Mode> _str2mode;
      static std::string _syspath;

      static bool directoryExist (const std::string & dname);
      static void * irqThread (std::atomic<int> & run, int fd, Isr isr);

      void holdMode();
      void holdPull();
      void readPull ();
      void writePull();
      void readMode();
      void writeMode ();
      void readEdge();
      void writeEdge ();

      bool sysFsEnable (bool enable);
      void sysFsExport (bool enable);
      bool sysFsIsExport () const;
      bool sysFsOpen();
      void sysFsClose();

      void sysFsGetEdge();
      void sysFsSetEdge ();
      void sysFsGetMode();
      void sysFsSetMode ();

      static int sysFsPoll (int fd, int timeout_ms = -1);
      static int sysFsRead (int fd);
      static int sysFsWrite (int fd, bool value);

      void sysFsWriteFile (const char * n, const std::string & v);
      std::string sysFsReadFile (const char * n) const;
      bool sysFsFileExist (const char * n) const;
  };
}
/* ========================================================================== */
#endif /*_SYSIO_GPIO_PIN_H_ defined */