DIY intelligens elektronikus ukulele Arduino -val: 14 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:42

Lépésről lépésre elmagyarázzuk, hogyan tervezheti meg saját ukulelét, és adhat hozzá néhány effektust, amelyek egyedivé teszik, például rajzoljon valamit, amit akarunk az ukulele felületére, vagy adjon hozzá néhány fényeffektust.

Ehhez ukulele készletet kell vásárolni.

Elmagyarázzuk, hogyan kell összeszerelni a műszert, és megoldjuk a különböző problémákat.

1. lépés: Anyagok

Szerkezeti anyagok:

DIY ukelele rögzítő készlet (lehet egy másik készlet), amelyet a következők alkotnak:

1- Test.

2-nyakú.

3-Nyereg

4 kötél támogatás

5-híd

6-húros anya.

7-rögzítőgyűrű a gépfejhez (x4).

8-gép fejek (x4).

9-szerelőcsavarok a gépfejekhez (x8).

10-szerelőcsavarok géphídhoz (x2).

11-fedősapka hídrögzítő csavarokhoz (x2).

12 húros (x4).

Elektronikus anyagok:

• NANO Arduino.
• Led kereke WS2812.
• Gyorsulásmérő BMA220 (opcionális).
• Akkumulátor csatlakozó.
• Akkumulátor 9V.
• Kapcsoló.

Mások

• Fa lakk.
• Tépőzár.
• Forrasztó konzervdoboz.
• Védő műanyag a lakkozáshoz.
• Forró olvadék szilikon.

Eszközök:

• Lézergravírozás.
• Csiszolópapír
• Csillag csavarhúzó.
• Ecset.
• Forró olvadék pisztoly.
• Ón forrasztópáka.

2. lépés: Testreszabhatja az Ukulele -t

Az ukulele öltöztetéséhez készíthetünk egy rajzot egy lézervágóval a testre. Abban az esetben, ha nincs ilyen eszközünk, festhetjük.

A választott kép az első, ami megjelenik.

Először is meg kell terveznünk a rajz sablont a metszet elkészítéséhez.

Ennek végrehajtásához az „Inkscape” nevű szoftvert fogjuk használni, amelyet a következő linkről szerezhet be:

Használatához be kell állítanunk a használni kívánt képet, ahogyan azt a második képen mutatjuk. Úgy tűnhet, hogy elforgattuk a kezdeti képet, hogy beállíthassuk a kéz ciklusát a műszer körével. Mint korábban már említettük, bármilyen képet elhelyezhet.

3. lépés: Vektorizálja a képet az Inkscape segítségével

Meglátjuk, hogyan lehet vektorfájlt létrehozni egy pixmap -ből (jpg, png, bármilyen raszteres formátumban is megnyitható az Inkscape).

Inkscape Az Inkscape egy nyílt forráskódú vektorgrafikus szerkesztő, és ahogy a cím is sugallja, ezt az eszközt fogom használni a logók vektorizálásához. Vektorizálási lépések A lépések közösek minden vektorizáláshoz, amelyet esetleg meg akarunk tenni.

1. Nyissa meg a képet az Inkscape -ben
2. Nyissa meg a Trace Bitmap Tool Path-> Trace Bitmap elemet
3. Játsszon a Bitkövetés nyomkövetési lehetőségeivel
4. Futtassa a nyomkövetést
5. Tisztítsa meg az eredményeket (ha szükséges)

Vegye figyelembe a „körüljátszás” részt. Nem vagyok szakértője a nyomkövetésnek, ezért ezt az eszközt fekete dobozként kezelem, gombokkal és fényekkel, csavarva és cserélve, amíg a legjobb eredményt nem kapom

4. lépés: Logó gravírozás

Ehhez fontos, hogy legyen egy sziluettje annak a felületnek, amelyen a rajz gravírozását készítik.

A gravírozáshoz a „T2Laser” szoftvert fogjuk használni. Ezt a szoftvert a következő címen szerezhetjük be:

