DIY Smart Electronic Ukulele พร้อม Arduino: 14 ขั้นตอน (พร้อมรูปภาพ)

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:07

เราจะอธิบายทีละขั้นตอนว่าคุณจะออกแบบอูคูเลเล่ของคุณเองได้อย่างไรและเพิ่มเอฟเฟกต์ที่จะทำให้มีเอกลักษณ์ เช่น การวาดสิ่งที่เราต้องการบนพื้นผิวของอูคูเลเล่หรือเพิ่มเอฟเฟกต์แสง

ในการทำเช่นนั้นจำเป็นต้องซื้อชุดอูคูเลเล่

เราจะอธิบายวิธีการประกอบเครื่องมือและแก้ปัญหาต่างๆ ที่อาจเกิดขึ้น

ขั้นตอนที่ 1: วัสดุ

วัสดุโครงสร้าง:

ชุดติดตั้งอูคูเลเล่ DIY (อาจเป็นชุดอื่น) ที่เกิดจาก:

1- ร่างกาย.

2-คอ.

3-อาน

รองรับ 4 เชือก

5-สะพาน

น๊อต 6 สาย.

7-แหวนยึดหัวเครื่อง (x4)

8-หัวเครื่อง (x4).

สกรูยึด 9 ตัวสำหรับหัวเครื่อง (x8)

สกรูยึด 10 ตัวสำหรับบริดจ์เครื่องจักร (x2)

ฝาปิด 11 อันสำหรับสกรูยึดสะพาน (x2)

12 สตริง (x4)

วัสดุอิเล็กทรอนิกส์:

• นาโน Arduino
• วงล้อไฟ LED WS2812
• มาตรความเร่ง BMA220 (อุปกรณ์เสริม)
• ขั้วต่อแบตเตอรี่
• แบตเตอรี่ 9V.
• สวิตช์.

คนอื่น

• วานิชไม้.
• เวลโคร
• บัดกรีดีบุก
• พลาสติกป้องกันสำหรับเคลือบเงา
• ซิลิโคนร้อนละลาย

เครื่องมือ:

• เลเซอร์แกะสลัก.
• กระดาษทราย
• ไขควงสตาร์
• พู่กัน.
• ปืนร้อนละลาย.
• หัวแร้งบัดกรี.

ขั้นตอนที่ 2: ปรับแต่งอูคูเลเล่

ในการแต่งซอสี่สายของอูคูเลเล่ เราสามารถแกะสลักภาพวาดด้วยเครื่องตัดเลเซอร์บนร่างกาย ในกรณีที่ไม่มีเครื่องมือนั้นเราสามารถทาสีได้

ภาพที่เราเลือกเป็นภาพแรกที่ปรากฏ

ก่อนอื่น เราต้องออกแบบแม่แบบการวาดเพื่อทำการแกะสลัก

ในการดำเนินการดังกล่าว เราจะใช้ซอฟต์แวร์ชื่อ 'Inkscape' ซึ่งเราสามารถหาได้จากลิงก์นี้:

ในการใช้งานเราต้องปรับภาพที่เราต้องการใช้เหมือนที่แสดงในรูปที่สอง คุณสามารถดูว่าเราได้หมุนภาพเริ่มต้นเพื่อปรับ cicle ของมือด้วยวงกลมของเครื่องดนตรี อย่างที่เราพูดไปก่อนหน้านี้ คุณสามารถใส่รูปภาพอะไรก็ได้

ขั้นตอนที่ 3: สร้างภาพเวกเตอร์โดยใช้ Inkscape

เราจะดูวิธีสร้างไฟล์เวกเตอร์จาก pixmap (jpg, png, รูปแบบแรสเตอร์ใดก็ตามที่ Inkscape สามารถเปิดได้)

Inkscape Inkscape เป็นโปรแกรมแก้ไขกราฟิกแบบโอเพนซอร์สแบบโอเพนซอร์ซ และตามความหมายของชื่อ นี่คือเครื่องมือที่ฉันจะใช้เพื่อสร้างโลโก้แบบเวกเตอร์ ขั้นตอนการทำเวคเตอร์ ขั้นตอนเป็นเรื่องปกติสำหรับการทำเวคเตอร์ที่เราอยากทำ

1. เปิดภาพใน Inkscape
2. เปิด Trace Bitmap Tool Path->Trace Bitmap
3. เล่นรอบตัวเลือก Trace Bitmap
4. เรียกใช้การติดตาม
5. ล้างผลลัพธ์ (ถ้าจำเป็น)

สังเกตส่วน "การเล่นรอบ" ฉันไม่ใช่ผู้เชี่ยวชาญในการติดตาม ฉันจึงถือว่าเครื่องมือนี้เป็นกล่องดำที่มีปุ่มและไฟ บิดและเปลี่ยนจนได้ผลลัพธ์ที่ดีที่สุด

