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

1、软件读取 COMP 结果实验
  e: z9 D1 K8 V, ICubeMX 配置如下，保存后生成对应的配置代码：


9 ]; T+ ~) G: D& Z) y$ n1 ~. v3 ~1 F▲ CubeMX 进行 COMP 配置
本实验使用软件读取 COMP 比较结果，不需要配置触发，为了使比较结果更加直观，开启外部比较结果输出。
9 B& O  W7 m  D; w7 S# c
8 R# M' n! x& g
相关操作函数说明：
HAL_StatusTypeDef HAL_COMP_Start(COMP_HandleTypeDef *hcomp)
4 c5 D% r* N: S功能：开启比较器；
1 E1 Z% I  D  d+ _. t8 Q: f参数 1：比较器句柄，根据需要填写；
$ h( J+ s5 w" {- {+ v返回：操作结果，HAL_OK 或 HAL_ERROR；
示例：HAL_COMP_Start(&hcomp3);// 开启 COMP3HAL_StatusTypeDef HAL_COMP_Stop(COMP_HandleTypeDef *hcomp)
功能：关闭比较器；
参数 1：比较器句柄，根据需要填写；
" I& d: r, D$ `/ `返回：操作结果，HAL_OK 或 HAL_ERROR；
uint32_t HAL_COMP_GetOutputLevel(const COMP_HandleTypeDef *hcomp)
' _4 \7 w; o8 S' g$ z5 k7 ?功能：读取比较器输出电平；
参数 1：比较器句柄，根据需要填写；
! x6 a' ~% W+ l7 m! W返回：比较结果，COMP_OUTPUT_LEVEL_LOW 或 COMP_OUTPUT_LEVEL_HIGH；
2 E4 |5 G+ ^7 T8 d( }$ C示例：result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果

* I; C# g6 n+ [8 o! [* j
8 e* ?$ O. o; z2 W+ M; Y7 C. l, S核心代码：
& N* T2 _" h+ j! F  r' \9 {if(HAL_COMP_Start(&hcomp3) != HAL_OK)
# D3 R  |3 E8 V  }8 j- G//开启比较器
{
Error_Handler();
' L* N! b) p7 ~2 p6 c3 T5 b}
while (1)
{
1 A4 s0 a/ D# n" N: Qresult = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
if(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
{
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
}
6 Z+ R1 ]4 f- X* T, y9 THAL_Delay(100);
% ~1 }& o. J& a" ?: |}
% i& X8 R3 T8 F+ V6 @. d, K

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

3 D- g8 y6 f$ g/ {% z5 R
6 q& b! L& ]& l3 N, g) z实验现象：
6 T$ Y6 t/ Y1 M3 [. U! H下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。
* o! I% x" ^' N: K0 f
2、中断读取 COMP 结果实验
CubeMX 配置如下，保存后生成对应的配置代码：
- Q* l" H6 f# G+ V% B2 D* H* k( L5 N: _

▲ CubeMX 进行 COMP 配置
; m0 P& Y! O- g0 c: N9 H9 x2 n% d
" X9 U( w0 n7 b, f( b4 X
' F5 B' x; \/ B$ y) R本实验使用中断读取 COMP 比较结果，在比较结果变化的上升沿和下降沿都触发中断，为了使比较结果更加直观，开启外部比较结果输出。

  f8 Y. z$ V5 z" w/ o
核心代码：
if(HAL_COMP_Start(&hcomp3) != HAL_OK)
0 [- D. C* O- @$ Y5 ^2 u1 A//开启比较器
{
Error_Handler();
4 `4 t# G9 ^1 o( P* u2 ?}
, U. _) l" j/ [+ u, p- M: B7 `1 G& ~8 W

以上为 main 函数中外设初始化结束后的部分，这里只需要开启比较器即可，使用函数与上例相同。

3 v, m" U0 X& g2 ]/ H8 F' N
! `7 G" t$ k; s2 p1 Y- Nvoid HAL_COMP_TriggerCallback(COMP_HandleTypeDef* hcomp)
{
if(hcomp->Instance==COMP3)
{
( _1 l( ~; {+ P2 I) iuint8_t temp;
temp = HAL_COMP_GetOutputLevel(&hcomp3);//读取比较结果
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
7 f1 i3 U; c' l; C3 a6 T) b}
- l/ _9 a0 r; ~- Pelse
{
' ?- ~2 X* P. S& S0 F. AHAL_GPIO_WritePin(GPIOD,GPIO_PIN_10,GPIO_PIN_SET);//熄灭 LED1
( Y! G/ B# w+ h7 B% z. L8 kHAL_GPIO_WritePin(GPIOD,GPIO_PIN_11,GPIO_PIN_RESET);//点亮
LED2
  S0 j8 P$ W5 F! {9 H}
2 ?4 z  C0 r6 a' j+ _}
}


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

' \3 j, `# n  \( ]
- S1 |+ n4 O/ k* o5 [$ S+ K实验现象：
下载烧录后可以观察到拨动拨盘电位器，或者遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED1 灭，LED2 亮，CMP 灭时，LED1 亮，LED2 灭。
$ v- p: t" D! [
5 S& T) E- b+ w2 V' t
" q$ n2 h3 W% y* [9 _3、内部 DAC 级联比较实验
CubeMX 配置如下，保存后生成对应的配置代码：

, E% j7 h- B7 _% V% O& z4 e# O
4 G9 H( p0 h7 L! [0 |▲ CubeMX 进行 COMP 配置


% u. ~9 k9 Q$ |/ E, ^- K! ]▲ CubeMX 进行 DAC 配置


本实验使用软件读取 COMP 比较结果，正相输入为光敏电阻，反相输入使用 DAC3 的 OUT1作为比较电压，为了使比较结果更加直观，开启外部比较结果输出。

9 [4 i( q( C5 L( X  R, n
核心代码：
) }3 v  y) M! F& d2 k4 P4 n. t; E" tvoid DAC3_CH1_Set_Vol(uint16_t vol)
/ c7 s: E2 X! x{
! @6 v& B& X. i% b8 ]double temp=vol;
temp/=1000;
# U% J" o9 B8 K9 ?# [5 ~, xtemp=temp*4096/3.3;
# n: d/ n% T& _( wHAL_DAC_SetValue(&hdac3,DAC_CHANNEL_1,DAC_ALIGN_12B_R,temp);//12 位右对齐数据格式设置 DAC 值
}
4 q! t9 f0 q& |

1 }: q- C0 {: K% o4 w% {3 ]以上为 DAC 设置函数，通过该函数可以将输入的电压快速转换为 DAC 所需的寄存器数据。
* A* O+ x+ |% B, w# i: V( p, H, K# m% {4 r, _

DAC3_CH1_Set_Vol(500);//DAC 输出设置为 500mv
: u% ~  I8 F9 O: p- S! q) U  uHAL_DAC_Start(&hdac3,DAC_CHANNEL_1);//生效 DAC 输出
7 m/ Z% |( E3 kif(HAL_COMP_Start(&hcomp3) != HAL_OK)
//开启比较器
{
' C# A) |; A3 zError_Handler();
}
while (1)
{
result = HAL_COMP_GetOutputLevel(&hcomp3); //软件读取比较结果
if(result == COMP_OUTPUT_LEVEL_HIGH)//比较结果为 1，即 INP 大于 INM
$ Z' W/ b! B& c{
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_11);//翻转 LED2
$ W( P6 Q1 d) {7 D* s; |}
HAL_Delay(100);
}
以上为 main 函数中外设初始化结束后的部分，首先设置好 DAC 输出电压，开启 DAC，然后开启比较器，最后在主循环中每 100ms 读取一次比较结果，如果结果为 1，即正相输入大于反相输入，则进行 LED2 翻转。
: j3 m/ P4 r1 ~. [
9 E/ P4 D5 Y( o2 C( u; J
1 O) Z* k. n( ?' w3 ~, p实验现象：
3 }) s8 p  \/ f% q: H下载烧录后可以观察到遮蔽光敏电阻时可以改变比较结果，CMP 亮时，LED2 状态不变，CMP 灭时，LED2 闪烁。


第十一、FLASH 实验
) l9 J* Z4 \+ G) A9 N5 P, ?实验目的：掌握和熟悉 G474 内部的 FLASH 用法，包括 FLASH 读写应用等。FLASH 读取无需进行配置。

8 b' p! j: T2 a9 j, L
核心代码：
5 {8 r# N9 d6 G1 B1 j/* 函数名：FLASH_Write
* 描述 ：flash 写入数据
' @( T1 A1 p0 q4 v: V/ F* 输入 ：data 写入数据地址 addr flash 地址 size 写入字节数
* 输出 ：无
9 }. y) h7 E" ~* y* 调用 ：FLASH_Write(data,FLASH_PAGE_127,8);//8 字节
*/
uint8_t FLASH_Write(uint8_t* data,uint32_t addr,uint16_t SIZE)
6 Y5 [" M* x( b% X{
( \4 K3 P& j1 x$ H: ]0 LFLASH_EraseInitTypeDef EraseInitStruct;//定义擦写操作结构体
uint32_t SECTORError = 0;
uint64_t write_buff[10];//写入缓冲数组
- f# d* \, r5 @9 `+ L8 w" luint8_t i = 0;
uint8_t size = SIZE/8;//8 字节写入次数
% u8 W* ^& p' `3 P8 Jmemcpy(write_buff,data,SIZE);//将输入的数组移动到写入缓冲区
HAL_FLASH_Unlock();//解锁
3 T3 P2 U, T3 w5 ]  X% vEraseInitStruct.Banks = FLASH_BANK_1; //存储区 1
EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;//页擦除
EraseInitStruct.Page = (addr-0x08000000)/FLASH_PAGE_SIZE;//擦除页
3 [8 N# D3 Z% i+ cEraseInitStruct.NbPages = 1;//擦除页数
- ~' z) z/ j8 L( q) jif(HAL_FLASHEx_Erase(&EraseInitStruct,&SECTORError) != HAL_OK) //擦除页
: ^9 O1 {5 s$ C8 }: a& K{
return 1;//擦除失败
- q: R* x! s9 z$ Q4 l5 r}
) M" h% D2 |1 M& ?/ L( R: w2 mwhile(size)
{
if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD,addr,write_buff)!= HAL_OK)//双字写入
{
return 2;//写入失败
% D, U8 t7 \7 W: G; G}
addr = addr+8;
: T2 Y6 T% J! ?. ]; B! Q$ s% \0 Bi++;
) G) z$ g. ]0 Vsize--;
& k5 o5 C( A2 A/ Z}
HAL_FLASH_Lock(); //锁定 FLASH
5 X; o( y' ?/ N% Ereturn 0;
, v9 u7 m+ W! Q4 }" n" t}
$ y8 B& g4 a9 V& V7 T: l4 Z/* 函数名：FLASH_Read
* 描述 ：flash 读取数据
3 i, a$ p7 u* l1 v% ?  |& |9 U* 输入 ：data 读取数据地址 addr flash 地址 size 读取字节数
* 输出 ：无
( j5 y$ I. j: g; a* o* 调用 ：FLASH_Read(data,FLASH_PAGE_127,8);//8 字节
! H- X9 ]! i' Z( c*/
& P1 \! l4 t6 L  T% u" tuint8_t FLASH_Read(uint8_t* data,uint32_t addr,uint16_t SIZE)
( i  J4 ~+ A/ }; X{
6 j' N$ z8 X7 C7 {1 |4 v; w( D0 K3 suint32_t read_buff[10]; //接收缓冲数组
uint8_t i = 0;
uint16_t size = SIZE/4; //接收次数
% a* j. F- M- H! Q  @3 E; ^- uwhile(size)
" n! n, K* Y# R4 W7 E0 m{
read_buff = *(__IO uint32_t*)addr; //从 FLASH 读取数据到接收缓冲数组
' d4 |. i; R: j# Haddr = addr+4;
i++;
size--;
}
memcpy(data,read_buff,SIZE); //将数据从接收缓冲数组转移到接收数组
return 0;
; ]( d/ }. f% j. Q4 Q6 S' e7 W2 q}

2 Q" d' D) Y) l. K/ z) a
2 R0 k5 ^- i. q: y主要代码：
" R: J2 H' o  X$ Duint8_t data[8]={0,0,0,0,0,0,0,0};
char buf[30]="";
/ C  d$ o4 W) J+ G% p9 KFLASH_Read(data,FLASH_PAGE_127,8);//8 字节
data[0]++;FLASH_Write(data,FLASH_PAGE_127,8);//8 字节
snprintf(buf,10,"times:%d",data[0]);
0 R! _9 \! y  \5 W* ZLCD_PutString(10,30,buf,Red,White,0);
/ B  e! h0 H+ n; o4 K+ r8 ^7 v3 luint32_t UID1=READ_REG(*((uint32_t *)UID_BASE));
uint32_t UID2=READ_REG(*((uint32_t *)(UID_BASE+4U)));
4 G" _( u3 s  M; a. Q! d2 R3 V) Zuint32_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 D0 t2 @# r7 l) y7 K: b0 P# j' G
% W+ `; U- K7 G! y  c
; Q9 Y+ K: I2 y4 Z: g2 M% h( v实验现象：
* b" C$ G8 c0 Z7 B下载烧录后可以观察到 LCD 显示 FLASH 测试次数以及芯片的 ID。

- ?2 D  R0 [* Z& |
, a5 t' ]: H6 A, }+ \4 v2 T7 M9 G  |▲ 实验现象


& k+ W9 R5 [/ F) l) z第十二、单总线实验
  C+ q  w8 n) ~$ S实验目的：掌握和熟悉常用的单总线通信，包括 DS18B20，DHT11 读写应用。
CubeMX 配置如下，保存后生成对应的配置代码：
# Z7 _, Z: x- Q- y, h3 P2 g: a

▲ 图 3.12.1 CubeMX 进行 GPIO 输出配置

$ j7 f9 s+ n9 _" [, `
/ t& k) l0 C2 @本实验进行单总线读取 DS18B20 和 DHT11。使用 CUBEMX 配置 IO 为输出模式。


( s1 q% l* p3 B: m2 l) k9 x读取 DS18B20 核心代码：
/* 函数名：DS18B20_IO_OUT
* 功能：初始化 DS18B20 的 GPIO 为输出模式
* 输入：无
* 输出：无
4 }& W  R" R0 j1 W* 备注：无
*/
& s+ K0 P' q8 @void DS18B20_IO_OUT(void )
# O# H' Y5 c# `) ?# N. G{
9 J( J, C+ y! }5 X  `GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
; D9 G1 _" \3 W; j8 |GPIO_InitStruct.Pull = GPIO_NOPULL;
3 c! g: P! U1 R% dGPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
}
/* 函数名：DS18B20_IO_OUT
* 功能：初始化 DS18B20 的 GPIO 为输入模式
* 输入：无
) n( S& {! S; v) I4 o3 G0 _: |* 输出：无
* 备注：无
& a0 e6 o; _+ p& o*/void DS18B20_IO_IN(void )
- P% E( t8 X+ j% C# L{
7 b4 T/ v" B- ~. EGPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = GPIO_PIN_9;
: U% l: w2 a5 n- r- U  AGPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
5 d, h# x4 M9 O: p' yGPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
" Z. q( E! n9 l2 x  K. jHAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
}
/* 函数名：DS18B20_Rst
* 功能：复位 DS18B20
- F# r$ k, R9 F) A, l- U* 输入：无
8 g+ ~/ d% q; s3 f' P0 G( K* l. X; J* 输出：无
/ S# x3 H, \' [; F. D2 F7 F0 Y% \  j* 备注：无
/ s8 l$ f0 b8 v5 b- Q3 I1 f*/
void DS18B20_Rst(void)
{
DS18B20_IO_OUT(); //SET PG11 OUTPUT
DQ_OUT_LOW();
//拉低 DQ
delay_us(750);
//拉低 750us
DQ_OUT_HIGH();
//DQ=1
delay_us(15);
//15US
; R1 C& z$ G' q6 l* e4 ^3 Z}
/* 函数名：DS18B20_Check
& l6 A& v  [1 y2 I5 X/ L5 [9 k* 功能：等待 DS18B20 的回应
* 输入：无
* 输出：返回 1:未检测到 DS18B20 的存在 返回 0:存在
* 备注：无
" n8 I- E& Q8 o% Y; G8 I* A2 Y! b*/
uint8_t DS18B20_Check(void)
{
7 ~7 f2 S2 p; e  G  k4 Luint8_t retry=0;
DS18B20_IO_IN();
//SET PG11 INPUT
while (DQ_GET_IN()&&retry<200)
9 C: s5 o% N, s* \, l2 _* F{
5 U8 b, k/ Z: X! X) p% |) ^+ Rretry++;delay_us(1);
# e5 f4 U2 N* w1 U; q4 o. _};
. w8 |5 v$ x9 J8 j9 Mif(retry>=200)return 1;
* ?3 A" c+ s5 A1 delse retry=0;
while (!DQ_GET_IN()&&retry<240)
5 u. n5 K# l9 k5 R# j" X{
retry++;
8 Q3 v0 _  R( r  o, K8 a5 M( Rdelay_us(1);
};
if(retry>=240)return 1;
4 v2 z1 k) n8 e9 h( h: Yreturn 0;
}
/* 函数名：DS18B20_Read_Bit
0 w8 Q) J9 _6 t0 L* 功能：从 DS18B20 读取一个位
+ a6 F' b! ]" T* 输入：无
8 k6 a# W8 E* A2 t, I. j6 J& B* 输出：返回值：1/0
9 X+ V0 {- d+ T- d) F* 备注：无
*/
; G3 A0 v8 q/ Y1 x& i# W5 O7 Puint8_t DS18B20_Read_Bit(void)
8 U5 T( q* a+ R" v{
3 S& V5 L) R# ~5 ^6 ]! H9 Yuint8_t data;
DS18B20_IO_OUT(); //SET PG11 OUTPUT
3 l6 N; D* |5 r1 a1 ^  g7 SDQ_OUT_LOW();delay_us(2);
8 l3 d, P( u% _9 J/ BDQ_OUT_HIGH();
DS18B20_IO_IN();
//SET PG11 INPUT
delay_us(12);
: Q6 }, y) f& f- Wif(DQ_GET_IN())data=1;
else data=0;
delay_us(50);
return data;
4 h( \1 E( z! Z" t7 z}
/* 函数名：DS18B20_Read_Byte
* 功能：从 DS18B20 读取一个字节
4 d5 X: N* F; x* 输入：无
* p. v4 o! {0 {3 D* 输出：返回值：读到的数据
* 备注：无
*/
uint8_t DS18B20_Read_Byte(void)
  U" c# j0 k1 ?$ D: D) Z) d{
uint8_t i,j,dat;
dat=0;
for (i=1;i<=8;i++)
{
j=DS18B20_Read_Bit();
1 O9 D; S. b+ E& `dat=(j<<7)|(dat>>1);
, D; q5 y& V4 b& J4 z}
return dat;
$ ?5 ?. W4 h* k" E1 v0 H}
/* 函数名：DS18B20_Write_Byte
9 o) X% Y0 p) L1 u* 功能：写一个字节到 DS18B20
* 输入：dat：要写入的字节
* 输出：无
* 备注：无
$ N7 h  C! t  x7 Z# [. T( x*/
) B- @+ ]+ X5 K6 H( L3 Tvoid DS18B20_Write_Byte(uint8_t dat)
{
uint8_t j;
3 g5 D5 a, q( D4 `/ Puint8_t testb;
DS18B20_IO_OUT(); //SET PG11 OUTPUT;
for (j=1;j<=8;j++)
{
4 Q6 |( k1 _7 y; B/ Ltestb=dat&0x01;
3 w$ D* Z7 O7 _: ]6 l% Wdat=dat>>1;
! o' m' Q4 H9 J9 h% T3 s% aif (testb)
{
- }4 o! K$ n1 A; H5 d' LDQ_OUT_LOW(); // Write 1
delay_us(2);
+ C( K* \. }, q0 F) vDQ_OUT_HIGH();
delay_us(60);
}
else
{
" ?' j, s6 j; vDQ_OUT_LOW(); // Write 0
delay_us(60);
DQ_OUT_HIGH();
- E( `# o% |9 J% X7 T. I4 q" }7 v3 udelay_us(2);
}
}
  N7 j1 ~- G% F. V}
