Paano Bumuo ng isang Light-up Ukulele !: 21 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:12

Naglalaro ako ng Ukulele. Kinda mediocre-ly (kung salita iyon) kaya naisip ko, "kung talagang gusto mong mapahanga ang mga kababaihan, kailangan mo ng paraan upang maabala sila mula sa kapahamakan na naglalaro sa entablado." Samakatuwid ang "Light-up Ukulele" ay isinilang.

Ang proyektong ito ay tumatagal ng isang kit ng Concert Ukulele at nagdaragdag ng isang Arduino na kinokontrol na LED sa bawat posisyon ng string at fret. Nagdadagdag din ito ng isang magarbong display ng OLED at umiikot na encoder batay sa interface ng gumagamit upang piliin ang mode at intensity ng LED string.

Ang nakumpletong mga tampok na hardware ng uke:

1. Arduino MICRO upang mag-interface sa LED string, display at input device.
2. 48 na indibidwal na napaprograma na buong mga kulay ng LED
3. Isang OLED display
4. Isang rotary encoder para sa pag-input ng gumagamit
5. USB interface para sa panlabas na lakas at Arduino program

Ang uke software ay may:

1. Pangunahing mga mode ng kontrol sa ilaw na nagpapatakbo ng mga LED sa pamamagitan ng kanilang mga bilis
2. Isang nakakatawang teatro marquee mode (napaka madaling gamiting para sa mga pagtatanghal!)
3. Pagkontrol ng intensidad ng LED
4. Isang buong aklatan ng chord ng lahat ng mga unang posisyon ng Ukulele chords (halaga ng chord at character)
5. Kakayahang ipakita ang tumatakbo na teksto (patayo) gamit ang isang natatanging 4 x 6 pixel na hanay ng character

Inilalarawan ng itinuturo na ito ang kumpletong prototype. Ang buong saga ng pag-unlad ay magagamit DITO, kasama ang ilang mga pang-edukasyon (masakit) na pagkakamali at isang mahalagang aralin kung bakit DAPAT mong tapusin ang iyong unang disenyo hanggang sa makumpleto (gaano man kakakuha ang mga pangit na bagay). Hindi mo alam ang lahat ng mga bagay na talagang hindi mo alam hanggang sa makarating ka sa katapusan (at pagkatapos ay hindi mo pa rin alam!), Ngunit mas mahusay ka at mas matalino para sa susunod na disenyo.

Itinayo ko ang prototype sa paligid ng isang Grizzly Concert Ukulele kit. Ang pagsisimula sa isang kit ay pinapawi ang pag-aalala tungkol sa katawan ng uke (mabuti, karamihan), at inaalis ang karamihan sa totoong gawaing uri ng luthier. Ang mga kit na ito ay medyo kumpleto at hindi ganon kamahal sa grand scheme ng mga bagay (at hindi gaanong masakit dahil magkakamali ka).

Hakbang 1: Gumawa ng isang Plano

Ang fretboard (o fingerboard) na kasama sa ilang mga kit ay mayroon nang nakakabit na mga fret. Mabuti / masama iyon. Maganda bilang isang tagatipid ng oras, ngunit sa mga tuntunin ng paglalagay ng isang pattern ng drill at hawakan ito sa lugar habang nagpapaikut, ito ay isang maliit na sakit. Matapos sirain ang ibinigay sa kit, nagpasyang sumali ako (mabuti, wala akong ibang pagpipilian maliban sa pagbili ng isa pang kit) upang bumili ng bagong fretboard.

Kapag ang pagdidisenyo ng fretboard, kailangan nating kalkulahin ang pagtaas ng kapal na kinakailangan upang mai-embed ang PCB at ang mga LED (at huwag kalimutan ang mga passive na bahagi), ngunit hindi gaanong ang mga LED ay masyadong malayo mula sa ibabaw ng fretboard.

Ang LED naka-print circuit board (PCB) ay dinisenyo bilang isang simpleng 2 layer board. Malaki ang naitutulong nito sa pagpupulong ng kamay ng LED string at nagbibigay ng ilang lakas na mekanikal (ito ay fiberglass at epoxy) sa leeg ng Ukulele. Sinimulan ko ang layout sa Eagle, ngunit nagtapos sa paggamit ng Altium Designer dahil sa mga limitasyon sa laki ng board. Ang Altium eskematiko at PCB file ay narito.

Ang kit fretboard ay isang 0.125 pulgada lamang ang kapal. Kaya, sa pag-aakalang isang 0.062 pulgada na makapal na PCB at pinapayagan ang isang karagdagang 0.062 pulgada para sa mga LED, nangangahulugan na kailangan nating gupitin (tulad ng lahat) ng fretboard. Upang mabayaran maaari naming alinman sa bahagyang i-cut ang mga bulsa para sa mga LED sa fretboard na may kaukulang bulsa sa leeg para sa PCB, o maaari nating palitan ang buong fretboard (ang pagpipiliang sumama ako) sa isang mas makapal na bersyon mula sa Luther Mercantile International (LMII), na kung saan ay 0.25 pulgada upang magsimula.

NGUNIT, tandaan na kakailanganin mo ring i-machine ang leeg upang mabayaran ang pagtaas ng kapal sa fretboard. Ang iba pang kalamangan na nakukuha mo ay kosmetiko, dahil ang PCB ay kumpleto na ngayong naka-embed sa loob ng fretboard na ginagawang mas madali ang mga gilid upang matapos (at mas maganda ang hitsura!) At pinapasimple ang paggiling ng leeg.

Mga bagay sa engineering (huwag pansinin kung nais mo):

Sa pamamagitan ng paraan, hindi talaga ito nakompromiso ang tigas ng leeg. Ang materyal ng PCB ay mas matigas kaysa sa orihinal na kahoy na fretboard (Mahogany modulus: 10.6 GPa kumpara sa FR4 modulus: 24 GPa), plus dahil nagtatayo kami ng isang Ukulele, walang isang malaking halaga ng pag-igting ng string na maaaring ibaluktot (i-twist o warp) ang leeg.

Ang isang napaka-kagiliw-giliw na pagsasaalang-alang (na marahil ay dapat ko pa ring kalkulahin) ay kung ano ang nangyayari sa paglipas ng temperatura. Pangkalahatan para sa kahoy, kahanay ng butil, ang thermal coefficient ng paglawak ay halos 3 x 10 ^ -6 / K, at para sa FR4 ay 14 × 10 ^ −6 / K. Kaya, mayroong isang makabuluhang pagkakaiba. Ang pag-aalala ay ang pag-igting ay nilikha sa leeg habang nag-iiba ang temperatura, na kung saan ay de-tuning ang mga string. Iyon ay isang bagay na maaaring mabayaran sa pamamagitan ng paglalapat ng isang katulad na layer sa kabaligtaran ng neutral na axis o sa pamamagitan ng pagkuha ng FR4 na mas malapit hangga't maaari sa walang kinikilingan na axis. Ngunit iiwan iyon para sa 2.0 … Isang bagay na dapat i-modelo at suriin.

Ang electronics ay nakalagay sa katawan ng uke. Ang mga butas ay pinutol sa sidewall (hindi ang soundboard!) Ng UKE upang bigyan ng puwang ang display at rotary encoder, kasama ang isang access plate upang hawakan ang Arduino Micro at magbigay ng access sa USB interface. Ang access plate / mount na disenyo at lokasyon ay maaaring mapabuti upang ang koneksyon ng USB ay lumabas sa isang mas maginhawang lokasyon, ngunit sa paninindigan nito, hindi ito gaanong masama, dahil wala ito sa paraan kapag naglalaro ka.

Ang balangkas ng mga hakbang ay ang mga sumusunod:

1. Ipunin ang mga materyales
2. Kunin ang mga tool na kailangan mo
3. Gilingin ang leeg upang mapaunlakan ang mas makapal na fretboard
4. Gilingin ang fretboard upang gumawa ng mga butas sa mga kinakailangang lokasyon at upang lumikha ng mga bulsa para sa board at LEDs
5. Kunin at buuin ang PCB na humahawak sa mga LED
6. Ang mga butas sa pag-access ng mill sa Ukulele body para sa OLED display, Rotary encoder, at access panel
7. Gumawa ng mga plate ng takip
8. Ikabit ang mga wire sa PCB; ikonekta at subukan ang electronics
9. Ikabit ang leeg sa katawan ng Ukulele
10. Mag-drill ng isang access hold upang maipasa ang mga wire ng PCB sa katawan
11. Pantayin at idikit ang PCB at fretboard sa leeg
12. I-level ang mga gilid ng fretboard sa leeg (alisin ang labis na materyal)
13. I-install ang mga fret wires
14. Mag-apply ng masking at ilapat ang tapusin sa Ukulele
15. Ihanay at ilakip ang tulay
16. Mag-install ng electronics at subukan.
17. Mag-install ng mga tuner at i-string ang instrumento
18. Programa ang Uke controller
19. Humanga ang mundo sa iyong kamangha-manghang Ukulele!

Hakbang 2: Magtipon ng Mga Materyales

Ganito ang aming listahan ng mga materyales:

1. Ukulele kit - Gumamit ako ng isang Grizzly Concert Ukulele kit (Grizzly Uke Kit sa Amazon), ngunit mukhang hindi na ipagpatuloy. Gumagawa ang Zimo ng isang katulad na modelo (Zimo Uke Kit @ Amazon) na mukhang gagawin nito ang trabaho
2. Ukulele fretboard, pre-slotted (LMII Uke Fingerboards). Ilalagay nila ang fretboard sa iyong scale, na nakakatipid ng gulo
3. Epoxy - para sa pagdikit ng fretboard sa leeg. Pinili ko ang epoxy dahil tugma ito sa materyal na PCB. Maghanap ng isang bagay na may hindi bababa sa 60 minuto ng buhay sa trabaho. HUWAG gumamit ng 5 minutong uri, kailangan mo ng oras upang magsagawa ng mga pagsasaayos
4. Fret wires - magagamit din mula sa LMII
5. Pasadyang PCB - Narito ang mga file ng Altium. Nag-opt ako para sa normal na materyal na uri ng FR4. Ang mga board ng Flex (polyimide) ay magiging isang kawili-wili (kung mas mahal) na kahalili, dahil maaari silang maging mas payat
6. 48x Neopixel (SK6812) LEDs. Magagamit mula sa Adafruit at Digikey
7. 48x 0.1uF 0402 cap - mas malaki ang katanggap-tanggap, ngunit kailangan mong panoorin ang pagkakalagay
8. Ang hookup wire - hindi bababa sa 4 hanggang 6 na kulay upang maiwasan ang pagkalito, pangunahin ang ginamit kong 28 gauge wire. Panoorin ang drop ng DC sa mga koneksyon sa kuryente ng LED (parehong VCC at GROUND … na ang kasalukuyang kailangang bumalik sa pinagmulan!)
9. Rotary encoder - PEC16-4220F-S0024
10. Magarbong sahig na gawa sa kahoy - para sa rotary encoder (nakuha ko ang akin mula sa LMII)
11. OLED display - mula sa 4D system na ipinapakita ng OLED
12. Panlabas na baterya ng USB - mas mura sa lahat ng oras, kasama ang pagdadala ng mga ekstrang!
13. Arduino MICRO
14. Sheet tanso - upang gawin ang plato upang hawakan ang arduino at bezel para sa display
15. Mga sari-saring konsumo kabilang ang: papel de liha, tapusin ng urethane, mga stick ng popsicle, mga bandang goma, panghinang, pagkilos ng bagay, brushes, dobleng panig na tape (Gusto ko ang UHC tape ng 3M) at maliliit na tanso na mga woodscrew (para sa plato)
16. Opsyonal na mga pagpapahusay sa Ukulele - mas mahusay na mga tuner, mas mahusay na mga string, mas mahusay na nut at saddle, inlay kung nais mong ipakita ang iyong lakas ng luthier)

Hakbang 3: Kunin ang Mga Tool na Kailangan Mo

Maaga o huli ay kakailanganin mong makakuha o makakuha ng pag-access sa mga ito:

Kasama sa aming listahan ng mga tool ang:

1. Milling machine - Mas gusto ng CNC, ngunit maaari ka ring makadaan sa isang router at maraming kapalaran. Gumamit ako ng combo CNC mill / router
2. Mga bit ng router - ginustong karbid. Pinili ang mga router bit sa mga end mill dahil nagmemensa kami ng kahoy, hindi metal
3. Mga clamp - marami sa kanila. Kadalasan kailangan upang humawak ng mga bahagi habang nakadikit
4. Panghinang na bakal - maliit na tip para sa pang-mount na pag-solder
5. Mikroskopyo o magnifier - maaari mong subukang maghinang gamit lamang ang iyong mga mata, ngunit hindi ko ito inirerekumenda, 10x minimum
6. Mga tweeter (para sa paglalagay ng mga bahagi sa lugar)
7. Mga tool sa pag-fretting (tingnan ang wastong mga tool sa LMII dito, ngunit ginamit ko kung ano ang mayroon ako sa bahay at ginawang gawin; martilyo, mga file at pamutol)
8. Iba't ibang mga tool sa kamay tulad ng mga chisel ng kahoy, mga distornilyador, malambot na suntok o rawhide martilyo (para sa fretting), atbp.
9. Abrasives - iba't ibang mga grits ng liha

Kasama sa aming mga tool sa software (ang ilan ay opsyonal depende sa iyong badyet / talino sa paglikha):

1. Arduino software
2. Ang source code ng Ukulele (https://github.com/conrad26/Ukulele)
3. Pakete ng layout ng PCB - Gumamit ako ng Altium dahil ang libreng bersyon ng Eagle ay hindi suportado sa laki ng board na gusto ko. Ang Altium ay isang buong tampok na package ng layout at hindi talaga sa isang hobbyist na saklaw ng presyo. Isinama ko ang mga Gerber file sa aking site para sa prototype, ngunit tiyak na nangangailangan ito ng isang pag-update
4. 3D modeling software - Gumamit ako ng SolidWorks, ngunit ang isang libreng kahalili ay FreeCAD (https://www.freecadweb.org/)
5. CAM software - tulad ng FeatureCAM mula sa Autodesk para sa paglikha ng NC mill file.

Ang kumbinasyon ng pag-export ng file ng 3D na hakbang mula sa Altium kasama ang isang 3D na modelo ng fretboard ay tinatanggal ang labis na paghihirap na matiyak na ang lahat ay nakahanay, ngunit hindi ito isang kinakailangan. Maingat na layout ay makakamit ang parehong resulta.

Ngayong alam na natin kung ano ang nais nating gawin, at kung ano ang kailangan nating gawin, bumuo tayo ng isang Ukulele.

Hakbang 4: Gilingin ang Leeg upang Maipasok ang Mas Kapal na Fretboard

Bago ang paggiling, tandaan na ang orihinal na fretboard mounting ibabaw na flatness DAPAT mapanatili, o magkakaroon ka ng isang baluktot na fretboard, na hahantong sa lahat ng uri ng mga isyu sa fret leveling.

Huwag lamang pumunta doon, gawin ang iyong oras at maingat at mahigpit na i-clamp ang leeg at suriin ang pagkakahanay sa router bit sa buong leeg bago i-cut. Ang oras na ginugol dito ay makatipid sa iyo ng labis na kalungkutan sa paglaon.

Ang isang kadahilanan na pinili ko para sa isang mas makapal na fretboard sa isang inlay sa leeg ay ang nadagdagan na mounting (gluing) na ibabaw na lugar. Ang isa pang dahilan ay pinapasimple nito ang paggiling ng leeg. Kailangan mo lang i-cut ang buong ibabaw sa kinakailangang taas.

Hakbang 5: Kumuha at Bumuo ng PCB Hawak ang mga LED

Ini-solder ko ang buong pagpupulong. Ang mga LED na pakete ay lalong madaling matunaw, kaya't mag-ingat upang maiwasan ang pinsala sa mga ito. Iminumungkahi kong magsuot ng isang static strap, dahil ang string ay nakasalalay sa bawat LED na gumagana.

Ang disenyo ng Fretboard ay batay sa paligid ng WS2812B LEDs. Napagpasyahan kong gawin lamang ang unang oktaba ng fretboard (48 LEDs !!). Ang bawat LED ay maaaring isipin bilang isang piraso sa isang shift register. Ang shift register ay naorasan sa 800 kHz. Ginamit ko ang Adafruit library (tingnan ang seksyon ng pagprogram) upang mabilis na maisagawa ang mga bagay.

Sinimulan ko ang disenyo sa Eagle, ngunit ang laki ng board ay limitado sa tulad ng 4 x 5 pulgada, kaya't kailangan kong (o higit na tama, pinili ko) na lumipat sa Altium. Gumagamit ako ng Altium sa trabaho, kaya sa totoo lang, mas mabilis itong nagawa para sa akin. Ang proyekto ng Altium, eskematiko at mga file ng pcb (at mga bahagi ng silid aklatan) ay nasa aking site. Ang board ay trapezoidal sa hugis at mga 10 pulgada ang haba. Sa palagay ko sinubukan ko sanang i-compress ang balangkas nang kaunti pa (susunod na paikutin!) Ang pagpupulong ay hindi masama, ngunit kung makakaya mo ito, talagang inirerekumenda ko ang isang disenteng bakal na panghinang (JBC Soldering Irons) at isang mahusay na mikroskopyo. Yeah, spoiled ako at hindi, wala akong ganoong klaseng bagay sa aking lab sa bahay. Mura ako.

Ginawa ko ang mga board sa Sunstone. $ 129 para sa dalawang board. Garantisadong isang linggong pagliko. Gayunpaman, huwag mag-scrimp sa pagpapadala. Hindi ko napansin na gumamit ako ng UPS ground at natapos kong maghintay ng dagdag na linggo para dumating ang aking mga board. Ang kabuuang oras ng pagpupulong ay halos 2 oras (98 bahagi).

Hakbang 6: Gilingin ang Fretboard

Kailangan naming gilingan ang fretboard upang gumawa ng mga butas sa mga kinakailangang lokasyon at upang lumikha ng mga bulsa para sa board at LEDs.

Lumikha ako ng isang 3D na modelo ng nakumpletong fretboard sa Solidworks at nilikha ang gawain sa paggiling ng CNC gamit ang FeatureCAM.

Ang ilalim na bahagi ng fretboard (pinakamalapit sa soundhole) ay kailangang gawing mas payat upang maituring ang pagbabago ng hakbang sa taas sa pagitan ng leeg at katawan. Tiyak na nagkakahalaga ng pagsubok na umaangkop nang maraming beses upang matiyak na ito ay isang makatuwirang angkop.

Sa paggunita, dapat ko nang putulin ang mga hindi nagamit na bahagi ng fretboard upang mas mahusay itong magkasya sa gilingan (ang aking murang galingan ay mayroon lamang 12 X-axis na paglalakbay). Ang pagkakasunud-sunod ng mga pagpapatakbo ay dapat na i-set up sa unang pag-aayos ng kapal ng gilingan bago paggiling pockets, na dapat humantong sa mas kaunting mga breakout sa pagitan ng mga pockets.

Gumawa ng mga manu-manong pagsasaayos kung kinakailangan upang magdagdag ng puwang para sa mga kable. Ang isang mahalagang bagay na dapat tandaan ay sa ilan sa mga bulsa, napasok ko ang puwang kung saan pupunta ang fret wire. Dahil sa isang konduktor iyon, tiyaking hindi ito nauuwi sa pagpapaikli ng anumang mahalaga. Binabawasan din nito ang lakas ng materyal na humahawak sa fret sa lugar. Ang disenyo ay dapat na mabago upang hindi kailanman intersect sa isang fret slot.

Hakbang 7: Mga Butas sa Pag-access ng Mill sa Ukulele Body

Manwal kong giniling ang mga butas sa pag-access sa katawan. Ang pinakamahirap na bahagi ay ang paghahanap ng rehiyon na "flattest" kung ano ang isang napaka-hubog na ibabaw. Markahan ang balangkas sa lapis at unti-unting magpapalayo ng materyal hanggang sa makakuha ka ng isang angkop para sa pagpapakita ng OLED. Nakuha ko ang isang makina ng isang bezel na tanso at ikinabit ito gamit ang 3M VHB bonding tape.

Dahil hindi nangangailangan ng mahusay na katumpakan, ang rotary encoder at pag-access ng mga butas ng panel ay mas madaling malikha.

Hakbang 8: Gumawa ng Mga Plato ng Takip

Kailangan mo ring gawin ang mga plate ng takip para sa display bezel at acess panel. Ang access panel ay nangangailangan ng isang butas (hugis-parihaba) para sa konektor ng USB (micro). Gamitin lamang ang mayroon nang konektor sa Arduino, dahil walang maraming mga pagpipilian sa pag-mount ng panel para sa micro USB. (bagaman kung nagdidisenyo ako mula sa simula, pagkatapos ay bibigyan ko ang isa sa mga ito ng hitsura)

Upang hawakan ang board sa lugar, ang mga fashion L bracket ay walang tanso at solder ang mga ito sa likuran ng access plate. Pinapayagan ka nitong may ilang latitude sa pagpoposisyon. Upang makuha ang tamang pagpoposisyon, lumikha muna ng isang perfboard mounting board (na may mounting hole) para sa Arduino MICRO at ilakip dito ang mga L bracket gamit ang 2-56 machine screws. Maaari mo nang mai-tweak ang lokasyon upang mai-line up ang usb port at tumpak na markahan ang mga lokasyon para sa mga braket sa plato. Alisin ang mga braket mula sa perfboard at solder ang mga ito sa lugar. Panghuli i-mount ang pagpupulong ng perfboard.

Gumamit ako ng apat na maliliit na screws ng kahoy na tanso upang hawakan ang panel ng pag-access ng tanso sa lugar.

Sa puntong ito inirerekumenda ko ang isang pagsubok na magkasya bago magsimula ang panghuling pagpupulong. Ang hakbang na ito ay opsyonal ngunit inirerekumenda. Napakadali na magsagawa ng mga pagsasaayos bago nakadikit.

Hakbang 9: Ikabit ang mga Wires sa PCB; Ikonekta at Subukan ang Elektronika

Huwag permanenteng ilakip ang electronics. Ikabit ang mga wire sa PCB, tiyakin na nag-iiwan ka ng sapat na katahimikan upang mailabas ang butas sa pag-access. Ang mga ito sa huli ay kailangang permanenteng nakakabit sa Arduino MICRO board (ang mga larawan ay nagpapakita ng isang Arduino UNO, na ginamit ko para sa pagpapaunlad ng code)

Hakbang 10: Ikabit ang Leeg sa Katawang Ukulele

Ikabit ang leeg sa Ukulele na katawan kasunod sa mga tagubiling kasama sa Ukulele kit. Partikular na panoorin ang pagkakahanay ng ibabaw ng fretboard sa katawan ng uke.

Hakbang 11: Mag-drill ng isang Access Hole upang Ipasa ang Mga Wire ng PCB Sa Katawan

Kapag ang kola ay tuyo, mag-drill ng isang ~ 1/4 (10mm) na butas sa isang anggulo upang payagan ang mga wire mula sa PCB na mag-ruta papunta sa katawan ng Ukulele. Tiyaking hindi masisira ang soundboard.

Maaaring kailanganin mong lumikha ng isang maliit na bulsa din upang payagan ang kapal ng mga wire sa ilalim ng board (o opsyonal na ilagay ang mga koneksyon sa itaas at isama ang kaluwagan sa fretboard.)

Ang isa pang pagsubok na fit ay hindi sasaktan sa puntong ito.

Hakbang 12: Ihanay at Idikit ang PCB at Fretboard sa Leeg

Iminumungkahi kong pag-isipan ang clamping (at subukan ito!) Bago nakadikit. Maaaring gusto mong mag-fashion ng isang bloke na hugis sa ilalim ng leeg upang bigyan ka ng isang patag na clamping ibabaw. Ang fretboard ay mas malaki kaysa sa leeg sa puntong ito, kaya kailangan mong payagan iyon.

Maging maingat na hindi makakuha ng epoxy sa anumang ibabaw na nais mong tapusin sa paglaon. Mas mahusay na maglagay ng masking sa lahat ng mga hindi nakadikit na ibabaw bago ka idikit upang matiyak na pupunta lamang ito sa kung saan mo nilayon.

Gumamit ng epoxy na may minimum na 60 minuto na buhay sa trabaho … kakailanganin mo ang lahat ng ito.

Idikit muna ang PCB sa lugar, siguraduhin na ang labis na pandikit ay hindi makakapagpunta sa ibabaw ng fretboard gluing. Nagbibigay ito ng isang pamamaraan upang ihanay ang fretboard sa leeg. Ang PCB ay may makinis na tapusin ng solder mask, kaya't hinugasan ko ito ng kaunting papel de liha upang bigyan ang epoxy ng isang bahagyang pinahusay na pagtapos sa ibabaw.

Pantayin at idikit ang fretboard sa leeg. Mag-ingat na huwag mag-iwan ng mga bulsa na maaaring maging resonant sa paglaon (buzz!). Mag-ingat din na hindi makakuha ng pandikit sa mga ibabaw ng LED.

Sa sandaling matuyo ang pandikit baka gusto mong mag-wire at subukan muli ang electronics. Ang isang masamang LED ay gagawa sa iyo ng galit sa buhay. Mayroon akong isang masamang LED (ang una!) Sa prototype at kailangan kong gumawa ng ilang malikhaing gawa sa kahoy upang ma-access ang may sira na LED at malinis itong i-patch.

Hakbang 13: I-level ang Fretboard Edges sa Leeg at Magdagdag ng Fret Wires

Kapag ang kola ay tuyo, maaari mong simulan ang pagtatapos ng mga gilid. Maingat kong pinutol ang labis na materyal na fretboard (gamit ang isang galingan) at natapos ang huling millimeter sa pamamagitan ng sanding ng kamay.

Ang pagdaragdag ng mga fret wires ay maaaring gawin lamang gamit ang martilyo (na may isang plastik na mukha upang maiwasan ang marring). Huwag lang masyadong martilyo. Kung naitugma mo ang fret wire sa mga puwang, dapat silang pumasok nang walang labis na paghihirap.

Ang bagay na kailangan mong panoorin ay ang pagsira sa manipis na ibabaw ng LED na bulsa. Sa prototype, pinayagan ko ang ilang mga LED pockets (malapit sa 12th fret, kung saan masikip ang puwang) upang mapalawak sa fret slot. Iyon ay isang masamang ideya, dahil lumilikha iyon ng isang mahinang lugar na maaaring (at nag-crack) kapag naipasok na ang fret wire.

Hakbang 14: Mag-apply ng Masking at Ilapat ang Tapusin sa Ukulele

Mask ang fretboard (hindi ito nakatapos) at ang lugar ng pagdikit ng tulay at simulang ilapat ang tapusin.

Kapag masking ang lugar ng tulay, basahin ang mga tagubilin sa iyong kit, pagkatapos ay i-double check ang haba ng sukat upang matiyak lamang. Ang kit na ginamit ko para sa prototype ay ginamit ang maling haba ng sukat at samakatuwid ay nagbigay ng mga maling sukat para sa paghahanap ng tulay (ngunit mayroon itong isang tala upang suriin ang website para sa pinakabagong mga tagubilin!). Sinabi sa akin ng aking gat na mali ito, ngunit bulag kong tinanggap ang awtoridad.

Palaging mas mahusay na maunawaan kung BAKIT gumagawa ka ng isang bagay, kaysa sa bulag na pagsunod sa mga tagubilin.

Para sa pagtatapos, maraming mga tutorial mula sa mga Luthier na alam kung ano ang ginagawa nila sa web, kaya inirerekumenda kong kumonsulta sa kanila bago tumalon sa proseso ng pagtatapos.

Siyempre, hindi ko ginawa iyon, kaya't sa wakas ay gumagamit ako ng maling sealer, na nagreresulta sa isang napaka butil na ibabaw. Wag mong gawin yan

Gawin mo ang iyong Takdang aralin.

Hakbang 15: Ihanay at Ilakip ang Bridge

Ang hakbang na ito ay medyo prangka, ngunit muli, planuhin ang iyong pamamaraang clamping at subukan ito nang maaga bago idikit. Gumamit ako ng isang karaniwang pandikit na kahoy upang ikabit ang tulay.

Hakbang 16: Mag-install ng Electronics at Test

Ngayon na ang oras upang pagandahin ang iyong mga kable. Dagdag nito ay hindi mo nais na ito ay flopping paligid sa loob ng katawan at gumawa ng mga buzzing ingay o mas masahol pa nasira sa entablado.

Ang Arduino code ay maaaring ma-update sa pamamagitan ng USB port, kaya talagang hindi na kailangang alisin ito maliban kung nais mong mag-tinker.

Hakbang 17: I-install ang mga Tuner at String the Instrument

Malamang kakailanganin mong i-level ang mga fret at maglaro nang kaunti sa pag-setup, ngunit bakit mag-alala ngayon, kung malapit ka na sa katapusan?

In-upgrade ko ang mga tuner at gumamit ng magagandang mga string ng Aquila, na hindi makakatulong sa tunog. Kaya't panatilihin iyon sa isip habang nagpapalabas ka ng pera sa isang proyekto ukulele …

Hakbang 18: Programming ang Uke

Ang huling Arduino code ay nasa Github. Mayroong ilang mga linya sa code upang suportahan ang mga pagpapahusay sa hinaharap (tulad ng isang pag-andar ng metronome at "mga slider" para sa display (isang elemento ng UI na mukhang isang slider)

Ang code na ito ay gumagamit ng isang Rotary Encoder Library (Rotary Encoder Arduino Library) upang mahawakan ang input ng gumagamit mula sa Rotary Encoder.

Gumagamit din ito ng Adafruit Neopixel library at halimbawa ng code na matatagpuan dito. Ang teatro at bahaghari mode ay nagmula sa mga halimbawang ibinigay sa silid-aklatan. (tingnan ang strandtest.ino).

Ang display driver ay ibinibigay ng mga 4D system at matatagpuan sa Github dito.

Mayroong dalawang natatanging mga pagpapaandar na ipinatupad para sa proyekto ng Ukulele. Ang una ay nagpapatupad ng chord library, at ang pangalawa ay nagpapakita ng isang pag-scroll na text message gamit ang isang pasadyang hanay ng character.

Ipinapakita ng naka-attach na diagram ang mga lokasyon ng fretboard LED at kung paano sila konektado. Ang LED 0 ay matatagpuan sa kanang sulok sa itaas.

Hakbang 19: Paano Magpakita ng Chord

Ipinapakita ng pagpapaandar ng displayChord ang mga posisyon ng daliri (unang posisyon lamang sa ngayon) para sa bawat chord. Ang mga chord na pinili ng gumagamit (root note at kalidad) ay nakaimbak bilang isang pares ng mga indeks. Ang mga ito naman ay ginagamit upang tingnan ang mga daliri para sa bawat chord.

Gumamit ako ng notasyong "GCEA" upang mag-imbak ng mga chord (hal. "A" ay "2100"). Ang mga chord ay paunang kinakalkula para sa bawat tala ng ugat at nakaimbak sa isang variable na naaayon sa kalidad ng chord. (sa gayon, Isang pangunahing, ay nakaimbak sa unang lokasyon ng array na "majorChords", na naaayon sa "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 "};

Tandaan na dahil ito ay isang string ng teksto ang bawat digit ay maaari ring kumatawan sa isang hex na halaga sa account para sa mga posisyon na fret na higit sa 9. Iyon ay, ang A at B ay kumakatawan sa LEDs 10 at 11. Para sa mga chord ng unang posisyon, hindi ito isang isyu).

Ang LED string ay naka-wire pahaba sa mga hilera ng 12 (isang oktaba) kasama ang bawat string (nagsisimula sa isang string), ang kasunod na pagpapatakbo ng 12 ay nagsisimula sa unang fret ng susunod na string (tingnan ang diagram sa hakbang 18). Ito ay mahalaga para sa algorithm upang matukoy kung aling mga ilaw ang bubuksan para sa isang naibigay na chord. Nangangahulugan iyon na ang mga pixel 0 hanggang 11 ay ang A string LEDs, 12 hanggang 23 ang mga E string LEDs, at iba pa. Kapag pinag-parse ang isang A = "2100" (naka-imbak bilang isang string, mayroon ding isang null terminator "\ n" sa code), binibigyang kahulugan namin ito bilang: walang mga pixel sa A string ang naiilawan, o sa E string, pixel 0 (fret 1) sa C string ay naiilawan at pixel 1 (fret 2) sa G string. Tandaan na ang isang "0" ay naka-off, hindi ang unang LED. Batay sa mga kable, nais naming sindihan ang mga LED 24 at 37. Ang code upang maipakita ang isang chord ay ipinapakita sa ibaba.

para sa (int i = 0; i <4; i ++) {if (int (chord - '0')) {// algorithm upang mai-parse ang chord string int ledNumber = int (chord - '0') + (3 - i) * 12 - 1; // tingnan sa itaas ang talakayan, ang (3-i) ay upang baligtarin ang index strip.setPixelColor (ledNumber, 0, 125, 125); // setPixelColor (ledNumber, pulang halaga, berde na halaga, asul na halaga)}}

Ang kung pahayag ay nagsuri kung pinangunahan ay naka-off. Kung hindi pagkatapos ay aabutin ang halaga ng ascii ng character, chord , at ibabawas ang halaga ng ascii para sa '0' upang makuha ang ledNumber upang magaan.

Ang strip ay isang halimbawa ng klase ng Adafruit_NeoPixel. Ang pagpapaandar ng setPixelColor ay nagtatakda ng kulay para sa kinakalkula na pixel (naayos sa (0, 125, 125) sa kasong ito.

Hakbang 20: Paano Magpapakita ng Mensahe sa Pag-scroll

Kaya mayroon kaming 12 x 4 na hanay ng mga LED … bakit hindi ito ipakita sa ibang bagay kaysa sa medyo random na mga pattern ng ilaw!

Ang unang isyu ay ang taas ng display (4) ay sa halip limitado dahil sa bilang ng mga string sa isang Uke. Ang pahalang na pag-scroll ay halos hindi nababasa, ngunit sa isang patayong orientation, maaari naming suportahan ang 4 x 5 na mga character na tumatakbo nang patayo.

Ang pag-aayos ng mga character bilang limang "patayong" mga hilera ay nangangahulugang ang dalawang mga character ay maaaring ipakita nang sabay-sabay na nagpapahintulot sa isang linya ng isang puwang sa pagitan ng bawat character.

Ang hirap nito ay walang standard na 4 x 5 character set. Gumawa ako ng sarili gamit ang kalakip na spreadsheet. Itinalaga ko ang bawat hilera sa isang solong halaga ng hex (4 na bit na kumakatawan sa aling pixel ang naka-on o naka-off). Ang kumbinasyon ng limang halagang hex ay bumubuo ng isang character (hal. "0" ay 0x69996).

Ang mga halaga para sa bawat character ay nakaimbak sa isang array sa ASCII order. Ang hanay ng tauhan ay gumagawa ng ilang mga kompromiso sa ilang mga titik, ngunit ang karamihan ay isang makatuwirang malinaw. (ang scribbling sa ilalim ng spreadsheet ay mga ideya na pinaglaruan ko dahil mayroon kaming kulay bilang isang pagpipilian, maaari kaming magdagdag ng "lalim" sa character at posibleng makakuha ng ilang resolusyon ng additonal.

Ang string na ipinapakita ay nakapaloob sa variable ng string, mensahe.

Ang isang buffer ay nilikha upang kumatawan sa pagpapakita ng character. Sa palagay ko ay nakalikha lamang ako ng isang malaking buffer na may buong isinalin na pagkakasunud-sunod ng mensahe, lalo na dahil ang karamihan sa mga mensahe ay mas mababa sa 20 mga character o higit pa. Gayunpaman, pinili ko sa halip upang lumikha ng isang nakapirming tatlong character (18 bytes) buffer. Dalawa lamang sa mga character ang aktibong ipinapakita, at ang pangatlo ay isang pagtingin sa unahan, kung saan na-load ang susunod na character. Ang LED string (isipin ito bilang isang malaking rehistro ng paglilipat) ay puno ng 48 na mga piraso para sa string. Sinayang ko ang ilang puwang ng memorya upang mas madali itong ma-konsepto. Ang bawat nibble ay nakakakuha ng sariling lokasyon ng memorya, pagdodoble ng kinakailangan sa memorya, ngunit hindi gaanong naibigay ang laki ng buffer.

Ang buffer ay na-load ng susunod na character kapag ang output index (pointer) ay nakakakuha sa isang character na hangganan (outputPointer sa 5, 11, o 17).

Upang mai-load ang buffer, kukunin namin ang unang character sa "mensahe" bilang isang halaga ng ASCII at ibawas ang 48 upang makuha ang index sa array ngFontFont. Ang halaga sa index na iyon ay nakaimbak sa codedChar.

Ang unang bahagi ng mensahe ay lumipat na tumutugma sa LEDs 47, 35, 23, at 11 (sa ilalim ng display). Kaya para sa bilang na zero 0x0F999F, ang F (kaliwang isa) ay inilipat sa una, 9 segundo at iba pa.

Ang susunod na character ay na-load sa pamamagitan ng masking bawat nibble at paglilipat nito sa kanan. Para sa halimbawa sa itaas, nagbibigay ang algorithm (0x0F999F & 0xF00000) >> 20, pagkatapos (0x0F999F & 0x0F0000) >> 16, atbp.

int index; kung (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) {char displayChar = message.charAt (messagePointer); // grab the first character of the message long codedChar = asciiFont [displayChar - 48]; kung (displayChar == 32) naka-codeChar = 0x000000; messageBuffer [bytePointer + 5] = byte ((codedChar & 0xF00000) >> 20); // mask all but the last nibble and shift it over by 20 (at iba pa) messageBuffer [bytePointer + 4] = byte ((codedChar & 0x0F0000) >> 16); // dapat itong maglagay ng isang nibble bawat lokasyon ng memorya ng messageBuffer [bytePointer + 3] = byte ((codedChar & 0x00F000) >> 12); // lahat ng anim na kumakatawan sa character messageBuffer [bytePointer + 2] = byte ((codedChar & 0x000F00) >> 8); messageBuffer [bytePointer + 1] = byte ((codedChar & 0x0000F0) >> 4); messageBuffer [bytePointer] = byte ((codedChar & 0x00000F)); kung (bytePointer == 0) {// hawakan ang loop sa paligid ng bytePointer bytePointer = 12; } iba pa {bytePointer - = 6; // pinupuno namin mula sa ibaba pataas; TANDAAN: kailangang tingnan ang pag-baligtarin nito upang makita kung ginagawang mas madali} kung (messagePointer == message.length () - 1) {// hawakan ang loop sa paligid ng message messagePointer = 0; } iba pa {messagePointer + = 1; // lumipat sa susunod na character}}

Kapag na-load na ang buffer, nagiging isang bagay sa pagsubaybay kung saan ang output pointer ay nasa at paglo-load ng LED string na may wastong 48 bits (ang kasalukuyang 4 at ang nakaraang 44). Tulad ng nabanggit dati, ang strip ay isang halimbawa ng klase ng NeoPixel at itinakda ng setPixelColor ang kulay (RGB) ng bawat pixel. Ang pagpapakita ng () pagpapaandar ay inililipat ang mga halaga ng pagpapakita sa LED string.

// loop upang patuloy na ilipat ang buffer

// nais na isulat ang buong strip sa bawat dumaan sa loop, ang panimulang lokasyon lamang ang nagbabago para sa (int row = 12; row> 0; row--) {index = outputPointer + (12-row); kung (index> 17) index = outputPointer + (12-row) -18; // loop kung mas malaki sa 17 para sa (int haligi = 4; haligi> 0; haligi--) {strip.setPixelColor (uint16_t (12 * (haligi-1) + (hilera-1)), uint8_t (RedLED * (bitRead (messageBuffer [index], haligi-1))), uint8_t (GreenLED * (bitRead (messageBuffer [index], haligi-1)), uint8_t (BlueLED * (bitRead (messageBuffer [index], haligi-1)))); // sa bawat lokasyon ay sindihan ang LED kung ang kaunti ay isang}} // outputPointer ay tumuturo sa kasalukuyang pinakamababang byte sa display string kung (outputPointer == 0) outputPointer = 17; iba pa ang outputPointer - = 1; strip.show (); }

Hakbang 21: Humanga ang Mundo Sa Iyong Ukulele Awsomeness

Ang huling prototype ng Ukulele ay tumagal ng halos 6 na buwan ng mga pagsisimula at humihinto upang mag-off.

Maraming mga bagong tech upang malaman at marahil ilang mga gawaing kahoy at teoryang musikal upang mag-boot!

Ano ang gagawin para sa susunod na bersyon?

1. Tanggalin ang display at rotary encoder. Palitan ang mga ito ng isang module ng Bluetooth na nakakabit sa arduino. Kontrolin ito nang malayuan gamit ang isang telepono o tablet. Ang lahat ay mas mahusay sa Bluetooth.
2. Malayo i-update ang mga pattern ng chord sa real time. Isang bagay na pinakamahusay na natitira para sa app.
3. Mga takip ng LED. Ang kasalukuyang bersyon ay walang ginagawa upang maiwasan ang gunk mula sa pagkuha sa mga LED hole. Ang isang kaibigan ay gumawa ng isang bungkos ng maliliit na lente, ngunit hindi ko malalaman kung paano sila makakapagpapanatili sa maayos na lugar.
4. Kahaliling mga materyales sa fretboard, marahil isang bagay na malinaw hangga't hawak ng mga fret.
5. Marami pang ilaw! Tanggalin ang pagpigil sa teksto sa pamamagitan ng pagdaragdag ng higit pang mga "row". Ito ay talagang isang limitasyon na sanhi ng laki ng fretboard at ng mga LED na katawan.

Muli, tingnan ang kasamang Makatuturo na naglalarawan sa itinakdang character na kinailangan kong likhain upang payagan ang pag-scroll ng teksto.

Maraming salamat sa paggawa nito sa ngayon! Mahalo!