Google Analytics in FHEM einbinden und Live-Besucher mit Analogmeter darstellen

IM EINSATZ?

Dann schau dir UNSEREN LOXKURS an und profitiere von unserem Wissen!

Heute mal ein etwas außergewöhnlicher Blogpost aus dem Bereich: Braucht zwar kein Mensch – Wollte ich aber unbedingt schon immer mal haben. Ziel war es die Live-Besucher von meintechblog.de per Google-Analytics-API an FHEM zu übermitteln, um diese Information dann in Echtzeit mit einem Analogmeter darzustellen. Klingt erstmal verwirrend und unnötig, macht aber jede Menge Spaß – gerade auch dann, wenn man das Ergebnis sieht und es tatsächlich auch noch funktioniert. Als Gag habe ich eine ungenutzte Webcam installiert, sodass jeder Besucher die Anzeige live mitverfolgen kann, die er durch den Besuch ja auch selbst beeinflusst.

Spannend ist das Ganze auch aus FHEM-Sicht, da der dafür genutzte Dummy mit recht viel Logik ausgestattet wurde, was auch für andere Anwendungsfälle interessant sein kann. Was aus technischer Sicht dahinter steckt, ist Inhalt des nachfolgenden Blogposts.

Google-Analytics-API vorbereiten

Wer Google Analytics einsetzt, um die Besucherzahlen seiner Seite zu tracken, muss im ersten Schritt die vom Suchmaschinenriesen bereitstellte Programmierschnittstelle (API) einrichten. Was ich selbst wohl nie geschafft hätte, hat dankenswerter Weise Matthias übernommen, der ein echter Profi in Sachen Webentwicklung ist.

In seinem extra für mich angefertigten Blogpost Google Analytics API – Aktuelle Besucherzahlen auf dem Raspberry PI erklärt er Schritt für Schritt, wie die Google API vorbereitet werden muss, um später die gewünschten Informationen auslesen zu können. Vielen Dank für deine Unterstütztung Matthias!

Google Developers Conosle API ist aktiviert

FHEM mit passendem Dummy vorbereiten

Damit die Daten aus FHEM heraus aktualisiert und angezeigt werden können, wird ein Dummy namens “GA.Meintechblog” und “FileLog” für spätere Analysezwecke definiert.

#Google Analytics Meintechblog Dummy für Auswertung
define GA.Meintechblog dummy
attr GA.Meintechblog event-on-update-reading usersRealtime
attr GA.Meintechblog room GoogleAnalytics
attr GA.Meintechblog webCmd updateAll:updateRealtime
define FileLog_GA.Meintechblog FileLog ./log/WEB.meintechblog-%Y.log GA.Meintechblog
attr FileLog_GA.Meintechblog logtype text
attr FileLog_GA.Meintechblog room GoogleAnalytics

Der Dummy erhält die Möglichkeit über die Kommandos “updateAll” und “updateRealtime” die entsprechenden Google-Analytics-Daten auch manuell anfordern zu können, indem jeweils php-Scripte getriggert werden.

#Update GA.Meintechblog All
define GAMeintechblogAllUpdate notify GA.Meintechblog:updateAll { system ("php /google-api-php-client/raspberry_all.php&")}

#Update GA.Meintechblog Realtime
define GAMeintechblogRealtimeUpdate notify GA.Meintechblog:updateRealtime { system ("php /google-api-php-client/raspberry_realtime.php&")}

