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

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:24

Vi skal forklare trinn for trinn hvordan du kan designe din egen ukulele og legge til noen effekter som vil gjøre den unik, for eksempel å tegne noe vi vil ha på overflaten av ukulelen eller legge til noen lyseffekter.

For å gjøre det, er det nødvendig å kjøpe et ukulele -sett.

Vi skal forklare hvordan du monterer instrumentet, og løser de forskjellige problemene som kan dukke opp.

Trinn 1: Materialer

Strukturmaterialer:

DIY ukelele monteringssett (det kan være et annet annet sett) dannet av:

1- Kropp.

2-hals.

3-sal

4-tau støtte

5-bro

6-strengs mutter.

7-festering for maskinhode (x4).

8-maskinhoder (x4).

9-festeskruer for maskinhoder (x8).

10-festeskruer for maskinbro (x2).

11-dekselhetter for bromonteringsskruer (x2).

12-strenger (x4).

Elektroniske materialer:

• NANO Arduino.
• Wheel of Leds WS2812.
• Akselerometer BMA220 (valgfritt).
• Batterikontakt.
• Batteri på 9V.
• Bytte om.

Andre

• Tre lakk.
• Borrelås.
• Loddetinn.
• Beskyttelsesplast for lakk.
• Varmsmeltende silikon.

Verktøy:

• Lasergravering.
• Sandpapir
• Stjerneskrutrekker.
• Pensel.
• Smeltepistol.
• Tinnloddejern.

Trinn 2: Tilpass Ukulele

For å utstyre ukulelen vår kunne vi lage en gravering av en tegning med en laserskjærer på kroppen. Hvis vi ikke har det verktøyet, kan vi male det.

Bildet vi har valgt er det første som vises.

Først av alt må vi designe tegningsmalen for å lage graveringen.

For å gjennomføre det, vil vi bruke en programvare kalt 'Inkscape' som vi kan få fra denne lenken:

For å bruke det, må vi justere bildet vi vil bruke, slik vi viser i det andre bildet. Du kan se at vi har rotert det opprinnelige bildet til, for å justere hånden med sirkelen på instrumentet. Som vi har sagt før, kan du sette et hvilket som helst bilde.

Trinn 3: Vektoriser et bilde ved hjelp av Inkscape

Vi får se hvordan vi lager en vektorfil fra en pixmap (jpg, png, uansett rasterformat som Inkscape kan åpne).

Inkscape Inkscape er en vektorgrafikkredigerer med åpen kildekode, og som tittelen tilsier, er dette verktøyet jeg vil bruke til å vektorisere logoene. Vektorisering av trinnene Trinnene er vanlige for enhver vektorisering vi måtte ønske å gjøre.

1. Åpne bildet i Inkscape
2. Åpne Trace Bitmap Tool Path-> Trace Bitmap
3. Spill rundt alternativene Trace Bitmap
4. Kjør sporing
5. Rydd opp resultatene (om nødvendig)

Legg merke til delen "spille rundt". Jeg er ikke ekspert på sporing, så jeg behandler dette verktøyet som en svart boks med knapper og lys, vridning og endring til jeg får det beste resultatet

Trinn 4: Logo gravering

For dette er det viktig å ha en silhuett av overflaten som graveringen av tegningen skal produseres på.

For å lage graveringen kommer vi til å bruke 'T2Laser' programvare. Vi kan få denne programvaren fra:

Når vi har åpnet programvaren, må vi laste inn bildet vi har laget i det siste trinnet. Trykk deretter på knappen "kontrolllaser", og cnc -kontrollene vises. De to bildene viser prosessen og resultatet av graveringen med laserskjæreren vår.

Trinn 5: Sliping og lakkering

