Pantalla Bluetooth - Teil 2

Bienvenido a la segunda parte de la serie Bluetooth Display.

Quien muestre la visualización de la primera parte ya terminado, se habrá observado que se puede introducir cualquier texto en nuestra pantalla muy convenientemente, pero por desgracia sólo se puede introducir un texto y también esto debe ser volver a introducir una y otra vez si la pantalla está desconectada de la actual. Esto es un poco tedioso a largo plazo. Por lo tanto, por parte de hoy, proporcionaremos la posibilidad de almacenar textos fijos en el EEPROM interno y recuperarlos si es necesario. 

Para ello, ampliamos nuestro menú en serie con los siguientes elementos de menú:

  • • S - Leer TODOS los bancos EEPROM
  • • E - Borrar TODOS los bancos EEPROM
  • • W - Escribir sel. Banco EEPROM
  • • R - Leer sel. Banco EEPROM
  • • P - Imprimir EEPROM Bank en la pantalla


Para esta extensión, cargue el siguiente código en nuestro Arduino UNO:

 

#include <Spi.H>
#include <Alambre.H>
#include <SoftwareSerial.H>
#include <Eeprom.H>
#include <LiquidCrystal.H>
#include <Avr/Dormir.H>


#define MaxInputBufferSize 20 máximo 255 caracteres para adaptarse a vlcdr
#define EEpromSize 990

#define rLcdChr 20
#define LcdRows 4
#define Intervalo 1000

CellAddresses de memoria EEprom para configuración
#define EEFadeSeconds  993
#define EEPINA 996
#define EEPINC 997
#define EEPINDD 998

SoftwareSerial mySerial(7, 6); RX, TX

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

Variables
Byte DisplayBankContent = 0;

Manejo de entradas serie
Char TBuffer;
Char Cbuffer[MaxInputBufferSize + 1];     Búfer de entrada de código USB
Cadena Sbuffer = "";                      Búfer de entrada de cadena USB
Int Valor;                                Búfer de entrada Nummeric USB
Byte Ccount = 0;                          Número recibido Chars
Byte Inptype = 0;
Booleana StrInput = Falso;
Booleana NumberInput = Falso;
Booleana DataInput = Falso;
Booleana EnterInput = Falso;
Byte MenueSelection = 0;

Byte SelectedMsg = 0;

Dar información de depuración a través de la interfaz serie
Booleana DebugMode = Falso;
Booleana EchoMode = Verdad;

Eeprom
Int eeaddress;                 Puntero de dirección EEPROM
Byte EePromBanks = 0;          Se utiliza para calcular los bancos EEPROM
SerMnueControl
Byte MnuState = 0;            Profundidad máxima del menú 255 icl Sub
Byte Selectedbank = 0;

Reloj en tiempo real
Largo anteriorMillis = 0;       almacenará la última vez se midió
Largo anteriorMillisB = 0;       almacenará la última vez se midió

Gestión de pantallas
Booleana DisplayLock = Falso;
Booleana Directprint = Falso;
Byte DirectprintROW = 0;
Byte DirectprintLine = 0;
Booleana RefreshDisplay = Falso;
Byte FRMCheck = 0; Operaciones de escritura fpr usadas a eeprom para guardar los ciclos de hosts

Vacío Configuración()
{   EePromBanks = EEpromSize / ((rLcdChr) * LcdRows);   Lcd.Comenzar(rLcdChr, LcdRows);   Lcd.Claro();   Lcd.setCursor(0, 0);   Lcd.Impresión(" Bluetooth ");   Lcd.setCursor(0, 1);   Lcd.Impresión(" Pantalla ");   mySerial.Comenzar(9600);   Lcd.setCursor(0, 0);   mySerial.rubor();
}



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

Vacío Bucle()

{   SerialcommandProcessor();   Procesador de pantalla();

}

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


Vacío TextHeader(Byte rowm)
{   mySerial.println("Texto para banco" + Cadena( Selectedbank) + " FILA " + Cadena (rowm) + ":");
}

Vacío SerialcommandProcessor()
{   Int Un;   Inptype = 0;   Inptype = SerInputHandler();   0 sin retorno   1 número   2 Cuerdas   3 Datos   Si ((Inptype > 0) & (!Directprint))   {     MenueSelection = 0;     Si ((MnuState < 2) && (Inptype == 2)) {       Sbuffer.Touppercase();  Para facilitar la introducción de comandos     }     Si ((Sbuffer == "S") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 3;     }     Borrado TODO el contenido de EEprom     Si ((Sbuffer == "E") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 4;     }     Si ((Sbuffer == "Si") && (MnuState == 1) && (Inptype == 2))      {       MenueSelection = 5;     }     Si ((Sbuffer != "Si") && (MnuState == 1) && (Inptype == 2))     {       MenueSelection = 6;     }     Editar contenido seleccionado     Si ((Sbuffer == "W") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 7;     }     Si ((MnuState == 2) && (Valor  < EePromBanks) && (Inptype == 1)) {       MenueSelection = 8;     }     Si (MnuState == 3)                                               {       MenueSelection = 9;     }     Si (MnuState == 4)                                               {       MenueSelection = 10;     }     Mostrar contenido seleccionado     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 == "D") && (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;     }     Interruptor (MenueSelection)     {       Caso 1:         {           Romper;         }       Caso 2:         {           Romper;         }       Caso 3:         {           mySerial.println("Leer contenido de EEEPROM:" );           mySerial.rubor();           Para (Int Un = 0; Un < EePromBanks; Un++)           {             mySerial.println("Banco de Memoria EEPROM: " + Cadena(Un) );             mySerial.rubor();             Para (Int B = 1; B <= LcdRows; B++)             {               mySerial.Impresión("Buena" + Cadena(B) + ": ");               mySerial.rubor();               Para (Int C = 0; C < rLcdChr; C++)               {                 eeaddress = 0;                 eeaddress = (Un * (rLcdChr) * LcdRows) + ((rLcdChr) * B) + C;                 Valor = Eeprom.Leer(eeaddress);                 mySerial.Impresión(Char(Valor));                 mySerial.rubor();               }               mySerial.println(" ");               mySerial.rubor();             }           }           Sbuffer = "";           mySerial.println("No hay más bancos EEPROM disponibles.");           mySerial.rubor();           Romper;         }       Caso 4:         {           Valor = 0;           mySerial.Impresión("Borrado de EEPROM");           mySerial.println("SI/NO:");           mySerial.rubor();           MnuState = 1;           Sbuffer = "";           Romper;         }       Caso 5:         {           Valor = 0;           mySerial.Impresión("Borrado de EEPROM");           mySerial.println("Espera.");           mySerial.rubor();           Para (Int Un = 0; Un < EePromBanks; Un++)           {             Banco de memoria a             mySerial.println("Banco Claro:" + Cadena(Un));             Para (Int B = 1; B <= LcdRows; B++)             {               Para (Int C = 0; C < rLcdChr; C++)               {                 eeaddress = 0;                 eeaddress = (Un * (rLcdChr) * LcdRows) + ((rLcdChr ) * B) + C;                 FRMCheck = Eeprom.Leer(eeaddress);                 Si (FRMCheck > 0)                 {                   Eeprom.Escribir(eeaddress, 00); Formatierung                   mySerial.Impresión(".");                   Valor++;                   Retraso(30);                   mySerial.rubor();                 }               }             }             mySerial.println("");             mySerial.rubor();           }           mySerial.println("");           mySerial.println("Acabado." + Cadena(Valor) + " Bytes borrados");           mySerial.println("");           mySerial.rubor();           Sbuffer = "";           MnuState = 0;           Romper;         }       Caso 6:         {           Valor = 0;           Sbuffer = "";           MnuState = 0;           mySerial.println("OP abortar.");           mySerial.rubor();           Romper;         }       Caso 7:         {           mySerial.println("Número de banco EEPPROM (0-" + Cadena(EePromBanks - 1) + "):");           mySerial.rubor();           MnuState = 2;           Valor = 0;           Sbuffer = "";           Romper;         }       Caso 8:         {           Selectedbank = Valor;           TextHeader(1);           MnuState = 3;           Sbuffer = "";           Valor = 0;           Romper;         }       Caso 9:         {           WriteEEPROM(Selectedbank, 1);           TextHeader(2);           Valor = 0;           MnuState = 4;           Sbuffer = "";           Romper;         }       Caso 10:         {           WriteEEPROM(Selectedbank, 2);           Valor = 0;           MnuState = 0;           Sbuffer = "";           TextHeader(3);           mySerial.rubor();           Valor = 0;           MnuState = 9;           Sbuffer = "";           Romper;         }       Caso 11:         {           Valor = 0;           mySerial.println("Número de banco EEPPROM (0-" + Cadena(EePromBanks - 1) + "):");           MnuState = 5;           Sbuffer = "";           mySerial.rubor();           Romper;         }       Caso 12:         {           SelectedMsg = Valor;           DisplayBank(Valor);           Romper;         }       Caso 13:         {           Valor = 0;           mySerial.println("Número de banco EEPPROM (0-" + Cadena(EePromBanks - 1) + "):");           MnuState = 6;           Sbuffer = "";           mySerial.rubor();           Romper;         }       Caso 14:         {           Un = Valor;           Si ( Un < EePromBanks)           {             mySerial.println("Banco de memoria: " + Cadena(Un) );             mySerial.rubor();             Para (Int B = 1; B <= LcdRows; B++)             {               mySerial.Impresión("Buena" + Cadena(B) + ": ");               mySerial.rubor();               Para (Int C = 0; C < rLcdChr; C++)               {                 eeaddress = 0;                 eeaddress = (Un * (rLcdChr) * LcdRows) + ((rLcdChr) * B) + C;                 Valor = Eeprom.Leer(eeaddress);                 mySerial.Impresión(Char(Valor));                 mySerial.rubor();               }               mySerial.println(" ");               mySerial.rubor();             }           } Más           {             mySerial.println("Valor fuera de rango.");           }           Valor = 0;           Sbuffer = "";           MnuState = 0;           Romper;         }       Caso 15:         {           Direct pPrint to Display           Directprint = Verdad;           mySerial.println ("Directprint ON.");           Si (Directprint)           {             DirectprintROW = 0;             DirectprintLine = 0;             Lcd.Claro();             Lcd.Cursor();             Lcd.Parpadear();           }           Valor = 0;           Sbuffer = "";           MnuState = 0;           Romper;         }       Caso 16:         {           Valor = 0;           Sbuffer = "";           MnuState = 0;           Romper;         }       Caso 20:         {           WriteEEPROM(Selectedbank, 3);           Valor = 0;           MnuState = 0;           Sbuffer = "";           TextHeader(4);           mySerial.rubor();           Valor = 0;           MnuState = 10;           Sbuffer = "";           Romper;         }       Caso 21:         {           WriteEEPROM(Selectedbank, 4);           Valor = 0;           MnuState = 0;           Sbuffer = "";           Romper;         }       Predeterminado:         {           mySerial.println("-------Smart Bluetooth Display 1.0------");           mySerial.println("S - Leer TODOS los bancos EEPROM");           mySerial.println("E - Borrar TODOS los bancos EEPROM");           mySerial.println("W - Escribir sel. EEPROM Bank");           mySerial.println("R - Leer sel. EEPROM Bank");           mySerial.println("P - Imprimir EEPROM Bank en pantalla");           mySerial.println("----------------------------------------");           mySerial.println("D - Impresión directa");           mySerial.println("----------------------------------------");           mySerial.println("Escriba Cmd y pulse Intro");           mySerial.rubor();           MnuState = 0;           Valor = 0;           Sbuffer = "";         }     }   } Eingabe erkannt
}

Vacío WriteEEPROM(Byte FBank, Byte FRow)
{   Byte Contador de escritura;   Contador de escritura = 0;   mySerial.Impresión("Ahorro");   Para (Int C = 0; C < rLcdChr; C++)   {     eeaddress = 0;     eeaddress = (FBank * (rLcdChr) * LcdRows) + ((rLcdChr) * FRow) + C;     Valor = Eeprom.Leer(eeaddress);     Si (Sbuffer[C] != Valor)     {       Eeprom.Escribir(eeaddress, Sbuffer[C]);       mySerial.Impresión(".");       Contador de escritura++;     }   }   mySerial.println(" " + Cadena (Contador de escritura) + " Bytes escritos.");

}


Vacío ClearCBuffer ()

{   Para (Byte Un = 0; MaxInputBufferSize - 1; Un++)     Cbuffer[Un] = 0;
}


Byte SerInputHandler()

{   Byte Resultado = 0;   Int C;   Int D;   Int Un;   Int B;   Resultado = 0;   Si (CheckforserialEvent())   {     Si ((NumberInput) Y No (DataInput) Y No (StrInput))    Sólo números     {       Sbuffer = "";       Valor = 0;       StrInput = Falso;       NumberInput = Falso;       DataInput = Falso;       EnterInput = Falso;       Un = 0;       B = 0;       C = 0;       D = 0;       Sbuffer = Cbuffer; Zahl wird AUCH ! en SBUFFER-bernommen, cae bentigt.       Si (Ccount == 1) {         Valor  = Cbuffer[0] - 48 ;       }       Si (Ccount == 2) {         Un = Cbuffer[0] - 48 ;         Un = Un * 10;         B = Cbuffer[1] - 48 ;         Valor = Un + B;       }       Si (Ccount == 3) {         Un = Cbuffer[0] - 48 ;         Un = Un * 100;         B = Cbuffer[1] - 48 ;         B = B * 10;         C = Cbuffer[2] - 48 ;         Valor = Un + B + C;       }       Si (Ccount == 4) {         Un = Cbuffer[0] - 48 ;         Un = Un * 1000;         B = Cbuffer[1] - 48 ;         B = B * 100;         C = Cbuffer[2] - 48 ;         C = C * 10;         D = Cbuffer[3] - 48 ;         Valor = Un + B + C + D;       }       Si (Ccount >= 5)       {         Sbuffer = "";         Valor = 0;         Sbuffer = Cbuffer;         ClearCBuffer;         Resultado = 2;       } Más       {         ClearCBuffer;         Ccount = 0;         Resultado = 1;                                                Código de devolución del número         NumberInput = Falso;         StrInput = Falso;         DataInput = Falso;         EnterInput = Falso;         Ccount = 0;         devolución Resultado;       }     }     Si ((StrInput) Y No (DataInput))                          Sólo entrada de cadena     {       Sbuffer = "";       Sbuffer = Cbuffer;       Valor = 0;       StrInput = Falso;       NumberInput = Falso;       DataInput = Falso;       EnterInput = Falso;       Ccount = 0;       ClearCBuffer;       Resultado = 2;                                                 Código de devolución del número     }     Si (DataInput) {       Sbuffer = "";       Sbuffer = Cbuffer;       Valor = 0;       StrInput = Falso;       NumberInput = Falso;       DataInput = Falso;       EnterInput = Falso;       Ccount = 0;       ClearCBuffer;       Resultado = 3;                                               Código de devolución del número     }     Si ((EnterInput) Y No (StrInput) Y No (NumberInput) Y No (DataInput))     {       Sbuffer = "";       Valor = 0;       Ccount = 0;       ClearCBuffer;       Resultado = 4;                                               Código de devolución del número     }     NumberInput = Falso;     StrInput = Falso;     DataInput = Falso;     EnterInput = Falso;     Ccount = 0;     devolución Resultado;   }   devolución Resultado;   Fin de CheckforSerialEvent
}