Aus kosmetischen Gründen übergeben die getriggerten Scripte zu Abholung der Analytics-Daten (“raspberry_all.php” und “raspberry_realtime.php” die Werte der Live-Besucher in das Reading “usersRealtime”. Damit diese Information auch im normalen state des Dummy angezeigt wird, muss man noch etwas nachhelfen:

#GA.Meintechblog Reading UsersRealtime in State schreiben
define GAMeintechblogReadingToState notify GA.Meintechblog:usersRealtime.* {\
 my $usersrealtime = ReadingsVal("GA.Meintechblog", "usersRealtime", "0");;\
  {\
  fhem ("set GA.Meintechblog $usersrealtime")\
 }\
}

Damit die Scripte zur Abholung der Analytics-Daten aber auch automatisch aus FHEM heraus getriggert werden können, werden zwei at-Befehle definiert, welche die Scripte “raspberry_realtime.php” und das dritte Script im Bunde “raspberry_non_realtime” ausführen können.

#Update NonRealtime alle 6 Minuten
define GAMeintechblogNonRealtimeUpdateAuto at +*00:06:00 { system ("php /google-api-php-client/raspberry_non_realtime.php&")}

#Update UsersRealtime alle 15 Sekunden
define GAMeintechblogRealtimeUpdateAuto at +*00:00:15 { system ("php /google-api-php-client/raspberry_realtime.php&")}

Die Zeiten sind dabei Erfahrungswerte. Alle 15 Sekunden werden so die Daten der Echtzeitbesucher abgefragt und entsprechend nur alle 6 Minuten alle anderen nicht-echtzeitrelevanten Daten, wie gesamte Besucherzahl und Seitenaufrufe für heute und diesen Monat. Letztgenannte Daten werden von Google nur ca. alle 10 Minuten aktualisiert, wobei sich eine Abfrage alle 6 Minuten als ganz guter Kompromiss herausgestellt hat.

Zusätzlich wird das Reading “pageviewsToday”, welches die aktuelle Anzahl der am jeweiligen Tag aufgerufenen Seiten ausgibt, um 0 Uhr resettet. Auch nur Kosmetik, aber soviel Zeit muss sein:

#Reset PageviewsToday um 0 Uhr
define GaMeintechblogPageviewsTodayReset at *00:00:00 setreading GA.Meintechblog pageviewsToday 0

Jetzt soll noch das Reading “usersRealtimeTodayMax” generiert werden, welches den aktuellen Höchstwert des Tages bzgl. Live-Besucher darstellt:

#Update UsersRealtimeTodayMax
define UsersRealtimeTodayMaxUpdate notify GA.Meintechblog:usersRealtime.* {\
 my $usersrealtime = ReadingsVal("GA.Meintechblog", "usersRealtime", "0");;\
 my $usersrealtimetodaymax = ReadingsVal("GA.Meintechblog", "usersRealtimeTodayMax", "0");;\
 if ($usersrealtime > $usersrealtimetodaymax) {\
  fhem ("setreading GA.Meintechblog usersRealtimeTodayMax $usersrealtime")\
 }\
}

Um Mitternacht wird dieses Reading dann wieder resettet:

#Reset UsersRealtimeTodayMax um 0 Uhr
define UsersRealtimeTodayMaxReset at *00:00:00 {\
 my $usersrealtime = ReadingsVal("GA.Meintechblog", "usersRealtime", "0");;\
 {\
  fhem ("setreading GA.Meintechblog usersRealtimeTodayMax $usersrealtime")\
 }\
}

Scripte zum Abrufen der Analytics-Daten aus FHEM

Folgendes Verfahren geht mit Sicherheit auch schöner, aber auf die Schnelle habe ich die drei Anwendungsfälle “Rufe alle Daten ab”, “Rufe alle Echtzeitdaten ab” und “Rufe alle Nicht-Echtzeitdaten ab” in drei unterschiedliche php-Dateien gepackt.

Jedes der drei php-Files, welche im Ordner “/google-api-php-client” abgelegt werden, beginnt mit folgendem Inhalt (von Matthias kopiert):

<?php

// Diesen Bereich anpassen!!!
$service_account_email = 'jay-xxx@iron-pottery-119414.iam.gserviceaccount.com'; //Dienstkonto-Email-Adresse
$key_file_location = __DIR__ . '/My Project-17220fxxxxxx.p12'; //p12-Konto-File
$profile = 4522xxxx; //ID der Datenansicht

require_once __DIR__ . '/google-api-php-client/src/Google/autoload.php';

class MKleine_Google_Analytics_API
{
    protected $serviceAccountEmail = null;
    protected $keyFile = null;
    protected $profileId = null;

    protected $analyticsRef = null;

    function __construct($serviceAccountEmail, $keyFile, $profileId)
    {
        $this->serviceAccountEmail = $serviceAccountEmail;
        $this->keyFile = $keyFile;
        $this->profileId = $profileId;
    }

    /**
     * @return Google_Service_Analytics
     */
    protected function getService()
    {
        if (is_null($this->analyticsRef)) {
            // Create and configure a new client object.
            $client = new Google_Client();
            $client->setApplicationName("RaspberryPi-Analytics");
            $this->analyticsRef = new Google_Service_Analytics($client);

            // Read the generated client_secrets.p12 key.
            $key = file_get_contents($this->keyFile);
            $cred = new Google_Auth_AssertionCredentials(
                $this->serviceAccountEmail,
                array(Google_Service_Analytics::ANALYTICS_READONLY),
                $key
            );

            $client->setAssertionCredentials($cred);
            if ($client->getAuth()->isAccessTokenExpired()) {
                $client->getAuth()->refreshTokenWithAssertion($cred);
            }
        }

        return $this->analyticsRef;
    }

    /**
     * @param $startDate
     * @param $endDate
     * @param $metrics
     * @return bool|int
     */
    public function getResults($startDate, $endDate, $metrics)
    {
        // Calls the Core Reporting API and queries for the number of sessions
        // for the last seven days.
        $data = $this->getService()->data_ga->get(
            'ga:' . $this->profileId,
            $startDate,
            $endDate,
            $metrics
        );

        return $this->parseResults($data);
    }

    /**
     * @param $metrics
     * @return bool|int
     */
    public function getRealtimeResults($metrics)
    {
        $data = $this->getService()->data_realtime->get(
            'ga:' . $this->profileId,
            $metrics
        );

        return $this->parseResults($data);
    }

    /**
     * @param $results
     * @return bool|int
     */
    protected function parseResults($results)
    {
        // Parses the response from the Core Reporting API and prints
        // the profile name and total sessions.
        if (count($results->getRows()) > 0) {

            // Get the entry for the first entry in the first row.
            $rows = $results->getRows();
            $sessions = $rows[0][0];

            return (int)$sessions > 0 ? (int)$sessions : false;
        } else {
            return false;
        }
    }

}

$obj = new MKleine_Google_Analytics_API(
    $service_account_email,
    $key_file_location,
    $profile
);

Die Datei “raspberry_all.php” bekommt dann danach noch folgenden Inhalt:

// Users Realtime
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_URL => 'http://localhost:8083/fhem?cmd=setreading%20GA.Meintechblog%20usersRealtime%20' . $obj->getRealtimeResults('rt:activeUsers'),
));
$resp = curl_exec($curl);
curl_close($curl);

// Pageviews This Month
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_URL => 'http://localhost:8083/fhem?cmd=setreading%20GA.Meintechblog%20pageviewsThisMonth%20' . $obj->getResults(date('Y-m-01'), 'today', 'ga:pageviews'),
));
$resp = curl_exec($curl);
curl_close($curl);

// Users All
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_URL => 'http://localhost:8083/fhem?cmd=setreading%20GA.Meintechblog%20usersAll%20' . $obj->getResults('2011-04-01', 'today', 'ga:users'),
));
$resp = curl_exec($curl);
curl_close($curl);

// Pageviews Today
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_URL => 'http://localhost:8083/fhem?cmd=setreading%20GA.Meintechblog%20pageviewsToday%20' . $obj->getResults('today', 'today', 'ga:pageviews'),
));
$resp = curl_exec($curl);
curl_close($curl);

Dabei werden die von Google-Analytics übermittelten Daten per CURL an FHEM übermittelt. Wie man an “localhost” sieht, befindet die gesamte Logik (sowohl FHEM als auch API-Abfrage) auf einem System, was das Vorgehen insgesamt vereinfacht.

Die Datei “raspberry_realtime.php” besitzt neben dem oben angesprochenen Block den Inhalt:

// Users Realtime
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_URL => 'http://localhost:8083/fhem?cmd=setreading%20GA.Meintechblog%20usersRealtime%20' . $obj->getRealtimeResults('rt:activeUsers'),
));
$resp = curl_exec($curl);
curl_close($curl);

Also im Grunde nur einen Teilausschnitt der “raspberry_all.php”.

Als drittes Script “raspberry_non_realtime.php” besitzt neben dem Startteil weiterhin den Inhalt:

// Pageviews This Month
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_URL => 'http://localhost:8083/fhem?cmd=setreading%20GA.Meintechblog%20pageviewsThisMonth%20' . $obj->getResults(date('Y-m-01'), 'today', 'ga:pageviews'),
));
$resp = curl_exec($curl);
curl_close($curl);

// Users All
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_URL => 'http://localhost:8083/fhem?cmd=setreading%20GA.Meintechblog%20usersAll%20' . $obj->getResults('2011-04-01', 'today', 'ga:users'),
));
$resp = curl_exec($curl);
curl_close($curl);

// Pageviews Today
$curl = curl_init();
curl_setopt_array($curl, array(
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_URL => 'http://localhost:8083/fhem?cmd=setreading%20GA.Meintechblog%20pageviewsToday%20' . $obj->getResults('today', 'today', 'ga:pageviews'),
));
$resp = curl_exec($curl);
curl_close($curl);

Damit die Scripte aus FHEM heraus aufgerufen werden können, habe ich dem Ordner “/google-api-php-client” auf dem RPI, in welchem alle Dateien und Scripte untergebracht sind, per Terminalbefehl die Berechtigung 777 gegeben. (Ja ich weiss, dass man sowas normalerweise nicht macht, leider habe ich kurzfristig keine bessere Möglichkeit ausfindig machen können. Wer einen besseren Vorschlag hat, kann diesen gerne per Kommentar mitteilen.)

sudo chmod 777 -R /google-api-php-client

Analytics-API-Abruf in FHEM testen

Sofern alles korrekt eingerichtet wurde, sollten die gewünschten Analytics-Daten bereits in FHEM im Dummy “GA.Meintechblog” auftauchen.

Google Analytics in FHEM Dummy GA.Meintechblog dargestellt

Analytics-Daten visualisieren

