实现效果图
( I, c+ E6 K$ Q7 S. X0 g

  e9 ?  Z/ c" O: i) \0 D3 _* f

2 K2 V8 ]% p  d+ y* U) c

I2C协议简介

I2C 通讯协议(Inter－Integrated Circuit)是由 Phiilps 公司开发的，由于它引脚少，硬件实现简单，可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备（那些电平转化芯片），现在被广泛地使用在系统内多个集成电路(IC)间的通讯。

I2C只有一根数据总线 SDA(Serial Data Line)，串行数据总线，只能一位一位的发送数据，属于串行通信，采用半双工通信

半双工通信：可以实现双向的通信，但不能在两个方向上同时进行，必须轮流交替进行，其实也可以理解成一种可以切换方向的单工通信，同一时刻必须只能一个方向传输，只需一根数据线.
对于I2C通讯协议把它分为物理层和协议层物理层规定通讯系统中具有机械、电子功能部分的特性（硬件部分），确保原始数据在物理媒体的传输。协议层主要规定通讯逻辑，统一收发双方的数据打包、解包标准（软件层面）。

I2C物理层

I2C 通讯设备之间的常用连接方式

, Y: W4 A4 r9 e, m

(1) 它是一个支持多设备的总线。“总线”指多个设备共用的信号线。在一个 I2C 通讯总线中，可连接多个 I2C 通讯设备，支持多个通讯主机及多个通讯从机。

(2) 一个 I2C 总线只使用两条总线线路，一条双向串行数据线SDA（Serial Data Line ），一条串行时钟线SCL（Serial Data Line ）。数据线即用来表示数据，时钟线用于数据收发同步

(3) 总线通过上拉电阻接到电源。当 I2C 设备空闲时会输出高阻态，而当所有设备都空闲，都输出高阻态时，由上拉电阻把总线拉成高电平。

I2C通信时单片机GPIO口必须设置为开漏输出，否则可能会造成短路。

4 q. Z1 C* V3 u  w

AHT10温湿度传感器介绍

AHT10是一款国产的温湿度传感器芯片，价格便宜，精度还高，体积也小。

AHT10配有一个全新设计的ASIC专用芯片、一个经过改进的MEMS半导体电容式湿度传感元件和一个标准的片上温度传感元件，其性能已经大大提升甚至超出了前一代传感器的可靠性水平，新一代温湿度传感器，经过改进使其在恶劣环境下的性能更稳定。

浏览数据手册可以得到一个大概信息：

• 温度范围：-40℃~85℃
• 温度误差：±0.3℃
• 湿度范围：0%~100%
• 湿度误差：±2%
• 工作电压：1.8v~3.6v
• 通讯方式：I2C
• 时钟频率：100kHz和400kHz
  
  - ?% @1 `4 V! i. C/ W# ^

温湿度设备地址和读写命令

在实际的使用过程中，AHT10的设备地址需要与读写数据/命令方向位组成一个字节同时发送，字节的最低位为读写数据/命令方向位，高7位是AHT10的设备地址。

如果要通过I2C写数据或命令给AHT10，在I2C起始信号之后，需要发送“0111 0000”，即0x70给AHT10，除了通过高7位“0111 000”的设备地址寻址还通过最低位“0”通知AHT10接下来是写数据或命令操作。

如果要通过I2C读取AHT10中的数据，在I2C起始信号之后，需要发送“0111 0001”，即0x71给AHT10，除了通过高7位“0111 000”的设备地址寻址还通过最低位“1”通知AHT10接下来是读取数据的操作。
& P) @" i( r) p1 h简单来说就是，0x70表示写数据，0x71表示读数据。不过使用STM32硬件I2C时只需要输入0x70就行，最低位标准库会处理的。

1 D4 U; I: d9 K; ^2 }

读取温湿度数据

) A& H% N1 _4 |8 e( h/ q

6 B8 W& V6 W9 Y4 C; D) f7 ~7 Z" j

从数据手册可知，一个测量周期包概括三个步骤：

• 发送测量命令
• 等待测量完成
• 读取测量后的数据　
  
  

总结如下：

• 发送测量命令：先发送写入指令（0x70），再发送触发测量指令（0xAC）,再发送命令参数（0x33和0x00）。
• 等待测量完成：数据手册上写的75ms，等待的时间大于这个就行了。
• 接收数据：发送读取指令（0x71），连续接收6个字节数据。接收到的第一个字节是状态字，检查状态字第3位校准使能位是否为1，不为1就发送初始化命令，检查第7位忙闲指示，如果是0为测量完成，进行下一步。
• 对接收到的数据进行转换处理。
  
  - C! H  o. A* A, h  e
  $ \1 E3 s3 I, J. C

数据的计算

由AHT10数据手册可知

- e! r. v2 o' g3 O+ ~9 [+ s0 I

例如：采集到的湿度数值是0x0C6501，换算成十进制是812289。
1 ~! }& H$ d, f; o4 v2 c  J则：湿度 = 812289 * 100 / 1048576 = 77.46 （单位：%）
2 r( C& d: r" t+ q采集到的温度数值是0x056A00，换算成十进制是354816。
则：温度 = ( 354816 * 200 / 1048576 ) - 50= 17.67 （单位：℃）

程序

这里就放出main.c、AHT10.c和OLED.c这三个主要的代码，其他的请下载下面链接的压缩包。

AHT10和OLED模块的 SCL接PB6，SDA接PB7。

main.c

1. #include "stm32f10x.h"                  // Device header
   
2. #include "Delay.h"
   $ Y! g* y2 P5 `" I
3. #include "OLED.h"
   ( o2 x3 k3 ]' m6 X3 ]4 o
4. #include "IWDG.h"
   
5. #include "AHT10.h"
   
6. 
   8 @" z% Q( X, R% {  C, \
7. 
   0 t' r3 Q! H6 m+ k4 T6 B& z
8. uint16_t numlen(uint16_t num);
   - o) e6 H2 q9 [0 F8 I# M
9. 
   
10. int main(void)
    
11. {
    7 [: z- X. k# \# [9 a  H
12.   IWDG_Configuration();  //初始化看门狗
    
13.   OLED_Init();      //初始化OLED屏
    ! e3 y: A2 ?7 A+ W4 o
14.   AHT10_Init();      //初始化AHT10
    
15.   
    6 j9 j/ w+ W. p& K
16.   OLED_ShowString(1, 1, "T:");
    ; c6 p2 b. @! W. u
17.   OLED_ShowString(2, 1, "H:");
    7 q# n9 _, S" R% ?: [; Y. i: ?) ~$ k
18. 
    
19.   uint32_t a=0;
    / E$ I7 G' U- U: Q& g4 a: t
20.   uint16_t err_count=0;
    9 y, X0 O' \* {6 ?' A
21.   
    
22.   while (1)
    
23.   {
    9 c: ?  Z+ B& S( Z2 S
24.     a++;
    
25.     OLED_ShowNum(3, 1, a, 9);//计数显示，方便观察程序是否正常运行
    % q" J* P( R" q5 [. {  _/ {: C1 V
26.     if(a==999999999)a=0;
    2 a8 n( [2 v! N) l' ^7 t. |
27. 
    
28.     float Temp,Hum;      //声明变量存放温湿度数据
    
29.    
    
30.   /*
    
31.   https://blog.zeruns.tech
    
32.   */
    
33. 
    
34.     if(ReadAHT10(&Hum,&Temp))  //读取温湿度数据
    
35.     {
    
36.       if(Temp>=0)
    0 `3 N& v' ~0 U5 o
37.       {
    
38.         char String[10];
    & b5 q" G9 _. A4 F+ Q) v$ ~8 |$ n
39.         sprintf(String, "+%.2fC", Temp);//格式化字符串输出到字符串变量
    
40.         OLED_ShowString(1, 3, String);  //显示温度
    
41. 
    
42.         sprintf(String, " %.2f%%", Hum);//格式化字符串输出到字符串变量
    ( b9 z% ~- u1 v. y3 V
43.         OLED_ShowString(2, 3, String);  //显示湿度
    
44.       }else
    
45.       {
    5 N$ o/ I- i9 n. u) O
46.         char String[10];
    # w* z, b* ]. q
47.         sprintf(String, "-%.2fC", Temp);//格式化字符串输出到字符串变量
    
48.         OLED_ShowString(1, 3, String);  //显示温度
    
49.         
    " D1 f: |  `7 x& n4 S
50.         sprintf(String, " %.2f%%", Hum);//格式化字符串输出到字符串变量
    
51.         OLED_ShowString(2, 3, String);  //显示湿度
    
52.       }
    * K0 \: [+ i9 a. A4 y: J- z, n# R
53.     }
    
54.     else
    1 M. l2 I% ?2 r; s
55.     {
    6 D+ O8 U% u7 T. }6 q* V, z! `" ~) D# E
56.       err_count++;
    
57.       OLED_ShowNum(4,1, err_count, 5);  //显示错误次数计数
    
58.     }
    0 }) o1 h/ E2 x+ g1 u
59. 
    
60.     Delay_ms(100);  //延时100毫秒
    ( N! J  r; q8 `3 M( S( _$ H! ^
61. 
    
62.     IWDG_FeedDog();  //喂狗（看门狗，超过1秒没有执行喂狗则自动复位）
    
63.   }
    
64. }

复制代码

AHT10.c

1. #include "stm32f10x.h"
   " D/ I. a# k: ?9 F8 J
2. #include "Delay.h"
   $ |2 w) u! o6 k
3. #include "OLED.h"
   
4. 
   ' {7 N: ?6 Q8 m
5. /*AHT10地址*/
   ' z+ e3 G$ M, I0 ~4 D6 ^5 \9 R
6. #define AHT10_ADDRESS 0x38<<1 //从机地址是7位，最后一位是传输方向位，所以左移一位
   
7. 
   5 E+ k) s5 I; k  z/ [; F
8. /*设置使用哪一个I2C*/
   
9. #define I2Cx I2C1
   ; a. [2 Q% V/ k2 X+ n7 p
10. 
    ' u' H, S) w6 D* y4 x+ w
11. /*
    
12. https://blog.zeruns.tech
    - R+ B# q0 K6 i' \, \/ O
13. */
    
14. 
    
15. 
    
16. /*发送起始信号*/
    
17. void AHT10_I2C_START(){
    
18.     while( I2C_GetFlagStatus(I2Cx, I2C_FLAG_BUSY));//等待总线空闲
    
19.   I2C_GenerateSTART(I2Cx, ENABLE);//发送起始信号
    
20.   while( I2C_CheckEvent(I2Cx,I2C_EVENT_MASTER_MODE_SELECT)==ERROR);//检测EV5事件
    * l' x- N" e! s4 K* G0 E
21. }
    
22. 
    
23. /*发送停止信号*/
    . B5 q' t# C9 y1 N  h: y+ l$ B
24. void AHT10_I2C_STOP(){
    
25.     I2C_GenerateSTOP(I2Cx, ENABLE);//发送停止信号
    
26. }
    
27. 
    
28. /**
      H" A) G" a" l
29.   * @brief  发送3个字节数据
    
30.   * @param  cmd 命令字节
    ; H8 M9 i0 _( ]& B3 K. o+ P! c7 e, z- ^
31.   * @param  DATA0 第0个参数
    
32.   * @param  DATA1 第1个参数
    
33.   * @retval 无
    ! ?/ C1 H- x4 q4 d
34.   */
    * Q9 K% m7 j/ P8 B; k/ ^
35. void AHT10_WriteByte(uint8_t cmd, uint8_t DATA0, uint8_t DATA1)
    8 B0 f% `( q0 |
36. {
    ! Q9 U! D* W% K1 w7 E- T8 j, A
37.   AHT10_I2C_START();  //发送起始信号
    
38.   
    0 B. i3 T. `5 A( l8 B2 o
39.   I2C_Send7bitAddress(I2Cx, AHT10_ADDRESS, I2C_Direction_Transmitter);    //发送设备写地址
    
40.   while(I2C_CheckEvent(I2Cx,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)==ERROR);  //检测EV6事件
    3 C- R& c+ ]7 o  P
41. 
    
42.     I2C_SendData(I2Cx, cmd);//发送命令
    
43.   while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED));//检测EV8事件
    9 b! c8 t: V% D* h) o7 k
44. 
    7 d, U* {4 M- Y8 X8 p2 r
45.     I2C_SendData(I2Cx, DATA0);//发送命令参数高8位数据
    5 p6 X5 {! e# @# k" L3 B5 ?
46.   while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED));//检测EV8事件
    ) S1 |* i' c$ V1 a0 e; B. h5 Z
47.    
    ' a5 |8 P' A; T% x
48.   I2C_SendData(I2Cx, DATA1);//发送命令参数低8位数据
    5 h# b% J; R8 `  m
49.   while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED));//检测EV8事件
    8 r# y  {% b) M$ o6 `8 u% P( t
50.   
    - E" b1 J2 |+ R' ]/ T: P
51.   I2C_GenerateSTOP(I2Cx, ENABLE);//发送停止信号  
    " n0 [4 ?( v- G" m5 k
52. }
    : M* _& b3 g8 a& i% w' d6 t
53. 
    ) A2 e2 Y3 d* S7 o' X
54. 
    9 K9 g* T- }6 R6 P
55. /**
    7 x; T2 j# Q5 c& n& ]
56.   * @brief  发送命令读取AHT10的状态
    ' f7 D- n1 \$ Q5 `+ c1 Z2 f
57.   * @retval 读取到的状态字节
    
58.   */
    
59. /*uint8_t AHT10_ReadStatus(void){
    3 Q  i+ V& N. w; O# c8 i: r. c
60.     AHT10_I2C_START();//发送起始信号  
    + L$ V: R) T1 B4 b3 L0 U" M
61.   I2C_Send7bitAddress(I2Cx,AHT10_ADDRESS,I2C_Direction_Receiver);//发送设备读地址
    2 _4 K8 I2 `- K+ }, Z
62.   while( I2C_CheckEvent(I2Cx,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED )==ERROR);//检测EV6事件
    
63.     while (!I2C_CheckEvent(I2Cx,I2C_EVENT_MASTER_BYTE_RECEIVED));//检测EV7事件
    
64.   I2C_AcknowledgeConfig(I2Cx, DISABLE); //关闭应答信号
    
65.   uint8_t status = I2C_ReceiveData(I2Cx);//读取数据并返回
    
66.   AHT10_I2C_STOP();   //发送停止信号
    
67.   I2C_AcknowledgeConfig(I2Cx,ENABLE);//重新开启应答信号
    
68.   return status;
    
69. }*/
    
70. 
    3 f2 e. u$ ~* P( y' x, K' q
71. /**
    $ U7 P  `; L; O
72.   * @brief  读取数据
    
73.   * @retval 读取到的字节数据
    
74.   */
    
75. uint8_t AHT10_ReadData(void)
    ) q' D$ p, [4 p3 j8 j: H7 Q+ _2 M) S
76. {
    4 a, `$ |6 ]( o  d
77.     while (!I2C_CheckEvent(I2Cx,I2C_EVENT_MASTER_BYTE_RECEIVED));//检测EV7事件
    0 F$ S( M- J* b5 B
78.   return I2C_ReceiveData(I2Cx);//读取数据并返回
    + j6 f/ p+ _3 _, o
79. }
    7 A: i& M9 Y# e6 t
80. 
    - u1 i2 t: i. G! Z) M' [  c
81. /*软件复位AHT10*/
    3 [0 A  b1 r5 P# y! C
82. void AHT10_SoftReset(void)                    
    
83. {
    
84.     AHT10_I2C_START();  //发送起始信号
    
85.   I2C_Send7bitAddress(I2Cx, AHT10_ADDRESS, I2C_Direction_Transmitter);    //发送设备写地址
    
86.   while(I2C_CheckEvent(I2Cx,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)==ERROR);  //检测EV6事件
    
87.     I2C_SendData(I2Cx, 0xBA);//发送软复位命令
    
88.   while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED));//检测EV8事件
      u; [! i' T/ Z- d  R  z- K4 C
89.     I2C_GenerateSTOP(I2Cx, ENABLE);//发送停止信号
    
90.   Delay_ms(20);
    ; b) R4 |$ h' c& J  U, P
91. }
    
92. 
    9 \5 Q2 p/ ?! G
93. 
    
94. /*引脚初始化*/
    / ]7 r" L, m2 E: Q
95. void AHT10_Init(void)
    . O6 i: }6 @9 R$ Z
96. {
    
97.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1,ENABLE);  //使能I2C1时钟
    0 R6 R1 Q1 X: @
98.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);//使能GPIOB时钟
    ' x2 u9 m3 m! @/ n8 v: N, J/ c
99. 
    - a+ W% k3 r" S  }9 o3 c. m* s
100.   /*STM32F103芯片的硬件I2C1: PB6 -- SCL; PB7 -- SDA */
     . @. e- Q$ l" p0 Q% g8 i4 B7 h
101.   GPIO_InitTypeDef  GPIO_InitStructure;               //定义结构体配置GPIO
     
102.   GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6 | GPIO_Pin_7;
     
103.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   
     
104.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;    //设置输出模式为开漏输出，需接上拉电阻
     
105.   GPIO_Init(GPIOB, &GPIO_InitStructure);              //初始化GPIO
     
106.   
     + e0 l& ]! d$ @6 J. ^1 M8 F
107.   I2C_DeInit(I2Cx);  //将外设I2C寄存器重设为缺省值
     ! o6 Q  n# x, \
108.   I2C_InitTypeDef  I2C_InitStructure;                 //定义结构体配置I2C
     2 t( z. I& U0 ~
109.   I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;      //工作模式
     
110.   I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;  //时钟占空比，Tlow/Thigh = 2
     
111.   I2C_InitStructure.I2C_OwnAddress1 = 0x88;  //主机的I2C地址,用不到则随便写，无影响
     - f' L0 k! A4 ^% r9 {
112.   I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;  //使能应答位
     8 X' |5 r) k; b1 n* x/ s+ T
113.   I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;//设置地址长度7位
     5 f6 o( l+ [; w" z7 c) s/ q+ x9 L/ ]
114.   I2C_InitStructure.I2C_ClockSpeed = 400000;  //I2C传输速度，400K，根据自己所用芯片手册查看支持的速度。  
     
115.   I2C_Init(I2Cx, &I2C_InitStructure);         //初始化I2C
     ! F  ?2 w9 h" V$ d" S# X, z/ T, \; N
116. 
     9 Q& y& e) E) Q9 h
117.   I2C_Cmd(I2Cx, ENABLE);  //启用I2C
     
118.   Delay_ms(20);//上电延时
     
119.   AHT10_WriteByte(0XE1,0X08,0x00);//发送指令初始化
     9 A* W5 J9 J# N4 g3 w5 h
120.   Delay_ms(20);
     
121. 
     
122. }
     % S7 f' Y8 v$ M* e/ X# }
123. 
     
124. /**
     
125.   * @brief  读取AHT10数据
     5 j; _0 v  j6 Y7 p* s6 B3 W
126.   * @param  *Hum 湿度
     ' f; G' K( V- F/ X1 Z7 L; K
127.   * @param  *Temp 温度
     
128.   * @retval 1 - 读取成功；0 - 读取失败
     : m+ _( ]4 L+ @0 @
129.   */
     9 g7 \& E$ P3 [! _9 B
130. uint8_t ReadAHT10(float *Hum,float *Temp)
     
131. {
     0 P( X9 f. N' Y0 g/ b3 y. q, r
132.   uint8_t Data[5];//声明变量存放读取的数据
     
133. 
     - m- j  t2 x, T/ y' Q
134.   AHT10_WriteByte(0XAC,0X33,0x00);//发送指令触发测量
     4 D" P' B2 f3 ^. m5 p
135. 
     
136.   Delay_ms(70);  //延时70毫秒等待测量完成
     ) [: x1 `. w8 ?1 A2 t1 _; N7 U
137. 
     
138.   AHT10_I2C_START();//发送起始信号  
     " K# K  ~. K# t; B
139.   I2C_Send7bitAddress(I2Cx,AHT10_ADDRESS,I2C_Direction_Receiver);//发送设备读地址
     # L% a( Y# l$ v( h. n
140.   while( I2C_CheckEvent(I2Cx,I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED )==ERROR);//检测EV6事件
     " e% A6 q3 ?5 X/ s6 P# l$ N' c, J
141.   
       m7 ~3 R# @! N/ S+ o
142.   uint8_t i;
     * k5 k+ ?& U& g5 U* ]% J7 C, {
143.   for(i=0;i<6;i++)//循环6次读取6个字节数据
     
144.   {
     # Y( P4 U' |( W( g
145.     if (i == 5)  //读取最后1个字节时关闭应答信号
     % ~+ ?) v# j5 w* h
146.     {
     ( V8 ?4 _- W. B5 q
147.       I2C_AcknowledgeConfig(I2Cx, DISABLE); //关闭应答信号
     
148.     }
     $ U& [/ r* Z' v3 P* h9 e8 p: Y8 Z
149.     Data[i] = AHT10_ReadData();  //读取数据
     
150.     if (i == 5)
     : o7 T- e; @. R( ~0 z+ K0 w5 H
151.       I2C_GenerateSTOP(I2Cx, ENABLE); //发送停止信号
     
152.   }
     + E( `1 l  U: h5 y
153.   I2C_AcknowledgeConfig(I2Cx,ENABLE);//重新开启应答信号
     
154. 
     - J1 r8 R" ^$ t# Y6 O
155.   if( (Data[0]&0x08) == 0 )//0x08(00001000)检查状态字节第3位(校准使能位)是否为0
     
156.   {
     
157.     AHT10_WriteByte(0XE1,0X08,0x00);  //发送指令初始化
     
158.     Delay_ms(20);
     
159.     return 0;
     
160.   }
     
161.   else if( (Data[0]&0x80) == 0 )//0x80(10000000)检查状态字节第7位(忙闲指示)是否为0
     4 H) z9 v' h; p8 v3 C
162.   {
     
163.    
     
164.     uint32_t SRH = (Data[1]<<12) | (Data[2]<<4) | (Data[3]>>4);  //湿度数据处理
     
165.     uint32_t ST = ((Data[3]&0x0f)<<16) | (Data[4]<<8) | Data[5];//温度数据处理
     
166. 
     
167.     *Hum = (SRH * 100.0) / 1024.0 / 1024;     //根据手册给的公式转换湿度数据
     
168.     *Temp = (ST * 200.0) / 1024.0 / 1024 - 50; //根据手册给的公式转换温度数据
     
169. 
     2 `2 C7 R6 \6 r5 U$ E; @& r
170.     return 1;
     5 i3 F1 y" l% |: ]: G
171.   }
     
172. 
     4 X5 \! Q6 G# Z3 q
173.   I2C_GenerateSTOP(I2Cx, ENABLE);//发送停止信号
     ( z+ d- Z+ K# |; s; y- c
174.   return 0;  
     ; @4 U3 t% S- S6 [5 ]' N; ]! R* e
175. 
     - [4 D, H% x/ x  `7 G
176. }
     1 J; J0 f( G' L0 ?' l
177. 
     
178. /*
     / h" @/ i& e7 o: X& m+ |
179. https://blog.zeruns.tech
     
180. */

复制代码

OLED.c

1. #include "stm32f10x.h"
   6 G% a' \) F3 J
2. #include "OLED_Font.h"
   . U! p% |0 U- ~- x3 K4 G$ v
3. 
   
4. /*OLED屏地址*/
   " W. T# U( r! N# l7 _8 b
5. #define OLED_ADDRESS 0x78
   
6. 
   
7. /*设置哪一个使用I2C*/
   / n0 b8 y, R& G- F, J: s2 D2 g
8. #define I2Cx I2C1
   
9. 
   
10. /*
    4 W4 T: l) p7 F! Q3 a- U2 n) e! N1 {
11. https://blog.zeruns.tech
    
12. */
    : g, C+ x2 p: k
13. 
    
14. /*引脚初始化*/
    1 y! x6 s& ^  h: K
15. void OLED_I2C_Init(void)
    ' m% ]& C/ D, P9 K4 ~- s
16. {
    " Y$ ~9 |4 u5 e/ {  K& O  U5 Q
17.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1,ENABLE);  //使能I2C1时钟
    ! s" A0 ?0 T5 A. i7 U0 d8 j) b
18.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);//使能GPIOB时钟
    . Q; G" ]4 T9 h7 g5 {
19. 
    . {4 }2 ^# c# G, V  b4 f0 T
20.   /*STM32F103芯片的硬件I2C: PB6 -- SCL; PB7 -- SDA */
    
21.   GPIO_InitTypeDef  GPIO_InitStructure;
    * o9 e+ q" w4 w8 i
22.   GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6 | GPIO_Pin_7;
    ; L1 U% ^1 v9 a. f  V8 ^3 c
23.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    9 j4 R9 H: |" D2 q; Z/ S- M
24.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;    //设置输出模式为开漏输出，需接上拉电阻
    
25.   GPIO_Init(GPIOB, &GPIO_InitStructure);
    
26.   
    
27.   I2C_DeInit(I2Cx);  //将外设I2C寄存器重设为缺省值
      s8 S* w, D4 g7 s( A0 s% [# E. n# r
28.   I2C_InitTypeDef  I2C_InitStructure;
    
29.   I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;      //工作模式
    9 r, X& K5 @# Q
30.   I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;  //时钟占空比，Tlow/Thigh = 2
    
31.   I2C_InitStructure.I2C_OwnAddress1 = 0x88;  //主机的I2C地址,用不到则随便写，无影响
    # y2 ^  q+ B, i$ f
32.   I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;  //使能应答位
    
33.   I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;//设置地址长度7位
      t8 s5 W  z4 H# \8 ?7 {
34.   I2C_InitStructure.I2C_ClockSpeed = 400000;  //I2C传输速度，400K，根据自己所用芯片手册查看支持的速度。  
    
35.   I2C_Init(I2Cx, &I2C_InitStructure);
    
36. 
    
37.   I2C_Cmd(I2Cx, ENABLE);
    
38. }
    
39. 
    
40. void I2C_WriteByte(uint8_t addr,uint8_t data)
    
41. {
      R5 t1 Z* y5 S' |8 |% a* X
42.   
    
43.   while( I2C_GetFlagStatus(I2Cx, I2C_FLAG_BUSY));
    
44.   
    ( V# l5 o/ f) E) W6 e
45.   //发送起始信号
    
46.   I2C_GenerateSTART(I2Cx, ENABLE);
    $ [4 l" A6 K9 T1 l
47.   //检测EV5事件
    
48.   while( I2C_CheckEvent(I2Cx,I2C_EVENT_MASTER_MODE_SELECT)==ERROR);
    % z. l! y% ^2 Z* h" \
49.   //发送设备写地址
    
50.   I2C_Send7bitAddress(I2Cx, OLED_ADDRESS, I2C_Direction_Transmitter);
    * ^4 O/ N; S2 x& [5 ]
51.   //检测EV6事件
    $ l$ Y6 a# D, C3 i: @7 l) W
52.   while( I2C_CheckEvent(I2Cx,I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)==ERROR);
    
53.   
    0 ^& O; N* g9 G1 U# Q7 J$ Q' `
54.   //发送要操作设备内部的地址
    
55.   I2C_SendData(I2Cx, addr);
    + Z9 H7 e' d- O; c: V( |. {  u
56.   //检测EV8_2事件
    
57.   while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
    $ `$ g$ d  _( d3 s& r4 N
58.   
    6 g$ i$ j' I$ v9 c, N  a( W
59.   I2C_SendData(I2Cx, data);//发送数据
    $ E. m: ^( |5 a! S! M2 J( n; E
60.   while (!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
    5 C- P" o! u3 f$ S; \
61. 
    
62.   //发送停止信号
    
63.   I2C_GenerateSTOP(I2Cx, ENABLE);
    1 i/ P  I2 B# y) B0 J5 O, l3 W
64. }
    
65. 
    
66. /**
    
67.   * @brief  OLED写命令
    + Q& {# g- I" r/ o$ ?3 C
68.   * @param  Command 要写入的命令
    
69.   * @retval 无
    
70.   */
    
71. void OLED_WriteCommand(unsigned char Command)//写命令
    0 T, l: q8 ^" o4 e5 ~
72. {
    
73.   I2C_WriteByte(0x00, Command);
    9 G  C9 o, Q) E( A
74. }
    
75. 
      J" X4 K9 V+ G, Z1 L
76. /**
    
77.   * @brief  OLED写数据
    & o4 ]; n, u0 D& z- |
78.   * @param  Data 要写入的数据
    9 K( R; Z) \2 m, X7 {7 Q1 X
79.   * @retval 无
    
80. */
    1 a$ u& Q+ P7 Q  w: O
81. void OLED_WriteData(unsigned char Data)//写数据
    
82. {
    
83.   I2C_WriteByte(0x40, Data);
    1 [/ {/ N! B+ R, w
84. }
    
85. 
    
86. /**
    ! J3 w2 z5 y" I1 W& b/ p
87.   * @brief  OLED设置光标位置
    , a/ y' C& ~* w( m! f" l6 t
88.   * @param  Y 以左上角为原点，向下方向的坐标，范围：0~7
    ! z& n, o& ?8 c' X0 ?8 M5 c
89.   * @param  X 以左上角为原点，向右方向的坐标，范围：0~127
    3 V) X: D& C: ~
90.   * @retval 无
    
91.   */
    8 T, I& k  ^, [3 ]* O
92. void OLED_SetCursor(uint8_t Y, uint8_t X)
    ! Y* K) q! o4 `* F7 _7 v
93. {
    7 J# b9 S% z* L( N  B% \0 |
94.   OLED_WriteCommand(0xB0 | Y);          //设置Y位置
    
95.   OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4));  //设置X位置低4位
    ; F6 o& j, a+ e, V$ U
96.   OLED_WriteCommand(0x00 | (X & 0x0F));      //设置X位置高4位
    
97. }
    
98. 
    / _* s- o/ ]2 u# R' ?
99. /**
    
100.   * @brief  OLED清屏
     5 j/ G0 ^5 R7 X0 i
101.   * @param  无
     . `- R5 N6 Y/ r- m/ G/ O
102.   * @retval 无
     : H) J9 S2 I5 r. j4 U
103.   */
     2 _+ z- ]- L) b1 V
104. void OLED_Clear(void)
     
105. {  
     
106.   uint8_t i, j;
     4 Q, f, Q& R0 D$ n3 I8 s. n2 ]. |
107.   for (j = 0; j < 8; j++)
     
108.   {
     
109.     OLED_SetCursor(j, 0);
     
110.     for(i = 0; i < 128; i++)
     . Y" U7 ^# f% S% h, \& U
111.     {
     
112.       OLED_WriteData(0x00);
     3 z( E2 O3 N2 }. j# ]
113.     }
     : R/ [: f2 C! q" |
114.   }
     
115. }
     
116. 
     ' c% S; J2 {0 P: _6 F
117. /**
     / p1 q4 u' n1 j9 m; v
118.   * @brief  OLED部分清屏
     7 n3 m8 s( Z2 ]3 k4 O' u: P: f
119.   * @param  Line 行位置，范围：1~4
     % c2 X9 T9 C0 \- |& p& X/ D
120.   * @param  start 列开始位置，范围：1~16
     
121.   * @param  end 列开始位置，范围：1~16
     3 V/ E; R) @$ Q1 p: Q( M
122.   * @retval 无
     
123.   */
     
124. void OLED_Clear_Part(uint8_t Line, uint8_t start, uint8_t end)
     
125. {  
     , w* j8 X) m7 e% a5 m5 i* _$ m. p  j
126.   uint8_t i,Column;
     5 E0 x" D  N+ n$ j# R1 K3 F
127.   for(Column = start; Column <= end; Column++)
     
128.   {
     
129.     OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);    //设置光标位置在上半部分
     
130.     for (i = 0; i < 8; i++)
     3 p: t# J5 q% I; S7 Q3 v8 u
131.     {
     ! n+ h# a$ l. i7 j9 k( A; R
132.       OLED_WriteData(0x00);      //显示上半部分内容
     % r3 i; U: c2 z* G0 G4 V
133.     }
     
134.     OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);  //设置光标位置在下半部分
     
135.     for (i = 0; i < 8; i++)
     
136.     {
     
137.       OLED_WriteData(0x00);    //显示下半部分内容
     
138.     }
     
139.   }
     
140. }
     
141. 
     $ q$ z( u+ p5 w1 ~, \2 e
142. /**
     : ]7 o$ z( L1 ^0 s5 i( K( }
143.   * @brief  OLED显示一个字符
     . ^" @* H) j3 o( Q
144.   * @param  Line 行位置，范围：1~4
     
145.   * @param  Column 列位置，范围：1~16
     
146.   * @param  Char 要显示的一个字符，范围：ASCII可见字符
     
147.   * @retval 无
     
148.   */
     
149. void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char)
     7 H0 m3 M; L7 w7 j
150. {        
     : i. Z1 d( L/ `
151.   uint8_t i;
     3 ~, I- T( F0 t6 w1 x  a- \
152.   OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);    //设置光标位置在上半部分
     , e4 I- r5 i4 z; o' E( L. J3 k1 z% j
153.   for (i = 0; i < 8; i++)
     
154.   {
     6 P! q( F; g: c) _- o: j: h
155.     OLED_WriteData(OLED_F8x16[Char - ' '][i]);      //显示上半部分内容
     , D8 M7 W* r- A+ I5 ]
156.   }
     ! c! P# r+ p0 y3 H
157.   OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);  //设置光标位置在下半部分
     6 U, J: A5 F6 b' d
158.   for (i = 0; i < 8; i++)
     3 P, O, E8 s0 Z) k; h; ~, s
159.   {
     5 w# _2 B! y* v: t: \/ y4 O
160.     OLED_WriteData(OLED_F8x16[Char - ' '][i + 8]);    //显示下半部分内容
     ( y$ D8 p1 j7 A- n- o$ D; |
161.   }
     $ }/ K( m4 B) K2 z
162. }
     
163. 
     + @7 `* E$ w' d% E0 E2 [
164. /**
     # _2 L+ g6 x5 |
165.   * @brief  OLED显示字符串
     
166.   * @param  Line 起始行位置，范围：1~4
       o4 Y2 B) g2 C
167.   * @param  Column 起始列位置，范围：1~16
     
168.   * @param  String 要显示的字符串，范围：ASCII可见字符
     
169.   * @retval 无
     
170.   */
     9 Y! U! ^: }$ i# U) Z, \( r
171. void OLED_ShowString(uint8_t Line, uint8_t Column, char *String)
     
172. {
     . C) `$ G0 Y, ]7 O' Z' t4 x' D% |
173.   uint8_t i;
     " C7 u0 P) @$ s1 g% ^( `
174.   for (i = 0; String[i] != '\0'; i++)
     
175.   {
     2 }/ N  G, p9 z3 k3 f2 A! G# _
176.     OLED_ShowChar(Line, Column + i, String[i]);
     & k2 x: D6 N$ A, L" Q# i
177.   }
     
178. }
     
179. 
     $ m+ V  K3 s: P  }+ Q9 X6 r3 U1 i
180. /**
     8 N1 k+ |; r- j- O4 i
181.   * @brief  OLED次方函数
     
182.   * @retval 返回值等于X的Y次方
     & k+ H) |. y! R+ B5 _. x
183.   */
     
184. uint32_t OLED_Pow(uint32_t X, uint32_t Y)
     : T. T" [  `  N! Z2 P' `& Q
185. {
     
186.   uint32_t Result = 1;
     
187.   while (Y--)
     1 z! ]/ ^# _+ b- t' B
188.   {
     ) r7 r, Q8 [) j# b. k1 j" F% H2 b, o
189.     Result *= X;
     
190.   }
     7 u% ^% X( o# }2 E0 {  D; f
191.   return Result;
     
192. }
     
193. 
     6 w( t* i$ D2 D9 d* z! z& `
194. /**
     " d5 k3 x# k. z+ b, G; k
195.   * @brief  OLED显示数字（十进制，正数）
     
196.   * @param  Line 起始行位置，范围：1~4
     ! g4 d2 q. m7 F1 I4 {7 n/ \2 z$ X
197.   * @param  Column 起始列位置，范围：1~16
     
198.   * @param  Number 要显示的数字，范围：0~4294967295
     & j0 O! q9 b  k  Z8 T* i9 }2 c; B+ p
199.   * @param  Length 要显示数字的长度，范围：1~10
     
200.   * @retval 无
     
201.   */
     
202. void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
     7 z4 a" Q+ o% k& @) B$ L5 n
203. {
     
204.   uint8_t i;
     / {" X7 B5 l  ?+ \3 d4 q
205.   for (i = 0; i < Length; i++)              
     
206.   {
     6 i0 g/ r6 o+ C/ g# X' j
207.     OLED_ShowChar(Line, Column + i, Number / OLED_Pow(10, Length - i - 1) % 10 + '0');
     - X& ^' M+ l' P  A" ^  G& w
208.   }
     : [7 D( v( S: d" |" C& p& p, Q/ O
209. }
     5 i% |' y" A5 Y/ g
210. 
     
211. /**
     8 l# p8 j& ?* D+ `
212.   * @brief  OLED显示数字（十进制，带符号数）
     3 \4 M6 j9 B% `
213.   * @param  Line 起始行位置，范围：1~4
     ) O, t3 ^1 e* n4 `( h; W* Q
214.   * @param  Column 起始列位置，范围：1~16
     8 N+ G5 n8 R' C; Q4 u% d0 F& V8 u
215.   * @param  Number 要显示的数字，范围：-2147483648~2147483647
     ( S$ w' L1 y  m4 P2 J
216.   * @param  Length 要显示数字的长度，范围：1~10
     % ?2 y2 e( [' r5 g1 E, q* f
217.   * @retval 无
     
218.   */
     0 S7 {2 y' R! o1 ^- z7 ?. H, K
219. void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length)
     
220. {
     , I8 A1 Z, r4 N! R. M- M* b
221.   uint8_t i;
     
222.   uint32_t Number1;
     2 B* q; y3 \& N
223.   if (Number >= 0)
     
224.   {
     + ?& Q. L( K8 @0 N1 p
225.     OLED_ShowChar(Line, Column, '+');
     . n4 P" C/ w( b
226.     Number1 = Number;
     7 A+ y8 c4 D# [3 O, ^. g9 s; m
227.   }
     ! R. B/ `- |5 X& O/ Q2 c  L
228.   else
     & U1 J8 T/ ?  z% S  e; c* L+ J/ T
229.   {
     $ Y6 ?$ n1 u  e7 \
230.     OLED_ShowChar(Line, Column, '-');
     " o& M/ [  M# N; b4 ^8 C! w- h7 ]: u
231.     Number1 = -Number;
     
232.   }
     1 c$ Q! L2 O* H' d  B) h+ J- s
233.   for (i = 0; i < Length; i++)              
     * ]; V6 ^8 `9 \* |# l7 j( k7 j1 j
234.   {
     7 }% A/ [1 J/ ^7 b
235.     OLED_ShowChar(Line, Column + i + 1, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0');
     
236.   }
     % S. e+ s1 T* M- K7 v4 I7 ]$ J$ h
237. }
     
238. 
     
239. /**
     * \$ w8 a3 E  N6 {! ^0 i9 H0 ]$ z
240.   * @brief  OLED显示数字（十六进制，正数）
     / ]* l/ t& q- w+ N
241.   * @param  Line 起始行位置，范围：1~4
     
242.   * @param  Column 起始列位置，范围：1~16
       I( m/ S& Q5 J* I
243.   * @param  Number 要显示的数字，范围：0~0xFFFFFFFF
     
244.   * @param  Length 要显示数字的长度，范围：1~8
     
245.   * @retval 无
     
246.   */
     
247. void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
     
248. {
     : j- J* U7 o! D2 G2 {" Y' d+ ]* d( M1 |
249.   uint8_t i, SingleNumber;
     ; M0 p/ U0 ?7 F
250.   for (i = 0; i < Length; i++)              
     
251.   {
     
252.     SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;
     8 `% G2 x6 J  z. B5 u
253.     if (SingleNumber < 10)
     
254.     {
     
255.       OLED_ShowChar(Line, Column + i, SingleNumber + '0');
     ' ~# Y( ^5 Q: N  K
256.     }
     
257.     else
     & |) J3 F3 ?  V6 M) z  A
258.     {
     
259.       OLED_ShowChar(Line, Column + i, SingleNumber - 10 + 'A');
     8 F8 B4 e( V( Y* F2 N  {! s
260.     }
     $ q3 A% ]/ e2 U0 J( I7 Z! \
261.   }
     # N7 o% u# O. E+ x
262. }
     5 D2 q' y  G; t. l7 J
263. 
     
264. /**
     
265.   * @brief  OLED显示数字（二进制，正数）
     : t7 s  `5 N# Y3 p
266.   * @param  Line 起始行位置，范围：1~4
     & ]( t0 k1 R5 S8 G  r% e; l
267.   * @param  Column 起始列位置，范围：1~16
     6 s# v/ {8 K" A* n" f
268.   * @param  Number 要显示的数字，范围：0~1111 1111 1111 1111
     
269.   * @param  Length 要显示数字的长度，范围：1~16
     + }1 |( t# O( V% w& S" m7 u
270.   * @retval 无
     
271.   */
     9 P+ i6 A, L) G! c
272. void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
     
273. {
     
274.   uint8_t i;
     
275.   for (i = 0; i < Length; i++)              
     
276.   {
     
277.     OLED_ShowChar(Line, Column + i, Number / OLED_Pow(2, Length - i - 1) % 2 + '0');
     
278.   }
     
279. }
     ) o/ Z3 l! d& O. N
280. 
     
281. /**
     . w* w& Q+ O- U, E! Q. G; ]& ?2 j4 p
282.   * @brief  OLED初始化
     
283.   * @param  无
     
284.   * @retval 无
     * S& H. a: ?7 z, d, w$ d
285.   */
     
286. void OLED_Init(void)
     ' d$ |0 Z! Y6 F
287. {
     
288.   uint32_t i, j;
     
289.   
     
290.   for (i = 0; i < 1000; i++)      //上电延时
     
291.   {
     
292.     for (j = 0; j < 1000; j++);
     
293.   }
     
294.   
     
295.   OLED_I2C_Init();      //端口初始化
     & n" W' \9 Q. T+ \1 n
296.   
     6 X6 K: a) t0 u3 I: l# Y
297.   OLED_WriteCommand(0xAE);  //关闭显示
     
298.   
     
299.   OLED_WriteCommand(0xD5);  //设置显示时钟分频比/振荡器频率
     
300.   OLED_WriteCommand(0x80);
     
301.   
     1 Z' T4 W: \8 C' x# h
302.   OLED_WriteCommand(0xA8);  //设置多路复用率
     ; x- O4 ?4 r" I! O
303.   OLED_WriteCommand(0x3F);
     0 M8 M! [: o& W: z$ x
304.   
     
305.   OLED_WriteCommand(0xD3);  //设置显示偏移
     
306.   OLED_WriteCommand(0x00);
     + p, c- Q) K- N. G2 V
307.   
       l/ d$ p% z) o6 r! U
308.   OLED_WriteCommand(0x40);  //设置显示开始行
     
309.   
     - a0 H# U2 L2 S
310.   OLED_WriteCommand(0xA1);  //设置左右方向，0xA1正常 0xA0左右反置
     ' Q# _) I6 C  q( }. i. q
311.   
     
312.   OLED_WriteCommand(0xC8);  //设置上下方向，0xC8正常 0xC0上下反置
       ?" A. i3 {, w4 E2 R% _
313. 
     
314.   OLED_WriteCommand(0xDA);  //设置COM引脚硬件配置
     2 ]8 x% J8 B1 `: p
315.   OLED_WriteCommand(0x12);
     9 o. B: \1 t: C  Q4 v0 B
316.   
     
317.   OLED_WriteCommand(0x81);  //设置对比度控制
     0 h( ?0 O7 p- d" v
318.   OLED_WriteCommand(0xCF);
     - n3 [' `7 @1 e4 b: G- Q9 \* ]
319. 
     
320.   OLED_WriteCommand(0xD9);  //设置预充电周期
     
321.   OLED_WriteCommand(0xF1);
     + n7 G7 G1 p: H* y6 |
322. 
     ! I/ M; o3 r, X& @5 s6 g* S
323.   OLED_WriteCommand(0xDB);  //设置VCOMH取消选择级别
     ! n; q: N3 `4 l  x3 R5 Y% b+ q6 f
324.   OLED_WriteCommand(0x30);
     
325. 
     
326.   OLED_WriteCommand(0xA4);  //设置整个显示打开/关闭
     * b9 w- y* t5 ~6 H
327. 
     
328.   OLED_WriteCommand(0xA6);  //设置正常/倒转显示
     5 z+ [0 `% v( E
329. 
     $ R" E$ z5 T  m
330.   OLED_WriteCommand(0x8D);  //设置充电泵
     
331.   OLED_WriteCommand(0x14);
     8 ]7 \) W+ j; ?8 w) ~! A
332. 
     / P$ f8 n- o; n, D/ D' f1 y5 y
333.   OLED_WriteCommand(0xAF);  //开启显示
     ' W. ]9 S3 j( X6 K. p% n% J; o& F* L
334.    
     + G4 L# J( a- e( g$ g: K+ Q
335.   OLED_Clear();        //OLED清屏
     4 ]% b# {% Q7 b2 I1 i
336. }
     4 [- m8 r3 I4 g% R

复制代码

2 Z: k! `. @1 V$ _  Z) z

转载自：zeruns

8 z7 B/ i& G  d