GxEPD2

https://github.com/zinggjm/gxepd2
Admin
GxEPD2 is an Arduino display library for SPI e-paper displays from Dalian Good Display and Waveshare...
Tokens:47,936
Snippets:680
Trust Score:7.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### 7-Color Display Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example code for initializing and drawing on a 5.65-inch 7-color display.

```cpp
// 5.65" 7-color display
GxEPD2_565c epd(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
GxEPD2_7C<GxEPD2_565c, 448> display(epd);

void setup() {
  display.init(0);
  
  display.fillScreen(GxEPD_WHITE);
  display.fillRect(10, 10, 100, 100, GxEPD_BLACK);
  display.fillRect(120, 10, 100, 100, GxEPD_RED);
  display.fillRect(230, 10, 100, 100, GxEPD_BLUE);
  display.display();
}
```

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

### RAM Optimization Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of initializing the display with minimum page height for very limited RAM systems (Arduino UNO with 2KB SRAM).

```cpp
// Minimum page height (8 pixels)
GxEPD2_BW<GxEPD2_213, 8> display(epd);  // Only 104 bytes per page

void setup() {
  display.init(0);
  display.drawPaged(drawContent, nullptr);
}

void drawContent(const void* param) {
  display.fillScreen(GxEPD_WHITE);
  display.setTextColor(GxEPD_BLACK);
  display.setCursor(10, 10);
  display.println("Low RAM mode");
}
```

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

### Library Includes

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of necessary library includes for different display types.

```cpp
#include <GxEPD2_BW.h>     // For black/white displays
#include <GxEPD2_3C.h>     // For 3-color displays
#include <GxEPD2_4C.h>     // For 4-color displays
#include <GxEPD2_7C.h>     // For 7-color displays
#include <GxEPD2_GFX.h>    // For GFX base class (if ENABLE_GxEPD2_GFX=1)
```

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

### Paged Drawing Configuration Examples

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Examples demonstrating how to configure the page height for paged drawing based on available RAM, ranging from limited to ample memory systems.

```cpp
// For systems with limited RAM (Arduino UNO with 2KB SRAM)
// 8-pixel page height = 200 pixels wide × 8 pixels / 8 bits per byte = 200 bytes per page
GxEPD2_BW<GxEPD2_290, 8> display(epd);  // 37 pages

// For systems with moderate RAM (Arduino with 8KB SRAM)
GxEPD2_BW<GxEPD2_290, 64> display(epd);  // 5 pages

// For systems with ample RAM (ESP32 with ~320KB SRAM)
GxEPD2_BW<GxEPD2_290, 296> display(epd);  // Full-screen buffer (1 page)

// For systems with ample RAM (full 7.5" display buffer)
GxEPD2_BW<GxEPD2_750, 480> display(epd);  // Full screen: 800×480 = 48KB
```

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

### Screen Fading/Image Persistence Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example demonstrating how to perform periodic full refreshes to prevent image burn-in.

```cpp
unsigned long lastFullRefresh = 0;
const unsigned long FULL_REFRESH_INTERVAL = 3600000;  // 1 hour

void loop() {
  unsigned long now = millis();
  
  if (now - lastFullRefresh > FULL_REFRESH_INTERVAL) {
    // Force full refresh to clear any image persistence
    display.epd2.refresh(false);  // Full refresh
    lastFullRefresh = now;
  }
  
  // Normal updates
  updateContent();
}
```

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

### Rotation Configuration

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of setting the display rotation and mirroring.

```cpp
void setup() {
  display.init(0);
  
  // Set rotation (0, 1, 2, or 3)
  display.setRotation(1);  // 90 degrees
  
  // Mirror display (flip left-right)
  display.mirror(true);
}
```

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

### 4-Color Display Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example code for initializing and drawing on a 2.13-inch 4-color display.

```cpp
// 2.13" 4-color display
GxEPD2_213c_GDEY0213F51 epd(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
GxEPD2_4C<GxEPD2_213c_GDEY0213F51, 250> display(epd);

void setup() {
  display.init(0);
  
  display.fillScreen(GxEPD_WHITE);
  display.fillRect(10, 10, 50, 50, GxEPD_BLACK);
  display.fillRect(70, 10, 50, 50, GxEPD_RED);
  display.display();
}
```

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

