Beiträge von Erforscht

Erforscht · 5. Dezember 2025

💡 Warum diese Platine mehrere LED-Streifen mit unterschiedlichen Spannungen gleichzeitig steuern kann

Diese Platine wurde absichtlich so entwickelt, dass man daran LED-Streifen mit völlig unterschiedlichen Betriebsspannungen gleichzeitig benutzen kann.

Das funktioniert, weil die Platinen-Ausgänge DATA1, DATA2 und DATA3 nur die Datensignale liefern,

aber keinen gemeinsamen Plus-Anschluss (VCC) haben.

👉 Die Plus-Pins bei DATA1 und DATA2 sind absichtlich nicht verbunden.

👉 Dadurch kann man verschiedene Spannungen anschließen, ohne dass sie sich gegenseitig zerstören.

⚡ Wie die Technik dahinter funktioniert

Für LED-Streifen ist nur eines wichtig:

✔ Plus (+) kommt IMMER direkt vom jeweiligen Netzteil

– unabhängig davon, ob es 5 V, 12 V oder 24 V sind.

✔ Minus (GND) muss zwischen LED-Streifen, Netzteil und Platine verbunden sein

– dadurch funktionieren die Datensignale korrekt.

✔ Das Datensignal kommt von DATA1 / DATA2 / DATA3

– die Platine liefert nur Daten, nicht die LED-Leistung.

Weil die Platine keinen Plus durchschleift, können sich verschiedene Spannungen auch nicht gegenseitig berühren.

Das macht das Ganze absolut sicher.

🔥 Warum das so sicher ist

Wenn Plusleitungen verbunden wären, würde z. B. eine 12-V-Versorgung sofort einen 5-V-Streifen zerstören.

Damit das nicht passieren kann:

❗ DATA1 und DATA2 haben keinen Plus

→ Sie sind stromlos, nur DATA + GND aktiv.

→ Keine Vermischung der Spannungsebenen möglich.

❗ DATA3 ist ebenfalls getrennt

→ eigener DATA-Kanal, eigene Stromversorgung.

🧠 Kurz gesagt:

die Platine liefert nur Datensignale
alle LED-Streifen bekommen ihre eigene Spannung direkt vom Netzteil
Minus (GND) wird gemeinsam genutzt
dadurch können 5 V, 12 V und 24 V gleichzeitig betrieben werden
ohne Risiko, ohne Kurzschluss, ohne Überlast

👉 Genau das war der Entwicklungszweck dieser Platine.

Erforscht · 5. Dezember 2025

⚡ Wichtige Hinweise zur Stromversorgung (links)

Auf der linken Schraubklemme gibt es drei Pins (von oben nach unten):

CC (oben)
GND (Mitte)
5V (unten)

Wenn man die Platine von unten anschaut, sieht man die Beschriftung.

🔋 1. CC (oben) – Eingang für Spannungen über 5 V

Hier wird alles zwischen 6 V und 30 V angeschlossen:

6 V
9 V
12 V
24 V
usw.

👉 Dieser Eingang geht direkt auf den Step-Down-Regler

👉 Der Regler erzeugt daraus interne stabile 5 V

Wichtig:

Der Step-Down kann nicht aus 5 V wieder 5 V machen.

Darum darf 5 V niemals auf CC angeschlossen werden.

🔋 2. GND (Mitte) – gemeinsamer Minuspol

Ist überall auf der Platine verbunden
Muss immer mit dem Minuspol des Netzteils verbunden werden
Wird auch für alle Datenleitungen geteilt (ESP, LED-Streifen usw.)

🔌 3. 5V (unten) – externer 5-Volt-Eingang

Dieser Anschluss ist nur dafür da, wenn man:

ein reines 5-Volt-Netzteil benutzt
keine höhere Spannung (12 V, 24 V …) verfügbar ist
und man möchte die Platine trotzdem betreiben

Wichtig:

Dieser Pin ist kein Ausgang, sondern ein Eingang
Hier wird NICHT die Last angeschlossen
Hier kommt nur die Versorgung für die Elektronik rein
Der Step-Down ist dann wirkungslos (weil 5 V rein = 5 V raus)

❗ Ganz wichtig: 5 V am unteren Pin sind NICHT für LED-Streifen gedacht

Wenn man oben z. B. 12 V einspeist, erzeugt der Step-Down unten 5 V —

aber:

👉 Diese 5 V sind nur für ESP32, Mikrofon und Logik

👉 Nicht für LED-Bänder!

👉 Nicht belastbar genug

👉 LED-Streifen können mehrere Ampere ziehen

Daher:

Niemals LED-Streifen an den 5V-Pin der Platine anschließen.
LED-Streifen immer direkt am Netzteil anschließen (5 V / 12 V / 24 V je nach Typ).

🎛 Anschlüsse rechts: DATA1 / DATA2 / DATA3

Jeder Datenanschluss hat drei Pins (von oben nach unten):

GND
DATA
VCC

Aber:

▶ DATA1 und DATA2

VCC ist nicht verbunden (absichtlich tot)
Nur GND und DATA sind aktiv
VCC dient nur als „Durchschleifpunkt“ für Kabel, aber führt keinen Strom

Warum „tote Pins“?

👉 damit keine hohe LED-Last über die Platine läuft

👉 alle LED-Streifen werden extern versorgt

▶ DATA3 (unten)

Hier ist RGB / WLED vorgesehen
DATA3 ist das echte Pixel-Signal
VCC bleibt trotzdem ungenutzt (Last gehört NICHT auf die Platine)

💡 Wie LED-Streifen korrekt angeschlossen werden

LED-Streifen werden immer direkt über ihr eigenes Netzteil versorgt.

Am DATA-Anschluss der Platine hängen gleichzeitig:

der LED-Streifen
und das passende Netzteil

Die Platine liefert nur das DATA-Signal, keinen Plus.

Darum können an DATA1, DATA2 und DATA3 auch verschiedene Spannungen gleichzeitig (z. B. 5 V, 12 V, 24 V) betrieben werden.

🔌 DATA1 – Beispiel 5-Volt-Streifen (z. B. WS2812B)

Am DATA1-Anschluss liegen also gleichzeitig LED-Streifen + Trafo:

VCC:
- +5 V vom Trafo → VCC
- +5 V vom LED-Streifen → ebenfalls an VCC
GND:
- GND vom Trafo → GND
- GND vom LED-Streifen → GND
DATA:
- DATA vom LED-Streifen → DATA1

Zusätzlich (meine Methode):

VCC von DATA1 → 5 V am linken Power-Eingang
GND von DATA1 → GND am linken Power-Eingang

➡ Damit bekommt die ganze Platine stabil 5 V.

➡ VCC ist sicher, weil DATA1 intern keinen Plus durchschleift.

🔌 DATA2 – Beispiel 12-Volt-Streifen gleichzeitig

Auch hier hängen LED-Streifen + Trafo gleichzeitig am DATA2-Anschluss:

VCC:
- +12 V vom Trafo → VCC
- +12 V vom LED-Streifen → ebenfalls an VCC
GND:
- GND vom Trafo → GND
- GND vom LED-Streifen → GND
DATA:
- DATA vom LED-Streifen → DATA2

Optional (aber ich mache es so):

GND von DATA2 → zusätzlich an GND vom Power-Eingang

➡ Muss nicht sein, denn GND ist intern überall verbunden,

➡ Aber es verteilt die Masse sauberer.

🔌 DATA3 – RGB / RGBW / CCT / 24-V-LEDs

Hier genauso:

+V vom passenden Trafo → +V LED-Streifen
GND vom passenden Trafo → zusätzlich an GND vom Power-Eingang
LED-Streifen R → Data3 R
LED-Streifen G → Data3 G
LED-Streifen B → Data3 B

➡ DATA3 unterstützt alles, was WLED kann.

🟢 Ganz kurz zusammengefasst für Anwender

CC oben = 6–30 V Eingang
GND = Minus MUSS immer mit allen GND die es gibt, verbunden sein. Also Trafos u.s.w. Sternenpunkt. Alles Zusammen.
5V unten = 5-Volt-Eingang (nur wenn man ein reines 5V-Netzteil hat)
Nie LED-Streifen über die Platine mit Strom versorgen
LED-Streifen immer direkt am Netzteil betreiben
DATA1/2 VCC sind absichtlich tot
DATA3 ist für adressierbare RGB-LEDs (z. B. CCT, RGB, Dimmbare LED u.s.w.)

Erforscht · 5. Dezember 2025

📘 Kurzanleitung – Bestückung der Platine (DIY-Lötset)

(ESP32 + Mikrofon jeweils mit Stiftleisten, Step-Down ohne Pins)

Alles bündig an Platine löten. Sonst passt es nicht in die Box.

🛠️ 1. Widerstände einlöten (R1–R8)

Alle Widerstände sind ungepolt.

✔ Diese drei zuerst (sie sitzen unter dem ESP32):

R6 – 10 kΩ
R7 – 10 kΩ
R8 – 10 kΩ

ESP32:

Stiftleisten in die Platine stecken (so bleiben sie gerade)
ESP32-Modul oben aufsetzen und keine Luft lassen. Also ganz runter auf die Platine. Er berührt fast die Widerstände.
Danach das Modul wie üblich festlöten

→ Dadurch sitzt der ESP32 exakt über R6–R8.

Dann die restlichen:

R1 – 100 Ω
R2 – 100 Ω
R3 – 20 Ω
R4 – 20 Ω
R5 – 20 Ω

→ Nach dem Löten Beinchen sauber abknipsen.

🔧 2. Kondensatoren

C1 – ca. 680 µF (Elektrolyt)
- Plus = längeres Bein
- Minus = markierter Streifen
C2 – ca. 100 nF (Keramik)
- keine Polung

🔌 3. Step-Down-Konverter vorbereiten (wichtig!)

Der Step-Down hat keine Stiftleisten.

Vier abgeschnittene Widerstandsbeinchen nehmen und von unten verlöten, sodass oben kein Lötzinn ist.
An die vier Pads löten: IN+, IN–, OUT+, OUT–
Beinchen gerade nach oben ausrichten
Step-Down-Modul durch die vier passenden Löcher der Platine stecken
Von unten verlöten
Überstände abschneiden

Damit sitzt der Regler stabil und plan auf der Platine.

📦 4. Stiftleisten an Mikrofon anlöten

(Immer die beiliegenden Stiftleisten verwenden)

Mikrofon-Modul:

Genau gleich: Stiftleisten anlöten und stecken
Dann verlöten

🔩 5. IC, Mosfet & Schraubklemmen

