Hoe een verlichte ukelele te bouwen! - Ajarnpa

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

Ik speel de ukelele. Nogal middelmatig (als dat een woord is), dus ik dacht: "Als je echt indruk wilt maken op de dames, heb je een middel nodig om ze af te leiden van de ramp die zich op het podium afspeelt." Zo werd de "Light-up Ukelele" geboren.

Dit project neemt een Concert Ukulele-kit en voegt een Arduino-gestuurde LED toe aan elke snaar- en fretpositie. Het voegt ook een fraai OLED-display en een op roterende encoder gebaseerde gebruikersinterface toe om de modus en intensiteit van de LED-string te selecteren.

De voltooide uke-hardwarefuncties:

1. Arduino MICRO om te communiceren met de LED-string, het display en het invoerapparaat.
2. 48 individueel programmeerbare full colour LED's
3. Een OLED-scherm
4. Een roterende encoder voor gebruikersinvoer
5. USB-interface voor externe voeding en Arduino-programmering

De uke-software heeft:

1. Basislichtregelingsmodi die de LED's op de proef stellen
2. Een handige theatertent-modus (erg handig voor optredens!)
3. LED-intensiteitsregeling
4. Een volledige akkoordenbibliotheek van alle Ukulele-akkoorden op de eerste positie (akkoordwaarde en teken)
5. Mogelijkheid om lopende tekst (verticaal) weer te geven met een unieke tekenset van 4 x 6 pixels

Dit instructable beschrijft het voltooide prototype. De volledige ontwikkelingssaga is HIER beschikbaar, inclusief enkele educatieve (pijnlijke) fouten en een waardevolle les in waarom je je eerste ontwerp MOET afmaken (hoe lelijk de dingen ook worden). Je weet nooit alle dingen die je echt niet weet totdat je het einde hebt bereikt (en dan weet je het nog steeds niet!), maar je bent een stuk beter af en een stuk slimmer voor het volgende ontwerp.

Ik bouwde het prototype rond een Grizzly Concert Ukelele-kit. Beginnen met een kit verlicht de zorgen over het lichaam van de uke (nou ja, meestal), en elimineert het meeste echte gitaarwerk. Deze kits zijn behoorlijk compleet en niet zo duur in het grote geheel van dingen (en minder pijnlijk omdat je fouten zult maken).

Stap 1: Maak een plan

Op de toets (of toets) die in sommige sets zit, zijn de frets al bevestigd. Dat is goed/slecht. Het is leuk om tijd te besparen, maar in termen van het uitzetten van een boorpatroon en het op zijn plaats houden tijdens het frezen, is het een beetje lastig. Nadat ik degene in de kit had vernietigd, koos ik (nou ja, ik had geen andere keuze dan een andere kit te kopen) om een nieuwe toets te kopen.

Bij het ontwerpen van de toets moeten we de toename van de dikte berekenen die nodig is om de PCB en de LED's in te bedden (en vergeet de passieve componenten niet), maar niet zozeer dat de LED's te ver van het oppervlak van de toets zijn verwijderd.

De LED-printplaat (PCB) is ontworpen als een eenvoudig 2-laags bord. Dit helpt veel bij de handmontage van de LED-snaar en geeft wat mechanische sterkte (het is glasvezel en epoxy) aan de Ukelele-hals. Ik ben begonnen met de lay-out in Eagle, maar heb uiteindelijk Altium Designer gebruikt vanwege de beperkingen van de bordgrootte. Het Altium-schema en PCB-bestanden zijn hier.

De kit toets was slechts 0,125 inch dik. Dus, uitgaande van een PCB met een dikte van 0,062 inch en een extra 0,062 inch voor de LED's, betekent dat we veel (zoals in alle) van de toets zouden moeten verwijderen. Ter compensatie kunnen we ofwel de LED's in de toets gedeeltelijk wegsnijden met een corresponderend vak in de hals voor de PCB, ofwel kunnen we de hele toets (de optie waar ik voor ging) vervangen door een dikkere versie van Luther Mercantile International (LMII), die 0,25 inch zijn om te beginnen.

MAAR onthoud dat je de hals nog steeds moet bewerken om de toename in dikte van de toets te compenseren. Het andere voordeel dat je krijgt is cosmetisch, aangezien de PCB nu volledig is ingebed in de toets, waardoor de randen veel gemakkelijker af te werken zijn (en er veel mooier uitzien!) en het frezen van de hals vereenvoudigt.

Technische dingen (negeren als je wilt):

