Ukulele Elektronik Pintar DIY Dengan Arduino: 14 Langkah (dengan Gambar)

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:11

Kami akan menerangkan langkah demi langkah bagaimana anda boleh merancang ukulele anda sendiri dan menambahkan beberapa kesan yang akan menjadikannya unik, seperti melukis sesuatu yang kita mahukan di permukaan ukulele atau menambahkan beberapa kesan cahaya.

Untuk membuatnya, perlu membeli kit ukulele.

Kami akan menjelaskan cara memasang instrumen, dan menyelesaikan pelbagai masalah yang mungkin muncul.

Langkah 1: Bahan

Bahan struktur:

Kit pemasangan ukelele DIY (ia boleh menjadi kit lain yang berbeza) yang dibentuk oleh:

1- Badan.

2-leher.

3-Pelana

Sokongan 4-Tali

5-Jambatan

Nasi 6-tali.

7-Cincin pemasangan untuk kepala mesin (x4).

Kepala 8-Mesin (x4).

Skru pemasangan 9 untuk kepala mesin (x8).

Skru pemasangan 10 untuk jambatan mesin (x2).

11-Tutup penutup untuk skru pemasangan jambatan (x2).

12-Strings (x4).

Bahan elektronik:

• NANO Arduino.
• Roda Leds WS2812.
• Accelerometer BMA220 (pilihan).
• Penyambung bateri.
• Bateri 9V.
• Tukar.

Yang lain

• Varnis kayu.
• Velcro.
• Tin pematerian.
• Plastik pelindung untuk pernis.
• Silikon cair panas.

Alat:

• Ukiran laser.
• Kertas pasir
• Pemutar skru bintang.
• Berus cat.
• Pistol lebur panas.
• Besi pematerian timah.

Langkah 2: Sesuaikan Ukulele

Untuk mengukir ukulele kita, kita dapat membuat ukiran gambar dengan pemotong laser di badan. Sekiranya tidak mempunyai alat itu, kita dapat melukisnya.

Gambar yang telah kami pilih adalah gambar pertama yang muncul.

Pertama sekali, kita harus merancang templat lukisan untuk membuat ukiran.

Untuk melaksanakannya, kami akan menggunakan perisian yang disebut 'Inkscape' yang dapat kami perolehi dari pautan ini:

Untuk menggunakannya, kita mesti menyesuaikan gambar yang kita mahu gunakan seperti yang kita tunjukkan pada gambar kedua. Anda dapat melihat bahawa kami telah memutar gambar awal untuk dapat menyesuaikan cikel tangan dengan bulatan instrumen. Seperti yang telah kami katakan sebelumnya, anda boleh meletakkan gambar apa pun.

Langkah 3: Vektorkan Gambar Menggunakan Inkscape

Kami akan melihat cara membuat fail vektor dari peta pikap (jpg, png, apa sahaja format raster yang dapat dibuka oleh Inkscape).

Inkscape Inkscape adalah penyunting grafik vektor sumber terbuka, dan sesuai dengan judulnya, ini adalah alat yang akan saya gunakan untuk vektor logo. Langkah-langkah vektorisasi Langkah-langkah yang biasa dilakukan untuk sebarang vektorisasi yang mungkin ingin kita lakukan.

1. Buka gambar di Inkscape
2. Buka Laluan Alat Trace Bitmap-> Trace Bitmap
3. Main di sekitar pilihan Trace Bitmap
4. Jalankan pengesanan
5. Bersihkan hasilnya (jika perlu)

Perhatikan bahagian "bermain-main". Saya bukan pakar penelusuran, jadi saya menganggap alat ini sebagai kotak hitam dengan tombol dan lampu, memutar dan menukar sehingga saya mendapat hasil terbaik

Langkah 4: Ukiran Logo

Untuk ini, penting untuk mempunyai siluet permukaan di mana ukiran lukisan akan dihasilkan.

Untuk membuat ukiran, kita akan menggunakan perisian 'T2Laser'. Kami boleh mendapatkan perisian ini dari:

Setelah membuka perisian, kita harus memuatkan gambar yang telah kita buat pada langkah terakhir. Kemudian, tekan butang "laser kawalan", dan muncul kawalan cnc. Kedua-dua gambar menunjukkan proses dan hasil ukiran dengan pemotong laser kami.

Langkah 5: Pengamplasan dan Pengamalan

Untuk membiarkan ukulele kita cerah dan dengan lapisan tanpa kekasaran, kita dapat mengoleskan dua bahagian alat muzik kita dengan lancar, kerana kita dapat merosakkan lukisan yang telah dibuat (jika anda memilih untuk melukis ukulele, anda harus pasir dahulu). Kemudian kita akan mempernis kedua-dua bahagian kita sehingga memperoleh warna yang lebih gelap dan kayu menunjukkan lebih banyak ketahanan. Kita boleh menggunakan pernis kayu biasa, tidak perlu istimewa.

Sebaik sahaja kita mempunyai pernis, kita mencampurkannya dengan sedikit pelarut sehingga larut sedikit. Seterusnya, kami sapukan campuran dengan sikat di leher dan badan instrumen dan biarkan kering.

Sekiranya kita melihat bahawa produk memerlukan lapisan kedua, kita dapat mengoleskan kedua bahagian sedikit dan menggunakan semula lapisan pernis yang dicairkan.

** PERHATIAN: Pernis adalah produk kimia, jadi perlu melakukan proses ini di tempat yang berventilasi, pakai topeng untuk mengelakkan bau dan pelindung mata.

Bahan yang perlu kita dapat berfungsi dengan betul adalah bahan yang terdapat dalam foto. Terutama kita akan bekerja dengan berus, kaleng pernis (dalam kes kita warna merah), sedikit pelarut dan perlindungan visual. Dan di atas semua berfungsi di tempat yang berventilasi baik.

Langkah 6: Perkakasan

Plak kami dengan Arduino, akselerometer dan roda dengan led akan diperkenalkan dalam kurungan kecil untuk mengelakkan semua komponen bergerak di dalam instrumen.

Kami juga telah menambahkan pemegang bateri dan suis untuk menjadikannya lebih selesa dan kami tidak kehabisan bateri semasa kami tidak menggunakan instrumen. Kami akan melampirkan sokongan ini dengan sekeping Velcro (ia juga berfungsi dengan silikon dan pistol lebur panas) ke permukaan dalaman badan ukulele. Sebaliknya, roda LED lebih kecil daripada lubang, sehingga akan jatuh. Sokongan telah dirancang supaya dapat berfungsi dengan baik dan dapat menjalankan fungsinya.

Langkah 7: Perisian

Untuk memberikan hiasan khas pada ukulele kami, kami dapat menambahkan kesan cahaya berkat roda led. Kami akan menggunakan WS2812, tetapi anda boleh menggunakan yang lain mengikut arahan lembaran data. Kami juga akan menggunakan akselerometer (BMA220), yang memungkinkan kita membuat kesan graviti.

Sebenarnya, kita akan mempunyai 4 permainan cahaya, termasuk di perpustakaan komputer yang disebut 'Adafruit' dari Arduino. Untuk itu, kita mesti membuat penyatuan yang betul antara tiga komponen: Arduino NANO, WS2812 dan BMA220, seperti yang muncul pada gambar pertama.

Kabel merah adalah untuk kuasa, hitam GND dan selebihnya adalah sambungan yang diperlukan untuk operasi yang betul. Kod yang kami gunakan untuk kit cahaya dilampirkan dalam fail yang disebut "play_of_light_v0.ino". Pastikan anda memasukkan perpustakaan yang diperlukan untuk pengoperasian program yang betul. Bateri yang kita tambahkan luaran ke litar mesti mempunyai voltan minimum 9V dan kita harus memastikan bahawa ia mampu memberikan arus minimum yang diperlukan untuk menghidupkan keseluruhan litar.

// Pemboleh ubah contador e interrupciónint counter; // Pemboleh ubah Ejemplo gravedad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #tentukan NEOPIXEL_RING_DATA_PIN 9

Versi bait [3];

int8_t x_data; int8_t y_data; int8_t z_data; julat bait = 0x00; float divi = 16; terapung x, y, z; float pi = 3.14159265359; apungan nx, ny, sudut; int led, sebelumnyaLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Pemboleh ubah Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parameter 1 = jumlah piksel dalam jalur // Parameter 2 = Nombor pin Arduino (kebanyakannya sah) // Parameter 3 = bendera jenis piksel, tambahkan bersama jika diperlukan: // NEO_KHZ800 bitstream 800 KHz (kebanyakan produk NeoPixel dengan LED WS2812) // NEO_KHZ400 400 KHz (piksel 'v1' (bukan v2) FLORA klasik, pemacu WS2811) // Piksel NEO_GRB adalah kabel untuk bitstream GRB (kebanyakan produk NeoPixel) / / Piksel NEO_RGB dikabelkan untuk aliran bit RGB (piksel v1 FLORA, bukan v2) // Piksel NEO_RGBW disambungkan untuk aliran bit RGBW (produk NeoPixel RGBW) Jalur Adafruit_NeoPixel = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // PENTING: Untuk mengurangkan risiko burnout NeoPixel, tambahkan kapasitor 1000 uF merentasi // daya piksel, tambahkan perintang 300 - 500 Ohm pada input data piksel pertama // dan kurangkan jarak antara Arduino dan piksel pertama. Elakkan menyambung // pada litar langsung … jika anda mesti, sambungkan GND terlebih dahulu.

// Pemboleh ubah Rueda de colores

// Sketsa sederhana NeoPixel Ring (c) 2013 Shae Erisson // dikeluarkan di bawah lesen GPLv3 untuk menandingi seluruh perpustakaan AdaFruit NeoPixel yang lain

#sertakan

#ifdef _AVR_ #masuk #endif

// Pin mana di Arduino yang disambungkan ke NeoPixels?

// Pada Trinket atau Gemma, kami mencadangkan menukarnya menjadi 1 #define PIN 9

// Berapa banyak NeoPixels yang dilekatkan pada Arduino?

#tentukan NUMPIXELS 16

// Semasa kami menyiapkan perpustakaan NeoPixel, kami memberitahu berapa piksel dan pin mana yang akan digunakan untuk mengirim isyarat.

// Perhatikan bahawa untuk jalur NeoPixel yang lebih tua, anda mungkin perlu mengubah parameter ketiga - lihat contoh strandtest // untuk maklumat lebih lanjut mengenai kemungkinan nilai. Piksel Adafruit_NeoPixel = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // kelewatan selama 50ms

// Pemboleh ubah mewarnakan aleatorios

#kemasukan #ifdef _AVR_ #masuk #endif

#tentukan PIN 9

#tentukan NUM_LEDS 16

#tentukan BRIGHTNESS 200

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

bait 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 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/ PENYEDIAAN METODO

batal persediaan () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // alamat akselerometer // tetapan julat Wire.write (0x22); // alamat pendaftaran Wire.write (julat); // dapat diatur pada "0x00" "0x01" "0x02" "0x03", rujuk Lembaran Data di wiki // penapis lulus rendah Wire.write (0x20); // alamat pendaftaran Wire.write (0x05); // boleh diatur di "0x05" "0x04" …… "0x01" "0x00", rujuk Lembaran Data di wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Ini untuk Trinket 5V 16MHz, anda boleh membuang ketiga baris ini jika anda tidak menggunakan Trinket #if yang ditentukan (_AVR_ATtiny85_) jika (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Akhir kod khas jalur perhiasan.begin (); strip.show (); // Memulakan semua piksel untuk 'mati'

// Código Rueda de colores

// Ini untuk Trinket 5V 16MHz, anda boleh membuang ketiga baris ini jika anda tidak menggunakan Trinket #if yang ditentukan (_AVR_ATtiny85_) jika (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Akhir kod khas perhiasan

piksel.begin (); // Ini memulakan perpustakaan NeoPixel.

// Codigo Gangguan

pembilang = 1;

// Vario Codigo Colores

// Ini untuk Trinket 5V 16MHz, anda boleh membuang ketiga baris ini jika anda tidak menggunakan Trinket #if yang ditentukan (_AVR_ATtiny85_) jika (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Hujung jalur kod khas perhiasan.setBrightness (BRIGHTNESS); jalur.begin (); strip.show (); // Memulakan semua piksel untuk 'mati'}

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

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

/ Bucle infinito

gelung kekosongan () {// Caso 1: Juego de luces de la gravedad; jika (pembilang == 1) {untuk (int i = 0; i 0.0) {if (nx 0.0) sudut + = 180; sudut lain + = 360; } // hujung yang lain jika (sudut == 360.0) sudut = 0.0; led = membulatkan (sudut / (360 / NUMBER_OF_LEDS_ON_RING)); // jadikan pergerakan led lancar jika (previousLed == led) {// tiada kaitan} yang lain jika (counterClockwiseDistanceBetweenLeds (sebelumnyaLed, led) <= 8) led = circularize (sebelumnyaLed + 1); lain dipimpin = edarkan (sebelumnyaLed - 1); ledQueue.push (dipimpin); buatLightShow (); sebelumnyaLed = dipimpin; kelewatan (25); } kaunter = 2; } // Tamat jika pembilang == 1 // Caso 2: Codigo del juego de luces del arcoiris lain jika (kaunter == 2) {untuk (int j = 0; j <5; j ++) {// Beberapa contoh prosedur menunjukkan cara memaparkan ke piksel: colorWipe1 (strip. Color (255, 0, 0), 50); // Warna merah Lap 1 (jalur. Warna (0, 255, 0), 50); // Warna hijauWipe1 (jalur. Warna (0, 0, 255), 50); // Warna biruWipe1 (jalur. Warna (0, 0, 0, 255), 50); // White RGBW // Hantar piksel teater di… theatreChase (strip. Color (127, 127, 127), 50); // Teater putihChase (jalur. Warna (127, 0, 0), 50); // Red theatreChase (strip. Color (0, 0, 127), 50); // Biru

pelangi (5);

RainbowCycle (5); teaterChaseRainbow (5); } kaunter = 3; } // Tamat jika pembilang == 2 // Caso 3: Suka Aleatorias lain jika (pembilang == 3) {untuk (int k = 0; k <50; k ++) {// Untuk sekumpulan NeoPixels, NeoPixel pertama adalah 0, kedua adalah 1, hingga jumlah piksel tolak satu. int a = rawak (255); int b = rawak (255); int c = rawak (255); untuk (int i = 0; i

// piksel. Warna mengambil nilai RGB, dari 0, 0, 0 hingga 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Warna hijau terang yang sederhana.

piksel.show (); // Ini menghantar warna piksel yang dikemas kini ke perkakasan.

kelewatan (delayval); // Kelewatan untuk jangka masa (dalam milisaat).

} a = rawak (255); b = rawak (255); c = rawak (255); untuk (int i = NUMPIXELS; i> 0; i -) {

// piksel. Warna mengambil nilai RGB, dari 0, 0, 0 hingga 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Warna hijau terang yang sederhana.

piksel.show (); // Ini menghantar warna piksel yang dikemas kini ke perkakasan.

kelewatan (delayval); // Kelewatan untuk jangka masa (dalam milisaat).

}} pembilang = 4; } lain jika (pembilang == 4) {untuk (int g = 0; g <= 6; g ++) {// Beberapa contoh prosedur yang menunjukkan cara memaparkan ke piksel: colorWipe (strip. Color (255, 0, 0), 50); // Warna merah Lap (jalur. Warna (0, 255, 0), 50); // Warna hijau Lap (jalur. Warna (0, 0, 255), 50); // Warna biruWipe (strip. Color (0, 0, 0, 255), 50); // Putih putihOverRainbow (20, 75, 5); nadiWhite (5); // fullWhite (); // kelewatan (2000); pelangiFade2White (3, 3, 1);

}

pembilang = 1; }} //////////////////////////////////////////////// ////////////////////////////////// /////////////// ////////////////////////////////////////////////// /////////////////

/ Metodos del Ejemplo de la gravedad

