@opensourcenomad

Echt jetzt? Könnt Ihr den Kleinkrieg an einer anderen Stelle machen?

Danke

@mcm57

Displays:
www.tindie.com/products/electronics-by-nic/5-pcs-29-epaper-tags-for-openepaperlink

AP:
www.tindie.com/products/electronics-by-nic/openepaperlink-mini-ap-v3-zigbee-wifi-gateway/

@doggie sagte in Wasserzähler - Version 2 - all-in-device:

Mir scheint das ganze AI on the edge Projekt ist nicht annähernd ausgereift. Sehr, sehr schade. Und enttäuschend.
Was sagen andere dazu?
Gibt es eigentlich Systeme die fehlerfrei laufen?
Als Entwickler des Systems würde mich so ein Fehler nicht schlafen lassen.

Ein klein wenig Demut wäre nicht schlecht. Hier macht jemand ein Projekt in seiner Freizeit. Alles kostenlos. Letztendlich ist es "Bastelei". Was nicht bedeutet das es sehr, sehr gute Projekte sind.

Wenn ein 100% zuverlässiges System gesucht wird, sollte man sich event. im Fachhandel umschauen. Ob dort die entsprechenden System und Programme auch kostenlos angeboten werden, kann ich so nicht sagen. Ich glaube aber eher nicht.

Grüße
Manfred

Vielen Dank.

Ich liebe dieses Forum und die Leute darin.

@bananajoe sagte in EPS E-INK Display Ansteuerung -> Statusdisplay für 2€:

@beowolf hast du die selbst geflasht? In der Bucht sind die gerade zu kaufen und ich starre gerade schon eine ganze weile auf das Pinout wo ich denn ran müsste ... (ich bin Tasmota-verwöhnt, da wird immer ein Bild hinterlegt welche Pins man nehmen muss)

Eines vorab. Das ist nicht auf meinem Mist gewachsen. Ich habe das auch nur mit der Hilfe von Aaron Christophel hin bekommen.

Vielen, vielen Dank dafür.

Hier z.B. ein Video von ihm.

https://www.youtube.com/watch?v=8oQdo9bJ7Rk

Es geht um diesen TAG

https://github.com/jjwbruijn/OpenEPaperLink/wiki/2.9″-EL029H3WRA#pinout

Für den Anschluss und Positionierung der POGO-Pins geht dieses z.B.

https://github.com/jjwbruijn/OpenEPaperLink/blob/master/Hardware/M3 Newton Jigs by Jelmer/M3-2.9.stl

Ich habe dieses

https://github.com/jjwbruijn/OpenEPaperLink/tree/master/Tag_Flasher

herunter geladen.

Nun in das Verzeichnis ESP32_Flasher wechseln und dann mit der Hilfe von Visual Studio Code den Flasher auf einen ESP32 S2 aufgespielen.

Den ESP dann so wie hier mit dem TAG verbinden.

Nun ein Verzeichnis höher gehen. Also in den Tag_Flasher Ordner gehen.

Dann diese Datei herunterladen und in das Verzeichnis ablegen.

https://github.com/jjwbruijn/OpenEPaperLink/blob/master/binaries/Tag/SOL_M3_Uni_full_26.bin

Ich habe es mit diesem Befehl gemacht.

python3 OEPL-Flasher.py -p COM11 -e -n write SOL_M3_Uni_full_26.bin --flash --pt

COM11 natürlich anpassen.

Für das Flashen muß auf dem Rechner Python installiert sein.

Hier die passende Version laden.

https://www.python.org/

Bei dem Versuch kamen bei mir ein paar Meldungen das diese oder jenes nicht da ist.

Ich musste z.b. dieses nachinstallieren: "pip install pyserial". Sollten da noch Meldungen kommen. einfach kurz bei google suchen.

Danach sollte der Tag mit OPenEPaper geflasht sein.

Ich hoffe ich habe nichts vergessen.

Halloö zusammen,

event. ist das ja etwas für den ein oder anderen.

https://www.tindie.com/products/muino/smart-water-meter-reader/

Grüße

@bananajoe sagte in EPS E-INK Display Ansteuerung -> Statusdisplay für 2€:

@beowolf sagte in EPS E-INK Display Ansteuerung -> Statusdisplay für 2€:

Ich bin ein wenig Ratlos und weiß nicht wo ich anfangen soll.

Hier mal grob in Schritten zusammengefasst:

Schritt 1: Eigene VIS für die ePaper Tags
.........

Für die schwarzen TAGs muß die Auflösung geändert werden. Sonst gibt es nur Schrott in der Anzeige.

Also auf 384 x 168 Pixel

Grüße

@bananajoe

So, ich habe jetzt das Skript mal ein wenig umgebaut.

sendTo('puppeteer.0', 'screenshot', { 
    url: urlOfVISView,                     
    path: imageSaveToFilenameWithPath,     
    width: viewWidth,                      
    height: viewHeight,                    
    quality: jpgQuality,                   

    waitOption: {
        waitForSelector: waitForSelector,  
        waitForTimeout: 20000              
    },

    fullPage: false,                       

    clip: {         
        x: cutoutX,                        
        y: cutoutY,                        
        width: cutoutWidth,                
        height: cutoutHeight               
    }
}, obj => {
    if (obj.error) {
        console.warn("Fehler beim Aufruf der View: " + urlOfVISView + " => " + obj.error.message);
    } else {
        const http = require('http'); 
        const https = require('https');
        const { URL } = require('url');

        const boundary = '--------------------------' + Date.now().toString(16);
        const CRLF = '\r\n';

        // Payload-Erstellung
        const payload = Buffer.concat([
            Buffer.from(`--${boundary}${CRLF}Content-Disposition: form-data; name="dither"${CRLF}${CRLF}0${CRLF}`),
            Buffer.from(`--${boundary}${CRLF}Content-Disposition: form-data; name="mac"${CRLF}${CRLF}${ePaperMAC}${CRLF}`),
            Buffer.from(`--${boundary}${CRLF}Content-Disposition: form-data; name="image"; filename="screenshot.jpg"${CRLF}Content-Type: image/jpeg${CRLF}${CRLF}`),
            Buffer.from(obj.result, 'binary'),
            Buffer.from(`${CRLF}--${boundary}--${CRLF}`)
        ]);

        // URL Parsing
        const url = new URL(imageUploadURL);
        const options = {
            hostname: url.hostname,
            port: url.port || (url.protocol === 'https:' ? 443 : 80),
            path: url.pathname + (url.search || ''),
            method: 'POST',
            headers: {
                'Content-Type': 'multipart/form-data; boundary=' + boundary,
                'Content-Length': payload.length
            }
        };

        // Protokollwahl
        const protocol = url.protocol === 'https:' ? https : http;

        // HTTP Request
        const req = protocol.request(options, function(res) {
            console.log('ImageUploadStatusCode:', res.statusCode);
            res.on('data', function(chunk) {
                console.log('Response:', chunk.toString());
            });
        });

        req.on('error', function(e) {
            console.error('Fehler beim Hochladen:', e.message);
        });

        req.write(payload);
        req.end();
    }
});

Na ja, ich bin jetzt mal ehrlich. Ich habe ChatGPT solange damit gernervt bis ich eine Version hatte die jetzt funktioniert.

Ich habe keine Ahnung was da wie gemacht wird, aber es läuft. Die TAG werden sehr schnell aktualisiert und alles ohne Fehlermeldungen.

Grüße
Manfred

Genau für den Fall, weil "request" nicht mehr geht, hatte ich doch das Skript geändert.

Hier läuft es ohne Probleme mit der Java-Skriptversion 8.3.1

@dieter_p
Danke für die Idee. Es ging jetzt aber einfacher. Ich habe einfach den Datenpin umbenannt.

Hier mal mein erster Skript-Entwurf.

// PartialUpdateTest : example for Waveshare 1.54", 2.31" and 2.9" e-Paper and the same e-papers from Dalian Good Display Inc.
//
// Created by Jean-Marc Zingg based on demo code from Good Display for GDEP015OC1.
//
// The e-paper displays are available from:
//
// https://www.aliexpress.com/store/product/Wholesale-1-54inch-E-Ink-display-module-with-embedded-controller-200x200-Communicate-via-SPI-interface-Supports/216233_32824535312.html
//
// http://www.buy-lcd.com/index.php?route=product/product&path=2897_8363&product_id=35120
// or https://www.aliexpress.com/store/product/E001-1-54-inch-partial-refresh-Small-size-dot-matrix-e-paper-display/600281_32815089163.html
//

// Supporting Arduino Forum Topics:
// Waveshare e-paper displays with SPI: http://forum.arduino.cc/index.php?topic=487007.0
// Good Dispay ePaper for Arduino : https://forum.arduino.cc/index.php?topic=436411.0

// mapping from Waveshare 2.9inch e-Paper to Wemos D1 mini
// BUSY -> D2, RST -> D4, DC -> D3, CS -> D8, CLK -> D5, DIN -> D7, GND -> GND, 3.3V -> 3.3V

// mapping example for AVR, UNO, NANO etc.
// BUSY -> 7, RST -> 9, DC -> 8, C S-> 10, CLK -> 13, DIN -> 11

// include library, include base class, make path known
#include <GxEPD.h>

// select the display class to use, only one

#include <GxGDEW042T2/GxGDEW042T2.h>      // 4.2" b/w

#include <ESP8266WiFi.h>
#include <ArduinoOTA.h>
#include <PubSubClient.h>

#ifndef STASSID
#define STASSID "xxxxx"
#define STAPSK  "xxxxxxxx"
#endif

const char* ssid = STASSID;
const char* password = STAPSK;

char* mqtt_client_id = "E-Paperdisplay-1";
const char* mqtt_server = "192.168.xx.xx";
const int mqtt_port = xxxx;
const char* mqtt_user = "xxxxxx";
const char* mqtt_password = "xxxxxxx";

WiFiClient espClient;
PubSubClient mqttClient(espClient);

#include <GxIO/GxIO_SPI/GxIO_SPI.h>
#include <GxIO/GxIO.h>

// FreeFonts from Adafruit_GFX
#include <Fonts/FreeMonoBold9pt7b.h>
#include <Fonts/FreeMonoBold12pt7b.h>

// for SPI pin definitions see e.g.:
// C:\Users\xxx\AppData\Local\Arduino15\packages\esp8266\hardware\esp8266\2.4.2\variants\generic\common.h

GxIO_Class io(SPI, /*CS=D0*/ 16, /*DC=D3*/ 0, /*RST=D4*/ 2); // arbitrary selection of D3(=0), D4(=2), selected for default of GxEPD_Class
GxEPD_Class display(io /*RST=D4*/ /*BUSY=D2*/); // default selection of D4(=2), D2(=4)

void setup(void)
{
  Serial.begin(115200);

  // Per WLAN mit dem Netzwerk verbinden
  Serial.print("Verbinden mit ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  ///////////////////////////////////////////
  // Anfang Update über Wlan
  ///////////////////////////////////////////

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

    // NOTE: if updating FS this would be the place to unmount FS using FS.end()
    Serial.println("Start updating " + type);
  });
  ArduinoOTA.onEnd([]() {
    Serial.println("\nEnd");
  });
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
  });
  ArduinoOTA.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();

  ///////////////////////////////////////////
  // Ende Update über Wlan
  ///////////////////////////////////////////

  // Die IP vom Webserver auf dem seriellen Monitor ausgeben
  Serial.println("");
  Serial.println("WLAN verbunden.");
  Serial.println("IP Adresse: ");
  Serial.println(WiFi.localIP());

  // MQTT Brocker
  // Mit ioBroker Mqtt verbinden
  mqttClient.setServer(mqtt_server, mqtt_port);//MQTT Server, - Port
  mqttClient.setCallback(callback);
  
  Serial.println();
  Serial.println("setup");
  //display.init(115200); // enable diagnostic output on Serial
  display.init(); // disable diagnostic output on Serial
  Serial.println("setup done");
  display.setTextColor(GxEPD_BLACK);
  display.setRotation(0);
  // draw background
  display.setFont(&FreeMonoBold12pt7b);
  display.update();
  display.fillScreen(GxEPD_WHITE);

}

void loop()
{


  ArduinoOTA.handle();
  ArduinoOTA.setHostname("E-Paperdisplay-1");
  
  // MQTT Broker
  mqttClient.loop();
  if (!mqttClient.connected()) {
    reconnectToMQTT();
  }


}

// MQTT Funktion
// *************
void reconnectToMQTT() {

  if (mqttClient.connect(mqtt_client_id , mqtt_user, mqtt_password)) {
    Serial.println("Per MQTT mit ioBroker verbunden");

//    mqttClient.publish("HH_Frischwasser/E-Paper1/alive", "0");
//    mqttClient.publish("HH_Frischwasser/E-Paper1/Info/IP Adresse", (char*) WiFi.localIP().toString().c_str());


    mqttClient.subscribe("HH_Wassertank_Aussen/HH_WT_A_Temperatur/Temperatur_am_Wassertank_Aussen");
    mqttClient.subscribe("HH_Wassertank_Innen/HH_WT_I_Temperatur/Temperatur_am_Wassertank_Innen");    
    mqttClient.subscribe("HH_Wassertank_Aussen/HH_WT_A_Wassertemperatur/Wassertemperatur_Wassertank_Aussen");  
    mqttClient.subscribe("HH_Wassertank_Innen/HH_WT_I_Wassertemperatur/Wassertemperatur_Wassertank_Innen");    
  

  
  } else {
    Serial.print("mqtt-Verbindung fehlgeschlagen ");
    Serial.print(mqttClient.state());
    Serial.println(" versuchen es in 5 Sekunden erneut");
    // Wait 5 seconds before retrying
    delay(5000);
  }
}



// MQTT Callback
void callback(char* topic, byte* payload, unsigned int length)
{

  payload[length] = '\0';
  String strTopic = String(topic);
  String strPayload = String((char * ) payload);

  Serial.print("Nachricht angekommen [");
  Serial.print(strTopic);
  Serial.print("----");
  Serial.print(strPayload);
  Serial.print("] ");
  Serial.println();
  

  if (strTopic == "HH_Wassertank_Aussen/HH_WT_A_Temperatur/Temperatur_am_Wassertank_Aussen")
  {
  Serial.println(strPayload);
  uint16_t box_x = 10;
  uint16_t box_y = 15;
  uint16_t box_w = 380;
  uint16_t box_h = 20;
  uint16_t cursor_y = box_y + 16;
  display.fillRect(box_x, box_y, box_w, box_h, GxEPD_WHITE);
  display.setCursor(box_x, cursor_y);
  display.print("Aussentemperatur: "); display.setCursor(box_x + 280, cursor_y);   display.print(strPayload.toFloat()); display.print(" C");
  display.updateWindow(box_x, box_y, box_w, box_h, true);
    }


  if (strTopic == "HH_Wassertank_Innen/HH_WT_I_Temperatur/Temperatur_am_Wassertank_Innen")
  {
  Serial.println(strPayload);
  uint16_t box_x = 10;
  uint16_t box_y = 50;
  uint16_t box_w = 380;
  uint16_t box_h = 20;
  uint16_t cursor_y = box_y + 16;
  display.fillRect(box_x, box_y, box_w, box_h, GxEPD_WHITE);
  display.setCursor(box_x, cursor_y);
  display.print("Innentemperatur: "); display.setCursor(box_x + 280, cursor_y);   display.print(strPayload.toFloat()); display.print(" C");
  display.updateWindow(box_x, box_y, box_w, box_h, true);  
    }


  if (strTopic == "HH_Wassertank_Aussen/HH_WT_A_Wassertemperatur/Wassertemperatur_Wassertank_Aussen")
  {
  Serial.println(strPayload);
  uint16_t box_x = 10;
  uint16_t box_y = 85;
  uint16_t box_w = 380;
  uint16_t box_h = 20;
  uint16_t cursor_y = box_y + 16;
  display.fillRect(box_x, box_y, box_w, box_h, GxEPD_WHITE);
  display.setCursor(box_x, cursor_y);
  display.print("W-Aussentemperatur: "); display.setCursor(box_x + 280, cursor_y);   display.print(strPayload.toFloat()); display.print(" C");
  display.updateWindow(box_x, box_y, box_w, box_h, true);  
    }



  if (strTopic == "HH_Wassertank_Innen/HH_WT_I_Wassertemperatur/Wassertemperatur_Wassertank_Innen")
  {
  Serial.println(strPayload);
  uint16_t box_x = 10;
  uint16_t box_y = 120;
  uint16_t box_w = 380;
  uint16_t box_h = 20;
  uint16_t cursor_y = box_y + 16;
  display.fillRect(box_x, box_y, box_w, box_h, GxEPD_WHITE);
  display.setCursor(box_x, cursor_y); 
  display.print("W-Innentemperatur: ");   display.setCursor(box_x + 280, cursor_y);   display.print(strPayload.toFloat()); display.print(" C");
  display.updateWindow(box_x, box_y, box_w, box_h, true);  
    }

}

Auf dem Diaplay erscheint dann folgendes.

@bananajoe

Ich habe diese hier

https://github.com/OpenEPaperLink/OpenEPaperLink/wiki/2.9″-EL029H3WRA

Dort funktioniert es.

@oxident sagte in E-INK Display OpenEPaperLink - Displayanzeige mit Batterie:

@beowolf 75 Tags? Hast Du damit tapeziert??

Die sind nur alle am AP angemeldet. Nur zum Testen.

Die Batteriespannung kann ich mir aber holen.

Ich habe dieses Skript ja am laufen.

// HIER DIE IP ADRESSE VOM OEPL ACCESS POINT EINTRAGEN
const serverIP = 'xxx.xxx.xxx.xxx';  // z.B. 192.168.1.71

// AB HIER NICHTS MEHR ÄNDERN!
const WebSocket = require('ws');
const http = require('http');
const wsUrl = `ws://${serverIP}/ws`;  // WebSocket-URL

let ws;
let pingInterval;
let scriptStopping = false;  // Flag, um zu prüfen, ob das Skript gestoppt wird

const controlState = '0_userdata.0.Tag_Buttons.Button_Skript_Steuerung.Button_Tags_Dachgeschoss';  // Datenpunkt zur Steuerung des Skripts

function ensureOpenEPaperLinkFolderExists(callback) {
    const OpenEPaperLinkFolderPath = '0_userdata.0.Tag_Buttons.Dachgeschoss';
    getObject(OpenEPaperLinkFolderPath, (err, obj) => {
        if (err || !obj) {
            setObject(OpenEPaperLinkFolderPath, {
                type: 'channel',
                common: { name: 'Open E-Paper Link' },
                native: {}
            }, callback);
        } else {
            callback();
        }
    });
}

function ensureChannelExists(path, alias, callback) {
    getObject(path, (err, obj) => {
        if (err || !obj) {
            setObject(path, {
                type: 'channel',
                common: { name: alias || 'Unbekanntes Gerät' },
                native: {}
            }, callback);
        } else if (obj.common.name !== alias) {
            extendObject(path, { common: { name: alias } }, callback);
        } else {
            callback();
        }
    });
}

function createStateAndSet(statePath, value) {
    setObject(statePath, {
        type: 'state',
        common: {
            name: statePath.split('.').pop(),
            type: 'string',
            role: 'value',
            read: true,
            write: true
        },
        native: {}
    }, (err) => {
        if (!err) {
            setState(statePath, String(value), true);
        }
    });
}

function updateStateIfChanged(statePath, value) {
    getState(statePath, (err, state) => {
        if (err || !state) {
            createStateAndSet(statePath, String(value));
        } else if (state.val !== String(value)) {
            setState(statePath, String(value), true);
        }
    });
}

function fetchDimensions(hwType, callback) {
    const hwTypeHex = hwType.toString(16).padStart(2, '0').toUpperCase();  // Convert hwType to two-digit uppercase hexadecimal
    const url = `http://${serverIP}/tagtypes/${hwTypeHex}.json`;
    http.get(url, (res) => {
        let data = '';
        res.on('data', (chunk) => data += chunk);
        res.on('end', () => {
            if (res.statusCode === 200) {
                try {
                    const dimensions = JSON.parse(data);
                    callback(null, dimensions);
                } catch (e) {
                    callback(`Error parsing JSON from ${url}: ${e}`);
                }
            } else {
                callback(`HTTP Error ${res.statusCode} from ${url}`);
            }
        });
    }).on('error', (err) => {
        callback(`Error fetching ${url}: ${err.message}`);
    });
}

function handleHWType(basePath, hwType) {
    createStateAndSet(`${basePath}.hwType`, String(hwType));  // Save hwType as a state
    fetchDimensions(hwType, (err, dimensions) => {
        if (!err && dimensions) {
            createStateAndSet(`${basePath}.height`, String(dimensions.height));
            createStateAndSet(`${basePath}.width`, String(dimensions.width));
            createStateAndSet(`${basePath}.name`, String(dimensions.name));
            if (dimensions.colors) {
                createStateAndSet(`${basePath}.colors`, String(dimensions.colors));
            }
            if (dimensions.colortable) {
                createStateAndSet(`${basePath}.colortable`, JSON.stringify(dimensions.colortable));
            }
        } else {
            // console.error(`Failed to fetch or set dimensions for hwType ${hwType}: ${err}`);
        }
    });
}

function connectWebSocket() {
    if (scriptStopping) {
        return;  // Wenn das Skript gestoppt wird, keine Verbindung mehr herstellen
    }

    ws = new WebSocket(wsUrl);
    ws.on('open', function open() {
        // console.log('Verbunden mit WebSocket');
        startHeartbeat();
    });

    ws.on('message', function incoming(data) {
        // console.log('Daten empfangen:', data);
        if (data) {
            try {
                let parsedData = JSON.parse(data);
                // console.log('Verarbeitete Daten:', JSON.stringify(parsedData, null, 2));
                handleData(parsedData);
            } catch (err) {
                // console.error('Fehler bei der Verarbeitung der Daten:', err);
            }
        } else {
            // console.log('Keine Daten oder leere Nachricht empfangen');
        }
    });

    ws.on('close', function close() {
        if (!scriptStopping) {
            // console.log('WebSocket-Verbindung geschlossen, versuche neu zu verbinden...');
            clearInterval(pingInterval);
            setTimeout(connectWebSocket, 5000);
        }
    });

    ws.on('error', function error(err) {
        // console.error('WebSocket-Fehler:', err);
    });
}

function startHeartbeat() {
    pingInterval = setInterval(() => {
        if (ws.readyState === WebSocket.OPEN) {
            ws.ping(() => {
                // console.log('Ping sent');
            });
        }
    }, 10000); // Send ping every 10 seconds

    ws.on('pong', () => {
        // console.log('Pong received');
    });
}

function handleData(parsedData) {
    if (parsedData.tags && Array.isArray(parsedData.tags)) {
        parsedData.tags.forEach(tag => {
            let basePath = `0_userdata.0.Tag_Buttons.Dachgeschoss.${tag.mac.replace(/:/g, '')}`;
            ensureChannelExists(basePath, tag.alias, () => {
                Object.keys(tag).forEach(key => {
                    let statePath = `${basePath}.${key}`;
                    let value = tag[key];
                    updateStateIfChanged(statePath, value);
                    if (key === 'hwType') {
                        handleHWType(basePath, tag.hwType);
                    }
                });
            });
        });
    }
}

function disconnectWebSocket() {
    if (ws) {
        ws.close();
        ws = null;
    }
    clearInterval(pingInterval);
}

// Skript-Start und -Stopp basierend auf einem Datenpunkt steuern
function setupScriptControl() {
    setObject(controlState, {
        type: 'state',
        common: {
            name: 'EPaper Script Control',
            type: 'boolean',
            role: 'switch',
            read: true,
            write: true,
            def: false
        },
        native: {}
    });

    on({id: controlState, change: 'ne'}, (obj) => {
        const state = obj.state.val;
        if (state) {
            // Skript starten
            scriptStopping = false;
            ensureOpenEPaperLinkFolderExists(connectWebSocket);
        } else {
            // Skript stoppen
            scriptStopping = true;
            disconnectWebSocket();
            // console.log('Skript beendet durch Steuer-Datenpunkt');
        }
    });
}

// Initiale Einrichtung
setupScriptControl();

Preislich ist das ok. Die Dinger gibt es bei E-Bay Kleinanzeigen für 25 - 30 €.

Ich glaube dieses wird es.

Homematic 3-Kanal-Funk-Schließerkontakt-Interface HM-SCI-3-FM für Smart Home / Hausautomation

@nordischerjung sagte in Master - Slave Schalter oder so?:

@martinp Shelly Plus i4 DC mit 5 VDC Netzgerät und ein Kondensator zum Puffern beim ausschalten

Das ist glaube ich die einfachere Lösung. Als Kondensator sollte doch ein Goldcap (Elko Goldcap 1,0F, 5,5V Typ C) reichen.

Ich habe drei von den yellow APs hier laufen. Damit habe ich keine Probleme.

Ich hatte allerdings erst auf "Update latest Version" geklickt und musste danach noch einmal bei "Environment" den "ESP32_S3_16_8_YELLOW_AP" auswählen.
Dann habe ich bei ESP32 und Filesystem das Update noch mal manuell angestossen.

Habe 75 TAGs am laufen.

@ticaki sagte in Master - Slave Schalter oder so?:

Man nimmt einen 240V magnet und einen Aqara Türsensor Zigbee. Das könnte gehen, auch wenn ich keinen plan habe obs 240V Elektromagneten in der benötigten größe gibt.

Jetzt wird es ein wenig schräg.

@martinp sagte in Master - Slave Schalter oder so?:

Falls eine Fritzbox da ist, könnte man die "Anwesenheit" des Shelly mit fb_checkpresence überwachen ...

Das wird wohl zu lange dauern.

IR-Signal oder Funk. Das muß ich mal schauen.

@linedancer sagte in Master - Slave Schalter oder so?:

Da braucht es einen Shelly hinter dem Wandschalter. Dort wo die alte Deckenlampe war, brauchst du Nix.
Als allererstes muss ein Fachkundiger klären, ob in der Schalterdose ein N-Leiter vorhanden ist. Den benötigt der Shelly.
Mit diesem Shelly können dann andere Shelly’s geschaltet werden.

Das ist ja das Problem. An bzw. hinter dem Schalter darf und soll nichts gemacht werden. Das mit den Shellys kenne ich ja. Das wäre ja kein Problem.

Ich habe eben nur die Möglichkeit mit dem "Anschluß" an der Decke.

Es ist eben die Überlegung, das ein kleiner "schwarzer" Kasten an der Decke eingeschaltet wird. Dieser sendet sofort ein "Einschaltsignal" an eine andere kleine "schwarze" Box um eine z.B. Stehlampe zu schalten.
Wird der kleine "schwarze" Kasten an der Decke ausgeschaltet, schaltet sich auch der Kasten für die Stehlampe wieder aus.