Miután megnyitottuk a szoftvert, be kell töltenünk az utolsó lépésben létrehozott képet. Ezután nyomja meg a "vezérlő lézer" gombot, és megjelenik a cnc vezérlők. A két kép a lézervágónkkal végzett gravírozás folyamatát és eredményét mutatja be.

5. lépés: Csiszolás és lakkozás

Ahhoz, hogy az ukulelét fényes és érdesség nélküli réteggel hagyjuk, gondosan csiszolhatjuk a műszerünket alkotó két részt, mert károsíthatjuk az elkészült rajzot (ha úgy döntött, hogy az ukulelét szeretné festeni, akkor először csiszolja le). Ezután lakkozni fogjuk két részünket, hogy sötétebb színt kapjanak, és a fa nagyobb ellenállást tanúsítson. Használhatunk normál falakkot, nem kell különlegesnek lennie.

Ha megvan a lakk, kevés oldószerrel összekeverjük, hogy kicsit feloldódjon. Ezután ecsettel vigyük fel a keveréket a műszer nyakára és testére, és hagyjuk megszáradni.

Ha azt látjuk, hogy a terméknek második rétegre van szüksége, akkor a két részt kissé lecsiszolhatjuk, és újra felvihetünk egy réteg hígított lakkot.

** ÓVINTÉZKEDÉSEK: A lakk vegyi termék, ezért ezt az eljárást szellőző helyen kell elvégezni, viseljen maszkot, hogy elkerülje a szagok és a védőszemüveg belélegzését.

A megfelelő munkához szükséges anyagok azok, amelyek a fényképeken láthatók. Főként ecsettel, lakkdobozzal (esetünkben piros színnel), kevés oldószerrel és vizuális védelemmel dolgozunk. És mindenekelőtt jól szellőző helyen dolgozzon.

6. lépés: Hardver

Táblát az Arduino -val, az acelerométert és a LED -es kereket egy kis zárójelben fogjuk bevezetni, hogy elkerüljük, hogy minden alkatrész elmozduljon a műszerben.

Hozzáadtunk egy elemtartót és egy kapcsolót is, hogy kényelmesebb legyen, és nem kopunk le az elemről, amikor nem használjuk a műszert. Ezt a támaszt egy tépőzárral (szilikon és forró olvadó pisztoly esetén is működtetjük) rögzítjük az ukulele test belső felületéhez. Másrészt a LED -kerék kisebb, mint a lyuk, ezért leesne. A támaszt úgy tervezték, hogy jól tartsa és elláthassa funkcióját.

7. lépés: Szoftver

Ahhoz, hogy különleges díszítést nyújtsunk ukulelénknek, fényeffektusokat adhatunk hozzá egy LED -keréknek köszönhetően. A WS2812 -et fogjuk használni, de az adatlap utasításait követve bármi mást is használhat. Acelerométert (BMA220) is használunk, amely lehetővé teszi számunkra a gravitáció hatását.

Valójában 4 fényjátékunk lesz az Arduino „Adafruit” nevű számítógépes könyvtárában. Ehhez meg kell adnunk a megfelelő összefüggést a három összetevő között: Arduino NANO, WS2812 és BMA220, mint az első képen.

A piros vezetékek a tápellátást szolgálják, a GND feketék és a többi szükséges csatlakozás a helyes működéshez. A fénykészlethez használt kód a "play_of_light_v0.ino" nevű fájlban található. Győződjön meg róla, hogy tartalmazza a program megfelelő működéséhez szükséges könyvtárakat. Az akkumulátornak, amelyet az áramkörön kívül adunk hozzá, legalább 9 V feszültséggel kell rendelkeznie, és gondoskodnunk kell arról, hogy képes legyen a minimális áramot biztosítani az egész áramkör ellátásához.

// Változók contador e interrupciónint counter; // Változók Ejemplo gravedad #include #include #include #define NUMBER_OF_LEDS_ON_RING 16 #define NEOPIXEL_RING_DATA_PIN 9

bájtos verzió [3];

int8_t x_data; int8_t y_data; int8_t z_data; bájttartomány = 0x00; float divi = 16; úszó x, y, z; float pi = 3,14159265359; úszó nx, ny, szög; int led, previousLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel (NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

// Változók Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Paraméter 1 = a szalagban lévő képpontok száma // Paraméter 2 = Arduino pin száma (a legtöbb érvényes) // Paraméter 3 = képpont típusú jelzők, szükség szerint adja hozzá: // NEO_KHZ800 800 KHz bitfolyam (a legtöbb NeoPixel termék WS2812 LED -ekkel) // NEO_KHZ400 400 KHz (klasszikus "v1" (nem v2) FLORA képpontok, WS2811 illesztőprogramok) // NEO_GRB Pixelek vezetékesek a GRB bitfolyamhoz (a legtöbb NeoPixel termék)/ / NEO_RGB A pixelek RGB bitfolyamhoz vannak kötve (v1 FLORA pixel, nem v2) // NEO_RGBW A pixelek RGBW bitfolyamhoz vannak kötve (NeoPixel RGBW termékek) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_K) // FONTOS: A NeoPixel kiégésének kockázatának csökkentése érdekében adjon hozzá 1000 uF kondenzátort // pixel tápvezetékekhez, adjon hozzá 300 - 500 Ohm ellenállást az első pixel adatbeviteléhez // és minimalizálja az Arduino és az első pixel közötti távolságot. Kerülje a csatlakoztatást // élő áramkörre… ha szükséges, először csatlakoztassa a GND -t.

// Változók Rueda de colores

// NeoPixel Ring egyszerű vázlat (c) 2013 Shae Erisson // megjelent a GPLv3 licenc alapján, hogy megfeleljen az AdaFruit NeoPixel könyvtár többi részének

#befoglalni

#ifdef _AVR_ #include #endif

// Az Arduino melyik csapja csatlakozik a NeoPixelshez?

// Egy csecsebecse vagy Gemma esetén javasoljuk, hogy módosítsa ezt 1 #define PIN 9 -re

// Hány NeoPixel kapcsolódik az Arduino -hoz?

#define NUMPIXELS 16

// Amikor beállítjuk a NeoPixel könyvtárat, megmondjuk, hogy hány képpont és melyik tűt használjuk jelek küldésére.

// Ne feledje, hogy a régebbi NeoPixel csíkok esetében előfordulhat, hogy módosítania kell a harmadik paramétert-a lehetséges értékekről további információt a strandtest // példában talál. Adafruit_NeoPixel pixelek = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // 50 ms késleltetés

// Variables colores aleatorios

#include #ifdef _AVR_ #include #endif

#define PIN 9

#define NUM_LEDS 16

#define FÉNYESSÉG 200

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

bájt 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); Sorozat.kezdet (9600); Wire.begin (); Wire.beginTransmission (0x0A); // a gyorsulásmérő címe // tartomány beállítások Wire.write (0x22); // regisztrációs cím Wire.write (tartomány); // beállítható "0x00" "0x01" "0x02" "0x03" -ra, lásd Datashhet on wiki // aluláteresztő szűrő Wire.write (0x20); // regisztrációs cím Wire.write (0x05); // beállítható "0x05" "0x04" …… "0x01" "0x00", lásd Datashhet a wiki -n Wire.endTransmission ();

Codigo; Luces Arcoiris

// Ez a Trinket 5V 16MHz -re vonatkozik, eltávolíthatja ezt a három sort, ha nem használ Trinket #if meghatározott (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // A csecsebecse speciális kódszalag vége.begin (); strip.show (); // Inicializálja az összes képpontot "kikapcsolt" állapotba

// Código Rueda de colores

// Ez a Trinket 5V 16MHz -re vonatkozik, eltávolíthatja ezt a három sort, ha nem használ Trinket #if meghatározott (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // A csecsebecse speciális kódjának vége

pixels.begin (); // Ezzel inicializálja a NeoPixel könyvtárat.

Codigo megszakítás

számláló = 1;

Codigo Colores varios

// Ez a Trinket 5V 16MHz -re vonatkozik, eltávolíthatja ezt a három sort, ha nem használ Trinket #if meghatározott (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // A csecsebecse speciális kódszalag vége.setBrightness (BRIGHTNESS); strip.begin (); strip.show (); // Inicializálja az összes képpontot "kikapcsolt" értékre}

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

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

/Bucle infinito

void loop () {// Caso 1: Juego de luces de la gravedad; if (counter == 1) {for (int i = 0; i 0.0) {if (nx 0.0) szög+= 180; más szög += 360; } // vége egyébként if (szög == 360,0) szög = 0,0; led = körkörös (szög / (360 / NUMBER_OF_LEDS_ON_RING)); // a led mozgását simává tegye, ha (előzőLed == led) {// nincs mit tenni} egyéb if (counterClockwiseDistanceBetweenLeds (előzőLed, led) <= 8) led = körkörös (előzőLed + 1); else led = körkörös (előzőLed - 1); ledQueue.push (led); makeLightShow (); előzőLed = led; késleltetés (25); } számláló = 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 ++) {// Néhány példamutató eljárás hogyan kell megjeleníteni a pixeleknek: colorWipe1 (strip. Color (255, 0, 0), 50); // Piros szín Törlés1 (csík. Szín (0, 255, 0), 50); // Zöld szín Törlés1 (csík. Szín (0, 0, 255), 50); // Kék szín Törlés1 (csík. Szín (0, 0, 0, 255), 50); // Fehér RGBW // Színházi pixel üldözés küldése… TheaterChase (strip. Color (127, 127, 127), 50); // Fehér színházChase (strip. Color (127, 0, 0), 50); // Vörös színházChase (strip. Color (0, 0, 127), 50); // Kék

szivárvány (5);

szivárványCiklus (5); színházChaseRainbow (5); } számláló = 3; } // End if counter == 2 // Caso 3: Luces Aleatorias else if (counter == 3) {for (int k = 0; k <50; k ++) {// NeoPixelek halmazánál az első NeoPixel 0, a második 1, egészen a képpontok számáig mínusz egy. int a = véletlenszerű (255); int b = véletlenszerű (255); int c = véletlenszerű (255); mert (int i = 0; i

// pixel. A szín RGB értékeket vesz fel, 0, 0, 0 és 255, 255, 255 között

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Mérsékelten élénkzöld színű.

pixels.show (); // Ez elküldi a frissített pixelszínt a hardvernek.

késleltetés (késleltetés); // Késleltetés egy bizonyos ideig (ezredmásodpercben).

} a = véletlenszerű (255); b = véletlenszerű (255); c = véletlenszerű (255); for (int i = NUMPIXELS; i> 0; i-) {

// pixel. A szín RGB értékeket vesz fel, 0, 0, 0 és 255, 255, 255 között

pixels.setPixelColor (i, pixels. Color (a, b, c)); // Mérsékelten élénkzöld színű.

pixels.show (); // Ez elküldi a frissített pixelszínt a hardvernek.

késleltetés (késleltetés); // Késleltetés egy bizonyos ideig (ezredmásodpercben).

}} számláló = 4; } else if (számláló == 4) {for (int g = 0; g <= 6; g ++) {// Néhány példa a képpontokhoz való megjelenítésről: colorWipe (strip. Color (255, 0, 0), 50); // Red colorWipe (strip. Color (0, 255, 0), 50); // Zöld szín Törlés (csík. Szín (0, 0, 255), 50); // Kék színWipe (strip. Color (0, 0, 0, 255), 50); // Fehér fehérOverRainbow (20, 75, 5); pulseWhite (5); // fullWhite (); // delay (2000); rainbowFade2White (3, 3, 1);

}

számláló = 1; }} //////////////////////////////////////////////////////////////// //////////////////////////////////////////////- //////////////////////////////////////////////////////////////////////////////////// //////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit () {Wire.beginTransmission (0x0A); // a gyorsulásmérő címe // a gyorsulásmérő alaphelyzetbe állítása Wire.write (0x04); // X adatok Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // kérjen 6 bájtot a 2. számú szolga eszköztől, míg a (Wire.available ()) // a slave kevesebbet küldhet a kértnél {Version [0] = Wire.read (); // bájt fogadása karakterként} x_adata = (int8_t) Verzió [0] >> 2; Wire.beginTransmission (0x0A); // a gyorsulásmérő címe // a gyorsulásmérő alaphelyzetbe állítása Wire.write (0x06); // Y adatok Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // kérjen 6 bájtot a 2. számú szolga eszköztől, míg a (Wire.available ()) // a slave kevesebbet küldhet a kértnél {Version [1] = Wire.read (); // bájt fogadása karakterként} y_data = (int8_t) Verzió [1] >> 2; Wire.beginTransmission (0x0A); // a gyorsulásmérő címe // a gyorsulásmérő alaphelyzetbe állítása Wire.write (0x08); // Z adatok Wire.endTransmission (); Wire.requestFrom (0x0A, 1); // kérjen 6 bájtot a 2. számú szolga eszköztől, míg a (Wire.available ()) // a slave kevesebbet küldhet a kértnél {Version [2] = Wire.read (); // bájt fogadása karakterként} z_data = (int8_t) Verzió [2] >> 2; x = (lebeg) x_adata/divi; y = (lebeg) y_adata/divi; z = (lebeg) z_data/divi; Soros.nyomtatás ("X ="); Sorozatnyomat (x); // a Serial.print karakter nyomtatása (""); Soros.nyomtatás ("Y ="); Soros.nyomat (y); // a Serial.print karakter nyomtatása (""); Soros.nyomtatás ("Z ="); // a karakter nyomtatása Serial.println (z); }

int körkörös (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 távolság;

int counterClockwiseDistanceBetweenLeds (int prevPos, int nextPos) {distance = nextPos - prevPos; if (távolság <0) távolság += NUMBER_OF_LEDS_ON_RING; visszatérés (távolság); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int brightnessStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow () {

for (int j = 0; j <NUMBER_OF_LEDS_ON_RING; j ++) neoring.setPixelColor (j, 0, 0, 0); currentQueueSize = ledQueue.count (); for (int k = 0; k <currentQueueSize; k ++) {ledPosition = ledQueue.pop (); neoring.setPixelColor (ledPosition, 0, (brightnessStep * k), 0); if ((k == 0 && currentQueueSize 0) ledQueue.push (ledPosition);} neoring.show ();}

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

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

/Metodos del juego de luces del arcoiris

// Töltse ki a pontokat egymás után egy színes üres színnelWipe (uint32_t c, uint8_t wait) {for (uint16_t i = 0; i

void rainbow (uint8_t wait) {

uint16_t i, j;

(j = 0; j <256; j ++) {esetén (i = 0; i

// Kicsit más, ezért a szivárvány egyenletesen oszlik el az egészben

void rainbowCycle (uint8_t várjon) {uint16_t i, j;

for (j = 0; j <256*5; j ++) {// 5 ciklus minden színben a keréken (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); késleltetés (várakozás); }}

// Színházi stílusú mászó fények.

void TheaterChase (uint32_t c, uint8_t wait) {for (int j = 0; j <10; j ++) {// végezzen 10 üldözési ciklust (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, c); // minden harmadik pixel bekapcsolása} strip.show ();

késleltetés (várakozás);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // minden harmadik képpont kikapcsolása}}}}

// Színházi stílusú kúszófények szivárványos hatással

void theatreChaseRainbow (uint8_t wait) {for (int j = 0; j <256; j ++) {// a kerék összes 256 színének ciklusa (int q = 0; q <3; q ++) {for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, Kerék ((i+j) % 255)); // minden harmadik pixel bekapcsolása} strip.show ();

késleltetés (várakozás);

for (uint16_t i = 0; i <strip.numPixels (); i = i+3) {strip.setPixelColor (i+q, 0); // minden harmadik képpont kikapcsolása}}}}

// Adjon meg egy 0 és 255 közötti értéket, hogy színértéket kapjon.

// A színek átmenet r - g - b - vissza r. uint32_t Kerék (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3); } if (WheelPos <170) {WheelPos -= 85; visszatérő csík. Szín (0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 170; visszatérő csík. Szín (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 // 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öltse fel a pontokat egymás után egy színnel

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

void pulseWhite (uint8_t wait) {

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

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

for (uint16_t i = 0; i

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

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

for (int k = 0; k <rainbowLoops; k ++) {for (int j = 0; j <256; j ++) {// 5 ciklus minden színben a keréken

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

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

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

greenVal = zöld (wheelVal) * float (fadeVal/fadeMax); blueVal = kék (wheelVal) * float (fadeVal/fadeMax);

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

}

// Első hurok, halványulj be!

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

// Utolsó ciklus, halványulj!

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

strip.show ();

késleltetés (várakozás); }}

késleltetés (500);

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

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

késleltetés (2000);

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

késleltetés (500);

}

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

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

int fej = fehérHosszúság - 1;

int far = 0;

int hurkok = 3;

int loopNum = 0;

static unsigned long lastTime = 0;

míg (igaz) {

for (int j = 0; j <256; j ++) {for (uint16_t i = 0; i = farok && i fej && i> = farok) || (farok> fej && i <= fej)) {strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); } else {strip.setPixelColor (i, Kerék ((((i * 256 / strip.numPixels ()) + j) & 255)); }}

if (millis () - lastTime> whiteSpeed) {

fej ++; farok ++; if (head == strip.numPixels ()) {loopNum ++; } lastTime = millis (); }

if (loopNum == ciklus) return;

head%= strip.numPixels (); farok%= csík.szám Pixelek (); strip.show (); késleltetés (várakozás); }}} void fullWhite () {for (uint16_t i = 0; i

// Kicsit más, ezért a szivárvány egyenletesen oszlik el az egészben

void rainbowCycle1 (uint8_t várjon) {uint16_t i, j;

for (j = 0; j <256 * 5; j ++) {// 5 színciklus a keréken (i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } strip.show (); késleltetés (várakozás); }}

void rainbow1 (uint8_t wait) {

uint16_t i, j;

(j = 0; j <256; j ++) {esetén (i = 0; i

// Adjon meg egy 0 és 255 közötti értéket, hogy színértéket kapjon.

// A színek átmenet r - g - b - vissza r. uint32_t Kerék1 (byte WheelPos) {WheelPos = 255 - WheelPos; if (WheelPos <85) {return strip. Color (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) {WheelPos -= 85; visszatérő csík. Szín (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; visszatérő csík. Szín (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t piros (uint32_t c) {

visszatérés (c >> 16); } uint8_t zöld (uint32_t c) {return (c >> 8); } uint8_t blue (uint32_t c) {return (c); }

8. lépés: 3D tervezés

Először is meg kell határoznia a hardverkomponensek méretét, hogy biztos lehessen a helyességben. Ha ugyanazok, mint a miénk, akkor ugyanazokat a fájlokat használhatja, amelyeket kölcsönadunk.

Mindkét támaszt 3D nyomtatóval tervezték, amelyek a következők is:

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

Végül a fény olyan lesz, mint a két utolsó kép.

9. lépés: A nyak felszerelése

Először a nyerget helyezzük a nyakra. A csavarok rögzítéséhez szükséges lyukak nincsenek meg, ezért ezeket meg kell jelölnünk, és meg kell jelölnünk, hová kell menniük, és óvatosan, csigával, elkészítve a lyukat.

Ugyanez vonatkozik a lyukakra is, ahol a csavarok, amelyek a nyakot a műszer testéhez tartják. Ezeket nem szükséges elvégezni, mivel ehhez a rögzítéshez nincsenek csavarok, de ha meg akarjuk csinálni, nem lenne probléma.

FONTOS: hagyjon 5 mm -es helyet az árboc eleje és a hangvilla eleje között, mert ebbe a lyukba kerül az anya.

Az anyát ragasztóval ragasztjuk, az ábra szerinti irányban.

Végül bevezetjük a 4 csapot az árboc elején lévő lyukakba, tartva mindegyik csapot 2 rövid csavarral, amint az az ábrán látható.

10. lépés: A Birdge felszerelése

A hidat ragasztással rögzítik, és a két hosszú csavarral a test középső helyzetében. Célszerű ceruzával megjelölni a test helyes helyzetét. Megtesszük a képen megjelölt távolságokat.

A két komponens egyesülésénél ragasztót alkalmazunk. A két részt óvatosan rögzítjük egy csavar segítségével, amíg a kötés megszárad. A két lyukat a csavarokhoz 1,5 mm -es fúróval fához készítjük. Rögzítse a hidat a test két hosszú csavarjával. Végül tegyük a védősapkákat a csavarok fejére.

11. lépés: Test és nyak összeszerelése

A két rész összeszereléséhez lyukak vannak a test fejében, ahol a nyak illeszkedik két kiálló részével. Ragaszthatjuk ragasztóval vagy forró olvadék pisztollyal. A nagyobb rögzítés érdekében elkészítheti a hangvilla végén található lyukakat, hogy a testhez csatlakozzon.

12. lépés: Tegye fel az Ukulele karakterláncokat

Végül úgy kell elhelyezni a húrokat, hogy a hangszerünk kész legyen.

Korábban a csapok rögzítőgyűrűit illesztjük az árbocon átmenő nyúlványokba. A húrok elhelyezéséhez vettük a készlethez tartozó 4 húrt. Először meg kell különböztetni az egyes karakterláncokat, mert nem mindegyik. Minden húr egyik végét be kell kötni (a két vastag, normál csomóval, a két vékony pedig egy dupla csomóval), és be kell illeszteni a húrokat a híd réseibe.

Ezután a húrokat úgy helyezzük el, hogy:

• Első pozíció: G karakterlánc (második legvastagabb karakterlánc).

• Második pozíció: C karakterlánc (vastagabb húr).

• Harmadik pozíció: E karakterlánc (második vékonyabb húr).

• Negyedik pozíció: Egy húr (vékonyabb karakterlánc).

Fűzze be a húrokat a mellékelt dugó lyukaiba. Próbáljon minden kötelet rögzíteni úgy, hogy két vagy három fordulatot tesz a csapon. Feszítse meg a húrokat túl nagy erő alkalmazása nélkül, és ellenőrizze a húrok és a nyereg közötti távolságot.

Ha kétségei vannak a készítés módjával kapcsolatban, olvassa el azt az oktatóanyagot, amely elmagyarázza, hogyan kell helyesen elhelyezni a karakterláncokat.

13. lépés: Tesztelés

Végül meg kell vizsgálnunk, hogy az ukulele -t megfelelően összeszereltük -e úgy, hogy az ideális távolság az első freten 0,1 mm, a tizenkettedik pedig körülbelül 1,2 mm.

Szükség van az ukulele karakterláncok hangolására. Ajánlom ezt az alkalmazást: GuitarTuna

14. lépés: Élvezze

Most már csak élvezni kell az ukulelét.

Ha többet szeretne tudni rólunk, akkor itt találhat minket:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Weboldal: Innovart.cc