DialogOS

Aus Debacher-Wiki
Version vom 3. Februar 2013, 12:08 Uhr von Debacher (Diskussion | Beiträge)
(Unterschied) ← Nächstältere Version | Aktuelle Version (Unterschied) | Nächstjüngere Version → (Unterschied)
Wechseln zu:Navigation, Suche

DialogOS ist ein Programm, welches hoffentlich weiterentwickelt wird. Da dabei auch immer wieder Fehler beseitigt werden ist es notwendig ständig die aktuellste Version zu Nutzen. Die Updates finden sich auf den Download-Seiten des Hersteller CLT.

DialogOS steht in zwei Versionen zur Verfügung, einerseits einer Einzelplatz-Version, andererseits in einer Schulversion. Die Einzelplatz-Version beinhaltet eine Stimme, die Schul-Version vier Stimmen in zwei Sprachen, also zwei Stimmen für jede der Sprachen. Die Stimmen funktionieren nur in der Sprache gut, für die sie gedacht sind.

Eine Besonderheit von DialogOS ist die Möglichkeit mit den Lego-Mindstorm Robotern zu kommunizieren. Man kann aus der Anwendung heraus die Sensoren abfragen und Programme ausführen. In der aktuellen Version kann man auch direkt die Motoren ansteuern.

Projekte aus dem eigenen Unterricht.

Sprachausgabe

Es ist sehr einfach eine Anwendung zu realisieren, die einen Text quasi vorliest. Beim Start der Java-Anwendung erscheint ein kleines Dialog-Fenster, indem ich zwischen dem Erstellen eines neuen Dialoges und dem Öffnen eines vorhandenen Dialoges wählen kann.

Dialogos1.PNG

Wählt man hier Neuen Dialog erstellen, so landet man in der eigentlichen Arbeitsfläche, die hauptsächlich aus einem großen weißen Arbeitsbereich und einer Knotenleiste (1) mit den zur Verfügung stehenden Funktionen besteht. Auf der Arbeitsfläche befindet sich immer der Start-Knoten (2), der auch nicht gelöscht werden kann.

Dialogos2.PNG

Die Programmierung besteht im Prinzip darin, dass man Elemente aus der Knotenleiste auf die Arbeitsfläche zieht und mit Linien verbindet. Um einen Knoten in die Arbeitsfläche zu bekommen, zieht man ihn mit gedrückter Maustaste an die gewünschte Stelle, ein Doppelklick funktioniert hier nicht.

In der Abbildung sind ein Sprachausgabe-Knoten (3) und ein Ende-Knoten (4) hinzugefügt. Alle Programme müssen in einem Ende-Knoten enden, sonst erhält man eine entsprechende Fehlermeldung.

Damit das Programm eine sinnvolle Ausgabe erzeugt müssen Eingaben für den Sprachausgabe-Knoten gemacht werden. Dazu erfolgt ein Doppelklick auf den Knoten im Arbeitsbereich, worauf sich der Eigenschafts-Dialog (5) öffnet. Im Reiter Allgemein hat man dort die Möglichkeit Einstellungen wie Titel und Hintergrundfarbe anzugeben, oder auch einen Kommentar einzutragen.

Die wichtigsten Einstellungen erfolgen im Reiter Sprachausgabe, hier gibt man den Text ein, der gesprochen werden soll und kann auch die Stimme auswählen. Bei Ausgabe-Typ muss Text stehen, wenn ein konstanter Text ausgegeben werden soll, wenn der Text in einer Variablen gespeichert ist, dann muss man hier Ausdruck wählen.

Sowie die Kästen verbunden sind, die Linien zieht man einfach mit der Maus, kann man das Programm starten, indem man auf Ausführen klickt.


Einfache Spracherkennung

Auch die Spracherkennung ist relativ einfach zu programmieren, zumindest, wenn man keine hohen Anforderungen stellt.

Dialogos3.png

Vor der Spracherkennung steht in der Regel erst einmal ein Ausgabe-Knoten, über den eine Frage gestellt oder ein Hinweis gegeben wird. Danach folgt dann der Knoten Spracherkennung (1). Dieser Knoten verfügt anfangs über keine Ausgänge, erst nachdem passende Einstellungen für diesen Knoten vorgenommen wurden, besitzt er eine entsprechende Anzahl von Ausgängen. Alle Ausgänge sind wieder mit weiteren Knoten verbunden, zumindest Ende-Knoten. In der Regel wird hier meist auch eine Reaktion auf das erkannte Wort erfolgen.

