Tự làm đàn Ukulele điện tử thông minh với Arduino: 14 bước (có hình ảnh)

2024 Tác giả: John Day | [email protected]. Sửa đổi lần cuối: 2024-01-30 13:34

Chúng tôi sẽ giải thích từng bước cách bạn có thể thiết kế đàn ukulele của riêng mình và thêm một số hiệu ứng làm cho nó trở nên độc đáo, chẳng hạn như vẽ thứ gì đó mà chúng tôi muốn lên bề mặt của đàn ukulele hoặc thêm một số hiệu ứng ánh sáng.

Để làm được điều đó, bạn cần mua một bộ đàn ukulele.

Chúng tôi sẽ giải thích cách lắp ráp nhạc cụ và giải quyết các vấn đề khác nhau có thể xuất hiện.

Bước 1: Vật liệu

Vật liệu cấu trúc:

Bộ dụng cụ gắn ukelele tự làm (có thể là một bộ khác khác) được hình thành bởi:

1- Thân máy.

2-Cổ.

3-Yên xe

Hỗ trợ 4 dây

5 cầu

6-Đai ốc dây.

7-Vòng cố định đầu máy (x4).

8-Đầu máy (x4).

9-Vít lắp đầu máy (x8).

10-Vít lắp cầu máy (x2).

11-Nắp đậy cho vít lắp cầu (x2).

12-Chuỗi (x4).

Vật liệu điện tử:

• NANO Arduino.
• Bánh xe Led WS2812.
• Gia tốc kế BMA220 (tùy chọn).
• Đầu nối pin.
• Pin 9V.
• Chuyển.

Khác

• Vecni gỗ.
• Khóa dán.
• Thiếc hàn.
• Nhựa bảo vệ để đánh vecni.
• Silicone nóng chảy.

Công cụ:

• Khắc laser.
• Giấy nhám
• Tuốc nơ vít hình sao.
• Cọ sơn.
• Súng nóng chảy.
• Mỏ hàn thiếc.

Bước 2: Tùy chỉnh đàn Ukulele

Để tăng giá thành cho cây đàn ukulele của mình, chúng tôi có thể tạo một bản khắc hình vẽ bằng máy cắt laser trên thân đàn. Trong trường hợp không có công cụ đó, chúng ta có thể vẽ nó.

Hình ảnh mà chúng tôi đã chọn là hình ảnh đầu tiên xuất hiện.

Trước hết phải thiết kế mẫu bản vẽ để thực hiện bản khắc.

Để thực hiện điều đó, chúng tôi sẽ sử dụng một phần mềm có tên là 'Inkscape' mà chúng tôi có thể lấy từ liên kết này:

Để sử dụng nó, chúng tôi phải điều chỉnh hình ảnh mà chúng tôi muốn sử dụng giống như chúng tôi hiển thị trong hình ảnh thứ hai. Bạn có thể thấy rằng chúng tôi đã xoay hình ảnh ban đầu để có thể điều chỉnh biểu bì của bàn tay với vòng tròn của nhạc cụ. Giống như chúng tôi đã nói trước đây, bạn có thể đặt bất kỳ hình ảnh nào.

Bước 3: Vectorize một hình ảnh bằng Inkscape

Chúng ta sẽ xem cách tạo tệp vectơ từ ảnh pixmap (jpg, png, bất kỳ định dạng raster nào mà Inkscape có thể mở).

Inkscape Inkscape là một trình chỉnh sửa đồ họa vector mã nguồn mở và như tiêu đề của nó, đây là công cụ mà tôi sẽ sử dụng để vectơ biểu trưng. Các bước tạo vectơ Các bước phổ biến đối với bất kỳ thao tác vectơ nào mà chúng tôi có thể muốn thực hiện.

1. Mở hình ảnh trong Inkscape
2. Mở Đường dẫn công cụ Bitmap Trace-> Trace Bitmap
3. Chơi xung quanh các tùy chọn Bản đồ bit theo dõi
4. Chạy theo dõi
5. Xóa kết quả (nếu cần)

Lưu ý phần "chơi xung quanh". Tôi không phải là chuyên gia về truy tìm, vì vậy tôi coi công cụ này như một hộp đen với các nút bấm và đèn, xoay và thay đổi cho đến khi tôi nhận được kết quả tốt nhất

