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





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

51单片机 Proteus仿真 联机乒乓球游戏机

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





```c
//键盘 
//启动  停止  加速  减速
//紧急   --   升高  降低
//模式   加时  加分  加秒
// --    减时  减分  减秒
//启动就是开启跑步机 灯0打开 
//停止关闭跑步机  灯0关闭
//加速就是加速跑步机  速度越快 灯0越来越亮
//减速就是减速跑步机  速度越慢 灯0越来越暗  距离会根据速度有换算 速度越快距离随时间变化越大
//紧急是紧急停止的意思 其实就是怕停止按键失效 紧急停止会关闭跑步机
//升高 就是升高跑步机坡度  就是灯1越亮 表示越高  实际跑步机会用舵机 和这个一样原理
//降低  就是降低跑步机坡度
//模式 就是进行模式切换的  按一下 进入倒计时模式 再按一下回到正计时模式  倒计时模式下可以设置倒计时时间
//后面这6个按键就是设置倒计时时间的
#include <reg52.h>
#include <intrins.h>
#include "lcd1602.h"
#define uchar unsigned char
#define uint unsigned int
sbit ENA = P1 ^ 1;       /* 使能 PWM 占空比越大 电机速度越快 接到灯上就是灯会越亮 */
sbit ENB = P1 ^ 0;       /* 使能 PWM 占空比越大 电机速度越快 接到灯上就是灯会越亮 */
uchar pwm_count = 0;    /* PWM计数 不用管 */
char ENA_PWM_data = 1;    /* 0表示占空比0  10表示占空比百分之百 */
char ENB_PWM_data = 9;    /* 0表示占空比0  10表示占空比百分之百 */
uchar open = 0;                 /* 是否打开 */
char rtc_hour = 0;
char rtc_min  = 0;
char rtc_sec  = 0;
char num2 = 0;                  /* 计数 */
uchar time_count_mode = 0;      /* 正计时 */
uint daojishi_shijiana = 0;
void delay( uint z )
{
 uint x;
 while ( z-- )
 {
  for ( x = 125; x > 0; x-- )
   ;
 }
}
void init_timer( void )
{
 EA = 1;                                 /* 开总中断 */
 TMOD = 0x11;
 ET0 = 1;
 TR0 = 1;
 TH0 = (65536 - 50000) / 256;        /* 计数初值重装载 */
 TL0 = (65536 - 50000) % 256;
 ET1 = 1;
 TR1 = 1;
 TH1 = (65536 - 50000) / 256;
 TL1 = (65536 - 50000) % 256;
}
#define GPIO_KEY P3
unsigned char KeyValue = 0xff;
/* 矩阵键盘扫描 电子琴 */
void ScanKey( void )
{
 char a = 0;
 GPIO_KEY = 0x0f;
 if ( GPIO_KEY != 0x0f )         /* 读取按键是否按下 */
 {
  delay( 5 );             /* 延时10ms进行消抖 */
  if ( GPIO_KEY != 0x0f ) /* 再次检测键盘是否按下 */
  {
   /* 测试列 */
   GPIO_KEY = 0X0F;
   switch ( GPIO_KEY )
   {
   case (0X07):
    KeyValue = 0;
    break;
   case (0X0b):
    KeyValue = 1;
    break;
   case (0X0d):
    KeyValue = 2;
    break;
   case (0X0e):
    KeyValue = 3;
    break;
   }
   /* 测试行 */
   GPIO_KEY = 0XF0;
   switch ( GPIO_KEY )
   {
   case (0X70):
    KeyValue = KeyValue;
    break;
   case (0Xb0):
    KeyValue = KeyValue + 4;
    break;
   case (0Xd0):
    KeyValue = KeyValue + 8;
    break;
   case (0Xe0):
    KeyValue = KeyValue + 12;
    break;
   }
   while ( (a < 100) && (GPIO_KEY != 0xf0) ) /* 检测按键松手检测 */
   {
    delay( 10 );
    a++;
   }
  }
 }
}
/*按键处理 */
void KEY_CHULI( void )
{
 uchar map[]={3,7,11,15,2,6,10,14,1,5,9,13,0,4,8,12};
 if (  KeyValue!= 0xff )
 {
  KeyValue=map[KeyValue];
  if ( KeyValue == 0 )
  {
   open = 1;          /* 启动 */
   if ( time_count_mode == 1 )
   {
    /* 倒计时 */
    daojishi_shijiana = rtc_hour * 3600 + rtc_min * 60 + rtc_sec;
   }
  }else if ( KeyValue == 1 )
  {
   open = 0;                            /* 停止 */
   ENA = 1;
  }else if ( KeyValue == 2 )
  {
   ENA_PWM_data++;                         /* 加速 */
   if ( ENA_PWM_data == 11 )
    ENA_PWM_data = 10;
  }else if ( KeyValue == 3 )
  {
   ENA_PWM_data--;                         /*减速 */
   if ( ENA_PWM_data == 0 )
    ENA_PWM_data = 1;
  }else if ( KeyValue == 4 )
  {
   open = 0;                            /*紧急停止 */
   ENA = 1;
  }else if ( KeyValue == 6 )
  {
   ENB_PWM_data++;                         /* 升高 */
   if ( ENB_PWM_data == 11 )
    ENB_PWM_data = 10;
  }else if ( KeyValue == 7 )
  {
   ENB_PWM_data--;                         /*降低 */
   if ( ENB_PWM_data == -1 )
    ENB_PWM_data = 0;
  }else if ( KeyValue == 8 )
  {
   /* 切换到倒计时模式 */
   time_count_mode = !time_count_mode;     /* 切换 */
   open  = 0;
   if ( time_count_mode == 0 )
   {
    rtc_hour = 0;
    rtc_min  = 0;
    rtc_sec  = 0;
   }else{
    rtc_hour = 0;
    rtc_min  = 10;
    rtc_sec  = 0;
   }
  }
  /* 倒计时下可以设置时间 */
  if ( time_count_mode == 1 )
  {
   if ( KeyValue == 9 )
   {
    /* 加 时 */
    rtc_hour++;
    if ( rtc_hour == 24 )
     rtc_hour = 0;
   }else if ( KeyValue == 10 )
   {
    /* 加 分 */
    rtc_min++;
    if ( rtc_min == 60 )
     rtc_min = 0;
   }else if ( KeyValue == 11 )
   {
    /* 加秒 */
    rtc_sec++;
    if ( rtc_sec == 60 )
     rtc_sec = 0;
   }else if ( KeyValue == 13 )
   {
    /* 减时 */
    rtc_hour--;
    if ( rtc_hour == -1 )
     rtc_hour = 23;
   }else if ( KeyValue == 14 )
   {
    /* 减分 */
    rtc_min--;
    if ( rtc_min == -1 )
     rtc_min = 59;
   }else if ( KeyValue == 15 )
   {
    /* 减秒 */
    rtc_sec--;
    if ( rtc_sec == -1 )
     rtc_sec = 59;
   }
   /* 倒计时 */
    daojishi_shijiana = rtc_hour * 3600 + rtc_min * 60 + rtc_sec;
  }
  KeyValue = 0xff; /* 恢复按键状态 */
 }
}
/* 刷新屏幕显示 */
void update( void )
{
 uint juli = 0;
 /*
  * 刷新 速度显示  显示在第一排 第一个位置
  * ENA_PWM_data 就是速度
  */
 LCD_write_str( 0, 0, "A:" );
 LCD_write_char( 2, 0, '0' + ENA_PWM_data / 10 );
 LCD_write_char( 3, 0, '0' + ENA_PWM_data % 10 );
 /*
  * 刷新 角度显示  显示在第一排
  * ENB_PWM_data 就是角度
  */
 LCD_write_str( 5, 0, "B:" );
 LCD_write_char( 7, 0, '0' + ENB_PWM_data / 10 );
 LCD_write_char( 8, 0, '0' + ENB_PWM_data % 10 );
 /* 模式 */
 LCD_write_char( 10, 0, 'M' );
 LCD_write_char( 11, 0, '0' + time_count_mode ); /* 0就是正计时 1就是倒计时 */
 //此时跑步机状态
 LCD_write_char( 13, 0, '0' + open ); /* 0没开 1开着的 */
 /* 刷新时间 */
 LCD_write_char( 0, 1, '0' + rtc_hour / 10 );
 LCD_write_char( 1, 1, '0' + rtc_hour % 10 );
 LCD_write_char( 2, 1, ':' );
 LCD_write_char( 3, 1, '0' + rtc_min / 10 );
 LCD_write_char( 4, 1, '0' + rtc_min % 10 );
 LCD_write_char( 5, 1, ':' );
 LCD_write_char( 6, 1, '0' + rtc_sec / 10 );
 LCD_write_char( 7, 1, '0' + rtc_sec % 10 );
 /* 刷新距离 */
 if ( time_count_mode == 0 )
 {
  juli = (uint)  (rtc_hour * 3600 + rtc_min * 60 + rtc_sec) ;      /* 1s 算走4.5m */
  juli = (uint) (juli*4.5);
 }else{
  juli = (uint)  (rtc_hour * 3600 + rtc_min * 60 + rtc_sec) ;   /* 1s 算走4.5m */
  juli = (uint) (juli*4.5);
  juli = (uint) (daojishi_shijiana * 4.5  ) - juli;
 }
 LCD_write_char( 9, 1, '0' + juli / 10000 );
 LCD_write_char( 10, 1, '0' + juli % 10000 / 1000 );
 LCD_write_char( 11, 1, '0' + juli % 1000 / 100 );
 LCD_write_char( 12, 1, '0' + juli % 100 / 10 );
 LCD_write_char( 13, 1, '0' + juli % 10 );
 LCD_write_char( 14, 1, 'm' );
}
/* 主程序 */
void main()
{
 init_timer();
 LCD_init();
 open = 0;
 ENA = 1;            /* 关闭PWM */
 ENA_PWM_data = 5;    /* 0表示占空比0  10表示占空比百分之百 */
  ENB_PWM_data = 9;    /* 0表示占空比0  10表示占空比百分之百 */
 while ( 1 )
 {
  ScanKey();      /* 得到按键 */
  KEY_CHULI();    /* 处理按键 */
  update();       /* 更新显示 */
 }
}
void Time0( void )
interrupt 1
{
 TH0 = (65536 - 1000) / 256; /* 计数初值重装载 */
 TL0 = (65536 - 1000) % 256;
 /* 启动状态下 */
 pwm_count++;
 if ( pwm_count == 10 )
 {
  pwm_count = 0;
  if ( open == 1 )
  {
   ENA = 0;        /*传动带速度 */
  }
  ENB = 0;                /* 角度 */
 }
 if ( ENA_PWM_data == pwm_count )
 {
  if ( open == 1 )
  {
   ENA = 1;        /*传动带速度 */
  }
 }
 if ( ENB_PWM_data == pwm_count )
 {
  ENB = 1;                /* 角度 */
 }
}
/* 50ms */
void T1_time()
interrupt 3
{
 unsigned int shijian = 0;
 TH1 = (65536 - 50000) / 256;
 TL1 = (65536 - 50000) % 256;
 num2++;
 if ( num2 == 20 )
 {
  num2 = 0;
  /* 正计时 */
  if ( time_count_mode == 0 && open == 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;
     }
    }
   }
  }
  /* 倒计时 */
  if ( time_count_mode == 1 && open == 1 )
  {
   shijian = rtc_hour * 3600 + rtc_min * 60 + rtc_sec;
   shijian--;
   if ( shijian == 0 )
   {
    open = 0;
    ENA = 1; /* 关闭PWM */
   }
   rtc_hour = shijian / 3600;
   rtc_min  = shijian / 60 % 60;
   rtc_sec  = shijian % 60;
  }
 }
}
```

