当设计中使用I2C的数量多于1个时，其底层I2C的代码逻辑都是一样的，只有IO口变了，为此还要复制粘贴、修改IO，不仅费时，而且还浪费片内资源，因此可以使用指针来重复执行IIC底层代码，实现一个代码，多个IO使用。
3 W$ P' |8 e. \, h0 o# x/ m注意：使用什么IO口，一定要打开其IO时钟，同时配置为输出开漏模式！！！
+ a# b6 b7 y6 T$ e$ X使用例程在最下面

Stm32f30x_SMLT_I2C.h

1. 
   
2. 
   . g9 [6 v6 l. a
3. #ifndef __Stm32f30x_SMLT_I2C_H
   
4. #define __Stm32f30x_SMLT_I2C_H
   
5. 
   % B& }( C* _8 s! D
6. //========================= Include ===============================================================
   0 Y) L1 n4 X  Z8 K+ S9 B
7. 
   
8. #include "stm32f30x.h"
   7 Y* y5 @9 ~- R) P, ^8 i
9. 
   
10. //========================= Variable ==============================================================
    
11. 
    
12. typedef struct
    
13. {
    
14.         GPIO_TypeDef* SDA_GPIO;        //SDA的GPIO组地址
    ' V$ W0 {$ M3 k
15.         GPIO_TypeDef* SCL_GPIO;        //SCL的GPIO组地址
    
16.         uint32_t SDA_SBIT;                //SDA 在 BSRR寄存器 中的置位
    0 `! @$ \  e* }, u8 _
17.         uint32_t SDA_RBIT;                //SDA 在 BSRR寄存器 中的复位
    ! b' k+ R; l! o' K2 O+ k2 Q
18.         uint32_t SCL_SBIT;                //SCL 在 BSRR寄存器 中的置位
    
19.         uint32_t SCL_RBIT;                //SCL 在 BSRR寄存器 中的复位
    3 M& h: y4 W9 Y5 g/ a' k6 p4 e
20.         uint32_t SDA_MODER;                //SDA 在 MODER寄存器 中的配置位
    
21.         uint32_t SDA_MODER_0;        //SDA 在 MODER寄存器 中的配置位低位
    
22.         uint32_t SDA_MODER_1;        //SDA 在 MODER寄存器 中的配置位高位
    
23.         uint8_t SCL_Delay;                //SCL的延时参数 调整波特率 越大波特率越大
    
24. }I2C_Struct;
    / R( L7 u: d, X1 N, d3 m
25. 
    ) g8 U5 z, m! a! y9 N/ D2 s) X/ u( U
26. extern I2C_Struct S_I2C_IO[2];//------------------------------------- 修改处
    
27. //（想要3个的话，数组添加，下面的define也要添加，初始化函数S_I2C_Init中也要添加）
    
28. 
    - Q% P6 c  F! k6 ?
29. //========================= I2C1_Define ================================================================
    
30. //--------------------------SDA-------------------------------------- 修改处
    - f- z( R6 f" v- b5 Q6 Y1 ~
31. #define S_I2C1_SDA_GPIO                GPIOE
    
32. #define S_I2C1_SDA_BIT                0
    1 M* |/ {* w' f7 V# V1 J. D
33. //--------------------------SCL-------------------------------------- 修改处
    
34. #define S_I2C1_SCL_GPIO                GPIOE
    
35. #define S_I2C1_SCL_BIT                1
    
36. #define S_I2C1_SCL_DELAY        0x80
    * V2 t& K9 n7 N. g, y: b4 u
37. //还需配置结构体初始化函数 S_I2C_Init 别忘了打开时钟及开漏配置
    
38. 
    
39. //========================= I2C2_Define ================================================================
    
40. //--------------------------SDA-------------------------------------- 修改处
    
41. #define S_I2C2_SDA_GPIO                GPIOE
    
42. #define S_I2C2_SDA_BIT                11
    , l/ Z, T8 }7 u2 _
43. //--------------------------SCL-------------------------------------- 修改处
    ! r% O) [- S, s$ }) |( Y
44. #define S_I2C2_SCL_GPIO                GPIOB
    
45. #define S_I2C2_SCL_BIT                13
    
46. #define S_I2C2_SCL_DELAY        0x10
    
47. //还需配置结构体初始化函数 S_I2C_Init 别忘了打开时钟及开漏配置
    $ J; c0 E1 p1 I2 R3 a% e
48. 
    ! M, b4 S& V* y) {- I) s8 R
49. // //========================= I2Cx_Define ================================================================
    5 l, l/ e! V/ E7 k. V( T
50. // //--------------------------SDA-------------------------------------- 修改处
    
51. // #define S_I2Cx_SDA_GPIO                GPIOx
    4 t' G, X/ S. x2 u$ t
52. // #define S_I2Cx_SDA_BIT                x
    6 F- g5 r6 e, W0 o
53. // //--------------------------SCL-------------------------------------- 修改处
    
54. // #define S_I2Cx_SCL_GPIO                GPIOx
    
55. // #define S_I2Cx_SCL_BIT                x
    
56. // #define S_I2Cx_SCL_DELAY                x
    % W. t$ A3 Y' o5 ]
57. // //添加在此添加
    & z: L. j  a! R. z; s& O' ?
58. 
    
59. 
    
60. //========================= Function ==============================================================
    % i/ T( L' m# K2 a
61. 
    
62. void S_I2C_Init(void);//--------------------------------------------- 修改处
    * I5 P7 n* B. H) q/ E8 x
63. 
    * n5 J& Q3 p% i. q
64. void S_I2C_Start(I2C_Struct I2C_temp);
    1 t* `) {: k; d7 i6 V9 V9 b
65. void S_I2C_Stop(I2C_Struct I2C_temp);
    % K% Q- B+ A5 d3 f% i: m0 E
66. uint8_t S_I2C_SendByte(I2C_Struct I2C_temp, uint8_t byte);
    
67. uint8_t S_I2C_ReceiveByte(I2C_Struct I2C_temp, uint8_t nack);
    1 c* ]. Y( i7 c. E# P* f
68. uint8_t S_I2C_WriteRegister(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t data);
    " g" v6 T/ a$ v" m- q
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);
    + \  K: f( I5 S; D! k3 m
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);
    
71. 
    
72. //========================= Define ================================================================
    
73. //通过宏定义将IO结构体直接放入基础函数中
    
74. //-------------------------- I2C1 -----------------------------------
    & p' T' s8 ?2 k& A6 ?
75. #define S_I2C1_Start()                                                                                        S_I2C_Start(S_I2C_IO[0])
    5 N: w/ I- H; R9 C
76. #define S_I2C1_Stop()                                                                                        S_I2C_Stop(S_I2C_IO[0])
    . ?$ B  _* Y# s  M: d* O3 G
77. #define S_I2C1_SendByte(byte)                                                                        S_I2C_SendByte(S_I2C_IO[0], byte)
    
78. #define S_I2C1_ReceiveByte(nack)                                                                S_I2C_ReceiveByte(S_I2C_IO[0], nack)
    
79. #define S_I2C1_WriteRegister(addr, regAddr, data)                                S_I2C_WriteRegister(S_I2C_IO[0], addr, regAddr, data)
    
80. #define S_I2C1_ReadRegister(addr, regAddr, amount, data, typ)        S_I2C_ReadRegister(S_I2C_IO[0], addr, regAddr, amount, data, typ)
    
81. #define S_I2C1_PointerRead(addr, regAddr, amount, data, typ)        S_I2C_PointerRead(S_I2C_IO[0], addr, regAddr, amount, data, typ)
    / }' y  u9 B; u7 y9 N, m* E( Q
82. 
    
83. //-------------------------- I2C2 -----------------------------------
    2 D/ }+ j; w7 ?1 Y- i
84. #define S_I2C2_Start()                                                                                        S_I2C_Start(S_I2C_IO[1])
    
85. #define S_I2C2_Stop()                                                                                        S_I2C_Stop(S_I2C_IO[1])
    9 I$ `$ }( S% h7 P, g$ P
86. #define S_I2C2_SendByte(byte)                                                                        S_I2C_SendByte(S_I2C_IO[1], byte)
    " H: R# A4 u) Z4 }8 O  n" _
87. #define S_I2C2_ReceiveByte(nack)                                                                S_I2C_ReceiveByte(S_I2C_IO[1], nack)
    2 O; x7 T, |* G2 X4 _  S
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)
    
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 --------------------------------
    
93. #define ACK                0
    
94. #define NACK        1
    9 M7 S$ b  M- B& I, Y$ @% U
95. 
    * a' ]. I- F; r4 q) g
96. #define FAILED        0
    ! O  Y( c' {2 Z; v- X, w* Y. b
97. #define SUCCEED        1
    
98. 
    
99. #define ARRAY        0
    
100. #define STRUCT        1
     % G7 i# r8 z% P& ?
101. //=================================================================================================
     
102. 
     5 G. b8 v8 Q% p7 a. W% B
103. #endif
     6 ]: c8 j! j# j# b# H, Y

复制代码

; r! @$ T7 [1 L& ?) c# sStm32f30x_SMLT_I2C.c
$ A- a, N3 D) A8 C! ?) B

1. 
   ; R! o% O1 {; ]7 W- [) }8 w
2. #include "Stm32f30x_SMLT_I2C.h"
   
3. 
   - C7 o+ E& R# k2 ]# s8 R6 K
4. I2C_Struct S_I2C_IO[2];//IO口结构体，通过.h文件定义使用的引脚
   + n+ g" S0 d) _
5. 
   0 C6 s8 H4 }" ]$ `- \
6. /**
   
7. * @description: I2C结构体IO初始化
   
8. * @param {I2C_Struct*} I2C_temp        I2C的IO结构体
   
9. * @param {GPIO_TypeDef*}        SDA_GPIO                I2C SDA GPIO（GPIOA~GPIOx)
   # j% D6 v; Y4 P$ B
10. * @param {uint8_t}                        SDA_BIT                        I2C SDA引脚号（1~16）
    
11. * @param {GPIO_TypeDef*}        SCL_GPIO                I2C SCL GPIO（GPIOA~GPIOx)
    5 R2 U8 t8 u4 l. D" y7 r9 E/ O0 ]
12. * @param {uint8_t}                        SCL_BIT                        I2C SCL引脚号（1~16）
    
13. * @param {uint8_t}                        SCL_Delay                I2C SCL时钟延时（0x00~0xff）越大波特率越低
    
14. * @return {*}
    
15. */
    ( F! \/ U) G0 t: ]  \7 T; Z5 [% q
16. 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 G" A8 a. Q2 P  x8 Y  Q( ~
17. {
    6 i! x) D% Y: Q" G
18.         I2C_temp->SDA_GPIO = SDA_GPIO;
    
19.         I2C_temp->SCL_GPIO = SCL_GPIO;
    ' ]7 T3 D) |3 t7 o# C/ Q
20.         I2C_temp->SDA_SBIT = (0x00000001 << SDA_BIT);
    8 a3 H8 l; n4 ]. L, o& B5 A0 \2 f
21.         I2C_temp->SDA_RBIT = (0x00010000 << SDA_BIT);
    
22.         I2C_temp->SCL_SBIT = (0x00000001 << SCL_BIT);
    
23.         I2C_temp->SCL_RBIT = (0x00010000 << SCL_BIT);
    % v$ {- t% Z: C. O4 K- a
24.         I2C_temp->SDA_MODER = 0x00000003 << (SDA_BIT << 1);
    & `- {  J- @; }5 a) e: I
25.         I2C_temp->SDA_MODER_0 = 0x00000001 << (SDA_BIT << 1);
    / x' K. Z8 D+ ], a3 I
26.         I2C_temp->SDA_MODER_1 = 0x00000002 << (SDA_BIT << 1);
    
27.         I2C_temp->SCL_Delay = SCL_Delay;
    
28. }
      t  V6 h+ z3 J
29. 
    3 ^# \: x6 L+ v& o
30. /**
    
31. * @description: I2C结构体总初始化，将计算的各个变量存入结构体中
    7 \1 Y( b1 S- D& x3 v4 M
32. * @param {*}
    
33. * @return {*}
    
34. */
    
35. void S_I2C_Init(void)
    ! a. H2 j. _0 [+ E' v7 _2 E8 ^
36. {
    
37.         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);
    
38.         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);
    
39.         // 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);//添加在此添加
    $ R/ c3 B- Z0 d* ~
40. }
    
41. 
    
42. /**
    
43. * @description: I2C时钟延时，调整波特率
    
44. * @param {*}
    
45. * @return {*}
    ) I1 P) ]5 o6 D+ z7 i$ {; _% p6 C
46. */
    
47. void S_I2C_Delay(uint8_t temp)
    6 g7 z, x  _/ U! e4 T6 A" f2 X2 L% ^
48. {
    
49.     for ( ; temp; temp--)
    
50.         {
    
51.                 /* code */
    6 ~7 n4 |/ B0 O* F7 ~+ C
52.         }
    
53. }
    
54. 
    
55. /**
    
56. * @description: 产生起始信号
    9 V  d+ a- q2 H( ~
57. * @param {I2C_Struct} I2C_temp I2C_IO结构体
    
58. * @return {*}
    
59. */
    
60. void S_I2C_Start(I2C_Struct I2C_temp)
    
61. {
    
62.         I2C_temp.SDA_GPIO->MODER |= I2C_temp.SDA_MODER_0;
    
63.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_SBIT;
    
64.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
    * M0 O$ @* X6 ]5 ~: q( k6 G  N
65.     S_I2C_Delay(I2C_temp.SCL_Delay);
    
66.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
    
67.     S_I2C_Delay(I2C_temp.SCL_Delay);
    
68.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
    
69.     S_I2C_Delay(I2C_temp.SCL_Delay);
    ! s$ k8 Z) i" H  v
70. }
    ; k% J+ v7 V; a% G2 ]# o: U6 J
71. 
    % v' T! \5 }4 I! H; h3 R
72. /**
    
73. * @description: 产生停止信号
    $ f8 J0 T) b! C5 M# U) a4 |4 ^
74. * @param {I2C_Struct} I2C_temp
    * u" A1 M* b% S( S! r( R5 F
75. * @return {*}
    - q  A& ?4 T! |  T( `
76. */
    
77. void S_I2C_Stop(I2C_Struct I2C_temp)
    
78. {
    
79.         I2C_temp.SDA_GPIO->MODER |= I2C_temp.SDA_MODER_0;
    
80.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
    
81.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
    " l  {1 ~0 R4 m, N4 \9 x: i7 j
82.     S_I2C_Delay(I2C_temp.SCL_Delay);
    8 s2 @7 q6 q9 B$ d1 M1 S
83.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
    
84.     S_I2C_Delay(I2C_temp.SCL_Delay);
    
85.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_SBIT;
    
86.     S_I2C_Delay(I2C_temp.SCL_Delay);
    ! x, |& s( q& k( l% |  m/ O% J
87. }
    
88. 
    
89. /**
    
90. * @description: 发送一个字节数据
    4 H( ^3 s7 x8 }; i) H6 ^
91. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
    % K7 j9 z- r! }9 h) J7 M6 j
92. * @param {uint8_t} byte        数据
    & W  g% ~: i7 E  u& s2 F$ A
93. * @return {uint8_t}                NACK
    ! o  l8 m! Z' b+ b) q; M$ D; @
94. *                                                         ACK
    
95. */
    
96. uint8_t S_I2C_SendByte(I2C_Struct I2C_temp, uint8_t byte)
    ! T' v$ d; y* T5 k& K$ F
97. {
    , F% u+ I& W5 K4 I, [, J
98.         uint8_t temp = 0x00;
    , f! J' M9 {$ T1 Z% x1 F# b* a
99.         for(uint8_t i = 0x80; i; i >>= 1)
    
100.         {
     3 _5 w8 r  i/ [4 {& S7 ~/ Y
101.                 I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     
102.                 if(byte & i)
     5 Y& B) T) k. h! M# y
103.                 {
     , H7 Z1 i1 o% G6 b6 O
104.                         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_SBIT;
     
105.                 }
       R5 P$ I* E1 w) E
106.                 else
     8 r* g+ N8 Q- E" y2 p1 ~2 l6 w
107.                 {
     
108.                         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
     ) Y3 z0 l" ~( J6 F) u
109.                 }
     2 L$ u! K8 S) s& ~* R* x8 S) p
110.         S_I2C_Delay(I2C_temp.SCL_Delay);
     9 V' w/ ~: x" q% [3 M, i9 V
111.                 I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
       F$ z* B9 D* Y
112.         S_I2C_Delay(I2C_temp.SCL_Delay);
     4 v( o' s- K' N6 E3 f
113.         }
     
114.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     $ \( m- W% u; `- A5 b( E% J  R
115.         I2C_temp.SDA_GPIO->MODER &= ~I2C_temp.SDA_MODER;
     ; h2 J0 c- c" Y  O* f2 |+ i: c
116.         S_I2C_Delay(I2C_temp.SCL_Delay);
     
117.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
     
118.         if(I2C_temp.SDA_GPIO -> IDR & I2C_temp.SDA_SBIT)
     
119.         {
     $ j& M( v, e( D$ P6 p
120.                 temp = NACK;
     ( t0 `$ i0 M+ @. \* X4 [
121.         }
     / J6 s8 @, q0 l& r/ M# K8 v# C
122.         else
     
123.         {
     
124.                 temp = ACK;
     + s& t8 v& P7 G7 c
125.         }
     , C$ S  Z$ E* F, m4 p
126.     S_I2C_Delay(I2C_temp.SCL_Delay);
     # X! U; d: K* u6 J& X
127.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
     $ {) q) n% J3 X2 G9 Z
128.         I2C_temp.SDA_GPIO->MODER |= I2C_temp.SDA_MODER_0;
     
129.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     ' b8 m4 O8 P( }- I! G
130.     S_I2C_Delay(I2C_temp.SCL_Delay);
     
131.         return temp;
     $ y  H* a4 e1 k- Q$ v, C: c3 _) T4 \/ W
132. }
     
133. 
     
134. /**
     4 F, Q% Q/ p, Y/ H/ i: z
135. * @description: 接收一个字节数据
     
136. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
     
137. * @param {uint8_t} nack        接收后结束要发送的应答信号
     
138. *                                                         NACK
     2 G, u& m4 N( q; [8 z; a& x% q
139. *                                                         ACK
     
140. * @return {uint8_t}        接收到的字节
     
141. */
     
142. uint8_t S_I2C_ReceiveByte(I2C_Struct I2C_temp, uint8_t nack)
     
143. {
     
144.         uint8_t byte = 0x00;
     
145.         I2C_temp.SDA_GPIO->MODER &= ~I2C_temp.SDA_MODER;
     
146.         for (uint8_t i = 8; i; i--)
     ( Z4 O! z# E' e! d9 s$ y
147.         {
     
148.                 I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     
149.         S_I2C_Delay(I2C_temp.SCL_Delay);
     3 `9 ~, j2 p1 a6 V1 e
150.                 byte <<= 1;
     
151.                 I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
     $ p# e$ G9 V2 c- Z+ i
152.                 if(I2C_temp.SDA_GPIO -> IDR & I2C_temp.SDA_SBIT)
     
153.                 {
     
154.                         byte |= 0x01;
     : @! Y, L6 x' L( K# G
155.                 }
     - [% X- r$ ]7 D% x# a% ^
156.         S_I2C_Delay(I2C_temp.SCL_Delay);
     
157.         }
     9 I* v1 J/ Y3 u9 F/ q1 F
158.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     
159.         I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
     
160.         I2C_temp.SDA_GPIO->MODER |= I2C_temp.SDA_MODER_0;
     
161.         if(nack)
     
162.                 I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_SBIT;
     
163.         else
     
164.                 I2C_temp.SDA_GPIO->BSRR |= I2C_temp.SDA_RBIT;
       ]3 h1 ]8 P, r/ V" B( L) z$ g. m& f
165.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_RBIT;
     
166.     S_I2C_Delay(I2C_temp.SCL_Delay);
     
167.         I2C_temp.SCL_GPIO->BSRR |= I2C_temp.SCL_SBIT;
     
168.     S_I2C_Delay(I2C_temp.SCL_Delay);
     
169.         return byte;
     . A) Y2 V$ I1 p
170. }
     
171. 
     , A/ _) P# X8 ]5 V7 q
172. 
     
173. /**
     
174. * @description: 写一个字节的寄存器
     
175. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
     
176. * @param {uint8_t} addr        器件地址(0x00~0x7f)
     
177. * @param {uint8_t} regAddr        寄存器地址(0x00~0xff)
     
178. * @param {uint8_t} data        数据
     
179. * @return {uint8_t}        FAILED        失败
     
180. *                                                 SUCCEED        成功
     
181. */
       ?( r1 o4 \+ l1 p$ i$ n
182. uint8_t S_I2C_WriteRegister(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t data)
     ' H8 D, u/ M' P7 k1 o% S
183. {
     
184.         addr <<= 1;
     
185.         S_I2C_Start(I2C_temp);
     % y. C3 J) x6 c$ r* }, b- I, `& `
186.         if(S_I2C_SendByte(I2C_temp, addr) == NACK)
     
187.         {
     9 I7 X0 B/ d; _+ ^; |$ X9 i
188.                 S_I2C_Stop(I2C_temp);
     , D/ P  s+ V* W% [" W2 z
189.                 return FAILED;
     
190.         }
     
191.         if(S_I2C_SendByte(I2C_temp, regAddr) == NACK)
     3 G# {. [! n; T% V/ O5 U" D( H( K) A# y
192.         {
     7 j7 Q# m1 V  t4 D
193.                 S_I2C_Stop(I2C_temp);
     # h. k! ^. N9 e
194.                 return FAILED;
     9 ]! n: c/ q) X* G& i
195.         }
     9 s2 N5 [9 ?* C: a
196.         if(S_I2C_SendByte(I2C_temp, data) == NACK)
     
197.         {
     
198.                 S_I2C_Stop(I2C_temp);
     
199.                 return FAILED;
     
200.         }
     
201.         S_I2C_Stop(I2C_temp);
     $ _" k! w' \$ d; z. s% @0 g! B1 [
202.         return SUCCEED;
     
203. }
     
204. 
     ! |+ P$ \' S& l, t7 s
205. 
     ' Y4 X5 o7 [$ g  c/ a2 L" V
206. /**
     
207. * @description:                 读取器件，读取格式：器件读-寄存器地址-读取数据
     ; c% G/ E" ?$ ^" P  E. G/ \
208. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
     
209. * @param {uint8_t} addr        器件地址(0x00~0x7f)
     
210. * @param {uint8_t} regAddr        寄存器地址(0x00~0xff)
     
211. * @param {uint8_t} amount        读取数据数量(0x00~0xff)
     
212. * @param {uint8_t*} data        返回数据指针
     
213. * @param {uint8_t} typ                数据指针类型（由于结构体和数组存储方式不一样，因此需要区分）
     % @4 Q( _5 G1 z4 z" V9 ?" p
214. *                                                 ARRAY        数组
     7 A, `  B3 h" C" l
215. *                                                 STRUCT        结构体
     8 S. k( O" Q2 {' B
216. * @return {*}                        FAILD   读取失败 数据无效
     ! {$ ^) t8 z7 @/ r- x
217. *                                                 SUCCEED 读取成功 数据有效
     
218. */
     
219. uint8_t S_I2C_ReadRegister(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t amount, uint8_t* data, uint8_t typ)
     
220. {
     
221.         S_I2C_Start(I2C_temp);
     , X& B' r* s, d% ]4 ^
222.         addr = (addr << 1) | 0x01;
     5 ]9 y- B2 S9 C. X
223.         if(S_I2C_SendByte(I2C_temp, addr) == NACK)
     3 z) Z9 K3 F$ @1 ?9 i$ M
224.         {
     
225.                 S_I2C_Stop(I2C_temp);
     ( u9 d& \8 p2 g) `% n
226.                 return FAILED;
     7 a0 Z. p  [% t, l, A3 q
227.         }
     , b  B0 T4 W, W1 v" \% k8 x; ?0 b
228.         if(S_I2C_SendByte(I2C_temp, regAddr) == NACK)
     
229.         {
     & q( m- i2 N9 \& p8 o+ c
230.                 S_I2C_Stop(I2C_temp);
     9 E. \* D. c  m1 ]) P2 \. D
231.                 return FAILED;
     
232.         }
     
233.         for(amount -= 1;amount;amount --)
     
234.         {
     ' }0 }- Q3 C0 p8 [, ]1 q' n: P
235.                 *data = S_I2C_ReceiveByte(I2C_temp, ACK);
     
236.                 if(typ == ARRAY)
     ) M. e8 B/ A* t& g/ ^
237.                         data ++;
     
238.                 else
     % j9 d- q5 S2 S! o5 f
239.                         data --;
     " }+ B0 T" V3 f; m
240.         }
     
241.         *data = S_I2C_ReceiveByte(I2C_temp, NACK);
     
242.         S_I2C_Stop(I2C_temp);
     ' I# G$ \4 q8 l% W
243.         return SUCCEED;
     
244. }
     
245. 
     * y% u' k$ |& O3 @- I' o4 B
246. /**
     
247. * @description:                 读取器件，读取格式：器件写-寄存器地址-器件读-读取数据
     6 m7 k6 H  \$ Q! N, F+ s$ X
248. * @param {I2C_Struct} I2C_temp        I2C_IO结构体
     6 F) Q# c% |5 A- m, O) D9 \
249. * @param {uint8_t} addr        器件地址(0x00~0x7f)
     5 `- D- W9 n' B0 m7 D5 e$ }& X
250. * @param {uint8_t} regAddr        寄存器地址(0x00~0xff)
     
251. * @param {uint8_t} amount        读取数据数量(0x00~0xff)
     ' s* P$ M5 s* ~+ N8 z
252. * @param {uint8_t*} data        返回数据指针
     
253. * @param {uint8_t} typ                数据指针类型（由于结构体和数组存储方式不一样，因此需要区分）
     
254. *                                                 ARRAY        数组
     * `$ k8 ^0 W+ b
255. *                                                 STRUCT        结构体
     
256. * @return {uint8_t}        FAILD   读取失败 数据无效
     
257. *                                                 SUCCEED 读取成功 数据有效
     8 U$ e# _$ y0 l+ o% M
258. */
     ) z0 _6 d1 ~$ @2 d; [# f
259. uint8_t S_I2C_PointerRead(I2C_Struct I2C_temp, uint8_t addr, uint8_t regAddr, uint8_t amount, uint8_t* data, uint8_t typ)
     / [' J! F7 c- Q& t: r) ~5 f9 B
260. {
     / x% }0 L, g, D1 Z- K: @8 m- J
261.         addr <<= 1;
     $ S) W% f/ D  w8 n  ~: @
262.         S_I2C_Start(I2C_temp);
     
263.         if(S_I2C_SendByte(I2C_temp, addr) == NACK)
     ) J$ q( V2 ~  p+ W
264.         {
     
265.                 S_I2C_Stop(I2C_temp);
     . ?$ o! ~8 X& d- p' |% ?
266.                 return FAILED;
     # N& p$ ?' j6 \
267.         }
     0 S) B. {" x$ Y) N! K
268.         if(S_I2C_SendByte(I2C_temp, regAddr) == NACK)
     
269.         {
     
270.                 S_I2C_Stop(I2C_temp);
     
271.                 return FAILED;
     
272.         }
     
273.         S_I2C_Stop(I2C_temp);
     
274.         
     
275.         addr |= 0x01;
     : @. \6 S" |; N9 |. N8 W/ ?
276.         S_I2C_Start(I2C_temp);
     
277.         if(S_I2C_SendByte(I2C_temp, addr) == NACK)        //NACK
       N, h1 D( z8 a
278.         {
     9 \6 e( @6 f% W% a3 n6 m
279.                 S_I2C_Stop(I2C_temp);
     4 R  [  Q2 K$ |  g
280.                 return FAILED;
     2 P1 }% ?$ |/ ?; I8 `' T+ i4 p$ c! m
281.         }
     
282.         for(amount -= 1;amount;amount --)
     
283.         {
     
284.                 *data = S_I2C_ReceiveByte(I2C_temp, ACK);
     
285.                 if(typ == ARRAY)
     * W) i0 G) u& \& b; X3 R  @, H
286.                         data ++;
     
287.                 else
     ( m3 h! q/ W9 a# r% x
288.                         data --;
     1 \: ^; }, X  }( G7 I
289.         }
     
290.         *data = S_I2C_ReceiveByte(I2C_temp, NACK);
     ' Q- R; `4 t# @$ \* n
291.         S_I2C_Stop(I2C_temp);
     0 J1 J3 y0 O. ]4 k% ~0 L
292.         return SUCCEED;
     7 A0 f( v! d$ ^% K3 D! S* q$ [
293. }

复制代码

* \# U3 M( ~7 ]+ q使用方法

1. void main(void)
   
2. {
   
3.         CLOCK_Init();
   1 K# ]. _0 ^0 r/ a9 e: y7 F  K
4.         GPIO_Init();
   $ |/ A( g8 l3 V' M, n1 {4 I
5.         S_I2C_Init();//初始化结构体，在宏定义中修改引脚等定义
   % A: V. N. p9 z; z1 E
6.         //接下来就可以调用I2C函数了
   5 I( w2 [& @% \' h3 S( D2 k
7. }

复制代码

————————————————
7 n7 Y  g8 s5 l7 }转载：Vice Versa XL
8 U5 s3 h+ V8 q9 `0 d