标题: 基于51单片机的稳压直流电源程序 [打印本页]

---

作者: fiarybu    时间: 2018-6-22 16:11
标题: 基于51单片机的稳压直流电源程序
•它利用单片机STC89C51作为主控芯片。将家用电压经过稳压电路后，输入AD芯片，单片机控制数字/模拟转换器（PCF8591）的输出电压的大小，从而输出恒定可调电压。最后通过电位器分压将输出信号反馈到运算放大器（LM358）上，使输出电压达到标准,并且还可以进行过压过流检测，防止电压过高产生事故。此设计通过键盘电路与单片机连接,读入控制数据,利用软件进行判断,从而起到控制电源输出的作用。通过LCD1602显示数控电源的输出电压

单片机源程序如下:

1. #include <reg52.h>
   
2. #include <intrins.h>
   
3. #define PCF8591_ADDR        0x90                //PCF8591地址
   
4. #define DACOUT_EN                0x40                //DAC输出使能
   
5. #define uchar unsigned char
   
6. #define uint unsigned int
   
7. int a,b,c,t,s,w=0;
   
8. uint AD_Value;        //存储AD转换回的数字量
   
9. void delay(uint z)
   
10. {
    
11.         uint x,y;
    
12.         for(x=z;x>0;x--)
    
13.                 for(y=110;y>0;y--);
    
14. }
    
15. void delay_5us()
    
16. {
    
17.         _nop_();
    
18. }
    
19. void keyscan();
    
20. sbit SDA = P2^0;   //I2C串行数据
    
21. sbit SCL = P2^1;   //I2C串行时钟
    
22. sbit dula  = P2^6;
    
23. sbit wela  = P2^7;   
    
24. sbit lcdrs=P3^7;
    
25. sbit rw=P3^6;
    
26. sbit lcden=P3^5;
    
27. void write_com(uchar com)
    
28. {
    
29.         lcdrs=0;
    
30.         P0=com;
    
31.         delay(5);
    
32.         lcden=1;
    
33.         delay(5);
    
34.         lcden=0;
    
35. }
    
36. void write_date(uchar date)
    
37. {
    
38.         lcdrs=1;
    
39.         P0=date;
    
40.         delay(5);
    
41.         lcden=1;
    
42.         delay(5);
    
43.         lcden=0;
    
44. }
    
45. void init()
    
46. {
    
47.         rw=0;
    
48.         dula=0;
    
49.         wela=0;
    
50.         lcden=0;
    
51.         write_com(0x38);
    
52.         write_com(0x0c);
    
53.         write_com(0x06);
    
54.         write_com(0x01);
    
55. }
    
56. 
    
57. /*I2C总线初始化*/
    
58. void I2C_init()
    
59. {
    
60.         SDA = 1;   //数据总线高
    
61.         _nop_();
    
62.         SCL = 1;   //时钟总线高
    
63.         _nop_();
    
64. }
    
65. 
    
66. /*I2C起始信号*/
    
67. void I2C_Start()  
    
68. {
    
69.         SCL = 1;
    
70.         _nop_();
    
71.         SDA = 1;
    
72.         delay_5us();
    
73.         SDA = 0;
    
74.         delay_5us();
    
75. }
    
76. 
    
77. /*I2C停止信号*/
    
78. void I2C_Stop()
    
79. {
    
80.         SDA = 0;
    
81.         _nop_();
    
82.         SCL = 1;
    
83.         delay_5us();
    
84.         SDA = 1;
    
85.         delay_5us();
    
86. }
    
87. 
    
88. /*I2C主机发送应答
    
89. i为0时发送非应答 为1时发送应答*/
    
90. void Master_ACK(bit i)       
    
91. {
    
92.         SCL = 0; // 拉低时钟总线允许SDA数据总线上的数据变化
    
93.         _nop_(); // 让总线稳定
    
94.         if (i)         //如果i = 1 那么拉低数据总线 表示主机应答
    
95.         {
    
96.                 SDA = 0;
    
97.         }
    
98.         else         
    
99.         {
    
100.                 SDA = 1;         //发送非应答
     
101.         }
     
102.         _nop_();//让总线稳定
     
103.         SCL = 1;//拉高时钟总线 让从机从SDA线上读走 主机的应答信号
     
104.         _nop_();
     
105.         SCL = 0;//拉低时钟总线， 占用总线继续通信
     
106.         _nop_();
     
107.         SDA = 1;//释放SDA数据总线。
     
108.         _nop_();
     
109. }
     
110. 
     
111. /*I2C检测从机应答
     
112. 0为非应答 1为应答*/
     
113. bit Test_ACK()         // 检测从机应答
     
114. {
     
115.         SCL = 1;//时钟总线为高电平期间可以读取从机应答信号
     
116.         delay_5us();
     
117.         if (SDA)
     
118.         {
     
119.                 SCL = 0;
     
120.                 I2C_Stop();
     
121.                 return(0);
     
122.         }
     
123.         else
     
124.         {
     
125.                 SCL = 0;
     
126.                 return(1);
     
127.         }
     
128. }
     
129. 
     
130. /*I2C发送一个字节
     
131.   byte 要发送的字节*/
     
132. void I2C_send_byte(uchar byte)
     
133. {
     
134.         uchar i;
     
135.         for(i = 0 ; i < 8 ; i++)
     
136.         {
     
137.                 SCL = 0;
     
138.                 _nop_();
     
139.                 if (byte & 0x80)       
     
140.                 {
     
141.                         SDA = 1;
     
142.                         _nop_();
     
143.                 }
     
144.                 else
     
145.                 {
     
146.                         SDA = 0;
     
147.                         _nop_();
     
148.                 }
     
149.                 SCL = 1;
     
150.                 _nop_();
     
151.                 byte <<= 1;
     
152.         }
     
153.         SCL = 0;
     
154.         _nop_();
     
155.         SDA = 1;
     
156.         _nop_();       
     
157. }
     
158. 
     
159. /*I2C读一个字节
     
160. 读取的字节*/
     
161. uchar I2C_read_byte()
     
162. {
     
163.         uchar i, dat;
     
164.         SCL = 0 ;
     
165.         _nop_();
     
166.         SDA = 1;
     
167.         _nop_();
     
168.         for(i = 0 ; i < 8 ; i++)
     
169.         {
     
170.                 SCL = 1;
     
171.                 _nop_();
     
172.                 dat <<= 1;          
     
173.                 if (SDA)
     
174.                 {
     
175.                         dat |= 0x01;  
     
176.                 }
     
177.                 _nop_();
     
178.                 SCL = 0;
     
179.                 _nop_();
     
180.         }
     
181.         return(dat);
     
182. }
     
183. 
     
184. /*DAC输出*/
     
185. 
     
186. bit DAC_OUT(uchar DAT)
     
187. {
     
188.         I2C_Start();
     
189.         I2C_send_byte(PCF8591_ADDR+0);
     
190.         if (!Test_ACK())
     
191.         {
     
192.                 return(0);
     
193.         }
     
194.         I2C_send_byte(DACOUT_EN);        //DA输出使能
     
195.         if (!Test_ACK())
     
196.         {
     
197.                 return(0);
     
198.         }
     
199.         I2C_send_byte(DAT);
     
200.         if (!Test_ACK())
     
201.         {
     
202.                 return(0);
     
203.         }
     
204.         I2C_Stop();
     
205.         return(1);       
     
206. }                               
     
207. 
     
208. /*读AD数据*/
     
209. bit ADC_Read(uchar CON)
     
210. {
     
211.         I2C_Start();
     
212.         I2C_send_byte(PCF8591_ADDR+0);
     
213.         if (!Test_ACK())
     
214.         {
     
215.                 return(0);
     
216.         }
     
217.         I2C_send_byte(CON);
     
218.         Master_ACK(0);
     
219.         I2C_Start();
     
220.         I2C_send_byte(PCF8591_ADDR+1);
     
221.         if (!Test_ACK())
     
222.         {
     
223.                 return(0);
     
224.         }
     
225.         AD_Value = I2C_read_byte();
     
226.         Master_ACK(0);
     
227.         I2C_Stop();
     
228.         return(1);       
     
229. }
     
230. 
     
231. void main()
     
232. {
     
233.         init();
     
234.         I2C_init();
     
235.         while(1)
     
236.         {               
     
237.                 ADC_Read(0x43);//外部       
     
238.                 keyscan();
     
239.                 DAC_OUT((double)s/3*5.12);               
     
240.         }
     
241.                
     
242. }
     
243. void keyscan()
     
244. {
     
245.         P1=0xfe;
     
246.         t=P1;
     
247.         t=t&0xf0;
     
248.         while(t!=0xf0)
     
249.         {
     
250.                 delay(5);
     
251.                 t=P1;
     
252.                 t=t&0xf0;
     
253.                 while(t!=0xf0)
     
254.                 {
     
255.                         t=P1;
     
256.                         switch(t)
     
257.                         {
     
258.                                 case 0xee:a=0,w=0;break;
     
259.                                 case 0xde:a=1,w=0;break;
     
260.                                  case 0xbe:a=2,w=0;break;
     
261.                                 case 0x7e:a=3,w=0;break;
     
262. 
     
263.                         }
     
264.                         while(t!=0xf0)
     
265.                         {
     
266.                                 t=P1;
     
267.                                 t=t&0xf0;
     
268.                         }               
     
269.                 }
     
270.         }
     
271. 
     
272.         P1=0xfd;
     
273.         t=P1;
     
274.         t=t&0xf0;
     
275.         while(t!=0xf0)
     
276.         {
     
277.                 delay(5);
     
278.                 t=P1;
     
279.                 t=t&0xf0;
     
280.                 while(t!=0xf0)
     
281.                 {
     
282.                         t=P1;
     
283.                         switch(t)
     
284.                         {
     
285.                                 case 0xed:a=4,w=0;break;
     
286.                                 case 0xdd:a=5,w=0;break;
     
287.                                  case 0xbd:a=6,w=0;break;
     
288.                                 case 0x7d:a=7,w=0;break;
     
289. 
     
290.                         }
     
291.                         while(t!=0xf0)
     
292.                         {
     
293.                                 t=P1;
     
294.                                 t=t&0xf0;
     
295.                         }               
     
296.                 }
     
297.         }
     
298.         P1=0xfb;
     
299.         t=P1;
     
300.         t=t&0xf0;
     
301.         while(t!=0xf0)
     
302.         {
     
303.                 delay(5);
     
304.                 t=P1;
     
305.                 t=t&0xf0;
     
306.                 while(t!=0xf0)
     
307.                 {
     
308.                         t=P1;
     
309.                         switch(t)
     
310.                         {
     
311.                                 case 0xeb:a=8,w=0;break;
     
312.                                 case 0xdb:a=9,w=0;break;
     
313.                                  case 0xbb:b=a*10,w=0;break;
     
314.                                 case 0x7b:c=a,w=0;break;
     
315. 
     
316.                         }
     
317.                         while(t!=0xf0)
     
318.                         {
     
319.                                 t=P1;
     
320.                                 t=t&0xf0;
     
321.                         }               
     
322.                 }
     
323.         }
     
324.         P1=0xf7;
     
325.         t=P1;
     
326.         t=t&0xf0;
     
327.         while(t!=0xf0)
     
328.         {
     
329.                 delay(5);
     
330.                 t=P1;
     
331.                 t=t&0xf0;
     
332.                 while(t!=0xf0)
     
333.                 {
     
334.                         t=P1;
     
335.                         switch(t)
     
336.                         {
     
337.                                 case 0xe7:s=s+1,w=1;break;
     
338.                                 case 0xd7:s=s-1,w=2;break;
     
339.                         }
     
340.                         while(t!=0xf0)
     
341.                         {
     
342.                                 t=P1;
     
343.                                 t=t&0xf0;
     
344.                         }       
     
345.                 }
     
346.         }
     
347.         if(w==0)
     
348.         {
     
349.                 s=b+c;
     
350.                 write_com(0x80);
     
351.                 write_date('D');
     
352.                 write_date('C');
     
353.                 write_date(':');
     
354.                 write_date(s/10+0x30);
     
355.                 write_date('.');
     
356.                 write_date(s%10+0x30);
     
357.                 write_date(0+0x30);
     
358.                 write_date('V');
     
359.         }
     
360.         if(w==1)
     
361.         {
     
362.                 if(s>99)
     
363.                 {
     
364.                         s=0;
     
365.                 }
     
366.                 write_com(0x80);
     
367.                 write_date('D');
     
368.                 write_date('C');
     
369.                 write_date(':');
     
370.                 write_date(s/10+0x30);
     
371.                 write_date('.');
     
372.                 write_date(s%10+0x30);
     
373.                 write_date(0+0x30);
     
374.                 write_date('V');
     
375.         }
     
376.         if(w==2)
     
377.         {
     
378.                 if(s<0)
     
379.                 {
     
380.                         s=99;
     
381.                 }
     
382.                 write_com(0x80);
     
383.                 write_date('D');
     
384.                 write_date('C');
     
385.                 write_date(':');
     
386.                 write_date(s/10+0x30);
     
387.                 write_date('.');
     
388.                 write_date(s%10+0x30);
     
389.                 write_date(0+0x30);
     
390.                 write_date('V');       
     
391.         }                       
     
392. }
     
393. 
     

复制代码

所有资料51hei提供下载:
终极电源程序.rar (34.42 KB, 下载次数: 28)

2018-6-22 16:11 上传

点击文件名下载附件
稳压电源的控制程序
下载积分: 黑币 -5

---

作者: laoyan    时间: 2019-6-25 21:51
学习一下

---

作者: 光一    时间: 2020-2-28 15:24
有没有电路连接图可以分享一下？

---

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

Powered by Discuz! X3.1