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.

EVE2 extends the functionality of the first generation devices (FT80x) with features such as increased pixel count (800 x 600), additional on-chip object memory (G_RAM now 1MByte) and new commands and registers such as CMD_SETROTATE.

To accommodate the extra memory and commands the memory map between EVE2 and EVE is slightly different resulting in slightly different application code.

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

Projects with (+EVE2) next to the name will also support FT81x series devices via Bridgetek’s MPSSE USB to SPI bridge or the FT90x series of microcontrollers. 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. 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 – In this demo Points and Blend functions are used in conjunction with Bitmaps for an Image viewer.
  • DemoEvChargePoint – In this demo an electric charging station control screen is created.
  • DemoGauges  –  In this demo, 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 – In this demo, a scrollable graph is drawn using an edge strip.
  • DemoHDPictureViewer – In this demo Adaptive Scalable Texture Compression (ASTC) images are utilised from flash memory to view a single HD image.
  • DemoImageViewer – In this demo, Blend function, Bitmap flip and JPEG decode functions are used to demonstrate interactive JPEG decode.
  • DemoImageViewer2 – In this demo Adaptive Scalable Texture Compression (ASTC) images are utilised from flash memory to create an image viewer application.
  • DemoInstrument – In this demo 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 -In this demo, JPEG decode, Rectangle & Points are used to demonstrate creating interactive menus.
  • DemoMetaballs – In this demo, Points & Bitmaps are used to demonstrate interactive random metaballs.
  • DemoMeterDemo – In this demo, 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 – In this demo, Points, Track & Stencil functions are used to demonstrate an interactive rotary dial.
  • DemoRunningBar – In this demo, Paletted Bitmaps & Blend functions are used to simulate a street light moving.
  • DemoSignals -In this demo, Strips, Points & Blend functions are used to demonstrate drawing signal waveforms.
  • DemoSignature –In this demo, Sketch, Bitmap rotation & Buttons functions are used to demonstrate an interactive signature.
  • DemoUnicode – In this demo, Unicode fonts are used from flash to create English, Chinese, Japanese and Hindi Keyboards.
  • DemoUnicodeRuntime – In this demo, Unicode fonts are utilised with the character set displayed being determined at runtime.
  • DemoWashingMachine – In this demo, 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

 FT801 Specific Example – FT Graph

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

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 

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

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 

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 

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 

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

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.

FT81x Simple PIC Application

This application note provides an example of creating a simple screen on the FT81x device using the PIC MCU. It explains the low level SPI communication and provides a basic framework for sending EVE commands. Although written specifically for PIC the material could be extended to form a full application on a variety of different MCU types.

Further details are provided in BRT AN 006
Download the project source code here

To compliment the basic instructions in BRT AN 006 an extended project was created to demonstrate how additional features may be added in the Application Layer to demonstrate usage of various FT81x features such as text, bitmaps and touch controls.

Further details are provided in BRT AN 007
Download the project source code here

FT81X examples using the Microchip PIC microcontroller as the SPI master.

Examples in this section build on the libraries and experience built up from other application notes in the series such as BRT_AN_006, BRT_AN_007, BRT_AN_008 and is supported by new application note BRT_AN_014

The examples show how to make use of the library which was created in BRT_AN_008 and have been developed to support a Microchip PIC.

The source code may be downloaded here

The new application note BRT_AN_014 may be downloaded here

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.

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 

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.

New-buttonCreating a Simple EVE library for a PIC MCU

Application note BRT AN 008  builds on techniques discussed in other PIC projects on this site and provides an example of how a developer can create a hardware abstraction layer in the form of libraries that make coding a final application simpler. The libraries could subsequently be used in multiple projects where only the main application has to change.
The target in this example is a relatively simple PIC micro, but the techniques could be applied to any MCU.

Click here  to download the associated source code that supports BRT AN 008

New-buttonFT90x Camera to EVE (+EVE2)

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.

New-buttonFT8xx – 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 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 AN 336.

The supporting libraries may be downloaded here.