这是最后一篇。自己昨天完成的一个工程，终于自己动手写出了人人喊打的代码。
- y( t6 _0 f  L
+++++++++++++项目介绍++++++++++++++++
逛论坛时间不长，新人，偶然看到@游名 发帖子免费申请按键板，我就参加了。
$ F# U+ m7 b) l. Y$ {9 c9 \# d其实我公司也有做门禁的，我也是公司新人，业务不懂，就先玩玩吧。
货到付款，相当于15块钱买了一个小板子。
提供的资料很全，有历程代码,有规格书。

# o9 {1 D- z. D. D+++++++++++框架介绍++++++++++++++++
& }; Z/ M2 v' t5 E2 g. G* V工作逻辑：按键板一共6个脚连接到STM32主控板
) a0 L  i+ f9 d1上电（不管）
2接地（不管）
3复位（就是接到STM32的一个GPIO，先拉高在拉低在拉高就可以让这个按键板复位一次）
4中断 (也是接到STM32的一个GPIO，当有按键被按的时候这个电平会突然拉高，也就触发了中断线。然后你去就IIC总线读数据)
5（IIC SDA）
6 (IIC SCL)
所以主要知识点是：A中断线（类似于很多教程里面的按键触发LED灯亮起）B IIC通讯（类似有ATC02存储的教程）
4 S' H+ d' Z. v; y6 ~++++++++开始吧+++++++++++


后面的配置都没有修改。(用了一个TIM定时器来做延时)
+ j$ l8 @$ H- C" F! q4 _

' t, [/ B/ p/ N6 p, A) c


+ Z9 _( Z( B; j$ d3 W5 z$ O6 j& x


基于cubemx+硬件IIC 几分钟就跑通了。
8 N! l! X. E2 u# n3 a6 t很快问题也就来了。（反馈给HTK公司技术的视频）
1 q* M  K; Q" d' _https://pan.baidu.com/s/10pr82ORcf4lanSPKwMdPHw
; X- t2 M3 O, c  ^+ [* a数据是00-32-32-32，虽然可以用，但有点膈应。
于是打算放弃硬件IIC，自己也来模拟IIC吧。
所以回到标题：机器风格的单片机程序

1. #include "HALI2C.h"
   * T# Q7 `. C1 ^8 V9 E+ s$ Q
2. 
   
3. _STM32I2CHandleType TemIIC;
   ! Y$ g' x% W" o
4. STM32I2CHandleType  pSTM32I2C=&TemIIC;
   5 w6 N$ f% E1 _3 i8 N
5. 
   * T$ v" m3 }7 }' C0 \  b
6. /*初始化 时钟 GPIO 两线都高*/
   ! B9 V. A) O. k8 z
7. void I2C_init(void)
   
8. {        
   , a( ], ?/ W2 x; ^# C6 S7 }
9.         GPIO_InitTypeDef GPIO_InitStruct;
   : e' f* p$ ^, U
10.         __HAL_RCC_GPIOD_CLK_ENABLE();
    
11.         __HAL_RCC_GPIOA_CLK_ENABLE();
    
12.         __HAL_RCC_GPIOB_CLK_ENABLE();
    
13.         GPIO_InitStruct.Pin=pSTM32I2C->SCL_PIN|pSTM32I2C->SDA_PIN;
    
14.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    1 G# E$ X% \$ a) o8 V9 J
15.         GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;/*推荐复用输出*/
      N+ S# g6 f2 i# i
16.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    + k7 t' K( e$ y. X
17. 
    1 _# Q4 A0 g! E# x( B. G# r  \
18.         pSTM32I2C->Set_SDA();
    5 F  `8 E; ~) z6 s! l3 Z% [. T  `1 M
19.         pSTM32I2C->Set_SCL();
    
20. }
    & l8 F" Z  n. v( V7 ?
21. /*设置SDA为输出模式*/
    " L& C1 C. n4 _+ o0 k8 F# ^
22. void I2C_SDA_OUT(void)
    
23. {
    
24.   GPIO_InitTypeDef GPIO_InitStruct;        
    
25.         
    1 V0 p) S  T8 G6 J3 Q  U# u8 L8 L
26.         GPIO_InitStruct.Pin=pSTM32I2C->SCL_PIN|pSTM32I2C->SDA_PIN;
    
27.         GPIO_InitStruct.Speed=GPIO_SPEED_FREQ_HIGH;
    0 ~; g+ {7 v; S
28.         GPIO_InitStruct.Mode=GPIO_MODE_OUTPUT_PP;
    
29.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    
30. }
    * r# a5 |* {3 z2 g& q2 e
31. /*设置SDA为输入模式*/
    / Y% t3 L/ Y. a4 R! T
32. void I2C_SDA_IN(void)
    " _. h- J: c, G" l, y
33. {
    . A: D) f% j) f3 X. ~' f( J
34.         GPIO_InitTypeDef GPIO_InitStruct;        
    
35.         
    
36.         GPIO_InitStruct.Pin=pSTM32I2C->SDA_PIN;
    8 u* H- u* d. g+ x
37.         GPIO_InitStruct.Mode=GPIO_MODE_INPUT;
    $ [5 K. L/ |0 m  j2 }) J% a
38.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    
39. }
    
40. 
    
41. /*产生起始信号*/
    1 s3 `& v0 M& @6 y, c; @
42. void I2C_Start(void)
    
43. {
    ) z1 o. l( C/ B+ ]2 J
44.         pSTM32I2C->Set_SDA_Output_Mode();
    ( K$ I0 b  l5 R
45.         pSTM32I2C->Set_SDA();
    8 |0 H7 \4 d$ S2 |) d% q
46.         pSTM32I2C->Set_SCL();
    
47.         pSTM32I2C->Delayus(5);
    4 |' J0 l" {( y- f. z& C) Z
48.         pSTM32I2C->Reset_SDA();
    
49.         pSTM32I2C->Delayus(5);
    / H0 y* g) E; O+ X, d, u3 R
50.         pSTM32I2C->Reset_SCL();
    
51.         pSTM32I2C->Delayus(5);
    ( m  p8 G9 L' ^
52. }
    1 ~6 d4 A1 d( b4 q7 o8 V
53. 
    0 b  a8 j( o( f: F7 T1 t% k+ X
54. /*产生停止信号*/
    
55. void I2C_Stop(void)
    ; Z$ _2 j, @, X% X8 V4 G
56. {
    
57.    pSTM32I2C->Set_SDA_Output_Mode();
    
58.    pSTM32I2C->Reset_SCL();
    ) `. j+ Y( V" [. N. C3 D
59.    pSTM32I2C->Reset_SDA();
    
60.    pSTM32I2C->Set_SCL();
    / ?& X1 d. W  B9 Y$ d
61.    pSTM32I2C->Delayus(6);
    , x6 D  o5 e" P9 x* W
62.    pSTM32I2C->Set_SDA();
    
63.    pSTM32I2C->Delayus(6);
    
64. }
    
65. 
    7 }& `% u" A4 D2 K- d% Y
66. //主机产生应答信号ACK
    / J: V7 N% f( H/ V7 _% @5 R% T& `
67. void I2C_Ack(void)
    
68. {
    ) A6 F7 O) r0 W- ]: A5 Y3 r
69.    pSTM32I2C->Reset_SCL();
    
70.          pSTM32I2C->Delayus(2);
    4 d2 g' e( ?, V+ q
71.    pSTM32I2C->Set_SDA_Output_Mode();
    4 D+ m3 I! G7 |% [0 K% w
72.    pSTM32I2C->Reset_SDA();
    
73.    pSTM32I2C->Delayus(5);
    & o1 d* b) I+ A6 x( R
74.    pSTM32I2C->Set_SCL();
    4 d8 t, {% X( j4 d& G/ m
75.    pSTM32I2C->Delayus(5);
    ( K: l7 \! q5 l; ]- G4 u
76.    pSTM32I2C->Reset_SCL();
    ( c  e% h' a, F3 ^
77. }
      Y" n3 Z  P; _* O8 K2 a
78. 
    / f: O! L5 U, z, K# O. Y) K
79. //主机不产生应答信号NACK
    5 k& {; R% x3 I
80. void I2C_NAck(void)
    & U- s1 ]$ g, ]7 s
81. {
    
82.          pSTM32I2C->Reset_SCL();
    * p5 _% X$ Y. c( {- F- u
83.          pSTM32I2C->Delayus(2);
    7 M0 ^# ~" F: r# s% M: R
84.    pSTM32I2C->Set_SDA_Output_Mode();
    
85.    pSTM32I2C->Set_SDA();
    ; a" c0 v2 E/ R2 O
86.    pSTM32I2C->Delayus(5);
    3 j- y$ e  M, Y+ R4 ?5 y
87.    pSTM32I2C->Set_SCL();
    
88.    pSTM32I2C->Delayus(5);
    ) W" g/ x4 P- M9 G, C7 r5 w7 \5 p
89.    pSTM32I2C->Reset_SCL();
    ' x( o' {/ k! X& ]( `
90.          pSTM32I2C->Delayus(2);
    
91. }
    1 C2 `# Q& v; S+ p
92. //等待从机应答信号
    ) R: e, C5 \2 ]3 Y) I6 Y2 q7 y
93. //返回值：1 接收应答失败
    ) Y/ z) r+ \: Z8 H3 x1 W* I$ j6 `# e
94. //                    0 接收应答成功
    - Y. Z6 k' D5 V0 r
95. unsigned char I2C_Wait_Ack(void)
    
96. {
    % ~" L' O! \/ @
97.         unsigned char tempTime=0;
    
98. 
    
99.         pSTM32I2C->Set_SDA_Input_Mode();
    
100. 
     4 e" Z/ U, Q% S; G+ o# C* O8 R
101.         pSTM32I2C->Set_SDA();
     2 T$ Z& Y* q! X2 B+ j5 z' w: ]* E8 c
102.         pSTM32I2C->Delayus(5);
     
103.         pSTM32I2C->Set_SCL();
     5 z2 Q* g& X2 o. y( y' D' K
104.         pSTM32I2C->Delayus(2);
     7 t3 z% N$ @. I, \7 K% [0 p
105. 
     
106. 
     ! @% K4 J: O0 F( F
107.         while(pSTM32I2C->Get_SDA())
     
108.         {
     
109.                 tempTime++;
     ! T: w* k$ T) u# L) j; x0 d& r
110.                 if(tempTime>50)
     
111.                 {
     
112.                         pSTM32I2C->I2C_stop();
     * E1 K/ d. e4 p+ y; n) }
113.                         return 0;
     
114.                 }         
     6 H2 Q) i5 B2 N# E. V
115.         }
     
116. 
     
117.         pSTM32I2C->Reset_SCL();
     
118.         pSTM32I2C->Delayus(5);
     
119.         return 1;
     # a/ q+ p( F6 r" J6 u( ]
120. }
     9 h1 j( E! U! m6 X
121. //I2C 发送一个字节
     
122. void I2C_Send_Byte(unsigned char txd)
     3 `, `' G8 S- |0 Z
123. {
     ; v* Y  O* h8 X. M, r: i5 P- X
124.         unsigned char i=0;
     
125. 
     
126.         pSTM32I2C->Set_SDA_Output_Mode();
     % W7 l" o6 H& Y% S+ G
127.         pSTM32I2C->Reset_SCL();//拉低时钟开始数据传输
     
128. 
     
129.         for(i=0;i<8;i++)
     
130.         {
     8 [' b2 o- ?3 y, l6 _9 M& I* K3 t4 n
131.                 if((txd<<i)&0x80)
     
132.                         pSTM32I2C->Set_SDA();
     
133.                 else
     
134.                         pSTM32I2C->Reset_SDA();
     
135.                
     2 X: _& z) W+ n) F& Z8 z3 R5 a
136.           pSTM32I2C->Delayus(2);
     * |( V4 a! D) j2 E& a
137.                 pSTM32I2C->Set_SCL();
     
138.                 pSTM32I2C->Delayus(5); //发送数据
     
139.                 pSTM32I2C->Reset_SCL();
       L, [' j4 c5 q5 L2 A; u
140.                 pSTM32I2C->Delayus(2);
     # a, I8 v: Q, J$ z6 ]! s, i
141.         }
     6 P. D- T: x& D% E0 L
142. }
     3 i- S# Y* r3 t' H8 k% {
143. 
     
144. //I2C 读取一个字节
     * Q* @* i& [0 @
145. 
     ! ^5 L8 D( \6 c7 _7 v$ ?
146. unsigned char I2C_Read_Byte(unsigned char ack)
     
147. {
     
148.    unsigned char i=0,receive=0;
     # g% l! ]) I: N' L+ T5 ]( F& V& x' B
149. 
     
150.    pSTM32I2C->Set_SDA_Input_Mode();
     
151.    for(i=0;i<8;i++)
     
152.    {
     4 p" R! B% ?8 f5 t- m
153.            pSTM32I2C->Reset_SCL();
     
154.                 pSTM32I2C->Delayus(5);
     
155.                 pSTM32I2C->Set_SCL();
     7 M- p5 @# l' \' |2 O5 B
156.                 receive<<=1;
     + {9 N) P6 g3 O0 x- W) R
157.                 if(pSTM32I2C->Get_SDA())
     
158.                    receive++;
     
159.                 pSTM32I2C->Delayus(5);        
       v$ u  c/ M( P" o+ H5 B; l
160.    }
     & j1 S. k5 Y- B1 |
161. 
     & j) f; z* O" N& q5 }
162.            if(ack==0)
     ' ~0 K* L% j" A" r+ y8 {; R, X
163.                    pSTM32I2C->I2C_withnoAck();
     1 N" M% O/ [# R* S: A  q
164.           else
     ; O: z, A8 @! e' \% `
165.                   pSTM32I2C->I2C_withAck();
     
166. 
     
167.         return receive;
     
168. }
     
169. 
     
170. void set_SDA(void)
     5 F& |7 o3 ~" x/ `/ N
171. {
     
172.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN,GPIO_PIN_SET);
     ) u! z8 S* n" |& |5 `. q
173. }
     
174. void set_SCL(void)
     7 V1 @3 P$ ?( P1 @. s, f
175. {
     
176.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SCL_PIN,GPIO_PIN_SET);
     ) p5 A, u) k2 }% \) s
177. }
     
178. void reset_SDA(void)
     & h* R8 d% V- h& R  O" n1 W
179. {
     8 c) o& i% |2 V
180.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN,GPIO_PIN_RESET);
     . x. D( Z( t0 {4 d4 I
181. }
     
182. void reset_SCL(void)
     
183. {
     
184.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SCL_PIN,GPIO_PIN_RESET);
     
185. }
     ! z# P" j9 p. x& ~$ [
186. unsigned char read_SDAPIN(void)
     2 {) F1 B+ e& c2 e( v
187. {
     # Z% C( P6 w; S7 X$ i$ Y
188.   return HAL_GPIO_ReadPin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN);
     0 R9 ^1 d: k. P& w3 \3 P8 t. S4 s/ b
189. }
     ( C/ b0 i& B( |/ J+ D  S
190. ///////////////////设备驱动//////////////////////
     
191. 
     
192. void STM32IICInit(void)
     # G' D, l) y) Z% V/ T5 P
193. {
     
194.         _STM32I2CHandleType temIIC=
     
195.         {
     % L4 D( I6 t, c: K4 K' d/ C+ T8 T, k0 X
196.         .IICGPIO=GPIOB,
     
197.         .SCL_PIN=GPIO_PIN_6,
     
198.         .SDA_PIN=GPIO_PIN_7,
     # N2 d. H( R6 G; t3 O$ h. R% P
199.         .I2C_Init=I2C_init,
     * H6 x8 A6 w& R3 C
200.         .Set_SDA=set_SDA,
     
201.         .Set_SCL=set_SCL,
     + S' {3 ?& n  O0 r
202.         .Reset_SDA=reset_SDA,
     
203.         .Reset_SCL=reset_SCL,
     
204.         .Get_SDA=read_SDAPIN,
     
205.         .Delayus=TIM3_Delay,
     2 |/ n0 U  i7 i4 _- w5 l
206.         .Set_SDA_Input_Mode=I2C_SDA_IN,
     
207.         .Set_SDA_Output_Mode=I2C_SDA_OUT,
     2 b+ Q! _' L# J- s6 L4 F
208.         .I2C_start=I2C_Start,
     
209.         .I2C_stop=I2C_Stop,
     
210.         .I2C_withAck=I2C_Ack,
     
211.         .I2C_withnoAck=I2C_NAck,
     
212.         .I2C_Wait_Ack_Check=I2C_Wait_Ack,
     
213.         .I2C_read_byte=I2C_Read_Byte,
     
214.         .I2C_send_byte=I2C_Send_Byte,
     
215.         };
     
216. TemIIC=temIIC;/*做了一个临时变量 然后用=号做了赋值*/
     : z  G3 e7 t! B5 f" l
217. pSTM32I2C->I2C_Init();
     - b7 z, F* Q: D) |( W
218. }
     
219. +++++++++++++++++++噢这不好 可以直接赋值的int a=9这样直接全局变量赋值+++++++++++++
     
220. 
     ( G0 W9 y+ i+ A. ^8 q8 t; {* m! Y
221. char __HTK_I2C_Read_optimal_touch_keyval(unsigned char  *pKeyVal)
     % h6 q/ {1 Q9 U1 W: U. |
222. {
     
223. /*第一次发送器件物理地址+写命令*/
     
224.         pSTM32I2C->I2C_start();
     3 }4 C) t7 r+ f$ s3 l3 g
225.         pSTM32I2C->Delayus(5);
     % a3 e$ P2 B8 b3 u/ t6 w* W( X8 U
226.         pSTM32I2C->I2C_send_byte((0X24<<1)|0) ;
     
227.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识
     
228. 
     / R* f  R6 b4 n/ B7 @+ U
229.         
     ( j, m( M& n7 P* d1 @" D
230. /*第二次发送器件内部地址*/        
     
231.         pSTM32I2C->Delayus(5);
     
232.         pSTM32I2C->I2C_send_byte(0X80);
     $ `% Y, n0 X+ d, j
233.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     - t1 @& L- ?  A, o- C" M3 j5 v
234. 
     
235.         
     6 \9 L$ A, U0 v  A* G3 `
236.   pSTM32I2C->Delayus(5);
     
237. 
     
238. /*第三次发送器件物理地址+读命令*/               
     
239.         pSTM32I2C->I2C_start();
     
240.         pSTM32I2C->Delayus(5);
     
241.         pSTM32I2C->I2C_send_byte((0X24<<1)|1) ;               
     7 r4 s- a! b" e6 Y; s& k) `- J
242.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     
243. 
     # U( ^1 f6 p: C6 ^6 |* M. w
244. 
     
245.         pSTM32I2C->Delayus(100);
     1 I) g, t4 N, h  I; S; }7 M
246. /*读取反馈数据 因为只读一个字节 所以不需要ack反馈信号*/        
     
247.         *pKeyVal = pSTM32I2C->I2C_read_byte(0);
     + C: y+ j+ L( B9 s0 S) k4 O3 O
248.         
     
249.         pSTM32I2C->Delayus(5);
     
250.         pSTM32I2C->I2C_stop();        
     
251.         return 1;
     
252. }
     + P* ^; L  o$ k3 [; _% E
253. 
     
254. 
     
255. 
     9 Q# p  r, L  ^6 I2 B
256. char __HTK_I2C_Read_keystatus(unsigned char  *pKeyVal)
     
257. {
     
258.         char i=0;
     % }$ E# @9 P9 L6 Y
259. /*第一次发送器件物理地址+写命令*/
     
260.         pSTM32I2C->I2C_start();
     % s  m. j3 h' Y" x+ V  K- h( L
261.         pSTM32I2C->Delayus(5);
     ( T$ f% G  t& j
262.         pSTM32I2C->I2C_send_byte((0X24<<1)|0) ;
     
263.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识
     
264. 
     8 y6 O, r- s9 P4 A2 ?9 D
265.         
     
266. /*第二次发送器件内部地址*/        
     
267.         pSTM32I2C->Delayus(5);
     
268.         pSTM32I2C->I2C_send_byte(0X81);
     
269.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     / a) i/ w, @9 l: z6 _8 C
270. 
     
271.         
     ) B9 s# f8 B; @& ?
272.   pSTM32I2C->Delayus(5);
     
273. 
     1 `( i% p% D( L( N
274. /*第三次发送器件物理地址+读命令*/               
     2 \( _' P; w( `
275.         pSTM32I2C->I2C_start();
     5 A4 ]- A- V! b: v2 \0 V3 ~
276.         pSTM32I2C->Delayus(5);
     , d; q4 W8 q/ z: @3 s
277.         pSTM32I2C->I2C_send_byte((0X24<<1)|1) ;               
     ! T" k) l: O. V7 x/ x" F6 D
278.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     7 K7 a& z$ m$ n* {, Z% c" I
279. 
     : A) |$ I' B7 p
280. 
     
281.         pSTM32I2C->Delayus(100);
     
282. /*前面的代码和前面是一样的。*/        
     ; _9 z  u# Y# [# y( o( }% T2 K3 Q# Y" e
283. /*前面0X80是读一个字节一个U8当前按下的值是多少*/        
     
284. /*现在我们是读0x81，后面4个字节4个U8*/        
     
285.         for(i=0;i<3;i++)
     ! z, I' ]" t2 E8 r; m
286.                 pKeyVal[i] = pSTM32I2C->I2C_read_byte(1);
     # h; z8 h. f& R; @2 I8 v7 t
287.         /*前面3个字节需要ack反馈，最后一个字节就跟前面一样不用反馈*/
     
288.         pKeyVal[3]=pSTM32I2C->I2C_read_byte(0);
     
289.         
     
290.         pSTM32I2C->Delayus(5);
     . `2 f* b6 X' ?* i4 s/ r
291.         pSTM32I2C->I2C_stop();        
     
292.         return 1;
     $ ]! N$ g$ Q. G5 a  d8 l
293. }
     

复制代码

1. #ifndef _HALI2C_H
   
2. #define _HALI2C_H
   
3. #include "stm32f1xx_hal.h"
   
4. #include "tim.h"
   
5. 
   
6. ////如果移植程序时只要改一下三个地方就行了
   % N! O' t& T" n
7. //#define I2C_SCL  GPIO_PIN_6
   
8. //#define I2C_SDA  GPIO_PIN_7
   ; Y( I. w$ e8 S0 w1 i  o
9. //#define GPIO_I2C GPIOB
   
10. //#define delay_us TIM3_Delay  
    
11. 
    
12. //#define I2C_SCL_H HAL_GPIO_WritePin(GPIO_I2C,I2C_SCL,GPIO_PIN_SET);
    
13. //#define I2C_SCL_L HAL_GPIO_WritePin(GPIO_I2C,I2C_SCL,GPIO_PIN_RESET);
    ! S& l" s; N8 n3 h
14. 
    
15. //#define I2C_SDA_H HAL_GPIO_WritePin(GPIO_I2C,I2C_SDA,GPIO_PIN_SET)
    / n& m1 t; e/ i; C1 `7 C! ?
16. //#define I2C_SDA_L HAL_GPIO_WritePin(GPIO_I2C,I2C_SDA,GPIO_PIN_RESET)
    : v" k5 ?* _/ Z( s
17. 
    9 e* p0 a7 |# ?  I
18. //void I2C_Init(void);
    ! K& @; ~# I# V- ^; e0 E% _
19. //void I2C_SDA_OUT(void);
    . A; U: b  z( m6 R: \* e1 S
20. //void I2C_SDA_IN(void);
    
21. //void I2C_Start(void);
    ! y; S) j: @( p1 r& m% f8 n+ R
22. //void I2C_Stop(void);
    
23. //void I2C_Ack(void);
    
24. //void I2C_NAck(void);
    ) J5 @: C" W7 M/ S5 d1 A/ o% o7 L
25. //unsigned char I2C_Wait_Ack(void);
    ) A! y, s9 t5 [9 C9 m+ a
26. //void I2C_Send_Byte(unsigned char txd);
    3 y: S! q# z/ r4 ~, f
27. //unsigned char I2C_Read_Byte(unsigned char ack);
    * a6 s5 B+ Z  w1 K
28. 
    
29. 
    
30. typedef struct
    . w& D5 ^/ |( o" G/ {) }
31. {
    1 w8 ]" d. z6 i+ }! g( f- q
32.         GPIO_TypeDef *        IICGPIO;
    
33.         uint16_t        SCL_PIN;
    : [& ~9 x( x2 j( ?' F2 ~( r  {
34.         uint16_t        SDA_PIN;
    
35.         void                                           (*I2C_Init)(void);
    
36.         void                                           (*Set_SDA)(void);
    
37.         void                                           (*Set_SCL)(void);
    
38.         void                                           (*Reset_SDA)(void);
    8 ^0 \& L3 p, k- J
39.         void                                           (*Reset_SCL)(void);
    5 F1 r2 G' F6 Y& l
40.         unsigned char   (*Get_SDA)(void);
    7 {" ?1 S2 W6 J0 ]0 R
41.         void                                           (*Delayus)(int Time);
    
42.         void            (*Set_SDA_Input_Mode)(void);
    
43.         void            (*Set_SDA_Output_Mode)(void);
    
44.         void                               (*I2C_start)(void);
    
45.         void            (*I2C_stop)(void);
    . L8 S2 p' @' M! T- G' i; W
46.         void            (*I2C_withAck)(void);
    - @) w# S1 O) w+ V& B
47.         void            (*I2C_withnoAck)(void);
    " g& J5 ]) X8 P
48.         unsigned char   (*I2C_Wait_Ack_Check)(void);
    1 A3 I2 j# N8 U+ a& L( B; l& C
49.         unsigned char   (*I2C_read_byte)(unsigned char ack);
    
50.         void            (*I2C_send_byte)(unsigned char Byte);
    
51. }_STM32I2CHandleType,*STM32I2CHandleType;
    1 ~( F7 J. U) i. \4 V8 F3 |
52. 
    
53. void STM32IICInit(void);
    
54. char __HTK_I2C_Read_keystatus(unsigned char  *pKeystatus);
    $ q3 V1 Y. I7 M& {) y$ T: Q( D
55. char __HTK_I2C_Read_optimal_touch_keyval(unsigned char  *pdwStatus);
    . h. Y* n! u$ C9 a' w0 _' \
56. #endif
    

复制代码

3 O# {3 k' H( w- d( M% j' g和传统的代码是有差别的。
. _6 e- e7 A2 H2 l传统的是用宏定义修改(头文件能看到刘洋老师的影子)，现在全是函数。
全局变量
2 W* x: Y; c$ [* c# ]4 M_STM32I2CHandleType TemIIC;
STM32I2CHandleType pSTM32I2C=&TemIIC;
( P! z8 B7 o1 V) D一个句柄，一个句柄指针，囊括了IIC所有的 属性。

! i$ J3 I1 n; f+++++++++++++++20180611补充+++++++++++今天打开论坛看了一个帖子，发现一个不错的资源：就是自己做按键板。
* p  K, H. I- A& H; T现在的按键盘是买的嘛，自己做怎么搞呢？
按键的扫描和设计。
8 N) N# x4 J/ L# X 矩阵按键扫描资料.rar (3.83 MB, 下载次数: 0)

2018-6-11 09:16 上传

点击文件名下载附件
4 A2 b  }3 @$ h0 ^7 K7 Q- V学有余力再来自己设计吧

自己又研究了个把小时，脑壳疼。硬件IIC问题先放着真的搞不明白。
现在的问题是：IIC的寄存器的值DR  是正确的它是U32
库函数过去的是U8的数组，挨个赋值。U8=U32这样(应该也是没事的 自动把高位放弃掉吧)
0 }& k% }% C  o. d/ A+ C现象确是U8的数组第一个总是0后面的总是一样。
埃
先用模拟的吧

楼主 厉害 学习了

除了代码量巨大，没看出来有什么优势~~~~~~~~~