batal AccelerometerInit () {Wire.beginTransmission (0x0A); // alamat accelerometer // tetapkan semula accelerometer Wire.write (0x04); // X data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // permintaan 6 bait dari peranti hamba # 2 sementara (Wire.available ()) // hamba boleh menghantar kurang daripada yang diminta {Versi [0] = Wire.read (); // terima bait sebagai ciri} x_data = (int8_t) Versi [0] >> 2; Wire.beginTransmission (0x0A); // alamat accelerometer // tetapkan semula accelerometer Wire.write (0x06); // Y data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // permintaan 6 bait dari peranti hamba # 2 sementara (Wire.available ()) // hamba boleh menghantar lebih sedikit daripada yang diminta {Versi [1] = Wire.read (); // terima bait sebagai ciri} y_data = (int8_t) Versi [1] >> 2; Wire.beginTransmission (0x0A); // alamat accelerometer // tetapkan semula accelerometer Wire.write (0x08); // Z data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // permintaan 6 bait dari peranti hamba # 2 sementara (Wire.available ()) // hamba boleh menghantar kurang daripada yang diminta {Versi [2] = Wire.read (); // terima bait sebagai ciri} z_data = (int8_t) Versi [2] >> 2; x = (terapung) x_data / divi; y = (terapung) y_data / divi; z = (terapung) z_data / divi; Serial.print ("X ="); Cetakan bersiri (x); // cetak watak Serial.print (""); Serial.print ("Y ="); Cetakan bersiri (y); // cetak watak Serial.print (""); Serial.print ("Z ="); // cetak watak Serial.println (z); }

int edarkan (int pos) {

jika (pos> = NUMBER_OF_LEDS_ON_RING) kembali (pos - NUMBER_OF_LEDS_ON_RING); lain jika (pos <0) kembali (pos + NUMBER_OF_LEDS_ON_RING); lain kembali (pos); }

jarak int;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {jarak = nextPos - prevPos; jika (jarak <0) jarak + = NUMBER_OF_LEDS_ON_RING; kembali (jarak); }

int ledPosition, currentQueueSize;

#tentukan NUMBER_OF_LEDS_TO_SHINE 10 int kecerahanLangkah = 255 / NUMBER_OF_LEDS_TO_SHINE;

batal makeLightShow () {

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

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

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

/ Metodos del juego de luces del arcoiris

// Isi titik satu demi satu dengan warna kekosongan warnaWipe (uint32_t c, uint8_t waiting) {untuk (uint16_t i = 0; i

kekosongan pelangi (uint8_tunggu) {

uint16_t i, j;

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

// Sedikit berbeza, ini menjadikan pelangi sama rata di seluruh

kekosongan pelangi kosong (uint8_t tunggu) {uint16_t i, j;

untuk (j = 0; j <256 * 5; j ++) {// 5 kitaran semua warna pada roda untuk (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); kelewatan (tunggu); }}

// Lampu merangkak gaya teater.

void theatreChase (uint32_t c, uint8_t waiting) {untuk (int j = 0; j <10; j ++) {// lakukan 10 kitaran mengejar (int q = 0; q <3; q ++) {untuk (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, c); // hidupkan setiap piksel ketiga} strip.show ();

kelewatan (tunggu);

untuk (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // matikan setiap piksel ketiga}}}}

// Lampu merangkak gaya teater dengan kesan pelangi

void theatreChaseRainbow (uint8_t waiting) {untuk (int j = 0; j <256; j ++) {// kitar semua 256 warna pada roda untuk (int q = 0; q <3; q ++) {untuk (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, Wheel ((i + j)% 255)); // hidupkan setiap piksel ketiga} strip.show ();

kelewatan (tunggu);

untuk (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // matikan setiap piksel ketiga}}}}

// Masukkan nilai 0 hingga 255 untuk mendapatkan nilai warna.

// Warna adalah peralihan r - g - b - kembali ke r. uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; jika (WheelPos <85) {jalur balik. Warna (255 - WheelPos * 3, 0, WheelPos * 3); } jika (WheelPos <170) {WheelPos - = 85; jalur balik. Warna (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos - = 170; jalur balik. Color (WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/ Metodos Rueda de colores

// int elegirColor = acak (0x000000, 0xffffff); // Se ele aleatoriamente entre toda la gama de colores includeendre entre 0x000000 y 0xFFFFFF

// CylonEyeColor = HtmlColor (elegirColor); // int elegirColor = rawak (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 (//xff00) // if (elegirColor == 5) CylonEyeColor = HtmlColor (0x200020); // Morado // if (elegirColor == 6) CylonEyeColor = HtmlColor (0x00ffff); // Azul Claro // if (elegirColor == 7) CylonEyeCol HtmlColor (0x100010); // Rosa // CylonEyeColor = HtmlColor (0x000000);

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

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

/ Metodos mengurangkan variasi

// Isi titik satu demi satu dengan warna

void colorWipe1 (uint32_t c, uint8_t waiting) {untuk (uint16_t i = 0; i

kekosongan nadiWhite (uint8_tunggu) {

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

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

untuk (uint16_t i = 0; i

batal pelangiFade2White (uint8_tunggu, int rainbowLoops, int whiteLoops) {

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

untuk (int k = 0; k <rainbowLoops; k ++) {untuk (int j = 0; j <256; j ++) {// 5 kitaran semua warna pada roda

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

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

redVal = merah (wheelVal) * apungan (fadeVal / fadeMax);

greenVal = hijau (wheelVal) * apungan (fadeVal / fadeMax); blueVal = biru (wheelVal) * apungan (fadeVal / fadeMax);

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

}

// Gelung pertama, pudar!

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

// Gelung terakhir, pudar!

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

strip.show ();

kelewatan (tunggu); }}

kelewatan (500);

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

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

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

kelewatan (2000);

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

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

kelewatan (500);

}

batal putihOverRainbow (uint8_t tunggu, uint8_t whiteSpeed, uint8_t whiteLength) {

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

int kepala = putih Panjang - 1;

int ekor = 0;

gelung int = 3;

int loopNum = 0;

LastTime long static unsigned = 0;

sementara (benar) {

untuk (int j = 0; j <256; j ++) {untuk (uint16_t i = 0; i = ekor && i kepala && i> = ekor) || (ekor> kepala && i <= kepala)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } lain {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); }}

jika (milis () - LastTime> whiteSpeed) {

kepala ++; ekor ++; jika (head == strip.numPixels ()) {loopNum ++; } lastTime = milis (); }

jika (loopNum == gelung) kembali;

kepala% = strip.numPixels (); ekor% = strip.numPixels (); strip.show (); kelewatan (tunggu); }}} batal fullWhite () {untuk (uint16_t i = 0; i

// Sedikit berbeza, ini menjadikan pelangi sama rata di seluruh

batal pelangiCycle1 (uint8_t tunggu) {uint16_t i, j;

untuk (j = 0; j <256 * 5; j ++) {// 5 kitaran semua warna pada roda untuk (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); kelewatan (tunggu); }}

batal pelangi1 (uint8_tunggu) {

uint16_t i, j;

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

// Masukkan nilai 0 hingga 255 untuk mendapatkan nilai warna.

// Warna adalah peralihan r - g - b - kembali ke r. uint32_t Wheel1 (byte WheelPos) {WheelPos = 255 - WheelPos; jika (WheelPos <85) {jalur balik. Warna (255 - WheelPos * 3, 0, WheelPos * 3, 0); } jika (WheelPos <170) {WheelPos - = 85; jalur pengembalian. Warna (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos - = 170; jalur balik. Color (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t merah (uint32_t c) {

kembali (c >> 16); } uint8_t hijau (uint32_t c) {kembali (c >> 8); } uint8_t biru (uint32_t c) {kembali (c); }

Langkah 8: Reka Bentuk 3D

Pertama, anda mesti mengukur komponen perkakasan anda untuk memastikan yang betul. Sekiranya fail itu sama dengan kami, anda boleh menggunakan fail yang sama dengan yang kami pinjamkan kepada anda.

Kedua-dua sokongan telah dirancang dengan pencetak 3D, yang juga disertakan sebagai:

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

Akhirnya, cahaya akan menjadi seperti dua gambar terakhir.

Langkah 9: Memasang Leher

Pertama kita akan meletakkan pelana di leher. Lubang yang perlu disekat oleh skru tidak ada, jadi kita harus membuatnya, menandakan ke mana mereka harus pergi dan berhati-hati, dengan auger, membuat lubang.

Perkara yang sama berlaku untuk lubang di mana skru yang menahan leher itu sendiri ke badan instrumen. Tidak perlu melakukannya, kerana tidak ada sekrup untuk pengancing ini, tetapi jika kita mahu melakukannya, tidak akan ada masalah.

PENTING: tinggalkan 5mm ruang antara permulaan tiang dan permulaan garpu penalaan, kerana di lubang itu kacang akan diletakkan.

Kami akan merekatkan kacang dengan gam, ke arah yang ditunjukkan oleh gambar.

Akhirnya, kami akan memperkenalkan 4 pin di lubang yang terdapat di awal tiang, memegang setiap pin dengan 2 skru pendek seperti yang ditunjukkan dalam gambar.

Langkah 10: Memasang Birdge

Jambatan dipasang dengan melekatkan dan dengan kedua skru panjang di kedudukan tengah pada badan. Sebaiknya tandakan dengan pensil kedudukan yang betul di badan. Kami akan mengambil jarak yang ditandai dalam gambar.

Kami akan menggunakan gam pada penyatuan kedua-dua komponen tersebut. Kami membetulkan kedua-dua bahagian dengan berhati-hati dengan bantuan skru pengetat sehingga sendi kering. Kami akan membuat dua lubang untuk skru dengan bit gerudi 1.5mm untuk kayu. Betulkan jambatan dengan dua skru panjang di badan. Dan akhirnya, kami meletakkan penutup pelindung di kepala skru.

Langkah 11: Pemasangan Badan dan Leher

Untuk memasang dua bahagian, kita mempunyai lubang di kepala badan, di mana leher akan sesuai dengan dua unjuran yang ada. Kita boleh merekatkannya dengan gam atau dengan pistol lebur panas. Untuk mempunyai fiksasi yang lebih besar, anda boleh membuat lubang yang ada di hujung garpu penala untuk menyambungkannya ke badan.

Langkah 12: Masukkan Tali Ukulele

Akhirnya kita harus meletakkan tali supaya instrumen kita selesai.

Sebelum ini kita akan memasukkan cincin pemasangan pin dalam unjuran yang melewati tiang. Untuk meletakkan tali, kami mengambil 4 tali yang disertakan dengan kit. Mula-mula anda harus membezakan setiap rentetan kerana semuanya tidak sama. Anda mesti mengikat satu hujung setiap tali (dua yang tebal dengan simpul biasa, dan dua yang nipis dengan tali ganda) dan memasukkan tali ke dalam slot jambatan.

Kemudian kita akan meletakkan tali sedemikian rupa sehingga:

• Kedudukan pertama: tali G (tali tebal kedua).

• Kedudukan kedua: tali C (tali lebih tebal).

• Kedudukan ketiga: tali E (tali nipis kedua).

• Kedudukan keempat: Rentetan (tali nipis).

Benang tali ke lubang palam yang disediakan. Cuba pasangkan setiap tali dengan memberikan dua atau tiga putaran pada pin. Ketegangan tali tanpa menggunakan terlalu banyak kekuatan dan periksa jarak antara tali dan pelana.

Sekiranya anda mempunyai keraguan tentang bagaimana membuatnya, anda boleh mengetahui tutorial yang menjelaskan cara meletakkan tali dengan betul.

Langkah 13: Menguji

Akhirnya, kita harus melihat apakah ukulele telah dipasang dengan betul sedemikian rupa sehingga jarak ideal pada fret pertama adalah 0.1mm dan pada kedua belas kira-kira 1.2mm.

Diperlukan agar anda menyesuaikan rentetan ukulele. Saya mengesyorkan anda aplikasi ini: GuitarTuna

Langkah 14: Nikmati

Sekarang, anda hanya perlu menikmati ukulele anda.

Sekiranya anda ingin mengetahui lebih banyak maklumat mengenai kami, anda boleh menemui kami di:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc