Wörter LCD abwechselnd anzeigen lassen 2x Timer

Hi,
aus einem mir nicht erklärbarem Grund kann ich keine 2 timer gleichzeitig nutzen.

Wenn ich die timer (milli() etc.) gegen delay(500) tausche, dann funktioniert das zwar, aber der egt Wert wird natürlich nur alle 500ms aktualliesiert, das soll aber durchgehend der Fall sein.

Bitte seid nachsichtig mit meinen ganzen notizen die ich gemacht hab, ist für mich als gedankenstütze da es erstes Projekt ist und ich mich noch zurechtfinden möchte, sollte ich mal 2 Wochen nicht reingeschaut haben.

der Sketch schaut bis jetzt wie folgt aus:

const int led = (7);            //Warn LED an Pin 7 mit 220 Ohm Wiederstand anschließen
const long interval1 = 1000;
int previousMillis1 = 0;
int previousMillis2 = 0;
unsigned long currentMillis1 = millis();
unsigned long currentMillis2 = millis();    //Wird das überhaupt benötigt? Weil ist ja das gleiche wie currentMillis1


void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);             // Initieirt LCD
  lcd.createChar(0,grad);       // für das ° vor dem C
  
  pinMode(7, OUTPUT);           // Beschreibt pin 7 als Output-Pin


}

void loop() {
  digitalWrite(7,LOW);
  Serial.println(millis());
  lcd.print("Abgas-Temperatur");                            // lcd.print = Auf LCD anzeigen/ausgeben 
  int sensorValue = analogRead(A0);                         // int = Integra (ganze Zahl ohne Nachkommastelle), sensorValue = Name der Zahl, = analogRead(A0) = Wert der an Pin A0 eingelesen wird
  float voltage = sensorValue * (5.0 / 1023.0);             // Konvertiert das Eingangssignal von Pin A0 (0-1023) zu Spannung (Volt) 0-5V
  int egt = voltage * (1250 / 5);                           // Konvertiert das 0-5V Signal zur Ausgabe 0-1250°C
  lcd.setCursor(6, 1);                                      // lcd.setCursor(5,1) = Anfang an Feld 5, Zeile 2 (Zeile 1=0 Zeile 2=1)
  lcd.print(egt);
  lcd.setCursor(10, 1);
  lcd.write(byte(0));                                       // lcd.write(byte(0)) = Befehl um das byte (customChar °) auf LCD auszugeben
  lcd.setCursor(11, 1);
  lcd.print("C");
  delay(150);                                                // delay(150) = Verzögerung um 150ms damit das LCD nicht flackert
  lcd.clear();                                              // lcd.clear() = alles auf LCD ausgegebenes löschen
  
    

  if(egt >= 1000){
       {
      
      lcd.print("Abgas-Temperatur");
      lcd.print(egt);
      lcd.write(byte(0)); 
      lcd.print("C");
      digitalWrite(led, LOW);
             
        if (currentMillis1 - previousMillis1 >= interval1) {
        previousMillis1 = currentMillis2;}

      lcd.clear();
      delay(20);

      lcd.print("!!!!ACHTUNG!!!!");
      lcd.print(egt);
      lcd.write(byte(0));
      lcd.print("C");
      digitalWrite(led, HIGH);


       if (currentMillis2 - previousMillis1 >= interval1) {
        previousMillis1 = currentMillis1;}
        
      lcd.clear();
      delay(20);    
     }
  } 
}

Im englischen Teil des Forum müssen die Beiträge und Diskussionen in englischer Sprache verfasst werden. Deswegen wurde diese Diskussion in den deutschen Teil des Forums verschoben.

mfg ein Moderator.

Wieso mischt Du die beiden Teimer?
Wieso holst Du nie den Wert von millis in Deinem Sketch?
Mir scheint Du hast die Funktion von millis() noch nicht verstanden.

PS Es ist kein Problem 2 oder mehr Nachtwächter in die Nacht zu schicken. Man muß nur jedem Nachtwächter alle Werkzeuge geben die er braucht. So können alle Nachtwächter unabhängig voneinander arbeiten.

Grüße Uwe

Nein, es ist nicht nötig. Du könntest deine Vergleiche auch direkt mit dem Wert von millis() machen. CurrentMillis wird nur nötig, wenn den ganzen Loop lang ein gleichbleibender Vergleichswert benötigt wird.

Aber, du sollst nach Ablauf deines Intevals etwas tun. Im Moment aktualisierst du nur deine Variablen previousMillis.

Warum steht dort eine 7 und nicht die Vergebene Konstante aus der ersten Zeile?

Es reicht nicht dass du die Zeile mit delay() gegen das currentMillis-previousMillis tauscht.
du musst da schon im if dann die jeweiligen Funktionsaufrufe machen.

Außerdem brauchst du meiner Meinung nicht "zwei Timer" sondern eh nur einen. EinTimer schaltet um zwischen Anzeige 1 und Anzeige 2. Genauso wie ein Timer das Blinken macht, es ist ein oder aus.

Außerdem ist dein Code nicht vollständig, da fehlen die Includes für LCD, der LCD Konstruktor und die Defintion von deinem Grad Zeichen, daher kann ich das nicht kompilieren.

Kann man sich aber auch sparen, wenn man meine LCD Library verwendet.
https://werner.rothschopf.net/202003_arduino_liquid_crystal_umlaute.htm

edit:

const int led = 7;                     // Warn LED an Pin 7 mit 220 Ohm Wiederstand anschließen
const uint32_t interval1 = 1000;       // Blinkinterval der Warnung
const uint32_t interval2 = 500;        // Messinterval
uint32_t previousMillis1;              // für die Ausgabe
uint32_t previousMillis2;              // für die Messung

uint8_t anzeige = 0;                   // 0 normal, 1 "blinkende Warnung", 2 "blinkende Warnung anderer text"
int egt;                               // gewandelter Wert zur Ausgabe
int previousEgt = -1;                  // merkt sich den letzten ausgegeben Wert, vermeidet "flicker"

//fehlte:
#include <Wire.h>                      // needed for the I2C interface
#include <NoiascaLiquidCrystal.h>      // download library from https://werner.rothschopf.net/202009_arduino_liquid_crystal_intro.htm 
#include <NoiascaHW/lcd_PCF8574.h>     // include the proper IO interface
const byte cols = 16;                  // columns/characters per row
const byte rows = 2;                   // how many rows
const byte addr = 0x3F;                // set the LCD address to 0x3F or 0x27
LiquidCrystal_PCF8574 lcd(Wire, addr, cols, rows);               // create lcd object - with support of special characters

void ausgabeDefault()
{
  lcd.clear(); // lcd.clear() = alles auf LCD ausgegebenes löschen
  lcd.print(F("Abgas-Temperatur"));    // lcd.print = Auf LCD anzeigen/ausgeben
  lcd.setCursor(6, 1);                 // lcd.setCursor(5,1) = Anfang an Feld 5, Zeile 2 (Zeile 1=0 Zeile 2=1)
  lcd.print(egt);
  lcd.setCursor(10, 1);
  //lcd.write(byte(0));                // lcd.write(byte(0)) = Befehl um das byte (customChar °) auf LCD auszugeben
  //lcd.setCursor(11, 1);
  lcd.print("°C");                     // die Noiasca Liquid Crystal kann das ;-)
  digitalWrite(led, LOW);
  previousEgt = egt;
}

void ausgabeWarnungTimer()
{
  uint32_t currentMillis = millis();
  if (currentMillis - previousMillis1 >= interval1 && previousEgt != egt)
  {
    previousMillis1 = currentMillis;
    previousEgt = egt;
    if (anzeige == 1)
    {
      lcd.clear();
      lcd.print(F("!!ACHTUNG!!"));
      lcd.print(egt);
      lcd.write(byte(0));
      lcd.print("C");
      digitalWrite(led, HIGH);
      anzeige = 2; // fürs nächste Mal
    }
    else
    {
      // die alternierende Anzeige im Warn-Modus
      lcd.clear();
      lcd.print(F("++ACHTUNG++"));
      lcd.print(egt);
      lcd.write(byte(0));
      lcd.print("C");
      digitalWrite(led, LOW);
      anzeige = 1; // fürs nächste Mal
    }
  }
}

void messungTimer()
{
  uint32_t currentMillis = millis();
  if (currentMillis - previousMillis2 >= interval2)
  {
    previousMillis2 = currentMillis;
    int sensorValue = analogRead(A0);                  // int = Integra (ganze Zahl ohne Nachkommastelle), sensorValue = Name der Zahl, = analogRead(A0) = Wert der an Pin A0 eingelesen wird
    float voltage = sensorValue * (5.0 / 1023.0);      // Konvertiert das Eingangssignal von Pin A0 (0-1023) zu Spannung (Volt) 0-5V
    egt = voltage * (1250 / 5);                        // Konvertiert das 0-5V Signal zur Ausgabe 0-1250°C
    Serial.println(egt);
  }
}

void setup() {
  Serial.begin(9600);
  Wire.begin();                        // start I2C library
  lcd.init();  //lcd.begin(16, 2);     // Initieirt LCD
  lcd.backlight();
  //lcd.createChar(0, grad);           // für das ° vor dem C
  pinMode(led, OUTPUT);                // Beschreibt pin 7 als Output-Pin
  lcd.print(F("START"));
}

void loop() {
  // Messen
  messungTimer();

  // Ausgeben
  if (egt >= 1000)
  {
    ausgabeWarnungTimer();   // den Timer triggern der die Ausgabe Warnung umschaltet
  }
  else
  {
    if (previousEgt != egt)  //flicker vermeiden und nur ausgeben, wenn anders
    {
      ausgabeDefault();
    }
  }
}

Anmerkung: ich habe mich entschieden einen Timer für die Messung zu machen, das verhindert auch den Flicker wenn sich die Werte nur wenig ändern.

Das wird nix.
Der Gültigkeitsbereich Deiner Variablen reicht nicht aus, um den Gültigkeitsbereich von millis() abzudecken.
Du wirst regelmäßig einen Überlauf erleben und damit ganz eigenartige Effekte.

Auch hast Du zweimal das lcd.print(egt) drin - einmal vor und einmal nach if egt >= 1000.
Und irgendwie fehlt am Anfang was in Deinem Code. Denn das lcd ist nicht existent.

Ich hab mal alles aus Deinem Code übernommen, was da war.
Du musst nur noch Dein custom Char und das lcd wieder reinbringen, dann sollte das gehen.

const int led = 7;            //Warn LED an Pin 7 mit 220 Ohm Wiederstand anschließen
float voltage;
unsigned int egt;

void setup()
{
  Serial.begin(9600);
  lcd.begin(16, 2);             // Initieirt LCD
  lcd.createChar(0, grad);      // für das ° vor dem C
  pinMode(led, OUTPUT);           // Beschreibt pin 7 als Output-Pin
}

void getSensors()
{
  unsigned int sensorValue = analogRead(A0);                         // int = Integra (ganze Zahl ohne Nachkommastelle), sensorValue = Name der Zahl, = analogRead(A0) = Wert der an Pin A0 eingelesen wird
  voltage = sensorValue * (5.0 / 1023.0);             // Konvertiert das Eingangssignal von Pin A0 (0-1023) zu Spannung (Volt) 0-5V
  egt = voltage * (1250 / 5);                           // Konvertiert das 0-5V Signal zur Ausgabe 0-1250°C
}

void printLcd(const uint32_t repeatTime)
{
  static uint32_t lastmillis = 0;
  if (millis() - lastmillis > repeatTime)
  {
    lastmillis = millis();
    if (egt >= 1000)
    {
      lcd.print(F("!!!!ACHTUNG!!!!"));
      digitalWrite(led, HIGH);
    }
    else
    {
      lcd.print(F("Abgas-Temperatur"));                             // lcd.print = Auf LCD anzeigen/ausgeben
      digitalWrite(led, LOW);
    }
    lcd.setCursor(6, 1);                                      // lcd.setCursor(5,1) = Anfang an Feld 5, Zeile 2 (Zeile 1=0 Zeile 2=1)
    lcd.print(egt);
    lcd.setCursor(10, 1);
    lcd.write(byte(0));                                       // lcd.write(byte(0)) = Befehl um das byte (customChar °) auf LCD auszugeben
    lcd.setCursor(11, 1);
    lcd.print("C");
  }
}


void loop()
{
  getSensors();
  printLcd(150);                                            // an die neue Funktion wird das Wiederholungsintervall übergeben
}

