i2c.h

Go to the documentation of this file.

#pragma once

#include <Wire.h>
#include "esphome/core/defines.h"
#include "esphome/core/component.h"
#include "esphome/core/helpers.h"

namespace esphome {
namespace i2c {

#define LOG_I2C_DEVICE(this) ESP_LOGCONFIG(TAG, "  Address: 0x%02X", this->address_);

class I2CComponent : public Component {
 public:
  I2CComponent();
  void set_sda_pin(uint8_t sda_pin) { sda_pin_ = sda_pin; }
  void set_scl_pin(uint8_t scl_pin) { scl_pin_ = scl_pin; }
  void set_frequency(uint32_t frequency) { frequency_ = frequency; }
  void set_scan(bool scan) { scan_ = scan; }

  bool read_bytes(uint8_t address, uint8_t a_register, uint8_t *data, uint8_t len, uint32_t conversion = 0);
  bool read_bytes_raw(uint8_t address, uint8_t *data, uint8_t len);

  bool read_bytes_16(uint8_t address, uint8_t a_register, uint16_t *data, uint8_t len, uint32_t conversion = 0);

  bool read_byte(uint8_t address, uint8_t a_register, uint8_t *data, uint32_t conversion = 0);

  bool read_byte_16(uint8_t address, uint8_t a_register, uint16_t *data, uint32_t conversion = 0);

  bool write_bytes(uint8_t address, uint8_t a_register, const uint8_t *data, uint8_t len);
  bool write_bytes_raw(uint8_t address, const uint8_t *data, uint8_t len);

  bool write_bytes_16(uint8_t address, uint8_t a_register, const uint16_t *data, uint8_t len);

  bool write_byte(uint8_t address, uint8_t a_register, uint8_t data);

  bool write_byte_16(uint8_t address, uint8_t a_register, uint16_t data);

  // ========== INTERNAL METHODS ==========
  // (In most use cases you won't need these)
  void raw_begin_transmission(uint8_t address);

  bool raw_end_transmission(uint8_t address, bool send_stop = true);

  bool raw_request_from(uint8_t address, uint8_t len);

  void raw_write(uint8_t address, const uint8_t *data, uint8_t len);

  void raw_write_16(uint8_t address, const uint16_t *data, uint8_t len);

  bool raw_receive(uint8_t address, uint8_t *data, uint8_t len);

  bool raw_receive_16(uint8_t address, uint16_t *data, uint8_t len);

  void setup() override;
  void dump_config() override;
  float get_setup_priority() const override;

 protected:
  TwoWire *wire_;
  uint8_t sda_pin_;
  uint8_t scl_pin_;
  uint32_t frequency_;
  bool scan_;
};

#ifdef ARDUINO_ARCH_ESP32
extern uint8_t next_i2c_bus_num_;
#endif

class I2CDevice;
class I2CMultiplexer;
class I2CRegister {
 public:
  I2CRegister(I2CDevice *parent, uint8_t a_register) : parent_(parent), register_(a_register) {}

  I2CRegister &operator=(uint8_t value);
  I2CRegister &operator=(const std::vector<uint8_t> &value);
  I2CRegister &operator&=(uint8_t value);
  I2CRegister &operator|=(uint8_t value);

  uint8_t get();

 protected:
  I2CDevice *parent_;
  uint8_t register_;
};

class I2CDevice {
 public:
  I2CDevice() = default;
  I2CDevice(I2CComponent *parent, uint8_t address) : address_(address), parent_(parent) {}

  void set_i2c_address(uint8_t address);
#ifdef USE_I2C_MULTIPLEXER
  void set_i2c_multiplexer(I2CMultiplexer *multiplexer, uint8_t channel);
#endif
  void set_i2c_parent(I2CComponent *parent);

  I2CRegister reg(uint8_t a_register) { return {this, a_register}; }

  void raw_begin_transmission();

  bool raw_end_transmission(bool send_stop = true);

  void raw_write(const uint8_t *data, uint8_t len);

  bool read_bytes(uint8_t a_register, uint8_t *data, uint8_t len, uint32_t conversion = 0);
  bool read_bytes_raw(uint8_t *data, uint8_t len);

  template<size_t N> optional<std::array<uint8_t, N>> read_bytes(uint8_t a_register) {
    std::array<uint8_t, N> res;
    if (!this->read_bytes(a_register, res.data(), N)) {
      return {};
    }
    return res;
  }
  template<size_t N> optional<std::array<uint8_t, N>> read_bytes_raw() {
    std::array<uint8_t, N> res;
    if (!this->read_bytes_raw(res.data(), N)) {
      return {};
    }
    return res;
  }

  bool read_bytes_16(uint8_t a_register, uint16_t *data, uint8_t len, uint32_t conversion = 0);

  bool read_byte(uint8_t a_register, uint8_t *data, uint32_t conversion = 0);

  optional<uint8_t> read_byte(uint8_t a_register) {
    uint8_t data;
    if (!this->read_byte(a_register, &data))
      return {};
    return data;
  }

  bool read_byte_16(uint8_t a_register, uint16_t *data, uint32_t conversion = 0);

  bool write_bytes(uint8_t a_register, const uint8_t *data, uint8_t len);
  bool write_bytes_raw(const uint8_t *data, uint8_t len);

  bool write_bytes(uint8_t a_register, const std::vector<uint8_t> &data) {
    return this->write_bytes(a_register, data.data(), data.size());
  }
  bool write_bytes_raw(const std::vector<uint8_t> &data) { return this->write_bytes_raw(data.data(), data.size()); }

  template<size_t N> bool write_bytes(uint8_t a_register, const std::array<uint8_t, N> &data) {
    return this->write_bytes(a_register, data.data(), data.size());
  }
  template<size_t N> bool write_bytes_raw(const std::array<uint8_t, N> &data) {
    return this->write_bytes_raw(data.data(), data.size());
  }

  bool write_bytes_16(uint8_t a_register, const uint16_t *data, uint8_t len);

  bool write_byte(uint8_t a_register, uint8_t data);

  bool write_byte_16(uint8_t a_register, uint16_t data);

 protected:
  // Checks for multiplexer set and set channel
  void check_multiplexer_();
  uint8_t address_{0x00};
  I2CComponent *parent_{nullptr};
#ifdef USE_I2C_MULTIPLEXER
  I2CMultiplexer *multiplexer_{nullptr};
  uint8_t channel_;
#endif
};
class I2CMultiplexer : public I2CDevice {
 public:
  I2CMultiplexer() = default;
  virtual void set_channel(uint8_t channelno);
};
}  // namespace i2c
}  // namespace esphome