声明：本处所说的菜单是用在128*64这种小屏幕的菜单，不是彩屏上的GUI。例如下面这种

% W3 k5 m" m/ a, a1 D, m4 B! N



作为一个底层驱动工程师，驱动写完了，是要写硬件测试程序的。
& }6 d6 K0 U7 G- J- t这个测试程序，一般给测试部/硬件工程师用来测试硬件，
也会给工厂产线测试准成品。

开始的人偷懒，不想一秒就直接上，所有菜单都这样做，一层套一层

1. void test_main(void)
   / n/ G7 N3 {% k4 e8 Z' l9 t
2. {
   # Z. i0 x4 Q4 v  x
3.         while(1)
   
4.         {
   
5.                 get_key(&key);
   ( w& b6 R& I. @0 \9 F& a' j6 G
6. 
   - M! e6 |9 v1 A7 D
7.                 switch(key)
   
8.                 {
   
9.                         case 1:
   
10.                                 test_key();
    
11.                                 break;
    1 Y* |- e; J& V! `/ }% z: r
12. 
    
13.                         case 2:
    
14.                                 test_lcd();
      ^. I* T) L+ M, ~, A0 a
15.                                 break;
    
16. 
    
17.                         ....
    
18. 
    . x( q  b8 b2 {5 Q
19.                        
    " j0 E& }* b8 R9 m! @
20.                        
    
21.                 }
    & e2 F: w+ Q4 ?7 |* T0 ^
22.        
    - \% ^( X: ^- C9 C4 d% j
23.         }
    
24. }

复制代码

当菜单越来越多，就开始纠结了，，，，
这样写维护不便，看起来也不美，还浪费程序空间。
( F" h# L) m7 L! O
# r7 F. w; H! F0 B作为一个天天看《编程之美》的码农，决定改变现状。
1 ^5 L$ J/ [7 Z" ~0 ]3 M酷狗百度一番，找到了两个参考：
《基于二叉树的多层的液晶菜单界面设计》
《--基于节点编号的通用树状菜单设计方法与实现.pdf》
按照他们的设计方法，鼓捣了一个版本，能用，挺好，但是也纠结。
因为他们用了树这种数据结构。对于程序运行来说，非常好。
: K2 Q: l3 n! f/ q但是对于我来说，菜单代码是一次性的，但是菜单内容，却是会经常改的。
  \' O0 |5 _/ M- C6 m. D让我用人脑去维护一个几十个上百个菜单的树，不容易。
, o& P- U; M  L) b0 Q4 \( E- F$ z
( }& U  M1 [4 ~' W想来想去，这些菜单到底有什么不好？对于我来说，为什么不好用？
得出下面结论：
6 \  X: J- j& d! R# A0 q" ]1 管得太宽
0 C1 T1 U7 o- E" U1 I/ h. u8 V1 U菜单，你就管菜单切换就行了，到了最低一层，也就是实际的测试功能了，就不要管了。
菜单切换时类似的，实际测试都是不同的。比如在菜单中，1，是进入第一个菜单。但是在测试中，按键1，功能都不一样。
" h+ \2 |, N+ x: t* e& g7 m5 t" }如果菜单连这个也要管，太累。
( s6 N2 j" U/ H; _! Z2 出发点不一样
上面说到的菜单，出发点都是如何设计一个好的菜单数据结构，让程序快速，高效运行。
6 j2 S' c# V+ z( T9 v1 b4 O我想要的却是一个容易维护的菜单结构，至于菜单的代码有多乱多纠结，没关系，
而且，几百上千个菜单，就算用轮询的方法，也不过几百us吧，没关系。

根据需求，设计了一个菜单结构体

1. /**
   
2. * @brief  菜单对象
   ; Y+ x9 K" F& t" J& @6 O
3. */
   
4. typedef struct _strMenu
   
5. {
   
6.     MenuLel l;     ///<菜单等级
   
7.     char cha[MENU_LANG_BUF_SIZE];   ///中文
   1 Y. w3 i) c3 N7 Z! W
8.     char eng[MENU_LANG_BUF_SIZE];   ///英文
   
9.     MenuType type;  ///菜单类型
   
10.     s32 (*fun)(void);  ///测试函数
    
11. 
    
12. } MENU;

复制代码

是的，就这么简单，每一个菜单都是这个结构体
9 @( P5 X, N' g3 M5 S用这个结构体填充一个列表，就是我们的菜单了
3 G* o5 q3 V' w7 T

1. 
   7 B1 \- T0 {6 u' Y
2. const MENU EMenuListTest[]=
     u% N* B; E  Z, q+ A
3. {
   $ p2 o6 o  x8 z0 _5 y
4.         MENU_L_0,//菜单等级
   6 u+ {+ g4 L- D+ @
5.         "测试程序",//中文
   " E1 o3 k/ C' o% J4 r
6.         "test",        //英文
   
7.         MENU_TYPE_LIST,//菜单类型
   ! M! T4 l0 P! d* n: H7 a, l
8.         NULL,//菜单函数，功能菜单才会执行，有子菜单的不会执行
   
9. 
   " T* b2 b- R6 _! J
10.                 MENU_L_1,//菜单等级
    
11.                 "LCD",//中文
    . {9 M6 x; T4 }
12.                 "LCD",        //英文
    
13.                 MENU_TYPE_LIST,//菜单类型
    
14.                 NULL,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    $ q* P- V; }4 C
15.                         MENU_L_2,//菜单等级
    
16.                         "VSPI OLED",//中文
    
17.                         "VSPI OLED",        //英文
    
18.                         MENU_TYPE_FUN,//菜单类型
    
19.                         test_oled,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    
20. 
    . b6 I% \! a: F- C
21.                         MENU_L_2,//菜单等级
    
22.                         "I2C OLED",//中文
    
23.                         "I2C OLED",        //英文
    8 p3 ~* R+ g. A+ \6 L; k, `
24.                         MENU_TYPE_FUN,//菜单类型
    
25.                         test_i2coled,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    * C  C! l. c0 C2 }
26. 
    1 B0 \( [* V- K3 A# B4 y7 D
27. 
    
28.                 MENU_L_1,//菜单等级
    
29.                 "声音",//中文
    : u& Q' C! `* Y+ R( `6 ^5 r
30.                 "sound",        //英文
    % N9 j) S2 Z6 r* X$ _
31.                 MENU_TYPE_LIST,//菜单类型
    9 E6 r7 @- G$ ?+ u* L: s" q* g
32.                 NULL,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    . y7 E* G. y) o4 F
33.                         MENU_L_2,//菜单等级
      A) i! O% e$ I( i
34.                         "蜂鸣器",//中文
    0 H% {( n3 i2 U! `9 ^
35.                         "buzzer",        //英文
    ! q/ }$ G- H4 k9 I0 s" s' c
36.                         MENU_TYPE_FUN,//菜单类型
    
37.                         test_test,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    
38. 
    5 I9 O* ~5 [+ q3 V
39.                         MENU_L_2,//菜单等级
    ! v  a3 Q* b3 p9 g3 ?0 _5 C
40.                         "DAC音乐",//中文
    : D. ^+ D3 c1 h* g0 v
41.                         "DAC music",        //英文
    , a# @* y- z" l6 V; E# @" l
42.                         MENU_TYPE_FUN,//菜单类型
    
43.                         test_test,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    
44. 
    : n( b! X8 g& r0 Z3 h; Z+ t
45.                         MENU_L_2,//菜单等级
    # {, P$ |- [" f* E% l1 N1 X
46.                         "收音",//中文
    
47.                         "FM",        //英文
    & M( p* _7 ~0 u8 d, {
48.                         MENU_TYPE_FUN,//菜单类型
    
49.                         test_test,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    : ]7 R# P/ B7 i3 B
50. 
    
51. 
    3 ]4 K: ^7 a) m2 y* V
52.                 MENU_L_1,//菜单等级
    
53.                 "触摸屏",//中文
    ) H1 |" E5 p" P; M! z
54.                 "tp",        //英文
    2 z5 g4 E) p' K5 W0 S
55.                 MENU_TYPE_LIST,//菜单类型
    
56.                 NULL,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    
57.                        
    + Z$ L/ ?% \- s7 Y
58.                         MENU_L_2,//菜单等级
    3 ?; b7 h6 M: H6 l" i' S1 X
59.                         "校准",//中文
    
60.                         "calibrate",        //英文
    
61.                         MENU_TYPE_FUN,//菜单类型
    2 Q" L, C* M) G# a2 ~8 d
62.                         test_cal,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    * z% e/ V- k0 K( z
63. 
    3 d& b4 ?- n- S5 k7 {& t
64.                         MENU_L_2,//菜单等级
    
65.                         "测试",//中文
    " n+ A; V) r. W9 Y/ {6 f1 _
66.                         "test",        //英文
    
67.                         MENU_TYPE_FUN,//菜单类型
    # L1 Q8 |# {7 Q! T- z2 e/ {( P
68.                         test_tp,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    
69.                        
    3 I6 `9 i, d- m& K9 k+ t
70.                 MENU_L_1,//菜单等级
    
71.                 "按键",//中文
    
72.                 "KEY",        //英文
    ; Q; S" Y  k! h* d% @
73.                 MENU_TYPE_FUN,//菜单类型
    
74.                 test_key,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    / U2 G1 Q- w8 e; K5 o
75. 
    
76.         /*最后的菜单是结束菜单，无意义*/                       
    
77.         MENU_L_0,//菜单等级
    
78.         "END",//中文
    
79.         "END",        //英文
    * G/ `' d4 c7 p$ h% h! z( l
80.         MENU_TYPE_NULL,//菜单类型
    
81.         NULL,//菜单函数，功能菜单才会执行，有子菜单的不会执行
    
82. };

复制代码

这个菜单列表有什么特点和要求呢？
9 A2 b! i9 U% l- x7 {) q1 需要一个根节点和结束节点
& B2 A8 k/ ^( [" m" H! W  N8 j2 子节点必须跟父节点，类似下面结构
' n3 p. b7 c) `+ _4 j4 _( ^-----------------------------------------------
3 h  p1 ]$ a* o* d- b根节点
        第1个1级菜单
                       第1个子菜单
                       第2个子菜单
0 W" {- @2 o1 e2 o5 N9 E9 L9 G+ I                       第3个子菜单
2 @5 h$ a' {" ^5 h# z# u, w        第2个1级菜单
# T) y/ Z2 {! O: `: ?, N1 j2 w                       第1个子菜单
                                     第1个孙菜单
                                     第2个孙菜单
                       第2个子菜单
                       第3个子菜单
1 _, E0 v) a& _7 o        第3个1级菜单
+ Z6 `6 ]0 n0 j, D( ]) e: h+ u" W8 P        第4个1级菜单
5 Y$ x1 w( a7 Z  y5 o        第5个1级菜单
4 B) o3 C8 f' i$ N结束节点
; T8 I( W1 g) ?# O------------------------------------------------
. K1 b7 {3 p1 K) L& `- {2 `第2个1级菜单有3个子菜单，子菜单是2级菜单，其中第1个子菜单下面又有2个孙菜单（3级菜单）。
+ E2 L5 R$ s' |" f8 M
' {. R2 N/ B6 w' w% V2 x, q维护菜单，就是维护这个列表，添加删除修改，非常容易。
那菜单程序怎么样呢？管他呢。
& d7 S! ?/ e, H# I% g; S定义好菜单后，通过下面函数运行菜单，

1. emenu_run(WJQTestLcd, (MENU *)&WJQTestList[0], sizeof(WJQTestList)/sizeof(MENU), FONT_SONGTI_1616, 2);       

复制代码

-第1个参数是在哪个LCD上显示菜单，
-第2个是菜单列表，
-第3个是菜单长度，
" I+ }6 d7 |- N-第4个四字体，
0 N) f; g' [; v! w-第5则是行间距
. j; O# a0 s6 ]+ \# b( U& V- h4 m

注意：
运行这个菜单需要有rtos，因为菜单代码是while(1)的，陷进去就不出来了。
需要有其他线程(TASK)维护系统，例如按键扫描。
, x  h& o( W2 ?) M: T
, M/ M/ p* Y9 n6 I3 N9 ~' r代码托管在github：http://github.com/wujique/stm32f407/tree/sw_arch
相关文件：emenu.c/emenu.h/emenu_test.c

当前代码：
1实现了双列菜单，用数字键选择进入下一层。每页最多显示8个菜单（4*4键盘用1-8键）
9 w+ J% a. ~# N' c8 t2 实现了单列菜单，通过上下翻查看菜单，确认键进入菜单。
3 天顶菜单未实现，谁有兴趣可以加上。
3 基于LCD驱动架构，这个简易菜单自适应于多种LCD。

效果如下，有需要的尽管拿去，不用谢。

OLED效果

3 M! \! E+ D/ F7 e

7 q3 L4 d/ s1 L- ~" N
1.44 128*128 tftlcd 效果
4 M8 E: w" v1 M
  k% x7 m0 g9 ^0 I: f2 \& c


# W' D9 ^1 B' Q# i5 R4 D7 s( O2.8 320*240 tftlcd 效果

3 T9 Z( c! c0 X# {" _3 N, @5 p
! X; a2 u# h1 A, f& V2 N
# l, v. a+ ^8 b: r) _( a2 I$ o) @

) v5 v+ c" O( Z5 ~路过点个赞呗！

* N0 d0 x' `6 Y! ?) K

l297915958 发表于 2019-2-23 11:12
6 c! o# `" g1 w  Z' `, w楼主哥哥，新手32学习，您这个菜单的实验程序有吗，可以分享一下吗，我加你联系方式 ...

在github上有最新的

huangxuejia-292 发表于 2018-6-25 09:14
都在玩GUI，这么简陋的东西，不知道还有没有人用。。。。。

大把的人用 很实用 感谢楼主分享

wolfgang2015 发表于 2018-6-25 11:00
麻烦的东东，继续优化；
" d$ }; F8 v/ ]# n3 d潜在问题：返回上级菜单

' L' O9 I6 I1 j3 q9 K. R% ~版主，你是说返回上级菜单有问题吗？

都在玩GUI，这么简陋的东西，不知道还有没有人用。。。。。

虽然我目前用不上GUI，但是楼主给的思路有一定的启发作用，感谢分享

我们产品上就有菜单，和楼主思路类似

strang 发表于 2018-6-25 10:01
我们产品上就有菜单，和楼主思路类似

有什么好设计提醒提醒我，我优化优化

用函数指针做界面，每个函数里都有while(1)

麻烦的东东，继续优化；
/ K& j3 o. a) l! `9 K潜在问题：返回上级菜单

很赞！

双向链表 基本都是菜单的路子

楼主哥哥，新手32学习，您这个菜单的实验程序有吗，可以分享一下吗，我加你联系方式

这个要点赞。

谢谢楼主收藏