DIY Smart Electronic Ukulele With Arduino: 14 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:29

Vi vil forklare trin for trin, hvordan du kan designe din egen ukulele og tilføje nogle effekter, der vil gøre den unik, som at tegne noget, vi ønsker på overfladen af ukulele eller tilføje nogle lyseffekter.

For at gøre det er det nødvendigt at købe et ukulele -kit.

Vi vil forklare, hvordan instrumentet samles, og løse de forskellige problemer, der kan dukke op.

Trin 1: Materialer

Strukturmaterialer:

DIY ukelele -monteringssæt (det kan være et andet andet kit) dannet af:

1- Krop.

2-hals.

3-sadel

4-reb support

5-bro

6-strenget møtrik.

7-fastgørelsesring til maskinhoved (x4).

8-maskinhoveder (x4).

9-monteringsskruer til maskinhoveder (x8).

10-monteringsskruer til maskinbro (x2).

11-dæksler til bromonteringsskruer (x2).

12-strenge (x4).

Elektroniske materialer:

• NANO Arduino.
• Wheel of Leds WS2812.
• Accelerometer BMA220 (valgfrit).
• Batteristik.
• Batteri på 9V.
• Kontakt.

Andre

• Trælak.
• Velcro.
• Loddeform.
• Beskyttelsesplast til lakering.
• Hot melt silikone.

Værktøjer:

• Lasergravering.
• Sandpapir
• Stjerneskruetrækker.
• Pensel.
• Hot melt gun.
• Tin loddejern.

Trin 2: Tilpas Ukulele

For at koste vores ukulele kunne vi lave en gravering af en tegning med en laserskærer på kroppen. I tilfælde af ikke at have det værktøj, kunne vi male det.

Det billede, vi har valgt, er det første, der vises.

Først og fremmest skal vi designe tegningsskabelonen for at lave graveringen.

For at udføre det vil vi bruge en software kaldet 'Inkscape', som vi kunne få fra dette link:

For at bruge det skal vi justere det billede, vi vil bruge, som vi viser på det andet billede. Du kunne se, at vi har roteret det oprindelige billede til, kunne justere håndens cicle med instrumentets cirkel. Som vi har sagt før, kan du sætte et hvilket som helst billede.

Trin 3: Vektoriser et billede ved hjælp af Inkscape

Vi ser, hvordan man opretter en vektorfil fra en pixmap (jpg, png, uanset hvilket rasterformat Inkscape kan åbne).

Inkscape Inkscape er en open source-vektorgrafikredaktør, og som titlen antyder, er dette det værktøj, jeg vil bruge til at vektorisere logoerne. Vektorisering af trinene Trinene er almindelige for enhver vektorisering, vi måske vil udføre.

1. Åbn billedet i Inkscape
2. Åbn Trace Bitmap Tool Path-> Trace Bitmap
3. Spil rundt i mulighederne for sporing af bitmap
4. Kør sporingen
5. Ryd op i resultaterne (hvis det er nødvendigt)

Bemærk delen "spiller rundt". Jeg er ikke ekspert i at spore, så jeg behandler dette værktøj som en sort æske med knapper og lys, der vrider og ændrer, indtil jeg får det bedste resultat

Trin 4: Logo gravering

Til dette er det vigtigt at have en silhuet af overfladen, hvorpå tegningen af tegningen vil blive fremstillet.

For at lave graveringen kommer vi til at bruge 'T2Laser' software. Vi kunne få denne software fra:

Når vi har åbnet softwaren, skal vi indlæse det billede, vi har oprettet i det sidste trin. Tryk derefter på knappen "kontrollaser", og cnc -kontrollerne vises. De to billeder viser processen og resultatet af graveringen med vores laserskærer.

Trin 5: Slibning og lakering

For at forlade vores ukulele lyst og med et lag uden ruhed kan vi glat slibe de to dele, der udgør vores instrument, med omhu, fordi vi kan beskadige tegningen (hvis du har valgt at male ukulele, skal du sand det først). Derefter lakerer vi vores to dele, så de får en mørkere farve, og træet giver mere modstand. Vi kan bruge en almindelig trælak, det behøver ikke at være specielt.

Når vi har lakken, blander vi det med lidt opløsningsmiddel, så det opløses lidt. Derefter påfører vi blandingen med en børste på nakken og instrumentets krop og lader den tørre.

Hvis vi ser, at produktet har brug for et andet lag, kan vi slibe de to dele lidt og påføre et lag fortyndet lak igen.

