Neuer Installer und neuer Fixer: übersichtliche Oberfläche und `iob docker`

[paul53]

@oliverio sagte: wohl auch den anderen neueren handys) funktioniert der ping adapter nicht zuverlässig

Das kann ich nicht bestätigen (Galaxy A41): Wird zuverlässig mit dem Ping-Adapter erkannt.

[OliverIO]

@paul53 sagte in Anwesenheitserkennung mit Hping3:

@oliverio sagte: wohl auch den anderen neueren handys) funktioniert der ping adapter nicht zuverlässig

Das kann ich nicht bestätigen (Galaxy A41): Wird zuverlässig mit dem Ping-Adapter erkannt.

ja denk ich mir, sonst hätte es schon mehr diskussion gegeben. aber meine iphones bisher nicht. sobald die in den schlafmodus gehen, sind sie weg.
schlafmodus ist nicht gleich bidschirmsperre und bildschirm aus. apple scheint da eine gewisse logik zu haben, bei dem sie die schlaf-intervalle immer mehr verlängern. in der nacht mehr wie tagsüber.

[OliverIO]

@jupp991 sagte in Anwesenheitserkennung mit Hping3:

@oliverio
die abfrage macht der jetzt wie gewollt jede 60 sek. Lag anscheinend an der Berechtigung. Mit 775 funktioniert die abfrage jetzt. Was mich nur wundert: ich bin seit 10 min nicht mehr im Wlan trotzdem werde ich als anwesend gekennzeichnet.

ich habe mal das skript erweitert.
füge direkt vor der zeile mit dem hping 3 folgendes ein

ping $i -c 1

dadurch funktioniert die "not present" Erkennung dann immer beim übernächsten start zuverlässig.

[Jupp991]

@oliverio
Jetzt klappt es. Vielen dank =)

[OliverIO]

Ich habe mal das Anwesenheitsscript mit hping3 überarbeitet, das ohne zusätzliche installation von hping3 auskommt.
da der ping adapter, der hping3 ebenfalls nutzt nur eine globale zeitvorgabe für alle geräte hat, wollte ich den dafür nicht verwenden.

für den suchindex des forums:
Anwesenheit, Apple, iphone, ipad, ping

das folgende skript habe ich erfolgreich erprobt.
zu beginn muss man zumindest die ip-adressen seiner apple geräte eintragen und ggfs den Hauptdatenpunkt unter dem dann die states angelegt und geändert werden.
Für Apple-Geräte gilt der Port 5353 (Multicast DNS) welcher für Airplay wichtig ist.
Das Skript kann ggfs auch für Geräte von anderen Herstellern verwendet werden. Dazu ist ggfs der Port anzupassen.

der hping3 befehl wird jetzt rein nur durch node befehle nachgebildet (zumindest was den udp burst angeht)
Ausserdem wurde das logging etwas verbessert.

Habe ich jetzt nicht ausführlich getestet:
aber auf den apple geräten sollte in der WLAN Einstellung die Beschränkung des IP-Trackings deaktiviert werden, falls es Probleme gibt.

Selbstverständlich sollte der router so konfiguriert werden, das die Geräte immer die gleiche IP-Adresse erhalten.
Das verwendete Paket node:dgram muss nicht extra installiert werden, es ist direkt in node verfügbar.

Grobe Funktionsweise:
für jedes Gerät wird auf dem angegebenen Port relativ schnell hintereinander ein UDP Paket gesendet. Das lässt das Gerät aus einem gewissen Tiefschlaf aucwachen. Apple optimiert die Batterieleistung so, das bestimmte Komponenten in ein Schlafmodus mit geringerer Energieaufnahme versetzt wird. Das kann uU auch passieren wenn auch der Bildschirm noch an ist (nur das man sich das besser vorstellen kann)
Ein anderer Gerätestatus kann uU auch diese Meldung nicht mehr "aufwecken", bspw im Stromsparmodus.

Wenn der burst gesendet wurde wird kurze Zeit gewartet und per PING abgefragt ob das Gerät antwortet.
Aus dem Ergebnis wird dann die Anwesenheit interpretiert.

Aktuell ist über die SCHEDULE Variable alle 5 Minuten eingestellt.
Zu kurz würde ich es nicht einstellen, da das wiederum einen höheren Energieverbrauch erzeugt. Aber bisher gab es auch beim alten Skript hier keine nennenswerte negative Erfahrungen.
Ist halt immer eine Frage, wie fein aufgelöst man die Anwesenheit haben möchte.

const dgram = require("node:dgram");

// ------------------------------------------------------------
// Konfiguration
// ------------------------------------------------------------

const DEVICES = [
    "192.168.1.216",
    "192.168.1.217"
];

const UDP_PORT = 5353;
const UDP_COUNT = 10;

// Wartezeit zwischen UDP-Burst und Ping
const AFTER_BURST_WAIT = 1000;

// Abstand zwischen den Geräten
const DEVICE_WAIT = 1000;

// Alle 5 Minuten prüfen
const SCHEDULE = "*/5 * * * *";

const STATE_BASE = "0_userdata.0.AnwesenheitNeu";


// ------------------------------------------------------------
// Allgemeine Hilfsfunktionen
// ------------------------------------------------------------

function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}


function isValidIPv4(ip) {

    const parts = ip.split(".");

    return parts.length === 4 &&
        parts.every(part =>
            /^\d+$/.test(part) &&
            Number(part) >= 0 &&
            Number(part) <= 255
        );
}


function getStateId(ip) {
    return `${STATE_BASE}.${ip.replace(/\./g, "-")}`;
}


// ------------------------------------------------------------
// Datenpunkte anlegen
// ------------------------------------------------------------

async function ensureState(ip) {

    const stateId = getStateId(ip);

    if (existsState(stateId)) {
        return;
    }

    log(`Lege Datenpunkt ${stateId} an`, "info");

    await createStateAsync(
        stateId,
        false,
        {
            name: `Anwesenheit ${ip}`,
            type: "boolean",
            role: "indicator.presence",
            read: true,
            write: true,
            def: false
        }
    );
}


async function ensureStates() {

    for (const ip of DEVICES) {

        if (!isValidIPv4(ip)) {
            log(`Ungültige IP: ${ip}`, "error");
            continue;
        }

        await ensureState(ip);
    }
}


// ------------------------------------------------------------
// UDP-Burst
// ------------------------------------------------------------

/*
 * Entspricht für unseren Zweck ungefähr:
 *
 * hping3 -2 -c 10 -p 5353 -i u1 -q <IP>
 */
async function sendUdpBurst(host) {

    const socket = dgram.createSocket("udp4");
    const payload = Buffer.alloc(0);

    try {

        for (let i = 0; i < UDP_COUNT; i++) {

            await new Promise((resolve, reject) => {

                socket.send(
                    payload,
                    UDP_PORT,
                    host,
                    err => {
                        if (err) {
                            reject(err);
                        } else {
                            resolve();
                        }
                    }
                );

            });

        }

    } finally {

        socket.close();

    }
}


// ------------------------------------------------------------
// Ping
// ------------------------------------------------------------

function pingDevice(ip) {

    return new Promise(resolve => {

        /*
         * -c 1
         *   genau ein Ping
         *
         * -W 1
         *   maximal 1 Sekunde auf Antwort warten
         */

        exec(
            `ping -c 1 -W 1 ${ip}`,
            (error, stdout, stderr) => {

                if (error) {

                    log(
                        `${ip}: Ping nicht erfolgreich`,
                        "debug"
                    );

                    resolve(false);
                    return;
                }


                /*
                 * exit code 0 bedeutet:
                 * Ping war erfolgreich.
                 */

                log(
                    `${ip}: Ping erfolgreich`,
                    "debug"
                );

                resolve(true);
            }
        );

    });
}


// ------------------------------------------------------------
// Gerät prüfen
// ------------------------------------------------------------

async function checkDevice(ip) {

    if (!isValidIPv4(ip)) {

        log(
            `Ungültige IP-Adresse: ${ip}`,
            "error"
        );

        return;
    }


    const stateId = getStateId(ip);

    await ensureState(ip);


    log(
        `Prüfe ${ip} ...`,
        "debug"
    );


    // --------------------------------------------------------
    // 1. UDP-Burst
    // --------------------------------------------------------

    try {

        await sendUdpBurst(ip);

        log(
            `${ip}: UDP-Burst gesendet`,
            "debug"
        );

    } catch (err) {

        /*
         * Ein Fehler beim UDP-Versand entscheidet noch
         * nicht über die Anwesenheit.
         *
         * Entscheidend ist ausschließlich der spätere Ping.
         */

        log(
            `${ip}: UDP-Fehler: ${err}`,
            "debug"
        );

    }


    // --------------------------------------------------------
    // 2. Kurz warten
    // --------------------------------------------------------

    await sleep(AFTER_BURST_WAIT);


    // --------------------------------------------------------
    // 3. Ping
    // --------------------------------------------------------

    const present = await pingDevice(ip);


    // --------------------------------------------------------
    // 4. Ergebnis
    // --------------------------------------------------------

    if (present) {

        log(
            `Phone ${ip} is detected!`,
            "info"
        );

    } else {

        log(
            `Phone ${ip} is not present`,
            "info"
        );

    }


    // --------------------------------------------------------
    // 5. ioBroker-State setzen
    // --------------------------------------------------------

    await setStateAsync(
        stateId,
        present,
        true
    );
}


// ------------------------------------------------------------
// Alle Geräte prüfen
// ------------------------------------------------------------

async function checkDevices() {

    for (const ip of DEVICES) {

        await checkDevice(ip);

        await sleep(DEVICE_WAIT);

    }
}


// ------------------------------------------------------------
// Start
// ------------------------------------------------------------

async function main() {

    // Datenpunkte anlegen
    await ensureStates();


    // Direkt beim Start einmal prüfen
    await checkDevices();


    // Danach alle 5 Minuten
    schedule(SCHEDULE, async () => {

        try {

            await checkDevices();

        } catch (err) {

            log(
                `Fehler bei Anwesenheitsprüfung: ${err}`,
                "error"
            );

        }

    });
}


main().catch(err => {

    log(
        `Fehler beim Start: ${err}`,
        "error"
    );

});

[Michael Schmitt]

Dann teste ich das mal in Verbindung mit meinem Script. Leider hat Junior ein Iphone und nur das zickt rum, aber mit meinem (Claude) Script und Ping Adapter hat das schon gut funktioniert. Jetzt werde ich den "Burst" noch zusätzlich mit benutzen

[OliverIO]

@Michael-Schmitt

super
mit den iphones funktioniert das hier gut.
das ipad hat wohl intern andere energieeinstellungen.
das meldet sich dennoch irgendwann mal ab.
aber das bewegt sich hier auch nicht wirklich weg

hab mal das als Änderung beim pin adapter eingereicht.

[Michael Schmitt]

leider bekommt man auch damit nicht "immer" das IPhone zum aufwecken :(

[OliverIO]

@Michael-Schmitt

Ich vermute mal, wenn der ladestand unter ein gewisses Level fällt, dann reagiert das Telefon auch darauf nicht mehr.

Die Handys bekommen immer mehr Komponenten, sollen kleiner/flacher werden. An der energiedichte von Lithium Ionen lässts sich aber nichts ändern.

[Michael Schmitt]

mit meinem zweiten Script kann ich das ständige flapping zum Glück so abfangen das ich nicht ständig Telegram Meldungen bekomme mit online offline oder das selbe in Iqontrol passiert.