### VirtualDisplay Buffer Examples

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Demonstrates the creation and usage of various `VirtualDisplay` subclasses for in-memory text buffering. Includes pre-built sizes and custom configurations.

```cpp
#include <MycilaEasyDisplay.h>

// Pre-built virtual display sizes for 128x64 OLEDs
Mycila::VirtualDisplay7x25 v7x25;  // 7 lines × 25 chars, font: 5x8
Mycila::VirtualDisplay6x21 v6x21;  // 6 lines × 21 chars, font: 6x10
Mycila::VirtualDisplay5x21 v5x21;  // 5 lines × 21 chars, font: 6x12
Mycila::VirtualDisplay5x18 v5x18;  // 5 lines × 18 chars, font: 7x13
Mycila::VirtualDisplay5x16 v5x16;  // 5 lines × 16 chars, font: 8x13
Mycila::VirtualDisplay4x14 v4x14;  // 4 lines × 14 chars, font: 9x15
Mycila::VirtualDisplay3x13 v3x13;  // 3 lines × 13 chars, font: 10x20

// Blank display (renders as a cleared screen)
Mycila::VirtualDisplayBlank blank;

// Fully custom: 4 lines, 10 chars wide, offset 2, custom font
Mycila::VirtualDisplay custom(4, 10, 2, u8g2_font_8x13_tf);

Mycila::EasyDisplay display;

void setup() {
  v7x25.printf("% -25.25s\n", "1234567890123456789012345");
  v7x25.printf("Temp: %5.1f C\n", 23.4f);
  v7x25.printf("Humidity: %3d%%\n", 65);
  v7x25.clear(); // Wipe buffer content without deallocating
  v7x25.printf("After clear\n");

  display.begin();
  display.setActive(true);
  display.display(v7x25);
}

void loop() {}
```

--------------------------------

### Initialize and Print to Default Display

Source: https://github.com/mathieucarbou/mycilaeasydisplay/blob/main/README.md

Basic setup for the EasyDisplay library. Initializes the display and prints formatted text to the default home display. Ensure the display is active before printing.

```c++
Mycila::EasyDisplay display;
    
display.begin();
display.setActive(true);

display.home.printf("%-6.6s %-3.3s %-8.8s %02ld:%02ld\n", "YaSolR", "Pro", "v1.2.3", random(10, 30), random(10, 30));
display.home.printf("%-17.17s %-5.5s C\n", WiFi.localIP().toString().c_str(), "24.05");
display.home.printf("G: %5ld W      R: %4ld W\n", random(1000, 2000), random(1000, 2000));
display.home.printf("1\n");
display.home.printf("2\n");
display.home.printf("3\n");
display.home.printf("4\n");
display.home.printf("5\n");
    
display.display();
```

--------------------------------

### Setup and Display Multiple Virtual Displays

Source: https://github.com/mathieucarbou/mycilaeasydisplay/blob/main/README.md

Demonstrates creating and cycling through various virtual displays with different dimensions and content. Includes necessary includes for EasyDisplay and WiFi. Ensure serial communication is initialized for debugging.

```c++
#include <MycilaEasyDisplay.h>
#include <WiFi.h>

Mycila::EasyDisplay display;

Mycila::VirtualDisplay7x25 virtual1;
Mysila::VirtualDisplay6x21 virtual2;
Mysila::VirtualDisplay5x18 virtual3;
Mysila::VirtualDisplay5x16 virtual4;
Mysila::VirtualDisplay4x14 virtual5;
Mysila::VirtualDisplay3x13 virtual6;

void setup() {
  Serial.begin(115200);
  while (!Serial)
    continue;

  virtual1.println("1234567890123456789012345");
  virtual1.println("V1 2 vgpjy");
  virtual1.println("V1 3 vgpjy");
  virtual1.println("V1 4 vgpjy");
  virtual1.println("V1 5 vgpjy");
  virtual1.println("V1 6 vgpjy");
  virtual1.println("V1 7 vgpjy");

  virtual2.println("123456789012345678901");
  virtual2.println("V2 2 vgpjy");
  virtual2.println("V2 3 vgpjy");
  virtual2.println("V2 4 vgpjy");
  virtual2.println("V2 5 vgpjy");
  virtual2.println("V2 6 vgpjy");

  virtual3.println("123456789012345678");
  virtual3.println("V3 2 vgpjy");
  virtual3.println("V3 3 vgpjy");
  virtual3.println("V3 4 vgpjy");
  virtual3.println("V3 5 vgpjy");

  virtual4.println("1234567890123456");
  virtual4.println("V4 2 vgpjy");
  virtual4.println("V4 3 vgpjy");
  virtual4.println("V4 4 vgpjy");
  virtual4.println("V4 5 vgpjy");

  virtual5.println("12345678901234");
  virtual5.println("V5 2 vgpjy");
  virtual5.println("V5 3 vgpjy");
  virtual5.println("V5 4 vgpjy");

  virtual6.println("1234567890123");
  virtual6.println("V6 2 vgpjy");
  virtual6.println("V6 3 vgpjy");

  // use default pins
  display.begin();
  display.setActive(true);
}

void loop() {
  display.display(virtual1);
  delay(1500);

  display.display(virtual2);
  delay(1500);

  display.display(virtual3);
  delay(1500);

  display.display(virtual4);
  delay(1500);

  display.display(virtual5);
  delay(1500);

  display.display(virtual6);
  delay(1500);
}
```

--------------------------------

### Initialize and Run Carousel Display

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Demonstrates how to initialize the EasyDisplay, set up multiple virtual displays with rotation times and chaining, and start the carousel engine. The carousel is manually restarted if it reaches the end.

```cpp
#include <MycilaEasyDisplay.h>

Mycila::EasyDisplay display;
Mycila::VirtualDisplay7x25 v1, v2, v3;

void setup() {
  v1.printf("Screen A\n"); v1.setDisplayTime(1000); v1.setNext(&v2);
  v2.printf("Screen B\n"); v2.setDisplayTime(2000); v2.setNext(&v3);
  v3.printf("Screen C\n"); v3.setDisplayTime(3000);
  // Linear (ends) — no setNext on v3

  display.begin();
  display.setActive(true);

  Mycila::EasyDisplay::CarouselState state = display.carousel(v1);
  // state == CAROUSEL_STARTED, v1 is now showing
}

void loop() {
  Mycila::EasyDisplay::CarouselState state = display.carousel();

  if (state == Mycila::EasyDisplay::CAROUSEL_NEXT) {
    Serial.printf("Switched to: %p\n", display.getCurrentDisplay());
  } else if (state == Mycila::EasyDisplay::CAROUSEL_ENDED) {
    Serial.println("Carousel finished — restarting");
    display.carousel(v1); // Restart manually
  }
}
```

--------------------------------

### Initialize EasyDisplay with Default or Custom Settings

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Initializes the OLED hardware using default I2C pins or custom pins with optional rotation. The display starts in power-save mode and must be activated.

```cpp
#include <MycilaEasyDisplay.h>
#include <WiFi.h>

Mycila::EasyDisplay display;

void setup() {
  Serial.begin(115200);

  // Default: SH1106, default I2C SCL/SDA pins, no rotation
  display.begin();

  // Or fully customized: SSD1306, clock=22, data=21, rotated 180°
  // display.begin(Mycila::EasyDisplayType::SSD1306, 22, 21, 180);

  // Supported rotations: 0, 90, 180, 270
  // Supported types: SH1106, SH1107, SSD1306

  display.setActive(true); // Turn on the display after init
}

void loop() {
  display.home.printf("IP: %-17.17s\n", WiFi.localIP().toString().c_str());
  display.home.printf("Uptime: %lu s\n", millis() / 1000);
  display.display(); // Push home buffer to screen
  delay(1000);
}
```

--------------------------------

### EasyDisplay::begin

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Initializes the OLED hardware on a specified I2C clock/data pin pair with an optional rotation. Supports SH1106, SH1107, and SSD1306 display controllers. Calling `begin()` again after initialization has no effect. After `begin()`, the display starts in power-save (off) mode and must be activated with `setActive(true)`.