1602.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^4;
sbit lcd_rw=P2^5;
sbit lcd_en=P2^6;
#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) 
{
    if (y == 0) 
    {
     LCD_write_com(0x80 + x);        //第一行显示
    }
    else 
    {
     LCD_write_com(0xC0 + x);        //第二行显示
    }
    while (*s) 
    {
     LCD_write_data( *s);
     s ++;
    }
}
//***********************************************************************
// 显示屏初始化函数
//***********************************************************************
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);
}
```

eeprom.h

```c
#include <reg52.h>
#include <intrins.h>
/****************特殊功能寄存器声明****************/
sfr ISP_DATA = 0xe2;
sfr ISP_ADDRH = 0xe3;
sfr ISP_ADDRL = 0xe4;
sfr ISP_CMD  = 0xe5;
sfr ISP_TRIG = 0xe6;
sfr ISP_CONTR = 0xe7;
/*
 * STC89C52RC内部EEPROM详细地址表：
 * 第一扇区                   第二扇区                    第三扇区                    第四扇区
 * 起始地址  结束地址   起始地址   结束地址   起始地址   结束地址   起始地址    结束地址
 * 2000h      21FFh       2200h       23FFh      2400h       25FFh       2600h        27FFH
 * 第五扇区                    第六扇区                     第七扇区                    第八扇区
 * 起始地址   结束地址   起始地址   结束地址    起始地址   结束地址   起始地址    结束地址
 * 2800h       29FFh       2A00h      2BFFh        2C00h      2DFFh      2E00h        2FFFh
 *
 *
 * 使用举例
 * cc(0X2000);//擦除第一扇区
 * xcx(0x2002,2);//向地址0x2002写入2
 * duqu=dcx(0x2002);//读取出来
 *
 */
void cc( unsigned int addr );
void xcx( unsigned int addr, char dat );
char dcx( unsigned int addr );
void Q0();
/*┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
*  函数：擦除某一扇区（每个扇区512字节）
*  入口：addr = 某一扇区首地址
*  ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈*/
void cc( unsigned int addr )
{
/*
 * 打开 IAP 功能(ISP_CONTR.7)=1:允许编程改变Flash, 设置Flash操作等待时间
 * 0x83(晶振<5M)   0x82(晶振<10M)   0x81(晶振<20M)   0x80(晶振<40M)
 */
 ISP_CONTR = 0x81;
 ISP_CMD  = 0x03;         /* 用户可以对"Data Flash/EEPROM区"进行扇区擦除 */
 ISP_ADDRL = addr;         /* ISP/IAP操作时的地址寄存器低八位， */
 ISP_ADDRH = addr >> 8;    /* ISP/IAP操作时的地址寄存器高八位。 */
 EA  = 0;
 ISP_TRIG = 0x46;         /* 在ISPEN(ISP_CONTR.7)=1时,对ISP_TRIG先写入46h， */
 ISP_TRIG = 0xB9;         /* 再写入B9h,ISP/IAP命令才会生效。 */
 _nop_();
 Q0();                           /* 关闭ISP/IAP */
}
/*┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
*  函数：写一字节
*  入口：addr = 扇区单元地址 , dat = 待写入数据
*  ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈*/
void xcx( unsigned int addr, char dat )
{
 ISP_CONTR = 0x81;
 ISP_CMD  = 0x02; /* 用户可以对"Data Flash/EEPROM区"进行字节编程 */
 ISP_ADDRL = addr;
 ISP_ADDRH = addr >> 8;
 ISP_DATA = dat;  /* 数据进ISP_DATA */
 EA  = 0;
 ISP_TRIG = 0x46;
 ISP_TRIG = 0xB9;
 _nop_();
 Q0();                   /* 关闭ISP/IAP */
}
/*┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
*  函数：读一字节
*  入口：addr = 扇区单元地址
*  出口：dat  = 读出的数据
*  ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈*/
char dcx( unsigned int addr )
{
 char dat;
 ISP_CONTR = 0x81;
 ISP_CMD  = 0x01; /* 用户可以对"Data Flash/EEPROM区"进行字节读 */
 ISP_ADDRL = addr;
 ISP_ADDRH = addr >> 8;
 EA  = 0;
 ISP_TRIG = 0x46;
 ISP_TRIG = 0xB9;
 _nop_();
 dat = ISP_DATA;         /* 取出数据 */
 Q0();                   /* 关闭ISP/IAP */
 return(dat);
}
/*┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈
*  函数：关闭ISP/IAP操作
*  ┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈*/
void Q0()
{
 ISP_CONTR = 0;    /* 关闭IAP功能 */
 ISP_CMD  = 0;    /* 待机模式，无ISP操作 */
 ISP_TRIG = 0;    /* 关闭IAP功能, 清与ISP有关的特殊功能寄存器 */
 EA  = 1;
}
/* 连续写入 10 字节 */
void lianxi_Write( char *pin , unsigned int addr)
{
 char num;
 for ( num = 0; num < 10; num++ )
 {
  xcx( addr + num, *pin ); /* 从0x2010开始读取32个字节 */
  pin++;
 }
}
/* 连续读取 10 个字节 */
void lianxi_Read( char *pin ,unsigned int addr)
{
 char num;
 for ( num = 0; num < 10; num++ )
 {
  *pin = dcx( addr + num ) ; /* 从0x2010开始读取32个字节 */
  pin++;
 }
}
```

51单片机 跑步机控制器设计

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





```c
#include <reg52.h>
#include <intrins.h>
#include "lcd1602.h"
//按键1 暂停播放
//按键2 上一首
//按键3 下一首
//按键4  加速播放
//按键5  减速播放
#define uchar unsigned char 
#define uint 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 ^ 6;    //蜂鸣器
/*  ******************************************    */
//  ********   程序变量定义
/*  ******************************************    */
unsigned int C;     //储存定时器的定时常数
unsigned char u, t;  //音乐所用的变量
unsigned char velocity = 60; //控制节拍使用的 这里100表示一个拍子100ms
unsigned char press_key = 0; //按键  按下后会改变数值  初始值为0
unsigned char open_flag = 0; //暂停时为0  播放时为1
unsigned char music_crr = 0; //当前是播放哪一首音乐  可以为0  1  2  分别是是三首歌
unsigned char code name0[]="1 TianKongZC    ";
unsigned char code name1[]="2 LiangZhiLaoHu ";
unsigned char code name2[]="3 MoLiHua       ";
unsigned char code name3[]="4 XiaoXingXing  ";
unsigned char  *song_name[]={name0,name1,name2,name3};
/*  ******************************************    */
//  ********  音乐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, /**/32};
/*  ******************************************    */
//  ********   音乐1
/*  ******************************************    */
unsigned int code music1[]=
{ Z1,Z2,Z3,Z1,Z1,Z2,Z3,Z1,Z3,Z4,Z5,Z3,Z4,Z5,Z5,Z6,Z5,Z4,
 Z3,Z1,Z5,Z6,Z5,Z4,Z3,Z1,Z2,L5,Z1,Z2,L5,Z1,0xff}; //以0xff作为音符的结束标志      
//以下是简谱中每个音符的节拍
//"4"对应4个延时单位，"2"对应2个延时单位，"1"对应1个延时单位 
unsigned char code music1_JP[ ]=
{ 8,8,8,8,8,8,8,8,8,8,8,8,8,8,4,4,4,4,8,8,4,4,4,4,8,8,8,8,16,8,8,8,1};
/*  ******************************************    */
//  ********   音乐2
/*  ******************************************    */
unsigned int code music2[]=
{ 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 music2_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};
 /*  ******************************************    */
