st7789 tft display free sample

The ST7789 TFT module contains a display controller with the same name: ST7789. It’s a color display that uses SPI interface protocol and requires 3, 4 or 5 control pins, it’s low cost and easy to use. This display is an IPS display, it comes in different sizes (1.3″, 1.54″ …) but all of them should have the same resolution of 240×240 pixel, this means it has 57600 pixels. This module works with 3.3V only and it doesn’t support 5V (not 5V tolerant).

The ST7789 display module shown in project circuit diagram has 7 pins: (from right to left): GND (ground), VCC, SCL (serial clock), SDA (serial data), RES (reset), DC (or D/C: data/command) and BLK (back light).

As mentioned above, the ST7789 TFT display controller works with 3.3V only (power supply and control lines). The display module is supplied with 3.3V (between VCC and GND) which comes from the Arduino board.

To connect the Arduino to the display module, I used voltage divider for each line which means there are 4 voltage dividers. Each voltage divider consists of 2.2k and 3.3k resistors, this drops the 5V into 3V which is sufficient.

The first library is a driver for the ST7789 TFT display which can be installed from Arduino IDE library manager (Sketch —> Include Library —> Manage Libraries …, in the search box write “st7789” and install the one from Adafruit).

This is a graphics library for the family of small colour TFT displays based on the ST7735 and ST7789 driver chips. These are really nice displays; bright, colourful, available in a variety of useful sizes, and available at low cost from suppliers like Adafruit, AliExpress, or Banggood:

This library allows you to plot points, draw lines, draw filled rectangles, and plot text with an optional scale factor. I"ve included a demo histogram-plotting program that adjusts itself to fit each of the displays I"ve supported.

Unlike most other TFT display libraries this one doesn"t require a memory buffer, allowing it to be run on any processor down to an ATtiny85. The displays are SPI and require four pins to drive the display, leaving one pin free on an ATtiny85 to interface to another device, such as a temperature sensor. If you need more pins choose a larger chip, such as the ATtiny84; see Using the library with other AVR chips at the end of the article for information about how to convert the code for different chips.

I"ve published a library for a colour OLED display in a previous article: Colour Graphics Library. The main difference between the colour TFT displays and the colour OLED displays is that the TFT displays are not self-illuminating, and so need a backlight; they therefore have a slightly higher power consumption. However, they are exceedingly cheap, and they are available in larger sizes than the colour OLED displays.

This library will work with displays based on the ST7735 which supports a maximum display size of 132 (H) x 162 (V), or the similar ST7789 which supports a maximum display size of 240 (H) x 320 (V).

The display driver interfaces to the displays with the longer side as the vertical dimension, which is why the rectangular displays are usually listed with the longer dimension second. My library allows you to rotate the image for any desired orientation.

All the Adafruit breakout boards for these displays include level-shifting circuitry, so they will work with either 5V or 3.3V microcontroller boards. They also include an SD card socket, if that"s of interest to you. The Adafruit boards have pullups on the backlight and reset pins, so the display will work if you leave these pins unconnected.

The pullup resistor from the display"s CS pin is optional; it holds the chip select high to prevent the display from being affected by the ISP signals while programming the ATtiny85.

The different displays are catered for by six constants which specify the size of the display, the offsets relative to the area supported by the display driver, whether the display is inverted, and the rotation value; for example:

Note that on some displays you may also have to change the xoff or yoff value when rotating the display. For example, to rotate the image on the 240x240 displays by 180° use the settings:

To check or adjust the values for each display I ran this program, which draws a one-pixel border around the display area, and plots an "F" to show the orientation:

The ATtiny85 and other AVR processors supports toggling of one or more bits in a port, so provided you set all the pins to their disabled state at startup, for speed the display access routines can simply toggle the appropriate pins to enable or disable them.

The InitDisplay() routine first defines the four display pins as outputs, and takes the SCK, DC, and CS pins high (inactive). It then sends the essential configuration commands to the display.

The display memory stores 18 bits per pixel: 6 bits per colour. However, you can write to the display in three alternative modes, with 12, 16, or 18 bits per pixel. I chose the 16 bit mode, which assigns 5 bits to red, 6 bits to green, and 5 bits blue. It"s the most convenient one to work with as you simply send two bytes to define the colour of each pixel.

To clear the display the ClearDisplay() routine sends the appropriate number of zero bytes. The routine temporarily switches to 12-bit colour mode, which reduces the time to clear the display by 25%:

The library includes basic graphics routines for plotting points and drawing lines. These work on a conventional coordinate system with the origin at lower left. For example, on the 80x160 display:

My first version of PlotChar() plotted characters by calling PlotPoint() for each pixel. However, I then tried the following alternative approach which defines an area of the display using the CASET (Column Address Set) and RASET (Row Address Set) commands, and then sends a stream of the appropriate bytes to define the character. This turned out to be over three times faster!

14th January 2020: Tested the program with the Adafruit 1.3" 240x240 TFT display, and updated the program to correct a problem when rotating the image on that display.

It works with TFT displays available from AliExpress, and I"ve included four examples showing how you can do things that wouldn"t be possible without the ability to read from the display.

You can use an exclusive-OR drawing mode that changes the state of pixels reversibly. Drawing the same thing a second time restores the display to its previous state. This is especially important for dynamic data plotting.

To implement these applications without the ability to read pixels from the display would require you to keep a mirror of the display in RAM, and update the mirror every time you draw to the actual display. This would slow down graphics and require a lot of memory: for example, to mirror a 320x240 colour display would require 153.6Kbytes of RAM. To put this in context, the ATtiny414 used to run these examples only has 256 bytes of RAM.

Unfortunately this feature does not work with Adafruit displays, which is why I didn"t include it in my original Tiny TFT Graphics Library 2. It is, however, compatible with all displays based on the ST7735 and ST7789 driver chips available from vendors such as AliExpress and Banggood. Here"s a list of displays I"ve tested:

Adafruit have a range of great TFT displays, in a wide selection of sizes and resolutions, but unfortunately they are not compatible with this library. The reason is that their displays all include a unidirectional on-board logic-level converter to allow them to be used with either 3.3V or 5V, but this has the downside of preventing them from being able to read back from the display memory.

The solution would be to replace the unidirectional logic-level converter on the MOSI connection to the display driver with a bidirectional one, which would require one N-MOSFET and two resistors. I originally planned to include details of how to modify an Adafruit display to implement this, but I"ve decided against this because the displays are fragile, and the risk of ending up with a non-functional display is too great.

This first uses the display commands CASET and RASET to set the column range and row range to the current point. It then gives the RAM read command, RAMRD.

The sequence to shift the 21 bits into the variable pixel needs to be slightly different depending on whether the display uses the ST7735 or ST7789 driver chip. The two if statements determine this from the width of the display, and toggle the sck pin either before or after reading the mosi pin, as appropriate. It took a bit of experimentation to figure this out.

These examples included with the library demonstrate applications of reading back from the display memory. For convenience I"ve used my Universal TFT Display Backpack to run these examples, but that"s not necessary.

This simple demo takes a triangular section of an existing image on the screen, and reflects it through horizontal, vertical, and diagonal lines to create a symmetrical image, like a kaleidoscope. It works best on square displays; here it is on a 240x240 1.54" display:

To run it first draw an image, and then run Kaleidoscope(). For this example the initial image is the Waterfall() demo, used for the title image in the article Tiny TFT Graphics Library 2:

The stopwatch takes advantage of exclusive-OR plotting to draw and undraw the hand when it moves without corrupting the clock face. It is designed for a 128x128 display:

Anything drawn in red on the display is treated as a barrier, and the ball will bounce off it. Any other colours, such as the white text, are ignored and can be used to create an interesting background.

The final demo draws the BarChart() demo, and it then calls BMPSave() to save it to a BMP-format image file on an SD card. Here"s the BarChart() demo running on a 320x170 display:

Here is the version of the Tiny TFT Graphics Library with the extensions for reading from the display, and the demos described above (excluding BMPSave()): Tiny TFT Graphics Library with Read.

Got one of these displays today and started playing with it. All is working pretty well with this library, thanks for all the effort that"s gone into it! I ran into the flickering everyone gets when updating the whole display and decided to try the sprites, but I haven"t been able to get it working to save my life. Simple working non-sprite example:

This new library is a standalone library that contains the TFT driver as well as the graphics functions and fonts that were in the GFX library. This library has significant performance improvements when used with an UNO (or ATmega328 based Arduino) and MEGA.

Examples are included with the library, including graphics test programs. The example sketch TFT_Rainbow_one shows different ways of using the font support functions. This library now supports the "print" library so the formatting features of the "print" library can be used, for example to print to the TFT in Hexadecimal, for example:

To use the F_AS_T performance option the ILI9341 based display must be connected to an MEGA as follows:MEGA +5V to display pin 1 (VCC) and pin 8 (LED) UNO 0V (GND) to display pin 2 (GND)

TFT_ILI9341 library updated on 1st July 2015 to version 12, this latest version is attached here to step 8:Minor bug when rendering letter "T" in font 4 without background fixed

Since the display uses 4-wire SPI to communicate and has its own pixel-addressable frame buffer, it can be used with every kind of microcontroller. Even a very small one with low memory and few pins available! The 1.9" display has 320x170 16-bit full-color pixels and is an IPS display, so the color looks great up to 80 degrees off-axis in any direction. The TFT driver (ST7789) is very similar to the popular ST7735, and tthe Arduino library supports it well.

The breakout has the TFT display soldered on (it uses a delicate flex-circuit connector) as well as an ultra-low-dropout 3.3V regulator, auto-reset circuitry, and a 3/5V level shifter so you can use it with 3.3V or 5V power and logic. Adafruit also had a little extra space, so they placed a microSD card holder so you can easily load full color bitmaps from a FAT16/FAT32 formatted microSD card. The microSD card is not included.

Of course, we wouldn"t just leave you with a datasheet and a "good luck!" - Adafruit have written a full open-source graphics Arduino library that can draw pixels, lines, rectangles, circles, text, and bitmaps as well as example code. The code is written for Arduino but can be easily ported to your favorite microcontroller! Wiring is easy, we strongly encourage using the hardware SPI pins of your Arduino as software SPI is noticeably slower when dealing with this size display. For Raspberry Pi or other Single Board Computer Python users, there is a user-space Pillow-compatible library. For CircuitPython there"s a displayio driver for native support.

This display breakout also features an 18-pin "EYE SPI" standard FPC connector with flip-top connector. You can use an 18-pin 0.5mm pitch FPC cable to connect to all the GPIO pins, for when you want to skip the soldering.

Please note! This display is designed original for smartwatches and similar, where there"s a glass over the screen. Without something gently holding the screen down, the backlight can eventually peel away from the TFT. (It"s not destructive but it"s unattractive) You can prevent this by, ideally, adding a plastic or glass cover/overlay. If using bare, try dabbing a touch of E6000 or similar craft glue on the thin side edges, or using a thin piece of tape to keep the front TFT attached to the backlight.

Spice up your Arduino project with a beautiful touchscreen display shield with built in microSD card connection. This IPS TFT display is 2.4" diagonal and colorful (18-bit 262,000 different shades)! 240x320 pixels with individual pixel control. As a bonus, this display has a optional capacitive touch panel and resistive touch panel with controller XPT2046 attached by default.

This display shield has a controller built into it with RAM buffering, so that almost no work is done by the microcontroller. You can connect more sensors, buttons and LEDs.

Yes, the original UTFT library does not contain a st7789 driver folder. The UTFT library they (buydisplay.com) provide contains it though. That folder contains the files initlcd.h and setxy.h,

I had tried the Adafruit_7789 library before and had tried some code (from this site: Interfacing Arduino with ST7789 TFT Display - Graphics Test Example )

Several ways exist to display bitmap images, pictures so to say, on a screen attached to an Arduino, ESP8266 or ESP32. In the present project we convert a color picture into a c-array that is either included in a sketch or saved in a file that is called from within a sketch. The screen used is a 1.3 inch, 240*240 pixel TFT display with ST7789 controller and SPI interface. Because the file size of a 240*240 color bitmap is way too large to fit program memory in an Arduino Uno we are using an ESP32 microcontroller board: ESP32-WROOM-32. The 1.3”, 240*240 TFT is one of my favorite displays, not only because of its 65,536 available colors (16 bits per pixel, RGB565) but also because of its fast SPI interface which is meticulously supported by Bodmer’s TFT_eSPI.h library.

Compared with current LCD displays and OLED displays, TFT type screens offer the luxury of nearly unlimited color. While it is possible on OLED displays to show pictures, the constraint with this type of display is that pictures are always presented in monochrome. A TFT display shows images as crisp and colorful as your smartphone’s screen does. Of course your smartphone has more pixels than the humble 240*240, which necessitates some cropping and scaling. In this project I started with a big, 2521*1688 pixels jpg image downloaded from Wikipedia.

To possess a TFT screen is one thing, making it work, that is: showing color pictures, needs some investment in ideas, time and effort. As graphical functions are called via a supporting library the selection of a competent library is of prime importance. Another issue is the communication protocol between microcontroller and display. Among the available libraries the TFT_eSPI.h library offers superior support for a variety of controllers / microcontroller board / TFT display configurations, including the configuration used in the current project.

TFT_eSPI can be installed via the Library Manager in the Arduino IDE (Tools → Manage Libraries). Additional Configuration: see section Software. Install the most recent version.

Figure 1 shows the wiring diagram. Wiring is straightforward: the VCC pin of the display breakout board is connected to the 3.3V pin of the ESP32. GND is connected to GND. Of the remaining display pins only four are necessary. Pins marked ‘SCL’ and ‘SDA’ (on other SPI displays sometimes labeled as SCLK and MOSI) are connected to pins D18 and D23 of the ESP32. Pin ‘RES’ on the TFT display is connected to pin D4 of the ESP32, and pin ‘DC’ of the display goes to pin D2 of the ESP32. Pin ‘BLK’ of the TFT is not connected.

The example here, shown in figure 1, is a picture of a ladybug. The image was acquired via a search on Wikipedia. Its credentials are: Gilles San Martin from Namur, Belgium – Coccinella magnifica, CC BY-SA 2.0, https://commons.wikimedia.org/w/index.php?curid=7694675. The original picture is beautiful, but it is also huge compared with my humble TFT: 2521*1688, format: jpg.

This library is extremely versatile, with many graphical functions, while it supports a great number of combinations of microcontroller boards and display controllers. The great difference between TFT_eSPI.h and alternative libraries, e.g. Adafruit_GFX.h and U8glib.h is that the so-called ‘constructor’ is absent.

The idea in TFT_eSPI is that all necessary parameters presented to the library are in a series of instructions bundled in a User_Setup.h file. As its name implies such a file is configurable by the end user. User_Setup.h contains calls to an array of drivers. Look around in the library’s folder named ‘User_Setups’. This folder is a playground for folks who like to experiment with all sorts of microcontrollers and displays. A superb idea!

– open User_Setup_Select.h and uncomment the line calling one of the pre-configured configuration files. In the present microcontroller-graphical controller combination this is a modified Setup24_ST7789.h.

After experimenting first with breadboards and jumper wires I decided to take a 7×9 cm soldering prototyping board and some pin sockets to solder a small robust bench that accommodates the ESP32-WROOM and the 2402*40 TFT (figure 4). Further software testing was done with this bench. Results were excellent. The TFT_eSPI library supports the ESP32 / ST7789 240*240 SPI TFT without any problem and, very important: very fast. I made and tested a variety of c-array coded images in a range of formats (e.g., 80*160; 128*128 and so on). They were all displayed very well on the small square screen. Condition is that the data file name is 8-character limited. One of these extra images, a picture of a dog called ‘bastien’, was cropped at 240*380 pixels and converted into a c-array (file size of the c-array: 1 MB). The sketch calling this c-array was perfectly compiled. Only the left part of the image was shown on screen with the instruction ‘tft.pushImage (0,0,240,240, bastien);‘, and the same happened when the instruction was changed into ‘ tft.pushImage (0,0,240,380,bastien);‘. This means that the TFT_eSPI library handles images benevolently. The instruction ‘’tft.pushImage (0,0,120,120, bastien);‘ produced an image on the left lower quadrant of the display, and this image contained the left lower quadrant of the bitmap picture.

An interesting option is to place several external c-array.h files into progmem in order to produce a slideshow. I tried this with two 240*240 pixel images of the famous portrait of Che Guevara; one named ‘che-red.h’ and the other ‘che-grey.h’. With a simple delay () instruction a display time between successive images can be set. A series of calls to several more external c-array image files is possible as well. Here the prospect of animation looms. The successful compilation of a 240*380 pixel c-array image tempts me to investigate how far the the envelope of the ESP32 microcontroller can be pushed with images of increasing size. Such a project can easily be entertained on my previously assembled benches that accommodate bigger SPI- or parallel displays (up to 3.95”. 320*480 pixel TFTs *, **). Another attractive project is to use a card reader to transfer images with lightning speed, pixel after pixel, from an image file on SD card to the TFT display.