Seltsamen Programmverhalten bei Ansteuerung eines Nextion-Displays

International Deutsch
1

Hallo zusammen,

ich habe ein Problem mit meinem aktuellen Projekt und hoffe, dass mir jemand weiterhelfen kann. Der folgende Code funktioniert grundsätzlich, aber es gibt ein seltsames Verhalten, das ich nicht erklären kann.

Wenn ich den Teil des Codes, der für die Ansteuerung der Ausgänge zuständig ist, komplett auskommentiere, funktioniert alles einwandfrei. In diesem Fall wird der Druck korrekt an das Display gesendet und angezeigt.

Kommentiere ich jedoch den Abschnitt zur Sensorauswertung aus, funktionieren die Ausgänge wie erwartet, aber natürlich werden keine Sensordaten verarbeitet und dementsprechend auch nicht ans Display gesendet.

Ich verstehe nicht, warum diese beiden Funktionen sich gegenseitig ausschließen. Hat jemand eine Idee, woran das liegen könnte?

#include <SoftwareSerial.h>

// Definieren der Pins für die Eingänge und Ausgänge
const int front_left_up = 15;
const int front_left_down = 19;
const int front_right_up = 29;
const int front_right_down = 6;
const int rear_left_up = 14;
const int rear_left_down = 18;
const int rear_right_up = 28;
const int rear_right_down = 7;

// Setze die Software-Serial Schnittstelle für das Nextion Display
SoftwareSerial nextion(2, 3); // RX, TX

// Drucksensor-Pins und Parameter
const int sensorPin = A1; // Anschluss des Drucksensors an den analogen Eingang A1
const float sensorMinVoltage = 0.5; // minimale Spannung des Sensors bei 0 Bar
const float sensorMaxVoltage = 4.5; // maximale Spannung des Sensors bei 13,7895 Bar
const float pressureMax = 13.7895; // maximaler Druck in Bar

String daten_display = "";

void setup() {
  // Initialisiere die serielle Kommunikation zur Debugging
  Serial.begin(9600);
  // Initialisiere die serielle Kommunikation zum Nextion Display
  nextion.begin(9600);
  // Definieren der Eingänge und Ausgänge als Variable
  pinMode(front_left_up, OUTPUT);
  pinMode(front_left_down, OUTPUT);
  pinMode(front_right_up, OUTPUT);
  pinMode(front_right_down, OUTPUT);
  pinMode(rear_left_up, OUTPUT);
  pinMode(rear_left_down, OUTPUT);
  pinMode(rear_right_up, OUTPUT);
  pinMode(rear_right_down, OUTPUT);
}

void loop() {
  // Drucksensor auslesen
  int sensorValue = analogRead(sensorPin); // Analogwert vom Sensor lesen
  float sensorVoltage = sensorValue * (5.0 / 1023.0); // Umwandlung des Analogwerts in Spannung

  // Umrechnung der Spannung in Druck (Bar)
  float pressure = (sensorVoltage - sensorMinVoltage) * (pressureMax / (sensorMaxVoltage - sensorMinVoltage));

  // Sicherstellen, dass der Druck nicht unter 0 fällt
  if (pressure < 0) {
    pressure = 0;
  }

  // Druckwert als String formatieren
  char pressureString[10];
  dtostrf(pressure, 0, 1, pressureString); // Druckwert in String umwandeln

  // Druckwert an das Nextion Display senden
  nextion.print("t8.txt=\"");
  nextion.print(pressureString);
  nextion.print("\"");
  nextion.write(0xff); nextion.write(0xff); nextion.write(0xff);

  nextion.print("t9.txt=\"");
  nextion.print(pressureString);
  nextion.print("\"");
  nextion.write(0xff); nextion.write(0xff); nextion.write(0xff);

  nextion.print("t10.txt=\"");
  nextion.print(pressureString);
  nextion.print("\"");
  nextion.write(0xff); nextion.write(0xff); nextion.write(0xff);

  nextion.print("t11.txt=\"");
  nextion.print(pressureString);
  nextion.print("\"");
  nextion.write(0xff); nextion.write(0xff); nextion.write(0xff);

  delay(1000); // Eine Sekunde warten, bevor der nächste Messwert gelesen wird

  // Display-Befehle auslesen
  if (nextion.available() > 0) {
    daten_display += char(nextion.read());
  }

  // Ansteuern der Magnetventile für vorne links
  if (daten_display == "front_left_up_on") {
    digitalWrite(front_left_up, HIGH);
    Serial.println("Erhöhung des Drucks im vorderen linken Balg wird gestartet");
    daten_display = "";
  }
  if (daten_display == "front_left_up_off") {
    digitalWrite(front_left_up, LOW);
    Serial.println("Erhöhung des Drucks im vorderen linken Balg wird gestoppt");
    daten_display = "";
  }
  if (daten_display == "front_left_down_on") {
    digitalWrite(front_left_down, HIGH);
    Serial.println("Ablassen des Drucks im vorderen linken Balg wird gestartet");
    daten_display = "";
  }
  if (daten_display == "front_left_down_off") {
    digitalWrite(front_left_down, LOW);
    Serial.println("Ablassen des Drucks im vorderen linken Balg wird gestoppt");
    daten_display = "";
  }

  // Ansteuern der Magnetventile für vorne rechts
  if (daten_display == "front_right_up_on") {
    digitalWrite(front_right_up, HIGH);
    Serial.println("Erhöhung des Drucks im vorderen rechten Balg wird gestartet");
    daten_display = "";
  }
  if (daten_display == "front_right_up_off") {
    digitalWrite(front_right_up, LOW);
    Serial.println("Erhöhung des Drucks im vorderen rechten Balg wird gestoppt");
    daten_display = "";
  }
  if (daten_display == "front_right_down_on") {
    digitalWrite(front_right_down, HIGH);
    Serial.println("Ablassen des Drucks im vorderen rechten Balg wird gestartet");
    daten_display = "";
  }
  if (daten_display == "front_right_down_off") {
    digitalWrite(front_right_down, LOW);
    Serial.println("Ablassen des Drucks im vorderen rechten Balg wird gestoppt");
    daten_display = "";
  }

  // Ansteuern der Magnetventile für die Vorderachse
  if (daten_display == "front_axle_up_on") {
    digitalWrite(front_left_up, HIGH);
    digitalWrite(front_right_up, HIGH);
    Serial.println("Erhöhung des Drucks in der Vorderachse wird gestartet");
    daten_display = "";
  }
  if (daten_display == "front_axle_up_off") {
    digitalWrite(front_left_up, LOW);
    digitalWrite(front_right_up, LOW);
    Serial.println("Erhöhung des Drucks in der Vorderachse wird gestoppt");
    daten_display = "";
  }
  if (daten_display == "front_axle_down_on") {
    digitalWrite(front_left_down, HIGH);
    digitalWrite(front_right_down, HIGH);
    Serial.println("Ablassen des Drucks in der Vorderachse wird gestartet");
    daten_display = "";
  }
  if (daten_display == "front_axle_down_off") {
    digitalWrite(front_left_down, LOW);
    digitalWrite(front_right_down, LOW);
    Serial.println("Ablassen des Drucks in der Vorderachse wird gestoppt");
    daten_display = "";
  }

  // Ansteuern der Magnetventile für hinten links
  if (daten_display == "rear_left_up_on") {
    digitalWrite(rear_left_up, HIGH);
    Serial.println("Erhöhung des Drucks im hinteren linken Balg wird gestartet");
    daten_display = "";
  }
  if (daten_display == "rear_left_up_off") {
    digitalWrite(rear_left_up, LOW);
    Serial.println("Erhöhung des Drucks im hinteren linken Balg wird gestoppt");
    daten_display = "";
  }
  if (daten_display == "rear_left_down_on") {
    digitalWrite(rear_left_down, HIGH);
    Serial.println("Ablassen des Drucks im hinteren linken Balg wird gestartet");
    daten_display = "";
  }
  if (daten_display == "rear_left_down_off") {
    digitalWrite(rear_left_down, LOW);
    Serial.println("Ablassen des Drucks im hinteren linken Balg wird gestoppt");
    daten_display = "";
  }

  // Ansteuern der Magnetventile für hinten rechts
  if (daten_display == "rear_right_up_on") {
    digitalWrite(rear_right_up, HIGH);
    Serial.println("Erhöhung des Drucks im hinteren rechten Balg wird gestartet");
    daten_display = "";
  }
  if (daten_display == "rear_right_up_off") {
    digitalWrite(rear_right_up, LOW);
    Serial.println("Erhöhung des Drucks im hinteren rechten Balg wird gestoppt");
    daten_display = "";
  }
  if (daten_display == "rear_right_down_on") {
    digitalWrite(rear_right_down, HIGH);
    Serial.println("Ablassen des Drucks im hinteren rechten Balg wird gestartet");
    daten_display = "";
  }
  if (daten_display == "rear_right_down_off") {
    digitalWrite(rear_right_down, LOW);
    Serial.println("Ablassen des Drucks im hinteren rechten Balg wird gestoppt");
    daten_display = "";
  }

  // Ansteuern der Magnetventile für die Hinterachse
  if (daten_display == "rear_axle_up_on") {
    digitalWrite(rear_left_up, HIGH);
    digitalWrite(rear_right_up, HIGH);
    Serial.println("Erhöhung des Drucks in der Hinterachse wird gestartet");
    daten_display = "";
  }
  if (daten_display == "rear_axle_up_off") {
    digitalWrite(rear_left_up, LOW);
    digitalWrite(rear_right_up, LOW);
    Serial.println("Erhöhung des Drucks in der Hinterachse wird gestoppt");
    daten_display = "";
  }
  if (daten_display == "rear_axle_down_on") {
    digitalWrite(rear_left_down, HIGH);
    digitalWrite(rear_right_down, HIGH);
    Serial.println("Ablassen des Drucks in der Hinterachse wird gestartet");
    daten_display = "";
  }
  if (daten_display == "rear_axle_down_off") {
    digitalWrite(rear_left_down, LOW);
    digitalWrite(rear_right_down, LOW);
    Serial.println("Ablassen des Drucks in der Hinterachse wird gestoppt");
    daten_display = "";
  }
}
2

Hallo und willkommen.

Was für einen Controller setzt du ein ?
Dein delay in der loop wird dir Probleme bereiten.
Wenn du den Sensor nur alle Sekunden auslesen möchtest, solltest du das mit einem Timer auf der Basis von millis machen und den Sensor damit alle Sekunden auslesen. Der blockiert nicht deine loop und damit alle anderen Aktionen.
Fakt ist, die loop muß schnell und ohne zu blockieren durchlaufen.
Solch ein Timer ist z. B. INTERVAL.

3

Hallo HotSystems,

vielen Dank für deine schnelle Antwort!

Ich verwende als Controller einen Arduino Mega 2560. Ich habe es jetzt mal ohne delay probiert, aber leider bleibt das Problem weiterhin bestehen.

Die Ansteuerung der Ausgänge des Arduinos funktioniert einwandfrei, solange ich den Teil mit nextion.print (siehe unten) auskommentiere. Sobald dieser Teil jedoch aktiviert ist, werden keine Sensorwerte mehr an das Display ausgegeben.

Falls du noch eine Idee hast, woran das liegen könnte, wäre ich für weitere Tipps sehr dankbar!

  // Druckwert an das Nextion Display senden
  nextion.print("t8.txt=\"");
  nextion.print(pressureString);
  nextion.print("\"");
  nextion.write(0xff); nextion.write(0xff); nextion.write(0xff);

  nextion.print("t9.txt=\"");
  nextion.print(pressureString);
  nextion.print("\"");
  nextion.write(0xff); nextion.write(0xff); nextion.write(0xff);

  nextion.print("t10.txt=\"");
  nextion.print(pressureString);
  nextion.print("\"");
  nextion.write(0xff); nextion.write(0xff); nextion.write(0xff);

  nextion.print("t11.txt=\"");
  nextion.print(pressureString);
  nextion.print("\"");
  nextion.write(0xff); nextion.write(0xff); nextion.write(0xff);

Sobald dieser Teil auskommentiert ist, können wenigstens die Ausgänge am Arduino wieder über das Nextion-Display angesteuert werden.

4

Dann solltest du nicht mit SoftwareSerial arbeiten, sondern eine der 3 Hardware Seriellen verwenden. Das entlastet auch den Controller, da es per Hardware läuft.

5

Auch schon getestet, leider auch keine Lösung des Problems.

6

Warum musst du denn den Sensor je Sekunde auslesen ?

Mein Weg das Problem zu beheben, wäre def. erst auf Hardware Seriell umstellen und dann den Sensoraufruf per Timer und auf längere Zeit gehen.

7

Geht um eine Druckanzeige von Lufbälgen. Ich kann zur Not auch auf 2 Sekunden hoch, mehr wäre leider aber nicht drin.

8

Okay, ich probiere das mal aus.

9

