2WD sprachgesteuerter Roboter mit Arduino und BitVoicer Server

Notwendige Werkzeuge und Maschinen

	Lötkolben (generisch)
	Zange
	Schraubendreher

Apps und Onlinedienste

Über dieses Projekt

In diesem Tutorial zeige ich, wie man einen sprachgesteuerten 2WD-Roboter baut. Obwohl ich nur Gleichstrommotoren steuere, um den Roboter zu bewegen, kann der gleiche Ansatz für die Sprachsteuerung von Schrittmotoren und Servomotoren verwendet werden. Wenn Sie also vorhaben, einen sprachgesteuerten Roboter zu bauen, der mechanische Bewegungen ausführt, kann dieses Tutorial als dienen Referenz für Ihr Projekt.

Um diesen Roboter zu bauen, benötigen Sie grundsätzlich ein 2-Rad-Chassis, ein Arduino-Board, ein DC-Motortreiberschild, eine BitVoicer-Server-Lizenz, ein WiFi-Modul und ein vorverstärktes Mikrofon. Was die Komponenten angeht, gibt es eine große Vielfalt auf dem Markt und Sie können mit verschiedenen Kombinationen die gleichen Ergebnisse erzielen. In Schritt 1 gebe ich einige Details zu einigen im Roboter verwendeten Komponenten. Wenn Sie also einige davon ändern müssen, suchen Sie einfach nach Komponenten mit ähnlichen Funktionen.

Die folgenden Verfahren werden ausgeführt, um Sprachbefehle in Roboterbewegungen umzuwandeln:

• 1. Audiowellen werden vom Sparkfun Electret Breakout Board erfasst und verstärkt;
• 2. Das verstärkte Signal wird digitalisiert und im Arduino mit seinem Analog-Digital-Wandler (ADC) gepuffert;
• 3. Die Audiobeispiele werden mit dem Microchip WiFi-Modul an den BitVoicer-Server gestreamt;
• 4. BitVoicer Server verarbeitet den Audiostream und erkennt die darin enthaltene Sprache;
• 5. Die erkannte Sprache wird vordefinierten Befehlen zugeordnet, die an das Arduino gesendet werden;
• 6. Der Arduino identifiziert den Befehl und legt fest, welche Gleichstrommotoren wie lange und mit welcher Geschwindigkeit verwendet werden;
• 7. Der Motortreiber wird aktiviert, um die erforderliche Spannung und den erforderlichen Strom zum Bewegen der Motoren bereitzustellen.

Materialliste:

• Arduino UNO:~ 25,00 US-Dollar
• Pololu Dual MC33926 Motortreiberschild:US 29,95
• SparkFun XBee-Schild:14,95 US-Dollar
• Mikrochip RN171VX-Modul mit Antenne:34,95 US-Dollar
• SparkFun Elektret-Mikrofon Breakout:7,95 US-Dollar
• BitVoicer Server 1.0:8,90 US-Dollar
• 2WD-Roboter-Autofahrgestell:15,95 US-Dollar
• Texas Instruments LM1117 (TO-220) Spannungsregler:~U$ 1,95
• 10μF Elektrolytkondensator:~U$ 0,35
• 4 x LEDs:~1,00 US-Dollar
• 4 x 330 Ohm Widerstände:~U$ 0,75
• 4 x 1,5 V AA-Batterien:~ 2,00 US-Dollar
• 9-V-Batterie:~2,00 US-Dollar
• 9V auf Barrel Jack Adapter:~US 2,50
• Jumperdrähte und normale Drähte:~2,00 USD
• Schrauben und flexible Kunststoffklemme zur Befestigung
• Lötkolben und Lot

SCHRITT 1:Kennenlernen der Komponenten

In diesem Schritt gebe ich einige wichtige Informationen über die Komponenten des Roboters und wie man sie für die Montage vorbereitet.

An erster Stelle das Herz des Roboters:ein Arduino UNO R3. Obwohl ich ein Arduino UNO verwende, können Sie andere Arduino-Boards verwenden, um Ihren Roboter zu montieren. Ich habe mich für ein Arduino UNO entschieden, weil es bei weitem das beliebteste Arduino-Board ist und mehr Leute diesen Roboter nachbauen könnten. Wenn Sie ein Arduino DUE haben, können Sie Ihrem Roboter auch Sprachantworten hinzufügen, wie ich es in diesem Tutorial getan habe.

Um die Gleichstrommotoren zu bewegen, habe ich dieses Pololu-Schild verwendet. Es handelt sich um einen Dual-Motor-Treiber, der 5 bis 28 V DC-Motoren steuern kann und bis zu 3 A Dauerstrom pro Motor liefert. Obwohl ich denke, dass dies ein sehr gutes Schild ist, hat mich die klare und detaillierte Dokumentation der Produkte von Pololu am meisten beeindruckt. Außerdem bietet Pololu eine Arduino-Bibliothek, die die Steuerung der Motoren sehr einfach macht. Sie müssen nur die Geschwindigkeit und Richtung (negative oder positive Werte) an die setSpeeds übergeben Funktion. Wenn Sie sich für die Verwendung eines anderen DC-Motortreibers entscheiden, achten Sie auf die vom Treiber verwendeten Pins, da sie nicht mit anderen vom Roboter verwendeten Pins in Konflikt geraten können. Das Pololu-Schild verwendet die folgenden Arduino-Pins:digital 4, 7, 8, 9, 10 und 12; analog 0 und 1; Boden; und 5V. Der wichtigste Aspekt hierbei ist, dass nur die Pins 9 und 10 als PWM-Pins verwendet werden und der Timer, der zum Erzeugen von Pulsen an diesen Pins verwendet wird, nicht derselbe Timer (Timer 2 auf der UNO) ist, der von der BVSMic-Klasse von BitSophia verwendet wird.

