Bluetooth-display - Deel 2

Welkom bij het tweede deel van de Bluetooth-weergaveserie.

Wie de weergave van de eerste deel  is al ingesteld, zal hebben ontdekt dat u heel gemakkelijk tekst op ons display kunt invoeren, maar helaas kan slechts één tekst tegelijk worden ingevoerd en dit moet ook steeds opnieuw worden ingevoerd als het display is losgekoppeld van de stroomtoevoer . Dit is op de lange termijn een beetje vervelend. Daarom zullen we in het deel van vandaag de optie bieden om vaste teksten in de interne EEPROM op te slaan en ze indien nodig op te halen.

We breiden ons seriële menu uit met de volgende menu-items:

  • • S - Lees ALLE EEPROM-banken
  • • ALLE EEPROM-banken wissen
  • • W - Schrijf selectie EEPROM-bank
  • • R - Lezen geselecteerde EEPROM-bank
  • • P - EEPROM-bank afdrukken op display


Upload voor deze extensie de volgende code naar onze Arduino UNO:

 

# opnemen <SPI.h>
# opnemen <Draad.h>
# opnemen <SoftwareSerieel.h>
# opnemen <EEPROM.h>
# opnemen <Vloeibaar Kristal.h>
# opnemen <avr/slapen.h>


#define MaxInputBufferSize 20 // maximaal 255 tekens aanpassen aan vlcdr
#define EEpromSize 990

#define rLcdChr 20
#define LcdRijen 4
#define interval 1000

// EEprom geheugenceladressen voor configuratie
#define EEFadeSeconds  993
#define EEPINA 996
#define EEPINC 997
#define EEPINDD 998

SoftwareSerieel mySerial(7, 6); // RX, TX

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

// variabelen
byte DisplayBankContent = 0;

// Seriële invoerafhandeling
char TBuffer;
char Cbuffer[MaxInputBufferSize + 1];     // USB-code invoerbuffer
String Sbuffer = "";                      // USB string invoerbuffer
int waarde;                                // USB numerieke invoerbuffer
byte Ccount = 0;                          // Aantal ontvangen tekens
byte Inptype = 0;
Boolean StrInput = fout;
Boolean Nummer Input = fout;
Boolean Data-invoer = fout;
Boolean Enter-invoer = fout;
byte Menu selectie = 0;

byte Geselecteerd Bericht = 0;

// Geef foutopsporingsinformatie via de seriële interface
Boolean DebugMode = fout;
Boolean EchoMode = waar;

// EEPROM
int adres;                 // EEPROM-adreswijzer
byte EEPromBanken = 0;          // Gebruikt voor het berekenen van de EEPROM-banken
// SerMnueControl
byte MnuState = 0;            // Maximale menudiepte 255 icl sub
byte Selectedbank = 0;

// Real-time klok
lang vorige Millis = 0;       // zal de laatste keer opslaan werd gemeten
lang vorige MillisB = 0;       // zal de laatste keer opslaan werd gemeten

// Displaybeheer
Boolean DisplayLock = fout;
Boolean Directprint = fout;
byte DirectprintROW = 0;
byte DirectprintLine = 0;
Boolean Vernieuwen Display = fout;
byte FRMCheck = 0; // Gebruikt voor schrijfbewerkingen naar eeprom, dus bespaar hostcycli

nietig instellen()
{   EEPromBanken = EEpromSize / ((rLcdChr) * LcdRijen);   lcd.beginnen(rLcdChr, LcdRijen);   lcd.duidelijk();   lcd.setCursor(0, 0);   lcd.afdrukken("Bluetooth");   lcd.setCursor(0, 1);   lcd.afdrukken("Display");   mySerial.beginnen(9600);   lcd.setCursor(0, 0);   mySerial.blozen();
}



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

nietig lus()

{   Seriële opdracht Processor();   Display processor();

}

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


nietig TextHeader(byte rowm)
{   mySerial.println("Tekst voor bank" + String( Selectedbank) + "ROW" + String (rowm) + ":");
}

nietig Seriële opdracht Processor()
{   int een;   Inptype = 0;   Inptype = SerInputHandler();   // 0 geen teruggave   // 1 nummer   // 2 string   // 3 gegevens   als ((Inptype > 0) & (!Directprint))   {     Menu selectie = 0;     als ((MnuState < 2) && (Inptype == 2)) {       Sbuffer.toUpperCase();  // Voor eenvoudig invoeren van opdrachten     }     als ((Sbuffer == "S") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 3;     }     // ALLE EEprom-inhoud wissen     als ((Sbuffer == "E") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 4;     }     als ((Sbuffer == "JA") && (MnuState == 1) && (Inptype == 2))      {       Menu selectie = 5;     }     als ((Sbuffer != "JA") && (MnuState == 1) && (Inptype == 2))     {       Menu selectie = 6;     }     // Bewerk geselecteerde inhoud     als ((Sbuffer == "W") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 7;     }     als ((MnuState == 2) && (waarde  < EEPromBanken) && (Inptype == 1)) {       Menu selectie = 8;     }     als (MnuState == 3)                                               {       Menu selectie = 9;     }     als (MnuState == 4)                                               {       Menu selectie = 10;     }     // Toon geselecteerde inhoud     als ((Sbuffer == "P") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 11;     }     als ((MnuState == 5) && (Inptype == 1))                           {       Menu selectie = 12;     }     als ((MnuState == 6) && (Inptype == 1))                           {       Menu selectie = 14;     }     als ((Sbuffer == "D") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 15;     }     als ((Sbuffer == "Z") && (MnuState == 0) && (Inptype == 2))       {       Menu selectie = 16;     }     als (MnuState == 9)                                               {       Menu selectie = 20;     }     als (MnuState == 10)                                              {       Menu selectie = 21;     }     schakelaar (Menu selectie)     {       geval 1:         {           breken;         }       geval 2:         {           breken;         }       geval 3:         {           mySerial.println("Lees EEEPROM-inhoud:" );           mySerial.blozen();           voor (int een = 0; een < EEPromBanken; een++)           {             mySerial.println("EEPROM-geheugenbank:" + Draad(een) );             mySerial.blozen();             voor (int b = 1; b <= LcdRijen; b++)             {               mySerial.afdrukken("Row" + Draad(b) + ": ");               mySerial.blozen();               voor (int c = 0; c < rLcdChr; c++)               {                 adres = 0;                 adres = (een * (rLcdChr) * LcdRijen) + ((rLcdChr) * b) + c;                 waarde = EEPROM.lezen(adres);                 mySerial.afdrukken(char(waarde));                 mySerial.blozen();               }               mySerial.println(" ");               mySerial.blozen();             }           }           Sbuffer = "";           mySerial.println("Geen EEPROM-banken meer beschikbaar.");           mySerial.blozen();           breken;         }       geval 4:         {           waarde = 0;           mySerial.afdrukken("EEPROM wissen");           mySerial.println("JA NEE:");           mySerial.blozen();           MnuState = 1;           Sbuffer = "";           breken;         }       geval 5:         {           waarde = 0;           mySerial.afdrukken("EEPROM wissen");           mySerial.println("Stand-by.");           mySerial.blozen();           voor (int een = 0; een < EEPromBanken; een++)           {             // Geheugenbank a             mySerial.println("Bank wissen:" + Draad(een));             voor (int b = 1; b <= LcdRijen; b++)             {               voor (int c = 0; c < rLcdChr; c++)               {                 adres = 0;                 adres = (een * (rLcdChr) * LcdRijen) + ((rLcdChr ) * b) + c;                 FRMCheck = EEPROM.lezen(adres);                 als (FRMCheck > 0)                 {                   EEPROM.schrijven(adres, 00); // Formatierung                   mySerial.afdrukken(".");                   waarde++;                   vertraging(30);                   mySerial.blozen();                 }               }             }             mySerial.println("");             mySerial.blozen();           }           mySerial.println("");           mySerial.println("Afgewerkt. " + Draad(waarde) + "Bytes gewist");           mySerial.println("");           mySerial.blozen();           Sbuffer = "";           MnuState = 0;           breken;         }       geval 6:         {           waarde = 0;           Sbuffer = "";           MnuState = 0;           mySerial.println("OP afbreken.");           mySerial.blozen();           breken;         }       geval 7:         {           mySerial.println("EEPPROM Banknummer (0-" + Draad(EEPromBanken - 1) + "):");           mySerial.blozen();           MnuState = 2;           waarde = 0;           Sbuffer = "";           breken;         }       geval 8:         {           Selectedbank = waarde;           TextHeader(1);           MnuState = 3;           Sbuffer = "";           waarde = 0;           breken;         }       geval 9:         {           WriteEEPROM(Selectedbank, 1);           TextHeader(2);           waarde = 0;           MnuState = 4;           Sbuffer = "";           breken;         }       geval 10:         {           WriteEEPROM(Selectedbank, 2);           waarde = 0;           MnuState = 0;           Sbuffer = "";           TextHeader(3);           mySerial.blozen();           waarde = 0;           MnuState = 9;           Sbuffer = "";           breken;         }       geval 11:         {           waarde = 0;           mySerial.println("EEPPROM Banknummer (0-" + Draad(EEPromBanken - 1) + "):");           MnuState = 5;           Sbuffer = "";           mySerial.blozen();           breken;         }       geval 12:         {           Geselecteerd Bericht = waarde;           DisplayBank(waarde);           breken;         }       geval 13:         {           waarde = 0;           mySerial.println("EEPPROM Banknummer (0-" + Draad(EEPromBanken - 1) + "):");           MnuState = 6;           Sbuffer = "";           mySerial.blozen();           breken;         }       geval 14:         {           een = waarde;           als ( een < EEPromBanken)           {             mySerial.println("Geheugenbank:" + Draad(een) );             mySerial.blozen();             voor (int b = 1; b <= LcdRijen; b++)             {               mySerial.afdrukken("Row" + Draad(b) + ": ");               mySerial.blozen();               voor (int c = 0; c < rLcdChr; c++)               {                 adres = 0;                 adres = (een * (rLcdChr) * LcdRijen) + ((rLcdChr) * b) + c;                 waarde = EEPROM.lezen(adres);                 mySerial.afdrukken(char(waarde));                 mySerial.blozen();               }               mySerial.println(" ");               mySerial.blozen();             }           } anders           {             mySerial.println("Waarde buiten bereik.");           }           waarde = 0;           Sbuffer = "";           MnuState = 0;           breken;         }       geval 15:         {           // Directe afdruk afdrukken           Directprint = waar;           mySerial.println ("Directprint AAN.");           als (Directprint)           {             DirectprintROW = 0;             DirectprintLine = 0;             lcd.Doorzichtig();             lcd.cursor();             lcd.knipperen();           }           waarde = 0;           Sbuffer = "";           MnuState = 0;           breken;         }       geval 16:         {           waarde = 0;           Sbuffer = "";           MnuState = 0;           breken;         }       geval 20:         {           WriteEEPROM(Selectedbank, 3);           waarde = 0;           MnuState = 0;           Sbuffer = "";           TextHeader(4);           mySerial.blozen();           waarde = 0;           MnuState = 10;           Sbuffer = "";           breken;         }       geval 21:         {           WriteEEPROM(Selectedbank, 4);           waarde = 0;           MnuState = 0;           Sbuffer = "";           breken;         }       standaard:         {           mySerial.println("------- Smart Bluetooth Display 1.0 ------");           mySerial.println("S - Lees ALLE EEPROM-banken");           mySerial.println("E - ALLE EEPROM-banken wissen");           mySerial.println("W - Schrijf sel. EEPROM Bank");           mySerial.println("R - Lees selectie. EEPROM Bank");           mySerial.println("P - EEPROM-bank afdrukken op display");           mySerial.println("----------------------------------------");           mySerial.println("D - Direct afdrukken");           mySerial.println("----------------------------------------");           mySerial.println("Typ Cmd en druk op Enter");           mySerial.blozen();           MnuState = 0;           waarde = 0;           Sbuffer = "";         }     }   } // Eingabe erkannt
}

nietig WriteEEPROM(byte FBank, byte Nu)
{   byte Schrijfteller;   Schrijfteller = 0;   mySerial.afdrukken("Opslaan");   voor (int c = 0; c < rLcdChr; c++)   {     adres = 0;     adres = (FBank * (rLcdChr) * LcdRijen) + ((rLcdChr) * Nu) + c;     waarde = EEPROM.lezen(adres);     als (Sbuffer[c] != waarde)     {       EEPROM.schrijven(adres, Sbuffer[c]);       mySerial.afdrukken(".");       Schrijfteller++;     }   }   mySerial.println(" " + Draad (Schrijfteller) + "Bytes geschreven.");

}


nietig ClearCBuffer ()

{   voor (byte een = 0; MaxInputBufferSize - 1; een++)     Cbuffer[een] = 0;
}


byte SerInputHandler()

{   byte resultaat = 0;   int c;   int d;   int een;   int b;   resultaat = 0;   als (CheckforserialEvent())   {     als ((Nummer Input) en niet (Data-invoer) en niet (StrInput))    //Alleen nummers     {       Sbuffer = "";       waarde = 0;       StrInput = fout;       Nummer Input = fout;       Data-invoer = fout;       Enter-invoer = fout;       een = 0;       b = 0;       c = 0;       d = 0;       Sbuffer = Cbuffer; // Zahl wird AUCH! in SBUFFER übernommen, valt benötigt.       als (Ccount == 1) {         waarde  = Cbuffer[0] - 48 ;       }       als (Ccount == 2) {         een = Cbuffer[0] - 48 ;         een = een * 10;         b = Cbuffer[1] - 48 ;         waarde = een + b;       }       als (Ccount == 3) {         een = Cbuffer[0] - 48 ;         een = een * 100;         b = Cbuffer[1] - 48 ;         b = b * 10;         c = Cbuffer[2] - 48 ;         waarde = een + b + c;       }       als (Ccount == 4) {         een = Cbuffer[0] - 48 ;         een = een * 1000;         b = Cbuffer[1] - 48 ;         b = b * 100;         c = Cbuffer[2] - 48 ;         c = c * 10;         d = Cbuffer[3] - 48 ;         waarde = een + b + c + d;       }       als (Ccount >= 5)       {         Sbuffer = "";         waarde = 0;         Sbuffer = Cbuffer;         ClearCBuffer;         resultaat = 2;       } anders       {         ClearCBuffer;         Ccount = 0;         resultaat = 1;                                                // Nummer retourcode         Nummer Input = fout;         StrInput = fout;         Data-invoer = fout;         Enter-invoer = fout;         Ccount = 0;         terug resultaat;       }     }     als ((StrInput) en niet (Data-invoer))                          // Alleen stringinvoer     {       Sbuffer = "";       Sbuffer = Cbuffer;       waarde = 0;       StrInput = fout;       Nummer Input = fout;       Data-invoer = fout;       Enter-invoer = fout;       Ccount = 0;       ClearCBuffer;       resultaat = 2;                                                 // Nummer retourcode     }     als (Data-invoer) {       Sbuffer = "";       Sbuffer = Cbuffer;       waarde = 0;       StrInput = fout;       Nummer Input = fout;       Data-invoer = fout;       Enter-invoer = fout;       Ccount = 0;       ClearCBuffer;       resultaat = 3;                                               // Nummer retourcode     }     als ((Enter-invoer) en niet (StrInput) en niet (Nummer Input) en niet (Data-invoer))     {       Sbuffer = "";       waarde = 0;       Ccount = 0;       ClearCBuffer;       resultaat = 4;                                               // Nummer retourcode     }     Nummer Input = fout;     StrInput = fout;     Data-invoer = fout;     Enter-invoer = fout;     Ccount = 0;     terug resultaat;   }   terug resultaat;   // Einde CheckforSerialEvent
}



// Eingabebuffer


Boolean CheckforserialEvent()
{   terwijl (mySerial.beschikbaar()) {     // haal de nieuwe byte:     TBuffer = mySerial.lezen();     als (TBuffer > 9 && TBuffer < 14)     {       Cbuffer[Ccount] = 0;       TBuffer = 0;       als (EchoMode)       {         mySerial.afdrukken(char(13));         mySerial.blozen();       }       als (Directprint)       {         mySerial.println("");         DirectprintLine = 0;         DirectprintROW = DirectprintROW + 1;         als ( DirectprintROW > 3)         {           Directprint = fout;           lcd.noCursor();           lcd.noBlink();           Sbuffer = "";           waarde = 0;         } anders         {           lcd.cursor();           lcd.knipperen();           lcd.setCursor(0, DirectprintROW);         }       }       Enter-invoer = waar;       terug waar;     } anders als (TBuffer > 47 && TBuffer < 58 )     {       als ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         als ((Directprint))         {           lcd.afdrukken(char(TBuffer));           DirectprintLine = DirectprintLine + 1;           als ( Ccount > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } anders {             lcd.cursor();             lcd.knipperen();           }         }         als (EchoMode) {           mySerial.afdrukken(char(TBuffer));           mySerial.blozen();         }       } anders {         mySerial.afdrukken("#");       }       // Nummerinvoer gedetecteerd       Nummer Input = waar;     }     anders als (TBuffer > 64 && TBuffer < 123 )     {       als ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         als ((Directprint))         {           lcd.afdrukken(char(TBuffer));           DirectprintLine = DirectprintLine + 1;           als ( Ccount > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } anders {             lcd.cursor();             lcd.knipperen();           }         }         als (EchoMode) {           mySerial.afdrukken(char(TBuffer));           mySerial.blozen();         }       } anders {         mySerial.afdrukken("#");       }       // Char Char Char Input gedetecteerd       StrInput = waar;     }     anders als ( (TBuffer == 127 )  |  (TBuffer == 8 ) )     {       als ( DirectprintLine > 0 )       {         DirectprintLine = DirectprintLine - 1;         lcd.setCursor(DirectprintLine, DirectprintROW);         lcd.afdrukken(" ");         lcd.setCursor(DirectprintLine, DirectprintROW);       }       als (( DirectprintLine == 0 ) & ( DirectprintROW > 0 ))       {         DirectprintROW = DirectprintROW - 1;         DirectprintLine = rLcdChr - 1;         lcd.setCursor(DirectprintLine, DirectprintROW);       }       als ( Ccount > 0)       {         Ccount--;         Cbuffer[Ccount] = 0;         als ((Directprint))         {           als ( Ccount > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } anders {             lcd.cursor();             lcd.knipperen();           }         }         als (EchoMode) {           mySerial.afdrukken("-");           mySerial.blozen();         }       }     }     anders     {       als ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         als ((Directprint))         {           DirectprintLine = DirectprintLine + 1;           als (TBuffer < 128) {             lcd.afdrukken(char(TBuffer));           } anders  {             lcd.afdrukken(Draad(TBuffer));           }           als ( Ccount > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } anders {             lcd.cursor();             lcd.knipperen();           }         }         als (EchoMode) {           mySerial.afdrukken(char(TBuffer));           mySerial.blozen();         }       } anders {         mySerial.afdrukken("#");       }       // Gegevensinvoer gedetecteerd       Data-invoer = waar;     }     terug fout;   }   terug fout;
}

nietig Displayprocessor()  // Bei Blauem Display wird auf Scrollfunktion verzichtet, da das nur "schmiert"
{   als (Vernieuwen Display)   {     lcd.Doorzichtig();     Vernieuwen Display = fout;     voor (int b = 1; b <= LcdRijen; b++)     {       lcd.setCursor(0, b - 1);       mySerial.afdrukken("Row" + Draad(b) + ": ");       voor (int c = 0; c < rLcdChr; c++)       {         adres = 0;         adres = (DisplayBankContent * (rLcdChr) * LcdRijen) + ((rLcdChr) * b) + c;         waarde = 0;         waarde = EEPROM.lezen(adres);         als (waarde > 31) // Sonderzeichen nicht anzeigen         {           vertraging(100);           lcd.afdrukken(char(waarde));         } anders         {           lcd.afdrukken(char(32));         }       }     }   }
}


nietig DisplayBank ( byte cobank)
{   als (cobank  < EEPromBanken )   {     Vernieuwen Display = waar;   // Initialiseer weergave-uitvoer     DisplayBankContent = cobank;     mySerial.println("Bank" + Draad(cobank) + "wordt weergegeven op LCD");     MnuState = 0;     Sbuffer = "";     waarde = 0;     mySerial.blozen();   } anders   {     mySerial.println("Bank niet beschikbaar.");     waarde = 0;     MnuState = 0;     Sbuffer = "";     mySerial.blozen();   }
}

 

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

  • S - Lees ALLE EEPROM-banken

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

 

EEPROM-inhoud

  • E - Wis ALLE EEPROM-banken

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

Verwijder alle inhoud met "E"

 

  • W - Schrijf sel. EEPROM Bank

W - schrijven

 

  • R - Lees selectie. EEPROM Bank

Als een bepaalde tekst van een bepaalde geheugenbank WORDT TOEGEZOND maar niet op het display wordt getoond, kan dit worden weergegeven via het menu-item "R" in.

R - Lezen

 

  • P - EEPROM-bank afdrukken op display

P - afdrukken

Ik hoop dat je geniet van de wederopbouw en zoals altijd tot de volgende keer.

DisplaysProjekte für anfänger

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert

Aanbevolen blog berichten

  1. Installeer ESP32 nu van de raad van bestuur
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - ESP Programmeren via Wi-Fi