Braț robotizat simplu și inteligent folosind Arduino !!!: 5 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

În acest instructabil voi face un simplu braț robotizat. Acest lucru va fi controlat folosind un braț principal. Brațul își va aminti mișcările și se va juca în ordine. Conceptul nu este nou. Am primit ideea de la „mini braț robotizat - de Stoerpeak”. Am vrut să fac acest lucru mult timp, dar pe atunci eram total noob și nu aveam cunoștințe despre programare. Acum, în cele din urmă, construiesc unul, păstrându-l simplu, ieftin și împărtășindu-l cu voi toți.

Deci sa începem….

Pasul 1: Lucruri de care aveți nevoie: -

Iată o listă de lucruri de care veți avea nevoie: -

1. Servomotoare x 5 Link pentru SUA: - https://amzn.to/2OxbSH7Link pentru Europa: -

2. Potențiometre x 5 (am folosit 100k.) Link pentru SUA: - https://amzn.to/2ROjhDMLink pentru Europa: -

3. Arduino UNO. (Puteți utiliza și Arduino Nano) Link pentru SUA: - https://amzn.to/2DBbENWLink for Europe: -

4. Pană de pâine. (Vă sugerez acest kit) Link pentru SUA: - https://amzn.to/2Dy86w4Link pentru Europa: -

5. Baterie. (opțional, folosesc un adaptor de 5v)

6. Carton / Lemn / Sun-board / acrilic ceea ce este vreodată disponibil sau ușor de găsit.

Și veți avea nevoie și de Arduino IDE instalat.

Pasul 2: Realizarea brațului: -

Aici am folosit bastoane Popsicle pentru a face brațul. Puteți folosi orice material disponibil. Și puteți încerca diferite modele mecanice pentru a face un braț și mai bun. designul meu nu este foarte stabil.

Tocmai am folosit bandă dublă pentru a lipi servosele de stick-ul Popsicle și a le fixa cu șuruburi.

Pentru brațul Master am lipit potențiometre de bețișoare și am făcut braț.

Referirea la imagini vă va oferi o idee mai bună.

Am montat totul pe o placă de pânză format A4 folosită ca bază.

Pasul 3: Realizarea conexiunilor: -

În acest pas vom face toate conexiunile necesare, consultați imaginile de mai sus.

• Conectați mai întâi toate servo-urile în paralel cu sursa de alimentare (firul roșu la + ve și firul negru sau maro la Gnd)
• Apoi conectați firele de semnal, adică firul galben sau portocaliu la pinul PWM al arduino.
• Acum conectați potențiometrele la + 5v și Gnd de arduino în paralel.
• Conectați terminalul din mijloc la pinul analogic al ardunio.

Aici Pinii digitali 3, 5, 6, 9 și 10 sunt utilizați pentru controlul servomotoarelor

Pinii analogici A0 la A4 sunt utilizați pentru intrarea de la potențiometre.

Servo-ul conectat la pinul 3 va fi controlat de un potențiometru conectat la A0

Servo-ul conectat la pinul 5 va fi controlat de pot pe A1 și așa mai departe….

Notă: - Chiar dacă Servo-urile nu sunt alimentate de arduino, asigurați-vă că conectați Gnd-ul servo-urilor la arduino, altfel brațul nu va funcționa.

Pasul 4: Codificare: -

Logica acestui cod este destul de simplă, valorile potențiometrelor sunt stocate într-o matrice, înregistrările sunt apoi parcurse folosind o buclă for și servo-urile fac pașii conform valorilor. Puteți consulta acest tutorial pe care l-am folosit pentru referință „Arduino Potentiometer Servo Control & Memory”

Cod: - (Fișier descărcabil atașat mai jos.)

Mai întâi vom declara toate variabilele necesare la nivel global, astfel încât să le putem folosi pe tot parcursul programului. Nu este necesară nicio explicație specială pentru acest lucru

#include

// Servo Objects Servo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4; // Potentiometer Objects int Pot_0; int Pot_1; int Pot_2; int Pot_3; int Pot_4; // Variabil pentru a stoca Servo Position int Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; // Variabil pentru stocarea valorilor poziției anterioare în Prev_0_Pos; int Prev_1_Pos; int Prev_2_Pos; int Prev_3_Pos; int Prev_4_Pos; // Variabil pentru stocarea valorilor poziției curente în Current_0_Pos; int Current_1_Pos; int Current_2_Pos; int Current_3_Pos; int Current_4_Pos; int Servo_Position; // Stochează unghiul int Servo_Number; // Stochează numărul de servo int Storage [600]; // Matrice pentru stocarea datelor (Creșterea dimensiunii matricei va consuma mai multă memorie) int Index = 0; // Indicele matrice începe de la poziția a 0-a date de caracter = 0; // variabilă pentru a stoca date de la intrarea serială.

Acum vom scrie o funcție de configurare, unde setăm pinii și funcțiile acestora. Aceasta este funcția principală care se execută mai întâi

configurare nulă ()

