DIY Smart Electronic Ukulele With Arduino: 14 Steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

Vi kommer att förklara steg för steg hur du kan designa din egen ukulele och lägga till några effekter som gör det unikt, som att rita något som vi vill ha på ukulele eller lägga till några ljuseffekter.

För att göra det är det nödvändigt att köpa ett ukulele -kit.

Vi ska förklara hur man monterar instrumentet och lösa de olika problemen som kan uppstå.

Steg 1: Material

Strukturmaterial:

DIY ukelele -monteringssats (det kan vara ett annat annorlunda kit) bildat av:

1- Kropp.

2-hals.

3-sadel

Stöd för 4 rep

5-bro

6-strängad mutter.

7-fästring för maskinhuvud (x4).

8-maskinhuvuden (x4).

9-monteringsskruvar för maskinhuvuden (x8).

10-monteringsskruvar för maskinbrygga (x2).

11-locklock för bryggmonteringsskruvar (x2).

12-strängar (x4).

Elektroniska material:

• NANO Arduino.
• Wheel of Leds WS2812.
• Accelerometer BMA220 (tillval).
• Batterikontakt.
• Batteri på 9V.
• Växla.

Andra

• Trä lack.
• Kardborre.
• Lödtenn.
• Skyddande plast för lackering.
• Smält silikon.

Verktyg:

• Lasergravering.
• Sandpapper
• Stjärnskruvmejsel.
• Pensel.
• Smältpistol.
• Tennlödkolv.

Steg 2: Anpassa Ukulele

För att kostymera vår ukulele kunde vi göra en gravering av en ritning med en laserskärare på kroppen. Om vi inte har det verktyget kan vi måla det.

Bilden som vi har valt är den första som visas.

Först och främst måste vi designa ritningsmallen för att göra graveringen.

För att utföra det kommer vi att använda en programvara som heter 'Inkscape' som vi kan få från denna länk:

För att använda den måste vi justera bilden som vi vill använda som vi visar i den andra bilden. Du kan se att vi har roterat den ursprungliga bilden till kan justera handens rulle med instrumentets cirkel. Som vi har sagt tidigare kan du sätta vilken bild som helst.

Steg 3: Vektorisera en bild med hjälp av Inkscape

Vi får se hur man skapar en vektorfil från en pixmap (jpg, png, vilket rasterformat som Inkscape kan öppna).

Inkscape Inkscape är en vektorgrafikredigerare med öppen källkod, och som titeln antyder är detta verktyget som jag kommer att använda för att vektorisera logotyperna. Vektorisering av stegen Stegen är vanliga för alla vektoriseringar vi kanske vill göra.

1. Öppna bilden i Inkscape
2. Öppna sökväg för spårning av bitmapsverktyg-> spårning av bitmapp
3. Spela runt alternativen Spåra bitmapp
4. Kör spårningen
5. Rensa resultaten (om det behövs)

Lägg märke till “spela runt” -delen. Jag är ingen expert på spårning, så jag behandlar det här verktyget som en svart låda med vred och lampor, vridning och ändring tills jag får det bästa resultatet

Steg 4: Logotyp

För detta är det viktigt att ha en silhuett av ytan på vilken graveringen av ritningen kommer att produceras.

För att göra graveringen kommer vi att använda "T2Laser" -programvara. Vi kan skaffa denna programvara från:

När vi har öppnat programvaran måste vi ladda bilden som vi har skapat i det sista steget. Tryck sedan på knappen "kontrolllaser" och cnc -kontrollerna visas. De två bilderna visar processen och resultatet av graveringen med vår laserskärare.

Steg 5: Slipning och lackering

För att lämna vår ukulele ljus och med ett lager utan grovhet kan vi smidigt slipa de två delarna som utgör vårt instrument med försiktighet, eftersom vi kan skada ritningen som har gjorts (om du har valt att måla ukulelen måste du slipa den först). Sedan kommer vi att lacka våra två delar så att de får en mörkare färg och träet ger mer motstånd. Vi kan använda ett vanligt trälack, det behöver inte vara speciellt.

När vi fått lacken blandar vi det med lite lösningsmedel så att det löser sig lite. Därefter applicerar vi blandningen med en pensel på halsen och instrumentets kropp och låter den torka.

Om vi ser att produkten behöver en andra skikt kan vi slipa de två delarna lite och applicera ett lager utspätt lack.

** FÖRSIKTIGHETSÅTGÄRDER: Lacken är en kemisk produkt, så det är nödvändigt att utföra denna process på en ventilerad plats, bära en mask för att undvika inandning av lukt och skyddsglasögon.