//  ********   音乐3 小星星
/*  ******************************************    */
unsigned int code music3[]=
{ 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 music3_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
};
/*  ******************************************    */
//  ********   延时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;
}
#define GPIO_KEY P3
/* 矩阵键盘扫描 电子琴 */
unsigned char ScanKey( void )
{
 char a = 0;
 unsigned char map[]={3,7,11,15,2,6,10,14,1,5,9,13,0,4,8,12};
 unsigned char KeyValue = 0xff;
 GPIO_KEY = 0x0f;
 if ( GPIO_KEY != 0x0f )         /* 读取按键是否按下 */
 {
  delay( 5 );             /* 延时10ms进行消抖 */
  if ( GPIO_KEY != 0x0f ) /* 再次检测键盘是否按下 */
  {
   /* 测试列 */
   GPIO_KEY = 0X0F;
   switch ( GPIO_KEY )
   {
   case (0X07):
    KeyValue = 0;
    break;
   case (0X0b):
    KeyValue = 1;
    break;
   case (0X0d):
    KeyValue = 2;
    break;
   case (0X0e):
    KeyValue = 3;
    break;
   }
   /* 测试行 */
   GPIO_KEY = 0XF0;
   switch ( GPIO_KEY )
   {
   case (0X70):
    KeyValue = KeyValue;
    break;
   case (0Xb0):
    KeyValue = KeyValue + 4;
    break;
   case (0Xd0):
    KeyValue = KeyValue + 8;
    break;
   case (0Xe0):
    KeyValue = KeyValue + 12;
    break;
   }
   while ( (a < 100) && (GPIO_KEY != 0xf0) ) /* 检测按键松手检测 */
   {
    delay( 10 );
    a++;
   }
   KeyValue=map[KeyValue]+1;
  }
 }
 return KeyValue;//返回按键
}
/*  ******************************************    */
//  ********   处理按键 按下按键后 相应变量改变 
/*  ******************************************    */
void delay_key(void)
{
 if (press_key == 1)  //暂停控制
 {
  press_key = 0;
  if (open_flag == 0)
  {
   open_flag = 1;   //开始
  } else
  {
   open_flag = 0;   //暂停
  }
 }
 if (press_key == 2)   //上一首
 {
  press_key = 0;
  if (music_crr > 0)
  {
   music_crr = (music_crr - 1) % 4;
  } else
  {
   music_crr = 3;   //如果是第0首歌  那么按上一首就是第3首
  }
  LCD_write_str(0,0,song_name[music_crr]);//显示歌名
 }
 if (press_key == 3)   //下一首
 {
  press_key = 0;
  music_crr = (music_crr + 1) % 4;
  LCD_write_str(0,0,song_name[music_crr]);//显示歌名
 }
 if (press_key == 4)    //加快播放速度
 {
  press_key = 0;
  velocity = velocity - 5;
 }
 if (press_key == 5)    //降低播放速度
 {
  press_key = 0;
  velocity = velocity + 5;
 }
}
/*  ******************************************    */
//  ********   主函数 程序逻辑
/*  ******************************************    */
void main()
{
 LCD_init();
 init_timer();
 TR1 = 0;     //关闭定时器
 sound = 1;  //关闭蜂鸣器
 open_flag = 0; //关闭音乐
 LCD_write_str(0,0,song_name[music_crr]);//显示歌名
 while (1)
 {
  press_key = ScanKey();   //获取按下的键
  delay_key();   //将按下的键值传入处理函数 改变状态变量
  if (music_crr == 0 && open_flag == 1)
  {
   u = 0;   //从第1个音符f[0]开始播放
   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
    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]开始播放
   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
    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]开始播放
   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
    for (t = 0; t < music2_JP[u] / 2; t++)  //控制节拍数
     delay1();          //延时1个节拍单位
    TR1 = 0;                   //关闭定时器T1
    u++;                        //播放下一个音符
   }
   init_timer();
   TR1 = 0;     //关闭定时器
   sound = 1;  //关闭蜂鸣器
  }
  if (music_crr == 3 && open_flag == 1)
  {
   u = 0;   //从第1个音符f[0]开始播放
   while (music2[u] != 0xff)            //只要没有读到结束标志就继续播放
   {
    press_key = ScanKey();   //获取按下的键
    delay_key();   //将按下的键值传入处理函数 改变状态变量
    if (music_crr != 3)    //切换音乐
    {
     init_timer();
     TR1 = 0;     //关闭定时器
     sound = 1;  //关闭蜂鸣器
     break;
    }
    if (open_flag == 0) //如果暂停音乐
    {
     while (open_flag == 0)
     {
      press_key = ScanKey();   //获取按下的键
      delay_key();   //将按下的键值传入处理函数 改变状态变量
     }
    }
    C = 460830 / music3[u];
    TH1 = (8192 - C) / 32;   //可证明这是13位计数器TH0高8位的赋初值方法     5
    TL1 = (8192 - C) % 32;   //可证明这是13位计数器TL0低5位的赋初值方法
    TR1 = 1;             //启动定时器T0
    for (t = 0; t < music3_JP[u] ; 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位的赋初值方法 
}
```


```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^4;
sbit lcd_rw=P2^5;
sbit lcd_en=P2^6;
#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) 
{
    if (y == 0) 
    {
     LCD_write_com(0x80 + x);        //第一行显示
    }
    else 
    {
     LCD_write_com(0xC0 + x);        //第二行显示
    }
    while (*s) 
    {
     LCD_write_data( *s);
     s ++;
    }
}
//***********************************************************************
// 显示屏初始化函数
//***********************************************************************
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);
}
```

51单片机 八音盒设计

控制电机正反转和启停





控制电机速度

采集电机速度

```c
/*按键处理 */
void user_do( unsigned char k )
{
 if ( k == 1 )
 {
  zhengzhuan = 1;         /* 正转 */
 }else if ( k == 2 )
 {
  zhengzhuan = 0;         /* 反转 */
 }else if ( k == 3 )
 {
  if ( dangwei < 10 )
   dangwei++;      /* 档位 */
 }else if ( k == 4 )
 {
  if ( dangwei > 0 )
   dangwei--;      /* 档位 */
 }else if ( k == 5 )
 {
  stop = !stop;           /* 启停 */
  if ( stop == 0 )
   dangwei = 0;
  else dangwei = 5;
 }
}
/* 速度采集 外部中断 */
void int0() interrupt 0
{
 Inpluse++; //采集电机速度加1
}
```

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

51单片机 Proteus仿真 直流电机控制正反转 控制电机转速 转速采集

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





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

51单片机 Proteus仿真 四路倒计时 定时器0.01S

LCD1602+矩阵键盘+HX711测重





重量实时显示在屏幕上

按数字输入单价

按abcd可以直接快捷输入单价

总金额实时显示在屏幕上

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

51单片机 Proteus仿真 简易电子称 键盘输入单价 显示总价 HX711称重

1 ADC0832芯片检测电压，雨滴检测板，雨滴越多电压越高





2 LCD1602屏幕显示此时有雨无雨，并显示当前检测到的电压

3 按键可以设定临界判断电压值，实际检测电压大于这个设置的值就代表有雨，相当于灵敏度调节

4 上电默认为无雨打开窗口状态，有雨后，直流电机正转五秒表示关闭窗户

5 无雨天晴后，电机反转5秒表示打开窗户

6 显示窗户状态 打开、关闭或者在运动

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

51单片机 Proteus仿真 智能窗帘

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





```c
#include "reg52.h"
#include <intrins.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
/*
 * 大概就是，做一个电子时钟，然后加四个独立按键，
 * K1按一次设置闹钟的秒，两次设置闹钟的分，三次设置闹钟的时，
 * 然后四次修改时间的秒，五次修改时间的分，六次改时间的时这样
 *
 * K2是加一，K3是减一
 *
 * K4是关闹钟
定时器实现时钟送PC机显示独立键盘设置时间
要求；
筒易时钟。并送PC机上湿示，当前时间可以通过独立键盘来没置;整点提醒、定时闹钟
需要keil c语言程序(注释)，proteus仿真图
 *
 */
#define uchar unsigned char
#define uint unsigned int
#define u8 unsigned char
#define u16 unsigned int
char rtc_hour = 23;
char rtc_min  = 59;
char rtc_sec  = 55;
char rtc_hour_al = 1;            /* 闹钟 */
char rtc_min_al = 0;
char rtc_sec_al = 1;
unsigned char num2 = 0;                 /* 计数 */
u8 ItemsNum = 0;                        /*按键改变项目 */
char *ALLtime[] = { &rtc_hour, &rtc_min, &rtc_sec, &rtc_hour_al, &rtc_min_al,
      &rtc_sec_al };      /* 指针便于调用 */
u8 openAlarm = 1;                       /* 打开或者关闭闹钟 */
u8 alarmifg = 0;
u8 alarm_shijian = 0;
sbit key_01 = P2 ^ 1;
sbit key_02 = P2 ^ 2;
sbit key_03 = P2 ^ 3;
sbit key_04 = P2 ^ 4;
sbit key_05 = P2 ^ 5;
sbit BEEP = P3 ^ 6;
/*********************************************************************************
 * 【函 数 名】： void send_cmd(unsigned char dat)
 * 【功    能】： 串口发送数据命令
 **********************************************************************************/
void send( unsigned char dat )
{
 SBUF = dat;     /* 发送指令到SBUF */
 while ( !TI )
  ;       /* 等待发送结束 */
 TI = 0;         /* 清除结束标志，以便再发送数据 */
}
/*********************************************************************************
 * 【函 数 名】： Print_Str(unsigned char *s)
 * 【功    能】： 串口发送 一个字符串
 **********************************************************************************/
void Print_Str( unsigned char *s )
{
 while ( *s != '\0' )
 {
  send( *s++ );
 }
}
#define FSOC 11059200L    //晶振
#define BAUD  9600        //波特率
/*********************************************************************************
 * 【函 数 名】： void SerInit(void)
 * 【功    能】： 串口初始化程序 设置波特率为9600
 **********************************************************************************/
void SerInit( void )
{
 SCON = 0x50; /* 010 1 0000B，工作方式1, 8位UART，波特率可变，允许接收 */
 TMOD = 0x20; /* T1工作于方式2 */
 TCON = 0x40; /* 定时器1开始计数 */
 TH1 = -(FSOC/BAUD/12/16);  /* T1计数初值 */
 TL1 = -(FSOC/BAUD/12/16);
 PCON = 0x80; /* SMOD置1,双倍速率 */
 RI = 0;
 TI = 0;
 ES = 0;    /* 关闭串口中断 */
}
/* 闹钟函数 */
void BeepAlarm()
{
 unsigned char beeptime = 0;
 int  cycl  = 1000;
 while ( cycl-- )
 {
  BEEP = !BEEP;
  for ( beeptime = 0; beeptime < 5; beeptime++ )
   ;
 }
 BEEP = 1;
}
/* 延时函数 */
void delay_ms_key( unsigned char t ) /* 延时xms */
{
 unsigned char ttt;
 while ( t-- )
 {
  for ( ttt = 0; ttt < 125; ttt++ )
   ;
 }
}
/*
 * 四个按键的检测函数
 * 按键则返回1 2 3 4
 * 无按键则返回0xff
 */
unsigned char KeySscan( void )
{
 unsigned char keyvaluee = 0xff;
 if ( key_01 == 0 )
 {
  delay_ms_key( 10 );
  if ( key_01 == 0 )
  {
   while ( key_01 == 0 )
    ;
   return(1);
  }
 }
 if ( key_02 == 0 )
 {
  delay_ms_key( 10 );
  if ( key_02 == 0 )
  {
   while ( key_02 == 0 )
    ;
   return(2);
  }
 }
 if ( key_03 == 0 )
 {
  delay_ms_key( 10 );
  if ( key_03 == 0 )
  {
   while ( key_03 == 0 )
    ;
   return(3);
  }
 }
 if ( key_04 == 0 )
 {
  delay_ms_key( 10 );
  if ( key_04 == 0 )
  {
   while ( key_04 == 0 )
    ;
   return(4);
  }
 }
 if ( key_05 == 0 )
 {
  delay_ms_key( 10 );
  if ( key_05 == 0 )
  {
   while ( key_05 == 0 )
    ;
   return(5);
  }
 }
 return(0xff);
}
/* 显示时间 */
void displaytime()
{
 u8 disp[15];
 u8 count = 0;
 disp[count++] = rtc_hour / 10 + '0';
 disp[count++] = rtc_hour % 10 + '0';
 disp[count++] = ':';
 disp[count++] = rtc_min / 10 + '0';
 disp[count++] = rtc_min % 10 + '0';
 disp[count++] = ':';
 disp[count++] = rtc_sec / 10 + '0';
 disp[count++] = rtc_sec % 10 + '0';
 disp[count++] = 0;
 Print_Str( disp );
 Print_Str("\r\n");//发送换行符号 便于看
}
/* 显示闹钟 */
void displayAlarm()
{
 u8 disp[15];
 u8 count = 0;
 disp[count++] = rtc_hour_al / 10 + '0';
 disp[count++] = rtc_hour_al % 10 + '0';
 disp[count++] = ':';
 disp[count++] = rtc_min_al / 10 + '0';
 disp[count++] = rtc_min_al % 10 + '0';
 disp[count++] = ':';
 disp[count++] = rtc_sec_al / 10 + '0';
 disp[count++] = rtc_sec_al % 10 + '0';
 disp[count++] = 0;
 Print_Str( disp );
 Print_Str("\r\n");//发送换行符号 便于看
}
/*********************************************************************************
 *
 *        定时器中断
 **********************************************************************************/
void T1_time()
interrupt 1
{
 TH0 = (65536 - 50000) / 256;
 TL0 = (65536 - 50000) % 256;
 num2++;
 if ( num2 == 20 )
 {
  displaytime(); /* 发送时间显示 */
  num2 = 0;
  rtc_sec++;
  /* 闹钟响声判定 */
  if ( openAlarm == 1 )                           /* 打开了闹钟 */
  {
   if ( *ALLtime[0] == *ALLtime[3] )       /* 判定时间一样不一样 */
   {
    if ( *ALLtime[1] == *ALLtime[4] )
    {
     if ( *ALLtime[2] == *ALLtime[5] )
     {
      alarmifg = 1;
     }
    }
   }
  }
  if ( alarmifg == 1 ) /* 闹钟开始响了 */
  {
   alarm_shijian++;
  }
  if ( rtc_sec == 60 )
  {
   rtc_sec = 0;
   rtc_min++;
   if ( rtc_min == 60 )
   {
    rtc_min = 0;
    //整点报时
    //alarmifg = 1;//打开蜂鸣器
    Print_Str("zheng dian bao shi ");
    Print_Str("\r\n");//发送换行符号 便于看
    rtc_hour++;
    if ( rtc_hour == 24 )
    {
     rtc_hour = 0;
    }
   }
  }
 }
}
void delay_ms( unsigned int t ) /* 延时xms */
{
 unsigned char ttt;
 while ( t-- )
 {
  for ( ttt = 0; ttt < 125; ttt++ )
   ;
 }
}
/*********************************************************************************
 *
 *       主函数
 **********************************************************************************/
void main( void )
{
 u8 key = 0xff;
 SerInit();
 TMOD |= 0x01;
 TH0 = (65536 - 50000) / 256;
 TL0 = (65536 - 50000) % 256;
 EA = 1;
 ET0 = 1;
 TR0 = 1;
 /* LCD_write_com(0x0c); //关光标，闪烁 */
 while ( 1 )
 {
  key = KeySscan();
  if ( key != 0xff )
  {
   if ( key == 1 )
   {
    ItemsNum = (ItemsNum + 1) % 7;
    if(ItemsNum==0)
    {
     Print_Str("Settings have been saved and exited\r\n");
    }else if(ItemsNum==1)
    {
     Print_Str("Set Clock hours\r\n");
    }else if(ItemsNum==2)
    {
     Print_Str("Set Clock minutes, \r\n");
    }else if(ItemsNum==3)
    {
     Print_Str("Set Clock seconds\r\n");
    }else if(ItemsNum==4)
    {
     Print_Str("Set Alarm clock hours \r\n");
    }else if(ItemsNum==5)
    {
     Print_Str("Set Alarm clock minutes, \r\n");
    }else if(ItemsNum==6)
    {
     Print_Str("Set Alarm clock seconds\r\n");
    }
   } else if ( key == 2 )          /* 加法 */
   {
    *ALLtime[ItemsNum - 1] = *ALLtime[ItemsNum - 1] + 1;
   } else if ( key == 3 )          /* 减法 */
   {
    *ALLtime[ItemsNum - 1] = *ALLtime[ItemsNum - 1] - 1;
   } else if ( key == 4 )          /* 关闭或者打开闹钟 */
   {
    openAlarm = !openAlarm;
    if ( openAlarm == 0 )   /* 恢复闹钟功能 */
    {
     alarmifg = 0;
     alarm_shijian = 0;
    }
   } else if ( key == 5 )          /* 保存并退出设置 */
   {
    ItemsNum=0;
    Print_Str("Settings have been saved and exited\r\n");
   }
   /* 增加时间界限 */
   if ( *ALLtime[0] == 24 )
   {
    *ALLtime[0] = 0;
   } else if ( *ALLtime[1] == 60 )
   {
    *ALLtime[1] = 0;
   } else if ( *ALLtime[2] == 60 )
   {
    *ALLtime[2] = 0;
   }
   if ( *ALLtime[0] == -1 )
   {
    *ALLtime[0] = 23;
   } else if ( *ALLtime[1] == -1 )
   {
    *ALLtime[1] = 59;
   } else if ( *ALLtime[2] == -1 )
   {
    *ALLtime[2] = 59;
   }
   /* 增加闹钟界限 */
   if ( *ALLtime[3] == 24 )
   {
    *ALLtime[3] = 0;
   } else if ( *ALLtime[4] == 60 )
   {
    *ALLtime[4] = 0;
   } else if ( *ALLtime[5] == 60 )
   {
    *ALLtime[5] = 0;
   }
   if ( *ALLtime[3] == -1 )
   {
    *ALLtime[3] = 23;
   } else if ( *ALLtime[4] == -1 )
   {
    *ALLtime[4] = 59;
   } else if ( *ALLtime[5] == -1 )
   {
    *ALLtime[5] = 59;
   }
   /* 无论按哪一个按键 我们都要刷新显示 */
   if ( ItemsNum <= 3 )
   {
    displaytime();
   } else {
    displayAlarm();
   }
   /* 控制游标 */
   if ( ItemsNum == 0 )
   {
    TR0 = 1;        /* 开启时钟 */
   } else {
    TR0 = 0;        /* 关闭时钟 */
   }
   key = 0xff;
  }
  /* 闹钟 */
  if ( alarmifg == 1 )
  {
   BeepAlarm();                    /* 闹钟想 */
   if ( alarm_shijian > 5 )        /* 响一会后关闭闹钟 alarm_shijian在定时器中自加 */
   {
    alarmifg = 0;
    alarm_shijian = 0;
   }
  }
 }
}
```

51单片机 Proteus仿真 时钟 串口 发送时钟 整点报时

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





```c
QQ742971636
/***********************1ms延时函数*****************************/
void delay_1ms( uint q )
{
 uint i, j;
 for ( i = 0; i < q; i++ )
  for ( j = 0; j < 120; j++ )
   ;
}
/***********************小延时函数*****************************/
void delay_uint( uint q )
{
 while ( q-- )
  ;
}
/***********************数码显示函数*****************************/
void display()
{
 static uchar i;
 i++;
 if ( i >= 4 )
  i = 0;
 P1 = 0xff;         /* 消隐 */
 P3 = smg_we[i];    /* 位选 */
 P1 = dis_smg[i];   /* 段选 */
}
/***********************18b20初始化函数*****************************/
void init_18b20()
{
 bit q;
 dq = 1; /* 把总线拿高 */
 delay_uint( 1 );
 dq = 0; /* 给复位脉冲 */
 delay_uint( 80 );
 dq = 1; /* 把总线拿高 等待 */
 delay_uint( 10 );
 q = dq; /* 读取18b20初始化信号 */
 delay_uint( 20 );
 dq = 1; /* 把总线拿高 释放总线 */
}
/*************写18b20内的数据***************/
void write_18b20( uchar dat )
{
 uchar i;
 for ( i = 0; i < 8; i++ )
 {                               /* 写数据是低位开始 */
  dq = 0;            /* 把总线拿低写时间隙开始 */
  dq = dat & 0x01;   /* 向18b20总线写数据了 */
  delay_uint( 5 );
  dq = 1;            /* 释放总线 */
  dat >>= 1;
 }
}
/*************读取18b20内的数据***************/
uchar read_18b20()
{
 uchar i, value;
 for ( i = 0; i < 8; i++ )
 {
  dq = 0;    /* 把总线拿低读时间隙开始 */
  value >>= 1;  /* 读数据是低位开始 */
  dq = 1;    /* 释放总线 */
  if ( dq == 1 )  /* 开始读写数据 */
   value |= 0x80;
  delay_uint( 5 );
 }
 return(value);          /* 返回数据 */
}
/*************读取温度的值 读出来的是小数***************/
uint read_temp()
{
 uint value;
 uchar low;                                            /* 在读取温度的时候如果中断的太频繁了，就应该把中断给关了，否则会影响到18b20的时序 */
 init_18b20();                                           /* 初始化18b20 */
 write_18b20( 0xcc );                                    /* 跳过64位ROM */
 write_18b20( 0x44 );                                    /* 启动一次温度转换命令 */
 delay_uint( 50 );
 init_18b20();                                           /* 初始化18b20 */
 write_18b20( 0xcc );                                    /* 跳过64位ROM */
 write_18b20( 0xbe );                                    /* 发出读取暂存器命令 */
 EA = 0;
 low = read_18b20();                                 /* 读温度低字节 */
 value = read_18b20();                                 /* 读温度高字节 */
 EA = 1;
 value <<= 8;                                          /* 把温度的高位左移8位 */
 value |= low;                                         /* 把读出的温度低位放到value的低八位中 */
 value *= 0.625;                                       /* 转换到温度值 小数 */
 return(value);                                          /* 返回读出的温度 带小数 */
}
/*************定时器0初始化程序***************/
void time_init()
{
 EA = 1;                                            /* 开总中断 */
 TMOD = 0X01;                                         /* 定时器0、定时器1工作方式1 */
 ET0 = 1;                                            /* 开定时器0中断 */
 TR0 = 1;                                            /* 允许定时器0定时 */
}
/********************独立按键程序*****************/
uchar key_can;                                                  /*按键值 */
void key()                                                      /* 独立按键程序 */
{
 static uchar key_new;
 key_can = 0;                                            /*按键值还原 */
 P2 |= 0x07;
 if ( (P2 & 0x07) != 0x07 )                              /*按键按下 */
 {
  if ( key_500ms == 1 )                           /* 连加 */
  {
   key_500ms = 0;
   key_new  = 1;
  }
  delay_1ms( 1 );                                 /*按键消抖动 */
  if ( ( (P2 & 0x07) != 0x07) && (key_new == 1) )
  {                                               /* 确认是按键按下 */
   key_new = 0;
   switch ( P2 & 0x07 )
   {
   case 0x06: key_can = 3; break;     /* 得到k2键值 */
   case 0x05: key_can = 2; break;     /* 得到k3键值 */
   case 0x03: key_can = 1; break;     /* 得到k4键值 */
   }
   flag_lj_en = 1;                         /* 连加使能 */
  }
 }else  {
  key_new  = 1;
  flag_lj_en = 0;                            /* 关闭连加使能 */
  flag_lj_3_en = 0;                            /* 关闭3秒后使能 */
  key_value = 0;                            /* 清零 */
  key_time = 0;
  key_500ms = 0;
 }
}
/****************按键处理数码管显示函数***************/
void key_with()
{
 if ( key_can == 1 ) /* 设置键 */
 {
  menu_1++;
  if ( menu_1 >= 3 )
  {
   menu_1 = 0;
  }
 }
 if ( menu_1 == 1 )                                              /* 设置高温报警 */
 {
  if ( key_can == 2 )
  {
   if ( flag_lj_3_en == 0 )
    t_high++;                               /*按键按下未松开自动加三次 */
   else
    t_high += 10;                           /*按键按下未松开自动加三次之后每次自动加10 */
   if ( t_high > 990 )
    t_high = 990;
  }
  if ( key_can == 3 )
  {
   if ( flag_lj_3_en == 0 )
    t_high--;                               /*按键按下未松开自动减三次 */
   else
    t_high -= 10;                           /*按键按下未松开自动减三次之后每次自动减10 */
   if ( t_high <= t_low )
    t_high = t_low + 1;
  }
  dis_smg[0] = smg_du[t_high % 10];                  /* 取小数显示 */
  dis_smg[1] = smg_du[t_high / 10 % 10] & 0xdf;      /* 取个位显示 */
  dis_smg[2] = smg_du[t_high / 100 % 10];            /* 取十位显示 */
  dis_smg[3] = 0x64;                                 /* H */
 }
 if ( menu_1 == 2 )                                              /* 设置低温报警 */
 {
  if ( key_can == 2 )
  {
   if ( flag_lj_3_en == 0 )
    t_low++;                                /*按键按下未松开自动加三次 */
   else
    t_low += 10;                            /*按键按下未松开自动加三次之后每次自动加10 */
   if ( t_low >= t_high )
    t_low = t_high - 1;
  }
  if ( key_can == 3 )
  {
   if ( flag_lj_3_en == 0 )
    t_low--;                                /*按键按下未松开自动减三次 */
   else
    t_low -= 10;                            /*按键按下未松开自动加三次之后每次自动加10 */
   if ( t_low <= 10 )
    t_low = 10;
  }
  dis_smg[0] = smg_du[t_low % 10];                   /* 取小数显示 */
  dis_smg[1] = smg_du[t_low / 10 % 10] & 0xdf;       /* 取个位显示 */
  dis_smg[2] = smg_du[t_low / 100 % 10];             /* 取十位显示 */
  dis_smg[3] = 0x3D;                                 /* L */
 }
}
/****************报警函数***************/
void clock_h_l()
{
 if ( (temperature <= t_low) || (temperature >= t_high) )
 {
  beep = ~beep; /* 蜂鸣器报警 */
 }else   {
  beep = 1;
 }
}
/****************主函数***************/
void main()
{
 beep = 0;                                                                       /* 开机叫一声 */
 delay_1ms( 150 );
 P0  = P1 = P2 = P3 = 0xff;
 temperature = read_temp();                                                  /* 先读出温度的值 */
 delay_1ms( 750 );
 temperature = read_temp();                                                  /* 先读出温度的值 */
 dis_smg[0] = smg_du[temperature % 10];                                     /* 取温度的小数显示 */
 dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf;                         /* 取温度的个位显示 */
 dis_smg[2] = smg_du[temperature / 100 % 10];                               /* 取温度的十位显示 */
 dis_smg[3] = 0xFF;
 time_init();                                                                    /* 初始化定时器 */
 while ( 1 )
 {
  key();                                                                  /*按键程序 */
  if ( key_can != 0 )
  {
   key_with();                                                     /* 设置报警温度 */
  }
  if ( flag_300ms == 1 )                                                  /* 300ms 处理一次温度程序 */
  {
   flag_300ms = 0;
   temperature = read_temp();                                  /* 先读出温度的值 */
   clock_h_l();                                                    /* 报警函数 */
   if ( menu_1 == 0 )
   {
    dis_smg[0] = smg_du[temperature % 10];             /* 取温度的小数显示 */
    dis_smg[1] = smg_du[temperature / 10 % 10] & 0xdf; /* 取温度的个位显示 */
    dis_smg[2] = smg_du[temperature / 100 % 10];       /* 取温度的十位显示 */
    dis_smg[3] = 0xFF;
   }
  }
 }
}
/*************定时器0中断服务程序***************/
void time0_int() interrupt 1
{
 static uchar value;                             /* 定时2ms中断一次 */
 TH0 = 0xf8;
 TL0 = 0x30;                                 /* 2ms */
 display();                                      /* 数码管显示函数 */
 value++;
 if ( value >= 150 )
 {
  value  = 0;
  flag_300ms = 1;
 }
 if ( flag_lj_en == 1 )                          /*按下按键使能 */
 {
  key_time++;
  if ( key_time >= 250 )                  /* 500ms */
  {
   key_time = 0;
   key_500ms = 1;            /* 500ms */
   key_value++;
   if ( key_value > 3 )
   {
    key_value = 10;
    flag_lj_3_en = 1;    /* 3次后1.5秒连加大些 */
   }
  }
 }
}
```

只有一个上限的情况：

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

```c
#include <reg52.h>                              /* 包含单片机寄存器的头文件 */
#include <intrins.h>
#define uchar unsigned char
#define uint unsigned int
#define dula P0                              /* 段选信号的锁存器控制 */
uint   temp;                   /* variable of temperature */
uint   WENDU;                  /* WENDU */
uint   BAOJINGLINJIE = 300;  /* 报警数值 30摄氏度  */
unsigned char code table[]  = { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d,
         0x07,        0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e,0x79,0x71 };
unsigned char  BUFFER[3] = { 0, 1, 2 };
sbit DS = P2 ^ 2;                       /* define interfac */
sbit sound = P2 ^ 3;                       /* 蜂鸣器 */
sbit wei1 = P2 ^ 4;
sbit wei2 = P2 ^ 5;
sbit wei3 = P2 ^ 6;
sbit wei4 = P2 ^ 7;
sbit key_01 = P3 ^ 4;
sbit key_02 = P3 ^ 5;
sbit key_03 = P3 ^ 6;
sbit key_04 = P3 ^ 7;
/* 延时函数 */
void delay_ms_key( unsigned char t ) /* 延时xms */
{
 unsigned char ttt;
 while ( t-- )
 {
  for ( ttt = 0; ttt < 125; ttt++ )
   ;
 }
}
/*
 * 四个按键的检测函数
 * 按键则返回1 2 3 4
 * 无按键则返回0xff
 */
unsigned char KeySscan( void )
{
 unsigned char keyvaluee = 0;
 if ( key_01 == 0 )
 {
  delay_ms_key( 2 );
  if ( key_01 == 0 )
  {
   while ( key_01 == 0 )
    ;
   return(1);
  }
 }
 if ( key_02 == 0 )
 {
  delay_ms_key( 2 );
  if ( key_02 == 0 )
  {
   while ( key_02 == 0 )
    ;
   return(2);
  }
 }
 if ( key_03 == 0 )
 {
  delay_ms_key( 2 );
  if ( key_03 == 0 )
  {
   while ( key_03 == 0 )
    ;
   return(3);
  }
 }
 if ( key_04 == 0 )
 {
  delay_ms_key( 2 );
  if ( key_04 == 0 )
  {
   while ( key_04 == 0 )
    ;
   return(4);
  }
 }
 return(0);
}
void delay( uint count )      /* delay */
{
 uint i;
 while ( count )
 {
  i = 200;
  while ( i > 0 )
   i--;
  count--;
 }
}
void dsreset( void )            /* send reset and initialization command */
{
 uint i;
 DS = 0;
 i = 103;          /* 将总线拉低480us~960us */
 while ( i > 0 )
  i--;
 DS = 1;            /* 然后拉高总线，若DS18B20做出反应会将在15us~60us后将总线拉低 */
 i = 4;            /* 15us~60us等待 */
 while ( i > 0 )
  i--;
 /* while(DS); */
}
bit tmpreadbit( void )          /* read a bit */
{
 uint i;
 bit dat;
 DS = 0; i++;       /* i++ for delay */
 DS = 1; i++; i++;
 dat = DS;
 i = 8; while ( i > 0 )
  i--;
 return(dat);
}
uchar tmpread( void )                                   /* read a byte date */
{
 uchar i, j, dat;
 dat = 0;
 for ( i = 1; i <= 8; i++ )
 {
  j = tmpreadbit();
  dat = (j << 7) | (dat >> 1);        /* 读出的数据最低位在最前面，这样刚好一个字节在DAT里 */
 }
 return(dat);
}
void tmpwritebyte( uchar dat )                          /* write a byte to ds18b20 */
{
 uint i;
 uchar j;
 bit testb;
 for ( j = 1; j <= 8; j++ )
 {
  testb = dat & 0x01;
  dat = dat >> 1;
  if ( testb ) /* write 1 */
  {
   DS = 0;
   i++; i++;
   DS = 1;
   i = 8; while ( i > 0 )
    i--;
  }else  {
   DS = 0; /* write 0 */
   i = 8; while ( i > 0 )
    i--;
   DS = 1;
   i++; i++;
  }
 }
}
void tmpchange( void )          /* DS18B20 begin change */
{
 dsreset();
 delay( 1 );
 tmpwritebyte( 0xcc );   /* address all drivers on bus */
 tmpwritebyte( 0x44 );   /*  initiates a single temperature conversion */
 /* delay(100); */
}
uint tmp()                      /* get the temperature */
{
 float tt;
 uchar a, b;
 dsreset();
 delay( 1 );
 tmpwritebyte( 0xcc );
 tmpwritebyte( 0xbe );
 a = tmpread();            /* 低八位 */
 b = tmpread();            /* 高八位 */
 temp = b;
 temp <<= 8;                  /* two byte  compose a int variable */
 temp = temp | a;
 tt = temp * 0.0625;        /* 算出来的是测到的温度，数值可到小数点后两位 */
 temp = tt * 10 + 0.5;        /* 为了显示温度后的小数点后一位并作出四舍五入，因为取值运算不能取小数点后的数 */
 return(temp);
}
/*  ******************************************    */
/*  ********   定时器初始化函数  用了定时器1 */
/*  ******************************************    */
void init_timer( void )
{
 TMOD = 0x01;
 TH0 = (65536 - 4000) / 256;
 TL0 = (65536 - 4000) % 256;
 ET0 = 1;
 TR0 = 1;
 EA = 1;
}
/*------------------------------------------------
 *                   主函数
 *  ------------------------------------------------*/
main()
{
 unsigned char keyvalue = 0;
 char  xiugai  = 0;
 init_timer();
 while ( 1 )
 {
  /* 温度高了就报警 */
  if ( WENDU > BAOJINGLINJIE )
  {
   sound = 0;
   P1=0X00;
  }else{
   sound = 1;
   P1=0XFF;
  }
  /* 根据当前模式显示出数值 */
  if ( xiugai == 0 )
  {
   BUFFER[0] = WENDU / 100;
   BUFFER[1] = WENDU % 100 / 10;
   BUFFER[2] = WENDU % 10;
  }else{
   BUFFER[0] = BAOJINGLINJIE / 100;
   BUFFER[1] = BAOJINGLINJIE % 100 / 10;
   BUFFER[2] = BAOJINGLINJIE % 10;
  }
  /* 检测按键 */
  keyvalue = KeySscan();
  if ( keyvalue != 0 )
  {
   if ( keyvalue == 1 )
   {
    xiugai = !xiugai; /* 模式 */
   }else if ( keyvalue == 3 )
   {
    BAOJINGLINJIE += 1;
    if ( BAOJINGLINJIE > 490 )
     BAOJINGLINJIE = 490;
   }else if ( keyvalue == 4 )
   {
    BAOJINGLINJIE -= 1;
    if ( BAOJINGLINJIE < 10 )
     BAOJINGLINJIE = 10;
   }
  }
  delay( 10 );
 }
}
char jishua  = 0;
uint timecount = 0;
void T0_time()
interrupt 1
{
 TH0 = (65536 - 5000) / 256;
 TL0 = (65536 - 5000) % 256;
 jishua = (jishua + 1) % 4;
 timecount++;
 if ( timecount == 200 )
 {
  timecount = 0;
  tmpchange();    /* 让18b20开始转换温度 */
  tmp();          /* 读取温度数值 */
  WENDU = (uint) (temp); 
 }
 P0 = 0x00;
 if ( jishua == 0 )
 {
  wei1 = 1;    /* 显示百位 */
  wei2 = 0;
  wei3 = 0;
  wei4 = 0;
  P0 = table[BUFFER[0]];
 }else if ( jishua == 1 )
 {
  wei1 = 0;    /* 显示十位 */
  wei2 = 1;
  wei3 = 0;
  wei4 = 0;
  P0 = table[BUFFER[1]] | 0x80;
 }else if ( jishua == 2 )
 {
  wei1 = 0;    /* 显示个位 */
  wei2 = 0;
  wei3 = 1;
  wei4 = 0;
  P0 = table[BUFFER[2]];
 }else if ( jishua == 3 )
 {
  wei1 = 0;    /* 显示个位 */
  wei2 = 0;
  wei3 = 0;
  wei4 = 1;
  P0 = 0x39;
 }
}
```

51单片机 Proteus仿真 温度上下限 报警器 数码管

题10 数字电子日历/时钟设计 





设计一个基于MSP430的电子日历和时钟。 

基本要求

 (1）可通过按键在日历和时间之间切换显示；

  (2）可由按键调整日期和时间

  (3）可整点报时（‘铆、嘟”声） 

  (4）可设定时，定时时间到发出嘟、嘟”声 

  (5）具有秒表功能 

  设计以MSP430为核心的控制电路并编写相关的系统软件。 

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

  

  时钟走时：

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

  秒表：

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

  日期切换：

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

  

代码：

https://github.com/xxddccaa/blog_code_search

# 帮助、问询

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

MSP430G2553 launchpad 口袋板 口袋实验平台 数字电子日历时钟设计 秒表 闹钟 整点报时 万年历 电子时钟

温度测量与通信系统设计





利用MSP430G2口袋实验平台(需焊接32.768kHz晶振并使用外部晶振)的相应模块，基于MSP430G2553 MCU，CCS6.2例程进行调试，实现以下功能：

（1）开机LCD先显示AA2019三秒，123456三秒，然后在LCD显示MCU芯片温度信息xx.x℃。

（2）同时与PC进行RS232通信，05作为握手信号（PC发送，MSP430实验平台接收），当握手信号正确时，蜂鸣器响一声（1000Hz、响2秒），回送温度给PC机，格式为“测量的温度为xx.x摄氏度”；不正确时蜂鸣器响三声（2000Hz、响1秒停1秒重复三次），回送字符串给PC机，格式为“序号是05”。

通信参数设置为：波特率4800bps，校验位N，数据位8，停止位1。

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

# 帮助、问询

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

MSP430G2553 launchpad 口袋板 口袋实验平台 温度测量与通信 系统设计 温度计

初始化ADC




```c
    ADC10CTL0 = ADC10SHT_2 + ADC10ON + ADC10IE; // ADC10ON, interrupt enabled
    ADC10CTL1 = INCH_4;                       // input A4  1.4
    ADC10AE0 |= BIT4;                         // PA.4 ADC option select
```

开始转换和读取

```c
 ADC10CTL0 |= ENC + ADC10SC;             // Sampling and conversion start
adtest = (float) ADC10MEM / 1024.0 * 3.3;
```

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

# 帮助、问询

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

MSP430G2553 launchpad 口袋板 口袋实验平台 电压表 检测P1.4引脚电压显示到屏幕上 ADC

步进电机控制代码：





```c
#include <reg52.h>
#define uint unsigned int
#define uchar unsigned char
uchar code FFW[] =
{
 0x01, 0x03, 0x02, 0x06, 0x04, 0x0c, 0x08, 0x09
};
uchar code REV[] =
{
 0x09, 0x08, 0x0c, 0x04, 0x06, 0x02, 0x03, 0x01
};
sbit K1 = P3 ^ 0;
sbit K2 = P3 ^ 1;
sbit K3 = P3 ^ 2;
void DelayMS( uint ms )
{
 uchar i;
 while ( ms-- )
 {
  for ( i = 0; i < 120; i++ )
   ;
 }
}
void SETP_MOTOR_FFW( uchar n )
{
 uchar i, j;
 for ( i = 0; i < 5 * n; i++ )
 {
  for ( j = 0; j < 8; j++ )
  {
   if ( K3 == 0 )
    break;
   P1 = FFW[j];
   DelayMS( 25 );
  }
 }
}
void SETP_MOTOR_REV( uchar n )
{
 uchar i, j;
 for ( i = 0; i < 5 * n; i++ )
 {
  for ( j = 0; j < 8; j++ )
  {
   if ( K3 == 0 )
    break;
   P1 = REV[j];
   DelayMS( 25 );
  }
 }
}
void main()
{
 uchar N = 3;
 while ( 1 )
 {
  if ( K1 == 0 )
  {
   P0 = 0xfe;
   SETP_MOTOR_FFW( N );
   if ( K3 == 0 )
    break;
  }else if ( K2 == 0 )
  {
   P0 = 0xfd;
   SETP_MOTOR_REV( N );
   if ( K3 == 0 )
    break;
  }else  {
   P0 = 0xfb;
   P1 = 0x03;
  }
 }
}
```

效果：

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

直流电机：

```c
#include <reg52.h>
#include <intrins.h>
#define uint unsigned int
#define uchar unsigned char
sbit K1 = P3 ^ 0;
sbit K2 = P3 ^ 1;
sbit K3 = P3 ^ 2;
sbit LED1 = P0 ^ 0;
sbit LED2 = P0 ^ 1;
sbit LED3 = P0 ^ 2;
sbit MA = P1 ^ 0;
sbit MB = P1 ^ 1;
void main( void )
{
 LED1 = 1;
 LED2 = 1;
 LED3 = 0;
 while ( 1 )
 {
  if ( K1 == 0 )
  {
   while ( K1 == 0 )
    ;
   LED1 = 0;
   LED2 = 1;
   LED3 = 1;
   MA = 0;
   MB = 1;
  }
  if ( K2 == 0 )
  {
   while ( K1 == 0 )
    ;
   LED1 = 1;
   LED2 = 0;
   LED3 = 1;
   MA = 1;
   MB = 0;
  }
  if ( K3 == 0 )
  {
   while ( K1 == 0 )
    ;
   LED1 = 1;
   LED2 = 1;
   LED3 = 0;
   MA = 0;
   MB = 0;
  }
 }
}
```

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

51单片机 Proteus仿真 步进电机和直流电机控制

车速检测显示，温度检测显示。





改变CLOCK频率就可以修改车速。

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

# 实验报告：基于单片机的车速与温度检测系统

## 一、实验背景

随着现代汽车电子技术的发展，车速与温度检测已成为汽车系统中的重要组成部分。本实验利用DS18B20温度传感器和LCD1602显示模块，结合单片机对车辆速度和环境温度进行实时检测和显示，实现一个简易的车速与温度检测系统。

## 二、实验目的

1. 学习并掌握DS18B20温度传感器的原理及使用方法。

2. 学习LCD1602显示模块的基本原理及使用方法。

3. 掌握单片机定时器的配置及中断服务程序的编写。

4. 实现车辆速度和温度的实时检测与显示。

## 三、实验器件

1. STC89C51单片机

2. DS18B20温度传感器

3. LCD1602显示模块

4. 按键（用于车速检测）

5. 相关电阻、电容及连接线

## 四、硬件连接

1. **DS18B20温度传感器**连接：DQ引脚接单片机P2.3，VCC接电源正极，GND接电源负极。

2. **LCD1602显示模块**连接：RS、RW、E及数据引脚分别接单片机相应引脚。

3. **按键**连接：一端接单片机P3.5，另一端接地。

## 五、设计原理

### 1. 温度检测原理

DS18B20是一种数字温度传感器，采用单总线协议进行通信。其主要操作包括初始化、发送命令和读取数据。每次温度转换后，温度数据存储在寄存器中，通过读取该寄存器获得温度值。

### 2. 车速检测原理

通过检测按键触发时间间隔来计算车速。每次按键触发时，记录两个触发事件的时间差，从而计算车速。

### 3. LCD1602显示原理

LCD1602是一种字符型液晶显示模块，通过并行接口与单片机通信。主要操作包括初始化、设置显示位置、写入字符等。

## 六、电路原理

本系统主要包括温度检测电路和车速检测电路：

1. **温度检测电路**：DS18B20传感器连接到单片机的P2.3引脚，单片机通过该引脚与DS18B20通信，读取温度数据。

2. **车速检测电路**：按键连接到单片机的P3.5引脚，通过检测按键按下的时间间隔来计算车速。

3. **显示电路**：LCD1602显示模块通过并行接口连接到单片机的P0、P2等引脚，单片机通过该接口控制LCD1602显示温度和车速。

## 七、程序原理

### 1. 温度检测程序

温度检测包括以下几个步骤：

- **初始化DS18B20**：通过单片机发送复位脉冲，等待传感器响应。

- **启动温度转换**：向DS18B20发送启动温度转换命令。

- **读取温度数据**：读取DS18B20寄存器中的温度数据，并进行数据处理。

### 2. 车速检测程序

车速检测通过定时器中断实现：

- **定时器配置**：设置定时器1，每50ms产生一次中断。

- **中断服务程序**：在中断服务程序中记录按键按下的时间，计算时间间隔，从而计算车速。

### 3. 显示程序

显示程序包括以下几个步骤：

- **初始化LCD1602**：设置显示模式和光标位置。

- **显示数据**：将温度和车速数据转换为字符，通过并行接口写入LCD1602显示。

## 八、代码解析

### 1. 温度检测代码

```c
void Init_DS18B20(void) {
    DQ = 1;
    delay_18B20(8);
    DQ = 0;
    delay_18B20(80);
    DQ = 1;
    delay_18B20(14);
}
unsigned int ReadTemperature(void) {
    unsigned char a = 0;
    unsigned int b = 0;
    unsigned int t = 0;
    Init_DS18B20();
    WriteOneChar(0xCC);
    WriteOneChar(0x44);
    DelayMs(10);
    Init_DS18B20();
    WriteOneChar(0xCC);
    WriteOneChar(0xBE);
    a = ReadOneChar();
    b = ReadOneChar();
    b <<= 8;
    t = a + b;
    return t;
}
```

### 2. 车速检测代码

```c
void T1_time() interrupt 3 {
    TH1 = (65536 - 50000) / 256;
    TL1 = (65536 - 50000) % 256;
    time++;
}
void main() {
    while (1) {
        if (key == 0) {
            delay_ms(5);
            if (key == 0) {
                while (key == 0);
                if (time < 60 && time > 2) {
                    chesu = (int)(1762.0 / ((float)time * 50.0) * 3600);
                    GotoXY(7, 1);
                    LCD1602_Write(1, chesu % 100000 / 10000 + 0x30);
                    LCD1602_Write(1, chesu % 10000 / 1000 + 0x30);
                    LCD1602_Write(1, '.');
                    LCD1602_Write(1, chesu % 1000 / 100 + 0x30);
                }
                time = 0;
            }
        }
    }
}
```

### 3. 显示程序

```c
void main() {
    int adc5, adc6, adc7;
    int temp = 0;
    LCD1602_init();
    LCD1602_Print(0, 0, "DS18B20:");
    LCD1602_Print(0, 1, "SPEED: 00.0 km/h");
    while (1) {
        temp = (uint)(ReadTemperature() * 0.625);
        adc5 = temp % 1000 / 100;
        adc6 = temp % 100 / 10;
        adc7 = temp % 10 / 1;
        GotoXY(10, 0);
        LCD1602_Write(1, adc5 + 0x30);
        LCD1602_Write(1, adc6 + 0x30);
        LCD1602_Write(1, '.');
        LCD1602_Write(1, adc7 + 0x30);
    }
}
```

## 九、总结

通过本实验，我们成功实现了基于DS18B20温度传感器和LCD1602显示模块的车速与温度检测系统。实验过程中，我们熟悉了DS18B20和LCD1602的使用方法，掌握了单片机定时器和中断的配置及使用技巧。这些知识和技能对于以后的嵌入式系统开发具有重要意义。

## 资料
```
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

