第十、COMP 实验
实验目的：掌握和熟悉 G474 内部的模拟比较器用法，包括触发方式以及与内部 DAC 级联使用等。
* [3 w! V+ T: J
' ?; m3 l- ^& E$ @9 y# m- n) t% A1、软件读取 COMP 结果实验
- ?& k$ i; X6 g" m/ W8 \" k! G+ wCubeMX 配置如下，保存后生成对应的配置代码：
3 U) a" v5 W6 f6 Q, X( r4 E2 f. r$ c
6 Y/ r) m* I* L$ J/ J: |
" N7 K* I. @0 d" A. w; [8 V( w▲ CubeMX 进行 COMP 配置
本实验使用软件读取 COMP 比较结果，不需要配置触发，为了使比较结果更加直观，开启外部比较结果输出。
2 D+ o7 U" H/ a  s$ H

相关操作函数说明：
HAL_StatusTypeDef HAL_COMP_Start(COMP_HandleTypeDef *hcomp)
功能：开启比较器；
参数 1：比较器句柄，根据需要填写；
返回：操作结果，HAL_OK 或 HAL_ERROR；
示例：HAL_COMP_Start(&hcomp3);// 开启 COMP3HAL_StatusTypeDef HAL_COMP_Stop(COMP_HandleTypeDef *hcomp)
功能：关闭比较器；
1 J( N' q. V* B0 l7 }. v3 W参数 1：比较器句柄，根据需要填写；
3 D  W  |5 K8 Q9 _9 i8 k. ?* I3 w返回：操作结果，HAL_OK 或 HAL_ERROR；
uint32_t HAL_COMP_GetOutputLevel(const COMP_HandleTypeDef *hcomp)
/ \8 i, m  M: m' g) N2 F$ Y* D0 L功能：读取比较器输出电平；
5 a8 J/ h! h( {+ c: W参数 1：比较器句柄，根据需要填写；
返回：比较结果，COMP_OUTPUT_LEVEL_LOW 或 COMP_OUTPUT_LEVEL_HIGH；
示例：result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果


/ [  k5 _2 ~; v核心代码：
& d7 s9 \. S4 D8 _: B) s8 h# zif(HAL_COMP_Start(&hcomp3) != HAL_OK)
8 m( D/ h, v0 v5 y//开启比较器
{
Error_Handler();
}
while (1)
7 U8 y3 o5 {' ~; U9 a{
- |$ e; `; q2 d! E! J3 }" E8 t* W+ D0 i; fresult = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
if(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
* n, H3 j2 D. }! O, p' `9 N{
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
; A+ j) W3 q; \4 Z* n' h6 _}
HAL_Delay(100);
}

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

' H$ C7 ], j, L: w- \; Y% s
# H/ c( o, h, W" ~! a% ~0 M, Q实验现象：
& c% U: p1 f) D下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。
" [7 |6 y) ^3 O
2、中断读取 COMP 结果实验
CubeMX 配置如下，保存后生成对应的配置代码：
- w# T' Q! g( P/ m2 s7 Z4 }
. [; Z/ T: y' H: k: @
▲ CubeMX 进行 COMP 配置


: W# e) G+ F" }- }本实验使用中断读取 COMP 比较结果，在比较结果变化的上升沿和下降沿都触发中断，为了使比较结果更加直观，开启外部比较结果输出。
* X" `3 H/ k/ c& Y9 ?2 ]% Y
% o- _, o/ e) f! L
核心代码：
# R0 M  D$ s: [" {" v2 I' x' `if(HAL_COMP_Start(&hcomp3) != HAL_OK)
+ h' y$ ]2 r6 D# ?1 L//开启比较器
{
Error_Handler();
4 S  C* C; R/ B}

3 r8 }" G( k% y& T! s+ i
* y% p1 |$ R+ L以上为 main 函数中外设初始化结束后的部分，这里只需要开启比较器即可，使用函数与上例相同。


void HAL_COMP_TriggerCallback(COMP_HandleTypeDef* hcomp)
( y6 M0 {- N, w/ w{
if(hcomp->Instance==COMP3)
& I& j0 [! _7 {- }3 n6 N& Z{
4 K& X* K4 J, W  c) a2 a8 }* Wuint8_t temp;
temp = HAL_COMP_GetOutputLevel(&hcomp3);//读取比较结果
  a; X( Q# @; \$ q9 mif(temp == COMP_OUTPUT_LEVEL_HIGH)//结果为 1，上升沿触发
, ]! E/ q" r7 a{
0 r+ v2 [+ P) ZHAL_GPIO_WritePin(GPIOD,GPIO_PIN_10,GPIO_PIN_RESET);//点亮
0 D6 p& ~: N: ]& S5 c: SLED1
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_11,GPIO_PIN_SET);//熄灭
" m- m3 z1 J7 c# v/ |# SLED2
}
else
{
  j; h+ @, A) Z" [4 B$ C, hHAL_GPIO_WritePin(GPIOD,GPIO_PIN_10,GPIO_PIN_SET);//熄灭 LED1
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_11,GPIO_PIN_RESET);//点亮
+ E) I, E1 F# jLED2
}
}
}
6 O$ q7 V/ |, ?0 F2 I$ c' h: N
  J' ~! f3 y1 d2 ?
以上为 COMP 触发中断回调函数，该回调函数为比较器共用，需要判断中断源，如果开启了多个边沿，还需要判断具体边沿。实质上，COMP 中断触发与 EXTI 类似，实际就是将COMP 比较输出作为一个 IO 映射到 EXTI 进行中断。
5 F5 G) G1 n8 N$ L) q9 e1 A
& j! o3 e  Q1 C( |
实验现象：
: v9 |# a& q( P5 U. s. b下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED1 灭，LED2 亮，CMP 灭时，LED1 亮，LED2 灭。
& Y6 k8 r0 m% x4 c. q3 f9 S+ p, \- ~+ C
# X0 G. [8 m( N* j* E
: c5 ]7 x8 O$ p5 k; s  x3、内部 DAC 级联比较实验
5 q9 w) F3 v) JCubeMX 配置如下，保存后生成对应的配置代码：

( h) G; Y% m' J$ c% U: p
' g$ V, R, A2 l5 l6 l) o▲ CubeMX 进行 COMP 配置

' [# b) \) E$ t' Y) h* m
; e4 U* J+ D- Y▲ CubeMX 进行 DAC 配置
/ ]5 [* Q% O, w1 f9 c( K4 y
+ }$ d$ U  T  y  A9 D& J
本实验使用软件读取 COMP 比较结果，正相输入为光敏电阻，反相输入使用 DAC3 的 OUT1作为比较电压，为了使比较结果更加直观，开启外部比较结果输出。

7 B8 P$ H, G9 O$ ~, d
: ^4 G6 |( T5 H8 Y) @3 a核心代码：
void DAC3_CH1_Set_Vol(uint16_t vol)
{
double temp=vol;
, G$ m4 ]$ [: l- S3 I; l% Stemp/=1000;
temp=temp*4096/3.3;
: K% O: z" i2 E- H+ K" ^  rHAL_DAC_SetValue(&hdac3,DAC_CHANNEL_1,DAC_ALIGN_12B_R,temp);//12 位右对齐数据格式设置 DAC 值
}
7 h9 c) J, H( c  M: e3 {/ R

以上为 DAC 设置函数，通过该函数可以将输入的电压快速转换为 DAC 所需的寄存器数据。

0 ?& O/ d- C# ?0 Y+ ?6 ^/ R1 m
# D! T5 k' J7 l4 O) U  R6 l3 bDAC3_CH1_Set_Vol(500);//DAC 输出设置为 500mv
- u% V# e% o9 [9 J* T4 K5 ?5 X1 ~HAL_DAC_Start(&hdac3,DAC_CHANNEL_1);//生效 DAC 输出
: C3 q1 Q: i) J* Kif(HAL_COMP_Start(&hcomp3) != HAL_OK)
//开启比较器
/ O6 ?) R# w9 q' t% P8 U6 [{
Error_Handler();
}
& r6 b2 a8 R8 \4 R2 W3 e6 Zwhile (1)
{
1 `" S7 Q- z0 dresult = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
if(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
{
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
}
HAL_Delay(100);
* i2 m4 j* z* k5 K  t/ X% Q9 C7 X}
以上为 main 函数中外设初始化结束后的部分，首先设置好 DAC 输出电压，开启 DAC，然后开启比较器，最后在主循环中每 100ms 读取一次比较结果，如果结果为 1，即正相输入大于反相输入，则进行 LED2 翻转。
; J: I1 F0 r* `& r9 N; Q/ h6 w0 p
& c4 R8 j1 p0 n$ F1 {8 d
4 U- a4 _+ B, x& ?1 X# N实验现象：
6 {' H$ z+ S( S" s# u( ~- [3 }下载烧录后可以观察到遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。

" M- c. L" v, Y& @
6 i7 B" F0 z6 }, X第十一、FLASH 实验
! f5 a' G  h  w+ J! U0 b6 R实验目的：掌握和熟悉 G474 内部的 FLASH 用法，包括 FLASH 读写应用等。FLASH 读取无需进行配置。
0 D" J4 u! s' D/ {; D

2 [+ Z6 `5 V8 l5 R8 T核心代码：
5 B5 k1 ~$ Y* g2 l$ g+ }/* 函数名：FLASH_Write
* 描述 ：flash 写入数据
+ F% }+ f% I: u# I9 F$ {$ k* 输入 ：data 写入数据地址 addr flash 地址 size 写入字节数
* 输出 ：无
, ]) w1 e9 O$ t  F# N* 调用 ：FLASH_Write(data,FLASH_PAGE_127,8);//8 字节
. H  F- x4 ?  g* P2 k. `- O*/
8 ]" J* A: y" d7 \( W. n7 Fuint8_t FLASH_Write(uint8_t* data,uint32_t addr,uint16_t SIZE)
3 e& |4 b2 k' e* R8 C{
FLASH_EraseInitTypeDef EraseInitStruct;//定义擦写操作结构体
uint32_t SECTORError = 0;
* r: x4 G2 B! D& s7 wuint64_t write_buff[10];//写入缓冲数组
uint8_t i = 0;
uint8_t size = SIZE/8;//8 字节写入次数
. S! g, j3 K$ hmemcpy(write_buff,data,SIZE);//将输入的数组移动到写入缓冲区
! N4 W7 q  ~4 [  `$ W7 ZHAL_FLASH_Unlock();//解锁
EraseInitStruct.Banks = FLASH_BANK_1; //存储区 1
( r2 t( L3 i1 }. Z2 `  @EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;//页擦除
( i' G, U% `+ @6 x( E' j: R/ ?EraseInitStruct.Page = (addr-0x08000000)/FLASH_PAGE_SIZE;//擦除页
EraseInitStruct.NbPages = 1;//擦除页数
if(HAL_FLASHEx_Erase(&EraseInitStruct,&SECTORError) != HAL_OK) //擦除页
{
return 1;//擦除失败
}
while(size)
# o) A! `- Q! |4 T' w9 D{
if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD,addr,write_buff)!= HAL_OK)//双字写入
0 }. Y! ^% K3 {+ |$ _{
; q! A  H: |% m1 i2 |return 2;//写入失败
; F( t" F3 v& X! \: ?2 I$ q5 u0 T}
addr = addr+8;
i++;
size--;
}
HAL_FLASH_Lock(); //锁定 FLASH
8 P  Y- s: \$ y! w& v& S6 y( Hreturn 0;
0 V6 ~9 \5 v/ @2 }( k}
/* 函数名：FLASH_Read
; P8 E7 z; |- `  Y, p- o+ t* 描述 ：flash 读取数据
* 输入 ：data 读取数据地址 addr flash 地址 size 读取字节数
* 输出 ：无
/ w; k* P4 @! T* 调用 ：FLASH_Read(data,FLASH_PAGE_127,8);//8 字节
*/
' w; h- j/ r0 ^5 h! u: Q! Xuint8_t FLASH_Read(uint8_t* data,uint32_t addr,uint16_t SIZE)
$ C& }7 B% X* Q2 I- z0 {% a9 Z{
uint32_t read_buff[10]; //接收缓冲数组
$ h/ D6 |* X: v& w' u" @uint8_t i = 0;
2 g. `7 ?3 g# u2 k' V% `uint16_t size = SIZE/4; //接收次数
$ y/ h/ q0 R* e' J- d" o. owhile(size)
{
read_buff = *(__IO uint32_t*)addr; //从 FLASH 读取数据到接收缓冲数组
addr = addr+4;
/ k6 g) d. R# b6 x4 [* {* Ui++;
size--;
}
) e/ P2 K) t3 E! u+ p4 Lmemcpy(data,read_buff,SIZE); //将数据从接收缓冲数组转移到接收数组
& b# T: B+ J% |return 0;
}


# B( ~5 e. s) H+ w- v7 Q) P3 D主要代码：
uint8_t data[8]={0,0,0,0,0,0,0,0};
" {+ \/ x( V  p& M2 K+ X' R# S: Xchar buf[30]="";
+ O) Z& p; H' VFLASH_Read(data,FLASH_PAGE_127,8);//8 字节
data[0]++;FLASH_Write(data,FLASH_PAGE_127,8);//8 字节
snprintf(buf,10,"times:%d",data[0]);
/ O7 z: b, K% Y! @. C3 ~' y& C' y0 ULCD_PutString(10,30,buf,Red,White,0);
uint32_t UID1=READ_REG(*((uint32_t *)UID_BASE));
, a9 B0 Q" l: Y6 w* C5 Puint32_t UID2=READ_REG(*((uint32_t *)(UID_BASE+4U)));
* \, e4 m. r/ E  m- y0 p. _uint32_t UID3=READ_REG(*((uint32_t *)(UID_BASE+8U)));
% D: {" Z& \& s$ \* F8 h8 J* Ksnprintf(buf,30,"UID:%0x-%0x-%0x",UID1,UID2,UID3);
LCD_PutString(10,60,buf,Red,White,0);
( t; @; D! |: I, C4 X# k. h
4 O' F3 _$ [5 Q
5 a7 W+ A; _1 t  g& h实验现象：
下载烧录后可以观察到 LCD 显示 FLASH 测试次数以及芯片的 ID。
$ Q% c( t, b7 i+ I, J9 ^0 j4 r3 t

* c! {1 N! n. h4 C' c▲ 实验现象
$ ]* `7 p% J1 T1 E( B

第十二、单总线实验
5 ~0 Y6 t1 }& u( ^实验目的：掌握和熟悉常用的单总线通信，包括 DS18B20，DHT11 读写应用。
CubeMX 配置如下，保存后生成对应的配置代码：


' ?. C$ n* z' y' H; r* e9 R▲ 图 3.12.1 CubeMX 进行 GPIO 输出配置


- a4 t4 C% Y4 m3 r7 J本实验进行单总线读取 DS18B20 和 DHT11。使用 CUBEMX 配置 IO 为输出模式。

8 z7 Y2 E/ `4 {4 ]+ o. \
/ P1 I+ k' @6 p" w读取 DS18B20 核心代码：
/* 函数名：DS18B20_IO_OUT
  u0 x+ q- @, Q! d8 D+ s' H4 l* 功能：初始化 DS18B20 的 GPIO 为输出模式
* 输入：无
* 输出：无
* 备注：无
*/
void DS18B20_IO_OUT(void )
! H8 }, s6 N5 p% ?( I{
% `2 L$ H0 F8 _3 }- Q9 {GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_9;
4 X8 N. P( d5 w& k, }+ IGPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
}
8 a5 @" x! x* Y7 o$ {3 w! W  E2 C# Y/* 函数名：DS18B20_IO_OUT
# d% Y8 X  Z; b! y; n* 功能：初始化 DS18B20 的 GPIO 为输入模式
8 r' \  `+ q( r+ ?% H* 输入：无
; T9 R; }7 {# R* 输出：无
* 备注：无
2 d8 I0 \6 l7 Q5 \, }- {- S2 S*/void DS18B20_IO_IN(void )
{
; z7 B" b% K; p, [1 }3 PGPIO_InitTypeDef GPIO_InitStruct = {0};
9 y7 r  t0 ^4 ^7 z, J) WGPIO_InitStruct.Pin = GPIO_PIN_9;
; S+ Z' e6 i- X. i9 eGPIO_InitStruct.Mode = GPIO_MODE_INPUT;
1 k* \1 g: D! L# o$ j1 q  p5 ^$ SGPIO_InitStruct.Pull = GPIO_NOPULL;
! z8 J& t: E+ R/ m* u$ w. KGPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
6 x2 L2 ]/ F; Q, c& s  N- \* q}
+ f1 x, G. }4 k. _" V6 {, W0 L/* 函数名：DS18B20_Rst
* 功能：复位 DS18B20
5 z; L5 a/ r, S6 v* 输入：无
& @( J; s2 j# X4 l6 _, P, |* C* 输出：无
# d6 ?$ W7 V/ h. |7 ^* 备注：无
*/
7 [6 I5 J/ D( T9 K4 ?; P; C( Mvoid DS18B20_Rst(void)
{
DS18B20_IO_OUT(); //SET PG11 OUTPUT
DQ_OUT_LOW();
# d5 \! e3 g! g0 U) S2 @9 [//拉低 DQ
delay_us(750);
//拉低 750us
0 N6 h- `" q2 O+ c7 ^DQ_OUT_HIGH();
//DQ=1
delay_us(15);
//15US
}
: j  E8 U' B6 V: Z/* 函数名：DS18B20_Check
7 N+ V" v" D; G1 s$ ^0 a  k* 功能：等待 DS18B20 的回应
* 输入：无
* 输出：返回 1:未检测到 DS18B20 的存在 返回 0:存在
- Z8 ]" X7 g7 G8 J9 k* 备注：无
*/
7 E! V4 a4 k' Y0 E) L( Iuint8_t DS18B20_Check(void)
( q0 _: {7 [' L. o) h. K/ B( i" |) i{
5 ]3 W4 n! |% R5 ?( W5 Suint8_t retry=0;
DS18B20_IO_IN();
) L& P4 E6 m0 ?* H//SET PG11 INPUT
; x; N  \' u1 Y8 C1 ]( e, y+ xwhile (DQ_GET_IN()&&retry<200)
{
retry++;delay_us(1);
  c  q' k1 e, T1 h7 f" Y};
, }$ n+ m1 ~/ O) \( x6 A2 Lif(retry>=200)return 1;
6 H0 F8 j* D" \1 Belse retry=0;
while (!DQ_GET_IN()&&retry<240)
% W6 N% \, n  {4 i% X  u! f{
, i$ e/ W8 _: l% t  D, ^. J$ Jretry++;
1 o1 [' S8 O) k) Hdelay_us(1);
+ ^7 l0 |8 G& a  Y};
- S5 v0 ^, K- S: {  }5 oif(retry>=240)return 1;
return 0;
4 V" y: i' ]) t+ p5 o. j% |}
/* 函数名：DS18B20_Read_Bit
* 功能：从 DS18B20 读取一个位
' |* M5 Z, t) a0 z* 输入：无
* 输出：返回值：1/0
* 备注：无
*/
' l& ~( @5 r) b* T2 U0 K  p* [3 Zuint8_t DS18B20_Read_Bit(void)
{
uint8_t data;
9 |0 P8 z0 m, k& S$ }DS18B20_IO_OUT(); //SET PG11 OUTPUT
* P1 I3 x; S& m; w" j! t0 kDQ_OUT_LOW();delay_us(2);
2 h! Q4 c% r3 V6 b* U+ H; LDQ_OUT_HIGH();
" S6 w* r. f! Q4 M5 lDS18B20_IO_IN();
% t2 f  ]% c. O9 z7 c+ j9 O//SET PG11 INPUT
delay_us(12);
if(DQ_GET_IN())data=1;
else data=0;
& a: }. O" r3 Q  ]9 c" Mdelay_us(50);
return data;
4 _4 b5 P9 \6 l) r}
/* 函数名：DS18B20_Read_Byte
8 [* |0 g& d* J" d; |* 功能：从 DS18B20 读取一个字节
; A5 h$ }. U: d# g* 输入：无
* 输出：返回值：读到的数据
; [$ n1 [3 Y$ K9 t7 C' B* 备注：无
*/
uint8_t DS18B20_Read_Byte(void)
{
uint8_t i,j,dat;
dat=0;
for (i=1;i<=8;i++)
{
: X' I4 T5 X9 j9 ^j=DS18B20_Read_Bit();
( y3 B# k( i; k3 {. s' ]4 Fdat=(j<<7)|(dat>>1);
4 z. [! x/ z4 v6 j+ B4 D# ^}
return dat;
}
$ u2 Q0 a3 S/ I# @! j6 o/* 函数名：DS18B20_Write_Byte
$ b9 i8 d# K, N4 l2 [* 功能：写一个字节到 DS18B20
* 输入：dat：要写入的字节
' Q) n( B# g% ?# N0 m5 b' {* 输出：无
& X) E, `6 q+ L. d* 备注：无
*/
$ K( H$ r. C- c8 {1 U9 Yvoid DS18B20_Write_Byte(uint8_t dat)
6 o% @2 u, B0 `9 `- E1 R5 b& V{
1 `; |0 z8 ?5 S8 M* G$ [, Zuint8_t j;
3 b! X& p$ d/ c1 R+ Y9 u0 \2 D4 cuint8_t testb;
DS18B20_IO_OUT(); //SET PG11 OUTPUT;
for (j=1;j<=8;j++)
/ ]# Y1 f$ W4 j{
testb=dat&0x01;
dat=dat>>1;
if (testb)
{
0 R/ a1 Q' c6 S% ~- cDQ_OUT_LOW(); // Write 1
9 x' y/ ]3 J2 a. K9 h( N7 F5 _delay_us(2);
( _; f; S$ W% H: q4 }DQ_OUT_HIGH();
& m- E9 m9 O2 e# I4 ^* tdelay_us(60);
}
else
{
DQ_OUT_LOW(); // Write 0
$ `2 }6 G% Y/ v' Tdelay_us(60);
0 R2 Y( X3 p! a) `' M+ @  h& nDQ_OUT_HIGH();
+ Q( ?1 ]- Z' r! edelay_us(2);
& S" b/ n1 U6 O0 z* N; N}
% {6 K  T  e: X. ]/ N2 p}
; }. Z" e2 X. i; G. p$ k1 C}
5 m2 A/ V8 f: Z( L/* 函数名：DS18B20_Start
7 b% b! B3 ?* e, K$ S* 功能：开始温度转换
* 输入：无
2 ~7 k9 ^! ?/ C# T8 `* 输出：无
( A7 @/ T) }4 i3 L- b* 备注：无
*/
, z* H# D: N* h7 T# i//
( H5 E# W, Y8 j/ V" T3 A4 ?# Tvoid DS18B20_Start(void)
) I! g2 k/ G( H2 h2 H; u{
DS18B20_Rst();
. h; n5 d9 H' t, p; iDS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0x44);// convert
8 `' @6 E4 ?+ k* {% i}
5 G% @: ~& L8 L! i1 E( T+ o/*
0 O% ~+ k  z$ r0 r  ^6 S1 r, v 函数名：DS18B20_Start
! M: a! `. b: I' C8 R1 R* 功能：从 ds18b20 得到温度值 精度：0.1C
1 J& f! p) x& ]" w; H% Y* 输入：无
- V- m) ~  }9 D; [, m* 输出：返回值：温度值 （-55.0~125.0）
6 k' N3 Y* |2 y0 b! P1 E8 I* 备注：无
' o% U% O% ]. n8 c3 x2 R6 m*/
; E+ h% n9 G9 Y: kshort DS18B20_Get_Temp(void)
{
  X. K( p2 [! H7 Z+ guint8_t temp;
uint8_t TL,TH;
short tem;DS18B20_Start ();
* O3 _' j( e7 U7 l  L4 g/ c// ds1820 start convertDS18B20_Rst();
' P* G% K$ s3 }/ k7 q$ ODS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0xbe);// convert
TL=DS18B20_Read_Byte();
// LSB
TH=DS18B20_Read_Byte();
// MSB
5 u. p% I& N. W) y- K  }if(TH>7)
* r  _/ B* |" J/ R{
TH=~TH;
; n3 q% S( u5 DTL=~TL;
temp=0;
//温度为负
}else temp=1;
//温度为正
9 T4 @5 O. ~+ ]% h% Atem=TH;
//获得高八位
! A6 c- H+ b6 W/ N, U; O, D1 _tem<<=8;tem+=TL;
//获得底八位
) y6 r; R0 ]/ C' Rtem=(float)tem*0.625;
//转换
char buf[20]="";
4 D4 Q, e$ B; z2 g& |9 Vif(temp)snprintf(buf,10,"Temp:%.1f",tem/10.0);
1 @* ^/ c. l* Q* {else snprintf(buf,10,"Temp:%.1f",tem/10.0);
LCD_PutString(10, 10, buf, White,Blue,1);
! l/ Y  Y3 j% z. S! zif(temp)return tem;
1 _1 m6 T6 N: c9 o6 x- M' p4 c//返回温度值
else return -tem;
1 F  f! a2 }. {& O, |: _ }
读取 DHT11 核心代码：
: W0 T- K7 Z: ]1 k/ x) N  w/* 函数名：delay_us
$ T1 R5 N6 l1 z! L! v7 L0 U+ B$ t* 功能：微秒延时
* 输入：delay 延时多少微秒
* 输出：无
* 备注：无
- w& E1 o  K7 @% X*/
& e7 v6 Z$ q2 k5 w( H9 i#define CPU_FREQUENCY_MHZ 170
# b0 F/ Q% T: u3 P// STM32 时钟主频
void delay_us(__IO uint32_t delay)
{
; `: I; y8 ~& W. ]int last, curr, val;
, d' T, I0 D! f' C4 z9 vint temp;
1 P7 n5 G' K1 |  ywhile (delay != 0)
0 i( m2 k' v+ o' ]: _9 X; K! P{
# Z' f& G9 q( H. ^2 W4 \temp = delay > 900 ? 900 : delay;
+ l& `) Z0 J+ ]7 z- _last = SysTick->VAL;
curr = last - CPU_FREQUENCY_MHZ * temp;
if (curr >= 0)
+ m7 }/ W8 y' M6 y{
( o4 U: Z+ ?9 A# X3 n* Qdo
9 e- g# L: ^% `0 T1 K7 }{
. B( u! _; i: W  P! Zval = SysTick->VAL;
}
while ((val < last) && (val >= curr));
1 @/ L4 r) f$ _5 B# ?}
" y( A4 {& T2 m' N; celse
4 _8 X" Y8 [! P! H. F- Z{
curr += CPU_FREQUENCY_MHZ * 1000;
do
, N0 M  w& V  t{
  ^6 r2 A5 _) e, {3 T. U; x2 y* r& I0 Qval = SysTick->VAL;
}
while ((val <= last) || (val > curr));
}
/ n- T7 `( A6 {8 g4 V0 y" Udelay -= temp;
, L% I8 A( u) t- U9 Q4 b}
}
: Y) G$ \, a4 k% x0 O" `unsigned int rec_data[4];
8 h0 L! g5 n! G% K5 Y) \, e/* 函数名：DH11_GPIO_Init_OUT
9 ^6 B0 R/ S! X$ h/ M* 功能：初始化 DHT11 的 GPIO 为输出模式
; ?* l! j& y  @6 t' a* 输入：无
2 x5 [' L: @1 }+ }# O" q* 输出：无
* 备注：无
*/
void DH11_GPIO_Init_OUT(void)
{
. u. z# m1 W+ Y7 MGPIO_InitTypeDef GPIO_InitStruct = {0};
0 n; b, b' h$ AGPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
# S7 e3 m/ ~, u8 r1 O' U, }; XHAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
; z8 h# y9 c. {}

0 P6 ^1 K  X, W' T6 Q// 对于 M0 来说，是输入
/* 函数名：DH11_GPIO_Init_IN
* 功能：初始化 DHT11 的 GPIO 为输入模式
- |' e# P6 ~. X$ x$ G; `. _* 输入：无
* 输出：无
* 备注：无
# m" H$ |; Q! ?1 b5 t) t/ y( c*/
void DH11_GPIO_Init_IN(void)
{
) k6 A7 ~( B# W2 r2 mGPIO_InitTypeDef GPIO_InitStruct = {0};
+ u6 S/ K/ L  g  {/ KGPIO_InitStruct.Pin = GPIO_PIN_9;
" v6 Q* Z' P+ E/ s% g9 xGPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
// DL_GPIO_initDigitalInput(GPIO_DQ_dht11_and_ds18b20_IOMUX);//配置为上拉输入
}
+ {, |0 Y+ h, h' V1 `* d/ C// 主机发送开始信号
/* 函数名：DHT11_Start
* 功能：主机发送开始信号
3 ~" b5 X6 g' ]  v! l( _* 输入：无
" y; n* N" x" x: V4 H* 输出：无
% i( c8 G( u; H9 S! T( @* 备注：无
' U% y1 R) J& y) E5 G8 L*/
void DHT11_Start(void)
{
  e; d# C/ o" n* W& v0 O  dDH11_GPIO_Init_OUT(); // 输出模式
dht11_high; // 先拉高
delay_us(30);
# Q0 f  \& b, l3 Gdht11_low; // 拉低电平至少 18ms
HAL_Delay(20);
& ?4 U( Z) |5 p( `dht11_high; // 拉高电平 20~40us
. u0 c5 T7 i: a$ qDH11_GPIO_Init_IN(); // 输入模式
delay_us(30);
" X$ B, w: _# k' K  ^2 G}
// 获取一个字节
/* 函数名：DHT11_Rec_Byte
  ^( d. b2 V8 i* 功能：获取一个字节
* 输入：无
  J5 D) Q3 ~$ q. u, W! ]1 J* 输出：读取的字符
: {0 N) k. F  B8 v* 备注：无
*/
char DHT11_Rec_Byte(void)
1 V: A' ~8 P8 v+ n! J{
- k8 [1 L4 `: l, w* L8 Cunsigned char i = 0;
unsigned char data;
6 O. d( C: @: ]4 Xfor (i = 0; i < 8; i++) // 1 个数据就是 1 个字节 byte，1 个字节 byte 有 8 位 bit
# y6 {# w( J: u$ V; `) {7 n. b{
while (dht11_read == 0)
;
8 q/ w) S- u: b! y" H/ a: q// 从 1bit 开始，低电平变高电平，等待低电平结束
. }4 w# Y' g' m% d  M7 Odelay_us(30); // 延迟 30us 是为了区别数据 0 和数据 1，0 只有 26~28us
data <<= 1; // 左移
if (dht11_read == GPIO_PIN_SET) // 如果过了 30us 还是高电平的话就是数据 1
{
, J# d# o* n& L1 G8 ^% g) Xdata |= 1; // 数据+1
/ k& O& l/ p$ c  G}
# Q' c+ c6 K% G3 t! z! ^while (dht11_read == GPIO_PIN_SET)
; // 高电平变低电平，等待高电平结束
1 E5 ^& Y) R/ {! o  _7 w}
return data;
! c( W  k5 H) x}
// 获取数据
: e+ ^1 i; l. M1 G/* 函数名：DHT11_REC_Data
* 功能：获取 DHT11 数据并打印
* 输入：无
* 输出：无
$ M, E$ C9 w0 I& t: k6 K* 备注：无
! q) B& S# C3 S2 b9 V. L*/
* m% N0 _4 y7 e! fvoid DHT11_REC_Data(void)
2 G1 o/ `3 V6 M+ J  {% f* {{
" K4 O* ^3 ]0 }& D  G2 K; ^unsigned int R_H, R_L, T_H, T_L;
unsigned char RH, RL, TH, TL, CHECK;
6 M* }/ c+ x6 `# v. F8 m: l! ~DHT11_Start(); // 主机发送信号
- p: R9 U1 C) t5 t! {//dht11_high; // 拉高电平
if (dht11_read == 0) // 判断 DHT11 是否响应
  ^; L- t- m* N{
4 i3 U' O* v& B8 ^5 e" y! Uwhile (dht11_read == 0); // 低电平变高电平，等待低电平结束
. d8 a* S" M- jwhile (dht11_read == GPIO_PIN_SET); // 高电平变低电平，等待高电平结束
0 E7 R  b& h5 I" @R_H = DHT11_Rec_Byte();
R_L = DHT11_Rec_Byte();
T_H = DHT11_Rec_Byte();
; V0 [6 P3 Z7 l% |& I% a; q6 z6 z9 D1 H6 rT_L = DHT11_Rec_Byte();
CHECK = DHT11_Rec_Byte(); // 接收 5 个数据
//DH11_GPIO_Init_OUT();
. u- I% B7 C. K2 [7 P3 z% t% e//dht11_low; // 当最后一 bit 数据传送完毕后，DHT11 拉低总线 50us
# X5 C4 U, ]* ^3 L- y6 [delay_us(55); // 这里延时 55us
/ m- x3 R" V% k* Z$ a" H//dht11_high; // 随后总线由上拉电阻拉高进入空闲状态。
if (R_H + R_L + T_H + T_L == CHECK) // 和检验位对比，判断校验接收到的数据是否正确
. V/ i. B2 n9 ]: F! g" C" R* `{
RH = R_H;
RL = R_L;
TH = T_H;
% C% a5 _0 |% q8 bTL = T_L;
}
8 q8 y% W, h. k! t) B1 f; o}


rec_data[0] = RH;
rec_data[1] = RL;
rec_data[2] = TH;
rec_data[3] = TL;
char buf[20]="";
& |- o7 c, z* Z" Rsnprintf(buf,10,"Temp:%d.%d",TH,TL);
! [6 E& r' r, r1 rLCD_PutString(10, 10, buf, White,Blue,1);
snprintf(buf,10,"Hum:%d.%d",RH,RL);
8 {5 Y" U9 m8 p7 u4 nLCD_PutString(10, 30, buf, White,Blue,1);}

3 [& _  f2 W. c( E
主要代码：
& Y) A+ e4 U3 k2 p: {6 @' @. ewhile(1){
8 P" Y; T1 l, o& \, {DHT11_REC_Data();//DHT11 读取
//DS18B20_Get_Temp();//18B20 读取
8 E7 k" m( Q7 UHAL_Delay(1000);
) @! v* R) t( K- P( \( F0 @" z}


实验现象：
下载烧录后可以观察到 LCD 显示 DS18B20 测试的温度，或者 DHT11 测量的温度和湿度。
3 T+ N: F5 u8 T/ Q% `  a

▲ 图 3.12.2 实验现象

第十三、独立看门狗
9 V& l0 i9 a; j$ V实验目的：掌握和熟悉独立看门狗用法，包括喂狗操作等。

0 ]# x5 V* U6 \- ^+ Z) [CubeMX 配置如下，保存后生成对应的配置代码：

# C- E& y& g6 V# x5 k' S) I; q▲ 图 3.13.1 CubeMX 进行独立看门狗配置

本实验进行独立看门狗配置。使用 CUBEMX 配置 IO 为输出输入模式实现 LED 指示和按键读取，GPIO 配置参考上文。程序中使用按键喂狗，如果没在 1s 内喂狗，系统将会自动复位。
3 F# a. Q# O3 l+ m8 B
1 n4 T+ s8 u3 {3 ]' B( g" Z! u主要代码：
3 U0 h3 |! V$ ]1 J% ?) U3 g7 n% zwhile (1)
) S" ~" Z) H. X{
if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
{
9 ?6 I% t9 n! H; X, N' e# \HAL_Delay(5);
6 C) s- V4 Z7 z( N* A' p9 A. Iif(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
0 Q9 N% g' F) w) R+ y3 A1 I{
HAL_IWDG_Refresh(&hiwdg);
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_10);
while(!HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4));
# e# y. B/ N& x6 i; r}
, R. x+ z4 M/ Y& D}
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
- X( k# [, p: l( q. d, d9 r}
( h  S& d) Q* |& i% B

: g$ @7 O( y3 e% {2 X- s" Y实验现象：
下载烧录后可以观察到如果在一定时间内进行喂狗操作，系统会复位，LCD 重新加载。
: b% @$ }$ `* e. n1 `
▲ 图 3.13.2 实验现象
- z% Q% S, Q0 k; H8 u. B1 p
6 ~* Q6 z% g" Y8 U1 ]+ S5 L
, w- A7 l: a/ Y+ R0 ?5 e转载自： AI电堂
: D" n# M" T/ U# d) Z$ ~8 Z3 P如有侵权请联系删除
' A0 _; G/ _9 W  P- U" R
& c( e% L, m% x+ S; M9 j

$ d4 n' F3 ^* \$ D