Wesentlich für die Programmierung ist wieder das Menü Eigenschaften, welches durch einen Doppelklick auf den Spracherkennungs-Knoten geöffnet wird. Wichtig ist hier vor allem der Reiter Spracherkennung (2). Hier kann man über den Button Neu (3) Zeilen erzeugen, in die dann die zu erkennenden Wörter eingetragen werden. Im Beispiel sind es nur die Wörter Ja und Nein (4).

Was nirgends dokumentiert ist, ist die Tatsache, dass man die Spracherkennung nicht richtig testen kann, solange die Schreibmarke, bzw. der Eingabefokus bei (4) in einer der Zeilen steht. Zumindest die betreffende Eingabe wird nie erkannt.

Das Programm aus der letzten Abbildung macht wenig Sinn, da das Programm die Eingaben nicht wirklich berücksichtigt. Ein vollständiges minimales Programm könnte also folgendermaßen aussehen.

Dialogos31.png

Zu jeder der möglichen Entscheidungen kommt also noch eine passende Sprachausgabe. In dem Kasten Eigenschaften ist zu sehen, dass das Wort Ja in Anführungsstriche gesetzt wurde. Dadurch wird es bei der Aussprache stärker hervorgehoben.

Die Spracherkennung kann man leicht flexibler gestalten und statt Nein auch Nö, Nee und Ähnliches zulassen. Dazu muss man die einzelnen Wörter, getrennt durch einen senkrechten Strich (auf der Taste mit < und > zu finden) voneinander abtrennen.

Dialogos32.png

Der senkrechte Strich ist hier als Oder zu lesen, wie in vielen Programmiersprachen üblich.

Sollen hier auch Antworten möglich sein, die aus mehr als einem Wort bestehen, so sollte man die Antworten in Anführungsstriche setzen, vor allem, wenn auch noch mehrere mögliche Äußerungen durch den senkrechten Strich getrennt werden sollen.

Quelle: Beispiel von CLT


  • Das Beispielprogramm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.

Spracherkennung mit eigener Grammatik

Solange die Zahl der zur Verfügung stehenden Antwortmöglichkeiten gering ist, funktioniert dieses System problemlos. Es stößt aber schnell an seine Grenzen, wenn die Antwortmöglichkeiten komplexer und umfangreicher werden sollen.

Für solche Fälle kennt DialogOS eigene Grammatiken. Will man mit einer eigenen Grammatik arbeiten, so muss man sie unter Graph -> Grammatiken erst einmal anlegen. In dem folgenden Fenster wählt man Neu und kann dann den Namen und den Inhalt der Grammatik angeben.

Dialogos34.png

In der ersten Eingabezeile steht der Name der Grammatik, in dem großen Fenster darunter der Inhalt. Die ersten beiden Zeilen jeder Grammatik sind gleich. Zuerst kommt die Festlegung der Sprache (language "Deutsch";), dann die Benennung der Grundregel (root = $JaNein;).

In der folgenden Zeile wird dann die Grundregel näher erläutert. Der Senkrechte Strich hat hier wieder die Bedeutung von Oder. Es steht da dann also $Ja oder $Nein. Durch das Dollarzeichen am Anfang wird festgelegt, dass $Ja und $Nein wieder Regeln sind, die in den nächsten beiden zeilen näher ausgeführt werden.

Die Regeln $Ja und $Nein sind dann so aufgebaut, wie im vorherigen Beispiel.

Nun muss man noch den roten Grammatik-Knoten entsprechend anpassen.

Dialogos35.png

In der zweiten Zeile steht hier ein Unterstrich "_", der als "alle anderen Werte" zu lesen ist. Dummerweise funktioniert das Beispiel nicht wie beabsichtigt, das hängt mit der internen Funktionsweise zusammen. Die Grammatik beschreibt, was die Texterkennung akzeptieren soll. Wird eine Eingabe gemacht, die einer der Regeln genügt, so beendet sich die Texterkennung und liefert das Ergebnis an den Grammatikknoten. Bei Eingaben, die nicht den Regeln entsprechen, beginnt die Texterkennung neu. Der Grammatikknoten bekommt auf alle Fälle eine regelkonforme Eingabe, z.B. das "Nö" geliefert. Nun interessiert es in Wirklichkeit nicht, ob der Benutzer "Jo" oder "Jau" gesagt hat, es soll als zustimmendes "Ja" gelten.

Dazu ist eine kleine Änderung an der Grammatik notwendig.

Dialogos36.png

Die Grammatik ist jetzt um die zwei Tags erweitert:

$JaNein = $Ja {$ = "Positiv"} | $Nein {$ = "Negativ"} ;

Das bewirkt, dass immer dann, wenn die Regel $Ja zutrifft, der Wert "Positiv" zurückgeliefert wird und wenn die Regel $Nein zutrifft der Wert "Negativ". In den meisten Beispielen würde hier übrigens statt "Positiv" wieder "Ja" benutzt und statt "Negativ" wieder "Nein", so sollten aber die unterschiedlichen Ebenen deutlicher werden.

Jetzt muss der Grammatik-Knoten nur noch zwischen "Positiv" und "Negativ" unterscheiden. In der zweiten Zeile kann man statt "Negativ" auch wieder das Jokerzeichen "_" angeben, mehr als die beiden Alternativen bleiben ja nicht.

Dialogos37.png


  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.


Erweiterung der eigenen Grammatik

Eigentlich hat die im letzten Abschnitt beschriebene Grammatik wenig Vorteile gegenüber dem Beispiel mit der einfachen Spracherkennung. Sie lässt sich aber leicht dahingehend erweitern, dass auch Antwort-Floskeln mit mehreren Buchstaben möglich werden.

Dialogos38.png

Verändert ist hier die Regel $Ja

$Ja = (Ja | Jau) [ bitte | gerne ] ;

Hier tauchen Klammern auf, die unterschiedliche Bedeutung haben. Die Runden Klammern bedeuten wie in der Mathematik einen Vorrang gegenüber den anderen Regeln. Hier muss der Benutzer also zuerst Ja oder Jau sagen. Die eckigen Klammern beinhalten Texte, die optional sind, also auch wegfallen dürfen. Korrekt wären also nach dieser Grammatik die Eingaben:

Ja
Jau
Ja bitte
Ja gerne
Jau bitte
Jau gerne

Wir haben hier also bisher die folgenden Zeichen mit besonderen Bedeutungen kennengelernt:

|    logisches Oder
( )  die Sequenz, fasst Dinge zusammen
[ ]  die Option, der Inhalt kann entfallen oder nicht

Es gibt noch ein paar weitere besondere Zeichen (Metazeichen)

.   steht für ein beliebiges Zeichen
+   das was davor steht darf mehrfach vorkommen, aber mindestens einmal
*   das was davor steht darf mehrfach vorkommen, aber auch entfallen

Die Regel

$Ja = (Ja | Jau)+ [ bitte | gerne ] ;

würde also auch die Eingaben:

Ja Ja Ja Ja
Ja Ja bitte
Jau Ja 

akzeptieren. Hier sind recht vielfältige Regeln möglich.

  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.


Grammatik mit Variablen

Für vielfältige Eingaben ist das Arbeiten mit den Tags auch recht umständlich, vor allem dann, wenn man sowieso genau wissen muss, was der Benutzer gesagt hat. Das folgende Beispiel soll dazu dienen Zahlen einzugeben und da gibt es doch recht viele verschiedene.

Das folgende Beispiel beginnt mit einem einfachen Ablauf und einer neuen Grammatik.

Dialogos39.PNG

Die erste Sprachausgabe fordert zur Eingabe einer Zahl auf. Die Grammatik wird wieder unter Graph -> Grammatiken ... angelegt. Im Grammatik-Knoten hätten wir jetzt Zehn Fälle zu unterscheiden, in späteren Abwandlungen noch deutlich mehr. Am einfachsten wird die Auswertung, wenn man sich die Eingabe einfach merkt, in einer Variablen namens eingabe. Variablen erstellt man unter Graph -> Variablen. In dem erscheinenden Fenster klickt man auf Neu und kann dann einige Einstellungen vornehmen.

Dialogos40.png

Die Variable ist vom Typ String, was soviel wie Text bedeutet. Generell ist es sinnvoll für alle Eingaben diesen Typ zu benutzen, auch wenn die Eingabe als Zahl ausgewertet werden soll. Vor Beginn des Programmes hat die Variable keinen Wert, deswegen steht hier undefined.

Im Grammatik-Knoten gibt man die vorher definierte Variable an, dann legt die Spracherkennung ihr Ergebnis in dieser Variablen ab.

Dialogos41.png

Nun kann man im Ausgabe-Knoten auf die Variable Bezug nehmen.

Dialogos42.png

Hier sind ein paar wichtige Einstellungen zu sehen. Wichtig ist, dass als Ausgabe-Typ hier jetzt Ausdruck auftaucht und nicht mehr wie bisher Text. Der "normale" Text muss in einem Ausdruck in Anführungszeichen stehen, die Variablen ohne Anführungszeichen. Die Ausgabe besteht hier aus drei Teilen, dem "normalen" Text "Du hast ", der Variablen eingabe und dem "normalen" Text "geantwortet". Mit dem +-Zeichen werden die Teile zusammengefügt.

  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.


Zahlen bis 99

Bisher kennt unser Programm nur die Einer-Zahlen, um das zu ändern, muss man im ersten Anlauf relativ viel Tipparbeit leisten. Wir müssen nämlich die Grammatik erweitern.

language "Deutsch";
root $Zahlen; 

$Zahlen = $Einer|$Zehner|$Zwanziger|$Dreissiger|$Vierziger|$Fuenfziger|    
          $Sechziger|$Siebziger|$Achtziger|$Neunziger;
$Einer=       0| 1| 2| 3| 4| 5| 6| 7| 8| 9;
$Zehner=     10|11|12|13|14|15|16|17|18|19;
$Zwanziger=  20|21|22|23|24|25|26|27|28|29;
$Dreissiger= 30|31|32|33|34|35|36|37|38|39;
$Vierziger=  40|41|42|43|44|45|46|47|48|49;
$Fuenfziger= 50|51|52|53|54|55|56|57|58|59;
$Sechziger=  60|61|62|63|64|65|66|67|68|69;
$Siebziger=  70|71|72|73|74|75|76|77|78|79;
$Achtziger=  80|81|82|83|84|85|86|87|88|89;
$Neunziger=  90|91|92|93|94|95|96|97|98|99;

Damit kann das Programm dann Zahlen zwischen 0 und 99 verstehen. Der Rest des Programmes kann erst einmal unverändert bleiben.

  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.


Beim Ausprobieren dieses Programmes zeigt sich schnell, dass es lästig ist, das Programm jedes mal neu starten zu müssen. Man kann recht einfach erreichen, dass das Programm immer wieder die Eingabe abfragt, indem man eine Linie vom letzten Sprachausgabeknoten zum ersten Sprachausgabeknoten zieht, damit baut man eine Wiederholstruktur, eine Schleife auf.

DialogOS43.png

Leider lässt sich das Programm jetzt nicht mehr ordentlich beenden, es muss abgebrochen werden. Das Problem lösen wir im nächsten Schritt, danach wird dann im übernächsten Schritt die Eingabe Grammatik so vereinfacht, dass auch größere Zahlen eingegeben werden können.

  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.

Zahlen bis 99 mit ordentlichem Ende

Es ist zwar nur ein Schönheitsfehler, aber jedes Programm sollte einen ordentlichen Ausgang besitzen. Wir wollen also die Möglichkeit haben durch Eingabe von "Ende" das Programm zu beenden. Dazu erweitern wir die Grammatik etwas.

language "Deutsch";
root $Eingabe;
$Eingabe = $Zahlen | Ende; 

$Zahlen = $Einer|$Zehner|$Zwanziger|$Dreissiger|$Vierziger|$Fuenfziger|    
          $Sechziger|$Siebziger|$Achtziger|$Neunziger;
$Einer =       0| 1| 2| 3| 4| 5| 6| 7| 8| 9;
$Zehner =     10|11|12|13|14|15|16|17|18|19;
$Zwanziger =  20|21|22|23|24|25|26|27|28|29;
$Dreissiger = 30|31|32|33|34|35|36|37|38|39;
$Vierziger =  40|41|42|43|44|45|46|47|48|49;
$Fuenfziger = 50|51|52|53|54|55|56|57|58|59;
$Sechziger =  60|61|62|63|64|65|66|67|68|69;
$Siebziger =  70|71|72|73|74|75|76|77|78|79;
$Achtziger =  80|81|82|83|84|85|86|87|88|89;
$Neunziger =  90|91|92|93|94|95|96|97|98|99;

Hier ist einfach die erste Regel durch die Regel $Eingabe ersetzt worden. Die Regel $Eingabe wird dann erklärt durch die Regel $Zahlen oder das Wort "Ende". Für Ende wird hier keine extra Regel benötigt, da wir ja nur ein konkretes Wort akzeptieren.

Einschub für die Oberstufe: Alle Zeichenketten, die mit einem $ beginnen sind Regeln. Alle Zeichenketten in den Regeln, die nicht mit einem $ beginnen sind Terminalsymbole, wie z.B. 84. Die Grammatik beginnt immer mit der root-Regel, in diesem Fall $Eingabe. Jede Regel muss erklärt werden, also irgendwo links von einem Gleichheitszeichen auftauchen. Erklärt werden kann eine Regel durch andere Regeln und Terminalsymbole. Zusätzliche dürfen in den Regeln auch Metasymbole wie "|" oder "(" auftauchen.

Die Änderung der Grammatik hat für den Programmablauf erst einmal keine Bedeutung, nur dass das Programm jetzt neben den Zahlen auch das Wort "Ende" akzeptiert, es fehlt immer noch der Ausgang. Am Spracherkennungs-Knoten kann man hierzu wenig erreichen, da wir das Ergebnis der Spracherkennung an eine Variable übergeben. Wir brauchen jetzt also einen Knoten zum Testen einer Variablen.

DialogOS44.png

In dem Knoten Variable testen muss man nur die benutzte Variable eingabe auswählen und dann das Eingabemuster "Ende" angeben. Die Anführungsstriche sind hier wichtig, sonst wird nach einer entsprechenden Variablen gesucht, wir wollen aber mit der festen Zeichenkette Ende vergleichen.

Wichtig ist auch das Häkchen Eine Kante für alle anderen Werte einfügen, über diesen Ausgang geht es dann weiter, wenn nicht Ende erkannt wurde.

Nun haben wir ein korrektes Ende für das Programm, immer dann, wenn der Benutzer Ende sagt. Es ist sinnvoll vor dem Ende des Programmes noch eine kleine Abschiedsmeldung auszugeben, z.B. "Tschüss und sprich mal wieder mit mir".

  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.


Zahlen mit dynamischer Grammatik

In den bisherigen Zahlen-Beispielen ist es lästig, dass in der Grammatik alle erlaubten Zahlen konkret aufgeführt werden müssen. Dabei ist doch genau das etwas, was Computer besser können als Menschen. Jede Programmierumgebung kennt Wiederholungen (Schleifen) mit deren Hilfe es einfach ist solch eine Liste von Zahlen zu erzeugen.

Damit tritt aber eine massive Veränderung in der Grammatik ein, die Grammatik wird jetzt nicht mehr vor dem Start des Programmes eingetippt, sondern nach dem Start des Programmes in einem Script-Knoten erzeugt. Die Struktur des Programmes ändert sich bis auf den neuen Knoten nicht.

DialogOS45.png

In dem Beispiel sieht man eine variable Grammatik, die vorher unter Graph -> Variablen angelegt worden sein muss und zwar vom Typ string.

DialogOS46.png

Das Listing selber kann auf den ersten Blick etwas unübersichtlich wirken.

grammatik = "language \"Deutsch\"; ";
grammatik = grammatik + "root $Eingabe; ";
grammatik = grammatik + "$Eingabe = $Zahlen | Ende ;";
grammatik = grammatik + "$Zahlen = 0|1|2|3|4|5|6|7|8|9; ";

Im Prinzip wird hier die Grammatik erzeugt, die wir schon aus den vorangegangenen Beispielen kennen, nur dass jetzt die Zeichen in die Variable grammatik gepackt werden, die Zeile für Zeile erweitert wird. Alles was an die Variable angehängt wird (für das Anhängen ist das +-Zeichen verantwortlich) müss in Anführungsstriche gesetzt sein. Falls man nun im eigenen Text Anführungsstriche benötigt, wie in der ersten Zeile, müssen diese in der Form \" geschrieben werden (es gibt übrigens auch \n für einen Zeilenumbruch).

Etwas erklärungsbedürftig ist die Zeichenfolge

; " ;

die häufiger auftritt. Das erste Semikolon gehört zur Grammatik und beendet dort die Zeile, dann beendet der Anführungsstrich die Zeichenkette, die an die Grammatik gehängt wird und zum Schluss folgt das Semikolon, welches die Script-Zeile beendet.

Im Knoten Spracherkennung ist jetzt noch eine kleine Änderung notwendig, da wir die Grammatik ja jetzt berechnen.

DialogOS47.png

Hier wird also unter Grammatik nicht mehr eine konkrete Grammatik angegeben, sondern <Aus einem Ausdruck berechnen> angewählt. Klick man dann auf Ausdruck bearbeiten, dann kann man den Ausdruck angeben, hier also einfach grammatik (da keine Anführungszeichen auftauchen, ist die Variable gemeint).


  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.


Bis hierher hat das Programm noch keinen großen Vorteil gegenüber der alten Version, aber das kommt jetzt. Durch eine kleine Veränderung im Script-Knoten kann man den Aufbau der Grammatik so vereinfachen, dass z.B. auch die Zahlen zwischen 0 und 999 eingegeben werden können.

grammatik  = "language \"Deutsch\"; \n";
grammatik = grammatik + "root $Eingabe; \n";
grammatik = grammatik + "$Eingabe = $Zahlen | Ende \n;";
grammatik = grammatik + "$Zahlen = 0 ";
for (int i=1; i<999; i++)
  grammatik = grammatik + "|"+i;
grammatik = grammatik + ";";

Hier wird also die Regel $Zahlen nicht mehr direkt angegeben, sondern in einer Schleife erzeugt. Die Konstruktion der Regel besteht aus drei Teilen, zuerst wird der Teil bis zum Gleichheitszeichen und der 0 angegeben, dann folgt im zweiten Teil die Schleife, die jeweils das Zeichen "|" und eine Zahl anhängt und zwar 999 mal. Zuletzt muss noch das Semikolon an die Regel angehängt werden.

Das ist schon deutlich einfacher, als in den anfänglichen Beispielen. Auch wenn es verlockt, an sollte hier die Grenze nicht wesentlich höher setzen als 999. Schon bei 9999 gibt es sonst spürbare Wartezeiten im Programm, vor allem direkt vor der Spracheingabe.

  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.


Kopfrechentrainer

Aus dem Programm für die Zahleneingabe kann man recht einfach einen kleinen Kopfrechen-Trainer bauen. Das Programm soll sich zwei Zahlen ausdenken, jeweils im Bereich von 0 bis 499 und den Benutzer auffordern dies Zahlen zu addieren. Wenn der Benutzer das Ergebnis nennt, dann überprüft das Programm auf Richtigkeit.

//hier bauen wir wie bisher die Grammatik
grammatik  = "language \"Deutsch\"; \n";
grammatik = grammatik + "root $Eingabe; \n";
grammatik = grammatik + "$Eingabe = 0 ";
for (int i=1; i<999; i++)
  grammatik = grammatik + "|"+i;
grammatik = grammatik + ";";

//hier kommt neu die Rechenaufgabe
operand1=random(0,499);
operand2=random(0,499);
ergebnis=operand1+operand2;

Eine Additionsaufgabe benötigt zwei Zahlen, die hier operand1 und operand2 genannt werden und natürlich als Variable vom Typ int angelegt worden sein müssen. Auch ergebnis ist eine int-Variable, hier merkt sich der Computer das richtige Ergebnis. Die beiden Operanden werden mittels Zufallszahlen-Generator (random) vom Rechner ausgewürfelt im Bereich von 0 bis 499.

DialogOS48.png

Mit dem Knoten Bedingung wird untersucht, ob das Ergebnis richtig ist. Dazu wird die Variable ergebnis mit der Variablen eingabe verglichen. Da ergebnis vom Typ int ist und eingabe vom Typ String muss hier eine Umwandlung von eingabe zum Typ string vorgenommen werden mittels str(ergebnis).

Die beiden möglichen Fälle fürhren zu zwei Ausgabeknoten mit unterschiedlichen Texten. Der rechte Knoten muss deutlich machen, dass die Eingabe falsch war, der linkt Knoten gehört zu einer richtigen Antwort.

  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.

LEGO-Mindstorm

Dialogos4a.png

Eine wirklich tolle Idee bei DialogOS ist die Unterstützung der LEGO-Mindstorm Roboter. Man kann von DialogOS aus folgende Dinge tun:

  • Ein Programm auf dem Roboter starten
  • Ein Programm auf dem Roboter beenden
  • Die Sensoren des Roboters abfragen
  • Die Motoren des Roboters schalten

Aufbau der Verbindung

Bevor man mit dem Mindstorm-Roboter arbeiten kann, benötigt man eine Verbindung zu dem Gerät. Diese Verbindung kann per USB oder per Bluetooth erfolgen, wobei die Nutzung von USB deutlich einfacher ist, die Nutzung von Bluetooth aber viel flexibler.

Dialogos-mindstorm1.PNG

Ausgangspunkt ist auf alle Fälle der Menüpunkt LEGO Mindstorms NXT... im Menü Dialog.

Dialogos-mindstorm2.PNG

Hier ist anfangs sicherlich kein Mindstorm-Roboter bekannt, man muss daher auf den Button NXT-Bausteine suchen klicken.

Dialogos-mindstorm3.PNG

Erkannte Mindstorms werden angezeigt und tauchen anschließen in einer Auswahlliste auf.

Dialogos-mindstorm4.PNG

Nach der Auswahl des Roboters erfolgt die Zuordnung der Anschlüsse zu den Sensoren, die Standard-Sensoren kann man jeweils aus einer Auswahlliste entnehmen.

Die richtige Zuordnung des Sensors ist wichtig, damit die Messwerte auch sinnvoll sinnvoll interpretiert werden können.

NXT-Programm starten/stoppen

Bei der Auswahl der entsprechenden Dialoge erscheint eine Liste der auf dem jeweiligen Roboter gespeicherten Programme. Hier kann eines der Programme ausgewählt werden, welches dann im Programmablauf an dieser Stelle gestartet bzw. gestoppt wird.

Dialogos-mindstorm7.PNG

In der vorigen DialogOS-Version waren diese Funktionen wichtig, da es die direkte Ansteuerung der Motoren noch nicht gab. Heutzutage kann man die Motoren direkt ansteuern. Beim Starten/Stoppen von Programmen gibt es eine merkliche Zeit, bis das Kommando ausgeführt ist. Die direkte Ansteuerung der Motoren erfolgt schneller.


NXT Sensor abfragen

Die Abfrage der Sensoren ist relativ einfach zu regeln. Das folgende Programm liest den Wert des Ultraschall-Sensors aus und spricht den gemessenen Wert. Das Programm besitzt keinen Endknoten, da der Ausgang des Sprach-Knotens mit dem Eingang des Sensor-Knotens verbunden ist, eine klassische Endlosschleife.

Dialogos4.png

In dem Programm steckt ein kleiner Trick. Der Sensor-Knoten speichert seine Daten in Variablen vom Typ int. Der Ausgabe-Knoten erwartet eine Variable vom Typ string. Daher muss der Typ umgewandelt werden, was hier indirekt geschieht, indem die Zahlenvariable zu einem String addiert wird, die Konvertierung erfolgt hierbei automatisch.

  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.


NXT Motor

Für jeden der drei Motoren A, B, C lässt sich hier einzeln festlegen, wie er sich verhalten soll.

Dialogos-mindstorm8.PNG

Dabei stehen die Möglichkeiten:

  • Vorwärts
  • Rückwärts
  • Anhalten
  • Leerlauf

zur Auswahl. Zusätzlich kann man im Feld Motorkraft angeben, mit welcher Leistung der Motor arbeiten soll.

Leider kennt DialogOS nicht die Möglichkeit mehrere Motoren gleichzeitig anzusteuern, man braucht für jeden Motor einen eigenen Knoten.

Ab hier ist der Text noch schwer in Arbeit

Namen buchstabieren

Für Dialoge mit Menschen ist es ganz schön, wenn man diese mit Namen ansprechen kann. Das folgende Programm lässt sich den Namen eines Menschen buchstabieren und lernt ihn so.

DialogOS49.png

Die Grammatik ist etwas lang und umständlich, aber die Buchstabiertabellen folgen keinem automatisierbarem System:

language "Deutsch";
 root $buchstabe;
 
 $buchstabe=$a {$ = "a" }|
            $b {$ = "b" }|
            $c {$ = "c" }|
            $d {$ = "d" }|
            $e {$ = "e" }|
            $f {$ = "f" }|
            $g {$ = "g" }|
            $h {$ = "h" }|
            $i {$ = "i" }|
            $j {$ = "j" }|
            $k {$ = "k" }|
            $l {$ = "l" }|
            $m {$ = "m" }|
            $n {$ = "n" }|
            $o {$ = "o" }|
            $p {$ = "p" }|
            $q {$ = "q" }|
            $r {$ = "r" }|
            $s {$ = "s" }|
            $t {$ = "t" }|
            $u {$ = "u" }|
            $v {$ = "v" }|
            $w {$ = "w" }|
            $x {$ = "x" }|
            $y {$ = "y" }|
            $z {$ = "z" }|
            $ß {$ = "ß" }|
            $ä {$ = "ä" }|
            $ö {$ = "ö" }|
            $ü {$ = "ü" }|
            "Ende"|
            "Zurück"|
            "Hilfe";
  
 $a = a | anton | alfa;
 $b = b | berta | bravo;
 $c = c | cäsar | charlie;
 $d = d | dora  | delta;
 $e = e | emil  | echo;
 $f = f | friedrich | foxtrot;
 $g = g | gustav  | golf;
 $h = h | heinrich | hotel;
 $i = i | inda | india;
 $j = j | julius | juliett;
 $k = k | kaufmann | kilo;
 $l = l | ludwig | lima;
 $m = m | martha | mike;
 $n = n | nordpol | november;
 $o = o | otto | oscar;
 $p = p | paula | papa;
 $q = q | quelle | quebec;
 $r = r | richard | romeo;
 $s = s | siegfried | samuel | sierra;
 $t = t | theodeor | tango;
 $u = u | ulrich | uniform;
 $v = v | viktor | victor;
 $w = w | wilhelm | whiskey;
 $x = x | xanthippe | x-ray;
 $y = y | ypsilon | yankee;
 $z = z | zacharias | zeppelin | zulu;
 $ß = ß | eszett | (scharfes s);
 $ä = ä | ärger | (a umlaut) | alfa-echo;
 $ö = ö | ökonom | (o umlaut) | oskar-echo;
 $ü = ü | übermut | (u umlaut) | uniform-echo;

Der Inhalt im Scriptknoten Zurück:

if (length(name) > 0)
 name=substring(name,0,length(name)-1);

Der Inhalt im Scriptknoten Buchstabe:

name=name+eingabe;

Inhalt des Ausgabeknotens bisher erkannt:

"Ich habe bisher " + length(name) + " Buchstaben gesammelt und " + name + " verstanden."
  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.

Kopfrechentrainer erweitert

Relativ viele der Möglichkeiten lassen sich an dem folgenden Beispiel zeigen, einem Kopfrechentrainer. DialogOS Quelltext des Programmes im XML-Format.

Rechentrainer01.PNG

Bevor es los geht, erst einmal eine Liste der definierten Variablen.

Rechentrainer05.PNG

Die Anwendung verfügt lediglich über sechs Knoten, wovon nur vier überhaupt eine Rolle spielen. Der wichtigste Knoten dabei ist der Script-Knoten.

Rechentrainer02.PNG

Der erste Teil des Listing ist relativ einfach. Hier werden Operator und die Operanden über einen Zufallszahlengenerator gesetzt. Ab Zeile 22 wird dann die Liste der Zahlen aufgebaut, die als falsch interpretiert werden müssen.

Ab Zeile 28 wird die Grammatik aufgebaut, die dann im Eingabeknoten benutzt wird. Zur Laufzeit ergibt sich dann z.B. folgendes Ergebnis.

Rechentrainer06.PNG

Für den Fall $richtig taucht nur die eine richtige Zahl auf, für den Fall $falsch alle übrigen Zahlen aus dem zulässigen Bereich. Als Ergebis zurückgeliefert wird ein Struct mit den Elementen erg und wert. In der Komponente erg wird richtig oder falsch zurückgeliefert, in der Komponente wert die Zahl, die der Benutzer eingegeben hat.

Vor dem Spracherkennungsknoten kommt ein Ausgabeknoten, über den die Aufgabe an den Benutzer ausgegeben wird.

Rechentrainer03.PNG

Der folgende Spracherkennungsknoten benutzt dann die bereits definierte Grammatik und liefert die Eingabe des Benutzers in der Variablen antwort ab.

Der letzte Knoten, vom Typ Sprachausgabe, gibt dem Benutzer dann eine passende Rückmeldung.

Rechentrainer04.PNG


  • Das Beispiel-Programm zum Download mit der rechten Maustaste anklicken und Ziel Speichern unter ... wählen.