Ukulele electronice inteligente DIY cu Arduino: 14 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Vom explica pas cu pas cum puteți să vă creați propriul ukulele și să adăugați câteva efecte care îl vor face unic, cum ar fi desenarea a ceea ce dorim pe suprafața ukulele sau adăugarea unor efecte de lumină.

Pentru a face acest lucru, este necesar să cumpărați un kit de ukulele.

Vom explica cum să asamblați instrumentul și să rezolvăm diferitele probleme care ar putea apărea.

Pasul 1: Materiale

Materiale structurale:

Kit de montare ukelele DIY (ar putea fi un alt kit diferit) format din:

1- Corp.

2-gât.

3-Sa

Suport cu 4 frânghii

5-Pod

Piuliță cu 6 șiruri.

7-Inel de fixare pentru capul mașinii (x4).

8-Capete de mașină (x4).

9-Șuruburi de montare pentru capete de mașini (x8).

10-Șuruburi de montare pentru podul mașinii (x2).

11-Capacele șuruburilor de fixare a punții (x2).

12 șiruri (x4).

Materiale electronice:

• NANO Arduino.
• Roata Leds WS2812.
• Accelerometru BMA220 (opțional).
• Conector baterie.
• Baterie de 9V.
• Intrerupator.

Alții

• Lac de lemn.
• Velcro.
• Cutie de lipit.
• Plastic de protecție pentru lăcuire.
• Silicon topit la cald.

Instrumente:

• Gravare cu laser.
• Hârtie de șlefuit
• Șurubelniță stea.
• Pensulă.
• Pistolul topit la cald.
• Fier de lipit staniu.

Pasul 2: Personalizați Ukulele

Pentru a ne costuma ukulele am putea face o gravură a unui desen cu un tăietor laser pe corp. În cazul în care nu avem acel instrument, l-am putea picta.

Imaginea pe care am ales-o este prima care apare.

În primul rând, trebuie să proiectăm șablonul de desen pentru a face gravura.

Pentru a realiza acest lucru, vom folosi un software numit „Inkscape” pe care l-am putea obține de pe acest link:

Pentru ao utiliza, trebuie să ajustăm imaginea pe care dorim să o folosim așa cum arătăm în a doua imagine. Ați putea arăta că am rotit imaginea inițială pentru a putea regla ciclul mâinii cu cercul instrumentului. Așa cum am spus înainte, puteți pune orice imagine.

Pasul 3: Vectorizați o imagine folosind Inkscape

Vom vedea cum să creăm un fișier vector dintr-un pixmap (jpg, png, indiferent de formatul raster pe care îl poate deschide Inkscape).

Inkscape Inkscape este un editor de grafică vectorială open-source și, după cum sugerează titlul, acesta este instrumentul pe care îl voi folosi pentru a vectoriza logo-urile. Pași de vectorizare Pașii sunt obișnuiți pentru orice vectorizare pe care am putea dori să o facem.

1. Deschideți imaginea în Inkscape
2. Deschideți calea instrumentului Urmărire bitmap-> Urmărire bitmap
3. Jucați în jurul opțiunilor Trace Bitmap
4. Rulați urmărirea
5. Curățați rezultatele (dacă este necesar)

Rețineți partea „joc în jurul”. Nu sunt expert în urmărire, așa că tratez acest instrument ca pe o cutie neagră cu butoane și lumini, răsucind și schimbând până când obțin cel mai bun rezultat

Pasul 4: Gravarea logo-ului

Pentru aceasta, este important să aveți o siluetă a suprafeței pe care se va produce gravarea desenului.

Pentru a realiza gravarea, vom folosi software-ul „T2Laser”. Am putea obține acest software de la:

Odată ce am deschis software-ul, trebuie să încărcăm imaginea pe care am creat-o în ultimul pas. Apoi, apăsați butonul „control laser” și apare comenzile cnc. Cele două imagini arată procesul și rezultatul gravării cu tăietorul nostru laser.

Pasul 5: Șlefuire și Lacuire

Pentru a lăsa ukulele noastre luminoase și cu un strat fără rugozitate, putem șlefui cu grijă cele două părți care alcătuiesc instrumentul nostru, deoarece putem deteriora desenul care a fost făcut (dacă ați ales să pictați ukulele, ar trebui să șlefuiți-l mai întâi). Apoi ne vom lăsa cele două părți astfel încât să obțină o culoare mai închisă și lemnul să prezinte mai multă rezistență. Putem folosi un lac normal pentru lemn, nu trebuie să fie special.

Odată ce avem lacul, îl amestecăm cu puțin solvent, astfel încât să se dizolve puțin. Apoi, aplicăm amestecul cu o perie pe gât și corpul instrumentului și îl lăsăm să se usuce.

Dacă vedem că produsul are nevoie de un al doilea strat, putem șlefui puțin cele două părți și aplicăm din nou un strat de lac diluat.

** PRECAUȚII: Lacul este un produs chimic, de aceea este necesar să efectuați acest proces într-un loc ventilat, purtați o mască pentru a evita inhalarea mirosurilor și ochelari de protecție.

Materialele de care avem nevoie pentru a putea funcționa corect sunt cele care apar în fotografii. În principal, vom lucra cu o pensulă, o cutie de lac (în cazul nostru culoare roșie), puțin solvent și protecție vizuală. Și mai presus de toate lucrați în spații bine ventilate.

Pasul 6: Hardware

Plăcuța noastră cu Arduino, accelerometrul și roata cu leduri vor fi introduse într-un mic suport pentru a evita ca toate componentele să se miște în instrument.

Am adăugat, de asemenea, un suport pentru baterie și un comutator pentru a-l face mai confortabil și nu uzăm bateria atunci când nu folosim instrumentul. Vom atașa acest suport cu o bucată de Velcro (ar funcționa, de asemenea, cu silicon și un pistol de topire la cald) pe fața interioară a corpului ukulele. Pe de altă parte, roata LED este mai mică decât gaura, deci ar cădea. Un suport a fost conceput astfel încât să poată rezista bine și să își poată îndeplini funcția.

Pasul 7: Software

Pentru a oferi un decor special ukulele noastre, am putea adăuga efecte de lumină datorită unei roți de leduri. Vom folosi WS2812, dar puteți utiliza orice altul urmând instrucțiunile din foaia tehnică. Vom folosi și un accelerometru (BMA220), care ne permite să facem efectul gravitației.

De fapt, vom avea 4 piese de lumină, incluse în biblioteca de calculatoare numită „Adafruit” din Arduino. Pentru aceasta, trebuie să facem o conexiune corectă între cele trei componente: Arduino NANO, WS2812 și BMA220, așa cum apare în prima imagine.

Firele roșii sunt pentru alimentare, negrii GND și restul sunt conexiuni necesare pentru o funcționare corectă. Codul pe care l-am folosit pentru kitul de lumină este atașat într-un fișier numit „play_of_light_v0.ino”. Asigurați-vă că ați inclus bibliotecile necesare pentru funcționarea corectă a programului. Bateria pe care o adăugăm externă la circuit trebuie să aibă o tensiune minimă de 9V și trebuie să ne asigurăm că este capabilă să dea curentul minim necesar pentru alimentarea întregului circuit.

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

octet Versiune [3];

int8_t x_data; int8_t y_data; int8_t z_data; interval de octeți = 0x00; float divi = 16; float x, y, z; plutitor pi = 3.14159265359; float nx, ny, unghi; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Variabile Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parametrul 1 = numărul de pixeli din bandă // Parametrul 2 = Numărul pinului Arduino (majoritatea sunt valide) // Parametrul 3 = steaguri de tip pixel, adăugați împreună după cum este necesar: // NEO_KHZ800 800 KHz bitstream (majoritatea produselor NeoPixel cu LED-uri WS2812) // NEO_KHZ400 400 KHz (pixeli FLORA clasici (nu v2), drivere WS2811) // Pixelii NEO_GRB sunt conectați pentru bitstream GRB (majoritatea produselor NeoPixel) / / Pixelii NEO_RGB sunt conectați pentru fluxul de biți RGB (v1 pixeli FLORA, nu v2) // Pixelii NEO_RGBW sunt conectați pentru fluxul de biți RGBW (produse NeoPixel RGBW) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // IMPORTANT: Pentru a reduce riscul de ardere NeoPixel, adăugați 1000 uF condensator peste // cabluri de putere a pixelilor, adăugați rezistență de 300 - 500 Ohm la intrarea de date a primului pixel // și minimizați distanța dintre Arduino și primul pixel. Evitați conectarea // la un circuit live … dacă trebuie, conectați mai întâi GND.

