662 lines
21 KiB
C
662 lines
21 KiB
C
#include "i2cs.h"
|
||
#include "main.h"
|
||
|
||
static inline void delay(i2c_t *handle); // 延时函数
|
||
static inline void _ack(i2c_t *handle); // 应答
|
||
static inline void _nack(i2c_t *handle); // 非应答
|
||
|
||
/**
|
||
* @brief 启动I2C总线
|
||
* @param {i2c_t} *handle - I2C总线句柄
|
||
* @note: 用于启动I2C总线的操作。在发送或接收数据之前，需要先启动总线。
|
||
*/
|
||
static void _start(i2c_t *handle)
|
||
{
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
// 获取gpios指针
|
||
i2c_gpio_group_t *gpios = &handle->gpios;
|
||
// 获取scl指针
|
||
gpio_t *scl = gpios->scl;
|
||
// 获取sda指针
|
||
gpio_t *sda = gpios->sda;
|
||
// 设置sda
|
||
gpios->sda->set(*sda);
|
||
// 设置scl
|
||
gpios->scl->set(*scl);
|
||
// 延时
|
||
delay(handle);
|
||
// 重置sda
|
||
gpios->sda->reset(*sda);
|
||
// 延时
|
||
delay(handle);
|
||
// 重置scl
|
||
gpios->scl->reset(*scl);
|
||
// 延时
|
||
delay(handle);
|
||
}
|
||
|
||
/**
|
||
* @brief 停止I2C总线
|
||
* @param {i2c_t} *handle - I2C总线句柄
|
||
* @note: 用于停止I2C总线的操作。在发送或接收数据之后，需要先停止总线。
|
||
*/
|
||
static void _stop(i2c_t *handle)
|
||
{
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
i2c_gpio_group_t *gpios = &handle->gpios;
|
||
gpio_t *scl = gpios->scl;
|
||
gpio_t *sda = gpios->sda;
|
||
gpios->scl->reset(*scl);
|
||
gpios->sda->reset(*sda);
|
||
delay(handle);
|
||
gpios->scl->set(*scl);
|
||
gpios->sda->set(*sda);
|
||
delay(handle);
|
||
}
|
||
/**
|
||
* @brief 等待应答信号
|
||
* @param {i2c_t} *handle - I2C总线句柄
|
||
* @return {BOOL} - 等待成功返回TRUE，否则返回FALSE
|
||
* @note: 用于等待I2C总线上发送的应答信号。
|
||
*/
|
||
static BOOL _wait_ack(i2c_t *handle)
|
||
{
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
uint8_t count = 0;
|
||
i2c_gpio_group_t *gpios = &handle->gpios;
|
||
gpio_t *scl = gpios->scl;
|
||
gpio_t *sda = gpios->sda;
|
||
gpios->sda->set(*sda);
|
||
gpios->scl->set(*scl);
|
||
delay(handle);
|
||
while (gpios->sda->read(*sda))
|
||
{
|
||
count++;
|
||
if (count > 250)
|
||
{
|
||
_stop(handle);
|
||
return FALSE;
|
||
}
|
||
}
|
||
gpios->scl->reset(*scl);
|
||
delay(handle);
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 读取一个字节
|
||
* @param {i2c_t} *handle - I2C总线句柄
|
||
* @param {BOOL} ack - 应答信号标志
|
||
* @return {uint8_t} - 读取到的字节
|
||
* @note: 用于从I2C总线上读取一个字节。在读取一个字节后，需要发送应答信号。
|
||
*/
|
||
static uint8_t _read_byte(i2c_t *handle, BOOL ack)
|
||
{
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
uint8_t i = 0, receive = 0;
|
||
i2c_gpio_group_t *gpios = &handle->gpios;
|
||
gpio_t *scl = gpios->scl;
|
||
gpio_t *sda = gpios->sda;
|
||
for (i = 0; i < 8; i++)
|
||
{
|
||
gpios->sda->set(*sda);
|
||
gpios->scl->set(*scl);
|
||
receive <<= 1;
|
||
delay(handle);
|
||
|
||
if (gpios->sda->read(*sda))
|
||
receive++;
|
||
|
||
gpios->scl->reset(*scl);
|
||
delay(handle);
|
||
}
|
||
|
||
if (TRUE == ack)
|
||
{
|
||
_ack(handle);
|
||
}
|
||
else
|
||
{
|
||
_nack(handle);
|
||
}
|
||
return receive;
|
||
}
|
||
/**
|
||
* @brief 发送一个字节的数据到I2C总线上
|
||
* @param {i2c_t} *handle I2C总线的句柄
|
||
* @param {uint8_t} data 要发送的字节数据
|
||
* @return {*} 无
|
||
* @note: 该函数用于在I2C总线上发送一个字节的数据。它首先定义了一个循环，用于遍历要发送的字节中的每一位。在循环中，首先检查当前位是否为1，如果是，则设置SDA为1，否则设置SDA为0。然后设置SCL为1，延时1ms。接着将数据右移一位，然后设置SCL为0，延时1ms。当位遍历完后，最后设置SDA为1，以确保正确的结束传输。
|
||
*/
|
||
static void _write_byte(i2c_t *handle, uint8_t data)
|
||
{
|
||
// 定义变量i
|
||
uint8_t i = 0;
|
||
// 断言参数handle不为空
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
// 定义变量gpios
|
||
i2c_gpio_group_t *gpios = &handle->gpios;
|
||
// 定义变量scl
|
||
gpio_t *scl = gpios->scl;
|
||
// 定义变量sda
|
||
gpio_t *sda = gpios->sda;
|
||
// 遍历每一位
|
||
for (i = 0; i < 8; i++)
|
||
{
|
||
// 如果data的最低位为1
|
||
if (data & 0x80)
|
||
{
|
||
// 设置sda的状态为1
|
||
gpios->sda->set(*sda);
|
||
}
|
||
// 否则，设置sda的状态为0
|
||
else
|
||
{
|
||
// 设置sda的状态为0
|
||
gpios->sda->reset(*sda);
|
||
}
|
||
|
||
// 设置scl的状态为1
|
||
gpios->scl->set(*scl);
|
||
// 延时1ms
|
||
delay(handle);
|
||
// 将data右移1位
|
||
data <<= 1;
|
||
// 设置scl的状态为0
|
||
gpios->scl->reset(*scl);
|
||
// 延时1ms
|
||
delay(handle);
|
||
|
||
// 如果i等于7
|
||
if (i == 7)
|
||
{
|
||
// 设置sda的状态为1
|
||
gpios->sda->set(*sda);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 发送一个字节的数据到I2C总线上
|
||
* @param {i2c_t} *handle I2C总线的句柄
|
||
* @param {uint16_t} data 要发送的字节数据
|
||
* @return {*} 无
|
||
* @note: 该函数用于在I2C总线上发送一个字节的数据。它首先定义了一个循环，用于遍历要发送的字节中的每一位。在循环中，首先检查当前位是否为1，如果是，则设置SDA为1，否则设置SDA为0。然后设置SCL为1，延时1ms。接着将数据右移一位，然后设置SCL为0，延时1ms。当位遍历完后，最后设置SDA为1，以确保正确的结束传输。
|
||
*/
|
||
static void _write_word(i2c_t *handle, uint16_t data)
|
||
{
|
||
// 循环写入2个字节
|
||
for (uint8_t i = 0; i < 2; i++)
|
||
{
|
||
// 将data的第i个字节写入i2c接口
|
||
_write_byte(handle, (uint8_t)(data >> (8 * i)));
|
||
// 等待ACK
|
||
_wait_ack(handle);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief I2C重置
|
||
* @param {I2C_TypeDef} *I2Cx
|
||
* @return {*}
|
||
* @note
|
||
*/
|
||
static void i2c_reset(I2C_TypeDef *I2Cx)
|
||
{
|
||
// Disable the I2C peripheral
|
||
LL_I2C_Disable(I2Cx);
|
||
|
||
// Re-enable the I2C peripheral
|
||
LL_I2C_Enable(I2Cx);
|
||
}
|
||
|
||
/**
|
||
* @brief 非阻塞模式下使用DMA将数据写入特定内存地址
|
||
* @param {i2c_t} *handle 指向一个i2c_t结构体，其中包含指定I2C的配置信息
|
||
* @param {uint16_t} dev_address 目标设备地址：在数据手册中，设备7位地址值需要向左移动以调用接口
|
||
* @param {uint16_t} mem_address 内部内存地址
|
||
* @param {uint16_t} mem_addsize 内部内存地址大小
|
||
* @param {uint8_t} *data 数据缓冲区的指针
|
||
* @param {uint16_t} size 要发送的数据量
|
||
* @return {*}
|
||
* @note
|
||
*/
|
||
static BOOL _write_mem_dma(i2c_t *handle, uint16_t mem_address, uint16_t mem_addsize, uint8_t *data, uint16_t size)
|
||
{
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
DBG_ASSERT(data != NULL __DBG_LINE);
|
||
if (LL_I2C_IsActiveFlag_BUSY(handle->i2c) == 1)
|
||
{
|
||
i2c_reset(handle->i2c); // xsh:重置I2C,修复一段时间后无法读写的问题
|
||
}
|
||
uint16_t count = 2000;
|
||
handle->txsize = 0;
|
||
handle->tx_dma_ok = FALSE;
|
||
for (uint8_t i = mem_addsize; i > 0; i--)
|
||
{
|
||
handle->txbuf[handle->txsize++] = (uint8_t)(mem_address >> (8 * (i - 1)));
|
||
}
|
||
osel_memcpy(&handle->txbuf[handle->txsize], data, size);
|
||
handle->txsize += size;
|
||
LL_DMA_SetDataLength(handle->dma, handle->dma_tx_channel, handle->txsize);
|
||
LL_DMA_EnableChannel(handle->dma, handle->dma_tx_channel);
|
||
|
||
LL_I2C_HandleTransfer(handle->i2c, handle->w_address, LL_I2C_ADDRSLAVE_7BIT, handle->txsize, LL_I2C_MODE_AUTOEND, LL_I2C_GENERATE_START_WRITE);
|
||
|
||
count = 2000;
|
||
while (!handle->tx_dma_ok)
|
||
{
|
||
if (count-- == 0)
|
||
{
|
||
handle->tx_dma_ok = TRUE;
|
||
return FALSE;
|
||
}
|
||
}
|
||
count = 2000;
|
||
while (!LL_I2C_IsActiveFlag_STOP(handle->i2c))
|
||
{
|
||
if (count-- == 0)
|
||
{
|
||
handle->tx_dma_ok = TRUE;
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
LL_DMA_DisableChannel(handle->dma, handle->dma_tx_channel);
|
||
LL_I2C_ClearFlag_STOP(handle->i2c);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
/**
|
||
* @brief 非阻塞模式下使用DMA从特定内存地址读取数据
|
||
* @param {i2c_t} *handle 指向一个i2c_t结构体，其中包含指定I2C的配置信息
|
||
* @param {uint16_t} dev_address 目标设备地址：在数据手册中，设备7位地址值需要向左移动以调用接口
|
||
* @param {uint16_t} mem_address 内部内存地址
|
||
* @param {uint16_t} mem_addsize 内部内存地址大小
|
||
* @param {uint8_t} *data 数据缓冲区的指针
|
||
* @param {uint16_t} size 要发送的数据量
|
||
* @return {*}
|
||
* @note
|
||
*/
|
||
static BOOL _read_mem_dma(i2c_t *handle, uint16_t mem_address, uint16_t mem_addsize, uint8_t *data, uint16_t size)
|
||
{
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
DBG_ASSERT(data != NULL __DBG_LINE);
|
||
if (LL_I2C_IsActiveFlag_BUSY(handle->i2c) == 1)
|
||
{
|
||
i2c_reset(handle->i2c); // xsh:重置I2C,修复一段时间后无法读写的问题
|
||
}
|
||
uint16_t count = 5000;
|
||
handle->txsize = 0;
|
||
handle->tx_dma_ok = FALSE;
|
||
handle->rx_dma_ok = FALSE;
|
||
|
||
for (uint8_t i = mem_addsize; i > 0; i--)
|
||
{
|
||
handle->txbuf[handle->txsize++] = (uint8_t)(mem_address >> (8 * (i - 1)));
|
||
}
|
||
|
||
LL_DMA_SetDataLength(handle->dma, handle->dma_tx_channel, handle->txsize);
|
||
LL_DMA_EnableChannel(handle->dma, handle->dma_tx_channel);
|
||
|
||
LL_I2C_HandleTransfer(handle->i2c, handle->w_address, LL_I2C_ADDRSLAVE_7BIT, handle->txsize, LL_I2C_MODE_SOFTEND, LL_I2C_GENERATE_START_WRITE);
|
||
count = 5000;
|
||
while (!handle->tx_dma_ok)
|
||
{
|
||
if (count-- == 0)
|
||
{
|
||
handle->tx_dma_ok = TRUE;
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
count = 5000;
|
||
while (LL_I2C_IsActiveFlag_TC(handle->i2c) != 1)
|
||
{
|
||
if (count-- == 0)
|
||
{
|
||
handle->tx_dma_ok = TRUE;
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
handle->tx_dma_ok = FALSE;
|
||
handle->rx_dma_ok = FALSE;
|
||
handle->rxsize = size;
|
||
osel_memset(handle->rxbuf, 0, handle->rxsize);
|
||
LL_DMA_DisableChannel(handle->dma, handle->dma_tx_channel);
|
||
LL_DMA_SetDataLength(handle->dma, handle->dma_rx_channel, handle->rxsize);
|
||
LL_DMA_EnableChannel(handle->dma, handle->dma_rx_channel);
|
||
LL_I2C_HandleTransfer(handle->i2c, handle->r_address, LL_I2C_ADDRSLAVE_7BIT, handle->rxsize, LL_I2C_MODE_AUTOEND, LL_I2C_GENERATE_RESTART_7BIT_READ);
|
||
|
||
count = 10000;
|
||
while (!LL_I2C_IsActiveFlag_STOP(handle->i2c))
|
||
{
|
||
if (count-- == 0)
|
||
{
|
||
handle->tx_dma_ok = TRUE;
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
LL_DMA_DisableChannel(handle->dma, handle->dma_rx_channel);
|
||
LL_I2C_ClearFlag_STOP(handle->i2c);
|
||
osel_memcpy(data, handle->rxbuf, handle->rxsize);
|
||
return TRUE;
|
||
}
|
||
/**
|
||
* @brief 创建一个I2C总线设备
|
||
* @param {i2c_gpio_group_t} gpios I2C总线的GPIO配置
|
||
* @param {uint16_t} delay_ticks I2C总线的延时参数
|
||
* @return {i2c_t *} 创建的I2C总线设备句柄
|
||
* @note: 该函数用于创建一个I2C总线设备。它首先创建一个i2c_t结构体，并将gpios和delay_ticks的内存地址复制到handle结构体中。然后，它为handle结构体定义了start、stop、wait_ack、read_byte、write_byte和write_word函数。最后，它返回handle结构体。
|
||
*/
|
||
i2c_t *i2c_create(i2c_gpio_group_t gpios, uint16_t delay_ticks)
|
||
{
|
||
// 创建一个i2c_t结构体
|
||
i2c_t *handle = (i2c_t *)osel_mem_alloc(sizeof(i2c_t));
|
||
// 将gpios的内存地址复制到handle结构体中
|
||
osel_memcpy((uint8_t *)&handle->gpios, (uint8_t *)&gpios, sizeof(i2c_gpio_group_t));
|
||
// 将delay_ticks的内存地址复制到handle结构体中
|
||
handle->delay_ticks = delay_ticks;
|
||
|
||
// 创建一个start函数
|
||
handle->interface.start = _start;
|
||
// 创建一个stop函数
|
||
handle->interface.stop = _stop;
|
||
// 创建一个wait_ack函数
|
||
handle->interface.wait_ack = _wait_ack;
|
||
// 创建一个read_byte函数
|
||
handle->interface.read_byte = _read_byte;
|
||
// 创建一个write_byte函数
|
||
handle->interface.write_byte = _write_byte;
|
||
// 创建一个write_word函数
|
||
handle->interface.write_word = _write_word;
|
||
|
||
// 返回handle结构体
|
||
return handle;
|
||
}
|
||
|
||
/**
|
||
* @brief 创建一个I2C总线设备 DMA
|
||
* @param {I2C_TypeDef} *i2c
|
||
* @param {DMA_TypeDef} *dma
|
||
* @param {uint16_t} rxsize
|
||
* @param {uint32_t} dma_rx_channel
|
||
* @param {uint16_t} txsize
|
||
* @param {uint32_t} dma_tx_channel
|
||
* @return {*}
|
||
* @note
|
||
*/
|
||
i2c_t *i2c_create_dma(I2C_TypeDef *i2c, DMA_TypeDef *dma, uint16_t rxsize, uint32_t dma_rx_channel,
|
||
i2cs_dma_callback *dma_rx_cb, uint16_t txsize, uint32_t dma_tx_channel, i2cs_dma_callback *dma_tx_cb)
|
||
{
|
||
i2c_t *handle = (i2c_t *)osel_mem_alloc(sizeof(i2c_t));
|
||
handle->i2c = i2c;
|
||
handle->dma = dma;
|
||
handle->dma_rx_channel = dma_rx_channel;
|
||
handle->dma_tx_channel = dma_tx_channel;
|
||
handle->rxbuf = (uint8_t *)osel_mem_alloc(rxsize);
|
||
handle->txbuf = (uint8_t *)osel_mem_alloc(txsize);
|
||
handle->rxsize = rxsize;
|
||
handle->txsize = txsize;
|
||
handle->tx_dma_ok = TRUE;
|
||
handle->interface.write_mem_dma = _write_mem_dma;
|
||
handle->interface.read_mem_dma = _read_mem_dma;
|
||
if (dma_rx_cb != NULL)
|
||
{
|
||
handle->dma_rx_cb = dma_rx_cb;
|
||
}
|
||
|
||
if (dma_tx_cb != NULL)
|
||
{
|
||
handle->dma_tx_cb = dma_tx_cb;
|
||
}
|
||
|
||
LL_DMA_DisableChannel(dma, dma_tx_channel);
|
||
LL_DMA_DisableChannel(dma, dma_rx_channel);
|
||
|
||
// TX
|
||
uint8_t *pTransmitBuffer = handle->txbuf;
|
||
LL_DMA_ConfigTransfer(dma, dma_tx_channel, LL_DMA_DIRECTION_MEMORY_TO_PERIPH | LL_DMA_PRIORITY_HIGH | LL_DMA_MODE_NORMAL | LL_DMA_PERIPH_NOINCREMENT | LL_DMA_MEMORY_INCREMENT | LL_DMA_PDATAALIGN_BYTE | LL_DMA_MDATAALIGN_BYTE);
|
||
LL_DMA_ConfigAddresses(dma, dma_tx_channel, (uint32_t)pTransmitBuffer, (uint32_t)LL_I2C_DMA_GetRegAddr(i2c, LL_I2C_DMA_REG_DATA_TRANSMIT), LL_DMA_GetDataTransferDirection(dma, dma_tx_channel));
|
||
LL_DMA_SetPeriphRequest(dma, dma_tx_channel, LL_DMA_REQUEST_3);
|
||
|
||
// RX
|
||
uint8_t *pReceiveBuffer = handle->rxbuf;
|
||
LL_DMA_ConfigTransfer(dma, dma_rx_channel, LL_DMA_DIRECTION_PERIPH_TO_MEMORY | LL_DMA_PRIORITY_HIGH | LL_DMA_MODE_NORMAL | LL_DMA_PERIPH_NOINCREMENT | LL_DMA_MEMORY_INCREMENT | LL_DMA_PDATAALIGN_BYTE | LL_DMA_MDATAALIGN_BYTE);
|
||
LL_DMA_ConfigAddresses(dma, dma_rx_channel, (uint32_t)LL_I2C_DMA_GetRegAddr(i2c, LL_I2C_DMA_REG_DATA_RECEIVE), (uint32_t)pReceiveBuffer, LL_DMA_GetDataTransferDirection(dma, dma_rx_channel));
|
||
LL_DMA_SetPeriphRequest(dma, dma_rx_channel, LL_DMA_REQUEST_3);
|
||
|
||
LL_DMA_EnableIT_TC(dma, dma_tx_channel);
|
||
LL_DMA_EnableIT_TE(dma, dma_tx_channel);
|
||
LL_DMA_EnableIT_TC(dma, dma_rx_channel);
|
||
LL_DMA_EnableIT_TE(dma, dma_rx_channel);
|
||
|
||
LL_I2C_EnableDMAReq_TX(i2c);
|
||
LL_I2C_EnableDMAReq_RX(i2c);
|
||
LL_I2C_Enable(i2c);
|
||
|
||
return handle;
|
||
}
|
||
|
||
/**
|
||
* @brief 设置I2C器件地址
|
||
* @param {i2c_t} *handle
|
||
* @param {uint8_t} w_address 写地址
|
||
* @param {uint8_t} r_address 读地址
|
||
* @return {*}
|
||
* @note
|
||
*/
|
||
void i2c_dma_set_address(i2c_t *handle, uint8_t w_address, uint8_t r_address)
|
||
{
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
handle->w_address = w_address;
|
||
handle->r_address = r_address;
|
||
}
|
||
|
||
/**
|
||
* @brief 释放I2C总线设备
|
||
* @param {i2c_t} *handle 需要释放的I2C总线设备句柄
|
||
* @return {*} 无
|
||
* @note: 该函数用于释放一个I2C总线设备。它首先检查handle是否为空，如果不为空，则释放所有的GPIO。最后，释放handle的内存。
|
||
*/
|
||
void i2c_free(i2c_t *handle)
|
||
{
|
||
// 如果handle不为空，则释放所有的gpio
|
||
if (NULL != handle)
|
||
{
|
||
gpio_free(handle->gpios.scl);
|
||
gpio_free(handle->gpios.sda);
|
||
osel_mem_free(handle);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief I2C DMA TX回调函数
|
||
* @param {i2c_t} handle
|
||
* @return {*}
|
||
* @note
|
||
*/
|
||
void i2c_dma_callback(i2c_t *handle)
|
||
{
|
||
// 检查输入参数是否为空
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
// 清除传输完成标志位
|
||
if (handle->dma_tx_cb != NULL)
|
||
{
|
||
handle->dma_tx_cb(handle);
|
||
}
|
||
if (handle->dma_rx_cb != NULL)
|
||
{
|
||
handle->dma_rx_cb(handle);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief I2C 中断回调函数
|
||
* @param {i2c_t} *handle
|
||
* @return {*}
|
||
* @note
|
||
*/
|
||
void i2c_ev_callback(i2c_t *handle)
|
||
{
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
if (LL_I2C_IsActiveFlag_ADDR(handle->i2c))
|
||
{
|
||
/* Verify the Address Match with the OWN Slave address */
|
||
if (LL_I2C_GetAddressMatchCode(handle->i2c) == handle->w_address || LL_I2C_GetAddressMatchCode(handle->i2c) == handle->r_address)
|
||
{
|
||
/* Verify the transfer direction, a write direction, Slave enters receiver mode */
|
||
if (LL_I2C_GetTransferDirection(handle->i2c) == LL_I2C_DIRECTION_WRITE)
|
||
{
|
||
/* Clear ADDR flag value in ISR register */
|
||
LL_I2C_ClearFlag_ADDR(handle->i2c);
|
||
|
||
/* Enable Receive Interrupt */
|
||
LL_I2C_EnableIT_RX(handle->i2c);
|
||
}
|
||
else if (LL_I2C_GetTransferDirection(handle->i2c) == LL_I2C_DIRECTION_READ)
|
||
{
|
||
/* Clear ADDR flag value in ISR register */
|
||
LL_I2C_ClearFlag_ADDR(handle->i2c);
|
||
|
||
/* Enable Transmit Interrupt */
|
||
LL_I2C_EnableIT_TX(handle->i2c);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* Clear ADDR flag value in ISR register */
|
||
LL_I2C_ClearFlag_ADDR(handle->i2c);
|
||
|
||
/* Call Error function */
|
||
DBG_ASSERT(FALSE __DBG_LINE);
|
||
}
|
||
}
|
||
/* Check NACK flag value in ISR register */
|
||
else if (LL_I2C_IsActiveFlag_NACK(handle->i2c))
|
||
{
|
||
/* End of Transfer */
|
||
LL_I2C_ClearFlag_NACK(handle->i2c);
|
||
}
|
||
/* Check RXNE flag value in ISR register */
|
||
else if (LL_I2C_IsActiveFlag_RXNE(handle->i2c))
|
||
{
|
||
/* Call function Slave Reception Callback */
|
||
}
|
||
/* Check TXIS flag value in ISR register */
|
||
else if (LL_I2C_IsActiveFlag_TXIS(handle->i2c))
|
||
{
|
||
/* Call function Slave Ready to Transmit Callback */
|
||
}
|
||
/* Check STOP flag value in ISR register */
|
||
else if (LL_I2C_IsActiveFlag_STOP(handle->i2c))
|
||
{
|
||
/* End of Transfer */
|
||
LL_I2C_ClearFlag_STOP(handle->i2c);
|
||
|
||
/* Check TXE flag value in ISR register */
|
||
if (!LL_I2C_IsActiveFlag_TXE(handle->i2c))
|
||
{
|
||
/* Flush TX buffer */
|
||
LL_I2C_ClearFlag_TXE(handle->i2c);
|
||
}
|
||
|
||
/* Call function Slave Complete Callback */
|
||
}
|
||
/* Check TXE flag value in ISR register */
|
||
else if (!LL_I2C_IsActiveFlag_TXE(handle->i2c))
|
||
{
|
||
/* Do nothing */
|
||
/* This Flag will be set by hardware when the TXDR register is empty */
|
||
/* If needed, use LL_I2C_ClearFlag_TXE() interface to flush the TXDR register */
|
||
}
|
||
else
|
||
{
|
||
/* Call Error function */
|
||
DBG_ASSERT(FALSE __DBG_LINE);
|
||
}
|
||
}
|
||
|
||
/*下面是内部实现方法*/
|
||
|
||
/**
|
||
* @brief 此方法是一个简单的延迟函数，它使用循环来执行指定数量的NOP（无操作）指令。这个延迟函数的目的是在程序的执行中引入延迟，这在需要精确定时的某些应用中很有用。延迟时间由输入参数“count”的值决定，该参数指定要执行的NOP指令的数量。延迟时间通常以微秒或毫秒为单位测量，具体取决于使用延迟的环境。
|
||
* @param {uint16_t} count NOP指令的数量
|
||
* @return {*}
|
||
*/
|
||
static inline void delay(i2c_t *handle)
|
||
{
|
||
// 断言参数handle不为空
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
// 定义循环计数变量count
|
||
uint16_t count = 0;
|
||
// 设置循环计数变量count的值为handle->delay_ticks
|
||
count = handle->delay_ticks;
|
||
// 循环计数变量count的值，直到count的值为0
|
||
while (count--)
|
||
{
|
||
// 每次循环调用__NOP()函数
|
||
__NOP();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 发送ACK信号
|
||
* @param {i2c_t} *handle I2C总线的句柄
|
||
* @return {*} 无
|
||
* @note: 该函数用于在I2C总线上发送ACK信号。它首先断言handle不为空，然后获取gpios和scl、sda的指针。接着重置sda，延时1ms，设置scl为1，延时1ms，重置scl，确保正确的结束传输。
|
||
*/
|
||
static inline void _ack(i2c_t *handle)
|
||
{
|
||
// 断言handle不为空
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
// 获取gpios指针
|
||
i2c_gpio_group_t *gpios = &handle->gpios;
|
||
// 获取scl指针
|
||
gpio_t *scl = gpios->scl;
|
||
// 获取sda指针
|
||
gpio_t *sda = gpios->sda;
|
||
|
||
// 重置sda
|
||
gpios->sda->reset(*sda);
|
||
// 延时
|
||
delay(handle);
|
||
// 设置scl
|
||
gpios->scl->set(*scl);
|
||
// 延时
|
||
delay(handle);
|
||
// 重置scl
|
||
gpios->scl->reset(*scl);
|
||
}
|
||
|
||
/**
|
||
* @brief 发送NACK信号
|
||
* @param {i2c_t} *handle I2C总线的句柄
|
||
* @return {*} 无
|
||
* @note: 该函数用于在I2C总线上发送NACK信号。它首先断言handle不为空，然后获取gpios和scl、sda的指针。接着设置sda为1，延时1ms，设置scl为1，延时1ms，重置scl，确保正确的结束传输。
|
||
*/
|
||
static inline void _nack(i2c_t *handle)
|
||
{
|
||
DBG_ASSERT(handle != NULL __DBG_LINE);
|
||
// 获取gpios指针
|
||
i2c_gpio_group_t *gpios = &handle->gpios;
|
||
// 获取scl指针
|
||
gpio_t *scl = gpios->scl;
|
||
// 获取sda指针
|
||
gpio_t *sda = gpios->sda;
|
||
|
||
// 设置sda引脚
|
||
gpios->sda->set(*sda);
|
||
// 等待延时
|
||
delay(handle);
|
||
// 设置scl引脚
|
||
gpios->scl->set(*scl);
|
||
// 等待延时
|
||
delay(handle);
|
||
// 重置scl引脚
|
||
gpios->scl->reset(*scl);
|
||
}
|