L’afficheur OLED SSD1306.

Présentation de ce tout petit écran graphique.

Quand à la réception du coli postal on ouvre le paquet et que l’on sort ce minuscule module, on reste dubitatif en considérant ses dimensions vraiment discrètes. L’écran en verre ne mesure que 27 x 15mm. Tant que l’on n’a pas vu ce que donne une si petite image, on ne peut que douter de l’efficience de ce composant. Rapidement on « triture » un programme pour afficher le plus grand cadre possible, pour se rendre compte que ses dimensions ne font plus que 22mm x 16mm. Le doute devient encore plus sérieux. Et pourtant, dès que l’on arrive à afficher du texte, la plus petite police reste parfaitement lisible. « Traçons » ensuite des traits, des rectangles, des cercles, une sinusoïde, tout ce petit monde graphique s’avère parfaitement visible, et immédiatement le doute s’évapore. Un si petit écran remplit totalement sa mission, comme vous pouvez le vérifier sur la Fig.39, le plus petit texte en taille ainsi que les graphes sont très facilement « lisibles ». Sur cette photographie, le texte BONJOUR utilise la plus petite police de caractères de 5 x 7 pixels. (Soit une matrice de texte bien classique.) La netteté est en outre un peu dégradée par le manque de définition de cette photographie, sur laquelle figure en haut à droite un pixel isolé. Il n’y a plus qu’à programmer …

Faisons connaissance avec l’afficheur SSD1306.

Plusieurs bibliothèques personnalisées sont disponibles sur la toile. Il faut bien faire un choix. Celle utilisée dans les programmes proposés dans ce didacticiel nous a semblé la plus « populaire ». Il s’agit de la « library de référence » Adafruit_ssd1306syp.h disponible sur de nombreux sites. Par exemple on peut aller sur :
http://www.codeforge.com/read/242813/Adafruit_ssd1306syp.h__html
Tous les programmes qui vont suivre vont utiliser ce module logiciel. Pour les comprendre il faudra consulter en permanence le chapitre Méthodes de la bibliothèque Adafruit_ssd1306syp.h qui détaille chaque instruction de cette bibliothèque.
Disposant de ses fonctionnalités, programmer le SSD1306 devient un jeu d’enfant … Encore que !
En effet, pour tracer tout ce que l’on désire, le code est immédiat pour peu que l’on s’imprime une grille de 64 x 128 carreaux pour repérer les coordonnées. Mais la petite puce fait de la résistance. Le petit écran ne se laisse pas faire et nous oppose dès le départ deux difficultés.

Première embuche : L’approvisionnement peut nous réserver une petite surprise. Ayant mis en service le premier de ces composants dans le boitier décrit dans ce document, il s’avérait plus commode d’en disposer d’un second relié à un module Arduino pour développer les programmes. Il est ainsi facile d’avoir un outil pour programmer, et un outil pour observer l’aspect de l’affichage quand l’écran est enfermé dans une lucarne. L’effet visuel n’est pas identique et il faut effectuer des essais de temps en temps. Ne pas avoir à débrancher en permanence le petit module est plus raisonnable. Ayant commandé la même référence, j’ai reçu un modèle un peu différent. Comme montré sur la Fig.40 en B il est bicolore, avec une zone orange de 16 lignes en haut, une ligne de séparation sans pixel (Repérée en rouge.) et le reste inférieur en bleu. Du coup, avec le même programme on constate qu’en blanc sur la photographie A il y a continuité du tracé, alors qu’en bicolore sur l’image B il y a une discontinuité entre les deux couleurs.
Renvoyer le produit au fournisseur était une option, mais tout compte fait, la couleur rend l’écran bien plus attrayant. Par exemple les deux photographies sur la Fig.41 en C et D montrent le résultat de l’affichage pour la fonction voltmètre. Compte tenu de la définition du SSD1306 il devient possible de visualiser à la fois la version analogique et l’option numérique. Les items dans le MENU de base seront ainsi moins nombreux. En tenant compte dans les programmes de la ligne sans pixels, on peut concevoir un logiciel qui favorise l’esthétique, les deux couleurs mettant en

évidence des informations de type différent. La version en blanc est bien moins accrocheuse. (ATTENTION : Les images présentées dégradent considérablement la finesse réelle de l’afficheur, car l’appareil photographique n’est pas prévu pour prendre des clichés en objectif rapproché.) Le seul cas où la perte de cette ligne de pixels peut s’avérer pénalisante, c’est celui de l’oscilloscope. Un programme strictement identique anime les deux écrans des photographies E et F. Sur F la discontinuité est discernable.
Personnellement je trouve que la couleur est très séduisante, et l’inconvénient de discontinuité faible puisqu’il n’est présent qu’en mode « dessin ». Pour que chacun puisse choisir à sa guise le modèle d’afficheur utilisé, tous les programmes seront conçus sur l’afficheur bicolore. (Prise en compte de la discontinuité.) Ainsi les deux versions du composant seront totalement compatibles.

Deuxième difficulté : Fonctionnant en allumant et en éteignant des pixels, l’effacement de l’afficheur total ou partiel prend du temps. Quand on recherchera de la rapidité de rafraichissement sur l’écran, il faudra faire un gros effort logiciel pour que le code soit optimisé en rapidité d’exécution. Y compris dans ces conditions il ne sera pas possible d’obtenir la « fluidité » des deux grands frères du PICOLAB. Rassurez-vous, mis à part quelques cas particuliers, et d’un usage marginal, dans l’ensemble les performances au final restent très « compétitives ».

Installer la bibliothèque indispensable.

Naturellement vous avez installé dans votre IDE la bibliothèque Adafruit_ssd1306syp.h, c’est un incontournable. Nous avons déjà abordé la notion de bibliothèque lors du didacticiel sur le MINI LABORATOIRE. Ceci dit, comme nous sommes dans un contexte de programmation sur le système Arduino, vous avez certainement déjà installé plusieurs « library ». Pour ceux qui n’ont jamais été obligé de le faire, ce n’est pas bien compliqué :

1) Téléchargez la bibliothèque dans un répertoire quelconque,
2) Décompacter le fichier ZIP dans ce répertoire.
3) Placer le dossier de la bibliothèque décompressé dans un répertoire de votre choix, celui dans lequel vous préserverez toutes les « library » que vous ajouterez à votre environnement IDE.
4) Déclarer la nouvelle bibliothèque dans la liste disponible :
Croquis > Importer bibliothèque … > Add Library …
Indiquer le chemin de votre dossier personnel sur le H.D. (Précisé en (3).) La bibliothèque est alors ajoutée dans un dossier personnel :
<C:\Users\VotreOrdi\Documents\Arduino\libraries>
ou éventuellement dans
<C:\Users\user\Documents\Arduino\libraries>.
5) Recharger un programme quelconque. Cliquer sur Croquis puis placer le curseur de la souris sur Importer bibliothèque … : En 1 on découvre les bibliothèques disponibles par défaut et en 2 les bibliothèques importées. Vous devez y trouver Adafruit_ssd1306syp.h comme mis en évidence dans l’encadré rouge.

C’est parfait, nous pouvons enfin passer à la programmation.

Méthodes de la bibliothèque Adafruit_ssd1306syp.h.

Spécifique à l’afficheur graphique monochrome miniature OLED SSD1306, cette bibliothèque est suffisante pour mettre facilement en œuvre  ce produit aussi bien pour du tracé géométrique que pour de l’affichage de textes. (Monochrome et bicolore Jaune/Bleu.)

Initialisations diverses.

Adafruit_ssd1306syp display(broche_SDA, broche_SCL);                           .
Cette directive doit être placée avant void setup() et précise les deux sorties binaires d’Arduino qui seront utilisées pour interfacer l’I2C. Il n’est pas utile de configurer ces deux broches en sorties.

display.initialize();        Instruction à placer dans void setup() avant toute utilisation de l’afficheur. Cette instruction se charge de définir les deux broches affectées à la ligne I2C en sorties. Les broches A0 à A5 sont parfaitement utilisables en sorties. (Déclarations avec 14 à 19 pour leur repère.)

Principe des d’affichages. 
Qu’il soit graphique ou texte, un affichage se fait toujours en deux phases. La première action consiste à placer les « pixels » dans la mémoire tampon 128 x 64 de l’afficheur. La deuxième action consiste à transférer les BIT de la mémoire dans les PIXELs sur l’écran LCD avec l’instruction display.update(); ligne indispensable même pour l’instruction display.clear(); d’effacement de l’écran.
La Fig.43  ci-contre précise les diverses valeurs des coordonnées des pixels.

 Affichages graphiques. (Voir Fig.43)

display.drawPixel(X, Y, WHITE);
Procédure qui permet de gérer l’afficheur point par point. Elle allume le pixel de coordonnées X et Y si le paramètre de lumière est WHITE ou éteint le point si le paramètre est BLACK.

display.drawLine(Xd, Yd, Xf, Yf, WHITE);
Procédure qui trace une ligne entre les deux points dont on précise les coordonnées. WHITE ou BLACK précise si on trace en blanc ou en noir. L’ordre de définition des extrémités est quelconque.

display.drawRect(Xo, Yo, Largeur, Hauteur,WHITE);
Procédure qui trace un rectangle dont on précise les coordonnées de l’Origine, la Largeur et la Hauteur. WHITE ou BLACK précise si on trace en blanc ou en noir. Largeur et hauteur peuvent avoir des valeurs négatives et sont alors tracés vers la gauche et vers le haut.

display.drawCircle(Xo, Yo, Rayon, WHITE);
Procédure qui trace un cercle dont on précise les coordonnées du centre et la valeur du Rayon. WHITE ou BLACK précise si on trace en blanc ou en noir. Gère les débordements de la zone 127 x 63.

Affichages des textes.

display.setTextColor(WHITE);     Procédure qui définit la « couleur » du texte. (Noir si BLACK.)

display.setTextColor(TEXTE,FOND);
Procédure qui définit la couleur du texte puis du fond. Par exemple display.setTextColor(BLACK, WHITE); fait passer le texte en « surbrillance » par inversion écriture en noir sur fond blanc.

display.setCursor(X, Y);      Positionne le pixel « Haut/Gauche » de la prochaine écriture textuelle.

display.setTextSize(Taille);       Définit la taille des caractères, la plus petite valeur étant 1.
1 : Matrice 5×7, 2 : Le double, (10×14) 3 : Le triple (15×21) etc.

display.print(Donnée);   ou pour changer de ligne  display.println(Donnée);
Affiche la donnée à partir de la position actuelle « du curseur ». Gère les débordements de la fenêtre
127 x 63, le texte dépassant du domaine affichable sera ignoré. Le format de la Donnée peut être :
display.println(« Texte quelconque. »); (1)
display.print(‘A’); (1)  (Caractère entre cotes ou valeur numérique de son code.)
display.print(PI,8); Valeur et en option le nombre de décimales.
display.println(1234, « BASE »);    avec BASE = BIN : Binaire / HEX : Hexadécimal / OCT : Octal.

(1) : Matrices de cractères standards ASCII au format 5×7 pour le coefficient 1.

>>> Page suivante.

9 réflexions sur « L’afficheur OLED SSD1306. »

    1. N’étant pas chez moi, je ne trouve ton post que ce matin.
      Pour pouvoir répondre à ta question, peux-tu m’indiquer le document et la Fig sur lequel est fait mention ce composant S T P ?
      Comme le didacticiel est volumineux, je ne retrouve pas le schéma sur lequel figure ce condensateur.
      Il y a fort à parier qu’il s’agit d’un condensateur de découplage. Si c’est le cas, sa valeur n’est absolument pas critique. Toute valeur entre 10nF et 0,1µF conviendra. C’est alors plus une question de volume du composant qu’autre chose. Il faut aussi vérifier que sa tension de service soit suffisante. En général, je puise dans mes « réserves » un élément disponible. Du coup j’en précise la valeur, mais c’est uniquement pour que le lecteur « débutant » puisse avoir une référence.
      Reste que si un composant est « critique », lors de la mise au point je teste les valeurs extrêmes tolérables, et j’indique sur mon schéma la valeur normalisée la plus proche de la moyenne.
      Amicalement : Nulentout.

  1. Quelle est la différence entre les bibliothèques
    Adafruit_ssd1306syp.h et Adafruit_ssd1306.h ?
    La bibliothèque Adafruit_ssd1306syp.h est en libre téléchargement mais elle est payante

    1. Il m’est difficile de répondre, car personnellement je n’utilise que les bibliothèques gratuites, qui jusqu’à présent se sont révélées largement suffisantes.
      Amicalement : Nulentout

  2. Bonjour
    Bravo, tuto « incroyable » pour le jour où j’aurais à tirer le maximum de ces petits écrans !
    Pour l’heure j’ai un bête problème d’adressage, pourrais je vous le soumettre ? en gros, j’échoue à faire reconnaître des adresses I2C passées via le constructeur dans les instances d’une classe dédiée à ces afficheurs ; pourtant en forçant directement cette adresse par une variable déclarée dans la classe, le display.begin est OK ! Malgré bien des essais bien sûr, j’ai pas trouvé. Je serais heureux de votre aide. En détaillant si besoin les lignes de code concernées mais elles sont tout à fait banales et sans problèmes dans d’autres cas.
    Dans tous les cas merci d’une réponse.
    bien cordialement
    P SIMON

    1. Quelle est l’adresse que vous essayez de mettre ? il y a un vielle confusion liée au fait que les adresse I2C sont sur 7 bits, avec le dernier bit réservé pour indiquer si on est en lecture et en écriture …
      Est ce que cela ne serait pas lié à votre problème.
      PS : Pour des réponses plus rapide il est mieux de passer par le forum 😉 http://www.robotix.fr/forum

  3. Bonjour les amis, bonjour SIMON,
    Rentrant d’un déplacement estival, je viens de découvrir la question relative à l’adressage du petit afficheur OLED. Du coup, je ne réponds qu’avec beaucoup de retard. Je ne suis pas certain de bien comprendre où se situe ta difficulté.
    Pour ma part, j’imagine qu’il s’agit des deux broches que sur le processeur tu vas utiliser pour échanger les signaux avec l’afficheur. Il y a longtemps que j’avais fait ce didacticiel, et je ne sais plus quels sont les critères que j’avais pris en compte pour sélectionner les E/S pour ce programme.
    Pour ma part, le logiciel fonctionnant parfaitement, je n’ai pas vraiment soulevé le capot pour étudier le fonctionnement des routines de la bibliothèque.
    Traduction : Je ne suis pas capable d’apporter une aide pertinente. La seule chose que je peux t’affirmer, c’est que le ou les programmes que je propose fonctionnent parfaitement pour peu que la bonne carte Arduino soit déclarée. (Comme je passe souvent de la UNO à la NANO parfois je me suis enlisé dans des faux problèmes.)
    Bien respecter l’ordre des déclarations, c’est également un facteur de difficultés.
    Désolé de ne pouvoir me montrer plus pertinent, mais en l’occurrence, chaque fois qu’un module qui n’est pas de mon fait ne fonctionne pas, je suis généralement incapable de savoir si c’est le matériel ou le logiciel. Si ça fonctionne j’adopte, je creuse les méthodes d’utilisation, je me fais des fiches pour ne pas oublier ; et dans le cas contraire, après avoir épuisé toutes mes ressources … j’abandonne !
    Amicalement : Nulentout.

  4. Bonjour,

    Comment reussir a afficher une valeur negative d’un nombre a virgules issu d’un calcul fait sur une entrée analogique ?
    Le signe.- se position systematiquement au milieu

  5. Bonjour les amis,
    Oui, ces problèmes d’affichage c’est toujours la galère. Pour te répondre, il faudrait avoir une idée du calcul par savoir sous quel type de donnée est disponible ton résultat, et surtout sur quoi tu désires afficher. En effet, que ce soit sur un écran quelconque ou sur la ligne série USB du moniteur, la programmation ne sera pas du tout la même.
    Amicalement : Nulentout.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *