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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机波形发生器程序与Proteus仿真图
返回列表 发新帖
查看: 1512|回复: 0
打印 上一主题 下一主题
收起左侧

51单片机波形发生器程序与Proteus仿真图

[复制链接]
跳转到指定楼层
楼主
ID:1081343 发表于 2023-6-5 16:57 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
原理说明

一、电源电路

输入使用12V直流，直接给DAC0832数模转换器和LM358运放供电。然后经过7805稳压器稳压输出5V，给单片机系统，1602液晶部分供电。

二、 单片机最小系统部分


单片机最小系统部分，复位电路，电容C1实现上电自动复位。独立按键部分，实现频率加减调节，波形选择，步进值调节。U2为10K排阻，给单片机P0口提供上拉电阻。Y1为12MHz晶振，给单片机提供时钟。

三、1602液晶显示模块电路

1602液晶模块电路使用8位并口进行控制。

四、 数模转换电路


单片机P2口输出数字信号给DAC0832，DAC0832配合LM358运放，把P2口数字量转换成模拟量输出。

     其中电位器R9用于调节波形幅值。幅值最大值为5V。

  
五、   波形产生原理
单片机P2口输出按正弦等波形规律变化的数字量，例，正弦波一个周期取64个点。则单片机一次输出64个按正弦规律变化的数字量，经DA转换后就输出了按正弦规律变化的模拟量。即产生了正弦波。其他波形原理一样。

频率控制：单片机控制数字信号输出的快慢，可以控制波形频率。控制中，单片机采用定时器定时一个时间t，时间t到达后产生定时器溢出中断，中断里单片机控制输出一个数字量。64个中断后，即输出64个数字量，就输出了一个波形完整的周期。由于单片机速度有限，12M晶振，指令周期是1us。例如t=5us，则波形一个周期是5*64=320uS，则波形周期是3.125KHZ。

单片机通过设置定时器时间t来控制波形输出的频率。



更过内容，可参考网上其他文档说明：

https://wenku.baidu.com/view/b5deb046be1e650e52ea99e6.html

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:
  1. #include<reg52.h>                                           //包含头文件
  2. #include<intrins.h>
  3. #define uchar unsigned char                           //宏定义
  4. #define uint unsigned int

  6. sbit s1=P1^0;                                                    //定义按键的接口
  7. sbit s2=P1^1;
  8. sbit s3=P1^2;
  9. sbit s4=P1^3;
  10.                                                                            
  11. sbit lcdrs=P1^6;                                           //液晶控制位
  12. sbit lcden=P1^7;


  15. char num,boxing,u;                                           //定义全局变量
  16. int pinlv=50,bujin=10,bujin1=10;
  17. uchar geshu=1;                                                        //两次DA输出数组中的个数
  18. uchar code table[]="0123456789";                //定义显示的数组
  19. uchar code table1[]="pinlv:boxing:";
  20. unsigned long int m;
  21. int n=0;
  22. float hc=0;
  23. int a,b,h,num1;
  24. uchar code sin[64]={
  25. 135,145,158,167,176,188,199,209,218,226,234,240,245,249,252,254,254,253,251,247,243,237,230,222,213,204,193,182,170,158,
  26. 146,133,121,108,96,84,72,61,50,41,32,24,17,11,7,3,1,0,0,2,5,9,14,20,28,36,45,55,66,78,90,102,114,128
  27. };                                          //正弦波取码
  28. uchar code juxing[64]={
  29. 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
  30. 255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  31. };                                          //矩形波取码
  32. uchar code juchi[64]={
  33. 0,4,8,12,16,20,24,28,32,36,40,45,49,53,57,61,65,69,73,77,81,85,89,93,97,101,105,109,113,117,121,125,130,134,138,142,
  34. 146,150,154,158,162,166,170,174,178,182,186,190,194,198,202,206,210,215,219,223,227,231,235,239,243,247,251,255
  35. };                                          //锯齿波取码
  36. uchar code sanjiao[64]={
  37. 0,8,16,24,32,40,48,56,64,72,80,88,96,104,112,120,128,136,144,152,160,168,176,184,192,200,208,216,224,232,240,248,
  38. 248,240,232,224,216,208,200,192,184,176,168,160,152,144,136,128,120,112,104,96,88,80,72,64,56,48,40,32,24,16,8,0
  39. };                                                //三角波取码


  42. void delay(uint xms)         //延时函数
  43. {
  44.         int a,b;
  45.         for(a=xms;a>0;a--)
  46.                 for(b=110;b>0;b--);
  47. }
  48. void write_com(uchar com)                //写命令函数
  49. {
  50.         lcdrs=0;
  51.         P0=com;        
  52.         delay(1);
  53.         lcden=1;
  54.         delay(1);                                                                           
  55.         lcden=0;
  56. }

  58. void write_date(uchar date)                //写数据函数
  59. {
  60.         lcdrs=1;
  61.         P0=date;
  62.         delay(1);
  63.         lcden=1;
  64.         delay(1);
  65.         lcden=0;
  66. }

  68. void init_lcd()                                        //初始化函数
  69. {                                                                  
  70.         lcden=0;                                        //默认开始状态为关使能端，见时序图  
  71.         write_com(0x0f);
  72.         write_com(0x38);                        //显示模式设置，默认为0x38,不用变。
  73.         write_com(0x01);                        //显示清屏，将上次的内容清除，默认为0x01.
  74.         write_com(0x0c);                        //显示功能设置0x0f为开显示，显示光标，光标闪烁；0x0c为开显示，不显光标，光标不闪
  75.         write_com(0x06);                        //设置光标状态默认0x06,为读一个字符光标加1.
  76.         write_com(0x80);                        //设置初始化数据指针，是在读指令的操作里进行的
  77. }
  78. void initclock()                           //时钟初始化
  79. {
  80.         uint i;
  81.         TMOD=0x01;
  82.         TH0=a;
  83.         TL0=b;
  84.         EA=1;
  85.         ET0=1;
  86.         TR0=1;
  87.         for(i=6;i<13;i++)                           //显示初始化
  88.         {
  89.                 write_date(table1[i]);
  90.                 delay(2);
  91.         }
  92.         write_com(0x80+0x40);
  93.         for(i=0;i<6;i++)
  94.         {
  95.                 write_date(table1[i]);
  96.                 delay(2);
  97.         }
  98.         write_com(0x80+7);
  99.                 write_date('s');
  100.                 write_date('i');
  101.                 write_date('n');
  102.                 write_date(' ');
  103.                 write_date(' ');
  104.                 write_date(' ');
  105.                 write_date(' ');
  106.                 write_com(0x80+0x40+0xa);
  107.                 write_date(' ');
  108.                 write_date('1');
  109.                 write_date('0');
  110.                 write_date('H');
  111.                 delay(2);
  112.                 write_date('Z');
  113.                 delay(2);
  114. }
  115. void display()                                   //显示函数
  116. {
  117.         uchar wan,qian,bai,shi,ge;
  118.         uint a=0;
  119.         a=pinlv;
  120.         wan=a/10000;
  121.         qian=a/1000%10;
  122.         bai=a/100%10;
  123.         shi=a%100/10;
  124.         ge=a%100%10;
  125.         write_com(0x80+0x40+8);
  126.         write_date(table[wan]);
  127.         delay(2);
  128.         write_date(table[qian]);
  129.         delay(2);
  130.         write_date(table[bai]);
  131.         delay(2);
  132.         
  133.         write_date(table[shi]);
  134.         delay(2);
  135.         write_date(table[ge]);
  136.         delay(2);
  137.         write_date('H');
  138.         delay(2);
  139.         write_date('Z');
  140.         delay(2);
  141.         if(boxing==0)
  142.         {
  143.                 write_com(0x80+7);
  144.                 write_date('s');
  145.                 write_date('i');
  146.                 write_date('n');
  147.                 write_date(' ');
  148.                 write_date(' ');
  149.                 write_date(' ');
  150.                 write_date(' ');
  151.         }
  152.         if(boxing==1)
  153.         {
  154.                 write_com(0x80+7);
  155.                 write_date('j');
  156.                 write_date('u');
  157.                 write_date('x');
  158.                 write_date('i');
  159.                 write_date('n');
  160.                 write_date('g');
  161.         }

  163.         if(boxing==2)
  164.         {
  165.                 write_com(0x80+7);
  166.                 write_date('s');
  167.                 write_date('a');
  168.                 write_date('n');
  169.                 write_date('j');
  170.                 write_date('i');
  171.                 write_date('a');
  172.                 write_date('o');
  173.         }
  174.         if(boxing==3)
  175.         {
  176.                 write_com(0x80+7);
  177.                 write_date('j');
  178.                 write_date('u');
  179.                 write_date('c');
  180.                 write_date('h');
  181.                 write_date('i');
  182.                 write_date(' ');
  183.                 write_date(' ');
  184.         }

  186. }
  187. uchar keyscan()                                        //键盘检测函数
  188. {
  189. //        if(P1&0x0F==0x0F) return 0;
  190.         if(s1==0)
  191.         {         
  192.                 EA=0;
  193.                 delay(1);
  194.                 if(s1==0)
  195.                 {
  196.                         while(!s1);
  197.                         pinlv+=bujin;
  198.                         if(pinlv>30000)
  199.                         {
  200.                                 pinlv=30000;
  201.                         }
  202.                         geshu=pinlv/120+1;
  203.                         if(pinlv>960)
  204.                         {
  205.                                 geshu=8;
  206.                                 bujin=100;
  207.                                 bujin1=100;
  208.                         }
  209.                         if(pinlv>1080) geshu=10;
  210.                         if(pinlv>2000) geshu=11;

  212.                         hc=15625/pinlv;
  213.                         m=hc*geshu;
  214.                         m-=54;
  215.                         m/=15;
  216.                         
  217.                         EA=1;
  218.                         display();
  219.                         
  220.                 }
  221.         }
  222.         if(s2==0)
  223.         {         
  224.                
  225.                 delay(1);
  226.                 if(s2==0)
  227.                 {
  228.                         EA=0;        
  229.                         while(!s2);
  230.                         pinlv-=bujin;
  231.                         if(pinlv<0)
  232.                         {
  233.                                 pinlv=0;
  234.                         }
  235.                         geshu=pinlv/120+1;
  236.                         if(pinlv>960)
  237.                         {
  238.                                 geshu=8;
  239.                                 bujin=100;
  240.                                 bujin1=100;
  241.                         }
  242.                         if(pinlv>1080) geshu=10;
  243.                         if(pinlv>2000) geshu=11;
  244.                         if(pinlv<=3100)
  245.                                 {hc=15625/pinlv;
  246.                                 m=hc*geshu;
  247.                                 m-=54;
  248.                                 m/=15;}        
  249.                         else
  250.                         {
  251.                                 m=65276+(pinlv-480);
  252.                         }
  253.                         display();        
  254.                         EA=1;
  255.                 }
  256.         }
  257.         if(s3==0)
  258.         {         
  259.                 delay(1);
  260.                 if(s3==0)
  261.                 {
  262.                         EA=0;
  263.                         while(!s3);
  264.                         boxing++;
  265.                         if(boxing==4)
  266.                         {
  267.                                 boxing=0;
  268.                         }
  269.                         display();
  270.                         EA=1;
  271.                 }
  272.         }
  273.         return 1;        
  274. }
  275. void bujindisplay()
  276. {
  277.         uint bai,shi,ge;
  278.         bai=bujin1/100;
  279.         shi=bujin1%100/10;
  280.         ge=bujin1%100%10;
  281.         write_com(0x80+6);
  282.         write_date(table[bai]);
  283.         delay(1);
  284.         write_date(table[shi]);
  285.         delay(1);
  286.         write_date(table[ge]);
  287.         delay(1);
  288. }
  289. void bujinjiance()
  290. {
  291.         if(s4==0)
  292.         {
  293.                 delay(3);
  294.                 if(s4==0)
  295.                 {
  296.                          while(!s4);
  297.                          h++;
  298.                          if(h==1)
  299.                          {
  300.                                   write_com(0x01);
  301.                                  write_com(0x80);
  302.                                  write_date('b');delay(1);
  303.                                  write_date('u');delay(1);
  304.                                  write_date('j');delay(1);
  305.                                  write_date('i');delay(1);
  306.                                  write_date('n');delay(1);
  307.                                  write_date(':');delay(1);
  308.                                  bujin1=bujin;
  309.                                  
  310.                                  bujindisplay();
  311.                          }
  312.                          if(h==2)
  313.                          {
  314.                                  h=0;
  315.                                 bujin=bujin1;
  316.                                 
  317.                                 init_lcd();
  318.                                 initclock();
  319.                                 display();
  320.                          }
  321.                 }
  322.         }
  323.         if(h==1)
  324.         {
  325.                 if(s1==0)
  326.                 {
  327.                         delay(5);
  328.                         if(s1==0)
  329.                         {
  330.                                 while(!s1);
  331.                                 bujin1++;
  332.                                 if(bujin1==101)
  333.                                 {
  334.                                         bujin1=100;
  335.                                 }
  336.                                 bujindisplay();
  337.                         }
  338.                 }
  339.                 if(s2==0)
  340.                 {
  341.                         delay(5);
  342.                         if(s2==0)
  343.                         {
  344.                                 while(!s2);
  345.                                 bujin1--;
  346.                                 if(bujin1==0)
  347.                                 {
  348.                                         bujin1=100;
  349.                                 }
  350.                                 bujindisplay();
  351.                         }
  352.                 }
  353.         }
  354. }
  355. void main()                                         //主函数
  356. {        
  357.         
  358.         init_lcd();
  359.         hc=15625/pinlv;
  360.         m=hc*geshu;
  361.         m-=54;
  362.         m/=15;

  364.         initclock();
  365.         display();
  366. //        csda=0;
  367. //        wr=0;
  368.         while(1)
  369.         {
  370.                  
  371.                  switch(boxing)
  372.                  {
  373.                          case 0:        P2=sin[u];
  374.                                 break;
  375.                         case 1:         P2=juxing[u];
  376.                                 break;
  377.                         case 2:                 P2=sanjiao[u];
  378.                                 break;
  379.                         case 3:                 P2=juchi[u];
  380.                                 break;
  381.                  }
  382.                 u+=geshu;
  383.                 n=m;
  384.                 if(u>=64)
  385.                 {
  386.                         u=0;
  387.                 }
  388.                 while(n-->0);
  389.         }
  390. }
  391. void T0_time()interrupt 1                   //定时器
  392. {
  393.         
  394. //                TH0=a;
  395. //                TL0=b;
  396.                 TH0=0;
  397.                 TL0=0;
  398.                 if(h==0)
  399.                  {
  400.                           keyscan();
  401.                  }
  402.                  bujinjiance();
  403.                
  404.         

  406. }
复制代码

Keil5代码与Proteus8.13仿真下载:
信号发生器.7z (1.54 MB, 下载次数: 29)

评分

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

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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