hjem

Ferdige Arduino-roboter. Arduino-basert firbeint robot Arduino-basert beltevogn styrt fra en mobiltelefon

God dag! Før dere, kjære dere, er en kunstrobot som kan male forskjellige sfæriske eller eggformede gjenstander i størrelse fra 4 til 9 cm.

For å lage det trenger du en 3D-printer, et sett med standardverktøy + Arduino.

Merk: Ikke gi opp prosjekter som bruker en 3D-printer. Om ønskelig kan du alltid finne et sted eller en metode hvor du kan bestille utskrift av detaljene som er nødvendige for prosjektet.

Trinn 1: Litt om roboten

Kunstrobot - to-akset hjemmelaget, som kan skrive ut på de fleste sfæriske overflater. Roboten er konfigurert for en bestemt type gjenstand (pingpongballer, julepynt, lyspærer og egg (and, gås, kylling ...).

Høypresisjonstrinnmotorer med høyt dreiemoment brukes til å rotere det sfæriske objektet og flytte manipulatoren, og en stillegående og pålitelig SG90 servodrift brukes til å løfte håndtaksmekanismen.

Trinn 2: Nødvendige deler

Å lage gjør-det-selv håndverk Vi trenger:

2x lagre 623;
Hårnål med en diameter på 3 mm og en lengde på 80-90 mm;
1x fjær (lengde 10 mm og diameter 4,5 mm);
2x NEMA 17 trinnmotorer (moment 4,4 kg/cm);
Kabler for motorer (lengde 14 + 70 cm);
USB-kabel;
1x SG90 servo;
Arduino Leonardo;
skjold JJRoboter;

2xA4988 trinnmotordrivere;
Strømforsyning 12V / 2A;
11x M3 6mm skruer;
4x M3 16mm skruer;
4x muttere M3;
2x 20 mm sugekopper;
1x vingemutter M3;
1x markør;

Trinn 3: Generelt opplegg

Som et "jukseark" kan du bruke denne ordningen.

Trinn 4: La oss komme i gang!

Roboten beveger en manipulator med en markør festet til den, som drives av en trinnmotor. En annen trinnmotor er ansvarlig for å snu objektet som tegningen er brukt på (egg, ball ...). To sugekopper brukes til å holde gjenstanden på plass, en festet til trinnmotoren og den andre på motsatt side av gjenstanden. En liten fjær vil trykke på sugekoppen for å hjelpe den med å holde gjenstanden. SG90-servoen brukes til å heve/senke markøren.

Trinn 5: Manipulator

Installer mutteren i hullet som er forberedt for den, og stram til 16 mm skruen. La oss gjøre det samme for vareholderen (til høyre i bildet ovenfor). Ved å lage hengslet for manipulatoren ble det brukt 2 stk 16 mm skruer. Dette hengslet må rotere fritt etter at skruene er trukket til.

Trinn 6: Sukker

Installer en av sugekoppene inne i hullet i gjenstandsholderen.

Trinn 7: Feste trinnmotorer

Fest begge trinnmotorene til hovedrammen med 8 skruer.

Trinn 8: Rotasjonsakse

La oss plassere alle elementene som vist på bildet ovenfor.

Sucker;
Skru;
Øverste del;
Vår;
Lager 623 (skal bygges inn i venstre kopp);
Venstre kopp;
Ledig plass for hovedrammen;
Høyre kopp;
Lager 623;
Skille ring;
Vingemutter (M3).

Trinn 9: Sett alt på plass

Sett den sammensatte manipulatoren inn på aksen til trinnmotoren.

Installer venstre støtte på trinnmotorens akse.

Markøren og egget er satt som eksempel (du trenger ikke å plassere dem nå).

MERK: Servoen vil kreve justeringer. Du må stille inn vinkelen på nytt under kalibreringsprosessen.

Trinn 10: Elektronikk

Fest elektronikken på baksiden av hovedrammen med skruer (2 er tilstrekkelig).

La oss koble til kablene.

Hvis du snur polariteten når du kobler til trinnmotorer, vil de rett og slett rotere i motsatt retning, men med en servo er ikke situasjonen så ufarlig! Så dobbeltsjekk polariteten før du kobler til!

Trinn 11: Programmering av Arduino Leonardo

La oss programmere Arduino Leonardo ved å bruke Arduino IDE-programvaremiljøet (v 1.8.1).

Last ned Arduino IDE (v 1.8.1) og installer programmet;
La oss kjøre programvaren. Velg Arduino Leonardo-brettet og den tilsvarende COM-PORT i "verktøy->brett"-menyen;
La oss åpne og laste ned Sphere-O-Bot-koden. La oss pakke ut alle filene i én mappe og kalle den "Ejjduino_ARDUINO".

Trinn 12: Kunstroboten er klar til å lage kunstverk

Trinn 13: Robotkontroll

Programvare blekklandskap. Last ned og installer Inkscape-programvaren (jeg anbefaler stabil versjon 0.91).

Last ned og installer EggBot Control-utvidelsen (versjon 2.4.0 er fullstendig testet).

EggBot Control-utvidelsen for Inkscape er et verktøy som skal brukes ved testing og kalibrering av EggBot og overføring av tegninger til egget. Først må du starte Inkscape. Etter å ha startet Inkscape, vises "Extensions"-menyen, og i den må du allerede velge "Eggbot"-undermenyen. Hvis du ikke ser Eggbot-undermenyen, har du ikke installert utvidelsene riktig. Sikkerhetskopier og følg nøye instruksjonene for installasjon av utvidelser.

Det er alt, takk for oppmerksomheten!)

Resultatet er en ganske morsom robot, som kan se hindringer foran seg, analysere situasjonen og deretter, bare velge den beste ruten, gå videre. Roboten viste seg å være svært manøvrerbar. Den er i stand til å snu 180 grader, og rotasjonsvinkelen er 45 og 90 grader. Som hovedkontroller brukte forfatteren Iteaduino, som er en analog av Arduino.

Materialer og verktøy for å lage en robot:
- mikrokontroller (Arduino eller lignende Iteaduino);
- ultralydsensor;
- holder for batterier;
- Kinesiske leker for å lage en akselavstand (du kan kjøpe ferdige);
- avbitertang;
- lim;
- ledninger;
- motorer;
- fiberplate;
- stikksag;
- transistorer (D882P).

Produksjonsprosess for roboter:

Steg en. Å skape en akselavstand
For å skape en akselavstand kjøpte forfatteren to kinesiske lekebiler. Du trenger imidlertid ikke å bekymre deg for dette hvis du har ekstra penger, siden du kan kjøpe en ferdig base. Ved hjelp av wirekuttere ble bilene kuttet i to deler for å danne to drivaksler. Disse delene ble deretter limt sammen. Men i dette tilfellet kan du jobbe med et loddejern, plasten er perfekt loddet.

Når du velger biler, er det best å ta leker med vanlige hjul, siden, ifølge forfatteren, med pigger som hans, hopper roboten mye.

Det er et annet slikt øyeblikk når ledninger kommer ut fra motorene, på en av dem må du huske å endre polariteten.

Trinn to. Lage toppdekselet
Toppdekselet til roboten er laget av fiberplater, og tykk papp kan også brukes til dette formålet. Et rektangulært hull kan sees i dekselet, det må være plassert slik at aksen til servoen, som skal settes inn i det, er symmetrisk. Når det gjelder hullet i midten, vil ledninger gå gjennom det.

Trinn tre. Robotstopping
Det er best å bruke en separat strømforsyning for å koble til chassiset, siden kontrolleren krever 9V for å drive den, og kun 3V for motorene. Generelt er batteriholdere allerede innebygd i chassiset til slike maskiner, de trenger bare å kobles parallelt.

Motorene er koblet til kontrolleren ved hjelp av transistorer av typen D882 P. De ble trukket ut av det gamle maskinkontrollpanelet. Det er selvfølgelig best å bruke krafttransistorer av typen TIP120B, men forfatteren valgte ganske enkelt i henhold til passende egenskaper. Hele den elektroniske delen er koblet til i henhold til spesifisert skjema.

Etter fastvaren til roboten vil den være klar for testing. For at roboten skal ha tid til å snu seg i en viss vinkel, må du velge riktig tidspunkt for driften av motorene.

Når det gjelder sensorene, må ultralyden kobles til den 7. digitale utgangen på mikrokontrolleren. Servomotoren er koblet til den tredje digitale inngangen, basen til transistoren til venstre motor er koblet til den 11. pinne, og basen til høyre motor er koblet til den tiende.

Hvis Krona brukes som strøm, er minus koblet til GND, og pluss til VIN. Du må også koble transistorens emitter og den negative kontakten fra strømforsyningen til robotchassiset til GND.

La oss snakke om hvordan du kan bruke Arduino til å lage en robot som balanserer som en Segway.

Segway fra engelsk. Segway er et tohjuls stående kjøretøy utstyrt med elektrisk drift. De kalles også gyroscootere eller elektriske scootere.

Har du noen gang lurt på hvordan en Segway fungerer? I denne opplæringen vil vi prøve å vise deg hvordan du lager en Arduino-robot som balanserer seg akkurat som en Segway.

For å balansere roboten må motorene motvirke robotens fall. Denne handlingen krever tilbakemelding og korrigerende elementer. Tilbakemeldingselement - , som gir både akselerasjon og rotasjon i alle tre aksene (). Arduinoen bruker dette for å kjenne robotens nåværende orientering. Det korrigerende elementet er kombinasjonen av motor og hjul.

Sluttresultatet bør være noe slikt:

Robotordning

L298N motordrivermodul:

DC girmotor med hjul:

En selvbalanserende robot er i hovedsak en invertert pendel. Den kan balanseres bedre hvis massesenteret er høyere i forhold til hjulakslene. Et høyere massesenter betyr et høyere massetreghetsmoment, som tilsvarer en lavere vinkelakselerasjon (saktere fall). Derfor legger vi batteripakken på toppen. Høyden på roboten ble imidlertid valgt basert på tilgjengeligheten av materialer 🙂

Den ferdige versjonen av den selvbalanserende roboten kan sees i figuren over. Øverst er det seks Ni-Cd-batterier for å drive PCB-en. Mellom motorer brukes et 9-volts batteri for motorføreren.

Teori

I kontrollteori krever det å holde en variabel (i dette tilfellet posisjonen til roboten) en spesiell kontroller kalt en PID (Proportional Integral Derivative). Hver av disse parameterne har en "gevinst", vanligvis referert til som Kp, Ki og Kd. PID gir en korreksjon mellom ønsket verdi (eller input) og den faktiske verdien (eller output). Forskjellen mellom input og output kalles "feil".

PID-regulatoren reduserer feilen til lavest mulig verdi ved å hele tiden justere utgangen. I vår selvbalanserende Arduino-robot settes inngangen (som er ønsket helning i grader) av programvaren. MPU6050 leser robotens nåværende tilt og mater den inn i en PID-algoritme som utfører beregninger for å kontrollere motoren og holde roboten oppreist.

PID krever at Kp-, Ki- og Kd-verdiene settes til optimale verdier. Ingeniører bruker programvare som MATLAB for automatisk å beregne disse verdiene. Dessverre kan vi ikke bruke MATLAB i vårt tilfelle fordi det vil komplisere prosjektet enda mer. I stedet vil vi justere PID-verdiene. Slik gjør du det:

Sett Kp, Ki og Kd til null.
Juster Kp. For lite Kp vil føre til at roboten faller fordi reparasjonen ikke er nok. For mye Kp får roboten til å gå vill frem og tilbake. En god Kp vil få roboten til å lene seg ganske mye frem og tilbake (eller svinge litt).
Når Kp er satt, justerer du Kd. En god Kd-verdi vil redusere svingningene til roboten er nesten stabil. Dessuten vil en skikkelig Kd beholde roboten selv om den blir presset.
Til slutt, installer Ki. Når den er slått på, vil roboten oscillere selv om Kp og Kd er innstilt, men vil stabilisere seg over tid. Riktig Ki-verdi vil forkorte tiden det tar for roboten å stabilisere seg.

Robotens oppførsel kan sees nedenfor i videoen:

Arduino-kode for en selvbalanserende robot

Vi trengte fire eksterne biblioteker for å lage roboten vår. PID-biblioteket gjør det enkelt å beregne P-, I- og D-verdier. LMotorController-biblioteket brukes til å styre to motorer med L298N-modulen. I2Cdev-biblioteket og MPU6050_6_Axis_MotionApps20-biblioteket er designet for å lese data fra MPU6050. Du kan laste ned koden inkludert biblioteker i dette depotet.

#inkludere #inkludere #include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE #inkluder "Wire.h" #endif #define MIN_ABS_SPEED 20 MPU6050 mpu; // MPU-kontroll/status vars bool dmpReady = usant; // satt sant hvis DMP init var vellykket uint8_t mpuIntStatus; // inneholder faktisk avbruddsstatusbyte fra MPU uint8_t devStatus; // returner status etter hver enhetsoperasjon (0 = suksess, !0 = feil) uint16_t packetSize; // forventet DMP-pakkestørrelse (standard er 42 byte) uint16_t fifoCount; // telling av alle byte for øyeblikket i FIFO uint8_t fifoBuffer; // FIFO-lagringsbuffer // orientering/bevegelse vars Quaternion q; // quaternion container VectorFloat gravity; // gravitasjonsvektor flyte ypr; // yaw/pitch/roll beholder og gravitasjonsvektor //PID dobbel originalsettpunkt = 173; dobbelt settpunkt = originalsettpunkt; double movingAngleOffset = 0,1; dobbel inngang, utgang; //juster disse verdiene for å passe til ditt eget design dobbel Kp = 50; dobbel Kd = 1,4; dobbel Ki = 60; PID pid(&inngang, &utgang, &settpunkt, Kp, Ki, Kd, DIRECT); dobbel motorSpeedFactorLeft = 0,6; dobbel motorSpeedFactorRight = 0,5; //MOTORKONTROLL int ENA = 5; int IN1 = 6; int IN2 = 7; int IN3 = 8; int IN4 = 9; int ENB = 10; LMotorController motorController(ENA, IN1, IN2, ENB, IN3, IN4, motorSpeedFactorLeft, motorSpeedFactorRight); volatile bool mpuInterrupt = usant; // indikerer om MPU-avbruddsstiften har gått høyt void dmpDataReady() ( mpuInterrupt = true; ) void setup() ( // join I2C bus (I2Cdev-biblioteket gjør ikke dette automatisk) #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE Wire.begin( ); TWBR = 24; // 400kHz I2C-klokke (200kHz hvis CPU er 8MHz) #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE Fastwire::setup(400, true); #endif mpu.initialize(); devdStatus = mpitialize.(); devdStatus = mpitialize.(); // oppgi dine egne gyroforskyvninger her, skalert for min følsomhet mpu.setXGyroOffset(220); mpu.setYGyroOffset(76); mpu.setZGyroOffset(-85); mpu.setZAccelOffset(1788); // 1688 fabrikkstandard for testen min chip // sørg for at den fungerte (returnerer 0 i så fall) if (devStatus == 0) ( // slå på DMP, nå som den er klar mpu.setDMPEnabled(true); // aktiver Arduino avbruddsdeteksjon attachInterrupt(0 , dmpDataReady , RISING); mpuIntStatus = mpu.getIntStatus(); // sett DMP Ready-flagget vårt slik at hovedloop()-funksjonen vet at det er greit å bruke den dmpReady = true; // få forventet DM P-pakkestørrelse for senere sammenligning packetSize = mpu.dmpGetFIFOPacketSize(); //oppsett PID pid.SetMode(AUTOMATISK); pid.SetSampleTime(10); pid. SetOutputLimits(-255, 255); ) else ( // FEIL! // 1 = innledende minneinnlasting mislyktes // 2 = DMP-konfigurasjonsoppdateringer mislyktes // (hvis den kommer til å gå i stykker, vil vanligvis koden være 1) Serial.print(F("DMP-initialisering mislyktes (kode ")); Serial.print(devStatus); Serial.println(F(")")); ) ) void loop() ( // hvis programmeringen mislyktes, ikke prøv å gjøre noe hvis (!dmpReady) ) return; // vent på MPU-avbrudd eller ekstra pakke(r) tilgjengelig mens (!mpuInterrupt && fifoCount< packetSize) { //no mpu data - performing PID calculations and output to motors pid.Compute(); motorController.move(output, MIN_ABS_SPEED); } // reset interrupt flag and get INT_STATUS byte mpuInterrupt = false; mpuIntStatus = mpu.getIntStatus(); // get current FIFO count fifoCount = mpu.getFIFOCount(); // check for overflow (this should never happen unless our code is too inefficient) if ((mpuIntStatus & 0x10) || fifoCount == 1024) { // reset so we can continue cleanly mpu.resetFIFO(); Serial.println(F("FIFO overflow!")); // otherwise, check for DMP data ready interrupt (this should happen frequently) } else if (mpuIntStatus & 0x02) { // wait for correct available data length, should be a VERY short wait while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount(); // read a packet from FIFO mpu.getFIFOBytes(fifoBuffer, packetSize); // track FIFO count here in case there is >1 pakke tilgjengelig // (dette lar oss umiddelbart lese mer uten å vente på et avbrudd) fifoCount -= packetSize; mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); input = ypr * 180/M_PI + 180; ) )

Kp, Ki, Kd-verdier fungerer kanskje ikke. Hvis de ikke gjør det, følg trinnene ovenfor. Merk at helningen i koden er satt til 173 grader. Du kan endre denne verdien hvis du vil, men merk at dette er vinkelen roboten må støtte. Hvis motorene dine er for raske, kan du justere verdiene for motorSpeedFactorLeft og motorSpeedFactorRight.

Det er alt for nå. Ser deg.

Det er veldig enkelt å lage forskjellige biler med fjernkontroll, enkle sensorer og logikk på Arduino. Derfor er denne linjen utrolig populær. Mange kompatible sensorer og utvidelseskort selges. Internett er fylt med ferdige programvarebiblioteker og åpen kildekode-prosjekter for alle anledninger. Nesten alle spørsmålene du vil ha i prosessen med å mestre Arduino har allerede blitt stilt av noen, og du vil alltid finne svaret.

La oss begynne med noe, skal vi? Hovedspørsmålet er valg av kontroller. Det er mange revisjoner av Arduino, så vel som tredjepartskloner bygget fra disse revisjonene. Her er kanskje de to mest interessante timene for oss:

Arduino Uno er det beste valget for en nybegynner, det enkleste, rimeligste og mest vanlige brettet. Den er basert på en ATmega328-brikke med en klokkefrekvens på 16 MHz, 32 KB flashminne, 2 KB RAM og 1 KB EEPROM. Uno har 14 digitale innganger/utganger som kan brukes til å styre sensorer og servoer og andre enheter;

Arduino Mega / Mega 2560 er et brett som vil komme godt med når du på forhånd vet at prosjektet blir vanskelig. Hovedforskjellen er flere innganger/utganger (48 i Mega, 54 i Mega 2560). Det er også mye mer minne her: 8 KB RAM, 4 KB EEPROM og flashminne på 128 og 256 KB (i henholdsvis Mega og Mega 2560). Innbyrdes skiller brettene seg også i chip, USB-hastighet og noen andre egenskaper.

Selvfølgelig er det også Arduino Pro, Arduino LilyPad og mange andre. Men la oss nå fokusere på de to første modellene. I vårt tilfelle er alt ganske enkelt: Mega er nødvendig for en robot med mange ben.

Første kode

La oss først installere Arduino IDE (arduino.cc) - dette er et gratis utviklingsmiljø på tvers av plattformer. Nå, hvis vi kobler til Arduinoen vår, kan vi prøve å skrive den første koden på det enkleste eksemplet: det blinkende LED-programmet. De fleste Arduino-kontrollere har det og er koblet til pin 13. Forresten, i Arduino-verdenen kalles programmer ofte skisser. Her er teksten til skissen med kommentarer:

// Gi denne pinnen navnet LED: const int LED = 13; void oppsett() ( // Initialiser digital pin // for utgang: pinMode(LED, OUTPUT); ) void loop() ( // Sett logic-one nivå // til pinne 13 (lys LED): digitalWrite(LED, HIGH ) ; // Pause skissen // i et sekund: delay(1000); // Bruk et logisk nullnivå // på pinne 13 (slå av LED): digitalWrite(LED, LOW); // Pause skissen igjen et sekund: delay(1000); )

Legg merke til oppsettet og loop-funksjonene. De må være til stede i enhver Arduino-skisse. Oppsettet kalles én gang når kontrolleren slås på eller etter at kontrolleren er startet på nytt. Hvis du vil at koden kun skal kjøres én gang, bør den plasseres her. Oftest er dette alle slags initialiseringsprosedyrer for noe. Skissen vår er intet unntak: Arduino digitale pinner kan fungere som både innganger og utganger. I oppsettfunksjonen sier vi at pin 13 vil fungere som en digital utgang på kontrolleren.

Etter at oppsettsfunksjonen har fullført arbeidet, startes automatisk en lukket sløyfe, der sløyfefunksjonen kalles opp. Vi er pålagt å skrive hva vi vil gjøre der. Og vi vil bruke et logisk ett-nivå (5 V) til pinne 13, det vil si tenne LED-en, deretter vente ett sekund (1000 i millisekunder), deretter bruke et logisk null-nivå (0 V) og vent igjen ett sekund. Neste call to loop vil gjenta alt.

Nå "laster" vi opp skissen vår til kontrolleren. Nei, vi trenger ingen programmerer. Arduino-kontrollere, i tillegg til skissene våre, inneholder et spesielt program - bootloader, som spesielt kontrollerer lasting av kode fra en datamaskin. Så for å laste opp skissen trenger vi bare en USB-kabel og menypunktet Fil → Last opp (Ctrl + U) i Arduino IDE.

nøkkelspørsmål

Hvor mange ben trenger vi egentlig? La oss definere i en rekke konfigurasjoner av gåroboter. Etter antall ben:

tobent - tobent (prototype - mann);
firbeint - firbent (prototype - de fleste pattedyr);
hexapod - seksbenet (prototype - de fleste insekter);
blekksprut - åttebent (prototype - edderkopper, skorpioner, krabber og andre leddyr).

I tillegg til antall ben er konfigurasjonen av hver også viktig. Hovedkarakteristikken til beinet er antall frihetsgrader, eller frihetsdimensjoner (DOF). Frihetsgraden er evnen til å rotere eller bøye seg rundt en akse (sjeldnere, for å bevege seg fremover langs den). Det er klart, hvis det bare er én grad av frihet, så kommer du ikke langt på et slikt ben. Ben med to frihetsgrader (2DOF) lar allerede flerbeinte roboter bevege seg, selv om 2DOF tillater fri bevegelse av tuppen av beinet i bare ett plan. Og 3DOF-benet beveger "foten" i 3D-rom (med mindre, selvfølgelig, alle tre aksene er parallelle). Det finnes også 4DOF-ben som ganske enkelt øker fleksibiliteten og bevegelsesområdet til benet. Insekter har oftest 4DOF-ben.

Hva betyr dette for oss? I billige amatørroboter implementeres hver frihetsgrad av én motor, mer presist, en servodrift eller serv. Konfigurasjonen av bena bestemmer unikt hvor mange av disse servoene som trengs. Så en 3DOF hexapod ville kreve 18 servoer, og en 4DOF edderkopp ville kreve 32. Ikke la deg skremme av tallene, de små servoene som brukes i amatør RC-modeller er veldig billige. I nettbutikker kan de bli funnet på forespørsel mikroservo.

For å programmere servoer er det nok å vite at de allerede har en kontroller som gjør hovedarbeidet. Og alt som trengs er å levere strøm og et digitalt signal som forteller kontrolleren i hvilken posisjon vi vil dreie drivakselen. Det er lett å finne informasjon om designet deres. Protokollen deres er den enkleste av alle digitale kommunikasjonsprotokoller: pulsbreddemodulasjon - PWM (PWM på engelsk). Alle enkle servoer har en tre-pinners kontakt: jord, +5V (spenning kan variere avhengig av størrelse og effekt) og en signalinngang. Arduino-kontrollere kan generere dette signalet på to forskjellige måter. Den første er hardware PWM, som brikken selv kan sende ut på flere av sine digitale I/O-pinner. Den andre er programvare. Programvare lar deg motta flere forskjellige PWM-signaler samtidig enn maskinvare. En praktisk innpakning er gitt for den under Arduino - Servo-biblioteket. Den lar deg bruke 12 servoer samtidig på de fleste små kontroller (Uno, Due, Nano) og 48 servoer på Arduino Mega og lignende. Signalpinnen til servoen er koblet til den digitale pinnen til Arduino. Jord og kraft - åpenbart, til jord og kraft, de kan deles av alle servoer. I tretråds servoløkker er svart eller brunt jordet, vanligvis rød +5 V i midten, og til slutt hvit eller gul er signal. Fra et programvaresynspunkt er kontrollen ekstremt enkel:

Servo myservo; // Servo på Arduino pin 9 myservo.attach(9); // Roter til posisjon 90º myservo.write(90);

De fleste servoer kan rotere akselen 180°, og for dem er 90° midtposisjon. For å forenkle tilkoblingen av servoer til Arduino-kortet finnes det en rekke løsninger. Den mest kanoniske er Sensors Shield. Ved å installere den på Uno og levere strøm til terminalene for servoene, kan du koble kontaktene direkte til den.

Batteri

En annen viktig sak er ernæring. Hvis du har et avansert brett som lar deg forsyne hele systemet gjennom én kraftlinje (og servomotorene vil ikke forstyrre driften av kontrolleren), så kan du klare deg med én kilde. Utvalget er stort, best av alt, selvfølgelig, Li-Ion / Li-Po-briketter for radiomodeller. Men de trenger også passende ladere. Hvis du har en enklere kontroller (Uno / Due / Nano), så kan du strømme den separat, for eksempel med en 9-volts Krona, og koble servoene til det kraftige hovedbatteriet. Så servoene vil definitivt ha nok kraft. Når det gjelder litiumbatterier, må du overvåke spenningen enda mer nøye enn vanlig, slik at det ikke er overutladning (tillatte spenninger bør avklares for en bestemt type batteri). For å gjøre dette skrus også et lite digitalt voltmeter på Sleipnir-roboten, som vil bli diskutert videre.

Robobug gjør det selv

Sett

Arduino Uno-kontroller: 1150 rubler
Tre servomotorer. Jeg brukte HXT500, 200 r. et stykke
Batterirom for "Krona" med en bryter: 50 rubler.
Batteri "Krona": 145 rubler.
IR-mottaker: $90
Ståltråd med en diameter på ca. 1,5 mm. Jeg brukte for eksempel en knust eggevisper

Totalt: 2035 s.

DmitryDzz: Jeg vil invitere deg til å lage en liten fjernstyrt seksbeint robotbille basert på Arduino Uno-kontrolleren. Potene vil ha én frihetsgrad, kontrollen vil foregå ved hjelp av en konvensjonell TV-fjernkontroll.

Jeg må si at dette er prisene på dyre Moskva-butikker. I kinesiske nettbutikker vil alt dette koste to ganger billigere. Vurderer frakt. Det er sant at du må vente, etter min erfaring, fra to uker til tre måneder.

En enklere måte er å ta et konstruktørsett, fordi i de første trinnene vil ikke én kontroller være nok. Nå tilbyr mange butikker slike sett. For eksempel er det en fantastisk nettbutikk "Amperka". Her vil du bli tilbudt flere lignende designere, forskjellige i fylde og selvfølgelig i pris. Det enkleste var nok for meg - "Matryoshka X". Den inkluderer en Arduino Uno-kontroller, en USB-kabel for tilkobling til en datamaskin, et prototyping-kort (en uunnværlig ting!), et sett med jumpere, lysdioder, motstander og andre småtterier.

I samme butikk er det en "Wiki"-seksjon, hvor du til og med finner fantastiske korte videoopplæringer oversatt til russisk. Sørg for å sjekke dem ut. Og selvfølgelig er det et forum hvor de sannsynligvis vil prøve å hjelpe deg.

Dette trenger du av verktøyene:

loddebolt og alt du trenger til lodding. Du trenger ikke å lodde mye, og du trenger ikke mye dyktighet;
varm limpistol og stenger til den;
tang for arbeid med ledning.

Hvis du har alt, la oss komme i gang!

Kontroll

La oss gå videre til det første trinnet: vi må lære å samhandle med fjernkontrollen og finne ut kodene for å trykke på noen av knappene. Disse kodene vil da være nyttige for robotkontrollskissen.

På dette stadiet vil du også trenge en IR-mottaker, og det ville være fint å ha et prototypingbrett. De aller fleste IR-fjernkontroller opererer ved bærefrekvenser på 36 kHz, 38 kHz eller 40 kHz (Panasonic, Sony). Unntakene er Sharp (56 kHz), Bang & Olufsen (455 kHz), og kanskje noen andre mer eksotiske. Derfor passer enhver IR-mottaker på 36, 38 eller 40 kHz ganske godt for oss. Frekvensen samsvarer kanskje ikke nøyaktig med bærefrekvensen til signalet. I dette tilfellet vil følsomheten til mottakeren avta, men i praksis merket jeg ikke noe ubehag ved å bruke TSOP2136 IR-mottakeren (36 kHz - de to siste sifrene - frekvens) og Sony-fjernkontrollen (40 kHz).

Så IR-mottakere TSOP21xx, TSOP22xx, TSOP312xx passer for de fleste fjernkontroller. De to siste sifrene kan være 36, 37, 38 eller 40. Før du slår på IR-mottakeren, sjekk pinouten til pinnene - det er bare tre av dem: + 5V (strøm), GND (jord), Vs (utgang) . La oss sette sammen kretsen, som i illustrasjonen (kabling for TSOP2136).

Som du kan se, koblet vi utgangen til IR-mottakeren til den analoge inngangen til A0-kontrolleren.

Slik ser skissekoden ut:

#include "IRremote.h" // Analog inngang til kontrolleren // som IR-mottakeren er koblet til: const int IR_PIN = A0; // Lag et IR-mottakerobjekt: IRrecv irrecv(IR_PIN); void setup() ( Serial.begin(9600); Serial.println("klar"); // Begynn å lytte til IR-signaler: irrecv.enableIRIn(); ) void loop() ( // Beskriv strukturresultatene, / / hvor // mottatt og dekodet // IR-kommandoer vil bli plassert: decode_results results; // Hvis IR-kommandoen er akseptert og // vellykket dekodet, må du sende // den mottatte koden til // serieporten til kontrolleren: if ( irrecv.decode (&results)) ( Serial.println(results.value); irrecv.resume(); ) )

Skissen bruker et spesielt bibliotek IRremote.h, som dekoder signalene til ulike IR-fjernkontroller. Dette biblioteket er et åpent prosjekt, du kan laste det ned fra https://github.com/shirriff/Arduino-IRremote. Og for å koble den til prosjektet vårt, må du utføre tre trinn:

kopier bibliotekskatalogen til bibliotekkatalogen, som igjen er plassert i Arduino IDE-installasjonskatalogen;
start IDE på nytt;
legg til linjen #include "IRremote.h" i begynnelsen av skissen vår.

Nå vil IR-dekodingsfunksjonene være tilgjengelige i skissen. Men for å se de resulterende kodene, vil vi fortsatt bruke serieobjektet. Med dens hjelp, via den serielle porten (samme USB-kabel), vil vi overføre kodene til datamaskinen. I oppsettfunksjonen initialiserer vi serieobjektet. "9600" er 9600 baud - hastigheten som vil bli brukt for dataoverføring. Etter initialisering kan vi skrive til serieporten ved å bruke println-funksjonen. For å se resultatet av denne utgangen på datamaskinen i Arduino IDE, velg menyelementet Verktøy → Serial Monitor (Ctrl + Shift + M). Bare sørg for at den er satt til 9600 baud.

Så kontrolleren mottar strøm via en USB-kabel, og overfører data via den. Vi laster inn skissen, starter seriemonitoren og begynner å trykke på knappene på fjernkontrollen. Koder skal vises i vinduet Serial Monitor. Fjernkontrollprotokoller er forskjellige, noen ganger kan det være én kode, noen ganger flere. Uansett kan du alltid tildele koder som er unike for hver knapp på fjernkontrollen.

