DIY Smart Electronic Ukulele Sa Arduino: 14 Mga Hakbang (na may Mga Larawan)

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:14

Ipapaliwanag namin ang hakbang-hakbang kung paano mo maaaring idisenyo ang iyong sariling ukulele at magdagdag ng ilang mga epekto na gagawing natatangi ito, tulad ng pagguhit ng isang bagay na nais namin sa ibabaw ng ukulele o pagdaragdag ng ilang mga light effects.

Upang magawa iyon, kinakailangan upang bumili ng isang ukulele kit.

Ipapaliwanag namin kung paano tipunin ang instrumento, at malulutas ang iba't ibang mga problemang maaaring lumitaw.

Hakbang 1: Mga Kagamitan

Mga materyales sa istraktura:

DIY ukelele mounting kit (maaaring ito ay isa pang magkaibang kit) na nabuo ng:

1- Katawan.

2-Leeg.

3-Saddle

Suporta sa 4-Rope

5-Tulay

6-String nut.

7-Pag-aayos ng singsing para sa ulo ng makina (x4).

8-Head ng machine (x4).

9-Mounting screws para sa mga ulo ng makina (x8).

10-mounting screws para sa machine bridge (x2).

11-Mga takip ng takip para sa mga mounting screw ng tulay (x2).

12-Strings (x4).

Mga elektronikong materyales:

• NANO Arduino.
• Wheel ng Leds WS2812.
• Accelerometer BMA220 (opsyonal).
• Konektor ng baterya.
• Baterya ng 9V.
• Lumipat

Ang iba pa

• Wood varnish.
• Velcro.
• Lata na panghinang.
• Protektibong plastik para sa varnishing.
• Mainit na matunaw na silikon.

Mga tool:

• Pag-ukit ng laser.
• Papel de liha
• Star distornilyador.
• Paintbrush.
• Mainit na baril na natutunaw.
• Tin na bakal na panghinang.

Hakbang 2: Ipasadya ang Ukulele

Upang gawing costumize ang aming ukulele maaari kaming gumawa ng isang pag-ukit ng isang guhit na may isang pamutol ng laser sa katawan. Sa kaso ng wala ang tool na iyon, maaari naming ipinta ito.

Ang larawan na pinili namin ay ang unang lilitaw.

Una sa lahat, kailangan nating idisenyo ang template ng pagguhit upang gawin ang pag-ukit.

Upang maisagawa iyon, gagamit kami ng isang software na tinatawag na 'Inkscape' na maaari naming makuha mula sa link na ito:

Upang magamit ito, dapat naming ayusin ang larawan na nais naming gamitin tulad ng ipinapakita namin sa pangalawang imahe. Maaari mong tingnan na paikutin namin ang paunang imahe upang maiayos ang cicle ng kamay gamit ang bilog ng instrumento. Tulad ng nasabi na namin dati, maaari kang maglagay ng anumang imahe.

Hakbang 3: I-Vectorize ang isang Imaheng Gamit ang Inkscape

Makikita natin kung paano lumikha ng isang vector file mula sa isang pixmap (jpg, png, anuman ang format ng raster na maaaring buksan ng Inkscape).

Ang Inkscape Inkscape ay isang open-source vector graphics editor, at ayon sa pamagat ng pamagat, ito ang tool na gagamitin ko upang i-vector ang mga logo. Mga hakbang sa Vectorising Ang mga hakbang ay karaniwan para sa anumang vectorization na nais naming gawin.

1. Buksan ang imahe sa Inkscape
2. Buksan ang Path ng Trace Bitmap Tool-> Trace Bitmap
3. Maglaro sa paligid ng mga pagpipilian sa Trace Bitmap
4. Patakbuhin ang pagsunod
5. Linisin ang mga resulta (kung kinakailangan)

Tandaan ang bahagi ng "paglalaro sa paligid". Hindi ako dalubhasa sa pagsubaybay, kaya tinatrato ko ang tool na ito bilang isang itim na kahon na may mga knobs at ilaw, pag-ikot at pagbabago hanggang sa makuha ko ang pinakamahusay na resulta

Hakbang 4: Pag-ukit sa Logo

Para sa mga ito, mahalagang magkaroon ng isang silweta ng ibabaw na kung saan makagawa ang pag-ukit ng pagguhit.

Upang gawin ang pag-ukit, gagamitin namin ang software na 'T2Laser'. Maaari naming makuha ang software na ito mula sa:

Kapag nabuksan na namin ang software, kailangan naming i-load ang imahe na nilikha namin sa huling hakbang. Pagkatapos, pindutin ang pindutan na "control laser", at lilitaw ang mga control ng cnc. Ipinapakita ng dalawang larawan ang proseso at ang resulta ng pag-ukit sa aming laser cutter.

Hakbang 5: Sanding at Varnishing

Upang iwanang maliwanag ang aming ukulele at may isang layer na walang pagkamagaspasan maaari naming maayos na buhangin ang dalawang bahagi na bumubuo sa aming instrumento nang may pag-iingat, dahil maaari naming mapinsala ang ginawang pagguhit (kung pinili mo upang ipinta ang ukulele, kailangan mong buhangin muna ito). Pagkatapos ay varnish namin ang aming dalawang bahagi upang makakuha sila ng isang mas madidilim na kulay at ang kahoy ay nagtatanghal ng higit na paglaban. Maaari kaming gumamit ng isang normal na barnisan ng kahoy, hindi ito kailangang maging espesyal.

Kapag mayroon kaming barnisan, ihinahalo namin ito sa isang maliit na may kakayahang makabayad ng utang upang ito ay natutunaw nang kaunti. Susunod, inilalagay namin ang halo na may isang brush sa leeg at ang katawan ng instrumento at hinayaan itong matuyo.

Kung nakita natin na ang produkto ay nangangailangan ng isang pangalawang amerikana, maaari naming buhangin nang kaunti ang dalawang bahagi at muling ilapat ang isang layer ng lasaw na barnisan.

** PRECAUTIONS: Ang varnish ay isang produktong kemikal, kaya kinakailangan upang maisagawa ang prosesong ito sa isang maaliwalas na lugar, magsuot ng maskara upang maiwasan ang paglanghap ng mga amoy at proteksiyon na salaming de kolor.

Ang mga materyal na kailangan upang makapagtrabaho nang tama ay ang mga lilitaw sa mga larawan. Pangunahin gagana kami sa isang brush, isang barnisan maaari (sa aming kaso pulang kulay), isang maliit na may kakayahang solvent at visual na proteksyon. At higit sa lahat gumagana sa maayos na maaliwalas na mga puwang.

Hakbang 6: Hardware

Ang aming plaka sa Arduino, ang acelerometer at ang gulong na may mga leds ay ipapakilala sa isang maliit na bracket upang maiwasan na ang lahat ng mga bahagi ay lumipat sa instrumento.

Nagdagdag din kami ng isang may hawak ng baterya at isang switch upang gawing mas komportable ito at hindi namin naubos ang baterya kapag hindi namin ginagamit ang instrumento. Ikakabit namin ang suportang ito gamit ang isang piraso ng Velcro (gagana rin ito gamit ang silicone at isang mainit na natutunaw na baril) sa panloob na mukha ng katawan ng ukulele. Sa kabilang banda, ang LED wheel ay mas maliit kaysa sa butas, kaya't mahuhulog ito. Ang isang suporta ay dinisenyo upang ito ay mahawakan nang maayos at maisasagawa ang pagpapaandar nito.

Hakbang 7: Software

Upang magbigay ng isang espesyal na dekorasyon sa aming ukulele, maaari kaming magdagdag ng mga light effects salamat sa isang gulong ng leds. Gagamitin namin ang WS2812, ngunit maaari kang gumamit ng iba pang pagsunod sa mga tagubilin ng datasheet. Gumagamit din kami ng isang acelerometer (BMA220) din, na nagpapahintulot sa amin na gumawa ng isang epekto ng gravity.

Sa katunayan, magkakaroon kami ng 4 na pag-play ng ilaw, kasama sa library ng computer na tinatawag na 'Adafruit' ng Arduino. Sa iyon, dapat kaming gumawa ng isang tamang pagkakaugnay sa pagitan ng tatlong mga bahagi: Arduino NANO, WS2812 at BMA220, tulad ng lilitaw sa unang imahe.

Ang mga pulang wire ay para sa lakas, ang mga itim na GND at ang natitira ay kinakailangan ng mga koneksyon para sa tamang operasyon. Ang code na ginamit namin para sa light kit ay naka-attach sa isang file na tinatawag na "play_of_light_v0.ino". Tiyaking isinama mo ang mga kinakailangang aklatan para sa wastong pagpapatakbo ng programa. Ang baterya na idinagdag namin panlabas sa circuit ay dapat magkaroon ng isang minimum na boltahe ng 9V at kailangan naming matiyak na ito ay may kakayahang magbigay ng minimum na kasalukuyang kinakailangan upang mapalakas ang buong circuit.

// Variable contador at interrupciónint counter; // Variables Ejemplo gravedad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 # tukuyin NEOPIXEL_RING_DATA_PIN 9

byte Bersyon [3];

int8_t x_data; int8_t y_data; int8_t z_data; saklaw ng byte = 0x00; float divi = 16; lumutang x, y, z; float pi = 3.14159265359; float nx, ny, anggulo; int led, nakaraangLed; Pinangunahan ng pila ang Queue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Variable Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parameter 1 = bilang ng mga pixel sa strip // Parameter 2 = Arduino pin number (karamihan ay may bisa) // Parameter 3 = mga flag na uri ng pixel, idagdag nang sama-sama kung kinakailangan: // NEO_KHZ800 800 KHz bitstream (karamihan sa mga produktong NeoPixel w / WS2812 LEDs) // NEO_KHZ400 400 KHz (klasikong 'v1' (hindi v2) FLORA pixel, mga driver ng WS2811) // NEO_GRB Ang mga pixel ay naka-wire para sa GRB bitstream (karamihan sa mga produktong NeoPixel) / / NEO_RGB Ang mga pixel ay naka-wire para sa RGB bitstream (v1 FLORA pixel, hindi v2) // NEO_RGBW Ang mga pixel ay naka-wire para sa RGBW bitstream (mga produktong NeoPixel RGBW) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // MAHALAGA: Upang mabawasan ang peligro ng NeoPixel burnout, magdagdag ng 1000 uF capacitor sa // // pixel power lead, magdagdag ng 300 - 500 Ohm resistor sa input ng data ng unang pixel // at i-minimize ang distansya sa pagitan ng Arduino at unang pixel. Iwasang kumonekta // sa isang live circuit … kung kailangan mo, ikonekta muna ang GND.

// Variable Rueda de colores

// NeoPixel Ring simpleng sketch (c) 2013 Shae Erisson // na inilabas sa ilalim ng lisensya ng GPLv3 upang tumugma sa natitirang library ng AdaFruit NeoPixel

# isama

#ifdef _AVR_ # isama ang #endif

// Aling pin sa Arduino ang konektado sa NeoPixels?

// Sa isang Trinket o Gemma iminumungkahi namin na baguhin ito sa 1 # tukuyin ang PIN 9

// Ilan sa mga NeoPixels ang nakakabit sa Arduino?

# tukuyin ang NUMPIXELS 16

// Kapag na-set up namin ang NeoPixel library, sasabihin namin sa ito kung gaano karaming mga pixel, at aling pin ang gagamitin upang magpadala ng mga signal.

// Tandaan na para sa mas matandang NeoPixel strips maaaring kailanganin mong baguhin ang pangatlong parameter - tingnan ang strandtest // halimbawa para sa karagdagang impormasyon sa mga posibleng halaga. Adafruit_NeoPixel pixel = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int pagkaantala = 50; // antala ng 50ms

// Variable colores aleatorios

# isama ang # ifdef _AVR_ #include #endif

# tukuyin ang PIN 9

# tukuyin ang NUM_LEDS 16

# tukuyin ang KARAPATAN 200

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

byte 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 SETUP

void setup () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // address of the accelerometer // range setting Wire.write (0x22); // register address Wire.write (saklaw); // maaaring itakda sa "0x00" "0x01" "0x02" "0x03", sumangguni sa Datashhet sa wiki // low pass filter Wire.write (0x20); // register address Wire.write (0x05); // maaaring itakda sa "0x05" "0x04" …… "0x01" "0x00", sumangguni sa Datashhet sa wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Ito ay para sa Trinket 5V 16MHz, maaari mong alisin ang tatlong mga linya na ito kung hindi ka gumagamit ng isang Trinket #if na tinukoy (_AVR_ATtiny85_) kung (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // End of trinket special code strip.begin (); strip.show (); // Initialize all pixel to 'off'

// Código Rueda de colores

