Tuner: 9 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Detta projekt var utformat för att göra en gitarrmottagare med Vivado och en 7-segmentskärm. När tunern har hittat frekvensen för det inmatade ljudet kommer tunern att jämföra det värdet med en lista med hårdkodade värden för exakta frekvenser som är kända som standardfrekvensen för den korrekta tonhöjden. Då visar tunern hur nära eller långt ditt inmatade ljud är från din önskade ton. Det som är intressant är att en ljudvåg är en kombination av flera sinusformade vågformer med verkliga och imaginära komponenter. Även om detta kan verka svårt att arbeta med för de okända, finns det några sätt att vi fortfarande kan analysera en våg med verkliga och imaginära värden.

Demo:

Steg 1: Utrustningslista (ta en bild av tavlan och Kevins komp)

Först behöver vi ett Basys 3 -kort och en dator som stöder följande program: Garageband/Audacity eller annan DAW - för att spela in via en mikrofon och exportera wavfiler

Python - kan använda pylab och scipy för provtagning och fft

Vivado - för att ansluta till Basys 3 -kortet och visuellt se resultaten

Steg 2: Översikt

En tuner består av få viktiga komponenter: mikrofon, sampler, FFT (Fast Fourier Transform), komparator, avkodare och display. Syftet med mikrofonen är att fånga ingångsvågformen. Samplaren tar emot mikrofonens utsignal och använder FFT för att omvandla signalen till en utmatning av storleken i frekvenser. Sedan använder man utgången från FFT och hittar maxstorleken och frekvensen som är associerad med den dividerad med 2, frekvensen som är associerad med vågformens tonhöjd kan hittas. Det värdet kan sedan gå in i jämföraren. Det jämförs sedan med en uppslagstabell, som redan har satt frekvensvärden för perfekta tonhöjden för alla noter. Jämföraren ges en ingång för den önskade noten, som den sedan kan matcha den önskade noten till den rätta frekvensen från uppslagstabellen. Då kommer komparatorn att välja noten med den närmaste frekvensen till maxfrekvensen. Jämföraren kommer att jämföra de två värdena och se stänga värdet av frekvensen till den önskade och sedan sätta den data i en signal. Jämföraren kommer att skicka den signalen till avkodaren, där avkodaren väljer ingångarna för anoderna på 7-segmentskärmen för att visa notens noggrannhet.

Steg 3: WAV -fil

I det här steget tar vi en wav -fil med en tonhöjd och försöker mata ut frekvensen för den tonhöjden.

Först behöver du en wav -fil med en anteckning. I det här exemplet använder vi en 16 -bitars stereo wav -fil med en samplingshastighet på 44,1 kHz. Detta kan antingen skapas i en DAW som Garageband eller laddas ner. För detta exempel kan en A4 440Hz sinusvåg som genereras av oss på Garageband laddas ner här.

Steg 4: Python- Användning av Pylab och Scipy

Vi använde Python -biblioteket för att göra "Fast Fourier -transform". Online resurs tillät oss att imitera och se vad som är användbart i pylab och scipy.

1. Om du inte har installerat pylab eller scipy måste du göra det. Eller, Pycharm har en mycket bra funktion. När du försöker importera pylab eller scipy, finns det en krånglig understrykning som säger att du inte har installerat biblioteket än. Du kan sedan installera dem direkt genom att trycka på den röda glödlampan (den visas när du placerar markören nära den krångliga underlinjen).

2. Använd scipy.io.wavfile.read -funktionen, läs och ta ut data från exempel -wav -fil. Kör igenom data med pylab.fft, det kommer att ge dig en lista över storleken för effekten.

3. Hitta sedan max för den effekt som avges från listan. Leta efter listindex där maxeffekten uppstår eftersom det snabbare sättet att hitta vilken frekvens som associeras med den effekten. Slutligen returnera maxfrekvensen. Eftersom vi senare behöver mata in en binär frekvenssignal till VHDL -kod kan vi konvertera frekvensen i float till binär och returnera den.

Steg 5: Python-provtagning och FFT (Visa kod och dess resultat)

I detta steg går hela poängen till denna länk nedan för provtagning och FFT.

