Uradi sam pametnu elektroničku ukulele s Arduinom: 14 koraka (sa slikama)

2024 Autor: John Day | [email protected]. Zadnja izmjena: 2024-01-30 08:08

Objasnićemo korak po korak 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 ukelele montažu (mogao bi biti još jedan drugačiji komplet) formiran od:

1- Tijelo.

2-Neck.

3-sedlo

4-Rope Support

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 mašinski most (x2).

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

12 žica (x4).

Elektronski materijali:

• NANO Arduino.
• Led točak WS2812.
• Akcelerometar BMA220 (opcionalno).
• Konektor za bateriju.
• Baterija od 9V.
• Switch.

Drugi

• Lak za drvo.
• Velcro.
• Lim za lemljenje.
• Zaštitna plastika za lakiranje.
• Topljeni silikon.

Alati:

• Lasersko graviranje.
• Brusni papir
• Star odvijač.
• Kist.
• Pištolj za topljenje.
• Limeno lemilica.

Korak 2: Prilagodite Ukulele

Kako bismo skupo koštali našu 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 graviranje.

Da bismo to učinili, upotrijebit ćemo softver pod nazivom 'Inkscape' koji možemo nabaviti sa ove veze:

Da bismo je koristili, moramo prilagoditi sliku koju želimo koristiti kao što smo prikazali na drugoj slici. Mogli biste pogledati da smo rotirali početnu sliku kako bismo ciklus ruke mogli prilagoditi krugu instrumenta. Kao što smo već rekli, možete postaviti 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 je uređivač vektorske grafike otvorenog koda, i kako naslov implicira, 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. Poigrajte se opcijama Trace Bitmap
4. Pokrenite praćenje
5. Očistite rezultate (ako je potrebno)

Obratite pažnju na dio „igranja okolo“. Nisam stručnjak za praćenje, pa se prema ovom alatu odnosim kao prema crnoj kutiji 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 bismo mogli nabaviti sa:

Nakon što otvorimo softver, moramo učitati sliku koju smo stvorili u posljednjem koraku. Zatim pritisnite tipku "control 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

Da bismo ukulele ostavili svijetle 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, morali biste 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 nanesemo 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.

** MERE PREDOSTROŽNOSTI: Lak je hemijski proizvod, pa je potrebno izvršiti ovaj postupak na ventiliranom mestu, nositi masku kako bi se izbeglo udisanje mirisa i zaštitnih naočara.

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 okvir kako bi se izbjeglo da se sve komponente pomiču u instrumentu.

Dodali smo i držač baterije i prekidač kako bi bili udobniji i ne trošimo bateriju dok 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ć je manji od rupe pa bi pao. Nosač je dizajniran tako da se dobro drži i može obavljati svoju funkciju.

Korak 7: Softver

Da 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ćava da učinimo učinak gravitacije.

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

Crvene žice služe za napajanje, GND crne i ostale su neophodne veze za ispravan rad. Kôd koji smo koristili za komplet svjetla priložen je u datoteci pod nazivom "play_of_light_v0.ino". Uvjerite se da ste uključili potrebne biblioteke 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

bajt Verzija [3];

int8_t x_data; int8_t y_data; int8_t z_data; opseg bajtova = 0x00; float divi = 16; float 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 važeća) // Parametar 3 = zastavice tipa piksela, po potrebi zbrajajte: // NEO_KHZ800 800 KHz bitstream (većina NeoPixel proizvoda sa WS2812 LED diodama) // 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 NeoPixel proizvoda)/ / 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 tok bitova (NeoPixel RGBW proizvodi) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // VAŽNO: Da biste smanjili rizik od izgaranja NeoPixela, dodajte kondenzator od 1000 uF 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 strujno kolo … ako morate, prvo spojite GND.

// Varijable Rueda de colores

// NeoPixel Ring jednostavna skica (c) 2013 Shae Erisson // objavljeno pod GPLv3 licencom kako bi odgovaralo ostatku AdaFruit NeoPixel biblioteke

#include

#ifdef _AVR_ #include #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?

#define NUMPIXELS 16

// Kada postavljamo NeoPixel biblioteku, 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; // kašnjenje 50ms

// Varijable colores 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);

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 PODEŠAVANJE

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); // registrirajte adresu Wire.write (range); // može se postaviti na "0x00" "0x01" "0x02" "0x03", pogledajte Datashhet na wiki // niskopropusni filter Wire.write (0x20); // registrirajte adresu 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 kôd drangulije

pixels.begin (); // Ovo inicijalizira NeoPixel biblioteku.

// 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 (); // Inicijalizacija svih piksela 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) ugao+= 180; else kut += 360; } // kraj else if (angle == 360.0) angle = 0.0; LED = kružiti (kut / (360 / NUMBER_OF_LEDS_ON_RING)); // čine da kretanje LED -a bude glatko if (previousLed == led) {// ništa ne treba raditi} else if (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = cirkularizovati (previousLed + 1); else led = cirkulirati (previousLed - 1); ledQueue.push (led); makeLightShow (); previousLed = led; 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 procedura prikazuju kako prikazati u pikselima: colorWipe1 (strip. Color (255, 0, 0), 50); // Crvena colorWipe1 (strip. Color (0, 255, 0), 50); // Zelena colorWipe1 (strip. Color (0, 0, 255), 50); // Plava colorWipe1 (strip. Color (0, 0, 0, 255), 50); // Bijeli RGBW // Slanje lovačkog piksela u… theatreChase (strip. Color (127, 127, 127), 50); // Bijelo kazališteChase (strip. Color (127, 0, 0), 50); // Red theatreChase (strip. Color (0, 0, 127), 50); // Plava

duga (5);

rainbowCycle (5); TheaterChaseRainbow (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, drugo 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, pixels. Color (a, b, c)); // Umjereno svijetlo zelena boja.

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

kašnjenje (delayval); // Odgoda za određeni vremenski period (u milisekundama).

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

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

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

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

kašnjenje (delayval); // Odgoda za određeni vremenski period (u milisekundama).

}} brojač = 4; } else if (counter == 4) {for (int g = 0; g <= 6; g ++) {// Neki primjeri procedura koje pokazuju kako se prikazuje u pikselima: colorWipe (strip. Color (255, 0, 0), 50); // Crvena colorWipe (strip. Color (0, 255, 0), 50); // Zelena colorWipe (strip. Color (0, 0, 255), 50); // Plava colorWipe (strip. Color (0, 0, 0, 255), 50); // Bijela bijelaOverRainbow (20, 75, 5); pulseWhite (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 akcelerometra Wire.write (0x04); // X 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 [0] = Wire.read (); // primamo bajt kao character} x_data = (int8_t) Verzija [0] >> 2; Wire.beginTransmission (0x0A); // adresa akcelerometra // resetiranje 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 zahtijevanog {Version [1] = Wire.read (); // primamo bajt kao character} y_data = (int8_t) Verzija [1] >> 2; Wire.beginTransmission (0x0A); // adresa akcelerometra // resetiranje akcelerometra Wire.write (0x08); // Z podaci Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // zahtijeva 6 bajtova od slave uređaja #2 while (Wire.available ()) // slave 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 ="); Serial.print (x); // ispisuje znak Serial.print (""); Serial.print ("Y ="); Serial.print (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 (poz <0) return (pos + NUMBER_OF_LEDS_ON_RING); else return (poz); }

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

// Popunite tačke jednu za drugom bojom void 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

// Malo drugačije, ovo čini dugu podjednako raspoređenom po cijeloj dužini

void rainbowCycle (uint8_t čekanje) {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 (); kašnjenje (čekanje); }}

// Svjetla za puzanje u kazališnom stilu.

void theatreChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// uradimo 10 ciklusa jurenja 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 ();

kašnjenje (čekanje);

za (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // isključuje 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 kolu za (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, Točak ((i+j) % 255)); // uključuje svaki treći piksel} strip.show ();

kašnjenje (čekanje);

za (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // isključuje 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 Točak (bajt 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); // Omogućite unos aleadora unos toda la gama de colores comprendida entre 0x000000 y 0xFFFFFF

// CylonEyeColor = HtmlColor (elegirColor); // int elegirColor = random (1, 7); // Podešavanje 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

// Popunite tačke jednu za drugom bojom

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

void pulseWhite (uint8_t čekanje) {

for (int j = 0; j <256; j ++) {for (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;

za (int k = 0; k <rainbowLoops; k ++) {za (int j = 0; j <256; j ++) {// 5 ciklusa svih boja na kotaču

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

wheelVal = Točak (((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, nestanite!

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

strip.show ();

kašnjenje (čekanje); }}

kašnjenje (500);

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

kašnjenje (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 čekanje, uint8_t whiteSpeed, uint8_t whiteLength) {

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

int head = whiteLength - 1;

int tail = 0;

int petlje = 3;

int loopNum = 0;

statičko nepotpisano dugo 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, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

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

if (loopNum == petlje) return;

glava%= strip.numPixels (); tail%= strip.numPixels (); strip.show (); kašnjenje (čekanje); }}} void fullWhite () {for (uint16_t i = 0; i

// Malo drugačije, ovo čini dugu podjednako raspoređenom po cijeloj dužini

void rainbowCycle1 (uint8_t čekanje) {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 (); kašnjenje (č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 Wheel1 (bajt WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (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 da su ispravni. Ako su iste kao i naše, možete koristiti iste datoteke koje vam posuđujemo.

Obje podrške su dizajnirane sa 3D štampačem, koji su takođe uključeni 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 vrat za tijelo instrumenta. Nije ih potrebno raditi, jer za ovo pričvršćivanje nema vijaka, ali ako to želimo, ne bi bilo problema.

VAŽNO: Ostavite 5 mm razmaka između početka jarbola i početka viljuške, 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 svaku iglu s 2 kratka vijka kao što je prikazano na slici.

Korak 10: Montiranje ptice

Most se fiksira lijepljenjem i sa dva dugačka vijka u središnjem položaju na tijelu. Preporučljivo je olovkom označiti pravilan položaj u tijelu. Uzećemo udaljenosti koje su označene na slici.

Primijenit ćemo ljepilo pri spajanju dviju komponenti. Pažljivo učvršćujemo dva dijela pomoću zateznog vijka dok se spoj ne osuši. Dvije rupe za vijke napravit ćemo svrdlom za drvo od 1,5 mm. Pričvrstite most s dva dugačka vijka u tijelu. I na kraju, stavljamo 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 (dvije debele s normalnim čvorom, a dvije tanke s dvostrukim) i umetnuti žice u proreze mosta.

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

• Prva pozicija: G niz (drugi najdeblji niz).

• Druga pozicija: C niz (deblji niz).

• Treća pozicija: E žica (druga tanja žica).

• Četvrta pozicija: Žica (tanja žica).

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

Ako imate bilo kakvih nedoumica o tome 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 trebate 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