最近一段时间在做I2C通信协议，需要在两块STM32之间做I2C通信，定的是主机用IO口模拟，从机用的是STM32的硬件I2C，我的项目要求是需要主从机之间能够进行一串数据收发而不出错，实验时在主机方面，利用IO口模拟主机，只需要理解时序就够了，同时将速度能够控制在100K（标准）左右，基本的时序理解网上大把的资料，所以主机这一块几个小时就搞定了，而在做从机时，遇到了困难，本来从机也想用IO口模拟的，但是速度达不到那么快，因此只能选择硬件做从机，现就从机用中断方式开说，总结过程中遇到的几点问题：

1、由于STM32的硬件问题，建议在使用I2C时，将其优先级设为最高。

2、针对程序中除了I2C数据收发，还有别的中断程序或者指令要执行而导致I2C数据传输堵塞时，可以在执行完该段程序后重新初始化I2C。

主机程序如下：

1. #include "Hal_IIC/I2C.h"
   . c$ {) w; ~: R- B. ^- i7 F
2. #include "Hal_delay/delay.h"
   ( I1 e2 X1 ?8 A2 |) Y
3. #include "common.h"
   
4. #include "gizwits_product.h"
   % z; P% }: e2 o1 z% P4 k- y3 x
5. 
   2 f2 s) U. \1 f; J3 e, ?+ l% }
6. extern void delayUs(uint32_t nus);
   : ~0 `' W* e8 ?0 l! X5 g2 H  `9 L& p
