Ecran oled 128x64 i2c et bibliothèque u8g2

Bonjour

Suite au post précédent sur "Ecran oled 128x64 i2c et bibliothèque u8x8, j'essaie la bibliothèque u8g2
qui me permet de changer la taille de la police.

J'ai 2 pb.
1 Je ne sais pas quel écran choisir dans la rubriqueSSD1306 128X64_NONAME
Et comment le paramétrer

2 Je ne comprends pas le choix des fontes.
Certaines sont notées en fin u8g2, d'autres x11.
Je pense que c'est directX11, mais laquelle je dois prendre ?

Je joints le code qui fonctionne en u8x8

/*
  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.
  Please UNCOMMENT one of the contructor lines below

  U8x8 Contructor List: https://github.com/olikraus/u8g2/wiki/u8x8setupcpp
  Update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
*/

/* utilisation de  A0 pour le voltage                avec resistance en //
             pin 4 pour l'AIR DS18b20EAU
             des A4 et A5 pour l'écran
             du  pin 2 pour l'eau DS18b20EAU

  AO   récupère l'information du voltage avec GND fil direct à la batterie mais avec resistance en parallèle !!
  pin 4 AIR récupère l'information de la température de la sonde étanche 1m  DS18B20
  pin 2 EAU récupère l'information de la température de la sonde étanche 1m  DS18B20
  A4 et A5 affichage de l'écran

    "5 Volt c'est la tension de la référence de tension de l'ADC.
    J'espère que tu n'as pas raccordé directement le 12V à A0 ?
    Il faut placer un pont diviseur à deux résistances pour que la tension sur A0 soit inférieure à 12V".
*/


/* Essai affichage voltage, température air et eau
  // http://www.instructables.com/id/Arduino-OLED-Voltage-Meter/  le voltmètre
  //              A0 et GND entre les deux mettre resistance ( voir le lien)ici A0 pour le voltage
  //              A0 est lié à la batterie et GND à l'autre  pôle de la batterie

  // http://edu.mrpigg.ca/termo.html     thermo resistor  Keyes KY-013  pour l'air
  // https://letmeknow.fr/blog/2016/08/10/le-capteur-de-temperature-ds18b20/

  //les librairies de l'écran
  //https://github.com/adafruit/Adafruit_SSD1306
  //https://github.com/adafruit/Adafruit-GFX-Library


  //les librairies de la sonde étanche DS18B20
  //https://github.com/PaulStoffregen/OneWire
*/


// Pour l'écran
#include <Arduino.h>
#include <U8x8lib.h>
//Pour les sondes
#include <DallasTemperature.h>     //DS18B20 pour température de l'eau et de l'air
#include <Wire.h>



// Déclaratipon de l'écran 128x64
U8X8_SSD1306_128X64_NONAME_SW_I2C u8x8(A5, A4, U8X8_PIN_NONE); // OLEDs without Reset of the Display
// Déclaratipon de l'écran 128x128 à venir
// U8X8_SH1107_128X128_HW_I2C u8x8(/* reset=*/ 8);

// les 2 sondes DS18B20
#define ONE_WIRE_BUS_1 2               // sonde pour l'eau pin 2 
#define ONE_WIRE_BUS_2 4               // sonde pour l'air pin 4
OneWire oneWire_in(ONE_WIRE_BUS_1);    // sonde pour l'eau
OneWire oneWire_out(ONE_WIRE_BUS_2);   // sonde pour l'air
DallasTemperature sensor_eau(&oneWire_in);     // sonde pour l'eau
DallasTemperature sensor_air(&oneWire_out);    // sonde pour l'air



void setup(void)
{
  /* U8g2 Project: SSD1306 Test Board */
  pinMode(A4, OUTPUT);
  digitalWrite(A4, 0);
  u8x8.begin();
  u8x8.setPowerSave(0);


  // start serial port
  Serial.begin(115200);
  Serial.println("Dallas Temperature Control Library Demo - TwoPin_DS18B20");

  // Start up the library
  sensor_eau.begin();    // sonde pour l'eau
  sensor_air.begin();    // sonde pour l'air

  // déclaration de la pin 2 et 4
  pinMode(2, INPUT);
  pinMode(4, INPUT);

  int readValEau = analogRead(2);// met à zéro la sonde EAU
  int readValAir = analogRead(4);// met à zéro la sonde AIR


}

void loop(void)
{
  // AFFICHAGE SUR SERIAL
  Serial.print("Recherche des temperatures...");
  sensor_eau.requestTemperatures();
  sensor_air.requestTemperatures();
  Serial.println(" done");

  // sonde EAU
  Serial.print("Température eau: ");
  Serial.println(sensor_eau.getTempCByIndex(0));

  // sonde AIR
  Serial.print("Température air: ");
  Serial.println(sensor_air.getTempCByIndex(0));
  delay ( 5000);

  /*/modele d'écriture
    u8x8.setFont(u8x8_font_chroma48medium8_r);
    u8x8.setCursor(0, 18);
    u8x8.print("Hello World");
  */

  // Affichage Niveau batterie
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 0);
  u8x8.println("NIVEAU BATTERIE");
  //delay ( 1000);

  // pour le voltage de la batterie
  // Conversion du signal (which goes from 0 - 1023) to a voltage (0 - (V):
  int sensorValue = analogRead(A0);//*******************************************************  A3 pour la voiture bateau
  // écrit la valeur lue
  float voltage = sensorValue * (5.0 / 1023.0);
  u8x8.setCursor(0, 1);// position 0, sur la 1 ere ligne,
  u8x8.print("        ");
  u8x8.print(voltage);
  u8x8.print("V");

  //Affichage  températures Air
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 3);
  u8x8.println("TEMP. AIR ");
  u8x8.print("       ");
  u8x8.print(sensor_air.getTempCByIndex(0));
  u8x8.print(" ");
  u8x8.print("C");

  // Affichage  températures Eau
  u8x8.setFont(u8x8_font_chroma48medium8_r);
  u8x8.setCursor(0, 6);
  u8x8.println("TEMP. EAU ");
  u8x8.print("       ");
  u8x8.print(sensor_eau.getTempCByIndex(0));
  u8x8.print(" ");
  u8x8.print("C");


}

Code de test dans lequel j'ai remplacé les u8x8 par u8g2 ( si j'ai bien compris la différence entre les 2 bibliothèque)

// Pour l'écran
#include <Arduino.h>
#include <U8g2lib.h>


// pour les fontes  https://github.com/olikraus/u8g2/wiki/fntlistall
// poue l'écran     https://github.com/olikraus/u8g2/wiki/u8g2setupc


// Déclaratipon de l'écran 128x64
U8G2_SSD1306_128X64_NONAME_SW_I2C U8G2(A5, A4, U8G2_PIN_NONE); // OLEDs without Reset of the Display
// Déclaratipon de l'écran 128x128 à venir
// U8G2_SH1107_128X128_HW_I2C U8G2(/* reset=*/ 8);





void setup(void)
{
  /* U8g2 Project: SSD1306 Test Board */
  pinMode(A4, OUTPUT);
  digitalWrite(A4, 0);
  u8g2.begin();
  u8g2.setPowerSave(0);
}

void loop(void)
{
  //modele d'écriture
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.setCursor(0, 15);
  u8g2.print("Hello World!");

}

Je n'au jamais testé u8g2, mais dans ton second lien on voit l'explication des noms des polices.

<prefix> '_' <name> '_' <purpose> <char set>

Purpose :

  • t Transparent font, Do not use a background color.
  • h All glyphs have common height.
  • m All glyphs have common height and width (monospace).
  • 8 All glyphs fit into a 8x8 pixel box.

Char set :

  • f The font includes up to 256 glyphs.
  • r Only glyphs on the range of the ASCII codes 32 to 127 are included in the font.
  • u Only glyphs on the range of the ASCII codes 32 to 95 (uppercase chars) are included in the font.
  • n Only numbers and extra glyphs for writing date and time strings are included in the font.
  • ... Other custom character list.

Là on voit que celles qui finissent par 'u' prennent moins de place : que des majuscules, plus les chiffres et la ponctuation (voir une table ASCII pour les codes de 32 à 95). Celles qui finissent par 't' ajoutent les minuscules.
Après, le choix de la police dépend de toi...

