Schermo Bluetooth - Parte 2

Benvenuti nella seconda parte della serie di display Bluetooth.

Chi è il display del prima parte  già finito, avrai notato che puoi inserire qualsiasi testo sul nostro display in modo molto comodo, ma sfortunatamente può essere inserito solo un testo alla volta e devi anche inserirlo più e più volte se il display è scollegato dall'alimentazione , Questo è un po 'noioso a lungo termine. Pertanto, nella parte odierna, forniremo la possibilità di archiviare testi fissi nella EEPROM interna e di recuperarli quando necessario.

Stiamo espandendo il nostro menu seriale con le seguenti voci di menu:

  • • S - Leggi TUTTE le banche EEPROM
  • • Cancella E TUTTE le banche EEPROM
  • • W - Scrivi sel. Banco EEPROM
  • • R - Leggi sel. Banco EEPROM
  • • P - Stampa il banco EEPROM sul display


Per questa estensione, carica il seguente codice sul nostro Arduino UNO:

 

#include <SPI.B>
#include <filo.B>
#include <Serial software.B>
#include <EEPROM.B>
#include <a cristalli liquidi.B>
#include <avr/sonno.B>


#define MaxInputBufferSize 20 // adatta un massimo di 255 caratteri a vlcdr
#define EEpromSize 990

#define rLcdChr 20
#define LcdRows 4
#define intervallo 1000

// Indirizzi di celle di memoria EEprom per la configurazione
#define EEFadeSeconds  993
#define EEPINA 996
#define EEPINC 997
#define EEPINDD 998

Serial software mySerial(7, 6); // RX, TX

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

// variabili
byte Displaybank Content = 0;

// Gestione degli input seriali
carbonizzare TBuffer;
carbonizzare cBuffer[MaxInputBufferSize + 1];     // Buffer di input codice USB
stringa sBuffer = "";                      // Buffer di input stringa USB
int valore;                                // Buffer di input numerico USB
byte CCOUNT = 0;                          // Numero di caratteri ricevuti
byte Inptype = 0;
booleano strInput = falso;
booleano ingresso numero = falso;
booleano L'inserimento dei dati = falso;
booleano ENTERINPUT = falso;
byte Selezione di menu = 0;

byte SelectedMsg = 0;

// Fornisce informazioni di debug tramite interfaccia seriale
booleano modalità di debug = falso;
booleano modalità echo = vero;

// EEPROM
int eeaddress;                 // Puntatore indirizzo EEPROM
byte EEPromBanks = 0;          // Utilizzato per il calcolo delle banche EEPROM
// SerMnueControl
byte MnuState = 0;            // Profondità massima del menu 255 icl sub
byte Selectedbank = 0;

// Orologio in tempo reale
lungo previousMillis = 0;       // memorizzerà l'ultima volta che è stata misurata
lungo previousMillisB = 0;       // memorizzerà l'ultima volta che è stata misurata

// Gestione display
booleano DisplayLock = falso;
booleano direct Print = falso;
byte DirectprintROW = 0;
byte Linea di stampa diretta = 0;
booleano Display Refresh = falso;
byte FRMCheck = 0; // Utilizzato per scrivere operazioni su eeprom, quindi salva i cicli host

vuoto configurazione()
{   EEPromBanks = EEpromSize / ((rLcdChr) * LcdRows);   lcd.iniziare(rLcdChr, LcdRows);   lcd.chiaro();   lcd.setCursor(0, 0);   lcd.stampare("Bluetooth");   lcd.setCursor(0, 1);   lcd.stampare("Display");   mySerial.iniziare(9600);   lcd.setCursor(0, 0);   mySerial.rossore();
}



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

vuoto cappio()

{   Command Processor Serial();   Processore display();

}

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


vuoto intestazione del testo(byte ROWm)
{   mySerial.println("Testo per banca" + stringa( Selectedbank) + "FILA" + stringa (ROWm) + ":");
}

