LibXR::ESP32I2C Class Reference

Inheritance diagram for LibXR::ESP32I2C:

Collaboration diagram for LibXR::ESP32I2C:

Public Member Functions
	ESP32I2C (i2c_port_t port_num, int scl_pin, int sda_pin, uint32_t clock_speed=400000U, bool enable_internal_pullup=true, uint32_t timeout_ms=100U, uint32_t isr_enable_min_size=32U)
ErrorCode	Read (uint16_t slave_addr, RawData read_data, ReadOperation &op, bool in_isr=false) override
	读取 I2C 设备的数据。 Reads data from an I2C device.
ErrorCode	Write (uint16_t slave_addr, ConstRawData write_data, WriteOperation &op, bool in_isr=false) override
	向 I2C 设备写入数据。 Writes data to an I2C device.
ErrorCode	SetConfig (Configuration config) override
	配置 I2C 设备参数。 Configures the I2C device settings.
ErrorCode	MemRead (uint16_t slave_addr, uint16_t mem_addr, RawData read_data, ReadOperation &op, MemAddrLength mem_addr_size=MemAddrLength::BYTE_8, bool in_isr=false) override
	从 I2C 设备指定寄存器读取数据。 Reads data from a specific register of an I2C device.
ErrorCode	MemWrite (uint16_t slave_addr, uint16_t mem_addr, ConstRawData write_data, WriteOperation &op, MemAddrLength mem_addr_size=MemAddrLength::BYTE_8, bool in_isr=false) override
	向 I2C 设备指定寄存器写入数据。 Writes data to a specific register of an I2C device.
i2c_port_t	Port () const
Public Member Functions inherited from LibXR::I2C
	I2C ()
	默认构造函数。 Default constructor.

Static Public Attributes
static constexpr int	PIN_NO_CHANGE = -1

Private Member Functions
bool	Acquire ()
void	Release ()
ErrorCode	InitHardware ()
ErrorCode	ConfigurePins ()
ErrorCode	ApplyConfig ()
ErrorCode	ResolveClockSource (uint32_t &source_hz)
ErrorCode	RecoverController ()
ErrorCode	EnsureInitialized (bool in_isr)
bool	ShouldUseInterruptAsync (size_t total_size) const
ErrorCode	ExecuteTransaction (uint16_t slave_addr, const uint8_t *write_payload, size_t write_size, uint8_t *read_payload, size_t read_size)
ErrorCode	StartAsyncTransaction (uint16_t slave_addr, const uint8_t *write_prefix_payload, size_t write_prefix_size, const uint8_t *write_payload, size_t write_size, uint8_t *read_payload, size_t read_size, ReadOperation &op)
ErrorCode	KickAsyncTransaction ()
void	FinishAsync (bool in_isr, ErrorCode ec)
ErrorCode	InstallInterrupt ()
void	HandleInterrupt ()

Static Private Member Functions
static size_t	MemAddrBytes (MemAddrLength mem_addr_size)
static void	EncodeMemAddr (uint16_t mem_addr, size_t mem_len, uint8_t *out)
static bool	IsValid7BitAddr (uint16_t addr)
static void	I2cIsrEntry (void *arg)

Private Attributes
i2c_port_t	port_num_
int	scl_pin_
int	sda_pin_
bool	enable_internal_pullup_
uint32_t	timeout_ms_
uint32_t	isr_enable_min_size_
bool	initialized_ = false
Configuration	config_ {}
i2c_hal_context_t	hal_ = {}
uint32_t	source_clock_hz_ = 0U
Flag::Plain	busy_
intr_handle_t	intr_handle_ = nullptr
bool	intr_installed_ = false
bool	async_running_ = false
ReadOperation	async_op_ {}
uint16_t	async_slave_addr_ = 0U
std::array< uint8_t, 2 >	async_write_prefix_ = {}
size_t	async_write_prefix_size_ = 0U
size_t	async_write_prefix_offset_ = 0U
const uint8_t *	async_write_payload_ = nullptr
size_t	async_write_size_ = 0U
size_t	async_write_offset_ = 0U
uint8_t *	async_read_payload_ = nullptr
size_t	async_read_size_ = 0U
size_t	async_read_offset_ = 0U
size_t	async_pending_read_chunk_ = 0U
bool	async_write_phase_done_ = true
bool	async_write_addr_sent_ = false
bool	async_write_stop_sent_ = false
bool	async_read_addr_sent_ = false
AsyncBlockWait	block_wait_ {}

Static Private Attributes
static constexpr size_t	kFifoLen = SOC_I2C_FIFO_LEN
static constexpr size_t	kMaxWritePayload = (kFifoLen > 4U) ? (kFifoLen - 4U) : 0U
static constexpr size_t	kMaxWriteReadPrefix
static constexpr size_t	kMaxReadPayload = (kFifoLen > 4U) ? (kFifoLen - 4U) : kFifoLen

Additional Inherited Members
Public Types inherited from LibXR::I2C
enum class	MemAddrLength : uint8_t { BYTE_8 , BYTE_16 }

Detailed Description

Definition at line 20 of file esp_i2c.hpp.

Constructor & Destructor Documentation

ESP32I2C()

LibXR::ESP32I2C::ESP32I2C	(	i2c_port_t	port_num,
		int	scl_pin,
		int	sda_pin,
		uint32_t	clock_speed = 400000U,
		bool	enable_internal_pullup = true,
		uint32_t	timeout_ms = 100U,
		uint32_t	isr_enable_min_size = 32U )

Definition at line 140 of file esp_i2c.cpp.

    : port_num_(port_num),
      scl_pin_(scl_pin),
      sda_pin_(sda_pin),
      enable_internal_pullup_(enable_internal_pullup),
      timeout_ms_(timeout_ms),
      isr_enable_min_size_(isr_enable_min_size),
      config_{clock_speed}
{
  ASSERT(port_num_ >= 0);
  ASSERT(port_num_ < SOC_I2C_NUM);
  ASSERT(GPIO_IS_VALID_OUTPUT_GPIO(static_cast<gpio_num_t>(scl_pin_)));
  ASSERT(GPIO_IS_VALID_OUTPUT_GPIO(static_cast<gpio_num_t>(sda_pin_)));
  ASSERT(config_.clock_speed > 0U);
  ASSERT(kFifoLen > 2U);
 
  if (InitHardware() != ErrorCode::OK)
  {
    ASSERT(false);
    return;
  }
}

Member Function Documentation

Acquire()

bool LibXR::ESP32I2C::Acquire ( )

private

Definition at line 165 of file esp_i2c.cpp.

{ return !busy_.TestAndSet(); }

ApplyConfig()

ErrorCode LibXR::ESP32I2C::ApplyConfig ( )

private

Definition at line 215 of file esp_i2c.cpp.

{
  if ((hal_.dev == nullptr) || (config_.clock_speed == 0U))
  {
    return ErrorCode::ARG_ERR;
  }
 
  i2c_ll_set_source_clk(hal_.dev, I2C_CLK_SRC_DEFAULT);
  if (ResolveClockSource(source_clock_hz_) != ErrorCode::OK)
  {
    return ErrorCode::INIT_ERR;
  }
 
  if (config_.clock_speed > (source_clock_hz_ / 20U))
  {
    return ErrorCode::ARG_ERR;
  }
 
  _i2c_hal_set_bus_timing(&hal_, static_cast<int>(config_.clock_speed),
                          I2C_CLK_SRC_DEFAULT, static_cast<int>(source_clock_hz_));
  i2c_ll_master_set_filter(hal_.dev, 7U);
  i2c_ll_update(hal_.dev);
 
  return ErrorCode::OK;
}

ConfigurePins()

ErrorCode LibXR::ESP32I2C::ConfigurePins ( )

private

Definition at line 299 of file esp_i2c.cpp.

{
  if (hal_.dev == nullptr)
  {
    return ErrorCode::STATE_ERR;
  }
 
  const auto& sig = i2c_periph_signal[port_num_];
  const gpio_num_t sda_gpio = static_cast<gpio_num_t>(sda_pin_);
  const gpio_num_t scl_gpio = static_cast<gpio_num_t>(scl_pin_);
 
  gpio_set_level(sda_gpio, 1);
  esp_rom_gpio_pad_select_gpio(static_cast<uint32_t>(sda_pin_));
  gpio_set_direction(sda_gpio, GPIO_MODE_INPUT_OUTPUT_OD);
  gpio_set_pull_mode(sda_gpio,
                     enable_internal_pullup_ ? GPIO_PULLUP_ONLY : GPIO_FLOATING);
  esp_rom_gpio_connect_out_signal(sda_pin_, sig.sda_out_sig, false, false);
  esp_rom_gpio_connect_in_signal(sda_pin_, sig.sda_in_sig, false);
 
  gpio_set_level(scl_gpio, 1);
  esp_rom_gpio_pad_select_gpio(static_cast<uint32_t>(scl_pin_));
  gpio_set_direction(scl_gpio, GPIO_MODE_INPUT_OUTPUT_OD);
  gpio_set_pull_mode(scl_gpio,
                     enable_internal_pullup_ ? GPIO_PULLUP_ONLY : GPIO_FLOATING);
  esp_rom_gpio_connect_out_signal(scl_pin_, sig.scl_out_sig, false, false);
  esp_rom_gpio_connect_in_signal(scl_pin_, sig.scl_in_sig, false);
 
  return ErrorCode::OK;
}

EncodeMemAddr()

void LibXR::ESP32I2C::EncodeMemAddr ( uint16_t mem_addr, size_t mem_len, uint8_t * out )

staticprivate

Definition at line 189 of file esp_i2c.cpp.

{
  ASSERT(out != nullptr);
  if (mem_len == 2U)
  {
    out[0] = static_cast<uint8_t>((mem_addr >> 8) & 0xFFU);
    out[1] = static_cast<uint8_t>(mem_addr & 0xFFU);
    return;
  }
 
  out[0] = static_cast<uint8_t>(mem_addr & 0xFFU);
}

EnsureInitialized()

ErrorCode LibXR::ESP32I2C::EnsureInitialized ( bool in_isr )

private

Definition at line 171 of file esp_i2c.cpp.

{
  if (initialized_)
  {
    return ErrorCode::OK;
  }
  if (in_isr)
  {
    return ErrorCode::INIT_ERR;
  }
  return InitHardware();
}

ExecuteTransaction()

ErrorCode LibXR::ESP32I2C::ExecuteTransaction ( uint16_t slave_addr, const uint8_t * write_payload, size_t write_size, uint8_t * read_payload, size_t read_size )

private

Definition at line 757 of file esp_i2c.cpp.

{
  if (!initialized_ || (hal_.dev == nullptr))
  {
    return ErrorCode::INIT_ERR;
  }
  if (!IsValid7BitAddr(slave_addr))
  {
    return ErrorCode::ARG_ERR;
  }
  if ((write_size > 0U) && (write_payload == nullptr))
  {
    return ErrorCode::PTR_NULL;
  }
  if ((read_size > 0U) && (read_payload == nullptr))
  {
    return ErrorCode::PTR_NULL;
  }
 
  if (i2c_ll_is_bus_busy(hal_.dev))
  {
    const ErrorCode ec = RecoverController();
    if (ec != ErrorCode::OK)
    {
      return ec;
    }
  }
 
  i2c_ll_txfifo_rst(hal_.dev);
  i2c_ll_rxfifo_rst(hal_.dev);
  i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_INTR_MASK);
 
  const uint64_t timeout_us = ToTimeoutUs(timeout_ms_);
  const uint8_t write_addr = static_cast<uint8_t>((slave_addr << 1U) | I2C_MASTER_WRITE);
  const uint8_t read_addr = static_cast<uint8_t>((slave_addr << 1U) | I2C_MASTER_READ);
  const size_t fifo_len = kFifoLen;
  const size_t write_chunk_cap = (fifo_len > 1U) ? (fifo_len - 1U) : 0U;
  ASSERT(write_chunk_cap > 0U);
 
  int cmd_idx = 0;
 
  auto start_and_wait = [&](int done_cmd) -> ErrorCode
  { return StartAndWaitSegment(hal_, done_cmd, timeout_us); };
 
  if ((write_size > 0U) || (read_size == 0U))
  {
    WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_RESTART, kAckValue, kAckValue,
                 kNoCheckAck, 0U);
 
    i2c_ll_write_txfifo(hal_.dev, &write_addr, 1U);
    WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_WRITE, kAckValue, kAckValue, kCheckAck,
                 1U);
 
    size_t write_offset = 0U;
    while (write_offset < write_size)
    {
      const size_t chunk = std::min(write_size - write_offset, write_chunk_cap);
      i2c_ll_write_txfifo(hal_.dev,
                          static_cast<const uint8_t*>(write_payload) + write_offset,
                          static_cast<uint8_t>(chunk));
      write_offset += chunk;
 
      WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_WRITE, kAckValue, kAckValue, kCheckAck,
                   static_cast<uint8_t>(chunk));
      WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue, kNoCheckAck,
                   0U);
 
      const ErrorCode ec = start_and_wait(cmd_idx - 1);
      if (ec != ErrorCode::OK)
      {
        (void)RecoverController();
        return ec;
      }
      cmd_idx = 0;
    }
 
    if (write_size == 0U)
    {
      if (read_size == 0U)
      {
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_STOP, kAckValue, kAckValue,
                     kNoCheckAck, 0U);
#if SOC_I2C_STOP_INDEPENDENT
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue,
                     kNoCheckAck, 0U);
#endif
      }
      const ErrorCode ec = start_and_wait(cmd_idx - 1);
      if (ec != ErrorCode::OK)
      {
        (void)RecoverController();
        return ec;
      }
      cmd_idx = 0;
    }
    else if (read_size == 0U)
    {
      WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_STOP, kAckValue, kAckValue,
                   kNoCheckAck, 0U);
#if SOC_I2C_STOP_INDEPENDENT
      WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue, kNoCheckAck,
                   0U);
#endif
      const ErrorCode ec = start_and_wait(cmd_idx - 1);
      if (ec != ErrorCode::OK)
      {
        (void)RecoverController();
        return ec;
      }
      cmd_idx = 0;
    }
  }
 
  if (read_size > 0U)
  {
    WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_RESTART, kAckValue, kAckValue,
                 kNoCheckAck, 0U);
    i2c_ll_write_txfifo(hal_.dev, &read_addr, 1U);
    WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_WRITE, kAckValue, kAckValue, kCheckAck,
                 1U);
 
    size_t read_offset = 0U;
    while (read_offset < read_size)
    {
      const size_t chunk = std::min(read_size - read_offset, fifo_len);
      const bool is_last = (read_offset + chunk) >= read_size;
 
      if (!is_last)
      {
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_READ, kAckValue, kAckValue,
                     kNoCheckAck, static_cast<uint8_t>(chunk));
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue,
                     kNoCheckAck, 0U);
      }
      else if (chunk == 1U)
      {
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_READ, kNackValue, kAckValue,
                     kNoCheckAck, 1U);
      }
      else
      {
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_READ, kAckValue, kAckValue,
                     kNoCheckAck, static_cast<uint8_t>(chunk - 1U));
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_READ, kNackValue, kAckValue,
                     kNoCheckAck, 1U);
      }
 
      if (is_last)
      {
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_STOP, kAckValue, kAckValue,
                     kNoCheckAck, 0U);
#if SOC_I2C_STOP_INDEPENDENT
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue,
                     kNoCheckAck, 0U);
#endif
      }
 
      const ErrorCode ec = start_and_wait(cmd_idx - 1);
      if (ec != ErrorCode::OK)
      {
        (void)RecoverController();
        return ec;
      }
 
      i2c_ll_read_rxfifo(hal_.dev, read_payload + read_offset,
                         static_cast<uint8_t>(chunk));
      read_offset += chunk;
      cmd_idx = 0;
    }
  }
 
  i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_INTR_MASK);
  return ErrorCode::OK;
}

FinishAsync()

void LibXR::ESP32I2C::FinishAsync ( bool in_isr, ErrorCode ec )

private

Definition at line 625 of file esp_i2c.cpp.

{
  if (!async_running_)
  {
    return;
  }
 
  if (hal_.dev != nullptr)
  {
    i2c_ll_disable_intr_mask(hal_.dev, I2C_LL_MASTER_EVENT_INTR);
    i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_INTR_MASK);
  }
 
  ReadOperation op = async_op_;
  async_op_ = {};
  async_running_ = false;
  async_write_prefix_size_ = 0U;
  async_write_prefix_offset_ = 0U;
  async_write_payload_ = nullptr;
  async_write_size_ = 0U;
  async_write_offset_ = 0U;
  async_read_payload_ = nullptr;
  async_read_size_ = 0U;
  async_read_offset_ = 0U;
  async_pending_read_chunk_ = 0U;
  async_write_phase_done_ = true;
  async_write_addr_sent_ = false;
  async_write_stop_sent_ = false;
  async_read_addr_sent_ = false;
 
  Release();
  if (op.type == ReadOperation::OperationType::BLOCK)
  {
    (void)block_wait_.TryPost(in_isr, ec);
  }
  else
  {
    op.UpdateStatus(in_isr, ec);
  }
}

HandleInterrupt()

void LibXR::ESP32I2C::HandleInterrupt ( )

private

Definition at line 698 of file esp_i2c.cpp.

{
  if (hal_.dev == nullptr)
  {
    return;
  }
 
  const uint32_t intr = hal_.dev->int_raw.val;
  if ((intr & I2C_LL_MASTER_EVENT_INTR) == 0U)
  {
    return;
  }
 
  if (!async_running_)
  {
    i2c_ll_disable_intr_mask(hal_.dev, I2C_LL_MASTER_EVENT_INTR);
    i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_INTR_MASK);
    return;
  }
 
  i2c_ll_disable_intr_mask(hal_.dev, I2C_LL_MASTER_EVENT_INTR);
  i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_INTR_MASK);
 
  if ((intr & I2C_LL_INTR_NACK) != 0U)
  {
    i2c_hal_master_fsm_rst(&hal_);
    i2c_ll_update(hal_.dev);
    FinishAsync(true, ErrorCode::NO_RESPONSE);
    return;
  }
  if ((intr & I2C_LL_INTR_TIMEOUT) != 0U)
  {
    i2c_hal_master_fsm_rst(&hal_);
    i2c_ll_update(hal_.dev);
    FinishAsync(true, ErrorCode::TIMEOUT);
    return;
  }
  if ((intr & I2C_LL_INTR_ARBITRATION) != 0U)
  {
    i2c_hal_master_fsm_rst(&hal_);
    i2c_ll_update(hal_.dev);
    FinishAsync(true, ErrorCode::FAILED);
    return;
  }
 
  if ((intr & (I2C_LL_INTR_MST_COMPLETE | I2C_LL_INTR_END_DETECT)) == 0U)
  {
    return;
  }
 
  const ErrorCode kick = KickAsyncTransaction();
  if (kick == ErrorCode::PENDING)
  {
    return;
  }
 
  FinishAsync(true, kick);
}

I2cIsrEntry()

void LibXR::ESP32I2C::I2cIsrEntry ( void * arg )

staticprivate

Definition at line 689 of file esp_i2c.cpp.

{
  auto* self = static_cast<ESP32I2C*>(arg);
  if (self != nullptr)
  {
    self->HandleInterrupt();
  }
}

InitHardware()

ErrorCode LibXR::ESP32I2C::InitHardware ( )

private

Definition at line 241 of file esp_i2c.cpp.

{
  if (initialized_)
  {
    return ErrorCode::OK;
  }
 
  if ((port_num_ < 0) || (port_num_ >= SOC_I2C_NUM) ||
      (static_cast<size_t>(port_num_) >= SOC_I2C_NUM))
  {
    return ErrorCode::OUT_OF_RANGE;
  }
 
  if (!GPIO_IS_VALID_OUTPUT_GPIO(static_cast<gpio_num_t>(scl_pin_)) ||
      !GPIO_IS_VALID_OUTPUT_GPIO(static_cast<gpio_num_t>(sda_pin_)))
  {
    return ErrorCode::ARG_ERR;
  }
 
  SetBusClockAtomic(port_num_, true);
  ResetBusRegisterAtomic(port_num_);
 
  _i2c_hal_init(&hal_, static_cast<int>(port_num_));
  if (hal_.dev == nullptr)
  {
    ASSERT(false);
    return ErrorCode::INIT_ERR;
  }
 
  i2c_hal_master_init(&hal_);
  i2c_ll_disable_intr_mask(hal_.dev, I2C_LL_MASTER_EVENT_INTR);
  i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_MASTER_EVENT_INTR);
 
  ErrorCode err = ConfigurePins();
  if (err != ErrorCode::OK)
  {
    ASSERT(false);
    return err;
  }
 
  err = InstallInterrupt();
  if (err != ErrorCode::OK)
  {
    ASSERT(false);
    return err;
  }
 
  err = ApplyConfig();
  if (err != ErrorCode::OK)
  {
    ASSERT(false);
    return err;
  }
 
  initialized_ = true;
  return ErrorCode::OK;
}

InstallInterrupt()

ErrorCode LibXR::ESP32I2C::InstallInterrupt ( )

private

Definition at line 666 of file esp_i2c.cpp.

{
  if (intr_installed_)
  {
    return ErrorCode::OK;
  }
 
  const int irq = i2c_periph_signal[port_num_].irq;
  if (irq <= 0)
  {
    return ErrorCode::NOT_SUPPORT;
  }
 
  if (esp_intr_alloc(irq, 0, I2cIsrEntry, this, &intr_handle_) != ESP_OK)
  {
    intr_handle_ = nullptr;
    return ErrorCode::INIT_ERR;
  }
 
  intr_installed_ = true;
  return ErrorCode::OK;
}

IsValid7BitAddr()

bool LibXR::ESP32I2C::IsValid7BitAddr ( uint16_t addr )

staticprivate

Definition at line 169 of file esp_i2c.cpp.

{ return addr <= 0x7FU; }

KickAsyncTransaction()

ErrorCode LibXR::ESP32I2C::KickAsyncTransaction ( )

private

Definition at line 466 of file esp_i2c.cpp.

{
  if (!async_running_ || (hal_.dev == nullptr))
  {
    return ErrorCode::STATE_ERR;
  }
 
  const uint8_t write_addr =
      static_cast<uint8_t>((async_slave_addr_ << 1U) | I2C_MASTER_WRITE);
  const uint8_t read_addr =
      static_cast<uint8_t>((async_slave_addr_ << 1U) | I2C_MASTER_READ);
  const size_t fifo_len = kFifoLen;
  const size_t write_chunk_cap = (fifo_len > 1U) ? (fifo_len - 1U) : 0U;
  ASSERT(write_chunk_cap > 0U);
 
  while (true)
  {
    if (async_pending_read_chunk_ > 0U)
    {
      i2c_ll_read_rxfifo(hal_.dev, async_read_payload_ + async_read_offset_,
                         static_cast<uint8_t>(async_pending_read_chunk_));
      async_read_offset_ += async_pending_read_chunk_;
      async_pending_read_chunk_ = 0U;
    }
 
    int cmd_idx = 0;
 
    if (!async_write_phase_done_)
    {
      if (!async_write_addr_sent_)
      {
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_RESTART, kAckValue, kAckValue,
                     kNoCheckAck, 0U);
        i2c_ll_write_txfifo(hal_.dev, &write_addr, 1U);
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_WRITE, kAckValue, kAckValue,
                     kCheckAck, 1U);
        async_write_addr_sent_ = true;
      }
 
      if (async_write_prefix_offset_ < async_write_prefix_size_)
      {
        const size_t chunk = std::min(
            async_write_prefix_size_ - async_write_prefix_offset_, write_chunk_cap);
        i2c_ll_write_txfifo(hal_.dev,
                            async_write_prefix_.data() + async_write_prefix_offset_,
                            static_cast<uint8_t>(chunk));
        async_write_prefix_offset_ += chunk;
 
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_WRITE, kAckValue, kAckValue,
                     kCheckAck, static_cast<uint8_t>(chunk));
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue,
                     kNoCheckAck, 0U);
      }
      else if (async_write_offset_ < async_write_size_)
      {
        const size_t chunk =
            std::min(async_write_size_ - async_write_offset_, write_chunk_cap);
        i2c_ll_write_txfifo(hal_.dev, async_write_payload_ + async_write_offset_,
                            static_cast<uint8_t>(chunk));
        async_write_offset_ += chunk;
 
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_WRITE, kAckValue, kAckValue,
                     kCheckAck, static_cast<uint8_t>(chunk));
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue,
                     kNoCheckAck, 0U);
      }
      else if (async_read_size_ == 0U)
      {
        if (!async_write_stop_sent_)
        {
          WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_STOP, kAckValue, kAckValue,
                       kNoCheckAck, 0U);
#if SOC_I2C_STOP_INDEPENDENT
          WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue,
                       kNoCheckAck, 0U);
#endif
          async_write_stop_sent_ = true;
        }
        async_write_phase_done_ = async_write_stop_sent_;
      }
      else
      {
        async_write_phase_done_ = true;
      }
 
      if (cmd_idx > 0)
      {
        i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_INTR_MASK);
        i2c_ll_enable_intr_mask(hal_.dev, I2C_LL_MASTER_EVENT_INTR);
        i2c_hal_master_trans_start(&hal_);
        return ErrorCode::PENDING;
      }
 
      continue;
    }
 
    if (async_read_size_ > 0U)
    {
      if (!async_read_addr_sent_)
      {
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_RESTART, kAckValue, kAckValue,
                     kNoCheckAck, 0U);
        i2c_ll_write_txfifo(hal_.dev, &read_addr, 1U);
        WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_WRITE, kAckValue, kAckValue,
                     kCheckAck, 1U);
        async_read_addr_sent_ = true;
      }
 
      if (async_read_offset_ < async_read_size_)
      {
        const size_t chunk = std::min(async_read_size_ - async_read_offset_, fifo_len);
        const bool is_last = (async_read_offset_ + chunk) >= async_read_size_;
 
        if (!is_last)
        {
          WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_READ, kAckValue, kAckValue,
                       kNoCheckAck, static_cast<uint8_t>(chunk));
          WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue,
                       kNoCheckAck, 0U);
        }
        else if (chunk == 1U)
        {
          WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_READ, kNackValue, kAckValue,
                       kNoCheckAck, 1U);
        }
        else
        {
          WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_READ, kAckValue, kAckValue,
                       kNoCheckAck, static_cast<uint8_t>(chunk - 1U));
          WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_READ, kNackValue, kAckValue,
                       kNoCheckAck, 1U);
        }
 
        if (is_last)
        {
          WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_STOP, kAckValue, kAckValue,
                       kNoCheckAck, 0U);
#if SOC_I2C_STOP_INDEPENDENT
          WriteCommand(hal_.dev, cmd_idx++, I2C_LL_CMD_END, kAckValue, kAckValue,
                       kNoCheckAck, 0U);
#endif
        }
 
        async_pending_read_chunk_ = chunk;
      }
 
      if (cmd_idx > 0)
      {
        i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_INTR_MASK);
        i2c_ll_enable_intr_mask(hal_.dev, I2C_LL_MASTER_EVENT_INTR);
        i2c_hal_master_trans_start(&hal_);
        return ErrorCode::PENDING;
      }
    }
 
    return ErrorCode::OK;
  }
}

MemAddrBytes()

size_t LibXR::ESP32I2C::MemAddrBytes ( MemAddrLength mem_addr_size )

staticprivate

Definition at line 184 of file esp_i2c.cpp.

{
  return (mem_addr_size == MemAddrLength::BYTE_16) ? 2U : 1U;
}

MemRead()

ErrorCode LibXR::ESP32I2C::MemRead ( uint16_t slave_addr, uint16_t mem_addr, RawData read_data, ReadOperation & op, MemAddrLength mem_addr_size = MemAddrLength::BYTE_8, bool in_isr = false )

overridevirtual

从 I2C 设备指定寄存器读取数据。 Reads data from a specific register of an I2C device.

该函数从指定 I2C 从设备的寄存器地址读取数据，并存储到 read_data 中。 This function reads data from the specified register of the I2C slave and stores it in read_data.

Parameters

slave_addr	目标 I2C 从设备地址，不带 R/W 位。 Target I2C slave address, no R/W bit included.
mem_addr	寄存器地址（通常为 8 位或 16 位）。 Register address (typically 8-bit or 16-bit).
read_data	用于存储读取数据的 RawData 对象。 RawData object to store read data.
op	异步或同步的读取操作对象。 Read operation object (sync or async).
mem_addr_size	寄存器地址长度。 Size of register address in bytes.
in_isr	是否在中断中进行操作。Whether the operation is performed in an ISR.

Returns

返回 ErrorCode，表示是否读取成功。 Returns ErrorCode indicating success or failure.

Implements LibXR::I2C.

Definition at line 1169 of file esp_i2c.cpp.

{
  const ErrorCode init_ec = EnsureInitialized(in_isr);
  if (init_ec != ErrorCode::OK)
  {
    return Complete(op, in_isr, init_ec);
  }
 
  if (!IsValid7BitAddr(slave_addr))
  {
    return Complete(op, in_isr, ErrorCode::ARG_ERR);
  }
 
  if ((read_data.size_ > 0U) && (read_data.addr_ == nullptr))
  {
    return Complete(op, in_isr, ErrorCode::PTR_NULL);
  }
 
  const size_t mem_len = MemAddrBytes(mem_addr_size);
  if (mem_len > kMaxWriteReadPrefix)
  {
    return Complete(op, in_isr, ErrorCode::SIZE_ERR);
  }
 
  if (!Acquire())
  {
    return Complete(op, in_isr, ErrorCode::BUSY);
  }
 
  std::array<uint8_t, 2> mem_raw = {};
  EncodeMemAddr(mem_addr, mem_len, mem_raw.data());
 
  auto* dst = static_cast<uint8_t*>(read_data.addr_);
  const size_t total_size = mem_len + read_data.size_;
  if ((read_data.size_ > 0U) && ShouldUseInterruptAsync(total_size))
  {
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
    const ErrorCode ans = StartAsyncTransaction(slave_addr, mem_raw.data(), mem_len,
                                                nullptr, 0U, dst, read_data.size_, op);
    if (ans != ErrorCode::OK)
    {
      if (op.type == ReadOperation::OperationType::BLOCK)
      {
        block_wait_.Cancel();
      }
      Release();
      return Complete(op, in_isr, ans);
    }
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      ASSERT(!in_isr);
      return block_wait_.Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
 
  size_t offset = 0U;
  ErrorCode ans = ErrorCode::OK;
 
  while (offset < read_data.size_)
  {
    const size_t chunk = std::min(read_data.size_ - offset, kMaxReadPayload);
    const uint16_t cur_mem = static_cast<uint16_t>(mem_addr + offset);
    EncodeMemAddr(cur_mem, mem_len, mem_raw.data());
 
    ans = ExecuteTransaction(slave_addr, mem_raw.data(), mem_len, dst + offset, chunk);
    if (ans != ErrorCode::OK)
    {
      break;
    }
    offset += chunk;
  }
 
  Release();
  return Complete(op, in_isr, ans);
}

MemWrite()

ErrorCode LibXR::ESP32I2C::MemWrite ( uint16_t slave_addr, uint16_t mem_addr, ConstRawData write_data, WriteOperation & op, MemAddrLength mem_addr_size = MemAddrLength::BYTE_8, bool in_isr = false )

overridevirtual

向 I2C 设备指定寄存器写入数据。 Writes data to a specific register of an I2C device.

该函数将 write_data 写入指定 I2C 从设备的寄存器地址。 This function writes write_data to the specified register of the I2C slave.

Parameters

slave_addr	目标 I2C 从设备地址，不带 R/W 位。 Target I2C slave address, no R/W bit included.
mem_addr	寄存器地址（通常为 8 位或 16 位）。 Register address (typically 8-bit or 16-bit).
write_data	要写入的数据，ConstRawData 类型。 Data to be written, of type ConstRawData.
op	异步或同步的写入操作对象。 Write operation object (sync or async).
mem_addr_size	寄存器地址长度。 Size of register address in bytes.
in_isr	是否在中断中进行操作。Whether the operation is performed in an ISR.

Returns

返回 ErrorCode，表示是否写入成功。 Returns ErrorCode indicating success or failure.

Implements LibXR::I2C.

Definition at line 1076 of file esp_i2c.cpp.

{
  const ErrorCode init_ec = EnsureInitialized(in_isr);
  if (init_ec != ErrorCode::OK)
  {
    return Complete(op, in_isr, init_ec);
  }
 
  if (!IsValid7BitAddr(slave_addr))
  {
    return Complete(op, in_isr, ErrorCode::ARG_ERR);
  }
 
  if ((write_data.size_ > 0U) && (write_data.addr_ == nullptr))
  {
    return Complete(op, in_isr, ErrorCode::PTR_NULL);
  }
 
  const size_t mem_len = MemAddrBytes(mem_addr_size);
  if (mem_len > kMaxWritePayload)
  {
    return Complete(op, in_isr, ErrorCode::SIZE_ERR);
  }
 
  if (!Acquire())
  {
    return Complete(op, in_isr, ErrorCode::BUSY);
  }
 
  std::array<uint8_t, 2> mem_raw = {};
  EncodeMemAddr(mem_addr, mem_len, mem_raw.data());
 
  const size_t total_size = mem_len + write_data.size_;
  if (ShouldUseInterruptAsync(total_size))
  {
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
    const ErrorCode ans = StartAsyncTransaction(
        slave_addr, mem_raw.data(), mem_len,
        static_cast<const uint8_t*>(write_data.addr_), write_data.size_, nullptr, 0U, op);
    if (ans != ErrorCode::OK)
    {
      if (op.type == WriteOperation::OperationType::BLOCK)
      {
        block_wait_.Cancel();
      }
      Release();
      return Complete(op, in_isr, ans);
    }
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      ASSERT(!in_isr);
      return block_wait_.Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
 
  std::array<uint8_t, kFifoLen> staging = {};
  const size_t max_chunk = kMaxWritePayload - mem_len;
  auto* src = static_cast<const uint8_t*>(write_data.addr_);
  size_t offset = 0U;
  ErrorCode ans = ErrorCode::OK;
 
  if (write_data.size_ == 0U)
  {
    EncodeMemAddr(mem_addr, mem_len, staging.data());
    ans = ExecuteTransaction(slave_addr, staging.data(), mem_len, nullptr, 0U);
  }
  else
  {
    while (offset < write_data.size_)
    {
      const size_t chunk = std::min(write_data.size_ - offset, max_chunk);
      const uint16_t cur_mem = static_cast<uint16_t>(mem_addr + offset);
      EncodeMemAddr(cur_mem, mem_len, staging.data());
      Memory::FastCopy(staging.data() + mem_len, src + offset, chunk);
      ans = ExecuteTransaction(slave_addr, staging.data(), mem_len + chunk, nullptr, 0U);
      if (ans != ErrorCode::OK)
      {
        break;
      }
      offset += chunk;
    }
  }
 
  Release();
  return Complete(op, in_isr, ans);
}

Port()

i2c_port_t LibXR::ESP32I2C::Port ( ) const

inline

Definition at line 49 of file esp_i2c.hpp.

{ return port_num_; }

Read()

ErrorCode LibXR::ESP32I2C::Read ( uint16_t slave_addr, RawData read_data, ReadOperation & op, bool in_isr = false )

overridevirtual

读取 I2C 设备的数据。 Reads data from an I2C device.

该函数从指定的 I2C 从设备地址读取数据，并存储到 read_data 中。 This function reads data from the specified I2C slave address and stores it in read_data.

Parameters

slave_addr	目标 I2C 从设备地址，不带 R/W 位。 Target I2C slave address, no R/W bit included.
read_data	存储读取数据的 RawData 对象。 A RawData object to store the read data.
op	读取操作对象，包含同步或异步操作模式。 Read operation object containing synchronous or asynchronous operation mode.
in_isr	是否在中断中进行操作。Whether the operation is performed in an ISR.

Returns

返回 ErrorCode，指示操作是否成功。 Returns an ErrorCode indicating whether the operation was successful.

Implements LibXR::I2C.

Definition at line 1019 of file esp_i2c.cpp.

{
  const ErrorCode init_ec = EnsureInitialized(in_isr);
  if (init_ec != ErrorCode::OK)
  {
    return Complete(op, in_isr, init_ec);
  }
 
  if (!IsValid7BitAddr(slave_addr))
  {
    return Complete(op, in_isr, ErrorCode::ARG_ERR);
  }
 
  if ((read_data.size_ > 0U) && (read_data.addr_ == nullptr))
  {
    return Complete(op, in_isr, ErrorCode::PTR_NULL);
  }
 
  if (!Acquire())
  {
    return Complete(op, in_isr, ErrorCode::BUSY);
  }
 
  const size_t total_size = read_data.size_;
  if (ShouldUseInterruptAsync(total_size))
  {
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
    const ErrorCode ans = StartAsyncTransaction(slave_addr, nullptr, 0U, nullptr, 0U,
                                                static_cast<uint8_t*>(read_data.addr_),
                                                read_data.size_, op);
    if (ans != ErrorCode::OK)
    {
      if (op.type == ReadOperation::OperationType::BLOCK)
      {
        block_wait_.Cancel();
      }
      Release();
      return Complete(op, in_isr, ans);
    }
    if (op.type == ReadOperation::OperationType::BLOCK)
    {
      ASSERT(!in_isr);
      return block_wait_.Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
 
  const ErrorCode ans = ExecuteTransaction(
      slave_addr, nullptr, 0U, static_cast<uint8_t*>(read_data.addr_), read_data.size_);
  Release();
  return Complete(op, in_isr, ans);
}

RecoverController()

ErrorCode LibXR::ESP32I2C::RecoverController ( )

private

Definition at line 329 of file esp_i2c.cpp.

{
  if (hal_.dev == nullptr)
  {
    return ErrorCode::INIT_ERR;
  }
 
#if SOC_I2C_SUPPORT_HW_FSM_RST
  i2c_hal_master_fsm_rst(&hal_);
  i2c_ll_update(hal_.dev);
  return ErrorCode::OK;
#else
  // ESP32-class targets without HW FSM reset require full register reset.
  ResetBusRegisterAtomic(port_num_);
  i2c_hal_master_init(&hal_);
  i2c_ll_disable_intr_mask(hal_.dev, I2C_LL_MASTER_EVENT_INTR);
  i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_INTR_MASK);
 
  const ErrorCode pin_ec = ConfigurePins();
  if (pin_ec != ErrorCode::OK)
  {
    return pin_ec;
  }
  return ApplyConfig();
#endif
}

Release()

void LibXR::ESP32I2C::Release ( )

private

Definition at line 167 of file esp_i2c.cpp.

{ busy_.Clear(); }

ResolveClockSource()

ErrorCode LibXR::ESP32I2C::ResolveClockSource ( uint32_t & source_hz )

private

Definition at line 202 of file esp_i2c.cpp.

{
  source_hz = 0U;
  const esp_err_t err =
      esp_clk_tree_src_get_freq_hz(static_cast<soc_module_clk_t>(I2C_CLK_SRC_DEFAULT),
                                   ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &source_hz);
  if ((err != ESP_OK) || (source_hz == 0U))
  {
    return ErrorCode::INIT_ERR;
  }
  return ErrorCode::OK;
}

SetConfig()

ErrorCode LibXR::ESP32I2C::SetConfig ( Configuration config )

overridevirtual

配置 I2C 设备参数。 Configures the I2C device settings.

该函数用于设置 I2C 设备的参数，例如通信速率等。 This function sets the parameters of the I2C device, such as the communication speed.

Parameters

config

包含 I2C 设置信息的 Configuration 结构体。 A Configuration structure containing I2C settings.

Returns

返回 ErrorCode，指示配置是否成功。 Returns an ErrorCode indicating whether the configuration was successful.

Implements LibXR::I2C.

Definition at line 934 of file esp_i2c.cpp.

{
  if (config.clock_speed == 0U)
  {
    return ErrorCode::ARG_ERR;
  }
 
  if (!initialized_)
  {
    const ErrorCode init_err = InitHardware();
    if (init_err != ErrorCode::OK)
    {
      return init_err;
    }
  }
 
  if (!Acquire())
  {
    return ErrorCode::BUSY;
  }
 
  config_ = config;
  const ErrorCode ans = ApplyConfig();
  Release();
  return ans;
}

ShouldUseInterruptAsync()

bool LibXR::ESP32I2C::ShouldUseInterruptAsync ( size_t total_size ) const

private

Definition at line 356 of file esp_i2c.cpp.

{
  if (!intr_installed_)
  {
    return false;
  }
  return (isr_enable_min_size_ > 0U) &&
         (total_size >= static_cast<size_t>(isr_enable_min_size_));
}

StartAsyncTransaction()

ErrorCode LibXR::ESP32I2C::StartAsyncTransaction ( uint16_t slave_addr, const uint8_t * write_prefix_payload, size_t write_prefix_size, const uint8_t * write_payload, size_t write_size, uint8_t * read_payload, size_t read_size, ReadOperation & op )

private

Definition at line 366 of file esp_i2c.cpp.

{
  if (!initialized_ || (hal_.dev == nullptr))
  {
    return ErrorCode::INIT_ERR;
  }
  if (!IsValid7BitAddr(slave_addr))
  {
    return ErrorCode::ARG_ERR;
  }
  if ((write_prefix_size > 0U) && (write_prefix_payload == nullptr))
  {
    return ErrorCode::PTR_NULL;
  }
  if (write_prefix_size > async_write_prefix_.size())
  {
    return ErrorCode::SIZE_ERR;
  }
  if ((write_size > 0U) && (write_payload == nullptr))
  {
    return ErrorCode::PTR_NULL;
  }
  if ((read_size > 0U) && (read_payload == nullptr))
  {
    return ErrorCode::PTR_NULL;
  }
  if (async_running_)
  {
    return ErrorCode::BUSY;
  }
 
  if (i2c_ll_is_bus_busy(hal_.dev))
  {
    const ErrorCode ec = RecoverController();
    if (ec != ErrorCode::OK)
    {
      return ec;
    }
  }
 
  i2c_ll_txfifo_rst(hal_.dev);
  i2c_ll_rxfifo_rst(hal_.dev);
  i2c_ll_disable_intr_mask(hal_.dev, I2C_LL_MASTER_EVENT_INTR);
  i2c_ll_clear_intr_mask(hal_.dev, I2C_LL_INTR_MASK);
 
  async_op_ = op;
  op.MarkAsRunning();
  async_running_ = true;
  async_slave_addr_ = slave_addr;
  async_write_prefix_size_ = write_prefix_size;
  async_write_prefix_offset_ = 0U;
  if (write_prefix_size > 0U)
  {
    Memory::FastCopy(async_write_prefix_.data(), write_prefix_payload, write_prefix_size);
  }
  async_write_payload_ = write_payload;
  async_write_size_ = write_size;
  async_write_offset_ = 0U;
  async_read_payload_ = read_payload;
  async_read_size_ = read_size;
  async_read_offset_ = 0U;
  async_pending_read_chunk_ = 0U;
  async_write_phase_done_ =
      !((write_prefix_size > 0U) || (write_size > 0U) || (read_size == 0U));
  async_write_addr_sent_ = false;
  async_write_stop_sent_ = false;
  async_read_addr_sent_ = false;
 
  const ErrorCode kick = KickAsyncTransaction();
  if ((kick == ErrorCode::PENDING) || (kick == ErrorCode::OK))
  {
    if (kick == ErrorCode::OK)
    {
      FinishAsync(false, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  async_running_ = false;
  async_write_prefix_size_ = 0U;
  async_write_prefix_offset_ = 0U;
  async_write_payload_ = nullptr;
  async_write_size_ = 0U;
  async_write_offset_ = 0U;
  async_read_payload_ = nullptr;
  async_read_size_ = 0U;
  async_read_offset_ = 0U;
  async_pending_read_chunk_ = 0U;
  async_write_phase_done_ = true;
  async_write_addr_sent_ = false;
  async_write_stop_sent_ = false;
  async_read_addr_sent_ = false;
  return kick;
}

Write()

ErrorCode LibXR::ESP32I2C::Write ( uint16_t slave_addr, ConstRawData write_data, WriteOperation & op, bool in_isr = false )

overridevirtual

向 I2C 设备写入数据。 Writes data to an I2C device.

该函数将 write_data 写入指定的 I2C 从设备地址。 This function writes write_data to the specified I2C slave address.

Parameters

slave_addr	目标 I2C 从设备地址，不带 R/W 位。 Target I2C slave address, no R/W bit included.
write_data	需要写入的数据，ConstRawData 类型。 The data to be written, of type ConstRawData.
op	写入操作对象，包含同步或异步操作模式。 Write operation object containing synchronous or asynchronous operation mode.
in_isr	是否在中断中进行操作。Whether the operation is performed in an ISR.

Returns

返回 ErrorCode，指示操作是否成功。 Returns an ErrorCode indicating whether the operation was successful.

Implements LibXR::I2C.

Definition at line 961 of file esp_i2c.cpp.

{
  const ErrorCode init_ec = EnsureInitialized(in_isr);
  if (init_ec != ErrorCode::OK)
  {
    return Complete(op, in_isr, init_ec);
  }
 
  if (!IsValid7BitAddr(slave_addr))
  {
    return Complete(op, in_isr, ErrorCode::ARG_ERR);
  }
 
  if ((write_data.size_ > 0U) && (write_data.addr_ == nullptr))
  {
    return Complete(op, in_isr, ErrorCode::PTR_NULL);
  }
 
  if (!Acquire())
  {
    return Complete(op, in_isr, ErrorCode::BUSY);
  }
 
  const size_t total_size = write_data.size_;
  if (ShouldUseInterruptAsync(total_size))
  {
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      block_wait_.Start(*op.data.sem_info.sem);
    }
    const ErrorCode ans = StartAsyncTransaction(
        slave_addr, nullptr, 0U, static_cast<const uint8_t*>(write_data.addr_),
        write_data.size_, nullptr, 0U, op);
    if (ans != ErrorCode::OK)
    {
      if (op.type == WriteOperation::OperationType::BLOCK)
      {
        block_wait_.Cancel();
      }
      Release();
      return Complete(op, in_isr, ans);
    }
    if (op.type == WriteOperation::OperationType::BLOCK)
    {
      ASSERT(!in_isr);
      return block_wait_.Wait(op.data.sem_info.timeout);
    }
    return ErrorCode::OK;
  }
 
  const ErrorCode ans =
      ExecuteTransaction(slave_addr, static_cast<const uint8_t*>(write_data.addr_),
                         write_data.size_, nullptr, 0U);
  Release();
  return Complete(op, in_isr, ans);
}

Field Documentation

async_op_

ReadOperation LibXR::ESP32I2C::async_op_ {}

private

Definition at line 101 of file esp_i2c.hpp.

{};

async_pending_read_chunk_

size_t LibXR::ESP32I2C::async_pending_read_chunk_ = 0U

private

Definition at line 112 of file esp_i2c.hpp.

async_read_addr_sent_

bool LibXR::ESP32I2C::async_read_addr_sent_ = false

private

Definition at line 116 of file esp_i2c.hpp.

async_read_offset_

size_t LibXR::ESP32I2C::async_read_offset_ = 0U

private

Definition at line 111 of file esp_i2c.hpp.

async_read_payload_

uint8_t* LibXR::ESP32I2C::async_read_payload_ = nullptr

private

Definition at line 109 of file esp_i2c.hpp.

async_read_size_

size_t LibXR::ESP32I2C::async_read_size_ = 0U

private

Definition at line 110 of file esp_i2c.hpp.

async_running_

bool LibXR::ESP32I2C::async_running_ = false

private

Definition at line 100 of file esp_i2c.hpp.

async_slave_addr_

uint16_t LibXR::ESP32I2C::async_slave_addr_ = 0U

private

Definition at line 102 of file esp_i2c.hpp.

async_write_addr_sent_

bool LibXR::ESP32I2C::async_write_addr_sent_ = false

private

Definition at line 114 of file esp_i2c.hpp.

async_write_offset_

size_t LibXR::ESP32I2C::async_write_offset_ = 0U

private

Definition at line 108 of file esp_i2c.hpp.

async_write_payload_

const uint8_t* LibXR::ESP32I2C::async_write_payload_ = nullptr

private

Definition at line 106 of file esp_i2c.hpp.

async_write_phase_done_

bool LibXR::ESP32I2C::async_write_phase_done_ = true

private

Definition at line 113 of file esp_i2c.hpp.

async_write_prefix_

std::array<uint8_t, 2> LibXR::ESP32I2C::async_write_prefix_ = {}

private

Definition at line 103 of file esp_i2c.hpp.

{};

async_write_prefix_offset_

size_t LibXR::ESP32I2C::async_write_prefix_offset_ = 0U

private

Definition at line 105 of file esp_i2c.hpp.

async_write_prefix_size_

size_t LibXR::ESP32I2C::async_write_prefix_size_ = 0U

private

Definition at line 104 of file esp_i2c.hpp.

async_write_size_

size_t LibXR::ESP32I2C::async_write_size_ = 0U

private

Definition at line 107 of file esp_i2c.hpp.

async_write_stop_sent_

bool LibXR::ESP32I2C::async_write_stop_sent_ = false

private

Definition at line 115 of file esp_i2c.hpp.

block_wait_

AsyncBlockWait LibXR::ESP32I2C::block_wait_ {}

private

Definition at line 117 of file esp_i2c.hpp.

{};

busy_

Flag::Plain LibXR::ESP32I2C::busy_

private

Definition at line 96 of file esp_i2c.hpp.

config_

Configuration LibXR::ESP32I2C::config_ {}

private

Definition at line 93 of file esp_i2c.hpp.

{};

enable_internal_pullup_

bool LibXR::ESP32I2C::enable_internal_pullup_

private

Definition at line 89 of file esp_i2c.hpp.

hal_

i2c_hal_context_t LibXR::ESP32I2C::hal_ = {}

private

Definition at line 94 of file esp_i2c.hpp.

{};

initialized_

bool LibXR::ESP32I2C::initialized_ = false

private

Definition at line 92 of file esp_i2c.hpp.

intr_handle_

intr_handle_t LibXR::ESP32I2C::intr_handle_ = nullptr

private

Definition at line 97 of file esp_i2c.hpp.

intr_installed_

bool LibXR::ESP32I2C::intr_installed_ = false

private

Definition at line 98 of file esp_i2c.hpp.

isr_enable_min_size_

uint32_t LibXR::ESP32I2C::isr_enable_min_size_

private

Definition at line 91 of file esp_i2c.hpp.

kFifoLen

size_t LibXR::ESP32I2C::kFifoLen = SOC_I2C_FIFO_LEN

staticconstexprprivate

Definition at line 52 of file esp_i2c.hpp.

kMaxReadPayload

size_t LibXR::ESP32I2C::kMaxReadPayload = (kFifoLen > 4U) ? (kFifoLen - 4U) : kFifoLen

staticconstexprprivate

Definition at line 56 of file esp_i2c.hpp.

kMaxWritePayload

size_t LibXR::ESP32I2C::kMaxWritePayload = (kFifoLen > 4U) ? (kFifoLen - 4U) : 0U

staticconstexprprivate

Definition at line 53 of file esp_i2c.hpp.

kMaxWriteReadPrefix

size_t LibXR::ESP32I2C::kMaxWriteReadPrefix

staticconstexprprivate

Initial value:

=
      (kFifoLen > 5U) ? (kFifoLen - 5U) : 0U

Definition at line 54 of file esp_i2c.hpp.

PIN_NO_CHANGE

int LibXR::ESP32I2C::PIN_NO_CHANGE = -1

staticconstexpr

Definition at line 23 of file esp_i2c.hpp.

port_num_

i2c_port_t LibXR::ESP32I2C::port_num_

private

Definition at line 86 of file esp_i2c.hpp.

scl_pin_

int LibXR::ESP32I2C::scl_pin_

private

Definition at line 87 of file esp_i2c.hpp.

sda_pin_

int LibXR::ESP32I2C::sda_pin_

private

Definition at line 88 of file esp_i2c.hpp.

source_clock_hz_

uint32_t LibXR::ESP32I2C::source_clock_hz_ = 0U

private

Definition at line 95 of file esp_i2c.hpp.

timeout_ms_

uint32_t LibXR::ESP32I2C::timeout_ms_

private

Definition at line 90 of file esp_i2c.hpp.

---

The documentation for this class was generated from the following files:

• driver/esp/esp_i2c.hpp
• driver/esp/esp_i2c.cpp