Ich poste hier mal meine Gedankengänge.
Wenn es nicht interessiert, bitte ignorieren :)
Wenn der Thread zu unübersichtlich ist, bitte nicht schimpfen, ja?
Ich würde gerne FHEM mit einer mir verständlichen Sprache steuern.
Als Beispiel:
Ich sage "mache bitte alle Lichter aus."
Sollte ein FHEM Befehl werden im Sinne von:
set => mache (oder schalte)
*. => alle (oder überall)
LICHT => Lichter (oder Lampen)
OFF => aus
Zusammen:
set *.LICHT off
Jemand ne Idee, wie man das in Perl-Code gießt?
Das ganze sollte als Quelle eine Textdatei nehmen. Die könnte von einer Spracherkennung kommen, oder aus einer eMail. Was mir wichtig ist, ist dass man nicht jeden Befehl einzeln skriptieren muss, und z.B. auch auf den Satzbau keine Rücksicht nehmen bräuchte.
Mache im Wohnzimmer die Heizung an
wäre gleich mit
Mache die Heizung im Wohnzimmer an.
$Tue
$Stockwerk
$Raum
$Geraet
$Befehl
$Stimmung (könnte man vielleicht auswerten, um auf ein vorhandenes "Bitte" anders zu reagieren als ohne :)
Beste Grüße
Rince
Hi,
nachdem ich jetzt ein bisserl mehr gelesen und neue Dinge entdeckt habe, bringe ich diesen Thread nochmal hoch :)
Die FullScreen Browser App von Dirk http://forum.fhem.de/index.php/topic,10628.0.html (http://forum.fhem.de/index.php/topic,10628.0.html) hat ja schon eine gute Möglichkeit, gesprochenen Text in FHEM zu nutzen.
Leider ist die Abfrage mit diversen notifies noch nicht so richtig gut.
Daher bestünde vielleicht wirklich Bedarf für ein Modul, welches einen normalen Text nach diversen Schlagworten universell durchsucht und an Hand einer Matrix daraus Befehle bastelt?
AAh alles klar da ist das eindeutig besser aufgehoben als im TTS-Thread :D
Durchaus eine coole Idee das Grammatikunabhängige erkennen :)
Also die Texterkennung und Speicherung in eine Textdatei sollte ja mit deinem Modul aus "Der Raspi hört aufs Wort" möglich sein oder?
Anschließend kann man den Text aus der Datei auslesen (wie das in perl geht weiß ich allerdings nicht) , dann splitten und mit for-schleifen die einzelnen Variablen des Arrays auf die Schlagwörter durchsuchen. Anschließend aus den gefundenen Schlagworten den Fhem Befehl erstellen und ausführen :) - Also das ist jetzt mal eine Vorgehensweise die mir Spontan einfällt.
So in etwa war es gedacht, ja.
Nachdem die Web Fullscreen Browser App schon den Text bereit hält, scheint es klug den gleich zu benutzen, und optional wenn eine Textdatei da ist, deren Inhalt zu verarbeiten.
Aber genau das ist die Idee, ja :)
Hallo!
Diesen Gedanken finde ich sehr gut, war schon langer ein kleiner Wunsch, Fhem per Sprache zu steuern.
Hatte es ne Zeit mit der Android-App "AIVC" versucht, die Befehle gut umsetzten konnte auch mit Variablen,
doch setzte sie sehr oft aus und die Sprach Erkennung ließ nach ca.1m sehr nach.
Nutze jetzt auch das Modul von Tobi("Text2Speech") was die Ausgabe sehr angenehm macht.
Hoffe das in naher Zukunft vielleicht ein lösungs Ansatz finden könnten, stelle mich gerne zum Testen bereit, da meine Perl Kenntnisse nicht so dolle sind!
Mfg Steffen
Na, dann haben wir 3 schon was gemeinsam :)
Nämlich keine Ahnung von Perl :(
Ok,
keine Ahnung ob es der richtige Weg ist:
Ich zitiere mal von dieser Seite:
http://pronix.linuxdelta.de/Perl_cgi/Perl/perl_kurs_kapitel14.shtml (http://pronix.linuxdelta.de/Perl_cgi/Perl/perl_kurs_kapitel14.shtml)
#!/usr/bin/perl -w
use strict;
my $text = "Hallo Welt ich lerne Regulaere Ausdruecke kennen";
$_=$text;
if (/^Hallo/) {print "Hallo am Anfang des Textes gefunden\n";}
if(/Hallo/) {print "Hallo gefunden\n";}
#wird nicht ausgegeben
if(/^Welt/) {print "Welt am Anfang gefunden\n"}
if(/Welt/) {print "Welt gefunden\n";}
if (/kennen$/) {print "\"kennen\" steht am Ende\n";}
if (/kennen/) {print "\"kennen\" gefunden\n";}
#wird nicht ausgegeben
if (/^kennen/) {print "\"kennen\" steht am Anfang\n";}
print "Der 1. Buchstabe des Strings lautet " , /^(.)/ , "\n";
print "Der letzte Buchstabe ist ein ", /(.)$/ , "\n";
#Gibt kompletten String aus von Anfang ^ bis Ende $
print /^(.*)$/ , "\n";
Den müssen wir jetzt umbauen:
Das my $text = Muss später entweder auf den Wert verweisen, den Dirk in seiner App an FHEM schickt, oder aber auf eine Textdatei (die das Skript aus dem RasPi hört aufs Wort Thread erzeugt); vermutlich später User-konfigurierbar (dann könnte man auch eMails da reinwerfen, die dann entsprechend ausgeführt werden)
$Tue = set
$Stockwerk = OG
$Raum = 0
$Geraet = 0
$Befehl = 0
$Stimmung = false
$_=$text; #vermutlich braucht an jetzt eine Perl Funktion, um alle Großbuchstaben durch Kleinbuchstaben zu ersetzen, wer weiß wie die Spracherkennung es so hält
if !(^/Haussteuerung/) die #hier müsste quasi das Erste Wort "Haussteuerung" sein, sonst passiert nix => Gebt eurer Haussteuerung doch mal einen hübschen Namen :)
if (/ich bin ein sonderbefehl/) {print "Direkt den Sonderbefehl ausführen, also vermutlich eine fest definierte Befehlsfolge ausführen\n";
print "so wie es das alte Skript immer macht. Lies mir den Börsenbericht vor, z.B.\n"}
if (/ich bin ein anderer sonderbefehl/) {print "Direkt den anderen Sonderbefehl ausführen, also vermutlich eine fest definierte Befehlsfolge ausführen\n";
print "so wie es das alte Skript immer macht. Lies mir den Gefahrenbericht vor, z.B.\n"}
if(/bitte/) {$Stimmung=true;} # wir wissen jetzt, dass unsere Haussteuerung mit einem Bitte angesprochen wurde :)
if(/lichter/|/lampen/|/beleuchtung/) {$Geraet=*.LICHT;}
if(/Wohnzimmer/) {$Ort=_wz;}
if(/mache/|/schalte/|/stelle/) {$Tue=set;}
if(/ein/|/an/) {$Befehl=on;}
if(/aus/|/ab/) {$Befehl=off;}
{fhem $Tue $Stockwerk$Ort$Geraet $Befehl}
-1
So in meiner kindlichen Naivität jedenfalls.
Vermutlich hat das mit Perl soviel zu tun wie ein Sojawürstchen mit einem Schweinebraten, aber so in etwa könnte man sich das vielleicht vorstellen :)
@Rince
ich glaub man kann die Groß-und Kleinschreibung beim durchsuchen des strings einfach nicht beachten lassen mit if(/TeXt/i)
entweder mit dem i oder mit s dahinter bin ich mir nicht mehr sicher :D
ebenfalls könnte man die Schlüsselwörter nach denen gesucht werden soll über ein oder mehrere attribute definiern und in ein array packen
man kann dann nämlich einfach if(/$Array[x]/i) in eine for-Schleife oder eine "allof" schleife packen und wenn es zutrifft in einem weiteren Array die jeweils zugehörige variable auf 1 setzen. So kann man dann aus dem 2. Array auslesen, welche der definierten Schlüsselwörter vorhanden sind und daraus einen Befehl basteln[/size][/font] :)
Hi,
Das Thema klingt Spannend :-)
Ich würde mir einen Parser zum Beispiel in C bauen und diesen Text dann direkt dort in FHEM Befehle umsetzen und dann direkt zB via http an diesen schicken ...
Hallo,
in C/C++ bin ich um einiges Fitter :D
Allerdings wäre das dann ein von FHEM unabhängiges Tool und kann dann nicht direkt auf Spracheingaben reagieren, da man ja nicht weiß, woher der Befehl kommt ::)
Das Tool sollte eigendlich nur die Auswertung eines bereits vorhandenen Textes (z.B. Email oder Spracheingabe oder so) übernehmen und darauf reagieren. So sollte das ganze auf jeder Plattform lauffähig sein :)
Bin allerdings offen für andere Lösungen :) deine funktioniert natürlich genau so
(existiert übrigens bereits in diesem Lösungsansatz bereits in der app "Tasker" und wird von mir so verwendet)
Rince weißt du, wie man den Inhalt der Textdatei in eine Variable schreiben kann?
Und könnte man anstadt der Textdatei eine .log Datei nehmen? dann kann direkt auf das Ereignis reagieren glaube ich.
Grüße
Kuzl
In dem Perl Kurs dessen Link ich oben gepostet habe, sind die ersten Beispiele mit dem Öffnen einer Datei. Das müsste also einfach sein. Einfach abschreiben ;)
Finde es toll, dass du dich des Themas annimmst :)
Entschuldige, war schon halb am schlafen.
Hier in Kurzform:
#!/usr/bin/perl -w
Use strict;
print "Welche Datei wollen Sie durchsuchen : ";
chomp(my $file=<>);
open(FH, "< $file")
or
die "Konnte $file nicht öffnen\n";
undef $/;
my $search = <FH>;
ZitatWas bedeutet nun das undef $/ ? Wir setzen damit die Standardvariable $/ auf einen undefinierten Wert, womit Sie den "Schlürfmodus" des Eingabeoperators aktivieren. Dies sorgt dafür, dass Sie den gesamten Text in der Variable $search stehen haben.
Ach kein Problem :D
ich werd das einfach mal Probieren sobald ich Zeit dafür finde :)
Allerdings kann sich das noch etwas ziehen, da ich keinerlei Programmiererfahrung mit Perl habe sondern eher in C/C++ zuhause bin :D
Ebenfalls hab ich keine Ahnung vom Aufbau eines solchen Moduls aber ich probiers einfach mal irgendwann muss man anfangen ;)
Rince ich hab gesehen, dass du in dem Thread von der App auch auf uns aufmerksam gemacht hast :D Rudi hat dort was von cmdalias geschrieben, allerdings kapier ich nicht ganz was genau der unterschied zu einem notify ist oder bin ich jetzt blöd ? :D
Viele Grüße
Kuzl
So wie ich es verstanden habe, werden damit neue Befehle erzeugt, die man dann als FHEM Befehle nutzen kann.
Man kann also einen neuen Befehl definieren, der dann z.B. mehrere Befehle ausführt. So eine Art Makro.
Dieses Makro könnte dann z.B. von einem Notify aufgerufen werden.
Uns könnte das weiterhelfen:
Zunächst könnten wir erst mal eine Routine in der my99Utils schreiben. Das ist leichter als ein Modul.
Darin könnte man die Variable, die den Text enthält, mit cmdalias einfach direkt vergleichen auf eine feste Zeichenfolge, quasi einem festen Text direkt einen FHEM Befehl zuweisen.
Das wäre dann quasi für feste Befehlssätze jeweils ein Einzeiler.
Und wenn davon nix zutrifft, analysieren wir den Text eben Wort für Wort.
also:
Die Wörter kommen nach $event
das wird nun mit einer festen Zeichenfolge verglichen, die einen festen Befehl ausfürt.
So in etwa habe ich Rudolf verstanden.
Quasi eine FHEM basierte Alternative die einige Zeilen Perl Code spart.
Achso okay damit kann man also in unserem fall mit einem befehl vergleichen - geht aber mit notify genau so deshalb versteh ich irgendwie den Sinn nicht ganz ich glaub ich steh aufm Schlauch :D
EDIT:
So ich hab nur kurz in der Pause geschrieben :D
Also der Vorteil besteht darin, dass man eine "Funktion" schreiben kann, die aufrufbar ist oder?
Man könnte quasi den Quellcode (wird schätze ich gar nicht soooo viel sein) zum Test einfach mal in so ein cmdalias basteln und dann diesem erstellten Befehl über ein notify den Text vom Event übergeben.
Bin mir jetzt nicht sicher ob das der Zweck war, den Rudi gemeint hat :D
Stimmt das ist einfacher einfach zum testen mal in in myutils zu schreiben.
Mal sehen wann ich mal Zeit finde damit bisschen zu probieren :) muss mir natürlich erst mal die App und das zugehörige Modul installiern :D
So ich hab jetzt mal bissl rumprobiert und heng an nem punkt :/
Also das ist jetz ein Code für die myUtils und eine Funktion, der einfach der String übergeben wird.
Der Text soll dann nach Schlagwörtern durchsucht werden und dann anhand der gefundenen Wörter ein Befehl gebastelt werden.
Das durchsuchen des Strings funktioniert schon mal.
###################################################################
###### Text auswerten
sub Text2Cmd {
my $text = $_[0];
my @suchworte = ("Licht","ein","aus");
my @gefunden;
my $i = 0;
foreach my $search (@suchworte){
if ($text =~ m/$search/i){$gefunden[i] = 1;}
else {$gefunden[i] = 0;}
$i++;
}
}
Bitte nicht streng sein mit den Klammern irgendwie ist da Perl ganz anders als C das verwirrt mich voll jetzt hab ich glaub ich bei if und else unnötige Klammern gesetzt :D
So also der Text wird für jedes Suchwort durchsucht und wenn gefunden, wird ein Flag im Array "gefunden" gesetzt. .... und jetzt? :D
ich bin mir nicht sicher, ob das der richtige Weg ist. Habt ihr Vorschläge?
Du suchst ob Licht, ein und aus in einem Text vorkommt?
Daraus wird sich kein Befehl basteln lassen, oder?
Du musst ja unterscheiden, ob es ein ODER aus ist.
Diese Funktion fürchte ich brauchen wir für jeden Zustand in einer eigenen Variablen (und jedes Gerät etc).
?
Jap in dem Array "Suchworte" sind einfach erst mal alle Worte drinnen, nach denen gesucht werden soll also z.b. Licht, ein, aus , an , dunkler, heller, bitte, steckdose, usw.
Für jedes dieser Wörter wird jetzt der Text durchsucht und die zugehörige Variable in dem Array "gefunden" wird auf 1 gesetzt. Da in einem Text hoffentlich nie "ein" und "aus" vorkommt, werden auch nie beide Variablen auf 1 stehen :D
So kann man dan prinzipiell herausfinden welche Wörter im Text vorkommen wenn z.b. in dem Code von oben "ein" im Text vorkommt und sonst nichts, so ist dann:
$gefunden[0] = 0 ;
$gefunden[1] = 1;
$gefunden[2] = 0;
Jetzt kann mann dann irgendwie abfragen, wo eine 1 eingetragen ist und so auf das Wort zurückführen, da ja $suchworte[1] = "ein";
Ich hoffe jetzt es es etwas klarer, wie ich das meine :)
Ab da weiß ich jetzt nicht mehr weiter... ich glaub für jedes der Suchworte benötigt man jetzt eine "IF" abfrage, die beinhaltet, was dann passieren soll, z.B. dass aus einem "ein" ein "set on" werden soll - ich weiß nicht wie man das schöner lösen kann.
Hallo ich hab bisschen weitergemacht und alles etwasgeändert:
###################################################################
###### Text auswerten
sub Text2Cmd {
my $text = $_[0];
my %hbefehl = (
'an', 'on',
'anschalten', 'on',
'ein', 'on',
'einschalten', 'on',
'aus', 'off',
'ausschalten', 'off',
'heller', 'up',
'dunkler', 'down' );
my @abefehl = %hbefehl;
my $anzahlbefehle = keys %hbefehl;
my %hgeraet = (
'Licht', 'Licht',
'TV', 'TV',
'Beleuchtung', 'LEDstripe',
'Computer' , 'PC' );
my @ageraet = %hgeraet;
my $anzahlgeraete = keys %hgeraet;
my $i = 0;
my $cmd = "set";
for($i=0,$i<$anzahlgeraete,$i=$i+2){
if ($text =~ m/$ageraet[$i]/i){$cmd= $cmd . $ageraet[$i+1];
Log 3 , "Gerät gefunden";
}
}
for($i=0,$i<$anzahlbefehle,$i=$i+2){
if ($text =~ m/$abefehl[$i]/i){$cmd= $cmd . $abefehl[$i+1];
Log 3 , "Befehl gefunden";
}
}
return $cmd;
}
Zur Erklärung: Man kann die Wörter und die zugehörigen Befehle oben in die 2 Hashes definieren. Anschließend wird der Text erst nach dem Gerät durchsucht, und dann an $cmd angehängt. Das gleiche passiert mit den Befehlen und dann sollte man einen fertigen fhem Befehl haben.
Allerdings wenn ich der Funktion einen Text übergebe, der z.b. licht und an enthält, wird mir im Log nichts geschrieben und an $cmd wird auch nichts hinzugefügt. Kann sich das mal jemand durchsehen und schaun, ob er einen Fehler findet, den ich nicht bedacht habe?
Hab noch nie was mit Perl gemacht und die Sprache auch erst mit FHEM vor ca. 3 Wochen kennengelernt bitte nicht zu streng sein :D
EDIT: Ok einen Fehler hab ich gefunden. Es muss in den For-Schleifen heißen $anzahlgeraete*2 und das gleiche bei befehle.
Allerdings immer noch das gleiche Problem.
So gibt schon mal was neues von mir :) also jetzt kann man der Funktion einen Text übergeben und sie gibt dann einen FHEM-Befehl zurück :)
Hab heute mal Zeit gefunden den Fehler zu suchen und.... es waren nur anstatt der "," in den for schleifen ein ";" zu setzen ::)
Oben können die Suchwörter und die Zugehörigen "Übersetzungen" eingegeben werden
So der nächste Schritt ist, das ganze etwas schöner und Übersichtlicher zu machen und anstadt des "return" den befehl an fhem zu setzen was mit einer Codezeile schon umsetzbar sein sollte :D wer will kanns mal ausprobieren;)
###################################################################
###### Text auswerten
sub Text2Cmd {
my $text = $_[0];
my %hbefehl = (
'an', 'on',
'anschalten', 'on',
'ein', 'on',
'einschalten', 'on',
'aus', 'off',
'ausschalten', 'off',
'heller', 'up',
'dunkler', 'down' );
my @abefehl = %hbefehl;
my $anzahlbefehle = keys %hbefehl;
my %hgeraet = (
'Licht', 'Licht',
'TV', 'TV',
'Beleuchtung', 'LEDstripe',
'Computer' , 'PC' );
my @ageraet = %hgeraet;
my $anzahlgeraete = keys %hgeraet;
my $i = 0;
my $cmd = "set";
{use Data::Dumper;; Log 3, "Geräte: ".Dumper($anzahlgeraete)};
{use Data::Dumper;; Log 3, "Befehle: ".Dumper($anzahlbefehle)};
{use Data::Dumper;; Log 3, "Text: ".Dumper($text)};
for($i=0;$i<($anzahlgeraete*2);$i=$i+2){
if ($text =~ m/$ageraet[$i]/i){
$cmd= $cmd . " " . $ageraet[$i+1];
Log 3 , "Gerät gefunden";
}
}
for($i=0;$i<($anzahlbefehle*2);$i=$i+2){
if ($text =~ m/$abefehl[$i]/i){
$cmd= $cmd . " " . $abefehl[$i+1];
Log 3 , "Befehl gefunden";
}
}
# das zum Testen in den Code einfügen => fhem($cmd);
return $cmd;
}
Viele Grüße
Kuzl
Unabhängig davon, dass mal selber eine Routine in perl schreiben kann, finde ich die Steuerung von FHEM über Sprache am besten mit einem Android Gerät durch die Kombination von Tasker mit Auto-Voice Plugin und AndFHEM.
Über Tasker mit Autovoiceplugin Profile definieren und dann einen oder mehrere Befehl(e) über Tasker-AndFHEM-Plugin auslösen. Wenn man auf einen Rückgabewert reagieren möchte, dann kann man auch eine GET Abfrage Richtung FHEM machen und die Taskervariable %HTTPR auswerten (zB Temperaturansage).
einige Vorteile von Autovoice:
- versucht aus dem gesagten mehrere mögliche "Resultate" zu interpretieren
- man kann mehrere Befehle gleichzeitig ansagen
- es kann über Google Now benutzt werden (gleichzeitig diverse Fragen, persönliche Daten abfragen wie Kalender und Heimsteuerung)
- es kann über Bluetoothheadset genutzt werden
Ich nutze FHEM erst seit ein paar Tagen, aber ein paar Kommandos habe ich mir schon zusammen gebaut.
Hallo siggi,
Jap, so eine Routine siehst du ja oben :D
ich selbst benutze für die Sprachsteuerung auch Tasker - allerdings ohne das Auto-Voice plugin, geht genau so.
Außerdem gibt es eine eigene FHEM-Browser-App, die die Sprachsteuerung unterstützt.
Allerdings gibt es bei diesen 2. Varianten zwei Probleme:
1. Jeder Befehl muss einzeln extra definiert werden.
2. man muss trotsdem immer den exakten Wortlaut in dem Geredeten einbauen (ausnahme Regex, siehe weiter oben)
Deswegen hab ich diese Routine oben geschrieben, die übrigens sogar ganz gut funkioniert :)
Ich selbst nutze aber so lange, bis man mit Tasker Variablen an FHEM übergeben kann weiter die Tasker-Variante, da ich die Befehle sowiso habe weil ich auch über meine Smartwatch steuere :)
Demnächst wird aber auch der Raspberry auf Voice-Steuerung mit einem Raummicro aufgebaut und dann im Zusammenhang mit der Routine verwendet :D
Viele Grüße
Kuzl
Zitat von: Kuzl am 27 Januar 2014, 17:11:51
Demnächst wird aber auch der Raspberry auf Voice-Steuerung mit einem Raummicro aufgebaut und dann im Zusammenhang mit der Routine verwendet :D
Das habe ich vor einem Jahr auch angefangen. Vorlage war Jarvis aus Iron Man. ;) Funktionierte auch mit vielen selbst gebauten Modulen. (Netzwerkscans, Radio/Videos anmachen, XBMC steuern, WOL Geräte ansteuern und Status abfragen, etc.) Das eigene programmieren von allen benötigten Schnittstellen ist jedoch alleine sehr mühsam und muss ständig gepflegt werden, daher habe ich momentan große Freude an FHEM. :)
Ich will demnächst anschauen wie man Audio von Raspbian (mein FHEM Server) auf AirPlay Lautsprecher bekommt. In den Haupträumen einen Airplaylautsprecher und man kann von überall über wichtige Events im Haus informiert werden (jemand an der Tür -> IP Cam anschauen, Freundin kommt gleich nach Hause, etc). Nebenbei auch Radio hören möglich. :P
Ich hoffe später auf eine Tasker- und FHEM version für Google Glass und werde so wohl endlich meine portable sprachgesteuerte Heimsteuerung haben. Momentan mit Bluetoothheadset funktioniert auch, aber ein Bildschirm im Sichtfeld gibt einige neue Möglichkeiten als nur auf Sprachausgabe zu setzen. :)
Sorry für die Plauderei, hier gehts ja um ein Wunschmodul. Man schreibt sich in anderen Threads. ;)
Bei mir soll der Raspberry dann einfach den Text an FHEM senden und dann wird er dort weiterverarbeitet dann spare ich mir die ganze Pflegerei :) ausgegeben wird der Text dann mit dem Text2Speech Modul. Das ist nebenbei für dich auch interessant, da man dort wählen kann, dass der auszugebende Text als MP3 gespeichert wird. Ebenfalls ist gerade ein DLNA-Modul (ähnlich Airplay) am entstehen, was deine Idee in der Kombination auch umsetzbar macht :D Warscheinlich wirds allerdings auch sehr viel einfacher gehen :D
Da ich zur Zeit mit 64kBit surfe, ist die Spracherkennung bei mir zur Zeit eher problematisch ;)
Sobald ich wieder vernünftig online bin, sehe ich es mir gerne an :)
Oh mein Beileid :D
alles Klar vielen Dank :)
Geht es hier nicht mehr weiter?
Ich bräuchte weitere ideen :D
Der ursprüngliche zweck eine menschliche sprache beliebig und unabhängig von der grammatik auszuwerten erfüllt diese funktion und sie ist an beliebiger stelle aus fhem aufrufbar.
Wenn du einer Idee hast immer her damit :)
Achso, ok - ich dachte es wäre noch Baustelle...
Sieht ja gar nicht Soooo aufwendig aus - auf den ersten Blick vermisse ich wärmer und kälter, lauter und leiser. Oder auch Mengen wie viel oder ein bisschen.
Mach bitte viel leiser wäre -10db etwas leiser vielleicht dann -2db oder so.
Nächster Titel wäre auch noch Schick.
Wenn ich deinen Code aber anschaue sollte es doch auch einfach möglich sein es selbst zu erweitern...
Jap genau kann man sich anpassen wie man will einfach oben das schlüsselwort und dahinter das, was beim set-befehl hinter dem device stehen würde :)
so kann man sich eigendlich alles eintragen was man will
Zitat von: Kuzl am 23 Februar 2014, 14:04:28
Ich bräuchte weitere ideen :D
Der ursprüngliche zweck eine menschliche sprache beliebig und unabhängig von der grammatik auszuwerten erfüllt diese funktion und sie ist an beliebiger stelle aus fhem aufrufbar.
Wenn du einer Idee hast immer her damit :)
Anbei mal etwas Brainstorming meinerseits:
define sprachsteuerung VOICECOMMAND
attr sprachsteuerung voiceCommands set,"Schalte":setstate,"Setze"
attr sprachsteuerung voiceLang de
attr sprachsteuerung voiceError set xbmc msg "Nichts verstanden"
define wz_htpc WOL aa:bb:cc:dd:ee:11 192.168.10.10
attr wz_htpc voiceName htpc
attr wz_htpc voiceCmd set,on,"an":set,off,"aus"
attr wz_htpc voiceOwn set,on,"Starte $voiceName",1:set,off,"Stoppe $voiceName",1
VOICECOMMAND ModulvoiceCommands: Attribut welches den Standardbefehlen in FHEM (set,setstate,setreading) global Werte zuweist damit sie nicht auf jedem Gerät definiert werden müssen.
Syntax: "Fhembefehl","RegEx":"Fh... usw.voiceLang: Sprache in welcher die Spracherkennung arbeiten soll
voiceError: Was soll ausgeführt werden wenn nichts erkannt wurde.
Zu steuerndes ModulvoiceName: Regex nach welchem gesucht wird um das zu schaltende Gerät fest zu legen.
voiceCmd: Mitgeben zu schaltender Zustände und des jeweiligen RegEx
Syntax: "Fhembefehl","zuschaltender Zustand","SprachRegex":"Fh... usw.voiceOwn: Komplette eigene Regex um ganze Befehle zu definieren. Die Variable $voiceName kommt aus dem gleichnamigen Attribut.
Sytax: "Fhembefehl","zuschaltender Zustand","Sprachregex","Priorität"Die Priorität gibt an in welcher alle Regex abgesucht werden sollen. z.B.
Die Standardpriorität für die voiceCommands Befehle könnte dabei 10 Betragen. Als von 1-9 wäre dann vor den globalen Kommandos, alles ab 11 würde erst abgearbeitet werden wenn keine eigenen Kommands von 1-9 und kein globales Kommando gegriffen hat.
Es fehlen hierbei natürlich noch Dinge wie:
- reagieren auf gesprochene Werte zB: "Setze die Temperatur auf 20 Grad" (hierbei würde ein Platzhalter im RegEx gebraucht werden, welcher in eine Variable schreibt. Der Platzhalter müsste nach dem Wert vor dem Wort "Grad" greppen.)
- Zeitgesteuerte ansagen zB: "Schalte htpc in 10 Minuten aus" (hier muss natürlich das reagieren auf einen bestimmten Wert (in diesem Fall die Minutenzahl) reagiert werden. Hinzu kommt hierbei aber, dass ein at definiert werden muss mit der gesprochenen Aktion)
Dies soll nur ein Denkanstoß für eine mögliche Realisierung sein. Ich hoffe ihr habt vielleicht auch noch Ideen hierzu oder sogar bessere! :)
Zusatz:
Vielleicht könnte man auch
attr sprachsteuerung voiceCommands set,"Schalte":setstate,"Setze"
umbauen zu
attr sprachsteuerung voiceCommands set,"Starte|Stoppe|Schalte",WOL:set,"Schalte",0:setstate,"Setze",0
Syntax: "Fhembefehl","RegEx","Modulart":"Fh... usw.
Dann könnte man für bestimmte Modultypen (in diesem Beispiel WOL) eigene Parameter definieren um sagen zu können "Starte htpc". Im WOL Modul muss natürlich auch noch definiert werden--> IF (voiceCommand eq starte) "zuschaltender Zustand"=on.
Zum Beipspiel vielleicht so:
attr wz_htpc voiceCmd set,on,"an":set,off,"aus":set,on,$voiceCommand="Starte"
Syntax: "Fhembefehl","zuschaltender Zustand","SprachRegex"ODER"Prüfung (zum Beispiel hier auf neue Variable $voiceCommand):"Fh... usw.
OK dann scheint es so, als muss da doch irgendwann mal ein direktes Modul daraus werden :D
Nur im Moment hab ich leider absolut keine Zeit sowas umzusetzen, evtl wenn ich mal Urlaub habe :)
Deine Idee ist ganz interessant und zeigt v.a. wie man das ganze etwas Benutzerfreundlicher gestallten könnte, denn bist auf die "at" ist bereits alles damit umsetzbar :)
Mit den Attributen für die einzelnen Module glaub ich, ist das nicht umsetzbar, da es das voicecmd etc. in keinem Modul gibt.
Ich wüde eher nur 5 Attribute für das Voicecmd-Modul nehmen und Zwar:
-Devices: Definiert alle Devices, die über Sprache gesteuert werden sollen
-cmds: Definiert die Befehle, evtl. optional zugeortnet zu einem bestimmten Device
-params: zusätzliche Parameter für bestimmte Befehle, keine Ahnung wie man das umsetzen könnte
-special: sachen wie at, setstate
-ErrorAction: Aktion die ausgeführt werden soll, wenn kein Befehl erkannt wurde.
Natürlich soll alles mit oder verküpft werden können um mehrere Schlüsselworte für einen Befehl zu haben.
wie das ganze dann genau aussehen und umgesetzt werden soll weis ich noch nicht aber schön langsam geht es in eine Richtung, unter der man sich was vorstellen kann :) Vll sieht das ja der ein oder andere erfahrene Entwickler und macht daraus was, bevor ich mich daran vergeblich versucht habe :D
Attribute sind ja für die devices, nicht für die Module... Ich finde auch die Version der Attribute für devices besser - entweder man setzt sie, oder das device nimmt nicht an der sprachsteuerung Teil.
Ich hab damit gemeint, dass das Modul die Attribute gar nicht kennt.
Devices werden ja immer mithilfe eines Moduls definiert, das Ihnen ihre attribute (zuzüglich der standard von fhem) mitbringt.
Da kann man nicht einfach mal so ein Attribut für ein STV dazuerfinden.
Zitatentweder man setzt sie, oder das device nimmt nicht an der sprachsteuerung Teil.
So hab ich das ja auch gedacht; entweder man schreibt das Device dazu oder es wird nicht beachtet
Ich denke genau aus diesen Gründen wird man die Attribute erst mal nur auf dem Voicecmd Modul haben können. Wenn das Modul viel genutzt wird, ist eine spätere Integration in andere Module vielleicht möglich. Aber das wird die Zukunft zeigen. Version 1 wird erst mal komplett im Voice Modul erfolgen müssen.
So sehe ich das auch :D
Für genau solche generischen Analysen von Sprache und Dialogen gibt es eigentlich schon eine Lösung: http://de.wikipedia.org/wiki/AIML (http://de.wikipedia.org/wiki/AIML).
Und ein Perl-Modul gibt es dafür auch: http://search.cpan.org/~perigrin/Net-AIML-0.0.5/lib/Net/AIML.pm (http://search.cpan.org/~perigrin/Net-AIML-0.0.5/lib/Net/AIML.pm)
Das Problem: Alles sehr generisch. Man muss die möglichen Dialoge in einer Baumstruktur vorhersehen.
Eigentlich möchte man doch eine Metaebene, die erahnt was der Nutzer will. Im Prinzip habt ihr das schon getan: Das Pattern mit Gerät, Befehl etc. pp. Aber es braucht noch die Intelligenz, die erahnt, dass der Nutzer die Temperatur hochstellen will, aber so lange fragt bis alle dafür notwendigen Infos vorhanden sind.
Bitte nicht die Threads mit Alternativen zukleistern.
Ein neuer Thread kostet nix :)
Und du hast doch hier schon einen:
http://forum.fhem.de/index.php/topic,22838.0.html
Da es hier im Thread lange nichts neues zu berichten gab, wollte ich mal fragen wie der Stand der Dinge ist?
VG
Frank
Spracherkennung würde mich auch interessieren.
Aber bitte über Google Now so wie es hier demonstriert wird:
https://github.com/MohammadAG/Google-Search-API
http://forum.xda-developers.com/xposed/modules/mod-google-search-api-t2554173
Über Tasker mit Autovoice sollte eine Umsetzung auch bei einer FHEM internen Lösung möglich sein.