DIY viedā elektroniskā ukulele ar Arduino: 14 soļi (ar attēliem)

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:57

Mēs soli pa solim paskaidrosim, kā jūs varat izveidot savu ukuleli un pievienot dažus efektus, kas padarīs to unikālu, piemēram, uzzīmējot kaut ko tādu, ko vēlamies uz ukuleles virsmas, vai pievienojot dažus gaismas efektus.

Lai to izdarītu, ir nepieciešams iegādāties ukuleles komplektu.

Mēs izskaidrosim, kā salikt instrumentu, un atrisināsim dažādas problēmas, kas varētu rasties.

1. solis: materiāli

Struktūras materiāli:

DIY ukelele montāžas komplekts (tas varētu būt cits komplekts), ko veido:

1- Ķermenis.

2-kakla.

3-segli

4 virvju atbalsts

5-tilts

6 stīgu uzgrieznis.

7-fiksācijas gredzens mašīnas galvai (x4).

8 mašīnu galvas (x4).

Mašīnu galvu stiprinājuma skrūves (x8).

Mašīnas tilta stiprinājuma skrūves (x2).

11-vāciņi tilta stiprinājuma skrūvēm (x2).

12 stīgas (x4).

Elektroniskie materiāli:

• NANO Arduino.
• LED ritenis WS2812.
• Akselerometrs BMA220 (pēc izvēles).
• Akumulatora savienotājs.
• Akumulators 9V.
• Slēdzis.

Citi

• Koka laka.
• Velcro.
• Lodēšanas alva.
• Aizsargplastika lakošanai.
• Karstā kausējuma silikons.

Rīki:

• Lāzergravēšana.
• Smilšpapīrs
• Zvaigžņu skrūvgriezis.
• Otas.
• Karstās kausēšanas lielgabals.
• Alvas lodāmurs.

2. darbība: pielāgojiet Ukulele

Lai kostīmētu mūsu ukuleli, mēs varētu izgatavot zīmējuma gravējumu ar lāzera griezēju uz ķermeņa. Gadījumā, ja mums nebūtu šī rīka, mēs to varētu krāsot.

Mūsu izvēlētais attēls ir pirmais, kas parādās.

Pirmkārt, mums ir jāizstrādā zīmējuma veidne, lai izveidotu gravējumu.

Lai to paveiktu, mēs izmantosim programmatūru “Inkscape”, kuru mēs varētu iegūt, izmantojot šo saiti:

Lai to izmantotu, mums ir jāpielāgo attēls, kuru vēlamies izmantot, kā parādīts otrajā attēlā. Varētu izskatīties, ka mēs esam pagriezuši sākotnējo attēlu, lai varētu noregulēt rokas ciklu ar instrumenta apli. Kā mēs jau teicām iepriekš, jūs varat ievietot jebkuru attēlu.

3. darbība: attēla vektorizācija, izmantojot Inkscape

Mēs redzēsim, kā izveidot vektoru failu no pikseļu kartes (jpg, png, neatkarīgi no rastra formāta, ko var atvērt Inkscape).

Inkscape Inkscape ir atvērtā koda vektorgrafikas redaktors, un, kā norāda nosaukums, šis ir rīks, ko izmantošu logotipu vektorizēšanai. Vektorizācijas soļi Šie soļi ir kopīgi jebkurai vektorizācijai, ko mēs varētu vēlēties darīt.

1. Atveriet attēlu programmā Inkscape
2. Atveriet Trace Bitmap Tool Path-> Trace Bitmap
3. Izspēlējiet izsekošanas bitu kartes opcijas
4. Palaidiet izsekošanu
5. Notīriet rezultātus (ja nepieciešams)

Ņemiet vērā daļu “spēlēšanās”. Es neesmu izsekošanas eksperts, tāpēc es uzskatu, ka šis rīks ir melna kaste ar pogām un gaismām, griežot un mainot, līdz tiek sasniegts labākais rezultāts

4. solis: logotipa gravēšana

Šim nolūkam ir svarīgi, lai būtu virsmas siluets, uz kura tiks izgatavots zīmējuma gravējums.

Lai izveidotu gravējumu, mēs izmantosim programmatūru “T2Laser”. Mēs varētu iegūt šo programmatūru no:

Pēc programmatūras atvēršanas mums ir jāielādē attēls, ko esam izveidojuši pēdējā solī. Pēc tam nospiediet pogu "vadības lāzers" un parādās cnc vadīklas. Abi attēli parāda gravēšanas procesu un rezultātu ar mūsu lāzera griezēju.

5. solis: slīpēšana un lakošana

Lai mūsu ukulele paliktu gaiša un ar slāni bez raupjuma, mēs varam uzmanīgi noslīpēt abas mūsu instrumenta daļas, jo mēs varam sabojāt izveidoto zīmējumu (ja esat izvēlējies krāsot ukuleli, jums tas jādara) vispirms noslīpējiet). Tad mēs lakojam abas mūsu daļas, lai tās iegūtu tumšāku krāsu un koks būtu izturīgāks. Mēs varam izmantot parasto koka laku, tai nav jābūt īpašai.

Kad mums ir laka, mēs to sajaucam ar nedaudz šķīdinātāja, lai tas nedaudz izšķīst. Tālāk mēs ar suku uzklājam maisījumu uz kakla un instrumenta korpusa un ļaujam nožūt.

Ja redzam, ka produktam nepieciešama otra kārta, abas daļas varam nedaudz noslīpēt un no jauna uzklāt atšķaidītas lakas kārtu.

** PIESARDZĪBAS PASĀKUMI: laka ir ķīmisks produkts, tādēļ ir nepieciešams veikt šo procesu vēdināmā vietā, valkāt masku, lai izvairītos no smaku ieelpošanas un aizsargbrillēm.

Materiāli, kas mums nepieciešami, lai spētu pareizi strādāt, ir tie, kas redzami fotoattēlos. Galvenokārt mēs strādāsim ar suku, lakas kārbu (mūsu gadījumā sarkanā krāsā), nelielu šķīdinātāju un vizuālu aizsardzību. Un galvenokārt strādājiet labi vēdināmās telpās.

6. darbība: aparatūra

Mūsu plāksne ar Arduino, acelerometru un riteni ar gaismas diodēm tiks ieviesta nelielā kronšteinā, lai izvairītos no tā, ka visas sastāvdaļas pārvietojas instrumentā.

Mēs esam pievienojuši arī akumulatora turētāju un slēdzi, lai padarītu to ērtāku, un neizmantojam akumulatoru, kad neizmantojam instrumentu. Mēs pievienosim šo atbalstu ar Velcro gabalu (tas darbotos arī ar silikonu un karsta kausējuma pistoli) pie ukuleles korpusa iekšējās virsmas. No otras puses, LED ritenis ir mazāks par caurumu, tāpēc tas nokristu. Atbalsts ir izstrādāts tā, lai tas labi turētos un varētu pildīt savu funkciju.

7. solis: programmatūra

Lai piešķirtu īpašu apdari mūsu ukulelei, mēs varētu pievienot gaismas efektus, pateicoties LED ritenim. Mēs izmantosim WS2812, bet jūs varat izmantot jebkuru citu, ievērojot datu lapas norādījumus. Mēs izmantosim arī acelerometru (BMA220), kas ļauj mums ietekmēt gravitāciju.

Patiesībā mums būs 4 gaismas lugas, kas iekļautas Arduino datora bibliotēkā ar nosaukumu “Adafruit”. Lai to izdarītu, mums ir jāizveido pareiza saikne starp trim komponentiem: Arduino NANO, WS2812 un BMA220, kā parādīts pirmajā attēlā.

Sarkanie vadi ir paredzēti strāvas padevei, GND melnie un pārējie ir nepieciešamie savienojumi pareizai darbībai. Kods, ko izmantojām gaismas komplektam, ir pievienots failam ar nosaukumu "play_of_light_v0.ino". Pārliecinieties, vai esat iekļāvis nepieciešamās bibliotēkas programmas pareizai darbībai. Akumulatoram, ko mēs pievienojam ārējai ķēdei, jābūt vismaz 9 V spriegumam, un mums ir jānodrošina, ka tas spēj nodrošināt minimālo strāvu, kas nepieciešama visas ķēdes barošanai.

// Variables contador e interrupciónint counter; // Mainīgie Ejemplo gravedad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

baitu versija [3];

int8_t x_data; int8_t y_data; int8_t z_data; baitu diapazons = 0x00; pludiņš divi = 16; pludiņš x, y, z; pludiņš pi = 3,14159265359; pludiņš nx, ny, leņķis; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Mainīgie Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parametrs 1 = pikseļu skaits joslā // Parametrs 2 = Arduino pin numurs (lielākā daļa ir derīgi) // Parametrs 3 = pikseļu tipa karodziņi, pēc vajadzības pievienojiet: // NEO_KHZ800 800 KHz bitu plūsma (lielākā daļa NeoPixel produktu ar WS2812 gaismas diodēm) // NEO_KHZ400 400 KHz (klasiskais “v1” (ne v2) FLORA pikseļi, WS2811 draiveri) // NEO_GRB pikseļi ir savienoti ar GRB bitu plūsmu (lielākā daļa NeoPixel produktu)/ / NEO_RGB Pikseļi ir pieslēgti RGB bitu plūsmai (v1 FLORA pikseļi, nevis v2) // NEO_RGBW Pikseļi ir pieslēgti RGBW bitu plūsmai (NeoPixel RGBW produkti) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_K) // SVARĪGI: Lai samazinātu NeoPixel izdegšanas risku, pievienojiet 1000 uF kondensatoru // pikseļu barošanas vadiem, pievienojiet 300 - 500 Ohm rezistoru pirmā pikseli datu ievadē // un samaziniet attālumu starp Arduino un pirmo pikseli. Izvairieties no savienojuma // uz strāvas ķēdes… ja jums tas ir nepieciešams, vispirms pievienojiet GND.

// Mainīgie Rueda de colores

// NeoPixel Ring vienkāršā skice (c) 2013 Shae Erisson // izdota saskaņā ar GPLv3 licenci, lai atbilstu pārējai AdaFruit NeoPixel bibliotēkai

#iekļaut

#ifdef _AVR_ #include #endif

// Kura Arduino tapa ir savienota ar NeoPixels?

// Krekļlietā vai Gemmā mēs iesakām to mainīt uz 1 #define PIN 9

// Cik NeoPikseļu ir pievienoti Arduino?

#define NUMPIXELS 16

// Iestatot NeoPixel bibliotēku, mēs sakām, cik pikseļu un kuru tapu izmantot signālu nosūtīšanai.

// Ņemiet vērā, ka vecākām NeoPixel sloksnēm jums, iespējams, būs jāmaina trešais parametrs-lai iegūtu plašāku informāciju par iespējamām vērtībām, skatiet piemēru strandtest //. Adafruit_NeoPixel pikseļi = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // kavēšanās par 50 ms

// Variables colores aleatorios

#include #ifdef _AVR_ #include #endif

#definējiet PIN 9

#define NUM_LEDS 16

#definējiet BRIGHTNESS 200

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

baits 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); Sērijas sākums (9600); Wire.begin (); Wire.beginTransmission (0x0A); // akselerometra adrese // diapazona iestatījumi Wire.write (0x22); // reģistrēt adresi Wire.write (diapazons); // var iestatīt uz "0x00" "0x01" "0x02" "0x03", skatiet Datashhet on wiki // zemas caurlaides filtrs Wire.write (0x20); // reģistrēt adresi Wire.write (0x05); // var iestatīt uz "0x05" "0x04" …… "0x01" "0x00", skatiet Datashhet vietnē wiki Wire.endTransmission ();

// Codigo; Luces Arcoiris

// Tas attiecas uz Trinket 5V 16MHz, jūs varat noņemt šīs trīs līnijas, ja neizmantojat piekariņu #if definēts (_AVR_ATtiny85_), ja (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Pieklājības īpašā koda sloksnes beigas.begin (); strip.show (); // Inicializēt visus pikseļus, lai tie būtu izslēgti

// Código Rueda de colores

// Tas attiecas uz Trinket 5V 16MHz, jūs varat noņemt šīs trīs līnijas, ja neizmantojat piekariņu #if definēts (_AVR_ATtiny85_), ja (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Pieklājības īpašā koda beigas

pikseļi.sākas (); // Tas inicializē NeoPixel bibliotēku.

// Codigo Interrupcion

skaitītājs = 1;

// Codigo Colores varios

// Tas attiecas uz Trinket 5V 16MHz, jūs varat noņemt šīs trīs līnijas, ja neizmantojat piekariņu #if definēts (_AVR_ATtiny85_), ja (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // Pieklājības īpašā koda sloksnes beigas.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Inicializēt visus pikseļus uz “izslēgts”}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; ja (skaitītājs == 1) {par (int i = 0; i 0,0) {ja (nx 0,0) leņķis+= 180; cits leņķis += 360; } // beigas else if (leņķis == 360,0) leņķis = 0,0; vadīja = apļveida (leņķis / (360 / NUMBER_OF_LEDS_ON_RING)); http cits led = apļveida (iepriekšējaisLed - 1); ledQueue.push (vadīja); makeLightShow (); previousLed = vadīja; kavēšanās (25); } skaitītājs = 2; } // Beigt, ja skaitītājs == 1 // Caso 2: Codigo del juego de luces del arcoiris else if (counter == 2) {for (int j = 0; j <5; j ++) {// Daži procedūru piemēri kā attēlot pikseļos: colorWipe1 (strip. Color (255, 0, 0), 50); // Sarkanā krāsaWipe1 (sloksne. Krāsa (0, 255, 0), 50); // Zaļā krāsaWipe1 (sloksne. Krāsa (0, 0, 255), 50); // Zilā krāsaWipe1 (sloksne. Krāsa (0, 0, 0, 255), 50); // Balts RGBW // Nosūtīt teātra pikseļu meklēšanu… TheaterChase (strip. Color (127, 127, 127), 50); // Baltais teātrisChase (sloksne. Krāsa (127, 0, 0), 50); // Sarkanais teātrisChase (sloksne. Krāsa (0, 0, 127), 50); // Zils

varavīksne (5);

varavīksnes cikls (5); teātrisChaseRainbow (5); } skaitītājs = 3; } // Beigas, ja skaitītājs == 2 // Caso 3: Luces Aleatorias else if (skaitītājs == 3) {par (int k = 0; k <50; k ++) {// NeoPikseļu kopai pirmais NeoPikselis ir 0, otrais ir 1, līdz pat pikseļu skaitam mīnus viens. int a = nejaušs (255); int b = nejaušs (255); int c = nejaušs (255); par (int i = 0; i

// pikseļi. Krāsa ņem RGB vērtības no 0, 0, 0 līdz 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Mēreni spilgti zaļa krāsa.

pikseļi.parādīt (); // Tādējādi aparatūrai tiek nosūtīta atjauninātā pikseļu krāsa.

kavēšanās (kavēšanās); // Kavēšanās uz noteiktu laiku (milisekundēs).

} a = nejaušs (255); b = nejaušs (255); c = nejaušs (255); par (int i = NUMPIXELS; i> 0; i-) {

// pikseļi. Krāsa ņem RGB vērtības no 0, 0, 0 līdz 255, 255, 255

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Mēreni spilgti zaļa krāsa.

pikseļi.parādīt (); // Tādējādi aparatūrai tiek nosūtīta atjauninātā pikseļu krāsa.

kavēšanās (kavēšanās); // Kavēšanās uz noteiktu laiku (milisekundēs).

}} skaitītājs = 4; } cits if (skaitītājs == 4) {par (int g = 0; g <= 6; g ++) {// Daži piemēri procedūrām, kas parāda, kā attēlot pikseļus: colorWipe (strip. Color (255, 0, 0), 50); // Red colorWipe (sloksne. Krāsa (0, 255, 0), 50); // Zaļā krāsaWipe (sloksne. Krāsa (0, 0, 255), 50); // Zilā krāsaWipe (sloksne. Krāsa (0, 0, 0, 255), 50); // Balts baltsVaravīksne (20, 75, 5); pulseWhite (5); // fullWhite (); // kavēšanās (2000); rainbowFade2White (3, 3, 1);

}

skaitītājs = 1; }} ////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////- ////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // akselerometra adrese // atiestatīt akselerometru Wire.write (0x04); // X dati Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // pieprasīt 6 baitus no vergu ierīces #2, kamēr (Wire.available ()) // vergs var nosūtīt mazāk, nekā pieprasīts {Versija [0] = Wire.read (); // saņemt baitu kā rakstzīmi} x_data = (int8_t) Versija [0] >> 2; Wire.beginTransmission (0x0A); // akselerometra adrese // atiestatīt akselerometru Wire.write (0x06); // Y dati Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // pieprasīt 6 baitus no vergu ierīces #2, kamēr (Wire.available ()) // vergs var nosūtīt mazāk, nekā pieprasīts {Versija [1] = Wire.read (); // saņemt baitu kā rakstzīmi} y_data = (int8_t) Versija [1] >> 2; Wire.beginTransmission (0x0A); // akselerometra adrese // atiestatīt akselerometru Wire.write (0x08); // Z dati Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // pieprasīt 6 baitus no vergu ierīces #2, kamēr (Wire.available ()) // vergs var nosūtīt mazāk nekā pieprasīts {Version [2] = Wire.read (); // saņemt baitu kā rakstzīmi} z_data = (int8_t) Versija [2] >> 2; x = (pludiņš) x_data/divi; y = (peldēt) y_data/divi; z = (pludiņš) z_data/divi; Sērijas nospiedums ("X ="); Sērijas nospiedums (x); // izdrukāt rakstzīmi Serial.print (""); Sērijas nospiedums ("Y ="); Sērijas nospiedums (y); // izdrukāt rakstzīmi Serial.print (""); Sērijas nospiedums ("Z ="); // izdrukā rakstzīmi Serial.println (z); }

int cirkulārs (int pos) {

if (pos> = NUMBER_OF_LEDS_ON_RING) atgriezties (pos - NUMBER_OF_LEDS_ON_RING); cits if (pos <0) return (pos + NUMBER_OF_LEDS_ON_RING); cits atgriezties (poz); }

int attālums;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; ja (attālums <0) attālums += NUMBER_OF_LEDS_ON_RING; atgriešanās (attālums); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

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

// Aizpildiet punktus vienu pēc otra ar krāsu tukšu krāsu Noslaukiet (uint32_t c, uint8_t gaidiet) {for (uint16_t i = 0; i

tukša varavīksne (pagaidiet) {{

uint16_t i, j;

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

// Nedaudz atšķirīgi, tāpēc varavīksne ir vienmērīgi sadalīta visā

void rainbowCycle (uint8_t gaidīt) {uint16_t i, j;

(j = 0; j <256*5; j ++) {// 5 visu krāsu riteņi uz riteņa (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); aizkavēties (gaidīt); }}

// Teātra stila rāpojošās gaismas.

void TheaterChase (uint32_t c, uint8_t gaidīt) {par (int j = 0; j <10; j ++) {// veic 10 vajāšanas ciklus (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // ieslēgt katru trešo pikseļu} strip.show ();

aizkavēties (gaidīt);

par (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // izslēdziet katru trešo pikseļu}}}}

// Teātra stila rāpojošas gaismas ar varavīksnes efektu

void theatreChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// ciklā visas 256 krāsas ritenī (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, Ritenis ((i+j) % 255)); // ieslēgt katru trešo pikseļu} strip.show ();

aizkavēties (gaidīt);

par (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // izslēdziet katru trešo pikseļu}}}}

// Ievadiet vērtību no 0 līdz 255, lai iegūtu krāsas vērtību.

// Krāsas ir pāreja r - g - b - atpakaļ uz r. uint32_t Ritenis (baits WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } ja (WheelPos <170) {WheelPos -= 85; atgriešanas sloksne. Krāsa (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; atgriešanas sloksne. Krāsa (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 (0) // ja (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

// Aizpildiet punktus vienu pēc otra ar krāsu

void colorWipe1 (uint32_t c, uint8_t gaidīt) {par (uint16_t i = 0; i

void pulseWhite (gaidīt uint8_t) {

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

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

par (uint16_t i = 0; i

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

pludiņš fadeMax = 100,0; int fadeVal = 0; uint32_t wheelVal; int redVal, greenVal, blueVal;

par (int k = 0; k <rainbowLoops; k ++) {par (int j = 0; j <256; j ++) {// 5 visu riteņu krāsu cikli

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

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

redVal = sarkans (wheelVal) * pludiņš (fadeVal/fadeMax);

greenVal = zaļš (wheelVal) * pludiņš (fadeVal/fadeMax); blueVal = zils (wheelVal) * pludiņš (fadeVal/fadeMax);

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

}

// Pirmā cilpa, izgaist!

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

// Pēdējā cilpa, izgaist!

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

strip.show ();

aizkavēties (gaidīt); }}

kavēšanās (500);

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

par (int j = 0; j <256; j ++) {

par (uint16_t i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, strip. Color (0, 0, 0, neopix_gamma [j])); } strip.show (); }

kavēšanās (2000);

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

par (uint16_t i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, strip. Color (0, 0, 0, neopix_gamma [j])); } strip.show (); }}

kavēšanās (500);

}

void whiteOverRainbow (uint8_t jāgaida, uint8_t whiteSpeed, uint8_t whiteLength) {

ja (balts garums> = sloksne.numPikseli ()) balts garums = sloksne.numPikseli () - 1;

int galva = balta Garums - 1;

int asti = 0;

int cilpas = 3;

int cilpaNum = 0;

static unsigned long lastTime = 0;

kamēr (taisnība) {

par (int j = 0; j <256; j ++) {par (uint16_t i = 0; i = asti && i galva && i> = asti) || (aste> galva && i <= galva)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } else {strip.setPixelColor (i, Ritenis ((((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

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

if (loopNum == cilpas) atgriežas;

galva%= sloksne.numPikseļi (); aste%= sloksne.numPikseļi (); strip.show (); aizkavēties (gaidīt); }}} void fullWhite () {for (uint16_t i = 0; i

// Nedaudz atšķirīgi, tāpēc varavīksne ir vienmērīgi sadalīta visā

void rainbowCycle1 (uint8_t gaidīt) {uint16_t i, j;

(j = 0; j <256 * 5; j ++) {// 5 visu krāsu riteņi uz riteņa (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); aizkavēties (gaidīt); }}

void rainbow1 (gaidīt) {{

uint16_t i, j;

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

// Ievadiet vērtību no 0 līdz 255, lai iegūtu krāsas vērtību.

// Krāsas ir pāreja r - g - b - atpakaļ uz r. uint32_t Wheel1 (baits WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } ja (WheelPos <170) {WheelPos -= 85; atgriešanas sloksne. Krāsa (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; atgriešanas sloksne. Krāsa (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t sarkans (uint32_t c) {

atgriešanās (c >> 16); } uint8_t zaļš (uint32_t c) {return (c >> 8); } uint8_t blue (uint32_t c) {return (c); }

8. solis: 3D dizains

Pirmkārt, jums ir jāizmēra aparatūras komponenti, lai pārliecinātos par pareizību. Ja tie ir tādi paši kā mūsējie, varat izmantot tos pašus failus, kurus mēs jums aizdodam.

Abi balsti ir izstrādāti ar 3D printeri, kas ir iekļauti arī kā:

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

Visbeidzot, gaisma būs tāda pati kā pēdējās divas bildes.

9. solis: kakla uzstādīšana

Vispirms mēs novietojam seglu uz kakla. Caurumi, kas nepieciešami skrūvēm, lai to noturētu, nav tur, tāpēc mums tie būs jāizveido, atzīmējot, kur tiem jāiet, un uzmanīgi, ar gliemežvāku, izveidojot caurumu.

Tas pats attiecas uz caurumiem, kur skrūves, kas pašu kaklu notur pie instrumenta korpusa. Tas nav jādara, jo šim stiprinājumam nav skrūvju, bet, ja mēs to vēlamies, nebūtu problēmu.

SVARĪGI: atstājiet 5 mm atstarpi starp masta sākumu un kamertona sākumu, jo šajā caurumā tiks ievietots uzgrieznis.

Mēs pielīmēsim uzgriezni ar līmi attēlā norādītajā virzienā.

Visbeidzot, mēs ieviesīsim 4 tapas caurumos, kas atrodas masta sākumā, turot katru tapu ar 2 īsām skrūvēm, kā parādīts attēlā.

10. solis: Birdge montāža

Tiltu nostiprina, pielīmējot, un ar divām garajām skrūvēm korpusa centrālajā stāvoklī. Ieteicams ar zīmuli atzīmēt pareizo ķermeņa stāvokli. Mēs veiksim attālumus, kas atzīmēti attēlā.

Mēs uzklāsim līmi abu sastāvdaļu savienojumā. Mēs rūpīgi nostiprinām abas daļas ar pievilkšanas skrūvi, līdz savienojums ir izžuvis. Mēs izgatavosim divus caurumus skrūvēm ar 1,5 mm urbi kokam. Nostipriniet tiltu ar divām garām skrūvēm korpusā. Un visbeidzot, mēs uzliekam aizsargvāciņus uz skrūvju galvām.

11. solis: ķermeņa un kakla montāža

Lai saliktu abas detaļas, ķermeņa galvā ir caurumi, kur kakls iederēsies ar diviem izvirzījumiem. Mēs varam tos pielīmēt ar līmi vai ar karstās kausēšanas pistoli. Lai iegūtu lielāku fiksāciju, varat izveidot caurumus, kas atrodas kamertona beigās, lai to pievienotu ķermenim.

12. solis: ielieciet Ukuleles stīgas

Visbeidzot, mums ir jānovieto stīgas tā, lai mūsu instruments būtu pabeigts.

Iepriekš mēs ievietojām tapu fiksējošos gredzenus to izvirzījumos, kas iet caur mastu. Lai novietotu stīgas, mēs paņēmām 4 virknes, kas bija komplektā. Vispirms jums ir jānošķir katra virkne, jo tās visas nav vienādas. Jums ir jāpiesaista katras auklas viens gals (divi biezi ar parastu mezglu un divi plāni ar dubultu) un jāievieto auklas tilta spraugās.

Tad mēs izvietojam virknes tā, lai:

• Pirmā pozīcija: G virkne (otrā biezākā virkne).

• Otrā pozīcija: C virkne (biezāka virkne).

• Trešā pozīcija: E virkne (otrā plānākā virkne).

• Ceturtā pozīcija: virkne (plānāka virkne).

Ievelciet auklas komplektā iekļautā kontaktdakšas caurumos. Mēģiniet salabot katru virvi, divas vai trīs reizes pagriežot tapu. Sasprindziniet auklas, nepieliekot pārāk lielu spēku, un pārbaudiet attālumu starp stīgām un seglu.

Ja jums ir šaubas par to, kā to izdarīt, varat izlasīt šo pamācību, kas paskaidro, kā pareizi ievietot virknes.

13. darbība: pārbaude

Visbeidzot, mums jāpārbauda, vai ukulele ir pareizi salikta tā, lai ideālais attālums pirmajā fretā būtu 0,1 mm, bet divpadsmitajā - aptuveni 1,2 mm.

Ir nepieciešams, lai jūs noregulētu ukuleles stīgas. Es iesaku jums šo lietotni: GuitarTuna

14. solis: izbaudiet to

Tagad jums tikai jāizbauda sava ukulele.

Ja vēlaties uzzināt vairāk par mums, varat mūs atrast:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Interneta adrese: Innovart.cc