Dit doet overigens niet zoveel af aan de stijfheid van de nek. Het PCB-materiaal is veel stijver dan het originele toetshout (mahonie-modulus: 10,6 GPa versus FR4-modulus: 24 GPa), en aangezien we een ukelele bouwen, is er niet een enorme hoeveelheid snaarspanning die anders zou kunnen vervormen (draai of kromtrekken) de nek.

Een zeer interessante overweging (die ik waarschijnlijk nog moet berekenen) is wat er gebeurt bij temperatuur. In het algemeen is voor hout, evenwijdig aan de nerf, de thermische uitzettingscoëfficiënt ongeveer 3 x 10^-6/K, en voor FR4 is het 14×10^−6/K. Er is dus nogal een significant verschil. De zorg is dat er spanning in de hals ontstaat als de temperatuur varieert, wat op zijn beurt de snaren ontstemt. Dat kan worden gecompenseerd door een vergelijkbare laag aan de andere kant van de neutrale as aan te brengen of door de FR4 zo dicht mogelijk bij de neutrale as te krijgen. Maar dat wordt overgelaten aan 2.0 … Iets om te modelleren en te evalueren.

De elektronica is ondergebracht in de body van de uke. Er zijn gaten gesneden in de zijwand (niet het klankbord!) van de UKE om ruimte te maken voor het display en de roterende encoder, plus een toegangsplaat om de Arduino Micro vast te houden en toegang te bieden tot de USB-interface. Het ontwerp en de locatie van de toegangsplaat/montage kunnen waarschijnlijk worden verbeterd om de USB-aansluiting op een handigere locatie te plaatsen, maar zoals het er nu uitziet, is het niet zo erg, omdat het niet in de weg zit als je aan het spelen bent.

Het stappenplan is als volgt:

1. Verzamel materialen
2. Krijg de tools die je nodig hebt
3. Frees de hals om plaats te bieden aan de dikkere toets
4. Frees de toets om gaten te maken op de gewenste locaties en om vakken te maken voor het bord en LED's
5. Verkrijg en construeer de PCB met de LED's
6. Frees toegangsgaten in de behuizing van de ukelele voor het OLED-display, de roterende encoder en het toegangspaneel
7. Afdekplaten maken
8. Bevestig draden aan de printplaat; sluit en test de elektronica
9. Bevestig de nek aan het lichaam van de ukelele
10. Boor een toegangsgreep om de PCB-draden in het lichaam door te voeren
11. Lijn de printplaat en toets uit en lijm ze vast aan de hals
12. Breng de fretboardranden waterpas tot aan de hals (verwijder het overtollige materiaal)
13. Installeer de fret draden
14. Breng maskering aan en breng afwerking aan op de ukelele
15. De brug uitlijnen en bevestigen
16. Elektronica installeren en testen.
17. Installeer stemmechanieken en besnaar het instrument
18. Programmeer de Uke-controller
19. Verbaas de wereld met je geweldige ukelele!

Stap 2: Verzamel materialen

Onze materialenlijst ziet er als volgt uit:

1. Ukulele-kit - Ik gebruikte een Grizzly Concert Ukulele-kit (Grizzly Uke Kit bij Amazon), maar die lijkt te worden stopgezet. Zimo maakt een soortgelijk model (Zimo Uke Kit @ Amazon) dat eruitziet alsof het zijn werk zal doen
2. Ukelele toets, pre-sleuven (LMII Uke Fingerboards). Ze zullen de toets op je schaal plaatsen, wat een hoop problemen bespaart
3. Epoxy - voor het lijmen van de toets aan de hals. Ik koos voor epoxy omdat het compatibel is met het PCB-materiaal. Zoek iets met een werktijd van minimaal 60 minuten. Gebruik GEEN typen van 5 minuten, u heeft tijd nodig om aanpassingen te maken
4. Fret-draden - ook verkrijgbaar bij LMII
5. Aangepaste PCB - Altium-bestanden zijn hier. Ik heb gekozen voor normaal materiaal van het type FR4. Flex (polyimide) boards zouden een interessant (zij het duurder) alternatief zijn, omdat ze veel dunner kunnen zijn
6. 48x Neopixel (SK6812) LED's. Verkrijgbaar bij Adafruit en Digikey
7. 48x 0.1uF 0402 caps - groter is acceptabel, maar je moet op de plaatsing letten
8. Aansluitdraad - minimaal 4 tot 6 kleuren om verwarring te voorkomen, ik gebruikte voornamelijk draad van 28 gauge. Bekijk de DC-daling op de LED-voedingsaansluitingen (zowel VCC als GROUND … die stroom moet terugkeren naar de bron!)
9. Roterende encoder - PEC16-4220F-S0024
10. Mooie houten knop - voor de roterende encoder (ik heb de mijne van LMII)
11. OLED-display - van 4D-systemen OLED-displays
12. Externe USB-batterij - altijd goedkoper, en u kunt reserveonderdelen meenemen!
13. Arduino MICRO
14. Bladmessing - om de plaat te maken om de arduino en de rand voor het display vast te houden
15. Diverse verbruiksartikelen, waaronder: schuurpapier, urethaanafwerking, ijslollystokjes, elastiekjes, soldeer, vloeimiddel, borstels, dubbelzijdige tape (ik hou van de UHC-tape van 3M) en kleine koperen houtschroeven (voor de plaat)
16. Optionele verbeteringen aan de ukelele - betere stemmechanieken, betere snaren, betere topkam en zadel, inleg als je je gitaarbouwer wilt laten zien)

Stap 3: Verkrijg de tools die u nodig hebt

Vroeg of laat zul je deze moeten verkrijgen of krijgen:

Onze gereedschapslijst omvat:

1. Freesmachine - Bij voorkeur CNC, maar misschien kom je zelfs met een router en veel geluk toe. Ik gebruikte een combo CNC-frees/router
2. Frezen - bij voorkeur hardmetaal. Frezen gekozen boven vingerfrezen omdat we hout bewerken, geen metaal
3. Klemmen - veel. Meestal nodig om onderdelen vast te houden tijdens het lijmen
4. Soldeerbout - kleine punt voor solderen op het oppervlak
5. Microscoop of vergrootglas - je kunt proberen te solderen met alleen je ogen, maar ik zou het niet aanraden, minimaal 10x
6. Pincet (om onderdelen op hun plaats te zetten)
7. Fretting tools (zie de juiste tools op LMII hier, maar ik gebruikte wat ik thuis had en gemaakt; hamers, vijlen en frezen)
8. Diverse handgereedschappen zoals houtbeitels, schroevendraaiers, zachte slag- of ongelooide huidhamer (om in te frezen), enz.
9. Schuurmiddelen - verschillende korrels schuurpapier

Onze softwaretools omvatten (sommige zijn optioneel, afhankelijk van uw budget/vindingrijkheid):

