Benachrichtigungen

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?

Moino

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 (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    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

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:

int TempSchwellen[9] = {45, 50, 55, 60, 65, 70, 75, 80, 85};

Dort fehlte das int am Anfang und ein ; am ende

int abfrage[abfrageZahl];       // Array Variable für das Mitteln der Temperatur

Habe ich wieder in int abfrage[1]; geändert, es gab kein Bezug

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:

  // 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

//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):

Code Auswählen Erweitern

#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
}

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

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.

Hier der überarbeitete Programmcode. Ich kann ihn natürlich nicht kompilieren und damit nicht auf grobe Fehler prüfen

Die Arduino Software ist Freeware.

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 :-)

// Ü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.

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.

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.

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.

Und das hast du da programmiert

Das ist nicht von der Hand zu weisen, ich bin da zu 100% Schuld
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.

[int]

Ok ok, so Langsam raucht der Kopf

Nachdem ich die Fett markierten Satzzeichen ergänzt hatte, wurde der Code nach der Prüfung akzeptiert. Auch mit der Optischen Ausgabe.

Ich fügte dann noch int bei den TempSchwellen ein und ein [9] ein. wo wir dann bei
int TempSchwellen[9]{t60, t63, t67, t70, t73, t77, t80, t82, t84}; angekommen waren.
Dann noch int Hysterese = 2; wobei das Große H nicht gewollt war, warum auch immer, hab es dann klein geschrieben.

int LStufe 0;  durfte auch nicht fehlen. (Bei int LStufe 9; fuhr der Lüfter nach Start immer auf volle pulle und pendelte sich erst ewig später runter)

Code Auswählen Erweitern


TempSchwellen = {t60, t63, t67, t70, t73, t77, t80, t82, t84} [b];[/b] // 9 Schwellen -> 10 Stufen
Hysterese = 2;
// LStufe kann Werte von 0 bis 9 (10 Werte) annehmen

switch (fanSteps)                      // Anfang Lüfterstufen
{
case 0:                             // Case 0 = Lüfter schaltet in 10 Stufen

switch(LStufe)
{
case 0:
analogWrite(fanPin, fanSpeed0);
if(temp > (TempSchwellen[0] + Hysterese)[b])[/b]
{
LStufe++;
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed0);
       Serial.println(" - Stufe: 0");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed0);
       lcd.print(" - Step: 0 ");
}
break;

case 1:
analogWrite(fanPin, fanSpeed1);
if(temp < (TempSchwellen[0] - Hysterese))
{
LStufe--;
}
else if(temp > (TempSchwellen[1] + Hysterese)[b])[/b]
{
LStufe++;
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed1);
       Serial.println(" - Stufe: 1");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed1);
       lcd.print(" - Step: 1 ");

}
break;


Auf jeden fall Funktionierte da was, nur was genau kann ich leider nicht genau sagen. Da mir die Anzeigen fehlten. leider wurde mir nur die Temperatur ausgegeben.
Hab die Ausgabe auch nicht zum laufen gebracht. Was ich aber feststellen konnte war das die Reaktionszeit sehr träge war.

dann habe ich versucht das Hysterese Thema in meinen Code einzubauen.
Da ich es möglich Kurz mag nannte ich es ds1 steht für DowenSet und hat den Wert 1 erhalten. mehr oder weniger als1 wird leider nicht akzeptiert was ich schade finde, weil so hätte man mit den Wert 10 z.B das haben können was ich von anfang an wollte. ich gehe bei 74°C in die nächste stufe und bleibe mit ds 10 bis 64°C in der höheren Stufe. geht leider nicht, max und min ist 1.
Im Code schaut das dann so aus:

Code Auswählen Erweitern


   switch (fanSteps)                  // Anfang Lüfterstufen
   {
   case 0:                                // Case 0 = Lüfter schaltet in 10 Stufen
// statements
   if (temp < t60 ) {                                // bis 60°C bleibt Stufe 0
       analogWrite(fanPin, fanSpeed0);      // dann Lüfter auf speed0 55 (22%)

   }
   if (temp >= t60 and temp <= t63 [b]- ds1[/b] ) {       // Stufe 1 schaltet bei 60°C oder unter 63°C (62°C)
       analogWrite(fanPin, fanSpeed1);                            // dann Lüfter auf speed1 64 (25%)

   }
   if (temp >= t63 and temp <= t67 [b]- ds1[/b] )  {   // Stufe 2 schaltet bei 63°C oder unter 67°C (66°C)
       analogWrite(fanPin, fanSpeed2);                         // dann Lüfter auf speed2 71 (28%)

   }


Ja, somit ist das Stufensägen abgestellt, zumindest mit dem Drehpoti. Wäre interessant zu wissen wie es mit einen echten NTC funktioniert.
Wäre ein Live Versuch jetzt drin?
Gibt es noch Anregungen?


Dann bitte ich um eine Erläuterung was ein = bei >< ausmacht. Den mit oder ohne = konnte ich jetzt keine Änderung feststellen.

Hier nochmal der ganze Code:

Code Auswählen Erweitern

#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
   int t60 = 60;               // ab hier werden die benötigten Temeraturen angegeben
   int t63 = 63;
   int t67 = 67;
   int t70 = 70;
   int t73 = 73;
   int t77 = 77;
   int t80 = 80;
   int t82 = 82;
   int t83 = 83;
   int t84 = 84;
   int t85 = 85;

   int ds1 = 1;                // DowenSet um 1°C unterdrückt Stufenschwankungen beim abkühlen
   
   int fanSteps = 0;           // es wird mit Lüfterstufen gearbeitet

   int fanSpeed0 = 55;         // ab hier werden die Lüfter geschwindigkeiten
   int fanSpeed1 = 64;         // für jede Stufe gesetzt
   int fanSpeed2 = 71;
   int fanSpeed3 = 76;
   int fanSpeed4 = 89;
   int fanSpeed5 = 102;
   int fanSpeed6 = 120;
   int fanSpeed7 = 130;
   int fanSpeed8 = 178;
   int fanSpeed9 = 254;       // bei 255 arbeitet der Lüfter stoßweise. darum 254

   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


   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

   switch (fanSteps)                  // Anfang Lüfterstufen
   {
   case 0:                            // Case 0 = Lüfter schaltet in 10 Stufen
// statements
   if (temp < t60 ) {                       // bis 60°C bleibt Stufe 0
       analogWrite(fanPin, fanSpeed0);      // dann Lüfter auf speed0 55 (22%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed0);
       Serial.println(" - Stufe: 0");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed0);
       lcd.print(" - Step: 0 ");
   }
   if (temp >= t60 and temp <= t63 - ds1 ) {       // Stufe 1 schaltet bei 60°C oder unter 63°C (62°C)
       analogWrite(fanPin, fanSpeed1);             // dann Lüfter auf speed1 64 (25%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed1);
       Serial.println(" - Stufe: 1");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed1);
       lcd.print(" - Step: 1 ");
   }
   if (temp >= t63 and temp <= t67 - ds1 )  {        // Stufe 2 schaltet bei 63°C oder unter 67°C (66°C)
       analogWrite(fanPin, fanSpeed2);               // dann Lüfter auf speed2 71 (28%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed2);
       Serial.println(" - Stufe: 2");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed2);
       lcd.print(" - Step: 2 ");
   }
   if (temp >= t67 and temp <= t70 - ds1 ) {       // Stufe 3 schaltet bei 67°C oder unter 70°C (69°C)
       analogWrite(fanPin, fanSpeed3);             // dann Lüfter auf speed3 76 (30%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed3);
       Serial.println(" - Stufe: 3");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed3);
       lcd.print(" - Step: 3 ");
   }   
   if (temp >= t70 and temp <= t73 - ds1 ) {       // Stufe 4 schaltet bei 70°C oder unter 73°C (72°C)
       analogWrite(fanPin, fanSpeed4);             // dann Lüfter auf speed4 89 (35%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed4);
       Serial.println(" - Stufe: 4");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed4);
       lcd.print(" - Step: 4 ");
   }
   if (temp >= t73 and temp <= t77 - ds1 ) {       // Stufe 5 schaltet bei 73°C oder unter 77°C (76°C)
       analogWrite(fanPin, fanSpeed5);             // dann Lüfter auf speed5 102 (40%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed5);
       Serial.println(" - Stufe: 5");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed5);
       lcd.print(" - Step: 5 ");
   }
   if (temp >= t77 and temp <= t80 - ds1 ) {      // Stufe 6 schaltet bei 77°C oder unter 80°C (79°C)
       analogWrite(fanPin, fanSpeed6);            // dann Lüfter auf speed6 120 (47%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed6);
       Serial.println(" - Stufe: 6");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed6);
       lcd.print(" - Step: 6 ");
   }
   if (temp >= t80 and temp <= t82 - ds1 ) {       // Stufe 7 schaltet bei 80°C oder unter 82°C (81°C)
       analogWrite(fanPin, fanSpeed7);             // dann Lüfter auf speed7 130 (50%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed7);
       Serial.println(" - Stufe: 7");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed7);
       lcd.print(" - Step: 7 ");
   }
   if (temp >= t82 and temp <= t84 - ds1 ) {       // Stufe 8 schaltet bei 82°C oder unter 84°C (83°C)
       analogWrite(fanPin, fanSpeed8);             // dann Lüfter auf speed8 178 (70%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed8);
       Serial.println(" - Stufe: 8");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed8);
       lcd.print(" - Step: 8 ");
   }
   if (temp > t84 ) {                           // Stufe 9 schaltet ab 84°C
       analogWrite(fanPin, fanSpeed9);          // dann Lüfter auf speed9 254 (100%)
       Serial.print("fanSpeed: ");
       Serial.print(fanSpeed9);
       Serial.println(" - Stufe: 9");
       lcd.setCursor(0,2);       
       lcd.print("PWM: ");
       lcd.print(fanSpeed9);
       lcd.print(" - Step: 9 ");
   }
   break;
   }
// Ende Lüfterstufen
   }
   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 >= 83) 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
}

Vieles von dem was ich geschrieben hab ist leider nicht so verstanden worden wie ich es gemeint hab. Sorry das ich mich schriftlich nicht so gut ausdrücken kann.

@Takeshi

Die fehlende Klammer fehlte nicht, ist beim Copy/Paste verloren gegangen:-)  Ich hoffe das der nächste Code für dich besser zu lesen geht.
Ich habe verstanden was du vorgeschlagen hast, leider konnte ich deine Codes nicht umsetzen, sie haben einfach nicht funktioniert und ich kann noch nicht mal wirklich erklären warum.
Aber ich habe dennoch weiter probiert.

Ich bin jetzt so weit das jede der 9 Stufen  wirklich alleine laufen, anlaufen wann sie sollen auch rückwärts.
Es gibt keine Bereiche mehr. Das bedeutet jetzt das zwischen Bereich x und y gependelt werden kann. Das kann bestimmt nervig werden.

Hier der Code ( ohne optische Ausgabe)

switch (fanSteps)                  // Anfang Lüfterstufen
   {
   case 0:                            // Case 0 = Lüfter schaltet in 10 Stufen
// statements
   if (temp < t60 ) {                       // bis 60°C bleibt Stufe 0
       analogWrite(fanPin, fanSpeed0);      // dann Lüfter auf speed0 55 (22%)

   }
   if (temp > t60 and temp < t63) {       // Stufe 1 schaltet bei 60°C oder unter 63°C
       analogWrite(fanPin, fanSpeed1);    // dann Lüfter auf speed1 64 (25%)

   }
   if (temp > t63 and temp < t67)  {        // Stufe 2 schaltet bei 63°C oder unter 67°C
       analogWrite(fanPin, fanSpeed2);      // dann Lüfter auf speed2 71 (28%)

   }
   if (temp > t67 and temp < t70 ) {       // Stufe 3 schaltet bei 67°C oder unter 70°C
       analogWrite(fanPin, fanSpeed3);     // dann Lüfter auf speed3 76 (30%)

   }   
   if (temp > t70 and temp < t73 ) {       // Stufe 4 schaltet bei 70°C oder unter 73°C
       analogWrite(fanPin, fanSpeed4);     // dann Lüfter auf speed4 89 (35%)

   }
   if (temp > t73 and temp < t77 ) {       // Stufe 5 schaltet bei 73°C oder unter 77°C
       analogWrite(fanPin, fanSpeed5);     // dann Lüfter auf speed5 102 (40%)

   }
   if (temp > t77 and temp < t80 ) {      // Stufe 6 schaltet bei 77°C oder unter 80°C
       analogWrite(fanPin, fanSpeed6);    // dann Lüfter auf speed6 120 (47%)

   }
   if (temp > t80 and temp < t82) {       // Stufe 7 schaltet bei 80°C oder unter 82°C
       analogWrite(fanPin, fanSpeed7);    // dann Lüfter auf speed7 130 (50%)

   }
   if (temp > t82 and temp <t84 ) {       // Stufe 8 schaltet bei 82°C oder unter 84°C
       analogWrite(fanPin, fanSpeed8);    // dann Lüfter auf speed8 178 (70%)

   }
   if (temp > t84 ) {                     // Stufe 9 schaltet ab 84°C
       analogWrite(fanPin, fanSpeed9);    // dann Lüfter auf speed9 254 (100%)

   }
   break;
   }
// Ende Lüfterstufen 

Anregungen?

Danke Dragoon für dein Beitrag,
Der Teensy gibt 3,28V raus, manchmal weiß ich was ich tue

Ich habe all meine Quellen angegeben, wenn diese renommierten Quellen irgendwo sind dann ok.

Ich schließe Fehler von meiner Seite nicht aus, konnte aber keine erkennen.
Und ich möchte nochmal betonen, mit der getrennten A/CE Verbindung und Tristate auf Masse blieb die Konsole an!
Und das ist nun mal die Tatsache, schönen wenn ich es mir beim nächsten mal sparen kann

Fotos von den 3,3V

Ich verstehe schon warum Sony das mach. Die a eine bestimmte Temperatur erreichen. Darum fahren sie bis 74C mit 20% und die 20 % auch nur wegen Lüfter Anlauf. Dann wollen sie nicht das zu stark runter gekühlt wird, darum die vielen Stufen. Und der Temperatur Bereich ist dafür da das nicht ständig hin und her geschaltet wird. So verstehe ich das und hoffentlich konnte ich das rüber bringen.

Takeshi, ich denke zu verstehen was du meinst, macht natürlich auch Sinn einen fest Wert zu geben und mit + - darum pegeln zu lassen. Aber, jetzt kommt das aber. Der Code ist mein Problem. Ich poste nachher mal den Code den versucht hab.

Nachtrag: aktueller Code die ersten 3 stufen

switch (fanSteps)                   // Anfang Lüfterstufen
{
case 0:                             // Case 0 = Lüfter schaltet in 10 Stufen
      // statements
    if (temp < t74 ) {                          // wenn T innerhalb Stufe 0
        analogWrite(fanPin, fanSpeed0);     // dann Lüfter auf speed0 55 (22%)
----------------------------------------------------------------
        Serial.print("fanSpeed: ");
        Serial.print(fanSpeed0);
        Serial.println(" - Stufe: 0");                     nur Optische Ausgabe
        lcd.setCursor(0,2);                               der Werte  Temp und PWM   
        lcd.print("PWM: ");                              an seriellen Monitor und LCD
        lcd.print(fanSpeed0);
        lcd.print(" - Step: 0 ");
        delay(500);
-------------------------------------------------------------------
}
    if (temp >= t75 and temp < t60 ) {            // wenn T zwischen Stufe 0 und 1
        analogWrite(fanPin, fanSpeed1);      // dann Lüfter auf speed1 64 (25%)
        Serial.print("fanSpeed: ");
        Serial.print(fanSpeed1);
        Serial.println(" - Stufe: 1");
        lcd.setCursor(0,2);       
        lcd.print("PWM: ");
        lcd.print(fanSpeed1);
        lcd.print(" - Step: 1 ");
        delay(500);
}
    if (temp >= t76 and temp < t61)  {         // wenn T zwischen Stufe 2 und 3
        analogWrite(fanPin, fanSpeed2);      // dann Lüfter auf speed2 71 (28%)
        Serial.print("fanSpeed: ");
        Serial.print(fanSpeed2);
        Serial.println(" - Stufe: 2");
        lcd.setCursor(0,2);       
        lcd.print("PWM: ");
        lcd.print(fanSpeed2);
        lcd.print(" - Step: 2 ");
        delay(500);
break; 

Alle folgende Stufen sehen genauso aus, nur andere Werte

Ich bin noch dran, bekomm nur die Lüfterstufen nicht hin. Zumindest nicht so wie original.

Ich versuch es mal zu beschreiben.

Ich gebe die stufen ein, dann läuft stufe 0 bis 74 °C dann ab 75 schaltet Stufe 1 dazu. bei 76 stufe 2 u.s.w.
bei 85°C Laufen alle stufen. Das blöde ist: Es werden immer wieder ALLE stufen nacheinander durchgeschaltet 0...1...2..3...4...5...  natürlich delay abhängig.
ist stufe 9 erreicht geht es wieder von vorne los.    es geht auch nicht  das in einer stufe verharrt wird. Beispiel: Ich bleibe in Stufe 0 bis ich 74°C erreiche( läuft) erreiche ich dann 75°C schalte ich in Stufe 1  (Läuft), bleibe aber dann bis zum unterschreiten von 60°C in stufe 1 ( läuft nicht). Bin ich unter 74 °C schalte ich wieder in Stufe 0. Und das soll ja nicht.

Und so ergeht es mir in allen Stufen,  es funktioniert nur der eintritt in eine neu Stufe und ab dann wird jede vorherige immer wieder mit angesteuert.

Moino,
Hab nicht viel bisher geschafft.
Zumindest konnte ich den eigentlichen Lüftercode deutlich verkleinern. Ohne Funktion einzubüßen.
Ein bischen experimentiert hab ich auch, aber ich bin nicht zufrieden. Aber eine Richtung gefunden.
So schaut der gekürzte Code jetzt aus:

// Lüftergeschwindigkeit über den Temperaturbereich einstellen
  // TMin->0% PWM | TMax->100% PWM
  fanSpeed = map(temp, tMin, tMax, 55, 255);   

    analogWrite(fanPin, fanSpeed);      // Den Lüfter mit dem PWM Wert ansteuern

 
// Lüftergeschwindigkeit über den Seriellen Monitor ausgeben
  Serial.print("Lueftergeschwindigkeit: ");         
  Serial.println(fanSpeed);
  delay(250); 
}

Bei den Variablen konnte folgendes raus

int fanSpeed = 0;          // Variable für die Lüftergeschwindigkeit
int fanMin = 20;           // Kleinster PWM Wert für den Lüfter bevor er abschält

Hier hab ich mal die geplanten originalen Lüfterstufen vereinfachter dargestellt und ganz rechts
die PWM Werte ausgerechnet

P0: TempD:00.0 - TempU:74.0     duty:20%       51 (55 min. Anlaufdrehzahl)
P1: TempD:60.0 - TempU:75.0     duty:25%       64
P2: TempD:61.0 - TempU:76.0     duty:28%       71
P3: TempD:67.0 - TempU:77.0     duty:30%       76 
P4: TempD:68.0 - TempU:78.0     duty:35%       89
P5: TempD:71.0 - TempU:79.0     duty:40%      102
P6: TempD:71.5 - TempU:80.0     duty:45%      115
P7: TempD:72.0 - TempU:81.0     duty:50%      128
P8: TempD:72.5 - TempU:82.0     duty:60%      153
P9: TempD:73.0 - TempU:85.0     duty:100%     255

Dann hab ich noch einen, ich hoffe verständlichen Schaltplan gemacht.

[void setup(){]

Schönen Sonntag an euch.
Ich habe es etwas weiter geschafft.
Festgestellt habe ich ja schon das der PS3 Lüfter erst bei PWM 55 anspringt, aber tatsächlich erst bei PWM 0 wieder ausgeht und nicht wie erwartet unter PWM 55.
Selbsthalt kann daher nicht genutzt werden. Im Code lasse ich den PS3 Lüfter nun mit PWM100 anlaufen. Hat er PWM 100 erreicht geht er wieder aus.

Den Code habe ich jetzt im void setup(){ mit eingefügt.

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

Damit der Lüfter aber nicht wieder ausgeht habe ich die tMin für den Lüfter statt auf 0 PWM auf 55 PWM gesetzt.
Da tMin auf 20 °C gesetzt ist, bedeutet das wir ab 20°C dann automatisch ein PWM von 55 anliegen haben. Ist es kälter bleibt der Lüfter nach dem Anlauf ebent aus.
Ich denke aber das 20 °C ein guter Wert ist.
Das sieht im Code dann so aus:

// Lüftergeschwindigkeit über den Temperaturbereich einstellen
  // TMin->0% PWM | TMax->100% PWM
  fanSpeed = map(temp, tMin, tMax, 55, 255); 

Dann wollte ich mich selbst nochmal ein bisschen testen und habe noch einen Summer mit eingebaut (vom cok002 Schrottboard runter gelötet)

Ich wollte das die Steuerung meldet das sie sich einschaltet und bei Übertemperatur zusätzlich zur roten LED arbeitet.
der Code zur Startmelodie schaut so aus und wird auch unter void setup(){ eingefügt.

//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 ( x , y )" ein Ton abgegeben.
delay(250);   // mit einer Dauer von 0,5 Sekunden
noTone(8 );    // Der Ton wird abgeschaltet
delay(50);   // Der Lautsprecher bleibt 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 );

Den Code für das piepen bei Übertemperatur hab ich unten bei den LEDs mit eingebaut und schaut so aus

// Übertemperatur Summerwarung
  if (temp >= 82) tone(8, 1500);    // mache den Summer bei 82 °C an
  delay(1100);   // mit einer Dauer von etwas über einer Sekunde
  noTone(8 );    // Der Ton wird abgeschaltet
  delay(25);    // Dauer der Abschaltung

Dann ist mir noch eingefallen ein Art Fehler Code auszugeben.
Erstmal nur wenn der NTC Sensor eine Unterbrechung hat.

// 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

Ich finde das ist schon ne ganz nette Geschichte. Jetzt fehlt nur noch ne anständige Kurve.;-)  Ich werde demnächst mal ne Skizze von der Schaltung machen.

Moino,
Ich bin jetzt etwas weiter.
Der Test mit Heißluft ist nicht sehr effektiv, es ist sehr schwer Temperatur drauf zu bringen . Was aber soweit fakt ist, der Lüfter ist bei 50°C schon zu laut.
Ich hab es geschafft ein LCD einzubinden, hab ein neues gekauft da das erste defekt war.
Die blaue und rote LED hab ich jetzt auch eingebunden bekommen und läuft wie soll. Blau leuchtet bis 82°C und die rote LED leuchtet ab 83°C ( Rot soll noch vor der PS3 Wartung kommen)
Das 31Khz PWM Signal konnte ich auch auf 25Khz runter setzen. ( Mein Multimeter kann das messen)

Hier der Code

#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 10kO 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
int fanSpeed = 0;          // Variable für die Lüftergeschwindigkeit
int fanMin = 20;           // Kleinster PWM Wert für den Lüfter befor er abschält
int fanOut = 1;            // Variable zum pürfen ob der Lüfter aus war
int tMin = 15;             // Untere Grenze des Temperaturbereichs
int tMax = 84;             // Obere Grenze des Temperaturbereichs
int abfrageZahl = 5;       // Je mehr abfragen, desto stabiler isr das Ergebnis, dauert aber länger
int abfrage[5];            // 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


void setup()
{

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).
 
// TCCR1B = TCCR1B & 0b11111000 | 0x01;   // Setzt Timer1 (Pin 9 und 10) auf 31300Hz (Deaktiviert mit //)
  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()
{
// 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
lcd.setCursor(0,2);       // Dritte Reihe
lcd.print("FanSpeed:");
lcd.print(fanSpeed);
lcd.print("PWM");
 
  temperaturberechnung();      // Startet die Temperaturerfassungsroutine

   // Lüftergeschwindigkeit über den Temperaturbereich einstellen
  // TMin->0% PWM | TMax->100% PWM
  fanSpeed = map(temp, tMin, tMax, 0, 255);   
   
  // Wenn der PWM Wert unter den van FanMin fällt, schält der Lüfter ab
  if (fanSpeed < fanMin)
  {
    fanSpeed = 0;
    fanOut = 1;
  }
   
  // Hysterese
  if (fanOut == 1)
  {
    fanSpeed = 0;
  }
   
  if(temp >= 20) // Temperatur ab wann der Lüfter laufen kann
  {
    if(fanOut == 1)
    {
      fanOut = 0;
      analogWrite(fanPin, 255);
    }
  }
   
  // PWM Wert auf 255 begerenzen 
  if (fanSpeed > 255)
  {
    fanSpeed = 255;
  }
   
  // Lüftergeschwindigkeit über den Seriellen Monitor ausgeben
  Serial.print("Lueftergeschwindigkeit: ");         
  Serial.println(fanSpeed);

  analogWrite(fanPin, fanSpeed);      // Den Lüfter mit dem PWM Wert ansteuern
  delay(250); 
}


void temperaturberechnung()
{
  // Nimmt N Abfragen in einer Reihe, mit einem kurzen delay
  for (int i=0; i < abfrageZahl; i++)
  {
    abfrage = analogRead(ntc);
    delay(10);
  }
   
  // Mittelt alle Abfragen
  durchschnitt = 0;
  for (int i=0; i < abfrageZahl; i++)
  {
    durchschnitt += abfrage;
  }
  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");
  delay(500);

// LED Temperatursteuerung 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

  }

Der PS3 Lüfter springt erst bei PWM 55 an, darum möchte ich ihn erstmal bei Start anlaufen lassen, das bekomm ich noch nicht hin ohne das ich Temp/PWM Steuerung störe

Dann möchte ich die Lüfterkurve für die CPU einbauen
siehe original Code ( Quelle PS3 Developer Wiki )

P0: TempD:0.0(0x0000) - TempU:74.0(0x4a00) duty:20%(0x33)
P1: TempD:60.0(0x3c00) - TempU:75.0(0x4b00) duty:25%(0x40)
P2: TempD:61.0(0x3d00) - TempU:76.0(0x4c00) duty:28%(0x48)
P3: TempD:67.0(0x4300) - TempU:77.0(0x4d00) duty:30%(0x4d)
P4: TempD:68.0(0x4400) - TempU:78.0(0x4e00) duty:35%(0x5a)
P5: TempD:71.0(0x4700) - TempU:79.0(0x4f00) duty:40%(0x66)
P6: TempD:71.50(0x4780) - TempU:80.0(0x5000) duty:45%(0x73)
P7: TempD:72.0(0x4800) - TempU:81.0(0x5100) duty:50%(0x80)
P8: TempD:72.50(0x4880) - TempU:82.0(0x5200) duty:60%(0x99)
P9: TempD:73.0(0x4900) - TempU:85.0(0x5500) duty:100%(0xff)

>$ tshutdown get 0
tshutdown get 0
TZone No:00
1st BE Primary Temperature:85.0(0x5500)

Das ist jetzt nur die CPU Einstellung, im Originalen wer aber noch  RSX und SB mit einbezogen, das ist aber erstmal nicht vorgesehen und beschränke mich auf CPU da sie am wärmsten läuft.
Ich denke aber das ich hier Hilfe brauchen werde.

Moinsen, kleines Update 
Ich hab jetzt richtig viel Zeit in dieses Projekt gesteckt um zu erkennen das der Arduino Nano every absolut ungeeignet ist.
Kein Sketch hat richtig funktioniert und und und. Ich habe dann den Vorgänger aber als Clone besorgt. Ich hab nach ewiger suche einen Text gefunden wo der every als kaum Kompatibel zu fertigen Sketchs sein soll, obwohl er es Hardwareseitig sein soll.
Nun gut, der Clone ließ sich doch recht einfach in Betrieb nehmen und Tada, der nimmt fertige Sketchs und funktioniert einfach.

Somit habe ich den folgenden Sketch fast 1 zu 1 übernehmen können. ein bisschen hab ich schon dran gespielt.

// Konstanten
const int fanPin = 9;                 // Pin für den Lüfter
const int ntc = A0;                   // Pin für den 10kO 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

// Variablen
int fanSpeed = 0;          // Variable für die Lüftergeschwindigkeit
int fanMin = 25;           // Kleinster PWM Wert für den Lüfter befor er abschält
int fanOut = 1;            // Variable zum pürfen ob der Lüfter aus war
int tMin = 20;             // Untere Grenze des Temperaturbereichs
int tMax = 90;             // Obere Grenze des Temperaturbereichs
int abfrageZahl = 5;       // Je mehr abfragen, desto stabiler isr das Ergebnis, dauert aber länger
int abfrage[5];            // 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


void setup()
{
  TCCR1B = TCCR1B & 0b11111000 | 0x01;   // Setzt Timer1 (Pin 9 und 10) auf 31300Hz
  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
}


void loop()
{
  temperaturberechnung();      // Startet die Temperaturerfassungsroutine
   
  // Lüftergeschwindigkeit über den Temperaturbereich einstellen
  // TMin->0% PWM | TMax->100% PWM
  fanSpeed = map(temp, tMin, tMax, 0, 255);   
   
  // Wenn der PWM Wert unter den van FanMin fällt, schält der Lüfter ab
  if (fanSpeed < fanMin)
  {
    fanSpeed = 0;
    fanOut = 1;
  }
   
  // Hysterese
  if (fanOut == 1)
  {
    fanSpeed = 0;
  }
   
  if(temp >= 32)
  {
    if(fanOut == 1)
    {
      fanOut = 0;
      analogWrite(fanPin, 255);
    }
  }
   
  // PWM Wert auf 255 begerenzen 
  if (fanSpeed > 255)
  {
    fanSpeed = 255;
  }
   
  // Lüftergeschwindigkeit über den Seriellen Monitor ausgeben
  Serial.print("Lueftergeschwindigkeit: ");         
  Serial.println(fanSpeed);

  analogWrite(fanPin, fanSpeed);      // Den Lüfter mit dem PWM Wert ansteuern
  delay(500); 
}



void temperaturberechnung()
{
  // Nimmt N Abfragen in einer Reihe, mit einem kurzen delay
  for (int i=0; i < abfrageZahl; i++)
  {
    abfrage = analogRead(ntc);
    delay(10);
  }
   
  // Mittelt alle Abfragen
  durchschnitt = 0;
  for (int i=0; i < abfrageZahl; i++)
  {
    durchschnitt += abfrage;
  }
  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");
   
  delay(500);
}

Stand der dinge:
Im Sketch sind 10K eingetragen, ich nutze aber 100K. Funktioniert trotzdem, ändere ich das in 100K  läuft es nicht.
Ich nutze 5V weil es mit 3,3V nicht geht .
Die Schaltung ist wieder + von Festwiederstand komment.

Lüfter:  Es werden 31Khz ausgegeben, die Led, die den Lüfter simulieren soll wird sogar angesteuert.
Und Endlich mal Glück, der PS3 Lüfter läuft auch mit 31Khz Was das aber nun bewirkt weiss ich nicht, Takeshi wird sicher was dazu sagen können
Das nette ist: Die Test LED kann sogar als Indikator drin bleiben, somit ist das eine LED Problem schonmal gelöst.

Ich hab ein bisschen mit dem der Reglung gespielt und finde das sie so erstmal läuft aber wohl nicht so zweckmäßig ist.
Wir arbeiten im Bereich 20°C/0% Drehzahl | 90°C 100% Drehzahl. In einen entsprechenden PWM Bereich 0= 0% Drehzahl bis 255 = 100% Drehzahl
Ab 20°C ist die Reglung aktiv, ca bei 32°C schaltet sich der Lüfter ein, bei 50°C hat der Lüfter schon über 50% Drehzahl. ( das schon sehr Laut ist).
Da die C04 weit höhere Normal Temps hat , wird der Lüfter wahrscheinlich unerträglich laut laufen. Ich schätze so um die 75%.
Bei ca 90°C werden wir wohl die Abschaltwarung der PS3 erhalten und auch erst bei 90°C haben wir den Lüfter auf 100%.
Ich schätze da müssen dann Lüfterstufen rein die sich in einen bestimmten Bereich einpegeln. ( Hab ich noch keinen Plan von )

Ich habe auch schon ( siehe Fotos) einen Kühler und ein IHS auf 2mm aufgebohrt ( die Pips sind nicht beschädigt) und den Tempsensor dort untergebracht. Ich habe diese Position gewählt, weil ich
aus dem Lüfter Bereich raus wollte.

Mein nächster schritt:

Ich werde das ganze mit einen Schrottboard zusammen bauen und ein bisschen mit dem Lüftgebläse aufheizten und sehen was passiert.
Dann werde ich nochmal berichten ,ggf Änderungen (wenn vorhanden)von euch mit einfließen lassen und eventuell nochmal Testen.


Nebenbei versuche ich noch die Warn LED mit einzubringen und ein I2C LCD oder eine 7 Segment Anzeige mit einzubinden, was ich aber ums verrecken nicht hinbekomme
Solo läuft das prima, bringt nur nichts sich Radom irgendwelche Texte und Zahlen anzeigen zu lassen

Warum die Anzeige? Ich möchte irgendwann natürlich ohne PC die Werte ablesen können, den der Controller soll ja auch mal von der PS3 versorgt werden.

Am Cell hab ich mein neuen Künstelerspachtel ausprobiert, etwas runter geschliffen und poliert , und zack der IHS war ab.
War jetzt nicht das große Problem für mich, aber der RSX war der Hammer.

Sorry, das ich jetzt erst Feedback gebe, hatte etwas zu tun.

Als ich die Konsole bekommen hab, lief sie genau 40 sek nach dem anschalten, dann alles aus. ( neuer ylod)
Auf Start gedrückt und Led war wieder rot, dann das selbe Spiel.

Dann legte ich den Tristate auf Masse, und weil es so beschrieben war trennte ich auch A/CE (keine Ahnung was das ist, es sollte gemacht werden)
So blieb die Konsole an und wie auch hier im Forum mehrmals geschrieben, ist das eine große Wahrscheinlichkeit das die HW intakt ist.
Konsole weggestellt und Teensy bestellt. 14 Tage später teensy da, teensy eingelötet, alle Lötstellen mehrmals mit Vergrößerung gescheckt und Konsole geht sofort aus. Auch mit Tristate auf Maße.  Alles zurück gerüstet und Konsole geht weiterhin sofort aus.

Der teensy wurde sofort von Win10 erkannt und installiert.
Meine Anleitung war das
https://psxtools.de/forum/index.php?thread/48831-tut-teensy-2-0-nor-ps3-downgrade-dualboot-faq/&threadid=48831..

Für mich war es dann ganz einfach, ich habe eine Testmöglichkeit für die IHS ( siehe Thema dazu) und die Ersatzteile. Besonders das Gehäuse brauche ich für eine andere V10.
HDMI Chip ist wertvoll und auch die HDMI Buchse.  Festplatte geht immer und CD Laufwerk wenn noch heile ist ein Segen ;-)

Ich finde nicht das ich schnell aufgegeben hab , sondern ganz nüchtern für mich entschieden was mir von Wert ist.

Der teensy ist jetzt da und ich werde ihn sicherlich noch brauchen und dann auch wieder nutzen:-)

Trotzdessen bin ich für die geleistet Hilfe vom Forum sehr Dankbar

Es war ja am Tag als ich den teensy gekauft hatte so. Naja, sei es drum.