Met Arduino is het heel eenvoudig om verschillende machines te maken afstandsbediening, eenvoudige sensoren en logica. Daarom is deze lijn ontzettend populair. Er zijn veel compatibele sensoren en uitbreidingskaarten verkocht. Het internet staat vol met kant-en-klare softwarebibliotheken en open source-projecten voor alle gelegenheden. Bijna alle vragen die je zult hebben tijdens het beheersen van Arduino zijn al door iemand gesteld en je zult altijd het antwoord vinden.
Laten we ergens beginnen? De belangrijkste vraag is de keuze van de controller. Er zijn veel herzieningen van Arduino, evenals klonen van derden die bovenop deze versies zijn gebouwd. Dit zijn misschien wel de twee meest interessante klassen voor ons:
- Arduino Uno is de beste keuze voor een beginner, het eenvoudigste, meest budgettaire en gebruikelijke bord. Het is gebaseerd op een ATmega328-chip met klok frequentie op 16 MHz, 32 KB flashgeheugen, 2 KB RAM en 1 KB EEPROM. De Uno heeft 14 digitale in-/uitgangen die kunnen worden gebruikt om sensoren, servo's en andere apparaten aan te sturen;
- Arduino Mega / Mega 2560 is een bord dat geschikt is als je van tevoren weet dat het project complex zal zijn. Het belangrijkste verschil is het grotere aantal in-/uitgangen (48 in Mega, 54 in Mega 2560). Er is ook veel meer geheugen: 8 KB RAM, 4 KB EEPROM en flashgeheugen 128 en 256 KB (respectievelijk in Mega en Mega 2560). Ook in de chip verschillen de borden van elkaar USB-snelheid en nog enkele andere kenmerken.
Natuurlijk is er ook Arduino Pro, Arduino LilyPad en vele anderen. Maar laten we ons nu concentreren op de eerste twee modellen. In ons geval is alles vrij eenvoudig: Mega is nodig voor een robot met veel benen.
Eerste code
Laten we eerst installeren Arduino-IDE(arduino.cc) is een platformonafhankelijk vrije omgeving ontwikkeling. Als we nu onze Arduino aansluiten, kunnen we proberen de eerste code te schrijven met het eenvoudigste voorbeeld: een LED-knipperprogramma. De meeste Arduino-controllers hebben het en zijn aangesloten op pin 13. Overigens ter wereld Arduino-programma's meestal schetsen genoemd. Hier is de tekst van de schets met commentaar:
// Laten we deze pin de naam LED geven: const int LED = 13; void setup() ( // Initialiseer de digitale pin // voor uitvoer: pinMode(LED, OUTPUT); ) void loop() ( // Pas een logisch één niveau toe // op pin 13 (steek de LED op): digitalWrite(LED , HIGH); // Pauzeer de uitvoering van de schets // een seconde: delay(1000); // Pas een logisch nulniveau toe // op pin 13 (schakel de LED uit): digitalWrite(LED, LOW); / Pauzeer de uitvoering van de schets // voor een seconde: delay(1000);
Let op instelfuncties en lus. Ze moeten aanwezig zijn in elke Arduino-schets. Setup wordt één keer opgeroepen bij het opstarten of nadat de controller opnieuw is opgestart. Als u wilt dat de code slechts één keer wordt uitgevoerd, moet u deze hier plaatsen. Meestal zijn dit allerlei procedures om iets te initialiseren. Onze schets is daarop geen uitzondering: Arduino digitale pinnen kunnen zowel als input als output werken. In de setup-functie zeggen we dat pin 13 zal fungeren als de digitale uitgang van de controller.
Nadat de setup-functie zijn werk heeft voltooid, wordt automatisch een gesloten lus gestart, waarbinnen de lusfunctie wordt aangeroepen. We moeten daar opschrijven wat we willen doen. En we willen een logisch niveau van één (5 V) toepassen op pin 13, dat wil zeggen: de LED laten branden, dan een seconde wachten (1000 in milliseconden), dan een logisch nulniveau (0 V) toepassen en opnieuw een seconde wachten. De volgende call-to-loop herhaalt alles.
Nu uploaden we onze schets naar de controller. Nee, we hebben geen programmeur nodig. Arduino-controllers bevatten, naast onze schetsen, een speciaal programma - bootloader, dat met name het laden van code vanaf de computer regelt. Om de schets te uploaden hebben we dus alleen een USB-kabel en het menu-item Bestand → Uploaden (Ctrl + U) in de Arduino IDE nodig.
Sleutelvraag
Hoeveel poten hebben we eigenlijk nodig? Laten we veel configuraties van lopende robots definiëren. Op aantal poten:
- tweevoetig - tweevoetig (prototype - mens);
- viervoeter - vierpotig (prototype - de meeste zoogdieren);
- hexapod - zespotig (prototype - de meeste insecten);
- octopus - achtpotig (prototype - spinnen, schorpioenen, krabben en andere geleedpotigen).
Naast het aantal poten is ook de configuratie van elke poten belangrijk. Het belangrijkste kenmerk van het been is het aantal vrijheidsgraden of vrijheidsdimensies (DOF). De mate van vrijheid is het vermogen om rond één as te draaien of te buigen (minder vaak om erlangs vooruit te bewegen). Het is duidelijk dat als er maar één vrijheidsgraad is, je met zo’n been niet ver komt. Met twee vrijheidsgraden (2DOF) kunnen meerpotige robots al bewegen, hoewel 2DOF alleen de punt van het been vrij in één vlak laat bewegen. En een 3DOF-been beweegt de ‘voet’ in de 3D-ruimte (tenzij natuurlijk alle drie de assen evenwijdig zijn). Er zijn ook 4DOF-poten, die eenvoudigweg de flexibiliteit en het bewegingsbereik van het been vergroten. Insecten hebben meestal 4DOF-poten.
Wat betekent dit voor ons? Bij goedkope amateurrobots wordt elke vrijheidsgraad gerealiseerd door één motor, preciezer gezegd: een servoaandrijving of serv. De configuratie van de poten bepaalt op unieke wijze hoeveel van deze servo's er nodig zijn. Een 3DOF-hexapod heeft dus 18 servo's nodig, en een 4DOF-spin heeft er 32 nodig. Wees niet bang voor de hoeveelheid, de kleine servo's die in amateur-RC-modellen worden gebruikt, zijn erg goedkoop. Je kunt ze in online winkels vinden door te zoeken naar microservo.
Om servo's te programmeren is het voldoende om te weten dat ze al een controller hebben die het hoofdwerk doet. En het enige dat u nodig hebt, is stroom leveren en digitaal signaal, waarbij we de controller vertellen naar welke positie we de aandrijfas willen draaien. Informatie over hun ontwerp is gemakkelijk te vinden. Hun protocol is het eenvoudigste van alle digitale communicatieprotocollen: pulsbreedtemodulatie - PWM (PWM in het Engels). Alle eenvoudige servo's hebben een connector met drie pinnen: aarde, +5 V (spanning kan variëren afhankelijk van grootte en vermogen) en signaalingang. Arduino-controllers kunnen er twee hebben op verschillende manieren een dergelijk signaal genereren. De eerste is hardware-PWM, die de chip zelf kan uitvoeren op verschillende digitale I/O-pinnen. De tweede is software. Met software kunt u tegelijkertijd meer verschillende PWM-signalen ontvangen dan met hardware. Er wordt een handige verpakking voor onder Arduino meegeleverd: de Servo-bibliotheek. Hiermee kunt u 12 servo's tegelijkertijd gebruiken op de meeste kleine controllers (Uno, Due, Nano) en 48 servo's op Arduino Mega en dergelijke. De servosignaalpin is verbonden met de digitale pin van Arduino. Grond en macht - uiteraard grond en macht, deze kunnen voor alle diensten hetzelfde zijn. In driedraads servolussen is zwart of bruin aarde, in het midden is meestal rood +5 V en ten slotte is wit of geel signaal. Softwarematig gezien is de bediening uiterst eenvoudig:
Servo mijnservo; // Servo op pin 9 van Arduino myservo.attach(9); // Draai naar 90º positie myservo.write(90);
De meeste servo's kunnen de as 180° draaien, en voor hen is 90° de gemiddelde positie. Om de aansluiting van servo's op het Arduino-bord te vereenvoudigen, zijn er een aantal oplossingen. De meest canonieke is Sensors Shield. Door het op de Uno te installeren en de klemmen voor de servo's van stroom te voorzien, kunt u hun connectoren er rechtstreeks op aansluiten.
Batterij
Een ander belangrijk onderwerp is voeding. Als je een geavanceerd bord hebt waarmee je het hele systeem via één stroomlijn kunt voeden (en de servomotoren de werking van de controller niet verstoren), dan kun je met één bron rondkomen. De keuze is enorm, de beste zijn natuurlijk Li-Ion/Li-Po-briketten voor radiomodellen. Maar ze hebben ook passend nodig opladers. Als je een eenvoudigere controller hebt (Uno/Due/Nano), dan kun je deze afzonderlijk van stroom voorzien, bijvoorbeeld met een 9 volt “Krona”, en de servo’s op de hoofdcontroller aansluiten krachtige batterij. Op deze manier zullen de servo's zeker voldoende kracht hebben. In het geval dat lithiumbatterijen u moet de spanning nog zorgvuldiger dan normaal controleren, zodat er geen sprake is van overontlading ( toelaatbare spanningen Het is de moeite waard om te controleren op het specifieke type batterij). Voor dit doel is aan de Sleipnir-robot, die verder zal worden besproken, ook een kleine digitale voltmeter bevestigd.
Doe-het-zelf robotkever
Kit
- Arduino Uno-controller: 1150 wrijven.
- Drie servomotoren. Ik gebruikte HXT500, 200 wrijven. per stuk
- Batterijcompartiment voor Krona met schakelaar: 50 wrijven.
- Batterij "Krona": 145 wrijven.
- IR-ontvanger: 90 wrijven.
- Staaldraad met een diameter van circa 1,5 mm. Ik gebruikte bijvoorbeeld een gebroken garde om eieren te kloppen
Totaal: 2035 wrijven.
DmitryDzz: Ik wil je uitnodigen om een kleine, op afstand bestuurbare zespotige robotbug te maken, gebaseerd op de Arduino Uno-controller. De poten hebben één vrijheidsgraad en de bediening vindt plaats met behulp van een gewone tv-afstandsbediening.
Ik moet zeggen dat dit de prijzen zijn van dure winkels in Moskou. In Chinese online winkels kost dit allemaal de helft minder. Levering tellen. Het is waar dat je, naar mijn ervaring, twee weken tot drie maanden moet wachten.
Een eenvoudigere manier is om een constructorset te nemen, omdat in de eerste stappen één controller niet voldoende zal zijn. Nu bieden veel winkels dergelijke sets aan. Er is bijvoorbeeld een prachtige online winkel "Amperka". Hier krijg je verschillende vergelijkbare bouwsets aangeboden, verschillend qua inhoud en uiteraard prijs. Het eenvoudigste was genoeg voor mij - "Matryoshka X". Het bevat een Arduino Uno-controller, een USB-kabel voor aansluiting op een computer en een prototypebord ( onvervangbaar ding!), een set jumpers, LED's, weerstanden en andere kleine dingen.
In dezelfde winkel is er een "Wiki" -sectie, waar je zelfs prachtige korte video-tutorials kunt vinden die in het Russisch zijn vertaald. Bekijk ze zeker eens. En natuurlijk is er een forum waar ze je waarschijnlijk zullen proberen te helpen.
Welke hulpmiddelen heb je nodig:
- soldeerbout en alles wat je nodig hebt om te solderen. Je hoeft niet veel te solderen en je hebt geen speciale vaardigheden nodig;
- heet lijmpistool en staven daarvoor;
- tang voor het werken met draad.
Als je alles hebt verzameld, gaan we aan de slag!
Controle
Laten we verder gaan met de eerste stap: we moeten leren omgaan met de afstandsbediening en de codes ontdekken voor het indrukken van enkele knoppen. Deze codes zullen later nuttig zijn voor de schets van de robotbesturing.
In dit stadium heb je ook een IR-ontvanger nodig en het zou leuk zijn om een prototypebord te hebben. De overgrote meerderheid van IR-afstandsbedieningen werkt op draaggolffrequenties van 36 kHz, 38 kHz of 40 kHz (Panasonic, Sony). De uitzonderingen zijn afstandsbedieningen van Sharp (56 kHz), Bang & Olufsen (455 kHz) en misschien iemand die nog exotischer is. Daarom zijn we vrij Iedereen zal het doen IR-ontvanger op 36, 38 of 40 kHz. De frequentie komt mogelijk niet exact overeen met de draaggolffrequentie van het signaal. In dit geval zal de gevoeligheid van de ontvanger afnemen, maar in de praktijk heb ik geen enkel ongemak ondervonden bij het gebruik van de TSOP2136 IR-ontvanger (36 kHz - de laatste twee cijfers zijn de frequentie) en de Sony-afstandsbediening (40 kHz).
IR-ontvangers TSOP21xx, TSOP22xx, TSOP312xx zijn dus geschikt voor de meeste afstandsbedieningen. De laatste twee cijfers kunnen 36, 37, 38 of 40 zijn. Voordat u de IR-ontvanger inschakelt, controleert u de bedrading van de contacten - er zijn er maar drie: +5V (stroom), GND (aarde), Vs (uitgang). Laten we het circuit samenstellen zoals in de afbeelding (bedrading voor TSOP2136).
Zoals je ziet hebben we de uitgang van de IR-ontvanger aangesloten op de analoge ingang van controller A0.
Zo ziet de schetscode eruit:
#include "IRremote.h" // Analoog controller-ingang, // waarop de IR-ontvanger is aangesloten: const int IR_PIN = A0; // Maak een IR-ontvangerobject: IRrecv irrecv(IR_PIN); void setup() ( Serial.begin(9600); Serial.println("ready"); // Begin met luisteren naar IR-signalen: irrecv.enableIRIn(); ) void loop() ( // Beschrijf de resultatenstructuur, / / waarin // ontvangen en gedecodeerd // IR-opdrachten worden geplaatst: decode_results results; // Als het IR-commando wordt ontvangen en // succesvol is gedecodeerd, // voer dan de ontvangen code uit naar de seriële // poort van de controller: if (irrecv.decode (&results)) ( Serial.println(resultaten.waarde); irrecv.resume(); ) )
De schets maakt gebruik van een speciale bibliotheek IRremote.h, die signalen van verschillende IR-afstandsbedieningen decodeert. Deze bibliotheek is geopend project, je kunt het downloaden van de pagina https://github.com/shirriff/Arduino-IRremote. En om het aan ons project te koppelen, moeten we drie stappen uitvoeren:
- kopieer de bibliotheekmap naar de bibliotheekmap, die zich op zijn beurt in de Arduino IDE-installatiemap bevindt;
- herstart IDE;
- voeg de regel #include “IRremote.h” toe aan het begin van onze schets.
Nu zijn er in de schets IR-signaaldecoderingsfuncties beschikbaar. Maar om de ontvangen codes te zien, zullen we ook het object Serieel gebruiken. Met zijn hulp, seriële poort(dezelfde USB-kabel) zullen we de codes naar de computer overbrengen. In de setup-functie initialiseren we het Serial-object. "9600" is 9600 baud - de snelheid die wordt gebruikt voor gegevensoverdracht. Na initialisatie kunnen we naar de seriële poort schrijven met behulp van de println-functie. Om het resultaat van deze uitvoer op uw computer in de Arduino IDE te bekijken, selecteert u het menu-item Extra → Seriële monitor (Ctrl + Shift + M). Zorg ervoor dat deze is ingesteld op 9600 baud.
De controller krijgt dus stroom via een USB-kabel en verzendt er gegevens via. Laad de schets, start Serial Monitor en druk op de knoppen van de afstandsbediening. Codes moeten verschijnen in het venster Seriële monitor. De afstandsbedieningsprotocollen verschillen, soms kan het één code zijn, soms meerdere. Je kunt in ieder geval altijd codes selecteren die uniek zijn voor elke afstandsbedieningsknop.
We hebben 13 knoppen op de afstandsbediening nodig. Ik heb het volgende gebruikt:
- 1 - soepele draai naar links;
- 2 - voorwaartse beweging;
- 3 - soepele draai naar rechts;
- 4 - sla ter plekke linksaf;
- 5 - stop;
- 6 - sla ter plekke rechtsaf;
- 7 - achteruit bewegen met een bocht naar rechts;
- 8 - achterwaartse beweging;
- 9 - achteruit bewegen met een bocht naar links;
- blauwe knop - erg langzaam;
- geel - langzaam;
- groen - snel;
- rood - zeer snel.
Schrijf de codes van deze knoppen op. Deze heb je later nodig voor de robotbesturingsschets.
Bewegingsalgoritme
De robotbesturingsschets is beschikbaar op onze projectpagina (bit.ly/1dEwNDC). Vergeet niet de waarden van de constanten voor de codes van de ingedrukte knoppen op de afstandsbediening te veranderen naar de codes van je afstandsbediening (de constanten IR_COMMAND_XXX_CODES in het bestand ir_command_codes.h).
We zullen de schets niet in detail bekijken; ik denk dat de opmerkingen in de code voldoende zijn, maar één vraag is nog steeds het overwegen waard.
De bewegingen van insecten zijn erg interessant. En hoewel al deze kevers bijna op de grond vallen, zijn ze om de een of andere reden altijd stabiel: op elk moment staan er minstens drie poten (twee aan de ene kant en één aan de andere kant) op het oppervlak. En terwijl deze poten de kever naar één doel trekken, worden de andere drie omhoog getrokken om deze beweging te herhalen. Onze taak is om iets soortgelijks te doen.
Onze robotbug heeft drie servomotoren die in een rij loodrecht op de beweging zijn geplaatst. Bij de linker en rechter servomotoren is de as naar boven gericht, bij de centrale servomotor naar voren. De taak van de linkerservo is bijvoorbeeld om twee benen tegelijk te pompen: linksvoor en linksachter. Ze zijn overigens vast met elkaar verbonden en vastgelijmd aan de rocker van deze servo. De taak van de centrale servo is om de linkerkant van de kever of de rechterkant op te tillen. Daarom zijn de centrale linker- en rechterpoten, die één U-vormig onderdeel vormen, aan de tuimelaar van deze motor bevestigd.
De schets moet ervoor zorgen dat de robot vooruit en achteruit beweegt, soepele bochten maakt en op zijn plaats draait. Ik zou ook graag de snelheid van de kever willen regelen. Om deze bewegingen programmatisch te beschrijven, hebben we wiskunde nodig. Kijk naar het diagram.
Blauwe cirkels De poten van de robotkever die op het oppervlak staan, zijn aangegeven, en die in de lucht zijn wit aangegeven. Houd er rekening mee dat bij het vooruit of achteruit rijden de linker en rechter servomotor exact hetzelfde moeten bewegen. En bij het draaien op hun plaats moeten de motoren in verschillende richtingen draaien (symmetrisch). Een ander interessant ding is dat de voorwaartse en achterwaartse beweging alleen verschillen in de fase van de centrale servomotor.
Dus hoe wordt dit geïmplementeerd? We herinneren ons dat de controller voortdurend de lusfunctie oproept. Dit betekent dat we in deze functie code moeten plaatsen die de huidige positie van de servo's bepaalt en op deze positie instelt. Elke servomotor moet oscillerende bewegingen uitvoeren. We kunnen de positie van de servomotor op tijdstip t berekenen met behulp van de volgende formule:
X = Een zonde(2πt/T),
waarbij X de gewenste positie van de servomotor is, A de amplitude van de trillingen, T de periode van de trillingen.
Afhankelijk van het tijdstip t krijgen we dus een verandering in de waarde van X in het bereik van –A tot +A. Servomotoren kunnen worden gepositioneerd van 0 tot 180°. Daarom is het beter voor ons om rond de “nul”-positie van 90° te oscilleren. En als we oscillaties willen geven met een periode van 1 s rond een positie van 90° met een amplitude van 30°, dan wordt de formule omgezet in de volgende vorm:
X = 90 + 30 sin(2πt/1000),
waarbij t de tijd in milliseconden is die is verstreken sinds het begin van de oscillaties. Om de snelheid van de robotkever te regelen, kunnen we de periode van oscillaties veranderen. Hoe groter het is, hoe lager de snelheid.
Laten we nu nogmaals naar ons diagram terugkeren, omdat de hierboven geschreven formule nog niet voltooid is. Hoe kan een synchrone of tegenbeweging van de linker en rechter servomotoren worden gegarandeerd? Hoe verander ik de fase van de centrale servomotor? We moeten de oscillatiefase aan onze formule toevoegen. Door het argument van de sinus met een hoeveelheid π te verschuiven voor bijvoorbeeld de rechtermotor, zal deze in tegenfase werken ten opzichte van de linkermotor, dat wil zeggen, op de manier waarop we hem nodig hebben om op zijn plaats te draaien. Zo ziet onze formule er nu uit:
X = 90 + 30 sin(2πt/1000 + Φ),
waarbij Φ de oscillatiefase is, ligt de waarde tussen 0 en 2π.
Kijk naar de tabel om te begrijpen wat de oscillatiefasen voor servomotoren moeten zijn voor elk type beweging.
Montage
Laten we nu de robot op een prototypebord monteren en de besturingsschets uploaden.
Dit is erg belangrijke fase vóór montage. Probeer de USB-kabel los te koppelen en het breadboard van stroom te voorzien met behulp van een Krona-batterij. Controleer alle bewegingsfasen en zorg ervoor dat alles werkt. Na het in elkaar zetten van de robot zal het lastiger zijn om iets te veranderen (bijvoorbeeld het vervangen van een kapotte servomotor).
Laten we nu verder gaan met de montage zelf. Het belangrijkste ondersteunende element is het batterijcompartiment. Ik raad aan een gesloten compartiment te gebruiken en altijd met een schakelaar.
De eenvoudigste manier om de keveronderdelen vast te zetten is met hete lijm. Begin met servomotoren. Verwijder onnodige bevestigingsoren en koppel de machines aan elkaar. Lijm vervolgens dit geheel van drie "serva" op het deksel batterijcompartiment. Vergeet niet dat het batterijcompartiment vrij moet openen om de batterij te vervangen.
De eenvoudigste manier is om de controller aan het compartiment te lijmen, maar deze optie bevalt me niet echt, omdat ik de Arduino Uno voor altijd aan de bug zal moeten geven. Daarom kunt u uw leven ingewikkelder maken en Arduino-connectoren gebruiken om het batterijcompartiment te bevestigen. Aan de onderkant van het compartiment lijmt u een pinconnector met een onderlinge afstand van 2,54 mm. Het moet zo worden geplaatst dat het in de controlleraansluiting past in het gebied van digitale pinnen 8–11. We hebben ze sowieso nog niet nodig. Als je geen connector bij de hand hebt, is een U-vormige paperclip voldoende.
De draden die uit het batterijcompartiment komen, moeten worden aangesloten op de Vin-pinnen en de aangrenzende GND. Verwar de polariteit niet! Plus “Kronen” op Vin, min op GND. Om een betrouwbaar contact van de draden met de Arduino-connectoren te garanderen, kun je de punt van de draad eenvoudigweg dikker vertinnen, maar ik heb een kort stukje paperclip als stekker gebruikt. En ik bedekte het soldeergebied met krimpkous.
De connectoren van de kabels van de servoaandrijving moeten worden afgesneden, de stroomdraden (+5 V - meestal rood en GND - zwart of bruin) moeten worden gecombineerd en naar de 5V-aansluitingen en de aangrenzende GND op de controller worden geleid. We zullen iets later verbinding maken. De stuursignaaldraden (meestal geel) worden uitgevoerd naar de digitale uitgangen van de controller: de linker servomotor naar pin 2, de centrale naar pin 4, de rechter naar pin 7.
De “+” en “–” van de IR-ontvanger kunnen eenvoudig op de Arduino-connector (5V en aangrenzende GND) worden aangesloten. Het is waar dat je ze doormidden buigt en hun dikte verdubbelt. We solderen de eerder aangesloten stroomdraden van de servomotoren aan dezelfde stroompoten van de IR-ontvanger. Het is onwaarschijnlijk dat de uitgang van het signaal van de IR-ontvanger de analoge ingang van de A0-controller bereikt, en u zult deze met een draad moeten vergroten.
Enkele tips voor het maken van poten. Bereid eerst de linker en rechter “voor-achter” benen voor. Zorg ervoor dat ze symmetrisch zijn (let op zowel de lengtes als de buighoeken). Begin pas met het lijmen van de poten nadat u zich ervan heeft verzekerd dat de servo's in de nulpositie (90°) staan.
Het is beter om het middelste paar poten als laatste te installeren. Ik adviseer je om eerst de middenpoten langer te maken, en deze na installatie vervolgens op de gewenste lengte af te knippen. In de nulpositie moeten alle zes de poten op het oppervlak staan. De zwaai van de middelste benen met een amplitude van 15° mag de “antero-posterieure” bochten niet hinderen.
Wat is het volgende?
Robozhuk is een kant-en-klaar mobiel platform gebaseerd op een van de meest populaire en betaalbare controllers. Het project is geopend: https://github.com/beetle-ringo/arduino. Maak een fork (branch) in GitHub en voeg je eigen functionaliteit toe. Geef je fantasie de vrije loop: voeg een IR-LED toe en de robot is klaar voor de robotgevechten. Sluit afstandsmeters, tactiele sensoren, een gyroscoop aan... Leer de robot obstakels te vermijden of langs een lijn te lopen, probeer er een webcam op te installeren. Er kunnen een miljoen ideeën zijn, en je kunt altijd de meest interessante kiezen.
Robot Sleipnir
Kit
- Arduino Uno Dagu Spider Robot-controller: 2530 wrijven.
- Servoaandrijvingen SG90 9g (16 stuks) 1150 wrijven.
- Accu LiPo-accupack, 7,4 V, 1800 mAh RUR 490
- Radiomodule 4-pins Bluetooth RF-zendontvanger RUR 270
- Spanningsindicator (optioneel) DC 3,3–30 V Rode LED Paneelmeter RUR 100
- Aluminium hoek. In de dichtstbijzijnde bouwmarkt 135 roebel.
- Bouten en moeren. Op de dichtstbijzijnde rommelmarkt 35 roebel.
Totaal: 4710 wrijven.
*Componenten zijn gekocht bij verschillende tijden, en veel posities kunnen worden geoptimaliseerd
poconoco: Laten we proberen een niet-standaard configuratie samen te stellen: een achtpotige 2DOF-robot. 2DOF-poten zijn veel gemakkelijker te programmeren en ik heb ook een heleboel ongebruikte servo's rondslingeren. En het allerbelangrijkste: het zal mogelijk zijn om het een naam te geven ter ere van het achtpotige paard van de god Odin, Sleipnir (altijd van gedroomd!).
Onze Sleipnir zal aan elke kant vier poten hebben met twee gewrichten. Elk gewricht is een servoaandrijving, wat betekent dat er acht servo's per zijde zijn. Voor de eenvoud roteren alle acht gewrichten aan één kant van het paard in hetzelfde vlak. Hoewel dit helemaal niet nodig is. Bovendien, als de benen aan één kant een beetje "schaakbord" zijn, zodat twee aangrenzende benen elkaar niet kunnen raken, zal dit nog beter zijn, het zal je in staat stellen een bredere stap te zetten en te galopperen.
Een nette en functionele, maar verre van de goedkoopste oplossing is het gebruik van een op maat gemaakt controllerbord dat is geoptimaliseerd voor het aansluiten van grote aantallen servo's. Ik kwam de Dagu Spider Robot Controller tegen - dit is dezelfde Arduino Mega, maar dan op een bord met voorgesoldeerde 3-pins pin-connectoren, waar je die 48 servo's meteen zonder schilden op kunt aansluiten. Ideaal voor meerpotige robots op Arduino.
Controle
We worden bestuurd via Bluetooth. Hier zijn verschillende hardwareoplossingen voor. Dit zijn schilden en losse kaarten met UART seriële interface(zoals een gewone com-poort, alleen met 5 V-signaalniveaus). Het leek mij dat de kleinste kaart met een UART-interface het meest praktisch was. Maakt verbinding met de overeenkomstige UART/seriële pinnen van de Arduino-poort. Laten we twee nuances opmerken: op Uno/Due/Nano en soortgelijke is er maar één zo'n poort, en deze wordt ook gebruikt voor firmware via USB. Daarom moet u mogelijk de Bluetooth-module uitschakelen tijdens de firmware-update. En de tweede nuance: vergeet niet dat de RX-pin van de module is verbonden met de TX-pin van de Arduino, en TX met de RX. Zulke dingen gebeuren in UART.
Het programmeren van Bluetooth is niet ingewikkelder dan dat servogegevens byte voor byte kunnen worden uitgelezen, en dat is wat we zullen gebruiken:
Char cmd; Serieel.begin(9600); if (Serieel.beschikbaar()) cmd = Serieel.lezen();
Als Arduino Mega wordt gebruikt en Bluetooth op de tweede poort is aangesloten, wordt Serial1 geschreven in plaats van Serial. Opvallend is dat je geen Bluetooth hoeft te gebruiken, maar de robot rechtstreeks via USB aanstuurt. En er verandert niets in de bovenstaande code! Er wordt gewoon mee gewerkt seriële poort, maar of er een BT-zender of een USB-serieel-converter hangt, is voor ons niet belangrijk.
De andere kant van Bluetooth
De handigste manier om verbinding te maken is via standaard Linux-hulpprogramma's. Om te werken hebben we de hulpprogramma's sdptool, rfcomm (onderdeel van het bluez-pakket in de Ubuntu-repository's) nodig, evenals minicom (zo heet het pakket). Instructies voor het werken met deze hulpprogramma's zijn te vinden op internet.
Bewegingsalgoritme
Voor een hexapod zou de eenvoudigste manier van lopen dit zijn: de benen zijn verdeeld in twee groepen van drie benen, en een van de groepen bevindt zich volledig op de grond, de andere bevindt zich in de lucht, naar voren verplaatst. Dit is verre van de enige mogelijke gang. Je kunt slechts twee poten in de lucht houden, of zelfs één, en de andere vier of vijf op de grond. Er zijn ook veel gangen voor een octapod. We nemen de eenvoudigste, ook met twee groepen van vier poten.
Dus wat moeten we doen om met 16 servo's en een geselecteerde gang te werken? Het juiste antwoord is om te lezen over inverse kinematica (IR). Door de lengte van het artikel kunnen we niet breed over het onderwerp uitweiden, maar er is voldoende materiaal op internet. Kortom, IC lost het probleem op van het vinden van de noodzakelijke stuursignalen, zodat het systeem ruimte in beslag neemt gewenste positie. Voor het been betekent dit dat aan de hand van de coördinaten van het punt waar de voet moet raken, de hoeken van de servo's die daarvoor ingesteld moeten worden, bepaald worden. En door de coördinaten van de voeten te controleren, kunt u de positie van het lichaam bepalen. We hebben 2DOF-poten, de assen zijn parallel, dus de voet beweegt altijd in hetzelfde vlak. Het IR-probleem wordt in dit geval gereduceerd tot 2D-ruimte, wat het aanzienlijk vereenvoudigt.
Laat de lokale oorsprong van de coördinaten O voor elk been de as van de bovenste servo zijn, dat wil zeggen de heupen. En we hebben de coördinaten van punt A waar de voet moet raken. Dan is het gemakkelijk in te zien dat je het probleem van het vinden van de snijpunten van twee cirkels moet oplossen (zie het diagram van de benen van één zijde, dit is geïllustreerd op het meest rechtse been). Nadat u het snijpunt B van de cirkels hebt gevonden (door een van de cirkels te kiezen), kunt u eenvoudig de vereiste hoeken berekenen met behulp van de conversie van cartesiaanse naar poolcoördinaten. In code ziet de oplossing voor dit probleem er als volgt uit:
Vlotter A = -2 * x; vlotter B = -2 * y; float C = sqr(x) + sqr(y) + sqr(heuplengte) - sqr(scheenbeenlengte); vlotter X0 = -A * C / (sqr(A) + sqr(B)); vlotter Y0 = -B * C / (sqr(A) + sqr(B)); float D = sqrt(sqr(heuplengte) - (sqr(C) / (sqr(A) + sqr(B)))); float mult = sqrt(sqr(D) / (sqr(A) + sqr(B))); zweefbijl, ay, bx, door; bijl = X0 + B * mult; bx = X0 - B * mult; ay = Y0 - A * mult; door = Y0 + A * mult; // of bx voor een ander snijpunt float jointLocalX = ax; // of door voor een ander snijpunt float jointLocalY = ay; zweven hipPrimaryAngle = polarAngle(jointLocalX, jointLocalY); zweven hipAngle = hipPrimaryAngle - hipStartAngle; zwevende scheenPrimaryAngle = polarAngle (x - jointLocalX, y - jointLocalY); zwevende shinAngle = (shinPrimaryAngle - hipAngle) - shinStartAngle;
waarbij x en y de coördinaten zijn van het punt waar je met je voet moet komen; hipStartAngle - de hoek waaronder de "heup" aanvankelijk wordt gedraaid (met de servo in de middelste positie), op dezelfde manier - shinStartAngle. Trouwens, in deze berekeningen zijn de hoeken uiteraard in radialen, maar ze moeten in graden naar Servo-objecten worden overgebracht. De volledige werkende firmwarecode, inclusief dit stukje, staat op GitHub, zie de link aan het einde van het artikel. Dit is een stukje IR, maar daarnaast heb je nog iets meer nodig eenvoudige code om deze IR op alle benen te gebruiken (zie functies legsReachTo(), legWrite()). Je hebt ook code nodig die het lopen daadwerkelijk implementeert: het ene stel benen “achteruit” bewegen (zodat de robot vooruit beweegt), terwijl het andere stel benen omhoog wordt gebracht en naar voren wordt bewogen voor de volgende stap, zie de functie stepForward(). Er is één stap nodig met de gegeven parameters. Met deze parameters kun je overigens een stapje terug doen, ondanks de naam van de functie. Als deze functie in een lus wordt aangeroepen, zal de robot naar voren stappen.
Nu opdrachten ontvangen en interpreteren. Laten we een status aan het programma toevoegen:
Enumstatus (STOP, FORWARD, BACKWARD, FORWARD_RIGHT, FORWARD_LEFT);
En in de hoofduitvoeringslus loop() zullen we kijken huidige staat(statusvariabele) en trek stepForward() als we vooruit gaan (met of zonder rotatie), en opnieuw stepForward(), maar met een negatief argument xamp, als we achteruit moeten gaan. Bochten worden in dit geval verwerkt in legWrite(), en voor het naar rechts draaien de benen met rechterkant zal stilstaan (terwijl de linker rijen). Hier is zo'n paardentank. Brutaal, maar heel simpel en het werkt. Vloeiende rotatie kan alleen worden gedaan met 3DOF-poten, een voorbeeld hiervan is te zien in de buggybug-repository.
Schakelaar (status) ( case FORWARD: case FORWARD_RIGHT: case FORWARD_LEFT: stepForward(h, dh, xamp, xshift); break; case BACKWARD: stepForward(h, dh, - xamp, xshift); break; )
Char-opdracht; while (Serial1.available()) opdracht = Serial1.read(); schakelaar (opdracht) ( case "w": status = FORWARD; break; case "s": state = ACHTERUIT; break; case "d": state = FORWARD_RIGHT; break; case "a": state = FORWARD_LEFT; break; standaard : status = STOP;
Dit is waar de belangrijkste punten van de firmware voorbij zijn, de rest bestaat uit allerlei kleine dingen. Hoewel er waarschijnlijk nog één is belangrijk punt- de mogelijkheid om de servo's te verfijnen. Zelfs met de meest zorgvuldige montage, als je alle servo's de opdracht geeft om 90° te draaien, zullen sommige nog steeds een enigszins afwijkende hoek krijgen. Daarom hebben we het vermogen nodig om het aan te passen. Je kunt zien hoe ik dit deed in de methoden hipsWrite() en shinsWrite() en in de arrays zelf fijne instellingen heupenTune en scheenbenenTune.
Montage
Voor dergelijke ontwerpen heb je niets speciaals nodig: een stuk plexiglas van geschikte dikte (van de dichtstbijzijnde hardware-vlooienmarkt) en een decoupeerzaag of ijzerzaag om de onderdelen uit te snijden is voldoende. En natuurlijk een boormachine om gaten te boren. In plaats van plexiglas kunt u multiplex gebruiken (dan kunt u ook een gedenkwaardige inscriptie maken met een brander op de uiteindelijke structuur). Je kunt ook platen of hoeken van aluminium gebruiken. Met Sleipnir ging ik precies zoals ik een aluminium hoek met ribben van 1 cm gebruikte (ergens gekocht in een bouwsupermarkt).
De basis zal een rechthoekig frame zijn. Ledematen - strepen van 4 centimeter. Het is ook de moeite waard om veel kleine bouten en moeren in te slaan. We snijden de hoek in de benodigde stukken, snijden groeven uit voor de servo's en boren gaten voor de bevestigingsbouten en schroeven. Het is beter om het ontwerp te laten zien dan om het te beschrijven. De maten kunnen elk zijn, robots moeten gevarieerd zijn. Maar onthoud: hoe langer de benen, hoe meer de hendel de servo zal moeten duwen en hoe meer belasting hij zal hebben. Tot het punt dat je niet meer kunt draaien en zelfs kapot kunt gaan. Maar 4-5 cm is geen probleem.
Voor budget-lichtgewichtrobots hebben ze vaak geen moeite met een apart scharnierend gewricht voor de ledematen, en valt de hele lading volledig op de servo-aandrijfas. Gezien het lage gewicht is dit helemaal niet kritisch. En bij meer gewicht moet je denken aan servo's met metalen tandwielen en kogellagers.
Elke servo wordt meestal geleverd met een paar schroeven en een set hulpstukken die op de as kunnen worden geschroefd diverse toepassingen. Onze beste keuze is een enkele “hoorn” (of hoorn), waarmee je een staafje aan de servo kunt bevestigen. De assen van twee servo's zijn dus aan één staaf bevestigd en de staaf wordt een "heup". In dit geval wordt de ene servo aan het lichaam bevestigd en wordt de andere onderdeel van het onderbeen. Het is de moeite waard om er nog een staaf aan te bevestigen, gewoon om hem langer te maken of de ledemaat interessanter te maken. Een beetje nauwgezet werk - en het platform is klaar (handige sets schroevendraaiers, sleutels, pincetten, draadknippers, etc. versnellen het proces enorm).
Wat is het volgende?
Het hele project is beschikbaar op https://github.com/poconoco/sleipnir. Ik beschreef een van de meest onpraktische configuraties: veel 2DOF-poten, lang, smal, gemakkelijk op zijn kant te vallen. Probeer een betere robot te maken met 3DOF-poten. Met 4DOF poten. Met klauwen of kaken. Als voorbeeld 3DOF omgekeerde kinematica Je kunt de buggybug-repository raadplegen - de hexapod-firmware is daar. Je kunt ook intelligente robots maken, in plaats van gecontroleerde, door afstandssensoren te installeren in plaats van Bluetooth, en de robot te leren muren en obstakels te vermijden. Als je zo'n sensor op een servodrive plaatst en deze draait, kun je het gebied scannen, bijna met een sonar.
Goededag! Voor jullie, geliefden, staat een kunstrobot die verschillende bolvormige of eivormige objecten kan schilderen, variërend in grootte van 4 tot 9 cm.
Om het te maken heb je een 3D-printer nodig, een kit standaard gereedschap+ Arduino.
Opmerking: geef projecten waarbij een 3D-printer wordt gebruikt niet op. Als u wilt, kunt u altijd een plaats of manier vinden waar u het afdrukken van de onderdelen die nodig zijn voor het project kunt bestellen.
Stap 1: Iets over de robot
Kunstrobot - tweeassig zelfgemaakt, die op de meeste bolvormige oppervlakken een patroon kan vormen. De robot is aangepast bepaald type artikelen (pingpongballen, kerstversiering, gloeilampen en eieren (eend, gans, kip...).
Er worden uiterst nauwkeurige stappenmotoren met een hoog koppel gebruikt om het bolvormige object te roteren en de manipulator te verplaatsen, en een stille en betrouwbare SG90-servoaandrijving wordt gebruikt om het handgreepmechanisme op te tillen.
Stap 2: Benodigde onderdelen
Om te doen Doe-het-zelf-ambachten wij hebben nodig:
- 2x lagers 623;
- Haarspeld met een diameter van 3 mm en een lengte van 80-90 mm;
- 1x veer (lengte 10 mm en diameter 4,5 mm);
- 2x NEMA 17 stappenmotoren (koppel 4,4 kg/cm);
- Motorkabels (lengte 14 + 70 cm);
- USB-kabel;
- 1x SG90 servoaandrijving;
- Arduino Leonardo;
- schild JJRobots;
- 2xA4988 drivers voor stappenmotoren;
- Voeding 12V/2A;
- 11x M3 6 mm schroeven;
- 4x M3 16 mm schroeven;
- 4x M3-moeren;
- 2x 20 mm zuignappen;
- 1x vleugelmoer M3;
- 1x markering;
Stap 3: Algemeen overzicht
U kunt dit diagram gebruiken als een “spiekbriefje”.
Stap 4: Laten we aan de slag gaan!
De robot beweegt een manipulator met daaraan een marker, die wordt aangedreven door een stappenmotor. Een andere stappenmotor is verantwoordelijk voor het roteren van het object waarop de tekening is aangebracht (ei, bal...). Er worden twee zuignappen gebruikt om het item op zijn plaats te houden: de ene is bevestigd aan de stappenmotor en de andere aan de andere kant van het item. Een kleine veer drukt tegen de zuignap, waardoor deze het voorwerp vasthoudt. De SG90-servoaandrijving wordt gebruikt om de markeur omhoog/omlaag te brengen.
Stap 5: Manipulator
Plaats de moer in het daarvoor bestemde gat en draai de 16 mm schroef vast. Laten we hetzelfde doen voor de itemhouder (rechts in de afbeelding hierboven). Bij het maken van het scharnier voor de manipulator zijn 2 schroeven van 16 mm gebruikt. Dit scharnier moet vrij kunnen draaien nadat de schroeven zijn vastgedraaid.
Stap 6: Sukkels
Plaats een van de zuignappen in het gat in de artikelhouder.
Stap 7: De stappenmotoren monteren
Beide stappenmotoren bevestigen we met 8 schroeven aan het hoofdframe.
Stap 8: Rotatie-as
Laten we alle elementen plaatsen zoals weergegeven in de afbeelding hierboven.
- Sukkel;
- Schroef;
- Bovenste deel;
- Lente;
- Lager 623 (moet in de linker cup worden ingebouwd);
- Linker kopje;
- Vrije ruimte voor het hoofdframe;
- Rechter kopje;
- Lager 623;
- Afstandsring;
- Vleugelmoer (M3).
Stap 9: Alles op zijn plaats zetten
Laten we de gemonteerde manipulator op de as van de stappenmotor plaatsen.
Laten we de linkersteun op de as van de stappenmotor installeren.
De marker en het ei zijn als voorbeeld geplaatst (u hoeft ze nu niet te plaatsen).
OPMERKING: De servo vereist aanpassingen. Tijdens het kalibratieproces moet u de hoek opnieuw instellen.
Stap 10: Elektronica
Laten we de elektronica met schroeven aan de achterkant van het hoofdframe bevestigen (2 is voldoende).
Laten we de kabels aansluiten.
Als je bij het aansluiten van stappenmotoren de polariteit omdraait, draaien ze gewoon in de tegenovergestelde richting, maar met een servoaandrijving zal de situatie niet zo onschadelijk zijn! Controleer daarom de polariteit voordat u aansluit!
Stap 11: Programmeren van de Arduino Leonardo
Laten we Arduino Leonardo programmeren met behulp van software-omgeving Arduino IDE (v 1.8.1).
- Download Arduino IDE (v 1.8.1) en installeer het programma;
- Laten we lanceren software. Selecteer het Arduino Leonardo-bord en de bijbehorende COM-POORT in het menu “tools->board”;
- Laten we de Sphere-O-Bot-code openen en downloaden. Laten we alle bestanden in één map uitpakken en deze “Ejjduino_ARDUINO” noemen.
Stap 12: De kunstrobot is klaar om kunstwerken te maken
Stap 13: Bestuur de robot
Software Inktlandschap. Download en installeer Inkscape-software (aanbevolen stabiele versie 0.91).
Download en installeer de EggBot Control-extensie (versie 2.4.0 is volledig getest).
De EggBot Control-extensie voor Inkscape is het hulpmiddel dat u moet gebruiken bij het testen en kalibreren van uw EggBot en het overbrengen van uw ontwerp op het ei. Eerst moet je Inkscape starten. Na het starten van Inkscape verschijnt het menu "Extensies" en daarin moet je het submenu "Eggbot" selecteren. Als u het Eggbot-submenu niet ziet, heeft u de extensies niet correct geïnstalleerd. Uitvoeren back-up en volg zorgvuldig de instructies voor het installeren van extensies.
Dat is alles, bedankt voor uw aandacht!)
Het resultaat is een nogal grappige robot die obstakels voor zich kan zien, de situatie kan analyseren en vervolgens, nadat hij alleen de beste route heeft gekozen, verder gaat. De robot bleek zeer wendbaar. Hij kan 180 graden draaien en de rotatiehoek is 45 en 90 graden. De auteur gebruikte Iteaduino, een analoog van Arduino, als hoofdcontroller.
Materialen en gereedschappen voor het maken van een robot:
- microcontroller (Arduino of soortgelijke Iteaduino);
- ultrasone sensor;
- batterijhouder;
- Chinees speelgoed voor het maken van een wielbasis (je kunt een kant-en-klaar exemplaar kopen);
- draadscharen;
- lijm;
- draden;
- motoren;
- vezelplaat;
- puzzel;
- transistors (D882 P).
Robotproductieproces:
Stap één. Het creëren van een wielbasis
Om een wielbasis te creëren kocht de auteur twee Chinese speelgoedauto's. U hoeft zich hier echter geen zorgen over te maken als u extra geld heeft, aangezien u een kant-en-klare basis kunt kopen. Met behulp van draadscharen werden de auto's in tweeën gesneden, zodat er twee aandrijfassen ontstonden. Deze onderdelen werden vervolgens aan elkaar gelijmd. In dit geval kun je echter ook een soldeerbout gebruiken; plastic kan perfect worden gesoldeerd.
Bij het kiezen van auto's kun je het beste speelgoed met gewone wielen nemen, omdat de robot volgens de auteur met pieken zoals de zijne veel springt.
Er is nog een moment waarop er draden uit de motoren komen; een daarvan moet je onthouden om de polariteit te veranderen.
Stap twee. Het maken van de bovenklep
De bovenklep van de robot is gemaakt van vezelplaat; dik karton kan ook voor deze doeleinden worden gebruikt. Je ziet een rechthoekig gat in het deksel; het moet zo worden geplaatst dat de as van de servoaandrijving, die erin wordt gestoken, symmetrisch ligt. Wat het gat in het midden betreft, de draden zullen er doorheen komen.
Stap drie. Robotvulling
Het beste is om een aparte voeding te gebruiken om het chassis aan te sluiten, aangezien de controller 9V nodig heeft om hem van stroom te voorzien, terwijl de motoren slechts 3V nodig hebben. Over het algemeen zijn batterijhouders al in het chassis van dergelijke machines ingebouwd; ze hoeven alleen maar parallel te worden aangesloten.
De motoren zijn met de controller verbonden met behulp van transistors van het type D882 P. Ze zijn uit het oude bedieningspaneel van de machine gehaald. Het is natuurlijk het beste om vermogenstransistors van het TIP120B-type te gebruiken, maar de auteur heeft ze eenvoudigweg gekozen op basis van geschikte kenmerken. Alle elektronische onderdelen zijn aangesloten volgens het opgegeven schema.
Na het flashen van de firmware van de robot is deze klaar om te testen. Om ervoor te zorgen dat de robot de tijd heeft om in een bepaalde hoek te draaien, moet u de juiste bedrijfstijd voor de motoren kiezen.
Wat de sensoren betreft, de ultrasone moet worden aangesloten op de 7e digitale uitgang van de microcontroller. De servomotor is verbonden met de derde digitale ingang, de basis van de transistor van de linkermotor is verbonden met pin 11 en de basis van de rechter is verbonden met de 10e.
Als Krona als voeding wordt gebruikt, is de min verbonden met GND en de plus met VIN. U moet ook de emitter van de transistor en het negatieve contact van de voeding van het robotchassis aansluiten op GND.
Winkel in robots en robotica huishoudelijke robots quadcopters hoverboards constructeurs robots speelgoed nieuws
Ik raak opgewonden als toekomstige ingenieurs hun eigen apparaten maken en raak boos als ik iemand hoor praten over het gebruik van Arduino daarin.
Dit is niet mijn eerste artikel over dit onderwerp: ik heb de wens om er meteen een te schrijven nadat ik de zin over de grenzeloze mogelijkheden van het platform in het doe-het-zelf-onderwerp op Habré heb gelezen. Ik heb zin om te schrijven over de werkelijke prijs van onderdelen na het lezen van een artikel over het kopen van een bouwset voor $ 200 die bijna niets bevat (sorry, ik ben vergeten waar ik het heb gezien).
Het punt hier is niet dat ik Arduino een slecht idee vind. Integendeel, dankzij het platform leerden veel mensen over de wereld van microcontrollers en leerden ze dat zelfs iemand zonder speciaal onderwijs, met minimale kennis van programmeren en geen kennis van elektronica, een klein cool apparaatje in elkaar kan zetten.
Dankzij Arduino zagen veel projecten die stof aan het verzamelen waren in de hersengeheugenbanken van hun auteurs het levenslicht.
Ik geef eerlijk toe dat ik zelf soms code gebruikte die voor Arduino was geschreven (het bedrijf InvenSense produceert bijvoorbeeld de MPU6050-module, die alleen goed kon werken).
Ik veracht de mensen die, nadat ze de wereld van de microcontrollers hadden ontdekt, niet de moeite namen om daarin rond te kijken, en degenen die schaamteloos van zulke mensen profiteren.
Een student van de afdeling Informatietechnologie, een fan van Arduino, kwam naar ons laboratorium (en werkte met ons samen). De man heeft veel geld uitgegeven aan de aanschaf van de *duins zelf en modules daarvoor. Ik keek, niet zonder spijt, toe hoe de toekomstige (ik hoop nog steeds) maker van robotsystemen PWM niet kon lanceren vereiste frequentie, hoewel hij veel ‘vluchturen’ maakte terwijl hij met het platform werkte.
Dus deze student liet me een ‘batterijniveaumeter’ zien, of iets dergelijks. Ik heb het nu specifiek op eBay gevonden, waar het “ Hoge gevoeligheid spanningssensormodule - Compatibel met Arduino" en wordt verkocht voor $ 8,58. Hier staat hij op de foto:
Trouwens, de centrale draad, die "+" is - hij hangt gewoon in de lucht - alles wordt maximaal gedaan handige verbinding een eenvoudige spanningsdeler, waarvan de rode prijs 2 cent is voor weerstanden en 20 cent voor een connector - dit is als je hem in de detailhandel koopt.
Dit is niet het enige geval van bedrog van onze broer; hieronder zal ik er nog een aantal noemen. Voor degenen die van structureren houden, zal ik nu de belangrijkste nadelen van Arduino opschrijven.
Op Hobbyking, waar fans van verschillende modelleringsprojecten op dezelfde manier worden misleid als in andere winkels voor Arduino-liefhebbers, werd een gewone condensator verkocht onder het mom van een soort filter. Ik kon hem nu niet vinden. Met een driepolige connector uiteraard. Voor slechts 3 dollar.
Arduino Compatibele Mini Motor Snelheidsteller Sensor AVR PIC– vervangen door een LED en een fototransistor aangesloten op een centrale controller en twintig regels code. Het is geen 7,98 waard.
2*4 Matrix-toetsenborddrukknoppen AVR ARM Arduino-compatibel- dit zijn slechts knopen die voor 10 stuks per dollar te koop zijn.
Er is één apparaat ter wereld dat ik meer haat dan de Arduino: de mbed. De ontwikkelaars namen de LPC1768-controller (ook beschikbaar op de LPC11U24), soldeerden deze op een bord met twee stabilisatoren (ik zal niet praten over de kwaliteit van de lay-out van het bord), verplaatsten de helft van de poten naar buiten (de andere helft is niet verbonden waar dan ook, wat erg vervelend is), schreef online een onnauwkeurige IDE (echter een beetje beter dan Arduino, hoewel er een internetverbinding voor nodig is) en verkoopt deze voor $ 64. Sorry, maar dit is al behoorlijk.
Wat moet je doen als je plotseling besluit om geen tijd meer te besteden aan het bestuderen van microcontrollers?
- Er was een reeks artikelen over Habré "STM32F1xx - samen Arduino-verslaving genezen" - de artikelen zijn goed en redelijk begrijpelijk, het is jammer dat de auteur is gestopt met het schrijven van nieuwe artikelen.
- Alle nieuwkomers worden naar easyelectronics.ru gestuurd, waar collega DIHALT een training over AVR-microcontrollers publiceerde.
- « Ontwerpen van applicaties op microcontrollers van de 68HC12/HCS12-familie met behulp van de C-taal"S.F. Barrett, D.J. Park - een superboek dat je helpt de basisprincipes van programmeren in C voor microcontrollers te begrijpen. Het enige probleem is dat het onwaarschijnlijk is dat je Freescale-microcontrollers zult krijgen, dus je zult de voorbeelden zelf moeten porten naar een AVR, PIC, MSP430 of een andere controller.
- Voordat u iets voor uw apparaten koopt, moet u er in ieder geval op Wikipedia over lezen - misschien kan hetzelfde onderdeel goedkoper worden gekocht als u het anders noemt.
Weet jij eigenlijk wat vreemd is? Onder Arduino-gebruikers zijn er zelfs mensen die Apple verachten vanwege hun ‘targeting van de bekrompen, drukbezette gebruiker’.
Ik wil niemand beledigen of overtuigen. Maar ik zal blij zijn als tenminste één persoon die het artikel tot nu toe heeft gelezen Arduino inruilt voor een eenvoudige microcontroller - misschien wordt hij in de toekomst een goede ontwikkelaar van embedded systemen.
Laten we het hebben over hoe je Arduino kunt gebruiken om een robot te maken die balanceert als een Segway.
Segway uit het Engels. Segway is een tweewielig staand voertuig uitgerust met een elektrische aandrijving. Ze worden ook wel hoverboards of elektrische scooters genoemd.
Heb je je ooit afgevraagd hoe een Segway werkt? In deze tutorial proberen we je te laten zien hoe je een Arduino-robot kunt maken die zichzelf in evenwicht houdt, net als een Segway.
Om de robot in evenwicht te brengen, moeten de motoren weerstand bieden aan het vallen van de robot. Deze actie vereist feedback en corrigerende elementen. Feedbackelement - dat zorgt voor zowel versnelling als rotatie in alle drie de assen (). Arduino gebruikt dit om de huidige oriëntatie van de robot te kennen. Het corrigerende element is de combinatie van motor en wiel.
Het eindresultaat zou ongeveer zo moeten zijn:
Robotdiagram
L298N Motorbesturingsmodule:
DC-reductiemotor met wiel:
Een zelfbalancerende robot is in wezen een omgekeerde slinger. Het kan beter uitgebalanceerd zijn als het zwaartepunt hoger ligt ten opzichte van de wielassen. Een hoger massamiddelpunt betekent een groter traagheidsmoment van de massa, wat overeenkomt met een lagere hoekversnelling (langzamere val). Daarom hebben wij het accupakket bovenop geplaatst. De hoogte van de robot is echter gekozen op basis van de beschikbaarheid van materialen :)
De voltooide versie van de zelfbalancerende robot is te zien in de figuur hierboven. Aan de bovenkant bevinden zich zes Ni-Cd-batterijen voor stroom printplaat. Tussen de motoren wordt een 9 volt batterij gebruikt voor de motorbestuurder.
Theorie
In de besturingstheorie vereist het vasthouden van een variabele (in dit geval de positie van de robot) een speciale controller genaamd PID (proportionele integrale afgeleide). Elk van deze parameters heeft een "versterking", gewoonlijk Kp, Ki en Kd genoemd. De PID zorgt voor correctie tussen de gewenste waarde (of invoer) en de werkelijke waarde (of uitvoer). Het verschil tussen invoer en uitvoer wordt "fout" genoemd.
De PID-regelaar reduceert de fout tot de kleinst mogelijke waarde door de uitgang continu aan te passen. In onze zelfbalancerende robot Arduino-ingang(wat de gewenste helling in graden is) wordt door de software ingesteld. De MPU6050 leest de huidige kanteling van de robot en geeft deze door aan het PID-algoritme, dat berekeningen uitvoert om de motor te besturen en de robot rechtop te houden.
De PID vereist dat de Kp-, Ki- en Kd-waarden worden aangepast aan optimale waarden. Ingenieurs gebruiken software zoals MATLAB om deze waarden automatisch te berekenen. Helaas kunnen we MATLAB in ons geval niet gebruiken omdat dit het project nog ingewikkelder zal maken. In plaats daarvan zullen we de PID-waarden aanpassen. Hier leest u hoe u het moet doen:
- Maak Kp, Ki en Kd gelijk aan nul.
- Kp aanpassen. Een te kleine Kp zal ervoor zorgen dat de robot valt omdat de correctie niet voldoende is. Te veel Kp zorgt ervoor dat de robot wild heen en weer gaat. Een goede Kp zorgt ervoor dat de robot behoorlijk heen en weer beweegt (of een beetje oscilleert).
- Zodra Kp is ingesteld, past u Kd aan. Een goede Kd-waarde vermindert de oscillaties totdat de robot bijna stabiel wordt. Bovendien zal de juiste Kd de robot vasthouden, zelfs als deze wordt geduwd.
- Installeer ten slotte Ki. Als de robot is ingeschakeld, zal hij oscilleren, zelfs als Kp en Kd zijn ingesteld, maar zal hij zich na verloop van tijd stabiliseren. De juiste Ki-waarde verkort de tijd die nodig is om de robot te stabiliseren.
Het gedrag van de robot is te zien in de onderstaande video:
Arduino-code voor zelfbalancerende robot
We hadden vier externe bibliotheken nodig om onze robot te maken. De PID-bibliotheek vereenvoudigt de berekening van P-, I- en D-waarden. De LMotorController-bibliotheek wordt gebruikt om twee motoren te besturen met de L298N-module. De I2Cdev-bibliotheek en de MPU6050_6_Axis_MotionApps20-bibliotheek zijn ontworpen om gegevens van de MPU6050 te lezen. U kunt de code, inclusief bibliotheken, downloaden in deze repository.
#erbij betrekken
De Kp-, Ki-, Kd-waarden kunnen wel of niet werken. Als dit niet het geval is, volgt u de bovenstaande stappen. Merk op dat de kanteling in de code is ingesteld op 173 graden. Je kunt deze waarde desgewenst wijzigen, maar houd er rekening mee dat dit de kantelhoek is die de robot moet behouden. Als uw motoren te snel zijn, kunt u bovendien de waarden motorSpeedFactorLeft en motorSpeedFactorRight aanpassen.
Dat is alles voor nu. Tot snel.
