Ukulele אלקטרוני חכם DIY עם Arduino: 14 שלבים (עם תמונות)

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:16

אנו הולכים להסביר צעד אחר צעד כיצד אתה יכול לעצב יוקלילה משלך ולהוסיף כמה אפקטים שיהפכו אותו לייחודי, כמו ציור משהו שאנחנו רוצים על פני ה יוקלילה או הוספת כמה אפקטים של אור.

כדי לעשות זאת, יש צורך לרכוש ערכת יוקולילה.

אנו הולכים להסביר כיצד להרכיב את המכשיר ולפתור את הבעיות השונות שעלולות להופיע.

שלב 1: חומרים

חומרי מבנה:

ערכת הרכבה DIY (זה יכול להיות עוד ערכה אחרת) שנוצרה על ידי:

1- גוף.

2-צוואר.

3-אוכף

תמיכת 4 חבלים

5-גשר

אגוז בעל 6 חוטים.

טבעת 7-תיקון לראש מכונה (x4).

ראשי 8 מכונות (x4).

9 ברגי הרכבה לראשי מכונות (x8).

10 ברגי הרכבה לגשר מכונה (x2).

11 מכסי כיסוי לברגי הרכבה לגשר (x2).

12-מיתרים (x4).

חומרים אלקטרוניים:

• NANO Arduino.
• גלגל האורות WS2812.
• מד תאוצה BMA220 (אופציונלי).
• מחבר סוללה.
• סוללה של 9V.
• החלף.

אחרים

• לכה מעץ.
• סקוטש.
• פח הלחמה.
• פלסטיק מגן לכה.
• סיליקון נמס חם.

כלים:

• חריטת לייזר.
• נייר זכוכית
• מברג כוכבים.
• מכחול.
• אקדח התכה חם.
• ברזל הלחמה מפח.

שלב 2: התאם אישית את Ukulele

בכדי לאפיין את האוקוללה שלנו נוכל לחרוט ציור עם חותך לייזר על הגוף. במקרה שאין כלי כזה, נוכל לצבוע אותו.

התמונה שבחרנו היא הראשונה שמופיעה.

קודם כל, עלינו לעצב את תבנית הציור לצורך החריטה.

לשם כך נשתמש בתוכנה בשם 'Inkscape' אותה אנו יכולים להשיג מקישור זה:

כדי להשתמש בה, עלינו להתאים את התמונה שאנו רוצים להשתמש בה כפי שאנו מציגים בתמונה השנייה. אתה יכול להבחין שאנו סובבים את התמונה ההתחלתית לכוון את כף היד עם העיגול של המכשיר. כמו שאמרנו בעבר, אתה יכול לשים כל תמונה.

שלב 3: וקטור תמונה באמצעות Inkscape

נראה כיצד ליצור קובץ וקטורי מ- pixmap (jpg, png, כל פורמט רסטר ש- Inkscape יכול לפתוח).

Inkscape Inkscape הוא עורך גרפיקה וקטורית עם קוד פתוח, וכפי שכותרתו מרמזת, זהו הכלי שבו אשתמש כדי להפוך את הלוגואים לווקטוריים. צעדים וקטוריים השלבים נפוצים בכל וקטוריזציה שתרצה לבצע.

1. פתח את התמונה ב- Inkscape
2. פתח את נתיב כלי מפת הסיביות מעקב-> מעקב סיביות מעקב
3. שחקו באפשרויות מפת הסיביות Trace
4. הפעל את המעקב
5. נקה את התוצאות (במידת הצורך)

שימו לב לחלק ה"משחק ". אני לא מומחה לאיתור, ולכן אני מתייחס לכלי הזה כאל קופסה שחורה עם ידיות ואורות, מתפתלת ומשתנה עד לקבלת התוצאה הטובה ביותר.

שלב 4: חריטת לוגו

לשם כך חשוב שתהיה צללית של המשטח שעליו תיוצר החריטה של הציור.

כדי לבצע את החריטה, אנו הולכים להשתמש בתוכנת 'T2Laser'. נוכל להשיג תוכנה זו מ:

לאחר שפתחנו את התוכנה, עלינו לטעון את התמונה שיצרנו בשלב האחרון. לאחר מכן, לחץ על הלחצן "לייזר שליטה", ומופיע פקדי ה- cnc. שתי התמונות מציגות את התהליך ואת תוצאת החריטה עם חותך הלייזר שלנו.

שלב 5: שיוף ולכה

כדי להשאיר את האוקוליל שלנו בהיר ובשכבה ללא חספוס נוכל לשייף בצורה חלקה את שני החלקים המרכיבים את המכשיר שלנו, מכיוון שנוכל לפגוע בציור שנעשה (אם היית בוחר לצבוע את היוקלילה, יהיה עליך חול אותו קודם). לאחר מכן נלכה את שני החלקים שלנו כך שיקבלו צבע כהה יותר והעץ יציג עמידות רבה יותר. אנחנו יכולים להשתמש בלכה מעץ רגיל, זה לא צריך להיות מיוחד.

ברגע שיש לנו את הלכה, אנו מערבבים אותו עם מעט ממס כך שהוא נמס מעט. לאחר מכן, אנו מורחים את התערובת בעזרת מברשת על הצוואר ועל גוף המכשיר ונותנים לו להתייבש.

אם נראה שהמוצר צריך שכבה שנייה, נוכל לשייף מעט את שני החלקים ולמרוח מחדש שכבת לכה מדוללת.

** אמצעי זהירות: הלכה היא מוצר כימי, ולכן יש צורך לבצע תהליך זה במקום מאוורר, ללבוש מסכה כדי להימנע משאיפת ריחות ומשקפי מגן.

החומרים שאנו זקוקים להם כדי שנוכל לעבוד נכון הם החומרים המופיעים בתמונות. בעיקר נעבוד עם מברשת, פחית לכה (במקרה שלנו צבע אדום), מעט ממס והגנה חזותית. ומעל הכל עבודה במקומות מאווררים היטב.

שלב 6: חומרה

הלוח שלנו עם הארדואינו, מד התאוצה והגלגל עם תאי האורות יוצגו בסוגר קטן כדי להימנע מכך שכל הרכיבים נעים במכשיר.

הוספנו גם מחזיק סוללה ומתג כדי להפוך אותו לנוח יותר ואיננו מתבלות את הסוללה כאשר איננו משתמשים במכשיר. נצמיד את התמיכה הזו עם פיסת סקוטש (זה יעבוד גם עם סיליקון ואקדח חם) לפנים הפנימיות של גוף האוקוללה. מצד שני, גלגל הלד קטן מהחור, כך שהוא ייפול. תמיכה תוכננה כך שתחזיק היטב ותוכל לבצע את תפקידה.

שלב 7: תוכנה

כדי להעניק קישוט מיוחד ליוקלילה שלנו, נוכל להוסיף אפקטים של אור הודות לגלגל של נוריות. אנו הולכים להשתמש ב- WS2812, אך תוכל להשתמש בכל אחר בהתאם להוראות גליון הנתונים. נשתמש גם במד תאוצה (BMA220) המאפשר לנו להשפיע על כוח הכבידה.

למעשה, יהיו לנו 4 הצגות אור, כלולות בספריית המחשבים בשם 'Adafruit' של Arduino. לשם כך עלינו לערוך חיבור נכון בין שלושת המרכיבים: Arduino NANO, WS2812 ו- BMA220, כמו שמופיע בתמונה הראשונה.

החוטים האדומים מיועדים להספק, השחורים GND והשאר חיבורים הכרחיים לפעולה הנכונה. הקוד שהשתמשנו עבור ערכת האור מצורף בקובץ בשם "play_of_light_v0.ino". ודא שכללת את הספריות הדרושות להפעלה נכונה של התוכנית. הסוללה שאנו מוסיפים חיצונית למעגל חייבת להיות בעלת מתח מינימלי של 9V ועלינו לוודא שהיא מסוגלת לתת את הזרם המינימלי הדרוש להפעלת המעגל כולו.

// משתנים 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_data; טווח בתים = 0x00; לצוף divi = 16; לצוף x, y, z; float pi = 3.14159265359; לצוף nx, ny, זווית; int led, previousLed; 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 w/WS2812 נוריות) // NEO_KHZ400 400 KHz (קלאסיות 'v1' (לא v2) פיקסלים של FLORA, מנהלי התקנים WS2811) // NEO_GRB פיקסלים מחוברים ל- bitstream GRB (רוב מוצרי NeoPixel)/ / NEO_RGB הפיקסלים מחוברים לזרם סיביות RGB (פיקסלים v1 FLORA, לא v2) // NEO_RGBW פיקסלים מחוברים ל- RGBW bitstream (מוצרי NeoPixel RGBW) רצועת Adafruit_NeoPixel = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // חשוב: כדי להפחית את הסיכון לשחיקה של NeoPixel, הוסף 1000 קבלים uF לרוחבי // פיקסלים, הוסף 300 - 500 אוהם על קלט הנתונים של הפיקסל הראשון // וצמצם את המרחק בין Arduino לפיקסל הראשון. הימנע מחיבור // במעגל חי … אם עליך, תחבר תחילה את GND.

// משתנים Rueda de colores

// סקיצה פשוטה של NeoPixel (c) Shae Erisson 2013 // שוחררה תחת רישיון GPLv3 להתאמה לשאר ספריית AdaFruit NeoPixel

#לִכלוֹל

#ifdef _AVR_ #כלול #endif

// איזו סיכה ב- Arduino מחוברת ל- NeoPixels?

// ב- Trinket או Gemma אנו מציעים לשנות את זה ל- #9 הגדרת מספר PIN אחד

// כמה NeoPixels מחוברים ל- Arduino?

#הגדר NUMPIXELS 16

// כאשר אנו מגדירים את ספריית NeoPixel, אנו מספרים לה כמה פיקסלים, ובאיזה סיכה להשתמש כדי לשלוח אותות.

// שים לב כי עבור רצועות NeoPixel ישנות יותר ייתכן שיהיה עליך לשנות את הפרמטר השלישי-עיין בדוגמת בדיקת הגדילה // למידע נוסף על ערכים אפשריים. Adafruit_NeoPixel פיקסלים = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // עיכוב של 50 ms

// משתנים colores aleatorios

#כלול #ifdef _AVR_ #כלול #endif

#הגדר PIN 9

#הגדר NUM_LEDS 16

#define BRIGHTNESS 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

הגדרת void () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (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 ב- wiki Wire.endTransmission ();

// קודיגו; לוקס ארקוריס

// זה מיועד ל- Trinket 5V 16MHz, תוכל להסיר את שלושת השורות האלה אם אינך משתמש ב- Trinket #if מוגדר (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // סוף תכונה מיוחדת של strip.begin (); strip.show (); // אתחל את כל הפיקסלים ל'כבוי '

// Código Rueda de colores

// זה מיועד ל- Trinket 5V 16MHz, תוכל להסיר את שלושת השורות האלה אם אינך משתמש ב- Trinket #if מוגדר (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // סוף קוד מיוחד של תכשיטים

פיקסלים.התחל (); // זה מאתחל את ספריית NeoPixel.

// Codigo Interrupcion

מונה = 1;

// Codigo Colores varios

// זה מיועד ל- Trinket 5V 16MHz, תוכל להסיר את שלושת השורות האלה אם אינך משתמש ב- Trinket #if מוגדר (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // סוף תכשיט מיוחד של קוד תכשיט מיוחד.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // אתחל את כל הפיקסלים ל'כבוי '}

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

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

/Bucle infinito

לולאת void () {// Caso 1: Juego de luces de la gravedad; if (counter == 1) {for (int i = 0; i 0.0) {if (nx 0.0) זווית+= 180; זווית אחרת += 360; } // סוף אחר אם (זווית == 360.0) זווית = 0.0; led = מעגל (זווית / (360 / NUMBER_OF_LEDS_ON_RING)); // להפוך את תנועת ה- LED חלקה אם (previousLed == led) {// אין מה לעשות} אחרת אם (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); else led = מעגליזציה (previousLed - 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 (strip. Color (255, 0, 0), 50); // אדום colorWipe1 (strip. Color (0, 255, 0), 50); // ירוק colorWipe1 (strip. Color (0, 0, 255), 50); // כחול colorWipe1 (strip. Color (0, 0, 0, 255), 50); // RGBW לבן // שלח מרדף פיקסל לתיאטרון ב … theaterChase (strip. Color (127, 127, 127), 50); // תיאטרון לבן צ'ייס (strip. Color (127, 0, 0), 50); // תיאטרון אדום צ'ייס (strip. Color (0, 0, 127), 50); // כחול

קשת (5);

rainbowCycle (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); עבור (int i = 0; i

// פיקסלים.צבע לוקח ערכי RGB, מ 0, 0, 0 עד 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // צבע ירוק בהיר למדי.

pixels.show (); // פעולה זו שולחת את צבע הפיקסל המעודכן לחומרה.

עיכוב (delayval); // עיכוב לפרק זמן (באלפיות השנייה).

} a = אקראי (255); b = אקראי (255); c = אקראי (255); עבור (int i = NUMPIXELS; i> 0; i-) {

// פיקסלים.צבע לוקח ערכי RGB, מ 0, 0, 0 עד 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // צבע ירוק בהיר למדי.

pixels.show (); // פעולה זו שולחת את צבע הפיקסל המעודכן לחומרה.

עיכוב (delayval); // עיכוב לפרק זמן (באלפיות השנייה).

}} מונה = 4; } אחרת אם (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); // כחול colorWipe (strip. Color (0, 0, 0, 255), 50); // לבן לבן OverRainbow (20, 75, 5); דופק לבן (5); // fullWhite (); // עיכוב (2000); rainbowFade2White (3, 3, 1);

}

מונה = 1; }} ////////////////////////////////// //////////////////////////////////////////////// ////////////////////////////////////////// //////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // כתובת מד התאוצה // אפס את מד התאוצה Wire.write (0x04); // X נתונים Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // לבקש 6 בתים ממכשיר העבדים מספר 2 בעוד (Wire.available ()) // העבד עשוי לשלוח פחות מהמתבקש {Version [0] = Wire.read (); // קבל בתים כמאפיין} x_data = (int8_t) גרסה [0] >> 2; שידור Wire.beginTransmission (0x0A); // כתובת מד התאוצה // אפס את מד התאוצה Wire.write (0x06); // Y data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // לבקש 6 בתים ממכשיר העבדים מספר 2 בעוד (Wire.available ()) // העבד עשוי לשלוח פחות מהמתבקש {Version [1] = Wire.read (); // לקבל בתים בתור characte} y_data = (int8_t) גירסה [1] >> 2; שידור Wire.beginTransmission (0x0A); // כתובת מד התאוצה // אפס את מד התאוצה Wire.write (0x08); // Z data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // לבקש 6 בתים ממכשיר העבדים מספר 2 בעוד (Wire.available ()) // העבד עשוי לשלוח פחות מהמתבקש {Version [2] = Wire.read (); // לקבל בתים בתור characte} z_data = (int8_t) גירסה [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) {

אם (pos> = NUMBER_OF_LEDS_ON_RING) החזרה (pos - NUMBER_OF_LEDS_ON_RING); אחרת אם (pos <0) החזרה (pos + NUMBER_OF_LEDS_ON_RING); אחרת החזרה (פוס); }

מרחק int;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; אם (מרחק <0) מרחק += NUMBER_OF_LEDS_ON_RING; החזרה (מרחק); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

עבור (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

// מלאו את הנקודות בזה אחר זה עם צבע חלל colorWipe (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i

קשת חלל (uint8_t המתן) {

uint16_t i, j;

עבור (j = 0; j <256; j ++) {עבור (i = 0; i

// מעט שונה, זה הופך את הקשת לחלק שווה לכל אורך

void rainbowCycle (uint8_t wait) {uint16_t i, j;

עבור (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 wait) {for (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) {for (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 גלגל (בייט WheelPos) {WheelPos = 255 - WheelPos; אם (WheelPos <85) {strip return. Color (255 - WheelPos * 3, 0, WheelPos * 3); } אם (WheelPos <170) {WheelPos -= 85; רצועת החזרה.צבע (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; רצועת החזרה.צבע (WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/Metodos Rueda de colores

// int elegirColor = random (0x000000, 0xffffff); // Se elige aleatoriamente entre toda la gama de colores comprendida entre 0x000000 y 0xFFFFFF

// CylonEyeColor = HtmlColor (elegirColor); // int elegirColor = random (1, 7); // Podemos elegir aleatoriamente entre los 7 colores que hay debajo0xf0ffff // if (elegirColor == 1) CylonEyeColor = HtmlColor (0xff0000); // Rojo // if (elegirColor == 2) CylonEyeColor = HtmlColor (0x00ff00); // Verde // if (elegirColor == 3) CylonEyeColor = HtmlColor (0x0000ff); // Azul // if (elegirColor == 4) CylonEyeColor = HtmlColor (0xffff00); // 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

// מלאו את הנקודות בזו אחר זו בצבע

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

דופק ריק White (uint8_t wait) {

עבור (int j = 0; j <256; j ++) {עבור (uint16_t i = 0; i

עבור (int j = 255; j> = 0; j-) {

עבור (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 מחזורים של כל הצבעים על הגלגל

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

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

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

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

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

}

// לולאה ראשונה, דוהה פנימה!

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

// לולאה אחרונה, דוהה החוצה!

אחרת אם (k == rainbowLoops - 1 && j> 255 - fadeMax) {fadeVal--; }

strip.show ();

עיכוב (המתנה); }}

עיכוב (500);

עבור (int k = 0; k <whiteLoops; k ++) {

עבור (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);

עבור (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 wait, uint8_t whiteSpeed, uint8_t whiteLength) {

אם (whiteLength> = strip.numPixels ()) whiteLength = strip.numPixels () - 1;

int int = whiteLength - 1;

int זנב = 0;

לולאות int = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

בעוד (נכון) {

for (int j = 0; j <256; j ++) {for (uint16_t i = 0; i = זנב && i ראש && i> = זנב) || (tail> head && i <= head)) {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 = millis (); }

if (loopNum == לולאות) להחזיר;

head%= strip.numPixels (); זנב%= strip.numPixels (); strip.show (); עיכוב (המתנה); }}} void fullWhite () {עבור (uint16_t i = 0; i

// מעט שונה, זה הופך את הקשת לחלק שווה לכל אורך

void rainbowCycle1 (uint8_t wait) {uint16_t i, j;

עבור (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 wait) {

uint16_t i, j;

עבור (j = 0; j <256; j ++) {עבור (i = 0; i

// הזן ערך 0 עד 255 כדי לקבל ערך צבע.

// הצבעים הם מעבר r - g - b - חזרה ל- r. uint32_t Wheel1 (בייט WheelPos) {WheelPos = 255 - WheelPos; אם (WheelPos <85) {strip return. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } אם (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) {return (c >> 8); } uint8_t כחול (uint32_t c) {return (c); }

שלב 8: עיצוב תלת מימד

ראשית, עליך לגודל את רכיבי החומרה שלך כדי להיות בטוח לגבי הנכונות. אם הם זהים לשלנו, תוכל להשתמש באותם קבצים שאנו מלווים לך.

שתי התמיכות עוצבו עם מדפסת תלת מימד, הנכללות גם כ:

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: תהנה מזה

עכשיו, אתה רק צריך ליהנות מהאוקוללה שלך.

אם אתה רוצה לדעת מידע נוסף עלינו, תוכל למצוא אותנו ב:

טוויטר: @Innovart_cc

פייסבוק: @Innovartcc

אינסטגרם: @Innovart_cc

אינטרנט: Innovart.cc