micropython tft display pricelist

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!

This section review several kits for learning MicroPython. Most of them use the RP2040 chip, but there are some that also use the ESP32 when wireless communication is needed.

The following list is not design to be an exhaustive list of all MicroPython development kits available on the market. We focus on value-based kits that will help our students have fun learning computational thinking.

Lemaker is introducing a line of LCD displays (3.5″, 5.0″ and 7.0″) for its popular Banana Pi and upcoming Banana Pro single board computers, and today we are reviewing the 3.5″ module.