! @% R- M( [$ z, U  o& ]: F/* 函数名：DS18B20_Start
* 功能：开始温度转换
1 Y, q9 Q: Q. S. S* 输入：无
* 输出：无
* 备注：无
*/
5 w( \% c+ f* g( \5 ~//
void DS18B20_Start(void)
{
( Z. g- ^4 e' l% \DS18B20_Rst();
DS18B20_Check();
DS18B20_Write_Byte(0xcc);// skip rom
  c& q1 o- p" x# ~* s' L: H2 GDS18B20_Write_Byte(0x44);// convert
3 j' U, B& }' N7 W}
1 m: G7 R7 w4 x8 _/*
3 |- C4 g% {9 q 函数名：DS18B20_Start
' s7 L* ~2 S' Y1 B* 功能：从 ds18b20 得到温度值 精度：0.1C
* 输入：无
* 输出：返回值：温度值 （-55.0~125.0）
* 备注：无
+ s) u; [& I5 x2 h. A*/
  S9 M  g6 H8 X) S: M; k6 G/ `short DS18B20_Get_Temp(void)
% u5 f: x- D& S7 w, r( P3 R{
  e$ Z4 Y; Q9 ^. X1 ruint8_t temp;
uint8_t TL,TH;
short tem;DS18B20_Start ();
- f2 e7 {2 M* H; f, d  W7 o6 O3 X// ds1820 start convertDS18B20_Rst();
DS18B20_Check();
3 ?! L, b  Q6 o" }9 S. s, kDS18B20_Write_Byte(0xcc);// skip rom
DS18B20_Write_Byte(0xbe);// convert
TL=DS18B20_Read_Byte();
// LSB
) s( F1 A# C8 z0 e# Y0 ^TH=DS18B20_Read_Byte();
# d. C8 D; j; h  }# d+ G// MSB
if(TH>7)
{
- Q! C7 C) w* ?( ^4 sTH=~TH;
5 o  }. ?: V+ [- N' p/ wTL=~TL;
- |, t+ z/ Y8 k) i2 |" _6 wtemp=0;
//温度为负
# l  V! P: I8 o) _: M0 `* d, P}else temp=1;
//温度为正
2 o, {* l+ B' `6 Etem=TH;
//获得高八位
* J" }3 i( m6 }; Ftem<<=8;tem+=TL;
2 w. K2 s  k  ~2 E* I( r( u//获得底八位
# Q8 ^4 o8 O- e% \+ @1 I* {/ ctem=(float)tem*0.625;
//转换
char 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);
7 J& n* y1 [! U- _if(temp)return tem;
8 F1 r/ i0 Z! H  S; A7 e//返回温度值
% y( c% w0 S' j6 K( C! D4 L3 lelse return -tem;
}
7 q( M, ~3 n! I6 p  U% |) k读取 DHT11 核心代码：
/* 函数名：delay_us
* 功能：微秒延时
, d' D! ^0 ^& `4 F; ~* 输入：delay 延时多少微秒
* 输出：无
( H& ^) R1 t( w2 u* 备注：无
*/
#define CPU_FREQUENCY_MHZ 170
// STM32 时钟主频
void delay_us(__IO uint32_t delay)
{
; f3 c3 M: M2 {; Q$ ^9 V# ], Gint last, curr, val;
6 w, N. B! y& e6 pint temp;
while (delay != 0)
{
9 I2 C) M* _3 Z: Z9 Ztemp = delay > 900 ? 900 : delay;
- Z5 l" M6 b5 m: l) M1 llast = SysTick->VAL;
curr = last - CPU_FREQUENCY_MHZ * temp;
6 M: V) `, o& g' |# z& sif (curr >= 0)
6 t  n8 G1 |; T  v{
do
{
val = SysTick->VAL;
}
while ((val < last) && (val >= curr));
, }, |% ?' i0 K% }% B& ^7 n, z}
else
{
curr += CPU_FREQUENCY_MHZ * 1000;
do
$ @: l1 O+ a% q- U{
0 d: l, u8 b: aval = SysTick->VAL;
}
* ]# A6 n0 E$ a9 M* Vwhile ((val <= last) || (val > curr));
}
delay -= temp;
}
}
unsigned int rec_data[4];
/* 函数名：DH11_GPIO_Init_OUT
; ^) }! N7 d- d4 X0 d* 功能：初始化 DHT11 的 GPIO 为输出模式
* 输入：无
# Z3 [2 B: X. @4 h9 z* 输出：无
* 备注：无
' s2 A2 {# T2 R% y9 w*/
2 e+ I: m  j, {1 Uvoid DH11_GPIO_Init_OUT(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
+ Y9 y* N1 y  N( u3 C- DGPIO_InitStruct.Pin = GPIO_PIN_9;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
# |2 E% Q9 ?8 b: rGPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
2 L* G. p$ ?: k5 t/ s2 z  JHAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
$ [9 d: f/ h2 p8 x3 f% r& V  U) K}

1 i6 W+ ~( U: h* S, m! g// 对于 M0 来说，是输入
1 o; h: `# w0 Z+ I9 l4 Q: q/* 函数名：DH11_GPIO_Init_IN
, O5 ~* p% x$ ~% R; l8 s8 V* 功能：初始化 DHT11 的 GPIO 为输入模式
* L! Y. z5 h& S/ }3 r6 D6 @' z3 F0 z* 输入：无
/ n) T$ ]5 u+ x- ^0 c% T* 输出：无
* 备注：无
*/
2 c# E6 W3 \8 M/ b4 y: kvoid DH11_GPIO_Init_IN(void)
1 X# |. e' p  k. Z{
6 f3 {& J  ]* A5 b$ F  ]GPIO_InitTypeDef GPIO_InitStruct = {0};
5 M! ~6 m0 G9 w$ DGPIO_InitStruct.Pin = GPIO_PIN_9;
# X8 H8 `* U" |+ M* [, |GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
, H0 r! j* U4 Q/ J. [GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
/ _2 N9 I; r) v( ^7 R: O& xHAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
! `1 t( i5 N! S9 y  ~// DL_GPIO_initDigitalInput(GPIO_DQ_dht11_and_ds18b20_IOMUX);//配置为上拉输入
, i2 B( g6 y7 `1 z, i( x5 M0 Z1 h}
6 n" h! ^& D! }/ d* O7 y5 d// 主机发送开始信号
: y$ Q# u9 g) n& N6 Y/* 函数名：DHT11_Start
/ C) V. T! Z3 {6 a5 G* 功能：主机发送开始信号
* 输入：无
* 输出：无
* 备注：无
*/
3 N1 P* i6 P# B" F- ]- Dvoid DHT11_Start(void)
{
DH11_GPIO_Init_OUT(); // 输出模式
8 p1 S) C$ f, F( Ndht11_high; // 先拉高
" W% ^3 O9 t; ?0 ~delay_us(30);
$ e/ _# B3 q3 [* ^6 [dht11_low; // 拉低电平至少 18ms
9 V( [/ u+ E4 P) JHAL_Delay(20);
- ?+ ?$ L2 i% x- m; N6 j+ ldht11_high; // 拉高电平 20~40us
4 ]0 H: X! Q7 w3 S, v; D( P# _DH11_GPIO_Init_IN(); // 输入模式
delay_us(30);
. }! t! U2 T) a1 c1 D}
// 获取一个字节
/ f/ I8 c3 u0 b$ K& u/* 函数名：DHT11_Rec_Byte
. c: K. ]6 S: `* c8 \4 t* 功能：获取一个字节
* 输入：无
* R. @/ e1 @! o/ S" q9 V7 \8 a/ Z* 输出：读取的字符
8 `0 P3 C8 G) [% L6 C% w5 }3 T) _* 备注：无
  Q9 m# E3 m3 ]* ~) o*/
; K3 ?) z/ Y" p! W$ i- H( t! qchar DHT11_Rec_Byte(void)
{
9 y/ n# P' n1 D- U! @unsigned char i = 0;
& m% J: v' M1 J5 ^9 nunsigned char data;
for (i = 0; i < 8; i++) // 1 个数据就是 1 个字节 byte，1 个字节 byte 有 8 位 bit
{
while (dht11_read == 0)
;
// 从 1bit 开始，低电平变高电平，等待低电平结束
delay_us(30); // 延迟 30us 是为了区别数据 0 和数据 1，0 只有 26~28us
data <<= 1; // 左移
9 V+ Z* [4 i& Hif (dht11_read == GPIO_PIN_SET) // 如果过了 30us 还是高电平的话就是数据 1
{
data |= 1; // 数据+1
9 C3 r! H9 s) f9 E* j4 R3 K}
while (dht11_read == GPIO_PIN_SET)
; // 高电平变低电平，等待高电平结束
/ C# Z% a0 w, [7 N; m; f}
" Z* s% v; f. I" D* v$ t! q3 Creturn data;
$ j+ Z) T5 K" B$ m! r: a}
6 c- @! w* Z7 ~, ^% `$ _// 获取数据
: h( ]# V% J) ], B. \& y/* 函数名：DHT11_REC_Data
6 U+ T; u+ |& p) z4 D0 `* 功能：获取 DHT11 数据并打印
% U" ]; _* L) {1 R4 |( d* 输入：无
  W- @$ L& r. L* 输出：无
* 备注：无
# [5 S1 S( n9 x& g& x3 [: Y- P% w*/
) B3 B/ s6 X& a/ b, v" h" K! y. Tvoid DHT11_REC_Data(void)
: B3 v$ ^2 Y& q2 o{
unsigned int R_H, R_L, T_H, T_L;
unsigned char RH, RL, TH, TL, CHECK;
DHT11_Start(); // 主机发送信号
* X( ~& Z+ f& y; q//dht11_high; // 拉高电平
if (dht11_read == 0) // 判断 DHT11 是否响应
" k$ o& t( \& T( q{
- J. V) Q' x% |8 gwhile (dht11_read == 0); // 低电平变高电平，等待低电平结束
. m3 y" X5 X* u6 {* B' ywhile (dht11_read == GPIO_PIN_SET); // 高电平变低电平，等待高电平结束
R_H = DHT11_Rec_Byte();
R_L = DHT11_Rec_Byte();
$ ^) u; _6 V6 p! KT_H = DHT11_Rec_Byte();
T_L = DHT11_Rec_Byte();
, \8 U6 g0 X4 kCHECK = DHT11_Rec_Byte(); // 接收 5 个数据
- U7 B1 d; c9 K+ i7 ]2 Q//DH11_GPIO_Init_OUT();
; D# L) H' A" \: X" Y& h//dht11_low; // 当最后一 bit 数据传送完毕后，DHT11 拉低总线 50us
9 t" I2 |" W" z* }) @delay_us(55); // 这里延时 55us
//dht11_high; // 随后总线由上拉电阻拉高进入空闲状态。
' u  ]2 p6 X$ F, pif (R_H + R_L + T_H + T_L == CHECK) // 和检验位对比，判断校验接收到的数据是否正确
0 s+ C9 R7 E# l5 }& Q1 E{
RH = R_H;
; [8 E  L7 p2 C. v% tRL = R_L;
TH = T_H;
( R+ b" _) }. r1 ~0 s" CTL = T_L;
! y# G1 g1 E7 }. q5 g5 S2 m/ G}
}
* ?8 J) w5 K* W: j+ Y7 B" i
: G1 y4 t, @1 C/ u+ x# W
1 G  T2 D- h& u1 o- F3 y2 [9 {) q3 rrec_data[0] = RH;
rec_data[1] = RL;
! L( z" G! O; F/ ?/ }& krec_data[2] = TH;
! _1 C; }) V: w9 J6 w6 ^) p8 jrec_data[3] = TL;
char buf[20]="";
! ?$ E/ Y0 ~0 z- qsnprintf(buf,10,"Temp:%d.%d",TH,TL);
- a" a: M# i( o# l6 M7 QLCD_PutString(10, 10, buf, White,Blue,1);
snprintf(buf,10,"Hum:%d.%d",RH,RL);
, P( ?% ^% ]7 H' S) Q- C3 KLCD_PutString(10, 30, buf, White,Blue,1);}

; l: N. J( L/ ^# b- [# r6 G
3 I4 s6 @( j& a$ i/ r主要代码：
* Q; F, e7 Q8 U& }while(1){
DHT11_REC_Data();//DHT11 读取
% l3 k* P- v7 U8 j//DS18B20_Get_Temp();//18B20 读取
& c" u2 I/ k7 ]  |/ z1 nHAL_Delay(1000);
3 l" E2 B; ?5 b6 n2 ?# I$ H}
6 q& [" y4 n' g
9 G% h% G8 t* v
实验现象：
* D' e7 S1 m5 `, f7 z$ g下载烧录后可以观察到 LCD 显示 DS18B20 测试的温度，或者 DHT11 测量的温度和湿度。
# u& h5 V9 K9 p5 o( v

7 U' J( K* ^% H/ e! o9 M+ m▲ 图 3.12.2 实验现象
- a7 k; S; p9 j% U1 Y
5 Y8 b/ K: t. [$ ?' n0 X  j1 {第十三、独立看门狗
实验目的：掌握和熟悉独立看门狗用法，包括喂狗操作等。
0 W9 n0 r& B7 q* |$ s& `/ `
, K3 \/ X) i' R, x. S/ VCubeMX 配置如下，保存后生成对应的配置代码：
% z8 z1 A; q2 A' J# K
▲ 图 3.13.1 CubeMX 进行独立看门狗配置
9 [. v$ u& e4 d* ~
( U: ?. h2 U5 ?$ b$ ]2 f本实验进行独立看门狗配置。使用 CUBEMX 配置 IO 为输出输入模式实现 LED 指示和按键读取，GPIO 配置参考上文。程序中使用按键喂狗，如果没在 1s 内喂狗，系统将会自动复位。
7 e  Z9 l+ @! ^- n
主要代码：
) B8 d. v9 ^' y% Z! E4 Owhile (1)
{
, B8 }- w* A0 bif(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
{
9 W% o3 O' Y. E7 H& QHAL_Delay(5);
+ N: Q$ S$ v) Sif(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==0)
& \+ a; |. T7 j7 y7 {! Y. t* U0 b, {{
% j' n6 O, L1 d4 i% RHAL_IWDG_Refresh(&hiwdg);
HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_10);
, S! d$ P  g' s6 y- l- Zwhile(!HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4));
1 O7 y( G  r) @# D+ x" e6 e) u}
}
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
' s. v$ o5 _0 Q2 P6 L}

1 c& h1 D+ x$ s  ?# D8 q; U
实验现象：
; `  [1 u$ |9 r' K9 n* c- y1 k下载烧录后可以观察到如果在一定时间内进行喂狗操作，系统会复位，LCD 重新加载。

▲ 图 3.13.2 实验现象


转载自： AI电堂
$ M' X; B7 [9 Z+ c; s1 A如有侵权请联系删除
  \( L! t2 b: b: c- T" r2 D: @
. ?# n' F) V, ^/ {# a" g/ M