trisaster-Forum

Ältere Konsolen => PlayStation-Konsolen => PlayStation 3 => Thema gestartet von: MaikLommatzsch am 12. Januar 2022, 19:59:07

Titel: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 12. Januar 2022, 19:59:07
Hallo, ich möchte jetzt mit dem Projekt alternative Lüftersteuerung für die PS3 anfangen. Der Hintergrund ist eine Defekte original Lüftersteuerung die nicht mehr zu reparieren ist.

Ich möchte das mit einen Arduino Nano Every ( Aktuell bei Amazon 12,99) verwirklichen.  Das ist ein Frei Programmierbarer Mikroprozessor Controller  mit sehr kleinen Abmessung die hoffentlich auch ins PS3 Gehäuse passen.
Die PS3 die genutzt wird ist einen CECH C04 (V2)
Mein erster Plan:

Ich möchte den Originalen Temperatursensor vom Cell nutzen, das ist der das ist der IC1101, warum den)? Weil die Cell Heißer wird als der RSX ( Es kann auch der RSX Sensor oder sogar beide genutzt werden). Sollten die originalen Sensoren nicht genutzt werden können, gehe ich auf externe Temperatursensoren, wir werden sehen.
benötigt werden an daten der Norminalwiederstand. (der Wiederstand der bei ca 25°C Raumtemperatur herrscht und den Beta Coefficient.Das ist eine Materialkonstante (B25)

Der Arduino soll mit 5V vom Ps3 Netzteilversorgt werden und einschalten beim anlegen der Netzspannung.

Es soll der originale Lüfter verwendet werden der auch weiterhin von der Ps3 mit den 12V versorgt wird. (Der Arduino kann das ohne weiters nicht, muss er auch nicht) Zu beachten ist das wir eine Programmierung finden oder erstellen die ohne Tachosignal arbeitet, da der PS3Lüfter das Signal nicht bietet. Ansonsten können wir uns denke ich an 4Pin PC Lüfter orientieren. wie geschrieben der PS3 Lüfter Arbeiten wie ein 4 Pin PC Lüfter nur ohne Tachosignal. ( 3 Pin PC Lüfter nutzen kein PWM Signal, bitte nicht verwechseln.)

Mein anstreben ist es erstmal die Originale Lüfterkurve zu übernehmen.
(https://i.imgur.com/dnX4NjE.png)
Ich hoffe das ich da schon das richtige gefunden hab, wenn nicht bitte nicht mit Infos Geizen:-)

Zum Schluss, möchte ich gern noch in meinen fall eine Doppeldiode verbauen die im Normalbetrieb Blau leuchtet und so bald eine bestimmte Temperatur erreicht ist dann Rot leuchtet. (im Idealfall noch bevor die PS3 die Überhitzungswarnung bringt.

Ich denke das wars erstmal für den Anfang,  ich bin im Thema Arduino 0 drin, muss mich da also erst noch komplett schulen, wenn da jemand schon Erfahrung hat, und mir helfen möchte bitte bitte bitte gern :-).

Ich freue mich Tierisch auf dieses Projekt.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 12. Januar 2022, 21:35:28
Zitat von: MaikLommatzsch am 12. Januar 2022, 19:59:07
Das ist ein Frei Programmierbarer Mikroprozessor Controller [...]

Kleine Anmerkung dazu. Es gibt keinen "Mikroprozessor Controller", nur einen "Mikroprozessor" und einen "Mikrocontroller". Die unterscheiden sich darin, dass der Mikroprozessor nur die CPU enthält. Der Cell ist damit ein Mikroprozessor, genau so der Pentium 1 und der AMD Ryzen. Es gibt aber auch kleine Vertreter für wenige Euro und Watt. Mikrocontroller beinhalten neben der CPU noch alles andere, was man so braucht: RAM, Programmspeicher und verschiedene Ein- und Ausgabemodule (ADC, Schnittstellen wie UART, SPI und I²C).
Das, was du rausgesucht hast, ist ein Mikrocontroller.

Zitat von: MaikLommatzsch am 12. Januar 2022, 19:59:07
Ich möchte das mit einen Arduino Nano Every ( Aktuell bei Amazon 12,99) verwirklichen.
[...] ich bin im Thema Arduino 0 drin, muss mich da also erst noch komplett schulen, wenn da jemand schon Erfahrung hat, und mir helfen möchte bitte bitte bitte gern :-).

Ich muss direkt sagen, ich habe noch nie in meinem Leben mit Arduino gearbeitet. Die Plattform ist für Laien konzipiert (anfangs Studenten), nicht für den "professionellen Bereich". Ich habe Mikrocontroller bisher nur in C programmiert, aber auch noch keine von Atmel (jetzt Mikrochip). Das heißt bei der mikrocontrollerspezifischen Programmierung kann ich dir nicht helfen, aber bei der Hardware und dem Rest der Software, sprich Regelung, Messwertverarbeitung usw.

Für dich ist das aber sicherlich eine gute Wahl, da die Anforderungen an die Software in dem Projekt sehr gering sind. Das schafft die Arduino-Plattform und du musst dich mit dem komplizierten Kram nicht herumschlagen, den du ohnehin nicht brauchst.

Die Arduino-Sprache soll C sehr ähnlich sein. Ich schreibe die Ideen einfach in C. Entweder es passt, oder du musst es geringfügig anpassen, aber das Prinzip ist trotzdem klar.

Zitat von: MaikLommatzsch am 12. Januar 2022, 19:59:07
Der Arduino soll mit 5V vom Ps3 Netzteilversorgt werden und einschalten beim anlegen der Netzspannung.

Ich würde eher 3,3 V vom Mainboard verwenden. Der Mikrocontroller läuft sowieso mit 3,3 V, dann kannst du dir die Wandlung der Versorgungsspannung (Verluste = Wärme) sparen und noh viel wichtiger, der Mikrocontroller arbeitet an den Ein- und Ausgängen mit 3,3 V. Das hilft dir dann, wenn du an Signale gehst, die ebenfalls mit 3,3 V arbeiten. Mit 5 V besteht die Gefahr, dass du etwas beschädigst. Auf dem Mainboard arbeitet zwar viel mit kleineren Pegeln, aber auch einiges mit 3,3 V und zufällig das, wo du dran arbeiten möchtest. Ich glaube das PWM-Signal an den Lüfter hat einen Pegel von 3,3 V und die ICs zur Temperaturmessung ebenfalls.

Du sparst dir damit ebenfalls zu messen, ob die PS3 an ist. Es ergibt schließlich keinen Sinn die Temperatur zu messen, wenn die PS3 im Standby ist. Der Lüfter wird sowieso nicht versorgt. Mit 3,3 V versorgt würde der Mikrocontroller immer dann starten, wenn auch die PS3 startet und der Lüfter laufen muss.

Zitat von: MaikLommatzsch am 12. Januar 2022, 19:59:07
Ich möchte den Originalen Temperatursensor vom Cell nutzen, das ist der das ist der IC1101, warum den)? Weil die Cell Heißer wird als der RSX ( Es kann auch der RSX Sensor oder sogar beide genutzt werden). Sollten die originalen Sensoren nicht genutzt werden können, gehe ich auf externe Temperatursensoren, wir werden sehen.
benötigt werden an daten der Norminalwiederstand. (der Wiederstand der bei ca 25°C Raumtemperatur herrscht und den Beta Coefficient.Das ist eine Materialkonstante (B25)

Ich würde beide auswerten, schadet nicht. Du kannst immer den höheren der beiden Werte verwenden, dann bist du auf der sicheren Seite. Geht ganz simpel:
// temp_cell enthält die Temperatur des Cell
// temp_rsx enthält die Temperatur des RSX
// temp_max enthält die höhere der beiden Temperaturen

temp_max = temp_cell;
if(temp_rsx > temp_max)
{
    temp_max = temp_rsx;
}


Die Auswertung des vorhandenen Sensors ist aber sportlich. Ich habe keine Ahnung, was für eine Art von Sensor drin verbaut ist, ob das ein PTC oder NTC ist, oder etwas ganz anderes. K-Fühler schließe ich mal aus, das wäre kaum umsetzbar. Die verwendeten ICs geben aber eventuell einen Hinweis darauf.

Am Cell ist der AD51/067ARMZ-R (IC1101) verbaut, am RSX laut Manual ADT7461A0002RMZR (IC2101), ich tippe mal der ADT7461ARMZ-R (https://www.onsemi.com/products/sensors/thermal-management/temperature-sensors/adt7461) ist identisch. Vielleicht ist das eine kleine Spezialversion für Sony mit einer anderen Standard-Adresse oder so.

Wenn ich mir das Datenblatt ansehe, dämmert es wieder. Da wird die Kennlinie eines Transistors benutzt, die sich mit der Temperatur verschiebt. Auf Seite 8 im Datenblatt dargestellt. Das wird schwer das auszulesen. Ich nehme an der Cell macht das genau so, nur hat der Transistor eine andere Kennlinie und deshalb wird ein anderes IC verwendet.

Da ist es einfacher die Daten des ICs abzufischen, das den Sensor schon ausgewertet hat. Laut dem Datenblatt verwendet das IC SMBus, wobei SMBus auf I²C basiert und größtenteils kompatibel sein soll. Im Service Manual der PS3 steht sogar I²C im Signalnamen.
Hintergrund: Du findest eher einen Mikrocontroller, der für I²C spezifiziert ist, als für SMBus. Der von dir kann aber auch kein I²C, wenn ich mich verlesen habe.

Auch hier muss ich sagen, ich habe I²C noch nie selbst verwendet, kenne es nur in der Theorie. Der SysCon wäre auf jeden Fall der Master (IC4002, Pin T8 und T9). Der Mikrocontroller wäre ein Slave, genau so wie diese ICs. Die senden in jedem Paket ihre Adresse mit.
Ob es möglich ist ein I²C-Modul eines Mikrocontrollers so zu konfigurieren, dass es die Daten mitliest, weiß ich nicht. Eventuell
- fühlt sich der Mikrocontroller wegen der falschen Adresse im paket nicht angesprochen.
- speichert er aber auch das ganze Paket und es obliegt dem Programmierer zu entscheiden, ob ihn die Daten interessieren.

Wenn das allerdings klappt, hast du die optimalen Messwerte und kannst wirklich 1:1 die Lüftersteuerung der Konsole nachbauen.

Sollte das alles nicht klappen, bleibt noch mein erster Vorschlag: PT100 am IHS montieren, Temperatur dort mit einem Mikrocontroller messen und dann damit die PWM generieren.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 12. Januar 2022, 23:38:35
Danke das du meine nicht fachlichen Ausdrücke korrigiert hast👍 Hab mich gerade 20 mal selbst in den Hinteren getreten weil ich da so ein Stuss geschrieben habe 🤣. Die ICs vom Cell/RSX haben an pin 2 und 3 ihre Temperatur Meldung. D+ und D-, da plane ich dran zu gehen. Bei Raumtemperatur hab ich da so 7,5 Mohm gemessen, kurz mit dem Heissluftföhn drüber hab ich um die 10 Mohm gemessen. Müsste Dan die PTC Eigenschaft sein.

3,3 V ist auch ne möglichkeit, ich hatte aber wenn es um Details geht vor das abzusichern und noch eine Sperrdiode einzusetzen. Um die PS3 Hardware zu schützen.

Hier habe ich eine Schaltung und Programmierung gefunden auf die sich vielleicht aufbauen lässt.

http://www.scynd.de/tutorials/arduino-tutorials/3-luefter-steuern/3-4-temperaturgesteuerter-l%C3%BCfter.html (http://www.scynd.de/tutorials/arduino-tutorials/3-luefter-steuern/3-4-temperaturgesteuerter-l%C3%BCfter.html)
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 13. Januar 2022, 00:53:25
Zitat von: MaikLommatzsch am 12. Januar 2022, 23:38:35
Danke das du meine nicht fachlichen Ausdrücke korrigiert hast👍 Hab mich gerade 20 mal selbst in den Hinteren getreten weil ich da so ein Stuss geschrieben habe 🤣.

Ach was, das ist ja kein Thema. Wollte da nur drauf hingewiesen haben, nicht dass das mal bei einer Suche zu Problemen führt.

Zitat von: MaikLommatzsch am 12. Januar 2022, 23:38:35
Die ICs vom Cell/RSX haben an pin 2 und 3 ihre Temperatur Meldung. D+ und D-, da plane ich dran zu gehen. Bei Raumtemperatur hab ich da so 7,5 Mohm gemessen, kurz mit dem Heissluftföhn drüber hab ich um die 10 Mohm gemessen. Müsste Dan die PTC Eigenschaft sein.

"PTC" und "NTC" ist mehr als nur "fallendes" und "steigendes" Verhältnis aus Spannung zu Strom. Die Charakteristik ist wahrscheinlich völlig anders und der Widerstand bewegt sich in einem höheren Bereich. Bei 10 MOhm wird es schwierig mit einer Messung.

Zitat von: MaikLommatzsch am 12. Januar 2022, 23:38:35
3,3 V ist auch ne möglichkeit, ich hatte aber wenn es um Details geht vor das abzusichern und noch eine Sperrdiode einzusetzen. Um die PS3 Hardware zu schützen.

Wofür? Was bringt es dir mit 5 V zu arbeiten? Ich sehe nicht einen Vorteil.

Zitat von: MaikLommatzsch am 12. Januar 2022, 23:38:35
Hier habe ich eine Schaltung und Programmierung gefunden auf die sich vielleicht aufbauen lässt.

http://www.scynd.de/tutorials/arduino-tutorials/3-luefter-steuern/3-4-temperaturgesteuerter-l%C3%BCfter.html (http://www.scynd.de/tutorials/arduino-tutorials/3-luefter-steuern/3-4-temperaturgesteuerter-l%C3%BCfter.html)

Die Funktion map() kenne ich nicht, ich kann nur mutmaßen, dass der Rückgabewert von 0 bis 255 entsprechend der Temperatur und dem Temperaturbereich skalliert wird.

Das ist nicht gerade so, wie ich eine Lüftersteuerung umsetzen würde, aber das sollte noch gar nicht das Thema sein. Ein Schritt nach dem anderen. Als erstes musst du die Temperatur einlesen und eine PWM ausgeben können, um den Lüfter zu steuern (nicht regeln). Die Schnittstellen müssen stimmen. Wenn das läuft, kannst du dir Gedanken um die Regelung machen.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 13. Januar 2022, 09:28:30
Alles gut mit den 3,3V. Nichts dagegen einzuwenden👍
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 13. Januar 2022, 09:50:03
Zu der Sache mit PTC und NTC wollte ich noch etwas nachreichen. Nach der Argumentation ist faktisch alles ein PTC oder ein NTC, jede Diode, jeder Kondensator, jede Spule.
Das Problem hierbei ist, dass es sich um einen Transistor handelt. Dioden und Transistoren sind vom Verhalten her immer Temperaturabhängig, was bei der normalen Anwendung stört. Hier verwendet man nicht die normale Funktion des Transistors, sondern nutzt nur den sonst ungewollten Effekt der Temperaturabhängigkeit. Das heißt aber nicht, dass es kein Transistor mehr ist.
Vereinfacht bei einer Diode kannst du ebenso eine Widerstandmessung durchführen und wirst feststellen, dass dieser sich mit der Temperatur ändert. Noch stärker ändert sich der Widerstandswert jedoch mit der Spannung! Die kannst du am Multimeter nur nicht einstellen, weshalb dir der Effekt verborgen bleibt. Außerdem haben Dioden (und auch Transistoren) eine recht große Streuung. Während du bei der einen Diode vielleicht 10 MOhm misst, ist es bei der anderen nur 8 MOhm, bei gleicher Temperatur.

Hier kommt erschwerend hinzu, dass der Transistor noch verstärkt. Der Strom ist damit nicht nur abhängig von der Differenz der beiden angelegten Spannungen, sondern auch der absoluten Höhe gegenüber GND. Du musst also genau wissen, was du da tun musst, um einen brauchbaren Messwert zu erhalten. Normalerweise sagt dir das der Hersteller, hier jedosch schweigt er, wir haben keinerlei Informationen. Dadurch wird das noch mal viel schwieriger hier einen ordentlichen Messwert zu erhalten. Das IC verwendet übrigens eine Messbereichsumschaltung. Es legt einen Konstantstrom an, deren Größe umgeschaltet wird, je nach Messwert. Das machen die nicht ohne Grund.
Du kannst einen Glücksgriff landen, du kannst aber auch ewig im Dunklen tappen. Überlege dir also gut, ob du darauf setzen willst.

Ich hatte vergessen zu den LEDs zu antworten. Wenn du eine mehrfarbige LED benutzt, nimm eine mit gemeinsamer Anode. Die kannst du dann an 3,3 V oder auch einer höheren Spannung anschließen, an den beiden Kathoden dann den Widerstand anshließen und das mit einem kleinen Transistor schalten, der vom µC (Mikrocontroller) angesteuert wird. Wenn du die LED direkt ansteuern möchtest, musst du die LEDs mit 3,3 V versorgen, sonst wird die Spannung am µC zu groß.
Achte bei der Wahl der LED unbedingt darauf, dass du ein ordentliches Datenblatt dazu bekommst, sonst kannst du nur herumraten und wenn was nicht richtig geht, kann man nicht mal nach der Ursache suchen.
Eine LED mit Blau und Rot wird schwer zu finden sein. Entweder du nimmst eine RGB-LED, oder aber zwei getrennte LEDs. Ein paar solcher LEDs gibt es aber natürlich.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 13. Januar 2022, 11:14:26
Das Bild mit den Lüfterstufen, scheint wohl von Webman ( hack) zu sein, das Bild  ist jetzt ja nur ein kleiner Teil von was Größeren, ggf steht da ja noch mehr ?!  Ich habe nur das Ganze Bild nicht.
Oder ist es möglich sich die Daten aus den Syscon zu ziehen?

Ich möchte es ja auch nur versuchen mit dem zu Arbeiten was schon da ist. sollte es nichts bringen, setzen wir auch eigene Temperatursensoren.

Darum schrieb ich : In meinen fall eine BlauLED .... und Rote LED für........ :-) Das mit der Blau/Roten Doppel LED ist kein Problem, die habe ich da, sogar in beide Richtungen mit gemeinsamen Minus oder mit gemeinsamen Plus.  Die hatte ich gebraucht als ich meine XBOX classic gemoddet hatte.   Mir hat die Grüne LED im Laufwerksknopf nicht gefallen und tauschte die gegen Blau/Rot anstand Grün/Rot.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 14. Januar 2022, 00:06:15
Zitat von: MaikLommatzsch am 13. Januar 2022, 11:14:26
Das Bild mit den Lüfterstufen, scheint wohl von Webman ( hack) zu sein, das Bild  ist jetzt ja nur ein kleiner Teil von was Größeren, ggf steht da ja noch mehr ?!  Ich habe nur das Ganze Bild nicht.
Oder ist es möglich sich die Daten aus den Syscon zu ziehen?

Falls du meinen Kommentar "würde ich nicht so machen" meintest, ich bezog mich auf das Arduino-Beispiel.

Ich bin mir ziemlich sicher, Sony hat dafür gesorgt, dass man den nicht auslesen kann.

Zitat von: MaikLommatzsch am 13. Januar 2022, 11:14:26
Ich möchte es ja auch nur versuchen mit dem zu Arbeiten was schon da ist. sollte es nichts bringen, setzen wir auch eigene Temperatursensoren.

Gut, ich wollte es nur gesagt haben, da es dir wichtig schien, dass die Arduino-Platine nur 13 € kostet. Na dann mal sehen, vielleicht klappt es ja.
"Mit dem arbeiten was schon da ist" kann halt auch bedeuten die I²C-Daten auszuwerten ;)

Gut, dann geht es im ersten Schritt darum die Sensoren auszulesen. Hast du was vor Augen, wie du das beschalten möchtest? Mein Vorschlag für den ersten Schritt wäre die Platine zu kaufen und den Eingangswiderstand der ADCs zu messen. Es gibt Mikrocontroller, da haben einige Pins 100 kOhm, andere liegen über 10 MOhm.

Dann könntest du versuchen eine Kennlinie des Sensors aufzunehmen, heißt bei Raumtemperatur verschiedene Spannungen anlegen und Strom messen und gucken, ob es linear ist (vermutlich nicht). Und das bei verschiedenen Temperaturen wiederholen, diese möglichst genau messen.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 14. Januar 2022, 01:44:49
[
Zitat von: Takeshi am 14. Januar 2022, 00:06:15

Falls du meinen Kommentar "würde ich nicht so machen" meintest, ich bezog mich auf das Arduino-Beispiel.

Das habe ich schon verstanden, ich bezog mich auf das erste Bild im Startpost. Dort ist eine Webman Lüfterstufung zu sehen. Man kann ja über cfw die Lüfterregelungen beeinflussen und vielleicht lässt sich darüber noch mehr herausfinden.
Zitat
Ich bin mir ziemlich sicher, Sony hat dafür gesorgt, dass man den nicht auslesen kann.

Ok dann hat sich das wohl erledigt
Zitat
Gut, ich wollte es nur gesagt haben, da es dir wichtig schien, dass die Arduino-Platine nur 13 € kostet. Na dann mal sehen, vielleicht klappt es ja.
Nein nicht so wichtig wie es vielleicht rübergekommen ist oder du denkst. Aber Geld verbrennen möchte ich auch nicht. Der Arduino hat mich halt überzeugt und er kann Lüfter antreiben und hat die benötigte kleine Baugröße. Ich möchte auch nicht das wir eine Hightech Lüftersteuerung bauen die den Wert so mancher Ps3 übersteigt. Wäre es keine V2 würde ich das sicherlich nicht machen. Aber es ist nunmal eine V2 und von daher alles Gut.

Zitat
"Mit dem arbeiten was schon da ist" kann halt auch bedeuten die I²C-Daten auszuwerten ;)

Richtig

Zitat
Gut, dann geht es im ersten Schritt darum die Sensoren auszulesen. Hast du was vor Augen, wie du das beschalten möchtest?

Ich hätte 3,3v und GND auf den IC gegeben und an D+ und D- hätte Ich mein Multimeter gehangen und geschaut was mit dem Wiederstand passiert wenn ich den Cell erwärme.

Nachtrag: Hab nochmal auf PS3 Developer wiki
Nachgelesen das der eigentliche sensor im Cell/RSX sitzt und der jeweilige IC nur als Tempmonitor fungiert. Gehe ich recht mit der Annahme das wir den IC ignorieren können? Dann bräuchten wir ja nur den norminalwiederstand von CELL/RSX sensor rausmessen. Ggf den ic an einen schottboard auslötten. (2 Schrott cok002 hätte ich ja da)
Zitat
Mein Vorschlag für den ersten Schritt wäre die Platine zu kaufen und den Eingangswiderstand der ADCs zu messen. Es gibt Mikrocontroller, da haben einige Pins 100 kOhm, andere liegen über 10 MOhm.

Der Arduino ist heute angekommen
Weiss aber nicht genau was du meinst.
Zitat
Dann könntest du versuchen eine Kennlinie des Sensors aufzunehmen, heißt bei Raumtemperatur verschiedene Spannungen anlegen und Strom messen und gucken, ob es linear ist (vermutlich nicht). Und das bei verschiedenen Temperaturen wiederholen, diese möglichst genau messen.
Dazu fehlt mir das Temperaturmessgetät um das zu können.
Nachtrag: Wenn die Arduino Software auch ne Art Monitor Funktion bietet, das also gelesene Daten auch in der Arduino Software angezeigt werden, könnte ich das mit einen IR Thermometer abgleichen.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 14. Januar 2022, 14:55:01
Ich habe gerade erst gemerkt, du hattest das etwas falsch verstanden, aber jetzt stimmt's. Der Sensor sitzt im Prozessor, denn nur Dort ergibt es Sinn. So bekommst man die Temperatur direkt im Die, wo der Grenzwert nicht überschritten werden darf. Das IC wertet den Fühler aus und gibt die Temperatur über I²C raus. Der Fühler im Prozessor ist wie gesagt sehr speziell, aber das IC ist genau darauf ausgelegt und wird den Fühler genauer auswerten, als wir es selbst jemals könnten. Und as IC gibt es dann digital heraus, da kommt es nicht mehr zu Abweichungen.

Wenn du direkt am Sensor messen möchtest, musst du das IC auslöten. Das hatte ich nur noch nicht vorgeschlagen, weil du es wieder einlöten müsstest, wolltest du das IC doch verwenden.

Zitat von: MaikLommatzsch am 14. Januar 2022, 01:44:49
ZitatMein Vorschlag für den ersten Schritt wäre die Platine zu kaufen und den Eingangswiderstand der ADCs zu messen. Es gibt Mikrocontroller, da haben einige Pins 100 kOhm, andere liegen über 10 MOhm.

Der Arduino ist heute angekommen
Weiss aber nicht genau was du meinst.

Auch in den analogen Eingang des Mikrocontrollers fließt ein Strom, wenn du eine Spannung anlegst. Der ist meistens sogar sehr linear, das heißt für alle Spannungen ist das Verhältnis zumindest nahezu gleich. Damit verhält sich der Eingang wie ein normaler ohm'scher Widerstand. Bei manchen wie einer mit 10 MOhm, bei anderen wie einer mit 100 kOhm. Den Widerstand kannst du mit einem Multimeter messen. Du steckst deinen Arduino an USB, so dass er versorgt ist. Dann mit der schwarzen Leitung an GND und mit der roten Leitung am ADC-Eingang eine Widerstandsmessung durchführen. Falls dein Multimeter eine Bereichseinstellung hat, auf den höchsten Bereich einstellen.

Wenn du mit dem Sensor und einem Festwiderstand einen Spannungsteiler aufbaust, dann ist der Eingangswiderstand eventuell relevant. Wenn du zu einem 10-MOhm-Widerstand einen 100 kOhm (Mikrocontroller) parallelschaltest, dann merkst du eine Änderung auf 8 MOhm nicht mehr wirklich. Und selbst wenn, musst du den Widerstandswert mit einberechnen.
Ein handelsübliches Multimeter hat übrigens 10 MOhm Innenwiderstand bei der Spannungsmessung.

Zitat von: MaikLommatzsch am 14. Januar 2022, 01:44:49
Dazu fehlt mir das Temperaturmessgetät um das zu können.
Nachtrag: Wenn die Arduino Software auch ne Art Monitor Funktion bietet, das also gelesene Daten auch in der Arduino Software angezeigt werden, könnte ich das mit einen IR Thermometer abgleichen.

Ein IR-Thermometer wäre ja schon mal ein Temperaturmessgerät. Wenn die Arduio-Software keine Möglichkeit bietet dir Werte im Betrieb anzusehen, kannst du abhängig vom Messwert einen digitalen Ausgang umschalten. Den misst du und weißt dann zumindest, wenn eine Grenze über- oder unterschritten wurde.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 18. Januar 2022, 08:51:38
Moinsen,
Ich habe mal ein wenig weiter gemacht. An D+ und D- vom Cell hab ich Prüfkabel angelötet um mein Multimeter daran sicher anschließen zu können.
Bei ca 21°C liegen wir so tatsächlich bei ca 8 MOhm, erwärme ich den Cell bis auf ca 55°C singt der Wiederstad auf unter 3 MOhm. Beim abkühlen kann man auch beobachten wie der Wiederstad wieder steigt. Sogar schön gleichmäßig.
Was mich aber nervt ist, fasst man nur das board an zeigt das Multimeter schon 10 MOhm, oder wenn es nicht gerade liegt haben wir dort auch andere Werte.
Na Punkt um, nachdem ich die Prüfkabel angelötet hab und gemerkt hab das es doch sehr nervig ist wenn das Lötzinn da hin läuft wo es nicht hinsoll und in Anbetracht das ich keine weiten Infos zum Temperatursensor des Cells gefunden hab und ich eigentlich eine fast Jedermannslösung haben möchte, denke ich das wir auch externe Tempsensoren nehmen solten.
Eigentlich kosten die nicht die Welt und es stehen alle benötigten Daten zu Verfügung.

Takeshi du darfst jetzt schreiben : Ich hab es doch gesagt  ;D

Wo bauen wir die Sensoren hin?  Auf der Rückseite vom Cell wo wir die Öffnung im Board haben, da kommen wir sehr nah dran, den die NTCs habe ja auch eine gewisse Baugröße.
Welchen Sensor nehmen wir? Ich hab mal ein bisschen geschaut und bin irgendwie an den hängen geblieben NTC MF52 10K https://pdf.indiamart.com/impdf/23139658333/MY-8985295/ntc-mf52-103-3950-thermistor-10k-ohm.pdf (https://pdf.indiamart.com/impdf/23139658333/MY-8985295/ntc-mf52-thermistor-10k-ohm.pdf)
Was meint Ihr?
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 18. Januar 2022, 14:13:34
Ich hab es doch gesagt ;D

Ich hätte einen dünnen Schlitz oben in den IHS gefräst und nahe der Mitte einen PT100 oder NTC mit Wärmeleitpaste eingesetzt. Der von dir verlinkte NTC scheint mir dafür zu dick zu sein.

Gut geeignet wäre zum Beispiel der NB-PTCO-160 (https://de.farnell.com/sensor-solutions-te-connectivity/nb-ptco-160/rtd-sensor-d-nnschicht-platin/dp/2748869) (PTFC-Gehäuse) mit einer Dicke von maximal 1,25 mm.
Durch den PT100 schickst du einen Konstantstrom mit einem LM317. Ausgang und ADJ mit einem Widerstand verbinden, ADJ mit dem PT100 verbinden, andere Seite des PT100 mit GND. Der Strom entspricht 1,2 V durch dem eingesetzten Widerstand. Der PT100 hat bei 80 °C ca. 130,8 Ohm. Wenn du mit 3,3 V arbeitest, kommen aus deiner Stromquelle maximal 3,3 V - 1,2 V = 2,1 V heraus. Mit 2 V und 130 Ohm beträgt der Strom 15,4 mA. Dafür muss der Widerstand am LM317 78 Ohm sein. Das gibt es nicht. Der nächst höhere Wert ist 82 Ohm. Damit beträgt der Strom 1,2 V / 82 Ohm = 14,63 mA. Bei 0°C hast du am PTC 1,463 V anliegen, bei jedem °C mehr 5,634 mOhm mehr. Bei 80 °C bist du dann bei 1,914 V.

Die Methode hat einige Nachteile.
- Es wird nur ein kleinere Bereich des ADCs abgedeckt, nur rund 15%. Mit einem 10-Bit-ADC hast du aber schon 1024 Werte und mit 15% noch rund 150 verschiedene Werte. Das heißt deine Temperaturazflösung liegt bei ungefähr 0,5°C, das reicht locker für den Zweck.
- Der Strom der Stromquelle schwankt mit der Toleranz der Ausgangsspannung des LM317 und mit der Toleranz des Widerstands. Die Referenzspannung (eigentlich Ausgangsspannung) schwankt gern um 5 bis 10%, das heißt damit liegst du schon im einer Größenordnung deines Messbereichs. Die Toleranz des Widerstands kommt noch hinzu. Da es sich aber nicht um ein Serienprodukt handelt, spielt das keine große Rolle, denn du kannst die Software auf die konkrete Toleranz abstimmen. Du kaufst dir einfach einen sehr genauen Widerstand mit 100 Ohm. Den schaltest du statt des PT100 in Reihe und misst die Spannung, kannst du auch mit dem Mikrocontroller machen. Dann weißt du die Spannung bei 0°C und dir kann egal sein, wie sich der Strom ergibt, wie groß er genau ist und wie stark er bei einem weiteren Aufbau abweichen würde. Über Dreisatz kommst du dann auf die Spannungen bei anderen Temperaturen.

NTCs sind für die Aufgabe eigentlich besser geeignet, da sie zwar nicht linear sind, aber sich der interessante Bereich in Hardware leicht linearisieren lässt (mit nur einem Widerstand statt Konstantstromquelle) und du dann einen größeren Bereich des ADCs nutzt und dazu noch die Toleranzen viel geringer sind. Leider finde ich keine passenden NTCs in ähnlicher Bauform, weil für exakte Messungen mit beliebigem Schaltungsaufwand PT100 besser geeignet sind.

Du hast auch die Möglichkeit die Stromquelle zu kalibrieren. Dann nimmst du keinen 82 Ohm, sondern einen 91 Ohm und schaltest einen großen Widerstand parallel, bis der Strom deinem Sollwert entspricht. Dazu brauchst du aber entweder ein Widerstandssortiment, damit du genau den richtigen da hast, oder du musst zwei mal Widerstände kaufen. Dann misst du erst mit den 91 Ohm und berechnest daraus den benötigten Widerstand.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 18. Januar 2022, 15:16:43
Ich mach nochmal was ganz anders.
Ich benutze einen KY-013. Der ist schon für einen
Arduino konzipiert. NTC mit 10K Wiederstand und ich brauche kein weiteres Zeugs. Wenn ich das richtig verstanden habe. Den NTC kann man ja von der Platine wieder auslösen und mit Kabeln dort hinbringen wo er hinsoll.

Takeshi, genau davon hab ich schon ein paar TUTs gesehen, zum Teil verstehe ich das auch. Aber gaaanz ehrlich, nur zum Teil. Gib mir einen Schaltplan und die Bauteile und ich Bau dir das zusammen, aber da hört es bei mir leider auf. Berechnen und so ist leider nicht drin bei mir. 😩
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 18. Januar 2022, 16:22:24
Zitat von: MaikLommatzsch am 18. Januar 2022, 15:16:43
Ich benutze einen KY-013. Der ist schon für einen Arduino konzipiert. NTC mit 10K Wiederstand und ich brauche kein weiteres Zeugs.

So wie ich das sehe, ist das genau das, was ich mit dem NTC beschrieben habe, einfach nur der NTC und ein Festwiderstand in Reihe. Damit bekommst du im Bereich von 20C bis 50°C einen ziemlich linearen Verlauf und bis so 70...80°C noch passabel linear. Das ist deshalb, wie gesagt, auch der bessere Ansatz, nur fand ich auf die Schnelle keinen NTC, der mechanisch in Frage kommt.

Es ist immer schön, wenn es was Fertiges gibt, aber es ist Käse, wenn man dir nicht sagt, was es ist. Du kannst es so lange verwenden, wie es wie vorgesehen eingesetzt wird und auch problemlos funktioniert. Ist das nicht der Fall und du musst irgendwie Hand anlegen, hast du ein Problem. Ich erachte es als recht sinnlos die Platine zu kaufen, um den NTC herunterzulöten, denn es gibt zwei Möglichkeiten:
1. Die genaue Typbezeichnung des NTCs ist nicht bekannt, damit bekommst du keine Daten und kannst nicht so viel damit anfangen.
2. Die genaue Typbezeichnung ist bekannt, dann kannst du das Bauteil vermutlich auch einzeln für kleineres Geld kaufen.

Auf EasyEDA (https://easyeda.com/adrirobot/KY-013-Analog-temperature-sensor-module) wird mein Verdacht bestätigt. Es ist eine Reihenschaltung aus dem NTC und einem Festwiderstand, mehr nicht. Hat auch seine Berechtigung, wenn man keinen Lötkolben besitzt und was basteln möchte. Aber die Platine willst du ja gar nicht verwenden. Die Typbezeichnung steht dabei: NTCLE100E3103JB0 (https://octopart.com/search?q=NTCLE100E3103JB0&currency=EUR&specs=0)
Das Teil ist 3 mm dick und damit zu dick, um dafür eine Kule in den IHS zu dremeln. Da landest du nämlich auf dem Die.

Hab mich noch mal auf die Suche begeben und sogar etwas gefunden.
- Vishay NTCLE305E4103SB: 1,6 mm
- TDK/Epcos B57541G1103F005: 1,4 mm
- TDK/Epcos B57550G1103F000: 1,3 mm
- TDK/Epcos B57540G1103F000: 0,8 mm

Leider ist der mit 0,8 mm schon recht teuer, kostet knappe 3 € das Stück.

IHS habe ich übrigens zu Genüge da. Da kann ich dir welche geben, um damit herumzuexperimentieren und kann dir ggf. auch so eine Nut dort reinmachen.

Zitat von: MaikLommatzsch am 18. Januar 2022, 15:16:43
Takeshi, genau davon hab ich schon ein paar TUTs gesehen, zum Teil verstehe ich das auch. Aber gaaanz ehrlich, nur zum Teil. Gib mir einen Schaltplan und die Bauteile und ich Bau dir das zusammen, aber da hört es bei mir leider auf. Berechnen und so ist leider nicht drin bei mir. 😩

Ich hab das auch nur schnell zusammengeschrieben, da ich keine Zeit hatte für ein Schaltbild. Das kann ich dir aber später noch machen.
Berechnung ist auch nicht so schwer, du brauchst nur das ohm'sche Gesetz und Dreisatz, das war's. Das bekommt jeder hin, der eine Schule von innen gesehen hat ;) Du musst nur wissen, was du warum berechnen musst, wie du von einem auf den anderen Wert kommst. Das erkläre ich ja.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 18. Januar 2022, 18:21:59
Ich möchte schon das ganze Bauteil nutzen, der NTC wird nur runtergelötet um Kabel dran zu machen, denn die ganze Platine wird im Cell Bereich kein Platz finden. IHS hab ich auch ein paar über, daran soll es nicht scheitern 😉 Ist es unabdingbar das der Sensor im IHS montiert wird? Unter der Cell in der Öffnung im Mainboard geht nicht?
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 18. Januar 2022, 21:47:34
Dir ist schon klar, dass "das ganze Bauteil" eine Platine ist, auf der sich nichts weiter als der NTC und ein 10-kOhm-Widerstand befindet? Da ist nichts mit "weiter nutzen", weil da nichts weiter drauf ist. Du kannst die Platine benutzen, um deine Leitung durchzuschleifen, aber der Nutzen davon ist zweifelhaft. Da kannst du genau so ein Stück Lochraster verwenden oder eine fliegende Leitung mit Schrumpfschlauch.

Zitat von: MaikLommatzsch am 18. Januar 2022, 18:21:59
Ist es unabdingbar das der Sensor im IHS montiert wird? Unter der Cell in der Öffnung im Mainboard geht nicht?

Selbst im IHS ist schon nicht so optimal, da die Temperatur dort schon viel träger ist und vom Wert abweicht. Normalerweise wird ja direkt im Die gemessen. Unterhalb des Cells misst du einfach nur eine Temperatur, die in der Nähe des Cells irgendwo anliegt. An der Stelle bringt es dir besonders wenig, da zwischen Die und der Messung FR4 liegt (das Trägermaterial des Dies), das isoliert. Dann sind darunter noch viele Kondensatoren, die leitende Kontakte haben. Das musst du isolieren und eine elektrische Isolation geht meistens mit einer thermischen Isolation einher.




Im Anhang hast du einmal die Schaltung mit PT100 und mit NTC. Habe in beiden Schaltungen noch Kondensatoren hinzugefügt. Am Eingang des LM317 ist das ganz gut, damit er sauber arbeitet und am Ausgang zum ADC glättet er in beiden Fällen das Messsignal. Das sollte auf jeden Fall gemacht werden, Messwerte filtert man normalerweise immer, ist auf der einen Platine aber auch nicht drauf.




Die dünnen NTCs sind leider schwer zu bekommen, die finde ich nur bei übrigen Distributoren für Gewerbetreibende. Bei Mouser bestelle ich sicher wieder, aber ich weiß nicht genau wann das sein wird.

Die IHS von Cell und RSX sind übrigens 1,9 mm dick, hab ich mal nachgemessen.
Wenn alle Stricke reißen, dann kommt eine Kerbe in den Kühlkörper. Da ist die Messung aber schon wieder schlechter.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 19. Januar 2022, 17:59:26
Moinsen aus dem Krankenhaus. OP überstanden.
Ich habe 2mm ntcs gefunden kosten nicht die Welt. Damit werde ich erstmal werkeln bis du bestellen kannst.  Ich werde bei einen IHS  mal ein 2mm Loch komplett durch bohen. Und Nuten für die Bein machen. Zum testen für erste life Daten sollte es genügen.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 19. Januar 2022, 20:03:26
Dann gute und schnelle Genesung!

Das Loch sollte auf keinen Fall direkt über dem Die sein, sonst wird dir dort die Wärme nicht richtig abtransportiert und dir geht der Prozessor hopps.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 19. Januar 2022, 21:03:17
Ungefähre die Mitte unterm Kern.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 19. Januar 2022, 22:56:28
Jo, das ist in Ordnung.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 24. Januar 2022, 08:44:58
Moinsen, Stand der dinge:
Ich habe es schonmal geschafft mit den Arduino und den KY-013 Temperaturen zu messen  ;D
Mit 5V schonmal kein Problem, das schaut recht gut aus. Mit dem IR Thermometer  ca 1°C unterschied.
Bei 3,3v schaut das schon ganz anders aus. auch wenn ich im Programm den max. Wert ändere.
Ich bin so vorgegangen ( was sicherlich falsch ist) 1024 bei 5V Hab ich das geteilt 1024/5 und mit 3,3 wieder Multipliziert. Sind wir bei 676.
Das Funktioniert besser, aber es herrscht ein unterschied von 6 bis 10 °C zum IR Thermometer.

Gut das soll mich jetzt erstmal nicht aufhalten. das lässt sich bestimmt richtig Programmieren.
Ich hab mir jetzt ein paar Hilfsmittel bestellt, ein Steckbrett Set u.s.w. das wird mir sicherlich in Zukunft noch nutzen.

@Takeshi  der LM317 wozu genau brauchen wir die Schaltung mit dem Gerät? Das leuchtet mir nicht so ganz ein.
Ich würde das Teil trotzdem gerne Besorgen, finde bei ebay aber nur welche mit einen Buchstaben am ende. ( LM317L oder T)
ist das egal welchen?
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 24. Januar 2022, 10:34:38
Zitat von: MaikLommatzsch am 24. Januar 2022, 08:44:58
Moinsen, Stand der dinge:
Ich habe es schonmal geschafft mit den Arduino und den KY-013 Temperaturen zu messen  ;D
Mit 5V schonmal kein Problem, das schaut recht gut aus. Mit dem IR Thermometer  ca 1°C unterschied.
Bei 3,3v schaut das schon ganz anders aus. auch wenn ich im Programm den max. Wert ändere.
Ich bin so vorgegangen ( was sicherlich falsch ist) 1024 bei 5V Hab ich das geteilt 1024/5 und mit 3,3 wieder Multipliziert. Sind wir bei 676.
Das Funktioniert besser, aber es herrscht ein unterschied von 6 bis 10 °C zum IR Thermometer.

Eigentlich musst du gar nichts umstellen, das verwundert mich, oder bei Arduino ist da was grundlegend anders, was ich nicht glaube.
Der Spannungsbereich des ADCs wird in eine feste Anzahl von Werten geteilt, bei deinem scheinbar 1024 (10 Bit). Versorgst du mit 5 V und musst 2,5 V (die Hälfte), dann ist das Ergebnis 512. Versorgst du mit 3,3 V und misst 1,65 V (ebenfalls die Hälfte), kommt genau so 512 raus.
Die Schaltung des KY-013 ist ein einfacher ohm'scher Spannungsteiler. Er ändert sich mit der Temperatur, aber dennoch ist es ein einfacher Spannungsteiler. Bei 20°C sind beide Widerstände gleich, womit die Ausgangsspannung genau die Hälfte der Eingangssspannung ist, immer. Somit ist der Messwert unabhängig von der Höhe der Versorgungsspannung. Das ändert sich nur, wenn die Spannung des Messteilers und des Mikrocontrollers unterschiedlich sind. Hier würde ich mal ansetzen.

Bei einem Thermoelement ("K-Fühler") ist das übrigens anders. Die sind kleine Spannungsquellen und die Spannung entspricht der Temperatur. Sie ändert sich nicht mit der Versorgungsspannung. Kämen da 3,3 V heraus und du versorgst mit 5 V, wäre der Messert 1024*3,3/5,0 = 676. Mit 3,3 V versorgt wäre er 1024, also größer, denn du erreichst ja bereits bei einer kleineren Mess-Spannung den Maximalwert, den der ADC messen kann. Deine Rechnung wäre somit umgekehrt. Sind es bei 5 V 1024, müssten es bei 3,3 V 1552 sein - was nur theoretisch richtig wäre, da es den Wert praktisch nicht gibt.
Das ist hierfür aber nicht wirklich relevant, da wir ein anderes Messprinzip haben. Das sollte nur verdeutlichen, wie du es umrechnen müsstest, wäre es nötig.

Zitat von: MaikLommatzsch am 24. Januar 2022, 08:44:58
@Takeshi  der LM317 wozu genau brauchen wir die Schaltung mit dem Gerät? Das leuchtet mir nicht so ganz ein.
Ich würde das Teil trotzdem gerne Besorgen, finde bei ebay aber nur welche mit einen Buchstaben am ende. ( LM317L oder T)
ist das egal welchen?

Der LM317 wird als Stromquelle benötigt, um bei einem PTC einen Konstantstrom und damit eine linear abhängige Mess-Spannung zu erreichen. Bei einem NTC brauchst du ihn nicht, da ist er sogar von Nachteil.
Die Bezeichnung dahinter ist egal, die ist herstellerspezifisch. Der LM317 muss aber einige Eigenschaften haben.
- Die maximale Leistung muss hoch genug sein. Bei 15 mA und 2 V Spannungsabfall ergeben sich 30 mW. Der sollte also mindestens 60 mA können.
- Dabei fällt mir ein zweiter Punkt auf und dass die Schaltung so gar nicht funktioniert. Der "Dropout" muss hoch genug sein. Das ist der minimale Spannungsabfall, der zwischen Ein- und Ausgang anliegen muss. Der liegt meistens so bei 1,5 bis 2 V, ich habe 0 V angenommen. Die Stromquelle müsste deshalb mit 5 V versorgt werden, dann geht es.

Ich habe hier welche im TO-220-Gehäuse gefunden für ca. 80 Cent. Was kosten die, die du gefunden hast?
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 24. Januar 2022, 15:34:39
OK, verstanden. Dann hab ich igentwo einen Fehler gemacht. Der KY ist sowieso anders geklemmt als angegeben.  Die 317 kosten unterschiedlich.  Nach Menge und Versand natürlich. Kommt aber hin mit deinen 80 Cent.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 27. Januar 2022, 14:30:05
moin, Update.
Der Fehler von letztens war so einfach, aber dennoch sehr langwierig raus zu finden.
Das lag an der Bitrate, die Skripte die ich hatte waren/sind alle für 8bit Arduino. Ich habe aber ein 10 Bit Arduino.
Schwup waren aus 1024  mal ebent 4095.. Und das haut natürlich nicht hin. also ab jetzt mit 4095 Arbeiten.

Ich kann aber jetzt Temperaturen messen ;D.
Ich benutze ein 100K NTC und einen 100K Festwiederstand . (2mm durchmesser)
Schaltung wie die von Takeshi nur anders herum gepolt. Funzt in aber beiden Richtungen.
3,3V hab ich auch anliegen. Ich finde die gemessenen Temps sehr gut,
den würde ich eher glauben als meinen IR Thermometer.
Die folgende Programmierung hab ich genutzt.

Zitat
int ThermistorPin = A0;     // Signal eingang am Arduino
int Vo;
float R1 = 10000; // value of R1 on board
float logR2, R2, T;
float c1 = 0.001129148, c2 = 0.000234125, c3 = 0.0000000876741; //steinhart-hart coeficients for thermistor


void setup()
{

Serial.begin(9600); // Aktivieren des Monitors

}
void loop() {
  Vo = analogRead(ThermistorPin);
  R2 = R1 * (4095.0 / (float)Vo - 1.0); //calculate resistance on thermistor   // hier waren die Bits (4095) entscheidend
  logR2 = log(R2);
  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2)); // temperature in Kelvin
  T = T - 273.15; //convert Kelvin to Celcius
// T = (T * 9.0)/ 5.0 + 32.0; //convert Celcius to Farenheit
  Serial.print("Temperature: ");
  Serial.print(T);
  Serial.println(" C");
  delay(500);

}


Neues Problem.
Ich bekomme diese Temperaturmesseung mit nichts kombiniert, keine Blaue Led die ab 20°C angehen soll und ab 90° in Rot wechselt.
Auch keine 7 Sekmentanzeige bekommt ich hin das mit dort die Temp angezeigt werden. (sie ist richtige verkabelt) Die Anzeige war für den Probelauf gedacht, nicht für später mit einzubauen.
Alles was ich bisher versucht hab läuft nicht! Ich denke das hat was damit zu tun weil die Leute in den TUTs immer digitale Sensoren nehmen. (3polig) Ich bin erstmal nicht in der Lage die Skripze so zusammen zu schreiben das läuft. und jetzt raucht mir der Kopf ;D



Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 27. Januar 2022, 20:01:25
Das motiviert mich eben zum Klugscheißen.

Du meintest eher die "Bitbreite". Bitrate ist Daten pro Zeit, Bitbreite ist die Menge an Daten zu einer Zeit. Hierbei spricht man aber eher von einer ADC-Auflösung von 8 bzw. 10 Bit.
Mit 8 Bit hast du 1024 verschiedene Werte. Da die 0 auch ein Wert ist, ist der maximale Wert 1023. Bei 10 Bit sind es 4096 Werte, Maximum 4095.
Aus 1024 wird also 4096 und aus 1023 wird 4095.

Wenn du die Schaltung umgekehrt anschließt, sinkt die Spannung bei steigender Temperatur. Das ist egal, so lange das die Software richtig herum auswertet. Kommt also auf die Funktion an. Mit einer Funktion kann es nicht in beiden Richtungen funktionieren.

Zitat von: MaikLommatzsch am 27. Januar 2022, 14:30:05
Neues Problem.

Ich denke nicht, dass es was mit dem Sensor zu tun hat, sondern damit, dass du keinen GPIO angesteuert bekommst. Ich empfehle dir erst einmal zu versuchen einem Ausgang einen festen Wert zuzuweisen, abhängig von gar nichts. Du kannst den Ausgang mit dem Multimeter messen, oder direkt den Ausgang der LED verwenden und auf die LED schauen. Dafür eignet sich gut ein neues Programm, das nur daraus besteht, dass dieser GPIO als Ausgang arbeitet und auf 1 gesetzt wird. Klappt das, lässt du ihn als Ausgang und setzt ihn fest auf 0. Klappt auch das, implementierst du das in deinem Temperatur-Programm. Klappt es auch dort, versuchst du den Zustand abhängig von der Temperatur zu machen.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 31. Januar 2022, 11:00:22
Ok, die Bitbreite ::), ( Bitte nicht damit aushören Takeshi ).

Ich habe einen Linearen Temperatur anstieg, aber im Minusbereich.
Ich starte die Messung und hier in meinen Bastelzimmer bei knapp 20°C. Ausgegeben wird -20°c.
Schalte ich nach Takeshi s Plan (Sensor Plusseitig) Startet die Messung bei -20 °C und beim erwärmen steigt es in Richtung Plus, -19 > -17> -15 u.s.w.
Schalte ich den Sensor Minusseitig, starte ich wieder bei -20°C falle aber beim erwärmen weiter ins Minus > -21> -23> -26> -28 u.s.w.
Zweiteres ist ja schonmal gut, somit ist eine Lineare Steigerung mit brauchbaren Werten, nervig ist das ganze aber schon, den egal was ich mache ,ich schaff es nicht das es richtig angezeigt wird.
Desweitern bekomm ich keine LED / Lüftersteuerung implementiert.

Ich finde auch im www nichts was mir dazu helfen könnte. Dabei sind wir noch nicht mal beim schwierigsten Punkt. Der wäre das 25Khz Signal :(
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 31. Januar 2022, 12:29:53
Schau dir mal den Wert von Vo an, dem direkten Wert aus dem ADC. Der müsste bei Raumtemperatur ungefähr 2047 sein und mit steigender Temperatur steigen.

Du kannst jetzt das Problem analytisch angehen und versuchen den Fehler zu finden, oder es einfach geradeklöppeln und drauf hoffen, dass der Wert stimmt.
//T = T - 273.15;
T = 273.15 - T;


Damit wird T einfach invertiert und damit stimmt das Vorzeichen. Das ist zwar NICHT der Fehler im System, aber damit biegst du es wieder gerade.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 31. Januar 2022, 15:00:32
Der Invert hat funktioniert  ;D
Der Ausgelesene Vo  bei 20°C ist 382 und sinkt bei zunehmender Temperatur.

Am A0 messe ich 1,758 Volt.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 31. Januar 2022, 20:39:03
382 ist echt wenig und passt auch gar nicht ins Bild. Wenn der Maximalwert 511 (2⁹-1) wäre, wären das grob 3/4 des Messbereichs statt 1/2 und bei 1023 (2¹⁰-1) dann 3/8. Das ist zwar näher an 1/2 dran, aber noch immer zu weit weg. Nur ganz falsch kann der Wert auch nicht sein, sonst käme mit der Berechnung nicht für mehrere Temperaturen ein passendes Messergebnis raus. Echt komisch.

1,758 V sind 53%, das passt dagegen ganz gut, sogar die Richtung (über 50%) stimmt.

Kannst du inzwischen die LED wie gewünscht ansteuern?
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 31. Januar 2022, 20:49:44
Nein, hab noch kein passenden Befehl dazu gefunden und die selbst Schulung mit 180 pdf Seiten ist sehr trocken und ich tu mich echt schwer das zu verstehen .
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 08. Februar 2022, 11:13:32
Moinsen, kleines Update  ;D
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.
Zitat// 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 ;D 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.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 12. Februar 2022, 16:50:05
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
Zitat#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 )
Zitat
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.

Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 13. Februar 2022, 16:47:51
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.

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

Zitat// 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.
Zitat
//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
Zitat// Ü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.
Zitat// 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.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 17. Februar 2022, 08:43:13
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:
Zitat// 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
Zitatint 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
Zitat
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.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 05. März 2022, 20:09:27
Nur kurz nachgefragt: Bist du noch dran? Nicht dass ich jetzt antworte und dann ist das sowieso schon gestorben.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 06. März 2022, 16:04:56
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.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 06. März 2022, 21:14:45
Ich verstehe bis heute nicht, wieso Sony überhaupt zwischen festen Stufen umschaltet. Ich würde das "analog" machen. Richtig analog funktioniert das natürlich nicht, aber so feinstufig, dass es wie analog wirkt. Eine mögliche Erklärung kann ich mir vorstellen: Dass es als unangenehm wahrgenommen wird, wenn die Drehzahl sich ständig ändert, ein Springen als angenehmer wahrgenommen wird. Aber glaube ich eher nicht.

Ich würde dafür einen (P)I-Regler einsetzen, da fast jede Regelung mit einem PI-Regler realisiert wird. Das P steht für "proportional" und das I für "integral". Klingt komplizierter, als es ist. Du misst die Temperatur und bildest die Differenz zu einem Sollwert, zum Beispiel 60 °C. Hast du 65 °C, kommt "+5" heraus, bei 50 °C kommt "-10" heraus. Diese Differenz addierst du auf eine Variable auf (Summe), die bei 0 startet. Wenn du dauerhaft 61 °C misst, wird die Variable also immer und immer größer. Diese Summe multiplizierst du mit einem Faktor und das Ergebnis ist dann die Pulsweite der PWM.
Du musst darauf achten, dass die Aufaddierung in festen zeitlichen Abständen passiert und dass die Variable nicht zu groß und nicht zu klein wird. Wie du es schaffst die Ausführung des Codes in festen Zeitabständen zu realisieren, kann ich dir nicht sagen, das ist stark abhängig vom verwendeten System.
Die Ausführungshäufigkeit, den Faktor und den Sollwert müsstest du in Tests ermitteln. Mit steigender Häufigkeit muss der Faktor kleiner werden, weil die Summe schneller steigt. Ich denke 100 Ausführungen pro Sekunde reichen locker, eher sogar 10.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 07. März 2022, 07:32:37
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
Zitatswitch (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
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 07. März 2022, 23:14:05
Zitat von: MaikLommatzsch am 07. März 2022, 07:32:37
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.

Es ist eigentlich genau umgekehrt. Der von mir beschriebene Ansatz sorgt dafür, dass eine Temperatur gehalten wird, die Konsole also nicht stark herunterkühlt. Außerdem sorgend die diskreten Stufen dafür, dass ständig hin- und hergeschaltet wird. Nehmen wir an, die Stufen gingen in 10-%-Schritten und man bräuchte genau 35 %, um eine Temperatur zu halten. Dann springt die Drehzahl ständig zwischen 30 % und 40 % hin und her. Das konnte ich schon beobachten. Genau so springt die Temperatur, was vermieden werden sollte, da das die Lötverbindungen auf Dauer schädigt.

Ich hätte meinem Code auch noch hinzugefügt, dass die Drehzahl einen festgelegten Wert nie unterschreitet, damit der Lüfter nicht ausgeht. Das hatte ich der Einfachheit halber erst einmal weggelassen.

Zu deinem Code: Wenn ich das richtig interpretiere, dann steht t74 für den Messwert bei 74 °C usw., richtig? Dann bedeutet die
- erste if-Bedingung, dass sie wahr ist, wenn die Temperatur unter 74 °C liegt.
- zweite Bedingung, dass sie wahr ist, wenn die Temperatur über 75 °C liegt UND unter 60 °C.
- dritte Bedingung, dass sie wahr ist, wenn die Temperatur über 76 °C liegt UND unter 61 °C.

Das ergibt keinen Sinn, selbst wenn die größer-/kleiner-Pfeile gedreht werden.

Ich empfehle dir auf korrektes Einrücken des Codes zu achten, denn so ist das sehr verwirrend. Die schließende Klammer einer Anweisung sollte sich immer auf gleicher Ebene befinden wie die Anweisung selbst und alle Befehle auf gleicher logischer Stufe auch auf gleicher Ebene einrücken, also zum Beispiel so:
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);
    }                                       // Diese Klammer scheint zu fehlen
    break;
...
}


Außerdem für Programmcode besser das Code-Tag benutzen, damit eine Monospace-Schriftart verwendet wird. Das macht es hier ebenfalls leserlicher.
Es sieht so aus, dass du eine Klammer bei der letzten if-Anweisung vergessen hast. Da der Compiler nicht meckert, wird das wo anders wieder durch einen anderen Fehler ausgeglichen, was ebenfalls das unerwünschte Verhalten erklären kann. Guck am besten mal nach.

Du fragst mit der switch-Anweisung den Wert fanSteps ab. Was sagt der Wert aus? Aktuell sieht es so aus, dass der Wert 0 für "Lüfterregelung" steht, mehr nicht. Mit den if-Abfragen unterscheidest du die Temperaturfenster und stellst damit die PWM-Pulsweite ein (fanSpeed1, fanSpeed2 usw).

Es gibt wie immer unzählige Möglichkeiten etwas umzusetzen, hier einige Vorschläge:

- Du korrigierst die if-Bedingungen.
Wenn du die Fenster "...60°C, "60...68 °C" und "68...75 °C" wählst, dann wären das (ich lasse die Ausgabe mal weg):
switch (fanSteps) // Anfang Lüfterstufen
{
    case 0:                                 // Case 0 = Lüfter schaltet in 10 Stufen
    // statements
    if if(temp < t60) {                      // wenn T innerhalb Stufe 0
        analogWrite(fanPin, fanSpeed0);     // dann Lüfter auf speed0 55 (22%)
        delay(500);
    }
    if if(temp >= t60 and temp < t68) {      // wenn T zwischen Stufe 0 und 1
        analogWrite(fanPin, fanSpeed1);     // dann Lüfter auf speed1 64 (25%)
        delay(500);
    }
    if if(temp >= t68 and temp < t75)  {      // wenn T zwischen Stufe 2 und 3
        analogWrite(fanPin, fanSpeed2);     // dann Lüfter auf speed2 71 (28%)
        delay(500);
    }                                       // Diese Klammer scheint zu fehlen
    break;
...
}


Das nur als Beispiel.

- Du baust die if-Abfrage etwas anders auf und verwendest eine Hilfsvariable, die ich mal temp_var nenne.
switch (fanSteps) // Anfang Lüfterstufen
{
    case 0:                                 // Case 0 = Lüfter schaltet in 10 Stufen
    // statements
    temp_var = fanSpeed9                    // Höchste Stufe
    ...
    if if(temp < t75) {                      // wenn T innerhalb Stufe 2
        temp_var = fanSpeed2;
    }
    if if(temp < t68) {                      // wenn T innerhalb Stufe 1
        temp_var = fanSpeed1;
    }
    if if(temp < t60) {                      // wenn T innerhalb Stufe 0
        temp_var = fanSpeed0;
    }
    analogWrite(fanPin, temp_var);
    delay(500);

    break;
...
}

Das kann man auch umdrehen:
switch (fanSteps) // Anfang Lüfterstufen
{
    case 0:                                 // Case 0 = Lüfter schaltet in 10 Stufen
    // statements
    temp_var = fanSpeed0                    // niedrigste Stufe
    if if(temp > t60) {                      // wenn T innerhalb Stufe 1
        temp_var = fanSpeed1;
    }
    if if(temp > t68) {                      // wenn T innerhalb Stufe 2
        temp_var = fanSpeed2;
    }
    if if(temp > t75) {                      // wenn T innerhalb Stufe 3
        temp_var = fanSpeed3;
    }
    analogWrite(fanPin, temp_var);
    delay(500);

    break;
...
}


Im oberen Fall schreibst du erst mal die höchste Lüfterstufe rein und gehst davon aus, dass die Temperatur extrem hoch ist. Sollte sie doch niedriger sein, wird die Drehzahl Stück für Stück verringert.
Unten ist es umgekehrt. Du schreibst die niedrigste Drehzahl als Standardwert rein. Ist die Temperatur größer als die erste Schwelle, schreibe nächste Stufe in die Hilfsvariable. Ist die Temperatur noch höher, ersetze sie durch die nächst höhere Stufe. Am Ende bleibt die höchste Drehzahl in der Hilfsvariable, für die die Bedingung noch stimmt. Bei 70°C wäre die zweite noch wahr, die dritte nicht mehr, also bleibt es bei Stufe 2.
Diese Variante hat einen Vorteil: Bei deiner Variante muss sowieso jede if-Bedingung geprüft werden, selbst wenn darüber schon eine wahr war. In meinem Beispiel ist das genau so, allerdings vergleichst du in jeder Bedingung nur einen einzigen Wert. Willst du die Schwelle verschieben, von 68 auf 66°C, dann änderst du die eine Zahl und bist durch. Dir kann es nicht passieren, dass du die Schwelle nur an einer statt an zweien änderst.

Die Hilfsvariable verhindert, dass beim Durchlaufen der ganzen Stufen sich in Echt die Ansteuerung auch ändert.

Optimal ist das alles nicht, aber da es bei dir nicht auf Laufzeit ankommt und wichtiger ist, dass es überhaupt läuft und du keinen Fehler machst, hielte ich das für besser.

- Die dritte Möglichkeit wäre über switch(), geht aber nur, wenn du Integer-Werte hast und keine Float-Werte.
switch (fanSteps) // Anfang Lüfterstufen
{
    case 0:                                 // Case 0 = Lüfter schaltet in 10 Stufen
    // statements
    switch(temp) {
        case t60:
        case t61:
        case t62:
        case t63:
        case t64:
        case t65:
        case t66:
        case t67:
        case t68:
            temp_var = fanSpeed2;           // wenn T innerhalb Stufe 2
        break;
        case t69:
        case t70:
        case t71:
        case t72:
        case t73:
        case t74:
        case t75:
            temp_var = fanSpeed3;           // wenn T innerhalb Stufe 3
        break;
        case 76:
        ...
        default:
            temp_var = fanSpeed1;           // wenn T innerhalb Stufe 1
    }
    analogWrite(fanPin, temp_var);
    delay(500);

    break;
...
}


Das ist ein schönes Beispiel, um die Funktion von switch-Anweisungen zu veranschaulichen. Wenn temp die Werte 60, 61, 62, ... oder 68 hat, wird Stufe 1 gespeichert. Bei den Werten 69 bis 75 ist es Stufe 3. Trifft kein Wert zu, dann ist die Temperatur unter 60°C und das bedeutet Stufe 0.
Bei einer switch-Anweisung wird die anfangs übergebene Variable mit einem Wert verglichen und wenn der passt, dann wird ab hier der folgende Code ausgeführt, bis ein break; kommt. Nehmen wir an, die Temperatur wäre 62. Da nach "case t62:" kein break; steht, geht es darunter weiter. Die nachfolgenden Abfragen bis "case: t68" sind egal und werden ignoriert. Für alle Temperaturen bis 68 °C wird "fanSpeed2" gespeichert. Hiernach kommt ein "break;", womit alle Vergleiche danach ignoriert werden.
Das funktioniert aber, wie gesagt, nur mit Integer-Variablen. Wenn die Variable temp den Wert 62,1 enthält, trifft kein Wert zu und es endet in Stufe 0.

Auch das ist nicht ganz optimal, es gilt Gleiches wie oben. Welche Variante besser ist, hängt davon ab, wie viele Temperaturbereiche es gibt und wie viele verschiedene Werte die Variable temp annehmen kann. Die Beispiele sollen auch ein kleiner Denkanstoß sein, auf welche Weise man eine Aufgabe in Programmcode umsetzen kann.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 08. März 2022, 19:04:11
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)
Zitatswitch (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?
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 10. März 2022, 00:47:51
Hab in meinem Code gesehen, da steht "if if(...), das erste if muss weg.

Du verwendest kein <= oder >= mehr, wodurch glatte Werte komplett herausfallen. Das würde ich ändern. Wird aber bei meinem nächsten Vorschlag hinfällig.

Du hast keinerlei Hysterese einprogrammiert. Bist du genau auf der Grenze, springt die Stufe ständig hin und her. Dagegen hilft folgender Code:

TempSchwellen = {t60, t63, t67, t70, t73, t77, t80, t82, t84} // 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)
{
LStufe++;
}
break;

case 1:
analogWrite(fanPin, fanSpeed1);
if(temp < (TempSchwellen[0] - Hysterese))
{
LStufe--;
}
else if(temp > (TempSchwellen[1] + Hysterese)
{
LStufe++;
}
break;

case 2:
analogWrite(fanPin, fanSpeed2);
if(temp < (TempSchwellen[1] - Hysterese))
{
LStufe--;
}
else if(temp > (TempSchwellen[2] + Hysterese)
{
LStufe++;
}
break;

// ...

case 8:
analogWrite(fanPin, fanSpeed8);
if(temp < (TempSchwellen[7] - Hysterese))
{
LStufe--;
}
else if(temp > (TempSchwellen[8] + Hysterese)
{
LStufe++;
}
break;

case 9:
analogWrite(fanPin, fanSpeed9);
if(temp < (TempSchwellen[8] - Hysterese))
{
LStufe--;
}
break;

default:
LStufe = 9;
}
delay(500);
}


Du erzeugst erst einmal ein Array, das 9 Schwellwerte für die 10 Stufen enthält. Den Wert der Hysterese habe ich willkürlich gesetzt, da müsstest du einen sinnvollen Wert ermitteln. Du musst einmalig die Variable LStufe initialisieren, am besten mit dem Wert 9. Diese Variable enthält die Nummer der Lüfterstufe, die gerade verwendet wird.

Die switch-Abfrage sucht dir jetzt den passenden Programmcode zur aktuellen Stufe raus. Die PWM wird auf den passenden Wert gesetzt. Gehen wir zunächst davon aus, dass die Hysterese 0 ist. Zu jeder Lüfterstufe gibt es nur zwei Schwellwerte, nämlich den nächsten über und unter der aktuellen Temperatur. Also musst du nur die beiden Schwellwerte abfragen. Ist die Temperatur kleiner als der untere Schwellwert, dann soll eine Stufe heruntergeschaltet werden. Umgekehrt, ist die Temperatur größer als der obere Schwellwert, dann hochschalten. Die PWM wird dabei noch nicht gesetzt, aber das ist egal, da die switch-Abfrage in sehr kurzer Zeit wieder durchlaufen wird, was die PWM dann anpasst. Die Temperatur und der Lüfter sind träge, das fällt nicht ins Gewicht. Bist du auf Stufe 0 und die Temperatur schnellt hoch auf 100 °C, dann würden nach und nach Stufe 1, 2, 3, ... bis 9 durchlaufen. Diese Variante ist also etwas "träge", was aber wieder egal ist, denn so schnell ändert sich die Temperatur nicht.
Mit der Variable Hysterese kannst du genau diese einbauen. Angenommen der Lüfter läuft auf Stufe 1. Die Temperatur überschreitet TempSchwellen[1] zzgl. der Hysterese, dann landet die Regelung in Stufe 2. Die Temperatur muss nun 2x um den Wert Hysterese fallen, damit wieder auf Stufe 1 geschaltet wird.

Der ganze Code lässt sich noch viel kompakter gestalten, wird dann aber vermutlich weniger verständlich. Wenn du mit Arrays nicht klarkommst, kannst du entweder versuchen dich mit Arrays auseinanderzusetzen, oder es mit diskreten Variablen umsetzen:
TempSchwellen0 = t60;
TempSchwellen1 = t63;
TempSchwellen2 = t67;
// ...


Der Vorteil der Variante ist auch, du siehst alle Schwellen auf einen Blick und musst wieder nur einen Wert ändern, damit er sich an zwei Stellen auswirkt. Die Hysterese kannst du ebenfalls für alle an einer Stelle anpassen. Und wenn du es noch etwas optimierst, kannst du den ganzen anderen Code mit der Ausgabe unten drunter packen, wie die Delay-Funktion. Du brauchst ja nicht 10 mal den gleichen Code hinschreiben.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 10. März 2022, 13:46:08
Ok ok, so Langsam raucht der Kopf ;D

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)


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:

   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:
#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
}
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: we3dm4n am 10. März 2022, 19:59:29
Zitat von: MaikLommatzsch am 10. März 2022, 13:46:08
Dann bitte ich um eine Erläuterung was ein = bei >< ausmacht. Den mit oder ohne = konnte ich jetzt keine Änderung feststellen.
Das aktueller Code sagt:
Wenn die Temperatur GRÖßER oder GLEICH 60°C ist, dann Lüfterstufe 1 - in der selben Bedingung steht dann zusätzlich: ...und KLEINER oder GLEICH 63°C MINUS 1
Somit Tempbereich 60°C bis 62°C (inkl. ds1)
Ohne das = wäre es der Temperaturbereich nur 61°C ...somit kein Bereich, sondern nur ein Wert.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 10. März 2022, 21:36:25
Hab die Zitat-Tags mal in Code-Tags geändert, nun nimmt der Post keine 5 Monitor-Seiten ein ;)

Wie gesagt, ich habe keine Ahnung von Arduino, daher weiß ich nicht, ob ein Int davor muss, was anderes oder gar nichts.

we3dm4n hat es ja bereits erklärt. "<" und ">" schließen eine Gleichheit aus. Wenn die Variable var den Wert 60 hat, dann ist die Klammer (var < 60) ist falsch, während (var <= 60) wahr ist. Das st wichtig, da du mit deiner Abfrage-Struktur auf jeden Wert reagieren möchtest. Ohne dem Gleichheitszeichen fallen die exakten Schwellwerte aber raus, das heißt da passiert gar nichts. Das ist in dem Fall vermutlich nicht so dramatisch, weil der Wert Schwankungen unterliegt, aber es ist unsauber und ich würde das auf jeden Fall berücksichtigen, denn wer weiß, was es vielleicht doch für Probleme macht.
Wichtig ist: Du darfst das nur "auf einer Seite" ("größer als" oder "kleiner als") verwenden, sonst gibt es zwei Abfragen, in denen der exakte Schwellwert zu einem "wahr" führt.

Zitat von: MaikLommatzsch am 10. März 2022, 13:46:08   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%)

   }

Die Hysterese kannst du in der if-Abfrage nicht einbauen. Das tut nicht das, was du dir vorstellst. Du fragst in einem Durchlauf IMMER alle Temperaturbereiche ab. Hast du eine Überlappung der Temperaturbereiche, wird immer die höhere Lüfterstufe benutzt, denn wenn eine Abfrage wahr ist, ist die nächste auch noch wahr und dann wird sofort die nächst höhere Lüfterstufe eingestellt.
Der Trick an dem Aufbau mit der switch-case-Struktur ist, dass die Grenzen zum Umschalten abhängig von der derzeitigen Lüfterstufe sind. Das ist die einfache Variante, die du auch ganz am Anfang umgesetzt hast:

(https://www.trisaster.de/user/takeshi/temp/2022-03-10_LS1.png)

Das wollen wir haben:

(https://www.trisaster.de/user/takeshi/temp/2022-03-10_LS2.png)

Hat die Konsole 69 °C, kann die Lüfterstufe 3 oder 4 sein, je nachdem, welche Temperatur vorher war. War sie vorher 70 °C, ist die Stufe 4 und sie muss auf 68°C fallen, damit die Stufe auf 3 wechselt. Danach muss sie auf 70 steigen, damit sie wieder auf Stufe 4 wechselt.
Das funktioniert aber nur, wenn du die aktuelle Lüfsterstufe mit verwurstest. Mit den if-Abfragen ausschließlich für die Temperatur, würde bei 69 °C jedes Mal Stufe 3 und direkt danach 4 ausgegeben werden. Bei der nächsten Abfrage das Gleiche. Im Resultat hast du dann immer Stufe 4.
Oder anders erklärt: Du fragst immer ab, ob die Bedingung für die jeweilige Stufe erfüllt ist. Mit 69 °C ist die Bedingung für zwei Stufen erfüllt. Mit der switch-case-Anweisung fragst du zunächst die aktuelle Lüfterstufe ab und entscheidest dann individuell für diese Stufe, ob das Kriterium zum Verlassen der Stufe erfüllt ist. Das ermöglicht für jede Stufe unterschiedliche Kriterien.

Und das hast du da programmiert ;D

(https://www.trisaster.de/user/takeshi/temp/2022-03-10_LS3.png)

Du musst die obere Schwelle normalerweise erhöhen und die untere Schwelle verringern. Stattdessen hast du die obere Schwelle verringert, wodurch eine Lücke entsteht.

Der komplette Programmcode ist schon mal praktisch, so kann man das Ganze viel besser verstehen und Fehler finden. Den Code habe ich erst einmal vernünftig eingerückt. Nicht sauber eingerückt ist wie eine miese Handschrift, die keiner lesen kann, außer man nimmt sich viel Zeit das zu entziffern. Hier ist dein originaler Programmcode ohne inhaltliche Änderungen:
#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
}


Gewöhne dir bitte an einen einheitlichen Stil zu verwenden. Die schließende geschweifte Klammer immer auf gleicher Ebene wie der Ausdruck, nach dem die öffnende Klammer kam. Alles innerhalb der Klammer um einen Tab weiter eingerückt und so weiter.
Vermeide if-Abfragen ohne geschweifte Klammer. Das geht, führt aber gerade bei Anfängern schnell zu Fehlern. Ich bin mir nämlich auch nicht sicher, ob das am Ende so gewollt ist bei "// Übertemperatur Summerwarung", aber genau so war es programmiert.

Nun versuche ich den Code einmal anzupassen. Das kommt in meinem nächsten Beitrag, um das hier erst mal abzuspeichern.

Edit: Ach ja, doch noch was.
Was soll das switch(fanSteps)? Es gibt nur eine Option und es ist immer die gleiche Option, der Wert ändert sich nicht. Ist das "für später"? Ich würde das erst mal herausnehmen, macht es einfacher.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 10. März 2022, 22:24:31
Hier der überarbeitete Programmcode. Ich kann ihn natürlich nicht kompilieren und damit nicht auf grobe Fehler prüfen.

#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[abfrageZahl]; // 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;

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

int ds1 = 1;                          // DowenSet 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.println(" - Stufe: ");
Serial.print(Stufe);
lcd.setCursor(0,2);       
lcd.print("PWM: ");
lcd.print(fanSpeed[Stufe]);
lcd.print(" - Step: ");
lcd.print(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 >= 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
}


Mich verwundert, dass du schreibst, mit dem Code wäre das alles sehr träge. Wenn das träge ist, dann ist die Abarbeitung so richtig langsam, denn viel zu berechnen ist das noch nicht. Da ist dann ganz wo anders ein Problem.
Wenn der Code oben nicht funktioniert, dann halte ich es für sinnvoller den Fehler zu finden, als es komplett umzuschreiben, mit der Hoffnung, dass der Fehler dabei nicht mitgeschleift wird.

Die switch-case-Anweisung in der Hauptfunktion loop() lässt sich außerdem extrem zusammenstauchen:
void loop()
{
temperaturberechnung();            // Startet die Temperaturerfassungsroutine

// Lüfter schaltet in 10 Stufen
if(Stufe > 0)
{
if(temp < TempSchwellen[Stufe-1])
{
Stufe--;
}
}
if(Stufe < 9)
{
if(temp > (TempSchwellen[Stufe] + ds1)
{
Stufe++;
}
}
analogWrite(fanPin, fanSpeed[Stufe]);

// optische Ausgabe
Serial.print("fanSpeed: ");
Serial.print(fanSpeed[Stufe]);
Serial.println(" - Stufe: ");
Serial.print(Stufe);
lcd.setCursor(0,2);       
lcd.print("PWM: ");
lcd.print(fanSpeed[Stufe]);
lcd.print(" - Step: ");
lcd.print(Stufe); // Wenn das nicht funktioniert, dann lcd.print(Stufe + 0x30); probieren
}


Das geht, da in jedem "case" der gleiche Code steht, mit wenigen Ausnahmen. Einmal werden die Zahlen darin hochgezählt, wobei die Differenz zum Vergleichswert in "case" immer identisch ist. Die Zahl lässt sich also immer in Abhängigkeit von der Zahl hinter "case" ausdrücken und damit mit der Zahl, die in switch() geprüft wird, nämlich die Variable "Stufe". Mal exemplarisch für Stufe 5:
case 5:
analogWrite(fanPin, fanSpeed[5]);
if(temp < TempSchwellen[4])
{
Stufe--;
}
else if(temp > (TempSchwellen[5] + ds1)
{
Stufe++;
}
break;

Das macht das Gleiche wie:
Zitatcase 5:
         // Variable "Stufe" hat den Wert 5
         analogWrite(fanPin, fanSpeed[Stufe]);
         if(temp < TempSchwellen[Stufe-1])
         {
            Stufe--;
         }
         else if(temp > (TempSchwellen[Stufe] + ds1)
         {
            Stufe++;
         }
      break;

Also eigentlich könnte man einfach nur diesen Code für alle Stufen verwenden und braucht dann die switch-case-Anweisung nicht mehr. Weil aber bei der kleinsten Stufe das Herunterzählen und bei der höchsten das Hochzählen fehlt, wird bei der ersten if-Abfrage noch zusätzlich kontrolliert, ob nicht schon die niedrigste Stufe erreicht ist. Bei der zweiten if-Abfrage wird geprüft, ob die höchste schon erreicht ist.
Weil die zweite if-Abfrage niemals wahr sein kann, wenn die erste wahr ist, macht es keinen Unterschied, ob wir bei der zweiten "else if" oder nur "if" verwenden. Einziger Unterschied ist die Abarbeitungszeit. Das "else" darf man also streichen. Und heraus kommt, was ich oben schrieb.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 11. März 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

Zitatwe3dm4n 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.

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

ZitatWas 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.

ZitatWie 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.

Zitatelse 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.

ZitatGewö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.

ZitatUnd 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.







Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: Takeshi am 12. März 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.

Zitat von: MaikLommatzsch am 11. März 2022, 08:55:22
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".

Zitat von: MaikLommatzsch am 11. März 2022, 08:55:22
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.

Zitat von: MaikLommatzsch am 11. März 2022, 08:55:22
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.
Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 15. März 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:
Zitatint TempSchwellen[9] = {45, 50, 55, 60, 65, 70, 75, 80, 85};
Dort fehlte das int am Anfang und ein ; am ende
Zitatint abfrage[abfrageZahl];       // Array Variable für das Mitteln der Temperatur
Habe ich wieder in int abfrage[1]; geändert, es gab kein Bezug
Zitatelse 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
}








Titel: Re: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch 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?






Titel: Aw: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 17. August 2023, 10:19:20
Moino, nach langer langer Zeit mal wieder ein Update
Wie das nun mal ist,  privat und beruflich ist eine Menge passiert und das Thema Lüftersteuerung wurde vergessen.
Als ich dann Anfang des Jahres wieder ran wollte, musste ich feststellen das es nicht mehr möglich war PS3 Online zu Hacken, ich musste ja die Originalen Temperaturen auslesen.

Außerdem war dieses Forum Offline.

Vor 2/3 Wochen habe ich über YouTube mitbekommen das der Online Hack wieder geht.
Also holte ich die gereflowte V2 wieder vor und freute mich das sie noch startete.
Ich habe die V2 ohne Zwischenfälle mit CFW ausgestattet und konnte mir nun endlich die aktuellen Temps anzeigen lassen.
Perfekt, die extern gemessenen Temps wichen nur um 2°C von den tatsächlichen ab.

Ich habe die Konsole zuerst mit den Werten laufen lassen:
int fanSpeed[10] = {55, 64, 71, 76, 89, 102, 120, 130, 178, 254};
int TempSchwellen[9] = {60, 63, 67, 70, 73, 77, 80, 82, 84};
Damit bewegten wir uns um die 70°C bis 75°C am CELL.

Aber mit {45, 50, 55, 60, 65, 70, 75, 80, 85} ( Für den Anfang größere Abstufungen, besser zum Testen)
Läuft die PS3 stabil um die 65°C am CELL, dabei ist der RSX immer kühler als der CELL.

Um häufiges umschalten zu vermeiden und die Lüfterlautstärke in dem Bereich zu senken hab ich es etwas angepasst:
{45, 50, 55, 60, 67, 70, 75, 80, 85};...
{55, 64, 71, 76, 85, 102, 120, 130, 178, 254.

Damit ich nicht stundenlang Zocken musste habe ich mich ein wenig mit CFW beschäftigt und habe Spiele, die ich auch Original besitze auf die Konsole installiert (was viel Zeit in Anspruch genommen hat) und auch mal über FTP auf den PC überspielt, nur um lange Laufzeiten zu generieren, ohne ständig dabei sein zu müssen.

Die Konsole läuft einen ganzen Tag nonstop ohne Probleme und bleibt stabil um die 65°C.

Die Externe Lüftersteuerung ist voll ok, die Konsole steht direkt neben mir und der Lüfter stört mich überhaupt nicht, also aus der Ferne dann erstrecht nicht.

Alle 3 Minuten wird der Lüfter etwas schneller, was aber auch nicht stört. Wir arbeiten in der Steuerung einen LOOP ab, und der scheint dann wohl alle 3 Minuten von vorn zu beginnen. Dabei schwankt die Temperaturmessung Stark um 5°C bis 10°C.

Nach über 48 Stunden Testphase mit Zocken und heftigen Datentransfer, mit diversen Neustarts und auch mal längeren Abkühlzeiten möchte ich meinen das die externe Lüftersteuerung funktioniert.

Im nächsten Stepp verpflanze ich die Elektronik ins Gehäuse und schließe den Controller an die Stromversorgung der PS3 an.
Ich werde mit Bildern berichten.
Titel: Aw: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 23. September 2023, 11:31:14
Moin Leute, hier ein paar Bilder Die Zeigen das die Steuerung jetzt von der Konsole mit Strom versorgt wird.
Die 3,3V habe ich mir direkt vom Netzteil geholt.
Titel: Aw: Alternative Externe Temperatur gesteuerte Lüfterreglung
Beitrag von: MaikLommatzsch am 23. September 2023, 11:57:34
Und hier mal die Temperatur die vom System erfasst wird.
Ich habe den Einbau so gemacht das wenn die Konsole mal zerlegt werden muss, das die Lüftersteuerung nicht stört.
Der Lüfter wird weiterhin von der PS3 bestromt, nur das Drehzahlsignal kommt von der neuen Steuerung, darum habe ich ein Adapter gebaut.
Den Controller habe ich unter der Festplatte platziert, da ist mehr als genug Platz für die kleine Platine.
An den USB C Stecker werden die Kontroll-LEDs verbunden.
Dann bekommt die PS3 ja noch ein neu Lackiertes Gehäuse, darum hab ich schonmal eine neue Schalterblende aus Edelstahl hergestellt.
Das Gehäuse hab ich noch nicht da, Bilder werden folgen.
LG Maik