Als nächstes wollte ich die Live-Besucherzahl des Blogs visualisieren. Geradezu aufgedrängt hat sich da ein analoges Volt-Meter, dessen “Tachonadel” Auskunft über die aktuelle Besucherzahl geben kann. Umgesetzt habe ich das – quick und dirty – erstmal mit einem analogen Voltmeter mit einem Wertebereich von 0-10V (Affiliate-Link, welches an einem freien analogen Ausgang meines Loxone-Miniservers angeschlossen wurde.

Loxone erhält die notwendigen Informationen wiederum per UDP-Mitteilungen vom FHEM-Server. Wie das funktioniert, wird im Detail im Blogpost HomeMatic FHEM-Wetteratation per UDP in Loxone integrieren erklärt.

Der Vollständigkeit halber nachfolgend noch die in FHEM notwendigen Settings, die im Vergleich zum verlinkten Blogpost bereits etwas verbessert wurden, da jetzt alle Readings aus FHEM auf einen Schlag als Array mit nur einer Nachricht übertragen werden können.

“99_myUtils.pm”

##############################################
# $Id: myUtilsTemplate.pm 7570 2015-01-14 18:31:44Z rudolfkoenig $
#
# Save this file as 99_myUtils.pm, and create your own functions in the new
# file. They are then available in every Perl expression.

package main;

use strict;
use warnings;
use POSIX;

sub
myUtils_Initialize($)
{
  my ($hash) = @_;
}

# Enter you functions below _this_ line.
use IO::Socket;

#UDP Befehle senden
sub UDP_Msg($$)
{
my ($dest,$port,$cmd)  = @_;
my $sock = IO::Socket::INET->new(
    Proto    => 'udp',
    PeerPort => $port,
    PeerAddr => $dest
) or die "Could not create socket: $!\n";
$sock->send($cmd) or die "Send error: $!\n";
return "send $cmd";
}


#GAToLoxone
#device:
#1 state
#2 pageviewsThisMonth
#3 pageviewsToday
#4 usersAll
#5 usersRealtime
#6 usersRealtimeTodayMax


sub GAToLoxone($)
{
 my ($device) = @_;

 my $state=ReadingsVal("$device","state","-1");
 my $pageviewsthismonth=ReadingsVal("$device","pageviewsThisMonth","-1");
 my $pageviewstoday=ReadingsVal("$device","pageviewsToday","-1");
 my $usersall=ReadingsVal("$device","usersAll","-1");
 my $usersRealtime=ReadingsVal("$device","usersRealtime","-1");
 my $usersRealtimeTodayMax=ReadingsVal("$device","usersRealtimeTodayMax","-1");
 UDP_Msg("192.168.3.11" , "7000" , "$device: $state $pageviewsthismonth $pageviewstoday $usersall $usersRealtime $usersRealtimeTodayMax");
}

1;

Und dann noch der notwendige Trigger aus der “fhem.cfg”:

#GAMeintechblog an Loxone senden
define GAMeintechblogToLoxone notify GA.Meintechblog.* {GAToLoxone("$NAME")}

Künftig möchte ich für die Ansteuerung des Anlogmeters einen Arduino einsetzen. Dessen Ausgänge müssen aber wohl erst etwas modifiziert werden, damit sie als analoge Ausgänge (ähnlich denen des Loxone Miniservers) fungieren können, weshalb ich erstmal die für mich “altbewehrte” Methode per Loxone Miniserver gewählt habe. Als netten Nebeneffekt kann ich jetzt auch in meiner Loxone App immer alle Daten einsehen.

Loxone App Google Analytics Integration

Und so sieht das Ganze dann noch in der Loxone Config aus:

Loxone Config Google Analytics Integration ueber FHEM

Die Befehlskennung des virtuellen UDP-Eingangs in Loxone für das übertragene Reading “usersRealtime” (Wert an Stelle 5) sieht dann bspw. so aus:

GA.Meintechblog: \# \# \# \# \v

Damit der fünfte Wert auch korrekt gezogen wird, werden vier Rauten vorangestellt.

Wie man erkennen kann, wurde dabei auch eine Eingangswertkorrektur genutzt, um die Live-Besucherzahl – in diesem Fall 38 – am analogen Ausgang – in diesem Fall 3,8V – korrekt auszugeben. Entsprechend habe ich dem Voltmeter auch eine neue Skala verpasst. Der alte Wert 10 V entspricht dann 100 Live-Besuchern.

Voltmeter Vorlage und neue meintechblog Skala

Dabei habe ich die alte Skala eingescannt, um die passende Größe zu bekommen und dann mit einem neuen Layout verpasst, welches dann über den Photodrucker Canon Selphy CP910 (Affiliate-Link) auf einem 148x100mm großen Papier gedruckt wurde.

Dann ab mit der neuen Skala in das Voltmeter und alles zusammengebaut. Der linke Anschluss des Voltmeters (von hinten gesehen) ist dabei Plus, der rechte Anschluss Minus.

Voltmeter Anschluesse

Plus habe ich am ersten analogen Ausgang des Miniservers angeschlossen, Minus entsprechend an Minus des Miniservers

Dann die Skala noch mit Werten aus dem Bereich 0-100 getestet und direkt in den Live-Modus gewechselt. Im Ergebnis sieht es dann doch recht brauchbar aus:

meintechblog Live Besucheranzeige als retro Analoganzeige

Aktuelle User visualisieren (LIVE WEBCAM)

Jetzt noch eine Webcam davorgeparkt, um die Live-User in Echtzeit zu visualisieren (Bild wird aktuell nur einmal pro Minute aktualisiert, also am besten etwas warten :-).

[netcam-live url=”https://meintechblog.de/webcam/mobotix/current.jpg?Resolution=1280×720&Quality=Clarity” refresh=”10000″ width=”100%”]

Dafür habe ich auch gleich noch eine extra Live-Seite ohne Schnickschnack eingerichtet.

Um das Webcam-Bild hier einzubinden, habe ich einen kleinen Umweg gewählt, um Skalierbarkeit zu ermöglichen und meinen VDSL-Upload nicht komplett dicht zu machen. Die Webcam schickt regelmäßig ein aktuelles Bild per FTP auf den Webserver (Standardfunktion der eingesetzten Mobotix-Cam) und das WordPress-Plugin Netcam / Webcam Live Stream kümmert sich dann um die Darstellung und Aktualisierung im Web-Frontend.

Hier noch der genutzte Plugin-Code des Blogposts:

[netcam-live url="https://meintechblog.de/webcam/mobotix/current.jpg?Resolution=1280x720&Quality=Clarity" refresh="10000" width="100%"]

Ich möchte die Intervalle gerne noch verkürzen, habe das spontan aber nicht hinbekommen bei der Mobotix I25 (Affiliate-Link), welche das Bild gegen aller getroffenen Einstellungen nur einmal pro Minute auf den Webserver legt.

Insgesamt eine wirklich mächtige IP-Cam, die aber auch echt schwierig zu konfigurieren ist. Da muss ich mich wohl erst noch tiefer einlesen, um dieses Detailproblem doch noch lösen zu können.

Aus meinem täglichen Leben

Schon lange stand diese Spielerei ganz oben auf meiner Geek-Wishlist. Mit der oldschool Visualisierung der Live-Besucher des Blogs habe ich jetzt endlich den ersten Schritt umgesetzt. Bald soll noch die Anzeige aller Besucher seit 2011 per 8 stelliger LED-Anzeige (Affiliate-Link) hinzukommen.

Die Anzeige befindet sich aber leider noch in der Post und muss nach Ankunft auch erstmal über einen Arduino angebunden werden.

Wirklich cool wäre ja die Nutzung von Klapptäfelchen wie man sie von alten Weckern oder den Anzeigen am Flughafen kennt, hier habe ich aber noch nichts Brauchbares gefunden, was ich per Arduino ansteuern könnte. Ganz zum Schluss sollen dann alle Visualisierungselemente in einem schicken Gehäuse untergebracht werden. Spätestens da muss ich mich dann wohl mit CAD beschäftigen, da ein Plastikgehäuse per 3D-Drucker natürlich genial wäre. Alles in Allem ein Megaaufwand, aber für mich mit Abstand die beste Spielerei seit Langem, die zudem recht gut demonstriert, dass man so ziemlich alles realisieren kann, wenn man nur möchte.

29 Kommentare
    1. Darauf bin ich in der Tat (noch) nicht vorbereitet. Da bleibt der “Tacho” hoffentlich einfach bei vollem Ausschlag hängen. Spontan könnte ich noch eine rote LED ansteuern, wenn 100 überschritten wird. 🙂
      Aber mal sehen, normalerweise wird die 80er Marke eher selten geknackt.

    2. Aber geil wäre natürlich die Skala per OLED-Display abzubilden und dann dynamisch anzupassen sowie entsprechend den Nadelausschlag nachzujustieren.

    3. Nein, ich finde die Analoganzeige sehr gut und nostalgisch. Nix mit OLED oder Display machen 😉

  1. Seit ich mich mit Hausautomation beschäftige, kommt logischerweise auch das Thema WAF (women acceptance factor) immer wieder auf … 😉

    Dies hier hat definitiv einen negativen WAF – aber geil isses trotzdem!!! :-))))

  2. Moin, hatte in einem andere Blog gelesen, dass Du als Statusanzeige ein IPAD an die Wand hängen möchtest…(den Einwand Deiner Frau kann ich da verstehen…).
    Hierzu ein Tip: Die Fa. Lancom hat Wireless E-Paper Displays im Angebot. Wäre das auch noch eine Alternative ? Geht natürlich in eine komplett andere Richtung als die Nixies, sieht aber schick aus (Thema WAF) , ist keine Bastellösung und die Batterien sollen laut Hersteller 1-2 Jahre halten, also ähnlich wie bei Homematic Geräten. Man hat keine Kabel an der Wand, eine API steht zur Verfügung und man kann auch Grafiken ausgeben.
    Ich finde, das Thema ist einen eigenen Blog wert?
    Gruß Axel

    1. Hi Axel,
      danke für deinen Tipp mit den “LANCOM Wireless ePaper Displays”. Habe ich mal direkt in meiner “Operation Smart Home”-Mindmap vermerkt.

      E-Ink ist natürlich geil, keine Frage, die Displays lassen sich dann aber lediglich als Ausgabemedium zur Visualisierung nutzen, jedoch nicht – wie bspw. ein iPad – für die Eingabe per Touchscreen. Außerdem benötigt man zur Ansteuerung der ePaper Displays einen passenden Wlan-Router von LANCOM, der auch nicht wirklich günstig ist.

      Bei meiner kurzen Recherche habe ich das WDG-1 mit 7,4 Zoll (Affiliate-Link) für 50 Euro entdeckt und gleich mal geordert (regulär 220€). War wohl ein Preisfehler, die Sendung ist aber bereits als verschickt markiert. 🙂 Da ich sowieso auf der Suche nach einem zuverlässigen WLAN-Accesspoint bin, teste ich den zum Display passenden LANCOM L-322E Wireless (Affiliate-Link) wohl auch mal. Gerade auch die dort eingebaute iBeacon-Funktion klingt spannend für künftige Smart-Home-Funktionen.

      Grüße
      Jörg

      PS: Die Nixies sind – davon abgesehen – sowieso nur als Spielerei für das “Arbeitszimmer” gedacht.

  3. Sorry aber ich musste mal die Live Anzeige testen ;). Hab euch mal ein paar Ebesucher für ein paar sec geschickt… Die Anzeige scheint zu funktionieren… Hat allerdings bei 100 aufgehört … Ich werde das Projekt nachbauen… Weiter So.

    ~lg. Mathias~

    1. Hehe, Ebesucher (Wikipedia) also… Was es nicht alles gibt. Und klar funktioniert die Anzeige, was denkt du denn? 😉
      Anzeige geht nur bis hundert, richtig. Ist einige Kommentare weiter oben schon mal angesprochen worden. Ist ja aktuell eher erstmal nur Proof of Concept.

      Grüße
      Jörg

      PS: Würde mich über weitere Infos zu deiner Umsetzung freuen.

  4. Hi Jörg, Ich werde mir mal die Anzeige bestellen. Wobei sie bei meinem Blog kaum mehr als 10 anzeigen wird. Ist aber der gewisse WAF und ich muss nich ständig in Anaytics schaun. Könnte man da noch ne zweite Anzeige Anschließen der die Besucher pro Tag hochzählt ?

    ~lg.Mathias~

    1. Schade beim genauen Lesen sehe ich gerade das es mit Miniserver über einen Analogenausgang läuft. Mann könnte doch bestimmt auch einen Raspberry Zero nehmen mit USB Wlan Stick und einen D/AWandler. Hab da was zur möglichen Ansteuerung gefunden:

      http://www.netzmafia.de/skripten/hardware/RasPi/Projekt-Langweilometer/

      Wüsste allerdings nicht, wie man das dann mit FHEM übergeben könnte.

      ~lg.Mathias~

    2. Hi Matthias,
      klar sollte das klappen. Dazu muss man aber schon etwas basteln bzw. tricksen, da hast du Recht.

      Grundsätzlich gibt es verschiedene Möglichkeiten, um Daten zwischen Arduino und FHEM auszutauschen. Evtl. helfen dir ja die Inhalte der Blogserie Arduino im Smart Home weiter.

      Grüße
      Jörg

  5. Hallo,
    ich wollte mir das mal nachbauen. Mit den API und den Ausführungen von deinem Kollegen mit dem Raspberry Pi hat es soweit geklappt. Die Daten kommen mit seinem php – script (raspberry.php) mit Echo Bla… auf die Konsole. Api und Connection stimmt also. Hier im Blogbeitrag fehlt meiner Meinung nach der Aufruf von raspberry.php. Wo wird der denn aufgerufen? Wo werden die Ergebnisdaten (live, anzahl der user etc:) gespeichert. Wenn ich raspberry_all.php in der Fhem commandozeile aufrufe, kommt -1. Das sagt aber gar nix. Im log steht dann // Users Realtime
    $curl = curl_init();
    curl_setopt_array($curl, array(
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT => 10,
    CURLOPT_URL => ‘http://192.168.178.11:8083/fhem?cmd=setreading%20GA.meinesite%20usersRealtime%20’ . $obj->getRealtimeResults(‘rt:activeUsers’),
    ));
    $resp = curl_exec($curl);
    curl_close($curl); (verbose 5). Kann es sein, dass mein CURL nicht funktioniert? apache2 und php musste bei mir auch nachinstalliert werden, hatte normales debian drauf.

  6. Hallo
    Leider benötigt man wohl für dieses Vorgehen ? die
    Google Cloud Platform, die kostenpflichtig ist.
    Kommt für mich also so nicht in Frage.Eine andere
    Möglichkeit wäre vielleicht per Tracking Code und abfragen
    der zugriffe per HTTPMOD

Schreibe einen Kommentar

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

Das könnte dir auch gefallen