Bewegungsmelder Frage

RoboCop0815 · 9. Juli 2025

moin und hallo,

ich habe probleme beim pairen in Zigbee.

Ich habe es mit der FW 1.07 und 1.06 ausprobiert.

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.

RoboCop0815 · 9. Juli 2025

Danke für die Antwort:

Ich habe alles so gemacht wie beschrieben, nur habe ich ein Master/Slave System und das Srcipt erstellt die Datei auf dem Master.

Nun habe ich die Datei auf den Slave kopiert, aber auch kein Erfolg

Dann habe ich in der Zigbee Instanz den kompletten Pfad eingegeben zu der including.js und siehe da....

scheint so als ob ich jetzt weiter machen kann...

Danke für die Hilfe.

RoboCop0815 · 11. Juli 2025

Moin Moin...

Ich habe meinen Sensor im Raum auf 12 Uhr und ca. 240cm Höhe, im 45° Winkel angebracht und habe Probleme das der "rote Punkt" sehr viel springt und je näher ich dem Senor komme um so weiter links, im Treppen Bereich (ist auch eine Treppe) werde ich angezeigt. Auf dem 2. Bild stehe ich immer noch mittig im Flur.

Wo soll ich den Sensor denn am besten anbringen?

// ---- Vorgabewerte für Kalibrierung ----
const calibrationDefaults = {
raumX: 240, // ① Raum breite z.B. 200 cm
raumY: 450, // ① Raum länge z.B. 400 cm
sensorX: 120, // ① Sensor Position von links in cm z.B. 100 cm
sensorY: 440, // ① 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
};

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 · 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

Warum der Punkt springt & „nach links zieht“

Besser aufhängen – zwei erprobte Varianten

Montage-Checkliste

Schritt-für-Schritt-Vorgehen

1 · Fein-Yaw als separates Kalibrations-Feld

2 · Sanftes Low-Pass-Filtering pro Slot

3 · Kleinst-Schwankungen ganz ausblenden

Ergebnis

Teilen