Pianoforte basato su Arduino con registrazione e riproduzione

Arduino è stato un vantaggio per le persone che non hanno esperienza nell'elettronica per costruire facilmente cose. È stato un ottimo strumento di prototipazione o per provare qualcosa di interessante, in questo progetto costruiremo un pianoforte piccolo ma divertente usando Arduino. Questo pianoforte è praticamente semplice con solo 8 pulsanti e cicalino. Utilizza la funzione tone () di Arduino per creare vari tipi di note di pianoforte sull'altoparlante. Per ravvivarlo un po 'abbiamo aggiunto la funzione di registrazione nel progetto, questo ci consente di riprodurre un brano, registrarlo e riprodurlo ripetutamente quando necessario. Sembra interessante vero !! Quindi cominciamo a costruire…

Materiali richiesti:

• Arduino Uno
• Display LCD 16 * 2
• Cicalino
• Trimmer 10k
• Interruttore SPDT
• Pulsante (8 n.)
• Resistori (10k, 560R, 1.5k, 2.6k, 3.9, 5.6k, 6.8k, 8.2k, 10k)
• Breadboard
• Cavi di collegamento

Schema elettrico:

Il progetto completo Arduino Piano può essere costruito su una breadboard con alcuni cavi di collegamento. Di seguito è riportato lo schema circuitale realizzato utilizzando il fritzing che mostra la breadboard view del progetto

Basta seguire lo schema del circuito e collegare i fili di conseguenza, i pulsanti e il cicalino come usati con un modulo PCB ma nell'hardware reale abbiamo usato solo l'interruttore e il cicalino, non dovrebbe confonderti molto perché hanno lo stesso tipo di pin out. È inoltre possibile fare riferimento all'immagine sottostante dell'hardware per effettuare i collegamenti.

Il valore dei resistori da sinistra è nel seguente ordine, 10k, 560R, 1.5k, 2.6k, 3.9, 5.6k, 6.8k, 8.2k e 10k. Se non si dispone dello stesso interruttore DPST, è possibile utilizzare un normale interruttore a levetta come quello mostrato nello schema del circuito sopra. Ora esaminiamo gli schemi del progetto per capire perché abbiamo effettuato i seguenti collegamenti.

Schemi e spiegazioni:

Di seguito sono riportati gli schemi per lo schema circuitale mostrato sopra, anch'esso realizzato utilizzando Fritzing.

Una connessione principale che dobbiamo capire è che come abbiamo collegato gli 8 pulsanti ad Arduino tramite il pin A0 analogico. Fondamentalmente abbiamo bisogno di 8 pin di ingresso che possono essere collegati agli 8 pulsanti di ingresso, ma per progetti come questo non possiamo usare 8 pin del microcontrollore solo per i pulsanti poiché potremmo averne bisogno per un uso successivo. Nel nostro caso abbiamo il display LCD da interfacciare.

Quindi usiamo il pin analogico di Arduino e formiamo un potenziale divisore con valori di resistenza variabili per completare il circuito. In questo modo, quando ogni pulsante viene premuto, una diversa tensione analogica verrà fornita al pin analogico. Di seguito è mostrato un circuito campione con solo due resistenze e due pulsanti.

In questo caso il pin ADC riceverà + 5V quando i pulsanti non vengono premuti, se il primo pulsante viene premuto, il potenziale divisore viene completato attraverso il resistore 560R e se il secondo pulsante viene premuto, il potenziale divisore viene gareggiato usando il 1.5 resistenza k. In questo modo la tensione ricevuta dal pin dell'ADC varierà in base alle formule del potenziale divisore. Se vuoi saperne di più su come funziona il potenziale divisore e su come calcolare il valore della tensione ricevuta dal pin ADC, puoi utilizzare questa pagina del calcolatore del potenziale divisore.

Oltre a questo tutte le connessioni sono dirette, il display LCD è collegato ai pin 8, 9, 10, 11 e 12. Il buzzer è collegato al pin 7 e l' interruttore SPDT è collegato al pin 6 di Arduino. Il progetto completo è alimentato tramite la porta USB del laptop. Puoi anche collegare Arduino a un'alimentazione da 9 V o 12V tramite il jack DC e il progetto funzionerà comunque allo stesso modo.

Capire il

Arduino ha una pratica funzione tone () che può essere utilizzata per generare segnali di frequenza variabile che possono essere utilizzati per produrre suoni diversi utilizzando un cicalino. Quindi capiamo come funziona la funzione e come può essere utilizzata con Arduino.

Prima di ciò dovremmo sapere come funziona un cicalino piezo. Potremmo aver imparato a conoscere i cristalli Piezo nella nostra scuola, non è altro che un cristallo che converte le vibrazioni meccaniche in elettricità o viceversa. Qui applichiamo una corrente (frequenza) variabile per la quale il cristallo vibra producendo suono. Quindi, per fare in modo che il cicalino Piezo emetta un po 'di rumore, dobbiamo far vibrare il cristallo elettrico Piezo, il tono e il tono del rumore dipendono dalla velocità di vibrazione del cristallo. Quindi il tono e il tono possono essere controllati variando la frequenza della corrente.

Ok, quindi come possiamo ottenere una frequenza variabile da Arduino? È qui che entra in gioco la funzione tone (). Tone () può generare una frequenza particolare su un pin specifico. Se necessario, è possibile indicare anche la durata. La sintassi per tone () è

Sintassi tono (pin, frequenza) tono (pin, frequenza, durata) Parametri pin: il pin su cui generare la frequenza del tono: la frequenza del tono in hertz - unsigned int duration: la durata del tono in millisecondi (opzionale1) - non firmato a lungo

I valori del pin possono essere qualsiasi dei tuoi pin digitali. Ho usato il pin numero 8 qui. La frequenza che può essere generata dipende dalla dimensione del timer nella tua scheda Arduino. Per UNO e la maggior parte delle altre schede comuni la frequenza minima che può essere prodotta è 31Hz e la frequenza massima che può essere prodotta è 65535Hz. Tuttavia noi umani possiamo sentire solo frequenze comprese tra 2000Hz e 5000 Hz.

Riproduzione di toni di pianoforte su Arduino:

Ok, prima ancora di iniziare su questo argomento, lascia che sia chiaro che sono un principiante con note musicali o pianoforte, quindi per favore perdonami se qualcosa menzionato sotto questo titolo è senza senso.

Ora sappiamo che possiamo usare la funzione tone in Arduino per produrre alcuni suoni, ma come possiamo suonare i toni di una nota particolare usando lo stesso. Fortunatamente per noi c'è una libreria chiamata “pitches.h” scritta da Brett Hagman. Questa libreria contiene tutte le informazioni su quale frequenza è equivalente a quale nota su un pianoforte. Sono rimasto sorpreso da quanto bene questa libreria potesse effettivamente funzionare e suonare quasi tutte le note di un pianoforte, ho usato lo stesso per suonare le note di pianoforte di Pirates of Caribbean, Crazy Frog, Mario e persino Titanic e hanno suonato in modo fantastico. Oops! Stiamo diventando un po 'fuori tema qui, quindi se sei interessato a questo, dai un'occhiata a suonare melodie usando il progetto Arduino. Troverai anche ulteriori spiegazioni sulla libreria pitches.h in quel progetto.

Il nostro progetto ha solo 8 pulsanti, quindi ogni pulsante può suonare solo una particolare nota musicale e quindi possiamo suonare solo 8 note. Ho selezionato le note più utilizzate su un pianoforte, ma puoi selezionare qualsiasi 8 o persino espandere il progetto con più pulsanti e aggiungere più note.

Le note selezionate in questo progetto sono le note C4, D4, E4, F4, G4, A4, B4 e C5 che possono essere suonate usando rispettivamente i pulsanti da 1 a 8.

Programmazione di Arduino:

Basta con la teoria per arrivare alla parte divertente della programmazione di Arduino. Il programma Arduino completo è fornito alla fine di questa pagina, puoi saltare giù se desideri o leggere oltre per capire come funziona il codice.