// Variabile Rueda de colores

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson // lansat sub licența GPLv3 pentru a se potrivi cu restul bibliotecii AdaFruit NeoPixel

#include

#ifdef _AVR_ #include #endif

// Care pin de pe Arduino este conectat la NeoPixels?

// Pe un Trinket sau Gemma, vă sugerăm să schimbați acest lucru la 1 #define PIN 9

// Câți NeoPixeli sunt atașați la Arduino?

#define NUMPIXELS 16

// Când configurăm biblioteca NeoPixel, îi spunem câți pixeli și ce pin să folosească pentru a trimite semnale.

// Rețineți că pentru benzile NeoPixel mai vechi poate fi necesar să schimbați al treilea parametru - consultați exemplul strandtest // pentru mai multe informații despre valorile posibile. Adafruit_NeoPixel pixels = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // întârziere pentru 50ms

// Variabile culori aleatorios

#include #ifdef _AVR_ #include #endif

#define PIN 9

#define NUM_LEDS 16

#define BRIGHTNESS 200

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

octet 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 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/ SETARE METODO

void setup () {// Cod: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // adresa accelerometrului // setările intervalului Wire.write (0x22); // adresa de înregistrare Wire.write (range); // poate fi setat la "0x00" "0x01" "0x02" "0x03", consultați Datashhet pe wiki // filtru low-pass Wire.write (0x20); // adresa de înregistrare Wire.write (0x05); // poate fi setat la "0x05" "0x04" …… "0x01" "0x00", consultați Datashhet pe wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Aceasta este pentru Trinket 5V 16MHz, puteți elimina aceste trei linii dacă nu utilizați un Trinket #if definit (_AVR_ATtiny85_) dacă (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Sfârșitul codului special trinket strip.begin (); strip.show (); // Inițializați toți pixelii la „dezactivat”

// Código Rueda de colores

// Aceasta este pentru Trinket 5V 16MHz, puteți elimina aceste trei linii dacă nu utilizați un Trinket #if definit (_AVR_ATtiny85_) dacă (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Sfârșitul codului special bibelou

pixeli.begin (); // Aceasta inițializează biblioteca NeoPixel.

// Codigo Interrupcion

contor = 1;

// Codigo Colores varios

// Aceasta este pentru Trinket 5V 16MHz, puteți elimina aceste trei linii dacă nu utilizați un Trinket #if definit (_AVR_ATtiny85_) dacă (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Sfârșitul codului special trinket strip.setBrightness (LUMINOSITATE); strip.begin (); strip.show (); // Inițializați toți pixelii la „dezactivat”}

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

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

/ Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (counter == 1) {for (int i = 0; i 0.0) {if (nx 0.0) angle + = 180; altfel unghiul + = 360; } // end else if (angle == 360.0) angle = 0.0; led = circularize (angle / (360 / NUMBER_OF_LEDS_ON_RING)); // face ca mișcarea ledului să fie netedă dacă (anteriorLed == led) {// nimic de făcut} altfel dacă (counterClockwiseDistanceBetweenLeds (precedentLed, led) <= 8) led = circularize (precedentLed + 1); else led = circularize (precedentLed - 1); ledQueue.push (led); makeLightShow (); precedentLed = led; întârziere (25); } contor = 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 ++) {// Câteva exemple de proceduri care arată cum se afișează la pixeli: colorWipe1 (strip. Color (255, 0, 0), 50); // Culoare roșie Ștergeți1 (strip. Color (0, 255, 0), 50); // Culoare verde Ștergeți1 (bandă. Culoare (0, 0, 255), 50); // Culoare albastrăWipe1 (strip. Color (0, 0, 0, 255), 50); // White RGBW // Trimiteți o urmărire a pixelilor de teatru în … theaterChase (strip. Color (127, 127, 127), 50); // Teatru albChase (strip. Color (127, 0, 0), 50); // Red TheatreChase (strip. Color (0, 0, 127), 50); // Albastru

curcubeu (5);

RainbowCycle (5); theaterChaseRainbow (5); } contor = 3; } // End if counter == 2 // Caso 3: Luces Aleatorias else if (counter == 3) {for (int k = 0; k <50; k ++) {// Pentru un set de NeoPixels primul NeoPixel este 0, a doua este 1, până la numărul de pixeli minus unul. int a = aleatoriu (255); int b = aleatoriu (255); int c = aleatoriu (255); pentru (int i = 0; i

// pixeli. Culoarea ia valori RGB, de la 0, 0, 0 până la 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Culoare verde moderat strălucitoare.

pixels.show (); // Aceasta trimite culoarea pixelilor actualizată la hardware.

întârziere (delayval); // Întârziere pentru o perioadă de timp (în milisecunde).

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

// pixeli. Culoarea ia valori RGB, de la 0, 0, 0 până la 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Culoare verde moderat strălucitoare.

pixels.show (); // Aceasta trimite culoarea pixelilor actualizată la hardware.

întârziere (delayval); // Întârziere pentru o perioadă de timp (în milisecunde).

}} contor = 4; } else if (contor == 4) {for (int g = 0; g <= 6; g ++) {// Câteva exemple de proceduri care arată cum se afișează pixelii: colorWipe (strip. Color (255, 0, 0), 50); // Culoare roșie Ștergeți (strip. Color (0, 255, 0), 50); // Culoare verde Ștergeți (strip. Color (0, 0, 255), 50); // Culoare albastră Ștergeți (strip. Color (0, 0, 0, 255), 50); // White whiteOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // întârziere (2000); rainbowFade2White (3, 3, 1);

}

contor = 1; }} //////////////////////////////////////////////////// ///////////////////////////////////// /////////////// ////////////////////////////////////////////////////// /////////////////

/ Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // adresa accelerometrului // resetează accelerometrul Wire.write (0x04); // X date Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // solicitați 6 octeți de pe dispozitivul slave # 2 în timp ce (Wire.available ()) // slave poate trimite mai puțin decât solicitat {Version [0] = Wire.read (); // primiți un octet ca caracter} x_data = (int8_t) Versiunea [0] >> 2; Wire.beginTransmission (0x0A); // adresa accelerometrului // resetează accelerometrul Wire.write (0x06); // Y date Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // solicitați 6 octeți de pe dispozitivul slave # 2 în timp ce (Wire.available ()) // slave poate trimite mai puțin decât solicitat {Version [1] = Wire.read (); // primiți un octet ca caracter} y_data = (int8_t) Versiunea [1] >> 2; Wire.beginTransmission (0x0A); // adresa accelerometrului // resetează accelerometrul Wire.write (0x08); // Z date Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // solicitați 6 octeți de pe dispozitivul slave # 2 în timp ce (Wire.available ()) // slave poate trimite mai puțin decât solicitat {Version [2] = Wire.read (); // primiți un octet ca caracter} z_data = (int8_t) Versiunea [2] >> 2; x = (float) x_data / divi; y = (float) y_data / divi; z = (float) z_data / divi; Serial.print ("X ="); Serial.print (x); // tipărește caracterul Serial.print (""); Serial.print ("Y ="); Serial.print (y); // tipărește caracterul Serial.print (""); Serial.print ("Z ="); // tipărește caracterul Serial.println (z); }

int circularize (int pos) {

if (pos> = NUMBER_OF_LEDS_ON_RING) return (pos - NUMBER_OF_LEDS_ON_RING); altfel dacă (pos <0) returnează (pos + NUMBER_OF_LEDS_ON_RING); altfel return (pos); }

int distanta;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; dacă (distanță <0) distanță + = NUMBER_OF_LEDS_ON_RING; retur (distanta); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 luminozitate int Pasul = 255 / NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

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

// Umpleți punctele unul după altul cu o culoare gol colorWipe (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i

gol curcubeu (uint8_t așteptați) {

uint16_t i, j;

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

// Ușor diferit, acest lucru face ca curcubeul să fie distribuit în mod egal peste tot

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

for (j = 0; j <256 * 5; j ++) {// 5 cicluri de toate culorile pe roată pentru (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); întârziere (așteptați); }}

// Lumini târâtoare în stil teatru.

void theatreChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// faceți 10 cicluri de urmărire pentru (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, c); // porniți fiecare al treilea pixel pe} strip.show ();

întârziere (așteptați);

pentru (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // opriți fiecare al treilea pixel}}}}

// Lumini târâtoare în stil teatru cu efect curcubeu

void theatreChaseRainbow (uint8_t așteptați) {for (int j = 0; j <256; j ++) {// ciclați toate cele 256 de culori din roată pentru (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)); // porniți fiecare al treilea pixel pe} strip.show ();

întârziere (așteptați);

pentru (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // opriți fiecare al treilea pixel}}}}

// Introduceți o valoare de la 0 la 255 pentru a obține o valoare a culorii.

// Culorile sunt o tranziție r - g - b - înapoi la 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; bandă de întoarcere. Culoare (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos - = 170; bandă de întoarcere. Culoare (WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/ Metodos Rueda de colores

// int elegirColor = random (0x000000, 0xffffff); // Se alege aleatoriamente între toată gama de culori cuprinse între 0x000000 și 0xFFFFFF

// CylonEyeColor = HtmlColor (elegirColor); // int elegirColor = random (1, 7); // Podemos elegir aleatoriamente între cele 7 culori care au 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

// Umpleți punctele unul după altul cu o culoare

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

void pulseWhite (uint8_t așteptați) {

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

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

pentru (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 cicluri de toate culorile pe roată

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

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

redVal = roșu (wheelVal) * float (fadeVal / fadeMax);

greenVal = verde (wheelVal) * float (fadeVal / fadeMax); blueVal = albastru (wheelVal) * float (fadeVal / fadeMax);

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

}

// Prima buclă, fade in!

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

// Ultima buclă, decolorează!

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

strip.show ();

întârziere (așteptați); }}

întârziere (500);

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

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

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

întârziere (2000);

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

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

întârziere (500);

}

void whiteOverRainbow (uint8_t așteptați, uint8_t whiteSpeed, uint8_t whiteLength) {

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

int head = whiteLength - 1;

int tail = 0;

bucle int = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

while (adevărat) {

for (int j = 0; j <256; j ++) {for (uint16_t i = 0; i = tail && i head && i> = tail) || (coadă> 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 ++; coada ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == bucle) return;

head% = strip.numPixels (); coada% = strip.numPixels (); strip.show (); întârziere (așteptați); }}} void fullWhite () {for (uint16_t i = 0; i

// Ușor diferit, acest lucru face ca curcubeul să fie distribuit în mod egal peste tot

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

for (j = 0; j <256 * 5; j ++) {// 5 cicluri de toate culorile pe roată pentru (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); întârziere (așteptați); }}

gol curcubeu1 (uint8_t așteptați) {

uint16_t i, j;

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

// Introduceți o valoare de la 0 la 255 pentru a obține o valoare a culorii.

// Culorile sunt o tranziție r - g - b - înapoi la r. uint32_t Wheel1 (octet WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) {WheelPos - = 85; bandă de întoarcere. Culoare (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos - = 170; bandă de întoarcere. Culoare (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t roșu (uint32_t c) {

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

Pasul 8: Proiectare 3D

În primul rând, trebuie să vă dimensionați componentele hardware pentru a vă asigura că sunt corecte. Dacă sunt identice cu ale noastre, puteți utiliza aceleași fișiere pe care vi le împrumutăm.

Ambele suporturi au fost proiectate cu o imprimantă 3D, care sunt, de asemenea, incluse ca:

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

În cele din urmă, lumina va fi ca ultimele două imagini.

Pasul 9: Montarea gâtului

Mai întâi vom așeza șaua gâtului. Găurile de care șuruburile trebuie să o țină nu sunt acolo, așa că va trebui să le facem, marcând unde ar trebui să meargă și cu grijă, cu un melc, făcând gaura.

Același lucru se aplică găurilor în care șuruburile care țin gâtul însuși de corpul instrumentului. Nu este necesar să le faceți, deoarece nu există șuruburi pentru această fixare, dar dacă vrem să o facem, nu ar exista nicio problemă.

IMPORTANT: lăsați 5 mm spațiu între începutul catargului și începutul diapazonului, deoarece în acea gaură va fi așezată piulița.

Vom lipi piulița cu lipici, în direcția indicată de figură.

În cele din urmă, vom introduce cei 4 știfturi în găurile care se află la începutul catargului, ținând fiecare știft cu 2 șuruburi scurte așa cum se arată în imagine.

Pasul 10: Montarea Birdge

Podul este fixat prin lipire și cu cele două șuruburi lungi într-o poziție centrală pe corp. Este indicat să marcați cu un creion poziția corectă în corp. Vom lua distanțele marcate în imagine.

Vom aplica lipici la unirea celor două componente. Fixăm cele două părți cu atenție cu ajutorul unui șurub de strângere până când îmbinarea se usucă. Cele două găuri pentru șuruburi le vom face cu un burghiu de 1,5 mm pentru lemn. Fixați puntea cu cele două șuruburi lungi din corp. Și, în cele din urmă, punem capacele de protecție pe capetele șuruburilor.

Pasul 11: Asamblarea corpului și gâtului

Pentru asamblarea celor două părți, avem găuri în capul corpului, unde gâtul se va potrivi cu două proiecții pe care le are. Le putem lipi cu adeziv sau cu pistolul de topire la cald. Pentru a avea o fixare mai mare, puteți face găurile care se află în capătul diapazonului pentru a-l uni cu corpul.

Pasul 12: Puneți coardele Ukulele

În cele din urmă trebuie să așezăm corzile astfel încât instrumentul nostru să fie terminat.

Anterior vom introduce inelele de fixare ale știfturilor în proiecțiile acestora care trec prin catarg. Pentru a plasa corzile, am luat cele 4 corzi care au venit cu trusa. Mai întâi trebuie să distingeți fiecare șir pentru că nu sunt toate la fel. Trebuie să legați câte un capăt al fiecărui șir (cele două groase cu un nod normal și cele două subțiri cu unul dublu) și să introduceți șirurile în fante ale podului.

Apoi vom plasa corzile în așa fel încât:

• Prima poziție: șir G (al doilea cel mai gros șir).

• A doua poziție: șir C (șir mai gros).

• A treia poziție: șir E (al doilea șir mai subțire).

• Poziția a patra: Un șir (șir mai subțire).

Infilați șirurile în orificiile ștecherului furnizat. Încercați să fixați fiecare coardă dând două sau trei rotații pe știft. Tensionați corzile fără a aplica prea multă forță și verificați distanța dintre corzi și șa.

Dacă aveți vreo îndoială cu privire la modul în care faceți acest lucru, ați putea asculta acel tutorial care vă explică cum ați pus corect șirurile.

Pasul 13: Testarea

În cele din urmă, trebuie să vedem dacă ukulele a fost asamblat corespunzător în așa fel încât distanța ideală pe primul fret să fie de 0,1 mm și pe a douăsprezecea este de aproximativ 1,2 mm.

Este necesar să reglați corzile ukulele. Vă recomand această aplicație: GuitarTuna

Pasul 14: Bucurați-vă

Acum, trebuie doar să vă bucurați de ukulele dvs.

Dacă doriți să aflați mai multe informații despre noi, ne puteți găsi în:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc