FHEMWiki - Benutzerbeiträge [de]

Sonos2mqtt

2021-02-25T20:20:36Z

Stefan Hvr: /* Tipps zur Verwendung */

== Grundeinrichtung ==
Die Grundeinrichtung ist bereits im Artikel [[MQTT2-Module - Praxisbeispiele#Sonos2Mqtt|MQTT2-Module - Praxisbeispiele]] beschrieben. Hier soll es um die praktische Verwendung und Erweiterung gehen.

Für alle Erweiterungen wird versucht vorhandene Devices in FHEM zu verwenden.

Viele Dinge werden derzeit noch entwickelt und können frei gestaltet werden - der Vorteil von generischen FHEM Devices.

== Tipps zur Verwendung ==
Die automatische Konfiguration setzt den alias entsprechend dem im Sonos vergeben Namen . Die langen MQTT2_RINCON_ Namen sind unhandlich und schlecht lesbar. Man kann Player mit einem devspec ansprechen, das simpelste ist:
:<code>set alias=Büro play</code>
Oder alle Player
:<code>set model=sonos2mqtt_speaker leaveGroup</code>

== Ansicht der Player ==
Im Template wird nur ein simples [[devStateIcon]] ausgeliefert. Dort kann man sehr viel mehr reinpacken. Hier mal die aktuelle Arbeitsvariante zum nachrüsten in der [[Import von Code Snippets|Raw Definition]]:
<syntaxhighlight lang="perl">
attr a:model=sonos2mqtt_speaker devStateIcon {\
my $wpix = '250px';;\
my $groupname = ReadingsVal($name,'groupName','0');;\
my $sgroupname = (split(' ',ReadingsVal($name,'groupName','')))[0];;\
my $uuidtoname = (devspec2array('DEF='.ReadingsVal($name,'coordinatorUuid','0')))[0];;\
my $vol = ReadingsVal($name,'volume','');;\
my $img = ReadingsVal($name,'currentTrack_AlbumArtUri','');;\
my $mystate = $name eq $uuidtoname \
? ReadingsVal($name,'state','FEHLER') : ReadingsVal($uuidtoname,'state','');;\
my $playpic = $mystate eq 'PLAYING'\
? 'rc_PAUSE@red' : $mystate eq 'PAUSED_PLAYBACK'\
? 'rc_PLAY@green' : $mystate eq 'STOPPED'\
? 'rc_PLAY@green' : $mystate eq 'TRANSITIONING'\
? 'rc_PLAY@blue' : $mystate eq 'set_next'\
? 'rc_NEXT@blue' : $mystate eq 'set_previous'\
? 'rc_PREVIOUS@blue': $mystate eq 'set_volumeUp'\
? 'rc_VOLUP@blue' : $mystate eq 'set_volumeDown'\
? 'rc_VOLDOWN@blue' : $mystate eq 'set_mute'\
? 'rc_MUTE@blue' : 'rc_PLAY@yellow';;\
my $mutecmd = ReadingsVal($name,'mute','0') eq 'false'?'true':'false';;\
my $mutepic = $mutecmd eq 'on'?'rc_MUTE':'rc_VOLUP';;\
my $show = 'FEHLER';;\
my $currentTrack_Artist = ReadingsVal($name,'currentTrack_Artist','FEHLER');;\
my $currentTrack_Title = ReadingsVal($name,'currentTrack_Title','FEHLER');;\
if ($currentTrack_Title =~ 'x-sonosapi-stream:'){$currentTrack_Title=''};;\
my $currentTrack = $mystate eq 'TRANSITIONING'\
? 'Puffern...' : $currentTrack_Artist.' - '.$currentTrack_Title;;\
my $nextTrack_Artist = ReadingsVal($name,'nextTrack_Artist','FEHLER');;\
my $nextTrack_Title = ReadingsVal($name,'nextTrack_Title','FEHLER');;\
my $nextTrack = $nextTrack_Artist.' - '.$nextTrack_Title;;\
my $previouspic = 'rc_PREVIOUS';;\
my $nextpic = 'rc_NEXT';;\
my $voldownpic = 'rc_VOLDOWN';;\
my $voluppic = 'rc_VOLUP';;\
my $leavegrouppic = 'rc_LEFT';;\
my $showlg = ReadingsVal($name,"name","0") ne $groupname ? "<a href=\"/fhem?cmd.dummy=set $name leaveGroup&XHR=1\">".FW_makeImage($leavegrouppic)."</a>" : "";;\
if (($mystate eq 'PLAYING')\
|| ($mystate eq 'TRANSITIONING' )\
|| ($mystate eq 'set_next' )\
|| ($mystate eq 'set_previous' )\
|| ($mystate eq 'set_volumeUp' )\
|| ($mystate eq 'set_volumeDown' )\
|| ($mystate eq 'set_mute' )) { \
my $shownp = ReadingsVal($name,'name','') eq $sgroupname \
? "<a href=\"/fhem?cmd.dummy=set $name previous&XHR=1\">".FW_makeImage($previouspic)."</a>\
<a href=\"/fhem?cmd.dummy=set $name next&XHR=1\">".FW_makeImage($nextpic)."</a>" : "";; \
$show = "$showlg <a href=\"/fhem?cmd.dummy=set $name toggle&XHR=1\">".FW_makeImage($playpic)."</a>\
<a href=\"/fhem?cmd.dummy=set $name volumeDown&XHR=1\">".FW_makeImage($voldownpic)."</a>\
$shownp\
<a href=\"/fhem?cmd.dummy=set $name volumeUp&XHR=1\">".FW_makeImage($voluppic)."</a>\
 ; ; ; ;\
<a href=\"/fhem?cmd.dummy=set $name mute $mutecmd&XHR=1\">".FW_makeImage($mutepic)."</a><br>";;\
\
if (ReadingsVal($name,'name','') eq $sgroupname) {\
$show = ReadingsVal($name,'currentTrack_TrackUri','') =~ 'spdif'\
? 'TV': ReadingsVal($name,'enqueuedMetadata_UpnpClass','FEHLER') ne 'object.item.audioItem.audioBroadcast'\
? "$show<marquee style='width: $wpix'>Aktueller Track: $currentTrack<br>Nächster Track: $nextTrack</marquee>"\
: "$show<marquee style='width: $wpix'>Radio: $currentTrack</marquee>"\
}\
elsif (ReadingsVal($name,'name','') ne $groupname) {\
$show = "$show Master: $sgroupname"}\
}\
else {\
$show = $name eq $uuidtoname\
? "$showlg <a href=\"/fhem?cmd.dummy=set $name toggle&XHR=1\">".FW_makeImage($playpic)."</a>"\
: "$showlg <a href=\"/fhem?cmd.dummy=set $name toggle&XHR=1\">".FW_makeImage($playpic)."</a><br>Master: $sgroupname"\
}\
"<div>\
<table>\
<tr>\
<td><div style='display: inline-block;; margin-right: 5px;; border: 1px solid lightgray;;\
height: 4.00em;; width: 4.00em;; background-image: url($img);; background-size: contain;;'></div></td>\
<td>$show</td>\
</tr>\
</table>\
</div>"\
}
</syntaxhighlight>

== Befehle nachrüsten ==
Um Befehle nicht manuell in die setList / readingList Einträge jedes Players machen zu müssen, wird diese Routine verwendet.

Der Code ist für die [[Raw definition]] gedacht. Die ersten drei Zeilen sind jeweils anzupassen!

Hier im Beispiel wird der setter für den folgenden Speak Befehl eingefügt bzw. ersetzt. <syntaxhighlight lang="perl">
{my @devlist = devspec2array('MQTT2_RINCON_.*');;\
my $attr = 'setList';;\
my $item = q( speak:textField { my $tts="SonosTTS";;my ($cmd,$vol,$text)=split(' ', $EVENT,3);;fhem("set $tts tts $text;;sleep $tts:playing:.0 ;;set $NAME notify $vol [$tts:httpName]")});;\
my ($first,$sec)=split(' ',$item,2);;\
$first=~s/^\s+//;;\
foreach (@devlist) {\
my @arr = grep {$_ !~ $first} split("\n",AttrVal($_,$attr,''));;\
push @arr,$item;;\
my $val = join "\n",@arr;;\
$val =~ s/;;/;;;;/g;;\
fhem("attr $_ $attr $val")}\
return "$attr in ".scalar(@devlist)." Definitionen modifiziert"\
}
</syntaxhighlight>
Vorhandenen Zeilen werden ersetzt. Identifiziert wird nur der erste Teil.

== Sprachausgabe ==
Man hat zwei Möglichkeiten, dies umzusetzen:
# Text2Speech FHEM intern
# Mit dem sonos text to speech Server https://svrooij.io/sonos2mqtt/

=== Text2Speech Variante einrichten ===
Zwei zusätzliche Geräte sind notwendig:
* [[Text2Speech]] im Servermodus, erzeugt mp3 Dateien im cache Verzeichnis und legt einen Link im Reading httpName ab.
* Ein HTTP Server stellt die Dateien im gleichen Verzeichnis bereit
'''Hinweis''': Für die vollständige Funktion und Installation von Text2Speech ist die Commandref zu beachten! Für das unten im Beispiel verwendete Feature UseMP3Wrap muss das Tool mp3wrap installiert werden (z.B. <code>apt install mp3wrap</code>). Dies ist bei längeren Texten und bei der Verwendung von eingebetteten festen Sounds existenziell!

Für die Funktion ist wichtig, dass das Sonos System den Host im Link zur Datei richtig auflösen kann. Deshalb wird der Hostname und Port des Servers im Reading host des TTS Device als Name oder IP Adresse abgelegt! Dies kann entweder mit dem hier gezeigten Befehl oder vollständig manuell erfolgen. Für FHEM innerhalb Docker muss man die Adresse des Docker Host angeben.
<syntaxhighlight lang="perl">
defmod SonosTTS Text2Speech none
attr SonosTTS TTS_UseMP3Wrap 1
attr SonosTTS TTS_Language Deutsch
attr SonosTTS userReadings httpName:lastFilename.* {'http://'.ReadingsVal($name,'host','set host:port first').'/fhem/'.ReadingsVal($name,'lastFilename','')}
attr SonosTTS TTS_CacheFileDir cache
setreading SonosTTS host {(qx(hostname -s|tr -d '\n').':'.InternalVal('WEB','PORT','8083'))}
#setreading SonosTTS host {((split(' ', qx(hostname -I)))[0].':'.InternalVal('WEB','PORT','8083'))}
#setreading SonosTTS host <hostname>:<port>

defmod SonosSpeakWeb HTTPSRV cache cache SonosSpeakWeb
</syntaxhighlight>
Der Sprachausgabe Befehle im Player Device läuft in 3 Schritten:
# mit dem TTS Gerät wird die mp3 Datei erzeugt,
# mit dem sleep wird auf die Fertigstellung gewartet,
# die Datei wird mit <code>set Player notify volume uri</code> abgespielt.
Durch den "sonos2mqtt notify" Befehl wird die laufende Umgebung wiederhergestellt.
* Wird der Sprachbefehl an den Gruppenmaster gesendet wird die mp3 Datei in der gesamten Gruppe gespielt.
* Wird der Sprachbefehl an ein Mitglied einer Gruppe gesendet (nicht den Master) wird die Gruppe aufgetrennt und später wieder hergestellt.
''Im derzeitigen attrTemplate steht beim [[notify]] Befehl "timeout":10 drin. Sollte die Sprachausgabe immer mal abbrechen, kann man diesen Wert erhöhen (100).''

=== sayText Befehl ===
Dieser Befehl orientiert sich an den FHEM [[DevelopmentGuidelinesAV|DevelopmentGuidelines]] und sammelt "gleichzeitig" eintreffende Sprachnachrichten, damit nichts verloren geht. Informationen im Forum dazu in {{Link2Forum|Topic=111711|Message=1100112|LinkText=diesem Beitrag}}.

Die Lautstärke wird separat in SonosTTS gesetzt: <code>setreading SonosTTS vol 15</code>, ebenso die Sprache (einmalig bei der Einrichtung oder bei Bedarf zwischendurch) <code>attr SonosTTS TTS_Language Deutsch</code>

''Hinweis: Der Befehl <code>set SonosTTS volume xx</code> hat im Servermodus des Devices keine Wirkung!''

Der Befehl selbst ist eine Erweiterung der setList im MQTT2 Player Device und sieht wie folgt aus. Man kann den Befehl einfach bei allen Playern mit dem obigen [[Sonos2mqtt#Befehle nachr.C3.BCsten|Codeschnipsel]] nachrüsten ( ; vorher verdoppeln).
<syntaxhighlight lang="perl">
sayText:textField { my $tts=ReadingsVal('SonosBridge','tts','SonosTTS');my ($cmd,$text)=split(' ', $EVENT,2);fhem("setreading $tts text ".ReadingsVal($tts,'text',' ').' '.$text.";sleep 0.4 tts;set $tts tts [$tts:text];sleep $tts:playing:.0 ;set $NAME notify [$tts:vol] [$tts:httpName];deletereading $tts text")}
</syntaxhighlight>

=== Speak Befehl ===
Verwendet wird ein Befehl ähnlich wie in der Sonos Umgebung:
:<code>set Player speak <volume> text</code>

Die Erweiterung der setList im MQTT2 Player Device sieht wie folgt aus. Man kann den Befehl einfach bei allen Playern mit dem obigen [[Sonos2mqtt#Befehle nachr.C3.BCsten|Codeschnipsel]] nachrüsten.
<syntaxhighlight lang="perl">
speak:textField { my $tts="SonosTTS";my ($cmd,$vol,$text)=split(' ', $EVENT,3);fhem("set $tts tts $text;sleep $tts:playing:.0 ;set $NAME notify $vol [$tts:httpName]")}
</syntaxhighlight>
Will man keine laufenden Sendung unterbrechen sondern einfach eine Ansage machen und danach etwas starten, kann man so vorgehen:
<syntaxhighlight lang="perl">
set SonosTTS tts Hier steht die Ansage;sleep SonosTTS:playing:.0 ; set alias=PlayerAlias playUri [SonosTTS:httpName]
</syntaxhighlight>

==== Spiele feste Sounds ====
Generell kann man feste mp3 Dateien (Klingeltöne, Klänge usw.) auch im cache Verzeichnis ablegen und direkt mit dem Link starten.

Es gibt zahlreiche Soundquellen im Internet, ist der gewünschte Sound dabei, kann man ihn innerhalb FHEM herunterladen und an Ort und Stelle platzieren. (Beispiel ohne und mit Umbennung)
<syntaxhighlight lang="perl">
"wget -qP ./cache https://cdn.smartersoft-group.com/various/pull-bell-short.mp3"
"wget -qO ./cache/KlingelTon.mp3 https://cdn.smartersoft-group.com/various/pull-bell-short.mp3"
</syntaxhighlight>
Vergewissern ob der gewünschte Sound auch da ist: {qx(ls -lha ./cache)}

Mit set magic kann man dabei einfach Teile aus anderen Readings holen.
<syntaxhighlight lang="perl">
set alias=Büro notify 25 {('http://[SonosTTS:host]/fhem/cache/KlingelTon.mp3')}
</syntaxhighlight>
Man kann auch den setter im Gerät erweitern:
<syntaxhighlight lang="perl">
playSound:textField {my $tts="SonosTTS";my ($cmd,$vol,$file)=split(' ', $EVENT,3);$file=($file=~m/.*\.mp3$/)?"$file":"$file.mp3";fhem("set $NAME notify $vol http://[$tts:host]/fhem/[a:$tts:TTS_CacheFileDir]/$file")}
</syntaxhighlight>
Damit sind dann dieser Syntax möglich:
<syntaxhighlight lang="perl">
set alias=Büro playSound 40 KlingelTon.mp3
</syntaxhighlight>
oder ohne Dateiendung (wird auf mp3 gesetzt)
<syntaxhighlight lang="perl">
set alias=Büro playSound 40 KlingelTon
</syntaxhighlight>

=== SonosBridge aufrüsten ===
Einige zentrale Dinge sind im SonosBridge Device gut aufgehoben. Seit der Version 3.1.0-beta.1 ist es möglich, die Sonos Umgebung zu aktualisieren ohne sonos2mqtt neu starten zu müssen.

Die setList stattet die Bridge mit der Möglichkeit aus, alle Player zu stoppen und die Umgebung neu einzulesen (das ist nützlich wenn man Player on/off betreibt).
<syntaxhighlight lang="perl">
PauseAll:noArg sonos/cmd/pauseall
CheckSubscription:noArg sonos/cmd/check-subscriptions
</syntaxhighlight>
Die Favoritenliste kann einmal zentral in der SonosBridge abgelegt werden. Dazu müssen wird dort die readingList ergänzen.
<syntaxhighlight lang="perl">
sonos/RINCON_([0-9A-Z]+)/Favorites:.* Favorites
</syntaxhighlight>
Für eine einfache Abholung der aktuellen Favoriten kann der SonosBridge eine getList spendiert werden, man muss dazu einen Player eintragen (RINCON_).
<syntaxhighlight lang="perl">
Favorites:noArg Favorites sonos/RINCON_XXXXXXXXXXXXX/control {"command": "adv-command","input": {"cmd": "GetFavorites","reply": "Favorites"}}
</syntaxhighlight>
ToDo: Code straffen und setList mit einbauen.

Wer das nicht per Hand machen will hier zwei Codeblöcke für die Raw Definition:<syntaxhighlight lang="perl">
{my @devlist = devspec2array('model=sonos2mqtt_bridge');;\
my $attr = 'readingList';;\
my $item = q( sonos/RINCON_([0-9A-Z]+)/Favorites:.* Favorites);;\
my ($first,$sec)=split(' ',$item,2);;\
$first=~s/^\s+//;;\
foreach (@devlist) {\
my @arr = grep {$_ !~ $first} split("\n",AttrVal($_,$attr,''));;\
push @arr,$item;;\
my $val = join "\n",@arr;;\
$val =~ s/;;/;;;;/g;;\
fhem("attr $_ $attr $val")}\
return "$attr in ".scalar(@devlist)." Definitionen modifiziert"\
}
</syntaxhighlight>
Achtung: dieser Code schreibt eine neue getList in die SonosBridge, zum Ergänzen müsste der Code analog der bisherigen Beispiele verändert werden.
<syntaxhighlight lang="perl">
{my @devlist2 = devspec2array('MQTT2_RINCON_.*');;\
my @arr2;;\
foreach (@devlist2) {push @arr2,InternalVal($_,'DEF','')};;\
my $item= q(Favorites:noArg Favorites sonos/).$arr2[int(rand(@arr2))].q(/control {"command": "adv-command","input": {"cmd": "GetFavorites","reply": "Favorites"}});;\
fhem("attr model=sonos2mqtt_bridge getList $item")\
}
</syntaxhighlight>

=== Player mit Favoritenliste ausstatten ===
Wenn nicht schon geschehen muss man jetzt die Favoriten zum ersten Mal einlesen: get SonosBridge Favorites

Nachdem die SonosBridge "aufgerüstet" ist kann man allen Playern die Favoritenliste zum Auswählen eintragen. Dieser Code ist etwas umfangreicher und wieder ein "Script" für die Raw Def.
<syntaxhighlight lang="perl">
{use JSON;;use HTML::Entities;;use Encode qw(encode decode);;\
my $enc = 'UTF8';;\
my $dev = (devspec2array('model=sonos2mqtt_bridge'))[0];;\
my $read = 'Favorites';;\
my $decoded = decode_json(ReadingsVal($dev,$read,''));;\
my @arr = @{$decoded->{'Result'}};;\
my @out;;\
foreach (@arr) {\
my $dec=encode($enc, decode_entities($_->{'Title'}));;\
$dec =~ s/\s/./g;;\
push @out,$dec}\
my $favliste= join ',', sort @out;;\
\
my @devlist = devspec2array('MQTT2_RINCON_.*');;\
my $attr = 'setList';;\
my $item = ' playFav:'.$favliste.q( {use JSON;;use HTML::Entities;;use Encode qw(encode decode);;my $enc = 'UTF8';;my $uri='';;my $search=(split(' ', $EVENT,2))[1];;$search=~s/[\/()]/./g;;my $dev = (devspec2array('model=sonos2mqtt_bridge'))[0];;my $read='Favorites';;my $decoded = decode_json(ReadingsVal($dev,$read,''));;my @arr=@{$decoded->{'Result'}};;foreach (@arr) {if (encode($enc, decode_entities($_->{'Title'}))=~/$search/i){$uri = $_->{'TrackUri'} }};;fhem("set $NAME playUri $uri") if ($uri ne '')});;\
my ($first,$sec)=split(':',$item,2);;\
$first=~s/^\s+//;;\
foreach (@devlist) {\
my @arr = grep {$_ !~ $first} split("\n",AttrVal($_,$attr,''));;\
push @arr,$item;;\
my $val = join "\n",@arr;;\
$val =~ s/;;/;;;;/g;;\
fhem("attr $_ $attr $val")}\
return "$attr in ".scalar(@devlist)." Definitionen modifiziert"\
}
</syntaxhighlight>
Der erste Teil des Codes erzeugt aus den Favoriten ein Komma separierte, sortierte Liste der Titel und ersetzt die Leerzeichen durch Punkte. Damit eignet sich diese Liste für die Auswahlbox. Dies wird als Ergänzung der setList im zweiten Teil des Codes erzeugt und bei allen Playern eingetragen.

Man kann den playFav Befehl auch im set Befehl mit einem Teil des Favoriten Namen verwenden. Enthält die Favoritenliste z.B. Radio Leipzig würde der auch mit diesem Befehl angesteuert werden:
<syntaxhighlight lang="perl">
set alias=Bad playFav leipzig
</syntaxhighlight>

=== Radioliste durchtasten ===
Will man eine Liste von bestimmten Radiostation mit einem Taster "durchtasten" kann man das wie folgt tun:

Eigene Radio Liste in ein Reading schreiben (Die Namen müssen zumindest in Teilen mit den Favoriten Titeln übereinstimmen)
<syntaxhighlight lang="perl">
setreading model=sonos2mqtt_bridge favRadios Deutschlandfunk Kultur,Radio Leipzig,Radio Station 3
</syntaxhighlight>
Der Befehl zum weiterschalten. Jedesmal wenn dieser Befehl ausgeführt wird, wird der nächste Favorit gestartet.
<syntaxhighlight lang="perl">
set alias=Arbeitszimmer playFav {(my $dev = (devspec2array('model=sonos2mqtt_bridge'))[0];;Each($dev,ReadingsVal($dev,'favRadios','')))}
</syntaxhighlight>

Will man vor dem Radiostart noch die Ansage des Senders haben, geht das zwar auch mit dem speak Befehl, die direkte Ausgabe ohne Restore der Umgebung (sonos2mqtt notify) ist aber effektiver.

Damit das funktioniert müssen wir die Events einschränken:
<syntaxhighlight lang="perl">
attr model=sonos2mqtt_speaker event-on-change-reading .*
{my $dev = (devspec2array('model=sonos2mqtt_bridge'))[0];;my $r=Each($dev,ReadingsVal($dev,'favRadios',''));;my $play = (devspec2array('alias=Büro'))[0];;my $tts="SonosTTS";;fhem("set $tts tts Es folgt $r;;sleep $tts:playing:.0;;set $play playUri [$tts:httpName];;sleep $play:play;;sleep $play:PLAYING;;sleep $play:STOPPED;;set $play playFav $r")}
</syntaxhighlight>
Kurze Erklärung zum Code
* ermittelt den nächsten Radiosender in der Liste,
* erzeugt die Ansage "Es folgt SenderXY",
* wenn die mp3 Datei fertig erzeugt ist wird sie mit dem Befehl playUri an den Player gesendet,
* es wird eine Eventfolge abgewartet -> play / PLAYING / STOPPED,
* danach wird der Radiosender gestartet.
Der Code ist so einfach und relativ "steif" für die Kommandozeile. Man kann das auch in einen Setter packen:
<syntaxhighlight lang="perl">
toggleRadio:noArg {my $dev = (devspec2array('model=sonos2mqtt_bridge'))[0];my $r=Each($dev,ReadingsVal($dev,'favRadios',''));my $tts="SonosTTS";fhem("set $tts tts Es folgt $r;sleep $tts:playing:.0;set $NAME playUri [$tts:httpName];sleep $NAME:play;sleep $NAME:PLAYING;sleep $NAME:STOPPED;set $NAME playFav $r")}
</syntaxhighlight>

== Dokumentationen und weitere Entwicklungen ==
ToDo

[[Kategorie:MQTT]]

Text2Speech

2021-02-25T19:31:40Z

Stefan Hvr: /* Text2Speech Sprachengines */

{{Infobox Modul
|ModPurpose=Sprachausgabe über FHEM
|ModType=h
|ModForumArea=Unterstützende Dienste
|ModTechName=98_Text2Speech.pm
|ModOwner=tobiasfaust ({{Link2FU|118|Forum}} / [[Benutzer_Diskussion:Tobias.faust|Wiki]])
}}

Das Modul [[Text2Speech]] ermöglicht es, eine Sprachausgabe über FHEM zu realisieren. Das Modul ist Client-Server-fähig. Einzelne Sprachbausteine werden zwischengespeichert damit diese bei erneutem Gebrauch nicht noch einmal nachgeladen werden müssen um somit einen flüssigen Spachfluss zu gewährleisten.

==Text2Speech Sprachengines==
Die Default Sprachengine ist Google mit deutscher, weiblicher Stimme.

Die Sprachengines Amazon Polly, Google und VoiceRSS sind OnlineSysteme die eine Internetverbindung voraussetzen. Die Sprachengines ESpeak und SVOX-Pico sind lokal installierte Sprachengines die keine Internetverbindung benötigen.

Als Empfehlung kann kann folgende Liste mit absteigender Sprachqualität eine Hilfestellung bieten:
* Amazon Polly
* Google
* VoiceRSS/ESpeak/SVOX-Pico

Die Sprachengine "Amazon Polly" ist kostenpflichtig. In den ersten 12 Monaten sind 5Mio Zeichen kostenlos, danach kosten 1Mio Zeichen 4US$ (Stand Februar 2021): [https://aws.amazon.com/de/polly/pricing/ Amazon Polly Pricing]

==Definition Lokale Architektur==
===Abhängigkeiten Installationspakete===
Egal welche Sprachengine verwendet werden soll müssen folgende Pakete installiert sein:
* IO::File
* Digest::MD5
* URI::Escape
* Text::Iconv
* Encode::Guess
* MP3::Info
* mp3wrap (Empfohlen, aber optional, wird über das Attribut TTS_UseMp3Wrap aktiviert)

<syntaxhighlight lang="bash">
sudo apt-get install libdigest-perl-md5-perl libany-uri-escape-perl libtext-iconv-perl libencode-perl libmp3-info-perl mp3wrap
</syntaxhighlight>

===zusätzliche Abhängigkeiten von Espeak===
<syntaxhighlight lang="bash">sudo apt-get install lame espeak</syntaxhighlight>

===zusätzliche Abhängigkeiten von SVOX-pico===
<syntaxhighlight lang="bash">sudo apt-get install lame libttspico-utils</syntaxhighlight>

Für ARM/Raspbian sind die <code>libttspico-utils</code> leider nicht verfügbar, deswegen müsste man diese selbst kompilieren oder das vorkompilierte Paket aus [http://www.robotnet.de/2014/03/20/sprich-freund-und-tritt-ein-sprachausgabe-fur-den-rasberry-pi/ dieser Anleitung] verwenden, folgend in aller Kürze:
<syntaxhighlight lang="bash">
sudo apt-get install libpopt-dev
cd /tmp
wget http://www.dr-bischoff.de/raspi/pico2wave.deb
sudo dpkg --install pico2wave.deb
</syntaxhighlight>

===zusätzliche Abhängigkeiten von Amazon Polly===
* Paws::Polly
* File::HomeDir

<syntaxhighlight lang="bash">
sudo apt-get install libfile-homedir-perl
sudo cpan Paws
</syntaxhighlight>

Die Zugangsdaten zum eigenen AWS Konto müssen unter ~/.aws/credentials liegen.
<syntaxhighlight lang="bash">
[default]
aws_secret_access_key = xxxxxxxxxxxxxxxxxxxxxx
aws_access_key_id = xxxxxxxxxxxxxxx
</syntaxhighlight>

Die Zugangsdaten erhält man in dem man im AWS Konto eine IAM Gruppe mit einem PollyRead Profile erstellt und diese Gruppe eine neuen User zuweist.
Nach Anlegen des Users erhält man einmalig(!) das Schlüsselpaar.

==allgemeine Konfiguration==
Relevant für die korrekte SprachEngine sind die folgenden Attribute:
* TTS_Ressource
* TTS_Language '''oder''' TTS_Language_Custom

Mit <code>aplay -l</code> kann man eine Liste der möglichen Audio Ausgabedevices erhalten. Von dem gewünschten Ausgabedevice ermittelt man nun die Kartennummer und das Subdevice.

Neben dem Audio Equipment gibt es zwei Voraussetzungen im System:
* Der User fhem muss Berechtigung haben Sound auszugeben und
* es muss ein Player installiert sein.
<syntaxhighlight lang="bash">sudo usermod -aG audio fhem</syntaxhighlight>
Nach dieser Änderung muss sich der Benutzer neu anmelden! Ein Neustart von FHEM oder dem System ist notwendig!

Test2Speech wurde ursprünglich für mplayer entwickelt:
<syntaxhighlight lang="bash">sudo apt-get install mplayer</syntaxhighlight>
Damit mplayer ohne sudo aufgerufen wird muss das Attribute <code>TTS_MplayerCall </code> gesetzt werden. Wird das weggelassen muss [[FHEM_mit_sudo|fhem sudo Berechtigung]] bekommen.
<syntaxhighlight lang="perl">define MyTTS Text2Speech hw=0.0
attr MyTTS TTS_MplayerCall /usr/bin/mplayer</syntaxhighlight>
Das Programm mplayer hat auf einigen Systemen sehr große Verzögerungen beim Start, als '''Alternative''' ist z.B. play verwendbar
<syntaxhighlight lang="bash">sudo apt-get install sox libsox-fmt-all</syntaxhighlight>
Die Definition muss in der Bezeichnung das Audiogerätes und im Attribute <code>TTS_MplayerCall </code> so aussehen (Mindestens Version 19378 2019-05-12 erforderlich).
<syntaxhighlight lang="perl">define MyTTS Text2Speech hw:0,0
attr MyTTS TTS_MplayerCall AUDIODEV={device} /usr/bin/play -q -v $(({volume}*{volumeadjust}/10000)).$(({volume}*{volumeadjust}%10000)) {file}</syntaxhighlight>

Bei wiederholten Sprachbausteinen wird durch die Verwendung von MP3Wrap eine deutlich flüssigere Sprachausgabe erreicht. Für die Verwendung von Kombinationen aus fertigen mp3 Files und Texten in der Art "Text:bing.mp3:Text" ist dies zwingend notwendig.
<syntaxhighlight lang="bash">sudo apt-get install mp3wrap</syntaxhighlight>

Als Ergänzung die Definition ein Attribute <code>TTS_UseMP3Wrap</code> :
<syntaxhighlight lang="perl">attr MyTTS TTS_UseMP3Wrap 1
attr MyTTS verbose 4</syntaxhighlight>

Ein erster Test kann wie folgt durchgeführt werden (als Einzeiler, ohne Zeilenumbruch einzugeben):
:<code> set MyTTS tts Das ist ein Test. Jetzt prüfen wir, ob wir etwas aus dem angeschlossenen Lautsprecher hören. Beim ersten Mal haben wir allerdings noch Sprechpausen. Spätestens beim zweiten Durchlauf ist der Textfluss flüssiger.</code>
Hört man etwas aus dem Lautsprecher, so führen wir das Kommando ein zweites Mal aus. Jetzt sollte es sich besser anhören. Bleiben die Lautsprecher stumm, so ist das FHEM-Log zu kontrollieren. Gegebenenfalls ist das [[verbose]]-Level auf 5 zu stellen.

War der Test erfolgreich, kann das verbose-Attribut wieder gelöscht werden.

==Definition Client-Server Architektur==
Es gibt Installationen, bei denen der FHEM-Server z.B. im Keller steht, die Sprachausgabe soll aber räumlich entfernt stattfinden, z.B. im Wohnzimmer. Hierzu ist am Zielort eine FHEM-Instanz anzulegen, z.B. über einen [[Raspberry Pi]], IP: 192.168.178.10.
Auf dem FHEM-Server ist Text2Speech als Remote zu definieren:
define MyTTS Text2Speech 192.168.178.10:7072 <Passwort>;
attr Text2Speech room Text2Speech;

Am Zielort ist Text2Speech auf dem Raspi wie folgt zu definieren:
define MyTTS Text2Speech hw=0.0;
attr MyTTS room Text2Speech;
attr MyTTS TTS_UseMP3Wrap 1;
attr MyTTS verbose 4;
Der Passwort Zugang ist entsprechend der {{Link2CmdRef|Anker=allowed}} zu definieren.
Bitte die Installation von Mplayer und Mp3Wrap nicht vergessen!
Danach der Test wie oben angegeben.

==Sprachausgabe per Bluetooth-Lautsprecher unter Raspbian Jessie==
Für die Sprachausgabe über Bluetooth bieten sich verschiedene Lautsprecher an. Wichtig ist jedoch, dass diese entweder gar nicht in einen Standby Modus wechseln oder aber über Bluetooth aus dem Standby aufgeweckt werden können. Folgende Lautsprecher sollen laut Internetrecherche funktionieren:

* Creative D80/D100/D200
* Sony Soundbar HT-XT3
* Panasonic SC-ALL6EG-W / SC-NE1
* Bose Soundtouch 10
* Bose Soundlink Mini II
* B&O Beoplay S3
* JBL Charge 2+/3
* LG Art 51
* UE Roll
* Energy PowerBar Elite
* Teufel Cinebar 11

Die folgenden Schritte müssen nacheinander durchgeführt werden, um auf einem aktuellen Jessie System Audio Inhalte über Bluetooth zu streamen:

'''1.''' USB-Bluetooth-Stick verbinden
und per ''lsusb'' prüfen, ob der Stick erkannt wurde.

'''2.''' System aktualisieren und notwendige Pakete installieren
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install alsa-utils bluez bluez-tools pulseaudio-module-bluetooth python-gobject python-gobject-2
sudo reboot

'''3.''' Benutzer pi zur PulseAudio Gruppe hinzufügen
sudo usermod -a -G lp pi
sudo usermod -a -G pulse-access,audio root
sudo adduser pi pulse-access

'''4.''' Datei daemon.conf von PulseAudio anpassen
sudo nano /etc/pulse/daemon.conf
Nach folgender Zeile suchen
; resample-method = speex-float-1
und wie folgt erweitern
; resample-method = speex-float-1
resample-method = trivial
und
; system-instance = no
system-instance = yes
speichern und schliessen

'''5.''' In PulseAudio müssen jetzt zusätzliche Module geladen werden
sudo nano /etc/pulse/system.pa
am Ende der Datei folgendes hinzufügen
.ifexists module-bluetooth-policy.so
load-module module-bluetooth-policy
.endif
.ifexists module-bluetooth-discover.so
load-module module-bluetooth-discover
.endif
speichern und schliessen

'''6.''' Jetzt müssen wir dafür sorgen, dass PulseAudio automatisch geladen wird
sudo nano /etc/systemd/system/pulseaudio.service
und folgenden Inhalt einfügen
[Unit]
Description=PulseAudio Sound System
Before=sound.target
[Service]
BusName=org.pulseaudio.Server
ExecStart=/usr/bin/pulseaudio
Restart=always
[Install]
WantedBy=multi-user.target
speichern und schliessen

'''7.''' Danach müssen wir PulseAudio neu starten
sudo systemctl daemon-reload
sudo systemctl enable pulseaudio.service
sudo systemctl start pulseaudio.service

'''8.''' Prüfen ob PulseAudio läuft
systemctl status pulseaudio

'''9.''' Jetzt den Audio Output einstellen: X entweder mit 0 (auto), 1 (3,5mm Klinke) oder 2 (HDMI) ersetzen.
sudo amixer cset numid=3 X

'''10.''' Die Lautstärke kann auf 100% gesetzt werden mit
sudo amixer set Master 100%
sudo pacmd set-sink-volume 0 65535

'''11.''' Soundausgabe z.B. über Kopfhörer prüfen
paplay /usr/share/sounds/alsa/Front_Left.wav

'''12.''' Jetzt können wir mit der Einrichtung von Bluetooth beginnen
sudo nano /etc/bluetooth/audio.conf
und folgendes einfügen
[General]
Enable=Source,Sink,Headset,Gateway,Control,Media,Socket
HFP=true
Class=0x20041C
speichern und schliessen

sudo nano /etc/bluetooth/main.conf
unter [General] folgendes einfügen
Name = RaspStream
Class = 0x20041C
speichern und schliessen

sudo hciconfig -a
eingeben und die MAC Adresse des Bluetooth Dongles aufschreiben

Jetzt müssen die Bluetooth Settings angepasst werden (XX:XX:XX:XX:XX:XX steht für die MAC Adresse des Bluetooth Dongles)
sudo nano /var/lib/bluetooth/XX:XX:XX:XX:XX:XX/settings
einngeben und folgendes einfügen
[General]
Discoverable=true
Alias=RaspStream
Class=0x20041C
speichern und schliessen

Jetzt muss der Raspberry wieder neu gestartet werden
sudo reboot

'''13.''' Jetzt können Bluetooth Dongle und Bluetooth Lautsprecher gepaired werden
bluetoothctl
und folgende Befehle nacheinander eingeben
agent on
default-agent
discoverable on
scan on

der Bluetooth Lautsprecher sollte jetzt irgendwann aufgelistet werden und kann dann gepaired werden mit
pair XX:XX:XX:XX:XX:XX
trust XX:XX:XX:XX:XX:XX
Bluetooth console verlassen mit
quit

Damit sollte die Einrichtung abgeschlossen sein und wir können überprüfen, ob wir etwas über Bluetooth ausgeben können
mplayer -ao pulse http://stream01.iloveradio.de/iloveradio1.mp3

'''14.''' Das Modul Text2Speech sollte dann mit 'default' angelegt werden
define TTS Text2Speech default

==Sprachausgabe per Bluetooth-Lautsprecher==
{{Randnotiz|RNTyp=Info|RNText=Dieser Abschnitt repräsentiert nicht den aktuellen Stand. Bezüglich Verbindung, Neustart alsa und dem Testbeispiel am Ende muss er überarbeitet werden}}
Es ist ebenfalls möglich die Sprachausgabe nicht über einen direkt per Kabel angeschlossenen Lautsprecher auszugeben, sondern per Bluetooth an einen oder mehrere Bluetooth-Lautsprecher. Der Test2Speech-Author verwendet einen CreativeD80.
Dabei ist auf dem Client mit der lokal eingerichteten Text2Speech-Instanz folgendes vorzunehmen:

'''1.''' USB-Bluetooth-Stick verbinden
per ''lsusb'' prüfen, ob der Stick erkannt wurde.

'''2.''' Bluetooth Bibliotheken installieren
sudo apt-get install bluez bluez-alsa mplayer

'''3.''' Bluetooth für eine AudioVerbindung konfigurieren
Dazu in ''/etc/bluetooth/audio.conf'' in der ''General section'' folgendes einfügen:
Enable=Source,Sink,Headset,Gateway,Control,Socket,Media

'''4.''' den Rechner neu starten
sudo reboot

'''5.''' Den Bluetooth-Lautsprecher lokalisieren
Den Lautsprecher in den Pairing-Modus versetzen. Erst Dadurch wird er im Scanning sichtbar
hcitool scan
Folgendes Ergebnis sollte kommen:
Scanning ...
11:22:33:44:55:66 device 1
12:34:56:78:90:12 device 2

'''6.''' eine RFComm Connection vorbereiten
Dazu ''/etc/bluetooth/rfcomm.conf'' editieren und folgendes eintragen (Mac-Adresse anpassen!)
rfcomm0 {
# Automatically bind the device at startup
bind no;
# Bluetooth address of the device
device 11:22:33:44:55:66;
# RFCOMM channel for the connection
channel 3;
# Description of the connection
comment "This is Device 1's serial port.";
}

'''7.''' rebooten
sudo reboot

'''8.''' Pairing-Key vergeben
Die meisten Bluetoothgeräte verlangen einen Schlüssel während des Pairings. Der Creative-D80 erwartet den Schlüssel 0000
bluetooth-agent 0000 &

'''9.''' Das eigentliche Pairing
Den Lautsprecher in den Pairing-Modus versetzen. Danach:
sudo rfcomm connect rfcomm0
Jetzt sollte keine Fehlermeldung mehr kommen....

'''10.''' Alsa konfigurieren
Der Bluetooth-Lautsprecher muss nun noch als Alsa-Audiodevice bekannt gemacht werden. Dazu muss ''/etc/asound.conf'' erstellt werden. MAC anpassen!
pcm.bluetooth {
type bluetooth
device 11:22:33:44:55:66
profile "auto"
}

Danach Alsa restarten:
{{Randnotiz|RNTyp=Fehl|RNText=Aktuell bei wheezy /etc/init.d/alsa-utils restart}}
/etc/init.d/alsasound restart

'''11.''' Testen der Verbindung
{{Randnotiz|RNTyp=Fehl|RNText=Dieses Beispiel geht allein wegen der ständigen Änderung bei Google nicht. Auch stimmt das Ausgabe Gerät nicht. Man könnte so testen :<code>mplayer -ao alsa:device=bluetooth http://1live-diggi.akacast.akamaistream.net/7/965/119435/v1/gnl.akacast.akamaistream.net/1live-diggi</code>}}
:<code>mplayer -ao alsa:device=hw=0.0 -nolirc -noconsolecontrols -http-header-fields "User-Agent:Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.22 (KHTML, like Gecko) Chrome/25.0.1364.172 Safari/537.22m" "http://translate.google.com/translate_tts?tl=de&q=Das ist ein Test.";</code>

== Problembehandlung ==

=== Beim abspielen via Bluetooth "stottert" die Wiedergabe ===
Das Problem tritt im Zusammenhang mit der verwendeten Abspielsoftware ab. Aus nicht nachvollziehbaren Gründen harmoniert die Kombination Bluetooth und Mplayer nicht immer perfekt. Lösung hierfür ist, anstelle mit Mplayer mit VLC zu arbeiten.

Hierfür legt man ein Skript z.B. mit dem Namen /opt/bin/vlc-wrapper.sh an mit folgendem Inhalt:
<pre>#!/bin/bash

cvlc -A alsa --alsa-audio-device bluealsa --quiet --no-interact --play-and-exit $1</pre>
Der Teil <pre>-A alsa --alsa-audio-device bluealsa</pre> kann ggf. weggelassen werden, wenn die Ausgabe nicht gezielt auf einem bestimmten Audiogerät erfolgen soll.
Anschließend muss die Ausgabe von Text2Speech noch auf das Skript umgeleitet werden mit folgendem Befehl in FHEM:<pre>attr myTTS TTS_MplayerCall /opt/bin/vlc-wrapper.sh</pre>

=== MickyMaus-artiger Sound ===
Das Problem tritt auf, wenn man per mp3wrap mehrere mp3 Files zusammenzieht die eine unterschiedliche Auflösung haben.

== Links ==
* Vorstellung und Diskussion des Moduls im {{Link2Forum|Topic=18481|LinkText=FHEM Forum}}
* [[Wetter_vorlesen_lassen|Code Snippets: Wetter vorlesen lassen]]
* [https://aubreykloppers.wordpress.com/2015/06/25/bluetooth-speaker-raspberry-pi-the-ultimate-guide/ weitere Guideline für Bluetooth per Rasperry Pi]
* [https://www.alefo.de/bluetooth-lautsprecher-und-adapter-f63/liste-kompatibler-bt-lautsprecher-fuer-amazon-dot-t907.html Liste von Bluetooth Lautsprechern]
* [http://www.forum-raspberrypi.de/Thread-tutorial-bluetooth-audio-streaming-mit-a2dp-raspbian-jessie Bluetooth einrichten mit Raspbian Jessie]

[[Kategorie:Akustische Ausgabe]]