1. Arduino-software
2. De Ukulele-broncode (https://github.com/conrad26/Ukulele)
3. PCB-layoutpakket - Ik gebruikte Altium omdat de gratis versie van Eagle niet de bordgrootte ondersteunde die ik wilde. Altium is een volledig uitgerust lay-outpakket en niet echt in een prijsklasse voor hobbyisten. Ik heb de Gerber-bestanden op mijn site geplaatst voor het prototype, maar deze hebben zeker een update nodig
4. 3D-modelleringssoftware - ik gebruikte SolidWorks, maar een gratis alternatief is FreeCAD (https://www.freecadweb.org/)
5. CAM-software - zoals FeatureCAM van Autodesk voor het maken van het NC-freesbestand.

De combinatie van het exporteren van 3D-stappenbestanden vanuit Altium samen met een 3D-model van de toets elimineert veel van de moeilijkheid om ervoor te zorgen dat alles op één lijn ligt, maar het is geen vereiste. Een zorgvuldige lay-out zal hetzelfde resultaat bereiken.

Nu we weten wat we willen doen en wat we nodig hebben, laten we een ukelele bouwen.

Stap 4: Frees de hals om de dikkere toets op te nemen

Houd er voor het frezen rekening mee dat de originele vlakheid van het bevestigingsoppervlak van de toets MOET worden gehandhaafd, anders krijgt u een gedraaide toets, wat leidt tot allerlei problemen met het nivelleren van de frets.

Ga daar gewoon niet heen, neem de tijd en klem de nek zorgvuldig en stevig vast en controleer de uitlijning met de frees over de hele nek voordat u gaat snijden. De tijd die je hier doorbrengt, zal je later veel verdriet besparen.

Een van de redenen waarom ik heb gekozen voor een dikkere toets over een inleg in de hals, was het grotere montage- (lijm) oppervlak. Een andere reden is dat het het frezen van de hals vereenvoudigt. Je zaagt eenvoudig het hele oppervlak op de gewenste hoogte.

Stap 5: Verkrijg en bouw de PCB die de LED's vasthoudt

Ik heb de hele montage met de hand gesoldeerd. De LED-pakketten zijn bijzonder gemakkelijk te smelten, dus zorg ervoor dat u ze niet beschadigt. Ik raad aan om een statische band te dragen, omdat de string afhankelijk is van het werken van elke LED.

Het ontwerp van de fretboard is gebaseerd op de WS2812B LED's. Ik besloot om alleen het eerste octaaf van de toets te doen (48 LED's!!). Elke LED kan worden gezien als één bit in een schuifregister. Het schuifregister is geklokt op 800 kHz. Ik heb de Adafruit-bibliotheek gebruikt (zie het gedeelte over programmeren) om dingen snel aan de gang te krijgen.

Ik begon het ontwerp in Eagle, maar de grootte van het bord is beperkt tot ongeveer 4 x 5 inch, dus ik moest (of beter gezegd, ik koos ervoor) over te schakelen naar Altium. Ik gebruik Altium op het werk, dus in werkelijkheid maakte het dingen sneller voor mij. Het Altium-project, schema en pcb-bestanden (en bibliotheekonderdelen) staan op mijn site. Het bord is trapeziumvormig en ongeveer 10 inch lang. Ik denk dat ik had moeten proberen de omtrek wat meer samen te drukken (volgende draai!) Montage was niet slecht, maar als je het kunt betalen, raad ik echt een degelijke soldeerbout (JBC Soldering Irons) en een goede microscoop aan. Ja, ik ben verwend en nee, dat soort dingen heb ik niet in mijn thuislab. Ik ben goedkoop.

Ik heb de planken laten maken bij Sunstone. $ 129 voor twee planken. Gegarandeerd een week beurt. Beknibbel echter niet op de verzending. Ik merkte niet dat ik UPS-aarde gebruikte en uiteindelijk wachtte ik een extra week op mijn boards. De totale montagetijd was ongeveer 2 uur (98 onderdelen).

Stap 6: frees de toets

We moeten de toets frezen om gaten te maken op de gewenste locaties en om vakken te maken voor het bord en LED's.

Ik heb een 3D-model gemaakt van de voltooide toets in Solidworks en de CNC-freesroutine gemaakt met FeatureCAM.

Het onderste deel van de toets (het dichtst bij het klankgat) moet dunner worden gemaakt om rekening te houden met de stapsgewijze hoogteverandering tussen de hals en de body. Zeker de moeite waard om meerdere keren te passen om er zeker van te zijn dat het een redelijk goede pasvorm is.

Achteraf had ik de ongebruikte delen van de toets moeten afsnijden om het beter op de frees te laten passen (mijn goedkope frees had slechts een 12 X-as verplaatsing). De volgorde van bewerkingen moet worden ingesteld om eerst de dikte van de frees aan te passen voordat het frezen van zakken, wat zou moeten leiden tot minder puistjes tussen de zakken.

Voer indien nodig handmatige aanpassingen uit om ruimte voor bedrading toe te voegen. Een belangrijk ding om op te merken is dat ik in sommige zakken doorbrak in de gleuf waar de fretdraad zal gaan. Aangezien dit een geleider is, moet u ervoor zorgen dat er niets belangrijks wordt kortgesloten. Het vermindert ook de sterkte van het materiaal dat de fret op zijn plaats houdt. Het ontwerp moet worden aangepast om nooit een fretsleuf te kruisen.

Stap 7: Frees toegangsgaten in het lichaam van de ukelele

Ik heb handmatig de toegangsgaten in het lichaam gefreesd. Het moeilijkste is om het "platste" gebied te vinden van wat een erg gebogen oppervlak is. Markeer de omtrek met potlood en frees geleidelijk materiaal weg totdat u een goede pasvorm voor het OLED-scherm krijgt. Ik kreeg een machinaal bewerkte koperen ring en bevestigde deze met 3M VHB-lijmtape.

Omdat geen van beide grote precisie vereist, zijn de gaten voor de roterende encoder en het toegangspaneel veel gemakkelijker te maken.

Stap 8: Afdekplaten maken

U moet ook de afdekplaten voor de beeldschermrand en het toegangspaneel aanbrengen. Het toegangspaneel heeft een gat (rechthoekig) nodig voor de USB (micro) connector. Gebruik gewoon de bestaande connector op de Arduino, want er zijn niet veel paneelmontage-opties voor micro-USB. (hoewel als ik helemaal opnieuw zou ontwerpen, ik een van deze zou bekijken)

Om het bord op zijn plaats te houden, maakt u L-beugels van messing en soldeert u ze aan de achterkant van de toegangsplaat. Dit geeft je enige speelruimte bij het positioneren. Om de juiste positionering te krijgen, maakt u eerst een perfboard-montagebord (met montagegaten) voor de Arduino MICRO en bevestigt u de L-beugels eraan met 2-56 machineschroeven. U kunt vervolgens de locatie aanpassen om de USB-poort uit te lijnen en nauwkeurig de locaties voor de beugels op de plaat markeren. Verwijder de beugels van de perfboard en soldeer ze op hun plaats. Monteer tot slot de perfboard-assemblage.

Ik heb vier kleine koperen houtschroeven gebruikt om het koperen toegangspaneel op zijn plaats te houden.

Op dit punt adviseer ik een testpassing voordat de definitieve montage begint. Deze stap is optioneel, maar wordt aanbevolen. Het is veel gemakkelijker om aanpassingen te maken voordat u gaat lijmen.

Stap 9: Bevestig de draden aan de printplaat; De elektronica aansluiten en testen

Bevestig de elektronica nog niet permanent. Bevestig de draden aan de printplaat en zorg ervoor dat u voldoende speling laat om het toegangsgat naar buiten te leiden. Deze moeten uiteindelijk permanent worden bevestigd aan het Arduino MICRO-bord (de foto's tonen een Arduino UNO, die ik heb gebruikt voor code-ontwikkeling)

Stap 10: Bevestig de nek aan het lichaam van de ukelele

Bevestig de nek aan het lichaam van de ukelele volgens de instructies die bij de ukelele-set zijn geleverd. Let vooral op de uitlijning van het toetsoppervlak op de body van de uke.

Stap 11: Boor een toegangsgat om de PCB-draden in het lichaam door te voeren

Zodra de lijm droog is, boort u een gat van ~1/4 (10 mm) onder een hoek zodat de draden van de PCB in de ukelele-body kunnen worden geleid. Zorg ervoor dat u het klankbord niet beschadigt.

Mogelijk moet u ook een klein zakje maken om rekening te houden met de dikte van de draden onder het bord (of optioneel de verbindingen aan de bovenkant plaatsen en reliëf in de toets aanbrengen.)

Een andere testpassing zou op dit moment geen kwaad kunnen.

Stap 12: Lijn de printplaat en de toets uit en lijm ze op de hals

Ik stel voor na te denken over het klemmen (en het uit te proberen!) voordat u gaat lijmen. Misschien wilt u een blok vormen in de vorm van de onderkant van de nek om u een vlak klemoppervlak te geven. De toets is op dit punt groter dan de hals, dus daar moet je rekening mee houden.

Pas op dat u geen epoxy krijgt op een oppervlak dat u later wilt afwerken. Beter nog, breng maskering aan op alle niet-gelijmde oppervlakken voordat u gaat lijmen om ervoor te zorgen dat het alleen gaat waar u het bedoeld heeft.

Gebruik epoxy met een minimale gebruiksduur van 60 minuten…je hebt alles nodig.

Lijm eerst de printplaat op zijn plaats, zorg ervoor dat overtollige lijm niet in het lijmoppervlak van de toets terechtkomt. Dit biedt een methode om de toets uit te lijnen met de hals. De PCB heeft een gladde soldeermaskerafwerking, dus ik heb hem opgeruwd met een beetje schuurpapier om de epoxy een iets verbeterde oppervlakteafwerking te geven.

Lijn de toets uit en lijm deze op de hals. Zorg ervoor dat u geen zakken achterlaat die later resoneren (zoem!). Pas ook op dat er geen lijm op de LED-oppervlakken komt.

Zodra de lijm droog is, wil je misschien nog een keer de bedrading en de elektronica testen. Eén slechte LED zal ervoor zorgen dat je het leven gaat haten. Ik had één slechte LED (de eerste!) op het prototype en ik moest wat creatief houtwerk doen om toegang te krijgen tot de defecte LED en deze netjes te patchen.

Stap 13: Breng de fretboardranden waterpas tot aan de hals en voeg fretdraden toe

Zodra de lijm droog is, kun je beginnen met het afwerken van de randen. Het overtollige toetsmateriaal heb ik voorzichtig weggesneden (met een frees) en de laatste millimeter met de hand afgeschuurd.

Het toevoegen van de fretdraden kan eenvoudig met een hamer (met een plastic gezicht om beschadiging te voorkomen). Gewoon niet te hard hameren. Als je de fretdraad hebt afgestemd op de sleuven, zouden ze zonder veel moeite naar binnen moeten gaan.

Waar u op moet letten, is het dunne oppervlak van de LED-zak breken. Op het prototype liet ik de enkele LED-pockets (in de buurt van de 12e fret, waar de ruimte krap wordt) uitstrekken in de fretsleuf. Dat is een slecht idee, want dat creëert een zwakke plek die kan (en deed) barsten zodra de fretdraad is ingebracht.

Stap 14: Masking toepassen en afwerking toepassen op de ukelele

Maskeer de toets (het wordt niet af) en het lijmgebied van de brug en begin met het aanbrengen van de afwerking.

Lees bij het maskeren van het bruggebied de instructies bij uw kit en controleer vervolgens voor de zekerheid de schaallengte. De kit die ik voor het prototype heb gebruikt, gebruikte de verkeerde schaallengte en gaf daarom de verkeerde afmetingen voor het lokaliseren van de brug (maar er zat wel een notitie bij om de website te controleren voor de nieuwste instructies!). Mijn gevoel vertelde me dat het verkeerd was, maar ik accepteerde blindelings autoriteit.

Het is altijd beter om te begrijpen WAAROM je iets doet, in plaats van blindelings de instructies te volgen.

Voor de afwerking zijn er veel tutorials van Luthiers die weten wat ze doen op het web, dus ik raad aan om ze te raadplegen voordat je aan het afwerkingsproces begint.

Dat heb ik natuurlijk niet gedaan, dus heb ik uiteindelijk de verkeerde sealer gebruikt, wat resulteerde in een erg korrelig oppervlak. Doe dat niet.

Doe je huiswerk.

Stap 15: De brug uitlijnen en bevestigen

Deze stap is vrij eenvoudig, maar nogmaals, plan uw klemmethode en probeer deze van tevoren uit voordat u gaat lijmen. Ik gebruikte een standaard houtlijm om de brug te bevestigen.

Stap 16: Elektronica installeren en testen

Dit is het moment om je bedrading mooi te maken. Bovendien wil je niet dat het in het lichaam rondslingert en zoemende geluiden maakt of erger nog, breekt op het podium.

De Arduino-code kan worden bijgewerkt via de USB-poort, dus het is echt niet nodig om hem uit elkaar te halen, tenzij je wilt sleutelen.

Stap 17: Installeer tuners en besnaar het instrument

Je zult waarschijnlijk ook de frets waterpas moeten stellen en een beetje met de setup moeten spelen, maar waarom zou je je nu zorgen maken, als je zo dicht bij het einde bent?

Ik heb de tuners geüpgraded en mooie Aquila-snaren gebruikt, wat het geluid helemaal niet hielp. Dus houd daar rekening mee terwijl je geld in een project-ukelele steekt …

Stap 18: Programmeren van de Uke

De laatste Arduino-code staat op Github. Er zijn enkele regels in de code om toekomstige verbeteringen te ondersteunen (zoals een metronoomfunctie en "schuifregelaars" voor het scherm (een UI-element dat eruitziet als een schuifregelaar)

Deze code gebruikt een Rotary Encoder Library (Rotary Encoder Arduino Library) om gebruikersinvoer van de Rotary Encoder te verwerken.

Het gebruikt ook de Adafruit Neopixel-bibliotheek en voorbeeldcode die hier te vinden is. De theater- en regenboogmodi zijn afgeleid van voorbeelden die bij de bibliotheek worden geleverd. (zie strandtest.ino).

Het beeldschermstuurprogramma wordt geleverd door 4D-systemen en is hier te vinden op Github.

Er zijn twee unieke functies geïmplementeerd voor het Ukulele-project. De eerste implementeert de akkoordenbibliotheek en de tweede geeft een scrollend tekstbericht weer met een aangepaste tekenset.

Het bijgevoegde diagram toont de locaties van de fretboard-LED's en hoe ze zijn aangesloten. LED 0 bevindt zich in de rechterbovenhoek.

Stap 19: Hoe een akkoord weer te geven

De displayChord-functie toont de vingerposities (voor nu alleen de eerste positie) voor elk akkoord. Door de gebruiker geselecteerde akkoorden (grondtoon en kwaliteit) worden opgeslagen als een paar indices. Deze worden op hun beurt gebruikt om de vingerzettingen voor elk akkoord op te zoeken.

Ik gebruikte de "GCEA"-notatie om akkoorden op te slaan (bijvoorbeeld "A" is "2100"). De akkoorden worden vooraf berekend voor elke grondtoon en opgeslagen in een variabele die overeenkomt met de kwaliteit van het akkoord. (dus A majeur wordt opgeslagen op de eerste locatie van de array "majeurakkoorden", overeenkomend met "2100").

char* majorChords = {"2100\n", "3211\n", "4322\n", "0003\n", "1114\n", "2220\n", "3331\n", " 4442\n", "2010\n", "3121\n", "0232\n", "5343\n"};

Merk op dat aangezien dit een tekststring is, elk cijfer ook een hexadecimale waarde kan vertegenwoordigen om rekening te houden met fretposities groter dan 9. Dat wil zeggen, A en B zouden LED's 10 en 11 vertegenwoordigen. Voor akkoorden van de eerste positie was dit geen probleem).

De LED-snaar is in de lengte bedraad in rijen van 12 (een octaaf) langs elke snaar (beginnend met de A-snaar), de daaropvolgende reeks van 12 begint bij de eerste fret van de volgende snaar (zie het diagram in stap 18). Dit is belangrijk voor het algoritme om te bepalen welke lichten moeten worden ingeschakeld voor een bepaald akkoord. Dat betekent dat pixels 0 t/m 11 de A-string-LED's zijn, 12 t/m 23 de E-string-LED's, enzovoort. Bij het ontleden van een A = "2100" (opgeslagen als een string, er is ook een null-terminator "\n" in de code), interpreteren we dit als: er zijn geen pixels op de A-string verlicht, noch op de E-string, pixel 0 (fret 1) op de C-snaar brandt en pixel 1 (fret 2) op de G-snaar. Merk op dat een "0" uit is, niet de eerste LED. Op basis van de bedrading willen we leds 24 en 37 laten oplichten. Hieronder staat de code om een akkoord weer te geven.

for (int i = 0; i <4; i++) {if (int(chord - '0')) { // algoritme om de akkoordreeks te ontleden int ledNumber = int(chord - '0') + (3 - ik) * 12 - 1; // zie bovenstaande discussie, de (3-i) is om de index strip.setPixelColor (ledNumber, 0, 125, 125) om te keren; // setPixelColor (ledNumber, rode waarde, groene waarde, blauwe waarde) } }

Het if-statement controleert of de led uit is. Als dat niet het geval is, neemt het de ascii-waarde van het teken, akkoord, en trekt het de ascii-waarde voor '0' af om het ledNumber te laten oplichten.

strip is een instantie van de klasse Adafruit_NeoPixel. De functie setPixelColor stelt de kleur in voor de berekende pixel (in dit geval vast op (0, 125, 125).

Stap 20: Een scrollend bericht weergeven

Dus we hebben een reeks van 12 x 4 LED's … waarom zou u niet iets anders laten weergeven dan vrij willekeurige lichtpatronen!

Het eerste probleem is dat de weergavehoogte (4) nogal beperkt is vanwege het aantal snaren op een Uke. Horizontaal scrollen zou meestal onleesbaar zijn, maar in een verticale richting kunnen we 4 x 5 tekens ondersteunen die verticaal lopen.

Door tekens te organiseren als vijf "verticale" rijen, kunnen twee tekens tegelijkertijd worden weergegeven, waardoor er een regelafstand tussen elk teken is.

De moeilijkheid was dat er geen standaard 4 x 5 karakterset was. Ik maakte mijn eigen met behulp van de bijgevoegde spreadsheet. Ik heb elke rij toegewezen aan een enkele hexadecimale waarde (4 bits die aangeven welke pixel aan of uit is). De combinatie van de vijf hexadecimale waarden vormt een teken (bijv. "0" is 0x69996).

De waarden voor elk teken worden opgeslagen in een array in ASCII-volgorde. De tekenset sluit wat compromissen met bepaalde letters, maar de meerderheid is redelijk duidelijk. (het gekrabbel onderaan de spreadsheet zijn ideeën waarmee ik aan het spelen was, omdat we kleur als optie hebben, we kunnen "diepte" aan het personage toevoegen en mogelijk wat extra resolutie krijgen.

De tekenreeks die moet worden weergegeven, bevindt zich in de tekenreeksvariabele, message.

Er wordt een buffer gemaakt om de tekenweergave weer te geven. Ik denk dat ik gewoon een grote buffer had kunnen maken met de hele vertaalde berichtenreeks, vooral omdat de meeste berichten minder dan 20 tekens zullen bevatten. Ik heb er echter voor gekozen om een vaste buffer van drie tekens (18 bytes) te maken. Slechts twee van de tekens worden actief weergegeven en de derde is een vooruitblik, waar het volgende teken wordt geladen. De LED-string (zie het als een groot schuifregister) wordt geladen met de 48 bits voor de string. Ik verspilde wat geheugenruimte om dit gemakkelijker te conceptualiseren. Elke nibble krijgt zijn eigen geheugenlocatie, een verdubbeling van de geheugenvereiste, maar het is niet veel gezien de buffergrootte.

De buffer wordt geladen met het volgende teken wanneer de uitvoerindex (pointer) een tekengrens bereikt (outputPointer op 5, 11 of 17).

Om de buffer te laden, pakken we het eerste teken in "bericht" als een ASCII-waarde en trekken we 48 af om de index in de asciiFont-array te krijgen. De waarde bij die index wordt opgeslagen in codedChar.

Het eerste deel van het bericht dat naar buiten is verschoven, komt overeen met de leds 47, 35, 23 en 11 (onderaan het display). Dus voor het getal nul 0x0F999F wordt de F (linker) eerst verschoven, 9 seconden enzovoort.

Het volgende teken wordt geladen door elke nibble te maskeren en naar rechts te schuiven. Voor het bovenstaande voorbeeld geeft het algoritme (0x0F999F & 0xF00000) >> 20, dan (0x0F999F & 0x0F0000) >> 16, enz.

int-index; if (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) { char displayChar = message.charAt(messagePointer); // pak het eerste teken van het bericht long codedChar = asciiFont [displayChar - 48]; if (displayChar == 32) codedChar = 0x000000; messageBuffer[bytePointer+5]=byte((codedChar & 0xF00000) >> 20); // maskeer alles behalve de laatste knabbel en verschuif deze met 20 (enzovoort) messageBuffer [bytePointer+4]=byte ((codedChar & 0x0F0000) >> 16); //dit zou één nibble per geheugenlocatie moeten plaatsen messageBuffer[bytePointer+3]=byte((codedChar & 0x00F000) >> 12); // alle zes vertegenwoordigen op karakter messageBuffer [bytePointer+2]=byte ((codedChar & 0x000F00) >> 8); messageBuffer[bytePointer+1]=byte((codedChar & 0x0000F0) >> 4); messageBuffer[bytePointer] =byte((codedChar & 0x00000F)); if (bytePointer ==0) {// behandel de lus rond de bytePointer bytePointer = 12; } else { bytePointer -= 6; // we vullen van onder naar boven; OPMERKING: je moet kijken of je dit kunt omkeren om te zien of dit het gemakkelijker maakt } if (messagePointer == message.length()-1) { //handle de lus rond op het bericht messagePointer = 0; } else { messagePointer +=1; // ga naar het volgende teken } }

Zodra de buffer is geladen, wordt het een kwestie van volgen waar de uitvoeraanwijzer zich bevindt en het laden van de LED-string met de juiste 48 bits (de huidige 4 en de vorige 44). Zoals eerder vermeld, is strip een instantie van de NeoPixel-klasse en stelt setPixelColor de kleur (RGB) van elke pixel in. De functie show() verschuift de weergavewaarden naar LED-string.

// lus om de buffer voortdurend te verschuiven

// wil de hele strook wegschrijven bij elke passage door de lus, alleen de startlocatie verandert voor (int rij = 12; rij > 0; rij--) { index = outputPointer + (12-rij); if (index > 17) index = outputPointer+(12-rij)-18; // lus indien groter dan 17 voor (int column = 4; column > 0; column--) { strip.setPixelColor (uint16_t (12 * (column-1) + (row-1)), uint8_t (RedLED * (bitRead (messageBuffer[index], kolom-1))), uint8_t(GreenLED*(bitRead(messageBuffer[index], column-1))), uint8_t(BlueLED*(bitRead(messageBuffer[index], column-1)))); //op elke locatie licht de LED op als de bit een is } } //outputPointer wijst naar de huidige laagste byte in de displaystring als (outputPointer == 0) outputPointer=17; anders outputPointer -= 1; strip.show(); }

Stap 21: Verbaas de wereld met je ukelele-geweldigheid

Het uiteindelijke Ukulele-prototype had ongeveer 6 maanden nodig om te starten en te stoppen.

Veel nieuwe technologie om te leren en misschien wat houtbewerking en muziektheorie om op te starten!

Wat te doen voor de volgende versie?

1. Weg met het display en de roterende encoder. Vervang ze door een Bluetooth-module die op de Arduino is aangesloten. Bedien hem op afstand met een telefoon of tablet. Alles is beter met Bluetooth.
2. Werk akkoordpatronen op afstand in realtime bij. Iets dat het beste over is voor de app.
3. LED-afdekkingen. De huidige versie doet niets om te voorkomen dat er smurrie in de LED-gaatjes komt. Een vriend heeft een aantal kleine lenzen gemaakt, maar ik kon er nooit achter komen hoe ik ze goed op hun plaats kon krijgen.
4. Alternatieve toetsmaterialen, misschien iets duidelijk zolang de frets het houden.
5. Meer lampen! Elimineer de beperking op tekst door meer "rijen" toe te voegen. Dit is echt een beperking die wordt veroorzaakt door de grootte van de toets en de LED-behuizingen.

Nogmaals, zie de begeleidende Instructable die de tekenset beschrijft die ik moest maken om scrollende tekst mogelijk te maken.

Heel erg bedankt dat je zo ver bent gekomen! Mahalo!