21ic电子技术开发论坛 › 单片机与嵌入式系统 › ARM技术论坛 › 【每周分享】I2C原理代码结合(干货)看图易懂 ...
返回列表 发新帖我要提问

[ARM入门] 【每周分享】I2C原理代码结合(干货)看图易懂

[复制链接]
 楼主| 虚幻的是灵魂 发表于 2024-10-15 15:13 | 显示全部楼层 |阅读模式
I2c, I2C通信, I2C读写, 硬件I2C, I2C工作原理, MUC GD32 I2C
本帖最后由 虚幻的是灵魂 于 2024-10-15 15:19 编辑

#申请原创#
@21小跑堂
I2C通讯规则

I2C总线包括两根信号线：SDA（串行数据线）和SCL（串行时钟线）。这两根信号线共用一个总线，因此在总线上可以连接多个设备。在I2C总线上，每个设备都有一个唯一的地址，用于标识设备。

SCL线是时钟线，用于控制数据传输的速度和时序；SDA线是数据线，用于传输实际的数据。

I2C写操作

流程如下:

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


I2C读流程

流程如下：

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

通讯信号开始

Start代码表示
复制
  1. static void start() {
    

  2.     SDA_OUT();
    

  3.  
    

  4.     SDA(1);
    

  5.     delay_1us(5);
    

  6.     SCL(1);
    

  7.     delay_1us(5);
    

  8.  
    

  9.     SDA(0);
    

  10.     delay_1us(5);
    

  11.     SCL(0);
    

  12.     delay_1us(5);
    

  13. }
结束


Stop代码表示
复制
  1. static void stop() {
    

  2.     SDA_OUT();
    

  3.  
    

  4.     SCL(0);
    

  5.     SDA(0);
    

  6.  
    

  7.     SCL(1);
    

  8.     delay_1us(5);
    

  9.     SDA(1);
    

  10.     delay_1us(5);
    

  11. }
发送数据bit发送


数据有效性：
  • SCL上升沿到下降沿这个阶段，SDA电平的高低，表示数据bit的1和0
  • 如果SDA电平在这个阶段发生变化，则无效，参考start和stop信号。

Byte发送

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

发送byte表示

复制
  1. static void send(uint8_t data) {
    

  2.     uint8_t i;
    

  3.     SDA_OUT();
    

  4.  
    

  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：Acknowledge character。表示等待响应，每发送一个数据，需要确认对方是否收到，就需要等待对方响应。



等待响应表示
复制
  1. static uint8_t wait_ack() {
    

  2.     int8_t retry = 10;
    

  3.  
    

  4.     SCL(0);
    

  5.     SDA(1);
    

  6.     SDA_IN();
    

  7.     delay_1us(5);
    

  8.     SCL(1);
    

  9.     delay_1us(5);
    

  10.  
    

  11.     while(SDA_STATE() == 1 && retry > 0) {
    

  12.         retry --;
    

  13.         delay_1us(5);
    

  14.     }
    

  15.  
    

  16.     if(retry <= 0) {
    

  17.         stop();
    

  18.         return 1;
    

  19.     } else {
    

  20.         SCL(0);
    

  21.         SDA_OUT();
    

  22.     }
    

  23.     return 0;
    

  24. }
结合代码

接收数据bit接收

Byte接收

逻辑分析仪测的：

说明： 在上升沿写入数据时，会获取从设备控制权，   上升沿写入数据； SCL在高电平时，会释放从设备控制权， 直到从设备被拉低后，主设备才响应成功。


接收byte代码表示

复制
  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);
    

  10.  
    

  11.         data <<= 1;
    

  12.  
    

  13.         data |= SDA_STATE();
    

  14.  
    

  15.         delay_1us(5);
    

  16.     }
    

  17.     SCL(0);
    

  18.     return data;
    

  19. }

发送响应

发送ACK
复制
  1. static void send_ack() {
    

  2.     SDA_OUT();
    

  3.     SCL(0);
    

  4.     SDA(0);
    

  5.     delay_1us(5);
    

  6.  
    

  7.     SDA(0);
    

  8.  
    

  9.     SCL(1);
    

  10.     delay_1us(5);
    

  11.     SCL(0);
    

  12.     SDA(1);
    

  13. }
发送NACK
复制
  1. static void send_nack() {
    

  2.     SDA_OUT();
    

  3.     SCL(0);
    

  4.     SDA(0);
    

  5.     delay_1us(5);
    

  6.  
    

  7.     SDA(1);
    

  8.  
    

  9.     SCL(1);
    

  10.     delay_1us(5);
    

  11.     SCL(0);
    

  12.     SDA(1);
    

  13. }
软件I2C开发流程
  • 引脚初始化
  • 引脚功能定义
  • 实现读操作
  • 实现写操作

