How to Build a Light-up Ukulele !: 21 Steps

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

Cânt la ukulele. Cam mediocru (dacă acesta este un cuvânt), așa că m-am gândit „dacă vreți cu adevărat să impresionați doamnele, aveți nevoie de un mijloc pentru a le distrage atenția de la dezastrul care se joacă pe scenă”. De aici s-a născut „Ukulele Light-up”.

Acest proiect ia un kit Concert Ukulele și adaugă un LED controlat de Arduino la fiecare poziție de șir și fret. De asemenea, adaugă un afișaj OLED elegant și o interfață de utilizator bazată pe codificator rotativ pentru a selecta modul și intensitatea șirului de LED-uri.

Caracteristicile hardware uke completate:

1. Arduino MICRO pentru interfață cu șirul de LED-uri, afișajul și dispozitivul de intrare.
2. 48 LED-uri color complet programabile individual
3. Un afișaj OLED
4. Un codificator rotativ pentru intrarea utilizatorului
5. Interfață USB pentru alimentare externă și programare Arduino

Software-ul uke are:

1. Moduri de bază de control al luminii care rulează LED-urile prin ritmul lor
2. Un mod de marcaj elegant de teatru (foarte util pentru spectacole!)
3. Controlul intensității LED-ului
4. O bibliotecă completă de acorduri cu toate acordurile ukulele de prima poziție (valoarea acordului și caracterul)
5. Abilitatea de a afișa textul în execuție (vertical) utilizând un set unic de caractere de 4 x 6 pixeli

Acest instructable descrie prototipul finalizat. Saga completă de dezvoltare este disponibilă AICI, incluzând câteva greșeli educaționale (dureroase) și o lecție valoroasă de ce TREBUIE să finalizați primul design până la finalizare (indiferent cât de urâte devin lucrurile). Nu știi niciodată toate lucrurile pe care chiar nu le știi până nu ajungi la final (și apoi încă nu știi!), Dar ești mult mai bine și mult mai inteligent pentru următorul design.

Am construit prototipul în jurul unui kit de ukulele Grizzly Concert. Începând cu un kit, ameliorează îngrijorarea cu privire la corpul uke-ului (bine, mai ales) și elimină majoritatea lucrărilor reale de tip luthier. Aceste truse sunt destul de complete și nu sunt atât de scumpe în marea schemă de lucruri (și mai puțin dureroase, deoarece veți face greșeli).

Pasul 1: Faceți un plan

Tastatura (sau tastatura) inclusă în unele truse are deja fretele atașate. Asta e bine / rău. Este frumos ca economie de timp, dar în ceea ce privește stabilirea unui model de burghiu și menținerea acestuia în loc în timpul măcinării, este puțin dureros. După ce am distrus-o pe cea prevăzută în kit, am optat (ei bine, nu am avut altă opțiune decât să cumpăr un alt kit) să cumpăr o tastă nouă.

Când proiectăm tastatura, trebuie să calculăm creșterea grosimii necesare pentru încorporarea PCB-ului și a LED-urilor (și nu uitați de componentele pasive), dar nu atât de mult încât LED-urile sunt prea departe de suprafața tastaturii.

Placa cu circuite imprimate cu LED (PCB) este proiectată ca o placă simplă cu 2 straturi. Acest lucru ajută foarte mult la asamblarea manuală a șirului cu LED-uri și oferă o anumită rezistență mecanică (este din fibră de sticlă și epoxidică) gâtului Ukulele. Am început aspectul în Eagle, dar am ajuns să folosesc Altium Designer din cauza limitărilor dimensiunii plăcii. Schemele Altium și fișierele PCB sunt aici.

Diafragma kitului avea o grosime de doar 0,125 inci. Deci, presupunând un PCB gros de 0,062 inci și permițând încă 0,062 inci pentru LED-uri, înseamnă că ar trebui să tăiem mult (ca în toate) tastatura. Pentru a compensa, putem tăia parțial buzunarele LED-urilor din fretboard cu un buzunar corespunzător în gât pentru PCB, sau am putea înlocui întreaga tastatură (opțiunea cu care am mers) cu o versiune mai groasă de la Luther Mercantile International (LMII), care sunt 0,25 inci pentru a începe.

DAR, amintiți-vă că va trebui totuși să prelucrați gâtul pentru a compensa creșterea grosimii în tastatură. Celălalt avantaj pe care îl obțineți este cosmetic, deoarece PCB-ul este acum complet încorporat în tastatură, ceea ce face marginile mult mai ușor de finisat (și arată mult mai frumos!) Și simplifică frezarea gâtului.

