a( f2 I# h% \8 Y/ ?
& `* o9 j# c8 l这是最后一篇。自己昨天完成的一个工程，终于自己动手写出了人人喊打的代码。

) P" v5 S5 _: j' Q% p; ?+++++++++++++项目介绍++++++++++++++++
逛论坛时间不长，新人，偶然看到@游名 发帖子免费申请按键板，我就参加了。
: ?1 N( e! m0 r( a3 F其实我公司也有做门禁的，我也是公司新人，业务不懂，就先玩玩吧。
货到付款，相当于15块钱买了一个小板子。
, p5 y9 a9 e- D0 x+ {* y提供的资料很全，有历程代码,有规格书。
* q% o% x' V; n3 S( y  y5 p
+++++++++++框架介绍++++++++++++++++
工作逻辑：按键板一共6个脚连接到STM32主控板
' l* @, q( f7 c1上电（不管）
( a, f, Q! x8 N2接地（不管）
1 n6 ]0 e: t! c9 T4 D' R) Q3复位（就是接到STM32的一个GPIO，先拉高在拉低在拉高就可以让这个按键板复位一次）
4中断 (也是接到STM32的一个GPIO，当有按键被按的时候这个电平会突然拉高，也就触发了中断线。然后你去就IIC总线读数据)
5 r. W& \2 C1 W0 O! j+ E! R5（IIC SDA）
6 (IIC SCL)
! L/ d# o! G# R& e3 m所以主要知识点是：A中断线（类似于很多教程里面的按键触发LED灯亮起）B IIC通讯（类似有ATC02存储的教程）
+ s4 d* b9 H: ]3 a9 Y++++++++开始吧+++++++++++


2 C2 ]4 U5 D! L后面的配置都没有修改。(用了一个TIM定时器来做延时)

! a, _5 L! ?$ U( x4 N




& o2 j1 M$ ?& X/ `
; O1 c, C2 T8 @4 y# Y9 Z
基于cubemx+硬件IIC 几分钟就跑通了。
- a3 I0 K! i# u/ ?3 V- z+ x5 D* X很快问题也就来了。（反馈给HTK公司技术的视频）
. k( E1 O3 T' i4 v/ @5 O) I* Ahttps://pan.baidu.com/s/10pr82ORcf4lanSPKwMdPHw
数据是00-32-32-32，虽然可以用，但有点膈应。
于是打算放弃硬件IIC，自己也来模拟IIC吧。
所以回到标题：机器风格的单片机程序
3 V$ X) l% U1 L8 @: c* r  j' T

1. #include "HALI2C.h"
   
2. 
   & i+ O! q/ d% [  y
3. _STM32I2CHandleType TemIIC;
   
4. STM32I2CHandleType  pSTM32I2C=&TemIIC;
   6 ?) A' P2 S0 F, ]9 B9 s: X6 q
5. 
   " P4 s3 Y+ E5 P2 ]* W
6. /*初始化 时钟 GPIO 两线都高*/
   . U2 s, p. p; N0 I% P4 i' k
7. void I2C_init(void)
   
8. {        
   
9.         GPIO_InitTypeDef GPIO_InitStruct;
   ) o/ ?' o, Q8 T3 g
10.         __HAL_RCC_GPIOD_CLK_ENABLE();
    
11.         __HAL_RCC_GPIOA_CLK_ENABLE();
    
12.         __HAL_RCC_GPIOB_CLK_ENABLE();
    ! K- G( y: X; |/ j/ J
13.         GPIO_InitStruct.Pin=pSTM32I2C->SCL_PIN|pSTM32I2C->SDA_PIN;
    4 b2 t; |9 X1 u/ ~4 t
14.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    
15.         GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;/*推荐复用输出*/
      R6 n) P  b0 ]5 A4 d7 V
16.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    ! d* G8 i8 s  V0 q' O
17. 
    
18.         pSTM32I2C->Set_SDA();
    
19.         pSTM32I2C->Set_SCL();
    
20. }
    ! [1 v. s, r2 s5 R  i; K. c
21. /*设置SDA为输出模式*/
    
22. void I2C_SDA_OUT(void)
    ) l! Y* }8 a( L9 G3 L1 l
23. {
    
24.   GPIO_InitTypeDef GPIO_InitStruct;        
    
25.         
    $ s. {$ y$ W5 p! l8 V; {( p
26.         GPIO_InitStruct.Pin=pSTM32I2C->SCL_PIN|pSTM32I2C->SDA_PIN;
    
27.         GPIO_InitStruct.Speed=GPIO_SPEED_FREQ_HIGH;
    / w& A" B/ j3 z. b4 t% ~. O2 [" G
28.         GPIO_InitStruct.Mode=GPIO_MODE_OUTPUT_PP;
    
29.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    % q4 p6 w' W& |& F- u; a6 k5 H
30. }
    ! U; }0 ]- l: v+ v9 e
31. /*设置SDA为输入模式*/
    
32. void I2C_SDA_IN(void)
    ) ~/ h, N3 F3 |0 [
33. {
    ' o% B& |' u: e6 @4 [- e
34.         GPIO_InitTypeDef GPIO_InitStruct;        
    - L" [4 H. P% u9 [1 g$ M: }
35.         
    4 Z. r+ [6 B1 x! J& V
36.         GPIO_InitStruct.Pin=pSTM32I2C->SDA_PIN;
    3 g8 i% k, Y3 l3 }; t, J
37.         GPIO_InitStruct.Mode=GPIO_MODE_INPUT;
    
38.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    
39. }
    
40. 
    
41. /*产生起始信号*/
    & e; {+ d4 g8 w: l$ h/ G$ ~
42. void I2C_Start(void)
    
43. {
    - }2 S7 t5 @* q2 V
44.         pSTM32I2C->Set_SDA_Output_Mode();
    
45.         pSTM32I2C->Set_SDA();
    " A8 G, H2 f) Z2 b) }  I( [
46.         pSTM32I2C->Set_SCL();
    : S% o* [: L7 _0 C7 }
47.         pSTM32I2C->Delayus(5);
    ! r1 P& B8 s, p6 X
48.         pSTM32I2C->Reset_SDA();
    2 o4 V: U$ y) t' b( B) _9 `* g: _
49.         pSTM32I2C->Delayus(5);
    * \! P$ Y+ F) v! b8 K1 p+ @
50.         pSTM32I2C->Reset_SCL();
    
51.         pSTM32I2C->Delayus(5);
    " r8 {9 G' o1 @6 p
52. }
    
53. 
    
54. /*产生停止信号*/
    
55. void I2C_Stop(void)
    0 ^2 G0 _% }. ~6 W6 r. g
56. {
    
57.    pSTM32I2C->Set_SDA_Output_Mode();
    
58.    pSTM32I2C->Reset_SCL();
    
59.    pSTM32I2C->Reset_SDA();
    ) V9 R- ^/ w( @* l; ~/ F4 f
60.    pSTM32I2C->Set_SCL();
    
61.    pSTM32I2C->Delayus(6);
    # e. o& T5 a6 r) J7 Y! Z, ]
62.    pSTM32I2C->Set_SDA();
    
63.    pSTM32I2C->Delayus(6);
    " s+ b8 X9 o" O* j' \* K2 _1 _8 b
64. }
    ! W& N- Q# E1 Q, b3 M+ H
65. 
    
66. //主机产生应答信号ACK
    
67. void I2C_Ack(void)
    ; {# T/ B4 u2 E
68. {
    ; K. l1 i+ z* K4 N; j
69.    pSTM32I2C->Reset_SCL();
    , G1 x6 t8 C2 e7 q5 c, S
70.          pSTM32I2C->Delayus(2);
    8 J" T# U( `0 S& ]6 [! A
71.    pSTM32I2C->Set_SDA_Output_Mode();
    , N! {$ i) j; Q0 Z8 T
72.    pSTM32I2C->Reset_SDA();
    % }) J7 p9 O# M: ]; a# `
73.    pSTM32I2C->Delayus(5);
    % A& h1 \! i2 d7 E' o* }  O
74.    pSTM32I2C->Set_SCL();
    * U% j" G5 E: B' I1 F4 X( e
