Overview of Azure RTOS GUIX and Azure RTOS GUIX Studio
Azure GUIX embedded GUI is Microsoft’s advanced, industrial grade GUI solution designed specifically for deeply embedded, real-time, and IoT applications. Microsoft also provides a full-featured WYSIWYG desktop design tool named Azure RTOS GUIX Studio, which allows developers to design their GUI on the desktop and generate Azure RTOS GUIX embedded GUI code that can then be exported to the target. Azure RTOS GUIX is fully integrated with Azure RTOS ThreadX RTOS and is available for many of the same processors supported by Azure RTOS ThreadX. All of this combined with an extremely small footprint, fast execution, and superior ease-of-use, make Azure RTOS GUIX the ideal choice for the most demanding embedded IoT applications requiring a user interface.
Azure RTOS GUIX API
Intuitive and consistent API
Noun-verb naming convention
All APIs have leading gx_ to easily identify as Azure RTOS GUIX
Event-driven programming model (API)
Full support for direct canvas drawing when needed
Simple to interact with Azure RTOS GUIX Studio generated code
APIs for line, rectangle, polygon, etc.
APIs for circle, arc, pie, chord, ellipse, etc.
APIs for text drawing and positioning
Anti-aliasing, texture fills, and solid fills
APIs for creating and modifing screens and widgets
Azure RTOS GUIX Studio Generated Files
Automatically generated ANSI C source files
Insulates application software from layout details
Includes fonts and images required by UI design
Generated files compiled with application code
Screen layout can be updated without affecting application logic
Resource IDs create language and theme independence
User-supplied custom drawing and event processing functions
Widget library
Pre-defined but customizable set of common interface elements
Extremely small, compact, and efficient
Library includes button, gauge, list, window, scroll, slider, progress bar, prompt and many more
Fully customizable drawing and appearance
Fully customizable operation and event handling
Only the widgets used are linked with application software
Math and utilities
Functions for sin, cos, arcsin, arccos, tangent, square root
Functions for manipulating screen regions
System configuration and startup
Memory pool definition (optional)
Timer Management
Animation Management
Dirty list maintenance
Image processing
Functions for runtime decode of jpeg and png images
Apply dithering and color space conversion
Image rotation
Image scaling
Image blending
Event processing
Automatically suspends Azure RTOS GUIX thread when idle
Event-driven programming model popular in UI design
Insulates input drivers from Azure RTOS GUIX drawing thread
Functions for sending and receiving events
Pre-defined event types for all Azure RTOS GUIX widget types
User-defined custom events supported
Canvas processing
Clipping and Z-Order maintenance
Insulates widget library from hardware details
Insulates application from hardware details
Automatic background refresh of dirty areas
Multiple canvases with layering and blending supported
Can be invoked directly by the application software
Input device driver(s)
Hardware-specific support, Azure RTOS GUIX and application insulated from hardware details
Resistive Touch, Cap Touch, and keypad supported
Input events passed to Azure RTOS GUIX event queue
Display drivers
Hardware-specific support
Generic drivers provided for all color depth and formats
Customized to utilize available graphics accelerators
Target hardware
Nearly any hardware capable of graphical output Is compatible with GUIX
Multiple physical displays supported
Minimal RAM and Flash requirements
Create Elegant User Interfaces
Azure RTOS GUIX and Azure RTOS GUIX Studio provide all the features necessary to create uniquely elegant user interfaces. The standard Azure RTOS GUIX package includes various sample user interfaces, including a medical device reference, a smart watch reference, a home automation reference, an industrial control reference, an automotive reference, and various sprite and animation examples. Please click on the reference examples shown below.
Home Automation
Medical
Consumer
White Goods
Automotive
Industrial
Each Azure RTOS GUIX reference has a corresponding Azure RTOS GUIX Studio project that defines all the graphical elements of the reference design. Changing a reference design is easy. Simply open the corresponding Azure RTOS GUIX project, make the desired changes, save the project, and then select Project.
Generate All Output Files to generate the C code for Azure RTOS GUIX. Then simply rebuild the target application and run to observe the modified reference design.
Small-footprint
Azure RTOS GUIX has a remarkably small minimal footprint of 13.2KB of FLASH and 4KB RAM for basic support, not including the memory required for a canvas.
For a display with internal GRAM and self-refresh technology, no canvas memory is required. However, to improve drawing performance, or for a display configuration that does not utilize GRAM local to the display, a canvas memory area is defined by the application.
Canvas memory requirements are a function of the canvas size as well as the color depth, and are defined by the formula:
Canvas RAM (bytes) = (x * y * (bpp/8))
Where “x” and “y” are the dimensions of the canvas (display).
Most applications also utilize graphical resources, which are not included in the core Azure RTOS GUIX library storage requirements. These resources include fonts, graphical icons (pixelmaps), and static strings. This data can be stored in the const memory section (i.e. FLASH).
The size of this memory area is dependent on a number of factors, including the number and size of unique fonts used, the number and size of the graphical icons used, the output color format, and whether or not each resource is using compressed data, since Azure RTOS GUIX supports RLE compression of both font and pixelmap data. The storage requirements for each resource are displayed within the Azure RTOS GUIX Studio application, allowing the user to track and monitor the amount of flash memory that will be consumed by the application resources.
Like Azure RTOS ThreadX, the size of Azure RTOS GUIX automatically scales based on the services actually used by the application. This virtually eliminates the need for complicated configuration and build parameters, making things easier for the developer.
Fast execution
Azure RTOS GUIX is written exclusively in C and is designed for speed. Azure RTOS GUIX has minimal internal function call layering.
In addition, Azure RTOS GUIX provides optimized clipping, drawing, and event handling. All of this and a general performance-oriented design philosophy help Azure RTOS GUIX achieve the fastest possible performance.
Pre-certified by TUV to many safety standards
Azure RTOS GUIX has been certified by SGS-TUV Saar for use in safety-critical systems, according to IEC-61508 SIL 4, IEC-62304 SW Safety Class C, ISO 26262 ASIL D and EN 50128. The certification confirms that Azure RTOS GUIX can be used in the development of safety-related software for the highest safety integrity levels of IEC-61508, IEC-62304, ISO 26262 and EN 50128 for the “Functional Safety of electrical, electronic, and programmable electronic safety-related systems.” SGS-TUV Saar, formed through a joint venture of Germany’s SGS-Group and TUV Saarland, has become the leading accredited, independent company for testing, auditing, verifying and certifying embedded software for safety-related systems worldwide. The industrial safety standard IEC 61508, and all standards that are derived from it, including IEC-62304, ISO 26262 and EN 50128, are used to assure the functional safety of electrical, electronic, and programmable electronic safety-related medical devices, process control systems, industrial machinery, automobiles and railway control systems.
Simple, easy-to-use
Azure RTOS GUIX is very simple to use and Azure RTOS GUIX Studio makes it even easier by allowing developers to visually design on the desktop and generate C code that runs on the actual target. Applications can then add their own custom event handling and drawing functions to complete their GUI.
Using the Azure RTOS GUIX API is straightforward. The Azure RTOS GUIX API is both intuitive and highly functional. The API names are made of real words and not the “alphabet soup” and/or the highly abbreviated names that are so common in other file system products. All Azure RTOS GUIX APIs have a leading gx_ and follow a noun-verb naming convention. Furthermore, there is a functional consistency throughout the API. For example, all APIs that initialize a widget control block are named < widget_type>_create, and the create function parameters for each widget type are always defined in the same order.
Comprehensive set of built-in widgets
Azure RTOS GUIX provides a rich set of built-in widgets, including:
Accordion Menu
Button
Checkbox
Circular Gauge
Drop Down List
Horizontal List
Horizontal Scrollbar Window
Icon
Icon Button
Line Chart
Menu
Multi Line Text Button
Multi Line Text Input
Multi Line Text View
Numeric Pixelmap Prompt
Numeric Prompt
Numeric Scroll Wheel
Pixelmap Button
Pixelmap Prompt
Pixelmap Slider
Pixelmap Sprite
Progress Bar
Prompt
Radial Progress Bar
Radio Button
Scroll Wheel
Single Line Text Input
Slider
String Scroll Wheel
Text Button
Tree View
Vertical List
Vertical Scrollbar
It’s easy for the application to create its own customer widgets as well.
Complete low-level drawing API
Azure RTOS GUIX provides a robust canvas drawing API, allowing the application to render complex graphical shapes.
All functions support anti-aliasing on high color depth targets, and all shapes can be filled our outlined, including solid and pixelmap pattern fills. All drawing primitives support brush alpha when running at 16 bpp and higher color depth. Drawing functions include:
Arc Draw
Circle Draw
Line Draw
Pie Draw
Pixelmap Blend
Pixelmap Tile
Polygon Draw
Text Draw
Chord Draw
Ellipse Draw
Pixel Draw
Pixelmap Draw
Pixelmap Rotate
Rectangle Draw
Text Blend
Default free fonts and easy to add more
Azure RTOS GUIX provides a free set of TrueType fonts. Developers can add additional TrueType fonts as desired.
The Azure RTOS GUIX font format supports 8bpp anti-aliasing, 4bpp anti-aliasing, and 1bpp monochrome fonts. For the most resource-constrained applications, Azure RTOS GUIX pre-renders the TrueType fonts to a compressed bitmap format using our GUIX Studio desktop tool.
Custom JPG and PNG decoder implementation
Custom JPG and PNG decoder implementation JPG and PNG file decoder implementation. This implementation supports color space conversion, dithering, and runtime creation of Azure RTOS GUIX-compatible pixelmap format images.
Extensive display and touchscreen support
Azure RTOS GUIX provides generic display drivers for nearly all color formats, including 1bpp monochrome, 8 bpp palette, 8 bpp 3:3:2 format,
16 bpp 565 rgb format, 16 bpp 4:4:4:4 format, 32 bpp x:r:g:b format, and 32 bpp a:r:g:b format. In addition, Azure RTOS GUIX is integrated with many of the most popular LCD controllers and hardware accelerators (ST ChromeArt, Renesas Synergy, etc.).
Azure RTOS GUIX fully supports touchscreen (including gesture support), pen, and virtual keyboard input devices.
Azure RTOS GUIX Studio desktop WYSIWYG tool
Azure RTOS GUIX Studio provides a complete WYSIWYG screen design environment which allows the user to drag-and-drop graphical elements used to build the GUI screens. Azure RTOS GUIX Studio automatically generates C code compatible with the Azure RTOS GUIX library, ready to be compiled and run on the target. Developers can produce pre-rendered fonts for use within an application using the integrated Azure RTOS GUIX Studio font generation tool. Fonts can be generated in monochrome or anti-aliased formats, and are optimized to save space on the target. Fonts can include any set of characters, including Unicode characters for multi-lingual applications.
Azure RTOS GUIX Studio facilitates the import of graphics from PNG or JPG files with conversion to compressed Azure RTOS GUIX Pixelmaps for use on the target system. Many of the Azure RTOS GUIX widget types are designed to incorporate user graphics for a custom look and feel. In addition, Azure RTOS GUIX Studio allows customization of the default colors and drawing styles used by the Azure RTOS GUIX widgets, allowing developers to tune the appearance of Azure RTOS GUIX very easily. Generation and maintenance of application strings is another built-in facility of Azure RTOS GUIX Studio. This enables developers to design an application using one language for developing, and quickly and easily add support for additional languages after the product is released. A complete Azure RTOS GUIX application can be executed on a PC desktop within the Azure RTOS GUIX Studio environment, allowing a quick and easy generation and demonstration of GUI concepts, testing of screen flows, and observation of screen transitions and animations. When completed, a design can be exported as target-ready C data structures, ready to be compiled and linked with the Azure RTOS GUIX and Azure RTOS ThreadX libraries.
Azure RTOS GUIX and Azure RTOS GUIX Studio support multiple resource themes, allowing an application to be easily reskinned at run-time. Fonts, colors, and pixelmaps can be changed at run-time with one simple API.
Learn more about GUIX Studio
Complete Win32 simulation
Azure RTOS GUIX runs on a Windows PC, using exactly the same drawing library that runs on the target board. With Azure RTOS GUIX, you can build and run a GUI application on the PC, and use the same application code on your target for debugging, rapid prototyping, demonstration, and WYSIWYG target operation.
Advanced technology
Azure RTOS GUIX's advanced technology incorporates:
Alpha blending
Anti-Aliasing
Automatic scaling
Bitmap compression
Canvas blending
Custom widget support
Deferred drawing support
Dithering support
Endian neutral programming
Hardware accelerator support
Multilingual support and UTF-8 encoding
Multiple display and canvas support
Optimized clipping, drawing, and event handling
Runtime JPEG and PNG decoder
Skinning and Themes
Supports monochrome through 32-bit true-color with alpha graphics formats
Transitions, Sprites, and Animation support
Win32 simulation
Window management including Viewports and Z-order maintenance
Fastest time-to-market
Azure RTOS GUIX is easy to install, learn, use, debug, verify, certify and maintain. Azure RTOS GUIX Studio also helps making embedded GUI design and implementation easier. As a result, Azure RTOS GUIX is one of the most popular GUI solutions for embedded IoT devices. Our consistent time-to-market advantage is built on:
Quality Documentation – please review our Azure RTOS GUIX User Guide and see for yourself!
Complete Source Code Availability
Easy-to-use API
Comprehensive and Advanced Feature Set
One Simple License
There is no cost to use and test the source code and no cost for production licenses when deployed to pre-licensed devices, all other devices need a simple annual license.
Full, highest-quality source code
Throughout the years, Azure RTOS NetX source code has set the bar in quality and ease of understanding. In addition, the convention of having one function per file provides for easy source navigation.
Supports most popular architectures
Azure RTOS GUIX runs on most popular 32/64-bit microprocessors, out-of-the-box, fully tested and fully supported, including the following:
Advanced Architectures:
Analog Devices: SHARC, Blackfin, CM4xx
Andes Core: RISC-V
Ambiqmicro: Apollo MCUs
ARM: ARM7, ARM9, ARM11, Cortex-M0/M3/M4/M7/A15/A5/A7/A8/A9/A5x 64-bi/A7x 64-bit/R4/R5, TrustZone ARMv8-M
Cadence: Xtensa, Diamond
CEVA: PSoC, PSoC 4, PSoC 5, PSoC 6, FM0+, FM3, MF4, WICED WiFi
Cypress: RISC-V
EnSilica: eSi-RISC
Infineon: XMC1000, XMC4000, TriCore
Intel; Intel FPGA: x36/Pentium, XScale, NIOS II, Cyclone, Arria 10
Microchip: AVR32, ARM7, ARM9, Cortex-M3/M4/M7, SAM3/4/7/9/A/C/D/E/G/L/SV, PIC24/PIC32
Microsemi: RISC-V
NXP: LPC, ARM7, ARM9, PowerPC, 68K, i.MX, ColdFire, Kinetis Cortex-M3/M4
Renesas: SH, HS, V850, RX, RZ, Synergy
Silicon Labs: EFM32
Synopsys: ARC 600, 700, ARC EM, ARC HS
ST: STM32, ARM7, ARM9, Cortex-M3/M4/M7
Tl: C5xxx, C6xxx, Stellaris, Sitara, Tiva-C
Wave Computing: MIPS32 4K, 24K, 34K, 1004K, MIPS64 5K, microAptiv, interAptiv, proAptiv, M-Class
Xilinx: MicroBlaze, PowerPC 405, ZYNQ, ZYNQ UltraSCALE