Pour la configuration, ton premier lien donne ceci :

u8g2_t u8g2; // a structure which will contain all the data for one display
...
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_lpc11u3x);  // init u8g2 structure
u8g2_InitDisplay(&u8g2); // send init sequence to the display, display is in sleep mode after this,
u8g2_SetPowerSave(&u8g2, 0); // wake up display

Il y a 3 arguments :

  • U8G2_R0 : définit la rotation de l'écran (5 cas possibles, voir sur le lien), tu testes jusqu'à trouver celui qui te convient
  • u8x8_byte_sw_i2c : c'est bon pour toi si tu es en I2C
  • u8x8_gpio_and_delay_lpc11u3x : là c'est assez complexe, je ne sais pas trop... Tu peux essayer de mettre U8X8_MSG_DELAY_I2C
    Ca donnerait :
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);

Merci

J'ai essayé de voir sur le site

Je ne pourrais tester que ce soir.

J'ai pris cet écran 128x128

Je ne sais pas lequel prendre , il y a des MIDAS, des EA ...
je prendrai celui-ci

u8g2_Setup_ssd1327_i2c_midas_128x128_1(u8g2, rotation, u8x8_byte_sw_i2c, uC specific)

Je suis aller sur leur wiki , mais je n'ai rien compris

C'est vrai qu'il y a 2 types d'écrans 128x128 en I2C, je suppose que ce sont des fabricants différents.

Pour U8x8, tu peux les tester avec ce code :

#include <Arduino.h>
#include <SPI.h>
#include <U8x8lib.h>

/* Constructor */
U8X8_SSD1327_EA_W128128_SW_I2C(A5, A4);
// ou, si ça ne marche pas :
//  U8X8_SSD1327_MIDAS_128X128_SW_I2C(A5, A4);

/* u8x8.begin() is required and will sent the setup/init sequence to the display */
void setup(void)
{
  u8x8.begin();
}

void loop(void)
{
  u8x8.setFont(u8x8_font_chroma48medium8_r);  // <-- Choisir la bonne police ici
  u8x8.drawString(0,0,"Hello World!");
  delay(1000);
}

Pour U8g2 :

#include <Arduino.h>
#include <SPI.h>
#include <U8g2lib.h>

/* Constructor */
U8G2_SSD1327_EA_W128128_1_SW_I2C(U8G2_R0, A5, A4);
// si ne marche pas :
//U8G2_SSD1327_MIDAS_128X128_1_SW_I2C(U8G2_R0, A5, A4);

/* u8g2.begin() is required and will sent the setup/init sequence to the display */
void setup(void) {
  u8g2.begin();
}

/* draw something on the display with the `firstPage()`/`nextPage()` loop*/
void loop(void) {
  u8g2.firstPage();
  do {
    u8g2.setFont(u8g2_font_ncenB14_tr);  // <-- Choisir la bonne police ici
    u8g2.drawStr(0,20,"Hello World!");
  } while ( u8g2.nextPage() );
  delay(1000);
}

super merci!

Je teste ce soir

Salut

Voici pour le test en 128x64 avec u8g2
Retour des erreurs

Arduino : 1.8.5 (Windows 10), Carte : "Arduino/Genuino Uno"

Ecran_u8G2_128x64_128x128:11: error: expected constructor, destructor, or type conversion before '(' token

 u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);

                                       ^

D:\ACER-Patrick\CLARISSE\Code bateau\000_fonctionnent\Ecran_u8G2_128x64_128x128\Ecran_u8G2_128x64_128x128.ino: In function 'void setup()':

Ecran_u8G2_128x64_128x128:23: error: 'u8g2' was not declared in this scope

   u8g2.begin();

   ^

D:\ACER-Patrick\CLARISSE\Code bateau\000_fonctionnent\Ecran_u8G2_128x64_128x128\Ecran_u8G2_128x64_128x128.ino: In function 'void loop()':

Ecran_u8G2_128x64_128x128:36: error: 'u8g2' was not declared in this scope

   u8g2.setFont(u8g2_font_ncenB14_tr);

   ^

exit status 1
expected constructor, destructor, or type conversion before '(' token

Ce rapport pourrait être plus détaillé avec
l'option "Afficher les résultats détaillés de la compilation"
activée dans Fichier -> Préférences.

Code complet

// Pour l'écran
#include <Arduino.h>
#include <U8g2lib.h>


// pour les fontes  https://github.com/olikraus/u8g2/wiki/fntlistall
// poue l'écran     https://github.com/olikraus/u8g2/wiki/u8g2setupc


// Déclaratipon de l'écran 128x64
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);

// Déclaratipon de l'écran 128x128 à venir
/* Constructor */
//U8G2_SSD1327_EA_W128128_1_SW_I2C(U8G2_R0, A5, A4);
// si ne marche pas :
//U8G2_SSD1327_MIDAS_128X128_1_SW_I2C(U8G2_R0, A5, A4);
void setup(void)
{
  /* U8g2 Project: SSD1306 Test Board */
  pinMode(A4, OUTPUT);
  digitalWrite(A4, 0);
  u8g2.begin();
  u8g2.setPowerSave(0);




}

void loop(void)
{


 // modele d'écriture
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.setCursor(0, 15);
  u8g2.print("Hello World!");



}

C'est la déclaration de l'écran qui n'est pas bonne :

// Déclaration de l'écran 128x64
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);

Tu as un peu tout mélangé. Essaye ça :

// Déclaration de l'écran 128x128
U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, A5, A4);

J'avais oublié le nom de l'instanciation de l'écran, "u8g2" que tu utilises pour les fonctions ensuite.

Comme dit plus haut, si ça ne marche pas, essaye le MIDAS :

U8G2_SSD1327_MIDAS_128X128_1_SW_I2C u8g2(U8G2_R0, A5, A4);

J'avance "à vue" car je n'ai jamais utilisé cette bibli... et ça n'a pas l'air simple (au moins au début, ça sera plus facile après)

Bonjour

NB : tu as répondu avant moi , j'écrivais ceci
"Il ne manquerait pas la rotation ?

U8G2_SSD1306_128X64_NONAME_2_SW_I2C(U8G2_R0, A5, A4 [, reset])

"

Comme je vais dans plusieurs voies en même temps je me noie un peu.

Pour tout mettre à plat.
Actuellement je n'ai que les écrans 128x64 sous la main.
J'attends les 128x128.

Je teste le code pour le 128x64 et en avance je prévoie pour le 128x128 ( que je ne peux tester actuellement)

Donc pour le 128x64, c'est ce code

// Pour l'écran
#include <Arduino.h>
#include <U8g2lib.h>


// pour les fontes  https://github.com/olikraus/u8g2/wiki/fntlistall
// poue l'écran     https://github.com/olikraus/u8g2/wiki/u8g2setupc


// Déclaratipon de l'écran 128x64
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, U8X8_MSG_DELAY_I2C);

/*U8G2_SSD1306_128X64_NONAME_2_SW_I2C(rotation, clock, data [, reset])
                                    // U8G2_R0,SCL  A5, SDA  A4
U8G2_SSD1306_128X64_NONAME_2_SW_I2C(U8G2_R0, A5, A4 [, reset])
*/
void setup(void)
{
  /* U8g2 Project: SSD1306 Test Board */
  pinMode(A4, OUTPUT);
  digitalWrite(A4, 0);
  u8g2.begin();
  u8g2.setPowerSave(0);




}

void loop(void)
{


  /*/modele d'écriture
    u8g2.setFont(u8g2_font_ncenB14_tr);
    u8g2.setCursor(0, 15);
    u8g2.print("Hello World!");
  */

  // Affichage Niveau batterie
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.setCursor(0, 0);
  u8g2.println("NIVEAU BATTERIE");
  
}

Pour la taille de la police, c'est son choix qui défini la taille, c'est bon ?

les lignes suivantes sont ce que je pensais bon

/*U8G2_SSD1306_128X64_NONAME_2_SW_I2C(rotation, clock, data [, reset])
                                    // U8G2_R0,SCL  A5, SDA  A4
U8G2_SSD1306_128X64_NONAME_2_SW_I2C(U8G2_R0, A5, A4 [, reset])
*/

Comme je vais dans plusieurs voies en même temps je me noie un peu.

C'est pas bon de se noyer pour un capitaine de bateau... même dans une piscine ! :slight_smile:

Quand tu déclares l'écran, avec ce qu'ils appellent le constructeur, tu dois lui donner un nom. Ce nom, le nom de l'instance, tu l'utilises à chaque fois que tu appelles une fonction d'affichage dans la suite de ton programme.
Ça sert par exemple si tu as plusieurs écrans : tu peux les distinguer par des noms différents et afficher sur l'un et sur l'autre des choses différentes.

Donc au niveau du constructeur, tu déclares ainsi :

Constructor_name Display_name (arguments)

Pour toi :

U8G2_SSD1306_128X64_NONAME_2_SW_I2C u8g2 (U8G2_R0, A5, A4)
  • Constructor_name : U8G2_SSD1306_128X64_NONAME_2_SW_I2C
  • Display_name : u8g2
  • arguments : U8G2_R0, A5, A4 (les [ et ] ne doivent pas être utilisés dans ton code, ils servent juste dans le manuel d'utilisation à préciser les arguments optionnels.
    Ensuite dans ton code, tu affiches sur l'écran appelé u8g2 (mais tu peux décider dès le début de l'appeler Marcel, il faut juste conserver cette convention dans tout le programme) en appelant les fonctions référencées par ce nom, comme par exemple u8g2.begin();

super explication

Merci

J'ai eu une explication ici
http://forum.arduino.cc/index.php?topic=555144.0

Peux-tu m'expliquer .

Merci

Il te propose d'utiliser un constructeur qui utilise le I2C hardware. Je suis loin de maîtriser le sujet, mais j'ai vu que le SPI et l'I2C existent en version hardware (je suppose que ça veut dire que ça oblige à utiliser les broches spécifiques A4, A5 pour I2C et les broches SCK, MOSI, CS pour le SPI) et en version software. Dans ce dernier cas, on peut utiliser d'autres broches, elles émulent les broches spécifiques. La différence c'est la vitesse : le HW est plus rapide que le SW.

A mon avis, pour toi, ça ne changera rien. Mais tu peux essayer la version HW :

U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2 (U8G2_R0, A5, A4);

Tu as raison
Même résultat
Rien sur l 'écran :confused:

Je suis pret a tester toutes tes propositions.
Je ne pense pas arriver a la fumée blanche :slight_smile:

J ai eu une autre reponse sur l autre post.

J'ai trouvé ceci

https://github.com/olikraus/U8g2_Arduino/archive/master.zip

Cela parle du 128x128 mais peut-être pour le 128x64 ?

Il y a deux exemples page buffer / Print Helle word
full buffer / Helo word

Lequel je dois prendre comme base ?

Pas facile de t'aider sur un sujet que je ne connais pas vraiment.

Ton écran est en I2C, donc tu dois choisir les constructeurs I2C. Tu connais les nombres de pixels, ça aide encore à choisir.
Je pense que les histoires de pages et de buffer, c'est lié à la mémoire et à la rapidité d'affichage : si tu veux pouvoir afficher plusieurs pages différentes et gagner du temps pour les afficher, tu les conserves en mémoire et il les affiche à partir de ces sauvegardes. Dans ton cas, ça utilise beaucoup de mémoire (j'ai cru comprendre que tu es short sur ce point) pour pas de réel besoin.

Donc, à ta place, je choisirais ceux qui n'utilisent qu'une page.

Donc, pour ton SSD1306 - 128x64 - I2C, les constructeurs sont ici (sauf erreur de ma part)

Le setup est décrit ici :

u8g2_t u8g2; // a structure which will contain all the data for one display
...
u8g2_Setup_ssd1306_i2c_128x64_noname_2(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_lpc11u3x);  // init u8g2 structure
u8g2_InitDisplay(&u8g2); // send init sequence to the display, display is in sleep mode after this,
u8g2_SetPowerSave(&u8g2, 0); // wake up display

Dans ton cas, ça donnerait :

u8g2_t u8g2; // a structure which will contain all the data for one display
u8g2_Setup_ssd1306_128x64_noname_1(&u8g2, U8G2_R0, u8x8_byte_sw_i2c, u8x8_gpio_and_delay_lpc11u3x);  // init u8g2 structure
u8g2_InitDisplay(&u8g2); // send init sequence to the display, display is in sleep mode after this,
u8g2_SetPowerSave(&u8g2, 0); // wake up display

Mais je ne comprends pas pourquoi on se retrouve avec du u8x8 dans les paramètres (ça m'a l'air du belle usine à gaz :frowning: ).

De plus à d'autres endroits on trouve des déclarations différentes, comme je l'avais proposé dans une réponse auparavant :

U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2 (U8G2_R0, A5, A4);
et
U8G2_SSD1306_128X64_NONAME_2_SW_I2C u8g2 (U8G2_R0, A5, A4);

Donc, je suis un peu perdu...

Essaye de simplifier ton code :

  • Ne cherche pas à utiliser une police avant d'avoir réussi à déclarer l'écran correctement,
  • Affiche au centre de l'écran : u8g2.setCursor(30, 15); par exemple (pas de 0 pour l'instant)

et n'oublies jamais : "Ce n'est qu'en essayant continuellement que l'on finit par réussir." Donc teste un peu tous les constructeurs tu tomberas sur le bon au bout d'un certain temps :slight_smile:

Salut
Et donc comme tu dis, pour essayer j'ai trouvé ceci

Ça a l'air de ce que je recherche !?
bien que ce ne soit pas mon écran avec 4 pin, et que le code est SPI

https://mithatkonar.com/wiki/doku.php/arduino/displays_for_classic_arduinos/tiny_oled_displays_and_classic_arduinos

  /*
     * display_SSD1306_OLED_U8g2lib.ino
     *  
     * Test screen update speed with large solid fonts on 
     * a 128x64 OLED screen that uses the SD1306 chip.
     * 
     * Consumes 46% of program storage space and
     * 28% of dynamic memory on a Nano.
     *  
     * Mithat Konar
     */
     
     
    #include <U8g2lib.h>
     
    /*
       Pin assignments:
       RST: 8
       CE/CS/SCE: 10
       DC/"D/C"/A0: 9
       DIN/DN/MOSI/DATA: 11 (Arduino HW standard)
       CLK/SCLK/SCK: 13  (Arduino HW standard)
       VCC: 5V (part is allegedly 5V tolerant)
       GND: ground
    */
     
    const unsigned int CLOCK_PIN = 13,
                       DATA_PIN = 11,
                       CS_PIN = 10,
                       DC_PIN = 9,
                       RESET_PIN = 8;
     
    U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI disp = U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI(U8G2_R0, CS_PIN, DC_PIN, RESET_PIN);
     
    unsigned int counter = 80;
    char dispStr[4];    // null terminated char array used to pass to renderer.
     
    void setup(void) {
      disp.begin();
      disp.setColorIndex(1);
    }
     
    void loop(void) {
      counter = (counter + 1) % 1000;
     
      // picture loop
      disp.firstPage();
      do {
        disp.setFont(u8g2_font_6x13_tr);
        disp.drawStr(0, 13, "SSD1306 u8g2");
     
        disp.setFont(u8g2_font_logisoso46_tr);
        String(counter).toCharArray(dispStr, 4);
        disp.drawStr( 0, 63, dispStr);
      } while ( disp.nextPage() );
     
      /* inherent frame rate is about 13 fps with 16 MHz processor 
         (without additional delay). */
      delay(500);
    }

J'ai trouvé un comparatif enter les adafruit et u8g2 avec un code.
Ce sera peut-être le bon ?

Je crois avoir le bon

OK, bonne chance !

Je ne peux que chercher, les tests sont le soir

salut

J'ai trouvé ceci

//All the u8g2 commands have to be encapsulated in a while loop:

void loop(void) {
  ...
  u8g2.firstPage();
  do {
    <your code>
  } while ( u8g2.nextPage() );
 ...
}