Um die Kommunikation mit dem Server herzustellen und auf die BitVoicer Server-Dienste zuzugreifen, verwende ich das Microchip WiFi RN171VX-Modul. Zwei Hauptmerkmale zeichnen sich bei diesem Modul aus:Die gesamte Kommunikation kann auf einfache Weise über die serielle Schnittstelle erfolgen; und das Modul hat den gleichen Formfaktor wie die meisten gängigen XBee-Module. Mit anderen Worten, wenn Sie bereits einen XBee-Schild haben, müssen Sie den Sparkfun-Schild, den ich in diesem Roboter verwende, höchstwahrscheinlich nicht kaufen.

Die Verwendung des XBee-Schilds mit dem Microchip-WLAN-Modul machte die Montage des Roboters ziemlich einfach. Ich habe jedoch ein Problem in dieser Kombination identifiziert. Es ist bekannt, dass die Arbeit mit Radio äußerst komplex ist und von manchen als „Voodoo-Magie“ angesehen wird. Nun, mir ist aufgefallen, dass, während der WiFi-Adapter eingeschaltet ist und Daten überträgt, eine starke Interferenz im Audiosignal auftritt, das vom Arduino ADC gemessen wird. Ich konnte die Quelle dieser Störung nicht genau identifizieren, aber ich habe zwei mögliche Quellen:Die Spitzenstromaufnahme des Moduls (bis zu 240 mA) wird nicht richtig entkoppelt und beeinträchtigt die Referenzspannung, die dem Arduino-ADC bereitgestellt wird; oder das von der Antenne ausgesendete Signal wird von einigen freiliegenden Pins direkt unter dem Modul aufgenommen. Normalerweise weisen die Hersteller von WLAN-Modulen die Designer an, nichts (auch keine Masseflächen) in der Nähe der Antenne zu platzieren, um genau diese Art von Problem zu vermeiden.

Um das oben beschriebene Problem zu beheben, habe ich einen 3,3-V-Spannungsregler und einen 10μF-Elektrolytkondensator an das Sparkfun-Shield gelötet, damit sie die Referenzspannung an den Arduino ADC liefern können. Die gleiche Stromquelle wird vom Sparkfun Elektretmikrofon verwendet. Es löste die Probleme mit dem Spitzenvolumen, die ich im BitVoicer Server Manager sah. Selbst während der Stilleperioden erreichte der Audiopegel im Servermonitor 35 (0-100). Wenn in Ihrem Projekt dasselbe passiert, untersuchen Sie, was mit dem vom Arduino ADC gemessenen Audiosignal passiert.

Ich beschloss, den im Sparkfun-Shield verfügbaren Prototyping-Platz auch zu nutzen, um ein paar LEDs zu löten, die den Status einiger BitVoicer Server-Funktionen anzeigen. Im Bild unten werden von links nach rechts die folgenden Informationen durch die LEDs angezeigt:

• Zeigt an, ob BitVoicer Server läuft und/oder ob die Verbindung aktiv bleibt;
• Gibt an, ob der Datenweiterleitungsdienst ausgeführt wird;
• Zeigt an, ob dem Arduino eine Spracherkennungs-Engine zugewiesen wurde;
• Gibt an, ob wir uns im Aktivierungswort-aktivierten-Zeitraum befinden. Diese LED leuchtet nur, wenn das Aktivierungswort erkannt wird.

In Bezug auf das vorverstärkte Elektretmikrofon gibt es viele Optionen auf dem Markt:Sparkfun, Adafruit, RoboCore, Hackerstore und wahrscheinlich viele andere. Um den Code zu verwenden, den ich in diesem Tutorial poste, stellen Sie sicher, dass das Mikrofon, das Sie kaufen, analog ist, die erforderliche Spannung in Ihrem Arduino-Board verfügbar ist und die Verstärkung hoch genug ist (normalerweise 100x für Elektret-Mikrofone) für den Arduino ADC.

Das im Roboter verwendete 2WD-Chassis ist eines der billigsten und beliebtesten bei ebay. Das komplette Kit enthält eine Acrylplattform, zwei Kunststoff-/Gummiräder, ein 360º-Rad, zwei Gleichstrommotoren mit Getriebe (1:48-Verhältnis), einen 4xAA-Batteriehalter, zwei Geschwindigkeits-Encoder-Scheiben und einen Satz Schrauben.

SCHRITT 2:Montage

Lass uns zur Arbeit gehen! In diesem Schritt müssen Sie alle Komponenten wie in den Bildern unten gezeigt am Chassis montieren.

Wenn Sie die LEDs und den Spannungsregler nicht auf dem XBee-Schild verlöten möchten, können Sie diese wie im Bild unten gezeigt auf einem kleinen Steckbrett montieren. Wählen Sie in diesem Fall ein verkleinertes Steckbrett, damit Sie es ohne weitere Probleme irgendwo am Chassis befestigen können.

In den obigen Bildern können Sie feststellen, dass ich eine Eisendrahtstütze gemacht habe, um das Mikrofon zu halten. Sie können auch sehen, dass ich einen Streifen Filzstoff um das 360º-Rad geklebt habe. Ich habe diese beiden Maßnahmen ergriffen, um zu versuchen, das vom Roboter erzeugte und vom Mikrofon aufgenommene Geräusch zu reduzieren, wenn sich der Roboter bewegt. Ich habe sogar ein kleines Stück Schwamm geschnitten, um die Mikrofondrähte von der Halterung zu isolieren. Natürlich war es nicht 100% effektiv, aber es reduzierte das Rauschen ein wenig und verbesserte die Genauigkeit der Spracherkennung.

SCHRITT 3:Einrichten des WLAN-Moduls

Wie ich in Schritt 1 sagte, kann das Microchip RN171VX WiFi-Modul vollständig über die serielle Schnittstelle betrieben werden. Dies macht die Einrichtung des Moduls extrem einfach, da alle Befehle einfache Zeichenfolgen sind, die über den seriellen Arduino-Port gesendet werden. Sie müssen nur eine Zeichenfolge mit „$$$“ senden, um in den Befehlsmodus zu gelangen, die Befehle senden und dann eine Zeichenfolge mit „exit“ senden, um in den Datenmodus zurückzukehren.

Der Code mit dem Namen WiFi-Modul-Setup Am Ende dieser Anleitung befindet sich der Code, mit dem ich das WLAN-Modul in meinem Heimnetzwerk eingerichtet habe. Sie müssen die mit „XXXXXX“ gekennzeichneten Teile des Codes mit Informationen aus Ihrem WLAN-Netzwerk ändern. Drei Befehle müssen geändert werden:

• WLAN-SSID XXXXXX festlegen :Ersetzen Sie XXXXXX durch Ihren Netzwerknamen (SSID);
• WLAN-Satz XXXXXX festlegen :Ersetzen Sie XXXXXX durch Ihr Netzwerkpasswort;
• IP-Adresse XXXXXX festlegen :Ersetzen Sie XXXXXX durch die IP-Adresse (statisch), die Sie für Ihr WLAN-Modul festlegen möchten.

In meinem WLAN-Netzwerk ist die Authentifizierungsmethode WPA2-PSK. Wenn Ihr Netzwerk eine andere Authentifizierungsmethode verwendet, müssen Sie auch die set wlan auth ändern Befehl. Sehen Sie in der Dokumentation des WLAN-Moduls (Abschnitt 4.3 Set Commands) nach, welcher Wert der richtige für Ihr Netzwerk ist.

Es gibt ein wichtiges Details zum Sparkfun-Schild und seinem kleinen Schalter (Bild unten). Um Code über seine USB-Schnittstelle auf den Arduino hochzuladen, muss der Schalter auf die Position DLINE gestellt werden. Damit der Arduino Daten über das WiFi-Modul über seinen seriellen Port senden/empfangen kann, muss der Schalter auf die UART-Position gestellt werden. Dies ist notwendig, da das WiFi-Modul und der USB-Chip des Arduino UNO den gleichen seriellen Port im ATmega-Mikrocontroller verwenden. Wenn der Schalter auf UART eingestellt ist und Sie versuchen, Code auf das Arduino hochzuladen, wird in der Arduino-IDE eine Fehlermeldung angezeigt.

So laden Sie das WiFi-Modul-Setup  . hoch Code zum Arduino und erlauben dem Arduino, das WiFi-Modul einzurichten, befolgen Sie die folgenden Schritte:

• 1. Stellen Sie den Schalter auf die Position DLINE;
• 2. Öffnen Sie die Arduino-IDE, fügen Sie den Code ein und laden Sie ihn auf den Arduino hoch;
• 3. Sobald der Upload abgeschlossen ist, haben Sie 5 Sekunden (Verzögerung am Anfang des Codes) Zeit, um den Schalter in die UART-Position zu bringen, bevor Befehle an das WiFi-Modul gesendet werden. Wenn der erste Befehl verloren geht, funktioniert keiner der anderen. Setzen Sie in diesem Fall einfach den Arduino zurück, damit der Sketch wieder von vorne laufen kann.

Während der Modulkonfiguration, die etwa 25 Sekunden dauert, blinken die Modul-LEDs anders als im Standardmuster. In diesem Moment wissen Sie, dass das WiFi-Modul konfiguriert wird.

Nachdem das Modul konfiguriert wurde, versuchen Sie, das Modul mit der IP-Adresse, die in der set IP-Adresse angegeben ist, zu pingen (Eingabeaufforderung --> "ping [IP-Adresse]" --> drücken Sie die Eingabetaste). Befehl. Wenn Sie keine Antwort vom Modul erhalten, ist bei den vorherigen Schritten ein Fehler aufgetreten.

SCHRITT 4:Planung der Roboterbewegungen

Obwohl der Roboter nur über zwei Gleichstrommotoren verfügt, kann er eine Reihe komplexer Bewegungen ausführen. Um dieses Tutorial so einfach wie möglich zu halten, habe ich mich entschieden, nur etwa drei Dutzend grundlegende gleichförmige Bewegungen und einige komplexe Bewegungen zu definieren, die durch die Kombination der Grundbewegungen gebildet werden.

Wie Sie in den Bildern in Schritt 2 sehen können, verwende ich keine Rotationssensoren in den Rädern, Ultraschallsensoren oder andere Arten von Sensoren, um den Abstand zu Objekten oder die zurückgelegte Strecke zu messen. Dies verhindert, dass der Roboter hochpräzise Bewegungen ausführt. Wenn Sie jedoch nur die Richtung und die Geschwindigkeit der Motoren steuern, können Sie eine Präzision erreichen, die ausreicht, um den Roboter zu bewegen.

Das erste, was Sie wissen müssen, um die erforderliche Ausführungszeit für jede Bewegung berechnen zu können, ist die Durchschnittsgeschwindigkeit des Roboters. Legen Sie dazu ein Maßband parallel zum Roboter und aktivieren Sie beide Motoren gleichzeitig für ein bis zwei Sekunden, messen Sie die zurückgelegte Strecke und leiten Sie die Geschwindigkeit ab. In meiner Konfiguration erreichte ich 13,7 Zentimeter pro Sekunde mit 62,5% der maximalen Motordrehzahl (250/400, siehe Pololu Arduino-Bibliothek). Mit anderen Worten, um den Roboter 1 Meter (100 cm) vorwärts zu bewegen, mussten die Motoren gleichzeitig für 7,299270… Sekunden aktiviert werden. Ich habe mich dafür entschieden, die Zeitzählung in Millisekunden-Auflösung zu halten, aber wenn Sie eine höhere Bewegungspräzision erreichen möchten, sollten Sie die Auflösung auf Mikrosekunden erhöhen. Um den Roboter 1 Meter zu bewegen, muss ich beide Motoren gleichzeitig für 7299 Millisekunden aktivieren. Ab dieser Zahl wird alles zur Dreierregel für andere Entfernungen. Um Bogen- oder Kreisbewegungen auszuführen, muss sich ein Rad schneller bewegen als das andere. Um den Roboter zur Seite zu drehen, muss nur ein Rad aktiviert werden oder beide in entgegengesetzte Richtungen (um sich um die eigene Achse zu drehen). Hier müssen Sie Trigonometrie verwenden, um die von jedem Rad zurückgelegte Strecke zu ermitteln und wie lange jeder Motor aktiviert werden muss. Einen guten Ausgangspunkt für diese Konzepte finden Sie in den folgenden Links (ich möchte hier nicht weiter darauf eingehen):http://rossum.sourceforge.net/papers/CalculationsForRobotics/CirclePath.htm und http://math .stackexchange.com/questions/60176/move-two-wheeled-robot-from-one-point-to-ander.

Wie Sie am Ende des Videos unten sehen können, lasse ich den Roboter auch einige geometrische Grundformen (Quadrat, Dreieck und Kreis) auf den Boden „zeichnen“. Diese Bewegungen werden durch die Kombination von Grundbewegungen (z. B. vorwärts gehen, drehen, vorwärts gehen, drehen usw.) erreicht. Die Kombination dieser Bewegungen erfolgt im BitVoicer Server Voice Schema und Sie werden sie in der im nächsten Schritt vorgestellten Arduino-Skizze nicht sehen.

SCHRITT 5:Hochladen des Codes auf den Arduino

In diesem Schritt müssen Sie die Skizze mit dem Namen Robot Source Code hochladen , am Ende dieser Anleitung zum Arduino. Sie können die Arduino-Skizze auch über den folgenden Link herunterladen. Denken Sie daran, dass Sie zum Senden von Code an das Arduino den Schalter am Sparkfun-Schild auf die DLINE-Position stellen müssen, wie in Schritt 3 beschrieben. Bevor Sie den Code hochladen, müssen Sie den BitVoicer-Server und die Pololu-Motortreiberbibliotheken ordnungsgemäß in der Arduino-IDE installieren (Importieren einer .zip-Bibliothek).

Roboter-Quellcode :BVS_Demo3.ino

Einige Teile dieser Skizze ähneln Teilen, die ich in einem meiner vorherigen Tutorials verwendet habe und behandeln die Kommunikation mit BitVoicer Server (BVSP- und BVSMic-Klassen). In diesem Tutorial bleibe ich bei der Erklärung der neuen Teile der Skizze. Wenn Sie weitere Informationen zur Verwendung des BVSP und der BVSMic-Klassen erhalten möchten, empfehle ich Ihnen, das oben erwähnte Tutorial zu lesen.

• Konstanten-Erklärung :Am Anfang der Skizze deklariere ich eine Reihe von Konstanten, die im gesamten Code verwendet werden. Die Gruppe der Konstanten mit Motoreinstellungen definiert die Standardmotordrehzahlen und zwei Richtungskonstanten. Die Pololu-Motortreiberbibliothek akzeptiert Werte von -400 bis +400 für die Motordrehzahl, wobei Null aus bedeutet. Negative Werte zeigen eine Rückwärtsdrehung oder, wenn Sie die Motorkabel wie ich invertiert haben, eine Vorwärtsdrehung an. Die Gruppe von Konstanten mit Befehlswerten bezieht sich auf die Befehle, die vom BitVoicer Server gesendet werden. In dieser Skizze habe ich nur 40 grundlegende Befehle von Byte . definiert Typ, aber komplexere Bewegungen können durch Kombination dieser Befehle ausgeführt werden.
• Variablen zur Ausführungssteuerung :Fünf Variablen werden am Anfang des Codes definiert, um die Ausführung von Befehlen zu steuern (motorSpeed , cmdDauer , cmdStartTime , cmdRunning e lastFwdCmd ). Die motorSpeed ​​ Variable hält die aktuelle Motordrehzahl. Diese Variable wird mit einem der Standardwerte aktualisiert, die durch die Geschwindigkeitskonstanten definiert sind, wenn das Arduino einen Befehl vom BitVoicer-Server erhält, um die Motorgeschwindigkeiten zu aktualisieren. Die cmdDuration Variable enthält die Gesamtdauer des aktuellen Befehls. Diese Variable wird gegen die cmdStartTime . geprüft variabel in allen Iterationen der Schleife Funktion wenn cmdRunning ist wahr . Wenn die Befehlsausführungszeit abgelaufen ist, wird der RunCommand Funktion wird aufgerufen, um die Motoren zu stoppen. Der lastFwdCmd Variable enthält den letzten „go/move forward“-Befehl. Diese Variable wird verwendet, um die zuletzt zurückgelegte Strecke zu kennen, damit der Befehl „Komm zurück“ ausgeführt werden kann. Beachten Sie, dass Sie, um diesen Befehl zu verwenden, dem Roboter zuerst sagen müssen, dass er sich umdrehen soll.
• WLAN-Verbindung :Am Ende der Skizze definiere ich zwei Funktionen zum Verbinden und Trennen von BitVoicer Server (Verbinden und Trennen ). Diese Funktionen versetzen das Microchip WiFi-Modul in den Befehlsmodus, öffnen oder schließen eine TCP/IP-Verbindung und bringen das Modul in den Datenmodus zurück. In der Schleife Funktion, wenn die verbundene Variable nicht wahr ist , ich nenne das Connect Funktion. Meldet die BVSP-Klasse den Serverstatus ist abgelaufen, d. h. auf die letzte Statusanfrage ist keine Antwort eingegangen, gehe ich davon aus, dass die Verbindung verloren gegangen ist und rufe die Disconnect Funktion. Dies erzwingt einen neuen Verbindungsversuch in der nächsten Schleifeniteration.
• RunCommand Funktion :Diese Funktion wird jedes Mal aufgerufen, wenn ein Befehl vom BitVoicer-Server empfangen wird. Es dauert ein Byte Wert, der einem der Grundbefehle entspricht, die durch die Konstanten am Anfang der Skizze definiert sind. Jeder Grundbefehl wird innerhalb des Schalters identifiziert, sodass die entsprechenden Motordrehzahlen sowie die Befehlsdauer eingestellt werden können. Am Ende der Funktion wird das cmdRunning Variable ist auf wahr gesetzt und die Zeit, die von den Millis zurückgegeben wird Funktion wird in der cmdStartTime . gespeichert Variable. Dadurch kann der Arduino die Befehlsausführung wie oben beschrieben steuern. Die Zeiten in Millisekunden für jeden Befehl wurden wie im vorherigen Schritt beschrieben ermittelt.

SCHRITT 6:BitVoicer Server einrichten

In diesem Schritt müssen Sie das BitVoicer Server Voice Schema mit den zu erkennenden Sätzen und den Befehlen erstellen, die an das Arduino gesendet werden. Am Ende dieses Schrittes gibt es zwei Links zu Dateien, die alle BitVoicer Server Solution Objects enthalten, die in diesem Tutorial verwendet werden. Wenn Sie nicht alle Lösungsobjekte einzeln erstellen möchten, können Sie sie mithilfe dieser Dateien importieren (Importieren von Lösungsobjekten).

Bevor Sie mit dem Erstellen des Sprachschemas beginnen, müssen Sie ein Gerät erstellen, das das Arduino in BitVoicer Server darstellt. Erstellen Sie ein gemischtes Gerät und nennen Sie es ArduinoUnoWiFi. Wählen Sie auf der Registerkarte Kommunikation TCP/IP und geben Sie die dem WiFi-Modul in Schritt 3 zugewiesene IP-Adresse ein. Aktivieren Sie auf der Registerkarte Cues den Start of Activated Period und Ende des aktivierten Zeitraums Hinweise. Wählen Sie Int16 SendData-Befehle für beide Cues und wählen Sie das ArduinoUnoWiFi-Gerät als Ziel der Befehle aus. Geben Sie im Datenfeld 1 für den Start des aktivierten Zeitraums ein Cue und 0 für das Ende des aktivierten Zeitraums Stichwort. Diese Hinweise lassen das Arduino jedes Mal eine LED einschalten, wenn das Aktivierungswort erkannt wird. Nach Ablauf des aktivierten Zeitraums (definiert im Voice-Schema) erlischt diese LED.

Lassen Sie uns nun das Voice-Schema erstellen. Obwohl der Roboter nur 40 Grundbefehle hat, möchten Sie vielleicht viele Wortkombinationen erstellen, die denselben Befehl auslösen. Als Beispiel möchten Sie vielleicht, dass die Sätze „einen Meter vorwärts gehen“ und „einen Meter vorwärts gehen“ denselben Befehl auslösen. Außerdem möchten Sie vielleicht komplexe Befehle wie „Do a Square“ erstellen, die eine Reihe von zeitlich begrenzten Befehlen nacheinander auslösen. Aus diesem Grund kann Ihr Sprachschema stark wachsen und über mehr als 40 grundlegende Befehle verfügen. BitVoicer Server unterstützt unbegrenzte Sätze, sodass Sie so viele Sätze definieren können, wie Sie benötigen (meiner hatte mehr als 80 Sätze). Hier möchte ich zwei Tipps geben:Erstellen Sie einen Standardbefehl in den BitVoicer Server Manager Options; und kopiere und füge duplizierte Befehle von einem Satz in den anderen ein.

Satzbefehle senden Byte Datentypen zum Arduino. Verwenden Sie die am Anfang der Skizze definierten Konstanten, um zu wissen, welcher Wert für jeden Befehl gesendet werden muss. Komplexe Befehle senden viele Werte nacheinander und Sie müssen das Intervall (die Verzögerung) zwischen ihnen so steuern, dass kein Wert gesendet wird, während der vorherige Befehl ausgeführt wird. Verwenden Sie das Verzögerungsfeld, um das Intervall zwischen den Befehlen einzustellen.

Lösungsobjektdateien :

Device.sof

VoiceSchema.sof

SCHRITT 7:Fazit

Jetzt müssen Sie nur noch die AA-Batterien einlegen und die 9-V-Batterie an die Arduino-Strombuchse anschließen, damit Ihr Roboter zum Leben erweckt wird! Nachdem Sie den Code auf den Arduino hochgeladen haben, vergessen Sie nicht, den am Sparkfun-Schild montierten Schalter in die UART-Position zu stellen. Andernfalls empfängt das WiFi-Modul keine Daten, die vom seriellen Arduino-Port gesendet werden.

Nach dem Einschalten des Roboters dauert es eine Weile, bis die Status-LEDs aufleuchten. Sie sehen, wie das WiFi-Modul mit der Kommunikation beginnt, und wenn die TCP/IP-Verbindung hergestellt ist, leuchtet eine der Modul-LEDs durchgehend. Nach wenigen Augenblicken leuchten auch drei der vier Status-LEDs auf. Dies bedeutet, dass dem Arduino eine Spracherkennungs-Engine zugewiesen wurde. Von nun an ist der Roboter bereit, Befehle anzunehmen.

Nach einigen Tests mit dem Roboter war ich mit der Spracherkennung recht zufrieden, obwohl sie nicht immer 100% der Befehle erkannte. In dieser Hinsicht hat mich BitVoicer Server wirklich überrascht. Mit der Präzision der Bewegungen des Roboters war ich jedoch nicht so zufrieden. Um dieses Problem zu beheben, müsste ich den Rädern Rotationssensoren hinzufügen. Das Chassis-Kit, das ich im Roboter verwendet habe, kommt bereits mit Decoder-Scheiben, die am Getriebe befestigt werden können. Das Anbringen von Sensoren an diesen Scheiben würde es mir ermöglichen, den Roboter basierend auf der tatsächlich zurückgelegten Strecke zu bewegen, damit seine Bewegung genauer wäre. Ich könnte auch Ultraschallsensoren hinzufügen, um ein Anstoßen an meinen Möbeln zu vermeiden. Wahrscheinlich werde ich das eines Tages tun, aber das überlasse ich vorerst dir.

Bis zum nächsten Mal!

Code

• WiFi-Modul-Setup
• Roboter-Quellcode

WiFi-Modul-SetupArduino

void setup() { Serial.begin(115200); pinMode(13, AUSGANG); Verzögerung (5000); Serial.print("$$$"); Verzögerung (1000); Serial.println ("set wlan auth 4"); Verzögerung (1000); Serial.println ("set wlan-phrase XXXXXX"); Verzögerung (1000); Serial.println ("set wlan ssid XXXXXX"); Verzögerung (1000); Serial.println("Wlan-Kanal 0 einstellen"); Verzögerung (1000); Serial.println ("set wlan join 1"); Verzögerung (1000); Serial.println ("set wlan tx 0"); Verzögerung (1000); Serial.println ("set IP dhcp 0"); Verzögerung (1000); Serial.println("IP-Adresse XXXXXX einstellen"); Verzögerung (1000); Serial.println ("set comm remote 0"); Verzögerung (1000); Serial.println ("set comm close 0"); Verzögerung (1000); Serial.println ("set comm open 0"); Verzögerung (1000); Serial.println("Comm-Größe 500 einstellen"); Verzögerung (1000); Serial.println ( "komm-Zeit 50 einstellen"); Verzögerung (1000); Serial.println ("set uart baud 115200"); Verzögerung (1000); Serial.println ("set uart flow 0"); Verzögerung (1000); Serial.println("Speichern"); Verzögerung (1000); Serial.println("Beenden"); Verzögerung (1000); digitalWrite(13, LOW);}void loop() { }

Roboter-QuellcodeArduino

#include #include #include // Definiert die Arduino-Pins that will be used to control// LEDs and capture audio#define BVS_RUNNING 2#define BVS_SRE 5#define BVS_DATA_FWD 3#define BVS_ACT_PERIOD 6#define BVSM_AUDIO_INPUT 3// Defines the constants that will be passed as parameters to // the BVSP.begin functionconst unsigned long STATUS_REQUEST_INTERVAL =2000;const unsigned long STATUS_REQUEST_TIMEOUT =1000;// Defines the size of the mic bufferconst int MIC_BUFFER_SIZE =64;// Initializes a new global instance of the BVSP classBVSP bvsp =BVSP();// Initializes a new global instance of the BVSMic classBVSMic bvsm =BVSMic();// Initializes a new global instance of the // DualMC33926MotorShield classDualMC33926MotorShield ms =DualMC33926MotorShield();// Creates a buffer that will be used to read recorded samples // from the BVSMic classbyte micBuffer[MIC_BUFFER_SIZE];// Creates a global variable that indicates whether the // Arduino is connected to BitVoicer Serverboolean connected =false;// Defines some constants for the motor settingsconst int SPEED_STOP =0;const int SPEED_SLOW =100;const int SPEED_NORMAL =250;const int SPEED_FAST =400;const int DIRECTION_FRONT =-1;const int DIRECTION_BACK =1;// Declares a global variables to hold the current motor speed.// The default is SPEED_NORMAL, but there are voice // commands that change this setting.int motorSpeed =SPEED_NORMAL;// Stores the command duration in millisecondsunsigned long cmdDuration =0;// Stores the time the command started runningunsigned long cmdStartTime =0;// Stores whether a command is running or notbool cmdRunning =false;// Stores the last MOVE_FORWARD command. This variable // is used only for the COME_BACK command.byte lastFwdCmd =0;// Defines some constants for command names/values// Just to make the code more readableconst byte CMD_STOP =0;const byte CMD_MOVE_FORWARD =1;const byte CMD_MOVE_FORWARD_1_CM =2;const byte CMD_MOVE_FORWARD_2_CM =3;const byte CMD_MOVE_FORWARD_5_CM =4;const byte CMD_MOVE_FORWARD_10_CM =5;const byte CMD_MOVE_FORWARD_25_CM =6;const byte CMD_MOVE_FORWARD_50_CM =7;const byte CMD_MOVE_FORWARD_1_M =8;const byte CMD_MOVE_BACKWARD =9;const byte CMD_MOVE_BACKWARD_1_CM =10;const byte CMD_MOVE_BACKWARD_2_CM =11;const byte CMD_MOVE_BACKWARD_5_CM =12;const byte CMD_MOVE_BACKWARD_10_CM =13;const byte CMD_MOVE_BACKWARD_25_CM =14;const byte CMD_MOVE_BACKWARD_50_CM =15;const byte CMD_MOVE_BACKWARD_1_M =16;const byte CMD_TURN_AROUND =17;const byte CMD_TURN_AROUND_RIGHT =18;const byte CMD_TURN_AROUND_LEFT =19;const byte CMD_DO_360 =20;const byte CMD_TURN_RIGHT =21;const byte CMD_TURN_RIGHT_10 =22;const byte C MD_TURN_RIGHT_25 =23;const byte CMD_TURN_RIGHT_45 =24;const byte CMD_TURN_LEFT =25;const byte CMD_TURN_LEFT_10 =26;const byte CMD_TURN_LEFT_25 =27;const byte CMD_TURN_LEFT_45 =28;const byte CMD_DO_CIRCLE =29;const byte CMD_COME_BACK =30;const byte CMD_MOVE_FORWARD_2_M =31;const byte CMD_MOVE_FORWARD_3_M =32;const byte CMD_MOVE_BACKWARD_2_M =33;const byte CMD_MOVE_BACKWARD_3_M =34;const byte CMD_SET_SPEED_SLOW =35;const byte CMD_SET_SPEED_NORMAL =36;const byte CMD_SET_SPEED_FAST =37;const byte CMD_TURN_LEFT_45_BACKWARD =38;const byte CMD_TURN_RIGHT_45_BACKWARD =39;void setup(){ // Starts serial communication at 115200 bps Serial.begin(115200); // Sets the Arduino pin modes pinMode(BVS_RUNNING, OUTPUT); pinMode(BVS_SRE, OUTPUT); pinMode(BVS_DATA_FWD, OUTPUT); pinMode(BVS_ACT_PERIOD, OUTPUT); AllLEDsOff(); // Sets the Arduino serial port that will be used for // communication, how long it will take before a status request // times out and how often status requests should be sent to // BitVoicer Server bvsp.begin(Serial, STATUS_REQUEST_TIMEOUT, STATUS_REQUEST_INTERVAL); // Sets the function that will handle the frameReceived // event bvsp.frameReceived =BVSP_frameReceived; // Prepares the BVSMic class timer bvsm.begin(); // Prepares the motor shield class (pins and timer1) ms.init();}void loop() { // If it is not connected to the server, opens a TCP/IP // connection, sets connected to true and resets the BVSP // class if (!connected) { Connect(Serial); connected =true; bvsp.reset(); } // Checks if the status request interval has elapsed and if it // has, sends a status request to BitVoicer Server bvsp.keepAlive(); // Checks if there is data available at the serial port buffer // and processes its content according to the specifications // of the BitVoicer Server Protocol bvsp.receive(); // Gets the respective status from the BVSP class and sets // the LEDs on or off digitalWrite(BVS_RUNNING, bvsp.isBVSRunning()); digitalWrite(BVS_DATA_FWD, bvsp.isDataFwdRunning()); // Checks if there is a SRE assigned to the Arduino if (bvsp.isSREAvailable()) { // Turns on the SRE available LED digitalWrite(BVS_SRE, HIGH); // If the BVSMic class is not recording, sets up the audio // input and starts recording if (!bvsm.isRecording) { bvsm.setAudioInput(BVSM_AUDIO_INPUT, EXTERNAL); bvsm.startRecording(); } // Checks if the BVSMic class has available samples if (bvsm.available) { // Makes sure the inbound mode is STREAM_MODE before // transmitting the stream if (bvsp.inboundMode ==FRAMED_MODE) bvsp.setInboundMode(STREAM_MODE); // Reads the audio samples from the BVSMic class int bytesRead =bvsm.read(micBuffer, MIC_BUFFER_SIZE); // Sends the audio stream to BitVoicer Server bvsp.sendStream(micBuffer, bytesRead); } } else { // There is no SRE available // Turns off the SRE and ACT_PERIOD LEDs digitalWrite(BVS_SRE, LOW); digitalWrite(BVS_ACT_PERIOD, LOW); // If the BVSMic class is recording, stops it if (bvsm.isRecording) bvsm.stopRecording(); } // If the status has timed out, the connection is considered // lost if (bvsp.hasStatusTimedOut()) { // If the BVSMic is recording, stops it if (bvsm.isRecording) bvsm.stopRecording(); // Closes the TCP/IP connection Disconnect(Serial); AllLEDsOff(); connected =false; } // If a command is running, checks if its duration has // expired. If it has, stop the motors. if (cmdRunning) if (millis() - cmdStartTime>=cmdDuration) RunCommand(CMD_STOP);}// Handles the frameReceived eventvoid BVSP_frameReceived(byte dataType, int payloadSize){ // Performs the appropriate actions based on the frame // data type. If the data type is byte, it is a command. // If the data type is int, changes the activated // period LED. switch (dataType) { case DATA_TYPE_BYTE:RunCommand(bvsp.getReceivedByte()); brechen; case DATA_TYPE_INT16:digitalWrite(BVS_ACT_PERIOD, bvsp.getReceivedInt16()); brechen; }}// Runs the command received from the servervoid RunCommand(byte cmd){ switch (cmd) { case CMD_STOP:ms.setSpeeds(SPEED_STOP, SPEED_STOP); cmdRunning =false; Rückkehr; case CMD_MOVE_FORWARD:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =60000; brechen; case CMD_MOVE_FORWARD_1_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =23; brechen; case CMD_MOVE_FORWARD_2_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =47; brechen; case CMD_MOVE_FORWARD_5_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =117; brechen; case CMD_MOVE_FORWARD_10_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =234; brechen; case CMD_MOVE_FORWARD_25_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =468; brechen; case CMD_MOVE_FORWARD_50_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =1170; brechen; case CMD_MOVE_FORWARD_1_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =2339; brechen; case CMD_MOVE_FORWARD_2_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =4678; brechen; case CMD_MOVE_FORWARD_3_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =7018; brechen; case CMD_MOVE_BACKWARD:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =60000; brechen; case CMD_MOVE_BACKWARD_1_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =23; brechen; case CMD_MOVE_BACKWARD_2_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =47; brechen; case CMD_MOVE_BACKWARD_5_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =117; brechen; case CMD_MOVE_BACKWARD_10_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =234; brechen; case CMD_MOVE_BACKWARD_25_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =468; brechen; case CMD_MOVE_BACKWARD_50_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =1170; brechen; case CMD_MOVE_BACKWARD_1_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =2339; brechen; case CMD_MOVE_BACKWARD_2_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =4678; brechen; case CMD_MOVE_BACKWARD_3_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =7017; brechen; case CMD_TURN_AROUND:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =540; brechen; case CMD_TURN_AROUND_RIGHT:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =540; brechen; case CMD_TURN_AROUND_LEFT:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_FRONT); cmdDuration =540; brechen; case CMD_DO_360:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =1065; brechen; case CMD_TURN_RIGHT:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =503; brechen; case CMD_TURN_RIGHT_10:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =56; brechen; case CMD_TURN_RIGHT_25:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =140; brechen; case CMD_TURN_RIGHT_45:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =252; brechen; case CMD_TURN_LEFT:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =503; brechen; case CMD_TURN_LEFT_10:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =56; brechen; case CMD_TURN_LEFT_25:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =140; brechen; case CMD_TURN_LEFT_45:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =252; brechen; case CMD_DO_CIRCLE:ms.setSpeeds( SPEED_NORMAL * DIRECTION_FRONT, SPEED_NORMAL * DIRECTION_FRONT * 0.60); cmdDuration =4587; brechen; case CMD_COME_BACK:RunCommand(lastFwdCmd); Rückkehr; case CMD_SET_SPEED_SLOW:motorSpeed =SPEED_SLOW; Rückkehr; case CMD_SET_SPEED_NORMAL:motorSpeed =SPEED_NORMAL; Rückkehr; case CMD_SET_SPEED_FAST:motorSpeed =SPEED_FAST; Rückkehr; case CMD_TURN_LEFT_45_BACKWARD:ms.setSpeeds(motorSpeed * DIRECTION_BACK, 0); cmdDuration =252; brechen; case CMD_TURN_RIGHT_45_BACKWARD:ms.setSpeeds(0, motorSpeed * DIRECTION_BACK); cmdDuration =252; brechen; } // Sets the command start time cmdStartTime =millis(); // Sets cmdRunning to true cmdRunning =true;}// Opens a TCP/IP connection with the BitVoicer Servervoid Connect(HardwareSerial &serialPort){ serialPort.print("$$$"); Verzögerung (500); // Use the IP address of the server and the TCP port set // in the server properties serialPort.println("open 192.168.0.11 4194"); Verzögerung (1000); serialPort.println("exit"); delay(500);}// Closes the TCP/IP connection with the BitVoicer Servervoid Disconnect(HardwareSerial &serialPort){ serialPort.print("$$$"); Verzögerung (500); serialPort.println("close"); Verzögerung (1000); serialPort.println("exit"); delay(500);}// Turns all LEDs offvoid AllLEDsOff(){ digitalWrite(BVS_RUNNING, LOW); digitalWrite(BVS_SRE, LOW); digitalWrite(BVS_DATA_FWD, LOW); digitalWrite(BVS_ACT_PERIOD, LOW);}

Schaltpläne