Autor Thema: Alternative Externe Temperatur gesteuerte Lüfterreglung  (Gelesen 4659 mal)

0 Mitglieder und 1 Gast betrachten dieses Thema.

MaikLommatzsch

  • Lv 2: Newbie
  • *
  • Offline Offline
  • Beiträge: 54
    • Profil anzeigen
Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
« Antwort #45 am: 11. 2022, 08:55:22 »
hui, ui,ui.
Ich Liebe dieses Thema, es macht sowas von Spaß, Geilo und Danke dafür. TOP

OK, ich hab mir ein paar Punkte rausgezogen worauf ich reagieren möchte

Zitat
we3dm4n hat es ja bereits erklärt.
Danke we3dm4n für die flotte Erklärung , das habe ich so verstanden.
Takeshi, ich begreif die Wahr Falsch Geschichte nicht.

Zitat
Hier der überarbeitete Programmcode. Ich kann ihn natürlich nicht kompilieren und damit nicht auf grobe Fehler prüfen
Die Arduino Software ist Freeware.

Zitat
Was soll das switch(fanSteps)?
Das stammt aus einem Ursprünglichen Code den ich übernommen habe. Da wurde mit 2 Case gearbeitet, im ersten Case war im Grunde der aktuelle Lüftercode und im Zweiten Case eine Lineare Lüfterreglung wenn bestimmte Situationen eintreten. Da ich es nicht besser wusste und es keine Fehler in der Prüfung gab, blieb er drin. Wenn es weg kann, umso besser :-)

Zitat
// Übertemperatur Summerwarung
Kann ich dir nicht sagen ob das gewollt war oder nicht, in der Tat sind die Letzen Codes Led, Summer und Sensorfehler von mir. Aber alles nur Ableitungen von schon vorhanden Codes im Skrip.
Prüfung ergab keinen Fehler und Funktionieren tut es auch noch. Von daher war es OK für mich, weil ich es auch nicht besser wusste.

Zitat
Wie gesagt, ich habe keine Ahnung von Arduino, daher weiß ich nicht, ob ein Int davor muss, was anderes oder gar nichts.
Ist doch nicht Schlimm, ich habe sogar noch weniger Ahnung :-) Wollte ohne böse Absicht nur drauf hinweisen.

Zitat
else if(temp > (TempSchwellen[1] + ds1)
Bitte nicht als Klugschei...en ansehen, ist mir aber aufgefallen. Nach der Letzen Klammer fehlt eine weitere klammer, bei allen mit else.

Zitat
Gewöhne dir bitte an einen einheitlichen Stil zu verwenden.

Wenn der Sketch einheitlich währe, würdest du noch mehr schimpfen, glaube mal :-)
Ich habe absolut 0 Ahnung und das möchte ich nochmal kurz anmerken, soll nicht heißen das ich nicht Reflexionsfähig bin. Ich werde versuchen alle Tipps und Anweisungen auch umzusetzen aber bitte auch darum etwas Nachsichtig zu sein wenn ich was nicht richtig mache. Man kann aber davon ausgehen das ich es einfach nicht besser weiß, aber es gerne wissen möchte.
Der Aktuelle Sketch ist eher mehr als weniger aus 5 verschiede Sketchs zusammen gebastelt. Alles im Copy/Paste verfahren und einer RIESEN Menge an Zeit um die Codes da und so zu platzieren und zu schreiben das es zusammen läuft. Natürlich hab ich inzwischen auch was gelernt dabei und verstehe jetzt einige Dinge besser. Bei sowas bin ich echt geduldig :-) Aber ohne die Hilfe hier und den ein oder anderen Fortschritt hätte ich aufgegeben.

Zitat
Und das hast du da programmiert ;D
Das ist nicht von der Hand zu weisen, ich bin da zu 100% Schuld ;D
Aber was soll ich sagen, auch wenn es nach dem Diagramm nicht so aussieht, es funktioniert aber.
Z.B. Stufe Drei:
Erreiche ich 67°C startet Stufe 3 und bleibe bis ich 70°C erreiche und starte stufe 4.
Kühle ich ab und komme knapp unter 70°C gehe ich in Stufe 3 zurück. Jetzt pendelt die Temperatur
aber um die 70°C herum und wechselt ständig die Stufen. Das war ja das Problem und um so Höher die Stufen sind
desto nerviger ist der Stufenwechsel.  Mit dem ds1 funktioniert das in der tat. Ich erreiche 70°C und schalte in die Stufe 4
werde wieder kühler und erreiche 69,2°C und bleibe in der Stufe 4 bis ich 69°C unterschreite. Das ist 1 °C Puffer, ob der reicht
wird sich zeigen, mehr geht aber mit dem Code nicht. Ob es richtig ist? weiß ich nicht. Ob es so laufen soll? Weiß ich nicht.
Würde es aber so versuchen, weil ich es nicht besser Weiß. Darum arbeiten wir gemeinsam daran. Da ich momentan die Praktische Kraft bin
kann nur ich das Feedback zurück geben was ich hier Live erfahre. Die Textform macht es zwar nicht leichter aber so ist es nun mal.


Soweit erstmal so gut, jetzt steht das Wochenende an und ich werde wahrscheinlich nicht dazu kommen Takeshis geänderten Sketch probieren zu können, werde es aber auf jeden fall machen
sobald ich kann. ( Ja momentan habe ich nur in der Woche Zeit :-))

Auf jeden fall nochmal danke für die Kritik, Hilfe und Ideen.
In diesen Sinne ein schönes Wochenende.








Takeshi

  • Administrator
  • Lv 99: Freak
  • *****
  • Offline Offline
  • Beiträge: 29514
  • Geschlecht: Männlich
    • Profil anzeigen
    • trisaster.de
Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
« Antwort #46 am: 12. 2022, 00:13:40 »
Der Ton macht die Musik, heißt es. Der Ton fehlt hier, hier haben wir nur den Liedtext ;) Keine Sorge, das war nicht böse gemeint und mir ist bewusst, dass du Anfänger bist. Es ist nur so, wenn man da viele Jahre drin ist, dann fällt es einem immer schwerer Einstiegshürden einzuschätzen. Ich kann mich nur dran erinnern, dass es gängige Praxis unter Anfängern war keinen Wert auf die Formatierung des Quelltextes zu legen, weil es für die Funktion keine Rolle spielt und eigentlich möchte man doch nur schnell ein funktionierendes Programm und keinen hübschen Programmcode. Das habe ich schon häufig so gehört. Ich selbst habe das nie so gesehen, ich habe von Anfang an versucht es ordentlich zu formatieren, tat mich nur schwer damit herauszufinden, was nun eine sinnvolle offizielle Strategie ist. Ich weiß auch nicht, wie du das grundsätzlich siehst (du hast dich diesbezüglich nie geäußert) und was dein Wissensstand ist. Und es ist sehr mühselig das alles umzuformatieren, weshalb es ärgerlich wäre das demnächst wieder zu tun. Ich wollte, dass der umformatierte Quelltext auch als gutes Lernbeispiel dienen kann, sprich "learning by lesing". Formatierung von Programmcode ist wichtig, weshalb ich dir nur den Ratschlag geben kann einen erheblichen Anteil an Hirnschmalz und Arbeit da hineinzustecken, denn die Zeit sparst du wo anders wieder ein.

Ich merke aber, dass da generell wesentlich größere Wissenslücken sind, als ich erwartet habe. Ich denke, die sollten wir als erstes mal angehen, damit du besser selbstständig programmieren kannst.

Takeshi, ich begreif die Wahr Falsch Geschichte nicht.

Das ist eine gute Information, denn das ist absolut grundlegend. Nehmen wir eine if-else-Anweisung, die sieht wie folgt aus:
if(Aussage)
{
    // führe aus, wenn Bedingung wahr
}
else
{
    // führe aus, wenn Bedingung falsch
}

Die Aussage wird auf Wahrheit geprüft, ob die Aussage wahr oder falsch ist. Nehmen wir an, du hast die Variable "test".
// Ist die Variable "test" gleich 2?
test == 2
... prüft die Variable test und die Zahl 2 auf Gleichheit. Enthält die Variable test den Wert 2, dann ist die Aussage wahr, in allen anderen Fällen ist sie falsch.

// Ist die Variable "test" ungleich 2?
test != 2
... prüft die Variable test und die Zahl 2 auf Ungleichheit. Enthält die Variable test den Wert 2, dann ist die Aussage falsch, in allen anderen Fällen ist sie wahr.

// Ist die Variable "test" kleiner als 2?
test < 2
... prüft, ob die Variable test kleiner als die Zahl 2 ist. Enthält die Variable test den Wert 1, 0, -1 , -2, ..., dann ist die Aussage wahr. Für die Zahlen 2, 3, 4, ... ist sie falsch.

// Ist die Variable "test" kleiner als 2 oder gleich 2?
test <= 2
... schließt den Wert 2 für "wahr" mit ein.

// Sinnlose Aussage, da immer falsch
1 == 2

// Einfache Anwendung
// Der Inhalt von "betrag" ist immer positiv
int zahl;
int betrag;

zahl = 1; // Der Variable werden für den Test verschiedene Werte zugewiesen, kann auch "-5" sein.

if(zahl < 0)
{
    betrag = -zahl;
}
else
{
    betrag = zahl;
}

Solche Aussage kann beliebig komplex sein. Zusammenhängede Aussagen können mit Klammern zusammengebunden und mit "and" verbunden werden. Beispiel:
if((zahl > -5) and (zahl < 5) and (zahl != 0))
{
    print("Zahl liegt zwischen -5 und +5, ist aber nicht Null!");
}
else
{
    print("Betrag von zahl ist größer oder gleich 5, oder aber Null!");
}

Das geht noch weiter, aber ich denke bis zu dem Punkt ist das erst einmal ausreichend.
So weit klar?

Zum Thema einrücken hatte ich ja bereits was geschrieben. Du wirst zwei Varianten finden:
(Reihenfolge wegen besserer Lesbarkeit meins Beitrags gewählt)
int zahl = 0;

void loop()
{
    if(irgendeineAussage)
    {
        zahl++;
        analogWrite(fanPin, 100);
    }
    // weiterer Code
}
int zahl = 0;

void loop() {
    if(irgendeineAussage) {
        zahl++;
    }
    // weiterer Code
}

Die zweite ist die, die du verwendest, ist scheinbar bei Arduino verbreitet. Die erste wirst du ggf. auch mal antreffen. Da du aber die zweite gewohnt bist, bleiben wir jetzt dabei.
Du siehst, Funktionen und sogenannte Kontrollstrukturen (if/else, for, switch, while)) haben immer den Aufbau "name(argument)". Befehlen folgt ein Simikolon ";" und Kontrollstrukturen in der Regel weitere Anweisungen. Wenn es nur eine Anweisung ist, kann man sie einfach darunter schreiben. Sind es mehrere, müssen sie in geschweiften  Klammern zusammengefasst werden und gelten für die Kontrollstuktur dann als "eine Anweisung", die ggf. ausgeführt wird, je nachdem, was im Argument der Anweisung steht. Ich rate wie gesagt dazu, IMMER geschweifte Klammern zu verwenden, auch wenn es nur ein Befehl ist, der danach ausgeführt wird. Sorgt einfach für weniger Fehler.
Einer Kontrollstruktur (oder die Definition eines Befehls wie "void temperaturberechnung()") ist somit immer eine öffnende und eine schließende geschweifte Klammer zugeordnet. Die öffnende schreibst du hinter den Befehl und die schließende natürlich weiter unten, aber immer auf gleicher Ebene eingerückt wie der Befehl/die Kontrollstruktur selbst. Wenn du eine Linie vom Anfang der Kontrollstruktur nach unten ziehst, landest du irgendwann bei der schließenden Klammer. Und alles bis zu der schließenden Klammer gehört zu dieser Kontrollstruktur. Alles innerhalb der Klammer ist weiter nach rechts eingerückt. Du solltest immer den gleichen Abstand pro Einrückung verwenden. Üblich sind 4 Leerzeichen oder ein Tabulator, wobei man die meisten Programme so einstellen kann, dass ein Tabulator als 4 Leerzeichen dargestellt wird.
Zeilen nur mit Kommentar werden eingerückt wie alles andere auch.

Und generell gilt: Versuche die Art, wie du es schreibst, als Regel zu definieren und wende sie immer gleich an. "Zwischen Befehl und runter Klammer steht (k)ein Leerzeichen", "zwischen runder Klammer und Argument steht (k)ein Leerzeichen" oder eben "eine öffnende runde Klammer nach einer geschlossenen geschweiften Klammer steht mit einem Leerzeichen direkt dahinter".

Die Arduino Software ist Freeware.

Das ist mir bekannt, ich muss nur ehrlich zugeben, ich wollte es nicht installieren. Ich hab das Zeug dann auf der Platte und sehe schon kommen, wie ich dann versuche das überhaupt zu installieren (benutze Linux), ein Projekt zu starten, einen passenden Controller oder ein Board zu wählen, bis ich dann mal den Code compilieren kann. Wenn es an vielen kleinen Sachen hakt (die ich alle zur Genüge kenne), neige ich dazu diese kleine Sache doch noch hinzubekommen und am Ende sitze ich Stunden dran.

Das stammt aus einem Ursprünglichen Code den ich übernommen habe. Da wurde mit 2 Case gearbeitet, im ersten Case war im Grunde der aktuelle Lüftercode und im Zweiten Case eine Lineare Lüfterreglung wenn bestimmte Situationen eintreten. Da ich es nicht besser wusste und es keine Fehler in der Prüfung gab, blieb er drin. Wenn es weg kann, umso besser :-)

Ah, alles klar! Dann kann das wirklich raus. So ist der Code gleich übersichtlicher.

Auf den Rest antworte ich ein anderes Mal, ist schon spät.

MaikLommatzsch

  • Lv 2: Newbie
  • *
  • Offline Offline
  • Beiträge: 54
    • Profil anzeigen
Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
« Antwort #47 am: 15. 2022, 11:48:53 »
Moino ;D

Ein herrlicher Tag und wieder was zu berichten.

@Takeshi,
Alles gut, es wird nie so heiß gegessen wie es gekocht wird, ich finde die Komunikation hier sehr gut, keiner dichtet was rein was auch nicht da ist. Alle Standpunkte sind klar und alles ist gut. Ich finde wir bekommen hier ordentlich was hin.

Ok, jetzt zur Steuerung

Ich hab es endlich geschafft ,das das System mit +3,3V läuft ;D (Auch wenn es nur zufall war)
Der Controller hat einen Spannungseingang der sich VIN nennt und je einen Ausgang für +5V und +3,3V.
Wie bin ich darauf gekommen? Ich wollte das Gerät mal ohne PC/USB betreiben und habe dann +5V an den VIN gegeben stellte aber Fest das die Temperatur nicht stimmt, nur gut die Hälfte wurde angezeigt. Super ist, mir ist sofort eingefallen was ich mal gelesen hatte:
Bis eine bestimmte Stromabnahme reicht es am VIN zu versorgen und ab eine bestimmte Stromabnahme muss am jeweiligen Ausgang zusätzlich Spannung angelegt werden.
Tada, nochmal +5V am +5V Ausgang angelegt und schon lief es. Moment!! Halbe Temperatur?
Das kannte ich schon und habe einfach mal nur  ohne weitere änderungen +3,3V anstatt +5V angelegt und auch das läuft  ;D  damaliger Fehler war einfach nur eine zu hohe Stromabnahme und / oder der Controller mochte es nicht mit USB versorgt zu werden und dabei mit +3,3V Arbeiten zu müssen ;D

Jetzt zum Programm

 1. switch (FanSteps) in meinen Sketch kann ich nicht ohne weiters löschen, es nimmt Bezug auf CASE0. Aber ich denke das Thema ist durch den:
Ich habe den von Takeshi umgeschrieben Sketch mit ein paar Änderungen übernommen.
Folgendes hab ich geändert , Korrigiert oder ergänzt:
Zitat
int TempSchwellen[9] = {45, 50, 55, 60, 65, 70, 75, 80, 85};
Dort fehlte das int am Anfang und ein ; am ende
Zitat
int abfrage[abfrageZahl];       // Array Variable für das Mitteln der Temperatur
Habe ich wieder in int abfrage[1]; geändert, es gab kein Bezug
Zitat
else if(temp > (TempSchwellen[1] + ds1)
Bei allen Befehlen mit ELSE fehlte eine zweite ) nach ds1

