DIY intelligente elektronische Ukulele mit Arduino - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

Wir erklären Ihnen Schritt für Schritt, wie Sie Ihre eigene Ukulele entwerfen und einige Effekte hinzufügen können, die sie einzigartig machen, z.

Um das zu machen, ist es notwendig, ein Ukulele-Kit zu kaufen.

Wir erklären, wie das Instrument zusammengebaut wird und lösen die verschiedenen Probleme, die auftreten können.

Schritt 1: Materialien

Strukturmaterialien:

DIY-Ukelele-Montagesatz (es könnte ein anderer Bausatz sein) bestehend aus:

1- Körper.

2-Hals.

3-Sattel

4-Seil-Unterstützung

5-Brücke

6-saitige Mutter.

7-Befestigungsring für Maschinenkopf (x4).

8-Maschinenköpfe (x4).

9-Befestigungsschrauben für Mechaniken (x8).

10-Befestigungsschrauben für Maschinenbrücke (x2).

11-Abdeckkappen für Brückenbefestigungsschrauben (x2).

12-Saiten (x4).

Elektronische Materialien:

• NANO-Arduino.
• LED-Rad WS2812.
• Beschleunigungsmesser BMA220 (optional).
• Batterieanschluss.
• Batterie von 9V.
• Schalter.

Andere

• Holzlack.
• Klettverschluss.
• Lötzinn.
• Schutzkunststoff zum Lackieren.
• Heißschmelz-Silikon.

Werkzeuge:

• Laser-Gravur.
• Sandpapier
• Sternschraubendreher.
• Pinsel.
• Heißschmelzpistole.
• Lötkolben aus Zinn.

Schritt 2: Passen Sie die Ukulele an

Um unsere Ukulele zu kostümieren, könnten wir eine Zeichnung mit einem Laserschneider auf dem Körper gravieren. Falls wir dieses Werkzeug nicht haben, könnten wir es malen.

Das Bild, das wir ausgewählt haben, ist das erste, das erscheint.

Zunächst müssen wir die Zeichnungsvorlage entwerfen, um die Gravur zu erstellen.

Dazu verwenden wir eine Software namens 'Inkscape', die wir über diesen Link beziehen können:

Um es zu verwenden, müssen wir das Bild anpassen, das wir verwenden möchten, wie wir es im zweiten Bild zeigen. Sie könnten sehen, dass wir das Anfangsbild gedreht haben, um den Kreis der Hand mit dem Kreis des Instruments anzupassen. Wie wir bereits gesagt haben, können Sie jedes Bild einfügen.

Schritt 3: Vektorisieren Sie ein Bild mit Inkscape

Wir werden sehen, wie Sie eine Vektordatei aus einer Pixmap erstellen (jpg, png, jedes Rasterformat, das Inkscape öffnen kann).

Inkscape Inkscape ist ein Open-Source-Vektorgrafik-Editor, und wie der Titel schon sagt, ist dies das Werkzeug, mit dem ich die Logos vektorisieren werde. Vektorisierungsschritte Die Schritte sind für jede Vektorisierung gleich, die wir durchführen möchten.

1. Öffnen Sie das Bild in Inkscape
2. Öffnen Sie den Werkzeugpfad „Bitmap verfolgen“-> „Bitmap verfolgen“.
3. Spielen Sie mit den Trace Bitmap-Optionen herum
4. Führen Sie die Verfolgung durch
5. Bereinigen Sie die Ergebnisse (falls erforderlich)

Beachten Sie den Teil des „Herumspielens“. Ich bin kein Experte für Tracing, daher behandle ich dieses Tool wie eine Blackbox mit Knöpfen und Lichtern, die sich drehen und verändern, bis ich das beste Ergebnis erziele

Schritt 4: Logogravur

Dazu ist es wichtig, eine Silhouette der Oberfläche zu haben, auf der die Gravur der Zeichnung hergestellt wird.

Für die Gravur verwenden wir die Software 'T2Laser'. Wir können diese Software erhalten von:

Nachdem wir die Software geöffnet haben, müssen wir das im letzten Schritt erstellte Image laden. Drücken Sie dann die Taste "Laser steuern", und es erscheint die CNC-Steuerung. Die beiden Bilder zeigen den Vorgang und das Ergebnis der Gravur mit unserem Lasercutter.

Schritt 5: Schleifen und Lackieren

Um unsere Ukulele hell und mit einer Schicht ohne Rauheit zu hinterlassen, können wir die beiden Teile, aus denen unser Instrument besteht, vorsichtig schleifen, da wir die erstellte Zeichnung beschädigen können (wenn Sie sich entschieden haben, die Ukulele zu bemalen, müssen Sie dies tun erst schleifen). Dann lackieren wir unsere beiden Teile, damit sie eine dunklere Farbe erhalten und das Holz widerstandsfähiger ist. Wir können einen normalen Holzlack verwenden, es muss nichts Besonderes sein.

Sobald wir den Lack haben, mischen wir ihn mit etwas Lösungsmittel an, damit er sich ein wenig auflöst. Als nächstes tragen wir die Mischung mit einem Pinsel auf den Hals und den Korpus des Instruments auf und lassen es trocknen.

Wenn wir feststellen, dass das Produkt eine zweite Schicht benötigt, können wir die beiden Teile ein wenig schleifen und eine Schicht verdünnten Lack erneut auftragen.

** VORSICHTSMASSNAHMEN: Der Lack ist ein chemisches Produkt, daher ist es notwendig, diesen Vorgang an einem belüfteten Ort durchzuführen. Tragen Sie eine Maske, um das Einatmen von Gerüchen und eine Schutzbrille zu vermeiden.

Die Materialien, die wir brauchen, um richtig zu arbeiten, sind die, die auf den Fotos erscheinen. Hauptsächlich arbeiten wir mit Pinsel, Lackdose (in unserem Fall rote Farbe), etwas Lösungsmittel und Sichtschutz. Und vor allem in gut belüfteten Räumen arbeiten.

Schritt 6: Hardware

Unsere Plakette mit dem Arduino, dem Beschleunigungsmesser und dem Rad mit LEDs wird in einer kleinen Halterung angebracht, um zu verhindern, dass sich alle Komponenten im Instrument bewegen.

Wir haben auch einen Batteriehalter und einen Schalter hinzugefügt, um es bequemer zu machen und die Batterie nicht zu verschleißen, wenn wir das Instrument nicht verwenden. Diese Halterung werden wir mit einem Stück Klettband (es würde auch mit Silikon und einer Heißklebepistole funktionieren) an der Innenseite des Ukulelenkörpers befestigen. Andererseits ist das LED-Rad kleiner als das Loch, also würde es fallen. Eine Stütze wurde so konstruiert, dass sie gut hält und ihre Funktion erfüllen kann.

Schritt 7: Software

Um unserer Ukulele eine besondere Dekoration zu verleihen, können wir dank eines LED-Rads Lichteffekte hinzufügen. Wir werden den WS2812 verwenden, aber Sie können jeden anderen verwenden, indem Sie den Anweisungen des Datenblatts folgen. Wir werden auch einen Beschleunigungsmesser (BMA220) verwenden, der es uns ermöglicht, die Schwerkraft zu beeinflussen.

Tatsächlich werden wir 4 Lichtspiele haben, die in der Computerbibliothek namens 'Adafruit' von Arduino enthalten sind. Dazu müssen wir eine korrekte Verbindung zwischen den drei Komponenten herstellen: Arduino NANO, WS2812 und BMA220, wie im ersten Bild zu sehen ist.

Die roten Drähte sind für die Stromversorgung, die GND-Schwarzen und der Rest sind notwendige Verbindungen für den korrekten Betrieb. Der Code, den wir für das Lichtkit verwendet haben, ist in einer Datei namens "play_of_light_v0.ino" angehängt. Stellen Sie sicher, dass Sie die notwendigen Bibliotheken für den korrekten Betrieb des Programms eingebunden haben. Die Batterie, die wir extern zum Stromkreis hinzufügen, muss eine Mindestspannung von 9 V haben und wir müssen sicherstellen, dass sie den minimalen Strom liefern kann, der für die Stromversorgung des gesamten Stromkreises erforderlich ist.

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

Byte-Version[3];

int8_t x_data; int8_t y_data; int8_t z_data; Bytebereich=0x00; Float divi=16; Schwimmer x, y, z; Schwimmerpi = 3,14159265359; Float nx, ny, Winkel; int led, früherLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel(NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

//Variablen Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parameter 1 = Anzahl der Pixel im Streifen // Parameter 2 = Arduino-Pinnummer (die meisten sind gültig) // Parameter 3 = Pixeltyp-Flags, nach Bedarf addieren: // NEO_KHZ800 800 KHz Bitstream (die meisten NeoPixel Produkte mit WS2812 LEDs) // NEO_KHZ400 400 KHz (klassische 'v1' (nicht v2) FLORA Pixel, WS2811 Treiber) // NEO_GRB Pixel sind für GRB Bitstream verdrahtet (die meisten NeoPixel Produkte) / / NEO_RGB Pixel sind für RGB-Bitstream verdrahtet (v1 FLORA-Pixel, nicht v2) // NEO_RGBW Pixel sind für RGBW-Bitstream verdrahtet (NeoPixel RGBW-Produkte) Adafruit_NeoPixel strip = Adafruit_NeoPixel(16, PIN, NEO_GRB + NEO_KHZ800); // WICHTIG: Um das NeoPixel-Burnout-Risiko zu reduzieren, fügen Sie einen 1000-uF-Kondensator über // Pixelstromleitungen hinzu, fügen Sie einen 300 - 500 Ohm Widerstand am Dateneingang des ersten Pixels hinzu // und minimieren Sie den Abstand zwischen Arduino und dem ersten Pixel. Vermeiden Sie das Anschließen von // an einen spannungsführenden Stromkreis … wenn Sie müssen, schließen Sie zuerst GND an.

//Variablen Rueda de colores

// NeoPixel Ring einfache Skizze (c) 2013 Shae Erisson // unter der GPLv3-Lizenz veröffentlicht, um dem Rest der AdaFruit NeoPixel-Bibliothek zu entsprechen

#enthalten

#ifdef _AVR_ #include #endif

// Welcher Pin des Arduino ist mit den NeoPixels verbunden?

// Bei einem Schmuckstück oder einer Gemma empfehlen wir, dies in 1 zu ändern #define PIN 9

// Wie viele NeoPixel sind an den Arduino angeschlossen?

#define NUMPIXELS 16

// Wenn wir die NeoPixel-Bibliothek einrichten, teilen wir ihr mit, wie viele Pixel und welcher Pin zum Senden von Signalen verwendet werden soll.

// Beachten Sie, dass Sie bei älteren NeoPixel-Streifen möglicherweise den dritten Parameter ändern müssen – siehe das Beispiel strandtest // für weitere Informationen zu möglichen Werten. Adafruit_NeoPixel-Pixel = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int Verzögerungswert = 50; // Verzögerung für 50ms

//Variablen colores aleatorios

#include #ifdef _AVR_ #include #endif

#definiere PIN 9

#define NUM_LEDS 16

#define HELLIGKEIT 200

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

Byte 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); // Adresse des Beschleunigungsmessers // Bereichseinstellungen Wire.write (0x22); // Adresse registrieren Wire.write (Bereich); // kann auf "0x00""0x01""0x02""0x03" gesetzt werden, siehe Datashhet im Wiki // Tiefpassfilter Wire.write (0x20); // Adresse registrieren Wire.write (0x05); //kann eingestellt werden auf "0x05""0x04"……"0x01""0x00", siehe Datashhet im Wiki Wire.endTransmission();

// Codigo; Luces Arcoiris

// Dies ist für Trinket 5V 16MHz, Sie können diese drei Zeilen entfernen, wenn Sie kein Trinket verwenden #wenn definiert (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Ende des Schmuckstück-Sondercodes strip.begin(); Strip-Show(); // Alle Pixel auf 'off' initialisieren

//Código Rueda de colores

// Dies ist für Trinket 5V 16MHz, Sie können diese drei Zeilen entfernen, wenn Sie kein Trinket verwenden #wenn definiert (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Ende des Schmuckstück-Sondercodes

Pixel.begin(); // Dies initialisiert die NeoPixel-Bibliothek.

//Codigo-Unterbrechung

Zähler = 1;

//Codigo Colores varios

// Dies ist für Trinket 5V 16MHz, Sie können diese drei Zeilen entfernen, wenn Sie kein Trinket verwenden #wenn definiert (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Ende des Schmuckstück-Sondercodes strip.setBrightness(BRIGHTNESS); strip.begin(); Strip-Show(); // Alle Pixel auf 'off' initialisieren }

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

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

/Bucle infinito

Void Schleife () {//Caso 1: Juego de luces de la gravedad; if(counter == 1){ for(int i=0;i 0.0){ if(nx 0.0) angle+=180; sonst Winkel += 360; } // Ende sonst if (Winkel == 360,0) Winkel = 0,0; led = zirkularisieren (Winkel / (360 / NUMBER_OF_LEDS_ON_RING)); // LED-Bewegung glatt machen if (vorherigeLed == led) { // nichts zu tun} else if (counterClockwiseDistanceBetweenLeds(vorherigeLed, led) <= 8) led = zirkularize (vorherigeLed + 1); else led = zirkularisieren (vorherigeLed - 1); ledQueue.push(led); makeLightShow(); previousLed = geführt; Verzögerung (25); } Zähler = 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++){ // Einige Beispielprozeduren zeigen wie man die Pixel anzeigt: colorWipe1(strip. Color(255, 0, 0), 50); // Rot colorWipe1 (strip. Color (0, 255, 0), 50); // Grün colorWipe1 (strip. Color (0, 0, 255), 50); // Blau colorWipe1 (strip. Color (0, 0, 0, 255), 50); // Weiß RGBW // Sende eine Theater-Pixel-Chase in… theaterChase(strip. Color(127, 127, 127), 50); // Weißes theaterChase (strip. Color (127, 0, 0), 50); // Rotes theaterChase (strip. Color (0, 0, 127), 50); // Blau

Regenbogen(5);

RegenbogenZyklus(5); theaterChaseRainbow(5); } Zähler = 3; } // End if counter==2 //Caso 3: Luces Aleatorias else if(counter == 3){ for(int k=0;k<50;k++){ // Für eine Menge von NeoPixels ist das erste NeoPixel 0, Sekunde ist 1, bis hin zur Anzahl der Pixel minus eins. int a = zufällig (255); int b = zufällig (255); int c = zufällig (255); for(int i=0;i

// Pixel. Color nimmt RGB-Werte an, von 0, 0, 0 bis 255, 255, 255

Pixel.setPixelColor(i, Pixel. Color(a, b, c)); // Mäßig hellgrüne Farbe.

Pixel.show(); // Dies sendet die aktualisierte Pixelfarbe an die Hardware.

Verzögerung (Verzögerungswert); // Verzögerung für einen bestimmten Zeitraum (in Millisekunden).

} a=zufällig(255); b = zufällig (255); c = zufällig (255); for(int i=NUMPIXELS;i>0;i--){

// Pixel. Color nimmt RGB-Werte an, von 0, 0, 0 bis 255, 255, 255

Pixel.setPixelColor(i, Pixel. Color(a, b, c)); // Mäßig hellgrüne Farbe.

Pixel.show(); // Dies sendet die aktualisierte Pixelfarbe an die Hardware.

Verzögerung (Verzögerungswert); // Verzögerung für einen bestimmten Zeitraum (in Millisekunden).

} } Zähler = 4; } else if(counter == 4){ for(int g=0;g<=6;g++){// Einige Beispielprozeduren, die zeigen, wie die Pixel angezeigt werden: colorWipe(strip. Color(255, 0, 0), 50); // Rot colorWipe (strip. Color (0, 255, 0), 50); // Grün colorWipe (strip. Color (0, 0, 255), 50); // Blau colorWipe (strip. Color (0, 0, 0, 255), 50); // Weiß weißOverRainbow (20, 75, 5); pulsweiß(5); // fullWhite(); // Verzögerung (2000); rainbowFade2White(3, 3, 1);

}

Zähler = 1; } } ////////////////////////////////////////////// ////////////////////////////////// /////////////// //////////////////////////////////////////////// //////////////////

/Metodos del Ejemplo de la Gravedad

Void AccelerometerInit () { Wire.beginTransmission (0x0A); // Adresse des Beschleunigungsmessers // Zurücksetzen des Beschleunigungsmessers Wire.write (0x04); // X-Daten Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // 6 Byte vom Slave-Gerät #2 anfordern while(Wire.available()) // Slave darf weniger als angefordert senden { Version[0] = Wire.read(); // ein Byte als Zeichen empfangen } x_data=(int8_t)Version[0]>>2; Wire.beginTransmission(0x0A); // Adresse des Beschleunigungsmessers // Zurücksetzen des Beschleunigungsmessers Wire.write (0x06); // Y-Daten Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // 6 Byte vom Slave-Gerät #2 anfordern while(Wire.available()) // Slave darf weniger als angefordert senden { Version[1] = Wire.read(); // ein Byte als Zeichen empfangen } y_data=(int8_t)Version[1]>>2; Wire.beginTransmission(0x0A); // Adresse des Beschleunigungsmessers // Zurücksetzen des Beschleunigungsmessers Wire.write (0x08); // Z-Daten Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // 6 Byte vom Slave-Gerät #2 anfordern while(Wire.available()) // Slave kann weniger als angefordert senden { Version[2] = Wire.read(); // ein Byte als Zeichen empfangen } z_data=(int8_t)Version[2]>>2; x=(float)x_data/divi; y=(float)y_data/divi; z=(float)z_data/divi; Serial.print("X="); Serial.print (x); // drucke das Zeichen Serial.print (" "); Serial.print("Y="); Serial.print (y); // drucke das Zeichen Serial.print (" "); Serial.print("Z="); // drucke das Zeichen Serial.println (z); }

int zirkularisieren (int pos) {

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

int-Abstand;

int counterClockwiseDistanceBetweenLeds(int prevPos, int nextPos){ Abstand = nextPos - prevPos; if(Abstand < 0) Abstand += NUMBER_OF_LEDS_ON_RING; Rückkehr (Entfernung); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int Helligkeitsschritt = 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

// Fülle die Punkte nacheinander mit einer Farbe void colorWipe(uint32_t c, uint8_t wait) { for(uint16_t i=0; i

void rainbow(uint8_t warte) {

uint16_t i, j;

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

// Etwas anders, dadurch ist der Regenbogen gleichmäßig verteilt

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

for(j=0; j<256*5; j++) {// 5 Zyklen aller Farben auf dem Rad for(i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255); } Strip-Show(); verzögern (warten); } }

// Kriechende Lichter im Theaterstil.

void theaterChase(uint32_t c, uint8_t wait) { for (int j=0; j<10; j++) { // 10 Zyklen jagen für (int q=0; q < 3; q++) { for (uint16_t i= 0; i < strip.numPixels(); i = i + 3) { strip.setPixelColor (i + q, c); // jedes dritte Pixel einschalten} strip.show();

verzögern (warten);

for (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); // jedes dritte Pixel ausschalten } } } }

// Kriechende Lichter im Theaterstil mit Regenbogeneffekt

void theaterChaseRainbow(uint8_t wait) { for (int j=0; j < 256; j++) {// alle 256 Farben im Rad durchlaufen 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)); // jedes dritte Pixel einschalten} strip.show();

verzögern (warten);

for (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); // jedes dritte Pixel ausschalten } } } }

// Geben Sie einen Wert von 0 bis 255 ein, um einen Farbwert zu erhalten.

// Die Farben sind ein Übergang r - g - b - zurück nach r. uint32_t Wheel(byte WheelPos) { WheelPos = 255 - WheelPos; if(WheelPos <85) { return strip. Color(255 - WheelPos * 3, 0, WheelPos * 3); } if (WheelPos <170) { WheelPos -= 85; Return strip. Color(0, WheelPos * 3, 255 - WheelPos * 3); } WheelPos -= 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

// Fülle die Punkte nacheinander mit einer Farbe

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

void pulseWhite(uint8_t warte) {

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) {

Float-FadeMax = 100,0; int fadeVal = 0; uint32_t RadVal; int redVal, greenVal, blueVal;

for(int k = 0; k < rainbowLoops; k ++) { for(int j=0; j<256; j++) {// 5 Zyklen aller Farben auf dem Rad

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));

}

//Erste Schleife, einblenden!

if(k == 0 && FadeVal < FadeMax-1) { FadeVal++; }

// Letzte Schleife, ausblenden!

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

Strip-Show();

verzögern (warten); } }

Verzögerung (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(); }

Verzögerung (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(); } }

Verzögerung (500);

}

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

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

int head = whiteLength - 1;

int-Schwanz = 0;

int-Schleifen = 3;

int loopNum = 0;

statisch unsigned long lastTime = 0;

während(wahr){

for(int j=0; j<256; j++) { for(uint16_t i=0; i= tail && i head && i >= tail) || (Schwanz > Kopf && i <= Kopf)) { strip.setPixelColor (i, strip. Color (0, 0, 0, 255)); aufrechtzuerhalten. Sonst { strip.setPixelColor (i, Wheel (((i * 256 / strip.numPixels ()) + j) & 255)); } }

if(millis() - lastTime > whiteSpeed) {

Kopf++; Schwanz++; if(head == strip.numPixels()){ loopNum++; } lastTime = millis(); }

if(loopNum == Schleifen) zurück;

head%=strip.numPixels(); tail%=strip.numPixels(); Strip-Show(); verzögern (warten); } } } void fullWhite() { for(uint16_t i=0; i

// Etwas anders, dadurch ist der Regenbogen gleichmäßig verteilt

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

for(j=0; j<256 * 5; j++) {// 5 Zyklen aller Farben auf dem Rad for(i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255); } Strip-Show(); verzögern (warten); } }

void rainbow1(uint8_t warte) {

uint16_t i, j;

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

// Geben Sie einen Wert von 0 bis 255 ein, um einen Farbwert zu erhalten.

// Die Farben sind ein Übergang r - g - b - zurück nach r. uint32_t Wheel1(byte WheelPos) { WheelPos = 255 - WheelPos; if(WheelPos <85) { return strip. Color(255 - WheelPos * 3, 0, WheelPos * 3, 0); } if (WheelPos <170) { WheelPos -= 85; Return strip. Color(0, WheelPos * 3, 255 - WheelPos * 3, 0); } WheelPos -= 170; Return strip. Color (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t red(uint32_tc) {

zurück (c >> 16); } uint8_t grün (uint32_t c) { zurück (c >> 8); } uint8_t blau (uint32_t c) { zurück (c); }

Schritt 8: 3D-Design

Zuerst müssen Sie Ihre Hardwarekomponenten dimensionieren, um sich über die richtige Größe zu vergewissern. Wenn sie mit unseren identisch sind, können Sie dieselben Dateien verwenden, die wir Ihnen leihen.

Beide Stützen wurden mit einem 3D-Drucker entworfen, die auch enthalten sind als:

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

Schließlich wird das Licht wie auf den beiden letzten Bildern sein.

Schritt 9: Montage des Halses

Zuerst legen wir den Sattel auf den Hals. Die Löcher, die die Schrauben brauchen, um es zu halten, sind nicht da, also müssen wir sie machen, markieren, wo sie hingehen und vorsichtig mit einer Schnecke das Loch machen.

Gleiches gilt für die Löcher, in denen die Schrauben den Hals selbst am Korpus des Instruments halten. Es ist nicht notwendig, sie zu machen, da es für diese Befestigung keine Schrauben gibt, aber wenn wir es tun möchten, wäre es kein Problem.

WICHTIG: Lassen Sie 5 mm Platz zwischen Mastanfang und Stimmgabelanfang, da in diesem Loch die Mutter platziert wird.

Wir kleben die Mutter mit Klebstoff in die in der Abbildung angegebene Richtung.

Schließlich führen wir die 4 Stifte in die Löcher am Anfang des Mastes ein und halten jeden Stift mit 2 kurzen Schrauben, wie in der Abbildung gezeigt.

Schritt 10: Montage des Birdge

Die Brücke wird durch Kleben und mit den beiden langen Schrauben in zentraler Position am Korpus befestigt. Es empfiehlt sich, mit einem Bleistift die richtige Position im Körper zu markieren. Wir nehmen die im Bild markierten Entfernungen.

Wir werden Kleber an der Vereinigung der beiden Komponenten auftragen. Wir fixieren die beiden Teile vorsichtig mit Hilfe einer Spannschraube, bis die Verbindung getrocknet ist. Wir werden die beiden Löcher für die Schrauben mit einem 1,5-mm-Holzbohrer bohren. Befestigen Sie die Brücke mit den beiden langen Schrauben im Korpus. Und zum Schluss setzen wir die Schutzkappen auf die Köpfe der Schrauben.

Schritt 11: Körper- und Halsmontage

Um die beiden Teile zusammenzubauen, haben wir Löcher im Kopf des Körpers, in die der Hals mit zwei Vorsprüngen passt. Wir können sie mit Leim oder mit der Heißklebepistole kleben. Um eine bessere Fixierung zu erreichen, können Sie die Löcher am Ende der Stimmgabel bohren, um sie mit dem Körper zu verbinden.

Schritt 12: Legen Sie die Ukulele-Saiten

Zum Schluss müssen wir noch die Saiten auflegen, damit unser Instrument fertig ist.

Zuvor werden wir die Befestigungsringe der Stifte in die Vorsprünge dieser, die durch den Mast gehen, einführen. Um die Saiten zu platzieren, haben wir die 4 Saiten genommen, die mit dem Kit geliefert wurden. Zuerst müssen Sie jede Zeichenfolge unterscheiden, da sie nicht alle gleich sind. Sie müssen ein Ende jeder Saite (die beiden dicken mit einem normalen Knoten und die beiden dünnen mit einem doppelten) binden und die Saiten in die Schlitze des Stegs einführen.

Dann werden wir die Strings so platzieren, dass:

• Erste Position: G-Saite (zweitstärkste Saite).

• Zweite Position: C-Saite (dickere Saite).

• Dritte Position: E-Saite (zweite dünnere Saite).

• Vierte Position: Eine Saite (dünnere Saite).

Fädeln Sie die Saiten in die Löcher des mitgelieferten Steckers. Versuchen Sie, jedes Seil zu fixieren, indem Sie den Stift zwei oder drei Mal drehen. Spannen Sie die Saiten ohne großen Kraftaufwand und prüfen Sie den Abstand zwischen Saiten und Sattel.

Wenn Sie Zweifel haben, wie das gemacht wird, können Sie dieses Tutorial nachschlagen, das Ihnen erklärt, wie die Saiten richtig gelegt werden.

Schritt 13: Testen

Schließlich müssen wir noch sehen, ob die Ukulele richtig so zusammengebaut wurde, dass der ideale Abstand am ersten Bund 0,1 mm und am zwölften etwa 1,2 mm beträgt.

Wird benötigt, um die Ukulele-Saiten zu stimmen. Ich empfehle Ihnen diese App: GuitarTuna

Schritt 14: Genießen Sie es

Jetzt müssen Sie nur noch Ihre Ukulele genießen.

Wenn Sie mehr über uns erfahren möchten, finden Sie uns in:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Internet: Innovart.cc