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

標題: 51單片機波形發生器程序與Proteus仿真圖 [打印本頁]

---

作者: GJIHK    時間: 2023-6-5 16:57
標題: 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
   
5. 
   
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;
    
13. 
    
14. 
    
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. };                                                //三角波取碼
    
40. 
    
41. 
    
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. }
    
57. 
    
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. }
    
67. 
    
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.         }
     
162. 
     
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.         }
     
185. 
     
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;
     
211. 
     
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;
     
363. 
     
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.         
     
405. 
     
406. }
     

復制代碼

Keil5代碼與Proteus8.13仿真下載:
信號發生器.7z (1.54 MB, 下載次數: 29)

2023-6-5 17:11 上傳

點擊文件名下載附件
下載積分: 黑幣 -5

---

歡迎光臨 (http://www.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影