Der neue Monatsrückblick für September 2026 ist online!

[paul53]

@jupp991 sagte: Anwesenheitserkennung mit Hping3

Funktioniert der Ping-Adapter nicht?

[Jupp991]

@paul53
genau.

wenn ich manuell per Putty anfrage ja, aber automatisch nicht.

[OliverIO]

@jupp991 sagte in Anwesenheitserkennung mit Hping3:

@oliverio
Okay sorry.

IphoneD_sh.txt
Anwesenheitsabfrage.txt
Alarmanlage einschalten.txt

Wir sind relativ lange Arbeiten und abends bzw. über Nacht sind die Handy immer am laden.

ok
folgende anmerkungen
das schedule reicht wenn du * * * * *
das /1 kannst du weglassen nur mit stern ist schon jede minute
bei mir läuft es.
etwas hat mich die adresse deiner curl-anweisung gewundert. 8082 ist normalerweise vis. der befehl sieht nach simple-api aus, der ist bei mir auf 8087.

daher kann es nur noch die berechtigung sein.

öffne am besten mal eine shell und gebe dort

su iobroker

ein und versuche dann das iphoned.sh skript zu starten
ich schätze das wird nicht funktionieren.
dann solltest du die Ausführungsberechtigung der Datei setzen.
ich habe die bei mir mal auf 775 gesetzt.
wenn es immer noch geht, dann ändere den eigentümer auf iobroker

[OliverIO]

@paul53 sagte in Anwesenheitserkennung mit Hping3:

@jupp991 sagte: Anwesenheitserkennung mit Hping3

Funktioniert der Ping-Adapter nicht?

bei iphone (und wohl auch den anderen neueren handys) funktioniert der ping adapter nicht zuverlässig, da die handys in den tiefschlaf geschickt werden und da nur noch auf ganz wenig netzwerk signale reagieren.
ein so eingeschlafenes handy ist dann nicht mehr anwesend.
daher wird hier hping3 verwendet, da darauf mit diesen einstellungen zumindest apple-geräte reagieren und aufwachen.

warum hier viele noch mit dem ping-adapter zurecht kommen ist mir schleierhaft, aber es wird wohl so sein.

[Wal]

@oliverio sagte in Anwesenheitserkennung mit Hping3:

hping3

Es dürfte doch kein Problem sein den Ping-Adapter auf Hping3 umzustellen, einfach den Adapter-Maintainer mal kontaktieren.

[Jupp991]

@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.

[OliverIO]

@jupp991 ja hatte ich auch. das hängt mit der verwaltung der arp tables in den netzwerkgeräten zusammen.
um sie sofort dazu zu aktualisieren, musst du mit normalen ping anpingen, dann kommt nicht erreichbar, dann erkennt hping3 ebenfalls das das gerät nicht mehr da ist.
ansonsten muss man auf das timeout der arp table warten. das kann bei verschiedenen geräten unterschiedlich sein.

[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.