SN74HC125N einstecken (Kerbe nach links, wie auf Platine markiert)
Mosfets anlöten. Bündig an die Platine
Blaue Schraubklemmen einlöten
- Links: Stromversorgung
- Rechts: DATA1 / DATA2 / DATA3

✔ Fertig!

Die Platine ist komplett bestückt und einsatzbereit.

Erforscht · 28. November 2025

Benutzen auf eigene Gefahr.
Ein Abenteuer nicht verlieren Script.

Das installieren in Chrome

https://chromewebstore.google.…?utm_source=item-share-cb

oder

Das auf Firefox

https://addons.mozilla.org/en-US/firefox/addon/tampermonkey/

Auf die Erweiterung in Firefox klicken und

Dann das: Dort auf "Install the script" klicken

https://greasyfork.org/en/scripts/450693-herowarshelper

Spiel starten.

Bei Abenteuer angreifen. Wenn man verliert, noch nichts drücken.

Wenn ein "Auto" Button erscheint, den drücken.

Wenn eine Art "Liste" kommt, wo viel steht, dort auf "Abbrechen".

Danach auf "ok". Dann am besten raus aus Abenteuer und nochmal rein.

Wenn was steht mit "Erfolgreich/Erfolgt(oben)", auf den Button "ok" klicken.

Am besten dann auch einmal raus aus dem Abenteuer und wieder rein.

Erforscht · 27. November 2025

Erforscht · 5. November 2025

Erforscht · 22. Oktober 2025

🟦 WLED ESP32-Platine mit I2S-Mikrofon – universelle LED-Steuerung

Diese kompakte ESP32-Platine ist eine flexible All-in-One-Lösung für WLED.

Sie unterstützt nahezu alle LED-Typen – von adressierbaren Pixel-LEDs wie WS2812B / WS2815 bis hin zu RGB-, RGBW-, CCT- und klassischen Weiß-LED-Streifen.

Dank der drei getrennten Datenkanäle lassen sich sogar unterschiedliche Spannungen gleichzeitig betreiben (z. B. 5 V, 12 V und 24 V), ohne dass sich die Spannungen gegenseitig beeinflussen.

Das integrierte I2S-Mikrofon ist ein optionales Extra:

Damit können Musik-Visualisierungen und Sound-Reaktionen genutzt werden – alle normalen WLED-Funktionen wie Farben, Effekte, Animationen, Timer, Alexa-Steuerung usw. bleiben vollständig erhalten.

Kurz gesagt:

Eine universelle, saubere und sichere WLED-Steuerplatine, die sowohl einfache LED-Streifen als auch anspruchsvolle Pixel-Lichtinstallationen problemlos beherrscht.

Erforscht · 20. September 2025

Adv 1		Blue: 02,03,05,Boss(x2) Orange: 02,04,07,Boss(x2) Green: no
Adv 2		Blue: 03,06,09,Boss(x2) Orange: 02,05,08,09,Boss Green: 04,07,10,09,Boss
Adv 3		Blue: 04,12,13,Boss(x2) Orange: 05,06,09,Boss(x2) Green: 02,03,07,10-Boss
Adv 4		Blue: 02,04,07,18,08,12,19,22,Boss(x2) Orange: 05,24,25,09,14,13,20,22,Boss(x2) Green: 03,06,11,17,10,16,21,22,Boss(x2)
Adv 5		Blue: 05,09,10,14,17,20,27,25,21,Boss Orange: 04,06,10,11,15,19,18,Boss(x3) Green: 02,07,08,12,16,23,26,25,22
Adv 6		Blue: 02,04,07,10,13,16,19,24,22,Boss Orange: 05,07,08,11,14,17,20,23,Boss(x2) Green: 03,06,09,12,15,18,21,26,Boss(x2)
Adv 7		Blue: 08,01,11,12,15,12,11,21,25,Boss Orange: 11,10,14,17,13,19,20,24,Boss(x2) Green: 07,03,04,05,09,16,23,22,26,Boss
Adv 8		Blue: 03,02,06,07,09,10,13,17,16,20,22,21,28-Boss(x2) Orange: 03,05,07,09,11,14,18,20,22,24,27,30,26,29,25 Green: 03,04,08,07,09,11,15,19,20,22,23,31,Boss(x3)
Adv 9		Blue: 02,06,10,15,20,14,24,29,25,36,39,42,44,Boss(x2) Orange: 03,08,12,11,07,16,21,26,30,31,32,35,37,40,Boss Green: 03,04,13,19,18,23,17,22,38,41,43,46,Boss(x3)
Adv 10		Blue: 03,02,06,11,17,25,30,35,34,29,24,21,17,12,07 Orange: 04,08,13,18,22,26,31,36,40,45,44,43,38,33,28 Green: 05,09,14,19,23,27,32,37,42,48,51,50,49,46-Boss
Adv 11		Blue: 02,03,06,07,12,11,15,21,27,36,39,40,41,Boss(x2) Orange: 02,04,06,08,12,17,18,19,25,31,30,29,28,22,16 Green: 02,05,06,09,13,14,20,26,32,38,35,33,34,Boss(x2)
Adv 12		Blue: 09,03,06,10,22,31,36,35,29,34,29,30,21,13 Orange: 05,12,15,28,20,12,14,26,18,19,20,Boss(x4) Green: 08,02,04,07,16,23,32,33,25,24,17,11

Erforscht · 15. September 2025

Erforscht · 4. August 2025

HA Zonen-Generator (YAML & Lovelace)

Home Assistant Zonen-Generator

Gib unten deine Werte ein. Die YAML-Paketdatei und die Lovelace-Card werden live generiert – nur zum Kopieren, es wird nichts auf dem Server gespeichert.

Basis

Raumname

Sensor-Pfad komplett

Breite (cm)

Länge (cm)

Sensor X (cm von links)

Sensor Y (cm von unten)

Sensor Ausrichtung (0–359)

Stale (Sek., X/Y älter als …)

Zonen

ID wird automatisch aus dem Namen gebildet (Kleinbuchstaben, Unterstriche).

Paket-YAML (raum.yaml)

Lovelace-Card (room-visual-card)

Erforscht · 3. August 2025

!! Im Tool alles kleinschreiben. HA mag keine großen Buchstaben!!

!! Sonst wird nichts funktionieren !!

1. MQTT installieren

Einstellungen - Geräte und Dienste - Integration - Integration hinzufügen - MQTT - MQTT - Das offizielle Mosquitto Mqtt Broker Add-on verwenden

Integration - MQTT - hinzufügen.

2. File Editor installieren

Einstellungen - Addons - AddOnStore - FileEditor - installieren

Addons - FileEditor - In Seitenleiste anzeigen - starten

3. zigbee2mqtt installieren

Einstellungen - Addons - AddOnStore - oben rechts ⋮ - Repositories - https://github.com/zigbee2mqtt/hassio-zigbee2mqtt

F5 drücken

Zigbee2MQTT - installieren

In Seitenleiste anzeigen - starten - links Zigbee2MQTT - Stick einrichten. MQTT Einstellungen so lassen.

4. Ordner erstellen (wo die configuration.yaml ist). Also ganz "vorne". Da kommt "www" und "room" hin

File editor - + new Folder - "www" (/homeassistant/www)

+ new Folder - "room" (/homeassistant/room)

4.1 Dateien erstellen.

Ordner www öffnen und "New file" - room-visual-card.js

Code

class RoomVisualCard extends HTMLElement {
setConfig(config) {
if (!config.room) throw new Error("Bitte 'room' angeben (z. B. arbeitszimmer).");
this._config = config;
if (!this.shadowRoot) this.attachShadow({ mode: "open" });
this._build();
}
getCardSize() { return 5; }
_build() {
const root = this.shadowRoot;
root.innerHTML = `
<ha-card>
<style>
.wrap { padding: 8px; }
.canvas { position: relative; background:#f0f0f0; border:1px solid #ccc;
min-width:100px; min-height:100px; }
.dot { position:absolute; width:10px; height:10px; border-radius:50%;
transform:translate(-50%,-50%); }
.s1{ background:red; } .s2{ background:green; } .s3{ background:blue; }
.zone{ position:absolute; border:2px dashed; pointer-events:none; opacity:.15; }
.label{ position:absolute; left:3px; top:3px; font-size:12px; color:#000; }
</style>
<div class="wrap">
<div id="canvas" class="canvas"></div>
</div>
</ha-card>
`;
this._canvas = root.getElementById("canvas");
// Dots anlegen (immer 3 Slots)
this._dots = [1,2,3].map(i => {
const d = document.createElement("div");
d.className = `dot s${i}`;
d.id = `dot${i}`;
this._canvas.appendChild(d);
return d;
});
// Zonen anlegen (aus config.zones [{id, color, name?}] )
this._zones = {};
(this._config.zones || []).forEach(z => {
const div = document.createElement("div");
div.className = "zone";
div.style.borderColor = z.color || "orange";
div.style.background = z.color || "orange";
// Label
const span = document.createElement("span");
span.className = "label";
span.textContent = z.name || z.id;
div.appendChild(span);
div.id = `zone_${z.id}`;
this._canvas.appendChild(div);
this._zones[z.id] = div;
});
}
set hass(hass) {
this._hass = hass;
if (!this._config) return;
const room = this._config.room;
// Raumgröße (cm == px)
const w = this._num(`input_number.${room}_raumx`);
const h = this._num(`input_number.${room}_raumy`);
if (w && h) {
this._canvas.style.width = Math.round(w) + "px";
this._canvas.style.height = Math.round(h) + "px";
}
// Punkte (Slot 1..3) positionieren
[1,2,3].forEach((i, idx) => {
const x = this._num(`sensor.${room}_slot${i}_welt_x`);
const y = this._num(`sensor.${room}_slot${i}_welt_y`);
const el = this._dots[idx];
if (!el) return;
if ([x,y,h].some(v => v == null)) { el.style.display="none"; return; }
el.style.display = "block";
el.style.left = Math.round(x) + "px";
el.style.top = Math.round(h - y) + "px"; // unten->oben
});
// Zonen (per input_number.<room>_<id>_{x1,x2,y1,y2})
(this._config.zones || []).forEach(z => {
const el = this._zones[z.id];
if (!el) return;
const x1 = this._num(`input_number.${room}_${z.id}_x1`);
const x2 = this._num(`input_number.${room}_${z.id}_x2`);
const y1 = this._num(`input_number.${room}_${z.id}_y1`);
const y2 = this._num(`input_number.${room}_${z.id}_y2`);
if ([x1,x2,y1,y2,h].some(v => v == null)) { el.style.display="none"; return; }
el.style.display = "block";
const left = Math.min(x1, x2);
const top = h - Math.max(y1, y2);
el.style.left = Math.round(left) + "px";
el.style.top = Math.round(top) + "px";
el.style.width = Math.round(Math.abs(x2 - x1)) + "px";
el.style.height = Math.round(Math.abs(y2 - y1)) + "px";
});
}
_num(entityId) {
const s = this._hass?.states?.[entityId]?.state;
const v = parseFloat(s);
return Number.isFinite(v) ? v : null;
}
}
console.info('%croom-visual-card loaded', 'color: green; font-weight: bold');
if (!customElements.get('room-visual-card')) {
customElements.define('room-visual-card', RoomVisualCard);
} else {
console.warn('room-visual-card was already defined');
}

Alles anzeigen

4.2. /homeassistant/configuration.yaml bearbeiten

File Editor - ganz am anfang die configuration.yaml bearbeiten

Code

# Lade alle Packages unter /config/room
homeassistant:
packages: !include_dir_named room

578-pasted-from-clipboard-png

5. Bewegungsmelder in Z2M erkennbar machen

File Editor - /homeassistant/zigbee2mqtt - Ordner external_converters erstellen

Dort Datei LD2450_erforscht.js erstellen.

Code

'use strict';
// --- Converter für LD2450 ---------------------------------------------
const fzLD2450 = {
cluster: 'genAnalogInput',
type: ['attributeReport', 'readResponse'],
convert: (model, msg) => {
const ep = msg.endpoint.ID;
const val = msg.data.presentValue;
if (ep === 25) return { slot1_brightness: Math.round(val * 1000) / 1000 };
if (ep === 26) return { slot1_temperature: Math.round(val * 10) / 10 };
if (ep === 27) return { slot1_pressure: Math.round(val * 10) / 10 };
switch (ep) {
case 1: return { slot1_distance: val };
case 6: return { slot1_x: val };
case 7: return { slot1_y: val };
case 9: return { slot2_distance: val };
case 14: return { slot2_x: val };
case 15: return { slot2_y: val };
case 17: return { slot3_distance: val };
case 22: return { slot3_x: val };
case 23: return { slot3_y: val };
}
},
};
const exposes = require('zigbee-herdsman-converters/lib/exposes');
const ea = exposes.access; // Kurz-Alias
const eNumeric = exposes.numeric; // Fabrik-Funktion
module.exports = [{
zigbeeModel: ['LD2450'],
fingerprint: [{ manufacturerName: 'erforscht', modelID: 'LD2450' }],
model: 'LD2450_erforscht',
vendor: 'erforscht',
description: 'LD2450 12 endpoints',
meta: { multiEndpoint: true },
configure: async (device, coordinator) => {
const used = [1,6,7,9,14,15,17,22,23,25,26,27];
for (const ep of used) {
const endpoint = device.getEndpoint(ep);
if (!endpoint) continue;
try { await endpoint.bind('genAnalogInput', coordinator); } catch (_) {}
// schnelleres Reporting und einheitlicher Schwellwert wie in der iobroker-Vorlage
await endpoint.configureReporting('genAnalogInput', [{
attribute: 0x0055, // presentValue
minimumReportInterval: 1, // frühestens alle 1 s (vorher 5 s)
maximumReportInterval: 3600, // spätestens alle 1 h
reportableChange: 0.01, // 1 cm / 0.01 lx / 0.01 °C / 0.01 hPa
}]);
}
},
fromZigbee: [fzLD2450],
toZigbee: [],
exposes: [
eNumeric('slot1_distance', ea.STATE).withUnit('m') .withValueMin(0) .withValueMax(6),
eNumeric('slot1_x', ea.STATE).withUnit('m') .withValueMin(-6) .withValueMax(6),
eNumeric('slot1_y', ea.STATE).withUnit('m') .withValueMin(-6) .withValueMax(6),
eNumeric('slot1_brightness', ea.STATE).withUnit('lx') .withValueMin(0) .withValueMax(100000),
eNumeric('slot1_temperature', ea.STATE).withUnit('°C') .withValueMin(-40).withValueMax(85),
eNumeric('slot1_pressure', ea.STATE).withUnit('hPa') .withValueMin(300).withValueMax(1100),
// ergänzt: Grenzen wie in der iobroker-Version
eNumeric('slot2_distance', ea.STATE).withUnit('m') .withValueMin(0) .withValueMax(6),
eNumeric('slot2_x', ea.STATE).withUnit('m') .withValueMin(-6) .withValueMax(6),
eNumeric('slot2_y', ea.STATE).withUnit('m') .withValueMin(-6) .withValueMax(6),
eNumeric('slot3_distance', ea.STATE).withUnit('m') .withValueMin(0) .withValueMax(6),
eNumeric('slot3_x', ea.STATE).withUnit('m') .withValueMin(-6) .withValueMax(6),
eNumeric('slot3_y', ea.STATE).withUnit('m') .withValueMin(-6) .withValueMax(6),
],
}];

Alles anzeigen

6. Bewegungsmelder integrieren

Einstellung - Addons - Zigbee2MQTT - Neu Starten

Bewegungsmelder Updaten. ->

Zigbee2MQTT - Anlernen

Nach Integration vom BW dort auf das gelbe Kästchen klicken (neu konfigurieren). Dann kontrollieren. Auf den BW klicken - Details.

7. Zonen erstellen !!!WICHTIG!!! ALLES Kleinschreiben im Tool und generell IMMER in HA!!! Bei Missachtung funktioniert es nicht!!!

Die Datei herunterladen, entpacken und starten. Eventuell Windows Warnungen zulassen. --> create_ha_yaml.zip

Oder direkt hier erstellen im Form >klick_mich<

Sensor-Pfad sensor.xxxx nimmt man aus Entwicklerwerkzeug - Zustände. Dort sieht man den Sensor.

z.B. sensor.0x588c81fffe36a1dc_slot1_distance

Dann ist der Pfad es bis zum ersten Unterstrich. Nicht den Unterstrich mitnehmen. In dem Fall "sensor.0x588c81fffe36a1dc"

Es wird eine xxx.yaml erzeugt und eine xxx_visual_card.txt

in "room" kann man weitere Ordner erstellen. Ich würde z.b. den Ordner "arbeitszimmer" erstellen. Dort die yaml reinkopieren:

File editor - room - Order erstellen "arbeitszimmer" - Upload File - "arbeitszimmer.yaml" auswählen und uploaden.

8. Visuelle Ansicht

Einstellung - Dashboards - Dashboard hinzufügen

Neues Dashboard von Grund auf - Titel z.B. "Visualisierung"

öffnen - oben rechts "Bleistift" - in der Mitte "Abschnitt erstellen" - "Neuer Abschnitt +"

Ganz runterscrollen "Manuell" - den Text löschen "type: ""

Die xxx_visual_card.txt öffnen. Alles kopieren und dann einfügen. Speichern. Oben rechts "Fertig"

9. neu Starten

Entwicklerwerkzeuge - YAML - Konnfiguration Prüfen - Neu Starten - Home Assistant neu starten - neu starten

Visualisierung sieht man jetzt denn Raum. Fals nicht, 1x F5 drücken.

Fertig

10. Weitere Bewegungsmelder

Bei weiteren Bewegungsmelder: Anlernen - Wieder die beiden Dateien erstellen durch das Tool. Die yaml in "room" rein. Dann wieder wie in der

8. Visuelle Ansicht

einen neuen Abschnitt machen und den Inhalt der txt Datei einfügen. Oder weitere Dashboard hinzufügen. Freie Wahl.

Erforscht · 24. Juli 2025

Hier der Treiber für WiFi BT- WB01 AX900+Bluetooth5.4 driver.zip

Erforscht · 14. Juli 2025

Code

###############################################################################
# Paket: Arbeitszimmer Zonenerkennung mit eindeutigen Entity-IDs (korrigiert)
###############################################################################
input_number:
az_raumx:
name: Arbeitszimmer Breite
initial: 204
min: 0
max: 500
step: 1
unit_of_measurement: cm
az_raumy:
name: Arbeitszimmer Länge
initial: 379
min: 0
max: 500
step: 1
unit_of_measurement: cm
az_sensorx:
name: Sensor Position X
initial: 106
min: 0
max: 500
step: 1
unit_of_measurement: cm
az_sensory:
name: Sensor Position Y
initial: 379
min: 0
max: 500
step: 1
unit_of_measurement: cm
az_sensorz:
name: Sensor Ausrichtung
initial: 180
min: 0
max: 359
step: 1
unit_of_measurement: "°"
template:
# Template-Sensoren
sensors:
# — Slot1 Rohdaten in cm —
arbeitszimmer_slot1_x_cm:
friendly_name: "Arbeitszimmer Slot1 X cm"
unit_of_measurement: "cm"
value_template: >
{{ (states('sensor.0x588c81fffe302e7c_slot1_x')|float) * 100 }}
arbeitszimmer_slot1_y_cm:
friendly_name: "Arbeitszimmer Slot1 Y cm"
unit_of_measurement: "cm"
value_template: >
{{ (states('sensor.0x588c81fffe302e7c_slot1_y')|float) * 100 }}
# — Slot2 Rohdaten in cm —
arbeitszimmer_slot2_x_cm:
friendly_name: "Arbeitszimmer Slot2 X cm"
unit_of_measurement: "cm"
value_template: >
{{ (states('sensor.0x588c81fffe302e7c_slot2_x')|float) * 100 }}
arbeitszimmer_slot2_y_cm:
friendly_name: "Arbeitszimmer Slot2 Y cm"
unit_of_measurement: "cm"
value_template: >
{{ (states('sensor.0x588c81fffe302e7c_slot2_y')|float) * 100 }}
# — Slot3 Rohdaten in cm —
arbeitszimmer_slot3_x_cm:
friendly_name: "Arbeitszimmer Slot3 X cm"
unit_of_measurement: "cm"
value_template: >
{{ (states('sensor.0x588c81fffe302e7c_slot3_x')|float) * 100 }}
arbeitszimmer_slot3_y_cm:
friendly_name: "Arbeitszimmer Slot3 Y cm"
unit_of_measurement: "cm"
value_template: >
{{ (states('sensor.0x588c81fffe302e7c_slot3_y')|float) * 100 }}
# — Weltkoordinaten —
arbeitszimmer_slot1_welt_x:
friendly_name: "Arbeitszimmer Slot1 Welt X"
unit_of_measurement: "cm"
value_template: >
{% set rx = states('sensor.arbeitszimmer_slot1_x_cm')|float %}
{% set ry = states('sensor.arbeitszimmer_slot1_y_cm')|float %}
{% set theta = (states('input_number.az_sensorz')|float) * pi/180 %}
{{ (states('input_number.az_sensorx')|float + (rx * cos(theta) - ry * sin(theta))) | round(1) }}
arbeitszimmer_slot1_welt_y:
friendly_name: "Arbeitszimmer Slot1 Welt Y"
unit_of_measurement: "cm"
value_template: >
{% set rx = states('sensor.arbeitszimmer_slot1_x_cm')|float %}
{% set ry = states('sensor.arbeitszimmer_slot1_y_cm')|float %}
{% set theta = (states('input_number.az_sensorz')|float) * pi/180 %}
{{ (states('input_number.az_sensory')|float + (rx * sin(theta) + ry * cos(theta))) | round(1) }}
arbeitszimmer_slot2_welt_x:
friendly_name: "Arbeitszimmer Slot2 Welt X"
unit_of_measurement: "cm"
value_template: >
{% set rx = states('sensor.arbeitszimmer_slot2_x_cm')|float %}
{% set ry = states('sensor.arbeitszimmer_slot2_y_cm')|float %}
{% set theta = (states('input_number.az_sensorz')|float) * pi/180 %}
{{ (states('input_number.az_sensorx')|float + (rx * cos(theta) - ry * sin(theta))) | round(1) }}
arbeitszimmer_slot2_welt_y:
friendly_name: "Arbeitszimmer Slot2 Welt Y"
unit_of_measurement: "cm"
value_template: >
{% set rx = states('sensor.arbeitszimmer_slot2_x_cm')|float %}
{% set ry = states('sensor.arbeitszimmer_slot2_y_cm')|float %}
{% set theta = (states('input_number.az_sensorz')|float) * pi/180 %}
{{ (states('input_number.az_sensory')|float + (rx * sin(theta) + ry * cos(theta))) | round(1) }}
arbeitszimmer_slot3_welt_x:
friendly_name: "Arbeitszimmer Slot3 Welt X"
unit_of_measurement: "cm"
value_template: >
{% set rx = states('sensor.arbeitszimmer_slot3_x_cm')|float %}
{% set ry = states('sensor.arbeitszimmer_slot3_y_cm')|float %}
{% set theta = (states('input_number.az_sensorz')|float) * pi/180 %}
{{ (states('input_number.az_sensorx')|float + (rx * cos(theta) - ry * sin(theta))) | round(1) }}
arbeitszimmer_slot3_welt_y:
friendly_name: "Arbeitszimmer Slot3 Welt Y"
unit_of_measurement: "cm"
value_template: >
{% set rx = states('sensor.arbeitszimmer_slot3_x_cm')|float %}
{% set ry = states('sensor.arbeitszimmer_slot3_y_cm')|float %}
{% set theta = (states('input_number.az_sensorz')|float) * pi/180 %}
{{ (states('input_number.az_sensory')|float + (rx * sin(theta) + ry * cos(theta))) | round(1) }}
# Template-Binary-Sensoren
binary_sensors:
arbeitszimmer_schreibtisch:
friendly_name: "Arbeitszimmer Schreibtisch"
unique_id: arbeitszimmer_schreibtisch
device_class: motion
delay_off: "00:00:03"
value_template: >
{% set thresh = 0.1 %}
{% macro iz(x,y,b) -%}
{{ not (x|abs < thresh and y|abs < thresh)
and x>=b[0] and x<=b[1] and y>=b[2] and y<=b[3] }}
{%- endmacro %}
{% set b = [10,188,210,359] %}
{{ iz(states('sensor.arbeitszimmer_slot1_welt_x')|float,
states('sensor.arbeitszimmer_slot1_welt_y')|float, b)
or iz(states('sensor.arbeitszimmer_slot2_welt_x')|float,
states('sensor.arbeitszimmer_slot2_welt_y')|float, b)
or iz(states('sensor.arbeitszimmer_slot3_welt_x')|float,
states('sensor.arbeitszimmer_slot3_welt_y')|float, b) }}
arbeitszimmer_vorne_links:
friendly_name: "Arbeitszimmer Vorne Links"
unique_id: arbeitszimmer_vorne_links
device_class: motion
delay_off: "00:00:03"
value_template: >
{% set thresh = 0.1 %}
{% macro iz(x,y,b) -%}
{{ not (x|abs < thresh and y|abs < thresh)
and x>=b[0] and x<=b[1] and y>=b[2] and y<=b[3] }}
{%- endmacro %}
{% set b = [10,130,10,210] %}
{{ iz(states('sensor.arbeitszimmer_slot1_welt_x')|float,
states('sensor.arbeitszimmer_slot1_welt_y')|float, b)
or iz(states('sensor.arbeitszimmer_slot2_welt_x')|float,
states('sensor.arbeitszimmer_slot2_welt_y')|float, b)
or iz(states('sensor.arbeitszimmer_slot3_welt_x')|float,
states('sensor.arbeitszimmer_slot3_welt_y')|float, b) }}
arbeitszimmer_vorne_rechts:
friendly_name: "Arbeitszimmer Vorne Rechts"
unique_id: arbeitszimmer_vorne_rechts
device_class: motion
delay_off: "00:00:03"
value_template: >
{% set thresh = 0.1 %}
{% macro iz(x,y,b) -%}
{{ not (x|abs < thresh and y|abs < thresh)
and x>=b[0] and x<=b[1] and y>=b[2] and y<=b[3] }}
{%- endmacro %}
{% set b = [131,188,10,210] %}
{{ iz(states('sensor.arbeitszimmer_slot1_welt_x')|float,
states('sensor.arbeitszimmer_slot1_welt_y')|float, b)
or iz(states('sensor.arbeitszimmer_slot2_welt_x')|float,
states('sensor.arbeitszimmer_slot2_welt_y')|float, b)
or iz(states('sensor.arbeitszimmer_slot3_welt_x')|float,
states('sensor.arbeitszimmer_slot3_welt_y')|float, b) }}

Alles anzeigen

Erforscht · 12. Juli 2025

Zitat von RoboCop0815

Moin Moin …

Ich habe meinen Sensor auf 12 Uhr, ca. 240 cm Höhe und 45 ° Neigung angebracht. Der rote Punkt springt stark; je näher ich komme, desto weiter links (Treppe) werde ich angezeigt.

Das Problem lässt sich super-easy mit ChatGPT analysieren.

Ohne das wird mehr als schwer.

Man muss verstehen wie ein Radarsensor funktioniert.

Was es bedeutet, mitRadarwellen zu messen.

Wo die hin gehhen. Wie die hingehen.

Was passiert wenn die auf was treffen u.s.w.

ChatGPT gefragt:

"ich hab ein LD2450 mit einem esp32c6. Dort ist diese Script in iobroker als javasript integriert

(dann den code posten)

Dann habe ich deine Frage reinkopiert.

Das ist die Antwort:

CHATGPT:

Warum der Punkt springt & „nach links zieht“

Pitch-Fehler
Die LD2450 rechnet mit waagerechter Antenne. Bei 240 cm Höhe und 45 ° Neigung kippst du das ganze Koordinatensystem.
Effekt: Je näher die Person steht, desto stärker driftet der Punkt seitlich.
Übersteiler Winkel
- Zentralstrahl trifft den Boden schon nach 2,4 m (240 cm / tan 45°).
- Nähere Ziele nur noch im Randbereich ⇒ schwächeres Signal ⇒ Jitter.
Treppen-Reflexionen
Metallgeländer und Stufen erzeugen Mehrwege-Echos; der Tracker springt zwischen Echo-Peaks.

Besser aufhängen – zwei erprobte Varianten

Variante	Höhe	Neigung (↓)	Warum das hilft
A Decken-Sweet-Spot	220 – 240 cm	25 – 30 °	Zentralstrahl trifft Boden erst ≈ 4 m entfernt → kaum Totzone.
B Brust-/Kopfhöhe	130 – 150 cm	15 – 20 °	Frontale Sicht → beste Mikrobewegungs-Erkennung (stößanfälliger).

Zitat

Praxis-Regel
Tilt ≈ arctan(H / Y_Mitte)
Bei H = 240 cm und Y_Mitte ≈ 225 cm ergibt das ≈ 27 °.

Montage-Checkliste

Exakte Ausrichtung – Sensoroberkante parallel zur Flurwand, Pitch zuletzt einstellen.
Wand statt Decke (falls Treppe stört) – ≥ 20 cm Abstand zu den Stufen.
Reflexionen dämpfen – 20 × 40 cm Sperrholzblende hinter/unter dem Modul.
Kabelzug entkoppeln – Gummipuffer oder 3-D-Halter gegen Vibrationen.

Schritt-für-Schritt-Vorgehen

Neigung von 45 ° auf ≈ 28 ° stellen, Flur ablaufen → Punkt sollte mittig bleiben.
Driftet er noch? → Yaw feinjustieren (siehe Code unten) oder Sensorplatte drehen.
Jitter?
- Geländer testweise mit Pappe abdecken → wenn ruhiger, Blende montieren.
- Filter (Moving Avg / Kalman) erhöhen.
Grenzfälle prüfen (Treppenantritt, < 1 m vorm Sensor). Totzone < 1 m? → ok; sonst Tilt + 3 °.

Kurzantwort:
LD2450 am besten auf 230 cm Höhe mit ~28 ° Tilt montieren (oder 140 cm / 18 ° für Mikrobewegungen). Ausrichtung exakt einstellen und kleines Moving-Average-Filter aktivieren – schon ist das Hakeln weg.

1 · Fein-Yaw als separates Kalibrations-Feld

Statt die 3,5 ° direkt im Code zu verdrahten, leg sie als State an, damit du sie in VIS anpassen kannst:

Code

// --- NEU: in „Kalibrierung“ aufnehmen -------------
ensure(PREFIX + 'calibration.yawFine', 0,
{type:'number', read:true, write:true});

Dann im update() die Zeile

Code

const sz = rad(val(PREFIX + 'calibration.sensorZ') || 0);

ersetzen durch

Code

const sz = rad(
(val(PREFIX + 'calibration.sensorZ') || 0) +
(val(PREFIX + 'calibration.yawFine') || 0) // Fein-Offset
);

Jetzt kannst du den Winkel bequem in 0,1-°-Schritten nachtrimmen, bis der Punkt exakt mittig läuft.

2 · Sanftes Low-Pass-Filtering pro Slot

Der Rohwert-Jitter verschwindet, wenn du pro Slot eine exponentielle Glättung (EMA) machst.

Direkt oberhalb von function update(){ … } ein globales Objekt anlegen:

Code

// --- NEU: Filterpuffer -----------------------------------------------
const filters = {
1:{x:null,y:null}, 2:{x:null,y:null}, 3:{x:null,y:null}
};
const alpha = 0.30; // 0…1 (höher = schneller, niedriger = ruhiger)

Und im Slot-Loop nach const wY = sy + relY; einsetzen:

Code

/ Glättung -------------------------------------------------------------
const id = p.x.match(/slot([1-3])_x$/)[1]; // '1' | '2' | '3'
if(filters[id].x === null){ // erster Wert -> direkt
filters[id].x = wX; filters[id].y = wY;
}else{
filters[id].x = alpha * wX + (1-alpha) * filters[id].x;
filters[id].y = alpha * wY + (1-alpha) * filters[id].y;
}
const wXf = filters[id].x;
const wYf = filters[id].y;

Danach alle Verwendungen von wX/wY im Slot-Block auf wXf/wYf umstellen (Zonen-Check, Begrenzen & VIS-Position).

3 · Kleinst-Schwankungen ganz ausblenden

Gerade wenn du nah am Sensor stehst, schwanken X/Y manchmal um ±1 cm, obwohl du stillstehst.

Den Schwellenwert kannst du im bestehenden Parameter einfach etwas höher setzen:

Code

const EMPTY_THRESHOLD_M = 0.03; // 3 cm statt 1 cm

Damit werden „Pseudo-Leerwerte“ ignoriert und der Punkt bleibt sichtbar, statt ständig zu verschwinden.

Ergebnis

Yaw-Fehler korrigierbar, ohne neu zu flashen.
Sprungfreier Punkt dank EMA-Filter (30 % frisch, 70 % alt).
Geringe Flackerei entfällt, weil Mini-Schwankungen cm übersehen werden.

Zitat

Tipp: Wenn du noch mehr Ruhe möchtest, reduziere alpha z. B. auf 0,15.

Bei sehr schnellen Bewegungen (z. B. Rennen) dagegen auf 0,5 erhöhen.

Einfach die drei Abschnitte einbauen, Skript speichern, kurz neu laden – das war’s. Viel Erfolg beim Testen!

Ganzes script:

Code

/****************************************
* VIS-Punkt im Raum – mod. 2025-07-12
* Autor: ErForscht | Erweiterungen: ChatGPT
****************************************/
/* ---------- Einstellungen anpassen ---------- */
const ROOM = 'arbeitszimmer'; // ① ioBroker-Ordner
const DEVICE = 'zigbee.0.588c81fffe36c36c'; // ② Zigbee-Geräte-ID
const PREFIX = `javascript.0.${ROOM}.`; // ③ nicht ändern
/* ---------- Kalibrierungs-Default ---------- */
const calibrationDefaults = {
raumX: 200, // Raumbreite (cm)
raumY: 400, // Raumlänge (cm)
sensorX: 100, // Sensor X-Pos (cm)
sensorY: 400, // Sensor Y-Pos (cm)
sensorZ: 180, // Sensor Richtung (°)
yawFine: 0 // *** Fein-Yaw in ° (NEU)
};
/* ---------- Feintuning ---------- */
const debounceMs = 3000; // Verzögerung bis Zone false (ms)
const EMPTY_THRESHOLD_M = 0.03; // *** 3 cm statt 1 cm (NEU)
const alpha = 0.30; // *** EMA-Filter-Faktor (0…1)
/* ---------- Zonen ---------- */
const zones = [
{ name:'schreibtisch', color:'orange', x1:10, x2:188, y1:210, y2:359 },
{ name:'vorne links', color:'cyan', x1:10, x2:130, y1:10, y2:210 },
{ name:'vorne rechts', color:'green', x1:131, x2:188, y1:10, y2:210 },
];
/* ---------- State-Helper ---------- */
function ensure(id, def, opt){ if(!existsState(id)) createState(id, def, opt); }
function setAckChanged(id, val){
const o = getState(id);
if(!o || o.val !== val) setState(id, val, true);
}
/* ---------- Haupt-HTML-State ---------- */
ensure(PREFIX + 'widgetHtml', '', {type:'string', read:true, write:false});
/* ---------- Zonen-Boolean ---------- */
zones.forEach(z => ensure(PREFIX + 'zone.' + z.name, false,
{type:'boolean', read:true, write:false}));
/* ---------- Kalibrierungs-States ---------- */
['raumX','raumY','sensorX','sensorY','sensorZ','yawFine'].forEach(k => // ★ yawFine ergänzt
ensure(PREFIX + 'calibration.' + k,
calibrationDefaults[k],
{type:'number', read:true, write:true}));
/* ---------- Slot-Outputs ---------- */
['1','2','3'].forEach(n => {
ensure(PREFIX + `calibration.left${n}`, -100, {type:'number', read:true, write:false});
ensure(PREFIX + `calibration.top${n}`, -100, {type:'number', read:true, write:false});
});
/* ---------- Slot-Rohdaten ---------- */
const slots = ['1','2','3'].map((n,i) => ({
x: `${DEVICE}.slot${n}_x`,
y: `${DEVICE}.slot${n}_y`,
l: PREFIX + `calibration.left${n}`,
t: PREFIX + `calibration.top${n}`,
color: ['red','blue','green'][i]
}));
/* ---------- Utils ---------- */
const rad = d => d * Math.PI / 180;
const val = id => { const o = getState(id); return o ? Number(o.val) : null; };
const hide = p => { setAckChanged(p.l, -100); setAckChanged(p.t, -100); };
const offTimers = {};
const zoneBool = (name,v) => setAckChanged(PREFIX + 'zone.' + name, v);
const isEmptySlot = (x,y) => Math.abs(x) <= EMPTY_THRESHOLD_M && Math.abs(y) <= EMPTY_THRESHOLD_M;
/* ---------- EMA-Filter-Puffer (NEU) ---------- */
const filters = { 1:{x:null,y:null}, 2:{x:null,y:null}, 3:{x:null,y:null} };
/* ---------- Haupt-Update ---------- */
function update(){
/* --- Kalibrierwerte laden --- */
const roomX = val(PREFIX + 'calibration.raumX') || 1;
const roomY = val(PREFIX + 'calibration.raumY') || 1;
const sx = val(PREFIX + 'calibration.sensorX') || 0;
const sy = val(PREFIX + 'calibration.sensorY') || 0;
const yawFine = val(PREFIX + 'calibration.yawFine') || 0; // ★ neu
const sz = rad((val(PREFIX + 'calibration.sensorZ') || 0) + yawFine);
const occ = Object.fromEntries(zones.map(z => [z.name, false]));
/* --- Slots verarbeiten --- */
slots.forEach(p => {
if(!existsState(p.x) || !existsState(p.y)){ hide(p); return; }
const rx = val(p.x), ry = val(p.y);
if(rx === null || ry === null || isEmptySlot(rx,ry)){ hide(p); return; }
/* Rohdaten → cm */
const rawX = rx * 100;
const rawY = ry * 100;
/* Rotation auf Raum-Koordinaten */
const relX = rawX * Math.cos(sz) - rawY * Math.sin(sz);
const relY = rawX * Math.sin(sz) + rawY * Math.cos(sz);
/* Welt-Koordinaten */
const wX = sx + relX;
const wY = sy + relY;
/* -------- EMA-Glättung (NEU) -------- */
const idNum = p.x.match(/slot([1-3])_x$/)[1]; // '1' | '2' | '3'
const buf = filters[idNum];
if(buf.x === null){ // erster Wert
buf.x = wX; buf.y = wY;
}else{
buf.x = alpha * wX + (1 - alpha) * buf.x;
buf.y = alpha * wY + (1 - alpha) * buf.y;
}
const wXf = buf.x;
const wYf = buf.y;
/* ------------------------------------ */
/* Begrenzen & VIS-Position */
const cX = Math.max(0, Math.min(wXf, roomX));
const cY = Math.max(0, Math.min(wYf, roomY));
setAckChanged(p.l, +(cX / roomX * 100).toFixed(1));
setAckChanged(p.t, +((1 - cY / roomY) * 100).toFixed(1));
/* Zonen-Check */
zones.forEach(z => {
if(wXf >= z.x1 && wXf <= z.x2 && wYf >= z.y1 && wYf <= z.y2) occ[z.name] = true;
});
});
/* --- Boolean-Logik mit Timeout --- */
zones.forEach(z => {
const cur = getState(PREFIX + 'zone.' + z.name).val;
if(occ[z.name]){
if(!cur) zoneBool(z.name, true);
if(offTimers[z.name]){ clearTimeout(offTimers[z.name]); offTimers[z.name] = null; }
}else if(cur && !offTimers[z.name]){
offTimers[z.name] = setTimeout(() => {
zoneBool(z.name, false);
offTimers[z.name] = null;
}, debounceMs);
}
});
buildHtml(roomX, roomY);
}
/* ---------- HTML bauen ---------- */
function buildHtml(roomX, roomY){
const dots = slots.map(p => {
const l = getState(p.l).val, t = getState(p.t).val;
return `<div class="dot" style="background:${p.color};left:${l}%;top:${t}%"></div>`;
}).join('');
const rects = zones.map(z => {
const l = ((z.x1 / roomX) * 100).toFixed(1);
const t = ((1 - z.y2 / roomY) * 100).toFixed(1);
const w = (((z.x2 - z.x1) / roomX) * 100).toFixed(1);
const h = (((z.y2 - z.y1) / roomY) * 100).toFixed(1);
return `<div class="zone" style="border-color:${z.color};background:${z.color};
left:${l}%;top:${t}%;width:${w}%;height:${h}%"><span>${z.name}</span></div>`;
}).join('');
const html = `
<style>
.roomWrap{position:relative;width:100%;height:100%;border:2px solid #000;background:#eee;overflow:hidden}
.dot{position:absolute;width:16px;height:16px;border-radius:50%;transform:translate(-50%,-50%)}
.zone{position:absolute;pointer-events:none;border:2px dashed;opacity:.15}
.zone span{position:absolute;left:2px;top:2px;font-size:12px;color:#000}
</style>
<div class="roomWrap">${dots}${rects}</div>`;
setAckChanged(PREFIX + 'widgetHtml', html);
}
/* ---------- Trigger ---------- */
on([
PREFIX + 'calibration.raumX',
PREFIX + 'calibration.raumY',
PREFIX + 'calibration.sensorX',
PREFIX + 'calibration.sensorY',
PREFIX + 'calibration.sensorZ',
PREFIX + 'calibration.yawFine' // ★ neu
], update);
on({
id: new RegExp('^' + DEVICE.replace('.', '\\.') + '\\.slot[1-3]_[xy]$'),
change: 'any',
debounce: 200
}, update);
/* ---------- Initialer Aufruf ---------- */
update();

Alles anzeigen

Einbau-Checkliste

Im Skript-Editor des ioBroker einfügen und speichern.
1 · Schnellvariante – Wert im Admin setzen
1. Objekte-Tab öffnen.
2. Zu javascript.0.arbeitszimmer.calibration.yawFine navigieren
  
  (wird vom Skript automatisch angelegt).
3. Doppelklick auf den Wert → Gradzahl eintragen (z. B. 3.5) → Speichern.
Das Skript reagiert sofort, dein Punkt verschiebt sich live.

Ideal zum einmaligen Nachjustieren.
Optional alpha anpassen, falls du noch mehr (oder weniger) Glättung möchtest.

Damit bleiben Firmware & Datenpunkte unverändert – nur die Anzeige wird ruhiger und der Drift lässt sich live nachregeln. Viel Erfolg!

Erforscht · 9. Juli 2025

Zitat von RoboCop0815

moin und hallo,

ich habe probleme beim pairen in Zigbee.

Ich habe es mit der FW 1.07 und 1.06 ausprobiert.

Es fehlt Schritt 2. Da ist keine including.js integriert. Bitte so machen, wie in der Anleitung steht.

Erforscht · 15. Juni 2025

LD2450-Radar in Home Assistant + Zigbee2MQTT

>klick mich<

Erforscht · 13. Juni 2025

Firmware für den ESP32C6

!!! ACHTUNG !!!

!!! Immer wieder mal hier gucken, ob es updates gibt!!!!

Funktioniert nur mit meinen bearbeiteten ESP32C6 Modulen

Firmware Upgrade: upgrade 1.0.9.zip<- hier klicken. Unten sind nur ältere Versionen zum download

Runterladen und entpacken.

Dabei Antivirenprogramm und/oder Sicherheitshinweise zulassen von Windows.

Mit dem USB Kabel den ESP verbinden. Port CH343. Unter der Boot Taste. Wo das Loch ist zum Pairing

Die exe Datei ausführen und flashen.

In der exe ist auch ein Serial Monitor verbaut.

So kann man sehen, was das Gerät macht.

Die Firmware kann man nur mit den von mir bearbeiteten ESP32C6 Module nutzen.

Eigene funktionieren nicht.

Versionshistorie:

13.06.2025: Version 1.0.0.

02.07.2025: Version 1.0.1.

05.07.2025: Version 1.0.2. /// Lichtsensor Fix

05.07.2025: Version 1.0.3 /// BMP280 Hot Fix

05.07.2025: Version 1.0.4 /// blink led for pairing-hotfixes !!! Änderung der including.js. Einfach ersetzen und starten.

08.07.2025: Version 1.0.5 /// blink led for pairing-hotfixes + Button !!! Pairing nach Stromausfall fix

08.07.2025: Version 1.0.6 /// blink led for pairing-hotfixes + Button !!! Restart pairing fix

08.07.2025: Version 1.0.7 /// Restart pairing fix

02.08.2025: Version 1.0.8 /// Sendet jetzt nur noch pro x Sekunden. Wichtig!!= Zwingend Gerät löschen vorher=

Gerät löschen. Zigbee Adapter stoppen. Die including.js von oben kopieren und ersetzen im Javascript. Adapter starten. Das Gerät Updaten. Gerät anlernen u.s.w.
minimumReportInterval: 1, // frühestens alle 1 s = hier kann man einstellen, wann das Gerät senden soll in Sekunden

25.09.2025: Version 1.0.8 /// Script in IoBroker wurde geändert (Punkt 5.) Es passierte, dass was nicht auf false ging, wenn man schnell Raum verlässt.

const STALE_MS = 10000; // Slot gilt als "alt", wenn X/Y länger als 10s nicht aktualisiert. Bedeutet, wenn 10 Sekunden gar nichts passiert, geht es auf false.

const TICK_MS = 1000; // update()-Tick alle 1s, auch ohne neue Events.

07.10.2025: Version 1.0.8 /// Script in IoBroker wurde geändert (Punkt 5.) Position Sensor fix.

08.10.2025: Version 1.0.9 /// Firmware auf Router-Modus geändert. Kein Endgerät mehr, sondern wird zu Zigbee-Router und erweitert das Mesh-Netzwerk.

Erforscht · 19. Mai 2025

Alpha Phase
Erwerb Juni

ESP32-C6

Radarsensor mit bis zu 3 Ziele Erkennung gleichzeitig

Unbegrenzte Anzahl von Zonenerkennung über Javascript mit html integration

Helligkeitsanzeige in Lux
Optionaler Anschlussmöglichkeit für Temperatur und Druck Anzeige.

Bausatz für Bastler (ESP32-C6)

Elektronik-Bausatz mit 3m USB Kabel u. optionalem Gehäuse.

Auf Wunsch löte ich ihn privat fertig zusammen.

Platine ist Beigabe (ohne CE, keine Gewährleistung).

➡️ -->Kauflink für ca. 20,99€ - 27,99€<---

Aktuelles Projekt :

Ein auf dem ESP32-C6 basierendes Zigbee-Gerät mit angeschlossenem HLK-LD2450 3D-Radarsensor zur personenbasierten Präsenz- und Bewegungsanalyse – ideal für Smart Home Automation auf Raumebene.

Funktionen & Features:

Direkte Zigbee-Integration via eigener Firmware (ESP32-C6 + LD2450 per UART)
3 gleichzeitige Personen erkennbar mit Positionsdaten (X/Y), Abstand und Bewegungsrichtung
Zigbee-Datenpunkte: distance, x, y, velocity, valid, target_id, resolution – für alle Slots
Volle VIS-Unterstützung (ioBroker) mit HTML-Raumansicht:
- Echtzeit-Visualisierung der Person(en) im Raum
- Automatische Rotation des Koordinatensystems je nach Sensorlage
- Grafische Darstellung inkl. Zonenlogik, z. B. zur Licht- oder Heizungssteuerung

Besonderheiten:

Ideal für Multiraum-Setups: Jeder Raum mit einem Sensor möglich
Extrem geringe Latenz, keine Cloud nötig, läuft komplett lokal
Reduziert Fehlauslösungen gegenüber PIR oder mmWave deutlich
Perfekt erweiterbar mit ioBroker-Logik oder Blockly-Automationen
Anschluss eines LDR5528 (Lichtsensor) an PIN0. Dadurch Helligkeitsanzeige in Lux
Otional an PIN 21,22 Anschlussmöglichkeit eines BMP280
Unter Vollast ist der Stromverbrauch bei 5 V ca. 0,28 A (entspricht etwa 1,4 W Leistungsaufnahme)

Zusammenbau:

1. Erst den ESP von unten anlöten. Alle Pins an den ESP und danach alle Pins an die Platin!!!

Schön Luft lassen zwischen ESP und Platine. So wie im Bild die Stifte immer nur ein wenig rausragen lassen, zum anlöten.

Vor allem bei der Platine. Das da die Pins nicht weit rausgucken. Immer nur ein klein wenig. So das es halt reicht, zum anlöten.

2. Dann die Bauteile von oben an die schon verlöteten Pins mit dran anlöten.

Bedeutet, hier im Bild hab ich die Bauteile nur zur Veranschaulichung in die Löcher gesteckt.

In Wirklichkeit sind da ja schon die Pins vom ESP drin. Einfach an die Pins so mit anlöten.

Oberhalb der Platine werden die Bauteile so verlötet, das nichts direkt neben oder über dem Radarsensors sich was befindet.

Das würde den Sensor stören, da Radarwellen nicht Metall durchdringen kann.

3. Dann den Sensor draufstecken und von unten verlöten.

Je genauer der Sensor angelötet wird, um so besser.

Also nicht schief anlöten. Je perfekter er waagereicht und senkrecht und gleicher Abstand hat, um so genauer wird er messen.

!! FERTIG !!

LDR_PIN(Lichtsensor) an ESP -> 3,3V und ESP -> 0

10kOhm_Widerstand an ESP -> 0 und ESP -> GND

Optional(BMP280 3,3V muss selber gekauft werden):

BMP_SDA_PIN an ESP -> 21

BMP_SCL_PIN an ESP -> 22

BMP_VCC an ESP -> 3,3V

BMP_GND an ESP -> GND

Verwendete Komponenten:

ESP32-C6 https://amzn.to/4kdRQRx
HLK-LD2450 https://amzn.to/45ieN1a
LDR5528 https://amzn.to/3FLbLs4
10kOhm Widerstand https://amzn.to/45eAH5I
Optional BMP280 Sensor 3,3V https://amzn.to/4mPZMu3
Firmware und ioBroker-Anbindung komplett selbst entwickelt

Anleitung:

1.

Pairing Modus:

Pairing: wenn es blinkt, ist er im pairing modus.

Auf der Platine ist ein Loch zu sehen in der nähe vom USB Port.

Dort mit ein Stift 5 Sekunden drücken. Dann fängt es an zu blinken, für den Pairing Modus

2.

Javascript Adapter:

Kommando "exec" erlauben ein Häkchen setzen in der Adaptereinstellung

including.js erstellen durch javascript:

Das script erstellen und starten.

Dadurch wird in /opt/iobroker/iobroker-data/zigbee_0/ eine including.js Datei erstellt, was benötigt wird, das der Adapter das Gerät findet.

Falls nötig und der Adapter nicht standardmäßig installiert wurde ganz unten den Pfad anpassen:

fs.writeFile('/opt/iobroker/iobroker-data/zigbee_0/including.js', inhalt, (err) => {

Code

const fs = require('fs');
const inhalt = `"use strict";
// fzLD2450 direkt im File definieren → kein require nötig!
const fzLD2450 = {
cluster: "genAnalogInput",
type: ["attributeReport"],
convert: (model, msg) => {
const ep = msg.endpoint.ID;
const val = msg.data.presentValue;
if (ep === 25) return { slot1_brightness: Math.round(val * 1000) / 1000 };
if (ep === 26) return { slot1_temperature: Math.round(val * 10) / 10 };
if (ep === 27) return { slot1_pressure: Math.round(val * 10) / 10 };
switch (ep) {
case 1: return { slot1_distance: val };
case 6: return { slot1_x: val };
case 7: return { slot1_y: val };
case 9: return { slot2_distance: val };
case 14: return { slot2_x: val };
case 15: return { slot2_y: val };
case 17: return { slot3_distance: val };
case 22: return { slot3_x: val };
case 23: return { slot3_y: val };
}
},
};
// exposes helper
function numeric(property, access, unit, min, max) {
return {
type: "numeric",
property,
access,
unit,
value_min: min,
value_max: max,
};
}
// === FINALER EXPORT ===
module.exports = [{
zigbeeModel: ["LD2450"],
fingerprint: [{ manufacturerName: "erforscht", modelID: "LD2450" }],
model: "LD2450_erforscht",
vendor: "erforscht",
description: "LD2450 12 endpoints",
meta: { multiEndpoint: true },
configure: async (device, coordinator) => {
const used = [1,6,7,9,14,15,17,22,23,25,26,27];
for (const ep of used) {
const endpoint = device.getEndpoint(ep);
if (!endpoint) continue;
try { await endpoint.bind("genAnalogInput", coordinator); } catch (_) {}
const change =
[1,6,7,9,14,15,17,22,23].includes(ep)
? 0.01 // <<< Distanz/X/Y-Schwellwert in Metern (1 cm)
: 0.01; // <<< Lux/°C/hPa-Schwellwert
await endpoint.configureReporting("genAnalogInput", [{
attribute: 0x0055, // presentValue
minimumReportInterval: 1, // frühestens alle 1 s
maximumReportInterval: 3600, // spätestens alle 1 h
reportableChange: change, // siehe oben
}]);
}
},
fromZigbee: [fzLD2450],
toZigbee: [],
exposes: [
numeric("slot1_distance", 1, "m", 0, 6),
numeric("slot1_x", 1, "m", -6, 6),
numeric("slot1_y", 1, "m", -6, 6),
numeric("slot1_brightness", 1, "lx", 0, 100000),
numeric("slot1_temperature", 1, "°C", -40, 85),
numeric("slot1_pressure", 1, "hPa", 300, 1100),
numeric("slot2_distance", 1, "m", 0, 6),
numeric("slot2_x", 1, "m", -6, 6),
numeric("slot2_y", 1, "m", -6, 6),
numeric("slot3_distance", 1, "m", 0, 6),
numeric("slot3_x", 1, "m", -6, 6),
numeric("slot3_y", 1, "m", -6, 6),
],
}];
`;
fs.writeFile('/opt/iobroker/iobroker-data/zigbee_0/including.js', inhalt, (err) => {
if (err) {
console.error(`Fehler beim Schreiben der Datei: ${err.message}`);
} else {
console.log('including.js wurde erfolgreich erstellt / überschrieben.');
}
});

Alles anzeigen

3.

Im Zigbee Adapter including.js eintippen und den Adapter neu starten.

4.

Im Zigbee Adapter das Gerät anlernen.

Danach am Gerät im Zigbee Adapter auf den Namen klicken und dann auf den "reconfigure" Button.

Dadurch werden die Werte dauerhaft übermittelt.

5.

Für jeden Bewegungsmelder dieses Javasricpt erstellen im Javascript Adapter.

Im Script die Zonen u.s.w. einrichten und das script starten.

Dadurch werden Datenpunkte erstellt im Javascript Adapter selber.

Code

/****************************************
* VIS-Punkt im Raum
* Autor: ErForscht
*
* Raum:
* Es zählt immer die VIS Ansicht vom "Raum".
* raumX = die Breite in cm vom Raum
* raumY = die länge in cm vom Raum
*
* Sensor:
* Sensor Standort:
* sensorX = von links nach rechts in cm gemessen, wo der Sensor sich befindet.
* sensorY = von unteren nach oben in cm gemessen, wo der Sensor sich befindet.
*
* Sensor Ausrichtung:
* sensorZ = 0-359
* sensorZ= Der Raum ist eine Uhr. also oben 12 Uhr. Rechts 3uhr u.s.w. wo der Sensor "hinguckt"
* Wenn der Sensor: sensorZ: Er guckt von:
* Untere Wand 0 6 → 12 Uhr
* Rechte Wand 270 3 → 9 Uhr
* Obere Wand 180 12 → 6 Uhr
* Linke Wand 90 9 → 3 Uhr
*
* Zonen:
* name= Name der Zone
* color= Farbe der Zone. Es funktionieren alle Arten von Formeln
* color:'orange' oder '#FF5733' oder 'rgb(255,87,51)' oder 'hsl(9,100%,60%)' oder'var(--my-accent-color)'
** Um Fehler zu minimieren, ca. 10cm von Raumwänden Abstand lassen, wenn direkt von Wand eine Zone beginnen soll.
* x1= von links in cm gemessen bis Anfang des Bereiches
* x2= von links in cm gemessen bis Ende des Bereiches
* y1= von unten in cm gemessen bis Anfang des Bereiches
* y2= von unten in cm gemessen bis Ende des Bereiches
*
* ROOM = Datenordner Name.
* DEVICE = Datenpunkt Pfad zum Zigbee Sensor.
* PREFIX = Datenordner Pfad.
****************************************/
// -------- Einstellungen bitte anpassen--------
const ROOM = 'arbeitszimmer'; // ① ioBroker-Ordner
const DEVICE = 'zigbee.0.588c81fffe36be80'; // ② Zigbee-Geräte-ID des BWM
const PREFIX = `javascript.0.${ROOM}.`; // ② nicht ändern
// ---- Vorgabewerte für Kalibrierung ----
const calibrationDefaults = {
raumX: 204, // ① Raum breite z.B. 200 cm
raumY: 379, // ① Raum länge z.B. 400 cm
sensorX: 106, // ① Sensor Position von links in cm z.B. 100 cm
sensorY: 379, // ① Sensor Position von unten in cm z.B. 400 cm
sensorZ: 180 // ① z.B. 180° wenn er oben wäre und nach unten überwachen soll
};
const debounceMs = 5000; // ① Verzögerung bis Zone false wird (ms)
const EMPTY_THRESHOLD_M = 0.01; // ② Max. Abstand (1 cm) für leere Slots
const zones = [
{ name:'schreibtisch', color:'orange', x1:10, x2:188, y1:210, y2:359 },
{ name:'vorne links', color:'cyan', x1:10, x2:130, y1:10, y2:210 },
{ name:'vorne rechts', color:'green', x1:131, x2:188, y1:10, y2:210 },
];
/* === ADD: Stale-Handling (minimal) === */
const STALE_MS = 10000; // Slot gilt als "alt", wenn X/Y länger als 10s nicht aktualisiert
const TICK_MS = 1000; // update()-Tick alle 1s, auch ohne neue Events
const ageMs = (id) => {
const o = getState(id);
const t = o && (o.lc || o.ts);
return t ? (Date.now() - t) : Infinity;
};
// =====================================
// -------- State-Helper --------
function ensure(id, def, opt){ if(!existsState(id)) createState(id, def, opt); }
function setAckChanged(id, val){
const o = getState(id);
if(!o || o.val !== val) setState(id, val, true);
}
// Haupt-HTML-State
ensure(PREFIX + 'widgetHtml', '', {type:'string', read:true, write:false});
// Zonen-Boolean
zones.forEach(z => ensure(PREFIX + 'zone.' + z.name, false,
{type:'boolean', read:true, write:false}));
// Kalibrierung
['raumX','raumY','sensorX','sensorY','sensorZ'].forEach((k) =>
ensure(PREFIX + 'calibration.' + k,
calibrationDefaults[k],
{type:'number', read:true, write:true}));
// Slot-Outputs
['1','2','3'].forEach(n => {
ensure(PREFIX + `calibration.left${n}`, -100, {type:'number', read:true, write:false});
ensure(PREFIX + `calibration.top${n}`, -100, {type:'number', read:true, write:false});
});
// -------- Slot-Rohdaten (DEVICE-basiert) --------
const slots = ['1','2','3'].map((n,i) => ({
x: `${DEVICE}.slot${n}_x`,
y: `${DEVICE}.slot${n}_y`,
l: PREFIX + `calibration.left${n}`,
t: PREFIX + `calibration.top${n}`,
color: ['red','blue','green'][i]
}));
// -------- Utils --------
const rad = d => d * Math.PI / 180;
const val = id => { const o = getState(id); return o ? Number(o.val) : null; };
const hide = p => { setAckChanged(p.l, -100); setAckChanged(p.t, -100); };
const offTimers = {};
const zoneBool = (name,v) => setAckChanged(PREFIX + 'zone.' + name, v);
const isEmptySlot = (x,y) => Math.abs(x) <= EMPTY_THRESHOLD_M && Math.abs(y) <= EMPTY_THRESHOLD_M;
// -------- Haupt-Update --------
function update(){
const roomX = val(PREFIX + 'calibration.raumX') || 1;
const roomY = val(PREFIX + 'calibration.raumY') || 1;
const sx = val(PREFIX + 'calibration.sensorX') || 0;
const sy = val(PREFIX + 'calibration.sensorY') || 0;
const sz = rad(val(PREFIX + 'calibration.sensorZ') || 0);
const occ = Object.fromEntries(zones.map(z => [z.name, false]));
slots.forEach(p => {
if(!existsState(p.x) || !existsState(p.y)){ hide(p); return; }
/* === ADD: Stale-Prüfung pro Slot === */
const ax = ageMs(p.x), ay = ageMs(p.y);
if (ax > STALE_MS || ay > STALE_MS) { hide(p); return; }
/* =================================== */
const rx = val(p.x), ry = val(p.y);
if(rx === null || ry === null || isEmptySlot(rx,ry)){ hide(p); return; }
// Rohdaten → cm
const rawX = rx * 100, rawY = ry * 100;
// Rotation auf Raum-Koordinaten (Patch: Winkel gemäß "Raum-Uhr", clockwise)
// forward f = (sin z, cos z), right r = ( f_y, -f_x )
const fx = Math.sin(sz), fy = Math.cos(sz);
const rxv = fy, ryv = -fx;
const relX = rawX * rxv + rawY * fx;
const relY = rawX * ryv + rawY * fy;
// Weltkoordinaten
const wX = sx + relX;
const wY = sy + relY;
// Begrenzen & VIS-Position
const cX = Math.max(0, Math.min(wX, roomX));
const cY = Math.max(0, Math.min(wY, roomY));
setAckChanged(p.l, +(cX / roomX * 100).toFixed(1));
setAckChanged(p.t, +((1 - cY / roomY) * 100).toFixed(1));
// Zonen-Check
zones.forEach(z => {
if(wX >= z.x1 && wX <= z.x2 && wY >= z.y1 && wY <= z.y2) occ[z.name] = true;
});
});
// Boolean-Logik mit Timeout
zones.forEach(z => {
const cur = getState(PREFIX + 'zone.' + z.name).val;
if(occ[z.name]){
if(!cur) zoneBool(z.name, true);
if(offTimers[z.name]){ clearTimeout(offTimers[z.name]); offTimers[z.name] = null; }
}else{
if(cur && !offTimers[z.name]){
offTimers[z.name] = setTimeout(() => {
zoneBool(z.name, false);
offTimers[z.name] = null;
}, debounceMs);
}
}
});
buildHtml(roomX, roomY);
}
// -------- HTML bauen --------
function buildHtml(roomX, roomY){
const dots = slots.map(p => {
const l = getState(p.l).val, t = getState(p.t).val;
return `<div class="dot" style="background:${p.color};left:${l}%;top:${t}%"></div>`;
}).join('');
const rects = zones.map(z => {
const l = ((z.x1 / roomX) * 100).toFixed(1);
const t = ((1 - z.y2 / roomY) * 100).toFixed(1);
const w = (((z.x2 - z.x1) / roomX) * 100).toFixed(1);
const h = (((z.y2 - z.y1) / roomY) * 100).toFixed(1);
return `<div class="zone" style="border-color:${z.color};background:${z.color};
left:${l}%;top:${t}%;width:${w}%;height:${h}%"><span>${z.name}</span></div>`;
}).join('');
const html = `
<style>
.roomWrap{position:relative;width:100%;height:100%;border:2px solid #000;background:#eee;overflow:hidden}
.dot{position:absolute;width:16px;height:16px;border-radius:50%;transform:translate(-50%,-50%)}
.zone{position:absolute;pointer-events:none;border:2px dashed;opacity:.15}
.zone span{position:absolute;left:2px;top:2px;font-size:12px;color:#000}
</style>
<div class="roomWrap">${dots}${rects}</div>`;
setAckChanged(PREFIX + 'widgetHtml', html);
}
// -------- Trigger --------
on([
PREFIX + 'calibration.raumX',
PREFIX + 'calibration.raumY',
PREFIX + 'calibration.sensorX',
PREFIX + 'calibration.sensorY',
PREFIX + 'calibration.sensorZ'
], update);
on({
id: new RegExp('^' + DEVICE.replace('.', '\\.') + '\\.slot[1-3]_[xy]$'),
change: 'any',
debounce: 200
}, update);
// Initialer Aufruf
update();
/* === ADD: zyklischer Tick (minimal) === */
setInterval(update, TICK_MS);
// =======================================

Alles anzeigen

6.

Alle Datenpunkte, die erstellt wurden durch das Javascipt, mit den richtigen Daten bearbeiten/füllen.

Wie man das macht, steht am Anfang von Javascript.

7.

VIS html Widget Code erstellen und Datenpunktverknüpfung javascript.0.arbeitszimmer.widgetHtml anpassen:

1= HTML Widget

2= Hier den Quellcode reinkopieren

3= Raumbreite 1 px = 1cm

4= Raumlänge 1 px = 1 cm

Code

<!-- Text‑HTML Widget
Datenpunkt eintragen: javascript.0.wohnzimmer.widgetHtml
Checkbox „Interpret HTML“ aktiv (noEscape = false) -->
{javascript.0.arbeitszimmer.widgetHtml}

8. Fertig

Erforscht · 3. Mai 2025

LD2410 = https://amzn.to/3YsSmlQ

Online Flashen : https://tasmota.github.io/install/

Unofficial -> Tasmota All Sensors

Anschluss des Sensors mit 3,3V. Ich hab den kleinen quadratischen HLK-LD2410C. Beschrieben mit 5V. aber da spinnt er bei mir herum. Bei 3,3V läuft er perfekt.

In Tasmota:

Template:

GPIO vom ESP	Das Auswählen in Tasmota	An den LD2410
TX GPIOX	LD2410 Tx	RX
RX GPIOX	LD2410 Rx	TX
IO GPIOX	Switch1	OUT

Die GPIO's Anpassen X

In der Tasmota Console eingeben:

Code

SetOption115 1
SetOption19 1

Sonoff Adapter=

Automatische Erstellung von Zuständen

Für tele/SENSOR

Häkchen machen.

Datenpunkt:

POWER = true = Jemand Vorhanden

POWER = false = Keiner mehr da

Wert Bedeutung:

Distance[0] Entfernung zu Bewegung in cm

Distance[1] Entfernung zu ruhigem Objekt in cm

Distance[2] Erkennungsabstand (Detect Distance) Die größte Entfernung, bis zum Sensor prinzipiell Bewegung erkennen könnte (normalerweise die eingestellte Maximaldistanz in der Konfiguration). Viele Tasmota-Versionen setzen diesen Wert aber immer auf 0,0 cm, weil er nicht immer über die UART-Schnittstelle ausgegeben wird.

Energy[0] Wie stark ist die Bewegung (0–100)

Energy[1] Wie stark reflektiert ein statisches Objekt (0–100)

Falls Fehler:

Wenn Power / Switch dauern on/off geht, muss ein Widerstand eingebaut werden.

10kOhm Widerstand ein Ende an den ESP32 GPIO wo der "OUT" vom Sensor ran geht und das andere Ende an den GND vom ESP32

Erforscht · 19. April 2025

Ich habe diesen Dimmer umgebaut und steuere damit mein Warmwasserboiler an, der über Steckdose läuft (2500Watt Boiler).

Sobald Solar Überschuss ist, wird der Dimmer so gesteuert, das immer genullt wird.

z.b. wenn 300Watt Überschuss ist und normalerweise in das Netz eingespeist werden, werden diese 300Watt vom Dimmer an mein Boiler abgeben.

Da ich ein Shelly 3EM habe (3 Phasen Zähler) wird immer soviel in den Boiler eingespeist, wie Überschuss ist.

Das wird per Blockly erledigt.

Shelly 3EM = https://amzn.to/4jIQ1LL https://amzn.to/4jIQ1LL

3x aqy212eh= https://amzn.to/42mwmeX https://amzn.to/42mwmeX

1 Dimmer mit 10kw und 3 Taster = https://amzn.to/42pCNhm https://amzn.to/42pCNhm (Darauf achten, dass er 3 Taster hat)

3x 220Ohm Widerstände = https://amzn.to/4cJghDx https://amzn.to/4cJghDx

Verlängerungskabel 1,5 qmm = https://amzn.to/42QMwNz https://amzn.to/42QMwNz

Wemos D1 = https://amzn.to/3Gvtu6H https://amzn.to/3Gvtu6H

Code

<xml xmlns="https://developers.google.com/blockly/xml">
<variables>
<variable type="interval" id="Intervall">Intervall</variable>
</variables>
<block type="timeouts_setinterval" id="MC|snm(gc}3eX-Q(L.R9" x="162" y="-187">
<field name="NAME">Intervall</field>
<field name="INTERVAL">5</field>
<field name="UNIT">sec</field>
<statement name="STATEMENT">
<block type="controls_if" id="4,sW@eZw,}[lm+x#dR3e">
<value name="IF0">
<block type="logic_operation" id="9S*{$%6AK$%/?s4Nu#}(">
<field name="OP">AND</field>
<value name="A">
<block type="logic_compare" id="bBueLmg4J5_O=/rk:18E">
<field name="OP">GT</field>
<value name="A">
<block type="get_value" id="Ah[kGFXEu)`Ljl={/u0N">
<field name="ATTR">val</field>
<field name="OID">shelly.0.SHEM-3#BCFF4DFD1DAE#1.Total.InstantPower</field>
</block>
</value>
<value name="B">
<block type="math_number" id="#fmel6-Cx_a{$3-I|CdR">
<field name="NUM">0</field>
</block>
</value>
</block>
</value>
<value name="B">
<block type="logic_compare" id="?Cz#``b[3-{Y%R{e3ls^">
<field name="OP">EQ</field>
<value name="A">
<block type="get_value" id="}!:(]Uy/,Gc|v]URYl=9">
<field name="ATTR">val</field>
<field name="OID">sonoff.0.Solardimmer.alive</field>
</block>
</value>
<value name="B">
<block type="logic_boolean" id="78Nk=KWK9a6xTr*C.)Gl">
<field name="BOOL">TRUE</field>
</block>
</value>
</block>
</value>
</block>
</value>
<statement name="DO0">
<block type="comment" id="$3^8fI7@lI47x$v94=;D">
<field name="COMMENT">1% weniger</field>
<next>
<block type="control" id="5z/([-2XX{8uuhO{pIeG">
<mutation xmlns="http://www.w3.org/1999/xhtml" delay_input="false"></mutation>
<field name="OID">sonoff.0.Solardimmer.POWER3</field>
<field name="WITH_DELAY">FALSE</field>
<value name="VALUE">
<block type="logic_boolean" id="|$M^zZ{Rm,{XP~HCHCym">
<field name="BOOL">TRUE</field>
</block>
</value>
</block>
</next>
</block>
</statement>
<next>
<block type="controls_if" id=".EJS?nS5wj%|i=0(ZIKE">
<value name="IF0">
<block type="logic_operation" id="]+p#bc$5}o?l`g=D$T9{">
<field name="OP">AND</field>
<value name="A">
<block type="logic_compare" id="p@Dl#6uq^Mx44IPi*;-}">
<field name="OP">LT</field>
<value name="A">
<block type="get_value" id=":%/:1BEF.9Qj?*?+CYnH">
<field name="ATTR">val</field>
<field name="OID">shelly.0.SHEM-3#BCFF4DFD1DAE#1.Total.InstantPower</field>
</block>
</value>
<value name="B">
<block type="math_number" id="xdl#Y-]aU.SPF`$h*A$w">
<field name="NUM">50</field>
</block>
</value>
</block>
</value>
<value name="B">
<block type="logic_compare" id="t]hSKM0G:Z;p@i1F}@ql">
<field name="OP">EQ</field>
<value name="A">
<block type="get_value" id="/bqIn`x}Kl^x!MOcKW1~">
<field name="ATTR">val</field>
<field name="OID">sonoff.0.Solardimmer.alive</field>
</block>
</value>
<value name="B">
<block type="logic_boolean" id="Ac*qdTgEDJ?3V]wiRqml">
<field name="BOOL">TRUE</field>
</block>
</value>
</block>
</value>
</block>
</value>
<statement name="DO0">
<block type="comment" id="PFXco5F0ca8lRIjrcp^X">
<field name="COMMENT">1% mehr</field>
<next>
<block type="control" id="O3TcHG%O^gO#]ofS0u5D">
<mutation xmlns="http://www.w3.org/1999/xhtml" delay_input="false"></mutation>
<field name="OID">sonoff.0.Solardimmer.POWER1</field>
<field name="WITH_DELAY">FALSE</field>
<value name="VALUE">
<block type="logic_boolean" id="e2UAcC^Ep!(v-ou3gug;">
<field name="BOOL">TRUE</field>
</block>
</value>
</block>
</next>
</block>
</statement>
</block>
</next>
</block>
</statement>
</block>
</xml>

Alles anzeigen

Tasmota Template:

Code

{"NAME":"SolarDimmer","GPIO":[1,1,1,1,1,1,1,1,225,226,224,1,1,1],"FLAG":0,"BASE":18}