DIY Inteligentne elektroniczne ukulele z Arduino: 14 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:31

Wyjaśnimy krok po kroku, jak zaprojektować własne ukulele i dodać kilka efektów, które sprawią, że będzie wyjątkowy, na przykład narysowanie czegoś, co chcemy na powierzchni ukulele lub dodanie efektów świetlnych.

Aby to zrobić, należy zakupić zestaw ukulele.

Wyjaśnimy, jak złożyć instrument i rozwiązać różne problemy, które mogą się pojawić.

Krok 1: Materiały

Materiały konstrukcyjne:

Zestaw do samodzielnego montażu ukelele (może to być inny zestaw) utworzony przez:

1- Ciało.

2-szyjkowy.

3-siodło

Wsparcie na 4 liny

5-Most

Nakrętka 6-strunowa.

7-pierścień mocujący do głowicy maszyny (x4).

8 głowic maszynowych (x4).

9-śruby mocujące do głowic maszynowych (x8).

10 śrub montażowych do mostka maszynowego (x2).

11-Zaślepki na śruby montażowe mostu (x2).

12-strunowy (x4).

Materiały elektroniczne:

• NANO Arduino.
• Koło diod WS2812.
• Akcelerometr BMA220 (opcja).
• Złącze akumulatora.
• Bateria 9V.
• Przełącznik.

Inni

• Lakier do drewna.
• Rzep.
• Cyna lutownicza.
• Plastik ochronny do lakierowania.
• Silikon topliwy.

Narzędzia:

• Grawerowanie laserowe.
• Papier ścierny
• Śrubokręt gwiazdowy.
• Pędzel.
• Pistolet topliwy.
• Lutownica cynowa.

Krok 2: Dostosuj Ukulele

Aby skomponować nasze ukulele, mogliśmy wykonać grawerowanie rysunku wycinarką laserową na ciele. W przypadku braku tego narzędzia możemy je pomalować.

Obraz, który wybraliśmy jest pierwszym, który się pojawia.

Przede wszystkim musimy zaprojektować szablon rysunkowy do wykonania graweru.

W tym celu użyjemy oprogramowania o nazwie „Inkscape”, które możemy uzyskać pod tym linkiem:

Aby z niego skorzystać, musimy dostosować obraz, którego chcemy użyć, tak jak pokazujemy na drugim obrazie. Można by pomyśleć, że obróciliśmy obraz początkowy, aby można było dopasować koło dłoni do koła instrumentu. Jak powiedzieliśmy wcześniej, możesz umieścić dowolny obraz.

Krok 3: Wektoryzacja obrazu za pomocą Inkscape

Zobaczymy, jak utworzyć plik wektorowy z mapy pikseli (jpg, png, dowolny format rastrowy, który Inkscape może otworzyć).

Inkscape Inkscape to edytor grafiki wektorowej typu open source i, jak sugeruje tytuł, jest to narzędzie, którego użyję do wektoryzacji logo. Etapy wektoryzacji Etapy są wspólne dla każdej wektoryzacji, którą możemy chcieć wykonać.

1. Otwórz obraz w Inkscape
2. Otwórz Ścieżka narzędzia śledzenia bitmapy->Śledź bitmapę
3. Pobaw się z opcjami Trace Bitmap
4. Uruchom śledzenie
5. Wyczyść wyniki (jeśli to konieczne)

Zwróć uwagę na część „zabawy”. Nie jestem ekspertem w śledzeniu, więc traktuję to narzędzie jak czarną skrzynkę z pokrętłami i światłami, przekręcając i zmieniając aż do uzyskania najlepszego wyniku

Krok 4: Grawerowanie logo

W tym celu ważne jest posiadanie sylwetki powierzchni, na której zostanie wykonany grawerunek rysunku.

Do wykonania graweru użyjemy oprogramowania „T2Laser”. Możemy uzyskać to oprogramowanie ze strony:

Po otwarciu oprogramowania musimy załadować obraz, który stworzyliśmy w ostatnim kroku. Następnie naciśnij przycisk "sterowanie laserem" i pojawi się kontrolka cnc. Dwa zdjęcia przedstawiają proces i wynik grawerowania za pomocą naszej wycinarki laserowej.

Krok 5: Szlifowanie i lakierowanie

Aby nasze ukulele pozostało jasne i pozbawione chropowatości, możemy gładko przeszlifować dwie części, z których składa się nasz instrument, ponieważ możemy uszkodzić wykonany rysunek (jeśli zdecydowałeś się na pomalowanie ukulele, musiałbyś najpierw przeszlifuj). Następnie pomalujemy nasze dwie części, aby uzyskały ciemniejszy kolor, a drewno miało większą odporność. Możemy użyć zwykłego lakieru do drewna, nie musi być on wyjątkowy.

Gdy już mamy lakier, mieszamy go z niewielką ilością rozpuszczalnika, aby trochę się rozpuścił. Następnie mieszankę nakładamy pędzelkiem na szyjkę i korpus instrumentu i pozostawiamy do wyschnięcia.

Jeśli zauważymy, że produkt wymaga drugiej warstwy, możemy delikatnie przeszlifować obie części i ponownie nałożyć warstwę rozcieńczonego lakieru.

** ŚRODKI OSTROŻNOŚCI: Lakier jest produktem chemicznym, dlatego konieczne jest wykonanie tego procesu w przewiewnym miejscu, założenie maski, aby uniknąć wdychania zapachów oraz okularów ochronnych.

Materiały, których potrzebujemy do poprawnej pracy, to te, które pojawiają się na zdjęciach. Głównie będziemy pracować przy pomocy pędzla, puszki po lakierze (w naszym przypadku koloru czerwonego), odrobiny rozpuszczalnika i ochrony wizualnej. A przede wszystkim pracować w dobrze wentylowanych pomieszczeniach.

Krok 6: Sprzęt

Nasza tabliczka z Arduino, akcelerometrem i kołem z diodami LED zostanie umieszczona w małym wsporniku, aby uniknąć poruszania się wszystkich elementów w instrumencie.

Dodaliśmy również uchwyt baterii i przełącznik, aby był wygodniejszy i nie zużywamy baterii, gdy nie korzystamy z instrumentu. Tę podporę przymocujemy kawałkiem rzepa (działałby również z silikonem i pistoletem do kleju topliwego) do wewnętrznej powierzchni korpusu ukulele. Z drugiej strony koło LED jest mniejsze niż otwór, więc wypada. Podpórka została zaprojektowana tak, aby dobrze trzymała się i mogła pełnić swoją funkcję.

Krok 7: Oprogramowanie

Aby nadać wyjątkowej ozdobie naszemu ukulele, mogliśmy dodać efekty świetlne dzięki kole diod led. Zamierzamy użyć WS2812, ale możesz użyć dowolnego innego, postępując zgodnie z instrukcjami zawartymi w arkuszu danych. Skorzystamy również z akcelerometru (BMA220), który pozwoli nam wykorzystać efekt grawitacji.

W rzeczywistości będziemy mieli 4 gry światła zawarte w komputerowej bibliotece Arduino o nazwie 'Adafruit'. W tym celu musimy dokonać poprawnego połączenia trzech komponentów: Arduino NANO, WS2812 i BMA220, jak widać na pierwszym obrazku.

Czerwone przewody służą do zasilania, GND czarne a reszta to niezbędne połączenia do poprawnego działania. Kod, który użyliśmy do zestawu oświetleniowego jest załączony w pliku o nazwie "play_of_light_v0.ino". Upewnij się, że załączyłeś niezbędne biblioteki do poprawnego działania programu. Bateria, którą dodajemy na zewnątrz obwodu, musi mieć minimalne napięcie 9V i musimy się upewnić, że jest w stanie dostarczyć minimalny prąd niezbędny do zasilenia całego obwodu.

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

Wersja bajtowa [3];

int8_t x_data; int8_t y_data; int8_t z_data; zakres bajtów=0x00; pływak divi=16; zmiennoprzecinkowe x, y, z; liczba pi = 3,14159265359; float nx, ny, kąt; int led, poprzednia dioda; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel(NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

//Zmienne Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parametr 1 = liczba pikseli w pasku // Parametr 2 = numer pinu Arduino (większość jest prawidłowa) // Parametr 3 = flagi typu piksela, dodaj je w razie potrzeby: // NEO_KHZ800 800 KHz bitstream (większość produktów NeoPixel z diodami LED WS2812) // NEO_KHZ400 400 KHz (klasyczne piksele „v1” (nie v2) FLORA, sterowniki WS2811) // NEO_GRB Piksele są podłączone do strumienia bitów GRB (większość produktów NeoPixel) / / NEO_RGB Piksele są okablowane dla strumienia bitowego RGB (piksele v1 FLORA, nie v2) // NEO_RGBW Piksele są okablowane dla strumienia bitowego RGBW (produkty NeoPixel RGBW) Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, PIN, NEO_GRB + NEO_KHZ800); // WAŻNE: Aby zmniejszyć ryzyko przepalenia NeoPixel, dodaj kondensator 1000 uF do przewodów zasilających // pikseli, dodaj rezystor 300 - 500 Ohm na wejściu danych pierwszego piksela // i zminimalizuj odległość między Arduino a pierwszym pikselem. Unikaj podłączania // do obwodu pod napięciem…jeśli musisz, najpierw podłącz GND.

//Zmienne Rueda de colores

// Prosty szkic NeoPixel Ring (c) 2013 Shae Erisson // wydany na licencji GPLv3, aby pasował do reszty biblioteki AdaFruit NeoPixel

#włączać

#ifdef _AVR_ #include #endif

// Który pin w Arduino jest podłączony do NeoPixels?

// Na Trinket lub Gemma sugerujemy zmianę na 1 #define PIN 9

// Ile NeoPixeli jest podłączonych do Arduino?

#define NUMPIXELS 16

// Kiedy konfigurujemy bibliotekę NeoPixel, mówimy jej, ile pikseli i którego pinu użyć do wysyłania sygnałów.

// Zauważ, że w przypadku starszych pasków NeoPixel może być konieczna zmiana trzeciego parametru - zobacz przykład strandtest //, aby uzyskać więcej informacji o możliwych wartościach. Adafruit_NeoPixel piksele = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int opóźnienie = 50; // opóźnienie o 50ms

//Zmienne kolory aleatorios

#include #ifdef _AVR_ #include #endif

#zdefiniuj PIN 9

#definiuj NUM_LEDS 16

#define JASNOŚĆ 200

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

bajt 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 }; /////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////

/KONFIGURACJA METODO

