DIY nutikas elektrooniline ukulele Arduinoga: 14 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:49

Me selgitame samm -sammult, kuidas saate oma ukulele kujundada ja lisada mõningaid efekte, mis muudavad selle ainulaadseks, näiteks joonistades ukulele pinnale midagi, mida soovime, või lisades mõned valgusefektid.

Selle tegemiseks on vaja osta ukulele komplekt.

Me selgitame, kuidas pilli kokku panna, ja lahendame erinevaid probleeme, mis võivad ilmneda.

Samm: materjalid

Struktuuri materjalid:

DIY ukelele paigalduskomplekt (see võib olla teine komplekt), mille moodustab:

1- Keha.

2-kael.

3-sadul

4-köie tugi

5-sild

6-stringiline pähkel.

7-kinnitusrõngas masinapea jaoks (x4).

8-masinapead (x4).

9-kinnituskruvid masinapeadele (x8).

10-kinnituskruvid masinasillale (x2).

11-kaanekatted silla kinnituskruvide jaoks (x2).

12-string (x4).

Elektroonilised materjalid:

• NANO Arduino.
• Ledide ratas WS2812.
• Kiirendusmõõtur BMA220 (valikuline).
• Aku pistik.
• Aku 9V.
• Lüliti.

Teised

• Puitlakk.
• Velcro.
• Jootmisvorm.
• Kaitsev plastik lakkimiseks.
• Kuumsulav silikoon.

Tööriistad:

• Lasergraveerimine.
• Liivapaber
• Tähekruvikeeraja.
• Värvipintsel.
• Kuumsulamispüstol.
• Tina jootekolb.

Samm: kohandage Ukulele

Ukulele kostüümimiseks võiksime teha kehale laserlõikuriga joonistuse graveeringu. Kui seda tööriista pole, võime selle värvida.

Esimene pilt, mille me valisime, on meie valitud.

Kõigepealt peame graveeringu tegemiseks kujundama joonistusmalli.

Selleks kasutame tarkvara nimega „Inkscape”, mille saame sellelt lingilt:

Selle kasutamiseks peame kohandama pilti, mida soovime kasutada, nagu näeme teisel pildil. Võiksite vaadata, et oleme pööranud esialgset pilti, et reguleerida käe tsüklit instrumendi ringiga. Nagu oleme varem öelnud, võite panna mis tahes pildi.

3. samm: pildi vektoriseerimine Inkscape'i abil

Näeme, kuidas luua vektorfaili pikslipildist (jpg, png, olenemata rasterivormingust, mida Inkscape saab avada).

Inkscape Inkscape on avatud lähtekoodiga vektorgraafika redaktor ja nagu pealkiri ütleb, on see tööriist, mida kasutan logode vektoriseerimiseks. Vektoristamisetapid Need sammud on tavalised mis tahes vektoriseerimise jaoks, mida võiksime teha.

1. Avage pilt Inkscape'is
2. Avage Trace Bitmap Tool Path-> Trace Bitmap
3. Mängige Bitcep -i jälgimise suvandite ümber
4. Käivitage jälgimine
5. Puhastage tulemused (vajadusel)

Pange tähele osa "mängimine". Ma ei ole jälgimise asjatundja, seega kohtlen seda tööriista kui musta kasti, millel on nupud ja tuled, keerutades ja vahetades, kuni saavutan parima tulemuse

Samm: logo graveerimine

Selleks on oluline, et oleks pinna siluett, millele joonise graveering tehakse.

Graveeringu tegemiseks kasutame tarkvara „T2Laser”. Selle tarkvara saime siit:

Kui oleme tarkvara avanud, peame laadima pildi, mille oleme viimases etapis loonud. Seejärel vajutage nuppu "juhtlaser" ja kuvatakse cnc -juhtelemendid. Kaks pilti näitavad meie laserlõikuriga graveerimise protsessi ja tulemust.

Samm: lihvimine ja lakkimine

Selleks, et jätta meie ukulele heledaks ja ilma kareduseta kihiga, saame hoolikalt lihvida kahte osa, millest meie instrument koosneb, sest me võime joonist kahjustada (kui olete valinud ukulele värvimise, peate kõigepealt lihvige seda). Seejärel lakkime oma kaks osa nii, et need saaksid tumedama värvi ja puit oleks vastupidavam. Saame kasutada tavalist puitlakki, see ei pea olema eriline.

