Schermo Bluetooth - Parte 4

Benvenuti alla quarta parte della serie Bluetooth Display.

 

Nella parte di oggi, il nostro display riceve un'ulteriore piccola estensione dell'hardware oltre a una voce di menu operatore aggiuntiva obbligatoria. Con questa nuova estensione hardware, i messaggi memorizzati nella memoria interna possono essere recuperati tramite un pulsante senza il menu operatore!

A tale scopo, utilizziamo come input un'altra porta libera del nostro microcontrollore (compatibile con Uno R3). Più precisamente: usiamo la porta 2 come input. A questo ingresso, un pulsante è collegato a terra, la cui pressione del tasto viene valutata dal nostro Arduino.

Ma ora all'effettiva costruzione e attuazione dell'allargamento. Nel primo passaggio espandiamo il nostro hardware come mostrato nel seguente schema al modulo pulsante KY-004. In totale, il display Bluetooth ha 12 memoria di testo 4x20 caratteri quando si utilizza un Arduino standard.

Questi vengono visualizzati in ordine crescente da 0 a 11 quando si preme il pulsante. Se viene visualizzato il messaggio 11 sul display e viene premuto il pulsante, il contatore torna al messaggio 0.

Bluetooth Display - Parte 4 - Diagramma cablato

 

Successivamente, per questa estensione, carichiamo il seguente codice personalizzato sul nostro microcontrollore:

 

 

#include <Spi.H>
#include <Filo.H>
#include <SoftwareSerialseriale.H>
#include <Eeprom.H>
#include <LiquidoCristallo.H>
#include <Avr/Dormire.H>

# define MaxInputBufferSize 20 massimo 255 caratteri per adattarsi a vlcdr
# define Dimensioni e-promSize 990
# define rLcdChr 20
# define LcdRows (informazioni in base ai colori in 4
# define Intervallo 1000
# define BackgroundLight 5 LED retroilluminazione porta 5
# define SwitchPin (SwitchPin) 2 Pulsanti di selezione dei messaggi della porta 12
# define DelayTOPWROFF 500

EEprom Memory CellAddresses per la configurazione
# define EEFadeSecondi  993
# define EEPINA 996
# define EPINC 997
# define EEPINDD 998


SoftwareSerialseriale mySerial(7, 6); RX, TX
LiquidoCristallo Lcd(8, 13, 12, 11, 10, 9);

Variabili
Byte DisplayBankContent (Contenuto Della banca) = 0;

Gestione dell'input seriale
Char TBuffer (TBuffer);
Char Cbuffer (Cbuffer)[MaxInputBufferSize + 1];     Buffer di input codice USB
Stringa Buffer = "";                      Buffer di input stringa USB
Int Valore;                                USB Nummeric Input Buffer
Byte Conteggio cconteggio = 0;                          Numero ricevuto Chars
Byte Inptype (Inptype) = 0;
Boolean StrInput = False;
Boolean NumeroIngresso = False;
Boolean DataInput (Input dati) = False;
Boolean Input enter = False;
Byte MenueSelezione = 0;

Controllo pulsante
Boolean Stato di commutazione = Vero;
Boolean SwitchstateBuffer (Server switch) = Vero;
Byte SelectedMsg = 0;

Fornire informazioni di debug tramite l'interfaccia seriale
Boolean Modalità Echo = Vero;

Eeprom
Int eeaddress (indirizzo eeaddress);                 Puntatore indirizzo EEPROM
Byte EEPromBanche = 0;          Utilizzato per il calcolo delle banche EEPROM
Controllo SerMnue
Byte MnuState = 0;            Profondità massima del menu 255 icl Sub
Byte Banca selezionata = 0;

Orologio in tempo reale
Lungo previousMillis = 0;       memorizzerà l'ultima volta è stato misurato
Lungo previousMillisB = 0;       memorizzerà l'ultima volta è stato misurato

Gestione del display
Boolean DisplayLock (DisplayLock) = False;
Boolean Impronta diretta = False;
Byte Stampa direttaROW = 0;
Byte Stampa direttaLinea = 0;

Boolean AggiornaVisualizzazione = False;
Byte FRMControllo = 0; Usato fpr operazioni di scrittura per eeprom in modo da salvare i cicli host
Monitoraggio della batteria
Galleggiante Tensione;
Boolean PowersaveMode (Modalità Powersave) = False;

Controllo della luce PWM

Byte Luminosità corrente = 0;
Byte Luminosità di destinazione = 0;
Byte FadeSecondi = 0; Standard n. 3


Vuoto Installazione()
{   EEPromBanche = Dimensioni e-promSize / ((rLcdChr) * LcdRows (informazioni in base ai colori in);   Lcd.Iniziare(rLcdChr, LcdRows (informazioni in base ai colori in);   Lcd.Chiaro();   Lcd.Setcursor(0, 0);   Lcd.Stampare("Bluetooth" (Bluetooth));   Lcd.Setcursor(0, 1);   Lcd.Stampare("Visualizza");   mySerial.Iniziare(9600);   PinMode (Modalità pin)(SwitchPin (SwitchPin), INPUT_PULLUP); Testo di selezione dei pulsanti da EEprom   PinMode (Modalità pin)(BackgroundLight, Output); Illuminazione di visualizzazione / Visualizza ON /OFF   digitalWrite (Scrittura digitale)(BackgroundLight, Basso);   leggere Config   FadeSecondi = Eeprom.Leggere(EEFadeSecondi);   Luminosità corrente = 0;   Luminosità di destinazione = 0;   Lcd.Setcursor(0, 4);   Se (DisplayLock (DisplayLock)) {     Lcd.Stampare(" Gesperrt di sistema");   }   Ulteriori routine di installazione / inizializzazione   Lcd.Setcursor(0, 0);   Luminosità di destinazione = 255;   mySerial.sciacquone();
}

// ###################################################################################################### //
Vuoto Ciclo()
{   SerialcommandProcessore();   runrealTimeClock();   Processore di visualizzazione();   SwitchProcessore();   Ciclo principale finale
}
// ###################################################################################################### //

Vuoto Intestazione di testo(byte rowm)
{   mySerial.println("Testo per banca" + Stringa( Banca selezionata) + " RIGA " + Stringa (rowm) + ":");
}

Vuoto SerialcommandProcessore()
{   Int Un;   Inptype (Inptype) = 0;   Inptype (Inptype) = SerInputHandler();   0 cheine R'ckgabe   1 Nummer   2 Stringa   3 Dati   Se ((Inptype (Inptype) > 0) & (!Impronta diretta))   {     MenueSelezione = 0;     Se ((MnuState < 2) && (Inptype (Inptype) == 2)) {       Buffer.ToUpperCase (Caso in taupper)();  Per facilitare l'immissione dei comandi     }     Se ((Buffer == "ECHO") && (MnuState == 0) && (Inptype (Inptype) == 2))     {       MenueSelezione = 2;     }     Se ((Buffer == "S") && (MnuState == 0) && (Inptype (Inptype) == 2))       {       MenueSelezione = 3;     }     Cancellazione di TUTTI i contenuti EEprom     Se ((Buffer == "E") && (MnuState == 0) && (Inptype (Inptype) == 2))       {       MenueSelezione = 4;     }     Se ((Buffer == "SÌ") && (MnuState == 1) && (Inptype (Inptype) == 2))      {       MenueSelezione = 5;     }     Se ((Buffer != "SÌ") && (MnuState == 1) && (Inptype (Inptype) == 2))     {       MenueSelezione = 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 ((Buffer == "R") && (MnuState == 0) && (Inptype (Inptype) == 2))       {       MenueSelezione = 13;     }     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 ((Buffer == "B") && (MnuState == 0) && (Inptype (Inptype) == 2))       {       MenueSelezione = 17;     }     Se ((MnuState == 7) && (Inptype (Inptype) == 1))                           {       MenueSelezione = 18;     }     Se ((Buffer == "DISSOLVEnza") && (MnuState == 0) && (Inptype (Inptype) == 2))     {       MenueSelezione = 19;     }     Se (MnuState == 9)                                               {       MenueSelezione = 20;     }     Se (MnuState == 10)                                              {       MenueSelezione = 21;     }     Se (MnuState == 12)                                              {       MenueSelezione = 25;     }     Interruttore (MenueSelezione)     {       Caso 2:         {           mySerial.Stampare("Echo");           Modalità Echo = !Modalità Echo;           Se (Modalità Echo) {             mySerial.println("ON".);           } Altro           {             mySerial.println("FUORI".);           }           mySerial.println("");           mySerial.sciacquone();           Valore = 0;           MnuState = 0;           Buffer = "";           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 17:         {           mySerial.println("Luminosità del display: (max 255)");           MnuState = 7;           Valore = 0;           Buffer = "";           Pausa;         }       Caso 18:         {           Se ((Valore < 256))           {             Luminosità di destinazione = Valore;             mySerial.println("Luminosità: " + Stringa (Luminosità di destinazione) + "Imposta");           } Altro           {             mySerial.println("Valore non compreso nell'intervallo.");           }           MnuState = 0;           Valore = 0;           Buffer = "";           Pausa;         }       Caso 19:         {           mySerial.println("Ritardo dissolvenza: (max 255 sec)");           MnuState = 12;           Valore = 0;           Buffer = "";           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;         }       Caso 25:         {           Se ((Valore > 0) & (Valore < 251))           {             FadeSecondi = Valore;             Eeprom.Scrivere(EEFadeSecondi, FadeSecondi);             mySerial.println("Valore" + Stringa (Valore) + " insieme.");           } Altro           {             Valore = 0;             Buffer = "";             mySerial.println("Valore non compreso nell'intervallo.");           }           Valore = 0;           MnuState = 0;           Buffer = "";           Pausa;         }       Predefinito:         {           Se (DisplayLock (DisplayLock))           {             Lcd.Chiaro();             DisplayLock (DisplayLock) = False;           }           mySerial.println("-------Smart Bluetooth Display 1.1------");           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("B - Visualizza il valore attuale di Brighness: " + Stringa (Luminosità corrente));           mySerial.println("Altro: ECHO");           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("#");       }       if (DebugMode) - mySerial.println("Debug: Char over Serial ricevuto ");       mySerial.flush(); }       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         {           mySerial.Stampare(Char(Valore));           Lcd.Stampare(Char(Valore));         } Altro         {           Lcd.Stampare(Char(32));         }       }       mySerial.println();     }   }
}

Vuoto runrealTimeClock()    BASE TEMPORALE
{   Orologio in tempo reale & Conto alla rovescia   lungo precedenteMillis - 0;       memorizzerà l'ultima volta è stato misurato   byte SecDivider - 0;   Unsigned Lungo currentMillis = millis();   Int ValoreStepValue = 0;   Controllo dello schermo PWM   ValoreStepValue = 4 * FadeSecondi;   Se (currentMillis - previousMillis > ValoreStepValue)   {     previousMillis = currentMillis;     Se (Luminosità corrente < Luminosità di destinazione        )     {       Luminosità corrente = Luminosità corrente + 1;       analogicoScrittura (BackgroundLight, Luminosità corrente);     } Altro Se (Luminosità corrente > Luminosità di destinazione)     {       Luminosità corrente = Luminosità corrente - 1;       analogicoScrittura (BackgroundLight, Luminosità corrente);     }   }   Se (currentMillis - previousMillisB > 1000)   {     secondi-corsa     previousMillisB = currentMillis;   }
}

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();   }
}

Vuoto SwitchProcessore()
{   Stato di commutazione = digitalRead (Lettura digitale)(SwitchPin (SwitchPin));   Se ((!Stato di commutazione) && (SwitchstateBuffer (Server switch)) && (Non DisplayLock (DisplayLock)))Opzione di query   {     SwitchstateBuffer (Server switch) = False;     Impronta diretta = False;     Lcd.noCursor (Cursore)();     Lcd.noBlink();     SelectedMsg = SelectedMsg + 1;     Se (SelectedMsg >  EEPromBanche - 1 )     {       SelectedMsg = 0;     }     Lcd.Chiaro();     Lcd.Setcursor(0, 0);     Lcd.Stampare("Banca: " + Stringa(SelectedMsg) + "Selezionato");     Lcd.Setcursor(0, 2);     Ritardo(10);     Valore = DelayTOPWROFF;     Mentre (digitalRead (Lettura digitale)(SwitchPin (SwitchPin)) == 0)     {       Ritardo(1);       Se (Valore > 0) {         Valore = Valore - 1;       };       Lcd.Setcursor(0, 3);     }     DisplayBank(SelectedMsg);   }   Se (Stato di commutazione)   {     SwitchstateBuffer (Server switch) = Vero;     ritardo(10);   }
}

 

Oltre all'estensione hardware, ora abbiamo una piccola funzione di supporto nel menu più: Il comando è "echo". Con questo si accende e si spegne la funzione Echo dei personaggi dell'interfaccia seriale. Per illustrare l'impatto di questo, la schermata seguente disattiva prima la funzione Echo con il comando Echo. Questo viene riconosciuto con "Echo OFF". Lo stesso comando riattiva la funzione Eco. (Attiva/disattiva funzione). Questo è confermato analogamente con "Echo ON". Da questo punto in eloming, ogni carattere di input viene riconosciuto.

Parte 4 - Menu Di visualizzazione

 

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

DisplaysPer arduinoProjekte für fortgeschritteneSensori

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