单片机 人体红外 步进电机1旋转打开垃圾桶 超声波检测垃圾装满了没 满了就语音提示清理   步进电机2旋转表示封口





功能：

1、步进电机1逆时针表示关闭盖子，顺时针表示打开盖子。检测到人。步进电机1正转一下，然后打开盖子约10秒钟时间后再次判断有人没，有人就不关闭盖子，没人就关闭盖子。关闭盖子后，再次检测到有人，立马反应打开盖子。

2、步进电机2表示垃圾封口，当超声波检测到距离小于10cm表示垃圾装满，此时步进电机2正转一下，表示封口袋子，然后播放提示。

器件：

单片机最小系统（STC89C52RC+11.0592MHZ晶振+30pf电容2个+10uf电容+10k电阻+复位按键）

DC002插头+DC002usb线

MY-1690模块（播放MP3模块）

ULN2003驱动2个

28BYJ-48步进电机2个

超声波模块

人体红外模块

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

51单片机 Proteus仿真 智能垃圾桶 步进电机 关盖子 封口

![在这里插入图片描述](/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仿真 直流电机控制正反转 控制电机转速 转速采集

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。