无痕幽雨
无痕幽雨

菜单技术

出处：https://www.amobbs.com/thread-5688720-1-1.html

说在前面的话


      从我第一次讨论菜单技术（2006年）到现在，已经十多年过去了。回想起来，当时还是大一新生，一个
亲切的学姐找到我，请我帮她的毕业设计——凌阳声控机器人小车做一个液晶菜单，并许诺请我吃学校老区
最著名的新疆大盘鸡。有小姐姐请客吃饭自然动力满满，我立马熬了一个通宵好搞定了程序。老区的大盘鸡
什么味道 我连同学姐的脸一起已经忘得差不多了，好在这个菜单程序却幸存了下来，在之后的一年被我作为
凑字数的素材强行安插在 了[古董贴][交流]怎样在点阵屏上绘图——基于LCD12864的一百楼。

      现在再看当年的程序，真是恨不得找个地缝钻进去——除了原理是勉强对的，其它细节真的是……一言难
尽——说好听了叫青涩，说难听了就是一坨屎……不好意思，我就是这么直接。我摘抄一段，大家感受一下：

  2. struct MenuItem        
  3. {
  4.     char MenuCount;
  5.     char *DisplayString;
  6.     void (*Subs)();
  7.     struct MenuItem *ChildrenMenus;
  8.     struct MenuItem *ParentMenus;
  9. }NULL_MENU;

  11. void NULL_FUNCTION(void){}

  13. struct MenuItem MainMenu[3];
  14. struct MenuItem TimeMenu[4];
  15. struct MenuItem VoiceMenu[5];
  16. struct MenuItem RobotMenu[5];
  17. struct MenuItem FlashMenu[5];

  19. void FlashMenuInit(void)
  20. {
  21.     FlashMenu[0].MenuCount = 5;
  22.     FlashMenu[0].DisplayString = "  Flash Record  ";
  23.     FlashMenu[0].Subs = FlashRecord;
  24.     FlashMenu[0].ChildrenMenus = &Null;
  25.     FlashMenu[0].ParentMenus = MainMenu;

  27.     ...
  28. }

复制代码


以下是吐槽，可以忽略……

    首先来说说这个结构体。

  2. struct MenuItem        
  3. {
  4.     char MenuCount;
  5.     char *DisplayString;
  6.     void (*Subs)();
  7.     struct MenuItem *ChildrenMenus;
  8.     struct MenuItem *ParentMenus;
  9. }NULL_MENU;
复制代码

  •         槽点1：  为毛不用typedef
  •         槽点2：  为毛不用 stdint 里面的标准类型？
  •         槽点3：  为毛要浪费一个字节来保存  MenuCount？
  •         槽点4：  函数指针  void (*Subs)()  为毛形参要省略 void ？
  •         槽点5：  为什么每一个菜单项（MenuItem）都要包含一个指向父目录的指针？
  •         槽点6：  为什么缺失了 专门的类型来描述菜单？（这里是直接用 MenuItem 的数组裸体上阵直接表示一个menu）
  •         槽点7：  NULL_MENU是什么鬼？为什么要浪费这个空间？
  •         槽点8：  菜单项处理函数的原型，为什么返回值是void？难道不应该是一个状态机么？（返回 fsm_rt_t）
  •         ...
  •         槽点n： 没有用匈牙利算不算……


    再来说说这个结构体的初始化:

  2. struct MenuItem MainMenu[3];
  3. struct MenuItem TimeMenu[4];
  4. struct MenuItem VoiceMenu[5];
  5. struct MenuItem RobotMenu[5];
  6. struct MenuItem FlashMenu[5];

  8. void FlashMenuInit(void)
  9. {
  10.     FlashMenu[0].MenuCount = 5;
  11.     FlashMenu[0].DisplayString = "  Flash Record  ";
  12.     FlashMenu[0].Subs = FlashRecord;
  13.     FlashMenu[0].ChildrenMenus = &Null;
  14.     FlashMenu[0].ParentMenus = MainMenu;

  16.     ...
  17. }
复制代码


  •     槽点1： 为什么不用typedef的类型？（好吧也许不算个槽点）
  •     槽点2： 为什么不用静态赋值的方法初始化？（这里用的是一个函数）
  •     槽点3： 为什么数组的大小要直接用数字给定？（应该通过静态初始化由编译器来确定数组的大小）
  •     槽点4： 请大家无视“&Null”，这是我人生的污点……


    从结论上看，一坨屎的数据结构是不可能写出秀色可餐的算法的，所以请大家无视菜单的处理函数，我自
己也懒得吐槽了。

    让我们抛开过去，重新审视下这个话题：
嵌入式系统中，如何使用C语言构建一个可维护性强的图式菜单。
【注】这里的图式菜单说的是菜单的数据结构是网状的，使用图论的方式来构建和维护


构建菜单的数据结构

    设计一个服务的数据结构，不仅要考虑用户的需求还要将目标环境的限制考虑在内。就菜单服务来说，我
们不光希望菜单的描述和维护简便、能适应不同类型的GUI（文字的还是图形化的），还要考虑嵌入式环境的
一些特点，比如对ROM和RAM的消耗要尽可能的小、嵌入式应用通常不会涉及到动态改变菜单结构、菜单服务
要能方便的进行裁剪和扩展等等。

    基于上述考虑，参考其它高级语言的常见菜单结构，我们决定使用“菜单容器”+"菜单项"的二元结构来构建
菜单的基本数据结构。简单的说就是我们要定义两个结构体，一个专门用来描述菜单项，一个专门作为容器来
装载菜单项，并追加菜单作为整体存在时所需的一些属性。

    首先从菜单项开始，容易得到：


  3. typedef struct __menu_item  menu_item_t;
  4. typedef struct __menu      menu_t;

  6. typedef fsm_rt_t menu_item_handler_t(menu_item_t *);

  8. struct __menu_item {
  9.     menu_item_handler_t *fnHandle;                      //!< handler
  10.     menu_t              *ptChild;                       //!< Child Menu
  11.     
  12.     //! depends on your application, you can add/remove/change following members
  13.     char                *pchTitle;                      //!< Menu Title
  14.     char                *pchDescription;                //!< Description for this menu item
  15.     char                chShortCutKey;                  //!< Shortcut Key value in current menu
  16. };
复制代码

    这里我们看到，菜单项的结构性主体由一个函数指针fnHandle和指向子目录的指针ptChild构成。一般来说，
二者是互斥的：
  • 当fnHandle不为NULL、指向对应的处理函数而ptChild为NULL时表示这是一个普通的菜单项，当用户选择了
    这一选项时，对应的处理程序就会被执行。值得注意的是，这里的fnHandler指向的是一个状态机，这意味着
    菜单引擎即有能力实现一个非阻塞的菜单结构，也可以无视状态机的返回，实现一个“一次性”的阻塞式菜单
    处理程序。
  • 当ptChild不为NULL、指向下一级菜单而fnHandler为NULL时表示这是一个多级菜单的入口。
  • ptChild和fnHandler同时不为空的情况较为少见，一般为了满足某些特殊的需求，需要定制特定的菜单引擎
    来配合。


    菜单项menu_item_t的剩下部分是和菜单的显示方式，或者说与菜单的外观效果高度相关的。根据需求的
不同，应该在这里添加对应的成员变量，比如例子中的 pchTitle用以保存菜单文字、pchDescription用以保存
菜单的简易提示信息，可以在用户悬停时以气球或者statusbar的形式进行显示。Windows菜单一般都有一个
快捷热键，如果我们的系统也希望增加这样的功能，那么chShortCutKey就是一个必不可少的部分，反之则是
多余的；甚至很多时候，简单的一个title就可以解决大部分问题。

    有些时候，我们希望用更为炫酷的方式来呈现菜单，而此时菜单的逻辑结构却是和菜单的显示方式无关的，
因此，在menu_item_t里加入额外的显示处理函数、字体、前景色、背景色、图标等等的描述（或者指针）
都是必要的。此时，你会发现，基础的menu_item_t更像是一个基类，而我们根据实际情况则需要继承和派生
出符合我们自己的实现形式。为了适应这一设定，我们将menu_item_t拆分成两个部分：

    基类部分 menu_item_t:

  2. typedef struct __menu_item  menu_item_t;
  3. typedef struct __menu      menu_t;

  5. typedef fsm_rt_t menu_item_handler_t(menu_item_t *);

  7. struct __menu_item {
  8.     menu_item_handler_t *fnHandle;                      //!< handler
  9.     menu_t              *ptChild;                       //!< Child Menu
  10. };
复制代码

    以及一个满足大部分应用情形的默认模板（派生类）：


  3. typedef struct __default_menu_item_t  default_menu_item_t;

  5. struct __default_menu_item_t   {

  7.     //! inherit from base class menu_item_t
  8.     menu_item_t; 

  10.     //! depends on your application, you can add/remove/change following members
  11.     char                *pchTitle;                      //!< Menu Title
  12.     char                *pchDescription;                //!< Description for this menu item
  13.     char                chShortCutKey;                  //!< Shortcut Key value in current menu
  14. };

复制代码


为了让模板的定义更为简单，我们提供了以下的宏进行辅助：
【注】如果你觉得宏让你头晕，请忽略这部分，它对理解这个菜单结构并没有实质性的作用。


  2. #define __declare_menu_item_template(__NAME)                                    \
  3.     typedef struct __##__NAME __NAME;
  4. #define declare_menu_item_template(__NAME)                                      \
  5.         __declare_menu_item_template(__NAME)
  6.     
  7. #define __def_menu_item_template(__NAME)                                        \
  8.     struct __##__NAME {                                                         \
  9.         menu_item_t;                                                            
  10. #define def_menu_item_template(__NAME)                                          \
  11.             __def_menu_item_template(__NAME)                                    

  13. #define end_def_menu_item_template(__NAME)                                      \
  14.     };
复制代码


因此，前面的默认模板就可以用极为简单的形式进行描述：


  3. typedef struct __menu_item  menu_item_t;
  4. typedef struct __menu      menu_t;

  6. typedef fsm_rt_t menu_item_handler_t(menu_item_t *);

  8. struct __menu_item {
  9.     menu_item_handler_t *fnHandle;                      //!< handler
  10.     menu_t              *ptChild;                       //!< Child Menu
  11. };


  14. declare_menu_item_template(default_menu_item_t)

  16. def_menu_item_template(default_menu_item_t)
  17.     //! depends on your application, you can add/remove/change following members
  18.     char                *pchTitle;                      //!< Menu Title
  19.     char                *pchDescription;                //!< Description for this menu item
  20.     char                chShortCutKey;                  //!< Shortcut Key value in current menu
  21. end_def_menu_item_template(default_menu_item_t)
复制代码


    你也可以参考这种形式通过这一系列宏来定义自己的菜单项模板。这里就不再赘述。接下来，我们来看看
菜单容器（menu_t）的结构：

  2. typedef struct __menu_engine_cb menu_engine_cb_t;
  3. typedef fsm_rt_t menu_engine_t(menu_engine_cb_t *);

  5. struct __menu {
  6.     menu_item_t        *ptItems;                        //!< menu item list
  7.     uint_fast8_t        chCount;                        //!< menu item count
  8.     menu_t             *ptParent;                       //!< parent menu;
  9.     menu_engine_t      *fnEngine;                       //!< engine for process current menu
  10. }; 
复制代码


  • 非常直接的，menu_t结构体的前两个成员就是体现其容器作用的ptItems和chCount。前者指向具体的菜单
    项数组，后者用以描述数组中有效的菜单项个数。
  • ptParent用以指向当前菜单的父菜单。单一的指针限定了当前菜单的扇入为1——也就是只有唯一的一个父
    目录——这对大部分应用来说不是什么问题。如果要支持更为灵活的结构，解决方案并不是在这里追加父目录
    指针的数量，而是在这一数据结构外额外增加一个动态的单链表，用以记录用户打开目录的路径，用以实现与
    手机浏览时常见的“返回之前页面”类似的效果——在这种情况下，ptParent理论上也可以从结构体中删除。
  • 一般来说，简单的应用倾向于给每一个菜单都使用同样的导航方式（根据按键处理菜单选择的方式）——
    也就是说唯一的一个菜单引擎就够了，然而在一些复杂的情况下，不同的菜单可能有自己独特的按键布局和
    菜单跳转需要——比如前一个目录是简单的线性排列结构而后面一个目录是平面的二维目录结构，他们对按键
    的响应方式是不同的——在这种情况下，为每一个菜单增加一个指向对应菜单引擎的函数指针就非常有必要了。


    看过 menu_item_t 推演过程的朋友可能会有疑问了，menu_t 是否也有作为基类在需要的时候进行扩展的可
能呢？答案是肯定的。实际上，fnEngine 就可以被看作是扩展出来的。同样的，如果GUI非常炫酷，我们需要
给不同的菜单提供不同的背景色、背景图片、前景色等等属性时，我们也需要把 menu_t 当作是一个基类，并
根据自己的需要进行对应的扩展。这是一个举一反三地过程，我很乐意把这一发挥空间留给大家，根据自己的
实际情况去扩展，这里就不再赘述。

    总结下来，我们完成了菜单最基础的数据结构，并初步定义了一些宏来简化菜单项模板的定义：

  2. #ifndef __FSM_RT_TYPE__
  3. #define __FSM_RT_TYPE__
  4. //! \name finit state machine state
  5. //! @{
  6. typedef enum {
  7.     fsm_rt_err          = -1,    //!< fsm error, error code can be get from other interface
  8.     fsm_rt_cpl          = 0,     //!< fsm complete
  9.     fsm_rt_on_going     = 1,     //!< fsm on-going
  10.     fsm_rt_wait_for_obj = 2,     //!< fsm wait for object
  11.     fsm_rt_asyn         = 3,     //!< fsm asynchronose complete, you can check it later.
  12. } fsm_rt_t;
  13. //! @}

  15. #endif


  18. typedef struct __menu_item  menu_item_t;
  19. typedef struct __menu      menu_t;

  21. typedef fsm_rt_t menu_item_handler_t(menu_item_t *);

  23. struct __menu_item {
  24.     menu_item_handler_t *fnHandle;                      //!< handler
  25.     menu_t              *ptChild;                       //!< Child Menu
  26. };

  28. typedef struct __menu_engine_cb menu_engine_cb_t;
  29. typedef fsm_rt_t menu_engine_t(menu_engine_cb_t *);

  31. struct __menu {
  32.     menu_item_t        *ptItems;                        //!< menu item list
  33.     uint_fast8_t        chCount;                        //!< menu item count
  34.     menu_t             *ptParent;                       //!< parent menu;
  35.     menu_engine_t      *fnEngine;                       //!< engine for process current menu
  36. }; 

复制代码



“菜单的描述要优雅”


    有了菜单的数据结构为基础，我们就可以来考虑如何描述一个实际的菜单，也就是底层上如何对一个菜单数据
结构进行初始化的问题。基于 default_menu_item_t 一个可能的初始化形式是：

  2. extern fsm_rt_t top_menu_engine(menu_engine_cb_t*ptThis);

  4. extern fsm_rt_t top_menu_item_a_handler(menu_item_t *ptItem);
  5. extern fsm_rt_t top_menu_item_b_handler(menu_item_t *ptItem);
  6. extern fsm_rt_t top_menu_item_c_handler(menu_item_t *ptItem);

  8. extern const menu_t c_tTopMenu;

  10. default_menu_item_t c_tTopMenuItems[] = {
  11.     {
  12.         top_menu_item_a_handler,
  13.         NULL,                                           //!< child menu
  14.         "Top Menu A",
  15.         "This is Top Menu A",
  16.     },
  17.     {
  18.         top_menu_item_b_handler,
  19.         NULL,                                           //!< child menu
  20.         "Top Menu B",
  21.         "This is Top Menu B"
  22.     },
  23.     {
  24.         top_menu_item_c_handler,
  25.         NULL,                                           //!< child menu
  26.         "Top Menu C",
  27.         "This is Top Menu C"
  28.     }
  29. };

  31. const menu_t c_tTopMenu = {
  32.     (menu_item_t *)c_tTopMenuItems,                                    //!< menu item list
  33.     UBOUND(c_tTopMenuItems),                            //!< menu item count
  34.     NULL,                                               //!< top menu has no parent
  35.     top_menu_engine,                                    
  36. };


  39. fsm_rt_t top_menu_item_a_handler(menu_item_t *ptItem)
  40. {
  41.     return fsm_rt_cpl;
  42. }

  44. fsm_rt_t top_menu_item_b_handler(menu_item_t *ptItem)
  45. {
  46.     return fsm_rt_cpl;
  47. }

  49. fsm_rt_t top_menu_item_c_handler(menu_item_t *ptItem)
  50. {
  51.     return fsm_rt_cpl;
  52. }

  54. fsm_rt_t top_menu_engine(menu_engine_cb_t*ptThis)
  55. {
  56.     return fsm_rt_cpl;
  57. }
复制代码


通过加入一些辅助宏，我们可以让这个初始化的菜单的定义过程更简单（只消耗ROM）：
【注】如果你觉得宏让你头晕，请忽略这部分，它对理解这个菜单结构并没有实质性的作用。


  2. #define __def_menu(__NAME, __PARENT, __ENGINE, __TEMPLATE)                      \
  3. extern const menu_t c_tMenu##__NAME;                                            \
  4. __TEMPLATE c_tMenu##__NAME##Items[] = {
  5. #define def_menu(__NAME, __PARENT, __ENGINE)                                    \
  6.             __def_menu(__NAME, (__PARENT), (__ENGINE), default_menu_item_t)
  7.             
  8. #define def_menu_ex(__NAME, __PARENT, __ENGINE, __TEMPLATE)                     \
  9.             __def_menu(__NAME, (__PARENT), (__ENGINE), __TEMPLATE)

  11. #define __end_def_menu(__NAME, __PARENT, __ENGINE, __TEMPLATE)                  \
  12.     };                                                                          \
  13.     const menu_t c_tMenu##__NAME = {                                            \
  14.         (menu_item_t *)c_tMenu##__NAME##Items,                                  \
  15.         (sizeof(c_tMenu##__NAME##Items)/sizeof(__TEMPLATE)),                    \
  16.         (menu_t *)(__PARENT),                                                   \
  17.         (__ENGINE),                                                             \
  18.     };
  19. #define end_def_menu(__NAME, __PARENT, __ENGINE)                                \
  20.             __end_def_menu(__NAME, (__PARENT), (__ENGINE), default_menu_item_t)
  21. #define end_def_menu_ex(__NAME, __PARENT, __ENGINE, __TEMPLATE)                 \
  22.             __end_def_menu(__NAME, (__PARENT), (__ENGINE), __TEMPLATE)
  23.             
  24. #define __extern_menu(__NAME)   extern const menu_t c_tMenu##__NAME;
  25. #define extern_menu(__NAME)     __extern_menu(__NAME)

  27. #define __menu(__NAME)          c_tMenu##__NAME
  28. #define menu(__NAME)            __menu(__NAME)            
  29.           
  30. #define __menu_item(__HANDLER, __CHILD_MENU, ...)                               \
  31.     {                                                                           \
  32.         (__HANDLER),                                                            \
  33.         (menu_t *)(__CHILD_MENU),                                               \
  34.         __VA_ARGS__,                                                            \
  35.     },
  36. #define menu_item(__HANDLER, __CHILD_MENU, ...)                                 \
  37.             __menu_item((__HANDLER), (__CHILD_MENU), __VA_ARGS__)
复制代码


从前面的宏中，我们注意到无论是 def_menu 还是 end_def_menu 都默认的采用了 default_menu_item_t 作为菜
单项的模板，因此，前面初始化的例子就等效的可以简化为：

  2. extern fsm_rt_t top_menu_engine(menu_engine_cb_t*ptThis);

  4. extern fsm_rt_t top_menu_item_a_handler(menu_item_t *ptItem);
  5. extern fsm_rt_t top_menu_item_b_handler(menu_item_t *ptItem);
  6. extern fsm_rt_t top_menu_item_c_handler(menu_item_t *ptItem);


  9. def_menu(TopMenu, NULL, top_menu_engine)
  10.     menu_item(
  11.         top_menu_item_a_handler, 
  12.         NULL, 
  13.         "Top Menu A",
  14.         "This is Top Menu A"
  15.     )
  16.     menu_item(
  17.         top_menu_item_a_handler, 
  18.         NULL, 
  19.         "Top Menu B",
  20.         "This is Top Menu B"
  21.     )
  22.     menu_item(
  23.         top_menu_item_a_handler, 
  24.         NULL, 
  25.         "Top Menu C",
  26.         "This is Top Menu C"
  27.     )
  28. end_def_menu(TopMenu, NULL, top_menu_engine)


  31. fsm_rt_t top_menu_item_a_handler(menu_item_t *ptItem)
  32. {
  33.     return fsm_rt_cpl;
  34. }

  36. fsm_rt_t top_menu_item_b_handler(menu_item_t *ptItem)
  37. {
  38.     return fsm_rt_cpl;
  39. }

  41. fsm_rt_t top_menu_item_c_handler(menu_item_t *ptItem)
  42. {
  43.     return fsm_rt_cpl;
  44. }

  46. fsm_rt_t top_menu_engine(menu_engine_cb_t*ptThis)
  47. {
  48.     return fsm_rt_cpl;
  49. }
复制代码


    当我们要采用自己定义的菜单项模板（而不是默认的 default_menu_item_t ）时，应该使用宏 def_menu_ex，并
将自己定义的模板作为最后一个参数传递给该宏。注意到 menu_item 宏的最后一项是可变参数列表，因此无论你的
模板扩展了多少元素，都可以放心的使用 menu_item() 宏进行初始化：


  3. declare_menu_item_template( my_menu_item_t )
  4. def_menu_item_template( my_menu_item_t )
  5. ...
  6. end_def_menu_item_template( my_menu_item_t )



  10. def_menu_ex( my_top_menu, NULL, top_menu_engine,  my_menu_item_t  )

  12. ...
  13.     menu_item(
  14.         top_menu_item_a_handler,
  15.         NULL,
  16.         //! initialise the extended members 
  17.         ...
  18.     )
  19. ...

  21. end_def_menu_ex( my_top_menu, NULL, top_menu_engine,  my_menu_item_t  )

复制代码


     使用上述方式构建的菜单，会消耗多少SRAM呢？答案是0。观察数据结构，我们会注意到，描述菜单的结构体的
值在编译时刻都是已知的——并且，这个并且至关重要——我们扩展的模板也不会引用（指针指向）或者包含任何在
运行时刻会发生变化的内容，因此完全可以将整个数据结构保存在ROM中——在ARM体系架构下，简单的const就可以
完成这一使命——如果你使用了不同的平台，则应该根据自己的实际情况修改前述的宏模板，使得最终产生的菜单内容
被保存在ROM中。

    下面我们来看一个2级菜单的例子（更多级菜单的情况请以此类推）：

  2. extern fsm_rt_t default_menu_engine(menu_engine_cb_t*ptThis);

  4. extern fsm_rt_t top_menu_item_a_handler(menu_item_t *ptItem);
  5. extern fsm_rt_t top_menu_item_b_handler(menu_item_t *ptItem);
  6. extern fsm_rt_t top_menu_item_c_handler(menu_item_t *ptItem);

  8. extern_menu(lv2_menu_A)

  10. def_menu(TopMenu, NULL, default_menu_engine)
  11.     menu_item(
  12.         top_menu_item_a_handler, 
  13.         &menu(lv2_menu_A), 
  14.         "Top Menu A",
  15.         "This is Top Menu A"
  16.     )
  17.     menu_item(
  18.         top_menu_item_a_handler, 
  19.         NULL, 
  20.         "Top Menu B",
  21.         "This is Top Menu B"
  22.     )
  23.     menu_item(
  24.         top_menu_item_a_handler, 
  25.         NULL, 
  26.         "Top Menu C",
  27.         "This is Top Menu C"
  28.     )
  29. end_def_menu(TopMenu, NULL, default_menu_engine)




  34. extern fsm_rt_t lv2_menu_item_1_handler(menu_item_t *ptItem);

  36. def_menu(lv2_menu_A, &menu(TopMenu), default_menu_engine)
  37.     menu_item(
  38.         lv2_menu_item_1_handler, 
  39.         NULL, 
  40.         "Lv2 Menu 1",
  41.         "This is Lv2 Menu 1"
  42.     )
  43.    ...
  44. end_def_menu(lv2_menu_1, &menu(TopMenu), default_menu_engine)


复制代码


“实际咋用”


定义好的menu数据结构怎么引用呢？

需要用到变量的时候，用menu宏，例如：

  2.     menu_t *ptThis = &menu(TopMenu);                        
复制代码


如果要extern给其它.c文件使用怎么办呢？使用extern_menu宏，例如：

  2. ...
  3.     extern_menu(TopMenu);
  4. ...                       
复制代码


     通过前面的内容，我们会很容易注意到，这个菜单结构的灵活性还体现在菜单的处理函数上，不仅每一个目录可以单
独指定处理引擎，每一个菜单项也都可以通过状态机的形式来处理具体的菜单事件。抛开应用高度相关的菜单项处理函数
不谈，我们来重点看一看菜单的引擎（以默认菜单引擎为例）：

  2. fsm_rt_t default_menu_engine(menu_engine_cb_t*ptThis)
  3. {
  4.      ...
  5.      return fsm_on_going;
  6. }
复制代码


  • 这是一个状态机，意味着菜单的处理可以是非阻塞的，这对喜欢酷炫特效以及需要在菜单后面做小动作的应用来说非常
    关键。状态机的模板参考我专门的帖子。在106楼的例子非常有参考价值，这里就不具体展开了。
  • 状态机的传入参数 ptThis 指向的是一个菜单引擎的runtime控制块，里面存放的是关于菜单当前状态的各种信息，容易
    想到：

    2. typedef struct __menu_engine_cb menu_engine_cb_t;
    3. typedef fsm_rt_t menu_engine_t(menu_engine_cb_t *);

    5. struct __menut {
    6.     menu_item_t        *ptItems;                        //!< menu item list
    7.     uint_fast8_t        chCount;                        //!< menu item count
    8.     menu_t             *ptParent;                       //!< parent menu;
    9.     menu_engine_t      *fnEngine;                       //!< engine for process current menu
    10. }; 

    12. struct __menu_engine_cb {
    13.     const menu_t    *ptCurrentMenu;
    14.     uint_fast8_t    chCurrentItemIndex;
    15. };
    复制代码

    这里，ptCurrentMenu是一个指向当前菜单的指针，而chCurrentItemIndex保存的就是当前用户选中的菜单项的数组下标。
    仅靠这两个变量，理论上再配合按键输入，已经能够实现一个简单的菜单引擎。实际上，考虑到目录菜单引擎是一个状态
    机，因而将状态机变量也放在menu_engine_cb_t中也是可行的，比如：

    2. struct __menu_engine_cb {
    3.     uint_fast8_t tState;
    4.     const menu_t    *ptCurrentMenu;
    5.     uint_fast8_t    chCurrentItemIndex;
    6. };
    复制代码


    这里给出一个简化的引擎范例（伪代码）：


    3. #ifndef this
    4. #   define this        (*ptThis)
    5. #endif

    7. typedef enum {
    8.     KEY_NULL = 0,
    9.     KEY_DOWN,
    10.     KEY_UP,
    11.     KEY_ENTER,
    12.     KEY_ESC,
    13. } key_t;

    15. extern key_t get_key(void);

    17. fsm_rt_t default_menu_engine(menu_engine_cb_t *ptThis)
    18. {
    19. #define DEFAULT_MENU_ENGINE_RESET_FSM() \
    20.     do { this.tState = START; } while(0)

    22.     enum {
    23.         START = 0,
    24.         READ_KEY_EVENT, 
    25.         KEY_PROCESS, 
    26.         RUN_ITEM_HANDLER
    27.     };
    28.     key_t tKey;
    29.     menu_item_t *ptItem;
    30.     
    31.     switch(this.tState) {
    32.         case START:
    33.             this.tState++;
    34.         case READ_KEY_EVENT: 
    35.             tKey = get_key();
    36.             if (KEY_NULL == tKey) {
    37.                 break;
    38.             }
    39.             //this.tState = KEY_PROCESS;
    40.             
    41.         case KEY_PROCESS:
    42.             switch (tKey) {
    43.                 case KEY_DOWN:
    44.                     this.chCurrentItemIndex++;
    45.                     if (this.chCurrentItemIndex >= this.ptCurrentMenu->chCount) {
    46.                         this.chCurrentItemIndex = 0;
    47.                     }
    48.                     break;
    49.                 case KEY_UP:
    50.                     if (0 == this.chCurrentItemIndex) {
    51.                         this.chCurrentItemIndex = this.ptCurrentMenu->chCount - 1;
    52.                     }
    53.                     break;
    54.                 case KEY_ENTER: {
    55.                         ptItem = &(this.ptCurrentMenu->ptItems[this.chCurrentItemIndex]);
    56.                         if (NULL != ptItem->fnHandle) {
    57.                             this.tState = RUN_ITEM_HANDLER;
    58.                         } else if (NULL != ptItem->ptChild) {
    59.                             this.ptCurrentMenu = ptItem->ptChild;
    60.                             this.chCurrentItemIndex = 0;
    61.                             
    62.                             DEFAULT_MENU_ENGINE_RESET_FSM();
    63.                             return fsm_rt_cpl;
    64.                         }
    65.                     }
    66.                     break;
    67.                 case KEY_ESC:
    68.                 
    69.                     //! return to upper menu
    70.                     if (NULL != this.ptCurrentMenu->ptParent) {
    71.                         this.ptCurrentMenu = this.ptCurrentMenu->ptParent;
    72.                         this.chCurrentItemIndex = 0;
    73.                             
    74.                         DEFAULT_MENU_ENGINE_RESET_FSM();
    75.                         return fsm_rt_cpl;
    76.                     }
    77.                     break;
    78.                 default:
    79.                     break;
    80.             }
    81.             break;
    82.             
    83.         case RUN_ITEM_HANDLER:
    84.             ptItem = &(this.ptCurrentMenu->ptItems[this.chCurrentItemIndex]);
    85.             fsm_rt_t tFSM = ptItem->fnHandle(ptItem);
    86.             if (IS_FSM_ERR(tFSM)) {
    87.                 //! report error
    88.                 DEFAULT_MENU_ENGINE_RESET_FSM();
    89.                 return tFSM;
    90.             } else if (fsm_rt_cpl == tFSM) {
    91.                 DEFAULT_MENU_ENGINE_RESET_FSM();
    92.                 return fsm_rt_cpl;
    93.             }
    94.             break;
    95.     }

    97.     return fsm_rt_on_going;
    98. }
    复制代码




最后我们还需要一个最顶层的任务，用来运行我们这个菜单服务（这个顶层任务和具体用哪个引擎无关）：


  3. #ifndef this
  4. #   define this        (*ptThis)
  5. #endif


  8. fsm_rt_t menu_task(menu_engine_cb_t *ptThis)
  9. {
  10.     do {
  11.         /* this validation code could be removed for release version */
  12.         if (NULL == ptThis) {
  13.             break;
  14.         } else if (NULL == this.ptCurrentMenu) {
  15.             break;
  16.         } else if (NULL == this.ptCurrentMenu->fnEngine) {
  17.             break;
  18.         } else if (NULL == this.ptCurrentMenu->ptItems) {
  19.             break;
  20.         } else if (0 == this.ptCurrentMenu->chCount) {
  21.             break;
  22.         }
  23.         
  24.         return this.ptCurrentMenu->fnEngine(ptThis);
  25.         
  26.     } while(false);
  27.     
  28.     return fsm_rt_err;
  29. }

  31. static menu_engine_cb_t s_tMenuDemo = {
  32.     .ptCurrentMenu = &menu(TopMenu),
  33. };

  35. void main(void)
  36. {
  37.      ...
  38.      while(1) {
  39.          menu_task(&s_tMenuDemo);
  40.      }
  41. }

复制代码

“能玩出啥花儿不？”
    看的人多了，提问的人多了，再写！
 相关链接
        - [古董贴][交流]怎样在点阵屏上绘图——基于LCD12864
        - 最近读傻孩子的菜单程序，做了一个PPT，希望大家批评指正



打完收工！

<-----------------------------------------分割线----------------------------------------->

说说我的理解，不一定对，但是会给提供一个参考，希望大家踊跃留言。

菜单就是一系列的界面的有机结合，你可以简单认为是个树形结构。至于这个树形结构是怎么

实现，数组也好、链表也行。然后就是实现的问题，我们可以把内容和现实耦合在一起，就是

每屏都有自己的画刷；也可以把画刷剥离出来，但是写成一个菜单显示引擎。再有就是菜单的

索引驱动，怎么设计。基于上面这篇论文，我们可以把菜单的引擎独立出来，它包括显示驱动

（也可以是一个fnHandler，由每屏传入，本论文没有这么做）+搜索驱动（也可以是一个

fnHandler，由每屏传入，本论文就是这么设计的），在这里我感觉可以这么设计，就是用户如果

传入的是NULL指针，就调用系统的标准处理函数，如果传入的不是NULL，就调用用户的函数。

好了，到目前为止，我们提取了菜单引擎。那么菜单如何设计内？我们知道一屏内容可能包含几种

控件，每种控件都有自己的内容和属性。于是就有了菜单项和菜单容器的概念，一个菜单项就是一

个控件，容器可以认为是一屏，可以类比MFC。这里需要为每个菜单项添加一个type，这样菜单引

擎才能加载合适的驱动。

你可能感兴趣的:(单片机)

  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • 51单片机——I2C总线存储器24C02的应用 老侯（Old monkey） 51单片机嵌入式硬件单片机
    目标实现功能单片机先向24C02写入256个字节的数据，再从24C02中一次读取2个字节的数据、并在数码管上动态显示，直至读完24C02中256个字节的数据。1.I2C总线简介I2C总线有两根双向的信号线，一根是数据线SDA,另一根是时钟线SCL。I2C总线通过上拉电阻接正电源，因此，当总线空闲时为高电平。2.I2C通信协议起始信号、停止信号由主机发出。在数据传送时，当时钟线为高电平时，数据线上的
  • 嵌入式单片机中数码管基本实现方法 嵌入式开发星球 单片机项目实战操作之优秀单片机
    1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
  • 4×4矩阵键盘详解（STM32） 辰哥单片机设计 STM32传感器教学矩阵计算机外设stm32嵌入式硬件单片机传感器
    目录一、介绍二、传感器原理1.原理图2.工作原理介绍三、程序设计main.c文件button4_4.h文件button4_4.c文件四、实验效果五、资料获取项目分享一、介绍矩阵键盘，又称为行列式键盘，是用4条I/O线作为行线，4条I/O线作为列线组成的键盘。在行线和列线的每一个交叉点上设置一个按键，因此键盘中按键的个数是4×4个。这种行列式键盘结构能够有效地提高单片机系统中I/O口的利用率，节约单
  • 学单片机怎么在3-5个月内找到工作？ 无际单片机编程 单片机嵌入式开发物联网stm32c语言
    每个初学者，都如履薄冰，10几年前，我自学单片机时，也一样。想通过学习，找一份体面点的工作，又害怕辛辛苦苦学出来，找不到工作。好在，当初执行力，还算可以，自学java没成功，后面自学单片机，成功入行了。转眼间，毕业到现在有13年了，马上也到了奔4的年纪。这13年一直在跟单片机打交道，打过工，创过业，对行业，对企业，都有一定的认知，坚持看完这篇内容，相信能帮你少走几个月弯路。有些老铁，加了我很久，时
  • 51单片机：P3.3口输入/P 1口输出实验 li星野 单片机
    51单片机：P3.3口输入/P1口输出实验一、实验内容1P3.3口做输入口，外接一脉冲,每输入一个脉冲,P1口按十六进制除2（乘2）。2.P1口做输出口，P1口接的8个发光二极管L1—L8按十六进制除2（乘2）方式点亮。二、仿真图三、代码实现C语言实现：#include#includesbitKEY=P3^3;voiddelay10ms(void);voidmain(){charnum=0xfe;
  • 2020-11-12 写单片机内存的脚本 nc openocd 事务自动测试 linuxScripter
    这是写单片机内存的脚本：z@z-ThinkPad-T400:~/zworkT400/EDA_heiche/zREPOgit/simple-gcc-stm32-project$catz.wholeRun.oneCase.cmdcattmp6.toWrite|awk'{system("echomwb"$1""$2"|nclocalhost4444");}'catUSER/DEBUG/debug.h|g
  • 单片机中断 woainizhongguo. STM32单片机原理解析篇单片机嵌入式硬件
    **在51单片机中，中断向量表的地址是如何被设置的？**在51单片机中，中断向量表的设置是中断系统的核心部分，它定义了中断服务程序的入口地址。以下是中断向量表的设置方法：中断向量表的位置：51单片机的中断向量表通常位于程序存储器的起始位置，即地址0x0000到0x000F（对于双字节的中断向量，实际占用0x0000到0x001F）。这些地址是固定的，由单片机的硬件设计决定。中断向量的分配：每个中断
  • 基于STC12C5A60S2单片机的LED汉字显示系统的设计 lantiandianzi 单片机嵌入式硬件
    本设计基于单片机的LED汉字显示装置，该设计以STC12C5A60S2单片机为核心，利用最小系统和多个模块完成设计，包括点阵驱动模块、时钟模块、串口通信模块、红外线接收模块以及LED点阵屏。其中，点阵驱动模块采用74HC245芯片设计完成，结合DS1302时钟芯片完成LED点阵显示屏的汉字与时间显示，使用按键、串口、红外线遥控可以完成时间的实时更新、自定义汉字显示、改变汉字显示颜色、改变汉字滚动方
  • 51单片机-AT24C02-实验2-秒表实验（可参考上一节） Whappy001 51单片机嵌入式硬件单片机
    利用定时器去对按键和数码管进行扫描(Whappy)main.c#include#include"LCD1602.h"#include"AT24C02.h"#include"Delay.h"#include"Timer0.h"#include"Nixie.h"#include"Key.h"unsignedcharKeyNum;unsignedcharMin,Sec,MiniSec;unsignedc
  • 单片机在医疗设备中的应用实例教程 kkchenjj 单片机单片机嵌入式硬件
    单片机在医疗设备中的应用实例教程单片机基础单片机概述单片机，全称为单片微型计算机（Single-ChipMicrocomputer），是一种将中央处理器（CPU）、存储器、输入输出接口等主要计算机部件集成在一块芯片上的微型计算机系统。它具有体积小、功耗低、成本低廉、控制功能强大等特点，广泛应用于工业控制、家用电器、汽车电子、医疗设备等多个领域。特点集成度高：单片机将计算机的主要部件集成在一块芯片上
  • 单片机与传感器接口技术应用实例教程 kkchenjj 单片机单片机nosql嵌入式硬件
    单片机与传感器接口技术应用实例教程单片机基础单片机概述单片机，全称为单片微型计算机（Single-ChipMicrocomputer），是一种将中央处理器（CPU）、存储器、输入输出接口等主要计算机部件集成在一块芯片上的微型计算机系统。它具有体积小、功耗低、成本低廉、控制功能强大等特点，广泛应用于工业控制、家用电器、汽车电子、通信设备、医疗器械等领域。特点集成度高：单片机将计算机的主要部件集成在一
  • 掌握单片机,其实并不难 培林将军 单片机嵌入式硬件
    Fearwillbeyourenemy恐惧将会是你的敌人单片机的学习绝不仅仅是对一项知识的掌握。想要学好单片机，需要从硬件结构、内部资源、外设应用等几个方面多方位入手。而要想成为一名嵌入式工程师，就要对单片机的基础非常熟悉，并且掌握C语言当中各个功能的初始化、启动、停止各类函数的编写调试。那么想要掌握单片机需要从哪几个方面入手呢？数字I/O的应用在大多数的单片机实验中，跑马灯实验正是数字I/O的典
  • 无人机动力系统设计之电调芯片参数选型 lida2003 Physics无人机动力系统ESC
    无人机动力系统设计之电调芯片参数选型1.源由2.关键因素2.1电压范围2.2电流处理能力2.3控制方式2.4PWM输出与分辨率2.5通讯接口2.6保护功能2.7支持霍尔传感器与无传感器模式2.8集成度与外围器件2.9效率与散热2.10市场供应与成本3.因素阐述3.1PWM工作频率3.1.1电机控制芯片3.1.2单片机算法定时器（Timers）电机控制部分3.2单片机工作频率Step1定时器频率St
  • 实现单片机简单的时间片轮询调度 盘大海 单片机stm3251单片机mcu
    时间片轮询调度1.创建一个结构体链表typedefstructtaskMember{pfuntiontaskName;volatileuint32_ttick;uint32_ttaskID;uint32_ttaskStatus;structtaskMember*listNext;}task_t;2.声明一个链表头。statictask_ttaskListHead;task_t*currentTas
  • 单片机程序架构-时间片轮询架构 Jerry--- 嵌入式单片机
    1定时器复用说明（1）首先定义任务数、任务定时初值（任务轮询时间=定时初值*定时器中断时间）、任务定时计数器；（2）在定时器中断服务函数中添加【复用函数】。#defineTASK_NUM3//这里定义的任务数为3，表示有三个任务会使用此定时器定时。uint16_tTaskCount[TASK_NUM];//这里为三个任务定义三个变量来存放定时值uint8_tTaskMark[TASK_NUM];/
  • 在单片机中，处于高阻态是什么状态 m0_69078052 单片机嵌入式硬件
    在单片机（微控制器）中，高阻态（High-Z，HighImpedanceState）是指引脚的电气特性类似于没有连接状态，即该引脚的电流非常小，几乎不对电路产生影响。具体来说，高阻态具有以下几个特点：高阻态的特点输入状态：引脚不驱动任何电平（高电平或低电平），相当于引脚在电路中没有连接。此时，电路中的电流几乎为零。无干扰：高阻态的引脚不会对其他电路产生电气干扰或影响。它在逻辑上“断开”了与电路的连
  • stm32单片机毕业设计方向推荐 Mdc_stdio 单片机
    文章目录1前言2如何选题2.1不要给自己挖坑2.2难度把控2.3如何命名题目3单片机嵌入式选题大全3.1嵌入式方向3.2算法方向3.3移动通信方向3.4学长作品展示4最后1前言近期不少学弟学妹询问学长关于单片机和嵌入式相关的毕设选题，学长特意写下这篇文章以作回应！以下是学长亲手整理的物联网相关的毕业设计选题，都是经过学长精心审核的题目，适合作为毕设，难度不高，工作量达标，对毕设有任何疑问都可以问学
  • 通信工程单片机毕设项目选题分享 cnhush 单片机stm32毕业设计
    文章目录1前言2如何选题2.1不要给自己挖坑2.2难度把控2.3如何命名题目3单片机嵌入式选题大全3.1嵌入式方向3.2算法方向3.3移动通信方向3.4学长作品展示4最后1前言近期不少学弟学妹询问学长关于单片机和嵌入式相关的毕设选题，学长特意写下这篇文章以作回应！以下是学长亲手整理的物联网相关的毕业设计选题，都是经过学长精心审核的题目，适合作为毕设，难度不高，工作量达标，对毕设有任何疑问都可以问学
  • STM32学习笔记（二、初识stm32单片机） 藏，捉 单片机stm32学习
    一、stm32的含义是什么？首先stm32是意法半导体公司（ST）使用ARM公司的Cortex-M为核心生产的32位的单片机。其中，ST---意法半导体公司，即SOC厂商。M---为Microelectronics的缩写，即微型处理器。32---表示控制器为32位的。103---表示F系列的子系列。二、stm32的分类CPU位数内核系列描述32Cortex--M0STM32F0入门级STM32L0
  • 单片机在汽车电子中的应用实例教程 kkchenjj 单片机单片机汽车mongodb
    单片机在汽车电子中的应用实例教程单片机基础介绍单片机的定义与结构单片机，全称为单片微型计算机（Single-ChipMicrocomputer），是一种将中央处理器（CPU）、存储器（RAM和ROM）、输入/输出接口（I/O）、定时器、计数器等主要计算机功能部件集成在一块芯片上的微型计算机系统。它具有体积小、功耗低、成本低廉、控制功能强大等特点，广泛应用于各种控制领域，如工业控制、家用电器、汽车电
  • 用五一最简单的板做一个智能循迹小车 21电信1刘天明 知识分享单片机嵌入式硬件
    五一最简单板也就是单片机最小系统,或者称为最小应用系统,是指用最少的元件组成的单片机可以工作的系统.。这个系统适合初学者使用，并且制作智能小车，可以考验青少年的机械组装，器件链接，电子焊接，现场调试能力等。有一定挑战性，又十分有趣，深受青少年这个年龄段的喜爱，参加这样活动既能充分培养学生动手操作手脑协调能力，又有较高的思维训练价值，十分适合中小学生发展。做一个智能小车，首先你要学会一个编程语言并且
  • GD32F103单片机-GPIO 侥幸哥f GD32单片机GD32GPIO
    GD32F103单片机-GPIO一、GPIO介绍二、GD32F103库函数介绍三、GPIO输入输出3.1GPIO输出-LED闪烁3.2GPIO输入-独立按键STM32GPIO部分见STM32F1单片机-GPIO一、GPIO介绍GD32的GPIO同STM32一样，GPIO可以配置成8种输入输出模式，由软件配置成推挽输出、开漏输出、复用推挽输出、复用开漏输出、上拉输入、下拉输入、浮空输入、模拟输入(A
  • 单片机之从C语言基础到专家编程 - 4 C语言基础 - 4.14指针 fancyang 单片机之从C语言基础到专家编程单片机c语言嵌入式硬件
    单片机之从C语言基础到专家编程-4C语言基础-4.14指针文章目录单片机之从C语言基础到专家编程-4C语言基础-4.14指针4.14指针1指针的概念2指针的声明与初始化3指针的算术运算4NULL指针1）定义和使用2）NULL指针的用途3）常见误区4）示例代码5）总结5字符串操作1）字符串的定义与初始化2）常用字符串操作函数3）字符串常量与指针6void*指针1）类型转换2）实现通用数据结构3）通用
  • 单片机软件工程师确认硬件 蓝黑墨水 单片机嵌入式硬件
    文章目录简介流程确认能连接usb和调试器确认芯片信息确认芯片存储是否正常确认屏幕是否能点亮确认其他硬件方式方法简介硬件工程师给出板子后，后面就是软件工程师的事儿了。通常来说并不会很顺利。流程确认能连接usb和调试器也是在“计算机管理”中或者在keil调试那里能发现你连的板子。确认芯片信息1，直接用眼看上面的封装信息2，使用相关命令确认一下确认芯片存储是否正常主要是确认芯片的存储是否正常。好几种情况
  • 自适返回年的每月1号周几 智者知已应修善业 51单片机经验分享笔记算法
    依据找到的年1月1日周一的规律自动推断参考年，配合年表可进一步减小计算出来的总天数在最小值，在单片机中用int类型变量就可以了，如此周而复始。void自适返回年的每月1号周几(int年){//依据找到的年1月1日周一的规律自动推断参考年，配合年表可进一步减小计算出来的总天数在最小值，在单片机中用int类型变量就可以了，如此周而复始。int年表[56]={6,11,6,5,6,11,6,5,6,11
  • 使用PHP和MQTT构建高效的物联网数据转发服务器流程 极客小张 php物联网服务器单片机运维MQTT数据库
    一、项目概述项目目标和用途本项目旨在搭建一个基于PHP的物联网服务器，能够接收来自各种传感器的数据，并通过MQTT协议将数据转发到其他设备或服务。该系统适用于智能家居、环境监测等场景，能够实现实时数据监控和远程控制。技术栈关键词PHPMQTTMySQLESP8266/ESP32（单片机）DHT11（温湿度传感器）Linux服务器Apache/Nginx二、系统架构系统架构设计本项目的系统架构主要由
  • 【车载测试面试：各大车企面试题汇总】 @逝水流年轻染尘@ 面试职场和发展
    HIL（硬件在环）测试、UDS功能诊断、UDS自动化诊断、数据库制作、DTC故障制造、CANoe工具使用、ECU刷写、报文解析、导航测试、车控测试、OTA升级测试、TBOX测试等TBOX深圳涉及过T-BOX测试吗Ota升级涉及的台架环境是什么样的？上车实测之前有没有一个仿真环境台架环境都什么零部件T-BOX了解多少Linux和shell有接触吗单片机车机有没有热点啊WiFi这个功能有没有涉及一些法
  • 单片机工程师：创新与挑战之路 嵌入式大圣 单片机嵌入式硬件
    摘要：本文全面深入地探讨了单片机工程师这一职业角色。详细阐述了单片机工程师的职责范围、所需技能，包括硬件设计、软件编程、调试与测试等方面。分析了单片机在不同领域的应用，如工业控制、消费电子、智能家居等。同时，探讨了单片机工程师面临的挑战，如技术更新迅速、项目复杂性增加等，并提出了相应的应对策略。此外，还展望了单片机工程师的未来发展趋势，强调了持续学习和创新的重要性。目录一、引言二、单片机工程师的职
  • 基于单片机多功能电子闹钟设计 创新电子设计 单片机单片机嵌入式硬件
    **单片机设计介绍，基于单片机多功能电子闹钟设计文章目录一概要二、功能设计设计思路三、软件设计原理图五、程序六、文章目录一概要  基于单片机多功能电子闹钟设计是一个结合了单片机控制、时间显示、闹钟提醒以及其他附加功能的综合性项目。以下是该设计的概要：一、系统概述该设计以单片机为核心控制器，通过外围电路和模块实现时间的精确显示、闹钟提醒以及其他多种功能。整个系统注重易用性、精确性和稳定性，力求为用户
  • java杨辉三角 3213213333332132 java基础
    package com.algorithm; /** * @Description 杨辉三角 * @author FuJianyong * 2015-1-22上午10:10:59 */ public class YangHui { public static void main(String[] args) { //初始化二维数组长度 int[][] y
  • 《大话重构》之大布局的辛酸历史 白糖_ 重构
    《大话重构》中提到“大布局你伤不起”，如果企图重构一个陈旧的大型系统是有非常大的风险，重构不是想象中那么简单。我目前所在公司正好对产品做了一次“大布局重构”，下面我就分享这个“大布局”项目经验给大家。   背景         公司专注于企业级管理产品软件，企业有大中小之分，在2000年初公司用JSP/Servlet开发了一套针对中
  • 电驴链接在线视频播放源码 dubinwei 源码电驴播放器视频ed2k
    本项目是个搜索电驴（ed2k）链接的应用,借助于磁力视频播放器（官网： http://loveandroid.duapp.com/ 开放平台），可以实现在线播放视频，也可以用迅雷或者其他下载工具下载。 项目源码： http://git.oschina.net/svo/Emule,动态更新。也可从附件中下载。 项目源码依赖于两个库项目，库项目一链接： http://git.oschina.
  • Javascript中函数的toString()方法 周凡杨 JavaScriptjstoStringfunctionobject
    简述     The toString() method returns a string representing the source code of the function.     简译之，Javascript的toString()方法返回一个代表函数源代码的字符串。 句法     function.
  • struts处理自定义异常 g21121 struts
    很多时候我们会用到自定义异常来表示特定的错误情况，自定义异常比较简单，只要分清是运行时异常还是非运行时异常即可，运行时异常不需要捕获，继承自RuntimeException，是由容器自己抛出，例如空指针异常。 非运行时异常继承自Exception，在抛出后需要捕获，例如文件未找到异常。 此处我们用的是非运行时异常，首先定义一个异常LoginException: /** * 类描述：登录相
  • Linux中find常见用法示例 510888780 linux
    Linux中find常见用法示例 ·find   path   -option   [   -print ]   [ -exec   -ok   command ]   {} \; find命令的参数；
  • SpringMVC的各种参数绑定方式 Harry642 springMVC绑定表单
    1. 基本数据类型(以int为例，其他类似)： Controller代码： @RequestMapping("saysth.do") public void test(int count) { } 表单代码： <form action="saysth.do" method="post&q
  • Java 获取Oracle ROWID aijuans javaoracle
    A ROWID is an identification tag unique for each row of an Oracle Database table. The ROWID can be thought of as a virtual column, containing the ID for each row. The oracle.sql.ROWID class i
  • java获取方法的参数名 antlove javajdkparametermethodreflect
    reflect.ClassInformationUtil.java package reflect; import javassist.ClassPool; import javassist.CtClass; import javassist.CtMethod; import javassist.Modifier; import javassist.bytecode.CodeAtt
  • JAVA正则表达式匹配 查找 替换 提取操作 百合不是茶 java正则表达式替换提取查找
    正则表达式的查找;主要是用到String类中的split();       String str;      str.split();方法中传入按照什么规则截取,返回一个String数组   常见的截取规则: str.split("\\.")按照.来截取 str.
  • Java中equals()与hashCode()方法详解 bijian1013 javasetequals()hashCode()
    一.equals()方法详解     equals()方法在object类中定义如下：  public boolean equals(Object obj) { return (this == obj); }    很明显是对两个对象的地址值进行的比较（即比较引用是否相同）。但是我们知道，String 、Math、I
  • 精通Oracle10编程SQL(4)使用SQL语句 bijian1013 oracle数据库plsql
    --工资级别表 create table SALGRADE ( GRADE NUMBER(10), LOSAL NUMBER(10,2), HISAL NUMBER(10,2) ) insert into SALGRADE values(1,0,100); insert into SALGRADE values(2,100,200); inser
  • 【Nginx二】Nginx作为静态文件HTTP服务器 bit1129 HTTP服务器
     Nginx作为静态文件HTTP服务器 在本地系统中创建/data/www目录，存放html文件(包括index.html) 创建/data/images目录，存放imags图片 在主配置文件中添加http指令   http { server { listen 80; server_name
  • kafka获得最新partition offset blackproof kafkapartitionoffset最新
    kafka获得partition下标，需要用到kafka的simpleconsumer   import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.HashMap; import java.util.List; import java.
  • centos 7安装docker两种方式 ronin47
          第一种是采用yum 方式              yum install -y docker           
  • java-60-在O(1)时间删除链表结点 bylijinnan java
    public class DeleteNode_O1_Time { /** * Q 60 在O(1)时间删除链表结点 * 给定链表的头指针和一个结点指针(!!)，在O(1)时间删除该结点 * * Assume the list is: * head->...->nodeToDelete->mNode->nNode->..
  • nginx利用proxy_cache来缓存文件 cfyme cache
    user  zhangy users; worker_processes 10; error_log  /var/vlogs/nginx_error.log  crit; pid        /var/vlogs/nginx.pid; #Specifies the value for ma
  • [JWFD开源工作流]JWFD嵌入式语法分析器负号的使用问题 comsci 嵌入式
        假如我们需要用JWFD的语法分析模块定义一个带负号的方程式，直接在方程式之前添加负号是不正确的，而必须这样做：     string str01 = "a=3.14;b=2.71;c=0;c-((a*a)+(b*b))"     定义一个0整数c,然后用这个整数c去
  • 如何集成支付宝官方文档 dai_lm android
    官方文档下载地址 https://b.alipay.com/order/productDetail.htm?productId=2012120700377310&tabId=4#ps-tabinfo-hash 集成的必要条件 1. 需要有自己的Server接收支付宝的消息 2. 需要先制作app，然后提交支付宝审核，通过后才能集成 调试的时候估计会真的扣款，请注意
  • 应该在什么时候使用Hadoop datamachine hadoop
    原帖地址：http://blog.chinaunix.net/uid-301743-id-3925358.html 存档，某些观点与我不谋而合，过度技术化不可取，且hadoop并非万能。 --------------------------------------------万能的分割线-------------------------------- 有人问我，“你在大数据和Hado
  • 在GridView中对于有外键的字段使用关联模型进行搜索和排序 dcj3sjt126com yii
    在GridView中使用关联模型进行搜索和排序 首先我们有两个模型它们直接有关联: class Author extends CActiveRecord { ... } class Post extends CActiveRecord { ... function relations() { return array( '
  • 使用NSString 的格式化大全 dcj3sjt126com Objective-C
    格式定义The format specifiers supported by the NSString formatting methods and CFString formatting functions follow the IEEE printf specification; the specifiers are summarized in Table 1. Note that you c
  • 使用activeX插件对象object滚动有重影 蕃薯耀 activeX插件滚动有重影
      使用activeX插件对象object滚动有重影   <object style="width:0;" id="abc" classid="CLSID:D3E3970F-2927-9680-BBB4-5D0889909DF6" codebase="activex/OAX339.CAB#
  • SpringMVC4零配置 hanqunfeng springmvc4
    基于Servlet3.0规范和SpringMVC4注解式配置方式，实现零xml配置，弄了个小demo，供交流讨论。     项目说明如下： 1.db.sql是项目中用到的表，数据库使用的是oracle11g 2.该项目使用mvn进行管理，私服为自搭建nexus,项目只用到一个第三方 jar，就是oracle的驱动； 3.默认项目为零配置启动，如果需要更改启动方式，请
  • 《开源框架那点事儿16》：缓存相关代码的演变 j2eetop 开源框架
    问题引入 上次我参与某个大型项目的优化工作，由于系统要求有比较高的TPS，因此就免不了要使用缓冲。 该项目中用的缓冲比较多，有MemCache，有Redis，有的还需要提供二级缓冲，也就是说应用服务器这层也可以设置一些缓冲。 当然去看相关实现代代码的时候，大致是下面的样子。 [java] view plain copy print ? public vo
  • AngularJS浅析 kvhur JavaScript
    概念 AngularJS is a structural framework for dynamic web apps. 了解更多详情请见原文链接：http://www.gbtags.com/gb/share/5726.htm Directive 扩展html，给html添加声明语句，以便实现自己的需求。对于页面中html元素以ng为前缀的属性名称，ng是angular的命名空间
  • 架构师之jdk的bug排查(一)---------------split的点号陷阱 nannan408 split
    1.前言.    jdk1.6的lang包的split方法是有bug的,它不能有效识别A.b.c这种类型,导致截取长度始终是0.而对于其他字符,则无此问题.不知道官方有没有修复这个bug. 2.代码 String[] paths = "object.object2.prop11".split("'"); System.ou
  • 如何对10亿数据量级的mongoDB作高效的全表扫描 quentinXXZ mongodb
      本文链接:  http://quentinXXZ.iteye.com/blog/2149440 一、正常情况下，不应该有这种需求 首先，大家应该有个概念，标题中的这个问题，在大多情况下是一个伪命题，不应该被提出来。要知道，对于一般较大数据量的数据库，全表查询，这种操作一般情况下是不应该出现的，在做正常查询的时候，如果是范围查询，你至少应该要加上limit。 说一下，
  • C语言算法之水仙花数 qiufeihu c算法
    /** * 水仙花数 */ #include <stdio.h> #define N 10 int main() { int x,y,z; for(x=1;x<=N;x++) for(y=0;y<=N;y++) for(z=0;z<=N;z++) if(x*100+y*10+z == x*x*x
  • JSP指令 wyzuomumu jsp
    jsp指令的一般语法格式： <%@ 指令名 属性 =”值 ” %> 常用的三种指令： page,include,taglib page指令语法形式： <%@ page 属性 1=”值 1” 属性 2=”值 2”%> include指令语法形式： <%@include file=”relative url”%> (jsp可以通过 include
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他