Bluetooth getoond - deel 3

Welkom bij het derde deel van de Bluetooth Display-serie. Vandaag, naast een verplichte extra operator menu item, ons scherm ontvangt een kleine uitbreiding van de hardware! Met deze nieuwe hardware-extensie kan de achtergrondhelderheid van ons scherm worden geregeld en geconfigureerd door software!

Hiervoor gebruiken we de poort 5 van onze Uno's als pulsbreedte modulatieoutput. Deze uitvoer regelt vervolgens een IRF520 driver module. Deze module, die ook wordt gebruikt voor bijvoorbeeld het besturen van motoren, gebruiken we om de grondverbinding van de ingebouwde leds van het display te regelen. (De IRF520 schakelt over naar de grond)

Op deze manier u de helderheid van ons scherm in 255 niveaus regelen. Daarnaast is het ook handig vanaf onze Bluetooth-terminal.

Maar nu naar de daadwerkelijke bouw en uitvoering van de uitbreiding. Als eerste stap breiden we onze hardware uit zoals weergegeven in het volgende schema IRF520 MOS Driver Module.

 

 

Circuit - Bluetooth Display Deel 3

In het circuit valt het eerste op dat de positieve input- en outputterminals van de IRF520 MOS Driver Modules zijn niet bezet. Dit is geen circuitfout, omdat deze terminals /aansluitingen van de module niet nodig zijn voor de werking van ons circuit, omdat we de positieve bedrijfsspanning voor de achtergrondverlichting van het display via de pre-stand direct via de 5 volt rail verkrijgen.

(Zelfs in de module zelf zijn de Terminals Vin en V+ alleen overbrugd en hebben ze geen actieve of passieve componenten tussen de twee terminals!)

Laat je daarom niet irriteren door de schakelmodus van de module, die enigszins afwijkt van de standaard.

Vervolgens uploaden we voor deze extensie de volgende aangepaste code naar onze Arduino UNO:

 

#include <Spi.H>
#include <Draad.H>
#include <SoftwareSerial.H>
#include <Eeprom.H>
#include <LiquidCrystal LiquidCrystal.H>
#include <Avr/Slaap.H>

#define MaxInputBufferSize 20 maximaal 255 tekens aan te passen aan vlcdr
#define EEpromSize EEpromSize 990

#define rLcdChr 20
#define LcdRows 4
#define Interval 1000
#define Achtergrondlicht 5 Poort 5 Backlight LED
#define DelayTOPWROFF 500

EEprom-geheugencelladdresses voor configuratie
#define EEfadeSeconden  993

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


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


Variabelen
Byte Inhoud van DisplayBank = 0;

Seriële invoerverwerking
Char TBuffer TBuffer;
Char Cbuffer[MaxInputBufferSize + 1];     USB-codeinvoerbuffer
Tekenreeks Sbuffer = "";                      USB-tekenreeksinvoerbuffer
Int Waarde;                                USB Nummeric-ingangsbuffer
Byte Ccount = 0;                          Aantal ontvangen Chars
Byte Inptype = 0;
Booleaanse StrInput StrInput = Valse;
Booleaanse NumberInput = Valse;
Booleaanse Gegevensinvoer = Valse;
Booleaanse EnterInput = Valse;
Byte MenueSelectie = 0;

Byte SelectedMsg = 0;

Eeprom
Int eeaddress;                 EEPROM-adresaanwijzer
Byte Eeprombanks Eeprombanks = 0;          Gebruikt voor de berekening van de EEPROM Banken
SerMnueControl SerMnueControl
Byte MnuState MnuState = 0;            Maximale menudiepte 255 icl Sub
Byte Selectedbank = 0;

Real-time klok
Lange previousMillis = 0;       zal opslaan laatste keer werd gemeten
Lange previousMillisB = 0;       zal opslaan laatste keer werd gemeten

Weergavebeheer
Booleaanse DisplayLock = Valse;
Booleaanse Directafdruk = Valse;
Booleaanse EchoMode = Waar;
Byte DirectprintROW = 0;
Byte DirectprintLine = 0;

Booleaanse RefreshDisplay = Valse;
Byte FRMCheck = 0; Gebruikte fpr Writing Operations om eeprom zo hosts cycli op te slaan


PWM Lichtbediening

Byte Huidige helderheid = 0;
Byte Doelhelderheid = 0;
Byte FadeSeconds = 0; Standaard = 3



Void Setup()
{   Eeprombanks Eeprombanks = EEpromSize EEpromSize / ((rLcdChr) * LcdRows);   Lcd.Beginnen(rLcdChr, LcdRows);   Lcd.Duidelijk();   Lcd.setCursor(0, 0);   Lcd.Afdrukken("Bluetooth");   Lcd.setCursor(0, 1);   Lcd.Afdrukken("Display");   mySerial.Beginnen(9600);   pinMode(Achtergrondlicht, Output); Displaybeleuchtung / Display AN /AUS   digitalWrite(Achtergrondlicht, Lage);   lees Config   FadeSeconds = 0;   Huidige helderheid = 0;   Doelhelderheid = 0;   Lcd.setCursor(0, 4);   Als (DisplayLock) {     Lcd.Afdrukken(" Systeem gesperrt");   }   Verdere setup routines / initalizing   Lcd.setCursor(0, 0);   Doelhelderheid = 255;   mySerial.Flush();
}



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

Void Lus()

{   SerialcommandProcessor();   runrealTimeClock();   Displayprocessor();   Hoofdlus beëindigen
}

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


Void TextHeader(Byte rowm rowm)
{   mySerial.println("Tekst voor Bank " + Tekenreeks( Selectedbank) + " RIJ " + Tekenreeks (rowm rowm) + ":");
}

Void SerialcommandProcessor()
{   Int A;   Inptype = 0;   Inptype = SerInputHandler();   0 keine Rückgabe   1 Nummer   2 Tekenreeks   3 Gegevens   Als ((Inptype > 0) & (!Directafdruk))   {     MenueSelectie = 0;     Als ((MnuState MnuState < 2) && (Inptype == 2)) {       Sbuffer.toUpperCase();  Voor eenvoudig invoeren opdrachten     }     Als ((Sbuffer == "S") && (MnuState MnuState == 0) && (Inptype == 2))       {       MenueSelectie = 3;     }     Alle EEprom-inhoud wissen     Als ((Sbuffer == "E") && (MnuState MnuState == 0) && (Inptype == 2))       {       MenueSelectie = 4;     }     Als ((Sbuffer == "JA") && (MnuState MnuState == 1) && (Inptype == 2))      {       MenueSelectie = 5;     }     Als ((Sbuffer != "JA") && (MnuState MnuState == 1) && (Inptype == 2))     {       MenueSelectie = 6;     }     Geselecteerde inhoud bewerken     Als ((Sbuffer == "W") && (MnuState MnuState == 0) && (Inptype == 2))       {       MenueSelectie = 7;     }     Als ((MnuState MnuState == 2) && (Waarde  < Eeprombanks Eeprombanks) && (Inptype == 1)) {       MenueSelectie = 8;     }     Als (MnuState MnuState == 3)                                               {       MenueSelectie = 9;     }     Als (MnuState MnuState == 4)                                               {       MenueSelectie = 10;     }     Geselecteerde inhoud weergeven     Als ((Sbuffer == "P") && (MnuState MnuState == 0) && (Inptype == 2))       {       MenueSelectie = 11;     }     Als ((MnuState MnuState == 5) && (Inptype == 1))                           {       MenueSelectie = 12;     }     Als ((Sbuffer == "R") && (MnuState MnuState == 0) && (Inptype == 2))       {       MenueSelectie = 13;     }     Als ((MnuState MnuState == 6) && (Inptype == 1))                           {       MenueSelectie = 14;     }     Als ((Sbuffer == "D") && (MnuState MnuState == 0) && (Inptype == 2))       {       MenueSelectie = 15;     }     Als ((Sbuffer == "Z") && (MnuState MnuState == 0) && (Inptype == 2))       {       MenueSelectie = 16;     }     Als ((Sbuffer == "B") && (MnuState MnuState == 0) && (Inptype == 2))       {       MenueSelectie = 17;     }     Als ((MnuState MnuState == 7) && (Inptype == 1))                           {       MenueSelectie = 18;     }     Als ((Sbuffer == "FADE") && (MnuState MnuState == 0) && (Inptype == 2))     {       MenueSelectie = 19;     }     Als (MnuState MnuState == 9)                                               {       MenueSelectie = 20;     }     Als (MnuState MnuState == 10)                                              {       MenueSelectie = 21;     }     Als (MnuState MnuState == 12)                                              {       MenueSelectie = 25;     }     Als (MnuState MnuState == 13)                                              {       MenueSelectie = 27;     }     Als (MnuState MnuState == 14)                                              {       MenueSelectie = 29;     }     Schakelen (MenueSelectie)     {       Geval 3:         {           mySerial.println("Lees EEEPROM Content:" );           mySerial.Flush();           Voor (Int A = 0; A < Eeprombanks Eeprombanks; A++)           {             mySerial.println("EEPROM Memory Bank: " + Tekenreeks(A) );             mySerial.Flush();             Voor (Int B = 1; B <= LcdRows; B++)             {               mySerial.Afdrukken("Rij " + Tekenreeks(B) + ": ");               mySerial.Flush();               Voor (Int C = 0; C < rLcdChr; C++)               {                 eeaddress = 0;                 eeaddress = (A * (rLcdChr) * LcdRows) + ((rLcdChr) * B) + C;                 Waarde = Eeprom.Lezen(eeaddress);                 mySerial.Afdrukken(Char(Waarde));                 mySerial.Flush();               }               mySerial.println(" ");               mySerial.Flush();             }           }           Sbuffer = "";           mySerial.println("Geen EEPROM Banks meer beschikbaar.");           mySerial.Flush();           Breken;         }       Geval 4:         {           Waarde = 0;           mySerial.Afdrukken("EEPROM wissen");           mySerial.println("JA/NEE:");           mySerial.Flush();           MnuState MnuState = 1;           Sbuffer = "";           Breken;         }       Geval 5:         {           Waarde = 0;           mySerial.Afdrukken("EEPROM wissen");           mySerial.println("Stand-by.");           mySerial.Flush();           Voor (Int A = 0; A < Eeprombanks Eeprombanks; A++)           {             Memory Bank a             mySerial.println("Duidelijke Bank: " + Tekenreeks(A));             Voor (Int B = 1; B <= LcdRows; B++)             {               Voor (Int C = 0; C < rLcdChr; C++)               {                 eeaddress = 0;                 eeaddress = (A * (rLcdChr) * LcdRows) + ((rLcdChr ) * B) + C;                 FRMCheck = Eeprom.Lezen(eeaddress);                 Als (FRMCheck > 0)                 {                   Eeprom.Schrijven(eeaddress, 00); Formatierung                   mySerial.Afdrukken(".");                   Waarde++;                   Vertraging(30);                   mySerial.Flush();                 }               }             }             mySerial.println("");             mySerial.Flush();           }           mySerial.println("");           mySerial.println('Klaar'. + Tekenreeks(Waarde) + " Bytes gewist");           mySerial.println("");           mySerial.Flush();           Sbuffer = "";           MnuState MnuState = 0;           Breken;         }       Geval 6:         {           Waarde = 0;           Sbuffer = "";           MnuState MnuState = 0;           mySerial.println("OP afbreken.");           mySerial.Flush();           Breken;         }       Geval 7:         {           mySerial.println("EEPPROM Bank Nummer (0-" + Tekenreeks(Eeprombanks Eeprombanks - 1) + "):");           mySerial.Flush();           MnuState MnuState = 2;           Waarde = 0;           Sbuffer = "";           Breken;         }       Geval 8:         {           Selectedbank = Waarde;           TextHeader(1);           MnuState MnuState = 3;           Sbuffer = "";           Waarde = 0;           Breken;         }       Geval 9:         {           WriteEEPROM WriteEEPROM(Selectedbank, 1);           TextHeader(2);           Waarde = 0;           MnuState MnuState = 4;           Sbuffer = "";           Breken;         }       Geval 10:         {           WriteEEPROM WriteEEPROM(Selectedbank, 2);           Waarde = 0;           MnuState MnuState = 0;           Sbuffer = "";           TextHeader(3);           mySerial.Flush();           Waarde = 0;           MnuState MnuState = 9;           Sbuffer = "";           Breken;         }       Geval 11:         {           Waarde = 0;           mySerial.println("EEPPROM Bank Nummer (0-" + Tekenreeks(Eeprombanks Eeprombanks - 1) + "):");           MnuState MnuState = 5;           Sbuffer = "";           mySerial.Flush();           Breken;         }       Geval 12:         {           SelectedMsg = Waarde;           DisplayBank(Waarde);           Breken;         }       Geval 13:         {           Waarde = 0;           mySerial.println("EEPPROM Bank Nummer (0-" + Tekenreeks(Eeprombanks Eeprombanks - 1) + "):");           MnuState MnuState = 6;           Sbuffer = "";           mySerial.Flush();           Breken;         }       Geval 14:         {           A = Waarde;           Als ( A < Eeprombanks Eeprombanks)           {             mySerial.println("Geheugenbank: " + Tekenreeks(A) );             mySerial.Flush();             Voor (Int B = 1; B <= LcdRows; B++)             {               mySerial.Afdrukken("Rij " + Tekenreeks(B) + ": ");               mySerial.Flush();               Voor (Int C = 0; C < rLcdChr; C++)               {                 eeaddress = 0;                 eeaddress = (A * (rLcdChr) * LcdRows) + ((rLcdChr) * B) + C;                 Waarde = Eeprom.Lezen(eeaddress);                 mySerial.Afdrukken(Char(Waarde));                 mySerial.Flush();               }               mySerial.println(" ");               mySerial.Flush();             }           } Anders           {             mySerial.println("Waarde buiten bereik.");           }           Waarde = 0;           Sbuffer = "";           MnuState MnuState = 0;           Breken;         }       Geval 15:         {           Direct pAfdrukken naar weergave           Directafdruk = Waar;           mySerial.println ("Directprint ON.");           Als (Directafdruk)           {             DirectprintROW = 0;             DirectprintLine = 0;             Lcd.Duidelijk();             Lcd.Cursor();             Lcd.Knipperen();           }           Waarde = 0;           Sbuffer = "";           MnuState MnuState = 0;           Breken;         }       Geval 16:         {           Waarde = 0;           Sbuffer = "";           MnuState MnuState = 0;           Breken;         }       Geval 17:         {           mySerial.println("Helderheid van het scherm: (max 255)");           MnuState MnuState = 7;           Waarde = 0;           Sbuffer = "";           Breken;         }       Geval 18:         {           Als ((Waarde < 256))           {             Doelhelderheid = Waarde;             mySerial.println("Helderheid: " + Tekenreeks (Doelhelderheid) + " Set");           } Anders           {             mySerial.println("Waarde buiten bereik.");           }           MnuState MnuState = 0;           Waarde = 0;           Sbuffer = "";           Breken;         }       Geval 19:         {           mySerial.println("Fade Delay: (max 255 Sec)");           MnuState MnuState = 12;           Waarde = 0;           Sbuffer = "";           Breken;         }       Geval 20:         {           WriteEEPROM WriteEEPROM(Selectedbank, 3);           Waarde = 0;           MnuState MnuState = 0;           Sbuffer = "";           TextHeader(4);           mySerial.Flush();           Waarde = 0;           MnuState MnuState = 10;           Sbuffer = "";           Breken;         }       Geval 21:         {           WriteEEPROM WriteEEPROM(Selectedbank, 4);           Waarde = 0;           MnuState MnuState = 0;           Sbuffer = "";           Breken;         }       Geval 25:         {           Als ((Waarde > 0) & (Waarde < 251))           {             FadeSeconds = Waarde;             Eeprom.Schrijven(EEfadeSeconden, FadeSeconds);             mySerial.println("Waarde" + Tekenreeks (Waarde) + " set.");           } Anders           {             Waarde = 0;             Sbuffer = "";             mySerial.println("Waarde buiten bereik.");           }           Waarde = 0;           MnuState MnuState = 0;           Sbuffer = "";           Breken;         }       Standaard:         {           mySerial.println("-------Smart Bluetooth Display 1.1------");           mySerial.println("S - Lees alle EEPROM Banken");           mySerial.println("E - Wis alle EEPROM Banken");           mySerial.println("W - Schrijf sel. EEPROM Bank");           mySerial.println("R - Lees sel. EEPROM Bank");           mySerial.println("P - Print EEPROM Bank on Display");           mySerial.println("----------------------------------------");           mySerial.println("D - Direct Print");           mySerial.println("B - Huidige waarde van de helderheid van de weergave: " + Tekenreeks (Huidige helderheid));           mySerial.println("----------------------------------------");           mySerial.println("Typ Cmd en druk op Enter");           mySerial.Flush();           MnuState MnuState = 0;           Waarde = 0;           Sbuffer = "";         }     }   } Eingabe erkannt
}



Void WriteEEPROM WriteEEPROM(Byte FBank, Byte FRow FRow FRow)
{   Byte Schrijfteller;   Schrijfteller = 0;   mySerial.Afdrukken("Opslaan");   Voor (Int C = 0; C < rLcdChr; C++)   {     eeaddress = 0;     eeaddress = (FBank * (rLcdChr) * LcdRows) + ((rLcdChr) * FRow FRow FRow) + C;     Waarde = Eeprom.Lezen(eeaddress);     Als (Sbuffer[C] != Waarde)     {       Eeprom.Schrijven(eeaddress, Sbuffer[C]);       mySerial.Afdrukken(".");       Schrijfteller++;     }   }   mySerial.println(" " + Tekenreeks (Schrijfteller) + Bytes geschreven.);

}

Void ClearCBuffer ClearCBuffer ()

{   Voor (Byte A = 0; MaxInputBufferSize - 1; A++)     Cbuffer[A] = 0;
}

Byte SerInputHandler()
{   Byte Resultaat = 0;   Int C;   Int D;   Int A;   Int B;   Resultaat = 0;   Als (CheckforserialEvent())   {     Als ((NumberInput) En Niet (Gegevensinvoer) En Niet (StrInput StrInput))    Alleen getallen     {       Sbuffer = "";       Waarde = 0;       StrInput StrInput = Valse;       NumberInput = Valse;       Gegevensinvoer = Valse;       EnterInput = Valse;       A = 0;       B = 0;       C = 0;       D = 0;       Sbuffer = Cbuffer; Zahl wird AUCH ! in SBUFFER übernommen, valt benötigt.       Als (Ccount == 1) {         Waarde  = Cbuffer[0] - 48 ;       }       Als (Ccount == 2) {         A = Cbuffer[0] - 48 ;         A = A * 10;         B = Cbuffer[1] - 48 ;         Waarde = A + B;       }       Als (Ccount == 3) {         A = Cbuffer[0] - 48 ;         A = A * 100;         B = Cbuffer[1] - 48 ;         B = B * 10;         C = Cbuffer[2] - 48 ;         Waarde = A + B + C;       }       Als (Ccount == 4) {         A = Cbuffer[0] - 48 ;         A = A * 1000;         B = Cbuffer[1] - 48 ;         B = B * 100;         C = Cbuffer[2] - 48 ;         C = C * 10;         D = Cbuffer[3] - 48 ;         Waarde = A + B + C + D;       }       Als (Ccount >= 5)       {         Sbuffer = "";         Waarde = 0;         Sbuffer = Cbuffer;         ClearCBuffer ClearCBuffer;         Resultaat = 2;       } Anders       {         ClearCBuffer ClearCBuffer;         Ccount = 0;         Resultaat = 1;                                                Retourcode nummer         NumberInput = Valse;         StrInput StrInput = Valse;         Gegevensinvoer = Valse;         EnterInput = Valse;         Ccount = 0;         Terug Resultaat;       }     }     Als ((StrInput StrInput) En Niet (Gegevensinvoer))                          Alleen tekenreeksinvoer     {       Sbuffer = "";       Sbuffer = Cbuffer;       Waarde = 0;       StrInput StrInput = Valse;       NumberInput = Valse;       Gegevensinvoer = Valse;       EnterInput = Valse;       Ccount = 0;       ClearCBuffer ClearCBuffer;       Resultaat = 2;                                                 Retourcode nummer     }     Als (Gegevensinvoer) {       Sbuffer = "";       Sbuffer = Cbuffer;       Waarde = 0;       StrInput StrInput = Valse;       NumberInput = Valse;       Gegevensinvoer = Valse;       EnterInput = Valse;       Ccount = 0;       ClearCBuffer ClearCBuffer;       Resultaat = 3;                                               Retourcode nummer     }     Als ((EnterInput) En Niet (StrInput StrInput) En Niet (NumberInput) En Niet (Gegevensinvoer))     {       Sbuffer = "";       Waarde = 0;       Ccount = 0;       ClearCBuffer ClearCBuffer;       Resultaat = 4;                                               Retourcode nummer     }     NumberInput = Valse;     StrInput StrInput = Valse;     Gegevensinvoer = Valse;     EnterInput = Valse;     Ccount = 0;     Terug Resultaat;   }   Terug Resultaat;   CheckforSerialEvent beëindigen
}

Eingabebuffer
Booleaanse CheckforserialEvent()
{   Terwijl (mySerial.Beschikbaar()) {     krijgen de nieuwe byte:     TBuffer TBuffer = mySerial.Lezen();     Als (TBuffer TBuffer > 9 && TBuffer TBuffer < 14)     {       Cbuffer[Ccount] = 0;       TBuffer TBuffer = 0;       Als (EchoMode)       {         mySerial.Afdrukken(Char(13));         mySerial.Flush();       }       Als (Directafdruk)       {         mySerial.println("");         DirectprintLine = 0;         DirectprintROW = DirectprintROW + 1;         Als ( DirectprintROW > 3)         {           Directafdruk = Valse;           Lcd.noCursor();           Lcd.noBlink();           Sbuffer = "";           Waarde = 0;         } Anders         {           Lcd.Cursor();           Lcd.Knipperen();           Lcd.setCursor(0, DirectprintROW);         }       }       EnterInput = Waar;       Terug Waar;     } Anders Als (TBuffer TBuffer > 47 && TBuffer TBuffer < 58 )     {       Als ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer TBuffer;         Ccount++;         Als ((Directafdruk))         {           Lcd.Afdrukken(Char(TBuffer TBuffer));           DirectprintLine = DirectprintLine + 1;           Als ( Ccount > MaxInputBufferSize - 1)           {             Lcd.noCursor();             Lcd.noBlink();           } Anders {             Lcd.Cursor();             Lcd.Knipperen();           }         }         Als (EchoMode) {           mySerial.Afdrukken(Char(TBuffer TBuffer));           mySerial.Flush();         }       } Anders {         mySerial.Afdrukken("#");       }       Aantalinvoer gedetecteerd       NumberInput = Waar;     }     Anders Als (TBuffer TBuffer > 64 && TBuffer TBuffer < 123 )     {       Als ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer TBuffer;         Ccount++;         Als ((Directafdruk))         {           Lcd.Afdrukken(Char(TBuffer TBuffer));           DirectprintLine = DirectprintLine + 1;           Als ( Ccount > MaxInputBufferSize - 1)           {             Lcd.noCursor();             Lcd.noBlink();           } Anders {             Lcd.Cursor();             Lcd.Knipperen();           }         }         Als (EchoMode) {           mySerial.Afdrukken(Char(TBuffer TBuffer));           mySerial.Flush();         }       } Anders {         mySerial.Afdrukken("#");       }       StrInput StrInput = Waar;     }     Anders Als ( (TBuffer TBuffer == 127 )  |  (TBuffer TBuffer == 8 ) )     {       Als ( DirectprintLine > 0 )       {         DirectprintLine = DirectprintLine - 1;         Lcd.setCursor(DirectprintLine, DirectprintROW);         Lcd.Afdrukken(" ");         Lcd.setCursor(DirectprintLine, DirectprintROW);       }       Als (( DirectprintLine == 0 ) & ( DirectprintROW > 0 ))       {         DirectprintROW = DirectprintROW - 1;         DirectprintLine = rLcdChr - 1;         Lcd.setCursor(DirectprintLine, DirectprintROW);       }       Als ( Ccount > 0)       {         Ccount--;         Cbuffer[Ccount] = 0;         Als ((Directafdruk))         {           Als ( Ccount > MaxInputBufferSize - 1)           {             Lcd.noCursor();             Lcd.noBlink();           } Anders {             Lcd.Cursor();             Lcd.Knipperen();           }         }         Als (EchoMode) {           mySerial.Afdrukken("-");           mySerial.Flush();         }       }     }     Anders     {       Als ( Ccount < MaxInputBufferSize)       {         Cbuffer[Ccount] = TBuffer TBuffer;         Ccount++;         Als ((Directafdruk))         {           DirectprintLine = DirectprintLine + 1;           Als (TBuffer TBuffer < 128) {             Lcd.Afdrukken(Char(TBuffer TBuffer));           } Anders  {             Lcd.Afdrukken(Tekenreeks(TBuffer TBuffer));           }           Als ( Ccount > MaxInputBufferSize - 1)           {             Lcd.noCursor();             Lcd.noBlink();           } Anders {             Lcd.Cursor();             Lcd.Knipperen();           }         }         Als (EchoMode) {           mySerial.Afdrukken(Char(TBuffer TBuffer));           mySerial.Flush();         }       } Anders {         mySerial.Afdrukken("#");       }       Gegevensinvoer gedetecteerd       Gegevensinvoer = Waar;     }     Terug Valse;   }   Terug Valse;
}

Void Weergaveprocessor()  Bij blauw display wordt scrollen weggelaten, omdat dit alleen maar "smeert"
{   Als (RefreshDisplay)   {     Lcd.Duidelijk();     RefreshDisplay = Valse;     Voor (Int B = 1; B <= LcdRows; B++)     {       Lcd.setCursor(0, B - 1);       Voor (Int C = 0; C < rLcdChr; C++)       {         eeaddress = 0;         eeaddress = (Inhoud van DisplayBank * (rLcdChr) * LcdRows) + ((rLcdChr) * B) + C;         Waarde = 0;         Waarde = Eeprom.Lezen(eeaddress);         Als (Waarde > 31) Geen speciale personages tonen         {           mySerial.Afdrukken(Char(Waarde));           Lcd.Afdrukken(Char(Waarde));         } Anders         {           Lcd.Afdrukken(Char(32));         }       }       mySerial.println();     }   }
}

Void runrealTimeClock()    TIMEBASE
{   Real-time klok en countdown   lang vorigeMillis = 0;       zal opslaan laatste keer werd gemeten   byte SecDivider = 0;   Unsigned Lange currentMillis = millis();   Int StepValue = 0;   PWM-weergavebeheer   StepValue = 4 * FadeSeconds;   Als (currentMillis - previousMillis > StepValue)   {     previousMillis = currentMillis;     Als (Huidige helderheid < Doelhelderheid        )     {       Huidige helderheid = Huidige helderheid + 1;       analogSchrijven (Achtergrondlicht, Huidige helderheid);     } Anders Als (Huidige helderheid > Doelhelderheid)     {       Huidige helderheid = Huidige helderheid - 1;       analogSchrijven (Achtergrondlicht, Huidige helderheid);     }   }   Als (currentMillis - previousMillisB > 1000)   {     secondenlijn     previousMillisB = currentMillis;   }
}

