Utilisation graphique de l’afficheur OLED.

PROGRAMMER L’OLED SSD1306.

Avant de chercher à optimiser du code C++ nous allons passer en revue rapidement les instructions de base proposées dans la bibliothèque Adafruit_ssd1306syp.h en commençant par du texte. Puis rapidement nous allons tracer un LOGO. Il sera alors temps de programmer les fonctions du PICOLAB. Puisque par conception cet afficheur est constitué d’une matrice de points que l’on peut allumer ou éteindre, c’est tout naturellement que l’on va commencer par dessiner.

Tracer des points, des lignes, des cercles et des rectangles.

Strictement enfantin informatiquement puisque ces éléments graphiques sont intégralement pris en charge par Adafruit_ssd1306syp.h. Pour se rendre compte à quel point ce type de programmation est aisé, nous allons réaliser un fabuleux projet P02_MINOU.ino qui implique l’utilisation de toutes les ressources graphiques de la bibliothèque.
Chaque fois que l’on désire tracer sur l’écran, que ce soit du texte ou des éléments géométriques, si vous désirez éviter de perdre un temps considérable dans des tentatives approximatives, il faut IMPÉRATIVEMENT définir en détail ce qui sera affiché sur l’écran. Fondamentalement c’est d’un banal à pleurer, car il suffit de déterminer les coordonnées géométriques comme elles sont définies sur la Fig.43 et ajouter l’instruction idoine. Vous devez ABSOLUMENT tracer votre œuvre d’art sur une grille telle que celle de la Fig.44 donnée ci-dessous et ainsi déterminer la position exacte de chaque point « stratégique ». C’est volontairement que sur cette grille aucun dessin n’a été ajouté pour éviter de la « polluer ». Vous pouvez ainsi l’imprimer si elle vous convient.

La Fig.45 exploite cette grille et permet de clarifier le projet « MINOU ». Nous allons analyser en détail certaines instructions, bien que globalement le programme P02_MINOU.ino coule de source. En préambule, ouvrir un croquis vierge et n’y inscrire que les deux instructions obligatoires :
void setup {}
void loop {}
C’est le plus petit programme acceptable par l’IDE. La procédure d’initialisation ne fait strictement rien. La procédure de base loop ne fait que boucler sans fin, sans rien faire autre que le saut.
Quand on compile ce logiciel « inerte », on consomme déjà 450 octets dans la mémoire de programme, et 9 octets dans la RAM dynamique. C’est que l’IDE place déjà plusieurs modules dont il aura besoin dans quasiment tous les programmes.

#include <Adafruit_ssd1306syp.h>
Placée tout au début cette directive permet de préciser qu’une bibliothèque différente de celles connues par défaut va être utilisée. Ce n’est qu’une information qui sera utilisée par la suite. Compiler à ce stade n’ajoute que 28 octets de programme et 6 emplacements de RAM dynamique.

#define broche_SDA 6 // D6 utilisée en sortie.
#define broche_SCL 7 // D7 utilisée en sortie.
On précise au compilateur la valeur numérique des deux constantes broche_SDA et _SCL. Cette directive ne consomme aucun octet. Ce n’est qu’une information disponible pour le compilateur.

Adafruit_ssd1306syp display(broche_SDA, broche_SCL);
Cette instruction crée réellement une instance pour l’afficheur OLED. L’ensemble des modules informatiques de la bibliothèque Adafruit_ssd1306syp.h est amené en mémoire de programme. La taille du programme passe à 5864 octets et la mémoire dynamique consommée monte à 104 octets.
Et encore, l’afficheur n’a toujours pas été initialisé. Dans la routine void setup {} on ajoute :

display.initialize();  delay(300);  display.clear(); display.update();
La taille du programme passe à 5938 octets soit 18%. La RAM dynamique reste inchangée à 104 octets soit 5% de consommé. Nous n’avons fait qu’effacer l’écran et presque un cinquième de l’espace mémoire est consommé. C’est le prix à payer pour utiliser cet afficheur. Ceci étant vérifié, maintenant la « consommation » va diminuer, car l’on ne va faire que des appels à des modules, et à ce prix on peut aussi-bien faire du dessin qu’écrire du texte. Comme pour les autres appareils de mesure, nous devons en permanence optimiser le code si l’on désire pourvoir PICOLAB d’un maximum de fonctions. NOTEZ au passage un détail important. L’initialisation de l’afficheur est suivie d’un délai de 0,3 seconde. Il faut obligatoirement ce délai si l’on veut que l’afficheur réagisse correctement à la mise sous tension. Oublier cette instruction : Au branchement de l’alimentation l’écran reste noir, et il faut effectuer un RESET sur la platine BOARDUINO.

Chaque fois que l’on a écrit une instruction d’affichage du genre display.print(« Bonjour. »); on croit que le texte (Ou l’élément graphique …) sera visualisé. Et bien non, il n’a été écrit que dans la RAM de l’afficheur. Pour voir l’effet se concrétiser sur l’écran LCD il faut transférer les pixels RAM sur les pixels lumineux par l’instruction obligatoire display.update();

REMARQUE : Le programme P01_Test_du_materiel.ino vous permet de tester le matériel. Forcément il utilise les routines propres à l’afficheur. Il n’a pas de vocation pédagogique, c’est uniquement un outil de mise au point. À ce titre, il ne sera pas analysé. La façon de s’en servir est précisée dans le texte de présentation et de commentaires placé en tête.

x
Pour construire le dessin, il suffit de le décomposer en éléments géométriques simples, puis de les faire tracer en utilisant les fonctions appropriées de la bibliothèque Adafruit_ssd1306syp.h Le plus laborieux consiste à extraite du croquis de la Fig.45 les coordonnées des points caractéristiques. Prenez garde que pour le rectangle on définit l’un des angles, puis sa largeur et sa hauteur et non sa diagonale comme c’est souvent le cas dans les langages graphiques. Notre programme est passé à 7144 octets soit 1198 octets pour tracer ce portrait. Le graphisme semble bien glouton en octets, il va falloir ruser au maximum. Dernier point « scabreux » : Les tracés ignorent la présence de la ligne inerte sur le type bicolore. De ce fait il y aura un « décalage de discontinuité » comme montré sur la Fig.46 sur laquelle le dessin blanc prouve que le programme est correct. Il faudra faire avec …

Tracer des textes de tailles variables …

Contrairement à ce que l’on pourrait penser, nous l’avons déjà vu au cours de nos périples informatiques, écrire du texte revient à construire des petits dessins. Pour chaque caractère on doit concevoir une « tête de MINOU », sauf que l’expérience prouve qu’une définition de 5 x 7 pixels est suffisante. En fait 5×8 pour l’interlignage. L’empreinte de chaque caractère va consommer cinq octets dans la mémoire de programme. Comme la bibliothèque Adafruit_ssd1306syp.h en fournit 256, au final la place qu’elle empiète en mémoire dynamique est importante. Nous verrons plus avant les conséquences, et comment contourner les difficultés qui en résultent.
Quand vous programmerez, vous aurez parfois le besoin d’employer un caractère particulier, c’est à dire qui sort de l’alphabet et des chiffres. Par exemple on va utiliser le « tilde » pour alternatif, le caractère oméga pour les unités des résistances etc. Pour explorer le jeu complet des « matrices » disponibles, le petit programme Afficher_le_jeu_de_caracteres.ino rangé dans le dossier spécifique <OUTILS> visualise l’intégralité des 255 empreintes.
Dans ce chapitre, nous allons faire appel aux fonctions de base de la bibliothèque pour en exploiter les procédures gérant du texte. Le programme élémentaire P03_TEXTE.ino passe en revue les diverses méthodes de la bibliothèque. Il n’y a qu’à puiser dans ses ressources.

Bien que globalement ce programme est fait d’évidences, surtout si l’on étudie un minimum la bibliothèque décrite ci-avant, un ou deux petits détails sont toutefois à souligner. Après avoir effacé la mémoire de l’afficheur pour en vider le contenu, on trouve l’instruction en ligne 18 qui positionne le « curseur » pour la prochaine écriture. On doit indiquer les coordonnées du pixel Haut/Gauche de la matrice du premier caractère qui sera visualisé. Puis, en ligne 20 on demande au logiciel d’afficher les textes en noir sur fond éclairé. (Surbrillance.) Comme on va effectuer trois affichages « en ligne », les deux premières instructions sont de type display.print() contrairement à l’instruction de la ligne 24 qui avec display.println() fait passer le curseur d’écriture à la ligne logique suivante. (En fonction de la taille des caractères : 8, 16, 24 pixels plus bas …)
Observez tout particulièrement la ligne de programme 23 codée display.print(char(133));
C’est par ce type d’instruction que l’on peut faire afficher un caractère particulier en indiquant l’ordre qu’il occupe dans le tableau des matrices. Quand vous désirez faire afficher un tel caractère, pour en trouver l’ordre utiliser Afficher_le_jeu_de_caracteres.ino, repérez l’empreinte souhaitée et comptez depuis le début qui commence en zéro. Le reste du programme n’appelle pas de commentaire. Vous y trouvez des affichages sous différentes bases dans les lignes 29, 30 et 31. En ligne 28 on affiche la valeur d’un réel avec quatorze décimales. Comme ce programme n’effectue aucun calcul et ne génère aucun réel, on a ici utilisé la constante prédéfinie PI. Pour la petite histoire, les décimales affichées ne sont pas toutes correctes. Voici les neuf premières 3.141592654 de ce nombre transcendant. Bon, on ne va pas trainer le compilateur C++ au tribunal, il nous rend bien trop de services …

>>> Page suivante.