电池容量测试仪电路与源码(PIC16F1938单片机+AD623实现)

分享一个由PIC16F1938单片机芯片和AD623构成的电池容量测试仪.

电路原理图如下：




电池容量测试仪的pic单片机源码：

1. #include    "main.h"
   
2. //------------------------32MHZ----------------------------------------------
   
3. __CONFIG(FOSC_INTOSC & CLKOUTEN_OFF & BOREN_ON & PWRTE_ON & CPD_OFF
   
4.           &CP_ON & MCLRE_ON & LVP_OFF & WDTE_ON );  //此处有关32MHz的设置与1829不同，PLL使能位必须在寄存器OSCCON里面设置SPLLEN
   
5.                                                                         //而不是在配置字里面设置PLLEN_ON      
   
6. /***eeprom 数据存储地址分配**************
   
7. 
   
8. 0X00 0X01 充电电流
   
9. 0X02 0X03 充电截止电压
   
10. 0X04 0X05 放电电流
    
11. 0X06 0X07 放电截止电压
    
12. 0X08      循环次数
    
13. 
    
14. 0X09      充满多久后放电
    
15. 0X0A      已循环次数
    
16. 0X0B 0X0C 充电时间
    
17. 0X0D 0X0E 放电时间
    
18. 0X0F 0X10 总容量
    
19. 
    
20. 0xf0 掉电前的状态：0放电/1充电
    
21. ******************************************/  
    
22.          
    
23. //---------非精确延时1ms函数------------
    
24. void delay_ms(uint16_t  time)
    
25. {
    
26.   uint16_t k, j=0;
    
27.   for(k=0;k<189;k++)
    
28.   {
    
29.     for(;j<time;j++)
    
30.      {CLRWDT();}
    
31.   }  
    
32. }         
    
33. //--------端口及时钟初始化--------------
    
34. void Init(void)
    
35. {
    
36. asm("CLRWDT");
    
37. PORTA=0X00;
    
38. LATA=0X00;
    
39. TRISA=0B00000111;
    
40. ANSELA=0B00000111;//RA0 RA1 RA2作为模拟输入，其余为数字输出
    
41. 
    
42. PORTB=0X00;
    
43. LATB=0X00;
    
44. TRISB=0B00111100;
    
45. ANSELB=0B00000000;
    
46. 
    
47. PORTC=0X00;
    
48. TRISC=0B00000000;
    
49. LATC=0X00;
    
50. 
    
51. screen_status=4;
    
52. i=0;
    
53. j=0;
    
54. FLAG_RUN=0;
    
55. }
    
56. 
    
57. //-------------串口初始化------------------
    
58. void Init_Uart(void)
    
59. {
    
60. TRISC6=0;
    
61. //TRISC7=1;
    
62. SPBRG=0xcf;
    
63. BRG16=1;
    
64. BRGH=0;
    
65. 
    
66. TX9=0;
    
67. SYNC=0;
    
68. SPEN=1;
    
69. TXEN=1;
    
70. 
    
71. TXIF=0;
    
72. TXIE=0;
    
73. CREN=1;
    
74. SYNC=0;
    
75. 
    
76. RCIF=0;
    
77. RCIE=0;
    
78. 
    
79. GIE=1;
    
80. PEIE=1;
    
81. 
    
82. }
    
83. 
    
84. void putch(unsigned char byte)
    
85. {
    
86.         /* output one byte */
    
87.         //CLRWDT();
    
88.         while(!TXIF)        /* set when register is empty */
    
89.                 continue;
    
90.         TXREG = byte;
    
91. }
    
92. 
    
93. void Set32MHZ(void)
    
94. {
    
95.   SCS1=0;        //配置字中若已经设置了FOSC<2:0>  那么在此必须将SCS<1:0>=00
    
96.   SCS0=0;
    
97.   IRCF3=1;      //16MHZ分频后得到8MHZ再4倍频到32MHZ
    
98.   IRCF2=1;
    
99.   IRCF1=1;
    
100.   IRCF0=0;
     
101.   OSTS=0;
     
102.   PLLR=1;
     
103.   HFIOFS=1;
     
104.   SPLLEN=1;//必须在此处设置此位，否则系统时钟频率不为8MHz  
     
105. }
     
106. 
     
107. void interrupt isr(void)               
     
108. {
     
109. //-----------TMER0中断--------------------        
     
110. if((TMR0IF)&&(TMR0IE))           
     
111. {
     
112.   TMR0=0x07;                    
     
113.   TMR0IF=0; //0.25ms  
     
114. }
     
115. //-----------TMER1中断-------------------
     
116. if((TMR1IF)&&(TMR1IE))//定时50ms           
     
117. {
     
118.   TMR1H=0x3C;            
     
119.   TMR1L=0xB5;                    
     
120.   TMR1IF=0;
     
121.   second--;
     
122.   if(second==0)
     
123.   {
     
124.           second=20;
     
125.     FLAG_SECOND=1;
     
126.   }
     
127. 
     
128.   if(second==10||second==20)
     
129.   {
     
130.    flag_work=1;
     
131.   }
     
132.   if(WORKING&&loop_temp<loop_times)
     
133.   {
     
134.         
     
135.           if(second==20)
     
136.             {LATB7=1;}
     
137.           else if(FLAG_RUN)
     
138.           {
     
139.             if(second==10)
     
140.                   {LATB7=1;}
     
141.       else if(!FLAG_CHARGE&&(second==5||second==15))
     
142.                   {LATB7=1;}
     
143.             else
     
144.                     {LATB7=0;}
     
145.           }
     
146.     else
     
147.       {LATB7=0;}
     
148.   }
     
149.   /*if(++count1>99)
     
150.   {
     
151.         
     
152.           count1=0;
     
153.           printf("%d \r\n",bat_voltage);
     
154.   }*/
     
155. }
     
156. //--------------------TMER4中断-----------
     
157. if((TMR4IF)&&(TMR4IE))   
     
158. {
     
159.   TMR4=0x57;                    
     
160.   TMR4IF=0; //0.5ms
     
161. }
     
162. if((TMR6IF)&&(TMR6IE))         
     
163. {
     
164.   TMR6=0x6F;//1ms进入中断一次
     
165.   TMR6IF=0;
     
166.     if((FLAG_RUN)&&(screen_status==0)&&(loop_temp<loop_times))
     
167.     {
     
168.      if(++keydelay1>1000)
     
169.      {
     
170.           keydelay1=0;
     
171.           m++;
     
172.           if(m>3)
     
173.       {
     
174.            m=0;
     
175.        lcd_write_char(12,0,' ');
     
176.        lcd_write_char(13,0,' ');
     
177.        lcd_write_char(14,0,' ');
     
178.       }
     
179.       else
     
180.       {lcd_write_char(11+m,0,'.');}
     
181.       lcd_write_char(15,0,' ');
     
182.      }
     
183.     }
     
184.    
     
185.   if(KEYDOWNING)
     
186.    {
     
187.     if(++keydelay>10)
     
188.     {
     
189.          keydelay=0;
     
190.      KEYDOWNING=0;
     
191.     }
     
192.    }
     
193.   
     
194. }
     
195. }
     
196. //-----------判断按键状态-------------------------
     
197. unsigned char getkey(void)
     
198. {        
     
199.         unsigned char keytemp;
     
200.         keytemp=LATB;//不能用keytemp=PORTB;
     
201.         return (~keytemp) & 0X3C;        
     
202. }
     
203. //------------按键初始化-----------------
     
204. void Keyinit(void)
     
205. {
     
206.      KEY_MAIN.KEY_BIT.ReadData_ON_OFF=(ON_OFF^1);
     
207.      KEY_MAIN.KEY_BIT.ReadData_DEC=(DEC^1);
     
208.      KEY_MAIN.KEY_BIT.ReadData_ADD=(ADD^1);
     
209.      KEY_MAIN.KEY_BIT.ReadData_MENU=(MENU^1);
     
210.      KEY_MAIN.KEY_BIT.TRG_ON_OFF=KEY_MAIN.KEY_BIT.ReadData_ON_OFF & (KEY_MAIN.KEY_BIT.ReadData_ON_OFF ^ KEY_MAIN.KEY_BIT.COUT_ON_OFF);
     
211.      KEY_MAIN.KEY_BIT.TRG_DEC=KEY_MAIN.KEY_BIT.ReadData_DEC & (KEY_MAIN.KEY_BIT.ReadData_DEC ^ KEY_MAIN.KEY_BIT.COUT_DEC);
     
212.      KEY_MAIN.KEY_BIT.TRG_ADD=KEY_MAIN.KEY_BIT.ReadData_ADD & (KEY_MAIN.KEY_BIT.ReadData_ADD ^ KEY_MAIN.KEY_BIT.COUT_ADD);
     
213.      KEY_MAIN.KEY_BIT.TRG_MENU=KEY_MAIN.KEY_BIT.ReadData_MENU & (KEY_MAIN.KEY_BIT.ReadData_MENU ^ KEY_MAIN.KEY_BIT.COUT_MENU);
     
214.      KEY_MAIN.KEY_BIT.COUT_ON_OFF=KEY_MAIN.KEY_BIT.ReadData_ON_OFF;
     
215.      KEY_MAIN.KEY_BIT.COUT_DEC=KEY_MAIN.KEY_BIT.ReadData_DEC;
     
216.      KEY_MAIN.KEY_BIT.COUT_ADD=KEY_MAIN.KEY_BIT.ReadData_ADD;   
     
217.      KEY_MAIN.KEY_BIT.COUT_MENU=KEY_MAIN.KEY_BIT.ReadData_MENU;
     
218.       
     
219. }
     
220. //-------按键扫描-------------------------
     
221. unsigned char  KeyScan(void)
     
222. {
     
223. Keyinit();
     
224. if(KEY_MAIN.KEY_ALL_BITS==0X0007)  //ON/OFF
     
225. {
     
226.   return 1;
     
227. }
     
228. else if(KEY_MAIN.KEY_ALL_BITS==0X0038)  //DEC
     
229. {
     
230.   return 2;
     
231. }
     
232. else if(KEY_MAIN.KEY_ALL_BITS==0X01C0)  //ADD
     
233. {
     
234.   return 3;
     
235. }
     
236. else if(KEY_MAIN.KEY_ALL_BITS==0X0E00)  //MENU
     
237. {
     
238.   return 4;
     
239. }
     
240. return 0;
     
241. }
     
242. void KeyProcess(void)
     
243. {
     
244. if(getkey())//判断有按键按下
     
245.   {
     
246.    if(!KEYDOWNING)
     
247.           {
     
248.             KEYDOWNING = 1;
     
249.             keyvalue=KeyScan();//提取具体按键值
     
250.           }
     
251.   }
     
252. else
     
253.   {
     
254.           KEYDOWNING = 0;
     
255.   }
     
256. if(keyvalue)   
     
257.   {
     
258.    if(STARTUP)        
     
259.            count=60;
     
260.    if(keyvalue==1) //ON_OFF
     
261.     {
     
262.      switch(screen_status)
     
263.      {
     
264.       case 0:     screen_status=2;
     
265.                   i=0;
     
266.                   read_data();
     
267.                   menu_2(); break;
     
268.       case 1:    if(i==0)
     
269.                  {
     
270.                   FLAG_RUN=1;
     
271.                   WORKING=1;
     
272.                   finish_discharge=0;
     
273.                   finish_charge=0;
     
274.                   screen_status=0;
     
275.                   i=0;
     
276.                   lcd_write_com_busy(0x01);
     
277.                   menu_0(); break;
     
278.                  }
     
279.                  else if(i==1)
     
280.                  {
     
281.                   screen_status=3;
     
282.                   i=0;
     
283.                   read_data();
     
284.                   menu_3(); break;
     
285.                  }
     
286.                  else if(i==2)
     
287.                  {
     
288.                   read_data();
     
289.                   screen_status=5;
     
290.                   i=0;
     
291.                   menu_5(); break;
     
292.                  }
     
293.       case 2:    if(i==0)
     
294.                  {
     
295.                   FLAG_RUN=0;
     
296.                   WORKING=0;
     
297.                   LATB7=0;
     
298.                   PWM_WIDE=0;
     
299.                   PWM_Size(PWM_WIDE);
     
300.                   PWM5_Size(PWM_WIDE);
     
301.                   screen_status=1;
     
302.                   i=0;
     
303.                   menu_1(); break;
     
304.                  }
     
305.                  else if(i==8)
     
306.                  {
     
307.                    for(k=16;k<36;k++)
     
308.                      {cap_data[k-16]=eeprom_read(k);}
     
309.                    screen_temp=screen_status;
     
310.                    screen_status=7;
     
311.                    i=0;
     
312.                    menu_7();break;
     
313.                  }
     
314.                  else
     
315.                  {
     
316.                    screen_status=2;
     
317.                    menu_2(); break;
     
318.                  }
     
319.       case 3:    if(i==0)
     
320.                  {
     
321.                   for(k=10;k<36;k++)
     
322.                     {eeprom_write(k,0);}
     
323.                   read_data();
     
324.                   screen_status=1;
     
325.                   i=0;
     
326.                   menu_1(); break;
     
327.                  }
     
328.                  else if(i==8)
     
329.                  {
     
330.                    for(k=16;k<36;k++)
     
331.                      {cap_data[k-16]=eeprom_read(k);}
     
332.                    screen_temp=screen_status;
     
333.                    screen_status=7;
     
334.                    i=0;
     
335.                    menu_7();break;
     
336.                  }
     
337.                  else
     
338.                  {
     
339.                   screen_status=3;
     
340.                   menu_3(); break;
     
341.                  }
     
342.       case 4:    if(i==0)
     
343.                  {
     
344.                   screen_status=0;
     
345.                   i=0;
     
346.                   lcd_write_com_busy(0x01);
     
347.                   menu_0();
     
348.                   STARTUP=0;
     
349.                   WORKING=1;
     
350.                   FLAG_RUN=1;break;
     
351.                  }
     
352.                  else
     
353.                  {
     
354.                   screen_status=1;
     
355.                   i=0;
     
356.                   menu_1();
     
357.                   STARTUP=0;
     
358.                   FLAG_RUN=0; break;
     
359.                  }  
     
360.       case 5:    screen_status=6;
     
361.                  i=0;
     
362.                  menu_6(); break;
     
363.       case 6:    if(i==0)//需要保存设置的数据
     
364.                  {
     
365.                    for(k=0;k<10;k++)
     
366.                      {eeprom_write(k,datatab[k]);}
     
367.                                    read_data();//此处读取各个参数数值
     
368.                                    screen_status=1;
     
369.                    i=0;
     
370.                    menu_1(); break;
     
371.                  }
     
372.                  else//不保存，则采用之前的数据
     
373.                  {
     
374.                    screen_status=1;
     
375.                    i=0;
     
376.                    menu_1(); break;
     
377.                  }
     
378.        default: break;  
     
379.       }
     
380.     }
     
381.    else if(keyvalue==2)//ADD
     
382.     {
     
383.      if((screen_status==5)&&(!FLAG_RUN))
     
384.      {
     
385.         switch(i)
     
386.         {
     
387.          case 0: temp=(datatab[0]<<8)|datatab[1];
     
388.                  temp+=10;//此处增加限制电流增加的上限
     
389.                  if(temp>2000)
     
390.                          {temp=10;}
     
391.                  datatab[1]=(unsigned char)temp;
     
392.                  datatab[0]=(temp>>8)&0xff;
     
393.                                  break;
     
394.          case 1: temp=(datatab[2]<<8)|datatab[3];
     
395.                  temp+=50;//此处增加限制电压增加的上限
     
396.                  if(temp>4500)
     
397.                          {temp=3500;}
     
398.                  datatab[2]=(temp>>8)&0xff;
     
399.                  datatab[3]=temp&0xff;break;
     
400.          case 2: temp=(datatab[4]<<8)|datatab[5];
     
401.                  temp+=10;//此处增加限制电流增加的上限
     
402.                  if(temp>3000)
     
403.                          {temp=10;}
     
404.                  datatab[4]=(temp>>8)&0xff;
     
405.                  datatab[5]=temp&0xff;break;
     
406.          case 3: temp=(datatab[6]<<8)|datatab[7];
     
407.                  temp+=50;//此处增加限制电流增加的上限
     
408.                  if(temp>4000)
     
409.                          {temp=2500;}
     
410.                  datatab[6]=(temp>>8)&0xff;
     
411.                  datatab[7]=temp&0xff;break;   
     
412.          case 4: temp=datatab[8];
     
413.                  temp++;//此处增加限制电流增加的上限
     
414.                  if(temp>50)
     
415.                          {temp=1;}
     
416.                  datatab[8]=temp;break;
     
417.          case 5: temp=datatab[9];
     
418.                  temp+=5;//此处增加限制电流增加的上限
     
419.                  if(temp>30)
     
420.                          {temp=0;}
     
421.                  datatab[9]=temp;break;                    
     
422.         }
     
423.        menu_5();   
     
424.      }
     
425.      else if(screen_status==2)
     
426.      {
     
427.        i++;
     
428.        if(i>(menu2_num-1))
     
429.        {i=0;}
     
430.        menu_2();         
     
431.      }
     
432.      else if((screen_status==1)&&(!FLAG_RUN))
     
433.      {
     
434.              i++;
     
435.         if(i>(menu1_num-1))
     
436.         {i=0;}
     
437.         menu_1();
     
438.      }
     
439.      else if((screen_status==3)&&(!FLAG_RUN))
     
440.      {
     
441.              i++;
     
442.         if(i>(menu3_num-1))
     
443.         {i=0;}
     
444.         menu_3();
     
445.      }
     
446.      else if(screen_status==7)
     
447.      {
     
448.              i++;
     
449.              if(i>9)
     
450.                {i=0;}
     
451.              menu_7();
     
452.      }
     
453.     }
     
454.    else if(keyvalue==3)//DEC
     
455.     {
     
456.      if((screen_status==5)&&(!FLAG_RUN))
     
457.      {
     
458.       switch(i)
     
459.         {
     
460.          case 0: temp=(datatab[0]<<8)|datatab[1];
     
461.                  temp-=10;//此处增加限制电流增加的上限
     
462.                  if(temp==0)
     
463.                          {temp=2000;}
     
464.                  datatab[1]=(unsigned char)temp;
     
465.                  datatab[0]=(temp>>8)&0xff;
     
466.                                  break;
     
467.          case 1: temp=(datatab[2]<<8)|datatab[3];
     
468.                  temp-=50;//此处增加限制电压增加的上限
     
469.                  if(temp<3500)
     
470.                          {temp=4500;}
     
471.                  datatab[2]=(temp>>8)&0xff;
     
472.                  datatab[3]=temp&0xff;break;
     
473.          case 2: temp=(datatab[4]<<8)|datatab[5];
     
474.                  temp-=10;//此处增加限制电流增加的上限
     
475.                  if(temp>3000)
     
476.                          {temp=3000;}
     
477.                  datatab[4]=(temp>>8)&0xff;
     
478.                  datatab[5]=temp&0xff;break;
     
479.          case 3: temp=(datatab[6]<<8)|datatab[7];
     
480.                  temp-=50;//此处增加限制电流增加的上限
     
481.                  if(temp<2500)
     
482.                          {temp=4000;}
     
483.                  datatab[6]=(temp>>8)&0xff;
     
484.                  datatab[7]=temp&0xff;break;   
     
485.          case 4: temp=datatab[8];
     
486.                  temp--;//此处增加限制电流增加的上限
     
487.                  if(temp==0)
     
488.                          {temp=50;}
     
489.                  datatab[8]=temp;break;
     
490.          case 5: temp=datatab[9];
     
491.                  temp-=5;//此处增加限制电流增加的上限
     
492.                  if(temp>30)
     
493.                          {temp=30;}
     
494.                  datatab[9]=temp;break;                    
     
495.         }
     
496.        menu_5();  
     
497.      }
     
498.      else if(screen_status==2)
     
499.      {
     
500.        i--;
     
501.        if(i>(menu2_num-1))
     
502.        {i=menu2_num-1;}
     
503.        menu_2();         
     
504.      }
     
505.      else if((screen_status==1)&&(!FLAG_RUN))
     
506.      {
     
507.              i--;
     
508.         if(i>(menu1_num-1))
     
509.         {i=menu1_num-1;}
     
510.         menu_1();
     
511.      }
     
512.      else if((screen_status==3)&&(!FLAG_RUN))
     
513.      {
     
514.              i--;
     
515.         if(i>(menu3_num-1))
     
516.         {i=menu3_num-1;}
     
517.         menu_3();
     
518.      }
     
519.      else if(screen_status==7)
     
520.      {
     
521.              i--;
     
522.              if(i>9)
     
523.                {i=9;}
     
524.              menu_7();
     
525.      }
     
526.     }
     
527.    else if(keyvalue==4)//MENU  选择项目 菜单循环显示
     
528.     {
     
529.      switch(screen_status)
     
530.      {
     
531.       
     
532.       case 2:    screen_status=0;
     
533.                  i=0;
     
534.                  lcd_write_com_busy(0x01);
     
535.                  menu_0(); break;
     
536.       case 3:    screen_status=1;
     
537.                  i=0;
     
538.                  menu_1(); break;
     
539.       case 4:    i++;
     
540.                  if(i>(menu4_num-1))
     
541.                  {i=0;}
     
542.                  menu_4();  break;     
     
543.       case 5:    i++;
     
544.                  if(i>5)
     
545.                  {i=0;}
     
546.                  menu_5();  break;   
     
547.       case 6:    i++;
     
548.                  if(i>1)
     
549.                  {i=0;}
     
550.                  menu_6();  break;                                                   
     
551.      case 7:     screen_status=screen_temp;
     
552.                               i=0;
     
553.                               if(screen_temp==2)
     
554.                                       {menu_2();}
     
555.                               else
     
556.                                  {menu_3();}
     
557.                               break;
     
558.      }
     
559.     }
     
560.    keyvalue=0;      
     
561.   }
     
562. }
     
563. //-------------------------------------------------------
     
564. //从eeprom中读取数据
     
565. //-----------------------------------------------------
     
566. void read_data(void)
     
567. {
     
568.         for(k=0;k<15;k++)
     
569.         {datatab[k]=eeprom_read(k);}
     
570.         
     
571.         charge_current=(datatab[0]<<8)|datatab[1];
     
572.         charge_voltage=(datatab[2]<<8)|datatab[3];
     
573.         discharge_current=(datatab[4]<<8)|datatab[5];
     
574.         discharge_voltage=(datatab[6]<<8)|datatab[7];
     
575.         loop_times=datatab[8];
     
576.         loop_temp=datatab[10];
     
577.         charge_time=(datatab[11]<<8)|datatab[12];
     
578.         discharge_time=(datatab[13]<<8)|datatab[14];
     
579. }
     
580. 
     
581. //------------------------------------------------------
     
582. //时间记录函数
     
583. //-----------------------------------------------------
     
584. void time_record(void)
     
585. {
     
586.         if(FLAG_CHARGE)
     
587.         {
     
588.                 charge_time++;
     
589.                 eeprom_write(0x0c,(unsigned char)charge_time);
     
590.                 eeprom_write(0x0b,0xff&(charge_time>>8));
     
591.         }
     
592.         else if(!FLAG_CHARGE)
     
593.         {
     
594.                 discharge_time++;
     
595.                 eeprom_write(0x0e,(unsigned char)discharge_time);
     
596.                 eeprom_write(0x0d,0xff&(discharge_time>>8));
     
597.         }
     
598. }
     
599. 
     
600. //-----------------------------------------------------
     
601. //电池容量累计（放电）
     
602. //------------------------------------------------------
     
603. void capacity_record(void)
     
604. {
     
605.         capacity_temp+=Current;
     
606.         if(capacity_temp>7200)
     
607.         {
     
608.                 bat_cap++;
     
609.                 if((loop_temp>=0)&&(loop_temp<10))
     
610.                 {
     
611.                         eeprom_write(17+loop_temp*2,(unsigned char)bat_cap);
     
612.                         eeprom_write(16+loop_temp*2,bat_cap>>8);
     
613.                 }
     
614.                 else if((loop_temp>9)&&(loop_temp<20))
     
615.                 {
     
616.                         eeprom_write(17+(loop_temp%10)*2,(unsigned char)bat_cap);
     
617.                         eeprom_write(16+(loop_temp%10)*2,bat_cap>>8);
     
618.                 }
     
619.                 else if((loop_temp>19)&&(loop_temp<30))
     
620.                 {
     
621.                         eeprom_write(17+(loop_temp%20)*2,(unsigned char)bat_cap);
     
622.                         eeprom_write(16+(loop_temp%20)*2,bat_cap>>8);
     
623.                 }
     
624.                 else if((loop_temp>29)&&(loop_temp<40))
     
625.                 {
     
626.                         eeprom_write(17+(loop_temp%30)*2,(unsigned char)bat_cap);
     
627.                         eeprom_write(16+(loop_temp%30)*2,bat_cap>>8);
     
628.                 }
     
629.                 else if((loop_temp>39)&&(loop_temp<50))
     
630.                 {
     
631.                         eeprom_write(17+(loop_temp%40)*2,(unsigned char)bat_cap);
     
632.                         eeprom_write(16+(loop_temp%40)*2,bat_cap>>8);
     
633.                 }
     
634.                 capacity_temp=capacity_temp%7200;
     
635.         }
     
636. }
     
637. //-------充电电流检测---------------------------------
     
638. //Current:充电电流值 mA
     
639. //-------------------------------------------------
     
640. void Current_Check(void)
     
641. {
     
642.   unsigned int ADC_temp2;
     
643.   unsigned int ADC_temp3;
     
644.   
     
645.   ADC_Channel(1);
     
646.   ADC_temp2=ADC_Convert();
     
647.   ADC_temp3=ADC_Convert();
     
648. 
     
649.   ADC_temp2=ADC_temp2*3/10+ADC_temp3*7/10;
     
650.   Current=(ADC_temp2*10)/4;
     
651. }
     
652. //-------电池电压检测函数-------------------------------
     
653. //bat_voltage:电池电压值 mV
     
654. //采用平均值滤波
     
655. //-------------------------------------------------------
     
656. void bat_voltage_check(void)
     
657. {
     
658.   unsigned int ADC_temp2=0;
     
659.   unsigned char ADC_temp3;
     
660.   
     
661.   ADC_Channel(0);
     
662.   Uvalue_buff[count2]=ADC_Convert();
     
663.   if(Uvalue_buff[7]!=0)
     
664.   {
     
665.           for(ADC_temp3=0;ADC_temp3<8;ADC_temp3++)
     
666.           {ADC_temp2+=Uvalue_buff[ADC_temp3];}
     
667.           bat_voltage=(ADC_temp2*5)>>3;
     
668.   }
     
669.   else
     
670.   {
     
671.             bat_voltage=Uvalue_buff[count2]*5;
     
672.   }
     
673.   count2++;
     
674.   if(count2>7)
     
675.           {count2=0;}
     
676. }
     
677. 
     
678. //--------放电电流检测函数------------------------
     
679. //--------采用了中值滤波--------------------------
     
680. //------------------------------------------------
     
681. void discharge_current_check(void)
     
682. {
     
683.   unsigned int ADC_temp2;
     
684.   unsigned char ADC_temp3;
     
685.   unsigned char ii,jj;
     
686.   ADC_Channel(2);
     
687.   for(ii=0;ii<5;ii++)
     
688.     {Cvalue_buff[ii]=ADC_Convert();}
     
689.   for (jj=0;jj<5;jj++)
     
690.   {
     
691.    for (ii=0;ii<5-jj;ii++)
     
692.    {
     
693.     if (Cvalue_buff[ii]>Cvalue_buff[ii+1] )
     
694.     {
     
695.       ADC_temp2 = Cvalue_buff[ii];
     
696.       Cvalue_buff[ii] = Cvalue_buff[ii+1];
     
697.       Cvalue_buff[ii+1] = ADC_temp2;
     
698.     }
     
699.    }
     
700.   }
     
701.   Current=Cvalue_buff[2]*10;
     
702. }
     
703. //--------充电函数--------------------------------
     
704. //函数说明：调用充电电流及电池电压检测函数
     
705. //                        Current:充电电流（mA）       bat_voltage:电池电压
     
706. //                        charge_voltage:充电限制电压  charge_current:恒流充电电流
     
707. //                        error_charge:充电错误（电压低于1V或者大于充电限制电压+300，报错）标志位，有误为1；
     
708. //                        finish_charge：充电完成标志位，为1充电完成；
     
709. //------------------------------------------------
     
710. void chargeing(void)
     
711. {
     
712.         Current_Check();
     
713.     delay_ms(1);
     
714.     bat_voltage_check();
     
715.         
     
716.         if((bat_voltage>(charge_voltage+300))||(bat_voltage<1000))//电压低于1V或者大于充电限制电压+300，报错
     
717.         {
     
718.                 PWM_WIDE=0;
     
719.                 error_charge=1;
     
720.         }        
     
721.         else if((1000<bat_voltage)&&(bat_voltage<3000)&&(!finish_charge))//预充电
     
722.                 {PWM_WIDE=30;}
     
723.         else if((3000<bat_voltage)&&(bat_voltage<(charge_voltage+50))&&(!finish_charge))//恒流充电
     
724.         {
     
725.                 error_charge=0;
     
726.                 if(bat_voltage<(charge_voltage-50))
     
727.                 {
     
728.                         if((Current+50)<charge_current)
     
729.                                 {PWM_WIDE+=20;}
     
730.                         else if(((Current+50)>charge_current)&&((Current+20)<charge_current))
     
731.                                 {PWM_WIDE+=5;}
     
732.                         else if(((Current+20)>charge_current)&&(charge_current>Current+3))
     
733.                                 {PWM_WIDE++;}
     
734.                         else if(Current>(charge_current+5))
     
735.                                 {PWM_WIDE--;}
     
736.                 }
     
737.                         
     
738.                 else if((bat_voltage>(charge_voltage-50))&&(bat_voltage<(charge_voltage+30)))
     
739.                 {        
     
740.                         if((bat_voltage>(charge_voltage-50))&&(bat_voltage<(charge_voltage-30)))
     
741.                                 {PWM_WIDE++;}
     
742.                         else if(bat_voltage>charge_voltage||Current>(charge_current+5))
     
743.                                 {PWM_WIDE--;}
     
744.                 }
     
745.                 if(PWM_WIDE>=0X3FF)
     
746.                         {PWM_WIDE=0X3FF;}        
     
747.         }
     
748.         
     
749.         if((PWM_WIDE<19)&&(!error_charge))//电流过小，充电完成。
     
750.         {
     
751.                 count=eeprom_read(0x09)*60;
     
752.                 finish_charge=1;
     
753.                 PWM_WIDE=0;
     
754.                 FLAG_CHARGE=0;
     
755.                 eeprom_write(0xf0,0);
     
756.                 FLAG_RUN=0;
     
757.         }
     
758. 
     
759. }
     
760. 
     
761. //--------放电函数----------------------
     
762. //函数说明：调用充电电流及电池电压检测函数
     
763. //                        Current:放电电流（mA）       bat_voltage:电池电压
     
764. //                        discharge_voltage:充电限制电压  discharge_current:恒流充电电流
     
765. //                        error_discharge:充电错误（电压低于1V或者大于充电限制电压+300，报错）标志位，有误为1；
     
766. //                        finish_discharge：充电完成标志位，为1充电完成；
     
767. //------------------------------------------------
     
768. void discharge(void)
     
769. {
     
770.         discharge_current_check();
     
771.     bat_voltage_check();
     
772.     if(bat_voltage<1000)
     
773.     {
     
774.             PWM_WIDE=0;
     
775.             //error_discharge=1;
     
776.     }
     
777.     else if(bat_voltage>=discharge_voltage)
     
778.     {
     
779.             //error_discharge=0;
     
780.             if((Current+100)<discharge_current)
     
781.                     {PWM_WIDE+=50;}
     
782.             else if(((Current+100)>discharge_current)&&(Current+50)<discharge_current)
     
783.                     {PWM_WIDE+=50;}
     
784.             else if(((Current+50)>discharge_current)&&(Current+15)<discharge_current)
     
785.                     {PWM_WIDE++;}
     
786.             else if(Current>(discharge_current+50))
     
787.                     {PWM_WIDE-=5;}
     
788.             else if(Current>(discharge_current+10))
     
789.                     {PWM_WIDE--;}
     
790.         if(PWM_WIDE>=0X3FF)
     
791.                     {PWM_WIDE=0X3FF;}
     
792.     }
     
793.     else if(bat_voltage<discharge_voltage)
     
794.     {
     
795.             count=10;//36000;//放电完成后，转入到充电的时间count s
     
796.             finish_discharge=1;
     
797.             PWM_WIDE=0;
     
798.             FLAG_CHARGE=1;
     
799.             eeprom_write(0xf0,1);
     
800.             FLAG_RUN=0;
     
801.             loop_temp++;
     
802.             eeprom_write(0x0a,loop_temp);
     
803.     }
     
804. }
     
805. //--------主函数-------------------------
     
806. void main(void)
     
807. {         
     
808. Init();
     
809. Set32MHZ();
     
810. Init_Uart();
     
811. read_data();
     
812. InitTIME0();
     
813. InitTIME1();
     
814. InitTIME246();
     
815. InitPWM();
     
816. InitADC();        
     
817. lcd_init();
     
818. if(eeprom_read(0x08)>eeprom_read(0x0A))
     
819. {
     
820.    menu_4();
     
821. }
     
822. else
     
823. {
     
824.    screen_status=1;
     
825.    i=0;
     
826.    menu_1();
     
827.    STARTUP=0;
     
828.    FLAG_RUN=0;
     
829. }
     
830. while(1)
     
831. {               
     
832.   asm("CLRWDT");  
     
833.   KeyProcess();
     
834.   if(STARTUP&&count==0)
     
835.   {
     
836.    STARTUP=0;
     
837.    screen_status=0;
     
838.    i=0;
     
839.    lcd_write_com_busy(0x01);
     
840.    menu_0();
     
841.    FLAG_RUN=1;
     
842.    WORKING=1;
     
843.   }  
     
844.   else if(WORKING)
     
845.   {
     
846.           if(loop_temp<loop_times)
     
847.           {
     
848.                   if(FLAG_RUN&flag_work)
     
849.                    {
     
850.                      if(FLAG_CHARGE)
     
851.                      {
     
852.                        chargeing();
     
853.                        PWM_Size(PWM_WIDE);
     
854.                      }
     
855.                      
     
856.                          else if(!FLAG_CHARGE)
     
857.                          {
     
858.                           discharge();
     
859.                           PWM5_Size(PWM_WIDE);
     
860.                           capacity_record();//容量累加
     
861.                          }
     
862.                          flag_work=0;
     
863.                          if(screen_status==0)
     
864.                             menu_0();
     
865.                    }
     
866.         
     
867.               else if(count==0)//倒计时结束，
     
868.                      {
     
869.                       if(finish_discharge&&FLAG_CHARGE)//开始充电
     
870.                       {
     
871.                               lcd_write_com_busy(0x01);
     
872.                               finish_discharge=0;
     
873.                               second_count=0;
     
874.                               charge_time=0;//充电时间清零
     
875.                               eeprom_write(0x0b,0);
     
876.                               eeprom_write(0x0c,0);
     
877.                               FLAG_RUN=1;
     
878.                       }
     
879.                       else if(finish_charge&&FLAG_CHARGE==0)//开始放电
     
880.                       {
     
881.                               lcd_write_com_busy(0x01);
     
882.                               finish_charge=0;
     
883.                               second_count=0;
     
884.                               discharge_time=0;
     
885.                               eeprom_write(0x0d,0);//放电时间清零
     
886.                               eeprom_write(0x0e,0);
     
887.                               
     
888.                               bat_cap=0;
     
889.                               capacity_temp=0;
     
890.                               FLAG_RUN=1;
     
891.                       }
     
892.               }
     
893.           }
     
894.           else if(loop_temp==loop_times&&flag_work)
     
895.           {
     
896.                   LATB7=1;
     
897.                   if(screen_status==0)//测试循环结束
     
898.               {
     
899.                        lcd_write_com_busy(0x01);
     
900.                        menu_0();
     
901.               }
     
902.             flag_work=0;
     
903.           }   
     
904.   }
     
905. 
     
906.   if(FLAG_SECOND)
     
907.   {
     
908.    FLAG_SECOND=0;
     
909.    second_count++;
     
910.    count--;   
     
911.    if(second_count>59)
     
912.    {
     
913.     second_count=0;
     
914.     if(FLAG_RUN)// 在工作状态，一分钟时间到，时间累加
     
915.     {
     
916.             time_record();
     
917.     }            
     
918.    }
     
919.          
     
920.   }
     
921. }  
     
922. }
     
923. //-----------------------------------------------------
     
924. void menu_0(void)
     
925. {
     
926. if(FLAG_RUN&&(loop_temp<loop_times))
     
927. {
     
928.           lcd_write_char(15,0,' ');
     
929.          if(FLAG_CHARGE)
     
930.             {DisplayListChar(4,0,menu0[0]);}
     
931.          else if(!FLAG_CHARGE)
     
932.                  {DisplayListChar(1,0,menu0[1]);}
     
933.          lcd_write_char(0,1,'U');
     
934.          lcd_write_char(8,1,'I');
     
935.          lcd_write_char(1,1,':');
     
936.          lcd_write_char(9,1,':');
     
937.         
     
938.          lcd_write_char(3,1,'.');
     
939.          lcd_write_char(6,1,'V');
     
940.          lcd_write_char(2,1,(bat_voltage/1000+'0'));
     
941.          lcd_write_char(4,1,((bat_voltage%1000)/100+'0'));
     
942.          lcd_write_char(5,1,((bat_voltage%100)/10+'0'));
     
943.          
     
944.          lcd_write_char(11,1,'.');
     
945.          lcd_write_char(14,1,'A');
     
946.          lcd_write_char(10,1,(Current/1000+'0'));
     
947.          lcd_write_char(12,1,((Current%1000)/100+'0'));
     
948.          lcd_write_char(13,1,((Current%100)/10+'0'));
     
949. }
     
950. else if(loop_temp==loop_times)
     
951.         {
     
952.                 lcd_write_com_busy(0x01);
     
953.                 DisplayListChar(2,0,menu0[2]);
     
954.         }
     
955. else if(finish_charge&&(loop_temp<loop_times))
     
956.          {
     
957.                  lcd_write_com_busy(0x01);
     
958.                  DisplayListChar(1,0,menu0[3]);
     
959.         }
     
960. else if(finish_discharge&&(loop_temp<loop_times))
     
961.          {
     
962.                  lcd_write_com_busy(0x01);
     
963.                  DisplayListChar(0,0,menu0[4]);
     
964.         }
     
965. }
     
966. //--------------------------------------------------
     
967. void menu_1(void)
     
968. {
     
969. lcd_write_com_busy(0x01);
     
970. //显示第一行
     
971. DisplayListChar(0, 0, menu1[i]);
     
972. lcd_write_char(15,0,'<');
     
973. j=i+1;
     
974. //显示第二行
     
975. if(j>(menu1_num-1))
     
976. {j=0;}
     
977. DisplayListChar(0, 1, menu1[j]);
     
978. 
     
979. }
     
980. //---------------------------------------------------
     
981. void menu_3(void)
     
982. {
     
983. lcd_write_com_busy(0x01);
     
984. //显示第一行
     
985. switch(i)
     
986. {
     
987.   case 1: databuf1=(datatab[0]<<8)|datatab[1];break;
     
988.   case 2: databuf1=(datatab[2]<<8)|datatab[3];break;
     
989.   case 3: databuf1=(datatab[11]<<8)|datatab[12];break;
     
990.   case 4: databuf1=(datatab[4]<<8)|datatab[5];break;   
     
991.   case 5: databuf1=(datatab[6]<<8)|datatab[7];break;
     
992.   case 6: databuf1=(datatab[13]<<8)|datatab[14];break;
     
993.   case 7: databuf1=datatab[10];break;
     
994. }
     
995. DisplayListChar(0, 0, menu3[i]);
     
996. 
     
997. if((i==1)||(i==2)||(i==4)||(i==5))
     
998. {
     
999.   if((i==1)||(i==4))
     
1000.          {lcd_write_char(12,0,'A');}
      
1001.   if((i==2)||(i==5))
      
1002.          {lcd_write_char(12,0,'V');}
      
1003. 
      
1004.   lcd_write_char(9,0,'.');
      
1005.   lcd_write_char(8,0,(databuf1/1000+'0'));            
      
1006.   lcd_write_char(10,0,(databuf1%1000)/100+'0');           
      
1007.   lcd_write_char(11,0,(databuf1%100)/10+'0');           
      
1008. }
      
1009. else if((i==3)||(i==6)||(i==7))
      
1010. {
      
1011.   if((i==3)||(i==6))
      
1012.          {lcd_write_char(12,0,'M');}
      
1013.   else if(i==7)
      
1014.          {lcd_write_char(12,0,'t');}
      
1015. 
      
1016.   lcd_write_char(8,0,(databuf1/1000+'0'));            
      
1017.   lcd_write_char(9,0,(databuf1%1000)/100+'0');           
      
1018.   lcd_write_char(10,0,(databuf1%100)/10+'0');           
      
1019.   lcd_write_char(11,0,(databuf1%10)+'0');  
      
1020. }
      
1021. lcd_write_char(15,0,'<');
      
1022. 
      
1023. j=i+1;
      
1024. //显示第二行
      
1025. if(j>(menu3_num-1))
      
1026. {j=0;}
      
1027. switch(j)
      
1028. {
      
1029.   case 1: databuf2=(datatab[0]<<8)|datatab[1];break;
      
1030.   case 2: databuf2=(datatab[2]<<8)|datatab[3];break;
      
1031.   case 3: databuf2=(datatab[11]<<8)|datatab[12];break;
      
1032.   case 4: databuf2=(datatab[4]<<8)|datatab[5];break;   
      
1033.   case 5: databuf2=(datatab[6]<<8)|datatab[7];break;
      
1034.   case 6: databuf2=(datatab[13]<<8)|datatab[14];break;
      
1035.   case 7: databuf2=datatab[10];break;
      
1036. }
      
1037. DisplayListChar(0, 1, menu3[j]);
      
1038. if((j==1)||(j==2)||(j==4)||(j==5))
      
1039. {
      
1040.   if((j==1)||(j==4))
      
1041.          {lcd_write_char(12,1,'A');}
      
1042.   else if((j==2)||(j==5))
      
1043.          {lcd_write_char(12,1,'V');}
      
1044.   
      
1045.   lcd_write_char(9,1,'.');
      
1046.   lcd_write_char(8,1,(databuf2/1000+'0'));            
      
1047.   lcd_write_char(10,1,(databuf2%1000)/100+'0');           
      
1048.   lcd_write_char(11,1,(databuf2%100)/10+'0');           
      
1049. }
      
1050. else if((j==3)||(j==6)||(j==7))
      
1051. {
      
1052.   if((j==3)||(j==6))
      
1053.          {lcd_write_char(12,1,'M');}
      
1054.   else if(j==7)
      
1055.          {lcd_write_char(12,1,'t');}
      
1056. 
      
1057.   lcd_write_char(8,1,(databuf2/1000+'0'));            
      
1058.   lcd_write_char(9,1,(databuf2%1000)/100+'0');           
      
1059.   lcd_write_char(10,1,(databuf2%100)/10+'0');           
      
1060.   lcd_write_char(11,1,(databuf2%10)+'0');   
      
1061. }
      
1062. }
      
1063. //-----------------------------------------------
      
1064. 
      
1065. void menu_4(void)
      
1066. {
      
1067. //--------------------------
      
1068.   lcd_write_com_busy(0x01);
      
1069.   STARTUP=1;
      
1070.   FLAG_CHARGE=eeprom_read(0XF0);//读取充电放电标志位，1:充电 0:放电
      
1071. //显示第一行
      
1072. if(FLAG_CHARGE)
      
1073. {
      
1074.   DisplayListChar(4, 0, menu0[0]); //charging
      
1075. }
      
1076. else
      
1077. {
      
1078.   DisplayListChar(2, 0, menu0[1]);// discharging
      
1079. }
      
1080. //显示第二行
      
1081. DisplayListChar(0, 1, menu4[0]);
      
1082. DisplayListChar(10, 1, menu4[1]);
      
1083. if(i==0)
      
1084. { lcd_write_char(8,1,'<'); }
      
1085. else
      
1086. { lcd_write_char(14,1,'<'); }
      
1087. }
      
1088. void menu_5(void)
      
1089. {
      
1090. lcd_write_com_busy(0x01);
      
1091. //显示第一行
      
1092. switch(i)
      
1093. {
      
1094.   case 0: DisplayListChar(0, 0, menu5[i]);
      
1095.           lcd_write_char(12,0,'A');
      
1096.           databuf1=(datatab[0]<<8)|datatab[1];break;
      
1097.   case 1: DisplayListChar(0, 0, menu5[i]);
      
1098.           lcd_write_char(12,0,'V');
      
1099.           databuf1=(datatab[2]<<8)|datatab[3];break;
      
1100.   case 2: DisplayListChar(0, 0, menu5[i+1]);
      
1101.           lcd_write_char(12,0,'A');
      
1102.           databuf1=(datatab[4]<<8)|datatab[5];break;
      
1103.   case 3: DisplayListChar(0, 0, menu5[i+1]);
      
1104.           lcd_write_char(12,0,'V');
      
1105.           databuf1=(datatab[6]<<8)|datatab[7];break;   
      
1106.   case 4: DisplayListChar(0, 0, menu5[i+2]);
      
1107.           lcd_write_char(12,0,'t');
      
1108.           databuf1=datatab[8];break;
      
1109.   case 5: DisplayListChar(0, 0, menu5[i+3]);
      
1110.           lcd_write_char(12,0,'M');
      
1111.           databuf1=datatab[9];break;                       
      
1112. }
      
1113. 
      
1114. if(i<=3)
      
1115. {
      
1116.   lcd_write_char(9,0,'.');
      
1117.   lcd_write_char(8,0,(databuf1/1000+'0'));            
      
1118.   lcd_write_char(10,0,(databuf1%1000)/100+'0');           
      
1119.   lcd_write_char(11,0,(databuf1%100)/10+'0');           
      
1120. }
      
1121. else
      
1122. {
      
1123.   //lcd_write_char(8,0,(databuf1/1000+'0'));            
      
1124.   //lcd_write_char(9,0,(databuf1%1000)/100+'0');           
      
1125.   lcd_write_char(10,0,(databuf1%100)/10+'0');           
      
1126.   lcd_write_char(11,0,(databuf1%10)+'0');   
      
1127. }
      
1128. lcd_write_char(15,0,'<');
      
1129. 
      
1130. j=i+1;
      
1131. //显示第二行
      
1132. if(j>5)
      
1133. {j=0;}
      
1134. switch(j)
      
1135. {
      
1136.   case 0: DisplayListChar(0, 1, menu5[j]);
      
1137.           lcd_write_char(12,1,'A');
      
1138.           databuf2=(datatab[0]<<8)|datatab[1];break;
      
1139.   case 1: DisplayListChar(0, 1, menu5[j]);
      
1140.           lcd_write_char(12,1,'V');
      
1141.           databuf2=(datatab[2]<<8)|datatab[3];break;
      
1142.   case 2: DisplayListChar(0, 1, menu5[j+1]);
      
1143.           lcd_write_char(12,1,'A');
      
1144.           databuf2=(datatab[4]<<8)|datatab[5];break;
      
1145.   case 3: DisplayListChar(0, 1, menu5[j+1]);
      
1146.           lcd_write_char(12,1,'V');
      
1147.           databuf2=(datatab[6]<<8)|datatab[7];break;   
      
1148.   case 4: DisplayListChar(0, 1, menu5[j+2]);
      
1149.           lcd_write_char(12,1,'t');
      
1150.           databuf2=datatab[8];break;
      
1151.   case 5: DisplayListChar(0, 1, menu5[j+3]);
      
1152.           lcd_write_char(12,1,'M');
      
1153.           databuf2=datatab[9];break;                       
      
1154. }
      
1155. 
      
1156. if(j<=3)
      
1157. {
      
1158.   lcd_write_char(9,1,'.');
      
1159.   lcd_write_char(8,1,(databuf2/1000+'0'));            
      
1160.   lcd_write_char(10,1,(databuf2%1000)/100+'0');           
      
1161.   lcd_write_char(11,1,(databuf2%100)/10+'0');           
      
1162. }
      
1163. else
      
1164. {
      
1165.   //lcd_write_char(8,1,(databuf2/1000+'0'));            
      
1166.   //lcd_write_char(9,1,(databuf2%1000)/100+'0');           
      
1167.   lcd_write_char(10,1,(databuf2%100)/10+'0');           
      
1168.   lcd_write_char(11,1,(databuf2%10)+'0');   
      
1169. }
      
1170. }
      
1171. void menu_2(void)
      
1172. {
      
1173. 
      
1174. lcd_write_com_busy(0x01);
      
1175. //显示第一行
      
1176. switch(i)
      
1177. {
      
1178.   case 1: databuf1=(datatab[0]<<8)|datatab[1];break;
      
1179.   case 2: databuf1=(datatab[2]<<8)|datatab[3];break;
      
1180.   case 3: databuf1=(datatab[11]<<8)|datatab[12];break;
      
1181.   case 4: databuf1=(datatab[4]<<8)|datatab[5];break;   
      
1182.   case 5: databuf1=(datatab[6]<<8)|datatab[7];break;
      
1183.   case 6: databuf1=(datatab[13]<<8)|datatab[14];break;
      
1184.   case 7: databuf1=datatab[10];break;
      
1185. }
      
1186. DisplayListChar(0, 0, menu2[i]);
      
1187. if((i==1)||(i==2)||(i==4)||(i==5))
      
1188. {
      
1189.   if((i==1)||(i==4))
      
1190.          {lcd_write_char(12,0,'A');}
      
1191.   else if((i==2)||(i==5))
      
1192.          {lcd_write_char(12,0,'V');}
      
1193.   lcd_write_char(9,0,'.');
      
1194.   
      
1195.   lcd_write_char(8,0,(databuf1/1000+'0'));            
      
1196.   lcd_write_char(10,0,(databuf1%1000)/100+'0');           
      
1197.   lcd_write_char(11,0,(databuf1%100)/10+'0');           
      
1198. }
      
1199. else if((i==3)||(i==6)||(i==7))
      
1200. {
      
1201.   if((i==3)||(i==6))
      
1202.          {lcd_write_char(12,0,'M');}
      
1203.   else if(i==7)
      
1204.          {lcd_write_char(12,0,'t');}
      
1205.   lcd_write_char(8,0,(databuf1/1000+'0'));            
      
1206.   lcd_write_char(9,0,(databuf1%1000)/100+'0');           
      
1207.   lcd_write_char(10,0,(databuf1%100)/10+'0');           
      
1208.   lcd_write_char(11,0,(databuf1%10)+'0');  
      
1209. }
      
1210. lcd_write_char(15,0,'<');
      
1211. 
      
1212. j=i+1;
      
1213. //显示第二行
      
1214. if(j>(menu2_num-1))
      
1215. {j=0;}
      
1216. switch(j)
      
1217. {
      
1218.   case 1: databuf2=(datatab[0]<<8)|datatab[1];break;
      
1219.   case 2: databuf2=(datatab[2]<<8)|datatab[3];break;
      
1220.   case 3: databuf2=(datatab[11]<<8)|datatab[12];break;
      
1221.   case 4: databuf2=(datatab[4]<<8)|datatab[5];break;   
      
1222.   case 5: databuf2=(datatab[6]<<8)|datatab[7];break;
      
1223.   case 6: databuf2=(datatab[13]<<8)|datatab[14];break;
      
1224.   case 7: databuf2=datatab[10];break;
      
1225. }
      
1226. 
      
1227. DisplayListChar(0, 1, menu2[j]);
      
1228. if((j==1)||(j==2)||(j==4)||(j==5))
      
1229. {
      
1230.   if((j==1)||(j==4))
      
1231.          {lcd_write_char(12,1,'A');}
      
1232.   else if((j==2)||(j==5))
      
1233.          {lcd_write_char(12,1,'V');}
      
1234.   lcd_write_char(9,1,'.');
      
1235.   lcd_write_char(8,1,(databuf2/1000+'0'));            
      
1236.   lcd_write_char(10,1,(databuf2%1000)/100+'0');           
      
1237.   lcd_write_char(11,1,(databuf2%100)/10+'0');           
      
1238.   //lcd_write_char(11,1,(databuf2%10)+'0');  
      
1239. }
      
1240. else if((j==3)||(j==6)||(j==7))
      
1241. {
      
1242.   if((j==3)||(j==6))
      
1243.          {lcd_write_char(12,1,'M');}
      
1244.   else if(j==7)
      
1245.          {lcd_write_char(12,1,'t');}
      
1246. 
      
1247.   lcd_write_char(8,1,(databuf2/1000+'0'));            
      
1248.   lcd_write_char(9,1,(databuf2%1000)/100+'0');           
      
1249.   lcd_write_char(10,1,(databuf2%100)/10+'0');           
      
1250.   lcd_write_char(11,1,(databuf2%10)+'0');   
      
1251. }
      
1252. }
      
1253. void menu_6(void)
      
1254. {
      
1255. lcd_write_com_busy(0x01);
      
1256. //显示第一行
      
1257. DisplayListChar(4, 0, menu6);
      
1258. //显示第二行
      
1259. DisplayListChar(0, 1, menu60[0]);
      
1260. DisplayListChar(8, 1, menu60[1]);
      
1261. if(i==0)
      
1262.   {lcd_write_char(6,1,'<');}
      
1263. else
      
1264.   {lcd_write_char(13,1,'<');}
      
1265. }
      
1266. 
      
1267. void menu_7(void)
      
1268. {
      
1269.         lcd_write_com_busy(0x01);
      
1270.         
      
1271.         //显示CAP
      
1272.         DisplayListChar(0,0,menu70);
      
1273.            DisplayListChar(0,1,menu70);
      
1274.            //显示 ：
      
1275.            lcd_write_char(4,0,':');
      
1276.            lcd_write_char(4,1,':');
      
1277.            //显示mah
      
1278.            DisplayListChar(12,0,menu_mah);
      
1279.            DisplayListChar(12,1,menu_mah);
      
1280.            //显示0-9数字
      
1281.            lcd_write_char(3,0,i+'0');
      
1282.            
      
1283.            j=i+1;
      
1284.            if(j>9)
      
1285.              {j=0;}
      
1286.            lcd_write_char(3,1,j+'0');
      
1287.            
      
1288.             switch(i)
      
1289.          {
      
1290.           case 0: databuf1=(cap_data[0]<<8)|cap_data[1];break;
      
1291.           case 1: databuf1=(cap_data[2]<<8)|cap_data[3];break;
      
1292.           case 2: databuf1=(cap_data[4]<<8)|cap_data[5];break;
      
1293.           case 3: databuf1=(cap_data[6]<<8)|cap_data[7];break;   
      
1294.           case 4: databuf1=(cap_data[8]<<8)|cap_data[9];break;
      
1295.           case 5: databuf1=(cap_data[10]<<8)|cap_data[11];break;
      
1296.           case 6: databuf1=(cap_data[12]<<8)|cap_data[13];break;
      
1297.           case 7: databuf1=(cap_data[14]<<8)|cap_data[15];break;
      
1298.           case 8: databuf1=(cap_data[16]<<8)|cap_data[17];break;
      
1299.           case 9: databuf1=(cap_data[18]<<8)|cap_data[19];break;
      
1300.          }
      
1301.          lcd_write_char(8,0,(databuf1/1000+'0'));            
      
1302.          lcd_write_char(9,0,(databuf1%1000)/100+'0');           
      
1303.          lcd_write_char(10,0,(databuf1%100)/10+'0');           
      
1304.          lcd_write_char(11,0,(databuf1%10)+'0');
      
1305.          
      
1306.          switch(j)
      
1307.          {
      
1308.           case 0: databuf2=(cap_data[0]<<8)|cap_data[1];break;
      
1309.           case 1: databuf2=(cap_data[2]<<8)|cap_data[3];break;
      
1310.           case 2: databuf2=(cap_data[4]<<8)|cap_data[5];break;
      
1311.           case 3: databuf2=(cap_data[6]<<8)|cap_data[7];break;   
      
1312.           case 4: databuf2=(cap_data[8]<<8)|cap_data[9];break;
      
1313.           case 5: databuf2=(cap_data[10]<<8)|cap_data[11];break;
      
1314.           case 6: databuf2=(cap_data[12]<<8)|cap_data[13];break;
      
1315.           case 7: databuf2=(cap_data[14]<<8)|cap_data[15];break;
      
1316.           case 8: databuf2=(cap_data[16]<<8)|cap_data[17];break;
      
1317.           case 9: databuf2=(cap_data[18]<<8)|cap_data[19];break;
      
1318.          }
      
1319.          lcd_write_char(8,1,(databuf2/1000+'0'));            
      
1320.          lcd_write_char(9,1,(databuf2%1000)/100+'0');           
      
1321.          lcd_write_char(10,1,(databuf2%100)/10+'0');           
      
1322.          lcd_write_char(11,1,(databuf2%10)+'0');
      
1323. }

复制代码

全部资料51hei下载地址：
battery_test4.zip (919.63 KB, 下载次数: 127)

2018-5-17 06:28 上传

点击文件名下载附件
源程序
下载积分: 黑币 -5

作者大大，电路原理图还在吗？求

好文章。