Com es construeix un ukelele il·luminat !: 21 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

Toco l’ukelele. Una mica mediocre (si això és una paraula), així que vaig pensar: "si realment voleu impressionar les dones, necessiteu un mitjà per distreure-les del desastre que s'està jugant a l'escenari". Per tant, va néixer el "Light-up Ukulele".

Aquest projecte pren un kit Concert Ukulele i afegeix un LED controlat per Arduino a cada posició de corda i trast. També afegeix una pantalla OLED elegant i una interfície d'usuari basada en el codificador rotatiu per seleccionar el mode i la intensitat de la cadena de LED.

Les funcions de maquinari uke completades:

1. Arduino MICRO per a la interfície amb la cadena, la pantalla i el dispositiu d’entrada de LED.
2. 48 LEDs a tot color individualment programables
3. Una pantalla OLED
4. Un codificador rotatiu per a l'entrada de l'usuari
5. Interfície USB per a alimentació externa i programació Arduino

El programari uke té:

1. Modes bàsics de control de llum que fan funcionar els LED a través dels seus passos
2. Un enginyós mode d’envelat de teatre (molt útil per a representacions!)
3. Control de la intensitat del LED
4. Una biblioteca completa d’acords de tots els acords d’ukelele de primera posició (valor i caràcter d’acord)
5. Possibilitat de mostrar text en execució (verticalment) mitjançant un conjunt de caràcters únic de 4 x 6 píxels

Aquest instructable descriu el prototip completat. La saga completa del desenvolupament està disponible AQUÍ, incloent-hi alguns errors educatius (dolorosos) i una valuosa lliçó sobre el motiu pel qual DEVEU acabar el vostre primer disseny (per molt lletges que siguin). Mai no sabeu totes les coses que realment no sabeu fins arribar al final (i després encara no ho sabeu!), Però esteu molt millor i molt més intel·ligent per al proper disseny.

Vaig construir el prototip al voltant d’un kit d’Ukelele de Grizzly Concert. Començar amb un kit alleuja la preocupació pel cos del uke (bé, sobretot) i elimina la major part del treball real del tipus luthier. Aquests kits són bastant complets i no són tan cars en el gran esquema de les coses (i són menys dolorosos ja que cometreu errors).

Pas 1: feu un pla

El diapasó (o diapasó) inclòs en alguns kits ja té els trasts acoblats. Això és bo / dolent. És bonic per estalviar temps, però pel que fa a establir un patró de trepant i mantenir-lo al seu lloc mentre es fresen, és una mica dolorós. Després de destruir el que es proporcionava al kit, vaig optar (bé, no vaig tenir més remei que comprar un altre kit) per comprar un diapasó nou.

A l’hora de dissenyar el diapasó, hem de calcular l’augment del gruix necessari per incrustar el PCB i els LED (i no oblidem els components passius), però no tant que els LED estiguin massa allunyats de la superfície del diapasó.

La placa de circuit imprès LED (PCB) està dissenyada com una simple placa de 2 capes. Això ajuda molt amb el muntatge manual de la corda LED i proporciona una certa resistència mecànica (fibra de vidre i epoxi) al coll de l’Ukelele. Vaig començar el disseny a Eagle, però vaig acabar fent servir Altium Designer a causa de les limitacions de mida del tauler. Els esquemes Altium i els fitxers PCB són aquí.

El diapasó del kit tenia només 0,125 polzades de gruix. Per tant, suposant un PCB de 0,062 polzades de gruix i permetent 0,062 polzades addicionals per als LED, significa que hauríem de tallar molt (com en tots) el diapasó. Per compensar, podem tallar parcialment les butxaques dels LEDs del diapasó amb una butxaca corresponent al coll del PCB, o bé podem substituir tot el diapasó (l'opció que vaig seguir) per una versió més gruixuda de Luther Mercantile International (LMII), que són 0,25 polzades per començar.

PER,, recordeu que encara haureu de mecanitzar el coll per compensar l’augment de gruix al diapasó. L’altre avantatge que obtingueu és el cosmètic, ja que el PCB ara està completament incrustat dins del diapasó, cosa que facilita l’acabat de les vores (i es veu molt més agradable) i simplifica el fresat del coll.

Coses d'enginyeria (ignoreu-les si voleu):

Per cert, això no compromet tant la rigidesa del coll. El material del PCB és molt més rígid que el diapasó original (mòdul de caoba: 10,6 GPa versus mòdul FR4: 24 GPa), a més, ja que estem construint un ukelele, no hi ha una gran quantitat de tensió de corda que d’altra manera podria distorsionar (gir o ordit) el coll.

Una consideració molt interessant (que probablement encara hauria de calcular) és el que passa amb la temperatura. Genèricament per a la fusta, paral·lel al gra, el coeficient tèrmic d’expansió és aproximadament de 3 x 10 ^ -6 / K, i per a FR4 és de 14 × 10 ^ −6 / K. Per tant, hi ha una diferència prou significativa. La preocupació és que es crea tensió al coll a mesura que varia la temperatura, cosa que al seu torn desafina les cordes. Això es pot compensar aplicant una capa similar al costat oposat de l’eix neutre o fent que el FR4 s’aproximi al màxim a l’eix neutre. Però això quedarà per a 2.0 … Alguna cosa per modelar i avaluar.

L’electrònica s’allotja al cos del uke. Els forats es tallen a la paret lateral (no a la caixa de ressonància!) De l'UKE per deixar espai a la pantalla i al codificador rotatiu, a més d'una placa d'accés per subjectar l'Arduino Micro i proporcionar accés a la interfície USB. Probablement es podria millorar el disseny i la ubicació de la placa d'accés / muntatge per fer que la connexió USB surti en un lloc més convenient, però, tal com està, no està tan malament, ja que no està en el camí quan jugueu.

El contorn dels passos són els següents:

1. Reuneix materials
2. Obteniu les eines que necessiteu
3. Fresqueu el coll per adaptar-vos al diapasó més gruixut
4. Freseu el diapasó per fer forats a les ubicacions necessàries i crear butxaques per a la placa i els LED
5. Obteniu i construïu el PCB que sosté els LED
6. Feu forats d’accés al cos d’Ukelele per a la pantalla OLED, el codificador rotatiu i el tauler d’accés
7. Feu plaques de coberta
8. Una els cables a la PCB; connecteu i proveu l'electrònica
9. Fixeu el coll al cos de l'ukelele
10. Perforeu una presa d'accés per passar els cables del PCB al cos
11. Alineeu i enganxeu el PCB i el diapasó al coll
12. Anivelleu les vores del diapasó fins al coll (traieu l’excés de material)
13. Instal·leu els cables del trast
14. Apliqueu l’emmascarament i apliqueu l’acabat al ukelele
15. Alinear i connectar el pont
16. Instal·leu electrònica i proveu.
17. Instal·lar sintonitzadors i cordes de l'instrument
18. Programa el controlador Uke
19. Sorprèn el món amb la teva fantàstica Ukulele!

Pas 2: reuniu materials

La nostra llista de materials té aquest aspecte:

1. Kit d'ukelele: he utilitzat un kit d'ukelele de Grizzly Concert (Grizzly Uke Kit a Amazon), però sembla que es deixarà de fabricar. Zimo fa un model similar (Zimo Uke Kit @ Amazon) que sembla que farà la feina
2. Diapas de ukulele, pre-ranurat (LMII Uke Fingerboards). Col·locaran el diapasó a la vostra escala, cosa que us estalviarà problemes
3. Epoxi: per enganxar el diapasó al coll. Vaig triar l’epoxi, ja que és compatible amb el material del PCB. Cerqueu alguna cosa amb 60 minuts de vida laboral com a mínim. NO utilitzeu tipus de 5 minuts, necessiteu temps per fer ajustaments
4. Cable de trast - també disponible a LMII
5. PCB personalitzats: els fitxers Altium són aquí. Vaig optar per material normal tipus FR4. Les taules flexibles (poliimida) serien una alternativa interessant (si més cara), ja que poden ser molt més primes
6. LED de 48x Neopixel (SK6812). Disponible a Adafruit i Digikey
7. 48x 0,1uF 0402 majúscules: és més gran, però cal veure la ubicació
8. Filferro de connexió: almenys de 4 a 6 colors per evitar confusions, he utilitzat principalment filferro de calibre 28. Mireu la caiguda de CC a les connexions d'alimentació del LED (tant VCC com GROUND … aquest corrent ha de tornar a la font!)
9. Codificador rotatiu - PEC16-4220F-S0024
10. Pom de fusta de luxe: per al codificador rotatiu (tinc el meu de LMII)
11. Pantalla OLED: de sistemes 4D Pantalles OLED
12. Bateria USB externa: més barata tot el temps, a més, podeu portar recanvis.
13. Arduino MICRO
14. Làmina de llautó: per fer la placa que subjecta l’arduino i el bisell de la pantalla
15. Consumibles diversos, inclosos: paper de vidre, acabat d’uretà, varetes de paletes, bandes de goma, soldadura, flux, raspalls, cinta de doble cara (m’agrada la cinta UHC de 3M) i petits cargols de fusta de llautó (per a la placa)
16. Millores opcionals de ukelele: millors sintonitzadors, millors cordes, millor femella i sella, incrustacions si voleu mostrar la vostra destresa luthier)

Pas 3: Obteniu les eines que necessiteu

Tard o d’hora haurà d’obtenir o obtenir accés a aquests:

La nostra llista d’eines inclou:

1. Fresadora: es prefereix el CNC, però fins i tot us podeu endur amb un encaminador i molta sort. He utilitzat un molí / enrutador CNC combinat
2. bits de Router - carbur preferits. Broques de fresadora escollides per sobre de les fresadores finals ja que estem mecanitzant fusta, no metall
3. Acoblament - un munt d'ells. Sobretot necessari per subjectar les peces mentre s’enganxaven
4. Soldador: punta petita per soldar a la superfície
5. Microscopi o lupa: podeu provar de soldar només amb els vostres ulls, però no ho recomanaria, com a mínim 10 vegades
6. Pinces (per col·locar peces)
7. Eines de trasteig (vegeu les eines adequades a LMII aquí, però he utilitzat el que tenia a casa i el que he fet; martells, llimes i talladores)
8. Eines manuals variades com cisells de fusta, tornavisos, martell de bufat suau o de pell crua (per trastornar), etc.
9. Abrasius: diversos grans de paper de vidre

Les nostres eines de programari inclouen (algunes són opcionals segons el vostre pressupost / enginy):

1. Programari Arduino
2. El codi font de l'ukulele (https://github.com/conrad26/Ukulele)
3. Paquet de disseny de PCB: he utilitzat Altium perquè la versió gratuïta de Eagle no admetia la mida de la placa que volia. Altium és un paquet de disseny complet i no està realment en un rang de preus aficionats. He inclòs els fitxers Gerber al meu lloc per al prototip, però definitivament necessiten una actualització
4. Programari de modelatge 3D: he utilitzat SolidWorks, però una alternativa gratuïta és FreeCAD (https://www.freecadweb.org/)
5. Programari CAM, com FeatureCAM d'Autodesk, per crear el fitxer de molí NC.

La combinació de l’exportació de fitxers 3D de pas d’Altium juntament amb un model 3D del diapasó elimina gran part de la dificultat per assegurar-se que tot s’alinea, però no és un requisit. disseny acurat aconseguir el mateix resultat.

Ara que sabem què volem fer i què hem de fer, construïm un ukelele.

Pas 4: Milleu el coll per adaptar-vos al diapasó més gruixut

Abans de fresar, tingueu en compte que s’ha de mantenir la planicitat de la superfície de muntatge del diapasó original, o bé tindrà un diapasó retorçat, que comporta tot tipus de problemes amb l’anivellament del trast.

No hi aneu, preneu-vos el temps i fixeu el coll amb cura i rígiditat i comproveu l’alineació de la punta de l’encaminador a tot el coll abans de tallar-lo. El temps passat aquí us estalviarà moltíssim dolor.

Una de les raons per les quals vaig optar per un diapasó més gruixut sobre una incrustació al coll va ser l’augment de la superfície de muntatge (encolat). Una altra raó és que simplifica el fresat del coll. Simplement heu de tallar tota la superfície a l’alçada desitjada.

Pas 5: Obteniu i construïu el PCB que subjecta els LED

mà I solda tot el conjunt. Els paquets de LED són especialment fàcils de fondre, així que tingueu cura de no danyar-los. Suggereixo portar una corretja estàtica, ja que la corda depèn de cada LED que funcioni.

El disseny del diapasó es basa en els LED WS2812B. Vaig decidir fer només la primera octava del diapasó (48 LED !!). Es pot considerar que cada LED és un bit en un registre de desplaçament. El registre de desplaçament es marca a 800 kHz. He utilitzat la biblioteca Adafruit (vegeu la secció de programació) per posar les coses en marxa ràpidament.

Vaig començar el disseny a Eagle, però la mida del tauler està limitada a 4 x 5 polzades, així que vaig haver de canviar (o més correctament, vaig optar per) canviar a Altium. Faig servir Altium a la feina, de manera que, en realitat, em va fer les coses més ràpides. El projecte Altium, els fitxers esquemàtics i pcb (i les parts de la biblioteca) són al meu lloc. El tauler té una forma trapezoïdal i fa uns 10 centímetres de llarg. Crec que hauria d’haver intentat comprimir l’esquema una mica més (pròxim gir!) El muntatge no va ser dolent, però si us ho podeu permetre, realment recomano un soldador decent (JBC Soldering Irons) i un bon microscopi. Sí, estic mimat i no, no tinc aquest tipus de coses al meu laboratori casolà. Sóc barat.

Tenia les taules fetes a Pedra de sol. 129 dòlars per a dues taules. Torn de setmana garantit. Tanmateix, no escatimeu l’enviament. No em vaig adonar que utilitzava UPS UPS Ground i vaig acabar esperant una setmana més perquè arribessin les taules. El temps total de muntatge va ser d’unes 2 hores (98 parts).

Pas 6: Molí el diapasó

Hem de fresar el diapasó per fer forats a les ubicacions necessàries i crear butxaques per al tauler i els LED.

Vaig crear un model 3D del diapasó completat a Solidworks i vaig crear la rutina de fresat CNC mitjançant FeatureCAM.

La part inferior del diapasó (la més propera al forat del so) haurà de ser més prima per tenir en compte el canvi d’alçada entre el coll i el cos. Definitivament val la pena encaixar-la diverses vegades per assegurar-se que és un ajust raonablement ajustat.

Retrospectivament, hauria d'haver tallat les parts no utilitzades del diapasó perquè encaixessin millor al molí (el meu molí barat només tenia un recorregut de l'eix X de 12 ). L'ordre de les operacions s'hauria de configurar fins als primers ajustos del gruix del molí abans butxaques de fresat, que haurien de provocar menys brots entre butxaques.

Feu els ajustaments manuals segons sigui necessari per afegir espai per al cablejat. Una cosa important a tenir en compte és que en algunes de les butxaques vaig entrar a la ranura on anirà el cable del trast. Tenint en compte que és un conductor, assegureu-vos que no acabi en curt el que sigui important. També disminueix la força del material que subjecta el trast al seu lloc. El disseny s’ha de modificar per no creuar-se mai amb una ranura per a trasts.

Pas 7: obrir els forats d’accés al cos de l’ukelele

He fresat manualment els forats d’accés al cos. El més difícil és trobar la regió "més plana" del que és una superfície molt corba. Marqueu l’esquema a llapis i aneu molent el material fins que s’adapti perfectament a la pantalla OLED. Vaig obtenir un bisell de llautó mecanitzat i el vaig connectar amb cinta adhesiva VHB 3M.

Com que cap dels dos requereix una gran precisió, el codificador rotatiu i els forats del tauler d’accés són molt més fàcils de crear.

Pas 8: Fer plaques de coberta

També heu de fabricar les plaques de cobertura del bisell de la pantalla i del panell d'accés. El tauler d’accés necessita un forat (rectangular) per al connector USB (micro). Només cal que utilitzeu el connector existent a l'Arduino, ja que no hi ha moltes opcions de muntatge de panell per a micro USB. (tot i que si estigués dissenyant des de zero, donaria una ullada a aquestes)

Per mantenir el tauler al seu lloc, formeu els suports L de llautó i soldeu-los a la part posterior de la placa d’accés. Això us permet una certa latitud en el posicionament. Per aconseguir un bon posicionament, primer creeu una placa de muntatge de perfboard (amb forats de muntatge) per a l'Arduino MICRO i poseu-hi els suports L mitjançant 2-56 cargols. A continuació, podeu ajustar la ubicació per alinear el port USB i marcar amb precisió les ubicacions dels suports de la placa. Traieu els suports del perfboard i soldeu-los al lloc. Finalment, munteu el conjunt del perfboard.

Vaig utilitzar quatre petits cargols de fusta de llautó per mantenir el tauler d’accés de llautó al seu lloc.

En aquest moment, recomano un ajust de prova abans que comenci el muntatge final. Aquest pas és opcional, però es recomana. És molt més fàcil fer ajustaments abans d’enganxar.

Pas 9: connecteu els cables al PCB; Connecteu i proveu l'electrònica

Encara no connecteu l'electrònica permanentment. Connecteu els cables a la PCB, assegurant-vos que deixeu prou folgats per fer enrere el forat d'accés. Aquests eventualment han d’estar connectats permanentment a la placa Arduino MICRO (les fotos mostren un Arduino UNO, que he utilitzat per al desenvolupament de codi)

Pas 10: fixeu el coll al cos de l'ukelele

Connecteu el coll al cos de l’Ukelele seguint les instruccions incloses amb el kit d’Ukelele. Vigileu particularment l’alineació de la superfície del diapasó amb el cos del uke.

Pas 11: perforar un forat d'accés per passar els cables de la PCB al cos

Un cop la cola estigui seca, foradeu un forat de ~ 1/4 (10 mm) en un angle per permetre que els cables de la PCB es dirigeixin cap al cos de l'Ukelele. Assegureu-vos de no danyar la taula de ressonància.

És possible que també hàgiu de crear una petita butxaca per permetre el gruix dels cables sota el tauler (o, opcionalment, posar les connexions a la part superior i incloure relleu al diapasó).

Un altre ajust de prova no estaria de més en aquest punt.

Pas 12: Alineeu i enganxeu el PCB i el diapasó al coll

Us suggereixo pensar en la subjecció (i provar-ho!) Abans d’enganxar. És possible que vulgueu formar un bloc en forma de part inferior del coll per obtenir una superfície de subjecció plana. El diapas és més gran que el coll en aquest punt, de manera que cal que ho permeteu.

Tingueu molta cura de no obtenir epoxi en cap superfície que vulgueu acabar més tard. És millor aplicar mascaratge a totes les superfícies sense enganxar abans d’enganxar per assegurar-vos que només vagi on volíeu.

Utilitzeu epoxi amb una vida laboral mínima de 60 minuts … ho necessiteu tot.

Enganxeu primer el PCB al seu lloc, assegurant-vos que l'excés de cola no s'extreu a la superfície d'encolat del diapasó. Això proporciona un mètode per alinear el diapasó al coll. El PCB té un acabat suau de màscara de soldadura, de manera que el vaig desbastar amb una mica de paper de vidre per donar a l’epoxi un acabat superficial lleugerament millorat.

Alineeu i enganxeu el diapasó al coll. Aneu amb compte de no deixar butxaques que després puguin resultar ressonants (buzz!). Tingueu també cura de no obtenir cola a les superfícies LED.

Un cop seca la cola, és possible que vulgueu connectar i provar l’electrònica una vegada més. Un mal LED us farà odiar la vida. Tenia un LED dolent (el primer!) Al prototip i vaig haver de fer una fusta creativa per accedir al LED defectuós i pegar-lo netament.

Pas 13: anivelleu les vores del diapasó al coll i afegiu-hi cables

Un cop la cola estigui seca, podeu començar a acabar les vores. Vaig tallar acuradament l’excés de diapasó (amb un molí) i vaig acabar l’últim mil·límetre mitjançant una polida manual.

Afegir els cables del trast es pot fer simplement amb un martell (amb una cara de plàstic per evitar que es trenquin). Simplement no martilleu massa fort. Si heu fet coincidir el cable de trast amb les ranures, haurien d’entrar sense moltes dificultats.

El que cal vigilar és trencar la fina superfície de la butxaca LED. Al prototip, vaig permetre que algunes butxaques LED (prop del 12è trast, on l’espai es redueix) s’estenguessin a la ranura del trast. Això és una mala idea, ja que això crea un punt feble que pot (i es va) esquerdar un cop inserit el filferro.

Pas 14: apliqueu l’emmascarament i apliqueu l’acabat a l’ukelele

Emmasqueu el diapasó (no s’acaba) i la zona d’encolat del pont i comenceu a aplicar l’acabat.

En emmascarar la zona del pont, llegiu les instruccions amb el vostre kit i, a continuació, comproveu la longitud de l’escala només per estar segur. El kit que vaig utilitzar per al prototip feia servir una longitud d’escala incorrecta i, per tant, proporcionava les dimensions incorrectes per ubicar el pont (però tenia una nota per comprovar les darreres instruccions al lloc web). El meu budell em va dir que estava malament, però vaig acceptar cegament l'autoritat.

Sempre és millor entendre PER QUÈ feu alguna cosa, en lloc de seguir cegament les instruccions.

Per acabar, hi ha molts tutorials de Luthiers que saben què fan al web, així que us recomano consultar-los abans de passar al procés d’acabat.

Jo, per descomptat, no ho vaig fer, així que vaig acabar fent servir un segellador equivocat, donant com a resultat una superfície molt granulosa. No ho facis.

Fes els deures.

Pas 15: Alineeu i fixeu el pont

Aquest pas és bastant senzill, però, de nou, planifiqueu el mètode de subjecció i proveu-ho amb antelació abans d’enganxar-lo. Vaig utilitzar una cola de fusta estàndard per fixar el pont.

Pas 16: instal·leu electrònica i proveu

Ara és el moment de fer que el cablejat sigui bonic. A més, no voleu que surti a l’interior del cos i que faci sorolls o pitjor encara que surti a l’escenari.

El codi Arduino es pot actualitzar a través del port USB, de manera que realment no cal desmuntar-lo tret que vulgueu jugar.

Pas 17: instal·leu afinadors i encordeu l’instrument

Probablement també haureu d’anivellar els trasts i jugar una mica amb la configuració, però per què us preocupeu ara, quan esteu tan a prop del final?

Vaig actualitzar els sintonitzadors i vaig fer servir cordes Aquila agradables, que no ajudaven en absolut el so. Tingueu-ho en compte, però, sense gastar diners en un ukelele de projecte …

Pas 18: programació de l'Uke

El codi Arduino final es troba a Github. Hi ha algunes línies al codi per donar suport a futures millores (com ara una funció de metrònom i "control lliscant" per a la pantalla (un element d'interfície d'usuari que sembla un control lliscant)

Aquest codi utilitza una biblioteca de codificadors rotatius (Rotary Encoder Arduino Library) per gestionar l'entrada de l'usuari des del codificador rotatiu.

També utilitza la biblioteca Adafruit Neopixel i el codi d'exemple que es troba aquí. Els modes teatre i arc de Sant Martí es deriven d’exemples proporcionats amb la biblioteca. (vegeu strandtest.ino).

Els sistemes 4D proporcionen el controlador de pantalla i es troba a Github aquí.

Hi ha dues funcions úniques implementades per al projecte Ukulele. El primer implementa la biblioteca d'acords i el segon mostra un missatge de text de desplaçament mitjançant un joc de caràcters personalitzat.

El diagrama adjunt mostra les ubicacions dels LED del diapasó i com estan connectats. El LED 0 es troba a l'extrem superior dret.

Pas 19: Com es mostra un acord

La funció displayChord mostra les posicions dels dits (per ara només la primera posició) per a cada acord. Els acords seleccionats per l'usuari (nota d'arrel i qualitat) s'emmagatzemen com un parell d'índexs. Al seu torn, s’utilitzen per buscar les digitacions de cada acord.

He utilitzat la notació "GCEA" per emmagatzemar acords (per exemple, "A" és "2100"). Els acords es pre-calculen per a cada nota arrel i s’emmagatzemen en una variable que correspon a la qualitat de l’acord. (per tant, A major, s'emmagatzema a la primera ubicació de la matriu "majorChords", corresponent a "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 "};

Tingueu en compte que, com que es tracta d’una cadena de text, cada dígit també podria representar un valor hexadecimal per tenir en compte posicions de trast superiors a 9. És a dir, A i B representarien els LED 10 i 11. Per als acords de primera posició, això no era un problema).

La cadena de LED es connecta longitudinalment en files de 12 (una octava) al llarg de cada cadena (començant per la cadena A), la tirada posterior de 12 comença al primer trast de la següent cadena (vegeu el diagrama del pas 18). Això és important per a l'algorisme per determinar quins llums s'encenen per a un acord determinat. Això vol dir que els píxels del 0 al 11 són els LED de la cadena A, del 12 al 23 són els LED de la cadena E, etc. En analitzar un A = "2100" (emmagatzemat com una cadena, també hi ha un terminador nul "\ n" al codi), ho interpretem com: no hi ha cap píxel a la cadena A ni a la cadena E, píxel 0 (trast 1) a la corda C s’encén i el píxel 1 (trast 2) a la corda G. Tingueu en compte que el "0" està apagat, no el primer LED. Basat en el cablejat, volem encendre els LED 24 i 37. A continuació es mostra el codi per mostrar un acord.

for (int i = 0; i <4; i ++) {if (int (acord - '0')) {// algorisme per analitzar la cadena d'acords int ledNumber = int (acord - '0') + (3 - i) * 12 - 1; // Vegeu la discussió anterior, el (3-i) és revertir l'índex strip.setPixelColor (ledNumber, 0, 125, 125); // setPixelColor (ledNumber, valor vermell, valor verd, valor blau)}}

La sentència if comprova si el led està desactivat. Si no ho és, pren el valor ascii del caràcter, l'acord , i resta el valor ascii de '0' per aconseguir que el ledNumber s'encengui.

strip és una instància de la classe Adafruit_NeoPixel. La funció setPixelColor estableix el color del píxel calculat (fixat en (0, 125, 125) en aquest cas.

Pas 20: Com es mostra un missatge de desplaçament

Així doncs, tenim una gamma de 12 x 4 de LEDs … per què no fer que mostri alguna cosa que no sigui patrons de llum força aleatoris?

El primer número és que l’alçada de la pantalla (4) és bastant limitada a causa del nombre de cadenes d’un Uke. El desplaçament horitzontal seria il·legible en la seva majoria, però en orientacions verticals podem admetre 4 x 5 caràcters que s’executen verticalment.

Organitzar els caràcters com a cinc files "verticals" significa que es poden mostrar dos caràcters simultàniament, permetent un espai d'una línia entre cada caràcter.

La dificultat era que no hi havia cap joc de caràcters estàndard de 4 x 5. Vaig fer el meu mitjançant el full de càlcul adjunt. He assignat cada fila a un valor hexadecimal únic (4 bits que representen quin píxel està activat o desactivat). La combinació dels cinc valors hexadecimals constitueix un caràcter (per exemple, "0" és 0x69996).

Els valors de cada caràcter s’emmagatzemen en una matriu en ordre ASCII. El joc de caràcters fa alguns compromisos amb certes lletres, però la majoria és raonablement clar. (els gargots a la part inferior del full de càlcul són idees amb què jugava, ja que tenim el color com a opció, podem afegir "profunditat" al personatge i, possiblement, obtenir una resolució addicional.

La cadena que es mostrarà es troba a la variable de cadena, missatge.

Es crea un buffer per representar la visualització de caràcters. Suposo que podria haver creat simplement un buffer gran amb tota la seqüència de missatges traduïts, sobretot perquè la majoria dels missatges tindran menys de 20 caràcters aproximadament. No obstant això, he optat per crear un buffer fix de tres caràcters (18 bytes). Només es mostren activament dos dels personatges i el tercer és mirar endavant, on es carrega el següent personatge. La cadena de LED (penseu-la com un registre de desplaçament gran) es carrega amb els 48 bits de la cadena. Vaig malgastar una mica d’espai de memòria per fer-ho més fàcil de conceptualitzar. Cada rosegada obté la seva pròpia ubicació de memòria, duplicant el requisit de memòria, però no es té molt en compte la mida de la memòria intermèdia.

La memòria intermèdia es carrega amb el caràcter següent quan l'índex de sortida (punter) arriba al límit de caràcters (outputPointer a 5, 11 o 17).

Per carregar la memòria intermèdia, agafem el primer caràcter de "missatge" com a valor ASCII i restem 48 per obtenir l'índex a la matriu asciiFont. El valor d’aquest índex s’emmagatzema a codedChar.

La primera part del missatge desplaçada correspon als LED 47, 35, 23 i 11 (la part inferior de la pantalla). Així doncs, pel número zero 0x0F999F, la F (esquerra) es desplaça en primer lloc, 9 segons, etc.

El següent personatge es carrega emmascarant cada rosegada i canviant-lo cap a la dreta. Per a l'exemple anterior, l'algorisme dóna (0x0F999F i 0xF00000) >> 20, després (0x0F999F i 0x0F0000) >> 16, etc.

índex int; if (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) {char displayChar = message.charAt (messagePointer); // agafa el primer caràcter del missatge long codedChar = asciiFont [displayChar - 48]; if (displayChar == 32) codedChar = 0x000000; messageBuffer [bytePointer + 5] = byte ((codedChar & 0xF00000) >> 20); // emmascara tots menys l'últim picet i canvia'l per 20 (i així successivament) messageBuffer [bytePointer + 4] = byte ((codedChar & 0x0F0000) >> 16); // això hauria de posar una picada per ubicació de memòria messageBuffer [bytePointer + 3] = byte ((codedChar & 0x00F000) >> 12); // els sis representen al personatge messageBuffer [bytePointer + 2] = byte ((codedChar & 0x000F00) >> 8); messageBuffer [bytePointer + 1] = byte ((codedChar & 0x0000F0) >> 4); messageBuffer [bytePointer] = byte ((codedChar & 0x00000F)); if (bytePointer == 0) {// gestiona el bucle al bytePointer bytePointer = 12; } else {bytePointer - = 6; // anem omplint de baix a dalt; NOTA: cal mirar cap enrere per veure si ho fa més fàcil} si (messagePointer == message.length () - 1) {// gestionar el bucle al missatge messagePointer = 0; } else {messagePointer + = 1; // passa al caràcter següent}}

Un cop carregat el buffer, es tracta de rastrejar on es troba el punter de sortida i carregar la cadena de LED amb els 48 bits correctes (els 4 actuals i els 44 anteriors). Com es va esmentar anteriorment, strip és una instància de la classe NeoPixel i setPixelColor estableix el color (RGB) de cada píxel. La funció show () canvia els valors de visualització a una cadena de LED.

// bucle per desplaçar contínuament la memòria intermèdia

// voleu escriure tota la franja a cada pas pel bucle, només canvia la ubicació inicial per a (int fila = 12; fila> 0; fila -) {índex = outputPointer + (12-fila); if (índex> 17) index = outputPointer + (12 files) -18; // bucle si és superior a 17 per a (int column = 4; column> 0; column--) {strip.setPixelColor (uint16_t (12 * (column-1) + (fila-1)), uint8_t (RedLED * (bitRead (messageBuffer [index], column-1))), uint8_t (GreenLED * (bitRead (messageBuffer [index], column-1))), uint8_t (BlueLED * (bitRead (messageBuffer [index], column-1))))); // a cada ubicació il·lumina el LED si el bit és únic}} // outputPointer apunta al byte més baix actual de la cadena de visualització si (outputPointer == 0) outputPointer = 17; else outputPointer - = 1; strip.show (); }

Pas 21: sorprengui el món amb la seva fantàstica ukelele

El prototip final de l’Ukelele va trigar uns 6 mesos a arrencar i arrencar.

Molta nova tecnologia per aprendre i potser una mica de fusta i teoria musical per arrencar.

Què cal fer per a la propera versió?

1. Desfeu-vos de la pantalla i del codificador rotatiu. Substituïu-los per un mòdul Bluetooth connectat a l'arduino. Controleu-lo remotament mitjançant un telèfon o una tauleta. Tot és millor amb Bluetooth.
2. Actualitzeu de forma remota els patrons d’acords en temps real. Queda el millor per a l'aplicació.
3. Cobertes LED. La versió actual no fa res per evitar que els gunk entrin als forats del LED. Un amic va fabricar un munt de lents petites, però mai no vaig saber com aconseguir que es quedessin al seu lloc correctament.
4. Alternar materials de diapasó, potser alguna cosa clar mentre es mantinguin els trasts.
5. Més llums! Elimineu la restricció del text afegint més "files". Aquesta és realment una limitació causada per la mida del diapasó i dels cossos LED.

Una vegada més, consulteu el document instructiu complementari que descriu el conjunt de caràcters que havia de crear per permetre el desplaçament de text.

Moltes gràcies per arribar fins aquí. Mahalo!