nodemcu esp8266 1.8 tft lcd factory

I am using the 1.8″ color ST7735 TFT display a lot. The reason for that is that this display is very easy to use, it costs less than $5 and it offers color! At the back, the display has an SD card slot.A brief summary of the pins (adapted from Adafruits thorough summary):

RST – this is the TFT reset pin. Connect to ground to reset the TFT! Its best to have this pin controlled by the library so the display is reset cleanly, but you can also connect it to the Arduino Reset pin, which works for most cases.CS – this is the TFT SPI chip select pinD / C – this is the TFT SPI data or command selector pinDIN – this is the SPI Master Out Slave In pin (MOSI), it is used to send data from the microcontroller to the SD card and / or TFTSCLK – this is the SPI clock input pinVcc – this is the power pin, connect to 5VDC – it has reverse polarity protection but try to wire it right!LED – this is the input for the backlight control. Connect to 5VDC to turn on the backlight.GND – this is the power and signal ground pinNow that we know what we’re dealing with it’s time to start wiring!

As you all know the are a few variants of the 1.8" TFT on the internet. With the genuine Adafruit lcd-s there are usually no problems. But when using fake ones(usually from Aliexpress) you have to make some adjustments.

Bodmers TFT_eSPI library is very awsome and rich funcionality. And the best part is that he made it to handle the pixel offsets depending on wich kind of 1.8" TFT you are using.

Then uncomment the tft height an width. And then in my case(REDTAB) uncomment for eg: #define ST7735_REDTAB. After this save it for the moment and compile sketch and upload to board. To be sure i have defined the parameters in the sketch too.This is a bit long procedure, cause you have to compile and upload the sketch every time to board untill the offset is gone, but it is worth the experimenting. For editing the h. files i strongly suggest Wordpad. Images included.

For an upcoming new project I wanted a colour (UK spelling) LCD screen (ideally OLED), 256×256 (or greater) resolution and nice and cheap. It was not an easy 2 minute task. There were no OLED screens offering what I wanted (that I could see at the time). So compromises were made, in the end I purchased a 128×128 pixel screen (none OLED) for around $3.50 (£3.20, 3.50 Euro). Not as cheap as I thought I might get one for but the cheapest I could find. There were a lot of sellers offering this screen and it’s shown below.

Due to the planned game being more advanced than Space Invaders I needed a processor with more memory and speed than the Arduino could offer. Enter the ESP8266 processors which offer faster speeds and lots and lots more memory. Wifi is also available but will not be required for this project unless we implemented a World High Score Table perhaps! There are newer versions, ESP32, available with even more power but are more expensive and we don’t need that level of performance for this project. I’m using a NodeMCU from Lolin, which is basically a breakout board for the ESP8266 so that you can use it easily on breadboards or small production runs using through hole.

Power is self explanatory. LED adds a little extra brightness to the screen but it does still work if not connected. I’ve seen resistors added in series here and even variable ones to vary the brightness but I’ve ran it directly connected on this screen with no issues and wouldn’t want it dimmer as its not ultra bright. It is actually on even when not connected giving adequate brightness in my opinion. SCL is the SPI clock and goes to the NodeMCU’s hardware SPI pin (pin D5). SDA is actually the SPI MOSI connection and goes to the NodeMCU’s SPI MOSI pin (D7). RS is a Regsiter Select pin for ST7735 driver chips, this maps to a variable called TFT_DC in the Adafruitcode (explained later) that I was using for testing. This controls whether we are sending a command to the ST7735 chip or actual data. I think that Adafruit call it DC meaning Data Control, but I’m not sure. On some boards it may even be referred to as A0. For our purposed we connect it to D4. RST is the screen reset and and is connected to pin D3. These last two can connect to any NodeMCU pins that are not used for other functions. CS is Chip Select (usually referred to as Slave Select in the SPI protocol) and again can connect to any pin but I use D2. If this is pulled low then this device can receive or send data on the SPI bus. If only one device in your design you could pull this low permanently and not use D2.

Load up the example code that should now be available at “Files->Examples->XTronical ST7735 Library->GraphicsTestESP8266”. This is basically the Adafruit example with just some tiny changes (It goes through all the tests for each rotational position of the screen) so that it uses the new driver file and slightly altered initialisation routine.

There is an issue with the line drawing routine within the Adafruit GFX library, so this part of the original demo was removed. Basically it forces the NodeMCU to reset. As I’m not going ot be using this I’ve decided for now to ignore this issue.

Pins D5 (GPIO14) and D7 (GPIO13) are hardware SPI module pins of the ESP8266EX microcontroller respectively for SCK (serial clock) and MOSI (master-out slave-in).

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

Project hardware circuit should give the same result as the one shown in the following video where Arduino UNO board is used (NodeMCU is much faster than Arduino UNO):

In this guide we’re going to show you how you can use the 1.8 TFT display with the Arduino. You’ll learn how to wire the display, write text, draw shapes and display images on the screen.

The 1.8 TFT is a colorful display with 128 x 160 color pixels. The display can load images from an SD card – it has an SD card slot at the back. The following figure shows the screen front and back view.

This module uses SPI communication – see the wiring below . To control the display we’ll use the TFT library, which is already included with Arduino IDE 1.0.5 and later.

The TFT display communicates with the Arduino via SPI communication, so you need to include the SPI library on your code. We also use the TFT library to write and draw on the display.

The 1.8 TFT display can load images from the SD card. To read from the SD card you use the SD library, already included in the Arduino IDE software. Follow the next steps to display an image on the display:

In this guide we’ve shown you how to use the 1.8 TFT display with the Arduino: display text, draw shapes and display images. You can easily add a nice visual interface to your projects using this display.

Only one drawback, Voltage input on WeMos is limited to 6V and NodeMCU says up to 20V but trust me, I burnt some at only 14V so If I need to power boards with more than 6V I"m using cheap and small DC/DC converters like this oneone. Plenty on ebay. If you need a more serious and robust one, take this amazing OKI-78SR-5 from Murata (up to 36V).

Take care that on the market you can find lot of NODEMCU boards with different version, and they do not all fit on this. Just because sometime the width of the board if too high. Take care when you order a NodeMCU, see this postfor explanations

New boards version V1.2 these boards add a MOSFET transistor to protect againns reversed power supply. Trust me this will avoid you to burn some nodeMCU board (but nobody plug reversed powed, never ?)

Boards V1.1 are tested ok (RFM69), no problem at all, just SILK error on TFT connector, TFT pin 4 is RST or VIN (depending on solder pad) not GPIO0, also R3 10K is not needed since GPIO2 is already pulled up by 12K on nodeMCU boards.

ESP8266 to boot correctly needs some pins at defined level, GPIO15 must be LOW and GPIO2 must be HIGH. Unfortunatlly with RFM69 connected as IRQ to GPIO2 and SS to GPIO15 it does not boot because RF69 pull it DIO IRQ to LOW, making GPIO2 LOW and ESP8266 not booting. The fix is to reverse the wiring, connect IRQ to GPIO15 and SS to GPIO2 (and do according changes in the code).

I have tried david_prentice"s MCUFRIEND_kbv Library with some hacks to no avail. I tried to hack the library for ESP8266 (updated write_8 and read_8 functions in mcufriend_sheild.h and defined SUPPORT_4532) - using these connections

This person ( (146) ESP8266 and 2.4" 8-bit parallel ST7781 TFT Uno Shield - YouTube) got the same display working w/ nodeMCU (albeit their module is 5V one and has hack on the LDO).

The Bodmer/TFT_eSPI: Arduino and PlatformIO IDE compatible TFT library optimised for the Raspberry Pi Pico (RP2040), STM32, ESP8266 and ESP32 that supports different driver chips (github.com) library says 8 bit parallel is not possible w/ ESP8266 because of shortage of GPIOs - but ESP8266 has 16 GPIOs (out of which 4 are SPI). I don"t plan on using touch or SD card functionality anyways. The LCD requires 8(data) + 4 (Control) + 1 = 13 pins, which should fit in the 16 provided by ESP8266 ? Please let me know if I am missing anything.

Anyways - the first question at hand would be - is it possible to run 8 bit parallel tft w/ ESP8266, followed by - which library can do the job if possible.

A 80*160 pixel color display has the particular advantage that it is small: screen diagonal of 0.96 inch. This makes it attractive for use in (literally) small applications, particularly in scale models: railways, homes, cities. Attached to a ESP8266 and ESP32 microcontroller these displays can produce animations or day/night scenes, illuminated shop windows, traffic boards, advertisement panels and so forth. Here we wire a 0.96’ TFT with ST7735S controller to ESP8266 and ESP32 microcontroller boards

Model railway displays can be made more attractive by the addition of ‘live’ decoration: train station arrival/departure boards, information screens, advertisement boards, etcetera. Another type of decoration is animated shop windows. For this genre of application a miniature display can be an interesting option. All these applications have in common that any display used needs to be small, flat, economical and easy to fit, sometimes as retrofit, into the interior of plastic model structures such as model railway homes and Lego buildings. They even may be placed in structures belonging to model Christmas or Easter villages. The market supplies small monochrome displays, e.g. 0.91 inch diameter, 128*32 pixel OLED, the slightly bigger (0.96 inch), 64*128 pixel OLED, and the recently introduced 0.96’ 160*80 TFT. The OLEDS can be found in different versions (white, blue, yellow monochrome color). Very attractive is the 0.96’ TFT because it is capable of displaying 64k colors. Driven by a powerful ESP8266 or ESP32, animations can be run such as miniature billboards and advertisement boards. Static displays that change between day and night such as shop window illumination, are also among the possibilities. In this article we deal with the connectivity between a 0.96’, 160*80 pixel TFT and ESP8266 or ESP32 microcontroller boards. The TFT’s controller is a ST7735S which is perfectly supprted by Bodmer’s TFT_eSPI library.

Whilst the early ESP8266 development work was done with a configuration consisting of a breadboard with the display on it and with connections through jumper wires such assemblies perform very irregular. The 0.96′ SPI TFT responds very critically to imperfect wiring: one slightly loose jumper wire and the display won’t work. A minibench with soldered pin connectivity was therefore constructed for ESP8266 experiments, designed to support a Wemos D1 mini ESP8266 and a TFT display. The Wemos was selected here because its small footprint makes it easy to hide this microcontroller board inside buildings constructed from Lego blocks. Components of the minibench: a double-sided 60×40 mm soldering prototyping board, three 8-pin headers sockets and wires. The design, wiring scheme and the result are shown in figures 2 and 3.

Connected with an ESP32 the TFT display feels at ease. Maybe this is so because Bodmer’s TFT_eSPI library provides a User_Setup example that did not need tweaking. The display responded immediately, fast and reliable. Hardware SPI pins on the ESP32 are used for clock and data: pin 18 is connected to SCL at the display while pin 23 is connected to SDA of the display (see figure 4). The other pins breathe familiarity as well: RST of the display to D4 of the Wemos, DC to D2 and CS to pin D6. The pin on the display marked BLK remains unconnected; I noted comments on several fora that BLK may be connected to the 3.3V pin, to any pin on the ESP32 that supports pulse width modulation, or that the BLK pin can be set HIGH (backlight ON) or LOW (backlight OFF). The display at hand has no voltage regulator which implies that if one wants to use it with an Arduino Uno the precaution must be followed that control signals to the display run via voltage level conversion.

There are two major libraries supporting ST7735 controller-based TFTs: the Adafruit_GFX.h library and Bodmer’s TFT_eSPI.h library. My experience with the Adafruit_GFX.h library is that although the common graphic functions perform well, support of animations via a series of instructions ‘drawBitmap ()’ is relatively slow. Adafruit_GFX seems to be created for 160*128 displays. The library does not support the instruction ‘pushImage ()’. By contrast the TFT_eSPI.h library supports graphics as good as the GFX library while animations perform perfectly and at high speed, both with ‘drawBitmap ()’ and ‘pushImage ()’ functions. We further discuss here the TFT_eSPI library and keep Adafruit_GFX.h in storage for future experiments.

The TFT_eSPI library is different from most libraries, e.g. Adafruit_GFX and U8G2 in the sense that the ‘constructor’ is inside a special file whose name is ‘Setup_xxxx.h’ that resides in the folder ‘User_setups’. These special files are ascii which makes them endlessly tweakable with a common ascii text editor. The specific Setup_xxxx.h is called in another setup file named User_Setup_Select.h that resides in the library’s main directory. Consider Bodmer’s ‘constructor’ systematics as a kind of two-stage rocket. Both stages need to be edited befor launch. The first stage is User_Setup_Select.h and the second stage is Setup_xxxx.h. After the editing has been done successfully the display will indeed perform ‘as a rocket’!

The display was with both platforms tested with graphical tests that are available for everyone in the Arduino IDE through File → Examples, while I also ran several of my own graphical tests as well that I created c-arrays of pictures and displayed these supported by the TFT_eSPI.h library. I recommend here to upload example TFT_Meter_5 available in the TFT_eSPI library ensemble (in the Arduino IDE: File → Examples → TFT_eSPI → 160×128 → TFT_Meter_5). Brilliant!

Below follows the complete listing of ‘Setup_FW_ESP8266_ST7735_TFT_017.h’. For intimi: this is a modified Setup43_ST7735.h. I post here a screen capture because the WordPress editor has problems with the character ‘#’.

One way to demonstrate what one can do with a small display that runs animations is to make it part of a building, let’s say a shop window or something similar. Fortunately the 0.96′ display nicely fits in portrait orientation a front door in the Lego plastic building block system. So I scooped up some material from my children’s Lego assortment and constructed a Swiss chalet that features in the front door the 160*80 TFT display. This display is powered by an ESP32WROOM32. The rooms were fitted with white leds that can be switched on and off. Switching is controlled by an Arduino Nano and is completely separate from all the action happening at the front door. For the purpose of preparing Figure 5 I replaced the animation by a static 160*80 Panda bear image – “there’s a bear at the front door, mama!”.

Only one drawback, Voltage input on WeMos is limited to 6V and NodeMCU says up to 20V but trust me, I burnt some at only 14V so If I need to power boards with more than 6V I"m using cheap and small DC/DC converters like this oneone. Plenty on ebay. If you need a more serious and robust one, take this amazing OKI-78SR-5 from Murata (up to 36V).

Take care that on the market you can find lot of NODEMCU boards with different version, and they do not all fit on this. Just because sometime the width of the board if too high. Take care when you order a NodeMCU, see this postfor explanations

New boards version V1.2 these boards add a MOSFET transistor to protect againns reversed power supply. Trust me this will avoid you to burn some nodeMCU board (but nobody plug reversed powed, never ?)

Boards V1.1 are tested ok (RFM69), no problem at all, just SILK error on TFT connector, TFT pin 4 is RST or VIN (depending on solder pad) not GPIO0, also R3 10K is not needed since GPIO2 is already pulled up by 12K on nodeMCU boards.

ESP8266 to boot correctly needs some pins at defined level, GPIO15 must be LOW and GPIO2 must be HIGH. Unfortunatlly with RFM69 connected as IRQ to GPIO2 and SS to GPIO15 it does not boot because RF69 pull it DIO IRQ to LOW, making GPIO2 LOW and ESP8266 not booting. The fix is to reverse the wiring, connect IRQ to GPIO15 and SS to GPIO2 (and do according changes in the code).

This is a single-chip controller/driver for 262K-color, graphic type TFT-LCD.  It consists of 396 source line and 162 gate line driving circuits. This chip is capable of connecting directly to an external microprocessor, and accepts Serial Peripheral Interface (SPI), 8-bit/9-bit/16-bit/18-bit parallel interface.

Adafruit_ST7735 is the library we need to pair with the graphics library for hardware specific functions of the ST7735 TFT Display/SD-Card controller.

Basically, besides the obvious backlight, we tell the controller first what we are talking to with the CS pins. CS(TFT) selects data to be for the Display, and CS(SD) to set data for the SD-Card. Data is written to the selected device through SDA (display) or MOSI (SD-Card). Data is read from the SD-Card through MISO.

You can name your BMP file “parrot.bmp” or modify the Sketch to have the proper filename (in “spitftbitmap” line 70, and in “soft_spitftbitmap” line 74).

#define SD_CS 4 // Chip select line for SD card#define TFT_CS 10 // Chip select line for TFT display#define TFT_DC 9 // Data/command line for TFT#define TFT_RST 8 // Reset line for TFT (or connect to +5V)

#define SD_CS 4 // Chip select line for SD card#define TFT_CS 10 // Chip select line for TFT display#define TFT_DC 9 // Data/command line for TFT#define TFT_RST 8 // Reset line for TFT (or connect to +5V)

However, if your application needs your screen sideways, then you’d want to rotate the screen 90 degrees, effectively changing the display from a 128×160 pixel (WxH) screen to a 160×128 pixel display. Valid values are: 0 (0 degrees), 1 (90 degrees), 2 (180 degrees) and 3 (270 degrees).

tft.print("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Curabitur adipiscing ante sed nibh tincidunt feugiat. Maecenas enim massa, fringilla sed malesuada et, malesuada sit amet turpis. Sed porttitor neque ut ante pretium vitae malesuada nunc bibendum. Nullam aliquet ultrices massa eu hendrerit. Ut sed nisi lorem. In vestibulum purus a tortor imperdiet posuere. ");

Nothing can be compared when you can put your hard work to display on a 4” TFT display- From one end to the other end it"s 480*360 pixel to play with. 4” TFT Analog-GPS clock on Arduino

Every electronic hobbyist dreams to display his work on display – be it LCD, GLCD (64*128), OLED or TFT . LCDs are the oldest type of displays. If putting your work on LCD or GLCD is great then putting it on OLED is certainly greater but nothing can be compared when you can put your hard work to display on a 4” TFT display. From one end to the other end it"s 480*360 pixel to put up with and it"s very very impressive.

The latest Chinese TFT displays are very cheap and works perfectly with Arduino & Raspberry Pi. The TFT ILI9488 display costs about $8 on aliexpress.com. There are two varieties available one with 26 pins 13*2 DIL and the other is with pins aligned exactly to sit on an UNO board.

The connections are easy as shown in the schematic diagrams. Since all the top portion of the UNO is covered by the TFT shield, the connections for the LM-35, GPS receiver is taken from the bottom side of the UNO shield.

Software: This is real fun ! With small strokes of code the TFT behaves differently and opens up many different ways of displaying the output. Creating a thick line, making the hands move smoothly was real challenge as the Adafruit_GFX is not so much developed but a look back to the high school trigonometry is all that you need to make it all happen for you.

However, as a chip, the ESP8266 is also hard to access and use. You must solder wires, with the appropriate analog voltage, to its pins for the simplest tasks such as powering it on or sending a keystroke to the “computer” on the chip. You also have to program it in low-level machine instructions that can be interpreted by the chip hardware. This level of integration is not a problem using the ESP8266 as an embedded controller chip in mass-produced electronics. It is a huge burden for hobbyists, hackers, or students who want to experiment with it in their own IoT projects.

But, what about Arduino? The Arduino project created an open-source hardware design and software SDK for their versatile IoT controller. Similar to NodeMCU, the Arduino hardware is a microcontroller board with a USB connector, LED lights, and standard data pins. It also defines standard interfaces to interact with sensors or other boards. But unlike NodeMCU, the Arduino board can have different types of CPU chips (typically an ARM or Intel x86 chip) with memory chips, and a variety of programming environments. There is an Arduino reference design for the ESP8266 chip as well. However, the flexibility of Arduino also means significant variations across different vendors. For example, most Arduino boards do not have WiFi capabilities, and some even have a serial data port instead of a USB port.

The NodeMCU is available in various package styles. Common to all the designs is the base ESP8266 core. Designs based on the architecture have maintained the standard 30-pin layout. Some designs use the more common narrow (0.9″) footprint, while others use a wide (1.1″) footprint – an important consideration to be aware of.

The most common models of the NodeMCU are the Amica (based on the standard narrow pin-spacing) and the LoLin which has the wider pin spacing and larger board. The open-source design of the base ESP8266 enables the market to design new variants of the NodeMCU continually.

VIN can be used to directly supply the NodeMCU/ESP8266 and its peripherals. Power delivered on VIN is regulated through the onboard regulator on the NodeMCU module – you can also supply 5V regulated to the VIN pin

GPIO Pins NodeMCU/ESP8266 has 17 GPIO pins which can be assigned to functions such as I2C, I2S, UART, PWM, IR Remote Control, LED Light and Button programmatically. Each digital enabled GPIO can be configured to internal pull-up or pull-down, or set to high impedance. When configured as an input, it can also be set to edge-trigger or level-trigger to generate CPU interrupts.

ADC Channel The NodeMCU is embedded with a 10-bit precision SAR ADC. The two functions can be implemented using ADC. Testing power supply voltage of VDD3P3 pin and testing input voltage of TOUT pin. However, they cannot be implemented at the same time.

UART Pins NodeMCU/ESP8266 has 2 UART interfaces (UART0 and UART1) which provide asynchronous communication (RS232 and RS485), and can communicate at up to 4.5 Mbps. UART0 (TXD0, RXD0, RST0 & CTS0 pins) can be used for communication. However, UART1 (TXD1 pin) features only data transmit signal so, it is usually used for printing log.

SPI Pins NodeMCU/ESP8266 features two SPIs (SPI and HSPI) in slave and master modes. These SPIs also support the following general-purpose SPI features:

SDIO Pins NodeMCU/ESP8266 features Secure Digital Input/Output Interface (SDIO) which is used to directly interface SD cards. 4-bit 25 MHz SDIO v1.1 and 4-bit 50 MHz SDIO v2.0 are supported.

Incorporated into each NodeMCU is a USB to Serial Converter. The official design is based on the CP2102 chipset and offers the best compatibility. Genuine boards use the CP2102 chipset including the officially licensed Amica NodeMCU modules. The other common USB to Serial Converter used is the CH340G which is common on the lower-priced modules including the LoLin units. Other designs may use drivers including the FTDI chipset, but those designs are rare.

Depending on the Operating System you are using with the NodeMCU, the appropriate driver must be installed. Generally, Windows 10 immediately recognizes the CP2102 chipset while the CH340G may require separate installation.

The NodeMCU offers a variety of development environments, including compatibility with the Arduino IDE (Integrated Development Environment). The NodeMCU/ESP8266 community took the IDE selection a step further by creating an Arduino add-on. If you’re just getting started programming the ESP8266 or even an established developer, this is the highly recommended environment. Visit our dedicated page on setting up and configuring the Arduino IDE for a NodeMCU ESP8266.

The NodeMCU Carrier Board features a genuine Amica NodeMCU ESP8266 processor along with a DB09 male and female connector with an RS-232 level converter.

The original design of the Carrier Board was for a WiFi application and the serial ports allowed for RS-232 data to be provided over the serial connectors, through a MAX232 compatible level converter to the NodeMCU. The level converter allows true RS-232 signals to be sent to the NodeMCU without worrying about the wide voltage swings.

The NodeMCU Carrier Board schematic shows the two DB-09 connectors, along with the switch at SW1. The switch toggles the data from either DB-09 between Pin 2 or Pin 3 to the level converter.

It is important to note that with a jumper placed across J1, this will interfere with the ability of the USB connector on the NodeMCU module, in particular, the ability to program the NodeMCU. If programming/reprogramming the NodeMCU, it is advisable to remove the jumper when programming.

The NodeMCU IoT Experimenter is a versatile prototyping platform for use with a variety of the most popular NodeMCU modules including our NodeMCU Carrier Board. Great to use for IoT projects, advanced or straightforward interfacing, and as a prototyping platform. The NodeMCU, with its versatility, including its ability to be programmed and used from the Arduino IDE, makes it along with this prototyping board the perfect experimenter’s solution.

The NodeMCU IoT Experimenter measures 5 5/16″ x 4.5″ (135mm x 115mm) with a solder mask on each side, plated holes along with a high-contrast silk-screen labeling component and prototyping positions.

Features of the board include a mounting socket area to accept either wide 1.1″ or narrow 0.9″ pitch NodeMCU modules. This includes the Amica NodeMCU carrier board (narrow pin spacing) to compatible variants such as the LoLin NodeMCU models. Power can be provided directly to your NodeMCU module through its built-in USB interface. Alternately, power can be supplied to the IoT Experimenter board which has provisions for an integrated regulated power supply module.

Interfacing to the NodeMCU is through a series of headers that extend each pin of the NodeMCU to rows of four headers. Each port is labeled to identify matching pins from the NodeMCU. The header area is located below the NodeMCU using standard 40-pin headers allowing for versatility in interfacing for sockets or header pins.

Are you interested in purchasing NodeMCU IoT Experimenter, either a partial or full kit of parts? Visit the Online Store for the NodeMCU IoT Experimenter or other NodeMCU and Arduino accessories.