Inheritance diagram for LibXR::CH32I2C:

Collaboration diagram for LibXR::CH32I2C:

Public Member Functions
	CH32I2C (ch32_i2c_id_t id, RawData dma_buff, GPIO_TypeDef scl_port, uint16_t scl_pin, GPIO_TypeDef sda_port, uint16_t sda_pin, uint32_t pin_remap=0, uint32_t dma_enable_min_size=3, uint32_t default_clock_hz=400000, bool ten_bit_addr=false)
	构造 I2C 驱动对象 / Construct I2C driver object

ErrorCode	Read (uint16_t slave_addr, RawData read_data, ReadOperation &op, bool in_isr) override
	读取 I2C 设备的数据。 Reads data from an I2C device.

ErrorCode	Write (uint16_t slave_addr, ConstRawData write_data, WriteOperation &op, bool in_isr) override
	向 I2C 设备写入数据。 Writes data to an I2C device.

ErrorCode	MemRead (uint16_t slave_addr, uint16_t mem_addr, RawData read_data, ReadOperation &op, MemAddrLength mem_addr_size, bool in_isr) 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, bool in_isr) override
	向 I2C 设备指定寄存器写入数据。 Writes data to a specific register of an I2C device.

ErrorCode	SetConfig (Configuration config) override
	配置 I2C 设备参数。 Configures the I2C device settings.

void	RxDmaIRQHandler ()
	DMA 回调入口 / DMA callbacks from CH32 DMA driver.

void	TxDmaIRQHandler ()

void	ErrorIRQHandler ()
	错误中断回调 / I2C error IRQ callback

Public Member Functions inherited from LibXR::I2C
	I2C ()
	默认构造函数。 Default constructor.

Data Fields
I2C_TypeDef *	instance_

DMA_Channel_TypeDef *	dma_rx_channel_

DMA_Channel_TypeDef *	dma_tx_channel_

ch32_i2c_id_t	id_

uint32_t	dma_enable_min_size_

RawData	dma_buff_

ReadOperation	read_op_

WriteOperation	write_op_

RawData	read_buff_

bool	read_ = false

bool	busy_ = false

bool	recovering_ = false

GPIO_TypeDef *	scl_port_

uint16_t	scl_pin_

GPIO_TypeDef *	sda_port_

uint16_t	sda_pin_

Configuration	cfg_ {400000}

bool	ten_bit_addr_ = false

AsyncBlockWait	block_wait_ {}

Static Public Attributes
static CH32I2C *	map_ [CH32_I2C_NUMBER] = {nullptr}

Private Member Functions
bool	DmaBusy () const

bool	WaitEvent (uint32_t evt, uint32_t timeout_us=K_DEFAULT_TIMEOUT_US)

bool	WaitFlag (uint32_t flag, FlagStatus st, uint32_t timeout_us=K_DEFAULT_TIMEOUT_US)

ErrorCode	WaitEventOrRecover (uint32_t evt, uint32_t timeout_us=K_DEFAULT_TIMEOUT_US)

ErrorCode	WaitFlagOrRecover (uint32_t flag, FlagStatus st, uint32_t timeout_us=K_DEFAULT_TIMEOUT_US)

void	ClearAddrFlag ()

ErrorCode	MasterStartAndAddress (uint16_t slave_addr, uint8_t dir)

ErrorCode	MasterStartAndAddress10Bit (uint16_t addr10, uint8_t final_dir)

ErrorCode	SendMemAddr (uint16_t mem_addr, MemAddrLength len)

ErrorCode	PollingWriteBytes (const uint8_t *data, uint32_t len)

ErrorCode	PollingReadBytes (uint8_t *data, uint32_t len)

void	StartTxDma (uint32_t len)

void	StartRxDma (uint32_t len)

void	AbortTransfer (ErrorCode ec)

void	RecoverAfterImmediateFailure ()

Static Private Member Functions
static uint8_t	Addr7ToAddr8 (uint16_t addr7)

static uint16_t	Addr10Clamp (uint16_t addr10)

Static Private Attributes
static constexpr uint32_t	K_DEFAULT_TIMEOUT_US = 20000
	默认超时（微秒） / Default timeout in microseconds

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

Detailed Description

Definition at line 19 of file ch32_i2c.hpp.

Constructor & Destructor Documentation

◆ CH32I2C()

CH32I2C::CH32I2C	(	ch32_i2c_id_t	id,
		RawData	dma_buff,
		GPIO_TypeDef *	scl_port,
		uint16_t	scl_pin,
		GPIO_TypeDef *	sda_port,
		uint16_t	sda_pin,
		uint32_t	pin_remap = 0,
		uint32_t	dma_enable_min_size = 3,
		uint32_t	default_clock_hz = 400000,
		bool	ten_bit_addr = false )

构造 I2C 驱动对象 / Construct I2C driver object

slave_addr 使用不带 R/W 位的原始 7 位或 10 位地址。 slave_addr uses raw 7-bit or 10-bit addresses without the R/W bit.

