SSD1306, écran OLED I2C 128×64 0.96″. Comment afficher du texte, image et animation avec un Arduino • Domotique et objets connectés à faire soi-même

0Vus

Dans ce tutoriel, nous allons apprendre comment câbler et afficher du texte, des images et faire de petites animations sur un mini écran OLED monochrome SSD1306 0.96” à l’aide d’un Arduino. Cet écran piloté par un micro-contrôleur SSD1306 utilise le bus I2C pour communiquer avec un Arduino, un ESP8266 et même un mini-PC (Raspberry Pi, Orange Pi…). Cet écran de 0,96” est capable d’afficher 128×64 pixels.

Vous pouvez trouver cet écran OLED chez Adafruit ou Sparkfun par exemple. On le trouve également pour moins de 3€ chez de nombreux fabricants asiatiques. Ces écrans sont de bonne qualité. Adafruit et Sparkfun ont développés des librairies qui permettent d’afficher très facilement du texte, des images et mêmes de faire des animations à base de formes géométriques très simplement.

Câblage de l’écran OLED I2C SSD1306 128x64p 0.96″ sur Arduino

L’utilisation de l’interface I2C permet de réduire très fortement le câblage de cet écran OLED. Cet écran n’étant pas disponible dans la librairie d’Adafruit, je l’ai remplacé par son cousin plus petit, 128 x 32 pixels. L’écran est alimenté en 3.3V, il utilise le même micro-contrôleur SSD1306.

Si vous disposez d’un Arduino Uno, relié le Pin A4 sur le Pin SDA (Serial DAta) de l’écran et le port A5 sur le Pin SCL (Serial CLock). Certaines cartes disposent directement des Pins dédiés SDA/SCL. Sinon, voici un petit tableau qui récapitule les connecteurs SDA et SCL pour différentes cartes Arduino courantes (d’après cet article).

Matériel nécessaire

Pour réaliser le montage de ce projet vous aurez besoin du matériel suivant

Pour ce tutoriel, nous allons utiliser un écran de 0,96” permettant d’afficher 128×64 pixels mais il existe d’autres résolutions et d’autres tailles disponibles. En voici quelques unes.

N’oubliez pas de vérifier que la résolution est supportée par la librairie. Par exemple, la librairie Adafruit supporte les écrans de 128×64 ou 128×32 pixels.

Enfin, il existe principalement trois couleurs d’affichage.​

Comment trouver l’adresse de l’écran SSD1306 sur le bus I2C ?

Avant de pouvoir utiliser l’écran OLED SSD1306, il va falloir configurer le port sur lequel celui-ci ce trouve sur le bus I2C. Pour cela, Nick Gammon’s a développé un petit programme Arduino pour trouver le port I2C sur lequel est branché l’écran OLED. Le programme scrute en boucle et recherche les appareils I2C connectés au port série toutes les 5 secondes mais on peut ajuster le délai de rafraichissement en ajustant le délai en fin de boucle.

/*
  Scanner I2C d'après le projet initial de Nick Grammon's http://playground.arduino.cc/Main/I2cScanner
  Projets DIY - Mars 2016 - http://www.projetsdiy.fr

*/
// --------------------------------------
// i2c_scanner
//
// Version 1
//    This program (or code that looks like it)
//    can be found in many places.
//    For example on the Arduino.cc forum.
//    The original author is not know.
// Version 2, Juni 2012, Using Arduino 1.0.1
//     Adapted to be as simple as possible by Arduino.cc user Krodal
// Version 3, Feb 26  2013
//    V3 by louarnold
// Version 4, March 3, 2013, Using Arduino 1.0.3
//    by Arduino.cc user Krodal.
//    Changes by louarnold removed.
//    Scanning addresses changed from 0...127 to 1...119,
//    according to the i2c scanner by Nick Gammon
//    http://www.gammon.com.au/forum/?id=10896
// Version 5, March 28, 2013
//    As version 4, but address scans now to 127.
//    A sensor seems to use address 120.
// Version 6, November 27, 2015.
//    Added waiting for the Leonardo serial communication.
//
//
// This sketch tests the standard 7-bit addresses
// Devices with higher bit address might not be seen properly.
//
 
#include 
 
void setup()
{
  Wire.begin();
 
  Serial.begin(9600);
  while (!Serial);             // Leonardo: wait for serial monitor
  Serial.println("\nI2C Scanner");
}
 
void loop()
{
  byte error, address;
  int nDevices;
 
  Serial.println("Scanning...");
 
  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    Wire.beginTransmission(address);
    error = Wire.endTransmission();
 
    if (error == 0)
    {
      Serial.print("Appareil I2C trouve a cette adresse 0x");
      if (address Ajouter la bibliothèque .ZIP et choisissez le zip de la librairie à importer.







Vous pouvez maintenant aller dans Fichier -> Exemples pour découvrir les exemples proposés dans la librairie.







Pour utiliser une librairie dans vos projets, déclarez la en début de projet, par exemple



#include 


Test des librairies Adafruit et Sparkfun pour piloter un écran OLED SSD1306



Pour gérer l’affichage sur votre écran OLED, il y a plusieurs librairies Open Source à notre disposition. Pour cet article, je vais vous présenter les deux principales. La librairie développée par Adafruit et celle de Sparkfun.



Librairies Adafruit_GFX et Adafruit_SSD1306



Adafruit a développé une librairie très puissante qui va nous permettre de gérer l’affichage de notre mini écran mais aussi de tracer plein de chose très facilement grâce à la librairie dédiée, GFX Library. Vous pouvez récupérer la librairie Adafruit SSD1306 sur le github https://github.com/adafruit/Adafruit_SSD1306 et la librairie GFX ici https://github.com/adafruit/Adafruit-GFX-Library/archive/master.zip.


Attention. Il est nécessaire d’inclure les 2 librairies dans votre projet. Pour gagner quelques précieux octets, vous pouvez utiliser la librairie Micro_OLED de Sparkfun décrite dans le prochain paragraphe.




Liste des fonctions de la librairie disponibles









Fonctions de la librairie Adafruit_SSD1306





Adafruit_SSD1306 display(OLED_RESET)
initialise l’objet display(Pin pour le reset)




display()
Actualise l’affichage




clearDisplay()
Efface l’écran et le buffer




invertDisplay(bool)
inverse l’affichage (true ou false)




Fonctions Adafruit_GFX





drawPixel(uint16_t x, uint16_t y, uint16_t color)
Dessine un pixel en X,Y de la couleur color




drawLine(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color)
Dessine une ligne de X1,Y1 à x2,Y2 de la couleur color




drawFastVLine(uint16_t x0, uint16_t y0, uint16_t length, uint16_t color)


drawFastHLine(uin86_t x0, uin86_t y0, uint8_t length, uint16_t color);


Tracé optimisé de lignes horizontales et verticales




drawRect(uint16_t x0, uint16_t y0, uint16_t w, uint16_t h, uint16_t color)


fillRect(uint16_t x0, uint16_t y0, uint16_t w, uint16_t h, uint16_t color)


Dessine un rectangle depuis X,Y de largeur w et hauteur h


idem mais plein






drawCircle(uint16_t x0, uint16_t y0, uint16_t r, uint16_t color)


fillCircle(uint16_t x0, uint16_t y0, uint16_t r, uint16_t color)


Dessine un cercle de centre X,Y et de rayon r


idem mais le cercle est plein






drawRoundRect(uint16_t x0, uint16_t y0, uint16_t w, uint16_t h, uint16_t radius, uint16_t color)


fillRoundRect(uint16_t x0, uint16_t y0, uint16_t w, uint16_t h, uint16_t radius, uint16_t color)


 Idem rectangle mais avec un arrondi de rayon raduis aux angles




drawTriangle(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color)


fillTriangle(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t x2, uint16_t y2, uint16_t color)


Dessine un triangle en spécifiant les coordonnées de chaque sommets (x0,y1), (x2,y2), (x3,y3)




drawChar(uint16_t x, uint16_t y, char c, uint16_t color, uint16_t bg, uint8_t size)
Dessine un caractère en x,y




drawBitmap(int16_t x, int16_t y, uint8_t *bitmap, int16_t w, int16_t h, uint16_t color)
 Affiche un bitmap en x,y de largeur w et hauteur t




fillScreen(uint16_t color);
 Colorie entièrement l’écran dans la couleur spécifiée




setRotation(uint8_t rotation)
 Rotation de l’affichage : 0 -> 0°, 1 -> 90°, 2 -> 180°, 3 -> 270°





Le paramètre color permettant de définir la couleur d’affichage uniquement sur les écrans couleur est disponible dans toutes les fonctions graphiques de la librairie GFX. Pour plus d’informations, vous pouvez consulter ce document de formation en anglais.


La librairie Adafruit_GFX est utilisée par d’autres librairies dédiées à chaque (microcontroleur) écran.


Afficher du texte


L’affichage d’un texte demande un peu plus de travail. Il est nécessaire de modifier les paramètres d’affichage paramètre par paramètre. Voici un petit exemple pour afficher Hello Word en 0,0:


display.setTextSize(1);                    // setTextSize applique est facteur d'échelle qui permet d'agrandir ou réduire la font

display.setTextColor(WHITE);    // La couleur du texte

display.setCursor(0,0);                  // On va écrire en x=0, y=0

display.println("Hello, world!"); // un println comme pour écrire sur le port série

display.setTextColor(BLACK, WHITE); // On inverse les couleurs, le fond devient noir

display.println("Hello, world!");

// Vous pouvez changer à la volée de Font (pour cela vous devez la déclarer comme une librairie en début de projet, par exemple #include )

display.setFont(&FreeMono9pt7b);

display.setTextColor(WHITE);

display.println("Hello, world!");

display.setFont();                          // Pour revenir à la Font par défaut


Par contre, vous pouvez oublier les accents, ils ne sont pas gérés dans les Fonts disponibles.


/*
  Programme de démo pour écran OLED 128x64 pixels I2C basé sur le contrôleur SSD1306
  Ajout de traduction en français
  Projets DIY - mars 2016 - http://www.projetsdiy.fr
  
*/
/*********************************************************************
This is an example for our Monochrome OLEDs based on SSD1306 drivers

  Pick one up today in the adafruit shop!
  ------> http://www.adafruit.com/category/63_98

This example is for a 128x64 size display using I2C to communicate
3 pins are required to interface (2 I2C and one reset)

Adafruit invests time and resources providing this open source code, 
please support Adafruit and open-source hardware by purchasing 
products from Adafruit!

Written by Limor Fried/Ladyada  for Adafruit Industries.  
BSD license, check license.txt for more information
All text above, and the splash screen must be included in any redistribution
*********************************************************************/
#include 
#include 
#include 
#include 

#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);

#define NUMFLAKES 10
#define XPOS 0
#define YPOS 1
#define DELTAY 2

#define LOGO16_GLCD_HEIGHT 16 
#define LOGO16_GLCD_WIDTH  16 
// Logo Adafruit
static const unsigned char PROGMEM logo16_glcd_bmp[] =
{ B00000000, B11000000,
  B00000001, B11000000,
  B00000001, B11000000,
  B00000011, B11100000,
  B11110011, B11100000,
  B11111110, B11111000,
  B01111110, B11111111,
  B00110011, B10011111,
  B00011111, B11111100,
  B00001101, B01110000,
  B00011011, B10100000,
  B00111111, B11100000,
  B00111111, B11110000,
  B01111100, B11110000,
  B01110000, B01110000,
  B00000000, B00110000 };

#if (SSD1306_LCDHEIGHT != 64)
#error("Height incorrect, please fix Adafruit_SSD1306.h!");
#endif

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

  // by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
  //Utiliser le scanner I2C pour trouver le port série sur lequel se trouve votre écran 
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3D (for the 128x64) 
  // init done
  
  display.display();        // show splashscreen  // Affiche le logo Adafruit par défaut
  delay(2000);
  display.clearDisplay();   // clears the screen and buffer   // Efface l'écran 

  // draw a single pixel // Dessine un pixel blanc aux coordonnées 10,10
  display.drawPixel(10, 10, WHITE);     
  display.display();
  delay(2000);
  display.clearDisplay();

  // draw many lines    // Dessine plusieurs lignes
  testdrawline();
  display.display();
  delay(2000);
  display.clearDisplay();

  // draw rectangles    // Des rectangles
  testdrawrect();
  display.display();
  delay(2000);
  display.clearDisplay();

  // draw multiple rectangles // Plusieurs rectangles imbriqués
  testfillrect();
  display.display();
  delay(2000);
  display.clearDisplay();

  // draw mulitple circles   // Des cercles
  testdrawcircle();
  display.display();
  delay(2000);
  display.clearDisplay();

  // draw a white circle, 10 pixel radius   // Un cercle blanc de 10 pixels de rayon
  display.fillCircle(display.width()/2, display.height()/2, 10, WHITE);
  display.display();
  delay(2000);
  display.clearDisplay();

  testdrawroundrect();      // Rectangle arondi
  delay(2000);
  display.clearDisplay();

  testfillroundrect();      // idem mais rempli
  delay(2000);
  display.clearDisplay();

  testdrawtriangle();       // triangle
  delay(2000);
  display.clearDisplay();
   
  testfilltriangle();       // triangle plein
  delay(2000);
  display.clearDisplay();

  // draw the first ~12 characters in the font  / 12 caractères
  testdrawchar();
  display.display();
  delay(2000);
  display.clearDisplay();

  // draw scrolling text    // scrolling d'un texte
  testscrolltext();
  delay(2000);
  display.clearDisplay();

  // text display tests
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);
  display.println("Hello, world!");
  display.setTextColor(BLACK, WHITE); // 'inverted' text
  display.println(3.141592);
  display.setTextSize(2);
  display.setTextColor(WHITE);
  display.print("0x"); display.println(0xDEADBEEF, HEX);
  display.display();
  delay(2000);

  // miniature bitmap display
  display.clearDisplay();
  display.drawBitmap(30, 16,  logo16_glcd_bmp, 16, 16, 1);
  display.display();

  // invert the display
  display.invertDisplay(true);
  delay(1000); 
  display.invertDisplay(false);
  delay(1000); 

  // draw a bitmap icon and 'animate' movement
  testdrawbitmap(logo16_glcd_bmp, LOGO16_GLCD_HEIGHT, LOGO16_GLCD_WIDTH);
}

void loop() {
}

void testdrawbitmap(const uint8_t *bitmap, uint8_t w, uint8_t h) {
  uint8_t icons[NUMFLAKES][3];
 
  // initialize
  for (uint8_t f=0; f< NUMFLAKES; f++) {
    icons[f][XPOS] = random(display.width());
    icons[f][YPOS] = 0;
    icons[f][DELTAY] = random(5) + 1;
    
    Serial.print("x: ");
    Serial.print(icons[f][XPOS], DEC);
    Serial.print(" y: ");
    Serial.print(icons[f][YPOS], DEC);
    Serial.print(" dy: ");
    Serial.println(icons[f][DELTAY], DEC);
  }

  while (1) {
    // draw each icon
    for (uint8_t f=0; f< NUMFLAKES; f++) {
      display.drawBitmap(icons[f][XPOS], icons[f][YPOS], logo16_glcd_bmp, w, h, WHITE);
    }
    display.display();
    delay(200);
    
    // then erase it + move it
    for (uint8_t f=0; f< NUMFLAKES; f++) {
      display.drawBitmap(icons[f][XPOS], icons[f][YPOS],  logo16_glcd_bmp, w, h, BLACK);
      // move it
      icons[f][YPOS] += icons[f][DELTAY];
      // if its gone, reinit
      if (icons[f][YPOS] > display.height()) {
    icons[f][XPOS] = random(display.width());
    icons[f][YPOS] = 0;
    icons[f][DELTAY] = random(5) + 1;
      }
    }
   }
}


void testdrawchar(void) {
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0,0);

  for (uint8_t i=0; i < 168; i++) {
    if (i == '\n') continue;
    display.write(i);
    if ((i > 0) && (i % 21 == 0))
      display.println();
  }    
  display.display();
}

void testdrawcircle(void) {
  for (int16_t i=0; i paddle1_Y) && (ball_Y < paddle1_Y + paddleH))
      {
        ball_X--;  // Move ball over one to the left
        ballVelocityX = -ballVelocityX; // change velocity
      }
    }
    // Check if the ball hit the top or bottom
    if ((ball_Y = (oled.getLCDHeight() - ball_rad - 1)))
    {
      // Change up/down velocity direction
      ballVelocityY = -ballVelocityY;
    }
    // Move the paddles up and down
    paddle0_Y += paddle0Velocity;
    paddle1_Y += paddle1Velocity;
    // Change paddle 0's direction if it hit top/bottom
    if ((paddle0_Y  oled.getLCDHeight() - 2 - paddleH))
    {
      paddle0Velocity = -paddle0Velocity;
    }
    // Change paddle 1's direction if it hit top/bottom
    if ((paddle1_Y  oled.getLCDHeight() - 2 - paddleH))
    {
      paddle1Velocity = -paddle1Velocity;
    }
    
    // Draw the Pong Field
    oled.clear(PAGE);  // Clear the page
    // Draw an outline of the screen:
    oled.rect(0, 0, oled.getLCDWidth() - 1, oled.getLCDHeight());
    // Draw the center line
    oled.rectFill(oled.getLCDWidth()/2 - 1, 0, 2, oled.getLCDHeight());
    // Draw the Paddles:
    oled.rectFill(paddle0_X, paddle0_Y, paddleW, paddleH);
    oled.rectFill(paddle1_X, paddle1_Y, paddleW, paddleH);
    // Draw the ball:
    oled.circle(ball_X, ball_Y, ball_rad);
    // Actually draw everything on the screen:
    oled.display();
    delay(25);  // Delay for visibility
  }
  delay(1000);
}

void textExamples()
{
  printTitle("Text!", 1);
  
  // Demonstrate font 0. 5x8 font
  oled.clear(PAGE);     // Clear the screen
  oled.setFontType(0);  // Set font to type 0
  oled.setCursor(0, 0); // Set cursor to top-left
  // There are 255 possible characters in the font 0 type.
  // Lets run through all of them and print them out!
  for (int i=0; i= 10) // If ms is >= 10
    {
      ms = 0;     // Set ms back to 0
      s++;        // and increment s
    }
  }
  
  // Demonstrate font 4. 31x48. Let's use the print function
  // to display some characters defined in this font.
  oled.setFontType(4);  // Set font to type 4
  oled.clear(PAGE);     // Clear the page
  oled.setCursor(0, 0); // Set cursor to top-left
  // Print can be used to print a string to the screen:
  oled.print("OL");
  oled.display();       // Refresh the display
  delay(1000);          // Delay a second and repeat
  oled.clear(PAGE);
  oled.setCursor(0, 0);
  oled.print("ED");
  oled.display();
  delay(1000);
}

void loop()
{
  pixelExample();  // Run the pixel example function
  lineExample();   // Then the line example function
  shapeExample();  // Then the shape example
  textExamples();  // Finally the text example
}

// Center and print a small title
// This function is quick and dirty. Only works for titles one
// line long.
void printTitle(String title, int font)
{
  int middleX = oled.getLCDWidth() / 2;
  int middleY = oled.getLCDHeight() / 2;
  
  oled.clear(PAGE);
  oled.setFontType(font);
  // Try to set the cursor in the middle of the screen
  oled.setCursor(middleX - (oled.getFontWidth() * (title.length()/2)),
                 middleY - (oled.getFontWidth() / 2));
  // Print the title:
  oled.print(title);
  oled.display();
  delay(1500);
  oled.clear(PAGE);
}



Comment préparer et afficher des images Bitmaps


Vous voudrez très certainement afficher plus qu’un simple texte sur votre petit écran. Voici deux solutions pour convertir vos Bitmaps en chaine Hexa.


LCD Assistant


LCD Assistant est un petit utilitaire bien pratique qui va vous permettre de convertir d’importe quel image au format Bitmap en un tableau de caractères pouvant être affiché sur votre mini écran OLED. LCD Assistant est recommandé par Sparkfun mais vous en trouverez d’autres sur internet avec les mots clés “convert bitmap to graphic lcd”.


Pour commencer vous devez disposer d’une image au format Bitmap. Après quelques tests, je vous conseil de redimensionner votre image pour quelle soit compatible avec l’écran cible. LCD Assistant est un programme bien pratique mais déjà ancien, il ne faut pas trop lui en demander et corriger à la main les petits défauts. J’ai pris pour cet exemple le logo de Projets DIY que j’ai redimensionné en 64 x 64 pixels (le logo est carré). Exportez l’image au format BMP monochrome. Si votre image dépasse la résolution demandée, elle sera tronquée et seule la partie en haut à gauche de l’image importée sera générée. J’ai obtenu le meilleur résultat en prenant la taille inférieure de 48×48 pixels.


Ouvrez l’image dans LCD Assistant en laissant 8 pixels/byte, orientation verticale pour Byte Orientation. Exportez le tableau via File -> Save Output. Donnez d’importe quel nom avec une extension .txt par exemple pour pouvoir ouvrir facilement le fichier avec un petit éditeur de texte. Vous obtiendrez une variable contenant votre image convertie. La conversion n’est pas toujours parfaite, bien souvent (toujours !!) vous devrez supprimer la première ligne du tableau [0x40, 0x00, 0x40, 0x00,] (attention de ne pas oublier la virgule).


//------------------------------------------------------------------------------
// File generated by LCD Assistant
// http://en.radzio.dxp.pl/bitmap_converter/
//------------------------------------------------------------------------------

const unsigned char icone [] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x60,
0x60, 0x60, 0x60, 0x60, 0xFF, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFF, 0x60, 0x60, 0x60, 0x60,
0x60, 0x60, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x10,
0x10, 0x10, 0x10, 0x10, 0xFF, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0xFF, 0x10, 0x10, 0x10, 0x10,
0x10, 0x10, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x08,
0x08, 0x08, 0x08, 0x08, 0xFF, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xFF, 0xF8, 0xF8, 0xF8, 0xF8,
0xF8, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x04,
0x04, 0x04, 0x04, 0x04, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC,
0xFC, 0xFC, 0xFC, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};


Affichage d’un bitmap à l’aide de la librairie Sparkfun


On commence par nettoyer l’écran


oled.clear(ALL);


En imaginant que votre écran OLED soit déclaré avec l’objet oled, il suffit d’appeler la fonction drawBitmap en lui passant en paramètre la variable contenant l’image à afficher.


oled.drawBitmap(bender);


Maintenant on actualise l’écran. C’est tout


oled.display();


Affichage d’un bitmap avec la librairie Adafruit_GFX


La librairie Adafruit_GFX utilise une variable PROGMEM pour stocker l’image. La variable suivante a été générée à l’aide d’image2cpp présenté au prochain paragraphe


const unsigned char myBitmap [] PROGMEM = {
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x10, 0x08, 0x07, 0xff, 0xff,
0xff, 0xff, 0xe0, 0x10, 0x08, 0x07, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x10, 0x08, 0x07, 0xff, 0xff,
0xff, 0xff, 0xe0, 0x10, 0x08, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xe0, 0x1f, 0xf8, 0x07, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x1f, 0xf8, 0x07, 0xff, 0xff,
0xff, 0xff, 0xe0, 0x1f, 0xf8, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xe0, 0x10, 0x08, 0x07, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x10, 0x08, 0x07, 0xff, 0xff,
0xff, 0xff, 0xe0, 0x10, 0x08, 0x07, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x10, 0x08, 0x07, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xe0, 0x1f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,};


Les commandes sont très similaires à celles de Sparkfun. On commence par nettoyer l’écran


display.clearDisplay()


La commande drawBitmap nécessite les paramètres suivants : position x, position y, variable contenant le bitmap, largeur, hauteur, couleur. Pour mes tests, j’ai un écran de 128×32 pixels. Pour obtenir un logo carré, j’ai étendu l’image en doublant le nombre de pixels de x (64×32).


display.drawBitmap(32,0,myBitmap,64,32,WHITE);


On actualise l’affichage


display.display();




Convertir une image bitmap en ligne avec Image2CPP


image2cpp est un outil de conversion de bitmap en chaine hexa pour afficheur LCD disponible en ligne à cette adresse http://javl.github.io/image2cpp/. image2cpp est beaucoup plus récent que LCD Assistant. image2cpp est aussi beaucoup plus puissant. Il vous permettra :


    

  • De choisir une taille de génération différente du fichier image
    • 

  • De choisir le mode de mise à l’échelle
    • 

  • D’ajuster le niveau de gris de seuillage (Brightness threshold) entre le noir et le blanc si vos choisissez une image en couleur ou en niveau de gris.
    • 

  • De re-centrer l’image verticalement et/ou horizontalement.
    • 

  • D’inverser les couleurs
    • 

  • D’ajouter du code Arduino qui définit la variable qu’il ne restera plus qu’à renommer après l’avoir collé dans votre code.
    • 



Un autre fonction très pratique et la possibilité de visualiser l’image qui sera produite par l’écran OLED en collant la chaine Hexa dans la zone “Paste byte array”. Par contre pour que cela fonctionne correctement, rechargez la page si vous aviez fait une conversion d’image avant.




Si vous avez un petit projet à réaliser et que vos trouvez que la programmation Arduino  demande trop d’effort, le firmware ESP Easy permet d’afficher très simplement des informations sur un mini écran OLED. Il n’est pas possible d’afficher des images ou faire des animations, mais c’est suffisant pour débuter.




D’autres projets et tutoriels utilisant l’écran OLED SSD1306


Mises à jour


26/08/2020 Actualisation du style














Avez-vous aimé cet article ?


[Total: 2 Moyenne: 5]