Pametna elektronička ukulele s Arduinom DIY: 14 koraka (sa slikama)

2024 Autor: John Day | [email protected]. Zadnja promjena: 2024-01-30 09:36

Korak po korak ćemo objasniti kako možete sami dizajnirati ukulele i dodati neke efekte koji će ga učiniti jedinstvenim, poput iscrtavanja nečega što želimo na površini ukulele ili dodavanja svjetlosnih efekata.

Da biste to učinili, potrebno je kupiti komplet za ukulele.

Objasnit ćemo kako sastaviti instrument i riješiti različite probleme koji bi se mogli pojaviti.

Korak 1: Materijali

Materijali za konstrukciju:

DIY komplet za montažu ukelelea (mogao bi biti još jedan drugačiji komplet) sastavljen od:

1- Tijelo.

2-vrat.

3-sedlo

Podrška za 4 užeta

5-most

6-žičana matica.

7-Prsten za pričvršćivanje glave stroja (x4).

8-glave stroja (x4).

9-montažni vijci za glave stroja (x8).

10-montažni vijci za strojni most (x2).

11-poklopci za vijke za pričvršćivanje mosta (x2).

12 žica (x4).

Elektronički materijali:

• NANO Arduino.
• Led kotač WS2812.
• Akcelerometar BMA220 (izborno).
• Priključak za bateriju.
• Baterija od 9V.
• Sklopka.

Drugi

• Lak za drvo.
• Čičak.
• Lim za lemljenje.
• Zaštitna plastika za lakiranje.
• Silikon za topljenje.

Alati:

• Lasersko graviranje.
• Šmirgl papir
• Odvijač sa zvjezdicom.
• Kist.
• Pištolj za topljenje.
• Limeno lemilica.

Korak 2: Prilagodite Ukulele

Kako bismo skupo koštali naš ukulele, mogli bismo napraviti gravuru crteža laserskim rezačem na tijelu. U slučaju da nemamo taj alat, mogli bismo ga slikati.

Slika koju smo odabrali prva se pojavljuje.

Prije svega, moramo dizajnirati predložak crteža za izradu gravure.

Da bismo to učinili, upotrijebit ćemo softver pod nazivom 'Inkscape' koji smo mogli dobiti s ove veze:

Da bismo ga koristili, moramo prilagoditi sliku koju želimo koristiti kao što smo prikazali na drugoj slici. Mogli biste pogledati da smo zakrenuli početnu sliku kako bismo ciklus ruke mogli prilagoditi krugu instrumenta. Kao što smo već rekli, možete staviti bilo koju sliku.

Korak 3: Vektorizirajte sliku pomoću Inkscape -a

Vidjet ćemo kako stvoriti vektorsku datoteku iz pixmape (jpg, png, bilo koji rasterski format koji Inkscape može otvoriti).

Inkscape Inkscape uređivač je vektorske grafike otvorenog koda, a kako i naslov govori, ovo je alat koji ću koristiti za vektorizaciju logotipa. Koraci vektorizacije Koraci su uobičajeni za svaku vektorizaciju koju bismo htjeli napraviti.

1. Otvorite sliku u Inkscape -u
2. Otvorite Trace Bitmap Tool Path-> Trace Bitmap
3. Igrajte se s opcijama Trace Bitmap
4. Pokrenite praćenje
5. Očistite rezultate (ako je potrebno)

Obratite pažnju na dio "poigravanja". Nisam stručnjak za praćenje, pa ovaj alat tretiram kao crnu kutiju s gumbima i svjetlima koja se uvijaju i mijenjaju dok ne postignem najbolji rezultat

Korak 4: Graviranje logotipa

Za to je važno imati siluetu površine na kojoj će se gravirati crtež.

Za graviranje ćemo koristiti softver 'T2Laser'. Ovaj softver mogli bismo nabaviti sa:

Nakon što otvorimo softver, moramo učitati sliku koju smo stvorili u posljednjem koraku. Zatim pritisnite gumb "kontrolni laser" i pojavit će se cnc kontrole. Dvije slike prikazuju proces i rezultat graviranja našim laserskim rezačem.

Korak 5: Brušenje i lakiranje

Kako bi naš ukulele ostao svijetao i sa slojem bez hrapavosti, možemo glatko izbrusiti dva dijela koja čine naš instrument, jer možemo oštetiti crtež koji je napravljen (ako ste odlučili slikati ukulele, morat ćete prvo ga izbrusite). Zatim ćemo naša dva dijela lakirati tako da dobiju tamniju boju, a drvo ima veću otpornost. Možemo koristiti običan lak za drvo, ne mora biti poseban.

Kad dobijemo lak, pomiješamo ga s malo otapala tako da se malo otopi. Zatim kistom nanosimo smjesu na vrat i tijelo instrumenta i ostavimo da se osuši.

Ako vidimo da proizvod treba drugi sloj, možemo malo izbrusiti dva dijela i ponovno nanijeti sloj razrijeđenog laka.

** MJERE OPREZA: Lak je kemijski proizvod, stoga je potrebno ovaj postupak izvesti na ventiliranom mjestu, nositi masku kako biste izbjegli udisanje mirisa i zaštitnih naočala.

Materijali koji su nam potrebni da bismo mogli ispravno raditi su oni koji se pojavljuju na fotografijama. Radit ćemo uglavnom četkom, limenkom laka (u našem slučaju crvenom bojom), malo otapala i zaštitom vida. I prije svega rad u dobro prozračenim prostorima.

Korak 6: Hardver

Naša ploča s Arduinom, acelerometrom i kotačićem s LED diodama bit će stavljena u mali nosač kako bi se izbjeglo da se sve komponente pomiču u instrumentu.

Dodali smo i držač baterije i prekidač kako bi bili ugodniji i ne trošimo bateriju kada ne koristimo instrument. Ovaj nosač pričvrstit ćemo komadom čičak trake (također bi funkcionirao sa silikonom i pištoljem za topljenje) na unutarnju stranu tijela ukulele. S druge strane, LED kotačić manji je od rupe pa bi pao. Nosač je dizajniran tako da dobro drži i može obavljati svoju funkciju.

Korak 7: Softver

Kako bismo našem ukuleleu dali poseban ukras, mogli bismo dodati svjetlosne efekte zahvaljujući kotaču LED dioda. Koristit ćemo WS2812, ali možete koristiti bilo koji drugi slijedeći upute u podatkovnoj tablici. Koristit ćemo i acelerometar (BMA220) koji nam omogućuje učinak gravitacije.

Zapravo, imat ćemo 4 svjetlosne predstave, uključene u računalnu knjižnicu pod nazivom 'Adafruit' iz Arduina. Da bismo to učinili, moramo napraviti ispravan spoj između tri komponente: Arduino NANO, WS2812 i BMA220, kao što je prikazano na prvoj slici.

Crvene žice služe za napajanje, crne GND, a ostale su potrebne veze za ispravan rad. Kôd koji smo koristili za komplet svjetla priložen je u datoteci pod nazivom "play_of_light_v0.ino". Provjerite jeste li uključili potrebne knjižnice za ispravan rad programa. Baterija koju dodamo vanjskom krugu mora imati minimalni napon od 9V i moramo osigurati da može dati minimalnu struju potrebnu za napajanje cijelog kruga.

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

bajtna verzija [3];

