上一篇我們講了鋰電池的充放電的流程和電池的一些特性，這一節我們重點說一下android關機充電是怎麼、充電畫面顯示是怎麼實現的，這個在工作中也比較有用，我們開始做這一塊的時候也走了不少的彎路。我記得我們做adnroid2.3的時候，關機狀態和充電logo顯示是在uboot中做的。應該是有兩種做法，回頭我再看下uboot中做畫面顯示那一塊是怎麼做的，這一節我們重點說系統中的充電logo顯示。

一、android正常開機流程、關機充電流程

在寫這篇文章之前我們先看兩個流程：正常開機流程，關機充電系統啟動流程

1、正常開機流程，按開機鍵。

可大致分成三部分

（1）、OS_level：UBOOT、kenrel、init這三步完成系統啟動；

（2）、Android_level：這部分完成android部的初始化；

（3）、Home Screen：這部分就是我們看到的launcher部分。

2、關機充電系統啟動流程

       與前面相比，這個流程只走到init這一部分，就沒有往後走了，這部分我們會在後面的程式碼中分析。

==========================

二、關機充電邏輯硬體邏輯

1、插入DC，charger IC從硬體上喚醒系統，相當於長按開機鍵開機。

下面這部分是charger IC連線系統的控制部分。

=========================

三、軟體邏輯。

DC插入，其實相當於關機狀態下“按開機鍵”開機。第一步要走UBOOT、kernel 、android init這一流程。

1、UBOOT

       UBOOT啟動程式碼我們不在這裡詳細分析，這裡我們只要注意二個問題：

a：如何判斷是DC插入；

b：設定setenv("bootargs", "androidboot.mode=charger")，androidboot.mode這個引數相當重要，這個引數決定系統是正常啟動、還是關機充電狀態。

Uboot/board/samsung/smdk4212/smkd4212.c

1. int board_late_init (void)  
2. {  
3.     int keystate = 0;  
4.     printf("check start mode\n");  
5.   if ((*(int
    *)0x10020800==0x19721212) || (*(int *)0x10020804==0x19721212)  
6. || (*(int *)0x10020808==0x19721212)) //（1）、檢查是否有DC插入；
7. {  
8.     setenv ("bootargs", "");//（2）、沒有DC插入；
9.   } else  {//DC插入
10.         int tmp=*(int *)0x11000c08;  
11.     *(int *)0x10020800=*(int *)0x10020804=0x19721212;  
12.     *(int *)0x11000c08=(tmp&(~0xc000))|0xc000;  
13.     udelay(10000);  
14.     if ((*(int *)0x11000c04 & 0x80)!=0x80 && INF_REG4_REG != 0xf) {  
15.         setenv ("bootargs", "androidboot.mode=charger");//（3）、設定bootargs為charger狀態
16.         printf("charger mode\n");  
17.     } else {  
18.         setenv ("bootargs", "");  
19.     }  
20.     *(int *)0x11000c08=tmp;  
21.   }  
22. #ifdef CONFIG_CPU_EXYNOS4X12
23.     int charge_status=CheckBatteryLow();//（4）、檢查電池電量，如果檢測電量太低，則不開機；
24.     keystate=board_key_check();//（5）、檢查按鍵狀態；
25.     // fuse bootloader
26.     if(second_boot_info != 0) {  
27.         boot_symbol=1;  
28.         INF_REG2_REG =0x8;  
29.         run_command(CONFIG_BOOTCMD_FUSE_BOOTLOADER, NULL);  
30.     }  
31.     if((INF_REG4_REG == 0xd)) {  
32.         // reboot default
33.         char buf[10];  
34.         sprintf(buf, "%d", CONFIG_BOOTDELAY);  
35.         setenv ("bootdelay", buf);  
36.         setenv ("reserved", NULL);  
37.         saveenv();  
38.     } elseif((INF_REG4_REG == 0xe) || keystate == (0x1 | 0x2)) {//（6）、按鍵進入fastboot模式；
39.         // reboot bootloader
40.         boot_symbol=1;  
41.         INF_REG2_REG =0x8;  
42.         printf("BOOTLOADER - FASTBOOT\n");  
43.         setenv ("reserved", "fastboot");  
44.         setenv ("bootdelay", "0");  
45.     } elseif((INF_REG4_REG == 0xf) || keystate == (0x1 | 0x2 | 0x4)) {//（7）、按鍵進入recovery模式；
46.         // reboot recovery
47.         printf("BOOTLOADER - RECOVERY\n");  
48.         boot_symbol=1;  
49.         INF_REG2_REG =0x8;  
50.         setenv ("reserved", CONFIG_BOOTCMD_RECOVERY);  
51.         setenv ("bootdelay", "0");  
52.     } else
53.     if(keystate == (0x1 | 0x4) || second_boot_info != 0 || partition_check()) {//（8）、按鍵進入卡升級模式；
54.         // 2nd boot
55.         printf("BOOTLOADER - 2ND BOOT DEVICE\n");  
56.         boot_symbol=1;  
57.         INF_REG2_REG =0x8;  
58.         setenv ("bootcmd", CONFIG_BOOTCOMMAND);  
59.         setenv ("reserved", CONFIG_BOOTCMD_FUSE_RELEASE);  
60.         setenv ("bootdelay", "0");  
61.     } else {//（9）、正常啟動；
62.         // normal case
63.         char buf[10];  
64.         sprintf(buf, "%d", CONFIG_BOOTDELAY);  
65.         setenv ("bootdelay", buf);  
66.     }  
67.     INF_REG4_REG = 0;  
68.     return 0;  
69. } 
    

（1）、檢查是否有DC插入；

1. if ((*(int *)0x10020800==0x19721212) || (*(int *)0x10020804==0x19721212)  
2.  (*(int *)0x10020808==0x19721212))   

這部分檢查暫存器的值。

（2）、沒有DC插入；

（3）、設定bootargs為charger狀態

1. if ((*(int *)0x11000c04 & 0x80)!=0x80 && INF_REG4_REG != 0xf) {  
2.         setenv ("bootargs", "androidboot.mode=charger");  

這是這部分的重點，如果能過暫存器判斷是DC插入，把androidboot.mode設定為charger狀態。

以下這部分根據需要加入，通過判斷不同的情況進入不同的功能，如fastboot\revovery…………，這部分不做詳細解釋。

（4）、檢查電池電量；

    這個在正常開機狀態下，如果檢測電量太低，則不開機，這部分程式碼就不做分析。

（5）、檢查按鍵狀態；

      我們這個平臺有幾種模式:fastboot\recovery\卡升級等……

（6）、按鍵進入fastboot模式；

（7）、按鍵進入recovery模式；

（8）、按鍵進入卡升級模式

（9）、正常啟動；

2、kernel

這部分和正常啟動是一樣的。

3、init

前面所有的描述其實只有一點和正常啟動不太一樣，那就是在UBOOT中把androidboot.mode設定為charger狀態，核心正常啟動，然後到init時要對charger這種狀態處理。

system\core\init\init.c

1. int main(int argc, char **argv)  
2. {  
3.     ………………  
4.     action_for_each_trigger("early-init", action_add_queue_tail);  
5.     queue_builtin_action(wait_for_coldboot_done_action, "wait_for_coldboot_done");  
6.     queue_builtin_action(property_init_action, "property_init");  
7.     queue_builtin_action(keychord_init_action, "keychord_init");  
8.     queue_builtin_action(console_init_action, "console_init");  //(1)、顯示initlogo.rle，也就是android第二張圖片;
9.     queue_builtin_action(set_init_properties_action, "set_init_properties");  
10.     /* execute all the boot actions to get us started */
11.     action_for_each_trigger("init", action_add_queue_tail);  
12.     /* skip mounting filesystems in charger mode */
13.     if (strcmp(bootmode, "charger") != 0) {//(2)、這裡就是UBOOT中設定的bootmode，如果是charger模式，跳過下面初始化；
14.         action_for_each_trigger("early-fs", action_add_queue_tail);  
15.         action_for_each_trigger("fs", action_add_queue_tail);  
16.         action_for_each_trigger("post-fs", action_add_queue_tail);  
17.         action_for_each_trigger("post-fs-data", action_add_queue_tail);  
18.     }  
19.     queue_builtin_action(property_service_init_action, "property_service_init");  
20.     queue_builtin_action(signal_init_action, "signal_init");  
21.     queue_builtin_action(check_startup_action, "check_startup");  
22.     if (!strcmp(bootmode, "charger")) {//(3)、如果為charger，則呼叫charger.c。
23.         action_for_each_trigger("charger", action_add_queue_tail);  
24.     } else {  
25.         action_for_each_trigger("early-boot", action_add_queue_tail);  
26.         action_for_each_trigger("boot", action_add_queue_tail);  
27.     }  
28. ……………………  
29. }  

(1)、顯示initlogo.rle，也就是android第二張圖片;

queue_builtin_action(console_init_action,"console_init");呼叫console_init_action

1. staticint console_init_action(int nargs, char **args)  
2. {  
3.     int fd;  
4.     char tmp[PROP_VALUE_MAX];  
5.     if (console[0]) {  
6.         snprintf(tmp, sizeof(tmp), "/dev/%s", console);  
7.         console_name = strdup(tmp);  
8.     }  
9.     fd = open(console_name, O_RDWR);  
10.     if (fd >= 0)  
11.         have_console = 1;  
12.     close(fd);  
13.     if( load_565rle_image(INIT_IMAGE_FILE) ) {//這裡定義rle檔案的名稱#define INIT_IMAGE_FILE "/initlogo.rle"
14.         fd = open("/dev/tty0", O_WRONLY);  
15.         if (fd >= 0) {//如果沒有這張圖片，就顯示android字樣，在螢幕左上角；
16.             constchar *msg;  
17.                 msg = "\n"
18.             "\n"
19.             "\n"// console is 40 cols x 30 lines
20.             "\n"
21.             "\n"
22.             "\n"
23.             "\n"
24.             "\n"
25.             "\n"
26.             "\n"
27.             "             A N D R O I D ";  
28.             write(fd, msg, strlen(msg));  
29.             close(fd);  
30.         }  
31.     }  
32.     return 0;  
33. }  

(2)、這裡就是UBOOT中設定的bootmode，如果是charger模式，跳過下面初始化；

1. /* skip mounting filesystems in charger mode */
2. if (strcmp(bootmode, "charger") != 0) {  
3.     action_for_each_trigger("early-fs", action_add_queue_tail);  
4.     action_for_each_trigger("fs", action_add_queue_tail);  
5.     action_for_each_trigger("post-fs", action_add_queue_tail);  
6.     action_for_each_trigger("post-fs-data", action_add_queue_tail);  
7. }  

(3)、如果為charger，則呼叫charger.c

1. action_for_each_trigger("charger", action_add_queue_tail);  

我們在後面細分charger這部分。

4、charger.c

這部分就是我們充電部分，充電畫面顯示的實現。

system\core\charger\charger.c

1. int main(int argc, char **argv)  
2. {  
3. ………………  
4.     klog_set_level(CHARGER_KLOG_LEVEL);  
5.     dump_last_kmsg();  
6.     LOGI("--------------- STARTING CHARGER MODE ---------------\n");  
7.     gr_init();  
8.     gr_font_size(&char_width, &char_height); //(1)、初始化graphics,包括buf大小；
9.     ev_init(input_callback, charger);//(2)初始化按鍵；
10. fd = uevent_open_socket(64*1024, true);  
11.     if (fd >= 0) {  
12.         fcntl(fd, F_SETFL, O_NONBLOCK);  
13.         ev_add_fd(fd, uevent_callback, charger);  
14.     }  
15.     charger->uevent_fd = fd;  
16.     coldboot(charger, "/sys/class/power_supply", "add");//(3)、建立/sys/class/power_supply結點，把socket資訊通知應用層；
17. ret = res_create_surface("charger/battery_fail", &charger->surf_unknown);  
18.     if (ret < 0) {  
19.         LOGE("Cannot load image\n");  
20.         charger->surf_unknown = NULL;  
21.     }  
22.     for (i = 0; i < charger->batt_anim->num_frames; i++) {//(4)、這裡是顯示charger logo，res_create_surface顯示圖片函式；
23.         struct frame *frame = &charger->batt_anim->frames[i];  
24.         ret = res_create_surface(frame->name, &frame->surface);  
25.         if (ret < 0) {  
26.             LOGE("Cannot load image %s\n", frame->name);  
27.             /* TODO: free the already allocated surfaces... */
28.             charger->batt_anim->num_frames = 0;  
29.             charger->batt_anim->num_cycles = 1;  
30.             break;  
31.         }  
32.     }  
33. ev_sync_key_state(set_key_callback, charger);  
34.     gr_fb_blank(true);  
35.     charger->next_screen_transition = now - 1;  
36.     charger->next_key_check = -1;  
37.     charger->next_pwr_check = -1;  
38.     reset_animation(charger->batt_anim);  
39.     kick_animation(charger->batt_anim);  
40.     event_loop(charger);//（5）、event_loop迴圈，電池狀態，檢測按鍵是否按下；
41.     return 0;  
42. }  

(1)、初始化graphics,包括buf大小

android/bootable/recovery/minui/graphics.c

gr_init():minui/graphics.c［settty0 to graphic mode, open fb0]，設制tty0為圖形模式，開啟fb0;

1. int gr_init(void)  
2. {  
3.     gglInit(&gr_context);  
4.     GGLContext *gl = gr_context;  
5.     gr_init_font();  
6.     gr_vt_fd = open("/dev/tty0", O_RDWR | O_SYNC);  
7.     if (gr_vt_fd < 0) {  
8.         // This is non-fatal; post-Cupcake kernels don't have tty0.
9.         perror("can't open /dev/tty0");  
10.     } elseif (ioctl(gr_vt_fd, KDSETMODE, (void*) KD_GRAPHICS)) {  
11.         // However, if we do open tty0, we expect the ioctl to work.
12.         perror("failed KDSETMODE to KD_GRAPHICS on tty0");  
13.         gr_exit();  
14.         return -1;  
15.     }  
16.     gr_fb_fd = get_framebuffer(gr_framebuffer);  
17.     if (gr_fb_fd < 0) {  
18.         gr_exit();  
19.         return -1;  
20.     }  
21.     get_memory_surface(&gr_mem_surface);  
22.     fprintf(stderr, "framebuffer: fd %d (%d x %d)\n",  
23.             gr_fb_fd, gr_framebuffer[0].width, gr_framebuffer[0].height);  
24.         /* start with 0 as front (displayed) and 1 as back (drawing) */
25.     gr_active_fb = 0;  
26.     set_active_framebuffer(0);  
27.     gl->colorBuffer(gl, &gr_mem_surface);  
28.     gl->activeTexture(gl, 0);  
29.     gl->enable(gl, GGL_BLEND);  
30.     gl->blendFunc(gl, GGL_SRC_ALPHA, GGL_ONE_MINUS_SRC_ALPHA);  
31.     gr_fb_blank(true);  
32.     gr_fb_blank(false);  
33.     return 0;  
34. }  

(2)android/bootable/recovery/minui/events.c

ev_init():minui/events.c[open /dev/input/event*]開啟 /dev/input/event*

這部分是在，充電狀態下，按鍵操作的初始化，比如：短按顯示充電logo，長按開機，初始化程式碼如下。

1. int ev_init(ev_callback input_cb, void *data)  
2. {  
3.     DIR *dir;  
4.     struct dirent *de;  
5.     int fd;  
6.     dir = opendir("/dev/input");//開啟驅動結點；
7.     if(dir != 0) {  
8.         while((de = readdir(dir))) {  
9.             unsigned long ev_bits[BITS_TO_LONGS(EV_MAX)];  
10. //            fprintf(stderr,"/dev/input/%s\n", de->d_name);
11.             if(strncmp(de->d_name,"event",5)) continue;  
12.             fd = openat(dirfd(dir), de->d_name, O_RDONLY);  
13.             if(fd < 0) continue;  
14.             /* read the evbits of the input device */
15.             if (ioctl(fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) < 0) {  
16.                 close(fd);  
17.                 continue;  
18.             }  
19.             /* TODO: add ability to specify event masks. For now, just assume 
20.              * that only EV_KEY and EV_REL event types are ever needed. */
21.             if (!test_bit(EV_KEY, ev_bits) && !test_bit(EV_REL, ev_bits)) {  
22.                 close(fd);  
23.                 continue;  
24.             }  
25.             ev_fds[ev_count].fd = fd;  
26.             ev_fds[ev_count].events = POLLIN;  
27.             ev_fdinfo[ev_count].cb = input_cb;  
28.             ev_fdinfo[ev_count].data = data;  
29.             ev_count++;  
30.             ev_dev_count++;  
31.             if(ev_dev_count == MAX_DEVICES) break;  
32.         }  
33.     }  
34.     return 0;  
35. }  

(3)、建立/sys/class/power_supply結點，把socket資訊通知應用層

uevent_open_socket這個函式是通過kobject_uevent的方式通知的應用層，就是往一個socket廣播一個訊息，只需要在應用層開啟socket監聽NETLINK_KOBJECT_UEVENT組的訊息，就可以收到了,主要是建立了socket介面獲得uevent的檔案描述符，然後觸發/sys/class/power_supply目錄及其子目錄下的uevent，然後接受並建立裝置節點，至此裝置節點才算建立。

(4)、這裡顯示charger logo，res_create_surface顯示圖片函式；

res_create_surface:minui/resource.c[create surfaces for all bitmaps used later, include icons, bmps]

建立surface為所以的點陣圖，包括圖示、點陣圖。  這些圖片的位置為：system\core\charger\images

（5）、event_loop迴圈，電池狀態，檢測按鍵是否按下；

5、event_loop

       這個函式判斷按鍵狀態，DC是否插拔。如果長按開機：執行android_reboot(ANDROID_RB_RESTART,0, 0);如果拔出DC:執行android_reboot(ANDROID_RB_POWEROFF,0, 0);

1. staticvoid event_loop(struct charger *charger)  
2. {  
3.     int ret;  
4.     while (true) {  
5.         int64_t now = curr_time_ms();//（1）、獲得當前時間；
6.         LOGV("[%lld] event_loop()\n", now);  
7.         handle_input_state(charger, now);//（2）、檢查按鍵狀態；
8.         handle_power_supply_state(charger, now);// (3)、檢查DC是否拔出； 
9.         /* do screen update last in case any of the above want to start 
10.          * screen transitions (animations, etc) 
11.          */
12.         update_screen_state(charger, now);//(4)、對按鍵時間狀態標誌位的判斷，顯示不同電量的充電logo; 
13.         wait_next_event(charger, now);  
14.     }  
15. }  

（1）、獲得當前時間；

   int64_t now = curr_time_ms();

       這個時間來判斷，有沒有螢幕超時，如果超時關閉螢幕充電logo顯示。

（2）、檢查按鍵狀態；

1. staticvoid handle_input_state(struct charger *charger, int64_t now)  
2. {  
3.     process_key(charger, KEY_POWER, now);  
4.     if (charger->next_key_check != -1 && now > charger->next_key_check)  
5.         charger->next_key_check = -1;  
6. }  
7. 我們再看下：process_key(charger, KEY_POWER, now);  
8. staticvoid process_key(struct charger *charger, int code, int64_t now)  
9. {  
10. ………………  
11.     if (code == KEY_POWER) {  
12.         if (key->down) {  
13.             int64_t reboot_timeout = key->timestamp + POWER_ON_KEY_TIME;  
14.             if (now >= reboot_timeout) {//如果長按power鍵，就重新啟動，也就是重啟開機；
15.                 LOGI("[%lld] rebooting\n", now);  
16.                 android_reboot(ANDROID_RB_RESTART, 0, 0);//重啟命令；
17.             }  
18.     ………………  
19.     }  
20.     key->pending = false;  
21. }  

（3）、檢查DC是否拔出；

handle_power_supply_state(charger, now); 

1. staticvoid handle_power_supply_state(struct charger *charger, int64_t now)  
2. {  
3.     if (charger->num_supplies_online == 0) {  
4.         if (charger->next_pwr_check == -1) {  
5.             charger->next_pwr_check = now + UNPLUGGED_SHUTDOWN_TIME;  
6.             LOGI("[%lld] device unplugged: shutting down in %lld (@ %lld)\n",  
7.                  now, UNPLUGGED_SHUTDOWN_TIME, charger->next_pwr_check);  
8.         } elseif (now >= charger->next_pwr_check) {  
9.             LOGI("[%lld] shutting down\n", now);  
10.             android_reboot(ANDROID_RB_POWEROFF, 0, 0);//如果DC拔出，則關機；
11.         }   
12. ………………  
13. }  

(4)、對按鍵時間狀態標誌位的判斷，顯示不同電量的充電logo;

  update_screen_state(charger, now);

這個函式比較長了，其實做用就是：我們在狀態的過程中,充電logo的電量是要增加的，比如電量是20%時，要從第一格開始閃爍；如果是80%時，則要從第三格開始閃爍，電量顯示就是通過這個函式來計算實現的。

1. staticvoid update_screen_state(struct charger *charger, int64_t now)  
2. {  
3.     struct animation *batt_anim = charger->batt_anim;  
4.     int cur_frame;  
5.     int disp_time;  
6.     if (!batt_anim->run || now < charger->next_screen_transition)  
7.         return;  
8.     /* animation is over, blank screen and leave */
9.     if (batt_anim->cur_cycle == batt_anim->num_cycles) {  
10.         reset_animation(batt_anim);  
11.         charger->next_screen_transition = -1;  
12.         gr_fb_blank(true);  
13.         LOGV("[%lld] animation done\n", now);  
14.         return;  
15.     }  
16.     disp_time = batt_anim->frames[batt_anim->cur_frame].disp_time;  
17.     /* animation starting, set up the animation */
18.     if (batt_anim->cur_frame == 0) {  
19.         int batt_cap;  
20.         int ret;  
21.         LOGV("[%lld] animation starting\n", now);  
22.         batt_cap = get_battery_capacity(charger);  
23.         if (batt_cap >= 0 && batt_anim->num_frames != 0) {  
24.             int i;  
25.             /* find first frame given current capacity */
26.             for (i = 1; i < batt_anim->num_frames; i++) {  
27.                 if (batt_cap < batt_anim->frames[i].min_capacity)  
28.                     break;  
29.             }  
30.             batt_anim->cur_frame = i - 1;  
31.             /* show the first frame for twice as long */
32.             disp_time = batt_anim->frames[batt_anim->cur_frame].disp_time * 2;  
33.         }  
34.         batt_anim->capacity = batt_cap;  
35.     }  
36.     /* unblank the screen  on first cycle */
37.     if (batt_anim->cur_cycle == 0)  
38.         gr_fb_blank(false);  
39.     /* draw the new frame (@ cur_frame) */
40.     redraw_screen(charger);  
41.     /* if we don't have anim frames, we only have one image, so just bump 
42.      * the cycle counter and exit 
43.      */
44.     if (batt_anim->num_frames == 0 || batt_anim->capacity < 0) {  
45.         LOGV("[%lld] animation missing or unknown battery status\n", now);  
46.         charger->next_screen_transition = now + BATTERY_UNKNOWN_TIME;  
47.         batt_anim->cur_cycle++;  
48.         return;  
49.     }  
50.     /* schedule next screen transition */
51.     charger->next_screen_transition = now + disp_time;  
52.     /* advance frame cntr to the next valid frame 
53.      * if necessary, advance cycle cntr, and reset frame cntr 
54.      */
55.     batt_anim->cur_frame++;  
56.     /* if the frame is used for level-only, that is only show it when it's 
57.      * the current level, skip it during the animation. 
58.      */
59.     while (batt_anim->cur_frame < batt_anim->num_frames &&  
60.            batt_anim->frames[batt_anim->cur_frame].level_only)  
61.         batt_anim->cur_frame++;  
62.     if (batt_anim->cur_frame >= batt_anim->num_frames) {  
63.         batt_anim->cur_cycle++;  
64.         batt_anim->cur_frame = 0;  
65.         /* don't reset the cycle counter, since we use that as a signal 
66.          * in a test above to check if animation is over 
67.          */
68.     }  
69. }  

下面是 不同 電量時 顯示logo的函式：

1. staticstruct frame batt_anim_frames[] = {  
2.     {  
3.         .name = "charger/battery_0",  
4.         .disp_time = 750,  
5.         .min_capacity = 0,  
6.     },  
7.     {  
8.         .name = "charger/battery_1",  
9.         .disp_time = 750,  
10.         .min_capacity = 20,  
11.     },  
12.     {  
13.         .name = "charger/battery_2",  
14.         .disp_time = 750,  
15.         .min_capacity = 40,  
16.     },  
17.     {  
18.         .name = "charger/battery_3",  
19.         .disp_time = 750,  
20.         .min_capacity = 60,  
21.     },  
22.     {  
23.         .name = "charger/battery_4",  
24.         .disp_time = 750,  
25.         .min_capacity = 80,  
26.         .level_only = true,  
27.     },  
28.     {  
29.         .name = "charger/battery_5",  
30.         .disp_time = 750,  
31.         .min_capacity = BATTERY_FULL_THRESH,  
32.     },  
33. };