For å etterlate ukulelen vår lys og med et lag uten grovhet, kan vi glatt slipe de to delene som utgjør instrumentet vårt forsiktig, fordi vi kan skade tegningen som er laget (hvis du har valgt å male ukulelen, må du sand den først). Deretter vil vi lakkere våre to deler slik at de får en mørkere farge og treverket gir mer motstand. Vi kan bruke en vanlig trelakk, den trenger ikke å være spesiell.

Når vi har lakken, blander vi den med litt løsemiddel slik at den oppløses litt. Deretter påfører vi blandingen med en pensel på nakken og instrumentets kropp og lar den tørke.

Hvis vi ser at produktet trenger et nytt strøk, kan vi slipe de to delene litt og påføre et lag fortynnet lakk på nytt.

** FORHOLDSREGLER: Lakken er et kjemisk produkt, så det er nødvendig å utføre denne prosessen på et ventilert sted, bruk en maske for å unngå innånding av lukt og vernebriller.

Materialene vi trenger for å kunne fungere riktig er de som vises på bildene. Hovedsakelig vil vi jobbe med en pensel, en lakkboks (i vårt tilfelle rød farge), litt løsemiddel og visuell beskyttelse. Og fremfor alt arbeid i godt ventilerte rom.

Trinn 6: Maskinvare

Plakaten vår med Arduino, akselerometeret og hjulet med lysdioder kommer til å bli introdusert i en liten brakett for å unngå at alle komponentene beveger seg i instrumentet.

Vi har også lagt til en batteriholder og en bryter for å gjøre det mer behagelig, og vi sliter ikke på batteriet når vi ikke bruker instrumentet. Vi vil feste denne støtten med et borrelås (det vil også fungere med silikon og en smeltepistol) til det indre ansiktet på ukulele -kroppen. På den annen side er LED -hjulet mindre enn hullet, så det ville falle. En støtte er designet slik at den holder godt og kan utføre sin funksjon.

Trinn 7: Programvare

For å gi en spesiell dekorasjon til ukulelen vår, kan vi legge til lyseffekter takket være et hjul med lysdioder. Vi skal bruke WS2812, men du kan bruke hvilken som helst annen etter instruksjonene i databladet. Vi vil også bruke et akselerometer (BMA220) som lar oss påvirke tyngdekraften.

Faktisk vil vi ha 4 lysspill, inkludert i databiblioteket kalt 'Adafruit' fra Arduino. Til det må vi gjøre en riktig sammenkobling mellom de tre komponentene: Arduino NANO, WS2812 og BMA220, som vises på det første bildet.

De røde ledningene er for strøm, GND -svarte og resten er nødvendige tilkoblinger for riktig drift. Koden som vi brukte for lyssettet er vedlagt i en fil som heter "play_of_light_v0.ino". Sørg for at du har inkludert de nødvendige bibliotekene for riktig drift av programmet. Batteriet vi legger til eksternt i kretsen må ha en minimumsspenning på 9V, og vi må sørge for at det er i stand til å gi minstestrømmen som er nødvendig for å drive hele 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

byte versjon [3];

int8_t x_data; int8_t y_data; int8_t z_data; byte -område = 0x00; float divi = 16; flyte x, y, z; float pi = 3.14159265359; flyte 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 = antall piksler i stripe // Parameter 2 = Arduino pin -nummer (de fleste er gyldige) // Parameter 3 = pixeltype flagg, legg sammen etter behov: // NEO_KHZ800 800 KHz bitstream (de fleste NeoPixel -produkter m/WS2812 lysdioder) // NEO_KHZ400 400 KHz (klassiske 'v1' (ikke v2) FLORA -piksler, WS2811 -drivere) // NEO_GRB Piksler er koblet til GRB -bitstrøm (de fleste NeoPixel -produkter)/ / NEO_RGB -piksler er kablet for RGB -bitstrøm (v1 FLORA -piksler, ikke v2) // NEO_RGBW -piksler er kablet for RGBW -bitstrøm (NeoPixel RGBW -produkter) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // VIKTIG: For å redusere NeoPixel utbrent risiko, legg til 1000 uF kondensator på tvers av // piksel strømledninger, legg til 300 - 500 Ohm motstand på den første pikselens datainngang // og minimer avstanden mellom Arduino og første piksel. Unngå å koble // til en strømførende krets … hvis du må, må du koble til GND først.

