i2c.h

Go to the documentation of this file.

#pragma once

#include <Wire.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 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);

 void set_i2c_parent(I2CComponent *parent);

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

 void raw_begin_transmission() { this->parent_->raw_begin_transmission(this->address_); };

 bool raw_end_transmission(bool send_stop = true) {
 return this->parent_->raw_end_transmission(this->address_, send_stop);
 };

 void raw_write(const uint8_t *data, uint8_t len) { this->parent_->raw_write(this->address_, data, 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) { return this->parent_->read_bytes_raw(this->address_, data, 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) {
 return this->parent_->write_bytes_raw(this->address_, data, 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:
 uint8_t address_{0x00};
 I2CComponent *parent_{nullptr};
};

} // namespace i2c
} // namespace esphome