De material som vi behöver för att kunna fungera korrekt är de som visas på bilderna. Främst kommer vi att arbeta med en pensel, en lackburk (i vårt fall röd färg), lite lösningsmedel och visuellt skydd. Och framför allt arbete i väl ventilerade utrymmen.

Steg 6: Hårdvara

Vår plakett med Arduino, acelerometern och hjulet med lysdioder kommer att introduceras i en liten konsol för att undvika att alla komponenter rör sig i instrumentet.

Vi har också lagt till en batterihållare och en omkopplare för att göra det mer bekvämt och vi sliter inte på batteriet när vi inte använder instrumentet. Vi kommer att fästa detta stöd med en kardborreband (det fungerar också med silikon och en smältpistol) på ukulelekroppens insida. Å andra sidan är LED -hjulet mindre än hålet, så det skulle falla. Ett stöd har utformats så att det håller bra och kan utföra sin funktion.

Steg 7: Programvara

För att ge vår ukulele en speciell dekoration kan vi lägga till ljuseffekter tack vare ett hjul med lysdioder. Vi kommer att använda WS2812, men du kan använda alla andra enligt instruktionerna i databladet. Vi kommer också att använda en acelerometer (BMA220) som gör att vi kan påverka gravitationen.

Faktum är att vi kommer att ha 4 ljusspel, inkluderade i datorbiblioteket som heter 'Adafruit' i Arduino. För det måste vi göra en korrekt sammanhang mellan de tre komponenterna: Arduino NANO, WS2812 och BMA220, som visas i den första bilden.

De röda ledningarna är för ström, GND -svarta och resten är nödvändiga anslutningar för korrekt funktion. Koden som vi använde för ljussatsen är bifogad i en fil som heter "play_of_light_v0.ino". Se till att du har inkluderat nödvändiga bibliotek för att programmet ska fungera korrekt. Batteriet som vi lägger till externt i kretsen måste ha en lägsta spänning på 9V och vi måste se till att det kan ge den minsta ström som krävs för att driva hela kretsen.

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

byteversion [3];

int8_t x_data; int8_t y_data; int8_t z_data; byteintervall = 0x00; float divi = 16; flyta x, y, z; float pi = 3.14159265359; flyta nx, ny, vinkel; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Variabler Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parameter 1 = antal pixlar i remsan // Parameter 2 = Arduino pin -nummer (de flesta är giltiga) // Parameter 3 = pixeltypflaggor, lägg ihop efter behov: // NEO_KHZ800 800 KHz bitström (de flesta NeoPixel -produkter med WS2812 lysdioder) // NEO_KHZ400 400 KHz (klassiska 'v1' (inte v2) FLORA -pixlar, WS2811 -drivrutiner) // NEO_GRB Pixlar är anslutna för GRB -bitström (de flesta NeoPixel -produkter)/ / NEO_RGB -pixlar är anslutna för RGB -bitström (v1 FLORA -pixlar, inte v2) // NEO_RGBW -pixlar är anslutna för RGBW -bitström (NeoPixel RGBW -produkter) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // VIKTIGT: För att minska risken för NeoPixel -utbrändhet lägger du till 1000 uF kondensator över // pixelkablar, lägger till 300 - 500 Ohm motstånd på den första pixelens datainmatning // och minimerar avståndet mellan Arduino och första pixeln. Undvik att ansluta // på en spänningskrets … om du måste, anslut GND först.

// Variabler Rueda de colores

// NeoPixel Ring enkel skiss (c) Shae Erisson 2013 // släppt under GPLv3 -licensen för att matcha resten av AdaFruit NeoPixel -biblioteket

#omfatta

#ifdef _AVR_ #inkludera #endif

// Vilken pin på Arduino är ansluten till NeoPixels?

// På en prydnad eller Gemma föreslår vi att du ändrar detta till 1 #define PIN 9

// Hur många NeoPixels är anslutna till Arduino?

#define NUMPIXELS 16

// När vi konfigurerar NeoPixel -biblioteket berättar vi hur många pixlar och vilken pin som ska användas för att skicka signaler.

// Observera att för äldre NeoPixel-remsor kan du behöva ändra den tredje parametern-se exempel på strängtest // för mer information om möjliga värden. Adafruit_NeoPixel pixlar = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // fördröjning i 50 ms

// Variabler colores aleatorios

#include #ifdef _AVR_ #include #endif

#definiera PIN 9

#define NUM_LEDS 16

#define BRIGHTNESS 200

// Adafruit_NeoPixel strip = Adafruit_NeoPixel (NUM_LEDS, 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 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/METODO SETUP

