你可能更需要这个播放器：[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
```