当设计中使用I2C的数量多于1个时，其底层I2C的代码逻辑都是一样的，只有IO口变了，为此还要复制粘贴、修改IO，不仅费时，而且还浪费片内资源，因此可以使用指针来重复执行IIC底层代码，实现一个代码，多个IO使用。
* y# V- y1 f$ Z! w8 c注意：使用什么IO口，一定要打开其IO时钟，同时配置为输出开漏模式！！！
" M9 A7 k. T9 l" i, Q+ X. |使用例程在最下面
; d( ^9 w3 i1 \* z2 u
Stm32f30x_SMLT_I2C.h

1. 
   ! \1 t# x) N9 s4 a. ~7 M
2. 
   
3. #ifndef __Stm32f30x_SMLT_I2C_H
   2 |! c2 n3 l* y* T  ~
4. #define __Stm32f30x_SMLT_I2C_H
   ' r+ q8 M& M8 Y5 w5 U
5. 
   
6. //========================= Include ===============================================================
   $ b/ l" K  w' J5 k2 ~1 F! d
7. 
   / P- N6 `$ Y# y8 x/ j! i
8. #include "stm32f30x.h"
     n* l: W# k; \: {
9. 
   
10. //========================= Variable ==============================================================
    
11. 
    , [& ^/ E; B9 z" M( I
12. typedef struct
    - @) r6 }. U4 q' s9 h, d
13. {
    
14.         GPIO_TypeDef* SDA_GPIO;        //SDA的GPIO组地址
    
15.         GPIO_TypeDef* SCL_GPIO;        //SCL的GPIO组地址
    , s0 }# `6 j& {/ W) b
16.         uint32_t SDA_SBIT;                //SDA 在 BSRR寄存器 中的置位
    4 x$ @9 M$ e( X
17.         uint32_t SDA_RBIT;                //SDA 在 BSRR寄存器 中的复位
    5 w4 F2 O3 t! e7 ]2 ~8 g1 D
18.         uint32_t SCL_SBIT;                //SCL 在 BSRR寄存器 中的置位
    6 d% z: a8 e: T, _- b
19.         uint32_t SCL_RBIT;                //SCL 在 BSRR寄存器 中的复位
    
20.         uint32_t SDA_MODER;                //SDA 在 MODER寄存器 中的配置位
    ' e3 W; _( p" @% g2 G6 l/ b
21.         uint32_t SDA_MODER_0;        //SDA 在 MODER寄存器 中的配置位低位
    
22.         uint32_t SDA_MODER_1;        //SDA 在 MODER寄存器 中的配置位高位
    8 a4 ?& E+ d* I  g& s
23.         uint8_t SCL_Delay;                //SCL的延时参数 调整波特率 越大波特率越大
    
24. }I2C_Struct;
    
25. 
    
26. extern I2C_Struct S_I2C_IO[2];//------------------------------------- 修改处
    " p' U$ x0 L# n9 [
27. //（想要3个的话，数组添加，下面的define也要添加，初始化函数S_I2C_Init中也要添加）
    
28. 
    
29. //========================= I2C1_Define ================================================================
    ( r' u5 `6 n$ o0 |5 ^; p. u4 g1 Y
30. //--------------------------SDA-------------------------------------- 修改处
    
31. #define S_I2C1_SDA_GPIO                GPIOE
    
32. #define S_I2C1_SDA_BIT                0
    
33. //--------------------------SCL-------------------------------------- 修改处
    0 ~% Q3 m1 `$ Y7 Y
34. #define S_I2C1_SCL_GPIO                GPIOE
    
35. #define S_I2C1_SCL_BIT                1
    
36. #define S_I2C1_SCL_DELAY        0x80
    
37. //还需配置结构体初始化函数 S_I2C_Init 别忘了打开时钟及开漏配置
    
38. 
    
39. //========================= I2C2_Define ================================================================
    
40. //--------------------------SDA-------------------------------------- 修改处
    
41. #define S_I2C2_SDA_GPIO                GPIOE
    # I% e4 ^7 j; Z* U
42. #define S_I2C2_SDA_BIT                11
      ~  j1 B, X  l( v% }8 B1 Q
43. //--------------------------SCL-------------------------------------- 修改处
    
44. #define S_I2C2_SCL_GPIO                GPIOB
    
45. #define S_I2C2_SCL_BIT                13
    
46. #define S_I2C2_SCL_DELAY        0x10
    ! U  _4 |8 a  j: u; }) ~
47. //还需配置结构体初始化函数 S_I2C_Init 别忘了打开时钟及开漏配置
    
48. 
    
49. // //========================= I2Cx_Define ================================================================
    % D2 P3 u1 o/ p% y6 c
50. // //--------------------------SDA-------------------------------------- 修改处
    
51. // #define S_I2Cx_SDA_GPIO                GPIOx
    8 @2 |1 [* N$ y  ?" t) |5 b8 }7 \8 K
52. // #define S_I2Cx_SDA_BIT                x
    
53. // //--------------------------SCL-------------------------------------- 修改处
    3 I9 f5 n; R0 o/ S1 Z- c
54. // #define S_I2Cx_SCL_GPIO                GPIOx
    
55. // #define S_I2Cx_SCL_BIT                x
    / }& u  Z% F" C% N
56. // #define S_I2Cx_SCL_DELAY                x
    
57. // //添加在此添加
    ) {7 t, m) B# j7 i; \7 C
58. 
    2 J! L% }: r$ l" H; Q0 b5 S, z
59. 
    $ z& W* o3 N! e7 U- b
60. //========================= Function ==============================================================
    ; g0 S- a" T4 f6 d) |! e" V  V; O
61. 
    
62. void S_I2C_Init(void);//--------------------------------------------- 修改处
    
63. 
    - i# d* V$ D4 G, N: B( s
64. void S_I2C_Start(I2C_Struct I2C_temp);
    : D' ^! W4 F( n2 x$ y  U, i1 Q" J
65. void S_I2C_Stop(I2C_Struct I2C_temp);
    * B; T" v; i& g. {
66. uint8_t S_I2C_SendByte(I2C_Struct I2C_temp, uint8_t byte);
      B1 `/ f8 j0 f) l7 M
67. uint8_t S_I2C_ReceiveByte(I2C_Struct I2C_temp, uint8_t nack);
    
68. uint8_t S_I2C_WriteRegister(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t data);
    ' o2 Q; P$ G/ y! }# C
69. uint8_t S_I2C_ReadRegister(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t amount, uint8_t* data, uint8_t typ);
    0 d1 ~  i3 A1 U. v
70. uint8_t S_I2C_PointerRead(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t amount, uint8_t* data, uint8_t typ);
    ' g( y& G0 x# A2 |
71. 
    
72. //========================= Define ================================================================
    
73. //通过宏定义将IO结构体直接放入基础函数中
    2 Q  ]' z% Z3 Z& ?! `; _+ F) G
74. //-------------------------- I2C1 -----------------------------------
    & O; g$ E) J4 I5 i
75. #define S_I2C1_Start()                                                                                        S_I2C_Start(S_I2C_IO[0])
    
76. #define S_I2C1_Stop()                                                                                        S_I2C_Stop(S_I2C_IO[0])
    / o) m/ N6 u4 Q5 A  v
77. #define S_I2C1_SendByte(byte)                                                                        S_I2C_SendByte(S_I2C_IO[0], byte)
    ; b7 D4 f, n+ m) q5 [( f5 c
78. #define S_I2C1_ReceiveByte(nack)                                                                S_I2C_ReceiveByte(S_I2C_IO[0], nack)
    , K# l% P0 H, @4 e8 Y. B8 k, e; I
79. #define S_I2C1_WriteRegister(addr, regAddr, data)                                S_I2C_WriteRegister(S_I2C_IO[0], addr, regAddr, data)
    3 ~. S" y; \- f- Q$ j
80. #define S_I2C1_ReadRegister(addr, regAddr, amount, data, typ)        S_I2C_ReadRegister(S_I2C_IO[0], addr, regAddr, amount, data, typ)
    3 ?; n6 M2 n; O$ `& M0 c
81. #define S_I2C1_PointerRead(addr, regAddr, amount, data, typ)        S_I2C_PointerRead(S_I2C_IO[0], addr, regAddr, amount, data, typ)
    
82. 
    
83. //-------------------------- I2C2 -----------------------------------
    7 g& y( O7 u1 E* G1 c7 L3 K5 w* t
84. #define S_I2C2_Start()                                                                                        S_I2C_Start(S_I2C_IO[1])
    % M( B6 j# C/ \+ c, m. ]" X
85. #define S_I2C2_Stop()                                                                                        S_I2C_Stop(S_I2C_IO[1])
    ! X$ T4 Y" M/ ?" z  L3 A' o
86. #define S_I2C2_SendByte(byte)                                                                        S_I2C_SendByte(S_I2C_IO[1], byte)
    
87. #define S_I2C2_ReceiveByte(nack)                                                                S_I2C_ReceiveByte(S_I2C_IO[1], nack)
    
88. #define S_I2C2_WriteRegister(addr, regAddr, data)                                S_I2C_WriteRegister(S_I2C_IO[1], addr, regAddr, data)
    
89. #define S_I2C2_ReadRegister(addr, regAddr, amount, data, typ)        S_I2C_ReadRegister(S_I2C_IO[1], addr, regAddr, amount, data, typ)
    3 e; G& e8 W& U$ s, B6 r
90. #define S_I2C2_PointerRead(addr, regAddr, amount, data, typ)        S_I2C_PointerRead(S_I2C_IO[1], addr, regAddr, amount, data, typ)
    
91. 
    
92. //-------------------------- Another --------------------------------
    3 S' c) n5 A0 e& j8 c( R
93. #define ACK                0
    & G! P; \) Q0 R) w- m! ^% l
94. #define NACK        1
    
95. 
    . r0 ]# [& [8 N; b# y
96. #define FAILED        0
    " G6 ^, P) [: Z+ s- r+ D7 g
97. #define SUCCEED        1
    * ]; m# a! a8 \6 a# g% X
98. 
    
99. #define ARRAY        0
    
100. #define STRUCT        1
     # n$ P4 v# |) p' }+ I
101. //=================================================================================================
     
102. 
     
103. #endif

复制代码

Stm32f30x_SMLT_I2C.c

9 N5 B3 a; O! F( l, R

1. #include "Stm32f30x_SMLT_I2C.h"
   
2. 
   8 w1 b1 y7 g: k4 P
3. I2C_Struct S_I2C_IO[2];//IO口结构体，通过.h文件定义使用的引脚
   ; _. n9 o' N; c6 R5 {
4. 
   % U. e0 i0 k4 h$ C) J2 Q: f9 `
5. /**
   
6. * @description: I2C结构体IO初始化
   % {: t$ X+ i7 Z2 o) d( E' u
7. * @param {I2C_Struct*} I2C_temp        I2C的IO结构体
   
8. * @param {GPIO_TypeDef*}        SDA_GPIO                I2C SDA GPIO（GPIOA~GPIOx)
   
9. * @param {uint8_t}                        SDA_BIT                        I2C SDA引脚号（1~16）
   
10. * @param {GPIO_TypeDef*}        SCL_GPIO                I2C SCL GPIO（GPIOA~GPIOx)
    1 a* e2 g3 X/ |5 I# K0 b3 r4 U3 Z
11. * @param {uint8_t}                        SCL_BIT                        I2C SCL引脚号（1~16）
    
12. * @param {uint8_t}                        SCL_Delay                I2C SCL时钟延时（0x00~0xff）越大波特率越低
    
13. * @return {*}
    
14. */
    
15. void S_I2C_Struct_Init(I2C_Struct* I2C_temp, GPIO_TypeDef* SDA_GPIO, uint8_t SDA_BIT, GPIO_TypeDef* SCL_GPIO, uint8_t SCL_BIT, uint8_t SCL_Delay)
    7 x" M4 e2 Z, T; ^+ }
16. {
    
17.         I2C_temp->SDA_GPIO = SDA_GPIO;
    . P% }: O/ {+ h6 v/ Q
18.         I2C_temp->SCL_GPIO = SCL_GPIO;
    
19.         I2C_temp->SDA_SBIT = (0x00000001 << SDA_BIT);
    7 s6 F; @8 i" W4 d& p8 h5 [" j
20.         I2C_temp->SDA_RBIT = (0x00010000 << SDA_BIT);
    
21.         I2C_temp->SCL_SBIT = (0x00000001 << SCL_BIT);
    
22.         I2C_temp->SCL_RBIT = (0x00010000 << SCL_BIT);
    
23.         I2C_temp->SDA_MODER = 0x00000003 << (SDA_BIT << 1);
    
24.         I2C_temp->SDA_MODER_0 = 0x00000001 << (SDA_BIT << 1);
    
25.         I2C_temp->SDA_MODER_1 = 0x00000002 << (SDA_BIT << 1);
    * r  V6 G% ?- L1 M
26.         I2C_temp->SCL_Delay = SCL_Delay;
    ) H1 N  L6 ?- J/ N5 H4 D
27. }
    7 B0 O3 e: I* h: B  w
28. 
    
29. /**
    
30. * @description: I2C结构体总初始化，将计算的各个变量存入结构体中
    
31. * @param {*}
    
32. * @return {*}
    * Y! T. b0 W0 [: }0 d
33. */
    1 Z  t  }% c' K* S* T
34. void S_I2C_Init(void)
    
35. {
    # K, l! X1 g$ U" H! Z" s
36.         S_I2C_Struct_Init(&S_I2C_IO[0], S_I2C1_SDA_GPIO, S_I2C1_SDA_BIT, S_I2C1_SCL_GPIO, S_I2C1_SCL_BIT, S_I2C1_SCL_DELAY);
    
37.         S_I2C_Struct_Init(&S_I2C_IO[1], S_I2C2_SDA_GPIO, S_I2C2_SDA_BIT, S_I2C2_SCL_GPIO, S_I2C2_SCL_BIT, S_I2C2_SCL_DELAY);
    # I; s. W( Q$ c$ }
38.         // S_I2C_Struct_Init(&S_I2C_IO[x], S_I2Cx_SDA_GPIO, S_I2Cx_SDA_BIT, S_I2Cx_SCL_GPIO, S_I2Cx_SCL_BIT, S_I2Cx_SCL_DELAY);//添加在此添加
    # J5 P' y/ P. z  }# J5 T3 ]
39. }
    
40. 
    
41. /**
    
42. * @description: I2C时钟延时，调整波特率
    9 x7 @( U5 Q7 G0 t3 N# j
43. * @param {*}
    
44. * @return {*}
    7 X5 L  g+ e* a3 V6 {
45. */
    
46. void S_I2C_Delay(uint8_t temp)
    7 k+ E0 p6 [6 K) @9 E" r8 w
47. {
    
48.     for ( ; temp; temp--)
    , w; Y4 r& M+ W; ~0 P
49.         {
    
50.                 /* code */
    
51.         }
    
52. }
    
53. 
    " S' A% Q/ S- c) k. X! h' Y
54. /**
    : h$ M8 [6 s1 Q% X5 [2 Q$ \/ u  r
55. * @description: 产生起始信号
    
56. * @param {I2C_Struct} I2C_temp I2C_IO结构体
    
57. * @return {*}
    5 v2 G1 K7 w3 K" Z
58. */
    # j! n8 d+ i# o0 W5 H( c0 D
59. void S_I2C_Start(I2C_Struct I2C_temp)
    ; D" `5 \2 Q! ?- n5 A% b$ y; n; M
60. {
    
61.         I2C_temp.SDA_GPIO->MODER |= I2C_temp.SDA_MODER_0;
    
62.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_SBIT;
    # M* Z! f6 P2 p  o
63.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
    
64.     S_I2C_Delay(I2C_temp.SCL_Delay);
    
65.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
    1 W+ A7 N/ S* h: E
66.     S_I2C_Delay(I2C_temp.SCL_Delay);
    ( z" Q) [( O& ~+ A9 r5 J; q
67.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
    
68.     S_I2C_Delay(I2C_temp.SCL_Delay);
    8 ~* `4 d+ I7 l: |
69. }
    
70. 
    " Q4 |8 C( {! [- W' J; y
71. /**
    . r' C$ G, ]! r  K: X+ ]- {
72. * @description: 产生停止信号
    
73. * @param {I2C_Struct} I2C_temp
    + `! `2 J/ S4 Z
74. * @return {*}
    
75. */
    6 e! [4 o5 c( ~; s# p
76. void S_I2C_Stop(I2C_Struct I2C_temp)
    
77. {
    9 c9 v" w7 T  Q7 b1 ?( R5 ]+ ~
78.         I2C_temp.SDA_GPIO->MODER |= I2C_temp.SDA_MODER_0;
    $ t, a0 I! [5 J" _
79.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
    ) F6 `3 Z, z( E( f' h1 k/ i
80.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
    
81.     S_I2C_Delay(I2C_temp.SCL_Delay);
    
82.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
    
83.     S_I2C_Delay(I2C_temp.SCL_Delay);
    
84.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_SBIT;
    , H$ F: w  G& C
85.     S_I2C_Delay(I2C_temp.SCL_Delay);
    6 ?/ O+ u* `9 Z& t
86. }
    
87. 
    
88. /**
    . O/ U) f; u' N% O( F( o
89. * @description: 发送一个字节数据
    & e! c: b4 t. ?2 t. u
90. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
    4 q8 b0 _+ E. b
91. * @param {uint8_t} byte        数据
    0 X6 J. Y' N( H
92. * @return {uint8_t}                NACK
    
93. *                                                         ACK
    
94. */
    
95. uint8_t S_I2C_SendByte(I2C_Struct I2C_temp, uint8_t byte)
    ! C+ i# E+ v# [! h! l' i6 v
96. {
    
97.         uint8_t temp = 0x00;
    , k2 J0 x* E8 z2 ^; R$ }% e
98.         for(uint8_t i = 0x80; i; i >>= 1)
    5 X1 u. A& Y5 |+ I. g
99.         {
    3 u; \/ i9 Q  k0 o
100.                 I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     : o, B5 Q2 ?8 a+ z! G
101.                 if(byte & i)
     , x( Q% u! U0 F4 L
102.                 {
     . Y8 j" Y& E3 O
103.                         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_SBIT;
     
104.                 }
     7 l9 x; t. X/ S. N( K1 A  W- U
105.                 else
     # O0 r. g/ {: X5 e% x4 \. Z) t
106.                 {
     
107.                         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
     
108.                 }
     + b1 B7 P3 f) j2 p5 K. m2 s
109.         S_I2C_Delay(I2C_temp.SCL_Delay);
     ' \: K6 B+ b7 f/ v7 ?7 A1 ^
110.                 I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
     
111.         S_I2C_Delay(I2C_temp.SCL_Delay);
     , d$ W# `$ {  u
112.         }
     4 v- e) M  ?3 h# s; y
113.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     0 W* U) S4 G' W$ f* a
114.         I2C_temp.SDA_GPIO->MODER &= ~I2C_temp.SDA_MODER;
     
115.         S_I2C_Delay(I2C_temp.SCL_Delay);
     
116.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
     
117.         if(I2C_temp.SDA_GPIO -> IDR & I2C_temp.SDA_SBIT)
     1 N) Y: {* Y2 Z+ o' c; H
118.         {
     
119.                 temp = NACK;
     
120.         }
     6 L$ |. _" ^* Q5 `9 B+ ?7 B2 \! X
121.         else
     : f2 j5 y- a0 t, S
122.         {
     
123.                 temp = ACK;
     
124.         }
     7 Z6 T" U+ Q  A9 a3 L7 M
125.     S_I2C_Delay(I2C_temp.SCL_Delay);
     5 m% R& ^: g( g; e7 E' ^5 F
126.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
     ' Y1 u6 U) C" P( @1 ?
127.         I2C_temp.SDA_GPIO->MODER |= I2C_temp.SDA_MODER_0;
     
128.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     
129.     S_I2C_Delay(I2C_temp.SCL_Delay);
     . E- R1 a" ]1 ?& M" {+ U+ v
130.         return temp;
     
131. }
     % D& M5 B* F2 N/ Z+ A* e
132. 
     & C1 ?( ^; q, @' E8 U8 F
133. /**
     6 N0 L6 Q( i: I* `9 F6 u0 I
134. * @description: 接收一个字节数据
     4 l+ \5 }* [: f* C0 y& y, Q
135. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
     ' w/ j% W: X) f) y0 m% h! D
136. * @param {uint8_t} nack        接收后结束要发送的应答信号
     
137. *                                                         NACK
     
138. *                                                         ACK
     # H# ^+ L8 l/ Q4 S3 t
139. * @return {uint8_t}        接收到的字节
     7 r- A2 q0 c2 R! p, C$ F
140. */
     
141. uint8_t S_I2C_ReceiveByte(I2C_Struct I2C_temp, uint8_t nack)
     
142. {
     ) O$ B9 B) ^2 X, R
143.         uint8_t byte = 0x00;
     
144.         I2C_temp.SDA_GPIO->MODER &= ~I2C_temp.SDA_MODER;
       Q) `$ N' g0 X4 R4 b/ K6 b
145.         for (uint8_t i = 8; i; i--)
     
146.         {
     
147.                 I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     
148.         S_I2C_Delay(I2C_temp.SCL_Delay);
     
149.                 byte <<= 1;
     
150.                 I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
     2 S) M& K0 E- S& F# @
151.                 if(I2C_temp.SDA_GPIO -> IDR & I2C_temp.SDA_SBIT)
     
152.                 {
     5 d$ |: u7 w8 T/ L# `, z" @
153.                         byte |= 0x01;
     ) _4 k. f) x9 I( }1 N/ A
154.                 }
     
155.         S_I2C_Delay(I2C_temp.SCL_Delay);
     
156.         }
     
157.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     1 f5 ~: A2 x) \# d" Z- k& ~3 v0 z0 k
158.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
     & Q, o8 r6 |# |5 x
159.         I2C_temp.SDA_GPIO->MODER |= I2C_temp.SDA_MODER_0;
     ' j# o4 R, g0 _( f
160.         if(nack)
     4 c8 J9 y9 n9 p" B; k% Q! U$ T
161.                 I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_SBIT;
     
162.         else
     
163.                 I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
     ' ~& U( D* E6 H. D
164.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     - m2 }) \! Y2 |  J* D! e3 U: P9 J
165.     S_I2C_Delay(I2C_temp.SCL_Delay);
     6 p3 Z0 A+ j+ y" A9 _6 f
166.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
     
167.     S_I2C_Delay(I2C_temp.SCL_Delay);
     8 ~  ?, Z" a6 f" V# x/ C+ s
168.         return byte;
     
169. }
     
170. 
     
171. 
     
172. /**
     
173. * @description: 写一个字节的寄存器
     
174. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
     6 Y2 }5 [& P' e  {2 l
175. * @param {uint8_t} addr        器件地址(0x00~0x7f)
     
176. * @param {uint8_t} regAddr        寄存器地址(0x00~0xff)
     9 ~, |; i# d7 w) p
177. * @param {uint8_t} data        数据
     
178. * @return {uint8_t}        FAILED        失败
     ; z! W$ p4 _! ?2 O
179. *                                                 SUCCEED        成功
     
180. */
     
181. uint8_t S_I2C_WriteRegister(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t data)
     0 q" K* c5 L0 ~- ?( F
182. {
     
183.         addr <<= 1;
     1 Y! A' r" ], v$ }" ]: L
184.         S_I2C_Start(I2C_temp);
     , ?' H. c3 }; U7 L/ S" j" ~
185.         if(S_I2C_SendByte(I2C_temp, addr) == NACK)
     4 Y. ^; Y5 q. z. |; U9 P. O& w: N8 F
186.         {
     1 v: ?( b  ]2 j2 ]& L0 [
187.                 S_I2C_Stop(I2C_temp);
     9 c2 y- v+ c% J  _
188.                 return FAILED;
     - B7 q0 D  O3 S9 f9 j/ R
189.         }
     
190.         if(S_I2C_SendByte(I2C_temp, regAddr) == NACK)
     
191.         {
     # f7 y6 e0 D# E2 l
192.                 S_I2C_Stop(I2C_temp);
     
193.                 return FAILED;
     
194.         }
     
195.         if(S_I2C_SendByte(I2C_temp, data) == NACK)
     0 k6 i5 J3 k' P& l* X, ~
196.         {
     & c# Z9 X9 w( H5 S! j* Q0 b
197.                 S_I2C_Stop(I2C_temp);
     ( h9 J4 d. z+ w: }8 E, E8 m/ a
198.                 return FAILED;
     ; [9 c/ U" r  v! o# M6 y
199.         }
     
200.         S_I2C_Stop(I2C_temp);
     
201.         return SUCCEED;
     7 h. ?4 l/ w# a* W6 o
202. }
     : G- G9 v5 d4 ^- Q( d, Z/ Q9 w: x
203. 
     
204. 
     # V1 Y5 e8 _  C: {- Q
205. /**
     . Q; d" c: H  K; ~
206. * @description:                 读取器件，读取格式：器件读-寄存器地址-读取数据
     ; k7 Q) f3 a6 P
207. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
     
208. * @param {uint8_t} addr        器件地址(0x00~0x7f)
     
209. * @param {uint8_t} regAddr        寄存器地址(0x00~0xff)
     8 Z9 X! ?  h; }" w% A
210. * @param {uint8_t} amount        读取数据数量(0x00~0xff)
     
211. * @param {uint8_t*} data        返回数据指针
     ' v9 T8 [+ B3 m: R
212. * @param {uint8_t} typ                数据指针类型（由于结构体和数组存储方式不一样，因此需要区分）
     
213. *                                                 ARRAY        数组
     
214. *                                                 STRUCT        结构体
     
215. * @return {*}                        FAILD   读取失败 数据无效
     
216. *                                                 SUCCEED 读取成功 数据有效
     , o& i7 k, n0 d  A! K# k
217. */
     # W' w2 U& N4 {5 f( D! H
218. uint8_t S_I2C_ReadRegister(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t amount, uint8_t* data, uint8_t typ)
     
219. {
     ' c9 X/ l# f+ p# P5 d
220.         S_I2C_Start(I2C_temp);
     * `( K0 ^" u2 e* L" V
221.         addr = (addr << 1) | 0x01;
     
222.         if(S_I2C_SendByte(I2C_temp, addr) == NACK)
     
223.         {
     3 F$ W* K1 O; G7 O. c- V( F
224.                 S_I2C_Stop(I2C_temp);
     : ^* U' v6 A, M- P- A
225.                 return FAILED;
     
226.         }
     6 R4 p% w( e( K3 k
227.         if(S_I2C_SendByte(I2C_temp, regAddr) == NACK)
     1 I7 F7 S. k, q: D) g6 R
228.         {
     $ c7 Y( o% e) v( E6 [
229.                 S_I2C_Stop(I2C_temp);
     
230.                 return FAILED;
     . ^3 i8 d8 a. w2 E6 F
231.         }
     
232.         for(amount -= 1;amount;amount --)
     ! ~& [8 |7 ]0 J" C  j! w+ ?
233.         {
     & F$ o% d3 N( P0 N
234.                 *data = S_I2C_ReceiveByte(I2C_temp, ACK);
     & x3 p; c4 [0 _+ J: q2 e6 s' N
235.                 if(typ == ARRAY)
     
236.                         data ++;
     # _- P# H* R" |: Y6 u6 u
237.                 else
     ' M) o& k' h9 {8 g. {
238.                         data --;
     3 t- i" a- F0 S# l$ g. p
239.         }
     
240.         *data = S_I2C_ReceiveByte(I2C_temp, NACK);
     
241.         S_I2C_Stop(I2C_temp);
     ) Q# W; I. s  z6 g$ `+ u  v
242.         return SUCCEED;
     
243. }
     4 O, N2 S( C+ O: G
244. 
     
245. /**
       e8 L8 {. G  R8 k7 M7 y4 J' p6 T0 m
246. * @description:                 读取器件，读取格式：器件写-寄存器地址-器件读-读取数据
     0 s& W$ v) z0 A/ i! T& }* H+ p
247. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
     2 W% P# q* C9 p. [
248. * @param {uint8_t} addr        器件地址(0x00~0x7f)
     : O( i6 A8 o1 L$ ]- Z6 ?' ?
249. * @param {uint8_t} regAddr        寄存器地址(0x00~0xff)
     / A+ O  `. J) i5 M8 y
250. * @param {uint8_t} amount        读取数据数量(0x00~0xff)
     
251. * @param {uint8_t*} data        返回数据指针
     . S9 A% Y; I  d3 _
252. * @param {uint8_t} typ                数据指针类型（由于结构体和数组存储方式不一样，因此需要区分）
     
253. *                                                 ARRAY        数组
     8 c2 G3 U! s0 l7 ~4 {; A5 a
254. *                                                 STRUCT        结构体
     % N% a* a, H) M. u
255. * @return {uint8_t}        FAILD   读取失败 数据无效
     
256. *                                                 SUCCEED 读取成功 数据有效
     : Y. b; ?5 m0 i; Y: Z( m) ~
257. */
     7 A: e, q, O; Q# c0 v2 z( W* V
258. uint8_t S_I2C_PointerRead(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t amount, uint8_t* data, uint8_t typ)
     
259. {
     
260.         addr <<= 1;
       D/ F+ ?/ |8 y1 }9 w8 z
261.         S_I2C_Start(I2C_temp);
     ! s( L( h  T% k" h
262.         if(S_I2C_SendByte(I2C_temp, addr) == NACK)
     . @) a1 Z4 G9 r2 y. P+ b% u5 H' a8 O
263.         {
     
264.                 S_I2C_Stop(I2C_temp);
     ' P& g- ~3 ^* a4 j- r
265.                 return FAILED;
     + m7 t& Z5 k  L5 e
266.         }
     / [& O) I& k9 G) O# b
267.         if(S_I2C_SendByte(I2C_temp, regAddr) == NACK)
     
268.         {
     0 e4 n' ?; [* d  R, Q1 B& M# ~
269.                 S_I2C_Stop(I2C_temp);
     
270.                 return FAILED;
     
271.         }
     
272.         S_I2C_Stop(I2C_temp);
     ( d* N+ V5 k/ n+ T9 Z; f1 Y2 ~7 F
273.         
     
274.         addr |= 0x01;
     3 o% R" u, \- j. r
275.         S_I2C_Start(I2C_temp);
     8 n) f( d/ L$ a: V. P, d
276.         if(S_I2C_SendByte(I2C_temp, addr) == NACK)        //NACK
     - M4 ]6 r: @0 ^) k0 Q  p$ H: Y$ t; ]; G, f
277.         {
     
278.                 S_I2C_Stop(I2C_temp);
     
279.                 return FAILED;
     
280.         }
     0 L2 U8 J# S$ ^
281.         for(amount -= 1;amount;amount --)
     ; `5 Z# g) T. ?! v8 n
282.         {
     ! U& C9 m; n( f; D9 [- g
283.                 *data = S_I2C_ReceiveByte(I2C_temp, ACK);
     8 |0 z$ i! {; E5 d2 q
284.                 if(typ == ARRAY)
     5 h8 `% f2 q3 e
285.                         data ++;
     
286.                 else
     
287.                         data --;
     
288.         }
     
289.         *data = S_I2C_ReceiveByte(I2C_temp, NACK);
     1 m" K  H+ f+ H
290.         S_I2C_Stop(I2C_temp);
     
291.         return SUCCEED;
     
292. }

复制代码

. _; i5 Y1 G3 E/ Y$ S7 Q使用方法
( g3 e* l' |& V1 }. q4 a: |

1. void main(void)
   
2. {
   ; V2 `9 f' \$ W2 M9 q) D- Q& M
3.         CLOCK_Init();
   
4.         GPIO_Init();
   : X. F, n. P9 R9 u2 t
5.         S_I2C_Init();//初始化结构体，在宏定义中修改引脚等定义
   5 z8 `; |& V; O9 {; b" v9 z
6.         //接下来就可以调用I2C函数了
   ( v1 s; E0 x7 G* L  F6 O  ~
7. }

复制代码

( H# E4 z$ B. o) K' V————————————————
版权声明：Vice Versa XL
( I/ F8 @* ]5 y