mcufriend tft lcd shield library price

A while ago I bought this 2.4"" Inch TFT LCD Touch Display Shield for Arduino UNO, but only recently I came up with a project where I could make use of this piece of hardware.

It turned out that indeed the RGB packing function from the Adafruit library did not play well with that display, but shifting and OR"ing the bits only slightly different would do the trick.

Then, instead of calling the method tft.clor565, a call to the newly created function fixed_color565 made sure that images got displayed correctly from now on..

There are many tutorials on Arduino shields for 2.4 inch TFT LCD displays. In this road test I apply different tutorials to check the performance and issues of this specific shield: AZ-Delivery 2.4 inch TFT LCD display with resistive 4-wire touchscreen and an integrated SD card reader.AZ-Delivery 2.4 inch TFT LCD display.

TFT LCD is a variant of a liquid-crystal display (LCD) that uses thin-film-transistor (TFT) technology. That improves image quality, better contrast and addressability.

Depends on the needs of your project. Arduino UNO processor frequency is low. With the Arduino UNO full-color TFT LCDs are suitable to display simple data and commands. The TFT controller used cannot switch internal display RAM, so you can"t use the double buffer technique for animations but still you can only re-draw small sections of screen.

This module consumes most of the resources available in Arduino UNO. This is not a limitation of the module itself. In return, using a parallel interface allows you to quickly update the image. If you want to take advantage of all its functionality (LCD + touch screen + SD card), only pins 0 and 1 (RX and TX, respectively) and pin 19 (A5) remain unused. If the SD card is not used, pins 10, 11, 12 and 13 are additionally available. With a suitable layout, some SPI devices could be connected even if the SD card is used.

The PCB silkscreen indicates the main function of each pin, the labels are easy to read, although it does not show labels for the touch screen pins:Pin 9 - Touch X+ / LCD_D1

The SD card reader is very well located between the USB connector and the power connector, it does not touch either of them as it happens in other lcd tft shield modules and it is easily accessible to insert and remove the SD cards.

You can directly use the shield with any arduino uno. In this case we are using an Arduino UNO that exposes all the pins both on the header and on the board. In such a way that you do not need another shield to access the pins not used by the screen

ShieldCompatible with Arduino. 5V compatible, can be used with 3.3V or 5V logic. On-board 3.3 V (300mA LDO controller). The design is very well thought out and fits Arduino UNO perfectly.

If you want to take advantage of all its functionality (LCD + touch screen + SD card), only pins 0 and 1 (RX and TX, respectively) and pin 19 (A5) remain unused. If the SD card is not used, pins 10, 11, 12 and 13 are additionally available. With a suitable layout, some SPI devices could be connected even if the SD card is used.

The ILI9341 which can control each pixel with a small number of pins. The shield connects ILI9341"s data pins 0-7 to Arduino digital pins 2-8 (allowing parallel communication, not SPI). ILI"s RESET goes to pin to Arduino analog pin A4.CS (chip select) to A3. RS (CD command/data) to A2. WR and RD to A1 and A0.

Includes a resistive 4-wire touchscreen (touchpad). The touch screen is attached on the surface of the display. Touch screen needs two analog inputs and two digital outputs. It connects through 4 wires, which share arduino pins 8, 9, A2, A3 with the ILI9341 driver. So you can"t write to LCD display and read the touch screen in the same time. I. Driver chip is XPT2046.

The resistive touch screen does not appear to appreciably affect the optical characteristics. Works properly, It takes a little pressure with the stylus for it to respond like in old mobile phones. You notice how it sinks into the screen when you press with the stylus. The stylus that comes with the module makes it easy to use if your interface design uses small controls. Some touch screen libraries offer better accuracy by specifying the resistance of the touch screen in the X direction. Resistance can be easily measured with a multimeter by connecting the test leads to the LCD_D1 - X + and LCD_DS X- terminals. Touch is sensitive to pressure.

The SD card reader works well. Accessing the SD card with the functions available in the SD library included in the IDE version used does not present any problem. SD cards are recognized and can be written or deleted.

This note introduces a low-cost Thin Film Transistor (TFT) display to enhance the operation and usefulness of Liquid Crystal Display(LCD) devices. TFT technology controls the pixel element on the glass surface thereby greatly reducing image blurring and improving viewing angles.

The test board chosen for this exercise is the Elegoo Arduino UNO board from the corresponding Super Starter Kit. The kit already has several simple numeric and text displays. The TFT display may perhaps provide better ways to interact in applications.

The controller for the illustrated model of the TFT display is SSD1297.This information is important because the display (owing to its low cost and high popularity) has many different manufacturers who may not leverage the same controller instruction set. The specification of the controller in the coding exercises is examined in the Appendix section of this note.

Of course, the display can be mounted elsewhere and the pins connected to the Arduino directly or indirectly using, for example, a breadboard. Other components can then use the breadboard in lieu of a shield with custom connectors. Of course, without access to such anon-standard or readily available breadboard, it is impossible to illustrate this arrangement in this note.

The Examples folder for the library provides the starter files for the tests. If you are using a newer display you will need the updated libraries from the GitHub repository (see link in References below)and using the#definestatement to identify the display model.

The output from the diagnostic program, LCD_ID_reading.ino, is shown below:Read Registers on MCUFRIEND UNO shieldcontrollers either read as single 16-bite.g. the ID is at readReg(0)or as a sequence of 8-bit valuesin special locations (first is dummy)reg(0x0000) 97 97ID: ILI9320, ILI9325, ILI9335, ...reg(0x0004) 97 97 97 97Manufacturer IDreg(0x0009) 97 97 97 97 97Status Registerreg(0x000A) 97 97Get Power Modereg(0x000C) 97 97Get Pixel Formatreg(0x0061) 97 97RDID1 HX8347-Greg(0x0062) 97 97RDID2 HX8347-Greg(0x0063) 97 97RDID3 HX8347-Greg(0x0064) 97 97RDID1 HX8347-Areg(0x0065) 97 97RDID2 HX8347-Areg(0x0066) 97 97RDID3 HX8347-Areg(0x0067) 97 97RDID Himax HX8347-Areg(0x0070) 97 97Panel Himax HX8347-Areg(0x00A1) 97 97 97 97 97RD_DDB SSD1963reg(0x00B0) 97 97RGB Interface Signal Controlreg(0x00B4) 97 97Inversion Controlreg(0x00B6) 97 97 97 97 97Display Controlreg(0x00B7) 97 97Entry Mode Setreg(0x00BF) 97 97 97 97 97 97ILI9481, HX8357-Breg(0x00C0) 97 97 97 97 97 97 97 97 97Panel Controlreg(0x00C8) 97 97 97 97 97 97 97 97 97 97 97 97 97GAMMAreg(0x00CC) 97 97Panel Controlreg(0x00D0) 97 97 97Power Controlreg(0x00D2) 97 97 97 97 97NVM Readreg(0x00D3) 97 97 97 97ILI9341, ILI9488reg(0x00D4) 97 97 97 97Novatek IDreg(0x00DA) 97 97RDID1reg(0x00DB) 97 97RDID2reg(0x00DC) 97 97RDID3reg(0x00E0) 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97GAMMA-Preg(0x00E1) 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97 97GAMMA-Nreg(0x00EF) 97 97 97 97 97 97ILI9327reg(0x00F2) 97 97 97 97 97 97 97 97 97 97 97 97Adjust Control 2reg(0x00F6) 97 97 97 97Interface Control

Many thanks toDavidPrenticefor the display driver library and the guidance, support and advice during the tests for this display. I would have failed at the starting block without his generous assistance. He is an authority on the drivers for this class of displays.

Actually a cheap color display has lot of advantages over any other type displays. Monochrome graphic LCD display actually costs same. Other options of cheap display is Nokia 5110 Display (which is often reported by many users as buggy), standard 1602A LCD Display (which is an all purpose standard basic LCD display). Here is Getting Started Guide For Arduino TFT Touch Screen Shield Manufactured by MCUFRIEND. This is possibly the cheapest 2.4″ color display for Arduino. It costs around $8 to $10. MCUFriend is a China company and has an useless website. However, all over the web, there is huge support for this cheap display. The display works as intended. I purchased it from physical shop. It is a 2.4″ diagonal LCD TFT display, has white-LED backlight, resistive touchscreen, 240×320 resolution, has SPFD 5408 controller with built in video RAM buffer, has 8 bit digital interface and 4 control lines, it uses digital pins 5-13 and analog 0-3. there is a micro SD card reader.

For Arduino UNO, you are actually having digital pins 2, 3, analog 4, analog 5 unoccupied by the shield. If you do not use the SD card slot then digital pin 12 is also available. 3 digital pins and 2 analog pins should be good for most of the basic projects but for multiple sensors, the actual need will be towards Arduino Mega instead of Arduino UNO. This shield does work with Arduino Mega but sometime oddly behave (may be there is some other problem with my piece). I lack idea whether the micro SD card slot actually works.

Obviously as it is a shield, it is challenging to use the unoccupied pins. The easy trick is use to pass a single stranded wire. I read somewhere that it is possible to control the backlight by connecting a digital pin and transistor.

Displaying a custom image or graphic on a LCD display is a very useful task as displays are now a premium way of providing feedback to users on any project. With this functionality, we can build projects that display our own logo, or display images that help users better understand a particular task the project is performing, providing an all-round improved User Experience (UX) for your Arduino or ESP8266 based project. Today’s tutorial will focus on how you can display graphics on most Arduino compatible displays.

The procedure described in this tutorial works with all color displays supported by Adafruit’s GFX library and also works for displays supported by the TFTLCD library from Adafruit with little modification. Some of the displays on which this procedure works include:

For this tutorial, we will use the 2.8″ ILI9325 TFT Display which offers a resolution of 320 x 340 pixels and we will display a bitmap image of a car.

To demonstrate how things work, we will use the 2.8″ TFT Display. The 2.8″ TFT display comes as a shield which plugs directly into the Arduino UNO as shown in the image below.

Not all Arduino displays are available as shields, so when working with any of them, connect the display as you would when displaying text (we recommend following the detailed tutorial for the display type you use of the above list). This means no special connection is required to display graphics.

Image2Code is an easy-to-use, small Java utility to convert images into a byte array that can be used as a bitmap on displays that are compatible with the Adafruit-GFX or Adafruit TFTLCD (with little modification) library.

To reduce the amount of code, and stress involved in displaying the graphics, we will use two wonderful libraries; The GFX library and the TFTLCD library from Adafruit.

The GFX library, among several other useful functions, has a function called drawBitmap(), which enables the display of a monochrome bitmap image on the display. This function allows the upload of monochrome only (single color) graphics, but this can be overcome by changing the color of the bitmap using some code.

The Adafruit libraries do not support all of the displays but there are several modifications of the libraries on the internet for more displays. If you are unable to find a modified version of the library suitable for your the display, all you need do is copy the code of the drawBitmap() function from the GFX library and paste it in the Arduino sketch for your project such that it becomes a user-defined function.

As usual, we start writing the sketch by including the libraries required. For this procedure, we will use the TFTLCD library alone, since we are assuming you are using a display that is not supported by the GFX library.

The last section of the code is the drawBitmap function itself, as earlier mentioned, to use the drawbitmap() function with the Adafruit TFTLCD library, we need to copy the function’s code and paste into the Arduino sketch.

The ST7793 is a big, cheap 8-bit parallel Touchscreen TFT-module with “arduino shield” pinouts. Price is below 6 Euros (without shipping) https://www.aliexpress.com/item/1lot-2- … 19187.html

Beware if you use another board, because there are some #ifdef exactly for the bluepill and or nucleo, so you need to change the library files or just set a #define in the sketch for bluepill, so check if this matches with your board (maple mini won’t do that!):

Reason: The controller is 240×432 and the TFT-display is 240×400 so you’ll get 32 lines of garbage while hardware scrolling. (Ok, HW-scrolling is cool a first time looking and further you’ll never need/miss it again)

So I need to rewrite it and put LCD WR and LCD RS to PB0 and PB1. Drawback: All analog inputs are used only by display. I’ve to thing about a better solution (maybe not using the whole PA (to 07) port for the 8-bit port….)

Strange that both values are quiet similar. On another MCUFRIEND Uno Shield Display the values are more “right” (25,30) – but the touchdisplay works on UNO, have to look for some better STM32 implementation (Currently I have some strange Y values on Nucleo/bluepill).

Overall I would say this display is more interesting for the bigger STM32 like RET or VET for comfortable pin manipulation without afio-remapping or compromises, maybe I’ll use it for my serial TFT – 3D printer project, because the size is fine for touching it with my fingers (better than those 2.4 or 2.8 ones). The low resolution is also fine, because I don’t need fancy hi-res graphics and the lower the resolution the smaller the code and faster the display.

Looking back, I see why someone would opt to shell out the extra cash for Adafruit’s (essentially) plug and play touchscreen. On the otherhand, I learned quite a bit about how the LCD works which will be useful when attempting to translate the relevant driver code into the Hack HL language.

After plugging in the LCD, I uploaded the graphicstest sketch (included in the Adafruit TFT LCD library) onto the Arduino. The guide shows how the graphicstest should look when working correctly. All I got was a blank screen. Here are the various changes I made to get the Arduino communicating with the LCD:

The Mcufriend driver reads as “Unkown LCD driver chip”… I tested the four drivers (932X, 7575, 9341, HX8357D) already implemented by Adafruit in the code and the 9341 worked. If none had worked, I would have found myself in a sticky situation. (I would have to either identify the driver installed on the LCD, then find and read the related docs (look at the size of these docs!), so that I can write the magic code needed to interface with it. Or fork up the cash for Adafruit’s LCD shield).

The 9341 driver worked, but the colors were inverted. For example black appears as white. Blue as magenta. I could technically write all future programs with this in mind, for example type ‘white’ when I want something to appear ‘black’ but that would be a PITA. I could alternatively read the driver manual and try to figure out why the colors are inverted and change the magic code accordingly… which would also be a (grueling) PITA. I instead opted to write some code that would invert the color right before it was sent to the LCD.

At first I though it was a software problem. But much googlefu later I found nothing. The following day I looked more closely at the noise. The more I looked at the screen the less digital it seemed. Depending on which angle you looked at the screen, the noise pattern changed and didn’t seem to follow the grid layout of the pixels. Given how relatively cheap the screen was to buy, I decided to peel off the touch screen layer that sits atop the LCD to verify whether it was the code or something physical causing the fuzziness.