 |
Librairie Arduino esp8266 et esp32 |
Février 2021 |
Si vous n'avez pas déjà utilisé l'une des librairies sai_oled ou menu_oled
il faut directement choisir la
librairie lib_1306_rot qui regroupe
toutes les fonctions des librairies citées
ainsi que des fonctions additionnelles.
Quand on développe sur Arduino où ESP on a souvent besoin d'adapter son montage à un environnement spécifique, réseau wifi,
vitesse de l'interface série, nom d'une action... cette librairie va permettre par exemple de saisir, un SSID Wifi et le mot de passe du réseau, ceci évite de
connaitre au moment de la création du code ces informations et donc le mot de passe n'apparaitra plus codé en dur dans le code.
Cette librairie est utilisée à plusieurs reprises dans ce site voir les exemples dans le chapitre électronique.
L'objet permettant la saisie propose 4 types d'écrans :
Chaque écran est divisé en trois parties :
A droite : Un premier menu qui permet de choisir le type de saisie (Majuscule, minuscule, spéciaux ou validation). Si l'on va en bout d'un menu on passe à l'autre menu.
A gauche : Une liste des caractères sélectionnés par le choix du menu de droite. Par exemple la liste des majuscules. A chaque appui sur le bouton le caractère est sélectionné
et affiché en partie 3, mais en cas d'erreur, il est possible de corriger avec le menu "val".
En bas : Le texte issue des sélections effectuées. Il est possible de valider ou d'annuler cette saisie avec le menu "val".
Une option modifiable dans le code permet de passer à l'autre menu par le haut et par le bas : sortie_deb(true) Quand cette option est à true, on gagne du temps dans la saisie
car il est possible de passer d'un menu à l'autre beaucoup plus rapidement mais le bouton devient plus difficile à maitriser. Perso je laisse cette option à false, à vous de tester...
Comme on peut le voir sur les photos l'utilisation d'un écran bicolor massacre un peu les affichages, attention lors de la commande !
L'encodeur rotatif est disponible en brut ou sur plaquette qui doit inclure 3 résistances de rappel au + (positif).
Différents Encodeurs rotatifs sont supportés mais l'objet a été créée avec un KY-040 30 pas.
Cette librairie a été développée avec un encodeur qui comporte bien une résistance de rappel au positif sur les trois signaux. Il existe cependant sur le marché des
encodeurs sur plaquette ou la résistance sur le signal "SW" n'a pas été installée, pour fonctionner avec cette librairie cette résistance doit être ajoutée.
Voir ici en bas de page.
Si vous utilisez un encodeur brut (sans pré câblage sur une plaquette)
vous devez réaliser le câblage des résistance comme sur le schéma ci-contre.
Dans cette version le LCD et l'encodeur sont directement connectés au microprocesseur. Sur ce schéma j'ai repris les numéros de port de l'exemple
si vous utilisez un autre processeur, vous devez adapter les numéros de port et utiliser dans votre code les numéros correspondants.
Je vous livre ici le code complet en "Open Source".
Si vous utilisez ce code, merci de mettre un lien vers ce site : https://castoo.fr
Attention c'est celle-ci
qu'il faut télécharger sur le site "github", elle est différente de celle qui est disponible dans l'environnement "Arduino".
On la reconnait au "w" de Wire qui doit dans notre cas être une majuscule. (Merci à Guy, pour cette précision qui peut éviter pas mal de galère !).
Merci également à tous les contributeurs(46) de ce petit package qui contient plusieurs librairies. Vous devez charger le zip complet comme montré sur
l'image ci-contre.
// sai_oled.h
// Saisie de texte sur LCD Oled 1306
// Affichage/Saisie depuis trois écrans de caractères majuscule/minuscule/numérique ou spéciaux
// Castoo
// Décembre 2019
/*
sai_oled.h
- Objet destiné à être utilisé avec Arduino ou ESPxxx.
Possibilité de supporter différents LCD mais l'objet a été créée avec un OLED SD1306
Possibilité de supporter différents Encodeurs rotatifs mais l'objet a été créée avec un KY-040 30 pas
Création Jean Michel Castille décembre 2019 / castoo.fr
Cette bibliothèque est un logiciel libre;
Vous pouvez la redistribuer et ou la modifier.
Cette bibliothèque est distribuée dans l'espoir qu'elle sera utile,
mais SANS AUCUNE GARANTIE, sans même la garantie implicite de
QUALITÉ MARCHANDE ou ADÉQUATION À UN USAGE PARTICULIER.
*/
#ifndef sai_oled_h
#define sai_oled_h
#include
#include "SSD1306Wire.h"
class sai_oled{
private:
uint8_t PinCLK; // Gpio x sur sortie Clk du selecteur rotatif
uint8_t PinDT; // Gpio x sur sortie DT du selecteur rotatif
uint8_t PinSW; // Gpio x sur sortie SW du selecteur rotatif
String ch_saisie; // Chaine de la saisie avec le menu sur OLED
uint8_t val_ch; // Fin de la saisie
bool flech_d; // sens des fleches dans menu sel chaine
bool sortieH; // Permet la sortie rapide aprés saisie d'un caractère lors du balayage.
SSD1306Wire *_ecran; // Ecran OLED
#define nb_ch_menu_Alpha 4 // Nombre de choix du menu Alphanumérique
String ch_menuAlpha[nb_ch_menu_Alpha] = { "Maj", "Min", "Spe", "Val" }; // Choix du menu Alphanumérique
#define nb_ch_menu_Valid 4 // Nombre de choix du menu Validation
String ch_menuValid[nb_ch_menu_Valid] = { "Correction", "Tout effacer", "Validation", "Annulation" }; // Choix du menu valid
public:
// Constructeur objet avec les 3 signaux clk, dt et sw du rotatif ainsi qu'un pointeur vers l'OLED
sai_oled(uint8_t vclk, uint8_t vdt, uint8_t vsw, SSD1306Wire &ecran);
// Initialisation de l'écran
void init(void);
// Affichage du menu alphanumerique retourne la chaine saisie ou "";
String aff_menu_Alpha(void);
// valide ou invalide la sortie du balayage des caracteres aprés chaque saisie (valide par defaut)
void sortie_deb(bool val);
private:
void aff_menu_alpha_maitre(uint8_t pos);
void aff_menu_alpha_string();
void maj_ch(uint8_t pos, uint8_t menu);
void aff_menu_Alpha_Maj(uint8_t pos, bool en_cours);
void aff_menu_Alpha_Min(uint8_t pos, bool en_cours);
void aff_menu_Alpha_Spe(uint8_t pos, bool en_cours);
void aff_menu_Alpha_Val(uint8_t pos, bool en_cours);
void aff_menu_alpha_zones(uint8_t pos, uint8_t menu, bool val_sys, bool val_det);
uint8_t sel_menu_Alpha(uint8_t max);
uint8_t sel_menu_Alpha_detail(uint8_t max, uint8_t menu);
};
#endif
// sai_oled.cpp
// Saisie de texte sur LCD Oled 1306
// Affichage/Saisie depuis trois écrans de caractères majuscule/minuscule/numérique ou spéciaux
// Castoo
// Décembre 2019
/*
sai_oled.cpp
- Objet destiné à être utilisé avec Arduino ou ESPxxx.
Possibilité de supporter différents LCD mais l'objet a été créée avec un OLED SD1306
Possibilité de supporter différents Encodeurs rotatifs mais l'objet a été créée avec un KY-040 30 pas
Création Jean Michel Castille décembre 2019 / castoo.fr
Cette bibliothèque est un logiciel libre;
Vous pouvez la redistribuer et ou la modifier.
Cette bibliothèque est distribuée dans l'espoir qu'elle sera utile,
mais SANS AUCUNE GARANTIE, sans même la garantie implicite de
QUALITÉ MARCHANDE ou ADÉQUATION À UN USAGE PARTICULIER.
*/
#include "sai_oled.h"
// Constructeur / Initialisation
sai_oled::sai_oled(uint8_t vclk, uint8_t vdt, uint8_t vsw, SSD1306Wire &ecran){
this->PinCLK = vclk; pinMode (this->PinCLK, INPUT); // Clk du selecteur rotatif
this->PinDT = vdt; pinMode (this->PinDT, INPUT); // DT du selecteur rotatif
this->PinSW = vsw; pinMode (this->PinSW, INPUT); // SW du selecteur rotatif
this->_ecran = &ecran; // Ecran OLED
this->sortieH = true; // Autorise la sortie du balayage des caracteres par le début
}
// Initialisation de l'écran
void sai_oled::init(void){
this->_ecran->flipScreenVertically();
this->_ecran->setFont(ArialMT_Plain_10);
this->_ecran->setTextAlignment(TEXT_ALIGN_LEFT);
this->ch_saisie = "";
}
// valide ou invalide la sortie du balayage des caracteres aprés chaque saisie
void sai_oled::sortie_deb(bool val){
this->sortieH = val;
}
// Affichage du menu Alpha
String sai_oled::aff_menu_Alpha(void){
this->val_ch = 2;
while (this->val_ch > 1){
this->sel_menu_Alpha(nb_ch_menu_Alpha);
}
if (this->val_ch == 1) return this->ch_saisie;
else return "";
}
// Affichage menu de selection de fonction du menu alpha
void sai_oled::aff_menu_alpha_maitre(uint8_t pos){
for (uint8_t i = 0; i < nb_ch_menu_Valid; i++) this->_ecran->drawString(105, (12*i), this->ch_menuAlpha[i]);
this->_ecran->drawRect(103, (12*pos), 22, 13);
if(this->flech_d){ this->_ecran->drawString(85, 12, "<<");this->_ecran->drawString(85, 24, "<<");}
else { this->_ecran->drawString(85, 12, ">>");this->_ecran->drawString(85, 24, ">>");}
}
// Affichage menu de selection de fonction du menu alpha
void sai_oled::aff_menu_alpha_string(){
this->_ecran->setFont(ArialMT_Plain_16);
this->_ecran->drawString(0,48, this->ch_saisie);
this->_ecran->setFont(ArialMT_Plain_10);
}
// Un caractere a été selectionné on met à jour la chaine de saisie
void sai_oled::maj_ch(uint8_t pos, uint8_t menu){
uint8_t car = 0;
switch (menu){
case 0 :
car = pos + 64;
break;
case 1 :
car = pos + 95;
break;
case 2 :
car = pos + 32;
break;
case 3 :
switch(pos){
case 0 :
// Correction
this->ch_saisie.remove((this->ch_saisie.length())-1);
break;
case 1 :
// Tout effacer
this->ch_saisie = "";
break;
case 2 :
// Validation
this->val_ch = 1;
break;
case 3 :
// Annulation
this->val_ch = 0;
break;
}
break;
}
if(menu < 3){
char ch_car = car;
this->ch_saisie = this->ch_saisie + ch_car;
}
}
// Affichage du menu Alpha Maj.
void sai_oled::aff_menu_Alpha_Maj(uint8_t pos, bool en_cours){
char ch_i[2];
uint8_t vx;
uint8_t vy;
for (uint8_t i = 64; i < 92; i++){
snprintf(ch_i, 2, "%c", i);
vy = (12 * ((i - 64) % 4));
vx = ((i - 64) / 4) * 10;
this->_ecran->drawString(vx, vy, ch_i );
}
if (en_cours) {
vy = (12 * (pos % 4));
vx = (pos / 4) * 10;
this->_ecran->drawRect(vx, vy, 10, 13);
}
}
// Affichage du menu Alpha Min.
void sai_oled::aff_menu_Alpha_Min(uint8_t pos, bool en_cours){
char ch_i[2];
uint8_t vx;
uint8_t vy;
for (uint8_t i = 95; i < 127; i++){
snprintf(ch_i, 2, "%c", i);
vy = (12 * ((i - 95) % 4));
vx = ((i - 95) / 4) * 10;
this->_ecran->drawString(vx, vy, ch_i );
}
if (en_cours) {
vy = (12 * (pos % 4));
vx = (pos / 4) * 10;
this->_ecran->drawRect(vx, vy, 10, 13);
}
}
// Affichage du menu Alpha Car. Spe.
void sai_oled::aff_menu_Alpha_Spe(uint8_t pos, bool en_cours){
char ch_i[2];
uint8_t vx;
uint8_t vy;
for (uint8_t i = 32; i < 64; i++){
snprintf(ch_i, 2, "%c", i);
vy = (12 * ((i - 32) % 4));
vx = ((i - 32) / 4) * 10;
this->_ecran->drawString(vx, vy, ch_i );
}
if (en_cours) {
vy = (12 * (pos % 4));
vx = (pos / 4) * 10;
this->_ecran->drawRect(vx, vy, 10, 13);
}
}
// Affichage du menu Alpha Val/Annul.
void sai_oled::aff_menu_Alpha_Val(uint8_t pos, bool en_cours){
for (uint8_t i = 0; i < nb_ch_menu_Valid; i++) this->_ecran->drawString(10, (12*i), this->ch_menuValid[i]);
if (en_cours) {
this->_ecran->drawRect(0, pos*12, 80, 13);
}
}
// Affichage ensemble
void sai_oled::aff_menu_alpha_zones(uint8_t pos, uint8_t menu, bool val_sys, bool val_det){
this->_ecran->clear();
this->aff_menu_alpha_maitre(menu);
switch(menu){
case 0 :
this->aff_menu_Alpha_Maj(pos, val_det);
if(val_sys){ delay(300); this->sel_menu_Alpha_detail(28, menu);}
break;
case 1 :
this->aff_menu_Alpha_Min(pos, val_det);
if(val_sys){ delay(300); this->sel_menu_Alpha_detail(28, menu);}
break;
case 2 :
this->aff_menu_Alpha_Spe(pos, val_det);
if(val_sys){ delay(300); this->sel_menu_Alpha_detail(32, menu);}
break;
case 3 :
this->aff_menu_Alpha_Val(pos, val_det);
if(val_sys){ delay(300); this->sel_menu_Alpha_detail(4, menu);}
break;
}
this->aff_menu_alpha_string();
this->_ecran->display();
}
// Selection dans le menu Alpha dans la partie droite
uint8_t sai_oled::sel_menu_Alpha(uint8_t max){
this->flech_d = true;
max--;
bool B_val = false, val_clk = true, memo_clk = true;
int B_choix = 0;
this->aff_menu_alpha_zones(0, B_choix, false, false);
while (! B_val){
val_clk = digitalRead(this->PinCLK);
if (val_clk != memo_clk){
if (digitalRead(this->PinDT) != val_clk) { B_choix++; if (B_choix > max) B_choix = max;}
else { B_choix--; if (B_choix < 0) B_choix = 0;}
this->aff_menu_alpha_zones(0, B_choix, false, false); delay(10);
}
if (!(digitalRead(this->PinSW))) { B_val = true; } // Bouton validation
memo_clk = val_clk; delay(5);
}
this->aff_menu_alpha_zones(0, B_choix, true, false);
return B_choix;
}
// Selection dans le menu Alpha dans la partie gauche
uint8_t sai_oled::sel_menu_Alpha_detail(uint8_t max, uint8_t menu){
this->flech_d = false;
max--;
bool B_val = false, val_clk = true, memo_clk = true;
int B_choix = 0;
this->aff_menu_alpha_zones(B_choix, menu, false, true);
while (! B_val){
val_clk = digitalRead(this->PinCLK);
if (val_clk != memo_clk){
if (digitalRead(this->PinDT) != val_clk) {
B_choix++;
if (B_choix > max){
B_choix = 0;
return B_choix;
}
} else {
B_choix--;
if (B_choix < 0){
B_choix = 0;
if(this->sortieH) return B_choix;
}
}
this->aff_menu_alpha_zones(B_choix, menu, false, true); delay(10);
}
if (!(digitalRead(this->PinSW))) { B_val = true; } // Bouton validation
memo_clk = val_clk; delay(5);
}
maj_ch(B_choix, menu);
if(this->val_ch < 2) return 0;
delay(100);
this->aff_menu_alpha_zones(B_choix, menu, true, false);
return B_choix;
}
Le fichier d'exemple d'utilisation des deux objets (mais chacun peut bien sûr être utilisé seul dans vos montage).
Ne pas oublier de personnaliser les PIN GPio en fonction du circuit sur lequel vous désirez tester l'exemple !
// test_obj_saioled.ino
// Test des objets sai_oled et menu_oled
// Castoo https://castoo.fr
// Décembre 2019
#include "SSD1306Wire.h"
#include "sai_oled.h"
#include "menu_oled.h"
// l'adresse I2C (ici 0x3C) peut être différente en fonction du module utilisé
//SSD1306Wire display(0x3c, 4, 5); // I2C sur un esp8266 donc gpio 4 > SDA & gpio 5 > SCL
SSD1306Wire display(0x3c, 15, 14); // I2C sur un esp8266 donc gpio 4 > SDA & gpio 5 > SCL
// Pour initialiser les objets sai_oled et menu_oled il faut passer les sorties Gpio utilisées pour le bouton rotatif
// Il est également necessaire de preciser le nom de l'objet écran utilisé (celui-ci peut facilement être modifié)
//sai_oled mon_sai_oled(16, 13, 0, display); // init saisie (Gpio vclk, Gpio vdt, Gpio vsw et nom de l'objet LCD)
sai_oled mon_sai_oled(3, 13, 1, display); // init saisie (Gpio vclk, Gpio vdt, Gpio vsw et nom de l'objet LCD)
//menu_oled mes_menus_oled(16, 13, 0, display); // init saisie (Gpio vclk, Gpio vdt, Gpio vsw et nom de l'objet LCD)
menu_oled mes_menus_oled(3, 13, 1, display); // init saisie (Gpio vclk, Gpio vdt, Gpio vsw et nom de l'objet LCD)
//uint8_t PinSW = 0; // Gpio x sur sortie SW du selecteur rotatif sera utilisée pour valider les delais d'attente
uint8_t PinSW = 1; // Gpio x sur sortie SW du selecteur rotatif sera utilisée pour valider les delais d'attente
int B_menu; // Choix selectionné dans menu
const int nb_ch_menuA = 3; // choix du menu Principal
const String ch_menuA[] = {"Saisir votre nom", "Saisir votre prénom", "Afficher Nom Prénom"};
String _ch_menuA = * ch_menuA;
String nom = "";
String prenom = "";
String ch_result = "";
// Initialisation
void setup() {
pinMode(PinSW, INPUT); // Sortie SW du selecteur rotatif
// Init OLED
display.init();
display.flipScreenVertically();
display.setFont(ArialMT_Plain_24);
display.setTextAlignment(TEXT_ALIGN_CENTER);
display.clear();
// Init des objets sai_oled
mon_sai_oled.init(); // Initialisation ecran pour saisie OLED
mon_sai_oled.sortie_deb(false); // Invalide sortie balayage aprés chaque saisie (+ rapide mais perso, j'aime pas !) à tester à true...
}
// Boucle principale
void loop(){
delay(200);
B_menu = 0;
B_menu = mes_menus_oled.init(nb_ch_menuA, _ch_menuA);
delay(300);
if (B_menu == 0) {
// Saisie du nom
mon_sai_oled.init(); // Initialisation ecran OLED pour saisie
nom = mon_sai_oled.aff_menu_Alpha(); // On lance la saisie
}
else if (B_menu == 1) {
// Saisie du prénom
mon_sai_oled.init(); // Initialisation ecran OLED pour saisie
prenom = mon_sai_oled.aff_menu_Alpha(); // On lance la saisie
}
else if (B_menu == 2) {
// Affichage du nom et du prénom
delay(200); // Anti rebond bouton
ch_result = nom + " " + prenom;
if(ch_result == " ") ch_result = "Vous devez faire une saisie !";
display.setFont(ArialMT_Plain_10);
display.setTextAlignment(TEXT_ALIGN_CENTER);
display.clear();
display.drawString(64, 25, ch_result);
display.display();
while(digitalRead(PinSW)){delay(10);} // On attend que le bouton soit pressé pour sortir de l'affichage
delay(400);
}
}