Controllare un nastro trasportatore fischertechnik con

TITOLO ESPERIENZA:
Controllare un nastro trasportatore fischertechnik con
Arduino
PRODOTTI UTILIZZATI:
OBIETTIVO:
Interfacciare e controllare un modello di nastro trasportatore
fischertechnik (a 24 Volt) con una scheda Arduino (a 5 Volt)
AUTORE:
Pietro Alberti (Media Direct srl, Italia) – [email protected]
RINGRAZIAMENTI:
Wohlfarth Laurenz (fischertechnik GmbH, Germany)
Dedicato alla mia famiglia:
Marco, Luca, Chiara, Francesco e Maria
10-01-2013: Versione finale
© Media Direct srl – Italy
1/12
fischertechnik: DESCRIZIONE DEL MODELLO
Modello di nastro trasportatore: 275 mm di lunghezza, trasporta pezzi con un diametro fino a
29 mm. Possibilità di combinare assieme più nastri trasportatori. Dimensioni del modello:
275x210x70 mm.
Il modello comprende:
- 1 motore a corrente continua a 24V
- 1 pulsante (libero da potenziale) utilizzabile come come start/stop o contatore di impulsi
(essendo accoppiato all’asse del motore psi può usare per misurare la distanza percorsa).
- 2 barriere fotoelettriche (fototransistor e lampade lenticolari a 24V).
- 1 pezzo cilindrico da trasportare (Ø 29 mm, h = 25 mm).
Ingressi/Uscite:
- 3 ingressi digitali (2 barriere fotoelettriche come fine corsa e 1 pulsante/contatore).
- 1 uscita (1 motore per il moto del nastro trasportatore, comandabile mediante 2 uscite per la
direzione avanti/indietro).
© Media Direct srl – Italy
2/12
Il modello fischertechnik arriva già assemblato e con un foglietto che descrive precisamente la
piedinatura dei contatti disponibili nella scheda per l’interfacciamento:
Il modello fischertechnik funziona a 24 Volt!
motore 24 V:
© Media Direct srl – Italy
lampada 24 V:
fototransistor 24 V:
3/12
ESCRIPTION
Arduino: COMPONENTI
1 Arduino Duemilanove…
… ma si può usare una qualsiasi delle
analoghe schede (Arduino Uno Rev3,
Arduino Leonardo, …): l’importante è che
abbiano almeno 3 ingressi analogici e 2
uscite digitali.
1 Shield TinkerKit Sensor:
solo per semplificarmi il cablaggio
(opzionale)
2 moduli relè TinkerKit:
per azionare il motore (avanti e indietro)
2 potenziometri (10 kOhm)
per ridurre 24V 5V (dai fototransistor)
Alimentazione (per Arduino)
Arriva dal cavo USB collegato al computer. Una
volta programmato Arduino, si può staccare il
cavo e usare una batteria 9V.
Arduino funziona a 5 Volt!
© Media Direct srl – Italy
4/12
LA SFIDA
Il modello di nastro trasportatore fischertechnik richiede 24V, essendo esso un TRAINING
MODEL da controllare mediante dispositivi del mondo reale come i PLC industriali di Siemens.
Quindi i motori e le lampade richiedono 24 V.
Arduino può comandare il motore a 24V senza problemi: ho usato 2 relè.
Fischertechnik ora offre due uscite per pilotare il motore: Q1 avanti; Q2 indietro: grande!
Ma il segnale di input che arriva dalla barriera luminosa è a 24 V!
Arduino accetta al massimo 5 V, no 24 V.
La sfida è leggere il segnale dal fototransistor con Arduino!
Si tratta di un problema di condizionamento del segnale (max: 5V, 40 mA).
Ho usato un circuito molto semplice mediante un trimmer da a 10 KOhm.
Attenzione: ho collegato la massa di fischertechnik (-) alla massa di Arduino (gnd): senza la
massa comune, l’ADC legge rumore.
Prima di collegare i fili ad Arduino ho regolato manualmente il trimmer grazie ad un comune
multimetro: mi sono fermato quando sono arrivato a 5 V.
Da un punto di vista analitico:
Vout = Vin *R2/( R1 + R2)
V
R1+R2
R2
Vout = Vin *R2/( R1 + R2)
IMAX
0V
24 V
10.000 Ω
10.000 Ω
≈ 2.000 Ω
0V
5V
0
3 mA
Quindi ora il voltaggio è di circa 5V e la corrente di pochi mA.
Ho usato alcuni plug di fischertechnik per collegare il trimmer evitando di usare una basetta di
prova e lo stagnatore:
© Media Direct srl – Italy
5/12
SCHEMA DEI COLLEGAMENTI ELETTRICI
Allego uno schema di collegamento elettrico. Potrebbe essere utile.
Ho preferito usare carta e penna… anche se forse avrei fatto prima a computer ;-)
© Media Direct srl – Italy
6/12
COME FUNZIONA IL MODELLO: ALGORITMO
Lo scopo è muovere avanti e indietro il cilindretto nero tra le due barriere luminose.
Ho sviluppato un programma e l’ho scaricato su Arduino mediante cavo USB.
Quando si alimenta Arduino (mediante il cavo USB o una batteria esterna) il programma
scaricato parte automaticamente.
Il principio di funzionamento è descritto dalle seguenti azioni 1-3, ripetute all’infinito (default):
1) Motore avanti (dalla barriera 1 alla 22): il cilindro deve essere posizionato a metà nastro
(solo la prima volta)
2) quando il cilindro arriva alla barriera 2: ferma il motore, aspetta 3 s, motore indietro
3) quando il cilindro arriva alla barriera 1: ferma il motore, aspetta 3 s, motore avanti per 1.5
s, (riposizionamento iniziale)
4) ripeti il ciclo dal punto 1)
PROGRAMMAZIONE DI ARDUINO (Processing)
Ho usato Processing per programmare Arduino, in linguaggio C.
Il programma è molto semplice, giusto per testare il sistema.
Molte migliorie si possono fare.
Ho programmato il sistema definendo la variabile di stato del sistema (“stato”), per capire “a
che punto siamo”.
stato = 0: cilindro in mezzo al nastro, motore avanti verso la barriera 2
stato = 1: cilindro arrivato alla barriera 2 (stop motore, attesa 3 s, motore indietro)
stato = 2: cilindro arrivato alla barriera 1 (stop motore, attesa 3 s, motore avanti fino a metà)
Ho inoltre usato lo Strumento > Monitor Seriale di Processing per mostrare a computer alcuni
messaggi indicanti lo stato del sistema..
/*
Uscite:
pin 10: motore nastro trasp. indietro (uscita digitale: HIGH/LOW)
pin 11: motore nastro trasp. avanti (uscita digitale: HIGH/LOW)
Ingressi:
pin A0: fine corsa 2 (ingresso analogico 0-5V)
pin A1: fine corsa 1 (ingresso analogico 0-5V)
0V = oggetto presente (phototransistor non illuminato)
5V = object non presente (phototransistor illuminato)
Ho deciso una soglia di 2.5V per decidere se l’oggetto è presente o no.
*/
const int MotAvantiPin = 11;
sullo shield-sensor
const int MotIndietroPin = 10;
sullo shield-sensor
int stato;
int sensorValue;
float voltage;
// USCITA DIGITALE: relè motore collegato a "OUTPUT 0" (pin 11)
// USCITA DIGITALE: relè motore collegato a "OUTPUT 1" (pin 10)
// stato del sistema
// valore letto dal sensore: 0...1023
// valore letto dal sensore, convertito in 0...5 Volt
// la routine 'setup' viene eseguita per PRIMA e una sola volta, all'avvio o quando si preme il
pulsante reset sulla scheda Arduino
void setup() {
Serial.begin(9600);
// inizializza la comunicazione seriale a 9600 bps
digitalWrite(MotIndietroPin, LOW); // Avvia nastro trasportatore
digitalWrite(MotAvantiPin, HIGH);
// Nastro avanti
Serial.println("Nastro AVANTI");
Serial.println("Posizionare pezzo in mezzo al nastro");
stato=0;
// 0 = avanzamento da fc1 -> fc2
}
// la routine 'loop' viene eseguita all'infinito
void loop() {
if (stato==0)
// Nastro AVANTI: attesa fc2
{
sensorValue = analogRead(A0);
// legge ingresso di tensione A0 (0…1023), FC2
voltage = sensorValue * (5.0 / 1023.0); // converte da 0...1023 0...5V
if (voltage < 2.5)
{
// Barriera fotoelettrica interrotta (presenza oggetto)
© Media Direct srl – Italy
7/12
stato=1;
// 1 = raggiunto fc2
digitalWrite(MotAvantiPin, LOW); // Nastro stop
Serial.println("Raggiunto fine corsa FC2: stop 3 s, poi indietro");
delay(3000); //pausa 3 secondi
Serial.println("Nastro INDIETRO");
digitalWrite(MotIndietroPin, HIGH); // Nastro indietro
}
}
if (stato==1)
// Oggetto arrivato a FC2 e Nastro indietro: attesa fc1
{
sensorValue = analogRead(A1);
// legge ingresso di tensione A1 (0…1023), FC1
voltage = sensorValue * (5.0 / 1023.0); // converte da 0...1023 0...5V
if (voltage < 2.5)
{
// Barriera fotoelettrica interrotta (presenza oggetto)
stato=2;
// 2 = raggiunto fc2
digitalWrite(MotIndietroPin, LOW); // Nastro stop
Serial.println("Raggiunto fine corsa FC1: stop 3 s, poi riposiziona in centro");
delay(3000); //pausa 3 secondi
digitalWrite(MotAvantiPin, HIGH); // Nastro avanti
delay(1500); //pausa 1.5 secondi
Serial.println("---- POSIZONE INIZIALE ----");
digitalWrite(MotAvantiPin, LOW); // Nastro STOP
delay(5000); //pausa 5 secondi
digitalWrite(MotAvantiPin, HIGH); // Nastro AVANTI, riparte il ciclo
stato=0;
//ripristina stato iniziale, così riparte il tutto...
}
}
}
© Media Direct srl – Italy
8/12
FOTO E ANNOTAZIONI
1a versione:
Nastro trasportatore fischertechnik +
Arduino Duemilanove
Cavi connessi “al volo”, versione alfa ma molto
chiara.
Cavi connessi alla morsettiera con contatti a
molla sulla scheda fischertechnik.
2a versione:
Ho usato un cavo flat (piattina) con
connettore IDC 26P, per un cablaggio migliore
e per facilitare lo sgancio tra il modello
fischertechnik e il mondo Arduino.
I 24 V arrivano da un alimentatore della
Siemens che ho usato in passato per
interfacciare i PLC Siemens con i modelli
industriali (Training Models) di fischertechnik.
Particolare del collegamento del potenziometro
usato per abbassare a 5V i 24V che arrivano
dalla barriera fotoelettrica.
Versione finale:
Ho realizzato un box di interfacciamento tra
Arduino e fischertechnik:
- basetta millefiori (a saldare)
- 3 trimmer 10 Kohm
- 2 relè tinkerkit
- 1 connettore 8 pin (lato Arduino)
- 1 connettore 8 pin (lato fischertechnik)
- morsettiera per 2 fili (per alimentazione 24V)
Inoltre ho implementato un contatore di
impulsi provenienti dallo switch I3 accoppiato
all’asse del motore (tipo encoder),
visualizzando questo dato nella seriale.
Infine ho interfacciato il sistema con l’ambiente
Processing, sincronizzando le informazioni
mediante trasmissione seriale.
© Media Direct srl – Italy
9/12
ULTIMO AGGIORNAMENTO: 10-01-2013
Ho deciso di chiudere il progetto cercando di realizzare un sistema il più possibile “chiaro”.
Ho realizzato un box di
interfacciamento tra Arduino e
fischertechnik:
- basetta millefiori (a saldare)
- 3 trimmer 10 Kohm
- 2 relè tinkerkit
- 1 connettore 8 pin (lato Arduino)
- 1 connettore 8 pin (lato fischertechnik)
- morsettiera per 2 fili (per
alimentazione 24V)
Nel software di gestione di Arduino ho
implementato un contatore di impulsi
provenienti dallo switch I3 accoppiato
all’asse del motore (tipo encoder),
visualizzando questo dato nella seriale.
Interessante è stata la soluzione
software per evitare l’effetto rimbalzo
nella commutazione degli ingressi
digitali.
Stati: 0,1,2,3
Impulsi: 100 + nr_impulsi_reali
Infine ho interfacciato il sistema con
l’ambiente Processing, sincronizzando
le informazioni mediante trasmissione
seriale e con visualizzazione grafica dello
stato dei sensori e del motore del nastro
trasportatore.
Processing riceve via seriale da Arduino
dei dati numerici che rappresentano lo
stato (valori: 0,1,2,3,4) o il numero di
impulsi contati dal sensore I3 (valore
aumentato di 100).
© Media Direct srl – Italy
10/12
SCHERMATE COL SOFTWARE “PROCESSING”
STATO
0
Il pezzo (cerchio verde) avanza da sx
verso dx
Schermata di Processing
1
Il pezzo (cerchio verde) ha raggiunto il
fine corsa a destra:
- led sensore dx acceso
- visualizzazione Numero di Impulsi
2
Il pezzo (cerchio verde) avanza da dx
verso sx
3
Il pezzo (cerchio verde) ha raggiunto il
fine corsa a sinistra:
- led sensore sx acceso
- visualizzazione Numero di Impulsi
Riparte il ciclo da stato=0 …
© Media Direct srl – Italy
11/12
CONSIDERAZIONI FINALI
All’inizio pensavo fosse un progetto troppo semplice (solo 3 ingressi e 2 uscite). Poi invece si è
rivelato molto interessante e ricco di aspetti tecnici hardware/software e di spunti per
miglioramenti da implementare in seguito.
Ecco alcune idee.
Hardware:
- Adattamento elettrico da 245 Volt. Notare che la mia soluzione è probabilmente la più
semplice ed economica. Sicuramente si può migliorare il circuito utilizzando amplificatori
operazionali, diodi, ecc.
- Numero di Ingressi/Uscite: si potrebbe aumentare il numero di ingressi/uscite (usando quindi
più relè, magari più piccoli) e quindi poter gestire anche i modelli più complessi di
fischertechnik a 24V (braccio robotico, nastro trasportatore, stazione pneumatica, …)
-…
Software:
Il software che ho realizzato è “essenziale”, giusto per mettere in funzione il sistema. Ma tante
idee mi sono venute come possibili completamenti e/o varianti:
- inserire pulsanti a video per lo start/stop del modello (usando la comunicazione seriale)
- inserire suoni/animazioni correlati allo stato del sistema
- usare altro ambiente di sviluppo, magari Visual Basic/C
- controllare il sistema via Web, usando una scheda Arduino Ethernet (esiste eventualmente
anche un apposito shield) e utilizzandola come server Web
-…
Grazie per la vostra attenzione!
Pietro Alberti
[email protected]
10 Gennaio 2013
Disclaimer: il sottoscritto declina ogni responsabilità per eventuali danni a persone e/o cose
derivanti dall’uso del presente documento.
© Media Direct srl – Italy
12/12