Ich belebe meine Homepage (mal wieder) neu und werde hoffentlich öfter dazu kommen hier etwas zu posten. Es is viel passiert.

Was bisher geschah

Seit meinem letzten Update hier ist ja nun schon eine Weile vergangen und in der Zwischenzeit ist eine Menge passiert, ich fass’ das mal kurz zusammen.

Umzug

Nach einer Eigenbedarfskündigung mussten wir uns was Neues suchen. Der Berliner Wohnungsmarkt ist total kaputt zur Zeit. Wir hatten Besichtigungen mit 60 und mehr Leuten auf Wohnungen, die bestenfalls mittel-gut waren. Um es kurz zu machen, wir haben eine schöne Wohnung im Süden von Berlin gefunden. Es war schon eine gewisse Umstellung vom Wedding nach Licherfelde Süd, hier ist alles sehr viel ruhiger. Nach Jahren mit Baustellen, gleich nebenan oder Dachausbauten im Hinterhaus, die sich fast ein Jahr hingezogen haben, kann man hier Homeoffice machen ohne die Fenster schließen zu müssen.

Jobs

Beruflich habe ich auch einige Fortschritte gemacht.

Berlin Direkt Versicherung

Bei der BD24 war ich damals als .Net Developer angestellt, der Job und Teamleiter waren toll und ich konnte mich Richtung DevOps weiterentwickeln. Im Grunde habe ich ja schon immer versucht Dinge in der IT zu automatisieren. Das macht mir einfach sehr viel Spaß. Als mein Teamleiter die BD24 verließ, war das auch für mich der Zeitpunkt mich nach neuen Herausforderungen umzuschauen. Ich habe mir damals LinkedIn und Xing Profile angelegt und wurde sofort von Personalvermittlern regelrecht zugespammt.

Bundesdruckerei

Am Ende entschied ich mich für eine Stelle als DevOps bei der bdr, vermutlich auch weil ich dort am ehesten das Gefühl hatte in ein Team zu kommen und an spannenden Aufgaben arbeiten zu können. Ich hatte bei den anderen Jobangeboten, auch wenn sie finanziell attraktiver waren, irgendwie immer das Gefühl die suchen zu verzweifelt.

Charité

Nach etwas über zwei Jahren bei der bdr, bot sich mir die Gelegenheit zur Charité zu wechseln und mit meinem Teamleiter von BD24 dort etwas Neues aufzubauen. Da konnte ich einfach nicht wiederstehen. Hier werde ich vermutlich in späteren Posts mehr dazu erzählen.

Verbesserungen

Mit dem Umzug bot sich die Möglichkeit ein paar Verbesserungen vorzunehmen. Ich werde auf ein paar Dinge, davon in späteren Post mehr berichten, aber unteranderem wurde in neue Büromöbel, PC-Hardware, Netzwerk, Verkabelung, Internetanbindung und vieles mehr invenstiert.

Das wars erstmal

Ein kleiner Teaser vielleicht noch: Ich habe angefangen ein wenig mit Holz Dinge zu bauen, macht mir sehr viel Spaß.

TL:TR

Ein Raspberry Pi 3 unter Last braucht eine aktive Kühlung, sonst drosselt er sich. Normale Gehäuse bieten maximal 40mm Lüfter, die sind zu laut und lassen sich nicht regeln. Dies ist mein Entwurf für ein Gehäuse mit Platz für einen 4-Pin PWM 80mm Lüfter. STL-Files: Oberteil, Basis

Ausgangssituation

Ich betreibe mehrere Webdienste intern in meinem lokalen Netzwerk zu Hause. Um diese Dienste aus dem Internet erreichbar zu machen, betreibe ich einen kleinen Reverse-SSL-Proxy. Der Proxy hat zwei Aufgaben, erstens werden die internen Webdienste unter einer URL (mit verschiedenen Pfaden) zusammengefasst und aus dem Internet verfügbar gemacht. Zweitens werden alle intern unverschlüsselten Webdienste nach aussen über https angeboten.

Das Problem

Der Reverse-SSL-Proxy läuft auf einem Raspberry Pi 3B in einem kleinen Gehäuse mit Wandbefestigung. Jeder Zugriff auf einen internen Webdienst muss durch diesen kleinen ARM-Rechner und erzeugt damit CPU-Last, dies bedeutet Abwärme. Ein kleiner Test mit dem Apache HTTP server benchmarking tool zeigt, dass bereits nach weniger als hundert Anfragen, die CPU des Raspberrys so heiß wird, dass er beginnt sich selbst zu drosseln. Zusammengefasst: Ein Raspberry Pi 3B unter Last benötigt einen Lüfter. In den gängigen Gehäusen passt maximal ein 40mm DC Lüfter. Die kleinen Dinger sind laut und lassen sich schlecht regeln. Zum diesem Zeitpunkt gab es auf thingiverse.com leider nur Gehäuse für wirklich große Lüfter (ab 120mm), meist wird dort noch eine Schrittmotorensteuerung für CNC-Fräsen oder 3D-Drucker mit gekühlt. Das ist zu groß für meine Zwecke.

Ein anderes Problem ist die Stromversorgung. Der Pi 3B(+) möchte mit mindestens 2.5A bei 5V versorgt werden. Der Pi 3B(+) ist da sehr viel anspruchsvoller als seine Vorgägner, bei schlechter Stromversorgung gibt es schnell eine ‘undervoltage’ Warnung. Gute USB-Kabel sind sehr wichtig, allerdings habe ich bisher kein Kabel gefunden das länger als 2m ist und den Pi stabil versorgt. Das liegt unter anderem am Innenwiderstand der USB-Kabel, an der niedrigen Spannung und daran das die gängigen Netzteile die Spannung nicht nachregeln.