// Ito ay para sa Trinket 5V 16MHz, maaari mong alisin ang tatlong mga linya na ito kung hindi ka gumagamit ng isang Trinket #if na tinukoy (_AVR_ATtiny85_) kung (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Pagtatapos ng espesyal na code ng trinket

pix.begin (); // Pinasimulan nito ang NeoPixel library.

// Codigo Interrupcion

counter = 1;

// Codigo Colores varios

// Ito ay para sa Trinket 5V 16MHz, maaari mong alisin ang tatlong mga linya na ito kung hindi ka gumagamit ng isang Trinket #if na tinukoy (_AVR_ATtiny85_) kung (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // End of trinket special code strip.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Initialize all pixel to 'off'}

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

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

/ Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; kung (counter == 1) {para sa (int i = 0; i 0.0) {kung (nx 0.0) anggulo + = 180; iba pang anggulo + = 360; } // magtapos pa kung (anggulo == 360.0) anggulo = 0.0; led = circularize (anggulo / (360 / NUMBER_OF_LEDS_ON_RING)); // make led kilusan makinis kung (nakaraangLed == humantong) {// wala gawin} iba pa kung (counterClockwiseDistanceBetweenLeds (nakaraangLed, humantong) <= 8) humantong = circularize (nakaraangLed + 1); iba pa humantong = circularize (nakaraangLed - 1); ledQueue.push (led); makeLightShow (); nakaraangLed = pinangunahan; antala (25); } counter = 2; } // End if counter == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {para (int j = 0; j <5; j ++) {// Ang ilang halimbawang mga pamamaraang ipinapakita kung paano ipakita sa mga pixel: colorWipe1 (strip. Color (255, 0, 0), 50); // Red colorWipe1 (strip. Color (0, 255, 0), 50); // Green colorWipe1 (strip. Kulay (0, 0, 255), 50); // Blue colorWipe1 (strip. Color (0, 0, 0, 255), 50); // White RGBW // Magpadala ng chase ng pixel ng teatro sa… teatroChase (strip. Color (127, 127, 127), 50); // White theatreChase (strip. Kulay (127, 0, 0), 50); // Red theatreChase (strip. Kulay (0, 0, 127), 50); // Bughaw

bahaghari (5);

bahaghariCycle (5); teatroChaseRainbow (5); } counter = 3; } // Tapusin kung counter == 2 // Caso 3: Luces Aleatorias kung (counter == 3) {para (int k = 0; k <50; k ++) {// Para sa isang hanay ng NeoPixels ang unang NeoPixel ay 0, pangalawa ay 1, hanggang sa bilang ng mga pixel na minus isa. int a = random (255); int b = random (255); int c = random (255); para sa (int i = 0; i

// pixel. Kinukuha ng kulay ang mga halagang RGB, mula 0, 0, 0 hanggang 255, 255, 255

pix.setPixelColor (i, mga pixel. Kulay (a, b, c)); // Katamtamang maliwanag na berdeng kulay.

pix.show (); // Ipinapadala nito ang na-update na kulay ng pixel sa hardware.

pagkaantala (pagkaantala); // Pag-antala para sa isang tagal ng oras (sa milliseconds).

} a = random (255); b = random (255); c = random (255); para sa (int i = NUMPIXELS; i> 0; i -) {

// pixel. Kinukuha ng kulay ang mga halagang RGB, mula 0, 0, 0 hanggang 255, 255, 255

pix.setPixelColor (i, mga pixel. Kulay (a, b, c)); // Katamtamang maliwanag na berdeng kulay.

pix.show (); // Ipinapadala nito ang na-update na kulay ng pixel sa hardware.

pagkaantala (pagkaantala); // Pag-antala para sa isang tagal ng oras (sa milliseconds).

}} counter = 4; } iba pa kung (counter == 4) {para sa (int g = 0; g <= 6; g ++) {// Ilang halimbawa ng mga pamamaraan na ipinapakita kung paano ipakita sa mga pixel: colorWipe (strip. Color (255, 0, 0), 50); // Red colorWipe (strip. Color (0, 255, 0), 50); // Green colorWipe (strip. Kulay (0, 0, 255), 50); // Blue colorWipe (strip. Color (0, 0, 0, 255), 50); // White whiteOverRainbow (20, 75, 5); PutiWhite (5); // fullWhite (); // pagkaantala (2000); bahaghariFade2White (3, 3, 1);

}

counter = 1; }} // ///. // ///. // ///. // ///.

/ Metodos del Ejemplo de la gravedad

walang bisa ang AccelerometerInit () {Wire.beginTransmission (0x0A); // address of the accelerometer // reset the accelerometer Wire.write (0x04); // X data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // request 6 bytes mula sa alipin aparato # 2 habang (Wire.available ()) // alipin ay maaaring magpadala ng mas mababa kaysa sa hiniling {Bersyon [0] = Wire.read (); // makatanggap ng isang byte bilang characte} x_data = (int8_t) Bersyon [0] >> 2; Wire.beginTransmission (0x0A); // address of the accelerometer // reset the accelerometer Wire.write (0x06); // Y data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // request 6 bytes mula sa alipin aparato # 2 habang (Wire.available ()) // alipin ay maaaring magpadala ng mas mababa kaysa sa hiniling {Bersyon [1] = Wire.read (); // makatanggap ng isang byte bilang characte} y_data = (int8_t) Bersyon [1] >> 2; Wire.beginTransmission (0x0A); // address of the accelerometer // reset the accelerometer Wire.write (0x08); // Z data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // request 6 bytes mula sa alipin aparato # 2 habang (Wire.available ()) // alipin ay maaaring magpadala ng mas mababa kaysa sa hiniling {Bersyon [2] = Wire.read (); // makatanggap ng isang byte bilang characte} z_data = (int8_t) Bersyon [2] >> 2; x = (float) x_data / divi; y = (float) y_data / divi; z = (float) z_data / divi; Serial.print ("X ="); Serial.print (x); // print the character Serial.print (""); Serial.print ("Y ="); Serial.print (y); // print the character Serial.print (""); Serial.print ("Z ="); // print the character Serial.println (z); }

int circularize (int pos) {

kung (pos> = NUMBER_OF_LEDS_ON_RING) bumalik (pos - NUMBER_OF_LEDS_ON_RING); iba pa kung bumalik (pos <0) (pos + NUMBER_OF_LEDS_ON_RING); kung hindi man bumalik (pos); }

int distansya;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distansya = nextPos - prevPos; kung (distansya <0) distansya + = NUMBER_OF_LEDS_ON_RING; bumalik (distansya); }

int ledPosition, kasalukuyangQueueSize;

# tukuyin ang NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 255 / NUMBER_OF_LEDS_TO_SHINE;

walang bisa makeLightShow () {

para sa (int j = 0; j <NUMBER_OF_LEDS_ON_RING; j ++) neoring.setPixelColor (j, 0, 0, 0); currentQueueSize = ledQueue.count (); para sa (int k = 0; k <currentQueueSize; k ++) {ledPosition = ledQueue.pop (); neoring.setPixelColor (ledPosition, 0, (brightnessStep * k), 0); kung ((k == 0 && currentQueueSize 0) ledQueue.push (ledPosition);} neoring.show ();}

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

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

/ Metodos del juego de luces del arcoiris

// Punan ang mga tuldok nang sunod-sunod sa isang kulay na walang bisa na colorWipe (uint32_t c, uint8_t maghintay) {para sa (uint16_t i = 0; i

walang bisa ang bahaghari (uint8_t wait) {

uint16_t i, j;

para sa (j = 0; j <256; j ++) {para sa (i = 0; i

// Bahagyang naiiba, ginagawa nitong pantay na ipinamamahagi ang bahaghari

walang bisa ang rainbowCycle (uint8_t maghintay) {uint16_t i, j;

para sa (j = 0; j <256 * 5; j ++) {// 5 cycle ng lahat ng mga kulay sa gulong para sa (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); antala (maghintay); }}

// Mga ilaw sa pag-crawl na istilo ng teatro.

void theatreChase (uint32_t c, uint8_t wait) {para sa (int j = 0; j <10; j ++) {// gawin ang 10 cycle ng paghabol para sa (int q = 0; q <3; q ++) {para sa (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, c); // turn on third pixel on} strip.show ();

antala (maghintay);

para sa (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // patayin ang bawat pangatlong pixel}}}}

// Mga ilaw-gumagapang na istilo ng teatro na may epekto ng bahaghari

void theatreChaseRainbow (uint8_t wait) {para (int j = 0; j <256; j ++) {// ikot ang lahat ng 256 na kulay sa gulong para sa (int q = 0; q <3; q ++) {para sa (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, Wheel ((i + j)% 255)); // turn on third pixel on} strip.show ();

antala (maghintay);

para sa (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // patayin ang bawat pangatlong pixel}}}}

// Magpasok ng halagang 0 hanggang 255 upang makakuha ng isang halagang kulay.

// Ang mga kulay ay isang paglipat r - g - b - pabalik sa r. uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; kung (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } kung (WheelPos <170) {WheelPos - = 85; return strip. Kulay (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos - = 170; return strip. Color (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

// Punan ang mga tuldok ng sunod-sunod sa isang kulay

walang bisa na colorWipe1 (uint32_t c, uint8_t maghintay) {for (uint16_t i = 0; i

void pulseWhite (uint8_t wait) {

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

para sa (int j = 255; j> = 0; j -) {

para sa (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;

para sa (int k = 0; k <rainbowLoops; k ++) {para sa (int j = 0; j <256; j ++) {// 5 cycle ng lahat ng mga kulay sa gulong

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

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

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

greenVal = berde (wheelVal) * float (fadeVal / fadeMax); blueVal = asul (wheelVal) * float (fadeVal / fadeMax);

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

}

// First loop, kumupas ka!

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

// Huling loop, kumupas!

kung hindi man (k == rainbowLoops - 1 && j> 255 - fadeMax) {fadeVal--; }

strip.show ();

antala (maghintay); }}

pagkaantala (500);

para sa (int k = 0; k <whiteLoops; k ++) {

para sa (int j = 0; j <256; j ++) {

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

pagkaantala (2000);

para sa (int j = 255; j> = 0; j -) {

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

pagkaantala (500);

}

void whiteOverRainbow (uint8_t wait, uint8_t whiteSpeed, uint8_t whiteLength) {

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

int ulo = maputi ang Haba - 1;

int buntot = 0;

int loop = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

habang (totoo) {

para sa (int j = 0; j <256; j ++) {para sa (uint16_t i = 0; i = buntot && i ulo && i> = buntot) || (buntot> ulo && i <= ulo)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } iba pa {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); }}

kung (millis () - lastTime> whiteSpeed) {

ulo ++; buntot ++; kung (ulo == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

kung (loopNum == loop) bumalik;

ulo% = strip.numPixels (); buntot% = strip.numPixels (); strip.show (); antala (maghintay); }}} void fullWhite () {para sa (uint16_t i = 0; i

// Bahagyang naiiba, ginagawa nitong pantay na ipinamamahagi ang bahaghari

walang bisa ang rainbowCycle1 (uint8_t maghintay) {uint16_t i, j;

para sa (j = 0; j <256 * 5; j ++) {// 5 cycle ng lahat ng mga kulay sa gulong para sa (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); antala (maghintay); }}

walang bisa ang bahaghari1 (uint8_t wait) {

uint16_t i, j;

para sa (j = 0; j <256; j ++) {para sa (i = 0; i

// Magpasok ng halagang 0 hanggang 255 upang makakuha ng isang halagang kulay.

// Ang mga kulay ay isang paglipat r - g - b - pabalik sa r. uint32_t Wheel1 (byte WheelPos) {WheelPos = 255 - WheelPos; kung (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } kung (WheelPos <170) {WheelPos - = 85; return strip. Kulay (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos - = 170; return strip. Color (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t pula (uint32_t c) {

bumalik (c >> 16); } uint8_t berde (uint32_t c) {return (c >> 8); } uint8_t blue (uint32_t c) {return (c); }

Hakbang 8: Disenyo ng 3D

Una, dapat mong sukatin ang iyong mga bahagi ng hardware upang matiyak ang tama. Kung pareho ang mga ito sa amin, maaari mong gamitin ang parehong mga file na pinahiram namin sa iyo.

Ang parehong mga suporta ay dinisenyo gamit ang isang 3D printer, na kasama rin bilang:

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

Sa wakas, ang ilaw ay magiging katulad ng dalawang huling larawan.

Hakbang 9: Pag-mount sa Leeg

Ilalagay muna namin ang saddleon sa leeg. Ang mga butas na kailangan ng mga tornilyo upang hawakan ito ay wala roon, kaya kailangan nating gawin ang mga ito, pagmamarka kung saan sila dapat pumunta at maingat, na may isang auger, na gumagawa ng butas.

Nalalapat ang pareho sa mga butas kung saan ang mga turnilyo na humahawak sa leeg mismo sa katawan ng instrumento. Hindi kinakailangan na gawin ang mga ito, dahil walang mga turnilyo para sa pangkabit na ito, ngunit kung nais naming gawin ito, walang problema.

MAHALAGA: iwanan ang 5mm ng puwang sa pagitan ng pagsisimula ng palo at ang simula ng tuning fork, sapagkat sa butas na iyon ang nut ay mailalagay.

Kami ay pandikit ang kulay ng nuwes na may pandikit, sa direksyon na ipinahiwatig ng figure.

Sa wakas, ipakikilala namin ang 4 na mga pin sa mga butas na nasa simula ng palo, na humahawak sa bawat pin na may 2 maikling turnilyo tulad ng ipinakita sa imahe.

Hakbang 10: Pag-mount ng Birdge

Ang tulay ay naayos sa pamamagitan ng pagdidikit at sa dalawang mahahabang turnilyo sa isang gitnang posisyon sa katawan. Maipapayo na markahan ng isang lapis ang tamang posisyon sa katawan. Dadalhin namin ang mga distansya na minarkahan sa imahe.

Maglalagay kami ng pandikit sa unyon ng dalawang sangkap. Maayos naming inaayos ang dalawang bahagi sa tulong ng isang humihigpit na tornilyo hanggang sa matuyo ang magkasanib. Gagawa kami ng dalawang butas para sa mga turnilyo na may 1.5mm drill bit para sa kahoy. Ayusin ang tulay gamit ang dalawang mahahabang turnilyo sa katawan. At sa wakas, inilalagay namin ang mga takip na proteksiyon sa mga ulo ng mga turnilyo.

Hakbang 11: Body at Neck Assembly

Upang tipunin ang dalawang bahagi, mayroon kaming mga butas sa ulo ng katawan, kung saan ang leeg ay magkakasya sa dalawang pagbawas na mayroon ito. Maaari nating idikit ang mga ito sa pandikit o sa mainit na natutunaw na baril. Upang magkaroon ng isang mas malaking fixation, maaari kang gumawa ng mga butas na nasa dulo ng tuning fork upang maisali ito sa katawan.

Hakbang 12: Ilagay ang Mga Ukulele Strings

Sa wakas kailangan naming ilagay ang mga string upang ang aming instrumento ay tapos na.

Dati ay isisingit namin ang mga pag-aayos ng mga singsing ng mga pin sa mga pagpapakita ng mga ito na dumaan sa palo. Upang mailagay ang mga string, kinuha namin ang 4 na mga string na kasama ng kit. Una kailangan mong makilala ang bawat string dahil hindi pareho ang lahat. Kailangan mong itali ang isang dulo ng bawat string (ang dalawang makapal na may isang normal na buhol, at ang dalawang manipis na may isang doble) at ipasok ang mga string sa mga puwang ng tulay.

Pagkatapos ay ilalagay namin ang mga string sa isang paraan na:

• Unang posisyon: G string (pangalawang makapal na string).

• Pangalawang posisyon: C string (mas makapal na string).

• Pangatlong posisyon: E string (pangalawang mas payat na string).

• Pang-apat na posisyon: Isang string (mas payat na string).

I-thread ang mga string sa mga butas ng ibinigay na plug. Subukang ayusin ang bawat lubid sa pamamagitan ng pagbibigay ng dalawa o tatlong pagliko sa pin. Pag-igtingin ang mga string nang hindi naglalapat ng labis na puwersa at suriin ang distansya sa pagitan ng mga string at ng siyahan.

Kung mayroon kang anumang pag-aalinlangan tungkol sa kung paano ito gawin, maaari kang tumawag sa tutorial na nagpapaliwanag sa iyo kung paano mailagay nang tama ang mga string.

Hakbang 13: Pagsubok

Sa wakas, kailangan nating makita kung ang ukulele ay maayos na naipon sa isang paraan na ang perpektong distansya sa unang fret ay 0.1mm at sa ikalabindalawa ay humigit-kumulang na 1.2mm.

Ay kinakailangan na ibagay mo ang mga string ng ukulele. Inirerekumenda ko sa iyo ang app na ito: GuitarTuna

Hakbang 14: Tangkilikin Ito

Ngayon, magugustuhan mo lang ang iyong ukulele.

Kung nais mong malaman ang karagdagang impormasyon tungkol sa amin, mahahanap mo kami sa:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc