这是最后一篇。自己昨天完成的一个工程，终于自己动手写出了人人喊打的代码。
* Z9 j* @: F4 h! G8 s% S
  c! b! D* R7 y9 C, d+++++++++++++项目介绍++++++++++++++++
逛论坛时间不长，新人，偶然看到@游名 发帖子免费申请按键板，我就参加了。
其实我公司也有做门禁的，我也是公司新人，业务不懂，就先玩玩吧。
* n: N" L; [+ \8 x) r4 D货到付款，相当于15块钱买了一个小板子。
: M+ t- x  S4 m2 i提供的资料很全，有历程代码,有规格书。
1 k  l- `* J/ W$ _
+++++++++++框架介绍++++++++++++++++
- h. N5 ]* w8 r1 t工作逻辑：按键板一共6个脚连接到STM32主控板
1上电（不管）
2 @0 S. B, {; c, K" \3 Y2接地（不管）
3复位（就是接到STM32的一个GPIO，先拉高在拉低在拉高就可以让这个按键板复位一次）
+ l" Q: H7 u$ @4中断 (也是接到STM32的一个GPIO，当有按键被按的时候这个电平会突然拉高，也就触发了中断线。然后你去就IIC总线读数据)
* ]) n  p  j+ Q5（IIC SDA）
9 l4 }2 ?) v+ L& s6 (IIC SCL)
所以主要知识点是：A中断线（类似于很多教程里面的按键触发LED灯亮起）B IIC通讯（类似有ATC02存储的教程）
( B8 p$ U2 H9 i. I8 V++++++++开始吧+++++++++++
9 J. _) d8 z0 G# Y* P
' \& F. e' m' v8 m
" ^* S6 r0 }" |& c# G后面的配置都没有修改。(用了一个TIM定时器来做延时)

. ?8 r& T& S( ~: _: R! _
: c3 l+ {: z+ H7 b

/ }; n6 l' E4 T: a% c



基于cubemx+硬件IIC 几分钟就跑通了。
很快问题也就来了。（反馈给HTK公司技术的视频）
https://pan.baidu.com/s/10pr82ORcf4lanSPKwMdPHw
" v8 X" q' x. d6 d' M8 u: |数据是00-32-32-32，虽然可以用，但有点膈应。
( v) \, z1 }  O* O于是打算放弃硬件IIC，自己也来模拟IIC吧。
7 x& i8 g' N2 D所以回到标题：机器风格的单片机程序
' y. a  g$ j5 K( Q' u

1. #include "HALI2C.h"
   
2. 
     y+ V& w& U& m  Z, ^, R  i* ?! x
3. _STM32I2CHandleType TemIIC;
   
4. STM32I2CHandleType  pSTM32I2C=&TemIIC;
   
5. 
   
6. /*初始化 时钟 GPIO 两线都高*/
   ; V8 s2 Q' b" Q) m
7. void I2C_init(void)
     \$ ^* C5 V# K5 \- R% ^
8. {        
   
9.         GPIO_InitTypeDef GPIO_InitStruct;
   
10.         __HAL_RCC_GPIOD_CLK_ENABLE();
    / k1 s3 P4 o' u. l8 j
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;
    / l; j: u$ n( h* k
15.         GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;/*推荐复用输出*/
    1 d$ E) \. A' R) ~
16.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    + I* E7 n0 e; d, e3 b. b
17. 
    % W9 ]) G" {7 g& Q; Q9 a
18.         pSTM32I2C->Set_SDA();
    
19.         pSTM32I2C->Set_SCL();
    
20. }
    3 f0 g  r1 A% y
21. /*设置SDA为输出模式*/
    
22. void I2C_SDA_OUT(void)
    & D" u0 M' a  H9 A% X! w
23. {
    ) g2 b* Z2 c* V! }* e8 p* l- `
24.   GPIO_InitTypeDef GPIO_InitStruct;        
      W  @; y5 L7 Y( f& T; K: Y1 _
25.         
    
26.         GPIO_InitStruct.Pin=pSTM32I2C->SCL_PIN|pSTM32I2C->SDA_PIN;
    * U% m8 h( {: w, f9 u+ H2 K" `
27.         GPIO_InitStruct.Speed=GPIO_SPEED_FREQ_HIGH;
    
28.         GPIO_InitStruct.Mode=GPIO_MODE_OUTPUT_PP;
    5 f3 G6 |: B9 n, d9 y6 R" l
29.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    . V  R) c1 J0 _/ n, I. ]$ G
30. }
    ) g9 e9 W3 c/ E* P" v5 b8 c+ \7 }
31. /*设置SDA为输入模式*/
    
32. void I2C_SDA_IN(void)
    
33. {
    " P  ^2 _2 f+ D2 O( r
34.         GPIO_InitTypeDef GPIO_InitStruct;        
    + w3 q/ j( E8 i" [! a4 K# `
35.         
    
36.         GPIO_InitStruct.Pin=pSTM32I2C->SDA_PIN;
    0 h& t. o( Z0 X  c* i
37.         GPIO_InitStruct.Mode=GPIO_MODE_INPUT;
    
38.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    
39. }
    9 A4 f. B* \' c  |0 ~9 X
40. 
    
41. /*产生起始信号*/
    
42. void I2C_Start(void)
    
43. {
    * w; I8 O' }% z6 Q, T9 g
44.         pSTM32I2C->Set_SDA_Output_Mode();
    
45.         pSTM32I2C->Set_SDA();
    
46.         pSTM32I2C->Set_SCL();
    + F# ]. j( i3 k2 p9 v  A7 D) i4 g  e
47.         pSTM32I2C->Delayus(5);
    
48.         pSTM32I2C->Reset_SDA();
    
49.         pSTM32I2C->Delayus(5);
    
50.         pSTM32I2C->Reset_SCL();
    
51.         pSTM32I2C->Delayus(5);
    , w. M5 h- I5 W  O- g. o+ [
52. }
    1 c8 F' S! a. m# _( O$ e. {
53. 
    9 [. t: H* J9 ^% V; h
54. /*产生停止信号*/
    
55. void I2C_Stop(void)
    0 h5 n  B, W- L, U. X
56. {
    
57.    pSTM32I2C->Set_SDA_Output_Mode();
    
58.    pSTM32I2C->Reset_SCL();
    
59.    pSTM32I2C->Reset_SDA();
    $ A" I$ \/ ?! Z( Y2 ~6 L
60.    pSTM32I2C->Set_SCL();
    
61.    pSTM32I2C->Delayus(6);
    . L: v* b3 ~! C) e& |
62.    pSTM32I2C->Set_SDA();
    ( C+ \# ]* Q! `. S
63.    pSTM32I2C->Delayus(6);
    
64. }
    
65. 
    4 m) O& L3 |1 z: ~$ d7 P
66. //主机产生应答信号ACK
    
67. void I2C_Ack(void)
    
68. {
    
69.    pSTM32I2C->Reset_SCL();
    1 F0 u0 z0 @8 K; B! K
70.          pSTM32I2C->Delayus(2);
    
71.    pSTM32I2C->Set_SDA_Output_Mode();
    
72.    pSTM32I2C->Reset_SDA();
    6 E4 M! E8 o4 G3 n* D8 t) \
73.    pSTM32I2C->Delayus(5);
    - H% }1 X9 p0 E+ ~
74.    pSTM32I2C->Set_SCL();
    
75.    pSTM32I2C->Delayus(5);
    
76.    pSTM32I2C->Reset_SCL();
    " s1 C7 d; j) ^9 P( e( `5 o8 @- {' `
77. }
    
78. 
    + o* X1 }( S0 Z1 K! y
79. //主机不产生应答信号NACK
    ; f2 o6 d* ?2 N% }! `9 n
80. void I2C_NAck(void)
    " f/ c% Z* C* K6 r5 x# v
81. {
    
82.          pSTM32I2C->Reset_SCL();
    ) g: g* b6 t& c& }& K2 w0 Y5 [4 t
83.          pSTM32I2C->Delayus(2);
    0 G9 d4 Q2 A1 i
84.    pSTM32I2C->Set_SDA_Output_Mode();
      \. m& b' E3 L. W
85.    pSTM32I2C->Set_SDA();
    
86.    pSTM32I2C->Delayus(5);
    
87.    pSTM32I2C->Set_SCL();
    * B5 F* y: Z- |9 ?' \1 c- t2 Z
88.    pSTM32I2C->Delayus(5);
    + b0 v/ X3 u1 p5 u9 b2 C* p, l5 B9 v6 R
89.    pSTM32I2C->Reset_SCL();
    0 c0 f9 C  A+ t, s
90.          pSTM32I2C->Delayus(2);
    
91. }
    ( u2 J7 T1 `. ?
92. //等待从机应答信号
    
93. //返回值：1 接收应答失败
    * x; G4 S8 [' }
94. //                    0 接收应答成功
    ( m* u4 s) K% T- F8 A2 _
95. unsigned char I2C_Wait_Ack(void)
    
96. {
    
97.         unsigned char tempTime=0;
    ' G1 {9 T2 `+ G( O
98. 
    3 Y* Z( a  @) B, O" Q7 w( O
99.         pSTM32I2C->Set_SDA_Input_Mode();
    
100. 
     
101.         pSTM32I2C->Set_SDA();
     
102.         pSTM32I2C->Delayus(5);
     2 P* k, A& r& q/ ~5 g; U
103.         pSTM32I2C->Set_SCL();
       U! }/ M0 h# C
104.         pSTM32I2C->Delayus(2);
     : [- u- ~4 T4 B' _  ~7 E: Y
105. 
     
106. 
     
107.         while(pSTM32I2C->Get_SDA())
     : G9 D8 q( T  s9 I' {2 }% ~
108.         {
     2 y6 P: `- w$ }4 r3 a) s
109.                 tempTime++;
     ' q0 Z, w0 @" s' Z6 V
110.                 if(tempTime>50)
     
111.                 {
     4 y1 E8 c3 s4 v/ g6 k
112.                         pSTM32I2C->I2C_stop();
     
113.                         return 0;
     8 ]. b, v. E! y* ~6 o7 Y0 a! l8 A9 c
114.                 }         
     
115.         }
     ) u/ T$ g. h+ e( C1 c! Y, z1 a, G
116. 
     
117.         pSTM32I2C->Reset_SCL();
     : \2 m9 U% _* L* ^" C6 q
118.         pSTM32I2C->Delayus(5);
     
119.         return 1;
     
120. }
     ) ]$ F# V+ j: ]
121. //I2C 发送一个字节
     
122. void I2C_Send_Byte(unsigned char txd)
     
123. {
     / J0 e  h9 P4 r) e1 W/ c
124.         unsigned char i=0;
     ! t8 r+ c) R/ o' k
125. 
     
126.         pSTM32I2C->Set_SDA_Output_Mode();
     
127.         pSTM32I2C->Reset_SCL();//拉低时钟开始数据传输
     / F1 z" m4 J" z( E5 w
128. 
     + N6 x; @1 K8 k, {
129.         for(i=0;i<8;i++)
     
130.         {
     $ f: A2 T. d* E
131.                 if((txd<<i)&0x80)
     / Q9 F- E- U/ U( r( E  v1 o
132.                         pSTM32I2C->Set_SDA();
     
133.                 else
     1 [6 v3 z  ?; [1 l2 q1 |
134.                         pSTM32I2C->Reset_SDA();
     
135.                
     3 E$ H8 O, }3 J: ?) f5 _3 j' H
136.           pSTM32I2C->Delayus(2);
     
137.                 pSTM32I2C->Set_SCL();
     
138.                 pSTM32I2C->Delayus(5); //发送数据
     
139.                 pSTM32I2C->Reset_SCL();
     1 b3 j% h, M( b- W2 H
140.                 pSTM32I2C->Delayus(2);
     7 i" O  E# y4 Y
141.         }
     
142. }
     
143. 
     ! c# u' Z7 _9 j4 b* Q9 D0 i
144. //I2C 读取一个字节
     
145. 
     
146. unsigned char I2C_Read_Byte(unsigned char ack)
     , a/ Y& q& H9 ~! ]
147. {
     2 \& d- K! |; S2 D$ A6 x7 B; p% v
148.    unsigned char i=0,receive=0;
     7 ^. _- u: j+ ^: y" c
149. 
     
150.    pSTM32I2C->Set_SDA_Input_Mode();
     
151.    for(i=0;i<8;i++)
     
152.    {
     ; d( {4 U2 }" C0 e  q
153.            pSTM32I2C->Reset_SCL();
     - P+ L1 Q- y  v% d
154.                 pSTM32I2C->Delayus(5);
     
155.                 pSTM32I2C->Set_SCL();
     
156.                 receive<<=1;
     
157.                 if(pSTM32I2C->Get_SDA())
     
158.                    receive++;
     
159.                 pSTM32I2C->Delayus(5);        
     
160.    }
     ) Q3 z; d9 c% Y5 l7 }2 ~$ X
161. 
     
162.            if(ack==0)
     8 F' m! ^' N4 H
163.                    pSTM32I2C->I2C_withnoAck();
     ' ]5 f! Q- p! W) y- [
164.           else
     
165.                   pSTM32I2C->I2C_withAck();
     
166. 
     6 e+ h7 l$ _+ `. H( m
167.         return receive;
     / C5 {$ K4 `( g; d
168. }
     , B8 C# s; \& b& b! n. q
169. 
     7 Y( d- o- s1 V. d
170. void set_SDA(void)
     + J) N) h- T6 z: r; j& j( M
171. {
     5 F" i: S2 [5 m
172.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN,GPIO_PIN_SET);
     
173. }
     
174. void set_SCL(void)
     & n, k& N- v4 K. }2 S
175. {
       [, `) @# x" ^. `, @$ I6 H' S* B
176.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SCL_PIN,GPIO_PIN_SET);
     5 Y  |9 P" V- @/ r% Y% C" D
177. }
     
178. void reset_SDA(void)
     
179. {
     
180.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN,GPIO_PIN_RESET);
     # C. C' w) E9 w( Q
181. }
     
182. void reset_SCL(void)
     " D; Q2 ]' s: T, b$ R+ |: }# q
183. {
     
184.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SCL_PIN,GPIO_PIN_RESET);
     
185. }
     
186. unsigned char read_SDAPIN(void)
     
187. {
     / L$ F* Z& g$ e6 S3 z5 b; A
188.   return HAL_GPIO_ReadPin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN);
     
189. }
     ; R+ a; B; i) _; x0 g
190. ///////////////////设备驱动//////////////////////
     0 j& s& z1 x: Y% o  g
191. 
       G  ?8 C# V- [& n, w4 m4 [0 F
192. void STM32IICInit(void)
     : R' P. h+ j2 R
193. {
     7 c) Z4 q& h' a0 R9 c
194.         _STM32I2CHandleType temIIC=
     " R: K- {% P, ?6 z
195.         {
     / o! _0 a9 n  ~# F
196.         .IICGPIO=GPIOB,
     
197.         .SCL_PIN=GPIO_PIN_6,
     . ]: E$ p+ M0 y. \
198.         .SDA_PIN=GPIO_PIN_7,
     
199.         .I2C_Init=I2C_init,
     
200.         .Set_SDA=set_SDA,
     
201.         .Set_SCL=set_SCL,
     
202.         .Reset_SDA=reset_SDA,
     
203.         .Reset_SCL=reset_SCL,
     ! E  T% u4 D$ Z7 {5 `& N6 r& S
204.         .Get_SDA=read_SDAPIN,
     
205.         .Delayus=TIM3_Delay,
     , \, b" u* I' A. Z
206.         .Set_SDA_Input_Mode=I2C_SDA_IN,
     
207.         .Set_SDA_Output_Mode=I2C_SDA_OUT,
     
208.         .I2C_start=I2C_Start,
     
209.         .I2C_stop=I2C_Stop,
     & c. W7 ~/ I, d# G+ H. M6 E) o
210.         .I2C_withAck=I2C_Ack,
     
211.         .I2C_withnoAck=I2C_NAck,
     
212.         .I2C_Wait_Ack_Check=I2C_Wait_Ack,
     . e' @- F$ t) f' E% ^/ W
213.         .I2C_read_byte=I2C_Read_Byte,
     ! p! X5 I  s, R' |7 {0 h1 T
214.         .I2C_send_byte=I2C_Send_Byte,
     
215.         };
     
216. TemIIC=temIIC;/*做了一个临时变量 然后用=号做了赋值*/
     / `8 \3 }' X/ d) b8 O' f; s. e1 x
217. pSTM32I2C->I2C_Init();
     ! w) |2 V, P  K" w7 [8 N$ m+ E
218. }
     
219. +++++++++++++++++++噢这不好 可以直接赋值的int a=9这样直接全局变量赋值+++++++++++++
     
220. 
     
221. char __HTK_I2C_Read_optimal_touch_keyval(unsigned char  *pKeyVal)
     + \$ @3 i* _$ |1 Z% \! a) S6 N) b
222. {
     ( J) \( x' I# }5 r1 m# X
223. /*第一次发送器件物理地址+写命令*/
     ' |7 e/ O7 A6 _, L
224.         pSTM32I2C->I2C_start();
     
225.         pSTM32I2C->Delayus(5);
     
226.         pSTM32I2C->I2C_send_byte((0X24<<1)|0) ;
     
227.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识
     ; i/ v1 n* B" A5 C' u
228. 
     
229.         
     - U5 }- @7 y2 X
230. /*第二次发送器件内部地址*/        
     1 |. A/ H9 l' j3 _
231.         pSTM32I2C->Delayus(5);
     
232.         pSTM32I2C->I2C_send_byte(0X80);
     5 o/ e0 d7 y5 C6 |3 w2 q" S
233.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     $ d- n0 v2 X) B  {* ?; O
234. 
     2 S1 Q8 H5 v/ \% K- y* J6 U  T) E( A% Q
235.         
     , B0 ?7 [6 s, w- Z
236.   pSTM32I2C->Delayus(5);
     
237. 
     
238. /*第三次发送器件物理地址+读命令*/               
     5 M4 N/ U* s. U( e
239.         pSTM32I2C->I2C_start();
     
240.         pSTM32I2C->Delayus(5);
     2 {! k* v) \, M  f+ I
241.         pSTM32I2C->I2C_send_byte((0X24<<1)|1) ;               
     
242.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     
243. 
     
244. 
     1 }" H% n( T6 d( R3 }: r& _
245.         pSTM32I2C->Delayus(100);
     3 r& A: H! q; _7 T
246. /*读取反馈数据 因为只读一个字节 所以不需要ack反馈信号*/        
     & B& Y" o5 p9 Q& R1 ~2 p9 i! g* r
247.         *pKeyVal = pSTM32I2C->I2C_read_byte(0);
     - K+ I+ r5 t; ^6 D7 k$ I6 i2 X
248.         
     
249.         pSTM32I2C->Delayus(5);
     , W# Z- g! S, p+ \
250.         pSTM32I2C->I2C_stop();        
     5 R# G, x2 q$ v! b7 r& B
251.         return 1;
     
252. }
     - }! S8 g6 B; l' R+ G3 ~6 H
253. 
     
254. 
     ' k. S* E% }8 }, q6 o
255. 
     % y* m  X5 ?! z0 l* M* _  P
256. char __HTK_I2C_Read_keystatus(unsigned char  *pKeyVal)
     
257. {
     ; [% j2 D9 B, g& ~* I/ d- g
258.         char i=0;
     
259. /*第一次发送器件物理地址+写命令*/
     9 X9 I$ H9 d% q+ R0 t
260.         pSTM32I2C->I2C_start();
     
261.         pSTM32I2C->Delayus(5);
     1 y+ i0 o9 Q! @$ u  L; x* ~
262.         pSTM32I2C->I2C_send_byte((0X24<<1)|0) ;
     4 b/ t9 D( G0 |1 P7 D' f
263.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识
     " J) S  ^. p/ Z7 e3 W0 r
264. 
     & o1 I4 v( n7 ~2 l; H. o' j! E; s
265.         
     
266. /*第二次发送器件内部地址*/        
     # J+ c2 r+ r5 h, R
267.         pSTM32I2C->Delayus(5);
     2 Q6 ^: A  H  }, ]9 `; z) n  b
268.         pSTM32I2C->I2C_send_byte(0X81);
     
269.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     : `* ]: m' S3 u1 e
270. 
     . C; E) B3 Y+ |  a: L: O" u" b
271.         
     
272.   pSTM32I2C->Delayus(5);
     1 a6 |  {+ S( ]/ i' ?+ f2 _2 q
273. 
     9 ?5 u' @# n+ ]3 q
274. /*第三次发送器件物理地址+读命令*/               
     
275.         pSTM32I2C->I2C_start();
     9 ]! A+ h+ \$ ~# U% z6 t8 m, y
276.         pSTM32I2C->Delayus(5);
     
277.         pSTM32I2C->I2C_send_byte((0X24<<1)|1) ;               
     6 A3 U8 r2 p& U5 l: z" M  d
278.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     - a6 x! G4 E% F; \8 y& J
279. 
     $ ^+ t. D/ h, ?* Z% C
280. 
     
281.         pSTM32I2C->Delayus(100);
     
282. /*前面的代码和前面是一样的。*/        
     
283. /*前面0X80是读一个字节一个U8当前按下的值是多少*/        
     ) a) U. d2 T2 g& D6 _, T& n* e
284. /*现在我们是读0x81，后面4个字节4个U8*/        
     
285.         for(i=0;i<3;i++)
     7 u. @- W: R( J' F& ~  t' D
286.                 pKeyVal[i] = pSTM32I2C->I2C_read_byte(1);
     
287.         /*前面3个字节需要ack反馈，最后一个字节就跟前面一样不用反馈*/
     
288.         pKeyVal[3]=pSTM32I2C->I2C_read_byte(0);
     ( R- Y8 i5 o; @8 U. C6 a3 d
289.         
     ) F2 \9 w1 K9 T3 X3 K
290.         pSTM32I2C->Delayus(5);
     3 _6 R. F7 T& G, ^/ M. j% v
291.         pSTM32I2C->I2C_stop();        
     3 o; ]$ W+ c3 f  y5 X9 c- Q, a2 v) c
292.         return 1;
     
293. }
     

复制代码

1. #ifndef _HALI2C_H
   1 Q) i8 J* {1 a) h
2. #define _HALI2C_H
   / ?- Q6 U7 ?' F0 z
3. #include "stm32f1xx_hal.h"
   $ s5 W' \/ h* m: W
4. #include "tim.h"
   1 a- S. N* ^: R) I* h- @
5. 
   & X5 _( k: W/ _
6. ////如果移植程序时只要改一下三个地方就行了
   , B2 F3 q. w  P2 d* `
7. //#define I2C_SCL  GPIO_PIN_6
   ! b/ w+ f7 W( R+ \0 K1 E
8. //#define I2C_SDA  GPIO_PIN_7
   8 r* D, n' E3 n) q) y9 J2 |
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);
    4 S$ V) n# s$ U) ~
13. //#define I2C_SCL_L HAL_GPIO_WritePin(GPIO_I2C,I2C_SCL,GPIO_PIN_RESET);
    
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);
    + W, F8 Z, S7 ]% a4 W3 C
19. //void I2C_SDA_OUT(void);
    
20. //void I2C_SDA_IN(void);
    
21. //void I2C_Start(void);
    
22. //void I2C_Stop(void);
    
23. //void I2C_Ack(void);
    
24. //void I2C_NAck(void);
    ) o" r; c4 u$ R5 A9 P
25. //unsigned char I2C_Wait_Ack(void);
    
26. //void I2C_Send_Byte(unsigned char txd);
    
27. //unsigned char I2C_Read_Byte(unsigned char ack);
    4 D- E5 C& m/ J
28. 
    
29. 
    7 F3 f3 |7 R4 \3 f
30. typedef struct
    * V* a: _/ D1 Y  a
31. {
    
32.         GPIO_TypeDef *        IICGPIO;
    % ]% Z# H. A7 y8 l9 U( Q7 z- _
33.         uint16_t        SCL_PIN;
    
34.         uint16_t        SDA_PIN;
    % L7 N" g9 R* W) b  a5 Z; S
35.         void                                           (*I2C_Init)(void);
    2 }3 b& y4 {8 M- M5 o% r6 d0 _
36.         void                                           (*Set_SDA)(void);
    9 I) u+ f2 o/ q: s) W. `% P
37.         void                                           (*Set_SCL)(void);
    
38.         void                                           (*Reset_SDA)(void);
    
39.         void                                           (*Reset_SCL)(void);
    
40.         unsigned char   (*Get_SDA)(void);
    
41.         void                                           (*Delayus)(int Time);
    
42.         void            (*Set_SDA_Input_Mode)(void);
    5 M2 Z$ A1 l  b+ y3 J* \" M! E
43.         void            (*Set_SDA_Output_Mode)(void);
    ' G4 q2 W+ C+ ^& S3 K
44.         void                               (*I2C_start)(void);
    
45.         void            (*I2C_stop)(void);
    : P9 i4 }$ ~- R7 C9 }1 M5 _
46.         void            (*I2C_withAck)(void);
    
47.         void            (*I2C_withnoAck)(void);
    ( ?8 O4 m# ?' ?2 _
48.         unsigned char   (*I2C_Wait_Ack_Check)(void);
    : Y0 y; X+ Y. w
49.         unsigned char   (*I2C_read_byte)(unsigned char ack);
    : g. x5 U: d5 v7 V: j% E+ o: U
50.         void            (*I2C_send_byte)(unsigned char Byte);
    
51. }_STM32I2CHandleType,*STM32I2CHandleType;
    
52. 
    ' Y' g$ L/ h/ N& d/ Y
53. void STM32IICInit(void);
    
54. char __HTK_I2C_Read_keystatus(unsigned char  *pKeystatus);
    1 d& W+ Q  y$ F$ I9 ?
55. char __HTK_I2C_Read_optimal_touch_keyval(unsigned char  *pdwStatus);
    
56. #endif
    3 L6 @9 g  r& V7 m% l5 ]2 Z( t. `

复制代码

" E; n3 {1 R- g( c6 O和传统的代码是有差别的。
3 y: u; b" q2 f! l传统的是用宏定义修改(头文件能看到刘洋老师的影子)，现在全是函数。
0 n4 Y3 f9 x, m5 Z$ E7 T( j全局变量
' w9 r8 j% A- U& w_STM32I2CHandleType TemIIC;
STM32I2CHandleType pSTM32I2C=&TemIIC;
一个句柄，一个句柄指针，囊括了IIC所有的 属性。

' U" J( z+ m8 b2 m/ E7 k% ~* Y+++++++++++++++20180611补充+++++++++++今天打开论坛看了一个帖子，发现一个不错的资源：就是自己做按键板。
现在的按键盘是买的嘛，自己做怎么搞呢？
8 Z$ d: y5 B( k9 a! K/ G1 c按键的扫描和设计。
矩阵按键扫描资料.rar (3.83 MB, 下载次数: 0)

2018-6-11 09:16 上传

点击文件名下载附件
5 Z7 q3 P- ]6 N) H) }学有余力再来自己设计吧
& h8 T. ]7 t" f+ A6 {' ]8 ]  g: n

自己又研究了个把小时，脑壳疼。硬件IIC问题先放着真的搞不明白。
' {  p' q5 o. B: s  A! X现在的问题是：IIC的寄存器的值DR  是正确的它是U32
1 [- x8 o$ b, T3 \库函数过去的是U8的数组，挨个赋值。U8=U32这样(应该也是没事的 自动把高位放弃掉吧)
现象确是U8的数组第一个总是0后面的总是一样。
9 u3 f1 M% {( j) l$ [6 h- x, i. o埃
" A( W) n/ [' [; s, \先用模拟的吧

楼主 厉害 学习了

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