Laser Harp Synthesizer op Zybo Board - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:19

In deze tutorial zullen we een volledig functionele laserharp maken met behulp van IR-sensoren met een seriële interface waarmee de gebruiker de stemming en toon van het instrument kan veranderen. Deze harp wordt de 21e-eeuwse remake van het eeuwenoude instrument. Het systeem is gemaakt met behulp van een Xilinx Zybo-ontwikkelbord samen met de Vivado Design Suites. Wat heb je nodig om het project te voltooien:

• 12 IR-sensoren en -zenders (meer of minder kunnen worden gebruikt, afhankelijk van het aantal strings)
• Zybo Zynq-7000 ontwikkelbord
• Gratis RTOS
• Vivado Design Suite
• Draad (voor het aansluiten van de sensoren op het bord)
• 3 stuks PVC pijp ((2) 18 inch en (1) 8 inch)
• 2 PVC-ellebogen

Stap 1: Download de Zybo DMA-audiodemo van Digilent

De FPGA-kant van dit project is grotendeels gebaseerd op het hier gevonden demoproject. Het gebruikt directe geheugentoegang om gegevens rechtstreeks vanuit het geheugen te verzenden waarnaar de processor kan schrijven via AXI Stream naar een I2S-audioblok. De volgende stappen helpen u om het DMA-audiodemoproject in gebruik te nemen:

1. Een nieuwe versie van het bordbestand voor het Zybo-bord kan nodig zijn. Volg deze instructies om nieuwe bordbestanden voor Vivado te verkrijgen.
2. Volg stap 1 en 2 in de instructies op deze pagina om het demoproject in Vivado te openen. Gebruik de Vivado-methode, niet de SDK-hardwareoverdracht.
3. Mogelijk krijgt u een bericht dat sommige van uw IP-blokkeringen moeten worden bijgewerkt. Als dit het geval is, selecteert u "Show IP Status" en selecteert u vervolgens in het tabblad IP-status alle verouderde IP-adressen en klikt u op "Upgrade Selected". Wanneer het klaar is en er een venster verschijnt met de vraag of je een outputproduct wilt genereren, ga je gang en klik je op "Genereren". Als u een kritieke waarschuwing krijgt, negeer deze dan.
4. Schakel van het ontwerp naar het tabblad bronnen in Vivado om de bronbestanden te zien. Klik met de rechtermuisknop op het blokontwerp "design_1" en selecteer "HDL-wrapper maken". Selecteer desgevraagd "gegenereerde wrapper kopiëren om gebruikersbewerkingen toe te staan". Er wordt een wrapper-bestand voor het project gegenereerd.
5. Nu die kritieke stappen die op de een of andere manier waren weggelaten in de andere tutorial zijn voltooid, kun je terugkeren naar de eerder gelinkte tutorial en doorgaan vanaf stap 4 tot het einde en ervoor zorgen dat het demoproject correct wordt uitgevoerd. Als je geen manier hebt om audio in te voeren om op te nemen, neem dan gewoon op met je koptelefoon in en luister naar een vaag geluid van 5-10 seconden wanneer je op de afspeelknop drukt. Zolang er iets uit de koptelefoonaansluiting komt wanneer je op de afspeelknop drukt, werkt het waarschijnlijk correct.

Stap 2: Breng enkele wijzigingen aan in Vivado

Dus nu heb je de DMA-audiodemo van Digilent aan het werk, maar dat is hier helemaal niet het einddoel. We moeten dus teruggaan naar Vivado en enkele wijzigingen aanbrengen zodat onze sensoren kunnen worden aangesloten op de PMOD-headers en we hun waarde aan de softwarekant kunnen gebruiken.

1. Open het blokschema in Vivado
2. Maak een GPIO-blok door met de rechtermuisknop te klikken in een lege ruimte in het blokschema en "IP toevoegen" te selecteren in het menu. Zoek en selecteer "AXI GPIO".
3. Dubbelklik op het nieuwe IP-blok en ga in het venster IP-adres opnieuw aanpassen naar het tabblad IP-configuratie. Selecteer alle ingangen en stel de breedte in op twaalf, aangezien we 12 "snaren" op onze harp zullen hebben en daarom 12 sensoren nodig hebben. Als u minder of meer sensoren wilt gebruiken, past u dit aantal op de juiste manier aan. Stel ook enable interrupt in.
4. Klik met de rechtermuisknop op het nieuwe GPIO IP-blok en selecteer "run connection automation". Vink het vakje AXI aan en klik op OK. Dit zou de AXI-interface automatisch moeten verbinden, maar laat de uitgangen van het blok niet aangesloten.
5. Om ruimte te maken voor de extra interrupt, dubbelklik je op het xlconcat_0 IP-blok en verander je het aantal poorten van 4 naar 5. Vervolgens kun je de ip2intc_irpt-pin van het nieuwe GPIO-blok verbinden met de nieuwe ongebruikte poort op het xlconcat-blok.
6. Klik met de rechtermuisknop op de "GPIO"-uitgang van het nieuwe GPIO IP-blok en selecteer "extern maken". Zoek waar de lijn naartoe gaat en klik op de kleine zijwaartse vijfhoek en aan de linkerkant zou een venster moeten openen waar je de naam kunt wijzigen. Verander de naam in "SENSOREN". Het is belangrijk om dezelfde naam te gebruiken als u wilt dat het bestand met beperkingen werkt, anders moet u de naam in het bestand met beperkingen wijzigen.
7. Ga terug naar het tabblad bronnen, zoek het bestand met beperkingen en vervang het door het bestand dat we bieden. U kunt ervoor kiezen om het bestand te vervangen of gewoon de inhoud van ons bestand met beperkingen te kopiëren en over de inhoud van het oude te plakken. Een van de belangrijke dingen die ons bestand met beperkingen doet, is het inschakelen van de pullup-weerstanden op de PMOD-headers. Dit is nodig voor de specifieke sensoren die we hebben gebruikt, maar niet alle sensoren zijn hetzelfde. Als uw sensoren pulldown-weerstanden nodig hebben, kunt u elke instantie van "set_property PULLUP true" wijzigen in "set_property PULLDOWN true". Als ze een andere weerstandswaarde vereisen dan die op het bord, dan kunt u deze lijnen verwijderen en externe weerstanden gebruiken. De pinnamen staan in de opmerkingen in het beperkingenbestand en ze komen overeen met de labels in het eerste diagram in de Zybo-schema's pagina die hier te vinden is. Als u verschillende pmod-pinnen wilt gebruiken, stemt u gewoon de namen in het beperkingsbestand af op de labels in het schema. We gebruiken PMOD-header JE en JD en gebruiken zes datapinnen op elk, waarbij pin 1 en 7 worden weggelaten. Deze informatie is belangrijk bij het aansluiten van uw sensoren. Zoals in het schema te zien is, zijn pinnen 6 en 12 op de PMODS VCC en zijn pinnen 5 en 11 geaard.
8. Genereer de HDL-wrapper zoals eerder en kopieer en overschrijf de oude. Wanneer dat is gebeurd, genereert u bitstream en exporteert u hardware zoals voorheen, en start u de SDK opnieuw. Als u wordt gevraagd of u het oude hardwarebestand wilt vervangen, is het antwoord ja. Het is waarschijnlijk het beste om de SDK te sluiten wanneer u hardware exporteert, zodat deze correct wordt vervangen.
9. Start de SDK.

Stap 3: FreeRTOS laten draaien

De volgende stap is om FreeRTOS op het Zybo-bord te laten draaien.

1. Als je nog geen exemplaar hebt, download dan FreeRTOS hier en pak de bestanden uit.
2. Importeer de FreeRTOS Zynq-demo op FreeRTOSv9.0.0\FreeRTOS\Demo\CORTEX_A9_Zynq_ZC702\RTOSDemo. Het importproces is vrijwel hetzelfde als voor het andere demoproject, maar omdat de FreeRTOS Zynq-demo afhankelijk is van andere bestanden in de FreeRTOS-map, moet u de bestanden niet naar uw werkruimte kopiëren. In plaats daarvan moet u de hele FreeRTOS-map in uw projectmap plaatsen.
3. Maak een nieuw board-ondersteuningspakket aan door naar "file" -> "new" -> "board support package" te gaan. Zorg ervoor dat standalone is geselecteerd en klik op voltooien. Even later verschijnt er een venster, vink het vakje naast lwip141 aan (dit voorkomt dat een van de FreeRTOS-demo's niet kan compileren) en klik op OK. Klik daarna met de rechtermuisknop op het RTOSdemo-project en ga naar "eigenschappen", ga naar het tabblad "projectreferenties" en vink het vakje aan naast de nieuwe bsp die u hebt gemaakt. Hopelijk wordt het herkend, maar soms kan de Xilinx SDK raar zijn over dit soort dingen. Als je na deze stap nog steeds een foutmelding krijgt dat xparameters.h ontbreekt of iets dergelijks, probeer dan deze stap te herhalen en misschien de SDK af te sluiten en opnieuw te starten.

Stap 4: Laserharpcode toevoegen

Nu FreeRTOS is geïmporteerd, kunt u de bestanden van het laserharpproject naar de FreeRTOS-demo brengen

1. Maak een nieuwe map onder de src-map in de FreeRTOS-demo en kopieer en plak alle meegeleverde c-bestanden behalve main.c in deze map.
2. Vervang de RTOSDemo main.c door de meegeleverde main.c.
3. Als alles correct is gedaan, zou u op dit punt de laserharp-code moeten kunnen uitvoeren. Voor testdoeleinden wordt de knopinvoer die werd gebruikt in het DMA-demoproject nu gebruikt om geluiden af te spelen zonder aangesloten sensoren (elk van de vier hoofdknoppen werkt). Het zal een snaar spelen elke keer dat u erop drukt en door alle snaren in het systeem bladeren door meerdere keren te drukken. Sluit een koptelefoon of luidsprekers aan op de koptelefoonaansluiting op het Zybo-bord en zorg ervoor dat je de geluiden van de snaren kunt horen die doorkomen als je op een knop drukt.

Stap 5: Over de code

Velen van jullie die deze tutorial lezen, zijn hier waarschijnlijk om te leren hoe je audio instelt of DMA gebruikt om iets anders te doen, of om een ander muziekinstrument te maken. Om die reden zijn de volgende paragrafen gewijd aan het beschrijven hoe de verstrekte code werkt in combinatie met de eerder beschreven hardware om een werkende audio-uitvoer te krijgen met behulp van DMA. Als je begrijpt waarom de codestukken er zijn, zou je ze moeten kunnen aanpassen voor wat je ook wilt maken.

Onderbrekingen

Eerst zal ik vermelden hoe interrupts worden gemaakt in dit project. De manier waarop we het deden, was door eerst een interrupt-vectortabelstructuur te maken die de ID, de interrupt-handler en een verwijzing naar het apparaat voor elke interrupt bijhoudt. De interrupt-ID's komen van xparameters.h. De interrupt-handler is een functie die we hebben geschreven voor de DMA en GPIO, en de I2C-interrupt komt van de Xlic I2C-driver. De apparaatreferentie verwijst naar instanties van elk apparaat die we elders initialiseren. Tegen het einde van de _init_audio-functie gaat een lus door elk item in de interruptvectortabel en roept twee functies aan, XScuGic_Connect() en XScuGic_Enable() om verbinding te maken en de interrupts in te schakelen. Ze verwijzen naar xInterruptController, een interruptcontroller die standaard in de FreeRTOS main.c is gemaakt. Dus eigenlijk koppelen we al onze interrupts aan deze interruptcontroller die al door FreeRTOS voor ons is gemaakt.

DMA

De DMA-initialisatiecode begint in lh_main.c. Eerst wordt een statische instantie van een XAxiDma-structuur gedeclareerd. Vervolgens wordt het in de functie _init_audio() geconfigureerd. Eerst wordt de configure-functie van het demo-project aangeroepen, die zich in dma.c bevindt. Het is redelijk goed gedocumenteerd en komt rechtstreeks uit de demo. Vervolgens wordt de interrupt verbonden en ingeschakeld. Voor dit project is alleen de master-naar-slave-interrupt nodig, omdat alle gegevens door de DMA naar de I2S-controller worden verzonden. Als u audio wilt opnemen, heeft u ook de slave-naar-master-interrupt nodig. De master-naar-slave-interrupt wordt aangeroepen wanneer de DMA klaar is met het verzenden van de gegevens die u hem hebt opgedragen. Deze onderbreking is ongelooflijk belangrijk voor ons project, want elke keer dat de DMA klaar is met het verzenden van een buffer met audiosamples, moet hij onmiddellijk beginnen met het verzenden van de volgende buffer, anders zou er een hoorbare vertraging optreden tussen de verzendingen. Binnen de functie dma_mm2s_ISR() kun je zien hoe we met de interrupt omgaan. Het belangrijke deel is bijna aan het einde, waar we xSemaphoreGiveFromISR() en portYIELD_FROM_ISR() gebruiken om _audio_task() te informeren dat het de volgende DMA-overdracht kan starten. De manier waarop we constante audiogegevens verzenden, is door af te wisselen tussen twee buffers. Wanneer een buffer naar het I2C-blok wordt verzonden, worden de waarden van de andere buffer berekend en opgeslagen. Wanneer dan de onderbreking van de DMA komt, schakelt de actieve buffer over en wordt de meer recent geschreven buffer overgedragen, terwijl de eerder overgedragen buffer wordt overschreven met nieuwe gegevens. Het belangrijkste onderdeel van de functie _audio_task is waar fnAudioPlay() wordt aangeroepen. fnAudioPlay() neemt het DMA-exemplaar, de lengte van de buffer en een aanwijzer naar de buffer van waaruit gegevens worden overgedragen. Een paar waarden worden naar I2S-registers gestuurd om te laten weten dat er meer samples komen. Vervolgens wordt XAxiDma_SimpleTransfer() aangeroepen om de overdracht te starten.

I2S-audio

audio.c en audio.h zijn waar de I2S-initialisatie plaatsvindt. I2S-initialisatiecode is een vrij algemeen stuk code dat op een aantal plaatsen rondzweeft, je kunt kleine variaties van andere bronnen vinden, maar deze zou moeten werken. Het is redelijk goed gedocumenteerd en er hoefde niet veel veranderd te worden voor het harpproject. De DMA-audiodemo waar het vandaan komt, heeft functies om over te schakelen naar de microfoon- of lijningangen, zodat je die kunt gebruiken als je die functionaliteit nodig hebt.

Geluidssynthese

Om te beschrijven hoe de geluidssynthese werkt, ga ik een lijst maken van elk van de geluidsmodellen die in de ontwikkeling zijn gebruikt en die tot de uiteindelijke methode hebben geleid, omdat het je een idee geeft van waarom het wordt gedaan zoals het wordt gedaan.

Methode 1: Een periode van sinuswaarden wordt berekend voor elke snaar met de corresponderende frequentie voor de muzieknoot van die snaar en opgeslagen in een array. De lengte van de array is bijvoorbeeld de periode van de sinusgolf in samples, wat gelijk is aan # samples/cycle. Als de bemonsteringsfrequentie 48 kHz is en de nootfrequentie 100 Hz, dan zijn er 48.000 samples/seconde en 100 cycli/seconde, wat leidt tot 4800 samples per cyclus, en de arraylengte is 4800 samples en bevat de waarden van één volledige sinusgolf periode. Wanneer de snaar wordt gespeeld, wordt de audiosamplebuffer gevuld door een waarde uit de sinusgolfarray te nemen en deze als een sample in de audiobuffer te plaatsen, en vervolgens de index in de sinusgolfarray te verhogen, zodat we ons vorige voorbeeld in de loop van de cursus gebruiken van 4800 samples wordt één sinusgolfcyclus in de audiobuffer geplaatst. Een modulo-bewerking wordt gebruikt op de array-index, zodat deze altijd tussen 0 en de lengte valt, en wanneer de array-index een bepaalde drempel overschrijdt (zoals misschien 2 seconden aan samples), wordt de string uitgeschakeld. Om meerdere snaren tegelijkertijd te spelen, houdt u de array-index van elke snaren afzonderlijk bij en voegt u de waarde van de sinusgolf van elke snaren bij elkaar om elk monster te krijgen.

Methode 2: Om een meer muzikale toon te creëren, beginnen we met het vorige model en voegen we harmonischen toe aan elke grondfrequentie. Harmonische frequenties zijn frequenties die gehele veelvouden zijn van de grondfrequentie. In tegenstelling tot wanneer twee niet-gerelateerde frequenties bij elkaar worden opgeteld, wat resulteert in twee verschillende geluiden die tegelijkertijd worden gespeeld, wanneer harmonischen bij elkaar worden opgeteld, blijft het klinken als slechts één geluid, maar met een andere toon. Om dit te bereiken, voegen we elke keer dat we de waarde van de sinusgolf op locatie (array-index % arraylengte) toe aan het audiomonster, ook (2 * array-index % arraylengte) en (3 * array-index % arraylengte), enzovoort, voor hoeveel harmonischen er ook gewenst zijn. Deze vermenigvuldigde indices zullen de sinusgolf doorkruisen bij frequenties die gehele veelvouden zijn van de oorspronkelijke frequentie. Om meer controle over de toon mogelijk te maken, worden de waarden van elke harmonische vermenigvuldigd met een variabele die de hoeveelheid van die harmonische in het totale geluid vertegenwoordigt. De fundamentele sinusgolf kan bijvoorbeeld zijn waarden allemaal met 6 vermenigvuldigen om het meer een factor in het algehele geluid te maken, terwijl de 5e harmonische een vermenigvuldiger van 1 kan hebben, wat betekent dat de waarden veel minder bijdragen aan het algehele geluid.

Methode 3: Oké, dus nu hebben we een heel mooie toon op de noten, maar er is nog steeds een vrij cruciaal probleem: ze spelen op een vast volume voor een vaste duur. Om helemaal als een echt instrument te klinken, moet het volume van een snaar die wordt bespeeld geleidelijk afnemen. Om dit te bereiken, wordt een array gevuld met de waarden van een exponentieel afnemende functie. Wanneer nu de audiosamples worden gemaakt, wordt het geluid dat uit elke snaar komt berekend zoals in de vorige methode, maar voordat het aan het audiosample wordt toegevoegd, wordt het vermenigvuldigd met de waarde bij de array-index van die snaren in de array met exponentiële vervalfunctie. Dit zorgt ervoor dat het geluid na verloop van tijd soepel verdwijnt. Wanneer de array-index het einde van de decay-array bereikt, wordt de string gestopt.

Methode 4: Deze laatste stap is wat de snaargeluiden echt hun realistische snaargeluid geeft. Vroeger klonken ze aangenaam maar duidelijk gesynthetiseerd. Om te proberen een echte harpsnaar beter na te bootsen, wordt aan elke harmonische een andere vervalsnelheid toegewezen. In echte snaren, wanneer de snaar voor het eerst wordt aangeslagen, is er een hoog gehalte aan hoogfrequente harmonischen die het soort tokkelgeluid creëren dat we van een snaar verwachten. Deze hoogfrequente harmonischen vormen heel kort het hoofdgedeelte van het geluid, het geluid van de snaar die wordt aangeslagen, maar ze vervallen zeer snel naarmate de langzamere harmonischen het overnemen. Er wordt een Decay-array gemaakt voor elk harmonisch nummer dat wordt gebruikt in de geluidssynthese, elk met zijn eigen Decay-snelheid. Nu kan elke harmonische onafhankelijk worden vermenigvuldigd met de waarde van de bijbehorende vervalarray bij de array-index van de snaar en aan het geluid worden toegevoegd.

Over het algemeen is de geluidssynthese intuïtief, maar rekenwerk zwaar. Het hele snaargeluid in één keer in het geheugen opslaan zou te veel geheugen vergen, maar het berekenen van de sinusgolf en de exponentiële functie tussen elk frame zou veel te lang duren om de snelheid van het afspelen van audio bij te houden. In de code worden een aantal trucs gebruikt om de berekening te versnellen. Alle wiskunde, behalve bij de initiële creatie van de sinus- en exponentiële vervaltabellen, wordt gedaan in een geheel getal, wat vereist dat de beschikbare numerieke ruimte in de 24-bits audio-uitvoer wordt gespreid. De sinustabel heeft bijvoorbeeld een amplitude van 150, zodat deze soepel is, maar niet zo groot dat veel snaren die samen worden gespeeld, samen meer dan 24 bits kunnen zijn. Evenzo worden de exponentiële tabelwaarden vermenigvuldigd met 80 voordat ze worden afgerond op gehele getallen en worden opgeslagen. De harmonische gewichten kunnen discrete waarden tussen 0 en 10 aannemen. Alle samples worden ook daadwerkelijk verdubbeld en de sinusgolven worden geïndexeerd door 2'en, waardoor de samplefrequentie effectief wordt gehalveerd. Dit beperkt de maximale frequentie die kan worden gespeeld, maar was nodig om het huidige aantal snaren en harmonischen snel genoeg te berekenen.

Het maken van dit geluidsmodel en het werkend krijgen kostte veel moeite aan de processorkant, en het zou ongelooflijk moeilijk zijn geweest om het in de tijdsbestek van dit project helemaal opnieuw aan de fpga-kant te krijgen (stel je voor dat je de bitstream elke keer opnieuw moet maken keer dat een stukje verilog werd gewijzigd om het geluid te testen). Het is echter waarschijnlijk een betere manier om het op de fpga te doen, waardoor het probleem van het niet kunnen berekenen van samples snel genoeg wordt geëlimineerd en er meer snaren, harmonischen en zelfs audio-effecten of andere taken op de computer kunnen worden uitgevoerd. processor kant.

Stap 6: Bedrading van de sensoren

Om de snaren te maken, hebben we IR-breekstraalsensoren gebruikt die detecteren wanneer de snaar wordt bespeeld. We hebben onze sensoren besteld via de volgende link. De sensoren hebben een voedings-, massa- en datakabel, terwijl de zenders alleen een voedings- en massakabel hebben. We gebruikten de 3,3 V- en aardingspinnen van de PMOD-headers om zowel de zenders als de sensoren van stroom te voorzien. Om alle sensoren en zenders van stroom te voorzien, is het noodzakelijk om alle sensoren en zender parallel aan te sluiten. De datadraden van de sensoren moeten elk naar hun eigen pmod-pin gaan.

Stap 7: Het skelet construeren

Om de vorm van de harp te creëren, worden de drie stukken gebruikt als een skelet om de sensoren en zenders op te plaatsen. Op een van de twee stukken PVC-buis van 18 inch lijnt u de sensoren en zenders in afwisselende volgorde uit op 1,5 inch van elkaar en plakt u ze vervolgens vast aan de buis. Op de andere 18 inch PVC-buis lijnt u de sensoren en emitters in afwisselende volgorde uit, maar zorg ervoor dat u de volgorde verschuift (d.w.z. als de eerste buis eerst een sensor had, zou de tweede eerst een emitter moeten hebben en vice versa). Het zal nodig zijn om langere draden op de data-, stroom- en aardingsdraden te solderen om ervoor te zorgen dat ze het bord kunnen bereiken.

Stap 8: Het bouwen van de houten buitenkant

Deze stap is optioneel, maar wordt ten zeerste aanbevolen. Door de houten buitenkant ziet de harp er niet alleen mooi uit, het beschermt ook de sensoren en draden tegen beschadiging. Het houten frame kan worden gemaakt door een rechthoekige ring van hout. De binnenkant van de rechthoek moet een opening hebben van minimaal 1-1 / 2 inch om in het buis- en sensorskelet te passen. Zodra het frame is geconstrueerd, boort u twee gaten waarmee de draden van de sensor en emitters naar buiten kunnen om ze met het bord te verbinden.

*Opmerking: Het wordt aanbevolen om toegangspunten toe te voegen om het pijpskelet te kunnen verwijderen en inbrengen voor het geval er reparaties moeten worden uitgevoerd of kleine aanpassingen moeten worden gemaakt.

Stap 9: Alle stukjes bij elkaar zetten

Zodra alle voorgaande stappen zijn voltooid, is het tijd om de harp te bouwen. Plaats eerst het pijpskelet in de houten buitenkant. Sluit vervolgens de draden voor de sensoren en zenders aan op de juiste locatie op het bord. Open vervolgens de SDK en klik op de debug-knop om het bord te programmeren. Zodra het bord is geprogrammeerd, sluit u een koptelefoon of een luidspreker aan. Afhankelijk van welke sensor in welke pmod-poort terechtkomt, zullen de snaren van je harp waarschijnlijk in het begin defect zijn. Omdat het moeilijk kan zijn om te bepalen welke draad naar welke sensor gaat als er zoveel draden bij betrokken zijn, hebben we een manier toegevoegd om stringnummers in kaart te brengen om bitposities in software te onderbreken. Zoek "static int sensor_map[NUM_STRINGS]" en pas de waarden in de array aan totdat de snaren in volgorde van laag naar hoog worden afgespeeld.

Het menu kan worden gebruikt door een seriële terminal te openen (bijv. RealTerm) en de baudrate in te stellen op 115200 en het display op ANSI. U kunt door het menu navigeren door de w en s-toetsen te gebruiken om omhoog en omlaag te gaan en de a en d-toetsen om de waarden te wijzigen.

Stap 10: ROCK OUT

Zodra de harp volledig functioneel is. Beheers de harp en luister naar het zoete geluid van je eigen muziek!