DIY chytré elektronické ukulele s Arduinem: 14 kroků (s obrázky)

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:22

Krok za krokem vysvětlíme, jak si můžete navrhnout vlastní ukulele a přidat některé efekty, díky nimž bude jedinečný, jako nakreslit něco, co chceme na povrch ukulele, nebo přidat nějaké světelné efekty.

K tomu je nutné zakoupit sadu ukulele.

Vysvětlíme, jak sestavit nástroj, a vyřešit různé problémy, které by se mohly objevit.

Krok 1: Materiály

Konstrukční materiály:

DIY ukelele montážní sada (může to být jiná sada) tvořená:

1- Tělo.

2-krk.

3-sedlo

Podpora 4 lan

5-most

6-strunná matice.

7-Upevňovací kroužek pro hlavu stroje (x4).

8 hlav strojů (x4).

9-Upevňovací šrouby pro hlavy strojů (x8).

10-Upevňovací šrouby pro most stroje (x2).

11-Krytky pro šrouby pro montáž na můstek (x2).

12 strun (x4).

Elektronické materiály:

• NANO Arduino.
• Kolo LED WS2812.
• Akcelerometr BMA220 (volitelně).
• Konektor baterie.
• Baterie 9V.
• Přepínač.

Ostatní

• Lak na dřevo.
• Suchý zip.
• Pájecí cín.
• Ochranný plast pro lakování.
• Tavný silikon.

Nástroje:

• Laserové gravírování.
• Smirkový papír
• Hvězdný šroubovák.
• Štětec.
• Tavná pistole.
• Cínová páječka.

Krok 2: Přizpůsobte si Ukulele

Abychom ukulele kostýmovali, mohli jsme na tělo vyrobit rytinu kresby laserovou řezačkou. V případě, že tento nástroj nemáme, můžeme jej namalovat.

Obrázek, který jsme vybrali, je první, který se objeví.

Nejprve musíme navrhnout výkresovou šablonu, abychom vytvořili rytinu.

K tomu použijeme software s názvem „Inkscape“, který bychom mohli získat z tohoto odkazu:

Abychom to mohli použít, musíme upravit obrázek, který chceme použít, jako na druhém obrázku. Můžete vypadat, že jsme počáteční obrázek otočili, abychom mohli upravit kružnici ruky kruhem nástroje. Jak jsme již řekli dříve, můžete vložit jakýkoli obrázek.

Krok 3: Vektorizujte obrázek pomocí Inkscape

Uvidíme, jak vytvořit vektorový soubor z pixmapy (jpg, png, jakýkoli rastrový formát, který může Inkscape otevřít).

Inkscape Inkscape je open-source vektorový grafický editor, a jak naznačuje název, toto je nástroj, který použiji k vektorizaci log. Vektorové kroky Kroky jsou společné pro jakoukoli vektorizaci, kterou bychom chtěli udělat.

1. Otevřete obrázek v Inkscape
2. Otevřete cestu nástroje Trace Bitmap-> Trace Bitmap
3. Pohrajte si s možnostmi trasování bitmapy
4. Spusťte trasování
5. Vyčistěte výsledky (je -li to nutné)

Všimněte si části „hraní kolem“. Nejsem odborník na trasování, takže s tímto nástrojem zacházím jako s černou skříňkou s knoflíky a světly, kroutí se a mění, dokud nedosáhnu nejlepšího výsledku

Krok 4: Gravírování loga

K tomu je důležité mít siluetu povrchu, na kterém bude rytina výkresu vyrobena.

K gravírování použijeme software „T2Laser“. Tento software bychom mohli získat z:

Jakmile software otevřeme, musíme načíst obrázek, který jsme vytvořili v posledním kroku. Poté stiskněte tlačítko „ovládací laser“a zobrazí se ovládací prvky cnc. Dva obrázky ukazují postup a výsledek gravírování naší laserovou řezačkou.

Krok 5: Broušení a lakování

Aby naše ukulele zůstalo jasné a s vrstvou bez drsnosti, můžeme opatrně obrousit dvě části, které tvoří náš nástroj, protože můžeme poškodit kresbu, která byla vytvořena (pokud jste se rozhodli namalovat ukulele, museli byste nejprve jej pískujte). Poté nalakujeme naše dvě části tak, aby získaly tmavší barvu a dřevo představovalo větší odolnost. Můžeme použít normální lak na dřevo, nemusí být speciální.

Jakmile máme lak, smícháme ho s trochou rozpouštědla, aby se trochu rozpustil. Směs dále naneseme štětcem na krk a tělo nástroje a necháme zaschnout.

Pokud vidíme, že výrobek potřebuje druhý nátěr, můžeme obě části trochu obrousit a znovu nanést vrstvu zředěného laku.

** BEZPEČNOSTNÍ OPATŘENÍ: Lak je chemický výrobek, proto je nutné tento proces provést na větraném místě, nosit masku, aby se zabránilo vdechování pachů a ochranných brýlí.

Materiály, které potřebujeme, abychom mohli správně pracovat, jsou ty, které se objevují na fotografiích. Hlavně budeme pracovat s kartáčem, plechovkou od laku (v našem případě červené barvy), trochou rozpouštědla a vizuální ochranou. A především pracovat v dobře větraných prostorách.

Krok 6: Hardware

Náš plak s Arduinem, akcelerometr a kolo s LED diodami bude představen v malém držáku, aby se zabránilo pohybu všech komponent v nástroji.

Přidali jsme také držák baterie a vypínač, aby byl pohodlnější a nevyužívali jsme baterii, když nástroj nepoužíváme. Tuto oporu připevníme kouskem suchého zipu (fungovalo by to i se silikonem a tavnou pistolí) na vnitřní stranu těla ukulele. Na druhou stranu je LED kolečko menší než otvor, takže by spadlo. Podpora byla navržena tak, aby dobře držela a mohla plnit svoji funkci.

Krok 7: Software

Abychom ukulele dodali zvláštní ozdobu, mohli jsme přidat světelné efekty díky kolečku LED diod. Použijeme WS2812, ale můžete použít jakýkoli jiný podle pokynů v datovém listu. Použijeme také akcelerometr (BMA220), který nám umožní efekt gravitace.

Ve skutečnosti budeme mít 4 hry světla, zahrnuté v počítačové knihovně s názvem „Adafruit“společnosti Arduino. Abychom to mohli udělat, musíme udělat správnou kombinaci mezi třemi komponentami: Arduino NANO, WS2812 a BMA220, like se objeví na prvním obrázku.

Červené vodiče jsou pro napájení, GND černé a zbytek jsou nezbytná připojení pro správnou funkci. Kód, který jsme použili pro světelnou sadu, je připojen v souboru s názvem „play_of_light_v0.ino“. Ujistěte se, že jste zahrnuli knihovny potřebné pro správnou funkci programu. Baterie, kterou přidáme externě do obvodu, musí mít minimální napětí 9V a musíme zajistit, aby byla schopna poskytnout minimální proud potřebný k napájení celého obvodu.

// Proměnné Contador e interrupciónint counter; // Proměnné Ejemplo gravedad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

bajtová verze [3];

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

// Proměnné Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parametr 1 = počet pixelů v pásu // Parametr 2 = počet pinů Arduino (většina z nich je platná) // Parametr 3 = příznaky typu pixelu, sčítejte podle potřeby: // NEO_KHZ800 800 KHz bitstream (většina produktů NeoPixel s LED WS2812) // NEO_KHZ400 400 KHz (klasický 'v1' (ne v2) pixely FLORA, ovladače WS2811) // NEO_GRB Pixely jsou zapojeny pro bitový tok GRB (většina produktů NeoPixel)/ / Pixely NEO_RGB jsou zapojeny pro bitový tok RGB (v1 pixely FLORA, nikoli v2) // NEO_RGBW Pixely jsou zapojeny pro bitový tok RGBW (produkty NeoPixel RGBW) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // DŮLEŽITÉ: Chcete -li snížit riziko vyhoření NeoPixel, přidejte kondenzátor 1000 uF přes // napájecí vodiče pixelů, přidejte odpor 300 - 500 Ohm na datový vstup prvního pixelu // a minimalizujte vzdálenost mezi Arduinem a prvním pixelem. Vyhněte se připojení // na živém okruhu … pokud musíte, nejprve připojte GND.

// Proměnné Rueda de colores

// Jednoduchý náčrt NeoPixel Ring (c) 2013 Shae Erisson // vydáno pod licencí GPLv3, aby odpovídalo zbytku knihovny AdaFruit NeoPixel

#zahrnout

#ifdef _AVR_ #include #endif

// Který pin na Arduinu je připojen k NeoPixelům?

// Na cetce nebo Gemmě doporučujeme změnit to na 1 #define PIN 9

// Kolik NeoPixelů je připojeno k Arduinu?

#define NUMPIXELS 16

// Když nastavujeme knihovnu NeoPixel, řekneme jí, kolik pixelů a jaký pin použít k odesílání signálů.

// U starších proužků NeoPixel bude možná nutné změnit třetí parametr-další informace o možných hodnotách najdete v příkladu strandtest //. Pixely Adafruit_NeoPixel = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // zpoždění 50ms

// Proměnné barvy aleatorios

#include #ifdef _AVR_ #include #endif

#definovat PIN 9

#define NUM_LEDS 16

#define BRIGHTNESS 200

// proužek 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 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/NASTAVENÍ METODO

neplatné nastavení () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // adresa akcelerometru // nastavení rozsahu Wire.write (0x22); // registrace adresy Wire.write (range); // lze nastavit na "0x00" "0x01" "0x02" "0x03", viz Datashhet na wiki // dolní propust Wire.write (0x20); // adresa registrace Wire.write (0x05); // lze nastavit na „0x05“„0x04“…… „0x01“„0x00“, viz Datashhet na wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Toto je pro Trinket 5V 16MHz, tyto tři řádky můžete odstranit, pokud nepoužíváte Trinket #if definováno (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Konec cetky speciální kód strip.begin (); strip.show (); // Inicializace všech pixelů na 'vypnuto'

// Código Rueda de colores

// Toto je pro Trinket 5V 16MHz, můžete tyto tři řádky odstranit, pokud nepoužíváte Trinket #if definováno (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Konec speciálního kódu cetky

pixely.begin (); // Tím se inicializuje knihovna NeoPixel.

// Codigo Interrupcion

čítač = 1;

// Různé barvy Codigo

// Toto je pro Trinket 5V 16MHz, můžete tyto tři řádky odstranit, pokud nepoužíváte Trinket #if definováno (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Konec cetky speciální kód strip.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Inicializujte všechny pixely na 'vypnuto'}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (čítač == 1) {pro (int i = 0; i 0,0) {if (nx 0,0) úhel+= 180; jinak úhel += 360; } // end else if (úhel == 360,0) úhel = 0,0; led = cirkulace (úhel / (360 / NUMBER_OF_LEDS_ON_RING)); // aby byl pohyb LED plynulý, pokud (previousLed == led) {// nic nedělat} else if (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); else led = cirkulace (předchozíLed - 1); ledQueue.push (led); makeLightShow (); previousLed = led; zpoždění (25); } čítač = 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 jak zobrazit na pixely: colorWipe1 (strip. Color (255, 0, 0), 50); // Red colorWipe1 (strip. Color (0, 255, 0), 50); // Zelená colorWipe1 (strip. Color (0, 0, 255), 50); // Blue colorWipe1 (strip. Color (0, 0, 0, 255), 50); // White RGBW // Odeslání pixelové honičky v kině… TheaterChase (strip. Color (127, 127, 127), 50); // White TheaterChase (strip. Color (127, 0, 0), 50); // Red TheaterChase (strip. Color (0, 0, 127), 50); // Modrá

duha (5);

rainbowCycle (5); divadloChaseRainbow (5); } čítač = 3; } // End if counter == 2 // Caso 3: Luces Aleatorias else if (counter == 3) {for (int k = 0; k <50; k ++) {// Pro sadu NeoPixels první NeoPixel je 0, sekunda je 1, až do počtu pixelů minus jeden. int a = random (255); int b = náhodný (255); int c = náhodný (255); pro (int i = 0; i

// pixely. Color přebírá hodnoty RGB, od 0, 0, 0 do 255, 255, 255

pixely.setPixelColor (i, pixely. Color (a, b, c)); // Středně jasně zelená barva.

pixely.show (); // Tím se na hardware odešle aktualizovaná barva pixelu.

delay (delayval); // Zpoždění po určitou dobu (v milisekundách).

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

// pixely. Color přebírá hodnoty RGB, od 0, 0, 0 do 255, 255, 255

pixely.setPixelColor (i, pixely. Color (a, b, c)); // Středně jasně zelená barva.

pixely.show (); // Tím se na hardware odešle aktualizovaná barva pixelu.

delay (delayval); // Zpoždění po určitou dobu (v milisekundách).

}} počítadlo = 4; } else if (counter == 4) {for (int g = 0; g <= 6; g ++) {// Některé příklady postupů, které ukazují, jak zobrazit pixely: colorWipe (strip. Color (255, 0, 0), 50); // Red colorWipe (strip. Color (0, 255, 0), 50); // Green colorWipe (strip. Color (0, 0, 255), 50); // Blue colorWipe (strip. Color (0, 0, 0, 255), 50); // Bílá bíláOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // zpoždění (2000); rainbowFade2White (3, 3, 1);

}

čítač = 1; }} //////////////////////////////////////////////////////// /////////////////////////////////////// /////////////////// ////////////////////////////////////////////////////////// ///////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // adresa akcelerometru // reset akcelerometru Wire.write (0x04); // X data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // požadavek 6 bytů od podřízeného zařízení #2 while (Wire.available ()) // slave může odeslat méně, než bylo požadováno {Verze [0] = Wire.read (); // obdrží bajt jako znaky} x_data = (int8_t) Verze [0] >> 2; Wire.beginTransmission (0x0A); // adresa akcelerometru // resetujte akcelerometr Wire.write (0x06); // Y data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // požadavek 6 bytů od podřízeného zařízení č. 2 while (Wire.available ()) // slave může odeslat méně než požadováno {Verze [1] = Wire.read (); // obdrží bajt jako znaky} y_data = (int8_t) Verze [1] >> 2; Wire.beginTransmission (0x0A); // adresa akcelerometru // reset akcelerometru Wire.write (0x08); // Z data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // požadavek 6 bajtů z podřízeného zařízení #2 while (Wire.available ()) // slave může odeslat méně, než bylo požadováno {Verze [2] = Wire.read (); // obdrží bajt jako znaky} z_data = (int8_t) Verze [2] >> 2; x = (float) x_data/divi; y = (float) y_data/divi; z = (float) z_data/divi; Serial.print ("X ="); Serial.print (x); // tisk znaku Serial.print (""); Serial.print ("Y ="); Serial.print (y); // tisk znaku Serial.print (""); Serial.print ("Z ="); // tisk znaku Serial.println (z); }

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

int vzdálenost;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {vzdálenost = nextPos - prevPos; if (vzdálenost <0) vzdálenost += NUMBER_OF_LEDS_ON_RING; návrat (vzdálenost); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int jasStep = 255/NUMBER_OF_LEDS_TO_SHINE;

neplatné makeLightShow () {

pro (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, (BrightStep * k), 0); if ((k == 0 && currentQueueSize 0) ledQueue.push (ledPosition);} neoring.show ();}

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

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

/Metodos del juego de luces del arcoiris

// Vyplňte tečky jeden po druhém barevnou prázdností colorWipe (uint32_t c, uint8_t čekejte) {for (uint16_t i = 0; i

prázdná duha (uint8_t čekat) {

uint16_t i, j;

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

// Mírně odlišná, díky čemuž je duha rovnoměrně rozložena po celém těle

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

for (j = 0; j <256*5; j ++) {// 5 cyklů všech barev na kolečku pro (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); zpoždění (čekání); }}

// Plazivá světla v divadelním stylu.

void TheaterChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// do 10 cyklů honění za (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // zapnutí každého třetího pixelu} strip.show ();

zpoždění (čekání);

pro (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // vypněte každý třetí pixel}}}}

// Plazivá světla v divadelním stylu s duhovým efektem

void TheaterChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// cyklus všech 256 barev v kolečku pro (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)); // zapnutí každého třetího pixelu} strip.show ();

zpoždění (čekání);

pro (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // vypněte každý třetí pixel}}}}

// Zadáním hodnoty 0 až 255 získáte hodnotu barvy.

// Barvy jsou přechodem r - g - b - zpět na r. uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } if (WheelPos <170) {WheelPos -= 85; zpětný proužek. Barva (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; zpětný proužek. Barva (WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/Metodos Rueda de colores

// int elegirColor = random (0x000000, 0xffffff); // Výběr eeage aleatoriamente entre toda la gama de Colores Componida 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); // 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 tečky jednu za druhou barvou

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

void pulseWhite (uint8_t wait) {

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

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

pro (uint16_t i = 0; i

void rainbowFade2White (uint8_t wait, int rainbowLoops, int whiteLoops) {

float fadeMax = 100,0; int fadeVal = 0; uint32_t wheelVal; int redVal, greenVal, blueVal;

for (int k = 0; k <rainbowLoops; k ++) {for (int j = 0; j <256; j ++) {// 5 cyklů všech barev na kolečku

pro (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));

}

// První smyčka, fade in!

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

// Poslední smyčka, zmizí!

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

strip.show ();

zpoždění (čekání); }}

zpoždění (500);

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

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

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

zpoždění (2000);

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

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

zpoždění (500);

}

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

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

int hlava = bíláDélka - 1;

int tail = 0;

int smyčky = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

while (true) {

pro (int j = 0; j <256; j ++) {pro (uint16_t i = 0; i = ocas && i hlava && i> = ocas) || (ocas> 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 ++; ocas ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == smyčky) return;

head%= strip.numPixels (); tail%= strip.numPixels (); strip.show (); zpoždění (čekání); }}} neplatné fullWhite () {for (uint16_t i = 0; i

// Mírně odlišná, díky čemuž je duha rovnoměrně rozložena po celém těle

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

for (j = 0; j <256 * 5; j ++) {// 5 cyklů všech barev na kolečku pro (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); zpoždění (čekání); }}

neplatné rainbow1 (uint8_t čekat) {

uint16_t i, j;

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

// Zadáním hodnoty 0 až 255 získáte hodnotu barvy.

// Barvy jsou přechodem r - g - b - zpět na r. uint32_t Wheel1 (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) {WheelPos -= 85; zpětný proužek. Barva (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; zpětný proužek. Barva (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 design

Nejprve si musíte dimenzovat hardwarové komponenty, abyste se ujistili, že jsou správné. Pokud jsou stejné jako naše, můžete použít stejné soubory, které vám půjčujeme.

Obě podpory byly navrženy s 3D tiskárnou, které jsou také zahrnuty jako:

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

Nakonec bude světlo jako dva poslední obrázky.

Krok 9: Nasazení krku

Nejprve umístíme sedlo na krk. Otvory, které šrouby potřebují, aby to držely, tam nejsou, takže je budeme muset udělat, označit, kam by měly jít, a opatrně, pomocí šneku, dělat otvor.

Totéž platí pro otvory, kde jsou šrouby, které drží samotný krk k tělu nástroje. Není nutné je provádět, protože pro toto upevnění neexistují žádné šrouby, ale pokud bychom to chtěli udělat, nebyl by žádný problém.

DŮLEŽITÉ: mezi začátkem stožáru a začátkem ladicí vidlice ponechte 5 mm mezery, protože v tomto otvoru bude umístěna matice.

Matici slepíme lepidlem, ve směru naznačeném na obrázku.

Nakonec představíme 4 kolíky v otvorech, které jsou na začátku stožáru, přičemž každý kolík přidržíme 2 krátkými šrouby, jak je znázorněno na obrázku.

Krok 10: Montáž Birdge

Most je upevněn lepením a dvěma dlouhými šrouby ve střední poloze na těle. Je vhodné vyznačit tužkou správnou polohu v těle. Vezmeme vzdálenosti, které jsou na obrázku vyznačeny.

Na spojení obou složek naneseme lepidlo. Oba díly opatrně zafixujeme pomocí utahovacího šroubu, dokud spoj nevyschne. Dva otvory pro šrouby uděláme 1,5 mm vrtákem na dřevo. Upevněte můstek dvěma dlouhými šrouby v těle. A nakonec jsme nasadili ochranné čepičky na hlavy šroubů.

Krok 11: Sestava těla a krku

K sestavení těchto dvou částí máme otvory v hlavě těla, kde se krk vejde se dvěma výstupky, které má. Můžeme je slepit lepidlem nebo tavnou pistolí. Chcete -li dosáhnout větší fixace, můžete otvory na konci ladicí vidlice spojit s tělem.

Krok 12: Vložte struny Ukulele

Nakonec musíme umístit struny tak, aby náš nástroj skončil.

Dříve vložíme upevňovací kroužky kolíků do výstupků, které procházejí stožárem. Pro umístění strun jsme vzali 4 struny, které byly součástí sady. Nejprve musíte rozlišit každý řetězec, protože nejsou všechny stejné. Musíte svázat jeden konec každého provázku (dva silné s normálním uzlem a dva tenké s dvojitým) a struny zasunout do otvorů mostu.

Poté umístíme řetězce tak, aby:

• První pozice: řetězec G (druhý nejsilnější řetězec).

• Druhá pozice: řetězec C (silnější řetězec).

• Třetí pozice: E struna (druhá tenčí struna).

• Čtvrtá pozice: Provázek (tenčí struna).

Zašroubujte struny do otvorů v dodávané zástrčce. Pokuste se opravit každé lano tak, že na čepu uděláte dvě nebo tři otáčky. Napněte struny bez použití příliš velké síly a zkontrolujte vzdálenost mezi strunami a sedlem.

Pokud máte nějaké pochybnosti o tom, jak to udělat, můžete použít tutoriál, který vám vysvětlí, jak správně umístit řetězce.

Krok 13: Testování

Nakonec musíme zjistit, zda bylo ukulele správně sestaveno tak, že ideální vzdálenost na prvním pražci je 0,1 mm a na dvanáctém přibližně 1,2 mm.

Je potřeba, abyste vyladili struny ukulele. Doporučuji vám tuto aplikaci: GuitarTuna

Krok 14: Užijte si to

Nyní si musíte užít jen své ukulele.

Pokud o nás chcete vědět více, najdete nás na:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc