DIY pametna elektronska ukulela z Arduinom: 14 korakov (s slikami)

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:07

Korak za korakom bomo razložili, kako lahko oblikujete svojo ukulelo in dodate nekaj učinkov, ki bodo naredili edinstveno, na primer, da na površino ukulele narišemo nekaj, kar želimo, ali dodamo nekaj svetlobnih učinkov.

Če želite to narediti, morate kupiti komplet za ukulele.

Pojasnili bomo, kako sestaviti instrument, in rešiti različne težave, ki bi se lahko pojavile.

1. korak: Materiali

Konstrukcijski materiali:

Komplet za montažo ukelele DIY (lahko je to drug komplet), ki ga sestavljajo:

1- Telo.

2-vrat.

3-sedlo

Podpora za 4 vrvi

5-most

6-strunna matica.

7-Pritrdilni obroč za glavo stroja (x4).

8-glave stroja (x4).

9-pritrdilni vijaki za glave stroja (x8).

10-pritrdilni vijaki za strojni most (x2).

11-pokrovi za pritrdilne vijake za most (x2).

12 strun (x4).

Elektronski materiali:

• NANO Arduino.
• Led kolo WS2812.
• Merilnik pospeška BMA220 (neobvezno).
• Priključek za baterijo.
• Baterija 9V.
• Preklopite.

Drugi

• Lak za les.
• Ježevi trakovi.
• Spajkalnik.
• Zaščitna plastika za lakiranje.
• Vroče topljeni silikon.

Orodja:

• Lasersko graviranje.
• Brusni papir
• Zvezdni izvijač.
• Čopič.
• Pištola za vroče taljenje.
• Spajkalnik iz kositra.

Korak: Prilagodite Ukulele

Za ceno naše ukulele bi lahko na telesu gravirali risbo z laserskim rezalnikom. V primeru, da tega orodja nimamo, ga lahko pobarvamo.

Slika, ki smo jo izbrali, je prva, ki se prikaže.

Najprej moramo oblikovati risalno predlogo za graviranje.

Za to bomo uporabili programsko opremo, imenovano "Inkscape", ki jo lahko dobimo na tej povezavi:

Če ga želimo uporabiti, moramo sliko, ki jo želimo uporabiti, prilagoditi, kot je prikazano na drugi sliki. Lahko bi pogledali, da smo začetno sliko zavrteli, da bi lahko prilagodili cikel roke s krogom instrumenta. Kot smo že povedali, lahko postavite katero koli sliko.

3. korak: Vektorizirajte sliko z uporabo Inkscape

Bomo videli, kako ustvariti vektorsko datoteko iz slike pixmap (jpg, png, ne glede na rastrsko obliko, ki jo lahko odpre Inkscape).

Inkscape Inkscape je odprtokodni urejevalnik vektorske grafike in kot pove že naslov, je to orodje, ki ga bom uporabil za vektorizacijo logotipov. Koraki vektorja Koraki so skupni za vsako vektorizacijo, ki bi jo radi izvedli.

1. Odprite sliko v programu Inkscape
2. Odprite pot orodja Trace Bitmap-> Trace Bitmap
3. Poigrajte se z možnostmi Trace Bitmap
4. Zaženite sledenje
5. Počistite rezultate (če je potrebno)

Upoštevajte del "igranja". Nisem strokovnjak za sledenje, zato to orodje obravnavam kot črno škatlo z gumbi in lučmi, ki se zvija in spreminja, dokler ne dobim najboljšega rezultata

4. korak: Graviranje logotipa

Za to je pomembno imeti silhueto površine, na kateri bo narejeno graviranje risbe.

Za graviranje bomo uporabili programsko opremo 'T2Laser'. To programsko opremo bi lahko dobili na:

Ko odpremo programsko opremo, moramo naložiti sliko, ki smo jo ustvarili v zadnjem koraku. Nato pritisnite gumb "kontrolni laser" in prikaže se kontrolnik cnc. Dve sliki prikazujeta postopek in rezultat graviranja z našim laserskim rezalnikom.

5. korak: Brušenje in lakiranje

Če želimo pustiti ukulele svetle in s plastjo brez hrapavosti, lahko dva dela, ki sestavljajo naš instrument, gladko prešmirkamo, saj lahko poškodujemo nastalo risbo (če ste se odločili za barvanje ukulele, bi morali najprej ga obrusite). Nato bomo naša dva dela lakirala tako, da bosta dobili temnejšo barvo, les pa bo imel večjo odpornost. Lahko uporabimo običajen lak za les, ni nujno, da je poseben.

Ko imamo lak, ga zmešamo z malo topila, da se malo raztopi. Nato zmes nanesemo s čopičem na vrat in telo instrumenta in pustimo, da se posuši.

Če vidimo, da izdelek potrebuje drugi sloj, lahko dva dela nekoliko pobrusimo in ponovno nanesemo plast razredčenega laka.

** PREVIDNOSTNI UKREPI: Lak je kemični izdelek, zato ga je treba izvesti v prezračevanem prostoru, nositi masko, da se izognete vdihavanju vonjav in zaščitnih očal.

Materiali, ki jih moramo znati pravilno delovati, so tisti, ki so prikazani na fotografijah. Delali bomo predvsem s čopičem, pločevinko laka (v našem primeru rdeče barve), malo topila in zaščito vida. In predvsem delo v dobro prezračenih prostorih.

6. korak: Strojna oprema

Naša plošča z Arduinom, merilnikom merilnika števca in kolesom z LED diodami bo predstavljena v majhnem oklepaju, da se izognemo premikanju vseh komponent v instrumentu.

Dodali smo tudi držalo za baterijo in stikalo, ki bo olajšalo uporabo in ne obrabimo baterije, ko instrumenta ne uporabljamo. To oporo bomo pritrdili s kosom Velcro (deloval bi tudi s silikonom in pištolo za topljenje) na notranjo stran ohišja ukulele. Po drugi strani pa je LED kolo manjše od luknje, zato bi padlo. Nosilec je zasnovan tako, da dobro drži in lahko opravlja svojo funkcijo.

7. korak: Programska oprema

Za posebno dekoracijo naše ukulele bi lahko dodali svetlobne učinke zahvaljujoč kolesu LED. Uporabili bomo WS2812, lahko pa uporabite katero koli drugo po navodilih v podatkovnem listu. Uporabili bomo tudi acelerometer (BMA220), ki nam omogoča vpliv gravitacije.

Pravzaprav bomo imeli 4 igre svetlobe, vključene v računalniško knjižnico, imenovano 'Adafruit' iz Arduina. Za to moramo pravilno združiti tri komponente: Arduino NANO, WS2812 in BMA220, kot je prikazano na prvi sliki.

Rdeče žice so za napajanje, črne GND in ostale so potrebne povezave za pravilno delovanje. Koda, ki smo jo uporabili za svetlobni komplet, je priložena v datoteki z imenom "play_of_light_v0.ino". Prepričajte se, da ste vključili potrebne knjižnice za pravilno delovanje programa. Baterija, ki jo dodamo zunaj vezja, mora imeti najmanjšo napetost 9 V in zagotoviti moramo, da lahko odda minimalni tok, potreben za napajanje celotnega vezja.

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

bajtna različica [3];

int8_t x_data; int8_t y_data; int8_t z_data; bajtni obseg = 0x00; float divi = 16; float x, y, z; plovec pi = 3,14159265359; float nx, ny, kot; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Spremenljivke Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parameter 1 = število slikovnih pik v traku // Parameter 2 = Arduino pin številka (večina je veljavnih) // Parameter 3 = zastavice tipa slikovnih pik, po potrebi seštejte: // NEO_KHZ800 800 KHz bitni tok (večina izdelkov NeoPixel z LED diodami WS2812) // NEO_KHZ400 400 KHz (klasični 'v1' (ne v2) slikovne pike FLORA, gonilniki WS2811) // NEO_GRB Piksli so povezani z bitnim tokom GRB (večina izdelkov NeoPixel)/ / NEO_RGB Piksli so ožičeni za bitni tok RGB (v1 FLORA slikovnih pik, ne v2) // NEO_RGBW Piksli so ožičeni za bitni tok RGBW (izdelki NeoPixel RGBW) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // POMEMBNO: Če želite zmanjšati nevarnost izgorevanja NeoPixel, dodajte 1000 uF kondenzatorja na // napajalne kable pikslov, dodajte 300 - 500 Ohm upor na vnos podatkov prve piksle // in zmanjšajte razdaljo med Arduinom in prvim piksom. Izogibajte se priključitvi // na tokokrog pod napetostjo … če morate, najprej priključite GND.

// Spremenljivke Rueda de colores

// Enostavna skica NeoPixel Ring (c) 2013 Shae Erisson // izdana pod licenco GPLv3, da ustreza preostali knjižnici AdaFruit NeoPixel

#vključi

#ifdef _AVR_ #include #endif

// Kateri pin na Arduinu je povezan z NeoPixels?

// Na Trinketu ali Gemmi predlagamo, da to spremenite v 1 #define PIN 9

// Koliko NeoPixels je priključenih na Arduino?

#define NUMPIXELS 16

// Ko nastavimo knjižnico NeoPixel, ji povemo, koliko slikovnih pik in kateri pin uporabite za pošiljanje signalov.

// Upoštevajte, da boste za starejše trakove NeoPixel morda morali spremeniti tretji parameter-glejte primer strandtest // za več informacij o možnih vrednostih. Piksli Adafruit_NeoPixel = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // zamuda za 50 ms

// Spremenljivke colores aleatorios

#include #ifdef _AVR_ #include #endif

#define PIN 9

#define NUM_LEDS 16

#define SVETLOST 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 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/NASTAVITEV METODA

void setup () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // naslov merilnika pospeška // nastavitve območja Wire.write (0x22); // registrirajte naslov Wire.write (obseg); // lahko nastavite na "0x00" "0x01" "0x02" "0x03", glejte Datashhet na wikiju // nizkoprepustni filter Wire.write (0x20); // registrirajte naslov Wire.write (0x05); // lahko nastavite na "0x05" "0x04" …… "0x01" "0x00", glejte Datashhet na wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// To je za Trinket 5V 16MHz, te tri vrstice lahko odstranite, če ne uporabljate Trinket #if definirano (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Konec nakita posebna koda strip.begin (); strip.show (); // Inicializirajte vse slikovne pike na "off"

// Código Rueda de colores

// To je za Trinket 5V 16MHz, te tri vrstice lahko odstranite, če ne uporabljate Trinket #if definirano (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Posebna koda drobtinice

pixels.begin (); // To inicializira knjižnico NeoPixel.

// Codigo Interrupcion

števec = 1;

// Codigo Colores varios

// To je za Trinket 5V 16MHz, te tri vrstice lahko odstranite, če ne uporabljate Trinket #if definirano (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Konec drobtinice poseben kodni trak.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Inicializirajte vse slikovne pike na 'off'}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (števec == 1) {for (int i = 0; i 0.0) {if (nx 0.0) kot+= 180; drugače kot += 360; } // konec else if (kot == 360,0) kot = 0,0; LED = kroženje (kot / (360 / NUMBER_OF_LEDS_ON_RING)); // omogočimo gladko premikanje led if (previousLed == led) {// ničesar ne storimo} else if (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); else led = cirkuliraj (previousLed - 1); ledQueue.push (led); makeLightShow (); previousLed = led; zamuda (25); } števec = 2; } // Konec, če je števec == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Nekateri primeri postopkov, ki prikazujejo kako prikazati v slikovnih pikah: colorWipe1 (strip. Color (255, 0, 0), 50); // Rdeča barvaWipe1 (strip. Color (0, 255, 0), 50); // zelena barvaWipe1 (strip. Color (0, 0, 255), 50); // modra colorWipe1 (strip. Color (0, 0, 0, 255), 50); // Bela RGBW // Pošlji lov na slikovne pike gledališča v… theatreChase (strip. Color (127, 127, 127), 50); // Belo gledališčeChase (strip. Color (127, 0, 0), 50); // Rdeče gledališčeChase (strip. Color (0, 0, 127), 50); // Modra

mavrica (5);

rainbowCycle (5); TheaterChaseRainbow (5); } števec = 3; } // Konec, če je števec == 2 // Caso 3: Luces Aleatorias sicer if (števec == 3) {for (int k = 0; k <50; k ++) {// Za niz NeoPixel je prvi NeoPixel 0, druga je 1, vse do števila slikovnih pik minus ena. int a = naključno (255); int b = naključno (255); int c = naključno (255); za (int i = 0; i

// slikovnih pik. Barva ima vrednosti RGB, od 0, 0, 0 do 255, 255, 255

pixels.setPixelColor (i, piksli. Color (a, b, c)); // Zmerno svetlo zelena barva.

piksli.show (); // To pošlje posodobljeno barvo slikovnih pik strojni opremi.

zamuda (delayval); // Zakasnitev za časovno obdobje (v milisekundah).

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

// slikovnih pik. Barva ima vrednosti RGB, od 0, 0, 0 do 255, 255, 255

pixels.setPixelColor (i, piksli. Color (a, b, c)); // Zmerno svetlo zelena barva.

piksli.show (); // To pošlje posodobljeno barvo slikovnih pik strojni opremi.

zamuda (delayval); // Zakasnitev za časovno obdobje (v milisekundah).

}} števec = 4; } else if (counter == 4) {for (int g = 0; g <= 6; g ++) {// Nekaj primerov postopkov, ki prikazujejo prikaz v slikovnih pikah: colorWipe (strip. Color (255, 0, 0), 50); // Rdeča colorWipe (strip. Color (0, 255, 0), 50); // zelena colorWipe (strip. Color (0, 0, 255), 50); // Modra colorWipe (strip. Color (0, 0, 0, 255), 50); // Bela belaOverRainbow (20, 75, 5); pulseBelo (5); // fullWhite (); // zamuda (2000); rainbowFade2White (3, 3, 1);

}

števec = 1; }} //////////////////////////////////////////////////// /////////////////////////////////////// ///////////////// //////////////////////////////////////////////////////// ///////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // naslov merilnika pospeška // ponastavitev merilnika pospeška Wire.write (0x04); // X podatki Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // zahtevam 6 bajtov od podrejene naprave #2 medtem ko (Wire.available ()) // pomožna oseba lahko pošlje manj kot zahteva {Version [0] = Wire.read (); // prejemamo bajt kot character} x_data = (int8_t) Različica [0] >> 2; Wire.beginTransmission (0x0A); // naslov merilnika pospeška // ponastavitev merilnika pospeška Wire.write (0x06); // Y podatki Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // zahtevam 6 bajtov od podrejene naprave #2 medtem ko (Wire.available ()) // pomožna oseba lahko pošlje manj kot zahteva {Version [1] = Wire.read (); // prejemamo bajt kot character} y_data = (int8_t) Različica [1] >> 2; Wire.beginTransmission (0x0A); // naslov merilnika pospeška // ponastavitev merilnika pospeška Wire.write (0x08); // Z podatki Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // zahtevam 6 bajtov od podrejene naprave #2 medtem ko (Wire.available ()) // pomožna oseba lahko pošlje manj kot zahteva {Version [2] = Wire.read (); // prejemamo bajt kot character} z_data = (int8_t) Različica [2] >> 2; x = (float) x_data/divi; y = (float) y_data/divi; z = (plavajoče) z_data/divi; Serial.print ("X ="); Serial.print (x); // natisnemo znak Serial.print (""); Serial.print ("Y ="); Serial.print (y); // natisnemo znak Serial.print (""); Serial.print ("Z ="); // natisnemo znak Serial.println (z); }

int circularize (int pos) {

če (poz> = NUMBER_OF_LEDS_ON_RING) vrne (poz - NUMBER_OF_LEDS_ON_RING); sicer, če (poz <0) vrne (poz + NUMBER_OF_LEDS_ON_RING); else return (pos); }

int razdalja;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; če (razdalja <0) razdalja += NUMBER_OF_LEDS_ON_RING; vrnitev (razdalja); }

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

// Pike napolnimo eno za drugo z barvno praznino 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

// Nekoliko drugače, zaradi česar je mavrica enakomerno razporejena po vsem

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

za (j = 0; j <256*5; j ++) {// 5 ciklov vseh barv na kolesu za (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); zamuda (čakanje); }}

// Plazeče luči v gledališkem stilu.

void theatreChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// naredi 10 ciklov lova za (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // vklopi vsak tretji pik} strip.show ();

zamuda (čakanje);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // izklopi vsak tretji slikovni pik}}}}

// Plazeče luči v gledališkem stilu z mavričnim učinkom

void theatreChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// cikel vseh 256 barv v kolesu za (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, kolo ((i+j) % 255)); // vklopi vsak tretji pik} strip.show ();

zamuda (čakanje);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // izklopi vsak tretji slikovni pik}}}}

// Vnesite vrednost od 0 do 255, da dobite barvno vrednost.

// Barve so prehod r - g - b - nazaj v r. uint32_t kolo (bajt WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {povratni trak. Color (255 - WheelPos * 3, 0, WheelPos * 3); } if (WheelPos <170) {WheelPos -= 85; povratni trak. Color (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; povratni trak. Barva (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

// Pike napolnimo eno za drugo z barvo

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

void pulseWhite (uint8_t čakanje) {

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 čakanje, int rainbowLoops, int whiteLoops) {

fload 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 ciklov vseh barv na kolesu

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

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

redVal = rdeča (wheelVal) * float (fadeVal/fadeMax);

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

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

}

// Prva zanka, zbledi!

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

// Zadnja zanka, zbledi!

sicer če (k == rainbowLoops - 1 && j> 255 - fadeMax) {fadeVal--; }

strip.show ();

zamuda (čakanje); }}

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

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

zamuda (500);

}

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

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

int head = whiteLength - 1;

int tail = 0;

int zanke = 3;

int loopNum = 0;

statični nepodpisani dolgi lastTime = 0;

medtem ko (res) {

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) {

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

if (loopNum == zanke) vrne;

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

// Nekoliko drugače, zaradi česar je mavrica enakomerno razporejena po vsem

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

za (j = 0; j <256 * 5; j ++) {// 5 ciklov vseh barv na kolesu za (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); zamuda (čakanje); }}

void rainbow1 (uint8_t wait) {

uint16_t i, j;

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

// Vnesite vrednost od 0 do 255, da dobite barvno vrednost.

// Barve so prehod r - g - b - nazaj v r. uint32_t Kolo1 (bajt WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {povratni trak. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) {WheelPos -= 85; povratni trak. Color (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; povratni trak. Barva (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t rdeča (uint32_t c) {

return (c >> 16); } uint8_t zelena (uint32_t c) {return (c >> 8); } uint8_t modra (uint32_t c) {return (c); }

8. korak: 3D oblikovanje

Najprej morate določiti velikost strojne komponente, da se prepričate o pravilnosti. Če so enake kot naše, lahko uporabite iste datoteke, ki vam jih posodimo.

Obe podpori sta bili zasnovani s 3D tiskalnikom, ki sta vključena tudi kot:

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

Končno bo luč podobna dvema zadnjima slikama.

9. korak: Namestitev vratu

Najprej bomo sedlu položili vrat. Luknje, ki jih morajo vijaki držati, niso tam, zato jih bomo morali narediti, označiti, kam naj gredo, in previdno, s svedrom narediti luknjo.

Enako velja za luknje, kjer so vijaki, ki držijo sam vrat na ohišju instrumenta. Izvesti jih ni treba, saj za to pritrditev ni vijakov, če pa to želimo, ne bi bilo težav.

POMEMBNO: pustite 5 mm prostora med začetkom jambora in začetkom umerjanja vilic, ker bo v to luknjo vstavljena matica.

Matico bomo zlepili z lepilom, v smeri, ki jo prikazuje slika.

Na koncu bomo predstavili 4 zatiče v luknjah na začetku jamborja, pri čemer vsak zatič držimo z 2 kratkima vijakoma, kot je prikazano na sliki.

10. korak: Namestitev ptiča

Most je pritrjen z lepljenjem in z dvema dolgima vijakoma v osrednjem položaju na telesu. Priporočljivo je, da s svinčnikom označite pravilen položaj v telesu. Vzeli bomo razdalje, ki so označene na sliki.

Lepilo bomo uporabili pri združevanju obeh komponent. Dva dela previdno pritrdimo s pomočjo vijaka za zategovanje, dokler se spoj ne posuši. Dve luknji za vijake bomo naredili s 1,5 mm svedrom za les. Most pritrdite z dvema dolgima vijakoma v ohišju. In na koncu smo na glave vijakov namestili zaščitne kape.

11. korak: Sestava telesa in vratu

Za sestavljanje obeh delov imamo luknje v glavi telesa, kjer se bo vrat prilegal z dvema izboklinama, ki jih ima. Lahko jih lepimo z lepilom ali s pištolo za topljenje. Za večjo fiksacijo lahko naredite luknje, ki so na koncu uglaševalne vilice, da se pridružijo telesu.

Korak: Postavite strune Ukulele

Na koncu moramo strune postaviti tako, da bo naš instrument končan.

Pred tem bomo v njihove izbokline, ki gredo skozi jambor, vstavili pritrdilne obroče zatičev. Za namestitev strun smo vzeli 4 strune, ki so priložene kompletu. Najprej morate razlikovati vsak niz, ker niso vsi enaki. Morate privezati en konec vsakega niza (dva debela z običajnim vozlom in dva tanka z dvojnim) in vstaviti strune v reže mostu.

Nato bomo nize postavili tako, da:

• Prvo mesto: niz G (drugi najdebelejši niz).

• Drugi položaj: niz C (debelejši niz).

• Tretji položaj: niz E (drugi tanjši niz).

• Četrti položaj: Vrvica (tanjša vrvica).

Vstavite strune v luknje priloženega čepa. Poskusite pritrditi vsako vrv tako, da dva ali trikrat zavrtite zatič. Napenjajte strune brez prevelike sile in preverite razdaljo med vrvicami in sedlom.

Če dvomite o tem, kako to narediti, bi lahko prebrali tisto vadnico, ki bi vam razložila, kako pravilno vstavite nize.

13. korak: Testiranje

Nazadnje moramo preveriti, ali je bila ukulela pravilno sestavljena tako, da je idealna razdalja na prvem pragu 0,1 mm, na dvanajstem pa približno 1,2 mm.

Potrebno je, da uglasite strune ukulele. Priporočam vam to aplikacijo: GuitarTuna

14. korak: Uživajte

Zdaj morate samo uživati v ukuleleju.

Če želite izvedeti več o nas, nas najdete na:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Splet: Innovart.cc