Moin, ich verwende ein ESP32 und benutze die Bibliotheken
<WiFiWebServer.h>
<HX711.h>
<Ticker.h>
<SparkFun_MCP9600.h>
Seit dem ich die Bibliothek <WiFiWebServer.h> benutze hängt sich die LOOP beim verwenden des I2C auf. Dadurch braucht er ca. 2.5 Sekunden für den durchlauf einer Schleife. Hatte jemand das Problem schon einmal?Verwende dieses Symbol um Code zu posten
Nein, denn ich nutze WiFi.h und habe keine Probleme mit I²C.
Gibt es einen speziellen Grund, warum Du WiFiWebServer.h nutzt?
Einfach gesagt, wenn du deinen Sketch entsprechend der Beispiel schreibst und keine gravierenden Fehler einbaust, funktioniert WiFi und I2C zusammen fehlerfrei.
Zeige uns deinen aktuellen Sketch, evtl. finden wir darin Fehler, wie z.B. genutzte delay(), die deinen Sketch blockieren. Oder Schleifen, die auch Zeit kosten.
Ich habe ein Smooker (zum Grillen) gebaut der komplett automatisch läuft und die Temperatur regelt. Als Bedienteil dient ein Seeed 2.4 LCD Display. Der ESP der Regelung baut ein W-Lan netz auf und da loggt sich das Display ein. Dann übermittelt der ESP32 dem Seeed die Temperaturen und anders herum kann man mit dem Seeed die Temperaturen einstellen und alle Funktionen einzeln anfahren.
tippe oder füge den Co/////////////////////////W-Lan/////////////////////////////////////////////////7
#define USE_WIFI_NINA false
#include <WiFiWebServer.h>
#define SHIELD_TYPE "ESP WiFi using WiFi Library"
#define BOARD_TYPE "ESP32"
char ssid[] = "YOUR_SSID"; // Netzwerkname
char pass[] = "12345678"; // Passwort
int keyIndex = 0;
String antwort_str="";
String sende_str="";
int antwort=0;
int status = WL_IDLE_STATUS;
WiFiServer server(80);
void printWiFiStatus(){
// print your WiFi shield's IP address:
// print the SSID of the network you're attached to:
Serial.print(F("SSID: "));
Serial.println(WiFi.SSID());
IPAddress ip = WiFi.localIP();
Serial.print(F("IP Address: "));
Serial.println(ip);
}
///////////////////////Bibliotek////////////////////////////
#include <Ticker.h> //Blibliotek für Zeitlicher Interrupt
#include <HX711.h> //Bibliotek für WAAGE
//#include <Wire.h> //Wirs üfr den I2C BUS benötigt
#include <SparkFun_MCP9600.h>
Thermocouple_Type type = TYPE_K; //Temperatursensor auf den Type K festlegen
MCP9600 tempSensor;
///////////////////////Variablen für Ein und Ausgänge ////////////////////////////
//const int Waage = 22; //Wage für Brenngut
const int Unterdruck_P1 = 15; //Unterdrucksensor im Speicher
const int Unterdruck_P2 = 2; //Unterdrucksensor bei der Klappe
const int Relais1 = 13; //Relais Unterdruckpumpe
const int Relais2 = 19; //Relais Klappe zu
const int Relais4 = 22; //Relais Pelletförderung runter
const int Relais3 = 23; //Relais Pelletförderung hoch
const int Relais5 = 32; //Relais Klappe auf
const int Relais6 = 21; // Relais Grühstift
const int Relais7 = 27; //Relais Kühlung
const int Relais8 = 33; // Relais Luft
int Endschalter_oben = 34; // Endschalter für Pelletförderung
int Endschalter_unten = 35; // Endschalter für Pelletförderung
//_____________Pins für die Waage________________//
const int Waage_DOUT_PIN = 16;
const int Waage_SCK_PIN = 4;
//_____________Pins für den Füllstandssensor__________//
HX711 scale;
const int ECHO = 18;
const int TRIGGER = 5;
///////////////////////Variablen zum Merken oder Zwischenspeichern/////////////////////////////////////////////////////////7
int Zeit_Integral = 0;
int Zeit_Nachwurf = 110; //Zähler für die mindest Zeit für den Nachwurf
int Startvorgang = 1; //Merker für den Startvorgang
int Starten = 0;
int tacktungsrate; //Zum Zählen der Relais Einschaltdauer von Relais 2 und 3
int Pelletausgleich = 0;
int Zeitabschaltung = 0;
int Regeldifferenz = 0;
int Zwischengewicht = 0;
int Counter_Gewicht = 0;
int D_Anteil = 0;
float Temperatursteigung = 1;
float Temp_ALT = 0;
int D_Anteil_auf = 0;
int D_Anteil_zu = 0;
bool D_Regelung_zu = false;
bool D_Regelung_auf = false;
float Integral = 0;
int Mit_Kerntemperatur = 0;
int min_Pellets = 0;
int Service = 0;
int Zuluft = 0;
int Hoch = 0;
int Runter = 0;
int Auf = 0;
int Zu = 0;
int Gluen = 0;
int Pumpen = 0;
int Relais5_Status = 1;
int Relais4_Status = 1;
int Relais3_Status = 1;
int Relais2_Status = 1;
/////////////////////////////Sensorwerte//////////////////////////////////////////////////7
float Gartemperatur = 0; // Temperatur in der Gaarkammmer
float Kerntemperatur = 0; // Kerntemperatur
int Unterdruckwert_P1 = 0; //Analogwert vom Unterdrucksensor 1
int Unterdruckwert_P2 = 0; //Analogwert vom Unterdrucksensor 2
long Wiegenote = 0; //Wert vom der Waage
////////////////////////////Einstellbare Variablen///////////////////////////////////////////////////////7
int Zeitabschaltung_max = 50; //Die maximale Zeit in Sekunden für die Peletförderung
int Soll_Temperatur = 100;
int Soll_Kerntemperatur = 60;
int Pelletausgleich_max = 30; // Differrenz Zeit zwischen denn Nachwürfen wenn die Temperatur zu klein ist.
int Druck_max = 750; //Abschaltdruck von der Unterdruck Pumpe
int Druck_min = 600; //Startdruck von der Unterdruck Pumpe
float D = 1; //DAnteil zum einstellen des Reglers
int I = 1; //IAnteil zum einstellen des Reglers
int P = 50; //PAnteil zum einstellen des Reglers
int Zeit_Integral_Max = 5; //Zeit der X Achse um das Inegral zu berechnen
unsigned int distance;
unsigned long duration;
//////////////////////////////////Variablen mit Bedingung///////////////////////////////////////////////////////////
bool maximaler_Druck = false; //Wenn erfüllt dann Pumpe an
bool minimaler_Druck = false; //Wenn erfüllt dann pumpe aus
bool differenz_Druck = false; //Wenn erfüllt dann Pumpe an
bool Nachwurf_hoch = false; //Wenn erfüllt dann nachwurf hoch
bool Nachwurf_runter = false; //Wenn erfüllt dann nachwurf runter
bool Gluehstift = false; //Wenn erfüllt dan Glühstift an
bool Luft = false; //Wenn erfüllt Gebläse an
Ticker timer1; //Einbindung zeitlicher interrupt 1
Ticker timer2; //Einbindung zeitlicher interrupt 2
Ticker timer3; //Einbindung zeitlicher interrupt 3
Ticker timer4; //Einbindung zeitlicher interrupt 4
Ticker timer5; //Einbindung zeitlicher interrupt 5
////////////////////////////////////Stringntrennen//////////////////////////////////////////
int anz_felder(String sendestring,String trenner) {
int ret_wert=0;
int i=0;
while (i!=-1){
i=i+1;
i=sendestring.indexOf(trenner, i );
ret_wert=ret_wert+1;
}
return ret_wert;
}
String felder_trennen(String sendestring,String trenner,int pos) {
int ret_wert=-1;
int i=0;
int p=0;
String string_1="";
while (i!=-1){
i=i+1;
i=sendestring.indexOf(trenner, i );
ret_wert=ret_wert+1;
}
if(ret_wert<pos){
Serial.println("Fehler, Feldposition nicht vorhanden");
string_1="";
}
else{
string_1 = sendestring.substring(0, sendestring.indexOf(trenner, 0 ));
if(pos>0){
while(p!=pos){
sendestring = sendestring.substring(sendestring.indexOf(trenner, 0 ) + 1, sendestring.length());
string_1 = sendestring.substring(0, sendestring.indexOf(trenner, 0 ));
p=p+1;
}
}
}
return string_1;
}
String wertfinden_setzen(String eingabe_str){
String sensorname_str="";
String art_str="";
String werte_str="";
String ausgang_str="";
art_str=antwort_str=felder_trennen(eingabe_str,"$",0); // Lesen oder Schreiben?
if(art_str=="lesen"){
sensorname_str=felder_trennen(eingabe_str,"$",1);
if(sensorname_str=="Gartemperatur"){
ausgang_str="senden$Gartemperatur$"+String(Gartemperatur);
Serial.println("Anforderung für Gartemperatur : "+ausgang_str);
}
if(sensorname_str=="Kerntemperatur"){
ausgang_str="senden$Kerntemperatur$"+String(Kerntemperatur);
Serial.println("Anforderung für Kerntemperatur : "+ausgang_str);
}
if(sensorname_str=="distance"){
ausgang_str="senden$kdistance$"+String(distance);
Serial.println("Anforderung für distance : "+ausgang_str);
}
if(sensorname_str=="kern_soll_temp"){
ausgang_str="senden$Soll_Kerntemperatur$"+String(Soll_Kerntemperatur);
Serial.println("Anforderung für Soll_Kerntemperatur : "+ausgang_str);
}
if(sensorname_str=="Startvorgang"){
ausgang_str="senden$Startvorgang$"+String(Startvorgang);
Serial.println("Anforderung für Startvorgang : "+ausgang_str);
}
if(sensorname_str=="Starten"){
ausgang_str="senden$Starten$"+String(Starten);
Serial.println("Anforderung für Starten : "+ausgang_str);
}
if(sensorname_str=="Mit_Kerntemperatur"){
ausgang_str="senden$Mit_Kerntemperatur$"+String(Mit_Kerntemperatur);
Serial.println("Anforderung für Mit_Kerntemperatur : "+ausgang_str);
}
if(sensorname_str=="Soll_Temperatur"){
ausgang_str="senden$Soll_Temperatur$"+String(Soll_Temperatur);
Serial.println("Anforderung für Soll_Temperaturt : "+ausgang_str);
}
if(sensorname_str=="Service"){
ausgang_str="senden$Service$"+String(Service);
Serial.println("Anforderung für Service : "+ausgang_str);
}
if(sensorname_str=="ZUluft"){
ausgang_str="senden$Luft$"+String(Zuluft);
Serial.println("Anforderung für Zuluft : "+ausgang_str);
}
if(sensorname_str=="Hoch"){
ausgang_str="senden$Hoch$"+String(Hoch);
Serial.println("Anforderung für Hoch : "+ausgang_str);
}
if(sensorname_str=="Runter"){
ausgang_str="senden$Runter$"+String(Runter);
Serial.println("Anforderung für Runter : "+ausgang_str);
}
if(sensorname_str=="Auf"){
ausgang_str="senden$Auf$"+String(Auf);
Serial.println("Anforderung für Auf : "+ausgang_str);
}
if(sensorname_str=="Zu"){
ausgang_str="senden$Zu$"+String(Zu);
Serial.println("Anforderung für Zu : "+ausgang_str);
}
if(sensorname_str=="Gluen"){
ausgang_str="senden$Gluen$"+String(Gluen);
Serial.println("Anforderung für Gluen : "+ausgang_str);
}
if(sensorname_str=="Pumpen"){
ausgang_str="senden$Pumpen$"+String(Pumpen);
Serial.println("Anforderung für Pumpen : "+ausgang_str);
}
}
if(art_str=="schreiben"){
Serial.println("Eingabe_str:"+eingabe_str);
sensorname_str=felder_trennen(eingabe_str,"$",1);
if(sensorname_str=="Soll_Temperatur"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Soll_Temperatur=werte_str.toFloat();
Serial.println("Schreibe Soll_Temperatur: "+antwort_str);
}
if(sensorname_str=="Soll_Kerntemperatur"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Soll_Kerntemperatur=werte_str.toFloat();
Serial.println("Soll_Kerntemperatur: "+antwort_str+" "+String(Soll_Kerntemperatur));
}
if(sensorname_str=="Starten"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Starten=werte_str.toInt();
Serial.println("Starten: "+antwort_str+" "+String(Starten));
}
if(sensorname_str=="Service"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Service=werte_str.toInt();
Serial.println("Service: "+antwort_str+" "+String(Service));
}
if(sensorname_str=="Zuluft"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Zuluft=werte_str.toInt();
Serial.println("Zuluft: "+antwort_str+" "+String(Zuluft));
}
if(sensorname_str=="Hoch"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Hoch=werte_str.toInt();
Serial.println("Hoch: "+antwort_str+" "+String(Hoch));
}
if(sensorname_str=="Runter"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Runter=werte_str.toInt();
Serial.println("Runter: "+antwort_str+" "+String(Runter));
}
if(sensorname_str=="Auf"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Auf=werte_str.toInt();
Serial.println("Auf: "+antwort_str+" "+String(Auf));
}
if(sensorname_str=="Zu"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Zu=werte_str.toInt();
Serial.println("Zu: "+antwort_str+" "+String(Zu));
}
if(sensorname_str=="Gluen"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Gluen=werte_str.toInt();
Serial.println("Gluen: "+antwort_str+" "+String(Gluen));
}
if(sensorname_str=="Pumpen"){
werte_str=felder_trennen(eingabe_str,"$",2);
ausgang_str=antwort_str+"$OK";
Pumpen=werte_str.toInt();
Serial.println("Pumpen: "+antwort_str+" "+String(Pumpen));
}
}
return ausgang_str;
}
void verbindung_bedienteil(){
WiFiClient client = server.available();
while (client) {
Serial.println("New client");
String currentLine = "";
while (client.connected()) {
// loop while the client's connected
while(client.available()) {
char c = client.read();
currentLine=currentLine+c;
}
if (currentLine.length() > 0) {
Serial.println("Eingang vom Client: "+currentLine);
if(felder_trennen(currentLine,"&",0)=="sammelanfrage"){
int ret_wert=0;
int i=0;
ret_wert=anz_felder(currentLine,"&");
sende_str="sammelantwort";
for(int i=1; i < ret_wert; i++){
Serial.println("Sammelabfrage: "+felder_trennen(currentLine,"&",i));
sende_str=sende_str+"&"+wertfinden_setzen(felder_trennen(currentLine,"&",i));
}
}
else{
sende_str=wertfinden_setzen(currentLine);
}
client.println(sende_str);
Serial.println("Sammelantwort: "+sende_str);
Serial.println(F("Client disconnected"));
// close the connection:
client.stop();
}
}
}
}
void setup() {
Wire.begin(25, 26); // SDA = GPIO 25, SCL = GPIO 26
Wire.setClock(100000);
tempSensor.begin(0X65);
tempSensor.begin(0x67);
scale.begin(Waage_DOUT_PIN, Waage_SCK_PIN);
Serial.begin(9600);
while (!Serial && millis() < 5000);
WiFi.softAP(ssid,pass);
server.begin();
printWiFiStatus();
digitalWrite(Relais1, HIGH);
digitalWrite(Relais2, HIGH);
digitalWrite(Relais3, HIGH);
digitalWrite(Relais4, HIGH);
digitalWrite(Relais5, HIGH);
digitalWrite(Relais6, HIGH);
digitalWrite(Relais7, HIGH);
digitalWrite(Relais8, HIGH);
Relais4_Status = 1;
Relais3_Status = 1;
pinMode(Relais1, OUTPUT);
pinMode(Relais2, OUTPUT);
pinMode(Relais3, OUTPUT);
pinMode(Relais4, OUTPUT);
pinMode(Relais5, OUTPUT);
pinMode(Relais6, OUTPUT);
pinMode(Relais7, OUTPUT);
pinMode(Relais8, OUTPUT);
pinMode(TRIGGER, OUTPUT);
pinMode(ECHO, INPUT);
pinMode(Endschalter_oben, INPUT);
pinMode(Endschalter_unten, INPUT);
pinMode(Unterdruck_P1, INPUT);
pinMode(Unterdruck_P2, INPUT);
timer1.attach(2.5, Ausgabe); // Interrupt alle 2 Sekunden auslösen
timer2.attach(5.0, Temperaturregelung);
timer3.attach(0.02, Ventiltacktung);
timer4.attach(120, Start);
timer5.attach(1, Timer);
//////////////////Temperatursensor///////////////////////////
}
////////////Manuelles fahren aller Funktionen///////////777
void Manuel(){
if (Service == 1){
if (Zuluft == 1){
digitalWrite(Relais8, LOW);
}
else {digitalWrite(Relais3, HIGH);}
if (Hoch == 0){
digitalWrite(Relais3, LOW);
}
else {digitalWrite(Relais3, HIGH);}
if(Runter == 0){
digitalWrite(Relais4, LOW);
}
else {digitalWrite(Relais4, HIGH);}
if(Auf == 0){
digitalWrite(Relais5, LOW);
}
else {digitalWrite(Relais5, HIGH);}
if (Zu == 0){
digitalWrite(Relais2, LOW);
}
else {digitalWrite(Relais2, HIGH);}
if(Gluen == 0){
digitalWrite(Relais6, LOW);
}
else {digitalWrite(Relais6, HIGH);}
if(Pumpen == 0){
digitalWrite(Relais1, LOW);
}
else {digitalWrite(Relais1, HIGH);}
}
else{
//Alle Ausgänge auf aus setzen
digitalWrite(Relais1, HIGH);
digitalWrite(Relais2, HIGH);
digitalWrite(Relais3, HIGH);
digitalWrite(Relais4, HIGH);
digitalWrite(Relais5, HIGH);
digitalWrite(Relais6, HIGH);
digitalWrite(Relais8, HIGH);
/////Setzen aller Variablen auf 0
Zuluft = 0;
Hoch = 0;
Runter = 0;
Auf = 0;
Zu = 0;
Gluen = 0;
Pumpen = 0;
}
}
///////////////Wertetabelle für den Pelletnachwurf, damit das System nah an der Systemgrenze ist////////////////////
void Pelletgewicht(){
if (Soll_Temperatur<85){min_Pellets=-70;}
if ((Soll_Temperatur>=85)&&(Soll_Temperatur<100)){min_Pellets=-30;}
if ((Soll_Temperatur>=100)&&(Soll_Temperatur<120)){min_Pellets=-10;}
if ((Soll_Temperatur>=120)&&(Soll_Temperatur<150)){min_Pellets=-0;}
if ((Soll_Temperatur>=150)&&(Soll_Temperatur<175)){min_Pellets=25;}
if (Soll_Temperatur>=175){min_Pellets=50;}
}
void Sensoren(){
Wire.begin(); // SDA = GPIO 25, SCL = GPIO 26
tempSensor.begin(0X65);
Kerntemperatur = tempSensor.getThermocoupleTemp(0X65);
tempSensor.begin(0X67);
Kerntemperatur = tempSensor.getThermocoupleTemp(0X67);
Unterdruckwert_P1 = analogRead(Unterdruck_P1);
Unterdruckwert_P2 = analogRead(Unterdruck_P2);
Zwischengewicht = scale.get_units(); //Auslesen der Waage
Zwischengewicht = Zwischengewicht / 1000; //Durch das Teilen in eine hendelbare größe bringen
//////Wenn Zwischengewicht größer alls minndest Pellets sind, wird das Zwischengewicht direkt als Wigenote gesetzt
if (Zwischengewicht > min_Pellets){
Wiegenote = Zwischengewicht;
Counter_Gewicht = 0;
}
if (Zwischengewicht <= 50){
Counter_Gewicht++;
if(Counter_Gewicht >= 250){
if (Zwischengewicht >-300){
Wiegenote = Zwischengewicht;
Counter_Gewicht = 0;
}
}
}
}
void loop() {
Serial.print("Starten");
Serial.println(Starten);
Pelletgewicht();
Sensoren();
Manuel();
////////////////////////////////////Setzen der Variablen mit Bedingung////////////////////////////////////////////////
////////////////////////Unterdruck Regelung////////////////////////////////////
if(Starten == 1){
digitalWrite(Relais7, LOW); // Kühlung vom Fördermotor
if (Unterdruckwert_P1 >= Druck_max) {
maximaler_Druck = false;
}
else if (Unterdruckwert_P1 <= Druck_min){
maximaler_Druck = true;
}
if (Unterdruck_P2 + 100 < Unterdruck_P1) {
differenz_Druck = true;
}
else if (Unterdruckwert_P1 >= Druck_max){
differenz_Druck = false;
}
/////////////////////////Regelung Nachwurf/////////////////////////////////////
if ((Wiegenote <= min_Pellets && Zeit_Nachwurf > 60 )||(Zeit_Nachwurf > 1000)){
Nachwurf_hoch = true;
}
else if (digitalRead(Endschalter_oben) == 0){
Nachwurf_hoch = false;
}
if (digitalRead(Endschalter_oben) == 1 && (Relais3_Status == 0)){
Nachwurf_runter = true;
Zeit_Nachwurf = 0;
Nachwurf_hoch = false;
Zeitabschaltung = 0;
}
else if ((digitalRead(Endschalter_unten) == 1 && Relais4_Status == 0)){
Nachwurf_runter = false;
Zeitabschaltung = 0;
}
///////////////////Startvorgang//////////////////////////////////////////////
if (Startvorgang == 0){
Nachwurf_hoch = true;
digitalWrite(Relais5, LOW);
Gluehstift = true;
}
else if (Startvorgang == 1){
Gluehstift = false;
}
/////////////////////////Ausführung der Variablen mit Bedingung////////////////
if (Gluehstift == true){
digitalWrite(Relais5, LOW);
digitalWrite(Relais6, LOW);
}
else if (Gluehstift == false){
digitalWrite(Relais5, HIGH);
digitalWrite(Relais6, HIGH);
}
if (Luft == true){
digitalWrite(Relais8, LOW);
}
else if (Luft == false){
digitalWrite(Relais8, HIGH);
}
if ((maximaler_Druck == true) && (Relais3_Status == 1 && Relais4_Status == 1)) {
digitalWrite(Relais1, LOW);
}
if((differenz_Druck == true) && (Relais3_Status == 1 && Relais4_Status == 1)){
digitalWrite(Relais1, LOW);
}
if ((maximaler_Druck == false) || (Relais3_Status == 0 && Relais4_Status == 0)){
digitalWrite(Relais1, HIGH);
}
if ( Nachwurf_hoch == true){
digitalWrite(Relais3, LOW);
Relais3_Status = 0;
}
if (Nachwurf_runter == true){
digitalWrite(Relais3, HIGH);
Relais3_Status = 1;
digitalWrite(Relais4, LOW);
Relais4_Status = 0;
}
if (digitalRead(Endschalter_unten) == 1 && Relais4_Status == 0){
digitalWrite(Relais4, HIGH);
Relais4_Status = 1;
Zeitabschaltung = 0;
}
}
}
///////////////////////Zeitlicher Interrrupt 1////////////////////////////
void Timer(){
if(Starten == 1){
Zeit_Nachwurf ++;
Zeit_Integral ++;
/////////____________________________Berechen des Integrals____________________________________
if (Zeit_Integral >= Zeit_Integral_Max){
Temperatursteigung = Temp_ALT-Gartemperatur;
Integral = ((Zeit_Integral*Temperatursteigung)/2)*I;
if (Integral < 0){
Integral=Integral*-1;
}
Temp_ALT = Gartemperatur;
Zeit_Integral = 0;
}
}
}
////////////////////////////////Zur Ausgabe div. Variablen Seriell.////////////////////////////////
void Ausgabe() {
verbindung_bedienteil(); /////////Void für das Bedienteil
Serial.print("Starten");
Serial.println(Starten);
if(Starten == 1){
Serial.print(D_Anteil_auf);
Serial.print(",");
Serial.print(D_Anteil_zu);
Serial.print(",");
Serial.print("Wiegenote ");
Serial.print(",");
Serial.print(Wiegenote);
Serial.print(",");
Serial.print("Unterdruckwert_P1 ");
Serial.print(",");
Serial.print(Unterdruckwert_P1);
Serial.print(",");
Serial.print("Unterdruckwert_P2 ");
Serial.print(",");
Serial.print(Unterdruckwert_P2);
Serial.print(",");
Serial.print(Starten);
Serial.print(",");
Serial.print(Gartemperatur);
Serial.print(",");
Serial.println(Kerntemperatur);
digitalWrite(TRIGGER, LOW);
delayMicroseconds(2);
digitalWrite(TRIGGER, HIGH);
delayMicroseconds(10);
duration = pulseIn(ECHO, HIGH);
distance = duration/58;
// Serial.println("Distance to object: " + String(distance) + " cm");
}
}
///////////////////////Zeitlicher Interrrupt 3////////////////////////////
void Ventiltacktung() {
if(Starten == 1){
if ((Gartemperatur > Soll_Temperatur)){
Luft = false;
}
else if ((Gartemperatur < Soll_Temperatur)){
Luft = true;
}
if ((Gartemperatur < Soll_Temperatur) && (Gartemperatur > ((-1)+Soll_Temperatur)) && (D_Anteil_auf > 0)){
digitalWrite(Relais2, LOW);
Relais2_Status = 0;
D_Regelung_auf = true;
tacktungsrate = 0;
}
if ((Gartemperatur > Soll_Temperatur) && (Gartemperatur < (Soll_Temperatur +0,5)) && (D_Anteil_zu < 0) ){
if (Integral > 1){
digitalWrite(Relais5, LOW);
Relais5_Status = 0;
}
D_Regelung_zu = true;
tacktungsrate = 0;
}
if ((Relais5_Status == 0 || Relais2_Status == 0)){
Regeldifferenz = Soll_Temperatur - Gartemperatur;
if (Regeldifferenz > 0 && tacktungsrate == 0){
if (D_Regelung_zu == true) {
Regeldifferenz = (( D_Anteil_zu)*Integral)*D;
}
else if (D_Regelung_zu == false) {
Regeldifferenz = (Regeldifferenz * Integral)*P;
}
}
if ((Regeldifferenz < 0) && (tacktungsrate == 0)){
Regeldifferenz = Regeldifferenz *-1;
if (D_Regelung_auf == true) {
Regeldifferenz = ((D_Anteil_auf)*Integral)*D;
}
else if (D_Regelung_zu == false){
Regeldifferenz =((Regeldifferenz*Integral))*P;
}
}
}
tacktungsrate = tacktungsrate+1;
if (Regeldifferenz > 20){
Regeldifferenz = 20;
}
if ((tacktungsrate > Regeldifferenz)&&(Startvorgang == 1)) {
if(Gartemperatur < Soll_Temperatur){
D_Anteil_auf = (D_Anteil_auf + Regeldifferenz);
}
if(Gartemperatur > Soll_Temperatur){
D_Anteil_zu =( D_Anteil_zu + Regeldifferenz);
}
digitalWrite(Relais2, HIGH);
Relais2_Status = 1;
digitalWrite(Relais5, HIGH);
Relais5_Status = 1;
tacktungsrate = 0;
Regeldifferenz = 0;
if ((D_Regelung_zu == true)||(D_Regelung_auf == true)) {
D_Anteil_auf = 0;
D_Anteil_zu = 0;
D_Regelung_zu = false;
D_Regelung_auf = false;
}
}
}
}
///////////////////////Zeitlicher Interrrupt 2////////////////////////////
// Teperaturregelung alle 2 Sekunden
void Temperaturregelung() {
if(Starten == 1){
Unterdruckwert_P2 = analogRead(Unterdruck_P2);
if ((Gartemperatur > Soll_Temperatur+1)&&(Unterdruckwert_P2 >= 250)&& (Relais5_Status == 1)&&D_Regelung_zu == false ){//(Relais5_Status == 1)
digitalWrite(Relais2, LOW);
Relais2_Status = 0;
tacktungsrate = 0;
}
if ((Gartemperatur < Soll_Temperatur-1) && (Relais2_Status == 1)&&D_Regelung_auf == false){
if (Unterdruckwert_P2 < (Unterdruckwert_P1-10)){
digitalWrite(Relais5, LOW);
Relais5_Status = 0;
digitalWrite(Relais8, LOW);
tacktungsrate = 0;
}
}
}
}
///////////////////////Zeitlicher Interrrupt 4////////////////////////////
// Teperaturregelung alle 120 Sekunden
void Start() {
if(Starten == 1){
Startvorgang = 1;
}
}
de hier ein
Mich wurde interessieren ein Lik zum Display, nach deiner Beschreibung klingt das für mich als wehre das ein HMI Display, so wie weiß hat seeed studio keine 2,4" HMI Displays, wenigstens noch nicht gesehen.
Wie ist das zu verstehen ?
Ein weiterer Controller mit Display ?
Dann dies hier:
Wire.begin(25, 26);
Wire.begin();
einmal im Setup und dann in "Sensoren".
Die kommen sich vermutlich in die Quere
Poste bitt den Link des Displays und deines Controllerboards.
Seeed Studio verkaufen auch Nextion Displays, vermutlich ist das eins.
Ok, bei ESP kann man I²C selbst belegen, nur es ist immer besser Standard Pins nehmen, da zu kommt, was für ESP32 ist das, da muss man schon aufpassen, es kommt keine Warnung, es tut nur nicht.
Ich habe versucht, da durchzusteigen, aber sorry der Sketch ist sehr unübersichtlich.
Auch durch die vielen unnötigen Leerzeilen und schlechter Formatierung.
Die Formatierung kannst du in der IDE optimieren, wenn du da STRG + t drückst.
Ok dann ist das kein seeed studio 
Deswegen ja der Hinweis. Im Setup definiert er andere (25 + 26) Pins, später löscht er das wieder.
Etwas konfus alles.
Ich sehe aber keine UART für das Display.
Fehlt auch der richtige Hinweis.
Und das irritiert mich total !
Außerdem fehlt noch eine Antwort, warum es der "WiFiWebServer" ist ?
Das verstehe gar nicht, wo zu das?
Naja...viele Fragen sind offen und der TO schläft.
Habe gefunden WiFiWebServer/examples/AdvancedWebServer/AdvancedWebServer.ino at master · khoih-prog/WiFiWebServer · GitHub
Hier ein mal der Link für das Display
Get Started with Wio Terminal | Seeed Studio Wiki
Verbaut ist ein ESP32 DEVKIT V1
Meinst du warum ich die Bibliothek benutzt habe?
Ja da hast du recht, aber, hatte was ausprobiert und daher kommt die doppelte Ausführung. Aber selbst allein im Setup stehend hilft es nicht.
Die Frage ist der auf welschem System soll das gezeigte laufen?