ESP32-S3 RGB LED Matrix Project 2

ESP32-S3 RGB LED Matrix Project 2 - Scrolling Text

Project 2 – Text Scroll on ESP32-S3 RGB LED Matrix

In this project we turn the ESP32-S3 RGB LED Matrix into a tiny text banner. A short message (for example Robojax) scrolls across the 8×8 RGB display, and you can easily change the text, color, brightness, and scroll speed directly in the code. This is very useful for simple notifications, name tags, or small status messages.

All six projects in this series are demonstrated and explained in a single YouTube video. The same video is embedded on this page, so you can see exactly how the text scroll looks in real time and how each setting affects the animation. The complete code for this project is loaded automatically below the article, and you can purchase the ESP32-S3 RGB LED Matrix module from affiliate stores listed under the code section.

This project builds on the basics of Project 1 (moving dot and color control) and adds text rendering and scrolling using the NeoMatrix library.

ESP32-S3 RGB LED Matrix Module Overview

The hardware is the same across all six projects: an ESP32-S3 microcontroller with Wi-Fi and Bluetooth, an 8×8 RGB LED matrix (64 addressable RGB LEDs), a QMI8658C accelerometer, USB port, and accessible IO pins.:contentReference[oaicite:0]{index=0}

ESP32-S3 – main CPU with Wi-Fi/BLE for advanced projects.
8×8 RGB matrix – 64 RGB LEDs for icons, text, and animations.
QMI8658C accelerometer – used in later projects for tilt and orientation.
USB port – used for power and programming via Arduino IDE.
Exposed pins – let you use the board like a normal ESP32 for other IO.
Boot / Reset buttons – for firmware upload and restarting sketches.

In Project 2 we mainly focus on the matrix and the NeoMatrix text functions. The accelerometer is not used yet, but the same board will handle all the later interaction and game projects as well.

Projects Covered in the Video (Timestamps)

The video that goes with this article covers all six projects. The approximate timestamps are:

00:00 – Introduction
02:01 – Installing ESP32 boards
03:32 – Installing libraries
05:32 – Project 1: Moving Dot
11:11 – Project 2: Text Scroll
12:59 – Project 3: HTTP Text
16:41 – Project 4: Tilt Dot
18:55 – Project 5: Arrow Up
20:02 – Project 6: Target Game

You are encouraged to watch the video while reading this article. It shows the text scrolling live on the LED matrix and walks through all the steps in the Arduino IDE.

Installing ESP32 Boards in Arduino IDE

Before running the text scroll code, make sure the ESP32 support is installed in your Arduino IDE:

Open File > Preferences and add the ESP32 boards URL to “Additional Boards Manager URLs”.
Go to Tools > Board > Boards Manager…, search for ESP32, and install the official ESP32 package.
Select your ESP32-S3 RGB Matrix board from Tools > Board.
Connect the module via USB and choose the correct COM/serial port under Tools > Port.

If the board type or port is not correct, the sketch will not upload.

Installing NeoMatrix and Required Libraries

The text scroll is implemented using Adafruit NeoMatrix and its dependencies. In the video, they are installed via Library Manager.

You will need:

Adafruit NeoMatrix
Adafruit NeoPixel
Adafruit GFX Library

Open Sketch > Include Library > Manage Libraries….
Search for Adafruit NeoMatrix and click Install.
When prompted, allow it to install Adafruit GFX and Adafruit NeoPixel as dependencies.

If installation is successful, you should see example sketches under File > Examples > Adafruit NeoMatrix and File > Examples > Adafruit NeoPixel.

Project 2 – Code Settings (Text Scroll)

The full text scroll sketch is automatically loaded below this article on the website. Here we focus only on the configuration values you will probably want to edit: pin, matrix size, brightness, text string, color, scroll speed, and optional direction.

All snippets below are taken from the configuration section at the top of the sketch so you can quickly adjust the behavior without touching the main logic.

Matrix Pin and Size

Just like Project 1, the RGB matrix is connected to GPIO 14 and contains 64 LEDs (8×8). Make sure these two lines match your module:


 // Pin connected to 8×8 RGB matrix const int MATRIX_PIN = 14; // must be 14 on this module // Matrix size (width and height) const int MATRIX_WIDTH = 8; const int MATRIX_HEIGHT = 8;

If you copy an example from the NeoMatrix library, it might use a different pin or size; always change them to match this board.

Brightness of the Text

Brightness is typically controlled with a value between 0 and 255, where 0 is off and 255 is maximum brightness. A moderate value is usually enough:


// Overall matrix brightness (0–255) uint8_t matrixBrightness = 40; // comfortable indoor brightness // In setup(): matrix.setBrightness(matrixBrightness);

If you use the panel in a bright environment or for a short time, you can increase this value, but avoid going too high if you are close to the display.

Text to Scroll

The actual message is stored as a string. In the video, the example text is Robojax. You can change it to any short label or message you like:


 // Text to scroll on the 8×8 matrix const char scrollText[] = "Robojax"; // change this to your message

Keep in mind that this is only an 8×8 matrix, so very long messages will take longer to scroll and may become hard to read.

Text Color (RGB Values)

The color of the scrolling text is set by red, green, and blue components (0–255). For example, pure red is (255, 0, 0), pure green is (0, 255, 0), and pure blue is (0, 0, 255). In the sketch you will see something like:


 // Text color (R, G, B) uint8_t textRed = 255; // red component uint8_t textGreen = 0; // green component uint8_t textBlue = 0; // blue component

To change the color:

Yellow: textRed = 255; textGreen = 255; textBlue = 0;
Cyan: textRed = 0; textGreen = 255; textBlue = 255;
White: textRed = 255; textGreen = 255; textBlue = 255;

The video also demonstrates using an online color picker to find the RGB values and then entering them in the code.:contentReference[oaicite:1]{index=1}

Scroll Speed (Delay Between Frames)

Scroll speed is controlled by a delay value in milliseconds between each update step. A smaller value makes the text move faster; a larger value slows it down. In the sketch, you should find a variable like:


// Delay between scroll steps (in milliseconds) int scrollDelayMs = 50; // smaller = faster, larger = slower

Examples:

scrollDelayMs = 20; → fast scrolling.
scrollDelayMs = 50; → medium speed (similar to the video).
scrollDelayMs = 100; or more → slow, easy-to-read scroll.

Inside the loop(), this value is used in a delay(scrollDelayMs); call after each redraw of the text position.

Scroll Direction (Optional)

In the “basic text scroll” project we usually scroll to the left, but it is useful to define a symbolic direction variable so you can experiment with other directions later (left, right, up, down).

One common pattern is:


 // Scroll direction selector // 0 = left, 1 = right, 2 = up, 3 = down int scrollDirection = 0; // default: scroll to the left

The main loop then checks scrollDirection and moves the text in the chosen direction. For Project 2 you can leave it at 0 (left), but if you extend the sketch later you can add conditions such as:


 if (scrollDirection == 0) { // move text left } else if (scrollDirection == 1) { // move text right } else if (scrollDirection == 2) { // move text up } else if (scrollDirection == 3) { // move text down }

For this article we only document the setting. The full implementation is part of the code loaded beneath the article.

Summary

Project 2 turns your ESP32-S3 RGB LED Matrix into a simple but eye-catching text display. By editing just a few variables at the top of the code, you can quickly change:

Which message is displayed (scrollText).
The color of the text (textRed, textGreen, textBlue).
The brightness of the matrix (matrixBrightness).
The speed of scrolling (scrollDelayMs).
The direction of scrolling (scrollDirection, if you choose to use it).

The full sketch for this project is available below this article (loaded automatically by the website). For detailed step-by-step configuration and a live demonstration of the scrolling text in action, make sure to watch the corresponding section of the video. If you like the project and want to build it yourself, you can also purchase the ESP32-S3 RGB LED Matrix module from the affiliate links listed beneath the code.