Pantalla Bluetooth - Parte 4

Bienvenido a la cuarta parte de la serie de pantallas Bluetooth.

 

En la parte de hoy, además de un elemento adicional obligatorio del menú del operador, nuestra pantalla recibe otra pequeña extensión de hardware. ¡Con esta nueva extensión de hardware, los mensajes almacenados en la memoria interna se pueden recuperar incluso sin el menú del operador!

Para esto, usamos otro puerto libre de nuestro microcontrolador (compatible con Uno R3) como entrada. Más precisamente: usamos el puerto 2 como entrada. Un botón pulsador está conectado a tierra en esta entrada, nuestro botón es evaluado por nuestro Arduino.

Pero ahora a la estructura real y la implementación de la extensión. En el primer paso, expandimos nuestro hardware con el módulo de botón KY-004 como se muestra en el siguiente diagrama de circuito. En total, la pantalla Bluetooth tiene 12 memorias de texto con 4x20 caracteres cuando se usa un Arduino estándar.

Estos se muestran en orden ascendente de 0 a 11 cuando se presiona el botón. Si aparece el mensaje 11 en la pantalla y se presiona el botón, el contador vuelve al mensaje 0.

Pantalla Bluetooth - parte 4 - diagrama del circuito

 

A continuación, cargamos el siguiente código personalizado en nuestro microcontrolador para esta extensión:

 

 

#include <SPI.h>
#include <Alambre.h>
#include <Software Serial.h>
#include <EEPROM.h>
#include <Cristal líquido.h>
#include <avr/dormir.h>

#definir MaxInputBufferSize 20 // adapta un máximo de 255 caracteres a vlcdr
#definir EEpromSize 990
#definir rLcdChr 20
#definir LcdRows 4
#definir intervalo 1000
#definir Luz de fondo 5 // LED de retroiluminación del puerto 5
#definir SwitchPin 2 // Selección del mensaje del botón del puerto 12
#definir DelayTOPWROFF 500

// Direcciones de celda de memoria EEprom para configuración
#definir EEFadeSeconds  993
#definir EEPINA 996
#definir EEPINC 997
#definir EEPINDD 998


Software Serial mySerial(7, 6); // RX, TX
Cristal líquido lcd(8, 13, 12, 11, 10, 9);

// variables
byte DisplayBankContent = 0;

// Manejo de entrada en 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 numérica USB
byte Cuenta = 0;                          // Número de caracteres recibidos
byte Intype = 0;
booleano StrInput = falso;
booleano NumberInput = falso;
booleano DataInput = falso;
booleano EnterInput = falso;
byte MenueSelection = 0;

// control de botón
booleano Switchstate = cierto;
booleano SwitchstateBuffer = cierto;
byte SelectedMsg = 0;

// Proporcione información de depuración a través de la interfaz serial
booleano EchoMode = cierto;

// EEPROM
int dirección;                 // puntero de dirección EEPROM
byte EEPromBanks = 0;          // Utilizado para calcular los bancos EEPROM
// SerMnueControl
byte MnuState = 0;            // Profundidad máxima del menú 255 icl sub
byte Banco seleccionado = 0;

// reloj en tiempo real
largo anteriorMillis = 0;       // almacenará la última vez que se midió
largo anteriorMillisB = 0;       // almacenará la última vez que se midió

// Gestión de pantallas
booleano DisplayLock = falso;
booleano Directprint = falso;
byte DirectprintROW = 0;
byte DirectprintLine = 0;

booleano ActualizarDisplay = falso;
byte FRMCheck = 0; // Se utiliza para escribir operaciones en eeprom, así que guarde los ciclos de host
// monitoreo de la batería
flotar Voltaje;
booleano PowersaveMode = falso;

// control de luz PWM

byte Brillo actual = 0;
byte Brillo objetivo = 0;
byte FadeSeconds = 0; // estándar = 3


nulo configuración()
{   EEPromBanks = EEpromSize / ((rLcdChr) * LcdRows);   lcd.comenzar(rLcdChr, LcdRows);   lcd.claro();   lcd.setCursor(0, 0);   lcd.imprimir("Bluetooth");   lcd.setCursor(0, 1);   lcd.imprimir("Pantalla");   mySerial.comenzar(9600);   pinMode(SwitchPin, INPUT_PULLUP); // texto de selección de botón de EEprom   pinMode(Luz de fondo, SALIDA); // Iluminación de pantalla / pantalla ON / OFF   digitalWrite(Luz de fondo, BAJO);   // leer Config   FadeSeconds = EEPROM.leer(EEFadeSeconds);   Brillo actual = 0;   Brillo objetivo = 0;   lcd.setCursor(0, 4);   Si (DisplayLock) {     lcd.impresión("Sistema gesperrt");   }   // Más rutinas de configuración / inicialización   lcd.setCursor(0, 0);   Brillo objetivo = 255;   mySerial.rubor();
}

// ###################################################################################################### //
vacío lazo()
{   SerialcommandProcessor();   runrealTimeClock();   Procesador de pantalla();   SwitchProcessor();   // Fin del bucle principal
}
// ###################################################################################################### //

vacío TextHeader(byte Rowm)
{   mySerial.println("Texto para el banco" + Cuerda( Banco seleccionado) + " FILA " + Cuerda (Rowm) + ":");
}

vacío SerialcommandProcessor()
{   En t un;   Intype = 0;   Intype = SerInputHandler();   // 0 keine Rückgabe   // 1 Nummer   // 2 cuerdas   // 3 datos   Si ((Intype > 0) & (!Directprint))   {     MenueSelection = 0;     Si ((MnuState < 2) && (Intype == 2)) {       Sbuffer.toUpperCase();  // Para comandos de ingreso fácil     }     Si ((Sbuffer == "ECO") && (MnuState == 0) && (Intype == 2))     {       MenueSelection = 2;     }     Si ((Sbuffer == "S") && (MnuState == 0) && (Intype == 2))       {       MenueSelection = 3;     }     // Borrar TODO el contenido de EEprom     Si ((Sbuffer == "MI") && (MnuState == 0) && (Intype == 2))       {       MenueSelection = 4;     }     Si ((Sbuffer == "SI") && (MnuState == 1) && (Intype == 2))      {       MenueSelection = 5;     }     Si ((Sbuffer != "SI") && (MnuState == 1) && (Intype == 2))     {       MenueSelection = 6;     }     // Editar contenido seleccionado     Si ((Sbuffer == "W") && (MnuState == 0) && (Intype == 2))       {       MenueSelection = 7;     }     Si ((MnuState == 2) && (valor  < EEPromBanks) && (Intype == 1)) {       MenueSelection = 8;     }     Si (MnuState == 3)                                               {       MenueSelection = 9;     }     Si (MnuState == 4)                                               {       MenueSelection = 10;     }     // Mostrar contenido seleccionado     Si ((Sbuffer == "PAG") && (MnuState == 0) && (Intype == 2))       {       MenueSelection = 11;     }     Si ((MnuState == 5) && (Intype == 1))                           {       MenueSelection = 12;     }     Si ((Sbuffer == "R") && (MnuState == 0) && (Intype == 2))       {       MenueSelection = 13;     }     Si ((MnuState == 6) && (Intype == 1))                           {       MenueSelection = 14;     }     Si ((Sbuffer == "RE") && (MnuState == 0) && (Intype == 2))       {       MenueSelection = 15;     }     Si ((Sbuffer == "Z") && (MnuState == 0) && (Intype == 2))       {       MenueSelection = 16;     }     Si ((Sbuffer == "SI") && (MnuState == 0) && (Intype == 2))       {       MenueSelection = 17;     }     Si ((MnuState == 7) && (Intype == 1))                           {       MenueSelection = 18;     }     Si ((Sbuffer == "DESVANECERSE") && (MnuState == 0) && (Intype == 2))     {       MenueSelection = 19;     }     Si (MnuState == 9)                                               {       MenueSelection = 20;     }     Si (MnuState == 10)                                              {       MenueSelection = 21;     }     Si (MnuState == 12)                                              {       MenueSelection = 25;     }     cambiar (MenueSelection)     {       caso 2:         {           mySerial.impresión("Eco ");           EchoMode = !EchoMode;           Si (EchoMode) {             mySerial.println(" EN.");           } más           {             mySerial.println(" APAGADO.");           }           mySerial.println("");           mySerial.rubor();           valor = 0;           MnuState = 0;           Sbuffer = "";           descanso;         }       caso 3:         {           mySerial.println("Leer contenido de EEEPROM:" );           mySerial.rubor();           para (En t un = 0; un < EEPromBanks; un++)           {             mySerial.println("Banco de memoria EEPROM:" + Cuerda(un) );             mySerial.rubor();             para (En t si = 1; si <= LcdRows; si++)             {               mySerial.impresión("Fila " + Cuerda(si) + ": ");               mySerial.rubor();               para (En t C = 0; C < rLcdChr; C++)               {                 dirección = 0;                 dirección = (un * (rLcdChr) * LcdRows) + ((rLcdChr) * si) + C;                 valor = EEPROM.leer(dirección);                 mySerial.impresión(carbonizarse(valor));                 mySerial.rubor();               }               mySerial.println(" ");               mySerial.rubor();             }           }           Sbuffer = "";           mySerial.println("No más bancos EEPROM disponibles".);           mySerial.rubor();           descanso;         }       caso 4:         {           valor = 0;           mySerial.impresión("Borrando EEPROM");           mySerial.println("SÍ NO:");           mySerial.rubor();           MnuState = 1;           Sbuffer = "";           descanso;         }       caso 5:         {           valor = 0;           mySerial.impresión("Borrando EEPROM");           mySerial.println("Colocarse.");           mySerial.rubor();           para (En t un = 0; un < EEPromBanks; un++)           {             // Banco de memoria a             mySerial.println("Clear Bank:" + Cuerda(un));             para (En t si = 1; si <= LcdRows; si++)             {               para (En t C = 0; C < rLcdChr; C++)               {                 dirección = 0;                 dirección = (un * (rLcdChr) * LcdRows) + ((rLcdChr ) * si) + C;                 FRMCheck = EEPROM.leer(dirección);                 Si (FRMCheck > 0)                 {                   EEPROM.escribir(dirección, 00); // Formatierung                   mySerial.impresión(".");                   valor++;                   retrasar(30);                   mySerial.rubor();                 }               }             }             mySerial.println("");             mySerial.rubor();           }           mySerial.println("");           mySerial.println("Terminado. " + Cuerda(valor) + "Bytes borrados");           mySerial.println("");           mySerial.rubor();           Sbuffer = "";           MnuState = 0;           descanso;         }       caso 6:         {           valor = 0;           Sbuffer = "";           MnuState = 0;           mySerial.println("OP abortar".);           mySerial.rubor();           descanso;         }       caso 7:         {           mySerial.println("Número de banco EEPPROM (0-" + Cuerda(EEPromBanks - 1) + "):");           mySerial.rubor();           MnuState = 2;           valor = 0;           Sbuffer = "";           descanso;         }       caso 8:         {           Banco seleccionado = valor;           TextHeader(1);           MnuState = 3;           Sbuffer = "";           valor = 0;           descanso;         }       caso 9:         {           WriteEEPROM(Banco seleccionado, 1);           TextHeader(2);           valor = 0;           MnuState = 4;           Sbuffer = "";           descanso;         }       caso 10:         {           WriteEEPROM(Banco seleccionado, 2);           valor = 0;           MnuState = 0;           Sbuffer = "";           TextHeader(3);           mySerial.rubor();           valor = 0;           MnuState = 9;           Sbuffer = "";           descanso;         }       caso 11:         {           valor = 0;           mySerial.println("Número de banco EEPPROM (0-" + Cuerda(EEPromBanks - 1) + "):");           MnuState = 5;           Sbuffer = "";           mySerial.rubor();           descanso;         }       caso 12:         {           SelectedMsg = valor;           DisplayBank(valor);           descanso;         }       caso 13:         {           valor = 0;           mySerial.println("Número de banco EEPPROM (0-" + Cuerda(EEPromBanks - 1) + "):");           MnuState = 6;           Sbuffer = "";           mySerial.rubor();           descanso;         }       caso 14:         {           un = valor;           Si ( un < EEPromBanks)           {             mySerial.println("Banco de memoria: " + Cuerda(un) );             mySerial.rubor();             para (En t si = 1; si <= LcdRows; si++)             {               mySerial.impresión("Fila " + Cuerda(si) + ": ");               mySerial.rubor();               para (En t C = 0; C < rLcdChr; C++)               {                 dirección = 0;                 dirección = (un * (rLcdChr) * LcdRows) + ((rLcdChr) * si) + C;                 valor = EEPROM.leer(dirección);                 mySerial.impresión(carbonizarse(valor));                 mySerial.rubor();               }               mySerial.println(" ");               mySerial.rubor();             }           } más           {             mySerial.println("Valor fuera de rango.");           }           valor = 0;           Sbuffer = "";           MnuState = 0;           descanso;         }       caso 15:         {           // pPrint directo para mostrar           Directprint = cierto;           mySerial.println ("Directprint activado".);           Si (Directprint)           {             DirectprintROW = 0;             DirectprintLine = 0;             lcd.claro();             lcd.cursor();             lcd.parpadeo();           }           valor = 0;           Sbuffer = "";           MnuState = 0;           descanso;         }       caso 16:         {           valor = 0;           Sbuffer = "";           MnuState = 0;           descanso;         }       caso 17:         {           mySerial.println("Brillo de pantalla: (máx. 255)");           MnuState = 7;           valor = 0;           Sbuffer = "";           descanso;         }       caso 18:         {           Si ((valor < 256))           {             Brillo objetivo = valor;             mySerial.println("Brillo:" + Cuerda (Brillo objetivo) + "Set");           } más           {             mySerial.println("Valor fuera de rango.");           }           MnuState = 0;           valor = 0;           Sbuffer = "";           descanso;         }       caso 19:         {           mySerial.println("Retraso de desvanecimiento: (máx. 255 segundos)");           MnuState = 12;           valor = 0;           Sbuffer = "";           descanso;         }       caso 20:         {           WriteEEPROM(Banco seleccionado, 3);           valor = 0;           MnuState = 0;           Sbuffer = "";           TextHeader(4);           mySerial.rubor();           valor = 0;           MnuState = 10;           Sbuffer = "";           descanso;         }       caso 21:         {           WriteEEPROM(Banco seleccionado, 4);           valor = 0;           MnuState = 0;           Sbuffer = "";           descanso;         }       caso 25:         {           Si ((valor > 0) & (valor < 251))           {             FadeSeconds = valor;             EEPROM.escribir(EEFadeSeconds, FadeSeconds);             mySerial.println("Valor" + Cuerda (valor) + "conjunto");           } más           {             valor = 0;             Sbuffer = "";             mySerial.println("Valor fuera de rango.");           }           valor = 0;           MnuState = 0;           Sbuffer = "";           descanso;         }       defecto:         {           Si (DisplayLock)           {             lcd.claro();             DisplayLock = falso;           }           mySerial.println("------- Pantalla inteligente Bluetooth 1.1 ------");           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 banco EEPROM en pantalla");           mySerial.println("----------------------------------------");           mySerial.println("D - Impresión directa");           mySerial.println("B - Valor actual del brillo de la pantalla:" + Cuerda (Brillo actual));           mySerial.println("Otro: ECHO");           mySerial.println("----------------------------------------");           mySerial.println("Escriba Cmd y presione Entrar");           mySerial.rubor();           MnuState = 0;           valor = 0;           Sbuffer = "";         }     }   } // Eingabe erkannt
}

vacío WriteEEPROM(byte FBank, byte Fow)
{   byte Contador de escritura;   Contador de escritura = 0;   mySerial.impresión("Ahorrando");   para (En t C = 0; C < rLcdChr; C++)   {     dirección = 0;     dirección = (FBank * (rLcdChr) * LcdRows) + ((rLcdChr) * Fow) + C;     valor = EEPROM.leer(dirección);     Si (Sbuffer[C] != valor)     {       EEPROM.escribir(dirección, Sbuffer[C]);       mySerial.impresión(".");       Contador de escritura++;     }   }   mySerial.println(" " + Cuerda (Contador de escritura) + "Bytes escritos".);
}

vacío ClearCBuffer ()
{   para (byte un = 0; MaxInputBufferSize - 1; un++)     Cbuffer[un] = 0;
}

byte SerInputHandler()
{   byte resultado = 0;   En t C;   En t re;   En t un;   En t si;   resultado = 0;   Si (CheckforserialEvent())   {     Si ((NumberInput) y no (Entrada de datos) y no (StrInput))    //Solo numeros     {       Sbuffer = "";       valor = 0;       StrInput = falso;       NumberInput = falso;       Entrada de datos = falso;       EnterInput = falso;       un = 0;       si = 0;       C = 0;       re = 0;       Sbuffer = Cbuffer; // ¡Zahl wird AUCH! en SBUFFER übernommen, cae benötigt.       Si (Cuenta == 1) {         valor  = Cbuffer[0] - 48 ;       }       Si (Cuenta == 2) {         un = Cbuffer[0] - 48 ;         un = un * 10;         si = Cbuffer[1] - 48 ;         valor = un + si;       }       Si (Cuenta == 3) {         un = Cbuffer[0] - 48 ;         un = un * 100;         si = Cbuffer[1] - 48 ;         si = si * 10;         C = Cbuffer[2] - 48 ;         valor = un + si + C;       }       Si (Cuenta == 4) {         un = Cbuffer[0] - 48 ;         un = un * 1000;         si = Cbuffer[1] - 48 ;         si = si * 100;         C = Cbuffer[2] - 48 ;         C = C * 10;         re = Cbuffer[3] - 48 ;         valor = un + si + C + re;       }       Si (Cuenta >= 5)       {         Sbuffer = "";         valor = 0;         Sbuffer = Cbuffer;         ClearCBuffer;         resultado = 2;       } más       {         ClearCBuffer;         Cuenta = 0;         resultado = 1;                                                // Número Código de retorno         NumberInput = falso;         StrInput = falso;         Entrada de datos = falso;         EnterInput = falso;         Cuenta = 0;         regreso resultado;       }     }     Si ((StrInput) y no (Entrada de datos))                          // Solo entrada de cadena     {       Sbuffer = "";       Sbuffer = Cbuffer;       valor = 0;       StrInput = falso;       NumberInput = falso;       Entrada de datos = falso;       EnterInput = falso;       Cuenta = 0;       ClearCBuffer;       resultado = 2;                                                 // Número Código de retorno     }     Si (Entrada de datos) {       Sbuffer = "";       Sbuffer = Cbuffer;       valor = 0;       StrInput = falso;       NumberInput = falso;       Entrada de datos = falso;       EnterInput = falso;       Cuenta = 0;       ClearCBuffer;       resultado = 3;                                               // Número Código de retorno     }     Si ((EnterInput) y no (StrInput) y no (NumberInput) y no (Entrada de datos))     {       Sbuffer = "";       valor = 0;       Cuenta = 0;       ClearCBuffer;       resultado = 4;                                               // Número Código de retorno     }     NumberInput = falso;     StrInput = falso;     Entrada de datos = falso;     EnterInput = falso;     Cuenta = 0;     regreso resultado;   }   regreso resultado;   // Fin de CheckforSerialEvent
}

// Eingabebuffer

booleano CheckforserialEvent()
{   mientras (mySerial.disponible()) {     // obtener el nuevo byte:     TBuffer = mySerial.leer();     Si (TBuffer > 9 && TBuffer < 14)     {       Cbuffer[Cuenta] = 0;       TBuffer = 0;       Si (EchoMode)       {         mySerial.impresión(carbonizarse(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.parpadeo();           lcd.setCursor(0, DirectprintROW);         }       }       EnterInput = cierto;       regreso cierto;     } más Si (TBuffer > 47 && TBuffer < 58 )     {       Si ( Cuenta < MaxInputBufferSize)       {         Cbuffer[Cuenta] = TBuffer;         Cuenta++;         Si ((Directprint))         {           lcd.impresión(carbonizarse(TBuffer));           DirectprintLine = DirectprintLine + 1;           Si ( Cuenta > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } más {             lcd.cursor();             lcd.parpadeo();           }         }         Si (EchoMode) {           mySerial.impresión(carbonizarse(TBuffer));           mySerial.rubor();         }       } más {         mySerial.impresión("#");       }       // Entrada de número detectada       NumberInput = cierto;     }     más Si (TBuffer > 64 && TBuffer < 123 )     {       Si ( Cuenta < MaxInputBufferSize)       {         Cbuffer[Cuenta] = TBuffer;         Cuenta++;         Si ((Directprint))         {           lcd.impresión(carbonizarse(TBuffer));           DirectprintLine = DirectprintLine + 1;           Si ( Cuenta > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } más {             lcd.cursor();             lcd.parpadeo();           }         }         Si (EchoMode) {           mySerial.impresión(carbonizarse(TBuffer));           mySerial.rubor();         }       } más {         mySerial.impresión("#");       }       // if (DebugMode) {mySerial.println ("Debug: Char over Serial recibido");       // mySerial.flush (); }       // Se detectó la entrada de caracteres de caracteres       StrInput = cierto;     }     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 ))       {         Línea de impresión directa = Línea de impresión directa - 1;         Línea de impresión directa = Rlcdchr Inc. - 1;         Socio limitado.Establecer cursor(Línea de impresión directa, Línea de impresión directa);       }       Si ( Cuenta > 0)       {         Cuenta--;         Cbuffer Inc.[Cuenta] = 0;         Si ((Impresión directa))         {           Si ( Cuenta > Tamaño máximo de la zona de amortiguación - 1)           {             Socio limitado.Moth();             Socio limitado.Norburyn.();           } Hora prevista de despegue {             Socio limitado.Cursor();             Socio limitado.Flash();           }         }         Si (Modo eco) {           Capa muscular.Imprimir("-");           Capa muscular.Sonrojar();         }       }     }     Hora prevista de despegue     {       Si ( Cuenta < Tamaño máximo de la zona de amortiguación)       {         Cbuffer Inc.[Cuenta] = Turbo.;         Cuenta++;         Si ((Impresión directa))         {           Línea de impresión directa = Línea de impresión directa + 1;           Si (Turbo. < 128) {             Socio limitado.Imprimir(Chamuscar(Turbo.));           } Hora prevista de despegue  {             Socio limitado.Imprimir(Cadena(Turbo.));           }           Si ( Cuenta > Tamaño máximo de la zona de amortiguación - 1)           {             Socio limitado.Moth();             Socio limitado.Norburyn.();           } Hora prevista de despegue {             Socio limitado.Cursor();             Socio limitado.Flash();           }         }         Si (Modo eco) {           Capa muscular.Imprimir(Chamuscar(Turbo.));           Capa muscular.Sonrojar();         }       } Hora prevista de despegue {         Capa muscular.Imprimir("#");       }       / / / detección de entrada de datos       Datos = ¿En serio?;     }     Regreso Falso;   }   Regreso Falso;
}

Vacío. Procesador de visualización()  / / en el caso del azul, se ignora la función de desplazamiento porque es sólo "lubricante"
{   Si (Actualizar visualización)   {     Socio limitado.Claro.();     Actualizar visualización = Falso;     Para (Interior B = 1; B <= Pantalla de cristal líquido; B++)     {       Socio limitado.Establecer cursor(0, B - 1);       Capa muscular.Imprimir(Rema. + Cadena(B) + ": ");       Para (Interior Categoría C = 0; Categoría C < Rlcdchr Inc.; Categoría C++)       {         Dirección eeaddress = 0;         Dirección eeaddress = (Mostrar contenido del Banco * (Rlcdchr Inc.) * Pantalla de cristal líquido) + ((Rlcdchr Inc.) * B) + Categoría C;         Valor = 0;         Valor = Memoria de sólo lectura programable.Leer(Dirección eeaddress);         Si (Valor > 31) / / / no mostrar caracteres especiales         {           Capa muscular.Imprimir(Chamuscar(Valor));           Socio limitado.Imprimir(Chamuscar(Valor));         } Hora prevista de despegue         {           Socio limitado.Imprimir(Chamuscar(32));         }       }       Capa muscular.Imprimir();     }   }
}

Vacío. Tiempo real()    / / / tiempo
{   / / reloj en tiempo real y cuenta regresiva   / / Long previous millis = 0; / / / se almacenará la última medición del tiempo   Secvider = 0;   Inapropiado adj. Largo adj. Flujo eléctrico = Millis();   Interior Paso = 0;   / / PWM Exhibition control   Paso = 4 * Temporada;   Si (Flujo eléctrico - Millones. > Paso)   {     Millones. = Flujo eléctrico;     Si (Presente < Objetivo        )     {       Presente = Presente + 1;       Simulación (Luz de fondo, Presente);     } Hora prevista de despegue Si (Presente > Objetivo)     {       Presente = Presente - 1;       Simulación (Luz de fondo, Presente);     }   }   Si (Flujo eléctrico - Millones anteriores > 1000)   {     / / / secundario     Millones anteriores = Flujo eléctrico;   }
}

Vacío. Banco de visualización ( Intercambio Banco)
{   Si (Banco  < EPROM Banks )   {     Actualizar visualización = ¿En serio?;   Salida de visualización inicial     Mostrar contenido del Banco = Banco;     Capa muscular.Imprimir("Banco" + Cadena(Banco) + "Mostrar en LCD");     Más de uno = 0;     Spiveer. = "";     Valor = 0;     Capa muscular.Sonrojar();   } Hora prevista de despegue   {     Capa muscular.Imprimir(El Banco no está disponible.);     Valor = 0;     Más de uno = 0;     Spiveer. = "";     Capa muscular.Sonrojar();   }
}

Vacío. Procesador de conmutador()
{   Estado del interruptor = Lectura digital(El interruptor.);   Si ((!Estado del interruptor) && (Estado del interruptor) && (No Mostrar el bloqueo.))Botón de consulta   {     Estado del interruptor = Falso;     Impresión directa = Falso;     Socio limitado.Moth();     Socio limitado.Norburyn.();     SG (OC) = SG (OC) + 1;     Si (SG (OC) >  EPROM Banks - 1 )     {       SG (OC) = 0;     }     Socio limitado.Claro.();     Socio limitado.Establecer cursor(0, 0);     Socio limitado.Imprimir("El Banco: + Cadena(SG (OC)) + "Selección");     Socio limitado.Establecer cursor(0, 2);     Retraso(10);     Valor = Retrasa el despegue.;     Aunque (Lectura digital(El interruptor.) == 0)     {       Retraso(1);       Si (Valor > 0) {         Valor = Valor - 1;       };       Socio limitado.Establecer cursor(0, 3);     }     Banco de visualización(SG (OC));   }   Si (Estado del interruptor)   {     Estado del interruptor = ¿En serio?;     / / retrasos (10);   }
}

 

Además de la expansión del hardware, ahora tenemos una pequeña función auxiliar en el menú: la orden es echo.De esta manera podemos abrir y cerrar la función de carácter eco de la interfaz en serie.Para determinar los efectos de esto, primero se utiliza el echo en la siguiente sección de pantalla para ordenar el cierre de la función echo.Eso es limpiar con "eco apagado".Utilizando la misma orden, se reactivará la función echo.(cambiar funciones)Esto es similar a "echo on".Desde este punto de vista, todos los caracteres son aceptados.

Parte 4 - Menú de visualización

 

Le deseo mucha diversión en la reconstrucción, como siempre, hasta la próxima vez.

MuestraPara arduinoProyectos para avanzados.Sensores

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