Ukelele electrònic intel·ligent de bricolatge amb Arduino: 14 passos (amb imatges)

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

Anem a explicar pas a pas com podeu dissenyar el vostre propi ukelele i afegir alguns efectes que el faran únic, com dibuixar alguna cosa que desitgem a la superfície de l’ukelele o afegir alguns efectes de llum.

Per fer-ho, és necessari comprar un kit d’ukelele.

Explicarem com muntar l’instrument i resoldre els diferents problemes que podrien aparèixer.

Pas 1: materials

Materials de l'estructura:

Kit de muntatge de ukelele de bricolatge (pot ser un altre kit diferent) format per:

1- Cos.

2-coll.

3-sella

Suport de 4 cordes

5-Pont

Femella de 6 cordes.

7-Anell de fixació per al capçal de la màquina (x4).

8-Capçals de màquina (x4).

9-Cargols de muntatge per a caps de màquina (x8).

10-Cargols de muntatge per a pont de màquina (x2).

11-Tapes per a cargols de muntatge de pont (x2).

12 cordes (x4).

Materials electrònics:

• NANO Arduino.
• Roda de leds WS2812.
• Acceleròmetre BMA220 (opcional).
• Connector de la bateria.
• Bateria de 9V.
• Interruptor.

Altres

• Vernís de fusta.
• Velcro.
• Estany de soldar.
• Plàstic protector per envernissar.
• Silicona termofusible.

Eines:

• Gravat làser.
• Paper de vidre
• Tornavís estrella.
• Pinzell.
• Pistola de fusió en calent.
• Soldador de llauna.

Pas 2: personalitzeu l'ukelele

Per personalitzar el nostre ukelele podríem fer un gravat d’un dibuix amb un tallador làser al cos. En el cas de no tenir aquesta eina, la podríem pintar.

La imatge que hem triat és la primera que apareix.

Primer de tot, hem de dissenyar la plantilla de dibuix per fer el gravat.

Per dur-ho a terme, utilitzarem un programari anomenat "Inkscape" que podríem obtenir en aquest enllaç:

Per utilitzar-lo, hem d’ajustar la imatge que volem utilitzar tal com mostrem a la segona imatge. Es podria veure que hem girat la imatge inicial per ajustar el cicle de la mà amb el cercle de l’instrument. Com hem dit abans, podríeu posar qualsevol imatge.

Pas 3: Vectoritzeu una imatge mitjançant Inkscape

Veurem com crear un fitxer vectorial a partir d’un pixmap (jpg, png, qualsevol format de ràster que pugui obrir Inkscape).

Inkscape Inkscape és un editor de gràfics vectorials de codi obert i, com indica el títol, aquesta és l’eina que faré servir per vectoritzar els logotips. Passos de vectorització Els passos són habituals per a qualsevol vectorització que vulguem fer.

1. Obriu la imatge a Inkscape
2. Obriu el camí de l'eina Traça mapa de bits-> Traça mapa de bits
3. Juga a les opcions Trace Bitmap
4. Executeu el traçat
5. Netejar els resultats (si cal)

Tingueu en compte la part "jugar". No sóc un expert en el traçat, de manera que considero aquesta eina com una caixa negra amb poms i llums, girant-se i canviant fins obtenir el millor resultat

Pas 4: Gravat del logotip

Per a això, és important tenir una silueta de la superfície sobre la qual es produirà el gravat del dibuix.

Per fer el gravat, utilitzarem el programari "T2Laser". Podríem obtenir aquest programari a:

Un cop hem obert el programari, hem de carregar la imatge que hem creat al darrer pas. A continuació, premeu el botó "control làser" i apareixeran els controls CNC. Les dues imatges mostren el procés i el resultat del gravat amb el nostre tallador làser.

Pas 5: polit i envernissat

Per deixar el nostre ukelele brillant i amb una capa sense rugositat, podem lijar amb cura les dues parts que formen el nostre instrument perquè podem danyar el dibuix que s’ha fet (si heu optat per pintar l’ukelele, hauríeu de lijeu-lo primer). Després envernissarem les nostres dues parts perquè obtinguin un color més fosc i la fusta presenti més resistència. Podem utilitzar un vernís de fusta normal, no cal que sigui especial.

Un cop tenim el vernís, el barregem amb una mica de dissolvent perquè es dissolgui una mica. A continuació, apliquem la barreja amb un pinzell al coll i al cos de l’instrument i ho deixem assecar.

Si veiem que el producte necessita una segona capa, podem lijar una mica les dues parts i tornar a aplicar una capa de vernís diluït.

