Sådan bygger du en oplyst ukulele !: 21 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:27

Jeg spiller Ukulele. Lidt middelmådigt (hvis det er et ord), så jeg tænkte, "hvis du virkelig vil imponere damerne, har du brug for et middel til at distrahere dem fra den katastrofe, der spiller på scenen." Derfor blev "Light-up Ukulele" født.

Dette projekt tager et Concert Ukulele -kit og tilføjer en Arduino -kontrolleret LED i hver streng og båndposition. Det tilføjer også et smukt OLED -display og en roterende encoderbaseret brugergrænseflade for at vælge tilstand og intensitet af LED -strengen.

Den færdige uge hardware funktioner:

1. Arduino MICRO til interface til LED -streng, display og inputenhed.
2. 48 individuelt programmerbare LED'er i fuld farve
3. Et OLED -display
4. En roterende encoder til brugerindgang
5. USB -interface til ekstern strøm og Arduino -programmering

Uke -softwaren har:

1. Grundlæggende lysstyringstilstande, der kører lysdioderne gennem deres skridt
2. En smart teatertelt -tilstand (meget praktisk til forestillinger!)
3. LED intensitetskontrol
4. Et fuldt akkordbibliotek med alle første position Ukulele -akkorder (akkordværdi og karakter)
5. Mulighed for at vise løbende tekst (lodret) ved hjælp af et unikt 4 x 6 pixel tegnsæt

Denne instruerbare beskriver den færdige prototype. Den fulde udviklingssaga er tilgængelig HER, herunder nogle uddannelsesmæssige (smertefulde) fejl og en værdifuld lektion i, hvorfor du SKAL afslutte dit første design til færdiggørelse (uanset hvor grimme tingene bliver). Du ved aldrig alle de ting, du virkelig ikke ved, før du når til slutningen (og så ved du det stadig ikke!), Men du er meget bedre stillet og meget klogere til det næste design.

Jeg byggede prototypen omkring et Grizzly Concert Ukulele -kit. At starte med et kit lindrer bekymringen om Ukes krop (godt, for det meste) og eliminerer det meste af det virkelige luthier-type arbejde. Disse kits er temmelig komplette og ikke så dyre i den store ordning (og mindre smertefulde, da du laver fejl).

Trin 1: Lav en plan

Gribebrættet (eller gribebrættet), der er inkluderet i nogle sæt, har allerede båndene fastgjort. Det er godt/dårligt. Det er rart som tidsbesparende, men i forhold til at lægge et boremønster og holde det på plads under fræsning, er det lidt af en smerte. Efter at have ødelagt den, der fulgte med i sættet, valgte jeg (godt, jeg havde ikke noget andet valg end at købe et andet kit) til at købe et nyt gribebræt.

Når vi designer gribebrættet, skal vi beregne stigningen i den tykkelse, der kræves for at integrere printkortet og lysdioderne (og glem ikke de passive komponenter), men ikke så meget, at lysdioderne er for langt fra gribebrættets overflade.

LED -printkortet (PCB) er designet som et simpelt 2 -lags bord. Dette hjælper meget med håndsamlingen af LED -strengen og giver en vis mekanisk styrke (det er glasfiber og epoxy) til Ukulele -halsen. Jeg startede layoutet i Eagle, men endte med at bruge Altium Designer på grund af begrænsninger i pladestørrelse. Altium -skematiske og PCB -filer er her.

Kit -gribebrættet var kun 0,125 tommer tykt. Så hvis vi antager en 0,062 tommer tyk print og tillader yderligere 0,062 tommer til lysdioderne, betyder det, at vi bliver nødt til at skære meget ud (som i alle) af gribebrættet. For at kompensere kan vi enten delvis skære lommer til lysdioderne i gribebrættet med en tilsvarende lomme i nakken til printkortet, eller vi kan udskifte hele gribebrættet (den mulighed, jeg gik med) med en tykkere version fra Luther Mercantile International (LMII), som er 0,25 tommer til at starte.

MEN, husk, at du stadig skal bearbejde nakken for at kompensere for stigningen i tykkelsen i gribebrættet. Den anden fordel, du får, er kosmetisk, da printkortet nu er fuldstændig indlejret inde i gribebrættet, hvilket gør kanterne langt lettere at afslutte (og ser langt pænere ud!) Og forenkler fræsning af halsen.

Ingeniørmæssige ting (ignorer hvis du vil):

I øvrigt kompromitterer dette ikke rigtigt stivheden i nakken så meget. PCB -materialet er langt stivere end det originale gribebræt (Mahogni -modul: 10,6 GPa kontra FR4 -modul: 24 GPa), plus da vi bygger en Ukulele, er der ikke en enorm mængde strengspændinger, der ellers kunne forvrænges (twist eller kæde) halsen.

En meget interessant overvejelse (som jeg nok stadig burde beregne) er, hvad der sker over temperatur. Generelt for træ, parallelt med kornet, er den termiske ekspansionskoefficient omtrent 3 x 10^-6/K, og for FR4 er det 14 × 10^−6/K. Så der er en ganske betydelig forskel. Bekymringen er, at der skabes spændinger i nakken, når temperaturen varierer, hvilket igen afstemmer strengene. Det er noget, der kan kompenseres ved at anvende et lignende lag på den modsatte side af neutralaksen eller ved at komme FR4 så tæt som muligt på neutralaksen. Men det bliver tilbage til 2.0 … Noget at modellere og evaluere.

Elektronikken er placeret i Ukens krop. Huller skæres i sidevæggen (ikke lydkortet!) I UKE for at give plads til displayet og roterende encoder, plus en adgangsplade til at holde Arduino Micro og give adgang til USB -interfacet. Adgangspladen/monteringsdesignet og placeringen kan sandsynligvis forbedres for at få USB -forbindelsen til at komme ud på et mere bekvemt sted, men som det ser ud, er det ikke så slemt, da det ikke er i vejen, når du spiller.

Oversigten over trin er som følger:

1. Saml materialer
2. Få de værktøjer, du har brug for
3. Fræse halsen for at rumme det tykkere gribebræt
4. Fræs gribebrættet for at lave huller på de krævede steder og for at oprette lommer til brættet og lysdioder
5. Hent og konstruer printkortet, der holder LED'erne
6. Fræseadgangshuller i Ukulele -kabinettet til OLED -display, Rotary encoder og adgangspanel
7. Lav dækplader
8. Fastgør ledninger til printkortet; tilslutte og teste elektronikken
9. Fastgør nakken til Ukulele -kroppen
10. Bor et adgangsgreb for at føre PCB -ledningerne ind i kroppen
11. Juster og lim printpladen og gribebrættet til halsen
12. Juster gribebrættets kanter til halsen (fjern overskydende materiale)
13. Installer båndtrådene
14. Påfør maskering og påfør finish på Ukulele
15. Juster og fastgør broen
16. Installer elektronik og test.
17. Installer tunere og streng instrumentet
18. Programmer Uke -controlleren
19. Forundre verden med din Ukulele -awesomeness!

Trin 2: Saml materialer

Vores materialeliste ser sådan ud:

1. Ukulele kit - Jeg brugte et Grizzly Concert Ukulele kit (Grizzly Uke Kit på Amazon), men det ser ud til at være afbrudt. Zimo laver en lignende model (Zimo Uke Kit @ Amazon), som ser ud til at gøre jobbet
2. Ukulele gribebræt, præ-slidset (LMII Uke Fingerboards). De vil placere gribebrættet til din skala, hvilket sparer et rod af problemer
3. Epoxy - til limning af gribebrættet til nakken. Jeg valgte epoxy, da det er kompatibelt med PCB -materialet. Kig efter noget med mindst 60 minutters arbejdsliv. Brug IKKE 5 minutters typer, du har brug for tid til at foretage justeringer
4. Båndtråde - fås også hos LMII
5. Brugerdefineret printkort - Altium -filer er her. Jeg valgte normalt materiale af FR4 -typen. Flex (polyimid) plader ville være et interessant (hvis mere dyrt) alternativ, da de kan være meget tyndere
6. 48x Neopixel (SK6812) lysdioder. Fås fra Adafruit og Digikey
7. 48x 0.1uF 0402 caps - større er acceptabelt, men du skal se placeringen
8. Tilslutningstråd - mindst 4 til 6 farver for at undgå forvirring, jeg brugte primært 28 gauge wire. Se DC falde på LED -strømforbindelserne (både VCC og GROUND … at strømmen skal tilbage til kilden!)
9. Roterende encoder-PEC16-4220F-S0024
10. Fancy træknap - til den roterende encoder (jeg fik min fra LMII)
11. OLED -skærm - fra 4D -systemer OLED -skærme
12. Eksternt USB -batteri - billigere hele tiden, plus du kan bære reservedele!
13. Arduino MIKRO
14. Ark messing - for at gøre pladen til at rumme arduino og ramme til displayet
15. Diverse forbrugsstoffer, herunder: sandpapir, urethanfinish, popsicle sticks, gummibånd, loddemateriale, flux, børster, dobbeltsidet tape (jeg kan godt lide UHC tape ved 3M) og små træskruer i messing (til pladen)
16. Valgfri Ukulele -forbedringer - bedre tunere, bedre strenge, bedre møtrik og sadel, indlæg, hvis du vil vise din luthier dygtighed)

Trin 3: Få de værktøjer, du har brug for

Før eller siden bliver du nødt til at få eller få adgang til disse:

Vores værktøjsliste indeholder:

1. Fræsemaskine - CNC foretrækkes, men du kan endda klare dig med en router og masser af held. Jeg brugte en kombinations CNC -fræser/router
2. Router bits - hårdmetal foretrækkes. Router bits valgt end endefræsere, da vi bearbejder træ, ikke metal
3. Klemmer - masser af dem. Mest brug for at holde dele under limning
4. Loddejern - lille spids til overflademontering
5. Mikroskop eller forstørrelsesglas - du kan prøve at lodde med kun dine øjne, men jeg vil ikke anbefale det, mindst 10x
6. Pincet (til at sætte dele på plads)
7. Frettingsværktøjer (se de korrekte værktøjer på LMII her, men jeg brugte det, jeg havde derhjemme og fik det til at fungere; hamre, filer og fræsere)
8. Assorteret håndværktøj såsom træmejsler, skruetrækkere, blødt slag eller råhudshammer (til fretting) osv.
9. Slibemidler - forskellige sandpapirkorn

Vores softwareværktøjer inkluderer (nogle er valgfrie afhængigt af dit budget/opfindsomhed):

1. Arduino software
2. Ukulele -kildekoden (https://github.com/conrad26/Ukulele)
3. PCB -layoutpakke - Jeg brugte Altium, fordi den gratis version af Eagle ikke understøttede den bestyrelsesstørrelse, jeg ønskede. Altium er en komplet layoutpakke og ikke rigtig i en prisklasse for hobbyister. Jeg har inkluderet Gerber -filerne på mit websted til prototypen, men disse har bestemt brug for en opdatering
4. 3D -modelleringssoftware - jeg brugte SolidWorks, men et gratis alternativ er FreeCAD (https://www.freecadweb.org/)
5. CAM -software - som FeatureCAM fra Autodesk til oprettelse af NC -møllefilen.

Kombinationen af 3D trin -fileksport fra Altium sammen med en 3D -model af gribebrættet eliminerer meget af vanskelighederne med at sikre, at alt er i orden, men det er ikke et krav. Omhyggelig layout vil opnå det samme resultat.

Nu hvor vi ved, hvad vi vil gøre, og hvad vi har brug for at gøre det, lad os bygge en Ukulele.

Trin 4: Fræs halsen for at passe til det tykkere gribebræt

Før fræsning skal du bemærke, at den originale gribebrætmonteringsoverfladens planhed SKAL opretholdes, eller du får en snoet gribebræt, hvilket fører til alle mulige problemer med båndudjævning.

Bare gå ikke derhen, tag din tid og klem nakken omhyggeligt og stift og kontroller justeringen til fræseren over hele halsen, før du skærer. Tiden brugt her vil spare dig for meget sorg senere.

En af grundene til at jeg valgte et tykkere gribebræt over et indlæg i nakken var det øgede monterings (limning) overfladeareal. En anden grund er, at det forenkler fræsning af nakken. Du summer simpelthen hele overfladen til den nødvendige højde.

Trin 5: Hent og konstruer printkortet, der holder LED'erne

Jeg lod lodde hele forsamlingen. LED -pakkerne er særligt lette at smelte, så pas på at undgå at beskadige dem. Jeg foreslår at bære en statisk rem, da strengen er afhængig af, at hver LED fungerer.

Gribebrættets design er baseret på WS2812B LED'erne. Jeg besluttede mig kun for at gøre den første oktav på gribebrættet (48 lysdioder !!). Hver LED kan betragtes som en bit i et skiftregister. Skiftregisteret clockes til 800 kHz. Jeg brugte Adafruit -biblioteket (se programmeringsafsnittet) til at få tingene til at fungere hurtigt.

Jeg startede designet i Eagle, men tavlestørrelsen er begrænset til 4 x 5 tommer, så jeg var nødt til (eller mere korrekt, jeg valgte) at skifte til Altium. Jeg bruger Altium på arbejdet, så i virkeligheden gjorde det tingene hurtigere for mig. Altium -projektet, skematiske filer og pcb -filer (og biblioteksdele) findes på mit websted. Pladen er trapezformet og cirka 10 centimeter lang. Jeg synes, jeg skulle have forsøgt at komprimere omridset lidt mere (næste spin!) Montering var ikke dårlig, men hvis du har råd, kan jeg virkelig anbefale et anstændigt loddejern (JBC Loddejern) og et godt mikroskop. Ja, jeg er forkælet og nej, jeg har ikke den slags ting i mit hjemmelaboratorium. Jeg er billig.

Jeg fik lavet brædderne på Sunstone. $ 129 for to brædder. Garanteret en uges omgang. Skrab dog ikke på forsendelsen. Jeg lagde ikke mærke til, at jeg brugte UPS ground, og jeg endte med at vente en ekstra uge på, at mine boards skulle ankomme. Samlet monteringstid var ca. 2 timer (98 dele).

Trin 6: Fræs gribebrættet

Vi skal fræse gribebrættet for at lave huller på de krævede steder og for at skabe lommer til brættet og lysdioder.

Jeg lavede en 3D -model af det færdige gribebræt i Solidworks og skabte CNC -fræserutinen ved hjælp af FeatureCAM.

Den nederste del af gribebrættet (tættest på lydhullet) skal gøres tyndere for at tage højde for trinændringen i højden mellem nakke og krop. Absolut værd at teste flere gange for at være sikker på, at det er en rimelig tæt pasform.

Set i bakspejlet burde jeg have afskåret de ubrugte dele af gribebrættet for at få det til at passe bedre til møllen (min billige mølle havde kun en 12 X-akse-kørsel). Betjeningsrækkefølgen skulle indstilles til de første mølletykkelsesjusteringer før fræselommer, hvilket skulle føre til færre udbrud mellem lommer.

Foretag manuelle justeringer efter behov for at tilføje plads til ledninger. En vigtig ting at bemærke er, at i nogle af lommerne brød jeg igennem i åbningen, hvor båndtråden vil gå. Da det er en leder, skal du sørge for, at det ikke ender med at kortslutte noget vigtigt. Det reducerer også styrken af det materiale, der holder båndet på plads. Designet bør ændres for aldrig at krydse med en båndplads.

Trin 7: Fræseadgangshuller i Ukulele -kroppen

Jeg fræste manuelt adgangshullerne i kroppen. Den sværeste del er at finde den "fladeste" region af, hvad der er en meget buet overflade. Marker omridset med blyant og fræser gradvist materiale væk, indtil du får en passende pasform til OLED -skærmen. Jeg skaffede mig en bearbejdet messingramme og fastgjorde den ved hjælp af 3M VHB -tape.

Da ingen af dem kræver stor præcision, er den roterende encoder og adgangspanelhullerne langt lettere at oprette.

Trin 8: Lav dækplader

Du skal også fabulere dækpladerne til skærmrammen og adgangspanelet. Adgangspanelet har brug for et hul (rektangulært) til USB (mikro) stikket. Brug bare det eksisterende stik på Arduino, da der ikke er mange panelmonteringsmuligheder til mikro -USB. (selvom hvis jeg var at designe fra bunden, så ville jeg give et af disse et kig)

For at holde tavlen på plads, skal du montere L -beslag af messing og lodde dem bag på adgangspladen. Dette giver dig mulighed for en vis breddegrad i positionering. For at få den rigtige placering skal du først oprette et perfboard-monteringsbræt (med monteringshuller) til Arduino MICRO og fastgøre L-beslagene til det ved hjælp af 2-56 maskinskruer. Du kan derefter justere placeringen for at justere usb -porten og markere placeringen af beslagene på pladen nøjagtigt. Fjern beslagene fra perfboardet og lod dem på plads. Monter endelig perfboard -samlingen.

Jeg brugte fire små træskruer i messing til at holde adgangspanelet i messing på plads.

På dette tidspunkt anbefaler jeg en testtilpasning, før den sidste samling begynder. Dette trin er valgfrit, men anbefales. Det er langt lettere at foretage justeringer inden limning.

Trin 9: Fastgør ledninger til printkortet; Tilslut og test elektronikken

Monter ikke elektronikken permanent endnu. Fastgør ledninger til printkortet, og sørg for, at du lader tilstrækkelig slap til at føre adgangshullet ud. Disse skal i sidste ende fastgøres permanent til Arduino MICRO -kortet (billederne viser en Arduino UNO, som jeg brugte til kodeudvikling)

Trin 10: Fastgør halsen til Ukulele -kroppen

Fastgør nakken til Ukulele -kroppen efter instruktionerne, der fulgte med Ukulele -kittet. Se især tilpasningen af gribebrættets overflade til ukens krop.

Trin 11: Bor et adgangshul for at føre printkorttrådene ind i kroppen

Når limen er tør, borer du et ~ 1/4 (10 mm) hul i en vinkel, så ledningerne fra printkortet kan ledes ind i Ukulele -kroppen. Sørg for ikke at beskadige lydkortet.

Du skal muligvis også oprette en lille lomme for at tillade tykkelsen af ledningerne under brættet (eller eventuelt sætte forbindelserne på toppen og inkludere aflastning i gribebrættet.)

En anden testtilpasning ville ikke skade på dette tidspunkt.

Trin 12: Juster og lim PCB og gribebrættet til halsen

Jeg foreslår, at man tænker igennem spændingen (og prøver det!) Inden limning. Det kan være en god idé at lave en blok formet på undersiden af halsen for at give dig en flad klemoverflade. Gribebrættet er større end halsen på dette tidspunkt, så du skal tillade det.

Vær meget forsigtig med ikke at få epoxy på en hvilken som helst overflade, som du vil afslutte senere. Bedre endnu påføre maskering på alle ikke-limede overflader, før du limer for at sikre, at den kun går, hvor du havde til hensigt.

Brug epoxy med et minimum af 60 minutters arbejdsliv … du skal bruge det hele.

Lim PCB'en på plads først, og sørg for, at overskydende lim ikke ekstruderes i gribebrættets limoverflade. Dette giver en metode til at justere gribebrættet til nakken. PCB'en har en glat loddemaske, så jeg ruede den op med lidt sandpapir for at give epoxyen en lidt forbedret overfladefinish.

Juster og lim gribebrættet til halsen. Vær forsigtig med at efterlade lommer, der senere kan blive resonante (buzz!). Vær også forsigtig med ikke at få lim på LED -overfladerne.

Når limen er tør, kan det være en god idé at wire og teste elektronikken endnu en gang. En dårlig LED vil få dig til at hader livet. Jeg havde en dårlig LED (den første!) På prototypen, og jeg var nødt til at lave noget kreativt træværk for at få adgang til den defekte LED og lappe den rent.

Trin 13: Juster gribebrættets kanter til halsen, og tilføj båndtråde

Når limen er tør, kan du begynde at afslutte kanterne. Jeg skar forsigtigt det overskydende gribebrætmateriale væk (ved hjælp af en mølle) og afsluttede den sidste millimeter ved håndslibning.

Tilføjelse af båndtrådene kan simpelthen gøres med en hammer (med et plastflade for at undgå at blive ødelagt). Bare hamrer ikke for hårdt. Hvis du har matchet båndtråden til åbningerne, skal de gå ind uden større besvær.

Det, du skal se efter, er at bryde den tynde overflade af LED -lommen. På prototypen tillod jeg, at nogle LED -lommer (nær den 12. bånd, hvor pladsen bliver stram) strakte sig ind i bæltespalten. Det er en dårlig idé, da det skaber et svagt sted, der kan (og gjorde) revne, når båndtråden er indsat.

Trin 14: Påfør maskering og påfør finish på Ukulele

Masker gribebrættet (det bliver ikke færdigt) og broens limområde og begynd at påføre finish.

Når du maskerer broområdet, skal du læse instruktionerne med dit kit, og derefter tjekke skalaens længde bare for at være sikker. Sættet, jeg brugte til prototypen, brugte den forkerte skalalængde og gav derfor de forkerte dimensioner til at lokalisere broen (men den havde en note til at tjekke webstedet for de nyeste instruktioner!). Min tarm fortalte mig, at det var forkert, men jeg accepterede blindt autoritet.

Det er altid bedre at forstå, HVORFOR du gør noget, frem for blindt at følge instruktionerne.

Til afslutningen er der masser af selvstudier fra Luthiers, der ved, hvad de laver på nettet, så jeg anbefaler at konsultere dem, før de hopper ind i efterbehandlingsprocessen.

Det gjorde jeg selvfølgelig ikke, så jeg endte med at bruge den forkerte forsegler, hvilket resulterede i en meget kornet overflade. Gør ikke det.

Lav dine lektier.

Trin 15: Juster og fastgør broen

Dette trin er ret ligetil, men igen, planlæg din fastspændingsmetode, og prøv det på forhånd, før du limer. Jeg brugte en standard trælim til at fastgøre broen.

Trin 16: Installer elektronik og test

Nu er det tid til at gøre dine ledninger smukke. Plus du vil ikke have, at den flopper rundt inde i kroppen og laver summende lyde eller værre, men alligevel bryder på scenen.

Arduino -koden kan opdateres via USB -porten, så der er virkelig ingen grund til at skille den ad, medmindre du vil tinker.

Trin 17: Installer tunere og streng instrumentet

Du skal sandsynligvis også udjævne båndene og lege lidt med opsætningen, men hvorfor bekymre dig nu, når du er så tæt på slutningen?

Jeg opgraderede tunerne og brugte flotte Aquila -strenge, som overhovedet ikke hjalp lyden. Så husk det, mens du afsætter penge til et projekt ukulele …

Trin 18: Programmering af Uke

Den sidste Arduino -kode er på Github. Der er nogle linjer i koden til understøttelse af fremtidige forbedringer (som en metronomfunktion og "skyder" til displayet (et UI -element, der ligner en skyder)

Denne kode bruger et Rotary Encoder Library (Rotary Encoder Arduino Library) til at håndtere brugerinput fra Rotary Encoder.

Det bruger også Adafruit Neopixel -biblioteket og eksempelkoden, der findes her. Teater- og regnbueindstillingerne stammer fra eksempler, der følger med biblioteket. (se strandtest.ino).

Skærmdriveren leveres af 4D -systemer og findes på Github her.

Der er to unikke funktioner implementeret til Ukulele -projektet. Den første implementerer akkordbiblioteket, og den anden viser en rullende tekstmeddelelse ved hjælp af et brugerdefineret tegnsæt.

Det vedlagte diagram viser gribebrættets LED -placeringer, og hvordan de er forbundet. LED 0 er placeret i øverste højre hjørne.

Trin 19: Sådan vises en akkord

DisplayChord -funktionen viser fingerpositionerne (kun første position for nu) for hver akkord. Akkorder valgt af brugeren (rodnote og kvalitet) gemmes som et par indekser. Disse bruges igen til at slå fingrene op for hver akkord.

Jeg brugte "GCEA" -notation til at gemme akkorder (f.eks. "A" er "2100"). Akkorderne beregnes på forhånd for hver rodnote og lagres i en variabel, der svarer til akkordens kvalitet. (så, A -dur, er gemt på den første placering af arrayet "majorChords", svarende til "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 "};

Bemærk, at da dette er en tekststreng, kan hvert ciffer også repræsentere en hex -værdi for at tage højde for båndpositioner større end 9. Det vil sige, at A og B repræsenterer lysdioder 10 og 11. For akkorder med første position var dette ikke et problem).

LED -strengen er kablet på langs i rækker med 12 (en oktav) langs hver streng (startende med A -strengen), den efterfølgende kørsel på 12 starter ved den første bånd i den næste streng (se diagrammet i trin 18). Dette er vigtigt for algoritmen at afgøre, hvilke lamper der skal tændes for en given akkord. Det betyder, at pixels 0 til 11 er A -streng -LED'er, 12 til 23 er E -streng -LED'er og så videre. Når vi analyserer en A = "2100" (gemt som en streng, der er også en null -terminator "\ n" i koden), tolker vi den som: ingen pixels på A -strengen lyser, ej heller på E -strengen, pixel 0 (bånd 1) på C -strengen lyser, og pixel 1 (bånd 2) på G -strengen. Bemærk, at en "0" er slukket, ikke den første LED. Baseret på ledningerne vil vi tænde lysdioderne 24 og 37. Koden til visning af en akkord er vist nedenfor.

for (int i = 0; i <4; i ++) {if (int (akkord - '0')) {// algoritme til at analysere akkordstrengen int ledNumber = int (akkord - '0') + (3 - i) * 12 - 1; // se ovenstående diskussion, (3-i) er at vende indeksstrimlen.setPixelColor (ledNumber, 0, 125, 125); // setPixelColor (ledNumber, rød værdi, grøn værdi, blå værdi)}}

If -sætningen kontrollerer, om LED er slukket. Hvis det ikke er det, tager det ascii -værdien af tegnet, akkord og trækker ascii -værdien for '0' for at få ledNumber til at lyse.

strip er en forekomst af Adafruit_NeoPixel -klassen. SetPixelColor -funktionen indstiller farven for den beregnede pixel (fastgjort til (0, 125, 125) i dette tilfælde.

Trin 20: Sådan vises en rullende meddelelse

Så vi har et 12 x 4 array af lysdioder … hvorfor ikke få det til at vise noget andet end temmelig tilfældige lysmønstre!

Det første problem er, at skærmens højde (4) er temmelig begrænset på grund af antallet af strenge på en Uke. Vandret rulning ville for det meste være ulæselig, men i lodrette retning kan vi understøtte 4 x 5 tegn, der kører lodret.

Organisering af tegn som fem "lodrette" rækker betyder, at to tegn kan vises samtidigt, så der er en mellemrum mellem hvert tegn.

Vanskeligheden var, at der ikke var et standard 4 x 5 tegnsæt. Jeg lavede mit eget ved hjælp af det vedhæftede regneark. Jeg tildelte hver række en enkelt hex -værdi (4 bits, der repræsenterer, hvilken pixel der er tændt eller slukket). Kombinationen af de fem hex -værdier udgør et tegn (f.eks. "0" er 0x69996).

Værdierne for hvert tegn gemmes i et array i ASCII -rækkefølge. Tegnsættet indgår nogle kompromiser med visse bogstaver, men størstedelen er rimelig klar. (skriften i bunden af regnearket er ideer, jeg legede med, da vi har farve som en mulighed, kan vi tilføje "dybde" til karakteren og muligvis få en ekstra opløsning.

Den streng, der skal vises, er indeholdt i strengvariablen, message.

En buffer oprettes for at repræsentere tegnvisning. Jeg formoder, at jeg simpelthen kunne have oprettet en stor buffer med hele den oversatte meddelelsessekvens, især da de fleste meddelelser vil være mindre end 20 tegn eller deromkring. Imidlertid valgte jeg i stedet at oprette en fast buffer med tre tegn (18 bytes). Kun to af tegnene vises aktivt, og det tredje er et kig fremad, hvor det næste tegn indlæses. LED -strengen (tænk på det som et stort skiftregister) er indlæst med de 48 bit til strengen. Jeg spildte lidt hukommelsesplads for at gøre det lettere at konceptualisere. Hver nibble får sin egen hukommelsesplacering, hvilket fordobler hukommelseskravet, men det er ikke meget givet bufferstørrelsen.

Bufferen indlæses med det næste tegn, når outputindekset (markøren) kommer til en tegngrænse (outputPointer ved 5, 11 eller 17).

For at indlæse bufferen tager vi det første tegn i "meddelelse" som en ASCII -værdi og trækker 48 fra for at få indekset i asciiFont -arrayet. Værdien ved dette indeks gemmes i codedChar.

Den første del af meddelelsen flyttet ud svarer til lysdioderne 47, 35, 23 og 11 (bunden af displayet). Så for tallet nul 0x0F999F flyttes F (venstre) ind første, 9 sekund og så videre.

Det næste tegn indlæses ved at maskere hvert nibble og flytte det til højre. For ovenstående eksempel giver algoritmen (0x0F999F & 0xF00000) >> 20, derefter (0x0F999F & 0x0F0000) >> 16 osv.

int indeks; hvis (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) {char displayChar = message.charAt (messagePointer); // tag den første karakter i meddelelsen lang codedChar = asciiFont [displayChar - 48]; hvis (displayChar == 32) codedChar = 0x000000; messageBuffer [bytePointer+5] = byte ((codedChar & 0xF00000) >> 20); // masker alt undtagen det sidste nibble og skift det over med 20 (og så videre) messageBuffer [bytePointer+4] = byte ((codedChar & 0x0F0000) >> 16); // dette skulle sætte et nibble pr. hukommelsesplacering messageBuffer [bytePointer+3] = byte ((codedChar & 0x00F000) >> 12); // alle seks repræsenterer on character messageBuffer [bytePointer+2] = byte ((codedChar & 0x000F00) >> 8); messageBuffer [bytePointer+1] = byte ((codedChar & 0x0000F0) >> 4); messageBuffer [bytePointer] = byte ((codedChar & 0x00000F)); hvis (bytePointer == 0) {// håndter løkken rundt på bytePointer bytePointer = 12; } ellers {bytePointer -= 6; // vi fylder nedefra og op; BEMÆRK: skal kigge på at vende dette for at se, om det gør det lettere} hvis (messagePointer == message.length ()-1) {// håndter løkken rundt på meddelelsen messagePointer = 0; } ellers {messagePointer += 1; // gå til det næste tegn}}

Når bufferen er indlæst, bliver det et spørgsmål om at spore, hvor outputmarkøren er på, og indlæse LED -strengen med de korrekte 48 bit (den nuværende 4 og den foregående 44). Som tidligere nævnt er strip en forekomst af NeoPixel -klassen, og setPixelColor indstiller farven (RGB) for hver pixel. Show () -funktionen skifter visningsværdierne til LED -streng.

// loop for løbende at skifte bufferen ud

// vil skrive hele strimlen ud på hver passage gennem løkken, kun startplaceringen ændres for (int række = 12; række> 0; række--) {index = outputPointer + (12-række); hvis (indeks> 17) indeks = outputPointer+(12 rækker) -18; // loop hvis større end 17 for (int column = 4; column> 0; column--) {strip.setPixelColor (uint16_t (12*(column-1)+(row-1)), uint8_t (RedLED*(bitRead) (messageBuffer [index], column-1))), uint8_t (GreenLED*(bitRead (messageBuffer [index], column-1)))), uint8_t (BlueLED*(bitRead (messageBuffer [index], column-1))))); // på hvert sted lyser LED'en, hvis bit er en en}} // outputPointer peger på den nuværende laveste byte i displaystrengen, hvis (outputPointer == 0) outputPointer = 17; ellers outputPointer -= 1; strip.show (); }

Trin 21: Forundre verden med din ukulele -awsomeness

Den sidste Ukulele -prototype tog omkring 6 måneders start og stop at trække ud.

Masser af ny teknologi at lære og måske noget træbearbejdning og musikalsk teori at starte op!

Hvad skal jeg gøre for den næste version?

1. Slip af med displayet og roterende encoder. Udskift dem med et Bluetooth -modul, der er knyttet til arduinoen. Styr det eksternt ved hjælp af en telefon eller tablet. Alt er bedre med Bluetooth.
2. Opdater akkordmønstre eksternt i realtid. Noget der er bedst tilbage til appen.
3. LED dæksler. Den nuværende version gør intet for at forhindre gunk i at komme ind i LED -hullerne. En ven lavede en flok små linser, men jeg kunne aldrig finde ud af at få dem til at blive på plads korrekt.
4. Alternative gribebrætmaterialer, måske noget klart, så længe båndene holder.
5. Flere lys! Eliminer begrænsningen af tekst ved at tilføje flere "rækker". Dette er virkelig en begrænsning forårsaget af gribebrættets størrelse og LED -kroppe.

Se igen ledsageren Instructable, der beskriver tegnsættet, jeg skulle oprette for at tillade rullende tekst.

Mange tak fordi du nåede så langt! Mahalo!