[EDIT: Variable geändert - siehe #7]

ich kann dir keine PM senden, daher so:

das solltest imho static oder global machen.

1 Like

Doch geht auch - aber egal. :wink:

Nicht egal.
Mach ich - Danke für den Hinweis.

Danke schonmal, allerdings funktioniert der code leider nicht wie gewünscht.

Im LCD wird nun die obere Reihe frei gelassen, wenn der egt Wert einmal über 1000°C kommt, bleibt jeder darauffolgende Wert immer 4-stellig (auch wenn er nur einen 3-stellig sein sollte und der Teil des Schriftzuges "Achtung" wird konstant eingeblendet, sobald die 1000er Marke erreicht und blinkt nicht abwechselnd mit dem "Abgastemperatur" Schriftzug.

Ich werde mich mit dem millis() Timer erstmal soweit beschäftigen, bis ich diesen wirklich verstanden habe :slight_smile:

Vielen Dank für den Tipp und die Erklärung, wird langsam heller in meiner Birne :smiley:

werde das erstmal verinnerlichen und mich dann wieder auf mein eigentliches Problem stürzen.

Ich bin mir nicht zu 100% sicher, allerdings glaube ich das ich kein I2C sondern ein "anderen" LCD Typen hab, wenn ich deinen code mit deiner Library versuche sind einfach alle Pixel schwarz und es passiert nichts beim verändern der Eingangsspannung an Pin A0.

Wie schon gesagt werde ich erstmal klein anfangen und die Timer-Funktion verinnerlichen :slight_smile:

Trotzdem Danke für die Mühen :+1:t2:

Du mußt schon alle Positionen überschreiben und wenn keine Zeichen oder Zahlen geschrieben werden müssen notfalls mit Leerzeichen.

Grüße Uwe

Mein Code funktioniert - habe ich mit Hardware geprüft.

wenn man dir helfen soll musst du halt schon genau schreiben welches Display du genau verwendest und wie das angeschlossen ist.

Was "anderes" heißt gar nichts. Zeige halt mal einen Sketch von dir INKLUSIVE LCD Ansteuerung - in dem Sketch den du gepostet hast, fehlt das ja alles.

Also ich hab meinen ursprünglichen sketch jetzt soweit angepasst, das er fast so funktioniert wie ich mir das gedacht habe.
Nur der Wechsel der beiden Wörter "Achtung" und "Abgastemperatur" klappt nicht wie gewünscht.

Die frage die ich mir jetzt stelle, wie zeige ich bei egt>=1000 eine Sekunde lang "Achtung" und dann eine Sekunde lang "Abgastemperatur" an.
Ich habe versucht das mit einem timer zu machen, quasi so:
(SCHEMATISCH)

-Wenn egt>=1000 & lcd.print"Abgastemperatur" & timer von 1 Sekunde vorbei,
-Dann lcd.print"Achtung"

allerdings hab ich keine Ahnung welche Befehle ich anstatt
if (led == LOW) {led = HIGH;} else {led = LOW;}

da einsetzen kann und somit hat das natürlich auch nicht funktioniert. :frowning:

Habs versucht mit etwas in der Richtung.
if (lcd.print("Abgastemperatur") && "Timerfunktion"){ lcd.print("Achtung");}

Hier jetzt der aktuelle sketch:

#include <LiquidCrystal.h>
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;   // LCD pin verkabeln mit Arduino UNO Pin´s: GND = GND, VDD/VSS = 5V, VO = Poti (Kontrasteinstellung (Poti-Pin 1=5V, 2=LCD Pin VO, 3=gnd)), RS = 12, RW = GND, EN/E = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2, BLA = 5V mit 1k Wiederstand!, BLK = GND
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);                    // Initiasiert die Bibliothek mit den benötigten LCD-Interface Pins

byte grad [] = {                // byte grad [] = byte (nahme Funktion zum erstellen von customChar´s), name, [] benötigt für Funktion.for printing ° symbol on lcd
B00010,
B00101,
B00010,
B00000,
B00000,
B00000,
B00000,
B00000
};

//String string1=("!!!ACHTUNG!!!");
const int ledPin = (7);            //Warn LED an Pin 7 mit 1k Wiederstand anschließen
unsigned long premillis = 0;
const long interval = 300;
int led = LOW;

void setup() {
  lcd.begin(16, 2);             // Initieirt LCD
  lcd.createChar(0,grad);       // für das ° vor dem C
  pinMode(7, OUTPUT);           // Beschreibt pin 7 als Output-Pin
  lcd.home();
  lcd.blink();
  lcd.print("Starte, ");
  lcd.setCursor(0, 1);
  lcd.print("bitte warten...");
  delay(5000);
  lcd.clear();
  delay(500);  
}

void loop() {
  
  unsigned long curmillis = millis();
  int sensorValue = analogRead(A0);                         // int = Integra (ganze Zahl ohne Nachkommastelle), sensorValue = Name der Zahl, = analogRead(A0) = Wert der an Pin A0 eingelesen wird
  float voltage = sensorValue * (5.0 / 1023.0);             // Konvertiert das Eingangssignal von Pin A0 (0-1023) zu Spannung (Volt) 0-5V
  int egt = voltage * (1250 / 5);                           // Konvertiert das 0-5V Signal zur Ausgabe 0-1250°C
  
  lcd.clear();
  lcd.setCursor(6, 1);                                      // lcd.setCursor(5,1) = Anfang an Feld 5, Zeile 2 (Zeile 1=0 Zeile 2=1)
  lcd.print(egt);
  lcd.setCursor(10, 1);
  lcd.write(byte(0));                                       // lcd.write(byte(0)) = Befehl um das byte (customChar °) auf LCD auszugeben
  lcd.setCursor(11, 1);
  lcd.print("C");

  if (egt <= 1000){
  lcd.setCursor(0,0);
  lcd.print(" Abgastemperatur");
  delay(50);
  digitalWrite(ledPin, LOW);
  }  
    
  if(egt >= 1000 && (curmillis - premillis >= interval )) {
            premillis = millis();
            
          if (led == LOW) {
            led = HIGH;
            } else {
            led = LOW;
            }
            digitalWrite(ledPin, led);
  }
   
 if(egt >= 1000){
   lcd.home();
   lcd.print(" !!! ACHTUNG !!!");
   delay(50);
   }

 if(egt <=1000){ 
  digitalWrite(ledPin, LOW);
  }
 }

auf dem LCD steht auf der Rückseite: RoHS, 1602A und Ver5.5

Grüße zvenni,

ein parallel angeschlossenes LCD.
Schön das wir das nun auch wissen.

Man könnte einfach einen gezeigten Sketch für ein parallel LCD anpassen:

const int led = 7;            //Warn LED an Pin 7 mit 220 Ohm Wiederstand anschließen
const uint32_t interval1 = 1000;
const uint32_t interval2 = 500;
uint32_t previousMillis1;        // für die Ausgabe
uint32_t previousMillis2;        // für die Messung

uint8_t anzeige = 0;                  // 0 normal, 1 "blinkende Warnung", 2 "blinkende Warnung anderer text"
int egt;                               // gewandelter Wert zur Ausgabe
int previousEgt = -1;

//dann halt parallel 4bit:
#include <NoiascaLiquidCrystal.h>      // download library from https://werner.rothschopf.net/202009_arduino_liquid_crystal_intro.htm 
#include <NoiascaHW/lcd_4bit.h>     // include the proper IO interface
constexpr uint8_t cols {16};           // columns/characters per row
constexpr uint8_t rows {2};            // how many rows

const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2, bl = 255; // deine Pins
//const int rs = 8, en = 9, d4 = 4, d5 = 5, d6 = 6, d7 = 7, bl = 10;   // meine Pins
LiquidCrystal_4bit lcd(rs, en, d4, d5, d6, d7, bl, cols, rows);  // create lcd object

void ausgabeDefault()
{
  lcd.clear(); // lcd.clear() = alles auf LCD ausgegebenes löschen
  lcd.print(F("Abgas-Temperatur"));                            // lcd.print = Auf LCD anzeigen/ausgeben
  lcd.setCursor(6, 1);                                      // lcd.setCursor(5,1) = Anfang an Feld 5, Zeile 2 (Zeile 1=0 Zeile 2=1)
  lcd.print(egt);
  lcd.setCursor(10, 1);
  //lcd.write(byte(0));                                       // lcd.write(byte(0)) = Befehl um das byte (customChar °) auf LCD auszugeben
  //lcd.setCursor(11, 1);
  lcd.print("°C");                                          // die Noiasca Liquid Crystal kann das ;-)
  digitalWrite(led, LOW);
  previousEgt = egt;
}

void ausgabeWarnungTimer()
{
  uint32_t currentMillis = millis();
  if (currentMillis - previousMillis1 >= interval1 && previousEgt != egt)
  {
    previousMillis1 = currentMillis;
    previousEgt = egt;
    if (anzeige == 1)
    {
      lcd.clear();
      lcd.print(F("!!ACHTUNG!!"));
      lcd.print(egt);
      lcd.write(byte(0));
      lcd.print("C");
      digitalWrite(led, HIGH);
      anzeige = 2; // fürs nächste Mal
    }
    else
    {
      // die alternierende Anzeige im Warn-Modus
      lcd.clear();
      lcd.print(F("++ACHTUNG++"));
      lcd.print(egt);
      lcd.write(byte(0));
      lcd.print("C");
      digitalWrite(led, LOW);
      anzeige = 1; // fürs nächste Mal
    }
  }
}

void messungTimer()
{
  uint32_t currentMillis = millis();
  if (currentMillis - previousMillis2 >= interval2)
  {
    previousMillis2 = currentMillis;
    int sensorValue = analogRead(A0);                         // int = Integra (ganze Zahl ohne Nachkommastelle), sensorValue = Name der Zahl, = analogRead(A0) = Wert der an Pin A0 eingelesen wird
    float voltage = sensorValue * (5.0 / 1023.0);             // Konvertiert das Eingangssignal von Pin A0 (0-1023) zu Spannung (Volt) 0-5V
    egt = voltage * (1250 / 5);                           // Konvertiert das 0-5V Signal zur Ausgabe 0-1250°C
    Serial.println(egt);
  }
}

void setup() {
  Serial.begin(9600);
  lcd.init();  //lcd.begin(16, 2);     // Initieirt LCD
  lcd.backlight();
  //lcd.createChar(0, grad);           // für das ° vor dem C
  pinMode(led, OUTPUT);                // Beschreibt pin 7 als Output-Pin
  lcd.print(F("START"));
}

void loop() {
  //Serial.println(millis());
  messungTimer();

  if (egt >= 1000)
  {
    ausgabeWarnungTimer();   // den Timer triggern der die Ausgabe Warnung umschaltet
  }
  else
  {
    if (previousEgt != egt)  //flicker vermeiden und nur ausgeben, wenn anders
    {
      ausgabeDefault();
      delay(200);
    }
  }
}

Dickes Danke dafür, ich habe noch ein paar kleine Veränderungen vorgenommen und jetzt ist es so wie ich es mir vorgestellt hab.

Woran hast du festgestellt das es ein paralleles 4 bit und kein I2C ist?
Hab mit google versucht herauszufinden was genau das aufgedruckte auf der Rückseite des LCD´s bedeutet aber hab nchts gefunden was mir weiter geholfen hat.

Es gäbe da noch eine Kleinigkeit die ich gern anpassen würde,

das "g"

die Pixelanordnung ist für meinen Geschmack eine Reihe zu hoch.
Wo in deiner Library könnte man das anpassen?

Gibt es dafür eine Datei, wo die Buchstaben wie im "customChar" dargestellt hinterlegt sind?

Quasi so:
(schematisch)
00000
00000
01111
10001
10001
01111
00001
01110

:slight_smile:

Das trifft alle Kleinbuchstaben mit Unterlängen, also g j p q y.
Wenn du dir das Datasheet von so einem LCD ansiehst dann wirst du im Character ROM auch andere Varianten finden, die sind genau um jeweils +0x80 verschoben ("um 8 Spalten nach links verschoben"). Sehen aber auch nicht besser aus. Siehe am Ende von meiner Seite:
https://werner.rothschopf.net/202003_arduino_liquid_crystal_umlaute.htm

Es gibt in der Tat eine Datei mit einigen Sonderzeichen. Die ist in utility/NoiascaCustomCharacters.h

Außerdem gibt es ein Beispiel
50_convert/5040_Convert_Descender

Das zeigt wie man einen Zeichenkonverter nutzt, um z.B. diese Kleinbuchstaben gegen Special Characters auszutauschen.

im Wesentlichen sind es 4 Schritte:
utility/NoiascaCustomCharacters.h includen,
im Konstruktor am ende einen anderen Sprachkonverter übergeben,
Eine Funktion die das Mapping macht bzw die Special Characters anlegt
Die Funktion einmal im Setup aufrufen

Eventuell helfen auch die anderen Beispiele zum Verständnis was da passiert:
https://werner.rothschopf.net/microcontroller/202012_arduino_liquid_crystal_language_en.htm

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.