Ein Tipp wäre noch, du kannst dich mal hier einlesen, da war ein ähnliches Problem.
Nicht erschrecken, der Thread ist sehr lang.
Da wurde übrigens die Baudrate zum Nextion höher gestellt. Das kann helfen.

10

Ich würde zusätzlich empfehlen, die Geschwindigkeit für den seriellen Monitor auf 115200 hochzusetzen. Die umfangreichen Ausgaben kosten bei 9600 unnötige Millisekunden.

Zum Testen würde ich mir mal in HEX auf dem seriellen Monitor anschauen, was das Display generell so schickt. Warum?
Vermutung: Wenn Du die Drücke an das Display (t8 bis t11) schickst, gibt es irgendeine unbehandelte Reaktion/Antwort vom Nextion, die dein daten_display "korrumpiert" - ähnliche Phänomene hatten wir in dem langen Thread auch.

11

Warum testest Du das Programm nicht erst über den Simulator, bevor Du das echte Display dran hängst? So würde ein Fehler in der Kommunikation mit dem Display relativ einfach vermieden.

cu

12

Hallo zusammen,

ich wollte mich nochmal kurz melden und mitteilen, dass ich nun eine Lösung für mein Problem gefunden habe.

Ich habe mein Vorhaben über die Easy Nextion Library umgesetzt. Ein großer Vorteil für mich ist dabei, dass ich die Ausgabe des Nextion Displays jetzt deutlich leichter über die Trigger-Funktion auswerten kann und somit gezielt Aktionen auslösen kann.

Zudem funktioniert jetzt auch das Auslesen der Sensoren einwandfrei, und die Weitergabe der Sensordaten an das Nextion Display klappt problemlos.

Falls jemand Verbesserungsvorschläge für den Code hat, wäre ich sehr dankbar. Ich freue mich über jede Rückmeldung!

Vielen Dank an alle, die mir bisher geholfen haben.

Hier der Code:

#include "EasyNextionLibrary.h"  // Laden der EasyNextionLibrary

EasyNex myNex(Serial2); // Setzen der Parameter für die Serielle Hardware-Schnittstelle für die Verbindung mit dem Nextion-Display
                        // Belegung: Pin 16 - Orange, Pin 17 - Braun

// Sensorpins
int sensorPins[5] = {A0, A1, A2, A3, A4}; // Definieren der Pins für die Drucksensoren
float sensorValues[5];  // Array zum Speichern der Sensorwerte

const int REFRESH_TIME = 100; // Zeit zum Aktualisieren der Nextion-Seite alle 100 ms
unsigned long refresh_timer = 0; // Timer für die Aktualisierung der Nextion-Seite

const int front_left_up = 15;       // Definieren des Pins für das Heben des vorderen linken Balgs
const int front_left_down = 19;     // Definieren des Pins für das Senken des vorderen linken Balgs
const int front_right_up = 29;      // Definieren des Pins für das Heben des vorderen rechten Balgs
const int front_right_down = 6;     // Definieren des Pins für das Senken des vorderen linken Balgs
const int rear_left_up = 14;        // Definieren des Pins für das Heben des hinteren linken Balgs
const int rear_left_down = 18;      // Definieren des Pins für das Senken des hinteren linken Balgs
const int rear_right_up = 28;       // Definieren des Pins für das Heben des hinteren rechten Balgs
const int rear_right_down = 7;      // Definieren des Pins für das Senken des hinteren rechten Balgs

const float voltageMin = 0.5;       // Minimaler Spannungsausgang der einzelnen Drucksensoren
const float voltageMax = 4.5;       // Maximaler Spannungsausgang der einzelnen Drucksensoren
const float pressureMax = 13.7895;  // Maximaler Druckwert der einzelnen Drucksensoren in BAR

void setup() {
  myNex.begin(9600); // Initialize the Nextion display with a baud rate of 9600
  for (int i = 0; i < 5; i++) {
    pinMode(sensorPins[i], INPUT); // Set the sensor pins as input
  }
  // Definieren der Variablen als Ausgänge
  pinMode(front_left_up, OUTPUT);
  pinMode(front_left_down, OUTPUT);
  pinMode(front_right_up, OUTPUT);
  pinMode(front_right_down, OUTPUT);
  pinMode(rear_left_up, OUTPUT);
  pinMode(rear_left_down, OUTPUT);
  pinMode(rear_right_up, OUTPUT);
  pinMode(rear_right_down, OUTPUT);
}