Definition at line 30 of file ch32_i2c.cpp.

    : I2C(),
      instance_(ch32_i2c_get_instance_id(id)),
      dma_rx_channel_(CH32_I2C_RX_DMA_CHANNEL_MAP[id]),
      dma_tx_channel_(CH32_I2C_TX_DMA_CHANNEL_MAP[id]),
      id_(id),
      dma_enable_min_size_(dma_enable_min_size),
      dma_buff_(dma_buff),
      scl_port_(scl_port),
      scl_pin_(scl_pin),
      sda_port_(sda_port),
      sda_pin_(sda_pin),
      ten_bit_addr_(ten_bit_addr)
{
  ASSERT(instance_ != nullptr);
  ASSERT(dma_buff_.addr_ != nullptr && dma_buff_.size_ > 0);
 
  map_[id_] = this;
 
  // Clock configuration.
  ch32_i2c_enable_clocks(id_);
 
  // GPIO configuration (I2C alternate-function open-drain).
  {
    GPIO_InitTypeDef gpio = {};
    gpio.GPIO_Speed = GPIO_Speed_50MHz;
    gpio.GPIO_Mode = GPIO_Mode_AF_OD;
 
    RCC_APB2PeriphClockCmd(ch32_get_gpio_periph(scl_port_), ENABLE);
    RCC_APB2PeriphClockCmd(ch32_get_gpio_periph(sda_port_), ENABLE);
 
    GPIO_SetBits(scl_port_, scl_pin_);
    GPIO_SetBits(sda_port_, sda_pin_);
 
    gpio.GPIO_Pin = scl_pin_;
    GPIO_Init(scl_port_, &gpio);
 
    gpio.GPIO_Pin = sda_pin_;
    GPIO_Init(sda_port_, &gpio);
 
    if (pin_remap != 0)
    {
      RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
      GPIO_PinRemapConfig(pin_remap, ENABLE);
    }
  }
 
  // DMA configuration.
  {
    // RX
    {
      ch32_dma_callback_t cb = [](void* arg)
      { reinterpret_cast<CH32I2C*>(arg)->RxDmaIRQHandler(); };
      ch32_dma_register_callback(ch32_dma_get_id(dma_rx_channel_), cb, this);
 
      DMA_InitTypeDef di = {};
      DMA_DeInit(dma_rx_channel_);
      di.DMA_PeripheralBaseAddr = (uint32_t)&instance_->DATAR;
      di.DMA_MemoryBaseAddr = (uint32_t)dma_buff_.addr_;
      di.DMA_DIR = DMA_DIR_PeripheralSRC;
      di.DMA_BufferSize = 0;
      di.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
      di.DMA_MemoryInc = DMA_MemoryInc_Enable;
      di.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
      di.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
      di.DMA_Mode = DMA_Mode_Normal;
      di.DMA_Priority = DMA_Priority_High;
      di.DMA_M2M = DMA_M2M_Disable;
      DMA_Init(dma_rx_channel_, &di);
      DMA_ITConfig(dma_rx_channel_, DMA_IT_TC, ENABLE);
      NVIC_EnableIRQ(CH32_DMA_IRQ_MAP[ch32_dma_get_id(dma_rx_channel_)]);
    }
 
    // TX
    {
      ch32_dma_callback_t cb = [](void* arg)
      { reinterpret_cast<CH32I2C*>(arg)->TxDmaIRQHandler(); };
      ch32_dma_register_callback(ch32_dma_get_id(dma_tx_channel_), cb, this);
 
      DMA_InitTypeDef di = {};
      DMA_DeInit(dma_tx_channel_);
      di.DMA_PeripheralBaseAddr = (uint32_t)&instance_->DATAR;
      di.DMA_MemoryBaseAddr = (uint32_t)dma_buff_.addr_;
      di.DMA_DIR = DMA_DIR_PeripheralDST;
      di.DMA_BufferSize = 0;
      di.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
      di.DMA_MemoryInc = DMA_MemoryInc_Enable;
      di.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
      di.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
      di.DMA_Mode = DMA_Mode_Normal;
      di.DMA_Priority = DMA_Priority_VeryHigh;
      di.DMA_M2M = DMA_M2M_Disable;
      DMA_Init(dma_tx_channel_, &di);
      DMA_ITConfig(dma_tx_channel_, DMA_IT_TC, ENABLE);
      NVIC_EnableIRQ(CH32_DMA_IRQ_MAP[ch32_dma_get_id(dma_tx_channel_)]);
    }
  }
 
  // I2C error interrupt for asynchronous transfer abort handling.
  I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
  NVIC_EnableIRQ(CH32_I2C_ER_IRQ_MAP[id_]);
 
  // Default runtime parameters.
  cfg_.clock_speed = default_clock_hz;
  (void)SetConfig(cfg_);
}

Member Function Documentation

◆ AbortTransfer()

void CH32I2C::AbortTransfer ( ErrorCode ec )

private

Definition at line 482 of file ch32_i2c.cpp.

{
  I2C_DMACmd(instance_, DISABLE);
  I2C_DMALastTransferCmd(instance_, DISABLE);
  DMA_Cmd(dma_tx_channel_, DISABLE);
  DMA_Cmd(dma_rx_channel_, DISABLE);
 
  // 恢复默认 ACK/NACK 配置
  I2C_AcknowledgeConfig(instance_, ENABLE);
  I2C_NACKPositionConfig(instance_, I2C_NACKPosition_Current);
 
  I2C_GenerateSTOP(instance_, ENABLE);
 
  busy_ = false;
 
  if (read_)
  {
    if (read_op_.type == ReadOperation::OperationType::BLOCK)
    {
      (void)block_wait_.TryPost(true, ec);
    }
    else
    {
      read_op_.UpdateStatus(true, ec);
    }
  }
  else
  {
    if (write_op_.type == WriteOperation::OperationType::BLOCK)
    {
      (void)block_wait_.TryPost(true, ec);
    }
    else
    {
      write_op_.UpdateStatus(true, ec);
    }
  }
}

◆ Addr10Clamp()

static uint16_t LibXR::CH32I2C::Addr10Clamp ( uint16_t addr10 )

inlinestaticprivate

Definition at line 73 of file ch32_i2c.hpp.

  {
    ASSERT(addr10 <= 0x3FF);
    return static_cast<uint16_t>(addr10 & 0x3FF);
  }

◆ Addr7ToAddr8()

static uint8_t LibXR::CH32I2C::Addr7ToAddr8 ( uint16_t addr7 )

inlinestaticprivate

Definition at line 65 of file ch32_i2c.hpp.

  {
    // WCH SPL 在 I2C_Send7bitAddress 中仅更新 bit0(R/W)。
    // WCH SPL updates only bit0 (R/W) in I2C_Send7bitAddress.
    ASSERT(addr7 <= 0x7F);
    return static_cast<uint8_t>(((addr7 & 0x7F) << 1) & 0xFE);
  }

◆ ClearAddrFlag()

void CH32I2C::ClearAddrFlag ( )

private

Definition at line 220 of file ch32_i2c.cpp.

{
  volatile uint16_t tmp1 = instance_->STAR1;
  volatile uint16_t tmp2 = instance_->STAR2;
  (void)tmp1;
  (void)tmp2;
}

◆ DmaBusy()

bool LibXR::CH32I2C::DmaBusy ( ) const

inlineprivate

Definition at line 60 of file ch32_i2c.hpp.

  {
    return (dma_rx_channel_->CNTR != 0) || (dma_tx_channel_->CNTR != 0) || busy_;
  }

◆ ErrorIRQHandler()

void CH32I2C::ErrorIRQHandler ( )

错误中断回调 / I2C error IRQ callback

Definition at line 959 of file ch32_i2c.cpp.

{
  bool has_err = false;
 
  const uint32_t ITS[] = {I2C_IT_BERR,    I2C_IT_ARLO,   I2C_IT_AF,      I2C_IT_OVR,
                          I2C_IT_TIMEOUT, I2C_IT_PECERR, I2C_IT_SMBALERT};
 
  for (uint32_t it : ITS)
  {
    if (I2C_GetITStatus(instance_, it) == SET)
    {
      I2C_ClearITPendingBit(instance_, it);
      has_err = true;
    }
  }
 
  if (has_err && busy_ && !recovering_)
  {
    AbortTransfer(ErrorCode::FAILED);
  }
}

◆ MasterStartAndAddress()

ErrorCode CH32I2C::MasterStartAndAddress	(	uint16_t	slave_addr,
		uint8_t	dir )

private

Definition at line 290 of file ch32_i2c.cpp.

{
  if (!ten_bit_addr_)
  {
    // 7-bit：输入为原始 7-bit 地址
    const uint8_t ADDR8 = Addr7ToAddr8(slave_addr);
 
    if (auto ec = WaitFlagOrRecover(I2C_FLAG_BUSY, RESET); ec != ErrorCode::OK)
    {
      return ec;
    }
 
    I2C_GenerateSTART(instance_, ENABLE);
    if (auto ec = WaitEventOrRecover(I2C_EVENT_MASTER_MODE_SELECT); ec != ErrorCode::OK)
    {
      return ec;
    }
 
    I2C_Send7bitAddress(instance_, ADDR8, dir);
 
    if (dir == I2C_Direction_Transmitter)
    {
      if (auto ec = WaitEventOrRecover(I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);
          ec != ErrorCode::OK)
      {
        return ec;
      }
    }
    else
    {
      if (auto ec = WaitEventOrRecover(I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED);
          ec != ErrorCode::OK)
      {
        return ec;
      }
    }
 
    ClearAddrFlag();
    return ErrorCode::OK;
  }
 
  // 10-bit：输入为原始 10-bit 地址
  return MasterStartAndAddress10Bit(slave_addr, dir);
}

◆ MasterStartAndAddress10Bit()

ErrorCode CH32I2C::MasterStartAndAddress10Bit	(	uint16_t	addr10,
		uint8_t	final_dir )

private

Definition at line 228 of file ch32_i2c.cpp.

{
  addr10 = Addr10Clamp(addr10);
 
  // 等待 BUSY 释放
  if (auto ec = WaitFlagOrRecover(I2C_FLAG_BUSY, RESET); ec != ErrorCode::OK)
  {
    return ec;
  }
 
  // --- 1) START ---
  I2C_GenerateSTART(instance_, ENABLE);
  if (auto ec = WaitEventOrRecover(I2C_EVENT_MASTER_MODE_SELECT); ec != ErrorCode::OK)
  {
    return ec;
  }
 
  // --- 2) 发送 10-bit 头字节（地址阶段固定以写方向发送，R/W=0）---
  // header (8-bit,left-shifted): 11110 A9 A8 0 => 0xF0/0xF2/0xF4/0xF6
  const uint8_t HEADER = static_cast<uint8_t>(0xF0 | ((addr10 >> 7) & 0x06));
  I2C_Send7bitAddress(instance_, HEADER, I2C_Direction_Transmitter);
 
  // 等待 EVT9（ADD10）
  if (auto ec = WaitEventOrRecover(I2C_EVENT_MASTER_MODE_ADDRESS10); ec != ErrorCode::OK)
  {
    return ec;
  }
 
  // --- 3) 发送地址低 8 位 ---
  I2C_SendData(instance_, static_cast<uint8_t>(addr10 & 0xFF));
 
  // 等待 EVT6（作为 Transmitter 完成地址阶段）
  if (auto ec = WaitEventOrRecover(I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED);
      ec != ErrorCode::OK)
  {
    return ec;
  }
  ClearAddrFlag();
 
  if (final_dir == I2C_Direction_Transmitter)
  {
    return ErrorCode::OK;
  }
 
  // --- 4) 若最终为读：Repeated START + 头字节（R/W=1） ---
  I2C_GenerateSTART(instance_, ENABLE);
  if (auto ec = WaitEventOrRecover(I2C_EVENT_MASTER_MODE_SELECT); ec != ErrorCode::OK)
  {
    return ec;
  }
 
  I2C_Send7bitAddress(instance_, HEADER, I2C_Direction_Receiver);
  if (auto ec = WaitEventOrRecover(I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED);
      ec != ErrorCode::OK)
  {
    return ec;
  }
  ClearAddrFlag();
 
  return ErrorCode::OK;
}

◆ MemRead()

ErrorCode CH32I2C::MemRead	(	uint16_t	slave_addr,
		uint16_t	mem_addr,
		RawData	read_data,
		ReadOperation &	op,
		MemAddrLength	mem_addr_size,
		bool	in_isr )

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 757 of file ch32_i2c.cpp.

{
  if (read_data.size_ == 0)
  {
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  ASSERT(read_data.size_ <= dma_buff_.size_);
  if (DmaBusy())
  {
    return ErrorCode::BUSY;
  }
 
  read_ = true;
  I2C_ITConfig(instance_, I2C_IT_ERR, DISABLE);
 
  // 1) 地址阶段：发送写地址 + mem addr
  ErrorCode ec = MasterStartAndAddress(slave_addr, I2C_Direction_Transmitter);
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
 
  ec = SendMemAddr(mem_addr, mem_addr_size);
  if (ec != ErrorCode::OK)
  {
    I2C_GenerateSTOP(instance_, ENABLE);
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ec);
    }
    return ec;
  }
 
  // 2) Repeated START + 读地址阶段
  if (!ten_bit_addr_)
  {
    const uint8_t ADDR8 = Addr7ToAddr8(slave_addr);
 
    I2C_GenerateSTART(instance_, ENABLE);
    if (!WaitEvent(I2C_EVENT_MASTER_MODE_SELECT))
    {
      I2C_GenerateSTOP(instance_, ENABLE);
      ec = ErrorCode::BUSY;
      if (op.type != ReadOperation::OperationType::BLOCK)
      {
        op.UpdateStatus(in_isr, ec);
      }
      return ec;
    }
 
    I2C_Send7bitAddress(instance_, ADDR8, I2C_Direction_Receiver);
    if (!WaitEvent(I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
    {
      I2C_GenerateSTOP(instance_, ENABLE);
      ec = ErrorCode::BUSY;
      if (op.type != ReadOperation::OperationType::BLOCK)
      {
        op.UpdateStatus(in_isr, ec);
      }
      return ec;
    }
    ClearAddrFlag();
  }
  else
  {
    const uint16_t ADDR10 = Addr10Clamp(slave_addr);
    const uint8_t HEADER = static_cast<uint8_t>(0xF0 | ((ADDR10 >> 7) & 0x06));
 
    I2C_GenerateSTART(instance_, ENABLE);
    if (!WaitEvent(I2C_EVENT_MASTER_MODE_SELECT))
    {
      I2C_GenerateSTOP(instance_, ENABLE);
      ec = ErrorCode::BUSY;
      if (op.type != ReadOperation::OperationType::BLOCK)
      {
        op.UpdateStatus(in_isr, ec);
      }
      return ec;
    }
 
    I2C_Send7bitAddress(instance_, HEADER, I2C_Direction_Receiver);
    if (!WaitEvent(I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
    {
      I2C_GenerateSTOP(instance_, ENABLE);
      ec = ErrorCode::BUSY;
      if (op.type != ReadOperation::OperationType::BLOCK)
      {
        op.UpdateStatus(in_isr, ec);
      }
      return ec;
    }
    ClearAddrFlag();
  }
 
  // 短传输：轮询
  if (read_data.size_ <= dma_enable_min_size_)
  {
    ec = PollingReadBytes(reinterpret_cast<uint8_t*>(read_data.addr_), read_data.size_);
    I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ec);
    }
    return ec;
  }
 
  // 长传输：DMA
  read_op_ = op;
  read_buff_ = read_data;
  busy_ = true;
 
  if (op.type == ReadOperation::OperationType::BLOCK)
  {
    block_wait_.Start(*op.data.sem_info.sem);
  }
  I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
  StartRxDma(read_data.size_);
 
  op.MarkAsRunning();
  if (op.type == ReadOperation::OperationType::BLOCK)
  {
    return block_wait_.Wait(op.data.sem_info.timeout);
  }
  return ErrorCode::OK;
}

◆ MemWrite()

ErrorCode CH32I2C::MemWrite	(	uint16_t	slave_addr,
		uint16_t	mem_addr,
		ConstRawData	write_data,
		WriteOperation &	op,
		MemAddrLength	mem_addr_size,
		bool	in_isr )

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 684 of file ch32_i2c.cpp.

{
  if (write_data.size_ == 0)
  {
    if (op.type != WriteOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  ASSERT(write_data.size_ <= dma_buff_.size_);
  if (DmaBusy())
  {
    return ErrorCode::BUSY;
  }
 
  read_ = false;
  I2C_ITConfig(instance_, I2C_IT_ERR, DISABLE);
 
  ErrorCode ec = MasterStartAndAddress(slave_addr, I2C_Direction_Transmitter);
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
 
  ec = SendMemAddr(mem_addr, mem_addr_size);
  if (ec != ErrorCode::OK)
  {
    I2C_GenerateSTOP(instance_, ENABLE);
    if (op.type != WriteOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ec);
    }
    return ec;
  }
 
  if (write_data.size_ <= dma_enable_min_size_)
  {
    ec = PollingWriteBytes(reinterpret_cast<const uint8_t*>(write_data.addr_),
                           write_data.size_);
    I2C_GenerateSTOP(instance_, ENABLE);
    I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
 
    if (op.type != WriteOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ec);
    }
    return ec;
  }
 
  Memory::FastCopy(dma_buff_.addr_, write_data.addr_, write_data.size_);
 
  write_op_ = op;
  busy_ = true;
 
  if (op.type == WriteOperation::OperationType::BLOCK)
  {
    block_wait_.Start(*op.data.sem_info.sem);
  }
  I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
  StartTxDma(write_data.size_);
 
  op.MarkAsRunning();
  if (op.type == WriteOperation::OperationType::BLOCK)
  {
    return block_wait_.Wait(op.data.sem_info.timeout);
  }
  return ErrorCode::OK;
}

◆ PollingReadBytes()

ErrorCode CH32I2C::PollingReadBytes	(	uint8_t *	data,
		uint32_t	len )

private

Definition at line 383 of file ch32_i2c.cpp.

{
  if (len == 0)
  {
    return ErrorCode::OK;
  }
 
  // 长度=1
  if (len == 1)
  {
    I2C_AcknowledgeConfig(instance_, DISABLE);
    I2C_GenerateSTOP(instance_, ENABLE);
    if (auto ec = WaitFlagOrRecover(I2C_FLAG_RXNE, SET); ec != ErrorCode::OK)
    {
      return ec;
    }
    data[0] = I2C_ReceiveData(instance_);
    I2C_AcknowledgeConfig(instance_, ENABLE);
    return ErrorCode::OK;
  }
 
  // 长度=2
  if (len == 2)
  {
    I2C_NACKPositionConfig(instance_, I2C_NACKPosition_Next);
    I2C_AcknowledgeConfig(instance_, DISABLE);
 
    if (auto ec = WaitFlagOrRecover(I2C_FLAG_BTF, SET); ec != ErrorCode::OK)
    {
      return ec;
    }
    I2C_GenerateSTOP(instance_, ENABLE);
 
    data[0] = I2C_ReceiveData(instance_);
    data[1] = I2C_ReceiveData(instance_);
 
    I2C_NACKPositionConfig(instance_, I2C_NACKPosition_Current);
    I2C_AcknowledgeConfig(instance_, ENABLE);
    return ErrorCode::OK;
  }
 
  // 长度>=3
  I2C_AcknowledgeConfig(instance_, ENABLE);
  I2C_NACKPositionConfig(instance_, I2C_NACKPosition_Current);
 
  uint32_t idx = 0;
  while (len > 3)
  {
    if (auto ec = WaitFlagOrRecover(I2C_FLAG_RXNE, SET); ec != ErrorCode::OK)
    {
      return ec;
    }
    data[idx++] = I2C_ReceiveData(instance_);
    --len;
  }
 
  // 剩余 3 字节处理
  if (auto ec = WaitFlagOrRecover(I2C_FLAG_BTF, SET); ec != ErrorCode::OK)
  {
    return ec;
  }
  I2C_AcknowledgeConfig(instance_, DISABLE);
  data[idx++] = I2C_ReceiveData(instance_);
  I2C_GenerateSTOP(instance_, ENABLE);
  data[idx++] = I2C_ReceiveData(instance_);
 
  if (auto ec = WaitFlagOrRecover(I2C_FLAG_RXNE, SET); ec != ErrorCode::OK)
  {
    return ec;
  }
  data[idx++] = I2C_ReceiveData(instance_);
 
  I2C_AcknowledgeConfig(instance_, ENABLE);
  return ErrorCode::OK;
}

◆ PollingWriteBytes()

ErrorCode CH32I2C::PollingWriteBytes	(	const uint8_t *	data,
		uint32_t	len )

private

Definition at line 366 of file ch32_i2c.cpp.

{
  for (uint32_t i = 0; i < len; ++i)
  {
    if (auto ec = WaitFlagOrRecover(I2C_FLAG_TXE, SET); ec != ErrorCode::OK)
    {
      return ec;
    }
    I2C_SendData(instance_, data[i]);
  }
  if (auto ec = WaitFlagOrRecover(I2C_FLAG_BTF, SET); ec != ErrorCode::OK)
  {
    return ec;
  }
  return ErrorCode::OK;
}

◆ Read()

ErrorCode CH32I2C::Read	(	uint16_t	slave_addr,
		RawData	read_data,
		ReadOperation &	op,
		bool	in_isr )

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 625 of file ch32_i2c.cpp.

{
  if (read_data.size_ == 0)
  {
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  ASSERT(read_data.size_ <= dma_buff_.size_);
  if (DmaBusy())
  {
    return ErrorCode::BUSY;
  }
 
  read_ = true;
  I2C_ITConfig(instance_, I2C_IT_ERR, DISABLE);
 
  ErrorCode ec = MasterStartAndAddress(slave_addr, I2C_Direction_Receiver);
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
 
  // 短传输：轮询
  if (read_data.size_ <= dma_enable_min_size_)
  {
    ec = PollingReadBytes(reinterpret_cast<uint8_t*>(read_data.addr_), read_data.size_);
    I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ec);
    }
    return ec;
  }
 
  // 长传输：DMA
  read_op_ = op;
  read_buff_ = read_data;
  busy_ = true;
 
  if (op.type == ReadOperation::OperationType::BLOCK)
  {
    block_wait_.Start(*op.data.sem_info.sem);
  }
  I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
  StartRxDma(read_data.size_);
 
  op.MarkAsRunning();
  if (op.type == ReadOperation::OperationType::BLOCK)
  {
    return block_wait_.Wait(op.data.sem_info.timeout);
  }
  return ErrorCode::OK;
}

◆ RecoverAfterImmediateFailure()

void CH32I2C::RecoverAfterImmediateFailure ( )

private

Definition at line 521 of file ch32_i2c.cpp.

{
  recovering_ = true;
  I2C_ITConfig(instance_, I2C_IT_ERR, DISABLE);
  I2C_DMACmd(instance_, DISABLE);
  I2C_DMALastTransferCmd(instance_, DISABLE);
  DMA_Cmd(dma_tx_channel_, DISABLE);
  DMA_Cmd(dma_rx_channel_, DISABLE);
  dma_tx_channel_->CNTR = 0;
  dma_rx_channel_->CNTR = 0;
 
  DMA_ClearITPendingBit(CH32_I2C_TX_DMA_IT_MAP[id_]);
  DMA_ClearITPendingBit(CH32_I2C_RX_DMA_IT_MAP[id_]);
 
  const uint32_t err_its[] = {I2C_IT_BERR,   I2C_IT_ARLO,    I2C_IT_AF,      I2C_IT_OVR,
                              I2C_IT_PECERR, I2C_IT_TIMEOUT, I2C_IT_SMBALERT};
  for (uint32_t it : err_its)
  {
    I2C_ClearITPendingBit(instance_, it);
  }
 
  I2C_GenerateSTOP(instance_, ENABLE);
  if (!WaitFlag(I2C_FLAG_BUSY, RESET, K_DEFAULT_TIMEOUT_US))
  {
    (void)SetConfig(cfg_);
  }
  else
  {
    I2C_AcknowledgeConfig(instance_, ENABLE);
    I2C_NACKPositionConfig(instance_, I2C_NACKPosition_Current);
  }
 
  busy_ = false;
  read_ = false;
  read_op_ = {};
  write_op_ = {};
  read_buff_ = {nullptr, 0};
  I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
  recovering_ = false;
}

◆ RxDmaIRQHandler()

void CH32I2C::RxDmaIRQHandler ( )

DMA 回调入口 / DMA callbacks from CH32 DMA driver.

Definition at line 919 of file ch32_i2c.cpp.

{
  if (DMA_GetITStatus(CH32_I2C_RX_DMA_IT_MAP[id_]) == RESET)
  {
    return;
  }
  DMA_ClearITPendingBit(CH32_I2C_RX_DMA_IT_MAP[id_]);
 
  DMA_Cmd(dma_rx_channel_, DISABLE);
  I2C_DMACmd(instance_, DISABLE);
  I2C_DMALastTransferCmd(instance_, DISABLE);
 
  if (recovering_ || !busy_)
  {
    return;
  }
 
  I2C_GenerateSTOP(instance_, ENABLE);
 
  if (read_buff_.size_ > 0)
  {
    Memory::FastCopy(read_buff_.addr_, dma_buff_.addr_, read_buff_.size_);
    read_buff_.size_ = 0;
  }
 
  // 恢复默认 ACK/NACK 配置
  I2C_AcknowledgeConfig(instance_, ENABLE);
  I2C_NACKPositionConfig(instance_, I2C_NACKPosition_Current);
 
  busy_ = false;
  if (read_op_.type == ReadOperation::OperationType::BLOCK)
  {
    (void)block_wait_.TryPost(true, ErrorCode::OK);
  }
  else
  {
    read_op_.UpdateStatus(true, ErrorCode::OK);
  }
}

◆ SendMemAddr()

ErrorCode CH32I2C::SendMemAddr	(	uint16_t	mem_addr,
		MemAddrLength	len )

private

Definition at line 335 of file ch32_i2c.cpp.

{
  if (len == MemAddrLength::BYTE_16)
  {
    if (auto ec = WaitFlagOrRecover(I2C_FLAG_TXE, SET); ec != ErrorCode::OK)
    {
      return ec;
    }
    I2C_SendData(instance_, static_cast<uint8_t>((mem_addr >> 8) & 0xFF));
    if (auto ec = WaitFlagOrRecover(I2C_FLAG_TXE, SET); ec != ErrorCode::OK)
    {
      return ec;
    }
    I2C_SendData(instance_, static_cast<uint8_t>(mem_addr & 0xFF));
  }
  else
  {
    if (auto ec = WaitFlagOrRecover(I2C_FLAG_TXE, SET); ec != ErrorCode::OK)
    {
      return ec;
    }
    I2C_SendData(instance_, static_cast<uint8_t>(mem_addr & 0xFF));
  }
 
  if (auto ec = WaitFlagOrRecover(I2C_FLAG_BTF, SET); ec != ErrorCode::OK)
  {
    return ec;
  }
  return ErrorCode::OK;
}

◆ SetConfig()

ErrorCode CH32I2C::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 140 of file ch32_i2c.cpp.

{
  cfg_ = config;
 
  I2C_Cmd(instance_, DISABLE);
  I2C_DeInit(instance_);
 
  I2C_InitTypeDef init = {};
  init.I2C_ClockSpeed = cfg_.clock_speed;
  init.I2C_Mode = I2C_Mode_I2C;
  init.I2C_DutyCycle = I2C_DutyCycle_2;
  init.I2C_OwnAddress1 = 0;
  init.I2C_Ack = I2C_Ack_Enable;
  init.I2C_AcknowledgedAddress =
      ten_bit_addr_ ? I2C_AcknowledgedAddress_10bit : I2C_AcknowledgedAddress_7bit;
 
  I2C_Init(instance_, &init);
  I2C_Cmd(instance_, ENABLE);
 
  // 默认 ACK/NACK 状态
  I2C_AcknowledgeConfig(instance_, ENABLE);
  I2C_NACKPositionConfig(instance_, I2C_NACKPosition_Current);
 
  return ErrorCode::OK;
}

◆ StartRxDma()

void CH32I2C::StartRxDma ( uint32_t len )

private

Definition at line 468 of file ch32_i2c.cpp.

{
  // DMA 接收需保持 ACK 使能
  I2C_AcknowledgeConfig(instance_, ENABLE);
  I2C_NACKPositionConfig(instance_, I2C_NACKPosition_Current);
 
  dma_rx_channel_->MADDR = reinterpret_cast<uint32_t>(dma_buff_.addr_);
  dma_rx_channel_->CNTR = len;
 
  I2C_DMALastTransferCmd(instance_, ENABLE);
  I2C_DMACmd(instance_, ENABLE);
  DMA_Cmd(dma_rx_channel_, ENABLE);
}

◆ StartTxDma()

void CH32I2C::StartTxDma ( uint32_t len )

private

Definition at line 459 of file ch32_i2c.cpp.

{
  dma_tx_channel_->MADDR = reinterpret_cast<uint32_t>(dma_buff_.addr_);
  dma_tx_channel_->CNTR = len;
 
  I2C_DMACmd(instance_, ENABLE);
  DMA_Cmd(dma_tx_channel_, ENABLE);
}

◆ TxDmaIRQHandler()

void CH32I2C::TxDmaIRQHandler ( )

Definition at line 889 of file ch32_i2c.cpp.

{
  if (DMA_GetITStatus(CH32_I2C_TX_DMA_IT_MAP[id_]) == RESET)
  {
    return;
  }
  DMA_ClearITPendingBit(CH32_I2C_TX_DMA_IT_MAP[id_]);
 
  DMA_Cmd(dma_tx_channel_, DISABLE);
  I2C_DMACmd(instance_, DISABLE);
 
  if (recovering_ || !busy_)
  {
    return;
  }
 
  (void)WaitFlag(I2C_FLAG_BTF, SET, 20000);
  I2C_GenerateSTOP(instance_, ENABLE);
 
  busy_ = false;
  if (write_op_.type == WriteOperation::OperationType::BLOCK)
  {
    (void)block_wait_.TryPost(true, ErrorCode::OK);
  }
  else
  {
    write_op_.UpdateStatus(true, ErrorCode::OK);
  }
}

◆ WaitEvent()

bool CH32I2C::WaitEvent	(	uint32_t	evt,
		uint32_t	timeout_us = K_DEFAULT_TIMEOUT_US )

private

Definition at line 166 of file ch32_i2c.cpp.

{
  const uint64_t START = static_cast<uint64_t>(Timebase::GetMicroseconds());
  while ((static_cast<uint64_t>(Timebase::GetMicroseconds()) - START) < timeout_us)
  {
    if ((instance_->STAR1 & CH32_I2C_ERROR_FLAGS) != 0u)
    {
      return false;
    }
    if (I2C_CheckEvent(instance_, evt) == READY)
    {
      return true;
    }
  }
  return false;
}

◆ WaitEventOrRecover()

ErrorCode CH32I2C::WaitEventOrRecover	(	uint32_t	evt,
		uint32_t	timeout_us = K_DEFAULT_TIMEOUT_US )

private

Definition at line 200 of file ch32_i2c.cpp.

{
  if (WaitEvent(evt, timeout_us))
  {
    return ErrorCode::OK;
  }
  RecoverAfterImmediateFailure();
  return ErrorCode::BUSY;
}

◆ WaitFlag()

bool CH32I2C::WaitFlag	(	uint32_t	flag,
		FlagStatus	st,
		uint32_t	timeout_us = K_DEFAULT_TIMEOUT_US )

private

Definition at line 183 of file ch32_i2c.cpp.

{
  const uint64_t START = static_cast<uint64_t>(Timebase::GetMicroseconds());
  while ((static_cast<uint64_t>(Timebase::GetMicroseconds()) - START) < timeout_us)
  {
    if ((flag != I2C_FLAG_BUSY) && ((instance_->STAR1 & CH32_I2C_ERROR_FLAGS) != 0u))
    {
      return false;
    }
    if (I2C_GetFlagStatus(instance_, flag) == st)
    {
      return true;
    }
  }
  return false;
}

◆ WaitFlagOrRecover()

ErrorCode CH32I2C::WaitFlagOrRecover	(	uint32_t	flag,
		FlagStatus	st,
		uint32_t	timeout_us = K_DEFAULT_TIMEOUT_US )

private

Definition at line 210 of file ch32_i2c.cpp.

{
  if (WaitFlag(flag, st, timeout_us))
  {
    return ErrorCode::OK;
  }
  RecoverAfterImmediateFailure();
  return ErrorCode::BUSY;
}

◆ Write()

ErrorCode CH32I2C::Write	(	uint16_t	slave_addr,
		ConstRawData	write_data,
		WriteOperation &	op,
		bool	in_isr )

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 562 of file ch32_i2c.cpp.

{
  if (write_data.size_ == 0)
  {
    if (op.type != WriteOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  ASSERT(write_data.size_ <= dma_buff_.size_);
  if (DmaBusy())
  {
    return ErrorCode::BUSY;
  }
 
  read_ = false;
  I2C_ITConfig(instance_, I2C_IT_ERR, DISABLE);
 
  ErrorCode ec = MasterStartAndAddress(slave_addr, I2C_Direction_Transmitter);
  if (ec != ErrorCode::OK)
  {
    return ec;
  }
 
  // 短传输：轮询
  if (write_data.size_ <= dma_enable_min_size_)
  {
    ec = PollingWriteBytes(reinterpret_cast<const uint8_t*>(write_data.addr_),
                           write_data.size_);
    I2C_GenerateSTOP(instance_, ENABLE);
    I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
 
    if (op.type != WriteOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ec);
    }
    return ec;
  }
 
  // 长传输：DMA
  Memory::FastCopy(dma_buff_.addr_, write_data.addr_, write_data.size_);
 
  write_op_ = op;
  busy_ = true;
 
  if (op.type == WriteOperation::OperationType::BLOCK)
  {
    block_wait_.Start(*op.data.sem_info.sem);
  }
  I2C_ITConfig(instance_, I2C_IT_ERR, ENABLE);
  StartTxDma(write_data.size_);
 
  op.MarkAsRunning();
  if (op.type == WriteOperation::OperationType::BLOCK)
  {
    return block_wait_.Wait(op.data.sem_info.timeout);
  }
  return ErrorCode::OK;
}

Field Documentation

◆ block_wait_

AsyncBlockWait LibXR::CH32I2C::block_wait_ {}

Definition at line 129 of file ch32_i2c.hpp.

129{};

◆ busy_

bool LibXR::CH32I2C::busy_ = false

Definition at line 118 of file ch32_i2c.hpp.

◆ cfg_

Configuration LibXR::CH32I2C::cfg_ {400000}

Definition at line 126 of file ch32_i2c.hpp.

126{400000};

◆ dma_buff_

RawData LibXR::CH32I2C::dma_buff_

Definition at line 112 of file ch32_i2c.hpp.

◆ dma_enable_min_size_

uint32_t LibXR::CH32I2C::dma_enable_min_size_

Definition at line 110 of file ch32_i2c.hpp.

◆ dma_rx_channel_

DMA_Channel_TypeDef* LibXR::CH32I2C::dma_rx_channel_

Definition at line 107 of file ch32_i2c.hpp.

◆ dma_tx_channel_

DMA_Channel_TypeDef* LibXR::CH32I2C::dma_tx_channel_

Definition at line 108 of file ch32_i2c.hpp.

◆ id_

ch32_i2c_id_t LibXR::CH32I2C::id_

Definition at line 109 of file ch32_i2c.hpp.

◆ instance_

I2C_TypeDef* LibXR::CH32I2C::instance_

Definition at line 106 of file ch32_i2c.hpp.

◆ K_DEFAULT_TIMEOUT_US

uint32_t LibXR::CH32I2C::K_DEFAULT_TIMEOUT_US = 20000

staticconstexprprivate

默认超时（微秒） / Default timeout in microseconds

Definition at line 58 of file ch32_i2c.hpp.

◆ map_

CH32I2C * CH32I2C::map_ = {nullptr}

static

Definition at line 54 of file ch32_i2c.hpp.

◆ read_

bool LibXR::CH32I2C::read_ = false

Definition at line 117 of file ch32_i2c.hpp.

◆ read_buff_

RawData LibXR::CH32I2C::read_buff_

Definition at line 116 of file ch32_i2c.hpp.

◆ read_op_

ReadOperation LibXR::CH32I2C::read_op_

Definition at line 114 of file ch32_i2c.hpp.

◆ recovering_

bool LibXR::CH32I2C::recovering_ = false

Definition at line 119 of file ch32_i2c.hpp.

◆ scl_pin_

uint16_t LibXR::CH32I2C::scl_pin_

Definition at line 122 of file ch32_i2c.hpp.

◆ scl_port_

GPIO_TypeDef* LibXR::CH32I2C::scl_port_

Definition at line 121 of file ch32_i2c.hpp.

◆ sda_pin_

uint16_t LibXR::CH32I2C::sda_pin_

Definition at line 124 of file ch32_i2c.hpp.

◆ sda_port_

GPIO_TypeDef* LibXR::CH32I2C::sda_port_

Definition at line 123 of file ch32_i2c.hpp.

◆ ten_bit_addr_

bool LibXR::CH32I2C::ten_bit_addr_ = false

Definition at line 128 of file ch32_i2c.hpp.

◆ write_op_

WriteOperation LibXR::CH32I2C::write_op_

Definition at line 115 of file ch32_i2c.hpp.

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

driver/ch/ch32_i2c.hpp
driver/ch/ch32_i2c.cpp

Public Member Functions

Data Fields

Static Public Attributes

Private Member Functions

Static Private Member Functions

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CH32I2C()

Member Function Documentation

◆ AbortTransfer()

◆ Addr10Clamp()

◆ Addr7ToAddr8()

◆ ClearAddrFlag()

◆ DmaBusy()

◆ ErrorIRQHandler()

◆ MasterStartAndAddress()

◆ MasterStartAndAddress10Bit()

◆ MemRead()

◆ MemWrite()

◆ PollingReadBytes()

◆ PollingWriteBytes()

◆ Read()

◆ RecoverAfterImmediateFailure()

◆ RxDmaIRQHandler()

◆ SendMemAddr()

◆ SetConfig()

◆ StartRxDma()

◆ StartTxDma()

◆ TxDmaIRQHandler()

◆ WaitEvent()

◆ WaitEventOrRecover()

◆ WaitFlag()

◆ WaitFlagOrRecover()

◆ Write()

Field Documentation

◆ block_wait_

◆ busy_

◆ cfg_

◆ dma_buff_

◆ dma_enable_min_size_

◆ dma_rx_channel_

◆ dma_tx_channel_

◆ id_

◆ instance_

◆ K_DEFAULT_TIMEOUT_US

◆ map_

◆ read_

◆ read_buff_

◆ read_op_

◆ recovering_

◆ scl_pin_

◆ scl_port_

◆ sda_pin_

◆ sda_port_

◆ ten_bit_addr_

◆ write_op_