Beiträge von JoergZ

    Mit den bereits in #2 erwähnten persönlichen Einschränkungen:

    Bring zunächst mal die Sensoren in Gang, dass sie von Tasmota erkannt werden (Beitrag #5 von Einstein67

    Dann richtest du in Domoticz unter Menü Einrichtung -> Hardware ->Virtuellen Sensor erstellen einen neuen Sensor ein (für jeden Sensor wiederholen)

    Das Untermenü beim Einrichten des Sensors bietet dir verschiedene Typen an; irgend einer der Temp...-Typen sollte gehen

    Nach dem Abspeichern des neuen Sensors wechselst du in Domoticz auf Menü Einrichtung -> Geräte. Dort taucht dein neuer Sensor/en auf, in der Regel an letzter Stelle mit der höchsten IDX; IDX merken

    Jetzt rufst du die Weboberfläche deines Tasmota-Gerätes auf und gehst auf Einrichtung -> Geräte-Einstellung und wähle für den GPIO 14 (vermutlich) den 4. Typ

    Danach auf Einrichtung -> Domoticz und die von Domoticz angegebenen IDX-Nummern auf die möglichen Sensor-Eingabe-Felder verteilen.


    So sollte es gehen. Aber wie bereits gesagt: vom grünen Tisch aus.

    Domoticz lässt sich normaler zuverlässig nach der Beschreibung auf der Domoticz-Seite installieren. Trägheit und Blinken deuten darauf hin, dass deine Geräte einen MQTT-Broker suchen und nicht finden. Entweder MQTT-Funktion mit setoption3 0 abschalten (keine gute Idee beim Einsatz von Domoticz) oder richtige IP für den Broker angeben. Schau mal nach, ob auf der Schiene alles in Ordnung ist.

    Meine Antwort wird dich nicht vollständig zufrieden stellen, aber es sollte gehen (keine eigene Erfahrung). Siehe hier:

    https://github.com/arendst/Sonoff-Tasmota/issues/1109 Besonders interessant die Beiträge vom 08.01.2018 von reneb 24 und Theo. Weitere Infos auch hier: https://github.com/arendst/Son…wiki/Sensor-Configuration.

    Wenn du mal in der Konsole der Weboberfläche gpio und gpios eingibst, werden dir viele Infos um die Ohren gehauen. Falls du schon ein Tasmota-Gerät mit Sensor im Betrieb hast, werden dir die Ergebnisse durch Eingabe von status 10 in der Konsole angezeigt. Vermutlich erscheinen weitere Sensoren auch hier. Das musst du dann softwaremäßig auswerten. Ich hoffe es hilft dir ein bisschen weiter und lass es uns wissen, ob und wie es klappt.

    Von der Spracherkennung zur Sprachsteuerung: Snips JSON-Objekte zur Steuerung von Geräten verwenden

    Wie im Teil 2 dieser Artikelserie gezeigt, generiert Snips aus den aufgezeichneten und "verstandenen" Worten einen JSON-Ausdruck. In diesem Teil werde ich beispielhaft darstellen, wie dieser JSON-Ausdruck mit einem kleinen Python-Skript ausgewertet wird und Schaltvorgänge auf mit Tasmota geflashten Geräten ausgelöst werden bzw. MQTT benutzt wird, um die Hausautomation anzusteuern.


    Dabei gehe ich von folgender Konfiguration aus:

    • Snips (bzw. die Snips-Basis) ist auf einem Raspberry Pi installiert
    • Auf demselben Board (localhost) läuft bereits ein MQTT-Broker (mosquitto, IOBroker usw.)
    • Auf den Tasmota-Geräten ist MQTT aktiviert
    • Alle Tasmota-Geräte haben einen eindeutigen MQTT-Namen (= topic), z. B. Fernseher, Werkstattleuchte usw.
    • Das fulltopic auf den Geräten ist folgendermaßen konfiguriert: %topic%/%prefix%/
      Anmerkung: Es scheint, dass bei Tasmota-Versionen > 6.2.1 die fulltopic-Struktur %topic%/%prefix%/ voreingestellt ist. In älteren Versionen ist es %prefix%/%topic%/. Ich weise an dieser Stelle deshalb daraufhin, weil das Skriptbeispiel mit der neueren Struktur arbeitet. Bei einer anderen fulltopic-Struktur müssen die Funktionen im Skript entsprechend angepasst werden.
    • Das Python-Skript läuft ebenfalls auf demselben Gerät
      Anmerkung: Das muss nicht sein, es kann auch auf einem anderen Gerät laufen, denn es wird lediglich der Zugriff auf den MQTT-Broker benötigt. Da aber das Skript im 24/7-Modus läuft, macht es Sinn, es auf demselben Gerät zu starten.


    Schritt 1 Python-Bibliothek paho-mqtt installieren

    sudo pip install paho-mqtt

    Diese Bibliothek und ihre Funktionen werden gebraucht, um mit dem MQTT-Broker zu kommunizieren. Zudem wird die Bibliothek json benötigt. Diese wird nicht installiert, weil sie bereits vorhanden ist. Sie muss durch das Skript lediglich importiert werden.

    Hier nun ein Skript, das mit den Slots aus Teil 2 arbeitet (Dateiname sprachsteuerung.py):

    Dieses Skript muss noch mit dem Befehl chmod +x sprachsteuerung.py ausführbar gemacht werden und kann nun mit der Eingabe ./sprachsteuerung.py gestartet werden. Nun sollte, wenn z. B. der Satz "Hey Snips, schalte den Fernseher ein" gesprochen wird, das MQTT-Topic "Fernseher/cmnd/Power" mit der payload "1" ausgesendet werden.


    Überprüfen kann man das z. B. praktisch, indem man einem Testgerät den MQTT-Namen (topic) "Fernseher" gibt, z. B. auf der Tasmota-Console durch topic Fernseher oder eher "virtuell" indem wir eine weiteres Terminal öffnen und dort mit mosquitto_sub -h <IP MQTT-Broker> -t Fernseher/stat/# das Status-Topic abonnieren (subskribieren) . Damit können wir kontrollieren, ob das Topic (richtig) übermittelt wird.


    Sicherlich kann man die Auswertung des JSON-Strings auch anders vornehmen. Dies ist eine quick-and-dirty-Version um die Weiterverarbeitung der von Snips generierten MQTT Botschaften zu demonstrieren.


    Zum Schluss dieses Artikels möchte ich noch vorstellen, wie man einen systemd-Starter anlegt, damit das Skript bei einem (Neu-) Start des Rechners gleich geladen wird und von Anfang an läuft um die Sprachbotschaften umzusetzen:


    Auf dem Raspberry Pi wird mit dem Befehl

    sudo nano etc/systemd/system/multi-user.target.wants/sprachsteuerung.service

    eine neue Datei anlegen. Der Inhalt dieser Datei soll so aussehen:

    Mit STRG-x und y die Datei speichern und verlassen. Danach noch folgende Eingaben:

    sudo systemctl enable sprachsteuerung.service

    sudo systemctl start sprachsteuerung.service

    Nun läuft die Sprachsteuerung und würde nach jedem Neustart automatisch gestartet. Wenn die Kommentarzeichen # in den beiden Restart-Zeilen entfernt werden startet das Skript auch im Falle von Fehlern (z. B. Unerreichbarkeit des MQTT-Brokers) immer wieder neu. Sonst würde es bei einem solchen Zustand/Fehler einfach stoppen und die Sprachbefehlsausführung nicht mehr umsetzen.


    Grundsätzlich ist es möglich, dass die Ausführung von Skripten im Prinzip in Snips-Assistenten mit angelegt werden kann. Die Bezeichnung von Snips dafür ist es, eine action zu definieren. Diese wird in der Snips-Console an der Stelle angelegt, wo auch ein Intent definiert wird. Rechts neben dem Tab Intent befindet sich der Tab Action. Dort kann man unter Nutzung diverser Hermes-*-Python-Bibliotheken mehr oder weniger komplexe Skripte programmieren, die fest mit Snips verbunden werden. Doch die Aktivierung dieser Skripte ist nicht gerade ein Selbstläufer. Deshalb möchte ich hier nicht darauf eingehen.

    III. Mit Satelliten arbeiten


    Für eine angestrebte Sprachsteuerung macht es wenig Sinn, wenn man Sprachbefehle nur an einer Stelle eingeben kann und dazu sich noch einen Headset aufsetzen muss. Der folgende Artikel befasst sich zum einen mit der Konfiguration von Snips-Basis und Snips-Satelliten und zum anderen mit der Installation eines sogenannten Mikrofon-Arrays am Beispiel des preisgünstigen Respeaker-4-Mic. Am Ende des Artikel beschrebe ich die Installation eines Mikrofon-Arrays und gebe ein paar Tips zur Verstärkung der Tonausgabe.


    Als Satelliten sind andere Raspberry Pis sehr gut geeignet. Ein Zero-Modell oder ein Raspberry Pi 2 reichen völlig aus. Folgende Schritte sollten an diesem Raspberry Pi mittels SSH-Konsole vorgenommen werden:

    Code
    1. sudo apt update
    2. sudo apt upgrade
    3. sudo apt install -y dirmngr
    4. sudo bash -c 'echo "deb https://raspbian.snips.ai/$(lsb_release -cs) stable main" > /etc/apt/sources.list.d/snips.list'
    5. sudo apt-key adv --keyserver pgp.surfnet.nl --recv-keys D4F50CDCA10A2849
    6. sudo apt update
    7. sudo apt install snips-hotword-model-heysnipsv4
    8. sudo apt install snips-satellite

    Das Paket snips-satellite beinhaltet alle Komponenten, die vor Ort erforderlich sind. Die Verarbeitung findet auf der Snips-Basis statt. Als nächstes sicherstellen, dass der Snips-Satellit die richtige Hardware benutzt, also mit sudo raspi-config die 3,5 mm Klinkenbuchse als Audio-Ausgabe konfigurieren: Punkt 7 - Advanced Options ansteuern, danach Punkt 4 - Audio und dort 1 Force 3.5mm (‘headphone‘) jack auswählen.


    Nun durch sudo nano /etc/hostname den Rechnernamen von raspberrypi auf einen eindeutigen ändern z. B. satellite01 oder wohnzimmer usw. Mit Strg-X[tt] anschließend [tt]y die Änderung speichern und den Satelliten neu starten. Anschließend wieder per SSH (z. B. ssh pi@satellite01.local) neu einloggen und mit sudo nano /etc/snips.toml die Konfigurationsdatei des Satelliten bearbeiten. Im Abschnitt [snips-common] in der zweiten Zeile das Kommentarzeichn # und den Leerschritt löschen und die IP-Nummer (oder rechnername.local) des Snips-Basis-Gerätes eingeben, sodass dort z. B. mqtt = "192.168.168.XXX:1883"[tt] (oder z. B. mqtt = "snips-base.local:1883"[tt] - wenn der hostname des Gerätes snips-base lautet) steht.

    Die zweite Änderung findet im Abschnitt [tt][snips-audio-server] statt. Hier muss die Zeile bind = ... auskommentiert werden (also das Zeichen # löschen) und folgendes eingegeben werden bind = "satellite01.local@mqtt" wenn der Satelliten-Raspi den hostname satellite01 trägt. Man kann an dieser Stelle natürlich auch die IP-Nummer des Satelliten eingeben. Mit Strg-X[tt] anschließend [tt]y die Änderung speichern und den Satelliten neu starten.


    Im nächsten Schritt per SSH in den Raspi, der die Snips-Basis ist, einloggen und ebenfalls mit sudo nano /etc/snips.toml die Konfigurationsdatei der Snips-Basis bearbeiten. Wir gehen zum Abschnitt [snips-audio-server] und entfernen dort von der Zeile bind = ... das Kommentarzeichen # und geben anstelle des default den Rechnernamen der Snips-Basis (oder die IP-Nummer) an. Wenn an der Basis ebenfalls Spracheingaben erfolgen sollen muss im Abschnitt [snips-hotword] die Zeile audio = ... bearbeitet werden. Sie wird auskommentiert und anstelle des Plus-Zeichens wird der hostname oder die IP-Nummer der Snips-Basis eingegeben. Anschließend auch dieses Gerät neu starten bzw. mit sudo systemctl restart snips-* alle Snips-Dienste neu starten und ausloggen.


    Als nächsten die USB-Soundkarte am Satelliten anschließen und auf dem Client-Rechner (siehe Beschreibung der Arbeitsumgebung in Teil 1) zur Sicherheit zunächst sam disconnect eigeben und anschließen sam connect satellite01.local eingeben bzw. den vergebenen Namen oder die IP-Nummer. Anmeldenamen und Passwort eingeben bzw. bestätigen. Nun konfigurieren wir den Satelliten. Mit sam setup audio überprüfen wir, ob snips die Audio-Hardware richtig erkennt (siehe Teil 1). Durch die Eingabe von sam test speaker und sam test microphone können wir zusätzliche Test machen. Wenn alles läuft, sollte nach einem beherzt gesprochenem "Hey snips" ein Ton zu hören sein: Die Basis hat das "Hotword" empfangen und warten auf weitere Ansagen.


    Auf diese Weise kann man weitere Satelliten-Geräte konfigurieren, wobei nur noch die Datei /etc/snips.toml auf den Satelliten bearbeitet werden muss.


    Ein Laptop, der unter Ubuntu 18.04 läuft, lässt sich ebenfalls als Satellit installieren. Dazu sind allerdings andere Paketquellen und ein anderer Signaturschlüssel anzugeben:

    sudo bash -c ‘echo “deb https://debian.snips.ai/stretch 10 stable main” > /etc/apt/sources.list.d/snips.list’

    sudo apt-key adv --keyserver pgp.mit.edu --recv-keys F727C778CCB0A455

    sudo apt update

    sudo apt install snips-hotword-model-heysnipsv4

    sudo apt install snips-satellite

    Nun kann ich mit "Hey Snips - Schalte den Drucker ein!" den Drucker unter Strom setzen, wenn ich ihn brauche. Ausgeschaltet wird er natürlich mit "Hey Snips - Schalte den Drucker aus!". Doch dazu später...



    IV Freisprecheinrichtung mit einem Mikrofon-Array: Respeaker-4-mic

    Sicherlich kann man sich auch eine Freisprecheinrichtung bauen, indem man einen Raspberry Pi 3 als Satellit einsetzt und einen Bluetooth-Headset benutzt. Damit befasse ich mich hier nicht, wäre aber eine interessante Ergänzung.


    Ich habe mir für meine beiden Satelliten zwei MakerHawk ReSpeaker 4-Mic Array aus dieser Quelle bestellt, die zügig geliefert wurden. Im Wesentlichen bin ich der Anleitung auf der Website des Herstellers gefolgt (). Danach geht man folgendermaßen vor:

    Im stromlosen Zustand die Erweiterungskarte aufstecken, danach Stromversorgung anschließen und sich per SSH verbinden. Dann:

    Code
    1. sudo apt-get update
    2. sudo apt-get upgrade
    3. git clone https://github.com/respeaker/seeed-voicecard.git
    4. cd seeed-voicecard
    5. sudo ./install.sh
    6. sudo reboot

    Anschließend wieder verbinden und mit

    arecord -L

    prüfen, ob die Treiber installiert wurden und die Aufzeichnungsgeräte erkannt werden. Das Ergebnis sollte so aussehen:

    Nun von der SSH-Konsole abmelden und mit sam connect satellite01.local mit dem Satelliten verbinden und anschließen sam setup audio aufrufen. Die Frage nach dem Maker Kit unbedingt mit 'n' beantworten! Geräte wie bereits oben beschrieben auswählen nzw. bestätigen und anschließend Lautsprecher und Mikrofon testen. Falls es Probleme gibt, die Tipps von dieser Seite (https://github.com/snipsco/snips-issues/issues/148) durcharbeiten. Bei mir hat ziemlich weit unten der Tipp von cpoisson vom 27. Mai geholfen: Das innere Objekt slave in slave.pcm. Mit dem Mikrofon-Array kann man bis zu 5 Meter entfernt sein und Spracheingaben machen.


    Tipp für die Audio-Ausgabe: Die Lautstärke, die der Kopfhörer-Ausgang am Raspberry Pi liefert, ist echt mikrig. Ich habe mir zwei Miniverstärker besorgt (z. B. hier ) und zwei kleine 5-Watt-Lautsprecher von Pollin. Den Strom hole ich mir von der GPIO-Leiste (Pin 2 +5 V, Pin 6 GND). Man kann die Kabel gut an dem Anschlusstecker des ReSpeakers anlöten. Das ist physisch alles recht groß ausgeführt, sodass man auch als nicht sehr geübter Löter die Kabel für die Stromversorgung der Verstärkerplatine angebracht bekommt. Das Audio-Signal greife ich mir von einem 3,5 mm Stereo-Klinkenstecker ab. Die Spitze ist der linke Kanal, das zweite Segment der rechte Kanal und der hintere Abschnitt ist das gemeinsame Ground-Signal.


    Nun kann ich frei sprechen und der Quittungs-Ton ist deutlich zu hören. Auch die Sprachausgabe (wird später erläutert) ist in der Verstärkung gut zu verstehen. Natürlich kein HiFi, aber das wird hier auch nicht gebraucht.

    II. Snips das „Hören und Verstehen“ beibringen


    Dies ist der zweite Teil eines längeren Artikels. Der Erste Teil zur Installation von snips ist hier:

    Snips auf einem Raspberry Pi installieren


    Wenn die beiden Audio-Tests erfolgreich waren, kann snips im Prinzip bereits Tonquellen empfangen und Laute ausgeben. Aber das Programm weiß noch nicht, was es mit Spracheingaben machen soll. Es gibt noch keine Verbindung zu Aktionen. Dies wird mit dem Sprachtraining erreicht. Das Sprachtraining wiederum findet auf der Website von snips.ai statt. Wir dürfen deren KI und die gesammelten Sprachtrainings nutzen, um unsere Anweisungen zu trainieren. Dazu sind folgende Schritte erforderlich:

    Einen Account auf snips.ai anlegen

    Sich mit den Zugangsdaten einloggen

    Einen Assistenten (Arbeitsumgebung) anlegen (create assisstant) Eine App anlegen (create app)

    Einen Funktionszusammenhang oder Projekt anlegen (create intent) Eine Aktion (Vorgang) anlegen (create slot)


    Schritt 1: Einen Account anlegen

    Die Seite https://snips.ai aufrufen und rechts oben auf Sign Up klicken und sich anmelden.

    Danach geht es gleich los mit dem Klick auf Let‘s start öffnet man eine „Console“.


    Schritt 2: Einen Assistenten (Projekt, Arbeitsumgebung) anlegen

    Auf Create Assistant klicken, einen Namen vergeben, z. B. Versuch_1, und die Sprache auswählen. Dies ist wichtig für die Spracherkennung!


    Schritt 3: Eine App anlegen

    Auf Add an App klicken. Nun hat man die Auswahl zwischen frei gegebenen Apps anderer oder der Programmierung einer eigenen App. Ich empfehle zunächst eine eigene App zu bauen. Wenn man die Funktionsweise verstanden hat, kann später mit einer Fremd-App arbeiten. Also ist der nächste Schritt auf das Plus-Zeichen für Create a New App zu klicken. Wieder wird ein Name vergeben, z. B. App_1.


    Schritt 4: Einen Intent anlegen

    Klick auf Edit App um einen Intent anzulegen: + Create New Intent. Wieder muss ein Name (z. B. smarthome) und ggfs. Eine Bescheibung angelegt werden.


    Schritt 5: Die ersten beiden Slots anlegen

    Für dieses kleine Projekt legen wir den ersten Slot mit Create New Slot an und geben ihm den Namen „schalten“ und wählen bei Select unterhalb der Auswahlliste den Eintrag + Create New Slot Type aus. Als Slot Type Namen können wir z. B. „an_aus“ vergeben. Dann richten wir noch zwei Values ein. Das erste Value (anstelle von „Type yor value here“) ist die Ziffer 0. Als Synonyme wird eingeben: „aus,ausschalten,schalte aus“ (ohne Anführungszeichen). Nach dem Komma keine Leerstelle eingeben! Anschließend auf + Add klicken.

    Der zweite Value ist die Ziffer 1 mit den Synonymen „ein,einschalten,schalte ein“. Ebenfalls mit + Add speichern und rechts oben auf Close klicken.


    Nun legen wir noch einen zweiten Slot an mit dem Namen „geraete“ mit ebenfalls einem neuen Slot Type namens „geraete“. Darin den Value „Fernseher“ mit den Synonymen „Glotze,TV „ und den Value „Werkstattlampe“ mit den Synonymen „Werkstattleuchte,Lampe in der Werkstatt,Leuchte in der Werkstatt,Arbeitslicht,Licht in der Werkstatt“. Mit Close diesen Bereich verlassen und das Training beginnen.


    Schritt 6: Das erste Training

    Auf der linken Seite stehen unsere beiden Slots. In die Zeile „Type your training example“ wird nun eine Formulierung eingegeben z. B. „Bitte die Glotze ausschalten“ (ohne Anführungszeichen) und mit Klick auf + Add übergeben. Der Satz wandert nach unten. Dort nun mit Doppelklick das Wort „Glotze“ markieren. Es erscheinen am Cursor die beiden Slots „geraete“ und „an_aus“. Glotze gehört zum Slot geraete. Dieser wird ausgewählt. Das Wort ist nun in der Farbe des Slots markiert. Das Wort „ausschalten“ wird dem Slot „schalten“ zugewiesen. Der nächste Satz könnte lauten „Mache das Werkstattlicht an“. Aus diesem Satz „Werkstattlicht“ dem Slot geraete zuweisen und „an“ dem Slot schalten. Auf diese Weise noch drei, vier weitere Sätze eingeben und die entsprechenden Worte dem jeweiligen Slot zuweisen. Nicht vergessen zwischendurch und nach Eingabe der Trainingssätze unten auf Save zu klicken. Nach ein paar Trainingssätzen sieht es dann ungefähr so aus:



    Schritt 7: Leistungsprüfung und Ergebniskontrolle.

    Nun ist es an der Zeit den Headset an dem PC anzuschließen, der mit snips.ai verbunden ist. Rechts oben im Browserfenster gibt es ein Eingabefeld für Text. Wir fangen zunächst mit einem Satz aus dem Training an, z. B. Bitte die Glotze ausschalten <enter>. Nun erscheint dieser JSON-Code. Zur Verdeutlichung der Struktur, habe ich Leerzeilen eingefügt:


    Es gibt auf der obersten Ebene die Objekte intent, input und slots. Man kann das u. a. an der Tiefe der Einrückung erkennen. Für‘s Erste interessiert uns vor allem das Objekt slots. Slots ist ein Array (Liste, Tabelle) aus zwei Objekten. (Zum besseren Auffinden: Die beiden slots fangen mit "rawValue" an.) In der Syntax von JSON handelt es sich um slots[0] und slots[1]. Das erste Objekt enthält ein weiteres Objekt mit Angaben aus dem Slot „geraete“ (z. B. „slotName“ : „geraete“ ) und das zweite Angaben aus dem Slot „schalten“. Auch hier kann mann die Unterobjekte an der Tiefe der Einrückung identifizieren. Wichtig ist in beiden Slot-Objekten, was im darin enthaltenen Objekt value steht, die ihrerseits nochmals jeweils ein Objekt mit dem Namen value enthalten. Dort stehen die Werte, die nach Interpretation des Sprachausdrucks übermittelt werden sollen. Das ist im Falle des ersten Objektes „Fernseher“ (obwohl Glotze gesagt wurde) und im Falle des „schalten“-Objektes der Zahlenwert 0. Oder in der Syntax von JSON ausgedrückt steht „Fernseher“ in slots[0]['value']['value'] und die Null („0“) in slots[1]['value']['value']


    Wer sich ein bisschen mit JSON auskennt, sieht schon, dass sich aus diesem JSON-String mit allen gängigen Programmier- und Skriptsprachen alles Notwendige an Informationen herausziehen lässt, um Auswertungen vorzunehmen und weitere Befehle zu abzusetzen.


    Anstelle der Texteingabe kann nun auch die Eingabe mit Mikrofon erfolgen. Klicke auf das Mikrofon-Symbol und warte bis die Sprechaufforderung angezeigt wird. Sage dann einen Satz wie "Glotze ausmachen!" Nach wenigen Sekunden sollte der JSON-String erscheinen mit den beiden Slots und den korrekten Values Fernseher und 0.


    Falls bei der gesprochenen Sprache (oder auch dem schriftlichen Test) auffällt, dass eine Formulierung ganz oder teilweise nicht verstanden – die Slots fehlen dann - müssen die Synonymlisten ergänzt werden. Beispiel: Schalte das Programm ab. Das geht einfach: Mit der Maus zu dem Slot gehen. Es erscheint ein Editier-Stift. Darauf klicken und "schalte ab" und "abschalten" als Synonyme zum Value 0 im Slot schalten ergänzen und "Programm" als Synonym für Fernseher eintragen. Save und Training nicht vergessen! Hier schon mal der Hinweis, dass es heikel werden kann das Wort Programm als Synonym für Fernseher zu verwenden.


    Schritt 8: Die Spracherkennung auf den eigenen Raspberry Pi laden und offline verfügbar machen.

    Wir klicken im Browserfenster rechts unten auf Deploy Assistant und kopieren die nun angezeigte Zeile sam install assistant -i <Projektnummer>

    Wir wechseln wieder zu unserem Terminal-Fenster des Client Computers. Dort geben wir

    sam login<enter>

    Wir werden nach Benutzernamen (E-Mail-Adresse) und Passworts unseres Snips-Accounts gefragt.

    Das gespeicherte Arbeitsergebnis wird von unserem Client-Rechner mit dem Befehl

    sam install assistant -i Projektnummer auf den Raspberry Pi aufgespielt.

    Dann schließen wir unseren Headset wieder an den Raspberry Pi an und starten ihn neu. Wenn er hochgefahren ist, sprechen wir in das Mikrofon zunächst das Aufwach-Wort „Hey snips“. Es wird mit einem Pling quittiert. Danach einen Satz sagen Wie Schalte den Fernseher ein. Es erfolgt ein zweiter Pling, etwas tiefer. Falls ein sehr tiefer Ton erfolgt, hat snips nichts verstanden. Eventuell war die Pause nach dem Hey snips zu lang. Einfach versuchen. Ob snips tatsächlich was verstanden hat und das auch richtig, kann man auf zwei Wegen überprüfen. Der eine geht mit sam watch im Terminal des Client-Rechners. Zuerst sich jedoch mit sam connect mit dem Gerät verbinden und danach sam watch eingeben. Nach ein paar Sekunden mit Hey snips die Befehlssequenz einleiten und sprechen. Im Terminalfenster sollte der Originaltext und die Slots mit ihren Values erscheinen. (Hinweis: Das Bild ist aus einer anderen App mit den Slots „geraet“ und „Schaltzustand“; die Values sind „Schalter“ und „an“.)





    Der zweite Weg mit Hilfe des MQTT-Clients mosquitto_sub, mit dem wir das relevante Topic hermes/intent/# abonnieren. In einem weiteren Terminal geben wir ein:

    mosquitto_sub -h 192.168.178.20 -t hermes/intent/#

    Übersichtlicher wird es, wenn zunächst das Paket jq installiert wird und anschließend der Inhalt des Topics besser lesbar aufbereitet wird (Siehe dazu mein Artikel im Wiki ). Die entsprechende Befehle lauten dann:

    mosquitto_sub -h 192.168.178.20 -t hermes/intent/# | jq .

    oder

    mosquitto_sub -h 192.168.178.20 -t hermes/intent/# | jq .slots


    In noch folgenden Artikeln oder Ergänzungen werde ich auf folgende Themen eingehen:

    • Mit Satelliten arbeiten (Spracheingabe in mehreren Räumen),
    • Die Nutzung von Snips für die Heimautomation mittels MQTT (und später auch mittels HTTP),
    • Sprachausgabe mit Snips einrichten (TTS = Text To Speech bzw. Wiedergabe von WAV-Dateien),
    • Snips JSON-Ausdrücke mit Python auswerten.

    Einleitung

    Aufmerksam geworden bin ich auf SNIPS durch einen Beitrag von HoerMirAuf  hier und einen Beitrag in der c't in Heft 11/2019, S. 34-37. Ich fand Sprachsteuerung schon länger attraktiv, wollte mich aber auf keinen Fall noch weiter in die Fänge von Amazon, Google oder Apple begeben, genauso wenig wie in die Cloud irgendeines anderen Anbieters. Die Vorstellung, dass ständig irgend jemand mithört oder mithören kann, ist einfach nur gruselig. Deshalb war die Beschreibung eines Systems, das offline arbeitet und die Spracherkennung und -verarbeitung in meinem lokalen Netz betreibt eine richtiger Lichtblick und sofort von dem dringenden Gefühl des must-have bzw. must-make befeuert.


    Dieser Artikel befasst sich zunächst nur mit der Einrichtung von Snips auf einem Raspberry Pi und dem Anlegen einer Spracherkennung. In späteren Artikeln bzw. Ergänzungen zu diesem Artikel, werde ich auf folgende Themen eingehen:

    • Mit Satelliten arbeiten (Spracheingabe in mehreren Räumen),
    • Die Nutzung von Snips für die Heimautomation mittels MQTT (und später auch mittels HTTP),
    • Sprachausgabe mit Snips einrichten (TTS = Text To Speech bzw. Wiedergabe von WAV-Dateien),
    • Snips JSON-Ausdrücke mit Python auswerten.


    An Hard- und Sotware-Voraussetzungen hatte ich schon alles, was man dazu braucht: Einen Raspberry Pi

    Eine USB-Soundkarte mit Kopfhörer-Ausgang und Mikrofon-Eingang (China Billigmodell)

    Ein Headset – ebenfalls popelige Billigware



    Wer und was ist SNIPS und wie funktioniert es – Ein Kurzüberblick


    Wer mehr über SNIPS erfahren will, kann sich auf der Websiite snips.ai umsehen. Spannend ist, dass dieses kommerzielle Unternehmen seine KI zur Verfügung stellt, damit Privatanwender und Partner eigene Spracherkennungssysteme aufbauen können. Snips ist eine Anwendung, die auf der Grundlage von nodejs läuft, einen MQTT-Broker für den Nachrichtenaustausch benötigt und die Sprachanalyse als JSON-Ausdruck über den MQTT-Broker publiziert.

    Mit Hilfe von weiteren Programmier- oder Skriptsprachen (Python, bash, Perl) oder in Umgebungen wie OpenHab, IOBroker oder Domoticz können diese JSON-Ausdrücke vom MQTT-Broker abonniert (subscribe) und ausgewertet werden. Der MQTTBroker kann ein bereits vorhandener sein. Snips benutzt in der Standardinstallation seinen eigenen, der, wenn man will, auch mit einem vorhandenen gekoppelt werden kann. Ich habe mich dazu entschlossen, den bereits vorhandenen MQTT-Broker Mosquitto zu benutzen. Dazu später mehr.



    I. Installation von SNIPS


    Die Installation läuft größtenteils im Client-Server-Modus ab, d. h. Wir arbeiten nicht am Raspberry Pi direkt, sondern sind mit dem Raspberry Pi mittels SSH oder Putty verbunden. (Wie ein Raspberry Pi hergerichtet wird, erkläre ich hier nicht. Dazu gibt es hunderte von deutschsprachigen Webseiten. Ich gehe also davon aus, dass es sich um eine frische Installation handelt.)


    Der Client-Rechner (ein Linux- oder Windows-Rechner) ist also unser Arbeitsplatz. Dies wiederum bedeutet, dass sich der Snips-Rechner irgendwo in der Wohnung oder im Haus befinden könnte. Aus rein praktischen Gründen empfiehlt es sich für die ersten Schritte allerdings, wenn der Raspberry räumlich in der Nähe ist, weil Lautsprecher und Mikrofon in der Nähe sein sollten. Wie man mit Satelliten arbeitet, also mit in der Wohnung verteilten Mikrofonen und Lautsprechern, wird ebenfalls weiter unten erläutert.


    Nun geht’s aber los:


    Voraussetzung 1: Ein Raspberry mit aktueller Raspbian(-lite)-Version, eine externe USB-Soundkarte (für das Mikrofon), Lautsprecher am Analog-Ausgang (3,5 mm Klinkenbuchse), ins Netz eingebunden, SSH aktiviert.


    Voraussetzung 2: Ein anderer Rechner mit dem Paket/Programm npm. Mit Hilfe von npm wird der Raspberry Pi vom Client-Rechner aus konfiguriert.


    Schritt 1 Analog-Audio auf dem Raspberry Pi einrichten: Per SSH oder Putty auf den Raspberry Pi einloggen und mit sudo raspi-config das Konfigurationsprogramm des Raspberry Pi aufrufen.

    Dann Punkt 7 Advanced Options auswählen, danach Punkt 4 Audio und dort 1 Force 3.5mm (‘headphone‘) jack auswählen. Mit Auswahl von OK und Finish bestätigen; anschließend mit exit die SSH-Konsole des Raspberry Pi verlassen. Wir bleiben aber im Terminal des Client-Rechners


    Schritt 2 Auf dem Client-Rechner das Konfigurationsprogramm snips-sam installieren:

    Das Nachfolgende bezieht sich auf einen Ubuntu-Rechner, der als Client des Raspberry Pi eingesetzt wird.

    Im Terminal bleiben Per sudo apt install npm die nodejs-Paketverwaltung npm installieren. Alle Abhängigkeiten werden mit installiert. Danach sudo npm install -g snips-sam> abschicken. Ein Neustart des Rechners, mindestens des Terminals ist angeraten. (Auf Windows Rechner muss zunächst das Programm NodeJS und npm in der Windows-Version installiert und ohne sudo gearbeitet werden.)


    Schritt 3 Auf dem Raspberry snips installieren

    Wir öffnen nach dem Neustart des Client-Rechners wieder ein Terminal und geben sam connect raspberrypi ein und mit <enter> abschicken. Man wird nach dem Benutzernamen und nach dem Passwort gefragt. Standardmäßig sind „pi“ und „raspberrypi“ vorbelegt und können mit zweimal <enter> bestätigt werden. Hinweis: Dies funktioniert nur, wenn es nur genau einen Rechner mit dem Namen raspberrypi gibt. Sind mehrere Raspberry Pis im Netz aktiv, dann an Stelle des Rechnernamens die IP-Nummer des Gerätes angeben. Eine elegante Lösung ist es auch, dem Raspberry Pi mit dem Befehl sudo nano /etc/hostname einen anderen Hostnamen als raspberrypi zu geben. Dazu muss das Wort raspberrypi durch z. B. Snips-base ersetzt werden. Die Änderung speichern und den Raspberry Pi mit sudo reboot neustarten. Danach kann das Gerät auch mit dem Befehl sam connect snips-base.local angesprochen werden. Steht die Verbindung, dann wird mit sam init SNIPS auf dem Raspberry Pi installiert. Das dauert ein Weilchen, denn das System wird aktualisiert, neue Paketquellen eingerichtet und die snips-Komponenten werden heruntergeladen und installiert.



    Schritt 4 snips einrichten und testen

    Spätestens jetzt wird das Headset bzw. das Mikrofon mit der USB-Soundkarte und der Kopfhörer kann alternativ auch mit der 3,5 mm-Buchse des Raspberry verbunden werden. Als nächstes folgendes eingeben:

    sam setup audio

    Die Frage Is it a Snips Makers Kit? (Y/n) unbedingt verneinen mit „n“. Danach erscheint folgendes Bild:



    Da nur ein Eingabegerät (capture device = Mikrofon) entdeckt wurde, ist dies bereits ausgewählt. Allerdings verfügt der Raspberry über drei potentielle Ausgabegeräte: die 3,5 mm-Buchse (Karte 0, Gerät 0), der HDMI-Ausgang (Karte 0, Gerät 1) oder der Ausgang der USB-Soundkarte (Karte 1, Gerät 0). Je nach dem wo der Kopfhörer angeschlossen ist, mit der Cursortaste Karte und Gerät auswählen, anschließend <enter>.


    Nun Ausgang und Eingang testen:

    sam test speaker. Es sollte etwas zu hören sein. Mit <enter> den Test abbrechen. Danach:

    sam test microphone. Du wirst zum Sprechen augefordert. Zum Beenden irgendeine Taste drücken und das Gesprochene sollte zu hören sein. Jetzt testen wir noch, ob alle erforderlichen Dienste auf dem Raspberry Pi laufen. Dazu eingeben:

    sam status

    Es sollte sich folgendes Bild zeigen:




    Wenn es so aussieht, kannst du einen ersten Test machen, in dem du einfach die Worte „Hey snips“ sagst. Nach ein paar Sekundenbruchteilen erfolgt ein Ton. Normalerweise würde man dann einen Befehl sprechen. Damit kann snips aber noch nichts anfangen. Versuche es erst gar nicht. Nach weiteren Sekundenbruchteilen erfolgt ein weiterer Ton und eventuell ein tiefer, einen Fehler anzeigenden Ton.


    Zweiter Teil: Snips das Hören und Verstehen beibringen

    Ich kann nur nichts mit dem Fehlertext anfangen

    Naja, der besagt auch nur einen Kommunikationsfehler. Versuchen kannst du noch die Baudrate deutlich herunterzusetzen z. B. auf 9600. Mir ist auch schon einmal ein FTDI abgeraucht, also er ging auf einmal nicht mehr. Gründe unbekannt. Mit einem neuen hat wieder alles funktioniert.

    Du hast recht, ich habe das Script nicht weiterentwickelt, weil es wenig Nutzer gibt, die gerne mit der Konsole arbeiten. Die meisten ziehen grafische Tools vor, wie sie mit TasmoAdmin und QuickView von den Kollegen hier in diesem Forum vorgestellt wurden und gute Alternativen sind. Nicht zuletzt QuickView arbeitet ebenfalls serverless.

    Warum beim S20 nicht eine geänderte IP übernommen wurde, muss ich mal prüfen. Dazu melde ich mich noch einmal.

    Leider belegen die Protokollauszüge nicht, ob du die richtige IP-Adresse für den DNS Server benutzt.

    Gib doch mal auf einer Windows-Konsole

    ipconfig /all

    ein, bzw. auf einem (aktuellen) Linux-System ebenfalls im Terminal

    systemd-resolve --status | grep DNS


    In beiden Fällen siehst du, welcher DNS-Server in deinem lokalen Netz werkelt.


    Problematisch könnte es werden, wenn die Tasmota-Sonoffs in Subnetzen arbeiten. Da muss dann die Konfiguration der Subnetze passen. Das Gateway (ipaddress4) ist korrekt gesetzt?

    Die andere Anleitung oben verlinkt ( ich hoffe das ist okay ), funktionierte SOFORT auf einem Raspi 3+.

    Ich habe die Anleitung überflogen und sie ist wohl weitestgehend identisch (hab's nicht buchstabengetreu überprüft) mit der ersten Anleitung, die nils91 in diesem Forum ursprünglich gepostet hatte. Hätte mir an der Stelle (smartapfel) einen Dank oder Verweis gewünscht. Darüber hinaus habe ich Oggy1 und Nils benachrichtigt und um Überprüfung/Anpassung gebeten.

    Com Port ist 4 sollte passen. Rx und tx habe ich getauscht. Habe beim anschließen den pin mit auf gnd gehalten....

    Was heißt denn "sollte". Entweder ist der FTDI am COM4 oder nicht. Schau doch mal in deinen Gerätemanager, was dort für das FTDI-Board angegeben ist. (Und falls du unter Linux/Raspberry arbeitest, ist es nicht COMx sondern ttyUSB0.) Und schau bei Atom in die platformio.ini was bei upload_port steht. Stimmt das wirklich überein? Falls ja, ist es eine Frage des Timings, wie lange bzw. wie kurz der Pin auf GND gebracht wird. Was für ein Gerät ist es überhaupt? Habe im Feed ein paar Seiten zurück geblättert und finde da keinen älteren Beitrag von dir, wo etwas dazu drin steht....

    Ich habe so etwas gebaut mit einem 1-Wire-Drucksensor und dem MCP3008 10-Bit A/D Wandler. Der liefert Werte zwischen 0 und 1023. Über ein Python-Skript auf einem Raspberry Pi frage ich die Werte ab und je nach Druck, wird ein Basic per HTTP-Befehl geschaltet. Am Basic hängt eine Gartenwasserpumpe.

    Funktionsweise: Gartenwasserhahn auf -> Druck fällt unter Wert x -> Basic ON; Gartenwasserhahn zu -> Druck steigt über Wert y -> Basic OFF.

    Wenn du interessiert bist, kann ich dir mehr Infos zukommen lassen.

    Was meierseppl beschreibt ist doch das standardmäßige pulsetime-Verhalten. Wenn ein Power ON reinkommt, dann für Zeit x anschalten, danach wieder ausschalten. Ist doch so gemeint oder?

    Also:

    poweronstate 0

    pulsetime[1 ... 4] 200


    Das geht auch mit zusätzlichen Tastern an GPIO 14 oder am anderen, wenn switchmode1 3 eingestellt ist.

    PS: Bei Mehrkanalgeräten bezieht sich poweronstate allerdings auf alle Kanäle, nur die pulsetime lässt sich pro Kanal definieren.