2WD spraakgestuurde robot met Arduino en BitVoicer-server

Over dit project

In deze tutorial laat ik zien hoe je een 2WD spraakgestuurde robot bouwt. Hoewel ik alleen DC-motoren bestuur om de robot te verplaatsen, kan dezelfde benadering worden gebruikt om stappenmotoren en servomotoren met stem te besturen, dus als u van plan bent een spraakgestuurde robot te bouwen die mechanische bewegingen uitvoert, kan deze tutorial dienen als referentie voor uw project.

Om deze robot te bouwen, heb je in principe één 2-wielig chassis, één Arduino-bord, één DC-motordriverschild, één BitVoicer Server-licentie, één WiFi-module en één voorversterkte microfoon nodig. Wat betreft de componenten, er is een enorme verscheidenheid op de markt en u kunt dezelfde resultaten bereiken met verschillende combinaties. In stap 1 geef ik een paar details over enkele componenten die in de robot worden gebruikt, dus als u er enkele moet wijzigen, zoek dan gewoon naar componenten met vergelijkbare functies.

De volgende procedures worden uitgevoerd om spraakopdrachten om te zetten in robotbewegingen:

• 1. Audiogolven worden opgevangen en versterkt door het Sparkfun Electret Breakout-bord;
• 2. Het versterkte signaal wordt gedigitaliseerd en gebufferd in de Arduino met behulp van de analoog-naar-digitaalomzetter (ADC);
• 3. De audiosamples worden gestreamd naar BitVoicer Server met behulp van de Microchip WiFi-module;
• 4. BitVoicer Server verwerkt de audiostream en herkent de spraak die erin zit;
• 5. De herkende spraak wordt toegewezen aan vooraf gedefinieerde opdrachten die naar de Arduino worden verzonden;
• 6. De Arduino identificeert het commando en bepaalt welke DC-motoren zullen worden gebruikt, voor hoe lang en met welke snelheid;
• 7. De motordriver wordt geactiveerd om de vereiste spanning en stroom te leveren om de motoren te laten bewegen.

Lijst met materialen:

• Arduino UNO:~U$ 25,00
• Pololu Dual MC33926 Motor Driver Shield:US 29,95
• SparkFun XBee-schild:$ 14,95
• Microchip RN171VX-module met antenne:U$ 34,95
• SparkFun Electret Microfoon Breakout:U$ 7,95
• BitVoicer Server 1.0:U$ 8,90
• 2WD robotwagenchassis:U$ 15,95
• Texas Instruments LM1117 (TO-220) Spanningsregelaar:~U$ 1,95
• 10μF elektrolytische condensator:~U$ 0,35
• 4 x LED's:~US 1,00
• 4 x 330 Ohm Weerstanden:~U$ 0,75
• 4 x 1.5V AA-batterijen:~US 2,00
• 9V batterij:~US 2,00
• 9V naar Barrel Jack Adapter:~US 2,50
• Jumperdraden en gewone draden:~U$ 2,00
• Schroeven en flexibele plastic klem voor bevestiging
• Soldeerbout en soldeer

STAP 1:De componenten leren kennen

In deze stap geef ik een aantal belangrijke informatie over de onderdelen van de robot en hoe deze voor te bereiden voor montage.

In de eerste plaats het hart van de robot:een Arduino UNO R3. Hoewel ik een Arduino UNO gebruik, kun je andere Arduino-borden gebruiken om je robot te monteren. Ik besloot een Arduino UNO te gebruiken omdat dit verreweg het populairste Arduino-bord is en meer mensen deze robot zouden kunnen herbouwen. Als je een Arduino DUE hebt, kun je ook spraakreacties aan je robot toevoegen, zoals ik in deze tutorial heb gedaan.

Om de DC-motoren te verplaatsen, heb ik dit Pololu-schild gebruikt. Het is een dubbele motordriver die 5 tot 28V DC-motoren kan besturen en tot 3A continue stroom per motor kan leveren. Hoewel ik denk dat dit een heel goed schild is, maakte de meeste indruk op mij in de producten van Pololu hun duidelijke en gedetailleerde documentatie. Bovendien biedt Pololu een Arduino-bibliotheek die het heel eenvoudig maakt om de motoren te besturen. U hoeft alleen de snelheid en richting (negatieve of positieve waarden) door te geven aan de setSpeeds functie. Als u ervoor kiest om een ​​andere DC-motordriver te gebruiken, let dan op de pinnen die door de driver worden gebruikt, omdat deze niet in conflict kunnen komen met een andere pin die door de robot wordt gebruikt. Het Pololu-schild gebruikt de volgende Arduino-pinnen:digitaal 4, 7, 8, 9, 10 en 12; analoog 0 en 1; grond; en 5V. Het belangrijkste aspect hierbij is dat alleen pinnen 9 en 10 worden gebruikt als PWM-pinnen en dat de timer die wordt gebruikt om pulsen op deze pinnen te genereren, niet dezelfde timer is (timer 2 op de UNO) die wordt gebruikt door de BVSMic-klasse van BitSophia.

Om communicatie met de server tot stand te brengen en toegang te krijgen tot BitVoicer Server-services, gebruik ik de Microchip WiFi RN171VX-module. Twee hoofdkenmerken vallen op in deze module:alle communicatie kan op een eenvoudige manier via de seriële poort worden gedaan; en de module heeft dezelfde vormfactor als de meeste populaire XBee-modules. Met andere woorden, als je al een XBee-schild hebt, hoef je waarschijnlijk niet het Sparkfun-schild te kopen dat ik in deze robot gebruik.

Het gebruik van het XBee-schild met de Microchip WiFi-module maakte het monteren van de robot vrij eenvoudig. Ik heb echter een probleem vastgesteld in deze combinatie. Het is bekend dat het werken met radio extreem complex is en door sommige mensen als "voodoopie" wordt beschouwd. Nou, ik heb gemerkt dat terwijl de wifi-adapter aan staat en gegevens verzendt, er een sterke interferentie optreedt in het audiosignaal dat wordt gemeten door de Arduino ADC. Ik heb de bron van deze interferentie niet precies kunnen identificeren, maar ik heb twee mogelijke bronnen:de piekstroom van de module (tot 240 mA) wordt niet goed ontkoppeld en compromitteert de referentiespanning die aan de Arduino ADC wordt geleverd; of het signaal dat door de antenne wordt uitgezonden, wordt opgevangen door enkele blootliggende pinnen direct onder de module. Gewoonlijk instrueren fabrikanten van wifi-modules ontwerpers om te voorkomen dat er iets (zelfs grondvlakken) in de buurt van de antenne wordt geplaatst, juist om dit soort problemen te voorkomen.

Om het hierboven beschreven probleem te verhelpen, heb ik een spanningsregelaar van 3,3 V en een elektrolytische condensator van 10 F aan het Sparkfun-schild gesoldeerd, zodat ze de referentiespanning aan de Arduino ADC konden leveren. Dezelfde stroombron wordt gebruikt door de Sparkfun electret microfoon. Het loste de piekvolumeproblemen op die ik zag in de BitVoicer Server Manager. Zelfs tijdens stilteperioden liep het audioniveau op tot 35 (0-100) in de Server Monitor. Als je hetzelfde ziet gebeuren in je project, onderzoek dan wat er aan de hand is met het audiosignaal dat wordt gemeten door de Arduino ADC.

Ik besloot dat ik ook de prototyping-ruimte in het Sparkfun-schild ging gebruiken om een ​​paar LED's te solderen die de status van sommige BitVoicer Server-functionaliteiten aangeven. In de onderstaande afbeelding wordt van links naar rechts de volgende informatie weergegeven door de LED's:

• Geeft aan of BitVoicer Server actief is en/of de verbinding actief blijft;
• Geeft aan of de gegevensdoorstuurservice actief is;
• Geeft aan of een spraakherkenningsengine is toegewezen aan de Arduino;
• Geeft aan of we ons in de activatie-woord-geactiveerd-periode bevinden. Deze LED licht alleen op wanneer het activeringswoord is geïdentificeerd.

Wat betreft de voorversterkte electret-microfoon zijn er veel opties op de markt:Sparkfun, Adafruit, RoboCore, Hackerstore en waarschijnlijk vele anderen. Om de code te gebruiken die ik in deze tutorial post, moet je ervoor zorgen dat de microfoon die je koopt analoog is, dat de vereiste spanning beschikbaar is op je Arduino-bord en dat de versterking hoog genoeg is (meestal 100x voor electret-microfoons) voor de Arduino ADC.

Het 2WD-chassis dat in de robot wordt gebruikt, is een van de goedkoopste en meest populaire op ebay. De complete set bevat een acrylplatform, twee kunststof/rubberen wielen, een 360º wiel, twee gelijkstroommotoren met versnelling (verhouding 1:48), een 4xAA batterijhouder, twee snelheidscodeerschijven en een set schroeven.

STAP 2:Montage

Laten we aan de slag gaan! In deze stap moet u alle componenten op het chassis monteren zoals weergegeven in de onderstaande afbeeldingen.

Als je de LED's en de spanningsregelaar niet op het XBee-schild wilt solderen, kun je ze op een klein breadboard monteren zoals op de onderstaande afbeelding. Kies in dit geval een kleiner breadboard, zodat je het zonder verdere problemen ergens op het chassis kunt bevestigen.

Op de foto's hierboven kun je zien dat ik een ijzerdraadsteun heb gemaakt om de microfoon vast te houden. Je kunt ook zien dat ik een strook viltstof om het 360º wiel heb geplakt. Ik heb deze twee maatregelen genomen om te proberen het geluid te verminderen dat door de robot wordt gegenereerd en door de microfoon wordt opgevangen wanneer de robot beweegt. Ik heb zelfs een klein stukje spons gesneden om de microfoondraden van de steun te isoleren. Natuurlijk was het niet 100% effectief, maar het verminderde de ruis een beetje en verbeterde de nauwkeurigheid van de spraakherkenning.

STAP 3:De WiFi-module instellen

Zoals ik in stap 1 al zei, kan de Microchip RN171VX WiFi-module volledig worden bediend via de seriële poort. Dit maakt het zeer eenvoudig om de module in te stellen, omdat alle commando's eenvoudige strings zijn die via de seriële poort van Arduino worden verzonden. U hoeft alleen maar een tekenreeks met "$$$" te verzenden om de opdrachtmodus te openen, de opdrachten te verzenden en vervolgens een tekenreeks met "exit" te verzenden om terug te keren naar de gegevensmodus.

De code genaamd WiFi Module Setup onderaan deze tutorial staat de code die ik heb gebruikt om de wifi-module in mijn thuisnetwerk in te stellen. U zult de delen van de code gemarkeerd als "XXXXXX" moeten wijzigen met informatie van uw WiFi-netwerk. Er moeten drie commando's worden gewijzigd:

• wlan ssid XXXXXX instellen :vervang de XXXXXX door uw netwerknaam (SSID);
• wlan-zin XXXXXX instellen :vervang de XXXXXX door uw netwerkwachtwoord;
• IP-adres XXXXXX instellen :vervang de XXXXXX door het IP-adres (statisch) dat u wilt instellen op uw WiFi-module.

In mijn wifi-netwerk is de authenticatiemethode WPA2-PSK. Als uw netwerk een andere authenticatiemethode gebruikt, moet u ook de wlan auth instellen wijzigen opdracht. Bekijk de documentatie van de WiFi-module (paragraaf 4.3 Opdrachten instellen) om erachter te komen welke waarde de juiste is voor uw netwerk.

Er is een belangrijke detail over het Sparkfun-schild en zijn kleine schakelaar (foto hieronder). Om code naar de Arduino te uploaden met behulp van de USB-interface, moet de schakelaar in de DLINE-positie worden gezet. Om ervoor te zorgen dat de Arduino gegevens kan verzenden/ontvangen via de WiFi-module met behulp van de seriële poort, moet de schakelaar in de UART-positie staan. Dit is nodig omdat de WiFi-module en de USB-chip op de Arduino UNO dezelfde seriële poort gebruiken in de ATmega-microcontroller. Als de schakelaar is ingesteld op UART en u probeert code naar de Arduino te uploaden, wordt er een foutmelding weergegeven in de Arduino IDE.

De WiFi-module-installatie  uploaden code naar de Arduino en laat de Arduino de WiFi-module instellen, volg de onderstaande stappen:

• 1. Zet de schakelaar in de DLINE-positie;
• 2. Open de Arduino IDE, plak en upload de code naar de Arduino;
• 3. Zodra de upload is voltooid, heeft u 5 seconden (vertraging aan het begin van de code) om de schakelaar in de UART-positie te zetten voordat opdrachten naar de WiFi-module worden verzonden. Als het eerste commando verloren gaat, zal geen van de andere werken. In dit geval reset je gewoon de Arduino zodat de schets weer vanaf het begin kan worden uitgevoerd.

Tijdens de moduleconfiguratie, die ongeveer 25 seconden duurt, zullen de module-LED's anders knipperen dan het standaardpatroon. Op dit moment weet u dat de WiFi-module wordt geconfigureerd.

Nadat de module is geconfigureerd, probeert u de module te pingen (opdrachtprompt --> "ping [IP-adres]" --> druk op Enter) met het IP-adres dat is opgegeven in het IP-adres instellen opdracht. Als je geen reactie krijgt van de module, is er iets misgegaan in de vorige stappen.

STAP 4:De robotbewegingen plannen

Hoewel de robot slechts twee gelijkstroommotoren heeft, is hij in staat een reeks complexe bewegingen uit te voeren. Om deze tutorial zo eenvoudig mogelijk te houden, heb ik ervoor gekozen om slechts ongeveer drie dozijn uniforme basisbewegingen te definiëren en een paar complexe bewegingen gevormd door de combinatie van de basisbewegingen.

Zoals je kunt zien op de afbeeldingen in stap 2, gebruik ik geen rotatiesensoren in de wielen, ultrasone sensoren of een ander type sensor om de afstand tot objecten of de afgelegde afstand te meten. Dit voorkomt dat de robot bewegingen met hoge precisie uitvoert. Als u echter alleen de richting en de snelheid van de motoren regelt, kunt u een precisieniveau bereiken dat goed genoeg is om de robot te verplaatsen.

Het eerste dat u moet weten om de benodigde uitvoeringstijd voor elke beweging te kunnen berekenen, is de gemiddelde snelheid van de robot. Leg hiervoor een meetlint evenwijdig aan de robot en activeer beide motoren tegelijk gedurende één of twee seconden, meet de afgelegde afstand en leid de snelheid af. In mijn configuratie haalde ik 13,7 centimeter per seconde met 62,5% van de maximale motorsnelheid (250/400, zie Pololu Arduino-bibliotheek). Met andere woorden, om de robot 1 meter (100 cm) vooruit te bewegen, moesten de motoren 7,299270… seconden gelijktijdig worden geactiveerd. Ik heb ervoor gekozen om de tijd in milliseconden resolutie te laten tellen, maar als je een hogere bewegingsprecisie wilt bereiken, overweeg dan om de resolutie te verhogen naar microseconden. Om een ​​lang verhaal kort te maken, om de robot 1 meter te verplaatsen, moet ik beide motoren 7299 milliseconden tegelijk activeren. Vanaf dit aantal wordt alles regel van drie voor andere afstanden. Om boog- of cirkelvormige bewegingen uit te voeren, moet het ene wiel sneller bewegen dan het andere. Om de robot naar de zijkant te draaien, hoeft slechts één wiel te worden geactiveerd of beide in tegengestelde richting (om om zijn eigen as te draaien). Hier zul je wat trigonometrie moeten gebruiken om de afstand te berekenen die door elk wiel is afgelegd en hoe lang elke motor moet worden geactiveerd. Een goed startpunt voor deze concepten is te vinden in de volgende links (ik ben niet van plan hier hier verder op in te gaan):http://rossum.sourceforge.net/papers/CalculationsForRobotics/CirclePath.htm en http://math .stackexchange.com/questions/60176/move-two-wheeled-robot-from-one-point-to-other.

Zoals je aan het einde van de onderstaande video kunt zien, laat ik de robot ook enkele geometrische basisvormen (vierkant, driehoek en cirkel) op de vloer "tekenen". Deze bewegingen worden bereikt door de combinatie van basisbewegingen (bijvoorbeeld vooruit gaan, draaien, vooruit gaan, draaien, etc.). De combinatie van deze bewegingen wordt gemaakt in het BitVoicer Server Voice Schema en je zult ze niet zien in de Arduino-schets die in de volgende stap wordt gepresenteerd.

STAP 5:De code uploaden naar de Arduino

In deze stap moet je de schets met de naam Robotbroncode uploaden , onder aan deze tutorial, naar de Arduino. Je kunt de Arduino-schets ook downloaden via de onderstaande link. Onthoud dat om code naar de Arduino te verzenden, je de schakelaar op het Sparkfun-schild in de DLINE-positie moet zetten zoals beschreven in stap 3. Voordat je de code uploadt, moet je de BitVoicer Server en de Pololu-motorstuurprogrammabibliotheken correct installeren in de Arduino IDE (Een .zip-bibliotheek importeren).

Robotbroncode :BVS_Demo3.ino

Sommige delen van deze schets zijn vergelijkbaar met delen die ik in een van mijn vorige tutorials heb gebruikt en gaan over de communicatie met BitVoicer Server (BVSP- en BVSMic-klassen). In deze tutorial zal ik me houden aan de uitleg van de nieuwe delen van de schets. Als je meer informatie wilt over het gebruik van de BVSP en de BVSMic-klassen, raad ik je aan de tutorial te raadplegen die ik hierboven heb genoemd.

• Constantenverklaring :aan het begin van de schets verklaar ik een reeks constanten die in de code worden gebruikt. De groep constanten met motorinstellingen definieert de standaard motorsnelheden en twee richtingsconstanten. De motordriverbibliotheek van Pololu accepteert waarden van -400 tot +400 voor de motorsnelheid waarbij nul uit betekent. Negatieve waarden duiden op omgekeerde rotatie of, als je de motordraden hebt omgekeerd, zoals ik, voorwaartse rotatie. De groep constanten met opdrachtwaarden verwijst naar de opdrachten die vanaf BitVoicer Server worden verzonden. In deze schets heb ik slechts 40 basiscommando's van byte . gedefinieerd type, maar complexere bewegingen kunnen worden uitgevoerd door deze commando's te combineren.
• Uitvoeringscontrolevariabelen :aan het begin van de code zijn vijf variabelen gedefinieerd om de uitvoering van opdrachten te regelen (motorSpeed , cmdDuration , cmdStartTime , cmdRunning e lastFwdCmd ). De motorSnelheid variabele houdt de huidige motorsnelheid vast. Deze variabele wordt bijgewerkt met een van de standaardwaarden gedefinieerd door de snelheidsconstanten als de Arduino een commando ontvangt van BitVoicer Server om de motorsnelheden bij te werken. De cmdDuration variabele bevat de totale duur van het huidige commando. Deze variabele wordt vergeleken met de cmdStartTime variabele in alle iteraties van de lus functie als cmdRunning is waar . Als de uitvoeringstijd van de opdracht is verstreken, wordt de RunCommand functie wordt aangeroepen om de motoren te stoppen. De lastFwdCmd variabele bevat het laatste "go/move forward"-commando. Deze variabele wordt gebruikt om de laatst afgelegde afstand te kennen, zodat het commando "kom terug" kan worden uitgevoerd. Merk op dat om dit commando te gebruiken, je eerst de robot moet vertellen dat hij zich moet omdraaien.
• WiFi-verbinding :aan het einde van de schets definieer ik twee functies om verbinding te maken en los te koppelen van BitVoicer Server (Verbinden en Verbinding verbreken ). Deze functies zetten de Microchip WiFi-module in de commandomodus, openen of sluiten een TCP/IP-verbinding en zetten de module terug in de datamodus. Binnen de lus functie, als de verbonden variabele niet waar is , ik bel de Connect functie. Als de BVSP-klasse meldt dat de serverstatus is verlopen, met andere woorden, er is geen antwoord ontvangen op het laatste statusverzoek, neem ik aan dat de verbinding is verbroken en bel ik de Verbreken functie. Dit dwingt een nieuwe verbindingspoging af in de volgende lus-iteratie.
• RunCommand functie :deze functie wordt aangeroepen telkens wanneer een opdracht wordt ontvangen van BitVoicer Server. Het duurt een byte waarde die overeenkomt met een van de basiscommando's gedefinieerd door de constanten aan het begin van de schets. Elk basiscommando wordt in de schakelaar geïdentificeerd, zodat de juiste motorsnelheden en de duur van het commando kunnen worden ingesteld. Aan het einde van de functie, de cmdRunning variabele is ingesteld op true en de tijd teruggegeven door de millis functie is opgeslagen in de cmdStartTime variabel. Hierdoor kan de Arduino de uitvoering van de opdracht besturen zoals hierboven beschreven. De tijden, in milliseconden, voor elk commando werden verkregen zoals beschreven in de vorige stap.

STAP 6:BitVoicer-server instellen

In deze stap moet je het BitVoicer Server Voice Schema bouwen met de te herkennen zinnen en de commando's die naar de Arduino worden gestuurd. Aan het einde van deze stap zijn er twee koppelingen naar bestanden die alle BitVoicer Server-oplossingsobjecten bevatten die in deze zelfstudie worden gebruikt. Als u niet alle oplossingsobjecten één voor één wilt maken, kunt u ze importeren (Importing Solution Objects) met behulp van deze bestanden.

Voordat u begint met het bouwen van het spraakschema, moet u een apparaat maken dat de Arduino in BitVoicer Server vertegenwoordigt. Maak een gemengd apparaat en noem het ArduinoUnoWiFi. Selecteer op het tabblad Communicatie TCP/IP en voer het IP-adres in dat is toegewezen aan de WiFi-module in stap 3. Schakel in het tabblad Cues de Begin van geactiveerde periode in. en Einde van geactiveerde periode signalen. Selecteer Int16 SendData-commando's voor beide cues en selecteer het ArduinoUnoWiFi-apparaat als het doel van de commando's. Voer in het veld Gegevens 1 in voor Begin van geactiveerde periode cue en 0 voor het Einde van geactiveerde periode keu. Deze signalen zorgen ervoor dat de Arduino één LED aanzet telkens wanneer het activeringswoord wordt herkend. Wanneer de geactiveerde periode (gedefinieerd in het Spraakschema) verloopt, gaat deze LED uit.

Laten we nu het spraakschema maken. Hoewel de robot slechts 40 basiscommando's heeft, wil je misschien veel woordcombinaties maken die hetzelfde commando activeren. U wilt bijvoorbeeld dat de zinnen "een meter vooruit" en "een meter vooruit" hetzelfde commando activeren. Bovendien wil je misschien complexe commando's maken als "doe een vierkant" die een reeks getemporiseerde commando's achter elkaar zullen activeren. Daardoor kan je Stemschema flink groeien en heeft het veel meer dan 40 basiscommando's. BitVoicer Server ondersteunt onbeperkte zinnen, dus je kunt zoveel zinnen definiëren als je nodig hebt (de mijne eindigde met meer dan 80 zinnen). Hier zou ik twee tips willen geven:maak een standaardopdracht in de BitVoicer Server Manager-opties; en kopieer en plak dubbele opdrachten van de ene zin naar de andere.

Zincommando's sturen byte gegevenstypen naar de Arduino. Gebruik de constanten die aan het begin van de schets zijn gedefinieerd om te weten welke waarde voor elk commando moet worden verzonden. Complexe commando's zullen veel waarden in volgorde verzenden en u zult het interval (vertraging) ertussen moeten regelen, zodat er geen waarde wordt verzonden terwijl het vorige commando wordt uitgevoerd. Gebruik het vertragingsveld om het interval tussen opdrachten in te stellen.

Bestanden met oplossingsobjecten :

Apparaat.sof

VoiceSchema.sof

STAP 7:Conclusie

Nu hoef je alleen nog maar de AA-batterijen te plaatsen en de 9V-batterij aan te sluiten op de Arduino-voedingsaansluiting zodat je robot tot leven komt! Nadat je de code naar de Arduino hebt geüpload, vergeet dan niet om de schakelaar op het Sparkfun-schild naar de UART-positie te draaien. Anders ontvangt de WiFi-module geen gegevens die zijn verzonden vanaf de seriële poort van Arduino.

Nadat u de robot hebt ingeschakeld, duurt het even voordat de status-LED's gaan branden. U zult zien dat de WiFi-module de communicatie start en wanneer de TCP/IP-verbinding tot stand is gebracht, gaat een van de module-LED's ononderbroken branden. Na enkele ogenblikken gaan ook drie van de vier status-LED's branden. Dit betekent dat er één spraakherkenningsengine is toegewezen aan de Arduino. Vanaf nu is de robot klaar om commando's op te nemen.

Na wat testen met de robot was ik redelijk tevreden met de spraakherkenning, hoewel hij niet altijd 100% van de commando's herkende. In dit opzicht heeft BitVoicer Server me echt verrast. Ik was echter niet zo tevreden over de precisie van de bewegingen van de robot. Om dit probleem op te lossen, zou ik rotatiesensoren aan de wielen moeten toevoegen. De chassiskit die ik in de robot heb gebruikt, wordt al geleverd met decoderschijven die aan de versnelling kunnen worden bevestigd. Door sensoren op deze schijven aan te brengen, zou ik de robot kunnen verplaatsen op basis van de werkelijk afgelegde afstand, zodat zijn beweging nauwkeuriger zou zijn. Ik zou ook ultrasone sensoren kunnen toevoegen om te voorkomen dat ik rond mijn meubels stoot. Ik zal dat waarschijnlijk ooit doen, maar voor nu laat ik dat aan jou over.

Tot de volgende keer!

Code

• WiFi-module instellen
• Robotbroncode

Installatie wifi-moduleArduino

Configureert de Microchip WiFi RN171VX-module met behulp van de Arduino seriële poort.

void setup() { Serial.begin(115200); pinMode(13, UITGANG); vertraging (5000); Serial.print("$$$"); vertraging (1000); Serial.println("wlan auth 4 instellen"); vertraging (1000); Serial.println ("stel wlan-zin XXXXXX in"); vertraging (1000); Serial.println("wlan ssid XXXXXX instellen"); vertraging (1000); Serial.println ("stel wlan-kanaal 0 in"); vertraging (1000); Serial.println("stel wlan join 1 in"); vertraging (1000); Serial.println ("stel wlan tx 0 in"); vertraging (1000); Serial.println ("set ip dhcp 0"); vertraging (1000); Serial.println ("set ip-adres XXXXXX"); vertraging (1000); Serial.println ("stel comm remote 0 in"); vertraging (1000); Serial.println("zet comm close 0"); vertraging (1000); Serial.println ("zet comm open 0"); vertraging (1000); Serial.println ("stel comm-grootte 500 in"); vertraging (1000); Serial.println ("stel comm-tijd 50 in"); vertraging (1000); Serial.println ("set uart baud 115200"); vertraging (1000); Serial.println ("stel uart-stroom 0 in"); vertraging (1000); Serial.println("opslaan"); vertraging (1000); Serial.println("exit"); vertraging (1000); digitalWrite(13, LOW);}void loop() { }

RobotbroncodeArduino

Bestuurt de robotbewegingen, legt audio vast, beheert de TCP/IP-verbinding en communiceert met BitVoicer Server.

#include #include #include // Definieert de Arduino-pinnen die zal worden gebruikt om// LED's te besturen en audio vast te leggen#define BVS_RUNNING 2#define BVS_SRE 5#define BVS_DATA_FWD 3#define BVS_ACT_PERIOD 6#define BVSM_AUDIO_INPUT 3// Definieert de constanten die als parameters worden doorgegeven aan // de 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()); pauze; case DATA_TYPE_INT16:digitalWrite(BVS_ACT_PERIOD, bvsp.getReceivedInt16()); pauze; }}// Runs the command received from the servervoid RunCommand(byte cmd){ switch (cmd) { case CMD_STOP:ms.setSpeeds(SPEED_STOP, SPEED_STOP); cmdRunning =false; opbrengst; case CMD_MOVE_FORWARD:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =60000; pauze; case CMD_MOVE_FORWARD_1_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =23; pauze; case CMD_MOVE_FORWARD_2_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =47; pauze; case CMD_MOVE_FORWARD_5_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =117; pauze; case CMD_MOVE_FORWARD_10_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =234; pauze; case CMD_MOVE_FORWARD_25_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =468; pauze; case CMD_MOVE_FORWARD_50_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =1170; pauze; case CMD_MOVE_FORWARD_1_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =2339; pauze; case CMD_MOVE_FORWARD_2_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =4678; pauze; case CMD_MOVE_FORWARD_3_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =7018; pauze; case CMD_MOVE_BACKWARD:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =60000; pauze; case CMD_MOVE_BACKWARD_1_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =23; pauze; case CMD_MOVE_BACKWARD_2_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =47; pauze; case CMD_MOVE_BACKWARD_5_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =117; pauze; case CMD_MOVE_BACKWARD_10_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =234; pauze; case CMD_MOVE_BACKWARD_25_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =468; pauze; case CMD_MOVE_BACKWARD_50_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =1170; pauze; case CMD_MOVE_BACKWARD_1_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =2339; pauze; case CMD_MOVE_BACKWARD_2_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =4678; pauze; case CMD_MOVE_BACKWARD_3_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =7017; pauze; case CMD_TURN_AROUND:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =540; pauze; case CMD_TURN_AROUND_RIGHT:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =540; pauze; case CMD_TURN_AROUND_LEFT:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_FRONT); cmdDuration =540; pauze; case CMD_DO_360:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =1065; pauze; case CMD_TURN_RIGHT:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =503; pauze; case CMD_TURN_RIGHT_10:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =56; pauze; case CMD_TURN_RIGHT_25:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =140; pauze; case CMD_TURN_RIGHT_45:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =252; pauze; case CMD_TURN_LEFT:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =503; pauze; case CMD_TURN_LEFT_10:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =56; pauze; case CMD_TURN_LEFT_25:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =140; pauze; case CMD_TURN_LEFT_45:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =252; pauze; case CMD_DO_CIRCLE:ms.setSpeeds( SPEED_NORMAL * DIRECTION_FRONT, SPEED_NORMAL * DIRECTION_FRONT * 0.60); cmdDuration =4587; pauze; case CMD_COME_BACK:RunCommand(lastFwdCmd); opbrengst; case CMD_SET_SPEED_SLOW:motorSpeed =SPEED_SLOW; opbrengst; case CMD_SET_SPEED_NORMAL:motorSpeed =SPEED_NORMAL; opbrengst; case CMD_SET_SPEED_FAST:motorSpeed =SPEED_FAST; opbrengst; case CMD_TURN_LEFT_45_BACKWARD:ms.setSpeeds(motorSpeed * DIRECTION_BACK, 0); cmdDuration =252; pauze; case CMD_TURN_RIGHT_45_BACKWARD:ms.setSpeeds(0, motorSpeed * DIRECTION_BACK); cmdDuration =252; pauze; } // 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("$$$"); vertraging (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"); vertraging (1000); serialPort.println("exit"); delay(500);}// Closes the TCP/IP connection with the BitVoicer Servervoid Disconnect(HardwareSerial &serialPort){ serialPort.print("$$$"); vertraging (500); serialPort.println("close"); vertraging (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);}

Schema's