Eingabebuffer


Booleana CheckforserialEvent()
{   Mientras (mySerial.Disponible()) {     obtener el nuevo byte:     TBuffer = mySerial.Leer();     Si (TBuffer > 9 && TBuffer < 14)     {       Cbuffer[Ccount] = 0;       TBuffer = 0;       Si (EchoMode)       {         mySerial.Impresión(Char(13));         mySerial.rubor();       }       Si (Directprint)       {         mySerial.println("");         DirectprintLine = 0;         DirectprintROW = DirectprintROW + 1;         Si ( DirectprintROW > 3)         {           Directprint = Falso;           Lcd.noCursor();           Lcd.noBlink();           Sbuffer = "";           Valor = 0;         } Más         {           Lcd.Cursor();           Lcd.Parpadear();           Lcd.setCursor(0, DirectprintROW);         }       }       EnterInput = Verdad;       devolución Verdad;     } Más Si (TBuffer > 47 && TBuffer < 58 )     {       Si ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         Si ((Directprint))         {           Lcd.Impresión(Char(TBuffer));           DirectprintLine = DirectprintLine + 1;           Si ( Ccount > MaxInputBufferSize - 1)           {             Lcd.noCursor();             Lcd.noBlink();           } Más {             Lcd.Cursor();             Lcd.Parpadear();           }         }         Si (EchoMode) {           mySerial.Impresión(Char(TBuffer));           mySerial.rubor();         }       } Más {         mySerial.Impresión("#");       }       Número Entrada detectada       NumberInput = Verdad;     }     Más Si (TBuffer > 64 && TBuffer < 123 )     {       Si ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         Si ((Directprint))         {           Lcd.Impresión(Char(TBuffer));           DirectprintLine = DirectprintLine + 1;           Si ( Ccount > MaxInputBufferSize - 1)           {             Lcd.noCursor();             Lcd.noBlink();           } Más {             Lcd.Cursor();             Lcd.Parpadear();           }         }         Si (EchoMode) {           mySerial.Impresión(Char(TBuffer));           mySerial.rubor();         }       } Más {         mySerial.Impresión("#");       }       Entrada de carácter Char detectada       StrInput = Verdad;     }     Más Si ( (TBuffer == 127 )  |  (TBuffer == 8 ) )     {       Si ( DirectprintLine > 0 )       {         DirectprintLine = DirectprintLine - 1;         Lcd.setCursor(DirectprintLine, DirectprintROW);         Lcd.Impresión(" ");         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();           } Más {             Lcd.Cursor();             Lcd.Parpadear();           }         }         Si (EchoMode) {           mySerial.Impresión("-");           mySerial.rubor();         }       }     }     Más     {       Si ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer;         Ccount++;         Si ((Directprint))         {           DirectprintLine = DirectprintLine + 1;           Si (TBuffer < 128) {             Lcd.Impresión(Char(TBuffer));           } Más  {             Lcd.Impresión(Cadena(TBuffer));           }           Si ( Ccount > MaxInputBufferSize - 1)           {             Lcd.noCursor();             Lcd.noBlink();           } Más {             Lcd.Cursor();             Lcd.Parpadear();           }         }         Si (EchoMode) {           mySerial.Impresión(Char(TBuffer));           mySerial.rubor();         }       } Más {         mySerial.Impresión("#");       }       Entrada de datos detectada       DataInput = Verdad;     }     devolución Falso;   }   devolución Falso;
}

Vacío Procesador de pantalla()  Con la pantalla azul, se omite el desplazamiento ingesising, ya que esto sólo "lubrica"
{   Si (RefreshDisplay)   {     Lcd.Claro();     RefreshDisplay = Falso;     Para (Int B = 1; B <= LcdRows; B++)     {       Lcd.setCursor(0, B - 1);       mySerial.Impresión("Fila" + Cadena(B) + ": ");       Para (Int C = 0; C < rLcdChr; C++)       {         eeaddress = 0;         eeaddress = (DisplayBankContent * (rLcdChr) * LcdRows) + ((rLcdChr) * B) + C;         Valor = 0;         Valor = Eeprom.Leer(eeaddress);         Si (Valor > 31) No muestres caracteres especiales         {           Retraso(100);           Lcd.Impresión(Char(Valor));         } Más         {           Lcd.Impresión(Char(32));         }       }     }   }
}


Vacío DisplayBank ( Byte cobank)
{   Si (cobank  < EePromBanks )   {     RefreshDisplay = Verdad;   Initalize Display Output     DisplayBankContent = cobank;     mySerial.println("Banco" + Cadena(cobank) + " se muestra en la pantalla LCD");     MnuState = 0;     Sbuffer = "";     Valor = 0;     mySerial.rubor();   } Más   {     mySerial.println("Banco no disponible.");     Valor = 0;     MnuState = 0;     Sbuffer = "";     mySerial.rubor();   }
}

 

Los nuevos comandos creados por la extensión de menú se explican a continuación.

  • S - Leer TODOS los bancos EEPROM

Al introducir "S" e Intro se muestran todos los espacios de memoria disponibles y su contenido. Con una pantalla de caracteres 4x20 y el Predeterminado son 11 ranuras de memoria. En la siguiente captura de pantalla se documenta el Banco 1:

 

Contenido de EEPROM

  • E - Borrar TODOS los bancos EEPROM

El elemento de menú "E" nos permite "formatear" el EEPROM interno al utilizar la pantalla por primera vez, así como eliminar TODOS los bancos de memoria más adelante en uso. Un "proceso de formato" se ve así en la interfaz de menú:

Eliminar todo el contenido usando "E"

 

  • W - Escribir sel. Banco EEPROM

W - Escritura

 

  • R - Leer sel. Banco EEPROM

Si se va a visualizar un texto específico de un banco de memoria específico pero no se muestra en la pantalla, se puede mostrar a través del elemento de menú "R" en.

R - Leer

 

  • P - Imprimir EEPROM Bank en la pantalla

P - Imprimir

Les deseo mucha diversión de reconstrucción y, como siempre, hasta la próxima vez.

MuestraProyectos para principiantes

Deja un comentario

Todos los comentarios son moderados antes de ser publicados

Artículos de blog

  1. Ahora instalamos el esp32 a través de la administración.
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. Transporte Aéreo - programación de ESP mediante redes locales inalámbricas