esp32 lcd display brands

Want to display sensor readings in your ESP32 projects without resorting to serial output? Then an I2C LCD display might be a better choice for you! It consumes only two GPIO pins which can also be shared with other I2C devices.

True to their name, these LCDs are ideal for displaying only text/characters. A 16×2 character LCD, for example, has an LED backlight and can display 32 ASCII characters in two rows of 16 characters each.

If you look closely you can see tiny rectangles for each character on the display and the pixels that make up a character. Each of these rectangles is a grid of 5×8 pixels.

At the heart of the adapter is an 8-bit I/O expander chip – PCF8574. This chip converts the I2C data from an ESP32 into the parallel data required for an LCD display.

If you are using multiple devices on the same I2C bus, you may need to set a different I2C address for the LCD adapter so that it does not conflict with another I2C device.

An important point here is that several companies manufacture the same PCF8574 chip, Texas Instruments and NXP Semiconductors, to name a few. And the I2C address of your LCD depends on the chip manufacturer.

So your LCD probably has a default I2C address 0x27Hex or 0x3FHex. However it is recommended that you find out the actual I2C address of the LCD before using it.

Connecting I2C LCD to ESP32 is very easy as you only need to connect 4 pins. Start by connecting the VCC pin to the VIN on the ESP32 and GND to ground.

Now we are left with the pins which are used for I2C communication. We are going to use the default I2C pins (GPIO#21 and GPIO#22) of the ESP32. Connect the SDA pin to the ESP32’s GPIO#21 and the SCL pin to the ESP32’s GPIO#22.

After wiring up the LCD you’ll need to adjust the contrast of the display. On the I2C module you will find a potentiometer that you can rotate with a small screwdriver.

Plug in the ESP32’s USB connector to power the LCD. You will see the backlight lit up. Now as you turn the knob on the potentiometer, you will start to see the first row of rectangles. If that happens, Congratulations! Your LCD is working fine.

The I2C address of your LCD depends on the manufacturer, as mentioned earlier. If your LCD has a Texas Instruments’ PCF8574 chip, its default I2C address is 0x27Hex. If your LCD has NXP Semiconductors’ PCF8574 chip, its default I2C address is 0x3FHex.

So your LCD probably has I2C address 0x27Hex or 0x3FHex. However it is recommended that you find out the actual I2C address of the LCD before using it. Luckily there’s an easy way to do this. Below is a simple I2C scanner sketch that scans your I2C bus and returns the address of each I2C device it finds.

After uploading the code, open the serial monitor at a baud rate of 115200 and press the EN button on the ESP32. You will see the I2C address of your I2C LCD display.

But, before you proceed to upload the sketch, you need to make a small change to make it work for you. You must pass the I2C address of your LCD and the dimensions of the display to the constructor of the LiquidCrystal_I2C class. If you are using a 16×2 character LCD, pass the 16 and 2; If you’re using a 20×4 LCD, pass 20 and 4. You got the point!

First of all an object of LiquidCrystal_I2C class is created. This object takes three parameters LiquidCrystal_I2C(address, columns, rows). This is where you need to enter the address you found earlier, and the dimensions of the display.

In ‘setup’ we call three functions. The first function is init(). It initializes the LCD object. The second function is clear(). This clears the LCD screen and moves the cursor to the top left corner. And third, the backlight() function turns on the LCD backlight.

After that we set the cursor position to the third column of the first row by calling the function lcd.setCursor(2, 0). The cursor position specifies the location where you want the new text to be displayed on the LCD. The upper left corner is assumed to be col=0, row=0.

lcd.scrollDisplayRight() function scrolls the contents of the display one space to the right. If you want the text to scroll continuously, you have to use this function inside a for loop.

lcd.scrollDisplayLeft() function scrolls the contents of the display one space to the left. Similar to above function, use this inside a for loop for continuous scrolling.

If you find the characters on the display dull and boring, you can create your own custom characters (glyphs) and symbols for your LCD. They are extremely useful when you want to display a character that is not part of the standard ASCII character set.

CGROM is used to store all permanent fonts that are displayed using their ASCII codes. For example, if we send 0x41 to the LCD, the letter ‘A’ will be printed on the display.

CGRAM is another memory used to store user defined characters. This RAM is limited to 64 bytes. For a 5×8 pixel based LCD, only 8 user-defined characters can be stored in CGRAM. And for 5×10 pixel based LCD only 4 user-defined characters can be stored.

Creating custom characters has never been easier! We have created a small application called Custom Character Generator. Can you see the blue grid below? You can click on any 5×8 pixel to set/clear that particular pixel. And as you click, the code for the character is generated next to the grid. This code can be used directly in your ESP32 sketch.

After the library is included and the LCD object is created, custom character arrays are defined. The array consists of 8 bytes, each byte representing a row of a 5×8 LED matrix. In this sketch, eight custom characters have been created.

We see a large number of ESP32-based projects over here at Hackster, and it"s of little surprise — the ESP32 is an absolute beast of a processor, sporting dual 240MHz Xtensa CPU cores, WiFI and BLE. What"s not to love about this one-stop shop for computing and connectivity?

The ESP32 is a solid choice when working with a product that has the option of being tethered to a power supply, but 9/10 of the projects we see making use of this processor wouldn"t last too long living off a lithium polymer cell!

Max K is out to show us that this doesn"t have to be the case, and has enlisted the lesser-seen, low-power operation modes of the ESP32, in order to allow him tocreate thisslick handheld device, based around the ESP32-WROOM module and a very nifty Memory LCD from Sharp.

The most striking feature that faces you when you first encounter this board is the huge LCD panel on the front of the device. Not only for its generous size however, the more observant would notice that the display is sat showing its frame buffer, even when the handheld is sat inactive.

You could be forgiven for thinking that there is already a disconnect between the design ethos, and the device implementation — surely an "always on" display doesn"t adhere to the ideas embodied by ultra-low-power operation?

Sitting somewhere in between conventional LCD technology and E Ink display tech, Sharp"s Memory LCD is a compelling option for those who prefer the faster update rates of LCD, but who also long for the low power operation of E Ink.

The display works using transflective technology, meaning that the pixels are themselves responsible for reflecting light, as they are in an EPD. There"s no backlight to worry about draining the battery, and there"s not much need — this type of screen is incredibly readable in even the lowest light conditions — readability in full darkness is obviously going to take a little bit of external light of course!

Even more impressive is that while these displays do indeed require a small amount of current in order to hold a static image — where as an EPD requires none — the draw is miniscule. Max K is quoting 180 uW(!) as the total power consumption figure for the device while asleep, yet holding an image on it"s display.

Normally, these modules can be found in places like some of the Garmin Fenix smartwatches, which feature color versions of the display panels, or on the development boards from companies such as Silicon Labs, where they nicely complement the ULP design of the microcontrollers they are showcasing.

There is one very neat feature to this design that has caught my eye, more so than the massive LCD panel front and center, and that is the input method available to the user.

Until it"s mentioned, you can be forgiven for overlooking the rather simplistic HMI afforded by the four-way joystick and action buttons mounted beneath the display. Instead, the GIF below appears to suggest that there is some extra magic going on when it comes to the HMI of this device...

We recently featured aproject from @martinfassini, which shares a number of design goals — ESP32-based, low-power operation being common goals of note between the two projects. Marin clued us in to the less-than-accurate operation of the internal RTC of the ESP32, noting that it can easily drift a number of minutes over the course of a day.

Utilizing the NTP (network time protocol) to synchronize the RTC of the ESP32 makes a great deal of sense — it is after all, how many of our devices keep tabs on time, and when you"re working with a networked device with web connectivity, why wouldn"t you take advantage of this atomic clock backed option?

Another design feature that"s quite interesting to see in this project, is the use of the ESP32"s ultra-low-power coprocessor. One of thequirksof the memory LCD panel technology is that while the display buffer can be treated as static, and forgo the need to be refreshed, the interface does require something in the region of a 1Hz signal to be applied to the EXTCOMM pin of the module to keep things fresh, in order to avoid issues such as display burn in.

Keeping the ESP32 main cores online just to toggle a pin at the right timing is a huge waste of energy, and would run down the devices 320mAh battery in the space of a few hours!

By offloading this task to the ULP coprocessor, the main cores can sit in standby, instead only spooling up once a minute to update the system time, and the display screen buffer itself! The downside? Programming the ULP "third core" must be done in assembler, but thankfully for Max K, Espressif has anexample programthat demonstrates the exact functionality needed — toggling a LED is done by toggling a pin, and that"s exactly what the EXTCOMM input of the display needs!

Made possible through use of a handy Arduino library (ESP32-ANCS-Notifications), this looks like something I"d be certain to use in my own projects. (That is, if I were ever to own an Apple device!) There seem to be a few low-level bugs noted by Max K with regard to the ESP32 not being able to resume WiFi after switching to BLE operation without a reboot — something necessitated by the fact that the two wireless interfaces share the same antenna.

There"s a whole wealth of interesting parts to this project, from the clever use of the ULP core of the ESP32 silicon, to the low-power focused component selection, all the way to the fully-featured firmware, packed with goodies, we highly recommend checking out theproject repositoryover on GitHub, and taking a look to see what you might like to leverage for your next low power project — of any flavor, but especially if you want to feature the ESP32!

This tutorial shows how to use the I2C LCD (Liquid Crystal Display) with the ESP32 using Arduino IDE. We’ll show you how to wire the display, install the library and try sample code to write text on the LCD: static text, and scroll long messages. You can also use this guide with the ESP8266.

Additionally, it comes with a built-in potentiometer you can use to adjust the contrast between the background and the characters on the LCD. On a “regular” LCD you need to add a potentiometer to the circuit to adjust the contrast.

Before displaying text on the LCD, you need to find the LCD I2C address. With the LCD properly wired to the ESP32, upload the following I2C Scanner sketch.

After uploading the code, open the Serial Monitor at a baud rate of 115200. Press the ESP32 EN button. The I2C address should be displayed in the Serial Monitor.

Displaying static text on the LCD is very simple. All you have to do is select where you want the characters to be displayed on the screen, and then send the message to the display.

The next two lines set the number of columns and rows of your LCD display. If you’re using a display with another size, you should modify those variables.

Then, you need to set the display address, the number of columns and number of rows. You should use the display address you’ve found in the previous step.

To display a message on the screen, first you need to set the cursor to where you want your message to be written. The following line sets the cursor to the first column, first row.

Scrolling text on the LCD is specially useful when you want to display messages longer than 16 characters. The library comes with built-in functions that allows you to scroll text. However, many people experience problems with those functions because:

The messageToScroll variable is displayed in the second row (1 corresponds to the second row), with a delay time of 250 ms (the GIF image is speed up 1.5x).

In a 16×2 LCD there are 32 blocks where you can display characters. Each block is made out of 5×8 tiny pixels. You can display custom characters by defining the state of each tiny pixel. For that, you can create a byte variable to hold  the state of each pixel.

In summary, in this tutorial we’ve shown you how to use an I2C LCD display with the ESP32/ESP8266 with Arduino IDE: how to display static text, scrolling text and custom characters. This tutorial also works with the Arduino board, you just need to change the pin assignment to use the Arduino I2C pins.

We hope you’ve found this tutorial useful. If you like ESP32 and you want to learn more, we recommend enrolling in Learn ESP32 with Arduino IDE course.