75.    pSTM32I2C->Delayus(5);
    . F. M7 t( Q3 O
76.    pSTM32I2C->Reset_SCL();
    
77. }
    
78. 
    8 x+ E+ o1 e; o6 t
79. //主机不产生应答信号NACK
    1 f- f% r! w4 k+ O3 Y5 p% W6 @
80. void I2C_NAck(void)
    
81. {
    
82.          pSTM32I2C->Reset_SCL();
    
83.          pSTM32I2C->Delayus(2);
    
84.    pSTM32I2C->Set_SDA_Output_Mode();
    - h: M6 Z9 d8 Y8 n2 ], B9 g
85.    pSTM32I2C->Set_SDA();
    
86.    pSTM32I2C->Delayus(5);
    
87.    pSTM32I2C->Set_SCL();
    
88.    pSTM32I2C->Delayus(5);
    / K9 A% v$ [6 m7 C  o" o
89.    pSTM32I2C->Reset_SCL();
    9 r+ r6 r. `2 h+ x# S" H
90.          pSTM32I2C->Delayus(2);
    + g$ A, `9 e+ g) _9 ^4 ~% A( {( e
91. }
    5 _6 D) x, W& V3 R
92. //等待从机应答信号
    
93. //返回值：1 接收应答失败
      q. O2 g+ b- h1 B- [% Q3 z' E
94. //                    0 接收应答成功
    
95. unsigned char I2C_Wait_Ack(void)
    
96. {
    % B# j2 p. P; f* W; R
97.         unsigned char tempTime=0;
    
98. 
    
99.         pSTM32I2C->Set_SDA_Input_Mode();
    
100. 
     
101.         pSTM32I2C->Set_SDA();
     3 P) {; n. K, X! e8 r
102.         pSTM32I2C->Delayus(5);
       ^( B' D- p1 I' Z0 P
103.         pSTM32I2C->Set_SCL();
     7 P" [! R2 i% ~4 G3 l3 y8 y; C# ?
104.         pSTM32I2C->Delayus(2);
     + e# {' P+ s5 e- [3 }& Y
105. 
     
106. 
     
107.         while(pSTM32I2C->Get_SDA())
     
108.         {
     ( i. O- c5 i" i* S8 x
109.                 tempTime++;
     
110.                 if(tempTime>50)
     
111.                 {
     
112.                         pSTM32I2C->I2C_stop();
     
113.                         return 0;
     
114.                 }         
     - U' N7 {" P: T# G
115.         }
     ! r1 ^: J" C) U; f
116. 
     
117.         pSTM32I2C->Reset_SCL();
     
118.         pSTM32I2C->Delayus(5);
     ! }! O/ [. M& D6 h4 w; p
119.         return 1;
     ( p& l1 m" F4 f/ v( d% o! N
120. }
     + Z2 k% S6 g5 ~, M3 u
121. //I2C 发送一个字节
     - n6 |/ D7 T: X6 @. G& B, x  l8 F
122. void I2C_Send_Byte(unsigned char txd)
     9 h4 _* S7 y4 f; @! l
123. {
     
124.         unsigned char i=0;
     
125. 
     
126.         pSTM32I2C->Set_SDA_Output_Mode();
     3 w2 s4 p/ C* b( ]6 j* z# B, ?/ S
127.         pSTM32I2C->Reset_SCL();//拉低时钟开始数据传输
     
128. 
     / X, W: X# r7 E7 m" J, a
129.         for(i=0;i<8;i++)
     
130.         {
     & D( ~  B6 Q4 F: \0 N
131.                 if((txd<<i)&0x80)
     " Q7 E! |, Q" s: [5 {% i! ]
132.                         pSTM32I2C->Set_SDA();
     1 R0 ^, Y4 \; s; U* F/ k) I6 V
133.                 else
     . j$ V2 U9 @; S. _4 s; R' {8 V
134.                         pSTM32I2C->Reset_SDA();
     . b! q  u; ?6 Q& t
135.                
     4 C2 d( S# S* [( V
136.           pSTM32I2C->Delayus(2);
     6 y4 |6 A+ b+ o( X  p' O( U
137.                 pSTM32I2C->Set_SCL();
     
138.                 pSTM32I2C->Delayus(5); //发送数据
     
139.                 pSTM32I2C->Reset_SCL();
     
140.                 pSTM32I2C->Delayus(2);
     
141.         }
     9 @3 w$ L4 g& D
142. }
     + a/ ?) y2 N. J1 x- B
143. 
     
144. //I2C 读取一个字节
     , t7 w$ I& C) a
145. 
     ( a. e8 l3 e) p% f6 `$ F
146. unsigned char I2C_Read_Byte(unsigned char ack)
     / s/ b& L! \3 {
147. {
     
148.    unsigned char i=0,receive=0;
     
149. 
     
150.    pSTM32I2C->Set_SDA_Input_Mode();
       o0 P% n$ E3 i+ }, f$ Y" h
151.    for(i=0;i<8;i++)
     ( O5 O: W$ @) Z9 n) B" r
152.    {
     ' q6 o9 m5 O# y& g- ?2 ~6 u- P2 B
153.            pSTM32I2C->Reset_SCL();
     3 t% ~, Q: D: X3 y4 H/ j9 X$ R$ y
154.                 pSTM32I2C->Delayus(5);
     4 c+ M/ y0 z4 q) D4 S/ x7 O
155.                 pSTM32I2C->Set_SCL();
     - j' c9 ?3 c, o- L: e% X. Z
156.                 receive<<=1;
     . N# x0 V8 V: N
157.                 if(pSTM32I2C->Get_SDA())
     
158.                    receive++;
     
159.                 pSTM32I2C->Delayus(5);        
     
160.    }
     
161. 
     * h, x5 _; o" O# @
162.            if(ack==0)
     * U( F: j  r# M0 ^: d/ {0 d  E& [
163.                    pSTM32I2C->I2C_withnoAck();
     
164.           else
     7 o5 Z1 y6 Q$ ~/ [8 o! @) l: p
165.                   pSTM32I2C->I2C_withAck();
     
166. 
     " s$ p; @: i+ ?% @9 E) k4 G
167.         return receive;
     
168. }
     
169. 
     , m+ p5 w8 `4 N9 R0 |
170. void set_SDA(void)
     5 w/ U1 n* H( j* w
171. {
     ) F4 N& w+ }+ S. k& w
172.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN,GPIO_PIN_SET);
     & J6 Y* U* r. s
173. }
     5 I8 G# }3 A4 ^& w5 F7 ^% X+ u- Y
174. void set_SCL(void)
     
175. {
     
176.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SCL_PIN,GPIO_PIN_SET);
       Q3 f# e" J" X5 y* H
177. }
     - v) P1 T+ J- ]/ ^
178. void reset_SDA(void)
     
179. {
     ! B" M# g/ @& d5 g3 A) _
180.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN,GPIO_PIN_RESET);
     & M5 W* L! A2 y) j" p* H
181. }
     
182. void reset_SCL(void)
     
183. {
     ; V1 c9 f4 K+ w( @9 N: D+ W
184.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SCL_PIN,GPIO_PIN_RESET);
     
185. }
     
186. unsigned char read_SDAPIN(void)
     
187. {
     ' Z! D5 r" h$ o7 J/ m7 ~3 s
188.   return HAL_GPIO_ReadPin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN);
     
189. }
     * _/ a2 i* p% s
190. ///////////////////设备驱动//////////////////////
     . }7 X; a/ a. M
191. 
     3 {  ]; S% b9 ]  _9 o
192. void STM32IICInit(void)
     
193. {
     4 F! V1 L; `" A0 u  V% c$ }' H9 @' c9 ?
194.         _STM32I2CHandleType temIIC=
     6 u) q4 }* G! p& z
195.         {
     / A* U8 |$ ^) {' s6 ^
196.         .IICGPIO=GPIOB,
     
197.         .SCL_PIN=GPIO_PIN_6,
     6 @* Z6 K2 Y0 k& W0 ^: V9 q
198.         .SDA_PIN=GPIO_PIN_7,
     
199.         .I2C_Init=I2C_init,
     & A1 d( ?. a" a- }: }3 {$ f# I  i
200.         .Set_SDA=set_SDA,
     
201.         .Set_SCL=set_SCL,
     
202.         .Reset_SDA=reset_SDA,
     
203.         .Reset_SCL=reset_SCL,
     
204.         .Get_SDA=read_SDAPIN,
     $ G& i$ |8 u) H# n7 e
205.         .Delayus=TIM3_Delay,
     # X/ m' ^" X3 M7 F7 Y1 B/ _1 W0 d
206.         .Set_SDA_Input_Mode=I2C_SDA_IN,
     3 l4 }5 x& a+ _  _* ?
207.         .Set_SDA_Output_Mode=I2C_SDA_OUT,
     
208.         .I2C_start=I2C_Start,
     % a& V+ k* m$ e# ]
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,
     - r. |, l7 B  ?0 [
214.         .I2C_send_byte=I2C_Send_Byte,
     * L6 p  C( J! H& `! h: i5 w
215.         };
     4 A0 X6 E6 ~; h. n$ ]' Z