Kui meil on lakk, segame selle vähese lahustiga, nii et see veidi lahustub. Järgmisena rakendame segu pintsliga kaelale ja instrumendi korpusele ning laseme kuivada.

Kui näeme, et toode vajab teist kihti, võime neid kahte osa pisut lihvida ja uuesti lahjendatud lakikihi peale kanda.

** ETTEVAATUSABINÕUD: Lakk on keemiline toode, seega on vaja seda protsessi teha ventileeritavas kohas, kandke maski, et vältida lõhnade ja kaitseprillide sissehingamist.

Materjalid, mida peame õigesti töötama, on need, mis on fotodel. Peamiselt töötame pintsli, lakkpurgi (meie puhul punase värvusega), vähese lahusti ja visuaalse kaitsega. Ja ennekõike töö hästi ventileeritud ruumides.

6. samm: riistvara

Meie tahvel koos Arduino, kiirendusmõõturi ja LED -idega rattaga tutvustatakse väikeses sulgus, et vältida kõigi komponentide liikumist instrumendis.

Oleme lisanud ka patareipesa ja lüliti, et muuta see mugavamaks ning me ei kuluta akut ära, kui me pilli ei kasuta. Kinnitame selle toe Velcro tükiga (see töötaks ka silikooni ja kuumsulamispüstoliga) ukulele korpuse sisepinnale. Teisest küljest on LED -ratas aukust väiksem, nii et see kukuks. Tugi on konstrueeritud nii, et see hoiab hästi ja saab oma ülesannet täita.

Samm 7: Tarkvara

Meie ukulele erilise kaunistuse andmiseks võiksime tänu valgusdioodide rattale lisada valgusefekte. Me kasutame WS2812, kuid saate kasutada mis tahes muud, järgides andmelehe juhiseid. Kasutame ka kiirendusmõõturit (BMA220), mis võimaldab meil gravitatsiooni mõjutada.

Tegelikult on meil Arduino arvutiteegis „Adafruit” neli valgusmängu. Selleks peame kolme komponendi: Arduino NANO, WS2812 ja BMA220 - vahel tegema õige seose, nagu esimesel pildil.

Punased juhtmed on toiteallikaks, GND mustad ja ülejäänud on vajalikud ühendused õigeks toimimiseks. Valguskomplekti jaoks kasutatud kood on lisatud faili nimega "play_of_light_v0.ino". Veenduge, et olete kaasanud programmi õigeks tööks vajalikud teegid. Aku, mille lisame ahela välispinnale, peab olema vähemalt 9 V pingega ja peame tagama, et see suudab anda kogu vooluahela toiteks vajaliku minimaalse voolu.

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

bait Versioon [3];

int8_t x_andmed; int8_t y_andmed; int8_t z_andmed; baitide vahemik = 0x00; float divi = 16; ujuk x, y, z; ujuk pi = 3,14159265359; ujuk nx, ny, nurk; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Muutujad Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parameeter 1 = pikslite arv ribas // Parameeter 2 = Arduino pin -number (enamik on kehtivad) // Parameeter 3 = pikslitüübi lipud, lisage vastavalt vajadusele: // NEO_KHZ800 800 kHz bitivool (enamik NeoPixeli tooteid koos WS2812 LED -idega) // NEO_KHZ400 400 KHz (klassikaline 'v1' (mitte v2) FLORA pikslid, WS2811 draiverid) // NEO_GRB pikslid on ühendatud GRB bitivooga (enamik NeoPixeli tooteid)/ / NEO_RGB Pikslid on ühendatud RGB bitivooga (v1 FLORA pikslit, mitte v2) // NEO_RGBW Pikslid on ühendatud RGBW bitivooga (NeoPixeli RGBW tooted) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_K) // TÄHTIS: NeoPixeli läbipõlemise riski vähendamiseks lisage 1000 uF kondensaatorit // piksli toitejuhtmetele, lisage esimese piksli andmesisestusele 300–500 oomi takisti // ja minimeerige Arduino ja esimese piksli vaheline kaugus. Vältige // ühendamist pingestatud vooluahelal… vajadusel ühendage kõigepealt GND.

// Muutujad Rueda de colores

// NeoPixel Ring lihtne visand (c) 2013 Shae Erisson // avaldati GPLv3 litsentsi alusel, et see sobiks ülejäänud AdaFruit NeoPixeli koguga

#kaasake

#ifdef _AVR_ #include #endif

// Milline Arduino tihvt on NeoPixelitega ühendatud?

// Trinketis või Gemmas soovitame muuta selle väärtuseks 1 #define PIN 9

// Mitu NeoPikslit on Arduino külge kinnitatud?

#defineeri NUMPIXELID 16

// NeoPixeli raamatukogu seadistamisel ütleme sellele, mitu pikslit ja millist tihvti signaalide saatmiseks kasutada.

// Pange tähele, et vanemate NeoPixeli ribade puhul peate võib-olla muutma kolmandat parameetrit-lisateavet võimalike väärtuste kohta leiate näitest strandtest //. Adafruit_NeoPixel pikslid = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // viivitus 50 ms

// Variables colores aleatorios

#include #ifdef _AVR_ #include #endif

#defineeri PIN -kood 9

#defineeri NUM_LEDS 16

#määratle heledus 200

// Adafruit_NeoPixel strip = Adafruit_NeoPixel (NUM_LEDS, PIN, NEO_GRBW + NEO_KHZ800);

bait 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); Seriaalne algus (9600); Wire.begin (); Wire.beginTransmission (0x0A); // kiirendusmõõturi aadress // vahemiku seaded Wire.write (0x22); // registriaadress Wire.write (vahemik); // saab määrata "0x00" "0x01" "0x02" "0x03", vt Datashhet on wiki // madalpääsfilter Wire.write (0x20); // registriaadress Wire.write (0x05); // saab määrata "0x05" "0x04" …… "0x01" "0x00", vt Datashhet wikis Wire.endTransmission ();

Codigo; Luces Arcoiris

// See on Trinket 5V 16MHz jaoks, saate need kolm rida eemaldada, kui te ei kasuta nipsasja #if defineeritud (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Nipsasja erikoodiriba lõpp.begin (); strip.show (); // Initsialiseeri kõik pikslid olekusse „väljas”

// Código Rueda de colores

// See on Trinket 5V 16MHz jaoks, saate need kolm rida eemaldada, kui te ei kasuta nipsasja #if defineeritud (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Nipsasja erikoodi lõpp

pixels.begin (); // See initsialiseerib NeoPixeli kogu.

// Codigo katkestus

loendur = 1;

// Codigo Colores varios

// See on Trinket 5V 16MHz jaoks, saate need kolm rida eemaldada, kui te ei kasuta nipsasja #if defineeritud (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Nipsasja erikoodiriba lõpp.setBrightness (BRIGHTNESS); riba.algus (); strip.show (); // Initsialiseeri kõik pikslid olekusse „väljas”}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; kui (loendur == 1) {jaoks (int i = 0; i 0,0) {kui (nx 0,0) nurk+= 180; muidu nurk += 360; } // lõpp muidu if (nurk == 360,0) nurk = 0,0; led = ringikujuline (nurk / (360 / NUMBER_OF_LEDS_ON_RING)); // tee ledi liikumine sujuvaks, kui (eelmineLed == juhitud) {// pole midagi teha} muud if (counterClockwiseDistanceBetweenLeds (eelmineLed, led) <= 8) led = ringikujuline (eelmineLed + 1); else led = ringikujuline (eelmineLed - 1); ledQueue.push (led); makeLightShow (); previousLed = led; viivitus (25); } loendur = 2; } // End if counter == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Mõned näidisprotseduurid kuidas kuvada pikslitele: colorWipe1 (riba. Värv (255, 0, 0), 50); // Punane värvPühkige1 (riba. Värv (0, 255, 0), 50); // Roheline värvPühkige1 (riba. Värv (0, 0, 255), 50); // Sinine värvPühkige1 (riba. Värv (0, 0, 0, 255), 50); // Valge RGBW // Saada teatripikslite tagaajamine… TheaterChase (strip. Color (127, 127, 127), 50); // Valge teaterChase (riba. Värv (127, 0, 0), 50); // Punane teaterChase (riba. Värv (0, 0, 127), 50); // Sinine

