Programación de Pantallas OLED con ESP32 y Protocolo I2C/SPI

En mi caso maneje la referencia a la pantalla dentro del main y no como una variable global, me quedo así:

#include <stdio.h>
#include "string.h"
#include "ssd1306.h"


void screen_init(SSD1306_t *screen) {
  i2c_master_init(screen, CONFIG_SDA_GPIO, CONFIG_SCL_GPIO, CONFIG_RESET_GPIO);
  ssd1306_init(screen, 128, 64);
  ssd1306_contrast(screen, 0xFF);
}

void screen_clear(SSD1306_t *screen) {
  ssd1306_clear_screen(screen, false);
}

void screen_print(SSD1306_t *screen, char * str, int page) {
  ssd1306_clear_line(screen, page, false);
  ssd1306_display_text(screen, page, str, strlen(str), false);
}

void app_main(void) {
  SSD1306_t ledScreen;

  screen_init(&ledScreen);
  screen_clear(&ledScreen);
  screen_print(&ledScreen, "Hola mundo!", 0);
}

Tal cual como lo enseñó:

.

.
.

Estoy siguiendo el curso desde visual studio con la extension de platformio, utilizando el modo de arduino ide.
.
implemente aqui con freertos un timer que pasa de la pagina 1 de informacion, a la pagina 2 de lectura de voltaje.
.
comparto el codigo
.

#include <Arduino.h>
#include <Wire.h>

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

error_t ret;

// --------------- Variables and functions for witness led ----------- 
#define LED_PIN 25
const TickType_t led_delay_on  = 100 / portTICK_PERIOD_MS;
const TickType_t led_delay_off = 900 / portTICK_PERIOD_MS;
TaskHandle_t     led_handle;

error_t init_led();
void refresh_led(void *args);

// --------------- Variables and functions for battery voltage read ----------- 


//The gpio35 is connected to a voltage divisor between battery and ground. The 2 resistor has the same value 50k.
#define  BATT_PIN 35
float batt_inv_div = 2.0;
int   batt_raw;
float batt_volt;
float conversion_factor = (3.3 / 4095) * batt_inv_div; 


const TickType_t batt_delay = 10000 / portTICK_PERIOD_MS;
TaskHandle_t     batt_handle;

error_t init_batt();
void refresh_batt(void *args);
float return_voltage_from_raw(int raw);

// --------------- Variables and functions for I2C Bus -----------
#define SDA_PIN   21
#define SCL_PIN   22

error_t init_I2C();

// --------------- Variables and functions for SSD1306 display -----------
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

int indexPage         = 0;
int indexPagePrevious = 0;
int maxPage           = 2;

enum pages {inf, batt};
TimerHandle_t page_timer = NULL;


TaskHandle_t     ssd1306_handle;
const TickType_t delay_1000    = 1000 / portTICK_PERIOD_MS;
const TickType_t delay_2000    = 2000 / portTICK_PERIOD_MS;
const TickType_t display_delay = 1000 / portTICK_PERIOD_MS;
const TickType_t page_delay    = 3000 / portTICK_PERIOD_MS;
error_t init_ssd1306();

void sendStringXY(String msg, int X, int Y);
void messageValue(String message, float value, int row, int col1, int col2);
void refresh_display(void *args);
void changePage(void *args);

// -------------------------
// SETUP
// -------------------------
void setup() {

    Serial.begin(115200);
    vTaskDelay(delay_2000);

    ret = init_led();
    Serial.println("The Led is OK");  

    xTaskCreatePinnedToCore(
        refresh_led,    //function thet implements the task
        "refresh_led",  //descriptive name
        2048,           //stack size
        NULL,           //pointer to input parameter
        5,              //task priority  0..(configMAX_PRIORITIES - 1)
        &led_handle,    //pointer to task reference. 
        1               // core 0 and core 1
    );


    ret = init_batt();
    Serial.println("The battery read is OK");

    xTaskCreatePinnedToCore(
        refresh_batt,    //function thet implements the task
        "refresh_batt",  //descriptive name
        2048,            //stack size
        NULL,            //pointer to input parameter
        2,               //task priority  0..(configMAX_PRIORITIES - 1)
        &batt_handle,    //pointer to task reference. 
        1                // core 0 and core 1
    );

    ret = init_I2C();
    Serial.println("The I2C is OK");


    ret = init_ssd1306();
    if (ret) {
        Serial.println("The SSD1306 is OK");
    }
    else {    
        Serial.printf("SSD1306 init fail error %d\n", ret);
        while (true) {
            vTaskDelay(delay_1000);
        }
    }

    xTaskCreatePinnedToCore(
        refresh_display,   // function thet implements the task
        "refresh_display", // descriptive name
        2048,              // stack size
        NULL,              // pointer to input parameter
        2,                 // task priority  0..(configMAX_PRIORITIES - 1)
        &ssd1306_handle,   // pointer to task reference. 
        1                  // core 0 and core 1
    );

    page_timer = xTimerCreate(
        "page_Timer",   // Name of Timer
        page_delay,     // Period of timer (ticks)
        pdTRUE,         // Auto reload
        0,              // Timer ID
        changePage);    // Callback function

    if (page_timer == NULL) {
        Serial.println("the timer could not be created");
    } 
    else {
        Serial.println("Start page timer");
    }  

    xTimerStart(page_timer, portMAX_DELAY);

}

