ESP32 - Temperaturmesswert in HTML-Seite ausgeben

Moin,
ich habe das Beispiel des Advanced Webserver genommen und will eigentlich statt der Uptime einfach die Temperatur des Temperatursensors ausgeben. Nur bekomme ich den Wert von
sensors.getTempC(sensor1)
nicht an eine Variable übergeben, die ich dann im HTML-Code hinter

Temperatur:

ausgeben könnte.

Hat da jemand eine Idee? Ich habe schon viele Beispiele zu diesem Thema gefunden, aber die verstehe ich nicht. Die Uptime wird ja auch regelmäßig über eine Variable aktualisiert, das müsste doch mit der Temperatur aus dem Messfühler auch gehen, oder?

Aber die Syntax von

<p>Uptime: %02d:%02d:%02d</p>\

verstehe ich leider auch nicht.

/*
   Copyright (c) 2015, Majenko Technologies
   All rights reserved.

   Redistribution and use in source and binary forms, with or without modification,
   are permitted provided that the following conditions are met:

 * * Redistributions of source code must retain the above copyright notice, this
     list of conditions and the following disclaimer.

 * * Redistributions in binary form must reproduce the above copyright notice, this
     list of conditions and the following disclaimer in the documentation and/or
     other materials provided with the distribution.

 * * Neither the name of Majenko Technologies nor the names of its
     contributors may be used to endorse or promote products derived from
     this software without specific prior written permission.

   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
   ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
   ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <ESPmDNS.h>
#include <OneWire.h>
#include <DallasTemperature.h>

const char *ssid = "FRITZ!Box 7590";
const char *password = "xxxxxxxxx";

WebServer server(80);

const int led = 13;
// Data wire is connected to GPIO15
#define ONE_WIRE_BUS 15
// Setup a oneWire instance to communicate with a OneWire device
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);

DeviceAddress sensor1 = { 0x28, 0x84, 0x63, 0x49, 0xF6, 0x54, 0x3C, 0x9 };

void handleRoot() {
  digitalWrite(led, 1);
  char temp[400];
  int sec = millis() / 1000;
  int min = sec / 60;
  int hr = min / 60;

  snprintf(temp, 400,
  "<html>\
  <head>\
    <meta http-equiv='refresh' content='5'/>\
    <title>ESP32 Demo</title>\
    <style>\
      body { background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }\
    </style>\
  </head>\
  <body>\
    <h1>Hello from ESP32!</h1>\
    <p>Temperatur:</p>\
    <p>Uptime: %02d:%02d:%02d</p>\
    <img src=\"/test.svg\" />\
  </body>\
</html>",

           hr, min % 60, sec % 60
          );
  server.send(200, "text/html", temp);
  digitalWrite(led, 0);
}

void handleNotFound() {
  digitalWrite(led, 1);
  String message = "File Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += (server.method() == HTTP_GET) ? "GET" : "POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";

  for (uint8_t i = 0; i < server.args(); i++) {
    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
  }

  server.send(404, "text/plain", message);
  digitalWrite(led, 0);
}

void setup(void) {
  pinMode(led, OUTPUT);
  digitalWrite(led, 0);
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.println("");

  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());

  if (MDNS.begin("esp32")) {
    Serial.println("MDNS responder started");
  }

  server.on("/", handleRoot);
  server.on("/test.svg", drawGraph);
  server.on("/inline", []() {
    server.send(200, "text/plain", "this works as well");
  });
  server.onNotFound(handleNotFound);
  server.begin();
  Serial.println("HTTP server started");
}

void loop(void) {
  server.handleClient();
  delay(2);//allow the cpu to switch to other tasks
}

void drawGraph() {
  String out = "";
  char temp[100];
  out += "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" width=\"400\" height=\"150\">\n";
  out += "<rect width=\"400\" height=\"150\" fill=\"rgb(250, 230, 210)\" stroke-width=\"1\" stroke=\"rgb(0, 0, 0)\" />\n";
  out += "<g stroke=\"black\">\n";
  int y = rand() % 130;
  for (int x = 10; x < 390; x += 10) {
    int y2 = rand() % 130;
    sprintf(temp, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" stroke-width=\"1\" />\n", x, 140 - y, x + 10, 140 - y2);
    out += temp;
    y = y2;
  }
  out += "</g>\n</svg>\n";

  server.send(200, "image/svg+xml", out);
}

Ich nutze gerne Esp32 Webserver Arduino Tab. Eventuell hilft meine Anleitung: Einführung zu fipsok.de

Lesestoff: printf und snprintf.

Du mußt die Formatierung und die Variablen zusammen betrachten.

Danke, aber ich verstehe es nicht. Mir ist immer noch nicht klar, was snprintf macht.

Ist es denn überhaupt möglich, eine variable oben im HTML-Code auszugeben? Wenn es mit der Uptime geht, müsste es ja auch mit anderen variablen gehen, oder?

Gruß,
Moritz

Die Syntax von

char buffer[30];
int wert= 4;
snprintf(buffer, sizeof (buffer)," wert ist  %d ", wert);
Serial.println(buffer);

ist eventuell einfacher, aber eigentlich dieselbe.
Stichworte: printf Formatanweisung %d %2d %02d

Hallo

esrtens habe ich die Stelle nicht gefunden wo die Temperatur vom Sensor eingelesen wir. Schau dir das noch mal in dem Beispiel "Simple" an wie man das macht.

Wenn Du dann die Temperatur in einer Variabeln hast und auf dem Monitor mit
Serial.print(temperatur) anzeigen kannst geht es weiter.

mit
sprintf(buffer ,"Text %f ",wert)
wird eine Zeichenkette buffer gebildet bei der an der Stelle %f der zahlenwert für die float Variable wert eingesetzt wird. bei Dir steht da temp das ist aber nicht die tempeartur sonder die Zeichenkette die ausgegebe werden soll.
Versuch mal

<h1>Hello from ESP32!</h1>\
    <p>Temperatur: %4.2f</p>\
    <p>Uptime: %02d:%02d:%02d</p>\

und dann am Ende

temperatur, hr, min % 60, sec % 60

https://cplusplus.com/reference/cstdio/sprintf/?kw=sprintf
https://cplusplus.com/reference/cstdio/printf/

Hallo Michael,
aber was bedeutet das jetzt? Kann ich damit nun eine Variable in den HTML-Code übergeben?
Und wenn ja, wie müsste ich das dann entsprechend erweitern?

Hallo Rentner,
danke, das verstehe ich jetzt, denke ich.

Die Temperatur wird mit
sensors.getTempC(sensor1)
ausgelesen, also dann mit Übergabe an Variable müsste das dann
float Temperatur = sensors.getTempC(sensor1):
lauten.

Ich teste das gleich mal.

Moin,
das funktioniert, nur wird die Variable "temperatur" nicht aktualisiert. Dazu müsste ich die Variable wohl als globale Variable definieren und dann in einem Loop regelmäßig die aktuelle Temperatur überschreiben. Aber das ist mir noch nicht klar, wie ich die Variable als globale Variable definieren muss.

/*
   Copyright (c) 2015, Majenko Technologies
   All rights reserved.

   Redistribution and use in source and binary forms, with or without modification,
   are permitted provided that the following conditions are met:

 * * Redistributions of source code must retain the above copyright notice, this
     list of conditions and the following disclaimer.

 * * Redistributions in binary form must reproduce the above copyright notice, this
     list of conditions and the following disclaimer in the documentation and/or
     other materials provided with the distribution.

 * * Neither the name of Majenko Technologies nor the names of its
     contributors may be used to endorse or promote products derived from
     this software without specific prior written permission.

   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
   ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
   ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <WiFi.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <ESPmDNS.h>
#include <OneWire.h>
#include <DallasTemperature.h>

const char *ssid = "FRITZ!Box 7590";
const char *password = "xxxxxxxxxxx";

WebServer server(80);

const int led = 13;
	
// Data wire is connected to GPIO15
#define ONE_WIRE_BUS 15
// Setup a oneWire instance to communicate with a OneWire device
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);

DeviceAddress sensor1 = { 0x28, 0x84, 0x63, 0x49, 0xF6, 0x54, 0x3C, 0x9 };

void handleRoot() {
  digitalWrite(led, 1);
  char temp[400];
  int sec = millis() / 1000;
  int min = sec / 60;
  int hr = min / 60;
  float temperatur = sensors.getTempC(sensor1);

  snprintf(temp, 400,
  "<html>\
  <head>\
    <meta http-equiv='refresh' content='5'/>\
    <title>ESP32 Demo</title>\
    <style>\
      body { background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }\
    </style>\
  </head>\
  <body>\
    <h1>Hello from ESP32!</h1>\
    <p>Temperatur: %4.2f</p>\
    <p>Uptime: %02d:%02d:%02d</p>\
    <img src=\"/test.svg\" />\
  </body>\
</html>",

           temperatur, hr, min % 60, sec % 60
          );
  server.send(200, "text/html", temp);
  digitalWrite(led, 0);
}

void handleNotFound() {
  digitalWrite(led, 1);
  String message = "File Not Found\n\n";
  message += "URI: ";
  message += server.uri();
  message += "\nMethod: ";
  message += (server.method() == HTTP_GET) ? "GET" : "POST";
  message += "\nArguments: ";
  message += server.args();
  message += "\n";

  for (uint8_t i = 0; i < server.args(); i++) {
    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
  }

  server.send(404, "text/plain", message);
  digitalWrite(led, 0);
}

void setup(void) {
  pinMode(led, OUTPUT);
  digitalWrite(led, 0);
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.println("");

  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());

  if (MDNS.begin("esp32")) {
    Serial.println("MDNS responder started");
  }

  server.on("/", handleRoot);
  server.on("/test.svg", drawGraph);
  server.on("/inline", []() {
    server.send(200, "text/plain", "this works as well");
  });
  server.onNotFound(handleNotFound);
  server.begin();
  Serial.println("HTTP server started");
}

void loop(void) {
  server.handleClient();
  delay(2);//allow the cpu to switch to other tasks
}

void drawGraph() {
  String out = "";
  char temp[100];
  out += "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" width=\"400\" height=\"150\">\n";
  out += "<rect width=\"400\" height=\"150\" fill=\"rgb(250, 230, 210)\" stroke-width=\"1\" stroke=\"rgb(0, 0, 0)\" />\n";
  out += "<g stroke=\"black\">\n";
  int y = rand() % 130;
  for (int x = 10; x < 390; x += 10) {
    int y2 = rand() % 130;
    sprintf(temp, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" stroke-width=\"1\" />\n", x, 140 - y, x + 10, 140 - y2);
    out += temp;
    y = y2;
  }
  out += "</g>\n</svg>\n";

  server.send(200, "image/svg+xml", out);
}
void loop(void){ 
  Serial.print("Requesting temperatures...");
  sensors.requestTemperatures(); // Send the command to get temperatures
  Serial.println("DONE");
  
  Serial.print("Sensor 1(*C): ");
  Serial.print(sensors.getTempC(sensor1)); 
  float temperatur = sensors.getTempC(sensor1);
  delay(2000);
}

Danke an alle,
die Ausgabe der Temperatur incl. Refresh der Temperatur vom Messfühler funktioniert jetzt!

Gruß

Das freut mich, Danke für die Rückmeldung!

Ein öffentliches Forum lebt vom Nehmen und Geben, daher wäre es für Mitleser hilfreich, wenn Du Deine Lösung hier zeigst. Wenn Du es dann noch als gelöst markierst, weiß der Suchende, hier gibt es nicht nur eine Frage, sondern auch eine Lösung.

Anregungen:

  • Dein Passwort Deiner Fritz!Box ist nun öffentlich, das solltest Du also unbedingt ändern :bangbang:
  • Der ESP32 hat SPIFFS oder LittleFS als Dateisystem, da kannst Du HTML-Dateien ablegen und den Datenupdate beispielsweise per JSON machen, anstatt immer eine ganze Datei zu verschicken.
  • Neue Temperaturen mittels <meta http-equiv='refresh' content='5'/> ist vollkommen OK, manchmal soll aber der Webserver die Initiative ergreifen können. Dazu siehe Stichwort Websockets.

Viel Spaß :slightly_smiling_face:

Moin,
danke für die Hinweise! Die Lösung Stelle ich noch ein!

Gruß
Moritz

Moin zusammen,
also kurz erst mal die Aufgabenstellung:

Ziel: Der Wert von mehreren Temperatur-Sensoren soll auf einer kleinen Webseite ausgegeben und in einem festen Zyklus aktualisiert werden.

Sensoren: 3 x DS18B20

Basis-Programme:

  • Zum Auslesen der Sensor-IDs habe ich den Beispiel-Sketch von ESP32 with Multiple DS18B20 Temperature Sensors | Random Nerd Tutorials verwendet. Damit werden die Sensor-IDs im Serial Monitor ausgegeben. Am besten die Sensoren durchnummerieren, mit Silber-Edding auf den Sensoren die Nummer markieren. Vorteil der digitalen Sensoren ist, dass alle parallel an einem GPIO angeschlossen und über ihre Adresse getrennt ausgelesen werden können.
  • Als Web-Server habe ich den Advanced Webserver von Majenko Technologies verwendet, der in der Arduino IDE zur Verfügung steht.
  • Für die Sensoren sind die Bibliotheken OneWire und DallasTemperature einzubinden.

Das Programm
Im Hauptprogramm sind die Libraries zu ergänzen:

#include <OneWire.h>
#include <DallasTemperature.h>

Als nächstes ebenso dort werden die Sensoren und der GPIO Port definiert, an dem die Sensoren angeschlossen sind. Die Temperatur-Variablen sind so global definiert und ich kann sie in einer Unterroutine mit einem neuen Wert überschreiben:

// Data wire is connected to GPIO15
#define ONE_WIRE_BUS 15
// Setup a oneWire instance to communicate with a OneWire device
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);

DeviceAddress sensor1 = { 0x28, 0x41, 0x6B, 0x49, 0xF6, 0x4D, 0x3C, 0x1D };
DeviceAddress sensor2 = { 0x28, 0x84, 0x63, 0x49, 0xF6, 0x54, 0x3C, 0x9 };
DeviceAddress sensor3 = { 0x28, 0x86, 0x57, 0x49, 0xF6, 0xC3, 0x3C, 0x51 };

float temperatur1 = sensors.getTempC(sensor1);
float temperatur2 = sensors.getTempC(sensor2);
float temperatur3 = sensors.getTempC(sensor3);

In der Anweisung snprintf(temp, 400, habe ich dann im HTML-Bereich folgende Ergänzung vorgenommen:

  <body>\
    <h1>Hello from ESP32!</h1>\
    <p>Temperatur 1: %2.1f</p>\
    <p>Temperatur 2: %2.1f</p>\
    <p>Temperatur 3: %2.1f</p>\
    <p>Uptime: %02d:%02d:%02d</p>\
    <img src=\"/test.svg\" />\
  </body>\
</html>",
           temperatur1, temperatur2, temperatur3, hr, min % 60, sec % 60
          );

und in der Unterroutine void loop(void) lese ich die Sensoren zyklisch aus, damit der neue Messwert an die Variablen temperatur1, temperatur2 und temperatur3 übergeben wird. Den delay kann man ruhig auf 2000 hochsetzen, da die Webseite eh nur alle 5 Sekunden refreshed wird.

  Serial.print("Sensor 1(*C): ");
  Serial.print(sensors.getTempC(sensor1)); 
  temperatur1 = sensors.getTempC(sensor1);
  Serial.print("Sensor 2(*C): ");
  Serial.print(sensors.getTempC(sensor2)); 
  temperatur2 = sensors.getTempC(sensor2);
  Serial.print("Sensor 3(*C): ");
  Serial.print(sensors.getTempC(sensor3)); 
  temperatur3 = sensors.getTempC(sensor3);
 delay(2000);//allow the cpu to switch to other tasks

Das war jetzt mein erstes selbst angepasstes Testprogramm. Ziel des ganzen wird aber sein, die manuelle Bypass-Klappe meiner Lüftungsanlage temperaturgesteuert von einem 3D-Drucker-Steppermotor (N42HS3418) öffnen und schließen zu lassen.

Also ich werde sicher noch weitere probleme haben, aber erst mal muss ich mich mit der Programmiersprache C vertraut machen.

Und so sieht das dann im Browser aus:

Die Grafik hat mit den Temperaturen noch nichts zu tun. Das könnte man natürlich auch irgendwie machen, dass die Temperaturmesswerte in eine Datei gespeichert und dann als Grafik ausgegeben werden. Ich werde da aber evtl. auf MQTT zurückgreifen und die Daten in meine InfluxDB schreiben und in Grafana ausgeben. Das ist aber noch Zukunftsmusik.

Gruß,
Moritz

Schau Dir den standardmäßig mit dem ESP32 ausgelieferten Webserver an.
Lege die statische Webseite ins SPIFFS/LittleFS und aktualisiere die Daten per Fetch-API.
Beispiele findest Du bei Fips.

Du musst C++ lernen.

Gruß Tommy

Hallo Tommy,
ja, um C++ hatte ich bisher immer erfolgreich einen Bogen machen können und mit Java, Basic, Pascal, batch etc. programmiert. C/C++ war mir immer etwas unhandlich. Aber da komme ich jetzt wohl nicht drumherum.

Gruß,
Moritz

Hier noch mein kleiner Testaufbau, der Motortreiber hat noch keine Funktion, ich habe den nur schon auf die kleine Platine gelötet, den brauche ich später für den Steppermotor.

Moin,
inzwischen bin ich schon viel weiter, als ich dachte. Über einen Timer kann ich nun die Abfrage-Frequenz der Temperatursensoren variieren:

  if (interruptCounter > 0) {
    Serial.print("Requesting temperatures...");
    sensors.requestTemperatures(); // Send the command to get temperatures
    Serial.print("Sensor 1(*C): ");
    Serial.print(sensors.getTempC(sensor1)); 
    temperatur1 = sensors.getTempC(sensor1);
    Serial.print("Sensor 2(*C): ");
    Serial.print(sensors.getTempC(sensor2)); 
    temperatur2 = sensors.getTempC(sensor2);
    Serial.print("Sensor 3(*C): ");
    Serial.print(sensors.getTempC(sensor3)); 
    temperatur3 = sensors.getTempC(sensor3);
    Serial.println("DONE");
    interruptCounter = 0;
    totalInterruptCounter = 0;
   }

Und den Motor lasse ich in Abhängigkeit von der temperatur1 in eine von drei verschiedenen Positionen fahren:

  if (temperatur1 < 25.0) {
    motor.moveTo(50);
    Serial.println("Move Motor in Position 50");
  }
  if (temperatur1 > 25.0 and temperatur1 < 27.0) {
    motor.moveTo(0);
    Serial.println("Move Motor in Position 0");
  }
  if (temperatur1 > 27.0) {
    motor.moveTo(-50);
    Serial.println("Move Motor in Position -50");
  }  
  motor.run();

Da der esp32 nach dem Einschalten nicht die Position des Motors kennt, werde ich noch einen Taster einbauen. Wird der esp32 eingeschaltet, muss der Motor dann erst in die Grundposition fahren, in der der Taster gedrückt ist. Das kennt man ja von den 3D-Druckern.

Danach ist die Position der Bypass-Klappe bekannt und ich kann an die Definition gehen, bei welchen Temperaturen der Sensoren die Klappe geöffnet oder geschlossen werden soll.

Gruß,
Moritz

Ich weiß zwar nicht, was uns diese Fragmente sagen wollen, wofür Du aber zur Zeitsteuerung meinst, einen Interrupt zu brauchen, erschließt sich mir nicht.
Schau Dir die Verwendung von millis() und das Beispiel BlinkWihoutDelay in der IDE an (und verstehe es)
Man kann den DS18S20 auch unblockierend abfragen. (setWaitForConversion), muss dann nur die Messzeit selbst steuern.
Warum fragst Du jede Temperatur 2 Mal ab?

    temperatur2 = sensors.getTempC(sensor2);tippe oder füge den Code hier ein
   Serial.print(temperatur2); 

Gruß Tommy

Hallo Tommy,
habe etwas Nachsicht mit mir, ich programmiere erst seit gestern Abend C++, da wirst Du verstehen, dass ich mich nicht alle Funktionen kenne und verinnerlicht habe.

Du hast Recht, die doppelte Abfrage ist natürlich Unsinn, schmeiß ich raus.

Gruß
Moritz

Dann nimm die Anmerkungen als Denkanstöße für weiter gehende Beschäftigung.
Als solche waren sie auch gedacht.

Gruß Tommy

Moin,
Dank Eurer Hilfe bin ich jetzt schon sehr weit gekommen, der Schrittmotor dreht sich in Abhängigkeit der Temperaturen und entsprechender Regeln. Und auf der Webseite kann ich den Status ablesen.

Hier ein Screenshot von der Webseite:

Jetzt fehlt nur noch der Taster für die Initialisierung der Grundstellung und die Temperaturen bekommen noch die passende Beschreibung (Außentemperatur Zuluft, Raumtemperatur Abluft, Zulufttemperatur hinter Wärmetauscher).

Gruß
Moritz