Guides · 10 min read

Arduino Display Types Compared: LCD, OLED, TFT, E-Paper, 7-Seg

Arduino display types compared: 16x2 LCD, OLED, TFT, e-paper, TM1637, MAX7219 and Nextion; resolution, pins, memory, power and which one suits each project.

Arduino display types are confusing at first: the same word "display" covers a 16-character LCD, an OLED the size of a fingertip, a colourful TFT like a phone screen and an e-paper panel that keeps its image even when the power is cut. Each one differs hugely in resolution, colour, connection method, memory use and energy draw. The wrong choice turns into an Uno that runs out of RAM, a readout you can't read in sunlight or a sensor that drains its battery in a day.

In this guide we'll go through the seven display families used most in Arduino projects one by one: character LCDs (16x2 and 20x4), OLEDs (SSD1306 and SH1106), colour TFTs (ILI9341 and ST7789), e-paper, 7-segment and TM1637, MAX7219 LED matrices and Nextion touch displays. First comes a big comparison table, then a short introduction and working example code for each display, and finally a "which display for which project" table and the most common mistakes.

16x2 LCD display with I2C backpack
16x2 character LCD with I2C backpack: the cheapest and easiest-to-read Arduino display, connected with just two data wires.

Arduino display types: quick comparison table

DisplayResolutionColourInterfaceData pinsTypical currentPrice
16x2 / 20x4 character LCD16×2 or 20×4 charactersMonochrome, backlitParallel or I2C backpack6 (parallel) / 2 (I2C)20–40 mAVery cheap
OLED SSD1306 / SH1106128×64 (0.96" and 1.3")Monochrome (white, blue, yellow-blue)I2C or SPI2 (I2C) / 5 (SPI)10–25 mACheap
TFT ILI9341240×320 (2.4–3.2")65K coloursSPI or 8-bit parallel5 (SPI)50–100 mAMedium
TFT ST7789240×240, 240×320, 135×24065K coloursSPI4–530–80 mAMedium
E-paper (e-ink)200×200, 296×128, 250×122Black and white (some red/yellow)SPI6 (incl. BUSY)5–20 mA only while refreshingMedium to high
7-segment / TM16371–8 digitsSingle-colour LEDDirect or 2 wires (TM1637)8–12 / 220–80 mAVery cheap
MAX7219 LED matrix8×8, chained to 32×8 and beyondSingle-colour LED3 wires (SPI-like)320–300 mA depending on brightnessCheap
Nextion HMI320×240 up to 800×48065K colours, touchUART (TX/RX)290–500 mAExpensive

The "data pins" count in the table doesn't include power (VCC and GND). Current figures vary a lot with backlight and brightness settings; e-paper only draws current while the image changes and then uses almost nothing. Prices are ranked relative to each other: for the price of one Nextion you can buy roughly ten 16x2 LCDs.

What to look for when choosing a display

  • What will you show? Numbers only call for a 7-segment display, a few lines of text for a character LCD, graphics and icons for an OLED, and a colour interface or photos for a TFT.
  • Where will it be read? E-paper and LCDs read well in sunlight; OLEDs and TFTs struggle in bright light. In the dark, on the other hand, an OLED's black is truly black and easy on the eyes.
  • How many pins are free? I2C displays get by with two wires; a parallel LCD needs six, an SPI TFT five and e-paper six. For the pin maths, see the I2C and SPI posts.
  • Does your board have enough memory? The Uno's 2 KB of RAM barely holds an OLED buffer and can never hold a colour TFT buffer. On the ESP32 and Pico this is hardly a problem.
  • Will it run on batteries? E-paper, which holds its image without using energy, is unbeatable for sensors that run for months.
  • Voltage level: most TFT and e-paper modules use 3.3 V logic; with an Uno you may need a level shifter.
  • Library support: displays that work with popular libraries such as Adafruit GFX, U8g2, TFT_eSPI and LiquidCrystal_I2C make finding examples and fixing problems much easier.

Character LCD: 16x2 and 20x4

Character LCDs with the HD44780 controller are the classic Arduino display. Each character is made of 5×8 dots; the 16x2 model fits 16 characters on each of 2 lines and the 20x4 model 20 characters on each of 4 lines. Because the display's own controller holds the image, it uses almost no RAM on the Arduino. Direct wiring needs 6 pins (RS, E and D4–D7) plus a potentiometer for contrast; we covered this method in the 16x2 LCD parallel wiring post. With a PCF8574-based I2C backpack soldered to the back, SDA and SCL are all you need. You can define up to 8 custom characters, so you can draw a degree sign, a battery icon or accented letters. Detailed usage is in the I2C LCD display post.

C++ (Arduino IDE)
1// I2C 16x2 LCD: sıcaklık gibi bir değeri göstermek / I2C 16x2 LCD: showing a value such as temperature
2// SDA -> A4, SCL -> A5, VCC -> 5V, GND -> GND
3#include <Wire.h>
4#include <LiquidCrystal_I2C.h>
5
6LiquidCrystal_I2C lcd(0x27, 16, 2);    // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8byte degree[8] = {                      // kendi karakterin: derece işareti / custom character: degree sign
9  0b00110, 0b01001, 0b01001, 0b00110,
10  0b00000, 0b00000, 0b00000, 0b00000
11};
12
13void setup() {
14  lcd.init();
15  lcd.backlight();
16  lcd.createChar(0, degree);            // 8 özel karakterden ilki / first of 8 custom characters
17  lcd.setCursor(0, 0);
18  lcd.print("BlueGrays LCD");
19}
20
21void loop() {
22  int raw = analogRead(A0);             // A0'a bağlı bir sensör / a sensor on A0
23  float value = raw * 100.0 / 1023.0;
24  lcd.setCursor(0, 1);
25  lcd.print("Deger: ");
26  lcd.print(value, 1);
27  lcd.write(byte(0));                   // derece işaretini yaz / print the degree sign
28  lcd.print("   ");                     // eski karakterleri sil / clear leftover characters
29  delay(500);
30}
If nothing shows on an I2C LCD, first turn the blue contrast potentiometer on the back of the backpack; it often comes set wrong from the factory. If it's still blank, the address may be 0x3F instead of 0x27; an I2C scanner sketch shows the right address in seconds.

OLED: SSD1306 and SH1106

0.96 inch I2C OLED display
0.96 inch I2C OLED: 128×64 pixels that produce their own light and only 4 connection pins.

In OLED displays every pixel produces its own light; there's no backlight, the contrast is very high and the image is sharp from every angle. The 0.96 inch models usually have an SSD1306 driver, while the 1.3 inch models mostly have an SH1106. The two look the same from outside, but the SH1106's internal memory has 132 columns; on an SH1106 driven with an SSD1306 library the image shifts by two pixels and a noisy strip appears at the edge. The solution is to pick a library or constructor that matches the driver. The U8g2 library supports both and, thanks to page mode, can run on the Uno with a buffer of only 128 bytes. You'll find the basics of the SSD1306 in the OLED display (SSD1306) post.

C++ (Arduino IDE)
1// U8g2 ile 1,3" SH1106 OLED (sayfa modu, Uno'da az RAM) / 1.3" SH1106 OLED with U8g2 (page mode, low RAM on the Uno)
2// SDA -> A4, SCL -> A5. 0,96" SSD1306 için yorumdaki satırı kullan / for a 0.96" SSD1306 use the commented line
3#include <U8g2lib.h>
4#include <Wire.h>
5
6U8G2_SH1106_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
7// U8G2_SSD1306_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
8
9void setup() {
10  oled.begin();
11}
12
13void loop() {
14  int level = map(analogRead(A0), 0, 1023, 0, 120);   // A0'daki potansiyometre / potentiometer on A0
15  oled.firstPage();
16  do {                                                 // her sayfa için aynı çizim tekrarlanır / the same drawing repeats per page
17    oled.setFont(u8g2_font_ncenB08_tr);
18    oled.drawStr(0, 12, "BlueGrays OLED");
19    oled.drawFrame(0, 40, 124, 14);                    // çubuk çerçevesi / bar frame
20    oled.drawBox(2, 42, level, 10);                    // dolu çubuk / filled bar
21  } while (oled.nextPage());
22  delay(100);
23}

The _1_ in the constructor name means the screen is drawn in pages of 8 rows: the firstPage() and nextPage() loop repeats the same drawing eight times and sends one strip of the screen each time. It's a little slower, but uses 128 bytes of RAM instead of 1 KB. On the ESP32 and Pico, where memory is plentiful, you can choose the full-buffer _F_ version and get smoother animations.

Colour TFT: ILI9341 and ST7789

ILI9341 TFT colour display module
2.8 inch colour TFT with the ILI9341 driver: 240×320 pixels, 65K colours and an SPI connection; some models also have a touch panel and an SD card slot.

If you want graphics, menus, icons and colour gauges, you move on to TFT displays. Each pixel carries 16-bit (RGB565) colour, so about 65 thousand colours can be shown. The two most common drivers are the ILI9341 and the ST7789. The ILI9341 is used on 240×320 screens from 2.4 to 3.2 inches and often comes with an XPT2046 touch controller. The ST7789 shows up on 1.3 and 1.54 inch square (240×240) screens and on 135×240 screens on boards like the TTGO T-Display. They work on the Uno, but slowly: even painting the whole screen once takes visible time. On the ESP32, smooth interfaces are possible with 40 MHz SPI and optimised libraries like TFT_eSPI. For details see the ILI9341 TFT display and ST7789 TFT display posts.

FeatureILI9341ST7789
Common sizes2.4", 2.8", 3.2"1.14", 1.3", 1.54", 2.0"
Resolution240×320135×240, 240×240, 240×320
InterfaceSPI (Uno shield versions use 8-bit parallel)SPI (some models have no CS pin)
TouchXPT2046 resistive touch on most modelsUsually none
LibraryAdafruit_ILI9341, TFT_eSPIAdafruit_ST7789, TFT_eSPI
Full-screen buffer size153,600 bytes115,200 bytes (240×240)
C++ (Arduino IDE)
1// ESP32 + 2,8" ILI9341 TFT: renkli sıcaklık göstergesi / colour temperature gauge
2// SCK 18, MOSI 23, MISO 19 (isteğe bağlı / optional), CS 5, DC 16, RST 17, VCC 3V3, LED 3V3
3#include <SPI.h>
4#include <Adafruit_GFX.h>
5#include <Adafruit_ILI9341.h>
6
7const int TFT_CS = 5;
8const int TFT_DC = 16;
9const int TFT_RST = 17;
10
11Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST);    // donanım SPI (VSPI) / hardware SPI (VSPI)
12
13void setup() {
14  tft.begin(40000000);                 // 40 MHz SPI
15  tft.setRotation(1);                  // yatay 320x240 / landscape 320x240
16  tft.fillScreen(ILI9341_BLACK);
17  tft.setTextColor(ILI9341_WHITE);
18  tft.setTextSize(2);
19  tft.setCursor(10, 10);
20  tft.print("BlueGrays TFT");
21  tft.drawRect(10, 180, 300, 30, ILI9341_WHITE);  // çubuk çerçevesi / bar frame
22}
23
24void loop() {
25  float temp = 20.0 + (analogReadMilliVolts(34) / 3300.0) * 20.0;   // örnek değer / example value
26  uint16_t color = temp < 26 ? ILI9341_GREEN : (temp < 33 ? ILI9341_YELLOW : ILI9341_RED);
27
28  tft.fillRect(10, 60, 300, 80, ILI9341_BLACK);   // yalnız değişen alanı sil / clear only the changing area
29  tft.setTextSize(6);
30  tft.setTextColor(color);
31  tft.setCursor(20, 70);
32  tft.print(temp, 1);
33  tft.print(" C");
34
35  int w = (int)((temp - 20.0) / 20.0 * 296);
36  tft.fillRect(12, 182, w, 26, color);
37  tft.fillRect(12 + w, 182, 296 - w, 26, ILI9341_BLACK);
38  delay(500);
39}
Most SPI TFT modules run on 3.3 V logic and have no level shifter on board. Connecting the Uno's 5 V pins directly can damage the display over time; put series resistors or a level shifter in between. The 2.4 inch TFT shields that plug straight into the Uno use almost every pin, leaving no room for other modules. The ESP32 and Pico are 3.3 V natively, so they don't have this problem.

E-paper (e-ink) displays

E-paper is the display technology used in e-book readers. It forms the image by moving tiny black and white pigment capsules with an electric field; once the image is drawn it stays on the screen even when the power is cut. That makes it ideal, together with the ESP32's deep sleep mode, for stations that wake once an hour to update the weather and run on batteries for months. Because it looks like paper, it reads perfectly in sunlight. The downside is speed: a full refresh takes around 2 seconds and the screen flashes a few times; on models that support partial refresh this drops below half a second, but frequent partial refreshes can leave faint ghosting. It connects over SPI and needs MOSI, SCK, CS, DC, RST and a BUSY pin that signals the display is busy. The most common library is GxEPD2.

FeatureValue
Common sizes1.54" (200×200), 2.13" (250×122), 2.9" (296×128), 4.2" (400×300)
ColourBlack and white; three-colour models add red or yellow (10–15 second refresh)
Full refresh timeAbout 1–3 seconds
Partial refresh0.3–0.5 seconds on models that support it
Standby currentClose to zero while holding the image
Supply3.3 V (most modules accept 5 V through a regulator)

7-segment and TM1637 displays

TM1637 4-digit 7-segment display module
TM1637 4-digit 7-segment module: a clock display with a colon in the middle, connected with just the CLK and DIO wires.

If you only need to show numbers, 7-segment displays are still the most readable option: big, bright and visible from metres away. A single-digit display needs 8 pins for the 7 segments and the decimal point, plus a resistor for each segment; a multiplexed 4-digit display uses 12 pins. We covered this wiring and the difference between common anode and common cathode in the 7-segment display post. The easiest way out of the pin trouble is the TM1637 module: you connect the 4-digit display, which has its own driver, with just CLK and DIO and set the brightness in 8 steps from software. Although the TM1637 protocol resembles I2C, it doesn't use addresses; that's why it can go on any two digital pins and each module needs its own pair of pins.

C++ (Arduino IDE)
1// TM1637 4 haneli gösterge ile sayaç ve saat / Counter and clock with a TM1637 4-digit display
2// CLK -> D2, DIO -> D3, VCC -> 5V, GND -> GND
3#include <TM1637Display.h>
4
5TM1637Display display(2, 3);           // CLK, DIO
6unsigned long lastTick = 0;
7int seconds = 0;
8
9void setup() {
10  display.setBrightness(4);            // 0 (sönük) - 7 (en parlak) / 0 (dim) - 7 (brightest)
11  display.clear();
12}
13
14void loop() {
15  if (millis() - lastTick >= 1000) {
16    lastTick = millis();
17    seconds++;
18    int mm = (seconds / 60) % 100;
19    int ss = seconds % 60;
20    // 0b01000000: ortadaki iki nokta / the colon in the middle
21    display.showNumberDecEx(mm * 100 + ss, 0b01000000, true);
22  }
23}

MAX7219 LED matrix

MAX7219 8x32 dot matrix LED module
MAX7219 8×32 module made of four 8×8 matrices: chained on a single CS line for scrolling text, clocks and simple animations.

The MAX7219 is a chip that drives 64 LEDs (an 8×8 matrix or an 8-digit 7-segment display) on its own and talks over three wires, DIN, CLK and CS, using an SPI-like protocol. Modules can be chained; with the common 4-in-1 modules you build 32×8 scrolling text boards, and with two rows 32×16. Its brightness and readability from a distance make it ideal for message boards, scoreboards and clocks. On the Arduino the MD_Parola and MD_MAX72XX libraries are used most; details are in the MAX7219 LED matrix post. Below we drive a single 8×8 matrix with a Raspberry Pi Pico without a library, writing directly to the registers:

MicroPython
1# Raspberry Pi Pico: kütüphanesiz MAX7219 8x8 matris / MAX7219 8x8 matrix without a library
2# GP18 -> CLK, GP19 -> DIN, GP17 -> CS, VCC -> VBUS (5 V), GND -> GND
3from machine import Pin, SPI
4import time
5
6spi = SPI(0, baudrate=1_000_000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
7cs = Pin(17, Pin.OUT, value=1)
8
9def write_reg(reg, value):
10    cs.value(0)
11    spi.write(bytearray([reg, value]))     # önce yazmaç, sonra değer / register first, then value
12    cs.value(1)
13
14def init():
15    write_reg(0x0F, 0x00)    # test modu kapalı / display test off
16    write_reg(0x09, 0x00)    # kod çözme yok (matris) / no decode (matrix)
17    write_reg(0x0B, 0x07)    # 8 satırın hepsi / scan all 8 rows
18    write_reg(0x0A, 0x03)    # parlaklık 0-15 / brightness 0-15
19    write_reg(0x0C, 0x01)    # uyku modundan çık / leave shutdown mode
20
21SMILE = [0x3C, 0x42, 0xA5, 0x81, 0xA5, 0x99, 0x42, 0x3C]
22HEART = [0x00, 0x66, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18]
23
24def show(image):
25    for row in range(8):
26        write_reg(row + 1, image[row])     # satır yazmaçları 1-8 / row registers 1-8
27
28init()
29while True:
30    show(SMILE)
31    time.sleep(1)
32    show(HEART)
33    time.sleep(1)

The MAX7219's LEDs need a 5 V supply to light brightly, which is why the module's VCC goes to the Pico's VBUS pin. According to the datasheet, with a 5 V supply the inputs need at least 3.5 V to count as HIGH; the Pico's 3.3 V signals work fine on most modules, but if you see instability, add a level shifter on the DIN, CLK and CS lines. Current rises with brightness and the number of LEDs lit: with all four modules fully lit at full brightness, hundreds of milliamps can be drawn.

Nextion touch HMI displays

Nextion is a smart touch display with its own processor and memory. You design the interface with buttons, sliders and gauges on your computer in Nextion Editor by drag and drop and load it onto the display; the Arduino only sends short commands such as t0.txt="25" over the serial port (UART) and reads the touch events. That way the whole drawing load sits on the display, and even a small board like the Uno can run a 7 inch colour interface. The default speed is 9600 baud. The drawbacks are the price, a current of 90 mA even on the 2.4 inch model and up to 500 mA on the 7 inch, and the fact that the design is done in a separate program. On the Uno the hardware serial port is shared with USB, so using SoftwareSerial or choosing boards with several serial ports, like the Mega and ESP32, makes life easier.

Memory needs: which display fits on an Uno?

Most graphics display libraries first draw the image into a buffer in RAM and then send the whole thing to the screen. Buffer size = width × height × bits per pixel / 8. When you remember that the Arduino Uno has only 2 KB of RAM, part of which goes to variables, the serial port and libraries, the limit becomes obvious straight away. We've collected general fixes for memory problems in the Arduino out of memory post.

DisplayFull bufferArduino Uno (2 KB)ESP32 (520 KB) / Pico (264 KB)
16x2 LCDNot needed (the display holds it)EasyEasy
OLED 128×641,024 bytesBorderline; page mode (128 bytes) recommendedEasy
OLED 128×32512 bytesEasyEasy
E-paper 296×1284,736 bytesOnly with page-by-page drawingEasy
TFT ST7789 240×240115,200 bytesImpossible; drawn directly to the screenPossible on the ESP32, half the RAM on the Pico
TFT ILI9341 240×320153,600 bytesImpossible; drawn directly to the screenPossible, but small sprites are usually preferred

Power consumption and battery use

In a battery-powered project the display often uses more energy than the microcontroller. A 16x2 LCD's backlight alone can draw more than 20 mA; if you switch it off (lcd.noBacklight()), the display is still readable in sunlight but not in the dark. An OLED's current is proportional to the number of lit pixels: thin white text on a black background uses several times less than a white background. On TFTs the backlight LEDs are always on; controlling the backlight pin with a transistor or PWM saves a lot. E-paper draws almost no current as long as you don't change the image. To work out battery life you can use the method in the mAh post.

Which display for which project?

ProjectRecommended displayWhy?
Temperature and humidity readout16x2 I2C LCD or 0.96" OLEDCheap, two wires, a few lines of text are enough
Digital clock and countdownTM1637 or MAX7219Big, bright digits; readable from a distance
Pocket game (Pong, snake, T-Rex)128×64 OLED or 8×8 matrixFast refresh, pixel-level drawing
Weather station (battery)E-paper + ESP32 deep sleepThe image stays without using energy, readable in sunlight
Colour control panel and menuILI9341 + touch, or NextionColour, icons and touch input
Scrolling text and message boardChained MAX7219 modulesVisible from metres away, grows on a single CS
Compact ESP32 deviceST7789 1.14" or 1.3"Small, colourful and fast over SPI

Common mistakes and how to fix them

SymptomLikely causeFix
The LCD shows only solid blocksContrast not set or display not initialisedTurn the contrast potentiometer, check the address and the lcd.init() call
Image shifted with noise at the edge on a 1.3" OLEDAn SH1106 display driven with an SSD1306 libraryUse the SH1106 constructor in U8g2 or the Adafruit SH110X library
The OLED sketch uploads but the Uno freezesThe display buffer used up the RAMUse U8g2 page mode, wrap strings in F()
The TFT stays plain whiteWrong driver, wrong pins or a 5 V signalConfirm the driver (ILI9341, ST7789), check the DC and CS pins, mind the 3.3 V level
The e-paper never changesBUSY pin not connected or wrong model selectedConnect BUSY, choose the exact model class for your panel in GxEPD2
Some segments are dim on a 7-segment displayCommon anode and cathode mixed up or a resistor missingCheck the display type, put a resistor on every segment
The MAX7219 lights random LEDsLoose wire, weak supply or a 3.3 V signal at the limitShorten the wires, strengthen the 5 V supply, add a level shifter if needed
Before wiring a display into your project, run the library's own example sketch. If the example works but yours doesn't, the problem is in your code; if the example doesn't work either, focus on the wiring, the address or the driver choice. This single step turns hours of trial and error into a few minutes.

The right display depends on what your project shows, where it's read and what powers it: an LCD for text, an OLED for small graphics, a TFT or Nextion for colour interfaces, e-paper for battery devices, and 7-segment and MAX7219 for big digits. In the BlueGrays app you'll find I2C LCD, OLED games and weather display, TM1637 clock and MAX7219 dot matrix projects, step by step with circuit diagrams and code.

Frequently asked questions

Which is the best display for Arduino?

There's no single best display; the choice depends on the project. A 16x2 I2C LCD suits a few lines of text, a 0.96 inch OLED small graphics, an ILI9341 TFT a colour interface, and e-paper battery-powered devices.

Is OLED or LCD better?

An OLED is sharper, has high contrast, can draw graphics and reads perfectly in the dark. A character LCD is cheaper, reads better in sunlight and uses almost no RAM on the Arduino.

Can an Arduino Uno run a colour TFT display?

Yes, SPI TFT displays like the ILI9341 or ST7789 work with the Uno, but since there isn't enough RAM for a full-screen buffer, drawing goes directly to the screen and is slow. For smooth colour interfaces the ESP32 or Raspberry Pi Pico is a better choice.

What is the difference between the SSD1306 and the SH1106?

Both are 128×64 OLED drivers; the SSD1306 is usually found on 0.96 inch screens and the SH1106 on 1.3 inch screens. Because the SH1106's memory has 132 columns, the image shifts when it's used with an SSD1306 library; you need a suitable library such as U8g2 or Adafruit SH110X.

Does an e-paper display keep its image when the power is off?

Yes. E-paper forms the image by moving pigment capsules, and once drawn the image stays on the screen without any power. That makes it ideal for battery-powered devices that update once an hour.

Is the TM1637 I2C?

No. The TM1637's two-wire protocol looks like I2C but uses no addresses and doesn't go on an I2C bus. It connects to any two digital pins and is driven with its own library (e.g. TM1637Display); several modules each need their own pair of pins.

See all projects
Using LCD Screen with I2C
AR-32Beginner
Premium

Using LCD Screen with I2C

Give your Arduino its own screen and make it write its first message. The two-line LCD screen hooks up with just a few wires; a greeting appears on the top line, then a second message on the bottom…

4.8(53)
70
Print Message on 2x16 LCD Screen
AR-29Advanced
Premium

Print Message on 2x16 LCD Screen

Your first step to writing text on a screen. The two-line LCD screen first shows a waiting message, then writes a greeting on the top line and types a word letter by letter on the bottom line like a…

4.6(37)
51
Paddle Ball Game - SSD1306
AR-86Intermediate
Premium

Paddle Ball Game - SSD1306

A ball, two paddles and you: you play table tennis, one of the very first video games, on a small OLED screen.

4.5(47)
65
OLED T-Rex Run: Arduino Dinosaur Game
AR-87Advanced
Premium

OLED T-Rex Run: Arduino Dinosaur Game

The dinosaur game that pops up when your internet goes down, now on your desk: the dinosaur runs across the small OLED screen, cacti come at you, and you jump with a single button.

4.7(33)
53
ESP32 HTTPClient + Weather API (with SSD1306 OLED Display)
ES-32Advanced
Premium

ESP32 HTTPClient + Weather API (with SSD1306 OLED Display)

In this project the ESP32 makes a REST API call over the internet to a weather API (wttr.in) using HTTPClient.h. Unlike the I2C LCD version, it uses an SSD1306 OLED (128×64) display, with large text and vector icons for a richer look. Seven weather icons (sunny, rainy, snowy and more) are drawn on the fly, with no bitmap files.

4.3(10)
22
ESP32 TM1637 4-Digit 7-Segment Display
ES-23Intermediate
Premium

ESP32 TM1637 4-Digit 7-Segment Display

We are controlling a 4-digit 7-segment display module with a TM1637 driver using an ESP32. Using just 2 GPIO pins (CLK and DIO), we run a counter from 0 to 9999, adjust the brightness level, and display the colon (:) character in clock format. Thanks to the TM1637Display library, controlling numbers, hex values, segments, and strings is very easy.

4.7(20)
32
Dot Matrix Clock and Calendar (MAX7219, DS1307)
AR-84Intermediate
Premium

Dot Matrix Clock and Calendar (MAX7219, DS1307)

A glowing board for your desk or wall that shows the time and date in scrolling text.

5.0(37)
59
Digital Clock with 4-Digit 7-Segment Display
AR-48Intermediate
Premium

Digital Clock with 4-Digit 7-Segment Display

A four-digit glowing digital clock, much like the one on a kitchen oven. The DS1302 clock module keeps the time, and every second the Arduino reads the hours and minutes and shows them on the…

4.8(56)
73