{Serial.begin (9600); // Pentru comunicarea în serie între arduino și IDE. // Obiectele servo sunt atașate pinilor PWM. Servo_0.attach (3); Servo_1.attach (5); Servo_2.attach (6); Servo_3.attach (9); Servo_4.attach (10); // Servo-urile sunt setate la 100 poziție la inițializare. Servo_0.write (100); Servo_1.write (100); Servo_2.write (100); Servo_3.write (100); Servo_4.write (100); Serial.println („Apăsați„ R”pentru a înregistra și„ P”pentru a reda”); }

Acum trebuie să citim valorile potențiometrelor folosind pinii de intrare analogică și să le mapăm pentru a controla servomotoarele. Pentru aceasta vom defini o funcție și o vom numi Map_Pot ();, îl puteți numi orice doriți, este o funcție definită de utilizator

void Map_Pot ()

{/ * Servo-urile se rotesc la 180 de grade, dar utilizarea acestuia la limite nu este o idee bună, deoarece face ca servo-urile să bâzâie continuu, ceea ce este enervant, așa că limităm servo-ul să se deplaseze între: 1-179 * / Pot_0 = analogRead (A0); // Citiți intrarea din pot și stocați-o în Variable Pot_0. Servo_0_Pos = hartă (Pot_0, 0, 1023, 1, 179); // Servo mape conform valorii cuprinse între 0 și 1023 Servo_0.write (Servo_0_Pos); // Mutați servo-ul în acea poziție. Pot_1 = analogRead (A1); Servo_1_Pos = hartă (Pot_1, 0, 1023, 1, 179); Servo_1.write (Servo_1_Pos); Pot_2 = analogRead (A2); Servo_2_Pos = hartă (Pot_2, 0, 1023, 1, 179); Servo_2.write (Servo_2_Pos); Pot_3 = analogRead (A3); Servo_3_Pos = hartă (Pot_3, 0, 1023, 1, 179); Servo_3.write (Servo_3_Pos); Pot_4 = analogRead (A4); Servo_4_Pos = hartă (Pot_4, 0, 1023, 1, 179); Servo_4.write (Servo_4_Pos); }

Acum vom scrie funcția buclă:

bucla nulă ()

{Map_Pot (); // Apel funcțional pentru a citi valorile potului în timp ce (Serial.available ()> 0) {data = Serial.read (); if (data == 'R') Serial.println ("Înregistrarea se mută …"); if (data == 'P') Serial.println ("Redarea mișcărilor înregistrate …"); } if (data == 'R') // Dacă este introdus 'R', începeți înregistrarea. {// Stocați valorile într-o variabilă Prev_0_Pos = Servo_0_Pos; Prev_1_Pos = Servo_1_Pos; Prev_2_Pos = Servo_2_Pos; Prev_3_Pos = Servo_3_Pos; Prev_4_Pos = Servo_4_Pos; Map_Pot (); // Funcția hartă este reamintită pentru comparație dacă (abs (Prev_0_Pos == Servo_0_Pos)) // valoarea absolută se obține prin compararea {Servo_0.write (Servo_0_Pos); // Dacă valorile se potrivesc servo este repoziționat dacă (Current_0_Pos! = Servo_0_Pos) // Dacă valorile nu se potrivesc {Storage [Index] = Servo_0_Pos + 0; // Valoarea este adăugată la matricea Index ++; // Valoarea indexului incrementată cu 1} Current_0_Pos = Servo_0_Pos; } / * În mod similar, comparația valorii se face pentru toate servoanele, +100 se adaugă fiecare pentru intrare ca valoare diferențială. * / 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 = Servo_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; } / * Valorile sunt tipărite pe monitorul serial, „\ t” este pentru afișarea valorilor în format tabular * / 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); întârziere (50); } dacă (date == 'P') // DACĂ este introdus 'P', începeți să jucați mișcări înregistrate. {for (int i = 0; i <Index; i ++) // Treceți matricea folosind bucla for {Servo_Number = Storage / 100; // Găsește numărul de servo Servo_Position = Stocare % 100; // Găsește poziția servo-comutatorului (Servo_Number) {caz 0: Servo_0.write (Servo_Position); pauză; cazul 1: Servo_1.write (Servo_Position); pauză; cazul 2: Servo_2.write (Servo_Position); pauză; caz 3: Servo_3.write (Servo_Position); pauză; caz 4: Servo_4.write (Servo_Position); pauză; } întârziere (50); }}}

Odată ce codul este gata, încărcați-l acum pe placa arduino

Brațul inteligent este gata să funcționeze. Funcția nu este încă la fel de netedă ca cea realizată de Stoerpeak.

Dacă puteți îmbunătăți codul sau aveți sugestii pentru mine, vă rugăm să ne anunțați în secțiunea de comentarii.

Acestea fiind spuse, să trecem la testare….

Pasul 5: Testare: -

După încărcarea cu succes a codului pe tablă, Deschideți „Serial Monitor” îl puteți găsi în opțiunea Instrumente. Când pornește monitorul serial, arduino se va reseta. Acum puteți controla brațul robot cu ajutorul brațului principal. Dar nu se înregistrează nimic.

Pentru a începe înregistrarea, introduceți „R” pe monitor acum puteți efectua mișcările pe care doriți să le înregistrați.

După ce mișcările sunt terminate, trebuie să introduceți „P” pentru a reda mișcările înregistrate. Servo-urile vor continua să efectueze mișcările atâta timp cât placa nu este resetată.