Modul Babble: Unterschied zwischen den Versionen
Keine Bearbeitungszusammenfassung |
|||
(116 dazwischenliegende Versionen von 3 Benutzern werden nicht angezeigt) | |||
Zeile 1: | Zeile 1: | ||
{{Baustelle}} | |||
{{ | {{ | ||
Infobox Modul | Infobox Modul | ||
|ModPurpose=Das Modul stellt eine komfortable Oberfläche bereit, um per Webinterface ein 'Natural Language User Interface' (NLUI) zu konfigurieren | |ModPurpose=Das Modul stellt eine komfortable Oberfläche bereit, um per Webinterface ein 'Natural Language User Interface' (NLUI) zu konfigurieren. Es stellt auch einen ChatBot zur Verfügung. | ||
|ModType=h | |ModType=h | ||
<!-- |ModCategory= (noch?) nicht verwendet --> | <!-- |ModCategory= (noch?) nicht verwendet --> | ||
Zeile 9: | Zeile 10: | ||
|ModOwner=Prof. Dr. Peter A. Henning | |ModOwner=Prof. Dr. Peter A. Henning | ||
}} | }} | ||
Diese Seite beschreibt die Konfiguration und Verwendung des Moduls 95_Babble.pm | Diese Seite beschreibt die Konfiguration und Verwendung des Moduls 95_Babble.pm in der aktuellen Version (NOCHT NICHT IM UPDATE) | ||
= | =Einleitung= | ||
Das Modul ''95_Babble.pm'' | Das Modul ''95_Babble.pm'' nimmt geschriebene Sätze in natürlicher Sprache entgegen, führt gegebenenfalls einen Dialog mit dem Nutzer, erkennt schließlich darin enthaltene Anweisungen an FHEM und bringt diese - auch auf entfernten FHEM-Installationen - zur Ausführung. Es vereint also die drei Funktionalitäten | ||
* Absichtserkennung = ''Intent Recognition'' | |||
* Anweisungserkennung = ''Intent Handling'' | |||
* Dialogmanagement | |||
einer Sprachsteuerung (''Natural Language User Interface'' NLUI). Jeder dieser drei Blöcke ist optional und kann auch separat genutzt werden. | |||
=Babble-Device= | =Konzepte= | ||
*Babble erkennt automatisch [[#Generisches Gerät | generische Geräte]], das sind FHEM-Devices auf der lokalen oder einer entfernten FHEM-Installation, die das [[Attribut genericDeviceType]] gesetzt haben. Beispielsweise können dieses Leuchten (<code>genericDeviceType</code>=light) oder Thermostate (<code>genericDevicetype</code>=thermostat) sein. Eine Übersicht der erkannten Attributwerte findet man in dem oben verlinkten Wiki-Artikel. | |||
*Babble erkennt automatisch [[#Benanntes Gerät | benannte Geräte]] das sind FHEM-Devices auf der lokalen oder einer entfernten FHEM-Installation, die das Attribut babbleDevice gesetzt haben. Diese Funktion ermöglicht, beliebige FHEM-Devices (auch Dummy-Devices ohne irgendeinen Inhalt) als steuerbare oder abfragbare Entitäten zu definieren. | |||
=Funktionsweise= | |||
==Absichtserkennung (Intent Recognition)== | |||
Ein ''Intent'', also eine ''Handlungsabsicht'', wird durch die folgenden Komponenten eines natürlichsprachlichen Satzes definiert: | |||
*''Womit'' ist etwas zu tun, im Namensraum von FHEM also mit welchem Gerät=Device? | |||
*''Wo'' ist etwas zu tun? Dabei kann es sich um einen echten Raum (z.B. "Wohnzimmer") ebenso wie um eine speziellere Bezeichnung (z.B. "hinter dem Haus") oder um einen abstrakten Raum (z.B. "Kontrollraum") handeln. Aus diesem Grund sprechen wir dabei von einem Ort=Place. | |||
*''Was'' ist zu tun? Dabei handelt es sich in der Regel um ein Verb, also z.B. "machen", "stellen", "schalten" | |||
*''Welches Ziel'' soll die Handlung haben? Dabei kann es sich um eine Richtungsangabe handeln, z.B. "wärmer", oder um die Angabe eines Endwertes, z.B. "an" oder "aus", oder einen numerischen Wert. | |||
Es ist klar, dass in der menschlichen Sprache noch sehr viel komplexere Sätze gebildet werden können - etwa mit bestimmten Bedingungen darin. Beispielsweise könnte es durchaus sinnvoll sein, einer KI zu sagen ''Öffne das Fenster im Arbeitszimmer, wenn die Außentemperatur größer ist als 25 °C und es nicht regnet''. Solche komplizierten Sätze werden derzeit von Spracherkennungssystemen noch nicht beherrscht. | |||
Babble überprüft einen empfangenen natürlichsprachlichen Satz auf einen darin enthaltenen Orts-Identifikator (aus einer konfigurierbaren Liste <code>babblePlaces</code>), sowie auf ein darin enthaltenes Verb (aus einer konfigurierbaren Liste <code>babbleVerbs</code>) und Verbteilen (aus einer konfigurierbaren Liste <code>babbleVerbParts</code>). Ein weiteres darin enthaltenes Nomen wird je nach Artikeln und Verben als Gerät <code>babbleDevice</code> identifiziert. Der Rest des Satzes wird identifiziert als Zielwert. | |||
*Beispiel 1: Die beiden nachfolgenden Sätze führen jeweils zum gleichen Ergebnis, dem erkannten ''Intent'': '''Gerät=licht Ort=sitzgruppe Verb=schalten Ziel=ein''' | |||
**''Schalte die Beleuchtung in der Sitzgruppe an'' | |||
**''Beleuchtung in der Sitzgruppe anschalten'' | |||
*Beispiel 2: Der Satz ''Wie ist der Status vom Haus'' führt zum erkannten ''Intent'': '''Gerät=haus Ort=none Verb=sagen Ziel=status | |||
*Beispiel 3: Der Satz ''Stelle die Temperatur im Gästbad auf 20 Grad'' führt zum erkannten ''Intent'': '''Gerät=temperatur Ort=gästebad Verb=stellen Ziel=auf / 20 grad''' | |||
*Beispiel 4: Der Satz ''Spiele Musik im Arbeitszimmer von den Dubliners'' führt zum erkannten ''Intent'': '''Gerät=musik Ort=arbeitszimmer Verb=spielen Ziel=quelle / dubliners''' | |||
==Anweisungserkennung (Intent Handling)== | |||
===Benanntes Gerät=== | |||
Der Gerätename in Babble ist entweder der Name eines benannten Gerätes, d.h. das Attribut<code>babbleDevice</code> ist bei dem betreffenden FHEM-Device auf einen Namen gesetzt. Dieser ist ein von der FHEM-Bezeichung unabhängiger Begriff, der aber eindeutig mit einem FHEM-Device verbunden sein muss. In den obigen Beispielen ist das für das zweite und vierte Beispiel der Fall. Sollen verschiedene FHEM-Devices unter demselben BabbleNamen gefunden werden, müssen die Attributwerte sich durch angehängte <code>_<Ziffer></code> unterscheiden. Das kann z.B. genutzt werden, um mit dem Begriff ''Licht'' verschiedene FHEM-Devices (die sich nur im Ort unterscheiden) anzusprechen. In einem mehrfach geschachtelten Daten-Hash wird anschließend unter der Adresse<br/> | |||
*<code>''$hash->{DATA}{"command"}{"haus"}{"none"}{"sagen"}{"status"}''</code> für Beispiel 2<br/> | |||
*<code>''$hash->{DATA}{"command"}{"musik"}{"arbeitszimmer"}{"quelle"}''</code> für Beispiel 4<br/> | |||
nachgesehen, ob dort ein Kommando abgelegt worden ist. Diese Ablage erfolgt im Webfrontend von Babble und ist daher sehr flexibel. Für die genannten Beispiele könnten dies sein<br/> | |||
*<code>{speak('$PARM0',ReadingsVal('houseProfileC','message',' '))}</code> für Beispiel 2, also ein Perl-Code<br/> | |||
*<code>set SoundLinux.DG origin $VALUE</code> für Beispiel 4, also ein FHEM-Code mit Parameter <code>$VALUE</code>. | |||
===Generisches Gerät=== | |||
Oder der Gerätename in Babble ist der Name eines generischen Gerätes, d.h. das Attribut <code>genericDeviceType</code> ist bei dem betreffenden FHEM-Device auf einen zulässigen Wert gesetzt. In den obigen Beispielen ist das für das erste und dritte Beispiel der Fall. Babble schaut danach in einer anderen Datenstruktur nach, ob unter den generischen Geräten des betreffenden Typs eines ist, bei dem die Ortsangabe mit der im erkannten ''Intent'' übereinstimmt. In den obigen Beispielen trifft das zu auf die generischen Geräte<br/> | |||
*<code>''$hash->{DATA}{"local"}{"WZ.4x}("type" => "light", "place" => "sitzgruppe")''</code> für Beispiel 1 | |||
*<code>''$hash->{DATA}{"192.168.0.XX"}{"GB.HMHz_Clima"}("type" => "thermometer", "place" => "gästebad")''</code> für Beispiel 3 | |||
Die echten FHEM-Gerätenamen und der <code>genericDeviceType</code> werden dann verwendet, um sehr eingeschränkte und vordefinierte Kommandos auszuführen, nämlich | |||
*<code>set WZ.4x on</code> für Beispiel 1 | |||
*<code>set GB.HMHz_Clima desired-temp 21</code> für Beispiel 3 | |||
auszuführen. Welches diese Kommandos sind, wird eindeutig durch den den Gerätetyp und den Datenwert (''Ziel'') aus der Absichtserkennung bestimmt. Durch einen besonderen Mechanismus erfolgt die tatsächliche Ausführung im ersten Beispiel auf der lokalen FHEM-Installation, im dritten Beispiel aber auf einer entfernten FHEM-Installation unter der IP-Adresse 192.168.0.XX | |||
==Dialogmanagement== | |||
User: "Hallo" => Babble: "Hallo, ich bin Jeannie. Wer bist Du ?" (Hier antwortet der ChatBot, weil der unvollständige Eingangssatz nicht mit einem Kommando belegt ist) | |||
User: "Ich bin Peter." => Babble: "Schoen, Dich kennenzulernen, Peter!" (Hier antwortet wieder der ChatBot) | |||
User: "Was kannst Du für mich tun ?" => Babble: "Ich kann für Dich das Haus steuern." (Hier antwortet wieder der ChatBot) | |||
User: "Was kannst Du steuern ?" => Babble: "Ich kenne die Geräte Licht, ....." (Hier antwortet wieder der ChatBot, holt sich aber die Liste der Geräte aus den Babble-Daten) | |||
User: Wie kannst Du Licht steuern => Babble: "Sprich: Licht, gefolgt von einer Ortsangabe und dem Wort an oder aus" (Hier antwortet wieder der ChatBot, indem er den Hilfetext für das Gerät ''Licht'' von Babble holt) | |||
User: "Welche Orte kennst Du ?" => Babble: "Ich kenne die Orte Wohnzimmer, ....." (Hier antwortet wieder der ChatBot, holt sich aber die Liste der Orte aus den Babble-Daten) | |||
User: Schalte das Licht in der Sitzgruppe an. => Babble sagt nun gar nichts mehr, sondern schaltet das Licht in der Sitzgruppe an. | |||
=Geräte= | |||
Die Verbindung von (Babble-)Gerätenamen mit real existierenden FHEM-Devices erfolgt im unteren Bereich des Web-Frontends. Solche Geräte können entweder ''lokal'' sein, (also derselben FHEM-Instanz wie das Babble_Device angehören). Oder sie sind ''entfernte'' Geräte (''remote''). | |||
* Lokale Geräte sind dadurch gekennzeichnet, dass in ihrem FHEM-Device das Attribut <code>babbleDevice</code> auf den Wert des gewünschten Gerätenamens gesetzt wird (siehe [[#Vorarbeiten|Abschnitt Vorarbeiten]]). | |||
** Solche lokalen Geräte werden automatisch (d.h. ohne weitere nötige Vorarbeiten) in der Babble-Übersicht angezeigt. | |||
* Entfernte Geräte liegen in einer anderen FHEM-Instanz. Sie müssen in der Liste <code>babbleDevices</code> des Babble-Devices angegeben werden. | |||
**In der gegenwärtigen ersten Fassung des Moduls können drei solche anderen FHEM-Instanzen angegeben werden, dazu müssen die Attribute <code>remoteFHEM(1|2|3)</code> und (optional) <code>remoteFunc(1|2|3|4)</code> gesetzt werden. Bei der tatsächlichen Ausführung eines Befehls (siehe Abschnitt Nutzung) werden diese Attribute berücksichtigt | |||
==Nutzung== | |||
Zur Nutzung durch beliebige andere FHEM-Module muss nur das Perl-Unterprogramm | |||
Babble_DoIt("Babble","<zu analysierender Satz>"[,parm0,parm1,...]) | |||
aufgerufen werden (''Babble'' ist duch den tatsächlichen Device-Namen zu ersetzen). Die Anzahl der Parameter beim Aufruf ist nicht festgelegt, es kann eine beliebige Anzahl von Parametern im Aufruf angegeben werden. | |||
Bei der semantischen Analyse werden identifiziert | |||
* ein (Babble-)Gerätename ''device'' | |||
* eine Ortsangabe ''place'', diese darf auch leer bleiben (abgespeichert als Wert ''none'') | |||
* ein Verb ''verb'' in der Infinitiv-Form | |||
* eine Zielvariable, ggf. ein Reading ''target'' | |||
* ein Zielwert ''value'' | |||
Wird ein natürlichsprachlicher Satz korrekt interpretiert und ein dazu hinterlegtes Kommando (gespeichert im Babble-Hash $hash->{DATA}{"command"}) gefunden, werden in diesem Substitutionen durchgeführt. | |||
* der String $VALUE wird durch den Zielwert ''value'' ersetzt. | |||
* ein String $PARM[0|1|2..] wird durch den beim Aufruf übergebenen Wert parm0, parm1,... ersetzt. | |||
Durch diesen Mechanismus kann man den auszuführenden Kommandos verschiedene Parameter mitgeben. | |||
Anschließend wird dieses Kommando ausgeführt. Vor der Ausführung | |||
* Bei lokalen (Babble-)Geräten wird im Modul einfach | |||
fhem(<Kommando>) | |||
ausgeführt. | |||
* Bei entfernten (Babble-)Geräten gibt es zwei Möglichkeiten: | |||
** Wurde nur die IP-Adresse der entfernten FHEM-Instanz (im Attribut remoteFHEM(1|2|3)) angegeben, erfolgt die Ausführung durch den HTTP-Request | |||
http://<IP-Adresse:Port>/fhem?XHR=1&cmd.<FHEM-Device>=<Kommando> | |||
** Achtung: Wenn hierbei die entfernte FHEM-Instanz durch ein csrfToken geschützt ist, oder dieses sich bei jedem Neustart der externen FHEM-Instanz verändert, muss Babble dieses Token natürlich kennen. Mit dem Befehl | |||
get Babble tokens | |||
werden diese csrfToken für alle bei Babble gemeldeten externen FHEM-Instanzen geholt. Wer dieses manuelle Neuholen vermeiden möchte, sollte bitte ein festes csrfToken für die entfernte FHEM-Instanz definieren. Das csrfToken wird natürlich nur benötigt, wenn keine entsprechende remoteFunc (siehe entsprechendes Attribut) verwendet wird. | |||
** Wurde zusätzlich zur IP-Adresse der entfernten FHEM-Instanz ein Funktionsname (im Attribute remoteFunc(1|2|3)) angegeben, erfolgt die Ausführung durch den Aufruf der Funktion | |||
<remoteFunc(1|2|3)>("<Kommando>") | |||
===Hilfetexte=== | |||
Wird zu einem Device bei der entsprechenden Kombination aus Ortsangabe, Verb und Ziel kein hinterlegtes Kommando gefunden, kommt es zu einem anderen Ablauf. | |||
* Falls der ChatBot aktiv ist (d.h. das RiveScript-Modul muss installiert sein und darf nicht mit dem Attribut '''noChatBot=1''' blockiert werden), wird der gesamte Eingabesatz an diesen ChatBot weitergeleitet. Dieser liefert in jedem Fall eine Antwort, diese Antwort wird an Stelle des Parameters $HELP in das unter dem Attribut '''helpFunc''' hinterlegte FHEM-Kommando substituiert und dieses ausgeführt. | |||
* Falls der ChatBot nicht aktiv ist (d.h., entweder ist das RiveScript-Modul nicht installiert oder wurde durch das Attribut '''noChatBot=1''' blockiert), überprüft Babble, ob wenigstens ein Babble-Device erkannt wurde. Wenn ja, wird der diesem Babble-Device zugeordnete Hilfetext an Stelle des Parameters $HELP in das unter dem Attribut '''helpFunc''' hinterlegte FHEM-Kommando substituiert und dieses ausgeführt. | |||
In beiden Fällen werden in der '''helpFunc'''-Funktion auch die Parameter $PARM(0|1|2|...) durch die Werte ersetzt, die beim Aufruf der '''DoIt'''-Funktion übergeben wurden. | |||
Beispielsweise kann man mit der Hinterlegung von | |||
attr Babble helpFunc {speak('$PARM0','$HELP')} | |||
dafür sorgen, dass die Perl-Funktion speak mit dem entsprechenden Hilfetext ausgeführt wird. Also resultiert in diesem Fall | |||
Babble_DoIt("Babble","<zu analysierender Satz>",parm0[,parm1,...]) -> speak("parm0","<Antwort des ChatBot>") | |||
bzw. | |||
Babble_DoIt("Babble","<zu analysierender Satz>",parm0[,parm1,...]) -> speak("parm0","<Hilfetext für das betreffende Device>") | |||
===Test=== | |||
Zum Test der durch beliebige andere FHEM-Module muss nur das Perl-Unterprogramm | |||
Babble_TestIt("Babble","<zu analysierender Satz>",<exec-Flag>,[,parm0,parm1,...]) | |||
aufgerufen werden (''Babble'' ist duch den tatsächlichen Device-Namen zu ersetzen). Die Anzahl der Parameter beim Aufruf ist nicht festgelegt, es kann eine beliebige Anzahl von Parametern im Aufruf angegeben werden. | |||
* Wenn <exec-Flag>==1 ist, wird zusätzlich zur Ausgabe des Analysestrings auch noch das zugehörige Kommando ausgeführt. | |||
* Ansonsten erfolgt nur die Ausgabe des Analysestrings. | |||
Neben der Möglichkeit eines Online-Tests mit beliebigen Sätzen besteht auch noch die Möglichkeit zum Selbsttest des Moduls. Dazu ruft man den Befehl | |||
set Babble test | |||
auf. In der Ausgabe sieht man eine Vielzahl von Beispielsätzen und kann überprüfen, ob diese korrekt analysiert werden. | |||
=FHEM-Device für Babble= | |||
==Installation== | ==Installation== | ||
Durch den normalen Update-Mechanismus von FHEM ist das Modul 95_Babble.pm bereits im Modulordner /opt/fhem vorhanden, ebenso Datei babble.js in /opt/fhem/www/pgm2. | |||
Voraussetzung für die Funktionsfähigkeit von Babble ist das Vorhandensein des Perl-Moduls JSON, ggf. installieren mit <code>cpan JSON</code>. | |||
Wenn das Dialogmanagement mit Hilfe von Rivescript genutzt werden soll, muss man das Perl-Modul RiveScript installieren, entweder durch Download von [https://github.com/aichaos/rivescript-perl github], oder via CPAN (<code>cpan RiveScript</code>) | |||
Zusätzlich zu diesem Perl-Modul benötigt man dann noch RiveScript-Dateien (Endung .rive). Babble erzeugt einen RiveScript-Interpreter, dieser sucht seine Konfigurationsdateien (unter Linux) im Verzeichnis ''/opt/fhem/rivescript''. Die benötigten RiveScript-Dateien befinden sich im Contrib-Ordner [https://svn.fhem.de/trac/browser/trunk/fhem/contrib/Babble] und können folgendermassen direkt aus dem SVN kopiert werden: | |||
<br \><code>cd /opt/fhem && mkdir rivescript && cd rivescript && wget https://svn.fhem.de/trac/export/HEAD/trunk/fhem/contrib/Babble/begin.rive && wget https://svn.fhem.de/trac/export/HEAD/trunk/fhem/contrib/Babble/general.rive</code> | |||
Ein Tutorial für RiveScript findet man [https://www.rivescript.com/docs/tutorial hier]. | |||
==Definition== | ==Definition== | ||
Das Babble-Device - hier mit dem Namen '' | Das Babble-Device - hier mit dem Namen ''BBB'' versehen - selbst wird über | ||
define | define BBB Babble | ||
definiert. Diese Definition legt einen versteckten Raum "babbleRoom" an, welcher über einen Weblink im oberen Menü des Webinterfaces erreichbar ist. | definiert. Diese Definition legt einen versteckten Raum "babbleRoom" an, welcher über einen Weblink im oberen Menü des Webinterfaces erreichbar ist. | ||
*Der Name dieses Raumes kann durch das Attribut ''hiddenRoom'' geändert werden. | *Der Name dieses Raumes kann durch das Attribut ''hiddenRoom'' geändert werden. | ||
Zeile 27: | Zeile 152: | ||
gesetzt werden. Für dieses Wiki werden die deutschen Ausgabedaten verwendet. | gesetzt werden. Für dieses Wiki werden die deutschen Ausgabedaten verwendet. | ||
Beim Anklicken des Begriffes ''Babble'' (eben der genannte Weblink) im oberen Menü des Webinterfaces wird dieser versteckte Raum angezeigt. Er enthält an erster Stelle das | Beim Anklicken des Begriffes ''Babble'' (eben der genannte Weblink) im oberen Menü des Webinterfaces wird dieser versteckte Raum angezeigt. Er enthält an erster Stelle das FHEM-Device Babble. Für die Konfiguration dieses Devices siehe den nächsten Abschnitt, für die Bedienung siehe den Abschnitt [Bedienung]. | ||
==Grundlegende Arbeiten== | |||
*Will man ''lokale'' (d.h. in derselben FHEM-Instanz befindliche) [[#Benanntes Gerät | benannte Geräte]] per Babble ansteuern oder auslesen, muss man vorher im Device ''global'' dem Attribut ''userAttr'' ein neues global verfügbares Attribut ''babbleDevice'' hinzufügen. Dieses wird damit für jedes FHEM-Device setzbar. | |||
*Will man ''lokale'' (d.h. in derselben FHEM-Instanz befindliche) [[#Generisches Gerät | generische Geräte]] per Babble ansteuern oder auslesen, muss man vorher im Device ''global'' dem Attribut ''userAttr'' ein neues global verfügbares Attribut ''babbleDeviceType'' hinzufügen. Dieses wird damit für jedes FHEM-Device setzbar. Welche Werte für dieses Attribut von Babble erkannt werden, kann man im Artikel [[Attribut genericDeviceType]] nachlesen. | |||
*Will man ''remote'' (d.h. in einer entfernten FHEM-Instanz befindliche) [[#Benanntes Gerät | benannte Geräte]] per Babble ansteuern oder auslesen, muss man vorher | |||
**die entfernte FHEM-Instanz bei Babble bekannt machen. Dazu gibt es die Attribute ''remoteFHEM1 ... remoteFHEM4'', in diese muss jeweils die IP-Adresse der entfernten FHEM-Installation (inklusive) Port eingetragen werden. | |||
**das benannte Gerät wie folgt als durch Leerzeichen getrennte Liste in das Attribut ''babbleDevices'' eintragen: | |||
<Babble-Devicename>:<FHEM-Devicename in der entfernten Installation>:<Ziffer 1-4> | |||
Als Ziffer ist dabei die Ziffer zu verwenden, unter der diese entfernte FHEM-Instanz im vorigen Schritt als Attribut eingefügt worden ist. | |||
Beispiel: Auf der entfernten FHEM-Instanz, die unter der IP-Adresse 192.168.0.XX:8083 erreichbar ist, soll das Device ''Muell'' von Babble gesteuert oder ausgelesen werden. | |||
attr BBB remoteFHEM1 192.168.0.XX:8083 | |||
attr BBB babbleDevices Müllabfuhr:Muell:1 | |||
*Will man ''remote'' (d.h. in einer entfernten FHEM-Instanz befindliche) [[#Generisches Gerät | generische Geräte]] per Babble ansteuern oder auslesen, muss man vorher in dieser entfernten FHEM-Instanz | |||
**im Device ''global'' dem Attribut ''userAttr'' ein neues global verfügbares Attribut ''babbleDeviceType'' hinzufügen. Dieses wird damit für jedes FHEM-Device setzbar. Welche Werte für dieses Attribut von Babble erkannt werden, kann man im Artikel [[Attribut genericDeviceType]] nachlesen. | |||
**ein Hilfsmodul 99_BabbleUtils.pm im Ordner /opt/fhem/FHEM installieren (erhältlich im FHEM-SVN Ordner contrib/Babble). Das besteht nur aus wenigen Zeilen, aber ermöglicht Babble, aus der entfernten FHEM-Installation eine Liste der generischen Geräte per Http-Aufruf zu erhalten. Nach der Installation muss das entfernte FHEM neu gestartet werden, das Hilfsmodul wird dann automatisch geladen. | |||
==Set-Befehle == | ==Set-Befehle == | ||
Das Babble-Device kennt die folgenden Set-Befehle (''Babble'' ist duch den tatsächlichen Device-Namen zu ersetzen): | Das Babble-Device kennt die folgenden Set-Befehle (''Babble'' ist duch den tatsächlichen Device-Namen zu ersetzen): | ||
set Babble locked | unlocked | set Babble locked | unlocked | ||
Sperre oder entsperre das Überschreiben der persistenten Daten, siehe [[#Sperrung | Sperrung]]. | Sperre oder entsperre das Überschreiben der persistenten Daten, siehe [[#Sperrung | Sperrung]]. | ||
'''TIPP:''' Diese Sperre sollte bei Experimenten immer gesetzt sein. | |||
set Babble save | restore | set Babble save | restore | ||
Speichere die Daten persistent, oder hole sie aus der betreffenden Datei ''babbleFile'' (Achtung für Nutzer der configdb: Das File wird in der Datenbank abgelegt, nicht im Dateisystem). | Speichere die Daten persistent, oder hole sie aus der betreffenden Datei ''babbleFile'' (Achtung für Nutzer der configdb: Das File wird in der Datenbank abgelegt, nicht im Dateisystem). | ||
set Babble rivereload | |||
Erzeuge eine neue Instanz des RiveScript Interpreters und lese die Konfigurationsdaten neu ein. | |||
set Babble test | |||
Lasse eine interne Testsuite von Erkennungssätzen durchlaufen | |||
==Get-Befehle== | ==Get-Befehle== | ||
Das | Das Babble-Device kennt die folgenden Get-Befehle (''Babble'' ist duch den tatsächlichen Device-Namen zu ersetzen): | ||
get Babble version | |||
Gibt die Versionsnummer des Moduls zurück | |||
get | |||
Gibt die Versionsnummer des | |||
==Attribute== | ==Attribute== | ||
* | Das Babble-Device benötigt zum Funktionieren unbedingt ein paar wichtige Attribute mit Wortlisten. Bei der ersten Definition sollten diese automatisch belegt werden, können aber jederzeit geändert werden. | ||
*'''babblePlaces''' ist eine durch Leerzeichen separierte Liste von Orts-Identifikatoren, die in der Sprachsteuerung erkannt werden sollen. Die in FHEM bekannten ''Rooms''=Räume werden ebenfalls als Ortsbezeichnungen zur Verfügung gestellt und brauchen nicht in dieser Liste aufzutauchen. | |||
*'''babbleNotPlaces''' ist eine durch Leerzeichen separierte Liste von FHEM-Räumen, die ''nicht'' als Orts-Indentifikatoren erkannt werden sollen. | |||
*'''babbleStatus''' ist eine durch Leerzeichen separierte Liste von Status-Identifikatoren, also Nomen, die den Status eines Untersystems wiedergeben. Beispiel: ''Status Wert Wetter Zeit'' | |||
*'''babblePrepos''' ist eine durch Leerzeichen separierte Liste von Präpositionen. Beispiel: ''von vom des der in im auf bei am'' | |||
*'''babbleTimes''' ist eine durch Leerzeichen separierte Liste von Zeit-Adverbien, die eine Zeitangabe eines Untersystems signalisieren. Beispiel: ''heute morgen übermorgen nacht'' | |||
*'''babbleQuests''' ist eine durch Leerzeichen separierte Liste von Frage-Adverbien. Beispiel: ''wie wo wann'' | |||
*'''babbleArticles''' ist eine durch Leerzeichen separierte Liste von Artikeln. Beispiel: ''der die das den des dem zur'' | |||
*'''babbleVerbs''' ist eine durch Leerzeichen separierte Liste von Verbengruppen, die jeweils aus kommagetrennten Variationen und Konjugationen sowie einem davon per ':' getrennten Infinitiv bestehen. Beispiel: ''schalt,schalte:schalten mach,machs,mache:machen öffne:öffnen schließe,schließ:schließen'' | |||
*'''babbleVerbParts''' ist eine durch Leerzeichen separierte Liste von Verbteilen, die den durch das grundlegende Tun (beschrieben durch ein Verb, z.B. ''schließen'') erreichten Zustand festlegen (z.B. ''zu'' in zuschließen und ''auf'' in aufschließen). Beispiel für diese Liste: ''zu auf ent wider ein an aus ab um'' | |||
*'''babbleWrites''' ist eine durch Leerzeichen separierte Liste, die spezielle Verben enthält, die mit Schreiboperationen befasst sind. Beispiel: ''sagen senden hinzufügen entfernen ändern löschen'' | |||
* | *'''helpFunc''' ist ein FHEM-Kommando, das aufgerufen wird, wenn zu einem Eingabesatz zwar ein Device, aber kein passendes Kommando gefunden wird. Siehe betreffenden Abschnitt unter Benutzung. | ||
*'''testParm(0|1|2|3)''' sind Attribute, die bei reinen Tests von Babble-Erkennungen an Stelle der Parameter $PARM(0|1|2|3) eingesetzt werden. | |||
* | |||
* | *'''noChatBot''' muss auf 1 gesetzt werden, wenn zwar RiveScript als Modul im System vorhanden ist, der ChatBot aber nicht genutzt werden soll. | ||
* | *'''babbleIds''' ist eine durch Leerzeichen separierte Liste von Namen, unter denen Babble selbst angesprochen werden kann | ||
*'''babblePreSubs''' ist eine durch Leerzeichen separierte Liste von regulären Ausdrücken und Ersetzungsstrings, diese sind jeweils durch ''':''' getrennt. Diese Substitutionen werden vor der Normalisierung des Eingabesatzes angewandt. Leerzeichen in den regulären Ausdrücken oder den Ersetzungsstrings müssen im Attribut als ''\s'' angegeben werden. | |||
* | <regexp1>:<ersetzung1> <regexp2>:<ersetzung2> ... | ||
* | *'''remoteFHEM(0|1|2|3)''' ist die IP-Adresse (+ Port) einer entfernten FHEM-Instanz. Username und Passwort müssen ggf. ebenfalls angegeben werden, im Format <user>:<password>@<host>:<port> | ||
*'''remoteToken(0|1|2|3)''' ist der csrf-Token einer entfernten FHEM-Instanz, siehe [[Modul_Babble#Nutzung|Nutzung]] | |||
*'''remoteFunc(0|1|2|3)''' ist der Name einer Perl-Funktion, die aufgerufen wird, um die entfernte FHEM-Instanz anzusprechen. Hierbei kann beispielsweise das Modul RFHEM oder das Modul FHEM2FHEM eingesetzt werden. Die Angabe dieser Funktion ist optional - verzichtet man darauf, wird Babble versuchen, die entfernten FHEM-Devices durch einfache Web-Aufrufe zu steuern (und dafür wird natürlich der csrf-Token benötigt). | |||
*'''linkname''' ist der Name für den Link im FHEM-Menü. Default: '' | *'''babbleDevices''' ist eine durch Leerzeichen separierte Liste von (''remote''-)Device-Identifikatoren in der Form | ||
*'''hiddenroom''' ist der Name für den versteckten Raum, der das | <Babble Devicename>:<FHEM-Devicename>:<Ziffer> <Babble Devicename>:<FHEM-Devicename>:<Ziffer> ... <Babble Devicename>:<FHEM-Devicename>:<Ziffer> | ||
**Als Ziffer sind die Werte 0,1,2,3 erlaubt, sie teilen Babble mit, um welche der gegenwärtig möglichen vier verschiedenen entfernten FHEM-Instanzen (siehe Attribut remoteFHEM) es sich handelt. | |||
**Der Babble Devicename darf ein '''*'''-Zeichen enthalten. Ist dies der Fall, wird der Babble Devicename als regulärer Ausdruck interpretiert, in dem '''*''' durch '''(.*)''' ersetzt wird. Wenn Babble nun mit einem Satz aufgerufen wird, dessen Device-Teil auf diesen Ausdruck passt, wird die entsprechende Zeichengruppe in den Parameter ''$STAR'' übernommen. Taucht ''$STAR'' nun in der Kommandosequenz auf, wird dies durch den aktuellen Wert der Zeichengruppe ersetzt. Beispiel: der Babble-Devicename im Attribut sei ''*liste''. Wird nun im zu interpretierenden Satz der Devicename ''Einkaufsliste'' erkannt, enthält ''$STAR'' den Wert ''Einkaufs''. Im FHEM-Kommando, das Babble ausführt, wird ''$STAR'' dann durch ''Einkaufs'' ersetzt. | |||
*'''linkname''' ist der Name für den Link im FHEM-Menü. Default: ''Babble''. | |||
*'''hiddenroom''' ist der Name für den versteckten Raum, der das Babble-Device enthält. Default: ''babbleRoom'' | |||
*'''lockstate''' ist der Sperrzustand für das Device, siehe [[#Sperrung | Sperrung]] | *'''lockstate''' ist der Sperrzustand für das Device, siehe [[#Sperrung | Sperrung]] | ||
=Webinterface= | |||
In diesem Abschnitt wird die Bedienung des Webinterfaces und damit die Konfiguration des NLUI beschrieben. Um sie zu erreichen, klickt man auf den Begriff ''Babble'' im oberen Menü des Webinterfaces. | |||
==Babble Test== | |||
In diesem Teil des Webinterfaces kann ein Testsatz eingegeben werden. Durch anklicken des Buttons ''Test'' wird dieser analysiert und das Resultat der Analyse unmittelbar darunter angezeigt. Ist bereits ein FHEM-Kommando dafür definiert (siehe übernächsten Abschnitt), wird dieses ebenfalls angezeigt. Wenn man vorher die Checkbox ''Ausführung'' setzt, wird dieses FHEM-Kommando auch ausgeführt. | |||
* | |||
[[Datei:Babble_Test.png|600px|]] | |||
==Babble Orte und Babble Verben== | |||
Hier können im oberen Bereich zusätzliche Orts-Identifikatoren angegeben und mit Hilfe des Buttons ''Hinzufügen'' dem Attribut '''babblePlaces''' hinzugefügt werden. Wählt man stattdessen einen bereits definierten Orts-Identifikator aus, verändert sich der Button in einen ''Entfernen''-Button, zusätzlich erscheint ein Button zum ''Abbruch''. | |||
Hier können im unteren Bereich zusätzliche Verbengruppen angegeben und mit Hilfe des Buttons ''Hinzufügen'' dem Attribut '''babbleVerbs''' hinzugefügt werden. Wählt man stattdessen ein bereits definiertes Verb aus, verändert sich der Button in einen ''Entfernen''-Button, zusätzlich erscheinen ein Button zum ''Ändern'' und zum ''Abbruch''. | |||
[[Datei:Babble_Places.png|600px|]] | |||
==Babble Devices== | |||
In diesem Bereich können mit Dropdown-Listen die bekannten Orte, Verben, und Zielzustände ausgewählt werden, die in der semantischen Analyse erkannt werden. Zusätzliche Zeilen können mit dem Button ''Hinzufügen'' gewonnen werden, alle bis auf die erste Zeile für jedes Device können entfernt werden. | |||
In der ersten Zeile sollte ein Hilfetext eingetragen werden - dieser wird ausgegeben, wenn für dieses Device keine Kombination aus Raum, Verb und Ziel erkannt worden ist. Für neue Devices wird ein Vorschlag geliefert. | |||
Im rechten Feld wird dann das auszuführende FHEM-Kommando eingetragen. | |||
* Perl-Aufrufe werden dabei wie üblich in '''{..}''' Klammern eingeschlossen. | |||
* '''Achtung:''' Derzeit noch doppelte Anführungszeichen vermeiden, nur einfache Anführungszeichen sind erlaubt. | |||
= | [[Datei:Babble_Devices.png|600px|]] | ||
Das Babble- | ===Gruppierung=== | ||
Mit der Spracheingabe können ''verschiedene FHEM-Devices mit dem gleichen Babble-Device'' adressiert werden. Dafür müssen lediglich Babble-Devicenamen vergeben werden, die sich durch ein angehängtes | |||
_<Ziffern> | |||
voneinander unterscheiden. Beispiel | |||
* Ein entferntes FHEM-Device WZ.Scene (auf der entfernten FHEM-Instanz Nr. 1) wird im Attribut babbleDevices mit dem Babble-Devicenamen ''Licht'' definiert: | |||
attr Babble babbleDevices WZ.Scene:Licht:1 | |||
* Ein lokales FHEM-Device Schlafzimmerlampe erhält selbst ein Attribut | |||
attr Schlafzimmerlampe babbleDevice Licht_1 | |||
Die beiden werden dann im Webfrontend von Babble direkt untereinander dargestellt, jeweils mit eigenem Hilfetext. Für den Zweck der Konfiguration sind sie dann unterschiedliche Geräte (so, wie es ja auch semantisch richtig ist). Bei der Verarbeitung eines Eingabesatzes werden aber '''beide''' Geräte durch den Devicenamen ''Licht'' adressiert, d.h. Babble geht alle intern gespeicherten Geräte mit den Babble-Devicenamen ''Licht'', ''Licht_<Ziffern>'' durch und führt das erste passende Kommando aus. | |||
=Anwendungsbeispiele= | |||
==Temperatur abfragen== | |||
Im Beispiel gehen wir davon aus, dass es ein dummy-Device ''tempProfileC'' mit verschiedenen userReadings gibt, z.B. steht ''WZ.T'' für die Temperatur im Wohnzimmer. | |||
[[Datei:Babble_Temperatur.png|400px|]] | |||
Dieses dummy-Device erhält nun den Attributwert | |||
attr tempProfileC babbleDevice Temperatur | |||
Damit erscheint dieses Device mit FHEM-Devicename ''tempProfileC'' und Babble-Devicename ''Temperatur'' in der Liste der Babble-Devices. Im nächsten Schritt müssen dafür Kommandos angelegt werden. Für das Beispiel wollen wir die Temperatur im Schlafzimmer und im Wohnzimmer abfragen. Dazu müssen diese beiden Orte der Liste ''babblePlaces'' hinzugefügt werden, das geht im Webfrontend von Babble. | |||
Als erstes wollen wir die Frage stellen: '''Wie ist die Temperatur im Schlafzimmer'''. Babble ist derzeit intern so konfiguriert, dass eine Frage "wie ist" mit dem Verb ''sagen'' assoziiert wird. Weil ein konkretes Ziel nicht genannt wurde, setzt Babble als Ziel der Abfrage den ''Status'' des Gerätes ein. Nötig sind also die beiden Einträge | |||
$hash->{DATA}{"command"}{"temperatur"}{"schlafzimmer"}{"sagen"}{"status"} = <1. Kommando zur Ausgabe> | |||
$hash->{DATA}{"command"}{"temperatur"}{"wohnzimmer"}{"sagen"}{"status"} = <2. Kommando zur Ausgabe> | |||
Alternativ kann man auch den Befehl erteilen '''Sage den Wert der Temperatur im Schlafzimmer'''. Hier wird spezifisch der ''Wert'' abgefragt, sinnvoll sind also zwei weitere Einträge mit denselben Ausgaben | |||
$hash->{DATA}{"command"}{"temperatur"}{"schlafzimmer"}{"sagen"}{"wert"} = <1. Kommando zur Ausgabe> | |||
$hash->{DATA}{"command"}{"temperatur"}{"wohnzimmer"}{"sagen"}{"wert"} = <2. Kommando zur Ausgabe> | |||
Auch diese beiden Einträge lassen sich komfortabel über das Webfrontend von Babble machen. Für das Beispiel verwenden wir eine Perl-Funktion namens ''speak(<speechdevice>,<text>)'', die nichts weiter macht, als auf einem der dazu fähigen Devices (hier ''speechdevice'') die zuständige TTS (Text-to-Speech) Funktion aufzurufen. | |||
<1. Kommando zur Ausgabe> = {speak($PARM0,'Die Temperatur im Schlafzimmer beträgt '.ReadingsVal('tempProfileC','SZ.T','').' Grad')} | |||
<2. Kommando zur Ausgabe> = {speak($PARM0,'Die Temperatur im Wohnzimmer beträgt '.ReadingsVal('tempProfileC','WZ.T','').' Grad')} | |||
Der Parameter ''$PARM0'' wird dabei durch denjenigen ersten Parameter ersetzt, den die Erkennungsfunktion mitgeliefert bekommen hat (siehe oben). | |||
[[Datei:Babble_Temperatur2.png|800px|]] | |||
Nach dem ''Sichern'' steht das zur Verfügung. Übergibt man an Babble den Textstring '''Wie ist die Temperatur im Schlafzimmer''', wird auf den Sprachausgabedevices z.B. der Text ausgegeben '''Die Temperatur im Schlafzimmer beträgt 21 Punkt 4 Grad'''. Schönheitsfehler ist noch, dass der englische Dezimalpunkt mit ausgegeben wird. Das lässt sich aber problemlos beheben, indem die Perl-Funktion ''speakEG'' etwas aufgebohrt wird. Durch einen einfachen regulären Ausdruck kann man jeden Punkt zwischen Ziffern durch ein Komma ersetzen lassen. | |||
==Weckzeit setzen== | |||
Im Beispiel gehen wir davon aus, dass es ein FHEM-dummy-Device ''Alexa.Weckzeit'' gibt, dieses dummy-Device erhält nun den Attributwert | |||
attr Alexa.Weckzeit babbleDevice Wecker | |||
Damit erscheint dieses Device mit FHEM-Devicename ''Alexa.Weckzeit'' und Babble-Devicename ''Wecker'' in der Liste der Babble-Devices. Im nächsten Schritt müssen dafür Kommandos angelegt werden. | |||
Als Sprachbefehl soll verwendet werden '''Wecken um 18 Uhr 27'''. Babble ist derzeit intern so konfiguriert, dass eine dem Teilstring ''weck'' versehene Sprachnachricht automatisch mit dem Device ''Wecker'' und dem Verb ''stellen'' assoziiert wird. Nötig ist also erstens der Eintrag des Verbs ''stellen'' in die Liste der Verben (geht mit dem Webfrontend) sowie ein Eintrag | |||
$hash->{DATA}{"command"}{"wecker"}{"none"}{"stellen"}{"auf"} = <Kommando zum Stellen> | |||
Auch dieser Eintrag lässt sich komfortabel über das Webfrontend von Babble machen. Als Kommando zum Stellen trägt man nun ein | |||
set Weckzeit $VALUE | |||
Der String $VALUE wird bei der Ausführung durch den Value-Parameter ersetzt, den Babble bei der semantischen Analyse herausfiltert, also im Beispiel '''18:27 Uhr'''. Aus dem Weckzeit-Dummy kann man nun diese Weckzeit mit einem einfachen notify auf den "echten" Wecker übertragen (natürlich ein FHEM-Device...) | |||
[[Datei:Babble_Weckzeit.png|800px|]] | |||
==Wetter abfragen== | |||
In diesem Beispiel gehen wir davon aus, das in dem FHEM-Device ''wunderground'' drei Readings vorliegen: | |||
*fc0_message ist die Wettervorhersage für heute | |||
*fc1_message ist die Wettervorhersage für morgen | |||
*fc2_message ist die Wettervorhersage für übermorgen | |||
Das Device erhält nun den Attributewert | |||
attr wunderground babbleDevice Wetter | |||
Damit erscheint dieses Device mit FHEM-Devicename ''wunderground'' und Babble-Devicename ''Wetter'' in der Liste der Babble-Devices. Im nächsten Schritt müssen dafür Kommandos angelegt werden. Da bei der Analyse der Zeitwert (''heute'',''morgen'' oder ''übermorgen'') in der Variablen '''$VALUE''' abgelegt wird, reichen zwei Kommands aus, indem die Fallunterscheidung untergebracht wird: | |||
$hash->{DATA}{"command"}{"wetter"}{"none"}{"sagen"}{"wetter"} = <Kommando zur Abfrage> | |||
$hash->{DATA}{"command"}{"wetter"}{"none"}{"sagen"}{"status"} = <Kommando zur Abfrage> | |||
Auch dieser Eintrag lässt sich komfortabel über das Webfrontend von Babble machen. Als Kommando zur Abfrage trägt man nun in beide Felder ein: | |||
{speakEG(ReadingsVal('wunderground','fc'.(('$VALUE' eq 'übermorgen')?'2':(('$VALUE' eq 'morgen')?'1':'0')).'_message',' '))} | |||
Für das Beispiel verwenden wir eine Perl-Funktion namens ''speak(<speechdevice>,<text>)'', die nichts weiter macht, als auf einem der dazu fähigen Devices (hier ''speechdevice'') die zuständige TTS (Text-to-Speech) Funktion aufzurufen. Der Parameter ''$PARM0'' wird dabei durch denjenigen ersten Parameter ersetzt, den die Erkennungsfunktion mitgeliefert bekommen hat (siehe oben). | |||
[[Datei:Babble_Wetter.png|800px|]] | |||
[[Kategorie:Sprachsteuerung|Babble]] |
Aktuelle Version vom 6. Januar 2022, 11:11 Uhr
![]() |
An dieser Seite wird momentan noch gearbeitet. |
Babble | |
---|---|
Zweck / Funktion | |
Das Modul stellt eine komfortable Oberfläche bereit, um per Webinterface ein 'Natural Language User Interface' (NLUI) zu konfigurieren. Es stellt auch einen ChatBot zur Verfügung. | |
Allgemein | |
Typ | Hilfsmodul |
Details | |
Dokumentation | EN / DE |
Support (Forum) | Unterstuetzende Dienste |
Modulname | 95_Babble.pm |
Ersteller | Prof. Dr. Peter A. Henning |
Wichtig: sofern vorhanden, gilt im Zweifel immer die (englische) Beschreibung in der commandref! |
Diese Seite beschreibt die Konfiguration und Verwendung des Moduls 95_Babble.pm in der aktuellen Version (NOCHT NICHT IM UPDATE)
Einleitung
Das Modul 95_Babble.pm nimmt geschriebene Sätze in natürlicher Sprache entgegen, führt gegebenenfalls einen Dialog mit dem Nutzer, erkennt schließlich darin enthaltene Anweisungen an FHEM und bringt diese - auch auf entfernten FHEM-Installationen - zur Ausführung. Es vereint also die drei Funktionalitäten
- Absichtserkennung = Intent Recognition
- Anweisungserkennung = Intent Handling
- Dialogmanagement
einer Sprachsteuerung (Natural Language User Interface NLUI). Jeder dieser drei Blöcke ist optional und kann auch separat genutzt werden.
Konzepte
- Babble erkennt automatisch generische Geräte, das sind FHEM-Devices auf der lokalen oder einer entfernten FHEM-Installation, die das Attribut genericDeviceType gesetzt haben. Beispielsweise können dieses Leuchten (
genericDeviceType
=light) oder Thermostate (genericDevicetype
=thermostat) sein. Eine Übersicht der erkannten Attributwerte findet man in dem oben verlinkten Wiki-Artikel. - Babble erkennt automatisch benannte Geräte das sind FHEM-Devices auf der lokalen oder einer entfernten FHEM-Installation, die das Attribut babbleDevice gesetzt haben. Diese Funktion ermöglicht, beliebige FHEM-Devices (auch Dummy-Devices ohne irgendeinen Inhalt) als steuerbare oder abfragbare Entitäten zu definieren.
Funktionsweise
Absichtserkennung (Intent Recognition)
Ein Intent, also eine Handlungsabsicht, wird durch die folgenden Komponenten eines natürlichsprachlichen Satzes definiert:
- Womit ist etwas zu tun, im Namensraum von FHEM also mit welchem Gerät=Device?
- Wo ist etwas zu tun? Dabei kann es sich um einen echten Raum (z.B. "Wohnzimmer") ebenso wie um eine speziellere Bezeichnung (z.B. "hinter dem Haus") oder um einen abstrakten Raum (z.B. "Kontrollraum") handeln. Aus diesem Grund sprechen wir dabei von einem Ort=Place.
- Was ist zu tun? Dabei handelt es sich in der Regel um ein Verb, also z.B. "machen", "stellen", "schalten"
- Welches Ziel soll die Handlung haben? Dabei kann es sich um eine Richtungsangabe handeln, z.B. "wärmer", oder um die Angabe eines Endwertes, z.B. "an" oder "aus", oder einen numerischen Wert.
Es ist klar, dass in der menschlichen Sprache noch sehr viel komplexere Sätze gebildet werden können - etwa mit bestimmten Bedingungen darin. Beispielsweise könnte es durchaus sinnvoll sein, einer KI zu sagen Öffne das Fenster im Arbeitszimmer, wenn die Außentemperatur größer ist als 25 °C und es nicht regnet. Solche komplizierten Sätze werden derzeit von Spracherkennungssystemen noch nicht beherrscht.
Babble überprüft einen empfangenen natürlichsprachlichen Satz auf einen darin enthaltenen Orts-Identifikator (aus einer konfigurierbaren Liste babblePlaces
), sowie auf ein darin enthaltenes Verb (aus einer konfigurierbaren Liste babbleVerbs
) und Verbteilen (aus einer konfigurierbaren Liste babbleVerbParts
). Ein weiteres darin enthaltenes Nomen wird je nach Artikeln und Verben als Gerät babbleDevice
identifiziert. Der Rest des Satzes wird identifiziert als Zielwert.
- Beispiel 1: Die beiden nachfolgenden Sätze führen jeweils zum gleichen Ergebnis, dem erkannten Intent: Gerät=licht Ort=sitzgruppe Verb=schalten Ziel=ein
- Schalte die Beleuchtung in der Sitzgruppe an
- Beleuchtung in der Sitzgruppe anschalten
- Beispiel 2: Der Satz Wie ist der Status vom Haus führt zum erkannten Intent: Gerät=haus Ort=none Verb=sagen Ziel=status
- Beispiel 3: Der Satz Stelle die Temperatur im Gästbad auf 20 Grad führt zum erkannten Intent: Gerät=temperatur Ort=gästebad Verb=stellen Ziel=auf / 20 grad
- Beispiel 4: Der Satz Spiele Musik im Arbeitszimmer von den Dubliners führt zum erkannten Intent: Gerät=musik Ort=arbeitszimmer Verb=spielen Ziel=quelle / dubliners
Anweisungserkennung (Intent Handling)
Benanntes Gerät
Der Gerätename in Babble ist entweder der Name eines benannten Gerätes, d.h. das AttributbabbleDevice
ist bei dem betreffenden FHEM-Device auf einen Namen gesetzt. Dieser ist ein von der FHEM-Bezeichung unabhängiger Begriff, der aber eindeutig mit einem FHEM-Device verbunden sein muss. In den obigen Beispielen ist das für das zweite und vierte Beispiel der Fall. Sollen verschiedene FHEM-Devices unter demselben BabbleNamen gefunden werden, müssen die Attributwerte sich durch angehängte _<Ziffer>
unterscheiden. Das kann z.B. genutzt werden, um mit dem Begriff Licht verschiedene FHEM-Devices (die sich nur im Ort unterscheiden) anzusprechen. In einem mehrfach geschachtelten Daten-Hash wird anschließend unter der Adresse
$hash->{DATA}{"command"}{"haus"}{"none"}{"sagen"}{"status"}
für Beispiel 2$hash->{DATA}{"command"}{"musik"}{"arbeitszimmer"}{"quelle"}
für Beispiel 4
nachgesehen, ob dort ein Kommando abgelegt worden ist. Diese Ablage erfolgt im Webfrontend von Babble und ist daher sehr flexibel. Für die genannten Beispiele könnten dies sein
{speak('$PARM0',ReadingsVal('houseProfileC','message',' '))}
für Beispiel 2, also ein Perl-Codeset SoundLinux.DG origin $VALUE
für Beispiel 4, also ein FHEM-Code mit Parameter$VALUE
.
Generisches Gerät
Oder der Gerätename in Babble ist der Name eines generischen Gerätes, d.h. das Attribut genericDeviceType
ist bei dem betreffenden FHEM-Device auf einen zulässigen Wert gesetzt. In den obigen Beispielen ist das für das erste und dritte Beispiel der Fall. Babble schaut danach in einer anderen Datenstruktur nach, ob unter den generischen Geräten des betreffenden Typs eines ist, bei dem die Ortsangabe mit der im erkannten Intent übereinstimmt. In den obigen Beispielen trifft das zu auf die generischen Geräte
$hash->{DATA}{"local"}{"WZ.4x}("type" => "light", "place" => "sitzgruppe")
für Beispiel 1$hash->{DATA}{"192.168.0.XX"}{"GB.HMHz_Clima"}("type" => "thermometer", "place" => "gästebad")
für Beispiel 3
Die echten FHEM-Gerätenamen und der genericDeviceType
werden dann verwendet, um sehr eingeschränkte und vordefinierte Kommandos auszuführen, nämlich
set WZ.4x on
für Beispiel 1set GB.HMHz_Clima desired-temp 21
für Beispiel 3
auszuführen. Welches diese Kommandos sind, wird eindeutig durch den den Gerätetyp und den Datenwert (Ziel) aus der Absichtserkennung bestimmt. Durch einen besonderen Mechanismus erfolgt die tatsächliche Ausführung im ersten Beispiel auf der lokalen FHEM-Installation, im dritten Beispiel aber auf einer entfernten FHEM-Installation unter der IP-Adresse 192.168.0.XX
Dialogmanagement
User: "Hallo" => Babble: "Hallo, ich bin Jeannie. Wer bist Du ?" (Hier antwortet der ChatBot, weil der unvollständige Eingangssatz nicht mit einem Kommando belegt ist)
User: "Ich bin Peter." => Babble: "Schoen, Dich kennenzulernen, Peter!" (Hier antwortet wieder der ChatBot)
User: "Was kannst Du für mich tun ?" => Babble: "Ich kann für Dich das Haus steuern." (Hier antwortet wieder der ChatBot)
User: "Was kannst Du steuern ?" => Babble: "Ich kenne die Geräte Licht, ....." (Hier antwortet wieder der ChatBot, holt sich aber die Liste der Geräte aus den Babble-Daten)
User: Wie kannst Du Licht steuern => Babble: "Sprich: Licht, gefolgt von einer Ortsangabe und dem Wort an oder aus" (Hier antwortet wieder der ChatBot, indem er den Hilfetext für das Gerät Licht von Babble holt)
User: "Welche Orte kennst Du ?" => Babble: "Ich kenne die Orte Wohnzimmer, ....." (Hier antwortet wieder der ChatBot, holt sich aber die Liste der Orte aus den Babble-Daten)
User: Schalte das Licht in der Sitzgruppe an. => Babble sagt nun gar nichts mehr, sondern schaltet das Licht in der Sitzgruppe an.
Geräte
Die Verbindung von (Babble-)Gerätenamen mit real existierenden FHEM-Devices erfolgt im unteren Bereich des Web-Frontends. Solche Geräte können entweder lokal sein, (also derselben FHEM-Instanz wie das Babble_Device angehören). Oder sie sind entfernte Geräte (remote).
- Lokale Geräte sind dadurch gekennzeichnet, dass in ihrem FHEM-Device das Attribut
babbleDevice
auf den Wert des gewünschten Gerätenamens gesetzt wird (siehe Abschnitt Vorarbeiten).- Solche lokalen Geräte werden automatisch (d.h. ohne weitere nötige Vorarbeiten) in der Babble-Übersicht angezeigt.
- Entfernte Geräte liegen in einer anderen FHEM-Instanz. Sie müssen in der Liste
babbleDevices
des Babble-Devices angegeben werden.- In der gegenwärtigen ersten Fassung des Moduls können drei solche anderen FHEM-Instanzen angegeben werden, dazu müssen die Attribute
remoteFHEM(1|2|3)
und (optional)remoteFunc(1|2|3|4)
gesetzt werden. Bei der tatsächlichen Ausführung eines Befehls (siehe Abschnitt Nutzung) werden diese Attribute berücksichtigt
- In der gegenwärtigen ersten Fassung des Moduls können drei solche anderen FHEM-Instanzen angegeben werden, dazu müssen die Attribute
Nutzung
Zur Nutzung durch beliebige andere FHEM-Module muss nur das Perl-Unterprogramm
Babble_DoIt("Babble","<zu analysierender Satz>"[,parm0,parm1,...])
aufgerufen werden (Babble ist duch den tatsächlichen Device-Namen zu ersetzen). Die Anzahl der Parameter beim Aufruf ist nicht festgelegt, es kann eine beliebige Anzahl von Parametern im Aufruf angegeben werden.
Bei der semantischen Analyse werden identifiziert
- ein (Babble-)Gerätename device
- eine Ortsangabe place, diese darf auch leer bleiben (abgespeichert als Wert none)
- ein Verb verb in der Infinitiv-Form
- eine Zielvariable, ggf. ein Reading target
- ein Zielwert value
Wird ein natürlichsprachlicher Satz korrekt interpretiert und ein dazu hinterlegtes Kommando (gespeichert im Babble-Hash $hash->{DATA}{"command"}) gefunden, werden in diesem Substitutionen durchgeführt.
- der String $VALUE wird durch den Zielwert value ersetzt.
- ein String $PARM[0|1|2..] wird durch den beim Aufruf übergebenen Wert parm0, parm1,... ersetzt.
Durch diesen Mechanismus kann man den auszuführenden Kommandos verschiedene Parameter mitgeben.
Anschließend wird dieses Kommando ausgeführt. Vor der Ausführung
- Bei lokalen (Babble-)Geräten wird im Modul einfach
fhem(<Kommando>)
ausgeführt.
- Bei entfernten (Babble-)Geräten gibt es zwei Möglichkeiten:
- Wurde nur die IP-Adresse der entfernten FHEM-Instanz (im Attribut remoteFHEM(1|2|3)) angegeben, erfolgt die Ausführung durch den HTTP-Request
http://<IP-Adresse:Port>/fhem?XHR=1&cmd.<FHEM-Device>=<Kommando>
- Achtung: Wenn hierbei die entfernte FHEM-Instanz durch ein csrfToken geschützt ist, oder dieses sich bei jedem Neustart der externen FHEM-Instanz verändert, muss Babble dieses Token natürlich kennen. Mit dem Befehl
get Babble tokens
werden diese csrfToken für alle bei Babble gemeldeten externen FHEM-Instanzen geholt. Wer dieses manuelle Neuholen vermeiden möchte, sollte bitte ein festes csrfToken für die entfernte FHEM-Instanz definieren. Das csrfToken wird natürlich nur benötigt, wenn keine entsprechende remoteFunc (siehe entsprechendes Attribut) verwendet wird.
- Wurde zusätzlich zur IP-Adresse der entfernten FHEM-Instanz ein Funktionsname (im Attribute remoteFunc(1|2|3)) angegeben, erfolgt die Ausführung durch den Aufruf der Funktion
<remoteFunc(1|2|3)>("<Kommando>")
Hilfetexte
Wird zu einem Device bei der entsprechenden Kombination aus Ortsangabe, Verb und Ziel kein hinterlegtes Kommando gefunden, kommt es zu einem anderen Ablauf.
- Falls der ChatBot aktiv ist (d.h. das RiveScript-Modul muss installiert sein und darf nicht mit dem Attribut noChatBot=1 blockiert werden), wird der gesamte Eingabesatz an diesen ChatBot weitergeleitet. Dieser liefert in jedem Fall eine Antwort, diese Antwort wird an Stelle des Parameters $HELP in das unter dem Attribut helpFunc hinterlegte FHEM-Kommando substituiert und dieses ausgeführt.
- Falls der ChatBot nicht aktiv ist (d.h., entweder ist das RiveScript-Modul nicht installiert oder wurde durch das Attribut noChatBot=1 blockiert), überprüft Babble, ob wenigstens ein Babble-Device erkannt wurde. Wenn ja, wird der diesem Babble-Device zugeordnete Hilfetext an Stelle des Parameters $HELP in das unter dem Attribut helpFunc hinterlegte FHEM-Kommando substituiert und dieses ausgeführt.
In beiden Fällen werden in der helpFunc-Funktion auch die Parameter $PARM(0|1|2|...) durch die Werte ersetzt, die beim Aufruf der DoIt-Funktion übergeben wurden.
Beispielsweise kann man mit der Hinterlegung von
attr Babble helpFunc {speak('$PARM0','$HELP')}
dafür sorgen, dass die Perl-Funktion speak mit dem entsprechenden Hilfetext ausgeführt wird. Also resultiert in diesem Fall
Babble_DoIt("Babble","<zu analysierender Satz>",parm0[,parm1,...]) -> speak("parm0","<Antwort des ChatBot>")
bzw.
Babble_DoIt("Babble","<zu analysierender Satz>",parm0[,parm1,...]) -> speak("parm0","<Hilfetext für das betreffende Device>")
Test
Zum Test der durch beliebige andere FHEM-Module muss nur das Perl-Unterprogramm
Babble_TestIt("Babble","<zu analysierender Satz>",<exec-Flag>,[,parm0,parm1,...])
aufgerufen werden (Babble ist duch den tatsächlichen Device-Namen zu ersetzen). Die Anzahl der Parameter beim Aufruf ist nicht festgelegt, es kann eine beliebige Anzahl von Parametern im Aufruf angegeben werden.
- Wenn <exec-Flag>==1 ist, wird zusätzlich zur Ausgabe des Analysestrings auch noch das zugehörige Kommando ausgeführt.
- Ansonsten erfolgt nur die Ausgabe des Analysestrings.
Neben der Möglichkeit eines Online-Tests mit beliebigen Sätzen besteht auch noch die Möglichkeit zum Selbsttest des Moduls. Dazu ruft man den Befehl
set Babble test
auf. In der Ausgabe sieht man eine Vielzahl von Beispielsätzen und kann überprüfen, ob diese korrekt analysiert werden.
FHEM-Device für Babble
Installation
Durch den normalen Update-Mechanismus von FHEM ist das Modul 95_Babble.pm bereits im Modulordner /opt/fhem vorhanden, ebenso Datei babble.js in /opt/fhem/www/pgm2.
Voraussetzung für die Funktionsfähigkeit von Babble ist das Vorhandensein des Perl-Moduls JSON, ggf. installieren mit cpan JSON
.
Wenn das Dialogmanagement mit Hilfe von Rivescript genutzt werden soll, muss man das Perl-Modul RiveScript installieren, entweder durch Download von github, oder via CPAN (cpan RiveScript
)
Zusätzlich zu diesem Perl-Modul benötigt man dann noch RiveScript-Dateien (Endung .rive). Babble erzeugt einen RiveScript-Interpreter, dieser sucht seine Konfigurationsdateien (unter Linux) im Verzeichnis /opt/fhem/rivescript. Die benötigten RiveScript-Dateien befinden sich im Contrib-Ordner [1] und können folgendermassen direkt aus dem SVN kopiert werden:
cd /opt/fhem && mkdir rivescript && cd rivescript && wget https://svn.fhem.de/trac/export/HEAD/trunk/fhem/contrib/Babble/begin.rive && wget https://svn.fhem.de/trac/export/HEAD/trunk/fhem/contrib/Babble/general.rive
Ein Tutorial für RiveScript findet man hier.
Definition
Das Babble-Device - hier mit dem Namen BBB versehen - selbst wird über
define BBB Babble
definiert. Diese Definition legt einen versteckten Raum "babbleRoom" an, welcher über einen Weblink im oberen Menü des Webinterfaces erreichbar ist.
- Der Name dieses Raumes kann durch das Attribut hiddenRoom geändert werden.
- Dieses Modul verwendet das globale Attribut language zur Bestimmung der Anzeigedaten (Standard: EN=english). Für deutsche Ausgabedaten muss in FHEM das Attribut
attr global language DE
gesetzt werden. Für dieses Wiki werden die deutschen Ausgabedaten verwendet.
Beim Anklicken des Begriffes Babble (eben der genannte Weblink) im oberen Menü des Webinterfaces wird dieser versteckte Raum angezeigt. Er enthält an erster Stelle das FHEM-Device Babble. Für die Konfiguration dieses Devices siehe den nächsten Abschnitt, für die Bedienung siehe den Abschnitt [Bedienung].
Grundlegende Arbeiten
- Will man lokale (d.h. in derselben FHEM-Instanz befindliche) benannte Geräte per Babble ansteuern oder auslesen, muss man vorher im Device global dem Attribut userAttr ein neues global verfügbares Attribut babbleDevice hinzufügen. Dieses wird damit für jedes FHEM-Device setzbar.
- Will man lokale (d.h. in derselben FHEM-Instanz befindliche) generische Geräte per Babble ansteuern oder auslesen, muss man vorher im Device global dem Attribut userAttr ein neues global verfügbares Attribut babbleDeviceType hinzufügen. Dieses wird damit für jedes FHEM-Device setzbar. Welche Werte für dieses Attribut von Babble erkannt werden, kann man im Artikel Attribut genericDeviceType nachlesen.
- Will man remote (d.h. in einer entfernten FHEM-Instanz befindliche) benannte Geräte per Babble ansteuern oder auslesen, muss man vorher
- die entfernte FHEM-Instanz bei Babble bekannt machen. Dazu gibt es die Attribute remoteFHEM1 ... remoteFHEM4, in diese muss jeweils die IP-Adresse der entfernten FHEM-Installation (inklusive) Port eingetragen werden.
- das benannte Gerät wie folgt als durch Leerzeichen getrennte Liste in das Attribut babbleDevices eintragen:
<Babble-Devicename>:<FHEM-Devicename in der entfernten Installation>:<Ziffer 1-4>
Als Ziffer ist dabei die Ziffer zu verwenden, unter der diese entfernte FHEM-Instanz im vorigen Schritt als Attribut eingefügt worden ist. Beispiel: Auf der entfernten FHEM-Instanz, die unter der IP-Adresse 192.168.0.XX:8083 erreichbar ist, soll das Device Muell von Babble gesteuert oder ausgelesen werden.
attr BBB remoteFHEM1 192.168.0.XX:8083 attr BBB babbleDevices Müllabfuhr:Muell:1
- Will man remote (d.h. in einer entfernten FHEM-Instanz befindliche) generische Geräte per Babble ansteuern oder auslesen, muss man vorher in dieser entfernten FHEM-Instanz
- im Device global dem Attribut userAttr ein neues global verfügbares Attribut babbleDeviceType hinzufügen. Dieses wird damit für jedes FHEM-Device setzbar. Welche Werte für dieses Attribut von Babble erkannt werden, kann man im Artikel Attribut genericDeviceType nachlesen.
- ein Hilfsmodul 99_BabbleUtils.pm im Ordner /opt/fhem/FHEM installieren (erhältlich im FHEM-SVN Ordner contrib/Babble). Das besteht nur aus wenigen Zeilen, aber ermöglicht Babble, aus der entfernten FHEM-Installation eine Liste der generischen Geräte per Http-Aufruf zu erhalten. Nach der Installation muss das entfernte FHEM neu gestartet werden, das Hilfsmodul wird dann automatisch geladen.
Set-Befehle
Das Babble-Device kennt die folgenden Set-Befehle (Babble ist duch den tatsächlichen Device-Namen zu ersetzen):
set Babble locked | unlocked
Sperre oder entsperre das Überschreiben der persistenten Daten, siehe Sperrung. TIPP: Diese Sperre sollte bei Experimenten immer gesetzt sein.
set Babble save | restore
Speichere die Daten persistent, oder hole sie aus der betreffenden Datei babbleFile (Achtung für Nutzer der configdb: Das File wird in der Datenbank abgelegt, nicht im Dateisystem).
set Babble rivereload
Erzeuge eine neue Instanz des RiveScript Interpreters und lese die Konfigurationsdaten neu ein.
set Babble test
Lasse eine interne Testsuite von Erkennungssätzen durchlaufen
Get-Befehle
Das Babble-Device kennt die folgenden Get-Befehle (Babble ist duch den tatsächlichen Device-Namen zu ersetzen):
get Babble version
Gibt die Versionsnummer des Moduls zurück
Attribute
Das Babble-Device benötigt zum Funktionieren unbedingt ein paar wichtige Attribute mit Wortlisten. Bei der ersten Definition sollten diese automatisch belegt werden, können aber jederzeit geändert werden.
- babblePlaces ist eine durch Leerzeichen separierte Liste von Orts-Identifikatoren, die in der Sprachsteuerung erkannt werden sollen. Die in FHEM bekannten Rooms=Räume werden ebenfalls als Ortsbezeichnungen zur Verfügung gestellt und brauchen nicht in dieser Liste aufzutauchen.
- babbleNotPlaces ist eine durch Leerzeichen separierte Liste von FHEM-Räumen, die nicht als Orts-Indentifikatoren erkannt werden sollen.
- babbleStatus ist eine durch Leerzeichen separierte Liste von Status-Identifikatoren, also Nomen, die den Status eines Untersystems wiedergeben. Beispiel: Status Wert Wetter Zeit
- babblePrepos ist eine durch Leerzeichen separierte Liste von Präpositionen. Beispiel: von vom des der in im auf bei am
- babbleTimes ist eine durch Leerzeichen separierte Liste von Zeit-Adverbien, die eine Zeitangabe eines Untersystems signalisieren. Beispiel: heute morgen übermorgen nacht
- babbleQuests ist eine durch Leerzeichen separierte Liste von Frage-Adverbien. Beispiel: wie wo wann
- babbleArticles ist eine durch Leerzeichen separierte Liste von Artikeln. Beispiel: der die das den des dem zur
- babbleVerbs ist eine durch Leerzeichen separierte Liste von Verbengruppen, die jeweils aus kommagetrennten Variationen und Konjugationen sowie einem davon per ':' getrennten Infinitiv bestehen. Beispiel: schalt,schalte:schalten mach,machs,mache:machen öffne:öffnen schließe,schließ:schließen
- babbleVerbParts ist eine durch Leerzeichen separierte Liste von Verbteilen, die den durch das grundlegende Tun (beschrieben durch ein Verb, z.B. schließen) erreichten Zustand festlegen (z.B. zu in zuschließen und auf in aufschließen). Beispiel für diese Liste: zu auf ent wider ein an aus ab um
- babbleWrites ist eine durch Leerzeichen separierte Liste, die spezielle Verben enthält, die mit Schreiboperationen befasst sind. Beispiel: sagen senden hinzufügen entfernen ändern löschen
- helpFunc ist ein FHEM-Kommando, das aufgerufen wird, wenn zu einem Eingabesatz zwar ein Device, aber kein passendes Kommando gefunden wird. Siehe betreffenden Abschnitt unter Benutzung.
- testParm(0|1|2|3) sind Attribute, die bei reinen Tests von Babble-Erkennungen an Stelle der Parameter $PARM(0|1|2|3) eingesetzt werden.
- noChatBot muss auf 1 gesetzt werden, wenn zwar RiveScript als Modul im System vorhanden ist, der ChatBot aber nicht genutzt werden soll.
- babbleIds ist eine durch Leerzeichen separierte Liste von Namen, unter denen Babble selbst angesprochen werden kann
- babblePreSubs ist eine durch Leerzeichen separierte Liste von regulären Ausdrücken und Ersetzungsstrings, diese sind jeweils durch : getrennt. Diese Substitutionen werden vor der Normalisierung des Eingabesatzes angewandt. Leerzeichen in den regulären Ausdrücken oder den Ersetzungsstrings müssen im Attribut als \s angegeben werden.
<regexp1>:<ersetzung1> <regexp2>:<ersetzung2> ...
- remoteFHEM(0|1|2|3) ist die IP-Adresse (+ Port) einer entfernten FHEM-Instanz. Username und Passwort müssen ggf. ebenfalls angegeben werden, im Format <user>:<password>@<host>:<port>
- remoteToken(0|1|2|3) ist der csrf-Token einer entfernten FHEM-Instanz, siehe Nutzung
- remoteFunc(0|1|2|3) ist der Name einer Perl-Funktion, die aufgerufen wird, um die entfernte FHEM-Instanz anzusprechen. Hierbei kann beispielsweise das Modul RFHEM oder das Modul FHEM2FHEM eingesetzt werden. Die Angabe dieser Funktion ist optional - verzichtet man darauf, wird Babble versuchen, die entfernten FHEM-Devices durch einfache Web-Aufrufe zu steuern (und dafür wird natürlich der csrf-Token benötigt).
- babbleDevices ist eine durch Leerzeichen separierte Liste von (remote-)Device-Identifikatoren in der Form
<Babble Devicename>:<FHEM-Devicename>:<Ziffer> <Babble Devicename>:<FHEM-Devicename>:<Ziffer> ... <Babble Devicename>:<FHEM-Devicename>:<Ziffer>
- Als Ziffer sind die Werte 0,1,2,3 erlaubt, sie teilen Babble mit, um welche der gegenwärtig möglichen vier verschiedenen entfernten FHEM-Instanzen (siehe Attribut remoteFHEM) es sich handelt.
- Der Babble Devicename darf ein *-Zeichen enthalten. Ist dies der Fall, wird der Babble Devicename als regulärer Ausdruck interpretiert, in dem * durch (.*) ersetzt wird. Wenn Babble nun mit einem Satz aufgerufen wird, dessen Device-Teil auf diesen Ausdruck passt, wird die entsprechende Zeichengruppe in den Parameter $STAR übernommen. Taucht $STAR nun in der Kommandosequenz auf, wird dies durch den aktuellen Wert der Zeichengruppe ersetzt. Beispiel: der Babble-Devicename im Attribut sei *liste. Wird nun im zu interpretierenden Satz der Devicename Einkaufsliste erkannt, enthält $STAR den Wert Einkaufs. Im FHEM-Kommando, das Babble ausführt, wird $STAR dann durch Einkaufs ersetzt.
- linkname ist der Name für den Link im FHEM-Menü. Default: Babble.
- hiddenroom ist der Name für den versteckten Raum, der das Babble-Device enthält. Default: babbleRoom
- lockstate ist der Sperrzustand für das Device, siehe Sperrung
Webinterface
In diesem Abschnitt wird die Bedienung des Webinterfaces und damit die Konfiguration des NLUI beschrieben. Um sie zu erreichen, klickt man auf den Begriff Babble im oberen Menü des Webinterfaces.
Babble Test
In diesem Teil des Webinterfaces kann ein Testsatz eingegeben werden. Durch anklicken des Buttons Test wird dieser analysiert und das Resultat der Analyse unmittelbar darunter angezeigt. Ist bereits ein FHEM-Kommando dafür definiert (siehe übernächsten Abschnitt), wird dieses ebenfalls angezeigt. Wenn man vorher die Checkbox Ausführung setzt, wird dieses FHEM-Kommando auch ausgeführt.
Babble Orte und Babble Verben
Hier können im oberen Bereich zusätzliche Orts-Identifikatoren angegeben und mit Hilfe des Buttons Hinzufügen dem Attribut babblePlaces hinzugefügt werden. Wählt man stattdessen einen bereits definierten Orts-Identifikator aus, verändert sich der Button in einen Entfernen-Button, zusätzlich erscheint ein Button zum Abbruch.
Hier können im unteren Bereich zusätzliche Verbengruppen angegeben und mit Hilfe des Buttons Hinzufügen dem Attribut babbleVerbs hinzugefügt werden. Wählt man stattdessen ein bereits definiertes Verb aus, verändert sich der Button in einen Entfernen-Button, zusätzlich erscheinen ein Button zum Ändern und zum Abbruch.
Babble Devices
In diesem Bereich können mit Dropdown-Listen die bekannten Orte, Verben, und Zielzustände ausgewählt werden, die in der semantischen Analyse erkannt werden. Zusätzliche Zeilen können mit dem Button Hinzufügen gewonnen werden, alle bis auf die erste Zeile für jedes Device können entfernt werden.
In der ersten Zeile sollte ein Hilfetext eingetragen werden - dieser wird ausgegeben, wenn für dieses Device keine Kombination aus Raum, Verb und Ziel erkannt worden ist. Für neue Devices wird ein Vorschlag geliefert.
Im rechten Feld wird dann das auszuführende FHEM-Kommando eingetragen.
- Perl-Aufrufe werden dabei wie üblich in {..} Klammern eingeschlossen.
- Achtung: Derzeit noch doppelte Anführungszeichen vermeiden, nur einfache Anführungszeichen sind erlaubt.
Gruppierung
Mit der Spracheingabe können verschiedene FHEM-Devices mit dem gleichen Babble-Device adressiert werden. Dafür müssen lediglich Babble-Devicenamen vergeben werden, die sich durch ein angehängtes
_<Ziffern>
voneinander unterscheiden. Beispiel
- Ein entferntes FHEM-Device WZ.Scene (auf der entfernten FHEM-Instanz Nr. 1) wird im Attribut babbleDevices mit dem Babble-Devicenamen Licht definiert:
attr Babble babbleDevices WZ.Scene:Licht:1
- Ein lokales FHEM-Device Schlafzimmerlampe erhält selbst ein Attribut
attr Schlafzimmerlampe babbleDevice Licht_1
Die beiden werden dann im Webfrontend von Babble direkt untereinander dargestellt, jeweils mit eigenem Hilfetext. Für den Zweck der Konfiguration sind sie dann unterschiedliche Geräte (so, wie es ja auch semantisch richtig ist). Bei der Verarbeitung eines Eingabesatzes werden aber beide Geräte durch den Devicenamen Licht adressiert, d.h. Babble geht alle intern gespeicherten Geräte mit den Babble-Devicenamen Licht, Licht_<Ziffern> durch und führt das erste passende Kommando aus.
Anwendungsbeispiele
Temperatur abfragen
Im Beispiel gehen wir davon aus, dass es ein dummy-Device tempProfileC mit verschiedenen userReadings gibt, z.B. steht WZ.T für die Temperatur im Wohnzimmer.
Dieses dummy-Device erhält nun den Attributwert
attr tempProfileC babbleDevice Temperatur
Damit erscheint dieses Device mit FHEM-Devicename tempProfileC und Babble-Devicename Temperatur in der Liste der Babble-Devices. Im nächsten Schritt müssen dafür Kommandos angelegt werden. Für das Beispiel wollen wir die Temperatur im Schlafzimmer und im Wohnzimmer abfragen. Dazu müssen diese beiden Orte der Liste babblePlaces hinzugefügt werden, das geht im Webfrontend von Babble.
Als erstes wollen wir die Frage stellen: Wie ist die Temperatur im Schlafzimmer. Babble ist derzeit intern so konfiguriert, dass eine Frage "wie ist" mit dem Verb sagen assoziiert wird. Weil ein konkretes Ziel nicht genannt wurde, setzt Babble als Ziel der Abfrage den Status des Gerätes ein. Nötig sind also die beiden Einträge
$hash->{DATA}{"command"}{"temperatur"}{"schlafzimmer"}{"sagen"}{"status"} = <1. Kommando zur Ausgabe> $hash->{DATA}{"command"}{"temperatur"}{"wohnzimmer"}{"sagen"}{"status"} = <2. Kommando zur Ausgabe>
Alternativ kann man auch den Befehl erteilen Sage den Wert der Temperatur im Schlafzimmer. Hier wird spezifisch der Wert abgefragt, sinnvoll sind also zwei weitere Einträge mit denselben Ausgaben
$hash->{DATA}{"command"}{"temperatur"}{"schlafzimmer"}{"sagen"}{"wert"} = <1. Kommando zur Ausgabe> $hash->{DATA}{"command"}{"temperatur"}{"wohnzimmer"}{"sagen"}{"wert"} = <2. Kommando zur Ausgabe>
Auch diese beiden Einträge lassen sich komfortabel über das Webfrontend von Babble machen. Für das Beispiel verwenden wir eine Perl-Funktion namens speak(<speechdevice>,<text>), die nichts weiter macht, als auf einem der dazu fähigen Devices (hier speechdevice) die zuständige TTS (Text-to-Speech) Funktion aufzurufen.
<1. Kommando zur Ausgabe> = {speak($PARM0,'Die Temperatur im Schlafzimmer beträgt '.ReadingsVal('tempProfileC','SZ.T',).' Grad')} <2. Kommando zur Ausgabe> = {speak($PARM0,'Die Temperatur im Wohnzimmer beträgt '.ReadingsVal('tempProfileC','WZ.T',).' Grad')}
Der Parameter $PARM0 wird dabei durch denjenigen ersten Parameter ersetzt, den die Erkennungsfunktion mitgeliefert bekommen hat (siehe oben).
Nach dem Sichern steht das zur Verfügung. Übergibt man an Babble den Textstring Wie ist die Temperatur im Schlafzimmer, wird auf den Sprachausgabedevices z.B. der Text ausgegeben Die Temperatur im Schlafzimmer beträgt 21 Punkt 4 Grad. Schönheitsfehler ist noch, dass der englische Dezimalpunkt mit ausgegeben wird. Das lässt sich aber problemlos beheben, indem die Perl-Funktion speakEG etwas aufgebohrt wird. Durch einen einfachen regulären Ausdruck kann man jeden Punkt zwischen Ziffern durch ein Komma ersetzen lassen.
Weckzeit setzen
Im Beispiel gehen wir davon aus, dass es ein FHEM-dummy-Device Alexa.Weckzeit gibt, dieses dummy-Device erhält nun den Attributwert
attr Alexa.Weckzeit babbleDevice Wecker
Damit erscheint dieses Device mit FHEM-Devicename Alexa.Weckzeit und Babble-Devicename Wecker in der Liste der Babble-Devices. Im nächsten Schritt müssen dafür Kommandos angelegt werden.
Als Sprachbefehl soll verwendet werden Wecken um 18 Uhr 27. Babble ist derzeit intern so konfiguriert, dass eine dem Teilstring weck versehene Sprachnachricht automatisch mit dem Device Wecker und dem Verb stellen assoziiert wird. Nötig ist also erstens der Eintrag des Verbs stellen in die Liste der Verben (geht mit dem Webfrontend) sowie ein Eintrag
$hash->{DATA}{"command"}{"wecker"}{"none"}{"stellen"}{"auf"} = <Kommando zum Stellen>
Auch dieser Eintrag lässt sich komfortabel über das Webfrontend von Babble machen. Als Kommando zum Stellen trägt man nun ein
set Weckzeit $VALUE
Der String $VALUE wird bei der Ausführung durch den Value-Parameter ersetzt, den Babble bei der semantischen Analyse herausfiltert, also im Beispiel 18:27 Uhr. Aus dem Weckzeit-Dummy kann man nun diese Weckzeit mit einem einfachen notify auf den "echten" Wecker übertragen (natürlich ein FHEM-Device...)
Wetter abfragen
In diesem Beispiel gehen wir davon aus, das in dem FHEM-Device wunderground drei Readings vorliegen:
- fc0_message ist die Wettervorhersage für heute
- fc1_message ist die Wettervorhersage für morgen
- fc2_message ist die Wettervorhersage für übermorgen
Das Device erhält nun den Attributewert
attr wunderground babbleDevice Wetter
Damit erscheint dieses Device mit FHEM-Devicename wunderground und Babble-Devicename Wetter in der Liste der Babble-Devices. Im nächsten Schritt müssen dafür Kommandos angelegt werden. Da bei der Analyse der Zeitwert (heute,morgen oder übermorgen) in der Variablen $VALUE abgelegt wird, reichen zwei Kommands aus, indem die Fallunterscheidung untergebracht wird:
$hash->{DATA}{"command"}{"wetter"}{"none"}{"sagen"}{"wetter"} = <Kommando zur Abfrage> $hash->{DATA}{"command"}{"wetter"}{"none"}{"sagen"}{"status"} = <Kommando zur Abfrage>
Auch dieser Eintrag lässt sich komfortabel über das Webfrontend von Babble machen. Als Kommando zur Abfrage trägt man nun in beide Felder ein:
{speakEG(ReadingsVal('wunderground','fc'.(('$VALUE' eq 'übermorgen')?'2':(('$VALUE' eq 'morgen')?'1':'0')).'_message',' '))}
Für das Beispiel verwenden wir eine Perl-Funktion namens speak(<speechdevice>,<text>), die nichts weiter macht, als auf einem der dazu fähigen Devices (hier speechdevice) die zuständige TTS (Text-to-Speech) Funktion aufzurufen. Der Parameter $PARM0 wird dabei durch denjenigen ersten Parameter ersetzt, den die Erkennungsfunktion mitgeliefert bekommen hat (siehe oben).