Lucruri de inginerie (ignorați dacă doriți):

Apropo, acest lucru nu compromite atât de mult rigiditatea gâtului. Materialul PCB este mult mai rigid decât lemnul de tastatură original (modul de mahon: 10,6 GPa versus modulul FR4: 24 GPa), plus că, din moment ce construim un ukulele, nu există o cantitate uriașă de tensiune a șirurilor care altfel ar putea distorsiona (răsuciți sau urzeală) gâtului.

Un aspect foarte interesant (pe care probabil că ar trebui să îl calculez în continuare) este ceea ce se întâmplă peste temperatură. Generic pentru lemn, paralel cu bobul, coeficientul termic de expansiune este de aproximativ 3 x 10 ^ -6 / K, iar pentru FR4 este de 14 × 10 ^ −6 / K. Deci, există o diferență destul de semnificativă. Îngrijorarea este că tensiunea se creează în gât pe măsură ce temperatura variază, ceea ce la rândul său dezactivează corzile. Acest lucru ar putea fi compensat prin aplicarea unui strat similar pe partea opusă a axei neutre sau prin apropierea FR4 cât mai aproape de axa neutră. Dar asta va fi lăsat pentru 2.0 … Ceva de modelat și evaluat.

Componentele electronice sunt adăpostite în corpul uke-ului. Găurile sunt tăiate în peretele lateral (nu în placa de sunet!) A UKE pentru a face loc afișajului și codificatorului rotativ, plus o placă de acces pentru a ține Arduino Micro și a oferi acces la interfața USB. Designul și locația plăcii de acces / montaj ar putea fi îmbunătățite probabil pentru a face conexiunea USB să iasă într-o locație mai convenabilă, dar așa cum este, nu este atât de rău, deoarece nu este în cale atunci când jucați.

Schița pașilor este următoarea:

1. Adună materiale
2. Obțineți instrumentele de care aveți nevoie
3. Frezați gâtul pentru a găzdui tastatura mai groasă
4. Frisați tastatura pentru a face găuri în locațiile necesare și pentru a crea buzunare pentru placă și LED-uri
5. Obțineți și construiți PCB-ul care ține LED-urile
6. Moriți găurile de acces în corpul Ukulele pentru afișajul OLED, codificatorul rotativ și panoul de acces
7. Faceți plăci de acoperire
8. Atașați firele la PCB; conectați și testați electronica
9. Atașați gâtul la corpul Ukulele
10. Găuriți o priză de acces pentru a trece firele PCB în corp
11. Aliniați și lipiți PCB-ul și tastatura pe gât
12. Nivelați marginile tastaturii până la gât (îndepărtați materialul în exces)
13. Instalați firele de fret
14. Aplicați mascare și aplicați finisaj pe ukulele
15. Aliniați și atașați podul
16. Instalați electronice și testați.
17. Instalați tunere și coardați instrumentul
18. Programați controlerul Uke
19. Uimeste lumea cu genialitatea ta Ukulele!

Pasul 2: Strângeți materiale

Lista materialelor noastre arată astfel:

1. Kit Ukulele - Am folosit un kit Ukulele Grizzly Concert (Grizzly Uke Kit la Amazon), dar se pare că va fi întrerupt. Zimo face un model similar (Zimo Uke Kit @ Amazon) care pare că va face treaba
2. Fretboard ukulele, presetat (LMII Uke Fingerboards). Vor monta tastatura pe cântarul dvs., ceea ce vă scutește de mizerie
3. Epoxidic - pentru lipirea diafragmei de gât. Am ales epoxidul, deoarece este compatibil cu materialul PCB. Căutați ceva cu cel puțin 60 de minute de viață profesională. NU folosiți tipuri de 5 minute, aveți nevoie de timp pentru a face ajustări
4. Sârme de fret - disponibile și de la LMII
5. PCB personalizate - Fișierele Altium sunt aici. Am optat pentru material normal de tip FR4. Plăcile flexibile (poliimide) ar fi o alternativă interesantă (dacă sunt mai scumpe), deoarece acestea pot fi mult mai subțiri
6. LED-uri 48x Neopixel (SK6812). Disponibil de la Adafruit și Digikey
7. 48x 0,1uF 0402 capace - mai mare este acceptabil, dar trebuie să urmăriți plasarea
8. Sârmă de conectare - cel puțin 4 până la 6 culori pentru a evita confuzia, am folosit în primul rând sârmă de 28. Urmăriți căderea de curent continuu a conexiunilor de alimentare cu LED-uri (atât VCC, cât și GROUND … acel curent trebuie să revină la sursă!)
9. Codificator rotativ - PEC16-4220F-S0024
10. Buton fantezie din lemn - pentru codificatorul rotativ (am primit-o pe a mea de la LMII)
11. Afișaj OLED - de la sistemele 4D Afișaje OLED
12. Baterie externă USB - mai ieftină tot timpul, plus că poți transporta piese de schimb!
13. Arduino MICRO
14. Foaie de alamă - pentru a face placa pentru a ține arduino și rama pentru afișaj
15. Consumabile diverse, inclusiv: șmirghel, finisaj uretanic, bețe de gheață, benzi de cauciuc, lipit, flux, perii, bandă dublă (îmi place banda UHC de 3M) și șuruburi mici din alamă (pentru placă)
16. Îmbunătățiri opționale ale ukulelelor - tunere mai bune, corzi mai bune, piuliță și șa mai bune, incrustare dacă doriți să vă arătați priceperea luthierului)

Pasul 3: Obțineți instrumentele de care aveți nevoie

Mai devreme sau mai târziu, va trebui să obțineți sau să obțineți acces la acestea:

Lista noastră de instrumente include:

1. Mașină de frezat - CNC preferat, dar s-ar putea chiar să treceți cu un router și mult noroc. Am folosit o moară / router CNC combinată
2. Biți de ruter - carbură preferată. Freze de rotație alese peste frezele finale, deoarece prelucrăm lemn, nu metal
3. Cleme - o mulțime de ele. Mai ales necesar pentru a ține piesele în timpul lipirii
4. Fier de lipit - vârf mic pentru lipirea la suprafață
5. Microscop sau lupă - puteți încerca să lipiți numai cu ochii dvs., dar nu l-aș recomanda, minimum 10x
6. Pensete (pentru punerea pieselor la locul lor)
7. Instrumente de fretting (a se vedea instrumentele adecvate de pe LMII aici, dar am folosit ceea ce aveam acasă și am făcut de făcut; ciocane, file și tăietoare)
8. Unelte manuale asortate, cum ar fi dalte de lemn, șurubelnițe, ciocan moale sau ciocan de piele brută (pentru frecare) etc.
9. Abrazivi - diverse granule de șmirghel

Instrumentele noastre software includ (unele sunt opționale în funcție de buget / ingeniozitate):

1. Software Arduino
2. Codul sursă Ukulele (https://github.com/conrad26/Ukulele)
3. Pachetul de aspect PCB - am folosit Altium deoarece versiunea gratuită a Eagle nu acceptă dimensiunea plăcii dorită. Altium este un pachet de aspecte complete și nu se încadrează într-o gamă de prețuri hobbyist. Am inclus fișierele Gerber pe site-ul meu pentru prototip, dar cu siguranță acestea au nevoie de o actualizare
4. Software de modelare 3D - am folosit SolidWorks, dar o alternativă gratuită este FreeCAD (https://www.freecadweb.org/)
5. Software CAM - precum FeatureCAM de la Autodesk pentru crearea fișierului NC.

Combinația dintre exportul de fișiere pas 3D din Altium împreună cu un model 3D al tastaturii elimină o mare parte din dificultatea de a vă asigura că totul se aliniază, dar nu este o cerință. Aspectul atent va obține același rezultat.

Acum, că știm ce vrem să facem și ce trebuie să facem, să construim un Ukulele.

Pasul 4: Frezați gâtul pentru a găzdui tastatura mai groasă

Înainte de frezare, rețineți că planeitatea originală a suprafeței de montare a tastaturii TREBUIE menținută, sau veți avea o tastă răsucită, ceea ce duce la tot felul de probleme legate de nivelarea fretului.

Pur și simplu nu mergeți acolo, luați-vă timp și fixați cu grijă și rigid gâtul și verificați alinierea la bitul routerului pe întregul gât înainte de tăiere. Timpul petrecut aici vă va economisi multă durere mai târziu.

Unul dintre motivele pentru care am optat pentru o tastă mai groasă peste o incrustare în gât a fost suprafața crescută de montare (lipire). Un alt motiv este acela că simplifică frezarea gâtului. Pur și simplu buzz tăiați întreaga suprafață la înălțimea necesară.

Pasul 5: Obțineți și construiți PCB-ul care ține LED-urile

Am lipit manual întregul ansamblu. Pachetele LED sunt deosebit de ușor de topit, așa că aveți grijă să nu le deteriorați. Vă sugerez să purtați o curea statică, deoarece șirul este dependent de fiecare LED care funcționează.

Designul tastaturii se bazează pe LED-urile WS2812B. Am decis să fac doar prima octavă a tastaturii (48 de LED-uri !!). Fiecare LED poate fi considerat un bit într-un registru de schimbare. Registrul de deplasare este tactat la 800 kHz. Am folosit biblioteca Adafruit (vezi secțiunea de programare) pentru a pune lucrurile în funcțiune rapid.

Am început proiectarea în Eagle, dar dimensiunea plăcii este limitată la 4 x 5 inci, așa că a trebuit să (sau mai corect, am optat să) trec la Altium. Folosesc Altium la locul de muncă, așa că, în realitate, mi-a făcut lucrurile mai rapide. Proiectul Altium, fișierele schematice și pcb (și părțile bibliotecii) sunt pe site-ul meu. Placa are o formă trapezoidală și are o lungime de aproximativ 10 inci. Cred că ar fi trebuit să încerc să mai comprim schița ceva mai mult (următoarea rotire!) Asamblarea nu a fost rea, dar dacă vă permiteți, chiar vă recomand un fier de lipit decent (JBC Soldering Irons) și un microscop bun. Da, sunt răsfățat și nu, nu am astfel de lucruri în laboratorul meu de acasă. Sunt ieftin.

Am făcut scândurile la Sunstone. 129 USD pentru două plăci. Tura garantată de o săptămână. Nu scrimp pe transport, totuși. Nu am observat că am folosit UPS sol și am ajuns să aștept o săptămână în plus pentru sosirea plăcilor mele. Timpul total de asamblare a fost de aproximativ 2 ore (98 părți).

Pasul 6: Moriți tastatura

Trebuie să frezăm tastatura pentru a face găuri în locațiile necesare și pentru a crea buzunare pentru placă și LED-uri.

Am creat un model 3D al tastaturii completate în Solidworks și am creat rutina de frezare CNC folosind FeatureCAM.

Partea inferioară a tastaturii (cea mai apropiată de gaura de sunet) va trebui să fie mai subțire pentru a ține cont de schimbarea treptelor în înălțime între gât și corp. Merită cu siguranță montarea testului de mai multe ori pentru a fi sigur că este o potrivire rezonabilă.

Retrospectiv, ar fi trebuit să tai părțile nefolosite ale tastaturii pentru a o face să se potrivească mai bine cu moara (moara mea ieftină avea doar o cursă de 12 pe axa X). Ordinea operațiunilor ar trebui setată la prima ajustare a grosimii morii înainte de buzunare de frezare, care ar trebui să conducă la mai puține rupturi între buzunare.

Efectuați ajustările manuale după cum este necesar pentru a adăuga spațiu pentru cablare. Un lucru important de remarcat este că, în unele buzunare, am pătruns în slotul în care va trece firul de fret. Având în vedere că este un dirijor, asigurați-vă că nu ajunge să scurtcircuiteze nimic important. De asemenea, scade rezistența materialului care ține freta în poziție. Designul trebuie modificat pentru a nu se intersecta niciodată cu un slot pentru fret.

Pasul 7: Găuri de acces la moară în corpul ukulelelor

Am frezat manual găurile de acces din corp. Cel mai greu este să găsești regiunea „cea mai plată” din ceea ce este o suprafață foarte curbată. Marcați conturul în creion și măcinați treptat materialul până când veți obține o potrivire perfectă pentru afișajul OLED. Am obținut o ramă de alamă prelucrată și am atașat-o folosind bandă de lipire VHB 3M.

Deoarece niciuna dintre acestea nu necesită o precizie mare, codificatorul rotativ și orificiile panoului de acces sunt mult mai ușor de creat.

Pasul 8: Faceți plăci de acoperire

De asemenea, trebuie să fabricați plăcile de acoperire pentru cadrul afișajului și panoul de acces. Panoul de acces are nevoie de o gaură (dreptunghiulară) pentru conectorul USB (micro). Folosiți conectorul existent pe Arduino, deoarece nu există multe opțiuni de montare pe panou pentru micro USB. (deși dacă aș proiecta de la zero, aș arunca unul dintre acestea)

Pentru a ține placa în poziție, formați consolele L din alamă și lipiți-le pe partea din spate a plăcii de acces. Acest lucru vă permite o anumită latitudine în poziționare. Pentru a obține o poziționare corectă, creați mai întâi o placă de montare pentru perfboard (cu găuri de montare) pentru Arduino MICRO și atașați consolele L la acesta folosind 2-56 șuruburi pentru mașină. Puteți apoi să modificați locația pentru a alinia portul USB și să marcați cu exactitate locațiile pentru parantezele de pe placă. Scoateți parantezele de pe panoul de perfecționare și lipiți-le în poziție. În cele din urmă montați ansamblul perfboard.

Am folosit patru șuruburi mici din alamă pentru a menține panoul de acces din alamă în poziție.

În acest moment recomand o potrivire de test înainte de începerea asamblării finale. Acest pas este opțional, dar recomandat. Este mult mai ușor să faceți ajustări înainte de lipire.

Pasul 9: Atașați firele la PCB; Conectați și testați electronica

Nu atașați încă permanent aparatele electronice. Atașați firele la PCB, asigurându-vă că lăsați suficient spațiu pentru a direcționa orificiul de acces. Acestea în cele din urmă trebuie atașate permanent la placa Arduino MICRO (fotografiile arată un Arduino UNO, pe care l-am folosit pentru dezvoltarea codului)

Pasul 10: Atașați gâtul la corpul ukulelelor

Atașați gâtul la corpul Ukulele urmând instrucțiunile incluse în kitul Ukulele. Urmăriți în special alinierea suprafeței tastaturii cu corpul uke-ului.

Pasul 11: găuriți un orificiu de acces pentru a trece firele PCB în corp

Odată ce lipiciul este uscat, găuriți o gaură de ~ 1/4 (10 mm) într-un unghi pentru a permite firelor de la PCB să treacă în corpul Ukulele. Asigurați-vă că nu deteriorați placa de sunet.

Poate fi necesar să creați și un buzunar mic pentru a permite grosimea firelor de sub placă (sau, opțional, puneți conexiunile pe partea de sus și includeți relief în tastatură).

O altă potrivire de test nu ar strica în acest moment.

Pasul 12: Aliniați și lipiți PCB-ul și tastatura pe gât

Vă sugerez să vă gândiți prin prindere (și să o încercați!) Înainte de a lipi. Poate doriți să configurați un bloc în formă de partea inferioară a gâtului pentru a vă oferi o suprafață plană de prindere. Fretboard-ul este mai mare decât gâtul în acest moment, deci trebuie să permiteți acest lucru.

Aveți mare grijă să nu obțineți epoxid pe nicio suprafață pe care doriți să o terminați mai târziu. Mai bine, aplică mascare pe toate suprafețele fără lipire înainte de a lipi pentru a te asigura că merge doar acolo unde ți-ai propus.

Folosiți epoxidic cu o durată de lucru de minimum 60 de minute … veți avea nevoie de toate acestea.

Lipiți mai întâi PCB-ul în loc, asigurându-vă că excesul de adeziv nu extrudează în suprafața de lipire a tastaturii. Aceasta oferă o metodă de a alinia tastatura la gât. PCB-ul are un finisaj neted de mască de lipit, așa că l-am aspru cu un pic de hârtie de șlefuit pentru a oferi epoxidului un finisaj superficial ușor îmbunătățit.

Aliniați și lipiți tastatura de gât. Aveți grijă să nu lăsați buzunare care pot deveni ulterior rezonante (buzz!). De asemenea, aveți grijă să nu obțineți adeziv pe suprafețele cu LED-uri.

Odată ce lipiciul este uscat, poate doriți să conectați și să testați electronica încă o dată. Un LED rău te va face să urăști viața. Am avut un LED rău (primul!) Pe prototip și a trebuit să fac niște lucrări de lemn creative pentru a accesa LED-ul defect și a-l repara curat.

Pasul 13: Nivelați marginile tastaturii la gât și adăugați fire de fret

Odată ce lipiciul este uscat, puteți începe să terminați marginile. Am tăiat cu atenție excesul de fretboard (folosind o moară) și am terminat ultimul milimetru prin șlefuire manuală.

Adăugarea firelor fretului se poate face pur și simplu cu un ciocan (cu o față de plastic pentru a evita deteriorarea). Doar nu ciocăni prea tare. Dacă ați asociat firul fretului cu sloturile, acestea ar trebui să intre fără mari dificultăți.

Lucrul pe care trebuie să-l urmăriți este ruperea suprafeței subțiri a buzunarului cu LED-uri. Pe prototip, am permis ca unele buzunare cu LED-uri (în apropierea celui de-al 12-lea fret, unde spațiul devine strâns) să se extindă în slotul pentru fret. Aceasta este o idee proastă, deoarece acest lucru creează un punct slab care poate (și s-a) fisurat odată cu introducerea firului fret.

Pasul 14: Aplicați mascare și aplicați Finish la ukulele

Mascați tastatura (nu se termină) și zona de lipire a podului și începeți să aplicați finisajul.

Când mascați zona podului, citiți instrucțiunile împreună cu kitul, apoi verificați de două ori lungimea scalei doar pentru a fi sigur. Kitul pe care l-am folosit pentru prototip a folosit lungimea greșită a scării și, prin urmare, a furnizat dimensiunile greșite pentru localizarea podului (dar a avut o notă pentru a verifica site-ul web pentru cele mai recente instrucțiuni!). Intestinul meu mi-a spus că este greșit, dar am acceptat orbește autoritatea.

Este întotdeauna mai bine să înțelegeți DE CE faceți ceva, decât să urmați orbește instrucțiunile.

Pentru finalizare, există o mulțime de tutoriale de la Luthiers care știu ce fac pe web, așa că vă recomand să le consultați înainte de a intra în procesul de finisare.

Eu, desigur, nu am făcut asta, așa că am ajuns să folosesc un sigilat greșit, rezultând o suprafață foarte granuloasă. Nu face asta.

Fă-ți tema.

Pasul 15: Aliniați și atașați podul

Acest pas este destul de simplu, dar, din nou, planificați-vă metoda de prindere și încercați-o în avans înainte de lipire. Am folosit un lipici standard pentru lemn pentru a atașa podul.

Pasul 16: Instalați electronice și testați

Acum este momentul să vă faceți cablurile frumoase. În plus, nu doriți ca acesta să curgă în interiorul corpului și să facă zgomote sau mai rău, totuși, să se rupă pe scenă.

Codul Arduino poate fi actualizat prin portul USB, deci nu este nevoie să-l dezlipi decât dacă vrei să te joci.

Pasul 17: Instalați tunere și legați instrumentul

De asemenea, va trebui probabil să nivelezi fretele și să te joci puțin cu setarea, dar de ce să-ți faci griji acum, când ești atât de aproape de final?

Am actualizat tunerele și am folosit corzi Aquila frumoase, care nu au ajutat niciun sunet. Așadar, ține cont de asta în timp ce scoți bani într-un ukulele de proiect …

Pasul 18: Programarea Uke

Codul final Arduino este pe Github. Există câteva linii în cod pentru a sprijini îmbunătățirile viitoare (cum ar fi o funcție de metronom și „glisante” pentru afișaj (un element de interfață care arată ca un glisor)

Acest cod utilizează o bibliotecă de codificare rotativă (Biblioteca de codificare rotativă Arduino) pentru a gestiona intrările utilizatorului de la codificatorul rotativ.

De asemenea, folosește biblioteca Adafruit Neopixel și codul de exemplu aflat aici. Modurile teatru și curcubeu sunt derivate din exemple furnizate împreună cu biblioteca. (vezi strandtest.ino).

Driverul de afișare este furnizat de sistemele 4D și se găsește aici pe Github.

Există două funcții unice implementate pentru proiectul Ukulele. Primul implementează biblioteca de acorduri, iar al doilea afișează un mesaj text cu defilare utilizând un set de caractere personalizat.

Diagrama atașată arată locațiile LED-ului tastaturii și modul în care acestea sunt conectate. LED-ul 0 este situat în colțul din dreapta sus.

Pasul 19: Cum să afișați un acord

Funcția displayChord afișează pozițiile degetelor (prima poziție doar pentru moment) pentru fiecare coardă. Acordurile selectate de utilizator (nota rădăcină și calitatea) sunt stocate ca o pereche de indici. La rândul lor, acestea sunt folosite pentru a căuta degetele pentru fiecare coardă.

Am folosit notația „GCEA” pentru a stoca acorduri (de ex. „A” este „2100”). Acordurile sunt precalculate pentru fiecare notă rădăcină și stocate într-o variabilă corespunzătoare calității acordului. (deci, A major, este stocat în prima locație a matricei "majorChords", corespunzător "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 "};

Rețineți că, deoarece acesta este un șir de text, fiecare cifră ar putea reprezenta, de asemenea, o valoare hexagonală pentru a contura pozițiile fretului mai mari de 9. Adică, A și B ar reprezenta LED-urile 10 și 11. Pentru acordurile de primă poziție, aceasta nu a fost o problemă).

Șirul cu LED-uri este conectat longitudinal în rânduri de 12 (o octavă) de-a lungul fiecărui șir (începând cu șirul A), cursa ulterioară de 12 începe de la primul fret al șirului următor (vezi diagrama de la pasul 18). Acest lucru este important pentru algoritmul de a determina ce lumini să se aprindă pentru o coardă dată. Asta înseamnă că pixelii de la 0 la 11 sunt LED-urile șirului A, 12 până la 23 sunt LED-urile șirului E și așa mai departe. Când analizați un A = "2100" (stocat ca un șir, există și un terminator nul "\ n" în cod), îl interpretăm ca: nu sunt aprinși pixeli pe șirul A și nici pe șirul E, pixel 0 (fret 1) pe șirul C este aprins și pixelul 1 (fret 2) pe șirul G. Rețineți că un „0” este oprit, nu primul LED. Pe baza cablării, dorim să aprindem LED-urile 24 și 37. Codul pentru afișarea unui acord este prezentat mai jos.

for (int i = 0; i <4; i ++) {if (int (acord - '0')) {// algoritm pentru a analiza șirul acordului int ledNumber = int (acord - '0') + (3 - i) * 12 - 1; // vezi discuția de mai sus, (3-i) este să inverseze indexul strip.setPixelColor (ledNumber, 0, 125, 125); // setPixelColor (ledNumber, valoare roșie, valoare verde, valoare albastră)}}

Instrucțiunea if verifică dacă ledul este dezactivat. Dacă nu este, atunci ia valoarea ascii a caracterului, coarda și scade valoarea ascii pentru '0' pentru a obține ledNumber să se aprindă.

strip este o instanță a clasei Adafruit_NeoPixel. Funcția setPixelColor setează culoarea pixelului calculat (fixat la (0, 125, 125) în acest caz.

Pasul 20: Cum se afișează un mesaj derulant

Deci, avem o gamă de 12 x 4 LED-uri … de ce să nu-l facem să afișeze altceva decât modele de lumină destul de aleatorii!

Prima problemă este că înălțimea afișajului (4) este destul de limitată din cauza numărului de șiruri de pe un Uke. Derularea orizontală ar fi în mare parte ilizibilă, dar în orientări verticale, putem suporta 4 x 5 caractere care rulează vertical.

Organizarea caracterelor ca cinci rânduri „verticale” înseamnă că două caractere pot fi afișate simultan, permițând un spațiu pe o linie între fiecare caracter.

Dificultatea era că nu exista un set standard de caractere 4 x 5. Mi-am făcut-o folosind foaia de calcul atașată. Am atribuit fiecărui rând o singură valoare hexagonală (4 biți reprezentând care pixel este pornit sau oprit). Combinația celor cinci valori hex constituie un caracter (de exemplu, „0” este 0x69996).

Valorile pentru fiecare caracter sunt stocate într-o matrice în ordine ASCII. Setul de caractere face unele compromisuri cu anumite litere, dar majoritatea sunt destul de clare. (mâzgălitul din partea de jos a foii de calcul sunt idei cu care mă jucam, deoarece avem opțiunea de culoare, putem adăuga „adâncime” personajului și, eventual, putem obține o rezoluție suplimentară.

Șirul afișat este conținut în variabila șir, mesaj.

Este creat un buffer pentru a reprezenta afișarea caracterelor. Cred că aș fi putut crea pur și simplu un buffer mare cu întreaga secvență de mesaje traduse, mai ales că majoritatea mesajelor vor avea mai puțin de 20 de caractere sau cam așa ceva. Cu toate acestea, am ales în schimb să creez un tampon fix cu trei caractere (18 octeți). Doar două dintre personaje sunt afișate în mod activ, iar al treilea este o privire înainte, unde este încărcat următorul caracter. Șirul LED (gândiți-vă la acesta ca la un registru de schimbare mare) este încărcat cu cei 48 de biți pentru șir. Am risipit niște spațiu de memorie pentru a face acest lucru mai ușor de conceptualizat. Fiecare nibble primește propria locație de memorie, dublând cerința de memorie, dar nu prea este dată având dimensiunea bufferului.

Tamponul este încărcat cu următorul caracter când indexul de ieșire (pointer) ajunge la o limită de caractere (outputPointer la 5, 11 sau 17).

Pentru a încărca bufferul, apucăm primul caracter din „mesaj” ca valoare ASCII și scădem 48 pentru a obține indexul în matricea asciiFont. Valoarea la acel indice este stocată în codedChar.

Prima parte a mesajului deplasată corespunde LED-urilor 47, 35, 23 și 11 (partea de jos a afișajului). Deci, pentru numărul zero 0x0F999F, F (stânga) este deplasat în primul, 9 secunde și așa mai departe.

Următorul caracter este încărcat mascând fiecare ciugulit și deplasându-l spre dreapta. Pentru exemplul de mai sus, algoritmul dă (0x0F999F și 0xF00000) >> 20, apoi (0x0F999F și 0x0F0000) >> 16 etc.

int index; if (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) {char displayChar = message.charAt (messagePointer); // apucați primul caracter al mesajului lung codificatChar = asciiFont [displayChar - 48]; if (displayChar == 32) codedChar = 0x000000; messageBuffer [bytePointer + 5] = octet ((codedChar & 0xF00000) >> 20); // mascați toate, cu excepția ultimului nibble și schimbați-l cu 20 (și așa mai departe) messageBuffer [bytePointer + 4] = byte ((codedChar & 0x0F0000) >> 16); // acest lucru ar trebui să pună o ciugulire pentru fiecare locație de memorie messageBuffer [bytePointer + 3] = byte ((codedChar & 0x00F000) >> 12); // toate cele șase reprezintă caracterul messageBuffer [bytePointer + 2] = octet ((codedChar & 0x000F00) >> 8); messageBuffer [bytePointer + 1] = octet ((codedChar & 0x0000F0) >> 4); messageBuffer [bytePointer] = octet ((codedChar & 0x00000F)); if (bytePointer == 0) {// gestionează bucla de pe bytePointer bytePointer = 12; } else {bytePointer - = 6; // umplem de jos în sus; NOTĂ: trebuie să ne uităm la inversarea acestui lucru pentru a vedea dacă este mai ușor} if (messagePointer == message.length () - 1) {// manevrează bucla în jurul mesajului messagePointer = 0; } else {messagePointer + = 1; // trece la următorul caracter}}

Odată ce bufferul este încărcat, acesta devine o chestiune de urmărire unde se află indicatorul de ieșire și de încărcare a șirului de LED-uri cu 48 de biți corecți (actualul 4 și anterior 44). După cum sa menționat anterior, strip este o instanță a clasei NeoPixel și setPixelColor stabilește culoarea (RGB) a fiecărui pixel. Funcția show () schimbă valorile afișate în șir de LED-uri.

// bucla pentru a deplasa continuu bufferul

// doriți să scrieți întreaga bandă pe fiecare trecere prin buclă, doar locația de pornire se modifică pentru (int rând = 12; rând> 0; rând -) {index = outputPointer + (12-rând); if (index> 17) index = outputPointer + (12 rânduri) -18; // bucla dacă este mai mare de 17 pentru (int coloană = 4; coloană> 0; coloană -) {strip.setPixelColor (uint16_t (12 * (coloana-1) + (rând-1)), uint8_t (RedLED * (bitRead (messageBuffer [index], coloana-1))), uint8_t (GreenLED * (bitRead (messageBuffer [index], coloana-1))), uint8_t (BlueLED * (bitRead (messageBuffer [index], coloana-1))))); // la fiecare locație aprindeți LED-ul dacă bitul este unul}} // outputPointer indică cel mai mic octet curent din șirul de afișare dacă (outputPointer == 0) outputPointer = 17; else outputPointer - = 1; strip.show (); }

Pasul 21: Uimeste lumea cu Ukulele Awsomeness

Prototipul final al Ukulele a durat aproximativ 6 luni de porniri și opriri pentru a se retrage.

O mulțime de noi tehnologii de învățat și poate ceva teorie de prelucrare a lemnului și muzicală!

Ce trebuie să faceți pentru următoarea versiune?

1. Scăpați de afișaj și de codificatorul rotativ. Înlocuiți-le cu un modul Bluetooth atașat la arduino. Controlați-l de la distanță folosind un telefon sau o tabletă. Totul este mai bun cu Bluetooth.
2. Actualizați de la distanță modelele de acorduri în timp real. Ceva cel mai bine a rămas pentru aplicație.
3. Huse LED. Versiunea actuală nu face nimic pentru a împiedica pătrunderea gunoiului în găurile LED. Un prieten a făcut o grămadă de lentile mici, dar niciodată nu mi-am putut da seama cum să-i fac să rămână pe loc în mod corespunzător.
4. Materiale alternative pentru tastatură, poate ceva clar atâta timp cât stă fretele.
5. Mai multe lumini! Eliminați constrângerea textului adăugând mai multe „rânduri”. Aceasta este într-adevăr o limitare cauzată de dimensiunea tastelor și a corpurilor cu LED-uri.

Din nou, consultați instrumentul însoțitor care descrie setul de caractere pe care a trebuit să îl creez pentru a permite derularea textului.

Mulțumesc mult că ați ajuns până aici! Mahalo!