Hur man bygger en upplyst ukulele !: 21 steg

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

Jag spelar Ukulele. Lite medelmåttigt (om det är ett ord) så jag tänkte, "om du verkligen vill imponera på damerna behöver du ett medel för att distrahera dem från katastrofen som spelar på scenen." Därför föddes "Light-up Ukulele".

Detta projekt tar ett Concert Ukulele -kit och lägger till en Arduino -kontrollerad LED i varje sträng och bandposition. Det lägger också till en snygg OLED -skärm och roterande kodare baserat användargränssnitt för att välja läge och intensitet för LED -strängen.

De färdiga Uke -maskinvarufunktionerna:

1. Arduino MICRO för gränssnitt till LED -strängen, displayen och inmatningsenheten.
2. 48 individuellt programmerbara fullfärgs -lysdioder
3. En OLED -skärm
4. En roterande kodare för användarinmatning
5. USB -gränssnitt för extern ström och Arduino -programmering

Uke -programvaran har:

1. Grundläggande ljusstyrningslägen som kör lysdioderna genom sina steg
2. Ett snyggt teatermarkeringsläge (mycket praktiskt för föreställningar!)
3. LED -intensitetskontroll
4. Ett fullständigt ackordbibliotek med alla första positionens Ukulele -ackord (ackordvärde och karaktär)
5. Möjlighet att visa löpande text (vertikalt) med en unik 4 x 6 pixlar teckenuppsättning

Denna instruerbara beskriver den färdiga prototypen. Hela utvecklingssagan finns HÄR, inklusive några pedagogiska (smärtsamma) misstag och en värdefull lektion i varför du MÅSTE avsluta din första design till slut (oavsett hur fula saker blir). Du vet aldrig alla saker du verkligen inte vet förrän du kommer till slutet (och då vet du fortfarande inte!), Men du är mycket bättre och mycket smartare för nästa design.

Jag byggde prototypen kring ett Grizzly Concert Ukulele -kit. Att börja med ett kit lindrar oro för veckans kropp (ja, mestadels) och eliminerar det mesta av det verkliga luthier-arbetet. Dessa kit är ganska kompletta och inte så dyra i den stora ordningen (och mindre smärtsamma eftersom du kommer att göra misstag).

Steg 1: Gör en plan

Greppbrädan (eller greppbrädan) som ingår i vissa kit har bandet redan fäst. Det är bra/dåligt. Det är trevligt som tidsbesparande, men när det gäller att lägga ut ett borrmönster och hålla det på plats under fräsning är det lite ont. Efter att ha förstört den som ingår i satsen valde jag (ja, jag hade inget annat val än att köpa ett annat kit) för att köpa en ny greppbräda.

Vid utformningen av greppbrädan måste vi beräkna ökningen av tjockleken som krävs för att bädda in kretskortet och lysdioderna (och glöm inte de passiva komponenterna), men inte så mycket att lysdioderna är för långt från greppbrädans yta.

LED -kretskortet (PCB) är utformat som ett enkelt tvålagerskort. Detta hjälper mycket med handmonteringen av LED -strängen och ger lite mekanisk styrka (det är glasfiber och epoxi) till Ukulele -halsen. Jag startade layouten i Eagle, men slutade använda Altium Designer på grund av begränsningar i brädans storlek. Altium -schematiska och PCB -filerna finns här.

Kit -greppbrädan var bara 0,125 tum tjock. Så om vi antar ett 0,062 tum tjockt kretskort och tillåter ytterligare 0,062 tum för lysdioderna, betyder det att vi måste klippa ut mycket (som i alla) greppbrädan. För att kompensera kan vi antingen delvis skära fickor för lysdioderna i greppbrädan med en motsvarande ficka i nacken för kretskortet, eller så kan vi byta ut hela greppbrädan (alternativet jag gick med) mot en tjockare version från Luther Mercantile International (LMII), som är 0,25 tum att starta.

MEN, kom ihåg att du fortfarande måste bearbeta nacken för att kompensera för ökningen av tjockleken i greppbrädan. Den andra fördelen du får är kosmetisk, eftersom kretskortet nu är helt inbäddat i greppbrädan vilket gör kanterna mycket lättare att avsluta (och ser mycket snyggare ut!) Och förenklar fräsning av halsen.

Ingenjörsgrejer (ignorera om du vill):

Förresten, det äventyrar inte riktigt halsens stelhet så mycket. PCB -materialet är mycket styvare än det ursprungliga greppbrädet (Mahogany -modul: 10,6 GPa kontra FR4 -modul: 24 GPa), plus eftersom vi bygger en Ukulele finns det inte en enorm mängd strängspänningar som annars skulle kunna snedvrida (vridning eller varp) nacken.

En mycket intressant övervägande (som jag nog borde beräkna) är vad som händer över temperatur. Generellt för trä, parallellt med säden, är den termiska expansionskoefficienten ungefär 3 x 10^-6/K, och för FR4 är det 14 × 10^−6/K. Så det är en ganska stor skillnad. Oron är att spänningar skapas i nacken när temperaturen varierar, vilket i sin tur avstämmer strängarna. Det är något som kan kompenseras genom att applicera ett liknande lager på den motsatta sidan av neutralaxeln eller genom att få FR4 så nära neutralaxeln som möjligt. Men det får stå kvar på 2.0 … Något att modellera och utvärdera.

Elektroniken finns i veckans kropp. Hål skärs i sidoväggen (inte ljudpanelen!) På UKE för att ge plats för displayen och roterande kodare, plus en åtkomstplatta för att hålla Arduino Micro och ge tillgång till USB -gränssnittet. Kopplingsplattans/monteringsdesign och plats kan troligen förbättras för att få USB -anslutningen att komma ut på en mer bekväm plats, men som det ser ut är det inte så illa, eftersom det inte är i vägen när du spelar.

Beskrivningen av stegen är följande:

1. Samla material
2. Få de verktyg du behöver
3. Fräsa halsen för att rymma den tjockare greppbrädan
4. Fräsa greppbrädan för att göra hål på önskade platser och för att skapa fickor för brädan och lysdioder
5. Skaffa och konstruera kretskortet som håller lysdioderna
6. Fräs åtkomsthål i Ukulele -kroppen för OLED -skärmen, vridkodaren och åtkomstpanelen
7. Gör täckplattor
8. Fäst ledningar till kretskortet; anslut och testa elektroniken
9. Fäst halsen på Ukulele -kroppen
10. Borra ett åtkomstgrepp för att föra in kretskortsledningarna i kroppen
11. Rikta in och limma kretskortet och greppbrädan mot halsen
12. Jämna greppbrädans kanter mot nacken (ta bort överflödigt material)
13. Installera bandtrådarna
14. Applicera maskering och applicera finish på Ukulele
15. Rikta in och fäst bron
16. Installera elektronik och testa.
17. Installera tuners och sträng instrumentet
18. Programmera Uke -styrenheten
19. Förbluffa världen med din Ukulele -underbarhet!

Steg 2: Samla material

Vår materiallista ser ut så här:

1. Ukulele kit - Jag använde ett Grizzly Concert Ukulele kit (Grizzly Uke Kit på Amazon), men det ser ut att avbrytas. Zimo gör en liknande modell (Zimo Uke Kit @ Amazon) som ser ut att göra jobbet
2. Ukulele greppbräda, förspårad (LMII Uke greppbräda). De kommer att placera greppbrädan i din skala, vilket sparar en massa problem
3. Epoxi - för limning av greppbrädan i nacken. Jag valde epoxi eftersom det är kompatibelt med PCB -materialet. Leta efter något med minst 60 minuters arbetsliv. ANVÄND INTE 5 minuters typer, du behöver tid att göra justeringar
4. Bandtrådar - även tillgängliga från LMII
5. Anpassad PCB - Altium -filer finns här. Jag valde normalt material av FR4 -typ. Flex (polyimid) brädor skulle vara ett intressant (om mer dyrt) alternativ, eftersom de kan vara mycket tunnare
6. 48x Neopixel (SK6812) lysdioder. Finns från Adafruit och Digikey
7. 48x 0.1uF 0402 lock - större är acceptabelt, men du måste titta på placering
8. Anslutningstråd - minst 4 till 6 färger för att undvika förvirring, jag använde främst 28 gauge tråd. Se likströmssänkningen på LED -strömanslutningarna (både VCC och JORD … att strömmen måste återgå till källan!)
9. Roterande pulsgivare-PEC16-4220F-S0024
10. Fancy träknopp - för roterande pulsgivare (jag fick min från LMII)
11. OLED -skärm - från 4D -system OLED -skärmar
12. Externt USB -batteri - billigare hela tiden, plus att du kan bära reservdelar!
13. Arduino MIKRO
14. Blad mässing - för att göra plattan för att hålla arduino och ram för displayen
15. Diverse förbrukningsmaterial inklusive: sandpapper, uretanfinish, popsicle -pinnar, gummiband, löd, fluss, borstar, dubbelsidig tejp (jag gillar UHC -tejpen med 3M) och små träskruvar i mässing (för plattan)
16. Valfria Ukulele -förbättringar - bättre tuners, bättre strängar, bättre mutter och sadel, inlägg om du vill visa upp din lutigare förmåga)

Steg 3: Få de verktyg du behöver

Förr eller senare kommer du att behöva skaffa eller få tillgång till dessa:

Vår verktygslista innehåller:

1. Fräsmaskin - CNC föredras, men du kan till och med klara dig med en router och mycket tur. Jag använde en kombinerad CNC -kvarn/router
2. Routerbitar - hårdmetall föredras. Fräsbitar valda över ändfräsar eftersom vi bearbetar trä, inte metall
3. Klämmor - massor av dem. Behövs mest för att hålla delar under limningen
4. Lödkolv - liten spets för ytmonterad lödning
5. Mikroskop eller förstoringsglas - du kan försöka lödas med bara dina ögon, men jag skulle inte rekommendera det, minst 10x
6. Pincett (för att sätta på plats delar)
7. Frettingverktyg (se lämpliga verktyg på LMII här, men jag använde det jag hade hemma och nöjde mig; hammare, filer och skärare)
8. Diverse handverktyg som trämejslar, skruvmejslar, mjukt slag eller råhammare (för frätning) etc.
9. Slipmedel - olika sandpapper

Våra mjukvaruverktyg inkluderar (vissa är valfria beroende på din budget/uppfinningsrikedom):

1. Arduino programvara
2. Ukulele -källkoden (https://github.com/conrad26/Ukulele)
3. PCB -layoutpaket - Jag använde Altium eftersom den fria versionen av Eagle inte stödde den brädstorlek jag ville ha. Altium är ett komplett layoutpaket och egentligen inte i en pristid för hobbyister. Jag har inkluderat Gerber -filerna på min webbplats för prototypen, men dessa behöver definitivt en uppdatering
4. 3D -modelleringsprogram - jag använde SolidWorks, men ett gratis alternativ är FreeCAD (https://www.freecadweb.org/)
5. CAM -programvara - som FeatureCAM från Autodesk för att skapa NC -kvarnfilen.

Kombinationen av 3D -stegfilexport från Altium tillsammans med en 3D -modell av greppbrädan eliminerar mycket av svårigheten att se till att allt stämmer, men det är inte ett krav. Noggrann layout kommer att uppnå samma resultat.

Nu när vi vet vad vi vill göra och vad vi behöver göra det, låt oss bygga en Ukulele.

Steg 4: Fräs nacken för att passa den tjockare greppbrädan

Innan fräsning, observera att den ursprungliga greppbrädans monteringsytans planhet MÅSTE bibehållas, annars kommer du att ha en vriden greppbräda, vilket leder till alla slags problem med bandutjämning.

Bara gå inte dit, ta dig tid och kläm försiktigt och hårt nacken och kontrollera inriktningen mot fräsbiten över hela halsen innan du skär. Tiden som spenderas här kommer att spara mycket sorg senare.

En anledning till att jag valde en tjockare greppbräda över ett inlägg i nacken var den ökade monteringsytan (limningen). En annan anledning är att det förenklar fräsning av nacken. Du surrar helt enkelt hela ytan till önskad höjd.

Steg 5: Skaffa och konstruera kretskortet som håller lamporna

Jag lödde hela enheten för hand. LED -förpackningarna är särskilt lätta att smälta, så var försiktig så att du inte skadar dem. Jag föreslår att du bär en statisk rem, eftersom strängen är beroende av varje LED som fungerar.

Greppbrädans design är baserad på lysdioderna WS2812B. Jag bestämde mig för att bara göra greppbrädans första oktav (48 lysdioder !!). Varje lysdiod kan ses som en bit i ett skiftregister. Skiftregistret klockas till 800 kHz. Jag använde Adafruit -biblioteket (se programmeringsavsnittet) för att få igång saker snabbt.

Jag började designen i Eagle, men brädans storlek är begränsad till ungefär 4 x 5 tum, så jag var tvungen att (eller mer korrekt, jag valde att) byta till Altium. Jag använder Altium på jobbet, så i verkligheten gjorde det saker snabbare för mig. Altium -projektet, schematiska och PCB -filer (och biblioteksdelar) finns på min webbplats. Brädet är trapetsformat och cirka 10 tum långt. Jag tror att jag borde ha försökt komprimera konturen lite mer (nästa snurr!) Montering var inte dålig, men om du har råd, rekommenderar jag verkligen ett anständigt lödkolv (JBC Lödkolv) och ett bra mikroskop. Ja, jag är bortskämd och nej, jag har inte sånt i mitt hemlabb. Jag är billig.

Jag lät göra brädorna på Sunstone. $ 129 för två brädor. Garanterat en veckas tur. Snåla inte på frakten dock. Jag märkte inte att jag använde UPS -mark och jag väntade en vecka extra på att mina brädor skulle komma. Total monteringstid var cirka 2 timmar (98 delar).

Steg 6: Fräs greppbrädan

Vi måste fräsa greppbrädan för att göra hål på de nödvändiga platserna och för att skapa fickor för brädan och lysdioder.

Jag skapade en 3D -modell av den färdiga greppbrädan i Solidworks och skapade CNC -fräserutinen med FeatureCAM.

Den nedre delen av greppbrädan (närmast ljudhålet) måste göras tunnare för att ta hänsyn till stegförändringen i höjd mellan nacke och kropp. Definitivt värt att testa att passa flera gånger för att vara säker på att det är en lagom passform.

I efterhand borde jag ha klippt bort de oanvända delarna av greppbrädan för att få den att passa bruket bättre (min billiga kvarn hade bara en 12 X-axel). Ordningsföljden bör ställas in till de första kvarntjocklekens justeringar innan fräsfickor, vilket borde leda till mindre utbrott mellan fickorna.

Gör manuella justeringar efter behov för att lägga till utrymme för ledningar. En viktig sak att notera är att i några av fickorna slog jag igenom i spåret där bandtråden kommer att gå. Med tanke på att det är en ledare, se till att det inte slutar med att korta något viktigt. Det minskar också styrkan hos materialet som håller bandet på plats. Designen bör modifieras för att aldrig korsa en fretplats.

Steg 7: Fräsåtkomsthål i Ukulele -kroppen

Jag fräst manuellt åtkomsthålen i kroppen. Det svåraste är att hitta den "plattaste" regionen av vad som är en mycket krökt yta. Markera konturen med blyertspenna och fräs gradvis bort material tills du får en passform för OLED -skärmen. Jag fick en bearbetad mässingsram och fäst den med 3M VHB -tejp.

Eftersom ingen av dem kräver stor precision är det mycket lättare att skapa roterande givare och åtkomstpanelhål.

Steg 8: Gör täckplattor

Du måste också fabulera täckplattorna för bildskärmsramen och åtkomstpanelen. Åtkomstpanelen behöver ett hål (rektangulärt) för USB -kontakten (mikro). Använd bara den befintliga kontakten på Arduino, eftersom det inte finns många panelmonteringsalternativ för mikro -USB. (även om jag designade från grunden, skulle jag titta på en av dessa)

För att hålla brädet på plats, dra ut L -fästen av mässing och löd dem på baksidan av åtkomstplattan. Detta tillåter dig en viss breddgrad i positionering. För att få positioneringen rätt, skapa först ett monteringsbräda (med monteringshål) för Arduino MICRO och fäst L-fästena med 2-56 maskinskruvar. Du kan sedan justera platsen för att ställa in usb -porten och exakt markera platserna för parenteserna på plattan. Ta bort fästena från perfboard och löd dem på plats. Montera slutligen perfboard -enheten.

Jag använde fyra små träskruvar i mässing för att hålla mässingspanelen på plats.

Vid denna tidpunkt rekommenderar jag en testpassning innan slutmonteringen börjar. Detta steg är valfritt men rekommenderas. Det är mycket lättare att göra justeringar innan limning.

Steg 9: Fäst ledningar på kretskortet; Anslut och testa elektroniken

Anslut inte elektroniken permanent. Fäst ledningar till kretskortet, se till att du lämnar tillräckligt med slakhet för att leda ut åtkomsthålet. Dessa måste så småningom permanent fästas på Arduino MICRO -kortet (bilderna visar en Arduino UNO, som jag använde för kodutveckling)

Steg 10: Fäst halsen på Ukulele -kroppen

Fäst halsen på Ukulele -kroppen enligt instruktionerna som medföljer Ukulele -satsen. Titta särskilt på att greppbrädans yta är anpassad till veckans kropp.

Steg 11: Borra ett åtkomsthål för att föra in kretskortets ledningar i kroppen

När limmet är torrt, borra ett ~ 1/4 tum (10 mm) hål i en vinkel så att ledningarna från kretskortet kan leda in i Ukulele -kroppen. Var noga med att inte skada ljudkortet.

Du kan också behöva skapa en liten ficka för att tillåta tjockleken på trådarna under brädet (eller lägg eventuellt anslutningarna på toppen och inkludera avlastning i greppbrädan.)

En annan testpassning skulle inte skada vid det här laget.

Steg 12: Justera och limma kretskortet och greppbrädan mot halsen

Jag föreslår att du tänker igenom klämningen (och provar!) Innan du limar. Du kanske vill skapa ett block format på undersidan av nacken för att ge dig en plan klämyta. Greppbrädan är större än nacken vid denna tidpunkt, så du måste tillåta det.

Var mycket försiktig så att du inte får epoxi på någon yta som du vill avsluta senare. Ännu bättre applicera maskering på alla icke-limmade ytor innan du limar för att se till att den bara går dit du tänkt dig.

Använd epoxi med minst 60 minuters arbetsliv … du behöver allt.

Limma kretskortet på plats först och se till att överflödigt lim inte extruderas in i limytan på greppbrädan. Detta ger en metod för att anpassa greppbrädan till nacken. Kretskortet har en slät lödmaskfinish, så jag grovade upp det med lite sandpapper för att ge epoxin en något förbättrad ytfinish.

Rikta in och limma greppbrädan mot halsen. Var noga med att inte lämna några fickor som senare kan bli resonanta (surr!). Var också försiktig så att du inte får lim på LED -ytorna.

När limmet är torrt kanske du vill tråda och testa elektroniken en gång till. En dålig lysdiod får dig att hata livet. Jag hade en dålig lysdiod (den första!) På prototypen och jag var tvungen att göra lite kreativt träarbete för att komma åt den defekta lysdioden och lappa den rent.

Steg 13: Nivå greppbrädans kanter till halsen och lägg till bandtrådar

När limmet är torrt kan du börja avsluta kanterna. Jag skar försiktigt bort det överflödiga greppbrädmaterialet (med en kvarn) och avslutade den sista millimetern för handslipning.

Lägga till bandtrådarna kan enkelt göras med en hammare (med ett plastsida för att undvika att skada). Bara inte slå för hårt. Om du har matchat bandkabeln till spåren bör de gå in utan större svårigheter.

Det du behöver titta på är att bryta den tunna ytan på LED -fickan. På prototypen tillät jag några LED -fickor (nära 12: e bandet, där utrymmet blir trångt) att sträcka sig in i bandplatsen. Det är en dålig idé, eftersom det skapar en svag plats som kan (och gjorde) spricka när bandtråden sätts in.

Steg 14: Applicera maskering och applicera Finish på Ukulele

Maskera greppbrädan (den får inte finish) och brygglimningsområdet och börja applicera finish.

När du maskerar broområdet läser du instruktionerna med ditt kit och kontrollerar sedan skallängden för att vara säker. Satsen jag använde för prototypen använde fel skallängd och gav därför fel dimensioner för att hitta bron (men den hade en anteckning för att kolla webbplatsen för de senaste instruktionerna!). Min tarm sa till mig att det var fel, men jag accepterade blindt auktoritet.

Det är alltid bättre att förstå VARFÖR du gör något, snarare än att blindt följa instruktionerna.

För avslutningen finns det massor av självstudier från Luthiers som vet vad de gör på webben, så jag rekommenderar att konsultera dem innan du går in i efterbehandlingsprocessen.

Jag gjorde naturligtvis inte det, så jag slutade använda fel tätningsmedel, vilket resulterade i en mycket kornig yta. Gör inte det.

Gör dina läxor.

Steg 15: Justera och fäst bron

Detta steg är ganska enkelt, men återigen, planera din fastspänningsmetod och prova det i förväg innan du limar. Jag använde ett vanligt trälim för att fästa bron.

Steg 16: Installera elektronik och testa

Nu är det dags att göra din ledning snygg. Plus att du inte vill att den ska floppa inuti kroppen och göra surrande ljud eller ännu värre men bryta på scenen.

Arduino -koden kan uppdateras via USB -porten, så det är verkligen inte nödvändigt att ta isär den om du inte vill pyssla.

Steg 17: Installera tuners och stränga instrumentet

Du kommer sannolikt också att behöva jämna ut banden och leka med installationen lite, men varför oroa dig nu när du är så nära slutet?

Jag uppgraderade tunern och använde fina Aquila -strängar, vilket inte hjälpte ljudet alls. Så ha det i åtanke medan du skjuter ut pengar till ett projekt ukulele …

Steg 18: Programmering av Uke

Den sista Arduino -koden finns på Github. Det finns några rader i koden för att stödja framtida förbättringar (som en metronomfunktion och "reglage" för displayen (ett UI -element som ser ut som ett reglage)

Denna kod använder ett Rotary Encoder Library (Rotary Encoder Arduino Library) för att hantera användarinmatning från Rotary Encoder.

Den använder också Adafruit Neopixel -biblioteket och exempelkoden som finns här. Teater- och regnbågslägen härstammar från exempel som medföljer biblioteket. (se strandtest.ino).

Displaydrivrutinen tillhandahålls av 4D -system och finns på Github här.

Det finns två unika funktioner implementerade för Ukulele -projektet. Det första implementerar ackordbiblioteket och det andra visar ett rullande textmeddelande med hjälp av en anpassad teckenuppsättning.

Det bifogade diagrammet visar greppbrädans LED -platser och hur de är anslutna. LED 0 finns i det övre högra hörnet.

Steg 19: Hur man visar ett ackord

DisplayChord -funktionen visar fingerpositionerna (endast första position för tillfället) för varje ackord. Ackord som valts av användaren (rotnot och kvalitet) lagras som ett par index. Dessa används i sin tur för att slå upp fingrarna för varje ackord.

Jag använde "GCEA" -notation för att lagra ackord (t.ex. "A" är "2100"). Ackorden beräknas för varje rotnot och lagras i en variabel som motsvarar ackordets kvalitet. (så, A -dur, lagras på den första platsen i arrayen "majorChords", motsvarande "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 "};

Observera att eftersom detta är en textsträng kan varje siffra också representera ett hex -värde för att ta hänsyn till bandpositioner som är större än 9. Det vill säga A och B skulle representera lysdioderna 10 och 11. För första positionens ackord var detta inte ett problem).

LED -strängen är trådbunden på längden i rader om 12 (en oktav) längs varje sträng (börjar med A -strängen), den efterföljande körningen av 12 startar vid den första bandet i nästa sträng (se diagrammet i steg 18). Detta är viktigt för algoritmen för att avgöra vilka lampor som ska tändas för ett givet ackord. Det betyder att pixlarna 0 till 11 är A -sträng -lysdioderna, 12 till 23 är E -sträng -lysdioderna och så vidare. När vi analyserar en A = "2100" (lagrad som en sträng, det finns också en null -terminator "\ n" i koden) tolkar vi den som: inga pixlar på A -strängen tänds, inte heller på E -strängen, pixel 0 (fret 1) på C -strängen tänds och pixel 1 (band 2) på G -strängen. Observera att en "0" är släckt, inte den första lysdioden. Baserat på ledningarna vill vi tända lysdioderna 24 och 37. Koden för att visa ett ackord visas nedan.

för (int i = 0; i <4; i ++) {if (int (ackord - '0')) {// algoritm för att analysera ackordsträngen int ledNumber = int (ackord - '0') + (3 - i) * 12 - 1; // se ovan diskussion, (3-i) är att vända index strip.setPixelColor (ledNumber, 0, 125, 125); // setPixelColor (ledNumber, rött värde, grönt värde, blått värde)}}

If -satsen kontrollerar om LED är avstängt. Om det inte är det krävs det ascii -värdet för tecknet, ackord , och subtraherar ascii -värdet för '0' för att få ledNumber att tändas.

strip är en instans av Adafruit_NeoPixel -klassen. SetPixelColor -funktionen anger färgen för den beräknade pixeln (fastställd till (0, 125, 125) i detta fall.

Steg 20: Hur man visar ett rullande meddelande

Så vi har en 12 x 4 matris av lysdioder … varför inte låta den visa något annat än ganska slumpmässiga ljusmönster!

Det första problemet är att displayhöjden (4) är ganska begränsad på grund av antalet strängar på en Uke. Horisontell rullning skulle mestadels vara oläslig, men i en vertikal orientering kan vi stödja 4 x 5 tecken som körs vertikalt.

Att organisera tecken som fem "vertikala" rader innebär att två tecken kan visas samtidigt och tillåta ett radrum mellan varje tecken.

Svårigheten var att det inte fanns någon standard 4 x 5 teckenuppsättning. Jag gjorde mitt eget med det bifogade kalkylbladet. Jag tilldelade varje rad till ett enda hex -värde (4 bitar som representerar vilken pixel som är på eller av). Kombinationen av de fem hexvärdena utgör ett tecken (t.ex. "0" är 0x69996).

Värdena för varje tecken lagras i en array i ASCII -ordning. Teckenuppsättningen gör vissa kompromisser med vissa bokstäver, men majoriteten är någorlunda tydlig. (klottret längst ner i kalkylbladet är idéer jag lekte med eftersom vi har färg som tillval, vi kan lägga till "djup" i karaktären och eventuellt få lite ytterligare upplösning.

Strängen som visas finns i strängvariabeln, meddelande.

En buffert skapas för att representera teckenvisningen. Jag antar att jag helt enkelt kunde ha skapat en stor buffert med hela den översatta meddelandesekvensen, särskilt eftersom de flesta meddelanden kommer att vara mindre än 20 tecken eller så. Men jag valde istället att skapa en fast buffert med tre tecken (18 byte). Endast två av karaktärerna visas aktivt, och den tredje är en blick framåt, där nästa tecken laddas. LED -strängen (se det som ett stort skiftregister) laddas med 48 bitar för strängen. Jag slösade bort lite minnesutrymme för att göra det lättare att konceptualisera. Varje nibble får sin egen minnesplats, vilket fördubblar minneskravet, men det är inte mycket med tanke på buffertstorleken.

Bufferten laddas med nästa tecken när utmatningsindex (pekare) kommer till en teckengräns (outputPointer vid 5, 11 eller 17).

För att ladda bufferten tar vi det första tecknet i "meddelande" som ett ASCII -värde och subtraherar 48 för att få indexet i asciiFont -arrayen. Värdet vid det indexet lagras i codedChar.

Den första delen av meddelandet som flyttas ut motsvarar lysdioderna 47, 35, 23 och 11 (nedre delen av displayen). Så för talet noll 0x0F999F flyttas F (vänster) in först, 9 andra och så vidare.

Nästa tecken laddas genom att maskera varje nibble och flytta det åt höger. För exemplet ovan ger algoritmen (0x0F999F & 0xF00000) >> 20, sedan (0x0F999F & 0x0F0000) >> 16, etc.

int index; if (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) {char displayChar = message.charAt (messagePointer); // ta tag i det första tecknet i meddelandet long codedChar = asciiFont [displayChar - 48]; om (displayChar == 32) codedChar = 0x000000; messageBuffer [bytePointer+5] = byte ((codedChar & 0xF00000) >> 20); // maskera alla utom den sista nibble och skifta den med 20 (och så vidare) messageBuffer [bytePointer+4] = byte ((codedChar & 0x0F0000) >> 16); // detta bör sätta en nibble per minne plats messageBuffer [bytePointer+3] = byte ((codedChar & 0x00F000) >> 12); // alla sex representerar on character messageBuffer [bytePointer+2] = byte ((codedChar & 0x000F00) >> 8); messageBuffer [bytePointer+1] = byte ((codedChar & 0x0000F0) >> 4); messageBuffer [bytePointer] = byte ((codedChar & 0x00000F)); if (bytePointer == 0) {// hantera slingan runt på bytePointer bytePointer = 12; } annat {bytePointer -= 6; // vi fyller nerifrån och upp; OBS: måste titta på att vända detta för att se om det gör det enklare} om (messagePointer == message.length ()-1) {// hantera öglan runt på meddelandet messagePointer = 0; } annat {messagePointer += 1; // gå till nästa tecken}}

När bufferten väl är laddad blir det en fråga om att spåra var utdatapekaren är och ladda LED -strängen med rätt 48 bitar (strömmen 4 och föregående 44). Som nämnts tidigare är strip en förekomst av NeoPixel -klassen och setPixelColor anger färgen (RGB) för varje pixel. Show () -funktionen flyttar ut visningsvärdena till LED -sträng.

// loop för att kontinuerligt flytta ut bufferten

// vill skriva ut hela remsan på varje passage genom slingan, endast startplatsen ändras för (int rad = 12; rad> 0; rad--) {index = outputPointer + (12-rad); om (index> 17) index = outputPointer+(12-rad) -18; // loop om större än 17 för (int column = 4; column> 0; column--) {strip.setPixelColor (uint16_t (12*(column-1)+(row-1)), uint8_t (RedLED*(bitRead) (messageBuffer [index], kolumn-1))), uint8_t (GreenLED*(bitRead (messageBuffer [index], kolumn-1))), uint8_t (BlueLED*(bitRead (messageBuffer [index], kolumn-1))))); // vid varje plats lyser lysdioden om biten är en en}} // outputPointer pekar på den nuvarande lägsta byte i displaysträngen om (outputPointer == 0) outputPointer = 17; annars outputPointer -= 1; strip.show (); }

Steg 21: Förbluffa världen med din Ukulele Awsomeness

Den sista Ukulele -prototypen tog cirka 6 månaders start och stopp att dra av.

Massor av ny teknik att lära sig och kanske lite träbearbetning och musikteori att starta!

Vad ska jag göra för nästa version?

1. Bli av med displayen och roterande pulsgivare. Ersätt dem med en Bluetooth -modul ansluten till arduino. Kontrollera det på distans med en telefon eller surfplatta. Allt är bättre med Bluetooth.
2. Uppdatera ackordmönster på distans i realtid. Något som är bäst kvar för appen.
3. LED -lock. Den nuvarande versionen gör ingenting för att förhindra att gunk hamnar i LED -hålen. En vän gjorde ett gäng små linser, men jag kunde aldrig komma på hur jag skulle få dem att stanna ordentligt.
4. Alternativa greppbräda, kanske något klart så länge bandet håller.
5. Mer ljus! Eliminera textbegränsningen genom att lägga till fler "rader". Detta är verkligen en begränsning som orsakas av greppbrädans storlek och LED -kropparna.

Återigen, se följeslagaren Instructable som beskriver teckenuppsättningen jag var tvungen att skapa för att tillåta rullningstext.

Tack så mycket för att du tog dig så här långt! Mahalo!