void loop() {
  myNex.NextionListen(); // This function must be called repeatedly to response touch events
  
  if (millis() - refresh_timer > REFRESH_TIME) {
    refresh_timer = millis(); // Timer zurücksetzen

    for (int i = 0; i < 5; i++) {
      int rawValue = analogRead(sensorPins[i]);  // Sensorwert lesen
      float voltage = (rawValue / 1023.0) * 5.0;  // Konvertiere den analogen Wert in eine Spannung (0 - 5V)
      sensorValues[i] = convertVoltageToPressure(voltage);  // Konvertiere die Spannung in Druck
    }

    // Sende die Druckwerte an die Textfelder auf dem Nextion Display
    myNex.writeStr("t8.txt", String(sensorValues[0], 1)); // Druck von Sensor 1 an Textfeld t8 senden
    myNex.writeStr("t9.txt", String(sensorValues[1], 1)); // Druck von Sensor 2 an Textfeld t9 senden
    myNex.writeStr("t10.txt", String(sensorValues[2], 1)); // Druck von Sensor 3 an Textfeld t10 senden
    myNex.writeStr("t11.txt", String(sensorValues[3], 1)); // Druck von Sensor 4 an Textfeld t11 senden
    myNex.writeStr("t12.txt", String(sensorValues[4], 1)); // Druck von Sensor 5 an Textfeld t12 senden
  }
}

float convertVoltageToPressure(float voltage) {
  // Konvertiere die Spannung in Druck, basierend auf dem spezifizierten Bereich
  if (voltage < voltageMin) voltage = voltageMin;
  if (voltage > voltageMax) voltage = voltageMax;

  float pressure = ((voltage - voltageMin) / (voltageMax - voltageMin)) * pressureMax;
  return pressure;
}

// Ansteuern der Magnetventile für vorne links
void trigger0() {
   // Bedingung in Touch Press Event: printh 23 02 54 00
  digitalWrite(front_left_up, HIGH); // Erhöhung des Drucks im vorderen linken Balg wird gestartet
}

void trigger1() {
  // Bedingung in Touch Release Event: printh 23 02 54 01
  digitalWrite(front_left_up, LOW); // Erhöhung des Drucks im vorderen linken Balg wird gestoppt
}

void trigger2() {
  // Bedingung in Touch Press Event: printh 23 02 54 02
  digitalWrite(front_left_down, HIGH); // Ablassen des Drucks im vorderen linken Balg wird gestartet
}

void trigger3() {
  // Bedingung in Touch Release Event: printh 23 02 54 03
  digitalWrite(front_left_down, LOW); // Ablassen des Drucks im vorderen linken Balg wird gestoppt
}

// Ansteuern der Magnetventile für vorne rechts
void trigger4() {
  // Bedingung in Touch Press Event: printh 23 02 54 04
  digitalWrite(front_right_up, HIGH); // Erhöhung des Drucks im vorderen rechten Balg wird gestartet
}

void trigger5() {
  // Bedingung in Touch Release Event: printh 23 02 54 05
  digitalWrite(front_right_up, LOW); // Erhöhung des Drucks im vorderen rechten Balg wird gestoppt
}

void trigger6() {
  // Bedingung in Touch Press Event: printh 23 02 54 06
  digitalWrite(front_right_down, HIGH); // Ablassen des Drucks im vorderen rechten Balg wird gestartet
}

void trigger7() {
  // Bedingung in Touch Release Event: printh 23 02 54 07
  digitalWrite(front_right_down, LOW); // Ablassen des Drucks im vorderen rechten Balg wird gestoppt
}

// Ansteuern der Magnetventile für die Vorderachse
void trigger8() {
  // Bedingung in Touch Press Event: printh 23 02 54 08
  digitalWrite(front_left_up, HIGH); // Erhöhung des Drucks im vorderen linken Balg wird gestartet
  digitalWrite(front_right_up, HIGH); // Erhöhung des Drucks im vorderen rechten Balg wird gestartet
}

void trigger9() {
  // Bedingung in Touch Release Event: printh 23 02 54 09
  digitalWrite(front_left_up, LOW); // Erhöhung des Drucks im vorderen linken Balg wird gestoppt
  digitalWrite(front_right_up, LOW); // Erhöhung des Drucks im vorderen rechten Balg wird gestoppt
}

void trigger10() {
  // Bedingung in Touch Press Event: printh 23 02 54 0A
  digitalWrite(front_left_down, HIGH); // Ablassen des Drucks im vorderen linken Balg wird gestartet
  digitalWrite(front_right_down, HIGH); // Ablassen des Drucks im vorderen rechten Balg wird gestartet
}

void trigger11() {
  // Bedingung in Touch Release Event: printh 23 02 54 0B
  digitalWrite(front_left_down, LOW); // Ablassen des Drucks im vorderen linken Balg wird gestoppt
  digitalWrite(front_right_down, LOW); // Ablassen des Drucks im vorderen rechten Balg wird gestoppt
}

// Ansteuern der Magnetventile für hinten links
void trigger12() {
  // Bedingung in Touch Press Event: printh 23 02 54 0C
  digitalWrite(rear_left_up, HIGH); // Erhöhung des Drucks im hinteren linken Balg wird gestartet
}

void trigger13() {
  // Bedingung in Touch Release Event: printh 23 02 54 0D
  digitalWrite(rear_left_up, LOW); // Erhöhung des Drucks im hinteren linken Balg wird gestoppt
}

void trigger14() {
  // Bedingung in Touch Press Event: printh 23 02 54 0E
  digitalWrite(rear_left_down, HIGH); // Ablassen des Drucks im hinteren linken Balg wird gestartet
}

void trigger15() {
  // Bedingung in Touch Release Event: printh 23 02 54 0F
  digitalWrite(rear_left_down, LOW); // Ablassen des Drucks im hinteren linken Balg wird gestoppt
}

// Ansteuern der Magnetventile für hinten rechts
void trigger16() {
  // Bedingung in Touch Press Event: printh 23 02 54 10
  digitalWrite(rear_right_up, HIGH); // Erhöhung des Drucks im hinteren rechten Balg wird gestartet
}

void trigger17() {
  // Bedingung in Touch Release Event: printh 23 02 54 11
  digitalWrite(rear_right_up, LOW); // Erhöhung des Drucks im hinteren rechten Balg wird gestoppt
}

void trigger18() {
  // Bedingung in Touch Press Event: printh 23 02 54 12
  digitalWrite(rear_right_down, HIGH); // Ablassen des Drucks im hinteren rechten Balg wird gestartet
}

void trigger19() {
  // Bedingung in Touch Release Event: printh 23 02 54 13
  digitalWrite(rear_right_down, LOW); // Ablassen des Drucks im hinteren rechten Balg wird gestoppt
}

// Ansteuern der Magnetventile für die Hinterachse
void trigger20() {
  // Bedingung in Touch Press Event: printh 23 02 54 14
  digitalWrite(rear_left_up, HIGH); // Erhöhung des Drucks im hinteren linken Balg wird gestartet
  digitalWrite(rear_right_up, HIGH); // Erhöhung des Drucks im hinteren rechten Balg wird gestartet
}

void trigger21() {
  // Bedingung in Touch Release Event: printh 23 02 54 15
  digitalWrite(rear_left_up, LOW); // Erhöhung des Drucks im hinteren linken Balg wird gestoppt
  digitalWrite(rear_right_up, LOW); // Erhöhung des Drucks im hinteren rechten Balg wird gestoppt
}

void trigger22() {
  // Bedingung in Touch Press Event: printh 23 02 54 16
  digitalWrite(rear_left_down, HIGH); // Ablassen des Drucks im hinteren linken Balg wird gestartet
  digitalWrite(rear_right_down, HIGH); // Ablassen des Drucks im hinteren rechten Balg wird gestartet
}

void trigger23() {
  // Bedingung in Touch Release Event: printh 23 02 54 17
  digitalWrite(rear_left_down, LOW); // Ablassen des Drucks im hinteren linken Balg wird gestoppt
  digitalWrite(rear_right_down, LOW); // Ablassen des Drucks im hinteren rechten Balg wird gestoppt
}
13

Hallo hawe07546,

welchen Simulator meinst du denn?

14

Den debug-Mode im Nextion-Editor.
Hier sieht man die Kommunikation zwischen Display und serieller Schnittstelle. Du kannst die Befehle zum Display sogar per "Hand" eingeben, brauchst also nicht mal das Board zum testen. Und auch das Display nicht, dieses simuliert die Anwendung ebenfalls.

Ich habe so die komplette Kommunikation Controller <-> Display vorher getestet, zumal ich in Richtung Controller ein eigenes Protokoll verwende.

Kannte ich nicht, muss ich mir mal anschauen. Auf den ersten Blick sieht es aus, als könnte man damit lediglich Trigger auslösen.

cu