Braç robòtic senzill i intel·ligent amb Arduino !!!: 5 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:14

En aquest instructiu faré un simple braç robòtic. Això es controlarà mitjançant un braç mestre. El braç recordarà els moviments i jugarà en seqüència. El concepte no és nou. Vaig obtenir la idea de "mini robot braç -per Stoerpeak". Volia fer-ho durant molt de temps, però aleshores era totalment noob i no tenia coneixements sobre programació. Ara per fi n’estic construint un, que sigui senzill, econòmic i que el comparteixi amb tots vosaltres.

Comencem doncs …

Pas 1: coses que necessitareu: -

Aquí teniu una llista de les coses que necessitareu: -

1. Servomotors x 5 enllaç per als EUA: - https://amzn.to/2OxbSH7Link per a Europa: -

2. Potenciòmetres x 5 (he utilitzat 100k.) Enllaç per a EUA: - https://amzn.to/2ROjhDMLink per a Europa: -

3. Arduino UNO. (També podeu utilitzar Arduino Nano) Enllaç per a EUA: - https://amzn.to/2DBbENWLink per a Europa: -

4. Taula de pa. (Us recomano aquest kit) Enllaç per als EUA: - https://amzn.to/2Dy86w4 Enllaç per a Europa: -

5. Bateria. (opcional, estic fent servir un adaptador de 5v)

6. Cartró / Fusta / Taulell solar / acrílic, sempre que estigui disponible o sigui fàcil de trobar.

I també necessitareu Arduino IDE instal·lat.

Pas 2: fer el braç: -

Aquí he utilitzat pals de palets per fer el braç. Podeu utilitzar qualsevol material que tingueu a la vostra disposició. I podeu provar diferents dissenys mecànics per fer un braç encara millor. el meu disseny no és molt estable.

Acabo d’utilitzar cinta de doble cara per enganxar els servos al pal de Popsicle i subjectar-los amb cargols.

Per al braç Master vaig enganxar potenciòmetres a pals de palets i vaig fer un braç.

Si feu referència a les imatges, obtindreu una millor idea.

Ho he muntat tot en una pissarra de mida A4 que es fa servir com a base.

Pas 3: establir connexions: -

En aquest pas farem totes les connexions necessàries. Consulteu les imatges anteriors.

• Connecteu primer tots els servos en paral·lel a la font d'alimentació (el cable vermell a + ve i el cable negre o marró a Gnd)
• A continuació, connecteu els cables de senyal, és a dir, un cable groc o taronja al pin PWM de Arduino.
• Ara connecteu els potenciòmetres a + 5v i Gnd d’arduino en paral·lel.
• Connecteu el terminal central al pin analògic de ardunio.

Aquí s’utilitzen els pins digitals 3, 5, 6, 9 i 10 per controlar els servos

Els pins analògics A0 a A4 s’utilitzen per a l'entrada de potenciòmetres.

El servo connectat al pin 3 es controlarà mitjançant un potenciòmetre connectat a A0

El servo connectat al pin 5 serà controlat per pot a A1, etc.

Nota: - Tot i que els servos no estan alimentats per arduino, assegureu-vos de connectar el Gnd dels servos a arduino o bé el braç no funcionarà.

Pas 4: Codificació: -

La lògica d'aquest codi és bastant simple; els valors dels potenciòmetres s'emmagatzemen en una matriu; els registres es recorren mitjançant un bucle for i els servos fan els passos segons els valors. Podeu consultar aquest tutorial que he utilitzat per a la referència "Servo Control i memòria del potenciómetre Arduino"

Codi: - (Arxiu descarregable adjunt a continuació).

Primer declararem totes les variables necessàries a nivell mundial perquè puguem utilitzar-les a tot el programa. No cal cap explicació especial per a això

#incloure

// Servo Objectes Servo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4; // Objectes potenciòmetres int Pot_0; int Pot_1; int Pot_2; int Pot_3; int Pot_4; // Variable per emmagatzemar Servo Position int Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; // Variable per emmagatzemar valors de posició anteriors int Prev_0_Pos; int Prev_1_Pos; int Prev_2_Pos; int Prev_3_Pos; int Prev_4_Pos; // Variable per emmagatzemar els valors de posició actual a Current_0_Pos; int Current_1_Pos; int Current_2_Pos; int Current_3_Pos; int Current_4_Pos; int Servo_Position; // Emmagatzema l’angle int Servo_Number; // No emmagatzema servo emmagatzematge [600]; // Matriu per emmagatzemar dades (Augmentar la mida de la matriu consumirà més memòria) int Índex = 0; // L’índex de matriu comença a partir de la posició número 0 dades de caràcters = 0; // variable per emmagatzemar dades des de l'entrada en sèrie.

Ara escriurem una funció de configuració, on establirem els pins i les seves funcions. Aquesta és la funció principal que s’executa primer

configuració nul·la ()

{Serial.begin (9600); // Per a la comunicació en sèrie entre arduino i IDE. // Els objectes servo estan units als pins PWM. Servo_0.attach (3); Servo_1.attach (5); Servo_2.attach (6); Servo_3.attach (9); Servo_4.attach (10); // Els servos es configuren a la posició 100 a la inicialització. Servo_0.write (100); Servo_1.write (100); Servo_2.write (100); Servo_3.write (100); Servo_4.write (100); Serial.println ("Premeu 'R' per gravar i 'P' per reproduir"); }

Ara hem de llegir els valors dels potenciòmetres mitjançant pins d’entrada analògica i mapear-los per controlar servos. Per a això definirem una funció i l’anomenarem Map_Pot ();, podeu anomenar-lo com vulgueu, ja que és una funció definida per l'usuari

void Map_Pot ()

{/ * Els servos giren a 180 graus, però no és una bona idea fer-lo servir fins als límits, ja que fa que els servos buzzin contínuament, cosa que molesta, de manera que limitem el servo a moure's entre: 1-179 * / Pot_0 = analogRead (A0); // Llegiu l'entrada del pot i emmagatzemeu-lo a la variable Pot_0. Servo_0_Pos = mapa (Pot_0, 0, 1023, 1, 179); // Mapa de servos segons el valor entre 0 i 1023 Servo_0.write (Servo_0_Pos); // Mou el servo a aquesta posició. Pot_1 = analogRead (A1); Servo_1_Pos = mapa (Pot_1, 0, 1023, 1, 179); Servo_1.write (Servo_1_Pos); Pot_2 = analogRead (A2); Servo_2_Pos = mapa (Pot_2, 0, 1023, 1, 179); Servo_2.write (Servo_2_Pos); Pot_3 = analogRead (A3); Servo_3_Pos = mapa (Pot_3, 0, 1023, 1, 179); Servo_3.write (Servo_3_Pos); Pot_4 = analogRead (A4); Servo_4_Pos = mapa (Pot_4, 0, 1023, 1, 179); Servo_4.write (Servo_4_Pos); }

Ara escriurem la funció de bucle:

bucle buit ()

{Mapa_Pot (); // Crida de funció per llegir els valors del pot mentre que (Serial.available ()> 0) {data = Serial.read (); if (data == 'R') Serial.println ("La gravació es mou …"); if (data == 'P') Serial.println ("Reproducció de moviments gravats …"); } if (dades == 'R') // Si s'introdueix 'R', comenceu a gravar. {// Emmagatzemeu els valors en una variable 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; Mapa_Pot (); // Funció de mapa recuperada per a la comparació si (abs (Prev_0_Pos == Servo_0_Pos)) // el valor absolut s’obté comparant {Servo_0.write (Servo_0_Pos); // Si els valors coincideixen amb el servo es torna a situar si (Current_0_Pos! = Servo_0_Pos) // Si els valors no coincideixen amb {Storage [Index] = Servo_0_Pos + 0; // El valor s'afegeix a la matriu Index ++; // Valor de l'índex incrementat per 1} Current_0_Pos = Servo_0_Pos; } / * De la mateixa manera, la comparació de valors es fa per a tots els servos, s'afegeixen +100 per a l'entrada com a valor diferencial. * / 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; Índex ++; } Actual_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; Índex ++; } 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) {Emmagatzematge [Índex] = Servo_3_Pos + 300; Índex ++; } 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; Índex ++; } Current_4_Pos = Servo_4_Pos; } / * Els valors s’imprimeixen al monitor sèrie, '\ t' és per mostrar valors en 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 ("Índex ="); Serial.println (Índex); retard (50); } si (dades == 'P') // SI s'introdueix 'P', comenceu a reproduir moviments enregistrats. {for (int i = 0; i <Index; i ++) // Recorre la matriu utilitzant el bucle for {Servo_Number = Storage / 100; // Troba el nombre de servos Servo_Position = Emmagatzematge % 100; // Troba la posició del servo interruptor (Servo_Number) {cas 0: Servo_0.write (Servo_Position); trencar; cas 1: Servo_1.write (Servo_Position); trencar; cas 2: Servo_2.write (Servo_Position); trencar; cas 3: Servo_3.write (Servo_Position); trencar; cas 4: Servo_4.write (Servo_Position); trencar; } retard (50); }}}

Quan el codi estigui llest, ara pengeu-lo a la placa arduino

El braç intel·ligent està preparat per funcionar. La funció encara no és tan suau com la que fa Stoerpeak.

Si podeu millorar el codi o tenir algun suggeriment per a mi, feu-m'ho saber a la secció de comentaris.

Dit això, passem a les proves …

Pas 5: proves: -

Després de carregar el codi al tauler amb èxit, Obriu 'Monitor serial' el trobareu a l'opció Eines. Quan s'iniciï el monitor sèrie, l'arduino es restablirà. Ara podeu controlar el braç robòtic amb el braç mestre. Però no s’està enregistrant res.

Per començar a gravar, introduïu "R" al monitor ara podreu realitzar els moviments que vulgueu gravar.

Un cop fets els moviments, heu d'introduir "P" per reproduir els moviments gravats. Els servos continuaran realitzant els moviments sempre que no es restableixi el tauler.