samcarcagno.altervista.org/blog/basic-sound…Vår kod:

Efter att pylab och scipy har installerats kan wav -filer importeras och läsas.

från pylab import*från scipy.io import wavfile

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

Sedan representerar snd.shape provpunkterna och antalet kanaler. I vårt fall beror samplingspunkterna på hur lång wav -filen är och antalet kanaler är 2 eftersom det är stereo.

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

organiserar tidssignalen i en array.

Sedan skapar FFT en matris i frekvens och storlek (effekt)

Sedan genom en stund -slinga hittas maxstorleken och frekvensen som är associerad med den. Frekvensen/2 representerar vågfilens tonhöjd.

Sedan använder vi vår egen kod, heltalet som representerar frekvensen konverterades till ett 12 -bitars binärt tal och en textfil skapades med det numret i det.

Steg 6: Vivado (komparator)

I denna del av processen behöver vi en komparator för att jämföra två ingångsfrekvenser.

1. Skapade en komparator för att jämföra om ingångsfrekvensen (mottagaren) är högre, lägre eller inom den definierade noten på 2 Hz. (typisk gitarrmottagare sträcker sig från e2 till g5, 82 Hz till 784 Hz).

2. När vi skapade en marginal på 2 Hz använde vi en RCA för att lägga till “000000000010” till mottagarfrekvensen och kontrollera var den fortfarande är för låg för användarinmatning. Om så är fallet, singelbitsignal "hög" <= '0', 'låg' <= '1'. Sedan lägger vi till “000000000010” till användarinmatningen för att se om mottagarens ingång är ännu högre än så. Om så är fallet, "hög" <= '1', 'låg' <= '0'. Inget fall skulle båda returnera "0".

3. Eftersom nästa del av modulen behöver en specifik 4-bitars data för att berätta vad mottagaranteckningen är, inte bara att returnera de 2 jämförande utgångarna (låg och hög), måste vi returnera koden associerad till not, som associerar med frekvensen. Se tabellen nedan:

C | 0011

C# | 1011

D | 0100

D# | 1100

E | 0101

F | 0110

F# | 1110

G | 0111

G# | 1111

A | 0001

A# | 1001

B | 0010

Använda flera if -satser för att kategorisera dem i notering och koda dem till vad som behövs för de sju segmentavkodaren.

Steg 7: BILDER AV BASYS 3 Board

Steg 8: Vivado (7 -segmentsavkodare med multiplexering)

Allt behöver en display. Det är en viktig faktor som bestämmer värdet på en design. Därför måste vi skapa en bildskärm med sju segmentavkodare, vilket gör att vi kan visa vår förmåga att designa en tuner på B-kortet. Det skulle också hjälpa oss att testa och felsöka.

En avkodare med sju segment innehåller ingångar med namnet Note, low, high och CLK, medan SSEG, AN och Fiz_Hz matas ut. Det finns en bild av blockdiagrammet ovan för att hjälpa oss att förstå designen.

Syftet med att ha två separata låga och höga ingångar är att ge komparatorns designer friheten att manipulera om ljudfrekvensen (våg) är högre eller lägre än ingångsfrekvensen (Fix_Hz) som användaren vill jämföra. Dessutom representerar utmatningen SSEG de sju segmenten som visas och pricken därefter, medan AN representerar anoderna för vilka uppsättningen av de sju segmenten visas för att lysa upp.

I denna avkodare med sju segment spelar klockan (CLK) en viktig roll för att visa två olika värden på två eller flera olika anoder. Eftersom styrelsen inte tillåter oss att visa två olika värden samtidigt, måste vi använda multiplexering för att visa ett värde ett i taget, medan vi byter till ett annat värde tillräckligt snabbt för att våra ögon inte kan fånga det. Det är här CLK -ingången spelar in.

Mer information finns i källkoden.

Steg 9: Vivado (kombinerande komponenter)

När varje modul (pythonmottagare, komparator, sju segmentavkodare, etc.) är klar, sätter vi ihop den med en större modul. Precis som bilden under avsnittet "Översikt" visas, ansluter vi varje signal därefter. För referens, kolla vår källkod "SW_Hz.vhd".

Tack. Hoppas du njuter.