This project provides a complete GUI system for systems with limited resources.
Sourceforge start page
project consists of two parts. The MenuInterpreter and the MenuEditor.
The MenuEditor is a graphical editor, written in Pascal/Lazarus (tested
with Linux and Windows), where you can build your menu system. The
MenuEditor then will compile the menu into a compact bytecode. The
MenuInterpreter, written in platform independent C, draws screens
according to the bytecode. The MenuInterpreter is optimized to use very
For example, the MenuInterpreter can run on a small 8 bit
microcontroller like an AVR ATmega32 (32KB flash, 2KB RAM) with a
128x64 black/white LCD and some keys connected. An example menu which
uses ASCII characters as display and runs on an ATmega8 (8KB flash, 1KB
RAM) is provided.
- Independent from the used LCD controller
- The interpreter needs about 5KB program space
- Very low permanent RAM usage
- The generated menu system can be stored on any random access readable memory
- Using 16 or 24 bit addresses, the menu may have a size of up to 24MB or up to 64KB if 16 bit addresses are used
- Navigation is optimized for use with few keys. The minimum is two, but four would be more comfortable
- The following GUI elements are supported:
- Window: Can contain objects
- SubWindow: Good for pop-up messages, has all abilities of a normal window
- Box: Draws a box either white or black
- Label: Draws text on the screen
- Button: A button for actions or text with a border
- Graphic: Black and white pixel images, supports basic compression
- List: Shows multiple lines of text and a scrollbar if needed
- Shortcut: Invisible, supports direct actions and window changes
- Global shortcut: Like a shortcut, but once defined, its valid within all windows
- Static text and graphics can be stored directly within the bytecode, changing text and graphics can be stored in the RAM
- Support for multiple fonts
- Renderer and data for 5x7 font included
- Renderer for 8x16 font included (3rd party)
- Tool for converting system fonts into a proper 8x16 or 5x7 data array provided
- Partial support for mice and touch screens (support for list element is incomplete)
- Support to select a different languages during run-time
- No need for special hardware like timers or similar
- The editor automatically configures the source code to either use
32 or 16 bit address size and switches between 8 and 16 bit types for
the display coordinates. This reduces the code size and improves speed
- The editor can optimizes the size of the byte code by finding and re-using duplicate text and graphics
- The editor detects which GUI elements are really used and
configures the source code of the interpreter so that unused code is
optimized out. As example, if neither lists, nor images are used, the
needed program space is reduced from 5KB to 3,5KB. And if you need
nothing more than labels and buttons, the space for the interpreter is
reduced to 2,8KB.
- GUI elements can not be moved to an other position during run-time
- Labels can use one of 256 possible fonts, all other elements only support one of 16 possible fonts
- Animations are difficult to realize
- There is a maximum of 256 different checkboxes
- There is a maximum of 256 different lists
- There is a maximum of 16 different groups of groupbuttons with 16 different selections in each group
- Lists are limited to ~10000 lines
- The screen may have a resolution of up to 4096x4096
- Only one Window and one SubWindow can be shown at the same time
- There is a maximum of 254 different languages
What is needed to use the codeGenerally the code should work on any platform, supported by gcc or a similar C compiler.
Normally you have to implemented five functions for yourself:
Implement unsigned char menu_byte_get(MENUADDR addr)
The access to the binary menu structure. Like RAM, Flash or EEPROM
read. Its best to make sure 'addr' is below the MENU_DATASIZE
Implement void menu_screen_set(SCREENPOS x, SCREENPOS y, unsigned char color)
This function gets called while the screen is redrawn. Please note that
x and y can be outside of the defined screen size. You must catch this
in order to prevent memory corruption.
Depending on your selected screen resolution, SCREENPOS is a 8 or 16 bit unsigned integer.
Implement void menu_screen_flush(void)
This function gets called once, when redrawing has completed. Use this
to draw the values set by the function above to the screen.
Implement void menu_screen_clear(void)
Gets called on every screen switch. Simply provided, because there are
often faster methods for clearing a screen than drawing every single
Implement unsigned char menu_action(unsigned short action)
This function gets called so you can react on the user inputs of the
screen, return 1 if you want a redraw, 0 if not. If a screen change
occurs, a redraw is made anyway.
Call void menu_keypress(unsigned char key)
You should call this function in order to initiate screen changes or let the menu react on other key inputs.
Call void menu_redraw(void)
If you have dynamic data (text, graphics) on the screen you should call void menu_redraw(void) in order
to init a redraw.
(Since version 1.4) If compiled with mouse/touch support,
call, void menu_mouse(SCREENPOS x, SCREENPOS y, unsigned char key)
to run the menu_keypress(unsigned char key) function for the element on the given screen position.
Note: This behaviour is currently not sufficient for comfortable using with the list element.
(Since version 1.5) If compiled with multi-language support,
call void menu_language_set(unsigned char id)
To set the language to display. You may need to call menu_redraw(void)
afterward in order for displaying the menu in the new selected language.
To exchange dynamic data with the GUI, like text which is modified
during run-time or read out the state of a checkbox, global variables
(the five arrays in the graphic) are used. They are used in favor of
getter and setter functions in order to reduce the program size. To
find the correct index in the array, the editor generates some #define
with user configurable names.
I wrote a wiki article over the menu system (in German) some time ago http://www.mikrocontroller.net/articles/MenuDesigner
and posted the source code to a forum http://www.mikrocontroller.net/topic/140369
You used the MenuDesigner?
Write me your opinion m DOT talk AT marwedels DOT de
Last changed: 23.05.2012