Ukelele electrónico inteligente DIY con Arduino: 14 pasos (con imágenes)

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

Vamos a explicarte paso a paso cómo puedes diseñar tu propio ukelele y agregar algunos efectos que lo harán único, como dibujar algo que queramos en la superficie del ukelele o agregar algunos efectos de luz.

Para hacer eso, es necesario comprar un kit de ukelele.

Vamos a explicar cómo montar el instrumento y solucionar los diferentes problemas que puedan aparecer.

Paso 1: Materiales

Materiales de estructura:

Kit de montaje DIY ukelele (podría ser otro kit diferente) formado por:

1- Cuerpo.

2 cuellos.

3 sillín

Soporte de 4 cuerdas

5 puentes

Tuerca de 6 hilos.

7-Anillo de fijación para cabezal de máquina (x4).

8-Cabezales de máquina (x4).

9-Tornillos de montaje para cabezales de máquina (x8).

10-Tornillos de montaje para puente de máquina (x2).

11-Tapas para tornillos de montaje en puente (x2).

12 cuerdas (x4).

Materiales electrónicos:

• NANO Arduino.
• Rueda de Leds WS2812.
• Acelerómetro BMA220 (opcional).
• Conector de bateria.
• Batería de 9V.
• Cambiar.

Otros

• Barniz para madera.
• Velcro.
• Estaño para soldar.
• Plástico protector para barnizar.
• Silicona termofusible.

Instrumentos:

• Grabado láser.
• Papel de lija
• Destornillador estrella.
• Cepillo de pintura.
• Pistola termofusible.
• Soldador de estaño.

Paso 2: personaliza el ukelele

Para personalizar nuestro ukelele podríamos realizar un grabado de un dibujo con un cortador láser en el cuerpo. En el caso de no tener esa herramienta, podríamos pintarla.

La imagen que hemos elegido es la primera que aparece.

En primer lugar, tenemos que diseñar la plantilla de dibujo para realizar el grabado.

Para ello utilizaremos un software llamado 'Inkscape' que podríamos obtener en este enlace:

Para usarlo, debemos ajustar la imagen que queremos usar como mostramos en la segunda imagen. Podrías mirar que hemos rotado la imagen inicial para poder ajustar el ciclo de la mano con el círculo del instrumento. Como hemos dicho antes, podrías poner cualquier imagen.

Paso 3: vectorizar una imagen con Inkscape

Veremos cómo crear un archivo vectorial a partir de un mapa de píxeles (jpg, png, cualquier formato ráster que pueda abrir Inkscape).

Inkscape Inkscape es un editor de gráficos vectoriales de código abierto y, como indica el título, esta es la herramienta que usaré para vectorizar los logotipos. Pasos de vectorización Los pasos son comunes para cualquier vectorización que deseemos realizar.

1. Abra la imagen en Inkscape
2. Abra la ruta de la herramienta Trazar mapa de bits-> Trazar mapa de bits
3. Juega con las opciones de Trace Bitmap
4. Ejecute el rastreo
5. Limpiar los resultados (si es necesario)

Tenga en cuenta la parte de "jugar". No soy un experto en rastreo, por lo que trato esta herramienta como una caja negra con perillas y luces, girando y cambiando hasta obtener el mejor resultado.

Paso 4: grabado del logotipo

Para ello, es importante tener una silueta de la superficie sobre la que se realizará el grabado del dibujo.

Para realizar el grabado, usaremos el software 'T2Laser'. Podríamos obtener este software en:

Una vez que hemos abierto el software, tenemos que cargar la imagen que hemos creado en el último paso. Luego, presione el botón "control láser", y aparecen los controles cnc. Las dos imágenes muestran el proceso y el resultado del grabado con nuestra cortadora láser.

Paso 5: lijado y barnizado

Para dejar nuestro ukelele brillante y con una capa sin rugosidad podemos lijar suavemente las dos partes que componen nuestro instrumento con cuidado, porque podemos dañar el dibujo que se ha realizado (si has optado por pintar el ukelele, tendrías que lijarlo primero). Luego barnizaremos nuestras dos partes para que obtengan un color más oscuro y la madera presente más resistencia. Podemos utilizar un barniz para madera normal, no hace falta que sea especial.

Una vez tenemos el barniz lo mezclamos con un poco de disolvente para que se disuelva un poco. A continuación, aplicamos la mezcla con una brocha en el cuello y el cuerpo del instrumento y lo dejamos secar.

Si vemos que el producto necesita una segunda mano, podemos lijar un poco las dos partes y volver a aplicar una capa de barniz diluido.

** PRECAUCIONES: El barniz es un producto químico, por lo que es necesario realizar este proceso en un lugar ventilado, llevar mascarilla para evitar inhalar olores y gafas protectoras.

Los materiales que necesitamos para poder funcionar correctamente son los que aparecen en las fotos. Principalmente trabajaremos con un pincel, una lata de barniz (en nuestro caso de color rojo), un poco de disolvente y protección visual. Y sobre todo trabajar en espacios bien ventilados.

Paso 6: hardware

Nuestra placa con el Arduino, el acelerómetro y la rueda con leds se van a introducir en un pequeño soporte para evitar que todos los componentes se muevan en el instrumento.

También hemos agregado un portapilas y un interruptor para que sea más cómodo y no gastemos la batería cuando no estamos usando el instrumento. Fijaremos este soporte con un trozo de velcro (también funcionaría con silicona y una pistola hot melt) a la cara interior del cuerpo del ukelele, por otro lado la rueda LED es más pequeña que el agujero, por lo que se caería. Se ha diseñado un soporte para que se mantenga bien y pueda realizar su función.

Paso 7: software

Para darle una decoración especial a nuestro ukelele, podríamos añadir efectos de luz gracias a una rueda de leds. Vamos a utilizar el WS2812, pero puede utilizar cualquier otro siguiendo las instrucciones de la hoja de datos. También usaremos un acelerómetro (BMA220), que nos permitirá hacer un efecto de la gravedad.

De hecho, tendremos 4 juegos de luces, incluidos en la biblioteca informática llamada 'Adafruit' de Arduino. Para eso, debemos hacer una correcta conexión entre los tres componentes: Arduino NANO, WS2812 y BMA220, como aparece en la primera imagen.

Los cables rojos son para alimentación, los GND negros y el resto son conexiones necesarias para el correcto funcionamiento. El código que usamos para el kit de luces se adjunta en un archivo llamado "play_of_light_v0.ino". Asegúrate de haber incluido las bibliotecas necesarias para el correcto funcionamiento del programa. La batería que agregamos externa al circuito debe tener un voltaje mínimo de 9V y tenemos que asegurarnos de que sea capaz de dar la corriente mínima necesaria para alimentar todo el circuito.

// Contador de variables e interrupciónint contador; // Variables Ejemplo gravedad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

Versión de bytes [3];

int8_t x_data; int8_t y_data; int8_t z_data; rango de bytes = 0x00; flotador divi = 16; flotar x, y, z; flotador pi = 3,14159265359; flotar nx, ny, ángulo; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Variables Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parámetro 1 = número de píxeles en la tira // Parámetro 2 = número de pin de Arduino (la mayoría son válidos) // Parámetro 3 = indicadores de tipo de píxel, agregue según sea necesario: // NEO_KHZ800 800 KHz bitstream (la mayoría de los productos NeoPixel con LED WS2812) // NEO_KHZ400 400 KHz (píxeles FLORA clásicos 'v1' (no v2), controladores WS2811) // NEO_GRB Los píxeles están conectados para GRB bitstream (la mayoría de los productos NeoPixel) / / NEO_RGB Los píxeles están conectados para el flujo de bits RGB (píxeles FLORA v1, no v2) // Los píxeles NEO_RGBW están conectados para el flujo de bits RGBW (productos NeoPixel RGBW) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // IMPORTANTE: Para reducir el riesgo de desgaste de NeoPixel, agregue un capacitor de 1000 uF a través de los cables de alimentación de // píxeles, agregue una resistencia de 300 - 500 Ohm en la entrada de datos del primer píxel // y minimice la distancia entre Arduino y el primer píxel. Evite conectar // en un circuito vivo … si es necesario, conecte GND primero.

// Variables Rueda de colores

// Boceto simple de NeoPixel Ring (c) 2013 Shae Erisson // publicado bajo la licencia GPLv3 para que coincida con el resto de la biblioteca AdaFruit NeoPixel

#incluir

#ifdef _AVR_ #include #endif

// ¿Qué pin del Arduino está conectado a los NeoPixels?

// En un Trinket o Gemma sugerimos cambiar esto a 1 #define PIN 9

// ¿Cuántos NeoPixels están conectados al Arduino?

#define NUMPIXELS 16

// Cuando configuramos la biblioteca NeoPixel, le decimos cuántos píxeles y qué pin usar para enviar señales.

// Tenga en cuenta que para las tiras NeoPixel más antiguas, es posible que deba cambiar el tercer parámetro; consulte el ejemplo de strandtest // para obtener más información sobre los posibles valores. Adafruit_NeoPixel píxeles = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // retraso de 50 ms

// Variables colores aleatorios

#include #ifdef _AVR_ #include #endif

#define PIN 9

#define NUM_LEDS 16

#define BRILLO 200

// Adafruit_NeoPixel strip = Adafruit_NeoPixel (NUM_LEDS, PIN, NEO_GRBW + NEO_KHZ800);

byte neopix_gamma = {

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36, 37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68, 69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89, 90, 92, 93, 95, 96, 98, 99, 101, 102, 104, 105, 107, 109, 110, 112, 114, 115, 117, 119, 120, 122, 124, 126, 127, 129, 131, 133, 135, 137, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 167, 169, 171, 173, 175, 177, 180, 182, 184, 186, 189, 191, 193, 196, 198, 200, 203, 205, 208, 210, 213, 215, 218, 220, 223, 225, 228, 231, 233, 236, 239, 241, 244, 247, 249, 252, 255 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/ CONFIGURACIÓN DEL METODO

void setup () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // dirección del acelerómetro // configuración de rango Wire.write (0x22); // registrar la dirección Wire.write (rango); // se puede establecer en "0x00" "0x01" "0x02" "0x03", consulte Datashhet en wiki // filtro de paso bajo Wire.write (0x20); // registrar la dirección Wire.write (0x05); // se puede establecer en "0x05" "0x04" …… "0x01" "0x00", consulte Datashhet en la wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Esto es para Trinket 5V 16MHz, puede eliminar estas tres líneas si no está usando un Trinket #if definido (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Fin del código especial de la baratija strip.begin (); strip.show (); // Inicializar todos los píxeles a 'desactivados'

// Código Rueda de colores

// Esto es para Trinket 5V 16MHz, puede eliminar estas tres líneas si no está usando un Trinket #if definido (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Fin del código especial de la baratija

pixels.begin (); // Esto inicializa la biblioteca NeoPixel.

// Codigo Interrupcion

contador = 1;

// Codigo Colores varios

// Esto es para Trinket 5V 16MHz, puede eliminar estas tres líneas si no está usando un Trinket #if definido (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Fin del código especial de la baratija strip.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Inicializar todos los píxeles en 'desactivado'}

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/ Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (contador == 1) {for (int i = 0; i 0.0) {if (nx 0.0) ángulo + = 180; si no ángulo + = 360; } // fin else if (ángulo == 360.0) ángulo = 0.0; led = circularizar (ángulo / (360 / NUMBER_OF_LEDS_ON_RING)); // hacer que el movimiento del led sea suave if (previousLed == led) {// nada que hacer} else if (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); else led = circularizar (previousLed - 1); ledQueue.push (led); makeLightShow (); previousLed = led; retraso (25); } contador = 2; } // End if counter == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Algunos procedimientos de ejemplo que muestran cómo mostrar los píxeles: colorWipe1 (strip. Color (255, 0, 0), 50); // Red colorWipe1 (strip. Color (0, 255, 0), 50); // Verde colorWipe1 (strip. Color (0, 0, 255), 50); // Azul colorWipe1 (strip. Color (0, 0, 0, 255), 50); // White RGBW // Envía una persecución de píxeles de teatro en… theaterChase (strip. Color (127, 127, 127), 50); // White theatreChase (strip. Color (127, 0, 0), 50); // Red theatreChase (strip. Color (0, 0, 127), 50); // Azul

arco iris (5);

rainbowCycle (5); theaterChaseRainbow (5); } contador = 3; } // Fin si contador == 2 // Caso 3: Luces Aleatorias else if (contador == 3) {for (int k = 0; k <50; k ++) {// Para un conjunto de NeoPixels, el primer NeoPixel es 0, el segundo es 1, hasta el número de píxeles menos uno. int a = aleatorio (255); int b = aleatorio (255); int c = aleatorio (255); para (int i = 0; i

// píxeles El color toma valores RGB, desde 0, 0, 0 hasta 255, 255, 255

píxeles.setPixelColor (i, píxeles. Color (a, b, c)); // Color verde moderadamente brillante.

pixels.show (); // Esto envía el color de píxel actualizado al hardware.

delay (delayval); // Retraso por un período de tiempo (en milisegundos).

} a = aleatorio (255); b = aleatorio (255); c = aleatorio (255); para (int i = NUMPIXELS; i> 0; i -) {

// píxeles El color toma valores RGB, desde 0, 0, 0 hasta 255, 255, 255

píxeles.setPixelColor (i, píxeles. Color (a, b, c)); // Color verde moderadamente brillante.

pixels.show (); // Esto envía el color de píxel actualizado al hardware.

delay (delayval); // Retraso por un período de tiempo (en milisegundos).

}} contador = 4; } else if (contador == 4) {for (int g = 0; g <= 6; g ++) {// Algunos procedimientos de ejemplo que muestran cómo mostrar los píxeles: colorWipe (strip. Color (255, 0, 0), 50); // Red colorWipe (strip. Color (0, 255, 0), 50); // Verde colorWipe (strip. Color (0, 0, 255), 50); // Blue colorWipe (strip. Color (0, 0, 0, 255), 50); // Blanco whiteOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // retraso (2000); rainbowFade2White (3, 3, 1);

}

contador = 1; }} ////////////////////////////////////////////////// ///////////////////////////////////// /////////////// //////////////////////////////////////////////////// ///////////////////

/ Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // dirección del acelerómetro // restablecer el acelerómetro Wire.write (0x04); // X datos Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // solicita 6 bytes del dispositivo esclavo # 2 mientras (Wire.available ()) // el esclavo puede enviar menos de lo solicitado {Version [0] = Wire.read (); // recibe un byte como carácter} x_data = (int8_t) Versión [0] >> 2; Wire.beginTransmission (0x0A); // dirección del acelerómetro // resetear el acelerómetro Wire.write (0x06); // Y datos Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // solicita 6 bytes del dispositivo esclavo # 2 mientras (Wire.available ()) // el esclavo puede enviar menos de lo solicitado {Version [1] = Wire.read (); // recibe un byte como carácter} y_data = (int8_t) Versión [1] >> 2; Wire.beginTransmission (0x0A); // dirección del acelerómetro // resetear el acelerómetro Wire.write (0x08); // Cable de datos Z.endTransmission (); Wire.requestFrom (0x0A, 1); // solicita 6 bytes del dispositivo esclavo # 2 mientras (Wire.available ()) // el esclavo puede enviar menos de lo solicitado {Version [2] = Wire.read (); // recibe un byte como characte} z_data = (int8_t) Version [2] >> 2; x = (flotante) x_data / divi; y = (flotante) y_data / divi; z = (flotante) z_data / divi; Serial.print ("X ="); Serial.print (x); // imprime el carácter Serial.print (""); Serial.print ("Y ="); Serial.print (y); // imprime el carácter Serial.print (""); Serial.print ("Z ="); // imprime el carácter Serial.println (z); }

int circularize (int pos) {

si (pos> = NUMBER_OF_LEDS_ON_RING) return (pos - NUMBER_OF_LEDS_ON_RING); si no (pos <0) return (pos + NUMBER_OF_LEDS_ON_RING); else return (pos); }

int distancia;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distancia = nextPos - prevPos; if (distancia <0) distancia + = NUMBER_OF_LEDS_ON_RING; retorno (distancia); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brilloStep = 255 / NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

para (int j = 0; j <NUMBER_OF_LEDS_ON_RING; j ++) neoring.setPixelColor (j, 0, 0, 0); currentQueueSize = ledQueue.count (); para (int k = 0; k <currentQueueSize; k ++) {ledPosition = ledQueue.pop (); neoring.setPixelColor (ledPosition, 0, (brilloStep * k), 0); if ((k == 0 && currentQueueSize 0) ledQueue.push (ledPosition);} neoring.show ();}

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/ Metodos del juego de luces del arcoiris

// Rellena los puntos uno tras otro con un color void colorWipe (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i

arco iris vacío (uint8_t espera) {

uint16_t i, j;

para (j = 0; j <256; j ++) {para (i = 0; i

// Ligeramente diferente, esto hace que el arco iris se distribuya por igual en todo

void rainbowCycle (uint8_t esperar) {uint16_t i, j;

for (j = 0; j <256 * 5; j ++) {// 5 ciclos de todos los colores en la rueda para (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) y 255)); } strip.show (); retrasar (esperar); }}

// Luces de arrastre estilo teatro.

void theaterChase (uint32_t c, uint8_t espera) {for (int j = 0; j <10; j ++) {// haz 10 ciclos de persecución for (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, c); // activa cada tercer píxel} strip.show ();

retrasar (esperar);

para (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // apagar cada tercer píxel}}}}

// Luces que se arrastran al estilo de un teatro con efecto arcoíris

void theaterChaseRainbow (uint8_t espera) {for (int j = 0; j <256; j ++) {// cicla los 256 colores en la rueda for (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, Wheel ((i + j)% 255)); // activa cada tercer píxel} strip.show ();

retrasar (esperar);

para (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // apagar cada tercer píxel}}}}

// Ingrese un valor de 0 a 255 para obtener un valor de color.

// Los colores son una transición r - g - b - de regreso a r. uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } si (WheelPos <170) {WheelPos - = 85; return strip. Color (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos - = 170; return strip. Color (WheelPos * 3, 255 - WheelPos * 3, 0); }

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/ Metodos Rueda de colores

// int elegirColor = random (0x000000, 0xffffff); // Se elige aleatoriamente entre toda la gama de colores comprendida entre 0x000000 y 0xFFFFFF

// CylonEyeColor = HtmlColor (elegirColor); // int elegirColor = random (1, 7); // Podemos elegir aleatoriamente entre los 7 colores que hay debajo0xf0ffff // if (elegirColor == 1) CylonEyeColor = HtmlColor (0xff0000); // Rojo // if (elegirColor == 2) CylonEyeColor = HtmlColor (0x00ff00); // Verde // if (elegirColor == 3) CylonEyeColor = HtmlColor (0x0000ff); // Azul // if (elegirColor == 4) CylonEyeColor = HtmlColor (0xffff00); // Amarillo // if (elegirColor == 5) CylonEyeColor = HtmlColor (0x200020); // Morado // if (elegirColor == 6) CylonEyeColor = HtmlColor (0x00ffff); // Azul Claro // if (elegirColor == 7) CylonEyeColor = HtmlColor (0x100010); // Rosa // CylonEyeColor = HtmlColor (0x000000);

///////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////

/ Metodos luces varias

// Rellena los puntos uno tras otro con un color

void colorWipe1 (uint32_t c, uint8_t espera) {for (uint16_t i = 0; i

void pulseWhite (uint8_t espera) {

para (int j = 0; j <256; j ++) {para (uint16_t i = 0; i

para (int j = 255; j> = 0; j -) {

para (uint16_t i = 0; i

void rainbowFade2White (uint8_t espera, int rainbowLoops, int whiteLoops) {

float fadeMax = 100.0; int fadeVal = 0; uint32_t wheelVal; int redVal, greenVal, blueVal;

for (int k = 0; k <rainbowLoops; k ++) {for (int j = 0; j <256; j ++) {// 5 ciclos de todos los colores en la rueda

para (int i = 0; i <strip.numPixels (); i ++) {

wheelVal = Wheel (((i * 256 / strip.numPixels ()) + j) & 255);

redVal = red (wheelVal) * float (fadeVal / fadeMax);

greenVal = green (wheelVal) * float (fadeVal / fadeMax); blueVal = blue (wheelVal) * float (fadeVal / fadeMax);

strip.setPixelColor (i, strip. Color (redVal, greenVal, blueVal));

}

// ¡Primer bucle, fade in!

if (k == 0 && fadeVal <fadeMax-1) {fadeVal ++; }

// ¡Último bucle, se desvanece!

else if (k == rainbowLoops - 1 && j> 255 - fadeMax) {fadeVal--; }

strip.show ();

retrasar (esperar); }}

retraso (500);

para (int k = 0; k <whiteLoops; k ++) {

para (int j = 0; j <256; j ++) {

para (uint16_t i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, strip. Color (0, 0, 0, neopix_gamma [j])); } strip.show (); }

retraso (2000);

para (int j = 255; j> = 0; j -) {

para (uint16_t i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, strip. Color (0, 0, 0, neopix_gamma [j])); } strip.show (); }}

retraso (500);

}

void whiteOverRainbow (uint8_t espera, uint8_t whiteSpeed, uint8_t whiteLength) {

if (whiteLength> = strip.numPixels ()) whiteLength = strip.numPixels () - 1;

int head = whiteLength - 1;

int tail = 0;

bucles int = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

while (verdadero) {

for (int j = 0; j <256; j ++) {for (uint16_t i = 0; i = tail && i head && i> = tail) || (cola> cabeza && i <= cabeza)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } else {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

cabeza ++; cola ++; if (cabeza == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == bucles) return;

head% = strip.numPixels (); tail% = strip.numPixels (); strip.show (); retrasar (esperar); }}} void fullWhite () {para (uint16_t i = 0; i

// Ligeramente diferente, esto hace que el arco iris se distribuya por igual en todo

void rainbowCycle1 (uint8_t esperar) {uint16_t i, j;

for (j = 0; j <256 * 5; j ++) {// 5 ciclos de todos los colores en la rueda para (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) y 255)); } strip.show (); retrasar (esperar); }}

void rainbow1 (uint8_t espera) {

uint16_t i, j;

para (j = 0; j <256; j ++) {para (i = 0; i

// Ingrese un valor de 0 a 255 para obtener un valor de color.

// Los colores son una transición r - g - b - de regreso a r. uint32_t Wheel1 (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } si (WheelPos <170) {WheelPos - = 85; return strip. Color (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos - = 170; return strip. Color (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t rojo (uint32_t c) {

retorno (c >> 16); } uint8_t verde (uint32_t c) {return (c >> 8); } uint8_t blue (uint32_t c) {return (c); }

Paso 8: Diseño 3D

Primero, debe dimensionar sus componentes de hardware para estar seguro de cuál es el correcto. Si son iguales a los nuestros, puedes usar los mismos archivos que te prestamos.

Ambos soportes han sido diseñados con una impresora 3D, que también se incluyen como:

ukelele_support_arduino_v0.stl: https://www.tinkercad.com/things/1aAGZ1xFptA-ukel… ukelele_support_WS2812_v0.stl:

Finalmente, la luz será como las dos últimas imágenes.

Paso 9: Montaje del cuello

Primero colocaremos la silla en el cuello. Los agujeros que necesitan los tornillos para sujetarlo no están ahí, así que tendremos que hacerlos, marcando por donde deben ir y con cuidado, con una barrena, haciendo el agujero.

Lo mismo ocurre con los orificios donde se encuentran los tornillos que sujetan el propio cuello al cuerpo del instrumento. No es necesario hacerlos, ya que no hay tornillos para esta sujeción, pero si queremos hacerlo no habría problema.

IMPORTANTE: dejar 5mm de espacio entre el inicio del mástil y el inicio del diapasón, porque en ese agujero se colocará la tuerca.

Pegaremos la tuerca con pegamento, en la dirección que indica la figura.

Finalmente, introduciremos los 4 pines en los orificios que están al inicio del mástil, sujetando cada pasador con 2 tornillos cortos como se muestra en la imagen.

Paso 10: Montaje del Birdge

El puente se fija pegando y con los dos tornillos largos en posición central sobre el cuerpo. Es recomendable marcar con lápiz la posición correcta en el cuerpo. Tomaremos las distancias que están marcadas en la imagen.

Aplicaremos pegamento en la unión de los dos componentes. Fijamos las dos partes con cuidado con la ayuda de un tornillo de apriete hasta que la junta se haya secado. Los dos agujeros para los tornillos los haremos con una broca de 1,5 mm para madera. Fije el puente con los dos tornillos largos en el cuerpo. Y finalmente, colocamos las tapas protectoras en las cabezas de los tornillos.

Paso 11: Ensamblaje de cuerpo y cuello

Para montar las dos partes, tenemos unos agujeros en la cabeza del cuerpo, donde encajará el cuello con dos salientes que tiene. Podemos pegarlos con cola o con la pistola termofusible. Para tener una mayor fijación, puedes hacer los agujeros que están en el extremo del diapasón para unirlo al cuerpo.

Paso 12: Pon las cuerdas del ukelele

Finalmente tenemos que colocar las cuerdas para que nuestro instrumento esté terminado.

Previamente insertaremos los anillos de fijación de los pasadores en los salientes de estos que atraviesan el mástil. Para colocar las cuerdas, tomamos las 4 cuerdas que venían con el kit. Primero hay que distinguir cada cadena porque no todas son iguales. Tienes que atar un extremo de cada hilo (los dos gruesos con un nudo normal y los dos delgados con uno doble) e insertar los hilos en las ranuras del puente.

Luego colocaremos las cuerdas de tal manera que:

• Primera posición: cuerda G (segunda cuerda más gruesa).

• Segunda posición: cuerda C (cuerda más gruesa).

• Tercera posición: cuerda Mi (segunda cuerda más fina).

• Cuarta posición: una cuerda (cuerda más fina).

Enrosque las cuerdas en los orificios del enchufe provisto. Intente fijar cada cuerda dando dos o tres vueltas al pasador. Tense las cuerdas sin aplicar demasiada fuerza y compruebe la distancia entre las cuerdas y el sillín.

Si tienes alguna duda sobre cómo hacer eso, puedes ver ese tutorial que te explica cómo poner correctamente las cuerdas.

Paso 13: Prueba

Por último, tenemos que comprobar si el ukelele se ha montado correctamente de tal forma que la distancia ideal en el primer traste sea de 0,1 mm y en el duodécimo sea de aproximadamente 1,2 mm.

Es necesario que afines las cuerdas del ukelele. Te recomiendo esta aplicación: GuitarTuna

Paso 14: disfrútalo

Ahora, solo tienes que disfrutar de tu ukelele.

Si quieres conocer más información sobre nosotros, puedes encontrarnos en:

Gorjeo: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc