设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机电子贺卡源程序与Proteus仿真原理图
返回列表 发新帖
查看: 1085|回复: 0
收起左侧

单片机电子贺卡源程序与Proteus仿真原理图

[复制链接]
ID:1086564 发表于 2023-7-3 15:24 | 显示全部楼层 |阅读模式
电子贺卡仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）
51hei.gif

单片机电子贺卡源程序如下:
  1. #include<reg52.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint unsigned int  
  5. sbit SPEAK=P2^7;  //定义蜂鸣器输出端口
  6. sbit CS1=P2^4;            
  7. sbit CS2=P2^3;            
  8. sbit RS=P2^2;            
  9. sbit RW=P2^1;            
  10. sbit E=P2^0;
  11. sbit L1=P1^0;
  12. sbit L2=P1^1;

  14. uchar code HZ0[]={

  16. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  17. .................
  18. ...............
  19. 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
  20. };



  24. void delayus(uchar delay)
  25. {
  26. uchar i;
  27. for(i=0;i<=delay;i++)
  28. _nop_();
  29. }

  31. void check_busy()
  32. {
  33. uchar a=0;
  34. for(a=0;a<200;a++);                  //此处为延时，一段时间后确保处于空闲状态
  35.                                       //此处为状态查询，查询忙状态，没有使用成功，以后再调试
  36. /*RW=1;
  37. RS=0;                                 
  38. E=1;
  39. while(1)
  40. {
  41.      E=1;
  42.      if(!(P0&0x80))
  43.         break;
  44.             a++;
  45.      if(a>10)
  46.                   break;
  47.             
  48. }        
  49. E=1;*/

  51. }      


  54. void write_cmd(uchar inst)
  55. {
  56. check_busy();
  57. RS=0;
  58. RW=0;
  59. E=1;
  60. P3=inst;
  61. E=0;
  62. _nop_();
  63. }



  67. void write_data(uchar dat)
  68. {
  69. check_busy();
  70. RS=1;
  71. RW=0;
  72. E=1;
  73. P3=dat;
  74. E=0;
  75. _nop_();
  76. }



  80. void LCD_Init()
  81. {
  82. write_cmd(0x30);//30H--基本指令操作?
  83. delayus(4);
  84. write_cmd(0x0c);//开显示，关光标，不闪烁。
  85. delayus(10);
  86. write_cmd(0x01);//清除显示
  87. delayus(10);
  88. write_cmd(0x06);//光标的移动方向左，DDRAM的地址计数器（AC）加1。
  89. delayus(10);
  90. }



  94. void set_xy(uchar x,uchar y)           //x为行，y为列
  95. {
  96. if(y>=64)                            //列地址大于等于64时右屏显示?
  97. {
  98.    CS2=0;                          //低电平选择
  99.         CS1=1;                            //写右屏是左屏关闭，不然两边会同时显示
  100.         y=y-64;
  101. }
  102. else                                 //列地址小于64时左屏显示
  103. {
  104.    CS1=0;                             //同上
  105.         CS2=1;
  106. }
  107. write_cmd(0x40|y);                      //写列地址
  108. _nop_();
  109. write_cmd(0xb8|x);                         //写行地址?
  110. }

  112. //显示函数
  113. void disp_hz(uchar *p)
  114. {
  115. uchar i;
  116. for(i=0;i<128;i++)
  117. {
  118. set_xy(0,i);           
  119. write_data(p[i]);         
  120. set_xy(1,i);        
  121. write_data(p[i+128]);
  122. set_xy(2,i);      
  123. write_data(p[i+256]);

  125. set_xy(3,i);      
  126. write_data(p[i+384]);

  128. set_xy(4,i);        
  129. write_data(p[i+512]);

  131. set_xy(5,i);        
  132. write_data(p[i+640]);

  134. set_xy(6,i);      
  135. write_data(p[i+768]);

  137. set_xy(7,i);        
  138. write_data(p[i+896]);

  140. set_xy(8,i);      
  141. write_data(p[i+1024]);
  142. }
  143. }
  144. void disp_zf(uchar R,uchar L,uchar *p)
  145. {
  146. uchar i;
  147. for(i=0;i<8;i++)
  148. {
  149. set_xy(2*R,8*L+i);               
  150. write_data(p[i]);
  151. set_xy(2*R+1,8*L+i);               
  152. write_data(p[i+8]);
  153. }
  154. }


  157. uchar beat,tl,th,key=0,k=0,temp; //定义节拍和T0初值变量
  158. uchar code TABLE[]={   //音符对应的定时器初值表  
  159. 0xfb,0x04,0xfb,0x90,0xfc,0x09,0xfc,0x44,  
  160. 0xfc,0xac,0xfd,0x09,0xfd,0x34,0xfd,0x82,  
  161. 0xfd,0xc8,0xfe,0x06,0xfe,0x22,0xfe,0x56,   
  162. 0xfe,0x85,0xfe,0x9a,0xfe,0xc1};  
  163. uchar code GRACE[]={   //《奇异恩典》音符码表           
  164. 0x14,0x48,0x62,0x42,0x68,0x54,0x48,0x24,0x18,  
  165. 0x14,0x48,0x62,0x42,0x68,0x54,0x8c,0x88,   
  166. 0x64,0x86,0x62,0x82,0x62,0x48,0x14,0x26,0x42,0x42,0x22,0x18,   
  167. 0x14,0x48,0x62,0x42,0x68,0x54,0x4c,0x48,0x00};  
  168. uchar code JOY[]={     //《欢乐颂》音符码表   
  169. 0x64,0x64,0x74,0x84,0x84,0x74,0x64,0x54,
  170. 0x44,0x44,0x54,0x64,0x66,0x52,0x58,0x64,
  171. 0x64,0x74,0x84,0x84,0x74,0x64,0x54,0x44,
  172. 0x44,0x54,0x64,0x56,0x42,0x48,0x54,0x54,
  173. 0x64,0x44,0x54,0x62,0x72,0x64,0x44,0x54,
  174. 0x62,0x72,0x64,0x54,0x44,0x54,0x18,0x64,
  175. 0x64,0x74,0x84,0x84,0x74,0x64,0x54,0x44,
  176. 0x44,0x54,0x64,0x56, 0x42,0x48,0x00};
  177. uchar code HAPPY[]={   //《生日快乐》音符码表  
  178. 0x82,0x01,0x81,0x94,0x84,0xB4,0xA4,0x04,  
  179. 0x82,0x01,0x81,0x94,0x84,0xC4,0xB4,0x04,   
  180. 0x82,0x01,0x81,0xF4,0xD4,0xB4,0xA4,0x94,
  181. 0xE2,0x01,0xE1,0xD4,0xB4,0xC4,0xB4,0x04,  
  182. 0x82,0x01,0x81,0x94,0x84,0xB4,0xA4,0x04,  
  183. 0x82,0x01,0x81,0x94,0x84,0xC4,0xB4,0x04,  
  184. 0x82,0x01,0x81,0xF4,0xD4,0xB4,0xA4,0x94,  
  185. 0xE2,0x01,0xE1,0xD4,0xB4,0xC4,0xB4,0x04,   
  186. 0x00};   
  187. void Timer0_Initialize();
  188. void delay_10ms();
  189. void Delay(uchar);  
  190. void Key_Scan();
  191. uint a[4]={0,1,2,3};
  192.   void main()
  193.   {  
  194.           uchar m,m1; //定义临时变量      
  195.           uchar *p[3];  
  196.           uchar beat=0;     
  197.           p[0]=GRACE;
  198.           p[1]=JOY;
  199.           p[2]=HAPPY;     
  200.           Timer0_Initialize();         
  201.       while(1)  
  202.       {         
  203.                           Key_Scan();
  204.                         if(key!=3)
  205.                                 TR0=1;
  206.                           switch(key)
  207.                                   {        
  208.                                         P1=0xff;
  209.                                         case 0:
  210.                                                         disp_hz(HZ0 );
  211.                                                         temp=key;
  212.                                                         TR0=1;
  213.                                                         while(*(p[key]+k)!=0) //判断取得的音符码是否为结束码   
  214.                                                         {   
  215.                                                                 beat=*(p[key]+k)&0x0f; //取节拍码   
  216.                                                                 m=_crol_(*(p[key]+k),4)&0x0f; //取音调码   
  217.                                                                 if(beat!=0)
  218.                                                                 {   //判断取得的音调码是否为0     {        //不是，根据取得的音调码计算T0初值      
  219.                                                                         m1=--m*2+1;     
  220.                                                                         m=m*2;     
  221.                                                                         tl=TL0=TABLE[m1];     
  222.                                                                         th=TH0=TABLE[m];     
  223.                                                                
  224.                                                                 }   
  225.                                                                 else
  226.                                                                 {       //取得的节拍码为0，则停止T0      
  227.                                                                         TR0=0;
  228.                                                                 }     
  229.                                                                   Delay(beat);   
  230.                                                                   k++;
  231.                                                                  Key_Scan();
  232.                                                                  delay_10ms();
  233.                                                                  if(temp!=key)break;                                      
  234.                                                         }
  235.                                                         TR0=0;
  236.                                                         k=0;
  237.                                                         break;
  238.                                                 
  239.                                         case 1:
  240.                                                         disp_hz(HZ1 );
  241.                                                             temp=key;
  242.                                                         TR0=1;
  243.                                                         while(*(p[key]+k)!=0) //判断取得的音符码是否为结束码   
  244.                                                         {   
  245.                                                                 beat=*(p[key]+k)&0x0f; //取节拍码   
  246.                                                                 m=_crol_(*(p[key]+k),4)&0x0f; //取音调码   
  247.                                                                 if(beat!=0)
  248.                                                                 {   //判断取得的音调码是否为0     {        //不是，根据取得的音调码计算T0初值      
  249.                                                                         m1=--m*2+1;     
  250.                                                                         m=m*2;     
  251.                                                                         tl=TL0=TABLE[m1];     
  252.                                                                         th=TH0=TABLE[m];     
  253.                                                                
  254.                                                                 }   
  255.                                                                 else
  256.                                                                 {       //取得的节拍码为0，则停止T0      
  257.                                                                         TR0=0;
  258.                                                                 }     
  259.                                                                   Delay(beat);   
  260.                                                                   k++;
  261.                                                                  Key_Scan();
  262.                                                                  delay_10ms();
  263.                                                                  if(temp!=key)break;                                      
  264.                                                         }
  265.                                                         TR0=0;
  266.                                                         k=0;
  267.                                                         break;
  268.                                                 
  269.                                         case 2:
  270.                                                         disp_hz(HZ2 );
  271.                                                         temp=key;
  272.                                                         TR0=1;
  273.                                                         while(*(p[key]+k)!=0) //判断取得的音符码是否为结束码   
  274.                                                         {   
  275.                                                                 beat=*(p[key]+k)&0x0f; //取节拍码   
  276.                                                                 m=_crol_(*(p[key]+k),4)&0x0f; //取音调码   
  277.                                                                 if(beat!=0)
  278.                                                                 {   //判断取得的音调码是否为0     {        //不是，根据取得的音调码计算T0初值      
  279.                                                                         m1=--m*2+1;     
  280.                                                                         m=m*2;     
  281.                                                                         tl=TL0=TABLE[m1];     
  282.                                                                         th=TH0=TABLE[m];     
  283.                                                                
  284.                                                                 }   
  285.                                                                 else
  286.                                                                 {       //取得的节拍码为0，则停止T0      
  287.                                                                         TR0=0;
  288.                                                                 }     
  289.                                                                   Delay(beat);   
  290.                                                                   k++;
  291.                                                                  Key_Scan();
  292.                                                                  delay_10ms();
  293.                                                                  if(temp!=key)break;                                      
  294.                                                         }
  295.                                                         TR0=0;
  296.                                                         k=0;
  297.                                                         break;
  298.                                         case 3:
  299.                                                 TR0=0;break;

  301.                                  }
  302.                         }
  303.                 }
  304.                        
  305.          
  306.          
  307.                   void Timer0_Initialize()
  308.                   {  
  309.                           EA=1;
  310.                           ET0=1;
  311.                           TMOD=0x01;  
  312.                           TR0=1;
  313.                   }  
  314.                   void timer0() interrupt 1 using 1
  315.                   {      
  316.                           TL0=tl;
  317.                           TH0=th;        //重装定时初值      
  318.                           SPEAK=~SPEAK;
  319.                   }           //蜂鸣器控制端口电平取反 }  /************************ 四分之一拍延时函数 ************************/
  320.                   void Delay_Beat()
  321.                   {  
  322.                           uint i;  
  323.                           for(i=0;i<20000;i++);
  324.                   }   
  325.                   void Delay(uchar tt)
  326.                   {  
  327.                            uchar i;  
  328.                            for(i=0;i<tt;i++)     
  329.                            Delay_Beat();  
  330.                    }
  331.                    void delay_10ms()
  332.                    {  
  333.                            int i;  
  334.                            for(i=0;i<200;i++);
  335.                    }  
  336.                    void Key_Scan()
  337.                    {   
  338.                                    uchar i,temp1;        
  339.                                         P1=0xfb;
  340.                                         for(i=0;i<=1;i++)
  341.                                         {
  342.                                                 if(L1==0)
  343.                                                 {
  344.                                                         if(i==0)
  345.                                                                 key=a[i];
  346.                                                         else
  347.                                                                 key=a[i+1];
  348.                                                                
  349.                                                 }
  350.                                                 if(L2==0)
  351.                                                 {   
  352.                                                         if(i==0)
  353.                                                                 key=a[i+1];
  354.                                                         else
  355.                                                                 key=a[i+2];
  356.                                                 }
  357.                                 
  358.                                                 delay_10ms();
  359.                                                 temp1=P1;
  360.                                                 temp1=temp1|0x03;
  361.                                                 temp1=temp1<<1;
  362.                                                 temp1=temp1|0x03;
  363.                                                 P1=temp1;
  364.                                  }
  365.                    }   

复制代码


Keil代码与Proteus仿真下载: 仿真和程序.7z (108.6 KB, 下载次数: 17)

评分

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

查看全部评分

回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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