Pantalla Bluetooth - Parte 3

Bienvenidos a la tercera Parte del Bluetooth con Pantalla de Serie. Hoy en día se obtiene nuestra Pantalla junto a un obligatorias de otras Bedienermenüpunkt una pequeña Extensión de Hardware nuevo! A través de esta nueva Hardwareerweiterung puede el color de Fondo y el Brillo de nuestra Pantalla controlados por el Software y configurar!

Para ello vamos a utilizar el Puerto 5 de nuestro Onu como el Pulso, Modulationsausgang. Esta Salida, a continuación, controla un IRF520 Módulo del controlador. Este Módulo, también, por Ejemplo, para el Control de los Motores se utilizan para ello vamos a la barra de puesta a tierra de los Leds incorporados en la Pantalla de impuestos. (La IRF520 activa contra Masa)

De esta Manera, para que el Brillo de nuestra Pantalla en 255 Niveles de impuestos. Más de la comodidad de nuestro Bluetooth Terminal.

Pero ahora a la Construcción real y a la Implementación de la Ampliación. En el primer Paso, ampliamos nuestro Hardware, como en el siguiente Diagrama de cableado se muestra, para el IRF520 MOS Driver Módulo.

 

 

Circuito de Bluetooth de la Pantalla, Parte 3,

En el Circuito cae en primer lugar, el positivo de Entrada y de Salida Terminales de la IRF520 MOS Driver Módulos no están ocupadas. Esto no es un Schaltungsfehler, ya que estos Terminales / Conectores del Módulo para el funcionamiento de nuestro Circuito no es necesario, ya que los Positivos de la Tensión de alimentación para la iluminación de la Pantalla a través de la Vorwiederstand directamente a través de los 5 Voltios del Carril de referencia.

(También en el mismo Módulo, son los Terminales de Vin y V+ sólo puenteado y no tienen ningún activo o pasivo, Componentes, entre los dos Terminales!)

No se dejen, por lo tanto, algo distinto del Predeterminado Beschaltungsweise del Módulo no irrita.

A continuación invitamos para esta Extensión en nuestro Arduino UNO el siguiente Código personalizado de alta:

 

#include <SPI.h>
#include <Wire.h>
#include <SoftwareSerial.h>
#include <EEPROM.h>
#include <LiquidCrystal.h>
#include <avr/sleep.h>

#define MaxInputBufferSize 20 // máximo de 255 Caracteres ajustar a vlcdr
#define EEpromSize 990

#define rLcdChr 20
#define LcdRows 4
#define interval 1000
#define BackgroundLight 5 // Puerto 5 Retroiluminación LED
#define DelayTOPWROFF 500

// EEprom SpeicherzellenAdressen de Configuración
#define EEFadeSeconds  993

#define EEPINA 996
#define EEPINC 997
#define EEPINDD 998


SoftwareSerial mySerial(7, 6); // RX, TX
LiquidCrystal lcd(8, 13, 12, 11, 10, 9);


//variables
byte DisplayBankContent = 0;

//Serial Input Manejo
char TBuffer;
char Cbuffer[MaxInputBufferSize + 1];     //Código USB Input Buffer
de Cadena Sbuffer = "";                      /USB/String Input Buffer,
int value;                                /USB/Nummeric Input Buffer
de bytes Ccount = 0;                          //Number received Char
byte Inptype = 0;
boolean StrInput = false;
boolean NumberInput = false;
boolean DataInput = false;
boolean EnterInput = false;
byte MenueSelection = 0;

byte SelectedMsg = 0;

//EEPROM
int eeaddress;                 //EEPROM Dirección Pointer
byte EEPromBanks = 0;          //Used for Calculating the EEPROM Banks
//SerMnueControl
byte MnuState = 0;            // Máximo Menuetiefe 255 icl Sub
byte Selectedbank = 0;

//Real Time Clock
long previousMillis = 0;       // quiere store last time lo measured
long previousMillisB = 0;       // quiero store last time lo measured

//Display Gestión
boolean DisplayLock = false;
boolean Directprint = false;
boolean EchoMode = true;
byte DirectprintROW = 0;
byte DirectprintLine = 0;

boolean RefreshDisplay = false;
byte FRMCheck = 0; // Used fpr Writing to Operations eeprom para save Amos cycles


// PWM de control de Iluminación

byte Currentbrightness = 0;
byte Targetbrightness = 0;
byte FadeSeconds = 0; // Predeterminado = 3



void setup()
{   EEPromBanks = EEpromSize / ((rLcdChr) * LcdRows);   lcd.begin(rLcdChr, LcdRows);   lcd.clear();   lcd.setCursor(0, 0);   lcd.print(" Bluetooth");   lcd.setCursor(0, 1);   lcd.print(" Display");   mySerial.begin(9600);   pinMode(BackgroundLight, OUTPUT); // Iluminación de pantalla / Pantalla /DE   digitalWrite(BackgroundLight, LOW);   // read Config   FadeSeconds = 0;   Currentbrightness = 0;   Targetbrightness = 0;   lcd.setCursor(0, 4);   if (DisplayLock) {     lcd.de impresión(" Sistema de gesperrt");   }   // Más Rutinas de Instalación / initalizing   lcd.setCursor(0, 0);   Targetbrightness = 255;   mySerial.ras();
}



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

void loop()

{   SerialcommandProcessor();   runrealTimeClock();   Displayprocessor();   //Fin del bucle Principal
}

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


void TextHeader(byte rowm)
{   mySerial.println("Texto para el Banco " + Cadena de( Selectedbank) + " FILA " + de la Cadena de (rowm) + ":");
}

vacío SerialcommandProcessor()
{   int un;   Inptype = 0;   Inptype = SerInputHandler();   // 0 keine Rückgabe   // 1 Nummer   // 2 Cadena   // 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;     }     // Borrando TODO el Contenido de la EEprom     si ((Sbuffer == "E") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 4;     }     si ((Sbuffer == "SÍ") && (MnuState == 1) && (Inptype == 2))      {       MenueSelection = 5;     }     si ((Sbuffer != "SÍ") && (MnuState == 1) && (Inptype == 2))     {       MenueSelection = 6;     }     //Editar el 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 el Contenido Seleccionado     si ((Sbuffer == "P") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 11;     }     si ((MnuState == 5) && (Inptype == 1))                           {       MenueSelection = 12;     }     si ((Sbuffer == "R") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 13;     }     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 ((Sbuffer == "B") && (MnuState == 0) && (Inptype == 2))       {       MenueSelection = 17;     }     si ((MnuState == 7) && (Inptype == 1))                           {       MenueSelection = 18;     }     si ((Sbuffer == "FADE") && (MnuState == 0) && (Inptype == 2))     {       MenueSelection = 19;     }     si (MnuState == 9)                                               {       MenueSelection = 20;     }     si (MnuState == 10)                                              {       MenueSelection = 21;     }     si (MnuState == 12)                                              {       MenueSelection = 25;     }     si (MnuState == 13)                                              {       MenueSelection = 27;     }     si (MnuState == 14)                                              {       MenueSelection = 29;     }     interruptor (MenueSelection)     {       caso 3:         {           mySerial.println("Leer EEEPROM Contenido:" );           mySerial.a ras();           de (int un = 0; un < EEPromBanks; un++)           {             mySerial.println("Memoria EEPROM del Banco: " + Cadena de(un) );             mySerial.a ras();             de (int b = 1; b <= LcdRows; b++)             {               mySerial.de impresión("de la Fila " + Cadena(b) + ": ");               mySerial.a ras();               de (int c = 0; c < rLcdChr; c++)               {                 eeaddress = 0;                 eeaddress = (un * (rLcdChr) * LcdRows) + ((rLcdChr) * b) + c;                 valor = de la EEPROM.de lectura(eeaddress);                 mySerial.de impresión(char(valor));                 mySerial.ras();               }               mySerial.println(" ");               mySerial.ras();             }           }           Sbuffer = "";           mySerial.println("No más EEPROM Bancos disponibles.");           mySerial.ras();           romper;         }       caso 4:         {           el valor = 0;           mySerial.impresión(de"Borrar EEPROM ");           mySerial.println("SÍ/NO:");           mySerial.ras();           MnuState = 1;           Sbuffer = "";           romper;         }       caso 5:         {           el valor = 0;           mySerial.impresión(de"Borrar EEPROM ");           mySerial.println("Stand by".);           mySerial.a ras();           de (int un = 0; un < EEPromBanks; un++)           {             //Banco de la Memoria de un             mySerial.println("Clara Banco: " + La cadena de(una));             de (int b = 1; b <= LcdRows; b++)             {               para (int c = 0; c < rLcdChr; c++)               {                 eeaddress = 0;                 eeaddress = (un * (rLcdChr) * LcdRows) + ((rLcdChr ) * b) + c;                 FRMCheck = EEPROM.de lectura(eeaddress);                 si (FRMCheck > 0)                 {                   EEPROM.escribir(eeaddress, 00); // Formatierung                   mySerial.imprimir(".");                   el valor++;                   de retardo(30);                   mySerial.ras();                 }               }             }             mySerial.println("");             mySerial.ras();           }           mySerial.println("");           mySerial.println("Terminado. " + Cadena de(valor) + " Bytes desactivada");           mySerial.println("");           mySerial.ras();           Sbuffer = "";           MnuState = 0;           romper;         }       caso 6:         {           el valor = 0;           Sbuffer = "";           MnuState = 0;           mySerial.println("OP abortar.");           mySerial.ras();           romper;         }       caso 7:         {           mySerial.println("EEPPROM Número de Banco (0-" + Cadena de(EEPromBanks - 1) + "):");           mySerial.ras();           MnuState = 2;           valor = 0;           Sbuffer = "";           romper;         }       caso 8:         {           Selectedbank = valor;           TextHeader(1);           MnuState = 3;           Sbuffer = "";           valor de = 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.ras();           valor = 0;           MnuState = 9;           Sbuffer = "";           romper;         }       caso 11:         {           el valor = 0;           mySerial.println("EEPPROM Número de Banco (0-" + Cadena de(EEPromBanks - 1) + "):");           MnuState = 5;           Sbuffer = "";           mySerial.ras();           romper;         }       caso 12:         {           SelectedMsg = valor;           DisplayBank(valor de);           romper;         }       caso 13:         {           el valor = 0;           mySerial.println("EEPPROM Número de Banco (0-" + Cadena de(EEPromBanks - 1) + "):");           MnuState = 6;           Sbuffer = "";           mySerial.ras();           romper;         }       caso 14:         {           un = valor;           si ( un < EEPromBanks)           {             mySerial.println("Banco de Memoria: " + Cadena de(un) );             mySerial.a ras();             de (int b = 1; b <= LcdRows; b++)             {               mySerial.de impresión("de la Fila " + Cadena(b) + ": ");               mySerial.a ras();               de (int c = 0; c < rLcdChr; c++)               {                 eeaddress = 0;                 eeaddress = (un * (rLcdChr) * LcdRows) + ((rLcdChr) * b) + c;                 valor = de la EEPROM.de lectura(eeaddress);                 mySerial.de impresión(char(valor));                 mySerial.ras();               }               mySerial.println(" ");               mySerial.ras();             }           } más           {             mySerial.println("Valor fuera de Rango.");           }           valor = 0;           Sbuffer = "";           MnuState = 0;           romper;         }       caso 15:         {           // Directa pPrint para Mostrar           Directprint = verdadero;           mySerial.println ("Directprint EN.");           si (Directprint)           {             DirectprintROW = 0;             DirectprintLine = 0;             lcd.clear();             lcd.cursor de la();             pantalla lcd.parpadea();           }           el valor = 0;           Sbuffer = "";           MnuState = 0;           romper;         }       caso 16:         {           el valor = 0;           Sbuffer = "";           MnuState = 0;           romper;         }       caso 17:         {           mySerial.println("Brillo de Pantalla: (máximo 255)");           MnuState = 7;           valor = 0;           Sbuffer = "";           romper;         }       caso 18:         {           si ((el valor < 256))           {             Targetbrightness = valor;             mySerial.println("Brillo: " + Cadena de (Targetbrightness) + " Set");           } más           {             mySerial.println("Valor fuera de Rango.");           }           MnuState = 0;           valor = 0;           Sbuffer = "";           romper;         }       caso 19:         {           mySerial.println("Fade Retraso: (máximo 255 Seg.)");           MnuState = 12;           valor = 0;           Sbuffer = "";           romper;         }       caso 20:         {           WriteEEPROM(Selectedbank, 3);           valor = 0;           MnuState = 0;           Sbuffer = "";           TextHeader(4);           mySerial.ras();           valor = 0;           MnuState = 10;           Sbuffer = "";           romper;         }       caso 21:         {           WriteEEPROM(Selectedbank, 4);           valor = 0;           MnuState = 0;           Sbuffer = "";           romper;         }       caso 25:         {           si ((el valor > 0) & (valor < 251))           {             FadeSeconds = valor;             de la EEPROM.escribir(EEFadeSeconds, FadeSeconds);             mySerial.println("Valor " + Cadena de (valor) + " conjunto".);           } otra cosa           {             de valor = 0;             Sbuffer = "";             mySerial.println("Valor fuera de Rango.");           }           valor = 0;           MnuState = 0;           Sbuffer = "";           romper;         }       defecto:         {           mySerial.println("-------Smart Bluetooth de la Pantalla 1.1------");           mySerial.println("S - Lea TODAS las EEPROM Bancos");           mySerial.println(("E - Borrar TODA la memoria EEPROM de los Bancos");           mySerial.println("W - Escritura sel. EEPROM Banco");           mySerial.println("R - Leer sel. EEPROM Banco");           mySerial.println("P - Impresión EEPROM Banco en la Pantalla");           mySerial.println("----------------------------------------");           mySerial.println("D - Impresión Directa");           mySerial.println("B - Brillo de la Pantalla Actual Valor: " + Cadena de (Currentbrightness));           mySerial.println("----------------------------------------");           mySerial.println("Escriba Cmd y pulse Enter");           mySerial.ras();           MnuState = 0;           valor = 0;           Sbuffer = "";         }     }   } // Eingabe erkannt
}