vikerkaar (5);

vikerkaaretsükkel (5); teaterChaseVikerkaar (5); } loendur = 3; } // End if counter == 2 // Caso 3: Luces Aleatorias else if (counter == 3) {for (int k = 0; k <50; k ++) {// NeoPikslite komplekti puhul on esimene NeoPixel 0, teine on 1, kuni pikslite arvuni miinus üks. int a = juhuslik (255); int b = juhuslik (255); int c = juhuslik (255); jaoks (int i = 0; i

// pikslit. Värv võtab RGB väärtused vahemikus 0, 0, 0 kuni 255, 255, 255

pixels.setPixelColor (i, pikslit. Värv (a, b, c)); // Mõõdukalt erkroheline värv.

pixels.show (); // See saadab riistvarale uuendatud pikslivärvi.

viivitus (viivitus); // Viivitus teatud aja jooksul (millisekundites).

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

// pikslit. Värv võtab RGB väärtused vahemikus 0, 0, 0 kuni 255, 255, 255

pixels.setPixelColor (i, pikslit. Värv (a, b, c)); // Mõõdukalt erkroheline värv.

pixels.show (); // See saadab riistvarale uuendatud pikslivärvi.

viivitus (viivitus); // Viivitus teatud aja jooksul (millisekundites).

}} loendur = 4; } else if (loendur == 4) {for (int g = 0; g <= 6; g ++) {// Mõned näiteprotseduurid, mis näitavad, kuidas pikslitele kuvada: colorWipe (strip. Color (255, 0, 0), 50); // Punane värvPühkige (riba. Värv (0, 255, 0), 50); // Roheline värvPühkige (riba. Värv (0, 0, 255), 50); // Sinine värvPühkige (riba. Värv (0, 0, 0, 255), 50); // Valge valgeOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // viivitus (2000); rainbowFade2White (3, 3, 1);

}

loendur = 1; }} /////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// või ////////////////////////////////////////////////////////////- //////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // kiirendusmõõturi aadress // kiirendusmõõturi lähtestamine Wire.write (0x04); // X andmed Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // taotleb 6 baiti alamseadmelt #2 samas (Wire.available ()) // ori võib saata vähem kui nõutud {Version [0] = Wire.read (); // saada tähemärgina bait} x_andmed = (int8_t) Versioon [0] >> 2; Wire.beginTransmission (0x0A); // kiirendusmõõturi aadress // kiirendusmõõturi lähtestamine Wire.write (0x06); // Y andmed Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // taotleb 6 baiti alamseadmelt #2, samas kui (Wire.available ()) // ori võib saata vähem kui nõutud {Version [1] = Wire.read (); // saada tähemärgina bait} y_data = (int8_t) Versioon [1] >> 2; Wire.beginTransmission (0x0A); // kiirendusmõõturi aadress // kiirendusmõõturi lähtestamine Wire.write (0x08); // Z andmed Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // taotleb 6 baiti alamseadmelt #2 samas (Wire.available ()) // ori võib saata vähem kui nõutud {Version [2] = Wire.read (); // saada tähemärgina bait} z_data = (int8_t) Versioon [2] >> 2; x = (ujuk) x_andmed/divi; y = (ujuk) y_andmed/divi; z = (ujuk) z_andmed/divi; Seeria.print ("X ="); Seeria.print (x); // printige märk Serial.print (""); Seeria.print ("Y ="); Seeriatrükk (y); // printige märk Serial.print (""); Seeria.print ("Z ="); // printige märk Serial.println (z); }

int ringikujuline (int pos) {

if (pos> = NUMBER_OF_LEDS_ON_RING) return (pos - NUMBER_OF_LEDS_ON_RING); muidu if (pos <0) return (pos + NUMBER_OF_LEDS_ON_RING); else tagasi (pos); }

int kaugus;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; if (kaugus <0) kaugus += NUMBER_OF_LEDS_ON_RING; tagasitulek (kaugus); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int heledusStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

jaoks (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

// Täida punktid üksteise järel värvi tühja värviga Pühkige (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i

tühi vikerkaar (uint8_t oota) {

uint16_t i, j;

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

// Veidi erinev, see muudab vikerkaare kogu ulatuses võrdselt jaotatuks

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

(j = 0; j <256*5; j ++) {// 5 ratta kõigi värvide tsüklit (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, ratas (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); viivitus (oota); }}

// Teatri stiilis roomavad tuled.

void theatreChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// tee 10 jahtimistsüklit (int q = 0; q <3; q ++) {jaoks (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // lülita sisse iga kolmas piksel} riba.show ();

viivitus (oota);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // lülita iga kolmas piksel välja}}}}

// Teatri stiilis roomavad tuled vikerkaareefektiga

void theatreChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// tsükli kõik 256 värvi ratta jaoks (int q = 0; q <3; q ++) {jaoks (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, Ratas ((i+j) % 255)); // lülita sisse iga kolmas piksel} riba.show ();

viivitus (oota);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // lülita iga kolmas piksel välja}}}}

// Värviväärtuse saamiseks sisestage väärtus 0 kuni 255.

// Värvid on üleminek r - g - b - tagasi r. uint32_t Ratas (bait WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } kui (WheelPos <170) {WheelPos -= 85; tagastusriba. Värv (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; tagastusriba. Värv (WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/Metodos Rueda de colores

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

// CylonEyeColor = HtmlColor (elegirColor); // int elegirColor = juhuslik (1, 7); // Podemos elegir aleatoriamente entre los 7 colores que hey 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 = Htmlvärv (0 // if (elegirColor == 5) CylonEyeColor = HtmlColor (0x200020); // Morado // if (elegirColor == 6) CylonEyeColor = HtmlColor (0x00ffff); // Azul Claro // if (elegirColor == 7) CylonE HtmlColor (0x100010); // Rosa // CylonEyeColor = HtmlColor (0x000000);

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

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

/Metodos luces varias

// Täida punktid üksteise järel värviga

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

void pulseWhite (uint8_t oota) {

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

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

jaoks (uint16_t i = 0; i

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

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

jaoks (int k = 0; k <rainbowLoops; k ++) {jaoks (int j = 0; j <256; j ++) {// 5 tsükli kõik värvid rattal

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

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

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

greenVal = roheline (wheelVal) * float (fadeVal/fadeMax); blueVal = sinine (wheelVal) * float (fadeVal/fadeMax);

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

}

// Esimene silmus, tuhmuma!

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

// Viimane silmus, tuhmuma!

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

strip.show ();

viivitus (oota); }}

viivitus (500);

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

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

viivitus (2000);

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

viivitus (500);

}

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

if (valgepikkus> = riba.numPikslid ()) valge Pikkus = riba.numberPikslid () - 1;

int pea = valgePikkus - 1;

int saba = 0;

int silmused = 3;

int loopNum = 0;

staatiline allkirjastamata pikk lastTime = 0;

samas (tõsi) {

jaoks (int j = 0; j <256; j ++) {jaoks (uint16_t i = 0; i = saba && i pea && i> = saba) || (saba> pea && i <= pea)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } else {strip.setPixelColor (i, Ratas ((((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

pea ++; saba ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == silmused) return;

pea%= riba.numPikslid (); saba%= riba.numPikslid (); strip.show (); viivitus (oota); }}} void fullWhite () {for (uint16_t i = 0; i

// Veidi erinev, see muudab vikerkaare kogu ulatuses võrdselt jaotatuks

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

(j = 0; j <256 * 5; j ++) {// 5 ratta kõigi värvide tsüklit (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, ratas (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); viivitus (oota); }}

tühine vikerkaar1 (uint8_t oota) {

uint16_t i, j;

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

// Värviväärtuse saamiseks sisestage väärtus 0 kuni 255.

// Värvid on üleminek r - g - b - tagasi r. uint32_t Ratas1 (bait WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } kui (WheelPos <170) {WheelPos -= 85; tagastusriba. Värv (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; tagastusriba. Värv (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t punane (uint32_t c) {

tagasitulek (c >> 16); } uint8_t roheline (uint32_t c) {return (c >> 8); } uint8_t sinine (uint32_t c) {return (c); }

8. samm: 3D -disain

Esiteks peate riistvarakomponentide suuruse kindlaks määrama, et olla õiged. Kui need on samad, mis meil, saate kasutada samu faile, mida me teile laename.

Mõlemad toed on disainitud 3D -printeriga, mis on samuti kaasas:

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

Lõpuks on valgus selline nagu kaks viimast pilti.

9. samm: kaela paigaldamine

Kõigepealt asetame sadula kaela. Auke, mida kruvid peavad hoidma, ei ole, seega peame need tegema, märgistades, kuhu nad peaksid minema, ja ettevaatlikult, teo abil auku tegema.

Sama kehtib aukude kohta, kus kruvid, mis hoiavad kaela ennast instrumendi korpuse külge. Neid ei ole vaja teha, kuna selle kinnituse jaoks pole kruvisid, kuid kui me tahame seda teha, poleks probleemi.

TÄHTIS: jäta masti alguse ja häälestushargi alguse vahele 5 mm ruumi, sest sellesse auku pannakse mutter.

Liimime mutri liimiga joonisel näidatud suunas.

Lõpuks tutvustame 4 tihvti aukudes, mis asuvad masti alguses, hoides iga tihvti 2 lühikese kruviga, nagu pildil näidatud.

10. samm: Birdge'i paigaldamine

Sild kinnitatakse liimimise teel ja kahe pika kruviga keha keskosas. Soovitav on pliiatsiga märkida õige asend kehas. Võtame kaugused, mis on pildil märgitud.

Me rakendame liimi kahe komponendi ühendamisel. Kinnitame mõlemad osad pingutuskruvi abil ettevaatlikult, kuni vuuk on kuivanud. Teeme kruvide jaoks kaks auku 1,5 mm puuriga puidu jaoks. Kinnitage sild kahe pika kruviga korpuses. Ja lõpuks paneme kruvide pähe kaitsekorgid.

11. samm: keha ja kaela kokkupanek

Kahe osa kokkupanekuks on meil kere peas augud, kuhu kael mahub kahe väljaulatuva osaga. Saame neid liimida liimiga või kuumsulamispüstoliga. Suurema fikseerimise saavutamiseks võite teha tuuningukahvli lõpus olevad augud, et see keha külge ühendada.

12. samm: pange Ukulele stringid

Lõpuks peame paigutama keeled nii, et meie pill oleks valmis.

Varem sisestame tihvtide kinnitusrõngad nende väljaulatuvatesse osadesse, mis läbivad masti. Nööride paigutamiseks võtsime komplektiga kaasas olnud 4 nööri. Kõigepealt peate eristama iga stringi, kuna need pole kõik ühesugused. Iga nööri üks ots tuleb siduda (kaks paksu tavalise sõlmega ja kaks õhukest kahekordsega) ja sisestada nöörid silla piludesse.

Seejärel asetame stringid selliselt, et:

• Esimene positsioon: G string (paksuselt teine string).

• Teine positsioon: C string (paksem string).

• Kolmas positsioon: E string (teine õhem string).

• Neljas positsioon: string (õhem string).

Keerake paelad kaasasoleva pistiku aukudesse. Proovige iga köit fikseerida, tehes tihvti kaks või kolm pööret. Pingutage nöörid ilma liigset jõudu rakendamata ja kontrollige nööride ja sadula vahelist kaugust.

Kui teil on kahtlusi, kuidas seda teha, võiksite selle õpetuse välja selgitada, kuidas stringe õigesti panna.

13. samm: testimine

Lõpuks peame vaatama, kas ukulele on korralikult kokku pandud nii, et ideaalseks kauguseks esimesel vöötil oleks 0,1 mm ja kaheteistkümnendal umbes 1,2 mm.

Vaja on ukulele keelte häälestamist. Soovitan teile seda rakendust: GuitarTuna

14. samm: naudi seda

Nüüd peate ainult oma ukulelet nautima.

Kui soovite meie kohta rohkem teavet saada, leiate meid aadressilt:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Veebisait: Innovart.cc