OpenEpaperLink - Script für Tastenabfrage

Eisbaeeer

Es kam schon öfter die Frage auf, wie man die Tasten an einem EPaper Display für OpenEpaperLink abfragen kann.
Leider funktioniert der Open-Epaper-Link Adapter derzeit eher mäßig, deshalb habe ich die Funktion des TCP Sockets in das Script übernommen (Danke an @Beowolf ).

Also was macht das Script?

Man erstellt sich mehrere Views, die auf dem Display angezeigt werden sollen.
Im Script gibt man die Parameter an
Mit den Tasten am Display kann man dann die Seiten "hoch und runterblättern".

Ich verwende hier ein 4" Touch Display mit integriertem Accesspoint. Das geht aber natürlich auch mit jedem anderen Epaper Display mit Taster.
Die Uhr wird jede Minute aktualisiert. Macht also nur auf einem Accesspoint Sinn. ;-)
Das Laden der nächsten Seite dauert etwa 5-6 Sekunden. Ganz unten gibt es auch ein Video.

// #############################################
// Author: Eisbaeeer
// Date: 20250519
//
// Dieses Script ermöglicht es, mit einem OpenEpaperTag und Tastern an dem Display (oder touch mit 4" Display), mehrere View´s durchzublättern. Die Tasten werden zum vor- bzw. zurückblättern
// verwendet. Bevor das Script verwendet werden kann, müssen die Views angelegt werden. Die Views werden durchnummeriert, beginnend bei 1. Der "Basis" Name der View muss unten konfiguriert werden.
// Die Anzahl der verwendeten Seiten werden mit "pageCount" konfiguriert.
// Für jede View muss noch der Selektor 'waitForSelectorArray' definiert werden. Im Beispiel wartet puppettier beim View1 auf den Selector '#w00042'.
// Die Erste View ist eine Uhr, welche jede Minute aktualisiert wird.
//
// In dem Script wird die Socket-Verbindung von Beowolf verwendet (https://forum.iobroker.net/topic/66380/e-ink-display-openepaperlink-displayanzeige-mit-batterie/809?_=1747419968864)
//
// Version: 0.4 : 20250519 Added socket
// Version: 0.3 : 20250518 AP-4" kann in Verbindung mit iobroker.open-epaper-llink Adapter mehrere Ansichten durchblättern
// Version 0.2 : Bugfix async pictures
// Version: 0.1 : Convert from Blockly to js
//
// Benötigt:
// - Puppeteer Adapter
// - Chrome Headless
//
// #############################################
// Hier die Anpassungen vornehmen!

const urlOfVISView = 'http://192.168.1.200:8082/vis/index.html?OpenEpaper#Tag4Zoll'; // Eure View oder URL vom Bild + Nummer der View beginnend bei 1
const targetWidth = 480; // Breite des Displays
const targetHeight = 480; // Höhe des Displays
const cutoutX = 0; // Abstand Pixel von links für Screenshot
const cutoutY = 0; // Abstand Pixel von oben für Screenshot
const pquality = 100; // Bildqualität
const pageCount = 3; // Anzahl der Seiten zum Durchblättern
const waitForSelectorArray = ["","#w00042","#w00044","#w00053"]; // Letztes Element auf das Peppeteer wartet als Array
const inputPath = "/tmp/Tag01_480x480"; // Screenshot temporär Format: /Pfad/prefix
const accesspointIP = '192.168.1.78'; // Accesspoint IP Adresse
const macAddress = '0000840B822F3728'; // MAC-Adresse des Displays anpassen
const ditherValue = 1; // Setze den Dither-Wert (Farbanpassungen: 0 = View hat gleiche Farben | 1 = View hat andere Farben als das Display
const autostart = true; // Websocket automatisch starten? true|false

// ENDE Anpassungen! Ab hier nichts mehr ändern!
// #############################################

var buttons = '0_userdata.0.open-epaper-link.Tag_Buttons.' + macAddress + '.page';
createState(buttons,1);
var uploadUrl = 'http://' + accesspointIP + '/imgupload';
var wakeupR = '0_userdata.0.open-epaper-link.Tag_Buttons.' + macAddress + '.wakeupReason';
var wakeup = '0_userdata.0.open-epaper-link.Tag_Buttons.' + macAddress + '.lastseen';

schedule("* * * * *", function() {
console.log("Send clock page every minute if pageVal is 1");
var pageVal = getState(buttons).val;
console.log("Page: " + pageVal);
let waitForSelector = waitForSelectorArray[pageVal];
console.log("waitForSelector: " + waitForSelector);
var view = urlOfVISView+pageVal;
console.log("View: " + view);
if ( pageVal == 1 ) {
takeScreenshots(pageVal,waitForSelector,view);
}
});

on(wakeup,function() {
var pageVal = getState(buttons).val;
if ( getState(wakeupR).val == 5 ) {
if (pageVal >= pageCount) {
setState(buttons, 1 );
pageVal = 1;
} else {
pageVal++;
setState(buttons,pageVal);
}
let waitForSelector = waitForSelectorArray[pageVal];
console.log("waitForSelector: " + waitForSelector);
var view = urlOfVISView+pageVal;
console.log("View: " + view);
takeScreenshots(pageVal,waitForSelector,view);
}
if ( getState(wakeupR).val == 4 ) {
if (pageVal <= 1 ) {
setState(buttons,pageCount);
pageVal = pageCount;
} else {
pageVal--;
setState(buttons,pageVal);
}
let waitForSelector = waitForSelectorArray[pageVal];
console.log("waitForSelector: " + waitForSelector);
var view = urlOfVISView+pageVal;
console.log("View: " + view);
takeScreenshots(pageVal,waitForSelector,view);
}
setState(wakeupR,0);
});

// Requirements
const puppeteer = require('puppeteer');
const axios = require('axios');
const fs = require('fs');
const FormData = require('form-data');

async function takeScreenshots(pageVal,waitForSelector,view) {
console.log("*** function takeScreenshot");
sendTo('puppeteer.0', 'screenshot', {
url: view,
path: inputPath+macAddress+pageVal+'.jpg',
width: targetWidth,
height: targetHeight,
quality: pquality,

    waitOption: {
        waitForSelector: waitForSelector,  
        waitForTimeout: 10000              
    },
 
    fullPage: false,                       
 
    clip: {         
        x: cutoutX,                        
        y: cutoutY,                        
        width: targetWidth,                
        height: targetHeight               
    }
}, obj => {
  if (obj.error) {
    log(`Error taking screenshot: ${obj.error.message}`, 'error');
  } else {
    // the binary representation of the image is contained in `obj.result`
    log(`Successfully took screenshot: ${obj.result}`);
    console.log("*** upload Image");
    // uploading Screenshot
    async function uploadImage() {
	try {
		// Prüfen, ob die Datei existiert
		if (!fs.existsSync(inputPath+pageVal+'.jpg')) {
		throw new Error(`Datei nicht gefunden: ${inputPath+macAddress+pageVal+'.jpg'}`);
	}
// FormData erstellen
const form = new FormData();
form.append("mac", macAddress);
form.append("dither", ditherValue); // Dither-Parameter hinzufügen
form.append("file", fs.createReadStream(inputPath+macAddress+pageVal+'.jpg'));
// POST-Anfrage senden
const response = await axios.post(uploadUrl, form, {
headers: {
	...form.getHeaders(),
},
});

console.log('Upload erfolgreich:', response.data);
} catch (error) {
if (error.response) {
	console.error('Server-Antwort:', error.response.status, error.response.data);
} else if (error.request) {
	console.error('Keine Antwort erhalten:', error.request);
} else {
	console.error('Fehler beim Hochladen:', error.message);
}
}
}
uploadImage();
}
})

}

const WebSocket = require('ws');
const http = require('http');
const wsUrl = ws://${accesspointIP}/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.open-epaper-link.Start'; // Datenpunkt zur Steuerung des Skripts - anhalten oder starten

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 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 disconnectWebSocket() {
if (ws) {
ws.close();
ws = null;
}
clearInterval(pingInterval);
}

// Skript-Start und -Stopp basierend auf einem Datenpunkt steuern
function setupScriptControl() {
if (autostart == true) {
ensureOpenEPaperLinkFolderExists(connectWebSocket);
}
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();

6807aa39-be12-4cbf-85e1-666b3c46749b-20250519_202102.jpg
64c057dd-e8d9-428f-80c0-c3d6e928ddc0-20250519_202121.jpg
674ec975-4bd9-482d-81b0-7e96eabf10ce-20250519_202136.jpg

https://youtube.com/shorts/G4g4ynx-t_k?feature=share

Beowolf

@eisbaeeer

Fein, fein. Danke dafür.

Ich habe das Skript jetzt noch nicht probiert.

Besteht mit dem Skript auch die Möglichkeit, das ich mit den Tasten auch eine z.B. Lampe über ioBroker schalten kann?

Eisbaeeer

@beowolf So direkt erstmal nicht. Dazu müsstest du das Script umbauen. Vorstellbar wäre, dass du nur eine Taste zum durchblättern benutzt und die andere zum Toggeln oder schalten.
Im Code findest du das Abfragen der Tasten hier:

on(wakeup,function() {
var pageVal = getState(buttons).val;
if ( getState(wakeupR).val == 5 ) {
if (pageVal >= pageCount) {
setState(buttons, 1 );
pageVal = 1;
} else {
pageVal++;
setState(buttons,pageVal);
}
let waitForSelector = waitForSelectorArray[pageVal];
console.log("waitForSelector: " + waitForSelector);
var view = urlOfVISView+pageVal;
console.log("View: " + view);
takeScreenshots(pageVal,waitForSelector,view);
}
if ( getState(wakeupR).val == 4 ) {
if (pageVal <= 1 ) {
setState(buttons,pageCount);
pageVal = pageCount;
} else {
pageVal--;
setState(buttons,pageVal);
}
let waitForSelector = waitForSelectorArray[pageVal];
console.log("waitForSelector: " + waitForSelector);
var view = urlOfVISView+pageVal;
console.log("View: " + view);
takeScreenshots(pageVal,waitForSelector,view);
}
setState(wakeupR,0);
});

"wakeupR" : 4 ist die linke Taste, 5 die rechte Taste.

if ( getState(wakeupR).val == 4 ) {

Beowolf

Habe das Skript mal NUR für die Button geändert. Es wird kein Inhalt an die TAGs gesendet.

//
// #############################################
//
// Dieses Script ermöglicht die Buttonabfrage.
//
// In dem Script wird die Socket-Verbindung von Beowolf verwendet (https://forum.iobroker.net/topic/66380/e-ink-display-openepaperlink-displayanzeige-mit-batterie/809?_=1747419968864)
//
// Ein erweitertes Skript von Eisbaeeer ist hier (https://forum.iobroker.net/topic/81101/openepaperlink-script-für-tastenabfrage )
//
// Die Button-States werden unter dem konfigurierten basePathPrefix erzeugt.
//
// #############################################

// #############################################
//
// Konfigurierbare Variablen - Hier die Anpassungen vornehmen!
//

const controlStatePath = '0_userdata.0.Buttons-DG-TAGs';   // Basis für controlState und basePath
const controlState = `${controlStatePath}.Start`;          // Skript starten oder beenden
const basePathPrefix = `${controlStatePath}.Tag_Buttons`;  // Basis-Pfad für Button-States
const accesspointIP = '192.168.49.187';                    // Accesspoint IP Adresse

//
// ENDE Anpassungen! Ab hier nichts mehr ändern!
// #############################################





const wsUrl = `ws://${accesspointIP}/ws`;
const WebSocket = require('ws');

let ws;
let pingInterval;
let scriptStopping = false;

function connectWebSocket() {
    if (scriptStopping) return;
    ws = new WebSocket(wsUrl);

    ws.on('open', () => {
        console.log('WebSocket verbunden');
        startHeartbeat();
    });

    ws.on('message', (data) => {
        try {
            const parsed = JSON.parse(data);
            handleData(parsed);
        } catch (err) {
            // Parsing-Fehler ignorieren
        }
    });

    ws.on('close', () => {
        clearInterval(pingInterval);
        if (!scriptStopping) setTimeout(connectWebSocket, 5000);
    });

    ws.on('error', () => {
        // WebSocket-Fehler ignorieren
    });
}

function startHeartbeat() {
    pingInterval = setInterval(() => {
        if (ws.readyState === WebSocket.OPEN) {
            ws.ping();
        }
    }, 10000);
}

function handleData(parsedData) {
    if (!parsedData.tags || !Array.isArray(parsedData.tags) || parsedData.tags.length === 0) {
        return;
    }

    parsedData.tags.forEach(tag => {
        if (!tag.mac) return;

        const macClean = tag.mac.replace(/:/g, '');
        const basePath = `${basePathPrefix}.${macClean}`;

        ensureChannelExists(basePath, tag.alias || tag.name || 'Unbenannt', () => {
            if ('wakeupReason' in tag) {
                const statePath = `${basePath}.wakeupReason`;
                updateStateIfChanged(statePath, tag.wakeupReason);
            }
        });
    });
}

function ensureChannelExists(id, name, callback) {
    getObject(id, (err, obj) => {
        if (!obj) {
            setObject(id, {
                type: 'channel',
                common: {
                    name: name
                },
                native: {}
            }, callback);
        } else {
            callback();
        }
    });
}

function updateStateIfChanged(id, value) {
    if (value === null || value === undefined) return;

    const isPrimitive = val => ['string', 'number', 'boolean'].includes(typeof val);

    let storedValue = value;
    let valueType = typeof value;

    if (!isPrimitive(value)) {
        try {
            storedValue = JSON.stringify(value);
            valueType = 'string';
        } catch {
            return;
        }
    }

    getState(id, (err, state) => {
        if (err || !state) {
            setObject(id, {
                type: 'state',
                common: {
                    name: id.split('.').pop(),
                    type: valueType,
                    role: 'value',
                    read: true,
                    write: false
                },
                native: {}
            }, () => setState(id, storedValue, true));
        } else if (state.val !== storedValue) {
            setState(id, storedValue, true);
        }
    });
}

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

function setupControl() {
    setObject(controlState, {
        type: 'state',
        common: {
            name: 'EPaper Script Control',
            type: 'boolean',
            role: 'switch',
            read: true,
            write: true,
            def: true
        },
        native: {}
    });

    on({ id: controlState, change: 'ne' }, (obj) => {
        if (obj.state.val === true) {
            scriptStopping = false;
            connectWebSocket();
        } else {
            scriptStopping = true;
            disconnectWebSocket();
        }
    });

    getState(controlState, (err, state) => {
        if (!err && state && state.val === true) {
            connectWebSocket();
        }
    });
}

setupControl();

Hier wird jetzt nur der Datenpunkt "wakeupReason" angelegt.

Beowolf

Hier ein geändertes Skript für die, die mehrere APs haben.

//
// #############################################
//
// Dieses Script ermöglicht die Buttonabfrage.
//
// In dem Script wird die Socket-Verbindung von Beowolf verwendet (https://forum.iobroker.net/topic/66380/e-ink-display-openepaperlink-displayanzeige-mit-batterie/809?_=1747419968864)
//
// Ein erweitertes Skript von Eisbaeeer ist hier (https://forum.iobroker.net/topic/81101/openepaperlink-script-für-tastenabfrage )
//
// Die Button-States werden unter dem konfigurierten basePathPrefix erzeugt.
//
// #############################################

// #############################################
//
// Konfigurierbare Variablen - Hier die Anpassungen vornehmen!
//


const rootPath = '0_userdata.0'; // Bei Bedarf anpassen
const controlRoot = 'EPaperControl'; // Oberordner für Steuerung
const buttonRoot = 'Buttons'; // Unterordner für Buttons

const accesspoints = [
    { location: 'Erdgeschoss', ip: '192.168.49.185' }, // Accesspoint IP Adresse
    { location: 'Obergeschoss', ip: '192.168.49.186' }, // Accesspoint IP Adresse
    { location: 'Dachgeschoss', ip: '192.168.49.187' }, // Accesspoint IP Adresse
    { location: 'Hühnerhaus', ip: '192.168.49.139' } // Accesspoint IP Adresse
];

//
// ENDE Anpassungen! Ab hier nichts mehr ändern!
// #############################################
//

// Automatisch generierte Pfade für jeden Accesspoint
accesspoints.forEach(ap => {
    ap.name = `${ap.location}-AP`;
    ap.controlState = `${rootPath}.${controlRoot}.${ap.location}.Start`;
    ap.buttonPathPrefix = `${rootPath}.${controlRoot}.${ap.location}.${buttonRoot}`;
});

const WebSocket = require('ws');

let wsConnections = {};
let pingIntervals = {};
let scriptStatus = {};

// Initialisierung der Steuerobjekte
accesspoints.forEach(ap => {
    scriptStatus[ap.name] = false;

    setObject(ap.controlState, {
        type: 'state',
        common: {
            name: `Start/Stop ${ap.name}`,
            type: 'boolean',
            role: 'switch',
            read: true,
            write: true,
            def: false
        },
        native: {}
    });

    on({ id: ap.controlState, change: 'ne' }, (obj) => {
        if (obj.state.val === true) {
            scriptStatus[ap.name] = true;
            connectWebSocket(ap.name, ap.ip);
        } else {
            scriptStatus[ap.name] = false;
            disconnectWebSocket(ap.name);
        }
    });

    getState(ap.controlState, (err, state) => {
        if (!err && state && state.val === true) {
            scriptStatus[ap.name] = true;
            connectWebSocket(ap.name, ap.ip);
        }
    });
});

function connectWebSocket(name, ip) {
    if (wsConnections[name]) return;

    const url = `ws://${ip}/ws`;
    const ws = new WebSocket(url);
    wsConnections[name] = ws;

    ws.on('open', () => {
        console.log(`WebSocket ${name} verbunden (${ip})`);
        pingIntervals[name] = setInterval(() => {
            if (ws.readyState === WebSocket.OPEN) {
                ws.ping();
            }
        }, 10000);
    });

    ws.on('message', (data) => {
        try {
            const parsed = JSON.parse(data);
            handleData(name, parsed);
        } catch {
            // Parsing-Fehler ignorieren
        }
    });

    ws.on('close', () => {
        clearInterval(pingIntervals[name]);
        delete wsConnections[name];
        if (scriptStatus[name]) {
            setTimeout(() => connectWebSocket(name, ip), 5000);
        }
    });

    ws.on('error', () => {
        // Fehler ignorieren
    });
}

function disconnectWebSocket(name) {
    if (wsConnections[name]) {
        wsConnections[name].close();
        clearInterval(pingIntervals[name]);
        delete wsConnections[name];
        delete pingIntervals[name];
    }
}

function handleData(apName, parsedData) {
    const ap = accesspoints.find(a => a.name === apName);
    if (!ap || !scriptStatus[ap.name]) return;

    if (!parsedData.tags || !Array.isArray(parsedData.tags) || parsedData.tags.length === 0) return;

    parsedData.tags.forEach(tag => {
        if (!tag.mac) return;

        const macClean = tag.mac.replace(/:/g, '');
        const basePath = `${ap.buttonPathPrefix}.${macClean}`;

        ensureChannelExists(basePath, tag.alias || tag.name || 'Unbenannt', () => {
            if ('wakeupReason' in tag) {
                const statePath = `${basePath}.wakeupReason`;
                updateStateIfChanged(statePath, tag.wakeupReason);
            }
        });
    });
}

function ensureChannelExists(id, name, callback) {
    getObject(id, (err, obj) => {
        if (!obj) {
            setObject(id, {
                type: 'channel',
                common: { name: name },
                native: {}
            }, callback);
        } else {
            callback();
        }
    });
}

function updateStateIfChanged(id, value) {
    if (value === null || value === undefined) return;

    const isPrimitive = val => ['string', 'number', 'boolean'].includes(typeof val);

    let storedValue = value;
    let valueType = typeof value;

    if (!isPrimitive(value)) {
        try {
            storedValue = JSON.stringify(value);
            valueType = 'string';
        } catch {
            return;
        }
    }

    getState(id, (err, state) => {
        if (err || !state) {
            setObject(id, {
                type: 'state',
                common: {
                    name: id.split('.').pop(),
                    type: valueType,
                    role: 'value',
                    read: true,
                    write: false
                },
                native: {}
            }, () => setState(id, storedValue, true));
        } else if (state.val !== storedValue) {
            setState(id, storedValue, true);
        }
    });
}

Community Forum

NEWS

OpenEpaperLink - Script für Tastenabfrage

Support us

730

32.6k

82.0k

1.3m