Void DisplayBank ( Byte cobank)
{   Als (cobank  < Eeprombanks Eeprombanks )   {     RefreshDisplay = Waar;   Weergave-uitvoer initalize     Inhoud van DisplayBank = cobank;     mySerial.println("Bank" + Tekenreeks(cobank) + " wordt weergegeven op LCD");     MnuState MnuState = 0;     Sbuffer = "";     Waarde = 0;     mySerial.Flush();   } Anders   {     mySerial.println("Bank niet beschikbaar.");     Waarde = 0;     MnuState MnuState = 0;     Sbuffer = "";     mySerial.Flush();   }
}

 

Klaar! Meer is niet meer nodig.

Na deze kleine uitbreiding of aanpassing van de hardware, de verdere opdracht "B" voor Helderheid is nu beschikbaar voor ons in het Bluetooth-menu.

  • B - Huidige waarde van de helderheid weergeven: 255

Deel 3 - Helderheid aanpassen via het menu

Het aantal dat erachter wordt gegeven beschrijft de momenteel ingestelde helderheid van het scherm in een waardebereik van 0 (backlight off) tot een maximum van 255 (maximale helderheid)

Zo zien we altijd in één oogopslag welke helderheid er momenteel op ons scherm is ingesteld.

Als we nu de helderheid van de achtergrondverlichting willen wijzigen, selecteren we het punt 'B' (Helderheid) en drukken we op Enter. Vervolgens wordt ons kort gevraagd: Display Brightness: (max 255) en voer onze gewenste waarde erachter in.

