Raspberry Pi mit Alexa (Amazon Echo) steuern -Anleitung

Mit dem Raspberry Pi kann kann man so ziemlich alles steuern, was man sich so vorstellen kann. Doch wie wäre es nun, wenn man mit Hilfe eines Amazon Echo Lautsprechers bzw. über Alexa diese Steuerungsaufgaben noch zusätzlich oder primär über die Sprache  anstoßen könnte? Wir haben uns darüber Gedanken gemacht und wollen Euch nun die fertige Lösung dafür in dieser kleinen Anleitung zeigen. Doch bevor wir mit dem HowTo beginnen, die Punkte – welche für uns wichtig waren.

Aufgabenstellung:
– Alexa und RasPi (Raspberry Pi) direkt über einen Skill verbinden ohne einen eigenen Skill zu programmieren
– keine Verwendung von speziellen Schlagworten wie z.B. „trigger“ oder den Devicenamen

Lösungsansatz:
Wir simulieren auf dem Raspberry Pi „WeMo“ Endgeräte. Im speziellen einen WeMo Switch – dies ist eine Steckdose die es im Handel zu kaufen gibt und welche direkt von der Amazon App als „Endgerät / Schaltbare Steckdose“ gefunden wird. Bis zu 16 dieser Endgeräte lassen sich so virtuell auf dem Raspberry Pi erzeugen und mit Aufgaben bzw.  Steuerungen hinterlegen. Wir ordnen hier im Schritt 1 den Befehlen ganz einfache Web-Aufrufe zu über welche man weitere Aktionen auslösen könnte. Im Schritt 2 binden wir danach die Möglichkeit ein, direkte Befehle auf der Konsole des Raspberry abzusetzen. Schon hier wäre es dann theoretisch möglich GPIO Pins direkt anzusprechen und darüber externe Aktionen auszulösen. Die einfachste Anwendung ist hier wohl ein Relais anzusprechen, welches dann direkt diverse Verbraucher anschalten und ausschalten kann. Wer in seine Automatisation noch mehr Funktionalität bringen möchte, kann wie wir hier zeigen auch weitere Pyhton Scripte einbinden, welche dann wiederum spezielle Dinge auslösen. So wäre es z.B. denkbar einen Ausgang mittels Script zum Taster zu machen, in dem man das Relais nur für eine bestimmte Zeit anzieht. Tja, und dann sind wir bei den Ausgängen wieder ganz offen und mittels dieser Schaltung zum Beispiel der Flurbeleuchtung einen weiteren Taster hinzufügen, welcher das Stromstoßrelais anziehen lässt. Und schon wäre eine ganz normale Beleuchtung in Alexa integriert. Man könnte jedoch dann auch solch eine Tasterfunktion einfach mit der Fernbedienung seines Garagen-Tor-Antriebs verbinden und schon könnte Alexa das Garagentor öffnen. Wie ihr sieht die Möglichkeiten sind danach ziemlich unbegrenzt. Denn in einem Script welches am Raspberry Pi startet, lässt sich so ziemlich alles unterbringen. So wäre es auch möglich Bluetooth Kommandos oder IR Schnittstellen auf das Kommando von Alexa hin zu steuern.

So, nun aber genug der vielen Worte!
Legen wir los!

Die Basis – ein Raspberry Pi mit einem frisch installierten Jessie LinuxLite System. Ich versuche meine Anleitungen immer möglichst so zu schreiben, dass diese direkt nach der Basisinstallation genutzt werden können und die Installation von weiteren Paketen einfach mal als Voraussetzung angenommen wird.

Welchen Pi ihr hier verwendet – spielt im Grunde keine Rolle. Wobei ich persönlich wahrscheinlich wegen der integrierten WLAN Unterstützung zum RPi 3 oder den aktuellen Raspberry Pi Zero greifen würde.

 

 

Daher fangen wir auch ganz vorne an:

Vorbereitungen des Pis

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install git
sudo apt-get install -y make build-essential libssl-dev zlib1g-dev libbz2-dev \ libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev \ xz-utils tk-dev

 

Installation von Python 3.6.1 am Raspberry Pi mittels pyenv
PYENV ist ein Python Versions-Management-Tool, welches uns erlaubt, mehrere Python Versionen gleichzeitig zu betreiben und zu nutzen. Dieser Weg über dieses Tool muss nicht sein – ist aber wegen der einfacheren Handhabung und besseren Übersichtlichkeit kein falscher Ansatzpunkt.

sudo install -o $(whoami) -g $(whoami) -d /opt/pyenv
git clone https://github.com/yyuu/pyenv /opt/pyenv
echo 'export PYENV_ROOT="/opt/pyenv"' >> ~/.bashrc
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(pyenv init -)"' >> ~/.bashrc
source ~/.bashrc
pyenv install 3.6.1

Nach dem letzten Kommando könnt ihr nun einen Kaffee trinken. Denn dieser nimmt etwas Zeit in Anspruch.

Fauxmo Installation
Fauxmo ist das Script auf dem der ganze Zauber beruht. Dieses ist für die Erstellung der virtuellen WeMo Geräte zuständig und hält die Kommunikation zu Alexa aufrecht.

"$(pyenv root)"/versions/3.6.1/bin/python3.6 -m pip install fauxmo

 

Die Installation liegt nun hier:

"$(pyenv root)"/versions/3.6.1/bin/fauxmo

 

Konfiguration erstellen
Jetzt sind wir schon fast durch und können mit der Konfiguration der Switche beginnen. Dafür legen wir uns ein Konfigurationsfile im Home Verzeichnis (/home/pi) des normalen Pi Nutzers ab. Ihr könnt hier natürlich auch jedes andere Verzeichnis wählen, müsst dann eben die Pfade und Aufrufe in den weiteren Schritten dieser Anleitung anpassen.

Config File erstellen:

cd ~
sudo nano config.json

In diese File tragen wir folgendes ein:

{
    "FAUXMO": {
        "ip_address": "auto"
    },
    "PLUGINS": {
        "SimpleHTTPPlugin": {
            "DEVICES": [
                {
                    "port": 12340,
                    "on_cmd": "http://google.de",
                    "off_cmd": "http://google.de",
                    "method": "GET",
                    "name": "Test"
                }
            ]
        }
    }
}

Dies erstellt uns nun einen virtuellen Switch mit dem Namen Test.
Möchte man mehrere Switche erstellen, so kopiert man einfach den ersten, erhöht die Portnummer um einen Zähler – ändert den Namen und fügt dies getrennt mittels Komma ein.

Beispiel:

{
    "FAUXMO": {
        "ip_address": "auto"
    },
    "PLUGINS": {
        "SimpleHTTPPlugin": {
            "DEVICES": [
                {
                    "port": 12340,
                    "on_cmd": "http://google.de",
                    "off_cmd": "http://google.de",
                    "method": "GET",
                    "name": "Test"
                },
                {
                    "port": 12341,
                    "on_cmd": "http://google.de",
                    "off_cmd": "http://google.de",
                    "method": "GET",
                    "name": "Test2"
                }
            ]
        }
    }
}

 

Jetzt starten wir das Script um es zu testen:

"$(pyenv root)"/versions/3.6.1/bin/python3.6 -m fauxmo.cli -c /home/pi/config.json -vvv

 

Jetzt könnt ihr in der Alexa App die nach den Endgeräten suchen und diese sollten dort gelistet werden.
Alexa App -> Smarthome –> Geräte –> Suche
oder einfach nur per Sprache!
Alexa – suche nach neuen Geräten.

Diese Endgeräte sollten dann in der App auftauchen1

STRG+C beendet das Script.
Solltet ihr hier nun Probleme haben, wisst ihr warum wir nun den Autostart definieren!

Autostart:

crontab -e

Folgende Zeile einfügen:

@reboot /opt/pyenv/versions/3.6.1/bin/python3.6 -m fauxmo.cli -c /home/pi/config.json -vvv

 

Neustart ausführen und testen!

 

So jetzt könnten wir mit dieser Konfiguration Dinge über URLs oder HTTP steuern!

Möchten wir die GPIOs über ALexa ansteuern, so müssen wir jetzt noch etwas Hand anlegen!

Zuerst müssen wir die GPIO Unterstützung installieren

sudo apt-get install python-dev
sudo apt-get install python-rpi.gpio

 

Nun legen wir unsere Python Scripte zur Aufgabensteuerung an:

Ein Script startet unsere LED und das zweite Script schaltet die LED wieder ab.
Hier könnte man dann später natürlich auch ein Relais mit dem Raspberry Pi verbinden, welches diverse Schaltaufgaben übernimmt.

Info: Hier könnte man die GPIOs auch direkt aus dem Konfigurationsfile heraus starten. Aber ich gehe bewusst den Weg über die Python Scripte, da man dabei sieht, wie man hier vorgehen muss.

Nutzerverzeichnis home/pi – wir erstellen das File um ein GPIO anzuschalten.

cd ~
sudo nano test-an.py

 

Inhalt:

import RPi.GPIO as GPIO
import time

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)

GPIO.output(4,True)

…und nun das gleiche Spiel um den Ausgang auf Low / Aus zu setzen.

sudo nano test-aus.py

Inhalt:

import RPi.GPIO as GPIO
import time

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)

