Egyszerű és intelligens robotkar az Arduino használatával !!!: 5 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:42

Ebben az utasításban egy egyszerű robotkart készítek. Ezt egy mesterkar segítségével lehet szabályozni. A kar emlékezni fog a mozdulatokra és sorban játszik. A koncepció nem új, az ötletet a "mini robotkar -Stoerpeak" -től kaptam. Régóta szerettem volna ezt elkészíteni, de akkor teljesen bunkó voltam, és nem tudtam programozásról. Most végre építek egyet, egyszerű, olcsó és megosztom veletek.

Tehát kezdjük….

1. lépés: Amire szüksége lesz:-

Itt van egy lista a szükséges dolgokról:-

1. Szervo motorok x 5 Link az USA-hoz:- https://amzn.to/2OxbSH7Link for Europe:-

2. Potenciométerek x 5 (100k-t használtam.) Link az USA-hoz:- https://amzn.to/2ROjhDMLink for Europe:-

3. Arduino UNO. (Használhatja az Arduino Nano-t is) Link US:- https://amzn.to/2DBbENWLink for Europe:-

4. Kenyeretábla. (Javaslom ezt a készletet) Link nekünk:- https://amzn.to/2Dy86w4Link for Europe:-

5. Akkumulátor. (opcionális, 5V -os adaptert használok)

6. Karton/Fa/Sun-board/akril, ami valaha is kapható vagy könnyen megtalálható.

És telepítenie kell az Arduino IDE -t.

2. lépés: A kar elkészítése:-

Itt Popsicle botokat használtam a kar elkészítéséhez. Bármilyen rendelkezésre álló anyagot használhat. És kipróbálhat különböző mechanikai konstrukciókat, hogy még jobb karokat készítsen. a dizájnom nem túl stabil.

Én csak kétoldalas ragasztószalaggal ragasztottam a szervókat a Popsicle bothoz, és csavarokkal rögzítettem őket.

A Master karhoz potenciométereket ragasztottam a popsicle botokhoz, és karot készítettem.

A képekre hivatkozva jobb ötletet ad.

Mindent egy alaplapként használt A4 -es méretű vászonlapra szereltem fel.

3. lépés: Kapcsolatok létrehozása:-

Ebben a lépésben elvégezzük az összes szükséges csatlakozást, lásd a fenti képeket.

• Először csatlakoztassa az összes szervót párhuzamosan a tápegységhez (a piros vezeték +ve -hez, a fekete vagy barna vezeték pedig a Gnd -hez)
• Ezután csatlakoztassa a jelvezetékeket, azaz sárga vagy narancssárga vezetéket az arduino PWM tűjéhez.
• Most csatlakoztassa a potenciométereket párhuzamosan az arduino +5v és Gnd értékéhez.
• Csatlakoztassa a középső terminált az ardunio analóg érintkezőjéhez.

Itt a 3, 5, 6, 9 és 10 digitális csapokat használják a szervók vezérlésére

Az A0 -tól az A4 -ig terjedő analóg érintkezők a potenciométerek bemenetére szolgálnak.

A 3. csaphoz csatlakoztatott szervót az A0 -hoz csatlakoztatott potenciométer fogja vezérelni

Az 5 -ös csaphoz csatlakoztatott szervót az A1 -es pot vezérli, és így tovább.

Megjegyzés:- Annak ellenére, hogy a szervókat nem az arduino hajtja, győződjön meg arról, hogy a szervók Gnd-jét az arduino-hoz csatlakoztatja, különben a kar nem fog működni.

4. lépés: Kódolás:-

Ennek a kódnak a logikája meglehetősen egyszerű, a potenciométerek értékeit egy tömb tárolja, majd a rekordokat for for cikluson áthaladva a szervók elvégzik az értékek szerinti lépéseket. Megnézheti ezt az oktatóanyagot, amelyet referenciaként használtam "Arduino potenciométer szervo vezérlés és memória"

Kód:- (Letölthető fájl csatolva az alábbiakban.)

Először globálisan deklaráljuk az összes szükséges változót, hogy azokat a program során használni tudjuk. Ehhez nincs szükség külön magyarázatra

#befoglalni

// Szervo objektumok Servo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4; // Potenciométer objektumok int Pot_0; int Pot_1; int Pot_2; int Pot_3; int Pot_4; // A Servo Position tárolására szolgáló változó int Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; // Változó tárolni Előző pozícióértékek int Prev_0_Pos; int Prev_1_Pos; int Prev_2_Pos; int Előző_3_Posz; int Előző_4_Posz; // Változó az aktuális pozíció értékeinek tárolására int Current_0_Pos; int Current_1_Pos; int Current_2_Pos; int Current_3_Pos; int Current_4_Pos; int Servo_Position; // tárolja a szöget int Servo_Number; // Üzletek száma a szervo int Storage -ban [600]; // Tömb adatok tárolására (A tömb méretének növelése több memóriát igényel) int Index = 0; // A tömbindex a 0. pozícióból indul char data = 0; // változó a soros bemenetről származó adatok tárolására.

Most írunk egy beállítási függvényt, ahol beállítjuk a csapokat és azok funkcióit. Ez a fő funkció, amelyet először hajt végre

üres beállítás ()

{Serial.begin (9600); // Soros kommunikációhoz az arduino és az IDE között. // A szervo objektumok a PWM csapokhoz vannak rögzítve. Szervo_0.csatlakozás (3); Szervo_1.csatlakozás (5); Szervo_2.csatlakozás (6); Szervo_3.csatlakozás (9); Szervo_4.csatlakozás (10); // A szervók inicializáláskor 100 pozícióra vannak állítva. Szervo_0.írás (100); Szervo_1.írás (100); Szervo_2.írás (100); Szervo_3.írás (100); Szervo_4.írás (100); Serial.println ("Nyomja meg az" R "gombot a felvételhez és a" P "gombot a lejátszáshoz"); }

Most ki kell olvasnunk a potenciométerek értékeit az analóg bemeneti csapok segítségével, és le kell őket képeznünk a szervók vezérléséhez. Ehhez definiálunk egy függvényt, és elnevezzük Map_Pot ();, bármikor elnevezheti, amit akar, ez egy felhasználó által definiált funkció

void Map_Pot ()

{ / * A szervók 180 fokban forognak, de a korlátozások használata nem jó ötlet, mivel a szervók folyamatosan zümmögnek, ami bosszantó, ezért korlátozzuk a szervó mozgását: 1-179 * / Pot_0 = analogRead (A0); // Olvassa el az inputot az edényből, és tárolja a Pot_0 változóban. Szervo_0_Pos = térkép (Pot_0, 0, 1023, 1, 179); // A szervók leképezése a 0 és 1023 közötti érték szerint Servo_0.write (Servo_0_Pos); // Állítsa a szervót ebbe a helyzetbe. Pot_1 = analogRead (A1); Servo_1_Pos = térkép (Pot_1, 0, 1023, 1, 179); Servo_1.write (Servo_1_Pos); Pot_2 = analogRead (A2); Servo_2_Pos = térkép (Pot_2, 0, 1023, 1, 179); Servo_2.write (Servo_2_Pos); Pot_3 = analóg olvasmány (A3); Servo_3_Pos = térkép (Pot_3, 0, 1023, 1, 179); Servo_3.write (Servo_3_Pos); Pot_4 = analógRead (A4); Servo_4_Pos = térkép (Pot_4, 0, 1023, 1, 179); Servo_4.write (Servo_4_Pos); }

Most írjuk be a ciklusfüggvényt:

üres hurok ()

{Map_Pot (); // Funkcióhívás a pot értékek olvasásához, miközben (Serial.available ()> 0) {data = Serial.read (); if (adatok == 'R') Serial.println ("Mozgás rögzítése …"); if (adatok == 'P') Serial.println ("Rögzített mozgások lejátszása …"); } if (data == 'R') // Ha 'R' van megadva, indítsa el a felvételt. {// Tárolja az értékeket egy változóban Prev_0_Pos = Servo_0_Pos; Prev_1_Pos = Servo_1_Pos; Prev_2_Pos = Servo_2_Pos; Prev_3_Pos = Szervo_3_Pos; Prev_4_Pos = Szervo_4_Pos; Map_Pot (); // A térképfüggvényt visszahívjuk összehasonlításra, ha (abs (Prev_0_Pos == Servo_0_Pos)) // abszolút értéket a {Servo_0.write (Servo_0_Pos) összehasonlításával kapunk; // Ha az értékek megegyeznek, akkor a szervo áthelyezésre kerül, ha (Current_0_Pos! = Servo_0_Pos) // Ha az értékek nem egyeznek {Storage [Index] = Servo_0_Pos + 0; // Érték hozzáadódik az Index ++ tömbhöz; // Az index értéke növelve 1} Current_0_Pos = Servo_0_Pos; } /* Hasonlóképpen az érték -összehasonlítást az összes szervóra végzik, +100 -at adnak minden egyes bejegyzéshez differenciális értékként. */ if (abs (Prev_1_Pos == Servo_1_Pos)) {Servo_1.write (Servo_1_Pos); if (Current_1_Pos! = Servo_1_Pos) {Storage [Index] = Servo_1_Pos + 100; Index ++; } Current_1_Pos = Servo_1_Pos; } if (abs (Prev_2_Pos == Servo_2_Pos)) {Servo_2.write (Servo_2_Pos); if (Current_2_Pos! = Servo_2_Pos) {Storage [Index] = Servo_2_Pos + 200; Index ++; } Current_2_Pos = Szervo_2_Pos; } if (abs (Prev_3_Pos == Servo_3_Pos)) {Servo_3.write (Servo_3_Pos); if (Current_3_Pos! = Servo_3_Pos) {Storage [Index] = Servo_3_Pos + 300; Index ++; } Current_3_Pos = Servo_3_Pos; } if (abs (Prev_4_Pos == Servo_4_Pos)) {Servo_4.write (Servo_4_Pos); if (Current_4_Pos! = Servo_4_Pos) {Storage [Index] = Servo_4_Pos + 400; Index ++; } Current_4_Pos = Servo_4_Pos; } / * Az értékek soros monitorra nyomtatódnak, a "\ t" az értékek táblázatos formátumban való megjelenítésére szolgál * / Serial.print (Servo_0_Pos); Serial.print ("\ t"); Serial.print (Servo_1_Pos); Serial.print ("\ t"); Serial.print (Servo_2_Pos); Serial.print ("\ t"); Serial.print (Servo_3_Pos); Serial.print ("\ t"); Serial.println (Servo_4_Pos); Serial.print ("Index ="); Serial.println (Index); késleltetés (50); } ha (adatok == 'P') // HA 'P' van megadva, Kezdje el a rögzített mozdulatok lejátszását. {for (int i = 0; i <Index; i ++) // Menjen át a tömbön a ciklus használatával {Servo_Number = Storage /100; // Megkeresi a szervo számát Servo_Position = Storage % 100; // Megkeresi a szervókapcsoló helyzetét (Szervo_szám) {case 0: Servo_0.write (Servo_Position); szünet; 1. eset: Servo_1.write (Servo_Position); szünet; 2. eset: Servo_2.write (Servo_Position); szünet; 3. eset: Servo_3.write (Servo_Position); szünet; 4. eset: Servo_4.write (Servo_Position); szünet; } késleltetés (50); }}}

Ha a kód kész, töltse fel most az arduino táblára

Az intelligens kar készen áll a munkára. A funkció még nem olyan sima, mint a Stoerpeak.

Ha javíthatja a kódot, vagy bármilyen javaslata van számomra, kérjük, jelezze a megjegyzés rovatban.

Ezzel együtt, térjünk át a tesztelésre….

5. lépés: Tesztelés:-

Miután sikeresen feltöltötte a kódot a táblára, nyissa meg a "Soros monitor" gombot, és megtalálja az Eszközök menüben. Amikor a soros monitor elindul, az arduino alaphelyzetbe áll. Most a mesterkar segítségével vezérelheti a robotkart. De nem rögzítenek semmit.

A felvétel megkezdéséhez írja be az „R” gombot a monitorba, és végre tudja hajtani a rögzíteni kívánt mozdulatokat.

A mozdulatok befejezése után be kell írnia a „P” -t a rögzített lépések lejátszásához. A szervók addig hajtják végre a mozdulatokat, amíg a tábla nincs visszaállítva.