普中51-单核-A3&A4开发板原理图





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

用到数码管、LED、矩阵按键

描述：

（1）按键是0到15

（2）按键0~7对应着小灯0~7

（3）有三个小灯的引脚和数码管驱动的引脚重复了，所以实际上只用了5个小灯。

（4）初始状态下8个小灯全部点亮数码管所技术的分数为0。

（5）按键8开始游戏，5个小灯会随机点亮一个。在4秒内用户需要给出对应的按键进行打地鼠。如果4秒了用户还没有打地鼠，那么会随机点亮另一外的小灯。

（6）小灯带4秒的时候还没有被打分数不扣分。打地鼠打错了也不扣分。但是也可以自己添加逻辑达到扣分的要求。

（7）按键9结束游戏，小灯全部点亮，回到初始状态。

仿真图：

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

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


一部分代码：

```c
  if ( counter_Whac == 0 )                                                /* 游戏只有一次不然只有复位 结束游戏后这个变量要变 */
  {
   randomNumber = ramdomSeed % 5;                               /* 生成随机数 */
   ledpTempV = (unsigned char) (0x01 << randomNumber);       /* 随机数  亮某一个灯 */
   ledpTempV = ( (ledpTempV & 0x1c) << 3) + (ledpTempV & 0x03);
   P2  = ~ledpTempV;                                   /* 点亮随机灯 */
   timeifg_Whac = 0;
   time_Whac = 0;
   KeyValue = 66;                                           /*按键初始化 */
   while ( !timeifg_Whac )                                         /* 4s后timeifg_Whac会成为1 */
   {
    KeyScan();                                              /*  KeyValue 的值改变为0 到7 */
    if ( KeyValue != 66 )                                   /*按键值一旦改变就说明按下了 */
    {
     if ( randomNumber == map[KeyValue] )                 /* 如果是随机数的值 */
     {
      score_Whac++;                           /* 加一分 */
      seg_disp[0] = score_Whac / 1000;    /* 整除 取下千位数字 */
      seg_disp[1] = score_Whac % 1000 / 100;
      seg_disp[2] = score_Whac % 100 / 10;
      seg_disp[3] = score_Whac % 10;
      P2  = 0xff;
      break;                                  /* 继续游戏 */
     }else if ( KeyValue == 9 )
     {
      counter_Whac = 1;                    /* 结束游戏 */
      P2  = 0x1c;                 /* 小灯全部点亮 表示游戏结束 */
      break;
     }else{
      /*按错按键不处理 */
      break;
     }
    }
   }
   if ( timeifg_Whac == 1 )   /* 打地鼠超时 不处理 */
   {
   }
  }
```


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

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

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

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

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

代码和仿真打开下载：

```bash
 http://dt3.8tupian.net/2/28880a65b16880.pg3
```

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

51单片机 普中51 打地鼠游戏 仿真 程序 流程图

已完成





设计一台以51为核心的，可供16名选手参加比赛的智力竞赛抢答器。

（1）16名选手各一个按键抢答采用4×4矩阵按键。

（2）主持人两个案件分别用来系统清零和开始。

（3）主持人按一下开始按键LED点阵显示抢答倒计时间由9倒计到零时无人抢答，蜂鸣器响。

（4）选手抢答成功时，LED点阵显示选手号，同时蜂鸣器发出三声间隔一秒提升倒计时停止。初始状态LED点阵显示为0，当抢答成功时，LED点阵显示为选手号。

```c
#define KEYS P1  
sbit start_key = P3 ^ 0;
sbit qingl_key = P3 ^ 1;
sbit beep_port = P2 ^ 1;
sbit HC595_SER = P3 ^ 4;
sbit HC595_CLK1 = P3 ^ 6;
sbit HC595_CLK2 = P3 ^ 5;
```

51单片机 16路抢答 显示在 点阵 普中 V2

已完成





二、抢答器

任务要求：

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

评分细则：

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

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

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

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

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

【注释】

按键P15为抢答开始键 3、   按键P16为数据清零（复位）键 4 ；

MSP430、STM32单片机选手抢答键为P11、P12、P13、P14四个键，分别对应编号1~4；STC89C51单片机选手抢答键为P13、P14两个键，分别对应编3、4。LED1~LED4分别对应编号1~4。

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

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

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




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

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

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

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

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

51单片机 抢答器 51 口袋手柄板 晨启

已经完成





一、密码锁

任务要求：

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

评分细则：

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

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

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

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

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

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

【注释】

口袋开发板上标注P15为撤销键，P16为确认键。MSP430、STM32单片机密码输入键为P11、P12、P13、P14四个键，共四个数字（或者字符）；STC89C51单片机密码输入键为P13、P14两个键，共两个数字（或者字符）。哪一个键代表什么数字（或字符），使用者可自定义。


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

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

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


代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

MSP430 F149 单片机 密码锁 口袋 手柄 板子

# 功能





16个按键，一个按键一个音。按下去就响，松开就不响。

# 部分代码

伪代码：
```c
    while (1)
    {
        key = get_key();                     //获取按键
        if (key)
        {
            key=map[key-1];
            CCR0 = SYSCLK / fre_st[key - 1] / 2; /*选一个频率 */
            while (get_key())
                ;                     //等待按键松开
            TACTL = TASSEL_2 + MC_0; /* 关闭中断 蜂鸣器不发出声音 */
            //P2OUT |= BIT2;
            P2OUT &= ~BIT2;
        }
    }
}
/* Timer A0 interrupt service routine */
#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A(void)
{
    P2OUT ^= BIT2;                     //取反蜂鸣器 发声
}
```

# 实物

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


# 帮助、问询

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

【TB作品】MSP430 G2553 矩阵键盘 无源蜂鸣器 电子琴

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





按键控制开始暂停

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


```c
int main(void)
{
    unsigned char dis[15], count;
    WDTCTL = WDTPW | WDTHOLD;   // stop watchdog timer
    //设置单片机工作时钟 设置为1MHZ
    if (CALBC1_1MHZ == 0xFF)                  // If calibration constant erased
    {
        while (1)
            ;                               // do not load, trap CPU!!
    }
    DCOCTL = 0;                          // Select lowest DCOx and MODx settings
    BCSCTL1 = CALBC1_1MHZ;                    // Set range
    DCOCTL = CALDCO_1MHZ;                     // Set DCO step + modulation */
    Port_init(); /* 显示器引脚初始化 */
    LCD_init(); /* 显示器初始化 */
```

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

MSP430 G2553 LCD1602 秒表

已经完成。





三、通信聊天

任务要求：

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

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

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

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

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

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

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

MSP430F149 单片机 通信聊天

已完成。






简易波形发生器 （限MSP430、STM32单片机）

任务要求：

制作一个简易波形发生器，具有如下功能：

1、能够产生方波、正弦波，并可通过示波器观察到；（30分）

2、可通过按键切换2种波形的产生；（20分）

3、在OLED显示屏上显示当前输出的波形类型的名称、频率和幅值；（20分）

4、通过独立按键修改波形的频率、幅值；（10分）

5、LED1~LED8同时亮起，且输出波形的幅值越大，LED灯亮度越大。（20分）

附加题：

在本题基础上，增加产生三角波的功能。


这是采用MSP430F149搭配板子上的DA芯片做的一个题目。

10ms中断中控制da输出。
```c
unsigned long Time10msTick = 0;
#pragma vector = TIMERA1_VECTOR
__interrupt void Timer_A( void )
```

下面是由公式得到Voltage_temp电压，随时间变化，Voltage_temp是正弦变化的。
```c
if ( waveForm == 1 )                                                                                                                                                              /* waveForm 1  正弦 */
  {
   /* 1  获取离散周期 比如周期等于10 代表10个中断时间是一个周期 */
   DispersedCycleTime = (int) (1000.0 / ( (float) waveForm_fre) );
   /* 2 给电压，正弦就是根据Asin(wx)离散采样公式 */
   if ( DispersedSamplingTime < (DispersedCycleTime) )
   {
    Voltage_temp = ( ( (float) waveForm_amplitude) / 10) * sin( 2 * 3.14 / (float) DispersedCycleTime * DispersedSamplingTime ) + ( ( (float) waveForm_amplitude) / 10); /* 幅度 */
    Voltage_temp /= 2.0;
   }else{
    DispersedSamplingTime = 0;
   }
  }
```

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

MSP430F149 单片机 波形发生器 示波器

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





# 部分代码
```c
// Timer A0 interrupt service routine
#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A(void)
{
    t_count = (t_count + 1) % 500;       //500次2ms就是1s
    if (t_count == 1)
    {
        rtc_sec++;
        if (rtc_sec == 60)
        {
            rtc_sec = 0;
            rtc_min++;
            if (rtc_min == 60)
            {
                rtc_min = 0;
                rtc_hour++;
                if (rtc_hour == 24)
                {
                    rtc_hour = 0;
                }
            }
        }
        num_str[0] = rtc_hour % 100 / 10;       //取位数字
        num_str[1] = rtc_hour % 10;       //取位数字
        num_str[2] = 10;       //表示什么都不显示
        num_str[3] = rtc_min % 100 / 10;       //取位数字
        num_str[4] = rtc_min % 10;       //取位数字
        num_str[5] = 10;       //表示什么都不显示
        num_str[6] = rtc_sec % 100 / 10;       //取位数字
        num_str[7] = rtc_sec % 10;       //取位数字
    }
    seg_count = (seg_count + 1) % 8;       //seg_count等于0到3中的一个
    LedScreen_WrTwoByte(~(0x01 << seg_count), ~LED_0F[num_str[seg_count]]); //选择第seg_count个数码管  亮的字为num_str数组中的数字
}
```

# 代码

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

【TB作品】MSP430G2553 HC595 数码管 SPI 显示 时分秒

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





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

软件IIC:

```c
/*
 * **************************************
 * 向I2C设备写入一个字节数据
 * **************************************
 */
void Single_WriteI2C( uchar SlaveAddress, uchar REG_Address, uchar REG_data )
{
    I2C_Start();                    /* 起始信号 */
    I2C_SendByte( SlaveAddress );   /* 发送设备地址+写信号 */
    I2C_SendByte( REG_Address );    /* 内部寄存器地址， */
    I2C_SendByte( REG_data );       /* 内部寄存器数据， */
    I2C_Stop();                     /* 发送停止信号 */
}
Single_WriteI2C( 0x90, 0x40, dac_value );               /* 地址  寄存器  电压 */
```

硬件IIC:

```c
初始化：
I2C_init(0x90>>1);
向寄存器写入数据：
pcf_write(0x40,dac_value);
```

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

MSP430 G2553 硬件 IIC 软件 IIC PCF8591 ADC DAC

模拟SPI接法是任意的：





```c
//HC595
//VCC-VCC GND-GND RCK-P21   SCK-P22   DIO-P20
```

硬件SPI，调节成3线SPI模式 8bit就可以通信：

P14  P12 分别是SPI时钟线和主机输出线。
```c
//HC595
//VCC-VCC GND-GND RCK-P21锁存信号，传输一次完成后给595锁存信号     SCK-P14 SPI时钟线2553拉起          DIO-P12 SPI输出给595
```

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

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

单片机 MSP430 G2553 HC595 数码管 SPI 通信

功能： 用蜂鸣器播放一首天空之城的音乐 。





![用](/static/img/images/01703.png)

需要无源蜂鸣器。


//如果根据简谱修改音乐?

//第一步

//首先修改music0 的变量，

//低音下面加点

//中音不加点

//高音上面加点

//根据简朴的符号写出对应C调音

//第二步 修改music0_JP数组  这个数组和上一个数组对应 就是每一个音 响多长时间

//普通无点是延时 7 即是800ms

//如果音 下有一条下划线，延时 4

//如果音 下有两条下划线，延时2

//如果音 后加一个点  延时12

//如果音后加一条线 延时16

//如果音后加2条线 延时20

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

单片机 MSP430 G2553 F5529 蜂鸣器 音乐 音乐播放器

# 1 原理





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

测距原理：

tirg平时都给低电平，当测距时，给trig输入10us以上的高电平，模块就会被激发。模块上的发射口向外发射8个40khz的声波信号。并开始计时。

声波遇到障碍物反射回来，模块的接收口收到这组声波后，会在echo引脚输出一段时间的高电平。高电平持续的时间刚好就是从开始计时到接受声波这2个事件所经历的时间。也即是声波从发出到被接受往返距离所用时间。

所以：

往返距离=echo高电平时间*声速

单程距离=超声波到障碍物距离=echo高电平时间*声速/2

测距注意：精准测量距离需要超声波模块和障碍物墙面严格平行。

编程：

单片机需要测定echo高电平时间。一般的单片机都可以用定时器去读取时间，MSP430 G2553 可以依靠捕获功能，捕获上升沿到下降沿的时间，从而得到距离。

# 2 MSP430G2553读取的代码

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

MSP430G2553：

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

这段代码是一个基于MSP430微控制器的超声波测距程序。主要使用了MSP430的定时器和IO口控制。

代码中的宏定义部分定义了一些常量和函数，如CPU时钟频率、延时函数等。

在main()函数中，初始化了MSP430的基本时钟系统（BCSplus_init），初始化了OLED显示屏，并设置了TRIG和ECHO引脚的方向和选择模式。然后通过一个无限循环开始测距和显示距离的操作。

在测距过程中，首先打开定时器计数功能并设置触发方式为上升沿捕获。然后通过设置TRIG引脚产生一个短时间的高电平信号来触发超声波模块发送出去。接着进入低功耗模式（LPM0）等待超声波发射并接收返回的回波信号。

当超声波模块发送回波信号后，通过定时器的中断处理程序进行捕获。根据定时器的计数值和捕获时间，计算出距离，并显示在OLED屏上。最后退出低功耗模式，回到主循环继续进行下一次测距操作。

在代码末尾的BCSplus_init()函数中，对MSP430的基本时钟系统进行了设置，使得MCLK和SMCLK的时钟频率为16MHz。

总体来说，这段代码实现了超声波测距功能，并通过OLED显示距离结果。


# 3 MSP430F5529读取超声波的代码

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

MSP430F5529：

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

这段代码实现了一个超声波测距仪的功能。具体解释如下：

包含了头文件 "OLED.h" 和 <msp430.h>，用于调用相应的函数和库。

定义了一些常量和函数。

CPU_F 表示外部高频晶振的频率，这里设置为8MHz。

delay_us(x) 和 delay_ms(x) 是延时函数，用于延时指定的微秒和毫秒数。

Send_Byte(char data) 函数用于发送一个字节的数据。

Print_Str(char *s) 函数用于发送一个字符串。

声明了一些全局变量，包括 END_Date、STA_Date、over_flag、cap_fail_count 和 distance。

main() 函数是程序的入口。

首先停止看门狗计时器（WDT）。

设置时钟频率为8MHz。

初始化串口通信（UART）。

配置IO口和定时器，用于控制超声波传感器和测距。

初始化OLED显示屏。

启用中断并进入主循环。

激发超声波信号，并开始测距。

计算得到的时间差转换为距离，并进行显示。

延时一段时间后继续下一次测距。

TIMER0_A1_VECTOR 是定时器0通道1中断的中断处理函数。

判断捕获模式，如果是高电平，则保存开始时间；如果是低电平，则保存结束时间并设置标志位。

以上就是这段代码的主要功能和逻辑。它使用MSP430微控制器实现超声波测距功能，并通过OLED显示屏显示测距结果。

# 4 串口发送

串口发送

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

# 5 模块必须是3.3V供电，不然有单片机烧毁风险

**超声波模块有的只能5V供电才能工作！有的兼容3.3V~5V都能正常供电。买的时候得注意。**

**如果是3.3V的单片机，推荐购买下图这种超声波模块：**

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

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

或者下图这种HC-SR04+ （左下角型号里有个+号）

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

# 用超声波模块做倒车雷达

[https://blog.csdn.net/x1131230123/article/details/109649680](https://blog.csdn.net/x1131230123/article/details/109649680)

代码:

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

单片机 MSP430 G2553 F5529 超声波 检测原理 测距原理 SR04 串口

模块，都一样，无区别





GY302上拉电阻473，跟没上拉一样，想要数据读取稳，得自己给MCU接上拉电阻。

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

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

ADDR在模块中接了GND，无需接。默认地址是0X46，不是0x23。

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

分辨率可以选，电源可以关断。开启转换后等待时间有120ms或者16ms。

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

1lx分辨率，结果除以1.2就是lx单位

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

```c
#include <msp430.h>
#include "gy30.h"
//SCL--P1.4
//SDA--P1.5
//VCC--3.3V
//GND--GND
//ADDR--不接
float lx;
int main(void)
{
    WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
    if (CALBC1_1MHZ == 0xFF)                  // If calibration constant erased
    {
        while (1)
            ;                               // do not load, trap CPU!!
    }
    DCOCTL = 0;                          // Select lowest DCOx and MODx settings
    BCSCTL1 = CALBC1_1MHZ;                    // Set range
    DCOCTL = CALDCO_1MHZ;                     // Set DCO step + modulation */
    while (1)
    {
        lx = get_lightpower();
        delay_ms(200);
    }
}
```

加个显示器，晚上日光灯光强170Lx，日照会上10000Lx甚至更高。

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

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

单片机 MSP430G2553 bh1750 GY-30 GY-302光强传感器

# DHT11原理





DHT11原理：[https://blog.csdn.net/x1131230123/article/details/103665953](https://blog.csdn.net/x1131230123/article/details/103665953)

# MSP430 G2553

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

部分c代码：

这段代码是一个嵌入式系统程序，采用C语言编写。它的作用是通过DHT11传感器获取温湿度数据，并将数据显示在OLED屏幕上。

下面是对代码的详细解释：

int main(void)：定义了main函数，是程序的入口。

unsigned char dis[10];：定义了一个长度为10的无符号字符数组dis，用于存储要显示的字符串。

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

if (CALBC1_8MHZ == 0xFF)：检查校准常量是否被擦除。

while (1);：如果校准常量被擦除，则进入死循环，陷入无限等待状态。

DCOCTL = 0;：选择最低的DCOx和MODx设置，即最低频率设置。

BCSCTL1 = CALBC1_8MHZ;：设置系统时钟频率为8MHz。

DCOCTL = CALDCO_8MHZ;：设置DCO步进和调制。

OLED_Init();：执行OLED初始化操作，准备显示数据。

OLED_ShowString(0, 0, "dht11:");：在OLED屏幕的第一行显示"dht11:"。

while (1)：进入一个无限循环，用于不断读取并显示温湿度数据。

if (start_DHT11())：如果启动DHT11传感器成功。

dis[0] = DHT11T_Data_H % 100 / 10 + '0';：将温度数据的十位数转换为字符并存储在dis数组的第一个位置。

dis[1] = DHT11T_Data_H % 10 + '0';：将温度数据的个位数转换为字符并存储在dis数组的第二个位置。

dis[2] = 'C';：存储字符'C'，表示摄氏度单位。

dis[3] = ' ';：存储一个空格字符。

dis[4] = DHT11RH_Data_H % 100 / 10 + '0';：将湿度数据的十位数转换为字符并存储在dis数组的第四个位置。

dis[5] = DHT11RH_Data_H % 10 + '0';：将湿度数据的个位数转换为字符并存储在dis数组的第五个位置。

dis[6] = '%';：存储字符'%'，表示湿度的百分比符号。

dis[7] = 0;：在dis数组的末尾加上字符串结束符。

OLED_ShowString(0, 2, dis);：在OLED屏幕的第三行显示dis数组中的数据。

delay_ms(2000);：延时2秒，使程序每2秒读取一次温湿度数据。

以上就是这段代码的解释，它的功能是通过DHT11传感器获取温湿度数据，并将数据显示在OLED屏幕上。
```c
int main(void)
{
    unsigned char dis[10];
    WDTCTL = WDTPW + WDTHOLD; /* Stop WDT */
    if (CALBC1_8MHZ == 0xFF) /* If calibration constant erased */
    {
        while (1)
            ; /* do not load, trap CPU!! */
    }
    DCOCTL = 0; /* Select lowest DCOx and MODx settings */
    BCSCTL1 = CALBC1_8MHZ; /* Set range */
    DCOCTL = CALDCO_8MHZ; /* Set DCO step + modulation * / */
    OLED_Init(); /* OLED初始化 */
    OLED_ShowString(0, 0, "dht11:");
    while (1)
    {
        if (start_DHT11())
        {
            dis[0] = DHT11T_Data_H % 100 / 10 + '0';
            dis[1] = DHT11T_Data_H % 10 + '0';
            dis[2] = 'C';
            dis[3] = ' ';
            dis[4] = DHT11RH_Data_H % 100 / 10 + '0';
            dis[5] = DHT11RH_Data_H % 10 + '0';
            dis[6] = '%';
            dis[7] = 0;
            OLED_ShowString(0, 2, dis);
            delay_ms(2000);
        }
    }
}
```


源码：dt3.8tupian.net/2/28880a17b9990.pg3

# MSP430 F5529

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

串口端：

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

部分c代码：

这段代码是一个包含了温湿度传感器DHT11的微控制器程序。主要功能是读取并显示DHT11传感器测量到的温度和湿度数据。

首先，代码初始化了系统时钟和外设。然后进入一个循环中，不断读取DHT11传感器的数据，并将数据显示在OLED屏幕上。

在循环中，通过调用start_DHT11函数启动DHT11传感器的测量过程。如果测量成功，将测量到的温度和湿度数据存储在dis数组中，并通过OLED_ShowString函数在OLED屏幕上显示出来。

同时，通过Print_Str函数将温湿度数据打印到串口上。

最后，通过delay_ms函数延时2秒，然后再进行下一次的测量和显示。

需要注意的是，该代码在运行之前需要先调用OLED_Init函数进行OLED屏幕的初始化操作。

```c
int main(void)
{
    unsigned char dis[10];
    WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
    UCSCTL3 = SELREF_2;                       // Set DCO FLL reference = REFO
    UCSCTL4 |= SELA_2;                        // Set ACLK = REFO
    UCSCTL0 = 0x0000;                         // Set lowest possible DCOx, MODx
    // Loop until XT1,XT2 & DCO stabilizes - In this case only DCO has to stabilize
    do
    {
        UCSCTL7 &= ~(XT2OFFG + XT1LFOFFG + DCOFFG);
        // Clear XT2,XT1,DCO fault flags
        SFRIFG1 &= ~OFIFG;                      // Clear fault flags
    }
    while (SFRIFG1 & OFIFG);                   // Test oscillator fault flag
    __bis_SR_register(SCG0);                  // Disable the FLL control loop
    UCSCTL1 = DCORSEL_5;                     // Select DCO range 16MHz operation
    UCSCTL2 |= 249;                           // Set DCO Multiplier for 8MHz
                                              // (N + 1) * FLLRef = Fdco
                                              // (249 + 1) * 32768 = 8MHz
    __bic_SR_register(SCG0);                  // Enable the FLL control loop
    // Worst-case settling time for the DCO when the DCO range bits have been
    // changed is n x 32 x 32 x f_MCLK / f_FLL_reference. See UCS chapter in 5xx
    // UG for optimization.
    // 32 x 32 x 8 MHz / 32,768 Hz = 250000 = MCLK cycles for DCO to settle
    __delay_cycles(250000);
    P4SEL |= BIT4 + BIT5;                       // P3.3,4 = USCI_A0 TXD/RXD
    UCA1CTL1 |= UCSWRST;                      // **Put state machine in reset**
    UCA1CTL1 |= UCSSEL_2;                     // SMCLK
    UCA1BR0 = 104;
    UCA1BR1 = 0;
    UCA1MCTL |= UCBRF_3 + UCBRS_0 + UCOS16;
    UCA1CTL1 &= ~UCSWRST;                   // **Initialize USCI state machine**
    //UCA1IE |= UCRXIE;                         // Enable USCI_A0 RX interrupt
    OLED_Init(); /* OLED初始化 */
    OLED_ShowString(0, 0, "dht11:");
    while (1)
    {
        if (start_DHT11())
        {
            dis[0] = DHT11T_Data_H % 100 / 10 + '0';
            dis[1] = DHT11T_Data_H % 10 + '0';
            dis[2] = 'C';
            dis[3] = ' ';
            dis[4] = DHT11RH_Data_H % 100 / 10 + '0';
            dis[5] = DHT11RH_Data_H % 10 + '0';
            dis[6] = '%';
            dis[7] = 0;
            OLED_ShowString(0, 2, dis);
            Print_Str("DHT11温湿度：\r\n");
            Print_Str(dis);
            Print_Str("\r\n");
            delay_ms(2000);
        }
    }
}
```

源码：dt1.8tupian.net/2/28880a16b9990.pg3


# 帮助、问询

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

MSP430 G2553 F5529 单片机 IIC OLED显示 DHT11 温湿度 串口发送 室内温湿度检测仪

MSP430 G2553：





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

MSP430 F5529：

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

串口：

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

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

MSP430 G2553 F5529 单片机 IIC OLED 显示 DS18B20 温度 串口

模块型号：GY-906-BAA,GY-906-BCC,GY-906-DCI





BAA  测距是2cm

BCC 测距是10CM

DCI  测距是一米

资料网盘下载： [https://pan.baidu.com/s/1V4IX0PKG8vDOionICghSTw](https://pan.baidu.com/s/1V4IX0PKG8vDOionICghSTw)


SMBus （System Management Bus，）是 1995 年由 intel 公司提出的一种高效同步串行总线，SMBus 只有两根信号线:双向数据线和时钟信号线，容许 CPU 与各种外围接口器件以串行方式进行通信、交换信息，即可以提高传输速度也可以减小器件的资源占用，另外即使在没有SMBus 接口的单片机上也可利用软件进行模拟。

Melexis 公司生产的 MLX90614 系列测温模块是应用非常方便的红外测温装置，其所有

的模块都在出厂前进行了校验，并且可以直接输出线性或准线性信号，具有很好的互换性，免去了复杂的校正过程。

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

效果还是不错的：

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

STM32F103C8T6
```c
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "timer.h"
#include "led.h"                        /* led */
#include "key.h"                        /* key */
#include  "oled.h"                      /* oled */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include  "gy906.h"       
void user_do( u8 k )
{
 if ( k == 1 )
 {
 }else if ( k == 2 )
 {
 }else if ( k == 3 )
 {
  }
}
void dislay( void )
{
}
int main( void )
{
 u8 keyboard_key;                                           /* 按键返回值 */
 u8 t = 0;                                                  /* /时间计数 */
 float temp;
 NVIC_PriorityGroupConfig( NVIC_PriorityGroup_2 );               /* 设置NVIC中断分组2:2位抢占优先级，2位响应优先级 */
 delay_init();                                                   /* 延时函数初始化 */
 RCC_APB2PeriphClockCmd( RCC_APB2Periph_AFIO, ENABLE );
 GPIO_PinRemapConfig( GPIO_Remap_SWJ_JTAGDisable, ENABLE );      /* 关闭jtag，使能SWD，可以用SWD模式调试 */
 uart_init( 115200 );                                            /* 串口初始化 */
 KEY_Init();                                                     /*按键初始化 */
 LED_Init();                                                     /* LED初始化 蜂鸣器初始化 */
 OLED_Init();                                                    /* OLED初始化B8  B9 */
 SMBus_Init();
 while ( 1 )
 {
  keyboard_key = KEY_Scan( 0 );           /* 检查键盘 */
  if ( keyboard_key != 0 )
  {
   user_do( keyboard_key );        /* 根据案件的编号来对案件进行处理 */
  }
  delay_ms( 10 );
  t++;
  if ( t > 20 )
  {
   t = 0;
   temp=SMBus_ReadTemp();
   printf("%.2f C\r\n",temp);
  }
 }
}
```

代码：

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

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

STM32 单片机 GY-906 MLX90614 红外温度读取

./taobaozuopin.json```c

//编程实现：编写串口接收程序，如果出现奇偶校验错误，点亮P1.3端口的LED，如果出现接收溢出错误，点亮P1.4端口的LED。
//默认8N1数据格式
#include <msp430.h>
int main(void)
{
    WDTCTL = WDTPW | WDTHOLD;     //关闭看门狗
    P3SEL = BIT3 + BIT4;                     //将P3.3,4引脚选择为特殊引脚，开启串口到引脚的映射
    UCA0CTL1 |= UCSWRST;                   //在对串口模块进行设置时需要将其先关掉
    UCA0CTL1 |= UCSSEL_1;                //选择串口模块的工作时钟为ACLK=32768HZ
    UCA0BR0 = 0x0D;         //设置波特率为2400   UCA0BR1_UCA0BR0这两个寄存器合起来要等于32768/2400
    UCA0BR1 = 0x00;         //设置波特率为2400   UCA0BR1_UCA0BR0这两个寄存器合起来要等于32768/2400
    UCA0MCTL |= UCBRS_6 + UCBRF_0; //微调制，因为32768/2400不是整数，所以会有误码，通过微调制减少误码率，微调制数值和32768/2400的小数部分相关联
    UCA0STAT |= UCLISTEN; //打开状态监听
    UCA0CTL1 &= ~UCSWRST;                 //设置完后 打开串口模块
    P1DIR |= (BIT3 + BIT4);                 //设置P1.3  P1.4为输出模式
    P1OUT &= ~(BIT3 + BIT4);                 //让P1.3  P1.4 输出低电平  表示关灯状态
    while (1)
    {
        if (UCA0STAT | UCPE)                 //条件满足 则是奇偶校验错误
        {
            P1OUT |= BIT3;                 //P1.3输出高电平 点亮LED
        }
        else
        {
            P1OUT &= ~ BIT3;                 //P1.3输出低电平 熄灭LED
        }
        if (UCA0STAT | UCOE)                 //条件满足 则是溢出错误
        {
            P1OUT |= BIT4;                 //P1.4输出高电平 点亮LED
        }
        else
        {
            P1OUT &= ~BIT4;                 //P1.4输出低电平 熄灭LED
        }
    }
}
```

```c
// 编程实现：在MSP430F5529单片机系统上，P1.0、P1.1、P1.2和P1.3端口分别接了红色、绿色、蓝色、白色4只LED，均为高电平点亮。P1.4、P1.5、P1.6端口各接有一只按键(S1、S2、S3)，按下为低电平。要求同时实现以下逻辑：
//（1）S1与S2中任意一个按键处于按下状态，红灯亮；
//（2）S2与S3同时处于按下状态时，绿灯亮；
//（3）S1与S3状态不同时，蓝灯亮；
//（4）S1按下后，白灯一直亮，直到S2按下后才灭。
#include <msp430.h>
int main(void)
{
    char key1_ifg, key2_ifg, key3_ifg; //按下标志
    WDTCTL = WDTPW | WDTHOLD;     //关闭看门狗
    P1DIR |= (BIT0 + BIT1 + BIT2 + BIT3);               //设置四个灯为输出模式 红色、绿色、蓝色、白色
    P1OUT &= ~(BIT0 + BIT1 + BIT2 + BIT3);  //输出低电平 初始状态全部小灯不亮
    P1DIR &= ~(BIT4 + BIT5 + BIT6);    //设置三个按键为输入模式  按键按下是低电平
    P1REN |= (BIT4 + BIT5 + BIT6); //上下拉使能
    P1OUT |= (BIT4 + BIT5 + BIT6); //开启内部上拉
    while (1)
    {
        if ((P1IN & BIT4) == 0) //S1按键按下状态
        {
            key1_ifg = 1; //按下标志
        }
        else
        {
            key1_ifg = 0;
        }
        if ((P1IN & BIT5) == 0) //S2按键按下状态
        {
            key2_ifg = 1; //按下标志
        }
        else
        {
            key2_ifg = 0;
        }
        if ((P1IN & BIT6) == 0) //S3按键按下状态
        {
            key3_ifg = 1; //按下标志
        }
        else
        {
            key3_ifg = 0;
        }
        if (key1_ifg == 1 || key2_ifg == 1) //S1与S2中任意一个按键处于按下状态，红灯亮；
        {
            P1OUT |= BIT0; //红灯亮
        }else
        {
            P1OUT &= ~BIT0; //红灯不亮
        }
        if (key2_ifg == 1 && key3_ifg == 1) //S2与S3同时处于按下状态时，绿灯亮；
        {
            P1OUT |= BIT1; //绿灯亮
        }else
        {
            P1OUT &= ~BIT1; //绿灯不亮
        }
        if ((key1_ifg == 1 && key3_ifg == 0)
                || (key1_ifg == 0 && key3_ifg == 1)) //S1与S3状态不同时，蓝灯亮；
        {
            P1OUT |= BIT2; //蓝灯亮
        }else
        {
            P1OUT &= ~BIT2; //蓝灯不亮
        }
        if (key1_ifg == 1) //S1按下后，白灯一直亮   检测到一次后白灯会一直亮
        {
            P1OUT |= BIT3; //白灯亮 刚开始白灯没亮
        }
        if (key2_ifg == 1) //S1按下后，白灯一直亮   检测到一次后白灯会一直亮
        {
            P1OUT &= ~BIT3; //熄灭白灯
        }
    }
}
```

```c
//编程实现：在MSP430F5529单片机系统上，P1.0、P1.1和P1.2端口分别接了红色、绿色、蓝色3只LED，均为高电平点亮。用定时器A实现以下事件：
//（1）红色LED每秒闪烁1次（0.5s亮，0.5s灭）；
//（2）绿色LED每秒闪烁2次（0.25s亮，0.25s灭）；
//（3）蓝色LED每秒闪烁1次（0.25s亮，0.75s灭）。
//提示：选择ACLK  32768Hz时钟，增计数模式
#include <msp430.h>
int main(void)
{
    WDTCTL = WDTPW + WDTHOLD;                 // Stop WDT
    P1DIR |= (BIT0 + BIT1 + BIT2);
    P1OUT &= ~(BIT0 + BIT1 + BIT2);
    TA0CCTL0 = CCIE;                          // CCR0 interrupt enabled
    TA0CCR0 = 327;                          //10MS一次中断
    TA0CTL = TASSEL_1 + MC_1 + TACLR;         // SMCLK, upmode, clear TAR
    __bis_SR_register(LPM0_bits + GIE);       // Enter LPM0, enable interrupts
}
int led1_ifg, led2_ifg, led3_ifg; //时间
#pragma vector=TIMER0_A0_VECTOR
__interrupt void TIMER0_A0_ISR(void)
{
    //（1）红色LED每秒闪烁1次（0.5s亮，0.5s灭）；
    led1_ifg = (led1_ifg + 1) % 100;//100*10ms=1s
    if (led1_ifg < 50)
    {
        P1OUT |= BIT0;
    }
    else
    {
        P1OUT &= BIT0;
    }
    //（2）绿色LED每秒闪烁2次（0.25s亮，0.25s灭）；
    led2_ifg = (led2_ifg + 1) % 50;
    if (led2_ifg < 25)
    {
        P1OUT |= BIT1;
    }
    else
    {
        P1OUT &= BIT1;
    }
    //（3）蓝色LED每秒闪烁1次（0.25s亮，0.75s灭）。
    led3_ifg = led3_ifg + 1) % 100;
    if led3_ifg < 25)
    {
        P1OUT |= BIT2;
    }
    else
    {
        P1OUT &= BIT2;
    }
}
```

# 帮助、问询

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

MSP430F5529 程序

PWM周期100，占空比从0到100，然后从100到0：





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

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

MSP430 G2553 呼吸灯

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





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

main.c

```c
#include<reg52.h>
#include<intrins.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include "lcd1602.h"
#define uchar unsigned char 
#define uint unsigned int
#define u8 unsigned char 
#define u16 unsigned int
//以下是C调低音的音频宏定义
#define L1  262    //将"L1"宏定义为低音"1"的频率262Hz         时间是1/262=3826/2 us    取半周期
#define L2  286    //将"L2"宏定义为低音"2"的频率286Hz
#define L3  311    //将"L3"宏定义为低音"3"的频率311Hz
#define L4  349    //将"L4"宏定义为低音"4"的频率349Hz
#define L5  392    //将"L5"宏定义为低音"5"的频率392Hz
#define L6  440    //将"l_a"宏定义为低音"6"的频率440Hz
#define L7  494    //将"L7"宏定义为低音"7"的频率494Hz
//以下是C调中音的音频宏定义
#define Z1    523     //将"Z1"宏定义为中音"1"的频率523Hz
#define Z2    587     //将"Z2"宏定义为中音"2"的频率587Hz
#define Z3    659     //将"Z3"宏定义为中音"3"的频率659Hz
#define Z4    698     //将"Z4"宏定义为中音"4"的频率698Hz
#define Z5    784     //将"Z5"宏定义为中音"5"的频率784Hz
#define Z6    880     //将"Z6"宏定义为中音"6"的频率880Hz
#define Z7    987     //将"Z7"宏定义为中音"7"的频率523H      
//以下是C调高音的音频宏定义
#define H1  1046    //将"H1"宏定义为高音"1"的频率1046Hz
#define H2  1174    //将"H2"宏定义为高音"2"的频率1174Hz
#define H3  1318    //将"H3"宏定义为高音"3"的频率1318Hz
#define H4  1396    //将"H4"宏定义为高音"4"的频率1396Hz
#define H5  1567    //将"H5"宏定义为高音"5"的频率1567Hz
#define H6  1760    //将"H6"宏定义为高音"6"的频率1760Hz
#define H7  1975    //将"H7"宏定义为高音"7"的频率1975Hz
/*  ******************************************    */
//  ********   硬件端口定义   
/*  ******************************************    */
sbit sound = P1 ^ 4;    //蜂鸣器
sbit KAISHI = P1 ^ 0;        //开始
sbit ZANTING = P1 ^ 1;        //暂停
sbit PRE_KEY = P1 ^ 2;        //上一首
sbit NEXT_KEY = P1 ^ 3;        //下一首
sbit yianjian = P1 ^ 5;        //1
sbit eranjian = P1 ^ 6;        //1
sbit sananjian = P1 ^ 7;        //1
/*  ******************************************    */
//  ********   程序变量定义
/*  ******************************************    */
unsigned int C;     //储存定时器的定时常数
unsigned char u, t;  //音乐所用的变量
unsigned char velocity = 60; //控制节拍使用的 这里100表示一个拍子100ms
unsigned char press_key = 0; //按键  按下后会改变数值  初始值为0
unsigned char open_flag = 1; //暂停时为0  播放时为1
unsigned char music_crr = 0; //当前是播放哪一首音乐  可以为0  1  2  分别是是三首歌
char rtc_hour = 0;
char rtc_min  = 0;
char rtc_sec  = 0;
char num2 = 0;    /* 计数 */
/*  ******************************************    */
//  ********  音乐0    天空之城
/*  ******************************************    */
//以下是《天空之城》简谱    //每行对应一小节音符
unsigned int code music0[]=
{ Z6,Z7,/**/H1,Z7,H1,H3,/**/Z7,Z3,Z3, /**/Z6,Z5,Z6,H1,/**/Z5,Z3,Z3, /**/Z4,Z3,Z4,H1,
 Z3,H1,H1,H1,/**/Z7,Z4,Z4,Z7,/**/Z7,Z6,Z7, /**/H1,Z7,H1,H3,/**/Z7,Z3,Z3, /**/Z6,Z5,Z6,H1,
 Z5, Z3,/**/Z4,H1,Z7,H1,/**/H2,H2,H2,H1,/**/H1,Z6,Z7,Z5,/**/Z6,H1,H2, /**/H3,H2,H3,H5,
 H2,Z5,Z5, /**/H1,Z7,H1,H3,/**/H3, /**/Z6,H1,Z7,H2,/**/H1,Z5,Z5, /**/H4,H3,H2,H1,
 H3, /**/Z3,H3, /**/H6,H5,H5, /**/H3,H2,H1,H1,/**/H2,H1,H2,H5,/**/H3,H3,
 H6,H5, /**/H3,H2,H1,H1,/**/H2,H1,H2,Z7,/**/Z6,Z6,Z7, /**/Z6,0xff}; //以0xff作为音符的结束标志      
//以下是简谱中每个音符的节拍
//"4"对应4个延时单位，"2"对应2个延时单位，"1"对应1个延时单位 
unsigned char code music0_JP[ ]=
{ 4,4, /**/12,4,8,8, /**/20,4,4, /**/12,4,8,8, /**/20,4,4, /**/12,4,4,12,
 20,4,4,4, /**/12,4,8,8, /**/20,4,4, /**/12,4,8,8, /**/20,4,4, /**/12,4,8,8,
 32, 4, /**/8,4,6,8, /**/4,4,4,16, /**/8,4,6,8, /**/24,4,4, /**/12,4,8,8,
 24,4,4, /**/4,4,8,8, /**/32, /**/4,8,8,6, /**/12,4,16, /**/8,8,8,8,
 30, /**/20,8, /**/16,8,8, /**/4,4,16,8, /**/8,4,4,8, /**/20,8,
 16,16, /**/4,20,8, /**/8,4,4,8, /**/20,4,4,8,8, /**/8};
/*  ******************************************    */
//  ********   音乐2
/*  ******************************************    */
unsigned int code music1[]=
{ Z3,Z3,Z5,Z6,H1,H1,Z6,
 Z5,Z5,Z6,Z5,
 Z3,Z3,Z5,Z6,H1,H1,Z6,
 Z5,Z5,Z6,Z5,
 Z5,Z5,Z5,Z3,Z5,
 Z6,Z6,Z5,
 Z3,Z2,Z3,Z5,Z3,Z2,
 Z1,Z1,Z2,Z1,0xff}; //以0xff作为音符的结束标志      
//以下是简谱中每个音符的节拍
//"4"对应4个延时单位，"2"对应2个延时单位，"1"对应1个延时单位 
unsigned char code music1_JP[ ]=
{ 16,8,8,8,8,8,8,
 16,8,8,32,
 16,8,8,8,8,8,8,
 16,8,8,32,
 16,16,16,8,8,
 16,16,32,
 16,8,8,16,8,8,
 16,8,8,32,1,8,8};
/*  ******************************************    */
//  ********   音乐3 小星星
/*  ******************************************    */
unsigned int code music2[]=
{ H3,H3,H3,H2,H1,H2,H5,H5,H1,H1,H1,H1,Z6,
 Z7,H3,H3,Z5,Z6,H6,H5,H4,H3,H2,H1,H1,
 Z6,H1,H2,H5,H5,H2,H1,H2,H2,Z1,H3,H3,
 H3,H2,H1,H2,H5,H5,H1,H1,H1,H1,Z6,Z7,
 H3,H3,Z5,Z6,H6,H5,H4,
 H3,H2,H1,H1,Z6,H1,H2,H5,H5,Z5,H2,H1,
 0xff}; //以0xff作为音符的结束标志      
//以下是简谱中每个音符的节拍
//"4"对应4个延时单位，"2"对应2个延时单位，"1"对应1个延时单位 
unsigned char code music2_JP[ ]=
{ 8,2,2,2,2,4,4,8, 8,2,2,2,2,
 4,4,4,4,8,4,2,2,4,2,2,8,
 2,2,2,2,2,2,2,2,8,8,8,2,2,2,2,4,4,8,8,2,2,2,2,4,4,4,4,8,4,2,2,
 8,2,2,4,2,2,2,2,2,2,4,12,8,8
};
/*  ******************************************    */
//  ********   延时1ms   用于一般延时
/*  ******************************************    */
void delay(uint z)
{
 uint x;
 while (z--)
 {
  for (x = 125; x > 0; x--)
   ;
 }
}
/*  ******************************************    */
//  ********   延时100ms 控制音乐节拍
/*  ******************************************    */
void delay1()
{
 uint i, j;
 for (i = 0; i < velocity; i++)
  for (j = 0; j < 125; j++)
   ;
}
/*  ******************************************    */
//  ********   定时器初始化函数  用了定时器1
/*  ******************************************    */
void init_timer(void)
{
 EA = 1;         //开总中断
 ET1 = 1;        //定时器T1中断允许
 TMOD &= 0x0f;
 TMOD |= 0x00;    // 使用定时器T1的模式1（13位计数器）
 TR1 = 1;
 TMOD |= 0x01;    // 使用定时器T1的模式1（13位计数器）
 TR0 = 1;
 ET0 = 1;        //定时器T1中断允许
}
/*  ******************************************    */
//  ********   按键扫描    返回值 1 2 3 4 5 代表五个按键
/*  ******************************************    */
unsigned char ScanKey(void)
{
 if (KAISHI == 0)  //是否按下
 {
  delay(1);   //延时防止电平抖动
  if (KAISHI == 0)
  {
   while (KAISHI == 0)
    ; //等待松开
   return 1;
  }
 }
 if (ZANTING == 0)
 {
  delay(1);
  if (ZANTING == 0)
  {
   while (ZANTING == 0)
    ;
   return 2;
  }
 }
 if (PRE_KEY == 0)
 {
  delay(1);
  if (PRE_KEY == 0)
  {
   while (PRE_KEY == 0)
    ;
   return 3;
  }
 }
 if (NEXT_KEY == 0)
 {
  delay(1);
  if (NEXT_KEY == 0)
  {
   while (NEXT_KEY == 0)
    ;
   return 4;
  }
 }
 if (yianjian == 0)//选择第1首歌的按键按下
 {
  delay(1);
  if (yianjian == 0)
  {
   while (yianjian == 0)
    ;
   return 5;
  }
 }
 if (eranjian == 0) //选择第二首歌的按键按下
 {
  delay(1);
  if (eranjian == 0)
  {
   while (eranjian == 0)
    ;
   return 6;
  }
 }
 if (sananjian == 0)//选择第3首歌的按键按下
 {
  delay(1);
  if (sananjian == 0)
  {
   while (sananjian == 0)
    ;
   return 7;
  }
 }
 return 0;
}
/*  ******************************************    */
//  ********   处理按键 按下按键后 相应变量改变 
/*  ******************************************    */
void delay_key(void)
{
 if (press_key == 1)  //开始
 {
  open_flag = 1;   //开始
  press_key = 0;
 }
 if (press_key == 2)  //暂停
 {
  open_flag = 0;   //暂停
  press_key = 0;
 }
 if (press_key == 3)   //上一首
 {
  press_key = 0;
  if (music_crr > 0)
  {
   music_crr = (music_crr - 1) % 3;
  } else
  {
   music_crr = 2;   //如果是第0首歌  那么按上一首就是第2首
  }
  LCD_write_char(9,0,music_crr+'1');//显示歌曲号
  rtc_hour=0;rtc_min=0; rtc_sec=0;
 }
 if (press_key == 4)   //下一首
 {
  press_key = 0;
  music_crr = (music_crr + 1) % 3;
  LCD_write_char(9,0,music_crr+'1'); //显示歌曲号
  rtc_hour=0;rtc_min=0; rtc_sec=0;
 }
 if (press_key == 5)    //1
 {
  press_key = 0;
  music_crr=0;
  LCD_write_char(9,0,music_crr+'1'); //显示歌曲号
  rtc_hour=0;rtc_min=0; rtc_sec=0;
  open_flag = 1;   //开始
 }
 if (press_key == 6)    //2
 {
  press_key = 0;
  music_crr=1;
  LCD_write_char(9,0,music_crr+'1'); //显示歌曲号
  rtc_hour=0;rtc_min=0; rtc_sec=0;
  open_flag = 1;   //开始
 }
 if (press_key == 7)    //3
 {
  press_key = 0;
  music_crr=2;
  LCD_write_char(9,0,music_crr+'1'); //显示歌曲号
  rtc_hour=0;rtc_min=0; rtc_sec=0;
  open_flag = 1;   //开始
 }
 if (open_flag == 1)
  {
TR0=1;
  }else
  {
    TR0=0;
  }
 LCD_dis_TIME( 6, 1, rtc_hour, rtc_min, rtc_sec );
}
uint changdu = 0;
/*  ******************************************    */
//  ********   主函数 程序逻辑
/*  ******************************************    */
void main()
{
 LCD_init();
 LCD_write_str(0,0,"   WELCOME!");
 delay(1000);
  LCD_write_str(0,0,"Playing:    ");
 LCD_write_char(9,0,'1');
 LCD_write_str(0,1,"Time:");
 LCD_dis_TIME( 6, 1, rtc_hour, rtc_min, rtc_sec );
 init_timer();
 TR1 = 0;     //关闭定时器
 sound = 0;  //关闭蜂鸣器
 open_flag = 0; //关闭音乐
 TR0 = 0;     //关闭定时器
 LCD_dis_TIME( 6, 1, rtc_hour, rtc_min, rtc_sec );
 while (1)
 {
  press_key = ScanKey();   //获取按下的键
  delay_key();   //将按下的键值传入处理函数 改变状态变量
  if (music_crr == 0 && open_flag == 1)
  {
   u = 0;   //从第1个音符f[0]开始播放
   changdu = sizeof(music0);
   while (music0[u] != 0xff)            //只要没有读到结束标志就继续播放
   {
    press_key = ScanKey();   //获取按下的键
    delay_key();   //将按下的键值传入处理函数 改变状态变量
    if (music_crr != 0)    //切换音乐
    {
     init_timer();
     TR1 = 0;     //关闭定时器
     sound = 1;  //关闭蜂鸣器
     break;
    }
    if (open_flag == 0) //如果暂停音乐
    {
     while (open_flag == 0)
     {
      press_key = ScanKey();   //获取按下的键
      delay_key();   //将按下的键值传入处理函数 改变状态变量
     }
    }
    C = 460830 / music0[u];
    TH1 = (8192 - C) / 32;   //可证明这是13位计数器TH0高8位的赋初值方法     5
    TL1 = (8192 - C) % 32;   //可证明这是13位计数器TL0低5位的赋初值方法
    TR1 = 1;             //启动定时器T0
    changdu--;
    for (t = 0; t < music0_JP[u]; t++)  //控制节拍数
     delay1();          //延时1个节拍单位
    TR1 = 0;                   //关闭定时器T1
    u++;                        //播放下一个音符
   }
   init_timer();
   TR1 = 0;     //关闭定时器
   sound = 1;  //关闭蜂鸣器
  }
  if (music_crr == 1 && open_flag == 1)
  {
   u = 0;   //从第1个音符f[0]开始播放
   changdu = sizeof(music1);
   while (music1[u] != 0xff)            //只要没有读到结束标志就继续播放
   {
    press_key = ScanKey();   //获取按下的键
    delay_key();   //将按下的键值传入处理函数 改变状态变量
    if (music_crr != 1)    //切换音乐
    {
     init_timer();
     TR1 = 0;     //关闭定时器
     sound = 1;  //关闭蜂鸣器
     break;
    }
    if (open_flag == 0) //如果暂停音乐
    {
     while (open_flag == 0)
     {
      press_key = ScanKey();   //获取按下的键
      delay_key();   //将按下的键值传入处理函数 改变状态变量
     }
    }
    C = 460830 / music1[u];
    TH1 = (8192 - C) / 32;   //可证明这是13位计数器TH0高8位的赋初值方法     5
    TL1 = (8192 - C) % 32;   //可证明这是13位计数器TL0低5位的赋初值方法
    TR1 = 1;             //启动定时器T0
    changdu--;
    for (t = 0; t < music1_JP[u]; t++)  //控制节拍数
     delay1();          //延时1个节拍单位
    TR1 = 0;                   //关闭定时器T1
    u++;                        //播放下一个音符
   }
   init_timer();
   TR1 = 0;     //关闭定时器
   sound = 1;  //关闭蜂鸣器
  }
  if (music_crr == 2 && open_flag == 1)
  {
   u = 0;   //从第1个音符f[0]开始播放
   changdu = sizeof(music2);
   while (music2[u] != 0xff)            //只要没有读到结束标志就继续播放
   {
    press_key = ScanKey();   //获取按下的键
    delay_key();   //将按下的键值传入处理函数 改变状态变量
    if (music_crr != 2)    //切换音乐
    {
     init_timer();
     TR1 = 0;     //关闭定时器
     sound = 1;  //关闭蜂鸣器
     break;
    }
    if (open_flag == 0) //如果暂停音乐
    {
     while (open_flag == 0)
     {
      press_key = ScanKey();   //获取按下的键
      delay_key();   //将按下的键值传入处理函数 改变状态变量
     }
    }
    C = 460830 / music2[u];
    TH1 = (8192 - C) / 32;   //可证明这是13位计数器TH0高8位的赋初值方法     5
    TL1 = (8192 - C) % 32;   //可证明这是13位计数器TL0低5位的赋初值方法
    TR1 = 1;             //启动定时器T0
    changdu--;
    for (t = 0; t < music2_JP[u] / 2; t++)  //控制节拍数
     delay1();          //延时1个节拍单位
    TR1 = 0;                   //关闭定时器T1
    u++;                        //播放下一个音符
   }
   init_timer();
   TR1 = 0;     //关闭定时器
   sound = 1;  //关闭蜂鸣器
  }
 }
}
void Time1(void)
interrupt 3   //T1定时器的中断等级要注意  是3
{
 sound=!sound;      //将P3.7引脚输出电平取反，形成方波  
 TH1=(8192-C)/32;//可证明这是13位计数器TH0高8位的赋初值方法
 TL1=(8192-C)%32;//可证明这是13位计数器TL0低5位的赋初值方法 
}
void Time0(void)
interrupt 1  //T1定时器的中断等级要注意  是3
{
 TH0=(65535-50000)/255;  //可证明这是13位计数器TH0高8位的赋初值方法
 TL0=(65535-50000)%255;//可证明这是13位计数器TL0低5位的赋初值方法 
 num2++;
 if ( num2 == 20 )
 {
  num2 = 0;
  rtc_sec++;
  if ( rtc_sec == 60 )
  {
   rtc_sec = 0;
   rtc_min++;
   if ( rtc_min == 60 )
   {
    rtc_min = 0;
    rtc_hour++;
    if ( rtc_hour == 24 )
    {
     rtc_hour = 0;
    }
   }
  }
 }
}
```

lcd1602.h

```c
#include <reg52.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
LCD_init();
LCD_write_str(1,1,"2223123");
*/
sbit lcd_rs=P2^5;
sbit lcd_rw=P2^6;
sbit lcd_en=P2^7;
#define DataPort P0
#define RS_CLR lcd_rs=0
#define RS_SET lcd_rs=1
#define RW_CLR lcd_rw=0
#define EN_CLR lcd_en=0
#define EN_SET lcd_en=1
void delay_lcd_ms(unsigned int a) {
 unsigned int i, j;
 for (i = a; i > 0; i--)
  for (j = 100; j > 0; j--)
   ;
}
//***********************************************************************
// 显示屏命令写入函数
//***********************************************************************
void LCD_write_com(unsigned char com) 
{ 
 RS_CLR;
 RW_CLR;
 EN_SET;
 DataPort = com;                 //命令写入端口
 delay_lcd_ms(5);
 EN_CLR;
}
//***********************************************************************
// 显示屏数据写入函数
//***********************************************************************
void LCD_write_data(unsigned char dataa) 
{
 RS_SET;
 RW_CLR;
 EN_SET;
 DataPort = dataa;                //数据写入端口
 delay_lcd_ms(5);
 EN_CLR;
}
//***********************************************************************
// 显示屏单字符写入函数
//***********************************************************************
void LCD_write_char(unsigned char x,unsigned char y,unsigned char dataa) 
{
    if (y == 0) 
    {
     LCD_write_com(0x80 + x);        //第一行显示
    }
    else 
    {
     LCD_write_com(0xC0 + x);        //第二行显示
    }
    LCD_write_data( dataa);  
}
//***********************************************************************
// 显示屏字符串写入函数
//***********************************************************************
void LCD_write_str(unsigned char x,unsigned char y,unsigned char *s) 
{
 EA=0;
    if (y == 0) 
    {
     LCD_write_com(0x80 + x);        //第一行显示
    }
    else 
    {
     LCD_write_com(0xC0 + x);        //第二行显示
    }
    while (*s) 
    {
     LCD_write_data( *s);
     s ++;
    }
 EA=1;
}
//***********************************************************************
// 显示一个数字 传入坐标和数值
//***********************************************************************
void LCD_dis_TIME(unsigned char x,unsigned char y, int hour,int min,int sec) 
{
   char disp[10];
   memset(disp,0,10);
 sprintf(disp,"%02d:%02d:%02d",hour,min,sec);
   LCD_write_str(x,y,disp);
}
//***********************************************************************
// 显示屏初始化函数
//***********************************************************************
void LCD_init(void) 
{
  LCD_write_com(0x38);  //显示模式设置  
    delay_lcd_ms(5);
  LCD_write_com(0x38);  //显示模式设置  
    delay_lcd_ms(5);
  LCD_write_com(0x38);  //显示模式设置  
    delay_lcd_ms(5);
    LCD_write_com(0x38);  //显示模式设置  
    delay_lcd_ms(5);
    LCD_write_com(0x08);  //显示关闭
    delay_lcd_ms(5);
    LCD_write_com(0x01);  //显示清屏
    delay_lcd_ms(5);
    LCD_write_com(0x06);  //显示光标移动设置
    delay_lcd_ms(5);
    LCD_write_com(0x0C);  //显示开及光标设置
    delay_lcd_ms(5);
}
```