### 3-Color Display Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example code for initializing and drawing on a 1.54-inch 3-color (red) display.

```cpp
// 1.54" 3-color (red) display
GxEPD2_154c epd(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
GxEPD2_3C<GxEPD2_154c, 200> display(epd);

void setup() {
  display.init(0);
  
  display.fillScreen(GxEPD_WHITE);
  display.fillRect(10, 10, 90, 90, GxEPD_BLACK);
  display.fillRect(110, 10, 90, 90, GxEPD_RED);
  display.display();
}
```

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

### Display Not Responding Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of reinitializing the display with extended parameters to resolve unresponsiveness.

```cpp
void setup() {
  // Try reinitializing with extended parameters
  display.end();        // Release SPI
  delay(500);
  
  // Reinitialize with diagnostic output and longer reset
  display.init(115200, true, 20, false);  // 20ms reset, standard mode
}
```

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

### Diagnostics Output Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of enabling detailed serial output for debugging display initialization.

```cpp
void setup() {
  Serial.begin(115200);
  delay(500);
  
  // Initialize with full diagnostics
  display.init(115200);  // Non-zero = enable serial output
  
  // Check display properties
  Serial.print("Width: ");  Serial.println(display.WIDTH);
  Serial.print("Height: "); Serial.println(display.HEIGHT);
  Serial.print("Has Partial: "); Serial.println(display.epd2.hasPartialUpdate);
  Serial.print("Has Fast Partial: "); Serial.println(display.epd2.hasFastPartialUpdate);
}
```

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

### pages() Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_BW.md

Example of getting the number of pages for the display.

```cpp
uint16_t numPages = display.pages();
```

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

### Basic Display Initialization

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of basic display initialization with serial diagnostics enabled and a simple 'Hello World' message displayed.

```cpp
void setup() {
  Serial.begin(115200);
  delay(100);
  
  display.init(115200);  // Initialize with serial diagnostics  
  
  display.fillScreen(GxEPD_WHITE);
  display.setTextColor(GxEPD_BLACK);
  display.setCursor(10, 10);
  display.println("Hello World");
  display.display();
}

void loop() {
  delay(10000);
}
```

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

### init (basic) Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_BW.md

Example of initializing the display with optional serial diagnostics.

```cpp
display.init(115200);
```

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

### Enable Serial Output for Diagnostics

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example showing how to enable serial diagnostics during display initialization by providing a valid baud rate.

```cpp
void setup() {
  Serial.begin(115200);
  
  // Enable serial diagnostics at 115200 baud
  display.init(115200);
  
  // Will print timing and status information to Serial monitor
}
```

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

### Usage Example for init (extended)

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_EPD.md

Example of full initialization with custom reset timing.

```cpp
// Full initialization with custom reset timing
display.init(115200, true, 2, false); // Waveshare "clever" reset circuit
```

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

### Constructor Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_7C.md

Example of how to instantiate the GxEPD2_7C class.

```cpp
GxEPD2_565c epd(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
GxEPD2_7C<GxEPD2_565c, 448> display(epd);
```

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

### Custom Reset Duration Configuration

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example showing how to set a custom reset duration in milliseconds for the display initialization.

```cpp
// Custom reset duration (in milliseconds)
display.init(0, true, 20, false);  // 20ms reset pulse
```

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

### Usage Example for mirror

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_BW.md

Example demonstrating how to enable and disable horizontal mirroring.

```cpp
display.mirror(true);  // Mirror left-right
display.mirror(false); // Disable mirroring
```

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

### Usage Example for Constructor

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_EPD.md

Example of initializing a driver instance for a specific panel type.

```cpp
// Initialize a driver instance for a specific panel type
// Constructor is typically called with hardware-specific parameters
GxEPD2_154 display(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
```

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

### Automatic Power Off (Default)

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example demonstrating automatic power off after displaying content.

```cpp
void setup() {
  display.init(0);
  
  // Display content and automatically power off
  display.display(false);  // Full refresh + power off
}
```

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

### Advanced Initialization with Custom SPI

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of initializing the display with custom SPI settings, including a specific speed and a custom reset duration for 'clever' reset circuits.

```cpp
void setup() {
  // Configure custom SPI speed (4 MHz)
  SPISettings spi_settings(4000000, MSBFIRST, SPI_MODE0);
  
  // Select custom SPI and settings
  display.epd2.selectSPI(SPI, spi_settings);
  
  // Initialize with custom reset duration for "clever" reset circuit
  display.init(115200, true, 2, false);
  
  display.fillScreen(GxEPD_WHITE);
  display.display();
}
```

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

### Manual Power Management

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of manual power management, including refreshing the screen and powering off separately.

```cpp
void setup() {
  display.init(0);
}

void refreshScreen() {
  // Write to controller without power change
  display.epd2.writeImage(bitmap_data, 0, 0, 200, 200);
  
  // Refresh with custom power control
  display.epd2.refresh(false);  // Full refresh, then powerOff called separately
  display.epd2.powerOff();
}
```

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

### Constructor Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_3C.md

Example of how to instantiate the GxEPD2_3C class.

```cpp
GxEPD2_154c epd(CS, DC, RST, BUSY);
GxEPD2_3C<GxEPD2_154c, 200> display(epd);
```

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

### SPI Speed Configuration

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of configuring a higher SPI speed for faster displays.

```cpp
void setup() {
  // Try higher SPI speed for larger displays
  SPISettings spi_settings(8000000, MSBFIRST, SPI_MODE0);  // 8 MHz
  display.epd2.selectSPI(SPI, spi_settings);
  
  display.init(0);
}
```

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

### Standard Reset Behavior

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example demonstrating the default reset behavior, which uses a 10ms reset duration and standard RST pin handling.

```cpp
// Default: reset_duration = 10ms, standard RST handling
display.init(115200, true);
```

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

### Constructor Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_4C.md

Example demonstrating how to initialize a GxEPD2_4C display object with a specific driver instance.

```cpp
GxEPD2_213c_GDEY0213F51 epd(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
GxEPD2_4C<GxEPD2_213c_GDEY0213F51, 250> display(epd);
```

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

### Template Instantiation Examples

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_7C.md

Various examples of template instantiation for different 7-color display models.

```cpp
// 5.65" 7-color 600x448 (with paging)
GxEPD2_7C<GxEPD2_565c, 224> display_565c(epd_565c);

// 5.65" 7-color 600x448 GDEP0565D90
GxEPD2_7C<GxEPD2_565c_GDEP0565D90, 224> display_565c_d90(epd_565c_d90);

// 7.3" 7-color 800x480 ACeP (with paging)
GxEPD2_7C<GxEPD2_730c_ACeP_730, 240> display_730c(epd_730c);

// 7.3" 7-color 800x480 GDEY073D46
GxEPD2_7C<GxEPD2_730c_GDEY073D46, 240> display_730c_d46(epd_730c_d46);

// 7.3" 7-color 800x480 GDEP073E01
GxEPD2_7C<GxEPD2_730c_GDEP073E01, 240> display_730c_e01(epd_730c_e01);
```

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

### Constructor Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_BW.md

Example of initializing GxEPD2_BW for full-frame buffer or paged drawing.

```cpp
GxEPD2_154 epd(CS, DC, RST, BUSY);
GxEPD2_BW<GxEPD2_154, 200> display(epd); // Full-frame buffer

// Or with paged drawing:
GxEPD2_BW<GxEPD2_290, 128> display(epd); // 128-pixel page height
```

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

### Waveshare "Clever" Reset Circuit Configuration

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example for configuring the reset behavior for Waveshare boards with a "clever" reset circuit, using a shorter reset pulse.

```cpp
// Shorter reset pulse for "clever" reset circuit
display.init(115200, true, 2, false);
```

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

### Usage Example for init (basic)

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_EPD.md

Examples of enabling or disabling serial diagnostics.

```cpp
display.init(115200); // Enable serial diagnostics at 115200 baud
display.init(0);      // Disable diagnostics
```

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

### Template Instantiation Examples

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_4C.md

Examples of how to instantiate the GxEPD2_4C template for various 4-color display sizes.

```cpp
// 2.13" 4-color 122x250
GxEPD2_4C<GxEPD2_213c_GDEY0213F51, 250> display_213c(epd_213c);

// 2.9" 4-color 168x384 (with paging)
GxEPD2_4C<GxEPD2_290c_GDEY029F51H, 128> display_290c(epd_290c);

// 3.0" 4-color 168x400
GxEPD2_4C<GxEPD2_300c, 400> display_300c(epd_300c);

// 3.5" 4-color 184x384
GxEPD2_4C<GxEPD2_350c_GDEM035F51, 384> display_350c(epd_350c);

// 4.2" 4-color 400x300
GxEPD2_4C<GxEPD2_420c_GDEY0420F51, 300> display_420c(epd_420c);

// 5.79" 4-color 792x272
GxEPD2_4C<GxEPD2_579c_GDEY0579F51, 272> display_579c(epd_579c);

// 7.5" 4-color 800x480 (with paging)
GxEPD2_4C<GxEPD2_750c_GDEM075F52, 240> display_750c(epd_750c);
```

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

### Usage Example for clearScreen

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_EPD.md

Example of clearing the screen to white.

```cpp
display.clearScreen(0xFF); // Clear to white
```

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

### SPI Configuration Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/index.md

Example of configuring SPI settings for the E-Paper display.

```cpp
SPISettings spi_settings(4000000, MSBFIRST, SPI_MODE0);  // 4 MHz
display.epd2.selectSPI(SPI, spi_settings);
display.init(0);
```

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

### Usage Example for end

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_EPD.md

Example of calling the end method.

```cpp
display.end();
```

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

### writeImage dual-channel usage example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_3C.md

Example demonstrating how to use the writeImage function for dual-channel bitmaps.

```cpp
const uint8_t black_data[] = { ... };  // Black pixels
const uint8_t red_data[] = { ... };    // Red pixels

display.writeImage(black_data, red_data, 0, 0, 200, 200);
```

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

### Partial Window Update Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/index.md

Example of updating a specific portion of the E-Paper display.

```cpp
display.setPartialWindow(0, 0, 100, 100);
display.fillScreen(GxEPD_WHITE);
display.drawRect(10, 10, 80, 80, GxEPD_BLACK);
display.display();
```

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

### Drawing Methods Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_7C.md

Example demonstrating the use of Adafruit_GFX drawing methods with GxEPD2_7C.

```cpp
display.fillScreen(GxEPD_WHITE);
display.fillRect(10, 10, 80, 80, GxEPD_BLACK);
display.fillRect(100, 10, 80, 80, GxEPD_RED);
display.fillRect(190, 10, 80, 80, GxEPD_GREEN);
display.fillRect(280, 10, 80, 80, GxEPD_BLUE);
display.display();
```

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

### fillScreen Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_3C.md

Example of filling the entire screen buffer with a specific color.

```cpp
display.fillScreen(GxEPD_WHITE);
```

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

### Multi-Display Support Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_GFX.md

An example illustrating how to write application code once that works for different display panels.

```cpp
#ifdef DISPLAY_TYPE_SMALL
  GxEPD2_BW<GxEPD2_154, 200> display(epd);
#elif DISPLAY_TYPE_MEDIUM
  GxEPD2_BW<GxEPD2_290, 128> display(epd);
#else
  GxEPD2_BW<GxEPD2_420, 300> display(epd);
#endif

void setup() {
  display.init(0);
  display.fillScreen(GxEPD_WHITE);
  display.display();
}

void loop() {
  // Same code works for all display sizes
  display.fillScreen(GxEPD_WHITE);
  display.setTextColor(GxEPD_BLACK);
  display.setCursor(10, 10);
  display.println("Same Code");
  display.display();
  delay(10000);
}
```

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

### Usage Example for drawPaged

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_BW.md

Example demonstrating how to use the drawPaged function with a custom drawing callback.

```cpp
void drawContent(const void* param) {
  display.fillScreen(GxEPD_WHITE);
  display.setTextColor(GxEPD_BLACK);
  display.setCursor(10, 10);
  display.println("Paged drawing");
}

display.drawPaged(drawContent, nullptr);
```

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

### Complete Minimal Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

A basic Arduino sketch demonstrating the initialization and display of text on an e-paper screen.

```cpp
#include <GxEPD2_BW.h>

#define CS_PIN    10
#define DC_PIN     8
#define RST_PIN    9
#define BUSY_PIN   7

GxEPD2_290 epd(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
GxEPD2_BW<GxEPD2_290, 128> display(epd);

void setup() {
  display.init(0);
  display.firstPage();
  do {
    display.fillScreen(GxEPD_WHITE);
    display.setTextColor(GxEPD_BLACK);
    display.setCursor(20, 100);
    display.println("GxEPD2 Demo");
  } while (display.nextPage());
}

void loop() {
  delay(10000);
}
```

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

### Accessing Driver-Specific Features Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_GFX.md

An example showing how to access driver-specific features while maintaining polymorphism.

```cpp
void updateDisplay(GxEPD2_GFX& display) {
  // Generic graphics operations
  display.fillScreen(GxEPD_WHITE);
  display.setTextColor(GxEPD_BLACK);
  display.setCursor(10, 10);
  display.println("Update");
  
  // Access driver-specific capabilities
  const GxEPD2_EPD& epd = display.getEPD();
  if (epd.hasPartialUpdate) {
    display.refresh(true);  // Partial refresh
  } else {
    display.refresh(false); // Full refresh
  }
}
```

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

### Performance Hint: Using Partial Updates

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Example of using partial updates for faster screen refreshes when available.

```cpp
// Use partial updates when available
if (display.epd2.hasPartialUpdate) {
  display.display(true);  // 300ms vs 1000ms
}
```

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

### Most Common Usage Pattern

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Demonstrates the basic setup and usage of the GxEPD2 library for displaying 'Hello' on an e-paper display.

```cpp
#include <GxEPD2_BW.h>

// Create driver (GPIO pins vary by hardware)
GxEPD2_290 epd(10, 8, 9, 7);  // CS, DC, RST, BUSY

// Create display with page height for paging
GxEPD2_BW<GxEPD2_290, 128> display(epd);

void setup() {
  display.init(0);            // Initialize
  display.fillScreen(GxEPD_WHITE);
  display.setTextColor(GxEPD_BLACK);
  display.setCursor(10, 10);
  display.println("Hello");
  display.display();          // Show on screen
}

void loop() {
  delay(10000);
}
```

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

### Initialization

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Shows various ways to initialize the GxEPD2 display, including basic, with serial diagnostics, extended parameters, and custom SPI speed, as well as how to clean up.

```cpp
// Basic
display.init(0);

// With serial diagnostics
display.init(115200);

// Extended (reset duration, power control)
display.init(115200, true, 10, false);

// Custom SPI speed
SPISettings spi(4000000, MSBFIRST, SPI_MODE0);
display.epd2.selectSPI(SPI, spi);
display.init(0);

// Clean up
display.end();
```

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

### Deep Sleep / Hibernate Mode

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Code examples for putting the display into deep sleep/hibernate mode and waking it up.

```cpp
void goToSleep() {
  // Put display into minimum power consumption mode
  if (display.epd2.panel != -1) {  // RST pin configured
    display.hibernate();
  }
  
  // Board enters sleep mode
  esp_deep_sleep_start();  // ESP32
  // or LowPower.powerDown() for Arduino
}

void wakeUp() {
  // Reset needed to wake from hibernate
  
  // Re-initialize (without initial full refresh if power was maintained)
  display.init(0, false);  // false = not initial power-up
}
```

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

### Refresh Screen

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Provides examples for different screen refresh modes: full refresh, partial refresh, partial window refresh, and manual refresh control.

```cpp
// Full refresh
display.display();
display.display(false);

// Partial refresh (if supported)
display.display(true);

// Partial window
display.setPartialWindow(0, 0, 100, 100);
display.display();

// Manual refresh control
display.epd2.refresh(false);  // Full
display.epd2.refresh(true);   // Partial
display.epd2.refresh(x, y, w, h);  // Region
```

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

### Partial Window Operations

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of setting a partial window for faster updates in a specific region of the display.

```cpp
void setup() {
  display.init(0);
  
  // Set partial window for faster updates in specific region
  display.setPartialWindow(0, 0, 100, 100);
  
  display.firstPage();
  do {
    display.fillScreen(GxEPD_WHITE);
    display.drawRect(10, 10, 80, 80, GxEPD_BLACK);
  } while (display.nextPage());
}
```

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

### Dual SPI Bus Configuration

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of configuring the display to use an alternative SPI bus (HSPI on ESP32).

```cpp
void setup() {
  // Configure for HSPI (alternative SPI bus on ESP32)
  SPISettings spi_settings(4000000, MSBFIRST, SPI_MODE0);
  display.epd2.selectSPI(SPI1, spi_settings);  // Use SPI1 instead of SPI
  
  display.init(0);
}
```

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

### Busy Wait Callback

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of registering a callback function to be called during the busy wait period, useful for watchdog timers.

```cpp
volatile uint32_t lastPetTime = 0;

void petWatchdog(const void* param) {
  // Called repeatedly during busy wait
  uint32_t now = millis();
  if (now - lastPetTime > 1000) {
    lastPetTime = now;
    // Pet watchdog or perform periodic task
  }
}

void setup() {
  display.init(0);
  
  // Register callback
  display.epd2.setBusyCallback(petWatchdog, nullptr);
  
  // Display updates will now call petWatchdog() while waiting
  display.display();
}
```

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

### Disable Serial Output for Diagnostics

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example showing how to disable all serial diagnostic output by passing a bitrate of 0 to the init function.

```cpp
void setup() {
  // Disable all serial output (diagnostic_bitrate = 0)
  display.init(0);
}
```

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

### Window Operations

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Shows how to set the display window to full screen or a partial area, and how to display a region from a buffer.

```cpp
// Set to full screen
display.setFullWindow();

// Set to partial window
display.setPartialWindow(x, y, width, height);

// Display region from buffer
display.displayWindow(x, y, width, height);
```

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

### ESP8266 with 2.13" Display Pin Configuration

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example pin definitions and display object instantiation for an ESP8266 connected to a 2.13-inch e-paper display.

```cpp
#define CS_PIN    15  // GPIO15 (D8)
#define DC_PIN     4   // GPIO4 (D2)
#define RST_PIN    2   // GPIO2 (D4)
#define BUSY_PIN   5   // GPIO5 (D1)

GxEPD2_213 epd(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
GxEPD2_BW<GxEPD2_213, 250> display(epd);
```

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

### ESP32 with 4.2" Display Pin Configuration

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example pin definitions and display object instantiation for an ESP32 connected to a 4.2-inch e-paper display.

```cpp
#define CS_PIN    5   // GPIO5
#define DC_PIN    17  // GPIO17
#define RST_PIN   16  // GPIO16
#define BUSY_PIN   4   // GPIO4

GxEPD2_420 epd(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
GxEPD2_BW<GxEPD2_420, 300> display(epd);
```

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

### Disable Partial Updates (Force Full Refresh)

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example of how to disable fast partial updates to force a full refresh on displays that support partial updates.

```cpp
void setup() {
  display.init(0);
  
  // Force full refresh even on partial update capable displays
  if (display.epd2.hasFastPartialUpdate) {
    display.epd2.hasFastPartialUpdate = false;  // Disable fast partial
  }
}
```

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

### Power Management

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Explains how to manage display power, including powering off for reduced current, entering deep sleep for minimum current, and re-initializing after sleep.

```cpp
// Power off (reduces current)
display.epd2.powerOff();

// Deep sleep (minimum current)
display.hibernate();

// With sleep wake
display.epd2.powerOff();
delay(30000);

// Re-init after sleep (without full refresh)
display.init(0, false);  // false = not initial power-up
```

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

### Arduino UNO with Waveshare Display Pin Configuration

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example pin definitions and display object instantiation for an Arduino UNO connected to a Waveshare e-paper display.

```cpp
#define CS_PIN    10  // D10
#define DC_PIN     8  // D8
#define RST_PIN    9  // D9
#define BUSY_PIN   7  // D7

GxEPD2_290 epd(CS_PIN, DC_PIN, RST_PIN, BUSY_PIN);
GxEPD2_BW<GxEPD2_290, 128> display(epd);
```

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

### Template Instantiation Examples

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_BW.md

Examples of how to instantiate the GxEPD2_BW template class for different display sizes and operation modes (full-screen buffer vs. paged operation).

```cpp
// Full-screen buffer (page_height = display height)
GxEPD2_BW<GxEPD2_154, 200> display_154(epd_154);    // 1.54" 200x200
GxEPD2_BW<GxEPD2_290, 296> display_290(epd_290);    // 2.9" 128x296
GxEPD2_BW<GxEPD2_420, 300> display_420(epd_420);    // 4.2" 400x300

// Paged operation (page_height < display height)
GxEPD2_BW<GxEPD2_154, 100> display_154_paged(epd_154);  // 2 pages
GxEPD2_BW<GxEPD2_290, 128> display_290_paged(epd_290);  // 3 pages
GxEPD2_BW<GxEPD2_750, 256> display_750_paged(epd_750);  // 2 pages
```

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

### GxEPD2 Example Initialization for Waveshare Boards

Source: https://github.com/zinggjm/gxepd2/blob/master/README.md

This code snippet shows an example initialization for Waveshare boards with a 'clever' reset circuit, specifying parameters for baud rate, reset pin usage, and other options.

```c++
init(115200, true, 2, false)
```

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

### 7.5" B/W Display Initialization

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Initializes a 7.5-inch black and white e-paper display.

```cpp
GxEPD2_750 epd(CS, DC, RST, BUSY);
GxEPD2_BW<GxEPD2_750, 256> display(epd);  // 800x480, 2 pages
```

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

### 5V-Safe RST Mode Configuration (ESP8266 with Level Converters)

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/configuration.md

Example for configuring the reset behavior for 5V-safe operation on ESP8266 using level converters, employing a pulldown-based RST handling.

```cpp
// Use pulldown-based RST handling for 5V-safe operation
display.init(115200, true, 10, true);
```

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

### Common Task: Show Image from SD Card

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Placeholder function to draw an image loaded from an SD card.

```cpp
void drawSDImage(const char* filename) {
  // Load bitmap data from SD
  // ...
  display.drawImage(bitmapBuffer, 0, 0, WIDTH, HEIGHT);
  display.display();
}
```

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

### hibernate Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_EPD.md

Example of entering deep sleep mode.

```cpp
if (display.panel != -1) { // RST pin configured
  display.hibernate();
}
```

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

### powerOff Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_EPD.md

Example of turning off panel driving voltages.

```cpp
display.powerOff();
```

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

### Page Height Selection for RAM Optimization

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Demonstrates selecting different page heights for memory optimization based on available RAM.

```cpp
// Ultra-low RAM (Arduino UNO, 8-pixel pages)
GxEPD2_BW<GxEPD2_290, 8> display(epd);      // ~40 bytes/page

// Low RAM (Arduino MEGA, 64-pixel pages)
GxEPD2_BW<GxEPD2_290, 64> display(epd);     // ~320 bytes/page

// Moderate RAM (Arduino Due, 128-pixel pages)
GxEPD2_BW<GxEPD2_290, 128> display(epd);    // ~640 bytes/page

// Full buffer (ESP32, 296-pixel pages)
GxEPD2_BW<GxEPD2_290, 296> display(epd);    // ~2368 bytes total
```

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

### Adafruit_GFX Methods Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_BW.md

Example demonstrating basic Adafruit_GFX drawing methods like fillScreen, setTextColor, setCursor, and println.

```cpp
display.fillScreen(GxEPD_WHITE);
display.setTextColor(GxEPD_BLACK);
display.setCursor(10, 10);
display.println("Hello World");
```

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

### setBusyCallback Usage Example

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/api-reference/GxEPD2_EPD.md

Example of how to set a busy callback function.

```cpp
void waitCallback(const void* param) {
  handlePendingEvents();
}

display.setBusyCallback(waitCallback, nullptr);
```

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

### 1.54" 3-Color Display Initialization

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Initializes a 1.54-inch 3-color e-paper display.

```cpp
GxEPD2_154c epd(CS, DC, RST, BUSY);
GxEPD2_3C<GxEPD2_154c, 200> display(epd);  // 200x200
```

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

### 2.9" 3-Color Display Initialization

Source: https://github.com/zinggjm/gxepd2/blob/master/_autodocs/quick-reference.md

Initializes a 2.9-inch 3-color e-paper display.

```cpp
GxEPD2_290c epd(CS, DC, RST, BUSY);
GxEPD2_3C<GxEPD2_290c, 128> display(epd);  // 128x296, 3 pages
```
Tokens:
Raw