// Variabler Rueda de colores

// NeoPixel Ring enkel skisse (c) Shae Erisson 2013 // utgitt under GPLv3 -lisensen for å matche resten av AdaFruit NeoPixel -biblioteket

#inkludere

#ifdef _AVR_ #inkludere #endif

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

// På en trinket eller Gemma foreslår vi at du endrer dette til 1 #define PIN 9

// Hvor mange NeoPixels er festet til Arduino?

#define NUMPIXELS 16

// Når vi konfigurerer NeoPixel -biblioteket, forteller vi det hvor mange piksler, og hvilken pin som skal brukes for å sende signaler.

// Vær oppmerksom på at for eldre NeoPixel-strimler kan det hende du må endre den tredje parameteren-se eksempel på strengtest // for mer informasjon om mulige verdier. Adafruit_NeoPixel piksler = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // forsinkelse i 50 ms

// Variabler colores aleatorios

#include #ifdef _AVR_ #include #endif

#definere 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); // adressen til akselerometeret // rekkeviddeinnstillinger Wire.write (0x22); // registeradresse Wire.write (område); // kan settes til "0x00" "0x01" "0x02" "0x03", se Datashhet på wiki // lavpassfilter Wire.write (0x20); // registrer adresse Wire.write (0x05); // kan settes 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 linjene hvis du ikke bruker et Trinket #if definert (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Slutt på spesialpyntet kode strip.begin (); strip.show (); // Initialiser alle piksler til "av"

// Código Rueda de colores

// Dette er for Trinket 5V 16MHz, du kan fjerne disse tre linjene hvis du ikke bruker et Trinket #if definert (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Slutt på spesialpyntkode

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

// Codigo Interrupcion

teller = 1;

// Codigo Colores varios

// Dette er for Trinket 5V 16MHz, du kan fjerne disse tre linjene hvis du ikke bruker et Trinket #if definert (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Slutt på spesiell kode strip.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Initialiser alle piksler til 'off'}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (teller == 1) {for (int i = 0; i 0.0) {if (nx 0.0) vinkel+= 180; ellers vinkel += 360; } // ende annet hvis (vinkel == 360,0) vinkel = 0,0; led = sirkulere (vinkel / (360 / NUMBER_OF_LEDS_ON_RING)); // gjøre led -bevegelsen jevn hvis (previousLed == led) {// ingenting å gjøre} annet hvis (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); annet led = sirkuler (forrigeLed - 1); ledQueue.push (led); makeLightShow (); previousLed = led; forsinkelse (25); } teller = 2; } // Slutt hvis teller == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Noen eksempler på prosedyrer som viser hvordan du viser til pikslene: colorWipe1 (strip. Color (255, 0, 0), 50); // Rød fargeWipe1 (strip. Color (0, 255, 0), 50); // Grønn colorWipe1 (strip. Color (0, 0, 255), 50); // Blå colorWipe1 (strip. Color (0, 0, 0, 255), 50); // Hvit RGBW // Send en teaterpikseljakt 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); } teller = 3; } // Slutt hvis teller == 2 // Caso 3: Luces Aleatorias ellers hvis (teller == 3) {for (int k = 0; k <50; k ++) {// For et sett med NeoPixels er den første NeoPixel 0, andre er 1, helt opp til antall piksler minus én. int a = tilfeldig (255); int b = tilfeldig (255); int c = tilfeldig (255); for (int i = 0; i

// pixels. Color tar RGB -verdier, fra 0, 0, 0 opp til 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Middels lys grønn farge.

piksler.vis (); // Dette sender den oppdaterte pikselfargen til maskinvaren.

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

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

// pixels. Color tar RGB -verdier, fra 0, 0, 0 opp til 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Middels lys grønn farge.

piksler. vis (); // Dette sender den oppdaterte pikselfargen til maskinvaren.

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

}} teller = 4; } annet hvis (teller == 4) {for (int g = 0; g <= 6; g ++) {// Noen eksempelprosedyrer som viser hvordan du viser til pikslene: colorWipe (strip. Color (255, 0, 0) 50); // Rød colorWipe (strip. Color (0, 255, 0), 50); // Grønn colorWipe (strip. Color (0, 0, 255), 50); // Blå colorWipe (strip. Color (0, 0, 0, 255), 50); // Hvit whiteOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // forsinkelse (2000); rainbowFade2White (3, 3, 1);

}

teller = 1; }} //////////////////////////////////////////// ///////////////////////////////////////// //////////////////////////////////////////// ///////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // adressen til akselerometeret // tilbakestill akselerometeret Wire.write (0x04); // X data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // be om 6 byte fra slaveenhet nr. 2 mens (Wire.available ()) // slave kan sende mindre enn forespurt {Version [0] = Wire.read (); // motta en byte som karakter} x_data = (int8_t) Versjon [0] >> 2; Wire.beginTransmission (0x0A); // adressen til akselerometeret // tilbakestill akselerometeret Wire.write (0x06); // Y data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // be om 6 byte fra slaveenhet nr. 2 mens (Wire.available ()) // slave kan sende mindre enn forespurt {Versjon [1] = Wire.read (); // motta en byte som karakter} y_data = (int8_t) Versjon [1] >> 2; Wire.beginTransmission (0x0A); // adressen til akselerometeret // tilbakestill akselerometeret Wire.write (0x08); // Z data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // be om 6 byte fra slaveenhet nr. 2 mens (Wire.available ()) // slave kan sende mindre enn forespurt {Versjon [2] = Wire.read (); // motta en byte som karakter} z_data = (int8_t) Versjon [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 tegnet Serial.print (""); Serial.print ("Y ="); Serial.print (y); // skriv ut tegnet Serial.print (""); Serial.print ("Z ="); // skriv ut tegnet Serial.println (z); }

int circularize (int pos) {

if (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 avstand;

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

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); if ((k == 0 && currentQueueSize 0) ledQueue.push (ledPosition);} neoring.show ();}

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

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

/Metodos del juego de luces del arcoiris

// Fyll prikkene etter hverandre med en farge void 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

// Litt annerledes, dette gjør regnbuen jevnt fordelt overalt

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

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

// Krypelys i teaterstil.

void theaterChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// gjør 10 sykluser med jakt etter (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // slå på hver tredje piksel} strip.show ();

forsinkelse (vent);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // slå av hver tredje piksel}}}}

// Krypelys i teaterstil med regnbueeffekt

void theaterChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// syklus alle 256 farger 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å på hver tredje piksel} strip.show ();

forsinkelse (vent);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // slå av hver tredje piksel}}}}

// Skriv inn en verdi 0 til 255 for å få en fargeverdi.

// Fargene er en overgang r - g - b - tilbake 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; returlist. Farge (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; returlist. Farge (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 prikkene etter hverandre med en farge

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 sykluser med alle farger 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 sløyfe, visne inn!

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

// Siste sløyfe, visne ut!

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 head = whiteLength - 1;

int hale = 0;

int sløyfer = 3;

int loopNum = 0;

statisk usignert lang lastTime = 0;

mens (sant) {

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

if (millis () - lastTime> whiteSpeed) {

hode ++; hale ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == loops) return;

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

// Litt annerledes, dette gjør regnbuen jevnt fordelt overalt

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

for (j = 0; j <256 * 5; j ++) {// 5 sykluser med alle farger 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

// Skriv inn en verdi 0 til 255 for å få en fargeverdi.

// Fargene er en overgang r - g - b - tilbake 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; returlist. Color (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; returlist. Farge (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t rød (uint32_t c) {

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

Trinn 8: 3D -design

Først må du størrelse maskinvarekomponentene dine for å være sikker på at det er riktig. Hvis de er de samme som våre, kan du bruke de samme filene som vi låner deg.

Begge støttene er designet med en 3D -skriver, som også er inkludert som:

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

Til slutt vil lyset være som de to siste bildene.

Trinn 9: Montering av nakken

Først plasserer vi salen nakken. Hullene som skruene trenger for å holde den er ikke der, så vi må lage dem, markere hvor de skal gå og forsiktig, med en skrue, lage hullet.

Det samme gjelder hullene der skruene som holder selve halsen til instrumentets kropp. Det er ikke nødvendig å gjøre dem, siden det ikke er skruer for denne festingen, men hvis vi vil gjøre det, ville det ikke være noe problem.

VIKTIG: la det være 5 mm mellomrom mellom mastens start og tuninggaffelens start, for i dette hullet vil mutteren plasseres.

Vi limer mutteren med lim, i retningen angitt av figuren.

Til slutt vil vi introdusere de 4 pinnene i hullene som er i begynnelsen av masten, og holde hver pinne med 2 korte skruer som vist på bildet.

Trinn 10: Montering av Birdge

Broen festes ved liming og med de to lange skruene i en sentral posisjon på karosseriet. Det anbefales å markere med blyant riktig posisjon i kroppen. Vi tar avstandene som er merket i bildet.

Vi vil påføre lim ved forening av de to komponentene. Vi fikser de to delene forsiktig ved hjelp av en strammeskrue til skjøten har tørket. Vi lager de to hullene til skruene med et 1,5 mm bor for tre. Fest broen med de to lange skruene i karosseriet. Og til slutt setter vi beskyttelseshettene på skruehodene.

Trinn 11: Kropps- og nakkemontasje

For å montere de to delene har vi hull i kroppens hode, der nakken passer med to fremspring som den har. Vi kan lime dem med lim eller med smeltepistolen. For å få en større fiksering, kan du lage hullene som er i enden av stemmegaffelen for å feste den til kroppen.

Trinn 12: Sett Ukulele -strengene

Til slutt må vi plassere strengene slik at instrumentet vårt er ferdig.

Tidligere vil vi sette inn festeringene til pinnene i fremspringene til disse som går gjennom masten. For å plassere strengene tok vi de 4 strengene som fulgte med settet. Først må du skille hver streng fordi de ikke er like. Du må knytte den ene enden av hver streng (de to tykke med en normal knute, og de to tynne med en dobbel) og sette strengene inn i sporene på broen.

Deretter plasserer vi strengene på en slik måte at:

• Første posisjon: G -streng (nest tykkeste streng).

• Andre posisjon: C -streng (tykkere streng).

• Tredje posisjon: E streng (andre tynnere streng).

• Fjerde posisjon: En streng (tynnere streng).

Tre strengene inn i hullene på den medfølgende pluggen. Prøv å fikse hvert tau ved å gi to eller tre svinger på pinnen. Stram strengene uten å bruke for mye kraft og kontroller avstanden mellom strengene og salen.

Hvis du er i tvil om hvordan du lager det, kan du sette opp den opplæringen som forklarer hvordan du setter strengene riktig.

Trinn 13: Testing

Til slutt må vi se om ukulelen er riktig montert på en slik måte at den ideelle avstanden på den første båndet er 0,1 mm og på den tolvte er den omtrent 1,2 mm.

Er nødvendig at du stiller ukulele -strengene. Jeg anbefaler deg denne appen: GuitarTuna

Trinn 14: Nyt det

Nå trenger du bare å nyte ukulelen din.

Hvis du vil vite mer informasjon om oss, kan du finne oss i:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Nett: Innovart.cc