DIY slim elektroniese ukelele met Arduino: 14 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

Ons gaan stap vir stap verduidelik hoe u u eie ukelele kan ontwerp en effekte byvoeg wat dit uniek sal maak, soos om iets op die oppervlak van die ukulele te teken of 'n paar ligte effekte by te voeg.

Om dit te kan doen, moet u 'n ukulele -kit koop.

Ons gaan verduidelik hoe om die instrument te monteer en die verskillende probleme wat kan voorkom, op te los.

Stap 1: materiaal

Struktuurmateriaal:

DIY ukelele -monteringskit (dit kan 'n ander stel wees) wat gevorm word deur:

1- Liggaam.

2-nek.

3-saal

Ondersteuning vir 4 toue

5-brug

6-snaar moer.

7-Bevestigingsring vir masjienkop (x4).

8-masjienkoppe (x4).

9-skroewe vir masjienkoppe (x8).

10-skroewe vir masjienbrug (x2).

11-Dekkappe vir brugmonteringsskroewe (x2).

12-snare (x4).

Elektroniese materiaal:

• NANO Arduino.
• Wheel of Leds WS2812.
• Versnellingsmeter BMA220 (opsioneel).
• Battery -aansluiting.
• Battery van 9V.
• Skakel oor.

Ander

• Hout vernis.
• Klittenband.
• Soldeerblik.
• Beskermende plastiek vir vernis.
• Warm smelt silikoon.

Gereedskap:

• Lasergravering.
• Skuurpapier
• Ster skroewedraaier.
• Verfkwas.
• Warm smelt geweer.
• Blik soldeerbout.

Stap 2: Pas die Ukulele aan

Om ons ukulele te bekostig, kan ons 'n tekening met 'n lasersnyer op die liggaam teken. As ons nie die gereedskap het nie, kan ons dit verf.

Die prentjie wat ons gekies het, is die eerste wat verskyn.

In die eerste plek moet ons die teken sjabloon ontwerp om die gravure te maak.

Om dit uit te voer, gebruik ons 'n sagteware genaamd 'Inkscape' wat ons via hierdie skakel kan kry:

Om dit te gebruik, moet ons die prentjie wat ons wil gebruik, aanpas soos ons in die tweede prent wys. U kan sien dat ons die aanvanklike beeld gedraai het om die handvatsel met die sirkel van die instrument aan te pas. Soos ons al voorheen gesê het, kan u enige beeld plaas.

Stap 3: Vectoriseer 'n prent met Inkscape

Ons sal kyk hoe u 'n vektorlêer kan maak vanaf 'n pixmap (jpg, png, watter rasterformaat ook al wat Inkscape kan oopmaak).

Inkscape Inkscape is 'n open source vektorgrafiese redakteur, en soos die titel aandui, is dit die instrument wat ek sal gebruik om die logo's te vektoriseer. Vectorisering van stappe Die stappe is algemeen vir enige vektorisering wat ons moontlik wil doen.

1. Maak die prent oop in Inkscape
2. Maak die Trace Bitmap Tool Path-> Trace Bitmap oop
3. Speel rond deur die Trace Bitmap -opsies
4. Begin die opsporing
5. Maak die resultate skoon (indien nodig)

Let op die 'speel' -gedeelte. Ek is nie 'n kenner van opsporing nie, so ek behandel hierdie instrument as 'n swart boks met knoppies en ligte, draai en verander totdat ek die beste resultaat kry

Stap 4: Logo -gravure

Hiervoor is dit belangrik om 'n silhoeët van die oppervlak te hê waarop die gravure van die tekening gemaak sal word.

Om die gravure te maak, gaan ons 'T2Laser' -sagteware gebruik. Ons kan hierdie sagteware verkry van:

Sodra ons die sagteware oopgemaak het, moet ons die prent wat ons in die laaste stap geskep het, laai. Druk dan op die knoppie "beheerlaser" en verskyn die cnc -kontroles. Die twee foto's toon die proses en die resultaat van die gravure met ons lasersnyer.

Stap 5: Skuur en vernis

Om ons ukulele helder en met 'n laag sonder grofheid te laat skuur, kan ons die twee dele wat ons instrument uitmaak, versigtig skuur, want ons kan die tekening beskadig (as u gekies het om die ukulele te verf, moet u skuur dit eers). Dan vernis ons ons twee dele sodat hulle 'n donkerder kleur kry en die hout meer weerstand bied. Ons kan 'n gewone houtvernis gebruik, dit hoef nie spesiaal te wees nie.

Sodra ons die vernis gekry het, meng ons dit met 'n bietjie oplosmiddel sodat dit 'n bietjie oplos. Dan pas ons die mengsel met 'n kwas op die nek en die liggaam van die instrument toe en laat dit droog word.

As ons sien dat die produk 'n tweede laag benodig, kan ons die twee dele 'n bietjie skuur en 'n laag verdunde vernis weer aanbring.

** VOORSORGMAATREËLS: Die vernis is 'n chemiese produk, daarom is dit nodig om hierdie proses op 'n geventileerde plek uit te voer, met 'n masker om inaseming van reuke en beskermende bril te voorkom.

Die materiaal wat ons nodig het om reg te kan werk, is materiaal wat op die foto's verskyn. Ons werk hoofsaaklik met 'n kwas, 'n vernisblik (in ons geval rooi kleur), 'n bietjie oplosmiddel en visuele beskerming. En veral werk in goed geventileerde ruimtes.

Stap 6: Hardeware

Ons gedenkplaat met die Arduino, die versnellingsmeter en die wiel met LED's word in 'n klein hakie ingebring om te voorkom dat al die komponente in die instrument beweeg.

Ons het ook 'n batteryhouer en 'n skakelaar bygevoeg om dit gemakliker te maak, en ons vermy die battery nie as ons nie die instrument gebruik nie. Ons sal hierdie steun met 'n stuk klittenband (dit werk ook met silikoon en 'n warmsmeltgeweer) aan die binnekant van die ukulele -liggaam vasmaak. Aan die ander kant is die LED -wiel kleiner as die gat, sodat dit val. 'N Steun is so ontwerp dat dit goed hou en sy funksie kan verrig.

Stap 7: sagteware

Om 'n spesiale versiering aan ons ukulele te gee, kan ons ligteffekte byvoeg danksy 'n wiel leds. Ons gaan die WS2812 gebruik, maar u kan enige ander gebruik volgens die instruksies van die datablad. Ons sal ook 'n versnellingsmeter (BMA220) gebruik waarmee ons die swaartekrag kan beïnvloed.

Trouens, ons sal vier ligspeelstukke hê, ingesluit in die rekenaarbiblioteek genaamd 'Adafruit' van Arduino. Hiervoor moet ons die korrekte verbinding tussen die drie komponente maak: Arduino NANO, WS2812 en BMA220, soos in die eerste prent verskyn.

Die rooi drade is vir krag, die GND -swartes en die res is noodsaaklike verbindings vir die korrekte werking. Die kode wat ons vir die ligstel gebruik het, is aangeheg in 'n lêer genaamd "play_of_light_v0.ino". Maak seker dat u die nodige biblioteke bevat vir die korrekte werking van die program. Die battery wat ons buite die stroombaan voeg, moet 'n minimum spanning van 9V hê, en ons moet verseker dat dit die minimum stroom kan gee wat nodig is om die hele stroombaan aan te dryf.

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

greep weergawe [3];

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

// Veranderlikes Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parameter 1 = aantal pixels in strook // Parameter 2 = Arduino -speldnommer (die meeste is geldig) // Parameter 3 = pixeltipe vlae, voeg by indien nodig: // NEO_KHZ800 800 KHz bitstroom (die meeste NeoPixel -produkte met WS2812 LED's) // NEO_KHZ400 400 KHz (klassieke 'v1' (nie v2) FLORA -pixels, WS2811 -drywers) // NEO_GRB Pixels is bedraad vir GRB -bitstroom (die meeste NeoPixel -produkte)/ / NEO_RGB Pixels is bedraad vir RGB -bitstroom (v1 FLORA -pixels, nie v2) // NEO_RGBW Pixels is bedraad vir RGBW -bitstroom (NeoPixel RGBW -produkte) Adafruit_NeoPixel -strook = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // BELANGRIK: Om die risiko van uitbranding van NeoPixel te verminder, voeg 1000 uF -kondensator by // pixel -kragdrade by, voeg 300 - 500 Ohm -weerstand by die eerste pixel se data -invoer // en verminder die afstand tussen Arduino en die eerste pixel. Vermy die aansluiting // op 'n stroombaan … as u moet, koppel eers GND.

// Veranderlikes Rueda de colores

// NeoPixel Ring eenvoudige skets (c) Shae Erisson 2013 // vrygestel onder die GPLv3 -lisensie om by die res van die AdaFruit NeoPixel -biblioteek te pas

#insluit

#ifdef _AVR_ #sluit #endif in

// Watter pen op die Arduino is aan die NeoPixels gekoppel?

// Op 'n snuistery of Gemma stel ons voor dat u dit verander na 1 #definieer PIN 9

// Hoeveel NeoPixels is aan die Arduino gekoppel?

#definieer NUMPIXELS 16

// As ons die NeoPixel -biblioteek opstel, vertel ons hoeveel pixels dit is en watter pen om te gebruik om seine te stuur.

// Let daarop dat u vir ouer NeoPixel-stroke moontlik die derde parameter moet verander-sien die stringtest // voorbeeld vir meer inligting oor moontlike waardes. Adafruit_NeoPixel pixels = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // vertraging vir 50 ms

// Veranderlikes colores aleatorios

#include #ifdef _AVR_ #include #endif

#definieer PIN 9

#definieer NUM_LEDS 16

#define BRIGHTNESS 200

// Adafruit_NeoPixel strook = 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 INSTELLING

ongeldige opstelling () {// Código: Dirección de la gravedad neoring.begin (); neoring.setBrightness (200); Serial.begin (9600); Wire.begin (); Wire.begin Transmissie (0x0A); // adres van die versnellingsmeter // reeks instellings Wire.write (0x22); // registreer adres Wire.write (reeks); // kan ingestel word op "0x00" "0x01" "0x02" "0x03", verwys na Datashhet op wiki // laagpasfilter Wire.write (0x20); // registreer adres Wire.write (0x05); // kan ingestel word op "0x05" "0x04" …… "0x01" "0x00", verwys na Datashhet op wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Dit is vir Trinket 5V 16MHz; u kan hierdie drie reëls verwyder as u nie 'n snuistery gebruik nie #as gedefinieer (_AVR_ATtiny85_) as (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Einde van die snuistery spesiale kode strip.begin (); strip.show (); // Initialiseer alle pixels na 'af'

// Código Rueda de colores

// Dit is vir Trinket 5V 16MHz; u kan hierdie drie reëls verwyder as u nie 'n snuistery gebruik nie #as gedefinieer (_AVR_ATtiny85_) as (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Einde van spesiale snuifkode

pixels.begin (); // Dit begin die NeoPixel -biblioteek.

// Codigo Interrupcion

teller = 1;

// Codigo Colores varios

// Dit is vir Trinket 5V 16MHz; u kan hierdie drie reëls verwyder as u nie 'n snuistery gebruik nie #as gedefinieer (_AVR_ATtiny85_) as (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Einde van die snuistery spesiale kode strip.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Initialiseer alle pixels na 'af'}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; as (teller == 1) {vir (int i = 0; i 0.0) {as (nx 0.0) hoek+= 180; anders hoek += 360; } // eindig anders as (hoek == 360.0) hoek = 0.0; gelei = sirkulariseer (hoek / (360 / NUMBER_OF_LEDS_ON_RING)); // maak geleide beweging glad as (previousLed == led) {// niks om te doen nie} anders as (counterClockwiseDistanceBetweenLeds (previousLed, led) <= 8) led = circularize (previousLed + 1); anders gelei = sirkulariseer (vorigeLed - 1); ledQueue.push (gelei); makeLightShow (); previousLed = gelei; vertraging (25); } teller = 2; } // Eindig as teller == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Enkele voorbeeldprosedures wat wys hoe om op die pixels te wys: colorWipe1 (strip. Color (255, 0, 0), 50); // Rooi colorWipe1 (strip. Color (0, 255, 0), 50); // Groen kleurWipe1 (strook. Kleur (0, 0, 255), 50); // Blou kleurWipe1 (strook. Kleur (0, 0, 0, 255), 50); // Wit RGBW // Stuur 'n teater pixel jaag in … theaterChase (strip. Color (127, 127, 127), 50); // White theaterChase (strip. Color (127, 0, 0), 50); // Red theaterChase (strip. Color (0, 0, 127), 50); // Blou

reënboog (5);

rainbowCycle (5); theaterChaseRainbow (5); } teller = 3; } // Einde as teller == 2 // Caso 3: Luces Aleatorias anders as (teller == 3) {vir (int k = 0; k <50; k ++) {// Vir 'n stel NeoPixels is die eerste NeoPixel 0, tweede is 1, tot by die aantal pixels minus een. int a = ewekansig (255); int b = ewekansig (255); int c = ewekansig (255); vir (int i = 0; i

// pixels. Color neem RGB -waardes, van 0, 0, 0 tot 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Matig heldergroen kleur.

pixels.show (); // Dit stuur die opgedateerde pixelkleur na die hardeware.

vertraging (delayval); // Vertraag vir 'n tydperk (in millisekondes).

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

// pixels. Color neem RGB -waardes, van 0, 0, 0 tot 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Matig heldergroen kleur.

pixels.show (); // Dit stuur die opgedateerde pixelkleur na die hardeware.

vertraging (delayval); // Vertraag vir 'n tydperk (in millisekondes).

}} teller = 4; } anders as (teller == 4) {vir (int g = 0; g <= 6; g ++) {// Enkele voorbeeldprosedures wat wys hoe om na die pixels te vertoon: colorWipe (strip. Color (255, 0, 0), 50); // Rooi colorWipe (strook. Kleur (0, 255, 0), 50); // Groen kleurveeg (strook. Kleur (0, 0, 255), 50); // Blou kleur Wipe (strook. Kleur (0, 0, 0, 255), 50); // Wit whiteOverRainbow (20, 75, 5); polsWit (5); // fullWhite (); // vertraging (2000); rainbowFade2White (3, 3, 1);

}

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

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // adres van die versnellingsmeter // stel die versnellingsmeter terug Wire.write (0x04); // X data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // versoek 6 grepe van slawe -toestel #2 terwyl (Wire.available ()) // slaaf minder as versoek kan stuur {Weergawe [0] = Wire.read (); // ontvang 'n greep as karakter} x_data = (int8_t) Weergawe [0] >> 2; Wire.begin Transmissie (0x0A); // adres van die versnellingsmeter // stel die versnellingsmeter terug Wire.write (0x06); // Y data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // versoek 6 grepe van slawe -toestel #2 terwyl (Wire.available ()) // slaaf minder as versoek kan stuur {Weergawe [1] = Wire.read (); // ontvang 'n greep as karakter} y_data = (int8_t) Weergawe [1] >> 2; Wire.begin Transmissie (0x0A); // adres van die versnellingsmeter // stel die versnellingsmeter terug Wire.write (0x08); // Z data Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // versoek 6 grepe van slawe -toestel #2 terwyl (Wire.available ()) // slaaf minder kan stuur as versoek {Weergawe [2] = Wire.read (); // ontvang 'n greep as karakter} z_data = (int8_t) Weergawe [2] >> 2; x = (float) x_data/divi; y = (float) y_data/divi; z = (float) z_data/divi; Serial.print ("X ="); Reeks.afdruk (x); // druk die karakter Serial.print ("") uit; Serial.print ("Y ="); Reeks.afdruk (y); // druk die karakter Serial.print ("") uit; Serial.print ("Z ="); // druk die karakter Serial.println (z) uit; }

int sirkulariseer (int pos) {

as (pos> = NUMBER_OF_LEDS_ON_RING) opgawe (pos - NUMBER_OF_LEDS_ON_RING); anders as (pos <0) terugkeer (pos + NUMBER_OF_LEDS_ON_RING); anders terug (pos); }

int afstand;

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

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

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

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

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

/Metodos del juego de luces del arcoiris

// Vul die kolletjies een na die ander met 'n kleur leegte colorWipe (uint32_t c, uint8_t wag) {vir (uint16_t i = 0; i

leë reënboog (wag nie) {

uint16_t i, j;

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

// Iets anders, dit maak die reënboog eweredig versprei

leegte rainbowCycle (uint8_t wag) {uint16_t i, j;

vir (j = 0; j <256*5; j ++) {// 5 siklusse van alle kleure op wiel vir (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); vertraag (wag); }}

// Kruipligte in teaterstyl.

void theaterChase (uint32_t c, uint8_t wag) {vir (int j = 0; j <10; j ++) {// doen 10 siklusse van jaag na (int q = 0; q <3; q ++) {vir (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // skakel elke derde pixel aan} strip.show ();

vertraag (wag);

vir (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // skakel elke derde pixel uit}}}}

// Kruipligte in teaterstyl met reënboog-effek

void theaterChaseRainbow (uint8_t wag) {vir (int j = 0; j <256; j ++) {// sikluseer al 256 kleure in die wiel vir (int q = 0; q <3; q ++) {vir (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, Wheel ((i+j) % 255)); // skakel elke derde pixel aan} strip.show ();

vertraag (wag);

vir (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // skakel elke derde pixel uit}}}}

// Voer 'n waarde 0 tot 255 in om 'n kleurwaarde te kry.

// Die kleure is 'n oorgang r - g - b - terug na r. uint32_t Wheel (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } as (WheelPos <170) {WheelPos -= 85; retourstrook. Kleur (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; retourstrook. Kleur (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

// Vul die kolletjies een na die ander met 'n kleur

leegte colorWipe1 (uint32_t c, uint8_t wag) {vir (uint16_t i = 0; i

leegte polsWit (uint8_t wag) {

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

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

vir (uint16_t i = 0; i

void rainbowFade2White (uint8_t wag, 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 siklusse van alle kleure op wiel

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

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

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

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

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

}

// Eerste lus, vervaag!

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

// Laaste lus, vervaag!

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

strip.show ();

vertraag (wag); }}

vertraging (500);

vir (int k = 0; k <whiteLoops; k ++) {

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

vertraging (2000);

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

vertraging (500);

}

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

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

int kop = whiteLength - 1;

int stert = 0;

int lusse = 3;

int loopNum = 0;

statiese ongetekende lang lastTime = 0;

terwyl (waar) {

vir (int j = 0; j <256; j ++) {vir (uint16_t i = 0; i = stert && i kop && i> = stert) || (stert> kop && i <= kop)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } anders {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

kop ++; stert ++; if (head == strip.numPixels ()) {loopNum ++; } laaste tyd = millis (); }

as (loopNum == loops) terugkeer;

kop%= strip.numPixels (); stert%= strip.numPixels (); strip.show (); vertraag (wag); }}} void fullWhite () {vir (uint16_t i = 0; i

// Iets anders, dit maak die reënboog eweredig versprei

leegte rainbowCycle1 (uint8_t wag) {uint16_t i, j;

vir (j = 0; j <256 * 5; j ++) {// 5 siklusse van alle kleure op wiel vir (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); vertraag (wag); }}

leë reënboog1 (uint8_t wag) {

uint16_t i, j;

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

// Voer 'n waarde 0 tot 255 in om 'n kleurwaarde te kry.

// Die kleure is 'n oorgang r - g - b - terug na r. uint32_t Wheel1 (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } as (WheelPos <170) {WheelPos -= 85; retourstrook. Kleur (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; retourstrook. Kleur (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t rooi (uint32_t c) {

terugkeer (c >> 16); } uint8_t groen (uint32_t c) {opgawe (c >> 8); } uint8_t blou (uint32_t c) {opgawe (c); }

Stap 8: 3D -ontwerp

Eerstens moet u die grootte van u hardeware -komponente om seker te maak of dit korrek is. As dit dieselfde is as ons s'n, kan u dieselfde lêers gebruik as wat ons u leen.

Beide ondersteunings is ontwerp met 'n 3D -drukker, wat ook ingesluit is as:

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

Uiteindelik sal die lig soos die twee laaste foto's lyk.

Stap 9: Monteer die nek

Eerstens plaas ons die nek van die saal. Die gate wat die skroewe nodig het om dit vas te hou, is nie daar nie, so ons moet dit maak en aandui waarheen hulle moet gaan, en maak die gat versigtig met 'n skroef.

Dieselfde geld vir die gate waar die skroewe wat die nek self aan die liggaam van die instrument hou. Dit is nie nodig om dit te doen nie, aangesien daar geen skroewe vir hierdie bevestiging is nie, maar as ons dit wil doen, is daar geen probleem nie.

BELANGRIK: laat 5 mm spasie tussen die begin van die mas en die begin van die stemvurk, want in die gat word die moer geplaas.

Ons plak die moer met gom in die rigting wat die figuur aandui.

Laastens stel ons die vier penne in die gate aan die begin van die mas voor, en hou elke pen vas met 2 kort skroewe soos in die prentjie getoon.

Stap 10: Monteer die Birdge

Die brug word vasgemaak deur te plak en met die twee lang skroewe in 'n sentrale posisie op die liggaam. Dit is raadsaam om met 'n potlood die korrekte posisie in die liggaam te merk. Ons neem die afstande wat in die prentjie gemerk is.

Ons sal gom aanwend by die vereniging van die twee komponente. Ons maak die twee dele versigtig vas met behulp van 'n styfskroef totdat die las droog is. Ons maak die twee gate vir die skroewe met 'n boorpunt van 1,5 mm vir hout. Maak die brug vas met die twee lang skroewe in die bak. En laastens sit ons die beskermende pette op die koppe van die skroewe.

Stap 11: Liggaam en nek

Om die twee dele te monteer, het ons gate in die kop van die liggaam, waar die nek pas by twee uitsteeksels wat dit het. Ons kan dit met gom of met 'n warmsmeltpistool plak. Om 'n groter bevestiging te hê, kan u die gate wat aan die einde van die stemvurk is, maak om dit aan die liggaam te koppel.

Stap 12: Sit die Ukulele snare

Uiteindelik moet ons die snare plaas sodat ons instrument klaar is.

Voorheen sal ons die bevestigingsringe van die penne in die uitsteeksels van hierdie wat deur die mas gaan, insteek. Om die snare te plaas, neem ons die 4 snare wat by die kit kom. Eerstens moet u elke string onderskei, want hulle is nie almal dieselfde nie. U moet die een punt van elke tou vasmaak (die twee dikke met 'n normale knoop en die twee dunne met 'n dubbele een) en die snare in die gleuwe van die brug steek.

Dan plaas ons die snare so dat:

• Eerste posisie: G string (tweede dikste string).

• Tweede posisie: C string (dikker string).

• Derde posisie: E string (tweede dunner string).

• Vierde posisie: 'n string (dunner string).

Ryg die toutjies in die gate van die meegeleverde prop. Probeer om elke tou vas te maak deur twee of drie draaie op die pen te draai. Span die snare sonder om te veel krag uit te oefen en kyk na die afstand tussen die snare en die saal.

As u twyfel oor hoe u dit kan maak, kan u die tutoriaal gebruik om u te verduidelik hoe die snare korrek is.

Stap 13: Toets

Uiteindelik moet ons kyk of die ukulele behoorlik saamgestel is sodat die ideale afstand op die eerste fret 0,1 mm is en op die twaalfde ongeveer 1,2 mm.

Is dit nodig dat u die ukulele snare afstem. Ek beveel u hierdie app aan: GuitarTuna

Stap 14: Geniet dit

Nou hoef u net u ukulele te geniet.

As u meer inligting oor ons wil weet, kan u ons vind in:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc