9 `% _! M0 a4 e$ s1 ?# M( m" N/ M& \
' s6 [, n8 d) A7 |' ~9 T这是最后一篇。自己昨天完成的一个工程，终于自己动手写出了人人喊打的代码。
7 O. A4 n( s  D
' o' _# v0 |- S- L' _+++++++++++++项目介绍++++++++++++++++
" A4 j! V/ W9 n+ [2 w2 H逛论坛时间不长，新人，偶然看到@游名 发帖子免费申请按键板，我就参加了。
其实我公司也有做门禁的，我也是公司新人，业务不懂，就先玩玩吧。
货到付款，相当于15块钱买了一个小板子。
7 x  |5 `2 E* v0 J提供的资料很全，有历程代码,有规格书。

; C6 `% y" Z5 j+++++++++++框架介绍++++++++++++++++
工作逻辑：按键板一共6个脚连接到STM32主控板
8 i7 F: [) q- @/ F1上电（不管）
  u# x# l+ H- |% O2接地（不管）
3复位（就是接到STM32的一个GPIO，先拉高在拉低在拉高就可以让这个按键板复位一次）
4中断 (也是接到STM32的一个GPIO，当有按键被按的时候这个电平会突然拉高，也就触发了中断线。然后你去就IIC总线读数据)
5（IIC SDA）
6 (IIC SCL)
所以主要知识点是：A中断线（类似于很多教程里面的按键触发LED灯亮起）B IIC通讯（类似有ATC02存储的教程）
4 U1 o5 }, {; U& J++++++++开始吧+++++++++++


( ?* `( s0 @3 Q后面的配置都没有修改。(用了一个TIM定时器来做延时)
* U5 @6 q3 ?+ f; f& h

4 |( N, S# W% d. h



  G, _! S, ~1 c. n5 F$ ~

基于cubemx+硬件IIC 几分钟就跑通了。
1 J* ^7 X8 v/ c2 ^" _很快问题也就来了。（反馈给HTK公司技术的视频）
https://pan.baidu.com/s/10pr82ORcf4lanSPKwMdPHw
7 m9 q& @. w9 Z/ ]0 F. {! O数据是00-32-32-32，虽然可以用，但有点膈应。
- u. X  E+ ?/ c* R/ M于是打算放弃硬件IIC，自己也来模拟IIC吧。
; K$ |% T2 d2 X' A& V, G" u所以回到标题：机器风格的单片机程序

1. #include "HALI2C.h"
   
2. 
   
3. _STM32I2CHandleType TemIIC;
   1 P7 q7 e8 j* Z  ^/ }5 R  T1 B8 l
4. STM32I2CHandleType  pSTM32I2C=&TemIIC;
   1 e4 {" X8 e; q1 _4 M
5. 
   
6. /*初始化 时钟 GPIO 两线都高*/
   
7. void I2C_init(void)
   " z1 G+ h0 k( ^5 s4 M
8. {        
   # w* O1 W1 o  w
9.         GPIO_InitTypeDef GPIO_InitStruct;
   * l$ N2 }0 b8 h5 j3 D7 U; s/ q
10.         __HAL_RCC_GPIOD_CLK_ENABLE();
    
11.         __HAL_RCC_GPIOA_CLK_ENABLE();
    7 Y$ T# n% ~- a) h( o
12.         __HAL_RCC_GPIOB_CLK_ENABLE();
    
13.         GPIO_InitStruct.Pin=pSTM32I2C->SCL_PIN|pSTM32I2C->SDA_PIN;
    
14.         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    
15.         GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;/*推荐复用输出*/
    # m& B- {! s) ?/ N& |. |/ q
16.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    
17. 
    
18.         pSTM32I2C->Set_SDA();
    
19.         pSTM32I2C->Set_SCL();
    
20. }
    8 v/ ]- J, W; }0 i+ E. [& g
21. /*设置SDA为输出模式*/
    0 E8 I3 O$ ~  r, Y
22. void I2C_SDA_OUT(void)
    7 R. R5 e2 r9 i' W' S: n
23. {
    $ a9 }/ V; U! Y: v! x
24.   GPIO_InitTypeDef GPIO_InitStruct;        
    8 |* Z  G) |' e: z, d2 `! |. G
25.         
    : a' k1 d0 y* y: I" g: u
26.         GPIO_InitStruct.Pin=pSTM32I2C->SCL_PIN|pSTM32I2C->SDA_PIN;
    7 Q  S' n: w+ _" N5 a/ R
27.         GPIO_InitStruct.Speed=GPIO_SPEED_FREQ_HIGH;
      Y3 f& `5 z+ `, \) E9 k! H/ S
28.         GPIO_InitStruct.Mode=GPIO_MODE_OUTPUT_PP;
    4 r! H% I! f* ]
29.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    , q, @4 |- }6 L" @, t
30. }
    
31. /*设置SDA为输入模式*/
    ( u- Q7 V$ l4 v6 [  h1 ?
32. void I2C_SDA_IN(void)
    
33. {
    
34.         GPIO_InitTypeDef GPIO_InitStruct;        
    ( N1 _" z2 t0 B8 p% K
35.         
    
36.         GPIO_InitStruct.Pin=pSTM32I2C->SDA_PIN;
    $ k/ D" R/ E% q7 Z; p
37.         GPIO_InitStruct.Mode=GPIO_MODE_INPUT;
    . k, X/ Z( V" m0 d% s* }
38.         HAL_GPIO_Init(pSTM32I2C->IICGPIO, &GPIO_InitStruct);
    
39. }
    
40. 
    8 v! Y* r' X; w! ]5 _
41. /*产生起始信号*/
    
42. void I2C_Start(void)
    : Z8 O0 e2 D9 q0 R% V2 \2 }
43. {
    
44.         pSTM32I2C->Set_SDA_Output_Mode();
    " c! p" ^: i/ t6 Q
45.         pSTM32I2C->Set_SDA();
    
46.         pSTM32I2C->Set_SCL();
    * l# ?0 B8 o( @9 m) U
47.         pSTM32I2C->Delayus(5);
    
48.         pSTM32I2C->Reset_SDA();
    4 Z, N# D: f; f/ Q
49.         pSTM32I2C->Delayus(5);
    0 J# |3 H6 f* m4 ]
50.         pSTM32I2C->Reset_SCL();
    
51.         pSTM32I2C->Delayus(5);
    , \% ~+ Y( o. J0 S8 v
52. }
    % }" K. y  ~  I8 f
53. 
    
54. /*产生停止信号*/
    ) J+ D9 _- M5 R2 g9 o( t
55. void I2C_Stop(void)
    
56. {
    
57.    pSTM32I2C->Set_SDA_Output_Mode();
    
58.    pSTM32I2C->Reset_SCL();
    
59.    pSTM32I2C->Reset_SDA();
    2 O" m8 {& B# }" E9 i! L: @
60.    pSTM32I2C->Set_SCL();
    5 r& L, x' a+ J3 F% Q9 G+ s
61.    pSTM32I2C->Delayus(6);
    
62.    pSTM32I2C->Set_SDA();
    
63.    pSTM32I2C->Delayus(6);
    
64. }
    
65. 
    " u- ~2 v3 F0 H. O5 ~# X# j" Z
66. //主机产生应答信号ACK
    9 a" G6 Z* u1 p7 H; l
67. void I2C_Ack(void)
    % w) X: I0 k; x
68. {
    
69.    pSTM32I2C->Reset_SCL();
    
70.          pSTM32I2C->Delayus(2);
    # W! t. e* j6 b: \" j
71.    pSTM32I2C->Set_SDA_Output_Mode();
    : _9 ?. `& ~9 |; X# V
72.    pSTM32I2C->Reset_SDA();
    - H. \$ n1 X! U0 m8 S8 T
73.    pSTM32I2C->Delayus(5);
    * U/ l1 S& [& @( e8 `8 p5 g) E
74.    pSTM32I2C->Set_SCL();
    " Q. C7 x. d; }0 F) T
75.    pSTM32I2C->Delayus(5);
    
76.    pSTM32I2C->Reset_SCL();
    : K1 @. U. C& M& s7 P6 `
77. }
    
78. 
    
79. //主机不产生应答信号NACK
    
80. void I2C_NAck(void)
    
81. {
    
82.          pSTM32I2C->Reset_SCL();
    
83.          pSTM32I2C->Delayus(2);
    2 I( w, v9 w. g1 f# ^' I
84.    pSTM32I2C->Set_SDA_Output_Mode();
    , C6 _: `7 X( J) I5 N/ n7 S
85.    pSTM32I2C->Set_SDA();
    
86.    pSTM32I2C->Delayus(5);
    8 a6 M' @( M& q, l2 c! d
87.    pSTM32I2C->Set_SCL();
    
88.    pSTM32I2C->Delayus(5);
    
89.    pSTM32I2C->Reset_SCL();
    
90.          pSTM32I2C->Delayus(2);
    
91. }
    4 T! I+ b5 f5 t
92. //等待从机应答信号
    7 |9 V. O0 G' z9 O: S* E
93. //返回值：1 接收应答失败
    0 E8 N) h1 d% m0 u. p
94. //                    0 接收应答成功
    
95. unsigned char I2C_Wait_Ack(void)
    9 w. w2 ]3 }2 \$ N0 i
96. {
    
97.         unsigned char tempTime=0;
    2 [1 T. L% p/ D+ |* j: t9 x& C
98. 
    6 S' t% R& N) b. z$ W
99.         pSTM32I2C->Set_SDA_Input_Mode();
    : K% g' ~" j! Q, [* A
100. 
     
101.         pSTM32I2C->Set_SDA();
     ) |& u; I7 d; j" ?. g
102.         pSTM32I2C->Delayus(5);
     
103.         pSTM32I2C->Set_SCL();
     6 W/ T- [+ V% r- V* r7 C
104.         pSTM32I2C->Delayus(2);
     4 g# n# Y  B3 i
105. 
     ; h2 k  P9 q: i3 S+ ^2 \* y
106. 
     
107.         while(pSTM32I2C->Get_SDA())
     
108.         {
     
109.                 tempTime++;
     
110.                 if(tempTime>50)
     
111.                 {
     
112.                         pSTM32I2C->I2C_stop();
     
113.                         return 0;
     8 _* v. P# l% c" m) R# r
114.                 }         
     6 V+ y0 H* [9 d. S* G
115.         }
     0 T8 Y7 f5 _! f% {; z7 N
116. 
     
117.         pSTM32I2C->Reset_SCL();
     7 D/ R; B" U1 |. s4 x+ G# y& L
118.         pSTM32I2C->Delayus(5);
     
119.         return 1;
     7 E9 E% Q4 V" d$ k5 x0 _3 |8 k# u
120. }
     5 _9 B* u6 ^( K+ V
121. //I2C 发送一个字节
     & \& g6 t/ A1 m. g" \2 r$ f% O
122. void I2C_Send_Byte(unsigned char txd)
     
123. {
     8 U0 K/ B; p- o1 g9 B& L
124.         unsigned char i=0;
     
125. 
     
126.         pSTM32I2C->Set_SDA_Output_Mode();
     
127.         pSTM32I2C->Reset_SCL();//拉低时钟开始数据传输
     
128. 
     
129.         for(i=0;i<8;i++)
     : e9 G# @. q- |3 X( i$ ~; {2 u
130.         {
     
131.                 if((txd<<i)&0x80)
     
132.                         pSTM32I2C->Set_SDA();
     ! L" y/ J5 }# q3 y/ T
133.                 else
     $ E- ~9 ~& z& Z1 `4 M. O3 r& k
134.                         pSTM32I2C->Reset_SDA();
     
135.                
     , K: d# y4 |. F: T: D: l
136.           pSTM32I2C->Delayus(2);
     
137.                 pSTM32I2C->Set_SCL();
     ( h/ i+ ~3 E' i5 b
138.                 pSTM32I2C->Delayus(5); //发送数据
     6 }6 _- m3 Y0 Y. F9 K1 D
139.                 pSTM32I2C->Reset_SCL();
     7 W( H; _3 c3 A$ {+ \& o
140.                 pSTM32I2C->Delayus(2);
     * C; Y& I) h  P
141.         }
     
142. }
     ( @7 j. |  f% q6 D/ V0 O! `
143. 
     
144. //I2C 读取一个字节
     
145. 
     
146. unsigned char I2C_Read_Byte(unsigned char ack)
     
147. {
     
148.    unsigned char i=0,receive=0;
     ! k  G' S; A5 R- v$ G% Z
149. 
     7 F0 ]0 g" s. n  M* }3 d% m  O
150.    pSTM32I2C->Set_SDA_Input_Mode();
     5 T+ |: M+ I6 V  M) P% W
151.    for(i=0;i<8;i++)
     " L! n1 W$ Z( P3 E3 \5 R
152.    {
     5 s+ d% ?  c6 O$ u1 W9 m
153.            pSTM32I2C->Reset_SCL();
     
154.                 pSTM32I2C->Delayus(5);
     
155.                 pSTM32I2C->Set_SCL();
     ) Y4 Q1 [; H8 s5 C. a) w$ y
156.                 receive<<=1;
     
157.                 if(pSTM32I2C->Get_SDA())
     
158.                    receive++;
     . {& U3 [! u. p+ W1 m3 p% L
159.                 pSTM32I2C->Delayus(5);        
     
160.    }
     
161. 
     
162.            if(ack==0)
     2 z& g* }; I8 z$ B
163.                    pSTM32I2C->I2C_withnoAck();
     1 L. v8 c2 N9 D
164.           else
     
165.                   pSTM32I2C->I2C_withAck();
     
166. 
     - v4 D9 @7 v5 l# H9 v" K& ~5 x
167.         return receive;
     
168. }
     / X9 l- {+ q' P& M* D$ Y  P& L
169. 
     ! k; d( O! {1 o
170. void set_SDA(void)
     
171. {
     
172.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN,GPIO_PIN_SET);
     
173. }
     
174. void set_SCL(void)
     4 M' G& H0 ?$ v% b
175. {
     
176.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SCL_PIN,GPIO_PIN_SET);
     
177. }
     , e' z6 \  f2 ^0 j+ T6 c/ D4 @
178. void reset_SDA(void)
     
179. {
     
180.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN,GPIO_PIN_RESET);
     % x1 K( O, u4 L0 @' N- p
181. }
     7 E+ Q6 t* d2 J+ B
182. void reset_SCL(void)
     
183. {
     
184.         HAL_GPIO_WritePin(pSTM32I2C->IICGPIO,pSTM32I2C->SCL_PIN,GPIO_PIN_RESET);
     
185. }
     
186. unsigned char read_SDAPIN(void)
     
187. {
     
188.   return HAL_GPIO_ReadPin(pSTM32I2C->IICGPIO,pSTM32I2C->SDA_PIN);
     
189. }
     4 D  H' a+ D; {% J1 ]
190. ///////////////////设备驱动//////////////////////
     - I6 a' `! P' d. D- ^. V- z: _
191. 
     , Q7 H9 L% _. N  s) Y
192. void STM32IICInit(void)
     
193. {
     6 [+ t* j  E; [4 _/ U! W; J" j
194.         _STM32I2CHandleType temIIC=
     
195.         {
     
196.         .IICGPIO=GPIOB,
     
197.         .SCL_PIN=GPIO_PIN_6,
     
198.         .SDA_PIN=GPIO_PIN_7,
     
199.         .I2C_Init=I2C_init,
     * S* m- M/ V7 {4 Z5 {0 Z5 f
200.         .Set_SDA=set_SDA,
     1 D* V( N7 Z1 Y
201.         .Set_SCL=set_SCL,
     
202.         .Reset_SDA=reset_SDA,
     3 v  }, o, G0 \/ L+ P' V5 _
203.         .Reset_SCL=reset_SCL,
     , C3 _) E6 N, J3 I- t* u+ U5 }; z
204.         .Get_SDA=read_SDAPIN,
     
205.         .Delayus=TIM3_Delay,
     9 _) X. g0 j9 ~
206.         .Set_SDA_Input_Mode=I2C_SDA_IN,
     * x" E& l( e! V
207.         .Set_SDA_Output_Mode=I2C_SDA_OUT,
     2 N  e, M+ n$ r4 f% l' Q; U+ p& ]
208.         .I2C_start=I2C_Start,
     
209.         .I2C_stop=I2C_Stop,
     5 y& a8 t0 t- j; f, W" P
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;/*做了一个临时变量 然后用=号做了赋值*/
     * y4 K6 E# E7 g1 c
217. pSTM32I2C->I2C_Init();
     
218. }
     
219. +++++++++++++++++++噢这不好 可以直接赋值的int a=9这样直接全局变量赋值+++++++++++++
     ) |  `# l: r. Y2 B2 l
220. 
       _  a7 N' ]% f/ w/ a% F0 ]
221. char __HTK_I2C_Read_optimal_touch_keyval(unsigned char  *pKeyVal)
     
222. {
     
223. /*第一次发送器件物理地址+写命令*/
     + A# v5 o8 P; u8 f. n
224.         pSTM32I2C->I2C_start();
     
225.         pSTM32I2C->Delayus(5);
     - J5 q" |( H8 ^* v2 X5 R$ p0 |  P* {) [
226.         pSTM32I2C->I2C_send_byte((0X24<<1)|0) ;
     
227.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识
     , A6 _1 Z2 S0 }$ G2 r0 F$ Q
228. 
     
229.         
     , g& Q. R; w/ @2 j- U+ j( z
230. /*第二次发送器件内部地址*/        
     . v' B% z$ y2 V' S( o& H
231.         pSTM32I2C->Delayus(5);
     # R6 ^) T2 t* M* P
232.         pSTM32I2C->I2C_send_byte(0X80);
     
233.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     9 v* T# o% w+ u) N! d" B& [% Q* Q
234. 
     
235.         
     " t/ ]# ]4 Y+ v# M8 h4 J3 R& b
236.   pSTM32I2C->Delayus(5);
     
237. 
     
238. /*第三次发送器件物理地址+读命令*/               
     
239.         pSTM32I2C->I2C_start();
     
240.         pSTM32I2C->Delayus(5);
     : E, K# b& G. q8 v! W
241.         pSTM32I2C->I2C_send_byte((0X24<<1)|1) ;               
     0 A3 D! W2 ^! [  Z4 L" A
242.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     
243. 
     
244. 
     
245.         pSTM32I2C->Delayus(100);
     # c$ l; H2 U" D" F5 |4 H/ K8 s
246. /*读取反馈数据 因为只读一个字节 所以不需要ack反馈信号*/        
     $ \+ J) @% f8 w5 Z6 L6 q* [
247.         *pKeyVal = pSTM32I2C->I2C_read_byte(0);
     
248.         
     , V. R  U! X$ ]" {6 C0 c
249.         pSTM32I2C->Delayus(5);
     
250.         pSTM32I2C->I2C_stop();        
     - F5 R* _( O1 U" X* X
251.         return 1;
     7 w& y& t* D) F* p9 \& U
252. }
     
253. 
     4 A% g; U0 l) b" T6 o
254. 
     9 V# l# Z5 f- L+ m
255. 
     / D( h' @! ]6 d* ~
256. char __HTK_I2C_Read_keystatus(unsigned char  *pKeyVal)
     
257. {
     
258.         char i=0;
     
259. /*第一次发送器件物理地址+写命令*/
     
260.         pSTM32I2C->I2C_start();
     
261.         pSTM32I2C->Delayus(5);
     : B$ a" ?$ K9 S5 }+ R% G" }% c, J3 z
262.         pSTM32I2C->I2C_send_byte((0X24<<1)|0) ;
     
263.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识
     
264. 
     ) _  y6 T7 o3 h, U7 p
265.         
     
266. /*第二次发送器件内部地址*/        
     
267.         pSTM32I2C->Delayus(5);
     / |! @% o& W" h  a! v# m
268.         pSTM32I2C->I2C_send_byte(0X81);
     5 L; h4 ^' v$ ^0 q; T8 Q3 e
269.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     4 r* O! p# d* F9 T
270. 
     ) Z5 ?1 O8 V) }7 \
271.         
     3 C! l' H/ a; H2 z5 g8 r
272.   pSTM32I2C->Delayus(5);
     
273. 
     
274. /*第三次发送器件物理地址+读命令*/               
     # G! ?! k, Z1 n3 A
275.         pSTM32I2C->I2C_start();
     
276.         pSTM32I2C->Delayus(5);
       w  f' u" o$ B! W1 ?
277.         pSTM32I2C->I2C_send_byte((0X24<<1)|1) ;               
     
278.   pSTM32I2C->I2C_Wait_Ack_Check();//等待从机收到消息，电平拉低标识        
     - S8 v5 ~, [- z! P7 ]: S5 S
279. 
     
280. 
     8 l: x' E  {* V' f9 v9 h) @. ]2 y
281.         pSTM32I2C->Delayus(100);
     
282. /*前面的代码和前面是一样的。*/        
     $ x  c. C* P5 K
283. /*前面0X80是读一个字节一个U8当前按下的值是多少*/        
     
284. /*现在我们是读0x81，后面4个字节4个U8*/        
     
285.         for(i=0;i<3;i++)
     : e* k! m/ E  r4 E! ^8 l( q4 E
286.                 pKeyVal[i] = pSTM32I2C->I2C_read_byte(1);
     
287.         /*前面3个字节需要ack反馈，最后一个字节就跟前面一样不用反馈*/
     * W' N) q0 o. L) D! B/ k0 p
288.         pKeyVal[3]=pSTM32I2C->I2C_read_byte(0);
     6 t. a0 X- E; \/ N
289.         
     
290.         pSTM32I2C->Delayus(5);
     
291.         pSTM32I2C->I2C_stop();        
     5 e; ]1 m  F0 k. J; C: f# b
292.         return 1;
     
293. }
     4 Z) M8 l0 f8 O

复制代码

1. #ifndef _HALI2C_H
   1 x4 c  W. _' _+ {4 f  q  f. ]
2. #define _HALI2C_H
   
3. #include "stm32f1xx_hal.h"
   / w. |* A+ M0 d
4. #include "tim.h"
   4 a+ P  [2 U  x$ L, z
5. 
   0 K! b4 ]+ t8 Y0 x/ ^3 i4 p0 K
6. ////如果移植程序时只要改一下三个地方就行了
   
7. //#define I2C_SCL  GPIO_PIN_6
   
8. //#define I2C_SDA  GPIO_PIN_7
   6 `; A) C* ]+ |
9. //#define GPIO_I2C GPIOB
   
10. //#define delay_us TIM3_Delay  
    % x$ r  [- h" H" d( A: p
11. 
    0 }+ o' {% j0 I( j$ P' U. x
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);
    
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)
    9 \  S6 S% ?5 r4 j. G
17. 
    . Z. J* q9 |; @6 I
18. //void I2C_Init(void);
    
19. //void I2C_SDA_OUT(void);
    6 A0 C3 R  ?: I
20. //void I2C_SDA_IN(void);
    6 J! ~+ |0 c9 h, p5 V& n' h
21. //void I2C_Start(void);
    
22. //void I2C_Stop(void);
    8 g) ]3 x+ W' ~0 c" g
23. //void I2C_Ack(void);
    - a+ ?# a2 R5 J. p/ o: U+ K
24. //void I2C_NAck(void);
    
25. //unsigned char I2C_Wait_Ack(void);
    
26. //void I2C_Send_Byte(unsigned char txd);
    6 e0 p4 P" S2 d1 B' i
27. //unsigned char I2C_Read_Byte(unsigned char ack);
    
28. 
    
29. 
    
30. typedef struct
    
31. {
    
32.         GPIO_TypeDef *        IICGPIO;
    , G* h. t9 ^/ U/ W) H2 J. R
33.         uint16_t        SCL_PIN;
    ! s0 @3 i. P# w4 _: e) ^
34.         uint16_t        SDA_PIN;
    6 o  P3 D0 n9 a& x, X
35.         void                                           (*I2C_Init)(void);
    * E, O: p1 s: f  W4 ~
36.         void                                           (*Set_SDA)(void);
    ; d' [! B! b4 V' A0 j0 q& o; ]
37.         void                                           (*Set_SCL)(void);
    
38.         void                                           (*Reset_SDA)(void);
    ! B# o5 E% W6 L6 D
39.         void                                           (*Reset_SCL)(void);
    
40.         unsigned char   (*Get_SDA)(void);
    
41.         void                                           (*Delayus)(int Time);
    ' ?' f! N, E( w8 I
42.         void            (*Set_SDA_Input_Mode)(void);
    " }1 I# w9 C: g
43.         void            (*Set_SDA_Output_Mode)(void);
    
44.         void                               (*I2C_start)(void);
    6 h( p) \5 K* x
45.         void            (*I2C_stop)(void);
    9 ~( D: [- h' V9 Y. _, T) l
46.         void            (*I2C_withAck)(void);
    
47.         void            (*I2C_withnoAck)(void);
    * ~$ C6 s1 O7 l6 `) P) Q
48.         unsigned char   (*I2C_Wait_Ack_Check)(void);
    1 t' _# _9 d0 Y
49.         unsigned char   (*I2C_read_byte)(unsigned char ack);
    
50.         void            (*I2C_send_byte)(unsigned char Byte);
    * `% x; P- C& i; M2 Z7 g
51. }_STM32I2CHandleType,*STM32I2CHandleType;
    
52. 
    ' h0 k6 B! a/ s- b
53. void STM32IICInit(void);
    
54. char __HTK_I2C_Read_keystatus(unsigned char  *pKeystatus);
    
55. char __HTK_I2C_Read_optimal_touch_keyval(unsigned char  *pdwStatus);
      Q4 m0 k: c' A' P6 `2 \
56. #endif
    5 X# F- e1 L1 q

复制代码

和传统的代码是有差别的。
传统的是用宏定义修改(头文件能看到刘洋老师的影子)，现在全是函数。
全局变量
_STM32I2CHandleType TemIIC;
* a1 p8 I1 p: o' B- ]4 u" e* iSTM32I2CHandleType pSTM32I2C=&TemIIC;
- e  c8 @5 K6 ?一个句柄，一个句柄指针，囊括了IIC所有的 属性。

+++++++++++++++20180611补充+++++++++++今天打开论坛看了一个帖子，发现一个不错的资源：就是自己做按键板。
现在的按键盘是买的嘛，自己做怎么搞呢？
按键的扫描和设计。
) H. h. o1 J4 U( S: M9 l0 T9 t  K9 p 矩阵按键扫描资料.rar (3.83 MB, 下载次数: 0)

2018-6-11 09:16 上传

点击文件名下载附件
学有余力再来自己设计吧
8 T1 i2 {. P( W0 n- l/ U! f5 y# L* b; j

自己又研究了个把小时，脑壳疼。硬件IIC问题先放着真的搞不明白。
现在的问题是：IIC的寄存器的值DR  是正确的它是U32
& Y0 f# y7 n$ i: f1 s库函数过去的是U8的数组，挨个赋值。U8=U32这样(应该也是没事的 自动把高位放弃掉吧)
现象确是U8的数组第一个总是0后面的总是一样。
埃
先用模拟的吧

楼主 厉害 学习了

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