Projekte - Rolladensteuerung mit RasPi

In meinem Haus habe ich Rolläden der Fa. SOMFY mit Funksteuerung. Für jeden Rolladen liegt eine seperate Schalteinheit herum und die optionale Zentralsteuerung des Herstellers ist ziemlich teuer.  Also habe ich mich "auf die Suche gemacht....".

Die Ursprünge dieses Projektes reichen mehrere Jahre ( 2018-2019 ) zurück - bei meinen Recherchen im WEB nach einer Möglichkeit, die Rolladenmotoren von einem Computer aus anzusteuern, habe ich damals auf "GitHub" ein vielversprechendes Projekt gefunden...

Diese Dokumentation behandelt ein sehr komplexes Thema und ist daher auch recht umfangreich...und Ihr solltet schon ein gewisses Wissen hinsichtlich der Programmierung mit Lazarus (Pascal), der Arduino IDE (C++)  und dem Betriebssystem Linux/Raspian haben, um es nachvollziehen zu können...

Übersicht

Pi-Somfy...

Die Projektdokumentation findet Ihr auf "https://github.com/Nickduino/Pi-Somfy" - ich hab grad nachgesehen, das Projekt ist noch verfügbar...

ACHTUNG:    "Pi-Somfy" ist KEIN VON MIR ENTWICKELTES PROJEKT - die komplette Software und eine ausführliche Anleitung haben Dritte entwickelt und bei GitHub bzw. auf Ihrer Webseite der Allgemeinheit zu Verfügung gestellt. In meinem Projekt nutze ich lediglich die Funktionen der Software mittels Aufruf aus meinem Programm !!  Alle Rechte und die Urheberschaft an dem Projekt "Pi-Somfy" haben die Ersteller des Projektes !!!!

Das Projekt ist auf "GitHub" sehr ausführlich und gut verständlich dokumentiert, schaut Euch mal die Readme-Datei an.

Für die Umsetzung "ohne weitere Extras" benötigt Ihr lediglich...

• einen RaspberryPi (ich nutze i.d. Regel die 3B+-Versionen) mit Raspian-Betriebssystem
• einen Funksender 433.42 MHz (s.u.) zzgl. Antenne.

In Deutschland haben die Funksender i.d. Regel leider 433.92 MHz, Ihr müsst also den Taktgeber auf dem Board (einen "Dreifuss") auslöten und gegen einen passenden Taktgeber (der meist aus dem Ausland kommt) austauschen.

Hinweis... kauft gleich mehrere dieser Funksender-Boards, das Auslöten ist etwas "tricky" und so ein Board wird schnell durch die Hitze beim Löten beschädigt.....

In der Readme-Datei hat der Ersteller auch Links zu dem benötigten Funksendern und Taktgebern etc. beigefügt - diese scheinen auch noch zu funktionieren.

Die Installation und Einrichtung der Software ist ebenfalls sehr ausführlich beschrieben, da ich dies keinesfalls besser kann - verweise ich Euch auf die Angaben in der o.g. Readme-Datei.....

Hinweis... wenn Ihr auch einen SPI-Touchscreen benutzen wollt, müsst Ihr ggf. die Schaltung anpassen.... (siehe Abschnitt Hardware-Zentralmodul)....

Hinweis... für die Software benötigt Ihr - soweit ich mich erinnere - das Programm Python (ebenfalls eine Entwicklungs-Software mit eigener Programmiersprache) auf Eurem RasPi, bei Standard-Betriebssystem-Installationen sollte es aber bereits mit installiert worden sein. Ggf. müsst Ihr aber noch die richtige Version nachinstallieren, da hilft eine kleine Web-Recherche.....

Da die Rolladen-Motoren mehrere Sender akzeptieren, bleiben Eure originalen Handschalter s.u. weiterhin aktiv - Ihr werden sie allerdings zukünftig nur noch selten nutzen -  denkt dann also an die Batterien in den Schaltern....

Ihr könnt "Pi-Somfy" natürlich auch - völlig unabhängig von meinem Projekt - seperat z.B. über Euren Web-Browser nutzen.

Hinweis... Vergebt bei der Anmeldung der Rolladenmotoren eindeutige Namen - diese werden nachher bei meiner Ansteuerungssoftware benötigt  (ACHTUNG: Linux/Unix etc. unterscheidet Gross/Kleinbuchstaben !!)

Aktualisierung Sept. 2024....

Da ich kürzlich aufgrund eines defekten Rolladenmotors meine Pi-Somfy-Installation überarbeiten musste - noch einige ergänzende Hinweise.....ich greife dabei mit dem VNC-Viewer auf den RasPi zu...

1. ihr müsst mit folgendem Befehl in der Betriebssystemebene (Terminal) das Programm starten..(ggf. die *.conf-Datei anpassen, wenn sie bei Euch anders heisst..)

   sudo python /home/pi/Pi-Somfy/operateShutters.py -c /home/pi/Pi-Somfy/operateShutters.conf -a 

   Dann könnt Ihr mit dem Webbrowser auf dem RasPi über "localhost" auf die Web-Oberfläche "pi-Somfy" zugreifen.

2. Wenn Ihr Eure Somfy-Steuerschalter in den "Edit-Modus" versetzt, um dann die Steuersequenzen zu ermitteln und abzuspeichern - BEACHTET das der Modus für längere Zeit aktiv bleibt - macht Ihr dann einen zweiten Schalter "scharf", koppeln sich die beiden Schalter untereinander !!! Ihr könnt den aktuellen Schalter durch einen Steuerbefehl an den Rolladen aber aus dem o.g. Modus "zurückholen".  NICHT VERGESSEN !!!

Ist mir zu kompliziert..... =>.... zurück zur Startseite

Meine Rolladensteuerung...

Mein Steuerungsmodul mit einem RasPi 3b+  hängt bei mir seit Jahren (Start war ja etwa 2018/19) an der Wand und "macht seinen Job" - mittlerweile mit Erweiterungen wie ...

• einem kleinen Touchscreen und einer LED-Statusanzeige,
• einem externen Temperatur-/Solarsensor mittels ESP32 und Bluetooth,
• einer kleinen hausinternen WLAN-Web-Steuerung für die Betätigung der Rolladen durch das Mobiltelefon,
• aktuell jetzt auch mit Aufzeichnungs-/ Grafik-Funktionalität für meinen Deye-Solarinverter.

Und so sieht es dann bei mir aus...(für Beschreibung mit Maus auf Bild gehen)

Als Erweiterung ist dann irgendwann noch eine kleine Box mit einem ESP32 dazugekommen, welche auf der Südseite meines Hauses steht - dort Sonneneinstrahlung und Raumtemperatur misst - und diese Werte dem RasPi auf Anfrage zur Verfügung stellt. Somit kann ich automatisch z.B. mittags ausgewählte Rolladen herunterfahren und mein Wohnzimmer kühl halten - wenn die Sonne zu stark scheint.

Ist mir zu kompliziert..... =>.... zurück zur Startseite

Hardware Zentralmodul...

Der technische Aufwand am Zentralmodul beschränkt sich (in der Grundversion ohne Extra's) prinzipiell auf die in der "Pi-Somfy" - Anleitung beschriebenen Anschlüsse des Funksenders...

Aber...

Als Display habe ich damals (2019) bei einem bekannten WEB-Portal ein "3,5 inch 320*480 dPi Touchscreen TFT LCD Display Modul mit SPI-Interface" für knapp 25 € erworben - dieser Touchscreen wird direkt auf die Schnittstellenleiste des RasPi aufgesetzt.

Dadurch werden natürlich mehrere GPIO-Pin's blockiert, für die weitere Hardware (und auch die "Pi-Somfy"-Steuerung) müssen wir also auf freie GPIO-Pin's ausweichen.

Für "Pi-Somfy" habe ich daher den GPIO13 genutzt, dazu müsst Ihr dann die Datei "shutters.conf" wie in der Anleitung beschrieben anpassen (GPIO4  => GPIO13 ändern). Für meine Status-LED habe ich den GPIO5 genutzt...

Da nicht zuletzt auch das Display "eine Menge Strom zieht" müsst Ihr für die Stromversorgung des RasPi's ein grösseres Netzteil einplanen...

Meine damalige Schaltungs-Lösung werde ich noch dokumentieren, wenn ich das nächste Mal das Zentralmodul auseinander baue... 

In Sketchup habe ich mir ein Gehäuse mit einer Wandaufhängung zum "Klipsen" und einer Abdeck-Klappe gebaut....

und hier die Sketchup-Datei zum Download....

Ist mir zu kompliziert..... =>.... zurück zur Startseite

Hardware Temperatur-/Solarsensor...

Für die Ermittlung der aktuellen Sonneneinstrahlung und der aktuellen Temperatur in meinem Wohnzimmer habe ich mir eine kleine Elektronik mit Unterstützung eines ESP32 gebaut....

Die Beschaltung habe ich damals - mehr durch Versuch als durch Wissen - folgendermaßen gelöst....

Was sehen wir...

Die Photodiode hat bei Dunkelheit einen sehr grossen Innenwiderstand - mehrere MOhm (gesprochen MegaOhm),  bei Helligkeit fällt dieser dann deutlich ab und es fliesst ein grösserer Strom - zusätzlich produziert die Diode selbst auch noch etwas Strom aus der Sonneneinstrahlung (wie eine Solarplatte). 

Solange die Basis unseres npn-Transistors keinen massgeblichen Strom bekommt, sperrt der Transistor den Durchgang und der GPIO32 unseres ESP32 bekommt "die volle Ladung ab" (sprich 3.3V, der Strom wird dabei durch den Widerstand begrenzt) - ist also definitiv Status HIGH (siehe auch Pull-Up-Schaltung). Schaltet der Transistor aber den Durchgang frei, so fliesst ein wesentlicher Teil über den 10kOhm Widerstand ab - im Prinzip eine Spannungsteiler-Schaltung - unser GPIO32 bekommt den Status LOW.

Der ESP32 - siehe Software - ist solange im DeepSleep-Modus, solange der GPIO32 im Status HIGH ist, er "wacht erst auf", wenn sich der Status zu LOW ändert.

Somit können wir unser System in Abhängigkeit von der Helligkeit de-/aktivieren...

Was sehen wir...

Im linken Teil unserer Schaltung haben wir die Temperatur-Ermittlung. Der Thermowiderstand ändert ja seinen Widerstand in Abhängigkeit von der Temperatur, ich kann ihn im eingebauten Zustand leider nicht mehr nachmessen aber der Grundwert anderer Thermowiderstände in meinem "Tütchen aus FernOst" ist hier bei 25 Grad  =>  100 kOhm (gesprochen kiloOhm). Und bei  50 Grad hatte ich zum Beispiel (siehe Abschnitt Lüftersteuerung im Projekt Windradsteuerung )  => 45 kOhm gemessen) .

Die Schaltung funktioniert im Wesentlichen ebenfalls wie ein Spannungsteiler (hier zwischen dem inneren Widerstand des ESP-GPIO und dem Thermowiderstand)..  Wenn wir am GPIO27 per Software 3.3V ausgeben, dann messen wir am GPIO33 eine Spannung, welche sich im Verhältniss der beiden Widerstände ändert...

Da wir aber den Innenwiderstand des ESP32 nicht kennen, wird unsere Messung etwas ungenau - dies habe ich dann einfach durch einen Korrekturfaktor der Temperatur in der Software gegenüber vor Ort gemessener Temperatur  angeglichen s.u..... 

Im rechten Teil unserer Schaltung haben wir eine kleine Solar-Zelle  (aus so einer ca. 1€-Gartenwegbeleuchtung aus dem Baumarkt), diese erzeugt je nach Sonneneinstrahlung zwischen 0 bis 3 (ggf. auch max. 4) Volt im unbelasteten Zustand gemessen (wie ich heute weiß nennt sich dies Leerlauf-Spannung)...

Da unser ESP32 ja max. 3.3 Volt verträgt und der Messbereich von 3,2-3,3V am ESP32 eine "sehr schlechte Auflösung" hat, musste die Spannung sicherheitshalber aber "begrenzt" werden. Ich hatte damals planmässig den 1kOhm -Widerstand eingebaut - musst dann aber feststellen, das die Spannung trotzdem noch zu hoch war. Also habe ich den 510'er noch "draufgelötet"...

Das heutige Ergebnis habe ich somit "iterativ" (durch Ausprobieren) erzielt, die nachfolgenden technischen Betrachtungen hab ich erst jetzt gemacht:

Die o.g. Leerlaufspannung steigt bei Solarzellen mit zunehmender Sonne schnell an und bleibt dann aber nahezu auf dem Maximal-Niveau.

Unter Lasteinfluss (Widerstand = Verbraucher) bricht die Leerlaufspannung der Solar-Zelle aber "unsymetrisch" ein, .....ich habe mal nachgemessen (hinter der Scheibe).....

BEACHTE:  die Widerstände 500 Ohm und 1 kOhm wirken ja parallel, der resultierende Widerstand ist also (500*10000) / (500+10000)  = 485 Ohm...also nahe dem 510 Ohm Widerstand alleinwirkend. Aber den 1kOhm-Widerstand hatte ich ja damals zuerst eingelötet...

Somit kann ich jetzt in Abhängigkeit von vorhandener Temperatur und aktueller Sonneneinstrahlung meine Rolladen regeln.....

In Sketchup habe ich mir ein auch hier Gehäuse gebaut....

und hier die Sketchup-Datei zum Download....

Ist mir zu kompliziert..... =>.... zurück zur Startseite

Software Zentralmodul...

Meine zentrale Steuerungs-Software habe ich auf dem Raspi mit Lazarus programmiert, bei mir ist die Programmieroberfläche auf dem RasPi installiert, um in Testphasen auch die Funktionen der Software zur Fehlersuche nutzen zu können.

Dieses Programm läuft auf unserem RasPi mit Raspian als Betriebssystem. Es verwendet diverse - Linux-spezifische Routinen - und kann also auch NUR AUF DEM RasPi ausgeführt werden !!!

Das Rolladen-Programm startet bei jedem Rechner-Neustart bei Anzeige der Desktop-Oberfläche neu. Dazu habe ich einen Autostart mit einer .desktop-Datei eingerichtet, die Datei ist im Zip-Archiv enthalten, muss aber in das Verzeichniss ../home/pi/.config/autostart/... kopiert werden. Wird Euch das Verzeichniss nicht angezeigt (Systemverzeichniss), dann könnt Ihr die Datei auch mit folgendem Befehl anlegen...

sudo nano ~/.config/autostart/Rolladensteuerung.desktop

Dateiinhalt...

[Desktop Entry]
Name=Rolladensteuerung
Comment=Steuerung der Rolladen im EFH
Type=Application
Exec=/home/pi/daten/Rolladensteuerung/Rolladensteuerung
Terminal=false

Für das Projekt wird weiterhin auch in der Lazarus-Installation die "LaszSerial-Komponente" benötigt. Erklärungen dazu und auch zum Aufruf externer Scripte und Programme findet Ihr in meinem Beitrag zu Lazarus ....

Denn wir verwenden einige ausführbare Unix-System-Scripte (*.sh-Dateien), um z.B. die Bluetooth-Anbindung zu realisieren und um den RasPi kontrolliert neu zu starten.

Im Archiv sind daher neben den "üblichen" Lazarus-Projektdateien auch 2 spezielle LINUX-Batch-Dateien (*.sh) für die Anbindung bzw. das Trennen derselben zum ESP über Bluetooth, diese müsst Ihr editieren und die aktuelle Bluetooth-Adresse Eures ESP eintragen...

Dazu muss natürlich auf dem ESP das dortige Programm laufen, damit er sich über Bluetooth überhaupt meldet....

Dann geht Ihr dazu in das Linux-Terminal-Fenster auf Eurem RasPi (das kleine schwarze Fenstersymbol in der Statusleiste), dort gebt Ihr ein....

sudo hcitool scan

Als Ergebniss solltet Ihr dann solch eine kryptische Antwort bekommen, dies ist die Bluetooth-Adresse Eures ESP.....

A0:A3:B3:2B:EB:BA               ESP32_Rolladen

Mit dieser Adresse müsst Ihr den Eintrag in den beiden Dateien anpassen, dies sollte mit dem Texteditor des Betriebssystem problemlos möglich sein. 

Hinweis... Ein "#" vor der jeweiligen Zeile deaktiviert diese Zeile für die spätere Ausführung....

Die *.sh Dateien sind eigentlich bereits als "ausführbare Dateien" definiert - sollte dies aber auf Eurem RasPi nicht funktionieren, müsst Ihr mal im Web nach den notwendigen Schritten für "Script ausführbar machen....." suchen. (ist aber nicht kompliziert)

Auch die "Pi-Somfy"-Software wird über die zugehörigen Phyton-Programmdateien "ferngesteuert"...dazu muss wie bereits erwähnt Python auf Euren RasPi installiert sein.

( hier ein Beispielauszug... )

 // die einfachen Ansteuerungen...
 if ( (Job_Liste.cells[3,i] = 'Runterfahren') or (Job_Liste.cells[3,i] = 'Hochfahren') ) then
     begin
     befehl:='';
     my_process:=TProcess.create(nil); // Ausgabe
     my_proclist:=TStringlist.create;  // Rückgabe
     // je nach Eingabe die Steuerbefehle...
     // die Steuerung für externes pythonprogramm zusammenstellen

     // einleitende syntax
     befehl:= 'sudo python /home/pi/Pi-Somfy/operateShutters.py ';
     // Name des Rolladenmotors
     befehl:=befehl + Job_Liste.cells[2,i];
     // syntax-Fortsetzung
     befehl:=befehl + ' -c /home/pi/Pi-Somfy/my_operateShutters.conf ';

     // Steuerbefehl für Tätigkeit...
     if  Job_Liste.cells[3,i] = 'Runterfahren' then befehl:=befehl + '-d'; // Befehl down
     if  Job_Liste.cells[3,i] = 'Hochfahren' then befehl:=befehl + '-u';   // Befehl up

     my_process.commandline:= (befehl);
     my_process.options:=my_process.options +  [ poWaitOnExit, poUsePipes];
     my_process.execute;
     my_process.free;
     my_proclist.free; 

Hinweis... Ganz allgemein müsst Ihr ggf. die Dateipfade in den Programmdateien überprüfen und anpassen....Ich habe genutzt...

Installationsverzeichniss   "PiSomfy"   :  .../home/pi/Pi-Somfy/....

mein Programmverzeichniss               :  .../home/pi/daten/Rolladensteuerung/...

Die wesentlichen Programmfenster....

Hinweis.... Ich hatte eigentlich geplant, das "Programmfenster" ohne den Kopfbalken darzustellen - dies ist mit bisher aber noch nicht gelungen - dadurch wird an der Unterkante des Fensters "etwas knapp" - Aber irgendwann bekomme ich die dafür notwendige Einstellung in Lazarus noch heraus...

Um die nachfolgenden Hinweise zu verstehen, empfehle ich Euch, die am Ende dieses Kapitels zur Verfügung gestellten Lazarus-Programm-Dateien herunterzuladen und in Eurem Lazarus zu öffnen....Ein wenig "Programmiererfahrung" muss ich nachfolgend aber voraussetzen - es kann nicht jeder kleine Zusammenhang hier erklärt (sonst wird dies eine "Enzyklopädie").

Die zentrale Steuerungs-Prozedur ist "Start_Stopp_BtnClick", hier läuft die Zeitsteuerung des Programmes. Sobald der Start-Stopp-Button den Status "Start" erhält (also ab System-Neustart bzw. "Mausklick") läuft diese Programm-Schleife durchgehend, bis Ihr auf "Stopp" drückt oder aber das Programm automatisch z.B. aufgrund eines WLAN-Problems neu startet.

Hinweis.... Ich musste feststellen, das der RasPi gelegentlich vom Betriebssystem her in einen sogenannten "WLAN-PowerSafe-Modus" geht - also das WLAN deaktiviert. Dies ist dann ungünstig, da wir ja auch per VNC-Viewer auf unser Programm zugreifen wollen und dann auch die Web-Steuerung für unser Handy nicht mehr funktioniert. Leider habe ich bisher keine Möglichkeit gefunden, dieses Verhalten seitens des Betriebssystems abzustellen (trotz intensiver Web-Recherche). Also prüfe ich regelmässig gesteuert durch die Variable "ping_count" in der Prozedur "Fritz_Ping" auf Vorhandensein des aktiven WLAN ( prüfen ob die FritzBox antwortet...) und starte ggf. den RasPi komplett neu => "Prozedur Neustart"....

Im normalen Tagesablauf setzen wir um Mitternacht das Programm zurück und speichern die aufgezeichneten Solar-Werte aus unserer temporären Tabelle (unsichtbares stringgrid1..) seit dem letzten Neustart (also normalerweise die Tageswerte) in unsere *.csv-Datei.

Dann suchen wir uns die nächste Aufgaben (Termin) aus der "Job_Liste" für das aktuelle "Szenario" und gehen wieder in die "Warte-Schleife".

Hinweis.... Wir können für diverse "Szenarien" unterschiedliche "Job_Listen" definieren z.B. Arbeitswoche, Urlaub, Sommer oder Winter. Allerdings nutze ich aktuell nur ein Szenario - ich hoffe es funktioniert dann auch bei mehrere Auswahlmöglichkeiten korrekt - habe ich aber ehrlicherweise noch nicht getestet....

In der "Warte-Schleife" prüfen wir alle 30 sek (Befehl sleep(30000) Milisekunden)) auf Nutzerbefehle, checken die Verfügbarkeit des WLAN und fragen in einem festgelegtem Intervall (aktuell ca. 10min) den Deye-Solarinverter ab. Um Mitternacht setzen wir wie schon erwähnt die Schleife zurück auf Anfang.

Hinweis.... Da unser RasPi somit immer 30 sek "schläft", bekommt ihr dann auch für diese Zeit keine Antwort auf Eure Eingaben.... natürlich nur im "Automatik-Modus", wenn die Zeitschleife aktiviert ist. Auch nach "Stopp" läuft die Zeitschleife noch 30sek weiter, bis der RasPi reagiert....

Hinweis.... Da hardwareseitig kein "Bildschirmschoner" auf meinem Touchscreen funktioniert, dunkle ich den Bildschirm nach einer Wartezeit ab, indem ich eine schwarze Fläche über der Programm-Oberfläche einblende.

Haben wir die "Job_Zeit" erreicht, überprüfen wir die Daten unseres ESP32-Temperatur-/Solarsenders (s.u.), stellen dann entsprechend der Einträge in der Job_Liste und der Sender_Liste die Befehle für die Ansteuerung der "PiSomfy"-Software zusammen und senden die entsprechenden Sequenzen...

Für Eintragungen und Änderungen in der Job-Liste und Sender-Liste habe ich seperate Eingabeformulare vorgesehen - da wir ja das System ggf. ohne Tastatur über den Touchscreen bedienen müssen, habe ich auch eine vereinfachte  "Bildschirm-Tastatur" mit vorgesehen (siehe unit2 bzw. unit3).

Hinweis... Die Bezeichnung der Rolladen in den Listen MUSS den Bezeichnungen Eurer Rolladen bei der Anmeldung in der "PiSomfy"-Software genau entsprechen !!! Wenn Ihr einen Rolladen einmal definiert habt, wird er Euch dann zur Auswahl mit angezeigt.

Hinweis.... Meine Rolladen wurde bei Installation durch den Handwerker so programmiert, das sie bei Betätigung des mittleren Stopp-Schalters ohne vorherigen Hoch-/Runterfahrbefehl die Rolladen auf den Stand "geöffnete Schlitze" fahren - ist dies bei Euch anders programmiert worden, müsst Ihr das dann entsprechend einstellen.

Hinweis: Die Zeitangaben für die beiden Stellungen  "halbe Höhe"  und  "offene Schlitze" beziehen sich IMMER auf die benötigte Zeit ab vollgeöffnetem Rolladen ( dann spielt die Grösse des Rolladen nur eine untergeordnete Rolle, da er ja nicht angehoben werden muss ). Später wird er dann auch zuerst immer voll hochfahren und dann die eingestellte Zeit wieder herunterfahren.... (in meiner Konfiguration  ist hier nur der Wert für "halbe Höhe" relevant - "offene Schlitze" sind ja voreingestellt und werden mit dem "Stopp-Befehl" aufgerufen).

Für die Ansteuerung über mein Mobiltelefon habe ich eine kleine Webseite angelegt, die massgebende Prozedur ist "onRequest"... Die massgebende html-Seite lade ich beim Programmstart aus der *.html-Datei im Programmverzeichniss in ein unsichtbares Memo2 auf dem Hauptformular....

Die Webseite (ist auch auf dem Computer-Browser möglich) könnt Ihr dann über die IP-Adresse mit dem Zusatz "  :8080 " (für den Zugriff über den Port am RasPi) aufrufen - das sieht dann etwa so aus...

In meiner Rolladenkonfiguration  führt das seperate Drücken der Stop-Taste (ohne vorherigen Hoch-/Runterbefehl) zur Auslösung des Befehls "offene Schlitze".

Für die Abfrage der Solar-Daten meines Deye-Solarinverters sind die Prozeduren "DownloadHTTP", "Solar_Abfragen", "Solar_Zeichnen", "Solar_CSV_lesen" und "Solar_Speichern" verantwortlich, die Bildschirmaktualisierung steuert noch die allgemeine Prozedur "PaintBox1Paint".

Bei einem Neustart des RasPi/Programmes z.B. infolge von WLAN-Problemen s.o. werden die bis dahin in der temporären Tabelle (unsichtbares stringgrid1...) gesammelten Solar-Werte abgespeichert, diese Werte für den aktuellen Tag werden in der Prozedur "Solar_CSV_lesen"  dann wieder eingelesen, damit sie später nicht nochmals gespeichert werden, erhalten sie den Status "saved" . 

hier die Larzarus-Dateien zzgl. der weiteren notwendigen Dateien zum Download...

Um dieses Programm nachzuvollziehen, benötigt Ihr einen RasPi mit Linux (Raspian oder eine aktuellere Variante) und installiertem Lazarus, da die beigefügte zip-Datei mit der Lazarus-Programmierung aktuell im Windows-Dateiformat ist, müsst Ihr sie dann mit "WinSCP" oder einem ähnlichem Programm auf den RasPi übertragen.

ACHTUNG: Die Programmierung ist ein Arbeitsstand, sie funktioniert grundlegend ist aber nicht gegen Fehlbedienung etc. abgesichert. Aber Ihr könnt ein "hängendes Programm" in der Lazarus-Oberfläche jederzeit mit "Halt" abbrechen...

Ist mir zu kompliziert..... =>.... zurück zur Startseite

Software Temperatur-/Solarsensor...

Wie schon vorhergehend erwähnt, startet der ESP32 aus dem DeepSleep erst, wenn es heller wird und der GPIO32 auf LOW geht. Dann läuft das nachfolgende Programm durchgängig bis es wieder dunkler wird. Das gesamte Programm gibt es dann am Ende nochmal komplett als Download für die Arduino-Oberfläche und das ESP32-DevBoard....

(Achtung - der Text [code].....[/code] gehört NICHT zum Programm..)

/* Bastel-Version Stand 25.08.21
 * ESP32 ermittelt mittels Photodiode die Lichtstärke
 * dunkel ca 0.5Volt, voll hell dann 3.3Volt und startet
 * aus dem deepsleep mit pin32 = low  ( pull-up-Schaltung )
 * er misst analog an pin 35 und 33 die licht- und temperatur
 * ermittelt die Voltzahl (rechnet temperatur um) und sendet
 * die Daten über Bluetooth an den Rolladen-RasPi - aktuell
 * durchgehend ständig alle 1 sekunde
 * der ESP antwortet nur über BT wenn der RASPI vorher fragt
 */


#include "BluetoothSerial.h"
#include "math.h"

BluetoothSerial SerialBT;

String Message_BT = "";
char incomingChar = 0;

int i=0;

int Sol_Summe=0;
float Sol_MittelWert=0;
int Sol_SensorValue=0;
float Sol_VoltWert =0;

int Temp_Summe=0;
float Temp_MittelWert=0;
int Temp_SensorValue=0;
float Temp_VoltWert =0;
float Temp_Rt=0;
float Temp_K=0;
float Temp_C=0;



void setup() {  // wird 1x nach Neustart ausgeführt
  
  pinMode(35, INPUT);  // für die Solarzelle - messen - analogRead
  pinMode(32, INPUT);  // für die photodiode - ein/ausschalten - digitalRead
  pinMode(33, INPUT);  // für den Temperatursensor - analogRead
  pinMode(27, OUTPUT);  // Strom für den Temperatursensor - digitalwrite

  
  Serial.begin(115200);
  if (!SerialBT.begin("ESP32_Rolladen")){
     Serial.println("Keine Verbindung"); //Bluetooth device name
     }
  Serial.println("Bereit zum Verbinden");
  
  delay(5000);  // 5sek warten nach Neustart, damit alle Spannungen passen
                // und Bluetooth läuft
                
  // STEUERSEQUENZ  - solange die Photodiode -pin32 low ist wird
  // an Pin 35 der Lichtwert und an Pin 33 der Temperaturwert
  // gemessen, der Strom für den temp-sensor wird an pin27 geschaltet, damit
  // sich dieser nicht durch Dauerstrom erwärmt und falsche Werte liefert....
  
  // solange die Steuerschaltung LOW ist d.h. die Sonne scheint
  while (digitalRead(32) == LOW) {    // d.h. es ist hell und sonnig - Schleife läuft alle 1 Sekunde etwa
 
        // Solar/Temp - Summen zurücksetzen
        Sol_Summe=0;
        Temp_Summe=0;

        // alle sekunde liegt nach der folgenden Schleife 
        // ein neuer wert vor...

        digitalWrite (27, HIGH ); // strom für TempSensor an
        // 10x messen .....und addiert das Ergebniss
        for (i=1; i<=10; i++){
            // read the input on analog pin 35 => SOLAR-Zelle
            Sol_SensorValue = analogRead(35);
            Sol_Summe = ( Sol_Summe + Sol_SensorValue);   // Aufaddieren
            // read the input on analog pin 33 => Temperatur
            Temp_SensorValue = analogRead(33);
            Temp_Summe = ( Temp_Summe + Temp_SensorValue);   // Aufaddieren
            delay(100); // 10 * 1/100sek = 1 sek
            }
         digitalWrite (27, LOW ); // strom für TempSensor aus
   
        // Mittelwerte der Messungen bilden
        Sol_MittelWert = ( Sol_Summe / i );
        Temp_MittelWert = ( Temp_Summe / i );
  
        // Messwerte umrechnen in Volt
        // Messbereich geht von 0-3.3V und wird in 4095 Stellen aufgelöst
        // nahe 3.2-3.3V ist die Kurve dann gleich gerade d.h. nicht unterscheidbar
        // für float-werte immer Nachkommastellen angeben !!!  
        Sol_VoltWert = (( Sol_MittelWert / 4095.000 )* 3.300);
        Temp_VoltWert = (( Temp_MittelWert / 4095.000 )* 3.300);
        
        // weiter für den Thermistor (Umrechnen lt. Web - Thermistor-Kenndaten und Kelvin/C
        Temp_Rt = (100.000 * Temp_VoltWert) / ( 3.300 - Temp_VoltWert); // 
        Temp_K = 1.000 / (  (1.000 / (273.150 + 25.000)) + ( log(Temp_Rt/100.000)/3950.000) );
        Temp_C = Temp_K - 273.150;
        // wir korrigieren den errechneten wert, welcher anscheinend immer 10 Grad wärmer ist
        Temp_C = Temp_C - 10.000;

 
  /*
    // für eventuelle Kontrollen am lokalen rechner...           
    // Schreibt in den lokalen Monitor
    Serial.print("Solar_Zelle_Volt: ");
    Serial.println(Sol_VoltWert , 3);   // floatWerte so, Integer nur reine Varable
    Serial.print("Temperatur_Volt: ");
    Serial.println(Temp_VoltWert , 3); // floatWerte so, Integer nur reine Varable
    Serial.print("Temperatur: ");
    Serial.println(Temp_C , 3);        // floatWerte so, Integer nur reine Varable
  */

  // der ESP antwortet nur über BT wenn der RASPI fragt... infolge Zwischenspeicherung
  // der Frage / Antwort in einem Cache ist dies nicht unbedingt zeitrelevant
  // gebunden, sollte aber zeitnah sein...
  // SerialBT() startet z.Zt. erst bei der ersten Anfrage automatisch und läuft
  // dann bis zum deep_sleep durch......
  // P.S. AKTUELL liest der RasPi nur den zweiten Wert für Solarspannung und den dritten
  // Wert als Temperatur......
  
    if ( SerialBT.available() ){
    
       Serial.println("empfange");
      
      // auf eine Nachricht vom Pi prüfen...die Nachricht kommt zeichenweise angekleckert...
      // Anfrage MUSS aus Lazarus unix mit  LazSerial1.writeData('text' + #10); 
      // gesendet werden....
      // #13#10 ist in Windows Car+Return => #10 ist in unix Line-end und
      // wird oben als Trennzeichen \n gebraucht....      
      Message_BT="";
      incomingChar = (SerialBT.read());
      while ( incomingChar != '\n' ) {
            Message_BT += String(incomingChar);
            delay(50);
            incomingChar = (SerialBT.read());
            }
      // und auf eine mögliche Anfrage antworten - hier erst mal Kennwort Test...

      if ( Message_BT == ("Test") ) {
        
          Serial.println(Message_BT);
        
          Serial.println("sende");
          SerialBT.print(Temp_VoltWert , 3);  // floatWerte so, Integer nur reine Varable
          SerialBT.print(" // ");                // abschliessendes Trennzeichen
          SerialBT.print(Sol_VoltWert , 3); // floatWerte so, Integer nur reine Varable
          SerialBT.print(" // ");                // Trennzeichen
          SerialBT.print(Temp_C , 3);         // floatWerte so, Integer nur reine Varable
          SerialBT.println(" // ");                // Trennzeichen 
          } 
      }// serialBT available
       
  } // solange Steuerschaltung LOW ist d.h. es ist hell - Schleife läuft alle 1 Sekunde etwa
      
  // und dann einschlafen bis wieder LOW ist...
  esp_sleep_enable_ext0_wakeup(GPIO_NUM_32, 0);   // bis GIOP32 LOW wird
  Serial.println(" deep_sleep ");
  delay(1000);                                    // sprich npn schaltet durch Licht
  esp_deep_sleep_start();

}

void loop() {
  // dauerschleife wird hier nicht gebraucht, da deep_sleep genutzt wird
  }

 das ESP-Programm komplett zum Download...

Die beigefügte zip-Datei ist aktuell im Windows-Dateiformat und wurde auf MS WIN programmiert...

ACHTUNG: Die Programmierung ist ein Arbeitsstand, sie funktioniert grundlegend ist aber nicht gegen Fehlbedienung etc. abgesichert. Aber es läuft schon lange bei mir im System...

.... zurück zur Startseite