第十、COMP 实验
  @- p% p- N7 s) V& L实验目的：掌握和熟悉 G474 内部的模拟比较器用法，包括触发方式以及与内部 DAC 级联使用等。

1、软件读取 COMP 结果实验
" E5 d( ^+ R+ i3 _3 K  H" Z6 iCubeMX 配置如下，保存后生成对应的配置代码：
3 ?2 q* D! Z3 J+ L5 j9 }

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


( K& Y, A" z" V. W0 i! K5 g相关操作函数说明：
HAL_StatusTypeDef HAL_COMP_Start(COMP_HandleTypeDef *hcomp)
功能：开启比较器；
* E. d, A9 l' \% o$ z6 `6 f参数 1：比较器句柄，根据需要填写；
/ I. M0 v" M: x, h8 U; ^返回：操作结果，HAL_OK 或 HAL_ERROR；
示例：HAL_COMP_Start(&hcomp3);// 开启 COMP3HAL_StatusTypeDef HAL_COMP_Stop(COMP_HandleTypeDef *hcomp)
功能：关闭比较器；
参数 1：比较器句柄，根据需要填写；
4 {8 _8 N$ \/ J  L0 ^0 x- O/ w7 G8 z返回：操作结果，HAL_OK 或 HAL_ERROR；
' P/ r& |* p# C' zuint32_t HAL_COMP_GetOutputLevel(const COMP_HandleTypeDef *hcomp)
功能：读取比较器输出电平；
参数 1：比较器句柄，根据需要填写；
1 \' l2 q" k' ~1 V返回：比较结果，COMP_OUTPUT_LEVEL_LOW 或 COMP_OUTPUT_LEVEL_HIGH；
% k5 K) B2 F* s& u. d$ e9 t示例：result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果

4 [. q7 w2 P. E7 s: A* U
  o" {% K  k- S" ^' r4 ^2 N& ?核心代码：
& T7 D0 S& z+ z) Q% E9 W: D4 Hif(HAL_COMP_Start(&hcomp3) != HAL_OK)
//开启比较器
. l# s' T6 Y* n" l' l: b: D0 w# B{
Error_Handler();
}
' [7 m* P8 l% A& l" q- v4 Cwhile (1)
{
' F; [- ]. g  J; }+ h3 Aresult = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
& y6 J. F; ^/ R: N0 z" e. dif(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
{
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
& o% e5 S$ J. I4 n( w1 Y* v: k}
HAL_Delay(100);
}


$ T! g% e, X" _9 F3 I/ v$ |# p以上为 main 函数中外设初始化结束后的部分首先开启比较器，然后在主循环中每 100ms读取一次比较结果，如果结果为 1，即正相输入大于反相输入，则进行 LED2 翻转。
6 j- ]2 `8 Q/ _" X1 u
/ x4 y2 ]! ~$ e, f) u( l2 c
( t& Q- v$ i3 t( V1 s实验现象：
8 k( D- |/ y0 G7 G! l/ G+ C2 U下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。
7 B6 h5 y/ Y1 [! O5 I: e
2、中断读取 COMP 结果实验
) }2 b& D/ \- h% f$ x$ A2 vCubeMX 配置如下，保存后生成对应的配置代码：
9 u7 U! E' v9 S1 |* V, D+ b
0 P! t$ q8 V2 Z1 s8 B* |: _. D
▲ CubeMX 进行 COMP 配置


本实验使用中断读取 COMP 比较结果，在比较结果变化的上升沿和下降沿都触发中断，为了使比较结果更加直观，开启外部比较结果输出。
/ M: L8 z' P0 \' ^; }5 s2 f
$ Y5 E, B, L/ Q) G0 @4 E
核心代码：
3 w5 |; E' H! i# n/ r+ l5 N" _: \if(HAL_COMP_Start(&hcomp3) != HAL_OK)
5 Q3 Q! {% d0 J9 p2 g//开启比较器
{
Error_Handler();
}
* H* o) d0 M0 t6 y5 G

以上为 main 函数中外设初始化结束后的部分，这里只需要开启比较器即可，使用函数与上例相同。
% ~5 Y- p& w3 j% y) t# I" Z
  w# j; U3 l4 M) d+ }# ]
void HAL_COMP_TriggerCallback(COMP_HandleTypeDef* hcomp)
{
: V1 q; d$ j* O! q- R: Oif(hcomp->Instance==COMP3)
{
uint8_t temp;
temp = HAL_COMP_GetOutputLevel(&hcomp3);//读取比较结果
8 C' e9 M  W7 ^% x2 Gif(temp == COMP_OUTPUT_LEVEL_HIGH)//结果为 1，上升沿触发
4 c+ C" V. K; N3 k{
$ \9 y4 F  m0 @- r( hHAL_GPIO_WritePin(GPIOD,GPIO_PIN_10,GPIO_PIN_RESET);//点亮
5 n% t. d0 g' ~6 l' d" a/ qLED1
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_11,GPIO_PIN_SET);//熄灭
/ q4 J1 p7 g& V% M( H! M& |6 bLED2
1 N) x# \. E# @) T}
# c$ z, v& W! y- D1 J6 ^5 g' \% Jelse
{
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_10,GPIO_PIN_SET);//熄灭 LED1
) K) c" t# ?' x/ `5 I2 E9 zHAL_GPIO_WritePin(GPIOD,GPIO_PIN_11,GPIO_PIN_RESET);//点亮
LED2
}
. M* t* `' @) B1 f$ k}
5 l" j* u& n% v# Y1 F}
% A% l& F5 Z& Y+ F- f* p% F
  |% B. O: j) |: u8 |; y* _  M
+ k+ i! W7 W* `$ A) V( t以上为 COMP 触发中断回调函数，该回调函数为比较器共用，需要判断中断源，如果开启了多个边沿，还需要判断具体边沿。实质上，COMP 中断触发与 EXTI 类似，实际就是将COMP 比较输出作为一个 IO 映射到 EXTI 进行中断。

% f% Z/ s7 S8 |5 s$ {
实验现象：
下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED1 灭，LED2 亮，CMP 灭时，LED1 亮，LED2 灭。

) q7 s% K; v/ p5 f) O$ l
3、内部 DAC 级联比较实验
8 X% x$ z; f* t% v! D2 R6 a9 ]CubeMX 配置如下，保存后生成对应的配置代码：
7 z# l& q5 R. U6 L( T' A+ i

▲ CubeMX 进行 COMP 配置

+ P" I: O2 W9 k0 M4 D
▲ CubeMX 进行 DAC 配置


2 U4 \, ?. k' i: B本实验使用软件读取 COMP 比较结果，正相输入为光敏电阻，反相输入使用 DAC3 的 OUT1作为比较电压，为了使比较结果更加直观，开启外部比较结果输出。
. E! s  P, q) h% [

; K& u: i6 `) C核心代码：
9 `! i& P0 S- q' N& N  z5 ^" _' ]9 ovoid DAC3_CH1_Set_Vol(uint16_t vol)
/ {9 e+ l) g- T  h- e+ i0 \3 {{
. A, Z' v+ }6 @  \. O! v" [double temp=vol;
0 m9 [( p9 v$ }, `7 `" ^6 h( htemp/=1000;
- [# {; s. B  ~temp=temp*4096/3.3;
HAL_DAC_SetValue(&hdac3,DAC_CHANNEL_1,DAC_ALIGN_12B_R,temp);//12 位右对齐数据格式设置 DAC 值
}
: u" `' j1 l% w5 }: I
. {+ [  H( w6 R1 W" ?  v
以上为 DAC 设置函数，通过该函数可以将输入的电压快速转换为 DAC 所需的寄存器数据。

( N: Q. H* W% c" ^
DAC3_CH1_Set_Vol(500);//DAC 输出设置为 500mv
! d2 [1 c- U- s' ?) j. e# D) oHAL_DAC_Start(&hdac3,DAC_CHANNEL_1);//生效 DAC 输出
if(HAL_COMP_Start(&hcomp3) != HAL_OK)
8 o2 h9 @# d; T8 X3 X  \( B//开启比较器
( J3 ?6 r. `, f4 X6 n2 O- X{
Error_Handler();
4 F' C" s' E7 Q' p6 a}
while (1)
# ~; D8 C3 d; \  ]: f6 {6 i{
result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
if(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
6 s( Z/ Z. \  z% e; Q/ C{
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
}
$ ~+ r+ W9 }3 m; }: kHAL_Delay(100);
}
4 q  c" k: j, Y7 `! S: r以上为 main 函数中外设初始化结束后的部分，首先设置好 DAC 输出电压，开启 DAC，然后开启比较器，最后在主循环中每 100ms 读取一次比较结果，如果结果为 1，即正相输入大于反相输入，则进行 LED2 翻转。
3 Y2 r9 ~; Q& e$ a9 T* s& p, O2 @
2 P7 A: p' p+ M' x
+ S* n& d: ^7 U, ?+ J2 y* ?! u实验现象：
下载烧录后可以观察到遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。
* j! J' O4 z' _! U

第十一、FLASH 实验
7 g$ k2 i" ^; f2 Z实验目的：掌握和熟悉 G474 内部的 FLASH 用法，包括 FLASH 读写应用等。FLASH 读取无需进行配置。
, w; s. ^8 I5 a0 U2 h9 M
1 ^" o+ L- i# X  H
核心代码：
8 T( ?* S. @  k2 w, e9 v" D/* 函数名：FLASH_Write
* 描述 ：flash 写入数据
  w3 q0 E( o% t" r8 D( U* 输入 ：data 写入数据地址 addr flash 地址 size 写入字节数
* 输出 ：无
  o/ k4 O  \& F4 M' b! J* 调用 ：FLASH_Write(data,FLASH_PAGE_127,8);//8 字节
# s( ^3 t# u& h*/
. N% U' A& L* H, p- [uint8_t FLASH_Write(uint8_t* data,uint32_t addr,uint16_t SIZE)
: h1 P% V3 t/ @% i{
0 H) e) V- k4 a- h) q4 tFLASH_EraseInitTypeDef EraseInitStruct;//定义擦写操作结构体
, `$ y$ [% x0 H6 ~uint32_t SECTORError = 0;
uint64_t write_buff[10];//写入缓冲数组
uint8_t i = 0;
uint8_t size = SIZE/8;//8 字节写入次数
% w. ?# v+ T% i; |" }4 s; \memcpy(write_buff,data,SIZE);//将输入的数组移动到写入缓冲区
HAL_FLASH_Unlock();//解锁
EraseInitStruct.Banks = FLASH_BANK_1; //存储区 1
/ h( X, h9 v1 ?4 t" IEraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;//页擦除
EraseInitStruct.Page = (addr-0x08000000)/FLASH_PAGE_SIZE;//擦除页
3 S3 _  l% j$ Y8 h$ @( h! u9 ^EraseInitStruct.NbPages = 1;//擦除页数
# B1 i% P6 n" l+ n- o0 Xif(HAL_FLASHEx_Erase(&EraseInitStruct,&SECTORError) != HAL_OK) //擦除页
" P0 \( x0 {) r{
/ S$ F6 Y- m* G3 B: f% Sreturn 1;//擦除失败
}
$ l& K2 S% l! ^$ ?* \8 R' Hwhile(size)
$ @: F, v; v/ b( f{
if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD,addr,write_buff)!= HAL_OK)//双字写入
; ]  M" Z1 K7 M{
+ r3 Z7 ^6 w# _! u+ Greturn 2;//写入失败
}
addr = addr+8;
i++;
! D9 {% l, Z$ @" Q$ usize--;
# `4 t& j0 w3 O8 V) i}
HAL_FLASH_Lock(); //锁定 FLASH
$ ^/ X7 _: y: i8 V( a) H0 X  Yreturn 0;
}
/* 函数名：FLASH_Read
* 描述 ：flash 读取数据
* 输入 ：data 读取数据地址 addr flash 地址 size 读取字节数
# F% c! Q6 }/ \( h" x4 q/ _% U* 输出 ：无
2 B4 B# b* Y  A6 {* 调用 ：FLASH_Read(data,FLASH_PAGE_127,8);//8 字节
2 u* u, `: m6 m) X6 i  D*/
uint8_t FLASH_Read(uint8_t* data,uint32_t addr,uint16_t SIZE)
5 @: N+ ?  N) T{
uint32_t read_buff[10]; //接收缓冲数组
uint8_t i = 0;
$ J& g4 m. j0 \& b3 N3 Duint16_t size = SIZE/4; //接收次数
while(size)
{
6 H7 z, \! U) M; f( qread_buff = *(__IO uint32_t*)addr; //从 FLASH 读取数据到接收缓冲数组
/ T* n& l" x( X$ ]addr = addr+4;
  S+ Z$ `% d% ~2 ^2 S' mi++;
size--;
. `6 o6 Y- j! y7 q}
/ b) g* T* v  @% p. q6 U1 J8 }memcpy(data,read_buff,SIZE); //将数据从接收缓冲数组转移到接收数组
3 J7 f. l2 Z& m, _. ^0 d! Dreturn 0;
}


主要代码：
uint8_t data[8]={0,0,0,0,0,0,0,0};
# D* w! i9 c- W5 achar buf[30]="";
  V5 A6 s7 x6 Z8 vFLASH_Read(data,FLASH_PAGE_127,8);//8 字节
( ~& h$ |" K6 Q1 jdata[0]++;FLASH_Write(data,FLASH_PAGE_127,8);//8 字节
, S4 s! f% o- q0 `9 y7 b, q7 _snprintf(buf,10,"times:%d",data[0]);
% R9 H7 l# y/ T' w  j; y6 F9 U. uLCD_PutString(10,30,buf,Red,White,0);
uint32_t UID1=READ_REG(*((uint32_t *)UID_BASE));
9 d# |/ n* V; y- e1 Q! Luint32_t UID2=READ_REG(*((uint32_t *)(UID_BASE+4U)));
. G- ?3 c% d# `5 d9 N- _# ?% luint32_t UID3=READ_REG(*((uint32_t *)(UID_BASE+8U)));
snprintf(buf,30,"UID:%0x-%0x-%0x",UID1,UID2,UID3);
2 a" H& _! H7 p  `LCD_PutString(10,60,buf,Red,White,0);
" o% ~5 J5 r8 n; W+ `
+ Y' g3 a  z8 E+ R$ P
( Q- q1 I. |4 D! T  @& _4 u实验现象：
下载烧录后可以观察到 LCD 显示 FLASH 测试次数以及芯片的 ID。

. V9 j. `0 I9 B& G$ Z; X
% h3 j- P3 K$ D2 I3 c! P▲ 实验现象
  K! [/ o/ Y2 ?- D+ z8 j

6 |+ ^4 G1 {8 n$ ^; U第十二、单总线实验
实验目的：掌握和熟悉常用的单总线通信，包括 DS18B20，DHT11 读写应用。
CubeMX 配置如下，保存后生成对应的配置代码：
% T0 ^! u  y' x2 Y) d8 U8 e

( S% W) [+ P, o, l, q0 ~▲ 图 3.12.1 CubeMX 进行 GPIO 输出配置
. b- [' r" E* _
* ^5 w2 x! m6 L" M- H) X
& r) l- R4 b. Z* H9 p本实验进行单总线读取 DS18B20 和 DHT11。使用 CUBEMX 配置 IO 为输出模式。
5 V9 w; `7 \2 v/ d2 F

读取 DS18B20 核心代码：
/* 函数名：DS18B20_IO_OUT
) p6 b0 R7 ?4 @1 ?1 a* 功能：初始化 DS18B20 的 GPIO 为输出模式
: C  F5 U: x3 n9 D9 q6 t* 输入：无
5 ]) f% Y0 w9 g) A2 U9 Z* 输出：无
* [5 ]* A0 Q, a* 备注：无
*/
void DS18B20_IO_OUT(void )
5 F1 S- v" m+ {' O0 h{
& ?' g/ s# F" S/ z: q9 MGPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
. m# z, t( _% e/ ~GPIO_InitStruct.Pull = GPIO_NOPULL;
# F/ x$ a- ~: I1 R+ ~GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
2 ^" a% |; d. b. w4 d* B( C+ C) ^}
/* 函数名：DS18B20_IO_OUT
2 w1 U; ?# \1 O% f9 K2 |* 功能：初始化 DS18B20 的 GPIO 为输入模式
! J6 K" n5 `6 _, Q/ _5 H! h+ U7 ^) a* 输入：无
& ~  C* `9 N# `( Q8 F* 输出：无
* 备注：无
2 `) F5 X9 z2 w* w2 @; R*/void DS18B20_IO_IN(void )
1 r: W8 h% @) X: r3 B{
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_9;
: y* r0 ]8 N  B( kGPIO_InitStruct.Mode = GPIO_MODE_INPUT;
( Q' Y% U, |; d3 PGPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
& z% v* Y6 J  \; m& S* o1 o+ n$ w6 v}
/* 函数名：DS18B20_Rst
6 a; p. E% g7 v7 X0 U" J4 I* 功能：复位 DS18B20
9 e0 T3 n) k) V+ E* 输入：无
0 D3 R) j' Q% Z6 |4 K2 k: u" c, `* 输出：无
* 备注：无
*/
7 |. w/ z( g: \9 d) J: C: P/ Svoid DS18B20_Rst(void)
{
( b2 w- i% q% B9 [: HDS18B20_IO_OUT(); //SET PG11 OUTPUT
DQ_OUT_LOW();
//拉低 DQ
delay_us(750);
//拉低 750us
DQ_OUT_HIGH();
. }. A6 j' g$ j0 x5 l3 d# a//DQ=1
delay_us(15);
//15US
5 T- ]6 \: \$ i, H) y}
/* 函数名：DS18B20_Check
! @0 m4 a& n+ N  R) `* 功能：等待 DS18B20 的回应
0 h( O' S6 e% |4 J* l* 输入：无
0 ~2 T7 h9 q* e8 t2 f& ^* 输出：返回 1:未检测到 DS18B20 的存在 返回 0:存在
* Y9 }  e4 o; X. i  O" F* 备注：无
*/
uint8_t DS18B20_Check(void)
{
uint8_t retry=0;
/ m1 R2 E( f8 i# j" YDS18B20_IO_IN();
9 {7 [2 P, R; ^$ r* Y2 Q2 c) a//SET PG11 INPUT
9 {7 ^* A/ f- ?( {7 @6 O+ u6 b' `9 {8 [while (DQ_GET_IN()&&retry<200)
, d) G6 q- e/ Z6 R0 B  l4 z{
retry++;delay_us(1);
};
if(retry>=200)return 1;
9 E, V6 L" }- r5 S- X% `else retry=0;
& H/ Z. Y8 Z' V% Kwhile (!DQ_GET_IN()&&retry<240)
{
retry++;
- P; a# f8 ?2 I* z" v  u1 |. S( Zdelay_us(1);
+ X# W$ d6 Z* E- y, h8 \% l};
  B* e+ g1 F1 T+ f0 y7 [& s1 bif(retry>=240)return 1;
return 0;
; `  L! r7 }- d! V4 w0 n# [}
/* 函数名：DS18B20_Read_Bit
* 功能：从 DS18B20 读取一个位
* 输入：无
* 输出：返回值：1/0
* 备注：无
8 c# S( Q# O: G$ p*/
# g2 c" E7 h$ Q! @* ^2 @uint8_t DS18B20_Read_Bit(void)
{
uint8_t data;
7 b9 d  E# I7 i. w* n& O1 gDS18B20_IO_OUT(); //SET PG11 OUTPUT
DQ_OUT_LOW();delay_us(2);
DQ_OUT_HIGH();
DS18B20_IO_IN();
//SET PG11 INPUT
delay_us(12);
3 o% g4 p. \2 ]2 Wif(DQ_GET_IN())data=1;
" b. w* n" \4 L) _/ Welse data=0;
8 g6 F$ o, U- c7 }) H. z1 `delay_us(50);
' J- }4 l! U) u0 v. Jreturn data;
}
/* 函数名：DS18B20_Read_Byte
* 功能：从 DS18B20 读取一个字节
1 a" o' |) u, `5 }4 E7 ?* 输入：无
/ r( v, S6 S6 O3 X9 w* 输出：返回值：读到的数据
1 p/ ?3 E& f% P6 E# [* 备注：无
( t; L+ L- b8 K8 N*/
9 ]" z  K9 J7 u* T" ^6 s1 duint8_t DS18B20_Read_Byte(void)
; @) j2 y2 K3 w$ a! _{
( f. T% X' x4 ^+ j/ W# R% suint8_t i,j,dat;
dat=0;
for (i=1;i<=8;i++)
{
j=DS18B20_Read_Bit();
8 W! S0 @. X3 u( U9 z& _2 ]/ Y+ F5 [dat=(j<<7)|(dat>>1);
+ ~% U9 D" r$ P* ^1 w, b  f}
  Q# N* d: z- h/ preturn dat;
+ M( l- a1 K5 D+ m}
2 ?7 l3 y+ b$ ?; v* K! Q" O/* 函数名：DS18B20_Write_Byte
: G5 C& p) B. f  [$ d* 功能：写一个字节到 DS18B20
* 输入：dat：要写入的字节
* 输出：无
* 备注：无
*/
void DS18B20_Write_Byte(uint8_t dat)
5 {2 s7 K7 W" _{
( C# `$ L  K& k( |uint8_t j;
. h' M% h5 \- e. w# n+ m! h9 ]uint8_t testb;
DS18B20_IO_OUT(); //SET PG11 OUTPUT;
. f, w3 _' W- |2 T  l5 A$ w8 Lfor (j=1;j<=8;j++)
{
3 W. f- f9 W" o8 e6 C/ Mtestb=dat&0x01;
7 E4 N# r. E7 |& Tdat=dat>>1;
; J4 r1 T5 |/ {1 A2 _if (testb)
{
DQ_OUT_LOW(); // Write 1
delay_us(2);
4 Z6 f3 t& ^3 DDQ_OUT_HIGH();
: h! g$ N4 C1 X+ edelay_us(60);
6 w5 ~& h3 {8 O( G9 W6 _/ ^}
else
{
& B4 a; \( M3 b0 ODQ_OUT_LOW(); // Write 0
- n/ N4 h$ h! Ndelay_us(60);
4 s6 ^/ R5 ~) v3 d% ^DQ_OUT_HIGH();
delay_us(2);
3 d' O- [) x* P. g}
& `# [% G; i/ o2 e}
  u! \# ?$ K9 b$ s" u}
' ?$ f2 @; w0 l# v9 Z) b8 M/* 函数名：DS18B20_Start
/ a; B# [/ K3 g" g6 O4 u/ f% |: T* 功能：开始温度转换
# Z, ~, ~% z/ [* 输入：无
* 输出：无
* 备注：无
7 T* p; D9 u' O% C6 a' h1 S*/
//
void DS18B20_Start(void)
{
$ j+ a0 N" `! E3 uDS18B20_Rst();
4 J* V2 ^7 ^, F5 n/ D' N0 kDS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
- r, j8 g5 f% A0 J* @. bDS18B20_Write_Byte(0x44);// convert
}
/*
函数名：DS18B20_Start
* 功能：从 ds18b20 得到温度值 精度：0.1C
' @* n: \% w, N, [, n- C* 输入：无
* 输出：返回值：温度值 （-55.0~125.0）
* 备注：无
*/
short DS18B20_Get_Temp(void)
  X/ |7 F$ V# ]  k" h4 P3 i{
! a0 l3 d4 r. ^% w0 c$ T2 W0 l  ?uint8_t temp;
uint8_t TL,TH;
5 l, P$ q6 s3 ^short tem;DS18B20_Start ();
* i. V: ]3 t! w4 B+ m9 `* K// ds1820 start convertDS18B20_Rst();
DS18B20_Check();
  F7 D& g9 ]# x8 _6 _; R  W' ]; b- QDS18B20_Write_Byte(0xcc);// skip rom
9 F+ e+ k/ X& E: ZDS18B20_Write_Byte(0xbe);// convert
TL=DS18B20_Read_Byte();
3 F4 J: L. B, m/ K4 L( w6 W// LSB
& C7 V  m: t. s/ j7 NTH=DS18B20_Read_Byte();
// MSB
5 q0 b# P4 U% M5 i4 R" }if(TH>7)
{
TH=~TH;
TL=~TL;
6 p) C* s0 y  t  D2 Ztemp=0;
//温度为负
7 _! u" E* R& ^4 l9 c9 W/ ]}else temp=1;
7 S2 g+ u' \0 N3 L4 j' h//温度为正
tem=TH;
//获得高八位
5 `+ s8 ?7 g! _1 }( m8 u) G' Vtem<<=8;tem+=TL;
//获得底八位
+ R  [4 D( i1 ?- b; H$ o) }tem=(float)tem*0.625;
//转换
char buf[20]="";
2 N0 M/ z. E3 i+ C# S& O3 |& xif(temp)snprintf(buf,10,"Temp:%.1f",tem/10.0);
- e/ I8 k6 T: z8 Z: `! c9 m. pelse snprintf(buf,10,"Temp:%.1f",tem/10.0);
LCD_PutString(10, 10, buf, White,Blue,1);
. p( O- d. }: T8 k: N- nif(temp)return tem;
//返回温度值
else return -tem;
- [' w4 S9 y4 C. F; b" z# t/ ^* ^; W }
) }, _5 e7 e* b) m读取 DHT11 核心代码：
+ l' E  b0 q# u0 I2 M0 {. H/* 函数名：delay_us
* 功能：微秒延时
- @9 P$ [0 M( r' W) g" d0 a* 输入：delay 延时多少微秒
  `5 K$ P! x" k" q! R; E1 T8 V* 输出：无
* 备注：无
, v, ?( i( r& u# G*/
0 ~. t$ B- A6 Z/ h#define CPU_FREQUENCY_MHZ 170
// STM32 时钟主频
void delay_us(__IO uint32_t delay)
{
int last, curr, val;
1 I& Y: ^" X$ X" b/ K! H: uint temp;
2 F) K' b5 \; h0 L6 h7 Ewhile (delay != 0)
% `; h7 V. X: X( u3 |8 Q{
temp = delay > 900 ? 900 : delay;
- Y5 n- Z8 t$ @- \$ u4 ilast = SysTick->VAL;
curr = last - CPU_FREQUENCY_MHZ * temp;
  Z! V- W1 f+ z" Y( Lif (curr >= 0)
{
8 l) O4 a- V. Ldo
1 K, H. V8 |  ]* w0 H8 f{
0 o% D& g2 P: u, B& d- M, m( p% ival = SysTick->VAL;
}
while ((val < last) && (val >= curr));
0 \5 [( M6 ]2 t& m3 U+ T6 X+ D2 k}
/ l  y/ w/ x  }; Relse
; D' m' C6 o8 r' ~! b. n; a# H. [{
curr += CPU_FREQUENCY_MHZ * 1000;
do
/ i2 j% O4 `' C4 I( _( s. ^5 Q{
val = SysTick->VAL;
}
0 `  ]- N2 o2 J  }( W0 m4 n* }while ((val <= last) || (val > curr));
}
delay -= temp;
, |/ d% @6 p* t  n7 e4 M$ H* A}
6 F1 D1 p7 z4 a) Q0 l# i; r1 m- E& f}
3 G! y$ B! o. O- u. D. Junsigned int rec_data[4];
" q  u) h; M' D' v4 Z% g; r! C# Z/* 函数名：DH11_GPIO_Init_OUT
& k0 Q9 q2 Q+ H' m4 a! T7 K8 Q! N* 功能：初始化 DHT11 的 GPIO 为输出模式
* 输入：无
( k* F$ ]* }4 R+ r4 V( d; g% B* 输出：无
* 备注：无
2 U6 q2 U' k& j8 `9 o5 ?: ?*/
: w* Q: A! d7 d! ^" V; Mvoid DH11_GPIO_Init_OUT(void)
) G+ e, \) t9 O& d, I, `- z7 J{
' G, P/ I1 c7 E: c4 x% {5 m# C" `/ FGPIO_InitTypeDef GPIO_InitStruct = {0};
; F' w1 g) z( l  W- u5 S: VGPIO_InitStruct.Pin = GPIO_PIN_9;
& W! h0 V: K% hGPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  b( Y3 w: P. ?3 y# IHAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
}

4 F/ w; A' F' a// 对于 M0 来说，是输入
6 |8 ]1 E  w& I6 s8 u) Y4 m8 M4 U/* 函数名：DH11_GPIO_Init_IN
% Z4 H% {7 U2 m" _% |0 R* 功能：初始化 DHT11 的 GPIO 为输入模式
* 输入：无
, [9 z: i, Q/ N2 e* 输出：无
* 备注：无
$ d. }5 q3 u, K- Y) n1 h( q1 Z7 G*/
5 s4 `7 s9 q7 r2 U7 _void DH11_GPIO_Init_IN(void)
: a% {& S  T1 p$ C; S{
3 j0 N9 ]- M  o7 ^1 t/ O" _GPIO_InitTypeDef GPIO_InitStruct = {0};
+ v: h& U! o2 CGPIO_InitStruct.Pin = GPIO_PIN_9;
/ b0 L$ X! |' D3 q, o3 x. _GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
% u. G: T, |( e" i; zGPIO_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);//配置为上拉输入
}
9 `. ^0 ~! ]# B9 }' V) u// 主机发送开始信号
" g0 m7 E- n% g. t" y: L+ P. I/* 函数名：DHT11_Start
( K/ E3 O# c$ I4 }( N! M* d* 功能：主机发送开始信号
* 输入：无
* 输出：无
* 备注：无
8 i0 N" G8 ?3 i4 `; g5 r( d+ @*/
0 r4 x- @& c  m( n& H+ x6 o- w/ uvoid DHT11_Start(void)
{
0 b4 h3 x7 _" R  IDH11_GPIO_Init_OUT(); // 输出模式
# |% k  A, I$ |4 k; @dht11_high; // 先拉高
9 q1 U; t; w# E0 B( k6 Hdelay_us(30);
dht11_low; // 拉低电平至少 18ms
. B9 O# }* }% _$ x/ V0 oHAL_Delay(20);
1 Y5 U" R, s8 P* j  y6 ^dht11_high; // 拉高电平 20~40us
$ ^5 y, |8 L9 s7 H" A. a7 `" a. mDH11_GPIO_Init_IN(); // 输入模式
delay_us(30);
1 q. t/ c5 o. J}
4 v" l* v/ w9 n8 j4 f/ v// 获取一个字节
! p* G  p7 p5 Q8 C- }4 e/* 函数名：DHT11_Rec_Byte
* 功能：获取一个字节
4 p' {! `; U. ^* 输入：无
; [/ l( n9 F* y, K9 x4 k' b* 输出：读取的字符
* 备注：无
+ P4 Q1 f+ Z8 i3 J*/
6 p. H! q; E2 X7 Hchar DHT11_Rec_Byte(void)
{
unsigned char i = 0;
3 q8 I  F! ~- Iunsigned char data;
8 [+ u4 F7 h% W& o6 Wfor (i = 0; i < 8; i++) // 1 个数据就是 1 个字节 byte，1 个字节 byte 有 8 位 bit
{
3 }0 I; r( t7 r, g  b! C  Kwhile (dht11_read == 0)
8 G( F1 ~0 q! M" ?;
  w. K4 m% ]6 j# U2 h( `0 {// 从 1bit 开始，低电平变高电平，等待低电平结束
delay_us(30); // 延迟 30us 是为了区别数据 0 和数据 1，0 只有 26~28us
0 d+ l4 w" W% n4 fdata <<= 1; // 左移
if (dht11_read == GPIO_PIN_SET) // 如果过了 30us 还是高电平的话就是数据 1
# r9 @4 T. p& Y; v' z{
. H2 u# A2 e; R6 Idata |= 1; // 数据+1
  N6 G4 _% `$ D5 H  M& [, g}
while (dht11_read == GPIO_PIN_SET)
; // 高电平变低电平，等待高电平结束
}
return data;
3 \% s; A6 Z- R* s}
: K% S0 f* [2 Y// 获取数据
/* 函数名：DHT11_REC_Data
* 功能：获取 DHT11 数据并打印
$ c! W' @' Y: Z) ~+ s9 r* h+ z, g* 输入：无
* 输出：无
6 J% O6 U3 P  [/ y* c! @* 备注：无
1 C0 e8 d& S0 m1 Q*/
void DHT11_REC_Data(void)
, C' @; B3 _3 @* l9 E( X' k{
unsigned int R_H, R_L, T_H, T_L;
unsigned char RH, RL, TH, TL, CHECK;
DHT11_Start(); // 主机发送信号
//dht11_high; // 拉高电平
3 C* W. O" O! fif (dht11_read == 0) // 判断 DHT11 是否响应
{
while (dht11_read == 0); // 低电平变高电平，等待低电平结束
while (dht11_read == GPIO_PIN_SET); // 高电平变低电平，等待高电平结束
- h) D2 H  s- w+ i- pR_H = DHT11_Rec_Byte();
- L7 Q4 ~+ _4 [7 rR_L = DHT11_Rec_Byte();
4 ]$ ]% X- V3 ~5 OT_H = DHT11_Rec_Byte();
  r0 d1 z4 Q' p) ^) sT_L = DHT11_Rec_Byte();
CHECK = DHT11_Rec_Byte(); // 接收 5 个数据
" p, k, K" e' V* `//DH11_GPIO_Init_OUT();
//dht11_low; // 当最后一 bit 数据传送完毕后，DHT11 拉低总线 50us
delay_us(55); // 这里延时 55us
# W- [: N) v' ?: m0 O5 F1 X//dht11_high; // 随后总线由上拉电阻拉高进入空闲状态。
, R8 m5 q' V+ c2 z5 l: [% Q2 x! X$ r$ ^if (R_H + R_L + T_H + T_L == CHECK) // 和检验位对比，判断校验接收到的数据是否正确
{
RH = R_H;
RL = R_L;
TH = T_H;
TL = T_L;
  n: U: i) e4 V- U3 J% V}
}

, e- O. e; h6 X9 ?
4 y4 k- ~  g& Hrec_data[0] = RH;
, I& D) E. s: q8 V7 j5 }) prec_data[1] = RL;
; c& `$ M9 A; a* Nrec_data[2] = TH;
rec_data[3] = TL;
: A( ?) A+ M9 x! P# Y, v' s8 pchar buf[20]="";
; K+ y( }7 X+ r2 Y+ V  W% A) v5 ?snprintf(buf,10,"Temp:%d.%d",TH,TL);
# g( c* ?# Q. Y( m1 f3 {5 M3 tLCD_PutString(10, 10, buf, White,Blue,1);
snprintf(buf,10,"Hum:%d.%d",RH,RL);
LCD_PutString(10, 30, buf, White,Blue,1);}
( E2 K6 i9 N! u; G* u2 c

主要代码：
while(1){
DHT11_REC_Data();//DHT11 读取
4 D  x5 `+ A" n5 P//DS18B20_Get_Temp();//18B20 读取
3 D5 a5 {" o$ F/ _8 u) a0 \% LHAL_Delay(1000);
}

' m) s# a1 y( m& h0 b
实验现象：
! B2 \$ O' @% z* g下载烧录后可以观察到 LCD 显示 DS18B20 测试的温度，或者 DHT11 测量的温度和湿度。

5 y& F& ?; t& c" E# i% v9 X- `; E
▲ 图 3.12.2 实验现象

% }9 p! k$ V6 A, h3 \第十三、独立看门狗
实验目的：掌握和熟悉独立看门狗用法，包括喂狗操作等。
5 I  F$ B! \. b1 d! x, i
CubeMX 配置如下，保存后生成对应的配置代码：
: j5 g- X8 \% i/ ]
▲ 图 3.13.1 CubeMX 进行独立看门狗配置

3 K( s% _  w8 ^5 Q* k: h* X; w8 @6 m本实验进行独立看门狗配置。使用 CUBEMX 配置 IO 为输出输入模式实现 LED 指示和按键读取，GPIO 配置参考上文。程序中使用按键喂狗，如果没在 1s 内喂狗，系统将会自动复位。
! b2 c+ W8 F' w: O$ q
主要代码：
; p0 N4 k5 ^* I9 @- Swhile (1)
- R/ h2 [9 _0 [1 i5 {9 m5 C{
( k3 r- R$ f1 x0 l5 Kif(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
  W/ M9 U5 i; f{
HAL_Delay(5);
, d0 w7 P: u; Hif(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
{
HAL_IWDG_Refresh(&hiwdg);
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_10);
3 e4 w; I. \3 s+ A! P- ^* l! Mwhile(!HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4));
& l! @+ v' v  d}
1 O5 d7 @: k9 D* ?2 ^( i}
  z6 v8 H# L& n$ R! \* j: Q/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
3 T, }' a8 P; B, y# S  T}

% W2 I4 m8 j# d! O6 ]4 ]4 M+ y
实验现象：
* v, P7 S0 e+ \9 s5 [& U# o0 L6 B+ C下载烧录后可以观察到如果在一定时间内进行喂狗操作，系统会复位，LCD 重新加载。

▲ 图 3.13.2 实验现象
4 E$ O* D4 Z( ^  u8 t: N7 a! R
! V7 S' l* t' P5 _1 C- |7 M* f, y% F  Y
转载自： AI电堂
, G; [  s* z% }2 [+ _如有侵权请联系删除
. _3 @3 f# }) x1 [


) h; d% C; S  H5 ]) x3 ~
4 J7 j8 s) G0 g3 }3 _; x! ~