Affichage Bluetooth - Partie 2

Bienvenue dans la deuxième partie de la série des écrans Bluetooth.

Qui l'affichage de la première partie  a déjà été configuré, vous aurez constaté que vous pouvez très facilement saisir n'importe quel texte sur notre écran, mais malheureusement, un seul texte peut être entré à la fois et cela doit également être saisi encore et encore si l'écran est déconnecté de l'alimentation . C'est un peu fastidieux à long terme. Par conséquent, dans la partie d'aujourd'hui, nous offrirons la possibilité de stocker des textes fixes dans l'EEPROM interne et de les récupérer si nécessaire.

Nous élargissons notre menu série avec les éléments de menu suivants:

  • • S - Lire TOUTES les banques EEPROM
  • • Effacez TOUTES les banques EEPROM
  • • W - Ecrire une banque EEPROM
  • • R - Lire la banque EEPROM
  • • P - Imprimer la banque EEPROM sur l'écran


Pour cette extension, téléchargez le code suivant sur notre Arduino UNO:

 

#include <SPI.h>
#include <Wire.h>
#include <LogicielSérie.h>
#include <EEPROM.h>
#include <LiquidCrystal.h>
#include <avr/dormir.h>


#define MaxInputBufferSize 20 // adapter un maximum de 255 caractères à vlcdr
#define EEpromSize 990

#define rLcdChr 20
#define LcdRows 4
#define intervalle 1000

// Adresses des cellules de mémoire EEprom pour la configuration
#define EEFadeSeconds  993
#define EEPINA 996
#define EEPINC 997
#define EEPINDD 998

LogicielSérie mySerial(7, 6); // RX, TX

// LiquidCrystal (rs, enable, d4, d5, d6, d7)
LiquidCrystal lcd(8, 13, 12, 11, 10, 9);

// variables
octet DisplayBankContent = 0;

// Gestion des entrées série
char TBuffer;
char Cbuffer[MaxInputBufferSize + 1];     // Tampon d'entrée de code USB
String Sbuffer = "";                      // Tampon d'entrée de chaîne USB
int valeur;                                // Tampon d'entrée numérique USB
octet Ccount = 0;                          // Nombre de caractères reçus
octet Inptype = 0;
booléen StrInput = faux;
booléen NumberInput = faux;
booléen DataInput = faux;
booléen EnterInput = faux;
octet MenueSelection = 0;

octet SelectedMsg = 0;

// Donne des informations de débogage via l'interface série
booléen DebugMode = faux;
booléen EchoMode = vrai;

// EEPROM
int eeaddress;                 // Pointeur d'adresse EEPROM
octet EEPromBanks = 0;          // Utilisé pour le calcul des banques EEPROM
// SerMnueControl
octet MnuState = 0;            // Profondeur maximale du menu 255 icl sub
octet Banque sélectionnée = 0;

// Horloge temps réel
longue précédentMillis = 0;       // stockera la dernière fois que la mesure a été effectuée
longue previousMillisB = 0;       // stockera la dernière fois que la mesure a été effectuée

// Gestion de l'affichage
booléen DisplayLock = faux;
booléen Directprint = faux;
octet DirectprintROW = 0;
octet DirectprintLine = 0;
booléen RefreshDisplay = faux;
octet FRMCheck = 0; // Utilisé pour écrire des opérations sur eeprom afin de sauver les cycles d'hôte

nul configuration()
{   EEPromBanks = EEpromSize / ((rLcdChr) * LcdRows);   lcd.commencer(rLcdChr, LcdRows);   lcd.clair();   lcd.setCursor(0, 0);   lcd.imprimer("Bluetooth");   lcd.setCursor(0, 1);   lcd.imprimer("Affichage");   mySerial.commencer(9600);   lcd.setCursor(0, 0);   mySerial.rincer();
}



// ###################################################################################################### //

nul boucle()

{   SerialcommandProcessor();   Processeur d'affichage();

}

// ###################################################################################################### //


nul TextHeader(octet rowm)
{   mySerial.println("Texte pour la banque" + String( Banque sélectionnée) + "ROW" + String (rowm) + ":");
}

nul SerialcommandProcessor()
{   int un;   Inptype = 0;   Inptype = SerInputHandler();   // 0 pas de retour   // 1 numéro   // 2 chaîne   // 3 données   si ((Inptype > 0) & (!Directprint))   {     MenueSelection = 0;     si ((MnuState < 2) && (Inptype == 2)) {       Sbuffer.toUpperCase();  // Pour des commandes faciles à saisir     }     si ((Sbuffer == "S") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 3;     }     // Effacement de TOUT le contenu EEprom     si ((Sbuffer == "E") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 4;     }     si ((Sbuffer == "OUI") && (MnuState == 1) && (Inptype == 2))      {       MenueSelection = 5;     }     si ((Sbuffer != "OUI") && (MnuState == 1) && (Inptype == 2))     {       MenueSelection = 6;     }     // Modifier le contenu sélectionné     si ((Sbuffer == "W") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 7;     }     si ((MnuState == 2) && (valeur  < EEPromBanks) && (Inptype == 1)) {       MenueSelection = 8;     }     si (MnuState == 3)                                               {       MenueSelection = 9;     }     si (MnuState == 4)                                               {       MenueSelection = 10;     }     // Afficher le contenu sélectionné     si ((Sbuffer == "P") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 11;     }     si ((MnuState == 5) && (Inptype == 1))                           {       MenueSelection = 12;     }     si ((MnuState == 6) && (Inptype == 1))                           {       MenueSelection = 14;     }     si ((Sbuffer == "RÉ") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 15;     }     si ((Sbuffer == "Z") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 16;     }     si (MnuState == 9)                                               {       MenueSelection = 20;     }     si (MnuState == 10)                                              {       MenueSelection = 21;     }     commutateur (MenueSelection)     {       Cas 1:         {           Pause;         }       Cas 2:         {           Pause;         }       Cas 3:         {           mySerial.println("Lire le contenu de l'EEEPROM:" );           mySerial.affleurer();           pour (int une = 0; une < EEPromBanks; une++)           {             mySerial.println("Banque de mémoire EEPROM:" + Chaîne(une) );             mySerial.affleurer();             pour (int b = 1; b <= LcdRows; b++)             {               mySerial.impression("Rangée " + Chaîne(b) + ": ");               mySerial.affleurer();               pour (int c = 0; c < rLcdChr; c++)               {                 eeaddress = 0;                 eeaddress = (une * (rLcdChr) * LcdRows) + ((rLcdChr) * b) + c;                 valeur = EEPROM.lis(eeaddress);                 mySerial.impression(carboniser(valeur));                 mySerial.affleurer();               }               mySerial.println(" ");               mySerial.affleurer();             }           }           Sbuffer = "";           mySerial.println("Plus de banques EEPROM disponibles.");           mySerial.affleurer();           Pause;         }       Cas 4:         {           valeur = 0;           mySerial.impression("Effacement de l'EEPROM");           mySerial.println("OUI NON:");           mySerial.affleurer();           MnuState = 1;           Sbuffer = "";           Pause;         }       Cas 5:         {           valeur = 0;           mySerial.impression("Effacement de l'EEPROM");           mySerial.println("Etre prêt.");           mySerial.affleurer();           pour (int une = 0; une < EEPromBanks; une++)           {             // Banque de mémoire a             mySerial.println("Clear Bank:" + Chaîne(une));             pour (int b = 1; b <= LcdRows; b++)             {               pour (int c = 0; c < rLcdChr; c++)               {                 eeaddress = 0;                 eeaddress = (une * (rLcdChr) * LcdRows) + ((rLcdChr ) * b) + c;                 FRMCheck = EEPROM.lis(eeaddress);                 si (FRMCheck > 0)                 {                   EEPROM.écrire(eeaddress, 00); // Formatierung                   mySerial.impression(".");                   valeur++;                   retard(30);                   mySerial.affleurer();                 }               }             }             mySerial.println("");             mySerial.affleurer();           }           mySerial.println("");           mySerial.println("Fini. " + Chaîne(valeur) + "Octets effacés");           mySerial.println("");           mySerial.affleurer();           Sbuffer = "";           MnuState = 0;           Pause;         }       Cas 6:         {           valeur = 0;           Sbuffer = "";           MnuState = 0;           mySerial.println("OP abandonné.");           mySerial.affleurer();           Pause;         }       Cas 7:         {           mySerial.println("Numéro de banque EEPPROM (0-" + Chaîne(EEPromBanks - 1) + "):");           mySerial.affleurer();           MnuState = 2;           valeur = 0;           Sbuffer = "";           Pause;         }       Cas 8:         {           Banque sélectionnée = valeur;           TextHeader(1);           MnuState = 3;           Sbuffer = "";           valeur = 0;           Pause;         }       Cas 9:         {           WriteEEPROM(Banque sélectionnée, 1);           TextHeader(2);           valeur = 0;           MnuState = 4;           Sbuffer = "";           Pause;         }       Cas 10:         {           WriteEEPROM(Banque sélectionnée, 2);           valeur = 0;           MnuState = 0;           Sbuffer = "";           TextHeader(3);           mySerial.affleurer();           valeur = 0;           MnuState = 9;           Sbuffer = "";           Pause;         }       Cas 11:         {           valeur = 0;           mySerial.println("Numéro de banque EEPPROM (0-" + Chaîne(EEPromBanks - 1) + "):");           MnuState = 5;           Sbuffer = "";           mySerial.affleurer();           Pause;         }       Cas 12:         {           SelectedMsg = valeur;           DisplayBank(valeur);           Pause;         }       Cas 13:         {           valeur = 0;           mySerial.println("Numéro de banque EEPPROM (0-" + Chaîne(EEPromBanks - 1) + "):");           MnuState = 6;           Sbuffer = "";           mySerial.affleurer();           Pause;         }       Cas 14:         {           une = valeur;           si ( une < EEPromBanks)           {             mySerial.println("Banque de mémoire:" + Chaîne(une) );             mySerial.affleurer();             pour (int b = 1; b <= LcdRows; b++)             {               mySerial.impression("Rangée " + Chaîne(b) + ": ");               mySerial.affleurer();               pour (int c = 0; c < rLcdChr; c++)               {                 eeaddress = 0;                 eeaddress = (une * (rLcdChr) * LcdRows) + ((rLcdChr) * b) + c;                 valeur = EEPROM.lis(eeaddress);                 mySerial.impression(carboniser(valeur));                 mySerial.affleurer();               }               mySerial.println(" ");               mySerial.affleurer();             }           } autre           {             mySerial.println("Valeur hors limites.");           }           valeur = 0;           Sbuffer = "";           MnuState = 0;           Pause;         }       Cas 15:         {           // Direct pPrint à afficher           Directprint = vrai;           mySerial.println ("Directprint ON".);           si (Directprint)           {             DirectprintROW = 0;             DirectprintLine = 0;             lcd.clair();             lcd.le curseur();             lcd.cligner();           }           valeur = 0;           Sbuffer = "";           MnuState = 0;           Pause;         }       Cas 16:         {           valeur = 0;           Sbuffer = "";           MnuState = 0;           Pause;         }       Cas 20:         {           WriteEEPROM(Banque sélectionnée, 3);           valeur = 0;           MnuState = 0;           Sbuffer = "";           TextHeader(4);           mySerial.affleurer();           valeur = 0;           MnuState = 10;           Sbuffer = "";           Pause;         }       Cas 21:         {           WriteEEPROM(Banque sélectionnée, 4);           valeur = 0;           MnuState = 0;           Sbuffer = "";           Pause;         }       défaut:         {           mySerial.println("------- Affichage Bluetooth intelligent 1.0 ------");           mySerial.println("S - Lire TOUTES les banques EEPROM");           mySerial.println("E - Effacer TOUTES les banques EEPROM");           mySerial.println("W - Ecrire sel. Banque EEPROM");           mySerial.println("R - Read sel. EEPROM Bank");           mySerial.println("P - Imprimer la banque EEPROM sur l'écran");           mySerial.println("----------------------------------------");           mySerial.println("D - Impression directe");           mySerial.println("----------------------------------------");           mySerial.println("Tapez Cmd et appuyez sur Entrée");           mySerial.affleurer();           MnuState = 0;           valeur = 0;           Sbuffer = "";         }     }   } // Eingabe erkannt
}

néant WriteEEPROM(octet FBank, octet FRow)
{   octet Writecounter;   Writecounter = 0;   mySerial.impression("Enregistrement");   pour (int c = 0; c < rLcdChr; c++)   {     eeaddress = 0;     eeaddress = (FBank * (rLcdChr) * LcdRows) + ((rLcdChr) * FRow) + c;     valeur = EEPROM.lis(eeaddress);     si (Sbuffer[c] != valeur)     {       EEPROM.écrire(eeaddress, Sbuffer[c]);       mySerial.impression(".");       Writecounter++;     }   }   mySerial.println(" " + Chaîne (Writecounter) + "Octets écrits.");

}


néant ClearCBuffer ()

{   pour (octet une = 0; MaxInputBufferSize - 1; une++)     Cbuffer[une] = 0;
}


octet SerInputHandler()

{   octet résultat = 0;   int c;   int ;   int une;   int b;   résultat = 0;   si (CheckforserialEvent())   {     si ((NumberInput) et ne pas (Entrée de données) et ne pas (StrInput))    //Chiffres uniquement     {       Sbuffer = "";       valeur = 0;       StrInput = faux;       NumberInput = faux;       Entrée de données = faux;       EnterInput = faux;       une = 0;       b = 0;       c = 0;        = 0;       Sbuffer = Cbuffer; // Zahl wird AUCH! à SBUFFER übernommen, tombe benötigt.       si (Ccount == 1) {         valeur  = Cbuffer[0] - 48 ;       }       si (Ccount == 2) {         une = Cbuffer[0] - 48 ;         une = une * 10;         b = Cbuffer[1] - 48 ;         valeur = une + b;       }       si (Ccount == 3) {         une = Cbuffer[0] - 48 ;         une = une * 100;         b = Cbuffer[1] - 48 ;         b = b * 10;         c = Cbuffer[2] - 48 ;         valeur = une + b + c;       }       si (Ccount == 4) {         une = Cbuffer[0] - 48 ;         une = une * 1000;         b = Cbuffer[1] - 48 ;         b = b * 100;         c = Cbuffer[2] - 48 ;         c = c * 10;          = Cbuffer[3] - 48 ;         valeur = une + b + c + ;       }       si (Ccount >= 5)       {         Sbuffer = "";         valeur = 0;         Sbuffer = Cbuffer;         ClearCBuffer;         résultat = 2;       } autre       {         ClearCBuffer;         Ccount = 0;         résultat = 1;                                                // Numéro Code retour         NumberInput = faux;         StrInput = faux;         Entrée de données = faux;         EnterInput = faux;         Ccount = 0;         revenir résultat;       }     }     si ((StrInput) et ne pas (Entrée de données))                          // Entrée chaîne uniquement     {       Sbuffer = "";       Sbuffer = Cbuffer;       valeur = 0;       StrInput = faux;       NumberInput = faux;       Entrée de données = faux;       EnterInput = faux;       Ccount = 0;       ClearCBuffer;       résultat = 2;                                                 // Numéro Code retour     }     si (Entrée de données) {       Sbuffer = "";       Sbuffer = Cbuffer;       valeur = 0;       StrInput = faux;       NumberInput = faux;       Entrée de données = faux;       EnterInput = faux;       Ccount = 0;       ClearCBuffer;       résultat = 3;                                               // Numéro Code retour     }     si ((EnterInput) et ne pas (StrInput) et ne pas (NumberInput) et ne pas (Entrée de données))     {       Sbuffer = "";       valeur = 0;       Ccount = 0;       ClearCBuffer;       résultat = 4;                                               // Numéro Code retour     }     NumberInput = faux;     StrInput = faux;     Entrée de données = faux;     EnterInput = faux;     Ccount = 0;     revenir résultat;   }   revenir résultat;   // Fin de CheckforSerialEvent
}



// Eingabebuffer


booléen CheckforserialEvent()
{   tandis que (mySerial.disponible()) {     // récupère le nouvel octet:     TBuffer = mySerial.lis();     si (TBuffer > 9 && TBuffer < 14)     {       Cbuffer[Ccount] = 0;       TBuffer = 0;       si (EchoMode)       {         mySerial.impression(carboniser(13));         mySerial.affleurer();       }       si (Directprint)       {         mySerial.println("");         DirectprintLine = 0;         DirectprintROW = DirectprintROW + 1;         si ( DirectprintROW > 3)         {           Directprint = faux;           lcd.noCursor();           lcd.noBlink();           Sbuffer = "";           valeur = 0;         } autre         {           lcd.le curseur();           lcd.cligner();           lcd.setCursor(0, DirectprintROW);         }       }       EnterInput = vrai;       revenir vrai;     } autre si (TBuffer > 47 && TBuffer < 58 )     {       si ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         si ((Directprint))         {           lcd.impression(carboniser(TBuffer));           DirectprintLine = DirectprintLine + 1;           si ( Ccount > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } autre {             lcd.le curseur();             lcd.cligner();           }         }         si (EchoMode) {           mySerial.impression(carboniser(TBuffer));           mySerial.affleurer();         }       } autre {         mySerial.impression("#");       }       // Numéro entrée détectée       NumberInput = vrai;     }     autre si (TBuffer > 64 && TBuffer < 123 )     {       si ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         si ((Directprint))         {           lcd.impression(carboniser(TBuffer));           DirectprintLine = DirectprintLine + 1;           si ( Ccount > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } autre {             lcd.le curseur();             lcd.cligner();           }         }         si (EchoMode) {           mySerial.impression(carboniser(TBuffer));           mySerial.affleurer();         }       } autre {         mySerial.impression("#");       }       // Entrée de caractères caractère détectée       StrInput = vrai;     }     autre si ( (TBuffer == 127 )  |  (TBuffer == 8 ) )     {       si ( DirectprintLine > 0 )       {         DirectprintLine = DirectprintLine - 1;         lcd.setCursor(DirectprintLine, DirectprintROW);         lcd.impression(" ");         lcd.setCursor(DirectprintLine, DirectprintROW);       }       si (( DirectprintLine == 0 ) & ( DirectprintROW > 0 ))       {         DirectprintROW = DirectprintROW - 1;         DirectprintLine = rLcdChr - 1;         lcd.setCursor(DirectprintLine, DirectprintROW);       }       si ( Ccount > 0)       {         Ccount--;         Cbuffer[Ccount] = 0;         si ((Directprint))         {           si ( Ccount > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } autre {             lcd.le curseur();             lcd.cligner();           }         }         si (EchoMode) {           mySerial.impression("-");           mySerial.affleurer();         }       }     }     autre     {       si ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         si ((Directprint))         {           DirectprintLine = DirectprintLine + 1;           si (TBuffer < 128) {             lcd.impression(carboniser(TBuffer));           } autre  {             lcd.impression(Chaîne(TBuffer));           }           si ( Ccount > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } autre {             lcd.le curseur();             lcd.cligner();           }         }         si (EchoMode) {           mySerial.impression(carboniser(TBuffer));           mySerial.affleurer();         }       } autre {         mySerial.impression("#");       }       // Entrée de données détectée       Entrée de données = vrai;     }     revenir faux;   }   revenir faux;
}

néant Processeur d'affichage()  // Bei Blauem Display wird auf Scrollfunktion verzichtet, da das nur "schmiert"
{   si (RefreshDisplay)   {     lcd.clair();     RefreshDisplay = faux;     pour (int b = 1; b <= LcdRows; b++)     {       lcd.setCursor(0, b - 1);       mySerial.impression("Rangée " + Chaîne(b) + ": ");       pour (int c = 0; c < rLcdChr; c++)       {         eeaddress = 0;         eeaddress = (DisplayBankContent * (rLcdChr) * LcdRows) + ((rLcdChr) * b) + c;         valeur = 0;         valeur = EEPROM.lis(eeaddress);         si (valeur > 31) // Sonderzeichen nicht anzeigen         {           retard(100);           lcd.impression(carboniser(valeur));         } autre         {           lcd.impression(carboniser(32));         }       }     }   }
}


néant DisplayBank ( octet cobank)
{   si (cobank  < EEPromBanks )   {     RefreshDisplay = vrai;   // Initialiser la sortie d'affichage     DisplayBankContent = cobank;     mySerial.println("Banque" + Chaîne(cobank) + "s'affiche sur l'écran LCD");     MnuState = 0;     Sbuffer = "";     valeur = 0;     mySerial.affleurer();   } autre   {     mySerial.println("Banque non disponible.");     valeur = 0;     MnuState = 0;     Sbuffer = "";     mySerial.affleurer();   }
}

 

Nachfolgend werden die durch die Menüerweiterung entstandenen neuen Befehle erklärt.

  • S - Lire TOUTES les banques EEPROM

Durch Eingabe von „S“ und Enter werden alle verfügbaren Speicherplätze und deren Inhalt angezeigt. Bei einem 4x20 Zeichen Display und der Configuration standard  sind das 11 Speicherplätze. In folgendem Screenshot ist Bank 1 belegt:

 

Contenu EEPROM

  • E - Effacer TOUTES les banques EEPROM

Über den Menüpunkt „E“ kann uns sollte beim erstmaligen Gebrauch des Displays der interne EEPROM „formatiert“ werden als auch später im Gebrauch ALLE Speicherbänke gelöscht werden. Ein „Formatierungsvorgang“ sieht auf der Menüoberfläche dann so aus:

Supprimer tout le contenu avec "E"

 

  • W - Ecrire sel. Banque EEPROM

W - écriture

 

  • R - Lire sel. Banque EEPROM

Si un certain texte d'une certaine banque de mémoire AFFICHÉ mais ne doit pas être affiché à l'écran, cela peut être affiché via l'élément de menu "R" dans.

R - Lire

 

  • P - Imprimer la banque EEPROM sur l'écran

P - impression

J'espère que vous apprécierez la reconstruction et, comme toujours, à la prochaine fois.

EtalagesProjets pour les débutants

Laisser un commentaire

Tous les commentaires sont modérés avant d'être publiés

Messages de blogs recommandés

  1. Installez maintenant ESP32 via l'administrateur de la carte
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA-Over the Air-ESP Programmation par WiFi