vacío WriteEEPROM(byte FBank, byte FRow)
{   byte Writecounter;   Writecounter = 0;   mySerial.de impresión("Guardar ");   para (int c = 0; c < rLcdChr; c++)   {     eeaddress = 0;     eeaddress = (FBank * (rLcdChr) * LcdRows) + ((rLcdChr) * FRow) + c;     valor = de la EEPROM.de lectura(eeaddress);     si (Sbuffer[c] != valor)     {       de la EEPROM.escribir(eeaddress, Sbuffer[c]);       mySerial.de impresión(".");       Writecounter++;     }   }   mySerial.println(" " + Cadena (Writecounter) + " de Bytes escritos.");

}

void ClearCBuffer ()

{   para (el byte de 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))    //los Números sólo     {       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 benötigt.       si (Uenta == 1) {         valor  = Cbuffer[0] - 48 ;       }       si (Uenta == 2) {         un = Cbuffer[0] - 48 ;         un = un * 10;         b = Cbuffer[1] - 48 ;         valor de = una + b;       }       si (Uenta == 3) {         un = Cbuffer[0] - 48 ;         un = un * 100;         b = Cbuffer[1] - 48 ;         b = b * 10;         c = Cbuffer[2] - 48 ;         valor de = un + b + c;       }       si (Uenta == 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 de = un + b + c + d;       }       si (Uenta >= 5)       {         Sbuffer = "";         valor = 0;         Sbuffer = Cbuffer;         ClearCBuffer;         resultado = 2;       } más       {         ClearCBuffer;         Uenta = 0;         de resultados = 1;                                                //Número de Returncode         NumberInput = falso;         StrInput = falso;         DataInput = falso;         EnterInput = falso;         Uenta = 0;         volver resultado;       }     }     si ((StrInput) y no (DataInput))                          //Cadena de Entrada sólo     {       Sbuffer = "";       Sbuffer = Cbuffer;       valor = 0;       StrInput = falso;       NumberInput = falso;       DataInput = falso;       EnterInput = falso;       Uenta = 0;       ClearCBuffer;       resultado = 2;                                                 //Número de Returncode     }     si (DataInput) {       Sbuffer = "";       Sbuffer = Cbuffer;       valor = 0;       StrInput = falso;       NumberInput = falso;       DataInput = falso;       EnterInput = falso;       Uenta = 0;       ClearCBuffer;       resultado = 3;                                               //Número Returncode     }     si ((EnterInput) y no (StrInput) y no (NumberInput) y no (DataInput))     {       Sbuffer = "";       valor = 0;       Uenta = 0;       ClearCBuffer;       resultado = 4;                                               //Número de Returncode     }     NumberInput = falso;     StrInput = falso;     DataInput = falso;     EnterInput = falso;     Uenta = 0;     volver resultado;   }   de devolución de resultados;   //Fin CheckforSerialEvent
}

// Eingabebuffer
booleano CheckforserialEvent()
{   mientras (mySerial.disponible()) {     // obtener el byte nuevo:     TBuffer = mySerial.leer();     si (TBuffer > 9 && TBuffer < 14)     {       Cbuffer[Uenta] = 0;       TBuffer = 0;       si (EchoMode)       {         mySerial.de impresión(char(13));         mySerial.ras();       }       si (Directprint)       {         mySerial.println("");         DirectprintLine = 0;         DirectprintROW = DirectprintROW + 1;         si ( DirectprintROW > 3)         {           Directprint = falso;           lcd.noCursor();           lcd.noBlink();           Sbuffer = "";           valor de = 0;         } más         {           de lcd.cursor de la();           pantalla lcd.parpadea();           lcd.setCursor(0, DirectprintROW);         }       }       EnterInput = true;       return true;     } else si (TBuffer > 47 && TBuffer < 58 )     {       si ( Uenta < MaxInputBufferSize)       {         Cbuffer[Uenta] = TBuffer;         Uenta++;         si ((Directprint))         {           lcd.de impresión(char(TBuffer));           DirectprintLine = DirectprintLine + 1;           si ( Uenta > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } demás {             lcd.cursor de la();             pantalla lcd.parpadea();           }         }         si (EchoMode) {           mySerial.de impresión(char(TBuffer));           mySerial.ras();         }       } más {         mySerial.de impresión("#");       }       //Ingresar el número de detectado       NumberInput = cierto;     }     otra cosa si (TBuffer > 64 && TBuffer < 123 )     {       si ( Uenta < MaxInputBufferSize)       {         Cbuffer[Uenta] = TBuffer;         Uenta++;         si ((Directprint))         {           lcd.de impresión(char(TBuffer));           DirectprintLine = DirectprintLine + 1;           si ( Uenta > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } demás {             lcd.cursor de la();             pantalla lcd.parpadea();           }         }         si (EchoMode) {           mySerial.de impresión(char(TBuffer));           mySerial.ras();         }       } más {         mySerial.de impresión("#");       }       StrInput = cierto;     }     otra cosa si ( (TBuffer == 127 )  |  (TBuffer == 8 ) )     {       si ( DirectprintLine > 0 )       {         DirectprintLine = DirectprintLine - 1;         lcd.setCursor(DirectprintLine, DirectprintROW);         lcd.de impresión(" ");         lcd.setCursor(DirectprintLine, DirectprintROW);       }       si (( DirectprintLine == 0 ) & ( DirectprintROW > 0 ))       {         DirectprintROW = DirectprintROW - 1;         DirectprintLine = rLcdChr - 1;         lcd.setCursor(DirectprintLine, DirectprintROW);       }       si ( Uenta > 0)       {         Uenta--;         Cbuffer[Uenta] = 0;         si ((Directprint))         {           si ( Uenta > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } demás {             lcd.cursor de la();             pantalla lcd.parpadea();           }         }         si (EchoMode) {           mySerial.de impresión("-");           mySerial.ras();         }       }     }     más     {       si ( Uenta < MaxInputBufferSize)       {         Cbuffer[Uenta] = TBuffer;         Uenta++;         si ((Directprint))         {           DirectprintLine = DirectprintLine + 1;           si (TBuffer < 128) {             lcd.de impresión(char(TBuffer));           } otro  {             lcd.de impresión(de la Cadena de(TBuffer));           }           si ( Uenta > MaxInputBufferSize - 1)           {             lcd.noCursor();             lcd.noBlink();           } demás {             lcd.cursor de la();             pantalla lcd.parpadea();           }         }         si (EchoMode) {           mySerial.de impresión(char(TBuffer));           mySerial.ras();         }       } más {         mySerial.de impresión("#");       }       //Entrada de Datos detectados       DataInput = true;     }     return false;   }   return false;
}

vacío Displayprocessor()  // Bei Blauem Pantalla wird auf Scrollfunktion verzichtet, da das nur "schmiert"
{   si (RefreshDisplay)   {     lcd.clara();     RefreshDisplay = falsa;     para (int b = 1; b <= LcdRows; b++)     {       lcd.setCursor(0, b - 1);       para (int c = 0; c < rLcdChr; c++)       {         eeaddress = 0;         eeaddress = (DisplayBankContent * (rLcdChr) * LcdRows) + ((rLcdChr) * b) + c;         valor = 0;         valor = de la EEPROM.de lectura(eeaddress);         si (el valor de > 31) // Sonderzeichen nicht anzeigen         {           mySerial.de impresión(char(valor de));           lcd.de impresión(char(valor de));         } más         {           de lcd.de impresión(char(32));         }       }       mySerial.println();     }   }
}

vacío runrealTimeClock()    //TIEMPO
{   // Reloj de Tiempo Real & la cuenta atrás   // largo previousMillis = 0; // almacenará la última vez que se midió   // byte SecDivider = 0;   unsigned long currentMillis = millis();   int StepValue = 0;   // PWM Pantalla Steuerung   StepValue = 4 * FadeSeconds;   si (currentMillis - previousMillis > StepValue)   {     previousMillis = currentMillis;     si (Currentbrightness < Targetbrightness        )     {       Currentbrightness = Currentbrightness + 1;       analogWrite (BackgroundLight, Currentbrightness);     } más si (Currentbrightness > Targetbrightness)     {       Currentbrightness = Currentbrightness - 1;       analogWrite (BackgroundLight, Currentbrightness);     }   }   si (currentMillis - previousMillisB > 1000)   {     // sekundentakt     previousMillisB = currentMillis;   }
}

vacío DisplayBank ( byte cobank)
{   si (cobank  < EEPromBanks )   {     RefreshDisplay = true;   // Iniciar la Salida de Pantalla de     DisplayBankContent = cobank;     mySerial.println("Banco " + de la Cadena de(cobank) + " se muestra en la pantalla LCD");     MnuState = 0;     Sbuffer = "";     valor = 0;     mySerial.ras();   } más   {     mySerial.println("Banco" no disponible".);     valor = 0;     MnuState = 0;     Sbuffer = "";     mySerial.ras();   }
}

 

Fertig ! Mehr ist nicht mehr notwendig.

Nach dieser kleinen Erweiterung bzw. Anpassung der Hardware steht uns monja der weitere Befehl "B" für Brillo en los dem Bluetooth Menü zur Verfügung.

  • B – el Brillo de la Pantalla Actual Valor: 255

Parte 3 - ajustar el Brillo mediante el Menú

Morir dahinter angegebene Zahl beschreibt morir aktuell eingestellte Displayhelligkeit en einem Wertebereich von 0 (Hintergrundbeleuchtung Aus) bis máxima de 255 (maximale Helligkeit)

Para ver wir immer auf einem Blick, welche Helligkeit gerade auf unserem Pantalla eingestellt ist.

Möchten wir monja morir Helligkeit der Hintergrundbeleuchtung ändern, así wählen wir den Punkt "B" (Brillo) aus und drücken Entrar. Wir werden dann kurz und knapp gefragt: el Brillo de la Pantalla: (máximo 255) und geben dahinter unseren gewünschten Wert ein.

de Ajuste de Brillo

Wir geben En diesem Beispiel 20 ela gewünschten Helligkeitswert ein)

Muere wird mit der Ausgabe: Brillo: 20 Set quittiert.Wir ver monja, wie das Pantalla sich auf den gewünschten Wert verdunkelt.

Für alle Interessierten, die das la Señal PWM, das unser Código zur Steuerung der Helligkeit generiert, ver möchten habe ich von meinem Oszilloskop einmal bei dem Wert 20 und bei dem Wert 200 Capturas de pantalla angefertigt:

Valor 20

Wert: 20

 

 

Valor: 200

Wert:200

 

Wie zu erkennen ist, unterscheidet sich das Puls-Pausen Verhältnis des Signales, während morir Frequenz gleich bleibt. Unser Auge mittelt dieses Verhältnis wieder zu einer gleichmäßigen Helligkeit.

Ich wünsche viel Spaß beim Nachbauen und wie immer bis zum su Mal.

MuestraPara arduinoProyectos para avanzados.

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