Ukulele elettronico intelligente fai-da-te con Arduino: 14 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Spiegheremo passo dopo passo come puoi progettare il tuo ukulele e aggiungere alcuni effetti che lo renderanno unico, come disegnare qualcosa che vogliamo sulla superficie dell'ukulele o aggiungere alcuni effetti di luce.

Per fare ciò, è necessario acquistare un kit di ukulele.

Spiegheremo come assemblare lo strumento e risolveremo i diversi problemi che potrebbero presentarsi.

Passaggio 1: materiali

Materiali della struttura:

Kit montaggio ukelele fai da te (potrebbe essere un altro kit diverso) formato da:

1- Corpo.

2-collo.

3-sella

Supporto a 4 corde

5-Ponte

Dado a 6 corde.

7-Anello di fissaggio per testa macchina (x4).

8-Testa macchina (x4).

9-Viti di montaggio per teste di macchine (x8).

10-Viti di montaggio per ponte macchina (x2).

11-Tappi di copertura per viti di montaggio a ponte (x2).

12 corde (x4).

Materiali elettronici:

• NANO Arduino.
• Ruota di LED WS2812.
• Accelerometro BMA220 (opzionale).
• Connettore batteria.
• Batteria da 9V.
• Interruttore.

Altri

• Vernice per legno.
• Velcro.
• Stagno di saldatura.
• Plastica protettiva per la verniciatura.
• Silicone a caldo.

Utensili:

• Incisione laser.
• Carta vetrata
• Cacciavite a stella.
• Pennello.
• Pistola a caldo.
• Saldatore a stagno.

Passaggio 2: personalizza l'ukulele

Per personalizzare il nostro ukulele potremmo fare un'incisione di un disegno con un laser cutter sul corpo. Nel caso non avessimo quello strumento, potremmo dipingerlo.

L'immagine che abbiamo scelto è la prima che appare.

Prima di tutto, dobbiamo progettare il modello di disegno per realizzare l'incisione.

Per farlo, utilizzeremo un software chiamato 'Inkscape' che potremmo ottenere da questo link:

Per usarlo, dobbiamo regolare l'immagine che vogliamo usare come mostriamo nella seconda immagine. Potresti vedere che abbiamo ruotato l'immagine iniziale per regolare il ciclo della mano con il cerchio dello strumento. Come abbiamo detto prima, potresti mettere qualsiasi immagine.

Passaggio 3: vettorializzare un'immagine utilizzando Inkscape

Vedremo come creare un file vettoriale da una pixmap (jpg, png, qualunque sia il formato raster che Inkscape può aprire).

Inkscape Inkscape è un editor di grafica vettoriale open source e, come suggerisce il titolo, questo è lo strumento che utilizzerò per vettorializzare i loghi. Passaggi di vettorizzazione I passaggi sono comuni per qualsiasi vettorizzazione che potremmo voler fare.

1. Apri l'immagine in Inkscape
2. Apri lo strumento Trace Bitmap Tool Path->Trace Bitmap
3. Gioca con le opzioni Trace Bitmap
4. Esegui il tracciamento
5. Pulisci i risultati (se necessario)

Nota la parte "giocare". Non sono un esperto di tracciatura, quindi tratto questo strumento come una scatola nera con manopole e luci, ruotando e cambiando fino a ottenere il miglior risultato

Passaggio 4: incisione del logo

Per questo, è importante avere una silhouette della superficie su cui verrà prodotta l'incisione del disegno.

Per realizzare l'incisione, utilizzeremo il software 'T2Laser'. Potremmo ottenere questo software da:

Una volta aperto il software, dobbiamo caricare l'immagine che abbiamo creato nell'ultimo passaggio. Quindi, premere il pulsante "controllo laser", e compaiono i controlli del cnc. Le due immagini mostrano il processo e il risultato dell'incisione con il nostro laser cutter.

Passaggio 5: levigatura e verniciatura

Per lasciare il nostro ukulele brillante e con uno strato senza asperità possiamo carteggiare dolcemente con cura le due parti che compongono il nostro strumento, perché possiamo danneggiare il disegno che è stato fatto (se avete scelto di dipingere l'ukulele, dovreste sabbia prima). Vernicieremo poi le nostre due parti in modo che ottengano un colore più scuro e il legno presenti più resistenza. Possiamo usare una normale vernice per legno, non ha bisogno di essere speciale.

Una volta ottenuta la vernice, la mescoliamo con un po' di solvente in modo che si sciolga un po'. Successivamente, applichiamo la miscela con un pennello sul collo e sul corpo dello strumento e lasciamo asciugare.

Se vediamo che il prodotto necessita di una seconda mano, possiamo carteggiare un po' le due parti e riapplicare uno strato di vernice diluita.

** PRECAUZIONI: La vernice è un prodotto chimico, quindi è necessario eseguire questo processo in un luogo ventilato, indossare una maschera per evitare l'inalazione di odori e occhiali protettivi.

I materiali di cui abbiamo bisogno per poter lavorare correttamente sono quelli che appaiono nelle foto. Principalmente lavoreremo con un pennello, un barattolo di vernice (nel nostro caso di colore rosso), un po' di solvente e una protezione visiva. E soprattutto lavorare in ambienti ben ventilati.

Passaggio 6: hardware

La nostra placca con l'Arduino, l'accelerometro e la ruota con i led andranno inseriti in una piccola staffa per evitare che tutti i componenti si muovano nello strumento.

Abbiamo anche aggiunto un portabatteria e un interruttore per renderlo più comodo e non consumiamo la batteria quando non utilizziamo lo strumento. Attaccheremo questo supporto con un pezzo di velcro (funzionerebbe anche con silicone e una pistola hot melt) alla faccia interna del corpo dell'ukulele. D'altra parte, la ruota LED è più piccola del foro, quindi cadrebbe. Un supporto è stato progettato in modo che regga bene e possa svolgere la sua funzione.

Passaggio 7: software

Per dare una decorazione speciale al nostro ukulele, potremmo aggiungere effetti di luce grazie ad una ruota di led. Utilizzeremo il WS2812, ma puoi utilizzarne un altro seguendo le istruzioni della scheda tecnica. Utilizzeremo anche un accelerometro (BMA220), che ci permetterà di fare un effetto della gravità.

Avremo infatti 4 giochi di luce, inseriti nella libreria del computer denominata 'Adafruit' di Arduino. A questo dobbiamo fare una corretta connessione tra i tre componenti: Arduino NANO, WS2812 e BMA220, come appare nella prima immagine.

I fili rossi sono per l'alimentazione, i neri GND e il resto sono collegamenti necessari per il corretto funzionamento. Il codice che abbiamo utilizzato per il kit luci è allegato in un file chiamato "play_of_light_v0.ino". Assicurati di aver incluso le librerie necessarie per il corretto funzionamento del programma. La batteria che aggiungiamo esternamente al circuito deve avere una tensione minima di 9V e dobbiamo assicurarci che sia in grado di fornire la corrente minima necessaria per alimentare l'intero circuito.

//Variabili contador e interrupciónint counter; //Variables Ejemplo gravedad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

versione in byte[3];

int8_t x_data; int8_t y_data; int8_t z_data; intervallo di byte=0x00; float divi=16; float x, y, z; galleggiante pi = 3,14159265359; float nx, ny, angolo; led int, led precedente; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel(NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

//Variabili Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parametro 1 = numero di pixel nella striscia // Parametro 2 = numero pin Arduino (la maggior parte sono validi) // Parametro 3 = flag di tipo pixel, sommare se necessario: // NEO_KHZ800 800 KHz bitstream (la maggior parte dei prodotti NeoPixel con LED WS2812) // NEO_KHZ400 400 KHz (pixel FLORA classici 'v1' (non v2), driver WS2811) // I pixel NEO_GRB sono cablati per GRB bitstream (la maggior parte dei prodotti NeoPixel) / / I pixel NEO_RGB sono cablati per bitstream RGB (pixel FLORA v1, non v2) // I pixel NEO_RGBW sono cablati per bitstream RGBW (prodotti NeoPixel RGBW) Striscia Adafruit_NeoPixel = Adafruit_NeoPixel(16, PIN, NEO_GRB + NEO_KHZ800); // IMPORTANTE: per ridurre il rischio di esaurimento del NeoPixel, aggiungere un condensatore da 1000 uF attraverso // i cavi di alimentazione dei pixel, aggiungere un resistore da 300 - 500 Ohm sull'ingresso dati del primo pixel // e ridurre al minimo la distanza tra Arduino e il primo pixel. Evita di connetterti // su un circuito sotto tensione…se necessario, collega prima GND.

//Variabili Rueda de colores

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson // rilasciato sotto licenza GPLv3 per adattarsi al resto della libreria AdaFruit NeoPixel

#includere

#ifdef _AVR_ #include #endif

// Quale pin dell'Arduino è connesso ai NeoPixel?

// Su un Trinket o su Gemma suggeriamo di cambiarlo in 1 #define PIN 9

// Quanti NeoPixel sono collegati ad Arduino?

#define NUMPIXELS 16

// Quando impostiamo la libreria NeoPixel, le diciamo quanti pixel e quale pin usare per inviare i segnali.

// Nota che per le vecchie strisce NeoPixel potresti aver bisogno di cambiare il terzo parametro--vedi l'esempio strandtest // per maggiori informazioni sui possibili valori. Adafruit_NeoPixel pixel = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); valore int ritardo = 50; // ritardo per 50 ms

//Variabili colores aleatorios

#include #ifdef _AVR_ #include #endif

#define PIN 9

#define NUM_LEDS 16

#define LUMINOSITÀ 200

//Strip Adafruit_NeoPixel = 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 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/CONFIGURAZIONE METODO

void setup() { //Código: Dirección de la gravedad neoring.begin(); neoring.setBrightness(200); Serial.begin(9600); Wire.begin(); Wire.beginTransmission(0x0A); // indirizzo dell'accelerometro // impostazioni range Wire.write(0x22); //indirizzo di registrazione Wire.write(range); //può essere impostato su"0x00""0x01""0x02""0x03", fare riferimento a Datashhet su wiki //filtro passa basso Wire.write(0x20); //indirizzo di registrazione Wire.write(0x05); //può essere impostato su "0x05""0x04"……"0x01""0x00", fare riferimento a Datashhet su wiki Wire.endTransmission();

//Codice; Luces Arcoiris

// Questo è per Trinket 5V 16MHz, puoi rimuovere queste tre righe se non stai usando un Trinket #if definito (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Codice speciale di fine trinket strip.begin(); strip.show(); // Inizializza tutti i pixel su 'off'

//Código Rueda de colores

// Questo è per Trinket 5V 16MHz, puoi rimuovere queste tre righe se non stai usando un Trinket #if definito (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Codice speciale di fine trinket

pixel.begin(); // Questo inizializza la libreria NeoPixel.

//Codigo Interrupcion

contatore = 1;

//Codigo Colores varios

// Questo è per Trinket 5V 16MHz, puoi rimuovere queste tre righe se non stai usando un Trinket #if definito (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Codice speciale di fine trinket strip.setBrightness(BRIGHTNESS); strip.begin(); strip.show(); // Inizializza tutti i pixel su 'off' }

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

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

/Bucle infinito

void loop() { //Caso 1: Juego de luces de la gravedad; if(contatore == 1){ for(int i=0;i 0.0){ if(nx 0.0) angolo+=180; altrimenti angolo += 360; }//end else if(angolo == 360.0) angolo = 0.0; led = circolarizza (angolo / (360 / NUMBER_OF_LEDS_ON_RING)); // rende fluido il movimento del led if(previousLed == led){ // niente da fare } else if (counterClockwiseDistanceBetweenLeds(previousLed, led) <= 8) led = circolarizza(previousLed + 1); else led = circolarizza(previousLed - 1); ledQueue.push(led); makeLightShow(); precedenteLed = led; ritardo(25); } contatore = 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++){ // Alcuni esempi di procedure che mostrano come visualizzare i pixel: colorWipe1(strip. Color(255, 0, 0), 50); // Red colorWipe1(strip. Color(0, 255, 0), 50); // Green colorWipe1(strip. Color(0, 0, 255), 50); // Blue colorWipe1(strip. Color(0, 0, 0, 255), 50); // RGBW bianco // Invia una sequenza di pixel cinematografici in… theaterChase(strip. Color(127, 127, 127), 50); // White theaterChase(strip. Color(127, 0, 0), 50); // Red theaterChase(strip. Color(0, 0, 127), 50); // Blu

arcobaleno(5);

Cicloarcobaleno(5); theaterChaseRainbow(5); } contatore = 3; }//End if counter==2 //Caso 3: Luces Aleatorias else if(counter == 3){ for(int k=0;k<50;k++){ // Per un insieme di NeoPixel il primo NeoPixel è 0, il secondo è 1, fino al conteggio dei pixel meno uno. int a=casuale(255); int b=casuale(255); int c=casuale(255); for(int i=0;i

// pixels. Color accetta valori RGB, da 0, 0, 0 fino a 255, 255, 255

pixels.setPixelColor(i, pixels. Color(a, b, c)); // Colore verde moderatamente brillante.

pixel.mostra(); // Questo invia il colore del pixel aggiornato all'hardware.

ritardo(ritardo); // Ritardo per un periodo di tempo (in millisecondi).

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

// pixels. Color accetta valori RGB, da 0, 0, 0 fino a 255, 255, 255

pixels.setPixelColor(i, pixels. Color(a, b, c)); // Colore verde moderatamente brillante.

pixel.mostra(); // Questo invia il colore del pixel aggiornato all'hardware.

ritardo(ritardo); // Ritardo per un periodo di tempo (in millisecondi).

} } contatore = 4; } else if(counter == 4){ for(int g=0;g<=6;g++){ // Alcune procedure di esempio che mostrano come visualizzare i pixel: colorWipe(strip. Color(255, 0, 0), 50); // Red colorWipe(strip. Color(0, 255, 0), 50); // Green colorWipe(strip. Color(0, 0, 255), 50); // Blue colorWipe(strip. Color(0, 0, 0, 255), 50); // Bianco whiteOverRainbow(20, 75, 5); impulsoWhite(5); // fullWhite(); // ritardo(2000); rainbowFade2White(3, 3, 1);

}

contatore = 1; } } /////////////////////////////////////////////// ////////////////////////////////// /////////////// ///////////////////////////////////////////////// /////////////////

/Metodi dell'Ejemplo de la gravedad

void AccelerometerInit() { Wire.beginTransmission(0x0A); // indirizzo dell'accelerometro // resetta l'accelerometro Wire.write(0x04); // X dati Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // richiede 6 byte dal dispositivo slave #2 while(Wire.available()) // lo slave può inviare meno di quanto richiesto { Version[0] = Wire.read(); // riceve un byte come carattere } x_data=(int8_t)Version[0]>>2; Wire.beginTransmission(0x0A); // indirizzo dell'accelerometro // resetta l'accelerometro Wire.write(0x06); // Dati Y Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // richiede 6 byte dal dispositivo slave #2 while(Wire.available()) // lo slave può inviare meno di quanto richiesto { Version[1] = Wire.read(); // riceve un byte come carattere } y_data=(int8_t)Version[1]>>2; Wire.beginTransmission(0x0A); // indirizzo dell'accelerometro // resetta l'accelerometro Wire.write(0x08); // Z dati Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // richiede 6 byte dal dispositivo slave #2 while(Wire.available()) // lo slave può inviare meno di quanto richiesto { Version[2] = Wire.read(); // riceve un byte come carattere } z_data=(int8_t)Version[2]>>2; x=(float)x_data/divi; y=(float)y_data/divi; z=(float)z_data/divi; Serial.print("X="); Serial.print(x); // stampa il carattere Serial.print(" "); Serial.print("Y="); Serial.print(y); // stampa il carattere Serial.print(" "); Serial.print("Z="); // stampa il carattere Serial.println(z); }

int circolarizza(int pos){

if(pos >= NUMBER_OF_LEDS_ON_RING) return(pos - NUMBER_OF_LEDS_ON_RING); else if(pos < 0) return(pos + NUMBER_OF_LEDS_ON_RING); altro ritorno(pos); }

distanza int;

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

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow(){

for(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

// Riempi i punti uno dopo l'altro con un colore void colorWipe(uint32_t c, uint8_t wait) { for(uint16_t i=0; i

void rainbow(uint8_t aspetta) {

uint16_t io, j;

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

// Leggermente diverso, questo rende l'arcobaleno equamente distribuito ovunque

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

for(j=0; j<256*5; j++) { // 5 cicli di tutti i colori sulla ruota for(i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); } strip.show(); ritardo (attesa); } }

//Luci striscianti in stile teatro.

void theaterChase(uint32_t c, uint8_t wait) { for (int j=0; j<10; j++) { //esegui 10 cicli di inseguimento per (int q=0; q < 3; q++) { for (uint16_t i= 0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, c); //attiva ogni terzo pixel } strip.show();

ritardo (attesa);

for (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); //spegne ogni terzo pixel } } } }

//Luci striscianti in stile teatrale con effetto arcobaleno

void theaterChaseRainbow(uint8_t wait) { for (int j=0; j < 256; j++) { // scorre tutti i 256 colori nella ruota 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)); //attiva ogni terzo pixel } strip.show();

ritardo (attesa);

for (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); //spegne ogni terzo pixel } } } }

// Immettere un valore da 0 a 255 per ottenere un valore di colore.

// I colori sono una transizione 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(PosRuota < 170) { PosRuota -= 85; striscia di ritorno. Color(0, WheelPos * 3, 255 - WheelPos * 3); } PosizioneRuota -= 170; striscia di ritorno. Color(WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/Metodi Rueda de colores

// int elegirColor = random(0x000000, 0xffffff);//Se elige aleatoriamente entre toda la gamma de color comprendida entre 0x000000 e 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);

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

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

/Metodi luces varias

// Riempi i punti uno dopo l'altro con un colore

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

void pulseWhite(uint8_t wait) {

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

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

for(uint16_t i=0; i

void rainbowFade2White(uint8_t wait, 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 cicli di tutti i colori sulla ruota

for(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));

}

// Primo ciclo, dissolvenza in entrata!

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

//Ultimo loop, dissolvenza!

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

strip.show();

ritardo (attesa); } }

ritardo (500);

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

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

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

ritardo (2000);

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

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

ritardo (500);

}

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

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

int head = whiteLength - 1;

int coda = 0;

int loop = 3;

int loopNum = 0;

statico unsigned long lastTime = 0;

mentre(vero){

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

if(millis() - lastTime > whiteSpeed) {

testa++; coda++; if(head == strip.numPixels()){ loopNum++; } lastTime = millis(); }

if(loopNum == loop) return;

head%=strip.numPixels(); tail%=strip.numPixels(); strip.show(); ritardo (attesa); } } } void fullWhite() { for(uint16_t i=0; i

// Leggermente diverso, questo rende l'arcobaleno equamente distribuito ovunque

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

for(j=0; j<256 * 5; j++) { // 5 cicli di tutti i colori sulla ruota for(i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); } strip.show(); ritardo (attesa); } }

void rainbow1(uint8_t aspetta) {

uint16_t io, j;

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

// Immettere un valore da 0 a 255 per ottenere un valore di colore.

// I colori sono una transizione 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(PosRuota < 170) { PosRuota -= 85; striscia di ritorno. Color(0, WheelPos * 3, 255 - WheelPos * 3, 0); } PosizioneRuota -= 170; striscia di ritorno. Color(WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t red(uint32_t c) {

ritorno (c >> 16); } uint8_t green(uint32_t c) { return (c >> 8); } uint8_t blue(uint32_t c) { return (c); }

Passaggio 8: progettazione 3D

Innanzitutto, è necessario dimensionare i componenti hardware per essere sicuri del corretto. Se sono uguali ai nostri, puoi utilizzare gli stessi file che ti prestiamo.

Entrambi i supporti sono stati progettati con una stampante 3D, che sono inclusi anche come:

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

Infine, la luce sarà come le ultime due foto.

Passaggio 9: montaggio del collo

Per prima cosa posizioneremo la sella sul collo. I fori che servono alle viti per tenerlo non ci sono, quindi dovremo farli, segnando dove dovrebbero andare e con attenzione, con una trivella, facendo il foro.

Lo stesso vale per i fori dove si trovano le viti che fissano il manico stesso al corpo dello strumento. Non è necessario eseguirli, poiché non ci sono viti per questo fissaggio, ma se vogliamo farlo, non ci sarebbero problemi.

IMPORTANTE: lasciare 5mm di spazio tra l'inizio dell'albero e l'inizio del diapason, perché in quel foro verrà posizionato il dado.

Incolleremo il dado con la colla, nella direzione indicata dalla figura.

Infine, introdurremo i 4 perni nei fori che si trovano all'inizio dell'albero, trattenendo ciascun perno con 2 viti corte come mostrato nell'immagine.

Passaggio 10: montaggio del Birdge

Il ponte si fissa mediante incollaggio e con le due viti lunghe in posizione centrale sul corpo. Si consiglia di segnare con una matita la corretta posizione nel corpo. Prenderemo le distanze che sono segnate nell'immagine.

Applicheremo la colla all'unione dei due componenti. Fissiamo accuratamente le due parti con l'aiuto di una vite di serraggio fino a quando il giunto non si è asciugato. Faremo i due fori per le viti con una punta da 1,5 mm per legno. Fissare il ponte con le due viti lunghe nel corpo. E infine, mettiamo i cappucci protettivi sulle teste delle viti.

Passaggio 11: assemblaggio del corpo e del collo

Per assemblare le due parti, abbiamo dei fori nella testa del corpo, dove si adatterà il collo con due sporgenze che ha. Possiamo incollarli con la colla o con la pistola a caldo. Per avere una fissazione maggiore, puoi fare dei fori che si trovano all'estremità del diapason per unirlo al corpo.

Passaggio 12: metti le corde dell'ukulele

Infine dobbiamo posizionare le corde in modo che il nostro strumento sia finito.

In precedenza inseriremo gli anelli di fissaggio dei perni nelle sporgenze di questi che attraversano l'albero. Per posizionare le corde, abbiamo preso le 4 corde fornite con il kit. Per prima cosa devi distinguere ogni stringa perché non sono tutte uguali. Bisogna legare un capo di ogni corda (le due grosse con nodo normale, e le due sottili con nodo doppio) e inserire le corde nelle asole del ponticello.

Quindi posizioneremo le stringhe in modo tale che:

• Prima posizione: G string (seconda corda più spessa).

• Seconda posizione: stringa C (corda più spessa).

• Terza posizione: E string (seconda corda più sottile).

• Quarta posizione: una stringa (corda più sottile).

Infilare le corde nei fori della spina fornita. Prova a fissare ogni corda dando due o tre giri sul perno. Tendere le corde senza applicare troppa forza e controllare la distanza tra le corde e la sella.

Se hai qualche dubbio su come farlo, puoi guardare quel tutorial che ti spiega come mettere correttamente le corde.

Passaggio 13: test

Infine, dobbiamo vedere se l'ukulele è stato assemblato correttamente in modo tale che la distanza ideale sul primo tasto sia di 0,1 mm e sul dodicesimo sia di circa 1,2 mm.

È necessario che tu accordi le corde dell'ukulele. Ti consiglio questa app: GuitarTuna

Passaggio 14: divertiti

Ora devi solo goderti il tuo ukulele.

Se vuoi saperne di più su di noi, puoi trovarci in:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc