Heizungssteuerung für einen Behälter

Hallo Leute, ich bin es mal wieder.

Mein Ziel ist es, eine Flüssigkeit in einem Behälter (150x150x150mm) aufzuheizen.
Die Regelung muss nicht so genau sein, habe eine Toleranz von +/-2,5K.

Der Sollwert für die Temperatur wird über ein Poti vorgegeben.
Es gibt zwei Temperaturerfassungen. Eine in der Flüssigkeit und eine direkt am Heizkörper.
Da der Heizkörper ein Tassenwärmer aus einer alten Kaffeemaschine ist, kann der nicht beliebige Temperatur ab.
Ich versuche daher, die Temperatur am Heizkörper zu begrenzen.

Leider kann ich es nicht testen und poste daher den Code und möchte wissen, ob das so hinhauen kann.
Habe noch nicht sowiel Erfahrung.

//Berechnung des Wertes je Dezimalwert (10-Bit A/D), Faktor hundert, da 10mV SesorSignal = 1°C (LM35 ohne Verstärkung)
  temp1    = analogRead(A5) * (5.00/1023) * 100;   
  temp2    = analogRead(A4) * (5.00/1023) * 100;

//Einlesen und Skalieren der Poti-Werte
  set_temp = map(analogRead(A3),0,1023,25,70  );      //Sollwert Auswahl über Potentiomerter. Möglich von 25°C bis 70°C
  time     = map(analogRead(A2),0,1023,60,1200);      //Zeitvorgabe über Potentiometer von 60s bis 1200s [1-20 min]

//Heizungsfreigabe erteilen   
  if(temp2 <= max_heat - 5)  freigabe = 1;
  if(temp2 >= max_heat + 5)  freigabe = 0;

//Heizungs-Regler Zweipunkt
    if      (temp1 <= set_temp - hys_l && freigabe == 1)                   //Wenn Temperatur im Bad kleiner gleich Sollwert - Hystere Low und freigabe, schalte Heizung ein
            {
              digitalWrite(heat, HIGH);
            }
    else if (temp1 >= set_temp + hys_h || freigabe == 0)                   //Wenn Temperatur im Bad größer gleich Sollwert + Hystere High oder keine freigabe, schalte Heizung aus
            {
              digitalWrite(heat, LOW);
            }

Genauer gehts mit einem PID Regler und einem PWM Ausgang. Für den PID Regler gibt es eine Bibliothek. Grüße Uwe

Das ist mir schon klar. Möchte jedoch nur die Teile einsetzen, die ich auch da habe.

Zu sehen ist nicht der gesamte Code. Da kommen noch Funktionen rein. Nutze ja den Mega8-16PU als standalone. Habe da nicht soviel Speicher um jetzt eine HighEnd Version zu bauen. Wäre natürlich schöner alles mit DIsplay und Sollwertvorgabe darüber usw. ist aber glaub ich nicht machbar.

Der PID-Regler ist kein "Teil", sondern eine Bibliothek http://playground.arduino.cc/Code/PIDLibrary

Wie gut ist denn dein Tassenwärmer thermisch angebunden? Wenn du hier einen Zeitverzug hast, wirst du das mit 2-Punktregler schwer in den Griff kriegen.

Mit "Teil" ist eher ein Triac oder ähnliches gemeint. Zurzeit verwende ich ein Relais, welches Über PWM anzusteuern wäre, aber das nicht lange mitmacht.

Der Behälter ist aus 1mm Edelstahl, Tassenwärmer (Ringeheizkörper auf Alu-Platte, 230VAC) mit dünnem Silikonfilm druntergeklebt.

Zeitverzug ist relativ groß, deßhalb habe ich im Code die Heizfreigabe, damit der Tassenwärmer sich nicht totheizt. Zu Beginn würde die Freigabe halt mehrmals wegfallen. Sobald das Wasser auf Temperatur kommt und der Zweipunkt-Regler einsetzt, sollte dies nicht mehr der Fall sein.

In diesem Thread ging es eigentlich darum, ob der Code so funktionieren sollte, und nicht warum ich den Zweipunktregler einsetze.

Hallo,

siehr doch schon gut aus...

Bei 150 cm3 keine Frage, die zweipunktregelung dürfte ausreichende Genauigkeit liefern.

Für 150 mm3 und einer Tassenwärmeheizung, ich tippe mal ~1kW, hmm, da könte es eng werden.

bei 'uns', Job, regeln wir die Temperaturen über einen PID, wie schon gesagt, ist hier ja auch 'nur' ne Libary. Prizipiell kannst Du mal versuchen, die Stellgröße in kleineren Schritten zu variieren und dann deine Leistung getaktet weiterzugeben. Wie verwenden z.B. einen Zeitrahmen von 10sec, 1s entspricht also 10% Heizleistung. Mit nem passenden SSR kannst Du dann schön smoothy die Leistung ins Gefäß bringen, die einzelnen Teile P- I und D erforschen und auch im Abgleich auf tolle Reaktionszeiten und Genauigkeiten kommen.

IMHO ein Projekt, was Dir auch im Bereich MSR ein tiefes nützliches Verständnis (Was machst Du so beruflich?) bringt..

Greetz, Linpotec

Ist ja nicht so, dass ich völlig im dunkeln Tappe.

Das Ding lief ja schonmal (gut, hab es da über die Heizungstemp und entsprechenden Offset geregelt).
Ist mein Säurebad, welches ich nun neu aufbaue, da das alte das zeitliche gesegnet hat.
Die Platine hab ich neu aufgebaut und schon fertig. Vorher hatte ich das zusammengefrickelt und mit einem Nano am laufen.

Sicherlich interessant das über ein PID zu machen. Kenne Regler zu genüge (War mal in der Reglerentwicklung für Dampfgarer bei Miele tätig)
Lege da aber (zurzeit) nicht so großen wert drauf. Ist wie gesagt nur um Platinen zu ätzen und läuft nicht 24/7 Betrieb und dient nicht als Destille o.ä.

Wenn ich das Teil erst mal am Laufen hab, dass ich endlich wieder Boards machen kann, sieht das alles anders aus.

Anbei der (fast) fertige Code.
Habe da nun noch eine Laufzeit drinnen, bei der ich nicht weiß, ob es so klappt, wie ich es vorhabe.
Funktion Soll: Bei Tastendruck startet eine Laufzeit (einstellbar über Poti), während der Die Beleuchtung des Behälters sowie eine LED leuchten.
(Später kommt noch eine “Luftpumpe” dazu, welche die Säure mit Sauerstoff anreichert)

//Pin Definition
int Beleuchtung  = 7;         //output relais Beleuchtung
int Heizung      = 8;         //output relais Heizung
int LED_Ablauf   = 0;         //output Ablauf LED
int Taster_Start = 1;         //input Start-Taster
int LED_Heizung  = 2;         //output LED Heizung

//Variablen
int temp1        = 0;       //Temperatur im Behälter    
int temp2        = 0;       //Temperatur Heizung
int Soll_Temp    = 0;       //Sollwert Temperatur skaliert
int Soll_Zeit    = 0;       //Zeitvorgabe skaliert
boolean Freigabe_Heizung  = 0;       //Heizungsfreigabe
boolean Merker_Ablauf     = 0;       //Zeit läuft

unsigned long Zeit_Tdruck = 0; //Zeitpunkt Taster betätigt

int max_Heizung = 80;        //Grenztemperatur für Heizkörper
int hys_h       = 2;         //Hysterese High
int hys_l       = 2;         //Hysterese Low

void setup() 
{                
  pinMode(Heizung,     OUTPUT);
  pinMode(Beleuchtung, OUTPUT);
  pinMode(LED_Ablauf,  OUTPUT);
  pinMode(Taster_Start, INPUT);    //Pulldown Hardwaremäßig, HIGH bei betätigtem Taster
  pinMode(LED_Heizung, OUTPUT);

  digitalWrite(Heizung,     LOW); 
  digitalWrite(Beleuchtung, LOW); 
  digitalWrite(LED_Heizung, LOW);   
}

void loop() {
/*******************************************************************************************************************************************************/ 
//Berechnung der Temperaturen je Dezimalwert (10-Bit A/D), Faktor hundert, da 10mV SesorSignal = 1°C (LM35 ohne Verstärkung)
  temp1    = analogRead(A5) * (5.00/1023) * 100;   
  temp2    = analogRead(A4) * (5.00/1023) * 100;

//Einlesen und Skalieren der Poti-Werte
  Soll_Temp = map(analogRead(A3),0,1023,25,70  );      //Sollwert Auswahl über Potentiometer. Möglich von 25°C bis 70°C
  Soll_Zeit = map(analogRead(A2),0,1023,60,1200);      //Zeitvorgabe über Potentiometer von 60s bis 1200s [1-20 min]

/*******************************************************************************************************************************************************/
//Ablauf starten bei Tastendruck, Ablaufmerker setzen, Zeit wegspeichern und LED setzen
  if(digitalRead(Taster_Start) == HIGH && Merker_Ablauf == LOW)                   
    {
      Merker_Ablauf = HIGH;
      LED_Ablauf    = HIGH;
      Beleuchtung   = HIGH;
      Zeit_Tdruck   = millis();
    }
    
//Ablauf beenden, wenn eingestellte Zeit vom Poti überschritten wurde, Ablaufmerker zurücksetzen, LED ausschalten, gespeicherte Zeit löschen
  if(millis() >= (Zeit_Tdruck + (Soll_Zeit * 1000)) && Merker_Ablauf == HIGH)    
    {
      Merker_Ablauf = LOW;
      LED_Ablauf    = LOW;
      Beleuchtung   = LOW;
      Zeit_Tdruck   = 0;
    }

/*******************************************************************************************************************************************************/  
//Heizungsfreigabe erteilen   
  if(temp2 <= max_Heizung - 5)  Freigabe_Heizung = HIGH;
  if(temp2 >= max_Heizung + 5)  Freigabe_Heizung = LOW;

//Heizungs-Regler Zweipunkt
    if      (temp1 <= Soll_Temp - hys_l && Freigabe_Heizung == HIGH) //Wenn Temperatur im Bad kleiner gleich Sollwert - Hystere Low und freigabe, schaltet Heizung ein
             { 
              digitalWrite(Heizung,  HIGH);
              digitalWrite(LED_Heizung, HIGH);  
             }
    else if (temp1 >= Soll_Temp + hys_h || Freigabe_Heizung == LOW) //Wenn Temperatur im Bad größer gleich Sollwert + Hystere High oder keine freigabe, schaltet Heizung aus
             { 
              digitalWrite(Heizung,  LOW);
              digitalWrite(LED_Heizung, LOW);   
             }
}

Linpotec: Hallo,

siehr doch schon gut aus...

Bei 150 cm3 keine Frage, die zweipunktregelung dürfte ausreichende Genauigkeit liefern.

Für 150 mm3 und einer Tassenwärmeheizung, ich tippe mal ~1kW, hmm, da könte es eng werden.

bei 'uns', Job, regeln wir die Temperaturen über einen PID, wie schon gesagt, ist hier ja auch 'nur' ne Libary. Prizipiell kannst Du mal versuchen, die Stellgröße in kleineren Schritten zu variieren und dann deine Leistung getaktet weiterzugeben. Wie verwenden z.B. einen Zeitrahmen von 10sec, 1s entspricht also 10% Heizleistung. Mit nem passenden SSR kannst Du dann schön smoothy die Leistung ins Gefäß bringen, die einzelnen Teile P- I und D erforschen und auch im Abgleich auf tolle Reaktionszeiten und Genauigkeiten kommen.

IMHO ein Projekt, was Dir auch im Bereich MSR ein tiefes nützliches Verständnis (Was machst Du so beruflich?) bringt..

Greetz, Linpotec

Sind nicht 150cm3, sondern 3,4 Liter wenn ich es randvoll mache.

Aber so langsam leuchtes es mir ein. Schaue mir definitiv die lib an und teste es mal, bei einer Zeitbasis von 10s würde das ganze auch mit einem Relais wieder Sinn machen 8)

Kenne die Möglichkeiten mit PWM noch nicht und arbeite mich da mal ein

Der PID-Regler gibt dir erstmal eine Stellgröße 0-255 aus.

Mit der kannst du dann dein Stellglied, in dem Falle dein Relais, ansteuern.
Du hast Recht, ein Relais kann man nicht direkt mit der Arduino-PWM ansteuern, aber es ist kein Problem sich eine langsame PWM zu erzeugen. z.B. so:

/*************************************************************************************************
**  	RelaisAusgang										**
**************************************************************************************************
** Setzt den vom PID errechneten Wert (0-255) in eine langsame Schalt-PWM um.			**
** Frequenz = 1/Periodendauer ;  								**
** GuntherB 2013										**
**  												**
**  											   	**
**  Input: Periodendauer [ms]; 	_PIDout Wert [0-255];						**
**  Output:	Pin "ReglerOutPin"								**
**  genutzte Globale Variablen: ReglerOutPin							**
**************************************************************************************************/
void RelaisAusgang( unsigned long Periodendauer, unsigned long _PIDout){
static int PinStatus = LOW;  
static unsigned long SwitchHigh =0, SwitchLow =0;
static boolean _init = true;

        if (_init){  // wird nur beim erstem Mal durchlaufen, um die Werte zu setzen.
          SwitchHigh = millis() + Periodendauer;
          SwitchLow =  millis() + (_PIDout*Periodendauer)/255L;
          _init = false;
        }
        
        switch (PinStatus){
          case HIGH:
            if (millis() > SwitchLow){
              digitalWrite(ReglerOutPin,LOW); 
              SwitchLow = SwitchHigh + (_PIDout*Periodendauer)/255L;              
              PinStatus = LOW;
            }
            break;
          case LOW:
            if (millis() > SwitchHigh){
              digitalWrite(ReglerOutPin,HIGH); 
              SwitchHigh = SwitchHigh + Periodendauer;              
              PinStatus = HIGH;
            }
            break;
        } // end switch
} // End Funktion RelaisAusgang

Das ist jetzt ungetester Code, in Abwandlung einer bei mir laufenden Funktion.
Du mußt global den ReglerOutPin deklarieren und dann in der loop() die Funktion nach dem PID aufrufen.

#include <PID_v1.h>
int ReglerOutPin = 13;

double Setpoint, Input, Output;
PID myPID(&Input, &Output, &Setpoint,6,0.02,0, DIRECT);

void setup()
{
   Setpoint =45;  // Sollwert der Aetzmittel Temperatur
   myPID.SetMode(AUTOMATIC);
}

void loop()
{
  Input = AetzmittelTemperatur();
  myPID.Compute();
  RelaisAusgang( 10000, Output);  // Relais wird mit einer Periodendauer von 10sek geschalten
}

So, oder so ähnlich könnte das funktionieren.

Wenn du deinen P-Anteil recht niedrig machst, dann sollte das auch funktionieren ohne die Heizung zu überlasten, dennoch solltest du noch eine überwachung einbauen.

Vielleicht so:

if (Heizungstemperatur() > HeizungMax){
  myPID.SetMode(MANUAL);
  Output = 0;
} else {
  myPID.SetMode(AUTOMATIC);
}

Edit:
PinStatus in der Funktion RelaisAusgang() muß natürlich als static deklariert werden! :astonished:geändert.
Und die Reglerparameter passten sicherlich nicht für eine Heizungsteuerung.
Es könnte klappen mit: Kp=6, Ki= 0.02, Kd=0 (Den D-Anteil brauchts bei so langsamen Systemen eher nicht)

Danke. Dieser Post hat mir jetzt sehr geholfen.

Bin dabei mir ein Beispiel zurecht zu biegen. Aber deins ist wesentlich verständlicher.

Hallo,

ich hänge mich mal mit an den Tröt, weil ich ein ähnlich gelagertes Heizungsproblem habe :slight_smile:
Ich habe einen alten Kühlschrank geschlachtet, das Kühlaggregat “entkernt” und daraus einen Honigauftauschrank gebaut (ein weiteres Hobby ist die Imkerei). Der Wärmeschrank soll 40°C halten, um den Honig nicht zu schädigen. In den Wärmeschrank kommen dann 12,5 kg Eimer oder 25 kg Hobbocks. Unten, wo die Gemüseschublade war, sind 2x 115V Papstlüfter und ein Heizregister aus Zementwiderständen (330W). Der Honigeimer kommt dann auf das unten eingelegte Gitter und wird ordentlich von der umgewälzten Luft umspült. Ein LM35 misst die Temperatur. Das Ergebnis ist auch sehr stabil und wird auf einem 16x2 per I2C angebundenem LCD Display in der Tür angezeigt. Die Elektronik ist auf Lochrasterplatte aufgebaut mit einem nackten ATMEGA 328, den ich per ISP Header mit dem USBasp programmiert habe und so auch nachträglich ändern kann. Als Relais verwende ich ein SSD von Typ S202 S01. Somit sind häufige Schaltvorgänge keine Hürde. Mit einem einfachen Zweipunktregler und 0,1°C Hysterese bekomme ich 2,5°C Überschwingen, da die Zementwiderstände ordentlich Wärme speichern. An die PID Lib habe ich mich bisher nicht rangetraut. Ich habe zwar was gegoogelt, wie man empirisch einen PID Regler abgleicht, aber dazu müßte ich erst mal ansatzweise einen Plan haben, wie groß die einzelnen Werte ganz grob sein müssen. Also wenn sich hier jemand am Einsatz der PID Lib versucht, dann bin ich auch interessiert :smiley:
Als “Notaus” habe ich noch eine termische Entlötsicherung, wie sie z.B. in Frittösen verwendet wird, direkt in die Heizungszuleitung eingeschleift. Der kleinste erhältliche Wert ist zwar 60°C, aber der verhindert zumindest Rauchzeichen! ]:slight_smile:

