This library is a firmware package which contains a collection of routines, data structures,
and macros covering the main features of a graphic library and supporting a HID device to
interact with the graphic objects (touchscreen, joystick, and pushbutton).
The library is general purpose and can be executed on any CPU, 8/16/32-bit, to guarantee
the maximum portability of any architecture or LCD controller, and it provides a graphical
user interface (GUI) for any application that operates with a graphical LCD.
While the firmware library functions with all currently available STM32 microcontrollers,
(STM32F10xxx, STM32L1xx and STM32F2xx series), this document describes the
firmware library through the implementation of a graphic library for embedded systems
based on the STM32F10xxx microcontroller family.
It can easily be used in the user application without an in-depth study of STM32 registers,
SPI, and I
significant time that would otherwise be spent in coding, while at the same time reducing the
application development and integration costs.
The firmware architecture is developed in separate layers and the HAL (hardware
abstraction layer) makes it independent from the microcontroller used in the final
application.
A set of fonts is included: 8x12 and 16x24.
Even though the firmware library source code is developed in 'ANSI-C', the code
architecture follows an OOP (object oriented programming) approach.
Section 1 describes the document and library rules.
Section 2 highlights the features of the STMPE811 and explains its hardware interface with
a device microcontroller (STM32 in this case).
Section 3 and 4 describe the library features, its architecture and its exported APIs
(application programming interfaces) in detail.
Section 5 contains an example application source code describing how to configure and use
the library.
Section 6 contains information about the embedded GUI resource editor application.
2
C read/write operation steps. As a result, using the firmware library saves
This document uses the conventions described in the sections below.
1.1 Acronyms
The following table lists the acronyms used in this document.
Table 1.List of acronyms
Acronym Meaning
API Application programming interface
HAL Hardware abstraction layer
MCU Microcontroller unit
I2C Inter-integrated circuit
SPISerial peripheral interface
OOP Object oriented programming
10/105Doc ID 16918 Rev 5
AN3128Touchscreen controller hardware description
2 Touchscreen controller hardware description
2.1 Description
In this section we describe an example device that could be used for the touchscreen
management. This device is present on both STM3210C-EVAL and STM32100E-EVAL
demonstration board. The STMPE811 is a GPIO (general purpose input/output) port
expander able to interface a main digital ASIC via the two-line bi-directional bus (I
separate GPIO expander is often used in mobile multimedia platforms to solve the problem
regarding the limited amount of GPIOs typically available on the digital engine.
The STMPE811 offers great flexibility, as each I/O can be configured as input, output, or
specific functions. The device has been designed with very low quiescent current and
includes a wake-up feature for each I/O, to optimize the power consumption of the device.
A 4-wire touchscreen controller is built into the STMPE811. The touchscreen controller is
enhanced with a movement tracking algorithm (to avoid excessive data), a 128 x 32-bit
buffer and programmable active window feature.
2.2 Features
2
C). A
●8 GPIOs
●1.8 - 3.3 V operating voltage
●Integrated 4-wire touchscreen controller
●Interrupt output pin
●Wake-up feature on each I/O
●SPI and I
●Up to 2 devices sharing the same bus in I
●8-input 12-bit ADC
●128-depth buffer touchscreen controller
●Touchscreen movement detection algorithm
●25 kV air-gap ESD protection (system level)
●4 kV HBM ESD protection (device level).
2
C interface
2.3 STMPE811 functional overview
The STMP811 consists of the following blocks:
2
●I
C and SPI interface
●Analog-to-digital converter (ADC)
●Touchscreen controller (TSC)
●Driver and switch control unit
●Temperature sensor
●GPIO controller.
2
C mode (1 address line)
Doc ID 16918 Rev 511/105
Touchscreen controller hardware descriptionAN3128
R
Figure 1.STMPE811 functional block diagram
).4
$ATAIN
!$ATAOUT
3#,+#,+
3$!4
#3
'.$
2.4 Touchscreen controller
The STMPE811 is integrated with a hard-wired touchscreen controller for a 4-wire resistive
type touchscreen. The touchscreen controller is able to operate completely autonomously,
and interrupts the connected CPU only when a pre-defined event occurs.
2.5 Interfacing touchscreen with microcontroller with the
STMPE811 via I2C
The STMPE811 has a simple 2-wire I2C digital serial interface which allows the user to
access the data in the touchscreen controller register at any time. It communicates via the
serial interface with a master controller.
Figure 3 shows how the STM32F10xxx microcontroller (master device) must be connected
to the STMPE811 device.
Figure 3.Two STMPE811s in IOExpander mode
+3V
C8
100n
IO_Expander_SCK
IO_Expander_SDA
IO_Expander_INT
VC
14
Vio
10
GN
SCLK
B1
R15
+3V
R3
10
+3V
SDAT
Data
A0/Data
ST
devic
Out
address:0x8
16
15
13
12
11
TouchScreen_Y-
TouchScreen_XTouchScreen_Y+
TouchScreen_X+
EXP
EXP
EXP
EXP
R5
100
C9
100n
VC
14
Vio
10
GN
SCLK
SDAT
R160
10
+3V
For more information on the touchscreen controller, refer to the STMPE811, datasheet,
+3V
R164
10
Data
A0/Data
Out
R5
ST
10
devic
address:0x8
16
15
13
12
11
R5
100
EXP
EXP
EXP
EXP
EXP
EXP
EXP
EXP
where it is possible to find details about the registers concerning the data of the touched
points on the touchscreen.
AM08449v1
Doc ID 16918 Rev 513/105
Multi-input embedded GUI libraryAN3128
3 Multi-input embedded GUI library
3.1 Introduction
The library supports touchscreen features and includes a low level driver which handles the
analog input (for 12-bit ADC), and a function for the touchscreen calibration based on an
algorithm using 5 points.
The multi-input embedded GUI firmware library is fully developed in 'ANSI-C' following an
OOP approach. This means that the final application uses instances of page and graphic
objects according to their public methods and properties. In the end the PageObj is a
structure containing public properties (data fields) and methods (functions pointers). The
OOP encapsulation feature is assured.
The library can be included in the final application as a library file (multi-input embedded
GUI library.a) and used as a black box through its exported public API, or included in the
final application as source files (.c and .h) if the user wants to debug the library itself, and/or
change the HAL functions in order to port the library on an LCD different (in model and
resolution).
The calibration process is part of the post-processing layer. The touchscreen must be
calibrated at first power-on and/or upon user request.
Once the calibration is done, on future power-on of the board it does not have to be run
again because the calibration parameters are saved on the Flash memory.
3.2 Graphic object introduction
This solution enables designers, comfortable with the use of standard microcontrollers, to
create higher-end “look and feel” human interfaces by replacing conventional
electromechanical switches with touch sensing controls.
Designers can combine touch sensing functions using multiple configurations (touchscreen,
joystick, and keys) with traditional MCU features (communication, LED control, beeper, LCD
control, etc.).
The multi-input embedded GUI library is part of the application firmware.
Maturity, robustness, flexibility, and performance, with good time-to-market, make this
solution simple to implement to develop any kind of application.
The graphic objects are a set of controls that can be printed on the screen and associated to
an action when pressed.
The library has been developed and tested on an LCD panel of QVGA resolution (320x240)
which is the default, but the library is independent to the LCD resolution, although it has not
been tested with others.
The library has been designed to have the minimum memory footprint possible.
The reserved Flash memory footprint requirement depends on the application configuration.
It is therefore not possible to specify a precise value, but normally for a “typical” user
application, 64 Kbytes of Flash memory are needed (the images are stored in ROM).
14/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library
It is the same as far as the RAM usage is concerned: the user can calculate the space
required by the application considering the heap space required by each graphic object
used in their own application. For a typical application, 32 KB of RAM are required.
Ta bl e 2 shows the ROM usage (Flash memory) of the bitmap images for each type of
graphic object using IAR 5.5 and high optimization for size:
Table 2.ROM usage of graphic objects
Graphic object typeROM (Flash)Note
Label 0 bytesTotally
Button 2.904 bytes Totally
Checkbox1.736 bytesTotally
RadioButton1.736 bytesTotally
ComboBox4.144 bytesTotally
Switch 2.904 bytes Totally
Icon 0 bytesTotally
Slidebar 944 bytesTotally
Histogram 0 bytesTotally
Graph chart 0 bytesTotally
Ta bl e 3 shows the RAM usage of each type of graphic object:
Table 3.RAM usage of graphic objects
Graphic object typeRAM (Heap)Note
Label101 bytesEach
Button 70 bytesEach
Checkbox79 bytesEach
RadioButtonGrp40 bytesEach
RadioOption48 bytesEach
ComboBoxGrp90 bytesEach
ComboOption29 bytesEach
Switch86 bytesEach
Icon53 bytesEach
Slidebar79 bytesEach
Histogram156 bytesEach
Graph chart257 bytesEach
Page162 bytesEach
Doc ID 16918 Rev 515/105
Multi-input embedded GUI libraryAN3128
Ta bl e 4 shows the ROM usage (Flash memory) of the font sets:
Table 4.ROM usage of font sets
Font setROM (Flash)Note
Font 16x244.560 bytesTotally
Font 8x122.688 bytesTotally
All the graphic objects are allocated dynamically, in a typical application the heap size
should be about 16 KB, and the stack should be about 2 KB.
3.3 Library package
The library was developed supporting Raisonance Ride Kit ARM, IAR the IAR EWARM,
Atollic TrueSTUDIO, Keil MDK-ARM , TASKING VX-toolset for ARM Cortex-M3 and the
related workspace/project files are included in the delivered package.
The “Libraries” folder contains all the subdirectories and files that make up the core of the
library.
Embedded_GUI_HAL contains all files and subdirectories that makes the hardware
abstraction layer (HAL). The developer has to modify only these files if he needs to port the
library to other board with other TSC/LCD/JOYSTICK controller, and set the defined
constant into the file “hw_config.h” contained under the folder
“./Embedded_GUI_Example/inc”:
●inc: sub-folder contains the HAL header files.
–LcdHal.h: HAL layer file; contains all the LCD function prototypes whose
implementation depends on the LCD used. The final user should change this file in
order to re-use this library with other LCDs.
–JoyHal.h: HAL layer file; contains all the joystick function prototypes whose
implementation depends on the joystick controller used by the application. The
user need only change these function implementations in order to re-use this code
with other joystick controllers.
–TscHal.h: HAL layer file; contains all the touchscreen function prototypes whose
implementation depends on the TSC controller used by the application. The user
need only change these function implementations in order to re-use this code with
other TSC controllers.
–touchscreen.h: contains all the function prototypes for the touchscreen firmware
driver.
●src: sub-folder contains the HAL source files.
–LcdHal.c: HAL layer file; contains all the LCD function declarations whose
implementation depends on the LCD used and the MCU (STM32 for this delivery).
The final user should change this file in order to re-use this library with other
LCDs.
–JoyHal.c: HAL layer file; contains all the joystick management function
declarations whose implementation depends on the joystick controller used by the
application. The user only needs to change these functions implementations in
order to re-use this code with other joystick controllers.
16/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library
–TscHal.c: HAL layer file; contains all the touchscreen management function
declarations whose implementation depends on the TSC controller used by the
application. The user only needs to change these functions implementations in
order to re-use this code with other TSC controllers.
–touchscreen.c: contains all the function declarations for the touchscreen firmware
driver.
Embedded_GUI_Library contains all files and subdirectories that makes the graphic objects
core:
●inc: sub-folder contains the firmware library header files
–cursor.h: contains all the function prototypes and basic structure for the cursor
pointer (arrow header).
–gl_fonts.h: contains all the LCD fonts size definition exported declarations.
–GraphicObject.h: API layer file; contains all the function prototypes for the graphic
objects; the API functions are declared in this file.
–GraphicObjectTypes.h: API layer file; contains all the defined types used by
GraphicObject.c file and related to the graphic objects structures; and the
structure parameters for the LCD, touchscreen, joystick and push button.
–images.h: contains all the Hex dumps of the various images used by the
application.
●src: sub-folder contains the firmware library source files.
–cursor.c: API layer file; contains the exported public API (application programming
interface) and the related private internal functions for the cursor pointer (arrow
header). No direct reference to the hardware and micro firmware library occurs in
this file.
–gl_fonts.c: contains all the LCD font size definitions.
–GraphicObject.c: API layer file; contains the entire exported public API (application
programming interface) and the related private internal functions for the graphic
objects and touchscreen calibration; no direct reference to the hardware and
microcontroller firmware library occurs in this file.
–images.c: contains all the Hex dumps of the various images used by the library
application.
STM32F10x_StdPeriph_Driver, STM32L1xx_StdPeriph_Driver and
STM32F2xx_StdPeriph_Driver sub-folders contain respectively the STM32F10xxxV3.5.0,
STM32L1xxV1.0.0 and STM32F2xxV1.0.0 firmware library files. If the final user wants to
use another microcontroller library version, he can replace the updated library folder and
check the HAL types and the microcontroller library function calls inside the HAL layer files
(TscHal.c, TscHal.h, JoyHal.h, JoyHal.c, LcdHal.c, LcdHal.h).
CMSIS sub-folder contains the STM32F10xxx, STM32L1xx and STM32F2xx CMSIS files:
device peripheral access layer and core peripheral access layer.
The “Project” folder contains all the subdirectories and files that make up the library
demonstration.
●Embedded_GUI_Example sub-folder contains the STM32F10xxx Graphic library
demonstration:
–inc: sub-folder contains the graphic library demonstration header files
–src: sub-folder contains the graphic library demonstration header source files
–EWARM sub-folder contains the IAR EWARM workspace and project files
–RIDE sub-folder contains the Raisonance Ride workspace and project files
Doc ID 16918 Rev 517/105
Multi-input embedded GUI libraryAN3128
–MDK-ARM sub-folder contains the Keil MDK-ARM workspace and project files
–TrueSTUDIO sub-folder contains the Atollic TrueSTUDIO workspace and project
files
–TASKING sub-folder contains the TASKING VX-toolset for ARM Cortex-M3
workspace and project files
●Embedded_GUI_Template sub-folder contains the STM32 Graphic library template for
Resource Editor (PC Software) output files:
●inc : sub-folder where to place generated header files from Resource Editor PC
The “_htmresc” folder contains all package html page resources.
Figure 4.Firmware library project files
18/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library
3.4 Library architecture
Library architecture is thought out and developed in two separate layers:
●API layer
●HAL layer
This layer architecture improves the code re-usability splitting the application programming
interface code (fully portable and re-usable) from the hardware abstraction layer code
(hardware dependent and written upon the LCD library).
Figure 5.Firmware library architecture
3.4.1 API layer
The application programming interface layer allows the final application to use the library as
a black-box. The library firmware encapsulation feature and exported API allow a full control
of the LCD and touchscreen without knowing, in-depth, LCD registers and SPI/I
read/write operation steps for the LCD and touchscreen respectively.
●The API layer includes the following files:
–graphicObject.h
–graphicObject.c
–graphicObjectTypes
–cursor.c
–cursor.h
See Section 4.1 for a more detailed description.
3.4.2 HAL layer
The hardware abstraction layer is directly built into the specific LCD firmware library and
allows the build-upon layers, like the API layer, to implement its functions without knowing,
in-depth, the LCD, MCU and touchscreen controller used. This improves the library code re-
2
C
Doc ID 16918 Rev 519/105
Multi-input embedded GUI libraryAN3128
usability and guarantees an easy portability on other LCDs, MCUs and touchscreen
controllers.
●The HAL layer includes the following files:
–LcdHal.h
–LcdHal.c
–TscHal.h
–TscHal.c
–JoyHal.h
–JoyHal.c
–Touchscreen.h
–Touchscreen.c
SeeSection 4.4for a more detailed description.
20/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4 Multi-input embedded GUI library firmware
This section describes the API and HAL layer implementation. Each library firmware
function is described in detail. An example of how to use API functions is provided. No
example is provided for the HAL function, because the final application should manage the
graphic objects through the API layer functions only, without any direct access to the HAL
functions.
The functions are described in the following format:
Table 5.Function description format
NameDescription
Function name The name of the function
Function prototype Prototype declaration of the function
Behavior description Brief explanation of how the function is executed
Input parameter {x} Description of the input parameters
Output parameter {x} Description of the output parameters
Return value Value returned by the function
Required preconditions Requirements before calling the function
Called functions Other library functions called
4.1 Graphic object API functions
The application programming interface layer allows the final application to create pages of
graphic objects and easy use of the STMPE811 touchscreen controller. An OOP approach
is used, so it's possible for the application developer to create and use one or more
instances of a graphic object and work with pages of object without writing the code to
display the graphic objects every time the application changes the focus on another page.
Graphic object structures are seen by the application as objects with encapsulated
properties and methods. In the end, they are advanced structures containing:
●Properties as data fields
●Methods as function pointers
In this way each API function belongs to the related graphic object instance and so, many
graphic objects can be managed without any conflicts.
Every type of graphic object has a pre-event function that provides the process to change its
visualization on the screen and the internal status of the object; for example in a ComboBox,
when the user hits the “Down Arrow” the pre-event function changes the image associated
showing the one associated to Image2_PTR for a few moments, and sets the next option in
the list as active. This function is predefined for each type of object and very useful in order
to minimize the developer workload. In this way, the developer need only place graphic
objects on the screen page and write a function event that is called after the pre-event
function, when a touch/click event occurs between the object coordinates area.
Doc ID 16918 Rev 521/105
Multi-input embedded GUI library firmwareAN3128
The library exports the following public API global functions in order to create the graphic
objects type structure instance and set/get the relative properties:
●NewLabel function
●NewButton function
●NewSwitch function
●NewCheckbox function
●NewIcon function
●NewRadioButtonGrp function
●AddRadioOption function
●NewSlidebar function
●NewHistogram function
●NewGraphChart function
●NewComboBoxGrp function
●AddComboOption function
●Create_PageObj function
●AddPageControlObj function
●DestroyPageControl function
●DestroyPage function
●Set_Label function
●Get_Label function
●Get_SlidebarValue function
●SetGraphChartPoints function
●SetHistogramPoints function
●GetObjStatus function
●GetComboOptionActive function
●ResetComboOptionActive function
●GetComboOptionLabel function
●SetComboOptionLabel function
●SetIconImage function
●ShowPage function
●RefreshPage function
●RefreshPageControl function
●ChangePage function.
22/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4.1.1 NewLabel API global function
Ta bl e 6 describes the NewLabel function:
Table 6.NewLabel API function
NameDescription
Function name NewLabel
Function prototype
Behavior description Create and initialize a new Label Object (a C structure)
Input parameter {x}
Output parameter {x} None
Return value The created object pointer or null if the object cannot be created
oName: object name
Label: text on a Label Object
Direction: the direction to follow printing the Label
FontSize: the size of the font: FONT_BIG or FONT_SMALL
Color: color of the Label text
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Label Object and add it with specified coordinates to a
Page Object */
GL_PageControls_TypeDef* pageLabel = NewLabel("pageLabel","Graphic Library",
GL_HORIZONTAL, GL_FONT_BIG, GL_Blue);
AddPageControlObj((uint16_t)((LCD_Width/11)*9),(uint8_t)(LCD_Height/11),pageLabel,
&page1);
Once a Label Object instance is created using the NewLabel function, the Label Object itself
provides all its features through its internal function pointers.
Figure 14, 15, 16, show, in detail, the Label Object properties and methods which the final
application can use to interact with.
Doc ID 16918 Rev 523/105
Multi-input embedded GUI library firmwareAN3128
4.1.2 NewButton API global function
The button object is the most used and its graphical look changes temporarily during the
interaction between the touchscreen or the joystick. In fact there are two looks for the button
as well as for the majority of the others objects.
When the button is pressed, its “graphical look” changes for a few moments and then
returns to the starting aspect.
Inside the button, it's possible to insert a text Label, by which the button width itself depends.
The library automatically fits the width and places the text in the center.
Figure 6.Button graphical layout
Ta bl e 7 describes the NewButton function:
Table 7.NewButton API function
NameDescription
Function name NewButton
Function prototype
Behavior description Create and initialize a new button object (a C structure)
Input parameter {x}
Output parameter {x} None
Return value The created object pointer or null if the object cannot be created
oName: object name
Label: Label on button
pEventHandler: pointer to function associated to its touch event
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares & initiates a Button Object and add it with specified coordinates to a
Page Object */
GL_PageControls_TypeDef* TestBtn = NewButton("TestBtn", "Test Button", TestBtnFunc);
AddPageControlObj((uint16_t)((LCD_Width/10)*6), (uint8_t)((LCD_Height/9)*4),
TestBtn, &page1);
Once a button object instance is created using the NewButton function, the button object
itself provides all its features through its internal function pointers.
24/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
Figure 14, 15, 16, show, in detail, the button object properties and methods which the final
application can use to interact with.
4.1.3 NewCheckbox API global function
The checkbox object follows a Boolean principle so its value can be defined in a binary way
(0/1).
A typical example of this kind of object could be enable/disable a variable concerning a
specified feature/option.
Figure 7.Checkbox graphical layout
Ta bl e 8 describes the NewCheckbox function:
Table 8.NewCheckbox API function
NameDescription
Function name NewCheckbox
Function prototype
Behavior description Create and initialize a new Label Object (a C structure)
Input parameter {x}
Output parameter {x} None
Return value The created object pointer or null if the object cannot be created
oName: object name
Label: Label for the checkbox
pEventHandler: pointer to function associated to its touch event
Required preconditions None
Called functions No API/HAL layer functions
Example
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Checkbox Object and add it with specified coordinates to
a Page Object */
GL_PageControls_TypeDef* CheckBox = NewCheckbox("CheckBox", "Enable", CheckboxFunc);
AddPageControlObj((uint16_t)((LCD_Width/10)*7),(uint8_t)((LCD_Height/9)*4),CheckBox,
&page1);
Once a checkbox object instance is created using the NewCheckbox function, the checkbox
object itself provides all its features through its internal function pointers.
Figure 14, 15, 16, show, in detail, the Checkbox object properties and methods which the
final application can use to interact with.
Doc ID 16918 Rev 525/105
Multi-input embedded GUI library firmwareAN3128
4.1.4 NewSwitch API global function
The switch object or SwitchButton is very similar to the button object and actually contains
all its features, the only difference being that when this object is stimulated through the
touchscreen or the joystick, its state, and then its graphical look, change permanently until a
new press event.
The most obvious function of this object is to change the status of a Boolean/Binary variable
(0/1) and so enable/disable something.
Figure 8.Switch graphical layout
Ta bl e 9 describes the NewSwitch function:
Table 9.NewSwitch API function
NameDescription
Function name NewSwitch
Function prototype
Behavior description Create and initialize a new Label Object (a C structure)
Input parameter {x}
Output parameter {x} None
Return value The created object pointer or null if the object cannot be created
oName: object name
Label_1: Label on not clicked switch button
Label_2: Label on clicked switch button
pEventHandler: pointer to function associated to its touch event
Example
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Switch Object and add it with specified coordinates to a
Page Object */
GL_PageControls_TypeDef* EnDisBtn = NewSwitch("EnDisBtn","Enable","Disable",MyFunc);
AddPageControlObj((uint16_t)((LCD_Width/10)*6),(uint8_t)((LCD_Height/9)*4),EnDisBtn,
&page1);
Once a switch object instance is created using the NewSwitch function, the switch object
itself provides all its features through its internal function pointers.
Figure 14, 15, 16, show, in detail, the switch object properties and methods which the final
application can use to interact with.
26/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4.1.5 NewIcon API global function
This object allows the user to show an arbitrary image on the LCD, stored in the Flash
memory of the MCU, and associate the press event of the image itself through the
touchscreen or the joystick.
oName: object name
Image_PTR: icon image pointer
Width: image width
Height: image height
pEventHandler: pointer to function associated to its touch event
Required preconditions None
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declare and initiate a Icon Object and add it with specified coordinates to a Page
Object */
GL_PageControls_TypeDef* MyIcon = NewIcon ("MyIcon", NULL, 90, 90, NullFunc);
AddPageControlObj( (uint16_t)((LCD_Width/2)+45),(uint8_t)((LCD_Height/2)+45),MyIcon,
&page1 );
Once an icon object instance is created using the icon function, the icon object itself
provides all its features through its internal function pointers.
Figure 14, 15, 16, show, in detail, the icon object properties and methods which the final
application can use to interact with.
Doc ID 16918 Rev 527/105
Multi-input embedded GUI library firmwareAN3128
4.1.6 NewRadioButtonGrp API global function
The radio button (sometimes called the option button) is a special kind of button that allows
the user to choose only one of a predefined set of alternatives. Its name derives from the old
car radio, where this button was used to select the preset stations. The major difference with
the ordinary button is that the radio buttons are arranged in groups where the group acts as
a big switchboard. In a group, only one radio button must be selected at most. Then, if in a
group, the first radio button is in the selected state, and suddenly the second radio button is
pressed, the first one must be immediately released going back to the normal state, and the
second passes to the selected state.
Figure 9.Radio button graphical layout
Ta bl e 1 1 describes the NewRadioButtonGrp function:
Table 11.NewRadioButtonGrp API function
NameDescription
Function name NewRadioButtonGrp
Function prototype GL_RadioButtonGrp_TypeDef* NewRadioButtonGrp (char* oName)
Behavior description Create and initialize a new RadioButtonGrp object (a C structure)
Input parameter {x} oName: object name
Output parameter {x} None
Return value The created object pointer or null if the object cannot be created
Required preconditions None
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a RadioButtonGrp Object */
GL_RadioButtonGrp_TypeDef* RadioButtonGrp = NewRadioButtonGrp("RadioButtonGrp");
4.1.7 AddRadioOption API global function
Ta bl e 1 2 describes the AddRadioOption function:
Table 12.AddRadioOption API function
NameDescription
Function name AddRadioOption
GL_PageControls_TypeDef* AddRadioOption
Function prototype
Behavior description Create and initialize a new Label Object (a C structure)
Once a RadioOption object instance is created using the AddRadioOption function, the
RadioOption object itself provides all its features through its internal function pointers.
Figure 14, 15, 16,show, in detail, the RadioOption object properties and methods which the
final application can use to interact with.
4.1.8 NewComboBoxGrp API global function
This kind of object allows the user to choose an option from a list of alternatives that can be
scrolled by selecting the up/down arrows.
Figure 10. Combobox graphical layout
Doc ID 16918 Rev 529/105
Multi-input embedded GUI library firmwareAN3128
Ta bl e 1 3 describes the NewComboBoxGrp function:
Table 13.NewComboBoxGrp API function
NameDescription
Function name NewComboBoxGrp
Function prototype GL_PageControls_TypeDef* NewComboBoxGrp (char* oName)
Behavior description Create and initialize a new
Input parameter {x} oName: object name
Output parameter {x} None
Return value The created object pointer or null if the object cannot be created
Required preconditions None
Called functions No API/HAL layer functions
ComboBoxGrp object (a C structure)
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a ComboBoxGroup Object and add it with specified
coordinates to a Page Object */
GL_PageControls_TypeDef* MyComboGrp = NewComboBoxGrp("MyComboGrp");
AddPageControlObj((uint16_t)((LCD_Width/10)*8),(uint8_t)(LCD_Height/2),MyComboGrp,
&page1);
Once a ComboBoxGrp object instance is created using the NewComboBoxGrp function, the
ComboBoxGrp object itself provides all its features through its internal function pointers.
Figure 14, 15, 16,show, in detail, the ComboBoxGrp object properties and methods which
the final application can use to interact with.
4.1.9 AddComboOption API global function
Ta bl e 1 4 describes the AddComboOption function:
Table 14.AddComboOption API function
NameDescription
Function name AddComboOption
Function prototype
Behavior description Create and initialize a new ComboBoxOption object (a C structure)
Input parameter {x}
Output parameter {x} None
Return value GL_OK if successful, GL_ERROR otherwise
GL_ComboBoxGrp_TypeDef*: pThis
Label: Label for RadioButton option
pEventHandler: pointer to function associated to its touch event
AN3128Multi-input embedded GUI library firmware
Table 14.AddComboOption API function (continued)
NameDescription
Required preconditions NewComboBoxGrp must have been called before
Called functions No API/HAL layer functions
Example:
GL_ErrStatus errStatus;
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declare and initiate a ComboBoxGroup with its ComboOptions Object and add it with
specified coordinates to a Page Object */
GL
Once a ComboBoxGrp object and its combo option instances are created using the
NewComboBoxGrp and AddComboOption functions, ComboBoxGrp and combo option
objects themselves provide all their features through their internal function pointers.
Figure 14, 15, 16,show, in detail, the ComboBoxOption object properties and methods
which the final application can use to interact with.
4.1.10 NewSlidebar API global function
This kind of object is composed of a rectangular shaped 3D image and a thin cursor that can
be moved using the joystick or touchscreen pressing the cursor itself laterally. The variance
is established in a percentage from 0 to 100, and the minimum step is fixed at 5%.
A typical example of the application of this object could be the volume variation of the audio
output in an MP3 player.
It is possible to read the current value of the cursor position through the function
“Get_SlidebarValue” defined in the following pages, therefore easily integrating such an
object in the application.
The slidebar can be chosen to be printed horizontally or vertically, as shown in Figure 11.
Figure 11. Slidebar graphical object
Doc ID 16918 Rev 531/105
Multi-input embedded GUI library firmwareAN3128
Ta bl e 1 5 describes the NewSlidebar function:
Table 15.NewSlidebar API function
NameDescription
Function name NewSlidebar
Function prototype
Behavior description Create and initialize a new slidebar object (a C structure)
Input parameter {x}
Output parameter {x} None
Return value The created object pointer or null if the object cannot be created
oName: object name
Label: Label for slidebar meaning
direction: the printing orientation. The parameters can be GL_Vertical or
GL_Horizontal
pEventHandler: pointer to function associated to its touch event
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Slidebar Object and add it with specified coordinates to
a Page Object */
GL_PageControls_TypeDef* MySlidebar = NewSlidebar("MySlidebar", "Volume",
GL_Horizontal, MySlidebarFunc);
AddPageControlObj((uint16_t)((LCD_Width/10)*7),(uint8_t)(LCD_Height/2),MySlidebar,
&page1);
Once a slidebar object instance is created using the NewSlidebar function, the slidebar
object itself provides all its features through its internal function pointers.
Figure 14, 15, 16, show, in detail, the slidebar object properties and methods which the final
application can use to interact with.
32/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4.1.11 NewHistogram API global function
This kind of object is composed of two axes (X & Y) with the relative values printed to the
side, and a certain number of blue columns representing the real distribution of respective
values. The values are saved in a vector of decimal numbers.
A typical example of the application of this object may be reading the distribution of
measured values concerning changing data.
It is possible to change the values of the vectors through the function “SetHistogramPoints”
defined in the following pages, therefore easily integrating such an object into the
application.
Figure 12. Histogram graphical object
Ta bl e 1 6 describes the NewHistogram function:
Table 16.NewHistogram API function
NameDescription
Function name NewHistogram
Function prototype
Behavior description Create and initialize a new histogram object (a C structure)
Input parameter {x}
Output parameter {x} None
Return value The created object pointer or null if the object cannot be created
oName: object Name
LabelX: Label for the X axis
LabelY: Label for the Y axis
data_points[]: the array of points to be plotted on the LCD pointer to
function associated to its touch event
n_points: number of points to be plotted
Doc ID 16918 Rev 533/105
Multi-input embedded GUI library firmwareAN3128
Table 16.NewHistogram API function (continued)
NameDescription
Required preconditions None
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Histogram Object and add it with specified coordinates to
a Page Object */
int16_tMyHistPoints[24];
MyHistPoints = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
GL_PageControls_TypeDef* MyHistogram = NewHistogram("MyHistogram", "Hours", "Wh",
MyHistPoints, 24 );
AddPageControlObj( 0, 0, MyHistogram, &page1 );
Once a histogram object instance is created using the NewHistogram function, the
histogram object itself provides all its features through its internal function pointers.
Figure 14, 15, 16, show, in detail, the histogram object properties and methods which the
final application can use to interact with.
34/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4.1.12 NewGraphChart API global function
This kind of object is made up of two axes (X and Y) with the relative values printed to the
side, and a certain number of blue columns representing the real distribution of respective
values. The values are saved in a vector of decimal numbers.
A typical example of the application of this object may be reading the distribution of
measured values concerning changing data.
It is possible to change the values of the vectors through the function “SetGraphChartPoints”
defined in the following pages, therefore easily integrating such an object into the
application.
oName: object Name
LabelX: Label for the X axis
LabelY: Label for the Y axis
data_points[]: the array of points to be plotted on the LCD pointer to
function associated to its touch event
n_points: number of points to be plotted
Background: select if black background has to be used. This parameter can
be GL_TRUE or GL_FALSE
Doc ID 16918 Rev 535/105
Multi-input embedded GUI library firmwareAN3128
Table 17.NewGraphChart API function (continued)
Function name NewGraphChart
Return value The created object pointer or null if the object cannot be created
Required preconditions None
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares & initiates a GraphChart Object and add it with specified coordinates to
a Page Object */
int16_tMyChartPoints[24];
MyChartPoints = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
GL_PageControls_TypeDef* MyGraphChart = NewGraphChart("MyGraphChart", "Hours", "Wh",
MyChartPoints, 24);
AddPageControlObj( 0, 0, MyGraphChart, &page1 );
Once a GraphChart object instance is created using the NewGraphChart function, the
GraphChart object itself provides all its features through its internal function pointers.
Figure 14, 15, 16, show, in detail, the GraphChart object properties and methods which the
final application can use to interact with.
4.1.13 AddPageControlObj API global function
Ta bl e 1 8 describes the AddPageControlObj function:
Table 18.AddPageControlObj API function
NameDescription
Function name AddPageControlObj
Function prototype
Behavior description Add a new control object to the page
Input parameter {x}
Output parameter {x} None
Return value GL_OK if successful, GL_ERROR otherwise
PosX & PosY: max and min coordinates for X and Y axis
*objPTR: pointer to object structure
*pagePTR: pointer to page structure
NewXXX must have been called before, where XXX represents a kind of
graphical object
Called functions No API/HAL layer functions
The values of PosX and PosY parameters represent the coordinates of the top-left corner of
the object according to the origin coordinates placed in the top-right corner of the LCD.
36/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
Example:
GL_ErrStatus errStatus;
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
. . . . . .
/* Adding an object with specified coordinates to a Page Object */
errStatus =
AddPageControlObj((uint16_t)((LCD_Width/10)*7.5),(uint8_t)(LCD_Height/2),
MyGraphicObject, &page1);
Once a PageControl object instance is created using the AddPageControlObj function, the
PageControl object itself provides all its features through its internal function pointers.
Figure 14, 15, 16, show, in detail, the PageControl object properties and methods which the
final application can use to interact with.
4.1.14 DestroyPageControl API global function
Ta bl e 1 9 describes the DestroyPageControl function:
Behavior description Free the allocated memory for a PageControl object
Input parameter {x}
*pPage: pointer to page structure
objName: name of the object
Output parameter {x} None
Return value GL_OK if successful, GL_ERROR otherwise
Required preconditions
NewXXX must have been called before, where XXX represents a kind of
graphical object
Called functions No API/HAL layer functions
Example:
GL_ErrStatus errStatus;
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
...
/* Adding an object with specified coordinates to a PageControl Object */
errStatus = AddPageControlObj((
MyGraphObj,&page1);
/* De-allocate a Page Object */
DestroyPageControl(page1, "MyGraphicObject");
uint16_t)(LCD_Width/2),(uint8_t)(LCD_Height/2),
Once a PageControl object instance is created, it can be destroyed at any time using the
DestroyPageControl function, and its pointer is set to NULL.
Doc ID 16918 Rev 537/105
Multi-input embedded GUI library firmwareAN3128
4.1.15 DestroyPage API global function
Ta bl e 2 0 describes the DestroyPage function:
Table 20.DestroyPage API function
NameDescription
Function name DestroyPage
Function prototype GL_ErrStatus DestroyPage (GL_Page_TypeDef * pPage)
Behavior description
Input parameter {x} *pPage: pointer to page structure
Output parameter {x} None
Return value GL_OK if successful, GL_ERROR otherwise
Required preconditions
Called functions No API/HAL layer functions
Free the allocated memory for all the PageControl objects belonging to a
page
NewXXX must have been called before, where XXX represents a kind of
graphical object
Example:
GL_ErrStatus errStatus;
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
. . . . . .
/* Adding an object with specified coordinates to a PageControl */
errStatus = AddPageControlObj( (uint16_t)(LCD_Width/2), (uint8_t)(LCD_Height/2),
MyGraphicObject, &page1);
/* De-allocate all the Object belonging to a Page */
DestroyPage(&page1);
Once a page object instance is created, it can be destroyed at any time using the
DestroyPage function, and its pointer is set to NULL.
4.1.16 Set_Label API global function
Ta bl e 2 1 describes the Set_Label function:
Table 21.Set_Label API function
NameDescription
Function name Set_Label
Function prototype
Behavior description Modify the Label in a Label Object
objName: name of the object
Label: text on a Label Object
Output parameter {x} None
Return value GL_OK if successful, GL_ERROR otherwise
Required preconditions None
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Label Object and add it with specified coordinates to a
Page Object */
GL_PageControls_TypeDef* pageLabel = NewLabel("pageLabel", "Graphic Library",
GL_HORIZONTAL, GL_FONT_BIG, GL_Blue);
AddPageControlObj((uint16_t)((LCD_Width/11)*9), (uint8_t)(LCD_Height/11), pageLabel,
&page1);
/* Modify the label in a "Label Object" */
Set_Label(&page1, "pageLabel", "Graphic Library New")
Figure 14, 15, 16, show, in detail, the Label Object properties and methods which the final
application can use to interact with.
4.1.17 Get_Label API global function
Ta bl e 2 2 describes the Get_Label function:
Table 22.Get_Label API function
NameDescription
Function name Get_Label
Function prototype
Behavior description Return the Label of a Label Object
Input parameter {x}
Output parameter {x} Label: this is the variable where the Label of a Label Object is copied into
Return value GL_OK if successful, GL_ERROR otherwise
*pPage: pointer to page structure
objName: name of the object
Doc ID 16918 Rev 539/105
Multi-input embedded GUI library firmwareAN3128
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Label Object and add it with specified coordinates to a
Page Object */
GL_PageControls_TypeDef* pageLabel = NewLabel("pageLabel", "Graphic Library",
GL_HORIZONTAL, GL_FONT_BIG, GL_Blue);
AddPageControlObj((uint16_t)((LCD_Width/11)*9),(uint8_t)(LCD_Height/11),pageLabel,
&page1);
/* Modify the label in a "Label Object" */
Set_Label(&page1, "pageLabel", "Graphic Library New")
/* Get the label in a "Label Object" */
Char* label;
Get_Label(&page1, "pageLabel", label)
Figure 14, 15, 16, show, in detail, the Label Object properties and methods which the final
application can use to interact with.
4.1.18 GetComboOptionLabel API global function
Ta bl e 2 3 describes the GetComboOptionLabel function:
Table 23.GetComboOptionLabel API function
NameDescription
Function name GetComboOptionLabel
Function prototype char* GetComboOptionLabel(GL_Page_TypeDef* pPage, char* objName)
Behavior description Return the active combo option Label
Input parameter {x}
*pPage: pointer to page structure
objName: name of the object
Output parameter {x} None
Return value
char* Label: the active combo option Label if the object was found
GL_NULL: if the object was not found
Required preconditions None
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Label Object and add it with specified coordinates to a
Page Object */
AddPageControlObj((uint16_t)((LCD_Width/11)*9),(uint8_t)(LCD_Height/11),pageLabel,
&page1);
/* Declares and initiates a Combobox object */
GL_PageControls_TypeDef* ComboBoxGrp1 = NewComboBoxGrp("ComboBoxGrp1");
/* Modify the label in a "Label Object by the active combobox option label" */
Set_Label( &page1, "pageLabel", GetComboOptionLabel(&page1, "ComboBoxGrp1") );
ComboBoxGrp1,
Figure 14, 15, 16, show, in detail, the Combobox object properties and methods which the
final application can use to interact with.
4.1.19 SetComboOptionLabel API global function
Ta bl e 2 4 describes the SetComboOptionLabel function:
Behavior description Set the Label for the active ComboOption
*pPage: pointer to page structure
Input parameter {x}
objName: name of the object
Label: new Label for the active ComboOption object
Output parameter {x} None
Return value GL_OK if successful, GL_ERROR otherwise
Required
preconditions
None
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Label Object and add it with specified coordinates to a
Page Object */
GL_PageControls_TypeDef* pageLabel = NewLabel("pageLabel", "Graphic Library",
GL_HORIZONTAL, GL_FONT_BIG, GL_Blue);
AddPageControlObj((uint16_t)((LCD_Width/11)*9),(uint8_t)(LCD_Height/11),pageLabel,
&page1);
/* Declares and initiates a Combobox object */
GL_PageControls_TypeDef* ComboBoxGrp1 = NewComboBoxGrp("ComboBoxGrp1");
AddComboOption (ComboBoxGrp1->objPTR, "Option1", ComboboxFunc);
AddComboOption (ComboBoxGrp1->objPTR, "Option2", ComboboxFunc);
AddComboOption (ComboBoxGrp1->objPTR, "Option3", ComboboxFunc);
AddPageControlObj((uint16_t)((LCD_Width/10)*7),(uint16_t)(LCD_Height/2),
&page1);
...
/* Modifying the active combobox option label" */
SetComboOptionLabel(&page1, "ComboBoxGrp1", "NewLabel");
ComboBoxGrp1,
Doc ID 16918 Rev 541/105
Multi-input embedded GUI library firmwareAN3128
Figure 14, 15, 16, show, in detail, the Combobox object properties and methods which the
final application can use to interact with.
4.1.20 ResetComboOptionActive API global function
Ta bl e 2 5 describes the ResetComboOptionActive function:
*pPage: pointer to page structure
objName: name of the object
Return value
j: the active combo option index if the object was found
GL_NULL: if the object was not found
Required preconditions None
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a ComboBoxGroup with its ComboOptions Object and add it
with specified coordinates to a Page Object */
GL_PageControls_TypeDef* MyComboBoxGrp = NewComboBoxGrp("MyComboBoxGrp");
AddComboOption (MyComboBoxGrp ->objPTR, "Option1", MyComboboxFunc);
AddComboOption (MyComboBoxGrp ->objPTR, "Option2", MyComboboxFunc);
AddComboOption (MyComboBoxGrp ->objPTR, "Option3", MyComboboxFunc);
*pPage: pointer to page structure
objName: name of the object
pImage: pointer to the image
Width: image width
Height: image height
Called functions No API/HAL layer functions
Example:
...
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Icon Object and add it with specified coordinates to a
Page Object */
GL_PageControls_TypeDef* MyIcon = NewIcon("MyIcon",(GL_uint8_t*)myImage1,90,90,
IconFunc);
AddPageControlObj((uint16_t)((LCD_Width/2)+45),(uint8_t)((LCD_Height/2)+45),MyIcon,
&page1);
...
Ta bl e 2 8 describes the Get_SlidebarValue function:
Table 28.Get_SlidebarValue API function
NameDescription
Function name Get_SlidebarValue
Function prototype uint8_t Get_SlidebarValue (GL_Page_TypeDef* pPage, char* objName)
Behavior description Return the current value of cursor position in a slidebar object
Input parameter {x}
Output parameter {x} None
Return value The cursor position value (0-100 percentage)
Required preconditions None
Called functions No API/HAL layer functions
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
*pPage: pointer to page structure
objName: name of the object
/* Declares and initiates a Slidebar Object and add it with specified coordinates to
a Page Object */
GL_PageControls_TypeDef* MySlidebar = NewSlidebar("MySlidebar", "Volume",
GL_Horizontal, MySlidebarFunc);
AddPageControlObj((uint16_t)((LCD_Width/10)*7),(uint8_t)((LCD_Height/9)*3),
MySlidebar,&page1);
*pPage: pointer to page structure
objName: name of the object
data_points[]: the array of points to be plotted on the LCD
n_points: number of points to be plotted
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Histogram Object and add it to a Page Object */
MyHistogram = NewHistogram ("MyHistogram", "Hours", "Watt", points, 24);
AddPageControlObj( 0, 0, MyHistogram, &page1 );
...
MyHistogramPoints ={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
Table 30.SetGraphChartPoints API function (continued)
NameDescription
*pPage: pointer to page structure
Input parameter {x}
Output parameter {x} None
Return value GL_OK if successful, GL_ERROR otherwise
Required preconditions None
Called functions No API/HAL layer functions
objName: name of the object
data_points[]: the array of points to be plotted on the LCD
n_points: number of points to be plotted
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a GraphChart Object and add it to a Page Object */
MyGraphChart = NewGraphChart("MyGraphChart", "Hours", "Watt", points, 24, GL_TRUE);
AddPageControlObj( 0, 0, MyGraphChart, &page1 );
...
MyGraphChartPoints={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24};
SetGraphChartPoints( &page1, "MyGraphChart", MyGraphChartPoints, 24 );
Figure 14, 15, 16, show, in detail, the GraphChart object properties and methods which the
final application can use to interact with.
4.1.26 GetObjStatus API global function
Ta bl e 3 1 describes the GetObjStatus function:
Table 31.GetObjStatus API function
NameDescription
Function name GetObjStatus
Function prototype GL_bool GetObjStatus(GL_Page_TypeDef* pThis, char* objName)
Return the status of the object:
Behavior description
Input parameter {x}
Output parameter {x} None
Return value GL_FALSE, GL_TRUE, or NULL in case no object is defined
Required preconditions None
Called functions No API/HAL layer functions
– GL_FALSE: the object is not Hit
– GL_TRUE: the object has been Hit
– NULL: represents that there are no objects with that name (objName).
*pPage: pointer to page structure
objName: name of the object
Doc ID 16918 Rev 547/105
Multi-input embedded GUI library firmwareAN3128
Example:
/* Declares and initiates a Page Object */
GL_Page_TypeDef page1;
Create_PageObj( &page1 );
/* Declares and initiates a Checkbox Object and add it with specified coordinates to
a Page Object */
GL_PageControls_TypeDef* CheckBox = NewCheckbox("CheckBox", "Enable", CheckboxFunc);
AddPageControlObj( (uint16_t)((LCD_Width/10)*7), (uint8_t)((LCD_Height/9)*3),
CheckBox, &page1);
uint16_t Lcd_Width: width of the LCD Panel
uint16_t Lcd_Height: height of the LCD Panel
4.1.32 Set_LastFlashMemoryAddress API global function
Ta bl e 3 7 describes the Set_LastFlashMemoryAddress function:
Table 37.Set_LastFlashMemoryAddress API global function
NameDescription
Function name Set_LastFlashMemoryAddress
Function prototype void Set_LastFlashMemoryAddress (uint32_t address)
Set the last Flash memory address.
Behavior description
Input parameter {x} uint32_t address: pointer to the last memory location
Output parameter {x} None
Return value None
Required preconditions None
Called functions No API/HAL layer functions
This address is used to calculate the penultimate Flash memory page,
where the calibration parameters are saved.
52/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
Example:
int main(void)
{
...
Set_LastFlashMemoryAddress( 0x08040000 );
...
}
The address of the Flash memory page, where the calibration parameters are saved, is
calculated by subtracting from the last Flash memory address, the size of one memory page
corresponding to “1024” (if a page is “1024 bytes”) and the size in bytes of a memory
pointer, “4” (32-bit), just to align the address to the start of a memory page location.
Therefore, if the Flash memory size is 256 KB and the ROM start address is 0x08000000, it
is necessary to subtract 0x0400+0x0004=0x0404 (1024+4=1028 in decimal) from
0x08040000 that is the last Flash memory address. The result is: 0x0803EFD8.
4.1.33 CursorInit API global function
The cursor is composed of two essential elements. The first is a data structure which
gathers all the necessary variables for regular cursor operations including user-defined
settings, and secondly a graphic appearance displayed on a screen, letting the user know
about its position as a main purpose of it.
In the meantime, the cursor seems to act as a graphic object, but it is different because it is
not involved in the user events management.
Although the actual implementation of the cursor can manage only the input from the
joystick, its structure also supports the input from the mouse connected to a USB port (this
feature is to be available in a future release).
The cursor data structure gathers all variables needed for the regular functioning of service
routines, such as coordinates, press state, pointer to the cursor bitmap mask, and array of
background pixel color. This array, together with a pixels pointer mask serves as storage for
pixels located behind an actual pointer mark. They must be saved before the cursor is
displayed, in order to allow the removal of the cursor when just these stored pixels are
employed to overdraw an old-positioned cursor. Therefore, no information is lost by cursor
drawing (moving).
The CursorInit function initializes a cursor, allocating the memory for the cursor data
structure and afterwards allocating the memory for behind data pixels regarding the number
of pixels listed in the pointer mark header. Ta b le 3 8 describes the CursorInit function:
Table 38.CursorInit API global function
NameDescription
Function name CursorInit
Function prototype ErrorStatus CursorInit (GL_uint8_t *PointerMark)
Behavior description
Input parameter {x} *PointerMark: pointer to the cursor mask
Output parameter {x} None
Return value None
Initiate the cursor including allocating memory for structure and behind
array.
This section describes the graphic object structures, and all their exported API functions and
defined types. See Figure 14, 15, 16.
Here is a description of the defined types used by graphic object source code and a
description of its properties and methods. All API layer types are defined in the file
GraphicObjectTypes.h.
The following structure types can be considered as OOP classes including private/public
properties and public methods. The final graphic objects are instances of these defined
structures.
These structure fields' parameters must not be directly accessed by the final application and
Getxxx/Setxxx methods should be used instead. Obviously the final application could
access these private members, but it should never do so.
The final application must interact with this library using the following public properties and
methods only, as described in the following sections.
/* Joystick Reading Mode */
typedef enum /* It contains the Reading Mode Parameter for the Joystick (Polling
Mode, IOExpander) */
{
IOEXP_MODE = 0,
POLLING_MODE = 1,
INTERRUPT = 2
}JOY_ReadMode;
64/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4.2.26 BTN_HW_Parameters_TypeDef type
/* Object type */
typedef struct /* It contains the Hardware Parameter for the Push Button (i.e.
Port, Pin) */
{
GL_uint8_t BTN_PortSource;
GL_uint16_t BTN_PinSource;
GL_uint8_t BTN_Exti_IrqChannel;
GL_uint32_t BTN_Exti_Line;
GL_PortType * BTN_Port
GL_uint16_t BTN_Pin
GL_PortType * BUTTON_Port;
GL_uint16_t BUTTON_Pin;
}BTN_HW_Parameters_TypeDef;
4.3 Graphic object API properties
4.3.1 Graphics controls:: properties
Below are some DEFINES that are useful for some of the graphic object parameters.
#define MAX_CTRL_X_PAGE 30 /* Defines the Max number of graphic objects per page */
#define MAX_NAME_LENGTH 22 /* Defines the Max name length for graphic objects */
#define MAX_LABEL_LENGTH 46 /* Defines the Max length for Label (Label objects) */
#define MAX_BUTTON_LABEL_LENGTH 16 /*Defines the Max Label length of Button objects*/
#define MAX_CHECKBOX_LABEL_LENGTH 25 /* Defines the Max Label length for Checkbox */
#define MAX_RADIO_OPTION_LABEL_LENGTH 12 /* Defines the Max Label length of
RadioButton */
#define MAX_RADIO_OPTIONS 3 /* Defines the Max options number of RadioButton group */
#define MAX_COMBO_OPTIONS 10 /* Defines the Max values number of ComboBox objects */
#define MAX_COMBO_LABEL_LENGTH 16 /* Defines the Max Label length for the ComboBox */
#define MAX_SWITCH_LABEL_LENGTH 12 /* Defines the Max Label length for the Switch */
#define MAX_SLIDE_LABEL_LENGTH 16 /* Defines the Max Label length for the Slidebar */
#define MAX_HIST_LABEL_LENGTH 7 /* Defines the Max Label length for the Histogram */
#define MAX_GRAPH_LABEL_LENGTH 7
#define MAX_HIST_POINTS 50 /* Defines the Max number of points for the Histogram */
#define MAX_GRAPH_POINTS 100 /*
/*Definesthe Max Label length for the GraphChart*/
Defines the Max number of points for the GraphChart*/
4.3.2 Graphic Object:: PagesList array
The GraphicObject.h library file exports the following public property:
extern GL_Page_TypeDef* PagesList[];
PagesList contains the array of page pointers created statically by the application. This
object has been left as public for utility means.
4.3.3 LCD:: pLcdParam API properties
LcdHal.c exports the following public structure variable:
/* Assign the following values for Button Parameters structure*/
pBtnParam->BTN_Port = USER_BUTTON_PORT;
pBtnParam->BTN_Pin = USER_BUTTON_PIN;
...
}
70/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4.4 HAL layer firmware overview
The following section describes the hardware abstraction layer function used by the upper
API layer described in the previous section. All the library microcontroller hardware
dependent functions and related defined types are described in this section. See Figure 14,
15, 16.
The final application should never directly use these HAL functions, and it should only
manage LCD, touchscreen, and joystick through API layer functions as described above.
/* Flag/IT Status Type */
typedef enum /* It contains the status parameter of LCD Flags/Interrupts
(GL_RESET, GL_SET) */
{
GL_RESET = 0,
GL_SET = !GL_RESET,
}GL_FlagStatus, GL_ITStatus;
4.5.3 GL_SignalActionType type
/* Signal state enumeration */
typedef enum
{
GL_LOW = Bit_RESET,
GL_HIGH = Bit_SET
}GL_SignalActionType;
Xpos: specifies the X position.
Ypos: specifies the Y position.
Length: line length.
Direction: line direction. This parameter can be one of the following values:
Vertical or Horizontal.
76/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4.6.11 GL_DrawBMP HAL function
Ta bl e 5 0 describes the GL_DrawBMP function of the hardware abstraction layer.
Table 50.GL_DrawBMP
NameDescription
Function name GL_DrawBMP
Function prototype void GL_DrawBMP (GL_uint8_t* ptrBitmap)
GPIO_PortSource: selects the GPIO port to be used as source for EXTI
lines. This parameter can be GPIO_PortSourceGPIOx where x can be
(A..G).
GPIO_PinSource: specifies the EXTI line to be configured. This parameter
can be GPIO_PinSourcex where x can be (0..15).
Output parameter {x} None
Return value None
Doc ID 16918 Rev 583/105
Multi-input embedded GUI library firmwareAN3128
Table 65.GL_GPIO_EXTILineConfig (continued)
NameDescription
Required preconditions None
Called functions GPIO_EXTILineConfig (GPIO_PortSource, GPIO_PinSource)
4.6.27 GL_EXTI_TSC_IRQHandler HAL function
Ta bl e 6 6 describes the GL_EXTI_TSC_IRQHandler function of the hardware abstraction
layer.
Table 66.GL_EXTI_TSC_IRQHandler
NameDescription
Function name GL_EXTI_TSC_IRQHandler
Function prototype void GL_EXTI_TSC_IRQHandler (void)
Behavior description This function handles external lines interrupt request for the touchscreen
Input parameter {x} None
Output parameter {x} None
Return value None
Required preconditions None
Called functions None
4.6.28 GL_TSC_Interface_Init HAL function
Ta bl e 6 7 describes the GL_TSC_Interface_Init function of the hardware abstraction layer.
Table 67.GL_TSC_Interface_Init
NameDescription
Function name GL_TSC_Interface_Init
Function prototype GL_uint32_t GL_TSC_Interface_Init (void)
Behavior description Initializes the IO expander registers
Input parameter {x} None
Output parameter {x} None
Return value 0: if all initializations are OK
Required preconditions None
Called functions TSC_IOExpander_Init()
84/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4.6.29 GL_JOY_Interface_Init HAL function
Ta bl e 6 8 describes the GL_JOY_Interface_Init function of the hardware abstraction layer.
Table 68.GL_JOY_Interface_Init
NameDescription
Function name GL_JOY_Interface_Init
Function prototype GL_uint32_t GL_JOY_Interface_Init (void)
Behavior description Initializes the IO expander registers
Input parameter {x} None
Output parameter {x} None
Return value 0: if all initializations are OK
Required preconditions None
Called functions JOY_IOExpander_Init()
4.6.30 GL_JoyStickConfig_IOExpander HAL function
Ta bl e 6 9 describes the GL_JoyStickConfig_IOExpander function of the hardware
abstraction layer.
Table 69.GL_JoyStickConfig_IOExpander
NameDescription
Function name GL_JoyStickConfig_IOExpander
Function prototype void GL_JoyStickConfig_IOExpander(void)
Behavior description Initializes the IO expander for joystick operations
Input parameter {x} None
Output parameter {x} None
Return value None
Required preconditions None
Called functions None
4.6.31 GL_JoyStickConfig_GPIO HAL function
Ta bl e 7 0 describes the GL_JoyStickConfig_ GPIO function of the hardware abstraction
layer.
Table 70.GL_JoyStickConfig_GPIO
NameDescription
Function name GL_JoyStickConfig_GPIO
Function prototype void GL_JoyStickConfig_GPIO(void)
Behavior description Configures the GPIO ports pins concerned with the joystick.
Doc ID 16918 Rev 585/105
Multi-input embedded GUI library firmwareAN3128
Table 70.GL_JoyStickConfig_GPIO (continued)
NameDescription
Input parameter {x} None
Output parameter {x} None
Return value None
Required preconditions None
Called functions None
4.6.32 GL_JoyStickStateIOEXP HAL function
Ta bl e 7 1 describes the GL_JoyStickStateIOEXP function of the hardware abstraction layer.
Table 71.GL_JoyStickStateIOEXP
NameDescription
Function name GL_JoyStickStateIOEXP
Function prototype uint32_t GL_JoyStickStateIOEXP(void)
Behavior description Return the joystick status
Input parameter {x} None
Output parameter {x} None
Return value The code of the joystick key pressed
Required preconditions None
Called functions None
4.6.33 GL_JoyStickStatePolling HAL function
The state acquisition of the joystick is implemented by reading the relative pins with a period
of 50 ms in order to easily recognize if one of the joystick commands has been activated for
a long period of time.
Ta bl e 7 2 describes the GL_JoyStickStatePolling function of the hardware abstraction layer.
Table 72.GL_JoyStickConfig_GPIO
NameDescription
Function name GL_JoyStickStatePolling
Function prototype uint32_t GL_JoyStickStatePolling (void)
Behavior description Return the joystick status
Input parameter {x} None
Output parameter {x} None
Return value The code of the joystick key pressed
Required preconditions None
Called functions None
86/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
4.6.34 GL_Delay HAL function
The delay routine employs the SysTick processor internal circuit. It is a very simple downcounting counter which is clocked by a processor clock, in this case 72 MHz. The counter
width is 24 bits, so it operates over a range from 16,777,215 to 0. Each working cycle starts
with a counter preloading by the entered scaler which determines a time of counting at the
end of which the SysTick interrupt handler is launched, in order to handle an underflow
event. The handler decrements an intended number of working cycles and reloads the
counter which continues in this manner, setting a number of working cycles generates a
variation of the total time latency.
The second important issue regarding this portion is interrupt handling.
Throughout all the families of diverse microprocessors, the interrupt feature is integrated into
a core behavior as an essential property in order to make it possible to handle some
circumstances time adequately, or better, as soon as possible. The interrupts are very often
closely linked with the data transfers where a regular time characteristic of protocols must
be accomplished or with purely timing business where a need of immediate treatment is
clear.
The library, as well as every ordinary project which employs this library, contains a file of
interrupt handler routines. According to a STM32 start-up vector file, which, among others,
sets a vector table entry with exception handler addresses (this means that it defines the
names of all handlers), a handler must be defined for every possible exception-interrupt
source even if that may be empty and unused.
Therefore, the file of the handler routines comprises also the handlers of peripherals which
are not involved in the application.
The GL_Delay(uint32_t nCount) function stops the code execution of the processor in an
empty “while-loop” for a defined time delay. There is a global variable TimingDelay and
another complementing routine called TimingDelay_Decrement, which must be taken into
account at the process of comprehension. The delay routine, first of all, sets TimingDelay
with an entered nCount number, enables the SysTick counter and then it sticks at whileloop, waiting until the TimingDelay is equal to zero. The TimingDelay value is decremented
by routine, as its name suggests, decrement TimeDelay, which is launched by SysTick
interrupt handler every time the counter reaches zero. Therefore, the nCount variable
multiplied by a SysTick period (which is fixed to 10 ms) is the total time latency caused by
delay procedure.
Ta bl e 7 3 describes the GL_Delay function of the hardware abstraction layer.
Table 73.GL_Delay
NameDescription
Function name GL_Delay
Function prototype void GL_Delay (uint32_t nCount)
Behavior description Inserts a delay time
Input parameter {x} nCount: specifies the delay time length (time base 10 ms)
Output parameter {x} None
Return value None
Required preconditions None
Called functions None
Doc ID 16918 Rev 587/105
Multi-input embedded GUI library firmwareAN3128
4.6.35 TSC_Read HAL function
Ta bl e 7 4 describes the TSC_Read function of the hardware abstraction layer.
Table 74.TSC_Read
NameDescription
Function name TSC_Read
Function prototype void TSC_Read (void)
Behavior description
Input parameter {x} None
Output parameter {x} None
Return value None
Required preconditions None
Called functions None
Reads the coordinates of the point touched and assigns their value to the
variables uint32_t_TSXCoordinate and uint32_t_TSYCoordinate
4.6.36 TSC_FLASH_Unlock HAL function
Ta bl e 7 5 describes the TSC_FLASH_Unlock function of the hardware abstraction layer.
Table 75.TSC_FLASH_Unlock
NameDescription
Function name TSC_FLASH_Unlock
Function prototype void TSC_FLASH_Unlock (void)
Behavior description Unlocks the Flash program erase controller
Input parameter {x} None
Output parameter {x} None
Return value None
Required preconditions None
Called functions None
4.6.37 TSC_FLASH_ClearFlag HAL function
Ta bl e 7 6 describes the TSC_FLASH_ClearFlag function of the hardware abstraction layer.
Table 76.TSC_FLASH_ClearFlag
NameDescription
Function name TSC_FLASH_ClearFlag
Function prototype void TSC_FLASH_ClearFlag (uint16_t FLASH_FLAG)
Behavior description Clears the Flash’s pending flags.
88/105Doc ID 16918 Rev 5
AN3128Multi-input embedded GUI library firmware
Table 76.TSC_FLASH_ClearFlag (continued)
NameDescription
FLASH_FLAG: specifies the Flash flags to clear.
This parameter can be any combination of the following values:
Input parameter {x}
Output parameter {x} None
Return value None
Required preconditions None
Called functions None
– TSC_FLASH_FLAG_PGERR: Flash program error flag
– TSC_FLASH_FLAG_WRPRTERR: Flash write protected error flag
– TSC_FLASH_FLAG_EOP: Flash end of operation flag
4.6.38 TSC_FLASH_ErasePage HAL function
Ta bl e 7 7 describes the TSC_FLASH_ErasePage function of the hardware abstraction layer.
Table 77.TSC_FLASH_ErasePage
NameDescription
Function name TSC_FLASH_ErasePage
Function prototype
Behavior description Erases a specified Flash page.
Input parameter {x} Page_Address: the page address to be erased.
GPIOx: where x can be B or D to select the GPIO peripheral.
CtrlPins: the control line. This parameter can be:
– LCD_CtrlPin_NCS: chip select pin (PB.02)
– CtrlPin_NWR: read/write selection pin (PD.15)
Input parameter {x}
Output parameter {x} None
Return value None
Required preconditions None
Called functions None
– CtrlPin_RS: register/RAM selection pin (PD.07)
BitVal: specifies the value to be written to the selected bit. This parameter
can be:
– GL_LOW: to clear the port pin
– GL_HIGH: to set the port pin
4.6.42 GL_LCD_ReadRAM HAL function
Ta bl e 8 1 describes the GL_LCD_ReadRAM function of the hardware abstraction layer.
Table 81.GL_LCD_ReadRAM
NameDescription
Function name GL_LCD_ReadRAM
Function prototype GL_uint16_t GL_LCD_ReadRAM (void)
Behavior description Reads the LCD RAM
Input parameter {x} None
Output parameter {x} None
Return value LCD RAM value.
Required preconditions None
Called functions None
4.6.43 GL_RCC_APBPeriphClockCmd HAL function
Ta bl e 8 2 describes the GL_RCC_APBPeriphClockCmd function of the hardware abstraction
- RCC_AHBPeriph: specifies the AHB peripheral to gate its clock.
For @b STM32_Connectivity_line_devices, this parameter can be any
combination of the following values:
– RCC_AHBPeriph_DMA1
– RCC_AHBPeriph_DMA2
– RCC_AHBPeriph_SRAM
– RCC_AHBPeriph_FLITF
– RCC_AHBPeriph_CRC
– RCC_AHBPeriph_OTG_FS
– RCC_AHBPeriph_ETH_MAC
– RCC_AHBPeriph_ETH_MAC_Tx
Input parameter {x}
– RCC_AHBPeriph_ETH_MAC_Rx
For @b other_STM32_devices, this parameter can be any combination of
the following values:
– RCC_AHBPeriph_DMA1
– RCC_AHBPeriph_DMA2
– RCC_AHBPeriph_SRAM
– RCC_AHBPeriph_FLITF
– RCC_AHBPeriph_CRC
– RCC_AHBPeriph_FSMC
– RCC_AHBPeriph_SDIO
– NewState: new state of the specified peripheral clock. This parameter can
be: Enable or Disable
Output parameter {x} None
Return value None
Required preconditions None
Called functions None
Doc ID 16918 Rev 593/105
Getting started with the systemAN3128
5 Getting started with the system
5.1 Example application - main.c
An example of a main application is given below. The main function contains an example of
the Graphic library initialization/configuration and implements the classic operations:
#ifdef __GNUC__
/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
set to 'Yes') calls __io_putchar() */
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#endif /* __GNUC__ */
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
RCC_ClocksTypeDef RCC_Clocks;
uint32_t time_out = 0xFFF;
/* Setup the microcontroller system. Initialize the Embedded Flash Interface,
initialize the PLL and update the SystemFrequency variable. */
SystemInit();
/* Setup SysTick Timer for 10 msec interrupts */
RCC_GetClocksFreq(&RCC_Clocks);
if (SysTick_Config(RCC_Clocks.SYSCLK_Frequency / 100))
{
/* Capture error */
while (1);
}
/* Set HW structure parameters */
HWConfig_SetHardwareParams();
/* Set the Vector Table base location at 0x08000000 */
NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0000);
/* If the LCD Panel has a resolution of 320x240 this command is not needed, it's
set by default */
/* Set_LCD_Resolution( 320, 240 ); */
/* Infinite main loop ------------------------------------------------------*/
while (1)
{
/* Catching touch events */
if ( calibration_done )
{
ProcessInputData ();
}
/*Time out calculate for power saving mode*/
TimeOutCalculate();
CursorReadJoystick(POLLING_MODE);
TSC_Read();
}
}
The initialization process is in charge of preparing the basic mechanism of the system. The
clock distribution and the interrupt settings are two components that are strongly dependent
on the target project. An example of clock rate may be 72 MHz as the maximum speed of
the current STM32 microcontroller. It can be decreased to reduce the power consumption.
Special attention should be paid to the SysTick counter and its related delay routine which
generates a variable time latency in multiples of 10 ms. The clock rate assumptions are:
●System HCLK - 72 MHz
●Low speed peripheral PCLK1 - 36 MHz
●High speed peripheral PCLK2 - 72 MHz
The interrupt setting situation is very similar to clock distribution. The library functions
involved with interrupt managing do not take care of the priorities, they only perform very
Doc ID 16918 Rev 595/105
Getting started with the systemAN3128
necessary and absolutely common settings to make them serviceable. The developer who
designs the final project and who decides to include the graphic library must consider the
relation between all the possible interrupts, and consequently must assess the priority
levels. Default characters of the interrupt controller are:
●Vector table base address is set to 0x08000000
●Priority group identifier takes 2 bits.
The goal of this document is not to give an exhaustive description of this issue. The
processor reference manual and the firmware library are comprehensive information
resources where lots of examples can be found as the clock distribution is an integral task of
every application.
96/105Doc ID 16918 Rev 5
AN3128Embedded GUI resource editor application
6 Embedded GUI resource editor application
6.1 Introduction
The “Resource Editor for STM32 embedded graphic objects/touchscreen library” is a
software application to leverage the features of the multi-input GUI library developed on the
microcontroller platform.
Traditionally, the generation of touchscreen UIs requires writing a lot of redundant code and
painful mapping of screen coordinates to the interface. In absence of any WYSIWYG tool,
perfecting such an interface requires numerous time consuming iterations. The GUI library
is a part of the embedded UI generation ecosystem. It comprises the embedded GUI library
running on the firmware and the resource editor application running on the PC. The
resource editor GUI provides one common unified user interface to implement all the
interface design functionality, so that it becomes possible to make the changes visually and
generate the C code targeting the embedded GUI library in a few mouse clicks. The user
can include this code in their application and burn on the firmware.
The GUI allows the user to develop their own screens using the controls provided by the
library. The user simply drags and drops the controls from the tool box and changes the
control properties as required. After finishing the layout, the user is able to generate the
source code (header and c file) which can be integrated into the firmware application.
Figure 17. Creating a GUI application
Doc ID 16918 Rev 597/105
Embedded GUI resource editor applicationAN3128
6.2 Resource editor application: quick start
Follow these simple steps for getting the first project run.
Click on New-->New Project to start the new project.
Figure 18. Creating a new GUI project
This opens the save dialog in which you must choose the path and the name of the project.
Figure 19. Choosing the project file location
This opens the resolution settings window, which asks for the resolution of the screen.
Figure 20. Set the screen resolution
98/105Doc ID 16918 Rev 5
AN3128Embedded GUI resource editor application
This opens the screen name window, which asks for the name of the screen.
Figure 21. Set the screen name
The project is started now, select the control from the tool box and drag and drop it into the
screen opened.
Figure 22. Screen workspace
You can create the any number of controls and change their properties in the property
window.
Figure 23. Screen properties
You can add more screens by selecting the New-->New Screen button on the menu bar.
Doc ID 16918 Rev 599/105
Embedded GUI resource editor applicationAN3128
Figure 24. Creating a new screen
The Project Explorer window shows all the screens in the project.
Figure 25. Screens list
Finally, build the project by clicking on “Generate Code” to generate the code. Build
operation automatically saves the project.
Figure 26. Building the project source code
The generate files are located at “project path\project name\output”.
100/105Doc ID 16918 Rev 5
Loading...
+ hidden pages
You need points to download manuals.
1 point = 1 manual.
You can buy points or you can get point for every manual you upload.