STM32软件模拟IIC驱动的设计

最新推荐文章于 2024-05-13 12:01:26 发布
最新推荐文章于 2024-05-13 12:01:26 发布
阅读量2k 收藏 22
点赞数 2
分类专栏： STM32 文章标签： STM32 IIC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liujiaying_7/article/details/94310584
版权

STM32软件模拟IIC驱动的设计

概述

STM32的硬件IIC存在一些问题，由于IIC时序较为简单，多数情况下考虑使用GPIO模拟来实现IIC设备的驱动程序。这里给出一份在FreeRTOS操作系统下的使用软件模拟IIC的驱动的例程，如果在裸机环境下，还需要做点小改动。这里需要使用到一些知识，这些知识不在本片文章中展开：

1.IIC协议；
2.FreeRTOS互斥锁;

定义一个IIC设备

在IIC协议中，可以在同一个总线上挂载多个IIC设备，这些设备通过不同的IIC设备地址进行区分。因此编写驱动的时候，需要设计一个IIC设备对象，该对象包含了设备的地址以及使用的IIC总线。

IIC总线的设计

熟悉51单片机的同学，在设计软件模拟IIC驱动的时候可能就直接将IIC驱动写死了。如果一个系统含有多条IIC总线，难道就要每条总线对实现一个对应的IIC驱动吗？这样就会导致代码膨胀、冗余，因为除了总线不一样，其他代码都是一样的。为了解决这个问题，就需要将总线做通用处理，即定义一个IIC总线。
在STM32中，每个GPIO引脚都是可以单独配置的，可以使用结构体来定义一个引脚：
结构体single_gpio_pin_t表示一个引脚：

typedef struct {
    GPIO_TypeDef *gpio;
    unsigned int  pin;
} single_gpio_pin_t;

在IIC总线中有两条信号线，分别为SCL和SDA，同样的可以使用两个引脚来定义IIC总线：
结构体i2c_bus_t：

/* 定义IIC总线 */
typedef struct {
    single_gpio_pin_t scl;      /* SCL引脚 */
    single_gpio_pin_t sda;      /* SDA引脚 */
    SemaphoreHandle_t mutex;    /* FreeRTOS互斥锁: 多线程环境下, 避免多个线程同时使用总线以至于IIC传输出现错误, 裸机环境下可以去掉该锁 */
} i2c_bus_t;

IIC设备的定义

在定义好总线之后，接下来就可以定义一个IIC设备的结构体了。IIC总线的设备拥有各自的地址，这些地址都必须不同，在协议中并不直接使用IIC的地址，通常需要将地址向左偏移一位后再进行操作，因此传递给IIC设备结构体的地址就是IIC设备地址向左偏移一位了。
IIC设备的结构体：

/* 定义IIC设备 */
typedef struct {
    const i2c_bus_t *bus;       /* IIC设备使用的总线 */
    uint8_t addr;               /* IIC设备的地址向左偏移一位 */
} i2c_device_t;

从该结构体可以看到，结构体成员bus被设计为了一个指针，指向一个IIC总线，可以实现多个IIC设备使用同一个IIC总线。

代码的实现

以下代码的实现参考IIC协议的时序图。
gpio.h：GPIO通用操作

#ifndef __GPIO_CONFIG_H_
#define __GPIO_CONFIG_H_

#include "stm32l4xx_hal.h"
#include "stm32l4xx_hal_gpio.h"

typedef struct {
    GPIO_TypeDef *gpio;
    unsigned int  pin;
} single_gpio_pin_t;

/* 使能GPIO的时钟 */
__STATIC_FORCEINLINE void gpio_clk_enable(GPIO_TypeDef *__RESTRICT GPIO)
{
    RCC->AHB2ENR |= 1 << (((uint32_t)GPIO - GPIOA_BASE) >> 10);
}

__STATIC_FORCEINLINE void gpio_set_pin(GPIO_TypeDef *__RESTRICT GPIO, const uint16_t pin)
{
    GPIO->BSRR = (uint32_t)pin;
}

__STATIC_FORCEINLINE void gpio_reset_pin(GPIO_TypeDef *__RESTRICT GPIO, const uint16_t pin)
{
    GPIO->BRR = (uint32_t)pin;
}

extern void gpio_switch_io_mode(GPIO_TypeDef *__RESTRICT GPIO, const uint16_t pin,
    const uint8_t mode);

#endif

gpio.c

#include "gpio.h"

void gpio_switch_io_mode(GPIO_TypeDef *__RESTRICT GPIO,
    const uint16_t pin, const uint8_t mode)
{
    uint8_t mode_pos;

    mode_pos = POSITION_VAL(pin) << 1;
    GPIO->MODER &= (uint32_t)~(3UL << mode_pos);
    GPIO->MODER |= (uint32_t)(mode << mode_pos);
}

iic.h

#ifndef __IIC_H_
#define __IIC_H_

#include "gpio.h"
#include <FreeRTOS.h>
#include <task.h>
#include <semphr.h>

#define I2C_STATUS_OK       0
#define I2C_STATUS_FAILED   1

/* 定义IIC总线 */
typedef struct {
    single_gpio_pin_t scl;      /* SCL引脚 */
    single_gpio_pin_t sda;      /* SDA引脚 */
    SemaphoreHandle_t mutex;    /* FreeRTOS互斥锁: 多线程环境下, 避免多个线程同时使用总线以至于IIC传输出现错误, 裸机环境下可以去掉该锁 */
} i2c_bus_t;

/* 定义IIC设备 */
typedef struct {
    const i2c_bus_t *bus;       /* IIC设备使用的总线 */
    uint8_t addr;               /* IIC设备的地址向左偏移一位 */
} i2c_device_t;

/*
 * @brief: i2c_init(内联函数)
 *   初始化IIC设备, 设置IIC设备使用的总线和IIC设备地址
 * @param:
 *   i2c_dev: IIC设备
 *   bus: IIC设备使用的总线
 *   addr: IIC设备的地址向左偏移一位
 * @returns: void
 */
__STATIC_FORCEINLINE void i2c_init(i2c_device_t *__RESTRICT i2c_dev, const i2c_bus_t *__RESTRICT bus,
    const uint8_t addr)
{
    i2c_dev->bus = bus;
    i2c_dev->addr = addr;       /* addr为设备i2c_dev的地址向左偏移一位 */
}

/*
 * @brief: i2c_bus_init
 *   初始化IIC总线
 * @param:
 *   bus: IIC总线
 * @returns: void 
 */
extern void i2c_bus_init(i2c_bus_t *__RESTRICT bus);

/*
 * @brief: i2c_write_byte
 *   向IIC设备写入一个字节
 * @param:
 *   i2c_dev: IIC设备
 *   reg: IIC设备的寄存器
 *   data: 一个字节的数据
 * @returns: uint8_t
 *   返回一个状态：写入成功返回I2C_STATUS_OK, 失败返回I2C_STATUS_FAILED
 */
extern uint8_t i2c_write_byte(const i2c_device_t *__RESTRICT i2c_dev, const uint8_t reg, const uint8_t data);

/*
 * @brief: i2c_read_byte
 *    从IIC设备读出一个字节
 * @param:
 *   i2c_dev: IIC设备
 *   reg: IIC设备的寄存器
 * @returns: uint8_t
 *   返回读取到的一个字节
 */
extern uint8_t i2c_read_byte(const i2c_device_t *__RESTRICT i2c_dev, const uint8_t reg);

/*
 * @brief: i2c_write_bytes
 *   向IIC设备写入多个字节
 * @param:
 *   i2c_dev: IIC设备
 *   buf: 数据源
 *   len: 写入的数据长度, 单位字节
 *   reg: 写入的寄存器
 * @returns: uint8_t
 *   返回一个状态：写入成功返回I2C_STATUS_OK, 失败返回I2C_STATUS_FAILED
 */
extern uint8_t i2c_write_bytes(const i2c_device_t *__RESTRICT i2c_dev, const uint8_t *__RESTRICT buf,
    const uint8_t len, const uint8_t reg);

/*
 * @brief: i2c_read_bytes
 *   从IIC设备读出多个字节
 * @param:
 *   i2c_dev: IIC设备
 *   buf: 接受数据的缓冲区
 *   len: 读取的数据长度, 单位字节
 *   reg: 读取的寄存器
 * @returns:
 *   返回一个状态：读取成功返回I2C_STATUS_OK, 失败返回I2C_STATUS_FAILED
 */
extern uint8_t i2c_read_bytes(const i2c_device_t *__RESTRICT i2c_dev, uint8_t *__RESTRICT buf,
    const uint8_t len, const uint8_t reg);

/*
 * @brief: i2c_only_read_bytes
 *   从IIC设备读出多个字节, 一般来说这个函数要和i2c_write_byte配合使用
 * @param:
 *   i2c_dev: IIC设备
 *   buf: 接受数据的缓冲区
 *   len: 读取的数据长度, 单位字节
 * @returns:
 *   返回一个状态：读取成功返回I2C_STATUS_OK, 失败返回I2C_STATUS_FAILED
 */
extern uint8_t i2c_only_read_bytes(const i2c_device_t *__RESTRICT i2c_dev, uint8_t *__RESTRICT buf,
    const uint8_t len);

#endif /* End of __IIC_H_ */

iic.c

#include "sys.h"    /* 只提供delay_us */
#include "iic.h"

/* 互斥锁操作 */
#define I2C_MUTEX_LOCK(dev) \
    xSemaphoreTake((dev)->bus->mutex, portMAX_DELAY)
#define I2C_MUTEX_UNLOCK(dev) \
    xSemaphoreGive((dev)->bus->mutex)
/* 如果不需要互斥锁, 将以上两个宏的定义置为空 */
//#define I2C_MUTEX_LOCK(dev)
//#define I2C_MUTEX_UNLOCK(dev)

#define I2C_READ_SDA(dev) \
    HAL_GPIO_ReadPin((dev)->bus->sda.gpio, (dev)->bus->sda.pin)
#define I2C_WRITE_SDA(dev, bit) \
    HAL_GPIO_WritePin((dev)->bus->sda.gpio, (dev)->bus->sda.pin, (bit))
#define I2C_SET_SDA(dev) \
    gpio_set_pin((dev)->bus->sda.gpio, (dev)->bus->sda.pin)
#define I2C_RESET_SDA(dev) \
    gpio_reset_pin((dev)->bus->sda.gpio, (dev)->bus->sda.pin)
#define I2C_SET_SCL(dev) \
    gpio_set_pin((dev)->bus->scl.gpio, (dev)->bus->scl.pin)
#define I2C_RESET_SCL(dev) \
    gpio_reset_pin((dev)->bus->scl.gpio, (dev)->bus->scl.pin)

/* 切换SDA引脚的模式为输出 */
#define I2C_SDA_MODE_OUT(dev) \
    gpio_switch_io_mode((dev)->bus->sda.gpio, (dev)->bus->sda.pin, GPIO_MODE_OUTPUT_PP)
/* 切换SDA引脚的模式为输入 */
#define I2C_SDA_MODE_IN(dev) \
    gpio_switch_io_mode((dev)->bus->sda.gpio, (dev)->bus->sda.pin, GPIO_MODE_INPUT)

/* IIC设备的ACK信号的电平 */
#define I2C_SIGNAL_NOACK    GPIO_PIN_SET        /* 无ACK应答 */
#define I2C_SIGNAL_ACK      GPIO_PIN_RESET      /* 有ACK应答 */

void i2c_bus_init(i2c_bus_t *bus)
{
    GPIO_InitTypeDef GPIO_Initure;

    GPIO_Initure.Pull = GPIO_PULLUP;
    GPIO_Initure.Speed= GPIO_SPEED_FAST;
    GPIO_Initure.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_Initure.Alternate = 0;
    gpio_clk_enable(bus->scl.gpio);
    gpio_clk_enable(bus->sda.gpio);
    GPIO_Initure.Pin  = bus->scl.pin;
    HAL_GPIO_Init(bus->scl.gpio, &GPIO_Initure);
    GPIO_Initure.Pin = bus->sda.pin;
    HAL_GPIO_Init(bus->sda.gpio, &GPIO_Initure);
    gpio_set_pin(bus->scl.gpio, bus->scl.pin);
    gpio_set_pin(bus->sda.gpio, bus->sda.pin);

    /* 如果不需要互斥锁, 则删除该语句 */
    bus->mutex = xSemaphoreCreateMutex();
}

/**
 * @brief: i2c_start
 *  向IIC总线发送开始信号
 * @param:
 *  i2c_dev: IIC设备
 * @returns: void
 */
static void i2c_start(const i2c_device_t *__RESTRICT i2c_dev)
{
    I2C_SDA_MODE_OUT(i2c_dev);
    I2C_SET_SDA(i2c_dev);
    I2C_SET_SCL(i2c_dev);
    delay_us(4);
    I2C_RESET_SDA(i2c_dev);
	delay_us(4);
    I2C_RESET_SCL(i2c_dev);
}

/**
 * @brief: i2c_stop
 *  向IIC总线发送停止信号
 * @param:
 *  i2c_dev: IIC设备
 * @returns: void
 */
static void i2c_stop(const i2c_device_t *__RESTRICT i2c_dev)
{
    I2C_SDA_MODE_OUT(i2c_dev);
	I2C_RESET_SDA(i2c_dev);
    I2C_SET_SCL(i2c_dev);
    delay_us(4);
	I2C_SET_SDA(i2c_dev);
	delay_us(4);
	I2C_RESET_SCL(i2c_dev);
}

/**
 * @brief: i2c_wait_ack
 *  等待IIC设备的应答
 * @param:
 *  i2c_dev: IIC设备
 * @returns: uint8_t
 *  等待应答信号成功返回I2C_STATUS_OK, 否则返回I2C_STATUS_FAILED
 */
static uint8_t i2c_wait_ack(const i2c_device_t *__RESTRICT i2c_dev)
{
    uint8_t ucErrTime = 0;

    I2C_SET_SDA(i2c_dev);
    I2C_SDA_MODE_IN(i2c_dev);
    delay_us(2);
    I2C_SET_SCL(i2c_dev);
    delay_us(2);
    while (I2C_READ_SDA(i2c_dev)) {
        ucErrTime++;
        if (ucErrTime > 250) {
            i2c_stop(i2c_dev);
            return I2C_STATUS_FAILED;
        }
    }
    I2C_RESET_SCL(i2c_dev);

    return I2C_STATUS_OK;
}

/**
 * @brief: i2c_send_ack
 *  向IIC设备发送应答信号
 * @param:
 *  i2c_dev: IIC设备
 *  ack: 无需ACK应答: I2C_SIGNAL_NOACK, 需要ACK应答: I2C_SIGNAL_ACK
 * @returns: void
 */
static void i2c_send_ack(const i2c_device_t *__RESTRICT i2c_dev, const GPIO_PinState ack)
{
    I2C_RESET_SCL(i2c_dev);
    I2C_SDA_MODE_OUT(i2c_dev);
    I2C_WRITE_SDA(i2c_dev, ack);
    delay_us(2);
    I2C_SET_SCL(i2c_dev);
    delay_us(2);
    I2C_RESET_SCL(i2c_dev);
}

/**
 * @brief: i2c_base_send_byte
 *  底层接口, 循环右移向IIC设备写入一个字节
 * @param:
 *  i2c_dev: IIC设备
 *  data: 需要写入的数据
 * @returns: void
 */
static void i2c_base_send_byte(const i2c_device_t *__RESTRICT i2c_dev, uint8_t data)
{
    I2C_SDA_MODE_OUT(i2c_dev);
    I2C_RESET_SCL(i2c_dev);
    for(uint8_t t = 0; t < 8; t++) {
        I2C_WRITE_SDA(i2c_dev, data >> 7 ? GPIO_PIN_SET : GPIO_PIN_RESET);
        data <<= 1;
        I2C_SET_SCL(i2c_dev);
        delay_us(2);
        I2C_RESET_SCL(i2c_dev);
        delay_us(2);
    }
}

/**
 * @brief: i2c_base_read_byte
 *  底层接口, 循环左移从IIC设备读取一个字节
 * @param:
 *  i2c_dev: IIC设备
 *  ack: 读取操作是否需要ack信号应答, 无需ACK应答: I2C_SIGNAL_NOACK, 需要ACK应答: I2C_SIGNAL_ACK
 * @returns: uint8_t
 *  返回读取到的一个字节
 */
static uint8_t i2c_base_read_byte(const i2c_device_t *__RESTRICT i2c_dev, const GPIO_PinState ack)
{
    uint8_t i, receive = 0;

    I2C_SDA_MODE_IN(i2c_dev);
    for(i = 0; i < 8; i++) {
        I2C_RESET_SCL(i2c_dev);
        delay_us(2);
        I2C_SET_SCL(i2c_dev);
        receive <<= 1;
        if(I2C_READ_SDA(i2c_dev))
            receive++;
        delay_us(2);
    }
    i2c_send_ack(i2c_dev, ack);

    return receive;
}

uint8_t i2c_write_byte(const i2c_device_t *__RESTRICT i2c_dev, const uint8_t reg, const uint8_t data)
{
    uint8_t ret;

    I2C_MUTEX_LOCK(i2c_dev);
    ret = I2C_STATUS_OK;
    i2c_start(i2c_dev);
    i2c_base_send_byte(i2c_dev, i2c_dev->addr);
    if (i2c_wait_ack(i2c_dev)) {
        ret = I2C_STATUS_FAILED;
        goto stop_i2c_write_byte;
    }
    i2c_base_send_byte(i2c_dev, reg);
    i2c_wait_ack(i2c_dev);
    i2c_base_send_byte(i2c_dev, data);
    if (i2c_wait_ack(i2c_dev))
        ret = I2C_STATUS_FAILED;

stop_i2c_write_byte:
    i2c_stop(i2c_dev);
    I2C_MUTEX_UNLOCK(i2c_dev);
    return ret;
}

uint8_t i2c_read_byte(const i2c_device_t *__RESTRICT i2c_dev, const uint8_t reg)
{
    uint8_t data;

    I2C_MUTEX_LOCK(i2c_dev);
    i2c_start(i2c_dev);
    i2c_base_send_byte(i2c_dev, i2c_dev->addr);
    i2c_wait_ack(i2c_dev);
    i2c_base_send_byte(i2c_dev, reg);
    i2c_wait_ack(i2c_dev);
    i2c_start(i2c_dev);
    i2c_base_send_byte(i2c_dev, i2c_dev->addr | 0x01);
    i2c_wait_ack(i2c_dev);
    data = i2c_base_read_byte(i2c_dev, I2C_SIGNAL_NOACK);
    i2c_stop(i2c_dev);
    I2C_MUTEX_UNLOCK(i2c_dev);

    return data;
}

uint8_t i2c_read_bytes(const i2c_device_t *__RESTRICT i2c_dev, uint8_t *__RESTRICT buf,
    const uint8_t len, const uint8_t reg)
{
    uint8_t i, ret;
    GPIO_PinState ack_signal;

    I2C_MUTEX_LOCK(i2c_dev);
    ret = I2C_STATUS_OK;
    i2c_start(i2c_dev);
    i2c_base_send_byte(i2c_dev, i2c_dev->addr);
    if (i2c_wait_ack(i2c_dev)) {
       ret = I2C_STATUS_FAILED;
       goto stop_i2c_read_bytes;
    }
    i2c_base_send_byte(i2c_dev, reg);
    i2c_wait_ack(i2c_dev);
    i2c_start(i2c_dev);
    i2c_base_send_byte(i2c_dev, i2c_dev->addr | 1);
    i2c_wait_ack(i2c_dev);
    ack_signal = I2C_SIGNAL_ACK;
    for (i = 0; i < len; ++i) {
        if (i == len - 1)
            ack_signal = I2C_SIGNAL_NOACK;
        buf[i] = i2c_base_read_byte(i2c_dev, ack_signal);
    }

stop_i2c_read_bytes:
    i2c_stop(i2c_dev);
    I2C_MUTEX_UNLOCK(i2c_dev);
    return ret;
}

uint8_t i2c_write_bytes(const i2c_device_t *__RESTRICT i2c_dev, const uint8_t *__RESTRICT buf,
    const uint8_t len, const uint8_t reg)
{
    uint8_t i, ret;

    I2C_MUTEX_LOCK(i2c_dev);
    ret = I2C_STATUS_OK;
    i2c_start(i2c_dev);
    i2c_base_send_byte(i2c_dev, i2c_dev->addr);
    if (i2c_wait_ack(i2c_dev)) {
        ret = I2C_STATUS_FAILED;
        goto stop_i2c_write_bytes;
    }
    i2c_base_send_byte(i2c_dev, reg);
    i2c_wait_ack(i2c_dev);
    for (i = 0; i < len; ++i) {
        i2c_base_send_byte(i2c_dev, buf[i]);
        if (i2c_wait_ack(i2c_dev)) {
            ret = I2C_STATUS_FAILED;
            goto stop_i2c_write_bytes;
        }
    }

stop_i2c_write_bytes:
    i2c_stop(i2c_dev);
    I2C_MUTEX_UNLOCK(i2c_dev);
    return ret;
}

uint8_t i2c_only_read_bytes(const i2c_device_t *__RESTRICT i2c_dev, uint8_t *__RESTRICT buf,
    const uint8_t len)
{
    uint8_t ret, i;
    GPIO_PinState ack_signal;

    I2C_MUTEX_LOCK(i2c_dev);
    ret = I2C_STATUS_OK;
    i2c_start(i2c_dev);
    i2c_base_send_byte(i2c_dev, i2c_dev->addr | 1);
    if (i2c_wait_ack(i2c_dev)) {
        ret = I2C_STATUS_FAILED;
        goto stop_i2c_only_read_bytes;
    }
    ack_signal = I2C_SIGNAL_ACK;
    for (i = 0; i < len; i++) {
        if (i == len - 1)
            ack_signal = I2C_SIGNAL_NOACK;
        buf[i] = i2c_base_read_byte(i2c_dev, ack_signal);
    }

stop_i2c_only_read_bytes:
    i2c_stop(i2c_dev);
    I2C_MUTEX_UNLOCK(i2c_dev);
    return ret;
}

使用示例

1.IIC设备定义

static i2c_bus_t i2c_device_bus[] = {
    [0] = {.sda.gpio = GPIOC, .sda.pin = GPIO_PIN_1,
           .scl.gpio = GPIOC, .scl.pin = GPIO_PIN_0},
    [1] = {.sda.gpio = GPIOC, .sda.pin = GPIO_PIN_1,
           .scl.gpio = GPIOD, .scl.pin = GPIO_PIN_6},
    [2] = {.sda.gpio = GPIOA, .sda.pin = GPIO_PIN_8,
           .scl.gpio = GPIOC, .scl.pin = GPIO_PIN_7},
};
static i2c_device_t ap3216c_i2c_dev = {.bus = &i2c_device_bus[0], .addr = AP3216C_I2C_ADDR};
static i2c_device_t icm20608_i2c_dev= {.bus = &i2c_device_bus[0], .addr = ICM20608_I2C_ADDR};
static i2c_device_t ath10_i2c_dev   = {.bus = &i2c_device_bus[1], .addr = AHT10_IIC_ADDR};
static i2c_device_t mpu9250_i2c_dev = {.bus = &i2c_device_bus[2], .addr = MPU925X_I2C_AD1_ADDR};
static i2c_device_t ak8963_i2c_dev = {.bus = &i2c_device_bus[2], .addr = AK8963_ADDR};

2.IIC设备初始化

int main(void)
{
	...
	i2c_bus_init(&i2c_device_bus[0]);
    i2c_bus_init(&i2c_device_bus[1]);
    vSemaphoreDelete(i2c_device_bus[1].mutex);	/* i2c_device_bus[0]和i2c_device_bus[1]共用了scl, 要用同一个锁 */
    i2c_device_bus[1].mutex = i2c_device_bus[0].mutex;
	i2c_bus_init(&i2c_device_bus[2]);
	...
}

3.接下来就可以使用iic.h提供的write/read函数了

    ...
    /* 示例 */
    if (i2c_write_bytes(aht10_dev, temp, 2, AHT10_NORMAL_CMD) == I2C_STATUS_FAILED) {
        ret = 1;
        goto stop_aht10_init;
	}
	...
Nassura
关注
  • 2
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Kendryte K210 在freertos上的i2c的使用
smile_5me的博客
06-16 1369
首先修改project_cfg.h文件，将硬件定义好的i2c引脚定义好，其中13和14表示IO13和IO14，如下： const fpioa_cfg_t g_fpioa_cfg = { .version = PIN_CFG_VERSION, .functions_count = 2, .functions = { {14, FUNC_I2C0_SCLK}, {13, FUNC_I2C0_SDA}, } }; 然后在主函数里的如下
STM32软件模拟IIC读RC522
01-04
在本主题中，我们关注的是如何在STM32F103C8T6上软件模拟IIC（Inter-Integrated Circuit）协议来读取RC522模块。RC522是一款基于MFRC522芯片的RFID阅读器，常用于非接触式卡片读写应用。 首先，我们需要理解IIC协议...
STM32F103学习笔记（1）——FreeRTOS下模拟I2C
Leung的博客
06-15 7611
一、硬件连接 功能口 引脚 SCL PB.6 SDA PB.5 二、移植文件 链接：https://pan.baidu.com/s/1wxbQTMlnX2pavrbW2RYg4g 提取码：dxex 将 board_i2c.c 和 board_i2c.h 两个文件加入工程的User文件夹下 注意：延时函数使用了FreeRTOS的vTaskDelay任务延时函数 2.1 board_i2c.c /**********************************************
freertos上进行gpio模拟iic通信
weixin_66375860的博客
09-24 2833
freertos上进行gpio模拟iic通信时遇到的问题及解决方法
（五）STM32F407 cubemx IIC驱动OLED（2）硬件篇
最新发布
weixin_52531699的博客
05-13 1045
本文不会概述OLED的物理工作原理，而是从技术手册的角度上简述它。首先要学习OLED就得先了解其驱动芯片，**SSD1306**。
FreeRTOS 任务之间运行时序
weixin_72283641的博客
12-07 1378
初步的理解FreeRTOS任务切换方式以及时序情况
STM32 HAL库：FreeRTOS系统 （带推荐使用除了Systick以外的时钟源问题及解决）
lf_lf_lf_的博客
07-19 1254
防止在高优先级(优先级高于systick)中断服务中调用HAL_Delay(),导致中断服务忙等待,这样任何优先级低于该中断的中断都得不到服务。警告: 当使用了FreeRtos的时候，强烈建议HAL库使用除了Systick以外的时钟源。，比如不使用FREERTOS时是把多个任务放在while（1）里，任务执行有先后顺序，所以效率不高。：优先级高的任务一旦就绪就能剥夺优先级较低任务的CPU使用权，提高了系统的实时响应能力。：任务管理、时间管理、信号量、消息队列、内存管理、记录功能、软件定时器、协程等。
STM32 freertos 使用软件模拟串口uart
mainbanp
01-23 1675
通过上面学习使用方法与故障排除，STM32 freertos 使用软件模拟串口uart已经正常可以使用了。通过这个测试也对freertos 有了进一步认识。
STM32软件模拟IIC
08-08
STM32软件模拟IIC是一种在微控制器STM32上实现I²C（Inter-Integrated Circuit）通信协议的方法，无需依赖硬件IIC接口。在某些STM32芯片中，可能并未配备专用的I²C外设，这时就需要通过GPIO引脚来模拟I²C通信。...
STM32F103 模拟IIC实验_STM32F103
09-25
学习STM32模拟IIC的使用,驱动24C02实现EEPROM数据读写. 硬件资源: 1,DS0(连接在PB5) 2,串口1(波特率:115200,PA9/PA10连接在板载USB转串口芯片CH340上面) 3,ALIENTEK 2.8/3.5/4.3/7寸TFTLCD模块(通过FSMC驱动,...
STM32 CH452软件IIC驱动程序
03-03
STM32 CH452软件IIC驱动程序是针对嵌入式系统中常见的微控制器STM32和CH452芯片进行通信的一种实现方式。在嵌入式开发中，IIC（Inter-Integrated Circuit）是一种广泛应用的串行通信协议，主要用于连接微控制器和...
STM32模拟IIC驱动MB85RC128
06-16
STM32模拟IIC驱动MB85RC128 根据自己的实际情况修改IO即可
F407ZET6模拟iic驱动0.96OLED
12-05
F407ZET6模拟iic驱动0.96OLEDF407ZET6模拟iic驱动0.96OLED
基于STM32的模拟IIC驱动OLED显示屏
02-19
在本项目"基于STM32的模拟IIC驱动OLED显示屏"中，开发者旨在利用STM32的GPIO引脚模拟IIC通信协议，来驱动OLED显示屏。OLED（有机发光二极管）是一种自发光显示技术，具有高对比度、响应速度快、视角广等优点，常用于...
FreeRTOS SPI 时序以及模拟SPI时序
qq_45542360的博客
02-24 2465
SPI（Serial Peripheral Interface），顾名思义就是串行外围设备接口。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线（MISO, MOSI, CLK, CS）可以不用CS片选引脚也是三线式，SPI有时候可以不用MISO, MOSI，中的一个，但CLK的引脚一定需要存在。SPI节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，正是出于这...
FreeRTOS学习之路，以STM32F103C8T6为实验MCU（2-7：软件定时器）
weixin_61908666的博客
11-26 823
学习之路主要为操作系统在STM32F103（）上的运用，采用的是标准库编程的方式，使用的IDE为KEIL5。注意！！！本学习之路可以通过购买STM32板以及部分配件的方式进行学习，也可以通过Proteus仿真的方式进行学习。后续文章会同时发表在个人博客(jason1016.club)、CSDN；视频会发布在bilibili(UID:399951374)
STM32 GPIO模拟多路I2C总线中阶操作
Pegasus的软件博客
10-03 4270
对于I2C设备地址相同的多个设备，则需要用多路并行I2C进行访问，通常硬件功能模块资源有限，就要通过GPIO模拟多路I2C总线实现。
基于STM32单片机编写的驱动与设备分离的IIC驱动（模拟IIC，可兼容其他32系列单片机）
weixin_52168390的博客
05-04 791
基于STM32单片机编写的驱动与设备分离的IIC驱动（模拟IIC，可兼容其他32系列单片机）
STM32 系列使用知识问题笔记
不浮夸，不将就，认真对待学知识的我们
08-18 1162
以后把使用过程自己遇到需要查询的问题记录在这篇博客，也不至于到处乱记录，用了就忘了。
软件模拟IIC 软件模拟IIC 软件模拟从机IIC
07-21
软件模拟IIC（Inter-Integrated Circuit）是指在软件层面上实现IIC总线通信协议。IIC是一种串行通信总线，常用于连接微控制器和外部设备，如传感器、存储器等。通过软件模拟IIC，可以在没有硬件IIC接口的情况下，利用通用IO口模拟IIC总线进行数据交换。 要实现软件模拟从机IIC，可以按照以下步骤进行： 1. 确定使用的硬件平台和开发环境，如使用的微控制器或单片机型号、编程语言等。 2. 根据IIC协议的时序要求，编写软件代码实现IIC的起始、地址传输、数据传输和停止等操作。 3. 配置相应的IO口作为模拟的SDA（串行数据线）和SCL（串行时钟线），并确保其电平变化符合IIC协议。 4. 在从机模式下，监听主机发起的传输请求，根据接收到的地址和数据进行相应的处理。 5. 对于数据的发送和接收，可以通过IO口的输入输出控制来模拟数据线的电平变化。 6. 在数据传输完成后，需要发送ACK（应答）信号以确认数据已接收。 需要注意的是，软件模拟IIC相比硬件IIC通信更加耗时，因为通信过程需要通过软件代码来实现，而不是通过硬件电路直接处理。因此，在实际应用中，需权衡软件模拟IIC的实时性和性能需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值