Vi trenger 13 fjernkontrollknapper. Jeg brukte følgende:

1 - jevn sving til venstre;
2 - gå fremover;
3 - jevn sving til høyre;
4 - ta til venstre på stedet;
5 - stopp;
6 - ta til høyre på stedet;
7 - bevegelse tilbake med en sving til høyre;
8 - bevegelse bakover;
9 - bevegelse tilbake med en sving til venstre;
blå knapp - veldig sakte;
gul - sakte;
grønn - rask;
rød - veldig rask.

Skriv ned kodene for disse knappene, du trenger dem senere for robotkontrollskissen.

Bevegelsesalgoritme

Robotkontrollskissen er tilgjengelig på vår prosjektside (bit.ly/1dEwNDC). Ikke glem å endre verdiene til konstantene til kodene til de trykket fjernkontrollknappene til kodene til fjernkontrollen (IR_COMMAND_XXX_CODES-konstantene i filen ir_command_codes.h).

Vi vil ikke analysere skissen i detalj, jeg tror kommentarer i koden er nok, men ett spørsmål er likevel verdt å vurdere.

Insekts bevegelser er veldig interessante. Og selv om alle disse billene faller veldig nær bakken, er de av en eller annen grunn alltid stabile: til enhver tid står minst tre ben (to på den ene siden og en på den andre) på overflaten. Og mens disse bena trekker billen mot et av dens drevne mål, trekkes de tre andre opp for å gjenta denne bevegelsen. Målet vårt er å gjøre noe lignende.

Vår robotbug har tre servomotorer arrangert på rad vinkelrett på bevegelsen. For venstre og høyre servomotor er akselaksen rettet oppover, og for den sentrale er den fremover. Oppgaven til venstre servo er for eksempel å pumpe to ben på en gang: venstre foran og venstre bak. Forresten, de er stivt sammenkoblet og limt til vippen til denne servoen. Oppgaven til den sentrale servoen er å løfte venstre side av billen, deretter høyre. Derfor er de sentrale venstre og høyre bena festet til vippen til denne motoren, som er en enkelt U-formet del.

Skissen skal sikre at roboten beveger seg fremover, bakover, jevne svinger i bevegelse og svinger på plass. Og jeg vil også gjerne kontrollere hastigheten til billen. For å beskrive disse bevegelsene programmatisk trenger vi matematikk. Se på diagrammet.

De blå sirklene indikerer bena til robotbillen som står på overflaten, og de hvite sirklene er de i luften. Vær oppmerksom på at når du beveger deg fremover eller bakover, må venstre og høyre servomotor bevege seg nøyaktig samme vei. Og når de snur på plass, skal motorene snurre i forskjellige retninger (symmetrisk). Det er også interessant at forover- og bakoverbevegelsen bare skiller seg i fasen av den sentrale servomotoren.

Så hvordan implementeres det? Vi husker at kontrolleren hele tiden kaller loop-funksjonen. Så, i denne funksjonen må vi sette koden som bestemmer den nåværende posisjonen til servoene og setter dem til denne posisjonen. Hver servomotor må oscillere. Vi kan beregne posisjonen til servomotoren på tidspunktet t ved å bruke følgende formel:

X = A sin(2πt/T),

hvor X er den ønskede posisjonen til servomotoren, A er oscillasjonsamplituden, T er oscillasjonsperioden.

Så, avhengig av tidspunktet t, vil vi få en endring i verdien av X i området fra -A til +A. Servomotorene kan ta stilling i området fra 0 til 180°. Derfor er det bedre for oss å svinge rundt "null" -posisjonen ved 90 °. Og hvis vi ønsker å gi oscillasjoner med en periode på 1 s rundt posisjonen 90 ° med en amplitude på 30 °, blir formelen konvertert til følgende form:

X = 90 + 30 sin(2πt/1000),

der t er tiden i millisekunder siden starten av svingningen. For å kontrollere hastigheten på robocall, kan vi endre oscillasjonsperioden. Jo større den er, jo lavere hastighet.

Og la oss nå gå tilbake til ordningen vår igjen, fordi formelen skrevet ovenfor er ennå ikke fullført. Hvordan sikre at den synkrone, så motsatt bevegelse av venstre og høyre servomotor? Hvordan endre fasen til den sentrale servomotoren? Vi må legge til oscillasjonsfasen til formelen vår. Forskyvning av sinusargumentet med π for for eksempel høyre motor vil få den til å fungere i motfase til den venstre, det vil si måten vi må svinge på plass. Slik ser formelen vår ut nå:

X = 90 + 30 sin(2πt/1000 + Φ),

hvor Φ er fasen til svingningene, er verdien fra 0 til 2π.

Se på tabellen for å forstå hva oscillasjonsfasene til servomotorene skal være for hver type bevegelse.

montering

La oss nå sette sammen roboten på prototypebrettet og fylle ut kontrollskissen.

Dette er et veldig viktig trinn før montering. Prøv å koble fra USB-kabelen og få strøm til oppsettet fra Krona-batteriet. Sjekk alle faser av bevegelsen og sørg for at alt fungerer. Etter å ha satt sammen roboten, vil det være vanskeligere å endre noe (for eksempel å erstatte en ødelagt servomotor).

La oss nå gå videre til selve forsamlingen. Hovedlagerelementet er batterirommet. Jeg anbefaler deg å bruke et lukket rom og alltid med en bryter.

Den enkleste måten å fikse detaljene til billen på er med varmt lim. Start med servomotorer. Fjern unødvendige festeører og koble bilene sammen. Lim deretter denne sammenstillingen av tre "servoer" til batteridekselet. Ikke glem at batterirommet må åpnes fritt for å skifte batteri.

Den enkleste måten er å lime kontrolleren til bukten, men jeg liker egentlig ikke dette alternativet, siden jeg må gi Arduino Uno til feilen for alltid. Derfor kan du komplisere livet ditt og bruke Arduino-kontaktene til å feste batterirommet. Lim en pinnekobling på bunnen av rommet med en stigning på 2,54 mm mellom pinnene. Den skal plasseres slik at den går inn i kontrollerkontakten i området for digitale utganger 8-11. Vi trenger dem fortsatt ikke uansett. Hvis kontakten ikke er for hånden, vil en U-formet buet binders gjøre det.

Ledningene som kommer fra batterirommet må kobles til Vin-terminalene og GND ved siden av. Ikke snu polariteten! Pluss «Krona» på Vin, minus på GND. For å sikre pålitelig kontakt av ledningene med Arduino-kontaktene, kan du ganske enkelt tinne tuppen av ledningen tykkere, men jeg brukte en kort binders som en plugg. Og stedet for lodding ble lukket med varmekrympeslange.

Kontaktene fra servokablene skal kuttes, strømledningene (+5 V - vanligvis rød og GND - svart eller brun) skal kombineres og kobles til 5V-kontaktene og den tilstøtende GND på kontrolleren. Vi kobler til litt senere. Styresignalledningene (vanligvis gule) sendes ut til de digitale utgangene til kontrolleren: venstre servomotor er på pinne 2, den midtre er på pinne 4, den høyre er på pinne 7.

"+" og "-" til IR-mottakeren kan ganske enkelt kobles til Arduino-kontakten (5V og tilstøtende GND). Det er sant at de bøyer seg i to og dobler tykkelsen. Vi lodder de tidligere tilkoblede strømledningene til servomotorene til de samme kraftbenene til IR-mottakeren. Det er usannsynlig at signalutgangen til IR-mottakeren når den analoge inngangen til A0-kontrolleren, og du må øke den med en ledning.

Noen tips for å lage ben. Forbered først venstre og høyre "front-back" ben. Pass på at de er symmetriske (vær oppmerksom på både lengdene og vinklene på bøyene). Start liming av bena først etter å ha kontrollert at servomotorene er satt til "null"-posisjon (90°).

Plasser det midterste benparet sist. Jeg anbefaler deg å først gjøre de midterste bena lengre, og deretter etter installasjonen, kutte dem til ønsket lengde. I "null"-posisjon skal alle seks føttene være på overflaten. Rullingen av de midtre bena med en amplitude på 15° skal ikke forstyrre svingene foran og bak.

Hva blir det neste?

Robobug er en ferdig mobilplattform basert på en av de mest populære og rimelige kontrollerene. Prosjektet er åpent: https://github.com/beetle-ringo/arduino . Lag en gaffel (gren) i GitHub og legg til funksjonaliteten din. La fantasien løpe løpsk - legg til en IR-LED og roboten er klar for robotkamp. Koble til avstandsmålere, taktile sensorer, et gyroskop... Lær roboten å omgå hindringer eller gå langs en linje, prøv å installere et webkamera på den. Det kan være en million ideer, og du kan alltid velge den mest interessante.

Robot Sleipnir

Sett

Arduino Uno Dagu Spider Robotkontroller: 2530 r.
Servodrev SG90 9g (16 stk) 1150 р.
LiPo batteripakke, 7,4 V, 1800 mAh $4,99
Radiomodul 4 Pins Bluetooth RF-sender/mottaker 270 р.
Spenningsindikator (valgfritt) DC 3,3-30V rød LED-panelmåler $100
Aluminium hjørne. I det nærmeste byggemarkedet 135 rubler.
Bolter og muttere. På nærmeste loppemarked 35 rubler.

Totalt: 4710 r.

*Komponenter ble kjøpt på forskjellige tidspunkter og mange posisjoner kan optimaliseres

poconoco: La oss prøve å sette sammen en ikke-standard konfigurasjon - en åttebent 2DOF-robot. 2DOF-ben er mye lettere å programmere, pluss at jeg har en haug med ubrukte servoer på lager. Og viktigst av alt, det vil være mulig å navngi den til ære for den åttebeinte hesten til guden Odin Sleipnir (alltid drømt om!).

Vår Sleipnir vil ha fire ben med to hengsler på hver side. Hvert ledd er en servo, så åtte servoer per side. For enkelhets skyld vil alle åtte hengslene på den ene siden av hesten rotere i samme plan. Selv om dette slett ikke er nødvendig. Dessuten, hvis bena på den ene siden legges i litt "sjakk" slik at to tilstøtende ben ikke kan berøre hverandre, vil det bli enda bedre, det vil tillate deg å ta et bredere skritt og galoppere.

En ryddig og funksjonell, men langt fra den billigste løsningen er å bruke et ikke-standard kontrollerkort, optimalisert for tilkobling av servoer i stort antall. Jeg kom over en Dagu Spider Robot Controller - dette er den samme Arduino Mega, men på et brett med forhåndsloddede 3-pinners pin-kontakter, hvor du umiddelbart kan koble til de samme 48 servoene uten noen skjold. Ideell for flerbeinte Arduino-roboter.