Catena di montaggio robotizzata con Arduino e braccio robotico
Una tesina di maturità dedicata all’automazione: due Arduino Uno, un braccio robotico, servomotori, sensori, cremagliere e display LCD lavorano insieme per simulare l’assemblaggio automatico di un pennarello.
Vista generale della catena di montaggio automatizzata.
Come è organizzato il sistema
Il progetto divide i compiti tra due Arduino Uno. Il primo, dedicato al braccio, gestisce i movimenti robotici e il display LCD. Il secondo, dedicato alle lavorazioni, controlla le stazioni di assemblaggio, i servomotori a rotazione continua, i sensori e i finecorsa.
Il pezzo da assemblare viene trasferito da una stazione alla successiva. Sensori e microinterruttori verificano la posizione, mentre i servo azionano le cremagliere che spingono i componenti del pennarello nella loro sede.
Materiale principale
🧰 Kit Arduino consigliato
Un kit completo è utile per avere breadboard, cavetti, resistenze, LED, pulsanti e molti componenti necessari per sperimentare con Arduino.
👉 Guarda il kit Arduino consigliatoLink di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
📘 Vuoi imparare Arduino passo dopo passo?
Se vuoi approfondire e realizzare progetti più completi, puoi dare un’occhiata anche ai miei libri dedicati ad Arduino. All’interno troverai spiegazioni semplici, schemi chiari e molti progetti pratici pensati per chi parte da zero.
👉 Scopri i miei libri su ArduinoLink di affiliazione Amazon: in qualità di Affiliato Amazon ricevo un guadagno dagli acquisti idonei, senza alcun costo aggiuntivo per te.
Il quadro elettrico
Il quadro elettrico raccoglie alimentazione, controllo e interfaccia operatore. Al suo interno trovano posto i due Arduino Uno, gli alimentatori, il display LCD I2C, l’amperometro e i pulsanti START e STOP.
Quadro elettrico del sistema.
Perché usare due Arduino Uno
La divisione in due controllori permette di separare la parte robotica dalle lavorazioni. Un Arduino gestisce quindi il braccio e il display, mentre l’altro si occupa della sequenza delle quattro stazioni.
Basetta realizzata per ottenere collegamenti a vite.
Alimentazione dei servomotori
I servomotori non vengono alimentati direttamente dai pin di Arduino. Il sistema utilizza alimentatori separati da 5 V per la parte meccanica e un’alimentazione dedicata ai microcontrollori.
Immagine mantenuta a 606 px.
Display LCD 16×2 I2C
Il display informa l’operatore sullo stato della macchina. L’interfaccia I2C riduce il numero di pin necessari e consente all’Arduino del braccio di mostrare le varie fasi della sequenza.
Amperometro e pulsanti START / STOP
L’amperometro permette di osservare l’assorbimento della parte robotica, mentre i pulsanti consentono di avviare o arrestare il processo.
Pinza e braccio robotico
La pinza è stata adattata alla forma del pennarello. Il braccio utilizza servomotori e strutture pan-tilt combinate per ottenere i movimenti necessari tra le diverse stazioni.
Immagine mantenuta a 231 px.
Struttura completa del braccio robotico.
Immagine mantenuta a 241 px.
Cablaggio e scatola del braccio
I collegamenti dei servo vengono portati a una scatola di distribuzione tramite cavi fissati lungo il braccio. L’uso di morsetti a vite rende più semplici manutenzione e sostituzione dei componenti.
Sensoristica a infrarossi
Ogni stazione utilizza un emettitore IRED e un fototransistor per verificare la presenza del pennarello. Quando il fascio viene interrotto, Arduino può riconoscere che il pezzo è arrivato nella postazione prevista.
Servomotori delle lavorazioni
Le stazioni utilizzano servo a rotazione continua per muovere le cremagliere avanti e indietro. A differenza di un servo posizionale, in questo caso il comando determina direzione e velocità; per fermare con precisione il movimento vengono quindi utilizzati finecorsa esterni.
Immagine mantenuta a 198 px.
Cremagliere stampate in 3D
Le cremagliere trasformano la rotazione dei servomotori in uno spostamento lineare. Sono state progettate per spingere i vari componenti del pennarello nelle rispettive sedi.
Finecorsa meccanici
Otto microinterruttori definiscono le posizioni estreme delle quattro cremagliere. La logica dei finecorsa permette di arrestare il movimento nel punto corretto senza affidarsi soltanto a temporizzazioni.
Magazzini dei componenti
La catena dispone di magazzini dedicati alle varie parti del pennarello. La forma dei contenitori deve guidare i componenti verso la postazione di montaggio senza inceppamenti.
Sketch Arduino del braccio robotico
Questo programma controlla i cinque servo del braccio, il display LCD I2C e la sequenza di posizionamento. Gli angoli e i tempi sono strettamente legati alla meccanica della struttura e devono essere calibrati sul sistema reale.
/*
ARDUINO "BRACCIO"
Questo sketch gestisce:
- 5 servomotori del braccio robotico;
- display LCD 16x2 tramite I2C;
- sequenza di presa, spostamento e posizionamento del pennarello;
- segnale di sincronizzazione verso Arduino "lavorazioni".
Pin servo:
servo1 -> D11
servo2 -> D10
servo3 -> D9
servo4 -> D6
servo5 -> D5
Il valore analogico su A0 viene utilizzato come consenso
all'avvio della sequenza.
Le numerose for() muovono i servo gradualmente per evitare
spostamenti troppo bruschi. Gli angoli e i tempi sono
calibrati meccanicamente sulla struttura del braccio.
*/
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>
Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
int posservo1 =0;
int posservo2 =0;
int posservo3 =0;
int posservo4 =0;
int posservo5 =0;
char com = 0;
int tempo=6000;
int tnorm=500;
void setup() {
pinMode(2, OUTPUT);
lcd.begin(16,2);
lcd.backlight();
Serial.begin(9600);
servo1.attach(11); //BIANCO
servo2.attach(10); //ROSSO
servo3.attach(9); //VIOLA
servo4.attach(6); //GIALLO
servo5.attach(5);//BLU
}
void loop() {
int sensorValue = analogRead(A0);
int valorecomparato=(sensorValue*5/1024);
if (valorecomparato>3)
{
servo1.write(0);
servo2.write(90);
servo3.write(55);
servo4.write(15);
servo5.write(168);
delay(500);
lcd.setCursor(0,0);
lcd.print("Posizionamento");
for (posservo4 = 15; posservo4 <= 59 ;posservo4 += 1) { //1
servo4.write(posservo4);
delay(30);
};
delay(tnorm);
for (posservo3 = 55; posservo3 <= 135 ;posservo3 += 1) { //2
servo3.write(posservo3);
delay(30);
};
delay(tnorm);
lcd.clear();
lcd.setCursor(0,1);
lcd.print("Presa Corpo");
for (posservo1 = 0; posservo1 <= 70 ;posservo1 += 1) { //3
servo1.write(posservo1);
delay(20);
};
delay(tnorm);
for (posservo4 = 59; posservo4 >= 45 ;posservo4 -= 1) { //1
servo4.write(posservo4);
delay(30);
};
delay(tnorm);
delay(1000);
for (posservo5 = 168; posservo5 >= 142 ;posservo5 -= 1) { //5
servo5.write(posservo5);
delay(30);
};
delay(tnorm);
for (posservo3 = 135; posservo3 <= 180 ;posservo3 += 1) { //2
servo3.write(posservo3);
delay(30);
};
delay(tnorm);
for (posservo4 = 45; posservo4 <= 59 ;posservo4 += 1) { //1
servo4.write(posservo4);
delay(30);
};
delay(tnorm);
lcd.clear();
lcd.print("Posizionamento");
lcd.setCursor(0,1);
lcd.print("1 Sede");
delay(tnorm);
for (posservo2 = 90; posservo2 <= 180 ;posservo2 += 1) { //6
servo2.write(posservo2);
delay(10);
};
delay(tnorm);
for (posservo4 = 59; posservo4 <= 80 ;posservo4 += 1) { //7
servo4.write(posservo4);
delay(30);
};
delay(tnorm);
for (posservo3 = 180; posservo3 >= 72 ;posservo3 -= 1) { //7.1
servo3.write(posservo3);
delay(20);
};
delay(tnorm);
for (posservo5 = 142; posservo5 >= 131 ;posservo5 -= 1) { //7.2
servo5.write(posservo5);
delay(20);
};
delay(tnorm);
for (posservo4 = 80; posservo4 <= 100 ;posservo4 += 1) { //8
servo4.write(posservo4);
delay(10);
};
delay(tnorm);
for (posservo3 = 72; posservo3 >= 68 ;posservo3 -= 1) { //8.1
servo3.write(posservo3);
delay(20);
};
lcd.clear();
lcd.print("1 Lavorazione");
lcd.setCursor(0,1);
lcd.print("Ins Tampone");
delay (1000);
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
delay(tnorm);
for (posservo3 = 68; posservo3 <= 72 ;posservo3 += 1) { //8.2
servo3.write(posservo3);
delay(20);
};
delay(tempo);
for (posservo4 = 100; posservo4 >= 80 ;posservo4 -= 1) { //9
servo4.write(posservo4);
delay(20);
};
delay(tnorm);
lcd.clear();
lcd.print("Posizionamento");
lcd.setCursor(0,1);
lcd.print("2 Sede");
delay(tnorm);
for (posservo5 = 131; posservo5 >= 102 ;posservo5 -= 1) { //10
servo5.write(posservo5);
delay(20);
};
delay(tnorm);
for (posservo4 = 80; posservo4 <= 107 ;posservo4 += 1) { //11
servo4.write(posservo4);
delay(10);
};
lcd.clear();
lcd.print("2 Lavorazione");
lcd.setCursor(0,1);
lcd.print("Ins Tappo");
delay (1000);
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
delay(tempo);
for (posservo4 = 107; posservo4 >= 85 ;posservo4 -= 1) { //12
servo4.write(posservo4);
delay(20);
};
delay(tnorm);
lcd.clear();
lcd.print("Posizionamento");
lcd.setCursor(0,1);
lcd.print("3 Sede");
delay(tnorm);
for (posservo2 = 180; posservo2 >= 0 ;posservo2 -= 1) { //13
servo2.write(posservo2);
delay(20);
};
delay(tnorm);
for (posservo5 = 102; posservo5 >= 72 ;posservo5 -= 1) { //14
servo5.write(posservo5);
delay(20);
};
delay(tnorm);
for (posservo4 = 85; posservo4 <= 100 ;posservo4 += 1) { //15
servo4.write(posservo4);
delay(10);
};
lcd.clear();
lcd.print("3 Lavorazione");
lcd.setCursor(0,1);
lcd.print("Ins Pennino");
delay (1000);
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
delay(tempo);
for (posservo4 = 100; posservo4 >= 85 ;posservo4 -= 1) { //16
servo4.write(posservo4);
delay(20);
};
lcd.clear();
lcd.print("Posizionamento");
lcd.setCursor(0,1);
lcd.print("4 Sede");
delay(tnorm);
for (posservo5 = 72; posservo5 >= 46 ;posservo5 -= 1) { //17
servo5.write(posservo5);
delay(20);
};
delay(tnorm);
for (posservo4 = 85; posservo4 <= 100 ;posservo4 += 1) {//18
servo4.write(posservo4);
delay(10);
};
lcd.clear();
lcd.print("4 Lavorazione");
lcd.setCursor(0,1);
lcd.print("Ins Cappuccio");
delay (1000);
digitalWrite(2, HIGH);
delay(1000);
digitalWrite(2, LOW);
delay(tempo);
for (posservo4 = 100; posservo4 >= 20 ;posservo4 -= 1) { //19
servo4.write(posservo4);
delay(20);
};
lcd.clear();
lcd.print("Riposizionamento");
delay(tnorm);
for (posservo5 = 46; posservo5 >= 20 ;posservo5 -= 1) { //20
servo5.write(posservo5);
delay(20);
};
delay(tnorm);
for (posservo1 = 70; posservo1 >= 0 ;posservo1 -= 1) { //21
servo1.write(posservo1);
delay(20);
};
delay(tnorm);
for (posservo5 = 20; posservo5 <= 167 ;posservo5 += 1) { //22
servo5.write(posservo5);
delay(20);
};
for (posservo4 = 20; posservo4 >= 15 ;posservo4 -= 1) {//23
servo4.write(posservo4);
delay(20);
};
for (posservo3 = 72; posservo3 <= 55 ;posservo3 += 1) { //24
servo3.write(posservo3);
delay(20);
};
lcd.clear();
lcd.print(" Attesa");
lcd.setCursor(0,1);
lcd.print(" Comando");
for (posservo2 = 0; posservo2 <= 90 ;posservo2 += 1) { //25
servo2.write(posservo2);
delay(20);
};
}
else{
servo1.write(0);
servo2.write(90);
servo3.write(55);
servo4.write(15);
servo5.write(168);
}
}
⬇️ Scarica newLiquidCrystal ⬇️ Scarica sketch Arduino braccio
Sketch Arduino delle lavorazioni
Il secondo Arduino gestisce quattro servo a rotazione continua, quattro sensori a infrarossi e otto microinterruttori. Per ogni servo sono presenti valori distinti di avanti, fermo e indietro, necessari alla calibrazione del moto.
/*
ARDUINO "LAVORAZIONI"
Questo sketch gestisce:
- 4 servomotori a rotazione continua;
- 8 microinterruttori di finecorsa;
- 4 sensori a infrarossi;
- segnale di avvio ricevuto dall'Arduino del braccio.
I valori "avanti", "fermo" e "indietro" sono specifici
per ciascun servo a rotazione continua e richiedono
calibrazione sul proprio esemplare.
I finecorsa impediscono alle cremagliere di superare
le posizioni meccaniche previste.
*/
#include <Servo.h>
Servo servolav1;
Servo servolav2;
Servo servolav3;
Servo servolav4;
const int avviolavoraz = A5;//avviolavorazione ricevuto da arduino braccio
int valavviolavoraz=0;//avviolavoraz ricevuto da arduino braccio
const int microD1 = 2; //micro didietro // 1
const int microA1 = 3; //micro davanti
const int senslav1 = A0;// sensore
int valmicroD1 = 0;//micro didietro // 1
int valmicroA1 = 0;//micro davanti
int valsenslav1 = 0;// sensore
int avanti1 = 97; // 1
int fermo1 = 88;
int indietro1= 75;
const int microD2 = 4; //micro didietro 2
const int microA2 = 5; //micro davanti
const int senslav2 = A1;// sensore
int valmicroD2 = 0;//micro didietro 2
int valmicroA2= 0;//micro davanti
int valsenslav2 = 0;// sensore
int avanti2 = 98; // 2
int fermo2 = 93.5;
int indietro2= 89;
const int microD3 = 7; //micro didietro 3
const int microA3 = 8; //micro davanti
const int senslav3 = A2;// sensore
int valmicroD3 = 0;//micro didietro 3
int valmicroA3= 0;//micro davanti
int valsenslav3 = 0;// sensore
int avanti3 = 93; // 3
int fermo3= 85; // 90 oppure 83.5
int indietro3= 75;
const int microD4 = 12; //micro didietro 4
const int microA4 = 13; //micro davanti
const int senslav4 = A3;// sensore
int valmicroD4 = 0;//micro didietro 4
int valmicroA4= 0;//micro davanti
int valsenslav4= 0;// sensore
int avanti4 = 100; // 4
int fermo4= 92;
int indietro4= 87;
void setup() {
Serial.begin(9600);
servolav1.attach(6);
servolav2.attach(9);
servolav3.attach(10);
servolav4.attach(11);
servolav1.write(indietro1);
servolav2.write(indietro2);
servolav3.write(indietro3);
servolav4.write(indietro4);
}
void loop() {
valavviolavoraz = (analogRead(avviolavoraz)*5/1023);
valmicroD1 = digitalRead(microD1);
valmicroA1 = digitalRead(microA1);
valsenslav1 = (analogRead(senslav1)*5/1023);
valmicroD2 = digitalRead(microD2);
valmicroA2 = digitalRead(microA2);
valsenslav2= (analogRead(senslav2)*5/1023);
valmicroD3 = digitalRead(microD3);
valmicroA3= digitalRead(microA3);
valsenslav3= (analogRead(senslav3)*5/1023);
valmicroD4 = digitalRead(microD4);
valmicroA4= digitalRead(microA4);
valsenslav4= (analogRead(senslav4)*5/1023);
if((valsenslav1 >2) && (valavviolavoraz>2)) //avviolav ricevuto da arduino braccio
{delay(1000);
servolav1.write(avanti1);
};
if(valmicroA1==HIGH)
{servolav1.write(fermo1);
servolav1.write(indietro1);
};
if(valmicroD1==HIGH)
{servolav1.write(fermo1);
delay(200);
servolav1.write(100);
delay(100);
servolav1.write(fermo1);
};
if((valsenslav2 >2) && (valavviolavoraz>2)) //avviolav ricevuto da arduino braccio
{delay(1000);
servolav2.write(avanti2);
};
if(valmicroA2==HIGH)
{servolav2.write(fermo2);
servolav2.write(indietro2);
};
if(valmicroD2==HIGH)
{servolav2.write(fermo2);
delay(200);
servolav2.write(100);
delay(200);
servolav2.write(fermo2);
};
if((valsenslav3 >2) && (valavviolavoraz>2)) //avviolav ricevuto da arduino braccio
{delay(1000);
servolav3.write(avanti3);
};
if(valmicroA3==HIGH)
{servolav3.write(fermo3);
servolav3.write(indietro3);
};
if(valmicroD3==HIGH)
{servolav3.write(fermo3);
delay(200);
servolav3.write(95);
delay(100);
servolav3.write(fermo3);
};
if((valsenslav4 >2) && (valavviolavoraz>2)) //avviolav ricevuto da arduino braccio
{delay(1000);
servolav4.write(avanti4);
};
if(valmicroA4==HIGH)
{servolav4.write(fermo4);
servolav4.write(indietro4);
};
if(valmicroD4==HIGH)
{servolav4.write(fermo4);
delay(200);
servolav4.write(95);
delay(200);
servolav4.write(fermo4);
};
}
⬇️ Scarica programma_arduino_lavorazioni.ino
Come dialogano le due schede
La logica generale è quella di una macchina sequenziale: il braccio porta il pennarello nella stazione prevista e invia un consenso all’Arduino delle lavorazioni. Quest’ultimo verifica i sensori della stazione, aziona la relativa cremagliera fino ai finecorsa e conclude l’operazione prima della fase successiva.
Debug e messa a punto
- provare ogni servomotore singolarmente prima di eseguire la sequenza completa;
- calibrare gli angoli del braccio con movimenti lenti;
- verificare uno alla volta tutti i finecorsa;
- controllare la lettura dei fototransistor prima di collegare le lavorazioni;
- assicurarsi che gli alimentatori abbiano corrente sufficiente per i servo;
- mantenere una massa comune tra i circuiti che scambiano segnali;
- testare prima le sequenze senza carico meccanico e poi con il pennarello.
Cosa devi ricordare
- La macchina utilizza due Arduino Uno con compiti separati.
- Il braccio robotico è comandato da servomotori posizionali.
- Le lavorazioni usano servo a rotazione continua e cremagliere.
- I sensori infrarossi verificano la presenza del pezzo nelle stazioni.
- Otto microinterruttori funzionano come finecorsa meccanici.
- Il display LCD I2C mostra le fasi del processo.
- Le alimentazioni dei servomotori devono essere dimensionate indipendentemente dai pin di Arduino.
Domande frequenti
Perché sono stati usati due Arduino Uno?
Per separare la gestione del braccio robotico dalla gestione delle quattro stazioni di lavorazione, riducendo la complessità di ciascun programma.
Perché servono i finecorsa?
I servo a rotazione continua non conoscono una posizione assoluta. I microinterruttori permettono quindi di sapere quando una cremagliera ha raggiunto il limite meccanico previsto.
Il display è indispensabile per il funzionamento?
No. Serve principalmente come interfaccia informativa per mostrare all’operatore lo stato della sequenza.
Posso realizzare lo stesso progetto con un solo Arduino?
In teoria è possibile ridisegnando hardware e software, ma la divisione in due controllori semplifica la gestione di molti servo, sensori e segnali.