标题: 用STC89C52制作的“锂电池容量检测器” [打印本页]

---

作者: ztzp    时间: 2025-7-6 12:03
标题: 用STC89C52制作的“锂电池容量检测器”


初步设想，使用STC89C52单片机控制，利用该单片机T2的16位自动装填初值功能，得到精确的1秒时钟，每隔1秒累计所放电量（Q=It），放电负载使用自制的2A电子负载仪，放电电流由负载仪设定（先以100mA为准），则每1秒所放的电量为：

每隔1秒就以上述公式计算电量进行累计。
放电电流的设定可以用跳线（或拨码开关）将某个I/O口的各位分别对地短路来实现。
在P1口外接5位拨码开关（也可以在PCB板上焊两排排针，用短路帽来短接），设置放电电流（图中电流为50mA）：

由于有5档开关，所以能够预置的放电电流种类为：

开关1~5分别设置电流强度为：50mA、100mA、200mA、400mA、800mA。
各档位组合设置的充电电流（以50mA递增）如下表：

当电池电压达到3V时终止放电，这个可以用继电器来控制负载仪，并接通蜂鸣器报警。
3V电压的检测可以用一个电压比较器（LM339）构成的“施密特触发器”来完成，基准电压源由一个TL431构成。
部分元件参数及封装：

电路原理：模拟部分（放电进行时）：

电路原理：模拟部分（放电停止）：

TL431分压原理：

其中R1是1、3脚间电阻；R2是1、2脚间电阻。
电路原理：数字部分：

单片机部分供电由78L05三端稳压器提供，实测单片机部分工作电流不大于20mA，所以78L05在不加散热片的情况下也能正常工作。

前面的电路（主要是模拟部分），由于电池有负载时的端电压小于空载时的电压，所以如果用继电器的开关控制电池放电的话，则在电池电压低于临界值时，继电器触点断开电池的瞬间，负载消失，导致电池电压又会高于临界值，这时继电器触点又会重新闭合，如此重复，继电器的触点就会不停的抖动，这个过程会长达几个小时不停，我第一个继电器就是这样损坏的。
所以在电路中取消了用继电器触点控制电池，在电路中只让触点控制单片机“中断”、蜂鸣器。
控制“中断”，在中断函数中停止累加器工作，LED显示最后的电量，这就是电池的容量；
控制蜂鸣器报警，提醒人，放电结束了。
在关闭电路以前，电池继续通过负载仪放电也无所谓，因为电池都有保护芯片，放到一定的时候它会自动断电的。

目前采用如下电路结构：
模拟部分：

数字部分：

电路最大的改变是放电截止时不再用继电器断开电池，以免造成继电器触点频繁抖动。
继电器采用双刀双掷，当放电截止时，一个触点控制单片机的INT0，使累计停止；另一个触点接通蜂鸣器，用声音提醒放电已经结束了。
用面包板搭建的测试电路：



电路调试成功后，用洞洞板焊接而成的最终作品：





工作状态：

这是自制的“2A负载仪”在放电过程中的工作状态：
开始放电时（100mA放电电流）：

放电结束时（100mA放电电流）：

经过对手中几片锂电池进行测量，数据如下：

---

作者: ztzp    时间: 2025-7-6 13:24

1. /**********************************************
   
2. * 功能：LED显示锂电池容量检测
   
3. * 编程：ztzp
   
4. * 日期：2020-04-14
   
5. * P0        段码控制
   
6. * P2        位码控制
   
7. * P1        5位拨码开关，决定放电电流。
   
8. **********************************************/
   
9. #include <reg52.h>
   
10. 
    
11. #define uchar unsigned char
    
12. #define uint unsigned int
    
13. #define ulong unsigned long
    
14. 
    
15. sfr T2MOD = 0xC9;        //使用定时器2必须定义，T2MOD的地址。
    
16. float Iout;                //放电电流，与预设值相关。
    
17. float Sum;                //放电量累加值
    
18. ulong S;                //放电量四舍五入后转换为整数
    
19. uchar S1;                //第一位
    
20. uchar S2;                //第二位
    
21. uchar S3;                //第三位
    
22. uint i;                        //1秒钟计时变量
    
23. uint State = 0;        //计数状态，0开始计数；1停止计数。此值由外部中断0控制。
    
24. 
    
25. sbit LED_R = P3^6;        //红色LED，表示正在放电，低电平有效。
    
26. sbit LED_G = P3^7;        //绿色LED，表示停止放电，低电平有效。
    
27. 
    
28. void init();                //系统初始化
    
29. void init_int0();        //外部中断初始化
    
30. void init_Time2();        //定时器2初始化
    
31. void Show();                //LED数码管显示放电量
    
32. 
    
33. //共阳LED数码管位码（从左到右：1、2、3、4、5、6、7、8）
    
34. //用PNP管驱动
    
35. code uchar WEI_CODE [] =
    
36. {
    
37.         0xFE,                //1          11111110
    
38.         0xFD,                //2          11111101
    
39.         0xFB,                //3          11111011
    
40.         0xF7,                //4          11110111
    
41.         0xEF,                //5          11101111
    
42.         0xDF,                //6          11011111
    
43.         0xBF,                //7          10111111
    
44.         0x7F                //8   01111111
    
45. };
    
46. 
    
47. //共阳LED数码管段码（带小数点）
    
48. code uchar DSY_CODE [] =
    
49. {
    
50.         0x40,                //0
    
51.         0x79,                //1
    
52.         0x24,                //2
    
53.         0x30,                //3
    
54.         0x19,                //4
    
55.         0x12,                //5
    
56.         0x02,                //6
    
57.         0x78,                //7
    
58.         0x00,                //8
    
59.         0x10                //9
    
60. };
    
61. 
    
62. // 延时 xms（晶振：11.0592MHz，）
    
63. void DelayMS(uint x)
    
64. {
    
65.         uchar i;
    
66.         while( x-- )
    
67.         {
    
68.                 for( i=0; i<111; i++ );
    
69.         }
    
70. }
    
71. 
    
72. //主程序
    
73. void main()
    
74. {
    
75.         init();                        //系统初始化
    
76.         init_int0();        //外部中断初始化
    
77.         init_Time2();        //定时器2初始化
    
78.         while(1)
    
79.         {
    
80.                 Show();                //显示
    
81.         }
    
82. }
    
83. 
    
84. //LED数码管显示放电量（从左到右）
    
85. void Show()
    
86. {
    
87.         //第1位
    
88.         S = Sum + 0.5;        //四舍五入
    
89.         S1 = S/10000000;
    
90.         if (S1 != 0)
    
91.         {
    
92.                 P2 = WEI_CODE[0];
    
93.                 P0 = DSY_CODE[S1] + 0x80;        //无小数点
    
94.                 DelayMS(1);
    
95.                 P2 = 0xFF;
    
96.                 P0 = 0xFF;
    
97.                 DelayMS(1);
    
98.         }
    
99. 
    
100.         //第2位
     
101.         S = Sum + 0.5;
     
102.         S2 = S%10000000/1000000;
     
103.         if (S2 != 0 || S1 != 0)                //当第一位不等于0时，第二位必须显示
     
104.         {
     
105.                 P2 = WEI_CODE[1];
     
106.                 P0 = DSY_CODE[S2] + 0x80;
     
107.                 DelayMS(1);
     
108.                 P2 = 0xFF;
     
109.                 P0 = 0xFF;
     
110.                 DelayMS(1);
     
111.         }
     
112. 
     
113.         //第3位
     
114.         S = Sum + 0.5;
     
115.         S3 = S%1000000/100000;
     
116.         if (S3 != 0 || S2 != 0 || S1 != 0)                //当第二位（或者第一位）不等于0时，第三位必须显示。
     
117.         {
     
118.                 P2 = WEI_CODE[2];
     
119.                 P0 = DSY_CODE[S3] + 0x80;
     
120.                 DelayMS(1);
     
121.                 P2 = 0xFF;
     
122.                 P0 = 0xFF;
     
123.                 DelayMS(1);
     
124.         }
     
125. 
     
126.         //第4位（个位）
     
127.         S = Sum + 0.5;
     
128.         S = S%100000/10000;
     
129.         P2 = WEI_CODE[3];
     
130.         P0 = DSY_CODE[S];        //有小数点
     
131.         DelayMS(1);
     
132.         P2 = 0xFF;
     
133.         P0 = 0xFF;
     
134.         DelayMS(1);
     
135. 
     
136.         //第5位
     
137.         S = Sum + 0.5;
     
138.         S = S%10000/1000;
     
139.         P2 = WEI_CODE[4];
     
140.         P0 = DSY_CODE[S]+0x80;
     
141.         DelayMS(1);
     
142.         P2 = 0xFF;
     
143.         P0 = 0xFF;
     
144.         DelayMS(1);
     
145. 
     
146.         //第6位
     
147.         S = Sum + 0.5;
     
148.         S = S % 1000 /100;
     
149.         P2 = WEI_CODE[5];
     
150.         P0 = DSY_CODE[S]+0x80;
     
151.         DelayMS(1);
     
152.         P2 = 0xFF;
     
153.         P0 = 0xFF;
     
154.         DelayMS(1);
     
155. 
     
156.         //第7位
     
157.         S = Sum + 0.5;
     
158.         S = S % 100/10;
     
159.         P2 = WEI_CODE[6];
     
160.         P0 = DSY_CODE[S]+0x80;
     
161.         DelayMS(1);
     
162.         P2 = 0xFF;
     
163.         P0 = 0xFF;
     
164.         DelayMS(1);
     
165. 
     
166.         //第8位
     
167.         S = Sum + 0.5;
     
168.         S = S % 10;
     
169.         P2 = WEI_CODE[7];
     
170.         P0 = DSY_CODE[S]+0x80;
     
171.         DelayMS(1);
     
172.         P2 = 0xFF;
     
173.         P0 = 0xFF;
     
174.         DelayMS(1);
     
175. }
     
176. 
     
177. //系统初始化
     
178. //根据读入P1的拨码开关状态值，决定放电电流。
     
179. void init()
     
180. {
     
181.         LED_R = 0;        //红灯亮
     
182.         LED_G = 1;        //绿灯灭
     
183. 
     
184.         switch( P1 )
     
185.         {
     
186.                 case 0XFE:        //50mA
     
187.                         Iout = 500.0/3.6;
     
188.                         break;
     
189.                 case 0XFD:        //100mA
     
190.                         Iout = 1000.0/3.6;
     
191.                         break;
     
192.                 case 0XFC:        //150mA
     
193.                         Iout = 1.5*1000.0/3.6;
     
194.                         break;
     
195.                 case 0XFB:        //200mA
     
196.                         Iout = 2.0*1000.0/3.6;
     
197.                         break;
     
198.                 case 0XFA:        //250mA
     
199.                         Iout = 2.5*1000.0/3.6;
     
200.                         break;
     
201.                 case 0XF9:        //300mA
     
202.                         Iout = 3.0*1000.0/3.6;
     
203.                         break;
     
204.                 case 0XF8:        //350mA
     
205.                         Iout = 3.5*1000.0/3.6;
     
206.                         break;
     
207.                 case 0XF7:        //400mA
     
208.                         Iout = 4.0*1000.0/3.6;
     
209.                         break;
     
210.                 case 0XF6:        //450mA
     
211.                         Iout = 4.5*1000.0/3.6;
     
212.                         break;
     
213.                 case 0XF5:        //500mA
     
214.                         Iout = 5.0*1000.0/3.6;
     
215.                         break;
     
216.                 case 0XF4:        //550mA
     
217.                         Iout = 5.5*1000.0/3.6;
     
218.                         break;
     
219.                 case 0XF3:        //600mA
     
220.                         Iout = 6.0*1000.0/3.6;
     
221.                         break;
     
222.                 case 0XF2:        //650mA
     
223.                         Iout = 6.5*1000.0/3.6;
     
224.                         break;
     
225.                 case 0XF1:        //700mA
     
226.                         Iout = 7.0*1000.0/3.6;
     
227.                         break;
     
228.                 case 0XF0:        //750mA
     
229.                         Iout = 7.5*1000.0/3.6;
     
230.                         break;
     
231.                 case 0XEF:        //800mA
     
232.                         Iout = 8.0*1000.0/3.6;
     
233.                         break;
     
234.                 case 0XEE:        //850mA
     
235.                         Iout = 8.5*1000.0/3.6;
     
236.                         break;
     
237.                 case 0XED:        //900mA
     
238.                         Iout = 9.0*1000.0/3.6;
     
239.                         break;
     
240.                 case 0XEC:        //950mA
     
241.                         Iout = 9.5*1000.0/3.6;
     
242.                         break;
     
243.                 case 0XEB:        //1000mA
     
244.                         Iout = 10.0*1000.0/3.6;
     
245.                         break;
     
246.                 case 0XEA:        //1050mA
     
247.                         Iout = 10.5*1000.0/3.6;
     
248.                         break;
     
249.                 case 0XE9:        //1100mA
     
250.                         Iout = 11.0*1000.0/3.6;
     
251.                         break;
     
252.                 case 0XE8:        //1150mA
     
253.                         Iout = 11.5*1000.0/3.6;
     
254.                         break;
     
255.                 case 0XE7:        //1200mA
     
256.                         Iout = 12.0*1000.0/3.6;
     
257.                         break;
     
258.                 case 0XE6:        //1250mA
     
259.                         Iout = 12.5*1000.0/3.6;
     
260.                         break;
     
261.                 case 0XE5:        //1300mA
     
262.                         Iout = 13.0*1000.0/3.6;
     
263.                         break;
     
264.                 case 0XE4:        //1350mA
     
265.                         Iout = 13.5*1000.0/3.6;
     
266.                         break;
     
267.                 case 0XE3:        //1400mA
     
268.                         Iout = 14.0*1000.0/3.6;
     
269.                         break;
     
270.                 case 0XE2:        //1450mA
     
271.                         Iout = 14.5*1000.0/3.6;
     
272.                         break;
     
273.                 case 0XE1:        //1500mA
     
274.                         Iout = 15.0*1000.0/3.6;
     
275.                         break;
     
276.                 case 0XE0:        //1550mA
     
277.                         Iout = 15.5*1000.0/3.6;
     
278.                         break;
     
279.         }
     
280. }
     
281. 
     
282. //外部中断初始化
     
283. void init_int0()
     
284. {
     
285.         PX0 = 1;        //设置外部中断0为最高优先级
     
286.         IT0 = 1;        //1：设置下降沿触发方式；0：低电平触发方式
     
287.         EA = 1;                //开总中断
     
288.         EX0 = 1;        //开外部中断0
     
289. }
     
290. 
     
291. //定时器2初始化
     
292. void init_Time2()
     
293. {
     
294.         T2MOD = 0;
     
295.         T2CON = 0;
     
296.         RCAP2H = (65536 - 50000)/256;                //12M晶振，50ms产生一次中断
     
297.         RCAP2L = (65536 - 50000)%256;
     
298.         ET2 = 1;        //允许T2中断
     
299.         TR2 = 1;        //启动T2中断
     
300. }
     
301. 
     
302. //外部中断0，用于停止放电计数。
     
303. void Int0() interrupt 0
     
304. {
     
305.         LED_R = 1;        //红灯灭
     
306.         LED_G = 0;        //绿灯亮
     
307.         State = 1;        //停止放电计数
     
308. //        EX0 = 0;        //停止外部中断
     
309. }
     
310. 
     
311. //定时器2中断服务程序
     
312. void Time2() interrupt 5
     
313. {
     
314.         TF2 = 0;        //定时器2必须由软件对溢出标志位清零！
     
315.         if (i > 20 && State == 0)        //每1秒累加一次放电量
     
316.         {
     
317.                 Sum += Iout;                //以100mA放电，1秒钟的放电量。
     
318.                 i = 0;
     
319.         }
     
320.         i++;
     
321. }

复制代码

---

作者: 太阳雨ZW    时间: 2025-7-6 15:09
请问拨码开关是如何通过单片机控制放电电流的？

---

作者: ztzp    时间: 2025-7-6 16:14

太阳雨ZW 发表于 2025-7-6 15:09
请问拨码开关是如何通过单片机控制放电电流的？

初始化函数：
void init()

---

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

Powered by Discuz! X3.1