** PRECAUCIONS: El vernís és un producte químic, per la qual cosa és necessari realitzar aquest procés en un lloc ventilat, portar una màscara per evitar inhalar olors i ulleres protectores.

Els materials que necessitem per poder funcionar correctament són els que apareixen a les fotos. Principalment treballarem amb un pinzell, una llauna de vernís (en el nostre cas de color vermell), una mica de dissolvent i protecció visual. I sobretot treballar en espais ben ventilats.

Pas 6: maquinari

La nostra placa amb l’Arduino, l’acceleròmetre i la roda amb leds s’introduiran en un petit suport per evitar que tots els components es moguin a l’instrument.

També hem afegit un suport per a la bateria i un interruptor per fer-lo més còmode i no esgotem la bateria quan no fem servir l’instrument. Fixarem aquest suport amb un tros de velcro (també funcionaria amb silicona i una pistola de fusió en calent) a la cara interna del cos de l’ukelele. En canvi, la roda LED és més petita que el forat, de manera que cauria. S'ha dissenyat un suport perquè es mantingui bé i pugui realitzar la seva funció.

Pas 7: programari

Per donar una decoració especial al nostre ukelele, podríem afegir efectes de llum gràcies a una roda de leds. Utilitzarem el WS2812, però podeu utilitzar qualsevol altre seguint les instruccions del full de dades. Utilitzarem també un acceleròmetre (BMA220), que ens permetrà fer un efecte de la gravetat.

De fet, tindrem 4 jocs de llum, inclosos a la biblioteca informàtica anomenada 'Adafruit' d'Arduino. Per a això, hem de fer una connexió correcta entre els tres components: Arduino NANO, WS2812 i BMA220, tal com apareix a la primera imatge.

Els cables vermells són per alimentar, els negres GND i la resta són connexions necessàries per al funcionament correcte. El codi que hem utilitzat per al kit de llum s’adjunta en un fitxer anomenat "play_of_light_v0.ino". Assegureu-vos que heu inclòs les biblioteques necessàries per al correcte funcionament del programa. La bateria que afegim externa al circuit ha de tenir una tensió mínima de 9V i hem d’assegurar-nos que sigui capaç de donar el corrent mínim necessari per alimentar tot el circuit.

// Variables contador i interrupcióint counter; // Variables Exemple gravedad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

Versió de bytes [3];

int8_t x_data; int8_t y_data; int8_t z_data; interval de bytes = 0x00; float divi = 16; flotació x, y, z; flotador pi = 3,14159265359; float nx, ny, angle; int led, previousLed; Llista de cues ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Variables Luces arcoiris

. // NEO_KHZ800 800 KHz de flux de bits (la majoria dels productes NeoPixel amb LEDs WS2812) // NEO_KHZ400 400 KHz (clàssics 'v1' (no v2) píxels FLORA, controladors WS2811) // Els píxels NEO_GRB estan connectats per a flux de bits GRB (la majoria dels productes NeoPixel) / / Els píxels NEO_RGB estan connectats per a flux de bits RGB (v1 píxels FLORA, no v2) // Els píxels NEO_RGBW estan connectats per a flux de bits RGBW (productes NeoPixel RGBW) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // IMPORTANT: per reduir el risc de cremada de NeoPixel, afegiu un condensador de 1000 uF a través de // cables de potència de píxels, afegiu una resistència de 300 a 500 Ohm a l'entrada de dades del primer píxel // i minimitzeu la distància entre Arduino i el primer píxel. Eviteu connectar // a un circuit en directe … si cal, connecteu primer GND.

// Variables Rueda de colors

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson // publicat sota la llicència GPLv3 per coincidir amb la resta de la biblioteca AdaFruit NeoPixel

#incloure

#ifdef _AVR_ #include #endif

// Quin pin de l'Arduino està connectat als NeoPixels?

// En un Trinket o Gemma, us recomanem que el canvieu per 1 #define PIN 9

// Quants NeoPixels estan connectats a l'Arduino?

#define NUMPIXELS 16

// Quan configurem la biblioteca NeoPixel, li indiquem quants píxels i quin pin utilitzar per enviar senyals.

// Tingueu en compte que per a les tires de NeoPixel més antigues és possible que hàgiu de canviar el tercer paràmetre; consulteu l'exemple de prova de cadena // per obtenir més informació sobre possibles valors. Adafruit_NeoPixel pixels = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // retard de 50 ms

// Variables colors aleatoris

#include #ifdef _AVR_ #include #endif

#defineix el PIN 9

#define NUM_LEDS 16

#define BRIGHTNESS 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Ó DE METODO

void setup () {// Codi: Direcció de la gravetat neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // adreça de l’acceleròmetre // configuració d’interval Wire.write (0x22); // adreça de registre Wire.write (interval); // es pot establir a "0x00" "0x01" "0x02" "0x03", consulteu Datashhet al wiki // filtre de pas baix Wire.write (0x20); // adreça de registre Wire.write (0x05); // es pot definir a "0x05" "0x04" …… "0x01" "0x00", consulteu Datashhet a la wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Això és per a Trinket 5V 16 MHz, podeu eliminar aquestes tres línies si no utilitzeu un # Trinket definit (_AVR_ATtiny85_) si (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Codi especial de fi de la baralla strip.begin (); strip.show (); // Inicialitza tots els píxels a "off"

// Codi Rueda de colors

// Això és per a Trinket 5V 16 MHz, podeu eliminar aquestes tres línies si no utilitzeu un # Trinket definit (_AVR_ATtiny85_) si (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Codi especial de fi de bibelot

pixels.begin (); // Això inicialitza la biblioteca NeoPixel.

// Codigo Interrupcion

comptador = 1;

// Codigo Colores varios

// Això és per a Trinket 5V 16 MHz, podeu eliminar aquestes tres línies si no utilitzeu un # Trinket definit (_AVR_ATtiny85_) si (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Codi especial de fi de baralla strip.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Inicialitza tots els píxels a "off"}

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

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

/ Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (comptador == 1) {for (int i = 0; i 0.0) {if (nx 0.0) angle + = 180; else angle + = 360; } // end else if (angle == 360,0) angle = 0,0; led = circularize (angle / (360 / NUMBER_OF_LEDS_ON_RING)); // fer que el moviment del led sigui suau if (led anterior == led) {// res a fer} else if (contraClockwiseDistanceBetweenLeds (anteriorLed, led) <= 8) led = circularize (anteriorLed + 1); else led = circularize (anteriorLed - 1); ledQueue.push (led); makeLightShow (); anteriorLed = led; retard (25); } comptador = 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 ++) {// Alguns exemples de procediments que mostren com es mostra als píxels: colorWipe1 (strip. Color (255, 0, 0), 50); // Color vermell Esborrar1 (strip. Color (0, 255, 0), 50); // Color verd Netegeu1 (strip. Color (0, 0, 255), 50); // Color blau Esborrar1 (strip. Color (0, 0, 0, 255), 50); // RGBW blanc // Envieu una persecució de píxels de teatre a … theaterChase (strip. Color (127, 127, 127), 50); // White theaterChase (strip. Color (127, 0, 0), 50); // Red theaterChase (strip. Color (0, 0, 127), 50); // Blau

arc de Sant Martí (5);

rainbowCycle (5); theatreChaseRainbow (5); } comptador = 3; } // Finalitza si el comptador == 2 // Caso 3: Luces Aleatorias else if (comptador == 3) {for (int k = 0; k <50; k ++) {// Per a un conjunt de NeoPixels, el primer NeoPixel és 0, el segon és 1, fins al recompte de píxels menys un. int a = aleatori (255); int b = aleatori (255); int c = aleatori (255); per a (int i = 0; i

// pixels. El color pren valors RGB, des de 0, 0, 0 fins a 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Color verd moderadament brillant.

pixels.show (); // Això envia el color de píxels actualitzat al maquinari.

delay (delayval); // Retard per un període de temps (en mil·lisegons).

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

// pixels. El color pren valors RGB, des de 0, 0, 0 fins a 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Color verd moderadament brillant.

pixels.show (); // Això envia el color de píxels actualitzat al maquinari.

delay (delayval); // Retard per un període de temps (en mil·lisegons).

}} comptador = 4; } else if (comptador == 4) {for (int g = 0; g <= 6; g ++) {// Alguns exemples de procediments que mostren com es mostra als píxels: colorWipe (strip. Color (255, 0, 0), 50); // Color vermell Netegeu (strip. Color (0, 255, 0), 50); // Color verd Netegeu (strip. Color (0, 0, 255), 50); // Color blau Netegeu (strip. Color (0, 0, 0, 255), 50); // White whiteOverRainbow (20, 75, 5); pols Blanc (5); // fullWhite (); // demora (2000); rainbowFade2White (3, 3, 1);

}

comptador = 1; }} //////////////////////////////////////////////////// ///////////////////////////////////// /////////////// ////////////////////////////////////////////////////// /////////////////

/ Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // adreça de l’acceleròmetre // restableix l’acceleròmetre Wire.write (0x04); // X dades Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // sol·liciteu 6 bytes des del dispositiu esclau # 2 mentre (Wire.available ()) // l’esclau pot enviar menys del que s’ha sol·licitat {Version [0] = Wire.read (); // rebre un byte com a caràcter} x_data = (int8_t) Versió [0] >> 2; Wire.beginTransmission (0x0A); // adreça de l’acceleròmetre // restableix l’acceleròmetre Wire.write (0x06); // Y dades Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // sol·liciteu 6 bytes des del dispositiu esclau # 2 mentre (Wire.available ()) // l'esclau pot enviar menys del que es demana {Versió [1] = Wire.read (); // rebre un byte com a caràcter} y_data = (int8_t) Versió [1] >> 2; Wire.beginTransmission (0x0A); // adreça de l’acceleròmetre // restableix l’acceleròmetre Wire.write (0x08); // Z dades Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // sol·liciteu 6 bytes des del dispositiu esclau # 2 mentre (Wire.available ()) // l'esclau pot enviar menys del que es demana {Versió [2] = Wire.read (); // rebre un byte com a caràcter} z_data = (int8_t) Versió [2] >> 2; x = (float) x_data / divi; y = (float) y_data / divi; z = (float) z_data / divi; Serial.print ("X ="); Serial.print (x); // imprimeix el caràcter Serial.print (""); Serial.print ("Y ="); Serial.print (y); // imprimeix el caràcter Serial.print (""); Serial.print ("Z ="); // imprimeix el caràcter Serial.println (z); }

int circularize (int pos) {

if (pos> = NUMBER_OF_LEDS_ON_RING) retorna (pos - NUMBER_OF_LEDS_ON_RING); else if (pos <0) return (pos + NUMBER_OF_LEDS_ON_RING); sinó tornar (pos); }

int distància;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; si (distància <0) distància + = NUMBER_OF_LEDS_ON_RING; retorn (distància); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 255 / NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

per a (int j = 0; j <NUMBER_OF_LEDS_ON_RING; j ++) neoring.setPixelColor (j, 0, 0, 0); currentQueueSize = ledQueue.count (); for (int k = 0; k <currentQueueSize; k ++) {ledPosition = ledQueue.pop (); neoring.setPixelColor (ledPosition, 0, (brightnessStep * k), 0); if ((k == 0 && CurrentQueueSize 0) ledQueue.push (ledPosition);} neoring.show ();}

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

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

/ Metodos del juego de luces del arcoiris

// Ompliu els punts un darrere l’altre amb un color buit colorWipe (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i

arc de Sant Martí buit (uint8_t espera) {

uint16_t i, j;

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

// Lleugerament diferent, això fa que l’arc de Sant Martí estigui distribuït per igual

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

for (j = 0; j <256 * 5; j ++) {// 5 cicles de tots els colors de la roda per a (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); retard (esperar); }}

// Llums de rastreig estil teatral.

void theatreChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// fer 10 cicles de persecució per (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 a} strip.show ();

retard (esperar);

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

// Llums de rastreig estil teatral amb efecte arc de Sant Martí

void theatreChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// cicle tots els 256 colors de la roda 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 a} strip.show ();

retard (esperar);

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

// Introduïu un valor de 0 a 255 per obtenir un valor de color.

// Els colors són una transició r - g - b - torna a r. uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } if (WheelPos <170) {WheelPos - = 85; tira de retorn. Color (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos - = 170; tira de retorn. Color (WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/ Metodos Rueda de colors

// 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); // Podem elegir aleatòriament entre els 7 colors que hi ha 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); // // 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

// Ompliu els punts un darrere l’altre d’un color

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

void pulseWhite (uint8_t espera) {

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

per a (int j = 255; j> = 0; j -) {

per a (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 cicles de tots els colors de la roda

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

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

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

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

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

}

// Primer bucle, fade in!

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

// Últim bucle, desapareix!

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

strip.show ();

retard (esperar); }}

retard (500);

per a (int k = 0; k <whiteLoops; k ++) {

per a (int j = 0; j <256; j ++) {

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

endarreriment (2000);

per a (int j = 255; j> = 0; j -) {

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

retard (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;

mentre que (cert) {

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

if (millis () - lastTime> whiteSpeed) {

cap ++; cua ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == bucles) retorna;

cap% = strip.numPixels (); cua% = strip.numPixels (); strip.show (); retard (esperar); }}} void fullWhite () {for (uint16_t i = 0; i

// Lleugerament diferent, això fa que l’arc de Sant Martí estigui distribuït per igual

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

for (j = 0; j <256 * 5; j ++) {// 5 cicles de tots els colors de la roda per a (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); retard (esperar); }}

void rainbow1 (uint8_t espera) {

uint16_t i, j;

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

// Introduïu un valor de 0 a 255 per obtenir un valor de color.

// Els colors són una transició r - g - b - torna a r. uint32_t Wheel1 (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) {WheelPos - = 85; tira de retorn. Color (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos - = 170; tira de retorn. Color (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t vermell (uint32_t c) {

retorn (c >> 16); } uint8_t green (uint32_t c) {return (c >> 8); } uint8_t blau (uint32_t c) {return (c); }

Pas 8: disseny 3D

Primer, heu de dimensionar els components del maquinari per assegurar-vos que són correctes. Si són els mateixos que els nostres, podeu utilitzar els mateixos fitxers que us prestem.

Els dos suports s’han dissenyat amb una impressora 3D, que també s’inclouen com:

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

Finalment, la llum serà com les dues darreres imatges.

Pas 9: muntatge del coll

Primer col·locarem la sella al coll. Els forats que els cargols necessiten per subjectar-lo no hi són, així que haurem de fer-los, marcant cap a on haurien d’anar i amb cura, amb una barrena, fent el forat.

El mateix s'aplica als forats on els cargols que subjecten el coll al cos de l'instrument. No cal fer-los, ja que no hi ha cargols per a aquesta subjecció, però si ho volem fer, no hi hauria cap problema.

IMPORTANT: deixeu 5 mm d’espai entre l’inici del pal i l’inici del diapasó, perquè en aquest forat es col·locarà la femella.

Enganxarem la nou amb cola, en la direcció que indica la figura.

Finalment, introduirem els 4 pins als forats que hi ha al començament del pal, subjectant cada pin amb 2 cargols curts com es mostra a la imatge.

Pas 10: muntatge del Birdge

El pont es fixa encolant i amb els dos cargols llargs en posició central sobre el cos. És aconsellable marcar amb un llapis la posició correcta al cos. Prendrem les distàncies que es marquen a la imatge.

Aplicarem cola a la unió dels dos components. Fixem les dues parts amb cura amb l'ajut d'un cargol de subjecció fins que la junta s'hagi assecat. Farem els dos forats dels cargols amb una broca de 1,5 mm per a fusta. Fixeu el pont amb els dos cargols llargs del cos. I, finalment, posem els taps de protecció als caps dels cargols.

Pas 11: Muntatge del cos i el coll

Per muntar les dues parts, tenim uns forats al cap del cos, on encaixarà el coll amb dues projeccions que té. Els podem enganxar amb cola o amb la pistola de fusió en calent. Per tenir una major fixació, podeu fer els forats que hi ha al final del diapasó per unir-lo al cos.

Pas 12: poseu les cordes de l'ukulele

Finalment, hem de col·locar les cordes perquè el nostre instrument estigui acabat.

Prèviament inserirem els anells de fixació dels passadors a les projeccions d’aquests que passen pel pal. Per col·locar les cordes, hem agafat les 4 cordes que venien amb el kit. Primer heu de distingir cada cadena perquè no són totes iguals. Cal lligar un extrem de cada corda (els dos gruixuts amb un nus normal i els dos prims amb un doble) i inserir les cordes a les ranures del pont.

A continuació, col·locarem les cordes de manera que:

• Primera posició: corda G (segona corda més gruixuda).

• Segona posició: corda C (corda més gruixuda).

• Tercera posició: corda E (segona corda més fina).

• Quarta posició: una corda (corda més fina).

Enfileu les cordes als orificis del tap subministrat. Intenteu arreglar cada corda donant dues o tres voltes al passador. Tenseu les cordes sense aplicar massa força i comproveu la distància entre les cordes i la sella.

Si teniu cap dubte sobre com fer això, podríeu buscar aquest tutorial que us expliqui com es posen correctament les cadenes.

Pas 13: proves

Finalment, hem de veure si l’ukelele s’ha muntat correctament de manera que la distància ideal al primer trast és de 0,1 mm i a la dotzena aproximadament 1,2 mm.

Cal afinar les cordes de l'ukelele. Et recomano aquesta aplicació: GuitarTuna

Pas 14: gaudiu-ne

Ara només heu de gaudir del vostre ukelele.

Si voleu obtenir més informació sobre nosaltres, ens podeu trobar a:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc