LibXR::MSPM0I2C Class Reference

Inheritance diagram for LibXR::MSPM0I2C:

Collaboration diagram for LibXR::MSPM0I2C:

Data Structures
struct	Resources

Public Member Functions
	MSPM0I2C (Resources res, RawData stage_buffer, uint32_t dma_enable_min_size=8, I2C::Configuration config={100000})
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	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.
ErrorCode	SetConfig (Configuration config) override
	配置 I2C 设备参数。 Configures the I2C device settings.
Public Member Functions inherited from LibXR::I2C
	I2C ()
	默认构造函数。 Default constructor.

Static Public Member Functions
static constexpr uint8_t	ResolveIndex (IRQn_Type irqn)

Private Member Functions
ErrorCode	WaitControllerIdle () const
ErrorCode	WaitTransactionDone () const
ErrorCode	WaitBusIdle () const
ErrorCode	CheckControllerError () const
ErrorCode	PollingWrite7 (uint16_t addr7, const uint8_t *data, size_t size)
ErrorCode	PollingRead7 (uint16_t addr7, uint8_t *data, size_t size)
ErrorCode	DmaWrite7 (uint16_t addr7, ConstRawData write_data)
ErrorCode	DmaRead7 (uint16_t addr7, RawData read_data)
ErrorCode	WaitDmaTransferDone (uint8_t channel_id) const

Private Attributes
Resources	res_
RawData	stage_buffer_
uint32_t	dma_enable_min_size_
bool	dma_enabled_ = false

Static Private Attributes
static constexpr uint8_t	MAX_I2C_INSTANCES = 4
static constexpr uint8_t	INVALID_INSTANCE_INDEX = 0xFF

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

Detailed Description

Definition at line 10 of file mspm0_i2c.hpp.

Constructor & Destructor Documentation

MSPM0I2C()

MSPM0I2C::MSPM0I2C	(	Resources	res,
		RawData	stage_buffer,
		uint32_t	dma_enable_min_size = 8,
		I2C::Configuration	config = {100000} )

Definition at line 107 of file mspm0_i2c.cpp.

    : I2C(),
      res_(res),
      stage_buffer_(stage_buffer),
      dma_enable_min_size_(dma_enable_min_size)
{
  ASSERT(res_.instance != nullptr);
  ASSERT(res_.clock_freq > 0);
  ASSERT(res_.index < MAX_I2C_INSTANCES);
  ASSERT(stage_buffer_.addr_ != nullptr);
  ASSERT(stage_buffer_.size_ > 0);
 
  if (config.clock_speed == 0)
  {
    config.clock_speed = res_.default_bus_speed_hz;
  }
  const ErrorCode SET_CFG_ANS = SetConfig(config);
  ASSERT(SET_CFG_ANS == ErrorCode::OK);
}

Member Function Documentation

CheckControllerError()

ErrorCode MSPM0I2C::CheckControllerError ( ) const

private

Definition at line 128 of file mspm0_i2c.cpp.

{
  const uint32_t STATUS = DL_I2C_getControllerStatus(res_.instance);
  if ((STATUS & DL_I2C_CONTROLLER_STATUS_ERROR) != 0 ||
      (STATUS & DL_I2C_CONTROLLER_STATUS_ARBITRATION_LOST) != 0)
  {
    return ErrorCode::FAILED;
  }
  return ErrorCode::OK;
}

DmaRead7()

ErrorCode MSPM0I2C::DmaRead7 ( uint16_t addr7, RawData read_data )

private

Definition at line 504 of file mspm0_i2c.cpp.

{
  if (read_data.size_ == 0)
  {
    return ErrorCode::OK;
  }
  if (read_data.size_ > MSPM0_I2C_MAX_TRANSFER_SIZE)
  {
    return ErrorCode::ARG_ERR;
  }
 
  auto stop_dma = [&]()
  {
    const uint32_t DMA_RX_MASK = mspm0_i2c_dma_channel_mask(DMA_CH_RX_CHAN_ID);
    DL_DMA_disableChannel(DMA, DMA_CH_RX_CHAN_ID);
    DL_DMA_clearInterruptStatus(DMA, DMA_RX_MASK);
  };
 
  auto attempt_once = [&]() -> ErrorCode
  {
    ErrorCode ans = WaitControllerIdle();
    if (ans != ErrorCode::OK)
    {
      return ans;
    }
 
    DL_I2C_disableInterrupt(res_.instance, 0xFFFFFFFFU);
    DL_I2C_clearInterruptStatus(res_.instance, 0xFFFFFFFFU);
 
    const uint32_t DMA_RX_MASK = mspm0_i2c_dma_channel_mask(DMA_CH_RX_CHAN_ID);
    DL_DMA_disableChannel(DMA, DMA_CH_RX_CHAN_ID);
    DL_DMA_clearInterruptStatus(DMA, DMA_RX_MASK);
    DL_DMA_setSrcAddr(DMA, DMA_CH_RX_CHAN_ID,
                      static_cast<uint32_t>(
                          reinterpret_cast<uintptr_t>(&res_.instance->MASTER.MRXDATA)));
    DL_DMA_setDestAddr(
        DMA, DMA_CH_RX_CHAN_ID,
        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(read_data.addr_)));
    DL_DMA_setTransferSize(DMA, DMA_CH_RX_CHAN_ID,
                           static_cast<uint16_t>(read_data.size_));
    DL_DMA_enableChannel(DMA, DMA_CH_RX_CHAN_ID);
 
    DL_I2C_startControllerTransfer(res_.instance, addr7, DL_I2C_CONTROLLER_DIRECTION_RX,
                                   static_cast<uint16_t>(read_data.size_));
 
    ans = WaitDmaTransferDone(DMA_CH_RX_CHAN_ID);
    if (ans != ErrorCode::OK)
    {
      stop_dma();
      return ans;
    }
 
    ans = WaitTransactionDone();
    if (ans != ErrorCode::OK)
    {
      stop_dma();
      return ans;
    }
 
    ans = WaitBusIdle();
    if (ans != ErrorCode::OK)
    {
      stop_dma();
      return ans;
    }
 
    stop_dma();
    return CheckControllerError();
  };
 
  ErrorCode last_error = ErrorCode::FAILED;
  for (uint32_t attempt = 0; attempt < MSPM0_I2C_POLLING_ATTEMPTS; ++attempt)
  {
    last_error = attempt_once();
    if (last_error == ErrorCode::OK)
    {
      return ErrorCode::OK;
    }
    mspm0_i2c_recover_controller(res_.instance);
  }
 
  return last_error;
}

DmaWrite7()

ErrorCode MSPM0I2C::DmaWrite7 ( uint16_t addr7, ConstRawData write_data )

private

Definition at line 420 of file mspm0_i2c.cpp.

{
  if (write_data.size_ == 0)
  {
    return ErrorCode::OK;
  }
  if (write_data.size_ > MSPM0_I2C_MAX_TRANSFER_SIZE)
  {
    return ErrorCode::ARG_ERR;
  }
 
  auto stop_dma = [&]()
  {
    const uint32_t DMA_TX_MASK = mspm0_i2c_dma_channel_mask(DMA_CH_TX_CHAN_ID);
    DL_DMA_disableChannel(DMA, DMA_CH_TX_CHAN_ID);
    DL_DMA_clearInterruptStatus(DMA, DMA_TX_MASK);
  };
 
  auto attempt_once = [&]() -> ErrorCode
  {
    ErrorCode ans = WaitControllerIdle();
    if (ans != ErrorCode::OK)
    {
      return ans;
    }
 
    DL_I2C_disableInterrupt(res_.instance, 0xFFFFFFFFU);
    DL_I2C_clearInterruptStatus(res_.instance, 0xFFFFFFFFU);
 
    const uint32_t DMA_TX_MASK = mspm0_i2c_dma_channel_mask(DMA_CH_TX_CHAN_ID);
    DL_DMA_disableChannel(DMA, DMA_CH_TX_CHAN_ID);
    DL_DMA_clearInterruptStatus(DMA, DMA_TX_MASK);
    DL_DMA_setSrcAddr(
        DMA, DMA_CH_TX_CHAN_ID,
        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(write_data.addr_)));
    DL_DMA_setDestAddr(DMA, DMA_CH_TX_CHAN_ID,
                       static_cast<uint32_t>(
                           reinterpret_cast<uintptr_t>(&res_.instance->MASTER.MTXDATA)));
    DL_DMA_setTransferSize(DMA, DMA_CH_TX_CHAN_ID,
                           static_cast<uint16_t>(write_data.size_));
    DL_DMA_enableChannel(DMA, DMA_CH_TX_CHAN_ID);
 
    DL_I2C_startControllerTransfer(res_.instance, addr7, DL_I2C_CONTROLLER_DIRECTION_TX,
                                   static_cast<uint16_t>(write_data.size_));
 
    ans = WaitDmaTransferDone(DMA_CH_TX_CHAN_ID);
    if (ans != ErrorCode::OK)
    {
      stop_dma();
      return ans;
    }
 
    ans = WaitTransactionDone();
    if (ans != ErrorCode::OK)
    {
      stop_dma();
      return ans;
    }
 
    ans = WaitBusIdle();
    if (ans != ErrorCode::OK)
    {
      stop_dma();
      return ans;
    }
 
    stop_dma();
    return CheckControllerError();
  };
 
  ErrorCode last_error = ErrorCode::FAILED;
  for (uint32_t attempt = 0; attempt < MSPM0_I2C_POLLING_ATTEMPTS; ++attempt)
  {
    last_error = attempt_once();
    if (last_error == ErrorCode::OK)
    {
      return ErrorCode::OK;
    }
    mspm0_i2c_recover_controller(res_.instance);
  }
 
  return last_error;
}

MemRead()

ErrorCode MSPM0I2C::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 682 of file mspm0_i2c.cpp.

