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