GD32软件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);
    

  7.  
    

  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引脚高低电平
GD32软件I2C引脚功能
复制
  1. #define SCL_RCU                RCU_GPIOB
    

  2. #define SCL_PORT        GPIOB
    

  3. #define SCL_PIN                GPIO_PIN_6
    

  4. #define SCL_AF                GPIO_AF_4
    

  5.  
    

  6. #define SDA_RCU                RCU_GPIOB
    

  7. #define SDA_PORT        GPIOB
    

  8. #define SDA_PIN                GPIO_PIN_7
    

  9. #define SDA_AF                GPIO_AF_4
    

  10.  
    

  11. /************** io ***************/
    

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

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

  14. #define SDA_STATE()         gpio_input_bit_get(SDA_PORT, SDA_PIN)
    

  15.  
    

  16. #define SDA_IN()          gpio_mode_set(SDA_PORT, GPIO_MODE_INPUT,  GPIO_PUPD_NONE, SDA_PIN)
    

  17. #define SDA_OUT()         gpio_mode_set(SDA_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, SDA_PIN)
  • IO引脚定义
  • 引脚输出模式高低电平输出：SCL高和低，SDA高和低
  • SDA模式配置：SDA输出模式，SDA输入模式
  • SDA输入模式状态读取。
写操作


代码：
复制
  1. uint8_t SoftI2C_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
    

  2.     start();
    

  3.  
    

  4.     send(addr << 1);                        //发送设备写地址
    

  5.     if(wait_ack()) return 1;        //等待响应
    

  6.  
    

  7.     send(reg);                                        //发送寄存器地址
    

  8.     if(wait_ack()) return 2;        //等待响应
    

  9.  
    

  10.     do {
    

  11.         send(*data++);
    

  12.         if(wait_ack()) return 3;
    

  13.     } while(--len);
    

  14.  
    

  15.     stop();
    

  16.     return 0;
    

  17. }
读操作

代码：
复制
  1. uint8_t SoftI2C_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len) {
    

  2.     start();
    

  3.  
    

  4.     send(addr << 1);                                //发送设备写地址
    

  5.     if(wait_ack()) return 1;                //等待响应
    

  6.  
    

  7.     send(reg);                                                //发送寄存器地址
    

  8.     if(wait_ack()) return 2;                //等待响应
    

  9.  
    

  10.     start();
    

  11.     send((addr << 1) | 0x01);                //发送设备读地址
    

  12.     if(wait_ack()) return 3;                //等待响应
    

  13.  
    

  14.     do {
    

  15.         *data = recv();
    

  16.         data++;
    

  17.         if(len != 1) send_ack();        // 发送 NACK
    

  18.     } while(--len);
    

  19.     send_nack();                                        // 发送 NACK
    

  20.     stop();
    

  21.  
    

  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;
    

  5.  
    

  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;
    

  10.  
    

  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);
    

  22.  
    

  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);
    

  30.  
    

  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);
    

  37.  
    

  38. // 使能i2c
    

  39. i2c_mode_addr_config(i2cx, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, 0x00);
    

  40. i2c_enable(i2cx);
    

  41.  
    

  42. // i2c ack enable
    

  43. i2c_ack_config(i2cx, I2C_ACK_ENABLE);
  • 哪个I2C
  • SCL是哪个引脚
  • SDA是哪个引脚
  • 速度是多快
写操作流程开始
复制
  1. /************* start ***********************/
    

  2. // 等待I2C闲置
    

  3. if(I2C_waitn(i2cx, I2C_FLAG_I2CBSY)) return 1;
    

  4.  
    

  5. // start
    

  6. i2c_start_on_bus(i2cx);
    

  7.  
    

  8. // 等待I2C主设备成功发送起始信号
    

  9. if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 2;
发送设备地址
复制
  1. /************* device address **************/
    

  2. // 发送设备地址
    

  3. i2c_master_addressing(i2cx, address, I2C_TRANSMITTER);
    

  4. // 等待地址发送完成
    

  5. if(I2C_wait(i2cx, I2C_FLAG_ADDSEND)) return 3;
    

  6. i2c_flag_clear(i2cx, I2C_FLAG_ADDSEND);
发送寄存器地址
复制
  1. /************ register address ************/
    

  2. // 寄存器地址
    

  3. // 等待发送数据缓冲区为空
    

  4. if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 4;
    

  5.  
    

  6. // 发送数据
    

  7. i2c_data_transmit(i2cx, reg);
    

  8.  
    

  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];
    

  6.  
    

  7.     // 等待发送数据缓冲区为空
    

  8.     if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;
    

  9.  
    

  10.     // 发送数据
    

  11.     i2c_data_transmit(i2cx, d);
    

  12.  
    

  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;
    

  4.  
    

  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);
    

  4.  
    

  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;
    

  4.  
    

  5. // 发送寄存器地址
    

  6. i2c_data_transmit(i2cx, reg);
    

  7.  
    

  8. // 等待发送数据完成        
    

  9. if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 5;
    

  10.  
    

  11. if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;
开始
复制
  1. /************* start ***********************/
    

  2. // 发送再启动信号
    

  3. i2c_start_on_bus(i2cx);
    

  4.  
    

  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);
    

  6.  
    

  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;
    

  6.  
    

  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.     }
    

  14.  
    

  15.     // 等待ACK数据发送完成
    

  16.     // 等待接收缓冲区        
    

  17.     if(I2C_wait(i2cx, I2C_FLAG_RBNE)) return 10;
    

  18.     data[i] = i2c_data_receive(i2cx);
    

  19.  
    

  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;
完整代码

I2C0.H

复制
  1. #ifndef __I2C0_H__
    

  2. #define __I2C0_H__
    

  3.  
    

  4. #include "systick.h"
    

  5. #include "gd32f4xx.h"
    

  6.  
    

  7. void I2C0_init();
    

  8.  
    

  9. uint8_t I2C0_read(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
    

  10.  
    

  11. uint8_t I2C0_write(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t len);
    

  12.  
    

  13. uint8_t I2C0_write2(uint8_t addr, uint8_t reg, uint8_t* data, uint32_t offset, uint32_t len);
    

  14.  
    

  15. void I2C0_deinit();
    

  16.  
    

  17. #endif

I2C.C

复制
  1. #include "I2C0.h"
    

  2.  
    

  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;
    

  8.  
    

  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;
    

  13.  
    

  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);
    

  25.     
    

  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);
    

  33.     
    

  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);
    

  40.  
    

  41.     // 使能i2c
    

  42.     i2c_mode_addr_config(i2cx, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, 0x00);
    

  43.     i2c_enable(i2cx);
    

  44.  
    

  45.     // i2c ack enable
    

  46.                 i2c_ack_config(i2cx, I2C_ACK_ENABLE);
    

  47.     //i2c_ackpos_config(i2cx, I2C_ACKPOS_CURRENT);
    

  48.         
    

  49. }
    

  50.  
    

  51. static uint8_t I2C_wait(uint32_t i2cx, uint32_t flag) {
    

  52.     uint16_t TIMEOUT = 50000;
    

  53.     uint16_t cnt = 0;
    

  54.  
    

  55.     while(!i2c_flag_get(i2cx, flag)) {
    

  56.         cnt++;
    

  57.         if(cnt > TIMEOUT) return 1;
    

  58.     }
    

  59.     return 0;
    

  60. }
    

  61.  
    

  62. static uint8_t I2C_waitn(uint32_t i2cx, uint32_t flag) {
    

  63.     uint16_t TIMEOUT = 50000;
    

  64.     uint16_t cnt = 0;
    

  65.  
    

  66.     while(i2c_flag_get(i2cx, flag)) {
    

  67.         cnt++;
    

  68.         if(cnt > TIMEOUT) return 1;
    

  69.     }
    

  70.                 return 0;
    

  71. }
    

  72.  
    

  73.  
    

  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;
    

  77.                 
    

  78.                 /************* start ***********************/
    

  79.                 // 等待I2C闲置
    

  80.     if(I2C_waitn(i2cx, I2C_FLAG_I2CBSY)) return 1;
    

  81.         
    

  82.     // start
    

  83.     i2c_start_on_bus(i2cx);
    

  84.                 
    

  85.                  // 等待I2C主设备成功发送起始信号
    

  86.     if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 2;
    

  87.         
    

  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);
    

  94.         
    

  95.                 /************ register address ************/
    

  96.     // 寄存器地址
    

  97.     // 等待发送数据缓冲区为空
    

  98.     if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 4;
    

  99.                 
    

  100.                 // 发送数据
    

  101.     i2c_data_transmit(i2cx, reg);
    

  102.  
    

  103.     // 等待数据发送完成
    

  104.     if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 5;
    

  105.                 
    

  106.                 /***************** data ******************/
    

  107.     // 发送数据
    

  108.     uint32_t i;
    

  109.     for(i = 0; i < data_len; i++) {
    

  110.         uint32_t d = data[i];
    

  111.  
    

  112.         // 等待发送数据缓冲区为空
    

  113.         if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;
    

  114.  
    

  115.         // 发送数据
    

  116.         i2c_data_transmit(i2cx, d);
    

  117.  
    

  118.         // 等待数据发送完成
    

  119.         if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 7;
    

  120.     }
    

  121.                 
    

  122.                 /***************** stop ********************/
    

  123.     // stop
    

  124.     i2c_stop_on_bus(i2cx);
    

  125.     if(I2C_waitn(i2cx, I2C_CTL0(I2C0)&I2C_CTL0_STOP)) return 8;
    

  126.         
    

  127.                 return 0;
    

  128. }
    

  129.  
    

  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;
    

  133.                 
    

  134.                 /************* start ***********************/
    

  135.                 // 等待I2C闲置
    

  136.     if(I2C_waitn(i2cx, I2C_FLAG_I2CBSY)) return 1;
    

  137.         
    

  138.     // start
    

  139.     i2c_start_on_bus(i2cx);
    

  140.                 
    

  141.                  // 等待I2C主设备成功发送起始信号
    

  142.     if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 2;
    

  143.         
    

  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);
    

  150.         
    

  151.                 /************ register address ************/
    

  152.     // 寄存器地址
    

  153.     // 等待发送数据缓冲区为空
    

  154.     if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 4;
    

  155.                 
    

  156.                 // 发送数据
    

  157.     i2c_data_transmit(i2cx, reg);
    

  158.  
    

  159.     // 等待数据发送完成
    

  160.     if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 5;
    

  161.                 
    

  162.                 /***************** data ******************/
    

  163.     // 发送数据
    

  164.                 do {
    

  165.         // 等待发送数据缓冲区为空
    

  166.         if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;
    

  167.  
    

  168.         // 发送数据
    

  169.         i2c_data_transmit(i2cx, *data);
    

  170.                                 data += offset;
    

  171.  
    

  172.         // 等待数据发送完成
    

  173.         if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 7;
    

  174.     } while(--len);
    

  175.                 
    

  176.                 /***************** stop ********************/
    

  177.     // stop
    

  178.     i2c_stop_on_bus(i2cx);
    

  179.     if(I2C_waitn(i2cx, I2C_CTL0(I2C0)&I2C_CTL0_STOP)) return 8;
    

  180.         
    

  181.                 return 0;
    

  182. }
    

  183.  
    

  184.  
    

  185. void I2C0_deinit() {
    

  186.         
    

  187. }
    

  188.  
    

  189.  
    

  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;
    

  193.                 
    

  194.                 /************* start ***********************/
    

  195.     // 等待I2C空闲
    

  196.                 if(I2C_waitn(i2cx, I2C_FLAG_I2CBSY)) return 1;
    

  197.  
    

  198.     // 发送启动信号
    

  199.     i2c_start_on_bus(i2cx);
    

  200.                 if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 2;
    

  201.  
    

  202.                 /************* device address **************/
    

  203.     // 发送从设备地址
    

  204.     i2c_master_addressing(i2cx, address, I2C_TRANSMITTER);
    

  205.                 
    

  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);
    

  211.                 
    

  212.                 if(I2C_wait(i2cx, I2C_FLAG_ADDSEND)) return 3;
    

  213.                 i2c_flag_clear(i2cx, I2C_FLAG_ADDSEND);
    

  214.  
    

  215.                 /********** register address **************/
    

  216.                 // 等待发送缓冲区        
    

  217.     if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 4;
    

  218.     
    

  219.                 // 发送寄存器地址
    

  220.     i2c_data_transmit(i2cx, reg);
    

  221.                 
    

  222.                 // 等待发送数据完成        
    

  223.     if(I2C_wait(i2cx, I2C_FLAG_BTC)) return 5;        
    

  224.                 if(I2C_wait(i2cx, I2C_FLAG_TBE)) return 6;
    

  225.  
    

  226.                 /************* start ***********************/
    

  227.     // 发送再启动信号
    

  228.     i2c_start_on_bus(i2cx);
    

  229.                 
    

  230.                 
    

  231.                 if(I2C_wait(i2cx, I2C_FLAG_SBSEND)) return 7;
    

  232.  
    

  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);
    

  238.  
    

  239.  
    

  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;
    

  245.                 
    

  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.                                 }
    

  253.                         
    

  254.                                 // 等待ACK数据发送完成
    

  255.                                 // 等待接收缓冲区        
    

  256.                                 if(I2C_wait(i2cx, I2C_FLAG_RBNE)) return 10;
    

  257.         data[i] = i2c_data_receive(i2cx);
    

  258.                         
    

  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.     }
    

  267.                 
    

  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. }













本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复 赏

举报

评论

21小跑堂
字数未满800字不予审核  发表于 2024-10-16 13:53

相关帖子
呐咯密密 发表于 2024-10-30 10:12 | 显示全部楼层
请教一下，这个时序图和流程图是用什么软件做的
回复 赏

举报

yangjiaxu 发表于 2024-10-31 21:21 | 显示全部楼层
话说，I2C的挂载数量跟什么有关系？巡检的时候也是点名的方式吗？
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

虚幻的是灵魂

15

主题

118

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部