 |
Librairie Arduino esp8266 et esp32 |
Février 2021 |
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.
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.
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.
L'encodeur rotatif est ici connecté sur un PCF85741 celui-ci ainsi que l'écran OLED ssd1306 sont ensuite raccordés sur le bus I2C.
Autre possibilité (fond de tirroir) les circuits I2C qui sont conçus pour le raccordement des anciens LCD 2 lignes genre "1602".
On peut donc utiliser la petite carte code 4585 équipée du PCF8574...
Attention brochage particulier des sorties P0 à P..
P0 P1 P2 P3 P4 P5 P6 P7
4 5 6 NC 11 12 13 14
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_i2c.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
// v2.0 fevrier 2021 (prise en charge de l'adresse i2c de l'interface i/o)
/*
sai_oled_i2c.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 / https://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_i2c_h
#define sai_oled_i2c_h
// Adresse I2C du 4585
//pour mémo 0x3F => interface vieux ecrans tft
//pour mémo 0x21 => interface E/S PCF85741
#include "Wire.h"
#include "SSD1306Wire.h"
// circuit I2C PCF8574 correspondance des broches sur le connecteur I2C LCD
// Ce tableau est à revoir suivant schèma réél de la plaquette !
// exemple => sai_oled mon_sai_oled(2, 1, 0, display); //clk en P2 dt en P1 sw en P0 donc broches 6, 5 et 4
// P0 P1 P2 P3 P4 P5 P6 P7
// 4 5 6 NC 11 12 13 14
// ou
// circuit I2C PCF85741 interface I/OLED adr de base i2c : 0x21
// Dans ce cas P0 à P7 sans surprise !
class sai_oled{
private:
uint8_t adr_i2c_4585; // adresse i2c circuit i/o
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 adr_i2c_io, 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);
// retourne etat du signal dt
bool li_rot_clk();
// retourne etat du signal CLK
bool li_rot_dt();
// retourne etat du signal sw
bool li_rot_sw();
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_i2c.cpp
// Saisie de texte sur LCD Oled 1306 l'encodeur rotatif est raccordé sur I2C
// Affichage/Saisie depuis trois écrans de caractères majuscule/minuscule/numérique ou spéciaux
// Castoo
// Décembre 2019
/*
sai_oled_i2c.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 / https://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_i2c.h"
// Constructeur / Initialisation
sai_oled::sai_oled(uint8_t adr_i2c_io, uint8_t vclk, uint8_t vdt, uint8_t vsw, SSD1306Wire &ecran){
this->adr_i2c_4585 = adr_i2c_io; // Adr circuit i/o
this->PinCLK = vclk; // Clk du selecteur rotatif
this->PinDT = vdt; // DT du selecteur rotatif
this->PinSW = vsw; // 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 = "";
}
// retourne etat du signal CLK
bool sai_oled::li_rot_clk(){
uint8_t lect_octet;
Wire.requestFrom(this->adr_i2c_4585, 1);
lect_octet = Wire.read();
Wire.endTransmission();
return bitRead(lect_octet, this->PinCLK);
}
// retourne etat du signal DT
bool sai_oled::li_rot_dt(){
uint8_t lect_octet;
Wire.requestFrom(this->adr_i2c_4585, 1);
lect_octet = Wire.read();
Wire.endTransmission();
return bitRead(lect_octet, this->PinDT);
}
// retourne etat du signal SW
bool sai_oled::li_rot_sw(){
uint8_t lect_octet;
Wire.requestFrom(this->adr_i2c_4585, 1);
lect_octet = Wire.read();
Wire.endTransmission();
return bitRead(lect_octet, this->PinSW);
}
// 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 = 96; i < 124; i++){
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 = this->li_rot_clk();
if (val_clk != memo_clk){
if (this->li_rot_dt() != 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 (!(this->li_rot_sw())) { 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 = this->li_rot_clk();
if (val_clk != memo_clk){
if (this->li_rot_dt() != 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 (!(this->li_rot_sw())) { 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 !
L'exemple a été testé avec un Wemos -D1 mini pro.
// test_obj_sai_menu_oled_i2c.ino
// Test des objets sai_oled et menu_oled
// Castoo https://castoo.fr
// Décembre 2019
// Màj février 2021
#include "SSD1306Wire.h"
#include "sai_oled_i2c.h"
#include "menu_oled_i2c.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, D2, D1); // I2C sur un Wemos D1 mini (esp8266 donc gpio 4 (ou D2) > SDA & gpio 5 (ou D1) > SCL)
#define adr_pcf85741 0x21 // Adresse du circuit I2C 8 I/O
#define encod_sw 0 // P0
#define encod_dt 1 // P1
#define encod_clk 2 // P2
// 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é)
// L'adresse du circuuit PCF8574 doit etre passé en premier parametre ceci permet l'utilisation de différents types de circuit I/O
// L'adresse peut etre 20 ou 21 ou tout autre suivant circuit ...
//sai_oled Sai_oled(adr, 16, 13, 0, display); // init saisie (Adresse PCF85741 0x21, Gpio vclk, Gpio vdt, Gpio vsw et nom de l'objet LCD)
sai_oled Sai_oled(adr_pcf85741, encod_clk, encod_dt, encod_sw, display); // init saisie (Adresse PCF85741 0x21, Gpio vclk, Gpio vdt, Gpio vsw et nom de l'objet LCD)
//menu_oled Menus_oled(adr, 16, 13, 0, display); // init saisie (Adresse PCF85741 0x21, Gpio vclk, Gpio vdt, Gpio vsw et nom de l'objet LCD)
menu_oled Menus_oled(adr_pcf85741, encod_clk, encod_dt, encod_sw, display); // init saisie (Adresse PCF85741 0x21, Gpio vclk, Gpio vdt, Gpio vsw et nom de l'objet LCD)
// Menus_oled.li_rot_sw() Sortie SW du selecteur rotatif sera utilisée pour valider les delais d'attente
int A_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() {
// Init OLED
display.init();
display.flipScreenVertically();
display.setFont(ArialMT_Plain_24);
display.setTextAlignment(TEXT_ALIGN_CENTER);
display.clear();
// Init des objets sai_oled
Sai_oled.init(); // Initialisation ecran pour saisie OLED
Sai_oled.sortie_deb(false); // Invalide sortie balayage aprés chaque saisie (+ rapide mais perso, j'aime pas !) à tester à true...
}
// Boucle principale
void loop(){
A_menu = 0;
A_menu = Menus_oled.init(nb_ch_menuA, _ch_menuA);
delay(300);
switch (A_menu){ // Menu général
case 0 : // Saisie du nom
Sai_oled.init(); // Initialisation ecran OLED pour saisie
nom = Sai_oled.aff_menu_Alpha(); // On lance la saisie
break;
case 1 : // Saisie du prénom
Sai_oled.init(); // Initialisation ecran OLED pour saisie
prenom = Sai_oled.aff_menu_Alpha(); // On lance la saisie
break;
case 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(Menus_oled.li_rot_sw()){ // On attend que le bouton soit pressé pour sortir de l'affichage
delay(10);
}
break;
}
delay(800);
}