void loop() {
  // put your main code here, to run repeatedly:
}

// ------------- Led functions ------------------------------------

error_t init_led() {
    pinMode(LED_PIN, OUTPUT);
    return 0; 
}

void refresh_led(void *args) {
    while (true) {
        digitalWrite(LED_PIN, HIGH);
        vTaskDelay(led_delay_on);
        digitalWrite(LED_PIN, LOW);
        vTaskDelay(led_delay_off);
    };
}

// ------------- Battery functions ------------------------------------

error_t init_batt() {
    pinMode(BATT_PIN, INPUT); 
    // analogReadResolution is 12 bits by default
    // analogSetAttenuation is 11DB by default
    return 0; 
}

void refresh_batt(void *args) {
    while (true) {
        batt_raw = analogRead(BATT_PIN);
        batt_volt = return_voltage_from_raw(batt_raw);
        Serial.printf("Raw: %d  voltage: %5.3f V\n", batt_raw, batt_volt);
        vTaskDelay(batt_delay);
    }
}

// This function must be developed later, due to the non-linearity and shifts of the ESP32 ADC.
float return_voltage_from_raw(int raw){
    return (raw * conversion_factor);
}

// ------------- I2C functions ------------------------------------

error_t init_I2C() {
    Wire.begin(SDA_PIN, SCL_PIN);
    return 0; 
}

// ------------- SSD1306 functions ------------------------------------
error_t init_ssd1306() {
    error_t display_ok;
    display_ok = display.begin(SSD1306_SWITCHCAPVCC, 0x3C, false, false);
    if (display_ok) {
        vTaskDelay(delay_2000);
        display.clearDisplay();
        display.setTextSize(1);
        display.setTextColor(SSD1306_WHITE);         
        display.cp437(true);
        display.display();
    };
    return display_ok;
}

void sendStringXY(String msg, int X, int Y) {
    unsigned char i;
    char c;
    
    display.setCursor(X*6, Y*8);
    for (i = 0; i < msg.length(); i++) 
    {
        c = msg.charAt(i);   
        display.write(c);
    }
}

void messageValue(String message, float value, int row, int col1, int col2) {
    String svalue;
    sendStringXY(message, col1, row);
    svalue = String(value) + "       ";
    svalue = svalue.substring(0,7);
    sendStringXY(svalue, col2, row);
}

void changePage(void *args) {
    indexPage++;
    if (indexPage >= maxPage) indexPage = 0; 
}

void refresh_display(void *args) {
    while (true) {
        if (indexPage != indexPagePrevious) {
            indexPagePrevious = indexPage;
        }
        display.clearDisplay();
        switch (indexPage) {
            
            case inf:
                sendStringXY("The quick brown ", 0, 0);
                sendStringXY("fox jumps over  ", 0, 1);
                sendStringXY("the lazy dog    ", 0, 2); 
                sendStringXY("0123456789      ", 0, 3); 
                sendStringXY("THE QUICK BROWN ", 0, 4); 
                sendStringXY("FOX JUMPS OVER  ", 0, 5); 
                sendStringXY("THE LAZY DOG    ", 0, 6);
                sendStringXY("01234567890     ", 0, 7);
                break;
            case batt: 
                sendStringXY("Battery", 0, 0);
                messageValue("Volt:", batt_volt, 3, 0, 8);
                break;               
            default: 
                break;        
        }
        display.display();
        vTaskDelay(display_delay);
    }        
}

Para los que depronto estén teniendo problemas al hacer build porque no se halla la librería ssd1306, deben agregar esta línea en el CMakeLists.txt del root:

set(EXTRA_COMPONENT_DIRS ../components/ssd1306)