** FORHOLDSREGLER: Lakken er et kemisk produkt, så det er nødvendigt at udføre denne proces på et ventileret sted, bære en maske for at undgå indånding af lugt og beskyttelsesbriller.

De materialer, vi har brug for for at kunne fungere korrekt, er dem, der vises på billederne. Hovedsageligt vil vi arbejde med en pensel, en lakbeholder (i vores tilfælde rød farve), lidt opløsningsmiddel og visuel beskyttelse. Og frem for alt arbejde i godt ventilerede rum.

Trin 6: Hardware

Vores plakette med Arduino, acelerometer og hjulet med lysdioder vil blive introduceret i et lille beslag for at undgå, at alle komponenter bevæger sig i instrumentet.

Vi har også tilføjet en batteriholder og en switch for at gøre det mere behageligt, og vi slider ikke batteriet, når vi ikke bruger instrumentet. Vi vil vedhæfte denne støtte med et stykke velcro (det ville også fungere med silikone og en hot melt gun) til ukulele -kroppens indvendige side. På den anden side er LED -hjulet mindre end hullet, så det ville falde. En støtte er designet, så den holder godt og kan udføre sin funktion.

Trin 7: Software

For at give vores ukulele en særlig dekoration kunne vi tilføje lyseffekter takket være et hjul med lysdioder. Vi kommer til at bruge WS2812, men du kan bruge enhver anden efter instruktionerne i databladet. Vi vil også bruge et acelerometer (BMA220), som gør det muligt for os at påvirke tyngdekraften.

Faktisk vil vi have 4 lysspil inkluderet i computerbiblioteket kaldet 'Adafruit' i Arduino. Til det skal vi lave en korrekt sammenhæng mellem de tre komponenter: Arduino NANO, WS2812 og BMA220, som vises på det første billede.

De røde ledninger er til strøm, GND -sorte og resten er nødvendige forbindelser til den korrekte betjening. Koden, som vi brugte til lyskittet, er vedhæftet i en fil kaldet "play_of_light_v0.ino". Sørg for, at du har inkluderet de nødvendige biblioteker til den korrekte drift af programmet. Batteriet, som vi tilføjer eksternt til kredsløbet, skal have en minimumsspænding på 9V, og vi skal sikre, at det er i stand til at give den nødvendige minimumsstrøm til at drive hele kredsløbet.

// 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

byte version [3];

int8_t x_data; int8_t y_data; int8_t z_data; byte område = 0x00; float divi = 16; flyde x, y, z; float pi = 3.14159265359; flyde 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 pixels i strip // Parameter 2 = Arduino pin -nummer (de fleste er gyldige) // Parameter 3 = pixeltypeflag, tilføj efter behov: // NEO_KHZ800 800 KHz bitstream (de fleste NeoPixel -produkter m/WS2812 LED'er) // NEO_KHZ400 400 KHz (klassiske 'v1' (ikke v2) FLORA -pixels, WS2811 -drivere) // NEO_GRB Pixels er tilsluttet GRB -bitstream (de fleste NeoPixel -produkter)/ / NEO_RGB Pixels er forbundet til RGB -bitstream (v1 FLORA -pixels, ikke v2) // NEO_RGBW Pixels er tilsluttet RGBW -bitstream (NeoPixel RGBW -produkter) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // VIGTIGT: For at reducere NeoPixel -udbrændingsrisiko skal du tilføje 1000 uF kondensator på tværs af // pixel strømledninger, tilføje 300 - 500 Ohm modstand på den første pixels dataindgang // og minimere afstanden mellem Arduino og den første pixel. Undgå tilslutning // på et strømførende kredsløb … hvis du skal, skal du først tilslutte GND.

// Variabler Rueda de colores

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson // frigivet under GPLv3 -licensen for at matche resten af AdaFruit NeoPixel -biblioteket

#omfatte

#ifdef _AVR_ #inklusiv #endif

// Hvilken pin på Arduino er forbundet til NeoPixels?

// På en Trinket eller Gemma foreslår vi at ændre dette til 1 #define PIN 9

// Hvor mange NeoPixels er knyttet til Arduino?

#define NUMPIXELS 16

// Når vi opsætter NeoPixel -biblioteket, fortæller vi det, hvor mange pixels og hvilken pin, der skal bruges til at sende signaler.

// Bemærk, at for ældre NeoPixel-strimler skal du muligvis ændre den tredje parameter-se eksempel på strengtest // for at få flere oplysninger om mulige værdier. Adafruit_NeoPixel pixels = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // forsinkelse i 50 ms

