DIY inteligentné elektronické ukulele s Arduinom: 14 krokov (s obrázkami)

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 11:59

Krok za krokom vysvetlíme, ako si môžete navrhnúť vlastné ukulele a pridať niektoré efekty, ktoré ho urobia jedinečným, napríklad nakresliť niečo, čo chceme na povrch ukulele, alebo pridať nejaké svetelné efekty.

Aby ste to urobili, musíte si kúpiť sadu ukulele.

Vysvetlíme vám, ako zostaviť nástroj, a vyriešime rôzne problémy, ktoré sa môžu objaviť.

Krok 1: Materiály

Konštrukčné materiály:

DIY ukelele montážna sada (môže to byť iná súprava) tvorená:

1- Telo.

2-krk.

3-sedlové

4-lanová podpora

5-most

6-strunová matica.

7-Upevňovací krúžok pre hlavu stroja (x4).

8-Hlavy strojov (x4).

9-Upevňovacie skrutky pre hlavy strojov (x8).

10-Upevňovacie skrutky pre most stroja (x2).

11-Krycie kryty skrutiek na montáž na most (x2).

12 strún (x4).

Elektronické materiály:

• NANO Arduino.
• Koleso LED WS2812.
• Akcelerometer BMA220 (voliteľný).
• Konektor batérie.
• Batéria 9V.
• Prepnúť.

Iní

• Lak na drevo.
• Suchý zips.
• Spájkovací cín.
• Ochranný plast na lakovanie.
• Taviteľný silikón.

Náradie:

• Laserové gravírovanie.
• Brúsny papier
• Hviezdicový skrutkovač.
• Štetec
• Tavná pištoľ.
• Cínová spájkovačka.

Krok 2: Prispôsobte si ukulele

Na kostýmovanie nášho ukulele by sme mohli urobiť gravírovanie kresby laserovou rezačkou na telo. V prípade, že tento nástroj nemáme, mohli by sme ho namaľovať.

Obrázok, ktorý sme vybrali, je prvý, ktorý sa objaví.

V prvom rade musíme navrhnúť šablónu kresby, aby sme mohli gravírovať.

Na tento účel použijeme softvér s názvom „Inkscape“, ktorý by sme mohli získať z tohto odkazu:

Aby sme to mohli použiť, musíme upraviť obrázok, ktorý chceme použiť, ako ho zobrazujeme na druhom obrázku. Môžete sa pozrieť na to, že sme pôvodný obrázok otočili, aby sme mohli upraviť kruh ruky pomocou kruhu nástroja. Ako sme už povedali, môžete vložiť ľubovoľný obrázok.

Krok 3: Vektorizujte obrázok pomocou Inkscape

Uvidíme, ako vytvoriť vektorový súbor z pixmapy (jpg, png, akýkoľvek rastrový formát, ktorý môže Inkscape otvoriť).

Inkscape Inkscape je editor vektorovej grafiky s otvoreným zdrojovým kódom a ako naznačuje názov, toto je nástroj, ktorý použijem na vektorizáciu log. Krok vektorizácie Kroky sú bežné pre každú vektorizáciu, ktorú by sme mohli chcieť urobiť.

1. Otvorte obrázok v Inkscape
2. Otvorte cestu nástroja Trace Bitmap-> Trace Bitmap
3. Hrajte o možnostiach trasovacej bitmapy
4. Spustite trasovanie
5. Vyčistite výsledky (ak je to potrebné)

Všimnite si časť „hrať sa“. Nie som odborník na sledovanie, takže s týmto nástrojom zaobchádzam ako s čiernou skrinkou s gombíkmi a svetlami, ktorá sa krúti a mení, kým nedosiahnem najlepší výsledok.

Krok 4: Gravírovanie loga

Za týmto účelom je dôležité mať siluetu povrchu, na ktorom bude rytina výkresu vyrobená.

Na gravírovanie použijeme softvér „T2Laser“. Tento softvér by sme mohli získať z:

Akonáhle otvoríme softvér, musíme načítať obrázok, ktorý sme vytvorili v poslednom kroku. Potom stlačte tlačidlo „Ovládací laser“a zobrazia sa ovládacie prvky cnc. Dva obrázky ukazujú postup a výsledok gravírovania pomocou našej laserovej rezačky.

Krok 5: Brúsenie a lakovanie

Aby naše ukulele zostalo svetlé a s vrstvou bez drsnosti, môžeme opatrne opatrne obrúsiť dve časti tvoriace náš nástroj, pretože môžeme poškodiť kresbu, ktorá bola vytvorená (ak ste sa rozhodli pre ukulele namaľovať, museli by ste najskôr ho obrúste) Potom nalakujeme naše dve časti tak, aby získali tmavšiu farbu a drevo bolo odolnejšie. Môžeme použiť bežný lak na drevo, nemusí byť špeciálny.

Akonáhle máme lak, zmiešame ho s trochou rozpúšťadla, aby sa trochu rozpustil. Potom zmes nanesieme štetcom na krk a telo nástroja a necháme zaschnúť.

Ak vidíme, že výrobok potrebuje druhú vrstvu, môžeme obe časti trochu obrúsiť a naniesť znova vrstvu zriedeného laku.

** BEZPEČNOSTNÉ OPATRENIA: Lak je chemický výrobok, preto je potrebné tento proces vykonať na vetranom mieste, nosiť masku, aby ste predišli vdýchnutiu pachov a ochranným okuliarom.

Materiály, ktoré potrebujeme, aby sme mohli správne pracovať, sú tie, ktoré sa objavujú na fotografiách. Hlavne budeme pracovať so štetcom, plechovkou na lak (v našom prípade červenou farbou), trochou rozpúšťadla a vizuálnou ochranou. A predovšetkým prácu v dobre vetraných priestoroch.

Krok 6: Hardvér

Náš plak s Arduinom, akcelerometrom a kolesom s LED diódami bude predstavený v malej zátvorke, aby sa zabránilo pohybu všetkých komponentov v prístroji.

Pridali sme aj držiak batérie a vypínač, aby bol pohodlnejší a batériu nevyužívame, keď nástroj nepoužívame. Túto podperu pripevníme kúskom suchého zipsu (fungovalo by to aj so silikónom a tavnou pištoľou) na vnútornú stranu tela ukulele. Na druhej strane je koliesko LED menšie ako otvor, takže by spadlo. Podpera bola navrhnutá tak, aby dobre držala a mohla vykonávať svoju funkciu.

Krok 7: Softvér

Aby bola ukulele špeciálna ozdoba, mohli by sme pridať svetelné efekty vďaka koliesku LED. Budeme používať WS2812, ale môžete použiť aj iné podľa pokynov v technickom liste. Použijeme aj akcelerometer (BMA220), ktorý nám umožní ovplyvniť gravitáciu.

V skutočnosti budeme mať 4 hry svetla, zahrnuté v počítačovej knižnici s názvom „Adafruit“spoločnosti Arduino. Na to musíme urobiť správnu súčinnosť medzi tromi komponentmi: Arduino NANO, WS2812 a BMA220, ako sa zobrazuje na prvom obrázku.

Červené vodiče slúžia na napájanie, GND čierne a ostatné sú nevyhnutné pripojenia pre správnu funkciu. Kód, ktorý sme použili pre svetelnú súpravu, je pripojený k súboru s názvom „play_of_light_v0.ino“. Uistite sa, že ste zahrnuli knižnice potrebné na správnu činnosť programu. Batéria, ktorú do obvodu pridáme externe, musí mať minimálne napätie 9 V a musíme zabezpečiť, aby bola schopná dodávať minimálny prúd potrebný na napájanie celého obvodu.

// Premenné Contador e interrupciónint counter; // Premenné Prebieha gravidad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

bajtová verzia [3];

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

// Premenné Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parameter 1 = počet pixelov v páse // Parameter 2 = Počet pinov Arduino (väčšina z nich je platných) // Parameter 3 = vlajky typu pixelov, podľa potreby sčítajte: // NEO_KHZ800 800 KHz bitstream (väčšina produktov NeoPixel s LED diódami WS2812) // NEO_KHZ400 400 KHz (klasický „v1“(nie v2) pixely FLORA, ovládače WS2811) // Pixely NEO_GRB sú zapojené pre bitový tok GRB (väčšina produktov NeoPixel)/ / Pixely NEO_RGB sú zapojené pre bitový tok RGB (v1 pixelov FLORA, nie v2) // NEO_RGBW Pixely sú zapojené pre bitový tok RGBW (produkty NeoPixel RGBW) Adafruit_NeoPixel pásik = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // DÔLEŽITÉ: Na zníženie rizika vyhorenia NeoPixel pridajte kondenzátor 1 000 uF na // napájacie vodiče pixelov, na vstup dát prvého pixelu pridajte odpor 300 - 500 Ohm // a minimalizujte vzdialenosť medzi Arduinom a prvým pixelom. Vyhnite sa pripájaniu // na živom okruhu … ak musíte, najskôr pripojte GND.

// Premenné Rueda de colores

// Jednoduchý náčrt NeoPixel Ring (c) 2013 Shae Erisson // vydaný pod licenciou GPLv3, aby zodpovedal zvyšku knižnice AdaFruit NeoPixel

#zahrnúť

#ifdef _AVR_ #include #endif

// Ktorý pin na Arduine je pripojený k NeoPixels?

// Na cetke alebo Gemme navrhujeme zmeniť to na 1 #definovať PIN 9

// Koľko NeoPixelov je pripojených k Arduinu?

#define NUMPIXELS 16

// Keď nastavujeme knižnicu NeoPixel, povieme jej, koľko pixelov a ktorý pin použiť na odosielanie signálov.

// Upozorňujeme, že pre staršie pásy NeoPixel bude možno potrebné zmeniť tretí parameter-ďalšie informácie o možných hodnotách nájdete v príklade strandtest //. Pixely Adafruit_NeoPixel = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // oneskorenie 50ms

// Premenné premenných farieb

#include #ifdef _AVR_ #include #endif

#definujte PIN 9

#define NUM_LEDS 16

#define BRIGHTNESS 200

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

/NASTAVENIE METODO

void setup () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // adresa akcelerometra // nastavenia rozsahu Wire.write (0x22); // zaregistrovanie adresy Wire.write (rozsah); // je možné nastaviť na "0x00" "0x01" "0x02" "0x03", pozrite si Datashhet na wiki // dolnopriepustný filter Wire.write (0x20); // registračná adresa Wire.write (0x05); // je možné nastaviť na „0x05“„0x04“…… „0x01“„0x00“, pozrite si Datashhet na wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Toto je pre Trinket 5V 16MHz, tieto tri riadky môžete odstrániť, ak nepoužívate Trinket #ak je definované (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Koniec cencúľa špeciálny kód strip.begin (); strip.show (); // Inicializácia všetkých pixelov na „vypnuté“

// Código Rueda de colores

// Toto je pre Trinket 5V 16MHz, tieto tri riadky môžete odstrániť, ak nepoužívate Trinket #ak je definované (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Koniec špeciálneho kódu drobností

pixely.begin (); // Tým sa inicializuje knižnica NeoPixel.

// Codigo Interrupcion

počítadlo = 1;

// Codigo Colores rôzne

// Toto je pre Trinket 5V 16MHz, tieto tri riadky môžete odstrániť, ak nepoužívate Trinket #ak je definované (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Koniec cencúľa špeciálny kód strip.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Inicializácia všetkých pixelov na 'vypnuté'}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (počítadlo == 1) {pre (int i = 0; i 0,0) {if (nx 0,0) uhol+= 180; inak uhol += 360; } // end else if (uhol == 360,0) uhol = 0,0; led = cirkularizácia (uhol / (360 / NUMBER_OF_LEDS_ON_RING)); // urobte pohyb LED hladkým if (previousLed == led) {// nič iné robiť} else if (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); else led = obiehať (previousLed - 1); ledQueue.push (led); makeLightShow (); previousLed = led; oneskorenie (25); } počítadlo = 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 ++) {// Some example procedures showing ako sa zobrazuje v pixeloch: colorWipe1 (strip. Color (255, 0, 0), 50); // Červená farbaWipe1 (strip. Color (0, 255, 0), 50); // Zelená farbaWipe1 (strip. Color (0, 0, 255), 50); // Blue colorWipe1 (strip. Color (0, 0, 0, 255), 50); // Biele RGBW // Odoslanie prenasledovania pixelov v kine v… TheaterChase (strip. Color (127, 127, 127), 50); // Biele divadloChase (strip. Color (127, 0, 0), 50); // Červené divadloChase (strip. Color (0, 0, 127), 50); // Modrá

dúha (5);

rainbowCycle (5); divadloChaseRainbow (5); } počítadlo = 3; } // End if counter == 2 // Caso 3: Luces Aleatorias else if (counter == 3) {for (int k = 0; k <50; k ++) {// Pre sadu NeoPixels the first NeoPixel is 0, druhá je 1, až do počtu pixelov mínus jeden. int a = náhodný (255); int b = náhodný (255); int c = náhodný (255); pre (int i = 0; i

// pixelov. Farba má hodnoty RGB od 0, 0, 0 do 255, 255, 255

pixely.setPixelColor (i, pixely. Color (a, b, c)); // Stredne jasne zelená farba.

pixely.show (); // Toto odošle aktualizovanú farbu pixelov na hardvér.

delay (delayval); // Oneskorenie na určité časové obdobie (v milisekundách).

} a = náhodný (255); b = náhodný (255); c = náhodný (255); pre (int i = NUMPIXELS; i> 0; i-) {

// pixelov. Farba má hodnoty RGB od 0, 0, 0 do 255, 255, 255

pixely.setPixelColor (i, pixely. Color (a, b, c)); // Stredne jasne zelená farba.

pixely.show (); // Toto odošle aktualizovanú farbu pixelov na hardvér.

delay (delayval); // Oneskorenie na určité časové obdobie (v milisekundách).

}} počítadlo = 4; } else if (counter == 4) {for (int g = 0; g <= 6; g ++) {// Niekoľko príkladov postupov zobrazujúcich pixely: colorWipe (strip. Color (255, 0, 0), 50); // Red colorWipe (strip. Color (0, 255, 0), 50); // Zelená farbaWipe (strip. Color (0, 0, 255), 50); // Blue colorWipe (strip. Color (0, 0, 0, 255), 50); // Biela bielaOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // zdržanie (2000); rainbowFade2White (3, 3, 1);

}

počítadlo = 1; }} //////////////////////////////////////////////////////// /////////////////////////////////////// /////////////////// ////////////////////////////////////////////////////////// ///////////////////

/Metodos del Ejemplo de la gravedad

neplatné AccelerometerInit () {Wire.beginTransmission (0x0A); // adresa akcelerometra // reset akcelerometra Wire.write (0x04); // X dáta Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // požiadavka 6 bajtov zo zariadenia slave #2 while (Wire.available ()) // slave can send less than requested {Version [0] = Wire.read (); // prijat bajt ako znak} x_data = (int8_t) Verzia [0] >> 2; Wire.beginTransmission (0x0A); // adresa akcelerometra // reset akcelerometra Wire.write (0x06); // Y data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // požiadavka 6 bajtov zo zariadenia slave č. 2 while (Wire.available ()) // slave can send less than requested {Version [1] = Wire.read (); // prijme bajt ako znak} y_data = (int8_t) Verzia [1] >> 2; Wire.beginTransmission (0x0A); // adresa akcelerometra // reset akcelerometra Wire.write (0x08); // Z data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // požiadavka 6 bajtov zo zariadenia slave #2 while (Wire.available ()) // slave can send less than requested {Version [2] = Wire.read (); // prijat bajt ako characte} z_data = (int8_t) Verzia [2] >> 2; x = (float) x_data/divi; y = (float) y_data/divi; z = (float) z_data/divi; Serial.print ("X ="); Serial.print (x); // vytlač znak Serial.print (""); Serial.print ("Y ="); Serial.print (y); // vytlač znak Serial.print (""); Serial.print ("Z ="); // vytlač znak Serial.println (z); }

int obehnúť (int pos) {

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

vnútorná vzdialenosť;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; ak (vzdialenosť <0) vzdialenosť += NUMBER_OF_LEDS_ON_RING; návrat (vzdialenosť); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int jasStep = 255/NUMBER_OF_LEDS_TO_SHINE;

neplatné makeLightShow () {

pre (int j = 0; j <NUMBER_OF_LEDS_ON_RING; j ++) neoring.setPixelColor (j, 0, 0, 0); currentQueueSize = ledQueue.count (); pre (int k = 0; k <currentQueueSize; k ++) {ledPosition = ledQueue.pop (); neoring.setPixelColor (ledPosition, 0, (BrightStep * k), 0); if ((k == 0 && currentQueueSize 0) ledQueue.push (ledPosition);} neoring.show ();}

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

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

/Metodos del juego de luces del arcoiris

// Vyplňte bodky za sebou farebnou prázdnotou colorWipe (uint32_t c, uint8_t počkajte) {for (uint16_t i = 0; i

prázdna dúha (uint8_t čakať) {

uint16_t i, j;

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

// Trochu odlišný, vďaka čomu je dúha rovnomerne rozložená v celom objeme

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

for (j = 0; j <256*5; j ++) {// 5 cyklov všetkých farieb na koliesku pre (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); oneskorenie (čakanie); }}

// Plazivé svetlá v divadelnom štýle.

void TheaterChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// do 10 cyklov chasing for (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // zapnite každý tretí pixel}} strip.show ();

oneskorenie (čakanie);

pre (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // vypnite každý tretí pixel}}}}

// Plazivé svetlá v divadelnom štýle s dúhovým efektom

void TheaterChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// cyklus všetkých 256 farieb v koliesku pre (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)); // zapnite každý tretí pixel}} strip.show ();

oneskorenie (čakanie);

pre (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // vypnite každý tretí pixel}}}}

// Na získanie hodnoty farby zadajte hodnotu 0 až 255.

// Farby sú prechodom r - g - b - späť na r. uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {spätný pás. Color (255 - WheelPos * 3, 0, WheelPos * 3); } if (WheelPos <170) {WheelPos -= 85; spätný pás. Farba (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; spätný pás. Farba (WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/Metodos Rueda de colores

// int elegirColor = random (0x000000, 0xffffff); // Výber eeage aleatoriamente entre toda la gama de Colores zahrnujúcich 0x000000 y 0xFFFFFF

// CylonEyeColor = HtmlColor (elegirColor); // int elegirColor = random (1, 7); // Podeos elegir aleatoriamente entre los 7 colores que seno 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

// Vyplňte bodky jednu za druhou farbou

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

void pulseWhite (uint8_t wait) {

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

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

pre (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;

pre (int k = 0; k <rainbowLoops; k ++) {for (int j = 0; j <256; j ++) {// 5 cyklov všetkých farieb na kolese

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

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

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

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

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

}

// Prvá slučka, fade in!

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

// Posledná slučka, zmizne!

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

strip.show ();

oneskorenie (čakanie); }}

oneskorenie (500);

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

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

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

oneskorenie (2000);

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

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

oneskorenie (500);

}

void whiteOverRainbow (uint8_t čakať, uint8_t whiteSpeed, uint8_t whiteLength) {

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

int hlava = bielaDĺžka - 1;

int chvost = 0;

int slučky = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

while (true) {

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

if (millis () - lastTime> whiteSpeed) {

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

if (loopNum == slučky) návrat;

hlava%= strip.numPixels (); chvost%= strip.numPixels (); strip.show (); oneskorenie (čakanie); }}} neplatné fullWhite () {for (uint16_t i = 0; i

// Trochu odlišný, vďaka čomu je dúha rovnomerne rozložená v celom objeme

neplatné rainbowCycle1 (uint8_t čakať) {uint16_t i, j;

for (j = 0; j <256 * 5; j ++) {// 5 cyklov všetkých farieb na koliesku pre (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); oneskorenie (čakanie); }}

neplatné rainbow1 (uint8_t čakať) {

uint16_t i, j;

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

// Na získanie hodnoty farby zadajte hodnotu 0 až 255.

// Farby sú prechodom r - g - b - späť na r. uint32_t Wheel1 (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {spätný pás. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) {WheelPos -= 85; spätný pás. Farba (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; spätný pás. Farba (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t červená (uint32_t c) {

návrat (c >> 16); } uint8_t zelená (uint32_t c) {return (c >> 8); } uint8_t modrá (uint32_t c) {return (c); }

Krok 8: 3D návrh

Najprv musíte hardvérové súčasti dimenzovať, aby ste sa presvedčili o správnosti. Ak sú rovnaké ako naše, môžete použiť rovnaké súbory, ktoré vám požičiame.

Obe podpery boli navrhnuté s 3D tlačiarňou, ktoré sú tiež zahrnuté ako:

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

Nakoniec bude svetlo ako na posledných dvoch obrázkoch.

Krok 9: Upevnenie krku

Najprv umiestnime sedlo na krk. Otvory, ktoré skrutky potrebujú na to, aby tam boli, tam nie sú, takže ich budeme musieť urobiť, pričom označíme, kam by mali ísť, a opatrne, pomocou šneku, urobíme otvor.

To isté platí pre otvory, kde sú skrutky, ktoré držia samotný krk k telu nástroja. Nie je potrebné ich vykonávať, pretože na toto upevnenie nie sú žiadne skrutky, ale ak by sme to chceli urobiť, nebol by žiadny problém.

DÔLEŽITÉ: medzi štartom stožiara a začiatkom ladiacej vidlice nechajte 5 mm priestor, pretože v tomto otvore bude umiestnená matica.

Maticu prilepíme lepidlom v smere uvedenom na obrázku.

Nakoniec predstavíme 4 čapy v otvoroch, ktoré sú na začiatku stožiara, pričom každý čap drží pomocou 2 krátkych skrutiek, ako je znázornené na obrázku.

Krok 10: Montáž Birdge

Most je upevnený lepením a dvoma dlhými skrutkami v centrálnej polohe na tele. Je vhodné vyznačiť si ceruzkou správnu polohu v tele. Zoberieme vzdialenosti, ktoré sú vyznačené na obrázku.

Na spojenie dvoch zložiek nanesieme lepidlo. Dve časti opatrne zafixujeme pomocou uťahovacej skrutky, kým spoj nevyschne. Dva otvory pre skrutky urobíme 1,5 mm vrtákom do dreva. Most pripevnite dvoma dlhými skrutkami v tele. A nakoniec sme nasadili ochranné kryty na hlavy skrutiek.

Krok 11: Zostava tela a krku

Na zostavenie týchto dvoch častí máme otvory v hlave tela, kde sa krk zmestí s dvoma výstupkami, ktoré má. Môžeme ich zlepiť lepidlom alebo tavnou pištoľou. Aby ste mali väčšiu fixáciu, môžete otvory na konci ladiacej vidlice spojiť s telom.

Krok 12: Vložte struny Ukulele

Nakoniec musíme struny umiestniť tak, aby bol náš nástroj hotový.

Predtým vložíme upevňovacie krúžky čapov do výčnelkov týchto, ktoré prechádzajú stožiarom. Na umiestnenie strún sme vzali 4 struny, ktoré boli súčasťou súpravy. Najprv musíte rozlíšiť každý reťazec, pretože nie sú všetky rovnaké. Musíte uviazať jeden koniec každého povrázku (dva hrubé s normálnym uzlom a dva tenké s dvojitým) a struny zasunúť do štrbín mosta.

Potom umiestnime reťazce takým spôsobom, že:

• Prvá pozícia: G reťazec (druhý najhrubší reťazec).

• Druhá pozícia: reťazec C (hrubší reťazec).

• Tretia pozícia: reťazec E (druhý tenší reťazec).

• Štvrtá pozícia: Šnúrka (tenšia šnúrka).

Navlečte struny do otvorov dodanej zástrčky. Skúste opraviť každé lano tak, že na čape urobíte dve alebo tri otáčky. Napnite struny bez použitia prílišnej sily a skontrolujte vzdialenosť medzi strunami a sedlom.

Ak máte nejaké pochybnosti o tom, ako to urobiť, môžete použiť tento návod, ktorý vám vysvetlí, ako správne struny umiestniť.

Krok 13: Testovanie

Nakoniec musíme zistiť, či je ukulele správne zostavené tak, že ideálna vzdialenosť na prvom pražci je 0,1 mm a na dvanástom je približne 1,2 mm.

Je potrebné, aby ste vyladili struny ukulele. Odporúčam vám túto aplikáciu: GuitarTuna

Krok 14: Užite si to

Teraz si musíte užiť len svoje ukulele.

Ak chcete o nás vedieť viac, nájdete nás na:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc