DIY Smart Electronic Ukulele Arduino– ით: 14 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

ჩვენ ვაპირებთ ეტაპობრივად ავუხსნათ, თუ როგორ შეგიძლიათ შექმნათ თქვენი საკუთარი უკულელე და დაამატოთ რამდენიმე ეფექტი, რაც მას უნიკალურს გახდის, მაგალითად, რაღაცის დახატვა, რაც ჩვენ გვინდა, უკულეს ზედაპირზე ან მსუბუქი ეფექტების დამატება.

ამის გასაკეთებლად აუცილებელია იყულულეს ნაკრების ყიდვა.

ჩვენ ვაპირებთ ავუხსნათ, თუ როგორ უნდა შევიკრიბოთ ინსტრუმენტი და გადავწყვიტოთ სხვადასხვა პრობლემები, რაც შეიძლება გამოჩნდეს.

ნაბიჯი 1: მასალები

სტრუქტურის მასალები:

DIY ukelele სამონტაჟო ნაკრები (ეს შეიძლება იყოს სხვა განსხვავებული ნაკრები) ჩამოყალიბებული:

1- სხეული.

2-კისერი.

3-უნაგირი

4-თოკის მხარდაჭერა

5-ხიდი

6-სიმებიანი თხილი.

7-აფიქსირებს ბეჭედს მანქანის თავზე (x4).

8-მანქანა თავები (x4).

9-სამონტაჟო ხრახნები მანქანის თავებისთვის (x8).

10-სამონტაჟო ხრახნები მანქანების ხიდისთვის (x2).

11-საფარის ხუფები ხიდის სამონტაჟო ხრახნებისთვის (x2).

12-სიმებიანი (x4).

ელექტრონული მასალები:

• ნანო არდუინო.
• წამყვანი ბორბალი WS2812.
• ამაჩქარებელი BMA220 (სურვილისამებრ).
• ბატარეის კონექტორი.
• ბატარეა 9 ვ.
• გადართვა.

სხვა

• ხის ლაქი.
• Velcro.
• შედუღების კალის.
• დამცავი პლასტიკური ლაქისთვის.
• ცხელი დნობის სილიკონი.

ინსტრუმენტები:

• ლაზერული გრავირება.
• სანდლის ქაღალდი
• ვარსკვლავი screwdriver.
• ფუნჯი.
• ცხელი დნობის იარაღი.
• კალის გამაგრილებელი რკინა.

ნაბიჯი 2: მორგეთ უკულელე

ჩვენი უკულელის კოსტუმიზაციისთვის ჩვენ შეგვიძლია გავაკეთოთ ნახატის გრავირება ლაზერული საჭრელით სხეულზე. იმ შემთხვევაში, თუ ეს ინსტრუმენტი არ გვაქვს, ჩვენ შეგვიძლია მისი დახატვა.

სურათი, რომელიც ჩვენ ავირჩიეთ, პირველი გამოჩნდება.

უპირველეს ყოვლისა, ჩვენ უნდა შევადგინოთ ნახატის შაბლონი, რათა მოხდეს გრავირება.

ამის განსახორციელებლად ჩვენ გამოვიყენებთ პროგრამულ უზრუნველყოფას სახელწოდებით "Inkscape", რომლის მოპოვებაც შეგვიძლია ამ ბმულიდან:

მისი გამოსაყენებლად, ჩვენ უნდა შევცვალოთ ის სურათი, რომლის გამოყენებაც გვსურს, როგორც ეს მეორე სურათზეა ნაჩვენები. თქვენ შეგიძლიათ შეხედოთ, რომ ჩვენ გადავაბრუნეთ საწყისი სურათი, რათა შეცვალოთ ხელის ციკლი ინსტრუმენტის წრეზე. როგორც უკვე ვთქვით, თქვენ შეგიძლიათ განათავსოთ ნებისმიერი სურათი.

ნაბიჯი 3: სურათის ვექტორიზაცია Inkscape– ის გამოყენებით

ჩვენ ვნახავთ, თუ როგორ უნდა შევქმნათ ვექტორული ფაილი pixmap– დან (jpg, png, რა რასტერული ფორმატიც შეიძლება გახსნას Inkscape– მა).

Inkscape Inkscape არის ღია კოდის ვექტორული გრაფიკული რედაქტორი და როგორც სათაურიდან ჩანს, ეს არის ინსტრუმენტი, რომელსაც გამოვიყენებ ლოგოების ვექტორიზაციისთვის. ვექტორიზაციის ნაბიჯები ნაბიჯები საერთოა ნებისმიერი ვექტორიზაციისათვის, რისი გაკეთებაც გვსურს.

1. გახსენით სურათი Inkscape– ში
2. გახსენით Trace Bitmap Tool Path-> Trace Bitmap
3. ითამაშეთ Trace Bitmap პარამეტრების გარშემო
4. გაუშვით კვალი
5. გაასუფთავეთ შედეგები (საჭიროების შემთხვევაში)

ყურადღება მიაქციეთ "თამაშის გარშემო" ნაწილს. მე არ ვარ მიკვლევის ექსპერტი, ამიტომ ამ ინსტრუმენტს ვთვლი როგორც შავ ყუთს სახელურებით და შუქებით, ვტრიალებ და ვცვლი სანამ არ მივიღებ საუკეთესო შედეგს

ნაბიჯი 4: ლოგოს გრავირება

ამისათვის მნიშვნელოვანია ზედაპირის სილუეტი, რომელზედაც მოხდება ნახატის გრავირება.

გრავიურის გასაკეთებლად ჩვენ ვაპირებთ გამოვიყენოთ 'T2Laser' პროგრამული უზრუნველყოფა. ჩვენ შეგვიძლია მივიღოთ ეს პროგრამა:

პროგრამული უზრუნველყოფის გახსნის შემდეგ, ჩვენ უნდა ჩავტვირთოთ სურათი, რომელიც შევქმენით ბოლო ეტაპზე. შემდეგ დააჭირეთ ღილაკს "კონტროლის ლაზერი" და გამოჩნდება cnc კონტროლი. ორი სურათი გვიჩვენებს ჩვენი ლაზერული საჭრელით გრავირების პროცესს და შედეგს.

ნაბიჯი 5: დაფქვა და ლაქირება

იმისათვის, რომ ჩვენი უკულელე იყოს ნათელი და ფენით უხეშობის გარეშე, ჩვენ შეგვიძლია შეუფერხებლად მოვაყაროთ ორი ნაწილი, რომელიც ქმნის ჩვენს ინსტრუმენტს, რადგან ჩვენ შეგვიძლია დავაზიანოთ ნახატი, რომელიც გაკეთებულია (თუ თქვენ ირჩევთ უკულელის ხატვას, მოგიწევთ ქვიშა ჯერ). შემდეგ ჩვენ დავფარავთ ჩვენს ორ ნაწილს ისე, რომ მათ მიიღონ მუქი ფერი და ხე უფრო მეტ წინააღმდეგობას ავლენს. ჩვენ შეგვიძლია გამოვიყენოთ ჩვეულებრივი ხის ლაქი, ის არ უნდა იყოს განსაკუთრებული.

მას შემდეგ, რაც ჩვენ გვაქვს ლაქი, ჩვენ ავურიოთ იგი პატარა გამხსნელით ისე, რომ ის ოდნავ დაიშალა. შემდეგი, ჩვენ ვრცელდება ნარევი ერთად ფუნჯი კისრის და სხეულის ინსტრუმენტი და მოდით მშრალი.

თუ ჩვენ ვნახავთ, რომ პროდუქტს მეორე ფენა სჭირდება, ჩვენ შეგვიძლია ორ ნაწილად ოდნავ მოვხვიოთ ქვიშა და ხელახლა გამოვიყენოთ განზავებული ლაქის ფენა.

** სიფრთხილის ზომები: ლაქი ქიმიური პროდუქტია, ამიტომ აუცილებელია ამ პროცესის ჩატარება ვენტილირებად ადგილას, ატარეთ ნიღაბი, რათა თავიდან აიცილოთ სუნი და დამცავი სათვალე.

მასალები, რომლებიც ჩვენ გვჭირდება იმისათვის, რომ შევძლოთ სწორად მუშაობა არის ის, რაც ჩანს ფოტოებში. ძირითადად ჩვენ ვიმუშავებთ ფუნჯით, ლაქის ქილა (ჩვენს შემთხვევაში წითელი ფერი), ცოტა გამხსნელი და ვიზუალური დაცვა. და უპირველეს ყოვლისა მუშაობა კარგად ვენტილირებად სივრცეებში.

ნაბიჯი 6: აპარატურა

ჩვენი დაფა არდუინოსთან, ასელერომეტრთან და ბორბალიანი ბილიკებით შემოვა პატარა ფრჩხილში, რათა თავიდან ავიცილოთ ყველა კომპონენტის გადატანა ინსტრუმენტში.

ჩვენ ასევე დავამატეთ ბატარეის დამჭერი და ჩამრთველი, რათა ის უფრო კომფორტული იყოს და ჩვენ არ ვცდით ბატარეას, როდესაც არ ვიყენებთ ინსტრუმენტს. ჩვენ დავუმატებთ ამ მხარდაჭერას Velcro- ს ნაჭერით (ის ასევე იმუშავებს სილიკონთან და ცხელ დნობასთან) უკულელის სხეულის შიდა სახეზე. მეორეს მხრივ, LED საჭე უფრო მცირეა ვიდრე ხვრელი, ასე რომ ის დაეცემა რა საყრდენი შემუშავებულია ისე, რომ კარგად იტევს და შეუძლია შეასრულოს თავისი ფუნქცია.

ნაბიჯი 7: პროგრამული უზრუნველყოფა

ჩვენს უკულელეს განსაკუთრებული დეკორაციის მისაცემად, ჩვენ შეგვიძლია დავამატოთ სინათლის ეფექტები ლიდერების ბორბლის წყალობით. ჩვენ ვაპირებთ გამოვიყენოთ WS2812, მაგრამ თქვენ შეგიძლიათ გამოიყენოთ ნებისმიერი სხვა მონაცემთა ფურცლის მითითებების შესაბამისად. ჩვენ ასევე გამოვიყენებთ ასელერომეტრს (BMA220), რომელიც გვაძლევს გრავიტაციის ეფექტს.

ფაქტობრივად, ჩვენ გვექნება სინათლის 4 პიესა, რომელიც შედის კომპიუტერულ ბიბლიოთეკაში არდუინოს "ადაფრუტი". ამისათვის ჩვენ უნდა გავაკეთოთ სწორი შეხამება სამ კომპონენტს შორის: Arduino NANO, WS2812 და BMA220, როგორც ეს ჩანს პირველ სურათზე.

წითელი მავთულები არის ძალა, GND შავები და დანარჩენი აუცილებელი კავშირები სწორი ოპერაციისთვის. კოდი, რომელიც ჩვენ გამოვიყენეთ მსუბუქი ნაკრებისთვის, თან ერთვის ფაილს სახელწოდებით "play_of_light_v0.ino". დარწმუნდით, რომ ჩართეთ საჭირო ბიბლიოთეკები პროგრამის სწორი მუშაობისთვის. ბატარეას, რომელსაც გარედან ვამატებთ მიკროსქემში, უნდა ჰქონდეს მინიმალური ძაბვა 9 ვ და ჩვენ უნდა დავრწმუნდეთ, რომ მას შეუძლია უზრუნველყოს მინიმალური დენი, რომელიც საჭიროა მთელი წრედის დასატენად.

// Variables contador e interrupciónint counter; // ცვლადები Ejemplo gravedad #Include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #განსაზღვრეთ NEOPIXEL_RING_DATA_PIN 9

ბაიტი ვერსია [3];

int8_t x_data; int8_t y_data; int8_t z_ მონაცემები; ბაიტის დიაპაზონი = 0x00; float divi = 16; ათწილადი x, y, z; float pi = 3.14159265359; float nx, ny, კუთხე; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel = = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// ცვლადები Luces arcoiris

#მოიცავს #ifdef _AVR_ #მოიცავს #endif #განსაზღვრა PIN 9 // პარამეტრი 1 = პიქსელების რაოდენობა ზოლში // პარამეტრი 2 = Arduino pin ნომერი (უმეტესობა მოქმედებს) // პარამეტრი 3 = პიქსელის ტიპის დროშები, საჭიროებისამებრ დაამატეთ ერთად: // NEO_KHZ800 800 KHz ბიტ -სტრიმი (უმეტესობა NeoPixel პროდუქტებით WS2812 LED- ებით) // NEO_KHZ400 400 KHz (კლასიკური 'v1' (არა v2) FLORA პიქსელები, WS2811 დრაივერები) // NEO_GRB პიქსელები სადენიანია GRB ბიტრემისთვის (ყველაზე NeoPixel პროდუქტები)/ / NEO_RGB პიქსელები მიერთებულია RGB ბიტრემისთვის (v1 FLORA პიქსელი, არა v2) // NEO_RGBW პიქსელები მიერთებულია RGBW ბიტრემისთვის (NeoPixel RGBW პროდუქტები) Adafruit_NeoPixel ზოლები = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_GRB + NEO_GRB + NEO_GRB + NEO_GRB + NEO_GRB + NEO_GRB8) // მნიშვნელოვანია: NeoPixel- ის გადაწვის რისკის შესამცირებლად, დაამატეთ 1000 uF კონდენსატორი // პიქსელის სიმძლავრის ხაზებს, დაამატეთ 300 - 500 Ohm რეზისტორი პირველი პიქსელის მონაცემების შეყვანაში // და შეამცირეთ მანძილი არდუინოსა და პირველ პიქსელს შორის. მოერიდეთ დაკავშირებას // პირდაპირ ჩართვაზე … თუ ეს გჭირდებათ, ჯერ GND დააკავშირეთ.

// ცვლადები Rueda de colores

// NeoPixel Ring მარტივი ესკიზი (გ) 2013 Shae Erisson // გამოშვებული GPLv3 ლიცენზიით, რათა შეესაბამებოდეს AdaFruit NeoPixel ბიბლიოთეკის დანარჩენ ნაწილს

#ჩართეთ

#ifdef _AVR_ #მოიცავს #ენდიფს

// არდუინოს რომელი პინია დაკავშირებული ნეოპიქსელებთან?

// წვრილმანზე ან გემაზე ჩვენ გირჩევთ შეცვალოთ ეს 1 #განსაზღვრეთ PIN 9 -ით

// რამდენი ნეოპიქსელი ერთვის არდუინოს?

#განსაზღვრეთ NUMPIXELS 16

// როდესაც ჩვენ ვაყენებთ NeoPixel ბიბლიოთეკას, ჩვენ ვეუბნებით მას რამდენი პიქსელი და რომელი პინი უნდა გამოვიყენოთ სიგნალების გასაგზავნად.

// გაითვალისწინეთ, რომ ძველი NeoPixel ზოლებისთვის შეიძლება დაგჭირდეთ მესამე პარამეტრის შეცვლა-იხილეთ strandtest // მაგალითი შესაძლო მნიშვნელობების შესახებ დამატებითი ინფორმაციისათვის. Adafruit_NeoPixel პიქსელი = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int დაგვიანებით = 50; // დაგვიანებით 50 წმ

// ცვლადები colores aleatorios

#მოიცავს #ifdef _AVR_ #მოიცავს #endif

#განსაზღვრეთ PIN 9

#განსაზღვრეთ 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 SETUP

void setup () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); სერიული.დაწყება (9600); Wire.begin (); Wire.beginTransmission (0x0A); // აქსელერომეტრის მისამართი // დიაპაზონის პარამეტრები Wire.write (0x22); // რეგისტრაციის მისამართი Wire.write (დიაპაზონი); // შეიძლება დაყენდეს "0x00" "0x01" "0x02" "0x03", მიმართეთ Datashhet ვიკიზე // დაბალი გავლის ფილტრი Wire.write (0x20); // რეგისტრაციის მისამართი Wire.write (0x05); // შეიძლება მითითებული იყოს "0x05" "0x04" …… "0x01" "0x00", მიმართეთ Datashhet ვიკიზე Wire.endTransmission ();

// კოდიგო; ლუის არკოირისი

// ეს არის Trinket 5V 16MHz– ისთვის, შეგიძლიათ წაშალოთ ეს სამი ხაზი, თუ არ იყენებთ წვრილმანებს #თუ განსაზღვრული (_AVR_ATtiny85_) თუ (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // წვრილმანების დასასრული სპეციალური კოდი strip.begin (); ზოლები. ჩვენება (); // ყველა პიქსელის ინიციალიზაცია "გამორთვის"

// Código Rueda de colores

// ეს არის Trinket 5V 16MHz– ისთვის, შეგიძლიათ წაშალოთ ეს სამი ხაზი, თუ არ იყენებთ წვრილმანებს #თუ განსაზღვრული (_AVR_ATtiny85_) თუ (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // წვრილმანი სპეციალური კოდის დასასრული

pixels.begin (); // ეს ინიციალებს NeoPixel ბიბლიოთეკას.

// Codigo Interrupcion

მრიცხველი = 1;

// Codigo Colores varios

// ეს არის Trinket 5V 16MHz– ისთვის, შეგიძლიათ წაშალოთ ეს სამი ხაზი, თუ არ იყენებთ წვრილმანებს #თუ განსაზღვრული (_AVR_ATtiny85_) თუ (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // წვრილმანი ბოლოს სპეციალური კოდი strip.setBrightness (BRIGHTNESS); ზოლები. დაწყება (); ზოლები. ჩვენება (); // ყველა პიქსელის ინიციალიზაცია "გამორთვის"}

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

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

/ბირთვი უსასრულო

void loop () {// Caso 1: Juego de luces de la gravedad; if (counter == 1) {for (int i = 0; i 0.0) {if (nx 0.0) კუთხე+= 180; სხვა კუთხე += 360; } // სხვაგან დასრულება if (კუთხე == 360.0) კუთხე = 0.0; led = მიმოქცევა (კუთხე / (360 / NUMBER_OF_LEDS_ON_RING)); // გახადე led მოძრაობა შეუფერხებელი, თუ (previousLed == led) {// არაფერია გასაკეთებელი} სხვაგან თუ (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); else led = მიმოქცევა (წინა Led - 1); ledQueue.push (led); makeLightShow (); previousLed = led; დაგვიანება (25); } მრიცხველი = 2; } // დასრულება თუ მრიცხველი == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// მაგალითები როგორ აჩვენოთ პიქსელებზე: colorWipe1 (ზოლები. ფერი (255, 0, 0), 50); // წითელი ფერი Wipe1 (ზოლები. ფერი (0, 255, 0), 50); // მწვანე ფერიWipe1 (ზოლები. ფერი (0, 0, 255), 50); // ლურჯი ფერიWipe1 (ზოლები. ფერი (0, 0, 0, 255), 50); // თეთრი RGBW // გაგზავნეთ თეატრის პიქსელის დევნა… theaterChase (ზოლები. ფერი (127, 127, 127), 50); // თეთრი თეატრი Chase (ზოლები. ფერი (127, 0, 0), 50); // წითელი თეატრი Chase (ზოლები. ფერი (0, 0, 127), 50); // ცისფერი

ცისარტყელა (5);

ცისარტყელა ველოსიპედი (5); TheaterChaseRainbow (5); } მრიცხველი = 3; } // დასრულება თუ მრიცხველი == 2 // Caso 3: Luces Aleatorias სხვა თუ (counter == 3) {for (int k = 0; k <50; k ++) {// NeoPixels– ის ნაკრებისთვის პირველი NeoPixel არის 0, მეორე არის 1, ყველა პიქსელის რაოდენობამდე მინუს ერთი. int a = შემთხვევითი (255); int b = შემთხვევითი (255); int c = შემთხვევითი (255); for (int i = 0; i

// პიქსელები. ფერი იღებს RGB მნიშვნელობებს, 0, 0, 0 -დან 255 -მდე, 255 -დან 255 -მდე

pixels.setPixelColor (i, pixels. Color (a, b, c)); // ზომიერად ნათელი მწვანე ფერი.

pixels.show (); // ეს აგზავნის განახლებული პიქსელის ფერს აპარატურაზე.

დაგვიანება (დაგვიანება); // გარკვეული პერიოდის განმავლობაში გადადება (მილიწამებში).

} a = შემთხვევითი (255); b = შემთხვევითი (255); c = შემთხვევითი (255); for (int i = NUMPIXELS; i> 0; i-) {

// პიქსელები. ფერი იღებს RGB მნიშვნელობებს, 0, 0, 0 -დან 255 -მდე, 255 -დან 255 -მდე

pixels.setPixelColor (i, pixels. Color (a, b, c)); // ზომიერად ნათელი მწვანე ფერი.

pixels.show (); // ეს აგზავნის განახლებული პიქსელის ფერს აპარატურაზე.

დაგვიანება (დაგვიანება); // გარკვეული პერიოდის განმავლობაში გადადება (მილიწამებში).

}} მრიცხველი = 4; } else if (counter == 4) {for (int g = 0; g <= 6; g ++) {// ზოგიერთი მაგალითი პროცედურები, რომლებიც აჩვენებს, თუ როგორ უნდა გამოჩნდეს პიქსელებზე: colorWipe (strip. Color (255, 0, 0), 50); // წითელი ფერი Wipe (ზოლები. ფერი (0, 255, 0), 50); // მწვანე ფერი Wipe (ზოლები. ფერი (0, 0, 255), 50); // ლურჯი ფერიWipe (ზოლები. ფერი (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 (); მავთული. მოთხოვნა (0x0A, 1); // მოითხოვოს 6 ბაიტი მონა მოწყობილობიდან #2 ხოლო (Wire.available ()) // მონას შეუძლია გამოაგზავნოს მოთხოვნაზე ნაკლები {ვერსია [0] = Wire.read (); // მიიღეთ ბაიტი როგორც ხასიათი} x_data = (int8_t) ვერსია [0] >> 2; Wire.beginTransmission (0x0A); // აქსელერომეტრის მისამართი // გადატვირთეთ ამაჩქარებელი Wire.write (0x06); // Y მონაცემები Wire.endTransmission (); მავთული. მოთხოვნა (0x0A, 1); // მოითხოვოს 6 ბაიტი მონა მოწყობილობიდან #2 ხოლო (Wire.available ()) // მონას შეუძლია გამოაგზავნოს მოთხოვნაზე ნაკლები {ვერსია [1] = Wire.read (); // მიიღეთ ბაიტი როგორც ხასიათი} y_data = (int8_t) ვერსია [1] >> 2; Wire.beginTransmission (0x0A); // აქსელერომეტრის მისამართი // გადატვირთეთ ამაჩქარებელი Wire.write (0x08); // Z მონაცემთა Wire.endTransmission (); მავთული. მოთხოვნა (0x0A, 1); // მოითხოვოს 6 ბაიტი მონა მოწყობილობიდან #2 ხოლო (Wire.available ()) // მონას შეუძლია გამოაგზავნოს მოთხოვნაზე ნაკლები {ვერსია [2] = Wire.read (); // მიიღეთ ბაიტი როგორც ხასიათი} z_data = (int8_t) ვერსია [2] >> 2; x = (float) x_data/divi; y = (float) y_data/divi; z = (float) z_data/divi; Serial.print ("X ="); სერიული. ბეჭდვა (x); // დაბეჭდე პერსონაჟი Serial.print (""); Serial.print ("Y ="); სერიული. ბეჭდვა (y); // დაბეჭდე პერსონაჟი Serial.print (""); Serial.print ("Z ="); // ამობეჭდვა პერსონაჟი Serial.println (z); }

int circularize (int pos) {

თუ (pos> = NUMBER_OF_LEDS_ON_RING) დაბრუნდება (pos - NUMBER_OF_LEDS_ON_RING); სხვა შემთხვევაში თუ (pos <0) დაბრუნდება (pos + NUMBER_OF_LEDS_ON_RING); სხვაგვარად დაბრუნება (pos); }

int მანძილი;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; თუ (მანძილი <0) მანძილი += NUMBER_OF_LEDS_ON_RING; დაბრუნება (მანძილი); }

int ledPosition, currentQueueSize;

#განსაზღვრეთ NUMBER_OF_LEDS_TO_SHINE 10 int სიკაშკაშე ნაბიჯი = 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, (brightnessStep * k), 0); if ((k == 0 && currentQueueSize 0) ledQueue.push (ledPosition);} neoring.show ();}

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

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

/Metodos del juego de luces del arcoiris

// შეავსეთ წერტილები ერთმანეთის მიყოლებით ფერის ბათილი ფერითწმინდეთ (uint32_t c, uint8_t დაელოდეთ) {for (uint16_t i = 0; i

ბათილი ცისარტყელა (uint8_t ლოდინი) {

uint16_t i, j;

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

// ოდნავ განსხვავებული, ეს ცისარტყელას თანაბრად ანაწილებს მთელ ტერიტორიაზე

void rainbowCycle (uint8_t ლოდინი) {uint16_t i, j;

for (j = 0; j <256*5; j ++) {// ყველა ფერის 5 ციკლი საჭეზე (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); დაგვიანება (ლოდინი); }}

// თეატრის სტილის მცოცავი შუქები.

void theaterChase (uint32_t c, uint8_t ლოდინი) {for (int j = 0; j <10; j ++) {// გააკეთეთ 10 ციკლი დევნისათვის (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // ყოველი მესამე პიქსელის ჩართვა} strip.show ();

დაგვიანება (ლოდინი);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // გამორთეთ ყოველი მესამე პიქსელი}}}}

// თეატრის სტილის მცოცავი შუქები ცისარტყელას ეფექტით

void theaterChaseRainbow (uint8_t ლოდინი) {for (int j = 0; j <256; j ++) {// ციკლის ყველა 256 ფერი ბორბალზე (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, Wheel ((i+j) % 255)); // ყოველი მესამე პიქსელის ჩართვა} strip.show ();

დაგვიანება (ლოდინი);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // გამორთეთ ყოველი მესამე პიქსელი}}}}

// შეიყვანეთ მნიშვნელობა 0 -დან 255 -მდე, რომ მიიღოთ ფერის მნიშვნელობა.

// ფერები არის გარდამავალი r - g - b - უკან r. uint32_t ბორბალი (ბაიტი WheelPos) {WheelPos = 255 - WheelPos; if (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); // შეინარჩუნეთ უფლება გაათავისუფლოთ თქვენი თავი გამა ფერითა კომპრენდია 0x000000 y 0xFFFFFF

// CylonEyeColor = HtmlColor (elegirColor); // int elegirColor = შემთხვევითი (1, 7); // Podemos elegir aleatoriamente entre los 7 colours 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 (0xff) // if (elegirColor == 5) CylonEyeColor = HtmlColor (0x200020); // Morado // if (elegirColor == 6) CylonEyeColor = HtmlColor (0x00ffff); // Azul Claro // if (elegirColor == 7) CylonEye HtmlColor (0x100010); // Rosa // CylonEyeColor = HtmlColor (0x000000);

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

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

/Metodos luces varias

// შეავსეთ წერტილები ერთმანეთის მიყოლებით ფერით

ბათილი ფერიWipe1 (uint32_t c, uint8_t ლოდინი) {for (uint16_t i = 0; i

ბათილი პულსი თეთრი (uint8_t ლოდინი) {

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 დაელოდეთ, 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 ფერის ციკლი ბორბალზე

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

}

// პირველი მარყუჟი, ქრებოდა!

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

// ბოლო მარყუჟი, ქრებოდა!

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

ზოლები. ჩვენება ();

დაგვიანება (ლოდინი); }}

დაგვიანება (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])); } strip.show (); }

დაგვიანება (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])); } strip.show (); }}

დაგვიანება (500);

}

void whiteOverRainbow (uint8_t ლოდინი, uint8_t თეთრი სიჩქარე, uint8_t თეთრი სიგრძე) {

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

int ხელმძღვანელი = თეთრი სიგრძე - 1;

int კუდი = 0;

int მარყუჟები = 3;

int loopNum = 0;

სტატიკური ხელმოუწერელი long lastTime = 0;

სანამ (მართალია) {

for (int j = 0; j <256; j ++) {for (uint16_t i = 0; i = tail && i head && i> = კუდი) || (კუდი> თავი && i <= თავი)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } else {strip.setPixelColor (i, Wheel ((((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

თავი ++; კუდი ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = მილი (); }

if (loopNum == მარყუჟები) დაბრუნდება;

თავი%= strip.numPixels (); კუდი%= strip.numPixels (); ზოლები. ჩვენება (); დაგვიანება (ლოდინი); }}} void fullWhite () {for (uint16_t i = 0; i

// ოდნავ განსხვავებული, ეს ცისარტყელას თანაბრად ანაწილებს მთელ ტერიტორიაზე

void rainbowCycle1 (uint8_t ლოდინი) {uint16_t i, j;

for (j = 0; j <256 * 5; j ++) {// ყველა ფერის 5 ციკლი საჭეზე (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); დაგვიანება (ლოდინი); }}

void rainbow1 (uint8_t ლოდინი) {

uint16_t i, j;

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

// შეიყვანეთ მნიშვნელობა 0 -დან 255 -მდე, რომ მიიღოთ ფერის მნიშვნელობა.

// ფერები არის გარდამავალი r - g - b - უკან r. uint32_t ბორბალი 1 (ბაიტი WheelPos) {WheelPos = 255 - WheelPos; if (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 >> 16); } uint8_t მწვანე (uint32_t გ) {დაბრუნება (c >> 8); } uint8_t ლურჯი (uint32_t გ) {დაბრუნება (გ); }

ნაბიჯი 8: 3D დიზაინი

უპირველეს ყოვლისა, თქვენ უნდა შეაფასოთ თქვენი აპარატურის კომპონენტები, რომ დარწმუნდეთ მის სისწორეში. თუ ისინი იგივეა, რაც ჩვენი, შეგიძლიათ გამოიყენოთ იგივე ფაილები, რომლებსაც ჩვენ ვაძლევთ სესხს.

ორივე საყრდენი შემუშავებულია 3D პრინტერის საშუალებით, რომლებიც ასევე შედის:

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

დაბოლოს, შუქი იქნება ორი ბოლო სურათის მსგავსი.

ნაბიჯი 9: კისრის დამონტაჟება

პირველ რიგში ჩვენ უნაგირის კისერს მოვათავსებთ. ხვრელები, რომლებიც ხრახნებს სჭირდებათ მის დასაჭერად, იქ არ არის, ამიტომ ჩვენ უნდა გავაკეთოთ ისინი, აღვნიშნოთ სად უნდა წავიდნენ და ფრთხილად, ავგერით, ხვრელს ვაკეთებთ.

იგივე ეხება ხვრელებს, სადაც ხრახნები, რომლებიც კისერზე უჭირავს თავად ინსტრუმენტის სხეულს. არ არის აუცილებელი მათი გაკეთება, რადგან ამ დამაგრებისთვის ხრახნები არ არის, მაგრამ თუ ჩვენ ამის გაკეთება გვსურს, პრობლემა არ იქნება.

მნიშვნელოვანია: დატოვეთ 5 მმ სივრცე ანძის დაწყებამდე და სამაგრი ჩანგლის დაწყებას შორის, რადგან ამ ხვრელში მოთავსდება კაკალი.

ჩვენ წებოვანა თხილის წებოთი, ფიგურის მიერ მითითებული მიმართულებით.

დაბოლოს, ჩვენ შემოვიღებთ 4 ქინძისთავს ხვრელებში, რომლებიც არის ანძის დასაწყისში, თითოეულ პინზე იჭერს 2 მოკლე ხრახნს, როგორც ეს მოცემულია სურათზე.

ნაბიჯი 10: ჩიტის დაყენება

ხიდი ფიქსირდება წებოთი და ორი გრძელი ხრახნით სხეულზე ცენტრალურ მდგომარეობაში. მიზანშეწონილია ფანქრით მონიშნოთ სხეულში სწორი პოზიცია. ჩვენ ვიღებთ დისტანციებს, რომლებიც გამოსახულია სურათზე.

ჩვენ წავუსვამთ წებოს ორი კომპონენტის გაერთიანებაში. ჩვენ ორ ნაწილს ყურადღებით ვაფიქსირებთ გამკაცრებელი ხრახნის დახმარებით, სანამ სახსარი არ გაშრება. ჩვენ ორ ხვრელს გავაკეთებთ ხრახნებისთვის 1.5 მმ საბურღი ხისთვის. შეასწორეთ ხიდი სხეულში ორი გრძელი ხრახნით. და ბოლოს, ჩვენ დავაყენეთ დამცავი ქუდები ხრახნების თავებზე.

ნაბიჯი 11: სხეულისა და კისრის შეკრება

ორი ნაწილის ასაწყობად, სხეულის ნაწილში გვაქვს ხვრელები, სადაც კისერი ჯდება ორი პროექციით, რაც მას აქვს. ჩვენ შეგვიძლია წებო მათ წებოთი ან ცხელი დნობის იარაღით. უფრო დიდი ფიქსაციისთვის, შეგიძლიათ გააკეთოთ ხვრელები, რომლებიც დასასრული ჩანგლის ბოლოს არის, რათა შეუერთდეს მას სხეულს.

ნაბიჯი 12: განათავსეთ უკულელის სიმები

დაბოლოს, ჩვენ უნდა მოვათავსოთ სიმები ისე, რომ ჩვენი ინსტრუმენტი დასრულდეს.

ადრე ჩვენ ჩავამაგრებთ ქინძისთავების დამაგრების რგოლებს მათ პროექციებში, რომლებიც ანძას გადის. სტრიქონების განთავსების მიზნით, ჩვენ ავიღეთ 4 სტრიქონი, რომელიც მოვიდა ნაკრებთან ერთად. პირველი თქვენ უნდა განასხვავოთ თითოეული სტრიქონი, რადგან ისინი ყველა ერთნაირი არ არის. თქვენ უნდა მიაბათ თითოეული სტრიქონის ერთი ბოლო (ორი სქელი ნორმალური კვანძით, ხოლო ორი თხელი ორმაგი) და ჩადეთ სტრიქონები ხიდის ჭრილში.

შემდეგ ჩვენ განვათავსებთ სტრიქონებს ისე, რომ:

• პირველი პოზიცია: G სიმებიანი (მეორე ყველაზე სქელი სიმებიანი).

• მეორე პოზიცია: C სიმებიანი (სქელი სიმებიანი).

• მესამე პოზიცია: E სიმებიანი (მეორე თხელი სიმებიანი).

• მეოთხე პოზიცია: სიმებიანი (თხელი სიმებიანი).

მიამაგრეთ სტრიქონები გათვალისწინებული დანამატის ხვრელებში. შეეცადეთ დააფიქსიროთ თითოეული თოკი ქინძისთავზე ორი ან სამი ბრუნვის მიცემით. დაძაბეთ სიმები ზედმეტი ძალის გამოყენების გარეშე და შეამოწმეთ მანძილი სიმებს და უნაგირს შორის.

თუ თქვენ გაქვთ რაიმე ეჭვი იმის შესახებ, თუ როგორ უნდა გააკეთოთ ეს, შეგიძლიათ ისწავლოთ ის სახელმძღვანელო, რომელიც აგიხსნით თუ როგორ სწორად მოაწყო სიმები.

ნაბიჯი 13: ტესტირება

დაბოლოს, ჩვენ უნდა დავინახოთ, არის თუ არა უკულელე სწორად აწყობილი ისე, რომ იდეალური მანძილი პირველ ფრეტზე არის 0.1 მმ, მეთორმეტეზე კი დაახლოებით 1.2 მმ.

საჭიროა, რომ აკრიფოთ უკულელეს სიმები. მე გირჩევთ ამ აპლიკაციას: GuitarTuna

ნაბიჯი 14: ისიამოვნეთ

ახლა თქვენ მხოლოდ უნდა დატკბეთ თქვენი უკულელებით.

თუ გსურთ იცოდეთ მეტი ინფორმაცია ჩვენს შესახებ, შეგიძლიათ მოგვძებნოთ აქ:

Twitter: @Innovart_cc

ფეისბუქი: @Innovartcc

Instagram: @Innovart_cc

ვებგვერდი: Innovart.cc