Autostart für Gernot
Eigentlich haben wir es ja beide nicht so mit "Smart Home". Smart sind wir selbst und das Hexenhaus braucht kein Hightech-Wohnraum werden. Andererseits ist Will immer noch sowas wie ein Technik-Mensch und wenn im Hexenhaus mal etwas wie von Geisterhand geschieht, dann passt das doch auch irgendwie. Wie dem auch sei: Es setzten sich Teufelchen auf seine rechte und linke Schulter und flüsterten in Stereo: "Gernot braucht einen Autostart!" "Du willst den Diesel per Computer starten können!" und was soll man sagen, sie hatten natürlich recht. Also ging's an die Arbeit um zu schauen, ob das Unterfangen überhaupt möglich ist.
Wie starte ich den Gernot überhaupt?
In Anbetracht der vielen notwendigen Handgriffe am Gerät selbst war es keineswegs offensichtlich, dass sich ein komplett automatisches Starten, wie es jeders moderne Dieselaggregat kann, überhaupt umsetzen lässt. Der normale Startvorgang ist in der Haus-Gebrauchsanleitung beschrieben, siehe also dort. Nach einigen Verwirrungen und mentalen Korrekturen am Schema in der Bedienungsanleitung zeigte sich aber, dass mit nur wenigen neu zu kaufenden und einigen bereits vorhandenen Komponenten die benötigte Erweiterung der Elektrik zum Ziel führen könnte. Theoretisch würde es ja reichen, parallel zu jedem Schalter ein Relais zu schalten und diese durch einen Steuerungsrechner zu schalten. Versuchen wir's also!
Einkaufsliste
Diese Liste umfasst alle Teile und Komponenten, die eingebaut wurde. Einen Großteil davon hatte ich bereits in der Werkstatt herumliegen bzw. waren schon installiert:
- Raspberry Pi 4 Model B (mit installiertem Homeassistant)
- 8fach-Relaissmodul mit Hutschienenhalter von Waveshare
- 24V PC817-Optokopplermodul
- Finder 24V-Relais inkl. Sockel (2xUM)
- 3 Stück 24V KFZ-Lastrelais 80A (1xUM)
- 8 Stück 2.5mm² Durchgangsreihenklemmen
- 4 Stück 4mm² Durchgangsreihenklemmen
- 2 Stück 2.5mm² Erdungsklemmen
- Weidmüller 9-Pol D-Sub RS-SD Schnittstellenmodul
- 9-Pol D-Sub Stecker
- 10m LiYCY 8x0.34mm² geschirmte Steuerleitung
- ~1.5 Meter 2.5mm²-H07V-K Schaltlitze
- ~2 Meter 0.75mm²-H07V-K Schaltlitze
- div. Aderendhülsen und Kabelschuhe
- 25cm DIN-Hutschiene
- Baumer Electric FVDM15P5130/S13 Glasfaserlichtschranke
- Bisschen Panzertape, Schrumpfschlauch, Lötzinn, Kabelspirale und ein paar Kabelbinder und Klebesockel.
Erste Schritte: Parallel geschaltete Relais
Eigentlich ist die Elektrik von so einem alten Diesel sehr übersichtlich, aber der Teufel liegt im Detail:
- Batterie-Minus ist mit Motormasse identisch.
- Akku-Pluspol hängt über sehr dicke Leitung direkt am Anlasser und an der Lichtmaschine, außerdem Abzweigung zur Schalttafel (=Dauer-Plus)
- Geschaltetes Plus hängt hinter dem Zündschloss.
- Dahinter Glühanlassschalter mit Stellungen "Vorglühen", "Start" (und "Stopp")
- Kaltstarteinrichtung mit "Flammenwerfer" im Zuluftkanal und Kraftstoff-Magnetventil
- Sperr-Relais an Öldrucksensor und Kühlwasserthermostat
- Schalt-Kontrollleuchte
- Glüh-Überwacher
Der Glüh-Überwachungsdraht ist in Serie geschaltet mit einem Vorwiderstand und dem Glühdraht der Kaltstarteinrichtung. Während des Startvorgangs wird aber gleichzeitig Plus auf den Anlasser geschaltet und dieser Glühdraht kurzgeschlossen. Warum das so ist, wurde erst nach längerer Recherche klar: Man ging beim Bau davon aus, dass die Batteriespannung beim Betätigen des Anlassers so weit heruntergezogen würde, dass über Glühüberwacher zu viel Spannung abfallen würde und die Glühwendel der Kaltstartvorrichtung ihre Arbeit nicht mehr verrichten können. Es wäre möglich gewesen, diese Schaltung mit insgesamt drei KFZ-Relais nachzubilden, aber es hat sich gezeigt, dass moderne LKW-Starterbatterien bei aktuell sommerlichem Wetter durchaus genug Saft liefern. Ob der Spannungsabfall nur bei alten DDR-Batterien oder nur bei kaltem Wetter ein Problem ist, werden wir im Winter dann sehen.
Das Zündschloss hat die Stellung "aus" (keine Spannung auf geschaltetem Plus), "An" (as you might have guessed) und "stillsetzen". Letzte Stellung schaltet Dauer-Plus auf einen eigenen Kontakt, der in diesem Fall für die Autostart-Elektrik verwendet wird. So ist sichergestellt, dass der Autostart auf keinen Fall dazwischen funken kann, wenn die Schalttafel manuell bedient wird. Umgekehrt kann aber mauell eingegriffen werden, während der Computer die Kontrolle hat.
Nach einigen Stunden Basteln sah der Motor-Schaltkasten so aus:
Und einen Raum weiter an der 24V-Wand dann so:
Wenn überall der Deckel drauf ist, sieht man von dem Kabelgewir übrigens nichts mehr ;)
HASS
Wie oben angedeutet wird zur Steuerung der ganzen Elektrik ein Raspberry Pi mit Homeassistant (HASS) verwendet. HASS bietet eine sehr bequeme Möglichkeit, über Web-UI oder YAML-Dateien Automatisierungen und Steuerungs-Scripte zusammenzubauen und dabei auf Aktoren wie die Relais oder Sensoren wie GPIO-Pins des RasPi zuzugreifen. Die YAML-Version des Autostart-Scriptes sieht so aus:
alias: Gernot starten
sequence:
- service: switch.turn_on
target:
entity_id: switch.gernot_hauptschalter
- delay:
hours: 0
minutes: 0
seconds: 1
milliseconds: 0
- service: switch.turn_on
target:
entity_id: switch.gernot_vorgluehen
- delay:
hours: 0
minutes: 0
seconds: 5
milliseconds: 0
- service: switch.turn_on
target:
entity_id:
- switch.gernot_choke
- switch.gernot_start
- wait_for_trigger:
- platform: numeric_state
entity_id: sensor.gernot_drehzahl
for: '00:00:01'
above: '5'
continue_on_timeout: true
timeout: '00:00:10'
- choose:
- conditions:
- condition: numeric_state
entity_id: sensor.gernot_drehzahl
above: '5'
sequence:
- service: switch.turn_off
target:
entity_id:
- switch.gernot_choke
- switch.gernot_start
- switch.gernot_vorgluehen
default:
- service: switch.turn_off
target:
entity_id:
- switch.gernot_choke
- switch.gernot_start
- switch.gernot_vorgluehen
- switch.gernot_hauptschalter
- wait_for_trigger:
- platform: numeric_state
entity_id: sensor.gernot_drehzahl
above: '24.5'
below: '25.5'
for: '00:00:05'
timeout: '00:00:20'
continue_on_timeout: false
- service: switch.turn_on
target:
entity_id: switch.gernot_strom_ein
mode: single
Was passiert hier? Eigentlich genau das, was passiert, wenn man den Diesel von hand startet:
- Hauptschalter ein, dann eine Sekunde warten
- 5 Sekunden vorglühen (sollte man im Winter vielleicht anpassen)
- Magnetventil der Kaltstarteinrichtung + Anlasser einschalten
- warte, bis die Drehzahl über 5 Hz liegt (der Anlasser schafft ca. 3 Hz an der Kurbelwelle)
- Wenn nach 10 Sekunden diese Drehzahl nicht erreicht ist, schalte alles wieder ab. Ansonsten schalte alles bis auf den Haubtschalter ab
- Warte bis zu 20 Sekunden, bis die Drehzahl ca. 25Hz (=Nenndrehzahl) beträgt
- Wenn Nenndrehzahl erreicht, dann schalte den Wechselstrom am Generator ein. Ansonsten ist hier Ende Gelände und irgend etwas stimmt nicht.
Nun die Große Preisfrage: Wie ermittelt man an so einem alten Gerät die Drehzahl? Ein Arbeitskollege hatte die Idee, das mit einem Magneten und einem Reed-Kontakt wie bei einem Fahrrad-Tacho umzusetzen. Da Will keinen Magneten für 1€ herumliegen hatte, aber ein paar alte industrielle Reflexionslichtschalter für NP ~200€, kam letzteres zum Einsatz. Ein Stückchen Panzertape als reflektierende Fläche kam auf die Keilriemenscheibe und mit einem Kabelbinder-Klebesockel wurde die Lichtschranke positioniert:
Die Lichtschranke wird, wie alles andere, mit 24V betrieben. Die GPIO-Pins des Raspberry vertragen aber nur 3.3V, daher befindet sich zwischen Lichtschranke und Raspi ein PC817-Optokopplermodul mit passenden Vorwiderständen. Das Signal wird zuverlässig übrtragen und ausgelesen.
Frequenzsensor
Das letzte zu lösende Problem war jetzt noch, das Homeassistant zwar einen Binärsensor ("an"/"aus") für die GIPO-Pins am Raspberry bereitstellt, aber keinen Frequenz-Sensor, wie er hier nötig ist. Glücklicherweise ist die Dokumentation hier ganz ordentlich und selbst mit bescheidenen Python-Kenntnissen war es eine Sache von wenigen Stunden, auf Grundlage eines Beispielsensors und eines Beispielscripts von pigpio das hier zu bauen:
from homeassistant.const import FREQUENCY_HERTZ
from homeassistant.helpers.entity import Entity
from homeassistant.components import rpi_gpio
from RPi import GPIO
from datetime import datetime, timedelta
import time
import logging
from . import DOMAIN, PLATFORMS
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the sensor platform."""
SCAN_INTERVAL=config.get("scan_interval") or timedelta(seconds=0.25)
sensors = []
ports = config.get("ports")
for port_num, port_name in ports.items():
sensors.append(
FrequencySensor(port_num, port_name)
)
add_entities(sensors)
class FrequencySensor(Entity):
"""Representation of a Sensor."""
def __init__(self, pin, name):
"""Initialize the sensor."""
self._state = None
self._name = name
self._reader = reader(pin, 0.7)
@property
def name(self):
"""Return the name of the sensor."""
return self._name
@property
def state(self):
"""Return the state of the sensor."""
return self._state
@property
def unit_of_measurement(self):
"""Return the unit of measurement."""
return FREQUENCY_HERTZ
def update(self):
"""Fetch new state data for the sensor.
"""
self._state = str(self._reader.frequency())
class reader:
def __init__(self, pin, weighting=0.0):
"""
Optionally a weighting may be specified. This is a number
between 0 and 1 and indicates how much the old reading
affects the new reading. This may be used to smooth the data.
"""
rpi_gpio.setup_input(pin, "UP")
if weighting < 0.0:
weighting = 0.0
elif weighting > 0.99:
weighting = 0.99
self._new = 1.0 - weighting # Weighting for new reading.
self._old = weighting # Weighting for old reading.
self._last_tick = None
self._period = None
self._high = None
# unfortunately, we have to interact with GIPO directly, since rpi_goio only
# allows listening to both raising and falling edges.
GPIO.add_event_detect(pin, GPIO.RISING, callback=self._cbf, bouncetime=1)
def _cbf(self, gpio):
tick = datetime.now()
if self._last_tick is not None:
delta_t = self.time_since_last_tick(tick)
if self._period is not None:
self._period = (self._old * self._period) + (self._new * delta_t)
else:
self._period = delta_t
self._last_tick = tick
def frequency(self):
"""
Returns the input frequency.
"""
if self._last_tick is None or self.time_since_last_tick() > 1.0:
return 0.0
elif self._period is not None:
return round(1.0 / self._period, 4)
else:
return 0.0
def time_since_last_tick(self, tick=None):
now = tick or datetime.now()
delta_t = (now - self._last_tick).total_seconds()
return delta_t
Damit steht nun eine neue Sensor-Plattform bereit, die in der configuration.yaml-Datei von Homeassistant in diesem Fall folgendermaßen konfiguriert wird:
sensors:
- platform: gpio_freq
scan_interval: 0.2
ports:
27: Gernot Drehzahl
# - ...
Und so kommt die Entität sensor.gernot_drehzahl in obigem Script zustande. Dieser Sensor gibt alle 0.2 Sekunden einen Frequenzwert von 1 Hz aufwärts oder 0 Hz zurück.
Und nu?
Der Start des Generators funktioniert sowohl manuell als auch computergesteuert einwandfrei. Bislang ist das aber mehr als Gimmick zu sehen, da ein atomatischer Stopp des Aggregats nicht so einfach möglich ist. Hier wird wohl noch mit dem Kraftstoffmagnetventil gebastelt werden müssen. Sobald der automatische Stopp funktioniert, könnte der Generator in Abhängigkeit der Batterie-Entladung wie von Geisterhand laufen und anhalten, auch in unserer Abwesenheit.
Klüger wäre es aber, die Freizeit jetzt in den Ausbau der Solaranlage zu investieren, damit Gernot im nächsten Winter gar nicht erst so viel rennen braucht. Und einen Ölwechsel könnte der auch mal vertragen. Und eine neue Auspuffdichtung muss ran. Kraftstofffilter sowieso...