tft display gif display in stock

Based on Arduino_GFX and gifdec, espgfxGIF is an Arduino sketch that plays animated GIF on TFT screen of some Arduino Dev modules, mainly esp32 and esp8266.

TFT_eSPI, which is the most common TFT graphic library, supports BMP, and MJPEG/JPEG files via drawBmp() and drawJpeg(). However, due to the way how GIF handles cmap with custom color palettes, drawGIF is not supported (as what I am aware of). Adafruit_GFX also lack support for animated GIF. Color corruption is a common issue.

Arduino_GFX is a rewritten library from Adafruit_GFX, TFT_eSPI to support various displays with various data bus interfaces. Using gifdec to fill the GIF frames into to display data bus, an animated GIF can be played on the TFT display.

9. Put your own animated GIF files on the "espgfxGIF/data" folder. Please note most esp32 DEV modules only have 1Mb of SPIFFS. Limit your total file size to 900Kb.

If you are not using m5Stack m5StickC or TTGO T-Display, please add your own configuration to the script after line 52. You need to declare your canvas and data-bus class, MOSI, SCLK, CS, DC, RST, BL pins, as well as control button pins

I"m trying to get my 3.2 TFT to animate with GIF files, but the images remain static. My TFT is attached to an Arduino ADK, with a Micro SD card in the TFT. All of the images are .raw files, which display with no problem, but I want one .gif image to animate when it"s displayed (my "Katrina" file). When the image I want to move is a .raw file, it shows up on the TFT just fine as a static image, but when I change it to a .gif image, the program no longer runs and a quarter of the screen gets staticy (see image below).

The VM800B development modules offer a hi-quality display system in an elegantly designed, form-fitted bezel that provides a fitted display and component board in a rugged, plastic enclosure. Offered in black or pearl colors, this display sub-system provides the engineer a low priced option which can shorten development time while enabling a production finished look. These FTDI Basic modules are designed to control 3.5”, 4.3” or 5” TFT displays.

The frame buffer is a memory buffer mapping all the pixels of the screen. Our screen"s resolution is 480x320, and each color is coded on 2 bytes, so it"s simply a 480x320x2 bytes buffer, so we have to write the pixel color at the proper buffer position to have this pixel displayed on the screen.

As said, the screen displays only 65536 colors, so each pixel is coded on 16 bits, using the RGB565 format ( 5 bits for red, 6 bits for green, 5 bits for blue ), here is the way to convert standard 24 bits RGB to 16 bits RGB565 :

I found a nice 8x8 pixels font here and made a few executables to use in scripts. You"ll find my code attached, or you can simply clone it from GitHub and build the various executables :git clone https://github.com/SamuelF94/fbdisplay

The prototype was built by plugging the ESP32 and displays into breadboards and using jumper wires. This is convenient for initial experimentation but is prone to poor connection especially if moved about. It the eyes are to be used as part of a costume then soldering all connections is recommended.

Normally the TFT chip select line for a single display is defined within a user_setup file of the TFT_eSPI library, however when using the library with two displays the chip selects must be controlled by the sketch, thus you must NOT define the TFT_CS pin in the TFT_eSPI library setup files. Instead, the chip selects (CS) must be defined in the "config.h" tab of the Animated_Eyes_2 sketch.

The TFT_eSPI library uses "user_setup" files to define all the parameters for the display, processor and interfaces, for the Animated_Eyes_2 sketch the "Setup47_ST7735.h" file was used with the wiring as shown above.

The displays used for testing were 128x128 ST7735 displays, the TFT_eSPI library setup file may need to be changed as these displays come in many configuration variants.

Under Upload image from your computer, click the Browse button to locate the GIF file on your computer. Select the file and then select the Open button.

After a few moments, the revised GIF is shown below the Make a GIF! button. Below the revised GIF is a row of buttons, and the far right one is named save.

Depending on your browser, the file will be saved to your Downloads folder or you"ll be allowed to specify where you want the GIF file to be copied to on your computer.

It"s useful if you want to decode GIF images from the flash memory on the processor, or from an SD card, and display them on a TFT or OLED display. The Minimal GIF Decoder takes about 1K bytes of program memory, and requires just over 12K bytes of RAM, so it will run on any processor with at least 16K bytes of RAM. I used an AVR128DA28.

As a demonstration of the GIF encoder I"ve included a slide-show application that displays a sequence of different images read from the processor"s flash memory. I also give details of how to display GIF images from an SD card.

The GIF image format is ideal for storing images to be displayed on a small TFT or OLED display. It uses the LZW compression algorithm which provides efficient compression of many types of images, and the code to decode LZW-compressed images can be made relatively compact. It"s also well supported by image editors.

I needed a GIF display routine for a project and couldn"t find a GIF decoder aimed at microcontrollers with a relatively small amount of RAM, so I decided to try and write one. The result is a decoder that uses just over 12K bytes, and is therefore suitable for AVR processors with at least 16K bytes of RAM such as the AVR128DA28 or ATmega1284P. It will also run on 32-bit processors such as the ATSAMD21 and ATSAMD51, and I include an example of it running on the ATSAMD51-based Adafruit PyBadge.

These processors have plenty of flash, so you could store several compressed GIF images in flash and display them using the decoder, for a stand-alone slide-show project. Alternatively you can read GIF images from an SD card and display them.

The GIF format treats the image as a linear stream of pixel colour values. The LZW compression it uses works by finding a sequence of pixels it has already encountered, and it encodes each sequence as a variable-length code of from 3 to 12 bits. These codes are then output as a continuous stream of bits.

Decoding a GIF requires the decoder to divide the input stream into codes containing the correct number of bits. These codes are then looked up in a 4096-element table, to translate them into the appropriate sequence of one or more pixels represented by that code.

The clever thing about LZW compression is that the lookup table doesn"t need to be included with the GIF image, because it can be reconstructed dynamically as the code values are read in from the input stream. For a full description of how the GIF format works see the Wikipedia page

A GIF image can contain a colour table of up to 256 colours, so there also needs to be a 256-byte array to store this colour table. Each colour is defined by three bytes, giving the colour"s R, G, and B components. Since this GIF decoder is intended for displaying images on TFT displays with a 5-6-5 colour space, we can reduce each entry in the colour table to 16 bits.

This decoder doesn"t support: the older GIF87a format, animated GIFs, local colour tables, transparency, interlaced GIFs, or other extensions. If it encounters an unknown format it flashes an LED with an error code. However it should work with standard GIFs created by a range of image editors, and I"ve tested it with images from several editors.

To drive the TFT display I used my Compact TFT Graphics Library, which uses standard Arduino SPI calls. The Arduino display provides an SD card socket, and you can use the same SPI interface to read GIF images from the SD card. I"ve removed routines from my library that are not needed by this application.

Alternatively you could also use my Tiny TFT Graphics Library 2, which uses direct bit manipulations on the AVR128DA28 port to drive the display as fast as possible. Both TFT libraries supports a wide range of displays; uncomment the parameters for the display you want to use.

ShowGif() first reads in the GIF header, which specifies the width and height of the image, and the global colour table. If the image has c colours it then initialises the first c entries in the compression table, Table[], with the corresponding colour index, c. A further two entries are reserved for two special codes: clear, which resets the compression table if it is full, and end which indicates the end of the image block. The first free entry in the table is therefore at c+2.

ShowGif() then checks for three types of block: an image block, prefixed by 0x2C, an extension block prefixed by 0x21 which is ignored, and a terminating byte 0x3B that ends the file.

To demonstrate the Minimal GIF Decoder the flash slide-show version of the program displays a sequence of GIF images from the AVR128DA28"s flash memory. The following four sample 160x128 images are provided:

The uncompressed size of a 160x128 image is 160x128x2 or 40960 bytes, so for these images the GIF compression reduces the size by a factor of between 5 and 30. On an AVR128DA28 you could fit approximately 40 images with a size of 3 Kbytes.

If your application needs at most 16-colour GIFs you could represent each pixel colour with four bits, and so fit each table entry into two bytes, reducing the RAM requirement further to 8K bytes.

4th January 2023: When the lookup table is full the GIF being decoded normally sends a clear code, causing the table to be cleared and built from scratch. This is the approach taken by most GIF programs, such as Photoshop.

Here are some examples. The GIF on the left is encoded in the conventional way, with a clear code when the table is full, and is 8750 bytes. The one on the right looks identical, but doesn"t clear the table, and is 7833 bytes: