devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

U8g2图形库使用技巧记录（4）_u8g2库

作者：你好赵伟 | 2024-04-20 22:10:24

赞

踩

u8g2库

        ~最近在优化平衡车的UI界面~

        寻寻觅觅间，偶然在B站上看到一个很优雅的UI框架WouoUI，底层的oled驱动操作使用的是U8G2方式，于是花了点时间把它移植了过来(丙正正)，跑在小平衡车(小黑)上效果真的很哇塞，以一路foc电机+一个按钮作为输入；

~以下是UI的视频效果：

~以下是移植的源码，希望对想移植的后来者有所帮助：

  1. /************************************* 屏幕驱动 *************************************/
  2. //分辨率128*64，可以使用硬件IIC接口
  3. #include "flex_ui.h"
  4. #include "u8g2_ssd1306.h"
  5.  
  6. #include <driver/gpio.h>
  7. #include <driver/spi_master.h>
  8. #include <esp_log.h>
  9. #include <freertos/FreeRTOS.h>
  10. #include <freertos/task.h>
  11. #include "nvs_flash.h"
  12. #include "nvs.h"
  13.  
  14. #include "sbus.h"
  15. #include "param.h"
  16. #include "ms5611.h"
  17. #include "tle5012b.h"
  18. #include "drv_adc.h"
  19. #include "drv_motor.h"
  20. #include "stabilizer.h"
  21. #include <stdio.h>
  22. #include <string.h>
  23. #include <u8g2.h>
  24.  
  25. #include "wiring.h"
  26. #include "lv_math.h"
  27.  
  28. static const char *TAG = "flex_ui";
  29.  
  30. /************************************* 定义页面 *************************************/
  31.  
  32. //总目录，缩进表示页面层级
  33. enum 
  34. {
  35.   M_WINDOW,
  36.   M_SLEEP,
  37.     M_MAIN, 
  38.       M_EDITOR,
  39.         M_KNOB,
  40.           M_KRF,
  41.           M_KPF,
  42.       M_VOLT,
  43.       M_SETTING,
  44.         M_ABOUT,
  45. };
  46.  
  47. //状态，初始化标签
  48. enum
  49. {
  50.   S_FADE,       //转场动画
  51.   S_WINDOW,     //弹窗初始化
  52.   S_LAYER_IN,   //层级初始化
  53.   S_LAYER_OUT,  //层级初始化
  54.   S_NONE,       //直接选择页面
  55. };
  56.  
  57. //菜单结构体
  58. typedef struct MENU
  59. {
  60.   char *m_select;
  61. } M_SELECT;
  62.  
  63. /************************************* 定义内容 *************************************/
  64.  
  65. /************************************* 文字内容 *************************************/
  66.  
  67. M_SELECT main_menu[]
  68. {
  69.   {"Sleep"},
  70.   {"Editor"},
  71.   {"Volt"},
  72.   {"Setting"},
  73. };
  74.  
  75. M_SELECT editor_menu[]
  76. {
  77.   {"[ Editor ]"},
  78.   {"- Function 0"},
  79.   {"- Function 1"},
  80.   {"- Function 2"},
  81.   {"- Function 3"},
  82.   {"- Function 4"},
  83.   {"- Function 5"},
  84.   {"- Function 6"},
  85.   {"- Function 7"},
  86.   {"- Function 8"},
  87.   {"- Function 9"},
  88.   {"- Knob"},
  89. };
  90.  
  91. M_SELECT knob_menu[]
  92. {
  93.   {"[ Knob ]"},
  94.   {"# Rotate Func"},
  95.   {"$ Press Func"},
  96. };
  97.  
  98. M_SELECT krf_menu[]
  99. {
  100.   {"[ Rotate Function ]"},
  101.   {"--------------------------"},
  102.   {"= Disable"},
  103.   {"--------------------------"},
  104.   {"= Volume"},
  105.   {"= Brightness"},
  106.   {"--------------------------"},
  107. };
  108.  
  109. M_SELECT kpf_menu[]
  110. {
  111.   {"[ Press Function ]"},
  112.   {"--------------------------"},
  113.   {"= Disable"},
  114.   {"--------------------------"},
  115.   {"= A"},
  116.   {"= B"},
  117.   {"= C"},
  118.   {"= D"},
  119.   {"= E"},
  120.   {"= F"},
  121.   {"= G"},
  122.   {"= H"},
  123.   {"= I"},
  124.   {"= J"},
  125.   {"= K"},
  126.   {"= L"},
  127.   {"= M"},
  128.   {"= N"},
  129.   {"= O"},
  130.   {"= P"},
  131.   {"= Q"},
  132.   {"= R"},
  133.   {"= S"},
  134.   {"= T"},
  135.   {"= U"},
  136.   {"= V"},
  137.   {"= W"},
  138.   {"= X"},
  139.   {"= Y"},
  140.   {"= Z"},
  141.   {"--------------------------"},
  142.   {"= 0"},
  143.   {"= 1"},
  144.   {"= 2"},
  145.   {"= 3"},
  146.   {"= 4"},
  147.   {"= 5"},
  148.   {"= 6"},
  149.   {"= 7"},
  150.   {"= 8"},
  151.   {"= 9"},
  152.   {"--------------------------"},
  153.   {"= Esc"},
  154.   {"= F1"},
  155.   {"= F2"},
  156.   {"= F3"},
  157.   {"= F4"},
  158.   {"= F5"},
  159.   {"= F6"},
  160.   {"= F7"},
  161.   {"= F8"},
  162.   {"= F9"},
  163.   {"= F10"},
  164.   {"= F11"},
  165.   {"= F12"},
  166.   {"--------------------------"},
  167.   {"= Left Ctrl"},
  168.   {"= Left Shift"},
  169.   {"= Left Alt"},
  170.   {"= Left Win"},
  171.   {"= Right Ctrl"},
  172.   {"= Right Shift"},
  173.   {"= Right Alt"},
  174.   {"= Right Win"},
  175.   {"--------------------------"},
  176.   {"= Caps Lock"},
  177.   {"= Backspace"},
  178.   {"= Return"},
  179.   {"= Insert"},
  180.   {"= Delete"},
  181.   {"= Tab"},
  182.   {"--------------------------"},
  183.   {"= Home"},
  184.   {"= End"},
  185.   {"= Page Up"},
  186.   {"= Page Down"},
  187.   {"--------------------------"},
  188.   {"= Up Arrow"},
  189.   {"= Down Arrow"},
  190.   {"= Left Arrow"},
  191.   {"= Right Arrow"},
  192.   {"--------------------------"},
  193. };
  194.  
  195. M_SELECT volt_menu[]
  196. {
  197.   {"A0"},
  198.   {"A1"},
  199.   {"A2"},
  200.   {"A3"},
  201.   {"A4"},
  202.   {"A5"},
  203.   {"A6"},
  204.   {"A7"},
  205.   {"B0"},
  206.   {"B1"},
  207. };
  208.  
  209. M_SELECT setting_menu[]
  210. {
  211.   {"[ Setting ]"},
  212.   {"~ Disp Bri"},
  213.   {"~ Tile Ani"},
  214.   {"~ List Ani"},
  215.   {"~ Win Ani"},
  216.   {"~ Spot Ani"},
  217.   {"~ Tag Ani"},
  218.   {"~ Fade Ani"},
  219.   {"~ Btn SPT"},
  220.   {"~ Btn LPT"},
  221.   {"+ T Ufd Fm Scr"},
  222.   {"+ L Ufd Fm Scr"},
  223.   {"+ T Loop Mode"},
  224.   {"+ L Loop Mode"},
  225.   {"+ Win Bokeh Bg"},
  226.   {"+ Knob Rot Dir"},
  227.   {"+ Dark Mode"},
  228.   {"- [ About ]"},
  229. };
  230.  
  231. M_SELECT about_menu[]
  232. {
  233.   {"[ FlexUI ]"},
  234.   {"- Version: v1.0"},
  235.   {"- Board: ESP32 PICO"},
  236.   {"- Ram: 340k"},
  237.   {"- Flash: 4MB"},
  238.   {"- Freq: 240Mhz"},
  239.   {"- Creator: Leon"},
  240.   {"- Billi UID: 20230705"},  
  241. };
  242.  
  243. /************************************* 图片内容 *************************************/
  244.  
  245. const uint8_t main_icon_pic[][120]
  246. {
  247.   {
  248.     0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xF1,0x3F,
  249.     0xFF,0xFF,0xC3,0x3F,0xFF,0xFF,0x87,0x3F,0xFF,0xFF,0x07,0x3F,0xFF,0xFF,0x0F,0x3E,
  250.     0xFF,0xFF,0x0F,0x3E,0xFF,0xFF,0x0F,0x3C,0xFF,0xFF,0x0F,0x3C,0xFF,0xFF,0x0F,0x38,
  251.     0xFF,0xFF,0x0F,0x38,0xFF,0xFF,0x0F,0x38,0xFF,0xFF,0x07,0x38,0xFF,0xFF,0x07,0x38,
  252.     0xFF,0xFF,0x03,0x38,0xF7,0xFF,0x01,0x38,0xE7,0xFF,0x00,0x3C,0x87,0x3F,0x00,0x3C,
  253.     0x0F,0x00,0x00,0x3E,0x0F,0x00,0x00,0x3E,0x1F,0x00,0x00,0x3F,0x3F,0x00,0x80,0x3F,
  254.     0x7F,0x00,0xC0,0x3F,0xFF,0x01,0xF0,0x3F,0xFF,0x07,0xFC,0x3F,0xFF,0xFF,0xFF,0x3F,
  255.     0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F
  256.   },
  257.   {
  258.     0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,0xFF,0xF9,0xE7,0x3F,
  259.     0xFF,0xF9,0xE7,0x3F,0xFF,0xF9,0xE7,0x3F,0xFF,0xF0,0xE7,0x3F,0x7F,0xE0,0xE7,0x3F,
  260.     0x7F,0xE0,0xC3,0x3F,0x7F,0xE0,0xC3,0x3F,0x7F,0xE0,0xC3,0x3F,0x7F,0xE0,0xE7,0x3F,
  261.     0xFF,0xF0,0xE7,0x3F,0xFF,0xF9,0xE7,0x3F,0xFF,0xF9,0xE7,0x3F,0xFF,0xF9,0xE7,0x3F,
  262.     0xFF,0xF9,0xE7,0x3F,0xFF,0xF9,0xC3,0x3F,0xFF,0xF9,0x81,0x3F,0xFF,0xF0,0x81,0x3F,
  263.     0xFF,0xF0,0x81,0x3F,0xFF,0xF0,0x81,0x3F,0xFF,0xF9,0x81,0x3F,0xFF,0xF9,0xC3,0x3F,
  264.     0xFF,0xF9,0xE7,0x3F,0xFF,0xF9,0xE7,0x3F,0xFF,0xF9,0xE7,0x3F,0xFF,0xFF,0xFF,0x3F,
  265.     0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F
  266.   },
  267.   {
  268.     0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,0xEF,0xFF,0xFF,0x3F,0xC7,0xFF,0xFF,0x3F,
  269.     0xC7,0xF3,0xFF,0x3F,0x83,0xC0,0xFF,0x3F,0xEF,0xCC,0xFF,0x3F,0x6F,0x9E,0xFF,0x3F,
  270.     0x6F,0x9E,0xFF,0x3F,0x2F,0x3F,0xFF,0x3F,0x2F,0x3F,0xFF,0x3F,0x8F,0x7F,0xFE,0x3F,
  271.     0x8F,0x7F,0xFE,0x39,0x8F,0x7F,0xFE,0x39,0xCF,0xFF,0xFC,0x3C,0xCF,0xFF,0xFC,0x3C,
  272.     0xEF,0xFF,0xFC,0x3C,0xEF,0xFF,0x79,0x3E,0xEF,0xFF,0x79,0x3E,0xEF,0xFF,0x33,0x3F,
  273.     0xEF,0xFF,0x33,0x3F,0xEF,0xFF,0x87,0x3F,0xEF,0xFF,0xCF,0x3F,0xEF,0xFF,0x7F,0x3E,
  274.     0xEF,0xFF,0x7F,0x38,0x0F,0x00,0x00,0x30,0xFF,0xFF,0x7F,0x38,0xFF,0xFF,0x7F,0x3E,
  275.     0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,
  276.   },
  277.   {
  278.     0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,
  279.     0xFF,0x1F,0xFE,0x3F,0xFF,0x1F,0xFE,0x3F,0xFF,0x0C,0xCC,0x3F,0x7F,0x00,0x80,0x3F,
  280.     0x3F,0x00,0x00,0x3F,0x3F,0xE0,0x01,0x3F,0x7F,0xF8,0x87,0x3F,0x7F,0xFC,0x8F,0x3F,
  281.     0x3F,0xFC,0x0F,0x3F,0x0F,0x3E,0x1F,0x3C,0x0F,0x1E,0x1E,0x3C,0x0F,0x1E,0x1E,0x3C,
  282.     0x0F,0x3E,0x1F,0x3C,0x3F,0xFC,0x0F,0x3F,0x7F,0xFC,0x8F,0x3F,0x7F,0xF8,0x87,0x3F,
  283.     0x3F,0xE0,0x01,0x3F,0x3F,0x00,0x00,0x3F,0x7F,0x00,0x80,0x3F,0xFF,0x0C,0xCC,0x3F,
  284.     0xFF,0x1F,0xFE,0x3F,0xFF,0x1F,0xFE,0x3F,0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F,
  285.     0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0x3F
  286.   },
  287. };
  288.  
  289. /************************************* 页面变量 *************************************/
  290.  
  291. //OLED变量
  292. #define   DISP_H              64    //屏幕高度
  293. #define   DISP_W              128   //屏幕宽度
  294. uint8_t   *buf_ptr;                 //指向屏幕缓冲的指针
  295. uint16_t  buf_len;                  //缓冲长度
  296.  
  297. //UI变量
  298. #define   UI_DEPTH            20    //最深层级数
  299. #define   UI_MNUMB            100   //菜单数量
  300. #define   UI_PARAM            16    //参数数量
  301. enum 
  302. {
  303.   DISP_BRI,     //屏幕亮度
  304.   TILE_ANI,     //磁贴动画速度
  305.   LIST_ANI,     //列表动画速度
  306.   WIN_ANI,      //弹窗动画速度
  307.   SPOT_ANI,     //聚光动画速度
  308.   TAG_ANI,      //标签动画速度
  309.   FADE_ANI,     //消失动画速度
  310.   BTN_SPT,      //按键短按时长
  311.   BTN_LPT,      //按键长按时长
  312.   TILE_UFD,     //磁贴图标从头展开开关
  313.   LIST_UFD,     //菜单列表从头展开开关
  314.   TILE_LOOP,    //磁贴图标循环模式开关
  315.   LIST_LOOP,    //菜单列表循环模式开关
  316.   WIN_BOK,      //弹窗背景虚化开关
  317.   KNOB_DIR,     //旋钮方向切换开关
  318.   DARK_MODE,    //黑暗模式开关
  319. };
  320. struct 
  321. {
  322.   bool      init;
  323.   uint8_t   num[UI_MNUMB];
  324.   uint8_t   select[UI_DEPTH];
  325.   uint8_t   layer;
  326.   uint8_t   index = M_MAIN;
  327.   uint8_t   state = S_LAYER_IN;
  328.   bool      sleep = true;
  329.   uint8_t   fade = 1;
  330.   uint8_t   param[UI_PARAM];
  331. } ui;
  332.  
  333. //磁贴变量
  334. //所有磁贴页面都使用同一套参数
  335. #define   TILE_B_FONT         u8g2_font_helvB18_tr        //磁贴大标题字体
  336. #define   TILE_B_TITLE_H      18                          //磁贴大标题字体高度
  337. #define   TILE_ICON_H         30                          //磁贴图标高度
  338. #define   TILE_ICON_W         30                          //磁贴图标宽度
  339. #define   TILE_ICON_S         36                          //磁贴图标间距
  340. #define   TILE_INDI_H         27                          //磁贴大标题指示器高度
  341. #define   TILE_INDI_W         7                           //磁贴大标题指示器宽度
  342. #define   TILE_INDI_S         36                          //磁贴大标题指示器上边距
  343. struct 
  344. {
  345.   float   title_y_calc = TILE_INDI_S + (TILE_INDI_H - TILE_B_TITLE_H) / 2 + TILE_B_TITLE_H * 2;
  346.   float   title_y_trg_calc = TILE_INDI_S + (TILE_INDI_H - TILE_B_TITLE_H) / 2 + TILE_B_TITLE_H;
  347.   int16_t temp;
  348.   bool    select_flag;
  349.   float   icon_x;
  350.   float   icon_x_trg;
  351.   float   icon_y;
  352.   float   icon_y_trg;
  353.   float   indi_x; 
  354.   float   indi_x_trg;
  355.   float   title_y;
  356.   float   title_y_trg;
  357. } tile;
  358.  
  359. //列表变量
  360. //默认参数
  361.  
  362. #define   LIST_FONT           u8g2_font_HelvetiPixel_tr   //列表字体
  363. #define   LIST_TEXT_H         8                           //列表每行文字字体的高度
  364. #define   LIST_LINE_H         16                          //列表单行高度
  365. #define   LIST_TEXT_S         4                           //列表每行文字的上边距，左边距和右边距，下边距由它和字体高度和行高度决定
  366. #define   LIST_BAR_W          5                           //列表进度条宽度，需要是奇数，因为正中间有1像素宽度的线
  367. #define   LIST_BOX_R          0.5                         //列表选择框圆角
  368.  
  369. /*
  370. //超窄行高度测试
  371. #define   LIST_FONT           u8g2_font_4x6_tr            //列表字体
  372. #define   LIST_TEXT_H         5                           //列表每行文字字体的高度
  373. #define   LIST_LINE_H         7                           //列表单行高度
  374. #define   LIST_TEXT_S         1                           //列表每行文字的上边距，左边距和右边距，下边距由它和字体高度和行高度决定
  375. #define   LIST_BAR_W          7                           //列表进度条宽度，需要是奇数，因为正中间有1像素宽度的线
  376. #define   LIST_BOX_R          0.5                         //列表选择框圆角
  377. */
  378. struct
  379. {
  380.   uint8_t line_n = DISP_H / LIST_LINE_H;
  381.   int16_t temp;
  382.   bool    loop;
  383.   float   y;
  384.   float   y_trg;
  385.   float   box_x;
  386.   float   box_x_trg;
  387.   float   box_y;
  388.   float   box_y_trg[UI_DEPTH];
  389.   float   bar_y;
  390.   float   bar_y_trg;
  391. } list;
  392.  
  393. //曲线相关
  394. #define   WAVE_SAMPLE         20                          //采集倍数
  395. #define   WAVE_W              94                          //波形宽度
  396. #define   WAVE_L              24                          //波形左边距
  397. #define   WAVE_U              0                           //波形上边距
  398. #define   WAVE_MAX            27                          //最大值
  399. #define   WAVE_MIN            4                           //最小值
  400. #define   WAVE_BOX_H          32                          //波形边框高度
  401. #define   WAVE_BOX_W          94                          //波形边框宽度
  402. #define   WAVE_BOX_L_S        24                          //波形边框左边距
  403. //列表和文字背景框相关
  404. #define   VOLT_FONT           u8g2_font_helvB18_tr        //电压数字字体
  405. #define   VOLT_TEXT_BG_L_S    24                          //文字背景框左边距
  406. #define   VOLT_TEXT_BG_W      94                          //文字背景框宽度
  407. #define   VOLT_TEXT_BG_H      29                          //文字背景框高度
  408. struct
  409. {
  410.   int     ch0_adc[WAVE_SAMPLE * WAVE_W];
  411.   int     ch0_wave[WAVE_W];
  412.   int     val;
  413.   float   text_bg_r; 
  414.   float   text_bg_r_trg; 
  415. } volt;
  416.  
  417.  
  418. //选择框变量
  419.  
  420. //默认参数
  421. #define   CHECK_BOX_L_S       95                          //选择框在每行的左边距
  422. #define   CHECK_BOX_U_S       2                           //选择框在每行的上边距
  423. #define   CHECK_BOX_F_W       12                          //选择框外框宽度
  424. #define   CHECK_BOX_F_H       12                          //选择框外框高度
  425. #define   CHECK_BOX_D_S       2                           //选择框里面的点距离外框的边距
  426.  
  427. /*
  428. //超窄行高度测试
  429. #define   CHECK_BOX_L_S       99                          //选择框在每行的左边距
  430. #define   CHECK_BOX_U_S       0                           //选择框在每行的上边距
  431. #define   CHECK_BOX_F_W       5                           //选择框外框宽度
  432. #define   CHECK_BOX_F_H       5                           //选择框外框高度
  433. #define   CHECK_BOX_D_S       1                           //选择框里面的点距离外框的边距
  434. */
  435. struct
  436. {
  437.   uint8_t *v;
  438.   uint8_t *m;
  439.   uint8_t *s;
  440.   uint8_t *s_p;
  441. } check_box;
  442.  
  443. //弹窗变量
  444. #define   WIN_FONT            u8g2_font_HelvetiPixel_tr   //弹窗字体
  445. #define   WIN_H               32                          //弹窗高度
  446. #define   WIN_W               102                         //弹窗宽度
  447. #define   WIN_BAR_W           92                          //弹窗进度条宽度
  448. #define   WIN_BAR_H           7                           //弹窗进度条高度
  449. #define   WIN_Y               - WIN_H - 2                 //弹窗竖直方向出场起始位置
  450. #define   WIN_Y_TRG           - WIN_H - 2                 //弹窗竖直方向退场终止位置
  451. struct
  452. {
  453.   //uint8_t
  454.   uint8_t   *value;
  455.   uint8_t   max;
  456.   uint8_t   min;
  457.   uint8_t   step;
  458.  
  459.   MENU      *bg;
  460.   uint8_t   index;
  461.   char      title[20];
  462.   uint8_t   select;
  463.   uint8_t   l = (DISP_W - WIN_W) / 2;
  464.   uint8_t   u = (DISP_H - WIN_H) / 2;
  465.   float     bar;
  466.   float     bar_trg;
  467.   float     y;
  468.   float     y_trg;
  469. } win;
  470.  
  471. //聚光灯变量
  472. struct
  473. {
  474.   float   l; 
  475.   float   l_trg; 
  476.   float   r; 
  477.   float   r_trg; 
  478.   float   u; 
  479.   float   u_trg; 
  480.   float   d; 
  481.   float   d_trg; 
  482. } spot;
  483.  
  484. /********************************** 自定义功能变量 **********************************/
  485.  
  486. //旋钮功能变量
  487. #define   KNOB_PARAM          4
  488. #define   KNOB_DISABLE        0
  489. #define   KNOB_ROT_VOL        1
  490. #define   KNOB_ROT_BRI        2
  491. enum 
  492. {
  493.   KNOB_ROT,       //睡眠下旋转旋钮的功能，0 禁用，1 音量，2 亮度
  494.   KNOB_COD,       //睡眠下短按旋钮输入的字符码，0 禁用
  495.   KNOB_ROT_P,     //旋转旋钮功能在单选框中选择的位置
  496.   KNOB_COD_P,     //字符码在单选框中选择的位置
  497. };
  498. struct 
  499. {
  500.   uint8_t param[KNOB_PARAM] = { KNOB_DISABLE, KNOB_DISABLE, 2, 2 }; //禁用在列表的第2个选项，第0个是标题，第1个是分界线
  501. } knob;
  502.  
  503. /************************************* 断电保存 *************************************/
  504.  
  505. //#include <EEPROM.h>
  506.  
  507. //EEPROM变量
  508. #define   EEPROM_CHECK        11
  509. struct
  510. {
  511.   bool    init;
  512.   bool    change;
  513.   int     address;
  514.   uint8_t check;
  515.   uint8_t check_param[EEPROM_CHECK] = { 'a', 'b', 'c', 'd', 'e', 'f','g', 'h', 'i', 'j', 'k' }; 
  516. } eeprom;
  517.  
  518. //EEPROM写数据，回到睡眠时执行一遍
  519. void eeprom_write_all_data()
  520. {
  521. #if 0
  522.   eeprom.address = 0;
  523.   for (uint8_t i = 0; i < EEPROM_CHECK; ++i)    EEPROM.write(eeprom.address + i, eeprom.check_param[i]);  eeprom.address += EEPROM_CHECK;
  524.   for (uint8_t i = 0; i < UI_PARAM; ++i)        EEPROM.write(eeprom.address + i, ui.param[i]);            eeprom.address += UI_PARAM;
  525.   for (uint8_t i = 0; i < KNOB_PARAM; ++i)      EEPROM.write(eeprom.address + i, knob.param[i]);          eeprom.address += KNOB_PARAM;
  526. #else
  527. 	nvs_handle handle;
  528. 	int32_t err;
  529.  
  530. 	// Open
  531. 	err = nvs_open(STORAGE_NAMESPACE, NVS_READWRITE, &handle);
  532. 	if (err != ESP_OK) goto err;
  533.  
  534. 	err = nvs_set_blob(handle, "ui_param_ck", eeprom.check_param, EEPROM_CHECK);
  535. 	if (err != ESP_OK) goto err;
  536.  
  537. 	err = nvs_set_blob(handle, "ui_param",    ui.param,   		  UI_PARAM);
  538. 	if (err != ESP_OK) goto err;
  539.  
  540. 	err = nvs_set_blob(handle, "knob_param",  knob.param, 		  KNOB_PARAM);
  541. 	if (err != ESP_OK) goto err;
  542.  
  543. 	
  544. 	ESP_LOGI(TAG, "param write all finish!");
  545.  
  546. 	err = nvs_commit(handle);
  547. 	if (err != ESP_OK) goto err;
  548.  
  549. err:
  550. 	// Close
  551. 	nvs_close(handle);
  552. #endif
  553. }
  554.  
  555. //EEPROM读数据，开机初始化时执行一遍
  556. void eeprom_read_all_data()
  557. {
  558. #if 0
  559.   eeprom.address = EEPROM_CHECK;   
  560.   for (uint8_t i = 0; i < UI_PARAM; ++i)        ui.param[i]   = EEPROM.read(eeprom.address + i);          eeprom.address += UI_PARAM;
  561.   for (uint8_t i = 0; i < KNOB_PARAM; ++i)      knob.param[i] = EEPROM.read(eeprom.address + i);          eeprom.address += KNOB_PARAM;
  562. #else
  563. 	nvs_handle handle;
  564. 	size_t length;
  565. 	int32_t err;
  566.  
  567. 	// Open
  568. 	err = nvs_open(STORAGE_NAMESPACE, NVS_READWRITE, &handle);
  569. 	if (err != ESP_OK) goto err;
  570.  
  571. 	err = nvs_get_blob(handle, "ui_param",   NULL, &length);
  572. 	err = nvs_get_blob(handle, "ui_param",   ui.param, &length);
  573. 	if (err != ESP_OK) goto err;
  574.  
  575. 	err = nvs_get_blob(handle, "knob_param", NULL, &length);
  576. 	err = nvs_get_blob(handle, "knob_param", knob.param, &length);
  577. 	if (err != ESP_OK) goto err;
  578.  
  579. 	ESP_LOGI(TAG, "param read all finish!");
  580.  
  581. err:
  582. 	// Close
  583. 	nvs_close(handle);
  584.  
  585. #endif
  586. }
  587.  
  588. //开机检查是否已经修改过，没修改过则跳过读配置步骤，用默认设置
  589. void eeprom_init()
  590. {
  591. #if 0
  592.   eeprom.check = 0;
  593.   eeprom.address = 0; for (uint8_t i = 0; i < EEPROM_CHECK; ++i)  if (EEPROM.read(eeprom.address + i) != eeprom.check_param[i])  eeprom.check ++;
  594.   if (eeprom.check <= 1) eeprom_read_all_data();  //允许一位误码
  595.   else ui_param_init();
  596. #else
  597. 	nvs_handle handle;
  598. 	size_t length;
  599. 	int32_t err;
  600.  
  601. 	uint8_t check_param[EEPROM_CHECK] = {0};
  602.  
  603. 	// Open
  604. 	err = nvs_open(STORAGE_NAMESPACE, NVS_READWRITE, &handle);
  605. 	if (err != ESP_OK) goto err;
  606.  
  607. 	err = nvs_get_blob(handle, "ui_param_ck", NULL, &length);
  608. 	err = nvs_get_blob(handle, "ui_param_ck", check_param, &length);
  609. 	
  610. 	if (err != ESP_OK) {
  611. 		ui_param_init();
  612. 		goto err;
  613. 	}
  614.  
  615. 	eeprom.check = 0;
  616. 	eeprom.address = 0; for (uint8_t i = 0; i < EEPROM_CHECK; ++i)	if (check_param[i] != eeprom.check_param[i])  eeprom.check ++;
  617. 	if (eeprom.check <= 1) eeprom_read_all_data();	//允许一位误码
  618. 	else ui_param_init();
  619.  
  620. 	ESP_LOGI(TAG, "ui param check pass!");
  621.  
  622. err:
  623. 	// Close
  624. 	nvs_close(handle);
  625. #endif
  626. }
  627.  
  628. /************************************* 旋钮相关 *************************************/
  629.  
  630. //可按下旋钮引脚
  631. #define   AIO   PB12
  632. #define   BIO   PB13
  633. //#define   SW    PB14
  634. #define   SW    34
  635.  
  636. //按键ID
  637. #define   BTN_ID_CC           0   //逆时针旋转
  638. #define   BTN_ID_CW           1   //顺时针旋转
  639. #define   BTN_ID_SP           2   //短按
  640. #define   BTN_ID_LP           3   //长按
  641.  
  642. //按键变量
  643. #define   BTN_PARAM_TIMES     2   //由于uint8_t最大值可能不够，但它存储起来方便，这里放大两倍使用
  644. struct
  645. {
  646.   uint8_t   id;
  647.   bool      flag;
  648.   bool      pressed;
  649.   bool      CW_1;
  650.   bool      CW_2;
  651.   bool      val;
  652.   bool      val_last;  
  653.   bool      alv;  
  654.   bool      blv;
  655.   long      count;
  656. } volatile btn;
  657.  
  658. void knob_inter() 
  659. {
  660. #if 0
  661.   btn.alv = digitalRead(AIO);
  662.   btn.blv = digitalRead(BIO);
  663.   if (!btn.flag && btn.alv == LOW) 
  664.   {
  665.     btn.CW_1 = btn.blv;
  666.     btn.flag = true;
  667.   }
  668.   if (btn.flag && btn.alv) 
  669.   {
  670.     btn.CW_2 = !btn.blv;
  671.     if (btn.CW_1 && btn.CW_2)
  672.      {
  673.       btn.id = ui.param[KNOB_DIR];
  674.       btn.pressed = true;
  675.     }
  676.     if (btn.CW_1 == false && btn.CW_2 == false) 
  677.     {
  678.       btn.id = !ui.param[KNOB_DIR];
  679.       btn.pressed = true;
  680.     }
  681.     btn.flag = false;
  682.   }
  683. #else
  684. 	if (btn.pressed == false) {
  685. 	  if (motor_a.pos_spd_ltd.v2 > 60) {
  686. 		btn.id = !ui.param[KNOB_DIR];
  687. 		btn.pressed = true;
  688. 	  } else if (motor_a.pos_spd_ltd.v2 < -60) {
  689. 		btn.id = ui.param[KNOB_DIR];
  690. 		btn.pressed = true;
  691. 	  } else {
  692. 		btn.pressed = false;
  693. 	  }
  694. 	}
  695. #endif
  696. }
  697.  
  698. void btn_scan() 
  699. {
  700.   btn.val = digitalRead(SW);
  701.   if (btn.val != btn.val_last)
  702.   {
  703.     btn.val_last = btn.val;
  704.     delay(ui.param[BTN_SPT] * BTN_PARAM_TIMES);
  705.     btn.val = digitalRead(SW);
  706.     if (btn.val == LOW)
  707.     {
  708.       btn.pressed = true;
  709.       btn.count = 0;
  710.       while (!digitalRead(SW))
  711.       {
  712.         btn.count++;
  713.         delay(1);
  714.       }
  715.       if (btn.count < ui.param[BTN_LPT] * BTN_PARAM_TIMES)  btn.id = BTN_ID_SP;
  716.       else  btn.id = BTN_ID_LP;
  717. 	  ESP_LOGI(TAG, "btn_scan:%d/%d=%d", btn.count, (ui.param[BTN_LPT] * BTN_PARAM_TIMES), btn.id);
  718.     }
  719.   }
  720. }
  721.  
  722. void btn_init() 
  723. {
  724. #if 0
  725.   pinMode(AIO, INPUT);
  726.   pinMode(BIO, INPUT);
  727.   pinMode(SW, INPUT_PULLUP);
  728.   attachInterrupt(digitalPinToInterrupt(AIO), knob_inter, CHANGE);
  729. #else
  730.  
  731. #endif
  732. }
  733.  
  734. /************************************ 初始化函数 ***********************************/
  735.  
  736. /********************************* 初始化数据处理函数 *******************************/
  737.  
  738. //显示数值的初始化
  739. void check_box_v_init(uint8_t *param)
  740. {
  741.   check_box.v = param;
  742. }
  743.  
  744. //多选框的初始化
  745. void check_box_m_init(uint8_t *param)
  746. {
  747.   check_box.m = param;
  748. }
  749.  
  750. //单选框时的初始化
  751. void check_box_s_init(uint8_t *param, uint8_t *param_p)
  752. {
  753.   check_box.s = param;
  754.   check_box.s_p = param_p;
  755. }
  756.  
  757. //多选框处理函数
  758. void check_box_m_select(uint8_t param)
  759. {
  760.   check_box.m[param] = !check_box.m[param];
  761.   eeprom.change = true;
  762. }
  763.  
  764. //单选框处理函数
  765. void check_box_s_select(uint8_t val, uint8_t pos)
  766. {
  767.   *check_box.s = val;
  768.   *check_box.s_p = pos;
  769.   eeprom.change = true;
  770. }
  771.  
  772. //弹窗数值初始化
  773. void window_value_init(char title[], uint8_t select, uint8_t *value, uint8_t max, uint8_t min, uint8_t step, MENU *bg, uint8_t index)
  774. {
  775.   strcpy(win.title, title);
  776.   win.select = select;
  777.   win.value = value;
  778.   win.max = max;
  779.   win.min = min;
  780.   win.step = step;
  781.   win.bg = bg;
  782.   win.index = index;  
  783.   ui.index = M_WINDOW;
  784.   ui.state = S_WINDOW;
  785. }
  786.  
  787. /*********************************** UI 初始化函数 *********************************/
  788.  
  789. //在初始化EEPROM时，选择性初始化的默认设置
  790. void ui_param_init()
  791. {
  792.   ui.param[DISP_BRI]  = 255;      //屏幕亮度
  793.   ui.param[TILE_ANI]  = 30;       //磁贴动画速度
  794.   ui.param[LIST_ANI]  = 60;       //列表动画速度
  795.   ui.param[WIN_ANI]   = 25;       //弹窗动画速度
  796.   ui.param[SPOT_ANI]  = 50;       //聚光动画速度
  797.   ui.param[TAG_ANI]   = 60;       //标签动画速度
  798.   ui.param[FADE_ANI]  = 30;       //消失动画速度
  799.   ui.param[BTN_SPT]   = 25;       //按键短按时长
  800.   ui.param[BTN_LPT]   = 150;      //按键长按时长
  801.   ui.param[TILE_UFD]  = 1;        //磁贴图标从头展开开关
  802.   ui.param[LIST_UFD]  = 1;        //菜单列表从头展开开关
  803.   ui.param[TILE_LOOP] = 0;        //磁贴图标循环模式开关
  804.   ui.param[LIST_LOOP] = 0;        //菜单列表循环模式开关
  805.   ui.param[WIN_BOK]   = 0;        //弹窗背景虚化开关
  806.   ui.param[KNOB_DIR]  = 0;        //旋钮方向切换开关   
  807.   ui.param[DARK_MODE] = 1;        //黑暗模式开关   
  808. }
  809.  
  810. //列表类页面列表行数初始化，必须初始化的参数
  811. void ui_init()
  812. {
  813.   ui.num[M_MAIN]      = sizeof( main_menu     )   / sizeof(M_SELECT);
  814.   ui.num[M_EDITOR]    = sizeof( editor_menu   )   / sizeof(M_SELECT);
  815.   ui.num[M_KNOB]      = sizeof( knob_menu     )   / sizeof(M_SELECT);
  816.   ui.num[M_KRF]       = sizeof( krf_menu      )   / sizeof(M_SELECT);
  817.   ui.num[M_KPF]       = sizeof( kpf_menu      )   / sizeof(M_SELECT);
  818.   ui.num[M_VOLT]      = sizeof( volt_menu     )   / sizeof(M_SELECT);
  819.   ui.num[M_SETTING]   = sizeof( setting_menu  )   / sizeof(M_SELECT);
  820.   ui.num[M_ABOUT]     = sizeof( about_menu    )   / sizeof(M_SELECT);   
  821. }
  822.  
  823. /********************************* 分页面初始化函数 ********************************/
  824.  
  825. //进入磁贴类时的初始化
  826. void tile_param_init()
  827. {
  828.   ui.init = false;
  829.   tile.icon_x = 0;
  830.   tile.icon_x_trg = TILE_ICON_S;
  831.   tile.icon_y = -TILE_ICON_H;
  832.   tile.icon_y_trg = 0;
  833.   tile.indi_x = 0;
  834.   tile.indi_x_trg = TILE_INDI_W;
  835.   tile.title_y = tile.title_y_calc;
  836.   tile.title_y_trg = tile.title_y_trg_calc;
  837. }
  838.  
  839. //进入睡眠时的初始化
  840. void sleep_param_init()
  841. {
  842. //#ifdef ARDUINO
  843. #if 0
  844.   u8g2.setDrawColor(0);
  845.   u8g2.drawBox(0, 0, DISP_W, DISP_H);
  846.   u8g2.setPowerSave(1);
  847. #else
  848.   u8g2_SetDrawColor(&u8g2, 0);
  849.   u8g2_DrawBox(&u8g2, 0, 0, DISP_W, DISP_H);
  850.   //u8g2_SetPowerSave(&u8g2, 1);
  851. #endif
  852.   ui.state = S_NONE;  
  853.   ui.sleep = true;
  854.   if (eeprom.change)
  855.   {
  856.     eeprom_write_all_data();
  857.     eeprom.change = false;
  858.   }
  859. }
  860.  
  861. //旋钮设置页初始化
  862. void knob_param_init() { check_box_v_init(knob.param); }
  863.  
  864. //旋钮旋转页初始化
  865. void krf_param_init() { check_box_s_init(&knob.param[KNOB_ROT], &knob.param[KNOB_ROT_P]); }
  866.  
  867. //旋钮点按页初始化
  868. void kpf_param_init() { check_box_s_init(&knob.param[KNOB_COD], &knob.param[KNOB_COD_P]); }
  869.  
  870. //电压测量页初始化
  871. void volt_param_init()
  872. {
  873.   volt.text_bg_r = 0;
  874.   volt.text_bg_r_trg = VOLT_TEXT_BG_W; 
  875. }
  876.  
  877. //设置页初始化
  878. void setting_param_init()
  879. {
  880.   check_box_v_init(ui.param);
  881.   check_box_m_init(ui.param);
  882. }
  883.  
  884. /********************************** 通用初始化函数 *********************************/
  885.  
  886. /*
  887.   页面层级管理逻辑是，把所有页面都先当作列表类初始化，不是列表类按需求再初始化对应函数
  888.   这样做会浪费一些资源，但跳转页面时只需要考虑页面层级，逻辑上更清晰，减少出错
  889. */
  890.  
  891. //弹窗动画初始化
  892. void window_param_init()
  893. {
  894.   win.bar = 0;
  895.   win.y = WIN_Y;
  896.   win.y_trg = win.u;
  897.   ui.state = S_NONE;
  898. }
  899.  
  900. //进入更深层级时的初始化
  901. void layer_init_in()
  902. {
  903.   ui.layer ++;
  904.   ui.init = 0;
  905.   list.y = 0;
  906.   list.y_trg = LIST_LINE_H;
  907.   list.box_x = 0;
  908.   list.box_y = 0;
  909.   list.bar_y = 0;
  910.   ui.state = S_FADE;
  911.   switch (ui.index)
  912.   {
  913.     case M_MAIN:    tile_param_init();    break;  //睡眠进入主菜单，动画初始化   
  914.     case M_KNOB:    knob_param_init();    break;  //旋钮设置页，行末尾文字初始化
  915.     case M_KRF:     krf_param_init();     break;  //旋钮旋转页，单选框初始化  
  916.     case M_KPF:     kpf_param_init();     break;  //旋钮点按页，单选框初始化  
  917.     case M_VOLT:    volt_param_init();    break;  //主菜单进入电压测量页，动画初始化
  918.     case M_SETTING: setting_param_init(); break;  //主菜单进入设置页，单选框初始化
  919.   }
  920. }
  921.  
  922. //进入更浅层级时的初始化
  923. void layer_init_out()
  924. {
  925.   ui.select[ui.layer] = 0;
  926.   list.box_y_trg[ui.layer] = 0;
  927.   ui.layer --;
  928.   ui.init = 0;
  929.   list.y = 0;
  930.   list.y_trg = LIST_LINE_H;
  931.   list.bar_y = 0;
  932.   ui.state = S_FADE;
  933.   switch (ui.index)
  934.   {
  935.     case M_SLEEP: sleep_param_init(); break;    //主菜单进入睡眠页，检查是否需要写EEPROM
  936.     case M_MAIN:  tile_param_init();  break;    //不管什么页面进入主菜单时，动画初始化
  937.   }
  938. }
  939.  
  940. /************************************* 动画函数 *************************************/
  941.  
  942. //动画函数
  943. void animation(float *a, float *a_trg, uint8_t n)
  944. {
  945.   if (fabs(*a - *a_trg) < 0.15) *a = *a_trg;
  946.   if (*a != *a_trg) *a += (*a_trg - *a) / (ui.param[n] / 10.0);
  947. }
  948.  
  949. //消失函数
  950. void fade()
  951. {
  952.   delay(ui.param[FADE_ANI]);
  953.   if (ui.param[DARK_MODE])
  954.   {
  955.     switch (ui.fade)
  956.     {
  957.       case 1: for (uint16_t i = 0; i < buf_len; ++i)  if (i % 2 != 0) buf_ptr[i] = buf_ptr[i] & 0xAA; break;
  958.       case 2: for (uint16_t i = 0; i < buf_len; ++i)  if (i % 2 != 0) buf_ptr[i] = buf_ptr[i] & 0x00; break;
  959.       case 3: for (uint16_t i = 0; i < buf_len; ++i)  if (i % 2 == 0) buf_ptr[i] = buf_ptr[i] & 0x55; break;
  960.       case 4: for (uint16_t i = 0; i < buf_len; ++i)  if (i % 2 == 0) buf_ptr[i] = buf_ptr[i] & 0x00; break;
  961.       default: ui.state = S_NONE; ui.fade = 0; break;
  962.     }
  963.   }
  964.   else
  965.   {
  966.     switch (ui.fade)
  967.     {
  968.       case 1: for (uint16_t i = 0; i < buf_len; ++i)  if (i % 2 != 0) buf_ptr[i] = buf_ptr[i] | 0xAA; break;
  969.       case 2: for (uint16_t i = 0; i < buf_len; ++i)  if (i % 2 != 0) buf_ptr[i] = buf_ptr[i] | 0x00; break;
  970.       case 3: for (uint16_t i = 0; i < buf_len; ++i)  if (i % 2 == 0) buf_ptr[i] = buf_ptr[i] | 0x55; break;
  971.       case 4: for (uint16_t i = 0; i < buf_len; ++i)  if (i % 2 == 0) buf_ptr[i] = buf_ptr[i] | 0x00; break;
  972.       default: ui.state = S_NONE; ui.fade = 0; break;
  973.     }    
  974.   }
  975.   ui.fade++;
  976. }
  977.  
  978. /************************************* 显示函数 *************************************/
  979.  
  980. //磁贴类页面通用显示函数
  981. void tile_show(struct MENU arr_1[], const uint8_t icon_pic[][120])
  982. {
  983.   //计算动画过渡值
  984.   animation(&tile.icon_x, &tile.icon_x_trg, TILE_ANI);
  985.   animation(&tile.icon_y, &tile.icon_y_trg, TILE_ANI);
  986.   animation(&tile.indi_x, &tile.indi_x_trg, TILE_ANI);
  987.   animation(&tile.title_y, &tile.title_y_trg, TILE_ANI);
  988.  
  989.   //设置大标题的颜色，0透显，1实显，2反色，这里用实显
  990.   //u8g2.setDrawColor(1);
  991.   u8g2_SetDrawColor(&u8g2, 1);
  992.  
  993.   //绘制大标题
  994.   //u8g2.setFont(TILE_B_FONT); 
  995.   //u8g2.drawStr(((DISP_W - TILE_INDI_W) - u8g2.getStrWidth(arr_1[ui.select[ui.layer]].m_select)) / 2 + TILE_INDI_W, tile.title_y, arr_1[ui.select[ui.layer]].m_select);
  996.   u8g2_SetFont(&u8g2, TILE_B_FONT);
  997.   u8g2_DrawStr(&u8g2, ((DISP_W - TILE_INDI_W) - u8g2_GetStrWidth(&u8g2, arr_1[ui.select[ui.layer]].m_select)) / 2 + TILE_INDI_W, tile.title_y, arr_1[ui.select[ui.layer]].m_select);
  998.  
  999.   //绘制大标题指示器
  1000.   //u8g2.drawBox(0, TILE_ICON_S, tile.indi_x, TILE_INDI_H);
  1001.   u8g2_DrawBox(&u8g2, 0, TILE_ICON_S, tile.indi_x, TILE_INDI_H); 
  1002.  
  1003.   //绘制图标
  1004.   if (!ui.init)
  1005.   {
  1006.     for (uint8_t i = 0; i < ui.num[ui.index]; ++i)  
  1007.     {
  1008.       if (ui.param[TILE_UFD]) tile.temp = (DISP_W - TILE_ICON_W) / 2 + i * tile.icon_x - TILE_ICON_S * ui.select[ui.layer];
  1009.       else tile.temp = (DISP_W - TILE_ICON_W) / 2 + (i - ui.select[ui.layer]) * tile.icon_x;
  1010.       //u8g2.drawXBMP(tile.temp, (int16_t)tile.icon_y, TILE_ICON_W, TILE_ICON_H, icon_pic[i]); 
  1011.       u8g2_DrawXBMP(&u8g2, tile.temp, (int16_t)tile.icon_y, TILE_ICON_W, TILE_ICON_H, icon_pic[i]); 
  1012.     }
  1013.     if (tile.icon_x == tile.icon_x_trg) 
  1014.     {
  1015.       ui.init = true;
  1016.       tile.icon_x = tile.icon_x_trg = - ui.select[ui.layer] * TILE_ICON_S;
  1017.     }
  1018.   }
  1019.   else for (uint8_t i = 0; i < ui.num[ui.index]; ++i) 
  1020.   	//u8g2.drawXBMP((DISP_W - TILE_ICON_W) / 2 + (int16_t)tile.icon_x + i * TILE_ICON_S, 0, TILE_ICON_W, TILE_ICON_H, icon_pic[i]);
  1021.   	u8g2_DrawXBMP(&u8g2, (DISP_W - TILE_ICON_W) / 2 + (int16_t)tile.icon_x + i * TILE_ICON_S, 0, TILE_ICON_W, TILE_ICON_H, icon_pic[i]);
  1022.  
  1023.  
  1024.   //反转屏幕内元素颜色，白天模式遮罩
  1025.   //u8g2.setDrawColor(2);
  1026.   u8g2_SetDrawColor(&u8g2, 2);
  1027.   if (!ui.param[DARK_MODE]) 
  1028.   	//u8g2.drawBox(0, 0, DISP_W, DISP_H);
  1029.   	u8g2_DrawBox(&u8g2, 0, 0, DISP_W, DISP_H);
  1030. }
  1031.  
  1032. static u8g2_uint_t u8g2_cursor_x = 0;
  1033. static u8g2_uint_t u8g2_cursor_y = 0;
  1034.  
  1035. static void u8g2_setCursor(u8g2_uint_t x, u8g2_uint_t y) {
  1036. 	u8g2_cursor_x = x;
  1037. 	u8g2_cursor_y = y;
  1038. }
  1039.  
  1040. static u8g2_uint_t u8g2_print(const char *str) { 
  1041. 	u8g2_uint_t delta = u8g2_DrawStr(&u8g2, u8g2_cursor_x, u8g2_cursor_y, str);
  1042. 	u8g2_cursor_x += delta;
  1043. 	if (u8g2_cursor_x > DISP_W) u8g2_cursor_x=0;
  1044. 	return delta;
  1045. }
  1046.  
  1047. #define DEC 10
  1048. #define HEX 16
  1049. #define OCT 8
  1050. #define BIN 2
  1051. static u8g2_uint_t printNumber(unsigned long n, uint8_t base)
  1052. {
  1053.     char buf[8 * sizeof(n) + 1]; // Assumes 8-bit chars plus zero byte.
  1054.     char *str = &buf[sizeof(buf) - 1];
  1055.  
  1056.     *str = '\0';
  1058.     // prevent crash if called with base == 1
  1059.     if(base < 2) {
  1060.         base = 10;
  1061.     }
  1062.  
  1063.     do {
  1064.         char c = n % base;
  1065.         n /= base;
  1066.  
  1067.         *--str = c < 10 ? c + '0' : c + 'A' - 10;
  1068.     } while (n);
  1069.  
  1070.     return u8g2_print(str);
  1071. }
  1072.  
  1073. static u8g2_uint_t printNumber(long n, uint8_t base)
  1074. {
  1075.     int t = 0;
  1076.     if (base == 10 && n < 0) {
  1077.         t = u8g2_print("-");
  1078.         n = -n;
  1079.     }
  1080. 	
  1081.     return printNumber(static_cast<unsigned long>(n), base);
  1082. }
  1083.  
  1084. static u8g2_uint_t u8g2_print(char value) { 
  1085. 	return printNumber((long)value, DEC);
  1086. }
  1087.  
  1088. static u8g2_uint_t u8g2_print(unsigned char value) { 
  1089. 	return printNumber((unsigned long)value, DEC);
  1090. }
  1091.  
  1092. static u8g2_uint_t u8g2_print(int value) { 
  1093. 	return printNumber((long)value, DEC);
  1094. }
  1095.  
  1096. static u8g2_uint_t u8g2_print(unsigned int value) { 
  1097. 	return printNumber((unsigned long)value, DEC);
  1098. }
  1099.  
  1100. static u8g2_uint_t u8g2_print(long value) { 
  1101. 	return printNumber(value, DEC);
  1102. }
  1103.  
  1104. static u8g2_uint_t u8g2_print(unsigned long value) { 
  1105. 	return printNumber(value, DEC);
  1106. }
  1107.  
  1108. static u8g2_uint_t printFloat(double number, uint8_t digits) {
  1109.  
  1110.     u8g2_uint_t n = 0;
  1111.  
  1112.     if(isnan(number)) {
  1113.         return u8g2_print("nan");
  1114.     }
  1115.     if(isinf(number)) {
  1116.         return u8g2_print("inf");
  1117.     }
  1118.     if(number > 4294967040.0) {
  1119.         return u8g2_print("ovf");    // constant determined empirically
  1120.     }
  1121.     if(number < -4294967040.0) {
  1122.         return u8g2_print("ovf");    // constant determined empirically
  1123.     }
  1124.  
  1125.     // Handle negative numbers
  1126.     if(number < 0.0) {
  1127.         n += u8g2_print("-");
  1128.         number = -number;
  1129.     }
  1130.  
  1131.     // Round correctly so that print(1.999, 2) prints as "2.00"
  1132.     double rounding = 0.5;
  1133.     for(uint8_t i = 0; i < digits; ++i) {
  1134.         rounding /= 10.0;
  1135.     }
  1136.  
  1137.     number += rounding;
  1138.  
  1139.     // Extract the integer part of the number and print it
  1140.     unsigned long int_part = (unsigned long) number;
  1141.     double remainder = number - (double) int_part;
  1142.     n += u8g2_print(int_part);
  1143.  
  1144.     // Print the decimal point, but only if there are digits beyond
  1145.     if(digits > 0) {
  1146.         n += u8g2_print(".");
  1147.     }
  1148.  
  1149.     // Extract digits from the remainder one at a time
  1150.     while(digits-- > 0) {
  1151.         remainder *= 10.0;
  1152.         int toPrint = int(remainder);
  1153.         n += u8g2_print(toPrint);
  1154.         remainder -= toPrint;
  1155.     }
  1156.  
  1157.     return n;
  1158. }
  1159.  
  1160. static u8g2_uint_t u8g2_print(double value) { 
  1161. 	return printFloat(value, 3);
  1162. }
  1163.  
  1164.  
  1165. /*************** 根据列表每行开头符号，判断每行尾部是否绘制以及绘制什么内容 *************/
  1166. //列表显示数值
  1167. void list_draw_value(int n) { 
  1168. 	//u8g2.print(check_box.v[n - 1]); 
  1169. 	u8g2_print(check_box.v[n - 1]); 
  1170. }
  1171.  
  1172. //绘制外框
  1173. void list_draw_check_box_frame() { 
  1174. 	//u8g2.drawRFrame(CHECK_BOX_L_S, list.temp + CHECK_BOX_U_S, CHECK_BOX_F_W, CHECK_BOX_F_H, 1);
  1175. 	u8g2_DrawRFrame(&u8g2, CHECK_BOX_L_S, list.temp + CHECK_BOX_U_S, CHECK_BOX_F_W, CHECK_BOX_F_H, 1);
  1176. }
  1177.  
  1178. //绘制框里面的点
  1179. void list_draw_check_box_dot() { 
  1180. 	//u8g2.drawBox(CHECK_BOX_L_S + CHECK_BOX_D_S + 1, list.temp + CHECK_BOX_U_S + CHECK_BOX_D_S + 1, CHECK_BOX_F_W - (CHECK_BOX_D_S + 1) * 2, CHECK_BOX_F_H - (CHECK_BOX_D_S + 1) * 2); 
  1181. 	u8g2_DrawBox(&u8g2, CHECK_BOX_L_S + CHECK_BOX_D_S + 1, list.temp + CHECK_BOX_U_S + CHECK_BOX_D_S + 1, CHECK_BOX_F_W - (CHECK_BOX_D_S + 1) * 2, CHECK_BOX_F_H - (CHECK_BOX_D_S + 1) * 2); 
  1182. }
  1183.  
  1184. //列表显示旋钮功能
  1185. void list_draw_krf(int n) 
  1186. { 
  1187.   switch (check_box.v[n - 1])
  1188.   {
  1189.     case 0: u8g2_print("OFF"); break;
  1190.     case 1: u8g2_print("VOL"); break;
  1191.     case 2: u8g2_print("BRI"); break;
  1192.   }
  1193. }
  1194.  
  1195. //列表显示按键键值
  1196. void list_draw_kpf(int n) 
  1197. { 
  1198.   if (check_box.v[n - 1] == 0) u8g2_print("OFF");
  1199.   else if (check_box.v[n - 1] <= 90) u8g2_print((char)check_box.v[n - 1]);
  1200.   else u8g2_print("?");
  1201. }
  1202.  
  1203. //判断列表尾部内容
  1204. void list_draw_text_and_check_box(struct MENU arr[], int i)
  1205. {
  1206.   //u8g2.drawStr(LIST_TEXT_S, list.temp + LIST_TEXT_H + LIST_TEXT_S, arr[i].m_select);
  1207.   //u8g2.setCursor(CHECK_BOX_L_S, list.temp + LIST_TEXT_H + LIST_TEXT_S);
  1208.   u8g2_DrawStr(&u8g2, LIST_TEXT_S, list.temp + LIST_TEXT_H + LIST_TEXT_S, arr[i].m_select);
  1209.   u8g2_setCursor(CHECK_BOX_L_S, list.temp + LIST_TEXT_H + LIST_TEXT_S);
  1210.  
  1211.   switch (arr[i].m_select[0])
  1212.   {
  1213.     case '~': list_draw_value(i); break;
  1214.     case '+': list_draw_check_box_frame(); if (check_box.m[i - 1] == 1)  list_draw_check_box_dot(); break;
  1215.     case '=': list_draw_check_box_frame(); if (*check_box.s_p == i)      list_draw_check_box_dot(); break;
  1216.     case '#': list_draw_krf(i);   break;
  1217.     case '$': list_draw_kpf(i);   break;
  1218.   }
  1219. }
  1220.  
  1221. /******************************** 列表显示函数 **************************************/
  1222.  
  1223. //列表类页面通用显示函数
  1224. void list_show(struct MENU arr[], uint8_t ui_index)
  1225. {
  1226.   //更新动画目标值
  1227.   //u8g2.setFont(LIST_FONT);
  1228.   u8g2_SetFont(&u8g2, LIST_FONT);
  1229.   
  1230.   //list.box_x_trg = u8g2.getStrWidth(arr[ui.select[ui.layer]].m_select) + LIST_TEXT_S * 2;
  1231.   list.box_x_trg = u8g2_GetStrWidth(&u8g2, arr[ui.select[ui.layer]].m_select) + LIST_TEXT_S * 2; 
  1232.   list.bar_y_trg = ceil((ui.select[ui.layer]) * ((float)DISP_H / (ui.num[ui_index] - 1)));
  1233.   
  1234.   //计算动画过渡值
  1235.   animation(&list.y, &list.y_trg, LIST_ANI);
  1236.   animation(&list.box_x, &list.box_x_trg, LIST_ANI);
  1237.   animation(&list.box_y, &list.box_y_trg[ui.layer], LIST_ANI);
  1238.   animation(&list.bar_y, &list.bar_y_trg, LIST_ANI);
  1239.  
  1240.   //检查循环动画是否结束
  1241.   if (list.loop && list.box_y == list.box_y_trg[ui.layer]) list.loop = false;
  1242.  
  1243.   //设置文字和进度条颜色，0透显，1实显，2反色，这里都用实显
  1244.   //u8g2.setDrawColor(1);
  1245.   u8g2_SetDrawColor(&u8g2, 1);
  1246.   
  1247.   //绘制进度条
  1248.   #if 0
  1249.   u8g2.drawHLine(DISP_W - LIST_BAR_W, 0, LIST_BAR_W);
  1250.   u8g2.drawHLine(DISP_W - LIST_BAR_W, DISP_H - 1, LIST_BAR_W);
  1251.   u8g2.drawVLine(DISP_W - ceil((float)LIST_BAR_W / 2), 0, DISP_H);
  1252.   u8g2.drawBox(DISP_W - LIST_BAR_W, 0, LIST_BAR_W, list.bar_y);
  1253.   #else
  1254.   u8g2_DrawHLine(&u8g2, DISP_W - LIST_BAR_W, 0, LIST_BAR_W);
  1255.   u8g2_DrawHLine(&u8g2, DISP_W - LIST_BAR_W, DISP_H - 1, LIST_BAR_W);
  1256.   u8g2_DrawVLine(&u8g2, DISP_W - ceil((float)LIST_BAR_W / 2), 0, DISP_H);
  1257.   u8g2_DrawBox(&u8g2, DISP_W - LIST_BAR_W, 0, LIST_BAR_W, list.bar_y);
  1258.   #endif
  1259.  
  1260.   //绘制列表文字  
  1261.   if (!ui.init)
  1262.   {
  1263.     for (int i = 0; i < ui.num[ui_index]; ++ i)
  1264.     {
  1265.       if (ui.param[LIST_UFD]) list.temp = i * list.y - LIST_LINE_H * ui.select[ui.layer] + list.box_y_trg[ui.layer];
  1266.       else list.temp = (i - ui.select[ui.layer]) * list.y + list.box_y_trg[ui.layer];
  1267.       list_draw_text_and_check_box(arr, i);
  1268.     }
  1269.     if (list.y == list.y_trg) 
  1270.     {
  1271.       ui.init = true;
  1272.       list.y = list.y_trg = - LIST_LINE_H * ui.select[ui.layer] + list.box_y_trg[ui.layer];
  1273.     }
  1274.   }
  1275.   else for (int i = 0; i < ui.num[ui_index]; ++ i)
  1276.   {
  1277.     list.temp = LIST_LINE_H * i + list.y;
  1278.     list_draw_text_and_check_box(arr, i);
  1279.   }
  1280.  
  1281.   //绘制文字选择框，0透显，1实显，2反色，这里用反色
  1282.   //u8g2.setDrawColor(2);
  1283.   //u8g2.drawRBox(0, list.box_y, list.box_x, LIST_LINE_H, LIST_BOX_R);
  1284.   u8g2_SetDrawColor(&u8g2, 2);
  1285.   u8g2_DrawRBox(&u8g2, 0, list.box_y, list.box_x, LIST_LINE_H, LIST_BOX_R);
  1286.  
  1287.   //反转屏幕内元素颜色，白天模式遮罩，在这里屏蔽有列表参与的页面，使遮罩作用在那个页面上
  1288.   if (!ui.param[DARK_MODE])
  1289.   {
  1290.     //u8g2.drawBox(0, 0, DISP_W, DISP_H);
  1291.     u8g2_DrawBox(&u8g2, 0, 0, DISP_W, DISP_H);
  1292.     switch(ui.index)
  1293.     {
  1294.       case M_WINDOW: 
  1295.       case M_VOLT:
  1296.       //u8g2.drawBox(0, 0, DISP_W, DISP_H);  
  1297.       u8g2_DrawBox(&u8g2, 0, 0, DISP_W, DISP_H);  
  1298.     }
  1299.   }
  1300. }
  1301.  
  1302. //电压页面显示函数
  1303. void volt_show()
  1304. {
  1305.   //使用列表类显示选项
  1306.   list_show(volt_menu, M_VOLT); 
  1307.  
  1308.   //计算动画过渡值  
  1309.   animation(&volt.text_bg_r, &volt.text_bg_r_trg, TAG_ANI);
  1310.  
  1311.   //设置曲线颜色，0透显，1实显，2反色，这里用实显
  1312.   //u8g2.setDrawColor(1); 
  1313.   u8g2_SetDrawColor(&u8g2, 1);
  1314.  
  1315.   //绘制电压曲线和外框
  1316.   volt.val = 0;
  1317.   //u8g2.drawFrame(WAVE_BOX_L_S, 0, WAVE_BOX_W, WAVE_BOX_H);
  1318.   //u8g2.drawFrame(WAVE_BOX_L_S + 1, 1, WAVE_BOX_W - 2, WAVE_BOX_H - 2);
  1319.   u8g2_DrawFrame(&u8g2, WAVE_BOX_L_S, 0, WAVE_BOX_W, WAVE_BOX_H);
  1320.   u8g2_DrawFrame(&u8g2, WAVE_BOX_L_S + 1, 1, WAVE_BOX_W - 2, WAVE_BOX_H - 2);
  1321.  
  1322.   if (list.box_y == list.box_y_trg[ui.layer] && list.y == list.y_trg)
  1323.   {
  1324.     for (int i = 0; i < WAVE_SAMPLE * WAVE_W; i++) volt.ch0_adc[i] = volt.val = (int)(motor_b.pos_spd_ltd.v2);//(int)(adc_data.voltage_mv);//analogRead(analog_pin[ui.select[ui.layer]]);
  1325.     for (int i = 1; i < WAVE_W - 1; i++)
  1326.     { 
  1327.       //volt.ch0_wave[i] = lv_map(volt.ch0_adc[int(5 * i)], 0, 4095, WAVE_MAX, WAVE_MIN);   
  1328.       //u8g2.drawLine(WAVE_L + i - 1, WAVE_U + volt.ch0_wave[i - 1], WAVE_L + i, WAVE_U + volt.ch0_wave[i]);
  1329. 	  volt.ch0_wave[i] = lv_map(volt.ch0_adc[int(5 * i)], -5000, 5000, WAVE_MIN, WAVE_MAX); 
  1330. 	  u8g2_DrawLine(&u8g2, WAVE_L + i - 1, WAVE_U + volt.ch0_wave[i - 1], WAVE_L + i, WAVE_U + volt.ch0_wave[i]);
  1331.     }
  1332.   }
  1333.  
  1334. #if 0
  1335.   //绘制电压值
  1336.   u8g2.setFontDirection(0);
  1337.   u8g2.setFont(VOLT_FONT); 
  1338.   u8g2.setCursor(39, DISP_H - 6);
  1339.   u8g2.print(volt.val / 4096.0 * 3.3);
  1340.   u8g2.print("V");
  1341.  
  1342.   //绘制列表选择框和电压文字背景
  1343.   u8g2.setDrawColor(2);
  1344.   u8g2.drawBox(VOLT_TEXT_BG_L_S, DISP_H - VOLT_TEXT_BG_H, volt.text_bg_r, VOLT_TEXT_BG_H);
  1345.  
  1346.   //反转屏幕内元素颜色，白天模式遮罩
  1347.   if (!ui.param[DARK_MODE]) u8g2.drawBox(0, 0, DISP_W, DISP_H);
  1348. #else
  1349. 	//绘制电压值
  1350. 	u8g2_SetFontDirection(&u8g2, 0);
  1351. 	u8g2_SetFont(&u8g2, VOLT_FONT); 
  1352. 	u8g2_setCursor(32, DISP_H - 6);
  1353. 	//u8g2_print(volt.val / 4096.0 * 3.3);
  1354. 	//u8g2_print(volt.val/1000.0);
  1355. 	//u8g2_print(motor_b.pos_spd_ltd.v2/1000.0);
  1356. 	u8g2_print(volt.val);
  1357. 	//u8g2_SetFont(&u8g2, LIST_FONT); 
  1358. 	u8g2_print("V");
  1359.  
  1360. 	//绘制列表选择框和电压文字背景
  1361. 	u8g2_SetDrawColor(&u8g2, 2);
  1362. 	u8g2_DrawBox(&u8g2, VOLT_TEXT_BG_L_S, DISP_H - VOLT_TEXT_BG_H, volt.text_bg_r, VOLT_TEXT_BG_H);
  1363.  
  1364. 	//反转屏幕内元素颜色，白天模式遮罩
  1365. 	if (!ui.param[DARK_MODE]) u8g2_DrawBox(&u8g2, 0, 0, DISP_W, DISP_H);
  1366. #endif
  1367. }
  1368.  
  1369. //弹窗通用显示函数
  1370. void window_show()
  1371. {
  1372.   //绘制背景列表，根据开关判断背景是否要虚化
  1373.   list_show(win.bg, win.index);
  1374.   if (ui.param[WIN_BOK]) for (uint16_t i = 0; i < buf_len; ++i)  buf_ptr[i] = buf_ptr[i] & (i % 2 == 0 ? 0x55 : 0xAA);
  1375.  
  1376.   //更新动画目标值
  1377.   //u8g2.setFont(WIN_FONT);
  1378.   u8g2_SetFont(&u8g2, WIN_FONT);
  1379.   win.bar_trg = (float)(*win.value - win.min) / (float)(win.max - win.min) * (WIN_BAR_W - 4);
  1380.  
  1381.   //计算动画过渡值
  1382.   animation(&win.bar, &win.bar_trg, WIN_ANI);
  1383.   animation(&win.y, &win.y_trg, WIN_ANI);
  1384.  
  1385. #if 0
  1386.   //绘制窗口
  1387.   u8g2.setDrawColor(0); u8g2.drawRBox(win.l, (int16_t)win.y, WIN_W, WIN_H, 2);    //绘制外框背景
  1388.   u8g2.setDrawColor(1); u8g2.drawRFrame(win.l, (int16_t)win.y, WIN_W, WIN_H, 2);  //绘制外框描边
  1389.   u8g2.drawRFrame(win.l + 5, (int16_t)win.y + 20, WIN_BAR_W, WIN_BAR_H, 1);       //绘制进度条外框
  1390.   u8g2.drawBox(win.l + 7, (int16_t)win.y + 22, win.bar, WIN_BAR_H - 4);           //绘制进度条
  1391.   u8g2.setCursor(win.l + 5, (int16_t)win.y + 14); u8g2.print(win.title);          //绘制标题
  1392.   u8g2.setCursor(win.l + 78, (int16_t)win.y + 14); u8g2.print(*win.value);        //绘制当前值
  1393.   
  1394.   //需要在窗口修改参数时立即见效的函数
  1395.   if (!strcmp(win.title, "Disp Bri")) u8g2.setContrast(ui.param[DISP_BRI]);
  1396.  
  1397.   //反转屏幕内元素颜色，白天模式遮罩
  1398.   u8g2.setDrawColor(2);
  1399.   if (!ui.param[DARK_MODE]) u8g2.drawBox(0, 0, DISP_W, DISP_H);
  1400. #else
  1401. 	//绘制窗口
  1402. 	u8g2_SetDrawColor(&u8g2, 0); u8g2_DrawRBox(&u8g2, win.l, (int16_t)win.y, WIN_W, WIN_H, 2);	//绘制外框背景
  1403. 	u8g2_SetDrawColor(&u8g2, 1); u8g2_DrawRFrame(&u8g2, win.l, (int16_t)win.y, WIN_W, WIN_H, 2);	//绘制外框描边
  1404. 	u8g2_DrawRFrame(&u8g2, win.l + 5, (int16_t)win.y + 20, WIN_BAR_W, WIN_BAR_H, 1);		//绘制进度条外框
  1405. 	u8g2_DrawBox(&u8g2, win.l + 7, (int16_t)win.y + 22, win.bar, WIN_BAR_H - 4);			//绘制进度条
  1406. 	u8g2_setCursor(win.l + 5, (int16_t)win.y + 14); u8g2_print(win.title);			//绘制标题
  1407. 	u8g2_setCursor(win.l + 78, (int16_t)win.y + 14); u8g2_print(*win.value);		//绘制当前值
  1408.  
  1409. 	//需要在窗口修改参数时立即见效的函数
  1410. 	//if (!strcmp(win.title, "Disp Bri")) u8g2_SetContrast(&u8g2, ui.param[DISP_BRI]);
  1411.  
  1412. 	//反转屏幕内元素颜色，白天模式遮罩
  1413. 	u8g2_SetDrawColor(&u8g2, 2);
  1414. 	if (!ui.param[DARK_MODE]) u8g2_DrawBox(&u8g2, 0, 0, DISP_W, DISP_H);
  1415.  
  1416. #endif
  1417. }
  1418.  
  1419. /************************************* 处理函数 *************************************/
  1420.  
  1421. /*********************************** 通用处理函数 ***********************************/
  1422.  
  1423. //磁贴类页面旋转时判断通用函数
  1424. void tile_rotate_switch()
  1425. {
  1426.   switch (btn.id)
  1427.   { 
  1428.     case BTN_ID_CC:
  1429.       if (ui.init)
  1430.       {
  1431.         if (ui.select[ui.layer] > 0)
  1432.         {
  1433.           ui.select[ui.layer] -= 1;
  1434.           tile.icon_x_trg += TILE_ICON_S;
  1435.           tile.select_flag = false;
  1436.         }
  1437.         else 
  1438.         {
  1439.           if (ui.param[TILE_LOOP])
  1440.           {
  1441.             ui.select[ui.layer] = ui.num[ui.index] - 1;
  1442.             tile.icon_x_trg = - TILE_ICON_S * (ui.num[ui.index] - 1);
  1443.             break;
  1444.           }
  1445.           else tile.select_flag = true;
  1446.         }
  1447.       }
  1448.       break;
  1449.  
  1450.     case BTN_ID_CW:
  1451.       if (ui.init)
  1452.       {
  1453.         if (ui.select[ui.layer] < (ui.num[ui.index] - 1)) 
  1454.         {
  1455.           ui.select[ui.layer] += 1;
  1456.           tile.icon_x_trg -= TILE_ICON_S;
  1457.           tile.select_flag = false;
  1458.         }
  1459.         else 
  1460.         {
  1461.           if (ui.param[TILE_LOOP])
  1462.           {
  1463.             ui.select[ui.layer] = 0;
  1464.             tile.icon_x_trg = 0;
  1465.             break;
  1466.           }
  1467.           else tile.select_flag = true;
  1468.         }
  1469.       }
  1470.       break;
  1471.   }
  1472. }
  1473.  
  1474. //列表类页面旋转时判断通用函数
  1475. void list_rotate_switch()
  1476. {
  1477.   if (!list.loop)
  1478.   {
  1479.     switch (btn.id)
  1480.     {
  1481.       case BTN_ID_CC:
  1482.         if (ui.select[ui.layer] == 0)
  1483.         {
  1484.           if (ui.param[LIST_LOOP] && ui.init)
  1485.           {
  1486.             list.loop = true;
  1487.             ui.select[ui.layer] = ui.num[ui.index] - 1;
  1488.             if (ui.num[ui.index] > list.line_n) 
  1489.             {
  1490.               list.box_y_trg[ui.layer] = DISP_H - LIST_LINE_H;
  1491.               list.y_trg = DISP_H - ui.num[ui.index] * LIST_LINE_H;
  1492.             }
  1493.             else list.box_y_trg[ui.layer] = (ui.num[ui.index] - 1) * LIST_LINE_H;
  1494.             break;
  1495.           }
  1496.           else break;
  1497.         }
  1498.         if (ui.init)
  1499.         {
  1500.           ui.select[ui.layer] -= 1;
  1501.           if (ui.select[ui.layer] < - (list.y_trg / LIST_LINE_H)) 
  1502.           {
  1503.             if (!(DISP_H % LIST_LINE_H)) list.y_trg += LIST_LINE_H;
  1504.             else
  1505.             {
  1506.               if (list.box_y_trg[ui.layer] == DISP_H - LIST_LINE_H * list.line_n)
  1507.               {
  1508.                 list.y_trg += (list.line_n + 1) * LIST_LINE_H - DISP_H;
  1509.                 list.box_y_trg[ui.layer] = 0;
  1510.               }
  1511.               else if (list.box_y_trg[ui.layer] == LIST_LINE_H)
  1512.               {
  1513.                 list.box_y_trg[ui.layer] = 0;
  1514.               }
  1515.               else list.y_trg += LIST_LINE_H;
  1516.             }
  1517.           }
  1518.           else list.box_y_trg[ui.layer] -= LIST_LINE_H;
  1519.           break;
  1520.         }
  1521.  
  1522.       case BTN_ID_CW:
  1523.         if (ui.select[ui.layer] == (ui.num[ui.index] - 1))
  1524.         {
  1525.           if (ui.param[LIST_LOOP] && ui.init)
  1526.           {
  1527.             list.loop = true;
  1528.             ui.select[ui.layer] = 0;
  1529.             list.y_trg = 0;
  1530.             list.box_y_trg[ui.layer] = 0;
  1531.             break;
  1532.           }
  1533.           else break;
  1534.         }
  1535.         if (ui.init)
  1536.         {
  1537.           ui.select[ui.layer] += 1;
  1538.           if ((ui.select[ui.layer] + 1) > (list.line_n - list.y_trg / LIST_LINE_H))
  1539.           {
  1540.             if (!(DISP_H % LIST_LINE_H)) list.y_trg -= LIST_LINE_H;
  1541.             else
  1542.             {
  1543.               if (list.box_y_trg[ui.layer] == LIST_LINE_H * (list.line_n - 1))
  1544.               {
  1545.                 list.y_trg -= (list.line_n + 1) * LIST_LINE_H - DISP_H;
  1546.                 list.box_y_trg[ui.layer] = DISP_H - LIST_LINE_H;
  1547.               }
  1548.               else if (list.box_y_trg[ui.layer] == DISP_H - LIST_LINE_H * 2)
  1549.               {
  1550.                 list.box_y_trg[ui.layer] = DISP_H - LIST_LINE_H;
  1551.               }
  1552.               else list.y_trg -= LIST_LINE_H;
  1553.             }
  1554.           }
  1555.           else list.box_y_trg[ui.layer] += LIST_LINE_H;
  1556.           break;
  1557.         }
  1558.         break;
  1559.     }
  1560.   }
  1561. }
  1562.  
  1563. //弹窗通用处理函数
  1564. void window_proc()
  1565. {
  1566.   window_show();
  1567.   if (win.y == WIN_Y_TRG) ui.index = win.index;
  1568.   if (btn.pressed && win.y == win.y_trg && win.y != WIN_Y_TRG)
  1569.   {
  1570.     btn.pressed = false;
  1571.     switch (btn.id)
  1572.     {
  1573.       case BTN_ID_CC: if (*win.value < win.max)  *win.value += win.step;  eeprom.change = true;  break;
  1574.       case BTN_ID_CW: if (*win.value > win.min)  *win.value -= win.step;  eeprom.change = true;  break;  
  1575.       case BTN_ID_SP: case BTN_ID_LP: win.y_trg = WIN_Y_TRG; break;
  1576.     }
  1577.   }
  1578. }
  1579.  
  1580. /********************************** 分页面处理函数 **********************************/
  1581.  
  1582. //睡眠页面处理函数
  1583. void sleep_proc()
  1584. {
  1585.   while (ui.sleep)
  1586.   {
  1587.     //睡眠时循环执行的函数
  1588.  
  1589.     //睡眠时需要扫描旋钮才能退出睡眠
  1590.     btn_scan();
  1591.  
  1592. 	delay(1);
  1593.  
  1594.     //当旋钮有动作时
  1595.     if (btn.pressed) { 
  1596. 		btn.pressed = false; 
  1597. 		switch (btn.id) {    
  1598. #if 0
  1599.         //睡眠时顺时针旋转执行的函数
  1600.         case BTN_ID_CW:
  1601.           switch (knob.param[KNOB_ROT])
  1602.           {
  1603.             case KNOB_ROT_VOL: Consumer.press(HIDConsumer::VOLUME_UP);       Consumer.release(); break;
  1604.             case KNOB_ROT_BRI: Consumer.press(HIDConsumer::BRIGHTNESS_UP);   Consumer.release(); break;
  1605.           }
  1606.           break;
  1607.  
  1608.         //睡眠时逆时针旋转执行的函数
  1609.         case BTN_ID_CC:
  1610.           switch (knob.param[KNOB_ROT])
  1611.           {
  1612.             case KNOB_ROT_VOL: Consumer.press(HIDConsumer::VOLUME_DOWN);     Consumer.release(); break;
  1613.             case KNOB_ROT_BRI: Consumer.press(HIDConsumer::BRIGHTNESS_DOWN); Consumer.release(); break;
  1614.           }
  1615.           break;
  1616.  
  1617.         //睡眠时短按执行的函数
  1618.         case BTN_ID_SP: Keyboard.press(knob.param[KNOB_COD]);  Keyboard.release(knob.param[KNOB_COD]); break;   
  1619. #endif        
  1620.         //睡眠时长按执行的函数
  1621.         //case BTN_ID_LP: ui.index = M_MAIN;  ui.state = S_LAYER_IN; u8g2.setPowerSave(0); ui.sleep = false; break;
  1622.         case BTN_ID_LP: ui.index = M_MAIN;  ui.state = S_LAYER_IN; /*u8g2_SetPowerSave(&u8g2, 0);*/ ui.sleep = false; break;
  1623.       }
  1624.     }
  1625.   }
  1626. }
  1627.  
  1628. //主菜单处理函数，磁贴类模板
  1629. void main_proc()
  1630. {
  1631.   tile_show(main_menu, main_icon_pic);
  1632.   if (btn.pressed) { btn.pressed = false; switch (btn.id) { case BTN_ID_CW: case BTN_ID_CC: tile_rotate_switch(); break; case BTN_ID_SP: switch (ui.select[ui.layer]) {
  1633.  
  1634.         case 0: ui.index = M_SLEEP;   ui.state = S_LAYER_OUT; break;
  1635.         case 1: ui.index = M_EDITOR;  ui.state = S_LAYER_IN;  break;
  1636.         case 2: ui.index = M_VOLT;    ui.state = S_LAYER_IN;  break;
  1637.         case 3: ui.index = M_SETTING; ui.state = S_LAYER_IN;  break;
  1638.       }
  1639.     }
  1640.     if (!tile.select_flag && ui.init) { tile.indi_x = 0; tile.title_y = tile.title_y_calc; }
  1641.   }
  1642. }
  1643.  
  1644. //编辑器菜单处理函数
  1645. void editor_proc()
  1646. {
  1647.   list_show(editor_menu, M_EDITOR); 
  1648.   if (btn.pressed) { btn.pressed = false; switch (btn.id) { case BTN_ID_CW: case BTN_ID_CC: list_rotate_switch(); break; case BTN_ID_LP: ui.select[ui.layer] = 0; case BTN_ID_SP: switch (ui.select[ui.layer]) {
  1649.         
  1650.         case 0:   ui.index = M_MAIN;  ui.state = S_LAYER_OUT; break;
  1651.         case 11:  ui.index = M_KNOB;  ui.state = S_LAYER_IN;  break;
  1652.       }
  1653.     }
  1654.   }
  1655. }
  1656.  
  1657. //旋钮编辑菜单处理函数
  1658. void knob_proc()
  1659. {
  1660.   list_show(knob_menu, M_KNOB);
  1661.   if (btn.pressed) { btn.pressed = false; switch (btn.id) { case BTN_ID_CW: case BTN_ID_CC: list_rotate_switch(); break; case BTN_ID_LP: ui.select[ui.layer] = 0; case BTN_ID_SP: switch (ui.select[ui.layer]) {
  1662.         
  1663.         case 0: ui.index = M_EDITOR;  ui.state = S_LAYER_OUT; break;
  1664.         case 1: ui.index = M_KRF;     ui.state = S_LAYER_IN;  check_box_s_init(&knob.param[KNOB_ROT], &knob.param[KNOB_ROT_P]); break;
  1665.         case 2: ui.index = M_KPF;     ui.state = S_LAYER_IN;  check_box_s_init(&knob.param[KNOB_COD], &knob.param[KNOB_COD_P]); break;
  1666.       }
  1667.     }
  1668.   }
  1669. }
  1670.  
  1671. //旋钮旋转功能菜单处理函数
  1672. void krf_proc()
  1673. {
  1674.   list_show(krf_menu, M_KRF);
  1675.   if (btn.pressed) { btn.pressed = false; switch (btn.id) { case BTN_ID_CW: case BTN_ID_CC: list_rotate_switch(); break; case BTN_ID_LP: ui.select[ui.layer] = 0; case BTN_ID_SP: switch (ui.select[ui.layer]) {
  1676.         
  1677.         case 0: ui.index = M_KNOB;  ui.state = S_LAYER_OUT; break;
  1678.         case 1: break;
  1679.         case 2: check_box_s_select(KNOB_DISABLE, ui.select[ui.layer]); break;
  1680.         case 3: break;
  1681.         case 4: check_box_s_select(KNOB_ROT_VOL, ui.select[ui.layer]); break;
  1682.         case 5: check_box_s_select(KNOB_ROT_BRI, ui.select[ui.layer]); break;
  1683.         case 6: break;
  1684.       }
  1685.     }
  1686.   }
  1687. }
  1688.  
  1689. #define KEY_LEFT_CTRL   0x80
  1690. #define KEY_LEFT_SHIFT  0x81
  1691. #define KEY_LEFT_ALT    0x82
  1692. #define KEY_LEFT_GUI    0x83
  1693. #define KEY_RIGHT_CTRL  0x84
  1694. #define KEY_RIGHT_SHIFT 0x85
  1695. #define KEY_RIGHT_ALT   0x86
  1696. #define KEY_RIGHT_GUI   0x87
  1697.  
  1698. #define KEY_UP_ARROW    0xDA
  1699. #define KEY_DOWN_ARROW  0xD9
  1700. #define KEY_LEFT_ARROW  0xD8
  1701. #define KEY_RIGHT_ARROW 0xD7
  1702. #define KEY_BACKSPACE   0xB2
  1703. #define KEY_TAB         0xB3
  1704. #define KEY_RETURN      0xB0
  1705. #define KEY_ESC         0xB1
  1706. #define KEY_INSERT      0xD1
  1707. #define KEY_DELETE      0xD4
  1708. #define KEY_PAGE_UP     0xD3
  1709. #define KEY_PAGE_DOWN   0xD6
  1710. #define KEY_HOME        0xD2
  1711. #define KEY_END         0xD5
  1712. #define KEY_CAPS_LOCK   0xC1
  1713. #define KEY_F1          0xC2
  1714. #define KEY_F2          0xC3
  1715. #define KEY_F3          0xC4
  1716. #define KEY_F4          0xC5
  1717. #define KEY_F5          0xC6
  1718. #define KEY_F6          0xC7
  1719. #define KEY_F7          0xC8
  1720. #define KEY_F8          0xC9
  1721. #define KEY_F9          0xCA
  1722. #define KEY_F10         0xCB
  1723. #define KEY_F11         0xCC
  1724. #define KEY_F12         0xCD
  1725. #define KEY_F13         0xF0
  1726. #define KEY_F14         0xF1
  1727. #define KEY_F15         0xF2
  1728. #define KEY_F16         0xF3
  1729. #define KEY_F17         0xF4
  1730. #define KEY_F18         0xF5
  1731. #define KEY_F19         0xF6
  1732. #define KEY_F20         0xF7
  1733. #define KEY_F21         0xF8
  1734. #define KEY_F22         0xF9
  1735. #define KEY_F23         0xFA
  1736. #define KEY_F24         0xFB
  1737.  
  1738. //旋钮点按功能菜单处理函数
  1739. void kpf_proc()
  1740. {
  1741.   list_show(kpf_menu, M_KPF);
  1742.   if (btn.pressed) { btn.pressed = false; switch (btn.id) { case BTN_ID_CW: case BTN_ID_CC: list_rotate_switch(); break;  case BTN_ID_LP: ui.select[ui.layer] = 0; case BTN_ID_SP: switch (ui.select[ui.layer]) {
  1743.     
  1744.         case 0:   ui.index = M_KNOB;  ui.state = S_LAYER_OUT; break;
  1745.         case 1:   break;
  1746.         case 2:   check_box_s_select(KNOB_DISABLE, ui.select[ui.layer]); break;
  1747.         case 3:   break;
  1748.         case 4:   check_box_s_select('A', ui.select[ui.layer]); break;
  1749.         case 5:   check_box_s_select('B', ui.select[ui.layer]); break;
  1750.         case 6:   check_box_s_select('C', ui.select[ui.layer]); break;
  1751.         case 7:   check_box_s_select('D', ui.select[ui.layer]); break;
  1752.         case 8:   check_box_s_select('E', ui.select[ui.layer]); break;
  1753.         case 9:   check_box_s_select('F', ui.select[ui.layer]); break;
  1754.         case 10:  check_box_s_select('G', ui.select[ui.layer]); break;
  1755.         case 11:  check_box_s_select('H', ui.select[ui.layer]); break;
  1756.         case 12:  check_box_s_select('I', ui.select[ui.layer]); break;
  1757.         case 13:  check_box_s_select('J', ui.select[ui.layer]); break;
  1758.         case 14:  check_box_s_select('K', ui.select[ui.layer]); break;
  1759.         case 15:  check_box_s_select('L', ui.select[ui.layer]); break;
  1760.         case 16:  check_box_s_select('M', ui.select[ui.layer]); break;
  1761.         case 17:  check_box_s_select('N', ui.select[ui.layer]); break;
  1762.         case 18:  check_box_s_select('O', ui.select[ui.layer]); break;
  1763.         case 19:  check_box_s_select('P', ui.select[ui.layer]); break;
  1764.         case 20:  check_box_s_select('Q', ui.select[ui.layer]); break;
  1765.         case 21:  check_box_s_select('R', ui.select[ui.layer]); break;
  1766.         case 22:  check_box_s_select('S', ui.select[ui.layer]); break;
  1767.         case 23:  check_box_s_select('T', ui.select[ui.layer]); break;
  1768.         case 24:  check_box_s_select('U', ui.select[ui.layer]); break;
  1769.         case 25:  check_box_s_select('V', ui.select[ui.layer]); break;
  1770.         case 26:  check_box_s_select('W', ui.select[ui.layer]); break;
  1771.         case 27:  check_box_s_select('X', ui.select[ui.layer]); break;
  1772.         case 28:  check_box_s_select('Y', ui.select[ui.layer]); break;
  1773.         case 29:  check_box_s_select('Z', ui.select[ui.layer]); break;
  1774.         case 30:  break;
  1775.         case 31:  check_box_s_select('0', ui.select[ui.layer]); break;
  1776.         case 32:  check_box_s_select('1', ui.select[ui.layer]); break;
  1777.         case 33:  check_box_s_select('2', ui.select[ui.layer]); break;
  1778.         case 34:  check_box_s_select('3', ui.select[ui.layer]); break;
  1779.         case 35:  check_box_s_select('4', ui.select[ui.layer]); break;
  1780.         case 36:  check_box_s_select('5', ui.select[ui.layer]); break;
  1781.         case 37:  check_box_s_select('6', ui.select[ui.layer]); break;
  1782.         case 38:  check_box_s_select('7', ui.select[ui.layer]); break;
  1783.         case 39:  check_box_s_select('8', ui.select[ui.layer]); break;
  1784.         case 40:  check_box_s_select('9', ui.select[ui.layer]); break;
  1785.         case 41:  break;
  1786.         case 42:  check_box_s_select( KEY_ESC, ui.select[ui.layer]); break;
  1787.         case 43:  check_box_s_select( KEY_F1,  ui.select[ui.layer]); break;
  1788.         case 44:  check_box_s_select( KEY_F2,  ui.select[ui.layer]); break;
  1789.         case 45:  check_box_s_select( KEY_F3,  ui.select[ui.layer]); break;
  1790.         case 46:  check_box_s_select( KEY_F4,  ui.select[ui.layer]); break;
  1791.         case 47:  check_box_s_select( KEY_F5,  ui.select[ui.layer]); break;
  1792.         case 48:  check_box_s_select( KEY_F6,  ui.select[ui.layer]); break;
  1793.         case 49:  check_box_s_select( KEY_F7,  ui.select[ui.layer]); break;
  1794.         case 50:  check_box_s_select( KEY_F8,  ui.select[ui.layer]); break;
  1795.         case 51:  check_box_s_select( KEY_F9,  ui.select[ui.layer]); break;
  1796.         case 52:  check_box_s_select( KEY_F10, ui.select[ui.layer]); break;
  1797.         case 53:  check_box_s_select( KEY_F11, ui.select[ui.layer]); break;
  1798.         case 54:  check_box_s_select( KEY_F12, ui.select[ui.layer]); break;
  1799.         case 55:  break;
  1800.         case 56:  check_box_s_select( KEY_LEFT_CTRL,   ui.select[ui.layer]); break;
  1801.         case 57:  check_box_s_select( KEY_LEFT_SHIFT,  ui.select[ui.layer]); break;
  1802.         case 58:  check_box_s_select( KEY_LEFT_ALT,    ui.select[ui.layer]); break;
  1803.         case 59:  check_box_s_select( KEY_LEFT_GUI,    ui.select[ui.layer]); break;
  1804.         case 60:  check_box_s_select( KEY_RIGHT_CTRL,  ui.select[ui.layer]); break;
  1805.         case 61:  check_box_s_select( KEY_RIGHT_SHIFT, ui.select[ui.layer]); break;
  1806.         case 62:  check_box_s_select( KEY_RIGHT_ALT,   ui.select[ui.layer]); break;
  1807.         case 63:  check_box_s_select( KEY_RIGHT_GUI,   ui.select[ui.layer]); break;
  1808.         case 64:  break;
  1809.         case 65:  check_box_s_select( KEY_CAPS_LOCK,   ui.select[ui.layer]); break;
  1810.         case 66:  check_box_s_select( KEY_BACKSPACE,   ui.select[ui.layer]); break;
  1811.         case 67:  check_box_s_select( KEY_RETURN,      ui.select[ui.layer]); break;
  1812.         case 68:  check_box_s_select( KEY_INSERT,      ui.select[ui.layer]); break;
  1813.         case 69:  check_box_s_select( KEY_DELETE,      ui.select[ui.layer]); break;
  1814.         case 70:  check_box_s_select( KEY_TAB,         ui.select[ui.layer]); break;
  1815.         case 71:  break;
  1816.         case 72:  check_box_s_select( KEY_HOME,        ui.select[ui.layer]); break;
  1817.         case 73:  check_box_s_select( KEY_END,         ui.select[ui.layer]); break;
  1818.         case 74:  check_box_s_select( KEY_PAGE_UP,     ui.select[ui.layer]); break;
  1819.         case 75:  check_box_s_select( KEY_PAGE_DOWN,   ui.select[ui.layer]); break;
  1820.         case 76:  break;
  1821.         case 77:  check_box_s_select( KEY_UP_ARROW,    ui.select[ui.layer]); break;
  1822.         case 78:  check_box_s_select( KEY_DOWN_ARROW,  ui.select[ui.layer]); break;
  1823.         case 79:  check_box_s_select( KEY_LEFT_ARROW,  ui.select[ui.layer]); break;
  1824.         case 80:  check_box_s_select( KEY_RIGHT_ARROW, ui.select[ui.layer]); break;
  1825.         case 81:  break;
  1826.       }
  1827.     }
  1828.   }
  1829. }
  1830.  
  1831. //电压测量页处理函数
  1832. void volt_proc()
  1833. {
  1834.   volt_show();
  1835.   if (btn.pressed) { btn.pressed = false; switch (btn.id) { case BTN_ID_CW: case BTN_ID_CC: list_rotate_switch(); break;
  1836.  
  1837.       case BTN_ID_SP: case BTN_ID_LP: ui.index = M_MAIN;  ui.state = S_LAYER_OUT; break;
  1838.     }
  1839.   }
  1840. }
  1841.  
  1842. //设置菜单处理函数，多选框列表类模板，弹窗模板
  1843. void setting_proc()
  1844. {
  1845.   list_show(setting_menu, M_SETTING);
  1846.   if (btn.pressed) { btn.pressed = false; switch (btn.id) { case BTN_ID_CW: case BTN_ID_CC: list_rotate_switch(); break; case BTN_ID_LP: ui.select[ui.layer] = 0; case BTN_ID_SP: switch (ui.select[ui.layer]) {
  1847.         
  1848.         //返回更浅层级，长按被当作选择这一项，也是执行这一行
  1849.         case 0:   ui.index = M_MAIN;  ui.state = S_LAYER_OUT; break;
  1850.         
  1851.         //弹出窗口，参数初始化：标题，参数名，参数值，最大值，最小值，步长，背景列表名，背景列表标签
  1852.         case 1:   window_value_init("Disp Bri", DISP_BRI, &ui.param[DISP_BRI],  255,  0,  5, setting_menu, M_SETTING);  break;
  1853.         case 2:   window_value_init("Tile Ani", TILE_ANI, &ui.param[TILE_ANI],  100, 10,  1, setting_menu, M_SETTING);  break;
  1854.         case 3:   window_value_init("List Ani", LIST_ANI, &ui.param[LIST_ANI],  100, 10,  1, setting_menu, M_SETTING);  break;
  1855.         case 4:   window_value_init("Win Ani",  WIN_ANI,  &ui.param[WIN_ANI],   100, 10,  1, setting_menu, M_SETTING);  break;
  1856.         case 5:   window_value_init("Spot Ani", SPOT_ANI, &ui.param[SPOT_ANI],  100, 10,  1, setting_menu, M_SETTING);  break;
  1857.         case 6:   window_value_init("Tag Ani",  TAG_ANI,  &ui.param[TAG_ANI],   100, 10,  1, setting_menu, M_SETTING);  break;
  1858.         case 7:   window_value_init("Fade Ani", FADE_ANI, &ui.param[FADE_ANI],  255,  0,  1, setting_menu, M_SETTING);  break;
  1859.         case 8:   window_value_init("Btn SPT",  BTN_SPT,  &ui.param[BTN_SPT],   255,  0,  1, setting_menu, M_SETTING);  break;
  1860.         case 9:   window_value_init("Btn LPT",  BTN_LPT,  &ui.param[BTN_LPT],   255,  0,  1, setting_menu, M_SETTING);  break;
  1861.  
  1862.         //多选框
  1863.         case 10:  check_box_m_select( TILE_UFD  );  break;
  1864.         case 11:  check_box_m_select( LIST_UFD  );  break;
  1865.         case 12:  check_box_m_select( TILE_LOOP );  break;
  1866.         case 13:  check_box_m_select( LIST_LOOP );  break;
  1867.         case 14:  check_box_m_select( WIN_BOK   );  break;
  1868.         case 15:  check_box_m_select( KNOB_DIR  );  break;
  1869.         case 16:  check_box_m_select( DARK_MODE );  break;
  1870.  
  1871.         //关于本机
  1872.         case 17:  ui.index = M_ABOUT; ui.state = S_LAYER_IN; break;
  1873.       }
  1874.     }
  1875.   }
  1876. }
  1877.  
  1878. //关于本机页
  1879. void about_proc()
  1880. {
  1881.   list_show(about_menu, M_ABOUT);
  1882.   if (btn.pressed) { btn.pressed = false; switch (btn.id) { case BTN_ID_CW: case BTN_ID_CC: list_rotate_switch(); break; case BTN_ID_LP: ui.select[ui.layer] = 0; case BTN_ID_SP: switch (ui.select[ui.layer]) {
  1883.  
  1884.         case 0:   ui.index = M_SETTING;  ui.state = S_LAYER_OUT; break;
  1885.       }
  1886.     }
  1887.   }
  1888. }
  1889.  
  1890. //总的UI进程
  1891. void ui_proc()
  1892. {
  1893.   //u8g2.sendBuffer();
  1894.   //u8g2_SendBuffer(&u8g2);
  1895.   //u8g2_FirstPage(&u8g2);
  1896.   switch (ui.state)
  1897.   {
  1898.     case S_FADE:          fade();                   break;  //转场动画
  1899.     case S_WINDOW:        window_param_init();      break;  //弹窗初始化
  1900.     case S_LAYER_IN:      layer_init_in();          break;  //层级初始化
  1901.     case S_LAYER_OUT:     layer_init_out();         break;  //层级初始化
  1902.   
  1903.     case S_NONE: u8g2_ClearBuffer(&u8g2);//u8g2.clearBuffer(); 
  1904. 	switch (ui.index)      //直接选择页面
  1905.     {
  1906.       case M_WINDOW:      window_proc();            break;
  1907.       case M_SLEEP:       sleep_proc();             break;
  1908.       case M_MAIN:        main_proc();              break;
  1909.       case M_EDITOR:      editor_proc();            break;
  1910.       case M_KNOB:        knob_proc();              break;
  1911.       case M_KRF:         krf_proc();               break;
  1912.       case M_KPF:         kpf_proc();               break;
  1913.       case M_VOLT:        volt_proc();              break;
  1914.       case M_SETTING:     setting_proc();           break;
  1915.       case M_ABOUT:       about_proc();             break;
  1916.     }
  1917.   }
  1918.   u8g2_NextPage(&u8g2);
  1919. }
  1920.  
  1921. //OLED初始化函数
  1922. void oled_init()
  1923. {
  1924.   //u8g2.setBusClock(1000000);  //硬件IIC接口使用
  1925.   //u8g2.begin();
  1926.   //u8g2.setContrast(ui.param[DISP_BRI]);
  1927.   
  1928.   u8g2_SetContrast(&u8g2, ui.param[DISP_BRI]);
  1929.   
  1930.   //buf_ptr = u8g2.getBufferPtr();
  1931.   //buf_len = 8 * u8g2.getBufferTileHeight() * u8g2.getBufferTileWidth();
  1932.  
  1933.   buf_ptr = u8g2_GetBufferPtr(&u8g2);
  1934.   buf_len = 8 * u8g2_GetBufferTileHeight(&u8g2) * u8g2_GetBufferTileWidth(&u8g2);
  1935. }
  1936.  
  1937. void flex_ui_setup() 
  1938. {
  1939.   eeprom_init();
  1940.   ui_init();
  1941.   oled_init();
  1942.   btn_init();
  1943.  
  1944.   ESP_LOGI(TAG, "flex ui setup!");
  1945. }
  1946.  
  1947. void flex_ui_loop() 
  1948. {
  1949.   btn_scan();
  1950.   knob_inter();
  1951.   ui_proc();
  1952. }
  1953.  
  1954.  
  1955.

~小结：

         这次主要记录了WouoUI框架在esp32 idf环境下的移植，WouoUI的框架原本是在arduino下面实现的，最终用丙正正实现了移植，移植过程主要难点在于arduino框架u8g2类各种方法的丙语言实现替换，其中又属print重载函数的实现最麻烦，还好最终一一克服，将这优雅的UI呈现在小黑上面；

以下是一些和本文相关的文章链接和U8g2的wiki链接：

一、~~呆萌的瓦力平衡机器人~~链接：

        1.基于ESP32双无刷FOC电机的瓦力平衡机器人（1）；

        2.基于ESP32双无刷FOC电机的瓦力平衡机器人（2）；

二、 ~~U8g2图形库使用技巧记录~~链接：

        1.U8g2图形库使用技巧记录（1）；

        2.U8g2图形库使用技巧记录（2）；

        3.U8g2图形库使用技巧记录（3）；

三、U8g2 wiki链接：

        1.U8g2_wiki；

        2.WouoUI框架,可以直接搜索；

后续的计划：

       目前UI的大体框架已经定型，后续会基于该框架实现小车参数的设置和增加一些动效页面的；          

                      大家如果也感兴趣，可以来这交流学习（这里提供了丰富的esp32资料）：

                             

                                                        燥起来吧！！！！！！ 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/459628
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号