Accordatore: 9 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Questo progetto è stato progettato per realizzare un accordatore per chitarra utilizzando Vivado e un display a 7 segmenti. Una volta che l'accordatore trova la frequenza del suono immesso, confronterà quel valore con un elenco di valori codificati per le frequenze esatte note come frequenza standard per l'altezza corretta di una nota. Quindi l'accordatore mostrerà quanto è vicino o lontano il suono immesso dalla nota desiderata. Ciò che è interessante è che un'onda sonora è una combinazione di più forme d'onda sinusoidali con componenti reali e immaginari. Anche se può sembrare difficile lavorare con chi non ha familiarità, ci sono alcuni modi in cui possiamo ancora analizzare un'onda con valori reali e immaginari.

Dimostrazione:

Passaggio 1: elenco dell'equipaggiamento (scatta una foto del tabellone e del comp di Kevin)

Per prima cosa abbiamo bisogno di una scheda Basys 3 e di un computer che supporti i seguenti programmi. Garageband/Audacity o un'altra DAW - per registrare tramite un microfono ed esportare file wav

Python - in grado di utilizzare pylab e scipy per il campionamento e fft

Vivado - per connettersi alla scheda Basys 3 e vedere visivamente i risultati

Passaggio 2: Panoramica

Un sintonizzatore è composto da pochi componenti importanti: microfono, campionatore, FFT (Fast Fourier Transform), comparatore, decodificatore e display. Lo scopo del microfono è catturare la forma d'onda in ingresso. Il campionatore riceve il segnale di uscita del microfono e utilizza la FFT per convertire il segnale in un'uscita di grandezza in frequenze. Quindi utilizzando l'uscita della FFT e trovando la magnitudine massima e la frequenza ad essa associata divisa per 2, si può trovare la frequenza associata all'altezza della forma d'onda. Quel valore può quindi andare nel comparatore. Viene quindi confrontato con una tabella di ricerca, che ha già impostato i valori di frequenza per le altezze perfette di tutte le note. Al comparatore viene fornito un input per la nota desiderata, che può quindi abbinare la nota desiderata alla sua frequenza corretta dalla tabella di ricerca. Quindi il comparatore sceglierà la nota con la frequenza più vicina alla frequenza massima. Il comparatore confronterà i due valori e vedrà che il valore della frequenza è vicino a quello desiderato e quindi metterà quei dati in un segnale. Il comparatore invierà quel segnale al decoder, dove il decoder sceglierà gli ingressi per gli anodi del display a 7 segmenti per mostrare l'accuratezza della nota.

Passaggio 3: file Wav

In questo passaggio, prenderemo un file wav di un passo e proveremo a produrre la frequenza di quel passo.

Per prima cosa hai bisogno di un file wav di una nota. In questo esempio utilizzeremo un file wav stereo a 16 bit con una frequenza di campionamento di 44,1 kHz. Questo può essere creato in una DAW come Garageband o scaricato. Per questo esempio, un'onda sinusoidale A4 440Hz generata da noi su Garageband può essere scaricata qui.

Passaggio 4: Python: usi di Pylab e Scipy

Abbiamo usato la libreria Python per fare la "trasformazione veloce di Fourier". La risorsa online ci ha permesso di imitare e vedere cosa è utile in pylab e scipy.

1. Se non hai installato pylab o scipy, devi farlo. Oppure, Pycharm ha una funzionalità molto buona, quando si prova a importare pylab o scipy, c'è una sottolineatura ondulata che ti dice che non hai ancora installato la libreria. Puoi quindi installarli direttamente premendo la lampadina rossa (apparirà quando avvicinerai il cursore alla sottolineatura ondulata).

2. Utilizzando la funzione scipy.io.wavfile.read, leggere ed estrarre i dati dal file wav di esempio. Esegui i dati da pylab.fft, ti restituirà un elenco di grandezza per la potenza.

3. Quindi trova il massimo della potenza emessa dall'elenco. Cerca l'indice dell'elenco in cui si verifica la potenza massima perché il modo più veloce per trovare quale frequenza è associata a quella potenza. Infine restituisci la frequenza massima. Poiché in seguito abbiamo bisogno di inserire un segnale di frequenza binario nel codice VHDL, possiamo convertire la frequenza in float in binario e restituirla.

Passaggio 5: campionamento Python e FFT (mostra codice e risultati)

In questo passaggio, i crediti completi vanno a questo link sottostante per il campionamento e la FFT.

samcarcagno.altervista.org/blog/basic-sound…Il nostro codice:

Dopo aver installato pylab e scipy, i file wav possono essere importati e letti.

da pylab import*from scipy.io import wavfile

sampFreq, snd = wavfile.read('440_sine.wav')

Quindi snd.shape rappresenta i punti campione e il numero di canali. Nel nostro caso, i punti di campionamento dipendono da quanto è lungo il file wav e il numero di canali è 2 perché è stereo.

Allora snd = snd / (2.**15)…… xlabel('Time (ms)')

organizza il segnale orario in un array.

Quindi la FFT crea un array in frequenza e ampiezza (Potenza)

Quindi attraverso un ciclo while viene trovata la magnitudine massima e la frequenza ad essa associata. Quella frequenza/2 rappresenta l'altezza del file wav.

Quindi, usando il nostro codice, l'intero che rappresenta la frequenza è stato convertito in un numero binario a 12 bit ed è stato creato un file di testo con quel numero.

Passaggio 6: Vivado (comparatore)

In questa parte del processo, abbiamo bisogno di un comparatore per confrontare due frequenze di ingresso.

1. Creato un comparatore per confrontare se la frequenza di ingresso (ricevitore) è più alta, più bassa o entro la nota definita dell'intervallo di margine di 2 Hz. (l'accordatore tipico per chitarra va da mi2 a sol5, da 82 Hz a 784 Hz).

2. Durante la creazione di un margine di 2 Hz, abbiamo utilizzato un RCA per aggiungere "00000000001" alla frequenza del ricevitore e verificare dove è ancora troppo basso per l'input dell'utente. In tal caso, segnale a bit singolo "alto" <= '0', "basso" <= '1'. Quindi aggiungiamo "00000000010" all'input dell'utente per vedere se l'input del ricevitore è ancora più alto di quello. In tal caso, "alto" <= '1', "basso" <= '0'. Nessuno dei due casi restituirebbe "0".

3. Poiché la parte successiva del modulo ha bisogno di un dato specifico a 4 bit per dire qual è la nota del ricevitore, non solo restituendo le 2 uscite comparative (basso e alto), dobbiamo restituire il codice associato alla nota, che associa la frequenza. Si prega di fare riferimento alla tabella sottostante:

C | 0011

C# | 1011

D | 0100

RE# | 1100

E | 0101

F | 0110

Fa# | 1110

G | 0111

G# | 1111

A | 0001

LA# | 1001

B | 0010

Utilizzo di diverse istruzioni if per classificarle in note e codificarle in ciò che è necessario per il decodificatore a sette segmenti.

Passaggio 7: IMMAGINI DELLA BASYS 3 Board

Passaggio 8: Vivado (decodificatore a 7 segmenti con multiplexing)

Tutto ha bisogno di un display. È un fattore importante che determina il valore di un design. Pertanto, dobbiamo creare un display utilizzando un decoder a sette segmenti, che ci consentirebbe di dimostrare la nostra capacità di progettare un sintonizzatore sulla scheda B. Inoltre, ci aiuterebbe nei test e nel debug.

Un decoder a sette segmenti contiene input denominati Note, low, high e CLK, mentre emette SSEG, AN e Fiz_Hz. C'è un'immagine del diagramma a blocchi sopra per aiutarci a capire il design.

Lo scopo di avere due ingressi separati di basso e alto è fornire al progettista del comparatore la libertà di manipolare se la frequenza del suono (onda) è superiore o inferiore alla frequenza di ingresso (Fix_Hz) che l'utente vuole confrontare. Inoltre, l'uscita SSEG rappresenta il display a sette segmenti e il punto accanto mentre l'AN rappresenta gli anodi per i quali l'insieme dei display a sette segmenti deve accendersi.

In questo decoder a sette segmenti, l'orologio (CLK) svolge un ruolo importante nella visualizzazione di due valori diversi su due o più anodi diversi. Poiché la scheda non ci consente di visualizzare due valori diversi contemporaneamente, dobbiamo utilizzare il multiplexing per visualizzare un valore uno alla volta, passando a un altro valore abbastanza velocemente da non consentire ai nostri occhi di catturarlo. È qui che entra in gioco l'ingresso CLK.

Per ulteriori informazioni, fare riferimento al codice sorgente.

Passaggio 9: Vivado (combinazione di componenti)

Con ogni modulo (ricevitore Python, comparatore, decodificatore a sette segmenti, ecc.) completato, abbiamo quindi messo insieme utilizzando un modulo più grande. Proprio come mostrato nell'immagine nella sezione "Panoramica", colleghiamo ogni segnale di conseguenza. Per riferimento, controlla il nostro codice sorgente "SW_Hz.vhd".

Grazie. Spero ti diverta.