手撕I2C和SPI协议实现

手撕I2C和SPI协议实现

I2C协议原理

I2C（Inter-Integrated Circuit）是一种串行通信总线，利用两根线：SCL（时钟线）和SDA（数据线）。
基本特性

• 主从架构，支持多主机
  
• 双向半双工通信
  
• 每个设备都有唯一地点（7位或10位）
  
• 开漏输出 + 上拉电阻实现线与功能
  
• 通信速率：100kHz(标准)、400kHz(快速)、1MHz+(高速)
  

I2C时序图

基本信号时序

1. 起始信号(START)：
2. SCL: ────────────
3. SDA: ────┐      
4.          └─────── (SDA从高到低，SCL保持高)
6. 停止信号(STOP)：
7. SCL: ────────────
8. SDA: ─────┌─────  
9.           └───── (SDA从低到高，SCL保持高)
11. 数据位传输：
12. SCL: ───┐   ┌───┐   ┌───
13.         └───┘   └───┘    (时钟脉冲)
14. SDA: ─────┬───────┬─────  
15.           │ Bit7  │ Bit6  (数据在SCL低时变化，高时采样)

复制代码

完整传输时序

1. I2C写操作时序：
2.   START 地址+W  ACK  寄存器  ACK  数据   ACK  STOP
3.      │    │     │     │     │    │     │     │
4. SCL: ┌─┐ ┌─────┐ ┌─┐ ┌─────┐ ┌─┐ ┌────┐ ┌─┐ ┌─┐
5.      │S│ │ 8位 │ │A│ │ 8位 │ │A│ │8位 │ │A│ │P│
6. SDA: │T│ │地址0│ │C│ │寄存│ │C│ │数据│ │C│ │ │
7.      │A│ │     │ │K│ │器  │ │K│ │    │ │K│ │ │
8.      │R│ │     │ │ │ │    │ │ │ │    │ │ │ │ │
9.      └─┘ └─────┘ └─┘ └────┘ └─┘ └────┘ └─┘ └─┘
11. I2C读操作时序：
12.   START 地址+W  ACK  寄存器  ACK RESTART 地址+R  ACK  数据  NACK STOP
13.      │    │     │     │     │     │     │     │    │     │    │
14.      └─── 写地址 ────┘     └──── 读数据 ──────────────────┘

复制代码

信号状态

• 空闲状态：SCL和SDA均为高电平
  
• 起始信号(START)：SCL高电平时，SDA从高变低
  
• 停止信号(STOP)：SCL高电平时，SDA从低变高
  
• 数据位：SCL低电平时准备数据，SCL高电平时采样数据
  
• 应答信号(ACK)：吸收方在第9个时钟周期将SDA拉低表示吸收乐成
  

通信流程

• 主设备发送起始信号(START)
  
• 发送从设备地点(7位)和读/写位(1位)
  
• 从设备发送应答(ACK)
  
• 数据传输(8位一组)，每组后跟应答位
  
• 主设备发送停止信号(STOP)
  

I2C位操作实现

首先需要实现基本的I2C底层函数：
GPIO设置

1. // 配置GPIO为开漏输出模式
2. void I2C_GPIO_Config(void) {
3.     // 使能GPIO时钟
4.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
5.    
6.     GPIO_InitTypeDef GPIO_InitStructure;
7.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;  // SCL: PB6, SDA: PB7
8.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;        // 开漏输出
9.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
10.     GPIO_Init(GPIOB, &GPIO_InitStructure);
11.    
12.     // 空闲状态，均为高电平
13.     GPIO_SetBits(GPIOB, GPIO_Pin_6 | GPIO_Pin_7);
14. }

复制代码

I2C基本操作函数

1. // SCL和SDA控制函数
2. #define SCL_H    GPIO_SetBits(GPIOB, GPIO_Pin_6)
3. #define SCL_L    GPIO_ResetBits(GPIOB, GPIO_Pin_6)
4. #define SDA_H    GPIO_SetBits(GPIOB, GPIO_Pin_7)
5. #define SDA_L    GPIO_ResetBits(GPIOB, GPIO_Pin_7)
6. #define SDA_READ GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_7)
8. // 延迟函数
9. void I2C_Delay(void) {
10.     uint8_t i = 10;  // 可根据时钟频率调整
11.     while(i--);
12. }
14. // 起始信号
15. void I2C_Start(void) {
16.     SDA_H;
17.     SCL_H;
18.     I2C_Delay();
19.     SDA_L;         // SDA从高到低，产生起始信号
20.     I2C_Delay();
21.     SCL_L;         // 钳住I2C总线，准备发送或接收数据
22. }
24. // 停止信号
25. void I2C_Stop(void) {
26.     SDA_L;
27.     SCL_H;
28.     I2C_Delay();
29.     SDA_H;         // SDA从低到高，产生停止信号
30.     I2C_Delay();
31. }
33. // 等待应答
34. uint8_t I2C_WaitAck(void) {
35.     uint8_t ack;
36.    
37.     SDA_H;         // 释放SDA
38.     I2C_Delay();
39.     SCL_H;         // 产生时钟脉冲
40.     I2C_Delay();
41.     ack = SDA_READ; // 读取SDA状态
42.     SCL_L;
43.     return ack;    // 返回0表示有应答
44. }
46. // 发送应答
47. void I2C_Ack(void) {
48.     SDA_L;         // SDA拉低，表示ACK
49.     I2C_Delay();
50.     SCL_H;
51.     I2C_Delay();
52.     SCL_L;
53.     SDA_H;         // 释放SDA
54. }
56. // 发送非应答
57. void I2C_NAck(void) {
58.     SDA_H;         // SDA保持高电平，表示NACK
59.     I2C_Delay();
60.     SCL_H;
61.     I2C_Delay();
62.     SCL_L;
63. }
65. // 发送一个字节
66. void I2C_SendByte(uint8_t byte) {
67.     uint8_t i = 8;
68.    
69.     while(i--) {
70.         SCL_L;
71.         I2C_Delay();
72.         if(byte & 0x80)
73.             SDA_H;
74.         else
75.             SDA_L;
76.         byte <<= 1;
77.         I2C_Delay();
78.         SCL_H;
79.         I2C_Delay();
80.     }
81.     SCL_L;
82. }
84. // 读取一个字节
85. uint8_t I2C_ReadByte(uint8_t ack) {
86.     uint8_t i = 8;
87.     uint8_t byte = 0;
88.    
89.     SDA_H;         // 释放SDA，准备读取数据
90.     while(i--) {
91.         byte <<= 1;
92.         SCL_L;
93.         I2C_Delay();
94.         SCL_H;
95.         I2C_Delay();
96.         if(SDA_READ)
97.             byte |= 0x01;
98.     }
99.     SCL_L;
100.    
101.     if(ack)
102.         I2C_Ack();  // 发送应答
103.     else
104.         I2C_NAck(); // 发送非应答
105.    
106.     return byte;
107. }

复制代码

I2C驱动代码编写

基于上面的底层函数，实现设备读写操作：

1. // 写入一个字节到指定设备的指定寄存器
2. uint8_t I2C_WriteReg(uint8_t DevAddr, uint8_t RegAddr, uint8_t data) {
3.     I2C_Start();
4.     I2C_SendByte(DevAddr << 1);  // 设备地址 + 写位(0)
5.     if(I2C_WaitAck()) {
6.         I2C_Stop();
7.         return 1;  // 无应答，失败
8.     }
9.    
10.     I2C_SendByte(RegAddr);       // 寄存器地址
11.     if(I2C_WaitAck()) {
12.         I2C_Stop();
13.         return 1;
14.     }
15.    
16.     I2C_SendByte(data);          // 写入数据
17.     if(I2C_WaitAck()) {
18.         I2C_Stop();
19.         return 1;
20.     }
21.    
22.     I2C_Stop();
23.     return 0;  // 成功
24. }
26. // 从指定设备的指定寄存器读取一个字节
27. uint8_t I2C_ReadReg(uint8_t DevAddr, uint8_t RegAddr) {
28.     uint8_t data;
29.    
30.     I2C_Start();
31.     I2C_SendByte(DevAddr << 1);  // 设备地址 + 写位(0)
32.     if(I2C_WaitAck()) {
33.         I2C_Stop();
34.         return 0xFF;  // 无应答，失败
35.     }
36.    
37.     I2C_SendByte(RegAddr);       // 寄存器地址
38.     if(I2C_WaitAck()) {
39.         I2C_Stop();
40.         return 0xFF;
41.     }
42.    
43.     I2C_Start();                 // 重复起始
44.     I2C_SendByte((DevAddr << 1) | 0x01);  // 设备地址 + 读位(1)
45.     if(I2C_WaitAck()) {
46.         I2C_Stop();
47.         return 0xFF;
48.     }
49.    
50.     data = I2C_ReadByte(0);      // 读取数据，发送非应答
51.     I2C_Stop();
52.    
53.     return data;
54. }

复制代码

实际应用示例：MPU6050读取数据

1. #define MPU6050_ADDR 0x68  // MPU6050设备地址
3. void MPU6050_Init() {
4.     I2C_WriteReg(MPU6050_ADDR, 0x6B, 0x00);  // 唤醒MPU6050
5.     I2C_WriteReg(MPU6050_ADDR, 0x19, 0x07);  // 采样率设置
6.     I2C_WriteReg(MPU6050_ADDR, 0x1A, 0x06);  // 配置数字低通滤波器
7.     I2C_WriteReg(MPU6050_ADDR, 0x1B, 0x18);  // 陀螺仪量程：±2000dps
8.     I2C_WriteReg(MPU6050_ADDR, 0x1C, 0x01);  // 加速度计量程：±2g
9. }
11. void MPU6050_GetAcceleration(int16_t *ax, int16_t *ay, int16_t *az) {
12.     uint8_t buf[6];
13.    
14.     // 读取加速度计数据
15.     buf[0] = I2C_ReadReg(MPU6050_ADDR, 0x3B);
16.     buf[1] = I2C_ReadReg(MPU6050_ADDR, 0x3C);
17.     buf[2] = I2C_ReadReg(MPU6050_ADDR, 0x3D);
18.     buf[3] = I2C_ReadReg(MPU6050_ADDR, 0x3E);
19.     buf[4] = I2C_ReadReg(MPU6050_ADDR, 0x3F);
20.     buf[5] = I2C_ReadReg(MPU6050_ADDR, 0x40);
21.    
22.     *ax = (buf[0] << 8) | buf[1];
23.     *ay = (buf[2] << 8) | buf[3];
24.     *az = (buf[4] << 8) | buf[5];
25. }

复制代码

SPI协议原理

SPI（Serial Peripheral Interface）是一种同步串行通信接口，利用四根线：
SPI信号定义

• MOSI (Master Out Slave In)：主设备发送，从设备吸收
  
• MISO (Master In Slave Out)：主设备吸收，从设备发送
  
• SCK (Serial Clock)：时钟信号，由主设备产生
  
• SS/CS (Slave Select/Chip Select)：片选信号，用于选择从设备
  

SPI时序图

四种工作模式时序

1. 模式0 (CPOL=0, CPHA=0)：空闲低电平，上升沿采样
2. CS:  ┌─────────────────────────────┐
3.      │                             │
4.   ───┘                             └───
6. SCK: ────┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─────
7.          └─┘ └─┘ └─┘ └─┘ └─┘ └─┘ └─┘
8.          ↑   ↑   ↑   ↑   ↑   ↑   ↑   
9.        采样 采样 采样 采样 采样 采样 采样
11. MOSI:────┬───┬───┬───┬───┬───┬───┬─────
12.          │D7 │D6 │D5 │D4 │D3 │D2 │D1 │D0
14. 模式1 (CPOL=0, CPHA=1)：空闲低电平，下降沿采样
15. SCK: ────┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─────
16.          └─┘ └─┘ └─┘ └─┘ └─┘ └─┘ └─┘
17.            ↓   ↓   ↓   ↓   ↓   ↓   ↓   
18.          采样 采样 采样 采样 采样 采样 采样
20. 模式2 (CPOL=1, CPHA=0)：空闲高电平，上升沿采样
21. CS:  ┌─────────────────────────────┐
22.      │                             │
23.   ───┘                             └───
25. SCK: ─────┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─────
26.           └─┘ └─┘ └─┘ └─┘ └─┘ └─┘ └─┘
27.           ↑   ↑   ↑   ↑   ↑   ↑   ↑   
28.         采样 采样 采样 采样 采样 采样 采样
30. MOSI:────┬───┬───┬───┬───┬───┬───┬─────
31.          │D7 │D6 │D5 │D4 │D3 │D2 │D1 │D0
33. 模式3 (CPOL=1, CPHA=1)：空闲高电平，下降沿采样
34. SCK: ─────┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─────
35.           └─┘ └─┘ └─┘ └─┘ └─┘ └─┘ └─┘
36.             ↓   ↓   ↓   ↓   ↓   ↓   ↓   
37.           采样 采样 采样 采样 采样 采样 采样

复制代码

SPI全双工传输时序

1. SPI全双工传输（模式0）：
2. CS:  ┌─────────────────────────────────────┐
3.      │                                     │
4.   ───┘                                     └───
6. SCK: ────┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─┐ ┌─────
7.          └─┘ └─┘ └─┘ └─┘ └─┘ └─┘ └─┘ └─┘
9. MOSI:────┬───┬───┬───┬───┬───┬───┬───┬─────
10.          │D7 │D6 │D5 │D4 │D3 │D2 │D1 │D0  
11.          └───┴───┴───┴───┴───┴───┴───┴─
13. MISO:────┬───┬───┬───┬───┬───┬───┬───┬─────
14.          │Q7 │Q6 │Q5 │Q4 │Q3 │Q2 │Q1 │Q0  
15.          └───┴───┴───┴───┴───┴───┴───┴─
17. 说明：主机发送数据D7-D0，同时接收从机数据Q7-Q0

复制代码

工作模式

SPI有四种工作模式，由CPOL（时钟极性）和CPHA（时钟相位）决定：

• 模式0：CPOL=0, CPHA=0，空闲时SCK低电平，第一个边沿采样
  
• 模式1：CPOL=0, CPHA=1，空闲时SCK低电平，第二个边沿采样
  
• 模式2：CPOL=1, CPHA=0，空闲时SCK高电平，第一个边沿采样
  
• 模式3：CPOL=1, CPHA=1，空闲时SCK高电平，第二个边沿采样
  

通信流程

• 主设备将对应从设备的CS线拉低（激活）
  
• 主设备通过SCK产生时钟信号
  
• 数据通过MOSI和MISO线同时双向传输
  
• 传输完成后，主设备将CS线拉高（释放）
  

SPI位操作实现

GPIO设置

1. // 配置SPI GPIO
2. void SPI_GPIO_Config(void) {
3.     // 使能GPIO时钟
4.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
5.    
6.     GPIO_InitTypeDef GPIO_InitStructure;
7.    
8.     // 配置SCK、MOSI为推挽输出
9.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;  // SCK: PA5, MOSI: PA7
10.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
11.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
12.     GPIO_Init(GPIOA, &GPIO_InitStructure);
13.    
14.     // 配置MISO为浮空输入
15.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;  // MISO: PA6
16.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
17.     GPIO_Init(GPIOA, &GPIO_InitStructure);
18.    
19.     // 配置CS为推挽输出
20.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;  // CS: PA4
21.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
22.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
23.     GPIO_Init(GPIOA, &GPIO_InitStructure);
24.    
25.     // 初始状态：CS高，SCK低
26.     GPIO_SetBits(GPIOA, GPIO_Pin_4);   // CS高电平，不选中从设备
27.     GPIO_ResetBits(GPIOA, GPIO_Pin_5); // SCK低电平，模式0初始状态
28. }

复制代码

SPI基本操作函数

1. // SPI引脚定义
2. #define SPI_CS_H   GPIO_SetBits(GPIOA, GPIO_Pin_4)
3. #define SPI_CS_L   GPIO_ResetBits(GPIOA, GPIO_Pin_4)
4. #define SPI_SCK_H  GPIO_SetBits(GPIOA, GPIO_Pin_5)
5. #define SPI_SCK_L  GPIO_ResetBits(GPIOA, GPIO_Pin_5)
6. #define SPI_MOSI_H GPIO_SetBits(GPIOA, GPIO_Pin_7)
7. #define SPI_MOSI_L GPIO_ResetBits(GPIOA, GPIO_Pin_7)
8. #define SPI_MISO   GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6)
10. // 延迟函数
11. void SPI_Delay(void) {
12.     uint8_t i = 2;
13.     while(i--);
14. }
16. // SPI发送并接收一个字节（模式0）
17. uint8_t SPI_ReadWriteByte(uint8_t data) {
18.     uint8_t i;
19.     uint8_t temp = 0;
20.    
21.     for(i = 0; i < 8; i++) {
22.         // 准备发送数据
23.         if(data & 0x80)
24.             SPI_MOSI_H;
25.         else
26.             SPI_MOSI_L;
27.         data <<= 1;  // 左移一位，准备下一位
28.         SPI_Delay();
29.         
30.         SPI_SCK_H;   // 时钟上升沿，从设备采样MOSI
31.         SPI_Delay();
32.         
33.         temp <<= 1;  // 左移一位，为接收新的数据位腾出空间
34.         if(SPI_MISO)
35.             temp++;  // 如果MISO为高，则置1
36.             
37.         SPI_SCK_L;   // 时钟下降沿，主设备采样MISO
38.         SPI_Delay();
39.     }
40.    
41.     return temp;     // 返回接收到的数据
42. }
44. // 支持不同模式的SPI传输
45. uint8_t SPI_TransferMode(uint8_t data, uint8_t mode) {
46.     uint8_t i, temp = 0;
47.     uint8_t cpol = (mode >> 1) & 1;  // 时钟极性
48.     uint8_t cpha = mode & 1;         // 时钟相位
49.    
50.     // 设置时钟空闲状态
51.     if(cpol) SPI_SCK_H; else SPI_SCK_L;
52.    
53.     for(i = 0; i < 8; i++) {
54.         // 根据CPHA决定数据变化时机
55.         if(!cpha) {
56.             if(data & 0x80) SPI_MOSI_H; else SPI_MOSI_L;
57.             data <<= 1;
58.         }
59.         
60.         // 产生时钟边沿
61.         if(!cpol) SPI_SCK_H; else SPI_SCK_L;
62.         SPI_Delay();
63.         
64.         if(cpha) {
65.             if(data & 0x80) SPI_MOSI_H; else SPI_MOSI_L;
66.             data <<= 1;
67.         }
68.         
69.         // 采样数据
70.         temp <<= 1;
71.         if(SPI_MISO) temp++;
72.         
73.         // 恢复时钟状态
74.         if(!cpol) SPI_SCK_L; else SPI_SCK_H;
75.         SPI_Delay();
76.     }
77.    
78.     return temp;
79. }

复制代码

SPI驱动代码编写

基于上面的底层函数，实现设备读写操作：

1. // 向指定寄存器写入一个字节
2. void SPI_WriteReg(uint8_t reg, uint8_t value) {
3.     SPI_CS_L;                 // 使能片选
4.     SPI_ReadWriteByte(reg);   // 发送寄存器地址
5.     SPI_ReadWriteByte(value); // 发送数据
6.     SPI_CS_H;                 // 禁用片选
7. }
9. // 从指定寄存器读取一个字节
10. uint8_t SPI_ReadReg(uint8_t reg) {
11.     uint8_t value;
12.    
13.     SPI_CS_L;                   // 使能片选
14.     SPI_ReadWriteByte(reg | 0x80); // 发送寄存器地址（最高位置1表示读操作）
15.     value = SPI_ReadWriteByte(0xFF); // 发送任意值，读取结果
16.     SPI_CS_H;                   // 禁用片选
17.    
18.     return value;
19. }
21. // 从指定寄存器读取多个字节
22. void SPI_ReadMulti(uint8_t reg, uint8_t *buf, uint8_t len) {
23.     SPI_CS_L;                   // 使能片选
24.     SPI_ReadWriteByte(reg | 0x80); // 发送寄存器地址（最高位置1表示读操作）
25.    
26.     while(len--) {
27.         *buf = SPI_ReadWriteByte(0xFF);
28.         buf++;
29.     }
30.    
31.     SPI_CS_H;                   // 禁用片选
32. }

复制代码

实际应用示例：读取W25Q64闪存

1. // W25Q64命令定义
2. #define W25Q64_READ_ID       0x90
3. #define W25Q64_READ_DATA     0x03
4. #define W25Q64_WRITE_ENABLE  0x06
5. #define W25Q64_PAGE_PROGRAM  0x02
6. #define W25Q64_ERASE_SECTOR  0x20
7. #define W25Q64_READ_STATUS   0x05
9. // 读取W25Q64芯片ID
10. uint16_t W25Q64_ReadID(void) {
11.     uint16_t id = 0;
12.    
13.     SPI_CS_L;
14.     SPI_ReadWriteByte(W25Q64_READ_ID);  // 发送读取ID命令
15.     SPI_ReadWriteByte(0x00);            // 发送3个虚拟地址
16.     SPI_ReadWriteByte(0x00);
17.     SPI_ReadWriteByte(0x00);
18.     id |= SPI_ReadWriteByte(0xFF) << 8; // 读取厂商ID
19.     id |= SPI_ReadWriteByte(0xFF);      // 读取设备ID
20.     SPI_CS_H;
21.    
22.     return id;
23. }
25. // 读取W25Q64状态寄存器
26. uint8_t W25Q64_ReadStatus(void) {
27.     uint8_t status;
28.     SPI_CS_L;
29.     SPI_ReadWriteByte(W25Q64_READ_STATUS);
30.     status = SPI_ReadWriteByte(0xFF);
31.     SPI_CS_H;
32.     return status;
33. }
35. // 等待W25Q64操作完成
36. void W25Q64_WaitBusy(void) {
37.     while((W25Q64_ReadStatus() & 0x01) == 0x01);
38. }
40. // 读取W25Q64数据
41. void W25Q64_ReadData(uint32_t addr, uint8_t *buf, uint16_t len) {
42.     SPI_CS_L;
43.     SPI_ReadWriteByte(W25Q64_READ_DATA);  // 发送读取命令
44.     SPI_ReadWriteByte((addr >> 16) & 0xFF); // 发送地址
45.     SPI_ReadWriteByte((addr >> 8) & 0xFF);
46.     SPI_ReadWriteByte(addr & 0xFF);
47.    
48.     while(len--) {
49.         *buf = SPI_ReadWriteByte(0xFF);
50.         buf++;
51.     }
52.    
53.     SPI_CS_H;
54. }

复制代码

协议对比与应用

I2C vs SPI对比表

特性I2CSPI信号线数目2线(SCL,SDA)4线(SCK,MOSI,MISO,CS)通信方式半双工全双工最大速度3.4MHz>100MHz多主机支持仲裁需额外计划设备寻址地点寻址片选线选择错误检测ACK/NACK无应用选择发起

选择I2C的场景：

• 多个传感器组网（温度、湿度、气压等）
  
• 系统设置器件（EEPROM、RTC、IO扩展）
  
• 引脚资源受限的项目
  
• 需要多主机通信的系统
  

选择SPI的场景：

• 高速数据传输（Flash存储器、ADC、DAC）
  
• 实时控制应用
  
• 音频/视频数据流
  
• 表现器驱动
  

调试技巧

• 利用示波器观察信号
  
  
  
  • 检查时序是否符合协议规范
    
  • 观察信号完整性和噪声干扰
    
  
  
• 软件调试方法
  

1. // I2C调试函数
2. void I2C_Debug_ScanBus(void) {
3.     printf("I2C总线扫描:\n");
4.     for(uint8_t addr = 0x08; addr < 0x78; addr++) {
5.         I2C_Start();
6.         if(I2C_SendByte_Check(addr << 1) == 0) {
7.             printf("发现设备地址: 0x%02X\n", addr);
8.         }
9.         I2C_Stop();
10.     }
11. }
13. // SPI调试函数  
14. void SPI_Debug_Test(void) {
15.     printf("SPI回环测试:\n");
16.     uint8_t test_data[] = {0xAA, 0x55, 0x00, 0xFF};
17.    
18.     SPI_CS_L;
19.     for(int i = 0; i < 4; i++) {
20.         uint8_t received = SPI_ReadWriteByte(test_data[i]);
21.         printf("发送: 0x%02X, 接收: 0x%02X\n", test_data[i], received);
22.     }
23.     SPI_CS_H;
24. }

复制代码

• 常见问题排查
  
  
  
  • 上拉电阻值不当（I2C）
    
  • 时序参数不匹配
    
  • 电源和地线连接问题
    
  • 信号线过长导致的干扰
    
  
  

总结

I2C协议实现要点

• 利用开漏输出模式设置GPIO
  
• 实现起始、停止、发送、吸收、应答等基本信号操作
  
• 按照协议时序编写读写函数
  
• 留意时钟速率控制和时序耽误
  

SPI协议实现要点

• 设置MOSI、SCK为输出，MISO为输入
  
• 确定利用的SPI模式（时钟极性和相位）
  
• 实现基本的读写字节函数
  
• 根据具体设备实现寄存器读写操作
  

留意事项

• 时序要严格遵循协议规范
  
• 延时函数需根据实际系统时钟频率调解
  
• 留意不同设备可能有特殊的地点或命令要求
  
• 调试时可以利用示波器观察信号波形
  
• 参加错误处理和超机会制提高鲁棒性