使用GPIO引脚模拟SDA和SCL总线实现软件模拟IIC通信，IIC的具体通信协议层和物理层链接：
4 j2 [6 e4 [4 G$ l

1. #ifndef __BSP_IIC_H
   5 X# E7 ?$ x& J
2. #define __BSP_IIC_H
   7 y# D# ?8 X! L. i( O) r0 X
3. 
   5 [) |; W0 d0 R. x, M1 `+ s
4. #include "stm32f10x.h"
   , v$ J/ k- s9 b! g% a/ }! x
5. 
   
6. 
   
7. 
   
8. #define SCL_PORT         GPIOA
   ' G! ]* o/ d( N4 z+ y& t/ t+ B
9. #define SCL_PIN          GPIO_Pin_2
   / t& O3 A& B3 u4 {9 Z
10. #define SCL_MOOD         GPIO_Mode_Out_OD
    , q% J( Y9 ]- n
11. #define SCL_SPEED        GPIO_Speed_50MHz
    
12. 
    4 M) P1 f( ]1 {4 @/ {5 n
13. #define SDA_PORT         GPIOA
    3 V. f1 [( `: w: V7 d5 `
14. #define SDA_PIN          GPIO_Pin_3
    0 C. X; A4 P, Y
15. #define SDA_MOOD         GPIO_Mode_Out_OD
    
16. #define SDA_SPEED        GPIO_Speed_50MHz
    
17. 
    
18. #define SDA_1()          GPIO_SetBits(SDA_PORT, SDA_PIN)
    
19. #define SDA_0()          GPIO_ResetBits(SDA_PORT, SDA_PIN)
    ! _8 L" V- L7 _9 `
20. 
    
21. #define SCL_1()          GPIO_SetBits(SCL_PORT, SCL_PIN)
    
22. #define SCL_0()          GPIO_ResetBits(SCL_PORT, SCL_PIN)
    
23. 
    
24. #define SDA_READ         GPIO_ReadInputDataBit(SDA_PORT, SDA_PIN)
    
25. 
    
26. 
    , K* f" Z- r2 m# A, O
27. /* ACK原型为acknowledge，意为：报告已收到 */
    * T" P( G# b" G
28. void Delay(void);
    
29. void IIC_START(void);
    
30. void IIC_STOP(void);
    
31. void IIC_ACK(void);
    ' Z4 Z0 n& i. u( ]
32. void IIC_NACK(void);
    + u! ^! `8 y* }8 N( `  o
33. uint8_t IIC_ReadACK(void);
    
34. void IIC_SendByte(uint8_t data)        ;
    
35. uint8_t IIC_ReadByte(void);
    % T) y! S. m9 \1 {1 b
36. void IIC_GPIO_Config(void);
    , W+ I6 Q7 m( B# \/ l  z
37. 
    3 d8 Y% s9 W* @  Q& H
38. 
    
39. 
    
40. 
    
41. #endif     /* __BSP_IIC_H */
    
42. 
    6 r- n6 d* T" `1 [* d# }$ Y

复制代码

1. 
   + t/ R# a: K' Y6 g9 v2 Z9 a! L
2. 
   
3. void Delay(void)
   + t; N5 {, \  P
4. {
   
5.         uint8_t i;
   
6. 
   % q9 q# n, E4 ]* ^" v
7.         /*　
   
8.                  下面的时间是通过逻辑分析仪测试得到的。
   ! f1 k* d5 e3 F
9.     工作条件：CPU主频72MHz ，MDK编译环境，1级优化
   . c/ m& h* M% ^6 |. E5 Z/ L
10.   
    
11.                 循环次数为10时，SCL频率 = 205KHz
    / F4 e- o8 Z3 t* _, n0 R
12.                 循环次数为7时，SCL频率 = 347KHz， SCL高电平时间1.5us，SCL低电平时间2.87us
    ; F! R' n# K( Z! h
13.                  循环次数为5时，SCL频率 = 421KHz， SCL高电平时间1.25us，SCL低电平时间2.375us
    
14.         */
    % @/ E9 Q# M6 n9 u# ]
15.         for (i = 0; i < 10; i++);
    " z$ b; z% D0 ^- l% `
16. }
    ; J/ l' r  J2 q. z% v
17. 
    
18. 
    
19. /* SCL高电平时期SDA产生下降沿表示起始信号 */
    % S' t! g1 }- ]1 z6 T0 U
20. void IIC_START(void)
    
21. {
    
22.         SDA_1();
    
23.         SCL_1();
    " i" o$ {# \! h2 q
24.         Delay();
    
25.        
    ! R) ~9 k- p, v; L7 f. h5 I
26.         SDA_0();
    
27.         Delay();
    . v1 j) ?( }; a. ?' o
28.         SCL_0();
    * w6 R& N7 M+ d6 w5 l0 g
29.         Delay();
    
30. }
    
31. 
    % A3 C2 \# g. b9 a
32. 
    
33. 
    - V' U% B% i6 ~! R* b
34. /* SCL高电平时期SDA产生上升沿表示停止信号 */
    
35. void IIC_STOP(void)
    $ x1 z' l6 P1 d7 c7 A
36. {
    $ y3 j/ f0 C% y- o' g/ M0 W9 f
37.         SDA_0();
    
38.         SCL_1();
    
39.         Delay();
    
40.        
    5 H, ~4 l4 R4 y" |
41.         SDA_1();
    " U8 t" R* J# H: ~( T1 K0 z( e
42.         Delay();
    ! [) U9 L7 s: G1 D" q9 g
43.   /* 停止信号后SDA和SCL都为高电平 */
    7 t9 k1 t7 j4 O* n% K
44. }
    
45. 
    4 o( G: Q) C$ S' T5 i3 |
46. 
    
47. /* SCL高电平时期 SDA保持低电平代表 应答信号 */
    
48. void IIC_ACK(void)
    
49. {
    ; @% Z4 r$ y* D% o8 y/ L7 Q
50.         SDA_0();
    
51.         Delay();
    
52.         SCL_1();
    0 X" g# }& u$ k, G5 X0 B
53.         Delay();
    
54.        
    : h* f8 N* l2 }
55.         SCL_0();
    
56.         Delay();
    ! T' k" P. V( P  t' {& Y4 Z3 t
57.         SDA_1();
    0 i$ k$ D% g  B8 V/ P
58. /* 随后释放SDA总线 */
    - |# ~0 d, Y1 H$ \$ X. h0 d. X+ {
59. }
    
60. 
    ! f; E; i2 f3 l
61. 
    9 V- Z1 p3 H8 I' Z3 o- f
62. /* SCL高电平时期 SDA保持高电平代表 非应答信号 */
    
63. void IIC_NACK(void)
    7 R. F9 C2 ~# D; S
64. {
    , j% ]% s6 b1 P2 c& e  c- A! g# A( ?
65.         SDA_1();
    
66.         Delay();
    
67.         SCL_1();
    ! ~7 T+ }9 r# s; v  O: i4 l
68.         Delay();
    
69.        
      U1 O3 J- O+ K$ V" M( \- H; I: M
70.         SCL_0();
    & \0 f: L- }5 V$ h4 T9 {" Y
71. /* SDA已经为高电平，无需释放 */
    
72. }
    % X9 D9 x5 O/ o  a! _
73. 
    % A" x  u2 y9 E9 b
74. 
    
75. /* CPU产生一个SCL时钟，读取应答  ACK：0   NACK：1*/
    ; y/ }# E: K8 q% b" r
76. /* 因为SDA平时为高电平，所以没有收到应答时，SDA还为高电平，即读取到 1 为非应答 */
    
77. uint8_t IIC_ReadACK(void)
    
78. {
    
79.         uint8_t k;
    
80.         /* 释放SDA总线 */
    
81.         SDA_1();
    
82.         Delay();
    
83.         /* SCL为高电平时，才会读取有效数据 */
    
84.         SCL_1();
    
85.         Delay();
    ; j. _3 i0 y/ G* O
86.        
    7 {" p1 i* E- @: C% T
87.         /* 读取信号 */
    1 {" D- l% t$ @. E0 c
88.         if(SDA_READ==1)
    + o. l; u* }1 H9 n2 X1 g; F
89.                 k=1;
    
90.         else
    4 h4 t: T% p! Y( H/ u* R
91.                 k=0;
    , Y2 O$ ?  x6 w, X' Z+ }$ z+ Q
92.         /* 收到信号后SCL要拉低 */
    2 r& A, j; `0 a7 O* l
93.         SCL_0();
    
94.         Delay();
    
95.         return k;
    
96. }
    
97. 
    6 F, ?0 w/ d7 Z6 J; x1 }
98. 
    
99. /* 发送一个字节，先发送高位 */
    
100. void IIC_SendByte(uint8_t data)
     / W' y. W2 i8 J5 }$ y! z! ]- s
101. {
     
102.         uint8_t n=0x01;
     * k, S1 q( P8 k: x4 V6 ^
103.         int i;
     
104.         SCL_0();
     & w4 q2 Y' I& W0 h
105.         Delay();
     
106.         for(i=7;i>=0;i--)
     
107.         {
     8 m, Z4 ?0 [& @! Q
108.                 if(n&(data>>i))
     
109.                 {
     
110.                         SDA_1();
     # Y3 F: M% W8 W9 |
111.                         Delay();
     
112.                         SCL_1();
     $ |/ O9 u. v' n  k; g
113.                         Delay();
     3 P% X* I/ o: ~8 x+ z" ?
114.                 }
     
115.                 else
     
116.                 {
     ( z6 c/ Z) B$ \1 e; |7 n& o( c" z- s
117.                         SDA_0();
     
118.                         Delay();
     
119.                         SCL_1();
     
120.                         Delay();
     
121.                 }
     
122.                 SCL_0();
     
123.                 Delay();
     3 \3 D9 E* v' a5 k/ M* d
124.         }
     
125.         /* 发送完一个字节后释放SDA总线 */
     # u1 `  Q+ t5 b4 R7 E! G# Q
126.         SDA_1();
     8 Y5 s9 a  O' \7 c7 w, w0 x2 T: V/ C
127.         Delay();
     
128.        
     2 k+ G5 q1 p0 h, E
129. }
     5 I$ v; U. K; \2 F. Y- B
130. 
     
131. /* 读取一个字节，在CPU产生的SCL高电平时期读取 */
     ) B. m# `9 g5 d" j
132. uint8_t IIC_ReadByte(void)
     - S* z9 m5 p: `2 Q& q- g
133. {
     9 y: _+ H! n* u" p5 }
134. //        uint8_t i,data=0;
     
135. //        for(i=0;i<8;i++)
     ' b+ ?8 G% O7 h& b( E. Z" s
136. //        {
     
137. //                SCL_1();
     
138. //                Delay();
     
139. //                if(SDA_READ)
     # D9 E1 k/ K$ B  @% d: k& o' M) |4 i# p
140. //                {
     7 _; h  T7 d0 H+ J
141. //                        data++; /* 利用自增实现对最低位写 1  */
     % B  E( `( G4 f2 G9 i6 l
142. //                }
     7 V& r( w$ E$ H7 d
143. //                data<<=1;
     ) B; j: B0 P0 c  s9 w. F
144. //                SCL_0();
     
145. //                Delay();
     
146. //               
     
147. //        }
     $ O3 L, \/ x' y
148. //        return data;
     & U& c7 A2 {# M5 \% J3 U$ C  f2 t
149. //       
     
150.        
     
151.         uint8_t i;
     + R8 w3 n8 `, V3 ]9 `/ G2 V4 }) f
152.        
     $ ?. o# P7 Z0 S7 O3 F6 c; h' \
153.         uint8_t temp = 0;
     
154.        
     : o% \& d9 h9 v  t4 @# W/ \
155.         for(i=0;i<8;i++)
     7 X$ H4 |0 M, E8 L7 Y
156.         {               
     
157.                 temp<<=1;
     5 T  i  k, ~, t+ J4 M
158.                
     
159.                 SCL_1();
     
160.                 Delay();
     
161.                
     0 s# R" Z' F% Y! d
162.                 if( SDA_READ==1 )
     
163.                 {
     
164.                         temp += 1;
     $ l5 B, g9 s/ X- ?
165.                 }
     
166.                
     
167.                 SCL_0();
     
168.                 Delay();
     
169.         }               
     
170.        
     
171.         return temp;
     / m( S9 t, H5 m4 M( V
172. }
     ( o* A; B1 Q3 c
173. 
     
174. 
     , l7 v& `' z6 U. m( L1 u
175. 
     
176. /* 配置SCL和SDA对应的GPIO引脚，模式都为开漏输出 */
     
177. void IIC_GPIO_Config(void)
     ! V8 x6 D; }9 m% G% ~# I
178. {
     
179.         GPIO_InitTypeDef GPIO_InitStruct;
     6 N: E  F- w2 U$ Q# k4 W
180.        
     
181.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
     3 r% u0 v' I8 t0 E: A2 j
182.        
     ( q+ j4 K) h, F2 N: z4 F4 o4 s
183.         GPIO_InitStruct.GPIO_Pin = SCL_PIN;
     6 `; k: B: h& I7 v& k6 ^% _, m
184.         GPIO_InitStruct.GPIO_Mode = SCL_MOOD;
     8 E7 K. W/ J- k0 B+ T( ^# ~
185.         GPIO_InitStruct.GPIO_Speed = SCL_SPEED;
     
186.         GPIO_Init(SCL_PORT, &GPIO_InitStruct);
     
187.        
     2 K: q3 V/ T, z0 p( T! I  r4 V
188.   GPIO_InitStruct.GPIO_Pin = SDA_PIN;
     9 r& B! U# a. ^( s
189.         GPIO_InitStruct.GPIO_Mode = SDA_MOOD;
     
190.         GPIO_InitStruct.GPIO_Speed = SDA_SPEED;
     8 Y( q1 r; c: O4 a$ |1 \) @
191.         GPIO_Init(SDA_PORT, &GPIO_InitStruct);
     " f6 K& x1 v4 a% F$ b
192.        
     5 w3 k1 K* q2 g2 {* D
193. /* 给一个停止信号，使IIC总线上所有设备处于复位 */
     ; E/ R; }3 z) O5 @* c- P( F
194.         IIC_STOP();
     3 n0 o, h+ V7 w; Q; q8 s
195.        
     . K  O3 g2 F! D, m" A
196. }
     
197. 
     
198. 
     

复制代码

转载自：Aspirant-GQ
如有侵权请联系删除

/ W8 l& e( v6 ^1 J/ L0 [