Gruß Gerald

So, konnte eben mein Board mit dem Code testen.

Die Zeitfunktion beim Betätigen des Tasters funktioniert nicht. Die 5V beim Betätigen kommen sauber an. Sollwert vom Poti auch sauber.

Woran kann es liegen? Spiele das ganze mal morgen auf dem Arduino durch, wo ich mir die Werte seriell rausgeben lassen kann, aber vielleicht sieht ja jemand einen Fehler in dem Code.

//Pin Definition
int Beleuchtung  = 7;         //output relais Beleuchtung
int Heizung      = 8;         //output relais Heizung
int LED_Ablauf   = 0;         //output Ablauf LED
int Taster_Start = 1;         //input Start-Taster
int LED_Heizung  = 2;         //output LED Heizung

//Variablen
int temp1        = 0;       //Temperatur im Behälter    
int temp2        = 0;       //Temperatur Heizung
int Soll_Temp    = 0;       //Sollwert Temperatur skaliert
int Soll_Zeit    = 0;       //Zeitvorgabe skaliert
boolean Freigabe_Heizung  = 0;       //Heizungsfreigabe
boolean Merker_Ablauf     = 0;       //Zeit läuft

unsigned long Zeit_Tdruck = 0; //Zeitpunkt Taster betätigt

int max_Heizung = 80;        //Grenztemperatur für Heizkörper
int hys_h       = 2;         //Hysterese High
int hys_l       = 2;         //Hysterese Low

void setup() 
{                
  pinMode(Heizung,     OUTPUT);
  pinMode(Beleuchtung, OUTPUT);
  pinMode(LED_Ablauf,  OUTPUT);
  pinMode(Taster_Start, INPUT);    //Pulldown Hardwaremäßig, HIGH bei betätigtem Taster
  pinMode(LED_Heizung, OUTPUT);

  digitalWrite(Heizung,     LOW); 
  digitalWrite(Beleuchtung, LOW); 
  digitalWrite(LED_Heizung, LOW);   
}

void loop() {
/*******************************************************************************************************************************************************/ 
//Berechnung der Temperaturen je Dezimalwert (10-Bit A/D), Faktor hundert, da 10mV SesorSignal = 1°C (LM35 ohne Verstärkung)
  temp1    = analogRead(A5) * (5.00/1023) * 100;   
  temp2    = analogRead(A4) * (5.00/1023) * 100;

//Einlesen und Skalieren der Poti-Werte
  Soll_Temp = map(analogRead(A3),0,1023,25,70  );      //Sollwert Auswahl über Potentiometer. Möglich von 25°C bis 70°C
  Soll_Zeit = map(analogRead(A2),0,1023,60,1200);      //Zeitvorgabe über Potentiometer von 60s bis 1200s [1-20 min]

/*******************************************************************************************************************************************************/
//Ablauf starten bei Tastendruck, Ablaufmerker setzen, Zeit wegspeichern und LED setzen
  if(digitalRead(Taster_Start) == HIGH && Merker_Ablauf == LOW)                   
    {
      Merker_Ablauf = HIGH;
      LED_Ablauf    = HIGH;
      Beleuchtung   = HIGH;
      Zeit_Tdruck   = millis();
    }
    
//Ablauf beenden, wenn eingestellte Zeit vom Poti überschritten wurde, Ablaufmerker zurücksetzen, LED ausschalten, gespeicherte Zeit löschen
  if(millis() >= (Zeit_Tdruck + (Soll_Zeit * 1000)) && Merker_Ablauf == HIGH)    
    {
      Merker_Ablauf = LOW;
      LED_Ablauf    = LOW;
      Beleuchtung   = LOW;
      Zeit_Tdruck   = 0;
    }
}

nix_mehr_frei:
Ich habe zwar was gegoogelt, wie man empirisch einen PID Regler abgleicht, aber dazu müßte ich erst mal ansatzweise einen Plan haben, wie groß die einzelnen Werte ganz grob sein müssen. Also wenn sich hier jemand am Einsatz der PID Lib versucht, dann bin ich auch interessiert :smiley:

Ich habe bei mir den PID als Regler für einen Holzkohlengrill im Einsatz. Der Regler hat über einen Servo zugriff auf die Schieber für Zuluft und Abluft.
Da hier die Leistungszufuhr extrem nicht linear ist, sind die Anforderungen an den Regler nicht in mathematische Formeln zu fassen.
Also mußte ich auch auf nichtmathematische Lösungen zurückgreifen.
am besten haben bei mir die Einstellregeln nach Ziegler und Nichols funktioniert, bin aber auch mit Chien-Hrones-Reswick auf ähnliche Ergebnisse gekommen.

Generelles Vorgehen: mittels Serial.print in einer Zeitscheibe die Werte während eines Regelvorganges in den Serialmonitor ausgeben. Nach Abschluß der Messung den Inhalt des Monitors in Excel kopieren und dort grafisch auswerten. Da kann man schön spielen und in die Grafik auch die Kenngrößen eintragen. Für solche trägen Systeme mit hohem Zeitverzug schlage ich vor:
Kp < 10; Ki < 0,01; Kd =0 als Startwert für die erste Messung. Dann kann man variieren.

Es gibt aber in der PID-Lib auch eine Autotune funktion, die die Reglerparameter selbst ermittelt. Die habe ich aber noch nicht ausprobiert. Ich möchte lieber selbst verstehen, was mein Regler macht.

Einfach mal anfangen und Ausprobieren. Und für die Test natürlich nur Wasser nehmen!

Werde den Regler wohl nach Ziegler und Nichols paramtrieren.

Muss jetzt aber erst mal das Becken aufbauen, damit ich zum heizen und Daten loggen komme.

Zudem hab ich jetzt das Problem, dass ich bei meinem µC die seriellen Pins vergeben habe :stuck_out_tongue_closed_eyes:

Schauen wie ich das mache…

SoftwareSerial: http://arduino.cc/en/Reference/SoftwareSerial http://arduiniana.org/libraries/newsoftserial/

Das ist schon in der IDE dabei, funktioniert aber nicht bei allen Anwendungen

Oder AltSoftwareSerial: http://www.pjrc.com/teensy/td_libs_AltSoftSerial.html

Letzte ist besser aber verbraucht aber einen Timer

Danke. Aber jetzt erst mal eins nach dem anderen.

Muss erst meinen Taster und die Zeit in den Griff kriegen

R1der: ..und die Zeit in den Griff kriegen.

Welche Zeit meinst du?

/*******************************************************************************************************************************************************/
//Ablauf starten bei Tastendruck, Ablaufmerker setzen, Zeit wegspeichern und LED setzen
  if(digitalRead(Taster_Start) == HIGH && Merker_Ablauf == LOW)                   
    {
      Merker_Ablauf = HIGH;
      LED_Ablauf    = HIGH;
      Beleuchtung   = HIGH;
      Zeit_Tdruck   = millis();
    }
    
//Ablauf beenden, wenn eingestellte Zeit vom Poti überschritten wurde, Ablaufmerker zurücksetzen, LED ausschalten, gespeicherte Zeit löschen
  if(millis() >= (Zeit_Tdruck + (Soll_Zeit * 1000)) && Merker_Ablauf == HIGH)    
    {
      Merker_Ablauf = LOW;
      LED_Ablauf    = LOW;
      Beleuchtung   = LOW;
      Zeit_Tdruck   = 0;
    }

Die meine ich. Funktioniert noch nicht und wurde gestern zu spät weiter zu suchen…

der Rest des Codes steht auf Seite 1 irgendwo.

Meine Erkentnisse:

-Variablen die große Werte aufnehmen sollen, auch als solche festlegen -digitale Pins auch mit digitalWrite schalten...

Aber jetzt bin ich fitter im seriellen ausgeben von Daten :sweat_smile:

Als nächstes: Thema Heizung mit PID

guntherb:
Für solche trägen Systeme mit hohem Zeitverzug schlage ich vor:
Kp < 10; Ki < 0,01; Kd =0 als Startwert für die erste Messung. Dann kann man variieren.

Na das klingt doch schon mal nach einem Plan :slight_smile:
Wenn ich jetzt noch schaffe, die PID Lib in meinen Code einzubinden, dann teste ich das mal. Leider stehe ich mit coden etwas auf Kriegsfuß. Ich bin schon heilfroh, wenn ich ein paar Libs zusammengestoppelt kriege und vorhandenen Code ein wenig für meine Bedürfnisse “verbiegen” kann. Ich tobe mich lieber in Hardware aus :smiley:

Gruß Gerald