i2cdev.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 <deque>
#include <string>
#include <map>
#include <memory>
#include <piduino/system.h>
#include <piduino/iodevice.h>
 
namespace Piduino {
 
  class I2cDev : public IoDevice {
    public:
 
      class Info {
        public:
          static const int MaxBuses = 32;
 
          Info (int id = 0);
 
          inline int id() const;
 
          inline void setId (int id);
 
          inline const std::string &path() const;
 
          bool setPath (const std::string &path);
 
          inline bool exists() const;
 
          bool operator== (const Info &other);
 
          bool operator!= (const Info &other);
 
          static std::string busPath (int id);
 
          static Info defaultBus ();
 
          static std::deque<Info> availableBuses ();
 
        private:
          int _id;
          std::string _path;
      };
 
      I2cDev ();
 
      I2cDev (const Info &bus);
 
      explicit I2cDev (const char *path);
 
      explicit I2cDev (const std::string &path);
 
      explicit I2cDev (int idBus);
 
      virtual ~I2cDev();
 
      static std::shared_ptr<I2cDev> factory (int busId);
 
      virtual bool open (OpenMode mode = IoDevice::ReadWrite);
 
      virtual void close();
 
      void setBus (const Info &bus);
 
      void setBus (int idBus);
 
      const Info &bus() const;
 
      void setBusPath (const char *path);
 
      void setBusPath (const std::string &path);
 
      void beginTransmission (uint16_t slave);
 
      bool endTransmission (bool stop = true);
 
      virtual int write (uint8_t data);
 
      virtual int write (const uint8_t *buffer, uint16_t len);
 
      inline int write (std::string str);
 
      inline int write (const char *str);
 
      inline int write (int data);
 
      inline int write (unsigned int data);
 
      inline int write (long data);
 
      inline int write (unsigned long data);
 
      int requestFrom (uint16_t slave, uint16_t max, bool stop = true);
 
      inline int requestFrom (int slave, int max, int stop = 1);
 
      uint16_t available() const;
 
      virtual int read (uint8_t *buffer, uint16_t max);
 
      virtual int read();
 
      virtual int peek() const;
 
      virtual void flush ();
 
    protected:
      class Private;
 
      I2cDev (Private &dd);
 
    private:
      PIMP_DECLARE_PRIVATE (I2cDev)
  };
 
  // ---------------------------------------------------------------------------
  //
  //                      Piduino I2cDev Global Object
  //
  // ---------------------------------------------------------------------------
 
  extern I2cDev Wire;
 
  #ifndef DOXYGEN
  // ===========================================================================
  //
  //                          Inline Function Definitions
  //
  // ===========================================================================
 
  // ---------------------------------------------------------------------------
  //                             I2cDev::Info
  // ---------------------------------------------------------------------------
 
  inline I2cDev::Info::Info (int id) {
    setId (id);
  }
 
  inline int I2cDev::Info::id() const {
    return _id;
  }
 
  inline void I2cDev::Info::setId (int id) {
    _id = id;
    _path = busPath (id);
  }
 
  inline const std::string &I2cDev::Info::path() const {
    return _path;
  }
 
  inline bool I2cDev::Info::exists() const {
    return System::charFileExists (_path);
  }
 
  inline bool I2cDev::Info::operator== (const Info &other) {
    return (_path == other._path) ;
  }
 
  inline bool I2cDev::Info::operator!= (const Info &other) {
    return (_path != other._path) ;
  }
 
  // ---------------------------------------------------------------------------
  //                               I2cDev
  // ---------------------------------------------------------------------------
 
  inline int I2cDev::write (std::string str) {
    return write (reinterpret_cast<const uint8_t *> (str.c_str()), str.length());
  }
 
  inline int I2cDev::write (const char *str) {
    return write (std::string (str));
  }
 
  inline int I2cDev::write (int data) {
    return write (static_cast<uint8_t> (data));
  }
 
  inline int I2cDev::write (unsigned int data) {
    return write (static_cast<uint8_t> (data));
  }
 
  inline int I2cDev::write (long data) {
    return write (static_cast<uint8_t> (data));
  }
 
  inline int I2cDev::write (unsigned long data) {
    return write (static_cast<uint8_t> (data));
  }
 
  inline int I2cDev::requestFrom (int slave, int max, int stop) {
    return requestFrom (static_cast<uint16_t> (slave), static_cast<uint16_t> (max), stop != 0);
  }
 
  #endif // DOXYGEN
 
}
 
/* ========================================================================== */