Projekte - Solar-Ströme mit MosFet's steuern...

Noch in Arbeit....Bei meinen bisherigen Projekten habe ich mich auf den Bereich kleinerer Spannungen und Ströme (elektronische Basteleien) beschränkt, aber gelegentlich muss man ja auch grössere Verbraucher etc. ansteuern. In diesem Fall die Ströme meiner Solarpaneele. Und so habe ich mich mal mit dem Thema beschäftigt....

ACHTUNG:

Die in diesem Projekt gemachten technischen Angaben, Überlegungen, Empfehlungen und Hinweise sind teilweise unvollständig ( oder möglicherweise auch unrichtig ) und sollen Euch lediglich einen Überblick verschaffen.  Bei Einsatz und Nutzung der Bauteile, Schaltungen und Programm-Codes müsst ihr UNBEDINGT die entsprechenden Handbücher/Dokumentationen beachten !!!

😎   Da wir hier mit grösseren Strömen und Spannungen arbeiten ist VORSICHT geboten, ich übernehme keine Haftung, wenn Ihr Eure Technik oder Euer Haus abfackelt !!!   😎

😎     Dieses Projekt ist zwar schon recht weit fortgeschritten, aber noch nicht in der Praxis getestet und demzufolge also auch noch nicht ganz ausgereift. Da ich es aus diversen Gründen erst mal unterbrechen musste.... wollte ich es schon mal dokumentieren, bevor wieder alles aus dem Gedächtnis verschwindet - ich bin ja auch "nicht mehr der Jüngste".  Die Angaben sind also MIT VORSICHT zu geniessen ! 😎

Einführung...

Das Thema MosFet's hat in meinen bisherigen Projekten eigentlich keine Rolle gespielt, da ich mich überwiegend im Bereich von geringen Strömen und Spannungen bewegt habe, jetzt allerdings musste ich mich doch mal damit beschäftigen....

Für mein Balkonkraftwerk hatte ich mir kürzlich ja einen Speicher zugelegt, um die als "kostenlose Spende" an meinen Stromversorger verschwendete Überproduktion zur Mittagszeit etwas besser auf den Tag zu verteilen und selbst zu nutzen.

Dieser hat ca. 1 kWh Kapazität ( ist bis auf 5 Speicherblöcke erweiterbar ) und wird zwischen Balkonkraftwerk und Inverter "eingehängt". Der vorhandene Inverter wird dabei weiterhin genutzt, der Speicher selbst hat also keinen eigenen Inverter.

Der Speicher lässt sich aber leider nur über eine "China-App" ansteuern und bietet lediglich wenige vorprogrammierte Steuerungsoptionen...

Im Sinne der Verteilung von selbst erzeugtem Strom aus dem "Zeitraum bester Solar-Ausbeute" in "dunklere Zeiten" wäre ja eigentlich die Einstellung - Zeitbetrieb - optimal - allerdings stellt sich der Speicher dann in den restlichen Zeiten ja "tot" und leitet den Überschuss aus den Solarpaneelen einfach nicht weiter - das ist kontraproduktiv...

Und da mein erster Speicher damals aber nach dem automatischen Abschalten beim ersten Erreichen der eingestellten Mindest-Restladung nicht wieder "aufwachte" und ich einigen Trouble hatte, bis ich ein Ersatzgerät bekam - habe ich auf die Variante "Dauerbetrieb" irgendwie nicht so richtig Lust.

Zwischenzeitlich ist noch ein weiteres Balkonkraftwerk dazugekommen, auch hier habe ich ebenfalls eine Speicherlösung ( mit alten Blei-Säure-Batterien ) ausgeführt, welche dann über einen netzunabhängigen Wechselrichter und seperate Steckdosen für Tätigkeiten auf meinem Hof einen 220-Volt-Anschluss versorgen soll. Lediglich der überschüssige Strom wird ins Netz eingeleitet. Auch hier bin ich mit der Verteilung der erzeugten Energie zwischen den Invertern nicht ganz zufrieden.

Also  habe ich eine Möglichkeit gesucht, den erzeugten Strom zwischen den verschiedenen Mikro-Inverter der Speicher und des Netzanschlusses umzuleiten....

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

Hardware...

Eine denkbare, einfache Lösung wären normale Relais bzw. mechanische Umschalter - allerdings ist zu bedenken, das wir ggf. bei voller Sonneneinstrahlung und entsprechend "fliessenden" Spannungen und Strömen damit den Kontakt herstellen bzw. unterbrechen müssen.

Das könnte dann zu "hässlichen Spannungsspitzen" und sogar Funkenbildung mit entsprechendem Verschleiss an den Relais - ggf. sogar zur Beschädigung der Elektronik im Speicher bzw. Mikro-Inverter führen.

Eine weitere mögliche Lösung sind MosFet's.... - sprich im Prinzip elektronisch ansteuerbare Transistoren.... welche wir bereits in mehreren Projekten bisher als Steuerelemente verwendet haben - nur eben jetzt als Variante für grössere Lasten.

Hinweis: Je nach Bauweise stellt die Rückseite des MosFet's ebenfalls einen mit einem der Füsse verbundenen Pol dar - oft der positive Pol des Arbeitsstromkreises. Dies ist mir mal beinahe zum Verhängniss geworden, da ich in meiner "internen Logik" davon ausgegangen war, das eine so grosse Fläche mit Kontakt zu Kühlkörpern, Gehäuse etc. wohl immer Masse wäre - FALSCH GEDACHT !!! Also IMMER das Datenblatt beachten !

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

MosFet's allgemein...

MosFet's gibt es in allen Grössen für nahezu alle Laststufen. Auf den ersten Blick erscheinen sie somit ideal - aber ihre Auswahl und Ansteuerung ist speziell bei höheren Lasten etwas "tricky" - und damit wollen wir uns hier jetzt mal befassen.

Viele MosFet's werden mit einer Steuerspannung von 10-12 Volt  (Strom fliesst dabei fast keiner) angesteuert, es gibt auch sogenannte Logik-Level-MosFet's, welche bereits ab ca. 5 Volt schalten...

Aber.... die mögliche Belastung ist - nach meinen bisherigen Erfahrungen - dann auch nur relativ gering. Sofern uns dies reicht - z.B. nur für einen kleinen Motor o.ä., können wir fast jeden handelsüblichen MosFet einfach nutzen (z.B. einen IRFZ44N - der wird oft verwendet)

Erläuterung...

Wir sehen hier die Strom-Spannungsdiagramme mit der jeweiligen Spannung der Ansteuerung unseres MosFet's (das sind die gezeichneten Linienwerte beginnend mit der minimal erforderlichen Ansteuerungsspannung von 4.5 Volt).

Ein MosFet ohne Ansteuerung hat einen "riesigen Innenwiderstand" d.h. er sperrt den Stromkreis nahezu vollständig. Wird er hingegen voll  angesteuert ( i.d. Regel dann mit 10-12 Volt ), fällt der Innenwiderstand sehr stark - durch den jetzt nur noch sehr geringen Restwiderstand wird allerdings immer noch etwas Strom "verbraten", was zu einem Temperaturanstieg führt.

Nicht voll durchgesteuerte MosFet's (z.B. nur mit 5 Volt angesteuert) leiten zwar bereits (siehe Diagramme), haben aber einen erhöhten Innenwiderstand => werden recht schnell heiss - sehr heiss !!!

Zwar wird als maximale Betriebtemperatur oft bis zu 175 Grad Celsius angegeben - aber wer möchte in seiner Schaltung schon derartige Temperaturen haben und die Haltbarkeit ist dann sicher auch nicht unbedingt optimal.

Bevor Ihr also im Web einkaufen geht, die dort angegebenen Kennwerte wie auch die Kennwerte auf den Datenblättern (meist im Kopfbereich dargestellt) sind so erst mal für uns nicht brauchbar.

Also müssen wir uns mit dem Thema noch etwas ausführlicher beschäftigen.......

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

Ermittlung der Belastungen...

Zuerst müssen wir uns mal Gedanken um die zu schaltenden Spannungen und Ströme machen, bei mir hier somit...

mein Deye-Inverter  ( ACHTUNG jeweils für einen Teil-/Paneelkreis..)

mein Speicher Storcube S1000  ( ACHTUNG jeweils für einen Teil-/Paneelkreis..)

mein Batterieladegerät Anern Solar Charge Controller 30A...( ACHTUNG für einen Teil-/Paneelkreis..)

Dies ist so ein günstiges "blaues System" aus "FernOst" erhältlich auf vielen WEB-Portalen, in meinem Fall speziell und NUR für Blei-Säure-Batterien (versiegelt,Gel,Flood(?))...

meine Solarpaneele  ( ACHTUNG für einen Teil-/Paneelkreis..)

Mein Paneel hat eine Nennleistung von 405 Watt maximal - also 31,2 V * 13,9 A = 405 W...

Da wir ja unsere Schaltung zwischen Solarpaneel und Inverter anordnen wollen, sind die Werte des Solarpaneels auch unsere Bemessungswerte für die Auswahl des MosFet's....

Hinweis: Betrachtet man die Strom-Spannungs-Kurven von Solarzellen, so sieht man das die Spannung ab Start (Sonneneinfall) recht schnell auf einen Regelwert ansteigt und dort nahezu unverändert bleibt, während der Strom entsprechend der Sonneneinstrahlung dann zu- bzw. abnimmt. Ob dies hier ebenfalls von Bedeutung ist, kann ich aktuell noch nicht beurteilen.....

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

Überlegungen zur Auswahl der MosFet's...

So, bisher war die Sache recht simpel - jetzt wird's etwas komplizierter - aber wir schaffen das schon....

Wie gesagt sind die Angaben von Händlern im Web bzw. auf den Datenblättern ohne weitere Betrachtungen / Berechnungen für uns so erst mal wertlos.

Ich habe viel recherchiert und ausprobiert und auf dieser Basis in mehreren Versuchen mehrere Versionen von MosFet's gekauft, "gegrillt" etc.....

Theoretisch kann - lt. diesen Angaben - z.B. der bereits zuvor erwähnte MosFet IRFZ44N lt. Datenblatt eine maximale Spannung von 55 Volt und einen maximalen Strom von 47A schalten....wenn Ihr das aber so dran klemmt ist der MosFet in kürzester Zeit entweder rotglühend oder einfach durchgebrannt - was dann ggf. einen Kurzschluss zur Folge hat. Mich hat dies ( mit deutlich geringeren Strom-/Spannungswerten beim Testen ) bereits ein ESP32-Dev-Board... gekostet.

Es gibt also noch eine ganze Reihe von anderen Kriterien, wie z.B.:

• bereits oben erwähnt die Spannung der Ansteuerung  (V_gs);
• ebenfalls bereits erwähnt der Innenwiderstand - je nach Ansteuerung und aktueller Temperatur des MosFet unterschiedlich (R_DSon);
• die Art der Ableitung der entstehenden Temperaturen - die Übergangswiderstände zur Luft (R_0JA) oder zum Kühlkörper (R_0JC) bzw. zum Kühlkörper mit Wärmeleitpaste (R_0CS).

Weitere Kriterien sind z.B. die Art der Ansteuerung (ständig bzw. gepulst ein/aus mit entsprechenden Frequenzen) und möglicherweise auch die Grösse und das Verhältniss Lastspannung und Laststrom => die zulässige Leistung....( in Watt) .

Eine kleine Berechnung (für Teilbereiche der Bemessung) hierzu habe ich mir mal anhand der Videos und Erklärungen auf der Webseite "www.shelvin.de" zusammengebastelt, ich habe sie als MS-EXCEL(97-2003)-Datei hier hinterlegt.

Die Werte gelten für den von mir aktuell ausgewählten MosFet IRFP260N..gemäss der oben erwähnten Grundangaben auf dem Datenblatt soll der - schon etwas grössere MosFet - bis zu 200 Volt und 50A schalten können....

Mal sehen, was draus wird....

Junction to Ambient ist die Temperaturabgabe ohne Kühlkörper, die Drain-Source-Resistance der interne Widerstand (durchgeschaltet bei 10 Volt Steuerspannung), dieser Widerstand erhöht sich mit zunehmender Temperatur hier bis auf das 1.5-fache (bei gewählter zulässiger Temperatur)  => die dann zulässigen Werte sehen schon ganz anders aus....

Dies ist für uns erst mal noch ohne Relevanz, da wir ja dauerhaft schalten wollen, die Frequenz ist abhängig von der internen Sättigung-Geschwindigkeit des MosFet's und kann auch durch einen Vorwiderstand beeinflusst werden....

Mit einem Kühlkörper können wir die entstehende Wärme ableiten, auf Basis der geplanten Stromstärke und der gewünschten Temperatur können wir die Wärmeableitung (eigentlich den Widerstand gegen Wärmeabfluss) unseres notwendigen Kühlkörpers ermitteln. Leider finden sich bei den Anbietern auf den Web-Plattformen selten Angaben bei den günstig angebotenen Kühlkörpern - ggf. muss man dann bei den spezialisierten Elektronikanbietern mal etwas nachschlagen - bei ähnlichen Kühlkörpern - WICHTIG ist aber auch die Materialstärke bei gleicher Bauform... Ggf. gibt es auch Webseiten zur Berechnung dieses Wertes, die hab ich aber noch nicht gefunden. Aber ein kleiner Lüfter hilft ggf. auch...

Einen aus meiner Sicht ebenfalls SEHR WICHTIGEN KENNWERT dürfte das auf dem Datenblatt des MosFet's dargestellte Diagramm "Safe-Operating-Area" darstellen - hier können wir abschätzen, ob unser MosFet bei den gewünschten Kennwerten dann auch sicher betrieben werden kann. Leider sind die Daten dort oft für einen Einschaltpuls bzw. eine Ein-/Aus-Schaltfrequenz von definierter Länge angegeben - nicht für Dauerbetrieb....

Aber alle diese Berechnungen sind ( für uns mangels technischem Detailwissen ) erst einmal theoretischer Natur, um eine praktische Überprüfung kommen wir letztendlich nicht herum...

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

Überlegungen zum Parallelbetrieb der MosFet's...

Tja, wenn unser MosFet für die gewünschte Leistung nicht ausreichend ist - oder um z.B. die Temperatur zu drücken - kommt "der gewiefte Bastler" schnell auf die Idee, mehrere MosFet's parallel zu schalten und somit die Last durch mehrere Kanäle gleichzeitig zu leiten.

Das ist aber möglicherweise ein "zweischneidiges Schwert"....., da auch MosFet's gleicher Bauart und aus der selben Charge trotzdem nicht identisch sein müssen, kann es dann dazu kommen das die Last nicht in gleicher anteiliger Grösse durch die beteiligten MosFet's geleitet wird.

Somit wird sich ggf. ein MosFet stärker erwärmen - der interne Widerstand steigt - und unser "Gesamtsystem läuft aus dem Ruder".....

Daher wird diese Lösung auch bei Allen bei meiner Recherche besuchten Webseiten NICHT EMPFOHLEN !!!

In meiner Lösung s.u. habe ich es trotzdem umgesetzt - ABER ich habe meine Schaltung so ausgelegt, das ein MosFet die Last allein hoffentlich sicher schalten kann UND ich habe die jeweils parallel geschalteten MosFet's auf einen gemeinsamen Kühlkörper gesetzt - damit sich die Temperaturen untereinander ausgleichen können.

AUFPASSEN !!! Die Rückseite des MosFet's und somit der Kühlkörper sind möglicherweise der PLUS-POL mit vollem "Saft" !!!

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

meine aktuelle Lösung...

Wie bereits erwähnt habe ich mir für die MosFet's-Typen IRFP260N entschieden und diese für jeden Kanal in einer parallelen Schaltung von 2 MosFet's auf einem gemeinsamen Kühlkörper angeordnet...diese Lösung ist aktuell für eine Solarplatte ausgelegt !

Ich führe den Plus-Pol (gelb-gruen) vom Paneel durch einen Strom-Messboard mit einem ACS712-20A (siehe auch mein Beitrag zum  ACS712-30A..) und dann direkt zum Speicher bzw. Inverter.

Auf der "Rück-Leitung" vom Speicher (blau) bzw. vom Inverter (braun) zum Paneel habe ich jeweils eine MosFet-Paarung zwischengeschaltet, wobei ich in meiner momentanen elektronischen Schaltungslösung (s.u.) jedes MosFet einzeln direkt ansprechen kann..

Ich schalte also die Masse !!

Als Test-Belastung habe ich vier "Birnen" (ja, ja..es gibt kein elektrisches Obst..)  aus dem KfZ-Bereich genutzt - jeweils 55 Watt bei 12 Volt = 4,5 Ampere Last.

Davon habe ich je zwei Lampen in Reihe geschalten ( d.h. 24 Volt und 4.5 Ampere ) und dann die Paare parallel (d.h. 24 Volt und ca. 9 Ampere ) als Verbraucher ... 

Somit kann ich diese 24 Volt und ca. 8-9 Ampere ( es ist real lt. Angabe meines Netzteils etwas weniger als vorher errechnet ) als Belastung für meine MosFet's nutzen.  

HINWEIS:  Temperaturen mit so einem günstigen Infrarot-Messgerät "von der Stange" auf den Aluminium-Schienen messen zu wollen ist keine gute Idee, es funktioniert irgendwie nicht - da kommt nur Blödsinn raus und man verbrennt sich dann gewaltig die Finger. Ich habe daher ein "Braten-Mess-Stab" mit reichlich Wärmeleitpaste auf dem Profil angeordnet.

Es ergibt sich....

• auch ein MosFet allein aktiviert brennt erst mal nicht durch (GUT) und erreicht ausgehend von Zimmertemperatur nach ca. 15 Minuten eine Temperatur auf dem Kühlkörper von ca. 70-80 Grad Celsius...
• aktiviere ich beide MosFet's auf dem Kühlprofil gleichzeitig, lande ich bei ca. 50-60 Grad Celsius...
• ein kleiner Ventilator drückt diese Temperatur dann zusätzlich problemlos weiter herunter...

Soweit...so gut....ABER....

24 Volt und 9 Ampere sind nur ca. 200 Watt - wir wollen später ja bis zu 405 Watt dauerhaft schalten...

Hier muss ich aber erst Mal auf bessere "Umweltbedingungen" warten - so grosse Energiequellen und Lasten stehen mir aktuell nicht zur Verfügung, die Sonne ist als kräftigere Energiequelle jetzt im Januar auch nicht wirklich hilfreich.

Und ich möchte es auch nicht unbedingt im "eigenen Heim" testen, wenn es "schiefgeht" - dann doch lieber auf freiem Gelände....

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

elektronische Schaltungen...

Ziel ist ja, diese Schaltung dann auch automatisiert bzw. mit dem Mobiltelefon umsetzen zu können...daher brauchen wir auch etwas "Low-Power-Elektronik"...

Als ansteuernden "Rechner" nutzen wir wieder ein ESP32-Dev-Board..., hier können wir dann über die Software und die GPIO's unsere MosFet's ansteuern und weitere Funktionen nutzen.

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

Ansteuerung der MosFet's

Ihr könnt es Euch auf " www.falstad.com/circuit/circuitjs.html " auch gern mal anschauen, anbei die Simulationsdatei... ( ist eine reine Textdatei ), ihr könnt sie mit "von lokaler Datei importieren" auf die Webseite hochladen...

Was sehen wir...

Mittig haben wir einen Opto-Koppler.., dieser entkoppelt den Stromkreis an unserem empfindlichen ESP32 vom Stromkreis der MosFet's ( z.B. um den ESP bei Kurzschluss auf der Lastseite zu schützen )

Auf der linken Seite haben wir also eine 3.3V-Quelle (den schaltbaren GPIO unseres ESP), einen Potentiometer (verstellbaren Widerstand), unseren Optokoppler mit der LED-Seite und einen weiteren Widerstand 100 Ohm. Den Potentiometer habe ich sicherheitshalber eingefügt, um mögliche Schwankungen aus der Stromversorgung des ESP ausgleichen zu können (wir haben später viele kleine Schaltungen, die der ESP versorgen muss), wenn Ihr mit dem 100 Ohm Widerstand "grössenmässig etwas spielt" seht Ihr, das die Spannung am Optokoppler ebenfalls angepasst werden kann. Somit können wir den Optokoppler ansteuern.

Auf der rechten Seite sehen wir eine variable Spannungs-/Stromquelle (das soll das Solarpaneel sein), einen "Motor" (als Last, das soll unser Speicher bzw. Inverter sein) und NACH DER LAST dann unseren MosFet.

Hinweis: Wird der MosFet nicht angesteuert, dann müssen wir den Steuerpol mit der Masse des MosFet's durch den 41 kOhm (kiloOhm) - Widerstand verbinden und somit auf einen definierten Nullpunkt "herunterziehen". Diesen Widerstand habe ich direkt an den Füssen des MosFet's angelötet (siehe vorhergehendes Photo).

Für die Ansteuerung brauchen wir ja eine Spannung zwischen 10-12 Volt entsprechend der MosFet-Spezifikationen, es ist also naheliegend, dieses Spannung direkt vom zu schaltenden Stromkreis "abzuzweigen".

Aber unser Stromkreis hat ja Spannungen von ca.  0-40 Volt (siehe Kennwerte der Solarpaneele), wir benötigen aber unsere Ansteuerspannung relativ konstant mit 10-12 Volt.

Geringere Spannungen berücksichtigen wir dadurch, das wir unseren ESP32 (und damit die Schalttätigkeiten) erst dann aktivieren, wenn im Gesamtsystem eine Mindestspannung von 10-12 Volt vorhanden ist = siehe nachfolgendes Thema "Deep-Sleep"...

Für höhere Spannungen nutzen wir eine Schutzschaltung mit einer Zener-Diode..., welche alle grösseren Spannungsanteile in Richtung Masse ableitet.  Unsere Zener-Diode hat eine maximal zulässige Leistung von 0.25 Watt, sprich 250 miliWatt. Den fliessenden Strom begrenzen wir daher mit den beiden 2 kiloOhm-Widerständen.

Hier habe ich mit Hilfe der vorgenannten Webseite etwas "gespielt" - wenn Ihr im Simulationsmodus mit dem Mauszeiger auf das Symbol der Zener-Diode geht, wird Euch die aktuelle Leistung angezeigt, welche entsprechend der Spannung durch die Zenerdiode fliesst.

Somit können wir mit Hilfe des Optokopplers den Gate-Pol unseres MosFet's ansteuern.

Dieser Steuerkreis ist jeweils für EINEN MosFet ausgelegt, die Spannungsstabilisierung mit der Zenerdiode selbst muss aber nur 1x für alle vier Steuerkreise zusammen ausgeführt werden ( der notwendige Steuer-Strom für das Gate des MosFet's ist minimal ).

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

DeepSleep-Funktion

Ich möchte die "DeepSleep"-Funktion unseres ESP32.. nutzen, um in den Nachtstunden unseren ESP32 auszuschalten und ihn ( und somit unsere Steuerungsschaltung ) erst bei mindestens 10 Volt Spannung vom Solarpaneel wieder zu aktivieren.

Dazu müssen wir aus der Spannung 0-40 Volt im Solarstromkreis eine Spannung zwischen 1.8 und max. 3.3 Volt als Eingangsspannung am ESP32 realisieren. Und natürlich wollen wir die beiden Stromkreise voneinander trennen - auch hier kommt ein Optokoppler zum Einsatz.

Was sehen wir...

Auf der linken Seite haben wir unsere Spannungsquelle 0-40 Volt, der Widerstand begrenzt die fliessenden Ströme. Durch die Zener-Diode Z10V fliesst der Strom desweiteren erst, wenn mind. 10 Volt erreicht sind... dann aber alle Spannung bis 40 Volt !  Durch eine 2. Zenerdiode Z2V leiten wir alle Spannunganteile grösser 2 Volt auf Masse ab - zum Optopkoppler kommen also - angepasst mit den beiden Widerständen max. 2 Volt.

Auf der rechten Seite nutzen wir den 3.3 Volt-Pol des ESP32 als Quelle und begrenzen den Strom wieder mit dem Widerstand. Solange der Optokoppler nicht durchschaltet, haben wir am Eingangs-GPIO auch keine Spannung anliegen, ansonsten ca. 3.3 Volt und damit mehr als die benötigten 1.8 Volt für den Zustand HIGH des Eingangs-Pins. 

Normalerweise müssen wir noch einen PullDown-Widerstand.. nutzen, um den Eingangs-Pin am ESP - wie schon mehrfach erwähnt - definiert auf Masse zu ziehen, ich hatte ihn in meiner Schaltung ( beim Löten) vergessen - bisher funktioniert sie trotzdem. Aber sicher ist sicher...ich werde es ggf. noch ergänzen.

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

Alternative zur DeepSleep-Funktion...

Auf der Suche nach einem kleinen Ansteuerungsmodul für den Kühllüfter habe ich bei einem bekannten OnLine-Händler mit "A..." einen DC/DC-Step-Down-Konverter mit Eingangsspannung 9-36 Volt und einer stabilisierten Ausgangsspannung von 5V und bis zu 5A Leistungsaufnahme gefunden.

Beim Test des Teils habe ich festgestellt, das es erst bei Anliegen der Mindestspannung von 9V auch eine Spannung von 5V auf der Ausgangsseite ausgibt, bei kleineren Eingangsspannungen ist die Ausgangsspannung 0V => hier hätten wir dann auch einen "Schalter", der unser System erst bei einer Mindestspannung startet.

Ich hatte zwischendurch die Idee, mittels dieses Teils auch die Stromversorgung des ESP32 direkt aus meinem Solarpaneel zu realisieren - allerdings "grätscht" mir da das Verhalten der Solarpaneele hinsichtlich Spannung und Strom "dazwischen".

Bei Sonneneinstrahlung steigt die Spannung ja recht schnell auf einen Wert >= 10 Volt an und dann weiter bis auf die Nennspannung von ca. 30 Volt.  Allerdings ist in diesem Zeitraum noch kaum Strom vorhanden => da unser ESP32 bei einer Startspannung von 10 Volt aber bereits ca. 2 A benötigt, können wir ihn leider wahrscheinlich nicht auf diese Weise mit Strom versorgen...

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

Stromstärke messen

Ich möchte eine automatische Umschaltung der Stromzufuhr vom Speicherinverter auf den netzgebundenen Deye-Inverter realisieren. Die Überlegung ist...

Wenn der Speicher voll ist, fliessen keinen massgeblichen Ströme mehr - dies kann ich mit dem ACS712-20A... ja messen. Normalerweise könnte ich den Ausgabepol des ACS712 direkt am ESP32 mit einem GPIO-Pin und dem internen Analog-Digital-Wandler auslesen.

Aber dann würde ich die Last-Seite elektrisch direkt mit der "Rechner"-Seite verbinden - das möchte ich aus mehrfach bereits genannten Gründen ja vermeiden. Also schalte ich einen Spannungs-Messboard INA219.. dazwischen und messe die vom ACS712-Board ausgegebene Spannung. 

Im Extremfall grillt es dann zuerst das INA-Board....

Das ACS712-Board gibt uns ja - wie im Beitrag dazu.... - bereits erläutert bei Stromstärke 0 Ampere einen Spannungswert aus, welcher der Hälfte der Versorgungsspannung entspricht - beim ESP32 wären das ja 3.3 Volt bzw. 5 Volt. (bzw. davon jeweils die Hälfte) .

Real kann der gemessene Wert dann etwas abweichen -  die Versorgungsspannung kann infolge der Versorgung mehrerer Teilkomponenten durch den ESP32 etwas variieren - wir müssen in unserer Programmierung später also eine Korrekturmöglichkeit einbauen.

Das INA-Board gibt uns das Ergebnis dann über die I2C-Schnittstelle... als digitalen Werte auf unseren ESP32.. und wir können es später in unserer Programmierung berücksichtigen.

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

PreLoad-Widerstände...

Nachdem wir nunmehr - aktuell mangels Testmöglichkeiten (ausreichend Sonne) noch theoretisch - zwischen Speicher und dem Deye-Inverter umschalten können, müssen wir uns mit einem weiteren möglichen Problem befassen.

Wenn wir bei "voller Sonneneinstrahlung" z.B. vom Speicher auf den Inverter umschalten, geben wir ja auch "volle Leistung" schlagartig auf die Elektronik des Inverters. 

Bei WEB-Recherchen wurde ich auf den Umstand aufmerksam gemacht, das in den MPPT-Schaltungen der Inverter ( unser Speicher-Inverter hat ebenfalls derartige Elektronik ) grössere Kondensatoren verbaut sind, diese würden beim Einschalten schlagartig auch grössere Ströme ziehen, bis sie aufgeladen sind...

Bei meinem Deye-Inverter kommt noch dazu, das er sich ohne ( bzw. bei zu geringer ) anliegender Spannung/Strom aus den Solarpaneelen ausschaltet und dann erst neu starten muss ( dies dauert inkl. WLAN-Verbindung etc. einige Zeit ).

Um dies etwas zu abzumindern, können wir sogenannte PreLoad-Widerstände in unsere Schaltung einbauen.  Dann fliesst unabhängig ( parallel ) von unserer Umschalt-Elektronik permanent bereits ein gewisser Strom zu den Invertern ( sobald die Sonne aufgeht ). Somit sind die Kondensatoren dann auch bereits aufgeladen ( bzw. zumindest anteilig vorgeladen), wenn wir nachher unter Last umschalten wollen.

Ich habe mich aktuell für Lastwiderstände mit 100 Ohm und einer zulässigen Last von 100 Watt entschieden - diese gibt es bereits für 5-6 € bei den entsprechenden Bezugsquellen im WEB...

Bei max. 30 Volt und 100 Ohm fliesst dann ein permanenter Strom von 0.3 Ampere zu JEDEM Inverter , sprich ca. 9-10 Watt....

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

Software...

Aktuell gibt es hier nur eine kleine VORAB-Steuerung, primär um die MosFet'S ( 4 Stk ) über eine kleine WLAN-Webseite einzeln ansteuern zu können. Ausserdem wird der aktuell fliessende Strom gemessen.

Ich habe hoffentlich ausreichend kommentiert und meine Gedankengänge erläutert.

Eine ganz neue - noch im Test befindliche - Ansteuerung der Webseite findet Ihr unter der Ansteuerung S1a, hier ist die Antwort nicht mehr eine neue Webseite ( mit der Notwendigkeit eines seperaten "Zurück-Befehls", das Programm springt direkt zur aufrufenden Webseite zurück...

Dies ist aber nicht nicht ganz ausgereift, da ich aus diversen Gründen das Projekt erst mal unterbrechen musste....

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

/*
* ESP 32 dev module 115200  80MHz default 4mb with spiffs
* 
* OTA als Solar-ESP !!!!   ACHTUNG:  der ESP mit EINEM ROTEN PUNKT.....
* 
* Über WEBSERVER schalten wir PIN 14, 27, 26, 25 (4 versionen)für die MosFet's...
* 
* DeepSleep - hier auf Pin 13 des ESP abgefragt...
* 
* Spannung aus Stromfluss zum Speicher mit ACS712 und INA219 ermittelt, Versorgung ACS mit
* ca. 5V vom ESP d.h. 2.5V ist NULL - die Auflösung beim 20A-ACS ist somit 2.5V/20A = 0.125V/A
* 
* Der angebliche NULL-Wert des ACS712 sind 2.50 Volt ( 5 Volt VCC /2)  bei 0 Ampere
* Stromfluss - für jedes Ampere erhöht/verringert sich die Voltzahl lt. Angabe Verkäufer
* um 100mV = 0.100 Volt....( beim AC712-30A waren es 0.066mV/A )
* 
* Da der INA219 bis zu 26V ( bzw. 16V aktuell eingestellt) messen kann, muss hier kein Spannungsteiler 
* etc. dazwischengeschaltet werden....20A * 0.100 V/A = 2 V bei 20A....
* 
* Als Verbraucher wird ein Widerstand >= 10kOhm eingesetzt, um den fliessenden Strom zu begrenzen, da
* die Messeinheit ja vom ESP versorgt wird.  Der INa soll 0.7mA und der ACS712 ca 10 mA verbrauchen.
* 
* Grundlegende Kommunikation mit einem Browser , der die IP-Adresse DIESES ESP - hier 192.168.172.xx 
* in meinem WLAN aufruft..
* 
* grundlegender Quelltext anteilig von Wolles Elektronik-Kiste, RandomNerds, Beispielen etc....
* 
*/

// für das Updaten über WLAN

#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>



// für den DeepSleep
#include "driver/rtc_io.h"




// für den Webserver 

#include <WebServer.h> 
#define PORT 80

const char* ssid = "*********";    // ROUTERNAME...
const char* pass = "*********";    // ROUTERPASSWORT....

WebServer server(PORT); 

// dies sind die Befehls-Links zu den Prozeduren und
// Ausgabe-Webseiten - die Seiten können auch mit z.B.
// ".ip-adresse./schalten1" direkt aufgerufen werden

//  Sendevariable  Auswahltext...
//  dargestellte Reihenfolge siehe unten....
String link_1= "<a href=\"/S1a_an\">S1a Einschalten..</a>";
String link_2= "<a href=\"/S1a_aus\">S1a Ausschalten..</a>";
String link_3= "<a href=\"/S1b_an\">S1b Einschalten..</a>";
String link_4= "<a href=\"/S1b_aus\">S1b Ausschalten..</a>";

String link_5= "<a href=\"/S2a_an\">S2a Einschalten..</a>";
String link_6= "<a href=\"/S2a_aus\">S2a Ausschalten..</a>";
String link_7= "<a href=\"/S2b_an\">S2b Einschalten..</a>";
String link_8= "<a href=\"/S2b_aus\">S2b Ausschalten..</a>";

String link_9= "<a href=\"/Messen\">INA Messen..</a>";

// die aktuelle locale IP - hier erst mal leer
String my_local_IP = "";


// für das Messen mit dem ina219  ( Adafruit-Version I2c  Pin 21 und 23)

#include <Wire.h>
#include <Adafruit_INA219.h>

Adafruit_INA219 ina219;

// als globale Variablen....
float shuntvoltage = 0.0000;
float busvoltage = 0.0000;
float current_mA = 0.0000;
float loadvoltage = 0.0000;          // in V
float power_mW = 0.0000;
float busvoltage_start = 0.0000;     // in V - eigene Variable für Kalibrierung




// für das Schalten der MosFet's PIN 14, 27, 26, 25

const int MF_S1a = 14;   // Speicherlinie
const int MF_S1b = 27;   // Speichelinie (Lastreserve)
const int MF_S2a = 26;   // Inverterlinie
const int MF_S2b = 25;   // Inverterlinie (Lastreserve)







//***************************************************************


// bei Programmstart

void setup(){
  
  Serial.begin(115200); 
  Serial.print("Connecting to: ");
  Serial.println(ssid);
 
  
  // warten bis WLAN verbunden ist... 
  WiFi.begin(ssid, pass);
  while(WiFi.status() != WL_CONNECTED){
    delay(500); 
    Serial.print(".");
    }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.print("IP-Address of ESP32 module: ");
  Serial.println(WiFi.localIP());
  Serial.print("Feldstärke: ");
  Serial.println(WiFi.RSSI());
  long rssi = WiFi.RSSI();
  if (rssi < -30){
     Serial.println("Gut");
     }


  // *******  für das Updaten ******* 
  
  ArduinoOTA.setHostname("Solar_ESP");

  ArduinoOTA
    .onStart([]() {
      String type;
      if (ArduinoOTA.getCommand() == U_FLASH)
        type = "sketch";
      else // U_SPIFFS
        type = "filesystem";

      // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
      Serial.println("Start updating " + type);
    })
    .onEnd([]() {
      Serial.println("\nEnd");
    })
    .onProgress([](unsigned int progress, unsigned int total) {
      Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
    })
    .onError([](ota_error_t error) {
      Serial.printf("Error[%u]: ", error);
      if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
      else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
      else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
      else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
      else if (error == OTA_END_ERROR) Serial.println("End Failed");
    });

  ArduinoOTA.begin();





// für den Webserver

  
  // handleRoot ist die Startseite bei Aufruf mit der IP-Adresse
  // die anderen sind die Subseiten s.o.
  server.on("/",handleRoot);
  server.on("/S1a_an", S1a_ON); // sendevar => procedur
  server.on("/S1a_aus", S1a_OFF); // sendevar => procedur
  server.on("/S1b_an", S1b_ON); // sendevar => procedur
  server.on("/S1b_aus", S1b_OFF); // sendevar => procedur
  server.on("/S2a_an", S2a_ON); // sendevar => procedur
  server.on("/S2a_aus", S2a_OFF); // sendevar => procedur
  server.on("/S2b_an", S2b_ON); // sendevar => procedur
  server.on("/S2b_aus", S2b_OFF); // sendevar => procedur
  server.on("/Messen", INA_Werte); // sendevar => procedur
  server.begin();

  // die aktuelle Startseite als IP zwischenspeichern  ( ist ein uint-array[4] )
  my_local_IP = WiFi.localIP().toString().c_str();
  // alternativ ggf......
  // my_local_IP = String(WiFi.localIP()[0]) + '.' + String(WiFi.localIP()[1]) + '.' + String(WiFi.localIP()[2]) + '.' + String(WiFi.localIP()[3]);
  


// für das Messen mit dem ina219

  // Initialize the INA219.
  // By default the initialization will use the largest range (32V, 2A).  However
  // you can call a setCalibration function to change this range (see comments).
  if (! ina219.begin()) {
    Serial.println("Failed to find INA219 chip");
    while (1) { delay(10); }
  }
  // To use a slightly lower 32V, 1A range (higher precision on amps):
  //ina219.setCalibration_32V_1A();
  
  // Or to use a lower 16V, 400mA range (higher precision on volts and amps):
  ina219.setCalibration_16V_400mA();  // AKTIV !!!



  

// für Schaltsteuerung der MosFet's PIN 14, 27, 26, 25
  
  pinMode(MF_S1a, OUTPUT);      // PIN 14
  digitalWrite(MF_S1a, LOW); 
  pinMode(MF_S2a, OUTPUT);      // PIN 27
  digitalWrite(MF_S2a, LOW); 
  
  pinMode(MF_S2a, OUTPUT);      // PIN 26
  digitalWrite(MF_S2a, LOW); 
  pinMode(MF_S2b, OUTPUT);      // PIN 25
  digitalWrite(MF_S2b, LOW); 



// für DeepSleep...

  pinMode(13, INPUT);       // PIN 13 als SleepPin



// Erstkalibrierung für das Messen mit ina219
// relevant ist die busvoltage, wenn KEIN STROM fliesst, sie weicht infolge
// Versorgung durch den ESP leicht von den idealen 2.5V (50% aus 5V) ab...

      busvoltage_start = 0.0000;

      // für die Mittelwertbildung
      for (int i=0;i<50;i++){

        busvoltage_start += ina219.getBusVoltage_V();

        delay(10);
        }

    // Mittelwert bilden
    busvoltage_start = (busvoltage_start/50.0000);

  
  
}  // ende Setup





//***************************************************************


void loop(){

  // notwendigen WLAN-Neustart prüfen

  int wifi_retry = 0;
  while( (WiFi.status() != WL_CONNECTED) && ( wifi_retry < 5) ){
      wifi_retry++;
      WiFi.disconnect();
      WiFi.mode(WIFI_OFF);
      WiFi.mode(WIFI_STA);
      WiFi.begin(ssid, pass);
      delay(100);
  }
  if(wifi_retry >=5){
    ESP.restart();
  }


// für das Messen mit ina219

      shuntvoltage = 0.0000;
      busvoltage = 0.0000; 
      current_mA = 0.0000;
      loadvoltage = 0.0000;
      power_mW = 0.0000;
      
      // für die Mittelwertbildung
      for (int i=0;i<50;i++){
        shuntvoltage += ina219.getShuntVoltage_mV();
        busvoltage += ina219.getBusVoltage_V();
        current_mA += ina219.getCurrent_mA();
        power_mW += ina219.getPower_mW();
        delay(10);
        }

    // Mittelwert bilden
    shuntvoltage = (shuntvoltage/50.0000); // eigentlich int 50 aber rechnen mit float 50.0000
    busvoltage = (busvoltage/50.0000);     // sonst gibt es ggf. Probleme bei den Nachkomma-Werten
    current_mA = (current_mA/50.0000);
    power_mW = (power_mW/50.0000);

    // busvoltage gegenüber busvoltage_start prüfen, ob Differenz eingehalten
    // gewählt zulässige Abweichung < 5%

    



    // Umrechnen....
    loadvoltage = busvoltage + (shuntvoltage / 1000.0000);  // in V


        
// für das Updaten....

   if ( (WiFi.status() == WL_CONNECTED) ){ // Absturz bei fehlendem WLAN vermeiden
        ArduinoOTA.handle();
        }
    



// für die Webseite
   

  // wartet bis zu einem Aufruf vom externen Browser bzw. Clienten
  // wartet er oder fragte er jedesmal ???  => er fragt bei jedem Durchlauf
  // und arbeitet dann ungerührt weiter - auch wenn er mal was gesendet hat
  // und im gegenerischen Browser eine Subseite aktuell ist....
  
  if ( (WiFi.status() == WL_CONNECTED) ) { // Absturz bei fehlendem WLAN vermeiden
       server.handleClient();
       }

/*
// für DeepSleep


    if (digitalRead(13) == LOW) {   // wenn der Pin13 LOW ist => DeepSleep...
      delay(5000);  // warten falls temporäre nur Unterbrechung der Spannungsversorgung
      
      if (digitalRead(13) == LOW) {  // nochmals prüfen..
      
        // jetzt die Definition für den Tiefschlaf...
        esp_sleep_enable_ext0_wakeup(GPIO_NUM_13, 1);  // wache auf, wenn der PIN 13 vom PIR Signal bekommt...
        esp_deep_sleep_start();                        // und der Schlaf-Befehl....
        Serial.println("Wird nicht mehr ausgegeben");  // da er ja schläft...
        }
      }

*/

} // ende void loop




//***************************************************************



// die Subproceduren

void handleRoot() {
  // die Startseite....
  String message="<h1>Auswahlmenue</h1>";
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += link_1;
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += link_2;
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += link_3;
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += link_4;
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += link_5;
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += link_6;
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += link_7;
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += link_8;
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += "</BR></BR>";
  message += link_9;
  server.send(200, "text/html", message); // 200 bedeutet für den aufrufenden Browser alles OK...
}


void S1a_ON(){  // Einfach AN  - springt automatisch zurück auf Startseite...
  // ein Schalte-Befehl.....
  pinMode(MF_S1a, OUTPUT);      // PIN 14
  digitalWrite(MF_S1a, HIGH);    // turn the LED on (HIGH is the voltage level)
/*
  String goToRoot = "<head><meta http-equiv=\"refresh\" content=\"0; URL=//192.168.178.56\"></head>";
         //goToRoot += my_local_IP;  // Variable ist mit "...." -zeichen als Text
         // goToRoot += "\"></head>";
  server.send(200, "text/html",goToRoot); // 200 bedeutet für den aufrufenden Browser alles OK...
*/

  String goToRoot = "<head><meta http-equiv=\"refresh\" content=\"0; URL=//";
         goToRoot += my_local_IP;  // aktuelle IP-Variable als String-Text
         goToRoot += "\"></head>";
  server.send(200, "text/html",goToRoot); // 200 bedeutet für den aufrufenden Browser alles OK...
  
  // alt...  
  // server.send(200, "text/html", " S1a - Eingeschalten.. </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
}

void S1a_OFF(){  // Einfach AN
  // ein Schalte-Befehl.....
  pinMode(MF_S1a, OUTPUT);      // PIN 14
  digitalWrite(MF_S1a, LOW);    // turn the LED off (LOW is the voltage level)
  server.send(200, "text/html", " S1a - Ausgeschalten.. </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
}


void S1b_ON(){  // Einfach AN
  // ein Schalte-Befehl.....
  pinMode(MF_S1b, OUTPUT);      // PIN 27
  digitalWrite(MF_S1b, HIGH);    // turn the LED on (HIGH is the voltage level)
  server.send(200, "text/html", " S1b - Eingeschalten.. </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
}

void S1b_OFF(){  // Einfach AN
  // ein Schalte-Befehl.....
  pinMode(MF_S1b, OUTPUT);      // PIN 27
  digitalWrite(MF_S1b, LOW);    // turn the LED off (LOW is the voltage level)
  server.send(200, "text/html", " S1b - Ausgeschalten.. </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
}


void S2a_ON(){  // Einfach AN
  // ein Schalte-Befehl.....
  pinMode(MF_S2a, OUTPUT);      // PIN 26
  digitalWrite(MF_S2a, HIGH);    // turn the LED on (HIGH is the voltage level)
  server.send(200, "text/html", " S2a - Eingeschalten.. </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
}

void S2a_OFF(){  // Einfach AN
  // ein Schalte-Befehl.....
  pinMode(MF_S2a, OUTPUT);      // PIN 26
  digitalWrite(MF_S2a, LOW);    // turn the LED off (LOW is the voltage level)
  server.send(200, "text/html", " S2a - Ausgeschalten.. </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
}


void S2b_ON(){  // Einfach AN
  // ein Schalte-Befehl.....
  pinMode(MF_S2b, OUTPUT);      // PIN 25
  digitalWrite(MF_S2b, HIGH);    // turn the LED on (HIGH is the voltage level)
  server.send(200, "text/html", " S2b - Eingeschalten.. </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
}

void S2b_OFF(){  // Einfach AN
  // ein Schalte-Befehl.....
  pinMode(MF_S2b, OUTPUT);      // PIN 25
  digitalWrite(MF_S2b, LOW);    // turn the LED off (LOW is the voltage level)
  server.send(200, "text/html", " S2b - Ausgeschalten.. </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
}



void INA_Werte(){  // Messergebniss weitergeben
  String message = "</BR></BR> Loadvoltage [V]:  ";
         message += String(loadvoltage, 3); // float to String, three decimal places
         message += "</BR></BR> Busvoltage [V]:  ";
         message += String(busvoltage, 3); // float to String, three decimal places
         message += "</BR></BR> Shuntvoltage [mV]:  ";
         message += String(shuntvoltage, 3); // float to String, three decimal places
         server.send(200, "text/html", message); // 200 bedeutet für den aufrufenden Browser alles OK...
         }






/*  reserve-proceduren...




void schalte_2(){   // Einfach AUS
  // ein Schalte-Befehl.....
  pinMode(19, OUTPUT);      // PIN 19 als PWM und ON/OFF
  digitalWrite(19, LOW);    // turn the LED on (HIGH is the voltage level)
  server.send(200, "text/html", " Ausgeschalten... </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
}


void schalte_3(){   // PWM hochfahren
  // ein Schalte-Befehl.....
  digitalWrite(19, LOW); 
  for (int i = 0; i <= 255 ; i=i+5) {
      analogWrite(19,i);
      delay(100);
      Serial.println(i);
      }
      digitalWrite(19, HIGH);  
      server.send(200, "text/html", " Hochgefahren.... </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
      }


void schalte_4(){   // PWM runterfahren
  // ein Schalte-Befehl.....
  digitalWrite(19, HIGH);
  for (int i = 255; i >= 0 ; i=i-5) {
      analogWrite(19,i);
      delay(100);
      Serial.println(i);
      }
      digitalWrite(19, LOW);  
      server.send(200, "text/html", " Runtergefahren </BR></BR> "); // 200 bedeutet für den aufrufenden Browser alles OK...
      }

*/      


      

Probiert es doch einfach aus...

 zurück zur Startseite