De helderheid instellen

In dit voorbeeld voeren we 20 in als gewenste helderheidswaarde)

Dit wordt erkend met de uitvoer: Helderheid: 20 Set. We zien nu hoe het display donkerder wordt tot de gewenste waarde.

Voor al diegenen die geïnteresseerd willen zien de PWM signaal dat onze code genereert voor het regelen van de helderheid, nam ik screenshots van mijn oscilloscoop een keer op de waarde 20 en tegen de waarde 200:

Waarde 20

Waarde: 20

 

 

Waarde: 200

Waarde:200

 

Zoals te zien is, verschilt de puls-pauzeverhouding van het signaal, terwijl de frequentie hetzelfde blijft. Ons oog gemiddelden deze verhouding terug naar een gelijkmatige helderheid.

Ik wens u veel plezier wederopbouw en, zoals altijd, tot de volgende keer.

DisplaysFür arduinoProjekte für fortgeschrittene

Einen Kommentar hinterlassen

Alle Kommentare werden vor der Veröffentlichung moderiert

Aanbevolen blog berichten

  1. Installeer ESP32 nu van de raad van bestuur
  2. Lüftersteuerung Raspberry Pi
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1
  4. ESP32 - das Multitalent
  5. OTA - Over the Air - ESP Programmeren via Wi-Fi