学习目标

  1. 理解I2C通讯原理
  2. 理解I2C通讯过程中的信号
  3. 理解软件I2C实现过程

  4. 理解硬件I2C的工作内容

    学习内容

    I2C通讯规则

    041.png
    I2C总线包括两根信号线：SDA（串行数据线）和SCL（串行时钟线）。这两根信号线共用一个总线，因此在总线上可以连接多个设备。在I2C总线上，每个设备都有一个唯一的地址，用于标识设备。
    SCL线是时钟线，用于控制数据传输的速度和时序；SDA线是数据线，用于传输实际的数据.

    I2C写操作

    流程如下:

  5. 开始。

  6. 发送设备地址，等待从设备响应
  7. 发送寄存器地址，等待从设备响应
  8. 发送一个字节，等待从设备响应。这个操作是循环执行，直到没有数据。
  9. 停止。

031.png

I2C读流程

流程如下：

  1. 开始。
  2. 发送设备地址（写地址），等待从设备响应
  3. 发送寄存器地址，等待从设备响应。
  4. 开始
  5. 发送设备地址（读地址），等待从设备响应
  6. 接收一个字节，发送响应给从设备。这个操作是循环执行，直到没有数据。当是最后一个数据时，发送空响应。
  7. 停止。

32.png

通讯信号

开始

033.png

  1. static void start() {
  2.     SDA_OUT();
  4.     SDA(1);
  5.     delay_1us(5);
  6.     SCL(1);
  7.     delay_1us(5);
  9.     SDA(0);
  10.     delay_1us(5);
  11.     SCL(0);
  12.     delay_1us(5);
  13. }

结束

034.png

  1. static void stop() {
  2.     SDA_OUT();
  4.     SCL(0);
  5.     SDA(0);
  7.     SCL(1);
  8.     delay_1us(5);
  9.     SDA(1);
  10.     delay_1us(5);
  11. }

发送数据

bit发送

035.png
数据有效性：

  • SCL上升沿到下降沿这个阶段，SDA电平的高低，表示数据bit的1和0

  • 如果SDA电平在这个阶段发生变化，则无效，参考start和stop信号。

    Byte发送

    基于数据有效性，将byte按bit位变化为高低电平，发送出去。
    091.png

    1. static void send(uint8_t data) {
    2.   uint8_t i;
    3.   SDA_OUT();
    5.   for(i = 0; i < 8; i++) {
    6.       if(data & 0x80) {
    7.           SDA(1);
    8.       } else {
    9.           SDA(0);
    10.       }
    11.       SCL(1);
    12.       delay_1us(5);
    13.       SCL(0);
    14.       delay_1us(5);
    15.       data <<= 1;
    16.   }
    17. }

等待响应

wait ack：_Ack_nowledge character。表示等待响应，每发送一个数据，需要确认对方是否收到，就需要等待对方响应。
image.png

  1. static uint8_t wait_ack() {
  2.     int8_t retry = 10;
  4.     SCL(0);
  5.     SDA(1);
  6.     SDA_IN();
  7.     delay_1us(5);
  8.     SCL(1);
  9.     delay_1us(5);
  11.     while(SDA_STATE() == 1 && retry > 0) {
  12.         retry --;
  13.         delay_1us(5);
  14.     }
  16.     if(retry <= 0) {
  17.         stop();
  18.         return 1;
  19.     } else {
  20.         SCL(0);
  21.         SDA_OUT();
  22.     }
  23.     return 0;
  24. }

接收数据

bit接收

039.png

Byte接收

092.png

  1. static uint8_t recv() {
  2.     uint8_t i, data;
  3.     SDA_IN();
  4.     data = 0;
  5.     for(i = 0; i < 8; i++) {
  6.         SCL(0);
  7.         delay_1us(5);
  8.         SCL(1);
  9.         delay_1us(5);
  11.         data <<= 1;
  13.         data |= SDA_STATE();
  15.         delay_1us(5);
  16.     }
  17.     SCL(0);
  18.     return data;
  19. }

发送响应

112.png

  1. static void send_ack() {
  2.     SDA_OUT();
  3.     SCL(0);
  4.     SDA(0);
  5.     delay_1us(5);
  7.     SDA(0);
  9.     SCL(1);
  10.     delay_1us(5);
  11.     SCL(0);
  12.     SDA(1);
  13. }
  1. static void send_nack() {
  2.     SDA_OUT();
  3.     SCL(0);
  4.     SDA(0);
  5.     delay_1us(5);
  7.     SDA(1);
  9.     SCL(1);
  10.     delay_1us(5);
  11.     SCL(0);
  12.     SDA(1);
  13. }

软件I2C

开发流程

  1. 引脚初始化
  2. 引脚功能定义
  3. 实现读操作

  4. 实现写操作

    GD32F4软件I2C初始化

    1. void SoftI2C_init() {
    2.  // 时钟配置
    3.  rcu_periph_clock_enable(SCL_RCU);
    4.  // 设置输出模式
    5.  gpio_mode_set(SCL_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, SCL_PIN);
    6.  gpio_output_options_set(SCL_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, SCL_PIN);
    8.  // 时钟配置
    9.  rcu_periph_clock_enable(SDA_RCU);
    10.  // 设置输出模式
    11.  gpio_mode_set(SDA_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, SDA_PIN);
    12.  gpio_output_options_set(SDA_PORT, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, SDA_PIN);
    13. }
  • I2C引脚高低电平

    GD32F4软件I2C引脚功能

    ```c

    define SCL_RCU RCU_GPIOB

    define SCL_PORT GPIOB

    define SCL_PIN GPIO_PIN_6

    define SCL_AF GPIO_AF_4

define SDA_RCU RCU_GPIOB

define SDA_PORT GPIOB

define SDA_PIN GPIO_PIN_7

define SDA_AF GPIO_AF_4

/** io */

define SCL(BIT) gpio_bit_write(SCL_PORT, SCL_PIN, BIT?SET:RESET)

define SDA(BIT) gpio_bit_write(SDA_PORT, SDA_PIN, BIT?SET:RESET)

define SDA_STATE() gpio_input_bit_get(SDA_PORT, SDA_PIN)

define SDA_IN() gpio_mode_set(SDA_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, SDA_PIN)

define SDA_OUT() gpio_mode_set(SDA_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, SDA_PIN)

  2. - IO引脚定义
  3. - 引脚输出模式高低电平输出：SCL高和低，SDA高和低
  4. - SDA模式配置：SDA输出模式，SDA输入模式
  5. - SDA输入模式状态读取。
  6. <a name="tWatG"></a>
  7. #### 写操作
  8. ![031.png](https://cdn.nlark.com/yuque/0/2023/png/27903758/1692842768446-3c8ee866-5cbf-4ef6-820e-3fc85b744592.png#averageHue=%23140a04&clientId=uff3818e1-2c0e-4&from=ui&height=425&id=u42a0aaa4&originHeight=760&originWidth=442&originalType=binary&ratio=1&rotation=0&showTitle=false&size=194479&status=done&style=none&taskId=u6e0b107f-f9ad-4c5b-99e3-7e152dffed5&title=&width=247)
  9. ```c
  10. uint8_t SoftI2C_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
  11.     start();
  13.     send(addr << 1);            //发送设备写地址
  14.     if(wait_ack()) return 1;    //等待响应
  16.     send(reg);                    //发送寄存器地址
  17.     if(wait_ack()) return 2;    //等待响应
  19.     do {
  20.         send(*data++);
  21.         if(wait_ack()) return 3;
  22.     } while(--len);
  24.     stop();
  25.     return 0;
  26. }

读操作

32.png

  1. uint8_t SoftI2C_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
  2.     start();
  4.     send(addr << 1);                //发送设备写地址
  5.     if(wait_ack()) return 1;        //等待响应
  7.     send(reg);                        //发送寄存器地址
  8.     if(wait_ack()) return 2;        //等待响应
  10.     start();
  11.     send((addr << 1) | 0x01);        //发送设备读地址
  12.     if(wait_ack()) return 3;        //等待响应
  14.     do {
  15.         *data = recv();
  16.         data++;
  17.         if(len != 1) send_ack();    // 发送 NACK
  18.     } while(--len);
  19.     send_nack();                    // 发送 NACK
  20.     stop();
  22.     return 0;
  23. }

硬件I2C-GD32F4系列

初始化操作

  1. uint32_t i2cx_scl_port_rcu = RCU_GPIOB;
  2. uint32_t i2cx_scl_port = GPIOB;
  3. uint32_t i2cx_scl_pin = GPIO_PIN_6;
  4. uint32_t i2cx_scl_af = GPIO_AF_4;
  6. uint32_t i2cx_sda_port_rcu = RCU_GPIOB;
  7. uint32_t i2cx_sda_port = GPIOB;
  8. uint32_t i2cx_sda_pin = GPIO_PIN_7;
  9. uint32_t i2cx_sda_af = GPIO_AF_4;
  11. uint32_t i2cx = I2C0;
  12. uint32_t i2cx_rcu = RCU_I2C0;
  13. uint32_t i2cx_speed = 400000;
  14. /****************** GPIO config **********************/
  15. // 时钟配置
  16. rcu_periph_clock_enable(i2cx_scl_port_rcu);
  17. // 设置复用功能
  18. gpio_af_set(i2cx_scl_port, i2cx_scl_af, i2cx_scl_pin);
  19. // 设置输出模式
  20. gpio_mode_set(i2cx_scl_port, GPIO_MODE_AF, GPIO_PUPD_NONE, i2cx_scl_pin);
  21. gpio_output_options_set(i2cx_scl_port, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, i2cx_scl_pin);
  23. // 时钟配置
  24. rcu_periph_clock_enable(i2cx_sda_port_rcu);
  25. // 设置复用功能
  26. gpio_af_set(i2cx_sda_port, i2cx_sda_af, i2cx_sda_pin);
  27. // 设置输出模式
  28. gpio_mode_set(i2cx_sda_port, GPIO_MODE_AF, GPIO_PUPD_NONE, i2cx_sda_pin);
  29. gpio_output_options_set(i2cx_sda_port, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, i2cx_sda_pin);
  31. /****************** I2C config  **********************/
  32. i2c_deinit(i2cx);
  33. // 时钟配置
  34. rcu_periph_clock_enable(i2cx_rcu);
  35. // I2C速率配置
  36. i2c_clock_config(i2cx, i2cx_speed, I2C_DTCY_2);
  38. // 使能i2c
  39. i2c_mode_addr_config(i2cx, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, 0x00);
  40. i2c_enable(i2cx);
  42. // i2c ack enable
  43. i2c_ack_config(i2cx, I2C_ACK_ENABLE);
  • 哪个I2C
  • SCL是哪个引脚
  • SDA是哪个引脚
  • 速度是多快

    写操作流程

    开始
    ```c /* start */ // 等待I2C闲置 if(I2C_waitn(i2cx, I2C_FLAG_I2CBSY)) return 1;

// start i2c_start_on_bus(i2cx);

// 等待I2C主设备成功发送起始信号 if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 2;

  1. <a name="WtaJX"></a>
  2. ##### 发送设备地址
  3. ```c
  4. /************* device address **************/
  5. // 发送设备地址
  6. i2c_master_addressing(i2cx, address, I2C_TRANSMITTER);
  7. // 等待地址发送完成
  8. if(I2C_wait(i2cx, I2C_FLAG_ADDSEND)) return 3;
  9. i2c_flag_clear(i2cx, I2C_FLAG_ADDSEND);

发送寄存器地址
  1. /************ register address ************/
  2. // 寄存器地址
  3. // 等待发送数据缓冲区为空
  4. if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 4;
  6. // 发送数据
  7. i2c_data_transmit(i2cx, reg);
  9. // 等待数据发送完成
  10. if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 5;

数据发送
  1. /***************** data ******************/
  2. // 发送数据
  3. uint32_t i;
  4. for(i = 0; i < data_len; i++) {
  5.     uint32_t d = data[i];
  7.     // 等待发送数据缓冲区为空
  8.     if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;
  10.     // 发送数据
  11.     i2c_data_transmit(i2cx, d);
  13.     // 等待数据发送完成
  14.     if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 7;
  15. }

停止
  1. /***************** stop ********************/
  2. // stop
  3. i2c_stop_on_bus(i2cx);
  4. if(I2C_waitn(i2cx, I2C_CTL0(I2C0)&I2C_CTL0_STOP)) return 8;

读操作流程

开始
  1. /************* start ***********************/
  2. // 等待I2C空闲
  3. if(I2C_waitn(i2cx, I2C_FLAG_I2CBSY)) return 1;
  5. // 发送启动信号
  6. i2c_start_on_bus(i2cx);
  7. if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 2;

发送设备地址（写）
  1. /************* device address **************/
  2. // 发送从设备地址
  3. i2c_master_addressing(i2cx, address, I2C_TRANSMITTER);
  5. if(I2C_wait(i2cx, I2C_FLAG_ADDSEND)) return 3;
  6. i2c_flag_clear(i2cx, I2C_FLAG_ADDSEND);

发送寄存器地址
  1. /********** register address **************/
  2. // 等待发送缓冲区    
  3. if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 4;
  5. // 发送寄存器地址
  6. i2c_data_transmit(i2cx, reg);
  8. // 等待发送数据完成    
  9. if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 5;
  11. if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;

开始
  1. /************* start ***********************/
  2. // 发送再启动信号
  3. i2c_start_on_bus(i2cx);
  5. if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 7;

发送设备地址（读）
  1. /************* device address **************/
  2. // 发送从设备地址
  3. i2c_master_addressing(i2cx, address, I2C_RECEIVER);
  4. if(I2C_wait(i2cx, I2C_FLAG_ADDSEND)) return 8;
  5. i2c_flag_clear(i2cx, I2C_FLAG_ADDSEND);
  7. //ack
  8. i2c_ack_config(i2cx, I2C_ACK_ENABLE);
  9. i2c_ackpos_config(i2cx, I2C_ACKPOS_CURRENT);
  10. if(I2C_wait(i2cx, (I2C_CTL0(i2cx) & I2C_CTL0_ACKEN))) return 23;

数据读取
  1. /************* data **************/
  2. //ack
  3. i2c_ack_config(i2cx, I2C_ACK_ENABLE);
  4. i2c_ackpos_config(i2cx, I2C_ACKPOS_CURRENT);
  5. if(I2C_wait(i2cx, (I2C_CTL0(i2cx) & I2C_CTL0_ACKEN))) return 11;
  7. // 读取数据
  8. uint8_t i;
  9. for (i = 0; i < len; i++) {
  10.     if(i != len - 1) {
  11.         // 等待接收缓冲区    
  12.         if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 9;
  13.     }
  15.     // 等待ACK数据发送完成
  16.     // 等待接收缓冲区    
  17.     if(I2C_wait(i2cx, I2C_FLAG_RBNE)) return 10;
  18.     data[i] = i2c_data_receive(i2cx);
  20.     if (i == len - 1) {
  21.         // 在读取最后一个字节之前，禁用ACK，并发送停止信号
  22.         // 配置自动NACK
  23.         i2c_ack_config(i2cx, I2C_ACK_DISABLE);
  24.     }
  25. }

结束
  1. /***************** stop ********************/
  2. i2c_stop_on_bus(i2cx);
  3. if(I2C_waitn(i2cx, I2C_CTL0(I2C0) & I2C_CTL0_STOP)) return 11;

GD32F4寄存器

流程 功能 标记 描述
START I2C_FLAG_I2CBSY busy标记。I2C是否占用，没有占用才可以使用。
I2C_FLAG_SBSEND 起始信号发送状态标记。START成功或失败。
数据 设备地址 I2C_FLAG_ADDSEND 地址发送状态标记。成功或失败。
发送 I2C_FLAG_TBE 发送数据寄存器是否为空的标记。为空才可以继续发送。
I2C_FLAG_BTC 发送数据寄存器中数据是否发送完成。
接收 I2C_FLAG_RBNE 接收缓冲区寄存器是否为空的标记。为空才可以继续接收。
STOP I2C_CTL0_STOP 停止标记位。

完整代码

  1. #ifndef __I2C0_H__
  2. #define __I2C0_H__
  4. #include "systick.h"
  5. #include "gd32f4xx.h"
  7. void I2C0_init();
  9. uint8_t I2C0_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
  11. uint8_t I2C0_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
  13. uint8_t I2C0_write2(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t offset, uint32_t len);
  15. void I2C0_deinit();
  17. #endif
  1. #include "I2C0.h"
  3. void I2C0_init() {
  4.         uint32_t i2cx_scl_port_rcu = RCU_GPIOB;
  5.     uint32_t i2cx_scl_port = GPIOB;
  6.     uint32_t i2cx_scl_pin = GPIO_PIN_6;
  7.     uint32_t i2cx_scl_af = GPIO_AF_4;
  9.     uint32_t i2cx_sda_port_rcu = RCU_GPIOB;
  10.     uint32_t i2cx_sda_port = GPIOB;
  11.     uint32_t i2cx_sda_pin = GPIO_PIN_7;
  12.     uint32_t i2cx_sda_af = GPIO_AF_4;
  14.     uint32_t i2cx = I2C0;
  15.     uint32_t i2cx_rcu = RCU_I2C0;
  16.     uint32_t i2cx_speed = 400000;
  17.     /****************** GPIO config **********************/
  18.     // 时钟配置
  19.     rcu_periph_clock_enable(i2cx_scl_port_rcu);
  20.         // 设置复用功能
  21.     gpio_af_set(i2cx_scl_port, i2cx_scl_af, i2cx_scl_pin);
  22.         // 设置输出模式
  23.     gpio_mode_set(i2cx_scl_port, GPIO_MODE_AF, GPIO_PUPD_NONE, i2cx_scl_pin);
  24.     gpio_output_options_set(i2cx_scl_port, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, i2cx_scl_pin);
  26.     // 时钟配置
  27.     rcu_periph_clock_enable(i2cx_sda_port_rcu);
  28.     // 设置复用功能
  29.     gpio_af_set(i2cx_sda_port, i2cx_sda_af, i2cx_sda_pin);
  30.         // 设置输出模式
  31.     gpio_mode_set(i2cx_sda_port, GPIO_MODE_AF, GPIO_PUPD_NONE, i2cx_sda_pin);
  32.     gpio_output_options_set(i2cx_sda_port, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, i2cx_sda_pin);
  34.     /****************** I2C config  **********************/
  35.     i2c_deinit(i2cx);
  36.     // 时钟配置
  37.     rcu_periph_clock_enable(i2cx_rcu);
  38.     // I2C速率配置
  39.     i2c_clock_config(i2cx, i2cx_speed, I2C_DTCY_2);
  41.     // 使能i2c
  42.     i2c_mode_addr_config(i2cx, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, 0x00);
  43.     i2c_enable(i2cx);
  45.     // i2c ack enable
  46.         i2c_ack_config(i2cx, I2C_ACK_ENABLE);
  47.     //i2c_ackpos_config(i2cx, I2C_ACKPOS_CURRENT);
  49. }
  51. static uint8_t I2C_wait(uint32_t i2cx, uint32_t flag) {
  52.     uint16_t TIMEOUT = 50000;
  53.     uint16_t cnt = 0;
  55.     while(!i2c_flag_get(i2cx, flag)) {
  56.         cnt++;
  57.         if(cnt > TIMEOUT) return 1;
  58.     }
  59.     return 0;
  60. }
  62. static uint8_t I2C_waitn(uint32_t i2cx, uint32_t flag) {
  63.     uint16_t TIMEOUT = 50000;
  64.     uint16_t cnt = 0;
  66.     while(i2c_flag_get(i2cx, flag)) {
  67.         cnt++;
  68.         if(cnt > TIMEOUT) return 1;
  69.     }
  70.         return 0;
  71. }
  74. uint8_t I2C0_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t data_len) {
  75.         uint32_t i2cx = I2C0;
  76.     uint8_t address = addr << 1;
  78.         /************* start ***********************/
  79.         // 等待I2C闲置
  80.     if(I2C_waitn(i2cx, I2C_FLAG_I2CBSY)) return 1;
  82.     // start
  83.     i2c_start_on_bus(i2cx);
  85.          // 等待I2C主设备成功发送起始信号
  86.     if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 2;
  88.         /************* device address **************/
  89.     // 发送设备地址
  90.     i2c_master_addressing(i2cx, address, I2C_TRANSMITTER);
  91.          // 等待地址发送完成
  92.     if(I2C_wait(i2cx, I2C_FLAG_ADDSEND)) return 3;
  93.     i2c_flag_clear(i2cx, I2C_FLAG_ADDSEND);
  95.         /************ register address ************/
  96.     // 寄存器地址
  97.     // 等待发送数据缓冲区为空
  98.     if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 4;
  100.         // 发送数据
  101.     i2c_data_transmit(i2cx, reg);
  103.     // 等待数据发送完成
  104.     if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 5;
  106.         /***************** data ******************/
  107.     // 发送数据
  108.     uint32_t i;
  109.     for(i = 0; i < data_len; i++) {
  110.         uint32_t d = data[i];
  112.         // 等待发送数据缓冲区为空
  113.         if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;
  115.         // 发送数据
  116.         i2c_data_transmit(i2cx, d);
  118.         // 等待数据发送完成
  119.         if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 7;
  120.     }
  122.         /***************** stop ********************/
  123.     // stop
  124.     i2c_stop_on_bus(i2cx);
  125.     if(I2C_waitn(i2cx, I2C_CTL0(I2C0)&I2C_CTL0_STOP)) return 8;
  127.         return 0;
  128. }
  130. uint8_t I2C0_write2(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t offset, uint32_t len) {
  131.     uint32_t i2cx = I2C0;
  132.     uint8_t address = addr << 1;
  134.         /************* start ***********************/
  135.         // 等待I2C闲置
  136.     if(I2C_waitn(i2cx, I2C_FLAG_I2CBSY)) return 1;
  138.     // start
  139.     i2c_start_on_bus(i2cx);
  141.          // 等待I2C主设备成功发送起始信号
  142.     if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 2;
  144.         /************* device address **************/
  145.     // 发送设备地址
  146.     i2c_master_addressing(i2cx, address, I2C_TRANSMITTER);
  147.          // 等待地址发送完成
  148.     if(I2C_wait(i2cx, I2C_FLAG_ADDSEND)) return 3;
  149.     i2c_flag_clear(i2cx, I2C_FLAG_ADDSEND);
  151.         /************ register address ************/
  152.     // 寄存器地址
  153.     // 等待发送数据缓冲区为空
  154.     if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 4;
  156.         // 发送数据
  157.     i2c_data_transmit(i2cx, reg);
  159.     // 等待数据发送完成
  160.     if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 5;
  162.         /***************** data ******************/
  163.     // 发送数据
  164.         do {
  165.         // 等待发送数据缓冲区为空
  166.         if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;
  168.         // 发送数据
  169.         i2c_data_transmit(i2cx, *data);
  170.                 data += offset;
  172.         // 等待数据发送完成
  173.         if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 7;
  174.     } while(--len);
  176.         /***************** stop ********************/
  177.     // stop
  178.     i2c_stop_on_bus(i2cx);
  179.     if(I2C_waitn(i2cx, I2C_CTL0(I2C0)&I2C_CTL0_STOP)) return 8;
  181.         return 0;
  182. }
  185. void I2C0_deinit() {
  187. }
  190. uint8_t I2C0_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
  191.         uint32_t i2cx = I2C0;
  192.         uint8_t address = addr << 1;
  194.         /************* start ***********************/
  195.     // 等待I2C空闲
  196.         if(I2C_waitn(i2cx, I2C_FLAG_I2CBSY)) return 1;
  198.     // 发送启动信号
  199.     i2c_start_on_bus(i2cx);
  200.         if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 2;
  202.         /************* device address **************/
  203.     // 发送从设备地址
  204.     i2c_master_addressing(i2cx, address, I2C_TRANSMITTER);
  206. //        //ack
  207. //        i2c_ack_config(i2cx, I2C_ACK_ENABLE);
  208. //        i2c_ackpos_config(i2cx, I2C_ACKPOS_CURRENT);
  209. //        if(I2C_wait(i2cx, (I2C_CTL0(i2cx) & I2C_CTL0_ACKEN))) return 11;
  210. //        // i2c_ack_config(i2cx, I2C_ACK_DISABLE);
  212.         if(I2C_wait(i2cx, I2C_FLAG_ADDSEND)) return 3;
  213.         i2c_flag_clear(i2cx, I2C_FLAG_ADDSEND);
  215.         /********** register address **************/
  216.         // 等待发送缓冲区    
  217.     if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 4;
  219.         // 发送寄存器地址
  220.     i2c_data_transmit(i2cx, reg);
  222.         // 等待发送数据完成    
  223.     if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 5;    
  224.         if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;
  226.         /************* start ***********************/
  227.     // 发送再启动信号
  228.     i2c_start_on_bus(i2cx);
  231.         if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 7;
  233.         /************* device address **************/
  234.     // 发送从设备地址
  235.     i2c_master_addressing(i2cx, address, I2C_RECEIVER);
  236.         if(I2C_wait(i2cx, I2C_FLAG_ADDSEND)) return 8;
  237.         i2c_flag_clear(i2cx, I2C_FLAG_ADDSEND);
  240.         /************* data **************/
  241.         //ack
  242.         i2c_ack_config(i2cx, I2C_ACK_ENABLE);
  243.         i2c_ackpos_config(i2cx, I2C_ACKPOS_CURRENT);
  244.         if(I2C_wait(i2cx, (I2C_CTL0(i2cx) & I2C_CTL0_ACKEN))) return 23;
  246.     // 读取数据
  247.         uint8_t i;
  248.     for (i = 0; i < len; i++) {
  249.                 if(i != len - 1) {
  250.                         // 等待ACK发送完成    
  251.                         if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 9;
  252.                 }
  254.                 // 等待ACK数据发送完成
  255.                 // 等待接收缓冲区    
  256.                 if(I2C_wait(i2cx, I2C_FLAG_RBNE)) return 10;
  257.         data[i] = i2c_data_receive(i2cx);
  259.         if (i == len - 1) {
  260.             // 在读取最后一个字节之前，禁用ACK，并发送停止信号
  261.                         // 配置自动NACK
  262.                         //i2c_ackpos_config(i2cx, I2C_ACKPOS_NEXT);
  263.                         //if(I2C_wait(i2cx, (I2C_CTL0(i2cx) & I2C_CTL0_ACKEN))) return 9;
  264.                         i2c_ack_config(i2cx, I2C_ACK_DISABLE);
  265.         }
  266.     }
  268.         /***************** stop ********************/
  269.         i2c_stop_on_bus(i2cx);
  270.         if(I2C_waitn(i2cx, I2C_CTL0(I2C0) & I2C_CTL0_STOP)) return 11;
  271.     return 0;
  272. }