Inimesed alustavad Arduino õppimist lihtsate robotite loomisega. Täna räägin Arduino Uno kõige lihtsamast robotist, mis nagu koer järgib teie kätt või muud infrapunavalgust peegeldavat objekti. See robot lõbustab ka lapsi. Minu 3-aastane õepoeg mängis innukalt robotiga :)

Alustan osade loetlemisest, mida ehituse käigus vaja läheb - Arduino UNO;

Infrapuna kaugusmõõdikud;

-3-voldised mootorid koos käigukastide ja ratastega;

- pistikud 3A akude jaoks;

-aku (kui akusid pole piisavalt);

-releed mootorite juhtimiseks;

Noh, ja muud materjalid, mida loomisprotsessis vaja läheb.
Kõigepealt valmistame aluse. Otsustasin teha selle puidust. Puuplangu saagisin nii, et mootorid sobiksid ideaalselt piludesse

Seejärel kinnitan mootorid puidust ribaga, kruvides selle riba

Järgmisena asetasin kerele arduino, relee, Bradboardi, kaugusmõõturid ja pöörleva šassii aluse alla

Nüüd ühendame kõik vastavalt skeemile

Lõpuks laadige Arduinosse üles järgmine visand:

Const int R = 13; //kontaktid, mille külge on ühendatud IR kaugusmõõturid const int L = 12; sisemootor L = 9; //kontaktid, millega relee on ühendatud in motorR = 11; int buttonState = 0; void setup() ( pinMode(R,INPUT); pinMode(L,INPUT); pinMode(mootorR,OUTPUT); pinMode(mootorL,VÄLJUND); ) void loop() ( ( nupuOlek = digitaalne lugemine(L); if (nupu olek) == HIGH)( digitalWrite(mootorR,HIGH); ) else ( digitalWrite(mootorR,LOW); ) ) (( nupuOlek = digitaalneRead(R); if (nupuOlek == HIGH)( digitalWrite(mootorL,HIGH); ) else ( digitalWrite(mootorL,LOW); ) ) )

Toimimispõhimõte on väga lihtne. Vasakpoolne kaugusmõõtur vastutab parema ratta eest ja parempoolne vasaku ratta eest

Et asi selgem oleks, saab vaadata videot, mis näitab loomisprotsessi ja roboti tööd

See robot on väga lihtne ja sellega saab hakkama igaüks. See aitab teil mõista moodulite (nt releed ja IR-kaugusmõõturid) tööpõhimõtteid ja nende parimat kasutamist.

Loodan, et teile meeldis see käsitöö, pidage meeles, et käsitöö on lahe!

Tulemuseks on üsna naljakas robot, mis näeb ette takistusi, analüüsib olukorda ja seejärel, olles valinud parima marsruudi, liigub edasi. Robot osutus väga manööverdatavaks. Seda saab pöörata 180 kraadi ja pöördenurk on 45 ja 90 kraadi. Autor kasutas peamise kontrollerina Iteaduinot, mis on Arduino analoog.

Materjalid ja tööriistad roboti valmistamiseks:
- mikrokontroller (Arduino või sarnane Iteaduino);
- ultraheliandur;
- patareihoidja;
- Hiina mänguasjad teljevahe loomiseks (saate osta valmis);
- traadilõikurid;
- liim;
- juhtmed;
- mootorid;
- puitkiudplaat;
- pusle;
- transistorid (D882 P).

Roboti tootmisprotsess:

Esimene samm. Teljevahe loomine
Teljevahe loomiseks ostis autor kaks hiinlast mänguautod. Siiski ei pea te selle pärast muretsema, kui teil on lisaraha, sest saate osta valmis aluse. Traadilõikurite abil lõigati autod kaheks, et moodustada kaks veotelge. Seejärel liimiti need osad kokku. Kuid sel juhul võite kasutada ka jootekolvi, plasti saab suurepäraselt joota.

Autode valimisel on kõige parem võtta tavaliste ratastega mänguasju, kuna autori sõnul hüppab robot selliste naeltega nagu tema.

On veel üks hetk, mil juhtmed tulevad mootoritest välja, peate meeles pidama polaarsuse muutmist.

Teine samm. Ülemise katte valmistamine
Roboti pealmine kate on valmistatud puitkiudplaadist; Kattes näete ristkülikukujulist auku, mis peaks asuma nii, et sellesse sisestatava servoajami telg asetseks sümmeetriliselt. Mis puudutab auku keskel, siis sealt tulevad juhtmed välja.

Kolmas samm. Roboti täidis
Šassii ühendamiseks on kõige parem kasutada eraldi toiteallikat, kuna kontroller vajab selle toiteks 9 V, samas kui mootorid vajavad ainult 3 V. Üldiselt on selliste masinate šassiidesse juba sisse ehitatud akuhoidikud, need tuleb lihtsalt paralleelselt ühendada.

Mootorid ühendatakse kontrolleriga D882 P transistoride abil. Need tõmmati välja vana masina juhtpaneelilt. Parim on muidugi kasutada jõutransistore nagu TIP120B, kuid autor valis lihtsalt sobivad omadused. Kõik elektroonilised osad on ühendatud vastavalt näidatud skeemile.

Pärast roboti püsivara vilkumist on see testimiseks valmis. Selleks, et robotil oleks aega teatud nurga all pöörata, tuleb valida mootoritele õige tööaeg.

Mis puudutab andureid, siis ultraheli tuleb ühendada mikrokontrolleri 7. digitaalse väljundiga. Servo mootor on ühendatud 3. digitaalsisendiga, vasakpoolse mootori transistori alus on ühendatud 11 viiguga ja parempoolse 10-ndaga.

Kui Kronat kasutatakse toiteallikana, ühendatakse miinus GND-ga ja pluss VIN-iga. Samuti peate ühendama transistori emitteri ja negatiivse kontakti roboti šassii toiteallikast GND-ga.

Arduinoga on väga lihtne teha erinevaid masinaid Pult, lihtsad andurid ja loogika. Sellepärast on see rida uskumatult populaarne. Müüakse palju ühilduvaid andureid ja laiendusplaate. Internet on täis valmis tarkvarateeke ja avatud lähtekoodiga projekte igaks juhuks. Peaaegu kõik küsimused, mis teil Arduino õppimise käigus tekivad, on keegi juba esitanud ja vastuse leiate alati.

Alustame kuskilt? Põhiküsimus on kontrolleri valik. Arduino versioone on palju, aga ka nende versioonide peale ehitatud kolmandate osapoolte kloone. Siin on ehk kaks meie jaoks kõige huvitavamat klassi:

• Arduino Uno - parim valik algajale kõige lihtsam, eelarveline ja levinum tahvel. See põhineb ATmega328 kiibil, mille taktsagedus on 16 MHz, 32 KB välkmälu, 2 KB RAM ja 1 KB EEPROM. Unol on 14 digitaalset sisendit/väljundit, mida saab kasutada andurite ja servode ning muude seadmete juhtimiseks;

• Arduino Mega / Mega 2560 on plaat, mis sobib siis, kui tead ette, et projekt saab olema keeruline. Peamine erinevus on suurem sisendite/väljundite arv (Mega puhul 48, Mega 2560 puhul 54). Mälu on ka palju rohkem: 8 KB RAM, 4 KB EEPROM ning välkmälu 128 ja 256 KB (vastavalt Mega ja Mega 2560 puhul). Plaadid erinevad üksteisest ka kiibi, USB kiiruse ja mõne muu omaduse poolest.

Loomulikult on olemas ka Arduino Pro, Arduino LilyPad ja paljud teised. Kuid praegu keskendume kahele esimesele mudelile. Meie puhul on kõik üsna lihtne: Mega on vajalik roboti jaoks suur summa jalad

Esimene kood

Kõigepealt installime Arduino IDE (arduino.cc) – see on platvormideülene tasuta arenduskeskkond. Nüüd, kui ühendame oma Arduino, võime proovida kirjutada esimene kood lihtne näide: LED vilkuv programm. Enamikul Arduino kontrolleritel on see olemas ja need on ühendatud viiguga 13. Muide, Arduino maailmas nimetatakse programme tavaliselt sketšideks. Siin on visandi tekst koos kommentaaridega:

// Anname sellele tihvtile nimetuse LED: const int LED = 13; void setup() ( // Initsialiseerige digitaalne viik // väljundiks: pinMode(LED, OUTPUT); ) void loop() ( // Rakendage viigule 13 loogiline üks tase // (valgusdioodi valgustamine): digitalWrite(LED) , HIGH) // Pause visandi täitmine // sekundiks: delay(1000) // Rakenda loogika nulltase // viigule 13 (lülita välja LED): digitalWrite(LED, /); / Peata visandi täitmine // sekundiks: delay(1000);

Pöörake tähelepanu seadistus- ja tsüklifunktsioonidele. Need peavad olema kõigis Arduino visandites. Seadistamine kutsutakse üks kord sisselülitamisel või pärast kontrolleri taaskäivitamist. Kui soovite, et kood käivitataks ainult üks kord, peaksite selle siia paigutama. Enamasti on need kõikvõimalikud protseduurid millegi lähtestamiseks. Meie visand pole erand: Arduino digitaalsed kontaktid võivad töötada nii sisendite kui ka väljundina. Seadistusfunktsioonis ütleme, et kontakt 13 toimib kontrolleri digitaalväljundina.

Kui häälestusfunktsioon on oma töö lõpetanud, käivitatakse automaatselt suletud tsükkel, mille raames kutsutakse välja tsüklifunktsioon. Peame kirjutama, mida me seal teha tahame. Ja me tahame rakendada kontaktile 13 loogilist ühe taset (5 V), st süüdata LED, seejärel oodata üks sekund (1000 millisekundites), seejärel rakendada loogilist nulltaset (0 V) ja oodata uuesti üks sekund. Järgmine tsüklikutse kordab kõike.

Nüüd laadime oma visandi kontrollerisse. Ei, me ei vaja programmeerijat. Arduino kontrollerid sisaldavad lisaks meie visanditele ka spetsiaalset programmi - alglaadurit, mis juhib eelkõige arvutist koodi laadimist. Nii et visandi üleslaadimiseks vajame Arduino IDE-s vaid USB-kaablit ja menüükäsku Fail → Laadi üles (Ctrl + U).

Põhiküsimus

Mitu jalga me tegelikult vajame? Määratleme palju kõndivate robotite konfiguratsioone. Jalgade arvu järgi:

• kahejalgsed – kahejalgsed (prototüüp – inimene);
• neljajalgsed - neljajalgsed (prototüüp - enamik imetajaid);
• kuusjalg - kuue jalaga (prototüüp - enamik putukaid);
• kaheksajalgsed - kaheksajalgsed (prototüüp - ämblikud, skorpionid, krabid ja muud lülijalgsed).

Lisaks jalgade arvule on oluline ka nende konfiguratsioon. Peamine omadus jalad on vabadusastmete arv või vabaduse mõõtmed (DOF). Vabadusaste on võime pöörata või painutada ümber ühe telje (harvemini liikuda mööda seda edasi). Ilmselgelt, kui on ainult üks vabadusaste, siis sellise jalaga kaugele ei jõua. Kahe vabadusastme (2DOF) jalad võimaldavad juba mitmejalgsetel robotitel liikuda, kuigi 2DOF võimaldab ainult jala otsal ühes tasapinnas vabalt liikuda. Ja 3DOF-jalg liigutab “jalga” 3D-ruumis (kui muidugi pole kõik kolm telge paralleelsed). Samuti on olemas 4DOF jalad, mis lihtsalt suurendavad jala paindlikkust ja liikumisulatust. Kõige sagedamini on putukatel 4DOF jalad.

Mida see meie jaoks tähendab? Odavates amatöörrobotites realiseerib iga vabadusastme üks mootor, täpsemalt servoajam ehk serv. Jalgade konfiguratsioon määrab unikaalselt, kui palju neid servosid on vaja. Niisiis, 3DOF kuusepood vajab 18 servot ja 4DOF spider 32. Ärge kartke koguse pärast, amatöör-RC mudelites kasutatavad väikesed servod on väga odavad. Need leiate veebipoodidest, otsides mikroservo.

Servode programmeerimiseks piisab teadmisest, et neil on juba olemas kontroller, mis põhitöö ära teeb. Ja vaja on vaid toidet ja digitaalset signaali, mis annab kontrollerile teada, millisesse asendisse veovõlli pöörata tahame. Teavet nende disaini kohta on lihtne leida. Nende protokoll on kõigist digitaalsetest sideprotokollidest kõige lihtsam: impulsi laiuse modulatsioon - PWM (inglise keeles PWM). Kõigil lihtsatel servodel on pistik kolme viiguga: maandus, +5 V (pinge võib varieeruda olenevalt suurusest ja võimsusest) ja signaali sisend. Arduino kontrolleritel võib olla kaks erinevaid viise genereerida sellist signaali. Esimene on riistvaraline PWM, mida kiip ise saab väljastada mitmele oma digitaalsele I/O kontaktile. Teine on tarkvara. Tarkvara võimaldab samaaegselt vastu võtta rohkem erinevaid PWM-signaale kui riistvara. Selle jaoks on Arduino all kaasas mugav ümbris - Servo raamatukogu. See võimaldab kasutada 12 servot samaaegselt enamikul väikese suurusega kontrolleritel (Uno, Due, Nano) ja 48 servot Arduino Megal jms. Servo signaali viik on ühendatud Arduino digitaalse viiguga. Maa ja võimsus – ilmselgelt maa ja võimsusega, need võivad olla ühised kõikidele servidele. Kolmejuhtmelistes servo aasades on must või pruun lihvitud, keskel tavaliselt punane +5 V ja lõpuks valge või kollane signaal. Tarkvara seisukohast on juhtimine äärmiselt lihtne:

Servo myservo; // Servo on Arduino pin 9 of myservo.attach(9); // Pöörake 90º asendisse myservo.write(90);

Enamik servosid suudab võlli pöörata 180° ja nende jaoks on 90° keskmine asend. Servode Arduino plaadiga ühendamise lihtsustamiseks on mitmeid lahendusi. Kõige kanoonilisem on Sensors Shield. Paigaldades selle Unole ja varustades toite servode klemmidega, saate nende pistikud otse sellesse ühendada.

Aku

Teine oluline teema on toitumine. Kui teil on täiustatud plaat, mis võimaldab varustada kogu süsteemi ühe elektriliini kaudu (ja servomootorid ei sega kontrolleri tööd), saate ühe allikaga hakkama. Valik on tohutu, parimad on muidugi raadiomudelitele mõeldud Li-Ion/Li-Po brikett. Kuid nad vajavad ka sobivaid laadijaid. Kui sul on lihtsam kontroller (Uno/Due/Nano), siis saad seda eraldi toitestada, näiteks 9-voldise “Krona” abil ja ühendada servod võimsa peamise akuga. Nii jätkub servodele kindlasti jõudu. Liitiumakude puhul tuleb pinget tavapärasest veelgi hoolsamalt jälgida, et ei tekiks ületühjenemist (selgitada konkreetset tüüpi aku puhul lubatud pinged). Selleks on Sleipniri robotil, millest pikemalt juttu tuleb, ka väike digitaalne voltmeeter küljes.

Isetegija robot-mardikas

komplekt

• Arduino Uno kontroller: 1150 hõõruda.
• Kolm servomootorit. Ma kasutasin HXT500, 200 hõõruda. tükk
• Krona akupesa koos lülitiga: 50 hõõruda.
• Aku "Krona": 145 hõõruda.
• IR-vastuvõtja: 90 hõõruda.
• Terastraat läbimõõduga umbes 1,5 mm. Mina kasutasin näiteks katkist visplit munade kloppimiseks

Kokku: 2035 hõõruda.

Dmitri Dzz: Tahan teid kutsuda tegema Arduino Uno kontrolleri baasil väikest puldiga juhitavat kuue jalaga robotputikat. Jalad saavad ühe vabadusastme ja juhtimine toimub tavalise teleripuldi abil.

Pean ütlema, et need on kallite Moskva kaupluste hinnad. Hiina veebipoodides hakkab see kõik maksma poole vähem. Tarnete loendamine. Tõsi, minu kogemuse kohaselt peate ootama kaks nädalat kuni kolm kuud.

Lihtsam viis on võtta konstruktorikomplekt, sest esimestel sammudel ühest kontrollerist ei piisa. Nüüd pakuvad paljud kauplused selliseid komplekte. Näiteks on olemas suurepärane veebipood “Amperka”. Siin pakutakse teile mitmeid sarnaseid ehituskomplekte, mis erinevad nii sisu kui ka loomulikult hinna poolest. Minu jaoks piisas kõige lihtsamast - “Matryoshka X”. Sisaldab Arduino Uno kontrollerit, USB-kaablit arvutiga ühendamiseks, prototüüpimisplaati (asendamatu asi!), džemprite komplekti, LED-e, takisteid ja muid pisiasju.

Samas poes on rubriik “Wiki”, kust leiab isegi imelisi lühikesi vene keelde tõlgitud videoõpetusi. Kontrollige neid kindlasti. Ja loomulikult on olemas foorum, kus nad tõenäoliselt püüavad teid aidata.

Milliseid tööriistu vajate:

• jootekolb ja kõik vajalik jootmiseks. Te ei pea palju jootma ja te ei vaja erilisi oskusi;
• kuumliimipüstol ja selle vardad;
• tangid traadiga töötamiseks.

Kui olete kõik kokku kogunud, alustame!

Kontroll

Liigume edasi esimese sammu juurde: peame õppima, kuidas kaugjuhtimispuldiga suhelda ja välja selgitada koodid selle mõne nupu vajutamiseks. Need koodid on hiljem kasulikud roboti juhtimise visandi jaoks.

Selles etapis vajate ka IR-vastuvõtjat ja oleks tore omada prototüüpimisplaati. Valdav enamus IR-kaugjuhtimispulte töötab kandesagedustel 36 kHz, 38 kHz või 40 kHz (Panasonic, Sony). Erandiks on kaugjuhtimispuldid firmadelt Sharp (56 kHz), Bang & Olufsen (455 kHz) ja võib-olla keegi veel eksootilisem. Seetõttu sobib meile iga 36, ​​38 või 40 kHz IR-vastuvõtja. Sagedus ei pruugi täpselt ühtida signaali kandesagedusega. Sel juhul vastuvõtja tundlikkus väheneb, kuid praktikas ei täheldanud ma TSOP2136 IR-vastuvõtja (36 kHz - kaks viimast numbrit on sagedus) ja Sony kaugjuhtimispuldi (40 kHz) kasutamisel ebamugavust.

Niisiis, IR-vastuvõtjad TSOP21xx, TSOP22xx, TSOP312xx sobivad enamiku kaugjuhtimispultide jaoks. Viimased kaks numbrit võivad olla 36, ​​37, 38 või 40. Enne IR-vastuvõtja sisselülitamist kontrollige selle kontaktide juhtmeid - neid on ainult kolm: +5 V (toide), GND (maandus), Vs (väljund) . Paneme vooluringi kokku nagu joonisel (juhtmestik TSOP2136 jaoks).

Nagu näete, ühendasime IR-vastuvõtja väljundi kontrolleri A0 analoogsisendiga.

Sketšikood näeb välja selline:

#include "IRremote.h" // Kontrolleri analoogsisend, // millega IR vastuvõtja on ühendatud: const int IR_PIN = A0; // IR-vastuvõtja objekti loomine: IRrecv irrecv(IR_PIN); void setup() ( Serial.begin(9600); Serial.println("ready"); // Alustage IR-signaalide kuulamist: irrecv.enableIRIn(); ) void loop() ( // Kirjeldage tulemuste struktuuri, // kuhu // vastuvõetud ja dekodeeritud // IR käsud paigutatakse: decode_results results // Kui IR käsk on vastu võetud ja // edukalt dekodeeritud, siis // väljastatakse vastuvõetud kood kontrolleri jadaporti // kui; (irrecv.decode (&results)) ( Serial.println(results.value); irrecv.resume(); ) )

Sketš kasutab spetsiaalset raamatukogu IRremote.h, mis dekodeerib signaale mitmesugustest IR-kaugjuhtimispulditest. See raamatukogu on avatud projekt, saate selle alla laadida lehelt https://github.com/shirriff/Arduino-IRremote. Ja selle ühendamiseks meie projektiga peame tegema kolm sammu:

• kopeerige raamatukogu kataloog raamatukogude kataloogi, mis omakorda asub Arduino IDE installikataloogis;
• taaskäivitage IDE;
• lisage meie visandi algusesse rida #include "IRremote.h".

Nüüd on visandil saadaval infrapunasignaali dekodeerimise funktsioonid. Kuid vastuvõetud koodide nägemiseks kasutame ka Serial objekti. Tema abiga edastame jadapordi (sama USB-kaabli) kaudu koodid arvutisse. Seadistusfunktsioonis initsialiseerime Serial objekti. "9600" on 9600 boodi – kiirus, mida kasutatakse andmeedastuseks. Pärast lähtestamist saame jadaporti kirjutada funktsiooni println abil. Selle väljundi tulemuse vaatamiseks arvutis Arduino IDE-s valige menüükäsk Tools → Serial Monitor (Ctrl + Shift + M). Lihtsalt veenduge, et see oleks seatud 9600 boodile.

Seega saab kontroller toidet USB-kaabli kaudu ja edastab selle kaudu andmeid. Laadige eskiis, käivitage Serial Monitor ja hakake vajutama kaugjuhtimispuldi nuppe. Serial Monitori aknas peaksid ilmuma koodid. Kaugjuhtimispuldi protokollid on erinevad, mõnikord võib see olla üks kood, mõnikord mitu. Igal juhul saate alati valida iga kaugjuhtimispuldi nupu jaoks unikaalsed koodid.

Vajame 13 kaugjuhtimispuldi nuppu. Kasutasin järgmist:

• 1 - sujuv pööre vasakule;
• 2 - edasiliikumine;
• 3 - sujuv pööre paremale;
• 4 - pöörake kohapeal vasakule;
• 5 - peatus;
• 6 - kohapeal pöörake paremale;
• 7 - parempöördega tagurpidi liikumine;
• 8 - tagurpidi liikumine;
• 9 - vasakpöördega tagurpidi liikumine;
• sinine nupp - väga aeglane;
• kollane - aeglane;
• roheline - kiire;
• punane - väga kiire.

Kirjutage üles nende nuppude koodid, neid läheb hiljem roboti juhtimise eskiisi jaoks vaja.

Liikumise algoritm

Roboti juhtimise eskiis on saadaval meie projekti lehel (bit.ly/1dEwNDC). Ärge unustage muuta kaugjuhtimispuldi vajutatud nuppude koodide konstantide väärtusi oma kaugjuhtimispuldi koodideks (konstandid IR_COMMAND_XXX_CODES failis ir_command_codes.h).

Me ei vaata visandit üksikasjalikult; arvan, et koodi kommentaaridest piisab, kuid üks küsimus on siiski kaalumist väärt.

Putukate liikumine on väga huvitav. Ja kuigi kõik need mardikad on maapinnale kukkumisele väga lähedal, on nad mingil põhjusel alati stabiilsed: igal ajahetkel seisab pinnal vähemalt kolm jalga (kaks ühel ja üks teisel pool). Ja kui need jalad tõmbavad mardikat ühe sihtmärgi poole, tõmmatakse ülejäänud kolm üles, et seda liigutust korrata. Meie ülesanne on midagi sarnast teha.

Meie robotpisikul on kolm servomootorit, mis on paigutatud reas liikumisega risti. Vasakpoolse ja parema servomootori puhul on võlli telg suunatud ülespoole ja keskse servomootori puhul ettepoole. Näiteks vasakpoolse servo ülesanne on pumbata korraga kaks jalga: vasak ees ja vasak tagumine. Muide, need on omavahel jäigalt ühendatud ja selle servo klapi külge liimitud. Keskservo ülesanne on tõsta mardika vasakut või paremat külge. Seetõttu on selle mootori nookuri külge kinnitatud kesksed vasak ja parem jalg, mis on üks U-kujuline osa.

Sketš peaks tagama, et robot liigub edasi, tagasi, sujuvad pöörded liikumises ja pöörded paigal. Tahaks ka mardika kiirust kontrollida. Nende liikumiste programmiliseks kirjeldamiseks vajame matemaatikat. Vaata diagrammi.

Sinised ringid tähistavad robotmardika jalgu, mis seisavad pinnal, ja valged ringid õhus olevaid. Pange tähele, et edasi või tagasi liikudes peavad vasak ja parem servomootor liikuma täpselt samamoodi. Ja kohale keerates peaksid mootorid pöörlema ​​eri suundades (sümmeetriliselt). Huvitav on ka see, et edasi- ja tagasiliikumine erineb ainult keskservomootori faasis.

Niisiis, kuidas seda rakendatakse? Peame meeles, et kontroller kutsub pidevalt silmusfunktsiooni. See tähendab, et sellesse funktsiooni peame paigutama koodi, mis määrab servode praeguse asukoha ja seab need sellesse asendisse. Iga servomootor peab sooritama võnkuvaid liigutusi. Servomootori asukoha ajahetkel t saame arvutada järgmise valemi abil:

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

kus X on servomootori soovitud asend, A on võnkeamplituud, T on võnkeperiood.

Seega, olenevalt ajahetkest t, saame X väärtuse muutuse vahemikus –A kuni +A. Servomootoreid saab paigutada 0 kuni 180°. Seetõttu on meil parem kõikuda 90° "null" asendi ümber. Ja kui tahame pakkuda võnkumisi perioodiga 1 s positsiooni ümber 90° amplituudiga 30°, siis teisendatakse valem järgmisele kujule:

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

kus t on aeg millisekundites, mis on möödunud võnkumiste algusest. Robotmardika kiiruse juhtimiseks saame muuta võnkeperioodi. Mida suurem see on, seda väiksem on kiirus.

Pöördume nüüd uuesti meie diagrammi juurde, sest ülaltoodud valem pole veel valmis. Kuidas tagada vasak- ja parempoolsete servomootorite sünkroonne või vastassuunaline liikumine? Kuidas muuta keskservomootori faasi? Peame oma valemile lisama võnkefaasi. Siinuse argumendi nihutamine π võrra näiteks parempoolse mootori puhul paneb selle töötama vasakpoolsega võrreldes antifaasis, st nii, nagu me vajame, et see paigale pöörduks. Meie valem näeb nüüd välja selline:

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

kus Φ on võnkefaas, on väärtus vahemikus 0 kuni 2π.

Vaadake tabelit, et mõista, millised peaksid olema servomootorite võnkefaasid iga liikumistüübi jaoks.

Kokkupanek

Nüüd paneme roboti prototüüpimisplaadile kokku ja laadime üles juhtsketši.

See on väga oluline etapp enne kokkupanekut. Proovige USB-kaabel lahti ühendada ja toide Krona akuga. Kontrollige kõiki liikumise faase ja veenduge, et kõik töötab. Pärast roboti kokkupanemist on millegi muutmine (näiteks mittetöötava servomootori asendamine) keerulisem.

Liigume nüüd montaaži enda juurde. Peamine kandeelement on akuruum. Soovitan kasutada sektsiooni suletud tüüpi ja alati lülitiga.

Lihtsaim viis mardika osade kinnitamiseks on kuumliim. Alusta servomootoritest. Eemaldage mittevajalikud kinnituskõrvad ja ühendage masinad üksteisega. Seejärel liimige see kolmest "servast" koosnev komplekt akupesa kaane külge. Ärge unustage, et patarei vahetamiseks peab akupesa vabalt avanema.

Lihtsaim viis on kontroller sektsiooni külge liimida, kuid see valik mulle eriti ei meeldi, kuna pean Arduino Uno igaveseks veale andma. Seetõttu saate oma elu keerulisemaks muuta ja kasutada akupesa kinnitamiseks Arduino pistikuid. Liimige sektsiooni põhjale tihvtidega pistik, mille tihvtide vahe on 2,54 mm. See peaks olema paigutatud nii, et see sobiks kontrolleri pesasse digitaalsete tihvtide 8–11 piirkonnas. Meil pole neid nagunii veel vaja. Kui teil pole pistikut käepärast, sobib U-kujuline kirjaklamber.

Akupesast tulevad juhtmed tuleb ühendada Vin-tihvtide ja külgneva GND-ga. Ärge ajage polaarsust segi! Pluss “Crowns” Vinil, miinus GND-l. Et tagada juhtmete usaldusväärne kontakt Arduino pistikutega, võib traadi otsa lihtsalt paksemaks tinatada, aga mina kasutasin pistikuna lühikest kirjaklambrit. Ja jootekoha katsin termokahaneva toruga.

Servoajami kaablite pistikud tuleks ära lõigata, toitejuhtmed (+5 V - tavaliselt punane ja GND - must või pruun) ühendada ja suunata kontrolleri 5 V pistikupesadesse ja külgnevasse GND-sse. Ühendame veidi hiljem. Juhtsignaali juhtmed (tavaliselt kollased) on ühendatud kontrolleri digitaalsete väljunditega: vasakpoolne servomootor viiguga 2, keskmine tihvtiga 4, parempoolne viiguga 7.

IR-vastuvõtja “+” ja “–” saab lihtsalt ühendada Arduino pistikuga (5 V ja külgnev GND). Tõsi, painutades neid pooleks, kahekordistades nende paksust. Eelnevalt ühendatud servomootorite toitejuhtmed jootsime IR-vastuvõtja samade toitejalgade külge. Tõenäoliselt ei jõua IR-vastuvõtja signaali väljund A0 kontrolleri analoogsisendini ja peate seda juhtmega suurendama.

Mõned näpunäited jalgade tegemiseks. Esmalt valmistage ette vasak ja parem jalg "ees-taga". Veenduge, et need oleksid sümmeetrilised (pöörake tähelepanu nii pikkusele kui ka paindenurkadele). Alustage jalgade liimimist alles pärast seda, kui olete veendunud, et servod on seatud "null" asendisse (90°).

Keskmine jalgade paar on parem paigaldada viimasena. Soovitan teil kõigepealt keskmised jalad pikemaks muuta ja seejärel pärast paigaldamist soovitud pikkuseks lõigata. Null-asendis peaksid kõik kuus jalga olema pinnal. Keskmiste jalgade kiik 15° amplituudiga ei tohiks segada “antero-posterior” pöördeid.

Mis järgmiseks?

Robozhuk on valmis mobiiliplatvorm, mis põhineb ühel populaarseimal ja ligipääsetavamal kontrolleril. Projekt on avatud: https://github.com/beetle-ringo/arduino. Looge GitHubis hark (haru) ja lisage oma funktsioonid. Anna oma kujutlusvõimele vabad käed – lisa IR LED ja robot on robotilahinguks valmis. Ühendage kaugusmõõturid, puuteandurid, güroskoop... Õpetage robotit vältima takistusi või kõndima mööda joont, proovige paigaldada sellele veebikaamera. Ideid võib olla miljon ja alati saate valida kõige huvitavama.

Robot Sleipnir

komplekt

• Arduino Uno Dagu Spider Robot kontroller: 2530 hõõruda.
• Servoajamid SG90 9g (16 tk) 1150 hõõruda.
• Aku LiPo aku, 7,4 V, 1800 mAh RUR 490
• Raadiomoodul 4 Pin Bluetooth RF Transiiver RUR 270
• Pingeindikaator (valikuline) DC 3,3–30 V punane LED-paneeliarvesti RUR 100
• Alumiiniumist nurk. Lähimas ehitusturul 135 rubla.
• Poldid ja mutrid. Lähimas kirbukal 35 rubla.

Kokku: 4710 hõõruda.

*Komponendid on ostetud ettevõttest erinev aeg ja paljusid positsioone saab optimeerida

poconoco: Proovime kokku panna ebastandardse konfiguratsiooni – kaheksajalgse 2DOF roboti. 2DOF-i jalgu on palju lihtsam programmeerida ja mul on hunnik kasutamata servosid. Ja mis kõige tähtsam, seda on võimalik nimetada jumal Odini kaheksajalgse hobuse Sleipniri auks (sellest alati unistanud!).

Meie Sleipniri mõlemal küljel on neli jalga, millel on kaks liigendit. Iga liigend on servoajam, mis tähendab kaheksat servot külje kohta. Lihtsuse huvides pöörlevad kõik kaheksa liigendit hobuse ühel küljel samal tasapinnal. Kuigi see pole üldse vajalik. Veelgi enam, kui jalad ühel küljel on veidi “malelauaga”, nii et kaks kõrvuti asetsevat jalga ei saaks teineteist puudutada, on see veelgi parem, see võimaldab teil astuda laiemalt ja galoppida.

Puhas ja funktsionaalne, kuid kaugeltki mitte kõige odavam lahendus on kasutada kohandatud kontrolleriplaati, mis on optimeeritud servode ühendamiseks. suured hulgad. Sattusin Dagu Spider Robot Controlleri peale - see on seesama Arduino Mega, aga eelnevalt joodetud 3-kontaktiliste pistikutega plaadil, kuhu saab need 48 servot kohe ühendada ilma igasuguste varjesteta. Ideaalne Arduino mitme jalaga robotitele.

Kontroll

Meid juhitakse Bluetoothi ​​kaudu. Selleks on erinevaid riistvaralahendusi. Need on varjed ja eraldi kaardid, millel on UART jadaliides (nagu tavaline COM-port, ainult 5 V signaalitasemega). Mulle tundus, et kõige praktilisem oli kõige väiksem UART-liidesega kaart. Ühendab Arduino pordi vastavate UART/Serial tihvtidega. Märgime kahte nüanssi: Uno/Due/Nano ja sarnaste seadmete puhul on ainult üks selline port ja seda kasutatakse ka püsivara jaoks USB kaudu. Seetõttu peate võib-olla püsivara värskendamise ajal Bluetooth-mooduli välja lülitama. Ja teine ​​nüanss - ärge unustage, et mooduli RX-viik on ühendatud Arduino TX-pistikuga ja TX-viik RX-iga. Selliseid asju juhtub UART-is.

Bluetoothi ​​programmeerimine pole keerulisem kui servod; andmeid saab lugeda baithaaval, mida me kasutame:

Char cmd; Serial.begin(9600); if (Serial.available()) cmd = Serial.read();

Kui on kasutusel Arduino Mega ja Bluetooth on teise pordiga ühendatud, siis kirjutatakse Serial1 asemel Serial1. Tähelepanuväärne on see, et te ei pea kasutama Bluetoothi, vaid juhtima robotit otse USB kaudu. Ja ülaltoodud koodis ei muutu midagi! See on lihtsalt jadapordiga töötamine ja see, kas seal ripub BT saatja või USB Serial converter, pole meie jaoks oluline.

Bluetoothi ​​teine ​​pool

Enamik mugav viisühendused on standardsed Linuxi utiliidid. Töötamiseks vajame utiliite sdptool, rfcomm (osa bluezi paketist Ubuntu hoidlates) ja minicomi (nii seda paketti nimetatakse). Nende utiliitidega töötamise juhised leiate Internetist.

Liikumise algoritm

Kuusjala puhul oleks lihtsaim kõnnak järgmine: jalad jagunevad kaheks kolme jalaga rühmaks ja üks gruppidest on täielikult maas, teine ​​on õhus, ettepoole ümber paigutatuna. See pole kaugeltki ainus võimalik käik. Õhus saate hoida ainult kahte käppa või isegi ühte ja ülejäänud nelja või viit maas. Ka kaheksajala jaoks on palju kõnnakuid. Võtame kõige lihtsama, samuti kahe nelja jalaga rühmaga.

Mida me peame tegema, et töötada 16 servo ja valitud kõnnakuga? Õige vastus on lugeda pöördkinemaatika (IR) kohta. Artikli pikkus ei võimalda teemat laiemalt laiendada, kuid materjali on Internetis küllaga. Lühidalt, IR lahendab vajalike juhtsignaalide leidmise probleemi, et süsteem ruumis saaks soovitud asendi. Jala jaoks tähendab see, et selle punkti koordinaatide põhjal, kuhu jalg peaks tabama, tuleks määrata servode nurgad, mida selleks on vaja seada. Ja jalgade koordinaate kontrollides saate kontrollida keha asendit. Meil on 2DOF jalad, teljed on paralleelsed, nii et jalg liigub alati samas tasapinnas. IR-probleem on sel juhul taandatud 2D-ruumile, mis lihtsustab seda oluliselt.

Olgu iga jala koordinaatide O lokaalne alguspunkt ülemise servo võll, see tähendab puusad. Ja meil on punkti A koordinaadid, kuhu jalg peab lööma. Siis on hästi näha, et peate lahendama kahe ringi ristumispunktide leidmise ülesande (vt ühe külje jalgade skeemi, see on illustreeritud kõige parempoolsel jalal). Olles leidnud ringide lõikepunkti B (valides neist ükskõik millise), on lihtne arvutada vajalikud nurgad, kasutades Descartes'i koordinaatide teisendamist polaarseteks. Koodis näeb selle probleemi lahendus välja järgmine:

Ujuk A = -2 * x; ujuk B = -2 * y; ujuki C = sqr(x) + sqr(y) + sqr(puusapikkus) - sqr(shinLength); ujuki X0 = -A * C / (sqr(A) + sqr(B)); ujuki Y0 = -B * C / (sqr(A) + sqr(B)); float D = sqrt(sqr(puusaPikkus) - (sqr(C) / (sqr(A) + sqr(B)))); float mult = sqrt(sqr(D) / (sqr(A) + sqr(B))); ujukikirves, ay, bx, poolt; ax = X0 + B * mult; bx = X0 - B * mult; ay = Y0 - A * mult; by = Y0 + A * mult; // või bx mõne teise lõikepunkti jaoks float jointLocalX = ax; // või teise lõikepunkti jaoks float jointLocalY = ay; float hipPrimaryAngle = polaarnurk(liigesLocalX, jointLocalY); float hipAngle = hipPrimaryAngle – hipStartAngle; float shinPrimaryAngle = polarAngle (x - jointLocalX, y - jointLocalY); float shinAngle = (shinPrimaryAngle - hipAngle) - shinStartAngle;

kus x ja y on selle punkti koordinaadid, kuhu peate jalaga jõudma; hipStartAngle - nurk, mille all "puusa" algselt pööratakse (servo keskmises asendis), samamoodi - shinStartAngle. Muide, nendes arvutustes on nurgad ilmselgelt radiaanides, kuid need tuleb servoobjektidele üle kanda kraadides. Täielik töötav püsivara kood, sealhulgas see tükk, on postitatud GitHubisse, vaadake artikli lõpus olevat linki. See on osa IR-st, kuid lisaks sellele on vaja veel natuke lihtsat koodi, et seda IR-i kõigil jalgadel kasutada (vt funktsioone legsReachTo(), legWrite()). Teil on vaja ka koodi, mis tegelikult kõnnakut rakendab - ühe jalgade komplekti liigutamine "tagasi" (nii robot liigub edasi), samal ajal kui teine ​​​​jalgade komplekt tõstetakse üles ja liigutatakse järgmiseks sammuks edasi, vaadake funktsiooni stepForward(). See võtab etteantud parameetritega ühe sammu. Muide, nende parameetritega saate funktsiooni nimest hoolimata sammu tagasi astuda. Kui seda funktsiooni kutsutakse tsüklina, astub robot edasi.

Nüüd käskude vastuvõtmine ja nende tõlgendamine. Lisame programmi oleku:

Enum olek ( STOP, EDASI, TAGASI, FORWARD_RIGHT, FORWARD_LEFT );

Ja peamises täitmistsüklis loop() vaatame praegust olekut (olekumuutuja) ja tõmbame sammu edasi (pööramisega või ilma), ja jälle stepForward(), kuid negatiivse argumendiga xamp, kui meil on vaja tagasi liikuda. Pöördeid käsitletakse funktsioonis legWrite() ja paremale pöördeks jäävad parempoolsed jalad paigale (vasakud aga reavad). Siin on selline hobutank. Jõhker, kuid väga lihtne ja see toimib. Sujuv pöörlemine on võimalik ainult 3DOF-i jalgadega, näidet selle kohta võib näha buggybug-i hoidlas.

Lüliti (olek) ( FORWARD: suurtäht FORWARD_RIGHT: tõst FORWARD_LEFT: sammEdasi(h, dh, xamp, xshift); paus; suurtäht TAGASI: sammEdasi(h, dh, - xamp, xshift); murda; )

Char käsk; while (Serial1.available()) käsk = Serial1.read(); lüliti (käsk) ( juhtum "w": olek = EDASI; katkestus; juhtum "s": olek = TAGASI; katkestus; juhtum "d": olek = FORWARD_RIGHT; katkestus; juhtum "a": olek = FORWARD_LEFT; katkestus; vaikeseade : olek = STOP;

Siin on püsivara põhipunktid läbi, ülejäänud on kõikvõimalikud pisiasjad. Kuigi ilmselt on veel üks oluline punkt- võimalus servosid peenhäälestada. Isegi kõige hoolikama kokkupanemise korral, kui kästate kogu servol 90° pöörata, on mõned neist ikkagi veidi viltu. Seetõttu vajame võimet seda kohandada. Näete, kuidas ma seda tegin meetodites hipsWrite() ja shinsWrite() ning peenhäälestusmassiivides hipsTune ja shinsTune.

Kokkupanek

Selliste kujunduste jaoks pole midagi erilist vaja: sobivad sobiva paksusega pleksiklaasist leht (lähimast riistvarakirbu turult) ja pusle või rauasaag osade välja lõikamiseks. Ja muidugi puur aukude puurimiseks. Pleksiklaasi asemel võite kasutada vineeri (siis saate lõpliku konstruktsiooni põleti abil teha ka meeldejääva pealdise). Võite kasutada ka alumiiniumist lehti või nurki. Sleipniriga läksin 1 cm ribidega alumiiniumnurga kasutamise teed (ostetud kuskilt ehitussupermarketist).

Aluseks saab ristkülikukujuline raam. Jäsemed - 4-sentimeetrised triibud. Samuti tasub varuda palju väikseid polte ja mutreid. Nurga lõikame vajalikeks juppideks, servodele lõikame välja sooned, kinnituspoltide ja kruvide jaoks puurime augud. Parem on kujundust näidata kui kirjeldada. Suurused võivad olla mis tahes, roboteid tuleb varieerida. Kuid pidage meeles: mida pikemad jalad, seda rohkem peab servo kangi vajutama ja seda suurem on koormus. Kuni selleni, et ei suuda pöörata ja isegi puruneb. Kuid 4–5 cm pole probleem.

Soodsate kergekaaluliste robotite puhul ei häiri nad sageli jäsemete jaoks eraldi liigendliigendit ja kogu koormus langeb täielikult servo veovõllile. Arvestades väikest kaalu, pole see üldse kriitiline. Ja suurema kaaluga tuleks mõelda metallist hammasratastega servodele ja kuullaager võll

Iga servoga on tavaliselt kaasas paar kruvi ja komplekt kinnitusi, mida saab võllile kruvida erinevaid rakendusi. Meie parim valik on üksik “sarv” (või sarv), mis võimaldab servo külge kinnitada lati. Niisiis kinnitatakse kahe servo teljed ühe varda külge ja latist saab “puus”. Sel juhul kinnitatakse üks servo kere külge ja teine ​​muutub sääre osaks. Sellele tasub kinnitada veel üks latt, et seda lihtsalt pikendada või jäseme huvitavamaks muuta. Natuke vaevarikast tööd – ja platvorm on valmis (mugavad kruvikeerajate komplektid, võtmed, pintsetid, traadilõikurid jne kiirendavad oluliselt protsessi).

Mis järgmiseks?

Kogu projekt on saadaval aadressil https://github.com/poconoco/sleipnir. Kirjeldasin üht ebapraktilisemat konfiguratsiooni - palju 2DOF jalgu, kõrged, kitsad, kergesti külili kukkuvad. Proovige teha parem 3DOF-jalgadega robot. 4DOF jalgadega. Küüniste või lõugadega. 3DOF-i pöördkinemaatika näitena võib viidata buggybug-i hoidlale – seal on kuusepoodide püsivara. Saate teha ka intelligentseid roboteid, mitte juhitavaid roboteid, paigaldades Bluetoothi ​​asemel kaugusandurid, ning õpetada robotit seinu ja takistusi vältima. Kui panete sellise anduri servoajamile ja pöörate seda, saate seda piirkonda peaaegu sonari abil skaneerida.

Head päeva! Teie ees, kallid, on kunstirobot, mis suudab maalida erinevaid kera- või munakujulisi esemeid, mille suurus on vahemikus 4–9 cm.

Selle valmistamiseks vajate 3D-printerit, standardsete tööriistade komplekti + Arduino.

Märkus. Ärge loobuge projektidest, mis kasutavad 3D-printerit. Soovi korral leiate alati koha või viisi, kust saate tellida projekti jaoks vajalike osade printimise.

1. samm: natuke roboti kohta

Kunstirobot – kaheteljeline isetehtud, mis võib mustrit kanda enamikule sfäärilistele pindadele. Robot on kohandatud teatud tüüpi esemed (pingpongipallid, jõulukaunistused, lambipirnid ja munad (part, hani, kana...).

Sfäärilise eseme pööramiseks ja manipulaatori liigutamiseks kasutatakse suure pöördemomendiga ülitäpseid samm-mootoreid ning käepideme mehhanismi tõstmiseks vaikset ja töökindlat SG90 servoajamit.

2. samm: vajalikud osad

Selleks, et teha DIY käsitöö me vajame:

• 2x laagrid 623;
• Juuksenõel läbimõõduga 3 mm ja pikkusega 80-90 mm;
• 1x vedru (pikkus 10 mm ja läbimõõt 4,5 mm);
• 2x NEMA 17 samm-mootorit (pöördemoment 4,4 kg/cm);
• Mootorikaablid (pikkus 14 + 70 cm);
• USB-kaabel;
• 1x servo SG90;
• Arduino Leonardo;
• kilp JJRobots;

• 2xA4988 draiverid samm-mootoritele;
• Toide 12V/2A;
• 11x M3 6mm kruvid;
• 4x M3 16mm kruvi;
• 4x M3 mutrid;
• 2x 20mm iminappasid;
• 1x tiibmutter M3;
• 1x marker;

3. samm: üldine ülevaade

Seda diagrammi saate kasutada "petulehena".

4. samm: alustame!

Robot liigutab manipulaatorit, mille külge on kinnitatud marker, mida juhib samm-mootor. Teine samm-mootor vastutab objekti pööramise eest, millele joonistus kantakse (muna, pall...). Eseme paigal hoidmiseks kasutatakse kahte iminappa: üks on samm-mootori küljes ja teine ​​eseme vastasküljel. Väike vedru surub vastu iminappa, aidates sellel objekti hoida. SG90 servoajamit kasutatakse markeri tõstmiseks/langetamiseks.

5. samm: manipulaator

Asetage mutter selle jaoks ettevalmistatud auku ja keerake 16 mm kruvi kinni. Teeme sama eseme omanikuga (paremal ülaloleval pildil). Manipulaatori hinge loomisel kasutati 2 16 mm kruvi. See hing peaks pärast kruvide pingutamist vabalt pöörlema.

6. samm: imesid

Asetage üks iminappadest esemehoidikus olevasse avasse.

7. samm: samm-mootorite paigaldamine

Kinnitame mõlemad samm-mootorid põhiraami külge 8 kruviga.

8. samm: pöörlemistelg

Asetame kõik elemendid nii, nagu on näidatud ülaltoodud pildil.

• Imeja;
• Kruvi;
• ülemine osa;
• Kevad;
• Laager 623 (peab olema ehitatud vasakpoolsesse tassi);
• Vasak tass;
• Vaba ruum põhiraami jaoks;
• Parem tass;
• laager 623;
• Vaherõngas;
• Tiibmutter (M3).

9. samm: asetage kõik oma kohale

Sisestame kokkupandud manipulaatori samm-mootori teljele.

Paigaldame vasakpoolse toe samm-mootori teljele.

Eeskujuks on seatud marker ja muna (praegu pole vaja neid panna).

MÄRKUS. Servo vajab reguleerimist. Peate kalibreerimisprotsessi ajal selle nurga uuesti seadistama.

10. samm: elektroonika

Kinnitame elektroonika kruvidega (piisab 2) põhiraami tagaküljele.

Ühendame kaablid.

Kui muudate samm-mootorite ühendamisel polaarsused vastupidiseks, pöörlevad need lihtsalt sisse vastassuunas, kuid servoajamiga pole olukord nii kahjutu! Seetõttu kontrollige enne ühendamist polaarsust!

11. samm: Arduino Leonardo programmeerimine

Programmeerime Arduino Leonardo, kasutades Arduino IDE-d (v 1.8.1).

• Laadige alla Arduino IDE (v 1.8.1) ja installige programm;
• Käivitame tarkvara. Vali menüüst “tööriistad->tahvel” Arduino Leonardo plaat ja vastav COM PORT;
• Avame ja laadime alla Sphere-O-Boti koodi. Pakime kõik ühes kaustas olevad failid lahti ja nimetame seda “Ejjduino_ARDUINO”.

12. samm: kunstirobot on valmis kunstiteoseid looma

13. samm: juhtige robotit

Tarkvara Inkscape. Laadime alla ja installime Inkscape tarkvara (soovitan stabiilset versiooni 0.91).

Laadige alla ja installige laiendus EggBot Control (versioon 2.4.0 on täielikult testitud).

Inkscape'i laiendus EggBot Control on tööriist, mida peate kasutama oma EggBoti testimisel ja kalibreerimisel ning kujunduse munale ülekandmisel. Kõigepealt peate käivitama Inkscape'i. Pärast Inkscape'i käivitamist ilmub menüü "Laiendused" ja selles peate valima alammenüü "Eggbot". Kui te ei näe Eggboti alammenüüd, pole te laiendusi õigesti installinud. Tehke varukoopia ja järgige hoolikalt laienduste installimise juhiseid.

See on kõik, tänan tähelepanu eest!)

Artikli viimane osa räägib väikesest robotist, mille paneme kokku šassiile - plastikust toidunõu kaanele. Meie roboti aju on Arduino UNO plaat, mootoreid ja servoajamit juhib Driver Motor Shield plaat, takistusanduriks on Ultrasonic Sonar - silmad nagu Vallil (multist) - “HC-SR04 Ultrasonic Sensor”. , . Kuidas luua Arduinos robotit?

9. Aku ja mootorite ühendamine

Aku ühendamisel peate olema täiesti kindel, et polaarsus on õige, nagu öeldakse, mõõtke 7 korda, ühendage üks kord. Proovige seda reeglit järgida – punane juhe on alati + toitega, must juhe on maandatud, tuntud ka kui miinus, tuntud ka kui GND. Tootjad püüavad järgida samu reegleid. Seetõttu ühendame akupesast tulevad juhtmed +M ja GND plokiga mootori juhtplaadil. Töötavate mootorite juhtmed ühendame mootori juhtplaadi plokkidega M1, M2. Vasak pool sõidusuunas on ühendatud plokiga M1, parem pool plokiga M2. Mootorite polaarsuse pärast pole vaja veel muretseda, seda saab muuta, kui testi käigus midagi valesti läheb.

10. Kontrollige moodulite polaarsust ja õiget ühendust

Väga oluline ja ülioluline hetk mikroroboti kokkupanemisel on plokkskeemi järgi õige paigalduse, ühenduste, moodulite kontrollimine, tahvlite märgistuste vaatamine, testeriga kontrollimine, toite polaarsus, kellel on tester.

11. Arduino programmeerimise etapp

Programm laaditakse arvutist Arduino mikrokontrollerisse USB kaabli abil ja eriprogramm- sketšide (programmide) programmeerimis- ja redigeerimiskeskkonnad - Arduino IDE. Programmi saate alla laadida arduino.cc veebisaidilt, kust saate alati alla laadida programmi uusima versiooni. Pärast programmeerimiskeskkonna installimist ei jää üle muud, kui valida draiveriprogrammi menüüst, millist plaati soovite kasutada - meie puhul Arduino UNO ja COM-port, mille kaudu Arduino USB-emulatsiooni kaudu ühendatud on. Sellel teemal on palju erinevaid käsiraamatuid, nii et jätame selle sammu vahele (igaks juhuks - menüü Tööriistad > Jadaport).

Mikroroboti programmi leiate meie veebisaidilt, kuigi alles pärast registreerimist, nali Mini robot Arduinos. Programmi töötamiseks on vaja täiendavaid teeke - AFMotor.h, Sevo.h, NewPing.h, kõik need on arhiivis, peate arhiivi lahti pakkima installitud Arduino IDE programmi kausta. Minu jaoks on see c:Program Files (x86)Arduino kataloog, raamatukogud tuleb paigutada kausta c:Program Files (x86)Arduinolibraries. Seejärel sisestage kataloog c:Program Files (x86)ArduinolibrariesAPC_4_ROBOT ja topeltklõpsake APC_4_ROBOT.ino - see on sketš ise, seejärel programmeerimiskeskkond käivitub. Ühendame palja Arduino Uno plaadi (see tähendab ilma ühendatud mooduliteta) USB-kaabli kaudu arvutiga, vajutage paremal asuva noolega nuppu, programm hakkab kontrollerisse üles laadima. Kogu protsess võtab paar sekundit ja kui kõik on õigesti ühendatud, ei tohiks ükski punane märk süttida ja paremas alanurgas olev indikaator lõpetab liikumise 100%. Arduino programm on installitud Atmega328 kontrollerisse.

12. Roboti käivitamine

Minirobot Arduino peal – valmis liikuma. Robot Wally

Saate läbi viia meie roboti esimese, endiselt proovisõidu. Meie robot ei sõitnud õigesti, üks ratas pöörles õigesti ja teine ​​vastupidises suunas. Pidin M2 plokil mootori juhtmete polaarsust muutma. Aga siis sai meie väike robot kõigi toanurkade ja takistustega aukalt toime.

Pühendan selle artikli kõigile algajatele, kes otsustasid õppida Arduino. Edasist õppimist saab jätkata alates esimesest tunnist – vilkuvast LED-ist. Materjal koos robotiga on väga huvitav ja selleks, et teid huvitaks, otsustasin alustada sellest, kuidas ehitada robotit, mis läheb mööda takistusi. Edasine on palju lihtsam ja läheb nagu kellavärk. See robot tõesti töötab. Edu kõigile!

P.S. Tegemist oli üsna vaba tõlkega interneti avarustest ammu leitud artiklist, muidugi rohkem rämpsu, sest kõik tehti uuena, jooniseid muudeti, linke allikale polnud, sest dokument oli Word.