Montag, 17. Oktober 2022

Da fehlen ja noch Bilder !

Stimmt, da fehlen sogar noch eine Menge Bilder. Beginnen wir damit, dass ich beim Bohren der Löcher schon wieder einen Hals bekommen habe, weil mein Stufenbohrer nur bis 30mm geht, die Löcher für die Steckdosen aber 35mm groß sein müssen. Also habe ich nach dem Bohren mit einer Rundfeile die Löcher mehr mit roher Gewalt als mit handwerklichem Geschick aufgeraspelt:


"Schief ist schick! Schief ist modern!". Oder so. Egal! Hauptsache, passt. Dann kamen da die vier Steckdosen rein, und an der Seite noch eine Durchführung für das Netzkabel. 


Innenansicht:


Oben links ist das erste der vier Relais montiert. Und wenn man alle vier Relais verkabelt hat, dann sieht das so aus:


Die zweite Durchführung, die man hier im Bild oben rechts erkennt, ist für den Temperatur-Fühler. Soweit zum "Back-End". Für das Frontend wollte ich mir eigentlich eine Platine machen, aber dann dachte ich mir "Für einen Prototypen so einen Aufwand?", und habe alles auf einer Punktraster-Platine aufgebaut:


Und so sieht das dann fertig gelötet aus:


Und eingebaut:


Fertig ist die Kiste:




Donnerstag, 17. März 2022

Programmierung abgeschlossen

Was lange währt, wird endlich gut

Die Programmierung ist nun endlich beendet, alles ist drin, alles funktioniert und Eingabefehler werden einigermaßen von den Web-Seiten abgefangen. Natürlich kann man immer noch eine Menge Blödsinn anrichten, wenn man sich URLs zurecht biegt und an den Controller schickt, es gibt auch keine Passwort-Sicherheit usw. Aber ich denke mir, wer es schafft, in mein lokales WLAN zu kommen, der darf auch meine Gartenbeleuchtung ein- und ausschalten. Ich gehe schließlich nicht davon aus, dass jemand diese Schaltuhr dazu benutzt, ein Kernkraftwerk zu steuern.

Anstelle der NodeMCU habe ich nun auch das Zielsystem, das winzige ESP8266-01 programmiert, erste Tests waren zufriedenstellend.

Jetzt geht es daran die Schaltung vom Steckbrett zu erfassen, eine Platine zu layouten und schließlich zu fertigen. Fortsetzung folgt.

Sonntag, 13. März 2022

Prototyp auf Steckbrett

 Überblick

  • Oben rechts die NodeMCU mit USB Stecker zum Laptop.
  • Oben links der ATTiny2313
  • Dazwischen der DS1820 Temperatursensor
  • Unten links 4 LEDs zur Anzeige der Schaltausgänge.
  • Unten mittig das Kabel zum Programmer für den ATTiny.
  • Mittig unter dem Kabelgewirr (links von der NodeMCU) das Poti für die Kontrasteinstellung.

Protokoll

Da die serielle Ausgabe der NodeMCU sowohl für das Debuggen, als auch für die Kommunikation zum ATTiny verwendet wird, muss der ATTiny wissen, wann er gemeint ist, damit nicht alle Debugausgaben auch auf das Display gelangen. Ferner werden einige Steuerzeichen gebraucht, um das Display bspw. zu löschen oder den Cursor zu positionieren.
Prinzipiell habe ich das so gelöst, dass alles zwischen den beiden ASCII-Zeichen STX und ETX als anzuzeigender Text behandelt wird. Das Steuerzeichen FF löscht das Display, CR setzt den Cursor an den Anfang der aktuellen Zeile und LF setzt ihn eine Zeile tiefer.
Außerhalb von STX und ETX reagiert der ATTiny auf die Sequenzen DC1-DC4 gefolgt von ACK/NAK. Damit werden die vier Ausgänge umgeschaltet. Mit der Sequenz DC2 ACK wird beispielsweise Port 2 eingeschaltet.

Samstag, 12. März 2022

Die Schaltuhr tickt

Erste Versuche auf dem Steckbrett

Tatsächlich habe ich noch keinen ESP8266-01 verbaut, sondern eine wesentlich einfacher zu handhabende NodeMCU. Erstens kann man diese bequem auf einem Steckbrett verwenden (für den ESP8266-01 sind die beiden Pinreihen zu nah beieinander), zum anderen auch viel einfacher programmieren: USB Kabel dran und fertig. Aber prinzipiell sollte das keinen Unterschied machen.
Von der Software der Cistercian Clock ist auch nicht sehr viel übrig geblieben, allenfalls der Web-Server zum Einstellen der Parameter. Das NTP-Server Gedöns habe ich rausgeschmissen, da es bereits in den Kern-Bibliotheken enthalten ist. Auch das ganze Geraffel zum Thema Sommerzeit/Winterzeit konnte ich getrost dem Kern überlassen. So blieb dann hinterher genug Luft, um die Formeln für die Berechnung des Mittags, der Tageslänge und der Dämmerungen zu hinterlegen. So weiß die Schaltuhr nun genau, wann eine Dämmerung beginnt, und wann sie aufhört.
An die NodeMCU habe ich einen Dallas DS1820 nebst Pull-Up Widerstand zur Temperaturmessung angeschlossen. Die Beispielprogramme im Netz hatten leider immer einen katastrophalen Systemcrash zur Folge. Als ich nicht mehr auf das Ende der Messung wartete, blieb der Absturz aus. Vermutlich schert sich die Bibliothek nicht um die Beruhigung des Watchdogs, der pflichtgemäß einen Reset auslöste, weil man ihn zu lange nicht beachtet hatte. Jetzt verwende ich eine Interrupt-Routine mit einem Timer, an dessen Ende ich die Messung starte, um sie zu Beginn des nächsten Interrupts auszulesen. Das wars dann.
Ferner habe ich ein zweizeiliges LCD an die NodeMCU angeschlossen, welches zu Beginn die erhaltene IP Adresse anzeigt, und anschließend das Datum, die Uhrzeit und die Temperatur. Wenn die NodeMCU jetzt noch ein paar freie Pins für die vier Schaltausgänge hätte, wäre ich an dieser Stelle schon beinahe fertig. Aber nöööö....
Der ATTiny2313 war fix programmiert, ich ließ ihn auch aus Bequemlichkeit einfach auf seinem internen 1 MHz RC-Oszillator laufen. Damit war die Wahl der Baudrate natürlich nicht mehr ganz so einfach, aber 4800Bd sollten genau genug machbar sein (1,7 Promille Abweichung). Ich habe die Source in der NodeMCU also auf 4800Bd eingestellt und den ATTiny2313 so programmiert, dass eintreffende Zeichen einen Interrupt auslösen. Dort gebe ich das Zeichen dann einfach aufs Display aus. Bei 4800Bd können 480 Zeichen/s übertragen werden: Für das Display allemal ausreichend. 
Während ich die NodeMCU mit der Arduino IDE programmiert habe, verwendete ich für den ATTiny einfach ein älteres Skelett für den avr-gcc mit einem guten, alten Makefile. So schön die IDE auch sein mag, aber vom Speichern der Source bis zum Ende des Hochladens in nicht einmal einer Sekunde ist auch eine feine Sache. 
So aus reiner Neugierde wollte ich mal wissen, womit die Arduino IDE eigentlich beim Compilieren so ihre Zeit verbringt, da ich eine halbe Minute für etwa 8 C++ Files doch ein wenig übertrieben hielt. Als ich in den Einstellungen die Compiler-Ausgaben einschaltete konnte ich sehen, dass jedes Mal, wenn ich eine Änderung in der Source mache, die IDE alles neu übersetzt, und mit alles meine ich, wirklich alles: Die ganzen Bibliotheken werden ebenfalls alle neu übersetzt. Okay, dafür ist es dann wieder schnell.
Jetzt braucht es noch ein Protokoll, damit nicht alles, was über die serielle Schnittstelle geht (die ja auch als Debug-Leitung zur IDE verwendet wird), auch auf dem Display erscheint. Außerdem noch ein paar vordefinierte Befehle, um die vier Ausgänge (an denen momentan vier LEDs hängen) ein- oder auszuschalten. Fortsetzung folgt.

Mittwoch, 2. März 2022

Die ultimative Schaltuhr

Vorgeschichte

Wir wohnen in einem kleinen Häuschen mit Garten. Und in diesem haben wir auch diverse elektrische Verbraucher, die - wenn möglich - automatisch ein- und ausgeschaltet werden sollen. Das sind zum einen die Teichpumpe, die von morgens um 10 Uhr bis abends zur Dämmerung laufen soll. Dann haben wir da die Gartenbeleuchtung, die von der Dämmerung, wenn es also dunkel ist, bis 23 Uhr leuchten soll. Dann haben da die Teichheizung, die im Winter bei Temperaturen unter 1°C in Betrieb sein muss, damit das Wasser nicht zufriert und die Fische keine Luft mehr bekommen.
Für das alles haben wir unter der Balkon-Terrasse in einem ausgedienten Meerschweingehege einige Schaltuhren und Thermostate installiert. Wenn da jetzt nicht die Sache mit der Dämmerung wäre, könnte man das eigentlich so lassen, aber wenn so mit länger werdenden Tagen die abendliche Beleuchtung immer noch um 16 Uhr angeht, während das Sonnenlicht noch zwei Stunden scheint, dann müsste man das eigentlich nachjustieren. Das Problem ist nur, dass das eine ziemliche Krabbelei unter der Terrasse ist, und man ist nicht mehr der Jüngste. Will heißen, runter ist das kleinste Problem, aber wie kommt man wieder hoch? Da muss man also was basteln.

Anforderungen

Da ich nicht mehr ein ganzes Rudel Uhren und Thermostate unter der Terrasse haben will, erscheint es mir sinnvoll, über eine mehrkanalige Schaltuhr nachzudenken. Vier Kanäle sollten ausreichen. Außerdem will ich die Schaltuhr nicht ständig umstellen müssen: Kann die Uhr sich nicht selbst ausrechnen, wann es dämmert und wann es zappenduster ist? Und drittens: Ich will da überhaupt nicht mehr unten herumkrabbeln. Kann man die Uhr nicht mit dem Handy fernbedienen? Viertens: Sommer- und Winterzeit sollte die Uhr von alleine umschalten.

Die Idee

Ausgehend von einem kleinen Espressif ESP-8266 01 (das ist dieses kleine, niedliche 16x26mm große Platinchen mit den 8 Pins auf der Rückseite und der markanten WLAN-Antenne) baute ich eine kleine Schaltung auf einem Steckbrett auf, und erweiterte den Chip um einen Dallas DS1820 Temperatursensor. Die Ausgabe auf der seriellen Leitung in die Arduino IDE zeigte plausible Temperaturen an. Dann brauchte man noch eine Oberfläche, einen Access-Point, eine Möglichkeit das ganze ins heimische WLAN zu hängen und eine bisschen Software, damit sich der Chip per Network Time Protocol (NTP) selbständig die aktuelle Uhrzeit holt. Ausgehend von diesem interessanten Projekt der Cistercian Clock fand ich einen guten Teil der Software schon dort vor. Leider hat der ESP 01 nicht genug Anschlüsse für den Temperatur-Sensor, die vier Relais und auch noch ein LC-Display. Auch eine NodeMCU hat nicht genug Anschlüsse. Also entschied ich mich für eine Kombination aus ESP-01 als Controller und ATTiny2313 als Porterweiterung. Die Kommunikation verläuft einseitig über eine serielle Schnittstelle.
Der ESP-01 übernimmt also sämtliche Aufgaben, verbindet sich mit dem WLAN, bedient den Temperatur-Sensor und übermittelt dem ATTiny, was dieser aufs Display schreiben soll, bzw. welches Relais er ein- oder ausschalten soll.

Mathematik

Der kasus knusus, also das hüpfende Komma, ist in diesem Fall die Berechnung der Dämmerungszeiten. Basis hierfür ist das Datum, sowie Längen- und Breitengrad. Ich habe mehrfach verschiedene kostenlose und registrierungsfreie Provider getestet, die mir aufgrund der IP Adresse die Position geben sollten, aber der genauste Provider lag immer noch 400km daneben. Das kanns nicht sein. Also muss ich die Geo-Koordinaten wohl per Hand über die Web-Oberfläche eingeben.
Damit und dem Datum konnte ich aufgrund des Längengrades und der Zeitgleichung berechnen, wann exakt eine Sonnenuhr hier Mittag anzeigen würde. Sonnenauf- und untergang liegen um diese berechnete Mittagszeit symmetrisch herum. Mit dem Breitengrad kann man mit den Formeln aus Lichter Tag die Tageslänge von Sonnenauf- bis untergang bestimmen. Mit den Formeln aus Dämmerung bekommt man dann die Informationen zu den Dauern der drei Dämmerungen (bürgerlich, nautisch, astronomisch), wobei mich hier nur die bürgerliche Dämmerung interessiert.
Wir haben nach den Berechnungen also für einen beliebigen Tag X die Informationen:
  • Beginn der morgendlichen (bürgerlichen) Dämmerung (Es wird hell)
  • Ende der morgendlichen (bürgerlichen) Dämmerung (Sonnenaufgang)
  • Beginn der abendlichen (bürgerlichen) Dämmerung (Sonnenuntergang)
  • Ende der abendlichen (bürgerlichen) Dämmerung (Dunkelheit)
Da für diese Berechnungen eine ganze Menge Winkelfunktionen (und somit ein gutes Maß Rechenzeit benötigt werden), werden diese Berechnungen nur einmal um Mitternacht, bzw. nach Eingabe von Längen- und Breitengrad gemacht.

Schaltzeiten

Die Uhr bekommt über das NTP von einem Zeitserver aus dem Internet die Uhrzeit und das Datum. Aus dem Datum kann problemlos der Wochentag berechnet werden. Mit der Osterformel folgen dann der Ostersonntag und davon ausgehend alle anderen beweglichen Feiertage. Somit kennt die Uhr also den Wochentag und alle Feiertage. Damit sind dann diese Kombinationen möglich:
  • Set aus einzelnen Wochentage
  • Montags bis Freitags
  • Wochenende
  • Arbeitstag (= Montags bis Freitags ohne Feiertage)
  • Nicht Arbeitstag (Wochenende und Feiertage)
  • Täglich
Damit können für unterschiedliche Tage unterschiedliche Schaltpunkte programmiert werden. Diese Schaltpunkte sind:
  • Konkrete Uhrzeit
  • Minuten vor / nach Dämmerung (Beginn morgens, Ende morgens, Beginn abends, Ende abends)
  • Unterhalb / Überhalb einer Temperatur

Grundlage für die Schaltuhr ist eine Tabelle mit den Spalten

  • Kanal
  • EIN / AUS
  • Tag
  • Schaltpunkt

Bauteile

Das meiste, was für die Uhr gebraucht wird, gibt es bei Amazon zu kaufen:

Alles zusammen also 120 Euro für Material für zwei (!) Schaltuhren. Dazu kommen noch Kleinteile wie Platine, Schrauben, Distanzröllchen, Kabel, Kabelschuhe, Aderendhülsen, usw. Insgesamt also etwa 80 Euro pro Schaltuhr. Fairer Preis.