欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 1608|回復: 0
打印 上一主題 下一主題
收起左側

51單片機波形發生器程序與Proteus仿真圖

[復制鏈接]
跳轉到指定樓層
樓主
原理說明

一、電源電路

輸入使用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 分享淘帖 頂頂 踩踩
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表