Nel nostro programma Arduino dobbiamo leggere la tensione analogica dal pin A0, quindi prevedere quale pulsante è stato premuto e riprodurre il rispettivo tono per quel pulsante. Mentre si fa questo dovremmo anche registrare quale pulsante l'utente ha premuto e per quanto tempo ha premuto, in modo da poter ricreare il tono che è stato suonato dall'utente in seguito.

Prima di passare alla parte logica, dobbiamo dichiarare quali 8 note suoneremo. La rispettiva frequenza per le note viene quindi presa dalla libreria pitches.h e quindi viene formato un array come mostrato di seguito. Qui la frequenza per suonare la nota C4 è 262 e così via.

int note = {262, 294, 330, 349, 392, 440, 494, 523}; // Imposta la frequenza per C4, D4, E4, F4, G4, A4, B4,

Successivamente dobbiamo menzionare a quali pin è collegato il display LCD. Se stai seguendo esattamente gli stessi schemi sopra riportati, non devi cambiare nulla qui.

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Pin a cui è collegato LCD LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

Successivamente, all'interno della nostra funzione di configurazione inizializziamo solo il modulo LCD e il monitor seriale per il debug. Visualizziamo anche un messaggio introduttivo solo per assicurarci che le cose funzionino come previsto. Successivamente , all'interno della funzione loop principale abbiamo due cicli while.

Un ciclo while verrà eseguito fino a quando l' interruttore SPDT è posizionato di più nella registrazione. In modalità di registrazione l'utente può pagare i toni desiderati e contemporaneamente verrà salvato anche il tono che si sta suonando. Quindi il ciclo while ha questo aspetto qui sotto

while (digitalRead (6) == 0) // Se l'interruttore a levetta è impostato in modalità di registrazione {lcd.setCursor (0, 0); lcd.print ("Registrazione.."); lcd.setCursor (0, 1); Detect_button (); Play_tone (); }

Come avrai notato, abbiamo due funzioni all'interno del ciclo while. La prima funzione Detect_button () viene utilizzata per trovare il pulsante premuto dall'utente e la seconda funzione Play_tone () viene utilizzata per riprodurre il rispettivo tono. Oltre a questa funzione, la funzione Detect_button () registra anche quale pulsante viene premuto e la funzione Play_tone () registra per quanto tempo il pulsante è stato premuto.

All'interno della Detect_button () funzione si legge la tensione analogica dal perno A0 e confrontare con alcuni valori predefiniti per scoprire quale pulsante è stato premuto. Il valore può essere determinato utilizzando il calcolatore del partitore di tensione sopra o utilizzando il monitor seriale per controllare quale valore analogico viene letto per ciascun pulsante.

void Detect_button () { analogVal = analogRead (A0); // legge il voltag analogico sul pin A0 pev_button = button; // ricorda il pulsante precedente premuto dall'utente se (analogVal <550) button = 8; se (analogVal <500) pulsante = 7; se pulsante (analogVal <450) = 6; se (analogVal <400) pulsante = 5; se (analogVal <300) pulsante = 4; se (analogVal <250) pulsante = 3; se (analogVal <150) pulsante = 2; se pulsante (analogVal <100) = 1; se (analogVal> 1000) pulsante = 0; / **** Rcorda i pulsanti premuti in un array *** / if (button! = pev_button && pev_button! = 0) { registered_button = pev_button; button_index ++; Record_button = 0; button_index ++; } / ** Fine del programma di registrazione ** / }

Come detto, all'interno di questa funzione registriamo anche la sequenza in cui vengono premuti i pulsanti. I valori registrati vengono memorizzati in un array denominato registered_button. Per prima cosa controlliamo se c'è un nuovo pulsante premuto, se premuto poi controlliamo anche se non è il pulsante 0. Dove il pulsante 0 non è altro che nessun pulsante viene premuto. All'interno del ciclo if memorizziamo il valore sulla posizione dell'indice data dalla variabile button_index e poi aumentiamo anche questo valore dell'indice in modo da non scrivere troppo sulla stessa posizione.

/ **** Rcorda i pulsanti premuti in un array *** / if (button! = Pev_button && pev_button! = 0) { registered_button = pev_button; button_index ++; Record_button = 0; button_index ++; } / ** Fine del programma di registrazione ** /

All'interno del Play_tone () funzione giocheremo il relativo tono per il tasto premuto utilizzando più , se le condizioni. Inoltre useremo un array chiamato registered_time all'interno del quale salveremo il tempo di durata per il quale il pulsante è stato premuto. L'operazione è simile alla registrazione della sequenza di pulsanti, usiamo la funzione millis () per determinare per quanto tempo ogni pulsante è stato premuto, inoltre per ridurre la dimensione della variabile dividiamo il valore per 10. Per il pulsante 0, il che significa che l'utente non lo è premendo qualsiasi cosa non suoniamo nessun tono per la stessa durata. Il codice completo all'interno della funzione è mostrato di seguito.

void Play_tone () { / **** Rcord il tempo di ritardo tra ogni pressione del pulsante in un array *** / if (button! = pev_button) { lcd.clear (); // Quindi puliscilo note_time = (millis () - start_time) / 10; record_time = note_time; time_index ++; start_time = millis (); } / ** Fine del programma di registrazione ** / if (button == 0) { noTone (7); lcd.print ("0 -> Pausa.."); } if (button == 1) { tone (7, notes); lcd.print ("1 -> NOTE_C4"); } if (button == 2) { tone (7, notes); lcd.print ("2 -> NOTE_D4"); } se (pulsante == 3) { tono (7, note); lcd.print ("3 -> NOTE_E4"); } if (button == 4) { tone (7, notes); lcd.print ("4 -> NOTE_F4"); } if (button == 5) { tone (7, notes); lcd.print ("5 -> NOTE_G4"); } if (button == 6) { tone (7, notes); lcd.print ("6 -> NOTE_A4"); } if (button == 7) { tone (7, notes); lcd.print ("7 -> NOTE_B4"); } if (button == 8) { tone (7, notes); lcd.print ("8 -> NOTE_C5"); } }

Infine, dopo la registrazione, l' utente deve commutare il DPST nell'altra direzione per riprodurre il tono registrato. Fatto ciò, il programma interrompe il ciclo while precedente ed entra nel secondo ciclo while dove suoniamo le note nella sequenza dei pulsanti premuti per una durata precedentemente registrata. Il codice per fare lo stesso è mostrato di seguito.

while (digitalRead (6) == 1) // Se l'interruttore a levetta è impostato in modalità di riproduzione { lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Now Playing.."); for (int i = 0; i <sizeof (registered_button) / 2; i ++) { delay ((registered_time) * 10); // Attendi prima di pagare il brano successivo if ( registered_button == 0) noTone (7); // l'utente non deve toccare qualsiasi pulsante altro tono (7, note - 1)]); // riproduce il suono corrispondente al pulsante toccato dall'utente } } }

Riproduci, registra, riproduci e ripeti!:

Realizza l'hardware secondo lo schema del circuito mostrato e carica il codice sulla scheda Arduino e l'ora mostrata. Posizionare l'SPDT nella modalità di registrazione e avviare la riproduzione dei toni desiderati, premendo ogni pulsante si produrrà un tono diverso. Durante questa modalità il display LCD visualizzerà " Registrazione…" e sulla seconda riga vedrai il nome della nota che è attualmente premuta come mostrato di seguito

Dopo aver suonato il tono, sposta l'interruttore SPDT sull'altro lato e il display LCD dovrebbe visualizzare " Now Playing.." e quindi iniziare a riprodurre il tono che hai appena suonato. Lo stesso tono verrà riprodotto ancora e ancora fintanto che l'interruttore a levetta viene mantenuto nella posizione mostrata nell'immagine sottostante.

Il funzionamento completo del progetto può essere trovato nel video riportato di seguito. Spero che tu abbia capito il progetto e ti sia piaciuto realizzarlo. In caso di problemi nella creazione di questo post, nella sezione commenti o utilizzare i forum per assistenza tecnica sul progetto. Inoltre, non dimenticare di controllare il video dimostrativo fornito di seguito.