Die Idee

Ich bräuchte ein Gehäuse, mit Platz für einen flachen 80mm 4-Pin PWM Lüfter und einen StepUp-Wandler (12V zu 5V/3A). Wandmontage sollte möglich sein, am besten so das man noch an die MicroSD-Karte kommt. Der Lüfter sollte nicht direkt mit dem Gehäuse verschraubt werden, besser ist eine Verbindung mit Gummi. Lüftungsschlitze müssen vorhanden sein, möglichst nicht oben, es soll ja nicht ins Gehäuse stauben.

Der Entwurf

Der Pi braucht 85x56mm Grundfläche, um ihn dann noch mit Strom zu versorgen, braucht man noch etwas Platz für den Micro-USB-Stecker. Das heißt der Pi wird nicht symetrisch in der Mitte liegen, sondern am rechten Rand. Mein 80mm 4-Pin PWM Lüfter ist etwas über 10mm hoch und es muss noch etwas Platz für die Gummidämpfer eingeplant werden. Mit diesen Rahmenbedingungen und meinem Wunsch nach geraden Werten, ergibt sich eine ungefähre Gehäusegröße von 100x100x50mm.

Dann brauche ich Halterungen für den Pi, Aussparungen für USB, Netzwerk, MicroSD-Karte und einen Rundstecker (12V Versorgungsspannung). Lüftungsschlitze an den Seiten und im Deckel und irgendetwas um den Lüfter zu befestigen und um den StepUp-Wanlder zu fixieren.

Die Software

Ich hatte bisher noch nie selbst mit 3D-Modelierung zu tun. Die meisten Anwendungen sahen für meinen Geschmack zu kompliziert aus. Ansprechend und einfach sah TinkerCAD von Autodesk aus. Ich war zuerst etwas skeptisch, da die Anwendung komplett im Browser läuft. Insgesamt bin ich positiv überrascht worden. Das Konzept und die Bedienung sind definitv an Anfänger gerichtet.

Im Grunde zieht man einfache geometrische Objekte, wie Quader, Kugeln oder Zylinder von der Seite auf die Arbeitsfläche und kann dessen Grösse dann in allen Dimensionen anpassen. Man bestimmt ob die Objekte massiv sind oder Aussparungen haben und dann kann man die Objekte verschmelzen.

Zur Ausrichtung der Objekte kann man nur zentriert, sowie links- oder rechtsbündig wählen. Genau hier merkt man dann auch die Zielgruppe, ein Objekt millimetergenau zu positionieren geht nur über selbst erstellte Hilfsobjekte.

Das Model

Die Konstruktion war recht straightforward. Als erstes habe ich auf der 100x100mm Grundfläche die Halterungen für den Pi positioniert. Zur Befestigung drückt man [M2,5] Muttern in die Unterseite der Grundplatte, dann lässt sich der Pi mit Schrauben von oben fixieren. Die Grundplatte brauchte dann noch eine Aussparung, um von aussen an die MicroSD-Karte zu kommen und schließlich noch ein paar Laschen für Kabelbinder, hier wird später der StepDown-Wandler zur Stromversorgung befestigt. In die Seitenteile habe ich Lüftungsschlitze eingefügt und in der Vorderseite Aussparungen für Netzwerk, USB und eine 5,5x2,1mm Hohlbuchse.

Der Deckel braucht auch Lüftungsschlitze, hier habe ich eine Wabenstruktur gewählt, da dies wohl etwas stabiler ist und besser aussieht. Innen braucht man kleine Taschen um die Gummidämpfer zur Lüfterfixierung zu befestigen. Fertig.

bnsp;

Der Druck

Ich selbst habe noch keinen 3D-Drucker, deshalb war meine erste Idee das Model bei einem der vielen kommerziellen Anbieter im Internet drucken zu lassen. Kurzum - das war mir zu teuer, vor allem, weil es sich um einen ersten Entwurf handelt. Ich hatte ja keine Ahnung ob das alles am Ende auch so passt wie ich mir das gedacht habe.

In der Nähe von mir wibt die Schiller-Bibliothek damit, dass sie einen Makerspace hat, also bin ich dahin um dort vielleicht zu drucken. Leider versteht man in der Bibliothek etwas anderes unter Makerspace. Dort wird die Möglichkeit geboten einmal im Monat ein Objekt von thingiverse zu laden und zu drucken, vorausgesetzt es dauert nicht zu lange. Wenn die beantragten Fördermittel bewilligt werden, soll das auf einmal die Woche erhöht werden. Das bietet eine schöne Gelegenheit sich mal 3D-Druck anzuschauen, ist aber keine Lösung für mich.

Auf der Suche nach “richtigen” Makerspaces, nach dem Prinzip der offenen Werkstatt, bin ich auf das HappyLab gestossen. Die haben einen Industrie 3D-Drucker, der wäre im Prinzip schon gut gewesen, leider wollen sie 0,45€ pro cm³ Druck- bzw. Stützmaterial. Ich verwende dünnere Wände als sie minimal empfehlen und würde dort dennoch etwa 40€ zahlen.

Am Ende bot mir ein Freund an, dass am Wochenende bei ihm auf der Arbeit zu drucken. Der Chef hatte sich vor einer Weile einen Creality3D CR-10 S5 zugelegt und meinte das wäre ok wenn wir den am Wochenende mal benutzen. Der erste Versuch lief leider schief, irgendwann nach zwei oder drei Lagen stockte der Filamentnachschub und der Drucker arbeitete fleissig in der Luft weiter. Als wir das bemerkten war es bereits zu spät.

bnsp; bnsp;

Beim zweiten Versuch haben wir den Deckel des Gehäuses fertig gedruckt, dass hat sehr viel länger gedauert als ich dachte. Wir haben auf anraten des Chefs mit weniger als 50% Druckgeschwindikeit gedruckt. Die Ecken des Deckels haben sich um einen Millimeter von der Glasplatte gelöst und angehoben, dass sieht man auch wenn man genau hinschaut, aber stört mich nicht sonderlich. Das Unterteil des Gehäuses haben wir dann über Nacht drucken lassen mit 35% Druckgeschwindigkeit. Das Ergebnis ist gut. Leider sind auch bei der niedriegen Druckgeschwindigkeit die Ecken etwas hochgekommen.

bnsp;

Die Montage

Der Lüfter wurde, zwecks Geräuschminimierung, mit Entkoppel-Gummies im Deckel befestigt. Die Gummidämpfer habe ich mit einem Tropfen Sekundenkleber in den Aussparungen im Deckel geklebt, damit bleiben sie dehnbar genug um den Lüfter wechseln zu können.

Um das Stromversorgungsproblem zu beheben, habe ich einen StepDown-Wandler verwendet. Die hier verwendete QC3-StepDown-Wandler ist im Grunde der Kern eines USB-Ladegeräts. Den Wandler betreibe ich mit einem normalen 12V Netzteil.

bnsp; bnsp;

Im Grunde kann der Wandler viel mehr, er beherrscht QuickCharge3 und kann bis zu 12V und 24W liefern. Zudem kostet er nur etwas über 1€. Die für mich wichtigste Funktion ist, dass er nachregelt, d.h. wenn der Pi wirklich mal Strom zieht und die Spannung runtergeht, erhöht der Wandler automatisch die Spannung um über 5V zu bleiben. Der Plan war den StepDown-Wandler mittels super kurzem Kabel anzuschließen. Leider habe ich kein passendes USB-zu-MicroUSB Kabel gefunden. Alle Kabel waren zu lang oder zu unflexibel. Ich habe mich also enschlossen den Pi direkt über seine PINs mit Strom zu versorgen. Damit umgeht man die Sicherungen des Raspberry. Man muss also sehr aufpassen, vertut man sich hier mit der PIN-Belegung ist der Pi recht schnell hin.

Schließlich muss noch der Lüfter mit 12V versorgt werden und der PWM- und der Tacho-Pin mit dem Raspberry verbunden werden.

Die Lüfterbeschaltung

Der Raspberry Pi kann max. 3.3V an seinen PINs ab, mehr zerstört ihn sehr schnell. Beim Tacho- und PWM-Pin des Lüfters kann es sein, je nach Lüfter-Bauart, dass dort kurzzeitig mehr als 3.3V anliegen. Also habe ich mir eine kleine Schutzschaltung aus dem Internet gesucht, die den Pi vor zu hohen Strömen schützt.

bnsp; bnsp;

Mein erster Versuch war es, dies mit in die Verkabelung einzubauen. Das hat nicht so gut funktioniert. Ich habe die Schaltung dann einfach auf einer Lochstreifenraster-Platine aufgebaut und mit Schrumpfschlauch isoliert. Die zusätzliche kleine Platine im Gehäuse unterzubringen war eine Herausvorderung. Sie klemmt jetzt auf der Oberseite vom MicroSD Karten Slot, zwischen Pi und Gehäusewand. Das hält erstaunlich gut.

Inbetriebnahme

An der Wand befestigt fand ich den Deckel etwas locker. Laut 3D-Model sind etwa 0,2mm Platz zwischen Deckel und Gehäuse. Ich habe einfach ein paar Lagen Tesafilm auf die Gehäuse Kanten geklebt, der Deckel verdeckt diese und durch die Extralagen sitzt der Deckel nun schön fest.

bnsp; bnsp;

Die Steuerung

Ziel war es, dass der Pi aktiv gekühlt wird, wenn dieser Kühlung benötigt. Im normalen Betrieb kann der Lüfter so langsam drehen wie möglich, wenn technisch möglich sogar stehen bleiben. Die Frage war nun, wie aktiv soll die Temperaturüberwachung sein.

Meine erste Idee war ein Skript, welchen per Cronjob jede Minute aufgerufen wird. Nach meinen Beobachtungen steigt und fällt die Temperatur der CPU aber sehr viel schneller. Unter Last dauert es nur Sekunden bis der Pi in den Bereich kommt, in dem er ohne Kühlung drosseln würde. Ein Minuten-Interval ist einfach zu langsam.

Ideal wäre eine Regelung, welche direkt bei einer Temperaturänderung anlaufen würde. Meine Lösung ist nicht ganz so perfekt, sollte aber auch gut genug funktionieren. Ich lese in einem einstellbaren Interval (zur Zeit 10s) die CPU-Temperatur aus und passe danach die Lüfterdrehzahl an.

Um aus dem Tachosignal eine Drehzahl zu bekommen gibt es verschiedene Methoden. Das Tachosignal liefert pro Umdrehung des Lüfters zwei Impulse. Ich habe mehrere Methoden ausprobiert, um aus dem Tachosignal eine Umdrehungszahl zu berechnen, keine funktionierte so wie ich mir das vorstellte.

Die besten Ergebnisse erzielte ich, wenn ich die Dauer von mehreren fallenden Flanken des Tachosignals messe und dann über durchschnittliche Dauer zwischen zwei Impulsen die Drehzahl errechne. Das liefert gute Ergebnisse, solange man nicht während der Beschleunigung misst.