GPIO.output(4,False)

 

Wer möchte kann diese Scripte nun mittels einer LED und folgendem Kommando testen:

python test-an.py
python test-aus.py

Wir verwenden dafür Ground und den GPIO Port 4.

—> Übersicht Raspberry Pi Pins

Die LED sollte nun ein- und ausgeschalten werden.

Damit unsere Konfiguration die Befehle auch direkt auf der Kommandozeile ausführen kann, müssen wir uns noch eine Erweiterung installieren.

CommandlinePlugin einrichten

sudo nano commandlineplugin.py

Folgender Inhalt:

"""restapiplugin.py
Runs a `shlex`ed command using `subprocess.run`, keeping the default of
`shell=False`. This is probaby frought with security concerns, which is why
this plugin is not included by default in `fauxmo.plugins`. By installing or
using it, you acknowledge that it could run commands from your config.json that
could lead to data compromise, corruption, loss, etc. Consider making your
config.json read-only. If there are parts of this you don't understand, you
should probably not use this plugin.
If the command runs with a return code of 0, Alexa should respond prompty
"Okay" or something that indicates it seems to have worked. If the command has
a return code of anything other than 0, Alexa stalls for several seconds and
subsequently reports that there was a problem (which should notify the user
that something didn't go as planned).
Note that `subprocess.run` as implemented in this plugin doesn't handle complex
commands with pipes, redirection, or multiple statements joined by `&&`, `||`,
`;`, etc., so you can't just use e.g. `"command that sometimes fails || true"`
to avoid the delay and Alexa's response. If you really want to handle more
complex commands, consider using this plugin as a template for another one
using `os.system` instead of `subprocess.run`, but realize that this comes with
substantial security risks that exceed my ability to explain.

"""

from functools import partialmethod  # type: ignore
import shlex
import subprocess

from fauxmo.plugins import FauxmoPlugin


class CommandLinePlugin(FauxmoPlugin):
    """Fauxmo Plugin for running commands on the local machine."""

    def __init__(self, name: str, port: int, on_cmd: str, off_cmd: str) \
            -> None:
        """Initialize a CommandLinePlugin instance.
        Args:
            name: Name for this Fauxmo device
            port: Port on which to run a specific CommandLinePlugin instance
            on_cmd: Command to be called when turning device on
            off_cmd: Command to be called when turning device off
       """

        self.on_cmd = on_cmd
        self.off_cmd = off_cmd

        super().__init__(name=name, port=port)

    def run_cmd(self, cmd: str) -> bool:
        """Partialmethod to run command.
        Args:
            cmd: Will be one of `"on_cmd"` or `"off_cmd"`, which `getattr` will
                 use to get the instance attribute.
        """

        command_str = getattr(self, cmd)
        shlexed_cmd = shlex.split(command_str)
        process = subprocess.run(shlexed_cmd)
        return process.returncode == 0

    on = partialmethod(run_cmd, "on_cmd")
    off = partialmethod(run_cmd, "off_cmd")

 

Prima – die Konfiguration ist nun fertig!

Jetzt ändern wir unser Konfigurations-File wie folgt ab:

sudo nano config.json

Inhalt:

  "FAUXMO": {
    "ip_address": "auto"
  },
  "PLUGINS": {
    "CommandLinePlugin": {
      "path": "/home/pi/commandlineplugin.py",
      "DEVICES": [
        {
            "name": "test",
            "port": 49915,
            "on_cmd": "python /home/pi/test-an.py",
            "off_cmd": "python /home/pi/test-aus.py"
        }
      ]
    }
  }
}

 

Jetzt starten wir den Raspberry neu und in der Zwischenzeit öffnen wir unsere Alexa App und entfernen die Geräte vom ersten Test. Hat der RasPi neu gebootet, wir eine erneute Suche nach Geräten durch geführt und siehe da – nun sollte erneut ein Test zu finden sein.

Wenn ihr nun sagt:
Alexa schalte „test“ ein
–> wird die LED zu leuchten beginnen
und wenn ihr sagt..
Alexa schalte „test“ aus
–> wird die LED erlöschen

 

Wir haben es geschafft!
Unsere Alexa steuert nun die Raspberry Pi Ausgänge wie wir es wünschen an!

Viel Spaß bei der Umsetzung!!

Fazit: 
Diese Anleitung bietet Euch eine gute Grundlage für die Steuerung von Aufgaben mittels Alexa auf einem Raspberry Pi. Im Grunde kann man nun damit wirklich fast alles damit anstellen, was man mit einen umsetzen kann. Denn jeder Befehl ..oder jedes weitere Script, kann entweder direkt über die Command Line oder dann eben indirekt über ein Python Script aufgerufen werden.