7 - Arduino Cocktail Machine

Attimi di pazzia mi hanno portato a costruire una "Cocktail Machine" a basso costo, la spesa totale è stata di 270 euro.
La struttura come si può notare nella foto è principalmente in legno e plastica pieghevole (materiale usato per costruire robot).
Le bottiglie dovranno essere posizionate a testa in giù sopra la macchina, con inserito l'apposito tappo che le mette in comunicazione con le valvole.
In molti mi hanno chiesto perché non ho usato dell' elettrovalvole al posto delle mie valvole di plastica bianche e arancioni, la risposta è semplice!!!!....16 elettrovalvole mi venivano a costare più di 1000 euro, mentre 16 semplici valvole di plastica (usate per imbottigliare il vino) mi sono costate 30 euro.

Il cervello di questa macchina è un Arduino Mega, dotato di 54 pin digitali e 16 analogici che mi hanno permesso di collegare:
- Keypad 3x4 (per gestire INPUT);
- display LCD 16x2 (per gestire OUTPUT);
- 1 motore passo passo bipolare da 2,5A per muovere il braccio principale;
- 3 servomotori (2 per comandare i movimenti del frullino ed 1 per aprire le valvole);
- 1 motore DC per far girare il frullino;
- 1 sensore di forza per verificare se arriva il liquido nel bicchiere;
- 1 sensore a infrarossi per verificare la presenza o meno del bicchiere;
- 10 led per illuminare la macchina e 1 led RGB per gestire un gioco di luci!

Come funziona la macchina??
Semplicissimo, si digita il codice del prodotto che corrisponde al cocktail che vogliamo e si conferma con il tasto "#" del keypad, a questo punto basta inserire il bicchiere sull'apposito vassoio e attendere che il cocktail si pronto.

Come si programma??
La prima cosa da fare, sarà quella di programmare i vari cocktail a nostro piacimento tramite un Pc, modificando un semplicissimo file.
Il file da modificare nel Pc si presenta così:

1 -  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0;
2 -  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0;
3 -  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0;
4 -  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0;
5 -  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0;
.......
.......
99 - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0;

il numero davanti ad ogni fila corrisponde al codice del cocktail, mentre i 16 zeri seguenti corrispondono alle 16 valvole e il 17° zero è riferito al frullino.
Per poter creare e attivare il cockatil numero 1, basterà quindi sostituire lo 0 che corrisponde alla valvola della bevanda che vogliamo con un valore che rappresenta il tempo che la valvola rimarrà aperta.
Se vogliamo aprire una valvola 3 secondi dovremo scrivere al posto dello zero il valore 3000.
Per esempio se vogliamo aprire la valvola n°3 2 secondi, la valvola n°7 1,5 secondo e la valvola n°11 3 secondi il file lo dovremo modificare così:

1 -  0,0,2000,0,0,0,1500,0,0,0,3000,0,0,0,0,0,0;

per poter attivare il frullino basterà sostituire al 17° zero il valore 1.
Quindi se nel nostro cocktail numero 1 vogliamo attivare la frullata finale dovremo modificare il file così:

1 -  0,0,2000,0,0,0,1500,0,0,0,3000,0,0,0,0,0,1;

Così facendo se il cliente seleziona il cocktail numero 1 il braccio della macchina andrà ad aprire la valvola n°3 2 secondi, la valvola n°7 1,5 secondi, la valvola n°11 3 secondi ed infine attiverà il frullino per shakerare il cocktail.

Come funzionano i sensori?
Nella macchina ho inserito due sensori che permettono di controllare diverse situazioni:

-SENSORE DI FORZA posizionato sotto il vassoio, permette di verificare se le bottiglie sono finite!
Quando vado ad aprire una valvola se il sensore riconosce una forza in aumento dovuta al liquido che scende nel bicchiere la macchina non segnala niente, mentre se a valvola aperta la forza rimane costante significa che non sta scendendo liquido e la macchina va di conseguenza in stato di errore segnalando di controllare la valvola n°X.

-SENSORE A RAGGI INFRAROSSI posizionato sopra al vassoio, permette di verificare la presenza del bicchiere! Questo sensore (molto usato nella robotica) permette di verificare se davanti ad esso c'è qualche ostacolo, io l ho usato nella macchina per tener monitorata la presenza del bicchiere sul vassoio. Nel caso in cui ci sia un cocktail in esecuzione e questo sensore segnala che è stato tolto il bicchiere, viene immediatamente chiusa la valvola n°X e la macchina va in stato di errore.

Foto:

Osservazioni:
Per motivi di tempo la macchina non è ancora stata ultimata, manca il porta bottiglie!
Come potete notare nel video seguente, ho testato solamente la parte meccanica-elettronica della macchina e direi che funziona alla grande.
Il prossimo passo sarà dunque la costruzione del porta bottiglie per poter creare un vero cocktail!
Non appena riuscirò a costruirlo pubblicherò  un video in questo post.

Video:

6 - Arduino comanda led RGB

In questo progetto ho usato il mio Arduino per controllare l'illuminazione di due casette in legno che andranno ad allestire una vetrina natalizia.

Componenti utilizzati:
Due casette in legno, Arduino UNO, 2 led RGB, 2 led a luce bianca e alcune resistenze:

Descrizione:
Dopo aver costruito le casette ho pensato di mettere un illuminazione interna per renderle più carine, ho così inserito un led RGB e un led al luce bianca in ognuna di esse.
Essendo un led RGB ad anodo comune ho alimentato il piedino più lungo del led con i 5 volt di Arduino servendomi di un' opportuna resistenza, mentre gli altri 3 piedini li ho collegati ai pin 9,10,11 di Arduino. Così facendo, tramite la funzione "analogWrite" sono riuscito a controllare l'intensità dei 3 colori principali Red, Green e Blue ottenendo diverse tonalità di colore.
La funzione "analogWrite" permette di impostare un valore in uscita del pin che varia da 0 a 255.
Nel mio caso, avendo un led ad anodo comune otterrò:

AnalogWrite(PinRed, 0)  ------> luce rossa accesa
AnalogWrite(PinRed,255) -----> luce rossa spenta
AnalogWrite(PinRed,125) -----> luce rossa a mezza tonalità
...e così via!

Allo stesso modo comando sia la luce verde che la luce blu.
Per creare un gioco di luci in continuo cambiamento mi sono servito di cicli "For" per ottenere diverse tonalità di colore.
In fine per poter illuminare la parte laterale delle casette ho introdotto un semplice led a luce bianca che accendo e spengo casualmente.

Sketch Arduino:
Puoi scaricarlo qui!

Video:

5 - Arduino IR: pilotare macchinina con telecomando della TV

Descrizione:

In questo progetto ho realizzato una macchinina pilotabile dal telecomando della TV servendomi di un semplice ricevitore IR con preamplificatore e della libreria "IRremote".

Componenti utilizzati: ArduinoUNO, macchina telecomandata, driver L298N, batteria per macchinina telecomandata, telecomando televisore SONY, ricevitore IR preamplificato.

Procedimento:
1- Smontare un macchinina telecomandata mantenendo solamente i motori;
2 - Creare e caricare lo sketch per Arduino (potete usare il mio!);
3 - Preparare una piccola antenna per la macchinina con in cima il il ricevitore IR che andrà collegato ad Arduino in modo che il segnale arrivi sul pin 9;
4 - Collegare i motori della macchinina ad Arduino servendosi del driver L298N;
5 - Alimentare il tutto con una batteria.

Come funziona il programma?
Grazie al ricevitore IR e alla libreria IRremote.h possiamo leggere la codifica esadecimale del pulsante del telecomando che abbiamo premuto.
Nel mio caso, usando un telecomando SONY, ho usato i seguenti tasti:

TASTO TELECOMANDO   >      CODIFICA     >   MOVIMENTO CONTROLLATO

                   2                         >         810               >                 AVANTI
                   1                         >         10                 >                 AVANTI A SINISTRA
                   3                         >         410               >                 AVANTI A DESTRA
                   4                         >         C10              >                 SINISTRA (inutile)
                   5                         >         210               >                 FRENO (spegne i motori)
                   6                         >         A10              >                 DESTRA (inutile)
                   7                         >         610               >                 INDIETRO A SINISTRA
                   8                         >         E10              >                 INDIETRO
                   9                         >         110               >                 INDIETRO A DESTRA

Sketch Arduino:
Scaricare sketch Arduino da qui!


Osservazioni e suggerimenti:
La libreria IRremote.h non contiene la codifica dei telecomandi di tutte le marche!
Nel mio sketch ho lasciato la possibilità di leggere tramite monitor seriale la codifica del tasto schiacciato sul telecomando.
Per verificare la compatibilità del proprio telecomando basterà premere un tasto e se Arduino stamperà su monitor seriale una codifica esadecimale vorrà dire che la libreria "IRremote.h"comprende quella marca.

Video:

4 - Arduino salva dati inviati da PROCESSING nella EEPROM

In questo programma ho utilizzato la EEPROM del mio Arduino per salvare le coordinate del mouse inviate da PROCESSING.

Componenti utilizzati: Arduino UNO, PROCESSING, led.


Descrizione:
ArduinoUNO è dotato di 1Kb (1024byte) di memoria EEPROM  per cui avremo spazio per 1024 dati da salvare.
Avendo a disposizione solamente 8 bit, ogni dato che salveremo nella EEPROM non dovrà superare il valore 255, in quanto con 8 bit possiamo esprimere al massimo 256 numeri.
Per facilitare le cose e, per il motivo sopra citato, ho deciso di creare una finestra di disegno con PROCESSING che non supera i 255 pixel d' altezza e di larghezza!
Per gestire la memoria EEPROM di Arduino ho usato la libreria "EEPROM.h" dove le tre funzioni principali sono:
-"EEPROM.clear()" per azzerare la memoria;
-"EEPROM.write(indirizzo,valore)" per scrivere i dati in memoria;
-"EEPROM.read(indirizzo)" per leggere i dati in memoria;

Con PROCESSING ho scritto un semplice programma che creare una finestra (255 x 255) e  trasmette i dati delle coordinate X e Y del mouse (solamente se premuto) ad Arduino tramite porta seriale.
Il primo dato inviato su seriale corrisponde alla coordinata X del mouse, mentre il secondo dato inviato corrisponde alla coordinata Y del mouse.

Avendo a disposizione solamente 1024 indirizzi di memoria EEPROM di Arduino ho deciso di salvare nei primi 512 indirizzi le coordinate di X e nei restanti 512 indirizzi le coordinate di Y, per cui dall'indirizzo 0 all'indirizzo 511 ci saranno le coordinate X e dall'indirizzo 512 all'indirizzo 1023 ci saranno le coordinate di Y.
La prima operazione che svolge lo Sketch di Arduino è quella di azzerare la memoria, dopo di che si mette in attesa di ricevere dati dalla porta seriale. Il primo dato che leggerà (coordinata X del mouse) verrà salvato all'indirizzo di memoria 0, mentre il secondo dato che riceverà (coordinata Y del mouse) verrà salvato all'indirizzo di memoria 512. IL dato successivo (coordinata X) verrà salvato all'indirizzo di memoria 1 e il dato dopo (coordinata Y) verrà salvato all'indirizzo 513, e così via.
Finiti gli indirizzi di memoria a disposizione, Arduino accenderà un led di avviso collegato al pin 13.
Così facendo abbiamo salvato le coordinate di dove siamo passati con il mouse nella nostra EEPROM.
Per fare una verifica basterà caricare su Arduino lo Sketch d'esempio "eeprom_read" per andare a leggere tutti i nostri dati salvati nella EEPROM.
Attenzione!!! bisogna  modificare lo Sketch nellla riga dove c'è:
(if == 512)
sostituendo il 512 con 1024. In questo modo il programma ci stamperà tutti i 1024 dati che abbiamo salvato.

Osservazioni:
Prima di effettuare la verifica dell'avvenuta memorizzazione delle coordinate X eY del mouse nella memoria EEPROM è necessario terminare l'esecuzione del programma scritto con PROCESSING altrimenti ci sarà la comunicazione seriale di Arduino occupata e non possiamo utilizzare il nostro monitor seriale.
Nello sketch di Arduino creato da me al termine della scrittura dei dati in memoria c'è una funzione chiamata "inizio()" che fa attendere ad Arduino 1 minuto prima di ricominciare il ciclo. Questa funzione potrà essere modificata in modo da utilizzare i dati salvati nella EEPROM  per svolgere determinate azioni:
per esempio si potrebbero collegare due attuatori lineari (formati da due motori passo a passo) che eseguono su un foglio di carta la scritta o il disegno fatti con il muose nella finestra di PROCESSING.


Programma con PROCESSING:
Puoi scaricare il file qui!

Sketch per Arduino:
Puoi scaricare il file qui!

Video:

3 - Arduino Web Server per macchina WiFi

Descrizione:
Ispirato dalla tecnologia del "Ar drone" (quadricottero comandabile da iPhone tramite rete WiFi) ho pensato di applicarla ad una macchina telecomandata servendomi di pezzi trovati per casa!
L'obbiettivo sarà quello di creare una macchinina che trasmetta una rete WiFi in modo da poterla comandare da qualsiasi dispositivo in grado di connettersi ad essa: iPhone, Pc, Wii, PS3.....

Componenti utilizzati: ArduinoUNO, shield ethernet, macchina telecomandata, driver L298N, router WiFi, batteria per macchinina telecomandata, cavo ethernet.

Procedimento:
1- Smontare un macchinina telecomandata mantenendo solamente i motori;
2 - Procurarsi un router WiFi e smontarlo in modo da renderlo il più leggero possibile;
3 - Collegare Arduino all'apposito shield ethernet;
4 - Creare un web server e l'apposita pagina HTML dotata di 9 tasti per poter controllare la macchinina in ogni direzione;
5 - Caricare lo sketch creato su Arduino;
6 - Collegare i motori della macchinina ad Arduino servendosi del driver L298N;
7 - Montare il router sulla macchinina e collegarlo ad Arduino tramite un cavo ethernet;
8 - Alimentare il tutto con una batteria.

Abbiamo così creato una rete alla quale basterà agganciarsi tramite WiFi e digitando l'indirizzo del web server (192.168.1.177), caricato su Arduino, potremo comandare la nostra macchinina.
Il compito di Arduino sarà dunque quello di leggere la richiesta di movimento del client connesso al server ed eseguirla facendo muovere i motori della macchinina!

Sketch Arduino:
Scaricare sketch Arduino da qui!


Osservazioni e suggerimenti:
Volendo è possibile collegare un IP CAM al router della nostra macchinina per poter vedere dove andiamo direttamente dal pc:
Arduino - Macchinina WiFi Spia (post non ancora disponibile).

Video:

2 - Arduino modem GSM

A grande richiesta ho deciso di costruire un modem GSM in grado di monitorare la corrente elettrica e  nel caso di Black_Out avvisa con un SMS oppure con una telefonata sul cellulare. Questo modem creato con Arduino e shield GSM è possibile applicarlo ovunque ne abbiamo la necessità: casa, ufficio, azienda....

In un  secondo momento, ho aggiunto un sensore di luminosità che servirà a monitorare anche il sistema d' antintrusione di casa!

Componenti utilizzati:

Vecchio "case" di un Hard Disk, presa/lampadina di emergenza,  ArduinoUNO, shield GSM, sensore di luminosità, led, bottone, componenti elettronici vari e una SIM di qualsiasi operatore telefonico.

 Funzionamento presa/lampadina di emergenza: collegata ad una presa qualsiasi della corrente, in caso di Black_Out emette una luce tramite un led.

Descrizione:

CIRCUITO:

-Montare e saldare tutti i componenti che formano lo shield GMS;

-Collegare lo shield GSM ad Arduino;

-Smontare lampadina d'emergenza e saldare ai due piedini del led che troviamo dentro due cavetti che andranno collegati al nostro Arduino. In questo modo Arduino terrà monitorato il led che in caso di Black-out si accenderà facendo arrivare un aumento di tensione ad un pin analogico!

-Collegare 4 led (rosso, blu, verde, giallo) che ci serviranno per capire in che stato si trova il nostro modem.

-Collegare un bottone che ci servirà per resettare alcune funzioni;

-Per poter monitorare l'impianto d'antintrusione di casa, possiamo collegare due cavetti al led che segnale l'allarme (come fatto precedentemente con la lampadina d'emergenza) o servirci di un sensore di luminosità che andrà incollato sul led da monitorare.

Per abbellire il tutto ho deciso d inserire nel "case" del mio vecchio Hard Hisk il circuito creato.
Per quanto riguarda l'alimentazione sarà necessario collegare Arudino ad un gruppo di continuità in modo che, in caso di Black-Out, il nostro modem possa rimanere acceso qualche minuto per segnalarci l'evento.
Arduino dovrà essere alimentato a 12 volt per poter far funzionare senza problemi lo shield GSM!
La presa/lampada di emergenza dovrà essere collegata ad una presa di corrente qualsiasi.

COME FUNZIONA IL PROGRAMMA:
Il programma permette ad Arduino di agganciarsi alla rete GSM in modo da poter effettuare chiamate e invaire SMS, se ciò avviene correttamente si accenderà un led verde del modem!
In questo caso Arduino, tramite un pin analogico, tiene monitorato il led della lampadina d'emergenza e nel caso si accenda (BLACK-OUT) procede a effettuare due squilli sul numero di telefono da noi inserito, tenendo il led blu accesso. Fatto ciò rimarrà in un ciclo infinito fino a che non verrà ripristinata la corrente, facendo lampeggiare in modo alternato led rosso e led blu, continuando però a monitorare il sistema d'antintrusione di casa.
Una volta ripristinata la corrente Arduino smetterà di far lampeggiare i led rosso e blu e procederà ad inviare un SMS di notifica ("Corrente _ripristinata!") riaccendendo il led verde.
Nel caso scatti l'allarme di casa, Arduino lo rileverà tramite il sensore di luce piazzato sul led dell'allarme e procederà ad inviare un SMS d' avviso("Allarme_scattato!"), accendendo in seguito un led giallo.
Per poter permettere ad Arduino di ricominciare a monitorare l'allarme di casa sarà necessario tenere premuto il bottone fino a che il led giallo si spegne.

Osservazioni:
Per verificare il corretto aggancio del nostro modem alla rete GSM basterà controllare che il led verde sia acceso oppure, se siamo fuori casa, basterà telefonare al numero del nostro modem e verificare che dia la linea libera.

Sketch Arduino:
Scaricare lo sketch Arduino qui!

Video:

1 - Arduino multiplexer/demultiplexer

Definizioni:

MULTIPLEXER = dispositivo in grado di selezionare un singolo segnale elettrico fra 2^n segnali d'ingresso.

DEMULTIPLEXER = dispositivo in grado di selezionare una singola uscita fra 2^n uscite disponibili.

Componenti Utilizzati:

Arduino UNO, multiplexer 16 channel, 16 led, computer

Descizione:

In questo caso ho usato il dispositivo in funzione di demultiplexer servendomi solamente di 5 pin digitali di Arduino, per poter comandare 16 led!

Attraverso 1 pin di arduino indico il segnale d'uscita (HIGH o LOW) mentre con gli altri 4 pin scelgo in che uscita far arrivare il segnale:

ARDUINO -> DEMULTIPLEXER -> LED
   0-0-0-0   ->         uscita 0;             ->   1

   0-0-0-1   ->         uscita 1;             ->   2
   0-0-1-0   ->         uscita 2;             ->   3
   0-0-1-1   ->         uscita 3;             ->   4
   0-1-0-0   ->         uscita 4;             ->   5            
   0-1-0-1   ->         uscita 5;             ->   6
   0-1-1-0   ->         uscita 6;             ->   7
   0-1-1-1   ->         uscita 7;             ->   8
   1-0-0-0   ->         uscita 8;             ->   9
   1-0-0-1   ->         uscita 9;             ->   10
   1-0-1-0   ->         uscita 10;           ->   11
   1-0-1-1   ->         uscita 11;           ->   12
   1-1-0-0   ->         uscita 12;           ->   13
   1-1-0-1   ->         uscita 13;           ->   14
   1-1-1-0   ->         uscita 14;           ->   15
   1-1-1-1   ->         uscita 15;           ->   16

Osservazioni: 
Nello sketch che trovate qui sotto, è possibile scegliere quale led accendere mandando dei caratteri ad Arduino tramite monitor seriale:

il carattere  "\"  corrisponde al led 1;
                  "0"  corrisponde al led 2;
                  "1"  corrisponde al led 3;
                  "2"  corrisponde al led 4;
                  "3"  corrisponde al led 5;
                  "4"  corrisponde al led 6;
                  "5"  corrisponde al led 7;
                  "6"  corrisponde al led 8;
                  "7"  corrisponde al led 9;
                  "8"  corrisponde al led 10;
                  "9"  corrisponde al led 11;
                  "Q"  corrisponde al led 12;
                  "W"  corrisponde al led 13;
                  "E"  corrisponde al led 14;
                  "R"  corrisponde al led 15;
                  "T"  corrisponde al led 16;

Usando la funzione multiplexer è possibile leggere il valore di 16 input analogici servendosi solamente di 5 pin di Arduino: 4 pin serviranno sempre per scegliere il canale da leggere tra i 16 disponibili, mentre, il pin usato precedentemente per trasmettere il segnale HIGH o LOW ai led, ora lo si usa per leggere il valore dei sensori, basterà quindi collegarlo ad un pin analogico di Arduino ed usare la funzione "analogRead(pin)" per rilevare il valore trasmesso dal input (per esempio un sensore di temperatura).

Sketch Arduino:

Scarica sketch Arduino qui!

Video: