设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › 自制18650电池容量检测器
返回列表 发新帖
查看: 15569|回复: 6
打印 上一主题 下一主题
收起左侧

自制18650电池容量检测器

  [复制链接]
跳转到指定楼层
楼主
ID:161768 发表于 2017-5-24 03:06 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
本文原作者为：wosiyabo 版权归作者所有
根据电池容量的mAh，可以计算电池的持续放电时间的电流数去确定电池的容量。以下用了一个STC12C5608AD去做检测电池放电400mA的时间，再以公式400mA*时间=mAh

（注意，有保护板的测不到因为低于2.86V会断电）


     
谁也没想到德力普的2500mAh的电池竟然实测只有1860mAh........ 原理图忘记加12MHz晶振了。。。请各位后期制作加上去吧。。单片机定时器1内用PWM输出控制在~400mA以内，电压降低时PWM提升幅度。已经调得很准了，不过温漂会有少少误差。
(刚开始时用电阻做负载，后来发现电压降到3.3V左右时电流变成300几毫安，后来才改成PWM模式保持电流在2.83V都可以400mA)

单片机源程序：
  1. #include "reg51.h"
  2. //#include
  3. #include "intrins.h"
  4. #define uchar unsigned char
  5. #define uint unsigned int
  6. #define ulong unsigned long
  7. #define ADC_POWER   0x80            //ADC电源控制位
  8. #define ADC_FLAG    0x10            //ADC完成标志
  9. #define ADC_START   0x08            //ADC起始控制位
  10. #define ADC_SPEEDLL 0x00            //540个时钟
  11. #define ADC_SPEEDL  0x20            //360个时钟
  12. #define ADC_SPEEDH  0x40            //180个时钟
  13. #define ADC_SPEEDHH 0x60            //90个时钟

  15. sfr CCON        =   0xD8;           //PCA control register
  16. sbit CCF0       =   CCON^0;         //PCA module-0 interrupt flag
  17. sbit CCF1       =   CCON^1;         //PCA module-1 interrupt flag
  18. sbit CR         =   CCON^6;         //PCA timer run control bit
  19. sbit CF         =   CCON^7;         //PCA timer overflow flag
  20. sfr CMOD        =   0xD9;           //PCA mode register
  21. sfr CL          =   0xE9;           //PCA base timer LOW
  22. sfr CH          =   0xF9;           //PCA base timer HIGH
  23. sfr CCAPM0      =   0xDA;           //PCA module-0 mode register
  24. sfr CCAP0L      =   0xEA;           //PCA module-0 capture register LOW
  25. sfr CCAP0H      =   0xFA;           //PCA module-0 capture register HIGH
  26. sfr PCAPWM0     =   0xF2;



  30. sfr AUXR        =   0x8e;               //辅助寄存器
  31. sfr P1ASF       =   0x9D;           //P1口第2功能控制寄存器
  32. sfr ADC_RES     =   0xBD;           //ADC高8位结果
  33. sfr ADC_CONTR  = 0xc5;
  34. sfr ADC_DATA   = 0xc6;
  35. sfr ADC_LOW2   = 0xbe;

  37. sfr P0M0  = 0x93;
  38. sfr P0M1  = 0x94;
  39. sfr P1M0  = 0x91;
  40. sfr P1M1  = 0x92;
  41. sfr P2M0  = 0x95;
  42. sfr P2M1  = 0x96;
  43. sfr P3M0  = 0xb1;
  44. sfr P3M1  = 0xb2;  

  46. typedef unsigned char BYTE;

  48. uchar code table[]="0123456789BatTime:V.mAh_";
  49. uchar time1,time2,time3,pwm1;
  50. uint fen=0,ad1=138,ad0;

  52. sbit P12 = P1^2;
  53. sbit P13 = P1^3;
  54. sbit LED = P3^2;  //背光脚H亮
  55. sbit  rs = P3^3;  //
  56. sbit POW = P3^7;  //PWM
  57. sbit  en = P3^5;  //
  58. sbit SPK = P3^4;  //蜂鸣器

  60. void InitADC();
  61. uint GetADCResult(BYTE ch);
  62. void Delayus(uint us);
  63. void Delayms(unsigned int ms);
  64. void write_com(uchar com);
  65. void write_dat(uchar dat);
  66. void init();
  67. void Timer0Init(void);

  69. /*----------------------------
  70. 读取ADC结果
  71. ----------------------------*/
  72. uint GetADCResult(BYTE ch)
  73. {
  74.     ADC_CONTR = ADC_POWER | ADC_SPEEDLL | ch | ADC_START;
  75.     _nop_();                        //等待4个NOP
  76.     _nop_();
  77.     _nop_();
  78.     _nop_();
  79.     while (!(ADC_CONTR & ADC_FLAG));//等待ADC转换完成
  80.     ADC_CONTR &= ~ADC_FLAG;         //Close ADC
  81.         return (ADC_DATA*4+ADC_LOW2);        //adc_data*4的意思是左移两位，4 = 2的2次方。
  82.                                     //然后左移后加上adc_low的值，这个值应该是adc转换的低两位。  

  84. //        ADC_CONTR = ADC_POWER | ADC_SPEEDLL | ch | ADC_START;
  85.    // _nop_();                        //Must wait before inquiry
  86.    // _nop_();
  87.   // _nop_();
  88.    // _nop_();
  89.    // while (!(ADC_CONTR & ADC_FLAG));//Wait complete flag
  90.    // ADC_CONTR &= ~ADC_FLAG;         //Close ADC
  91.     //return ADC_DATA;                //Return ADC result         */

  93. }

  95. /*----------------------------
  96. 初始化ADC
  97. ----------------------------*/
  98. void InitADC()
  99. {
  100.     P1 = P1M0 = P1M1 = 0x03;        //Set all P1 as Open-Drain mode
  101.         ADC_RES = 0;
  102.     ADC_DATA = 0;                   //Clear previous result
  103.         ADC_LOW2 = 0;
  104.     ADC_CONTR = ADC_POWER | ADC_SPEEDLL;
  105.     Delayms(2);                       //ADC上电并延时
  106. }

  108. void Delayus(uint us)                //@12.000MHz
  109. {
  110.    while(--us)
  111.    {
  112.                 _nop_();
  113.                 _nop_();
  114.                 _nop_();
  115.                 _nop_();
  116.    }
  117. }
  118. void Delayms(unsigned int ms)                //@12.000MHz
  119. {
  120.         unsigned char i, j;
  121.         while(--ms)
  122.         {
  123.                 i = 12;
  124.                 j = 169;
  125.                 do
  126.                 {
  127.                         while (--j);
  128.                 } while (--i);
  129.         }
  130. }
  131. void write_com(uchar com)
  132. {
  133.         rs=0;
  134.         en=0;
  135.         P2=com;
  136.         Delayms(2);
  137.         en=1;
  138.         Delayms(2);
  139.         en=0;
  140. }
  141. void write_dat(uchar dat)
  142. {
  143.         rs=1;
  144.         en=0;
  145.         P2=dat;
  146.         Delayms(2);
  147.         en=1;
  148.         Delayms(2);
  149.         en=0;
  150. }
  151. void init()
  152. {
  153.         Delayms(15);
  154.         write_com(0x38); //写指令38H（不检测忙信号）
  155.         Delayms(5);
  156.         write_com(0x38); //写指令38H（不检测忙信号）
  157.         Delayms(5);
  158.         write_com(0x38); //写指令38H（不检测忙信号）
  159.         write_com(0x08); //写指令08H：显示关闭
  160.         write_com(0x01); //写指令01H：显示清屏
  161.       
  162.         write_com(0x06); //写指令06H：显示光标移动设置
  163.         write_com(0x0C); //写指令0CH：显示开及光标设置
  164. }

  166. void Timer0Init(void)                //2毫秒@12.000MHz
  167. {
  168.         AUXR &= 0x7F;                //定时器时钟12T模式
  169.         TMOD &= 0xF0;                //设置定时器模式
  170.         TMOD |= 0x01;                //设置定时器模式
  171.         TL0 = 0x30;                //设置定时初值
  172.         TH0 = 0xF8;                //设置定时初值
  173.         TF0 = 0;                //清除TF0标志
  174.         TR0 = 0;                //定时器0开始计时
  175. }


  178. void Timer1Init(void)                //5毫秒@12.000MHz
  179. {
  180.         AUXR &= 0xBF;                //定时器时钟12T模式
  181.         TMOD &= 0x0F;                //设置定时器模式
  182.         TMOD |= 0x10;                //设置定时器模式
  183.         TL1 = 0x78;                //设置定时初值
  184.         TH1 = 0xEC;                //设置定时初值
  185.         TF1 = 0;                //清除TF1标志
  186.         TR1 = 1;                //定时器1开始计时
  187. }


  190. void main()
  191. {      
  192.    bit q1=0,q2=0,q3=0;
  193.         uchar k1;
  194.         ulong ww=1667;
  195.         P0M0 = P0M1 = 0x00;
  196.         //P1M0 = 0x00;
  197.         //P1M1 = 0x00;
  198.         P2M0 = P2M1 = 0x00;
  199.         P3M1 = 0x94;
  200.         P3M0 = 0x00;
  201.         POW=0;
  202.         LED=1;
  203.         SPK=0;
  204.         init();
  205.         InitADC();
  206.         Timer0Init();
  207.         Timer1Init();
  208.         TR0 = 1;                        //timer0 start running
  209.     ET0 = 1;                        //enable timer0 interrupt
  210.     //TR1 = 1;                        //timer1 start running
  211.     //ET1 = 1;                        //enable timer1 interrupt
  212.     EA = 1;                         //open global interrupt switch
  213.                   
  214.         for(k1=255;k1>0;k1--)
  215.            {
  216.                    SPK=~SPK;
  217.                 Delayus(k1);
  218.            }   
  219.            SPK=0;

  221.           write_com(0x80); //80为上排第一个
  222.           write_dat(table[10]);
  223.           write_dat(table[11]);
  224.           write_dat(table[12]);
  225.           write_dat(table[12]);
  226.           write_dat(table[17]);
  227.           write_com(0xC0); //C0为下排第一个
  228.           write_dat(table[13]);
  229.           write_dat(table[14]);
  230.           write_dat(table[15]);
  231.           write_dat(table[16]);
  232.           write_dat(table[17]);
  233.           write_com(0xC0+6);
  234.           write_dat(table[0]);
  235.           write_dat(table[0]);
  236.           write_dat(table[17]);
  237.           write_dat(table[0]);
  238.           write_dat(table[0]);
  239.           write_dat(table[17]);
  240.           write_dat(table[0]);
  241.           write_dat(table[0]);
  242.         while(1)
  243.         {


  246.           while(1)
  247.           {

  249.            if(EA==1)
  250.               {
  251.                         write_com(0xC0+13);
  252.                         write_dat(table[time1%10/1]);
  253.                         write_com(0xC0+12);
  254.                         write_dat(table[time1%100/10]);
  255.                         write_com(0xC0+10);
  256.                         write_dat(table[time2%10/1]);
  257.                         write_com(0xC0+9);
  258.                         write_dat(table[time2%100/10]);
  259.                         write_com(0xC0+7);
  260.                         write_dat(table[time3%10/1]);
  261.                         write_com(0xC0+6);
  262.                         write_dat(table[time3%100/10]);
  263.               }


  266.          
  267.          
  268.           if(q1==0&time1==2)
  269.              {
  270.                         write_com(0x85);
  271.                         write_dat(table[ad0%1000/100]);
  272.                         write_com(0x86);
  273.                         write_dat(table[19]);
  274.                         write_com(0x87);
  275.                         write_dat(table[ad0%100/10]);
  276.                         write_com(0x88);
  277.                         write_dat(table[ad0%10/1]);
  278.                         write_com(0x89);
  279.                         write_dat(table[18]);
  280.                         q1=1;                              

  282.                                    for(k1=0;k1<255;k1++)
  283.                            {
  284.                                    SPK=~SPK;
  285.                                 Delayus(150);
  286.                            }
  287.                                 Delayms(100);
  288.                                    for(k1=0;k1<255;k1++)
  289.                            {
  290.                                    SPK=~SPK;
  291.                                 Delayus(150);
  292.                            }
  293.                             SPK=0;
  294.                                 CCON = 0;                       //Initial PCA control register
  295.                                                                 //PCA timer stop running
  296.                                                                 //Clear CF flag
  297.                                                                 //Clear all module interrupt flag
  298.                                 CL = 0;                         //Reset PCA base timer
  299.                                 CH = 0;
  300.                                 CMOD = 0x02;                    //Set PCA timer clock source as Fosc/2
  301.                                                                 //Disable PCA timer overflow interrupt
  302.                                 CCAP0H = CCAP0L = 0xFF;         //PWM0 port output 50% duty cycle square wave
  303.                                 CCAPM0 = 0x42;                  //PCA module-0 work in 8-bit PWM mode and no PCA interrupt
  304.                               
  305.                                 CR = 1;                         //PCA timer start run
  306.                             TR0 = 1;
  307.                                 ET1 = 1;
  308.                }      

  310.                         write_com(0x8B);
  311.                         write_dat(table[ad0%1000/100]);
  312.                         write_com(0x8C);
  313.                         write_dat(table[19]);
  314.                         write_com(0x8D);
  315.                         write_dat(table[ad0%100/10]);
  316.                         write_com(0x8E);
  317.                         write_dat(table[ad0%10/1]);
  318.                         write_com(0x8F);
  319.                         write_dat(table[18]);

  321.           if(fen>=1)LED=0;
  322.           if(ad0<=286)q3=1;
  323.            while(q3==1)
  324.            {
  325.                         for(k1=0;k1<100;k1++)
  326.                            {
  327.                                    SPK=~SPK;
  328.                                 Delayus(110);
  329.                            }
  330.                                 SPK=0;                        
  331.                                 LED=~LED;
  332.                                 CCAP0H = CCAP0L = 0xFF;
  333.                                 POW=0;
  334.                                 EA=0;
  335.                                 Delayms(500);
  336.                         ad0=GetADCResult(0);
  337.                         write_com(0x8B);
  338.                         write_dat(table[ad0%1000/100]);
  339.                         write_com(0x8C);
  340.                         write_dat(table[19]);
  341.                         write_com(0x8D);
  342.                         write_dat(table[ad0%100/10]);
  343.                         write_com(0x8E);
  344.                         write_dat(table[ad0%10/1]);
  345.                         write_com(0x8F);
  346.                         write_dat(table[18]);
  347.                  if(!q2)
  348.                  {      
  349.                    ww*=fen;
  350.                    ww*=4;
  351.                     write_com(0xC0+0);
  352.                         write_dat(table[23]);
  353.                         write_com(0xC0+1);
  354.                         write_dat(table[23]);
  355.                     write_com(0xC0+2);
  356.                         write_dat(table[23]);
  357.                     write_com(0xC0+3);
  358.                         write_dat(table[23]);
  359.                     write_com(0xC0+4);
  360.                         write_dat(table[23]);
  361.                     write_com(0xC0+5);
  362.                         write_dat(table[23]);
  363.                         write_com(0xC0+6);
  364.                         write_dat(table[23]);
  365.                         write_com(0xC0+7);
  366.                         write_dat(table[ww%100000000/10000000]);
  367.                         write_com(0xC0+8);
  368.                         write_dat(table[ww%10000000/1000000]);
  369.                         write_com(0xC0+9);
  370.                         write_dat(table[ww%1000000/100000]);
  371.                         write_com(0xC0+10);
  372.                         write_dat(table[ww%100000/10000]);
  373.                         write_com(0xC0+11);
  374.                         write_dat(table[ww%10000/1000]);
  375.                         write_com(0xC0+12);
  376.                         write_dat(table[20]);
  377.                         write_com(0xC0+13);
  378.                         write_dat(table[21]);
  379.                         write_com(0xC0+14);
  380.                         write_dat(table[22]);
  381.                         Delayms(1000);
  382.                 q2=1;
  383.                  }
  384.            }

  386.                  
  387.           }

  389.         }  
  390. }
  391. void tm0_isr() interrupt 1 using 1
  392. {
  393.   static uchar i1,i2;
  394.         TL0 = 0x30;                //设置定时初值
  395.         TH0 = 0xF8;                //设置定时初值
  396.         i1++;
  397.         if(i1>=50)
  398.         {
  399.           i1=0;
  400.           i2++;
  401.           if(i2>=10)
  402.                   {
  403.                    i2=0;
  404.                    time1++;
  405.                   if(time1>=60)
  406.                          {
  407.                            time1=0;
  408.                            time2++;
  409.                            fen++;
  410.                           if(time2>=60)
  411.                                   {
  412.                                     time2=0;
  413.                                         time3++;
  414.                                         if(time3>=24)time3=0;
  415.                                   }
  416.                           }
  417.                           }
  418.         }
  419.    ad0=GetADCResult(0);      
  420. }

  422. void tm1_isr() interrupt 3 using 1
  423. {
  424.         TL1 = 0x78;                //设置定时初值
  425.         TH1 = 0xEC;                //设置定时初值
  426.         if(ad0>=428)CCAP0H = CCAP0L = 142;
  427.         if(ad0<=427&&ad0>424)CCAP0H = CCAP0L = 142;
  428.         if(ad0<=424&&ad0>420)CCAP0H = CCAP0L = 141;
  429.         if(ad0<=420&&ad0>416)CCAP0H = CCAP0L = 140;
  430.         if(ad0<=416&&ad0>412)CCAP0H = CCAP0L = 139;
  431.         if(ad0<=412&&ad0>408)CCAP0H = CCAP0L = 138;
  432.         if(ad0<=408&&ad0>404)CCAP0H = CCAP0L = 137;
  433.         if(ad0<=404&&ad0>400)CCAP0H = CCAP0L = 136;
  434.         if(ad0<=400&&ad0>396)CCAP0H = CCAP0L = 135;
  435.         if(ad0<=396&&ad0>392)CCAP0H = CCAP0L = 134;
  436.         if(ad0<=392&&ad0>388)CCAP0H = CCAP0L = 132;//
  437.         if(ad0<=388&&ad0>384)CCAP0H = CCAP0L = 131;
  438.         if(ad0<=384&&ad0>380)CCAP0H = CCAP0L = 129;
  439.         if(ad0<=380&&ad0>376)CCAP0H = CCAP0L = 128;
  440.         if(ad0<=376&&ad0>372)CCAP0H = CCAP0L = 127;
  441.         if(ad0<=372&&ad0>368)CCAP0H = CCAP0L = 126;//
  442.         if(ad0<=368&&ad0>364)CCAP0H = CCAP0L = 125;
  443.         if(ad0<=364&&ad0>360)CCAP0H = CCAP0L = 123;
  444.         if(ad0<=360&&ad0>356)CCAP0H = CCAP0L = 122;
  445.         if(ad0<=356&&ad0>352)CCAP0H = CCAP0L = 120;
  446.         if(ad0<=352&&ad0>348)CCAP0H = CCAP0L = 119;
  447.         if(ad0<=348&&ad0>344)CCAP0H = CCAP0L = 117;
  448.         if(ad0<=344&&ad0>340)CCAP0H = CCAP0L = 116;
  449.         if(ad0<=340&&ad0>336)CCAP0H = CCAP0L = 114;
  450.         if(ad0<=336&&ad0>332)CCAP0H = CCAP0L = 113;
  451.         if(ad0<=332&&ad0>328)CCAP0H = CCAP0L = 111;
  452.         if(ad0<=328&&ad0>324)CCAP0H = CCAP0L = 109;
  453.         if(ad0<=324&&ad0>320)CCAP0H = CCAP0L = 108;
  454.         if(ad0<=320&&ad0>316)CCAP0H = CCAP0L = 106;
  455.         if(ad0<=316&&ad0>312)CCAP0H = CCAP0L = 105;
  456.         if(ad0<=312&&ad0>308)CCAP0H = CCAP0L = 103;
  457.         if(ad0<=304&&ad0>300)CCAP0H = CCAP0L = 100;
  458.         if(ad0<=300&&ad0>296)CCAP0H = CCAP0L = 98;
  459.         if(ad0<=296&&ad0>292)CCAP0H = CCAP0L = 97;
  460.         if(ad0<=292&&ad0>288)CCAP0H = CCAP0L = 94;
  461.         if(ad0<=288&&ad0>284)CCAP0H = CCAP0L = 91;
  462.         if(ad0<=284)CCAP0H = CCAP0L = 0xFF;
  463.       
  464.         //CCAPM0 = 0x42;
  465. }
复制代码
本文原作者为：wosiyabo 版权归作者所有
电池容量, 检测器
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏10 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:204108 发表于 2017-5-24 06:36 | 只看该作者
楼主大神，我想自己动手焊接一个，能将所需的电子原件和加完晶振的电路图告诉我吗，不胜感激！！！
回复

使用道具 举报

板凳
ID:191195 发表于 2017-5-24 07:00 来自手机 | 只看该作者
好资料呀，支持一下。
回复

使用道具 举报

地板
ID:140980 发表于 2017-5-27 08:18 | 只看该作者
没有电流检测电路,怎么保证电流的准确.
回复

使用道具 举报

5#
ID:67537 发表于 2018-12-30 22:31 | 只看该作者
如果是一次性的锂电池，有什么办法测量容量
回复

使用道具 举报

6#
ID:358930 发表于 2018-12-31 09:45 来自手机 | 只看该作者
yyhhgg 发表于 2018-12-30 22:31
如果是一次性的锂电池，有什么办法测量容量

好像是算内阻值的，电动车不是有那种短路一样的容量表吗？你去修车那看看就知道了
回复

使用道具 举报

7#
ID:412684 发表于 2019-3-20 17:55 | 只看该作者
czvsgd 发表于 2017-5-24 06:36
**** 作者被禁止或删除 内容自动屏蔽 ****

很给力
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表