{
  if (read_data.size_ > MSPM0_I2C_MAX_TRANSFER_SIZE)
  {
    return ErrorCode::ARG_ERR;
  }
  if (read_data.size_ == 0)
  {
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  const uint16_t ADDR7 = mspm0_i2c_to_addr7(slave_addr);
  const size_t ADDR_SIZE = (mem_addr_size == MemAddrLength::BYTE_8) ? 1 : 2;
  auto* addr_bytes = static_cast<uint8_t*>(stage_buffer_.addr_);
  if (stage_buffer_.size_ < ADDR_SIZE)
  {
    return ErrorCode::ARG_ERR;
  }
 
  if (ADDR_SIZE == 1)
  {
    addr_bytes[0] = static_cast<uint8_t>(mem_addr & 0xFF);
  }
  else
  {
    addr_bytes[0] = static_cast<uint8_t>((mem_addr >> 8) & 0xFF);
    addr_bytes[1] = static_cast<uint8_t>(mem_addr & 0xFF);
  }
 
  auto finalize = [&](ErrorCode code)
  {
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, code);
    }
    return code;
  };
 
  auto try_repeated_start = [&]() -> ErrorCode
  {
    ErrorCode ans = WaitControllerIdle();
    if (ans != ErrorCode::OK)
    {
      return ans;
    }
 
    DL_I2C_clearInterruptStatus(res_.instance, 0xFFFFFFFFU);
 
    const uint16_t ADDR_SENT = DL_I2C_fillControllerTXFIFO(
        res_.instance, addr_bytes, static_cast<uint16_t>(ADDR_SIZE));
    if (ADDR_SENT != ADDR_SIZE)
    {
      return ErrorCode::FAILED;
    }
 
    DL_I2C_startControllerTransferAdvanced(
        res_.instance, ADDR7, DL_I2C_CONTROLLER_DIRECTION_TX,
        static_cast<uint16_t>(ADDR_SIZE), DL_I2C_CONTROLLER_START_ENABLE,
        DL_I2C_CONTROLLER_STOP_DISABLE, DL_I2C_CONTROLLER_ACK_ENABLE);
 
    uint32_t tx_done_timeout = MSPM0_I2C_WAIT_FIFO_TIMEOUT;
    while (DL_I2C_getRawInterruptStatus(res_.instance,
                                        DL_I2C_INTERRUPT_CONTROLLER_TX_DONE) == 0U)
    {
      if (CheckControllerError() != ErrorCode::OK)
      {
        return ErrorCode::FAILED;
      }
      if (tx_done_timeout-- == 0U)
      {
        return ErrorCode::BUSY;
      }
    }
    DL_I2C_clearInterruptStatus(res_.instance, DL_I2C_INTERRUPT_CONTROLLER_TX_DONE);
 
    if (CheckControllerError() != ErrorCode::OK)
    {
      return ErrorCode::FAILED;
    }
 
    DL_I2C_startControllerTransferAdvanced(
        res_.instance, ADDR7, DL_I2C_CONTROLLER_DIRECTION_RX,
        static_cast<uint16_t>(read_data.size_), DL_I2C_CONTROLLER_START_ENABLE,
        DL_I2C_CONTROLLER_STOP_ENABLE, DL_I2C_CONTROLLER_ACK_DISABLE);
 
    size_t received = 0;
    auto* read_ptr = static_cast<uint8_t*>(read_data.addr_);
    while (received < read_data.size_)
    {
      uint32_t timeout = MSPM0_I2C_WAIT_FIFO_TIMEOUT;
      while (DL_I2C_isControllerRXFIFOEmpty(res_.instance))
      {
        if (CheckControllerError() != ErrorCode::OK)
        {
          return ErrorCode::FAILED;
        }
        if (timeout-- == 0)
        {
          return ErrorCode::BUSY;
        }
      }
 
      while (!DL_I2C_isControllerRXFIFOEmpty(res_.instance) && received < read_data.size_)
      {
        read_ptr[received++] = DL_I2C_receiveControllerData(res_.instance);
      }
    }
 
    uint32_t rx_done_timeout = MSPM0_I2C_WAIT_FIFO_TIMEOUT;
    while (DL_I2C_getRawInterruptStatus(res_.instance,
                                        DL_I2C_INTERRUPT_CONTROLLER_RX_DONE) == 0U)
    {
      if (CheckControllerError() != ErrorCode::OK)
      {
        return ErrorCode::FAILED;
      }
      if (rx_done_timeout-- == 0U)
      {
        return ErrorCode::BUSY;
      }
    }
    DL_I2C_clearInterruptStatus(res_.instance, DL_I2C_INTERRUPT_CONTROLLER_RX_DONE);
 
    ans = WaitBusIdle();
    if (ans != ErrorCode::OK)
    {
      return ans;
    }
 
    return CheckControllerError();
  };
 
  ErrorCode last_error = ErrorCode::FAILED;
  for (uint32_t attempt = 0; attempt < MSPM0_I2C_MEMREAD_RS_ATTEMPTS; ++attempt)
  {
    last_error = try_repeated_start();
    if (last_error == ErrorCode::OK)
    {
      return finalize(ErrorCode::OK);
    }
    mspm0_i2c_recover_controller(res_.instance);
  }
 
  for (uint32_t attempt = 0; attempt < MSPM0_I2C_MEMREAD_FALLBACK_ATTEMPTS; ++attempt)
  {
    last_error = PollingWrite7(ADDR7, addr_bytes, ADDR_SIZE);
    if (last_error == ErrorCode::OK)
    {
      last_error =
          PollingRead7(ADDR7, static_cast<uint8_t*>(read_data.addr_), read_data.size_);
      if (last_error == ErrorCode::OK)
      {
        return finalize(ErrorCode::OK);
      }
    }
    mspm0_i2c_recover_controller(res_.instance);
  }
 
  return finalize(last_error);
}

MemWrite()

ErrorCode MSPM0I2C::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 649 of file mspm0_i2c.cpp.

{
  const size_t ADDR_SIZE = (mem_addr_size == MemAddrLength::BYTE_8) ? 1 : 2;
  const size_t TOTAL_SIZE = ADDR_SIZE + write_data.size_;
  if (TOTAL_SIZE > MSPM0_I2C_MAX_TRANSFER_SIZE)
  {
    return ErrorCode::ARG_ERR;
  }
  if (TOTAL_SIZE > stage_buffer_.size_)
  {
    return ErrorCode::ARG_ERR;
  }
 
  auto* tx = static_cast<uint8_t*>(stage_buffer_.addr_);
  if (ADDR_SIZE == 1)
  {
    tx[0] = static_cast<uint8_t>(mem_addr & 0xFF);
  }
  else
  {
    tx[0] = static_cast<uint8_t>((mem_addr >> 8) & 0xFF);
    tx[1] = static_cast<uint8_t>(mem_addr & 0xFF);
  }
  if (write_data.size_ > 0)
  {
    memcpy(tx + ADDR_SIZE, write_data.addr_, write_data.size_);
  }
 
  return Write(slave_addr, ConstRawData(tx, TOTAL_SIZE), op, in_isr);
}

PollingRead7()

ErrorCode MSPM0I2C::PollingRead7 ( uint16_t addr7, uint8_t * data, size_t size )

private

Definition at line 335 of file mspm0_i2c.cpp.

{
  if (size == 0)
  {
    return ErrorCode::OK;
  }
  if (size > MSPM0_I2C_MAX_TRANSFER_SIZE)
  {
    return ErrorCode::ARG_ERR;
  }
 
  auto attempt_once = [&]() -> ErrorCode
  {
    ErrorCode ans = WaitControllerIdle();
    if (ans != ErrorCode::OK)
    {
      return ans;
    }
 
    DL_I2C_clearInterruptStatus(res_.instance, 0xFFFFFFFFU);
    DL_I2C_startControllerTransfer(res_.instance, addr7, DL_I2C_CONTROLLER_DIRECTION_RX,
                                   static_cast<uint16_t>(size));
 
    size_t received = 0;
    while (received < size)
    {
      uint32_t timeout = MSPM0_I2C_WAIT_FIFO_TIMEOUT;
      while (DL_I2C_isControllerRXFIFOEmpty(res_.instance))
      {
        if (CheckControllerError() != ErrorCode::OK)
        {
          return ErrorCode::FAILED;
        }
        if (timeout-- == 0)
        {
          return ErrorCode::BUSY;
        }
      }
 
      while (!DL_I2C_isControllerRXFIFOEmpty(res_.instance) && received < size)
      {
        data[received++] = DL_I2C_receiveControllerData(res_.instance);
      }
    }
 
    ans = WaitBusIdle();
    if (ans != ErrorCode::OK)
    {
      return ans;
    }
 
    return CheckControllerError();
  };
 
  ErrorCode last_error = ErrorCode::FAILED;
  for (uint32_t attempt = 0; attempt < MSPM0_I2C_POLLING_ATTEMPTS; ++attempt)
  {
    last_error = attempt_once();
    if (last_error == ErrorCode::OK)
    {
      return ErrorCode::OK;
    }
    mspm0_i2c_recover_controller(res_.instance);
  }
 
  return last_error;
}

PollingWrite7()

ErrorCode MSPM0I2C::PollingWrite7 ( uint16_t addr7, const uint8_t * data, size_t size )

private

Definition at line 266 of file mspm0_i2c.cpp.

{
  if (size == 0)
  {
    return ErrorCode::OK;
  }
  if (size > MSPM0_I2C_MAX_TRANSFER_SIZE)
  {
    return ErrorCode::ARG_ERR;
  }
 
  auto attempt_once = [&]() -> ErrorCode
  {
    ErrorCode ans = WaitControllerIdle();
    if (ans != ErrorCode::OK)
    {
      return ans;
    }
 
    DL_I2C_clearInterruptStatus(res_.instance, 0xFFFFFFFFU);
 
    size_t sent =
        DL_I2C_fillControllerTXFIFO(res_.instance, data, static_cast<uint16_t>(size));
    DL_I2C_startControllerTransfer(res_.instance, addr7, DL_I2C_CONTROLLER_DIRECTION_TX,
                                   static_cast<uint16_t>(size));
 
    while (sent < size)
    {
      uint32_t timeout = MSPM0_I2C_WAIT_FIFO_TIMEOUT;
      while (DL_I2C_getRawInterruptStatus(
                 res_.instance, DL_I2C_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER) == 0U)
      {
        if (CheckControllerError() != ErrorCode::OK)
        {
          return ErrorCode::FAILED;
        }
        if (timeout-- == 0)
        {
          return ErrorCode::BUSY;
        }
      }
 
      sent += DL_I2C_fillControllerTXFIFO(res_.instance, data + sent,
                                          static_cast<uint16_t>(size - sent));
    }
 
    ans = WaitBusIdle();
    if (ans != ErrorCode::OK)
    {
      return ans;
    }
 
    return CheckControllerError();
  };
 
  ErrorCode last_error = ErrorCode::FAILED;
  for (uint32_t attempt = 0; attempt < MSPM0_I2C_POLLING_ATTEMPTS; ++attempt)
  {
    last_error = attempt_once();
    if (last_error == ErrorCode::OK)
    {
      return ErrorCode::OK;
    }
    mspm0_i2c_recover_controller(res_.instance);
  }
 
  return last_error;
}

Read()

ErrorCode MSPM0I2C::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 588 of file mspm0_i2c.cpp.

{
  if (read_data.size_ == 0)
  {
    if (op.type != ReadOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  const uint16_t ADDR7 = mspm0_i2c_to_addr7(slave_addr);
  ErrorCode ans = ErrorCode::NOT_SUPPORT;
  if (dma_enabled_ && read_data.size_ > dma_enable_min_size_)
  {
    ans = DmaRead7(ADDR7, read_data);
  }
  else
  {
    ans = PollingRead7(ADDR7, static_cast<uint8_t*>(read_data.addr_), read_data.size_);
  }
 
  if (op.type != ReadOperation::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
  return ans;
}

ResolveIndex()

static constexpr uint8_t LibXR::MSPM0I2C::ResolveIndex ( IRQn_Type irqn )

inlinestaticconstexpr

Definition at line 43 of file mspm0_i2c.hpp.

  {
    switch (irqn)
    {
#if defined(I2C0_BASE)
      case I2C0_INT_IRQn:
        return 0;
#endif
#if defined(I2C1_BASE)
      case I2C1_INT_IRQn:
        return 1;
#endif
#if defined(I2C2_BASE)
      case I2C2_INT_IRQn:
        return 2;
#endif
#if defined(I2C3_BASE)
      case I2C3_INT_IRQn:
        return 3;
#endif
      default:
        return INVALID_INSTANCE_INDEX;
    }
  }

SetConfig()

ErrorCode MSPM0I2C::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 191 of file mspm0_i2c.cpp.

{
  if (config.clock_speed == 0)
  {
    return ErrorCode::ARG_ERR;
  }
 
  const uint32_t PERIOD_DEN = config.clock_speed * 10U;
  if (PERIOD_DEN == 0)
  {
    return ErrorCode::ARG_ERR;
  }
 
  uint32_t period_factor = res_.clock_freq / PERIOD_DEN;
  if (period_factor == 0)
  {
    return ErrorCode::NOT_SUPPORT;
  }
  if (period_factor > 128U)
  {
    return ErrorCode::NOT_SUPPORT;
  }
 
  const uint8_t TIMER_PERIOD = static_cast<uint8_t>(period_factor - 1U);
  const DL_I2C_ClockConfig CLOCK_CONFIG = {
      .clockSel = DL_I2C_CLOCK_BUSCLK,
      .divideRatio = DL_I2C_CLOCK_DIVIDE_1,
  };
 
  uint8_t dma_tx_trigger = 0U;
  uint8_t dma_rx_trigger = 0U;
  const bool USE_DMA =
      mspm0_i2c_resolve_dma_triggers(res_.instance, dma_tx_trigger, dma_rx_trigger);
  dma_enabled_ = USE_DMA;
 
  DL_I2C_disableController(res_.instance);
  DL_I2C_setClockConfig(res_.instance, &CLOCK_CONFIG);
  DL_I2C_resetControllerTransfer(res_.instance);
  DL_I2C_setTimerPeriod(res_.instance, TIMER_PERIOD);
  DL_I2C_setControllerTXFIFOThreshold(
      res_.instance, USE_DMA ? DL_I2C_TX_FIFO_LEVEL_EMPTY : DL_I2C_TX_FIFO_LEVEL_BYTES_1);
  DL_I2C_setControllerRXFIFOThreshold(res_.instance, DL_I2C_RX_FIFO_LEVEL_BYTES_1);
  DL_I2C_enableControllerClockStretching(res_.instance);
  DL_I2C_disableInterrupt(res_.instance, 0xFFFFFFFFU);
  DL_I2C_clearInterruptStatus(res_.instance, 0xFFFFFFFFU);
 
  DL_I2C_disableDMAEvent(res_.instance, DL_I2C_EVENT_ROUTE_1,
                         DL_I2C_DMA_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER);
  DL_I2C_disableDMAEvent(res_.instance, DL_I2C_EVENT_ROUTE_2,
                         DL_I2C_DMA_INTERRUPT_CONTROLLER_RXFIFO_TRIGGER);
  DL_DMA_disableChannel(DMA, DMA_CH_TX_CHAN_ID);
  DL_DMA_disableChannel(DMA, DMA_CH_RX_CHAN_ID);
  DL_DMA_clearInterruptStatus(DMA, mspm0_i2c_dma_channel_mask(DMA_CH_TX_CHAN_ID) |
                                       mspm0_i2c_dma_channel_mask(DMA_CH_RX_CHAN_ID));
 
  if (USE_DMA)
  {
    DL_DMA_Config dma_tx_config = MSPM0_I2C_DMA_TX_CONFIG_BASE;
    DL_DMA_Config dma_rx_config = MSPM0_I2C_DMA_RX_CONFIG_BASE;
    dma_tx_config.trigger = dma_tx_trigger;
    dma_rx_config.trigger = dma_rx_trigger;
 
    DL_I2C_enableDMAEvent(res_.instance, DL_I2C_EVENT_ROUTE_1,
                          DL_I2C_DMA_INTERRUPT_CONTROLLER_TXFIFO_TRIGGER);
    DL_I2C_enableDMAEvent(res_.instance, DL_I2C_EVENT_ROUTE_2,
                          DL_I2C_DMA_INTERRUPT_CONTROLLER_RXFIFO_TRIGGER);
    DL_DMA_initChannel(DMA, DMA_CH_TX_CHAN_ID, &dma_tx_config);
    DL_DMA_initChannel(DMA, DMA_CH_RX_CHAN_ID, &dma_rx_config);
  }
 
  DL_I2C_enableController(res_.instance);
 
  return ErrorCode::OK;
}

WaitBusIdle()

ErrorCode MSPM0I2C::WaitBusIdle ( ) const

private

Definition at line 173 of file mspm0_i2c.cpp.

{
  uint32_t timeout = MSPM0_I2C_WAIT_BUS_TIMEOUT;
  while (timeout-- > 0)
  {
    if ((DL_I2C_getControllerStatus(res_.instance) & DL_I2C_CONTROLLER_STATUS_BUSY_BUS) ==
        0)
    {
      return ErrorCode::OK;
    }
    if (CheckControllerError() != ErrorCode::OK)
    {
      return ErrorCode::FAILED;
    }
  }
  return ErrorCode::BUSY;
}

WaitControllerIdle()

ErrorCode MSPM0I2C::WaitControllerIdle ( ) const

private

Definition at line 139 of file mspm0_i2c.cpp.

{
  uint32_t timeout = MSPM0_I2C_WAIT_IDLE_TIMEOUT;
  while (timeout-- > 0)
  {
    if ((DL_I2C_getControllerStatus(res_.instance) & DL_I2C_CONTROLLER_STATUS_IDLE) != 0)
    {
      return ErrorCode::OK;
    }
    if (CheckControllerError() != ErrorCode::OK)
    {
      return ErrorCode::FAILED;
    }
  }
  return ErrorCode::BUSY;
}

WaitDmaTransferDone()

ErrorCode MSPM0I2C::WaitDmaTransferDone ( uint8_t channel_id ) const

private

Definition at line 403 of file mspm0_i2c.cpp.

{
  uint32_t timeout = MSPM0_I2C_WAIT_FIFO_TIMEOUT;
  while (DL_DMA_getTransferSize(DMA, channel_id) != 0U)
  {
    if (CheckControllerError() != ErrorCode::OK)
    {
      return ErrorCode::FAILED;
    }
    if (timeout-- == 0U)
    {
      return ErrorCode::BUSY;
    }
  }
  return ErrorCode::OK;
}

WaitTransactionDone()

ErrorCode MSPM0I2C::WaitTransactionDone ( ) const

private

Definition at line 156 of file mspm0_i2c.cpp.

{
  uint32_t timeout = MSPM0_I2C_WAIT_FIFO_TIMEOUT;
  while (timeout-- > 0)
  {
    if (DL_I2C_getTransactionCount(res_.instance) == 0)
    {
      return ErrorCode::OK;
    }
    if (CheckControllerError() != ErrorCode::OK)
    {
      return ErrorCode::FAILED;
    }
  }
  return ErrorCode::BUSY;
}

Write()

ErrorCode MSPM0I2C::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 618 of file mspm0_i2c.cpp.

{
  if (write_data.size_ == 0)
  {
    if (op.type != WriteOperation::OperationType::BLOCK)
    {
      op.UpdateStatus(in_isr, ErrorCode::OK);
    }
    return ErrorCode::OK;
  }
 
  const uint16_t ADDR7 = mspm0_i2c_to_addr7(slave_addr);
  ErrorCode ans = ErrorCode::NOT_SUPPORT;
  if (dma_enabled_ && write_data.size_ > dma_enable_min_size_)
  {
    ans = DmaWrite7(ADDR7, write_data);
  }
  else
  {
    ans = PollingWrite7(ADDR7, static_cast<const uint8_t*>(write_data.addr_),
                        write_data.size_);
  }
 
  if (op.type != WriteOperation::OperationType::BLOCK)
  {
    op.UpdateStatus(in_isr, ans);
  }
  return ans;
}

Field Documentation

dma_enable_min_size_

uint32_t LibXR::MSPM0I2C::dma_enable_min_size_

private

Definition at line 92 of file mspm0_i2c.hpp.

dma_enabled_

bool LibXR::MSPM0I2C::dma_enabled_ = false

private

Definition at line 93 of file mspm0_i2c.hpp.

INVALID_INSTANCE_INDEX

uint8_t LibXR::MSPM0I2C::INVALID_INSTANCE_INDEX = 0xFF

staticconstexprprivate

Definition at line 70 of file mspm0_i2c.hpp.

MAX_I2C_INSTANCES

uint8_t LibXR::MSPM0I2C::MAX_I2C_INSTANCES = 4

staticconstexprprivate

Definition at line 69 of file mspm0_i2c.hpp.

res_

Resources LibXR::MSPM0I2C::res_

private

Definition at line 90 of file mspm0_i2c.hpp.

stage_buffer_

RawData LibXR::MSPM0I2C::stage_buffer_

private

Definition at line 91 of file mspm0_i2c.hpp.

---

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

• driver/mspm0/mspm0_i2c.hpp
• driver/mspm0/mspm0_i2c.cpp