ขั้นตอนที่ 4: การแกะสลักโลโก้

สำหรับสิ่งนี้ มันเป็นสิ่งสำคัญที่จะมีเงาของพื้นผิวที่จะสร้างการแกะสลักของภาพวาด

ในการแกะสลัก เราจะใช้ซอฟต์แวร์ 'T2Laser' เราสามารถรับซอฟต์แวร์นี้ได้จาก:

เมื่อเราเปิดซอฟต์แวร์แล้ว เราต้องโหลดภาพที่เราสร้างในขั้นตอนสุดท้าย จากนั้นกดปุ่ม "ควบคุมเลเซอร์" และปรากฏตัวควบคุมซีเอ็นซี ภาพสองภาพแสดงกระบวนการและผลการแกะสลักด้วยเครื่องตัดเลเซอร์ของเรา

ขั้นตอนที่ 5: การขัดและเคลือบเงา

เพื่อให้อูคูเลเล่ของเราสดใสและมีชั้นที่ปราศจากความหยาบ เราสามารถขัดชิ้นส่วนทั้งสองที่ประกอบขึ้นเป็นเครื่องดนตรีของเราได้อย่างราบรื่นด้วยความระมัดระวัง เพราะเราสามารถทำลายรูปวาดที่ทำขึ้นได้ (หากคุณเลือกทาสีอูคูเลเล่ คุณจะต้องทำ ขัดก่อน) จากนั้นเราจะทำการเคลือบเงาทั้งสองส่วนของเราเพื่อให้ได้สีเข้มขึ้นและไม้มีความต้านทานมากขึ้น เราสามารถใช้วานิชไม้ธรรมดาก็ได้ ไม่จำเป็นต้องพิเศษ

เมื่อได้น้ำยาวานิชแล้ว เราก็ผสมกับตัวทำละลายเล็กน้อยเพื่อให้มันละลายเล็กน้อย ต่อไป เราใช้ส่วนผสมด้วยแปรงที่คอและตัวเครื่องมือแล้วปล่อยให้แห้ง

หากเราเห็นว่าผลิตภัณฑ์ต้องการการเคลือบครั้งที่สอง เราสามารถขัดทั้งสองส่วนเล็กน้อยแล้วทาวานิชเจือจางอีกชั้นหนึ่งอีกครั้ง

** ข้อควรระวัง: น้ำยาเคลือบเงาเป็นผลิตภัณฑ์ทางเคมี ดังนั้นจึงจำเป็นต้องดำเนินการในที่ที่มีอากาศถ่ายเท สวมหน้ากากเพื่อหลีกเลี่ยงไม่ให้สูดดมกลิ่นและแว่นตาป้องกัน

วัสดุที่เราต้องการเพื่อให้สามารถทำงานได้อย่างถูกต้องคือวัสดุที่ปรากฏในรูปถ่าย ส่วนใหญ่เราจะใช้แปรง น้ำยาวานิช (ในกรณีของเราคือสีแดง) ตัวทำละลายเล็กน้อยและการปกป้องภาพ และเหนือสิ่งอื่นใด ทำงานในพื้นที่ที่มีการระบายอากาศได้ดี

ขั้นตอนที่ 6: ฮาร์ดแวร์

โล่ประกาศเกียรติคุณของเรากับ Arduino, มาตรความเร่ง และวงล้อพร้อมไฟ LED จะถูกนำมาใช้ในวงเล็บเล็กๆ เพื่อหลีกเลี่ยงไม่ให้ส่วนประกอบทั้งหมดเคลื่อนที่ในเครื่องมือ

เรายังได้เพิ่มที่ใส่แบตเตอรี่และสวิตช์เพื่อให้ใช้งานได้สะดวกยิ่งขึ้น และเราจะไม่ทำให้แบตเตอรี่เสื่อมสภาพเมื่อเราไม่ได้ใช้เครื่องมือ เราจะแนบส่วนรองรับนี้ด้วยแถบเวลโคร (สามารถใช้กับซิลิโคนและปืนร้อนละลายได้) กับใบหน้าด้านในของตัวอูคูเลเล่ ในทางกลับกัน ล้อ LED มีขนาดเล็กกว่ารูจึงตกลงมา. ตัวรองรับได้รับการออกแบบมาเพื่อให้รองรับได้ดีและใช้งานได้จริง

ขั้นตอนที่ 7: ซอฟต์แวร์

เพื่อเป็นการตกแต่งพิเศษให้กับอูคูเลเล่ของเรา เราสามารถเพิ่มเอฟเฟกต์แสงได้ด้วยวงล้อไฟ LED เราจะใช้ WS2812 แต่คุณสามารถใช้สิ่งอื่นๆ โดยทำตามคำแนะนำของแผ่นข้อมูล เราจะใช้มาตรความเร่ง (BMA220) ด้วยเช่นกัน ซึ่งช่วยให้เราสร้างผลกระทบของแรงโน้มถ่วงได้

อันที่จริง เราจะมีการเล่นแสง 4 บท ซึ่งรวมอยู่ในไลบรารีคอมพิวเตอร์ที่เรียกว่า 'Adafruit' ของ Arduino ในการนั้น เราจะต้องสร้างคอนเนกชันที่ถูกต้องระหว่างส่วนประกอบทั้งสาม: Arduino NANO, WS2812 และ BMA220 ดังที่ปรากฏในภาพแรก

สายไฟสีแดงใช้สำหรับจ่ายไฟ ส่วน GND เป็นสีดำ และส่วนที่เหลือเป็นการเชื่อมต่อที่จำเป็นสำหรับการทำงานที่ถูกต้อง รหัสที่เราใช้สำหรับชุดไฟจะแนบมาในไฟล์ชื่อ "play_of_light_v0.ino" ตรวจสอบให้แน่ใจว่าคุณได้รวมไลบรารีที่จำเป็นสำหรับการทำงานที่ถูกต้องของโปรแกรม แบตเตอรี่ที่เราเพิ่มภายนอกวงจรจะต้องมีแรงดันไฟฟ้าขั้นต่ำ 9V และเราต้องตรวจสอบให้แน่ใจว่าสามารถให้กระแสไฟขั้นต่ำที่จำเป็นในการจ่ายไฟให้กับวงจรทั้งหมด

//ตัวแปร contador e interrupciónint เคาน์เตอร์; //ตัวแปร ตัวอย่าง หลุมฝังศพ #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

เวอร์ชันไบต์[3];

int8_t x_data; int8_t y_data; int8_t z_data; ช่วงไบต์ = 0x00; ทุ่น Divi=16; ลอย x, y, z; พายลอย = 3.14159265359; float nx, ny, มุม; int นำ, ก่อนหน้าLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel(NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

//ตัวแปร Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // พารามิเตอร์ 1 = จำนวนพิกเซลในแถบ // พารามิเตอร์ 2 = หมายเลขพิน Arduino (ส่วนใหญ่ถูกต้อง) // พารามิเตอร์ 3 = แฟล็กประเภทพิกเซล รวมกันตามต้องการ: // NEO_KHZ800 800 KHz bitstream (ผลิตภัณฑ์ NeoPixel ส่วนใหญ่ที่มีไฟ LED WS2812) // NEO_KHZ400 400 KHz (คลาสสิก 'v1' (ไม่ใช่ v2) พิกเซล FLORA, ไดรเวอร์ WS2811) // NEO_GRB Pixels ต่อสายสำหรับ GRB bitstream (ผลิตภัณฑ์ NeoPixel ส่วนใหญ่) / / NEO_RGB พิกเซลต่อสายสำหรับบิตสตรีม RGB (พิกเซล FLORA v1 ไม่ใช่ v2) // NEO_RGBW พิกเซลต่อสายสำหรับบิตสตรีม RGBW (ผลิตภัณฑ์ NeoPixel RGBW) แถบ Adafruit_NeoPixel = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // สำคัญ: เพื่อลดความเสี่ยงในการหมดไฟของ NeoPixel ให้เพิ่มตัวเก็บประจุ 1000 uF ทั่วทั้ง // สายไฟของพิกเซล เพิ่มตัวต้านทาน 300 - 500 โอห์มในการป้อนข้อมูลของพิกเซลแรก // และลดระยะห่างระหว่าง Arduino และพิกเซลแรก หลีกเลี่ยงการต่อ // บนวงจรไฟฟ้า…ถ้าคุณต้องการ ให้เชื่อมต่อ GND ก่อน

//ตัวแปร Rueda de colores

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson // เผยแพร่ภายใต้ลิขสิทธิ์ GPLv3 เพื่อให้ตรงกับส่วนที่เหลือของไลบรารี AdaFruit NeoPixel

#รวม

#ifdef _AVR_ #รวม #endif

// พินใดบน Arduino ที่เชื่อมต่อกับ NeoPixels

// สำหรับ Trinket หรือ Gemma เราแนะนำให้เปลี่ยนเป็น 1 #define PIN 9

// NeoPixels ต่อกับ Arduino จำนวนเท่าใด

#กำหนด NUMPIXELS 16

// เมื่อเราตั้งค่าไลบรารี NeoPixel เราจะบอกจำนวนพิกเซลและพินที่จะใช้ส่งสัญญาณ

// โปรดทราบว่าสำหรับแถบ NeoPixel รุ่นเก่า คุณอาจต้องเปลี่ยนพารามิเตอร์ที่สาม - ดูตัวอย่าง strandtest // สำหรับข้อมูลเพิ่มเติมเกี่ยวกับค่าที่เป็นไปได้ พิกเซล Adafruit_NeoPixel = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int ความล่าช้า = 50; // หน่วงเวลา 50ms

//ตัวแปรสี aleatorios

#รวม #ifdef _AVR_ #รวม #endif

#กำหนด PIN 9

#define NUM_LEDS 16

#กำหนดความสว่าง200

//แถบ Adafruit_NeoPixel = Adafruit_NeoPixel (NUM_LEDS, PIN, NEO_GRBW + NEO_KHZ800);

ไบต์ 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

การตั้งค่าเป็นโมฆะ () {// Código: Dirección de la Gravedad neoring.begin (); neoring.setBrightness(200); Serial.begin(9600); Wire.begin(); Wire.beginการส่ง(0x0A); // ที่อยู่ของมาตรความเร่ง // การตั้งค่าช่วง Wire.write(0x22); //ลงทะเบียนที่อยู่ Wire.write(ช่วง); //สามารถตั้งค่าได้ที่"0x00""0x01""0x02""0x03" อ้างอิงจาก Datashhet บนวิกิ // ตัวกรองความถี่ต่ำ Wire.write(0x20); //ที่อยู่ลงทะเบียน Wire.write(0x05); //สามารถตั้งค่าได้ที่"0x05""0x04"……"0x01""0x00" อ้างถึง Datashhet บน wiki Wire.endTransmission();

//โคดิโก้; Luces Arcoiris

// นี่สำหรับ Trinket 5V 16MHz คุณสามารถลบสามบรรทัดนี้ได้หากคุณไม่ได้ใช้ Trinket #if ที่กำหนดไว้ (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // สิ้นสุดโค้ดพิเศษเล็ก ๆ น้อย ๆ strip.begin(); แถบ.show(); // เริ่มต้นพิกเซลทั้งหมดเป็น 'ปิด'

//Código Rueda de colores

// นี่สำหรับ Trinket 5V 16MHz คุณสามารถลบสามบรรทัดนี้ได้หากคุณไม่ได้ใช้ Trinket #if ที่กำหนดไว้ (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // สิ้นสุดโค้ดพิเศษเล็กๆ น้อยๆ

พิกเซล.begin(); // นี่เป็นการเริ่มต้นไลบรารี NeoPixel

//โคดิโก้ อินเตอร์รัปซิออน

ตัวนับ = 1;

//Codigo Colores หลากหลาย

// นี่สำหรับ Trinket 5V 16MHz คุณสามารถลบสามบรรทัดนี้ได้หากคุณไม่ได้ใช้ Trinket #if ที่กำหนดไว้ (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // สิ้นสุดโค้ดพิเศษเล็ก ๆ น้อย ๆ strip.setBrightness(BRIGHTNESS); แถบ.begin(); แถบ.show(); // เริ่มต้นพิกเซลทั้งหมดเป็น 'ปิด' }

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

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

/บูเคิล อินฟินิโต

วงเป็นโมฆะ () {//Caso 1: เกมฟรีที่เล่นโดย Gravedad; if(ตัวนับ == 1){ สำหรับ(int i=0;i 0.0){ if(nx 0.0) มุม+=180; มุมอื่น += 360; }//จบอย่างอื่น if(angle == 360.0) angle = 0.0; led = วงกลม (มุม / (360 / NUMBER_OF_LEDS_ON_RING)); // ทำให้การเคลื่อนไหวแบบ led ราบรื่น if (previousLed == led) { // ไม่มีอะไรทำ } else if (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); อื่นนำ = หมุนเวียน (ก่อนหน้าLed - 1); ledQueue.push (นำ); makeLightShow(); PreviousLed = นำ; ล่าช้า(25); } ตัวนับ = 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++){ // ตัวอย่างขั้นตอนที่แสดง วิธีการแสดงเป็นพิกเซล: colorWipe1(strip. Color(255, 0, 0), 50); // สีแดง colorWipe1(strip. Color(0, 255, 0), 50); // สีเขียว colorWipe1(strip. Color(0, 0, 255), 50); // สีน้ำเงินเช็ด1(แถบสี(0, 0, 0, 255), 50); // สีขาว RGBW // ส่งการไล่ล่าพิกเซลของโรงภาพยนตร์ใน… theaterChase(strip. Color(127, 127, 127), 50); // โรงละครสีขาว Chase(แถบ.สี(127, 0, 0), 50); // โรงละครสีแดง Chase(แถบสี(0, 0, 127), 50); // สีฟ้า

รุ้ง(5);

รุ้งรอบ(5); โรงละครเชสเรนโบว์(5); } ตัวนับ = 3; }//End if counter==2 //Caso 3: Luces Aleatorias else if(counter == 3){ for(int k=0;k<50;k++){ // สำหรับชุด NeoPixels NeoPixel ตัวแรกคือ 0, วินาทีคือ 1 จนถึงจำนวนพิกเซลลบหนึ่ง int a=random(255); int b=สุ่ม(255); int c = สุ่ม (255); สำหรับ(int i=0;i

// pixels. Color ใช้ค่า RGB ตั้งแต่ 0, 0, 0 ถึง 255, 255, 255

pixels.setPixelColor(i, pixels. Color(a, b, c)); // สีเขียวสดใสปานกลาง

พิกเซล.show(); // สิ่งนี้จะส่งสีพิกเซลที่อัปเดตไปยังฮาร์ดแวร์

ล่าช้า (ล่าช้า); // หน่วงเวลาชั่วขณะหนึ่ง (หน่วยเป็นมิลลิวินาที)

} a=สุ่ม(255); b=สุ่ม(255); c=สุ่ม(255); สำหรับ (int i=NUMPIXELS;i>0;i--){

// pixels. Color ใช้ค่า RGB ตั้งแต่ 0, 0, 0 ถึง 255, 255, 255

pixels.setPixelColor(i, pixels. Color(a, b, c)); // สีเขียวสดใสปานกลาง

พิกเซล.show(); // สิ่งนี้จะส่งสีพิกเซลที่อัปเดตไปยังฮาร์ดแวร์

ล่าช้า (ล่าช้า); // หน่วงเวลาชั่วขณะหนึ่ง (หน่วยเป็นมิลลิวินาที)

} } ตัวนับ = 4; } else if(counter == 4){ for(int g=0;g<=6;g++){ // ตัวอย่างขั้นตอนที่แสดงวิธีการแสดงเป็นพิกเซล: colorWipe(strip. Color(255, 0, 0), 50); // สีแดง colorWipe(strip. Color(0, 255, 0), 50); // สีเขียว colorWipe(strip. Color(0, 0, 255), 50); // สีน้ำเงิน เช็ด(แถบสี(0, 0, 0, 255), 50); // สีขาว สีขาว OverRainbow(20, 75, 5); พัลส์ไวท์(5); // ฟูลไวท์(); // ล่าช้า (2000); rainbowFade2White(3, 3, 1);

}

ตัวนับ = 1; } } ///////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////// ////////////////

/Metodos del Ejemplo de la gravedad

เป็นโมฆะ AccelerometerInit () { Wire.beginTransmission (0x0A); // ที่อยู่ของมาตรความเร่ง // รีเซ็ตตัวตรวจวัดความเร่ง Wire.write(0x04); // X ข้อมูล Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // ขอ 6 ไบต์จากอุปกรณ์ทาส # 2 ในขณะที่ (Wire.available ()) // ทาสอาจส่งน้อยกว่าที่ร้องขอ { รุ่น [0] = Wire.read (); // รับไบต์เป็นอักขระ } x_data=(int8_t)Version[0]>>2; Wire.beginการส่ง(0x0A); // ที่อยู่ของมาตรความเร่ง // รีเซ็ตตัวตรวจวัดความเร่ง Wire.write(0x06); // Y ข้อมูล Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // ขอ 6 ไบต์จากอุปกรณ์ทาส # 2 ในขณะที่ (Wire.available ()) // ทาสอาจส่งน้อยกว่าที่ร้องขอ { รุ่น [1] = Wire.read (); // รับไบต์เป็นอักขระ } y_data=(int8_t)Version[1]>>2; Wire.beginการส่ง(0x0A); // ที่อยู่ของมาตรความเร่ง // รีเซ็ตตัวตรวจวัดความเร่ง Wire.write(0x08); // ข้อมูล Z Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // ขอ 6 ไบต์จากอุปกรณ์ทาส # 2 ในขณะที่ (Wire.available ()) // ทาสอาจส่งน้อยกว่าที่ร้องขอ { รุ่น [2] = Wire.read (); // รับไบต์ตามตัวอักษร } z_data=(int8_t)Version[2]>>2; x=(ลอย)x_data/divi; y=(ลอย)y_data/divi; z=(ลอย)z_data/divi; Serial.print("X="); Serial.print(x); // พิมพ์อักขระ Serial.print(" "); Serial.print("Y="); Serial.print(y); // พิมพ์อักขระ Serial.print(" "); Serial.print("Z="); // พิมพ์อักขระ Serial.println(z); }

int วงกลม (int pos){

if(pos >= NUMBER_OF_LEDS_ON_RING) ผลตอบแทน (pos - NUMBER_OF_LEDS_ON_RING); อื่น ๆ if(pos < 0) return(pos + NUMBER_OF_LEDS_ON_RING); ผลตอบแทนอื่น (pos); }

ระยะทางภายใน;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) { ระยะทาง = nextPos - prevPos; ถ้า (ระยะทาง < 0) ระยะทาง += NUMBER_OF_LEDS_ON_RING; กลับ(ระยะทาง); }

int ledPosition, คิวปัจจุบันขนาด;

#define NUMBER_OF_LEDS_TO_SHINE ความสว่าง 10 int = 255/NUMBER_OF_LEDS_TO_SHINE;

เป็นโมฆะ makeLightShow(){

สำหรับ (int j = 0; j < NUMBER_OF_LEDS_ON_RING; j++) neoring.setPixelColor(j, 0, 0, 0); currentQueueSize = ledQueue.count (); สำหรับ (int k = 0; k <currentQueueSize; k++) { ledPosition = ledQueue.pop (); neoring.setPixelColor(ledPosition, 0, (ความสว่างขั้นตอน * k), 0); ถ้า((k == 0 && currentQueueSize 0) ledQueue.push(ledPosition); } neoring.show(); }

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

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

/Metodos del juego de luces del arcoiris

// เติมจุดทีละจุดด้วยสี void colorWipe(uint32_t c, uint8_t wait) { for(uint16_t i=0; i

รุ้งเป็นโมฆะ (uint8_t รอ) {

uint16_t ผม, เจ;

สำหรับ(j=0; j<256; j++) { สำหรับ(i=0; i

// ต่างกันเล็กน้อย ทำให้รุ้งกระจายไปทั่ว

เป็นโมฆะ rainbowCycle (uint8_t รอ) { uint16_t i, j;

สำหรับ (j=0; j<256*5; j++) {// 5 รอบของสีทั้งหมดบนวงล้อ for (i=0; i< strip.numPixels(); i++) { strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels()) + j) & 255)); } strip.show(); ล่าช้า(รอ); } }

//ไฟคลานแบบโรงละคร

เป็นโมฆะ theatreChase (uint32_t c, uint8_t รอ) { สำหรับ (int j=0; j<10; j++) {// ไล่ตาม 10 รอบ (int q=0; q <3; q++) { สำหรับ (uint16_t i= 0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, c); // เปิดทุก ๆ พิกเซลที่สามบน } strip.show();

ล่าช้า(รอ);

สำหรับ (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); //ปิดทุกๆ พิกเซลที่สาม } } } }

//ไฟคลานสไตล์โรงละครพร้อมเอฟเฟกต์สีรุ้ง

void theaterChaseRainbow (uint8_t wait) { สำหรับ (int j=0; j < 256; j++) { // วนรอบ 256 สีทั้งหมดในวงล้อสำหรับ (int q=0; q < 3; q++) { สำหรับ (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, วงล้อ((i+j) % 255)); // เปิดทุก ๆ พิกเซลที่สามบน } strip.show();

ล่าช้า(รอ);

สำหรับ (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); //ปิดทุกๆ พิกเซลที่สาม } } } }

// ป้อนค่า 0 ถึง 255 เพื่อรับค่าสี

// สีเป็นการเปลี่ยน r - g - b - กลับ r. uint32_t Wheel (ไบต์ WheelPos) { WheelPos = 255 - WheelPos; ถ้า (WheelPos <85) { แถบส่งคืน. สี (255 - WheelPos * 3, 0, WheelPos * 3); } if (WheelPos <170) { WheelPos -= 85; แถบส่งคืน.สี(0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; แถบส่งคืน.สี(WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/Metodos Rueda de colores

// int elegirColor = สุ่ม (0x000000, 0xffffff); // สิทธิ์ในการเข้าร่วม entre toda la gama de colores comprendida entre 0x000000 y 0xFFFFFF

//CylonEyeColor=HtmlColor(elegirColor); //int elegirColor = สุ่ม (1, 7); // Podemos elegir aleatoriamente entre los 7 สี 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

// เติมจุดทีละจุดด้วยสี

เป็นโมฆะ colorWipe1 (uint32_t c, uint8_t รอ) { สำหรับ (uint16_t i = 0; i

โมฆะ pulseWhite (uint8_t รอ) {

สำหรับ (int j = 0; j < 256; j++){ สำหรับ (uint16_t i=0; i

สำหรับ(int j = 255; j >= 0; j--){

สำหรับ (uint16_t i=0; i

เป็นโมฆะ 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 รอบของสีทั้งหมดบนวงล้อ

สำหรับ (int i=0; i< strip.numPixels(); i++) {

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

redVal = สีแดง (wheelVal) * float (fadeVal/fadeMax);

greenVal = สีเขียว (wheelVal) * float (fadeVal/fadeMax); blueVal = สีน้ำเงิน (wheelVal) * float (fadeVal/fadeMax);

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

}

//วงแรก เฟดอิน!

ถ้า (k == 0 && fadeVal < fadeMax-1) { fadeVal ++; }

//วงสุดท้าย จางหายไป!

อย่างอื่น if(k == rainbowLoops - 1 && j > 255 - fadeMax){ fadeVal--; }

แถบ.show();

ล่าช้า(รอ); } }

ล่าช้า (500);

สำหรับ (int k = 0; k < whiteLoops; k ++){

สำหรับ(int j = 0; j < 256; j++){

สำหรับ (uint16_t i=0; i < strip.numPixels(); i++) { strip.setPixelColor(i, strip. Color(0, 0, 0, neopix_gamma[j])); } strip.show(); }

ล่าช้า (2000);

สำหรับ(int j = 255; j >= 0; j--){

สำหรับ (uint16_t i=0; i < strip.numPixels(); i++) { strip.setPixelColor(i, strip. Color(0, 0, 0, neopix_gamma[j])); } strip.show(); } }

ล่าช้า (500);

}

โมฆะ whiteOverRainbow (uint8_t รอ uint8_t whiteSpeed uint8_t whiteLength) {

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

int head = สีขาวความยาว - 1;

หาง int = 0;

int ลูป = 3;

int loopNum = 0;

LastTime ที่ไม่ได้ลงนามแบบคงที่ = 0;

ในขณะที่(จริง){

for(int j=0; j<256; j++) { for(uint16_t i=0; i= tail && i head && i >= tail) || (หาง > หัว && ผม <= หัว)){ strip.setPixelColor(i, strip. Color(0, 0, 0, 255)); } อื่น ๆ { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); } }

if(millis() - lastTime > whiteSpeed) {

หัว++; หาง++; ถ้า (หัว == strip.numPixels ()) { loopNum ++; } ครั้งสุดท้าย = มิลลิวินาที (); }

if(loopNum == ลูป) ส่งคืน;

หัว% = strip.numPixels (); หาง%=แถบ.numPixels(); แถบ.show(); ล่าช้า(รอ); } } } เป็นโมฆะ fullWhite() { สำหรับ (uint16_t i=0; i

// ต่างกันเล็กน้อย ทำให้รุ้งกระจายไปทั่ว

เป็นโมฆะ rainbowCycle1 (uint8_t รอ) { uint16_t i, j;

สำหรับ (j=0; j<256 * 5; j++) { // 5 รอบของสีทั้งหมดบนวงล้อ for (i=0; i< strip.numPixels(); i++) { strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels()) + j) & 255)); } strip.show(); ล่าช้า(รอ); } }

เป็นโมฆะ rainbow1 (uint8_t รอ) {

uint16_t ผม, เจ;

สำหรับ(j=0; j<256; j++) { สำหรับ(i=0; i

// ป้อนค่า 0 ถึง 255 เพื่อรับค่าสี

// สีเป็นการเปลี่ยน r - g - b - กลับ r. uint32_t Wheel1 (ไบต์ WheelPos) { WheelPos = 255 - WheelPos; ถ้า (WheelPos <85) { แถบส่งคืน. สี (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) { WheelPos -= 85; แถบกลับ.สี(0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; แถบส่งคืน.สี(WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t สีแดง (uint32_t c) {

กลับ (c >> 16); } uint8_t สีเขียว (uint32_t c) { กลับ (c >> 8); } uint8_t สีน้ำเงิน (uint32_t c) { กลับ (c); }

ขั้นตอนที่ 8: การออกแบบ 3 มิติ

ขั้นแรก คุณต้องกำหนดขนาดส่วนประกอบฮาร์ดแวร์ของคุณเพื่อให้แน่ใจว่าถูกต้อง หากเป็นไฟล์เดียวกันกับของเรา คุณสามารถใช้ไฟล์เดียวกันกับที่เราให้ยืมได้

ส่วนรองรับทั้งสองได้รับการออกแบบด้วยเครื่องพิมพ์ 3D ซึ่งรวมอยู่ใน:

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

สุดท้ายแสงก็จะเหมือนสองภาพสุดท้าย

ขั้นตอนที่ 9: การติดตั้งคอ

ก่อนอื่นเราจะวางอานที่คอ รูที่สกรูต้องยึดไม่มีอยู่ ดังนั้นเราจะต้องสร้างรู ทำเครื่องหมายตำแหน่งที่ควรไปและระมัดระวังด้วยสว่านเพื่อทำรู

เช่นเดียวกับรูที่สกรูที่ยึดคอไว้กับตัวเครื่อง ไม่จำเป็นต้องทำเพราะไม่มีสกรูสำหรับยึด แต่ถ้าเราต้องการจะทำก็ไม่มีปัญหา

สำคัญ: เว้นช่องว่างไว้ 5 มม. ระหว่างจุดเริ่มต้นของเสากับจุดเริ่มต้นของส้อมเสียง เพราะในรูนั้น น็อตจะถูกวางไว้

เราจะติดน็อตด้วยกาวในทิศทางที่ระบุโดยรูป

สุดท้ายนี้เราจะมาแนะนำหมุด 4 ตัวในรูที่อยู่ต้นเสา โดยยึดหมุดแต่ละอันไว้ด้วยสกรูสั้น 2 ตัวตามที่แสดงในภาพ

ขั้นตอนที่ 10: ติดตั้ง Birdge

สะพานได้รับการแก้ไขโดยการติดกาวและด้วยสกรูยาวสองตัวที่ตำแหน่งตรงกลางของลำตัว ขอแนะนำให้ทำเครื่องหมายตำแหน่งที่ถูกต้องในร่างกายด้วยดินสอ เราจะใช้ระยะทางที่ทำเครื่องหมายไว้ในภาพ

เราจะทากาวที่การรวมเข้าด้วยกันของส่วนประกอบทั้งสอง เรายึดทั้งสองส่วนอย่างระมัดระวังโดยใช้สกรูขันให้แน่นจนกว่าข้อต่อจะแห้ง เราจะทำสองรูสำหรับสกรูด้วยดอกสว่าน 1.5 มม. สำหรับไม้ แก้ไขสะพานด้วยสกรูยาวสองตัวในตัว และสุดท้าย เราใส่ฝาครอบป้องกันบนหัวสกรู

ขั้นตอนที่ 11: การประกอบร่างกายและคอ

ในการประกอบทั้งสองส่วน เรามีรูที่ส่วนหัวของร่างกาย โดยที่คอจะพอดีกับส่วนที่ยื่นออกมาสองส่วน เราสามารถทากาวด้วยกาวหรือปืนร้อนละลาย เพื่อให้มีการยึดเกาะที่ดียิ่งขึ้น คุณสามารถสร้างรูที่อยู่ท้ายสุดของส้อมเสียงเพื่อรวมเข้ากับร่างกาย

ขั้นตอนที่ 12: ใส่สายอูคูเลเล่

สุดท้ายเราต้องวางสายเพื่อให้เครื่องดนตรีของเราเสร็จ

ก่อนหน้านี้เราจะใส่วงแหวนยึดของหมุดในส่วนที่ยื่นออกมาจากเสา ในการวางสาย เราใช้สาย 4 ที่มาพร้อมกับชุด ก่อนอื่นคุณต้องแยกแยะแต่ละสตริงเพราะมันไม่เหมือนกันทั้งหมด คุณต้องผูกปลายข้างหนึ่งของแต่ละสาย (อันหนาสองอันที่มีปมปกติ และอีกอันสองอันที่มีอันสองอัน) แล้วสอดเชือกเข้าไปในช่องของสะพาน

จากนั้นเราจะวางสตริงในลักษณะที่:

• ตำแหน่งแรก: สตริง G (สตริงที่หนาที่สุดเป็นอันดับสอง)

• ตำแหน่งที่สอง: สตริง C (สตริงที่หนาขึ้น)

• ตำแหน่งที่สาม: สตริง E (สตริงที่บางกว่าที่สอง)

• ตำแหน่งที่สี่: สตริง (สตริงทินเนอร์)

ร้อยสายอักขระลงในรูของปลั๊กที่ให้มา พยายามแก้ไขเชือกแต่ละเส้นโดยหมุนหมุดให้สองหรือสามรอบ ตึงสายโดยไม่ออกแรงมากเกินไป และตรวจสอบระยะห่างระหว่างสายและอาน

หากคุณมีข้อสงสัยเกี่ยวกับวิธีการทำสิ่งนั้น คุณสามารถทำแบบฝึกหัดที่อธิบายวิธีการใส่สตริงได้อย่างถูกต้อง

ขั้นตอนที่ 13: การทดสอบ

สุดท้าย เราต้องดูว่าอูคูเลเล่ประกอบอย่างเหมาะสมหรือไม่ โดยให้ระยะห่างในอุดมคติของเฟรตแรกคือ 0.1 มม. และช่วงที่สิบสองจะอยู่ที่ประมาณ 1.2 มม.

จำเป็นต้องจูนสายอูคูเลเล่ ฉันขอแนะนำแอพนี้ให้คุณ: GuitarTuna

ขั้นตอนที่ 14: สนุกกับมัน

ตอนนี้คุณต้องสนุกกับอูคูเลเล่ของคุณเท่านั้น

หากคุณต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับเรา คุณสามารถหาเราได้ใน:

Twitter: @Innovat_cc

Facebook: @Innovatcc

อินสตาแกรม: @Innovat_cc

เว็บ: Innovat.cc