51单片机 Proteus仿真 车速检测 温度检测

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





ADC0832检测锅炉电压换算成温度，显示温度。

按键设置想要的温度。

控制继电器对锅炉加热，实际温度就会慢慢到达设定数值。

文件有程序和仿真图：

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

下载请看这里：

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

51单片机 Proteus仿真 电炉丝控制 温度控制 锅炉温度

红外遥控器控制小车，小车自带超声波避障，遥控器可以打开循迹，打开循迹后自己循迹走。没打开循迹就红外遥控器控制小车走。






按键如下

1 进入或者退出循迹功能，循迹模式下对小车操作无效

2 前进

5 左转

6 停止

7 右转

10 后退

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

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

循迹依靠P1.3 P1.4的红外探测：

```c
/* 寻迹 */
void tracking()
{
 /* 为0 没有识别到黑线 为1识别到黑线 */
 if ( left_led1 == 1 && right_led1 == 1 )                /* 左右寻迹探头识别到黑线 */
 {
  forward();                                      /* 前进 */
 }else  {
  if ( left_led1 == 1 && right_led1 == 0 )        /* 小车右边出线，左转修正 */
  {
   left();                                 /* 左转 */
  }
  if ( left_led1 == 0 && right_led1 == 1 )        /* 小车左边出线，右转修正 */
  {
   right();                                /* 右转 */
  }
  if ( left_led1 == 0 && right_led1 == 0 )        /* 左右寻迹探头都没识别到黑线 */
  {
   backward();                             /* 后退 */
  }
 }
}
```

避障一直带有：

```c
/*超声波避障111111*/
void Avoid1()
{
 if ( distance < 50 )                                    /* 如果前方有障碍物进行左转   前方没有障碍物就直行 */
 {
  left();
 }else
 {
  forward();
 }
}
```

51单片机 Proteus仿真 红外 避障 循迹 小车 红外遥控器

基于单片机大棚温控系统





 * 1.使用STC89C52RC单片机与DS18B20采集温度在液晶上显示

 * 2.按键设置报警值，超过报警值则蜂鸣器响

 * 

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

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

# 基于单片机大棚温控系统实验报告

## 背景介绍

随着现代农业的发展，温室大棚成为了种植各种作物的重要设施。然而，温室内温度的控制对作物的生长具有至关重要的影响。因此，设计一个基于单片机的温控系统，实时监测温室内的温度并进行相应的控制，是非常必要的。

本实验基于STC89C52RC单片机，使用DS18B20温度传感器采集温度数据，并通过LCD1602液晶显示屏显示实时温度。此外，系统还配备了按键设置报警温度值的功能，当温度超过设定值时，蜂鸣器将会报警提示。

## 器件连接

1. **STC89C52RC单片机**：

   - 主要控制单元，负责数据的处理和设备的控制。

2. **DS18B20温度传感器**：

   - 连接到P3.3端口，用于采集温度数据。

3. **LCD1602液晶显示屏**：

   - 连接到P0口，显示温度数据和设定的报警值。

4. **按键**：

   - 两个按键分别连接到P1.0和P1.1，用于增加和减少设定的报警温度值。

5. **蜂鸣器**：

   - 连接到P1.7，用于报警提示。

## 硬件介绍

### STC89C52RC单片机

STC89C52RC是STC公司推出的一款8051系列增强型单片机，具有以下特点：

- 工作电压范围宽（3.0V ~ 5.5V）。

- 高速、低功耗。

- 丰富的I/O端口。

- 支持ISP/IAP功能。

### DS18B20温度传感器

DS18B20是一种数字温度传感器，具有以下特点：

- 单总线通信。

- 测量范围为-55℃到+125℃。

- 测量精度为±0.5℃。

- 可多点布置。

### LCD1602液晶显示屏

LCD1602是一种常用的字符型液晶显示屏，具有以下特点：

- 显示字符数：2行×16字符。

- 内置字符生成器。

- 通过I2C接口与单片机通信。

## 设计原理

### 电路原理

本系统的电路设计主要分为以下几部分：

1. **电源电路**：

   - 提供稳定的5V电源供单片机和其他外设使用。

2. **单片机与DS18B20连接**：

   - DS18B20的数据引脚DQ连接到单片机的P3.3端口，通过单总线协议进行通信。

3. **单片机与LCD1602连接**：

   - LCD1602的控制和数据引脚分别连接到单片机的P0口，实现数据的显示。

4. **按键电路**：

   - 两个按键分别连接到单片机的P1.0和P1.1端口，用于设置报警温度值。

5. **蜂鸣器电路**：

   - 蜂鸣器连接到单片机的P1.7端口，用于超温报警。

### 程序原理

程序设计主要包括以下几个模块：

1. **LCD初始化和显示**：

   - 通过LCD_Init函数初始化LCD1602显示屏，并在屏幕上显示“Temp: ”和“Set: ”提示信息。

2. **温度采集和显示**：

   - 使用getTmpValue函数读取DS18B20采集到的温度值，并通过display函数显示在LCD1602上。

3. **按键设置报警值**：

   - 使用Key_borad函数处理按键输入，增加或减少设定的报警温度值，并实时显示在LCD1602上。

4. **报警控制**：

   - 在主循环中比较当前温度值与设定值，如果当前温度超过设定值，则通过BEEP函数控制蜂鸣器发出报警。

## 实验过程

1. **硬件搭建**：

   - 按照设计原理连接各个器件，确保接线正确无误。

2. **软件编写**：

   - 使用Keil C51编写程序代码，并烧录到STC89C52RC单片机中。

3. **调试运行**：

   - 上电后，观察LCD1602显示的温度值和设定值，通过按键调整报警温度值，验证系统功能的实现。

## 实验结果

实验结果表明，系统能够实时采集并显示温度数据，按键可以正确设置报警温度值，当温度超过设定值时，蜂鸣器能够发出报警提示，系统功能符合设计要求。

## 结论

本实验通过STC89C52RC单片机和DS18B20温度传感器，实现了大棚温控系统的基本功能。系统能够实时监测温度并进行报警提示，具有较高的实用价值。通过此次实验，不仅加深了对单片机编程和硬件设计的理解，还掌握了温度传感器和液晶显示屏的应用，为后续更多功能的扩展奠定了基础。

## 资料
```
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

51单片机 Proteus仿真 温度报警器 大棚温度报警 DS18B20 基于单片机大棚温控系统

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





# 实验报告：基于51单片机的简易电子琴设计与实现

## 实验背景

本实验旨在设计和实现一个基于51单片机的简易电子琴，通过按键控制不同频率的声音输出。该系统可以模拟电子琴的基本功能，通过按键的不同组合，产生对应音调的声音。

## 实验器件与连接

### 器件清单

1. 51单片机（STC89C52）

2. 蜂鸣器

3. 按键（6个）

4. 电阻、电容等基本元器件

5. 面包板及连接线

6. Proteus仿真软件

### 硬件连接

1. **单片机**：使用STC89C52作为主控制芯片。

2. **蜂鸣器**：连接到P1^6引脚，用于发声。

3. **按键**：6个按键分别连接到P2口，用于选择不同的音调。

4. **电源**：提供稳定的5V电源给单片机和外设。

硬件连接示意图如下：

```
+-------------+        +----------+
|             |        |          |
|  STC89C52   |        | 蜂鸣器   |
|             |        |          |
|   P1^6 -----+-------->          |
|             |        +----------+
|             |
|  P2.0-P2.5--+
|    |  |  |  |       +---------+
|    |  |  |  +------>| 按键1   |
|    |  |  +--------->| 按键2   |
|    |  +----------->| 按键3   |
|    +------------->| 按键4   |
|                 +->| 按键5   |
|                 |  | 按键6   |
+-----------------+  +---------+
```

## 设计原理

### 电路原理

该设计利用51单片机的I/O端口控制蜂鸣器发声，通过定时器产生不同频率的方波，从而产生不同音调。按键用于选择不同的音调，按键按下时单片机读取按键值并控制蜂鸣器发出相应频率的声音。

### 程序原理

程序主要分为以下几个部分：

1. **音调频率定义**：定义低音、中音和高音的频率。

2. **定时器初始化**：配置定时器用于产生不同频率的方波。

3. **按键扫描**：检测按键输入，根据按键值选择相应的音调。

4. **中断服务程序**：通过定时器中断产生方波，从而驱动蜂鸣器发声。

### 主要函数解析

#### 定时器初始化函数

```c
void init_timer(void) {
    EA = 1;            // 开总中断
    ET1 = 1;           // 定时器T1中断允许
    TMOD &= 0x0f;
    TMOD |= 0x00;      // 使用定时器T1的模式1（13位计数器）
    TR1 = 1;
}
```

该函数用于初始化定时器1，并设置为13位计数模式。

#### 按键扫描函数

```c
void ScanKey(void) {
    if (GPIO_KEY != 0xff) {
        if (GPIO_KEY == 0xff - 0x01) {
            TEMP_C = Z1;
        } else if (GPIO_KEY == 0xff - 0x02) {
            TEMP_C = Z2;
        } else if (GPIO_KEY == 0xff - 0x04) {
            TEMP_C = Z3;
        } else if (GPIO_KEY == 0xff - 0x08) {
            TEMP_C = Z4;
        } else if (GPIO_KEY == 0xff - 0x10) {
            TEMP_C = Z5;
        } else if (GPIO_KEY == 0xff - 0x20) {
            TEMP_C = Z6;
        }
        C = 460830 / TEMP_C;
        TH1 = (8192 - C) / 32;
        TL1 = (8192 - C) % 32;
        TR1 = 1;
        while (GPIO_KEY != 0xff);
        TR1 = 0;
    }
}
```

该函数用于扫描按键并根据按键值设置相应的频率常数。

#### 主函数

```c
void main() {
    init_timer();
    TR1 = 0;         // 关闭定时器
    sound = 1;       // 关闭蜂鸣器
    while (1) {
        ScanKey();   // 获取处理按下的键
    }
}
```

主函数初始化定时器并进入无限循环，持续检测按键输入。

#### 定时器中断函数

```c
void Time1(void) interrupt 3 {
    sound = !sound;               // 将P3.7引脚输出电平取反，形成方波
    TH1 = (8192 - C) / 32;      // 13位计数器TH0高8位的赋初值方法
    TL1 = (8192 - C) % 32;      // 13位计数器TL0低5位的赋初值方法
}
```

该函数用于定时器中断，通过改变蜂鸣器引脚的电平，产生方波，从而发出声音。

## 实验结果

通过按下不同的按键，蜂鸣器可以发出对应频率的声音，实现了简易电子琴的功能。各按键对应的音调准确，响应速度快，满足设计要求。

## 总结

本实验成功实现了一个基于51单片机的简易电子琴，通过按键控制蜂鸣器发出不同频率的声音。实验验证了定时器中断、按键扫描等基本技术在电子琴设计中的应用，为进一步的扩展和改进提供了基础。

## 资料
```
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

51单片机 Proteus仿真 6个按键的简易电子琴

1 利用键盘及数码管作为计算机的输入及显示模块





2 能进行10以内的减减乘除的基本运算，按键有0~9+-*/=

3 有清零“CR”按键

4 有记忆功能键 M+ RM M-，可以保存、显示并运用存储数据进行计算

1. M+：记忆当前数字，「加入」累加数字当中。

2. M-：记忆当前数字，以负数的形式「加入」累加数字当中。换句话说，就是把总数扣除当前数字的意思。

4. MR：Memory Recall的意思，将当前计算出来的数字呈现出来。

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

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

# 实验报告：利用键盘及数码管实现基本计算器功能

## 一、实验背景

本实验旨在设计并实现一个简易计算器，能够通过键盘输入进行基本的加、减、乘、除运算，并通过数码管显示计算结果。计算器还应具备清零功能以及存储和调用中间计算结果的记忆功能。

## 二、实验器件

1. **单片机**：STC89C52RC

2. **键盘**：4x4矩阵键盘

3. **数码管**：共阴极七段数码管

4. **其他器件**：电阻、电容、跳线等

## 三、硬件连接

1. **矩阵键盘**：将键盘的行连接到P1.0至P1.3，列连接到P1.4至P1.7。

2. **数码管**：数码管的段选端连接到P0口，位选端连接到P2口。

3. **独立按键**：三个独立按键分别连接到P3.0、P3.1和P3.2，用于实现M+、M-、MR功能。

## 四、设计原理

### 1. 矩阵键盘扫描

通过P1口控制矩阵键盘，逐行扫描键盘，判断按键按下情况。通过行列信号组合，确定具体按键值。

```c
void KeyScan() {
    keyboPORT = 0xf0;
    if (keyboPORT != 0xf0) {
        delay(5);
        if (keyboPORT != 0xf0) {
            switch (keyboPORT) {
                case 0xe0: KeyValue = 0; break;
                case 0xd0: KeyValue = 1; break;
                case 0xb0: KeyValue = 2; break;
                case 0x70: KeyValue = 3; break;
            }
            keyboPORT = 0x0f;
            switch (keyboPORT) {
                case 0x0e: KeyValue = KeyValue; break;
                case 0x0d: KeyValue += 4; break;
                case 0x0b: KeyValue += 8; break;
                case 0x07: KeyValue += 12; break;
            }
            while (keyboPORT != 0x0f);
        }
    }
}
```

### 2. 基本运算功能

通过捕获键盘输入，存储表达式，然后进行加、减、乘、除运算，并显示结果。

```c
float CalculateSeries(char *exprs_str) {
    float Series_result = 0.0;
    switch (exprs_str[1]) {
        case '+': Series_result = (exprs_str[0] - '0') + (exprs_str[2] - '0'); break;
        case '-': Series_result = (exprs_str[0] - '0') - (exprs_str[2] - '0'); break;
        case '*': Series_result = (exprs_str[0] - '0') * (exprs_str[2] - '0'); break;
        case '/': Series_result = (exprs_str[0] - '0') / (exprs_str[2] - '0'); break;
    }
    return Series_result;
}
```

### 3. 数码管显示

通过数码管显示结果，使用四位数码管分别显示千位、百位、十位和个位的数值。

```c
void Display_Result(float d) {
    long temp = (long) (d * 10);
    // 显示个位
    P0 = 0xff;
    P2 = ~0x8;
    P0 = ~LEDData[temp % 10];
    delay(1);
    // 显示十位
    P0 = 0xff;
    P2 = ~0x4;
    P0 = ~(LEDData[temp % 100 / 10] | 0x80);
    delay(1);
    // 显示百位
    P0 = 0xff;
    P2 = ~0x2;
    P0 = ~LEDData[temp % 1000 / 100];
    delay(1);
    // 显示千位
    P0 = 0xff;
    P2 = ~0x1;
    P0 = ~LEDData[temp % 10000 / 1000];
    delay(1);
}
```

### 4. 记忆功能

实现M+、M-、MR功能，通过独立按键输入控制，分别执行累加、累减和显示存储结果。

```c
void main() {
    float result = 0.0, display_value = 0, temp = 0.0;
    char expression[5], inputChar;
    unsigned char key;
    while (1) {
        KeyScan();
        if (KeyValue != 0xff) {
            inputChar = MAP[KeyValue];
            KeyValue = 0xff;
            if ((inputChar >= '0') && (inputChar <= '9')) {
                expression[count++] = inputChar;
                display_value = inputChar - '0';
            } else if (strchr("+-*/=", inputChar)) {
                expression[count++] = inputChar;
                if (inputChar == '=') {
                    result = CalculateSeries(expression);
                    display_value = result;
                    temp = result;
                    count = 0;
                }
            } else if (inputChar == 'R') {
                result = 0;
                display_value = result;
                temp = 0;
                count = 0;
            }
        }
        key = KeySscanSI();
        if (key != 0xff) {
            switch (key) {
                case 1: temp += CalculateSeries(expression); display_value = temp; count = 0; break;
                case 2: temp -= CalculateSeries(expression); display_value = temp; count = 0; break;
                case 3: display_value = temp; break;
            }
        }
        Display_Result(display_value);
    }
}
```

## 五、实验总结

通过本次实验，成功实现了一个简易计算器的设计，能够进行基本的算术运算，并通过数码管显示结果。键盘输入和数码管显示配合良好，记忆功能有效。进一步的优化可以考虑增强运算功能，支持更复杂的表达式计算。

## 资料
```
https://docs.qq.com/sheet/DUEdqZ2lmbmR6UVdU?tab=BB08J2
```

51单片机 Proteus仿真 简易计算器设计 清零 十以内

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





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

源码工程打开下载，仿真文件和代码：

```bash
http://dt2.8tupian.net/2/28880a69b22000.pg3
```

这段代码是基于8051单片机的C语言程序，用于驱动一个LED点阵显示器和一个蜂鸣器。以下是代码的主要组成部分和功能解释：

1. **头文件和宏定义**：  

   代码首先包含一些必要的头文件和宏定义，例如定时器配置、数据类型定义、音频频率宏定义等。

2. **硬件端口定义**：  

   使用`sbit`关键字定义了硬件端口的位，例如`P1^6`代表P1口的第6位，表示蜂鸣器。

3. **延时函数**：  

   `delay()`函数提供了一个简单的延时功能。

4. **定时器初始化函数**：  

   `init_timer()`函数初始化了定时器T1，配置了相关的定时器模式。

5. **LED点阵显示器驱动**：  

   `LedScreen_WrTwoByte()`函数用于向LED点阵显示器写入两个字节的数据。

6. **LED点阵数据表**：  

   `Digit_Tab[]`数组包含了用于显示数字0到9的数据。

7. **按键扫描功能**：  

   `ScanKey()`函数用于扫描按键输入，并根据按键的输入值更改LED点阵显示的内容和蜂鸣器的频率。

8. **主函数**：  

   `main()`函数是程序的入口点，首先初始化定时器和关闭蜂鸣器。然后，程序进入一个无限循环，其中不断扫描按键和更新LED点阵显示。

9. **定时器中断处理**：  

   `Time1()`函数是定时器T1的中断服务函数。当定时器T1溢出时，该函数会被调用，改变蜂鸣器的状态以产生声音。

总体来说，这段代码是一个简单的8051单片机应用程序，用于驱动LED点阵显示器和蜂鸣器。用户可以通过按键输入来改变LED点阵的显示内容和蜂鸣器的声音频率。