问题描述：





设计一款背诵英语单词的软件。用户可以根据自己的需求导入需背诵的词库，并可以编辑自己的词库。背单词时有两种模式供选择：系统可以给出中文提示，用户输入对应的单词，也可输出单词让用户输入中文意思。系统判定词义是否正确。如果正确成绩加十分，如果不正确给出提示并要求用户重新输入。

2. 功能要求：

代码要能提供以下几个基本功能：

（1）用户登录：

新用户可以注册，旧用户直接登录。

可以只打卡不背词，直接退出界面。

（2）单词本：

存储单词基本信息，英文、词性、中文解释等。

选择词库维护编辑单词本信息，实现增加、修改、删除、补充（单词已有，补充新的释义）的功能。

（3）单词背诵及成绩统计：

选择单词预览进行单词学习。

单词背诵时有两种模式选择，选择题背诵及拼写单词背诵，而且支持多次背诵。

答对加十分，答错扣十分，错词计入错题本。

可查阅自己的总成绩，未达过关成绩可以选择错题重背直至完全掌握。

（4）单词复习：

背诵完全正确时界面显示没有错题继续努力。

有错题时可以选择错题重背加强记忆。

（5）退出系统时可以进行打卡，统计背诵单词天数。

选做要求：

（1）对用户的输入进行一定的正确性检查。

（2）能统计每一个单词出现频率及背诵正确率，供以后出题时提供依据。

（3）能设置提醒功能，激励大家坚持下去。



python+Qt5+sqllite做的：

【已开发完成，需要可私】

![在这里插入图片描述](/static/img/images/03774.png)

python+Qt5+sqllite 个性化单词记忆软件设计

功能：





1 超声波测距显示

2 按键设置报警上下限

3 蜂鸣器报警

原理图：

![在这里插入图片描述](/static/img/images/03828.png)

PCB样式：

![在这里插入图片描述](/static/img/images/03829.png)

实物：

![在这里插入图片描述](/static/img/images/03830.png)

![在这里插入图片描述](/static/img/images/03831.png)

代码：

https://github.com/xxddccaa/blog_code_search

【TB作品】基于MSP430G2553单片机的超声波测距与报警系统，原理图，PCB

![请添加图片描述](/static/img/images/03885.png)





![请添加图片描述](/static/img/images/03886.png)

![请添加图片描述](/static/img/images/03887.png)

![请添加图片描述](/static/img/images/03888.png)

下载：https://github.com/xxddccaa/blog_code_search

晨启，MSP430开发板，51开发板，原理图，PCB图

# 芯片介绍





芯片介绍： [https://qq742971636.blog.csdn.net/article/details/132164189](https://qq742971636.blog.csdn.net/article/details/132164189)


DS2431内部有128个字节的数据，这篇博客可以对这128个字节的数据进行读写，而有的人想要改写芯片ROM，这是芯片的唯一地址，请看这里 [https://blog.csdn.net/x1131230123/article/details/135667146](https://blog.csdn.net/x1131230123/article/details/135667146)


接线

![在这里插入图片描述](/static/img/images/03985.png)



![在这里插入图片描述](/static/img/images/03986.jpeg)


串口结果：

![在这里插入图片描述](/static/img/images/03987.png)


# 进一步设计

很多用户希望快捷读取和写入芯片，为此专门设计了一个程序，有需要可以私，用法如下：

接线方式参考下面这个图：

CH340是串口模块，和单片机接线四根：

3V3--------单片机的3V3

GND--------单片机的GND

TXD--------单片机的PA10

RXD--------单片机的PA9

DS2401或者DS28E07，和单片机的接线两根：

GND--------单片机的GND

IO--------单片机的PA1


![在这里插入图片描述](/static/img/images/03988.png)


CH340插电脑上，打开电脑串口助手软件XCOM，选择正确com口，然后点击打开串口：

![在这里插入图片描述](/static/img/images/03989.png)

打开串口后，按一下单片机的复位按键，则单片机会读取DS2431的信息。会看到芯片里目前的ID码和数据，ID码是固定不可修改的，数据是128个字节，一个字节就是类似十六进制的0x15，也可以看到芯片里目前的保护页状态，一旦保护后，对应页的数据也无法更改，只有保护页数据是0x00，才能修改对应页。下图中，保护页1的数据是0xAA，这说明保护页1的数据不可更改。

![在这里插入图片描述](/static/img/images/03990.png)

自己可以用txt中写128个字节的数据，点击发送给单片机，只要是大小写的a到f，数字0到9，都会被单片机程序识别到，如果是128个数据，单片机就会执行写入操作，会写入到芯片128个字节。

![在这里插入图片描述](/static/img/images/03991.png)

下图是点击发送后的状态，会显示出当前收到的128个数据是什么，并执行写入，可以看到页1因为保护了所以写入不了，其他页都已经正常写入。

![在这里插入图片描述](/static/img/images/03992.png)






# 代码、帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【单片机】DS2431，DS28E07，STM32，EEPROM读取与写入，解密破解

简易电压采集装置（限MSP430、STM32单片机）





任务要求：

设计制作一个简易电压采集与显示装置，实现如下基本功能：

评分细则：

1.通过单片机内部ADC模块采集1路电压并通过OLED屏显示电压大小；（30分）

2.能够同时采集并显示3路电压；（15分）

3.当采集到的电压在电压为0-1v的时候led2和led3亮，电压为1-2v时，led4-led5亮，大于2v时，led6-led7亮，蜂鸣器响起警报，同时OLED显示“采集的电压过大！”；（20分）

4.LED的亮度能够随着采集到的电压大小变化（通过PWM波调控LED的亮度）（35分）。

【注释】

STC89C51单片机无内部ADC转换模块，不建议选择该题！

单片机的ADC输入电压不应超过3.3伏，否则会烧毁单片机。MSP430最大采样电压2.5伏。

根据单片机手册自行选择单片机ADC引脚进行采集。

一节干电池的电压在1.5伏左右，可以试着测量一节干电池的电压。实验过程可以使用杜邦线将单片机的AD采样引脚与手柄板上的电位器输出引脚TAD1或者TAD2（实际引脚在显示屏下方）连接，转动电位器可改变单片机采集到的电压大小。

 

涉及的单片机内容以及口袋开发板模块：

单片机：I/O功能、显示接口、A/D转换

口袋开发板：流水灯、独立按键、A/D转换、蜂鸣器、电位器、OLED显示屏


代码：https://github.com/xxddccaa/blog_code_search

【单片机】晨启科技，酷黑版，简易电压采集装置

密码锁





任务要求：

当输入密码（至少6位密码）时，OLED显示屏显示输入的数字（或者字符），当密码位数输入完毕按下确认键时，对输入的密码与设定的密码进行比较（可使用外设键盘）。主要完成如下功能：

评分细则：

1. 显示屏显示密码输入情况（20分）；

2. 每按下一个按键，蜂鸣器发出一声短暂的提示音（10分）；

3. 如果密码输入正确，显示屏显示密码输入正确提示，蜂鸣器发出短暂的提示音（20分）；

4. 如果密码输入错误，显示屏显示密码输入错误提示，蜂鸣器发出长响警告音，流水灯模块闪烁（20分）；

5. 具有输入撤销键，当按错按键时，有撤销功能（15分）；

6. 连续输入错误3次，键盘被冻结1分钟，这1分钟内无法输入。（15分）。

【注释】

口袋开发板上标注A6为撤销键，A7为确认键。STC89C51、MSP430、STM32单片机密码输入键为A2、A3、A4、A5四个键，共四个数字（或者字符）；哪一个键代表什么数字（或字符），使用者可自定义（不同批次产品按键标识略有区别，可参考上述注意事项）。


涉及的单片机内容以及口袋开发板模块：

单片机：I/O功能、中断系统、定时\计数、显示接口

口袋开发板：流水灯、独立按键、蜂鸣器、OLED显示屏


下图是430单片机做的密码锁：

![在这里插入图片描述](/static/img/images/04081.png)



代码：

```cpp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

带原理图和PCB:

![在这里插入图片描述](/static/img/images/04082.png)

![在这里插入图片描述](/static/img/images/04083.png)

【单片机】MSP430F149，单片机，晨启科技，酷黑，密码锁

四、音乐播放器





任务要求：

设计制作一个简易音乐播放器（通过手柄板上的蜂鸣器发声，播放2到4首音乐），同时LED模块闪烁，给人视、听觉美的感受。

评分细则：

1. 按下播放按键A6开始播放音乐，再次按下停止播放；（20分）

2. 按下按键A5播放下一首，按下按键A4播放上一首；（20分）

3. 播放音乐时OLED显示相应的曲目名；（20分）

4. 当按下“下一首”或者“上一首”按键，但是已经播放至最后一首时，显示屏显示“无更多曲目！”，同时蜂鸣器报警三秒钟；（20分）

5. 歌曲名横向滚动显示；（10分）

6.具有音乐播放模式切换键，播放模式有单曲循环、顺序播放、随机播放三种模式。（10分）

【注释】

要求可以播放2至4首音乐，音乐节拍可通过网络等渠道收集。LED模块的闪烁方式不做要求。

涉及的单片机内容以及口袋开发板模块：

单片机：I/O功能、定时/计数器、显示接口

口袋开发板：独立按键、OLED显示屏、蜂鸣器

 


四个按键：

摇杆单击和双击构成四个按键。

蜂鸣器音乐：有源蜂鸣器不太好听。

![请添加图片描述](/static/img/images/04084.jpeg)

代码：

```cpp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

![在这里插入图片描述](/static/img/images/04085.png)

【51单片机】晨启科技，酷黑版，音乐播放器

抢答器





任务要求：

四名选手各有一个抢答按键，按键的编号以及指示灯（手柄板上的LED模块）的编号与选手的编号相对应，抢答器具有编号的识别和数据的锁存、显示以及提示音功能。

评分细则：

1. 裁判按下开始键后，显示屏显示答题倒计时1分钟（25分）；

2. 在答题时间内，若有选手按下抢答按键，则在OLED显示屏上显示相应的编号，与选手对应的指示灯点亮（指示灯使用开发板上的LED灯模块）并且蜂鸣器发出短鸣提示音。（25分）

3.程序应具备自锁功能，在第一个选手按下按键后其他选手再按按键无效，第一个抢答的选手编号一直保持到裁判按下复位键；（20分）

4. 若在答题倒计时结束仍未有选手按下抢答键，蜂鸣器发出长鸣提示音；（20分）

5. 当裁判按下复位按键，清除数据，完成一次抢答流程，1分钟倒计时重新开始。（10分）

【注释】

按键A6为抢答开始键、按键A7为数据清零（复位）键；

MSP430、STC89C51、STM32单片机选手抢答键为A2、A3、A4、A5四个键，分别对应编号1~4。

涉及的单片机内容以及口袋开发板模块：

单片机：I/O功能、定时/计数器、中断系统、显示接口

口袋开发板：流水灯、独立按键、蜂鸣器、OLED显示屏





左边的扭杆按下，是开始。

右边的扭杆按下，是复位。

![在这里插入图片描述](/static/img/images/04086.png)

代码：

```cpp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

![在这里插入图片描述](/static/img/images/04087.png)

【51单片机】晨启科技，酷黑版，四位选手抢答器

三、通信聊天





任务要求：

用单片机实现与串口调试助手的通信，具体功能如下:

1、通过蓝牙模块（需要领取，如果使用笔记本电脑做该题，则只需要领取一个蓝牙模块，如果使用台式机则需要领取两个蓝牙模块外加一条USB转TTL线，尽量使用笔记本电脑，简化工作，学院的USB转TTL线并不多）实现与电脑串口调试助手的连接；（15分）

2、设定单片机的两种运行模式：接收消息/发送消息，同时按下按键A6和A7进行模式切换；（20分）

3、实现由电脑串口调试助手发送字母或数字给单片机，并由开发板OLED显示出来。(20分)

4、从PC端串口助手发送一个字符串到单片机，OLED显示屏显示该字符串，并通过按键上下左右选择其中任意一个字符，并将选中的字符发送回PC端。其中按键A4为上移方向、A5为下移方向、A6为左移方向、A7为右移方向。（25分）

5、单片机发送字符成功后流水灯亮起，接收到消息后蜂鸣器发出短暂声响。（20分）

附加题：

自行编写上位机软件与单片机通信，编程语言不限，基本功能必须有发送数据和接收数据并显示的功能。

【注释】

1、已提供串口调试助手软件；

2、蓝牙模块需要同学们自己外接，手柄板上有现成的接口，如需详细了解其引脚连接，可查看手柄板原理图。此部分涉及知识为串口通讯，蓝牙模块更多信息请参考说明书或网络资料。

3、请同学们根据自己情况搭配杜邦线（学院每位同学提供五根）与口袋开发板外接引脚（排针）连接，详见实验板数据手册。

![在这里插入图片描述](/static/img/images/04386.png)

部分程序：

```c
/*
 * 引脚说明：
 * KEY:
 * P1.2 返回1  在发送模式下，按一下就发送字符
 * P1.3 返回2  上 只有在发送模式下可以用
 * P1.4 返回3  下 只有在发送模式下可以用
 * P1.5 返回4  左 只有在发送模式下可以用
 * P1.6 返回5  右 只有在发送模式下可以用
 * 时按P1.5 P1.6 返回6  切换接收/发送
 * BEEP:P5.6
 * 指示灯:P6.7
 * 8个LED:P4
 * OLED CS P3.0    DC P2.7   RST P2.6 D1 P3.1   D0 P3.3
 * 蓝牙串口UART1:P3.6tx   P3.7rx 9600波特率
 * 功能说明:
 * 1 总体说来系统是一个聊天功能
 * 2 依靠同时按P1.5 P1.6 来修改系统为发送模式或者是接收模式
 * 3 接收模式状态下指示灯点亮,发射模式下只是灯不亮
 * 4 接收模式下单片机可以接收电脑发送的字符串，每接受一帧字符串单片机蜂鸣器就要响一声
 * 接收的字符串全部存入暂存区并在oLED中显示出来,最多可以接收64个字符
 * 5 发送模式下,用户可以通过上下左右按键选择某一个字符
 * OLED会将选择的字符以不一样的方式显示出来
 * 中一个字符后可以按1.2按键将选中的字符发送到电脑
 * 发送成功流水灯会亮一下
 * 特殊说明：
 * 1 转接板上面有复位按键
 * 2 蓝牙模块使用5伏直流电压供电
 * 3 使用的是串口1
 * 4 user.c里面存放初始化程序和按键检测程序
 * 5 isr.c里面存放定时器中断程序和串口接收中断程序 定时器中断程序中会有判断流水灯和判断接收一帧数据是否完毕的逻辑
 * 6 task_oled.c里面存放oLED的显示驱动代码
 */
char taskBusy;
void main( void )
{
 unsigned char temp;
 char  len_temp = 0;
 WDT_Init();                                                                             /*看门狗设置 */
 Clock_Init();                                                                           /* 系统时钟设置 */
 User_SystemInit();                                                                      /* 用户控制系统初始化函数 */
 Timer_Init( TimerA, 10000 );                                                            /* 10ms定时器中断 */
 UART_Init( UART0, 9600 );                                                               /* 初始化串口 */
 GPIO_Set( P6, 7, sys_mode_rt );                                                         /* sys_mode_rt=0蓝色灯点亮 表示处于接收模式 =1不亮表示处于发送模式 */
 memset( receive_data_buff, ' ', 64 );                                                   /* 初始化数据暂存区 */
        TBCCTL0 = CCIE;                         /* CCR0 interrupt enabled */
        TBCCR0 = 1000;
        TBCTL = TBSSEL_2 + MC_0 + ID_3; //关闭蜂鸣器
 _EINT();                                                                                /* 打开总中断 */
 while ( 1 )
 {
  /* 更新接收到的字符串 */
  if ( len_temp != receive_data_length )                                          /* 检测到接收字符串长度有变化=只是说有新接收到一帧数据 */
  {
   len_temp = receive_data_length;                                         /* 把新的数据长度负责给暂存变量 */
   if ( receive_data_length <= 64 )
   {
    OLED_DisplaysCertainLengthString( receive_data_buff, 64 );      /*有新接收到一帧数据=就需要重新刷新显示 */
   }
  }
                //蜂鸣器控制
  if ( receive_finish == 2 )                                                      /* 这个条件表示一帧数据已经接收完毕 */
  {
   receive_finish = 10;                                                    /* 重新将receive_finish负值为一个不相关的变量 不是012即可 */
                        TBCTL = TBSSEL_2 + MC_1 + TBCLR + ID_3; //打开蜂鸣器
                        delay_ms(30);
                        TBCTL = TBSSEL_2 + MC_0 + ID_3; //关闭蜂鸣器
   GPIO_Set( P5, 6, 0 );                                                   /* 关闭蜂鸣器 */
  }
  temp = TestKeyInput();                                                          /* 检测按键 */
  if ( temp )
  {
   ProcessKeyInput( temp );                                                /* 处理按键 */
  }
  if ( taskBusy == 1 )
  {
   User_RealTimeTask( 100 );                                               /* 实时控制任务 */
  }else {
   User_IdleTask();
  }
 }
}
/* Timer B0 interrupt service routine */
#pragma vector=TIMERB0_VECTOR
__interrupt void Timer_B( void )
{
  GPIO_turn( P5, 6 );
}
```

全部代码：https://github.com/xxddccaa/blog_code_search

【单片机】MSP430F149单片机，晨启，通信聊天，串口收发器

你可能更需要这个播放器：[https://qq742971636.blog.csdn.net/article/details/132117887](https://qq742971636.blog.csdn.net/article/details/132117887)





四、音乐播放器

任务要求：

设计制作一个简易音乐播放器（通过手柄板上的蜂鸣器发声，播放2到4首音

乐），同时LED模块闪烁，给人视、听觉美的感受。

评分细则：

1. 按下播放按键P15开始播放音乐，再次按下停止播放；（20分）

2. 按下按键P14播放下一首，按下按键P13播放上一首；（20分）

3. 播放音乐时OLED显示相应的曲目名；（20分）

4. 当按下"下一首"或者"上一首〃按键，但是已经播放至最后一首时，显示屏显

示"无更多曲目！"，同时蜂鸣器报警三秒钟；（20分）

5. 歌曲名横向滚动显示；（10分）

6. 具有音乐播放模式切换键，播放模式有单曲循环、顺序播放、随机播放三种

模式。（10分）

要求可以播放2至4首音乐，音乐节拍可通过网络等渠道收集。LED模块的闪烁

方式不做要求。

涉及的单片机内容以及口袋开发板模块：

单片机：I/O功能、定时/计数器、显示接口

口袋开发板：独立按键、OLED显示屏、蜂鸣器


![在这里插入图片描述](/static/img/images/04387.png)

原理：单片机使用PWM驱动无源蜂鸣器发声，PWM频率改变，发声频率就会改变。一首简谱就是由不同频率的音节组成的。





部分代码：

```go
/*  ******************************************    */
/*  ********   延时 80 ms 控制音乐节拍 */
/*  ******************************************    */
void delay1()
{
  delay_ms( 80 );
}
char taskBusy;
void main( void )
{
  unsigned char u = 0, t = 0;
  WDT_Init();                             /*看门狗设置 */
  Clock_Init();                           /* 系统时钟设置 */
  User_SystemInit();                      /* 用户控制系统初始化函数 */
  Timer_Init( TimerA, 10000 );             /* 10ms定时器中断 */
  TBCCTL0 = CCIE;                         /* CCR0 interrupt enabled */
  TBCCR0 = 0;
  TBCTL = TBSSEL_2 + MC_1 + ID_3;       /* SMCLK, contmode */
  dis_bofangmode();dis_bofangmode();
  _EINT();
  while ( 1 )
  {
    if ( taskBusy == 1 )
    {
      User_RealTimeTask( 100 );                               /* 实时控制任务 */
    }else  { /* 空闲任务（大部分时间空闲，可以用来管理一些不紧急的任务，不易放长时间执行的任务） */
      User_IdleTask();
    }
    delay_ms(10);
    if(daojishi==0 && ((music_crr == 10) ||(music_crr==-1)))//倒计时结束关闭蜂鸣器
    {
      TBCTL = TBSSEL_2 + MC_0 + ID_3;                         /* 关闭 */
      GPIO_Set( P5, 6, 1 );                                   /* 关闭蜂鸣器 */
    }
    if(daojishi!=0)
    {
      TBCCR0 = SYSCLK / H7 / 2;               /*选一个频率 */
      TBCTL = TBSSEL_2 + MC_1 + TBCLR + ID_3;       /* SMCLK, upmode */
    }
    if ( (music_crr == 0) && open_flag == 1 )
    {
      u = 0;                                                  /* 从第1个音符f[0]开始播放 */
      while ( music0[u] != 0xff )                             /* 只要没有读到结束标志就继续播放 */
      {
        if ( music_crr != 0 )                           /* 切换音乐 */
        {
          TBCTL = TBSSEL_2 + MC_0 + ID_3;         /* 关闭 */
          GPIO_Set( P5, 6, 1 );                   /* 关闭蜂鸣器 */
          break;
        }
        while ( open_flag == 0 )
          ;                                       /* 如果暂停音乐 */
        TBCCR0 = SYSCLK / music0[u] / 2;               /*选一个频率 */
        TBCTL = TBSSEL_2 + MC_1 + TBCLR + ID_3;       /* SMCLK, upmode */
        for ( t = 0; t < music0_JP[u]; t++ )            /* 控制节拍数 */
          delay1();                               /* 延时1个节拍单位 */
        TBCTL = TBSSEL_2 + MC_0 + ID_3;                 /* 关闭 */
        u++;                                            /* 播放下一个音符 */
      }
      if(bofang_mode==1)
      {
        music_crr=music_crr+1;
        if(music_crr==4)music_crr=0;//顺序循环
      }else if(bofang_mode==2)
      {
        music_crr=(music_crr+13)%4;//随机
      }
      TBCTL = TBSSEL_2 + MC_0 + ID_3;                         /* 关闭 */
      GPIO_Set( P5, 6, 1 );                                   /* 关闭蜂鸣器 */
    }
    if ( music_crr == 1 && open_flag == 1 )
    {
      u = 0;                                                  /* 从第1个音符f[0]开始播放 */
      while ( music1[u] != 0xff )                             /* 只要没有读到结束标志就继续播放 */
      {
        if ( music_crr != 1 )                           /* 切换音乐 */
        {
          TBCTL = TBSSEL_2 + MC_0 + ID_3;         /* 关闭 */
          GPIO_Set( P5, 6, 1 );                   /* 关闭蜂鸣器 */
          break;
        }
        while ( open_flag == 0 )
          ;                                       /* 如果暂停音乐 */
        TBCCR0 = SYSCLK / music1[u] / 2;               /*选一个频率 */
        TBCTL = TBSSEL_2 + MC_1 + TBCLR + ID_3;       /* SMCLK, upmode */
        for ( t = 0; t < music1_JP[u] / 2; t++ )        /* 控制节拍数 */
          delay1();                               /* 延时1个节拍单位 */
        TBCTL = TBSSEL_2 + MC_0 + ID_3;                 /* 关闭 */
        u++;                                            /* 播放下一个音符 */
      }
      if(bofang_mode==1)
      {
        music_crr=music_crr+1;
        if(music_crr==4)music_crr=0;//顺序循环
      }else if(bofang_mode==2)
      {
        music_crr=(music_crr+13)%4;//随机
      }
      TBCTL = TBSSEL_2 + MC_0 + ID_3;                         /* 关闭 */
      GPIO_Set( P5, 6, 1 );                                   /* 关闭蜂鸣器 */
    }
    if ( music_crr == 2 && open_flag == 1 )
    {
      u = 0;                                                  /* 从第1个音符f[0]开始播放 */
      while ( music2[u] != 0xff )                             /* 只要没有读到结束标志就继续播放 */
      {
        if ( music_crr != 2 )                           /* 切换音乐 */
        {
          TBCTL = TBSSEL_2 + MC_0 + ID_3;         /* 关闭 */
          GPIO_Set( P5, 6, 1 );                   /* 关闭蜂鸣器 */
          break;
        }
        while ( open_flag == 0 )
          ;                                       /* 如果暂停音乐 */
        TBCCR0 = SYSCLK / music2[u] / 2;               /*选一个频率 */
        TBCTL = TBSSEL_2 + MC_1 + TBCLR + ID_3;       /* SMCLK, upmode */
        for ( t = 0; t < music2_JP[u]; t++ )            /* 控制节拍数 */
          delay1();                               /* 延时1个节拍单位 */
        TBCTL = TBSSEL_2 + MC_0 + ID_3;                 /* 关闭 */
        u++;                                            /* 播放下一个音符 */
      }
      if(bofang_mode==1)
      {
        music_crr=music_crr+1;
        if(music_crr==4)music_crr=0;//顺序循环
      }else if(bofang_mode==2)
      {
        music_crr=(music_crr+13)%4;//随机
      }
      TBCTL = TBSSEL_2 + MC_0 + ID_3;                         /* 关闭 */
      GPIO_Set( P5, 6, 1 );                                   /* 关闭蜂鸣器 */
    }
    if ( music_crr == 3 && open_flag == 1 )
    {
      u = 0;                                                  /* 从第1个音符f[0]开始播放 */
      while ( music3[u] != 0xff )                             /* 只要没有读到结束标志就继续播放 */
      {
        if ( music_crr != 3 )                           /* 切换音乐 */
        {
          TBCTL = TBSSEL_2 + MC_0 + ID_3;         /* 关闭 */
          GPIO_Set( P5, 6, 1 );                   /* 关闭蜂鸣器 */
          break;
        }
        while ( open_flag == 0 )
          ;                                       /* 如果暂停音乐 */
        TBCCR0 = SYSCLK / music3[u] / 2;               /*选一个频率 */
        TBCTL = TBSSEL_2 + MC_1 + TBCLR + ID_3;       /* SMCLK, upmode */
        for ( t = 0; t < music3_JP[u]; t++ )            /* 控制节拍数 */
          delay1();                               /* 延时1个节拍单位 */
        TBCTL = TBSSEL_2 + MC_0 + ID_3;                 /* 关闭 */
        u++;                                            /* 播放下一个音符 */
      }
      if(bofang_mode==1)
      {
        music_crr=music_crr+1;
        if(music_crr==4)music_crr=0;//顺序循环
      }else if(bofang_mode==2)
      {
        music_crr=(music_crr+13)%4;//随机
      }
      TBCTL = TBSSEL_2 + MC_0 + ID_3;                         /* 关闭 */
      GPIO_Set( P5, 6, 1 );                                   /* 关闭蜂鸣器 */
    }
  }
}
/* Timer B0 interrupt service routine */
#pragma vector=TIMERB0_VECTOR
__interrupt void Timer_B( void )
{
  GPIO_turn( P5, 6 );
}
```

全部代码：https://github.com/xxddccaa/blog_code_search

【单片机】MSP430F149单片机，晨启，音乐播放器，蜂鸣器音乐

# 功能





 * 功能

 * 1 万年历显示

 * 2 按键修改时间

 * 3 按键修改闹钟

 * 4 闹钟到达 蜂鸣器鸣叫10秒自动关闭 闹钟是音乐

 * 5 温湿度显示

 * 6 温度到达28度以上蜂鸣器鸣叫

采用单片机内部的RTC模块走时。

按键1 切换选择年月日时分秒，靠按键1退出时间不会保存

按键2 保存设置的万年历时间并退出

按键3 加1

按键4 减1

按键5 切换选择闹钟的时分秒

矩阵键盘的16个按键只用了5个。

温湿度依靠DHT11传感器。

闹钟到达后是鸣叫天空之城，最长10秒钟后自动关闭。

# 硬件连接


 * msp430f5529

 * 矩阵键盘

 * oled  4针

 * 蜂鸣器  无源  低电平触发

 * dht11温湿度传感器

 


 * OLED  SCL--P3.0 SDA--P3.1 VCC--3.3V  GND--GND

 * beep DAT--P2.4 VCC--3.3V  GND--GND 无源 低电平触发

 * DHT11 DAT--P4.1  VCC--3.3 GND--GND


矩阵键盘

 * 列0 P8.2

 * 列1 P3.7

 * 列2 P4.0

 * 列3 P4.3

 * 行0 P1.2

 * 行1 P1.3

 * 行2 P1.4

 * 行3 P1.5

 * 行作为上拉输入 列作为输出

 

# 实物

![在这里插入图片描述](/static/img/images/04390.jpeg)

![在这里插入图片描述](/static/img/images/04391.jpeg)

# 程序

全部程序：[https://github.com/xxddccaa/blog_code_search](https://github.com/xxddccaa/blog_code_search)

部分程序如下

主程序：

这段程序是一个基于MSP430F5529微控制器的嵌入式系统应用程序。它使用了一些外部设备库（oled、delay、keyboard、rtc、dht11、beep_music）来实现以下功能：

万年历显示：在OLED屏幕上显示日期和时间。

按键修改时间：通过矩阵键盘输入，可以修改系统的当前时间。

按键修改闹钟：通过矩阵键盘输入，可以修改系统的闹钟时间。

闹钟到达：当系统的当前时间和闹钟时间匹配时，触发蜂鸣器鸣叫10秒钟，并自动关闭。闹钟的声音由音乐驱动。

温湿度显示：通过DHT11温湿度传感器获取环境的温度和湿度数据，并在OLED屏幕上显示。

温度到达28度以上蜂鸣器鸣叫：当温度超过28度时，触发蜂鸣器鸣叫。

整个程序的主要逻辑在main()函数中，初始化各个外部设备并进入一个无限循环。循环中不断读取按键、更新时间、读取温湿度数据，并根据条件触发蜂鸣器的开关和音乐播放。此外，还有一个定时器中断函数Timer_A()，用于控制蜂鸣器音乐的播放。

整个程序的功能是实现一个具有时间显示、闹钟设置、温湿度检测和报警的系统。

```c
#include <msp430.h>
#include "oled.h"
#include "delay.h"
#include "keyboard.h"
#include "rtc.h"
#include "oled_disp.h"
#include "do_key.h"
#include "dht11.h"
#include "beep_music.h"
int main( void )
{
    WDTCTL = WDTPW + WDTHOLD;       /* Stop WDT */
    init_clock_4mhz();
    OLED_Init();                    /* OLED初始化 */
    KEY_Init();
    SetupRTC();
    P1DIR   |= BIT0;
    P4DIR   |= BIT7;
    /* 温度湿度 */
    OLED_ShowCHinese( 16 * 0, 0, 0 );
    OLED_ShowCHinese( 16 * 1, 0, 1 );
    OLED_ShowCHinese( 16 * 4, 0, 2 );
    OLED_ShowCHinese( 16 * 5, 0, 3 );
    /* 闹钟 */
    OLED_ShowCHinese( 16 * 0, 6, 4 );
    OLED_ShowCHinese( 16 * 1, 6, 5 );
    rtc_time_alarm.shi  = 23;
    rtc_time_alarm.fen  = 12;
    rtc_time_alarm.miao = 15;
    _EINT();
    while ( 1 )
    {
        delay_ms( 5 );
        t++;
        if ( t > 50 )
        {
            t   = 0;
            P4OUT   ^= BIT7;
        }
        key = read_key_2( 0 );
        if ( key )
        {
            user_pro_key( key );
            disp_rtc();
            oled_cnt        = 0;
            oled_disp[oled_cnt++]   = key / 10 + '0';
            oled_disp[oled_cnt++]   = key % 10 + '0';
            oled_disp[oled_cnt++]   = 0;
            OLED_ShowString( 16*6, 2, oled_disp, 0 );
        }
        /* 显示时间 */
        if ( setting == 0 )
        {
            if ( sec != rtc_time.miao )
            {
                sec = rtc_time.miao;
                disp_rtc();
                /* 闹钟比对 */
                if ( beep_open_state == 1 )
                {
                    music_open_rtc_cnt++;
                }
                if ( (rtc_time_alarm.shi == rtc_time.shi)
                     && (rtc_time_alarm.fen == rtc_time.fen)
                     && (rtc_time_alarm.miao == rtc_time.miao) )
                {
                    beep_open_state     = 1; /* 0关闭蜂鸣器  1蜂鸣器音乐模式  2蜂鸣器pwm鸣叫模式 */
                    music_u         = 0;
                    new_music       = 0;
                    delay_music     = 0;
                    music_open_rtc_cnt  = 0;
                }
            }
        }
        /* 读取温湿度 */
        dht11_read_cnt++;
        if ( dht11_read_cnt > 400 ) /* 约2秒更新一次温湿度 */
        {
            dht11_read_cnt = 0;
            /* 如果读取到了 并且校验成功 */
            if ( receive_init() == 1 )
            {
                dht11_temp  = temph;
                dht11_humi  = humdh;
                if ( temph > 27 )
                {
                    P1OUT |= BIT0;                  /* 点亮 */
                    if ( beep_open_state == 0 )
                    {
                        beep_open_state = 2;    /* 0关闭蜂鸣器  1蜂鸣器音乐模式  2蜂鸣器pwm鸣叫模式 */
                    }
                }else  {
                    P1OUT &= ~BIT0;                 /* 熄灭 */
                    if ( beep_open_state == 2 )
                    {
                        beep_open_state = 0;
                    }
                }
                disp_rtc();
            }
        }
        /* 蜂鸣器控制 */
        if ( beep_open_state_previous != beep_open_state )
        {
            beep_open_state_previous = beep_open_state;
            if ( beep_open_state == 0 )             /* 0关闭蜂鸣器  1蜂鸣器音乐模式  2蜂鸣器pwm鸣叫模式 */
            {
                close_beep();
            }else if ( beep_open_state == 2 )       /* 0关闭蜂鸣器  1蜂鸣器音乐模式  2蜂鸣器pwm鸣叫模式 */
            {
                open_beep();
            }else if ( beep_open_state == 1 )       /* 0关闭蜂鸣器  1蜂鸣器音乐模式  2蜂鸣器pwm鸣叫模式 */
            {
                open_beep_music();
            }
        }
    }
}
/* Timer A0 interrupt service routine */
#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A( void )
{
    /* 100ms中断 */
    if ( beep_open_state == 1 )
    {
        if ( music_open_rtc_cnt < 11 )                                          /* 音乐响10秒 */
        {
            if ( (delay_music < music0_JP[music_u]) && (new_music == 0) )   /* 计时没结束 且第一次赋值 */
            {
                if ( music0[music_u] != 0xff )                          /* 只要不是最后一个音符 */
                {
                    set_pwm_freq( music0[music_u] );                /* 设置pwm频率 */
                }else  {
                    new_music       = 0;
                    delay_music     = 0;
                    music_open_rtc_cnt  = 0;
                    beep_open_state     = 0;
                    close_beep();
                }
                new_music = 1;
            }else if ( delay_music >= music0_JP[music_u] )  /* 计时结束 */
            {
                music_u     += 1;                   /*下一个音符 fgvb5 */
                new_music   = 0;                    /* 重新计时 */
                delay_music = 0;                    /* 重新计时 */
            }
            delay_music++;
        }else  {
            new_music       = 0;
            delay_music     = 0;
            music_open_rtc_cnt  = 0;
            beep_open_state     = 0;
            close_beep();
        }
    }
}
#pragma vector=RTC_VECTOR
__interrupt void RTC_ISR( void )
{
    switch ( __even_in_range( RTCIV, RTC_RT1PSIFG ) )
    {
    case RTC_NONE:
        break;
    case RTC_RTCRDYIFG:
    {
        if ( setting == 0 )
        {
            /* 读取时间 */
            rtc_time.nian   = RTCYEAR;
            rtc_time.yue    = RTCMON;
            rtc_time.ri = RTCDAY;
            rtc_time.shi    = RTCHOUR;
            rtc_time.fen    = RTCMIN;
            rtc_time.miao   = RTCSEC;
            rtc_time.zhou   = RTCDOW;
        }
        /* 闪烁灯 */
        P1OUT ^= BIT0;
    }
    break;
    case RTC_RTCTEVIFG:
        break;
    case RTC_RTCAIFG:
        break;
    case RTC_RT0PSIFG:
        break;  /* 分频器 0 */
    case RTC_RT1PSIFG:
        break;  /* 分频器 1 */
    default:
        break;
    }
    __no_operation();
}
```


# 帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

演示视频：

```
链接：https://pan.baidu.com/s/1800k3C_iNUzFLup-va3cMQ?pwd=uqp0 
提取码：uqp0 
```

MSP430F5529单片机，万年历，闹钟，数字时钟，温湿度dht11，蜂鸣器音乐

# 硬件连接





/*

 * OLED----MSP430

 * VCC-----3.3V

 * GND-----GND

 * SCL------P3.1

 * SDA------P3.0

 */


/*

 * 蜂鸣器----MSP430

 * VCC-----3.3V

 * GND-----GND

 * DAT------P2.4

 */


/*

 * 超声波----MSP430

 * VCC-----3.3V

 * GND-----GND

 * TRIG------P1.3

 * ECHO------P1.2

 */


/*

 * 小灯1 P1.0

 * 小灯2 P4.7

 */

/*

 * 键1 P2.1

 * 键2 P1.1

 */

# 功能

/*

 * 功能

 * 1、测定超声波sr04的距离

 * 2、显示距离、报警阈值

 * 3、按键设置报警阈值

 * 4、超声波距离小于阈值时蜂鸣器报警，且距离越小越急促【倒车雷达】

 * 5、超声波距离大于阈值时蜂鸣器不报警

 * 6、按键单击双击识别，单击加减10，双击加减1

 * 7、小灯1 会在蜂鸣器响的时候点亮

 * 8、小灯2 程序正常的话，会一直闪烁

 */


# 实物效果

![在这里插入图片描述](/static/img/images/04392.png)

# 代码

代码：https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2

这段代码是一个基于MSP430微控制器的超声波测距仪器。它使用了OLED显示屏和2个小灯，通过超声波测量物体与传感器的距离，并在OLED屏上显示距离和报警阈值。以下是代码的主要功能：

初始化时钟、LED、定时器、蜂鸣器、OLED显示屏和按键。

循环中不断测量超声波距离并显示在OLED屏上。

根据超声波距离和报警阈值控制蜂鸣器的鸣叫频率和小灯的亮灭。

按键操作可以调整报警阈值。

具体的代码逻辑可以参考注释部分。

MSP430F5529，超声波，距离检测报警，倒车雷达，SR-04模块

# 功能





1 显示万年历，利用内部RTC模块

2 按键修改时间

3 显示芯片内部的温度数值

# 实物图

![在这里插入图片描述](/static/img/images/04398.jpeg)

![在这里插入图片描述](/static/img/images/04399.jpeg)

![在这里插入图片描述](/static/img/images/04400.jpeg)

# 原理图

![在这里插入图片描述](/static/img/images/04401.png)

# 一些程序片段

## 矩阵键盘

[https://qq742971636.blog.csdn.net/article/details/131650521](https://qq742971636.blog.csdn.net/article/details/131650521)

## 内部温度读取

这段代码是用来初始化一个模拟-数字转换器（ADC）的函数。它的作用是配置ADC的参数和寄存器，以便进行模拟信号的采样和转换。

具体解释如下：

首先，设置ADC12CTL0寄存器的位操作。将ADC12ON置1，表示打开ADC；将ADC12SHT0_12设置为1，表示设置采样保持时间为1024个时钟周期。

然后，配置ADC12CTL1寄存器的位操作。将ADC12SHP置1，表示使用脉冲采样模式；将ADC12SSEL_1置1，表示选择ACLK作为时钟源；将ADC12DIV_1置1，表示时钟分频系数为1。

接下来，设置ADC12IE寄存器的值为0x01，表示允许中断使能。这样当ADC转换完成时，将会触发中断。

清除REFCTL0寄存器的REFMSTR位，将参考电压控制权交给ADC12。这是为了确保ADC使用内部参考电压。

设置ADC12CTL0寄存器的ADC12REFON位为1，表示打开参考电压。此时参考电压被设置为1.5V。

设置ADC12MCTL0寄存器的ADC12SREF_1位为1，表示ADC的正输入端连接到参考电压（VREF）。这是为了使用内部参考电压来测量。

设置ADC12MCTL0寄存器的ADC12INCH_10位为1，表示ADC的输入通道选择为内部温度传感器。

最后，设置ADC12CTL0寄存器的ADC12ENC位为1，表示使能ADC12_A转换。这样配置完成后，即可开始进行ADC转换。

总结起来，这段代码的作用是初始化ADC，设置采样保持时间、选择时钟源、配置输入通道等参数，并打开ADC使能，以便进行模拟信号的采样和转换。

```c
#define CALADC12_15V_30C *((unsigned int *)0x1A1A)  //6682
#define CALADC12_15V_85C *((unsigned int *)0x1A1C)  //6684
void ADC_Init(void) {
    ADC12CTL0 |= ADC12ON + ADC12SHT0_12;              /* 打开AD，设置采样保持时间为1024个时钟周期 */
    ADC12CTL1 = ADC12SHP + ADC12SSEL_1 + ADC12DIV_1;  /* 脉冲采样模式 ACLK 2分频 */
    ADC12IE = 0x01;                                 /* 中断使能 */
    REFCTL0 &= ~REFMSTR;                            /* 参考电压控制权交给ADC12 */
    ADC12CTL0 |= ADC12REFON;                          /* REF_ON REF=1.5V */
    ADC12MCTL0 |= ADC12SREF_1;                         /* V+ = REF  V- = AVSS */
    ADC12MCTL0 |= ADC12INCH_10;                        /* ADC输入为内部温度传感器 */
    ADC12CTL0 |= ADC12ENC;                            /* 开启ADC12_A转换 最后写 */
}
unsigned int temperature = 0;
void main(void){
    double tmp;
    int temp_k;
 WDTCTL = WDTPW + WDTHOLD;       /* Stop WDT */
 ADC_Init();
 while(1){
 ADC12CTL0 |= ADC12SC;
    tmp = (float) (((long) temperature - CALADC12_15V_30C) * (85 - 30))
          / (CALADC12_15V_85C - CALADC12_15V_30C) + 30.0f;
    temp_k = tmp * 100;
    //显示温度
    oled_cnt = 0;
    oled_disp[oled_cnt++] = 'T';
    oled_disp[oled_cnt++] = 'E';
    oled_disp[oled_cnt++] = 'M';
    oled_disp[oled_cnt++] = ':';
    oled_disp[oled_cnt++] = temp_k / 1000 + '0';
    oled_disp[oled_cnt++] = temp_k % 1000 / 100 + '0';
    oled_disp[oled_cnt++] = '.';
    oled_disp[oled_cnt++] = temp_k % 100 / 10 + '0';
    oled_disp[oled_cnt++] = temp_k % 10 + '0';
    oled_disp[oled_cnt++] = 'C';
    oled_disp[oled_cnt++] = 0;
    OLED_ShowString(0, 6, oled_disp, 0);
 } 
}
#pragma vector = ADC12_VECTOR
__interrupt void ADC12_ISR(void) {
    switch (__even_in_range(ADC12IV, 34)) {
        case 6: // Vector 6: ADC12IFG0
            temperature = ADC12MEM0;
            //__bic_SR_register_on_exit(LPM0_bits); // Exit active CPU
        default:
            break;
    }
}
```

## 将年月日转为星期

这段代码是一个函数，用于根据给定的年月日计算对应的星期几。

代码以输入参数 iY、iM 和 iD 代表年、月和日。然后，根据公式计算出一个数值 iWeekDay 来表示星期几。

首先，代码检查给定的月份是否为1月或2月，如果是，则将传入的月份 iM 增加12，并将年份 iY 减去1。这是因为在公式中，一月和二月被认为属于前一年的13月和14月。

然后，使用如下公式计算星期几的数值：(iD + 1 + 2 * iM + 3 * (iM + 1) / 5 + iY + iY / 4 - iY / 100 + iY / 400) % 7

最后，如果计算出的星期几数值为0，则将其转换为7，以符合星期数值的范围。

函数返回计算得到的星期几数值，范围在1到7之间，分别代表星期一到星期天。
```c
/*
 * 由年月日获取星期 https://www.cnblogs.com/fengbohello/p/3264300.html
 * 返回1到7 代表星期一到星期天
 *
 */
int getWeekdayByYearday(int iY, int iM, int iD) {
    int iWeekDay = -1;
    if (1 == iM || 2 == iM) {
        iM += 12;
        iY--;
    }
    iWeekDay = (iD + 1 + 2 * iM + 3 * (iM + 1) / 5 + iY + iY / 4 - iY / 100 + iY / 400) % 7;
    if (iWeekDay == 0)
        iWeekDay = 7;
    return (iWeekDay);
}
```


源码：http://dt4.8tupian.net/2/28880a12b16800.pg3


# 帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【单片机】msp430f5529 万年历，数字时钟，矩阵键盘修改时间，7针OLED显示，内部温度读取

多路温度巡回检测仪的设计





多路温度检测仪共有3个测温点，每个点连续检测8次，以平均值代表该点温度，并同时在 LCD 显示器．器任选，测量精度为±1°℃。系统每隔1秒完成一个点的测量。

设计以msp430g2553为核心的多路温度检测仪的软硬件。

![在这里插入图片描述](/static/img/images/04486.png)

源码下载：[ http://dt2.8tupian.net/2/28880a7b9990.pg3](http://dt2.8tupian.net/2/28880a7b9990.pg3)

# 帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【单片机】MSP430 单片机 多路温度巡回检测仪的设计 LCD1602显示，四线接法

# 原理图





![在这里插入图片描述](/static/img/images/04527.png)



# ZE08-CH2O甲醛传感器

ZE08-CH2O是一种甲醛（甲醛）传感器，用于检测环境中的甲醛浓度。甲醛是一种有毒气体，广泛用于建筑材料、家具、地毯、化妆品和其他消费品的生产中。高浓度的甲醛对人体健康有害，可能导致呼吸道问题、眼痛、皮肤刺激甚至癌症。

ZE08-CH2O传感器采用电化学原理，能够测量环境中甲醛的浓度，并输出相应的电信号。它通常与微控制器或数据采集系统配合使用，以便监测甲醛浓度并采取适当的措施，如提醒用户开窗通风或触发警报。

这种传感器通常具有以下特点：

高灵敏度：能够检测到低浓度的甲醛。

高精度：提供准确的测量结果。

高稳定性：能够长时间稳定地工作。

快速响应：能够迅速检测到甲醛浓度的变化。

小型化设计：体积小，便于集成到不同的应用中。

![在这里插入图片描述](/static/img/images/04528.png)

![在这里插入图片描述](/static/img/images/04529.png)

采用5V供电，然后使用STM32F103C8T6单片机的串口3，波特率9600，与ZE08-CH2O甲醛传感器进行通信。ZE08-CH2O甲醛传感器的输出电平是3.3。

![在这里插入图片描述](/static/img/images/04530.png)

串口接收的代码：

```c
u32 ch2o_high = 1000;//甲醛的最大值，高于就报警 1000就是0.1mg/m3
u32 ch2o;//甲醛浓度 mg/m3*10000
u8 UART3_dat_ch2o[20];
u8 ch2o_cnt = 0;
void USART3_IRQHandler(void) {
    u8 res;
    if (USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) /* 接收到数据 */
    {
        res = USART_ReceiveData(USART3);
        //回发
        //USART_SendData(USART3, res);                                          /* 发送数据到串口3 */
    UART3_dat_ch2o[ch2o_cnt]=res;
        switch (ch2o_cnt) {
            case 0:
                if (UART3_dat_ch2o[ch2o_cnt] == 0xFF) ch2o_cnt = 1;
                else ch2o_cnt = 0;
                break;
            case 1:
                if (UART3_dat_ch2o[ch2o_cnt] == 0x17) ch2o_cnt = 2;
                else ch2o_cnt = 0;
                break;
            case 2:
                if (UART3_dat_ch2o[ch2o_cnt] == 0x04) ch2o_cnt = 3;
                else ch2o_cnt = 0;
                break;
            case 3:
                if (UART3_dat_ch2o[ch2o_cnt] == 0x00) ch2o_cnt = 4;
                else ch2o_cnt = 0;
                break;
            case 4:
                ch2o_cnt = 5;
                break;
            case 5:
                ch2o_cnt = 6;
                break;
            case 6:
                if (UART3_dat_ch2o[ch2o_cnt] == 0x13) ch2o_cnt = 7;
                else ch2o_cnt = 0;
                break;
            case 7:
                if (UART3_dat_ch2o[ch2o_cnt] == 0x88) ch2o_cnt = 8;
                else ch2o_cnt = 0;
                break;
            case 8:  //校验接收的数据  正确则处理接收的数据
                if ((UART3_dat_ch2o[ch2o_cnt] + UART3_dat_ch2o[1] + UART3_dat_ch2o[2] + UART3_dat_ch2o[3] +
                     UART3_dat_ch2o[4] + UART3_dat_ch2o[5] + UART3_dat_ch2o[6] + UART3_dat_ch2o[7]) % 256 == 0) {
                    ch2o = UART3_dat_ch2o[4] * 256 + UART3_dat_ch2o[5];
                    ch2o = ch2o * 13.392857;
                    ch2o_cnt = 0;
                } else {
                    ch2o_cnt = 0;
                }
                break;
        }
    }
}
```

显示的代码：

```c
    //甲醛
    memset(xianshi, 0, sizeof(xianshi));
    sprintf(xianshi, "C:%d.%04d mg/m3 ", (int) ch2o / 10000, (int) ch2o % 10000);
    OLED_P8x16Str(16 * 0, 4, xianshi, 0);
```

# A9短信模块

引脚图：

![在这里插入图片描述](/static/img/images/04531.png)

原理图：

![在这里插入图片描述](/static/img/images/04532.png)


初始化：

```c
void init_A9(void) {
    OK = 0;
    printf("AT\r\n");
    delay_ms(500);
    printf("AT\r\n");
    delay_ms(500);
    while (1) {
        if (OK == 1)                  /* OK */
        {
            OK = 0;
            break;
        } else {
            delay_ms(500);
            printf("AT\r\n");     /* 再次测试AT */
            OLED_P8x16Str(16 * 0, 2, "SIM AT TEST ", 0);
        }
    }
    /* 检测卡SIM */
    OK = 0;
    printf("AT+CCID\r\n");
    delay_ms(500);
    while (OK == 0) {
        printf("AT+CCID\r\n");
        OLED_P8x16Str(16 * 0, 2, "SIM ERROR   ", 0);
        delay_ms(500);
    }
}
//A9模块
void USART1_IRQHandler(void)                                                                  /* 串口1中断服务程序 */
{
    u8 receiveData;
    static unsigned char over_flag = 0;                                                  /* 完成标志 */
    if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)                              /* 接收中断(接收到的数据必须是0x0d 0x0a结尾) */
    {
        receiveData = USART_ReceiveData(USART1);                                      /* 读取接收到的数据 */
        if (receiveData == '>') {
            OKGSM = 1;
        }
        RX_BUF[LENGTH++] = receiveData;
        if (receiveData == '\r') {
            over_flag = 1;
        } else if (((receiveData == '\n') && (over_flag == 1)))      /* 收到\r\n */
        {
            RX_BUF[LENGTH] = '\0';
            LENGTH = 0;
            over_flag = 0;                                    /* 完成标志 */
            if (strstr(RX_BUF, "OK") != NULL) {
                OK = 1;
            } else {
                OK = 0;
            }
        }
    }
}
```

发送短信：

```c
void send_once_GSM(void) {
    printf("AT+CMGF=1\r\n");
    OK = 0;
    delay_ms(500);
    while (OK == 0) {
        printf("AT+CMGF=1\r\n");
        delay_ms(500);
    }
    printf("AT+CMGS=\"13198256451\"\r\n");
    OKGSM = 0;
    delay_ms(500);
    while (OKGSM == 0) {
        printf("AT+CMGS=\"13198256451\"\r\n");
        delay_ms(500);
    }                                                       /* 等待 反应 */
    delay_ms(500);
    printf("message warining!!!!!!! ");
    while (USART_GetFlagStatus(USART1, USART_FLAG_TC) != SET);
    USART_SendData(USART1, 0x1a);                         /* 短信结尾字符 */
    while (USART_GetFlagStatus(USART1, USART_FLAG_TC) != SET);
}
```

# 实物

最终搭载了SIM800C短信模块。

源码：http://dt4.8tupian.net/2/28880a8b9990.pg3

![在这里插入图片描述](/static/img/images/04533.png)

【单片机 TB作品】基于STM32F103C8T6单片机的甲醛监测与报警系统

# yolov7训练





yolov7:[https://github.com/WongKinYiu/yolov7](https://github.com/WongKinYiu/yolov7)

人脸口罩数据集：链接：[https://pan.baidu.com/s/1bnxJPnoRNwUfVzLxKjIvkQ?pwd=c0yc ](https://pan.baidu.com/s/1bnxJPnoRNwUfVzLxKjIvkQ?pwd=c0yc)

300轮训练趋于稳定：

```
   276/299     34.3G    0.0257  0.007348   0.00204   0.03509      1466       416    0.9493    0.8662    0.9207    0.6118   0.06233   0.01659    0.0317
   277/299     34.3G   0.02548  0.007208  0.002046   0.03473      1397       416    0.9512    0.8673    0.9206    0.6138   0.06227    0.0166   0.03165
   278/299     34.3G   0.02532  0.007306  0.001777    0.0344      1487       416    0.9605    0.8608    0.9207    0.6124   0.06215   0.01658   0.03148
   279/299     34.3G   0.02536  0.007267   0.00177    0.0344      1447       416    0.9605    0.8605     0.921    0.6127   0.06217   0.01652   0.03169
   280/299     34.3G   0.02569  0.007402  0.001857   0.03495      1581       416    0.9475    0.8719    0.9223    0.6111   0.06234   0.01662   0.03161
   281/299     34.3G   0.02528  0.007174  0.001653   0.03411      1525       416    0.9539    0.8662    0.9215    0.6138   0.06228   0.01673   0.03155
   282/299     34.3G   0.02548  0.007163  0.001838   0.03448      1497       416    0.9445    0.8734     0.922    0.6131   0.06231   0.01659     0.032
   283/299     34.3G   0.02502   0.00728  0.001912   0.03421      1581       416    0.9623    0.8628    0.9217    0.6129   0.06229   0.01658   0.03189
   284/299     34.3G    0.0256   0.00737  0.001769   0.03474      1443       416     0.953      0.87    0.9205    0.6125    0.0622   0.01653   0.03176
   285/299     34.3G   0.02513   0.00714  0.001742   0.03401      1407       416    0.9554    0.8657    0.9196    0.6116    0.0622   0.01652   0.03188
   286/299     34.3G   0.02545  0.007449  0.001775   0.03468      1489       416      0.96    0.8633    0.9201    0.6109    0.0622   0.01662   0.03191
   287/299     34.3G   0.02528  0.007087   0.00196   0.03433      1576       416    0.9434    0.8748    0.9204    0.6096   0.06215    0.0166   0.03185
   288/299     34.3G   0.02556  0.007509   0.00175   0.03481      1435       416     0.944    0.8723    0.9187    0.6102   0.06218   0.01653    0.0319
   289/299     34.3G   0.02504  0.007301  0.001822   0.03416      1432       416    0.9412    0.8713    0.9192    0.6112   0.06223    0.0165   0.03185
   290/299     34.3G    0.0254  0.007088  0.001781   0.03427      1531       416    0.9587      0.86    0.9185     0.611   0.06227   0.01651   0.03189
   291/299     34.3G   0.02507  0.007189  0.001821   0.03408      1431       416    0.9585    0.8635    0.9199     0.612   0.06223   0.01658   0.03172
   292/299     34.3G   0.02508   0.00739  0.001682   0.03415      1519       416    0.9615    0.8644      0.92    0.6137   0.06216   0.01661   0.03165
   293/299     34.3G   0.02538   0.00718  0.001836   0.03439      1348       416    0.9599    0.8617    0.9186    0.6131   0.06213   0.01657   0.03178
   294/299     34.3G   0.02553  0.007235  0.002009   0.03477      1330       416      0.95    0.8668    0.9186    0.6109   0.06213   0.01662   0.03183
   295/299     34.3G   0.02568  0.007386   0.00182   0.03489      1599       416    0.9563    0.8642    0.9201    0.6123   0.06213   0.01664   0.03188
   296/299     34.3G   0.02541  0.007049  0.001726   0.03419      1528       416    0.9507    0.8662    0.9194    0.6127   0.06217   0.01665   0.03198
   297/299     34.3G    0.0251  0.007234  0.001805   0.03414      1395       416    0.9429    0.8727     0.919    0.6114   0.06224   0.01664   0.03192
   298/299     34.3G   0.02508  0.006955  0.001866    0.0339      1465       416    0.9458    0.8713    0.9197    0.6121   0.06223   0.01662   0.03193
   299/299     34.3G   0.02551  0.007269  0.001724    0.0345      1555       416    0.9528    0.8664    0.9199    0.6123    0.0622   0.01658   0.03203
```

准确率曲线：

![在这里插入图片描述](/static/img/images/04534.png)

召回率曲线：

![在这里插入图片描述](/static/img/images/04535.png)

# 系统集成

Qt界面：

![在这里插入图片描述](/static/img/images/04536.png)

播放过程中，没戴口罩的人脸红色框，戴口罩的白色框。

![在这里插入图片描述](/static/img/images/04537.png)

![在这里插入图片描述](/static/img/images/04538.png)

# 数据库报警记录查看

sqlite数据库，可以查看报警信息，右键可以删除某条记录。

![在这里插入图片描述](/static/img/images/04539.png)

# qt页面跳转方式

sqllite用着很便利，无需安装数据库服务。

qt中从主窗口跳转到别的窗口再回来的方法：

要在DatabaseViewer页面退出后返回到主页面，你需要进行以下操作：

1、在MainWindow类中，创建一个方法来显示DatabaseViewer页面。在这个方法中，实例化DatabaseViewer类，并将其显示为一个对话框或窗口。

```python
from PyQt5.QtWidgets import QDialog
class MainWindow(QWidget):
    # ...
    def show_database_viewer(self):
        # 调用并显示DatabaseViewer页面
        self.database_viewer = DatabaseViewer()
        self.database_viewer.show()
```

2、在主页面的初始化方法中，连接history_btn按钮的点击事件到

```python
def __init__(self):
    super().__init__()
    # ...
    self.history_btn.clicked.connect(self.show_database_viewer)
    # ...
```

3、在DatabaseViewer类中，添加一个属性来保存主页面的引用。

```python
class DatabaseViewer(QMainWindow):
    def __init__(self, main_window):
        super().__init__()
        self.main_window = main_window
        # ...
```

4、在主页面的show_database_viewer方法中，将主页面的引用传递给DatabaseViewer类的实例。

```python
def show_database_viewer(self):
    # 调用并显示DatabaseViewer页面
    self.database_viewer = DatabaseViewer(self)
    self.database_viewer.show()
```

5、在DatabaseViewer类中，重写关闭事件的方法closeEvent。在关闭事件中，调用父类的关闭事件方法，并显示主页面。

```python
class DatabaseViewer(QMainWindow):
    # ...
    def closeEvent(self, event):
        # 调用父类的关闭事件方法
        super().closeEvent(event)
        # 显示主页面
        self.main_window.show()
```

这样，当你在主页面点击"查看记录"按钮时，会调用show_database_viewer方法，显示DatabaseViewer页面。当你在DatabaseViewer页面关闭窗口时，会触发关闭事件，显示主页面。这样就可以在两个页面之间进行切换了。

# qt 的数据库某表查看页面如何写

以下是参考：

```python
import os
import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QTableView, QMenu, QAction, QMessageBox, QDesktopWidget, \
    QHeaderView
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QStandardItemModel, QStandardItem
import sqlite3
class DatabaseViewer(QMainWindow):
    def __init__(self, main_window):
        super().__init__()
        self.main_window = main_window
        # 设置主窗口的大小为屏幕宽高的一半
        screen_geometry = QDesktopWidget().screenGeometry()
        width = screen_geometry.width() // 2
        height = screen_geometry.height() // 2
        self.resize(width, height)
        # 连接到数据库文件
        self.conn = sqlite3.connect('database.db')
        self.cursor = self.conn.cursor()
        self.table_view = QTableView(self)
        self.setCentralWidget(self.table_view)
        # 创建数据模型
        self.model = QStandardItemModel()
        self.model.setColumnCount(3)
        self.model.setHorizontalHeaderLabels(['ID', '时间戳', '图片路径'])
        self.table_view.setModel(self.model)
        # 设置表格属性
        self.table_view.setEditTriggers(QTableView.NoEditTriggers)
        self.table_view.setSelectionBehavior(QTableView.SelectRows)
        self.table_view.setSelectionMode(QTableView.SingleSelection)
        self.table_view.setContextMenuPolicy(Qt.CustomContextMenu)
        self.table_view.customContextMenuRequested.connect(self.show_context_menu)
        # 设置最后一列填充剩余空间
        self.table_view.horizontalHeader().setStretchLastSection(True)
        # 设置第二列宽度为自定义宽度
        self.table_view.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeToContents)
        # 查询数据并显示
        self.query_data()
    def query_data(self):
        # 查询数据
        self.cursor.execute("SELECT * FROM warning_table")
        rows = self.cursor.fetchall()
        # 清空数据模型
        self.model.removeRows(0, self.model.rowCount())
        # 添加数据到数据模型
        for row_data in rows:
            row = [QStandardItem(str(data)) for data in row_data]
            self.model.appendRow(row)
    def show_context_menu(self, position):
        # 右键菜单
        menu = QMenu(self.table_view)
        delete_action = QAction("删除", self.table_view)
        delete_action.triggered.connect(self.delete_row)
        menu.addAction(delete_action)
        # 显示右键菜单
        menu.exec_(self.table_view.viewport().mapToGlobal(position))
    def delete_row(self):
        # 获取选中的行
        selected_row = self.table_view.selectedIndexes()
        if selected_row:
            row = selected_row[0].row()
            item_id = self.model.item(row, 0)
            id_value = int(item_id.text())
            # 拿出数据库里的此id的一行数据，有id、时间戳、图片路径，删除图片路径
            self.cursor.execute("SELECT * FROM warning_table WHERE id = ?", (id_value,))
            rows = self.cursor.fetchall()
            for row_data in rows:
                os.remove(row_data[2])
            # 删除数据
            self.cursor.execute("DELETE FROM warning_table WHERE id = ?", (id_value,))
            self.conn.commit()
            # 从数据模型中移除该行
            self.model.removeRow(row)
            QMessageBox.information(self, "提示", "删除成功")
        else:
            QMessageBox.warning(self, "警告", "请先选择要删除的行")
    def closeEvent(self, event):
        # 调用父类的关闭事件方法
        super().closeEvent(event)
        # 显示主页面
        self.main_window.show()
```

# 源码下载

采用416*416的一个输入，使得对小脸检测效果不是很好。训练数据也是重点，肯定是需求更多的训练数据让模型更加稳定。

源码下载：[http://dt2.8tupian.net/2/28880a9b9990.pg3](http://dt2.8tupian.net/2/28880a9b9990.pg3)

【深度学习】基于Python Qt的口罩检测与报警系统

# 一个简单的sin波形发生器





代码：

```c
#include <msp430.h>
#define uchar unsigned char
#define CPU_F ((double)1000000)//cpu frequency1000000
#define delay_us(x) __delay_cycles((long)(CPU_F*(double)x/1000000.0))
#define delay_ms(x) __delay_cycles((long)(CPU_F*(double)x/1000.0))
#define CS_SET P2OUT |= BIT6
#define CS_CLR P2OUT &= ~BIT6       //P26 CS
#define WR_SET P2OUT |= BIT7
#define WR_CLR P2OUT &= ~BIT7     //P27 WR
#define DI P1OUT   //DI
const uchar sin_a[52] = {128, 143, 159, 174, 188, 201, 213, 224, 234, 242, 248, 252, 255, 255, 254, 251, 246, 239, 230, 220, 209, 196, 182, 168, 153, 137, 121, 106, 91, 76, 62, 49, 37, 27, 18, 11, 5, 1, 0, 0, 2, 6, 12, 19, 28, 39, 51, 64, 78, 93, 108, 124 };
void write_dac(uchar data)    //dac写数据函数
{
    CS_CLR;
    DI = data;
    WR_CLR;
    delay_us(1);
    WR_SET;   //latch data
    CS_SET;
}
void sin()     //正弦波发生函数
{
    uchar i;
    for (i = 0; i < 52; i++)
    {
        write_dac(sin_a[i]);
    }
}
void main(void)
{
    WDTCTL = WDTPW + WDTHOLD;// Stop WDT
    P1DIR = 0xff;//0832的数据位
    P2DIR |= BIT6 + BIT7;
    P2SEL &= ~(BIT6 + BIT7);
    for (;;)
    {
        sin();
    }
}
```

仿真：

![在这里插入图片描述](/static/img/images/04547.png)

# 控制频率、幅度

频率依靠定时器可以较为精准控制，但幅度只能加一点减一点。

稍微修改后，按键调节频率和幅度，产生正弦、矩形、三角波：

![在这里插入图片描述](/static/img/images/04548.png)

![在这里插入图片描述](/static/img/images/04549.png)

![在这里插入图片描述](/static/img/images/04550.png)

仿真图和程序源码：http://dt2.8tupian.net/2/28880a10b9990.pg3

# 帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【单片机】MSP430单片机，波形发生器，Proteus仿真

// 硬件：DS1302、按键、LCD1602、无源蜂鸣器





// 1、具有万年历功能的数字时钟 (本世纪100年通用)，能够正确的显示年、月、日、时、分、秒

// 2、按键设置时间(校时)

// 3、24小时内至少可设置3个闹钟，并具有不同的闹钟铃声。每个闹钟可以选择启用或者不启用。

// 4、具有秒表功能(计时精度0.1秒)

// 5、其它与数字时钟相关的功能扩展（整点报时、闹钟时间掉电保存功能AT24C02、）

//按键1 可以设置时间切换，秒表下是开始

//按键2 可以设置时间切换，秒表下是暂停

//按键3 可以设置闹钟切换，秒表下是复位

//按键4 可以设置闹钟切换

//按键5 +

//按键6 -

//按键7 直接回到主页面

//按键8 进入秒表

主页面：

![在这里插入图片描述](/static/img/images/04554.png)

闹钟0设置：

![在这里插入图片描述](/static/img/images/04555.png)

闹钟1设置：

![在这里插入图片描述](/static/img/images/04556.png)

闹钟2设置：

![在这里插入图片描述](/static/img/images/04557.png)

秒表：

![在这里插入图片描述](/static/img/images/04558.png)





部分源码：

```c
void main() {
    char miaoa = 0;
    char ifg = 0;
    unsigned char keyvl = 0;
    LCD_init();
    x24c02_init();
    ds1302_init();
    // LCD_write_str(1, 1, "2223123");
    get_time(&rtctime); /* 调用取时间函数 */
    ifg = 0;
    if (rtctime.nian > 99)
        ifg = 1;
    if (rtctime.yue > 12)
        ifg = 1;
    if (rtctime.ri > 31)
        ifg = 1;
    if (rtctime.zhou > 7)
        ifg = 1;
    if (rtctime.shi > 23)
        ifg = 1;
    if (rtctime.fen > 59)
        ifg = 1;
    if (rtctime.miao > 59)
        ifg = 1;
    if (ifg == 1) /* 如果时间有问题 就初始化时间 */
    {
        rtctime.nian = 20;
        rtctime.yue = 10;
        rtctime.ri = 10;
        rtctime.zhou = getWeekdayByYearday(rtctime.nian + 2000, rtctime.yue, rtctime.ri);
        rtctime.shi = 7;
        rtctime.fen = 59;
        rtctime.miao = 58;
        set_time(&rtctime);
    }
    read_alarm();
    ifg = 0;
    if ((ALARMtime.shi > 23) || (ALARMtime.shi < 0))
        ifg = 1;
    if ((ALARMtime.fen > 59) || (ALARMtime.fen < 0))
        ifg = 1;
    if ((ALARMtime.miao > 59) || (ALARMtime.miao < 0))
        ifg = 1;
    if ((ALARMtime1.shi > 23) || (ALARMtime1.shi < 0))
        ifg = 1;
    if ((ALARMtime1.fen > 59) || (ALARMtime1.fen < 0))
        ifg = 1;
    if ((ALARMtime1.miao > 59) || (ALARMtime1.miao < 0))
        ifg = 1;
    if ((ALARMtime2.shi > 23) || (ALARMtime2.shi < 0))
        ifg = 1;
    if ((ALARMtime2.fen > 59) || (ALARMtime2.fen < 0))
        ifg = 1;
    if ((ALARMtime2.miao > 59) || (ALARMtime2.miao < 0))
        ifg = 1;
    if (ifg == 1) /* 如果时间有问题 就初始化  闹钟 */
    {
        ALARMtime.shi = 10;
        ALARMtime.fen = 0;
        ALARMtime.miao = 0;
        ALARMtime1.shi = 10;
        ALARMtime1.fen = 5;
        ALARMtime1.miao = 0;
        ALARMtime2.shi = 10;
        ALARMtime2.fen = 10;
        ALARMtime2.miao = 0;
        write_alarm();
    }
    init_timer0();
    init_timer1();
    while (1) {
        delay_ms(10);
        keyvl = getkey();
        if (keyvl) {
            user_pro_key(keyvl);
            while (getkey())
                ;
        }
        if (set == 0) {
            get_time(&rtctime); /* 调用取时间函数 */
            if (miaoa != rtctime.miao) {
                miaoa = rtctime.miao;
                user_lcd_display(); /* 刷新显示 */
                user_zheng_con();   /* 整点报时控制 */
                user_alarm_con();   /* 闹钟控制 */
            }
        }
        if (naozhong_music) {
            music_beep(naozhong_music);
        }
        if (set == 19) {
            if (TR0 == 1) {
                /* 秒表 unsigned char num=0,ms100=0,second100=0,minute100=0; */
                memset(xianshi, 0, sizeof(xianshi));                                            /* 清空 */
                sprintf(xianshi, "%02d:%02d:%01d", (int)minute100, (int)second100, (int)ms100); /* 装填 */
                LCD_write_str(0, 1, xianshi);
            }
        }
    }
}
void T0_time0(void) interrupt 1 {
    TH0 = (65536 - 50000) / 256;
    TL0 = (65536 - 50000) % 256;
    num2++;
    if (num2 == 2) /* 1秒 */
    {
        num2 = 0;
        ms100++;
        if (ms100 == 10) {
            ms100 = 0;
            second100++;
            if (second100 == 60) {
                second100 = 0;
                minute100++;
            }
        }
    }
}
全部代码见：dt4.8tupian.net/2/28880a11b7000.pg3
```

【51单片机】万年历功能的数字时钟+倒计时 Proteus仿真 普中板子可用

读取效果：





![在这里插入图片描述](/static/img/images/04569.png)

标准的SPI时序：

![在这里插入图片描述](/static/img/images/04570.png)

寄存器：

![在这里插入图片描述](/static/img/images/04571.png)

部分代码：

float toFloat(signed int tempr)

{

    float result = (float) (tempr >> 8); //Discard LSByte (Only holds fraction flag bits)

    char count = tempr & FRAC_FLAG;

    if (count)

    {

        count = count >> 6;

        result = result + (count * 0.25);

    }

    return (result);

}

void main(void)

{

    char cnt = 0;

    unsigned char disp[16];

    float temp1 = 0.0f;

    WDTCTL = WDTPW + WDTHOLD; /* 关闭看门狗 */

    P1DIR = 0xFF; /* 设置方向 */

    P1SEL = 0; /* 设置为普通I/O 口 */

    P2DIR = 0xFF; /* 设置方向 */

    P2SEL = 0; /* 设置为普通I/O 口 */

    P2OUT = 0x00;

    P1OUT = 0x00;

    delay_ms(200);

    LCD_init();

    TC72_Init();

    while (1)

    {

        temp1 = toFloat(TC72_ReadTempr());

        cnt = 0;

        disp[cnt++] = 0x30 + ((int) temp1 / 10);

        disp[cnt++] = 0x30 + ((int) temp1 % 10);

        disp[cnt++] = '.';

        disp[cnt++] = 0x30 + ((int) (temp1 * 10) % 10);

        disp[cnt++] = 0x30 + ((int) (temp1 * 100) % 10);

        LCD_dsp_string(0, 1, disp);

        delay_ms(100);

    }

}

这段代码是一个温度转换程序。它将一个有符号的整数温度值转换为浮点数，并在 LCD 显示屏上显示出来。

首先，给出了一个名为 toFloat 的函数，用于将有符号整数 tempr 转换为浮点数。函数内部的具体操作如下：

将 tempr 右移 8 位，得到一个浮点数类型的 result，这里右移 8 位是为了舍弃低字节（仅包含小数部分标志位）。

从 tempr 中获取一个名为 count 的变量，用于表示低字节中的计数值。

如果 count 不为零，则将 count 右移 6 位，得到实际的计数值，并将其乘以 0.25，然后加到 result 上去。

返回转换后的浮点数 result。

然后，在 main 函数中，使用了以下步骤：

初始化一些变量和设置引脚的方向。

初始化 LCD 屏幕和 TC72 温度传感器。

进入一个无限循环，不断读取温度并显示在 LCD 屏幕上：

使用 TC72_ReadTempr 函数读取温度值，并调用 toFloat 函数将其转换为浮点数赋给 temp1。

将 temp1 的整数部分和小数部分拆分并转换为字符，存储在 disp 数组中。

调用 LCD_dsp_string 函数将 disp 数组中的内容显示在 LCD 屏幕上。

延时 100 毫秒。

通过这段代码，可以实现温度读取和显示功能。


源码：http://dt4.8tupian.net/2/28880a13b6880.pg3

# 帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

【TB作品】MSP430单片机 Proteus仿真 TC72 温度传感器 温度的设置与显示

# 读取与显示





Burst模式连续读取到DS1302数组，存放顺序是 秒、分、时、日、月、周、年。

这段代码是一个嵌入式系统的程序，用于控制一个基于MSP430微控制器的时钟显示器。下面是代码的解释：

#include 部分是引入了所需要的头文件，包括MSP430微控制器的库、ds1302驱动以及LCD显示器的库。

void main(void) 是主函数的定义，程序从这里开始执行。

WDTCTL = WDTPW + WDTHOLD; 关闭了看门狗定时器，防止系统复位。

P1DIR = 0xFF; 和 P2DIR = 0xFF; 设置了P1和P2端口为输出模式。

P2OUT = 0x00; 和 P1OUT = 0x00; 将P1和P2端口的输出初始化为0。

delay_ms(200); 是一个延时函数，延时200毫秒。

LCD_init(); 初始化LCD显示器。

P5DIR = 0xFF; 和 P5SEL = 0; 设置了P5端口为输出模式。

TimeData 数组存储了时间和日期信息，依次表示秒、分、时、日、月、年和星期。

Init_DS1302(); 初始化ds1302实时时钟模块。

while (1) 是一个无限循环，程序将会在此处一直运行。

Read_DS1302_Time(DS1302_R_ADDR) 从ds1302模块读取时间和日期，并将其存储在TimeData数组中。

LCD_dsp_string(0, 1, disp); 在第一行显示日期信息。

LCD_dsp_string(0, 2, disp); 在第二行显示时间信息。

TimeData[5]=getWeekdayByYearday(2000+TimeData[6],TimeData[4],TimeData[3]); 计算当前日期对应的星期几，并将结果保存在TimeData[5]中。

switch (TimeData[5]) 根据TimeData[5]的值选择相应的星期字符串，在第二行的特定位置显示。

delay_ms(500); 延时500毫秒。

以上就是代码的大致解释。该程序通过读取ds1302实时时钟模块的数据，将时间和日期显示在LCD上，并且还会显示当前日期对应的星期几。循环执行，实现了时钟的实时更新。

```c
void main(void)
{
    char cnt=0;
    unsigned char disp[16];
    WDTCTL = WDTPW + WDTHOLD; /* 关闭看门狗 */
    P1DIR = 0xFF; /* 设置方向 */
    P1SEL = 0; /* 设置为普通I/O 口 */
    P2DIR = 0xFF; /* 设置方向 */
    P2SEL = 0; /* 设置为普通I/O 口 */
    P2OUT = 0x00;
    P1OUT = 0x00;
    delay_ms(200);
    LCD_init();
//    LCD_dsp_string(1, 1, "QQ742971636");
    DS1302[0]=58;//秒
    DS1302[1]=59;//分
    DS1302[2]=23;//时
    DS1302[3]=31;//日
    DS1302[4]=1;//月
    DS1302[6]=0;//年
    DS1302[5]=1;//星期
    Init_DS1302();
    while (1)
    {
        Read_DS1302_Burst_Mode();
        cnt=0;
        disp[cnt++]=DS1302[6]/10+'0';
        disp[cnt++]=DS1302[6]%10+'0';
        disp[cnt++]='-';
        disp[cnt++]=DS1302[4]/10+'0';
        disp[cnt++]=DS1302[4]%10+'0';
        disp[cnt++]='-';
        disp[cnt++]=DS1302[3]/10+'0';
        disp[cnt++]=DS1302[3]%10+'0';
        disp[cnt++]=0;
        LCD_dsp_string(0, 1, disp);
        cnt=0;
        disp[cnt++]=DS1302[2]/10+'0';
        disp[cnt++]=DS1302[2]%10+'0';
        disp[cnt++]=':';
        disp[cnt++]=DS1302[1]/10+'0';
        disp[cnt++]=DS1302[1]%10+'0';
        disp[cnt++]=':';
        disp[cnt++]=DS1302[0]/10+'0';
        disp[cnt++]=DS1302[0]%10+'0';
        disp[cnt++]=0;
        LCD_dsp_string(0, 2, disp);
        switch(DS1302[5])
        {
            case 1:  LCD_dsp_string(12, 2, "MON");break;
            case 2:  LCD_dsp_string(12, 2, "TUE");break;
            case 3:  LCD_dsp_string(12, 2, "WED");break;
            case 4:  LCD_dsp_string(12, 2, "THU");break;
            case 5:  LCD_dsp_string(12, 2, "FRI");break;
            case 6:  LCD_dsp_string(12, 2, "SAT");break;
            case 7:  LCD_dsp_string(12, 2, "SUN");break;
        }
        delay_ms(100);
    }
}
```

仿真图：

![在这里插入图片描述](/static/img/images/04572.jpeg)



# DS1302寄存器介绍

写入0x80到0x8c即可。

![在这里插入图片描述](/static/img/images/04573.png)

# 液晶显示代码

这段代码是为了控制液晶屏(LCD1602)显示内容的函数库。主要包括以下几个函数：

LCD_write_command(unsigned char command)：向液晶屏写入指令的函数。

LCD_write_dat(unsigned char dat)：向液晶屏写入数据的函数。

LCD_set_xy(unsigned char x, unsigned char y)：设置液晶屏的显示位置。

LCD_dsp_char(unsigned char x, unsigned char y, char dat)：在指定位置显示一个字符。

LCD_dsp_string(unsigned char X, unsigned char Y, char *s)：在指定位置显示一个字符串。

LCD_init(void)：初始化液晶屏。

其中，定义了一些接口和函数的宏，如LCDIO、LCD1602_RS_1等。这些宏定义用于控制具体的引脚和功能。

代码中还有一个LCD_check_busy()函数，用于检查液晶屏是否忙于执行操作，但实践证明该函数在某些液晶屏上不能正常使用，因此没有再使用该函数。

整体来说，这段代码实现了对液晶屏的基本操作，包括写入指令和数据、设置显示位置和显示内容等。通过调用这些函数，可以实现控制液晶屏显示不同的内容。

```c
#include "LCD.h"
#include <string.h>
/**************定义接口************************/
#define LCDIO       P1OUT
#define LCD1602_RS_1    P2OUT   |= 1
#define LCD1602_RS_0    P2OUT   &=~1
#define LCD1602_RW_1    P2OUT   |= 2
#define LCD1602_RW_0    P2OUT   &=~2
#define LCD1602_EN_1    P2OUT   |= 4
#define LCD1602_EN_0    P2OUT   &=~4
/**************定义函数************************/
void LCD_write_command(unsigned char command); /* 写入指令函数 */
void LCD_write_dat(unsigned char dat); /* 写入数据函数 */
void LCD_set_xy(unsigned char x, unsigned char y); /* 设置显示位置函数 */
void LCD_dsp_char(unsigned char x, unsigned char y, char dat); /* 显示一个字符函数 */
void LCD_dsp_string(unsigned char X, unsigned char Y, char *s); /* 显示字符串函数 */
void LCD_init(void); /* 初始化函数 */
/*******检查忙函数*************/
void LCD_check_busy() /* 实践证明，在我的LCD1602上，检查忙指令通过率极低，以 */
{ /* 至于不能正常使用LCD。因此我没有再用检查忙函数。而使 */
    P1DIR = 0x00;
    LCDIO = 0xff;
    LCD1602_RS_0; /* 要用200次循环便能完成。 */
    LCD1602_RW_1;
    LCD1602_EN_1;
    while (P1IN & 0x80)
        ;
    LCD1602_EN_0;
    P1OUT = 0x00;
    P1DIR = 0xFF;
}
/******************************/
/**************写指令函数********************************/
void LCD_write_command(unsigned char command)
{
    /* LCD_check_busy(); //加上这句仿真无法通过 */
    LCD1602_RS_0;
    LCDIO = command;
    LCD1602_EN_1;
    /* delay_ms(1); */
    LCD1602_EN_0;
    delay_ms(1);
}
/***************************************************/
/****************写数据函数************************/
void LCD_write_dat(unsigned char dat)
{
    /* LCD_check_busy();  //加上这句仿真无法通过 */
    LCD1602_RS_1;
    LCDIO = dat;
    LCD1602_EN_1;
    /* delay_ms(1); */
    LCD1602_EN_0;
    delay_ms(1);
    LCD1602_RS_0;
}
/****************************************************/
/***************设置显示位置**************************/
void LCD_set_xy(unsigned char x, unsigned char y)
{
    unsigned char address;
    if (y == 1)
        address = 0x80 + x;
    else if (y == 2)
    {
        address = 0x80 + 0x40 + x;
    }
    LCD_write_command(address);
}
/***************************************************/
/****************显示一个字符**********************/
void LCD_dsp_char(unsigned char x, unsigned char y, char dat)
{
    LCD_set_xy(x, y);
    LCD_write_dat(dat);
}
/**********************************************/
/***************显示字符串函数***************/
void LCD_dsp_string(unsigned char X, unsigned char Y, char *s)
{
    uchar len, List;
    len = strlen(s);
    LCD_set_xy(X, Y);
    for (List = 0; List < len; List++)
        LCD_write_dat(s[List]);
}
/**************************************/
/************初始化函数****************/
void LCD_init(void)
{
    LCD1602_RW_0;
    LCD1602_EN_0;
    /* CLEARSCREEN;//clear screen */
    LCD_write_command(0x38); /* set 8 bit data transmission mode */
    delay_ms(1);
    LCD_write_command(0x38); /* set 8 bit data transmission mode */
    delay_ms(1);
    LCD_write_command(0x38); /* set 8 bit data transmission mode */
    delay_ms(1);
    LCD_write_command(0x06); /* open display (enable lcd display) */
    delay_ms(1);
    LCD_write_command(0x0C); /* set lcd first display address */
    delay_ms(1);
    LCD_write_command(0x01); /* clear screen */
    delay_ms(1);
    /*
     * LCD_write_command(0x80);//clear screen
     * delay_ms(1);
     */
}
```

# 全部源码

源码：http://dt2.8tupian.net/2/28880a14b9990.pg3

# 帮助、问询

```csharp
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```