diff --git a/OLD.hardsoftware b/OLD.hardsoftware
index 89219a1..e65466e 100644
--- a/OLD.hardsoftware
+++ b/OLD.hardsoftware
@@ -78962,3 +78962,69 @@
 
 
 
+Wetterstationen (Bambulko, 15. Mar 2022, 14:20:59):
+Ich bin mir nich sicher, ob das die richtige Rubrik ist, aber hat hier
+zuafaellig jemand Ahnung von Privaten Wetterstationen? Ich wuerde mir geren
+etwas kaufen, aber ich habe keine Ahnung wo ich da anfangen kann. Ich haetter
+gerne etwas was ausbaufaehig ist, und bei dem man per Funk Temeraturen an
+verschiedenen Orten aufzeichnen kann. Auch waere es wichtig, dass die Daten
+irgendwo gespecihert werden, und man sie als .csv oder sonst irgendwie
+runterladen kann. Uber Tipps bin ich dankbar.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Wetterstationen (Anthea, 15. Mar 2022, 16:18:34):
+~#! rn=Bambulko rt=1647350459 rg=hardsoftware
+~#! tid=1647350459
+Tja, gute Frage. Ich hatte ueber die Jahre mehrere grosse Stationen, die
+ersten noch mit serieller Schnittstelle, die alle 14 Tage ausgelesen werden
+musste (sonst gingen Daten verloren)... Alle hatten so ihre Problemchen.
+Haeufig gingen die Aussenmodule kaputt, bei einer konnte ich die Ersatzteile
+nur noch aus Frankreich bestellen, bei anderen gar nicht mehr, oder der
+interne Speicher verlor staendig Daten, oder die PC-Software schredderte
+die... Vor ein paar Jahren bin ich dann auf das NetAtmo-System umgestiegen.
+Einmal gingen bei den internen Modulen ueberall die CO2-Sensoren kaputt, das
+war wohl ein Systemfehler, und ist bei den Ersatzgeraeten nicht mehr passiert.
+Dort werden die Daten auf einem Server von Netatmo gespeichert, man kann sie
+von ueberall her abrufen (mit Benutzername/Passwort), oder auch andere Leute
+zum Nutzen einladen. Die Software bietet einen CSV-Export ueber die letzten 3
+Monate, man kann aber auch die Web API verwenden und die Daten als JSON Paket
+holen ( https://dev.netatmo.com ). Das System ist nicht das billigste, aber
+fuer mich bisher das stressfreieste, was ich ausprobiert habe.
+Naja, Stressfrei? Einmal wollte ich im Skiurlaub Mitreisenden zeigen, was das
+alles kann, und dabei festgestellt, dass wohl vor 3 Tagen die Heizung
+ausgefallen war und die Innentemperatur immer weiter runter ging. Das hat dann
+bei mir doch fuer Stress gesorgt ;) Immerhin konnte unser Katzensitter die
+Heizung neu starten, und der Termin mit dem Monteur war dann auch schon
+abgesprochen.
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Wetterstationen (Bambulko, 15. Mar 2022, 16:33:54):
+~#! rn=Anthea rt=1647357514 rg=hardsoftware
+~#! tid=1647350459
+NetAtmo habe ich auch schon gesehen. Das sieht auch schick aus, was die
+Akzeptanz in der Familie erhoehen wuerde. Aber das ganze funktioniert nur
+ueber deren Server? Wenn die mal pleite gehen, oder deren Server ausfaellt,
+funktioniert es nicht mehr?
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Wetterstationen (Anthea, 15. Mar 2022, 16:41:32):
+~#! rn=Bambulko rt=1647358434 rg=hardsoftware
+~#! tid=1647350459
+Ja, meines Wissens ist man da an den NetAtmo-Server gebunden. Da die nicht nur
+die "kleinen" Klimamessgeraete, sondern auch Sicherheitssachen im Programm
+haben, sind die mit hinreichender Wahrscheinlichkeit ueber die naechsten
+vielen Jahre recht sicher aufgestellt.
+
+-----------------------------------------------------------------------------
+
+
+
diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index c28c3bc..5109dff 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
