今天在这里贴一个今天写的IIC读AT24C02的帖子
2 L( w: @+ ]! D) X

1. #include "stm32f10x_i2c.h"
   
2. #include "iic.h"
   " z0 w2 y: D2 X$ B  g5 v
3. #include "stdio.h"
   
4. 
   / y' u: K; m  u" C' i
5. #define I2C_Speed  400000
   
6. #define I2C1_SLAVE_ADDRESS7 0XA0
   ; E- z" H; b1 H6 y# p: q8 g5 a
7. #define I2C_PageSize 8
   ) B9 f9 R, a- l$ M
8. 
   
9. u16 EEPROM_ADDRESS;
   $ G) i4 d  i6 _" C/ i8 q9 e
10. 
    8 O4 K: H; Y5 K
11. 
    
12. 
    . d0 {0 F: F) U2 v
13. void GPIO_Configuration(void)//GPIO_Pin_6，GPIO_Pin_7复用开漏输出
    
14. {
    . F$ i3 R5 C7 @* x
15.         GPIO_InitTypeDef  GPIO_InitStructure;
    
16.        
    5 v( P& f" @1 Z! \
17.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1,ENABLE);//IIC1 和 IIC2 都是在APB1上的
    
18.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);//SCL 和 SDA
    . d6 `/ S; a- i; Y. n
19.        
    
20.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;// GPIO_Pin_6(SCL) GPIO_Pin_7;
    
21.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//
    & \8 r! r# \2 w
22.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;//IIC 的 SDA和SCL都是复用开漏输出模式
    ) C- f! P; S8 l" k" l" q4 m5 Q: F
23.         GPIO_Init(GPIOB,&GPIO_InitStructure);
    & d2 J& X3 {* [# P" G3 q
24. }
    . }7 a+ v& d- m. ?
25. 
    & ~7 F7 L6 K+ H
26. void I2C_Configuration(void)
    , k# T& F  z- j! J& W) c
27. {
    9 D1 `! i/ @+ ?  Y
28.         I2C_InitTypeDef  I2C_InitStructure;
    $ q3 L. Y" A" T: Q8 F8 T3 z
29.        
    1 g7 {6 u# d* B
30.         I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;//设置IIC是IIC模式;
    * z! d. Q# i" n# Y; e
31.         //IIC 的 工作模式有两种的，一种是IIC 一种是SMBus模式
    
32.         I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;//
    
33.         /*本成员设置的是I2C的SCL线时钟的占空比。SCL线的时钟信号的高电平时间
    - b" V- o+ O- E* e
34.     与低电平时间是没必要相同的，由于SDA线是在SCL线维持在高电平时读取或写入数据的，而在SCL的
    + T5 o+ x& |/ |7 `% ?2 B
35.     低电平期间SDA的数据发生变化，所以高电平时间较长就不容易出现数据错误。根据I2C协议，在快速
    
36.     模式和高速模式下SCL的高低电平时间可以不同。在STM32的I2C占空比配置中有两个选择，分别为高
    
37.     电平时间比低电平时间为16：9 (I2C_DutyCycle_16_9)和2：1 ( I2C_DutyCycle_2)。 本实验中使用
      ^  I, O9 x" ^; o+ w
38.     的是I2C_DutyCycle_2*/
    $ S. Q8 w+ u$ L/ I0 A' p+ x
39.         I2C_InitStructure.I2C_OwnAddress1 = 0;//这个是STM32 本身的地址，可以随便设置，它是作为主设备的，但是如果作为从设备的话，设定的地址，就必须
    
40.         //作为主设备进行寻地址的地址了
    + U: H" \& a3 E
41.         I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;//
    
42.         /*
    
43.             本成员是关于I2C应答设置，设置为使能则每接收到一个字节就返回一个应
    
44.       答信号。 本实验配置为允许应答(I2C_Ack_Enable)，这是绝大多数遵循I2C标准的设备通讯的要求，
    
45.       改为禁止应答(I2C_Ack_Disable)往往会导致通讯错误
    
46.         ***************/
    
47.         I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    
48.         //本成员选择I2C的寻址模式是7位还是10位地址
    8 m0 X" @$ O3 `3 l
49.         I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;
    
50.         /*
    ; W+ ]$ l" ^1 |' v# b# q6 D
51.             本成员设置的是I2C的传输速率，在调用初始化函数时，函数会根据我们输
    7 v$ B! g( y3 n
52.       入的数值经过运算后把分频值写入到I2C的时钟控制寄存器。而我们写入的这个参数值不得高于
    
53.       400KHz。**************/
    
54.        
    0 \9 ~3 t/ [- W
55.         I2C_Init(I2C1,&I2C_InitStructure);//初始化
    ! V# _5 U$ T. E# H; G5 @; g) B
56.        
    
57.         I2C_Cmd(I2C1,ENABLE);//使能I2C1;
    5 Y; k0 m: n9 ~3 W0 M4 Z
58. 
    
59.         printf("\n\r I2C_Configuration----\r\n");
    
60.        
    " C- ^! h) m9 B# u7 G
61. }
    
62. 
    
63. void I2C_EE_Init(void)
    
64. {
    
65.         GPIO_Configuration();
    
66.        
    
67.         I2C_Configuration();
    
68.        
    
69. #ifdef EEPROM_Block0_ADDRESS
    / m% p/ [& Z/ t
70.         EEPROM_ADDRESS = EEPROM_Block0_ADDRESS;
    . W, Y6 u0 h3 G! B5 K
71.         //0xA0
    * c+ Y- D/ n( I6 o: {
72. #endif
    4 Z1 V4 A! D; @! K8 i5 D
73. #ifdef EEPROM_Block1_ADDRESS
    9 Q$ U, ?) v2 P5 Q9 ^2 V' j
74.         EEPROM_ADDRESS = EEPROM_Block1_AFFRESS;
    1 X3 O, \8 f) o3 t: ^! ~
75.         //0XA2
    
76. #endif
    
77. #ifdef EEPROM_Block2_ADDRESS
    
78.         EEPROM_ADDRESS = EEPROM_Block2_ADDRESS;
    8 M& ~6 {  S9 Q1 }0 k8 X
79.         //0XA4
    0 }- h3 O! g& }0 Y# F" V6 _
80. #endif
    : w9 ?& b2 N4 x- \5 [
81. #ifdef EEPROM_Block3_ADDRESS
    
82.         EEPROM_ADDRESS = EEPROM_Block3_ADDRESS;
    * h. g# w& U6 q0 Q% T
83.         //0XA6
    & h9 F6 U. A9 z1 B
84. #endif
    ' `, n- u3 ~. a( H
85. }
      h  }, t/ L; ~
86. /*********************
    
87. 
    
88. 1:这个的思想就是先看看你的字节数是不是够你的1page的大小;
    
89. 2:然后再去看看你设置的需要写的字节的位置
    
90. 3:看看你需要写的这一页的还需要多少字节才能写完
    
91. 4:最后就是去分析了;
    ' C! F5 a5 i! V0 V1 V
92. ******************/
    ' L* e* X" V2 i- l( K" k0 }9 a
93. //NumOfPage 是指你需要写的字节一共需要占用的的页数
    0 i. L: H8 C: c) y# `) Z
94. //NumOfSingle 是指你需要写的字节写完完整的页数以后还剩下多少字节数
    
95. //Addr 是你要写的第一个字节的位置
    3 h3 n" o4 u' D5 m3 S9 [
96. //count 是你要写完一页page 的个数;
    9 g; N' A4 v' l. B+ }/ k
97. //注意你写完一page的时候,他的地址会自动变成0的，没写完一页page 的时候，他的地址会自动累加这是一个很重要的特性
    
98. void I2C_EE_BufferWrite(u8* pBuffer,u8 WriteAddr,u16 NumByteToWrite)
    4 X+ }' Z! u4 V0 `
99. {
    
100.         u8 NumOfPage = 0,NumOfSingle = 0,Addr = 0,count = 0;
     ( M" ^; @0 Z3 L+ b% a# `$ q' ?0 U
101.   Addr = WriteAddr % I2C_PageSize;//把首个字节的位置找出来
     ( m* G5 r* Z* c# h! N% `( {
102.         count = I2C_PageSize - Addr;//把写完该页page的个数找出来
     
103.         NumOfPage = NumByteToWrite / I2C_PageSize;//找出你要写的数据能占几页page
     2 H7 c- t7 M: x! P. K
104.         NumOfSingle = NumByteToWrite % I2C_PageSize;//找出写完page以后还剩多少个字节
     
105.        
     
106.         if(Addr == 0)//如果上来要写的位置是某一个page 的 第一个位置
     
107.         {
     
108.                 if(NumOfPage == 0)//如果要写的字数小于一页page 所需要的大小
     4 I* }. ~! S0 l0 n! s
109.                 {
     , y2 {1 B# K  r' @
110.                         I2C_EE_PageWrite(pBuffer,WriteAddr,NumOfSingle);//直接开始从page 写
     ' Y& `$ [  e& l1 E; z0 U
111.                         I2C_EE_WaitEepromStandbyState();//等待发送成功;
     
112.                 }
     $ n- N+ b$ C* n. q2 L$ P* T1 [
113.                 else
     
114.                 {
     & Y; w6 Q2 C5 v: w# h
115.                         while(NumOfPage--)//如果page >0 那就写完page
     8 f7 D. i7 G7 C6 H3 A) g
116.                         {
     : F0 ?4 ~: ?4 C1 S5 ~5 k- I( \+ h; }
117.                                 I2C_EE_PageWrite(pBuffer,WriteAddr,I2C_PageSize);//写一页page
     5 X3 r) L; R6 O" D. o& a) W: w1 m
118.                                 I2C_EE_WaitEepromStandbyState();//等待这一页的数据发送完成
     
119.                                 WriteAddr += I2C_PageSize;//把地址进行累加
     
120.                                 pBuffer += I2C_PageSize;//字符往后加
     . U% C2 M4 c) X( {& ]
121.                         }
     
122.                         if(NumOfSingle!=0)//写完你要写的page 以后如果还有写的数据
     
123.                         {
     
124.                                 I2C_EE_PageWrite(pBuffer,WriteAddr,NumOfSingle);//将剩下的字符写进去
     $ D* g3 |0 w" J
125.                                 I2C_EE_WaitEepromStandbyState();//等待数据发送完成
     
126.                         }
     4 W, z* D9 L6 I/ L/ z& o, t
127.                 }
     
128.         }
     - u+ a; c; ^6 g9 w# F+ P5 n- ?
129.         else
     
130.         {
     
131.                 if(NumOfPage == 0)//要写的字符数小于一page
     
132.                 {
     
133.                         if(NumOfSingle < count)//如果写的数还不够写完1page的数的话
     1 z# o4 k& e" b( r% K
134.                         {
     8 z  T# J7 d7 [3 K* w( F- {" t/ c
135.                                 I2C_EE_PageWrite(pBuffer,WriteAddr,NumOfSingle);//直接写进去
     : X2 z0 s# y8 G. d0 m
136.                           I2C_EE_WaitEepromStandbyState();//等待这一页的数据发送完成
     
137.                         }
     
138.                         else//如果要写的数据大于写完这一页的字数
     
139.                         {
     ( r- K! S# ]- J0 T0 a
140.                                 I2C_EE_PageWrite(pBuffer,WriteAddr,count);//先把这一页写完
     6 j$ p' n7 x. I, A/ ^
141.                           I2C_EE_WaitEepromStandbyState();//等待数据发送完成
     
142.                                 WriteAddr += count;//将地址累加
     
143.                                 pBuffer += count;//
     . K( L( N2 b7 m6 X# _' a
144.                                 I2C_EE_PageWrite(pBuffer,WriteAddr,NumOfSingle-count);//再去写完剩下的字节数
     
145.                           I2C_EE_WaitEepromStandbyState();//等待数据完成
     : C8 O$ _: W6 p' J/ b3 T
146.                   }
     
147.                 }
     6 s; s. H. ~3 C) w, B* F
148.                 else//如果要写的数据大于一page
     . K" p; `( q# u3 j
149.                 {
     # h9 R9 V& h9 ^/ o) A
150.                         NumByteToWrite -= count;//这个是写完本页剩下的字节数
     ! _" w- f) l: Z7 @# Q9 f) W2 C
151.       NumOfPage = NumByteToWrite /         I2C_PageSize;//这个是还剩下的数据所占有的页数
     3 D6 p* V$ _3 U9 B, M/ t2 Y$ n& k2 m
152.       NumOfSingle = NumByteToWrite % I2C_PageSize;//剩下的数据写完页数以后还剩下的字节数
     
153.       if(count != 0)//如果要写完一页需要的字节数不是0；
       y  m, c5 t4 q* i' u+ g8 T9 E
154.                         {
     5 I" N% n, E* A' G) K" y- C
155.         I2C_EE_PageWrite(pBuffer,WriteAddr,count);//先把这一页写完
     ! r0 R1 f* r. e" s" u/ }1 O$ `
156.         I2C_EE_WaitEepromStandbyState();
     & v7 ]$ d+ g$ m5 N+ l! X+ j8 w# B
157.         WriteAddr += count;
     
158.         pBuffer += count;
     
159.                         }
     
160.                         while(NumOfPage--)//写完剩下的page
     ) Y; M* i, F6 p4 w+ S) F  D  J
161.                         {
     9 m1 o0 q6 m9 N/ _
162.                                 I2C_EE_PageWrite(pBuffer,WriteAddr,I2C_PageSize);
     , D3 A+ t; f/ E/ d, j
163.                                 I2C_EE_WaitEepromStandbyState();
     - Z! Y! Z2 C8 S0 ~
164.                                 WriteAddr += I2C_PageSize;
     2 l& c& U, T9 q% c# n! b
165.                                 pBuffer += I2C_PageSize;
     
166.                         }
     
167.                         if(NumOfSingle != 0)//将最后的字节写进去
     , {2 h- o, I% v& c$ t
168.                         {
     
169.                                 I2C_EE_PageWrite(pBuffer,WriteAddr,NumOfSingle);
     
170.                                 I2C_EE_WaitEepromStandbyState();
     ' w" w- l/ s; [2 R" n8 r
171.                         }
     
172.                 }
     
173.         }
     & `* V  f' \1 {$ |2 g! T
174. }
     
175. 
     - ~5 ]+ b# S* Q
176. 
     
177. 
     
178. /*
     
179. 
     
180.     IIC通信的步骤;
     4 Y  O* A  ]5 a* W0 X  \* d
181. 1:首先要等待总线BUSY = 0;
     . X  [3 H7 O9 M: B/ m' e& u4 |
182. 2:产生一个开始的信号;然后等待EV5;
     3 @- \/ M; I9 p* W* k. |4 |
183. 3:发送一个地址;然后等待EV6;
     
184. 4:发送数据;等待EV8;
     
185. 5:发送STOP;
     
186. 这是通信一次的步骤;
     ( c' u' `4 w: r4 G$ }
187.       ******/
     
188. void I2C_EE_ByteWrite(u8* pBuffer,u8 WriteAddr)//给EPPROM写一个字节
     . e2 ]5 V1 I$ a* ^- k
189. {
     # L& J5 W& O$ Y
190.         while(I2C_GetFlagStatus(I2C1,I2C_FLAG_BUSY));//等待IIC忙结束
     
191.        
     
192.         I2C_GenerateSTART(I2C1,ENABLE);//产生开始信号
     9 O3 t4 u& k" I9 J/ T7 d% @8 V
193.         // I2C_ CheckEvent()  检查最近一次 I2C 事件是否是输入的事件
     
194.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_MODE_SELECT));//等待EV5;
     ! {  ~. d& B9 ~% q( V
195.        
     
196.         I2C_Send7bitAddress(I2C1,EEPROM_ADDRESS,I2C_Direction_Transmitter);//配置成发送方向和发送的外设地址
     
197.        
     
198.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));//等待EV6
     
199.        
     ' R  C5 [. F7 C8 R
200.         I2C_SendData(I2C1,WriteAddr);//发送第一个数据(这里其实第一个数据是给EPPROM写地址)
     
201.        
     1 f) k; _- c4 Y$ c- o+ N( T" H. |7 Y
202.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED));//等待EV8
     $ H/ h6 k( b! }* R
203.        
     : C2 }- J) |2 U5 J
204.         I2C_SendData(I2C1,*pBuffer);//发送你要写的数据
     
205.        
     
206.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED));//等待EV8
     ( L1 S1 a  ?3 ~& r. ~
207.        
     . g, Y$ e, t2 c+ E: m) @
208.         I2C_GenerateSTOP(I2C1,ENABLE);//产生停止信号
     
209. }
     
210. 
     
211. 
     
212. void I2C_EE_PageWrite(u8* pBuffer,u8 WriteAddr,u8 NumByteToWrite)//写一个EPPROM 的 Page
     
213. {
     
214.         while(I2C_GetFlagStatus(I2C1,I2C_FLAG_BUSY));//等待IIC忙结束
     : m. d  O$ b% }% y1 o; q9 A
215.        
     0 e* F; e) ?4 [7 C6 o% h
216.         I2C_GenerateSTART(I2C1,ENABLE);//这个是产生开始信号
     
217.        
     % `. r, r& P% f
218.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_MODE_SELECT));//等待EV5
     
219.        
     
220.         I2C_Send7bitAddress(I2C1,EEPROM_ADDRESS,I2C_Direction_Transmitter);//设置发送方向以及发送的地址
     
221.        
     
222.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));//等待EV6(这里的EV6和EV8一块了,主要是因为这里的速度确实快)
     
223.        
     
224.         I2C_SendData(I2C1,WriteAddr);//发送第一个数据(这个其实就是给EPPROM写地址)
     , Y' ?- n  t) J( v: c% N9 E
225.        
     
226.         while(! I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED));//等待EV8
     + U3 z5 d, f* ]- b+ K
227.        
     
228.         while(NumByteToWrite--)//写数据
     4 I- B3 B/ ^: _( R0 Z5 C1 p
229.         {
     - u4 \- a# @* N# _& B
230.                 I2C_SendData(I2C1,*pBuffer);
     
231.                
     ( j+ u, t5 I5 x- ~; |' c0 w
232.                 pBuffer++;
     
233.                
     / v' f3 f. t+ T/ h1 Q" k
234.                 while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED));//等待EV8
     
235.         }
     
236.        
     : h2 U, g: H: z& j( P4 Y
237.         I2C_GenerateSTOP(I2C1,ENABLE);//产生停止信号
     
238. }
     : J- _" d  B% {6 j8 x; V# P
239. 
     
240. 
     
241. 
     * Y8 h0 \* Z3 c) S$ i
242. 
     
243. 
     2 b0 b8 k. \0 [2 F7 }$ l
244. void I2C_EE_BufferRead(u8* pBuffer,u8 ReadAddr,u16 NumByteToRead)//读NumByteToRead个EPPROM的字节
     " W: U5 U$ g: |# j! G9 t+ q
245. {
     # M' ~, Z+ @$ O, p1 n& ^5 Q
246.         while(I2C_GetFlagStatus(I2C1,I2C_FLAG_BUSY));//等待BUSY = 0;
     " _7 z* M9 C+ s6 \' z
247.        
     
248.         I2C_GenerateSTART(I2C1,ENABLE);//产生一个开始信号
     
249.        
       O3 p$ W9 u' e4 f8 i  Y
250.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_MODE_SELECT));//等待EV5
     1 W5 T8 O4 e' y( \5 l# G
251.        
     
252.         I2C_Send7bitAddress(I2C1,EEPROM_ADDRESS,I2C_Direction_Transmitter);//发送一个外设地址
     ( T0 K& v% Q4 w# ~) K; }
253.        
     
254.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));//等待VE6;
     7 e  T/ z+ ~3 F% q0 e# t  g
255.        
     
256.         I2C_Cmd(I2C1,ENABLE);//使能外设
     $ G' m! `' U% r! L% h6 _
257.        
     
258.         I2C_SendData(I2C1,ReadAddr);//发送一个数据(这个就是你要读的数据的地址)
     2 t" l/ M9 `4 X( B) I. J
259.        
     5 Q& a. {; a( C/ _8 W
260.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_TRANSMITTED));//EV8
     
261.        
     + P9 J% M* z+ {, O( }% p0 \3 E
262.         I2C_GenerateSTART(I2C1,ENABLE);//发送一个开始信号
     ) Z" L& m; B+ Y! ^# J& E% S
263.        
     
264.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_MODE_SELECT));//EV5
     
265.        
     
266.         I2C_Send7bitAddress(I2C1,EEPROM_ADDRESS,I2C_Direction_Receiver);//发送一个数据,加一个方向（这个就是读的方向)
     $ b* D% \! @8 g% s5 B3 W0 y8 I) c
267.        
     ) v: p! P. M1 t7 q/ w
268.         while(!I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));//EV6
     
269.        
     
270.         while(NumByteToRead)//剩下的就是读数据了
     
271.         {
     
272.                 if(NumByteToRead == 1)//只有当最后一个数据的时候，才不会去应答,其他读的数据的时候需要去应答
     ; n) A( T8 I7 Y  y; J5 K
273.                 {
     
274.                         I2C_AcknowledgeConfig(I2C1,DISABLE);//最后一个传输的数据不需要响应
     
275.                         I2C_GenerateSTOP(I2C1,ENABLE);
     
276.                 }
     4 M# z  b0 ~* @7 B& l
277.                 if(I2C_CheckEvent(I2C1,I2C_EVENT_MASTER_BYTE_RECEIVED))//EV7
     1 c  k* N7 [. |7 }, z
278.                 {
     / K1 t8 D  y3 k* L3 v5 {6 M
279.                         *pBuffer = I2C_ReceiveData(I2C1);
     
280.                         pBuffer++;
     / q* N8 t; B% q& p" B: x; x
281.                         NumByteToRead--;
     ! C7 B: k, }. e  r/ p; j3 Q
282.                 }
     ) J2 V" Y  {6 b5 [+ G7 N& @4 ?
283.         }
     ! \1 I" G# Y& ?# f) I  V. v
284.         I2C_AcknowledgeConfig(I2C1,ENABLE);//把硬件自动应答打开
     
285. }
     
286. 
     4 x  O; u2 d9 t" T) ^* O! E
287. 
     . O4 `# l* `1 ?( L; w
288. 
     9 x$ b! H! c. @6 x( ]
289. void I2C_EE_WaitEepromStandbyState(void)
     
290. {
     ' \  ]; G& f- Z3 g) g
291.         vu16 SR1_Tmp = 0;
     
292.         do
     
293.         {
     * s7 n# p' {% m, b6 _/ ?9 K# `
294.                 I2C_GenerateSTART(I2C1,ENABLE);//产生一个开始的信号;
     : M" ^% ]& {: L6 S! Z* p( `- |
295.                
     5 @& h* C3 `5 C; X- M1 r+ w8 K, e
296.                 SR1_Tmp = I2C_ReadRegister(I2C1,I2C_Register_SR1);//
     9 f) k' z( O* Z" u+ d" m
297.                
     
298.                 I2C_Send7bitAddress(I2C1,EEPROM_ADDRESS,I2C_Direction_Transmitter);
     8 Q' U* {( n4 W$ z/ \' f% l0 A) q3 f
299.         }
     
300.         while(!(I2C_ReadRegister(I2C1,I2C_Register_SR1) & 0x0002));//这个是判断你发送的数据成功没成功
     ( @2 j. R: {! r+ C* M" ^
301.        
     1 q1 i. U& o' U# h" A
302.        
     
303.         I2C_ClearFlag(I2C1,I2C_FLAG_AF);//清除应答错误标志位
     
304.        
     
305.         I2C_GenerateSTOP(I2C1,ENABLE);
     , z3 {5 _) G# g. h0 y" i/ B
306. }
     2 l, v+ H+ I9 A) Z4 T' k
307. 
     ( V4 ?. b  X3 j+ y
308. void I2C_Test(void)
     
309. {
     
310.         u16 i;
     
311.         u8 I2c_Buf_Write[256];
     ( `: _+ d8 g+ x# _, H5 y! b
312.         u8 I2c_Buf_Read[256];
     
313.        
     
314.         printf("写入数据\n\r");
     
315.        
     ! e0 e5 T* K" a: z5 \% v
316.         for(i=0;i<=255;i++)
     . o# ~- E: ^* }! y& V
317.         {
     : g( |, {3 f0 n% q% |
318.                 I2c_Buf_Write[i] = i;
     
319.                 printf("0x%02X ",I2c_Buf_Write[i]);
     9 e) d$ S4 Z& D+ g" d: a- P
320.                 if(i%16 == 15)
     2 z5 x7 U3 F( r) c- s8 _6 o0 D
321.                 {
     
322.                         printf("\n\r");
     
323.                 }
     * C8 W1 V5 z" x: f
324.         }
     
325.         I2C_EE_BufferWrite(I2c_Buf_Write,EEP_Firstpage,256);
     : o, b' Y2 d. h% `4 }
326.        
     2 Z9 H/ e/ x, p+ y" g3 l/ J& d
327.         printf("\n\r读出的数据\r\n");
     " [" z3 b; u7 I" a& q  v
328. 
     
329.   I2C_EE_BufferRead(I2c_Buf_Read,EEP_Firstpage,256);
     $ n- e+ p/ s1 z8 b/ G
330.        
     
331.         for(i=0;i<256;i++)
     : f9 Y9 |8 b& F- U/ H3 W
332.         {
     5 P: B) V3 f' ]& ~; ]
333.                 if(I2c_Buf_Read[i] != I2c_Buf_Write[i])
     * B8 ?5 E' }0 {! D2 d/ S% S/ H
334.                 {
     $ l7 d3 b! E& G" N; d7 B# x
335.                         printf("0x%02X ",I2c_Buf_Read[i]);
     - E: `: w  ?+ M+ Y# r+ o# q9 x
336.                         printf("错误:I2C EEPROM写入与读出数据不一样\r\n");
     
337.                         return;
     
338.                 }
     $ n  b" h. h0 U' s/ U
339.                 printf("0x%02X ",I2c_Buf_Read[i]);
     : J1 u6 m  f, x
340.                 if(i%16 == 15)
     
341.                 {
     1 y  J9 x0 A0 ~6 n" g3 e
342.                         printf("\r\n");
     2 J0 }3 f+ ^# G& M  h
343.                 }
     8 `; c# ?+ K8 y+ i5 |
344.         }
     
345.         printf("读写测试通过PASSED\r\n");
     
346. }
     ' L, N7 Y& R6 j6 W- X0 q
347. 
     
348. 
     ( c+ W& F+ o7 V, |: ]3 f# \

复制代码

这里主要用的东西在这里我给大家贴上（不知道为什么，今天想偷点懒）
4 S5 E' M8 i/ E$ F

' u+ N9 t' W9 K- }7 U* l6 B# x

IIC的引脚

IIC的时钟树

GPIO模式

这个对应上边的写和读的EV5之类的东西

- e9 w& b1 ]$ S3 s4 \9 ^$ x先这样吧，确实有点懒了，但是基本上都全了，代码在附件上，大家可以看看，有什么错误之处还请指出，毕竟不是很熟悉。大家将就着看吧。 IIC.rar (5.29 MB, 下载次数: 1341)

2017-7-16 22:08 上传

点击文件名下载附件
( C* {8 ]4 I) K( C/ j

谢谢分享啦

谢谢分享啦

有不有I2C做slave的代码？这个代码相对比较难写。

硬件IIC读写AT24C02
谢谢分享啦

太给力了，谢谢分享

谢谢分享

谢谢分享 学习一下

谢谢分享

HAODE

能否再进一步，采用DMA方式？

谢谢分享，学习学习