7. uint8_t b[5];
   1 C4 K( C( x6 O4 Z
8. extern uint8_t Cookr[5];
   $ M& V1 x$ p5 n7 `) s; z' ^) R
9. extern uint8_t WR_flag;
   
10. uint8_t Wifi_SET;  //WIFI状态脚
    
11. extern uint8_t Power_flag;         //电磁炉开启关闭标志位
    : V" I/ u/ D! s, j; e# u
12. uint8_t Give_Up;
    ! c! R6 q2 c9 }6 s  n$ K1 }0 i0 _
13. /*--------------------------------------------------------------------------------
    
14. 调用方式：void IIC_Init(void)
    
15. 函数说明：私有函数，I2C专用，函数初始化
    1 t6 b1 l6 W2 d5 v0 K6 s$ d
16. ---------------------------------------------------------------------------------*/
    9 @. _2 }+ ?3 E% R! p
17. void IIC_Init(void)
    # a+ I5 I4 C0 j, @6 F& K! O/ }" m' f
18. {
    & j0 r7 D3 J$ h4 l: B
19.     GPIO_InitTypeDef GPIO_InitStructure;
    : R2 O; J0 x; O' J  A
20.     RCC_APB2PeriphClockCmd(    RCC_APB2Periph_GPIOA, ENABLE );    //使能GPIOA时钟
    # i4 Q2 b# B* C7 U3 C8 o+ p7 a1 g
21. 
    6 ^' S$ }0 h  d! t8 ]
22.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_12;
      ?) n; K% \& @' C# b
23.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
    
24.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    / L1 S8 @2 @) u! Q  [5 I5 v% Z/ v
25.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    
26.     GPIO_SetBits(GPIOA,GPIO_Pin_11|GPIO_Pin_12);     //PA11,PA12 输出高
    
27. }
    
28. /*--------------------------------------------------------------------------------
    
29. 调用方式：void I2CStart(void)
    1 |. o" v. _; ~% \- T
30. 函数说明：私有函数，I2C专用，开始信号
    
31. ---------------------------------------------------------------------------------*/
    + N: k" t# B' Y1 n$ X4 [* Q
32. void IIC_Start(void)
    8 |4 I: `9 |" J
33. {
    
34.     SDA_OUT();     //sda线输出
    2 g; {% }5 w2 l' `& R' i0 s% S# v2 m; o5 X! h
35.     IIC_SDA=1;
    & B7 o) Z3 r! x% S& O% u! R# a8 w
36.     IIC_SCL=1;
    - V& g5 y0 d# u- B* E( H
37.     delayUs(4);
    
38.      IIC_SDA=0;//START:when CLK is high,DATA change form high to low
    
39.     delayUs(4);
    # R& E6 J& B9 l- u
40.     IIC_SCL=0;  //钳住I2C总线，准备发送或接收数据
    
41. }
    
42. /*--------------------------------------------------------------------------------
    & f, g4 j6 \% O, Q( F
43. 调用方式：void I2CStop(void)
    , A0 n: k3 E) |
44. 函数说明：私有函数，I2C专用，停止信号
    " c' h7 l8 ^' z; O) Z
45. ---------------------------------------------------------------------------------*/
    
46. void IIC_Stop(void)
    
47. {
    & i2 Y9 P# L6 w+ {. G$ ~/ M$ d
48.     SDA_OUT();//sda线输出
    : E# h% V, ^" S; h, r0 a
49.     IIC_SCL=0;
    
50.     IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
    
51.      delayUs(4);
    
52.     IIC_SCL=1;
    
53.     IIC_SDA=1;//发送I2C总线结束信号
    : b4 _1 f' \( n9 ]3 ~) \
54.     delayUs(4);
    
55. }
    
56. /*--------------------------------------------------------------------------------
    ' t2 Z6 S% j" t. w8 L6 E7 t
57. 调用方式：I2CAck(void)
    7 ~8 j) ?8 P9 v+ r4 ?2 c# ~4 U
58. 函数说明：私有函数，I2C专用，等待从器件接收方的应答，0表示接受成功，1表示失败
    / Z. B- n- Y/ n. h$ h# R- k
59. ---------------------------------------------------------------------------------*/
    
60. uint8_t IIC_Wait_Ack(void)
    
61. {
    
62.     uint8_t ucErrTime=0;
    * j1 I" V! {0 q& u
63.     SDA_IN();      //SDA设置为输入
    
64.     IIC_SDA=1;delayUs(1);
    9 p) k  X  \, G
65.     IIC_SCL=1;delayUs(1);
    
66.     while(READ_SDA)
    
67.     {
    4 g/ `2 ?+ L4 d8 P% P, e# \% Z
68.         ucErrTime++;
    ; y; g8 n* ]( ^* |" q
69.         if(ucErrTime>250)
    : l% m* s4 K1 ?8 I4 P- r
70.         {
    
71.             IIC_Stop();
    
72.             return 1;
    
73.         }
    
74.     }
    
75.     IIC_SCL=0;//时钟输出0
    ' j( q) v4 ^. ?  [0 }6 d
76.     return 0;
    : x' J$ |1 ?3 k+ B7 y$ o) {7 ?
77. }
    
78. /*--------------------------------------------------------------------------------
    
79. 调用方式：void SendAck(void)
    
80. 函数说明：私有函数，I2C专用，主器件为接收方，从器件为发送方时，应答信号。
    2 e. g# d' t1 o* Z- F/ M8 B3 y% j
81. ---------------------------------------------------------------------------------*/
    8 R/ U0 W1 o, @; X6 G- I" z( R
82. void IIC_Ack(void)
    8 ?7 C8 ~5 z. l; j0 ~+ a7 S
83. {
    
84.     IIC_SCL=0;
    
85.     SDA_OUT();
    $ y( Z' N# }! l& t! B# z
86.     IIC_SDA=0;
    
87.     delayUs(2);
    , O* p$ H# h" Z$ A/ P
88.     IIC_SCL=1;
    , n- t) _- e; r) h" K, y
89.     delayUs(2);
    # V/ g9 {# y( j* y+ }
90.     IIC_SCL=0;
    
91. }
    
92. /*--------------------------------------------------------------------------------
    
93. 调用方式：void SendAck(void)
    
94. 函数说明：私有函数，I2C专用，主器件为接收方，从器件为发送方时，非应答信号。
    
95. ---------------------------------------------------------------------------------*/
    
96. void IIC_NAck(void)
    % G& j. C7 {) X; Q" N# Y1 p% K
97. {
    
98.     IIC_SCL=0;
    % _! [' j! _+ m% \! D
99.     SDA_OUT();
    + f0 a; {3 C% k. q9 J8 D
100.     IIC_SDA=1;
     
101.     delayUs(2);
     4 d  V) v2 J3 {7 R, \3 Q
102.     IIC_SCL=1;
     
103.     delayUs(2);
     
104.     IIC_SCL=0;
     8 K0 S1 l% \1 u7 @9 q0 i
105. }
     
106. /*--------------------------------------------------------------------------------
     3 e$ z" F) i$ }  c; i
107. 调用方式：void IIC_Send_Byte(unsigned char ch)
     
108. 函数说明：私有函数，I2C专用
     & @1 I+ m8 i0 r+ c8 w! y' w
109. ---------------------------------------------------------------------------------*/
     4 G8 N1 B( H5 a! e. q( V
110. void IIC_Send_Byte(uint8_t txd)
     + W4 m+ X; P! j. |4 i% w
111. {
     , Z, P+ K6 i1 |* p, F4 c2 ^; j
112.     uint8_t t;
     % Q# @  z' s) n9 @/ A5 |
113.     SDA_OUT();
     + U" }7 Q7 u' O0 b7 P4 A5 b- [# Y* s
114.     IIC_SCL=0;//拉低时钟开始数据传输
     
115.     for(t=0;t<8;t++)
     
116.     {
     + g& y2 _3 @& t  D; R6 y6 i+ y9 \: b1 W
117.         //IIC_SDA=(txd&0x80)>>7;
     0 e+ Q3 ~2 b0 z
118.         if((txd&0x80)>>7)
     0 d, }1 b: G, J4 r$ {) j
119.             IIC_SDA=1;
     
120.         else
     
121.             IIC_SDA=0;
     
122.         txd<<=1;
     
123.         delayUs(2);   //对TEA5767这三个延时都是必须的
     
124.         IIC_SCL=1;
     , V6 r; {7 N, X; U
125.         delayUs(2);
     
126.         IIC_SCL=0;
     * v  I. S! V% @. P9 \
127.         delayUs(2);
     
128.     }
     4 [5 q. z4 r  P- q% M
129. }
     
130. /*--------------------------------------------------------------------------------
     
131. 调用方式：unsigned char IIC_Read_Byte(void)
     
132. 函数说明：私有函数，I2C专用
     
133. ---------------------------------------------------------------------------------*/
     
134. //读1个字节，ack=1时，发送ACK，ack=0，发送nACK
     
135. uint8_t IIC_Read_Byte(unsigned char ack)
     
136. {
     
137.     unsigned char i,receive=0;
     
138.     SDA_IN();//SDA设置为输入
     7 E: e% _+ \8 q% ^- ?/ ^
139.     for(i=0;i<8;i++ )
     9 M" @) |% k8 y7 x9 H, r: f
140.     {
     
141.                 receive<<=1;
     : p2 s- s6 ^2 N/ P5 Y* }: a
142.         IIC_SCL=0;
     
143.         delayUs(5);
     
144.             IIC_SCL=1;
     7 _2 ]6 q- T: i7 F/ k& Z
145.                 delayUs(5);
     
146. 
     
147.         if(READ_SDA)receive++;
     
148. 
     & o+ J0 l8 Z  y6 c, G" W- R2 M
149.   }
     ) s, W; K$ o# a
150.     if (!ack)
     
151.         IIC_NAck();//发送nACK
     ; X' ]9 `  D) M& W" k
152.     else
     
153.         IIC_Ack(); //发送ACK
     ( s/ J% g* y9 F* w  v" e
154.     return receive;
     & y% u& {* t( u2 m2 g! \9 V* ^" N
155. }
     
156. 
     4 Z+ |4 [, D( V0 R) n5 E
157. 
     
158. //读温度传感器，温度值是由h的高字节和低字节的高四位组成，总共12位，其中负温度值是由补码形式
     & |( H3 _% f+ v- P" b# @. r$ z% ~
159. void T_Read(void)
     ( l7 A( K, |: U
160. {
     # `4 j/ {' O& |
161. 
     % q& `* ^0 [( C; z1 @! X
162.     /***************read start*******************/
     
163.     if(WR_flag==0x02)
     3 E# O" N; J6 ]6 ~
164.     {
     / l6 t8 ~% j1 M+ ?2 B! f
165. 
     1 r3 [6 J, {& T* v. |
166.     IIC_Start();
     : m7 g* U* f8 d$ N0 p# U4 h# S
167.         IIC_Send_Byte( 0x30|0x01);          //读操作
     1 S  [" ^9 u" `+ i9 F( |. }3 r
168.          while(IIC_Wait_Ack());
     9 _8 {! `/ h) T( e2 C2 s0 X
169.    //     delayMs(500);                         //等待从机处理一个字节地址位
     , I5 y0 j5 P! ]" ~
170.     Give_Up = IIC_Read_Byte(1);
     3 o4 r& U- B" ?) S" o9 w
171.         for(uint8_t i=0;i<4;i++)
     
172.         {
     
173.             b[i] = IIC_Read_Byte(1);
     ( I8 o6 n/ k! ^  [
174.             printf("%c",b[i]);
     
175.         }
     : _0 v" Z/ P; G2 k$ d
176.         b[4] = IIC_Read_Byte(0);
     : J2 a6 D+ [; `, |
177.         printf("%c",b[4]);
     
178. 
     
179.         if((b[0]==0xFA)&&(b[4]==0xFB))
     
180.         {
     
181.           for(uint8_t i=1;i<6;i++)
     
182.           {
     
183.               Cookr[i] = b[i];
     $ K3 K5 q1 b6 t8 p) A- T* L& l4 J
184.           }
     6 ]2 N+ C8 F  V" s
185. 
     
186.         }
     / Z7 B* c1 E" f/ x# B5 \7 H& s, {
187.     }
     / _# O* g: `* V% s  @" o
188. 
     
189.     /****************read end********************/
     ( B0 m+ @+ Q/ A. B
190.   /****************write start*****************/
     ; H/ b7 q* ]; @7 M
191.         if(WR_flag==0x01)
     8 D6 \3 H* o2 k" w
192.         {
     
193.             IIC_Start();
     . a) w1 v. z) W  _0 r- d) S
194.             IIC_Send_Byte(0x30);     //写操作
     
195.             while(IIC_Wait_Ack());
     
196.             IIC_Send_Byte(0xFA);
     # u" q$ M, d0 U' K) ?' v7 T' y
197.             while(IIC_Wait_Ack());
     . z5 S8 H0 W7 B, j8 W/ n3 D3 K
198.             delayMs(3);              //延时太低传输数据会出错,因为从机还没处理完数据
     
199.             IIC_Send_Byte(Cookr[1]);
     * O- x9 x' V7 w# h: }& ^
200.             while(IIC_Wait_Ack());
     
201.             delayMs(3);
     8 g- k. @" Y3 E' A) F
202.             IIC_Send_Byte(0x03);
     
203.             while(IIC_Wait_Ack());
     . ]" l- L2 @$ }# f& t2 i& U
204.             delayMs(3);
     
205.             IIC_Send_Byte(Power_flag);
     0 h9 r  J' x) [# z. K4 x; W; M
206.             while(IIC_Wait_Ack());
     4 @& X+ X4 l4 D+ Z# C; a. ?
207.             delayMs(3);
     
208.             IIC_Send_Byte(0xFB);
     
209.             while(IIC_Wait_Ack());
     " u0 C" E& q- w7 O1 |
210.             delayMs(3);
     
211.             IIC_Stop();
     5 |& c! F1 K4 x9 ?, \. c1 t
212.           WR_flag=0x02;
     
213.         }
     ! f$ Y% H) w1 ]8 j4 t7 z# ?$ d
214.         /***************write end*****************/
     
215. 
     & U! g% \# W  X$ Q9 [
216. }

复制代码

从机使用中断方式

1. #include "myiic.h"
   
2. #include "delay.h"
   
3. #include "led.h"
   
4. #include "key.h"
   
5. #include "usart.h"
   0 z8 S4 l/ }# a7 p# g
6. 
     ~4 E* ?" c: s0 E; d
7. 
   
8. #define MY_I2C_ADDRESS    0x30                         //模拟从机地址
     z: V1 }9 |0 U( z9 I! ~
9. unsigned char b[5]={0x00,0x00,0x00,0x00,0x00};         //从机接收操作
   ( [0 T. b  Z2 |7 a
10. uint8_t Wifi_Set=0x00;
    
11. extern u8 flag;                                        //电磁炉开关中断位
    " h/ |4 w2 l; N% Q
12. unsigned char a[5]={0xFA,0x00,0x00,0x00,0xFB};
    ! ~; p! ]) i# p9 `) n4 n" r; _
13. //初始化IIC
    
14. void I2C1_Init(void)
    , Q3 K/ k4 K2 P/ w0 V
15. {
    8 ?: `$ q5 i3 ?  a/ F6 o
16.     GPIO_InitTypeDef GPIO_InitStructure;
    $ D$ [. A% }6 B3 I9 J
17.     I2C_InitTypeDef I2C_InitStructure;
    
18.     NVIC_InitTypeDef NVIC_InitStructure;
    
19. 
    
20.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);   // enable APB1 peripheral clock for I2C1
    
21. 
    
22.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);  // enable clock for SCL and SDA pins
    0 }" W" X& C8 A" B& B" h% J% Y" H
23. 
    ' f, Z' W, A; U7 f" U! D2 i
24.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
    3 _1 z; V6 g6 i- Z& f% b1 y' k* `
25.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    & `2 x$ T( H- j# {- E+ ^
26.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;        //I2C必须开漏输出，实现线与逻辑
    5 y2 C& B9 H4 z( x, [* s* r
27.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    ! z) n  F$ Y) x
28. 
    2 G8 q. V* Y) T9 u* T7 |4 F
29. 
    
30.     I2C_InitStructure.I2C_ClockSpeed = 100000;             // configure I2C1
    
31.     I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
    6 n+ a" k  L! b# o( d# G
32.     I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
    . t$ }1 g8 C0 ?& O8 N1 m
33.     I2C_InitStructure.I2C_OwnAddress1 = MY_I2C_ADDRESS;
    $ e) I3 _: s7 J% U7 \
34.     I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
    , O6 w2 j2 w: d8 R1 w
35.     I2C_InitStructure.I2C_AcknowledgedAddress= I2C_AcknowledgedAddress_7bit;
    1 i( Q  q4 @- B+ E9 W" }5 a
36.     I2C_Init(I2C1, &I2C_InitStructure);
    
37. 
    4 r0 T$ }1 w' U7 _0 d
38.     //setup interrupts
    ) e/ r( d" R' e6 \4 a' q( c
39.     I2C_ITConfig(I2C1, I2C_IT_ERR | I2C_IT_EVT | I2C_IT_BUF, ENABLE);
    
40. 
    4 y# l( A4 W1 {& {1 \/ }8 L  o
41. 
    
42.     // Configure the I2C event priority
    
43.     NVIC_InitStructure.NVIC_IRQChannel                   = I2C1_EV_IRQn;
    + g  r: [9 Q$ B9 q
44.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;       //抢占优先级1
    ) Q5 c* z; O5 m0 K6 k3 N
45.     NVIC_InitStructure.NVIC_IRQChannelSubPriority        = 0;       //响应优先级0
    - z7 H3 a* s5 |0 a4 \" ^0 b( `+ A
46.     NVIC_InitStructure.NVIC_IRQChannelCmd                = ENABLE;
    
47.     NVIC_Init(&NVIC_InitStructure);
    % u# [4 Z+ W/ W( o% F, l- O
48. 
    8 E* c: a, p& z7 B1 d. p" K
49.     // enable I2C1
    2 T1 }6 u0 ^+ r$ l, C
50.     I2C_Cmd(I2C1, ENABLE);
    
51. }
    & A1 I5 a$ J, U# D7 k0 W  i
52. 
    # i$ g9 b& u3 ?  |& t
53. 
    
54. //Clear ADDR by reading SR1, then SR2
    / c* {7 y) X( G0 K! Y$ l
55. 
    
56. void I2C_clear_ADDR(I2C_TypeDef* I2Cx) {
    8 I* S, b* f- i$ {2 n2 @
57.     I2C_GetFlagStatus(I2Cx, I2C_FLAG_ADDR);
    
58.     ((void)(I2Cx->SR2));
    4 v. g" X* L: y2 I1 m5 P
59. }
    
60. 
    
61. //Clear STOPF by reading SR1, then writing CR1
    + r" j5 j+ L4 z* J
62. 
    
63. void I2C_clear_STOPF(I2C_TypeDef* I2Cx) {
    % C8 n- C+ S8 p2 r9 H+ h2 Y/ k4 Q
64.     I2C_GetFlagStatus(I2Cx, I2C_FLAG_STOPF);
    ' ?* G! v+ ?& _" W; t5 |
65.     I2C_Cmd(I2Cx, ENABLE);
    
66. }
    
67. 
    6 z$ M( W) P  g
68. /*--------------------------------------------------------------------------------
    9 Z9 ~8 l! R0 L
69. 调用方式：void I2C1_EV_IRQHandler(void)
    * m6 d8 ]7 d1 Y, k
70. 函数说明：私有函数，I2C专用，中断按键处理函数，从机中断都在这里面执行
    
71. ---------------------------------------------------------------------------------*/
    
72. 
    % E/ [" G5 r- v  I- F& ~
73. uint8_t data = 0;
    
74. uint8_t S_data=0;
    # @  g( z0 c7 f# e
75. void I2C1_EV_IRQHandler(void)
    
76. {
    ) t7 r/ a9 x2 G3 h( H
77. //        KV1=0;                                 //只是一个测试灯
    . E8 s6 x" Z* W1 ^: q/ `* g: V4 F# ^% o
78.         //Clear AF from slave-transmission end
    8 y+ E# ^" x: b+ g  L9 g
79.         if(I2C_GetITStatus(I2C1, I2C_IT_AF))
    
80.         {
    2 r5 J3 b! Q# F
81.             I2C_ClearITPendingBit(I2C1, I2C_IT_AF);
    # h! E2 b+ z; @" x- B+ w
82.         }
    
83.         //Big state machine response, since doesn't actually keep state
    
84.         switch(I2C_GetLastEvent(I2C1))
    
85.             {
    6 j6 r& D8 ~/ a9 e
86.             //SLAVE
    . E& f7 i1 \& @9 [
87.             //Receive
    $ m2 e; s/ I; |5 e5 c3 [$ ~
88.             case I2C_EVENT_SLAVE_RECEIVER_ADDRESS_MATCHED: //EV1
    3 d& J0 O% J! t% b% v
89.                 I2C_clear_ADDR(I2C1);
    
90.                 break;
    . J/ @. g) }- w3 J5 n  I
91.             case I2C_EVENT_SLAVE_BYTE_RECEIVED: //EV2
    
92.                 //Read it, so no one is waiting, clears BTF if necessary
    
93.                 b[data] = I2C_ReceiveData(I2C1);
    
94.         //      printf("%c",b[data]);
    ' |7 W* x# l, |7 F: z. K/ I& A! z
95.                 data++;
    / x; y: U1 D7 I; e6 @" f# p
96.                 if(data>=5)
    
97.                 {
    
98.                                 data=0;
    
99.                                 if((b[0]==0xFA)&&(b[4]==0xFB))
    " U5 ^% D2 d/ [( B+ |+ m
100.                                 {
     8 V, y4 W/ \  h% ~- `3 u
101.                                     a[1]=b[1];
     
102.                                     Wifi_Set=b[2];
     
103.                                     flag=b[3];
     3 X) L0 d% z, \: U9 x
104.                 //                    printf("%c",a[1]);
     
105.                                 }
     + P/ `. M% r! O% m. R
106. 
     , R3 P0 j, }- L% N
107.                 }
     8 o, n) {+ |$ _* F; U' s
108.                 if(I2C_GetFlagStatus(I2C1, I2C_FLAG_DUALF))
     
109.                 {//Secondary Receive
     ) d; @* i2 X; M! ]: \
110.                 }
     5 X! h; Q3 k. v% }' v' E& I8 {. P( g/ E
111.                 else if(I2C_GetFlagStatus(I2C1, I2C_FLAG_GENCALL))
     1 F2 u: E) L5 c: [4 M3 M! r" _
112.                 {//General Receive
     9 a4 [6 h8 x- R) Q* J2 Z6 c8 A
113.                 }
     
114.                 else
     
115.                 {//Normal
     0 c/ ]) N8 M. V4 p0 R% E7 g5 h
116.                 }
     
117.                 break;
     
118.             case I2C_EVENT_SLAVE_STOP_DETECTED: //End of receive, EV4
     + m" l  X1 |( F
119.                 I2C_clear_STOPF(I2C1);
     
120.                 break;
     3 H& s  `3 u# U. a( Y  K
121. 
     
122.             //Transmit
     
123.             case I2C_EVENT_SLAVE_TRANSMITTER_ADDRESS_MATCHED: //EV1
     ' H4 [/ A. _' P, K. d- k
124.                 I2C_clear_ADDR(I2C1);
     - ^% e2 q; q4 }$ `
125.                 //Send first byte
     / ~: @- ~; Z7 S; M3 V; }
126.                I2C_SendData(I2C1, 0x00);
     
127. 
     / n+ M5 {: Z, Y! O& Y0 A
128.                 break;
     " c2 o/ H3 O# s; h& ]: m6 W
129.             case I2C_EVENT_SLAVE_BYTE_TRANSMITTED: //EV3
     
130.                 //Determine what you want to send
     % V; C5 t, G: h/ `/ c: Q
131.                 //data = 5;
     
132.                 if(I2C_GetFlagStatus(I2C1, I2C_FLAG_DUALF))
     
133.                 {//Secondary Transmit
     
134.                 }
     
135.                 else if(I2C_GetFlagStatus(I2C1, I2C_FLAG_GENCALL))
     - c) L9 W3 P$ _4 k
136.                 {//General Transmit
     
137.                 }
     7 e. K7 p4 D' q$ [# n4 j9 t# h
138.                 else
     6 B- w- x6 \! V  h" x8 y
139.                 {//Normal
     
140.                 }
     / V- Y' M1 r$ Z: v0 G7 u! A
141.                 //Read flag and write next byte to clear BTF if present
     ! P* y' g9 `$ i( y% z: i7 m
142.                 I2C_GetFlagStatus(I2C1, I2C_FLAG_BTF);
     
143.                 I2C_SendData(I2C1, a[S_data]);
     * N/ O! ]" C% [8 K
144.                 S_data++;
     ; w/ |, G+ w8 I  w
145.                 if(S_data>=5)
     # x; w: ^. ~  }. i6 w  Q- [8 {
146.                 S_data=0;
     8 k; W. y: o7 R. w9 p0 ?7 a, o
147.                 break;
       U1 W7 M5 P$ Z8 T0 [5 U4 ], {) q
148.             case I2C_EVENT_SLAVE_ACK_FAILURE://End of transmission EV3_2
     5 M/ j/ X. \$ J) z; q
149.                 //TODO: Doesn't seem to be getting reached, so just
     
150.                 //check at top-level
     1 o/ D2 ?8 `. g5 |: z& z( L
151.                 I2C_ClearITPendingBit(I2C1, I2C_IT_AF);
     7 l: m! D! ?, E3 N5 m  D5 u! J/ b
152.                 break;
     
153.             //Alternative Cases for address match
     
154.             case I2C_EVENT_SLAVE_RECEIVER_SECONDADDRESS_MATCHED:    //EV1
     
155.                 break;
     
156.             case I2C_EVENT_SLAVE_TRANSMITTER_SECONDADDRESS_MATCHED: //EV1
     
157.                 break;
     
158.             case I2C_EVENT_SLAVE_GENERALCALLADDRESS_MATCHED:        //EV1
     
159.                 break;
     ! u  Z2 {3 _5 @' j/ c$ h6 y
160. 
     
161. 
     ( _, f7 y& k" ^& m; j  _; f( d
162.             //MASTER
     
163.             case I2C_EVENT_MASTER_MODE_SELECT: //EV5, just sent start bit
     ; B3 b( @' _% Q% ^* p
164.                 break;
     3 t6 c8 O2 w: q! `1 Z
165.             //Receive
     
166.             case I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED: //EV6, just sent addr
     # `- O2 F* u1 Y9 L
167.                 break;
     , g) k0 Y' q( T% ~3 P, B9 y
168.             case I2C_EVENT_MASTER_BYTE_RECEIVED: //EV7
     
169.                 break;
     
170.             //Transmit
     
171.             case I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED: //EV6, just sent addr
     " I8 X# X: c  d" F
172.                 break;
     . a# {, P/ l) u
173.             case I2C_EVENT_MASTER_BYTE_TRANSMITTING: //EV8, about to send data
     / K6 @% \4 C" b7 O
174.                 break;
     
175.             case I2C_EVENT_MASTER_BYTE_TRANSMITTED: //EV8_2, just sent data
     
176.                 break;
     
177. 
     
178.             //Alternative addressing stuff, not going to worry about
     
179.             case I2C_EVENT_MASTER_MODE_ADDRESS10: //EV9
     
180.                 break;
     
181.             default:
     
182.                 //How the FUCK did you get here?
     : L! Z! R/ r  C9 T
183.                 //I should probably raise some error, but fuck it,
     7 E5 J# f. q% V$ w
184.                 //it's late
     
185.                 break;
     
186. 
     
187.         }
     
188. 
     3 t; B) R" L5 j
189. 
     
190. }
     
191. 
     
192. void I2C1_ER_IRQHandler(void) {
     - k* B2 e. ~8 E
193. //       GPIO_SetBits(GPIOD, RED);
     # d1 o2 g% J! a
194. //    LED3=0;
     % A1 |  v) z5 b( c) U
195.         //Can't use nice switch statement, because no fxn available
     
196.         if(I2C_GetITStatus(I2C1,        I2C_IT_SMBALERT)) {
     ! Z1 H# N$ ?: v6 F5 h, M+ H
197.         } else if(I2C_GetITStatus(I2C1, I2C_IT_TIMEOUT)) {
     ) I' N8 m5 s  a& F# J
198.         } else if(I2C_GetITStatus(I2C1, I2C_IT_PECERR)) {
     
199.         } else if(I2C_GetITStatus(I2C1, I2C_IT_OVR)) {
     6 c$ R0 V4 K- q  P0 u
200.             //Overrun
     4 L1 P9 T8 j2 \! T2 W' U, X
201.             //CLK stretch disabled and receiving
     - ]+ f2 h1 L2 w8 i- s, I
202.             //DR has not been read, b4 next byte comes in
     
203.             //effect: lose byte
     ! |  D$ @+ w6 V" Y8 O5 i, m% a
204.             //should:clear RxNE and transmitter should retransmit
     
205. 
     
206.             //Underrun
     
207.             //CLK stretch disabled and I2C transmitting
     
208.             //haven't updated DR since new clock
     
209.             //effect: same byte resent
     0 C8 q8 s# n; ^" q! ^' T" F5 ?
210.             //should: make sure discarded, and write next
     
211.         } else if(I2C_GetITStatus(I2C1, I2C_IT_AF)) {
       X5 Z# z& t$ e" ]7 T* A& Q+ W
212.             //Detected NACK
     
213.             //Transmitter must reset com
     
214.                 //Slave: lines released
     
215.                 //Master: Stop or repeated Start must must be generated
     
216.                 //Master = MSL bit
     3 `: c9 V  |& [+ B$ Z$ C( f
217.             //Fixup
     , h$ h. i7 f+ D. F) e8 n+ D
218.             I2C_ClearITPendingBit(I2C1, I2C_IT_AF);
     : z# t' O4 J! s$ o) O, K
219.         } else if(I2C_GetITStatus(I2C1, I2C_IT_ARLO)) {
     
220.             //Arbitration Lost
     
221.             //Goes to slave mode, but can't ack slave address in same transfer
     
222.             //Can after repeat Start though
     ) X; l9 c! }( n3 ^
223.         } else if(I2C_GetITStatus(I2C1, I2C_IT_BERR)) {
     
224.             //Bus Error
     / ^# a: h) y% y
225.             //In slave mode: data discarded, lines released, acts like restart
     
226.             //In master mode: current transmission continues
     
227.         }
     
228. }

复制代码

  q) e; E5 `1 x' M& U& W
  A: z  o/ d/ D; {  r  ^