216. TemIIC=temIIC;/*做了一个临时变量 然后用=号做了赋值*/
     
217. pSTM32I2C->I2C_Init();
     7 `) u. d% ]& a9 m) E
218. }
     " W8 Q$ X; w$ [& @/ o- L
219. +++++++++++++++++++噢这不好 可以直接赋值的int a=9这样直接全局变量赋值+++++++++++++
     ' b9 u  V! d* M% b
220. 
     ' |, J3 E6 N/ f- y* u: \  M: p
221. char __HTK_I2C_Read_optimal_touch_keyval(unsigned char  *pKeyVal)
     
222. {
     
223. /*第一次发送器件物理地址+写命令*/
     
224.         pSTM32I2C->I2C_start();
     
225.         pSTM32I2C->Delayus(5);
     
226.         pSTM32I2C->I2C_send_byte((0X24<<1)|0) ;
     9 n- ~: ?8 f8 W1 K. {" k
227.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识
     
228. 
     9 I0 ^' i) i! F, p$ V
229.         
     
230. /*第二次发送器件内部地址*/        
     
231.         pSTM32I2C->Delayus(5);
     9 t1 C) Q. Z" a8 t( c
232.         pSTM32I2C->I2C_send_byte(0X80);
     
233.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     4 x/ D$ F! ]$ v/ M  ?
234. 
       w7 U6 }# k! C/ \
235.         
     
236.   pSTM32I2C->Delayus(5);
     
237. 
     5 ~! }5 @0 a) A7 M- D
238. /*第三次发送器件物理地址+读命令*/               
     % q: U6 S9 o0 l9 M& o+ r, ^5 Z5 Z
239.         pSTM32I2C->I2C_start();
     . O+ M2 d1 X: x2 B
240.         pSTM32I2C->Delayus(5);
     
241.         pSTM32I2C->I2C_send_byte((0X24<<1)|1) ;               
     
242.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     . N1 Q- P: [1 D1 j$ I. `) L
243. 
     ) R) s1 n7 W5 r# D
244. 
     ; ]1 s4 @1 W# d5 s( `2 _
245.         pSTM32I2C->Delayus(100);
     , f4 h# p/ C$ I6 p0 b
246. /*读取反馈数据 因为只读一个字节 所以不需要ack反馈信号*/        
     
247.         *pKeyVal = pSTM32I2C->I2C_read_byte(0);
     
248.         
     7 u2 B% L( Y  z
249.         pSTM32I2C->Delayus(5);
     
250.         pSTM32I2C->I2C_stop();        
     
251.         return 1;
     # k# w6 m8 L6 q; s; i
252. }
     
253. 
     
254. 
     
255. 
     
256. char __HTK_I2C_Read_keystatus(unsigned char  *pKeyVal)
     4 S: j! t1 S) b" Y) I
257. {
     ! x" K8 ~, p) A, x
258.         char i=0;
     
259. /*第一次发送器件物理地址+写命令*/
     
260.         pSTM32I2C->I2C_start();
     
261.         pSTM32I2C->Delayus(5);
     
262.         pSTM32I2C->I2C_send_byte((0X24<<1)|0) ;
     7 b2 z( r% ?7 d5 H# s' P. D
263.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识
     
264. 
     * M7 r7 Y$ f) O! v4 f
265.         
     
266. /*第二次发送器件内部地址*/        
     ' Z/ [0 P' U- Z; z; C  E* `
267.         pSTM32I2C->Delayus(5);
     / Q/ }& ?- L- S' d$ H
268.         pSTM32I2C->I2C_send_byte(0X81);
     5 t$ f$ e. ^+ p& a" K5 ~% _( U
269.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     2 c3 A: T. q6 C% \  v2 _
270. 
     
271.         
     
272.   pSTM32I2C->Delayus(5);
     
273. 
     . E1 y( [8 j5 Q6 J( B
274. /*第三次发送器件物理地址+读命令*/               
     
275.         pSTM32I2C->I2C_start();
     
276.         pSTM32I2C->Delayus(5);
     + b2 L: m4 s% n6 c, H# E/ z
277.         pSTM32I2C->I2C_send_byte((0X24<<1)|1) ;               
     / w! f# @$ M+ R$ l* @9 T1 g
278.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     
279. 
     
280. 
     
281.         pSTM32I2C->Delayus(100);
     ; d! ?% Z3 Y+ Y4 v, e; F
282. /*前面的代码和前面是一样的。*/        
     & M: [5 [0 y4 M) G) K: l$ r
283. /*前面0X80是读一个字节一个U8当前按下的值是多少*/        
     
284. /*现在我们是读0x81，后面4个字节4个U8*/        
     2 o$ B' S( S$ @  L
285.         for(i=0;i<3;i++)
     
286.                 pKeyVal[i] = pSTM32I2C->I2C_read_byte(1);
     + K# S( r. G. `4 R( q0 }
287.         /*前面3个字节需要ack反馈，最后一个字节就跟前面一样不用反馈*/
     
288.         pKeyVal[3]=pSTM32I2C->I2C_read_byte(0);
     
289.         
     " J% l, @$ b) I1 o, Z3 j
290.         pSTM32I2C->Delayus(5);
     , a9 R0 r# J/ j  d
291.         pSTM32I2C->I2C_stop();        
       n7 e) r/ f6 R2 D/ T/ i4 G6 U
292.         return 1;
     % N9 [. c" H. D; l& y: n
293. }
     

复制代码

1. #ifndef _HALI2C_H
   8 H$ T* S% J" A0 s
2. #define _HALI2C_H
   
3. #include "stm32f1xx_hal.h"
   
4. #include "tim.h"
   % y" r- x0 e7 g+ ^2 K5 h* U0 [& u
5. 
   
6. ////如果移植程序时只要改一下三个地方就行了
   
7. //#define I2C_SCL  GPIO_PIN_6
   " H. P9 e3 J: }6 B; N( J. U+ |4 |) w
8. //#define I2C_SDA  GPIO_PIN_7
   
9. //#define GPIO_I2C GPIOB
   7 {" A5 Z) P' D- V4 ^9 V% S  |& X
10. //#define delay_us TIM3_Delay  
    
11. 
    0 e2 K& l: S  S9 S0 x+ L" S
12. //#define I2C_SCL_H HAL_GPIO_WritePin(GPIO_I2C,I2C_SCL,GPIO_PIN_SET);
    + o) q- [; f# O- v9 Q1 i
13. //#define I2C_SCL_L HAL_GPIO_WritePin(GPIO_I2C,I2C_SCL,GPIO_PIN_RESET);
    / f& k- \3 m' c6 e" N+ ?
14. 
    
15. //#define I2C_SDA_H HAL_GPIO_WritePin(GPIO_I2C,I2C_SDA,GPIO_PIN_SET)
    
16. //#define I2C_SDA_L HAL_GPIO_WritePin(GPIO_I2C,I2C_SDA,GPIO_PIN_RESET)
    
17. 
    
18. //void I2C_Init(void);
    
19. //void I2C_SDA_OUT(void);
    0 O* L  L8 Z7 M! c( L$ n
20. //void I2C_SDA_IN(void);
    9 ~" J8 X4 b: u* T' P
21. //void I2C_Start(void);
    ; P7 e/ O7 _4 v" |
22. //void I2C_Stop(void);
    
23. //void I2C_Ack(void);
    
24. //void I2C_NAck(void);
    
25. //unsigned char I2C_Wait_Ack(void);
    & k5 G7 j% V- Q) N8 M3 s4 j$ r
26. //void I2C_Send_Byte(unsigned char txd);
    ' O+ ~9 @/ i# M% h- _1 Q+ V
27. //unsigned char I2C_Read_Byte(unsigned char ack);
    
28. 
    
29. 
    8 w4 p- t/ q" o- D
30. typedef struct
    
31. {
    
32.         GPIO_TypeDef *        IICGPIO;
    5 J5 |; p# x; Y4 X* @8 F
33.         uint16_t        SCL_PIN;
    * ]3 C7 B6 H0 |! H
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);
    2 f4 e" i- u5 d6 e- u
39.         void                                           (*Reset_SCL)(void);
    
40.         unsigned char   (*Get_SDA)(void);
    
41.         void                                           (*Delayus)(int Time);
    6 x$ |) K: L5 L* k' x) h
42.         void            (*Set_SDA_Input_Mode)(void);
      u: t: N+ U( _9 v+ R. ?, A
43.         void            (*Set_SDA_Output_Mode)(void);
    
44.         void                               (*I2C_start)(void);
    - j; a+ C% ^0 z" v
45.         void            (*I2C_stop)(void);
    - J8 s, u" _( G& u" i9 Z0 f
46.         void            (*I2C_withAck)(void);
    1 ^, n6 d4 H* D+ Y# E
47.         void            (*I2C_withnoAck)(void);
    
48.         unsigned char   (*I2C_Wait_Ack_Check)(void);
    
49.         unsigned char   (*I2C_read_byte)(unsigned char ack);
    * \2 \3 n, e" L
50.         void            (*I2C_send_byte)(unsigned char Byte);
    ) h8 Q$ N# |; u" [
51. }_STM32I2CHandleType,*STM32I2CHandleType;
      [+ A1 ~! B* }2 [: k
52. 
    " O! B0 u! P. @# m; J
53. void STM32IICInit(void);
    ) j: J( K  \' q6 i) J7 b3 \$ C
54. char __HTK_I2C_Read_keystatus(unsigned char  *pKeystatus);
    
55. char __HTK_I2C_Read_optimal_touch_keyval(unsigned char  *pdwStatus);
    ; ], R" U) E6 b8 R& d6 i3 J  c
56. #endif
    3 ~+ Y  U8 E# |/ z& p) m

复制代码

& B5 f& }/ d( Y和传统的代码是有差别的。
. @1 a% A8 f' y5 q2 Z0 M2 c+ ]2 u传统的是用宏定义修改(头文件能看到刘洋老师的影子)，现在全是函数。
全局变量
_STM32I2CHandleType TemIIC;
. D+ E' G0 w  f  K* pSTM32I2CHandleType pSTM32I2C=&TemIIC;
2 B5 z, R: U% O一个句柄，一个句柄指针，囊括了IIC所有的 属性。

+++++++++++++++20180611补充+++++++++++今天打开论坛看了一个帖子，发现一个不错的资源：就是自己做按键板。
2 F0 P: o. s' c! a2 T现在的按键盘是买的嘛，自己做怎么搞呢？
按键的扫描和设计。
3 N& G! b& k, o/ ] 矩阵按键扫描资料.rar (3.83 MB, 下载次数: 0)

2018-6-11 09:16 上传

点击文件名下载附件
学有余力再来自己设计吧
0 p5 G# J7 {0 g$ Q

自己又研究了个把小时，脑壳疼。硬件IIC问题先放着真的搞不明白。
现在的问题是：IIC的寄存器的值DR  是正确的它是U32
库函数过去的是U8的数组，挨个赋值。U8=U32这样(应该也是没事的 自动把高位放弃掉吧)
现象确是U8的数组第一个总是0后面的总是一样。
0 k) q) e5 f: M' |* H+ D& R埃
, W( H# p1 F8 ^( }0 ]/ }先用模拟的吧

楼主 厉害 学习了

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