vuoto Command Processor Serial()
{   int un;   Inptype = 0;   Inptype = SerInputHandler();   // 0 nessun ritorno   // 1 numero   // 2 stringhe   // 3 dati   se ((Inptype > 0) & (!direct Print))   {     Selezione di menu = 0;     se ((MnuState < 2) && (Inptype == 2)) {       sBuffer.toUpperCase();  // Per comandi di facile inserimento     }     se ((sBuffer == "S") && (MnuState == 0) && (Inptype == 2))       {       Selezione di menu = 3;     }     // Cancellazione di TUTTI i contenuti EEprom     se ((sBuffer == "E") && (MnuState == 0) && (Inptype == 2))       {       Selezione di menu = 4;     }     se ((sBuffer == "SI") && (MnuState == 1) && (Inptype == 2))      {       Selezione di menu = 5;     }     se ((sBuffer != "SI") && (MnuState == 1) && (Inptype == 2))     {       Selezione di menu = 6;     }     Modifica contenuto selezionato     Se ((Buffer == "W") && (MnuState == 0) && (Inptype (Inptype) == 2))       {       MenueSelezione = 7;     }     Se ((MnuState == 2) && (Valore  < EEPromBanche) && (Inptype (Inptype) == 1)) {       MenueSelezione = 8;     }     Se (MnuState == 3)                                               {       MenueSelezione = 9;     }     Se (MnuState == 4)                                               {       MenueSelezione = 10;     }     Visualizza contenuto selezionato     Se ((Buffer == "P") && (MnuState == 0) && (Inptype (Inptype) == 2))       {       MenueSelezione = 11;     }     Se ((MnuState == 5) && (Inptype (Inptype) == 1))                           {       MenueSelezione = 12;     }     Se ((MnuState == 6) && (Inptype (Inptype) == 1))                           {       MenueSelezione = 14;     }     Se ((Buffer == "D" (D)) && (MnuState == 0) && (Inptype (Inptype) == 2))       {       MenueSelezione = 15;     }     Se ((Buffer == "z") && (MnuState == 0) && (Inptype (Inptype) == 2))       {       MenueSelezione = 16;     }     Se (MnuState == 9)                                               {       MenueSelezione = 20;     }     Se (MnuState == 10)                                              {       MenueSelezione = 21;     }     Interruttore (MenueSelezione)     {       Caso 1:         {           Pausa;         }       Caso 2:         {           Pausa;         }       Caso 3:         {           mySerial.println("Leggi contenuto EEEPROM:" );           mySerial.sciacquone();           Per (Int Un = 0; Un < EEPromBanche; Un++)           {             mySerial.println("Banca di memoria EEPROM: " + Stringa(Un) );             mySerial.sciacquone();             Per (Int B = 1; B <= LcdRows (informazioni in base ai colori in; B++)             {               mySerial.Stampare("Riga" + Stringa(B) + ": ");               mySerial.sciacquone();               Per (Int C = 0; C < rLcdChr; C++)               {                 eeaddress (indirizzo eeaddress) = 0;                 eeaddress (indirizzo eeaddress) = (Un * (rLcdChr) * LcdRows (informazioni in base ai colori in) + ((rLcdChr) * B) + C;                 Valore = Eeprom.Leggere(eeaddress (indirizzo eeaddress));                 mySerial.Stampare(Char(Valore));                 mySerial.sciacquone();               }               mySerial.println(" ");               mySerial.sciacquone();             }           }           Buffer = "";           mySerial.println("Non sono più disponibili banche EEPROM.");           mySerial.sciacquone();           Pausa;         }       Caso 4:         {           Valore = 0;           mySerial.Stampare("Cancellare EEPROM");           mySerial.println("SÌ/NO:");           mySerial.sciacquone();           MnuState = 1;           Buffer = "";           Pausa;         }       Caso 5:         {           Valore = 0;           mySerial.Stampare("Cancellare EEPROM");           mySerial.println("Stand by.");           mySerial.sciacquone();           Per (Int Un = 0; Un < EEPromBanche; Un++)           {             Banca di memoria a             mySerial.println("Banca Chiara: " + Stringa(Un));             Per (Int B = 1; B <= LcdRows (informazioni in base ai colori in; B++)             {               Per (Int C = 0; C < rLcdChr; C++)               {                 eeaddress (indirizzo eeaddress) = 0;                 eeaddress (indirizzo eeaddress) = (Un * (rLcdChr) * LcdRows (informazioni in base ai colori in) + ((rLcdChr ) * B) + C;                 FRMControllo = Eeprom.Leggere(eeaddress (indirizzo eeaddress));                 Se (FRMControllo > 0)                 {                   Eeprom.Scrivere(eeaddress (indirizzo eeaddress), 00); Formatierung                   mySerial.Stampare(".");                   Valore++;                   Ritardo(30);                   mySerial.sciacquone();                 }               }             }             mySerial.println("");             mySerial.sciacquone();           }           mySerial.println("");           mySerial.println("Finito". + Stringa(Valore) + " Byte cancellati");           mySerial.println("");           mySerial.sciacquone();           Buffer = "";           MnuState = 0;           Pausa;         }       Caso 6:         {           Valore = 0;           Buffer = "";           MnuState = 0;           mySerial.println("Interruzione OP".);           mySerial.sciacquone();           Pausa;         }       Caso 7:         {           mySerial.println("Numero di banca EEPPROM (0-" + Stringa(EEPromBanche - 1) + "):");           mySerial.sciacquone();           MnuState = 2;           Valore = 0;           Buffer = "";           Pausa;         }       Caso 8:         {           Banca selezionata = Valore;           Intestazione di testo(1);           MnuState = 3;           Buffer = "";           Valore = 0;           Pausa;         }       Caso 9:         {           Scrittura(Banca selezionata, 1);           Intestazione di testo(2);           Valore = 0;           MnuState = 4;           Buffer = "";           Pausa;         }       Caso 10:         {           Scrittura(Banca selezionata, 2);           Valore = 0;           MnuState = 0;           Buffer = "";           Intestazione di testo(3);           mySerial.sciacquone();           Valore = 0;           MnuState = 9;           Buffer = "";           Pausa;         }       Caso 11:         {           Valore = 0;           mySerial.println("Numero di banca EEPPROM (0-" + Stringa(EEPromBanche - 1) + "):");           MnuState = 5;           Buffer = "";           mySerial.sciacquone();           Pausa;         }       Caso 12:         {           SelectedMsg = Valore;           DisplayBank(Valore);           Pausa;         }       Caso 13:         {           Valore = 0;           mySerial.println("Numero di banca EEPPROM (0-" + Stringa(EEPromBanche - 1) + "):");           MnuState = 6;           Buffer = "";           mySerial.sciacquone();           Pausa;         }       Caso 14:         {           Un = Valore;           Se ( Un < EEPromBanche)           {             mySerial.println("Banca della memoria: " + Stringa(Un) );             mySerial.sciacquone();             Per (Int B = 1; B <= LcdRows (informazioni in base ai colori in; B++)             {               mySerial.Stampare("Riga" + Stringa(B) + ": ");               mySerial.sciacquone();               Per (Int C = 0; C < rLcdChr; C++)               {                 eeaddress (indirizzo eeaddress) = 0;                 eeaddress (indirizzo eeaddress) = (Un * (rLcdChr) * LcdRows (informazioni in base ai colori in) + ((rLcdChr) * B) + C;                 Valore = Eeprom.Leggere(eeaddress (indirizzo eeaddress));                 mySerial.Stampare(Char(Valore));                 mySerial.sciacquone();               }               mySerial.println(" ");               mySerial.sciacquone();             }           } Altro           {             mySerial.println("Valore non compreso nell'intervallo.");           }           Valore = 0;           Buffer = "";           MnuState = 0;           Pausa;         }       Caso 15:         {           PPrint diretto da visualizzare           Impronta diretta = Vero;           mySerial.println ("Directprint ON.");           Se (Impronta diretta)           {             Stampa direttaROW = 0;             Stampa direttaLinea = 0;             Lcd.Chiaro();             Lcd.Cursore();             Lcd.Lampeggiare();           }           Valore = 0;           Buffer = "";           MnuState = 0;           Pausa;         }       Caso 16:         {           Valore = 0;           Buffer = "";           MnuState = 0;           Pausa;         }       Caso 20:         {           Scrittura(Banca selezionata, 3);           Valore = 0;           MnuState = 0;           Buffer = "";           Intestazione di testo(4);           mySerial.sciacquone();           Valore = 0;           MnuState = 10;           Buffer = "";           Pausa;         }       Caso 21:         {           Scrittura(Banca selezionata, 4);           Valore = 0;           MnuState = 0;           Buffer = "";           Pausa;         }       Predefinito:         {           mySerial.println("-------Smart Bluetooth Display 1.0------");           mySerial.println("S - Leggi TUTTE le banche EEPROM");           mySerial.println("E - Cancella TUTTE le banche EEPROM");           mySerial.println("W - Scrivi banca EEPROM");           mySerial.println("R - Leggi sel. EEPROM Bank");           mySerial.println("P - Stampa Banca EEPROM sul display");           mySerial.println("----------------------------------------");           mySerial.println("D - Stampa diretta");           mySerial.println("----------------------------------------");           mySerial.println("Digitare Cmd e premere Invio");           mySerial.sciacquone();           MnuState = 0;           Valore = 0;           Buffer = "";         }     }   } Eingabe erkannt
}

Vuoto Scrittura(byte FBank, byte Riga F)
{   byte Scrivicounter;   Scrivicounter = 0;   mySerial.Stampare("Salvataggio");   Per (Int C = 0; C < rLcdChr; C++)   {     eeaddress (indirizzo eeaddress) = 0;     eeaddress (indirizzo eeaddress) = (FBank * (rLcdChr) * LcdRows (informazioni in base ai colori in) + ((rLcdChr) * Riga F) + C;     Valore = Eeprom.Leggere(eeaddress (indirizzo eeaddress));     Se (Buffer[C] != Valore)     {       Eeprom.Scrivere(eeaddress (indirizzo eeaddress), Buffer[C]);       mySerial.Stampare(".");       Scrivicounter++;     }   }   mySerial.println(" " + Stringa (Scrivicounter) + "Byte scritti.");

}


Vuoto ClearCBuffer (Buffer Di ClearC) ()

{   Per (byte Un = 0; MaxInputBufferSize - 1; Un++)     Cbuffer (Cbuffer)[Un] = 0;
}


byte SerInputHandler()

{   byte Risultato = 0;   Int C;   Int D;   Int Un;   Int B;   Risultato = 0;   Se (VerificaforserialE())   {     Se ((NumeroIngresso) E Non (DataInput (Input dati)) E Non (StrInput))    Solo numeri     {       Buffer = "";       Valore = 0;       StrInput = False;       NumeroIngresso = False;       DataInput (Input dati) = False;       Input enter = False;       Un = 0;       B = 0;       C = 0;       D = 0;       Buffer = Cbuffer (Cbuffer); AUCH wird ! in SBUFFER sbernommen, cade bentigt.       Se (Conteggio cconteggio == 1) {         Valore  = Cbuffer (Cbuffer)[0] - 48 ;       }       Se (Conteggio cconteggio == 2) {         Un = Cbuffer (Cbuffer)[0] - 48 ;         Un = Un * 10;         B = Cbuffer (Cbuffer)[1] - 48 ;         Valore = Un + B;       }       Se (Conteggio cconteggio == 3) {         Un = Cbuffer (Cbuffer)[0] - 48 ;         Un = Un * 100;         B = Cbuffer (Cbuffer)[1] - 48 ;         B = B * 10;         C = Cbuffer (Cbuffer)[2] - 48 ;         Valore = Un + B + C;       }       Se (Conteggio cconteggio == 4) {         Un = Cbuffer (Cbuffer)[0] - 48 ;         Un = Un * 1000;         B = Cbuffer (Cbuffer)[1] - 48 ;         B = B * 100;         C = Cbuffer (Cbuffer)[2] - 48 ;         C = C * 10;         D = Cbuffer (Cbuffer)[3] - 48 ;         Valore = Un + B + C + D;       }       Se (Conteggio cconteggio >= 5)       {         Buffer = "";         Valore = 0;         Buffer = Cbuffer (Cbuffer);         ClearCBuffer (Buffer Di ClearC);         Risultato = 2;       } Altro       {         ClearCBuffer (Buffer Di ClearC);         Conteggio cconteggio = 0;         Risultato = 1;                                                Numero Codice restituito         NumeroIngresso = False;         StrInput = False;         DataInput (Input dati) = False;         Input enter = False;         Conteggio cconteggio = 0;         Ritorno Risultato;       }     }     Se ((StrInput) E Non (DataInput (Input dati)))                          Solo input stringa     {       Buffer = "";       Buffer = Cbuffer (Cbuffer);       Valore = 0;       StrInput = False;       NumeroIngresso = False;       DataInput (Input dati) = False;       Input enter = False;       Conteggio cconteggio = 0;       ClearCBuffer (Buffer Di ClearC);       Risultato = 2;                                                 Numero Codice restituito     }     Se (DataInput (Input dati)) {       Buffer = "";       Buffer = Cbuffer (Cbuffer);       Valore = 0;       StrInput = False;       NumeroIngresso = False;       DataInput (Input dati) = False;       Input enter = False;       Conteggio cconteggio = 0;       ClearCBuffer (Buffer Di ClearC);       Risultato = 3;                                               Numero Codice restituito     }     Se ((Input enter) E Non (StrInput) E Non (NumeroIngresso) E Non (DataInput (Input dati)))     {       Buffer = "";       Valore = 0;       Conteggio cconteggio = 0;       ClearCBuffer (Buffer Di ClearC);       Risultato = 4;                                               Numero Codice restituito     }     NumeroIngresso = False;     StrInput = False;     DataInput (Input dati) = False;     Input enter = False;     Conteggio cconteggio = 0;     Ritorno Risultato;   }   Ritorno Risultato;   Fine controlloforSerialEvent
}



Eingabebuffer


Boolean VerificaforserialE()
{   Mentre (mySerial.Disponibile()) {     ottenere il nuovo byte:     TBuffer (TBuffer) = mySerial.Leggere();     Se (TBuffer (TBuffer) > 9 && TBuffer (TBuffer) < 14)     {       Cbuffer (Cbuffer)[Conteggio cconteggio] = 0;       TBuffer (TBuffer) = 0;       Se (Modalità Echo)       {         mySerial.Stampare(Char(13));         mySerial.sciacquone();       }       Se (Impronta diretta)       {         mySerial.println("");         Stampa direttaLinea = 0;         Stampa direttaROW = Stampa direttaROW + 1;         Se ( Stampa direttaROW > 3)         {           Impronta diretta = False;           Lcd.noCursor (Cursore)();           Lcd.noBlink();           Buffer = "";           Valore = 0;         } Altro         {           Lcd.Cursore();           Lcd.Lampeggiare();           Lcd.Setcursor(0, Stampa direttaROW);         }       }       Input enter = Vero;       Ritorno Vero;     } Altro Se (TBuffer (TBuffer) > 47 && TBuffer (TBuffer) < 58 )     {       Se ( Conteggio cconteggio < MaxInputBufferSize)       {         Cbuffer (Cbuffer)[Conteggio cconteggio] = TBuffer (TBuffer);         Conteggio cconteggio++;         Se ((Impronta diretta))         {           Lcd.Stampare(Char(TBuffer (TBuffer)));           Stampa direttaLinea = Stampa direttaLinea + 1;           Se ( Conteggio cconteggio > MaxInputBufferSize - 1)           {             Lcd.noCursor (Cursore)();             Lcd.noBlink();           } Altro {             Lcd.Cursore();             Lcd.Lampeggiare();           }         }         Se (Modalità Echo) {           mySerial.Stampare(Char(TBuffer (TBuffer)));           mySerial.sciacquone();         }       } Altro {         mySerial.Stampare("#");       }       Numero Ingresso rilevato       NumeroIngresso = Vero;     }     Altro Se (TBuffer (TBuffer) > 64 && TBuffer (TBuffer) < 123 )     {       Se ( Conteggio cconteggio < MaxInputBufferSize)       {         Cbuffer (Cbuffer)[Conteggio cconteggio] = TBuffer (TBuffer);         Conteggio cconteggio++;         Se ((Impronta diretta))         {           Lcd.Stampare(Char(TBuffer (TBuffer)));           Stampa direttaLinea = Stampa direttaLinea + 1;           Se ( Conteggio cconteggio > MaxInputBufferSize - 1)           {             Lcd.noCursor (Cursore)();             Lcd.noBlink();           } Altro {             Lcd.Cursore();             Lcd.Lampeggiare();           }         }         Se (Modalità Echo) {           mySerial.Stampare(Char(TBuffer (TBuffer)));           mySerial.sciacquone();         }       } Altro {         mySerial.Stampare("#");       }       Rilevato input carattere carattere       StrInput = Vero;     }     Altro Se ( (TBuffer (TBuffer) == 127 )  |  (TBuffer (TBuffer) == 8 ) )     {       Se ( Stampa direttaLinea > 0 )       {         Stampa direttaLinea = Stampa direttaLinea - 1;         Lcd.Setcursor(Stampa direttaLinea, Stampa direttaROW);         Lcd.Stampare(" ");         Lcd.Setcursor(Stampa direttaLinea, Stampa direttaROW);       }       Se (( Stampa direttaLinea == 0 ) & ( Stampa direttaROW > 0 ))       {         Stampa direttaROW = Stampa direttaROW - 1;         Stampa direttaLinea = rLcdChr - 1;         Lcd.Setcursor(Stampa direttaLinea, Stampa direttaROW);       }       Se ( Conteggio cconteggio > 0)       {         Conteggio cconteggio--;         Cbuffer (Cbuffer)[Conteggio cconteggio] = 0;         Se ((Impronta diretta))         {           Se ( Conteggio cconteggio > MaxInputBufferSize - 1)           {             Lcd.noCursor (Cursore)();             Lcd.noBlink();           } Altro {             Lcd.Cursore();             Lcd.Lampeggiare();           }         }         Se (Modalità Echo) {           mySerial.Stampare("-");           mySerial.sciacquone();         }       }     }     Altro     {       Se ( Conteggio cconteggio < MaxInputBufferSize)       {         Cbuffer (Cbuffer)[Conteggio cconteggio] = TBuffer (TBuffer);         Conteggio cconteggio++;         Se ((Impronta diretta))         {           Stampa direttaLinea = Stampa direttaLinea + 1;           Se (TBuffer (TBuffer) < 128) {             Lcd.Stampare(Char(TBuffer (TBuffer)));           } Altro  {             Lcd.Stampare(Stringa(TBuffer (TBuffer)));           }           Se ( Conteggio cconteggio > MaxInputBufferSize - 1)           {             Lcd.noCursor (Cursore)();             Lcd.noBlink();           } Altro {             Lcd.Cursore();             Lcd.Lampeggiare();           }         }         Se (Modalità Echo) {           mySerial.Stampare(Char(TBuffer (TBuffer)));           mySerial.sciacquone();         }       } Altro {         mySerial.Stampare("#");       }       Immissione dati rilevata       DataInput (Input dati) = Vero;     }     Ritorno False;   }   Ritorno False;
}

Vuoto Processore di visualizzazione()  Con il display blu, l'ingesissimento a scorrimento viene omesso, in quanto questo
{   Se (AggiornaVisualizzazione)   {     Lcd.Chiaro();     AggiornaVisualizzazione = False;     Per (Int B = 1; B <= LcdRows (informazioni in base ai colori in; B++)     {       Lcd.Setcursor(0, B - 1);       mySerial.Stampare("Riga" + Stringa(B) + ": ");       Per (Int C = 0; C < rLcdChr; C++)       {         eeaddress (indirizzo eeaddress) = 0;         eeaddress (indirizzo eeaddress) = (DisplayBankContent (Contenuto Della banca) * (rLcdChr) * LcdRows (informazioni in base ai colori in) + ((rLcdChr) * B) + C;         Valore = 0;         Valore = Eeprom.Leggere(eeaddress (indirizzo eeaddress));         Se (Valore > 31) Non mostrare caratteri speciali         {           Ritardo(100);           Lcd.Stampare(Char(Valore));         } Altro         {           Lcd.Stampare(Char(32));         }       }     }   }
}


Vuoto DisplayBank ( Byte cobank)
{   Se (cobank  < EEPromBanche )   {     AggiornaVisualizzazione = Vero;   Inializzare l'output di visualizzazione     DisplayBankContent (Contenuto Della banca) = cobank;     mySerial.println("Banca" + Stringa(cobank) + " viene visualizzato su LCD");     MnuState = 0;     Buffer = "";     Valore = 0;     mySerial.sciacquone();   } Altro   {     mySerial.println("Banca non disponibile.");     Valore = 0;     MnuState = 0;     Buffer = "";     mySerial.sciacquone();   }
}

 

I nuovi comandi creati dall'estensione del menu sono illustrati di seguito.

  • S - Leggi TUTTE le banche EEPROM

Immettendo "S" e Invio vengono visualizzati tutti gli spazi di memoria disponibili e il relativo contenuto. Con un display 4x20 e il Predefinito sono 11 slot di memoria. Nella seguente schermata Bank 1 è documentato:

 

Contenuto EEPROM

  • E - Cancellare TUTTE le banche EEPROM

La voce di menu "E" ci permette di "formattare" l'EEPROM interno quando si utilizza il display per la prima volta, nonché di eliminare TUTTE le banche di memoria in seguito in uso. Un "processo di formattazione" è simile al seguente nell'interfaccia del menu:

Elimina tutto il contenuto con "E"

 

  • W - Scrivi sel. Banca EEPROM

W - scrivere

 

  • R - Leggi sel. Banca EEPROM

Se un testo specifico di un banco di memoria specifico deve essere DISPLAYED ma non visualizzato sul display, può essere visualizzato tramite la voce di menu "R" in.

R - Leggi

 

  • P - Stampa Banca EEPROM sul display

P - stampa

Vi auguro un sacco di divertimento ricostruzione e, come sempre, fino alla prossima volta.

DisplaysProjekte für anfänger

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert

Post di blog consigliati

  1. Installa ESP32 ora dal gestore del consiglio di amministrazione
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - Programmazione ESP tramite WLAN