ESP32 屏幕刷新实验：比较局部更新、单缓冲和双缓冲

idf.py --version
# 必须ESP-IDF v5.5.5，在本工程根目录执行
idf.py -B build.single -D SDKCONFIG=sdkconfig.single -D SDKCONFIG_DEFAULTS=sdkconfig.defaults build
idf.py -B build.double -D SDKCONFIG=sdkconfig.double -D 'SDKCONFIG_DEFAULTS=sdkconfig.defaults;sdkconfig.double.defaults' build
idf.py -B build.single -p REPLACE_WITH_BOX3_PORT flash monitor
# 换双缓冲时改用 build.double；不要混用固件与日志标签

// ---- main/refresh_metrics.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdint.h>
#include <stdbool.h>
typedef struct {
 uint64_t render_started,flush_started,wait_started,touch_started;
 uint64_t render_count,render_us,render_max_us,flush_count,payload_bytes,submit_us,wait_us;
 uint64_t feedback_count,feedback_us,feedback_max_us,feedback_overwritten,feedback_timeout;
 bool in_render,in_flush,in_wait,touch_pending;
} refresh_metrics_t;
static inline void metrics_reset(refresh_metrics_t *m){*m=(refresh_metrics_t){0};}
static inline bool metrics_intersects(int32_t x1,int32_t y1,int32_t x2,int32_t y2){
 return x1<=x2&&y1<=y2&&x1<=307&&x2>=240&&y1<=35&&y2>=8;
}
static inline void metrics_touch(refresh_metrics_t *m,uint64_t now){
 if(m->touch_pending)++m->feedback_overwritten;
 m->touch_pending=true;m->touch_started=now;
}
static inline void metrics_expire_touch(refresh_metrics_t *m,uint64_t now){
 if(m->touch_pending&&now>=m->touch_started&&now-m->touch_started>2000000){m->touch_pending=false;++m->feedback_timeout;}
}
static inline void metrics_render_start(refresh_metrics_t *m,uint64_t now){m->render_started=now;m->in_render=true;}
static inline void metrics_render_end(refresh_metrics_t *m,uint64_t now){
 if(!m->in_render||now<m->render_started)return;
 uint64_t elapsed=now-m->render_started;++m->render_count;m->render_us+=elapsed;
 if(elapsed>m->render_max_us)m->render_max_us=elapsed;
 m->in_render=false;
}
static inline void metrics_flush_start(refresh_metrics_t *m,uint64_t now,int32_t x1,int32_t y1,int32_t x2,int32_t y2){
 metrics_expire_touch(m,now);
 m->flush_started=now;m->in_flush=true;++m->flush_count;
 /* Sum submitted clipped RGB565 areas, including repeated pixels. */
 if(x1<0)x1=0;
 if(y1<0)y1=0;
 if(x2>319)x2=319;
 if(y2>239)y2=239;
 if(x1<=x2&&y1<=y2)m->payload_bytes+=(uint64_t)(x2-x1+1)*(uint64_t)(y2-y1+1)*2;
 if(m->touch_pending&&now>=m->touch_started&&metrics_intersects(x1,y1,x2,y2)){
  uint64_t elapsed=now-m->touch_started;++m->feedback_count;m->feedback_us+=elapsed;
  if(elapsed>m->feedback_max_us)m->feedback_max_us=elapsed;
  m->touch_pending=false;
 }
}
static inline void metrics_flush_end(refresh_metrics_t *m,uint64_t now){
 if(m->in_flush&&now>=m->flush_started)m->submit_us+=now-m->flush_started;
 m->in_flush=false;
}
static inline void metrics_wait_start(refresh_metrics_t *m,uint64_t now){m->wait_started=now;m->in_wait=true;}
static inline void metrics_wait_end(refresh_metrics_t *m,uint64_t now){
 if(m->in_wait&&now>=m->wait_started)m->wait_us+=now-m->wait_started;
 m->in_wait=false;
}

// ---- main/main.c ----
/* SPDX-License-Identifier: MIT */
#include <stdio.h>
#include "driver/i2c_master.h"
#include "esp_log.h"
#include "esp_timer.h"
#include "esp_heap_caps.h"
#include "bsp/esp-bsp.h"
#include "bsp/display.h"
#include "lvgl.h"
#include "refresh_metrics.h"
static const char *TAG="refresh_lab";
/* Everything below belongs to LVGL's task; app_main holds its BSP lock to create. */
static refresh_metrics_t metrics;
static lv_obj_t *screen,*counter_label,*feedback_label,*mode_label;
static bool full_invalidate,measuring;
static uint64_t warmup_until,measured_since,last_report;
static uint32_t counter,touches;
static uint64_t now_us(void){return (uint64_t)esp_timer_get_time();}
static void display_event(lv_event_t *e){
 if(!measuring)return;
 uint64_t now=now_us();
 switch(lv_event_get_code(e)){
  case LV_EVENT_RENDER_START:metrics_render_start(&metrics,now);break;
  case LV_EVENT_RENDER_READY:metrics_render_end(&metrics,now);break;
  case LV_EVENT_FLUSH_START:{
   const lv_area_t *a=lv_event_get_param(e);
   if(a)metrics_flush_start(&metrics,now,a->x1,a->y1,a->x2,a->y2);
   break;
  }
  case LV_EVENT_FLUSH_FINISH:metrics_flush_end(&metrics,now);break;
  case LV_EVENT_FLUSH_WAIT_START:metrics_wait_start(&metrics,now);break;
  case LV_EVENT_FLUSH_WAIT_FINISH:metrics_wait_end(&metrics,now);break;
  default:break;
 }
 /* Never replace the port flush callback or call flush_ready here. */
}
static void restart_window(void){
 measuring=false;metrics_reset(&metrics);warmup_until=now_us()+2000000;
 lv_label_set_text(mode_label,full_invalidate?"Mode: full invalidation":"Mode: local changes");
}
static void mode_clicked(lv_event_t *e){
 (void)e;full_invalidate=!full_invalidate;restart_window();
}
static void reset_clicked(lv_event_t *e){(void)e;restart_window();}
static void touch_pressed(lv_event_t *e){
 (void)e;uint64_t pressed_at=now_us();++touches;
 lv_label_set_text_fmt(feedback_label,"T%lu",(unsigned long)(touches%10));
 lv_obj_set_style_bg_color(feedback_label,lv_color_hex(touches%2?0x206048:0x74284C),0);
 lv_obj_invalidate(feedback_label);
 if(measuring)metrics_touch(&metrics,pressed_at);
}
static void sample_tick(lv_timer_t *timer){
 (void)timer;uint64_t now=now_us();
 if(!measuring&&now>=warmup_until){metrics_reset(&metrics);measuring=true;measured_since=last_report=now;}
 lv_label_set_text_fmt(counter_label,"Count %06lu",(unsigned long)(++counter%1000000));
 if(full_invalidate)lv_obj_invalidate(screen);
 if(!measuring)return;
 metrics_expire_touch(&metrics,now);
 if(now-last_report<2000000)return;
 last_report=now;
 /* Cumulative after warmup. No reset halfway through an in-flight render. */
 printf("D08,%s,%u,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%llu,%u,%u,%u\n",
  full_invalidate?"full":"local",
#if CONFIG_BSP_LCD_DRAW_BUF_DOUBLE
  2U,
#else
  1U,
#endif
  (unsigned long long)(now-measured_since),
  (unsigned long long)metrics.render_count,(unsigned long long)metrics.render_us,(unsigned long long)metrics.render_max_us,
  (unsigned long long)metrics.flush_count,(unsigned long long)metrics.payload_bytes,(unsigned long long)metrics.submit_us,
  (unsigned long long)metrics.wait_us,(unsigned long long)metrics.feedback_count,(unsigned long long)metrics.feedback_us,
  (unsigned long long)metrics.feedback_max_us,(unsigned long long)metrics.feedback_overwritten,(unsigned long long)metrics.feedback_timeout,
  (unsigned)heap_caps_get_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT),
  (unsigned)heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT),
  (unsigned)heap_caps_get_minimum_free_size(MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT));
}
static lv_obj_t *label_at(int x,int y,const char *text){
 lv_obj_t *o=lv_label_create(screen);lv_obj_set_pos(o,x,y);lv_label_set_text(o,text);return o;
}
static void button_at(int x,const char *text,lv_event_cb_t callback){
 lv_obj_t *o=lv_button_create(screen);lv_obj_set_pos(o,x,174);lv_obj_set_size(o,140,44);
 lv_obj_add_event_cb(o,callback,LV_EVENT_CLICKED,NULL);
 lv_obj_t *t=lv_label_create(o);lv_label_set_text(t,text);lv_obj_center(t);
}
static void create_ui(void){
 screen=lv_screen_active();lv_obj_remove_flag(screen,LV_OBJ_FLAG_SCROLLABLE);
 lv_obj_set_style_bg_color(screen,lv_color_hex(0x101C2B),0);lv_obj_set_style_text_color(screen,lv_color_white(),0);
 label_at(12,12,"Refresh experiment");
 feedback_label=label_at(240,8,"T0");lv_obj_set_size(feedback_label,68,28);
 lv_obj_set_style_bg_opa(feedback_label,LV_OPA_COVER,0);lv_obj_set_style_text_align(feedback_label,LV_TEXT_ALIGN_CENTER,0);
 mode_label=label_at(12,58,"");counter_label=label_at(12,96,"");lv_obj_set_size(counter_label,230,28);
 label_at(12,138,"100ms source; software counters");
 button_at(12,"Full / Local",mode_clicked);button_at(168,"Reset window",reset_clicked);
 restart_window();lv_timer_create(sample_tick,100,NULL);
}
void app_main(void){
 ESP_ERROR_CHECK(bsp_i2c_init());i2c_master_bus_handle_t bus=bsp_i2c_get_handle();
 if(i2c_master_probe(bus,0x24,100)!=ESP_OK||i2c_master_probe(bus,0x5D,100)==ESP_OK||i2c_master_probe(bus,0x14,100)==ESP_OK){
  ESP_LOGE(TAG,"Require confirmed BOX3 TT21100/ST7789 combination; touch probe failed/other controller branch");return;
 }
 lv_display_t *disp=bsp_display_start();lv_indev_t *input=bsp_display_get_input_dev();
 if(!disp||!input){ESP_LOGE(TAG,"Display/touch allocation failed");return;}
 ESP_ERROR_CHECK(bsp_display_brightness_set(60));
 if(!bsp_display_lock(1000)){ESP_LOGE(TAG,"LVGL lock timeout");return;}
 create_ui();lv_display_add_event_cb(disp,display_event,LV_EVENT_ALL,NULL);
 lv_indev_add_event_cb(input,touch_pressed,LV_EVENT_PRESSED,NULL);bsp_display_unlock();
 ESP_LOGI(TAG,"320x240 RGB565, internal DMA strips 320x40; software submit != DMA completion != optical pass");
 puts("kind,mode,buffers,elapsed_us,render_cycles,render_elapsed_us,render_max_us,flush_submits,rgb565_submitted_bytes,submit_elapsed_us,wait_elapsed_us,feedback_submits,feedback_elapsed_us,feedback_max_us,feedback_overwritten,feedback_timeout,internal_free_bytes,internal_largest_bytes,internal_min_since_boot_bytes");
}

python3 tools/summarize.py run.log
cc -std=c11 -Wall -Wextra -Werror -I main host/host_check.c -o /tmp/d08-host
/tmp/d08-host
python3 host/summary_test.py