TouchGFX Technology

alt

TouchGFX is a software framework written in C++ that enables the development of embedded GUIs with high-end graphics on energy efficient hardware. The TouchGFX embedded GUI technology optimizes the utilization of small hardware platforms, such as the ARM Cortex M-range microcontrollers (MCUs), resulting in faster image updates with less MCU load, outperforming competing frameworks.

Optimal Resource Utilization

The core of TouchGFX technology is an advanced algorithm that decodes what is showing on-screen and enables the GUI to only use resources to draw the graphics visible at any given time. In addition, TouchGFX includes rendering algorithms and new advanced drawing mechanisms, giving you:

  • Higher GUI performance and smooth animations at a frame rate of 25 or more.
  • Display-resolutions up to WSVGA: 1024×600.
  • Low MCU load, typically ≤15%.
  • Ultra-low power consumption.

TouchGFX Designer

TouchGFX Designer is created as an intuitive add-on tool to the TouchGFX framework. Its drag and drop approach makes developers and designers able to create a fully functional prototype fast and easy.

The Designer automatically generates high-quality code that can be used in your TouchGFX development.

This gives you an efficient process that undertakes everything from early design sketches and quickly created iterations over finished prototypes to exclusive end-products.

Developer-Friendly Framework

TouchGFX is structured to make your embedded GUI development simple and easily manageable. With automated developer-tools we have created an efficient framework that gives you the perfect platform for developing GUI applications in TouchGFX. The developer-friendly framework includes:

  • TouchGFX Designer: Drag & drop GUI builder
  • Object-oriented extendable API.
  • Automated build chains for generating elements, such as bitmaps and fonts.
  • PC simulator for prototyping and easy debugging.
  • Optional built-in scheme for efficient memory allocation.
  • A standardized structure for integrating the GUI with the rest of the system.

Modern GUI features

TouchGFX enables transparency, alpha-blending, anti-aliased fonts and kerning, touch gestures, animations, screen transitions, high-resolutions displays, high frame rates, and much more.

DESIGN FEATURES TECHNICAL FEATURE

Modern GUI Features

TouchGFX enables transparency, alpha-blending, anti-aliased fonts and kerning, touch gestures, animations, screen transitions, high-resolutions displays, high frame rates, and much more.

Model View Presenter

TouchGFX uses the widely acknowledged Model-View-Presenter architecture to structure your application.

Multiple Alphabet/Script Support

TouchGFX supports multiple alphabets and scripts, such as Latin, Cyrillic, Chinese, and Japanese. A converter turns translations into a memory-optimized internal format at compile time.

Static Memory Allocation

The default memory allocation scheme operates on the Model-View-Presenter architecture and uses static memory allocation only.

TrueType Font Converter

An integrated font converter creates internal representation of any TrueType font. TouchGFX uses the font-specific kerning information to adjust character positions.

PC Simulator

A PC-based simulator running on Windows and Linux gives you an easy way to evaluate and analyze your application. You can also do non-target debugging.

Multiple Image Format Support

The integrated image converter will convert 24-bit BMP and PNG images to the internal format. The process supports opaque, transparent, and semitransparent pixels in PNG images.

Multiple Compiler Support:

TouchGFX comes with built-in support for a range of compilers for both the PC simulator and target application builds:
  • Simulator (Windows):
    • TouchGFX command line build environment. Make and GCC compilation.
    • Microsoft Visual Studio.
  • Simulator (Linux 64-bit):
    • Command line. Make and GCC compilation.
  • Target:
    • IAR, Keil and GCC.

High Image Quality

The internal image format is represented in 16 bit color depth and uses advanced dithering algorithms to maximize performance and improve image quality

Examples & Demos:

TouchGFX includes a wide range of ready to compile and run examples and demos for both PC and targets. These applications come with full source code and are the perfect way to familiarize with key concepts of the TouchGFX framework.

Targeted Platforms & Resource Requirements

TouchGFX runs on a multitude of hardware platforms. Depending on exact parameters, such as display resolution, memory latency, and bandwidth, a natural fit is any Cortex-M based platform:

  • Cortex-M0 MCUs at 24-48MHz for 320×240 QVGA displays.
  • Cortex-M3 MCUs at 48-64MHz for 320×240 QVGA displays.
  • Cortex-M3/M4 MCUs at 96-120MHz for 480×272 WQVGA displays.
  • Cortex-M3/M4 MCUs at 120-204MHz for 800×480 WVGA displays.
  • Cortex-M3/M4/M7 MCUs at 180-300MHz for 1024×768 XGA displays.

Read our Hardware Selection Guide here.

TouchGFX works perfectly with systems where the TFT controller is integrated in the MCU with frame buffers in external memory, or on systems that use LCD with integrated frame buffers and controllers. The resource requirements of TouchGFX depends on the size and complexity of the specific application. Below, you see framework usage figures as well as typical requirements for GUI implementations. The lower bounds represent less complex GUIs and the higher bounds represent very complex applications with ~200 screens.

  • Internal RAM:
    • 10-20 KB (framework and stack).
    • 1-15 KB (widgets).
  • Internal ROM:
    • 20 KB (framework).
    • 1-100 KB (screen definitions, GUI logic).
  • External RAM:
    • Memory usage depends on the resolution of the display and the number of framebuffers.
    • Examples:
      • 320×240 QVGA displays with 2 framebuffers = 307 KB.
      • 480×272 WQVGA displays with 2 framebuffers = 522 KB.
      • 800×480 WVGA displays with 2 framebuffers = 1.5 MB.
  • External Flash:
    • Depends on the total size of the graphical elements, typically 1-8 MB.
  • Operating System:
    • OS independent. Can run with or without OS..
    • With an OS, it requires a single task and two semaphores.