标题: 单片机程序中pwm信号读取不出来，求解救！ [打印本页]

---

作者: 石头儿    时间: 2017-11-19 00:05
标题: 单片机程序中pwm信号读取不出来，求解救！
51单片机中断中pwm的信号读取不出来，无法和count比较

1. #include<reg52.h>
   
2. #include "control.h"
   
3. #include "12864.h"
   
4. #define uchar unsigned char
   
5. #define uint unsigned int
   
6. #define keydata P1
   
7. sbit A1=P2^2;
   
8. sbit A2=P2^3;
   
9. sbit ENA=P2^4;
   
10. signed int count=0;
    
11. signed char pwm=0;
    
12. signed char anjian=0;
    
13. uchar numshi=0;
    
14. uchar numge=0;
    
15. void delayms(unsigned int xms)
    
16. {
    
17.         unsigned int i,j;
    
18.         for(i=0;i<xms;i++)
    
19.                 for(j=0;j<110;j++);
    
20. }
    
21. 
    
22. void pwm_dis()
    
23. {
    
24.         numshi=pwm/10;
    
25.         numge=pwm%10;
    
26.         write_12864_data(0x30+numshi);
    
27.         write_12864_data(0x30+numge);      
    
28. }
    
29. 
    
30. void anjian_dis()
    
31. {
    
32.         numshi=anjian/10;
    
33.         numge=anjian%10;
    
34.         write_12864_data(0x30+numshi);
    
35.         write_12864_data(0x30+numge);      
    
36. }
    
37. void keyscan()
    
38. {
    
39.                 unsigned char dat=0;
    
40.                 unsigned char num=0;
    
41.                         keydata=0xfe;
    
42.                         dat=keydata;
    
43.                         dat=dat&0xf0;
    
44.                         while(dat!=0xf0)
    
45.                                 {
    
46.                                         delayms(5);
    
47.                                         dat=keydata;
    
48.                                         dat=dat&0xf0;
    
49.                                         while(dat!=0xf0)
    
50.                                         {
    
51.                                                 dat=keydata;
    
52.                                         switch(dat)
    
53.                                                 {
    
54.                                                         case 0xee:num=1;
    
55.                                                                 break;
    
56.                                                         case 0xde:num=2;
    
57.                                                                 break;
    
58.                                                         case 0xbe:num=3;
    
59.                                                                 break;
    
60.                                                         case 0x7e:num=4;
    
61.                                                                 break;
    
62.                                                 }
    
63.                                         while(dat!=0xf0)
    
64.                                                 {
    
65.                                                         dat=keydata;
    
66.                                                         dat=dat&0xf0;
    
67.                                                 }
    
68.                                                
    
69.                                         }
    
70.                                 }
    
71. 
    
72.                         keydata=0xfd;
    
73.                         dat=keydata;
    
74.                         dat=dat&0xf0;
    
75.                         while(dat!=0xf0)
    
76.                                 {
    
77.                                         delayms(5);
    
78.                                         dat=keydata;
    
79.                                         dat=dat&0xf0;
    
80.                                         while(dat!=0xf0)
    
81.                                         {
    
82.                                                 dat=keydata;
    
83.                                         switch(dat)
    
84.                                                 {
    
85.                                                         case 0xed:num=5;
    
86.                                                                 break;
    
87.                                                         case 0xdd:num=6;
    
88.                                                                 break;
    
89.                                                         case 0xbd:num=7;
    
90.                                                                 break;
    
91.                                                         case 0x7d:num=8;
    
92.                                                                 break;
    
93.                                                 }
    
94.                                         while(dat!=0xf0)
    
95.                                                 {
    
96.                                                         dat=keydata;
    
97.                                                         dat=dat&0xf0;
    
98.                                                 }
    
99.                                                
    
100.                                         }
     
101.                                 }
     
102. 
     
103. 
     
104.                         keydata=0xfb;
     
105.                         dat=keydata;
     
106.                         dat=dat&0xf0;
     
107.                         while(dat!=0xf0)
     
108.                                 {
     
109.                                         delayms(5);
     
110.                                         dat=keydata;
     
111.                                         dat=dat&0xf0;
     
112.                                         while(dat!=0xf0)
     
113.                                         {
     
114.                                                 dat=keydata;
     
115.                                         switch(dat)
     
116.                                                 {
     
117.                                                         case 0xeb:num=9;
     
118.                                                                 break;
     
119.                                                         case 0xdb:num=10;
     
120.                                                                 break;
     
121.                                                         case 0xbb:num=11;
     
122.                                                                 break;
     
123.                                                         case 0x7b:num=12;
     
124.                                                                 break;
     
125.                                                 }
     
126.                                         while(dat!=0xf0)
     
127.                                                 {
     
128.                                                         dat=keydata;
     
129.                                                         dat=dat&0xf0;
     
130.                                                 }
     
131.                                        
     
132.                                         }
     
133.                                 }
     
134. 
     
135. 
     
136.                         keydata=0xf7;
     
137.                         dat=keydata;
     
138.                         dat=dat&0xf0;
     
139.                         while(dat!=0xf0)
     
140.                                 {
     
141.                                         delayms(5);
     
142.                                         dat=keydata;
     
143.                                         dat=dat&0xf0;
     
144.                                         while(dat!=0xf0)
     
145.                                         {
     
146.                                                 dat=keydata;
     
147.                                         switch(dat)
     
148.                                                 {
     
149.                                                         case 0xe7:num=13;
     
150.                                                                 break;
     
151.                                                         case 0xd7:num=14;
     
152.                                                                 break;
     
153.                                                         case 0xb7:num=15;
     
154.                                                                 break;
     
155.                                                         case 0x77:num=16;
     
156.                                                                 break;
     
157.                                                 }
     
158.                                         while(dat!=0xf0)
     
159.                                                 {
     
160.                                                         dat=keydata;
     
161.                                                         dat=dat&0xf0;
     
162.                                                 }
     
163.                                                
     
164.                                         }
     
165.                                 }
     
166.                
     
167.                
     
168.       
     
169.                 switch(num)
     
170.                 {
     
171.                         case 1:        write_12864_addr(1,3);
     
172.                                 pwm=0;
     
173.                                 pwm_dis();
     
174.                                 break;
     
175.                 case 2:        write_12864_addr(1,3);
     
176.                                 pwm=10;
     
177.                                 pwm_dis();
     
178.                                 break;
     
179.                 case 3:write_12864_addr(1,3);
     
180.                                 pwm=20;
     
181.                                 pwm_dis();
     
182.                                 break;
     
183.                 case 4:write_12864_addr(1,3);
     
184.                                 pwm=30;
     
185.                                 pwm_dis();
     
186.                                 break;
     
187.                 case 5:write_12864_addr(1,3);
     
188.                                 pwm=40;
     
189.                                 pwm_dis();
     
190.                                 break;
     
191.                 case 6:write_12864_addr(1,3);
     
192.                                 pwm=50;
     
193.                                 pwm_dis();
     
194.                                 break;
     
195.                 case 7:write_12864_addr(1,3);
     
196.                                 pwm=60;
     
197.                                 pwm_dis();
     
198.                                 break;
     
199.                 case 8:write_12864_addr(1,3);
     
200.                                 pwm=70;
     
201.                                 pwm_dis();
     
202.                                 break;
     
203. 
     
204.                 case 9:        write_12864_addr(1,3);
     
205.                                 pwm=80;
     
206.                                 pwm_dis();
     
207.                                 break;
     
208.                 case 10:        write_12864_addr(1,3);
     
209.                                 pwm=90;
     
210.                                 pwm_dis();
     
211.                               
     
212.                                 break;
     
213.                 case 11:write_12864_addr(1,3);
     
214.                        
     
215.                                 pwm=99;
     
216.                                 pwm_dis();
     
217.                                 break;
     
218.                 case 12:write_12864_addr(1,3);
     
219.                        
     
220.                                 pwm=35;
     
221.                                 pwm_dis();
     
222.                                 break;
     
223.                 case 13:write_12864_addr(1,3);
     
224.                        
     
225.                                 pwm=pwm+5;
     
226.                                 pwm_dis();
     
227.                                 break;
     
228.                 case 14:write_12864_addr(1,3);
     
229.                        
     
230.                                 pwm=pwm-5;
     
231.                                 pwm_dis();
     
232.                                 break;
     
233.                 case 15:write_12864_addr(1,3);
     
234.                                 pwm=pwm+1;
     
235.                                 pwm_dis();
     
236.                                 break;
     
237.                 case 16:write_12864_addr(1,3);
     
238.                                 pwm=pwm-1;
     
239.                                 pwm_dis();
     
240.                                 break;
     
241. 
     
242. 
     
243.         }
     
244.       
     
245. 
     
246.       
     
247. }
     
248. 
     
249. void keyscan_1()
     
250. {
     
251.                 unsigned char dat=0;
     
252.                 unsigned char num=0;
     
253.                         keydata=0xfe;
     
254.                         dat=keydata;
     
255.                         dat=dat&0xf0;
     
256.                         while(dat!=0xf0)
     
257.                                 {
     
258.                                         delayms(5);
     
259.                                         dat=keydata;
     
260.                                         dat=dat&0xf0;
     
261.                                         while(dat!=0xf0)
     
262.                                         {
     
263.                                                 dat=keydata;
     
264.                                         switch(dat)
     
265.                                                 {
     
266.                                                         case 0xee:num=1;
     
267.                                                                 break;
     
268.                                                         case 0xde:num=2;
     
269.                                                                 break;
     
270.                                                         case 0xbe:num=3;
     
271.                                                                 break;
     
272.                                                         case 0x7e:num=4;
     
273.                                                                 break;
     
274.                                                 }
     
275.                                         while(dat!=0xf0)
     
276.                                                 {
     
277.                                                         dat=keydata;
     
278.                                                         dat=dat&0xf0;
     
279.                                                 }
     
280.                                                
     
281.                                         }
     
282.                                 }
     
283. 
     
284.                         keydata=0xfd;
     
285.                         dat=keydata;
     
286.                         dat=dat&0xf0;
     
287.                         while(dat!=0xf0)
     
288.                                 {
     
289.                                         delayms(5);
     
290.                                         dat=keydata;
     
291.                                         dat=dat&0xf0;
     
292.                                         while(dat!=0xf0)
     
293.                                         {
     
294.                                                 dat=keydata;
     
295.                                         switch(dat)
     
296.                                                 {
     
297.                                                         case 0xed:num=5;
     
298.                                                                 break;
     
299.                                                         case 0xdd:num=6;
     
300.                                                                 break;
     
301.                                                         case 0xbd:num=7;
     
302.                                                                 break;
     
303.                                                         case 0x7d:num=8;
     
304.                                                                 break;
     
305.                                                 }
     
306.                                         while(dat!=0xf0)
     
307.                                                 {
     
308.                                                         dat=keydata;
     
309.                                                         dat=dat&0xf0;
     
310.                                                 }
     
311.                                                
     
312.                                         }
     
313.                                 }
     
314. 
     
315. 
     
316.                         keydata=0xfb;
     
317.                         dat=keydata;
     
318.                         dat=dat&0xf0;
     
319.                         while(dat!=0xf0)
     
320.                                 {
     
321.                                         delayms(5);
     
322.                                         dat=keydata;
     
323.                                         dat=dat&0xf0;
     
324.                                         while(dat!=0xf0)
     
325.                                         {
     
326.                                                 dat=keydata;
     
327.                                         switch(dat)
     
328.                                                 {
     
329.                                                         case 0xeb:num=9;
     
330.                                                                 break;
     
331.                                                         case 0xdb:num=10;
     
332.                                                                 break;
     
333.                                                         case 0xbb:num=11;
     
334.                                                                 break;
     
335.                                                         case 0x7b:num=12;
     
336.                                                                 break;
     
337.                                                 }
     
338.                                         while(dat!=0xf0)
     
339.                                                 {
     
340.                                                         dat=keydata;
     
341.                                                         dat=dat&0xf0;
     
342.                                                 }
     
343.                                        
     
344.                                         }
     
345.                                 }
     
346. 
     
347. 
     
348.                         keydata=0xf7;
     
349.                         dat=keydata;
     
350.                         dat=dat&0xf0;
     
351.                         while(dat!=0xf0)
     
352.                                 {
     
353.                                         delayms(5);
     
354.                                         dat=keydata;
     
355.                                         dat=dat&0xf0;
     
356.                                         while(dat!=0xf0)
     
357.                                         {
     
358.                                                 dat=keydata;
     
359.                                         switch(dat)
     
360.                                                 {
     
361.                                                         case 0xe7:num=13;
     
362.                                                                 break;
     
363.                                                         case 0xd7:num=14;
     
364.                                                                 break;
     
365.                                                         case 0xb7:num=15;
     
366.                                                                 break;
     
367.                                                         case 0x77:num=16;
     
368.                                                                 break;
     
369.                                                 }
     
370.                                         while(dat!=0xf0)
     
371.                                                 {
     
372.                                                         dat=keydata;
     
373.                                                         dat=dat&0xf0;
     
374.                                                 }
     
375.                                                
     
376.                                         }
     
377.                                 }
     
378.                
     
379.                
     
380.       
     
381.                 switch(num)
     
382.                 {
     
383.                 case 1:        write_12864_addr(3,7);
     
384.                                 anjian=0;
     
385.                                 anjian_dis();
     
386.                                 break;
     
387.                 case 2:        write_12864_addr(3,7);
     
388.                                 anjian=10;
     
389.                                 anjian_dis();
     
390.                                 break;
     
391.                 case 3:write_12864_addr(3,7);
     
392.                                 anjian=20;
     
393.                                 anjian_dis();
     
394.                                 break;
     
395.                 case 4:write_12864_addr(3,7);
     
396.                                 anjian=30;
     
397.                                 anjian_dis();
     
398.                                 break;
     
399.                 case 5:write_12864_addr(3,7);
     
400.                                 anjian=40;
     
401.                                 anjian_dis();
     
402.                                 break;
     
403.                 case 6:write_12864_addr(3,7);
     
404.                                 anjian=50;
     
405.                                 anjian_dis();
     
406.                                 break;
     
407.                 case 7:write_12864_addr(3,7);
     
408.                                 anjian=60;
     
409.                                 anjian_dis();
     
410.                                 break;
     
411.                 case 8:write_12864_addr(3,7);
     
412.                                 anjian=anjian+1;
     
413.                                 anjian_dis();
     
414.                                 break;
     
415.                 case 9:        write_12864_addr(3,7);
     
416.                                 anjian=anjian+2;
     
417.                                 anjian_dis();
     
418.                                 break;
     
419.                 case 10:        write_12864_addr(3,7);
     
420.                                 anjian=anjian+3;
     
421.                                 anjian_dis();                              
     
422.                                 break;
     
423.                 case 11:write_12864_addr(3,7);                       
     
424.                                 anjian=anjian+4;
     
425.                                 anjian_dis();
     
426.                                 break;
     
427.                 case 12:write_12864_addr(3,7);                       
     
428.                                 anjian=anjian+5;
     
429.                                 anjian_dis();
     
430.                                 break;
     
431.                 case 13:write_12864_addr(3,7);                       
     
432.                                 anjian=anjian+6;
     
433.                                 anjian_dis();
     
434.                                 break;
     
435.                 case 14:write_12864_addr(3,7);                       
     
436.                                 anjian=anjian+7;
     
437.                                 anjian_dis();
     
438. 
     
439.                                 break;
     
440.                 case 15:write_12864_addr(3,7);
     
441.                                 anjian=anjian+8;
     
442.                                 anjian_dis();
     
443.                                 break;
     
444.                 case 16:write_12864_addr(3,7);
     
445.                                 anjian=anjian+9;
     
446.                                 anjian_dis();
     
447.                                 break;
     
448. 
     
449. 
     
450.         }
     
451.       
     
452. 
     
453. }
     
454. 
     
455. 
     
456. void timer1() interrupt 3
     
457. {
     
458.       
     
459. 
     
460.         TH1=(65535-1000)/256;
     
461.         TL1=(65535-1000)%256;
     
462.         count++;
     
463.         if(count=100)
     
464.         {
     
465.         count=0;
     
466.         }
     
467.         if(count<=pwm)
     
468.         {
     
469.                 ENA=1;
     
470.                 A1=0;
     
471.                 A2=1;
     
472.         }
     
473.         else
     
474.         {
     
475.                 ENA=0;
     
476.                 A1=0;
     
477.                 A2=1;
     
478.         }
     
479. 
     
480.                 TR1=1;
     
481. 
     
482. 
     
483. }

复制代码

---

作者: 石头儿    时间: 2017-11-19 00:19
顶 求解救

---

作者: wulin    时间: 2017-11-19 06:44
你写的这程序中既没有主程序main(),也没有初始化定时器，怎么能够跑得起来？

---

作者: 石头儿    时间: 2017-11-19 10:35

wulin 发表于 2017-11-19 06:44
你写的这程序中既没有主程序main(),也没有初始化定时器，怎么能够跑得起来？

这是子程序之一，这个子程序的pwm信号读不出来，你帮我看看，是不是switc好  case 函数有问题  谢谢啦

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1