```APIDOC
## EasyDisplay::begin — Initialize the physical display

### Description
Initializes the OLED hardware on a specified I2C clock/data pin pair with an optional rotation. Supports SH1106, SH1107, and SSD1306 display controllers. Calling `begin()` again after initialization has no effect. After `begin()`, the display starts in power-save (off) mode and must be activated with `setActive(true)`.

### Method
`EasyDisplay::begin(displayType, sdaPin, sclPin, rotation)`

### Parameters
#### Path Parameters
- `displayType` (Mycila::EasyDisplayType) - Optional - The type of display controller (SH1106, SH1107, SSD1306). Defaults to SH1106.
- `sdaPin` (int) - Optional - The GPIO pin for the I2C data line (SDA). Defaults to the library's default.
- `sclPin` (int) - Optional - The GPIO pin for the I2C clock line (SCL). Defaults to the library's default.
- `rotation` (int) - Optional - The display rotation in degrees (0, 90, 180, 270). Defaults to 0.

### Request Example
```cpp
#include <MycilaEasyDisplay.h>
#include <WiFi.h>

Mycila::EasyDisplay display;

void setup() {
  Serial.begin(115200);

  // Default: SH1106, default I2C SCL/SDA pins, no rotation
  display.begin();

  // Or fully customized: SSD1306, clock=22, data=21, rotated 180°
  // display.begin(Mycila::EasyDisplayType::SSD1306, 22, 21, 180);

  // Supported rotations: 0, 90, 180, 270
  // Supported types: SH1106, SH1107, SSD1306

  display.setActive(true); // Turn on the display after init
}

void loop() {
  display.home.printf("IP: %-17.17s\n", WiFi.localIP().toString().c_str());
  display.home.printf("Uptime: %lu s\n", millis() / 1000);
  display.display(); // Push home buffer to screen
  delay(1000);
}
```
```

--------------------------------

### Utilize Multiple Virtual Displays

Source: https://github.com/mathieucarbou/mycilaeasydisplay/blob/main/docs/index.md

Demonstrates setting up and cycling through various virtual displays with different dimensions and content. Requires including the library and WiFi.h. Ensure serial communication is initialized.

```c++
#include <MycilaEasyDisplay.h>
#include <WiFi.h>

Mycila::EasyDisplay display;

Mycila::VirtualDisplay7x25 virtual1;
Mycila::VirtualDisplay6x21 virtual2;
Mycila::VirtualDisplay5x18 virtual3;
Mycila::VirtualDisplay5x16 virtual4;
Mycila::VirtualDisplay4x14 virtual5;
Mycila::VirtualDisplay3x13 virtual6;

void setup() {
  Serial.begin(115200);
  while (!Serial)
    continue;

  virtual1.println("1234567890123456789012345");
  virtual1.println("V1 2 vgpjy");
  virtual1.println("V1 3 vgpjy");
  virtual1.println("V1 4 vgpjy");
  virtual1.println("V1 5 vgpjy");
  virtual1.println("V1 6 vgpjy");
  virtual1.println("V1 7 vgpjy");

  virtual2.println("123456789012345678901");
  virtual2.println("V2 2 vgpjy");
  virtual2.println("V2 3 vgpjy");
  virtual2.println("V2 4 vgpjy");
  virtual2.println("V2 5 vgpjy");
  virtual2.println("V2 6 vgpjy");

  virtual3.println("123456789012345678");
  virtual3.println("V3 2 vgpjy");
  virtual3.println("V3 3 vgpjy");
  virtual3.println("V3 4 vgpjy");
  virtual3.println("V3 5 vgpjy");

  virtual4.println("1234567890123456");
  virtual4.println("V4 2 vgpjy");
  virtual4.println("V4 3 vgpjy");
  virtual4.println("V4 4 vgpjy");
  virtual4.println("V4 5 vgpjy");

  virtual5.println("12345678901234");
  virtual5.println("V5 2 vgpjy");
  virtual5.println("V5 3 vgpjy");
  virtual5.println("V5 4 vgpjy");

  virtual6.println("1234567890123");
  virtual6.println("V6 2 vgpjy");
  virtual6.println("V6 3 vgpjy");

  // use default pins
  display.begin();
  display.setActive(true);
}

void loop() {
  display.display(virtual1);
  delay(1500);

  display.display(virtual2);
  delay(1500);

  display.display(virtual3);
  delay(1500);

  display.display(virtual4);
  delay(1500);

  display.display(virtual5);
  delay(1500);

  display.display(virtual6);
  delay(1500);
}
```

--------------------------------

### Initialize and Display Simple Text

Source: https://github.com/mathieucarbou/mycilaeasydisplay/blob/main/docs/index.md

Basic usage for initializing the display and printing formatted text to the home screen. Ensure the display is active before attempting to print.

```c++
    Mycila::EasyDisplay display;
    
    display.begin();
    display.setActive(true);

    display.home.printf("%-6.6s %-3.3s %-8.8s %02ld:%02ld\n", "YaSolR", "Pro", "v1.2.3", random(10, 30), random(10, 30));
    display.home.printf("%-17.17s %-5.5s C\n", WiFi.localIP().toString().c_str(), "24.05");
    display.home.printf("G: %5ld W      R: %4ld W\n", random(1000, 2000), random(1000, 2000));
    display.home.printf("1\n");
    display.home.printf("2\n");
    display.home.printf("3\n");
    display.home.printf("4\n");
    display.home.printf("5\n");
    
    display.display();
```

--------------------------------

### Configure and Use Carousel Mode

Source: https://github.com/mathieucarbou/mycilaeasydisplay/blob/main/README.md

Sets up multiple virtual displays to cycle through automatically with specified display times. The `carousel` function initiates the sequence, and `display.carousel()` in the loop advances it. The home display is skipped in this configuration.

```c++
#include <MycilaEasyDisplay.h>
#include <WiFi.h>

Mysila::EasyDisplay display;

Mysila::VirtualDisplay7x25 virtual1;
Mysila::VirtualDisplay6x21 virtual2;
Mysila::VirtualDisplay5x18 virtual3;

void setup() {
  Serial.begin(115200);
  while (!Serial)
    continue;

  // carousel loop: home -> virtual1 -> virtual2 -> virtual3 -> home -> ...
  // home is skipped

  virtual1.println("1 SEC");
  virtual1.println("V1 2 vgpjy");
  virtual1.println("V1 3 vgpjy");
  virtual1.println("V1 4 vgpjy");
  virtual1.println("V1 5 vgpjy");
  virtual1.println("V1 6 vgpjy");
  virtual1.println("V1 7 vgpjy");
  virtual1.setDisplayTime(1000);
  virtual1.setPrev(&display.home);

  virtual2.println("2 SEC");
  virtual2.println("V2 2 vgpjy");
  virtual2.println("V2 3 vgpjy");
  virtual2.println("V2 4 vgpjy");
  virtual2.println("V2 5 vgpjy");
  virtual2.println("V2 6 vgpjy");
  virtual2.setDisplayTime(2000);
  virtual2.setPrev(&virtual1);

  virtual3.println("3 SEC");
  virtual3.println("V3 2 vgpjy");
  virtual3.println("V3 3 vgpjy");
  virtual3.println("V3 4 vgpjy");
  virtual3.println("V3 5 vgpjy");
  virtual3.setDisplayTime(3000);
  virtual3.setPrev(&virtual2);

  display.home.println("HOME IS SKIPPED");
  display.home.setDisplayTime(0); // will be skipped by the carousel
  display.home.setPrev(&virtual3);

  // use default pins
  display.begin();
  display.setActive(true);
  display.carousel(virtual3);
}

void loop() {
  display.carousel();
}
```

--------------------------------

### Configure Display Geometry and Font via Macros

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Illustrates how to override default display dimensions (lines, line length, line height offset) and font at compile time using preprocessor macros. These macros should be defined before including the library header or set via build flags.

```ini
; platformio.ini example
[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
lib_deps = mathieucarbou/MycilaEasyDisplay
build_flags =
  -DMYCILA_DISPLAY_LINES=5
  -DMYCILA_DISPLAY_LINE_LENGTH=18
  -DMYCILA_DISPLAY_LINE_HEIGHT_OFFSET=1
  ; Font macro requires the U8g2 font symbol, set in code instead for type-safety
```

```cpp
// Or defined before the include in a single translation unit:
#define MYCILA_DISPLAY_LINES        5
#define MYCILA_DISPLAY_LINE_LENGTH  18
#define MYCILA_DISPLAY_LINE_HEIGHT_OFFSET 1
#define MYCILA_DISPLAY_FONT         u8g2_font_7x13_tf
#include <MycilaEasyDisplay.h>

// EasyDisplay constructed with these defaults
Mycila::EasyDisplay display; // 5 lines × 18 chars, 7x13 font
```

--------------------------------

### Create a Custom Virtual Display

Source: https://github.com/mathieucarbou/mycilaeasydisplay/blob/main/README.md

Instantiates a custom virtual display with specified dimensions (rows, columns) and a chosen font. This allows for flexible display configurations beyond the predefined types.

```c++
Mycila::VirtualDisplay virtual(4, 10, 2, u8g2_font_8x13_tf);
```

--------------------------------

### Direct U8g2 Access for Advanced Graphics

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Shows how to obtain a reference to the underlying U8G2 instance from EasyDisplay for performing advanced drawing operations like text, lines, and bitmaps not covered by the text-buffer API.

```cpp
#include <MycilaEasyDisplay.h>

Mycila::EasyDisplay display;

void setup() {
  display.begin();
  display.setActive(true);

  // Access raw U8g2 for direct graphics drawing
  U8G2& u8g2 = display.u8g2();

  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.drawStr(0, 20, "Hello!");
  u8g2.drawLine(0, 25, 128, 25);
  u8g2.sendBuffer();
}

void loop() {}
```

--------------------------------

### Render Virtual Display to Screen

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Renders the contents of a VirtualDisplay buffer to the physical OLED screen. Use `display()` for the home buffer or `display(vDisplay)` for a specific VirtualDisplay instance.

```cpp
#include <MycilaEasyDisplay.h>

Mycila::EasyDisplay display;
Mycila::VirtualDisplay7x25 statusScreen;
Mycila::VirtualDisplay4x14 alertScreen;

void setup() {
  display.begin();
  display.setActive(true);

  // Populate the home buffer
  display.home.printf("Home Screen\n");
  display.home.printf("Line 2\n");

  // Populate a virtual buffer
  statusScreen.printf("Status: OK\n");
  statusScreen.printf("Temp: 23.4 C\n");

  // Populate an alert buffer
  alertScreen.printf("!! ALERT !!\n");
  alertScreen.printf("Overheat!\n");
}

void loop() {
  // Render home display
  display.display();          // same as display.display(display.home)
  delay(1000);

  // Render status screen
  display.display(statusScreen);
  delay(1000);

  // Render alert screen
  display.display(alertScreen);
  delay(1000);
}
```

--------------------------------

### VirtualDisplay

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Base class for in-memory text buffers, extending U8G2LOG for printf/println functionality. Supports pre-built subclasses for common OLED layouts or custom configurations.

```APIDOC
## VirtualDisplay — In-memory text buffer

`VirtualDisplay` is the base class for all text buffers. It extends `U8G2LOG` to provide `printf`/`println` text printing. Each instance holds a character buffer sized by `lines × lineLength`. Pre-built typed subclasses cover common 128×64 OLED layouts; a custom instance can be created by specifying lines, columns, line height offset, and a U8g2 font pointer directly.

### Constructors
#### Default (Pre-built subclasses)
```cpp
Mycila::VirtualDisplay7x25 v7x25;  // 7 lines × 25 chars, font: 5x8
Mycila::VirtualDisplay6x21 v6x21;  // 6 lines × 21 chars, font: 6x10
Mycila::VirtualDisplay5x21 v5x21;  // 5 lines × 21 chars, font: 6x12
Mycila::VirtualDisplay5x18 v5x18;  // 5 lines × 18 chars, font: 7x13
Mycila::VirtualDisplay5x16 v5x16;  // 5 lines × 16 chars, font: 8x13
Mycila::VirtualDisplay4x14 v4x14;  // 4 lines × 14 chars, font: 9x15
Mycila::VirtualDisplay3x13 v3x13;  // 3 lines × 13 chars, font: 10x20
Mycila::VirtualDisplayBlank blank; // Blank display
```

#### Custom
```cpp
Mycila::VirtualDisplay(uint8_t lines, uint8_t lineLength, uint8_t lineOffset, const uint8_t *font);
```

### Methods
- **printf(const char *fmt, ...)**: Formats and prints text to the buffer.
- **println(const char *fmt, ...)**: Formats and prints text followed by a newline.
- **clear()**: Wipes the buffer content without deallocating memory.
```

--------------------------------

### Control Display Power with setActive and isActive

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Turns the OLED screen on or off using `setActive()`. `isActive()` checks the current power state. Useful for waking the display upon user interaction.

```cpp
#include <MycilaEasyDisplay.h>

Mycila::EasyDisplay display;

void setup() {
  display.begin();
  display.setActive(true);  // Turn screen ON
}

void loop() {
  // Simulate a button wake-up
  bool buttonPressed = (millis() % 10000 < 100); // "pressed" briefly every 10 s

  if (buttonPressed && !display.isActive()) {
    display.setActive(true);  // Wake the screen
    Serial.println("Display woken up");
  }

  display.home.printf("Active: %s\n", display.isActive() ? "YES" : "NO");
  display.display();
  delay(500);
}
```

--------------------------------

### Implement Carousel Mode for Displays

Source: https://github.com/mathieucarbou/mycilaeasydisplay/blob/main/docs/index.md

Configures and activates a carousel mode where displays automatically cycle through each other with specified display times. The home display can be skipped by setting its display time to 0. Requires including the library and WiFi.h.

```c++
#include <MycilaEasyDisplay.h>
#include <WiFi.h>

Mycila::EasyDisplay display;

Mycila::VirtualDisplay7x25 virtual1;
Mycila::VirtualDisplay6x21 virtual2;
Mycila::VirtualDisplay5x18 virtual3;

void setup() {
  Serial.begin(115200);
  while (!Serial)
    continue;

  // carousel loop: home -> virtual1 -> virtual2 -> virtual3 -> home -> ...
  // home is skipped

  virtual1.println("1 SEC");
  virtual1.println("V1 2 vgpjy");
  virtual1.println("V1 3 vgpjy");
  virtual1.println("V1 4 vgpjy");
  virtual1.println("V1 5 vgpjy");
  virtual1.println("V1 6 vgpjy");
  virtual1.println("V1 7 vgpjy");
  virtual1.setDisplayTime(1000);
  virtual1.setPrev(&display.home);

  virtual2.println("2 SEC");
  virtual2.println("V2 2 vgpjy");
  virtual2.println("V2 3 vgpjy");
  virtual2.println("V2 4 vgpjy");
  virtual2.println("V2 5 vgpjy");
  virtual2.println("V2 6 vgpjy");
  virtual2.setDisplayTime(2000);
  virtual2.setPrev(&virtual1);

  virtual3.println("3 SEC");
  virtual3.println("V3 2 vgpjy");
  virtual3.println("V3 3 vgpjy");
  virtual3.println("V3 4 vgpjy");
  virtual3.println("V3 5 vgpjy");
  virtual3.setDisplayTime(3000);
  virtual3.setPrev(&virtual2);

  display.home.println("HOME IS SKIPPED");
  display.home.setDisplayTime(0); // will be skipped by the carousel
  display.home.setPrev(&virtual3);

  // use default pins
  display.begin();
  display.setActive(true);
  display.carousel(virtual3);
}

void loop() {
  display.carousel();
}
```

--------------------------------

### Configure VirtualDisplay Carousel Chain

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Configures a VirtualDisplay for automatic carousel participation. Use `setDisplayTime` to set visibility duration and `setNext`/`setPrev` to link displays into a chain.

```cpp
#include <MycilaEasyDisplay.h>

Mycila::EasyDisplay display;
Mycila::VirtualDisplay7x25 page1;
Mycila::VirtualDisplay6x21 page2;
Mycila::VirtualDisplay5x18 page3;

void setup() {
  page1.printf("Page 1\n");
  page1.setDisplayTime(2000);  // Show for 2 s

  page2.printf("Page 2\n");
  page2.setDisplayTime(3000);  // Show for 3 s

  page3.printf("Page 3\n");
  page3.setDisplayTime(1500);  // Show for 1.5 s

  // Build a linear chain: page1 -> page2 -> page3 (ends after page3)
  page1.setNext(&page2);
  page2.setNext(&page3);
  // page3.next == nullptr => carousel ends after page3

  // Or create a looping chain via setPrev on page1
  // page1.setPrev(&page3); // page3 -> page1 -> page2 -> page3 -> ...

  // home has no displayTime — will be skipped
  display.home.setDisplayTime(0);
  display.home.setNext(&page1);

  display.begin();
  display.setActive(true);
  display.carousel(display.home); // Start from home (skipped → lands on page1)
}

void loop() {
  display.carousel(); // Must be called in loop to advance the carousel
}
```

--------------------------------

### Configure Automatic Screen Timeout with setPowerSaveDelay

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Sets an automatic power-save timer in seconds. The screen turns off after the specified inactivity period. Set to 0 to disable auto power-save. `setActive(true)` resets the timer.

```cpp
#include <MycilaEasyDisplay.h>
#include <WiFi.h>

Mycila::EasyDisplay display;

void setup() {
  display.begin();
  display.setActive(true);

  // Auto power-save after 5 seconds of no activity
  display.setPowerSaveDelay(5);
}

void loop() {
  display.home.printf("% -6.6s % -3.3s % -8.8s %02ld:%02ld\n",
    "YaSolR", "Pro", "v1.2.3", random(10, 30), random(10, 30));
  display.home.printf("% -17.17s % -5.5s C\n",
    WiFi.localIP().toString().c_str(), "24.05");
  display.home.printf("G: %5ld W      R: %4ld W\n",
    random(1000, 2000), random(1000, 2000));
  display.display();
  delay(2000);

  // Wake the display back up if a user interaction is detected
  if (!display.isActive()) {
    display.setActive(true); // Resets the 5-second countdown
  }
}
```

--------------------------------

### EasyDisplay::display

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Renders the contents of a VirtualDisplay buffer or the home buffer to the physical OLED screen. The overload without arguments renders the home buffer.

```APIDOC
## EasyDisplay::display — Render a virtual display to the screen

Pushes the contents of a `VirtualDisplay` buffer (or the built-in `home` buffer) to the physical OLED screen. The overload `display()` with no arguments renders `home`. The overload `display(vDisplay)` renders any `VirtualDisplay` instance.

### Method
```cpp
void display();
void display(VirtualDisplay& vDisplay);
```

### Parameters
#### display(vDisplay)
- **vDisplay** (`VirtualDisplay&`) - A reference to the `VirtualDisplay` instance to render.
```

--------------------------------

### VirtualDisplay::setDisplayTime, setNext, setPrev

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Configures a VirtualDisplay for participation in an automatic carousel. setDisplayTime sets visibility duration, while setNext and setPrev link displays into a chain.

```APIDOC
## VirtualDisplay::setDisplayTime / setNext / setPrev — Carousel chain configuration

These methods configure a `VirtualDisplay` for participation in an automatic carousel. `setDisplayTime(ms)` sets how many milliseconds the display should remain visible (0 = skipped by carousel). `setNext()` and `setPrev()` link displays into a doubly-linked chain that the carousel engine traverses. Setting either end to a display already in the chain creates a loop.

### Methods
- **setDisplayTime(uint32_t ms)**: Sets the display duration in milliseconds. A value of 0 skips this display in the carousel.
- **setNext(VirtualDisplay *next)**: Sets the next display in the carousel chain.
- **setPrev(VirtualDisplay *prev)**: Sets the previous display in the carousel chain.
```

--------------------------------

### Clear Physical Display

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Clears the physical display output and resets the display pointer. Virtual display buffers remain unaffected. Call `clearDisplay()` to blank the OLED panel.

```cpp
#include <MycilaEasyDisplay.h>

Mycila::EasyDisplay display;

void setup() {
  display.begin();
  display.setActive(true);

  display.home.printf("Hello!\n");
  display.display();
  delay(2000);

  display.clearDisplay(); // Blank the OLED
  delay(1000);

  display.home.printf("Back again\n");
  display.display();
}

void loop() {}
```

--------------------------------

### EasyDisplay::clearDisplay

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Clears the physical display output and resets the tracked current display pointer. The virtual display buffers remain unaffected.

```APIDOC
## EasyDisplay::clearDisplay — Blank the screen

Clears the physical display output and resets the tracked current display pointer. The virtual display buffers are unaffected — only the OLED panel is blanked.

### Method
```cpp
void clearDisplay();
```
```

--------------------------------

### EasyDisplay::setActive / isActive

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Turns the OLED screen on or off. When set to inactive (`false`), the U8g2 power-save mode is engaged and the panel draws minimal current. When re-activated, the display immediately comes back on. Use `isActive()` to check the current state.

```APIDOC
## EasyDisplay::setActive / isActive — Power save control

### Description
Turns the OLED screen on or off. When set to inactive (`false`), the U8g2 power-save mode is engaged and the panel draws minimal current. When re-activated, the display immediately comes back on. Use `isActive()` to check the current state.

### Method
`void setActive(bool active)`
`bool isActive() const`

### Parameters
#### `setActive` Parameters
- `active` (bool) - `true` to turn the screen on, `false` to turn it off.

### Request Example
```cpp
#include <MycilaEasyDisplay.h>

Mycila::EasyDisplay display;

void setup() {
  display.begin();
  display.setActive(true);  // Turn screen ON
}

void loop() {
  // Simulate a button wake-up
  bool buttonPressed = (millis() % 10000 < 100); // "pressed" briefly every 10 s

  if (buttonPressed && !display.isActive()) {
    display.setActive(true);  // Wake the screen
    Serial.println("Display woken up");
  }

  display.home.printf("Active: %s\n", display.isActive() ? "YES" : "NO");
  display.display();
  delay(500);
}
```
```

--------------------------------

### EasyDisplay::setPowerSaveDelay

Source: https://context7.com/mathieucarbou/mycilaeasydisplay/llms.txt

Configures an automatic power-save timer (in seconds). After the specified number of seconds without a call to `setActive(true)`, the screen turns itself off automatically. Set to `0` to disable auto power-save. Calling `setActive(true)` resets the countdown.

```APIDOC
## EasyDisplay::setPowerSaveDelay — Automatic screen timeout

### Description
Configures an automatic power-save timer (in seconds). After the specified number of seconds without a call to `setActive(true)`, the screen turns itself off automatically. Set to `0` to disable auto power-save. Calling `setActive(true)` resets the countdown.

### Method
`void setPowerSaveDelay(uint16_t seconds)`

### Parameters
#### `setPowerSaveDelay` Parameters
- `seconds` (uint16_t) - The number of seconds of inactivity before the screen automatically turns off. Set to `0` to disable.

### Request Example
```cpp
#include <MycilaEasyDisplay.h>
#include <WiFi.h>

Mycila::EasyDisplay display;

void setup() {
  display.begin();
  display.setActive(true);

  // Auto power-save after 5 seconds of no activity
  display.setPowerSaveDelay(5);
}

void loop() {
  display.home.printf("% -6.6s % -3.3s % -8.8s %02ld:%02ld\n",
    "YaSolR", "Pro", "v1.2.3", random(10, 30), random(10, 30));
  display.home.printf("% -17.17s % -5.5s C\n",
    WiFi.localIP().toString().c_str(), "24.05");
  display.home.printf("G: %5ld W      R: %4ld W\n",
    random(1000, 2000), random(1000, 2000));
  display.display();
  delay(2000);

  // Wake the display back up if a user interaction is detected
  if (!display.isActive()) {
    display.setActive(true); // Resets the 5-second countdown
  }
}
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.