抢答器





任务要求：

四名选手各有一个抢答按键，按键的编号以及指示灯（手柄板上的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
```