„Pasidaryk pats“išmanioji elektroninė ukulele su „Arduino“: 14 žingsnių (su nuotraukomis)

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:48

Mes žingsnis po žingsnio paaiškinsime, kaip galite sukurti savo ukulelę ir pridėti tam tikrų efektų, kurie padarys jį unikalų, pavyzdžiui, nupiešdami ką nors, ko norime, ant ukulelės paviršiaus arba pridėdami tam tikrų šviesos efektų.

Norėdami tai padaryti, turite nusipirkti ukulelės rinkinį.

Mes paaiškinsime, kaip surinkti instrumentą, ir išspręsime įvairias galimas problemas.

1 žingsnis: medžiagos

Struktūros medžiagos:

„Pasidaryk pats“„ukelele“tvirtinimo komplektas (tai gali būti kitas komplektas), kurį sudaro:

1- Kūnas.

2-kaklas.

3-balnelis

4 virvių palaikymas

5-tiltas

6 eilučių veržlė.

7-mašinos galvutės tvirtinimo žiedas (x4).

8 mašinų galvutės (x4).

Mašinų galvučių tvirtinimo varžtai (x8).

Mašinos tilto tvirtinimo varžtai (x2).

11 dangtelių dangteliai, skirti tilto tvirtinimo varžtams (x2).

12 stygų (x4).

Elektroninės medžiagos:

• NANO Arduino.
• Ledų ratas WS2812.
• Akselerometras BMA220 (neprivaloma).
• Baterijos jungtis.
• Baterija 9V.
• Perjungti.

Kiti

• Medinis lakas.
• Velcro.
• Litavimo skarda.
• Apsauginis plastikas lakavimui.
• Karšto lydymosi silikonas.

Įrankiai:

• Graviravimas lazeriu.
• Švitrinis popierius
• Žvaigždžių atsuktuvas.
• Teptukas.
• Karšto lydymo pistoletas.
• Alavo lituoklis.

2 žingsnis: pritaikykite „Ukulele“

Norėdami kostiumuoti savo ukulelę, mes galime išgraviruoti piešinį lazeriniu pjaustytuvu ant kūno. Jei neturime to įrankio, galime jį dažyti.

Pirmas pasirodo mūsų pasirinktas paveikslas.

Visų pirma, mes turime suprojektuoti piešimo šabloną, kad padarytume graviūrą.

Norėdami tai padaryti, naudosime programinę įrangą „Inkscape“, kurią galėtume gauti iš šios nuorodos:

Norėdami jį naudoti, turime pakoreguoti norimą naudoti paveikslėlį, kaip parodyta antrame paveikslėlyje. Galite pažiūrėti, kad mes pasukome pradinį vaizdą, kad galėtume sureguliuoti rankos formą pagal prietaiso apskritimą. Kaip jau minėjome, galite įdėti bet kokį vaizdą.

3 žingsnis: Vektorizuokite vaizdą naudodami „Inkscape“

Pamatysime, kaip sukurti vektorinį failą iš pikselių žemėlapio (jpg, png, bet kokio rastrinio formato, kurį gali atidaryti „Inkscape“).

„Inkscape“„Inkscape“yra atvirojo kodo vektorinės grafikos redaktorius, ir, kaip rodo pavadinimas, tai yra įrankis, kurį naudosiu logotipams vektorizuoti. Vektorizavimo veiksmai Šie veiksmai yra įprasti bet kokiai vektorizacijai, kurią norėtume atlikti.

1. Atidarykite vaizdą „Inkscape“
2. Atidarykite „Trace Bitmap Tool Path-> Trace Bitmap“
3. Žaiskite „Trace Bitmap“parinktis
4. Vykdykite sekimą
5. Išvalykite rezultatus (jei reikia)

Atkreipkite dėmesį į „žaidimo aplinką“dalį. Nesu sekimo ekspertas, todėl šį įrankį laikau juodąja dėžute su rankenėlėmis ir lemputėmis, sukdamasis ir keisdamas, kol pasieksiu geriausią rezultatą

4 žingsnis: logotipo graviravimas

Tam svarbu turėti paviršiaus, ant kurio bus išgraviruotas piešinys, siluetą.

Graviravimui naudosime „T2Laser“programinę įrangą. Šią programinę įrangą galėjome gauti iš:

Atidarę programinę įrangą, turime įkelti vaizdą, kurį sukūrėme paskutiniame žingsnyje. Tada paspauskite mygtuką „valdymo lazeris“ir pasirodys cnc valdikliai. Dvi nuotraukos parodo graviravimo su lazeriniu pjaustytuvu procesą ir rezultatą.

5 žingsnis: šlifavimas ir lakavimas

Kad mūsų ukulelė liktų šviesi ir su sluoksniu be šiurkštumo, mes galime atsargiai nušlifuoti dvi mūsų instrumentą sudarančias dalis, nes galime sugadinti padarytą piešinį (jei pasirinksite dažyti ukulelę, turėsite pirmiausia nušlifuokite). Tada mes lakuosime dvi dalis, kad jos įgautų tamsesnę spalvą ir mediena būtų atsparesnė. Mes galime naudoti įprastą medienos laką, jis neturi būti ypatingas.

Kai turėsime laką, sumaišome jį su trupučiu tirpiklio, kad šiek tiek ištirptų. Tada teptuku tepame mišinį ant instrumento kaklo ir kūno ir leidžiame jam išdžiūti.

Jei matome, kad gaminiui reikia antro sluoksnio, abi dalis galime šiek tiek nušlifuoti ir iš naujo užtepti praskiesto lako sluoksnį.

** ATSARGUMO PRIEMONĖS: Lakas yra cheminis produktas, todėl būtina šį procesą atlikti vėdinamoje vietoje, dėvėti kaukę, kad neįkvėptumėte kvapų ir apsauginių akinių.

Medžiagos, kurių mums reikia, kad galėtume tinkamai dirbti, yra tos, kurios yra nuotraukose. Dažniausiai dirbsime su teptuku, lako skardine (mūsų atveju raudona spalva), šiek tiek tirpiklio ir vizualine apsauga. Ir svarbiausia dirbti gerai vėdinamose patalpose.

6 žingsnis: Aparatūra

Mūsų plokštelė su „Arduino“, acelerometru ir ratuku su lemputėmis bus pristatyta mažame laikiklyje, kad visi komponentai nejudėtų instrumente.

Taip pat pridėjome akumuliatoriaus laikiklį ir jungiklį, kad būtų patogiau, ir nenaudojame baterijos, kai nenaudojame prietaiso. Mes pritvirtinsime šią atramą su Velcro gabalėliu (jis taip pat veiktų su silikonu ir karšto lydymosi pistoletu) prie ukulelės korpuso vidinio paviršiaus. Kita vertus, LED ratas yra mažesnis už skylę, todėl jis nukris. Atrama sukurta taip, kad gerai laikytųsi ir galėtų atlikti savo funkciją.

7 žingsnis: programinė įranga

Kad mūsų ukulelė būtų ypatingai papuošta, šviesos ratų dėka galėtume pridėti šviesos efektų. Mes naudosime WS2812, bet jūs galite naudoti bet kurį kitą, vadovaudamiesi duomenų lapo instrukcijomis. Mes taip pat naudosime acelerometrą (BMA220), kuris leis mums paveikti gravitaciją.

Tiesą sakant, turėsime 4 šviesos pjeses, įtrauktas į kompiuterinę biblioteką, pavadintą „Arduino“„Adafruit“. Norėdami tai padaryti, turime teisingai sujungti tris komponentus: „Arduino NANO“, WS2812 ir BMA220, kaip parodyta pirmame paveikslėlyje.

Raudoni laidai skirti maitinti, GND juodi, o kiti yra būtini tinkamo veikimo jungtys. Šviesos rinkiniui naudojamas kodas pridedamas prie failo, pavadinto „play_of_light_v0.ino“. Įsitikinkite, kad įtraukėte reikiamas bibliotekas, kad programa veiktų tinkamai. Akumuliatoriaus, kurį pridedame prie grandinės išorės, minimali įtampa turi būti 9 V, ir mes turime užtikrinti, kad ji galėtų suteikti mažiausią srovę, reikalingą visai grandinei maitinti.

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

baitų versija [3];

int8_t x_data; int8_t y_data; int8_t z_data; baitų diapazonas = 0x00; plūdė divi = 16; plūdė x, y, z; plūdė pi = 3.14159265359; plūdė nx, ny, kampas; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Kintamieji Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parametras 1 = pikselių skaičius juostelėje // Parametras 2 = Arduino kaiščio numeris (dauguma galioja) // 3 parametras = pikselių tipo vėliavos, jei reikia, pridėkite: // NEO_KHZ800 800 KHz bitų srautas (dauguma „NeoPixel“produktų su WS2812 šviesos diodais) // NEO_KHZ400 400 KHz (klasikinis „v1“(ne v2) FLORA pikselių, WS2811 tvarkyklės) // „NEO_GRB Pixels“yra prijungti prie GRB bitų srauto (dauguma „NeoPixel“produktų)/ / NEO_RGB Pikseliai yra prijungti prie RGB bitų srauto (v1 FLORA pikselių, o ne v2) // NEO_RGBW Pikseliai yra prijungti prie RGBW bitų srauto („NeoPixel RGBW“produktai) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_K) // SVARBU: Kad sumažintumėte „NeoPixel“perdegimo riziką, pridėkite 1000 uF kondensatorių prie // taškų maitinimo laidų, pridėkite 300–500 omų rezistorių pirmojo taško duomenų įvestyje // ir sumažinkite atstumą tarp „Arduino“ir pirmojo taško. Venkite prijungti // prie tiesioginės grandinės … jei reikia, pirmiausia prijunkite GND.

// Kintamieji Rueda de colores

// „NeoPixel Ring“paprastas eskizas (c) 2013 m. „Shae Erisson“// išleistas pagal GPLv3 licenciją, kad atitiktų likusią „AdaFruit NeoPixel“bibliotekos dalį

#įtraukti

#ifdef _AVR_ #include #endif

// Kuris „Arduino“kaištis yra prijungtas prie „NeoPixels“?

// „Trinket“ar „Gemma“siūlome tai pakeisti į 1 #define PIN 9

// Kiek „NeoPixels“pridedama prie „Arduino“?

#define NUMPIXELS 16

// Kai nustatome „NeoPixel“biblioteką, nurodome, kiek pikselių ir kokį smeigtuką naudoti signalams siųsti.

// Atminkite, kad senesnėms „NeoPixel“juostelėms gali tekti pakeisti trečiąjį parametrą-daugiau informacijos apie galimas vertes rasite „strandtest //“pavyzdyje. Adafruit_NeoPixel pikseliai = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // atidėti 50 ms

// Variables colores aleatorios

#įtraukti #ifdef _AVR_ #įtraukti #endif

#define PIN 9

#define NUM_LEDS 16

#define BRIGHTNESS 200

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

baitas 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); // akselerometro adresas // diapazono nustatymai Wire.write (0x22); // registracijos adresas Wire.write (diapazonas); // gali būti nustatytas kaip "0x00" "0x01" "0x02" "0x03", žr. Datashhet on wiki // žemo dažnio filtras Wire.write (0x20); // registracijos adresas Wire.write (0x05); // gali būti nustatytas kaip "0x05" "0x04" …… "0x01" "0x00", žr. Datashhet wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Tai skirta „Trinket 5V 16MHz“, galite pašalinti šias tris eilutes, jei nenaudojate „Trinket #if“(_AVR_ATtiny85_), jei (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Paminklo specialios kodo juostos pabaiga.begin (); strip.show (); // Inicijuokite visus taškus į „išjungtą“

// Código Rueda de colores

// Tai skirta „Trinket 5V 16MHz“, galite pašalinti šias tris eilutes, jei nenaudojate „Trinket #if“(_AVR_ATtiny85_), jei (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Paminklo specialaus kodo pabaiga

pixels.begin (); // Tai inicijuoja „NeoPixel“biblioteką.

// „Codigo Interrupcion“

skaitiklis = 1;

// Codigo Colores varios

// Tai skirta „Trinket 5V 16MHz“, galite pašalinti šias tris eilutes, jei nenaudojate „Trinket #if“(_AVR_ATtiny85_), jei (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Paminklo specialios kodo juostelės pabaiga.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Inicijuoti visus taškus į „išjungta“}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; jei (skaitiklis == 1) {už (int i = 0; i 0,0) {jei (nx 0,0) kampas+= 180; kitas kampas += 360; } // pabaiga else if (kampas == 360,0) kampas = 0,0; ledas = apskritimas (kampas / (360 / NUMBER_OF_LEDS_ON_RING)); // padaryti sklandų judėjimą, jei (ankstesnisLed == vedamas) {// nieko nereikia daryti} kitaip, jei (prieš laikrodžio rodyklęDistanceBetweenLeds (ankstesnisLed, ledas) <= 8) led = apskritimas (ankstesnisLed + 1); else led = circularize (ankstesnisLed - 1); ledQueue.push (ledas); makeLightShow (); previousLed = vedė; vėlavimas (25); } skaitiklis = 2; } // Pabaiga, jei skaitiklis == 1 // Caso 2: Codigo del juego de luces del arcoiris else, jei (skaitiklis == 2) {for (int j = 0; j <5; j ++) {// Kai kurie procedūrų pavyzdžiai kaip rodyti pikseliams: colorWipe1 (strip. Color (255, 0, 0), 50); // Raudona spalvaWipe1 (juostelė. Spalva (0, 255, 0), 50); // Žalia spalvaWipe1 (juostelė. Spalva (0, 0, 255), 50); // Mėlyna spalvaWipe1 (juostelė. Spalva (0, 0, 0, 255), 50); // Baltas RGBW // Siųsti teatro pikselių persekiojimą… teatreChase (strip. Color (127, 127, 127), 50); // Baltasis teatrasChase (strip. Color (127, 0, 0), 50); // Raudonasis teatrasChase (strip. Color (0, 0, 127), 50); // Mėlyna

vaivorykštė (5);

vaivorykštinis ciklas (5); teatrasChaseVaivorykštė (5); } skaitiklis = 3; } // Pabaiga, jei skaitiklis == 2 // Caso 3: Luces Aleatorias else if (skaitiklis == 3) {for (int k = 0; k <50; k ++) {// NeoPikselių rinkiniui pirmasis NeoPikselis 0, antrasis yra 1, iki pikselių skaičiaus minus vienas. int a = atsitiktinis (255); int b = atsitiktinis (255); int c = atsitiktinis (255); už (int i = 0; i

// taškai. Spalva paima RGB reikšmes nuo 0, 0, 0 iki 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Vidutiniškai ryškiai žalia spalva.

pixels.show (); // Tai siunčia atnaujintą pikselių spalvą aparatinei įrangai.

vėlavimas (uždelsimas); // Vėlavimas tam tikrą laiką (milisekundėmis).

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

// taškai. Spalva paima RGB reikšmes nuo 0, 0, 0 iki 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Vidutiniškai ryškiai žalia spalva.

pixels.show (); // Tai siunčia atnaujintą pikselių spalvą aparatinei įrangai.

vėlavimas (uždelsimas); // Vėlavimas tam tikrą laiką (milisekundėmis).

}} skaitiklis = 4; } else if (skaitiklis == 4) {for (int g = 0; g <= 6; g ++) {// Kai kurie procedūrų pavyzdžiai, rodantys, kaip rodyti taškus: colorWipe (strip. Color (255, 0, 0), 50); // Raudona spalvaWipe (strip. Color (0, 255, 0), 50); // Žalia spalva Nuvalykite (juostelė. Spalva (0, 0, 255), 50); // Mėlyna spalvaWipe (strip. Color (0, 0, 0, 255), 50); // balta baltaOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // uždelsimas (2000); rainbowFade2White (3, 3, 1);

}

skaitiklis = 1; }} /////////////////////////////////////////////////////////////- /////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// //////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // akselerometro adresas // iš naujo nustatyti pagreičio matuoklį Wire.write (0x04); // X duomenys Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // prašyti 6 baitų iš antrojo įrenginio #2, o (Wire.available ()) // vergas gali siųsti mažiau nei prašoma {Versija [0] = Wire.read (); // gauti baitą kaip simbolį} x_data = (int8_t) Versija [0] >> 2; Wire.beginTransmission (0x0A); // akselerometro adresas // iš naujo nustatyti pagreičio matuoklį Wire.write (0x06); // Y duomenys Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // prašyti 6 baitų iš antrojo įrenginio #2, o (Wire.available ()) // vergas gali siųsti mažiau nei prašoma {Version [1] = Wire.read (); // gauti baitą kaip simbolį} y_data = (int8_t) Versija [1] >> 2; Wire.beginTransmission (0x0A); // akselerometro adresas // iš naujo nustatyti pagreičio matuoklį Wire.write (0x08); // Z duomenys Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // prašyti 6 baitų iš antrojo įrenginio #2, o (Wire.available ()) // vergas gali siųsti mažiau nei prašoma {Version [2] = Wire.read (); // gauti baitą kaip simbolį} z_data = (int8_t) Versija [2] >> 2; x = (plūdė) x_data/divi; y = (plūdė) y_data/divi; z = (plūdė) z_data/divi; Serijinis atspaudas ("X ="); Serijinis atspaudas (x); // spausdinti simbolį Serial.print (""); Serijinis atspaudas ("Y ="); Serijinis atspaudas (y); // spausdinti simbolį Serial.print (""); Serijinis atspaudas ("Z ="); // spausdinti simbolį Serial.println (z); }

int cirkuliuoti (int pos) {

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

int atstumas;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; if (atstumas <0) atstumas += NUMBER_OF_LEDS_ON_RING; grįžimas (atstumas); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

už (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

// Užpildykite taškus vienas po kito spalva tuščia spalvaWipe (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i

void rainbow (uint8_t wait) {

uint16_t i, j;

už (j = 0; j <256; j ++) {už (i = 0; i

// Šiek tiek skiriasi, todėl vaivorykštė pasiskirsto tolygiai

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

(j = 0; j <256*5; j ++) {// 5 visų rato spalvų ciklai (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, ratas (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); atidėti (laukti); }}

// Teatro stiliaus šliaužiančios šviesos.

void theatreChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// atlikite 10 persekiojimo ciklų (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // įjungti kas trečią pikselį} strip.show ();

atidėti (laukti);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // išjunkite kas trečią tašką}}}}

// Teatro stiliaus šliaužiančios šviesos su vaivorykštės efektu

void theatreChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// perjungti visas 256 rato spalvas, skirtas (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, ratas ((i+j) % 255)); // įjungti kas trečią pikselį} strip.show ();

atidėti (laukti);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // išjunkite kas trečią tašką}}}}

// Įveskite reikšmę nuo 0 iki 255, kad gautumėte spalvos vertę.

// Spalvos yra perėjimas r - g - b - atgal į r. uint32_t Ratas (baitas WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } if (WheelPos <170) {WheelPos -= 85; grąžinimo juostelė. Spalva (0, WheelPos * 3, 255 - WheelPos * 3); } „WheelPos“-= 170; grąžinimo juostelė. Spalva („WheelPos“* 3, 255 - „WheelPos“* 3, 0); }

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

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

/Metodos Rueda de colores

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

// CylonEyeColor = HtmlColor (elegirColor); // int elegirColor = atsitiktinis (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 (0x0000ff) // 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

// Taškus vieną po kito užpildykite spalva

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

void pulseWhite (uint8_t palaukti) {

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

už (int j = 255; j> = 0; j-) {

už (uint16_t i = 0; i

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

plūdė 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 visų rato spalvų ciklai

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

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

redVal = raudona (wheelVal) * plūdė (fadeVal/fadeMax);

greenVal = žalia (wheelVal) * plūdė (fadeVal/fadeMax); blueVal = mėlyna (wheelVal) * plūdė (fadeVal/fadeMax);

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

}

// Pirma kilpa, išblėsk!

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

// Paskutinė kilpa, išnyks!

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

strip.show ();

atidėti (laukti); }}

vėlavimas (500);

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

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

vėlavimas (2000 m.);

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

vėlavimas (500);

}

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

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

int galva = baltaIlgis - 1;

int uodega = 0;

int kilpos = 3;

int kilpaNum = 0;

statinis nepasirašytas ilgas lastTime = 0;

nors (tiesa) {

už (int j = 0; j <256; j ++) {už (uint16_t i = 0; i = uodega && i galva && i> = uodega) || (uodega> galva && i <= galva)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } else {strip.setPixelColor (i, ratas ((((i * 256 / strip.numPixels ()) + j) ir 255)); }}

if (millis () - lastTime> whiteSpeed) {

galva ++; uodega ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = milis (); }

if (loopNum == kilpos) return;

galva%= juostelė.numPikseliai (); uodega%= juostelė.numPikseliai (); strip.show (); atidėti (laukti); }}} void fullWhite () {for (uint16_t i = 0; i

// Šiek tiek skiriasi, todėl vaivorykštė pasiskirsto tolygiai

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

(j = 0; j <256 * 5; j ++) {// 5 visų rato spalvų ciklai (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, ratas (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); atidėti (laukti); }}

void rainbow1 (uint8_t wait) {

uint16_t i, j;

už (j = 0; j <256; j ++) {už (i = 0; i

// Įveskite reikšmę nuo 0 iki 255, kad gautumėte spalvos vertę.

// Spalvos yra perėjimas r - g - b - atgal į r. uint32_t Ratas1 (baitas „WheelPos“) {WheelPos = 255 - „WheelPos“; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) {WheelPos -= 85; grąžinimo juostelė. Spalva (0, WheelPos * 3, 255 - WheelPos * 3, 0); } „WheelPos“-= 170; grąžinimo juostelė. Spalva („WheelPos“* 3, 255 - „WheelPos“* 3, 0, 0); }

uint8_t raudona (uint32_t c) {

grįžimas (c >> 16); } uint8_t žalia (uint32_t c) {return (c >> 8); } uint8_t blue (uint32_t c) {return (c); }

8 žingsnis: 3D dizainas

Pirmiausia turite nustatyti aparatūros komponentų dydį, kad įsitikintumėte, jog jie teisingi. Jei jie yra tokie patys kaip mūsų, galite naudoti tuos pačius failus, kuriuos mes jums skoliname.

Abi atramos buvo sukurtos naudojant 3D spausdintuvą, kuris taip pat įtrauktas kaip:

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

Galiausiai šviesa bus tokia, kaip dvi paskutinės nuotraukos.

9 žingsnis: kaklo montavimas

Pirmiausia padėkime balną ant kaklo. Skylių, kurias reikia laikyti varžtams laikyti, nėra, todėl turėsime jas padaryti, pažymėdami, kur jie turi eiti, ir atsargiai, sraigtu, padarę skylę.

Tas pats pasakytina apie skyles, kuriose varžtai, laikantys patį kaklą prie prietaiso korpuso. Jų daryti nebūtina, nes šiam tvirtinimui nėra varžtų, tačiau jei norime tai padaryti, problemų nekiltų.

SVARBU: tarp stiebo pradžios ir derinimo šakutės pradžios palikite 5 mm tarpą, nes toje skylėje bus įdėta veržlė.

Veržlę klijuosime klijais paveikslo nurodyta kryptimi.

Galiausiai mes pristatysime 4 kaiščius skylėse, esančiose stiebo pradžioje, kiekvieną kaištį laikydami 2 trumpais varžtais, kaip parodyta paveikslėlyje.

10 žingsnis: „Birdge“montavimas

Tiltas tvirtinamas klijuojant ir dviem ilgais varžtais centrinėje kūno vietoje. Patartina pieštuku pažymėti teisingą kūno padėtį. Mes imsimės atstumų, kurie pažymėti paveikslėlyje.

Dviejų komponentų sujungimo metu tepame klijus. Dvi dalis atsargiai pritvirtiname priveržimo varžtu, kol jungtis išdžius. Mes padarysime dvi skyles varžtams su 1,5 mm gręžtuvu medienai. Pritvirtinkite tiltą dviem ilgais varžtais korpuse. Ir galiausiai ant varžtų galvų uždedame apsauginius dangtelius.

11 žingsnis: Kūno ir kaklo surinkimas

Norėdami surinkti dvi dalis, kūno galvutėje turime skyles, kuriose kaklas tilps su dviem turimomis iškyšomis. Mes galime juos klijuoti klijais arba karšto lydymosi pistoletu. Norėdami didesnės fiksacijos, galite padaryti skylutes, esančias derinimo šakutės gale, kad sujungtumėte ją su korpusu.

12 žingsnis: įdėkite „Ukulele“stygas

Galiausiai turime išdėstyti stygas taip, kad mūsų instrumentas būtų baigtas.

Anksčiau kaiščių tvirtinimo žiedus įkišame į jų iškyšas, einančias per stiebą. Norėdami įdėti stygas, mes paėmėme 4 stygas, kurios buvo komplekte. Pirmiausia turite atskirti kiekvieną eilutę, nes jos ne visos vienodos. Turite surišti vieną kiekvienos virvelės galą (du stori su įprastu mazgu, o du ploni - su dviguba) ir įkišti stygas į tilto angas.

Tada eilutes išdėstysime taip, kad:

• Pirma pozicija: G eilutė (antra storiausia eilutė).

• Antroji padėtis: C eilutė (storesnė eilutė).

• Trečia pozicija: E eilutė (antra plonesnė eilutė).

• Ketvirta pozicija: eilutė (plonesnė eilutė).

Įkiškite stygas į pateikto kištuko angas. Pabandykite pritvirtinti kiekvieną virvę du ar tris apsisukimus ant kaiščio. Įtempkite virves nenaudodami per daug jėgos ir patikrinkite atstumą tarp stygų ir balno.

Jei turite kokių nors abejonių, kaip tai padaryti, pamokoje galite paaiškinti, kaip teisingai įdėti eilutes.

13 žingsnis: bandymas

Galiausiai turime pamatyti, ar ukulelė buvo tinkamai surinkta taip, kad idealus atstumas pirmame frette būtų 0,1 mm, o dvyliktoje - maždaug 1,2 mm.

Reikia suderinti ukulelės stygas. Aš rekomenduoju jums šią programą: GuitarTuna

14 žingsnis: mėgaukitės

Dabar belieka mėgautis savo ukulele.

Jei norite sužinoti daugiau informacijos apie mus, mus rasite:

„Twitter“: @Innovart_cc

„Facebook“: @Innovartcc

Instagram: @Innovart_cc

Tinklapis: Innovart.cc