Kuidas ehitada valgustatud Ukulele !: 21 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:47

Mängin Ukulelet. Veidi keskpärane (kui see on sõna), siis mõtlesin: "kui sa tõesti tahad daamidele muljet avaldada, siis on vaja vahendit, mis neid laval mängivast katastroofist eemale juhtiks." Nii sündis "Valgustatud Ukulele".

See projekt võtab Concert Ukulele komplekti ja lisab Arduino juhitava LED -i igasse stringi ja fret -asendisse. Samuti lisab see LED -stringi režiimi ja intensiivsuse valimiseks uhke OLED -ekraani ja pöördkodeerijapõhise kasutajaliidese.

Valmis uke riistvara omadused:

1. Arduino MICRO liidesega LED -stringi, ekraani ja sisendseadmega.
2. 48 individuaalselt programmeeritavat täisvärvilist LED -i
3. OLED ekraan
4. Pöörlev kodeerija kasutaja sisendiks
5. USB -liides väliseks toiteks ja Arduino programmeerimiseks

Uke tarkvaral on:

1. Põhilised valguse juhtimisrežiimid, mis juhivad LED -e oma tempos
2. Mugav teatritelk (väga mugav etenduste jaoks!)
3. LED -i intensiivsuse reguleerimine
4. Kõigi esimese positsiooni Ukulele akordide täielik akorditeek (akordi väärtus ja iseloom)
5. Võimalus kuvada jooksvat teksti (vertikaalselt), kasutades ainulaadset 4 x 6 pikslist märgistikku

See juhend juhendab valmis prototüüpi. Täielik arengusaaga on saadaval SIIN, sealhulgas mõned harivad (valusad) vead ja väärtuslik õppetund, miks PEAB oma esimese disaini lõpuni viima (ükskõik kui koledateks asjad lähevad). Sa ei tea kunagi kõiki asju, mida sa tegelikult ei tea, kuni jõuad lõpuni (ja siis sa ikka veel ei tea!), Kuid oled järgmise kujunduse jaoks palju parem ja palju targem.

Ehitasin prototüübi ümber Grizzly Concert Ukulele komplekti. Komplektiga alustamine leevendab muret uke keha pärast (noh, enamasti) ja kõrvaldab enamiku tõelisest lutsutüüpi tööst. Need komplektid on üsna täielikud ja pole asjade suures plaanis nii kallid (ja vähem valusad, kuna teete vigu).

Samm: tehke plaan

Mõne komplekti kuuluval otsteplaadil (või sõrmeplaadil) on frets juba kinnitatud. See on hea/halb. Ajasäästjana on see tore, kuid puurimustri väljapaneku ja freesimise ajal paigal hoidmise osas on see natuke valus. Pärast komplekti kuuluva hävitamist otsustasin (noh, mul polnud muud valikut kui teise komplekti ostmine) osta uus fretboard.

Fretboardi projekteerimisel peame arvutama trükkplaadi ja valgusdioodide sisestamiseks vajaliku paksuse suurenemise (ja ärge unustage passiivseid komponente), kuid mitte nii palju, et valgusdioodid oleksid otsteplaadi pinnast liiga kaugel.

LED -trükkplaat (PCB) on disainitud lihtsa kahekihilise plaadina. See aitab palju LED -nööri käsitsi kokkupanemisel ja annab Ukulele kaelale teatud mehaanilise tugevuse (see on klaaskiud ja epoksü). Alustasin paigutust Eagle'is, kuid kasutasin tahvli suuruse piirangute tõttu Altium Designerit. Altiumi skemaatilised ja PCB -failid on siin.

Komplekti otstelaud oli vaid 0,125 tolli paks. Niisiis, eeldades 0,062 tolli paksust trükkplaati ja lubades LED -ide jaoks täiendavat 0,062 tolli, tähendab see, et me peame palju (nagu üldse) väljalõikeplaati lõikama. Selle kompenseerimiseks võime kas osaliselt lõigata taskulambri LED -ide jaoks taskulambi, millel on vastav tasku kaelas PCB jaoks, või asendada kogu otstelaud (valik, millega ma läksin) Luther Mercantile Internationali (LMII) paksema versiooniga, mille algus on 0,25 tolli.

AGA, pidage meeles, et peate ikkagi kaela töötlema, et kompenseerida paksuse suurenemist otsteplaadil. Teine eelis, mille saate, on kosmeetiline, kuna trükkplaat on nüüd täielikult fretboardi sisse ehitatud, mis muudab servade viimistlemise palju lihtsamaks (ja näeb palju kenam välja!) Ning lihtsustab kaela freesimist.

Tehnilised asjad (ignoreerige, kui soovite):

Muide, see ei kahjusta tegelikult kaela jäikust nii palju. Trükkplaatide materjal on palju jäigem kui esialgne fretboard puit (mahagonmoodul: 10,6 GPa versus FR4 moodul: 24 GPa), pluss kuna ehitame Ukulele'i, ei ole tohutul hulgal nööripinget, mis muidu moonutada võiks või lõime) kaela.

Üks väga huvitav kaalutlus (mida ma ilmselt peaksin ikkagi arvutama) on see, mis juhtub temperatuuril. Üldiselt puidu puhul, paralleelselt teraga, on soojuspaisumistegur ligikaudu 3 x 10^-6/K ja FR4 puhul 14 × 10^-6/K. Niisiis, seal on üsna oluline erinevus. Mure on selles, et temperatuuri muutudes tekib kaelas pinge, mis omakorda nöörid tuunib. Seda saab kompenseerida, kandes sarnase kihi neutraaltelje vastasküljele või viies FR4 neutraalteljele võimalikult lähedale. Aga see jääb 2.0 -le… Midagi modelleerida ja hinnata.

Elektroonika on paigutatud uke kehasse. UKE külgseinale (mitte heliplaadile!) On lõigatud augud, et teha ruumi kuvarile ja pöörlevale kodeerijale, lisaks juurdepääsuplaat Arduino Micro hoidmiseks ja juurdepääsuks USB -liidesele. Juurdepääsuplaadi/kinnituse konstruktsiooni ja asukohta võiks tõenäoliselt parandada, et USB -ühendus oleks mugavamas kohas, kuid praegusel kujul pole see kõik nii hull, sest see ei takista mängimist.

Sammude ülevaade on järgmine:

1. Koguge materjale
2. Hankige vajalikud tööriistad
3. Freesige kael, et mahuks paksem fretboard
4. Freesige lõikelaud, et teha auke vajalikes kohtades ning luua tasku plaadile ja valgusdioodidele
5. Hankige ja konstrueerige trükkplaat, mis hoiab LED -e
6. Freesige Ukulele korpusesse juurdepääsuaugud OLED -ekraani, pöördkodeerija ja juurdepääsupaneeli jaoks
7. Tehke katteplaadid
8. Kinnitage juhtmed trükkplaadile; ühendage ja katsetage elektroonikat
9. Kinnitage kael Ukulele keha külge
10. Puurige juurdepääsupidur, et juhtida PCB juhtmed korpusesse
11. Joondage ja liimige trükkplaat ja fretboard kaela külge
12. Joondage otsteplaadi servad kaela külge (eemaldage liigne materjal)
13. Paigaldage traatjuhtmed
14. Kandke maskeerimine ja viimistlus Ukulele
15. Joondage ja kinnitage sild
16. Paigaldage elektroonika ja katsetage.
17. Paigaldage tuunerid ja pingutage pill
18. Programmeerige Uke kontroller
19. Imetle maailma oma Ukulele'i suurepärasusega!

Samm: koguge materjalid

Meie materjalide loend näeb välja selline:

1. Ukulele komplekt - kasutasin Grizzly Concert Ukulele komplekti (Grizzly Uke Kit Amazonis), kuid tundub, et see lõpetatakse. Zimo teeb sarnase mudeli (Zimo Uke Kit @ Amazon), mis näeb välja, et see teeb selle töö ära
2. Ukulele fretboard, eelnevalt piludega (LMII Uke Fingerboards). Nad lükavad fretti vastavalt teie skaalale, mis säästab probleeme
3. Epoksü - rehviplaadi kaelale liimimiseks. Valisin epoksiidi, kuna see sobib PCB materjaliga. Otsige midagi, mille tööaeg on vähemalt 60 minutit. ÄRGE kasutage 5 -minutilisi tüüpe, vajate kohandamiseks aega
4. Fret traadid - saadaval ka LMII -st
5. Kohandatud trükkplaat - Altium -failid on siin. Valisin tavalise FR4 tüüpi materjali. Painduvad (polüimiid) plaadid oleksid huvitav (kui kallim) alternatiiv, kuna need võivad olla palju õhemad
6. 48x Neopixel (SK6812) LEDid. Saadaval Adafruitist ja Digikeyst
7. 48x 0,1uF 0402 korki - suurem on vastuvõetav, kuid peate jälgima paigutust
8. Haaketraat - segaduste vältimiseks vähemalt 4 kuni 6 värvi, kasutasin peamiselt 28 -mõõtmelist traati. Jälgige alalisvoolu langust LED -toiteühendustel (nii VCC kui ka GROUND… see vool peab allikasse tagasi jõudma!)
9. Pöörlev kodeerija-PEC16-4220F-S0024
10. Fancy puidust nupp - pöörleva kodeerija jaoks (sain oma LMII -st)
11. OLED -ekraan - 4D -süsteemidest OLED -ekraanid
12. Väline USB -aku - kogu aeg odavam, lisaks saate varuosi kaasas kanda!
13. Arduino MICRO
14. Leht messing - et plaat hoiaks ekraani jaoks arduinot ja raami
15. Mitmesugused tarbekaubad, sealhulgas: liivapaber, uretaanviimistlus, popsicle pulgad, kummipaelad, jootetoru, flux, harjad, kahepoolne teip (mulle meeldib UHC lint 3M võrra) ja väikesed messingist puitkruvid (plaadi jaoks)
16. Valikulised Ukulele'i täiustused - paremad tuunerid, paremad stringid, parem pähkel ja sadul, inkrusteerimine, kui soovite näidata oma lutsier võimet)

Samm: hankige vajalikud tööriistad

Varem või hiljem peate neid hankima või neile juurde pääsema:

Meie tööriistade loend sisaldab:

1. Freespink - eelistatud CNC, kuid võite isegi ruuteri ja palju õnne läbi saada. Kasutasin kombineeritud CNC veskit/ruuterit
2. Ruuteriotsad - eelistatud karbiid. Ruuterite otsad valitakse lõppveskite asemel, kuna me töötleme puitu, mitte metalli
3. Klambrid - palju neid. Enamasti on vaja osade hoidmiseks liimimise ajal
4. Jootekolb - väike ots pinnapealse jootmise jaoks
5. Mikroskoop või luup - võite proovida jootma ainult oma silmadega, kuid ma ei soovitaks seda, vähemalt 10 korda
6. Pintsetid (osade paigaldamiseks)
7. Tööriistad (vt LMII korralikke tööriistu siit, aga ma kasutasin seda, mis mul kodus oli ja tegin; haamrid, viilid ja lõikurid)
8. Erinevad käsitööriistad, nagu puitpeitlid, kruvikeerajad, pehme löök või toornahast haamer (muretsemiseks) jne.
9. Abrasiivid - erinevad liivapaberi liivad

Meie tarkvaratööriistade hulka kuuluvad (mõned on teie eelarvest/leidlikkusest sõltuvalt valikulised):

1. Arduino tarkvara
2. Ukulele lähtekood (https://github.com/conrad26/Ukulele)
3. PCB paigutuspakett - kasutasin Altiumi, kuna Eagle'i tasuta versioon ei toetanud soovitud tahvli suurust. Altium on täisfunktsionaalne paigutuspakett ja pole tegelikult harrastajate hinnaklassis. Olen prototüübi jaoks lisanud oma saidile Gerberi failid, kuid need vajavad kindlasti värskendamist
4. 3D -modelleerimistarkvara - kasutasin SolidWorksi, kuid üks tasuta alternatiiv on FreeCAD (https://www.freecadweb.org/)
5. CAM -tarkvara - nagu Autodeski FeatureCAM NC -veski faili loomiseks.

Kombinatsioon 3D -astmefailide eksportimisest Altiumist koos fret -laua 3D -mudeliga välistab suure osa raskustest selle tagamisel, et kõik oleks kooskõlas, kuid see pole nõue. Hoolikas paigutus annab sama tulemuse.

Nüüd, kui me teame, mida me tahame teha ja mida me peame tegema, ehitame Ukulele.

4. samm: freesige kael, et mahutada paksem otstelaud

Enne freesimist pange tähele, et Fretboardi kinnituspinna algset tasasust PEAB säilitama, vastasel juhul on teil väänatud otstelaud, mis toob kaasa kõikvõimalikud probleemid.

Lihtsalt ärge minge sinna, võtke aega ja kinnitage kael ettevaatlikult ja jäigalt kinni ning kontrollige enne lõikamist ruuteri otsikuga joondamist kogu kaela ulatuses. Siin veedetud aeg säästab hiljem palju leina.

Üks põhjus, miks ma valisin paksema otstelaua kaela sisekatte kohal, oli suurenenud kinnituspind (liimimine). Teine põhjus on see, et see lihtsustab kaela freesimist. Lõikate lihtsalt kogu pinna soovitud kõrgusele.

Samm: hankige ja konstrueerige trükkplaat, mis hoiab LED -e

Jootsin käsitsi kogu komplekti. LED -pakette on eriti lihtne sulatada, seega olge ettevaatlik, et neid mitte kahjustada. Soovitan kanda staatilist rihma, kuna nöör sõltub iga LED -i töötamisest.

Fretboardi disain põhineb WS2812B LED -idel. Otsustasin teha ainult esimese oktaavi (48 LED -i !!). Iga LED -i võib nihkeregistris pidada üheks bitiks. Nihkeregister on sagedusel 800 kHz. Kasutasin asjade kiireks käivitamiseks Adafruit'i raamatukogu (vt programmeerimise osa).

Alustasin disaini Eagle'is, kuid tahvli suurus on piiratud 4 x 5 tolliga, nii et pidin (või õigemini valisin) Altiumile üle minema. Tööl kasutan Altiumi, nii et tegelikult tegi see minu jaoks asja kiiremaks. Altiumi projekt, skemaatilised ja PCB -failid (ja raamatukogu osad) on minu saidil. Plaat on trapetsikujuline ja umbes 10 tolli pikk. Ma arvan, et oleksin pidanud proovima veidi rohkem kontuuri kokku suruda (järgmine keerutus!) Kokkupanek polnud halb, aga kui saate seda endale lubada, soovitan tõesti tõesti korralikku jootekolvi (JBC Soldering Irons) ja head mikroskoopi. Jah, ma olen rikutud ja ei, mul pole selliseid asju oma kodulaboris. Ma olen odav.

Lasin Sunstone'is lauad teha. 129 dollarit kahe laua eest. Garanteeritud kord nädalas. Ärge siiski koonerdage saatmist. Ma ei märganud, et kasutasin UPS -i maapinda ja lõpuks ootasin lisanädala, kuni mu lauad kohale jõudsid. Kogu kokkupanekuaeg oli umbes 2 tundi (98 osa).

6. toiming: freesige töölaud

Peame freesima freesplaadi, et teha auke vajalikesse kohtadesse ning luua tasku tahvlile ja valgusdioodidele.

Lõin Solidworksis valmis mudeli 3D -mudeli ja lõin FeatureCAM -i abil CNC freesimisrutiini.

Fretti alumine osa (heliaugule kõige lähemal) tuleb õhemaks muuta, et võtta arvesse kaela ja keha vahelise kõrguse muutust. Kindlasti tasub mitu korda katsetada, et olla kindel, et see sobib piisavalt hästi.

Tagantjärele mõeldes oleksin pidanud otstarbekohased lõiked ära lõikama, et see paremini veskile sobiks (minu odaval veskil oli ainult 12-tolline X-telje käik). Toimingute järjekord tuleks seadistada kuni esimese veski paksuse reguleerimiseni enne freesitaskud, mis peaks vähendama taskutevahelist murdumist.

Juhtmete jaoks ruumi lisamiseks tehke vajadusel käsitsi seadistusi. Üks oluline asi, mida tuleb märkida, on see, et mõnes taskus murdsin sisse pilusse, kuhu läheb traat. Arvestades, et see on dirigent, veenduge, et see ei lühendaks midagi olulist. See vähendab ka materjali, mis hoiab vimma paigal. Kujundust tuleks muuta nii, et see ei ristuks kunagi fret -piluga.

Samm: veski juurdepääsuavad Ukulele korpuses

Freesisin käsitsi kere sissepääsuavad. Kõige raskem on väga kaarduva pinna "lamedaima" piirkonna leidmine. Märkige piirjooned pliiatsiga ja jahvatage materjali järk -järgult, kuni olete OLED -ekraani jaoks kindlalt sobiv. Sain töödeldud messingist raami ja kinnitasin selle, kasutades 3M VHB kleeplinti.

Kuna kumbki ei vaja suurt täpsust, on pöörleva kodeerija ja juurdepääsupaneeli avade loomine palju lihtsam.

Samm: valmistage katteplaadid

Samuti peate valmistama ekraani raami ja juurdepääsupaneeli katteplaadid. Juurdepääsupaneel vajab auku (ristkülikukujuline) USB (mikro) pistiku jaoks. Kasutage lihtsalt Arduino olemasolevat pistikut, kuna mikro -USB jaoks pole palju paneelide kinnitamise võimalusi. (kuigi kui ma kujundasin nullist, siis ma vaataksin ühte neist)

Tahvli paigal hoidmiseks moodustage messingist L -sulgud ja jootke need juurdepääsuplaadi taha. See võimaldab teil positsioneerimisel teatud laiuskraadi. Asukoha õigeks saamiseks looge esmalt Arduino MICRO jaoks kinnitusplaat (koos kinnitusavadega) ja kinnitage selle külge 2-56 masinakruvi abil L-klambrid. Seejärel saate USB -pordi joondamiseks asukohta muuta ja plaadil olevate sulgude asukohad täpselt märkida. Eemaldage klambrid perfboardilt ja jootke need oma kohale. Lõpuks paigaldage perfboard -komplekt.

Messingi juurdepääsupaneeli paigal hoidmiseks kasutasin nelja väikest messingist puidukruvi.

Siinkohal soovitan enne lõpliku kokkupaneku algust katsetada. See samm on valikuline, kuid soovitatav. Enne liimimist on reguleerimine palju lihtsam.

Samm: ühendage juhtmed trükkplaadiga; Ühendage ja katsetage elektroonikat

Ärge veel elektroonikat püsivalt ühendage. Kinnitage juhtmed trükkplaadile, veendudes, et jätate ligipääsuava väljajuhtimiseks piisavalt lõtvaks. Need tuleb lõpuks Arduino MICRO plaadile püsivalt kinnitada (fotodel on Arduino UNO, mida kasutasin koodi arendamiseks)

Samm: kinnitage kael Ukulele keha külge

Kinnitage kael Ukulele keha külge, järgides Ukulele komplektiga kaasasolevaid juhiseid. Eriti jälgige, et lõikelaud oleks joondatud uke kehaga.

Samm: puurige juurdepääsuauk PCB juhtmete kehasse juhtimiseks

Kui liim on kuiv, puurige 10 mm (~ 1/4 ) auk nurga all, et PCB -l olevad juhtmed saaksid Ukulele korpusesse juhtuda. Ärge kahjustage heliplaati.

Võimalik, et peate looma ka väikese tasku, et võimaldada juhtmete paksust plaadi all (või soovi korral asetada ühendused ülaosale ja lisada reljeef kaanelauale.)

Veel üks katse sobivus ei teeks praegu haiget.

12. samm: joondage ja liimige trükkplaat ja fretboard kaela külge

Soovitan enne liimimist klammerdamine läbi mõelda (ja proovida!). Võimalik, et soovite moodustada kaela alumisele küljele vormitud ploki, et saada lame kinnituspind. Praktika on sel hetkel kaelast suurem, nii et peate seda lubama.

Olge väga ettevaatlik, et epoksiid ei satuks pinnale, mille soovite hiljem lõpetada. Veel parem on maskeerimine enne liimimist rakendada kõikidele liimimata pindadele, veendumaks, et see läheb ainult soovitud kohta.

Kasutage epoksiidi, mille tööiga on vähemalt 60 minutit … vajate seda kõike.

Liimige kõigepealt trükkplaat oma kohale, veendudes, et liigne liim ei ulatuks välja otsteplaadi liimimispinnale. See annab meetodi, millega joondada rehviplaat kaela külge. Trükkplaadil on sile jootmismaskiga viimistlus, nii et karestasin selle natuke liivapaberiga, et anda epoksüpinnale veidi parem pinnaviimistlus.

Joondage ja liimige fretboard kaela külge. Olge ettevaatlik, ärge jätke taskuid, mis võivad hiljem kõlada (sumin!). Samuti olge ettevaatlik, et LED -pindadele ei satuks liimi.

Kui liim on kuiv, võiksite elektroonikat veel kord ühendada ja katsetada. Üks halb LED paneb sind elu vihkama. Mul oli prototüübil üks halb LED (esimene!) Ja pidin defektsele LED -ile ligi pääsemiseks ning selle puhtaks parandamiseks tegema loomingulisi puutöid.

Samm 13: tasandage Fretboardi servad kaelale ja lisage Fret Traadid

Kui liim on kuiv, võite hakata servi viimistlema. Lõikasin ettevaatlikult üle lihvimisplaadi materjali (kasutades veskit) ja lõpetasin viimase millimeetri käsitsi lihvimisega.

Fret traate saab lisada lihtsalt haamriga (plastikust näoga, et vältida kahjustusi). Lihtsalt ärge haamer liiga kõvasti. Kui olete pahandustraadi pesadega sobitanud, peaksid need ilma suuremate raskusteta sisse minema.

Peate jälgima LED -tasku õhukese pinna purustamist. Prototüübil lubasin mõnel LED -taskul (12. viha lähedal, kus ruumi napib) laieneda närvipessa. See on halb mõte, sest see tekitab nõrga koha, mis võib (ja purunes) pärast traatjuhtme sisestamist.

14. samm: kandke Ukulele maskeerimist ja viimistlust

Maskeeri otstelaud (see ei saa viimistlust) ja silla liimimisala ning alusta viimistlust.

Sillapiirkonna maskeerimisel lugege oma komplektiga kaasasolevaid juhiseid ja kontrollige seejärel kindlasti skaala pikkust. Komplekt, mida kasutasin prototüübi jaoks, kasutas vale skaala pikkust ja andis seega silla asukoha määramiseks valed mõõtmed (kuid sellel oli märge, et kontrollida veebisaidilt viimaseid juhiseid!). Mu sisetunne ütles mulle, et see on vale, aga ma võtsin pimesi autoriteedi vastu.

Alati on parem mõista, MIKS te midagi teete, mitte pimesi juhiseid järgida.

Lõpetuseks on palju õpetusi Luthiersilt, kes teavad, mida nad veebis teevad, seega soovitan nendega enne viimistlusprotsessi hüppamist konsulteerida.

Mina seda muidugi ei teinud, seega kasutasin vale tihendit, mille tulemuseks oli väga teraline pind. Ära tee seda.

Tee oma kodutöid.

Samm: joondage ja kinnitage sild

See samm on üsna lihtne, kuid jällegi kavandage oma kinnitusmeetod ja proovige seda enne liimimist eelnevalt proovida. Silla kinnitamiseks kasutasin tavalist puiduliimi.

16. samm: elektroonika paigaldamine ja testimine

Nüüd on aeg muuta oma juhtmestik ilusaks. Lisaks ei taha te, et see kehas ringi libiseb ja laval sumisevat häält teeb või veel hullemini laval puruneb.

Arduino koodi saab värskendada USB -pordi kaudu, nii et tegelikult pole vaja seda lahti võtta, kui te ei soovi nokitseda.

17. samm: paigaldage tuunerid ja keelustage instrument

Tõenäoliselt peate ka fretid tasandama ja seadistusega natuke mängima, kuid miks muretseda nüüd, kui olete lõppu nii lähedal?

Uuendasin tuunereid ja kasutasin toredaid Aquila keeli, mis ei aidanud heli kuidagi. Nii et pidage seda meeles, kui kulutate raha projekti ukulele jaoks…

18. samm: Uke programmeerimine

Lõplik Arduino kood on Githubis. Koodis on mõned read, mis toetavad tulevasi täiustusi (nt metronoomi funktsioon ja ekraani liugurid (liugurina näiv kasutajaliidese element)

See kood kasutab Rotary Encoder Library (Rotary Encoder Arduino Library), et hallata kasutaja sisendit Rotary Encoderist.

Samuti kasutab see Adafruit Neopixeli raamatukogu ja siin asuvat näidiskoodi. Teatri- ja vikerkaarerežiimid on tuletatud raamatukoguga kaasasolevatest näidetest. (vt strandtest.ino).

Ekraanidraiverit pakuvad 4D süsteemid ja selle leiate Githubist siit.

Ukulele projekti jaoks on rakendatud kaks ainulaadset funktsiooni. Esimene rakendab akorditeeki ja teine kuvab kohandatud märgistiku abil keriva tekstisõnumi.

Lisatud skeemil on näidatud LED -i asukohad ja nende ühendamine. LED 0 asub paremas ülanurgas.

19. samm: akordi kuvamine

Funktsioon displayChord kuvab sõrmede asukohad (esialgu ainult esimene positsioon) iga akordi jaoks. Kasutaja valitud akordid (juurmärkus ja kvaliteet) salvestatakse indeksite paarina. Neid kasutatakse omakorda iga akordi sõrmede otsimiseks.

Akordide salvestamiseks kasutasin märget "GCEA" (nt "A" on "2100"). Akordid arvutatakse iga juurte jaoks ette ja salvestatakse akordi kvaliteedile vastavasse muutujase. (seega A -duur salvestatakse massiivi "majorChords" esimesse asukohta, mis vastab "2100" -le).

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 "};

Pange tähele, et kuna tegemist on tekstistringiga, võib iga number kujutada ka kuueteistkümnendväärtust, et arvestada üle 9 -ga. See tähendab, et A ja B tähistavad valgusdioode 10 ja 11. Esimese positsiooni akordide puhul polnud see probleem).

LED -string on juhtmestatud pikisuunas 12 -nda rida (oktaav) piki igat stringi (alustades stringist A), järgnev 12 -kordne käik algab järgmise stringi esimesest nurgast (vt skeemi etapis 18). See on oluline algoritmi jaoks, et määrata, millised tuled antud akordi jaoks sisse lülitada. See tähendab, et pikslid 0–11 on A -stringi LED -id, 12–23 on E -stringi LED -id jne. Analüüsides A = "2100" (salvestatud stringina, on koodis ka null -terminaator), tõlgendame seda järgmiselt: stringil A ei piksleid ega E -stringil pikslit 0 (fret 1) C -stringil süttib ja piksel 1 (fret 2) G -stringil. Pange tähele, et "0" on väljas, mitte esimene LED. Juhtmestiku põhjal tahame süttida valgusdioode 24 ja 37. Akordi kuvamise kood on näidatud allpool.

jaoks (int i = 0; i <4; i ++) {if (int (akord - '0')) {// algoritm akordistringi sõelumiseks int ledNumber = int (akord - '0') + (3 - i) * 12 - 1; // vt ülaltoodud arutelu, (3-i) on indeksriba tagurpidi pööramine.setPixelColor (ledNumber, 0, 125, 125); // setPixelColor (ledNumber, punane väärtus, roheline väärtus, sinine väärtus)}}

Kui avaldus kontrollib, kas LED on välja lülitatud. Kui see pole nii, võtab see märgi ascii väärtuse, akordi ja lahutab ascii väärtuse '0', et LEDNumber süttiks.

riba on klassi Adafruit_NeoPixel eksemplar. Funktsioon setPixelColor määrab arvutatud piksli värvi (antud juhul fikseeritud (0, 125, 125).

Samm 20: Kuidas kerimissõnumit kuvada

Nii et meil on 12 x 4 LED -i massiivi … miks mitte panna see kuvama midagi muud kui päris juhuslikud valgusmustrid!

Esimene probleem on see, et ekraani kõrgus (4) on Uke stringide arvu tõttu üsna piiratud. Horisontaalne kerimine oleks enamasti loetamatu, kuid vertikaalses asendis saame toetada 4 x 5 tähemärki, mis jooksevad vertikaalselt.

Märkide korraldamine viie "vertikaalse" reana tähendab, et korraga saab kuvada kahte märki, jättes iga märgi vahele ühe rea tühiku.

Raskuseks oli see, et puudus standardne 4 x 5 tähemärkide komplekt. Tegin oma, kasutades lisatud arvutustabelit. Määrasin igale reale ühe kuuskantväärtuse (4 bitti, mis tähistavad seda, milline piksel on sisse või välja lülitatud). Viie kuusnurkse väärtuse kombinatsioon moodustab märgi (nt "0" on 0x69996).

Iga märgi väärtused salvestatakse massiivi ASCII järjekorras. Märgikomplekt teeb teatud tähtedega mõningaid kompromisse, kuid enamus on mõistlikult selge. (arvutustabeli allservas olev kritseldus on ideed, millega ma mängisin, kuna meil on valikuvõimalus värv, saame tegelasele lisada sügavuse ja saada täiendava eraldusvõime.

Kuvatav string sisaldub stringimuutuja sõnumis.

Tähemärkide kuvamiseks luuakse puhver. Ma arvan, et oleksin võinud lihtsalt luua suure puhvri kogu tõlgitud sõnumijadaga, eriti kuna enamik sõnumeid on vähem kui 20 tähemärki. Siiski otsustasin selle asemel luua fikseeritud kolme tähemärgi (18 baiti) puhver. Ainult kahte tegelast kuvatakse aktiivselt ja kolmas on pilk ettepoole, kuhu laaditakse järgmine märk. LED -string (mõelge sellele kui suur nihkeregister) on laaditud stringi 48 bitti. Ma raiskasin natuke mäluruumi, et seda oleks lihtsam ette kujutada. Iga näksimine saab oma mälu asukoha, kahekordistades mälunõudlust, kuid puhvri suurust arvestades pole seda palju.

Puhvrisse laaditakse järgmine märk, kui väljundindeks (kursor) jõuab märgi piirini (outputPointer 5, 11 või 17).

Puhvri laadimiseks võtame ASCII väärtusena sõnumi esimese märgi ja lahutame 48, et saada indeks asciiFont massiivist. Selle indeksi väärtus salvestatakse kausta codedChar.

Sõnumi esimene osa nihutatud vastab LED -idele 47, 35, 23 ja 11 (ekraani allosas). Nii et numbri null 0x0F999F puhul nihutatakse F (vasakpoolne) esimeses, 9 sekundis ja nii edasi.

Järgmine märk laaditakse iga näksimise maskeerimisega ja paremale nihutamisega. Ülaltoodud näite puhul annab algoritm (0x0F999F & 0xF00000) >> 20, seejärel (0x0F999F & 0x0F0000) >> 16 jne.

int indeks; if (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) {char displayChar = message.charAt (messagePointer); // haarata sõnumi esimene märk pikalt kodeeritudChar = asciiFont [displayChar - 48]; if (displayChar == 32) codedChar = 0x000000; messageBuffer [baitPointer+5] = bait ((kodeeritudChar & 0xF00000) >> 20); // maskeeri kõik peale viimase näksimise ja nihuta see 20 võrra (ja nii edasi) messageBuffer [baitPointer+4] = bait ((codedChar & 0x0F0000) >> 16); // see peaks panema ühe nibble mälu asukoha kohta teate Puhver [bytePointer+3] = bait ((codedChar & 0x00F000) >> 12); // kõik kuus tähistavad märgisõnumitBuffer [bytePointer+2] = bait ((codedChar & 0x000F00) >> 8); messageBuffer [baitPointer+1] = bait ((kodeeritudChar & 0x0000F0) >> 4); messageBuffer [baitPointer] = bait ((kodeeritudChar & 0x00000F)); if (bytePointer == 0) {// käsitleda baitiPointeri ringi ümber bytePointer = 12; } else {baitPointer -= 6; // täidame alt üles; MÄRKUS. Peate vaatama selle ümberpööramist, et näha, kas see lihtsustab}} kui (messagePointer == message.length ()-1) {// käsitsege sõnumi loopPointer = 0; } else {messagePointer += 1; // liigu järgmise märgi juurde}}

Kui puhver on laaditud, tuleb jälgida, kus väljundi osuti asub, ja laadida LED -string õigesse 48 bitti (praegune 4 ja eelmine 44). Nagu varem mainitud, on riba NeoPixeli klassi eksemplar ja setPixelColor määrab iga piksli värvi (RGB). Funktsioon show () nihutab kuva väärtused LED -stringile.

// tsükkel puhvri pidevaks nihutamiseks

// tahad kogu riba välja kirjutada igal tsükli läbimisel, muutub ainult lähtekoht (int rida = 12; rida> 0; rida--) {index = outputPointer + (12-rida); if (indeks> 17) indeks = outputPointer+(12-rida) -18; // silmus, kui see on suurem kui 17 (int veerg = 4; veerg> 0; veerg-) {strip.setPixelColor (uint16_t (12*(veerg-1)+(rida-1)), uint8_t (RedLED*(bitRead (messageBuffer [register], veerg-1)))), uint8_t (GreenLED*(bitRead (messageBuffer [register], veerg-1))), uint8_t (BlueLED*(bitRead (messageBuffer [indeks], veerg 1)))); // igas kohas süttib LED, kui bit on üks}} // outputPointer osutab kuvatava stringi praegusele madalaimale baidile, kui (outputPointer == 0) outputPointer = 17; else outputPointer -= 1; strip.show (); }

21. samm: hämmastage maailma oma ukuleleemeelsusega

Viimase Ukulele prototüübi käivitamiseks kulus umbes 6 kuud alustamist ja peatumist.

Palju uut tehnoloogiat õppida ja võib -olla käivitada mõni puidutöö- ja muusikateooria!

Mida teha järgmise versiooni jaoks?

1. Vabanege ekraanist ja pöörlevast kodeerijast. Asendage need arduino külge kinnitatud Bluetooth -mooduliga. Juhtige seda eemalt telefoni või tahvelarvuti abil. Bluetoothiga on kõik parem.
2. Värskendage reaalajas akordimustreid eemalt. Rakendusele on jäänud midagi paremat.
3. LED -katted. Praegune versioon ei tee midagi, et takistada gunkide sattumist LED -aukudesse. Sõber valmistas hunniku väikseid läätsi, kuid ma ei suutnud kunagi välja mõelda, kuidas neid korralikult oma kohale hoida.
4. Alternatiivsed otsteplaadimaterjalid, võib -olla midagi selget, kuni frettid jätkuvad.
5. Rohkem tulesid! Kõrvaldage piirangud tekstile, lisades rohkem "ridu". See on tõesti piirang, mille on põhjustanud retuudi ja LED -korpuste suurus.

Vaadake jällegi kaaslast Instructable, mis kirjeldab märgistikku, mille pidin looma teksti kerimise võimaldamiseks.

Suur tänu, et nii kaugele jõudsite! Mahalo!