标题: 怎样修改单片机程序可以调节led灯的亮起的时间或者可以调节小灯l亮度 [打印本页]

---

作者: stc89c52小白    时间: 2021-4-21 16:28
标题: 怎样修改单片机程序可以调节led灯的亮起的时间或者可以调节小灯l亮度
有大佬可以帮忙看一下

1. #include<reg52.h>
   
2. #include<intrins.h>
   
3. #define uint unsigned int
   
4. #define uchar  unsigned char
   
5. //°′?ü?¨
   
6. sbit k1=P1^0;                  
   
7. sbit k2=P1^1;                 
   
8. sbit k3=P1^2;                  
   
9. sbit k4=P1^3;                  
   
10. 
    
11. //oì
    
12. sbit IRIN=P3^2;               
    
13. sbit led=P3^7;                    
    
14. uchar IrValue[4];                  
    
15.    
    
16. uchar flag=0;                  
    
17. uchar mode=0;               
    
18. uchar light;                  
    
19. char k;                        
    
20. uint count;                       
    
21. uint time;                    
    
22. 
    
23. void init()                    
    
24. {
    
25.     EA=1;                    
    
26.     ET0=1;               
    
27.     TMOD=0x01;                /
    
28.     TR0=1;               
    
29.     EX0=1;               
    
30.     IT0=1;               
    
31.     TH0=(65536-50000)/256;            
    
32.     TL0=(65536-50000)%256;
    
33.     k=0;                    
    
34. }
    
35. 
    
36. void delay(uint z)            
    
37. {
    
38.     uint x,y;
    
39.     for(x=z;x>0;x--)
    
40.      for(y=13;y>0;y--);
    
41. }
    
42. 
    
43. void key1()
    
44. {
    
45.     if(k1==0)               
    
46.    
    
47.         delay(36);            
    
48.         if(k1==0)
    
49.         {
    
50.             if(mode==0)        
    
51.             {   
    
52.                 mode=1;
    
53.             }
    
54.             else
    
55.             {
    
56.                 mode=0;
    
57.             }
    
58.             if(flag==1)
    
59.             {
    
60.                 P2=0xff;
    
61.                 flag=0;
    
62.             }
    
63.             while(!k1);
    
64.         }                 
    
65.     }  
    
66. }
    
67. 
    
68. void key2()                    
    
69. {
    
70.     if(k2==0)               
    
71.     {               
    
72.         delay(36);         
    
73.         if(k2==0)
    
74.         {
    
75.             if(flag==0)        
    
76.             {
    
77.                 flag=1;
    
78.             }
    
79.             else
    
80.             {
    
81.                 flag=0;
    
82.                 k=9;
    
83.             }
    
84.             while(!k2);     
    
85.         }
    
86.     }
    
87. }
    
88. 
    
89. void key3()                    
    
90. {
    
91.     if(k3==0)           
    
92.     {                    
    
93.         delay(36);               
    
94.         if(k3==0)
    
95.         {
    
96.               TH0=(65536-50000)/256;     
    
97.             TL0=(65536-50000)%256;
    
98.             light=1;
    
99.             count=0;
    
100.             k++;
     
101.             if(k>8) k=8;
     
102.             while(!k3);   
     
103.         }
     
104.     }
     
105. }
     
106. void key4()
     
107. {
     
108.     if(k4==0)               
     
109.     {
     
110.         delay(36);            
     
111.         if(k4==0)
     
112.         {
     
113.             TH0=(65536-50000)/256;
     
114.             TL0=(65536-50000)%256;
     
115.             light=1;
     
116.             count=0;
     
117.             k--;
     
118.             if(k<0) k=0;
     
119.             while(!k4);
     
120.         }                 
     
121.     }
     
122. }
     
123. void  keyscan()                        
     
124. {     
     
125.     uint i,j;
     
126.         key2();
     
127.     if(k==9)
     
128.     {
     
129.         P2=0xff;
     
130.         k=0;
     
131.     }
     
132.     if(flag!=0)         
     
133.     {         
     
134.         key3();
     
135.           key4();
     
136.            switch(k)
     
137.            {
     
138.             case 0:{P2=0;break;}        
     
139.             case 1:{P2=0X55;break;}        
     
140.             case 2:{P2=0XAA;break;}        
     
141.             case 3:{P2=0X0F;break;}        
     
142.             case 4:{P2=0XF0;break;}        
     
143.             case 5:{               
     
144.                     if(light==1)   
     
145.                     {
     
146.                         P2=0xf0;
     
147.                     }
     
148.                     if(k!=5||mode!=0) break;
     
149.                     if(light==0)
     
150.                     {
     
151.                         P2=0x0f;
     
152.                     }
     
153.                         key2();
     
154.                     if(k==9)  
     
155.                     {
     
156.                         P2=0xff;
     
157.                         break;
     
158.                     }
     
159.                     if(k!=5||mode!=0) break;
     
160.                     break;
     
161.                     }
     
162.             case 6:{                        
     
163.                         P2=0XFE;
     
164.                         for(j=0;j<8;j++)        
     
165.                         {
     
166.                             for(i=0;i<5700;i++)
     
167.                             {
     
168.                                                          
     
169.                                 key1();
     
170.                                 key2();
     
171.                                 key3();
     
172.                                 key4();
     
173.                                 if(k!=6||mode!=0) break;
     
174.                             }                                
     
175.                             P2=_crol_(P2,1);
     
176.                         if(k!=6||mode!=0) break;
     
177.                         }
     
178.                         break;
     
179.                     }
     
180.             case 7:    {                    
     
181.                           if(light==1)
     
182.                         {   
     
183.                             P2=0x55;         
     
184.                         }
     
185.                         if(k!=7||mode!=0) break;
     
186.                         if(light==0)
     
187.                         {   
     
188.                             P2=0xaa;           
     
189.                         }
     
190.                         if(k!=7||mode!=0) break;
     
191.                         break;
     
192.                     }
     
193.             case 8:{                          
     
194.                          if(light==1)   
     
195.                         {
     
196.                             P2=0;            
     
197.                         }            
     
198.                         if(k!=8||mode!=0) break;
     
199.                         if(light==0)
     
200.                         {
     
201.                             P2=0xff;         
     
202.                         }
     
203.                         break;
     
204.                 }
     
205.             }
     
206.     }
     
207. }
     
208. 
     
209. void  Irkeyscan()               
     
210. {         
     
211.     uint i,j;
     
212.     if(k==9)
     
213.     {
     
214.         P2=0xff;
     
215.         k=0;
     
216.     }
     
217.     if(flag!=0)         
     
218.     {         
     
219.            switch(k)
     
220.            {
     
221.             case 0:{P2=0;break;}   
     
222.             case 1:{P2=0X55;break;}   
     
223.             case 2:{P2=0XAA;break;}   
     
224.             case 3:{P2=0X0F;break;}   
     
225.             case 4:{P2=0XF0;break;}   
     
226.             case 5:{               
     
227.                     if(light==1)   
     
228.                     {
     
229.                         P2=0xf0;
     
230.                     }
     
231.                     if(k!=5||mode!=1) break;
     
232.                     if(light==0)
     
233.                     {
     
234.                         P2=0x0f;
     
235.                     }
     
236.                     if(k==9)  
     
237.                     {
     
238.                         P2=0xff;
     
239.                         break;
     
240.                     }
     
241.                     if(k!=5||mode!=1)  break;
     
242.                     key1();
     
243.                     break;
     
244.                     }
     
245.             case 6:{   
     
246.                         P2=0Xfe;
     
247.                         for(j=0;j<8;j++)   
     
248.                         {
     
249.                             for(i=0;i<10000;i++)
     
250.                         {
     
251.                             key1();
     
252.                             if(k!=6||mode!=1)  break;
     
253.                         }
     
254.                             P2=_crol_(P2,1);
     
255.                         }
     
256.                         key1();
     
257.                         break;
     
258.                     }
     
259.             case 7:    {   
     
260.                           if(light==1)
     
261.                         {   
     
262.                             P2=0x55;     
     
263.                         }
     
264.                         if(k!=7||mode!=1)  break;
     
265.                         key1();
     
266.                         if(light==0)
     
267.                         {   
     
268.                             P2=0xaa;           
     
269.                         }
     
270.                         if(k!=7||mode!=1)  break;
     
271.                         break;
     
272.                     }
     
273.             case 8:{         
     
274.                          if(light==1)   
     
275.                         {
     
276.                             P2=0;     
     
277.                         }
     
278.                         key1();
     
279.                         if(k!=8||mode!=1)  break;
     
280.                         if(light==0)
     
281.                         {
     
282.                             P2=0xff;     
     
283.                         }
     
284.                         break;
     
285.                 }      
     
286.             }
     
287.     }   
     
288. }   
     
289. void main()
     
290. {
     
291.     init();
     
292.     while(1)
     
293.     {
     
294.         key1();
     
295.         if(mode==0)
     
296.         {   
     
297.             keyscan();
     
298.             led=1;
     
299.         }
     
300.         else
     
301.         {
     
302.             led=0;
     
303.             Irkeyscan();
     
304.         }
     
305. 
     
306.     }
     
307. }
     
308. void IrRead() interrupt 0        
     
309. {
     
310.     uchar a,b;   
     
311.     uint err;                           
     
312.     time=0;
     
313.     delay(70);
     
314. 
     
315.     if(IRIN==0)               
     
316.     {
     
317.         err=1000;
     
318.         while(IRIN==0&&err>0)   
     
319.         {
     
320.             delay(1);
     
321.             err--;
     
322.         }
     
323.         if(IRIN==1)              
     
324.         {
     
325.             err=500;
     
326.             while(IRIN==1&&err>0)   
     
327.             {
     
328.                 delay(1);
     
329.                 err--;
     
330.             }
     
331.             for(a=0;a<4;a++)        
     
332.             {
     
333.                 for(b=0;b<8;b++)   
     
334.                 {
     
335.                     err=60;
     
336.                     while(IRIN==0&&err>0)   
     
337.                     {
     
338.                         delay(1);
     
339.                         err--;
     
340.                     }
     
341.                     err=500;
     
342.                     while(IRIN==1&&err>0)   
     
343.                     {
     
344.                         delay(1);
     
345.                         time++;
     
346.                         err--;
     
347. 
     
348.                         if(time>30)
     
349.                         {
     
350.                             EX0=1;
     
351.                             return;
     
352.                         }
     
353.                     }
     
354.                     IrValue[a]>>=1;            
     
355.                     if(time>=8)               
     
356.                     {
     
357.                         IrValue[a]|=0x80;   
     
358.                     }
     
359.                     time=0;               
     
360.                 }   
     
361.             }
     
362.         }
     
363.         if(IrValue[2]!=~IrValue[3])
     
364.         {
     
365.             return;
     
366.         }
     
367.         if(IrValue[2]==0x0c)   
     
368.         {
     
369.             if(flag==0)
     
370.             {
     
371.                 flag=1;      
     
372.                 k=0;
     
373.             }
     
374.             else
     
375.             {
     
376.                 flag=0;      
     
377.                 P1=0xff;
     
378.                 k=9;
     
379.             }
     
380.         }
     
381.         if(IrValue[2]==0x18)     
     
382.         {
     
383.             k++;
     
384.             if(k>8)
     
385.                 k=8;
     
386.         }
     
387.         if(IrValue[2]==0x5E)        
     
388.         {
     
389.             k--;
     
390.             if(k<=0)
     
391.                 k=0;
     
392.         }   
     
393.     }
     
394. }
     
395. void Timer0() interrupt 1
     
396. {
     
397.          TH0=(65536-50000)/256;
     
398.          TL0=(65536-50000)%256;
     
399.          count++;
     
400.        if(count<10&&count>0)                    
     
401.        {
     
402.            light=1;
     
403.        }
     
404.        if(count>=10&&count<20)
     
405.        {
     
406.            light=0;
     
407.        }
     
408.        if(count==20)
     
409.        {
     
410.            count=0;
     
411.        }
     
412. }
     

复制代码

---

作者: 黄youhui    时间: 2021-4-21 17:59
亮起时间？你想要它什么时候亮都行，只要你的定时器不跑飞20小时后亮都行，改变亮度参照pwm

---

作者: stc89c52小白    时间: 2021-4-21 21:17

黄youhui 发表于 2021-4-21 17:59
亮起时间？你想要它什么时候亮都行，只要你的定时器不跑飞20小时后亮都行，改变亮度参照pwm

我实物已经好了，没有pwm，就是想着怎样不加元器件可以改变亮度或者流水灯的闪烁持续时间

---

作者: dasSpieler    时间: 2021-4-21 22:00
pwm不是硬件是软件，中文名脉宽调制，使用定时器很容易实现
闪烁时间也是定时器解决。如果硬件定时器资源不够可以自己写软件定时器。能达到效果就行。

---

作者: yygdzjs    时间: 2021-4-21 22:04
没有PWM,多用1个定时器，
例如: 数码管动态扫描1ms定时器 ，
加个10us定时器。1个变量标志位就可以.
1ms/10us=100 级亮度.

---

作者: ANT1987    时间: 2021-4-22 07:45
调整占空比就可以调整亮度 PWM=0 全灭 PWM=0.5 中等亮度 PWM=1 最亮

---

作者: u8899361    时间: 2021-4-22 15:35
用PWM加一个电容

---

作者: stc89c52小白    时间: 2021-4-25 15:26

yygdzjs 发表于 2021-4-21 22:04
没有PWM,多用1个定时器，
例如: 数码管动态扫描1ms定时器 ，
加个10us定时器。1个变量标志位就可以.

还需要加按键吗

---

作者: stc89c52小白    时间: 2021-4-25 15:42

yygdzjs 发表于 2021-4-21 22:04
没有PWM,多用1个定时器，
例如: 数码管动态扫描1ms定时器 ，
加个10us定时器。1个变量标志位就可以.

那如果再控制灯的闪烁时间是不是还要再添加两个定时器来控制，比如一个定时器让他亮一秒，另一个让他灭1.5秒这样的

---

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

Powered by Discuz! X3.1