void setup() { //Código: Kierunek grobu neoring.begin(); neoring.setJasność(200); Serial.początek(9600); Wire.początek(); Wire.beginTransmission (0x0A); // adres akcelerometru // ustawienia zakresu Wire.write(0x22); //rejestruj adres Wire.write(range); //można ustawić na"0x00""0x01""0x02""0x03", patrz Datashhet na wiki // filtr dolnoprzepustowy Wire.write(0x20); //rejestruj adres Wire.write(0x05); //można ustawić na "0x05""0x04"……"0x01""0x00", patrz Datashhet na wiki Wire.endTransmission();

//Codigo; Luces Arcoiris

// To jest dla Trinket 5V 16MHz, możesz usunąć te trzy linie, jeśli nie używasz Trinket #if zdefiniowany (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Koniec specjalnego kodu drobiazgowego strip.begin(); strip.pokaż(); // Zainicjuj wszystkie piksele na „wyłączone”

//Código Rueda de colores

// To jest dla Trinket 5V 16MHz, możesz usunąć te trzy linie, jeśli nie używasz Trinket #if zdefiniowany (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Koniec specjalnego kodu drobiazgu

piksele.początek(); // Inicjuje bibliotekę NeoPixel.

//Przerwanie Codigo

licznik = 1;

//Codigo Colores różne

// To jest dla Trinket 5V 16MHz, możesz usunąć te trzy linie, jeśli nie używasz Trinket #if zdefiniowany (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Koniec specjalnego kodu drobiazgowego strip.setBrightness(BRIGHTNESS); strip.początek(); strip.pokaż(); // Zainicjuj wszystkie piksele na „wyłączone” }

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

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

/Bucle infinito

void loop() { //Caso 1: Juego de luces de la gravedad; if(licznik == 1){ for(int i=0;i 0,0){ if(nx 0,0) kąt+=180; w przeciwnym razie kąt += 360; }//koniec else if(angle == 360,0) angle = 0.0; led = cykliczne (kąt / (360 / NUMBER_OF_LEDS_ON_RING)); // spraw, aby ruch diody był płynny if(previousLed == led){ // nic do zrobienia } else if (counterClockwiseDistanceBetweenLeds(previousLed, led) <= 8) led = circularize(previousLed + 1); w przeciwnym razie led = cykliczne(poprzedniaLed - 1); ledQueue.push(led); makeLightShow(); poprzednia dioda = dioda; opóźnienie(25); } licznik = 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++){ // Kilka przykładowych procedur pokazujących jak wyświetlić do pikseli: colorWipe1(strip. Color(255, 0, 0), 50); // Czerwony colorWipe1(strip. Color(0, 255, 0), 50); // Zielony colorWipe1(strip. Color(0, 0, 255), 50); // Niebieski colorWipe1(strip. Color(0, 0, 0, 255), 50); // Biały RGBW // Wyślij chase pikseli teatralnych w… theaterChase(strip. Color(127, 127, 127), 50); // Biały teatrChase(strip. Color(127, 0, 0), 50); // Czerwony teatrChase(strip. Color(0, 0, 127), 50); // Niebieski

tęcza(5);

cykl tęczy(5); teatr ChaseTęcza(5); } licznik = 3; }//End if counter==2 //Caso 3: Luces Aleatorias else if(counter == 3){ for(int k=0;k<50;k++){ // Dla zestawu NeoPixels pierwszy NeoPixel jest 0, sekunda to 1, aż do liczby pikseli minus jeden. int a=losowy(255); int b=losowy(255); int c=losowy(255); for(int i=0;i

// piksele. Kolor przyjmuje wartości RGB, od 0, 0, 0 do 255, 255, 255

piksele.setPixelColor(i, piksele. Color(a, b, c)); // Umiarkowanie jasny zielony kolor.

piksele.pokaż(); // Wysyła zaktualizowany kolor piksela do sprzętu.

opóźnienie(opóźnienie); // Opóźnienie na pewien okres czasu (w milisekundach).

} a=losowy(255); b=losowy(255); c=losowy(255); for(int i=NUMPIKSELS;i>0;i--){

// piksele. Kolor przyjmuje wartości RGB, od 0, 0, 0 do 255, 255, 255

piksele.setPixelColor(i, piksele. Color(a, b, c)); // Umiarkowanie jasny zielony kolor.

piksele.pokaż(); // Wysyła zaktualizowany kolor piksela do sprzętu.

opóźnienie(opóźnienie); // Opóźnienie na pewien okres czasu (w milisekundach).

} } licznik = 4; } else if(counter == 4){ for(int g=0;g<=6;g++){ // Kilka przykładowych procedur pokazujących, jak wyświetlać na pikselach: colorWipe(strip. Color(255, 0, 0), 50); // Czerwony colorWipe(strip. Color(0, 255, 0), 50); // Zielony colorWipe(strip. Color(0, 0, 255), 50); // Niebieski colorWipe(strip. Color(0, 0, 0, 255), 50); // Biały białyOverRainbow(20, 75, 5); pulsBiały(5); // pełna biel(); // opóźnienie(2000); rainbowFade2White(3, 3, 1);

}

licznik = 1; } } /////////////////////////////////////////////// ////////////////////////////////// ////////////// //////////////////////////////////////////////// /////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit() { Wire.beginTransmission(0x0A); // adres akcelerometru // resetowanie akcelerometru Wire.write(0x04); // X dane Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // żądanie 6 bajtów od urządzenia podrzędnego nr 2 while(Wire.available()) // urządzenie podrzędne może wysłać mniej niż żądano { Version[0] = Wire.read(); // odbierz bajt jako characte } x_data=(int8_t)Version[0]>>2; Wire.beginTransmission (0x0A); // adres akcelerometru // resetowanie akcelerometru Wire.write(0x06); // dane Y Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // żądanie 6 bajtów od urządzenia podrzędnego #2 while(Wire.available()) // urządzenie podrzędne może wysłać mniej niż żądano { Version[1] = Wire.read(); // odbierz bajt jako znak } y_data=(int8_t)Version[1]>>2; Wire.beginTransmission (0x0A); // adres akcelerometru // resetowanie akcelerometru Wire.write(0x08); // Z dane Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // żądanie 6 bajtów od urządzenia podrzędnego #2 while(Wire.available()) // urządzenie podrzędne może wysłać mniej niż żądano { Wersja[2] = Wire.read(); // odbierz bajt jako characte } z_data=(int8_t)Version[2]>>2; x=(zmiennoprzecinkowa)x_data/divi; y=(zmiennoprzecinkowa)y_data/divi; z=(zmiennoprzecinkowa)z_dane/podział; Serial.print("X="); Serial.print(x); // drukuj znak Serial.print(" "); Serial.print("Y="); Serial.print(y); // drukuj znak Serial.print(" "); Serial.print("Z="); // drukuj znak Serial.println(z); }

int cykliczne (pozycja int){

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); w przeciwnym razie powrót (poz); }

odległość międzymiastowa;

int counterClockwiseDistanceBetweenLeds(int prevPos, int nextPos){ distance = nextPos - prevPos; if(odległość < 0) odległość += NUMBER_OF_LEDS_ON_RING; powrót (odległość); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int jasnośćStep = 255/NUMBER_OF_LEDS_TO_SHINE;

void makeLightShow(){

for(int j = 0; j < LICZBA_LED_PIERŚCIENIA; j++) neoring.setPixelColor(j, 0, 0, 0); obecnyRozmiarKolejki = ledKolejka.liczba(); for(int k = 0; k < bieżącyRozmiarKolejki; k++){ pozycja led = ledQueue.pop(); neoring.setPixelColor(ledPosition, 0, (krok jasności * k), 0); if((k == 0 && currentQueueSize 0) ledQueue.push(ledPosition); } neoring.show(); }

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

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

/Metodos del juego de luces del arcoiris

// Wypełnij kropki jedna po drugiej kolorem void colorWipe(uint32_t c, uint8_t wait) { for(uint16_t i=0; i

void rainbow(uint8_t czekaj) {

uint16_ti, j;

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

// Nieco inaczej, dzięki temu tęcza jest równomiernie rozłożona

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

for(j=0; j<256*5; j++) { // 5 cykli wszystkich kolorów na kole for(i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) i 255)); } strip.show(); opóźnienie (czekaj); } }

//Lampki w stylu teatralnym.

void teatrChase(uint32_t c, uint8_t czekaj) { for (int j=0; j<10; j++) { //zrób 10 cykli pogoni za (int q=0; q < 3; q++) { for (uint16_t i= 0;i < strip.numPixels();i=i+3) { strip.setPixelColor(i+q, c); //włącz co trzeci piksel na } strip.show();

opóźnienie (czekaj);

for (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); //wyłącz co trzeci piksel } } } }

//pełzające światła w stylu teatralnym z efektem tęczy

void theaterChaseRainbow(uint8_t wait) { for (int j=0; j < 256; j++) { // cykl wszystkich 256 kolorów w kole for (int q=0; q < 3; q++) { for (uint16_t i=0;i < strip.numPixels();i=i+3) { strip.setPixelColor(i+q, Wheel((i+j) % 255)); //włącz co trzeci piksel na } strip.show();

opóźnienie (czekaj);

for (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); //wyłącz co trzeci piksel } } } }

// Wprowadź wartość od 0 do 255, aby uzyskać wartość koloru.

// Kolory są przejściem r - g - b - z powrotem do r. uint32_t Wheel(byte WheelPos) { WheelPos = 255 - WheelPos; if(WheelPos < 85) { return strip. Color(255 - WheelPos * 3, 0, WheelPos * 3); } if(PozycjaKół < 170) { PozycjaKół -= 85; powrotna listwa. Kolor(0, Pozycja koła * 3, 255 - Pozycja koła * 3); } Pozycja koła -= 170; return strip. Color(WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/Metodos Rueda de colores

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

//CylonEyeColor=HtmlColor(elegirColor); //int elegirColor = random(1, 7);//Podemos elegir aleatoriamente entre los 7 colores que hay debajo0xf0ffff // if(elegirColor == 1) CylonEyeColor=HtmlColor(0xff0000);//Rojo // if(elegirColor == 2) CylonEyeColor=HtmlColor(0x00ff00);//Verde // if(elegirColor == 3) CylonEyeColor=HtmlColor(0x0000ff);//Azul // if(elegirColor == 4) CylonEyeColor=HtmlColor(0xffff00);//Amarillo // if(elegirColor == 5) CylonEyeColor=HtmlColor(0x200020);//Morado // if(elegirColor == 6) CylonEyeColor=HtmlColor(0x00ffff);//Azul Claro // if(elegirColor == 7) CylonEyeColor= HtmlColor(0x100010);//Rosa //CylonEyeColor=HtmlColor(0x000000);

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

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

/Metodos luces varias

// Wypełnij kropki jedna po drugiej kolorem

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

void pulseWhite (uint8_t wait) {

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

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

for(uint16_t i=0; i

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

zanikanie zmiennoprzecinkoweMax = 100,0; int zanikVal = 0; uint32_t wheelVal; int redVal, greenVal, blueVal;

for(int k = 0; k < rainbowLoops; k ++){ for(int j=0; j<256; j++) { // 5 cykli wszystkich kolorów na kole

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

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

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

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

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

}

//Pierwsza pętla, pojawianie się!

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

//Ostatnia pętla, zanikaj!

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

strip.pokaż();

opóźnienie (czekaj); } }

opóźnienie (500);

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

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

opóźnienie (2000);

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

opóźnienie (500);

}

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

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

int głowa = białyDługość - 1;

int ogon = 0;

pętle int = 3;

int liczba pętli = 0;

static unsigned long lastTime = 0;

podczas (prawda){

for(int j=0; j<256; j++) { for(uint16_t i=0; i= ogon && i głowa && i >= ogon) || (ogon > głowa && i <= głowa)){ strip.setPixelColor(i, strip. Color(0, 0, 0, 255)); } else{ strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); } }

if(millis() - lastTime > whiteSpeed) {

głowa++; ogon++; if(head == strip.numPixels()){ loopNum++; } ostatni czas = mili(); }

if(loopNum == pętle) return;

head%=strip.numPixels(); ogon%=strip.numPixels(); strip.pokaż(); opóźnienie (czekaj); } } } void fullWhite() { for(uint16_t i=0; i

// Nieco inaczej, dzięki temu tęcza jest równomiernie rozłożona

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

for(j=0; j<256 * 5; j++) { // 5 cykli wszystkich kolorów na kole for(i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) i 255)); } strip.show(); opóźnienie (czekaj); } }

void rainbow1(uint8_t czekaj) {

uint16_ti, j;

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

// Wprowadź wartość od 0 do 255, aby uzyskać wartość koloru.

// Kolory są przejściem r - g - b - z powrotem do r. uint32_t Wheel1(byte WheelPos) { WheelPos = 255 - WheelPos; if(WheelPos < 85) { return strip. Color(255 - WheelPos * 3, 0, WheelPos * 3, 0); } if(PozycjaKół < 170) { PozycjaKół -= 85; return strip. Color(0, Poz.koła * 3, 255 - Poz.koła * 3, 0); } Pozycja koła -= 170; return strip. Color(WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t czerwony(uint32_t c) {

powrót (c >> 16); } uint8_t green(uint32_t c) { return (c >> 8); } uint8_t blue(uint32_t c) { return (c); }

Krok 8: Projektowanie 3D

Najpierw musisz zwymiarować komponenty sprzętowe, aby mieć pewność, że są prawidłowe. Jeśli są takie same jak nasze, możesz użyć tych samych plików, które Ci pożyczyliśmy.

Obie podpory zostały zaprojektowane za pomocą drukarki 3D, w zestawie znajdują się również:

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

Wreszcie światło będzie jak na dwóch ostatnich zdjęciach.

Krok 9: Montaż szyi

Najpierw założymy siodło na szyję. Otwory, które potrzebne są śrubom, nie są tam, więc będziemy musieli je zrobić, zaznaczając, gdzie powinny iść i ostrożnie, świdrem, robiąc otwór.

To samo dotyczy otworów, w których śruby mocujące samą szyjkę do korpusu instrumentu. Nie trzeba ich robić, ponieważ nie ma śrub do tego mocowania, ale jeśli będziemy chcieli to zrobić, nie byłoby problemu.

WAŻNE: zostaw 5mm odstępu pomiędzy początkiem masztu a początkiem kamertonu, ponieważ w tym otworze zostanie umieszczona nakrętka.

Przykleimy nakrętkę klejem, w kierunku wskazanym na rysunku.

Na koniec wprowadzimy 4 kołki w otworach znajdujących się na początku masztu, przytrzymując każdy kołek 2 krótkimi śrubami, jak pokazano na obrazku.

Krok 10: Montaż Birdge

Most jest mocowany przez klejenie i dwie długie śruby w centralnej pozycji na korpusie. Wskazane jest zaznaczenie ołówkiem prawidłowej pozycji w ciele. Weźmiemy odległości zaznaczone na obrazku.

Klej nałożymy na połączenie dwóch składników. Obie części starannie mocujemy za pomocą śruby mocującej, aż złącze wyschnie. Dwa otwory na wkręty wykonamy wiertłem do drewna 1,5mm. Zamocuj most za pomocą dwóch długich śrub w korpusie. I na koniec nakładamy zaślepki ochronne na łby śrub.

Krok 11: Montaż korpusu i szyi

Aby zmontować dwie części, mamy otwory w główce korpusu, gdzie szyja zmieści się z dwoma występami, które ma. Możemy je skleić klejem lub pistoletem termotopliwym. Aby uzyskać większe mocowanie, możesz zrobić otwory, które znajdują się na końcu kamertonu, aby połączyć go z ciałem.

Krok 12: Umieść struny ukulele

Na koniec musimy ułożyć struny, aby nasz instrument był skończony.

Wcześniej w występy tych, które przechodzą przez maszt, wstawiamy pierścienie mocujące szpilki. Aby umieścić struny, wzięliśmy 4 struny dołączone do zestawu. Najpierw musisz rozróżnić każdy ciąg, ponieważ nie wszystkie są takie same. Musisz zawiązać jeden koniec każdego sznurka (dwa grube zwykłym węzłem, a dwa cienkie podwójnym) i włożyć sznurki w otwory mostka.

Następnie ułożymy sznurki w taki sposób, aby:

• Pierwsza pozycja: struna G (druga najgrubsza struna).

• Druga pozycja: ciąg C (grubszy ciąg).

• Trzecia pozycja: struna E (druga cieńsza struna).

• Czwarta pozycja: struna (cieńsza struna).

Przeciągnij sznurki do otworów dostarczonej wtyczki. Spróbuj naprawić każdą linę, wykonując dwa lub trzy obroty na szpilce. Napinaj struny nie przykładając zbyt dużej siły i sprawdzaj odległość między strunami a siodełkiem.

Jeśli masz jakiekolwiek wątpliwości, jak to zrobić, możesz przeczytać ten samouczek, który wyjaśni ci, jak poprawnie umieścić struny.

Krok 13: Testowanie

Na koniec musimy sprawdzić, czy ukulele zostało prawidłowo zmontowane w taki sposób, aby idealna odległość na pierwszym progu wynosiła 0,1 mm, a na dwunastym około 1,2 mm.

Potrzebne jest nastrojenie strun ukulele. Polecam Ci tę aplikację: GuitarTuna

Krok 14: Ciesz się tym

Teraz musisz tylko cieszyć się swoim ukulele.

Jeśli chcesz dowiedzieć się więcej o nas, znajdziesz nas w:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Sieć: Innovart.cc