// Variabler colores aleatorios

#include #ifdef _AVR_ #include #endif

#definer 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 OPSÆTNING

void setup () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.beginTransmission (0x0A); // adresse på accelerometer // områdeindstillinger Wire.write (0x22); // registrer adresse Wire.write (område); // kan indstilles til "0x00" "0x01" "0x02" "0x03", se Datashhet på wiki // lavpasfilter Wire.write (0x20); // registrer adresse Wire.write (0x05); // kan indstilles til "0x05" "0x04" …… "0x01" "0x00", se Datashhet på wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Dette er for Trinket 5V 16MHz, du kan fjerne disse tre linjer, hvis du ikke bruger en Trinket #if defineret (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Slut på nipstegs specialkode strip.begin (); strip.show (); // Initialiser alle pixels til 'off'

// Código Rueda de colores

// Dette er for Trinket 5V 16MHz, du kan fjerne disse tre linjer, hvis du ikke bruger en Trinket #if defineret (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Slut på specialpinkode

pixels.begin (); // Dette initialiserer NeoPixel -biblioteket.

// Codigo Interrupcion

tæller = 1;

// Codigo Colores varios

// Dette er for Trinket 5V 16MHz, du kan fjerne disse tre linjer, hvis du ikke bruger en Trinket #if defineret (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Slut på nipstegs specialkode strip.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Initialiser alle pixels til 'off'}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; hvis (tæller == 1) {for (int i = 0; i 0,0) {hvis (nx 0,0) vinkel+= 180; ellers vinkel += 360; } // ende andet hvis (vinkel == 360,0) vinkel = 0,0; led = cirkulariser (vinkel / (360 / NUMBER_OF_LEDS_ON_RING)); // gør led -bevægelsen jævn, hvis (previousLed == led) {// intet at gøre} ellers hvis (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); else led = circularize (previousLed - 1); ledQueue.push (led); makeLightShow (); previousLed = led; forsinkelse (25); } tæller = 2; } // Slut hvis tæller == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Nogle eksempler på procedurer, der viser hvordan man viser til pixels: colorWipe1 (strip. Color (255, 0, 0), 50); // Rød farveWipe1 (strip. Color (0, 255, 0), 50); // Grøn colorWipe1 (strip. Color (0, 0, 255), 50); // Blå colorWipe1 (strip. Color (0, 0, 0, 255), 50); // Hvid RGBW // Send en teater -pixeljagt 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å

regnbue (5);

rainbowCycle (5); theaterChaseRainbow (5); } tæller = 3; } // Slut hvis tæller == 2 // Caso 3: Luces Aleatorias ellers hvis (tæller == 3) {for (int k = 0; k <50; k ++) {// For et sæt NeoPixels er det første NeoPixel 0, sekund er 1, helt op til antallet af pixels minus en. int a = tilfældigt (255); int b = tilfældig (255); int c = tilfældig (255); for (int i = 0; i

// pixels. Color tager RGB -værdier, fra 0, 0, 0 op til 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Moderat lysegrøn farve.

pixels.show (); // Dette sender den opdaterede pixelfarve til hardwaren.

forsinkelse (delayval); // Forsinkelse i en periode (i millisekunder).

} a = tilfældig (255); b = tilfældig (255); c = tilfældig (255); for (int i = NUMPIXELS; i> 0; i-) {

// pixels. Color tager RGB -værdier, fra 0, 0, 0 op til 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Moderat lysegrøn farve.

pixels.show (); // Dette sender den opdaterede pixelfarve til hardwaren.

forsinkelse (delayval); // Forsinkelse i en periode (i millisekunder).

}} tæller = 4; } ellers hvis (tæller == 4) {for (int g = 0; g <= 6; g ++) {// Nogle eksempler på procedurer, der viser, hvordan man viser til pixels: colorWipe (strip. Color (255, 0, 0), 50); // Rød farveWipe (strip. Color (0, 255, 0), 50); // Grøn colorWipe (strip. Color (0, 0, 255), 50); // Blå colorWipe (strip. Color (0, 0, 0, 255), 50); // Hvid whiteOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // forsinkelse (2000); rainbowFade2White (3, 3, 1);

}

tæller = 1; }} //////////////////////////////////////////////////// ////////////////////////////////////////////////// ///////////////////////////////////////////////// ////////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // adresse på accelerometer // nulstil accelerometer Wire.write (0x04); // X data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // anmode om 6 bytes fra slaveenhed nr. 2, mens (Wire.available ()) // slave kan sende mindre end anmodet {Version [0] = Wire.read (); // modtag en byte som karakter} x_data = (int8_t) Version [0] >> 2; Wire.beginTransmission (0x0A); // adresse på accelerometer // nulstil accelerometer Wire.write (0x06); // Y data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // anmode om 6 bytes fra slaveenhed nr. 2, mens (Wire.available ()) // slave kan sende mindre end anmodet {Version [1] = Wire.read (); // modtag en byte som karakter} y_data = (int8_t) Version [1] >> 2; Wire.beginTransmission (0x0A); // adresse på accelerometer // nulstil accelerometer Wire.write (0x08); // Z data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // anmode om 6 bytes fra slaveenhed #2, mens (Wire.available ()) // slave kan sende mindre end anmodet {Version [2] = Wire.read (); // modtag en byte som karakter} 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 ="); Seriel.print (x); // udskriv tegnet Serial.print (""); Serial.print ("Y ="); Serial.print (y); // udskriv tegnet Serial.print (""); Serial.print ("Z ="); // udskriv tegnet Serial.println (z); }

