Media68·
To scroll text on a 1.54 inch 128x64 OLED display, you need to use the display's built-in hardware scrolling feature or implement software-based scrolling via the microcontroller. The 1.54 inch 128x64 oled display typically uses the SSD1306 or SH1106 driver IC, both of which support horizontal and vertical scrolling through dedicated commands. For example, with the SSD1306, you send a series of I2C or SPI commands to set the scroll direction, start page, end page, and frame rate. The display then handles the scrolling automatically, freeing up the microcontroller for other tasks. Alternatively, you can manually shift the display buffer in software, which gives you more control over text speed and direction but consumes more processing power. The key is to match the scrolling method to your application: hardware scrolling is efficient for simple left/right or up/down text movement, while software scrolling is better for custom animations or diagonal scrolling.
Let’s break down the hardware specifics. The 1.54 inch 128x64 OLED display has a resolution of 128 pixels horizontally and 64 pixels vertically, with each pixel individually addressable. The active area is about 35.0mm x 17.5mm, and the pixel pitch is roughly 0.27mm. The SSD1306 driver, which is common in these displays, includes a 128x64-bit GDDRAM (Graphics Display Data RAM) that maps directly to the screen. When you scroll text, you’re essentially moving the content within this RAM. The hardware scrolling commands for SSD1306 are defined in the datasheet: for horizontal scrolling, you use command 0x26 (right scroll) or 0x27 (left scroll), followed by parameters for dummy bytes, start page, frame rate, and end page. Frame rates are set via a 4-bit value, ranging from 2 frames per second (0x07) to 256 frames per second (0x06). A typical setting for smooth text scrolling is 64 frames per second (0x05), which gives a noticeable but not jerky motion. For vertical and horizontal scrolling combined, you use command 0x29 (vertical and right scroll) or 0x2A (vertical and left scroll), which requires additional parameters for vertical offset and scrolling rows. The SH1106 driver, on the other hand, has a slightly different command set—it uses 0x26 and 0x27 for horizontal scrolling as well, but the frame rate range is different: from 0x02 (2 fps) to 0x07 (128 fps). Both drivers support continuous scrolling until you send a stop command (0x2E).
Now, let’s talk about the actual implementation steps. If you’re using an Arduino with the Adafruit_SSD1306 library, you can enable hardware scrolling with a few lines of code. First, initialize the display with display.begin(SSD1306_SWITCHCAPVCC, 0x3C) for I2C or with the appropriate pins for SPI. Then, clear the buffer and draw your text using display.setTextSize(1) and display.println("Your text"). To start scrolling, call display.startscrollright(0x00, 0x07) for continuous right scroll across all pages (pages 0 to 7, where each page is 8 pixels tall). The parameters are the start page and end page—for a 64-pixel height, pages range from 0 to 7. If you want to scroll only the top half of the screen, set the start page to 0 and end page to 3. The frame rate is set by a third parameter in some library versions, but Adafruit’s library uses a default of 64 fps. To stop scrolling, call display.stopscroll(). For left scrolling, use display.startscrollleft(0x00, 0x07). For vertical and horizontal scrolling, you need to use display.startscrolldiagleft(0x00, 0x07) or display.startscrolldiagright(0x00, 0x07). Note that the diagonal scrolling commands in the Adafruit library are actually for vertical and horizontal combined scrolling, but they may not work on all displays due to driver differences. A more reliable approach is to send raw commands via display.ssd1306_command(). For example, to set up vertical and right scroll, you send: 0x29 (command), 0x00 (dummy byte), 0x00 (start page), 0x00 (vertical offset), 0x07 (end page), 0x01 (vertical scrolling rows), 0x2F (activate scroll). This gives you precise control over the scrolling parameters.
Let’s look at a comparison of hardware vs. software scrolling in a table to highlight the trade-offs:
| Feature | Hardware Scrolling | Software Scrolling |
|---|---|---|
| CPU usage | Minimal (display driver handles it) | High (microcontroller shifts buffer) |
| Frame rate control | Limited to preset values (2-256 fps) | Arbitrary (set by code timing) |
| Direction options | Horizontal, vertical, diagonal (limited) | Any direction (including custom paths) |
| Buffer size | Uses GDDRAM directly | Requires full 1KB buffer (128x64 bits) |
| Text quality | No tearing (hardware synchronized) | Potential tearing if not timed properly |
| Implementation complexity | Low (few commands) | Moderate to high (buffer manipulation) |
For software scrolling, the basic idea is to shift the entire display buffer by a few pixels in the desired direction, then redraw the new content. On a 128x64 display, the buffer is 1024 bytes (128 columns x 64 rows / 8 bits per byte). To scroll left, you copy each byte from column 1 to column 0, column 2 to column 1, and so on, while clearing the rightmost column. This requires a loop that iterates over all 64 rows and 128 columns. On an Arduino Uno (16 MHz), this takes about 2-3 milliseconds per frame, which limits the maximum frame rate to around 300 fps. In practice, you’ll want to add a delay to control the speed. For example, a 50ms delay gives 20 fps, which is smooth for text. You can also scroll only a portion of the screen by limiting the buffer shift to a specific area, like a text box. This is useful for multi-line displays where you want one line to scroll while others remain static. To implement this, define a clipping region in the buffer—say, rows 16 to 23 (page 2 only)—and only shift those bytes. This reduces the processing time to about 0.3 milliseconds per frame, allowing for faster scrolling in that region.
Another important factor is the display interface. The 1.54 inch 128x64 oled display supports both I2C and SPI. I2C runs at 400 kHz max, which gives a theoretical throughput of 50 KB/s, but in practice, with overhead, it’s closer to 30 KB/s. SPI, on the other hand, can run at 8 MHz or higher, giving a throughput of 1 MB/s or more. For scrolling applications, SPI is preferable because it reduces the time to update the buffer. If you’re using hardware scrolling, the interface speed doesn’t matter much because the driver handles the scrolling internally. But for software scrolling, SPI makes a big difference. For example, sending a full 1024-byte buffer over I2C takes about 34 milliseconds (1024 bytes / 30 KB/s), while over SPI it takes about 1 millisecond (1024 bytes / 1 MB/s). This means you can achieve higher frame rates with SPI. If you’re using a microcontroller like the ESP32 or STM32, you can also use DMA (Direct Memory Access) to send the buffer without CPU intervention, further improving performance.
Now, let’s discuss power consumption. The OLED display itself draws about 20-30 mA when all pixels are on, but scrolling text typically uses fewer pixels, so the draw is lower—around 10-15 mA. The microcontroller’s power consumption depends on the clock speed and the scrolling method. For hardware scrolling, the microcontroller can enter a low-power sleep mode after initiating the scroll, reducing total system power to under 50 mA. For software scrolling, the microcontroller must stay active to continuously shift the buffer, which increases power draw to 50-100 mA, depending on the MCU. If you’re building a battery-powered device, hardware scrolling is the clear winner. For example, on a 2000 mAh battery, a system using hardware scrolling could last 40 hours, while software scrolling would last only 20 hours. This is a critical consideration for wearable or portable applications.
Timing and synchronization are also crucial. When using hardware scrolling, the display driver updates the screen at a fixed rate, independent of the microcontroller. This means the text moves smoothly without jitter, even if the microcontroller is busy with other tasks. However, if you’re drawing new text while scrolling is active, you might see artifacts if the new data overlaps with the scrolling region. To avoid this, you should stop the scroll, update the buffer, and then restart the scroll. For software scrolling, you need to synchronize the buffer update with the display’s refresh rate. The OLED panel typically refreshes at 60 Hz, but the SSD1306 can be set to a higher frame rate via the display clock divide ratio command (0xD5). The default is 0x80, which gives a frame rate of about 60 Hz. If you update the buffer faster than the refresh rate, you’ll waste power without improving visual quality. A good rule of thumb is to update the buffer at 30-60 fps for smooth scrolling, which matches the display’s refresh rate.
Let’s look at a practical example with code snippets. Assume you’re using an Arduino Nano and an I2C-connected 1.54 inch 128x64 oled display. First, include the libraries: #include and #include . Define the display object: Adafruit_SSD1306 display(128, 64, &Wire, -1);. In setup, initialize the display: display.begin(SSD1306_SWITCHCAPVCC, 0x3C); and clear it. Then, draw a long string of text: display.setCursor(0, 0); display.setTextSize(1); display.println("This is a long scrolling text example for the 1.54 inch OLED display. It will scroll from right to left continuously."); display.display();. To start hardware scrolling, call display.startscrollleft(0x00, 0x07);. This will scroll the entire screen left at 64 fps. To stop it, use display.stopscroll();. If you want to scroll only part of the screen, you need to use raw commands. For example, to scroll only pages 2 to 5 (rows 16 to 47), send: display.ssd1306_command(0x2E); (stop scroll), then display.ssd1306_command(0x27); (left scroll), display.ssd1306_command(0x00); (dummy byte), display.ssd1306_command(0x02); (start page 2), display.ssd1306_command(0x05); (frame rate 64 fps), display.ssd1306_command(0x05); (end page 5), display.ssd1306_command(0x2F); (activate scroll). This gives you precise control over the scrolling region.
For software scrolling, here’s a simple implementation. Define a buffer: uint8_t buffer[1024];. In the loop, shift the buffer left by one column: for (int row = 0; row < 64; row++) { for (int col = 0; col < 127; col++) { buffer[row * 128 + col] = buffer[row * 128 + col + 1]; } buffer[row * 128 + 127] = 0x00; }. Then, draw new text at the rightmost column: display.drawChar(127, 0, 'A', SSD1306_WHITE, SSD1306_BLACK, 1);. Finally, update the display: display.display();. Add a delay: delay(50); for 20 fps. This approach works but is inefficient for long text strings. A better method is to use a circular buffer for the text and only update the visible portion. For example, store the text in a character array and track the offset. Each frame, increment the offset and redraw the text starting from that position. This reduces the buffer manipulation to just drawing the text, not shifting the entire buffer. The code would look like: static int offset = 0; display.clearDisplay(); display.setCursor(0, 0); for (int i = offset; i < offset + 16; i++) { display.print(text[i % strlen(text)]); } display.display(); offset++; delay(50);. This method is much faster and uses less memory.
Another angle to consider is the display’s temperature range and durability. The 1.54 inch 128x64 oled display operates from -40°C to 85°C, making it suitable for outdoor or industrial applications. The OLED panel itself has a contrast ratio of over 10000:1, so text is highly readable even in direct sunlight if you use a polarizer. However, scrolling text in bright sunlight might require a higher brightness setting, which increases power consumption. The typical brightness is 100 cd/m², but you can adjust it via the contrast command (0x81). A contrast value of 0x7F gives maximum brightness, while 0x00 turns the display off. For scrolling text, a contrast of 0x40 (about 50% brightness) is usually sufficient for indoor use. If you’re using the display in a dark environment, you can lower the contrast to 0x20 to save power. The display’s lifetime is rated at 50,000 hours to half brightness, so scrolling text continuously for years is feasible as long as you don’t run it at maximum brightness all the time.
Let’s also talk about common pitfalls. One issue is that hardware scrolling on the SSD1306 can glitch if you change the display buffer while scrolling is active. For example, if you call display.clearDisplay() while scrolling, the screen might show random pixels. The solution is to stop the scroll, update the buffer, and then restart. Another issue is that the vertical scrolling feature on the SH1106 driver is not as well-documented. Some SH1106 displays only support horizontal scrolling, and attempting vertical scrolling might cause the display to freeze. To test this, check the datasheet of your specific module. If you’re using a generic OLED module, it’s safer to stick with horizontal scrolling. For software scrolling, a common mistake is to update the buffer too frequently, causing the display to flicker. This happens because the display’s refresh rate is not synchronized with the buffer update. To fix this, use a timer interrupt to update the buffer at a fixed rate, or use the display’s built-in refresh rate as a reference. For example, you can read the display’s status register to check if the last frame has been sent, but this is complex. A simpler approach is to use a delay that matches the display’s refresh rate, like 16 ms for 60 fps.
Finally, let’s discuss the data rate and memory requirements. For hardware scrolling, the microcontroller only needs to send a few commands, so the code size is small—around 200 bytes of flash. For software scrolling, the buffer takes up 1024 bytes of RAM, which is significant for microcontrollers like the ATmega328P (2 KB RAM). If you’re using an Arduino Uno, you’ll have only 1 KB of free RAM after the buffer, which limits what else you can do. For more complex projects, consider using a microcontroller with more RAM, like the ESP32 (520 KB) or STM32 (64 KB+). The SPI interface also requires 4 pins (CS, DC, MOSI, SCK), while I2C uses only 2 pins (SDA, SCL). If you’re short on pins, I2C is better, but you’ll sacrifice speed. For scrolling applications, I2C is still fine for hardware scrolling, but for software scrolling, you’ll notice the difference. A good compromise is to use hardware scrolling for the main text and software scrolling for small animations, combining both methods to optimize performance and power.