EVE Projects

EVE is Bridgetek’s series of Human Machine Interface (HMI) controller ICs. This page provides examples on how to create static and animated displays, control touch features of the TFT panel and playback audio.

For a breakdown of supported features across EVE series please see the following page: https://brtchip.com/eve/

AN_391 EVE Platform Guide explains which platforms and EVE chipsets are supported by the examples below.

New-buttonEVE Sample Applications

The EVE Sample Applications (EveApps) based upon EVE Series ICs (FT80X, FT81X, BT81X) are a superset of design examples, demonstrations, and usages of the EVE command set (pseudo language) developed to assist in designers’ learning curve as well as providing a starting point for projects. The Sample Applications code is intended for usage with either FTDI’s MPSSE bridge cable which provides a USB to SPI Bridge. With this cable the designer can interface between a PC and the development module to experiment, develop, and validate their project. The Sample Applications can also be used with the FT9xx (link) series of MCUs from Bridgetek. An example Hardware Abstraction Layer is supplied to simplify sending the functional codes to the FT8xx/BT81x to create basic shapes, manipulate bitmaps, control a TFT touch panel and playback audio.

Download the project and source code here

The download contains 26 demo applications and 1 sample application (SampleApp). These are written in ANSI C code and full source code is provided for each application. The Demo applications are for demonstration purposes and are fairly complex, intending to be as close to real-life project as possible.  The Sample application is for tutorial purposes, and is intended to be much simpler and easier to understand for each display list generated or command executed.

    • SampleApp – Main Sample application for tutorial purposes
    • DemoCircleArea – Points and Blend functions are used in conjunction with Bitmaps for an Image viewer.
    • DemoEvChargePoint – An electric charging station control screen is created.
    • DemoGauges  – Lines & custom font functions are used to create an interactive gauge application.
    • DemoGradient – In this demo, String, Gradient and Slider app functions are used to demonstrate an interactive gradient.
    • DemoGraph – A scrollable graph is drawn using an edge strip.
    • DemoHDPictureViewer – Adaptive Scalable Texture Compression (ASTC) images are utilised from flash memory to view a single HD image.
    • DemoImageViewer – Blend function, Bitmap flip and JPEG decode functions are used to demonstrate interactive JPEG decode.
    • DemoImageViewer2 – Adaptive Scalable Texture Compression (ASTC) images are utilised from flash memory to create an image viewer application.
    • DemoInstrument – A frequency spectrogram is drawn using bitmap manipulation in RAM_G.
    • DemoJackpot – This application is a custom version of a Slot Machine game and it demonstrates the usage of built-in FT/BT8xx widgets and primitives, manipulating bitmaps and playing audio.
    • DemoKeyboard – In this demo, String, Keys & Button functions are used to demonstrate an interactive keyboard.
    • DemoLift – This application demonstrates a lift simulation drawn using bitmaps for fonts, arrows, date and time    display and audio in sync with the change in floor number.
    • DemoLift2 – This application demonstrates a lift simulation with Video Playback utilised to create the background of the control panel.
    • DemoMainMenu – JPEG decode, Rectangle & Points are used to demonstrate creating interactive menus.
    • DemoMetaballs – Points & Bitmaps are used to demonstrate interactive random metaballs.
    • DemoMeterDemo – Bitmaps & Stencil techniques are used to create an interactive knob and meter.
    • DemoRefrigeratior –This application demonstrates a Smart Refrigerator application using inbuilt fonts, stencil operation and the scissor command implemented on the EVE platform.
    • DemoRotaryDial – Points, Track & Stencil functions are used to demonstrate an interactive rotary dial.
    • DemoRunningBar – Paletted Bitmaps & Blend functions are used to simulate a street light moving.
    • DemoSignals – Strips, Points & Blend functions are used to demonstrate drawing signal waveforms.
    • DemoSignature – Sketch, Bitmap rotation & Buttons functions are used to demonstrate an interactive signature.
    • DemoUnicode – Unicode fonts are used from flash to create English, Chinese, Japanese and Hindi Keyboards.
    • DemoUnicodeRuntime – Unicode fonts are utilised with the character set displayed being determined at runtime.
    • DemoWashingMachine – Bitmaps, Bitmap Animation & Audio playback are used to create a Washing machine UI.

AN 245 VM800CB SampleApp PC Introduction
AN 246 VM800CB SampleApp Arduino Introduction
AN 381 ME810A HV35R Sample Application
AN 418 ME81XAU SampleApp PC Introduction

New-buttonMCU Specific Examples

These examples are part of a series of application notes covering how to develop your own EVE library. They cover a range of topics including:

  • Understanding the low-level SPI transfers used by EVE
  • Creating a layered library framework allowing your main application to use commands from the Programmers Guide
  • Examples of using the framework for common tasks and useful code snippets

They include code projects for a range of different MCUs allowing you to get up and running quickly with your current or preferred MCU. They can also be ported to other platforms.

When using the code from this page, it is recommended to use BRT_AN_025 when developing an application for your MCU and to refer to the other documents/examples in this section for background information on how its framework operates at lower levels all the way down to the SPI transfers.

BRT_AN_025 – Portable EVE Library

This portable EVE framework includes a sample application and EVE framework for the following MCUs. It can also be ported to other MCUs and toolchains

  • Bridgetek FT900
  • ST Micro STM32
  • Microchip PIC18F
  • TI MSP430
  • Espressif ESP32
  • Raspberry Pi
  • BeagleBone

The code can be used as the basis for developing the EVE library for your MCU. It is based upon the earlier BRT_AN_008 example but has been optimised for portability to other MCUs.

Note: The code currently supports FT81x and FT80x and is being updated to support BT81x.

Download the BRT_AN_025 Application Note and BRT_AN_025 source code

A porting guide BRT_AN_062 is also available showing how to port the code from BRT_AN_025 to other platforms, in this case using the NXP Freedom K64 board as an example.

Download the BRT_AN_062 Application Note and BRT_AN_062 source code

BRT_AN_008 – Creating a Simple EVE Library for a PIC MCU

Application note BRT_AN_008 explains how to create a library for EVE on your MCU, using the PIC18F device as an example. It uses various code layers to provide an intuitive framework so that the main application can use high-level commands from the EVE Programmers Guide whilst the lowest layers translate these to the byte level transfers for the MCU’s SPI Master Interface. The code supports the FT80x and FT81x series.

Download the BRT_AN_008 Application Note and BRT_AN_008 source code

Application note BRT_AN_014 uses the same framework as BRT_AN_008 and includes additional examples in the main application for common tasks such as loading bitmaps and compressed images, fonts, optimising screen updates and taking screenshots.

Download the BRT_AN_014 Application Note and BRT_AN_014 source code

Application note BRT_AN_042 explains two techniques which allow special characters within text. Many applications will require symbols for currency and scientific notation or characters to allow the use of different languages.  These examples show how the characters can be used as part of text strings. The examples use the same framework as BRT_AN_008 but the same techniques can be used in other libraries.

Download the BRT_AN_042 Application Note and BRT_AN_042 source code

BRT_AN_006 – Understanding low-level EVE API and SPI Transfers

These applications notes are primarily for reference as the other application notes later in the series (BRT_AN_008 and BRT_AN_025) now have a more comprehensive framework on which to base the main application.

Application note BRT_AN_006 shows how the SPI transfers work down to bit level and how the data is formatted into the API used by the EVE device itself. This low-level framework is used as the basis for BRT_AN_008. Although written specifically for PIC, the same data transfers and formatting can be used on other MCUs.

Download the BRT_AN_006 Application Note and BRT_AN_006 source code

Application note BRT_AN_007 extends the principles shown in BRT_AN_006 to demonstrate how these low level transfers can be used for various widgets and common operations such as text, bitmaps and touch controls.

Download the BRT_AN_007 Application Note and BRT_AN_007 source code

Application Notes

These application notes demonstrate techniques and provide useful information for developing applications across all EVE series ICs.

Optimising Screen Updates with Macro and Append

This simple example demonstrates the power of EVE’s internal functions for memory management by simplifying display list creation using macros and an append function which may be used to reduce the amount of SPI traffic and hence speed up screen edits when only small sections of the display change e.g. keeping a static background while updating objects in the foreground.

For further reading and explanation of the code please refer to AN 340.
Download the project source code here.

FT90x Camera to EVE

Application note BRT_AN_018 describes a display showing video obtained from a camera module with an FT90x device and an FT81x. The display also shows a graphical overlay for the camera output to resemble a car reversing camera. There is no need to connect the device to a host computer, apart from programming the FT90x, as the application runs standalone. The camera is attached to the FT90x device. The FT8xx device controls the TFT display.

Click here to download the associated source code that supports BRT_AN_018.

Selecting an LCD Display

Adding support for alternative capacitive touch controllers.

The EVE chipset is an ideal HMI solution offering display, touch and audio functionality. Whilst resistive touch control is relatively standard with a simple 4 –wire connection, the support for capacitive touch is more complex. Capacitive touch is generally handled over I2C with communication to a dedicated Capacitive Touch Panel Module (CTPM) integrated into the display module. To increase the range of CTPM’s the FT801, FT811, FT813 , BT815 and BT817 devices can support, a new library and additional initialisation routines for the EVE chipset have been developed. This extends our Azotec and Focaltec support whilst also adding in support for new devices such as those from Goodix.

Further information on selecting a compatible display or implementing additional support for these additional CTPM’s may be found at

The supporting libraries may be downloaded here.

To accommodate the extra memory and commands the memory map between EVE2 and EVE is slightly different resulting in slightly different application code. EVE3 and EVE4s memory map is backwards compatible with EVE2.

More details on migrating designs from FT80x to FT81x chipset may be found in AN_390 FT80x Migration Guide.

Other Examples

These examples were developed for the FT80x series of EVE controllers, but similar techniques can be utilised with newer EVE series controllers such as the FT81x and the BT81x.

FT801 Specific Example – FT Graph (also supports EVE2)

This example demonstrates zoom-in and zoom-out functionality using the FT801 with multi-touch capability. The application constructs a power graph on the screen. Based on user touch movement, either-zoom in or zoom-out is performed. This application demonstrates the use of two simultaneous touch inputs from the user.
Download the project and source code here

FT801 Specific Example – FT Polygon

In this example, the multi-touch functionality of the FT801 chip is demonstrated by drawing a polygon on the screen, where the corners are defined by the points on the screen touched by the user.
The polygon created is used to lighten the selected area of a bitmap image.
Download the project and source code here

Simplified Freescale Application (FT80x)

In this example, a simplified version of the Hardware Abstraction Layer (HAL) is generated to demonstrate targeted code generation for a Freescale MC9S08QE8 microcontroller, using the CodeWarrior development suite.
The example demonstrates how to configure the microcontroller SPI port to match the FT800 settings, then perform read and writes over SPI to wake and configure the FT800 such that it will draw a simple display. The source code is provided with the executable to enable users to customise the code and develop their own applications.

For further reading and explanation of the code please refer to AN_259

Download the project and source code here.

Simplified I2C Freescale Application (FT80x)

In this example, a simplified version of the Hardware Abstraction Layer (HAL) is generated to demonstrate targeted code generation for a Freescale MC9S08QE8 microcontroller, using the CodeWarrior development suite.
The example demonstrates how to configure the microcontroller I2C port to match the FT800 settings, then perform read and writes over I2C to wake and configure the FT800 such that it will draw a simple display. The source code is provided with the executable to enable users to customise the code and develop their own applications.
For further reading and explanation of the code please refer to AN 308
Download the project and source code here.

Simplified Arduino Application (FT80x)

In this example, a simplified version of the Hardware Abstraction Layer (HAL) is generated to demonstrate targeted code generation for an ATMEGA 328P, using the Arduino tools and an Arduino PRO board.

The example demonstrates how to configure the microcontroller SPI port to match the FT800 settings, then perform read and writes over SPI to wake and configure the FT800 such that it will draw a simple display. The source code is provided with the executable to enable users to customise the code and develop their own applications.

For further reading and explanation of the code please refer to AN275.

Download the project source code here.

Simplified Arduino I2C Application (FT80x)

In this example, a simplified version of the Hardware Abstraction Layer (HAL) is generated to demonstrate targeted code generation for an ATMEGA 328P, using the Arduino tools and an Arduino PRO board.
The example demonstrates how to configure the microcontroller I2C port to match the FT800 settings, then perform read and writes over I2C to wake and configure the FT800 such that it will draw a simple display. The source code is provided with the executable to enable users to customise the code and develop their own applications.
For further reading and explanation of the code please refer to AN296.
Download the project source code here.

Arduino Specific Libraries (FT80x)

This download contains a suite of libraries and examples specific to the Arduino controller. Syntax is compatible with common Arduino programmes. The Arduino Specific library for the FT800 can be accessed here. The library for the FT801 is available here.

AN 318 Arduino Library for FT800 Series can be downloaded to act as a guide for programmers to develop GUI applications using the FT800 series graphics controller with Arduino development boards via SPI.

Simplified ARM Application (FT80x)

In this example, a simplified version of the Hardware Abstraction Layer (HAL) is generated to demonstrate targeted code generation for STM32F407 ARM based processor, using the Keil tools, a STM32CubeMX development environment and an STM32F4-Discovery board.
The example demonstrates how to configure the microcontroller SPI port to match the FT800 settings, then perform read and writes over SPI to wake and configure the FT800 such that it will draw a simple display. The source code is provided with the executable to enable users to customise the code and develop their own applications.
For further reading and explanation of the code please refer to AN312.
Download the project source code here.

Simplified PIC Application (FT80x)

This simple example utilises a Microchip PIC16F886 device on a PICkit 28 pin demo board with the standard MPLAB X IDE V.195 to initialise the FT800. Different displays are then created using the graphics processor commands, and low-level SPI function calls are created to provide convenient methods of sending and receiving data to the FT800.
For further reading and explanation of the code please refer to AN320.
Download the project source code here.

**NOTE: If testing this project with an Arduino platform, connecting a real time clock over I2C is also required.
***NOTE: If testing these projects on an Arduino platform, an SD Card with the files from the project, TEST folder must be connected. Pinout to your SD Card can be reconfigured in platform.

VM800P RS232 Application

This example demonstrates how the VM800P ‘Plus’ module may be used to access a wider system via the expansion card socket. For this demonstration, two VM800P devices were used, each fitted with a VI800A-232U RS232 daughter card and connected back to back over RS232. Images were stored on an SD card and transferred from one VM800P to the other and displayed on the screen, demonstrating the use of a RS232 interface to control/deliver data as requested from touch input on the VM800P display.

Application notes describing the demonstration and techniques used are available as AN 367 and AN 368.
Download the project source code here.

FT800 Sensor Reading and Display Application

This example demonstrates how the VM800P ‘Plus’ module may be used to read sensor data via the Arduino controller I2C port and display the data both in terms of digital numbers and in a graphical form with scaling applied to the graph. This particular demonstration is measuring voltage and current supplied to a USB peripheral, but the concepts demonstrated could easily be applied to other sensor applications such as temperature, heart rate, or fluid/gas flow rates.

An application note describing the demonstration and techniques used are available in AN 356.
Download the project source code here.

JPEG Viewer (FT80x)

Source code supporting AN 339 may be downloaded here to demonstrate validating JPEG compatibility with the FT800 series and how to display the images on an FT800 series device.