int circularize (int pos) {

hvis (pos> = NUMBER_OF_LEDS_ON_RING) return (pos - NUMBER_OF_LEDS_ON_RING); ellers hvis (pos <0) return (pos + NUMBER_OF_LEDS_ON_RING); ellers retur (pos); }

int afstand;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; hvis (afstand <0) afstand += NUMBER_OF_LEDS_ON_RING; retur (afstand); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 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); hvis ((k == 0 && currentQueueSize 0) ledQueue.push (ledPosition);} neoring.show ();}

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

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

/Metodos del juego de luces del arcoiris

// Fyld prikkerne efter hinanden med et farve tomrum colorWipe (uint32_t c, uint8_t vent) {for (uint16_t i = 0; i

ugyldig regnbue (uint8_t vent) {

uint16_t i, j;

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

// Lidt anderledes, dette gør regnbuen ligeligt fordelt overalt

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

for (j = 0; j <256*5; j ++) {// 5 cykler af alle farver på hjulet for (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); forsinkelse (vent); }}

// Krybelys i teaterstil.

void theaterChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// gør 10 cykler med jagt efter (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // slå hver tredje pixel til} strip.show ();

forsinkelse (vent);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // sluk for hver tredje pixel}}}}

// Krybelys i teaterstil med regnbueeffekt

void theaterChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// cyklér alle 256 farver i hjulet for (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)); // slå hver tredje pixel til} strip.show ();

forsinkelse (vent);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // sluk for hver tredje pixel}}}}

// Indtast en værdi 0 til 255 for at få en farveværdi.

// Farverne er en overgang r - g - b - tilbage til r. uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; hvis (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } hvis (WheelPos <170) {WheelPos -= 85; returstrimmel. Farve (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; returstrimmel. Farve (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

// Fyld prikkerne efter hinanden med en farve

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

void pulseWhite (uint8_t wait) {

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

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

for (uint16_t i = 0; i

void rainbowFade2White (uint8_t wait, int rainbowLoops, int whiteLoops) {

float fadeMax = 100,0; int fadeVal = 0; uint32_t wheelVal; int redVal, greenVal, blueVal;

for (int k = 0; k <rainbowLoops; k ++) {for (int j = 0; j <256; j ++) {// 5 cykler af alle farver på hjulet

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

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

redVal = rød (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ørste loop, fade in!

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

// Sidste loop, fade out!

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

strip.show ();

forsinkelse (vent); }}

forsinkelse (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 (); }

forsinkelse (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 (); }}

forsinkelse (500);

}

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

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

int hoved = hvidLængde - 1;

int hale = 0;

int sløjfer = 3;

int loopNum = 0;

statisk usigneret lang lastTime = 0;

mens (sandt) {

for (int j = 0; j <256; j ++) {for (uint16_t i = 0; i = hale && i hoved && i> = hale) || (hale> hoved && i <= hoved)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } ellers {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

hoved ++; hale ++; hvis (head == strip.numPixels ()) {loopNum ++; } sidste tid = millis (); }

hvis (loopNum == loops) returnerer;

hoved%= strip.numPixels (); hale%= strip.numPixels (); strip.show (); forsinkelse (vent); }}} void fullWhite () {for (uint16_t i = 0; i

// Lidt anderledes, dette gør regnbuen ligeligt fordelt overalt

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

for (j = 0; j <256 * 5; j ++) {// 5 cykler af alle farver på hjulet for (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); forsinkelse (vent); }}

ugyldig regnbue1 (uint8_t vent) {

uint16_t i, j;

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

// Indtast en værdi 0 til 255 for at få en farveværdi.

// Farverne er en overgang r - g - b - tilbage til r. uint32_t Wheel1 (byte WheelPos) {WheelPos = 255 - WheelPos; hvis (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } hvis (WheelPos <170) {WheelPos -= 85; returstrimmel. Farve (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; returstrimmel. Farve (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t rød (uint32_t c) {

retur (c >> 16); } uint8_t grøn (uint32_t c) {return (c >> 8); } uint8_t blå (uint32_t c) {return (c); }

Trin 8: 3D -design

Først skal du størrelse dine hardwarekomponenter for at være sikker på, om det er korrekt. Hvis de er de samme som vores, kan du bruge de samme filer, som vi låner dig.

Begge understøtninger er designet med en 3D -printer, som også er inkluderet som:

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

Endelig vil lyset være som de to sidste billeder.

Trin 9: Montering af halsen

Først placerer vi sadlen i nakken. De huller, skruerne har brug for for at holde det, er der ikke, så vi bliver nødt til at lave dem og markere, hvor de skal gå, og forsigtigt, med en snegl, lave hullet.

Det samme gælder hullerne, hvor skruerne, der holder nakken selv til instrumentets krop. Det er ikke nødvendigt at gøre dem, da der ikke er skruer til denne fastgørelse, men hvis vi vil gøre det, ville der ikke være noget problem.

VIGTIGT: efterlad 5 mm plads mellem mastens start og tuninggaffelens start, for i det hul placeres møtrikken.

Vi limer møtrikken med lim i den retning, som figuren angiver.

Endelig introducerer vi de 4 ben i hullerne, der er i begyndelsen af masten, og holder hver stift med 2 korte skruer som vist på billedet.

Trin 10: Montering af Birdge

Broen fastgøres ved limning og med de to lange skruer i en central position på kroppen. Det tilrådes at markere med en blyant den korrekte position i kroppen. Vi tager de afstande, der er markeret i billedet.

Vi påfører lim ved foreningen af de to komponenter. Vi fikserer de to dele omhyggeligt ved hjælp af en stramningsskrue, indtil samlingen er tørret. Vi laver de to huller til skruerne med et 1,5 mm bor til træ. Fix broen med de to lange skruer i kroppen. Og endelig satte vi beskyttelseshætterne på skruernes hoveder.

Trin 11: Krops- og nakkemontage

For at samle de to dele har vi huller i hovedet på kroppen, hvor nakken passer med to fremspring, den har. Vi kan lime dem med lim eller med hot melt pistolen. For at få en større fiksering kan du lave hullerne i enden af stemmegaflen for at forbinde den med kroppen.

Trin 12: Sæt Ukulele -strengene

Endelig skal vi placere strengene, så vores instrument er færdigt.

Tidligere vil vi indsætte stifternes fikseringsringe i fremspringene af disse, der går gennem masten. For at placere strengene tog vi de 4 strenge, der fulgte med sættet. Først skal du skelne hver streng, fordi de ikke alle er ens. Du skal binde den ene ende af hver snor (de to tykke med en normal knude, og de to tynde med en dobbelt) og indsætte snorene i broens slidser.

Derefter placerer vi strengene på en sådan måde, at:

• Første position: G -streng (anden tykkeste streng).

• Anden position: C -streng (tykkere streng).

• Tredje position: E streng (anden tyndere streng).

• Fjerde position: En streng (tyndere streng).

Træk strengene ind i hullerne på det medfølgende stik. Prøv at fastsætte hvert reb ved at give to eller tre omdrejninger på stiften. Spænd strengene uden at anvende for meget kraft, og kontroller afstanden mellem strengene og sadlen.

Hvis du er i tvivl om, hvordan du laver det, kan du lave den vejledning, der forklarer dig, hvordan du sætter strengene korrekt.

Trin 13: Test

Endelig skal vi se, om ukulelen er korrekt monteret på en sådan måde, at den ideelle afstand på den første bånd er 0,1 mm, og på den tolvte er den cirka 1,2 mm.

Er det nødvendigt, at du indstiller ukulele -strengene. Jeg anbefaler dig denne app: GuitarTuna

Trin 14: Nyd det

Nu skal du kun nyde din ukulele.

Hvis du vil vide mere information om os, kan du finde os i:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc