第十、COMP 实验
8 h1 h6 Y/ Y: Q9 q实验目的：掌握和熟悉 G474 内部的模拟比较器用法，包括触发方式以及与内部 DAC 级联使用等。
4 v2 b4 b# [9 Q, v
1、软件读取 COMP 结果实验
CubeMX 配置如下，保存后生成对应的配置代码：


▲ CubeMX 进行 COMP 配置
本实验使用软件读取 COMP 比较结果，不需要配置触发，为了使比较结果更加直观，开启外部比较结果输出。

( S2 j! @3 D$ U) x; \; l+ |
相关操作函数说明：
3 T8 e0 y$ [- i+ ]! `' S( y- QHAL_StatusTypeDef HAL_COMP_Start(COMP_HandleTypeDef *hcomp)
功能：开启比较器；
! A/ z( r! D3 }: `5 Y. `参数 1：比较器句柄，根据需要填写；
返回：操作结果，HAL_OK 或 HAL_ERROR；
+ Q6 c; J; r2 F* K8 |* f! P/ i示例：HAL_COMP_Start(&hcomp3);// 开启 COMP3HAL_StatusTypeDef HAL_COMP_Stop(COMP_HandleTypeDef *hcomp)
功能：关闭比较器；
参数 1：比较器句柄，根据需要填写；
4 x  q+ c8 ^+ ~+ E. F' i; d2 V4 T9 z返回：操作结果，HAL_OK 或 HAL_ERROR；
uint32_t HAL_COMP_GetOutputLevel(const COMP_HandleTypeDef *hcomp)
功能：读取比较器输出电平；
参数 1：比较器句柄，根据需要填写；
5 @* M) n/ p6 I返回：比较结果，COMP_OUTPUT_LEVEL_LOW 或 COMP_OUTPUT_LEVEL_HIGH；
示例：result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果

. l0 \7 O6 E+ E: d. \! Z: m6 Z) \' F
核心代码：
if(HAL_COMP_Start(&hcomp3) != HAL_OK)
5 [5 ?' P8 \: h+ u, f: \" n1 e" Y//开启比较器
- d' {5 I1 {0 {- d7 C+ P7 s& C9 \{
. H7 n. o% T! d4 _$ j7 S1 uError_Handler();
}
while (1)
{
result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
if(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
9 ?& a7 f5 i  k& t5 ?8 U{
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
}
4 u: D3 Z0 t+ j6 J" B" c( |HAL_Delay(100);
}


以上为 main 函数中外设初始化结束后的部分首先开启比较器，然后在主循环中每 100ms读取一次比较结果，如果结果为 1，即正相输入大于反相输入，则进行 LED2 翻转。

. a3 D7 O, n, b
, H6 X) Q, x7 w5 u9 @/ S, C; n实验现象：
# u$ J. q3 h: U  {4 D. W下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。
/ V  K- T  h& O# h5 T. v, a
2、中断读取 COMP 结果实验
CubeMX 配置如下，保存后生成对应的配置代码：
# ^; {9 J2 w" Z
7 z: r' f( d+ I1 ]- L# G: L
▲ CubeMX 进行 COMP 配置
8 o' k/ n2 w. h) I3 b
9 y: D& l1 y9 `' e  N
本实验使用中断读取 COMP 比较结果，在比较结果变化的上升沿和下降沿都触发中断，为了使比较结果更加直观，开启外部比较结果输出。
2 T) G  f1 _5 }: V" F4 X; X8 n

' n: Z8 {6 F  [3 p7 q2 z  O5 S核心代码：
* _, g* y$ }; M& R& \6 Mif(HAL_COMP_Start(&hcomp3) != HAL_OK)
% H% Y$ {' u6 J' P$ u" P, b# g7 P//开启比较器
{
Error_Handler();
8 `7 {  ^# J1 A1 D- E}
& }9 o& o2 g- k  h+ k
6 C% u) s  a. C7 P
1 f4 ~$ H/ [" w0 x9 n, G: s以上为 main 函数中外设初始化结束后的部分，这里只需要开启比较器即可，使用函数与上例相同。


void HAL_COMP_TriggerCallback(COMP_HandleTypeDef* hcomp)
{
  r) p) K7 Q) p  x$ D; B; Rif(hcomp->Instance==COMP3)
{
6 V* y6 H  ~7 i' ?. Nuint8_t temp;
! Z3 a- r% p1 ^  e# Qtemp = HAL_COMP_GetOutputLevel(&hcomp3);//读取比较结果
+ Y4 S% ~8 h: ^if(temp == COMP_OUTPUT_LEVEL_HIGH)//结果为 1，上升沿触发
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_10,GPIO_PIN_RESET);//点亮
LED1
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_11,GPIO_PIN_SET);//熄灭
LED2
! W1 q2 f9 Q7 j1 P# i" m}
. m+ g2 M% j- T( X4 \: Belse
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_10,GPIO_PIN_SET);//熄灭 LED1
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_11,GPIO_PIN_RESET);//点亮
LED2
}
) v# \# ?3 u' E8 r- p: v}
0 [( r* _/ c5 s, E% l3 Q}


5 M/ J7 B. x8 I7 ]以上为 COMP 触发中断回调函数，该回调函数为比较器共用，需要判断中断源，如果开启了多个边沿，还需要判断具体边沿。实质上，COMP 中断触发与 EXTI 类似，实际就是将COMP 比较输出作为一个 IO 映射到 EXTI 进行中断。

/ z/ W; z8 h! K0 w" D! B9 r
实验现象：
, i' r) F; {& o5 u0 Q& Y1 ^3 {下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED1 灭，LED2 亮，CMP 灭时，LED1 亮，LED2 灭。
9 d: U+ K4 [* [' V, U) \) O
3 N3 J$ W5 E' Q, [3 n
3、内部 DAC 级联比较实验
) e+ P; x7 B7 ^) m) c1 HCubeMX 配置如下，保存后生成对应的配置代码：
  I% j7 _1 Y7 t" w+ Y* F  p& D: [0 W

▲ CubeMX 进行 COMP 配置


6 F  E) `" p& N! w▲ CubeMX 进行 DAC 配置
' F" m) \- r0 s% p4 Q  I& [) Q
/ R5 p$ @' y$ d9 d3 }
本实验使用软件读取 COMP 比较结果，正相输入为光敏电阻，反相输入使用 DAC3 的 OUT1作为比较电压，为了使比较结果更加直观，开启外部比较结果输出。

; [1 L" ^: S$ N) v$ p' z
核心代码：
void DAC3_CH1_Set_Vol(uint16_t vol)
{
double temp=vol;
' `" w8 `, V- D1 F% Q, Atemp/=1000;
0 @+ Y+ i7 F# `& J1 {% ptemp=temp*4096/3.3;
2 b2 R! B- [/ H. K  U8 X# OHAL_DAC_SetValue(&hdac3,DAC_CHANNEL_1,DAC_ALIGN_12B_R,temp);//12 位右对齐数据格式设置 DAC 值
}


2 a( _) a9 ]2 w以上为 DAC 设置函数，通过该函数可以将输入的电压快速转换为 DAC 所需的寄存器数据。

- Q2 C" J8 u! F( Y
! w1 k5 T# B' E. p8 UDAC3_CH1_Set_Vol(500);//DAC 输出设置为 500mv
7 k# Q% {6 U6 ]% XHAL_DAC_Start(&hdac3,DAC_CHANNEL_1);//生效 DAC 输出
if(HAL_COMP_Start(&hcomp3) != HAL_OK)
) s' p- [; W0 V7 `3 u5 E//开启比较器
% P5 l# L" i( O8 g{
" w' r4 w4 D3 IError_Handler();
}
while (1)
{
) {  c) `2 }+ n% e9 q; ~5 _result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
if(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
{
3 N% a" {. b) S( n: ]4 DHAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
}
0 W3 M6 m$ M: p  ?8 D$ o2 e2 `HAL_Delay(100);
7 R: Z5 q, d9 h# v( S}
以上为 main 函数中外设初始化结束后的部分，首先设置好 DAC 输出电压，开启 DAC，然后开启比较器，最后在主循环中每 100ms 读取一次比较结果，如果结果为 1，即正相输入大于反相输入，则进行 LED2 翻转。

* m* }& K' x; D2 L/ B' G: I* C
实验现象：
+ n- \# g) k* j- F, d; X) v下载烧录后可以观察到遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。
% K$ E2 |: Q% L3 ]' q( D+ Z
# ^- I! I+ q. A3 _4 B# z2 J. y
第十一、FLASH 实验
: x$ f# h! R# w实验目的：掌握和熟悉 G474 内部的 FLASH 用法，包括 FLASH 读写应用等。FLASH 读取无需进行配置。
% h4 l* t/ [: u$ W! W
  p* j; Q1 d# {* `
核心代码：
/* 函数名：FLASH_Write
* 描述 ：flash 写入数据
* 输入 ：data 写入数据地址 addr flash 地址 size 写入字节数
  D8 y. e+ ?" k- A* 输出 ：无
* 调用 ：FLASH_Write(data,FLASH_PAGE_127,8);//8 字节
*/
uint8_t FLASH_Write(uint8_t* data,uint32_t addr,uint16_t SIZE)
" T3 L: N# A7 h6 K6 t$ J6 C{
$ n+ t0 ?; E2 N: bFLASH_EraseInitTypeDef EraseInitStruct;//定义擦写操作结构体
uint32_t SECTORError = 0;
uint64_t write_buff[10];//写入缓冲数组
( Z9 O+ ?5 J: E+ E' [6 `" Quint8_t i = 0;
uint8_t size = SIZE/8;//8 字节写入次数
memcpy(write_buff,data,SIZE);//将输入的数组移动到写入缓冲区
; `  w% ]8 f5 _2 ^0 FHAL_FLASH_Unlock();//解锁
7 X0 V  I8 Q; z8 _EraseInitStruct.Banks = FLASH_BANK_1; //存储区 1
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;//页擦除
; I8 ~9 n; H  v# y4 U8 w0 W. M$ wEraseInitStruct.Page = (addr-0x08000000)/FLASH_PAGE_SIZE;//擦除页
4 |/ q& A( c, C0 H  kEraseInitStruct.NbPages = 1;//擦除页数
if(HAL_FLASHEx_Erase(&EraseInitStruct,&SECTORError) != HAL_OK) //擦除页
# r  f. q8 {. Y% z2 [{
return 1;//擦除失败
  Q7 V$ a: m  }3 J$ `}
while(size)
{
; `) {- C$ ?9 H% C0 Z% Q0 J+ n1 Pif(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD,addr,write_buff)!= HAL_OK)//双字写入
{
return 2;//写入失败
' F& J; d6 }0 X6 c}
addr = addr+8;
i++;
8 O% q% r" [4 M( b& @6 w! d1 H+ t, Rsize--;
}
HAL_FLASH_Lock(); //锁定 FLASH
/ Y) j. {* k) [return 0;
}
, L$ E2 Z8 p" \/* 函数名：FLASH_Read
* 描述 ：flash 读取数据
; K2 h2 [) v% F1 ~* 输入 ：data 读取数据地址 addr flash 地址 size 读取字节数
* 输出 ：无
+ g! K4 w8 N6 A0 X* 调用 ：FLASH_Read(data,FLASH_PAGE_127,8);//8 字节
*/
uint8_t FLASH_Read(uint8_t* data,uint32_t addr,uint16_t SIZE)
3 M7 t( ^  ]8 {) F  ^{
uint32_t read_buff[10]; //接收缓冲数组
/ l: r% {$ i5 j8 J9 Cuint8_t i = 0;
2 m! e1 s3 }# tuint16_t size = SIZE/4; //接收次数
while(size)
& p: m6 R& j, o1 Q( W{
read_buff = *(__IO uint32_t*)addr; //从 FLASH 读取数据到接收缓冲数组
  @! z2 f: z  aaddr = addr+4;
# g. [' b6 t5 o" Ci++;
size--;
# w& |0 _3 g. ^2 @# w}
memcpy(data,read_buff,SIZE); //将数据从接收缓冲数组转移到接收数组
return 0;
  p$ T& H' q& W- ]% ^2 w2 ~8 ~}
* J1 ~# F' ?3 i: L4 T, m
* Z, F, C0 M2 o: P1 G  ^: m
主要代码：
uint8_t data[8]={0,0,0,0,0,0,0,0};
, h3 g1 C& r. \3 Kchar buf[30]="";
% |  n8 p7 A; t# L/ iFLASH_Read(data,FLASH_PAGE_127,8);//8 字节
% k8 Q. G4 D  [data[0]++;FLASH_Write(data,FLASH_PAGE_127,8);//8 字节
snprintf(buf,10,"times:%d",data[0]);
LCD_PutString(10,30,buf,Red,White,0);
uint32_t UID1=READ_REG(*((uint32_t *)UID_BASE));
uint32_t UID2=READ_REG(*((uint32_t *)(UID_BASE+4U)));
' _7 P. z2 W) w7 S! E" s- ~uint32_t UID3=READ_REG(*((uint32_t *)(UID_BASE+8U)));
snprintf(buf,30,"UID:%0x-%0x-%0x",UID1,UID2,UID3);
LCD_PutString(10,60,buf,Red,White,0);
- i1 B7 [& _% Y- `. \( h: \# V
* s7 }6 z6 y2 |& t
& j' e/ Q) e+ U& @实验现象：
下载烧录后可以观察到 LCD 显示 FLASH 测试次数以及芯片的 ID。


: E" y9 g7 |% O▲ 实验现象
" m: z/ M% Z# ^3 l, X

第十二、单总线实验
0 [4 I# l7 l! Y/ _1 g实验目的：掌握和熟悉常用的单总线通信，包括 DS18B20，DHT11 读写应用。
3 g+ M2 V4 Z' `. D8 J  S8 {CubeMX 配置如下，保存后生成对应的配置代码：


▲ 图 3.12.1 CubeMX 进行 GPIO 输出配置

* m/ I4 r1 b' o0 w" T+ j
4 L& N4 O8 O, m# z本实验进行单总线读取 DS18B20 和 DHT11。使用 CUBEMX 配置 IO 为输出模式。
" [2 I0 ]9 e! Q0 P* D
7 \% C  R0 [! A' b& ]  l# Z" z
读取 DS18B20 核心代码：
9 N/ @; @# J6 u/* 函数名：DS18B20_IO_OUT
9 N% X$ a# ^, O% q' e* 功能：初始化 DS18B20 的 GPIO 为输出模式
* 输入：无
* 输出：无
# O8 J( ]% |+ K7 B, |* 备注：无
*/
3 N- L  F# B8 P+ i8 G. Nvoid DS18B20_IO_OUT(void )
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
: }4 H3 U3 {6 }5 S5 }' D) iGPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
}
/* 函数名：DS18B20_IO_OUT
* 功能：初始化 DS18B20 的 GPIO 为输入模式
* 输入：无
, |/ a3 L6 E$ p# ?* 输出：无
* 备注：无
! c( j8 _7 D( M  O*/void DS18B20_IO_IN(void )
' m9 Y* ]3 U4 {, n7 C& R{
GPIO_InitTypeDef GPIO_InitStruct = {0};
& a% ]3 E4 j1 ?$ c! L' UGPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
9 Q: X* l: Y! U  ~: L% Q# O! H0 cGPIO_InitStruct.Pull = GPIO_NOPULL;
: l% g: A4 n& v  ~GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/ L* c) T6 }3 y/ v}
4 Q8 T& _6 Q/ p- U. p9 @) j0 T/* 函数名：DS18B20_Rst
( S6 W4 i' f+ }8 a* @: {% J8 k& ?* 功能：复位 DS18B20
* 输入：无
, h* R. c% n) }. }* 输出：无
* 备注：无
*/
% t1 a! g/ n9 ?! Z$ u  ovoid DS18B20_Rst(void)
; M- c* T) E2 B2 k{
DS18B20_IO_OUT(); //SET PG11 OUTPUT
7 }2 w7 n1 `4 i$ xDQ_OUT_LOW();
//拉低 DQ
# u$ p" F5 G% c& A3 Qdelay_us(750);
$ o- Y) |4 u; q) N& B//拉低 750us
0 ^$ D5 w, r6 |8 ?DQ_OUT_HIGH();
//DQ=1
delay_us(15);
//15US
}
/* 函数名：DS18B20_Check
3 _; h2 d4 C, w* m* 功能：等待 DS18B20 的回应
+ }, W* E& ^9 P$ M% t" w* 输入：无
* 输出：返回 1:未检测到 DS18B20 的存在 返回 0:存在
4 t) R, \; A( b- U( r3 h2 _* 备注：无
*/
8 Z. x2 y" e$ o* L+ q6 _6 i7 Euint8_t DS18B20_Check(void)
* r2 }+ B# s: b* V{
uint8_t retry=0;
DS18B20_IO_IN();
1 I6 w7 _0 _9 }3 |- ^//SET PG11 INPUT
while (DQ_GET_IN()&&retry<200)
1 k- L0 n7 z' ?7 Z& i, P{
! K7 W( B% U% B; z% Yretry++;delay_us(1);
% d  {4 C& t( z$ q1 a};
) j. [* G, A$ _+ B6 @if(retry>=200)return 1;
else retry=0;
$ j1 o8 }2 S) S. Z$ A9 P! {while (!DQ_GET_IN()&&retry<240)
0 k1 Y$ u; p4 B6 W+ Q. |. B{
retry++;
delay_us(1);
};
$ w' W% B+ @+ }2 u4 C- |if(retry>=240)return 1;
% G4 G- l  u) y0 e! ]* a& Jreturn 0;
" A0 \0 `: j% C' R( o, k}
/ u% K" \. h$ y- T$ O5 p- y+ S) G/* 函数名：DS18B20_Read_Bit
# q* e0 P0 z, w, @* 功能：从 DS18B20 读取一个位
* 输入：无
6 {, L0 W6 }$ i2 J" j* 输出：返回值：1/0
* P) V% x: P" e* W5 t* 备注：无
*/
6 b" e2 g3 X. |4 q8 ~+ T6 F9 Y* z& ]9 Wuint8_t DS18B20_Read_Bit(void)
% G; c% A$ K' l/ N{
+ z$ f! D2 t# w' N- _' Duint8_t data;
6 O' Q8 b" q4 F/ [9 sDS18B20_IO_OUT(); //SET PG11 OUTPUT
DQ_OUT_LOW();delay_us(2);
DQ_OUT_HIGH();
- e2 ?; o9 P7 ^: @DS18B20_IO_IN();
//SET PG11 INPUT
delay_us(12);
0 M7 |3 l1 U5 i" {2 y3 Uif(DQ_GET_IN())data=1;
else data=0;
delay_us(50);
# g- i6 w. b1 C; ~return data;
}
/* 函数名：DS18B20_Read_Byte
* 功能：从 DS18B20 读取一个字节
* 输入：无
& a3 N" `3 J9 [0 d& ^: s* 输出：返回值：读到的数据
* 备注：无
*/
uint8_t DS18B20_Read_Byte(void)
{
uint8_t i,j,dat;
dat=0;
for (i=1;i<=8;i++)
{
# [9 C/ D$ |1 _( U7 Rj=DS18B20_Read_Bit();
dat=(j<<7)|(dat>>1);
5 l" D  R; x& V}
% D9 K' _7 ^5 Y8 B: V" Ereturn dat;
: L) P% c4 }' W  w2 e) n% [}
0 \) [6 t! E& ~* @; T# i5 Y/* 函数名：DS18B20_Write_Byte
* 功能：写一个字节到 DS18B20
' o! p9 t' W4 X! F* 输入：dat：要写入的字节
* 输出：无
* 备注：无
; _  o3 _0 \  L8 T  f- q*/
- A7 j+ t0 w6 y0 z# Y' kvoid DS18B20_Write_Byte(uint8_t dat)
{
4 i( d' [6 U7 n( Y0 S2 Guint8_t j;
uint8_t testb;
1 u( q. I( L2 WDS18B20_IO_OUT(); //SET PG11 OUTPUT;
- t$ Y& ]8 q$ Z8 ]" L6 K% y; a5 @/ P3 yfor (j=1;j<=8;j++)
' {  g) V7 w) x" y! c+ T& c2 u{
  L: E7 A. n$ v9 Rtestb=dat&0x01;
dat=dat>>1;
if (testb)
0 T0 U1 F# \- Z6 u: \2 V$ @5 g& I7 x4 b{
  V) y8 H4 n0 ~; pDQ_OUT_LOW(); // Write 1
delay_us(2);
DQ_OUT_HIGH();
delay_us(60);
8 s0 h/ \4 [( X3 M% t; O}
else
{
9 s, r4 g/ j7 p$ E; u* w: ]DQ_OUT_LOW(); // Write 0
delay_us(60);
3 \8 J- X+ ~( `! O/ \& zDQ_OUT_HIGH();
' N. ?% L1 n$ Cdelay_us(2);
1 q6 m* k" T& A}
}
}
8 y5 p/ D! A# K* B& E  E/* 函数名：DS18B20_Start
6 z1 l* S5 M6 M4 H* 功能：开始温度转换
- P! s& k# t& O: e* 输入：无
* 输出：无
" o( e( I# W+ S% T' b* 备注：无
*/
//
void DS18B20_Start(void)
{
, g, _8 S" V- X* U0 N7 l+ Z) n' [DS18B20_Rst();
DS18B20_Check();
+ i2 S8 c; m+ Q' g' oDS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0x44);// convert
}
/*
函数名：DS18B20_Start
6 L/ I! |4 P& O/ T; d" x8 b* 功能：从 ds18b20 得到温度值 精度：0.1C
* 输入：无
5 l0 ]9 Z: h" _+ t1 \; h0 L$ z* 输出：返回值：温度值 （-55.0~125.0）
: [6 J; Q0 _6 y* 备注：无
*/
short DS18B20_Get_Temp(void)
{
uint8_t temp;
, s. [3 T  |9 O4 }: [2 U2 ~uint8_t TL,TH;
short tem;DS18B20_Start ();
// ds1820 start convertDS18B20_Rst();
, v# z) F: I* q! dDS18B20_Check();
* D! R9 w$ K' \' SDS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0xbe);// convert
) f+ x' z5 u5 ~* Q, FTL=DS18B20_Read_Byte();
// LSB
TH=DS18B20_Read_Byte();
// MSB
if(TH>7)
{
9 K* H# Y) w/ Y7 p8 @TH=~TH;
5 O0 }$ y1 c5 R2 z* mTL=~TL;
% i: R7 ?+ p" w; a3 |temp=0;
! i9 R  T" q) k3 F& J" b) V, ^//温度为负
}else temp=1;
* g8 `0 |0 {; I5 V//温度为正
tem=TH;
5 \, \$ ]0 w- `( g//获得高八位
tem<<=8;tem+=TL;
3 v/ l3 ~) }5 F- a$ Z* h//获得底八位
tem=(float)tem*0.625;
/ _- N. {7 f3 E6 u//转换
! ]8 `! @  P% n0 A, s) Vchar buf[20]="";
if(temp)snprintf(buf,10,"Temp:%.1f",tem/10.0);
else snprintf(buf,10,"Temp:%.1f",tem/10.0);
LCD_PutString(10, 10, buf, White,Blue,1);
. E* v2 e5 S& b! y& B1 vif(temp)return tem;
0 S9 n0 q- |4 S0 A//返回温度值
else return -tem;
}
读取 DHT11 核心代码：
/* 函数名：delay_us
* 功能：微秒延时
* 输入：delay 延时多少微秒
2 q: t8 L8 j3 e. {$ U* 输出：无
* 备注：无
# @9 }' R* U; m) y( ?0 i6 a. j*/
#define CPU_FREQUENCY_MHZ 170
' r7 z: D; n2 h6 D// STM32 时钟主频
% h6 g8 a% L6 d) gvoid delay_us(__IO uint32_t delay)
{
: A7 v& K1 L0 ^: q: [int last, curr, val;
+ ?4 z! ^4 n/ v7 U( Jint temp;
9 ~) S: K- n# G* ]& hwhile (delay != 0)
{
4 ]* m! k4 I# E0 \temp = delay > 900 ? 900 : delay;
; q( L! ]+ H- Xlast = SysTick->VAL;
curr = last - CPU_FREQUENCY_MHZ * temp;
if (curr >= 0)
3 L& Y" }2 I$ g0 v" k, y2 B{
do
{
# K' J& i% n. d' x6 G6 I, Y( rval = SysTick->VAL;
}
# M1 ~. k* f% y) t* J7 Nwhile ((val < last) && (val >= curr));
}
else
+ r# e3 B" x. b& h! N{
curr += CPU_FREQUENCY_MHZ * 1000;
& Y- \7 T% h3 w: {- j) j& k- ^do
& ^4 |' G4 r9 P  U{
, d" n5 U# M% R/ i3 L0 Pval = SysTick->VAL;
$ z7 u8 O" T+ l& f& F* H; I}
while ((val <= last) || (val > curr));
}
delay -= temp;
}
; X1 ^+ Q' K! G# F9 d}
unsigned int rec_data[4];
8 V$ G& f3 I* w7 |  q) s8 a/* 函数名：DH11_GPIO_Init_OUT
* 功能：初始化 DHT11 的 GPIO 为输出模式
0 o+ b/ J; x) Z8 K0 z* 输入：无
, U' `3 W1 K0 @, @3 a, I* 输出：无
* 备注：无
*/
void DH11_GPIO_Init_OUT(void)
) z# I/ r' T- Q9 w{
GPIO_InitTypeDef GPIO_InitStruct = {0};
# W$ r; \" b9 d% y* `: rGPIO_InitStruct.Pin = GPIO_PIN_9;
1 }( n0 P- |( G4 |+ yGPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
1 {3 h6 [0 ?+ a+ U$ N. EGPIO_InitStruct.Pull = GPIO_NOPULL;
' |+ h: ?  v4 O" xGPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
1 |' p% T3 J& P' ?. G" m7 qHAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
& {( a4 o" z4 n* y3 i}

// 对于 M0 来说，是输入
/* 函数名：DH11_GPIO_Init_IN
6 ^% C3 R$ _% @8 c$ {$ P* 功能：初始化 DHT11 的 GPIO 为输入模式
4 n6 r2 M, n, E" y" u/ s* 输入：无
* 输出：无
7 I8 V- b7 f- |/ ]* R1 s7 T$ T- }3 Q* 备注：无
) U1 u7 d6 n, E! y5 Q*/
void DH11_GPIO_Init_IN(void)
( U" R0 f9 C$ F. r! `3 a; _! l{
: Q, _3 ]; W! i9 CGPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
& ^( s+ M  i3 PGPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
/ M- U, v; ^& T' B/ L  ?HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
  A8 j) R, O1 _' f// DL_GPIO_initDigitalInput(GPIO_DQ_dht11_and_ds18b20_IOMUX);//配置为上拉输入
/ E- h! m7 V7 n}
* \+ U! w4 ~- f$ D  L8 u// 主机发送开始信号
# z. g  |/ ]) n# p: _( l2 ]% U/* 函数名：DHT11_Start
) ]8 Q, Q  m/ `& L2 \. n* 功能：主机发送开始信号
% z( x9 a0 O; n* o* 输入：无
* 输出：无
9 \) v' T9 O- E# H4 Y3 u6 B2 R2 q+ Q* 备注：无
*/
! `4 [/ X' `$ u: I! K- I/ F; Cvoid DHT11_Start(void)
{
- M+ s9 j/ K" [" u. Z* gDH11_GPIO_Init_OUT(); // 输出模式
) c' T% v! }# _+ ldht11_high; // 先拉高
delay_us(30);
9 C* r/ w$ x: s( R- z8 E( z0 Vdht11_low; // 拉低电平至少 18ms
2 }/ H$ U! K) h: Y( Z2 t9 ]9 _HAL_Delay(20);
dht11_high; // 拉高电平 20~40us
DH11_GPIO_Init_IN(); // 输入模式
6 M6 G* p4 c' b# p5 ]delay_us(30);
}
& c# z  [( E5 J$ e5 u// 获取一个字节
/* 函数名：DHT11_Rec_Byte
* 功能：获取一个字节
* 输入：无
( i# t; b- Q! i& t' _0 i5 D# r* 输出：读取的字符
* 备注：无
*/
3 F5 R8 m  T. x/ v( l$ m$ T7 V+ Nchar DHT11_Rec_Byte(void)
{
unsigned char i = 0;
unsigned char data;
for (i = 0; i < 8; i++) // 1 个数据就是 1 个字节 byte，1 个字节 byte 有 8 位 bit
{
. S7 d- ^" x+ d! }  ~  e1 Vwhile (dht11_read == 0)
) J+ g% e5 @4 K;
* M  I3 ^2 I! I7 S! z" L2 w+ s// 从 1bit 开始，低电平变高电平，等待低电平结束
delay_us(30); // 延迟 30us 是为了区别数据 0 和数据 1，0 只有 26~28us
data <<= 1; // 左移
. f% V! w$ r1 z5 z: ?3 b# Nif (dht11_read == GPIO_PIN_SET) // 如果过了 30us 还是高电平的话就是数据 1
; Q, M2 Q" p2 y* T. V{
( M( |9 k$ x- g  `$ U) g, }  E* D; `data |= 1; // 数据+1
4 J8 G# T7 C/ [1 n* _2 V. \}
" \. n- w9 j: _9 w: |while (dht11_read == GPIO_PIN_SET)
; // 高电平变低电平，等待高电平结束
}
4 ~" t! @9 _. _& Q, C: Q& p+ Breturn data;
( o9 H9 |7 }' {9 J: }7 d}
  j! \7 w* L; h2 c5 X% U" w9 b2 M- \// 获取数据
/* 函数名：DHT11_REC_Data
3 m; `& k  O+ l* 功能：获取 DHT11 数据并打印
* 输入：无
* 输出：无
* 备注：无
0 J$ v' v" g6 }; F*/
void DHT11_REC_Data(void)
{
unsigned int R_H, R_L, T_H, T_L;
unsigned char RH, RL, TH, TL, CHECK;
' _4 V8 I  ]0 l  ]4 L! I3 DDHT11_Start(); // 主机发送信号
//dht11_high; // 拉高电平
) s  m, b5 T! s* h0 v. M) Uif (dht11_read == 0) // 判断 DHT11 是否响应
{
! H* E' N6 d7 wwhile (dht11_read == 0); // 低电平变高电平，等待低电平结束
while (dht11_read == GPIO_PIN_SET); // 高电平变低电平，等待高电平结束
R_H = DHT11_Rec_Byte();
R_L = DHT11_Rec_Byte();
T_H = DHT11_Rec_Byte();
T_L = DHT11_Rec_Byte();
2 a. X4 l$ F5 C6 q7 ^4 iCHECK = DHT11_Rec_Byte(); // 接收 5 个数据
//DH11_GPIO_Init_OUT();
+ }- |# v% o/ V. K+ k5 L5 v//dht11_low; // 当最后一 bit 数据传送完毕后，DHT11 拉低总线 50us
delay_us(55); // 这里延时 55us
- \5 ~8 s4 R2 ^* W0 B//dht11_high; // 随后总线由上拉电阻拉高进入空闲状态。
if (R_H + R_L + T_H + T_L == CHECK) // 和检验位对比，判断校验接收到的数据是否正确
; s; H/ Q6 d  |, I) Y8 ^{
RH = R_H;
% U2 j) |! ]% u  ]RL = R_L;
! m7 V% n) @# z* C6 KTH = T_H;
, q9 z+ G+ e, N+ }5 _TL = T_L;
}
! \" x: w, c+ y+ S" H8 q# @}
1 L( S& a, a5 z
+ d* x& w3 R. I+ |
- J6 t3 H$ C  I) f, p$ ], ]rec_data[0] = RH;
rec_data[1] = RL;
rec_data[2] = TH;
rec_data[3] = TL;
char buf[20]="";
. K9 {( e2 _9 c; ysnprintf(buf,10,"Temp:%d.%d",TH,TL);
LCD_PutString(10, 10, buf, White,Blue,1);
) c! D# T0 {- I9 \, ksnprintf(buf,10,"Hum:%d.%d",RH,RL);
LCD_PutString(10, 30, buf, White,Blue,1);}

& V& T. d9 Z+ B0 A7 X; U0 u5 g
主要代码：
while(1){
DHT11_REC_Data();//DHT11 读取
//DS18B20_Get_Temp();//18B20 读取
HAL_Delay(1000);
}
% H& X; r& H# X3 o/ F

8 l" B3 r& T; Z实验现象：
下载烧录后可以观察到 LCD 显示 DS18B20 测试的温度，或者 DHT11 测量的温度和湿度。

) G# k7 y& R  N8 I- B; w
% l8 {0 x' O2 l2 s▲ 图 3.12.2 实验现象

2 P2 U  F$ O% w. L" `第十三、独立看门狗
实验目的：掌握和熟悉独立看门狗用法，包括喂狗操作等。
4 M& C5 l7 }: g, D2 i1 d4 h& m
: e- t- |3 Z' ]CubeMX 配置如下，保存后生成对应的配置代码：
+ Y3 d$ g8 e" l
▲ 图 3.13.1 CubeMX 进行独立看门狗配置

本实验进行独立看门狗配置。使用 CUBEMX 配置 IO 为输出输入模式实现 LED 指示和按键读取，GPIO 配置参考上文。程序中使用按键喂狗，如果没在 1s 内喂狗，系统将会自动复位。
! Z* t1 Z: u4 T7 J& m- o: ~
( K- Q2 N. K9 f, ]" d; c主要代码：
while (1)
0 C  ?" l+ }& s9 Z{
$ Q% k% u$ k) n0 K7 H; W, Eif(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
' J6 D% s/ i4 l% o4 V. L: I{
HAL_Delay(5);
1 [/ z7 g* I- q# z; D1 C0 G, vif(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
  Y1 ~1 D6 {3 i2 [' {' X{
6 |3 [: h0 q4 @: O" JHAL_IWDG_Refresh(&hiwdg);
: w: Q  V' n) W" \' _HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_10);
+ V* {& g' F& G2 T$ y/ X: dwhile(!HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4));
) s3 b3 R$ ^& Y" T. O}
0 q8 s; d$ M$ l' ?; F) d}
/* USER CODE END WHILE */
  k; C- j; n7 l; V$ R/* USER CODE BEGIN 3 */
}
3 S! ?, Y" `8 W* x- ]. Z

1 H5 c0 Q& L9 r实验现象：
下载烧录后可以观察到如果在一定时间内进行喂狗操作，系统会复位，LCD 重新加载。

▲ 图 3.13.2 实验现象

5 d+ ~; D: D4 F- t9 D+ r9 \! W4 V
8 F6 u3 g1 P, x! c$ ~转载自： AI电堂
  u- H0 k2 l5 M) A如有侵权请联系删除
0 L5 g6 m# ^0 X. T, Z3 k+ N
4 s- {" k+ X' U0 ^- D$ f% u

% g4 Y# V& `. j. b4 x
8 e6 N8 y: P2 S4 ?4 b