Nextion zu Arduino, Serial Stream Problem

Das Nextion sendet ja zu vielen Aktionen einen Header, wie z.B. 0x65, 0x71, gefolgt von weiteren Bytes und werden dann mit 3x(4x) 0xFF abgeschlossen.

Bisher hatte ich mich geschäut, dies hier auszuwerten, da mir die Kenntnisse und die Fähigkeit fehl(t)en. Kurz und gut, es war mir zu kompliziert, ich fand eine Lösung über String versenden usw.
Die Spezialisten werden schon die Nase rümpfen, weil dieses Thema schon so oft kam, aber ich habe sehr viel Zeit mit Suchen und Lesen zu diesem Thema verbracht.
Aktuell gibt es einen aktuellen Beitrag von mir, die Inhalte des TFT-EEPROMS in den Arduino auszulesen. Die Lösung wäre wahrscheinlich mit dem Befehl 'rept....'. Auch dazu habe ich viel probiert. Das Problem liegt an dem Aufspalten der einzelnen Bytes und die Zuweisung deren Inhalte in die entsprechenden Variablen. Dies ist der Grund, warum ich mich nun doch wieder mit diesem Problem beschäftige. Da das o.g. Thema doch zu speziell ist, habe ich mich zu diesem neuen Beitrag entschieden. Ich hoffe, es kommen keine (bösen) Kommentare zu Crossposting, dies ist nicht meine Absicht.

Nun stöbere ich doch immer wieder im Forum und auf YT, um auf eine für mich verständliche, durchschaubare Lösung zu kommen. Es ist ja fast überall ein Lerneffekt dabei und Danke an alle Forenmitglieder und Problemlöser.

Vor kurzem hatte ich eine für mich brauchbare Lösung gefunden, unter: [ Serial.read bei Nextion Display - #9 by firefist235]

Der Kollege hat ein Muster ausgearbeitet, das mir zusagt und wo ich eine Zukunft für meine weiteren Projekte in dieser Richtung sehe. Ich nahm dies als Basis (es soll ja so gelöst worden sein) und habe noch etwas herum gebastelt, bzw. ergänzt, so dass es zunächst mal lauffähig wirkt.

Wie so viele kopieren sich die Problemlöser diverse Lösungsansätze, Codeschnipsel zusammen und bauen auf diesem dann auf. Ich hoffe es ist keiner böse deswegen.

Das nachfolgende Programm lässt sich kompilieren und es scheint zu arbeiten. Auf dem GUI habe ich momentan zwei Schalter, welche den Haken bei ID aktiv haben, so dass beim Drücken des Buttons die übliche Codesequenz wie z.B. 65 00 0F 01 FF FF FF oder 65 00 10 01 FF FF FF sendet.

Als TFT hängt momentan nur der Simulator von Nextion dran. Der Simulator ist über einen TTL-USB-Wandler mit dem Arduino UNO über SoftSerial verbunden, die Baudraten sind eingestellt.
Fachforen wie Böcker, das Handbuch zum Display usw. sind mir bekannt, der Code ist hoffentlich richtig in den Codetags eingebettet. :face_with_monocle:

Warum bekomme ich hier nur „Müll“ zurück? Habe ich was falsch eingestellt?

Der Serielle Monitor bringt mir zweimal das Zeichen ‚e‘ zurück und das nur ein einziges Mal. Das ‚e‘ entspricht natürlich 0x65 (in Hex) oder 101 (in Dezimal) . Irgendwie ist die Kommunikation gestört, finde aber nicht heraus, wo es fehlt.

Erzeuge ich einen Reset im System (im Setup den Befehl "rest" an das TFT), so klappt das Auslesen nur genau 1x, egal welchen Schalter und wie oft ich diesen drücke.

Mein Ziel wäre es, ein lauffähiges Beispiel zu haben, um weiter ausbauen zu können.

Kann mir hier jemand helfen?

Gruß und Dank, Franz

/*
 * Beispiel aus'm Forum unter: 
 * https://forum.arduino.cc/t/serial-read-bei-nextion-display/656433/9
 * 
 * verbaute Hardware: UNO mit SoftSerial
 *                    Nextion-Simulator
 */

#include <SoftwareSerial.h>
SoftwareSerial Serial2(2, 3); // RX, TX

const char nextionNumChars = 25;  
char nextionReceivedChars[nextionNumChars]; // die Antwort ohne Endekennung  
boolean nextionNewData = false;             // wird true, wenn Antwort komplett ist, 
                                            // muss nach Auswerten vonm Aufrufer zurückgesetzt werden
     

//--------------------------------------------
void setup() {
  
  Serial.begin(9600);
  Serial2.begin(115200);

    Serial2.print("rest"); // 1x definierter Reset am Nextion
    Serial2.write(0xff);
    Serial2.write(0xff);
    Serial2.write(0xff);
    delay(100);
}
//--------------------------------------------
void loop() 
{
  
 recvFromNextion();
 delay(10); 

} 
//--------------------------------------------
void recvFromNextion() 
{
    static byte index     = 0;        // Index for Char Array
    char        endMarker = 0xFF;     // Endmarker
    char        rc;                   // incoming char
    static bool headerRead = false;   // 1 when first char (header) was read
    static bool stringComplete;       // 1 when incoming string is read until endMarker
    static byte maxIndex = 0;         // max expected bytes according to header

    while (Serial2.available() > 0 && nextionNewData == false)
        {
        rc = Serial2.read(); 
       
        if (!headerRead) 
          {                           // When header isn't read yet
            nextionReceivedChars[index] = rc;  // Write header in char arry index 0
            headerRead = true;
          }
          
        // maxIndex is set in the next section according to header
        if (headerRead)     // When header is already read
          {  
            switch (nextionReceivedChars[0]) 
            {
                // Header containing 4 Bytes
                case 0x00:  // Invalid Instruction
                case 0x02:  // Invalid Component ID
                case 0x03:  // Invalid Page ID
                case 0x04:  // Invalid Picture ID
                case 0x05:  // Invalid Font ID
                case 0x06:  // Invalid File Operation
                case 0x09:  // Invalid CRC
                case 0x11:  // Invalid Baud rate Setting
                case 0x12:  // Invalid Waveform ID or Channel #
                case 0x1A:  // Invalid Variable name or attribute
                case 0x1B:  // Invalid Variable Operation
                case 0x1C:  // Assignment failed to assign
                case 0x1D:  // EEPROM Operation failed
                case 0x1E:  // Invalid Quantity of Parameters
                case 0x1F:  // IO Operation failed
                case 0x20:  // Escape Character Invalid
                case 0x23:  // Variable name too long
                case 0x24:  // Serial Buffer Overflow
                case 0x86:  // Auto Entered Sleep Mode
                case 0x87:  // Auto Wake from Sleep
                case 0x88:  // Nextion Ready
                case 0x89:  // Start microSD Upgrade
                case 0xFD:  // Transparent Data Finished
                case 0xFE:  // Transparent Data Ready
                    maxIndex = 2;
                    break;

                // Header containing 5 Bytes
                case 0x66:  // Current Page Number (from sendme), byte2 = PageNr
                    maxIndex = 3;
                    break;

                // Header containing 7 Bytes
                case 0x65:  // Touch Event (from send Component ID), 2=PageNr, 3=ID, 4=event
                    maxIndex = 5;
                    break;

                // Header containing 8 Bytes
                case 0x71:  // Numeric Data Enclosed (from get of numeric values)
                    maxIndex = 6;
                    break;

                // Header containing 9 Bytes
                case 0x67:  // Touch Coordinate (awake), 2+3=x coord, 4+5=y coord, 6=event
                case 0x68:  // Touch Coordinate (sleep), 2+3=x coord, 4+5=y coord, 6=event
                    maxIndex = 7;
                    break;

                // Header containg string
                case 0x70:
                    break;
            }// end switch
            
            if ((index <= maxIndex) && (nextionReceivedChars[0] != 0x70)) // Execute only if incoming datagram is not a string
              {  
                nextionReceivedChars[index] = rc;
                index++;
              } else if (nextionReceivedChars[0] == 0x70 && !stringComplete) { // Execute if incoming datagram is a string
                if (rc != endMarker) 
                {
                    nextionReceivedChars[index] = rc;
                    index++;
                    if (index >= nextionNumChars) // Prevent writing out of array bounds
                    {  
                        index = nextionNumChars - 1;
                    }
                } else { // if endMarker has been found
                    nextionReceivedChars[index] = '\0';
                    stringComplete              = true;
                }
            } else { 
            
                Serial.print("  Char 0: ");// If all chars were read or header is unknown
                Serial.println(nextionReceivedChars[0]);  // ONLY FOR TESTING
                Serial.print("  Char 1: ");                
                Serial.println(nextionReceivedChars[1]);  // ONLY FOR TESTING
                Serial.print("  Char 2: ");
                Serial.println(nextionReceivedChars[2]);  // ONLY FOR TESTING
                Serial.print("  Char 3: ");                
                Serial.println(nextionReceivedChars[3]);  // ONLY FOR TESTING
                Serial.print("  Char 4: ");                
                Serial.println(nextionReceivedChars[4]);  // ONLY FOR TESTING
                Serial.print("  Char 5: ");                
                Serial.println(nextionReceivedChars[5]);  // ONLY FOR TESTING
                Serial.print("  Char 6: ");                
                Serial.println(nextionReceivedChars[6]);  // ONLY FOR TESTING
                Serial.print("  Char 7: ");                 
                Serial.println(nextionReceivedChars[7]);  // ONLY FOR TESTING
                Serial.print("  Char 8: ");                 
                Serial.println(nextionReceivedChars[8]);  // ONLY FOR TESTING
                Serial.print("  Char 9: ");                 
                Serial.println(nextionReceivedChars[9]);  // ONLY FOR TESTING
                
                //nextionTerminate();                     // ONLY FOR TESTING
                index          = 0;
                nextionNewData = true;  // is called in loop for further processing, gets FALSE when processing is finished
                headerRead     = false;
                stringComplete = false;
            }
        }
    }
}// end recvFromNextion() 

Hast Du Dein Nextion auf 115200 Baud dauerhaft umgestellt? Default sind 9600.
Außerdem arbeitet Softwareserial nicht sauber mit dieser hohen Baudrate.
Bleib lieber bei 9600.

Gruß Tommy

@Tommy56 hats ja schon angesprochen - kann es sein, das Du die Geschwindigkeiten versehentlich vertauscht hast?

Die Baudraten habe ich nun sicherheitshalber auf 9600 gestellt. Was sich ändert sind die Serial.print-Texte....Char1: usw.
Die Inhalte sind wie schon als Fehler beschrieben.
Wenn ich alles richtig verstanden hatte, dann sollten die Bytes wie aus dem Simulator dargestellt werden. Hier noch ein Screenshot.
Die Serial2 geht zum Simulator, Serial....der IDE-Monitor vom Arduino.

Gruß und Dank, Franz
2021-10-07 15_58_30-COM41

Was ist das?
Denk dran, das ich nicht weiss, was Du da machst.
Beide seriellen auf 9600 stellen - und dann auch die jeweiligen Tools darauf abstimmen.

Wenn Du irgendwo auf dem Arduino-SerMon ein Zeichen bekommst, das Dir nicht passt, dann stell es auf BIN

Serial.println(nextionReceivedChars[0], BIN);  // ONLY FOR TESTING

Warum benutzt Du nicht die Routine von Whandall?

Gruß Tommy

So, noch etwas genauer.
Der Screnshot zeigt rechts den seriellen Monitor der Arduino-IDE mit ‚Serial.begin(9600)‘ gestartet.
Links davon ein aktueller Shot, was aus dem Simulator kommt, ebenfalls mit 9600 Baud. Die beiden unterschiedlichen Werte im Nextionsimulator werden so ausgegeben, wenn ich zwei verschiedene Taster drücke.
Am Uno ist an Pin2+3 ein Umsetzer auf USB, an Com47.

Hallo Thommy56,
Auch das von Whandall hab ich mir angesehen, sogar mehrmals. Irgendwie habe ich hier den Einsprung nicht gefunden. Mein Problem liegt hier eher am Einbinden in ein ganzes Programm.
Vielleicht muss ich meinen bestehenden Steuerung Code kpl. Löschen und neu aufbauen, dies ist ja nur ein kleines Testprogramm zum lernen.
Aber nun zum eigentlichen Problem, warum das Miniprogramm nicht läuft. Die Umstellung auf binär kann ich erst wieder morgen testen….ist eine gute Idee.

Gruß und Dank, Franz

Ich habe auf der Basis des Codes von Whandal eine Funktion gebaut, die die Grundfunktionen des Nextion einlesen kann. Die Auswertung muss dann anhand des ersten Bytes erfolgen, da dieses bestimmt, welche Inhaltsbytes wie zu verarbeiten sind.

// nach Whandall 05.09.2019 forum.arduino.cc
// https://forum.arduino.cc/t/nextion-component-id-trennen/609217/19
const byte bufferSize = 15;
uint8_t buffer[bufferSize];

void setup() {
  Serial.begin(115200);
  Serial2.begin(9600); 
}

bool readNex(Stream &s) {
  static uint8_t bIndex = 0;
  bool allesDa = false;
  if (s.available()) {
    uint8_t inChar = s.read();
    buffer[bIndex++] = inChar;
		// 0x71 bei diesen Paketen können drei 0xFF Bestandteil des Pakets sein,
    // also ergibt es nur Sinn auf die Delimiter hinter dem Wert zu testen
    if (inChar == 0xFF && (bIndex >= (*buffer == 0x71 ? 8 : 3)) &&
        buffer[bIndex - 2] == 0xFF && buffer[bIndex - 3] == 0xFF) {
      allesDa = true;
    } else {
      allesDa = (bIndex == bufferSize);
    }
  }
  if (allesDa) bIndex = 0; // Index zurücksetzen 
  return allesDa;
}

void loop() {

unsigned long varVomNextion =0;
bool fertig = readNex(Serial2);
  if (fertig && buffer[0] == 0x71) { // Buffer[0] enthält das Kennbyte, nach dem die Auswertung erfolgen muss - hier numerische Daten
    varVomNextion = buffer[1]+buffer[2]*256+buffer[3]*65536+buffer[4]*16777216;
	  Serial.println(varVomNextion);
	}
}

Evtl. kannst Du damit mehr anfangen. 

Gruß Tommy

Edit: Für das Auslesen mehrerer Bytes des EEPROM brauchst Du evtl. einen größeren Puffer.

Hallo Tommy,

Danke erstmal. Ich werde es testen, dauert nur manchmal.

Franz

Kein Problem, wenn es dauert.

Gruß Tommy

Hallo Tommy,

Dein Code läuft bei mir nicht, macht aber nichts.
Durch die Darstellung, wie die Funktionsweise von Whandall eingebunden ist, half mir definitiv weiter, vielen Dank.
Ich konnte den Beitrag #19 von Whandall https://forum.arduino.cc/t/nextion-component-id-trennen/609217/19 gut umsetzen und auch gleich erweitern, so dass ich die Events mit 0x65 und 0x71 lauffähig bekam.

Mein angefügtes Beispiel in meiner Anfrage läuft weiterhin nur 1x durch und streikt dann, aber durch die Ergänzung von my_xy_projekt mit

Serial.println(nextionReceivedChars[0], BIN);  // ONLY FOR TESTING

konnte ich erstmals die Daten vom TFT überprüfen, auch das half mir weiter, auch wenn es nicht so richtig läuft.

Diese Lösung von Whandall finde ich genial, ist durch die Abfrage der FF's eigentlich nur die richtige Lösung. Auch die Zeile mit '8 : 3' (einige und auch ich meinten es sei ein Fussballergebnis) finde ich sehr tricky. So etwas können nur Profis....und der bin ich hier sicherlich nicht.
Zuerst mal vielen Dank an die Betreuer meines Problems.
Sicher werde ich noch einige Fragen zum Thema haben, aber alles zu seiner Zeit.

Gruß und Dank, Franz :+1:

Das Ding nennt sich Bedingungs- oder Konditional-Operator

https://www.c-howto.de/tutorial/verzweigungen/bedingungs-operator/

Hallo zusammen,

zuerst vielen Dank an Serenifly für den Link zum Bedingungs-Operator.
Da nun die Schalterabfrage super und 100%ig funktioniert, habe ich meinen Code nach dem Beispiel von Whandall soweit umgebaut und es klappt.

Nun habe ich eine Frage zu den ca. 20 Slidern, die ich verarbeiten muss.
Die Auswertung nach Whandall-Beispiel funktioniert einwandfrei, wenn ich irgend einen Slider bewege. Die Daten kommen korrekt am Arduino an.

Aber wie werte ich den Slider aus, so dass ich den Sliderwert einer Variable zuordnen kann?
Es wird mit 0x71 eingesteuert und mit den restlichen übertragenen Bytes nur noch der Wert übertragen, es fehlt also die ID des Sliders auf dem TFT.

Im verlinkten Beitrag von Tommy ist auch ein HMI-Beispiel (#22) dabei. Dies habe ich mal soweit untersucht und bei dem Slider wird im MoveEvent mit 'get slider.val' der Wert auf die Piste geschickt. Zusätzlich ist noch im ReleaseEvent die ID aktiviert, hier wird noch die ID übermittelt.

Nun kommt beim Bewegen des Sliders zunächst die 0x71 ..... und dann noch die 0x65 für das ReleaseEvent.

Ich habe mehrmals versucht, die beiden Auswertungen mit 'If....' zu verschachteln, aber es klappt nicht.

Kann mir hier nochmal jemand unter die Arme greifen, oder gibt es einen anderen Trick?

Gruß und Dank, Franz

Hallo Tommy,

nur zur Info, Dein eingestelltes Programm läuft nun bei mir.

Gruß, Franz

Prima. Woran lag es?

Gruß Tommy

Tja der Fehler sitzt vor dem Bildschirm :grinning: Im Detail kann ich es nicht mehr sagen.

Hast Du noch einen Tipp oder eine Idee zu meiner letzten Frage, wie man einen übertragenen Sliderwerte durch seine ID zu einer Variable zuordnen kann? Die Werteübertragung klappt ja prima. Ich möchte das kpl. Konstrukt von Dir und Whandall übernehmen, weil es die beste Lösung ist, was ich gesehen habe. Ich komm hier nicht weiter.

Gruß und Dank, Franz

Dert Touch-Event kann auch bei Touch ausgelöst werden. Dann hast Du Touch (0x65) und danach den Sliderwert (0x71).
Du weißt also was betätigt wurde und hast danach den Wert als unsigned long.
Wie er ausgerechnet wird steht ja im Beispiel.
Den kannst Du dann einer Variablen oder einem Arrayelement zuweisen.
Die Auswertung der ID und damit die Zuordnung würde ich über switch/case oder wenn die ID aufsteigend sind kannst Du sie gleich in einen Index umrechnen.

Gruß Tommy

Hallo zusammen,

ich war am WE fleissig und habe mich speziell mit der Datenübertragung vom Nextion beschäftigt. Mein spezielles Problem konnte ich lösen. Die Schalter und Slider bekomme ich nun korrekt geliefert und ich kann den eigentlichen Code weitertreiben.

@Thommy: die Arbeitsweise vom Nextion war mir schon klar, einzig der Simulator hat mich ins Schleudern gebracht, weil er zwei einzelne Zeilen, 1x die 0x65 und 1x die 0x71 lieferte. Da hatte ich keine Idee dazu, wie man es verknüpft.
Dass es ein einziger Stream ist und bleibt, habe ich erst später erkannt.
Danke an alle Helfer, das hätte ich alleine nie geschafft.

Nachfolgend der ungepflegte Code, wie ich es auf die Schnelle gelöst habe. Vielleicht hilft es jemandem weiter.

Gruß und Dank, Franz

type or paste code here
// Grundlage aus https://forum.arduino.cc/t/nextion-component-id-trennen/609217/18
// Doku zum Thema unter: Component_ID_trennen_01.docx
// im Forum ist es der Artikel #19
// 
// Test mit UNO, daher softwareSerial....
//
//  - Slider:
//    im ReleaseEvent die SendID aktivieren, und im MoveEvent noch die 
//	Weiterreichung auf das Nummernfeld einstellen.
//	so wird beim Loslassen des Schiebers der letzte Wert mit
//	'get Slider1.val' über die Schnittstelle gesendet,
//	Antwort:  	71 64 00 00 00 FF FF FF (dez.Wert=100) 
//			65 01 01 00 FF FF FF -> wegen TouchEvent 
//-------------------------------------------------------------------------------

#include <SoftwareSerial.h>
SoftwareSerial Serial2(2, 3); // RX, TX

const byte bufferSize = 64;

int hGiessMenge1 = 0; // Variablen beinhalten den Sliderwert
int hGiessMenge2 = 0;
int hGiessMenge3 = 0;
int hGiessMenge4 = 0;
int hGiessMenge5 = 0;
int hGiessMenge6 = 0;

boolean Slider1 = LOW;  // Hilfsmerker für die Auswertung
boolean Slider2 = LOW;
boolean Slider3 = LOW;
boolean Slider4 = LOW;
boolean Slider5 = LOW;
boolean Slider6 = LOW;

unsigned long VarFromNextion = 0; // beinhaltet den Sliderwert
int led = 13;
boolean StateLed = LOW;

void setup() 
{
  Serial.begin(9600);
  Serial2.begin(9600);
  pinMode(led, OUTPUT);
}

void loop() 
{
    static uint8_t bIndex;
    static uint8_t buffer[bufferSize];
    bool allesDa = false;

//-----------Einleseroutine nach Whandall+Thommy----------------------
      if (Serial2.available()) 
        {
          uint8_t inChar = Serial2.read();
          buffer[bIndex++] = inChar;
  
          if (inChar == 0xFF && (bIndex >= (*buffer == 0x71 ? 8 : 3)) &&
              buffer[bIndex - 2] == 0xFF && buffer[bIndex - 3] == 0xFF) 
              {
                allesDa = true;
              } 
              else 
              {
                allesDa = (bIndex == bufferSize);
              }

                  Serial.print("                inChar ");
                  Serial.print(inChar);
                  Serial.print("    allesDa ");
                  Serial.println(allesDa);
                  
        }// end if Serial.available()
        
//---- Auswertung ------------ ----------------        
        if (allesDa) 
          {
            if (*buffer == 0x71)
              {
/*                Serial.print(F("Kennung: "));
                Serial.println(buffer[0],HEX);
                Serial.print(F("Byte1 d: "));
                Serial.println(buffer[1],DEC);
                Serial.print(F("Byte2  : "));
                Serial.println(buffer[2],HEX);
                Serial.print(F("Byte3  : "));
                Serial.println(buffer[3],HEX);
                Serial.print(F("Byte4  : "));
                Serial.println(buffer[4],HEX);
                Serial.print(F("Byte5  : "));
                Serial.println(buffer[5],HEX);
                Serial.print(F("Byte6  : "));
                Serial.println(buffer[6],HEX);
                Serial.print(F("Byte7  : "));
                Serial.println(buffer[7],HEX);
                Serial.print(F("Byte8  : "));
                Serial.println(buffer[8],HEX);
*/
                VarFromNextion = buffer[1]+buffer[2]*256+buffer[3]*65536+buffer[4]*16777216;
                Serial.println(VarFromNextion);
                
              }
    //---------------------------------------------------------------------------            
                //slider1 page0
                if ((*buffer == 0x65)  && (buffer[1] == 0) && (buffer[2] == 6))
                  {
/*                    Serial.print(F("0x65 : "));
                    Serial.println(buffer[0],HEX);
                    Serial.print(F("Page : "));
                    Serial.println(buffer[1]);
                    Serial.print(F("ID   : "));
                    Serial.println(buffer[2]);
                    //Serial.print(F("Event: "));
                    //Serial.println(buffer[3] ? F("PRESS") : F("RELEASE"));
*/                       
                    Slider1 = true;
                    Serial.print(F("Slider 1 "));
                    Serial.println(Slider1);
                  }
                  else 
                  {
                    Slider1 = false; 
                    Serial.print(F("Slider 1 "));
                    Serial.println(Slider1);
                                
                  }
    //----------------------------------------------------------------------------
                  // slider 2 page0
                   if ((*buffer == 0x65)  && (buffer[1] == 0) && (buffer[2] == 2))
                  {
/*                    Serial.print(F("0x65 : "));
                    Serial.println(buffer[0],HEX);
                    Serial.print(F("Page : "));
                    Serial.println(buffer[1]);
                    Serial.print(F("ID   : "));
                    Serial.println(buffer[2]);
                    //Serial.print(F("Event: "));
                    //Serial.println(buffer[3] ? F("PRESS") : F("RELEASE"));
*/    
                    Slider2 = true;
                    Serial.print(F("Slider 2 "));
                    Serial.println(Slider2);                                
                  }
                  else 
                  {
                    Slider2 = false;  
                    Serial.print(F("Slider 2 "));
                    Serial.println(Slider2);                           
                  }
//----------------------------------------------------------------------------  
//slider3 page0            
if ((*buffer == 0x65)  && (buffer[1] == 0) && (buffer[2] == 8))
                  {
/*                    Serial.print(F("0x65 : "));
                    Serial.println(buffer[0],HEX);
                    Serial.print(F("Page : "));
                    Serial.println(buffer[1]);
                    Serial.print(F("ID   : "));
                    Serial.println(buffer[2]);
                    //Serial.print(F("Event: "));
                    //Serial.println(buffer[3] ? F("PRESS") : F("RELEASE"));
*/    
                    Slider3 = true;
                    Serial.print(F("Slider 3 "));
                    Serial.println(Slider3);                                
                  }
                  else 
                  {
                    Slider3 = false;  
                    Serial.print(F("Slider 3 "));
                    Serial.println(Slider3);                           
                  }
//---------------------------------------------------------------------------- 
//Slider4 page0 
if ((*buffer == 0x65)  && (buffer[1] == 0) && (buffer[2] == 10))
                  {
/*                    Serial.print(F("0x65 : "));
                    Serial.println(buffer[0],HEX);
                    Serial.print(F("Page : "));
                    Serial.println(buffer[1]);
                    Serial.print(F("ID   : "));
                    Serial.println(buffer[2]);
                    //Serial.print(F("Event: "));
                    //Serial.println(buffer[3] ? F("PRESS") : F("RELEASE"));
*/    
                    Slider4 = true;
                    Serial.print(F("Slider 4 "));
                    Serial.println(Slider4);                                
                  }
                  else 
                  {
                    Slider4 = false;  
                    Serial.print(F("Slider 4 "));
                    Serial.println(Slider4);                           
                  }
//---------------------------------------------------------------------------- 
//Slider1 page01
if ((*buffer == 0x65)  && (buffer[1] == 1) && (buffer[2] == 1))
                  {
/*                    Serial.print(F("0x65 : "));
                    Serial.println(buffer[0],HEX);
                    Serial.print(F("Page : "));
                    Serial.println(buffer[1]);
                    Serial.print(F("ID   : "));
                    Serial.println(buffer[2]);
                    //Serial.print(F("Event: "));
                    //Serial.println(buffer[3] ? F("PRESS") : F("RELEASE"));
*/    
                    Slider5 = true;
                    Serial.print(F("Slider 5 "));
                    Serial.println(Slider5);                                
                  }
                  else 
                  {
                    Slider5 = false;  
                    Serial.print(F("Slider 5 "));
                    Serial.println(Slider5);                           
                  }
//---------------------------------------------------------------------------- 
//Slider2 page01
if ((*buffer == 0x65)  && (buffer[1] == 1) && (buffer[2] == 3))
                  {
/*                    Serial.print(F("0x65 : "));
                    Serial.println(buffer[0],HEX);
                    Serial.print(F("Page : "));
                    Serial.println(buffer[1]);
                    Serial.print(F("ID   : "));
                    Serial.println(buffer[2]);
                    //Serial.print(F("Event: "));
                    //Serial.println(buffer[3] ? F("PRESS") : F("RELEASE"));
*/    
                    Slider6 = true;
                    Serial.print(F("Slider 6 "));
                    Serial.println(Slider6);                                
                  }
                  else 
                  {
                    Slider6 = false;  
                    Serial.print(F("Slider 6 "));
                    Serial.println(Slider6);                           
                  }
//---------------------------------------------------------------------------- 
                //btn page01
                if ((*buffer == 0x65)  && (buffer[1] == 1) && (buffer[2] == 5))
                  {
                      if (StateLed == LOW)
                      {
                        StateLed = HIGH;
                        digitalWrite(led, HIGH);                                
                      }
                      else 
                      {
                        StateLed = LOW;
                        digitalWrite(led, LOW);                           
                      }
                  }   
                  
//----------------------------------------------------------------------------              
// Zusammenführung der Events+Sliderwerte mit Auswertung der Slider....

                      if (Slider1 == HIGH)
                         {
                            hGiessMenge1 = VarFromNextion;
                            Serial.print("hGiessMenge 1: ");
                            Serial.println(hGiessMenge1);
                         }
                      //--------------------------   
                      if (Slider2 == HIGH)
                         {
                            hGiessMenge2 = VarFromNextion;
                            Serial.print("hGiessMenge 2: ");
                            Serial.println(hGiessMenge2);
                         }  
                      //--------------------------                
                      if (Slider3 == HIGH)
                         {
                            hGiessMenge3 = VarFromNextion;
                            Serial.print("hGiessMenge 3: ");
                            Serial.println(hGiessMenge3);
                         }  
                      //--------------------------                
                      if (Slider4 == HIGH)
                         {
                            hGiessMenge4 = VarFromNextion;
                            Serial.print("hGiessMenge 4: ");
                            Serial.println(hGiessMenge4);
                         }      
                      //--------------------------                
                      if (Slider5 == HIGH)
                         {
                            hGiessMenge5 = VarFromNextion;
                            Serial.print("hGiessMenge 5: ");
                            Serial.println(hGiessMenge5);
                         }               
                         //--------------------------                
                      if (Slider6 == HIGH)
                         {
                            hGiessMenge6 = VarFromNextion;
                            Serial.print("hGiessMenge 6: ");
                            Serial.println(hGiessMenge6);
                         }                           
                              
            bIndex = 0;
          } // end allesDa
} // end loop