找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 4056|回复: 2
收起左侧

超详细单片机八按键电子琴仿真+程序

[复制链接]
ID:405043 发表于 2019-7-2 09:42 | 显示全部楼层 |阅读模式
超详细单片机八按键电子琴仿真+程序
四首歌切换,可暂停,可输出八个音节。
见附件
0.png

单片机源程序如下:
  1. /******************************************************************/
  2. #include <reg52.h>
  3. #include "main.h"
  4. /******************************************************************/
  5. sbit BeepIO = P3^4; //定义音频输出管脚
  6. sbit KEY1   = P1^0; //按键1 do
  7. sbit KEY2   = P1^1; //按键2        re
  8. sbit KEY3   = P1^2; //按键3        mi
  9. sbit KEY4   = P1^3; //按键4        fa
  10. sbit KEY5   = P1^4; //按键5        sol
  11. sbit KEY6   = P1^5; //按键6        la
  12. sbit KEY7   = P1^6; //按键7        si
  13. sbit KEY9   = P1^7; //按键9 do
  14. sbit KEY8   = P3^2; //按键8        音乐切换

  15. sbit LED=P3^7;

  16. uchar music=0;
  17. uchar n=0;
  18. uchar n1=0;
  19. uchar n2=0;
  20. uchar n3=0;
  21. uchar key=0;
  22. char temp1,temp2;                //存放初值的中间变量
  23. uchar code music_dat[][2]= //两只老虎音乐数据,下面每一组是【音调【节拍】
  24. //比如说:1,4。其中1是音调,在函数中取得1的值然后在table[]中取得相应的音调
  25. //其中4是节拍,通过这个值来确定延时的长短
  26. {3,4, 5,4,  8,2,  5,2,  
  27. 6,4,  0,2,  6,2,  5,2,  
  28. 3,2,  3,2,  5,2,  
  29. 5,6,  3,2,  5,2,  
  30. 6,2,  8,2,  9,2,  8,2,  5,2,  3,2,   
  31. 2,2,  5,2,  3,2,  3,2,  3,6,  3,2,  
  32. 5,2,  8,2,  5,2,  
  33. 6,4,  0,2,  8,2,
  34. /*1,4, 2,4, 3,4, 1,4,                                //第一节
  35. 3,4, 2,4, 3,4, 1,4,                                //第二节
  36. 3,4, 4,4, 5,8,                                        //第三节
  37. 3,4, 4,4, 5,8,                                        //第四节
  38. 5,3, 6,1, 5,3, 4,1, 3,4, 1,4,        //第五节
  39. 5,3, 6,1, 5,3, 4,1, 3,4, 1,4,        //第六节
  40. 1,4, 8,4, 1,8,                                        //第七节
  41. 1,4, 8,4, 1,8,                                        //第八节*/
  42. 0XFF                                                //结束
  43. };
  44. uchar code music_dat1[][2]= //祝你生日快乐音乐数据,下面每一组是【音调【节拍】
  45. //比如说:1,4。其中1是音调,在函数中取得1的值然后在table[]中取得相应的音调
  46. //其中4是节拍,通过这个值来确定延时的长短
  47. {
  48. 1,2, 1,2, 2,4, 1,4, 4,4, 3,8,                        //第一节
  49. 1,2, 1,2, 2,4, 1,4, 5,4, 4,8,                        //第二节
  50. 1,2, 1,2, 8,4, 6,4, 4,4, 3,4, 2,4,            //第三节
  51. 7,2, 7,2, 6,4, 4,4, 5,4, 4,8,                        //第四节
  52. 0XFF                                                //结束
  53. };
  54. uchar code music_dat2[][2]= //铃儿响叮当音乐数据,下面每一组是【音调【节拍】
  55. //比如说:1,4。其中1是音调,在函数中取得1的值然后在table[]中取得相应的音调
  56. //其中4是节拍,通过这个值来确定延时的长短
  57. {
  58. 6,2, 6,2, 6,4, 6,2,        6,2, 6,4,                                    //第一节
  59. 6,2, 8,2, 4,3, 5,1, 6,8,                                        //第二节
  60. 7,2, 7,2, 7,3, 7,1, 7,2, 6,2, 6,2, 6,1, 6,1,        //第三节
  61. 6,2, 5,2, 5,2, 4,2, 5,4, 8,4,                                        //第四节
  62. 6,2, 6,2, 6,4, 6,2, 6,2, 6,4,                        //第五节
  63. 6,2, 8,2, 4,3, 5,1, 6,8,                            //第六节
  64. 7,2, 7,2, 7,3, 7,1, 7,2, 6,2, 6,2, 6,1, 6,1,        //第七节
  65. 8,2, 8,2, 7,2, 5,2, 4,6,                                            //第八节
  66. 0XFF                                                                //结束
  67. };
  68. uchar code music_dat3[][2]= //音乐数据,下面每一组是【音调【节拍】
  69. //比如说:1,4。其中1是音调,在函数中取得1的值然后在table[]中取得相应的音调
  70. //其中4是节拍,通过这个值来确定延时的长短
  71. {
  72. 6,4,4,4,5,4,2,4,6,2,5,2,4,2,5,2,2,4,6,4,4,4,5,4,5,2,5,2,8,2,6,2,3,4,4,4,4,1,3,1,
  73. 2,4,3,2,4,2,5,4,1,4,9,2,8,2,6,4,6,4,5,2,4,4,5,2,6,2,5,4,1,4,2,4,2,1,4,1,2,4,
  74. 0XFF                                                                //结束
  75. };
  76. uint code table[]={                                                                                        //数组存放的数据是各个音调的初始值
  77. 0Xfc,0X8e,0Xfc,0Xed,0Xfd,0X43,0Xfd,0X6a,0Xfd,0Xb3,0Xfd,0Xf3,0Xfe,0X2d};
  78. unsigned int code table1[9]={                                        //这个数组里存放的是1-7的音调的初始值
  79. 0xfc5b,0xfc8e,0xfced,0xfd43,0xfd6a,0xfdb3,0xfdf3,0xfe2d,0xfb68
  80. };

  81. /****************************************************************
  82. 延时函数,在程序里是当做节拍。我们把100ms作为1/4节拍
  83. *****************************************************************/
  84. void delay100ms(unsigned char z)
  85. {
  86.         unsigned int i;
  87.         z++;
  88.         while(--z)
  89.         {
  90.                 for(i=11502;i;i--);
  91.         }
  92. }
  93. /**********************************************************************************
  94. 延时函数,这个延时函数的延时值,大概是1ms,改变z可以获得不同时间的延时
  95. ***********************************************************************************/
  96. void delay(uint z)
  97. {       
  98.         uint x,y;
  99.         for(x=z;x>0;x--)
  100.                 for(y=110;y>0;y--);               
  101. }
  102. /**********************************************************************************
  103. 按键发音函数
  104. 作用是:判断按键是否按下,然后把预设好的初值赋给定时器,从而得到想要的得到的音调
  105. **********************************************************************************/       
  106. void key_scan()
  107. {
  108.         if(KEY1==0)                                                //等待按键按下
  109.         {
  110.                 LED=0;
  111.                 temp1=table[0];                                //为赋初值做准备
  112.                 temp2=table[1];
  113.                 TH0=temp1;
  114.                 TL0=temp2;
  115.                 while(KEY1==0);                                //等待松手
  116.                 TR0=1;                                                //开始计时
  117.                 LED=1;
  118.                 delay(100);                                        //默认节拍是100ms
  119.                 key = 1;
  120.         }
  121.         if(KEY2==0)                                                //等待按键按下
  122.         {
  123.                 LED=0;
  124.                 temp1=table[2];                                //为赋初值做准备
  125.                 temp2=table[3];
  126.                 LED=0;
  127.                 TH0=temp1;
  128.                 TL0=temp2;
  129.                 while(KEY2==0);                                //等待松手
  130.                 TR0=1;
  131.                 LED=1;
  132.                 delay(100);                                        //默认节拍是100ms
  133.                 key = 2;
  134.         }
  135.         if(KEY3==0)                                                //等待按键按下
  136.         {
  137.                 LED=0;
  138.                 temp1=table[4];                                //为赋初值做准备
  139.                 temp2=table[5];
  140.                 LED=0;
  141.                 TH0=temp1;
  142.                 TL0=temp2;
  143.                 while(KEY3==0);                                //等待松手                       
  144.                 TR0=1;                                                //开始计时
  145.                 LED=1;
  146.                 delay(100);                                        //默认节拍是100ms
  147.                 key = 3;
  148.         }
  149.         if(KEY4==0)                                                //等待按键按下
  150.         {
  151.                 LED=0;
  152.                 temp1=table[6];                                //为赋初值做准备
  153.                 temp2=table[7];
  154.                 LED=0;
  155.                 TH0=temp1;
  156.                 TL0=temp2;
  157.                 while(KEY4==0);                                //等待松手
  158.                 TR0=1;                                                //开始计时
  159.                 LED=1;
  160.                 delay(100);                                        //默认节拍是100ms
  161.                 key = 4;
  162.         }
  163.         if(KEY5==0)                                                //等待按键按下
  164.         {
  165.                 LED=0;
  166.                 temp1=table[8];                                //为赋初值做准备
  167.                 temp2=table[9];
  168.                 LED=0;
  169.                 TH0=temp1;
  170.                 TL0=temp2;
  171.                 while(KEY5==0);                                //等待松手
  172.                 TR0=1;                                                //按键松手
  173.                 LED=1;
  174.                 delay(100);                                        //默认节拍是100ms
  175.                 key = 5;
  176.         }
  177.         if(KEY6==0)                                                //等待按键按下
  178.         {
  179.                 LED=0;
  180.                 temp1=table[10];                        //为赋初值做准备
  181.                 temp2=table[11];
  182.                 LED=0;
  183.                 TH0=temp1;
  184.                 TL0=temp2;
  185.                 while(KEY6==0);                                //等待松手
  186.                 TR0=1;                                                //开始计时
  187.                 LED=1;
  188.                 delay(100);                                        //默认节拍是100ms
  189.                 key = 6;
  190.         }
  191.         if(KEY7==0)                                                //等待按键按下
  192.         {
  193.                 LED=0;
  194.                 temp1=table[12];                        //为赋初值做准备
  195.                 temp2=table[13];
  196.                 LED=0;
  197.                 TH0=temp1;
  198.                 TL0=temp2;
  199.                 while(KEY7==0);                                //等待松手
  200.                 TR0=1;                                                //开始计时
  201.                 LED=1;
  202.                 delay(100);                                        //默认节拍是100ms
  203.                 key = 7;
  204.         }
  205.         if(KEY9==0)                                                //等待按键按下
  206.         {
  207.                 LED=0;
  208.                 temp1=table[0];                                //为赋初值做准备
  209.                 temp2=table[1];
  210.                 TH0=temp1;
  211.                 TL0=temp2;
  212.                 while(KEY9==0);                                //等待松手
  213.                 TR0=1;                                                //开始计时
  214.                 LED=1;
  215.                 delay(100);                                        //默认节拍是100ms
  216.                 key = 1;
  217.         }
  218.         if(KEY8 == 0)
  219.         {
  220.                 delay(5);
  221.                 if(KEY8 == 0)
  222.                 {
  223.                         LED=0;
  224.                         while(!KEY8);
  225.                         music++;
  226.                         LED=1;
  227.                         if(music == 5)
  228.                         {
  229.                                 music = 0;
  230.                         }
  231.                         key = 8;
  232.                 }
  233.         }
  234.         TR0=0;        //计时器停止,也就是停止放音
  235. }
  236. /*-------------------------------------------------------------------
  237. 定时器初始化程序
  238. --------------------------------------------------------------------*/
  239. void systimer0_init(void)
  240. {
  241.         TMOD |=0x01;//设置为1时用或(|)
  242.         TMOD &=0xfd;//设置为0时用与(&)
  243.         EA = 1;
  244.         ET0 = 1;
  245.         TR0 = 1;  
  246. }

  247. /**********************************************************************************
  248. 主函数
  249. 作用是:判断按键是否按下,然后把预设好的初值赋给定时器,从而得到想要的得到的音调
  250. **********************************************************************************/       
  251. void main()
  252. {       
  253.         BeepIO=0;
  254.         LED=0;
  255.         systimer0_init();
  256.         while(1)
  257.         {
  258.                 BeepIO=1;
  259.                 key_scan();
  260.                 if(music > 0)
  261.                 {
  262.                         key = 0;
  263.                         if(music == 1)                                                                //判断按键是否按下
  264.                         {
  265.                                 while(1)
  266.                                 {
  267.                                         key_scan();       
  268.                                         if(key != 0)
  269.                                         {
  270.                                                 if(key != 8)
  271.                                                 {
  272.                                                         music = 0;
  273.                                                 }                                               
  274.                                                 break;
  275.                                         }
  276.                                         TH0=table1[music_dat[n][0]]/256;                //赋初值
  277.                                         TL0=table1[music_dat[n][0]]%256;
  278.                                         TR0=1;                                                        //音乐开始
  279.                                         delay100ms(music_dat[n][1]);                //调用延时,用做节拍的发生
  280.                                         n++;                                                        //下个音调开始
  281.                                         if(music_dat[n][0]==0xff)
  282.                                         {
  283.                                                 n=0;                                                        //判断是否到最后一个音调
  284.                                                 TR0=0;                                                        //一个调放完,即将进行下一个调
  285.                                         }                               
  286.                                 }                                               
  287.                         }
  288.                         if(music == 4)                                                                //判断按键是否按下
  289.                         {
  290.                                 while(1)
  291.                                 {
  292.                                         key_scan();       
  293.                                         if(key != 0)
  294.                                         {
  295.                                                 if(key != 8)
  296.                                                 {
  297.                                                         music = 0;
  298.                                                 }                                               
  299.                                                 break;
  300.                                         }
  301.                                         TH0=table1[music_dat1[n1][0]]/256;                //赋初值
  302.                                         TL0=table1[music_dat1[n1][0]]%256;
  303.                                         TR0=1;                                                        //音乐开始
  304.                                         delay100ms(music_dat1[n1][1]);                //调用延时,用做节拍的发生
  305.                                         n1++;                                                        //下个音调开始
  306.                                         if(music_dat1[n1][0]==0xff)
  307.                                         {
  308.                                                 n1=0;                                                        //判断是否到最后一个音调
  309.                                                 TR0=0;                                                        //一个调放完,即将进行下一个调
  310.                                         }                               
  311.                                 }                                               
  312.                         }
  313.                         if(music == 3)                                                                //判断按键是否按下
  314.                         {
  315.                                 while(1)
  316.                                 {
  317.                                         key_scan();       
  318.                                         if(key != 0)
  319.                                         {
  320.                                                 if(key != 8)
  321.                                                 {
  322.                                                         music = 0;
  323.                                                 }                                               
  324.                                                 break;
  325.                                         }
  326.                                         TH0=table1[music_dat2[n2][0]]/256;                //赋初值
  327.                                         TL0=table1[music_dat2[n2][0]]%256;
  328.                                         TR0=1;                                                        //音乐开始
  329.                                         delay100ms(music_dat2[n2][1]);                //调用延时,用做节拍的发生
  330.                                         n2++;                                                        //下个音调开始
  331.                                         if(music_dat2[n2][0]==0xff)
  332.                                         {
  333.                                                 n2=0;                                                        //判断是否到最后一个音调
  334.                                                 TR0=0;                                                        //一个调放完,即将进行下一个调
  335.                                         }                               
  336.                                 }                                               
  337.                         }       
  338.                         if(music == 2)                                                                //判断按键是否按下
  339.                         {
  340.                                 while(1)
  341.                                 {
  342.                                         key_scan();       
  343.                                         if(key != 0)
  344.                                         {
  345.                                                 if(key != 8)
  346.                                                 {
  347.                                                         music = 0;
  348.                                                 }                                               
  349.                                                 break;
  350.                                         }
  351.                                         TH0=table1[music_dat3[n3][0]]/256;                //赋初值
  352.                                         TL0=table1[music_dat3[n3][0]]%256;
  353.                                         TR0=1;                                                        //音乐开始
  354.                                         delay100ms(music_dat3[n3][1]);                //调用延时,用做节拍的发生
  355.                                         n3++;                                                        //下个音调开始
  356.                                         if(music_dat3[n3][0]==0xff)
  357.                                         {
  358.                                                 n3=0;                                                        //判断是否到最后一个音调
  359.                                                 TR0=0;                                                        //一个调放完,即将进行下一个调
  360. ……………………

  361. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
电子琴主程序(4首).zip (63.82 KB, 下载次数: 35)



评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

回复

使用道具 举报

ID:626398 发表于 2019-10-18 21:55 | 显示全部楼层
好懵哦....
回复

使用道具 举报

ID:626813 发表于 2019-11-18 22:39 | 显示全部楼层
这个用不了啊
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表