void setup () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // accelerometerns adress // intervallinställningar Wire.write (0x22); // registeradress Wire.write (intervall); // kan ställas in på "0x00" "0x01" "0x02" "0x03", se Datashhet på wiki // lågpassfilter Wire.write (0x20); // registrera adressen Wire.write (0x05); // kan ställas in på "0x05" "0x04" …… "0x01" "0x00", se Datashhet på wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Detta är för Trinket 5V 16MHz, du kan ta bort dessa tre rader om du inte använder en Trinket #if definierad (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Slut på prydnadsspecialkodremsa. börjar (); strip.show (); // Initiera alla pixlar till 'av'

// Código Rueda de colores

// Detta är för Trinket 5V 16MHz, du kan ta bort dessa tre rader om du inte använder en Trinket #if definierad (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Slut på prydnadsspecialkod

pixlar. börjar (); // Detta initierar NeoPixel -biblioteket.

// Codigo Interrupcion

räknare = 1;

// Codigo Colores varios

// Detta är för Trinket 5V 16MHz, du kan ta bort dessa tre rader om du inte använder en Trinket #if definierad (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Slut på prydnadsspecialkodremsa.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Initiera alla pixlar till 'av'}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (räknare == 1) {för (int i = 0; i 0,0) {om (nx 0,0) vinkel+= 180; annars vinkel += 360; } // slutet annat om (vinkel == 360,0) vinkel = 0,0; led = cirkulera (vinkel / (360 / NUMBER_OF_LEDS_ON_RING)); // gör ledrörelsen smidig om (previousLed == led) {// inget att göra} annars om (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); annars ledde = cirkuläriserar (previousLed - 1); ledQueue.push (led); makeLightShow (); previousLed = led; fördröjning (25); } räknare = 2; } // Avsluta om räknare == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Några exempel på procedurer som visar hur man visar till pixlarna: colorWipe1 (strip. Color (255, 0, 0), 50); // Röd colorWipe1 (strip. Color (0, 255, 0), 50); // Grön colorWipe1 (strip. Color (0, 0, 255), 50); // Blå colorWipe1 (strip. Color (0, 0, 0, 255), 50); // Vit RGBW // Skicka en teaterpixeljakt i … theaterChase (strip. Color (127, 127, 127), 50); // White theaterChase (strip. Color (127, 0, 0), 50); // Red theaterChase (strip. Color (0, 0, 127), 50); // Blå

regnbåge (5);

rainbowCycle (5); theaterChaseRainbow (5); } räknare = 3; } // Avsluta om räknare == 2 // Caso 3: Luces Aleatorias annars om (räknare == 3) {för (int k = 0; k <50; k ++) {// För en uppsättning NeoPixels är den första NeoPixel 0, andra är 1, ända upp till antalet pixlar minus en. int a = slumpmässigt (255); int b = slumpmässigt (255); int c = slumpmässigt (255); för (int i = 0; i

// pixlar. Color tar RGB -värden, från 0, 0, 0 upp till 255, 255, 255

pixels.setPixelColor (i, pixlar. Color (a, b, c)); // Måttligt ljusgrön färg.

pixlar. visa (); // Detta skickar den uppdaterade pixelfärgen till hårdvaran.

fördröjning (delayval); // Fördröjning under en viss tid (i millisekunder).

} a = slumpmässigt (255); b = slumpmässig (255); c = slumpmässig (255); för (int i = NUMPIXELS; i> 0; i-) {

// pixlar. Color tar RGB -värden, från 0, 0, 0 upp till 255, 255, 255

pixels.setPixelColor (i, pixlar. Color (a, b, c)); // Måttligt ljusgrön färg.

pixlar. visa (); // Detta skickar den uppdaterade pixelfärgen till hårdvaran.

fördröjning (delayval); // Fördröjning under en viss tid (i millisekunder).

}} räknare = 4; } annars if (counter == 4) {for (int g = 0; g <= 6; g ++) {// Några exempel på procedurer som visar hur man visar för pixlarna: colorWipe (strip. Color (255, 0, 0), 50); // Röd colorWipe (strip. Color (0, 255, 0), 50); // Grön colorWipe (strip. Color (0, 0, 255), 50); // Blå colorWipe (strip. Color (0, 0, 0, 255), 50); // White whiteOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // fördröjning (2000); rainbowFade2White (3, 3, 1);

}

räknare = 1; }} ////////////////////////////////////////////// /////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// ///////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // accelerometerns adress // återställ accelerometern Wire.write (0x04); // X data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // begär 6 byte från slavenhet nr 2 medan (Wire.available ()) // slav kan skicka mindre än begärd {Version [0] = Wire.read (); // ta emot en byte som karaktär} x_data = (int8_t) Version [0] >> 2; Wire.beginTransmission (0x0A); // accelerometerns adress // återställ accelerometern Wire.write (0x06); // Y data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // begär 6 byte från slavenhet nr 2 medan (Wire.available ()) // slav kan skicka mindre än begärd {Version [1] = Wire.read (); // ta emot en byte som karaktär} y_data = (int8_t) Version [1] >> 2; Wire.beginTransmission (0x0A); // adressen till accelerometern // återställ accelerometern Wire.write (0x08); // Z data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // begär 6 byte från slavenhet nr 2 medan (Wire.available ()) // slav kan skicka mindre än begärd {Version [2] = Wire.read (); // ta emot en byte som karaktär} z_data = (int8_t) Version [2] >> 2; x = (float) x_data/divi; y = (float) y_data/divi; z = (float) z_data/divi; Serial.print ("X ="); Serial.print (x); // skriv ut tecknet Serial.print (""); Serial.print ("Y ="); Serial.print (y); // skriv ut tecknet Serial.print (""); Serial.print ("Z ="); // skriv ut tecknet Serial.println (z); }

int cirkulera (int pos) {

if (pos> = NUMBER_OF_LEDS_ON_RING) return (pos - NUMBER_OF_LEDS_ON_RING); annars om (pos <0) return (pos + NUMBER_OF_LEDS_ON_RING); annars retur (pos); }

int avstånd;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; om (avstånd <0) avstånd += NUMBER_OF_LEDS_ON_RING; retur (distans); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

för (int j = 0; j <NUMBER_OF_LEDS_ON_RING; j ++) neoring.setPixelColor (j, 0, 0, 0); currentQueueSize = ledQueue.count (); för (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

// Fyll prickarna efter varandra med en färg tomrum colorWipe (uint32_t c, uint8_t vänta) {för (uint16_t i = 0; i

void rainbow (uint8_t wait) {

uint16_t i, j;

för (j = 0; j <256; j ++) {för (i = 0; i

// Lite annorlunda, detta gör regnbågen lika fördelad över hela

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

för (j = 0; j <256*5; j ++) {// 5 cykler av alla färger på hjulet för (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); fördröjning (vänta); }}

// Krypande lampor i teaterstil.

void theaterChase (uint32_t c, uint8_t wait) {för (int j = 0; j <10; j ++) {// gör 10 cykler med att jaga efter (int q = 0; q <3; q ++) {för (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // slå på var tredje pixel} strip.show ();

fördröjning (vänta);

för (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // stäng av var tredje pixel}}}}

// Krypande lampor i teaterstil med regnbågseffekt

void theaterChaseRainbow (uint8_t wait) {för (int j = 0; j <256; j ++) {// cykla alla 256 färger i hjulet för (int q = 0; q <3; q ++) {för (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, Wheel ((i+j) % 255)); // slå på var tredje pixel} strip.show ();

fördröjning (vänta);

för (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // stäng av var tredje pixel}}}}

// Ange ett värde 0 till 255 för att få ett färgvärde.

// Färgerna är en övergång r - g - b - tillbaka till 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; returremsa. Färg (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; returremsa. Färg (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

// Fyll prickarna en efter en med en färg

void colorWipe1 (uint32_t c, uint8_t wait) {för (uint16_t i = 0; i

void pulseWhite (uint8_t wait) {

för (int j = 0; j <256; j ++) {för (uint16_t i = 0; i

för (int j = 255; j> = 0; j-) {

för (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;

för (int k = 0; k <rainbowLoops; k ++) {för (int j = 0; j <256; j ++) {// 5 cykler av alla färger på hjulet

för (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));

}

// Första slingan, blekna in!

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

// Sista slingan, blekna ut!

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

strip.show ();

fördröjning (vänta); }}

fördröjning (500);

för (int k = 0; k <whiteLoops; k ++) {

för (int j = 0; j <256; j ++) {

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

fördröjning (2000);

för (int j = 255; j> = 0; j-) {

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

fördröjning (500);

}

void whiteOverRainbow (uint8_t vänta, uint8_t whiteSpeed, uint8_t whiteLength) {

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

int head = whiteLength - 1;

int svans = 0;

int slingor = 3;

int loopNum = 0;

statisk osignerad lång lastTime = 0;

medan (sant) {

för (int j = 0; j <256; j ++) {för (uint16_t i = 0; i = svans && i huvud && i> = svans) || (tail> head && i <= head)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } annat {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

huvud ++; svans ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == loop) return;

huvud%= strip.numPixels (); svans%= strip.numPixels (); strip.show (); fördröjning (vänta); }}} void fullWhite () {för (uint16_t i = 0; i

// Lite annorlunda, detta gör regnbågen lika fördelad över hela

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

för (j = 0; j <256 * 5; j ++) {// 5 cykler av alla färger på hjulet för (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); fördröjning (vänta); }}

void rainbow1 (uint8_t wait) {

uint16_t i, j;

för (j = 0; j <256; j ++) {för (i = 0; i

// Ange ett värde 0 till 255 för att få ett färgvärde.

// Färgerna är en övergång r - g - b - tillbaka till 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; returremsa. Färg (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; returremsa. Färg (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t röd (uint32_t c) {

retur (c >> 16); } uint8_t grönt (uint32_t c) {retur (c >> 8); } uint8_t blå (uint32_t c) {retur (c); }

Steg 8: 3D -design

Först måste du storlek dina hårdvarukomponenter för att vara säker på att det är rätt. Om de är desamma som våra kan du använda samma filer som vi lånar dig.

Båda stöden har utformats med en 3D -skrivare, som också ingår som:

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

Slutligen kommer ljuset att vara som de två sista bilderna.

Steg 9: Montera nacken

Först placerar vi sadeln nacken. Hålen som skruvarna behöver för att hålla den finns inte där, så vi måste göra dem, markera var de ska gå och försiktigt, med en skruv, göra hålet.

Detsamma gäller hålen där skruvarna som håller själva halsen vid instrumentets kropp. Det är inte nödvändigt att göra dem, eftersom det inte finns några skruvar för detta fäste, men om vi vill göra det skulle det inte vara några problem.

VIKTIGT: lämna 5 mm utrymme mellan mastens början och stämgaffelns start, för i det hålet kommer muttern att placeras.

Vi kommer att limma muttern med lim, i den riktning som figuren anger.

Slutligen kommer vi att introducera de 4 stiften i hålen i början av masten, hålla varje stift med 2 korta skruvar som visas på bilden.

Steg 10: Montering av Birdge

Bron fixeras genom limning och med de två långa skruvarna i ett centralt läge på karossen. Det är lämpligt att markera med en penna rätt position i kroppen. Vi tar de avstånd som är markerade i bilden.

Vi kommer att applicera lim vid sammanslutningen av de två komponenterna. Vi fixar de två delarna noggrant med hjälp av en åtdragningsskruv tills fogen har torkat. Vi gör de två hålen för skruvarna med en 1,5 mm borr för trä. Fixera bron med de två långa skruvarna i karossen. Och slutligen sätter vi skyddskåporna på skruvarnas huvuden.

Steg 11: Kropps- och nackmontering

För att montera de två delarna har vi hål i kroppshuvudet, där nacken passar med två utskjutande delar. Vi kan limma dem med lim eller med smältpistolen. För att få en större fixering kan du göra hålen i änden av stämgaffeln för att fästa den med kroppen.

Steg 12: Sätt Ukulele Strings

Slutligen måste vi placera strängarna så att vårt instrument är klart.

Tidigare kommer vi att fästa stifternas fästringar i utsprången på dessa som går genom masten. För att placera strängarna tog vi de 4 strängarna som följde med satsen. Först måste du skilja varje sträng eftersom de inte är lika. Du måste knyta ena änden av varje sträng (de två tjocka med en normal knut och de två tunna med en dubbel) och sätt in strängarna i slitsarna på bron.

Sedan placerar vi strängarna på ett sådant sätt att:

• Första position: G -sträng (näst tjockaste sträng).

• Andra position: C -sträng (tjockare sträng).

• Tredje position: E -sträng (andra tunnare sträng).

• Fjärde position: En sträng (tunnare sträng).

Trä in strängarna i hålen på den medföljande kontakten. Försök att fixa varje rep genom att ge två eller tre varv på stiftet. Spänn strängarna utan att använda för mycket kraft och kontrollera avståndet mellan strängarna och sadeln.

Om du har några tvivel om hur du gör det kan du göra den där självstudien som förklarar hur du sätter strängarna korrekt.

Steg 13: Testning

Slutligen måste vi se om ukulele har monterats ordentligt på ett sådant sätt att det idealiska avståndet på den första bandet är 0,1 mm och på det tolfte är det ungefär 1,2 mm.

Behövs att du stämmer ukulelesträngarna. Jag rekommenderar dig den här appen: GuitarTuna

Steg 14: Njut av det

Nu behöver du bara njuta av din ukulele.

Om du vill veta mer information om oss kan du hitta oss på:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Webbplats: Innovart.cc