¡Cómo construir un ukelele iluminado !: 21 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Toco el ukelele. Un poco mediocre (si esa es una palabra), así que pensé, "si realmente quieres impresionar a las chicas, necesitas un medio para distraerlas del desastre que está sucediendo en el escenario". De ahí nació el "Ukulele iluminado".

Este proyecto toma un kit de ukelele de concierto y agrega un LED controlado por Arduino en cada posición de cuerda y traste. También agrega una elegante pantalla OLED y una interfaz de usuario basada en codificador rotatorio para seleccionar el modo y la intensidad de la cadena de LED.

Las características completas del hardware de uke:

1. Arduino MICRO para interactuar con la cadena de LED, la pantalla y el dispositivo de entrada.
2. 48 LED a todo color programables individualmente
3. Una pantalla OLED
4. Un codificador rotatorio para la entrada del usuario
5. Interfaz USB para alimentación externa y programación Arduino

El software de uke tiene:

1. Modos de control de luz básicos que hacen funcionar los LED a su ritmo
2. Un modo de marquesina de teatro ingenioso (¡muy útil para actuaciones!)
3. Control de intensidad LED
4. Una biblioteca de acordes completa de todos los acordes de ukelele de primera posición (valor de acorde y carácter)
5. Capacidad para mostrar texto en ejecución (verticalmente) utilizando un conjunto de caracteres único de 4 x 6 píxeles

Este instructable describe el prototipo completo. La saga de desarrollo completa está disponible AQUÍ, incluidos algunos errores educativos (dolorosos) y una valiosa lección sobre por qué DEBE terminar su primer diseño hasta su finalización (sin importar cuán feas se pongan las cosas). Nunca sabes todas las cosas que realmente no sabes hasta que llegas al final (¡y luego todavía no las sabes!), Pero estás mucho mejor y mucho más inteligente para el próximo diseño.

Construí el prototipo alrededor de un kit de ukelele de concierto de Grizzly. Comenzar con un kit alivia la preocupación por el cuerpo del uke (bueno, en su mayoría) y elimina la mayor parte del trabajo de tipo luthier real. Estos kits son bastante completos y no tan caros en el gran esquema de las cosas (y menos dolorosos ya que cometerá errores).

Paso 1: haz un plan

El diapasón (o diapasón) incluido en algunos kits ya tiene los trastes adjuntos. Eso es bueno / malo. Es bueno para ahorrar tiempo, pero en términos de diseñar un patrón de perforación y mantenerlo en su lugar mientras se fresa, es un poco molesto. Después de destruir el que se proporciona en el kit, opté (bueno, no tuve más remedio que comprar otro kit) por comprar un diapasón nuevo.

Al diseñar el diapasón, necesitamos calcular el aumento en el grosor requerido para incrustar el PCB y los LED (y no olvide los componentes pasivos), pero no tanto como para que los LED estén demasiado lejos de la superficie del diapasón.

La placa de circuito impreso LED (PCB) está diseñada como una placa simple de 2 capas. Esto ayuda mucho con el montaje manual de la cadena de LED y proporciona cierta resistencia mecánica (es fibra de vidrio y epoxi) al cuello del ukelele. Comencé el diseño en Eagle, pero terminé usando Altium Designer debido a las limitaciones de tamaño de la placa. Los archivos de PCB y el esquema de Altium están aquí.

El diapasón del kit tenía un grosor de apenas 0,125 pulgadas. Entonces, asumiendo un PCB de 0.062 pulgadas de grosor y permitiendo 0.062 pulgadas adicionales para los LED, significa que tendríamos que cortar mucho (como en todo) el diapasón. Para compensar, podemos cortar parcialmente los bolsillos para los LED en el diapasón con un bolsillo correspondiente en el cuello para el PCB, o podríamos reemplazar todo el diapasón (la opción con la que elegí) con una versión más gruesa de Luther Mercantile International (LMII), que son 0,25 pulgadas para empezar.

PERO, recuerde que aún tendrá que mecanizar el mástil para compensar el aumento de grosor en el diapasón. La otra ventaja que obtiene es cosmética, ya que la PCB ahora está completamente incrustada dentro del diapasón, lo que hace que los bordes sean mucho más fáciles de terminar (¡y se vean mucho mejor!) Y simplifica el fresado del mástil.

Cosas de ingeniería (ignora si quieres):

Por cierto, esto realmente no compromete tanto la rigidez del cuello. El material de PCB es mucho más rígido que la madera del diapasón original (módulo de caoba: 10.6 GPa versus módulo FR4: 24 GPa), además, dado que estamos construyendo un ukelele, no hay una gran cantidad de tensión de cuerda que de otra manera podría distorsionar (torcer o deformación) el cuello.

Una consideración muy interesante (que probablemente aún debería calcular) es lo que sucede con la temperatura. Genéricamente para la madera, paralela a la fibra, el coeficiente térmico de expansión es aproximadamente 3 x 10 ^ -6 / K, y para FR4 es 14 × 10 ^ −6 / K. Entonces, hay una diferencia bastante significativa. La preocupación es que se crea tensión en el mástil a medida que varía la temperatura, lo que a su vez desafina las cuerdas. Eso es algo que podría compensarse aplicando una capa similar en el lado opuesto del eje neutral o acercando el FR4 lo más posible al eje neutral. Pero eso quedará para 2.0 … Algo para modelar y evaluar.

La electrónica está alojada en el cuerpo del uke. Se cortan agujeros en la pared lateral (¡no en la caja de resonancia!) Del UKE para dejar espacio para la pantalla y el codificador rotatorio, además de una placa de acceso para sostener el Arduino Micro y proporcionar acceso a la interfaz USB. El diseño y la ubicación de la placa de acceso / montaje probablemente podrían mejorarse para que la conexión USB salga en una ubicación más conveniente, pero tal como está, no es tan malo, ya que no estorba cuando estás jugando.

El esquema de pasos es el siguiente:

1. Reúna materiales
2. Obtenga las herramientas que necesita
3. Fresa el mástil para acomodar el diapasón más grueso
4. Fresa el diapasón para hacer agujeros en las ubicaciones requeridas y crear bolsillos para la tabla y los LED
5. Obtenga y construya la PCB que sostiene los LED
6. Fresa orificios de acceso en el cuerpo del ukelele para la pantalla OLED, el codificador rotatorio y el panel de acceso
7. Hacer placas de cubierta
8. Conecte los cables a la PCB; conectar y probar la electrónica
9. Une el cuello al cuerpo del ukelele
10. Taladre una bodega de acceso para pasar los cables de la PCB al interior del cuerpo.
11. Alinee y pegue el PCB y el diapasón al mástil
12. Nivele los bordes del diapasón hasta el mástil (retire el material sobrante)
13. Instale los cables del traste
14. Aplicar enmascaramiento y aplicar acabado al ukelele.
15. Alinear y colocar el puente
16. Instale la electrónica y pruebe.
17. Instale afinadores y encorde el instrumento
18. Programar el controlador Uke
19. ¡Asombra al mundo con tu genialidad de ukelele!

Paso 2: Reúna los materiales

Nuestra lista de materiales se ve así:

1. Kit de ukelele: utilicé un kit de ukelele de concierto de Grizzly (Grizzly Uke Kit en Amazon), pero parece que se descontinuará. Zimo hace un modelo similar (Zimo Uke Kit @ Amazon) que parece que hará el trabajo
2. Diapasón de ukelele, pre-ranurado (LMII Uke Fingerboards). Colocarán el diapasón en tu escala, lo que te evitará muchos problemas.
3. Epoxi: para pegar el diapasón al mástil. Elegí epoxi porque es compatible con el material de PCB. Busque algo con al menos 60 minutos de vida laboral. NO use tipos de 5 minutos, necesita tiempo para hacer ajustes
4. Cables de traste - también disponibles en LMII
5. PCB personalizado: los archivos Altium están aquí. Opté por material tipo FR4 normal. Las placas Flex (poliimida) serían una alternativa interesante (aunque más cara), ya que pueden ser mucho más delgadas.
6. 48 LEDs de Neopixel (SK6812). Disponible en Adafruit y Digikey
7. 48 x 0.1uF 0402 caps - más grande es aceptable, pero debe vigilar la ubicación
8. Cable de conexión: al menos de 4 a 6 colores para evitar confusiones, utilicé principalmente cable de calibre 28. Observe la caída de CC en las conexiones de alimentación del LED (tanto VCC como TIERRA … ¡esa corriente tiene que regresar a la fuente!)
9. Codificador rotatorio - PEC16-4220F-S0024
10. Pomo de madera de lujo - para el codificador rotatorio (obtuve el mío de LMII)
11. Pantalla OLED: de pantallas OLED de sistemas 4D
12. Batería USB externa: más barata todo el tiempo, ¡además puedes llevar repuestos!
13. Arduino MICRO
14. Hoja de latón: para hacer que la placa sujete el arduino y el bisel para la pantalla
15. Consumibles varios que incluyen: papel de lija, acabado de uretano, palitos de helado, bandas de goma, soldadura, fundente, cepillos, cinta de doble cara (me gusta la cinta UHC de 3M) y pequeños tornillos para madera de latón (para la placa)
16. Mejoras opcionales de ukelele: mejores afinadores, mejores cuerdas, mejor cejilla y montura, incrustaciones si desea mostrar su destreza como luthier)

Paso 3: obtenga las herramientas que necesita

Tarde o temprano necesitará obtener u obtener acceso a estos:

Nuestra lista de herramientas incluye:

1. Fresadora: se prefiere el CNC, pero es posible que incluso se las arregle con un enrutador y mucha suerte. Usé una fresadora / enrutador CNC combinada
2. Brocas de enrutador: se prefiere el carburo. Brocas de enrutador elegidas sobre fresas de extremo ya que estamos mecanizando madera, no metal
3. Abrazaderas, muchas. Se necesita principalmente para sujetar piezas mientras se pega
4. Soldador - punta pequeña para soldadura de montaje en superficie
5. Microscopio o lupa: puede intentar soldar solo con sus ojos, pero no lo recomendaría, 10x mínimo
6. Pinzas (para colocar piezas en su lugar)
7. Herramientas de trastes (vea las herramientas adecuadas en LMII aquí, pero usé lo que tenía en casa y me las arreglaba; martillos, limas y cortadores)
8. Herramientas manuales variadas como cinceles para madera, destornilladores, martillo de golpe suave o de cuero sin curtir (para fretting), etc.
9. Abrasivos: varios granos de papel de lija

Nuestras herramientas de software incluyen (algunas son opcionales según su presupuesto / ingenio):

1. Software arduino
2. El código fuente de Ukulele (https://github.com/conrad26/Ukulele)
3. Paquete de diseño de PCB: utilicé Altium porque la versión gratuita de Eagle no admitía el tamaño de placa que quería. Altium es un paquete de diseño con todas las funciones y no está realmente en un rango de precios para aficionados. He incluido los archivos Gerber en mi sitio para el prototipo, pero definitivamente necesitan una actualización.
4. Software de modelado 3D: utilicé SolidWorks, pero una alternativa gratuita es FreeCAD (https://www.freecadweb.org/)
5. Software CAM - como FeatureCAM de Autodesk para crear el archivo de fresado NC.

La combinación de la exportación de archivos de pasos 3D de Altium junto con un modelo 3D del diapasón elimina gran parte de la dificultad para asegurarse de que todo esté alineado, pero no es un requisito. Un diseño cuidadoso logrará el mismo resultado.

Ahora que sabemos lo que queremos hacer y lo que tenemos que hacer, construyamos un ukelele.

Paso 4: Fresa el mástil para adaptarse al diapasón más grueso

Antes de fresar, tenga en cuenta que DEBE mantenerse la planitud de la superficie de montaje del diapasón original, o tendrá un diapasón torcido, lo que conduce a todo tipo de problemas con la nivelación de los trastes.

Simplemente no vaya allí, tómese su tiempo y sujete el cuello con cuidado y rigidez y verifique la alineación con la broca del enrutador en todo el cuello antes de cortar. El tiempo que pase aquí le ahorrará mucho dolor más adelante.

Una de las razones por las que opté por un diapasón más grueso sobre una incrustación en el mástil fue el aumento del área de superficie de montaje (pegado). Otra razón es que simplifica el fresado del cuello. Simplemente corte toda la superficie a la altura requerida.

Paso 5: Obtenga y construya la PCB que sostiene los LED

Soldé a mano todo el conjunto. Los paquetes de LED son especialmente fáciles de fundir, así que tenga cuidado de no dañarlos. Sugiero usar una correa estática, ya que la cuerda depende de que todos los LED funcionen.

El diseño del diapasón se basa en los LED WS2812B. Decidí hacer solo la primera octava del diapasón (¡¡48 LED !!). Cada LED puede considerarse como un bit en un registro de desplazamiento. El registro de desplazamiento tiene una frecuencia de 800 kHz. Usé la biblioteca Adafruit (ver la sección de programación) para poner las cosas en marcha rápidamente.

Comencé el diseño en Eagle, pero el tamaño de la placa está limitado a 4 x 5 pulgadas, así que tuve que (o más correctamente, opté por) cambiar a Altium. Utilizo Altium en el trabajo, así que, en realidad, me hizo las cosas más rápidas. El proyecto Altium, los archivos esquemáticos y pcb (y las partes de la biblioteca) están en mi sitio. La tabla tiene forma trapezoidal y mide aproximadamente 10 pulgadas de largo. Creo que debería haber intentado comprimir el contorno un poco más (¡siguiente giro!). El ensamblaje no estuvo mal, pero si puedes pagarlo, realmente recomiendo un soldador decente (Soldadores JBC) y un buen microscopio. Sí, estoy malcriado y no, no tengo ese tipo de cosas en el laboratorio de mi casa. Soy tacaño.

Hice las tablas en Sunstone. $ 129 por dos tablas. Vuelta garantizada de una semana. Sin embargo, no escatime en el envío. No me di cuenta de que usaba UPS Ground y terminé esperando una semana más para que llegaran mis tablas. El tiempo total de montaje fue de aproximadamente 2 horas (98 piezas).

Paso 6: fresar el diapasón

Necesitamos fresar el diapasón para hacer agujeros en las ubicaciones requeridas y crear bolsillos para el tablero y los LED.

Creé un modelo 3D del diapasón completo en Solidworks y creé la rutina de fresado CNC usando FeatureCAM.

La parte inferior del diapasón (más cercana a la boca) deberá hacerse más delgada para tener en cuenta el cambio de altura entre el mástil y el cuerpo. Definitivamente vale la pena probar el ajuste varias veces para asegurarse de que quede razonablemente ceñido.

En retrospectiva, debería haber cortado las partes no utilizadas del diapasón para que se ajustara mejor al molino (mi molino barato solo tenía un recorrido del eje X de 12 ). El orden de operaciones debe configurarse para los primeros ajustes de espesor del molino antes fresado de bolsillos, lo que debería conducir a menos rupturas entre los bolsillos.

Realice los ajustes manuales necesarios para agregar espacio para el cableado. Una cosa importante a tener en cuenta es que en algunos de los bolsillos, rompí la ranura donde irá el alambre del traste. Dado que es un conductor, asegúrese de que no termine cortocircuitando nada importante. También disminuye la resistencia del material que mantiene el traste en su lugar. El diseño debe modificarse para que nunca se cruce con una ranura de traste.

Paso 7: orificios de acceso al molino en el cuerpo del ukelele

Fresé manualmente los orificios de acceso en el cuerpo. La parte más difícil es encontrar la región "más plana" de lo que es una superficie muy curva. Marque el contorno con lápiz y elimine gradualmente el material hasta que se ajuste perfectamente a la pantalla OLED. Obtuve un bisel de latón mecanizado y lo coloqué con cinta adhesiva 3M VHB.

Dado que ninguno de los dos requiere una gran precisión, el codificador rotatorio y los orificios del panel de acceso son mucho más fáciles de crear.

Paso 8: hacer placas de cubierta

También necesita fabricar las placas de cubierta para el bisel de la pantalla y el panel de acceso. El panel de acceso necesita un orificio (rectangular) para el conector USB (micro). Simplemente use el conector existente en el Arduino, ya que no hay muchas opciones de montaje en panel para micro USB. (aunque si estuviera diseñando desde cero, le daría un vistazo a uno de estos)

Para mantener la placa en su lugar, forme soportes en L de latón y suéldelos a la parte posterior de la placa de acceso. Esto le permite cierta latitud en el posicionamiento. Para obtener el posicionamiento correcto, primero cree una placa de montaje perfboard (con orificios de montaje) para el Arduino MICRO y fije los soportes en L con tornillos de máquina 2-56. Luego, puede modificar la ubicación para alinear el puerto USB y marcar con precisión las ubicaciones de los soportes en la placa. Retire los soportes de la placa perfilada y suéldelos en su lugar. Finalmente monte el conjunto de la placa perfilada.

Usé cuatro tornillos pequeños de latón para madera para sujetar el panel de acceso de latón en su lugar.

En este punto, recomiendo un ajuste de prueba antes de que comience el ensamblaje final. Este paso es opcional pero recomendado. Es mucho más fácil hacer ajustes antes de pegar.

Paso 9: Conecte los cables a la PCB; Conecte y pruebe la electrónica

No conecte permanentemente los componentes electrónicos todavía. Conecte los cables a la PCB, asegurándose de dejar suficiente holgura para enrutar el orificio de acceso. Estos eventualmente deben estar conectados permanentemente a la placa Arduino MICRO (las fotos muestran un Arduino UNO, que utilicé para el desarrollo de código)

Paso 10: une el cuello al cuerpo del ukelele

Fije el mástil al cuerpo del Ukulele siguiendo las instrucciones incluidas con el kit de Ukulele. Observe particularmente la alineación de la superficie del diapasón con el cuerpo del uke.

Paso 11: Perfore un orificio de acceso para pasar los cables de la PCB al cuerpo

Una vez que el pegamento esté seco, taladre un orificio de ~ 1/4 (10 mm) en ángulo para permitir que los cables de la PCB pasen al cuerpo del ukelele. Asegúrese de no dañar la tapa armónica.

Es posible que también deba crear un pequeño bolsillo para permitir el grosor de los cables debajo de la tabla (u opcionalmente, coloque las conexiones en la parte superior e incluya un relieve en el diapasón).

Otro ajuste de prueba no estaría de más en este momento.

Paso 12: Alinee y pegue la PCB y el diapasón al mástil

Sugiero pensar en la sujeción (¡y probarla!) Antes de pegar. Es posible que desee crear un bloque en la parte inferior del cuello para darle una superficie de sujeción plana. El diapasón es más grande que el mástil en este punto, por lo que debes tenerlo en cuenta.

Tenga mucho cuidado de no aplicar epoxi en ninguna superficie que desee terminar más tarde. Mejor aún, aplique enmascaramiento a todas las superficies no pegadas antes de pegar para asegurarse de que solo vaya a donde pretendía.

Utilice epoxi con una vida útil mínima de 60 minutos … lo necesitará todo.

Primero pegue la PCB en su lugar, asegurándose de que el exceso de pegamento no se pegue en la superficie de pegado del diapasón. Esto proporciona un método para alinear el diapasón con el mástil. El PCB tiene un acabado de máscara de soldadura suave, así que lo lijé con un poco de papel de lija para darle al epoxi un acabado superficial ligeramente mejorado.

Alinea y pega el diapasón al mástil. Tenga cuidado de no dejar bolsas que luego puedan volverse resonantes (¡zumbido!). También tenga cuidado de no manchar las superficies de los LED con pegamento.

Una vez que el pegamento esté seco, es posible que desee cablear y probar los componentes electrónicos una vez más. Un LED defectuoso te hará odiar la vida. Tenía un LED defectuoso (¡el primero!) En el prototipo y tuve que hacer un trabajo en madera creativo para acceder al LED defectuoso y repararlo limpiamente.

Paso 13: Nivele los bordes del diapasón hasta el mástil y agregue los alambres del traste

Una vez que el pegamento esté seco, puede comenzar a terminar los bordes. Corté con cuidado el exceso de material del diapasón (usando un molino) y terminé el último milímetro lijando a mano.

La adición de los alambres de los trastes se puede hacer simplemente con un martillo (con una cara de plástico para evitar que se estropeen). Simplemente no martillees demasiado fuerte. Si ha hecho coincidir el cable del traste con las ranuras, deberían entrar sin mucha dificultad.

Lo que debe vigilar es romper la delgada superficie del bolsillo LED. En el prototipo, dejé que algunos bolsillos de LED (cerca del duodécimo traste, donde el espacio se estrecha) se extendieran hacia la ranura del traste. Esa es una mala idea, ya que crea un punto débil que puede (y lo hizo) agrietarse una vez que se inserta el alambre del traste.

Paso 14: aplique enmascaramiento y aplique acabado al ukelele

Enmascare el diapasón (no se termina) y el área de pegado del puente y comience a aplicar el acabado.

Al enmascarar el área del puente, lea las instrucciones con su kit, luego verifique la longitud de la escala solo para estar seguro. El kit que utilicé para el prototipo usó la longitud de escala incorrecta y, por lo tanto, proporcionó las dimensiones incorrectas para ubicar el puente (¡pero tenía una nota para consultar el sitio web para obtener las últimas instrucciones!). Mi instinto me dijo que estaba mal, pero acepté ciegamente la autoridad.

Siempre es mejor entender POR QUÉ estás haciendo algo, en lugar de seguir ciegamente las instrucciones.

Para finalizar, hay muchos tutoriales de Luthiers que saben lo que están haciendo en la web, así que recomiendo consultarlos antes de saltar al proceso de acabado.

Yo, por supuesto, no hice eso, así que terminé usando el sellador equivocado, lo que resultó en una superficie muy granulada. No hagas eso.

Haz tu tarea.

Paso 15: alinee y coloque el puente

Este paso es bastante sencillo, pero nuevamente, planifique su método de sujeción y pruébelo con anticipación antes de pegar. Usé un pegamento para madera estándar para unir el puente.

Paso 16: Instale la electrónica y pruebe

Ahora es el momento de hacer que su cableado sea bonito. Además, no querrás que se mueva dentro del cuerpo y haga ruidos de zumbido o, peor aún, rompa en el escenario.

El código Arduino se puede actualizar a través del puerto USB, por lo que realmente no hay necesidad de desarmarlo a menos que quieras jugar.

Paso 17: Instale los afinadores y encorde el instrumento

Es probable que también necesites nivelar los trastes y jugar un poco con la configuración, pero ¿por qué preocuparte ahora, cuando estás tan cerca del final?

Actualicé los afinadores y usé bonitas cuerdas Aquila, que no ayudaron en absoluto al sonido. Así que tenlo en cuenta mientras gastas dinero en un proyecto de ukelele …

Paso 18: Programando el Uke

El código final de Arduino está en Github. Hay algunas líneas en el código para admitir mejoras futuras (como una función de metrónomo y "controles deslizantes" para la pantalla (un elemento de la interfaz de usuario que parece un control deslizante)

Este código utiliza una biblioteca de codificador rotatorio (biblioteca Arduino de codificador rotatorio) para manejar la entrada del usuario desde el codificador rotatorio.

También utiliza la biblioteca Adafruit Neopixel y el código de ejemplo que se encuentra aquí. Los modos de teatro y arco iris se derivan de ejemplos proporcionados con la biblioteca. (ver strandtest.ino).

El controlador de pantalla lo proporcionan los sistemas 4D y se encuentra en Github aquí.

Hay dos funciones únicas implementadas para el proyecto Ukulele. El primero implementa la biblioteca de acordes y el segundo muestra un mensaje de texto que se desplaza usando un juego de caracteres personalizado.

El diagrama adjunto muestra las ubicaciones de los LED del diapasón y cómo están conectados. El LED 0 se encuentra en la esquina superior derecha.

Paso 19: Cómo mostrar un acorde

La función displayChord muestra las posiciones de los dedos (la primera posición solo por ahora) para cada acorde. Los acordes seleccionados por el usuario (nota fundamental y calidad) se almacenan como un par de índices. Estos, a su vez, se utilizan para buscar las digitaciones de cada acorde.

Usé la notación "GCEA" para almacenar acordes (por ejemplo, "A" es "2100"). Los acordes se calculan previamente para cada nota fundamental y se almacenan en una variable correspondiente a la calidad del acorde. (por lo tanto, A mayor, se almacena en la primera ubicación de la matriz "majorChords", correspondiente 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 "};

Tenga en cuenta que, dado que se trata de una cadena de texto, cada dígito también podría representar un valor hexadecimal para tener en cuenta las posiciones de los trastes superiores a 9. Es decir, A y B representarían los LED 10 y 11. Para los acordes de la primera posición, esto no fue un problema).

La cuerda de LED está cableada a lo largo en filas de 12 (una octava) a lo largo de cada cuerda (comenzando con la cuerda A), la siguiente serie de 12 comienza en el primer traste de la siguiente cuerda (vea el diagrama en el paso 18). Esto es importante para que el algoritmo determine qué luces encender para un acorde dado. Eso significa que los píxeles del 0 al 11 son los LED de la cadena A, del 12 al 23 son los LED de la cadena E, y así sucesivamente. Al analizar un A = "2100" (almacenado como una cadena, también hay un terminador nulo "\ n" en el código), lo interpretamos como: no hay píxeles en la cadena A, ni en la cadena E, píxel 0 (traste 1) en la cuerda C está iluminado y el píxel 1 (traste 2) en la cuerda G. Tenga en cuenta que un "0" está apagado, no el primer LED. En función del cableado, queremos encender los LED 24 y 37. A continuación se muestra el código para mostrar un acorde.

for (int i = 0; i <4; i ++) {if (int (chord - '0')) {// algoritmo para analizar la cadena de acordes int ledNumber = int (chord - '0') + (3 - i) * 12 - 1; // ver la discusión anterior, el (3-i) es invertir el índice strip.setPixelColor (ledNumber, 0, 125, 125); // setPixelColor (ledNumber, valor rojo, valor verde, valor azul)}}

La sentencia if comprueba si el led está apagado. Si no es así, toma el valor ascii del carácter, acorde , y resta el valor ascii de '0' para que el ledNumber se ilumine.

strip es una instancia de la clase Adafruit_NeoPixel. La función setPixelColor establece el color del píxel calculado (fijado en (0, 125, 125) en este caso.

Paso 20: Cómo mostrar un mensaje de desplazamiento

Así que tenemos una matriz de LED de 12 x 4 … ¿por qué no hacer que muestre algo más que patrones de luz bastante aleatorios?

El primer problema es que la altura de la pantalla (4) es bastante limitada debido al número de cadenas en un Uke. El desplazamiento horizontal sería en su mayoría ilegible, pero en orientaciones verticales, podemos admitir caracteres de 4 x 5 que se ejecutan verticalmente.

Organizar los caracteres como cinco filas "verticales" significa que se pueden mostrar dos caracteres simultáneamente permitiendo un espacio de una línea entre cada carácter.

La dificultad era que no había un juego de caracteres estándar de 4 x 5. Hice la mía usando la hoja de cálculo adjunta. Asigné cada fila a un único valor hexadecimal (4 bits que representan qué píxel está encendido o apagado). La combinación de los cinco valores hexadecimales constituye un carácter (por ejemplo, "0" es 0x69996).

Los valores de cada carácter se almacenan en una matriz en orden ASCII. El conjunto de caracteres hace algunos compromisos con ciertas letras, pero la mayoría es razonablemente clara. (Los garabatos en la parte inferior de la hoja de cálculo son ideas con las que estaba jugando, ya que tenemos el color como una opción, podemos agregar "profundidad" al personaje y posiblemente obtener una resolución adicional.

La cadena que se mostrará está contenida en la variable de cadena, mensaje.

Se crea un búfer para representar la visualización de caracteres. Supongo que simplemente podría haber creado un búfer grande con toda la secuencia de mensajes traducidos, especialmente porque la mayoría de los mensajes tendrán menos de 20 caracteres aproximadamente. Sin embargo, opté por crear un búfer fijo de tres caracteres (18 bytes). Solo dos de los personajes se muestran activamente, y el tercero es una mirada hacia adelante, donde se carga el siguiente personaje. La cadena de LED (piense en ello como un gran registro de desplazamiento) se carga con los 48 bits de la cadena. Perdí algo de espacio en la memoria para hacer esto más fácil de conceptualizar. Cada nibble obtiene su propia ubicación de memoria, duplicando el requisito de memoria, pero no es mucho dado el tamaño del búfer.

El búfer se carga con el siguiente carácter cuando el índice de salida (puntero) llega a un límite de carácter (outputPointer en 5, 11 o 17).

Para cargar el búfer, tomamos el primer carácter en "mensaje" como un valor ASCII y restamos 48 para obtener el índice en la matriz asciiFont. El valor en ese índice se almacena en codedChar.

La primera parte del mensaje desplazada corresponde a los LED 47, 35, 23 y 11 (la parte inferior de la pantalla). Entonces, para el número cero 0x0F999F, la F (la izquierda) se desplaza en primer lugar, en 9 segundos y así sucesivamente.

El siguiente carácter se carga enmascarando cada mordisco y moviéndolo hacia la derecha. Para el ejemplo anterior, el algoritmo da (0x0F999F y 0xF00000) >> 20, luego (0x0F999F y 0x0F0000) >> 16, etc.

int index; if (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) {char displayChar = message.charAt (messagePointer); // toma el primer carácter del mensaje long codedChar = asciiFont [displayChar - 48]; if (displayChar == 32) codedChar = 0x000000; messageBuffer [bytePointer + 5] = byte ((codedChar & 0xF00000) >> 20); // enmascara todo menos el último nibble y lo cambia 20 (y así sucesivamente) messageBuffer [bytePointer + 4] = byte ((codedChar & 0x0F0000) >> 16); // esto debería poner un nibble por ubicación de memoria messageBuffer [bytePointer + 3] = byte ((codedChar & 0x00F000) >> 12); // los seis representan en el carácter messageBuffer [bytePointer + 2] = byte ((codedChar & 0x000F00) >> 8); messageBuffer [bytePointer + 1] = byte ((codedChar & 0x0000F0) >> 4); messageBuffer [bytePointer] = byte ((codedChar & 0x00000F)); if (bytePointer == 0) {// maneja el bucle alrededor del bytePointer bytePointer = 12; } else {bytePointer - = 6; // estamos llenando de abajo hacia arriba; NOTA: es necesario revertir esto para ver si lo hace más fácil} if (messagePointer == message.length () - 1) {// manejar el bucle alrededor del mensaje messagePointer = 0; } else {messagePointer + = 1; // pasar al siguiente carácter}}

Una vez que se carga el búfer, se trata de rastrear dónde está el puntero de salida y cargar la cadena de LED con los 48 bits correctos (los 4 actuales y los 44 anteriores). Como se mencionó anteriormente, strip es una instancia de la clase NeoPixel y setPixelColor establece el color (RGB) de cada píxel. La función show () desplaza los valores de la pantalla a la cadena de LED.

// bucle para desplazar continuamente el búfer

// desea escribir la tira completa en cada pasada a través del bucle, solo cambia la ubicación inicial para (int fila = 12; fila> 0; fila--) {index = outputPointer + (12-row); if (índice> 17) índice = outputPointer + (12 filas) -18; // repite si es mayor que 17 para (int column = 4; column> 0; column--) {strip.setPixelColor (uint16_t (12 * (column-1) + (row-1)), uint8_t (RedLED * (bitRead (messageBuffer [índice], columna-1))), uint8_t (GreenLED * (bitRead (messageBuffer [índice], columna-1))), uint8_t (BlueLED * (bitRead (messageBuffer [índice], columna-1)))); // en cada ubicación enciende el LED si el bit es uno}} // outputPointer apunta al byte más bajo actual en la cadena de visualización if (outputPointer == 0) outputPointer = 17; else outputPointer - = 1; strip.show (); }

Paso 21: ¡Sorprenda al mundo con su asombro de ukelele

El prototipo final de Ukulele tomó alrededor de 6 meses de arranques y paradas para llevarse a cabo.

¡Mucha nueva tecnología para aprender y tal vez algo de carpintería y teoría musical para arrancar!

¿Qué hacer para la próxima versión?

1. Deshazte de la pantalla y el codificador rotatorio. Reemplácelos con un módulo Bluetooth conectado al arduino. Contrólalo de forma remota con un teléfono o una tableta. Todo es mejor con Bluetooth.
2. Actualice de forma remota los patrones de acordes en tiempo real. Es mejor dejar algo para la aplicación.
3. Cubiertas LED. La versión actual no hace nada para evitar que entre suciedad en los orificios de los LED. Un amigo hizo un montón de lentes pequeños, pero nunca pude averiguar cómo hacer que se mantuvieran en su lugar correctamente.
4. Materiales alternativos del diapasón, tal vez algo claro siempre que los trastes se mantengan.
5. ¡Más luces! Elimine la restricción en el texto agregando más "filas". Esta es realmente una limitación causada por el tamaño del diapasón y los cuerpos de los LED.

Nuevamente, vea el Instructable complementario que describe el conjunto de caracteres que tuve que crear para permitir el desplazamiento del texto.

¡Muchas gracias por llegar tan lejos! Mahalo!