Michele Maffucci
- Arduino – lezione 02: facciamo lampeggiare un led
- Arduino – lezione 03: controlliamo un led con un pulsante
- Arduino – lezione 04: realizzare un programma che identifica le variazioni di stato
- Arduino – lezione 05: controllo presenza
Mauro Alfieri
Trovi sotto questo titolo alcuni tutorial base per iniziare con Arduino:
1. Tutorial: il driver usb per Arduino sul Mac
2. Arduino – primi passi
3. Programmare con Arduino – le basi
4. Programmare con Arduino– Pin Digitali e Analogici
5. Programmare con Arduino – led in dissolvenza
6. Programmare con Arduino – leggere un segnale digitale
7. Programmare con Arduino – leggere un segnale analogico
8. Arduino led e pulsante
9. Tutorial: Fotoresistenze e Arduino
10. Tutorial: arduino, 3 led e 3 potenziometri
11. Tutorial: arduino, led rgb e potenziometri
12. Tutorial: arduino, led rgb, potenziometri e pulsanti
13. Tutorial Ardiuno e i servo
14. Tutorial Arduino e i servo II
15. Tutorial Arduino e i servo III
16. Tutorial: Arduino, i servo e i pulsanti
17. Arduino per comandare due servo con i pulsanti
18. Alimenta Arduino e i tuoi progetti a 5v
19. Tutorial: LCD ACM1602B con Arduino
20. Tutorial: SHARP 2D120X e Arduino
21. Tutorial: usare la EEPROM di arduino
22. Tutorial Arduino e le stringhe
23. Tutorial Arduino e le stringhe II
24. Tutorial Arduino Ethernet e SD Card
25. Wifi Shield arduino – il montaggio dell’SPI
26. Wifi Shield arduino – installazione librere ed esempi
27. Rainbow LED Ring V3 Arduino
28. RTC Arduino: usa arduino come orologio
29. RTC shield DS1307: impostare data e ora
Mauro Alfieri
1. Motori passo-passo, cosa sono
2. Motori passo-passo, come riconoscerli
3. Motori passo-passo unipolari, riconoscerne le fasi – prima parte
4. Motori passo-passo unipolari, riconoscerne le fasi – seconda parte
5. Motori passo-passo, pilotarli con arduino – prima parte
6. Motori passo-passo, pilotarli con arduino – seconda parte
7. Motori passo-passo, pilotarli con arduino – terza parte
8. Motori passo-passo, pilotarli con Arduino – quarta parte
9. Motori passo-passo, pilotarli con arduino – il video
10. Motori passo-passo bipolari con Arduino – prima parte
11. Motori passo-passo bipolari con Arduino – seconda parte
12. Motori passo-passo bipolari con Arduino controlla la velocità
13. Motori passo-passo bipolari comandati da interruttori – prima parte
14. Motori passo-passo bipolari comandati da interruttori – seconda parte
15. Motori passo-passo bipolari comandati da interruttori – terza parte
16. Motori passo-passo bipolari comandati da interruttori – quarta parte
17. Motori passo-passo bipolari comandati da interruttori – quinta parte
18. Arduino: lampada rgb a Led
19. Tutorial: Arduino led rgb via Web
20. Tutorial: Giochi di luce con Arduino
21. Giochi di luce con Arduino – secondo gioco – prima parte
22. Giochi di luce con Arduino – secondo gioco – seconda parte
23. Giochi di luce con Arduino – terzo gioco
24. Giochi di luce con Arduino – quarto gioco
25. Giochi di luce con Arduino – quinto gioco
26. Giochi di luce con Arduino – sesto gioco
27. Giochi di luce con Arduino – settimo gioco
28. Giochi di luce con Arduino – ottavo gioco
29. Giochi di luce con Arduino – nono gioco
30. Tutorial: Motor Shield FE – prima parte
31. Tutorial: Motor Shield FE – seconda parte
32. Tutorial: collega la Motor Shield e pilota i motori in CC
33. Motor Shield FE e motore bipolare
34. Tutorial: semaforo per autopista con arduino
35. Inseguitore solare con Arduino – prima parte
36. Tutorial: Arduino interrupt
37. Tutorial: Easy Driver Arduino riduzione del passo
38. Pololu a4983 arduino ridurre i passi del motore
39. Photo Lazy Susan – foto a 360 gradi con arduino
40. Mano robotica con Arduino – un progetto di Giuseppe
Utilizziamo l'istruzione millis()
Arduino e programmare stati finiti
Cos' e' un Automa?
Esso ci permette di automatizzare un processo. Trattiamo in queso caso di automi a stati finiti .
Un automa a stati finiti è una macchina che legge uno stato alla volta. Interviene il concetto di stato. Uno stato non e' altro che la fotografia di un istante, di una situazione ben precisa.
Ad esempio, vediamo un caso pratico come il cancello del nostro condominio.
Alcuni stati che si possono individuare sono:
1. motore apertura cancello spento, chiave non inserita;
2. motore acceso, chiave inserita e girata;
3. motore spento, cancello fermo in apertura
4. motore acceso, cancello in chiusura
5. motore spento, cancello fermo e chiuso
Questi stati sono la memoria del processo di apertura e chiusura del cancello.
Da uno stato all'altro e' possibile passare con il verificarsi di un evento.
Ad esempio, per passare dallo stato (1) allo stato (2), si puo' compiere l'azione di girare la chiave di apertura.
Formalmente, un automa a stati finiti e' formato da:
A=(Stati, Stato iniziale, Stati finali, Funzione di transizione, comandi dei motori e luci)
Gli stati sono un insieme di simboli (S1, S2, S3, ecc.) che identificano la situazione in cui si e' arrivati durante il processo di apertura e chiusura del cancello: hanno informazione della posizione in cui si e' arrivati e quindi di tutta la storia passata per arrivare allo stato stesso.
La funzione di transizione associa ad ogni stato "Si" un altro stato "Sj" a seconda dell'evento che si verifica.
In pratica, la funzione di transizione identifica l'azione da compiere per passare da uno stato ad un altro.
Articolo di Vittorio Zuccalà sulla programmazione a stati finiti
Dopo aver visto come simulare il multitasking con Arduino grazie alla funzione millis() nella prima e seconda parte dell'articolo, andiamo a vedere la programmazione a stati finiti. .....-> leggi tutto l'articolo di Zuccalà
1) ESERCIZIO : nastro trasportatore (realizzato con tecnica grafcet- arduino)
//costanti
//ingressi
const byte fotocellula_presenza__giallo = 2; // pulsante "A" con filo bianco
const byte finecorsa_nastro__viola = 5; //filo verde
const byte finecorsa_inizio_nastro = 3; //filo viola
const byte pulsante__arancione = 4; //filo bianco pulsante "B"
const byte pin7 = 7;
//uscite
const byte motore_avanti_5v__marrone = 31;
const byte motore_avanti_0v__blu = 33;
const byte motore_indietro_0v__bianco = 35;
const byte motore_indietro_5v__verde = 37;
const byte luce_lavorazione__marrone = 26; //led gialla
const byte luce_avanti = 27; //led verde
const byte luce_indietro__bianco = 24; //led rosso
const byte led_PIR = 32;
const unsigned long T5secondi = 10000;
//variabili
unsigned long inizio_intervallo = 0;
int Stato = 0;
unsigned long intervallo = 8000; //8 secondi di intervallo di lavorazione
void setup()
{
pinMode(pin7, INPUT);
pinMode(led_PIR, OUTPUT);
pinMode(fotocellula_presenza__giallo, INPUT); //SF1
pinMode(finecorsa_nastro__viola, INPUT); //SF2
pinMode(finecorsa_inizio_nastro, INPUT); //SF3
pinMode(pulsante__arancione, INPUT); //SB0
pinMode(motore_avanti_5v__marrone, OUTPUT); //KMd
pinMode(motore_avanti_0v__blu, OUTPUT); //KMd
pinMode(motore_indietro_5v__verde, OUTPUT); //KMa
pinMode(motore_indietro_0v__bianco, OUTPUT); //KMa
pinMode(luce_lavorazione__marrone, OUTPUT); //HLY
pinMode(luce_avanti, OUTPUT); //HLG
pinMode(luce_indietro__bianco, OUTPUT); //HLR
//inizializzazione I/O
digitalWrite(pulsante__arancione,HIGH); //PULL-UP
digitalWrite(finecorsa_nastro__viola, HIGH); //PULL-UP
digitalWrite(finecorsa_inizio_nastro, HIGH); //PULL-UP
digitalWrite(fotocellula_presenza__giallo, HIGH); //PULL-UP
digitalWrite(motore_avanti_5v__marrone, LOW);
digitalWrite(motore_avanti_0v__blu, LOW);
digitalWrite(motore_indietro_5v__verde, LOW);
digitalWrite(motore_indietro_0v__bianco, LOW);
digitalWrite(luce_lavorazione__marrone, LOW);
digitalWrite(luce_avanti, LOW);
digitalWrite(luce_indietro__bianco, LOW);
digitalWrite(led_PIR, HIGH);
Serial.begin(9600); //inizializza la seriale
}
void loop()
{
//lettura ingressi
int pulsante = !digitalRead(pulsante__arancione); //logica negata
int finecorsa_inizionastro = !digitalRead(finecorsa_inizio_nastro); //logica negata
int finecorsa_nastro_viola = !digitalRead(finecorsa_nastro__viola); //logica negata
int fotocellula_presenza_giallo = !digitalRead(fotocellula_presenza__giallo); //logica negata
if (digitalRead(pin7) == HIGH) {
digitalWrite(led_PIR, LOW);}
else
{digitalWrite(led_PIR, HIGH);
}
switch(Stato)
{
//fase 0 : tutto fermo
case 0 :
digitalWrite(motore_avanti_5v__marrone, LOW);
digitalWrite(motore_avanti_0v__blu, LOW);
digitalWrite(motore_indietro_5v__verde, LOW);
digitalWrite(motore_indietro_0v__bianco, LOW);
digitalWrite(luce_lavorazione__marrone, LOW);
digitalWrite(luce_indietro__bianco, LOW);
digitalWrite(luce_avanti, LOW);
if (pulsante == HIGH && fotocellula_presenza_giallo == HIGH) {Stato = 1;}
break;
//fase 1: il nastro va in avanti
case 1 : digitalWrite(motore_avanti_5v__marrone, HIGH);
digitalWrite(motore_avanti_0v__blu, HIGH);
digitalWrite(luce_avanti, HIGH);
if (finecorsa_nastro_viola == HIGH)
{
Stato = 2;
inizio_intervallo = millis();
}
break;
//fase 2 il nastro si ferma e conta 5 secondi
case 2 :
digitalWrite(motore_avanti_5v__marrone, LOW); //si ferma il motore
digitalWrite(motore_avanti_0v__blu, LOW);
digitalWrite(luce_avanti, LOW); //si spegne il led verde
digitalWrite(luce_lavorazione__marrone, HIGH); //si accende la luce gialla
if (millis() - inizio_intervallo > intervallo) {Stato = 3;} //conteggio di 5 secondi
break;
//fase 3 : il nastro va indietro
case 3 :
digitalWrite(luce_lavorazione__marrone, LOW); //spegne la luce gialla
digitalWrite(motore_indietro_5v__verde, HIGH); // avvio motore
digitalWrite(motore_indietro_0v__bianco, HIGH);
digitalWrite(luce_indietro__bianco, HIGH); //si accende la luce rossa
if (finecorsa_inizionastro == HIGH)
{
Stato = 0;
}
break;
} //chiusura istruzione SWITCH CASE
} //chiusura loop
...