micropython tft display brands

So you have a nifty display like a bright TFT LCD, Charlieplex LED or NeoPixel matrix powered by MicroPython, but what if you want to draw shapes and graphics on it? Most MicroPython display modules only give you basic pixel drawing commands so it"s difficult to draw graphics yourself pixel by pixel. Luckily there"s a handy new MicroPython graphics module you can use to draw basic shapes and graphics on any pixel-based display! This module shows some of the power of MicroPython--a single module can work with any pixel display because of MicroPython"s dynamic language features. In this guide you"ll learn how to use a MicroPython graphics module to draw basic line, rectangle, circle, and triangle shapes on pixel-based displays like the ILI9341 TFT FeatherWing.

For this guide there"s no special hardware you need to draw graphics on a display. However you do need to have a pixel-based display of some sort (LED, TFT, NeoPixel--anything!) connected to your MicroPython board. Check out the following guides for details on how to use a few pixel displays with MicroPython:

First make sure you are running the latest version of MicroPython for your board. If you"re using the ESP8266 MicroPython port you must be running version

If your board supports USB mass storage, like the SAMD21 MicroPython port, then simply drag the .mpy and other files to the board"s file system (eject the drive and reset the board to make sure it is picked up by MicroPython).

The following section will show how to draw shapes on a ILI9341 TFT display like the TFT FeatherWing. You"ll see how the module can be adpated to draw on any pixel-based display by plugging in a new pixel drawing function too.

Next you"ll need to initialize your display so that you can draw pixels on it. Consult the MicroPython display guides for details on initializing displays.

To use the graphics and shape rendering module you"ll need to import its module and create an instance of the GFX class inside it. For example, to create a graphics renderer for the TFT FeatherWing above you would run:

A pixel drawing function to call when the GFX class needs to write a pixel. For this example the TFT display classpixelfunction is specified. It"s important to note that to use the graphics class youmusthave a function it can call to draw pixels! This function can live anywhere, like as a global function or on a class instance. The function needs to take at least a pixel x position and pixel y position parameter (in that order), and any number of other positional and keyword parameters after them (like color, intensity, etc.).

There are two optional parameters you can specify as keyword arguments too. They aren"t shown in this guide but see how the ILI9341 display example code uses them:

hline- Optionally set hline to a fast horizontal line drawing function for your display. This will improve the speed of drawing certain shapes. The function should take as parameters an x position and y position of the line start, then width of the line in pixels. Any number of optional color or other parameters can follow. If you don"t provide a hline function a slow default implementation that draws pixel by pixel will be used.

vline - Optionally set vline to a fast vertical line drawing function for your display. This will improve the speed of drawing certain shapes, especially filled shapes. The function should take as parameters an x position, y position of the line start, then height of the line in pixels. Any number of optional color or other parameters can follow. If you don"t provide a vline function a slow default implementation that draws pixel by pixel will be used.

Now the fun begins! After creating the GFX class you can call functions to draw shapes on the display. For example, draw a simple line across the entire display with the line function:

That"s all there is to basic shape drawing with the Adafruit MicroPython GFX module! With these basic shape primitives you can start to create interesting graphic projects, like a pong or breakout game using filled rectangles and circles. You can add text with the Adafruit MicroPython bitmap font module too!

Remember any pixel-based display can be used with this library, for example, an OLED display or NeoPixel, Charlieplex LED, or simple LED backpack matrix are great targets to use with the library. Just plug in each module"s pixel function and you"ll be drawing shapes in no time!

Note the video above was made showing the MicroPython version of this library. Follow the guide to see both CircuitPython and MicroPython versions of the ILI9341 library.

Small TFT displays are a great way to add graphics to your projects. These are like tiny little LCD monitors that you can drive with a simple SPI serial interface. You can even use these displays in CircuitPython and MicroPython using a module from Adafruit! This module allows you to do basic drawing like putting pixels and filling rectangles on TFT displays like the TFT FeatherWing. You can start to explore a fun world of Python and graphical TFT displays!

This guide explores how to use ILI9341/ILI9340 TFT displays with CircuitPython and MicroPython. Note that right now drawing support for these displays is limited to basic pixel and rectangle drawing commands. You can use another library to draw basic graphics or to draw text. In addition, the touchscreens commonly found on these small TFT displays are not currently supported by the Python module. In the future, a touchscreen module might be available, but for now these displays are only for viewing graphics.

If you"re using a Feather the TFT FeatherWing is the perfect option that easily connects to the Feather. For other boards, you"ll need an ILI9341 or ILI9340 display breakout, like this large 2.8" TFT display breakout. ILI9340 displays like the 2.2" TFT breakout or 2.4" TFT breakout should work too. Make sure the display you"re using has the ILI9341 or ILI9340 driver chip!

If you"re using a TFT FeatherWing and Feather just slide the wing onto the Feather board and you"re all set! The FeatherWing will automatically be connected to the board using its SPI connection.

If you"re using a TFT display breakout you"ll need to connect its power, ground, and SPI connections to the board. For example, the wiring for a 2.8" TFT breakout to Feather HUZZAH ESP8266 might look like:

Display 3.3V output to IM3, IM2, and IM1 (but not IM0!) pins. This configures the breakout to use its SPI interface. See the breakout guide for details on soldering closed these connections to make the SPI interface the default.

To use the TFT display with your Adafruit CircuitPython board you"ll need to install the Adafruit_CircuitPython_RGB_Display module on your board. Remember this module is for Adafruit CircuitPython firmware and not MicroPython.org firmware!

For express boards that have extra flash storage, like the Feather/Metro M0 express and Circuit Playground express, you can easily install the necessary libraries with Adafruit"s CircuitPython bundle. This is an all-in-one package that includes the necessary libraries to use the ILI9341 display with CircuitPython. To install the bundle follow the steps in your board"s guide.

Before continuing, make sure your board"s root filesystem has the adafruit_rgb_display, adafruit_bus_device, and adafruit_register folders/modules copied over.

The following section will show how to control the LED backpack from the board"s Python prompt / REPL. You"ll walk through how to control the TFT display and learn how to use the CircuitPython module built for the display. As a reference, be sure to see the micropython-adafruit-rgb-display module documentation too.

On CircuitPython the SPI bus must be initialized before the display can be used by your code. Run the following code to import the necessary modules and initialize the SPI bus:

These lines create the SPI bus interface and two digital inputs/outputs for the chip select and data/command lines connected to the display. Notice that the pin numbers might be different depending on your board and how it"s wired. Read the comments above and pick the correct two cs and dc lines to run for your setup.

When creating the display instance of the ILI9341 class you"ll need to know which pins are connected to the display"s CS, DC, and optionally RST or reset line. For the TFT FeatherWing see its guide for details on these pin connections.

Once the display is initialized you"re ready to perform basic fill and pixel drawing. First to fill the display with a solid color use the fill function:

Notice how the color565 function is called to get a color that"s passed to the fill function. This color565 function takes in the red, green, and blue color component values which should range from 0 (lowest intensity) to 255 (highest intensity). Try filling the display with different color values!

That"s all there is to drawing on the ILI9341 display with CircuitPython! Right now, only basic fill, pixel, and filled rectangle drawing commands are supported. However, since this is a pixel-based display you can also draw text with the bitmap font library. There"s even a basic graphics library to draw lines and other shapes!

Note this page describes how to use a MicroPython.org version of this library with MicroPython boards. Skip back to the previous page if you"re using a CircuitPython board like the Feather M0 express!

In addition to CircuitPython, there"s an older MicroPython version of the TFT library that you can use with some MicroPython boards. Before you get started it will help to be familiar with these guides for working with MicroPython:

To use the TFT display with your MicroPython board you"ll need to install the micropython-adafruit-rgb-display MicroPython module on your board. Remember this module is for MicroPython.org firmware and not Adafruit CircuitPython!

First make sure you are running the latest version of MicroPython for your board. If you"re using the ESP8266 MicroPython port you must be running version 1.8.5 or higher as earlier versions do not support using .mpy modules as shown in this guide.

The following section will show how to control the ILI9341 display from the board"s Python prompt / REPL. First connect to the board"s serial REPL so you are at the MicroPython >>> prompt.

On MicroPython.org firmware which uses the machine API you can initialize SPI like the MicroPython SPI guide mentions. For example, on the ESP8266 with TFT FeatherWing you can run:

Notice how the baudrate is specifying the SPI bus clock speed at 32mhz. This means pixel data will be sent very quickly to the display--much quicker than a software SPI interface. These displays can actually run up to about 64mhz but the ESP8266 SPI hardware can"t support that fast of a speed!

When creating the display instance of the ILI9341 class you"ll need to know which pins are connected to the display"s CS, DC, and optionally RST or reset line. For the TFT FeatherWing see its guide for details on these pin connections.

After initializing SPI and the display you"re ready to start drawing on it. The usage of the drawing library is exactly the same as with CircuitPython so check out the CircuitPython drawing information--the same code will work on MicroPython too!

Timing the display.clear() function gets a time of about 1100ms to write a completely black screen. Results are worse when looking at displaying an image. I am taking one of the RAW images from the repo which are preconverted pngs and so there shouldn"t be any conversion needed at write time. When writing one to fill the screen I get a write time of 2680ms, over 2.5 seconds, which is a far cry from the 40ms you get, even allowing for the factor of a larger display.

I am very new to working with SPI displays so could be completely missing something but I appreciate the help you are offereing. How much work has to go into each of the drivers / would it be feasable for me to work on creating a driver to work with your GUI with some learning?

In this tutorial Tony Goodhew explains how to use the basic graphics procedures which are included in the display driver, and for the ambitious makers out there he also provides examples for advanced shapes and graphics!

All the other graphical and text objects we would like to display can be built from this single pixel instruction; such as lines, circles, rectangles, triangles and text strings at different sizes.

This is all carried out with code. Display manufacturers usually supply some of these procedures/methods but leave the rest up to the end user to construct.

At the top of our driver program we will always import a minimal set of libraries using this block at the top of our MicroPython script (we add even more later when we want to do advanced programs):

The third line here imports the Framebuffer library which includes several very useful routines to draw objects on the display. The garbage collection library, gc, has also been imported so that we can check how much memory is available.

Each program contains the screen driver code, sets up the buttons/joystick (if applicable), sets the width and height variables, loads the essential libraries, defines the colour (R, G, B) and clear (c) procedures, then displays some colour checking text like this:

Draw a dark grey rectangle in the centre of the screen. Draw 500 white pixels inside the square, none touching the edge. (Random was explained in the previous display tutorial.)

This is routine is very complicated. It splits the original triangle into two with a horizontal line and then fills them in. If you uncomment all the # lcd.show() lines and sleep instructions it will slow right down and you can see it working (unfortunately, the 2” display needs such a large buffer that there is not enough memory for the filled triangles code):

In the centre of the screen display a ‘bull’s eye’ circular target with a ‘gold’ centre, 4 other colours and scores 10, 8, 6, 4 and 2 written in the appropriate positions.

You may have noticed that on some screens the text is very small and difficult to read. In a following tutorial will add an extra font, with more characters, which we can display in different sizes.

This article was written by Tony Goodhew. Tony is a retired teacher of computing who starting writing code back in 1968 when it was called programming - he started with FORTRAN IV on an IBM 1130! An active Raspberry Pi community member, his main interests now are coding in MicroPython, travelling and photography.

This 1.14inch display is equipped with Raspberry Pi RP2040. It supports C/C++ and MicroPython programming language and comes with a 135*240 full color TFT display.

I"m trying to output some data from a python script to a Sainsmart 1.8 TFT display. Followed the instructions from https://github.com/notro/fbtft/wiki, I am able to show the raspberry"s screen on the tft display with

When I try to output data from my python script, a pygame window ("pop up"-like) opens, but not on the tft screen, but on the main screen connected to the Raspberry with HDMI.

As a 2.4inch TFT display module with a resolution of 240 * 320, it uses the SPI interface for communication. LCD has an internal controller with basic functions, which can be used to draw points, lines, circles, and rectangles, and can display English, Chinese as well as pictures.

Note: Different from the traditional SPI protocol, the data line from the slave to the master is hidden since the device only has a display requirement.

Framebuffer uses a video output device to drive a video display device from a memory buffer containing complete frame data. Simply put, a memory area is used to store the display content, and the display content can be changed by changing the data in the memory.

If you need to draw pictures, or display Chinese and English characters, we provide some basic functions here about some graphics processing in the directory RaspberryPi\c\lib\GUI\GUI_Paint.c(.h).

Set points of the display position and color in the buffer: here is the core GUI function, processing points display position and color in the buffer.

The fill color of a certain window in the image buffer: the image buffer part of the window filled with a certain color, usually used to fresh the screen into blank, often used for time display, fresh the last second of the screen.

Display time: in the image buffer,use (Xstart Ystart) as the left vertex, display time,you can choose Ascii visual character font, font foreground color, font background color.;

Note: Each character library contains different characters; If some characters cannot be displayed, it is recommended that you can refer to the encoding set ro used.

This version of the TFT LCD display that I purchased here in Brazil does not come with the CS pin, which is used in many libraries. This offered me some challenge. At the end of the day, I indicated a pin on the nameplate in the call to the driver, but there is no connection made between the CS pin (absent in the display) and the Raspberrry Pi Pico.