int8_t x_data; int8_t y_data; int8_t z_data; raspon bajtova = 0x00; float divi = 16; plutaju x, y, z; plovak pi = 3,14159265359; float nx, ny, angle; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Varijable Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parametar 1 = broj piksela u traci // Parametar 2 = Arduino broj pina (većina je ispravna) // Parametar 3 = zastavice tipa piksela, po potrebi zbrajajte: // NEO_KHZ800 800 KHz bitstream (većina NeoPixel proizvoda sa LED diodama WS2812) // NEO_KHZ400 400 KHz (klasični 'v1' (ne v2) FLORA pikseli, upravljački programi WS2811) // NEO_GRB Pikseli su ožičeni za GRB bitstream (većina proizvoda NeoPixel)/ / NEO_RGB Pikseli su ožičeni za RGB bitstream (v1 FLORA piksela, a ne v2) // NEO_RGBW Pikseli su ožičeni za RGBW bitstream (NeoPixel RGBW proizvodi) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // VAŽNO: Da biste smanjili rizik od izgaranja NeoPixela, dodajte 1000 uF kondenzatora preko // kabela za napajanje piksela, dodajte otpornik 300 - 500 Ohm na ulaz podataka prvog piksela // i smanjite udaljenost između Arduina i prvog piksela. Izbjegavajte spajanje // na strujni krug … ako morate, prvo spojite GND.

// Varijable Rueda de colores

// NeoPixel Ring jednostavna skica (c) 2013. Shae Erisson // objavljena pod licencom GPLv3 kako bi odgovarala ostatku biblioteke AdaFruit NeoPixel

#uključi

#ifdef _AVR_ #uključuje #endif

// Koji je pin na Arduinu spojen na NeoPixels?

// Na Trinketu ili Gemmi predlažemo da ovo promijenite u 1 #define PIN 9

// Koliko je NeoPixela priključeno na Arduino?

#definirajte BROJKE 16

// Kad postavljamo NeoPixel knjižnicu, govorimo joj koliko piksela i koji pin treba koristiti za slanje signala.

// Imajte na umu da ćete za starije NeoPixel trake možda morati promijeniti treći parametar-za više informacija o mogućim vrijednostima pogledajte primjer Strandtest //. Adafruit_NeoPixel pikseli = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // odgoda za 50ms

// Varijable colores aleatorios

#include #ifdef _AVR_ #include #endif

#definirajte PIN 9

#define NUM_LEDS 16

#definirajte SVJETLOST 200

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

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

/METODO POSTAVKE

void setup () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // adresa akcelerometra // postavke raspona Wire.write (0x22); // adresa registra Wire.write (raspon); // može se postaviti na "0x00" "0x01" "0x02" "0x03", pogledajte Datashhet na wikiju // niskopropusni filter Wire.write (0x20); // adresa registra Wire.write (0x05); // može se postaviti na "0x05" "0x04" …… "0x01" "0x00", pogledajte Datashhet na wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Ovo je za Trinket 5V 16MHz, možete ukloniti ove tri linije ako ne koristite Trinket #if definirano (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Kraj drangulije poseban kod strip.begin (); strip.show (); // Pokretanje svih piksela na "isključeno"

// Código Rueda de colores

// Ovo je za Trinket 5V 16MHz, možete ukloniti ove tri linije ako ne koristite Trinket #if definirano (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Poseban kod kraja drangulije

pikseli.begin (); // Ovo inicijalizira NeoPixel knjižnicu.

// Codigo Interrupcion

brojač = 1;

// Codigo Colores varios

// Ovo je za Trinket 5V 16MHz, možete ukloniti ove tri linije ako ne koristite Trinket #if definirano (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Kraj drangulije poseban kod strip.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Inicijaliziraj sve piksele na "isključeno"}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (brojač == 1) {for (int i = 0; i 0.0) {if (nx 0.0) kut+= 180; else kut += 360; } // kraj else if (kut == 360,0) kut = 0,0; LED = kružiti (kut / (360 / NUMBER_OF_LEDS_ON_RING)); // učiniti LED kretanje glatkim if (previousLed == led) {// ništa za napraviti} else if (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = cirkularizirati (previousLed + 1); else led = cirkulirati (previousLed - 1); ledQueue.push (vodio); makeLightShow (); previousLed = vodio; kašnjenje (25); } brojač = 2; } // Završi ako je brojač == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Neki primjeri postupaka koji prikazuju kako prikazati u pikselima: colorWipe1 (strip. Color (255, 0, 0), 50); // Crvena bojaWipe1 (strip. Color (0, 255, 0), 50); // Zelena bojaWipe1 (strip. Color (0, 0, 255), 50); // Plava bojaWipe1 (strip. Color (0, 0, 0, 255), 50); // Bijeli RGBW // Slanje kazališnih piksela u … theatreChase (strip. Color (127, 127, 127), 50); // Bijelo kazališteChase (strip. Color (127, 0, 0), 50); // Crveno kazališteChase (strip. Color (0, 0, 127), 50); // Plava

duga (5);

rainbowCycle (5); kazališteChaseRainbow (5); } brojač = 3; } // End if counter == 2 // Caso 3: Luces Aleatorias else if (counter == 3) {for (int k = 0; k <50; k ++) {// Za skup NeoPixela prvi NeoPixel je 0, druga je 1, sve do broja piksela minus jedan. int a = slučajno (255); int b = slučajno (255); int c = slučajno (255); za (int i = 0; i

// piksela. Boja uzima RGB vrijednosti, od 0, 0, 0 do 255, 255, 255

pixels.setPixelColor (i, pikseli. Color (a, b, c)); // Umjereno svijetlo zelena boja.

pikseli.show (); // Ovo šalje ažuriranu boju piksela na hardver.

odgoda (delayval); // Odgoda za određeno vrijeme (u milisekundama).

} a = slučajno (255); b = slučajno (255); c = slučajno (255); za (int i = NUMPIXELS; i> 0; i-) {

// piksela. Boja uzima RGB vrijednosti, od 0, 0, 0 do 255, 255, 255

pixels.setPixelColor (i, pikseli. Boja (a, b, c)); // Umjereno svijetlo zelena boja.

pikseli.show (); // Ovo šalje ažuriranu boju piksela na hardver.

odgoda (delayval); // Odgoda za određeno vrijeme (u milisekundama).

}} brojač = 4; } else if (counter == 4) {for (int g = 0; g <= 6; g ++) {// Neki primjeri postupaka koji pokazuju kako se prikazati u pikselima: colorWipe (strip. Color (255, 0, 0), 50); // Crvena bojaWipe (strip. Color (0, 255, 0), 50); // Zelena bojaWipe (strip. Color (0, 0, 255), 50); // Plava bojaWipe (strip. Color (0, 0, 0, 255), 50); // Bijela bijelaOverRainbow (20, 75, 5); pulseBjelo (5); // fullWhite (); // kašnjenje (2000); rainbowFade2White (3, 3, 1);

}

brojač = 1; }} ////////////////////////////////////////////////////// /////////////////////////////////////// ///////////////// ////////////////////////////////////////////////////////// ///////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // adresa akcelerometra // resetiranje mjerila akcelerometra Wire.write (0x04); // X podaci Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // zahtijevam 6 bajtova od slave uređaja #2 while (Wire.available ()) // slave može poslati manje od traženog {Version [0] = Wire.read (); // primamo bajt kao character} x_data = (int8_t) Verzija [0] >> 2; Wire.beginTransmission (0x0A); // adresa akcelerometra // resetiranje mjerila akcelerometra Wire.write (0x06); // Y podaci Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // zahtijeva 6 bajtova od slave uređaja #2 while (Wire.available ()) // slave može poslati manje od traženog {Version [1] = Wire.read (); // primamo bajt kao character} y_data = (int8_t) Verzija [1] >> 2; Wire.beginTransmission (0x0A); // adresa akcelerometra // resetiranje mjerila akcelerometra Wire.write (0x08); // Z podaci Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // zahtijeva 6 bajtova od slave uređaja #2 while (Wire.available ()) // rob može poslati manje od zahtijevanog {Version [2] = Wire.read (); // primamo bajt kao character} z_data = (int8_t) Verzija [2] >> 2; x = (float) x_data/divi; y = (float) y_data/divi; z = (float) z_data/divi; Serial.print ("X ="); Serijski.ispis (x); // ispisuje znak Serial.print (""); Serial.print ("Y ="); Serijski.ispis (y); // ispisuje znak Serial.print (""); Serial.print ("Z ="); // ispisuje znak Serial.println (z); }

int circularize (int pos) {

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

int udaljenost;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; if (udaljenost <0) udaljenost += NUMBER_OF_LEDS_ON_RING; povratak (udaljenost); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

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

// Ispunite točke jednu za drugom bojom praznine colorWipe (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i

void rainbow (uint8_t wait) {

uint16_t i, j;

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

// Pomalo drugačije, zbog toga je duga podjednako raspoređena

void rainbowCycle (uint8_t čekaj) {uint16_t i, j;

za (j = 0; j <256*5; j ++) {// 5 ciklusa svih boja na kotaču za (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); odgoda (čekanje); }}

// Svjetla za puzanje u kazališnom stilu.

void theatreChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// napravite 10 ciklusa jurnjave za (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // uključuje svaki treći piksel} strip.show ();

odgoda (čekanje);

za (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // isključi svaki treći piksel}}}}

// Svjetla za puzanje u kazališnom stilu s efektom duge

void theatreChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// ciklus svih 256 boja u kotaču za (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, Kotačić ((i+j) % 255)); // uključuje svaki treći piksel} strip.show ();

odgoda (čekanje);

za (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // isključi svaki treći piksel}}}}

// Unesite vrijednost od 0 do 255 da biste dobili vrijednost boje.

// Boje su prijelaz r - g - b - natrag u r. uint32_t Kotač (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } if (WheelPos <170) {WheelPos -= 85; povratna traka. Boja (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; povratna traka. Boja (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

// Ispunite točkice jednu za drugom bojom

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

void pulseWhite (uint8_t čekanje) {

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

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

za (uint16_t i = 0; i

void rainbowFade2White (uint8_t čekaj, 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 ciklusa svih boja na kotaču

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

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

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

greenVal = zelena (wheelVal) * float (fadeVal/fadeMax); blueVal = plavo (wheelVal) * float (fadeVal/fadeMax);

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

}

// Prva petlja, postepeno!

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

// Zadnja petlja, izblijedi!

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

strip.show ();

odgoda (čekanje); }}

kašnjenje (500);

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

za (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 (); }

odgoda (2000);

za (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 (); }}

kašnjenje (500);

}

void whiteOverRainbow (uint8_t čekaj, uint8_t whiteSpeed, uint8_t whiteLength) {

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

int head = whiteLength - 1;

int rep = 0;

int petlje = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

while (istina) {

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

if (millis () - lastTime> whiteSpeed) {

glava ++; rep ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == petlje) return;

glava%= strip.numPixels (); rep%= strip.numPixels (); strip.show (); odgoda (čekanje); }}} void fullWhite () {for (uint16_t i = 0; i

// Pomalo drugačije, zbog toga je duga podjednako raspoređena

void rainbowCycle1 (uint8_t čekaj) {uint16_t i, j;

za (j = 0; j <256 * 5; j ++) {// 5 ciklusa svih boja na kotaču za (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); odgoda (čekanje); }}

void rainbow1 (uint8_t čekaj) {

uint16_t i, j;

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

// Unesite vrijednost od 0 do 255 da biste dobili vrijednost boje.

// Boje su prijelaz r - g - b - natrag u r. uint32_t Kotač1 (bajt WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {povratna traka. Boja (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) {WheelPos -= 85; povratna traka. Boja (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; povratna traka. Boja (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t crveno (uint32_t c) {

return (c >> 16); } uint8_t zeleno (uint32_t c) {return (c >> 8); } uint8_t plavo (uint32_t c) {return (c); }

Korak 8: 3D dizajn

Prvo morate dimenzionirati hardverske komponente kako biste bili sigurni u ispravnost. Ako su iste kao naše, možete koristiti iste datoteke koje vam posuđujemo.

Obje su potpore dizajnirane s 3D pisačem, koje su također uključene kao:

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

Konačno, svjetlo će biti poput dvije posljednje slike.

Korak 9: Montiranje vrata

Prvo ćemo sedlo postaviti na vrat. Rupe koje vijci trebaju držati nisu tu, pa ćemo ih morati napraviti, označivši gdje trebaju ići i pažljivo, pomoću svrdla, napraviti rupu.

Isto se odnosi i na rupe u kojima su vijci koji drže sam vrat uz tijelo instrumenta. Nije ih potrebno raditi, budući da za ovo pričvršćivanje nema vijaka, ali ako to želimo učiniti, ne bi bilo problema.

VAŽNO: ostavite 5 mm razmaka između početka jarbola i početka ugađanja vilice, jer će u tu rupu biti postavljena matica.

Maticu ćemo zalijepiti ljepilom, u smjeru koji prikazuje slika.

Konačno, predstavit ćemo 4 igle u rupama na početku jarbola, držeći svaki zatik s 2 kratka vijka kao što je prikazano na slici.

Korak 10: Montiranje ptice

Most se učvršćuje lijepljenjem i s dva duga vijka u središnjem položaju na tijelu. Preporučljivo je olovkom označiti ispravan položaj u tijelu. Uzet ćemo udaljenosti koje su označene na slici.

Ljepilo ćemo nanijeti pri spajanju dviju komponenti. Dva dijela pažljivo učvršćujemo pomoću vijka za stezanje dok se spoj ne osuši. Dvije rupe za vijke napravit ćemo svrdlom od 1,5 mm za drvo. Popravite most s dva dugačka vijka u tijelu. I na kraju, stavili smo zaštitne kape na glave vijaka.

Korak 11: Sklapanje tijela i vrata

Za sastavljanje dva dijela imamo rupe na glavi tijela, gdje će se vrat uklopiti s dvije izbočine koje ima. Možemo ih zalijepiti ljepilom ili pištoljem za topljenje. Da biste imali veću fiksaciju, možete napraviti rupe koje se nalaze na kraju viljuške kako biste je spojili s tijelom.

Korak 12: Stavite Ukulele žice

Na kraju moramo postaviti žice tako da naš instrument bude gotov.

Prethodno ćemo umetnuti prstenove za pričvršćivanje klinova u njihove izbočine koji prolaze kroz jarbol. Za postavljanje žica uzeli smo 4 žice koje su došle s kompletom. Prvo morate razlikovati svaki niz jer nisu svi isti. Morate vezati jedan kraj svake žice (dva debela s normalnim čvorom, a dva tanka s dvostrukim) i umetnuti žice u utore mosta.

Tada ćemo nizove postaviti na takav način da:

• Prvo mjesto: G niz (drugi najdeblji niz).

• Drugo mjesto: C niz (deblji niz).

• Treće mjesto: E niz (drugi tanji niz).

• Četvrto mjesto: Žica (tanja žica).

Uvucite žice u otvore isporučenog utikača. Pokušajte popraviti svako uže tako da dva ili tri puta okrenete iglu. Zategnite žice bez primjene prevelike sile i provjerite udaljenost između žica i sedla.

Ako imate bilo kakvih sumnji u to kako to učiniti, možete izbaciti vodič koji će vam objasniti kako ste pravilno postavili nizove.

Korak 13: Testiranje

Na kraju, moramo vidjeti je li ukulele pravilno sastavljena na takav način da je idealna udaljenost na prvom pragu 0,1 mm, a na dvanaestom približno 1,2 mm.

Potrebno je da podesite ukulele žice. Preporučujem vam ovu aplikaciju: GuitarTuna

Korak 14: Uživajte

Sada samo morate uživati u ukuleleu.

Ako želite znati više informacija o nama, možete nas pronaći na:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc