Es könnte ja auch mal das WLAN / der Router kaputt gehen. Also die Geräte. Okay, so richtig macht das Leben dann natürlich auch kein Sinn mehr 
Aber ein Plan B zu haben schadet grundsätzlich ja mal nicht.
Grundsätzlich stimmt das.
Allerdings bei WLAN oder Router muss das repariert erst werden. Ohne das geht eh nix.
Hey Leute,
ich hoffe, dass dies hier noch gelesen wird, da der Beitrag von mir ja schon ein paar Tage alt war. Ich habe mich vom Plan einer "Masterplatine" temporär gelöste, da sich etwas das drum und dran leicht verändert hat. Ich habe nun eine neue Platine entworfen, welche über ein PCF8574 mir 4 Schaltzustände "überwacht". Theoretisch und auf dem Breadboard lief auch alles. Ich hoffe mir ist beim übertragen in KiCAT kein großer Bock passiert. Auf jeden Fall gibt es nun 2 Probleme.
- Das Board startet ständig neu, wen ich es an die Spannungsquelle gebe und es kommt somit zu keinem Laufbetrieb.
- Ich kann per Serielle Schnittstelle kein Code übertragen. Ich wollte es testen, was passiert, wenn ich den Code nochmal übertrage.
- OTA wird garnicht erst ermöglicht.
Hier erstmal der Schaltplan:
Und hier der Code:
// Benötige Lib's
// **************
#include <ESP8266WiFi.h>
#include <ArduinoOTA.h>
#include <PubSubClient.h>
#include <time.h>
#include "PCF8574.h"
WiFiClient espClient;
PubSubClient client(espClient);
// Variablen und Konstanten
// ************************
const char* ssid = "SSID";
const char* password = "WLAN Passwort";
IPAddress staticIP(192, 168, 178, 204);
IPAddress gateway(192, 168, 178, 1);
IPAddress subnet(255, 255, 255, 0);
PCF8574 m1(0x20);
const char* otaHostname = "OTA-Name"; // OTA Hostname
const char* otaPassword = "OTA-Passwort"; // OTA Zugangscode
char* clientId = "ESP-Kellerlicht";
const char* mqtt_server = "192.168.178.152";
const int mqtt_port = 8883;
const char* mqtt_user = "mqtt User";
const char* mqtt_password = "mqtt Passwort";
char* msg1;
char* msg2;
char* msg3;
char* msg4;
// Setup Teil
//***********
void setup() {
Serial.begin(115200);
m1.begin();
m1.pinMode(P0,OUTPUT);
m1.pinMode(P1,OUTPUT);
m1.pinMode(P2,OUTPUT);
m1.pinMode(P4,INPUT);
m1.pinMode(P5,INPUT);
m1.pinMode(P6,INPUT);
m1.pinMode(P7,INPUT);
setup_wifi();
ota_setup();
delay(500);
connectToMQTT();
}
// Loop Teil
// *********
void loop() {
ArduinoOTA.handle();
snprintf (msg1, 1, " %ld", digitalRead(m1.digitalRead(P4)));
client.publish("ESP_Kellerlicht/Keller", msg1);
snprintf (msg2, 1, " %ld", digitalRead(m1.digitalRead(P5)));
client.publish("ESP_Kellerlicht/Schleifplatz", msg2);
snprintf (msg3, 1, " %ld", digitalRead(m1.digitalRead(P6)));
client.publish("ESP_Kellerlicht/NC1", msg3);
snprintf (msg4, 1, " %ld", digitalRead(m1.digitalRead(P7)));
client.publish("ESP_Kellerlicht/NC2", msg4);
}
void connectToMQTT() {
client.setServer(mqtt_server, mqtt_port);//MQTT Server, - Port
if (client.connect(clientId , mqtt_user, mqtt_password)) {
Serial.println("connected");
m1.digitalWrite(P1,LOW);
}
else {
m1.digitalWrite(P0,LOW);
m1.digitalWrite(P1,HIGH);
}
}
void setup_wifi() {
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
WiFi.config(staticIP, gateway, subnet);
while (WiFi.status() != WL_CONNECTED) {
delay(100);
m1.digitalWrite(P2,HIGH);
m1.digitalWrite(P0,LOW);
}
m1.digitalWrite(P2,LOW);
m1.digitalWrite(P0,HIGH);
Serial.println(WiFi.localIP());
}
// OTA Funktion
// ************
void ota_setup() {
ArduinoOTA.setHostname(otaHostname);
ArduinoOTA.setPassword(otaPassword);
ArduinoOTA.begin();
}
Über den Seriellen Monitor bekomme ich folgende Ausgabe:
--------------- CUT HERE FOR EXCEPTION DECODER ---------------
ets Jan 8 2013,rst cause:2, boot mode:(3,2)
load 0x4010f000, len 3460, room 16
tail 4
chksum 0xcc
load 0x3fff20b8, len 40, room 4
tail 4
chksum 0xc9
csum 0xc9
v0004fab0
~ld
192.168.178.204
connected
--------------- CUT HERE FOR EXCEPTION DECODER ---------------
Exception (29):
epc1=0x4021182d epc2=0x00000000 epc3=0x00000000 excvaddr=0x00000000 depc=0x00000000
>>>stack>>>
ctx: cont
sp: 3ffffd40 end: 3fffffc0 offset: 0190
3ffffed0: 3ffee6e0 3ffe8368 00000001 4021181d
3ffffee0: 00000000 00000000 00000000 ffff0208
3ffffef0: 00000000 00000000 00000001 00000001
3fffff00: 60000314 00000001 3ffeebd0 4020bdf9
3fffff10: 00000000 3ffee8ea 3ffeebd0 4020c040
3fffff20: 00000000 4bc6a7f0 1df3b645 001406f2
3fffff30: 00000000 00000000 4bc6a7f0 00000000
3fffff40: 00000004 3ffee6e0 3fffff70 3fffff60
3fffff50: 0000000c 3ffee96c 3ffee7b4 40204108
3fffff60: 3fffdad0 00000000 00000000 00000001
3fffff70: 00000000 00000000 00000000 40203d2a
3fffff80: 3ffee6e0 3ffe87fc 00000000 40201088
3fffff90: 3fffdad0 00000000 3ffee6e0 3ffeeb84
3fffffa0: 3fffdad0 00000000 3ffeeb70 4020b678
3fffffb0: feefeffe feefeffe 3ffe8600 4010132d
<<<stack<<<
--------------- CUT HERE FOR EXCEPTION DECODER ---------------
Vielleicht kann mir da jemand helfen. Irgendwie bin ich etwas "verwirrt" und etwas Ratlos.
Zur Erklärung:
- J2 Ist die Brücke für das Automatische Aufwachen wenn ich mal Deepsleep implementieren sollte.
- J3 Ist die Brücke zur "Überprüfung" ob ich den Deepsleep an oder ausgeschalten habe. Also Abfrage in der Software ob er in Deepsleep gehen soll
- J10 Ist der Jumper um den "Programmiermodus an der Seriellen Schnittstelle" zu aktivieren. Zumindest war das der Plan
- J5 - J8 sind die zu überwachenden Eingänge
- J1 ist die Klemme für die 230V Eingangsspannung des Mininetzteil Modul Hi-Link.
Hier noch Kurz Bilder der Platine im Layout von oben:
Und von Unten:
Wie zu erkennen ist, habe ich bei der Antenne und beim 230V Teil eine möglichst große Speerfläche eingefügt.
Ich hoffe man kann mir helfen und die Platine ist nicht gleich totaler Müll 
Michael
PS: Ich muss mich korrigieren, es liegt wohl am Code. Habe es gerade nochmal auf einem anderen ESP getestet und die gleiche Fehlerausgabe bekommen. Nun muss ich also in erster Linie dazu kommen irgendwie den eingelöteten ESP zu Programmieren. ohne diesen hoffentlich auslöten zu müssen.
Einen Bock habe ich gefunden:
Falsch:
snprintf (msg1, 1, " %ld", digitalRead(m1.digitalRead(P4)));
client.publish("ESP_Kellerlicht/Keller", msg1);
Richtig:
snprintf (msg1, 1, " %ld", m1.digitalRead(P4));
client.publish("ESP_Kellerlicht/Keller", msg1);
Also das natürlich mal 4, nur trotzdem keine Besserung.
Das ist manchmal das Problem wenn man dann aus eigenen und verschiedenen was zusammen sammelt und irgendwo versteckt doch den Bock rein setzt.
Schau Dir mal die Beschreibung von snprintf an.
msg1 ist außerdem ein char* und kein char-Array. Du hast also keinen Speicherplartz für Deinen Text.
digitalRead bringt nur 0 oder 1. Was willst Du da mit long?
Gruß Tommy
Wenn Du den Exception decoder nicht nutzen willst, dann kannst Du das erstmal versuchen einzukreisen.
Du hast zwar ein Serial.begin drin, nutzt es aber nicht....
Ginge z.B. so:
void setup() {
Serial.begin(115200);
Serial.println(F("Start..."));
m1.begin();
m1.pinMode(P0,OUTPUT);
m1.pinMode(P1,OUTPUT);
m1.pinMode(P2,OUTPUT);
m1.pinMode(P4,INPUT);
m1.pinMode(P5,INPUT);
m1.pinMode(P6,INPUT);
m1.pinMode(P7,INPUT);
Serial.println(F("Starte Wifi"));
setup_wifi();
Serial.println(F("Starte OTA-Setup"));
ota_setup();
delay(500);
Serial.println(F("Starte Connect"));
connectToMQTT();
Serial.println(F("Setup Ende"));
}Und das dann jeweils weiter einkreisen im loop...
Ich habe nochmal angefangen bei Adam und Eva, nun habe ich was halbwegs hin bekommen, aber er überträgt nicht die Daten vernünftig jedes mal, sondern verbindet sich ständig aufs neue immer wieder. Habe ich da irgendwo ein Denkfehler noch drin?
Hier der Überarbeitete Code, der beim ersten Kontakt die richtigen Werte übermittelt danach aber nur Blödsinn:
#include <ESP8266WiFi.h>
#include <ArduinoOTA.h>
#include "PCF8574.h"
#include <PubSubClient.h>
//#include <time.h>
WiFiClient espClient;
PubSubClient client(espClient);
const char* ssid = "SSID";
const char* password = "WLAN Passwort";
IPAddress ip(192,168,178,200); // 192.168.178.xxx = freie IP Adresse, ggf. müsst ihr auch die anderen Zahlen anpassen; schaut am besten in euren Router
IPAddress gateway(192,168,178,1);
IPAddress subnet(255,255,255,0);
PCF8574 m1(0x20);
const char* otaHostname = "OTA Name"; // OTA Hostname
const char* otaPassword = "OTA Passwort"; // OTA Zugangscode
char* clientId = "clientABC";
const char* mqtt_server = "192.168.178.43";
const int mqtt_port = 1883;
char* msg1;
char* msg2;
char* msg3;
char* msg4;
void setup() {
Serial.begin(9600);
WiFi.begin(ssid, password);
WiFi.config(ip, gateway, subnet);
ArduinoOTA.setHostname(otaHostname);
ArduinoOTA.setPassword(otaPassword);
ArduinoOTA.begin();
connectToMQTT();
m1.begin();
m1.pinMode(P0,OUTPUT);
m1.pinMode(P4,INPUT);
m1.pinMode(P5,INPUT);
m1.pinMode(P6,INPUT);
m1.pinMode(P7,INPUT);
//pinMode(D8, INPUT);
//pinMode(D1, OUTPUT);
m1.digitalWrite(P0, LOW);
delay(1000);
}
void loop() {
ArduinoOTA.handle();
Serial.println("Test");
Serial.println(m1.digitalRead(P4));
Serial.println(m1.digitalRead(P5));
Serial.println(m1.digitalRead(P6));
Serial.println(m1.digitalRead(P7));
if (WiFi.status() != WL_CONNECTED) {
m1.digitalWrite(P0, HIGH);
}
else {
m1.digitalWrite(P0, LOW);
}
//Serial.println(digitalRead(D8));
//digitalWrite(D1, digitalRead(D8));
connectToMQTT();
if(!m1.digitalRead(P4)) {
msg1 = "ON";
}
else {
msg1 = "OFF";
}
client.publish("ESP_Kellerlicht2/Keller", msg1);
if(!m1.digitalRead(P5)) {
msg2 = "ON";
}
else {
msg2 = "OFF";
}
client.publish("ESP_Kellerlicht2/Schleifplatz", msg2);
if(!m1.digitalRead(P6)) {
msg3 = "ON";
}
else {
msg3 = "OFF";
}
client.publish("ESP_Kellerlicht2/NC1", msg3);
if(!m1.digitalRead(P7)) {
msg4 = "ON";
}
else {
msg4 = "OFF";
}
client.publish("ESP_Kellerlicht2/NC2", msg4);
delay(2000);
}
void connectToMQTT() {
client.setServer(mqtt_server, mqtt_port);//MQTT Server, - Port
if (client.connect(clientId)) {
Serial.println("connected");
}
}
Ich habe für die Nachrichten einfach eine Abfrage gemacht und die übermittelt dann direkt ON oder OFF an den Broker. Zumindest war das der Plan gewesen. Ich bin auf mein Testborker ausgewichen, daher ohne Passwort und User für MQTT.
Da war ich parallel etwas zu schnell. Hatte was neues zusammen gebaut
Nur sobald Code läuft, kommt das nächste Problem, wie bekomme ich den Code auf das Board 
Über die seriellen Pins und einer korrekten Beschaltung des Reset und Programm Pins.
Alternativ geht auch vor dem Löten ein externer Programmer
Hm.
Erstmal hast Du eine andere Baustelle.
Dein delay() muss weg.
Und kann es sein, das Du hier:
if (!m1.digitalRead(P4))
{
msg1 = "ON";falsch liegst?
Du hast den PIN als INPUT deklariert und ziehst ihn mit einem PULLDOWN auf GND.
Für mich wäre das aus der Logik her der Aus-Zustand.
Wäre meins - nicht getestet nur umgeschrieben:
#include <ESP8266WiFi.h>
#include <ArduinoOTA.h>
#include "PCF8574.h"
#include <PubSubClient.h>
//#include <time.h>
WiFiClient espClient;
PubSubClient client(espClient);
const char *ssid = "SSID";
const char *password = "WLAN Passwort";
IPAddress ip(192, 168, 178, 200); // 192.168.178.xxx = freie IP Adresse, ggf. müsst ihr auch die anderen Zahlen anpassen; schaut am besten in euren Router
IPAddress gateway(192, 168, 178, 1);
IPAddress subnet(255, 255, 255, 0);
PCF8574 m1(0x20);
const char *otaHostname = "OTA Name"; // OTA Hostname
const char *otaPassword = "OTA Passwort"; // OTA Zugangscode
char *clientId = "clientABC";
const char *mqtt_server = "192.168.178.43";
const int mqtt_port = 1883;
char *msg1;
char *msg2;
char *msg3;
char *msg4;
const unsigned long interval = 2000;
unsigned long lastmillis = 0;
void setup()
{
Serial.begin(9600);
WiFi.begin(ssid, password);
WiFi.config(ip, gateway, subnet);
ArduinoOTA.setHostname(otaHostname);
ArduinoOTA.setPassword(otaPassword);
ArduinoOTA.begin();
connectToMQTT();
m1.begin();
m1.pinMode(P0, OUTPUT);
m1.pinMode(P4, INPUT);
m1.pinMode(P5, INPUT);
m1.pinMode(P6, INPUT);
m1.pinMode(P7, INPUT);
//pinMode(D8, INPUT);
//pinMode(D1, OUTPUT);
m1.digitalWrite(P0, LOW);
delay(1000);
}
void loop()
{
ArduinoOTA.handle();
if (millis() - lastmillis >= interval)
{
if (WiFi.status() != WL_CONNECTED)
{
m1.digitalWrite(P0, HIGH);
}
else
{
m1.digitalWrite(P0, LOW);
lastmillis = millis();
//Serial.println(digitalRead(D8));
//digitalWrite(D1, digitalRead(D8));
connectToMQTT();
if (!m1.digitalRead(P4))
{
msg1 = "ON";
}
else
{
msg1 = "OFF";
}
client.publish("ESP_Kellerlicht2/Keller", msg1);
if (!m1.digitalRead(P5))
{
msg2 = "ON";
}
else
{
msg2 = "OFF";
}
client.publish("ESP_Kellerlicht2/Schleifplatz", msg2);
if (!m1.digitalRead(P6))
{
msg3 = "ON";
}
else
{
msg3 = "OFF";
}
client.publish("ESP_Kellerlicht2/NC1", msg3);
if (!m1.digitalRead(P7))
{
msg4 = "ON";
}
else
{
msg4 = "OFF";
}
client.publish("ESP_Kellerlicht2/NC2", msg4);
Serial.println(msg1);
Serial.println(msg2);
Serial.println(msg3);
Serial.println(msg4);
}
}
}
void connectToMQTT()
{
client.setServer(mqtt_server, mqtt_port);//MQTT Server, - Port
if (client.connect(clientId))
{
Serial.println("connected");
}
}Mit dem
if (!m1.digitalRead(P4))
{
msg1 = "ON";
liegst richtig. Irgendwie ist heute nicht so ganz mein Tag.
Also stimmt schon, richtig muss es wie folgt heißen:
if (!m1.digitalRead(P4))
{
msg1 = "ON";
Ich probiere mal dein Code mit der einen Anpassung aus und gucke was nun passiert.
Okay nun tut es was es soll. Ich werde mir noch eines ergänzen, wo er die Nachrichten überprüft bevor er die Sendet, so sendet er nicht ständig unnötige Informationen, wo sich nichts geändert hat.
Ich hab das hin bekommen mit überprüfen ob sich der Wert geändert hat. Nur anderseits bin ich mir da nicht ganz sicher. Den wenn ich den ESP mal neu startet, bekommt er ja die Werte erst, sobald sich die Zustände "verändert" haben. Also muss man sich überlegen wie weit das Sinn macht, vor allem wenn sich manche Zustände eher seltener ändern.
Danke hier für erstmal.
@HotSystems
Ich muss dann nochmal gucken, wegen der "korrekten" Beschaltung des Resets und des Programm Pins. Problem ist im WWW findet man viel und nicht alles ist "richtig". Aber deine Alternative geht zumindest aktuell beim vorhandenen Board nicht. Da der ESP07 schon drauf gelötet ist
Die Beschaltung sieht soweit richtig aus.
Meine Module konnte ich bisher auch bei ähnlichen Problemen immer neu flashen.
Erst Reset drücken und halten, dann den Programm-Taster drücken, Reset loslassen und danach Prog-Taster loslassen und flashen. So hat es bei mir immer funktioniert.
Der Adapter ist auch nur eine Alternative vor dem Einlöten, wie auch geschrieben.
Und du kannst einen Aufbau sehr gut mittels Steckbrett testen.
Dann muss ich mir was basteln. Aktuell ist der "Prog Taster" ein Jumper, der Steckt
Aber probiere ich gleich mal aus und gucke was passiert.
Was nun noch im Code an sich fehlt sind 2 der 3 Status LEDs. Aber da möchte ich gerne erstmal selber probieren.
LED D4 soll leuchten, wenn WLAN läuft
LED D3 soll leuchten, wenn MQTT läuft
LED D2 soll leuchten, wenn Error eingetreten ist. Also entweder WLAN oder MQTT Error produziert.
Pinbelegung sieht wie folgt aus:
D2 -> P0
D3 -> P1
D4 -> P2
Wobei, wenn ich das Board nochmal überarbeiten müsste, könnte ich mir auch überlegen 2 Error LEDs ein zu planen. 1 Pin ist ja am PCF8574 noch frei
irgendwie mache ich entweder was falsch oder im Schaltplan ist doch ein "Bock" drin. Ich habe es gemacht wie von dir beschrieben.
- Programmiergerät (2 Verschiedene getestet) angeschlossen (GND -> GND, RXD -> TXD, TXD -> RXD)
- 230V einstecken, damit Stromversorgung da ist (Habe ich leider nicht dran gedacht, einfach beim Programmierport ein 3,3V Anschluß mit ein zu planen)
- Reset Drücken und halten
- Programmiertaste drücken und halten
- Reset Los lassen
- Programmieren los lassen
- Auf Flashen drücken
Ergebnis war in der Arduino IDE:
Und nichts Programmieren. Ich habe die Dumpfe Ahnung, ich darf den ESP nochmal auslöten zum Programmieren 
Als Programmiergerät habe ich unter anderem den genommen:
mit dem habe ich eigentlich ganz gute Erfahrung gemacht. Zumindest mit Chip alleine in ihm.
Bei dem wirst Du TX->TX und RX->RX verbinden müssen, da das dort ja schon die Anschlüsse des ESP sind.
Gruß Tommy
Danke, probiere ich gleich aus.
Danke für den Hinweis, nun klappte es mit dem Programmieren. Nach dem Programmieren war ich zwar noch verwundert, warum er trotzdem keine Änderung an den Pins festgestellt hatte. Aber nach dem ich den i2c Scanner nochmal drauf gepackt habe, hab ich festgestellt, dass die Hardwareadresse des PCF8574 nicht passte. Schande auf mein Haupt. Muss wohl einer mit dem "falschen" Typen dazwischen geraten sein. Gibt ja 2 Verschiedne Basisadressen bei dem Chip. Aber naja es läuft, der Code Ohne oben den Teil mit SSID sieht nun wie folgt aus:
const char* mqtt_server = "192.168.178.43";
const int mqtt_port = 1883;
char* msg1 = "";
char* msg2;
char* msg3;
char* msg4;
char* msg1old;
char* msg2old;
char* msg3old;
char* msg4old;
const unsigned long interval = 2000;
unsigned long lastmillis = 0;
void setup()
{
Serial.begin(9600);
WiFi.begin(ssid, password);
WiFi.config(ip, gateway, subnet);
ArduinoOTA.setHostname(otaHostname);
ArduinoOTA.setPassword(otaPassword);
ArduinoOTA.begin();
connectToMQTT();
m1.begin();
m1.pinMode(P0, OUTPUT);
m1.pinMode(P4, INPUT);
m1.pinMode(P5, INPUT);
m1.pinMode(P6, INPUT);
m1.pinMode(P7, INPUT);
//pinMode(D8, INPUT);
//pinMode(D1, OUTPUT);
m1.digitalWrite(P0, LOW);
delay(1000);
}
void loop()
{
ArduinoOTA.handle();
if (millis() - lastmillis >= interval)
{
if (WiFi.status() != WL_CONNECTED)
{
m1.digitalWrite(P0, HIGH);
m1.digitalWrite(P2, LOW);
}
else
{
m1.digitalWrite(P0, LOW);
m1.digitalWrite(P2, HIGH);
lastmillis = millis();
//Serial.println(digitalRead(D8));
//digitalWrite(D1, digitalRead(D8));
connectToMQTT();
if (m1.digitalRead(P4))
{
msg1 = "ON";
}
else
{
msg1 = "OFF";
}
if (msg1 != msg1old) {
client.publish("ESP_Kellerlicht/Keller", msg1);
msg1old = msg1;
}
if (m1.digitalRead(P5))
{
msg2 = "ON";
}
else
{
msg2 = "OFF";
}
client.publish("ESP_Kellerlicht/Schleifplatz", msg2);
if (m1.digitalRead(P6))
{
msg3 = "ON";
}
else
{
msg3 = "OFF";
}
client.publish("ESP_Kellerlicht/NC1", msg3);
if (m1.digitalRead(P7))
{
msg4 = "ON";
}
else
{
msg4 = "OFF";
}
client.publish("ESP_Kellerlicht/NC2", msg4);
Serial.println(msg1);
Serial.println(msg2);
Serial.println(msg3);
Serial.println(msg4);
}
}
}
void connectToMQTT()
{
client.setServer(mqtt_server, mqtt_port);//MQTT Server, - Port
if (client.connect(clientId))
{
Serial.println("connected");
m1.digitalWrite(P1, LOW);
m1.digitalWrite(P0, HIGH);
}
else {
m1.digitalWrite(P1, HIGH);
m1.digitalWrite(P0, LOW);
}
}
Was noch leicht stört, ist dass die LED D2 (Error) gelegentlich leicht "pulst". Also ganz kurz halbhell an und wieder aus geht. Das stimmt mit dem übertragen der Daten überein. Also wird es wohl im mqtt Teil irgendwie noch nich ganz rund laufen.
Foto der Platine in echt kommt gleich. Werde aber vermutlich nochmal eine etwas überarbeitete Version die Tage bestellen.
- Programmierport mit 3,3V
- Deepsleep Jumper (beide) kommen weg
- evtl. Jumper für PCF8574 für die Adressierung aber ich glaube weniger, müsste man sich überlegen, falls ich den i2c Port mit nach außen gebe, für andere Module oder so.
Was ich gleich noch in den Code implementieren muss ist der Teil mit dem DS18B20, der soll ja die Schaltung im Gehäuse etwas "Überwachen".
Michael