bnsp; bnsp;

Ich habe zwei Temperaturpunkte definiert, bis zum Punkt A soll der Lüfter mit minimaler Drehzahl laufen, ab dann soll der Lüfter bis zum Punkt B beschleunigen. Über Punkt B soll der Lüfter mit voller Drehzahl laufen.

Monitoring

Die CPU-Temperatur wird schon an mein Monitoring übertragen. Die Lüfterdrehzahl möchte ich auch gern aufzeichen. Problematisch ist eine Drehzahlmessung während der Regelung, da diese oft unsinnige Drehzahlen liefert

#!/usr/bin/python3 -u

import RPi.GPIO as gpio
import wiringpi, time

pin_pwm = 18
wiringpi.wiringPiSetupGpio()
wiringpi.pinMode(pin_pwm, 2) # hardware pwm mode

pin_tacho_bcm = 23
gpio.setmode(gpio.BCM)
gpio.setup(pin_tacho_bcm, gpio.IN)

wait_seconds_before_next_loop = 5
wait_seconds_after_pwm_change_before_measure_rpm = 10
temp_rpm_start_raise = 45
temp_rpm_full_speed = 67
last_temperature = temp_rpm_start_raise

if __name__ == "__main__":
    while True:
        # measure: rotation per minute
        count_cycles_for_average = 10
        gpio.wait_for_edge(pin_tacho_bcm, gpio.FALLING) # wait till falling edge
        start = time.time()                             # start stopwatch
        for impulse_count in range(count_cycles_for_average):
            gpio.wait_for_edge(pin_tacho_bcm, gpio.FALLING)
        duration = time.time() - start                  # stop stopwatch
        frequency = count_cycles_for_average / duration # Hz
        rpm = int(frequency*3) * 10                     # rpm rounded by 10

        # get temperature
        temperature_file = open('/sys/class/thermal/thermal_zone0/temp')
        cur_temp = float(temperature_file.read()) / 1000

        # if current temperature differs last temperatur
        new_pwm = 0
        if cur_temp != last_temperature:
            # calculate new pwm value
            temp_span = temp_rpm_full_speed - temp_rpm_start_raise
            pwm_per_degree = (1024 / temp_span)
            new_pwm = (cur_temp - temp_rpm_start_raise + 1) * pwm_per_degree
            new_pwm = int(0 if new_pwm < 0 else 1024 if new_pwm > 1024 else new_pwm)
            # set new pwm value
            try:
                wiringpi.pwmWrite(pin_pwm, int(new_pwm))
            except:
                rpm = 0
        else:
            last_temperature = cur_temp

        # write rpm to ramdisk file
        with open("/run/user/0/rpm",'w') as out_file:
            out_file.write(str(rpm))
            out_file.close()

        # wait
        wait_seconds = max(wait_seconds_before_next_loop, wait_seconds_after_pwm_change_before_measure_rpm)
        time.sleep(wait_seconds)

Der Python-Server-Daemon selbst weiß natürlich wann er den PWM-Wert ändert, kennt also auch den besten Zeitpunkt zum Messen. Meine Lösung besteht nun darin die Drehzahl im Regelprozess zu messen und in eine Datei auf einer RAM-Disk zu schreiben. Die Drehzahldatei wird mehrmals die Minute aktuallisiert, um damit die MicroSD-Karte nicht kaputt zu schreiben, verwende ich die RAM-Disk, welche das Debiansystem schon angelegt hat.

Zum starten und stoppen bzw. überwachen des Python-Server-Daemon definiere ich ihn als systemd-Dienst. Das Skript liegt hier:

/etc/systemd/system/fancontrol.service

Aktiviert und gestartet wird es wie folgt:

systemctl enable pyserver
systemctl start pyserver

[Unit]
Description=Fan control server
After=syslog.target

[Service]
Type=simple
WorkingDirectory=/etc/check_mk
ExecStart=/etc/check_mk/fancontrol_server.py
SyslogIdentifier=fancontrol
StandardOutput=syslog
StandardError=syslog
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target

Das Skript, welches dann die Drehzahl ausliest und ans Monitoring überträgt kann somit los gelöst von der Regelung ausgeführt werden.

#!/usr/bin/python3

import sys, os, time, stat

FILE = "/run/user/0/rpm"
WARN_FILE_AGE_IN_SECONDS = 60
CRIT_FILE_AGE_IN_SECONDS = 120

if not os.path.exists(FILE):
  print("UNKNOWN - FanControl file not found.")
  sys.exit(3)

file_age = time.time() - os.stat(FILE)[stat.ST_MTIME]
if file_age > WARN_FILE_AGE_IN_SECONDS:
  print("WARNING - FanControl RPM Value is old.")
  sys.exit(1)

if file_age > CRIT_FILE_AGE_IN_SECONDS:
  print("CRITICAL - FanControl RPM Value is outdated.")
  sys.exit(2)

line = ""
with open(FILE, 'r') as infile:
    try:
        data = infile.read()
        infile.close()
    except :
         print("UNKNOWN - FanControl file open failed.")
         sys.exit(3)

rpm = int(data)
if rpm < 1:
    print("CRITICAL - FanControl RPM is 0..")
    sys.exit(2)

if rpm < 500:
    print("WARNING - FanControl RPM is too slow.")
    sys.exit(1)

# maybe waring/critical if too long too high

print("OK - FanControl is working. Fan has " +str(rpm)+ "rpm. |fan="+str(rpm)+";:500;:200;600;3500")
sys.exit(0)

So sieht das dann in meinem Monitoring aus, ich habe hier mal Last aufs System gegeben, damit man den Peak am Ende des Graphen sehen kann.

Fazit und Verbesserungen

So im Ganzen finde ich es ein gelungenes Projekt. Hier ein paar Sachen die ich beim nächsten mal besser machen würde:

• Das Gehäuse etwas größer machen, damit Platz ist für die Schutzschaltung.
• Eine bessere Wandbefestigung, zur Zeit muss man den Pi dafür ausbauen.
• Den Pi dichter an die Gehäusewand, manche USB Stecker passen z.Z. nicht.
• Ein Kabel finden und verwenden, dass zwischen StepDown-Wandler und Pi passt.
• Gehäusewand etwas dicker machen, bringt mehr Stabilität.

STL-Files:

• Oberteil
• Basis

Bei Fragen oder Kommentaren schreibt mir einfach eine E-Mail, ich veröffentliche das dann hier wenn ihr wollt.

Anforderungen

Die Anforderungen an die Lüftersteuerung waren übersichtlich:

• Bei Steuerungsausfall müssen die Lüfter mit voller Geschwindigkeit laufen.
• Die Lüfter sollen immer mit einer Mindestdrehzahl laufen.
• Die Temperatur der Festplatten soll um die 40 °C gehalten werden.
• Je ein Sensor soll je eine Festplattentemperatur messen.
• Bis zu vier Lüfter sollen individuell gesteuert werden.
• Die Steuerung soll die Lüfter und deren ideale Drehzahl selbst ermitteln.
• Eine Schnittstelle zum Steuerungsdaten abfragen soll bereitgestellt werden.
• Die Drehgeschwindigkeit der Lüfter soll messbar sein.

Prototypen

Die Anforderungen an die Messbarkeit sprechen für einen 3-Pin oder 4-Pin Lüfter. Die Steuerung von 4-Pin Lüftern ist allerdings sehr viel einfacher und preislich ist da kein großer Unterschied. 4-Pin Lüfter für PCs funktionieren nach einer Intel Spezifikation. Die Lüfter haben 4 Anschlüsse: GND, 12V, Tacho, PWM. Der Pin für das PWM Signal nimmt 0V als Low und 5V als High entgegen, kann also direkt am Arduino betrieben werden. Das Tacho-Signal wird meist mit einem Hall-Sensor realisiert, pro Umdrehung liefert Sensor 2 Impulse. Der Arduino muss also Impulse über Zeit zählen und kann daraus die Drehzahl errechnen. Um die Impulse sauber zu erkennen, wird die Verbindung zwischen Tacho-Signal und Arduino mit einem Widerstand auf 5V gezogen. Als Temperatursensoren verwende ich Dallas DS18B20 OneWire Sensoren, dies ermöglicht es mehrere Sensoren an einem Bus zu betreiben. Den OneWire-Bus zieht man ebenfalls über einen Widerstand auf 5V. Daraus ergibt sich folgende Schaltung.

Wie ich im Logic Analyzer schon erklärte, hat der Arduino Uno bzw. sein Mikroprozessor der ATmega328P leider zu wenig 16-Bit Timer. Ich verwende deshalb den Arduino Leonardo, dessen Mikroprozessor hat einen 16-Bit mehr und damit genug für die Ansteuerung von 4 Lüftern.

Wenn man die PWM-Signale nicht vom Arduino erzeugen lässt, geht natürlich auch ein Arduino Uno. Ich habe einen Prototypen gebaut, der ein PWM-Generator-Board via UART (also serieler Ansteuererung) zur Erzeugung der PWM-Signale benutzt.

Leider hat das Board, welches die PWM-Signale erzeugt, auch nur drei Ausgänge, ich hatte da noch die Hoffnung ein ähnliches Board mit vier oder mehr Ausgängen zu finden, leider erfolglos.

Die ursprüngliche Schaltung habe ich auf einem Arduino Prototyp-Shield aufgebaut, um sie zu testen und mit der Softwareentwicklung anfangen zu können.

Eigene Platine (PCB)

Eigentlich hätte ich jeden Pin des Arduinos fest verdrahten können, also in der Software festlegen können an welchen Pin das PWM-Signal ausgegeben werden muss und an welchem Pin das dazugehörige Tacho-Signal anliegt. Bei meinem Prototyp-Shield sieht man eher schlecht was an welchen Pin geführt wird. Ich habe in der Software nur die Pins festgelegt, welche für Tacho bzw. PWM verwendet werden. Im Setup testet die Software dann selbständig welche Lüfter angeschlossen sind und an welchen Pins die dazugeöhrigen Tacho-Signale anliegen. Das finde ich sehr komfortabel und verhindert auch Fehlverdrahtungen auf dem Breadboard, auch wenn es beim Erstellen eines PCB nicht mehr nötig wäre.

Fritzing ermöglicht es aus dem Breadboard-Aufbau ein PCB zu erstellen. Nach dem händischen Optimieren der auto-gerouteten Leiterbahnen erhält man produktionsfähiges Layout. 2-Layer, also unten und oben, reichen hier aus. Manche Leiterbahnen müssen ab und an die Seite wechseln, damit es keine ungewollten Verbindungen gibt. Eigentlich wollte ich mir das dann von irgendwem ätzen lassen, aber das Durchkontaktieren der zwei Layer ist relativ umständlich.

Aus Fritzing heraus kann man mit wenigen Klicks direkt bei aisler.net das PCB in Auftrag geben. Die Mindestbestellmenge lag bei mir bei drei Stück und die sollten etwa 25€ kosten. Das ist im Prinzip recht günstig, verglichen mit den anderen deutschen Herstellern, dass liegt an der geringen Stückzahl.

Direkt in China stellt man deutlich günstiger her. Ich hatte das vorher noch nie gemacht. Ich habe hier PCBWay getestet, dort war die Mindestmenge fünf Stück für $1 das Stück, der Express-Versand hat $6 gekostet und als Neukunde habe ich $5 Rabatt bekommen.

Für 5 PCBs habe ich etwa 5€ gezahlt. Die Dateien die man zur Produktion braucht, können direkt aus Fritzing exportiert werden. Die Produktion kann man auf der Webseite gut verfolgen und dauerte knapp drei Tage. Der Versand hat dann etwa eine Woche gedauert, ich hatte also nach 10 Tagen die PCBs zu Hause.

Für die Sensoren hatte ich zuerst 2,54mm Pin-Header verwendet. Leider sind die nicht verdrehsicher, es hat mich einen Arduino gekostet dies herauszufinden. OK bei dem Arduino ist nur die Spannungsversorgung durchgebrannt, der Mikroprozessor selbst funktioniert noch. Ich habe dann für den zweiten Anlauf Steckerbuchsen von Molex verwendet, die kosten bei Segor pro Sensor (Wanne, Stecker & Crimkontakte) etwas unter 1€, dafür geht aber kein Arduino mehr kaputt.

Im ersten Versuch waren alle Widerstände 4,7kΩ, leider konnte ich dann nur noch vier Temperatursensoren anschließen, einer mehr und es wurde keiner mehr gefunden. Ich habe den Widerstand der zwischen 5V und dem OneWire-Bus durch einen 2,7kΩ ersetzt, damit ging es dann ohne weitere Probleme.

Die 4-Pin PWM Lüfter Buchsen sind etwas speziell. Der Teil der beim zusammenstecken für das Einrasten sorgt, ist nur drei Pin breit. Das ermöglicht im PC 3-Pin und 4-Pin Lüfter zu verwenden und sorgt dafür das 4-Pin Lüfter nicht falsch aufgesteckt werden können. Bei Segor habe ich die leider nicht bekommen. Aufgebaut sieht das Arduino-Shield dann so aus:

Für die Stromversorgung benötigt man 12V für die Lüfter und irgendetwas zwischen 7-12V für den Arduino. Man könnte auch direkt 5V nehmen und den Arduino über die Pins mit Strom versorgen. Das würde vermutlich sogar etwas Strom sparen, da der Spannungswandler auf dem Arduino nicht verwendet wird. Ich habe einfach die 12V genommen mit denen ich auch die Lüfter versorge und einen kleiner Y-Adapter gebastelt.

Softwareentwicklung

Beim Testaufbau für die Softwareentwicklung habe ich die Anzahl und Art der Lüfter und Anzahl der Sensoren variiert. Mit maximaler Bestückung sieht das dann so aus:

Die Software habe ich so geschrieben, dass beim Einschalten oder Reset des Arduinos im Setup erst einmal alle Parameter ermittelt werden, die für die Steuerung benötigt werden. Ich beschreiber hier nur die grobe Funktionsweise.

Als erstes wird geschaut wieviele Temperatursensoren angeschlossen sind. Es muss mindestens ein Sensor angeschlossen sein, sonst verharrt der Arduino hier bis der erste Sensor angeschlossen wird. Das Vorhandensein von Sensoren wird später regelmäßig überprüft, sodass man auch im Betrieb welche hinzufügen oder entfernen kann. Sollte die Software allerdings keine Sensoren mehr finden, werden die Lüfter voll aufgedreht.

Im nächsten Schritt werden die vier möglichen PWM Signale den vier möglichen Tachosignalen zugeordnet. Dabei wird auch ermittelt wieviele Lüfter angeschlossen sind. Es muss mindestens ein Lüfter angeschlossen sein, damit dieser Schritt abgeschlossen wird, sonst wartet der Arduino hier wieder. Jede Änderung an der Lüfterkonfiguration bedarf eines Neustarts bzw. Resets.

Im letzten Schritt werden die Lüfter ausgemessen. Es wird pro Lüfter der höhste PWM-Wert ermittelt, bei dem der Lüfter eine minimale Drehzahl größer als 0 hat.

Die Spanne zwischen welcher der Lüfter geregelt wird, befindet sich dann zwischen PWM-Wert 100 und dem gemessenen minimalen PWM-Wert. Es werden zwei Temperaturpunkte definiert. Punkt A, unter dem die Lüfter mit minimaler Drehzahl laufen soll, und Punkt B, bei welcher der Lüfter mit voller Drehzahl laufen soll.

Die Spanne zwischen den beiden Temperaturen wird gleichmäßig auf die Spanne der möglichen PWM-Werte aufgeteilt. So kann man für jede Temperatur den passenden PWM-Wert berechnen.

Betrieb

Die Steuerung selbst ist recht einfach. Es werden alle Temperaturen gemessen und die Höhste wird zur Regelung verwendet. Für jeden Lüfter wird der PWM-Wert passend berechnet und der Lüfter entsprechend angesteuert.

Um mit Arduino zu kommunizieren, wird er an einen internen USB-Anschluss angeschlossen. Ich habe mir dafür so ein kleines Kabel gebaut.

Mit dem internen USB verbunden, verhält sich der Arduino wie eine über USB verbundene serielle Schnittstelle. Man kann an die serielle Schnittstelle ein beliebiges Byte schicken (ausser das kleine ‘r’) und er antwortet mit den aktuellen Parametern. Sendet man das kleine ‘r’, wird ein Reset durchgeführt. Ich verwende zum Auslesen und der Weitergabe an check_mk folgendes kleines Python-Skript:

#!/usr/bin/python

import serial
import time
import sys

connected = False
tries = 0

while not connected:
    try:
        arduino = serial.Serial('/dev/fancontrol', 9600, timeout=2)
        connected = True
    except:
        if tries > 10:
            sys.stdout.write("FanControl Failed - Not connectable. |")
            sys.stdout.flush()
            sys.exit(2)
        pass
    time.sleep(1)
    tries = tries + 1

arduino.write("x")

sys.stdout.write("FanControl OK - Running and readable. |")
sys.stdout.write(arduino.readline())
sys.stdout.flush()
sys.exit(0)

Fazit und Verbesserungen

Nach ausgiebigen Tests läuft die Steuerung nun seit drei Wochen zuverlässig in meinem Fileserver. Ich bin insgesamt zufrieden. Für Version 1.1 würde ich ein paar Sachen verbessern:

• Mehr Änschlüsse für den OneWire-Bus und den Abstand dazwischen vergrößern.
• Die Widersände leicht versetzen, damit der 12V auch 90° zum Shield zeigen kann.
• Eine Diode oder so einbauen, damit ein verdrehter Sensor nichts beschädigt.
• Statt des Arduinos, eine eigene Platine mit dem ATmega32u4 entwerfen.
• Ein richtiges Gehäuse zb. 3D gedruckt, vielleicht als 3,5 Zoll Laufwerk.
• Vielleicht ein Display oder Kontroll-Leds.
• Temperaturpunkte A und B via serieller Kommunikation ändern.
• Der ExitCode für check_mk sollte vom Arduino kommen.

Hier nochmal alle Teile die ich verwendet habe:

• Arduino Leonardo China-Version
• Extra lange Pin-Header
• 4-Pin PWM Lüfter Buchsen
• Dallas DS18B20 Temperatursensoren
• 4 x 4,7kΩ und 1 x 2,7kΩ Widerstände
• Y-Kabel-Stromkabel: 4-Pin Molex + 5,5 x 2.1mm Hohlstecker
• internes USB-Kabel: Dupont

Hier alle benötigten Dateien:

• fritzing file
• arduino code

Bei Fragen, Anregungen, Kommentaren oder Verbesserungsvorschlägen schickt mir einfach eine E-Mail, ich baue das hier dann ein.

Da mein Mainboard bzw. der Chipsatz nicht von lm-sensors unterstützt wird, baue ich zur Zeit eine Lüftersteuerung auf Arduino-Basis. Die Lüftersteuerung wird einen eigenen Post bekommen. Hier geht es nur um ein Teilproblem.

Der Arduino muss zur Steuerung der 4-Pin PWM-Lüfter laut Intel Spezifikation ein Pulsweitenmodulations-Signal mit etwa 25 kHz erzeugen. Pulsweitenmodulation (kurz: PWM) bedeutet in idealen Fall ein Rechtecksignal. Die obere Linien des Signals bedeutet das Strom fließt (An) und die untere Linie das kein Strom fließt (Aus). Das Verhältnis der Länge der An-Phase zur Länge der Aus-Phase plus Aus-Phase, also einer Periode, nennt man Tastgrad im englischen duty cycle, mit ihr wird die Geschwindigkeit des Lüfters gesteuert.

Zurück zum Arduino. Ich möchte mehrere Lüfter individuell steuern, alle brauchen also ein 25 kHz PWM-Signal, aber mit unterschiedlichen duty cycles.

Es gibt verschiedene Möglichkeiten diese Signale mit dem Arduino zu erzeugen. Man kann das in Software machen, in Hardware und es gibt spezielle Bibliotheken dafür. Ich habe nun die verschiedenen Möglichkeiten auf verschiedenen Arduinos getestet. Mein Problem war nur wie ich die resultierende PWM-Signale kontrolliere.

Man könnte einen Lüfter als Messinstrument benutzen und aus den Veränderungen der Drehgeschwindigkeit Rückschlüsse über den duty cycle ableiten. Ich finde das ohne ein Messinstrument für die Lüfterdrehzahl viel zu ungenau. Ausserdem sagt das auch nicht viel über die Frequenz des PWM-Signals aus, da ein 4-Pin PWM-Lüfter laut Intel Spezifikation durchaus um mehrere kHz varieren darf. Im Internet liest man oft eine LED bzw. deren Helligkeit wären eine gute Messmethode. Das finde ich auch zu ungenau.

Die sicherlich beste Methode wäre ein Oszilloskop, hier könnte man sich das Signal sehr genau anschauen. Für die Zukunft ist eine Anschaffung geplant, zur Zeit besitze ich leider keins. Für digitale Signale, also solche die nur aus An/Aus bzw High/Low bestehen, kann man einen Logic Analyser verwenden.

Wie bei allen Messgeräten ist die Preisspanne der verfügbaren Geräte extrem. Ich wollte preiswert einsteigen und habe mir einen bei Logic Analyser bei Aliexpress für 5€ bestellt.

Beim Aliexpress stand leider nicht wirklich viel über kompatible Software, mit irgendetwas muss man sich die Signale ja dann anschauen. Die Firma saleae verkauft eigene Logic Analyzer und liefert eine gute Software mit. Irgendwo habe ich gelesen, dass die kleinen preiswerten China-Geräte mit deren Software kompatible sind. Der saleae-Support schrieb mir recht klar, dass die Software zwar kostenlos sei, aber nur ihre eigenen Produkte unterstützt.

Entgegen dieser Aussage, funktioniert mein (China) Logic Analyzer einwandfrei mit der saleae-Software.

Nach ein paar Experimenten habe ich es dann geschafft mit einem Arduino Uno mehrere PWM-Signale mit 25 kHz und verschiendenen duty cycles hinzubekommen.

Leider muss man beim ATmega328P (das ist der Mikroprozessor des Arduino Uno) dafür auch den Timer0 verwenden bzw. umkonfigurieren. Der wird aber für viele andere Dinge wie delay() oder OneWire benötigt. Das heißt für mich kommt der Uno nicht in Frage. Ich werde den Arduino Leonardo (ATmega32u4) verwenden, dieser hat einen weiteren 16Bit-Timer, damit sollte alles realisierbar sein.

Leider konnte FreeNAS damals noch nicht die Temperatur der Festplatten überwachen. Irgendwann letztes Jahr fiel einer der zwei Frontlüfter aus. Das habe ich leider nicht mitbekommen. Langsam aber sicher hat das die Platten gegrillt.

Lange Rede, kurzer Sinn: Diesmal wollte ich ein Gehäuse für größere Mainboards als MiniITX und mit ordentlich Platz zwischen den Festplatten. Meine Wahl fiel auf BeQuiet’s PURE BASE, hier lagern bis zu fünf Festplatten in Einzelkäfigen übereinander. In der Front kann man zwei 14 cm oder drei 12 cm Lüfter verbauen.

Nun wollte ich natürlich alle Kabel sauber verlegen. Bei den SATA-Stromkabeln stieß ich auf Probleme. Erstens hat mein Netzteil an jedem Kabelstrang nur drei SATA-Anschlüsse und zweitens liegen die Festplatten etwa 6 cm auseinander. Das ist zu dicht um die Standard-Kabel ordentlich zu verlegen und zu weit auseinander für die gängigen Mehrfach-SATA-Kabel.

Was lag da näher als die Kabel passgenau selbst herzustellen. Folgende Teile habe ich beim AliExpress gekauft:

• 5 x SATA-Stecker mit Verriegelung (Σ ~ 2,50€)
• 4 x AWG 18 Kabel in den Farben Rot/Schwarz/Gelb (Σ ~ 2,00€)
• 1 x 4 Pin Molex-Buchse Gehäuse und Pins (~ 0,50€)

Der Zusammenbau ist einfach, die Kabel kann man einfach in die Stecker quetschen, ich habe dafür einen Phasenprüfer benutzt. Für die Pins der Molex-Buchse braucht man eine Crimp-Zange, es gibt aber auch hier Varianten mit Quetsch-Verbindungen.

Beim AliExpress muss man immer etwas suchen und vergleichen. Einzelne Artikel sind oft günstiger wenn man sie mit kostenlosem Versand bestellt, bei mehreren Artikeln ist es machmal besser mit Versandkosten zu bestellen.

Insgesamt habe ich etwa 5€ für die Materialien für das Kabel bezahlt, dass ist deutlich unter dem was man für ähnliche fertige Kabel bezahlen würde, wenn man sie denn käuflich erwerben könnte.

Ich habe die Kabel zwischen den Steckern noch mit Schrumpfschlauch versehen, möglich und etwas schöner wäre vermutlich Nylon-Gewebe gewesen.

Verbaut sieht das Ganze recht ordentlich aus und funktioniert tadellos, aber was soll da auch nicht funktionieren, ist ja nur Strom.

Als nächstes hab’ ich mich um die Lüftersteuerung gekümmert. Das ein Lüfter aussteigt und ich das nicht mitbekomme soll ja nie wieder passieren.

Bei Fragen oder Kommentaren schreibt mir einfach eine E-Mail, ich veröffentliche das dann hier wenn ihr wollt.

Ich hatte die letzten Jahre Wordpress im Einsatz und war immer nur so mittel zufrieden. Das lag sicher auch daran das ich nicht so regelmäßig veröffentlicht habe und mich jedes mal wieder neu in die Feinheiten einarbeiten musste. Ein anderer Punkt war, dass trotz der vielfältigen Einstellungsmöglichkeiten, bestimmte Sachen nicht so gingen, wie ich mir das vorstellte, außer ich hätte angefangen Templates zu verändern oder am Wordpress-Code selbst rum zu spielen. Beides keine Gute Idee, denn bei einem Update werden solche Änderungen meist überschrieben.

Diesmal verwende ich Hugo, ein in Go geschriebens Framework zum Erstellen statischer Webseiten. Im Grunde erstellt man seine Seiten in der Auszeichnungssprache Markdown, welche auch HTML enthalten können und legt diese in einer Ordernerstruktur ab. Zusammen mit CSS und einer Konfigurationdatei generiert Hugo dann daraus die eigentliche Webseite, mit Indexseiten, Tags und Kategorien.

Dafür braucht man Serverseitig keinen Interpreter, d.h. aber auch das man keine Daten entgegen nehmen und/oder verarbeiten kann. Das hat den Nachteil das Formulare und ähliches so erstmal nicht möglich sind, hat aber auch den Vorteil das prinzipbedingt die üblichen Angriffe auf Webseiten (OWASP Top 10) schwerer durchzuführen sind.

Ob das ganze für mich funktioniert wird sich zeigen, aber auf die letzten Jahre zurück blickend denke ich das wird schon klappen 👍, die paar Kommentare kann ich auch per E-Mail entgegen nehmen und hier veröffentlichen. Also dann auf ein fleissiges bloggen ähm posten …