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

1、软件读取 COMP 结果实验
CubeMX 配置如下，保存后生成对应的配置代码：

+ Y, T7 r2 `0 w' ^" w+ u
' G* j- Z2 y' ~5 {8 r; x▲ CubeMX 进行 COMP 配置
" p/ e( T! M$ W' z, d% ?本实验使用软件读取 COMP 比较结果，不需要配置触发，为了使比较结果更加直观，开启外部比较结果输出。


7 _' }; ^8 F0 [7 g+ g* n0 n% x5 W相关操作函数说明：
* V* h! S7 ?2 v9 z  m% u7 dHAL_StatusTypeDef HAL_COMP_Start(COMP_HandleTypeDef *hcomp)
功能：开启比较器；
参数 1：比较器句柄，根据需要填写；
! w( ?. F8 K5 k6 [2 H$ _  K返回：操作结果，HAL_OK 或 HAL_ERROR；
示例：HAL_COMP_Start(&hcomp3);// 开启 COMP3HAL_StatusTypeDef HAL_COMP_Stop(COMP_HandleTypeDef *hcomp)
功能：关闭比较器；
6 v! B1 U3 s5 F+ ^7 z参数 1：比较器句柄，根据需要填写；
. g5 Y- u( O: B' V+ B3 P8 P- J返回：操作结果，HAL_OK 或 HAL_ERROR；
0 d5 `* ^* O, huint32_t HAL_COMP_GetOutputLevel(const COMP_HandleTypeDef *hcomp)
功能：读取比较器输出电平；
9 w' t! n- `: `4 \5 X参数 1：比较器句柄，根据需要填写；
返回：比较结果，COMP_OUTPUT_LEVEL_LOW 或 COMP_OUTPUT_LEVEL_HIGH；
3 F4 V; e' k" S示例：result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
  C8 r2 c1 D# p
( c  O2 B! `" X. H# `4 @
核心代码：
if(HAL_COMP_Start(&hcomp3) != HAL_OK)
0 z0 m: J( h/ p8 G  [; c//开启比较器
% V2 O" w  u$ F/ `{
Error_Handler();
}
while (1)
% ~( a5 c' o+ q4 @{
  E& R7 L, m; I& Z8 |  rresult = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
if(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
{
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
}
HAL_Delay(100);
}

/ h1 I& N  P1 D# Y
以上为 main 函数中外设初始化结束后的部分首先开启比较器，然后在主循环中每 100ms读取一次比较结果，如果结果为 1，即正相输入大于反相输入，则进行 LED2 翻转。
6 n& m$ D6 Y9 Y, R- F

# F; j4 s! a& H& Q1 [实验现象：
3 T* a; W- k# L4 L+ z7 @, ^下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。
$ ?, O9 E- a/ \* B% ?% o
2、中断读取 COMP 结果实验
1 L$ x7 \0 Q/ O6 D8 `, P) kCubeMX 配置如下，保存后生成对应的配置代码：
0 [5 D) d0 j/ |8 @

* m0 X  j6 _1 w+ P$ K& j! a8 V▲ CubeMX 进行 COMP 配置


4 u  \7 E) w0 {3 X6 \本实验使用中断读取 COMP 比较结果，在比较结果变化的上升沿和下降沿都触发中断，为了使比较结果更加直观，开启外部比较结果输出。
. H5 r9 _  @, H$ \* l

核心代码：
- O6 t6 T0 U- H6 ?if(HAL_COMP_Start(&hcomp3) != HAL_OK)
//开启比较器
8 M. Z. Z4 K( u  l8 c& m3 _! ?{
) y3 z# N5 P* M2 Y2 iError_Handler();
}
2 b1 V9 s, l+ {  c5 p$ A$ z

1 G* m3 e' l- J! V4 X8 g以上为 main 函数中外设初始化结束后的部分，这里只需要开启比较器即可，使用函数与上例相同。


1 ^  ~! ?, v  O/ `void HAL_COMP_TriggerCallback(COMP_HandleTypeDef* hcomp)
{
if(hcomp->Instance==COMP3)
( U& s' @3 k7 s2 I4 Y{
$ d$ x; p, k* y* a( duint8_t temp;
temp = HAL_COMP_GetOutputLevel(&hcomp3);//读取比较结果
if(temp == COMP_OUTPUT_LEVEL_HIGH)//结果为 1，上升沿触发
6 h( y& ]5 b/ Y) ~7 T{
; z  Q. A. R/ yHAL_GPIO_WritePin(GPIOD,GPIO_PIN_10,GPIO_PIN_RESET);//点亮
LED1
  a+ i9 I8 P9 U8 N7 @. m+ }4 T2 kHAL_GPIO_WritePin(GPIOD,GPIO_PIN_11,GPIO_PIN_SET);//熄灭
LED2
$ r6 v3 ?& w! l6 K' ?& R}
else
{
  f2 |6 H3 z5 T- _7 e, H0 w/ x  IHAL_GPIO_WritePin(GPIOD,GPIO_PIN_10,GPIO_PIN_SET);//熄灭 LED1
HAL_GPIO_WritePin(GPIOD,GPIO_PIN_11,GPIO_PIN_RESET);//点亮
2 B- G5 @. J( ~5 D/ tLED2
}
& O4 A5 G6 e; G, D}
}
6 U$ j. h  D9 K% P1 A

+ h" X: {; S4 z, Z; X以上为 COMP 触发中断回调函数，该回调函数为比较器共用，需要判断中断源，如果开启了多个边沿，还需要判断具体边沿。实质上，COMP 中断触发与 EXTI 类似，实际就是将COMP 比较输出作为一个 IO 映射到 EXTI 进行中断。
6 O+ ~) m2 m" N' T* q9 E9 u

实验现象：
! K8 ~5 T! c4 ?( D+ i0 X. a' ^/ s" [下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED1 灭，LED2 亮，CMP 灭时，LED1 亮，LED2 灭。
. D( ]9 {' l" U3 ~3 J2 N8 Y
7 d& ?5 A- l$ y4 V& I
& m* @; j! {7 f3、内部 DAC 级联比较实验
. J" V3 ~7 g2 g# F" UCubeMX 配置如下，保存后生成对应的配置代码：

, n, B4 J( m* ^
▲ CubeMX 进行 COMP 配置


6 u. e0 W" p3 d1 n& [▲ CubeMX 进行 DAC 配置

6 K3 S/ ?% R( H0 ?
本实验使用软件读取 COMP 比较结果，正相输入为光敏电阻，反相输入使用 DAC3 的 OUT1作为比较电压，为了使比较结果更加直观，开启外部比较结果输出。
  U% M( K7 }3 x7 \8 G% Q
2 s7 w6 C9 Z. C
  D1 m: k* l9 I5 Z) a& O- R* G核心代码：
void DAC3_CH1_Set_Vol(uint16_t vol)
{
. L) ?2 n0 N* t  X1 B) i- P3 Ndouble temp=vol;
' Z! d* ?) ~* i- y) \temp/=1000;
temp=temp*4096/3.3;
HAL_DAC_SetValue(&hdac3,DAC_CHANNEL_1,DAC_ALIGN_12B_R,temp);//12 位右对齐数据格式设置 DAC 值
}


1 g/ \9 K$ [+ m: r以上为 DAC 设置函数，通过该函数可以将输入的电压快速转换为 DAC 所需的寄存器数据。
- l* H" V! c$ Z: s

+ ]6 @/ z/ c/ l, DDAC3_CH1_Set_Vol(500);//DAC 输出设置为 500mv
% O7 y6 T+ ~# R& z& H+ cHAL_DAC_Start(&hdac3,DAC_CHANNEL_1);//生效 DAC 输出
3 y2 K' I4 \4 h4 ?if(HAL_COMP_Start(&hcomp3) != HAL_OK)
( l# H+ [* \& t) X. j0 t//开启比较器
& B, ?" q1 z! x  c* ^1 O1 D: r9 `{
5 x9 S& {$ w: w* w  CError_Handler();
) D& @! Y; w  X9 M5 b7 c7 R- B}
while (1)
{
result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
if(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
0 S* O; i* v! ]% }9 ?{
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
, c+ I% o1 |2 X7 g+ [/ F0 a* V/ v6 R}
HAL_Delay(100);
}
" \; l; [9 r# Q" |; |( d以上为 main 函数中外设初始化结束后的部分，首先设置好 DAC 输出电压，开启 DAC，然后开启比较器，最后在主循环中每 100ms 读取一次比较结果，如果结果为 1，即正相输入大于反相输入，则进行 LED2 翻转。

/ R+ b' h' S4 L- ^8 g" q. U8 v
2 w1 ]( x. R4 f& G' X8 s( Q实验现象：
下载烧录后可以观察到遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。
) R2 N5 y* Z' Y0 b) F3 V/ e
" c3 g) U% b/ c% a
9 w+ L' x: J6 Q0 f1 K( k第十一、FLASH 实验
* U+ S6 ^4 q: ?) u/ |9 {$ S* {1 `实验目的：掌握和熟悉 G474 内部的 FLASH 用法，包括 FLASH 读写应用等。FLASH 读取无需进行配置。
. a! r6 \; k$ i1 t+ r
- l( z* f6 t/ z7 m
& ~& ^2 M# @5 t核心代码：
/* 函数名：FLASH_Write
9 R* l# T! c$ M, c* 描述 ：flash 写入数据
* 输入 ：data 写入数据地址 addr flash 地址 size 写入字节数
* 输出 ：无
* 调用 ：FLASH_Write(data,FLASH_PAGE_127,8);//8 字节
*/
3 g! ]5 b2 W1 K+ y4 |uint8_t FLASH_Write(uint8_t* data,uint32_t addr,uint16_t SIZE)
, D5 @# h6 Z( C3 Z/ g" \# I{
FLASH_EraseInitTypeDef EraseInitStruct;//定义擦写操作结构体
. V6 V; \% ^) m+ f( Wuint32_t SECTORError = 0;
uint64_t write_buff[10];//写入缓冲数组
uint8_t i = 0;
' q2 J' r7 g5 G" u0 v. W+ o1 V' f. Cuint8_t size = SIZE/8;//8 字节写入次数
memcpy(write_buff,data,SIZE);//将输入的数组移动到写入缓冲区
6 B. v- ~& i% d& K# t! HHAL_FLASH_Unlock();//解锁
EraseInitStruct.Banks = FLASH_BANK_1; //存储区 1
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;//页擦除
% m; U0 Q' x2 W2 g, LEraseInitStruct.Page = (addr-0x08000000)/FLASH_PAGE_SIZE;//擦除页
/ ?3 N6 S9 F# M- [  I4 nEraseInitStruct.NbPages = 1;//擦除页数
$ a& w- e" r8 v6 ~9 \; |if(HAL_FLASHEx_Erase(&EraseInitStruct,&SECTORError) != HAL_OK) //擦除页
2 W6 S5 [+ p2 M) b4 y1 {/ @1 l1 @{
return 1;//擦除失败
/ Q/ H; T* q& w/ \* v) ~( q$ h}
while(size)
: y. k0 P; u9 M$ q( p# d{
5 v4 b. u! e8 b7 H  C- hif(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD,addr,write_buff)!= HAL_OK)//双字写入
{
return 2;//写入失败
}
addr = addr+8;
3 f0 n# ^6 E; J0 Li++;
" h$ X0 D7 ~% ?: v- f: w, \size--;
4 f* g5 U5 K* t+ r  ]/ f8 {9 h  B}
HAL_FLASH_Lock(); //锁定 FLASH
7 ?. v3 S& [* c' k& Lreturn 0;
}
5 S/ n- m& _3 O$ k8 x# |/* 函数名：FLASH_Read
* 描述 ：flash 读取数据
* 输入 ：data 读取数据地址 addr flash 地址 size 读取字节数
* 输出 ：无
6 H: q  a- M8 W* 调用 ：FLASH_Read(data,FLASH_PAGE_127,8);//8 字节
0 `' }3 n* J; g5 L9 o6 T) r*/
uint8_t FLASH_Read(uint8_t* data,uint32_t addr,uint16_t SIZE)
7 V( A/ F5 C3 h: h' ^{
uint32_t read_buff[10]; //接收缓冲数组
uint8_t i = 0;
uint16_t size = SIZE/4; //接收次数
' r# q" u+ p& Kwhile(size)
3 S6 ]6 d" w# K$ r5 Y- Z{
read_buff = *(__IO uint32_t*)addr; //从 FLASH 读取数据到接收缓冲数组
addr = addr+4;
i++;
size--;
}
memcpy(data,read_buff,SIZE); //将数据从接收缓冲数组转移到接收数组
return 0;
}
2 H5 ~# g, B9 \7 {/ ?9 {
2 p+ V/ F5 i, K
  i/ i5 F! {2 o) ]) M* C主要代码：
( u9 c7 G0 i, H4 Xuint8_t data[8]={0,0,0,0,0,0,0,0};
char buf[30]="";
/ b# L0 _( z: _& nFLASH_Read(data,FLASH_PAGE_127,8);//8 字节
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));
9 R$ [; U/ S2 ~- C# ^1 Juint32_t UID2=READ_REG(*((uint32_t *)(UID_BASE+4U)));
uint32_t UID3=READ_REG(*((uint32_t *)(UID_BASE+8U)));
snprintf(buf,30,"UID:%0x-%0x-%0x",UID1,UID2,UID3);
/ v4 w+ y; O# D3 uLCD_PutString(10,60,buf,Red,White,0);

+ h! }, e" ^2 _3 K4 W' R- Y; r
实验现象：
下载烧录后可以观察到 LCD 显示 FLASH 测试次数以及芯片的 ID。
% S, Q5 x7 Z/ ?5 n. @" s
+ o* a: l# V9 e0 p1 _; c
: ]/ q7 h" F9 H" Y8 m) u▲ 实验现象


第十二、单总线实验
+ e7 O0 K- q2 d* Z' O3 x: V实验目的：掌握和熟悉常用的单总线通信，包括 DS18B20，DHT11 读写应用。
! F  T: Z0 X* z9 YCubeMX 配置如下，保存后生成对应的配置代码：

) Y! a/ N( J) A+ \
9 L  S4 S2 L# @  R7 C▲ 图 3.12.1 CubeMX 进行 GPIO 输出配置


; ]% o% C& `) t# l本实验进行单总线读取 DS18B20 和 DHT11。使用 CUBEMX 配置 IO 为输出模式。
+ _  m' @2 S8 w$ g  a
8 N7 A2 a7 r4 S/ n
读取 DS18B20 核心代码：
/* 函数名：DS18B20_IO_OUT
* 功能：初始化 DS18B20 的 GPIO 为输出模式
* 输入：无
* 输出：无
* 备注：无
+ R6 n) {+ `. t+ o: H*/
void DS18B20_IO_OUT(void )
1 K' m# `1 S5 |) n4 r8 n- b( V{
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_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 为输入模式
2 Y8 ]8 F) a7 z: g% N& n6 C3 P* 输入：无
* 输出：无
# [: `  |1 A* N( e! W$ j* 备注：无
*/void DS18B20_IO_IN(void )
: o8 R1 |6 m5 P# ?{
' e. c: b+ D" X$ J: aGPIO_InitTypeDef GPIO_InitStruct = {0};
4 w% _5 p' `' h& q$ C9 CGPIO_InitStruct.Pin = GPIO_PIN_9;
9 Q1 z3 r& z, X1 O# I6 tGPIO_InitStruct.Mode = GPIO_MODE_INPUT;
) ?& n. n! V" f5 @GPIO_InitStruct.Pull = GPIO_NOPULL;
3 w; U2 |8 H( [4 tGPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
}
/* 函数名：DS18B20_Rst
* 功能：复位 DS18B20
* 输入：无
  m" {5 R& u2 r5 i& ^5 c* 输出：无
9 e4 X& S% t9 N* 备注：无
*/
void DS18B20_Rst(void)
{
DS18B20_IO_OUT(); //SET PG11 OUTPUT
+ r: F9 u! y4 C$ i  IDQ_OUT_LOW();
//拉低 DQ
delay_us(750);
) k; d. C: l9 B) P8 z, z" y9 \//拉低 750us
- i9 z2 w1 E9 n% P0 h. `DQ_OUT_HIGH();
//DQ=1
delay_us(15);
, A1 R% o2 o/ r- ]" |1 Z( }. M( F//15US
}
' ?8 a* Q: Q2 H% N! K9 ?/* 函数名：DS18B20_Check
* 功能：等待 DS18B20 的回应
* 输入：无
1 j# T3 V9 J; U* 输出：返回 1:未检测到 DS18B20 的存在 返回 0:存在
* 备注：无
! G1 o& f5 M3 c/ P2 K5 N1 H; M*/
uint8_t DS18B20_Check(void)
{
( B( w% J# ?8 g- ?: ~" a- `  tuint8_t retry=0;
DS18B20_IO_IN();
//SET PG11 INPUT
while (DQ_GET_IN()&&retry<200)
{
! \- V3 C+ |* M: U* s6 pretry++;delay_us(1);
};
if(retry>=200)return 1;
else retry=0;
0 m, ~/ {. t3 {5 \while (!DQ_GET_IN()&&retry<240)
" P) }( K# D- G! w{
9 a0 s3 L, {! k/ R$ Oretry++;
delay_us(1);
9 s- k" \$ j0 ^. F5 j/ b# T, Z  J8 e};
if(retry>=240)return 1;
return 0;
}
  U+ `# z0 l' P7 S$ Y$ k/* 函数名：DS18B20_Read_Bit
% J8 d9 g' e, I% n* 功能：从 DS18B20 读取一个位
* 输入：无
4 D8 X3 a) M, B; W% ^. L1 }/ r: j5 S* 输出：返回值：1/0
* 备注：无
*/
8 U2 R& Z4 V& d( t5 K% quint8_t DS18B20_Read_Bit(void)
  z) B! z- @, ^$ [5 C{
- x; G+ v) Z4 Buint8_t data;
6 w# p5 q& |2 P" F; A$ YDS18B20_IO_OUT(); //SET PG11 OUTPUT
DQ_OUT_LOW();delay_us(2);
# h3 Z* y+ Q& z0 i! \! q+ ADQ_OUT_HIGH();
DS18B20_IO_IN();
//SET PG11 INPUT
delay_us(12);
3 h$ s) y7 f3 z, c. aif(DQ_GET_IN())data=1;
( j: |  W- g4 w" a; T( N4 T+ [else data=0;
delay_us(50);
return data;
' i9 s! @- D% {. n- @}
# ^5 K( V, D* T8 w0 Q/ K: V1 u/* 函数名：DS18B20_Read_Byte
* 功能：从 DS18B20 读取一个字节
. t2 b# u1 n6 ^+ o, K# h* 输入：无
, K: U( [& M+ }. D* 输出：返回值：读到的数据
5 w' M1 V5 {( }: r* 备注：无
& k5 t5 ~. T9 A# C: n0 Z9 D*/
* A6 W+ c0 Y% h( q# n# |uint8_t DS18B20_Read_Byte(void)
1 Q; T% w2 [& t! n{
uint8_t i,j,dat;
dat=0;
* f' |- C) E9 ^! x7 V+ lfor (i=1;i<=8;i++)
{
1 M1 t! {& m# y9 W* lj=DS18B20_Read_Bit();
dat=(j<<7)|(dat>>1);
}
7 o2 r3 c' m: F6 {/ O2 O6 Nreturn dat;
}
8 {. \' z3 U7 ?( P/* 函数名：DS18B20_Write_Byte
* B9 o# e3 y, M% ^* 功能：写一个字节到 DS18B20
* 输入：dat：要写入的字节
* 输出：无
3 ~( y: O4 J4 [/ U; c2 Z* 备注：无
" H3 L( U$ Y% U0 l- U3 D& V*/
void DS18B20_Write_Byte(uint8_t dat)
{
* B' c8 \; S+ W$ B# Q# G; vuint8_t j;
/ ^* l( J7 b, W9 D; o: q( G& R6 Tuint8_t testb;
. G- K- |" g6 N: QDS18B20_IO_OUT(); //SET PG11 OUTPUT;
) H5 G3 O2 q- A# Ufor (j=1;j<=8;j++)
6 p  u8 G' G' [{
testb=dat&0x01;
0 c3 q/ h# z, W# A/ Edat=dat>>1;
if (testb)
{
" i* s5 S# x- j4 k+ {4 ]DQ_OUT_LOW(); // Write 1
: [* v( Q- d( ~+ Odelay_us(2);
DQ_OUT_HIGH();
delay_us(60);
& u- _# k- z8 z6 ]9 b" u& ]$ Q; _" v  u}
else
{
DQ_OUT_LOW(); // Write 0
delay_us(60);
8 A9 U: A. X8 T0 h" X' i. JDQ_OUT_HIGH();
0 Q+ M2 y6 c+ \1 \8 n  z+ x2 Ddelay_us(2);
' m# N7 m  o" Q  k/ z! e7 A- w}
( @. I3 B4 w! u' r' v' C}
}
/* 函数名：DS18B20_Start
5 ~- Q  X9 A( \" G+ U  p9 p- x/ s* 功能：开始温度转换
* 输入：无
/ H& {; _$ l& w2 e5 c* 输出：无
* 备注：无
* Q, D) ]0 U1 P( q9 o: [*/
7 A1 T/ @$ v' i# M) |//
void DS18B20_Start(void)
{
DS18B20_Rst();
DS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0x44);// convert
/ y# I4 X, B9 b( P}
/*
; n% \0 s) z! n( V 函数名：DS18B20_Start
* 功能：从 ds18b20 得到温度值 精度：0.1C
* 输入：无
* 输出：返回值：温度值 （-55.0~125.0）
: h! O) ?% z6 X$ W- J* 备注：无
*/
short DS18B20_Get_Temp(void)
8 \( f9 \  X3 P; x8 m{
9 J! D: F6 q: S8 huint8_t temp;
8 T9 q; S! T- [) s% B, m9 p$ c- Yuint8_t TL,TH;
short tem;DS18B20_Start ();
) r  w- s$ x$ U: y// ds1820 start convertDS18B20_Rst();
5 G! z+ v  N! Q# `DS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
( H5 L( W4 L* n3 E- c3 o" cDS18B20_Write_Byte(0xbe);// convert
, }/ Q5 \. p& QTL=DS18B20_Read_Byte();
4 @# G5 S4 ~+ U, {7 [/ I2 E2 \0 s// LSB
( E: U6 O7 b3 z9 r2 uTH=DS18B20_Read_Byte();
$ l! f) g, e. r2 R// MSB
if(TH>7)
{
& T- Q9 r$ Y' `! A0 s9 U# R: RTH=~TH;
0 V5 O, }/ V4 f/ o( \# STL=~TL;
" k# [- N: D" vtemp=0;
; _  L% V+ A1 A- h: n: D//温度为负
}else temp=1;
% W* k) j- m) I8 a//温度为正
* v0 C) w8 w6 f" l0 C6 j7 etem=TH;
//获得高八位
( p; h4 f/ N6 _9 N1 stem<<=8;tem+=TL;
' E0 A7 F/ ?1 x2 m//获得底八位
. _8 v. o; H& C2 `& dtem=(float)tem*0.625;
3 \, ^. W/ |5 J; o! Z) w//转换
char buf[20]="";
if(temp)snprintf(buf,10,"Temp:%.1f",tem/10.0);
else snprintf(buf,10,"Temp:%.1f",tem/10.0);
# u+ v8 c1 U8 Z2 {LCD_PutString(10, 10, buf, White,Blue,1);
if(temp)return tem;
8 e6 w$ d1 @+ F# W" @( U//返回温度值
else return -tem;
}
读取 DHT11 核心代码：
  j/ B2 P8 }' y2 J4 `2 A: |) E/* 函数名：delay_us
* 功能：微秒延时
* 输入：delay 延时多少微秒
) }! T! y3 A! e$ e! Y* 输出：无
* 备注：无
*/
  c# F$ c/ V" P1 A4 i% y  G( x#define CPU_FREQUENCY_MHZ 170
# u# `! y2 |' u+ y6 \// STM32 时钟主频
void delay_us(__IO uint32_t delay)
6 L# b" P- t1 V# P" t! q( ?& F; R{
int last, curr, val;
int temp;
while (delay != 0)
{
temp = delay > 900 ? 900 : delay;
last = SysTick->VAL;
curr = last - CPU_FREQUENCY_MHZ * temp;
5 |! r+ C* M) L+ U0 r6 Yif (curr >= 0)
3 P  V" n7 `1 K% C& k{
/ V* ~8 Q# J  ]( O* y5 d0 Sdo
{
: v8 k, h: f1 x. R0 k1 fval = SysTick->VAL;
}
2 e  ]: f9 Q4 }) d' z4 b) Nwhile ((val < last) && (val >= curr));
}
else
1 D# o8 ?2 X& b4 j{
) M, M  t' Y' ^: u9 O" J  h4 ?curr += CPU_FREQUENCY_MHZ * 1000;
. ?. [" o5 K! ^6 @2 z/ [, s! u  ddo
{
! @4 }2 z# w4 _9 Eval = SysTick->VAL;
+ }; T! X* k8 v! ?}
while ((val <= last) || (val > curr));
! c5 n" G& v" Y1 |+ M. O0 m) K}
delay -= temp;
$ c% W) `5 l4 I}
7 }9 _  o; }8 \4 h$ ?# v}
unsigned int rec_data[4];
/* 函数名：DH11_GPIO_Init_OUT
* 功能：初始化 DHT11 的 GPIO 为输出模式
* 输入：无
( z8 h$ w0 z; \+ g( c6 b8 \* 输出：无
" o' \* p1 L) n* 备注：无
*/
! [6 `7 k: `3 O; H2 Svoid DH11_GPIO_Init_OUT(void)
{
% C! i' v0 F& @2 `/ k; PGPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
- e8 c2 i% L( U+ lGPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
8 e9 p& H! s' L8 CHAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
% a3 M; f) U1 v}

5 b1 f0 C* S* k5 L, s' b# q// 对于 M0 来说，是输入
/* 函数名：DH11_GPIO_Init_IN
* 功能：初始化 DHT11 的 GPIO 为输入模式
2 d+ y. S  P# V/ Q& K1 m* 输入：无
4 ]5 C4 i$ e! {2 p; ?5 o* 输出：无
* 备注：无
*/
2 m8 Y( P; m$ `* k, k* W9 \void DH11_GPIO_Init_IN(void)
  _3 ?+ f: ]2 Z& \; a{
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
7 J1 V8 i  u- ]' v. o7 W5 E+ zGPIO_InitStruct.Pull = GPIO_NOPULL;
' g+ |6 c. ?: g  u; IGPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
' m1 `7 b8 M) k" QHAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
// DL_GPIO_initDigitalInput(GPIO_DQ_dht11_and_ds18b20_IOMUX);//配置为上拉输入
1 A: ^/ i- v- T7 Y4 _3 q}
' g+ S3 B7 l. M% `# i$ ]// 主机发送开始信号
; a0 {0 d1 v7 g0 D, A' n2 S. ?/* 函数名：DHT11_Start
* 功能：主机发送开始信号
9 g: T" G9 W9 s$ W- V$ ]$ R& S6 ~, M- \* 输入：无
* 输出：无
* 备注：无
* ^) u+ z, o: K9 k% b4 v*/
, b7 Z' D$ V! b  ?- P- |void DHT11_Start(void)
{
DH11_GPIO_Init_OUT(); // 输出模式
- t$ W) g& F8 l, |2 K* E# _dht11_high; // 先拉高
( t6 E- ^3 |4 h* v" \. e* @- L6 Ddelay_us(30);
4 `+ g7 o" S) s0 odht11_low; // 拉低电平至少 18ms
! U8 n0 |, Z4 [8 Y; a) JHAL_Delay(20);
dht11_high; // 拉高电平 20~40us
DH11_GPIO_Init_IN(); // 输入模式
delay_us(30);
3 D( f9 C7 d2 V5 o}
5 L. m5 c9 i5 I4 b" I. t0 w// 获取一个字节
3 h7 n1 A5 s) E+ }( D/* 函数名：DHT11_Rec_Byte
9 Q9 h0 }* J7 }3 D% b$ p* 功能：获取一个字节
' {; `( u% V- d! m+ x* S" u4 b6 }* 输入：无
* 输出：读取的字符
* 备注：无
*/
$ u, H% Q" p3 B" `, Ichar DHT11_Rec_Byte(void)
! o4 T( K1 A" @8 P8 A4 {+ H# a: F. ~{
unsigned char i = 0;
unsigned char data;
for (i = 0; i < 8; i++) // 1 个数据就是 1 个字节 byte，1 个字节 byte 有 8 位 bit
{
while (dht11_read == 0)
4 I" d$ f! P( O) r9 Q: J+ x;
; |" E' m% F" O% h# R. Y// 从 1bit 开始，低电平变高电平，等待低电平结束
delay_us(30); // 延迟 30us 是为了区别数据 0 和数据 1，0 只有 26~28us
data <<= 1; // 左移
, i& j2 Z% {( c# F) hif (dht11_read == GPIO_PIN_SET) // 如果过了 30us 还是高电平的话就是数据 1
{
/ Y* Y  s' X& O" W0 I$ ^data |= 1; // 数据+1
7 B6 O& q6 f6 x$ X; q}
while (dht11_read == GPIO_PIN_SET)
; // 高电平变低电平，等待高电平结束
}
return data;
) ]9 o+ ~, D& m! C/ z- n) r, g1 s}
, S& [1 W6 v" U% `. v% m// 获取数据
/* 函数名：DHT11_REC_Data
* 功能：获取 DHT11 数据并打印
8 [( f+ [( k! Z9 {) A* 输入：无
* 输出：无
& s  x1 L9 R0 E1 {* 备注：无
*/
+ z- E' i6 Q( {  Y5 A+ p+ Jvoid DHT11_REC_Data(void)
{
unsigned int R_H, R_L, T_H, T_L;
3 c+ L: M9 Z* q; o) {' a) @unsigned char RH, RL, TH, TL, CHECK;
DHT11_Start(); // 主机发送信号
//dht11_high; // 拉高电平
0 r' l/ p% ?7 G. K$ ]if (dht11_read == 0) // 判断 DHT11 是否响应
{
, e# M, r: [. z) K+ ?4 V. Bwhile (dht11_read == 0); // 低电平变高电平，等待低电平结束
while (dht11_read == GPIO_PIN_SET); // 高电平变低电平，等待高电平结束
R_H = DHT11_Rec_Byte();
  A! A2 g+ ?  b/ GR_L = DHT11_Rec_Byte();
T_H = DHT11_Rec_Byte();
' a: w1 L& r% K$ a, h* }  d3 OT_L = DHT11_Rec_Byte();
CHECK = DHT11_Rec_Byte(); // 接收 5 个数据
//DH11_GPIO_Init_OUT();
+ C& K" }. p0 `4 f% j- _- W4 `//dht11_low; // 当最后一 bit 数据传送完毕后，DHT11 拉低总线 50us
delay_us(55); // 这里延时 55us
//dht11_high; // 随后总线由上拉电阻拉高进入空闲状态。
if (R_H + R_L + T_H + T_L == CHECK) // 和检验位对比，判断校验接收到的数据是否正确
{
RH = R_H;
6 `( ?, k4 m$ M& ?3 [: yRL = R_L;
TH = T_H;
TL = T_L;
4 s# p: a* O9 H' T/ c}
}
' n% G" ~3 M6 f$ }. [
7 e$ p  ?* y! d& k
/ Y1 {8 ^" |) Q% g; y6 nrec_data[0] = RH;
7 G2 Q% a7 y9 t: [7 Zrec_data[1] = RL;
rec_data[2] = TH;
rec_data[3] = TL;
7 w: G( n, u' Qchar buf[20]="";
snprintf(buf,10,"Temp:%d.%d",TH,TL);
  r$ H/ Y' q! {9 Z; OLCD_PutString(10, 10, buf, White,Blue,1);
; d- A/ S6 o+ F! q; Dsnprintf(buf,10,"Hum:%d.%d",RH,RL);
LCD_PutString(10, 30, buf, White,Blue,1);}

! }5 M  H7 n9 ?, ?; y! H5 o
" I% x8 p* A* I4 j% q: t' r主要代码：
+ h8 K- Z, d* K* ^" v  Y# nwhile(1){
2 O6 g* ^5 D3 p, J9 o# jDHT11_REC_Data();//DHT11 读取
//DS18B20_Get_Temp();//18B20 读取
HAL_Delay(1000);
# u  ?& u; @, G6 {/ q}
6 b1 z/ K1 Q4 |

' l. {7 N. T* m; U: J实验现象：
5 Y* l- s  `4 N4 a1 ]& I下载烧录后可以观察到 LCD 显示 DS18B20 测试的温度，或者 DHT11 测量的温度和湿度。
3 s! o1 F& p0 U* e# |7 G
; B6 F0 g8 \. X: e8 A  J0 Y$ w! m0 Y
▲ 图 3.12.2 实验现象
' @3 M( e7 x5 a8 p
第十三、独立看门狗
3 {! D' W0 c" q8 k$ y3 c实验目的：掌握和熟悉独立看门狗用法，包括喂狗操作等。

; P, [; L, B( V% y) J, D! CCubeMX 配置如下，保存后生成对应的配置代码：

- R1 N% U2 \6 {: Y* Y& W& k! z▲ 图 3.13.1 CubeMX 进行独立看门狗配置

本实验进行独立看门狗配置。使用 CUBEMX 配置 IO 为输出输入模式实现 LED 指示和按键读取，GPIO 配置参考上文。程序中使用按键喂狗，如果没在 1s 内喂狗，系统将会自动复位。
( b$ @* s0 v" f$ W& ~1 L
主要代码：
while (1)
{
if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
{
! S* V2 I& Z( G# f: PHAL_Delay(5);
$ B  l2 e6 Z0 z$ |8 G/ rif(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
' T0 q) w- }/ [( J( M{
8 q. M; |/ ~' q5 i* y0 mHAL_IWDG_Refresh(&hiwdg);
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_10);
while(!HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4));
}
}
/* USER CODE END WHILE */
* {' a4 H  i# B1 Z/* USER CODE BEGIN 3 */
: b/ m0 j; |! ]. v}
; _$ M: |0 m0 ?! _  ~4 T! I

实验现象：
下载烧录后可以观察到如果在一定时间内进行喂狗操作，系统会复位，LCD 重新加载。
) G: r/ Q2 R+ I+ b" z
▲ 图 3.13.2 实验现象

/ {& n  J/ N# \( w2 }, W: I1 [
转载自： AI电堂
& S8 [* i; D. `1 q2 u2 \, d. i如有侵权请联系删除


. u4 S, [! i1 m* l$ }