gpiopin.h

/* Copyright © 2018-2025 Pascal JEAN, All rights reserved.
   This file is part of the Piduino Library.
 
   The Piduino Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.
 
   The Piduino Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public License
   along with the Piduino Library; if not, see <http://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include <string>
#include <map>
#include <piduino/converter.h>
#include <piduino/gpio2.h>
 
 
namespace Piduino {
 
  class Gpio;
  class GpioDevice;
  class Connector;
 
  enum AccessLayer {
    AccessLayerAuto  = 0,
    AccessLayerIoMap = 0x0001,
    AccessLayerSysFs = 0x0002,
    AccessLayerGpioDev = 0x0004,
    AccessLayerAll = AccessLayerIoMap + AccessLayerGpioDev,
    AccessLayerUnk = -1
  };
 
  class Pin {
    public:
      friend class Connector; 
 
      enum Mode {
        ModeInput,      
        ModeOutput,     
        ModeDisabled,   
        ModePwm,        
        ModeAlt0,       
        ModeAlt1,       
        ModeAlt2,       
        ModeAlt3,       
        ModeAlt4,       
        ModeAlt5,       
        ModeAlt6,       
        ModeAlt7,       
        ModeAlt8,       
        ModeAlt9,       
        ModeUnknown = -1
      };
 
      enum Pull {
        PullOff,        
        PullDown,       
        PullUp,         
        PullUnknown = -1
      };
 
      enum Edge {
        EdgeNone,       
        EdgeRising,     
        EdgeFalling,    
        EdgeBoth,       
        EdgeUnknown = -1
      };
 
      enum Numbering {
        NumberingLogical,   
        NumberingMcu,       
        NumberingSystem,    
        NumberingUnknown = -1
      };
 
      enum Type {
        TypeGpio,           
        TypePower,          
        TypeUsb,            
        TypeSound,          
        TypeVideo,          
        TypeNotConnected,   
        TypeNet,            
        TypeUnknown = -1    
      };
 
      class Number {
        public:
          int logical;    
          int mcu;        
          int system;     
          int row;        
          int column;     
          int chip;       
          int offset;     
          Number (int logical = -1, int mcu = -1, int system = -1,
                  int row = -1, int column = -1, int chip = -1, int offset = -1)
            : logical (logical), mcu (mcu), system (system), row (row),
              column (column), chip (chip), offset (offset) {}
 
      };
 
      class Descriptor {
        public:
          Type type;                          
          Number num;                         
          long long id;                       
          std::map<Mode, std::string> name;   
          Descriptor (long long pinId = -1, int pinRow = -1, int pinColumn = -1);
          bool insert();
          bool hasModeName (Mode m, long long nameId) const;
          long long findId() const;
          long long findName (const std::string &name) const;
        private:
          void insertModeName (Mode m, const std::string &n);
      };
 
      class SpiCs {
        public:
          long long pin;   
          int bus;         
          int cs;          
          Pin::Mode mode;  
      };
 
      using Event = Gpio2::LineEvent;
 
      AccessLayer accessLayer() const;
 
      bool isOpen() const;
 
      int number (Numbering numbering) const;
 
      static const std::map<Numbering, std::string> &numberings();
 
      static const std::string &numberingName (Numbering n);
 
      int logicalNumber() const;
 
      int mcuNumber() const;
 
      int systemNumber() const;
 
      int physicalNumber() const;
 
      int chipNumber() const;
 
      int chipOffset() const;
 
      int row() const;
 
      int column() const;
 
      Type type() const;
 
      unsigned int flags() const;
 
      const std::string &typeName() const;
 
      static const std::string &typeName (Type t);
 
      static const std::map<Type, std::string> &types();
 
      const std::string &name() const;
 
      const std::string &name (Mode mode) const;
 
      void setMode (Mode mode);
 
      Mode mode() const;
 
      const std::map<Mode, std::string> &modes() const;
 
      const std::string &modeName();
 
      const std::string &modeName (Mode mode) const;
 
      void setPull (Pull pull);
 
      Pull pull() const;
 
      static const std::map<Pull, std::string> &pulls();
 
      const std::string &pullName();
 
      static const std::string &pullName (Pull n);
 
      int drive();
 
      void setDrive (int drive);
 
      void write (bool value);
 
      bool read() const;
 
      void toggle();
 
      void release();
 
      void waitForInterrupt (Edge edge, int timeout_ms = -1);
 
      void waitForInterrupt (Edge edge, Event &event, int timeout_ms = -1);
 
      void waitForInterrupt (Edge edge, int debounce_ms, Event &event, int timeout_ms = -1);
 
      typedef void (*Isr) (Event event, void *userData);
 
      void attachInterrupt (Isr isr, Edge edge, void *userData = nullptr);
 
      void attachInterrupt (Isr isr, Edge edge, int debounce_ms, void *userData = nullptr);
 
      void detachInterrupt();
 
      bool isGpioDevEnabled() const;
 
      bool enableGpioDev (bool enable = true);
 
      void analogWrite (long value);
 
      Converter *dac();
 
      bool setDac (Converter *dac);
 
      void resetDac();
 
      long long id() const;
 
      Connector *connector() const;
 
      Gpio *gpio() const;
 
      bool isDebug() const;
 
      void setDebug (bool enable);
 
      friend std::ostream &operator<< (std::ostream &os, const Pin &p);
 
      Pin (Connector *parent, const Descriptor *desc);
 
      virtual ~Pin();
 
    protected:
      GpioDevice *device() const;
 
      bool open();
 
      void close();
 
    protected:
      class Private;
 
      Pin (Private &dd);
 
      std::unique_ptr<Private> d_ptr;
 
    private:
      PIMP_DECLARE_PRIVATE (Pin)
  };
}
 
/* ========================================================================== */