I2C_IIC

使用IIC驱动框架来读取LM75的信号

发布于 2019-01-28 20:44:35 浏览：6132 订阅该版

43 个回答

whj467467222 认证专家 2019-01-28

开源，分享，交流，共同进步

whj467467222 认证专家 2019-01-28

开源，分享，交流，共同进步

whj467467222 认证专家 2019-01-28

开源，分享，交流，共同进步

4，上面配置好了，接下来就是IIC总线的初始化。

```
int rt_hw_i2c_init(void)
{
    rt_size_t obj_num = sizeof(i2c_obj) / sizeof(struct stm32_i2c);
    rt_err_t result;

for (int i = 0; i < obj_num; i++)
    {
        i2c_obj[i].ops = stm32_bit_ops_default;
        i2c_obj[i].ops.data = (void*)&soft_i2c_config[i];
        i2c_obj[i].i2c2_bus.priv = &i2c_obj[i].ops;
        stm32_i2c_gpio_init(&i2c_obj[i]);
        result = rt_i2c_bit_add_bus(&i2c_obj[i].i2c2_bus, soft_i2c_config[i].bus_name);
        RT_ASSERT(result == RT_EOK);
        stm32_i2c_bus_unlock(&soft_i2c_config[i]);
    }

return RT_EOK;
}
INIT_BOARD_EXPORT(rt_hw_i2c_init);
```

这个函数完成了IIC的初始化。
INIT_BOARD_EXPORT(rt_hw_i2c_init)完成了板级自动初始化。

obj_num = sizeof(i2c_obj) / sizeof(struct stm32_i2c);计算定义了几个IIC总线
soft_i2c_config这个结构体通过宏定义来获取定义了几个IIC总线的名字：目前支持I2C1 I2C2 I2C3
i2c_obj[i].ops = stm32_bit_ops_default;默认的参数，这里不需要自己修改

```
static const struct rt_i2c_bit_ops stm32_bit_ops_default =
{
    .data     = RT_NULL,
    .set_sda  = stm32_set_sda,
    .set_scl  = stm32_set_scl,
    .get_sda  = stm32_get_sda,
    .get_scl  = stm32_get_scl,
    .udelay   = stm32_udelay,
    .delay_us = 1,
    .timeout  = 100
};
```

stm32_i2c_gpio_init(&i2c_obj[i]);完成对模拟IIC SDA SCL引脚的初始化，这里初始化的模式是PIN_MODE_OUTPUT_OD

rt_i2c_bit_add_bus(&i2c_obj[i].i2c2_bus, soft_i2c_config[i].bus_name);完成对IIC总线的注册

stm32_i2c_bus_unlock(&soft_i2c_config[i]);刚刚完成对IIC总线的注册，这个时候还不需要发送数据，这个时候把互斥锁打开。

whj467467222 认证专家 2019-01-28

开源，分享，交流，共同进步

whj467467222 认证专家 2019-01-28

开源，分享，交流，共同进步

whj467467222 认证专家 2019-01-28

开源，分享，交流，共同进步

whj467467222 认证专家 2019-01-28

开源，分享，交流，共同进步

whj467467222 认证专家 2019-01-28

开源，分享，交流，共同进步

whj467467222 认证专家 2019-01-28

开源，分享，交流，共同进步

10，IIC总线框架读写操作的函数rt_i2c_transfer

```
rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus,
                                       struct rt_i2c_msg         msgs[],
                                       rt_uint32_t               num)
{
        rt_mutex_take(&bus->lock, RT_WAITING_FOREVER);
        ret = bus->ops->master_xfer(bus, msgs, num);
        rt_mutex_release(&bus->lock);

return ret;
 }
```

struct rt_i2c_bus_device *bus, 总线
struct rt_i2c_msg msgs[]          消息结构体
rt_uint32_t num                        数据数量

然后获取互斥锁，获取到了之后执行

```
ret = bus->ops->master_xfer(bus, msgs, num);
```

实际执行的函数是

```
static rt_size_t i2c_bit_xfer(struct rt_i2c_bus_device *bus,
                              struct rt_i2c_msg         msgs[],
                              rt_uint32_t               num)
{
    struct rt_i2c_msg *msg;
    struct rt_i2c_bit_ops *ops = bus->priv;
    rt_int32_t i, ret;
    rt_uint16_t ignore_nack;

bit_dbg("send start condition\n");
    i2c_start(ops);
    for (i = 0; i < num; i++)
    {
        msg = &msgs[i];
        ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
        if (!(msg->flags & RT_I2C_NO_START))
        {
            if (i)
            {
                i2c_restart(ops);
            }
            ret = i2c_bit_send_address(bus, msg);
            if ((ret != RT_EOK) && !ignore_nack)
            {
                bit_dbg("receive NACK from device addr 0x%02x msg %d\n",
                        msgs[i].addr, i);
                goto out;
            }
        }
        if (msg->flags & RT_I2C_RD)
        {
            ret = i2c_recv_bytes(bus, msg);
            if (ret >= 1)
                bit_dbg("read %d byte%s\n", ret, ret == 1 ? "" : "s");
            if (ret < msg->len)
            {
                if (ret >= 0)
                    ret = -RT_EIO;
                goto out;
            }
        }
        else
        {
            ret = i2c_send_bytes(bus, msg);
            if (ret >= 1)
                bit_dbg("write %d byte%s\n", ret, ret == 1 ? "" : "s");
            if (ret < msg->len)
            {
                if (ret >= 0)
                    ret = -RT_ERROR;
                goto out;
            }
        }
    }
    ret = i;

out:
    bit_dbg("send stop condition\n");
    i2c_stop(ops);

return ret;
}
```

该函数进入之后就发送了i2c_start(ops);IIC启动信号，
然后进入了for循环，我这个就发送一个数据进行说明
ignore_nack = msg->flags & RT_I2C_IGNORE_NACK; 这里需要回复ACK所以这里的ignore_nack=0
所以i2c_restart(ops);不会被执行
接下来执行ret = i2c_bit_send_address(bus, msg);

```
static rt_err_t i2c_bit_send_address(struct rt_i2c_bus_device *bus,
                                     struct rt_i2c_msg        *msg)
{
    rt_uint16_t flags = msg->flags;
    rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
    struct rt_i2c_bit_ops *ops = bus->priv;

rt_uint8_t addr1, addr2;
    rt_int32_t retries;
    rt_err_t ret;

retries = ignore_nack ? 0 : bus->retries;

if (flags & RT_I2C_ADDR_10BIT)
    {
    }
    else
    {
        /* 7-bit addr */
        addr1 = msg->addr << 1;
        if (flags & RT_I2C_RD)
            addr1 |= 1;
        ret = i2c_send_address(bus, addr1, retries);
        if ((ret != 1) && !ignore_nack)
            return -RT_EIO;
    }

return RT_EOK;
}
```

这里删掉了10bit模式，因为我用的7bi't'模式，10bit还没看
rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;因为第一次是写数据，所以这里的结果是0
addr1 = msg->addr << 1;这个地方要重点注意一下，地址左移了一位
然后执行ret = i2c_send_address(bus, addr1, retries);

```
    for (i = 0; i <= retries; i++)
    {
        ret = i2c_writeb(bus, addr);
        if (ret == 1 || i == retries)
            break;
        bit_dbg("send stop condition\n");
        i2c_stop(ops);
        i2c_delay2(ops);
        bit_dbg("send start condition\n");
        i2c_start(ops);
    }
```

前面做了这么多的准备工作，终于要执行写数据的函数了

```
static rt_int32_t i2c_writeb(struct rt_i2c_bus_device *bus, rt_uint8_t data)
{
    rt_int32_t i;
    rt_uint8_t bit;

struct rt_i2c_bit_ops *ops = bus->priv;

for (i = 7; i >= 0; i--)
    {
        SCL_L(ops);
        bit = (data >> i) & 1;
        SET_SDA(ops, bit);
        i2c_delay(ops);
        if (SCL_H(ops) < 0)
        {
            bit_dbg("i2c_writeb: 0x%02x, "
                    "wait scl pin high timeout at bit %d\n",
                    data, i);

return -RT_ETIMEOUT;
        }
    }
    SCL_L(ops);
    i2c_delay(ops);

return i2c_waitack(ops);
}
```