Bei der Optischen Ausgabe musste nur, ich sag es mal so, ein END Befehl geändert werden, (ln). Also keine neue Zeile nötig das schaut dann so aus und funzt Prima:
Zitat
  // optische Ausgabe
  Serial.print("fanSpeed: ");
  Serial.print(fanSpeed[Stufe]);
  Serial.print(" - Stufe: ");
  Serial.println(Stufe);
  lcd.setCursor(0,2);       
  lcd.print("PWM: ");
  lcd.print(fanSpeed[Stufe]);
  lcd.print(" - Step: ");
  lcd.println(Stufe);         // Wenn das nicht funktioniert, dann lcd.print(Stufe + 0x30); probieren

Dann habe ich erstmal mit // den Lüfteranlauf deaktiviert, Grund folg
Zitat
  //analogWrite(fanPin, 100);          // Lüfter startet und geht wieder aus

Der Lüfteranlauf ist aus weil beim Start des Systems der Lüfter mit Stufe 8 anläuft und sich dann im 2 Sekunden Takt abregelt. Es wird jede Stufe nach unten durchgeschaltet.
Ob das gewollt ist, weiß ich nicht. Ich würde das aber lassen um den Nutzer zu signalisieren das der Lüfter anläuft wie es Original ja auch der Fall ist. Zwar nicht genau so, aber es ist ja auch nicht Original ;)

Dann wird jede Stufe in Richtung warm sauber durchgeschaltet mit ein + 1 °C
In Richtung kalt das selbe nur mit -1°C. also haben wir ein +/- von 1°C in jede Richtung, was wir ja auch wollten.

ABER, jetzt kommt das aber.
Ich hatte in jüngster Vergangenheit eine Verzögerung angesprochen und jetzt dank funktionierender Optischer Ausgabe kann ich es erklären.
Das sind unsere Schalt/Regelpunkte  ( Testwerte um besser einstellen zu können )
Stufe 0 bis 45°C,
Stufe 1 bis 50°C,
Stufe 2 bis 55°C,
Stufe 3 bis 60°C, u.s.w bis 85°C
Ich hoffe das ich das jetzt gut geschrieben bekomme.
Ich benutze einen  Drehpoti um die Temperaturen einstellen zu können, ich drehe den Poti langsam bis mir am Display/Monitor 45°C angezeigt wird und drehe weiter auf 46°C und sehe am Display/Monitor wie die Stufe 1 eingelegt wird. Ab dem Moment dauert es gut 2 Sekunden bis sich die Drehzahl am Lüfter erhöht, das selbe auch wenn ich die Temperatur wieder senke und der Lüfter wieder langsamer drehen soll. Temperatur wird erreicht, Stufe schaltet und 2 Sekunden später reagiert der Lüfter. Genau das haben wir auch nach Systemstart, Lüfter geht auf Stufe 8 und dann alle 2 Sekunden eine Stufe runter.

Ich habe keine Erklärung dafür, wir arbeiten schon ohne Delay und ich kann nichts finden ob der Delay von wo anders herkommt.

Nur finde ich das nicht sehr schön das der Lüfter 2 Sekunden später reagiert.

Hier der momentane Code (komplett):
#include <PWM.h>                      // Bibliothek zur einstellung des PWM Signals
#include <Wire.h>                     // Wire Bibliothek für die I2C verbindung zum LCD
#include <LiquidCrystal_I2C.h>        // LiquidCrystal_I2C Bibliothek zur komunikation zum LCD
LiquidCrystal_I2C lcd(0x27, 20, 4);   // Hier wird das Display benannt (Adresse/Zeichen pro Zeile/Anzahl Zeilen).

// Konstanten
const int fanPin = 9;                 // Pin für den Lüfter
const int ntc = A0;                   // Pin für den 100kO NTC Wiederstand
const int ntcNominal = 10000;         // Wiederstand des NTC bei Nominaltemperatur
const int tempNominal = 25;           // Temperatur bei der der NTC den angegebenen Wiederstand hat
const int bCoefficient = 3977;        // Beta Coefficient(B25 aus Datenblatt des NTC)
const int serienWiederstand = 10000;  // Wert des Wiederstands der mit dem NTC in Serie geschalten ist
int ledBlau  = 12;                    // Pin für die blaue LED (Kalt) an Pin 12
int ledRot   = 11;                    // Pin für die rote LED (Heiss) an Pin 11
int32_t frequency = 25000;            // einstellen der Lüfterfrequenz  25Khz

/***********************************************
* Variablen
***********************************************/

// Temperatur und Messung
int abfrageZahl = 1;          // Je mehr abfragen, desto stabiler isr das Ergebnis, dauert aber länger
int abfrage[1];       // Array Variable für das Mitteln der Temperatur
float durchschnitt = 0;         // Variable für das Mitteln der Temperatur
float temp;               // Variable für die Berechnung der temperatur nach Steinhart

// Lüftersteuerung
int fanSpeed[10] = {55, 64, 71, 76, 89, 102, 120, 130, 178, 254};

int Stufe = 9;

int TempSchwellen[9] = {45, 50, 55, 60, 65, 70, 75, 80, 85}; // Für den Anfang größere Abstufungen, besser zum Testen
// int TempSchwellen[9] = {60, 63, 67, 70, 73, 77, 80, 82, 84};

int ds1 = 1;                          // Dowen/UpSet um 1°C unterdrückt Stufenschwankungen beim abkühlen

void setup()
{
  /* Startmelodie
  Die Spannungsausgabe für den Piezo-Lautsprecher wird im Sketch durch den Arduino-Befehl "tone"
  automatisch festgelegt. Erstes zeichen nach der Klammer ist der Anschnlusspin.*/
  tone(8, 1500);                     // Im Hauptteil wird nun mit dem Befehl "tone ( Pinnummer , Tonfrequenz )" ein Ton abgegeben.
  delay(250);                        // mit einer Dauer von 0,25 Sekunden
  noTone(8);                         // Der Ton wird abgeschaltet
  delay(50);                         // Der Lautsprecher kurz aus
  tone(8, 2500);
  delay(250);
  noTone(8);
  delay(50);
  tone(8, 3500);
  delay(250);   
  noTone(8);
  delay(50);
  tone(8, 4500);
  delay(250);
  noTone(8);
  delay(50);
  tone(8, 1500);
  delay(250);   
  noTone(8);

  // Lüfteranlauf
  //analogWrite(fanPin, 100);          // Lüfter startet und geht wieder aus

  // Frequenzustellung
  InitTimersSafe();                                       // Frenqenz umwandlung startet
  bool success = SetPinFrequencySafe(fanPin, frequency);  // Setzt die Frequenz auf Pin

  lcd.init();                        //Im Setup wird der LCD gestartet
  lcd.backlight();                   //Hintergrundbeleuchtung einschalten (0 schaltet die Beleuchtung aus).
 

  Serial.begin(9600);                // Baudrate für die Ausgabe am Serial Monitor
  pinMode(fanPin, OUTPUT);           // Setzt den Pin des Lüfters als Ausgang
  pinMode(ntc, INPUT);               // Setzt den Pin des NTC Wiederstands als Eingang
  pinMode(ledBlau, OUTPUT);          // definiere die blaue LED als Ausgang
  pinMode(ledRot, OUTPUT);           // definiere die blaue LED als Ausgang
}

void loop()
{
  temperaturberechnung();            // Startet die Temperaturerfassungsroutine

  // Lüfter schaltet in 10 Stufen
  switch(Stufe)
  {
    case 0:
      analogWrite(fanPin, fanSpeed[0]);
      if(temp > (TempSchwellen[0] + ds1))
      {
        Stufe++;
      }
    break;
   
    case 1:
      analogWrite(fanPin, fanSpeed[1]);
      if(temp < TempSchwellen[0])
      {
        Stufe--;
      }
      else if(temp > (TempSchwellen[1] + ds1))
      {
        Stufe++;
      }
    break;
   
    case 2:
      analogWrite(fanPin, fanSpeed[2]);
      if(temp < TempSchwellen[1])
      {
        Stufe--;
      }
      else if(temp > (TempSchwellen[2] + ds1))
      {
        Stufe++;
      }
    break;
   
    case 3:
      analogWrite(fanPin, fanSpeed[3]);
      if(temp < TempSchwellen[2])
      {
        Stufe--;
      }
      else if(temp > (TempSchwellen[3] + ds1))
      {
        Stufe++;
      }
    break;
   
    case 4:
      analogWrite(fanPin, fanSpeed[4]);
      if(temp < TempSchwellen[3])
      {
        Stufe--;
      }
      else if(temp > (TempSchwellen[4] + ds1))
      {
        Stufe++;
      }
    break;
   
    case 5:
      analogWrite(fanPin, fanSpeed[5]);
      if(temp < TempSchwellen[4])
      {
        Stufe--;
      }
      else if(temp > (TempSchwellen[5] + ds1))
      {
        Stufe++;
      }
    break;
   
    case 6:
      analogWrite(fanPin, fanSpeed[6]);
      if(temp < TempSchwellen[5])
      {
        Stufe--;
      }
      else if(temp > (TempSchwellen[6] + ds1))
      {
        Stufe++;
      }
    break;
   
    case 7:
      analogWrite(fanPin, fanSpeed[7]);
      if(temp < TempSchwellen[6])
      {
        Stufe--;
      }
      else if(temp > (TempSchwellen[7] + ds1))
      {
        Stufe++;
      }
    break;
   
    case 8:
      analogWrite(fanPin, fanSpeed[8]);
      if(temp < TempSchwellen[7])
      {
        Stufe--;
      }
      else if(temp > (TempSchwellen[8] + ds1))
      {
        Stufe++;
      }
    break;
   
    case 9:
      analogWrite(fanPin, fanSpeed[9]);
      if(temp < TempSchwellen[8])
      {
        Stufe--;
      }
    break;
  }
 
  // optische Ausgabe
  Serial.print("fanSpeed: ");
  Serial.print(fanSpeed[Stufe]);
  Serial.print(" - Stufe: ");
  Serial.println(Stufe);
  lcd.setCursor(0,2);       
  lcd.print("PWM: ");
  lcd.print(fanSpeed[Stufe]);
  lcd.print(" - Step: ");
  lcd.println(Stufe);         // Wenn das nicht funktioniert, dann lcd.print(Stufe + 0x30); probieren
}

void temperaturberechnung()
{
  // Nimmt N Abfragen in einer Reihe, mit einem kurzen delay
  for (int i=0; i < abfrageZahl; i++)
  {
    abfrage[i] = analogRead(ntc);
    delay(10);
  }
   
  // Mittelt alle Abfragen
  durchschnitt = 0;
  for (int i=0; i < abfrageZahl; i++)
  {
    durchschnitt += abfrage[i];
  }
  durchschnitt /= abfrageZahl;
   
  // Umwandlung des Wertes in Wiederstand
  durchschnitt = 1023 / durchschnitt - 1;
  durchschnitt = serienWiederstand / durchschnitt;
   
  // Umrechnung aller Ergebnisse in die Temperatur mittels einer Steinhard Berechnung
  temp = durchschnitt / ntcNominal;                   // (R/Ro)
  temp = log(temp);                                   // ln(R/Ro)
  temp /= bCoefficient;                               // 1/B * ln(R/Ro)
  temp += 1.0 / (tempNominal + 273.15);               // + (1/To)
  temp = 1.0 / temp;                                  // Invertieren
  temp -= 273.15;                                     // Umwandeln in °C
   
  // Ausgabe an den Seriellen Monitor
  Serial.print("Temperatur ");
  Serial.print(temp);
  Serial.println(" °C");
  // Was am LCD angezeigt werden soll
  lcd.setCursor(0,0);               // Text soll beim ersten Zeichen in der ersten Reihe beginnen..
  lcd.print("Temperatur:");         // In der ersten Zeile soll ein Text in Zeile 1 angezeigt werden
  lcd.print(temp);                  // Wert der in der Zeile 1 neben dem Text angezeigt wird
  lcd.print("C ");                  // Text der in der Zeile 1 neben dem Wert angezeigt wird

  // LED Temperaturwarung Blau zu Rot
  digitalWrite(ledBlau, HIGH);                        // macht die blaue LED am Start an
  if (temp >= 82) digitalWrite(ledBlau, LOW);         // mache die blaue LED bei 82 °C aus
 
  digitalWrite(ledRot, LOW);                          // macht die rote LED am Start aus
  if (temp >= 83) digitalWrite(ledRot, HIGH);         // mache die rote LED bei 83 °C an
 
  // Übertemperatur Summerwarung
  if (temp >= 84) {
    tone(8, 1500);                // mache den Summer bei 84 °C an
  }
  delay(1100);                      // mit einer Dauer von etwas über einer Sekunde
  noTone(8);                        // Der Ton wird abgeschaltet
  delay(25);                        // Dauer der Abschaltung

  // Sensordefekt Warnung ( LED wechselt von Rot zu Blau und Summer ertönt)
  digitalWrite(ledRot, LOW);        // macht die rote LED ab Start aus
  if (temp <= 0) {
    digitalWrite(ledRot, HIGH);   // mache die rote LED unter 0 °C an
  }
  if (temp <= 0) {
    tone(8, 1500);                // Aktiviert den Warnsummer
  }
  delay(1100);                      // mit einer Dauer von etwas über einer Sekunde
  noTone(8);                        // Der Ton wird abgeschaltet
  delay(25);                        // Dauer der Abschaltung
  // Fehlermeldung bei unterbrechung Sensor
  // LED Blau wechselt zu Rot und wieder zu Blau und so weiter ... Und Warnsummer ertönt.
  // Selbes Bild erscheint auch unter °0C
}








MaikLommatzsch

  • Lv 2: Newbie
  • *
  • Offline Offline
  • Beiträge: 54
    • Profil anzeigen
Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
« Antwort #48 am: 07. April 2022, 18:40:34 »
Moin Moin, lang ist es her aber nun ist es Zeit für ein Update.

Ich war aus persönlichen Gründen verhindert und hab dann auch noch Corona bekommen. Corona ist überstanden und nun hatte ich auch mal wieder Zeit für die Steuerung.

Ich habe das www durchsucht um eine Erklärung für die oben angesprochenen Verzögerung zu finden, tja nichts habe ich gefunden. Das einzige was ich herausgefunden hab, was man wissen sollte ist:
Das ein Delay ein Programmstop bedeutet was an der falschen Stelle schlecht sein kann, weil ebent das ganze Programm für die eingestellte Dauer aufhört zu arbeiten. Ich denke aber das die Delays in unseren Programm nichts beeinflusst weil die im LED Bereich zu finden ist. Gerne wird statt Delay die Timer Funktion genutzt, das hab ich aber noch nicht so ganz verstanden wie man die implementiert.

Dann hab noch herausgefunden das die Umstellung auf 25khz den Programmablauf beeinträchtigen kann, das aber auch nur in Zusammenhang mit Delay?!
Arduino arbeitet normal im MHZ Bereich, zwingt man ihn durch Programmierung im KHZ Bereich zu arbeiten ändert man wohl die Bitrate, zumindest hab ich das so verstanden. Ändert sich die Bitrate werden z.B. die Delayzeiten beeinflusst. Wie gesagt so hab ich das verstanden. Hat das noch Auswirkungen wo anders? I dont no.

Also konnte ich wegen der Verzögerung nichts finden.

Trotzdem hab ich jetzt die PS3 (V2) zusammengebaut. Kabel konnten gut nach außen verlegt werden und für später ist auch genug platz für den Arduino vorhanden.

Lüfter und Arduino würde extern mit Strom versorgt und es wurde die Teststufen verwendet. ({45, 50, 55, 60, 65, 70, 75, 80, 85}; // Für den Anfang größere Abstufungen, besser zum Testen).

Das ganze läuft jetzt folgendermaßen: (immer laut Display)
Ich habe die PS3 gut 45 Minuten am laufen gehabt und habe auch die meiste zeit ein Game gezockt ( Ratchet and Clank tools of destruction).
Zu den Temperaturen: Die Steuerung Arbeitete um die 60°C rum und die Abluft war bei 35°C.
In der Regel befanden wir uns im Bereich von 57°C bis 65°C und in der stufe 3 bis 4. Einmal wurde auch stufe 5 eingelegt.

Leider habe ich zum teil starke Schwankungen festgestellt, oft schwankt es um 3°C im Bereich von stufe 3 und 4. Was ein ständiges hin und her schalten des Lüfters verursacht.
3°C ist Regel, 5°C bis 6°C kommen leider auch oft vor.  Vielleicht bekommt das im griff in dem man die stufen ändert, z.B. 62°C anstand 60°C. Zumindest erklärt mir das warum Sony so
Große rücklaufende Temperatur Bereiche hat. Die Temperaturschwankungen  hat der originale Sensor sicher auch.

Kann der original Bereich doch irgendwie realisiert werden, oder ist doch unsere Temperaturmessung zu langsam?

Als nächstes möchte ich gerne die Temperaturen vergleichen, Original vs Extern. Muss ich dazu zwingend eine CFW draufmachen oder gibt es da Tools um die Temperatur auszulesen?