Bước 4: Khắc logo

Đối với điều này, điều quan trọng là phải có hình bóng của bề mặt mà trên đó bản khắc của bản vẽ sẽ được tạo ra.

Để thực hiện việc khắc, chúng tôi sẽ sử dụng phần mềm 'T2Laser'. Chúng tôi có thể lấy phần mềm này từ:

Khi chúng ta đã mở phần mềm, chúng ta phải tải hình ảnh mà chúng ta đã tạo ở bước cuối cùng. Sau đó, nhấn nút "điều khiển laser", và xuất hiện các điều khiển cnc. Hai hình ảnh cho thấy quá trình và kết quả của việc khắc bằng máy cắt laser của chúng tôi.

Bước 5: Chà nhám và hoàn thiện

Để cây đàn ukulele của chúng ta sáng và có lớp không nhám, chúng ta có thể chà nhám hai phần tạo nên cây đàn một cách cẩn thận, bởi vì chúng ta có thể làm hỏng hình vẽ đã được thực hiện (nếu bạn đã chọn sơn ukulele, bạn sẽ phải cát nó trước). Sau đó, chúng tôi sẽ đánh vecni cho hai bộ phận của mình để chúng có màu sẫm hơn và gỗ có sức đề kháng cao hơn. Chúng ta có thể sử dụng một loại sơn bóng gỗ bình thường, không cần quá đặc biệt.

Khi chúng ta đã có lớp sơn bóng, chúng ta trộn nó với một ít dung môi để nó hòa tan một chút. Tiếp theo, chúng ta bôi hỗn hợp bằng cọ lên cổ và thân đàn rồi để khô.

Nếu thấy sản phẩm cần sơn lớp thứ hai, chúng ta có thể chà nhám hai phần một chút và quét lại một lớp dầu bóng đã pha loãng.

** THẬN TRỌNG: Dầu bóng là sản phẩm hóa học nên cần thực hiện quy trình này ở nơi thoáng gió, đeo khẩu trang để tránh hít phải mùi hôi và đeo kính bảo vệ.

Vật liệu mà chúng ta cần để có thể hoạt động chính xác là những vật liệu xuất hiện trong ảnh. Chủ yếu chúng tôi sẽ làm việc với một bàn chải, một lon sơn bóng (trong trường hợp của chúng tôi là màu đỏ), một ít dung môi và bảo vệ thị giác. Và hơn hết là hoạt động trong không gian thông thoáng.

Bước 6: Phần cứng

Tấm bảng của chúng tôi với Arduino, acelerometer và bánh xe có đèn led sẽ được giới thiệu trong một khung nhỏ để tránh tất cả các thành phần di chuyển trong thiết bị.

Chúng tôi cũng đã thêm một giá đỡ pin và một công tắc để làm cho nó thoải mái hơn và chúng tôi không làm hao pin khi chúng tôi không sử dụng thiết bị. Chúng tôi sẽ gắn giá đỡ này bằng một miếng Velcro (nó cũng hoạt động với silicone và súng nóng chảy) vào mặt trong của thân ukulele. Mặt khác, bánh xe LED nhỏ hơn lỗ nên nó sẽ rơi. Một giá đỡ đã được thiết kế để nó giữ tốt và có thể thực hiện chức năng của nó.

Bước 7: Phần mềm

Để trang trí đặc biệt cho đàn ukulele của chúng tôi, chúng tôi có thể thêm hiệu ứng ánh sáng nhờ một bánh xe đèn led. Chúng tôi sẽ sử dụng WS2812, nhưng bạn có thể sử dụng bất kỳ mã nào khác theo hướng dẫn của biểu dữ liệu. Chúng tôi cũng sẽ sử dụng một máy đo gia tốc (BMA220), cho phép chúng tôi tạo ra ảnh hưởng của lực hấp dẫn.

Trên thực tế, chúng ta sẽ có 4 lần phát ánh sáng, có trong thư viện máy tính có tên 'Adafruit' của Arduino. Để đạt được điều đó, chúng ta phải thực hiện một sự kết hợp chính xác giữa ba thành phần: Arduino NANO, WS2812 và BMA220, giống như xuất hiện trong hình ảnh đầu tiên.

Các dây màu đỏ dùng để cấp nguồn, các dây màu đen GND và phần còn lại là các kết nối cần thiết để hoạt động chính xác. Mã mà chúng tôi sử dụng cho bộ đèn được đính kèm trong một tệp có tên "play_of_light_v0.ino". Đảm bảo rằng bạn đã bao gồm các thư viện cần thiết để chương trình hoạt động chính xác. Pin mà chúng ta thêm bên ngoài vào mạch phải có điện áp tối thiểu là 9V và chúng ta phải đảm bảo rằng nó có khả năng cung cấp dòng điện tối thiểu cần thiết để cung cấp năng lượng cho toàn bộ mạch.

// Biến contador e bộ đếm interrupciónint; // Biến Ejemplo gravedad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

Phiên bản byte [3];

int8_t x_data; int8_t y_data; int8_t z_data; phạm vi byte = 0x00; float divi = 16; float x, y, z; float pi = 3,14159265359; float nx, ny, angle; int đã dẫn, trước đóLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Biến Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Tham số 1 = số pixel trong dải // Tham số 2 = số chân Arduino (hầu hết đều hợp lệ) // Tham số 3 = cờ loại pixel, thêm vào nhau nếu cần: // Dòng bit NEO_KHZ800 800 KHz (hầu hết các sản phẩm NeoPixel có đèn LED WS2812) // NEO_KHZ400 400 KHz (pixel 'v1' (không v2) FLORA cổ điển, trình điều khiển WS2811) // Các điểm ảnh NEO_GRB có dây cho dòng bit GRB (hầu hết các sản phẩm NeoPixel) / / NEO_RGB Điểm ảnh được nối dây cho dòng bit RGB (pixel v1 FLORA, không phải v2) // Điểm ảnh NEO_RGBW được nối dây cho dòng bit RGBW (sản phẩm NeoPixel RGBW) Dải Adafruit_NeoPixel = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // QUAN TRỌNG: Để giảm nguy cơ cháy NeoPixel, hãy thêm tụ điện 1000 uF qua // dẫn nguồn pixel, thêm điện trở 300 - 500 Ohm trên đầu vào dữ liệu của pixel đầu tiên // và giảm thiểu khoảng cách giữa Arduino và pixel đầu tiên. Tránh kết nối // trên mạch trực tiếp… nếu bạn phải kết nối GND trước.

// Các biến Rueda de colores

// Bản phác thảo đơn giản NeoPixel Ring (c) 2013 Shae Erisson // được phát hành theo giấy phép GPLv3 để khớp với phần còn lại của thư viện AdaFruit NeoPixel

#bao gồm

#ifdef _AVR_ #include #endif

// Chân nào trên Arduino được kết nối với NeoPixels?

// Trên Trinket hoặc Gemma, chúng tôi khuyên bạn nên thay đổi mã này thành 1 mã PIN #define 9

// Có bao nhiêu NeoPixel được gắn vào Arduino?

#define NUMPIXELS 16

// Khi chúng tôi thiết lập thư viện NeoPixel, chúng tôi sẽ cho nó biết có bao nhiêu pixel và chân nào sẽ sử dụng để gửi tín hiệu.

// Lưu ý rằng đối với các dải NeoPixel cũ hơn, bạn có thể cần thay đổi tham số thứ ba - hãy xem ví dụ // strandtest để biết thêm thông tin về các giá trị có thể có. Adafruit_NeoPixel pixel = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // độ trễ trong 50ms

// Các biến tô màu aleatorios

#include #ifdef _AVR_ #include #endif

#define mã PIN 9

#define NUM_LEDS 16

#define BRIGHTNESS 200

// Dải Adafruit_NeoPixel = Adafruit_NeoPixel (NUM_LEDS, mã 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 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/ THIẾT LẬP METODO

