Arduino-Bastelei: Wer da?

Es war nur so eine spontane Idee, eines späten Abends bereits im liegend und auf die Rückkehr eines der streunenden Kinder geboren: Wie wäre es, wenn man zuhause sehr einfach sehen könnte, welches Familienmitglied sich noch bzw. schon zuhause befindet und welches nicht? Nicht, dass unser Haus so unübersichtlich wäre, dass das nicht irgendwie herauszufinden wäre, aber praktisch wäre eine Art Anzeige oder Display schon. Weiteres Beispiel: Ich komme spät vom Volleyballtraining heim und setzte mich noch im Arbeitszimmer an den Rechner, einen Blogpost schreiben, etwas basteln, Bass spielen oder was auch immer. Es wird spät und später. Die Gattin schreckt irgendwann aus dem Schlaf hoch und wundert sich, dass ich noch nicht da bin. Sie macht sich Sorgen: Wenn er jetzt noch immer nicht da ist könnte er sich verletzt haben und… Könnte sie jetzt im Bett liegend direkt sehen, wer zuhause ist, müsste sie sich nur umdrehen und könnte entspannt weiter schlafen. Oder so.

So etwas zu bauen sollte kein Problem sein, tönte ich irgendwann im Übermut. Tatsächlich war im Geheimen recht schnell ein funktionierender Prototyp zusammengeschustert. Der Weg hin zu einem ansehlichen Gerät und einer Android-App, mit deren Hilfe man auch unterwegs den Anwesenheitszustand prüfen kann, war dann doch noch etwas länger. Das ganze Teil gab es dann Ende letzten Jahres als Geburtstagsgeschenk für die sich ab und an sorgende Gattin. Und so sieht das Ganze nun aus:

Mir ist bewusst, das so eine Familien-Überwachung grenzwertig ist. Habe ich eigentlich schon einmal den Blog von „Das Nuf“ empfohlen? Falls nicht ist das die Gelegenheit dazu. Sie schreibt gerne über Familienthemen, und das in einer erfrischenden Art und mit einer Haltung, die ich fast immer komplett unterstreichen kann. Vor einigen Tagen ging es um das Thema der Überwachung von Familienmitgliedern. Auch hier folge ich ihr in ihrer ablehnenden Haltung der Überwachung von Kindern gegenüber. Allerdings geht das, was sie beschreibt, weit über das hinaus, was wir hier machen: Komplette Ortung per GPS, Festlegung erlaubter Aufenthaltsbereiche, Anzapfen des Mikrofons des Kinderhandys usw. Uns ging es vor allem um das, was vermutlich viele aus den Anfängen ihrere Teenagerzeit kennen: Die Eltern möchten gerne informiert werden, wenn das zunehmnd streunende Kinder wieder zuhause einläuft. Ich habe mich umgehört, das gibt und gab es in den verschiedensten Varianten: Das Kind weckt ggf. die Eltern und meldet sich zurück. Oder das Kind gibt eine Art Signal, wenn es zurück ist (schaltet z.B. das Flurlich aus). Oder die Eltern checken zu einer bestimmten Uhrzeit, ob das Kind im Bett ist. Ich finde ein solches Verhalten für eine gewissen Übergangszeit legitim, auch wenn klar ist, dass damit irgendwann Schluss sein muss.

Für den interessierten Leser jetzt noch ein paar Details zur technischen Realisierung:

Der Bau

Als ersten Schritt hatte ich als „proof of concept“ wiedermal einen Wemos D1 mini zur Hand genommen, 4 LEDs angeschlossen (für jedes Familienmitglied eine), ein Programm geschrieben und das Teil im Haus testweise einige Tage laufen lassen. LED an = Person ist zuhause, LED aus = Person ist nicht zuhause. Das hat nach einem groben Fehlschlag doch recht zügig funktioniert, Details zur Programmierung gitb es weiter unten. Ich wollte das Ganze aber etwas schöner gestalten, sollte eher ein dekoratives Element werden. Einige Entwürfe wurden gezeichnet, am Ende habe ich mich für das oben gezeigte hexagonale Layout entschieden. Ausgangsmaterial waren zwei Stiftehalter aus Holz. Die wurden jeweils halbiert, der Boden abgetrennt, das ganze verleimt. Innen habe ich einzeln adressierbare LED-Strips verbaut, und am Ende die Waben vorne mit milchig geschliffene Plexiglasscheiben vor schwarzweiß gedruckten Fotos abgeschlossen.

Ein paar Impressionen vom Bau:

Die Programmierung

Die Programmierung des „Arduino“ will ich hier nur kurz umreißen. Das Konzept funktioniert folgendermaßen:gehen Der Wemos D1 mini (hier der Einfachheit halber „Arduino“ genannt) hat Ein ESP8266-WLAN-Modul. Damit verbindet er sich mit dem heimischen WLAN.

  • Der Arduino fragt z.B. alle 15 Sekunden mittels eines speziellen Protokolls (SOAP / TR064, hier die verwendete Library) beim Router (z.B. einer Fritzbox) ab, welche Geräte gerade im WLAN aktiv sind und vergleicht das mit den MAC-Adressen der Familienmitglieder. Dafür braucht der Arduino einen Account auf dem Router, denn ohne Authentifizierung kann er dort keine Daten abfragen.
  • Abhängig vom Abwesenheitszustand schaltet der Arduino dann die LEDs oder LED-Strips.
  • Außerdem baut der EPS8266-Chip des Arduino noch einen Webserver auf einem bestimmten Port auf. Über den kann die App (s.u.) schließlich mit ihm kommunizieren und so den Status der Anwesenden ebenfalls abfragen.

Was nicht funktioniert hat:

  • Es war mir wichtig, auf den Handys der Familienmitglieder nicht irgend etwas einrichten zu müssen, damit die Überprüfung funktioniert. Zunächst dachte ich, ich könnte die Geräte einfach regelmäßig anpingen. Das funktioniert auch eine Zeit lang, aber nach einigen Minuten gehen sie (jedenfalls Android-Geräte) in eine Art Standby und melden sich nicht mehr, obwohl sie noch im Netz hängen. Ping war also nichts, daher die Lösung über SOAP.
  • Um die App nutzen zu können muss im Router eine Port-Weiterleitung eingerichtet werden. Elegant wäre es gewesen, der Arduino hätte das selbst per UPnP erledigt. Ich habe verschiedene Versuche in diese Richtung unternommen, das aber nicht zu laufen bekommen und den Port letztendlich einfach manuell freigegeben.

Der (unaufgeräumte!) Code:


#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266HTTPClient.h>

// Includes für den LED-Strip:
#include "Adafruit_WS2801.h"
#include "SPI.h"



ESP8266WiFiMulti WiFiMulti;


#include "tr064.h"


WiFiServer server(1234);



//Wifi network name (SSID)
const char* wifi_ssid = "**********";
//Wifi network password
const char* wifi_password = "**********************";
//IP address of your router. This should be "192.168.179.1" for all FRITZ!Boxes
const char* IP = "192.168.178.1";
//Port of the API of your router. This should be 49000 for all TR-064 devices.
const int PORT = 49000;
//The username if you created and account, "admin" otherwise
const char* fuser = "********";
//The password for the aforementioned account.
const char* fpass = "*****************";

//Put the settings for the devices to detect here
//The number of different people/user you want to be able to detect
const int numUser = 4;
//The maximum amount of devices per user
const int maxDevices = 1;

/*
   The array of macs. Structure:
   = {{"mac1:user1", "mac2:user1", ..., "macX:user1"}, {"mac1:user2", "mac2:user2", ..., "macX:user2"}, ..., {"mac1:userY", "mac2:userY", ..., "macX:userY"}};
   Doesn't matter if upper or lowercase 🙂
*/
const char macsPerUser[numUser][maxDevices][18] = {
  {"ab:cd:ef:00:01:02"}, // Nutzer 1
  {"ab:cd:ef:00:01:03"}, // Nutzer 2
  {"ab:cd:ef:00:01:04"}, // Nutzer 3
  {"ab:cd:ef:00:01:05"}, // Nutzer 4
};



//Do not mess with these 🙂
//TR-064 connection
TR064 connection(PORT, IP, fuser, fpass);
//Status array. No need to change this!
bool onlineUsers[numUser];
bool onlineUsersPre[numUser];
bool firstRun = true;

// slider PIN:
uint8_t sliderPIN = A0;
float dim;      // scaling value of the slider, betweet 0 and 1
float dim_last;



// PINs der LED-Strips:
uint8_t dataPin1  = D3;
uint8_t clockPin1 = D4;
uint8_t dataPin2  = D7;
uint8_t clockPin2 = D8;
uint8_t dataPin3  = D5;
uint8_t clockPin3 = D6;
uint8_t dataPin4  = D1;
uint8_t clockPin4 = D2;
int numberOfLEDs = 6;


Adafruit_WS2801 strip[numUser] = {
  Adafruit_WS2801(numberOfLEDs, dataPin1, clockPin1),
  Adafruit_WS2801(numberOfLEDs, dataPin2, clockPin2),
  Adafruit_WS2801(numberOfLEDs, dataPin3, clockPin3),
  Adafruit_WS2801(numberOfLEDs, dataPin4, clockPin4)
};






//###########################################################################################
void setup() {

  for (int i = 0; i < numUser; ++i) {
    onlineUsersPre[i] = false;
  }


  //You might want to change the baud-rate
  Serial.begin(115200);

  // read the slider value:
  dim = analogRead(sliderPIN) / 1024.;
  dim_last = dim;
  
  // Setup für LED-Strip:
  for (int s = 0; s < numUser; ++s) {
    strip[s].begin();
    strip[s].show();
  }

  // Start TCP server.
  server.begin();


  //**************************************************
  //Wait a few secs for warm-up (dunno why, was in the default code for http connections).
  //You might be able to remove this block
  Serial.println("[SETUP] WAIT 1...");
  LEDfadeInAll(1, 0, 0);
  LEDfadeOutAll(1, 0, 0);
  Serial.println("[SETUP] WAIT 2...");
  LEDfadeInAll(0, 1, 0);
  LEDfadeOutAll(0, 1, 0);
  Serial.println("[SETUP] WAIT 3...");
  LEDfadeInAll(0, 0, 1);
  LEDfadeOutAll(0, 0, 1);
  //**************************************************


  //Connect to wifi
  WiFiMulti.addAP(wifi_ssid, wifi_password);


  //Wait for the wifi to connect and flash all LEDs
  while ((WiFiMulti.run() != WL_CONNECTED)) {
    for (int i = 0; i < strip[0].numPixels(); i++) {
      for (int s = 0; s < numUser; ++s) { if (random(1, 10) > 5) strip[s].setPixelColor(i,  Color(random(1, 255), random(1, 255), random(1, 255)));
        else     strip[s].setPixelColor(i,  Color(0, 0, 0));
      }
    }
    for (int s = 0; s < numUser; ++s) {
      strip[s].show();
    }
    delay(200);
  }

  LEDfadeInAll(1, 1, 0);



  //Initialize the TR-064 library
  Serial.println("Initialize TR-064 connection");
  connection.init();
  //Request the number of (connected) Wifi-Devices
  int numDev = getWifiNumber();
  Serial.printf("WIFI has %d (connected) devices.\n", numDev);
  //Check the status of all the devices connected to wifi
  getStatusOfAllWifi(numDev);
  //Get the number of all devices, that are known to this router
  numDev = getDeviceNumber();
  Serial.printf("Router has %d known devices.\n", numDev);
}






//###########################################################################################
void loop() {
  //For the next round, assume all users are offline
  for (int i = 0; i < numUser; ++i) {
    onlineUsersPre[i] = onlineUsers[i];
    onlineUsers[i]    = false;
  }

  //Check for all users if at least one of the macs is online
  for (int i = 0; i < numUser; ++i) { Serial.printf("> USER %d -------------------------------\n", i);
    boolean b = true; //No online device found yet
    //Check all devices
    for (int j = 0; j < maxDevices && b; ++j) {
      //Get the mac of the device to check
      String curMac = macsPerUser[i][j];
      b = (curMac != ""); //If it is empty, we don't need to check it (or the next one)
      if (b) {
        //okay, ask the router for the status of this MAC
        String stat2[4][2];
        getStatusOfMAC(curMac, stat2);

        //aaaaaaaaaaaannd??? Is it online?
        if (stat2[3][1] != "" && stat2[3][1] != "0") {
          onlineUsers[i] = true;
          b = true;
        }
        //Okay, print the status to the console!
        verboseStatus(stat2);
      }
    }
  }
  Serial.println("-------------------------------------------");

  //Flash all LEDs and then set them to the status we just found
  if (firstRun) {
    for (int s = 0; s < numUser; ++s) {
      // Gelb ausblenden:
      LEDfadeOut(s, 1, 1, 0);
      if (onlineUsers[s]) {
        LEDfadeIn(s, 1, 1, 1);
      }
      else {
        LEDfadeIn(s, 1, 0, 0);
      }
    }
  }
  else {
    for (int s = 0; s < numUser; ++s) {
      if (!onlineUsersPre[s] && onlineUsers[s]) {
        // Rot ausblenden:
        LEDfadeOut(s, 1, 0, 0);
        // Grün blinken:
        LEDfadeIn(s, 0, 1, 0);
        LEDfadeOut(s, 0, 1, 0);
        // Weiß einblenden:
        LEDfadeIn(s, 1, 1, 1);
      }
      if (onlineUsersPre[s] && !onlineUsers[s]) {
        // Weiß ausblenden:
        LEDfadeOut(s, 1, 1, 1);
        // Rot blinken:
        LEDfadeIn(s, 1, 0, 0);
        LEDfadeOut(s, 1, 0, 0);
        // Rot einblenden:
        LEDfadeIn(s, 1, 0, 0);
      }
    }
  }
  firstRun = false;




  //delay(10000);
  unsigned long starttime = millis();
  while (millis() - starttime < 10000) { // adjust the brightness according to the slider: dim = analogRead(sliderPIN) / 1024.; // if (round(dim*100) != round(dim_last*100)) { if (dim != dim_last) { Serial.print("Brightness changed: "); Serial.print(dim_last); Serial.print(" -> ");
      Serial.println(dim);
      for (int s = 0; s < numUser; ++s) {
        if (onlineUsers[s]) {
          for (int i = 0; i < strip[0].numPixels(); i++) {
            strip[s].setPixelColor(i, Color(dim * 255., dim * 255., dim * 255.));
          }
        }
        else {
          for (int i = 0; i < strip[0].numPixels(); i++) {
            strip[s].setPixelColor(i, Color(dim * 255., 0, 0));
          }
        }
        strip[s].show();
      }
      dim_last = dim;
    }
  
    

    // Check if a client has connected
    WiFiClient client = server.available();
    if (client) {

      // Return the response
      // (the following lines are necessary the server should be used with a browser):
      //client.println("HTTP/1.1 200 OK");
      //client.println("Content-Type: text/html");
      //client.println(""); //  do not forget this one
      //client.println("<!DOCTYPE HTML>");
      //client.println("<html>");
      String response = "";       // it's important to send the response at once, not in the folling loop in separat pieces
      for (int i = 0; i < numUser; ++i) {
        if (onlineUsers[i]) {
          response += "1";
        }
        else                {
          response += "0";
        }
      }
      client.print(response);
      //client.println("</html>");
    }
  }


}








///////////////////////////////////////////////////
void LEDfadeIn(int s, float r, float g, float b) {
  dim = analogRead(sliderPIN) / 1024.;
  
  for (int c = 0; c <= 255; c = c + 5) {
    for (int i = 0; i < strip[s].numPixels(); i++) { strip[s].setPixelColor(i, Color(dim * c * r, dim * c * b, dim * c * g)); } strip[s].show(); delay(15); } delay(100); } /////////////////////////////////////////////////// void LEDfadeOut(int s, float r, float g, float b) { dim = analogRead(sliderPIN) / 1024.; for (int c = 255; c >= 0; c = c - 5) {
    for (int i = 0; i < strip[s].numPixels(); i++) {
      strip[s].setPixelColor(i, Color(dim * c * r, dim * c * b, dim * c * g));
    }
    strip[s].show();
    delay(15);
  }
  delay(100);
}
///////////////////////////////////////////////////
void LEDfadeInAll(float r, float g, float b) {
  dim = analogRead(sliderPIN) / 1024.;
  
  for (int c = 0; c <= 255; c = c + 5) {
    for (int i = 0; i < strip[0].numPixels(); i++) {
      for (int s = 0; s < numUser; ++s) {
        strip[s].setPixelColor(i, Color(dim * c * r, dim * c * b, dim * c * g));
      }
    }
    for (int s = 0; s < numUser; ++s) { strip[s].show(); } } delay(200); } /////////////////////////////////////////////////// void LEDfadeOutAll(float r, float g, float b) { dim = analogRead(sliderPIN) / 1024.; for (int c = 255; c >= 0; c = c - 5) {
    for (int i = 0; i < strip[0].numPixels(); i++) {
      for (int s = 0; s < numUser; ++s) {
        strip[s].setPixelColor(i, Color(dim * c * r, dim * c * b, dim * c * g));
      }
    }
    for (int s = 0; s < numUser; ++s) {
      strip[s].show();
    }
  }
  delay(200);
}






/////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////// helper methods//////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////

/**
    Get the number of devices that were connected to the WIFI lastly
    (some of them might not be online anymore, you need to check them individually!)
    return (int)
*/
int getWifiNumber() {
  String params[][2] = {{}};
  String req[][2] = {{"NewTotalAssociations", ""}};
  connection.action("urn:dslforum-org:service:WLANConfiguration:1", "GetTotalAssociations", params, 0, req, 1);
  int numDev = (req[0][1]).toInt();
  return numDev;
}

/** Print the status of all devices that were connected to the WIFI lastly
   (some of them might not be online anymore, also gets you the hostnames and macs)
   return nothing as of yet
*/
void getStatusOfAllWifi() {
  getStatusOfAllWifi(getWifiNumber());
}


/**
    Print the status of all devices that were connected to the WIFI lastly
   (some of them might not be online anymore, also gets you the hostnames and macs)
   return nothing as of yet
*/
void getStatusOfAllWifi(int numDev) {
  //Query the mac and status of each device
  for (int i = 0; i < numDev; ++i) {
    String params[][2] = {{"NewAssociatedDeviceIndex", String(i)}};
    String req[][2] = {{"NewAssociatedDeviceAuthState", ""}, {"NewAssociatedDeviceMACAddress", ""}, {"NewAssociatedDeviceIPAddress", ""}};
    connection.action("urn:dslforum-org:service:WLANConfiguration:1", "GetGenericAssociatedDeviceInfo", params, 1, req, 2);
    Serial.printf("%d:\t", i);
    Serial.println((req[1][1]) + " is online " + (req[0][1]));
    Serial.flush();
  }
}

/**
    Get the number of devices that were connected to the router (ever)
    (some of them might not be online, you need to check them individually!)
    return (int)
*/
int getDeviceNumber() {
  String params[][2] = {{}};
  String req[][2] = {{"NewHostNumberOfEntries", ""}};
  connection.action("urn:dslforum-org:service:Hosts:1", "GetHostNumberOfEntries", params, 0, req, 1);
  int numDev = (req[0][1]).toInt();
  return numDev;
}

/**
    Get the status of one very specific device. May contain less information as the same option for WIFI.
   return nothing, but fills the array r
*/
void getStatusOfMAC(String mac, String (&r)[4][2]) {
  //Ask for one specific device
  String params[][2] = {{"NewMACAddress", mac}};
  String req[][2] = {{"NewIPAddress", ""}, {"NewActive", ""}, {"NewHostName", ""}};
  connection.action("urn:dslforum-org:service:Hosts:1", "GetSpecificHostEntry", params, 1, req, 2);
  Serial.println(mac + " is online " + (req[1][1]));
  Serial.flush();
  r[0][0] = "MAC";
  r[0][1] = mac;
  r[1][0] = "IP";
  r[1][1] = req[0][1];
  r[2][0] = "HOSTNAME";
  r[2][1] = req[2][1];
  r[3][0] = "ACTIVE";
  r[3][1] = req[1][1];
}


/**
   Prints the status of the device on the screen (arrays r of the getStatusOfMAC methods).
   return nothing
*/
void verboseStatus(String r[4][2]) {
  for (int i = 0; i < 4; ++i) {
    Serial.print(r[i][0] + "=" + r[i][1] + ", ");
  }
  Serial.print("\n");
}








/* Helper functions */

// Create a 24 bit color value from R,G,B
uint32_t Color(byte r, byte g, byte b)
{
  uint32_t c;
  c = r;
  c <<= 8;
  c |= g;
  c <<= 8;
  c |= b;
  return c;
}




Die App

Gleich vorneweg: Das mit der App war eine sponatane Idee. Ich habe vorher noch nie eine App gebastelt. Die Idee entstand, als ich parallel zum Bau der Überwachungsanlage über Evothings Studio gestolpert bin, einem Framework, in dem man einigermaßen simple (ich weiß, das ist relativ) eine App im Stile eine Webseite schreiben kann: Das Grundgerüst liefert HTML, das Styling passiert per CSS und die Logik kommt mit Javascript. Das lachte mich an. Tatsächlich hatte ich in einem Abend einen Prototypen der App zusammengepfuscht und kompiliert! Wie immer steckt der Teufel natürlich im Detail, trotzdem kann ich für App-Anfänger diese Weg durchaus empfehlen. Evothings nutzt für das Kompilieren eine virtuelle Maschine via VirtualBox, die per Vagrant konfiguriert wird. Das klingt komplizierter als es ist, Evothings führt einen durch die Installation der beiden Tools und richtet diese dann selbst ein. Kompiliert werden kann für Androdid und iOS, wobei ich nur die Android-Schiene getestet habe. Die Entwicklung einer App läuft grob so:

Meinen Code für die App erspare ich dir hier, der Blogpost ist eh schon lange genug… Einen Eindruck von der App bekommst du am Ende des Videos oben.

Fazit

Dieses Projekt hat richtig Spaß gemacht! War vermutlich bisher eines meiner umfangreichsten. Vor allem das Zusammenspiel der verschiedenen Komponenten war faszinierend: Arduino, ESP8266, WLAN, Fritzbox, Holz, LED-Strips, Handys, eine App. Auch der Familie gefällt das Teil, wenn wir z.B. gemeinsam nach Hause kommen wird regelmäßig derjenige gedisst, dessen Licht zuletzt von rot auf weiß umspringt 😉 So muss das sein, mission accomplished.

18 Reaktionen auf “Arduino-Bastelei: Wer da?

  1. Lukas Weber

    Cooles Gerät, und richtig schön umgesetzt! Als regelmäßiger Flugmodus-Verwender kann ich nur darauf schließen, dass das bei euch wohl nicht Usus ist. Zumindest würde dann der nächtliche Blick auf die App wohl eher zum Sorgen als zum entspannten Umdrehen beitragen…

    Antworten
  2. Daniel Weber

    Kein Usus bei uns. Ich weiß, dass einige Leute das machen, wenn sie das Handy nachts am Bett haben (Strahlungsparanoia). Bei uns liegen alle Handys nachst unten zum Laden (ok, bis auf meines). Flugmodus macht keiner.

    Antworten
  3. Daniel Weber

    Lukas Weber Ah, unterbrechungsfrei schlafen. Mein Handy ist immer komplett geräuschlos, weil mir in der Regel die Pebble-Uhr Bescheid gibt, wenn was ist. Und die lasse ich üblicherweise abends am Schreibtisch liegen (und sie hat einen Ruhemodus).

    Antworten
  4. Johannes

    Super Projekt, Kollege Weber. Und nettes Holzgehäuse.

    Ich plane seit längerem etwas ähnliches: Ich habe einen großen Info-Screen bei uns in der Küche stehen (24″ an Raspi). Er gibt mir diverse Statistiken (Temperatur, Stromverbrauch, Uplink-Throughput im Rechenzentrum, …) und weiter Infos wie Staukarte von GoogleMaps aus. Sinn wäre es nun, die Ausgabe auf eine Dia-Show zu ändern wenn ich sowieso nicht im Haus bin. Oder anders: Die Grafiken nur dann, wenn ich im WLAN bin und sonst nicht. Lässt sich vermutlich ähnlich lösen wie dein Zeugs, nur dass ich irgendwie die Programme in Linux steuern muss.

    Antworten
    1. dasaweb Beitragsautor

      Wenn du eh einen Pi am laufen hast geht das z.B. mit PHP sehr einfach. Kleiner Codeschnipsel aus einem anderen Projekt, welches ich vor längerer Zeit mal umgesetzt habe:

      <?php
      
      $fritzboxIP 	= 'fritz.box'; // ggf. IP eintragen
      $fritzboxPort 	= '49000';
      $login 			= '***********';
      $password 		= '***********';
      
      $blacklist		= array(
      						'AA:AA:AA:AA:AA:AA',		# FritzBox
      						'AA:AA:AA:AA:AA:AA',		# Raspberry Pi
      						);
      $client = new SoapClient(
          null,
          array(
              'location'   => 'http://'.$fritzboxIP.':'.$fritzboxPort.'/upnp/control/hosts',
              'uri'        => 'urn:dslforum-org:service:Hosts:1',
              'noroot'     => True,
              'login'      => $login,
              'password'   => $password
          )
      );
      print_r($client);
      for ($i = 0; $i < $client->GetHostNumberOfEntries(); $i++) $Hosts[] = $client->GetGenericHostEntry(new SoapParam($i,'NewIndex'));
      print_r($Hosts);
      $activeHosts = array();
      foreach ($Hosts as $Host) if ($Host['NewActive'] == 1 && !in_array($Host['NewMACAddress'], $blacklist)) $activeHosts[] = $Host;
      print_r($activeHosts);
      
      

      Damit sollte sich sehr leicht feststellen lassen, ob du daheim bist oder nicht. Das musst du dann eben irgendwie noch in deine Monitor-Software integrieren.

      Antworten

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.