Braccio robotico semplice e intelligente con Arduino !!!: 5 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

In questo tutorial realizzerò un semplice braccio robotico. Questo sarà controllato usando un braccio principale. Il braccio ricorderà le mosse e giocherà in sequenza. Il concetto non è nuovo Ho avuto l'idea da "mini braccio robotico -by Stoerpeak" Volevo farlo da molto tempo, ma allora ero totalmente noob e non avevo alcuna conoscenza della programmazione. Ora finalmente ne sto costruendo uno, mantenendolo semplice, economico e condividendolo con tutti voi.

Quindi iniziamo….

Passaggio 1: cose di cui avrai bisogno: -

Ecco un elenco di cose di cui avrai bisogno: -

1. Servomotori x 5 Link per gli Stati Uniti: - https://amzn.to/2OxbSH7Link per l'Europa: -

2. Potenziometri x 5 (ho usato 100k.)Link per gli Stati Uniti:- https://amzn.to/2ROjhDMLink per l'Europa:-

3. Arduino UNO. (Puoi usare anche Arduino Nano) Link per gli Stati Uniti: - https://amzn.to/2DBbENWLink per l'Europa: -

4. Tagliere. (Suggerisco questo kit) Link per gli Stati Uniti: - https://amzn.to/2Dy86w4Link per l'Europa: -

5. Batteria. (opzionale, sto usando un adattatore 5v)

6. Cartone/legno/tavola solare/acrilico ciò che è disponibile o facile da trovare.

E avrai anche bisogno di Arduino IDE installato.

Passaggio 2: fare il braccio: -

Qui ho usato i bastoncini di ghiacciolo per fare il braccio. Puoi usare qualsiasi materiale a tua disposizione. E puoi provare diversi design meccanici per realizzare un braccio ancora migliore. il mio design non è molto stabile.

Ho appena usato del nastro biadesivo per attaccare i servi allo stick del ghiacciolo e fissarli usando le viti.

Per il braccio Master ho incollato i potenziometri ai bastoncini dei ghiaccioli e ho realizzato il braccio.

Fare riferimento alle immagini ti darà un'idea migliore.

Ho montato il tutto su un cartoncino formato A4 usato come base.

Passaggio 3: creazione di connessioni: -

In questo passaggio effettueremo tutti i collegamenti necessari, fare riferimento alle immagini sopra.

• Prima collega tutti i servi in parallelo all'alimentazione (il filo rosso a +ve e il filo nero o marrone a Gnd)
• Quindi collegare i fili del segnale, ad esempio il filo giallo o arancione al pin PWM di arduino.
• Ora collega i potenziometri a +5v e Gnd di arduino in parallelo.
• Collega il terminale centrale al pin analogico di ardunio.

Qui i pin digitali 3, 5, 6, 9 e 10 sono usati per controllare i servi

I pin analogici da A0 a A4 vengono utilizzati per l'ingresso dai potenziometri.

Il servo collegato al pin 3 sarà controllato dal potenziometro collegato ad A0

Il servo collegato al pin 5 sarà controllato dal potenziometro su A1, e così via….

Nota: anche se i servi non sono alimentati da arduino, assicurati di collegare il Gnd dei servi ad arduino, altrimenti il braccio non funzionerà.

Passaggio 4: codifica: -

La logica di questo codice è abbastanza semplice, i valori dei potenziometri sono memorizzati in un array, i record vengono quindi attraversati utilizzando un ciclo for e i servi eseguono i passaggi secondo i valori. Puoi dare un'occhiata a questo tutorial che ho usato come riferimento "Arduino Potenziometro Servo Control & Memory"

Codice:- (File scaricabile allegato sotto.)

Per prima cosa dichiareremo globalmente tutte le variabili necessarie in modo da poterle utilizzare in tutto il programma. Non è necessaria alcuna spiegazione speciale per questo

#includere

//Oggetti Servo Servo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4; //Oggetti potenziometro int Pot_0; int Pot_1; int Pentola_2; int Pentola_3; int Pentola_4; //Variabile per memorizzare Servo Position int Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; //Variabile per memorizzare i valori della posizione precedente int Prev_0_Pos; int Prev_1_Pos; int Prec_2_Pos; int Prec_3_Pos; int Prec_4_Pos; //Variabile per memorizzare i valori di posizione attuale int Current_0_Pos; int Current_1_Pos; int Current_2_Pos; int Current_3_Pos; int Current_4_Pos; int Servo_Posizione; //Memorizza l'angolo int Servo_Number; //Memorizza il numero di servo int Storage[600]; //Array per memorizzare i dati (l'aumento della dimensione dell'array consumerà più memoria) int Index = 0; // L'indice dell'array inizia dalla posizione 0 char data = 0; //variabile per memorizzare i dati dall'input seriale.

Ora scriveremo una funzione di configurazione, dove impostiamo i pin e le loro funzioni. Questa è la funzione principale che viene eseguita per prima

configurazione nulla()

{ Serial.begin(9600); //Per la comunicazione seriale tra arduino e IDE. //Gli oggetti servo sono collegati ai pin PWM. Servo_0.attach(3); Servo_1.attach(5); Servo_2.attach(6); Servo_3.attach(9); Servo_4.attach(10); //I servi sono impostati sulla posizione 100 all'inizializzazione. Servo_0.write(100); Servo_1.write(100); Servo_2.write(100); Servo_3.write(100); Servo_4.write(100); Serial.println("Premi 'R' per registrare e 'P' per riprodurre"); }

Ora dobbiamo leggere i valori dei potenziometri usando i pin di ingresso analogico e mapparli per controllare i servi. Per questo definiremo una funzione e la chiameremo Map_Pot();, puoi chiamarlo come vuoi, è una funzione definita dall'utente

void Map_Pot()

{ /* I servi ruotano di 180 gradi ma utilizzarlo fino ai limiti non è una buona idea in quanto fa ronzare continuamente i servi, il che è fastidioso, quindi limitiamo il servo a spostarsi tra: 1-179 */ Pot_0 = analogRead(A0); // Legge l'input dal pot e lo memorizza nella Variable Pot_0. Servo_0_Pos = map(Pot_0, 0, 1023, 1, 179); //Mappa i servi secondo il valore compreso tra 0 e 1023 Servo_0.write(Servo_0_Pos); //Sposta il servo in quella posizione. Pot_1 = analogRead(A1); Servo_1_Pos = map(Pot_1, 0, 1023, 1, 179); Servo_1.write(Servo_1_Pos); Pot_2 = analogRead(A2); Servo_2_Pos = map(Pot_2, 0, 1023, 1, 179); Servo_2.write(Servo_2_Pos); Pot_3 = analogRead(A3); Servo_3_Pos = map(Pot_3, 0, 1023, 1, 179); Servo_3.write(Servo_3_Pos); Pot_4 = analogRead(A4); Servo_4_Pos = map(Pot_4, 0, 1023, 1, 179); Servo_4.write(Servo_4_Pos); }

Ora scriveremo la funzione loop:

ciclo vuoto()

{Map_Pot(); //Chiamata di funzione per leggere i valori pot while (Serial.available() > 0) { data = Serial.read(); if (data == 'R') Serial.println("Registrazione mosse…"); if (data == 'P') Serial.println("Riproduzione di mosse registrate…"); } if (data == 'R') //Se viene immesso 'R', avvia la registrazione. { //Memorizza i valori in una variabile 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(); // Funzione mappa richiamata per confronto if (abs(Prev_0_Pos == Servo_0_Pos)) // il valore assoluto si ottiene confrontando { Servo_0.write(Servo_0_Pos); // Se i valori corrispondono, il servo viene riposizionato if (Current_0_Pos != Servo_0_Pos) // Se i valori non corrispondono { Storage[Index] = Servo_0_Pos + 0; // Il valore viene aggiunto all'array Index++; // Valore indice incrementato di 1 } Current_0_Pos = Servo_0_Pos; } /* Allo stesso modo il confronto dei valori viene eseguito per tutti i servi, viene aggiunto +100 ogni per l'immissione come valore differenziale. */ if (abs(Prev_1_Pos == Servo_1_Pos)) { Servo_1.write(Servo_1_Pos); if (Current_1_Pos != Servo_1_Pos) { Memoria[Indice] = Servo_1_Pos + 100; Indice++; } 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) { Memoria[Indice] = Servo_2_Pos + 200; Indice++; } 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) { Memoria[Indice] = Servo_3_Pos + 300; Indice++; } 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) { Memoria[Indice] = Servo_4_Pos + 400; Indice++; } Current_4_Pos = Servo_4_Pos; } /* I valori sono stampati sul monitor seriale, '\t' serve per visualizzare i valori in formato tabulare */ 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 ("Indice = "); Serial.println(Indice); ritardo(50); } if (data == 'P') //IF 'P' viene immesso, Avvia la riproduzione delle mosse registrate. { for (int i = 0; i < Index; i++) //Attraversa l'array utilizzando il ciclo for { Servo_Number = Storage / 100; // Trova il numero di servo Servo_Position = Storage % 100; // Trova la posizione dell'interruttore del servo(Servo_Number) { case 0: Servo_0.write(Servo_Position); rottura; caso 1: Servo_1.write(Servo_Position); rottura; caso 2: Servo_2.write(Servo_Position); rottura; caso 3: Servo_3.write(Servo_Position); rottura; caso 4: Servo_4.write(Servo_Position); rottura; } ritardo(50); } } }

Una volta che il codice è pronto, ora caricalo sulla scheda arduino

Il braccio Smart è pronto per funzionare. La funzione non è ancora così fluida come quella realizzata da Stoerpeak.

Se puoi migliorare il codice o hai qualche suggerimento da darmi, faccelo sapere nella sezione commenti.

Detto questo, passiamo ai test….

Passaggio 5: test: -

Dopo aver caricato con successo il codice sulla scheda, apri "Serial Monitor" e puoi trovarlo nell'opzione Strumenti. Quando il monitor seriale si avvia, arduino si ripristinerà. Ora puoi controllare il braccio robotico usando il braccio principale. Ma non si registra nulla.

Per avviare la registrazione, inserisci 'R' nel monitor ora puoi eseguire le mosse che desideri registrare.

Dopo che le mosse sono state eseguite devi inserire 'P' per riprodurre le mosse registrate. I servi continueranno ad eseguire le mosse finché la scheda non sarà resettata.