Fisica generale 1: moto dei proiettili con Arduino e servomotore

Per il corso di Fisica Generale I, ci è stato chiesto di mettere su un piccolo esperimento fisico: in particolare, si è trattato dello studio del moto dei proiettili. Ciò che ho sviluppato e vi propongo è un semplice circuito che, grazie all’utilizzo di un servo motore a cui è collegato un “cannone”, consente di impostare con facilità e precisione l’angolo di tiro: in questo modo è facile studiare come varia il moto del proiettile al variare di tale angolo.

Per realizzare il circuito occorre un servomotore, un display LCD (opzionale) e, ovviamente, Arduino. Per il collegamento relativo al display LCD, rimando allo specifico articolo; il servomotore va collegato ad un pin digitale dell’Arduino (io ho utilizzato il pin numero 7).

Il codice , che è possibile leggere qui, prende in input il valore dell’angolo da seriale, aggiorna il display e imposta il servomotore.

IMG_20141219_122123 IMG_20141215_105034

IMG_20141218_145533Stay tuned!

KnockBox – (4) Conclusione

Finalmente, ecco qui l’ultimo post del progetto KnockBox. Oggi costruiremo la scatola che racchiuderà il sistema e metteremo insieme tutti i pezzi. Assicuratevi di aver seguito tutti i passaggi necessari: li trovate nel menu in alto sotto la voce “Projects > KnockBox”.

Iniziamo subito: per prima cosa procuriamoci una scatola abbastanza grande da contenere Arduino e tutti i componenti – si può ridurre lo spazio utilizzato programmando un chip (ad esempio l’ATMega328P) e saldare il tutto su una basetta millefori, per creare uno standalone (per maggiori informazioni vedi qui).

Io ho utilizzato una scatola acquistata da Leroy Merlin per il prezzo di €2.50.

Attenzione: il coperchio della scatola non deve essere completamente dritto, ma ha bisogno di una componente verticale, come quello della mia scatola.

Con un trapano, fate sette buchi sulla facciata della scatola, come nell’immagine: i primi tre conterranno i LED, il quarto l’interruttore e gli ultimi tre i pulsanti. Cercate di essere più precisi di me – era la prima volta che ho preso in mano un trapano.

100_2795

Adesso il sistema di chiusura: forate il coperchio della scatola nel punto indicato dall’immagine precedente: è lì che la linguetta del servomotore si inserirà bloccando l’apertura. Trapanate leggermente sul lato interno nei pressi del foro appena effettuato creando una sorta di “scia” dando alla linguetta del servomotore lo spazio necessario per muoversi.

Di seguito, alcune immagini scattate durante la realizzazione del progetto:

100_2781 100_2780100_2744

100_2745100_2742100_2750100_2743

Inserite il vostro Arduino (o il vostro chip) con tutti i componenti all’interno della scatola, fissate il sensore piezo al centro del coperchio ed il servo motore in corrispondenza del foro.

Potete utilizzare un pezzo di cartoncino colorato o di altro materiale per nascondere alla vista il circuito.

Complimenti, la vostra personale KnockBox è pronta a custodire i vostri segreti!

Se ti è piaciuto il progetto, per favore votami per l’Arduino Contest su Instructables.com!

Stay tuned!

KnockBox – (3) Chiusura

Eccoci al terzo ed ultimo post del progetto KnockBox, prima della presentazione della versione definitiva: qui parlerò di come realizzare la serratura utilizzando il motore servo.

Il sistema è quello illustrato in figura:Knockbox lock gif

Il coperchio della scatola contiene internamente uno spazio vuoto in cui si inserisce la linguetta del motore, bloccando la sua eventuale apertura. Quando essa si ritira, il coperchio è libero di essere aperto.

Presto presenterò il progetto finito: tuttavia, per realizzarlo curandone i minimi particolari richiede tempo. Per questo motivo, nel frattempo andrò avanti parlandovi di altri progetti o scrivendo altri how-to.

In attesa della versione finale: stay tuned!

KnockBox – (2) Elettronica e software

Questa è la seconda parte di una serie di tre articoli riguardanti il progetto KnockBox: qui tratteremo delle sue componenti elettroniche e del software.

Elettronica

I componenti necessari sono i seguenti:

  • un piezo;
  • un motore servo;
  • un capacitor da 100uF;
  • tre LED (uno rosso, uno verde, uno blu);
  • tre pulsanti;
  • tre resistenze da 220Ω, tre resistenze da 10kΩ e una resistenza da 1MΩ.

Analizziamo nel dettaglio il materiale utilizzato nel progetto.

Il piezo è il cuore di tutto: è il sensore che rileva il colpo con le nocche. Calcolando il tempo trascorso tra un tocco e l’altro all’interno di una serie, riusciamo a distinguere il ritmo e a confrontarlo con quello registrato.

Il motore servo è invece utilizzato per aprire e chiudere la serratura: di questo tratteremo più ampiamente nel prossimo articolo. Va però detto che, quando un motore servo comincia a muoversi, consuma più corrente di quando è già in movimento. Questo causa una flessione nel voltaggio. A questo serve il capacitor: collegandolo tra l’alimentazione ed il ground del servo, riusciamo ad appianare eventuali cambiamenti di voltaggio. Attenzione: assicurati di collegare al ground il catodo (la parte con la striscetta nera) e l’anodo all’alimentazione. Invertire il senso di collegamento potrebbe causare l’esplosione del dispositivo.

I LED servono a comunicare all’utente lo stato del sistema. Il LED verde acceso indica che la scatola è aperta, il rosso che è chiusa, il blu che è stato registrato un input.

I tre pulsanti attivano tre diversi comportamenti della scatola:

  1. Chiusura della serratura;
  2. Riproduzione del ritmo registrato;
  3. Registrazione di un nuovo ritmo.

Tutte e tre le funzioni collegate ai pulsanti possono essere attivate solo quando la serratura è già stata aperta.

Le resistenze permettono il corretto funzionamento degli altri componenti.

Lo schema del circuito elettrico è questo:KnockBox_scheme

Il risultato è questo:KnockBox - Closed KnockBox - Open KnockBox - Input

Software

Il software necessario al funzionamento di KnockBox è un unico sketch Arduino: data la sua complessità rispetto a tutti i post precedenti, è utile analizzarlo nel dettaglio. Si basa sul paradigma di programmazione OOP (Object-Oriented Programming), e ho cercato di tenerlo quanto più ordinato e semplice possibile.

Il codice si può reperire qui.

Lo sketch si compone di due classi, Rhythm e Box, e delle due funzioni tipiche di Arduino, ovvero setup() e loop().

La classe Rhythm fornisce gli strumenti necessari per gestire input e ritmi. Essa utilizza tre costanti:

  • RHYTHM_SIZE = 10: il numero massimo di intervalli tra un tocco e l’altro del ritmo registrato (esso può quindi essere composto al massimo da 11 tocchi).
  • TOLERANCE = 150: tolleranza in millisecondi calcolata quando si confronta l’input con il ritmo registrato. Ciò significa che, se nel ritmo il primo intervallo dura 500ms, un input di 400ms sarà considerato valido, ma uno di 700ms no.
  • TRESHOLD = 20: la soglia minima dell’input registrato dal piezo affinché esso sia considerato un tocco valido. Se il sensore registra un input inferiore di questo valore, esso non verrà considerato.

Inoltre, Rhythm offre in tutto 10 funzioni:

  • Rhythm(): il costruttore. Si occupa di impostare un ritmo predefinito a compile-time.
  • void getRhythm(int *rhythm_a): copia il ritmo registrato nell’array puntato da *rhythm_a
  • void setRhythm(const int rhythm_a[RHYTHM_SIZE]): imposta un nuovo ritmo. Richiede come argomento un array di interi, di grandezza RHYTHM_SIZE che contenga i valori in millisecondi degli intervalli del nuovo ritmo.
  • int getActualSize() const: ritorna un intero che rappresenta il reale numero di intervalli presenti nel ritmo registrato. Questa funzione è necessaria poiché si può registrare un ritmo di intervalli inferiori a RHYTHM_SIZE. Se ciò accade, il resto dell’array viene riempio di valori -1 (ad esempio, un ritmo di 4 tocchi quindi 3 intervalli viene salvato in questo modo: [INTERVALLO_1, INTERVALLO_2, INTERVALLO_3, -1, -1, -1, -1, -1, -1, -1].
  • int getActualSize(const int rhythm_a[RHYTHM_SIZE]) const: identico alla funzione precedente, ma ritorna il numero di intervalli del ritmo rhythm_a passatogli come argomento.
  • void play() const: riproduce il ritmo registrato.
  • void play(const int rhythm_a[RHYTHM_SIZE]) const: riproduce il ritmo rhythm_a passatogli come argomento.
  • int listenForKnock() const: attende un input di valore superiore o uguale a TRESHOLD e ritorna il tempo in millisecondi trascorso dalla chiamata della funzione alla ricezione dell’input.
  • void listenForRhythm(int *rhythm_a): registra un intero ritmo e ne salva gli intervalli all’interno dell’array di dimensione RHYTHM_SIZE puntato dall’argomento *rhythm_a.
  • boolean checkRhythm(): registra un ritmo e controlla che corrisponda a quello registrato, applicando una tolleranza in millisecondi di valore TOLERANCE. Ritorna TRUE se i ritmi coincidono, FALSE altrimenti.

La classe Box fornisce gli strumenti necessari per gestire il funzionamento della serratura. Si compone di 5 metodi:

  • Box(): il costruttore. Inizializza il motore servo, chiude la serratura ed accende il LED rosso.
  • boolean isLocked() const: ritorna TRUE se la serratura è chiusa, FALSE se è aperta.
  • void openBox(): attiva il motore servo per aprire la serratura ed accende il LED verde.
  • void closeBox(): attiva il motore servo per chiudere la serratura ed accende il LED rosso.
  • void recordNewRhythm(Rhythm *rhythm): registra un nuovo ritmo e lo riproduce. Se viene premuto il pulsante di chiusura, la registrazione viene annullata. Se viene premuto il pulsante di registrazione, il nuovo ritmo viene salvato e la serratura viene chiusa. L’argomento *rhythm è il puntatore all’istanza della classe Rhythm in uso.

Restano da discutere le due funzioni setup() e loop(): la prima si occupa di inizializzare i pin per l’input e l’output; la seconda, invece, esegue le giuste operazioni in base all’input ricevuto.

Per osservare all’opera il funzionamento del sistema, vi rimando al video all’inizio del post.

Stay tuned!

KnockBox – (1) Introduzione

Quello di oggi è il progetto più complicato che ho realizzato fino a questo momento: una scatola la cui serratura si apre solo quando vi si batte sopra con le nocche riproducendo un determinato ritmo. Non si tratta di un miracolo, né di magia nera: è solo una applicazione delle infinite possibilità dell’elettronica.

Data la difficoltà del progetto, ho diviso l’esposizione del progetto in tre parti: l’introduzione (quella che stai leggendo adesso), una discussione sulla componente elettronica e software ed una sul sistema di chiusura.

L’intero sistema si basa sull’utilizzo di uno strumento chiamato “piezo”: oltre ad essere usato per riprodurre suoni di una certa tonalità può anche essere utilizzato come sensore (vedi How to – Sensore piezoelettrico).

Questo è l’aspetto della facciata della scatola: analizziamola nel dettaglio per spiegare il funzionamento di KnockBox.KnockBox_Scheme

  • L’interruttore (1) collega il circuito elettrico della scatola all’alimentazione, composta da 4 pile stilo AA da 1.5V.
  • La scatola all’accensione è chiusa, ed è pertanto acceso il LED rosso (2).
  • Per aprire la scatola bisogna battere con le nocche all’interno della “Knock Zone” (5), ovvero la zona che corrisponde alla posizione del sensore.
  • Ad ogni input ricevuto, il LED blu (4) si illuminerà.
  • Se l’input ricevuto corrisponde al ritmo registrato (per ogni tocco è prevista una tolleranza di 150ms), allora la serratura si aprirà, e resterà acceso il LED verde (3).
  • Per richiudere la serratura, bisogna chiudere il coperchio e premere il pulsante di chiusura (6). Il LED rosso (2) tornerà attivo.
  • E’ possibile anche registrare un nuovo ritmo: per prima cosa, bisogna sbloccare la serratura, riproducendo il ritmo registrato. Una volta fatto, basta premere il pulsante di registrazione (7) e battere nella Knock Zone (5) seguendo il nuovo ritmo. Fatto ciò, il ritmo ricevuto verrà riprodotto. Se si vuole procedere a salvare il nuovo ritmo, premere nuovamente il pulsante di registrazione (7). Altrimenti, premere il pulsante di chiusura (6) per annullare l’operazione.
    • Se si decide di salvare il nuovo ritmo, la serratura si chiuderà automaticamente.
    • Se si annulla il processo, la serratura rimarrà aperta.
  • Il tasto di riproduzione (8) consente di ascoltare il ritmo registrato. Può essere utilizzato solo se la serratura è aperta.

Attenzione:

  • Il ritmo registrato non può essere superiore a 10 intervalli (11 tocchi).
  • La sequenza di input si considera terminata quando sono trascorsi 3 secondi dall’ultimo tocco o quando si è raggiunto il limite massimo di 10 intervalli.

Nel prossimo articolo vedremo come assemblare il circuito elettrico e discuteremo il codice sorgente.

Stay tuned!

Quiz controller

Oggi costruiremo un controller per un quiz a risposte multiple. Si tratta di un progetto molto semplice, ma che può essere molto divertente da utilizzare per sfidare agli amici a colpi di domande a risposta multipla.

Procuriamoci il materiale necessario. Abbiamo bisogno di:

  • 3 LED di colori diversi;
  • 3 resistenze da 220Ω;
  • 3 pulsanti.

L’idea è questa: alla pressione di uno dei pulsanti, il LED corrispondente si accende, e tramite porta seriale viene inviata l’informazione su quale pulsante è stato premuto, e quindi quale risposta è stata scelta: A, B, o C.

I (pochi) componenti vanno collegati in questo modo:

Quiz_scheme

Qui è possibile trovare il codice sorgente. La sua unica funzione è quella di inviare tramite porta seriale il valore ‘0’, ‘1’, oppure ‘2’ in base a quale tasto è stato premuto. La scelta viene abilitata solo quando si riceve un segnale di “ok” tramite porta seriale, che annuncia che la domanda è stata posta ai concorrenti.

Di seguito qualche foto del controller:

Quiz 1 Quiz 2 Quiz 3Stay tuned!

Lampadina multi-colore

Rieccomi qui, per mostrarvi come realizzare una “color mixing lamp”: una lampadina che cambia colore.

Il progetto è molto semplice, così come il materiale necessario:

  • un LED RGB;
  • tre resistenze da 220Ω;
  • cavi di connessione

Basta collegare il LED al GND e all’Arduino tramite le resistenze. Questo lo schema del circuito:

ColorMixingLamp Circuit Scheme

LED RGBRGB LED

Questo particolare LED è dotato di 4 pin: tre per i rispettivi colori primari rosso, verde e blu, e il quarto è il catodo. Creando una differenza di voltaggio sui pin (connessi all’Arduino tramite resistenze da 220Ω), il LED oscillerà tra i tre colori. Il piede più lungo è l’anodo.

Pulse Width Modulation

Il LED RGB ovviamente può mostrare più dei tre colori primari: basta modificare il voltaggio applicato ai pin (il valore dei colori varia da 0 a 255).

Per far ciò, viene utilizzata la tecnica Pulse Width Modulation, o PWM. E’ un procedimento che consiste nel cambiare molto rapidamente l’output sul pin da HIGH a LOW, per un certo periodo di tempo. E’ molto simile al funzionamento dei film: una serie di immagine scorre molto rapidamente, creando l’illusione del movimento.

La percentuale di tempo in cui il pin è su valore HIGH si chiama duty cicle. Più è alto il valore del duty cicle, più è alto il voltaggio applicato sul pin, e, di conseguenza, il valore del colore corrispondente.

Pulse Width Modulation

La scheda che utilizzo, Arduino Uno, è dotata di sei pin predisposti al PWM (pin digitali 3, 5, 6, 9, 10 e 11), che possono essere identificati dalla tilde ~ posta vicino al numero del pin sulla scheda.

Software

Utilizzeremo due programmi:

  • lo sketch Arduino, che legge terne di valori nel formato (r;g;b) dalla porta seriale e illumina il led del colore inviato (ad esempio la stringa “255;0;0” per il rosso);
  • lo sketch Processing che invia tramite porta seriale la stringa con i valori rgb del colore selezionato dall’utente.

Clicca qui per scaricare il pacchetto completo.

Questo è il risultato finale:

ColorMixingLamp - Finished

Stay tuned!