void setup () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // địa chỉ của máy đo gia tốc // cài đặt phạm vi Wire.write (0x22); // đăng ký địa chỉ Wire.write (range); // có thể được đặt ở "0x00" "0x01" "0x02" "0x03", tham khảo Datashhet trên wiki // bộ lọc thông thấp Wire.write (0x20); // đăng ký địa chỉ Wire.write (0x05); // có thể được đặt tại "0x05" "0x04" …… "0x01" "0x00", tham khảo Datashhet trên wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Đây là cho Trinket 5V 16MHz, bạn có thể loại bỏ ba dòng này nếu bạn không sử dụng Trinket #if được định nghĩa (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Kết thúc dải mã đặc biệt trinket.begin (); dải.show (); // Khởi tạo tất cả các pixel thành 'tắt'

// Código Rueda de colores

// Đây là cho Trinket 5V 16MHz, bạn có thể loại bỏ ba dòng này nếu bạn không sử dụng Trinket #if được định nghĩa (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Kết thúc mã đặc biệt của trang sức

pixel.begin (); // Thao tác này khởi tạo thư viện NeoPixel.

// Ngắt Codigo

bộ đếm = 1;

// Codigo Colores varios

// Đây là cho Trinket 5V 16MHz, bạn có thể loại bỏ ba dòng này nếu bạn không sử dụng Trinket #if được định nghĩa (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Kết thúc đoạn mã đặc biệt trinket.setBrightness (BRIGHTNESS); dải.begin (); dải.show (); // Khởi tạo tất cả các pixel thành 'off'}

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

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

/ Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (counter == 1) {for (int i = 0; i 0.0) {if (nx 0.0) angle + = 180; góc khác + = 360; } // kết thúc else if (angle == 360.0) angle = 0.0; led = vòng quay (góc / (360 / NUMBER_OF_LEDS_ON_RING)); // làm cho chuyển động của đèn led trơn tru if (beforeLed == led) {// không cần làm gì} else if (counterClockwiseDistanceBetweenLeds (beforeLed, led) <= 8) led = cyclearize (beforeLed + 1); else led = cyclearize (trước đóLed - 1); ledQueue.push (đã dẫn); makeLightShow (); beforeLed = đã dẫn; chậm trễ (25); } truy cập = 2; } // Kết thúc if counter == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Một số thủ tục ví dụ hiển thị cách hiển thị tới các pixel: colorWipe1 (dải. Color (255, 0, 0), 50); // Red colorWipe1 (dải. Color (0, 255, 0), 50); // Màu xanh lá cây colorWipe1 (dải. Color (0, 0, 255), 50); // Màu xanh lam colorWipe1 (dải. Color (0, 0, 0, 255), 50); // Màu trắng RGBW // Gửi theo đuổi pixel rạp hát trong… TheaterChase (dải. Color (127, 127, 127), 50); // White TheaterChase (dải. Color (127, 0, 0), 50); // Red TheaterChase (dải. Color (0, 0, 127), 50); // Màu xanh dương

cầu vồng (5);

cầu vồngCycle (5); rạp hátChaseRainbow (5); } truy cập = 3; } // Kết thúc if counter == 2 // Caso 3: Luces Aleatorias else if (counter == 3) {for (int k = 0; k <50; k ++) {// Đối với một tập hợp các NeoPixel, NeoPixel đầu tiên là 0, giây là 1, tính đến số pixel trừ đi một. int a = random (255); int b = random (255); int c = random (255); for (int i = 0; i

// pixel. Color nhận các giá trị RGB, từ 0, 0, 0 cho đến 255, 255, 255

pixel.setPixelColor (i, pixel. Color (a, b, c)); // Màu xanh lục sáng vừa phải.

pixel.show (); // Điều này sẽ gửi màu pixel được cập nhật đến phần cứng.

sự chậm trễ (delayval); // Trì hoãn trong một khoảng thời gian (tính bằng mili giây).

} a = random (255); b = ngẫu nhiên (255); c = ngẫu nhiên (255); for (int i = NUMPIXELS; i> 0; i -) {

// pixel. Color nhận các giá trị RGB, từ 0, 0, 0 lên đến 255, 255, 255

pixel.setPixelColor (i, pixel. Color (a, b, c)); // Màu xanh lục sáng vừa phải.

pixel.show (); // Điều này sẽ gửi màu pixel được cập nhật đến phần cứng.

sự chậm trễ (delayval); // Trì hoãn trong một khoảng thời gian (tính bằng mili giây).

}} truy cập = 4; } else if (counter == 4) {for (int g = 0; g <= 6; g ++) {// Một số quy trình ví dụ chỉ ra cách hiển thị tới các pixel: colorWipe (dải. Color (255, 0, 0), 50); // Màu đỏ colorWipe (dải. Color (0, 255, 0), 50); // Màu xanh lá cây colorWipe (dải. Color (0, 0, 255), 50); // Màu xanh lam colorWipe (dải. Color (0, 0, 0, 255), 50); // Màu trắng whiteOverRainbow (20, 75, 5); xungWhite (5); // fullWhite (); // delay (2000); RainbowFade2White (3, 3, 1);

}

bộ đếm = 1; }} ////////////////////////////////////////////////////// /////////////////////////////////////////////////////// //////////////////////////////////////////////////////// ///////////////////

/ Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // địa chỉ của gia tốc kế // đặt lại gia tốc kế Wire.write (0x04); // Dữ liệu X Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // yêu cầu 6 byte từ thiết bị tớ # 2 trong khi (Wire.available ()) // tớ có thể gửi ít hơn yêu cầu {Version [0] = Wire.read (); // nhận một byte như là đặc tính} x_data = (int8_t) Phiên bản [0] >> 2; Wire.beginTransmission (0x0A); // địa chỉ của gia tốc kế // đặt lại gia tốc kế Wire.write (0x06); // Dữ liệu Y Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // yêu cầu 6 byte từ thiết bị tớ # 2 trong khi (Wire.available ()) // tớ có thể gửi ít hơn yêu cầu {Version [1] = Wire.read (); // nhận một byte như là đặc tính} y_data = (int8_t) Phiên bản [1] >> 2; Wire.beginTransmission (0x0A); // địa chỉ của gia tốc kế // đặt lại gia tốc kế Wire.write (0x08); // Dữ liệu Z Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // yêu cầu 6 byte từ thiết bị tớ # 2 trong khi (Wire.available ()) // tớ có thể gửi ít hơn yêu cầu {Version [2] = Wire.read (); // nhận một byte như là đặc tính} z_data = (int8_t) Phiên bản [2] >> 2; x = (float) x_data / divi; y = (float) y_data / divi; z = (float) z_data / divi; Serial.print ("X ="); Serial.print (x); // in ra ký tự Serial.print (""); Serial.print ("Y ="); Serial.print (y); // in ra ký tự Serial.print (""); Serial.print ("Z ="); // in ra ký tự Serial.println (z); }

int roundarize (int pos) {

if (pos> = NUMBER_OF_LEDS_ON_RING) return (pos - NUMBER_OF_LEDS_ON_RING); else if (pos <0) return (pos + NUMBER_OF_LEDS_ON_RING); else return (pos); }

khoảng cách int;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; if (khoảng cách <0) khoảng cách + = NUMBER_OF_LEDS_ON_RING; trở lại (khoảng cách); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int BrightStep = 255 / NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

for (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

// Tô lần lượt vào các chấm bằng màu void colorWipe (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i

void cầu vồng (uint8_t chờ đã) {

uint16_t tôi, j;

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

// Hơi khác một chút, điều này làm cho cầu vồng được phân bổ đều khắp

void cầu vồngCycle (uint8_t chờ) {uint16_t i, j;

for (j = 0; j <256 * 5; j ++) {// 5 chu kỳ của tất cả các màu trên bánh xe for (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } dải.show (); trì hoãn (chờ đợi); }}

// Đèn bò kiểu rạp hát.

void TheaterChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// thực hiện 10 chu kỳ theo đuổi for (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <dải.numPixels (); i = i + 3) {dải.setPixelColor (i + q, c); // biến mọi pixel thứ ba trên} strip.show ();

trì hoãn (chờ đợi);

for (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // tắt từng pixel thứ ba}}}}

// Đèn bò kiểu rạp hát với hiệu ứng cầu vồng

void TheaterChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// xoay vòng tất cả 256 màu trong bánh xe for (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <dải.numPixels (); i = i + 3) {dải.setPixelColor (i + q, Bánh xe ((i + j)% 255)); // biến mọi pixel thứ ba trên} strip.show ();

trì hoãn (chờ đợi);

for (uint16_t i = 0; i <strip.numPixels (); i = i + 3) {strip.setPixelColor (i + q, 0); // tắt từng pixel thứ ba}}}}

// Nhập giá trị 0 đến 255 để nhận giá trị màu.

// Các màu là sự chuyển đổi r - g - b - trở lại 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; dải trả về. Color (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos - = 170; dải trả về. 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 (ElegantirColor); // int elegirColor = Rand 2) CylonEyeColor = HtmlColor (0x00ff00); // Verde // if (elegirColor == 3) CylonEyeColor = HtmlColor (0x0000ff); // Azul // if (elegirColor == 4) CylonEyeColor = HtmlColor (0xffff00); // Amarillo // if (tao nhã == 5) CylonEyeColor = HtmlColor (0x200020); // Morado // if (tao nhã == 6) CylonEyeColor = HtmlColor (0x00ffff); // Azul Claro // if (tao nhã == 7) CylonEyeColor = HtmlColor (0x100010); // Rosa // CylonEyeColor = HtmlColor (0x000000);

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

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

/ Metodos luces varias

// Tô màu lần lượt vào các chấm

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

void xungWhite (uint8_t chờ) {

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

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

for (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 chu kỳ của tất cả các màu trên bánh xe

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

wheelVal = Bánh xe (((i * 256 / dải.numPixels ()) + j) & 255);

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

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

dải.setPixelColor (i, dải. Color (redVal, greenVal, blueVal));

}

// Vòng lặp đầu tiên, fade in!

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

// Vòng lặp cuối cùng, mờ dần!

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

dải.show ();

trì hoãn (chờ đợi); }}

chậm trễ (500);

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

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

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

chậm trễ (2000);

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

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

chậm trễ (500);

}

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

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

int head = whiteLength - 1;

int tail = 0;

int vòng lặp = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

trong khi (đúng) {

for (int j = 0; j <256; j ++) {for (uint16_t i = 0; i = tail && i head && i> = tail) || (tail> head && i <= head)) {dải.setPixelColor (i, dải. Color (0, 0, 0, 255)); } else {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

đầu ++; đuôi ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == vòng) return;

đầu% = dải.numPixels (); tail% = strip.numPixels (); dải.show (); trì hoãn (chờ đợi); }}} void fullWhite () {for (uint16_t i = 0; i

// Hơi khác một chút, điều này làm cho cầu vồng được phân bổ đều khắp

void RainbowCycle1 (uint8_t chờ) {uint16_t i, j;

for (j = 0; j <256 * 5; j ++) {// 5 chu kỳ của tất cả các màu trên bánh xe for (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } dải.show (); trì hoãn (chờ đợi); }}

void cầu vồng1 (uint8_t chờ đã) {

uint16_t tôi, j;

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

// Nhập giá trị 0 đến 255 để nhận giá trị màu.

// Các màu là sự chuyển đổi r - g - b - trở lại 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; dải trả về. Color (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos - = 170; dải trả về. Color (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t red (uint32_t c) {

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

Bước 8: Thiết kế 3D

Đầu tiên, bạn phải kích thước các thành phần phần cứng của mình để chắc chắn về độ chính xác. Nếu chúng giống với tệp của chúng tôi, bạn có thể sử dụng cùng các tệp mà chúng tôi cho bạn mượn.

Cả hai hỗ trợ đã được thiết kế với một máy in 3D, cũng được bao gồm như:

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

Cuối cùng, ánh sáng sẽ giống như hai bức hình cuối cùng.

Bước 9: Gắn cổ

Đầu tiên, chúng tôi sẽ đặt yên xe vào cổ. Các lỗ mà các vít cần giữ nó không có ở đó, vì vậy chúng tôi sẽ phải tạo chúng, đánh dấu nơi chúng nên đi và cẩn thận, bằng một cái khoan, tạo lỗ.

Điều tương tự cũng áp dụng cho các lỗ mà các vít giữ chính cổ đàn với thân của nhạc cụ. Nó không cần thiết để làm chúng, vì không có vít để buộc này, nhưng nếu chúng tôi muốn làm điều đó, sẽ không có vấn đề gì.

QUAN TRỌNG: để lại khoảng cách 5mm giữa đầu cột buồm và đầu âm thoa, vì trong lỗ đó sẽ đặt đai ốc.

Chúng tôi sẽ dán đai ốc bằng keo, theo hướng được chỉ ra trong hình.

Cuối cùng, chúng tôi sẽ giới thiệu 4 chốt trong các lỗ ở đầu cột buồm, giữ mỗi chốt bằng 2 vít ngắn như trong hình.

Bước 10: Gắn Birdge

Cầu được cố định bằng cách dán và hai vít dài ở vị trí trung tâm trên thân. Nên dùng bút chì đánh dấu vị trí chính xác trên thân. Chúng tôi sẽ thực hiện các khoảng cách được đánh dấu trong hình ảnh.

Chúng tôi sẽ áp dụng keo tại sự kết hợp của hai thành phần. Chúng tôi cố định hai bộ phận một cách cẩn thận với sự trợ giúp của vít siết chặt cho đến khi mối nối đã khô. Chúng tôi sẽ tạo hai lỗ cho vít bằng mũi khoan 1,5mm cho gỗ. Cố định cầu bằng hai vít dài ở thân. Và cuối cùng, chúng tôi đặt các nắp bảo vệ vào đầu của các con vít.

Bước 11: Lắp ráp cơ thể và cổ

Để lắp ráp hai phần, chúng tôi có các lỗ trên đầu của cơ thể, nơi cổ sẽ phù hợp với hai hình chiếu mà nó có. Chúng tôi có thể dán chúng bằng keo hoặc bằng súng nóng chảy. Để có độ cố định cao hơn, bạn có thể tạo các lỗ ở phần cuối của âm thoa để nối nó với thân.

Bước 12: Đặt dây đàn Ukulele

Cuối cùng chúng ta phải đặt dây sao cho cây đàn của chúng ta đã hoàn thành.

Trước đây, chúng tôi sẽ chèn các vòng cố định của các chốt vào các hình chiếu của chúng đi qua cột buồm. Để đặt dây, chúng tôi lấy 4 dây đi kèm với bộ dụng cụ. Đầu tiên bạn phải phân biệt từng chuỗi vì chúng không giống nhau. Bạn phải buộc một đầu của mỗi dây (hai dây dày thắt nút bình thường và hai dây mỏng thắt nút đôi) và luồn dây vào các khe của cây cầu.

Sau đó, chúng tôi sẽ đặt các chuỗi theo cách:

• Vị trí đầu tiên: Chuỗi G (chuỗi dày thứ hai).

• Vị trí thứ hai: Chuỗi C (chuỗi dày hơn).

• Vị trí thứ ba: Chuỗi E (chuỗi thứ hai mỏng hơn).

• Vị trí thứ tư: Một chuỗi (chuỗi mỏng hơn).

Luồn dây vào các lỗ của phích cắm được cung cấp. Cố gắng cố định từng sợi dây bằng cách bật hai hoặc ba vòng trên chốt. Căng dây mà không cần tác dụng quá nhiều lực và kiểm tra khoảng cách giữa dây và yên xe.

Nếu bạn có bất kỳ nghi ngờ nào về cách tạo ra điều đó, bạn có thể tìm hiểu hướng dẫn đó giải thích cho bạn cách đặt đúng các chuỗi.

Bước 13: Kiểm tra

Cuối cùng, chúng ta phải xem liệu cây đàn ukulele đã được lắp ráp đúng cách sao cho khoảng cách lý tưởng trên phím đàn đầu tiên là 0,1mm và trên phím thứ 12 là khoảng 1,2mm hay chưa.

Điều cần thiết là bạn chỉnh dây đàn ukulele. Tôi giới thiệu cho bạn ứng dụng này: GuitarTuna

Bước 14: Tận hưởng nó

Bây giờ, bạn chỉ cần thưởng thức ukulele của bạn.

Nếu bạn muốn biết thêm thông tin về chúng tôi, bạn có thể tìm thấy chúng tôi tại:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc