DIY slimme elektronische ukelele met Arduino 14 stappen (met afbeeldingen) - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

We gaan stap voor stap uitleggen hoe je je eigen ukelele kunt ontwerpen en enkele effecten kunt toevoegen die hem uniek maken, zoals het tekenen van iets dat we willen op het oppervlak van de ukelele of het toevoegen van wat lichteffecten.

Om dat te maken, is het noodzakelijk om een ukelele-kit te kopen.

We gaan uitleggen hoe je het instrument in elkaar zet en de verschillende problemen oplossen die kunnen optreden.

Stap 1: Materialen

Structuur materialen:

DIY-montagekit voor ukelele (het kan een andere kit zijn) gevormd door:

1- Lichaam.

2-hals.

3-zadel

Ondersteuning voor 4-touwen

5-brug

6-snarige moer.

7-Bevestigingsring voor stemmechaniek (x4).

8-Machinekoppen (x4).

9-Montage schroeven voor stemmechanieken (x8).

10-Bevestigingsschroeven voor machinebrug (x2).

11-Afdekkappen voor brugmontageschroeven (x2).

12-snaren (x4).

Elektronische materialen:

• NANO-Arduino.
• Wiel van Leds WS2812.
• Versnellingsmeter BMA220 (optioneel).
• Batterij aansluiting.
• Batterij van 9V.
• Schakelaar.

anderen

• Hout vernis.
• klittenband.
• Soldeer tin.
• Beschermende kunststof voor lakken.
• Hotmelt siliconen.

Gereedschap:

• Lasergravure.
• Schuurpapier
• Ster schroevendraaier.
• Penseel.
• Hotmelt pistool.
• Tinnen soldeerbout.

Stap 2: Pas de ukelele aan

Om onze ukelele te personaliseren konden we een gravure maken van een tekening met een lasersnijder op het lichaam. Als we dat gereedschap niet hebben, kunnen we het schilderen.

De foto die we hebben gekozen is de eerste die verschijnt.

Allereerst moeten we het tekensjabloon ontwerpen om de gravure te maken.

Om dat uit te voeren, gebruiken we een software genaamd 'Inkscape' die we kunnen verkrijgen via deze link:

Om het te gebruiken, moeten we de afbeelding aanpassen die we willen gebruiken, zoals we laten zien in de tweede afbeelding. Je zou kunnen zien dat we de eerste afbeelding hebben gedraaid om de cirkel van de hand te kunnen aanpassen aan de cirkel van het instrument. Zoals we al eerder zeiden, je zou elke afbeelding kunnen plaatsen.

Stap 3: Vectoriseer een afbeelding met Inkscape

We zullen zien hoe we een vectorbestand kunnen maken van een pixmap (jpg, png, welk rasterformaat dan ook dat Inkscape kan openen).

Inkscape Inkscape is een open-source editor voor vectorafbeeldingen, en zoals de titel al aangeeft, is dit de tool die ik zal gebruiken om de logo's te vectoriseren. Stappen vectoriseren De stappen zijn gebruikelijk voor elke vectorisering die we zouden willen doen.

1. Open de afbeelding in Inkscape
2. Open de Trace Bitmap Tool Path->Trace Bitmap
3. Speel rond de Trace Bitmap-opties
4. Voer de tracering uit
5. Ruim de resultaten op (indien nodig)

Let op het gedeelte 'rondspelen'. Ik ben geen expert op het gebied van traceren, dus ik behandel deze tool als een zwarte doos met knoppen en lichten, draaiend en veranderend totdat ik het beste resultaat krijg

Stap 4: Logo graveren

Hiervoor is het belangrijk om een silhouet te hebben van het oppervlak waarop de gravure van de tekening zal worden geproduceerd.

Om de gravure te maken gaan we gebruik maken van 'T2Laser' software. We kunnen deze software verkrijgen via:

Nadat we de software hebben geopend, moeten we de afbeelding laden die we in de laatste stap hebben gemaakt. Druk vervolgens op de knop "controle laser", en de cnc-bedieningselementen verschijnen. De twee foto's tonen het proces en het resultaat van het graveren met onze lasersnijder.

Stap 5: Schuren en lakken

Om onze ukelele helder en met een laag zonder ruwheid te laten, kunnen we de twee delen waaruit ons instrument bestaat, met zorg glad schuren, omdat we de gemaakte tekening kunnen beschadigen (als u ervoor heeft gekozen om de ukelele te schilderen, zou u eerst schuren). Daarna zullen we onze twee delen vernissen zodat ze een donkerdere kleur krijgen en het hout meer weerstand biedt. We kunnen een normale houtvernis gebruiken, dit hoeft niet speciaal te zijn.

Zodra we de lak hebben, mengen we deze met een beetje oplosmiddel zodat het een beetje oplost. Vervolgens brengen we het mengsel met een kwast aan op de hals en de body van het instrument en laten we het drogen.

Als we zien dat het product een tweede laag nodig heeft, kunnen we de twee delen een beetje schuren en opnieuw een laag verdunde vernis aanbrengen.

** VOORZORGSMAATREGELEN: De lak is een chemisch product, dus het is noodzakelijk om dit proces uit te voeren op een geventileerde plaats, draag een masker om het inademen van geuren te voorkomen en een veiligheidsbril.

De materialen die we nodig hebben om correct te kunnen werken, zijn die op de foto's. We zullen voornamelijk werken met een penseel, een vernisbus (in ons geval rode kleur), een beetje oplosmiddel en visuele bescherming. En vooral werken in goed geventileerde ruimtes.

Stap 6: Hardware

Onze plaquette met de Arduino, de acceleratiemeter en het wiel met leds zullen in een kleine beugel worden geïntroduceerd om te voorkomen dat alle componenten in het instrument bewegen.

We hebben ook een batterijhouder en een schakelaar toegevoegd om het comfortabeler te maken en we verslijten de batterij niet als we het instrument niet gebruiken. We zullen deze steun met een stuk klittenband (het zou ook werken met siliconen en een hotmelt-pistool) aan de binnenkant van de ukulele-body bevestigen. Aan de andere kant is het LED-wiel kleiner dan het gat, dus het zou vallen. Een steun is zo ontworpen dat deze goed blijft zitten en zijn functie kan uitoefenen.

Stap 7: Software

Om onze ukelele een speciale decoratie te geven, konden we lichteffecten toevoegen dankzij een wiel van leds. We gaan de WS2812 gebruiken, maar u kunt elke andere gebruiken volgens de instructies van de datasheet. We zullen ook een acceleratiemeter (BMA220) gebruiken, waarmee we een effect van de zwaartekracht kunnen maken.

In feite zullen we 4 lichtspelen hebben, opgenomen in de computerbibliotheek genaamd 'Adafruit' van Arduino. Daartoe moeten we een juiste verbinding maken tussen de drie componenten: Arduino NANO, WS2812 en BMA220, zoals in de eerste afbeelding verschijnt.

De rode draden zijn voor stroom, de GND-zwarten en de rest zijn noodzakelijke verbindingen voor de juiste werking. De code die we voor de lichtset hebben gebruikt, is bijgevoegd in een bestand met de naam "play_of_light_v0.ino". Zorg ervoor dat u de benodigde bibliotheken hebt opgenomen voor de juiste werking van het programma. De batterij die we extern aan het circuit toevoegen, moet een minimale spanning van 9V hebben en we moeten ervoor zorgen dat deze de minimale stroom kan leveren die nodig is om het hele circuit van stroom te voorzien.

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

byte-versie [3];

int8_t x_data; int8_t y_data; int8_t z_data; bytebereik = 0x00; vlotter divi=16; zweven x, y, z; vlotter pi = 3.14159265359; vlotter nx, ny, hoek; int led, vorigeLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel(NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

//Variabelen Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Parameter 1 = aantal pixels in strip // Parameter 2 = Arduino pinnummer (de meeste zijn geldig) // Parameter 3 = pixeltype vlaggen, voeg zo nodig bij elkaar: // NEO_KHZ800 800 KHz bitstream (meeste NeoPixel-producten met WS2812 LED's) // NEO_KHZ400 400 KHz (klassieke 'v1' (niet v2) FLORA-pixels, WS2811-stuurprogramma's) // NEO_GRB-pixels zijn bedraad voor GRB-bitstream (de meeste NeoPixel-producten) / / NEO_RGB Pixels zijn bedraad voor RGB-bitstream (v1 FLORA-pixels, niet v2) // NEO_RGBW Pixels zijn bedraad voor RGBW-bitstream (NeoPixel RGBW-producten) Adafruit_NeoPixel strip = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // BELANGRIJK: om het risico op doorbranden van NeoPixel te verminderen, voegt u 1000 uF condensator toe over // pixelvoedingsdraden, voegt u 300 - 500 Ohm weerstand toe aan de gegevensinvoer van de eerste pixel // en minimaliseert u de afstand tussen Arduino en de eerste pixel. Vermijd het aansluiten van // op een circuit onder spanning… sluit indien nodig eerst GND aan.

//Variabelen Rueda de colores

// Eenvoudige schets NeoPixel Ring (c) 2013 Shae Erisson // uitgebracht onder de GPLv3-licentie om overeen te komen met de rest van de AdaFruit NeoPixel-bibliotheek

#erbij betrekken

#ifdef _AVR_ #include #endif

// Welke pin op de Arduino is verbonden met de NeoPixels?

// Op een Trinket of Gemma raden we aan dit te wijzigen in 1 #define PIN 9

// Hoeveel NeoPixels zijn aangesloten op de Arduino?

#define NUMPIXELS 16

// Wanneer we de NeoPixel-bibliotheek instellen, vertellen we hoeveel pixels en welke pin we moeten gebruiken om signalen te verzenden.

// Houd er rekening mee dat u voor oudere NeoPixel-strips mogelijk de derde parameter moet wijzigen - zie het voorbeeld van de strandtest // voor meer informatie over mogelijke waarden. Adafruit_NeoPixel pixels = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int vertragingswaarde = 50; // vertraging voor 50ms

//Variabelen colores aleatorios

#include #ifdef _AVR_ #include #endif

#definieer pincode 9

#define NUM_LEDS 16

#define HELDERHEID 200

//Adafruit_NeoPixel strip = 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); Serieel.begin(9600); Draad.begin(); Wire.beginTransmission (0x0A); // adres van de versnellingsmeter // bereikinstellingen Wire.write (0x22); //register adres Wire.write (bereik); //kan worden ingesteld op "0x00""0x01""0x02""0x03", zie Datashhet op wiki // laagdoorlaatfilter Wire.write (0x20); //register adres Wire.write (0x05); //kan worden ingesteld op "0x05""0x04"……"0x01""0x00", zie Datashhet op wiki Wire.endTransmission();

//Codigo; Luces Arcoiris

// Dit is voor Trinket 5V 16MHz, u kunt deze drie regels verwijderen als u geen Trinket gebruikt #if gedefinieerd (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Einde van speciale code strip.begin(); strip.show(); // Initialiseer alle pixels op 'uit'

//Codigo Rueda de colores

// Dit is voor Trinket 5V 16MHz, u kunt deze drie regels verwijderen als u geen Trinket gebruikt #if gedefinieerd (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Einde van speciale code voor trinket

pixels.begin(); // Hiermee wordt de NeoPixel-bibliotheek geïnitialiseerd.

//Codigo onderbreking

teller = 1;

//Codigo Colores varios

// Dit is voor Trinket 5V 16MHz, u kunt deze drie regels verwijderen als u geen Trinket gebruikt #if gedefinieerd (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Einde van trinket speciale code strip.setBrightness(BRIGHTNESS); strip.begin(); strip.show(); // Initialiseer alle pixels op 'uit'}

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

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

/Bucle infinito

void loop() {//Caso 1: Juego de luces de la gravedad; if(teller == 1){ for(int i=0;i 0.0){ if(nx 0.0) angle+=180; anders hoek += 360; }//end else if(hoek == 360,0) hoek = 0,0; led = ronddraaien (hoek / (360 / NUMBER_OF_LEDS_ON_RING)); // maak led-beweging soepel if (previousLed == led) {// niets te doen} else if (counterClockwiseDistanceBetweenLeds(previousLed, led) <= 8) led = circularize (previousLed + 1); else led = circularize(previousLed - 1); ledQueue.push(led); makeLightShow(); vorigeLed = led; vertraging(25); } teller = 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++){ // Enkele voorbeeldprocedures die hoe te tonen aan de pixels: colorWipe1(strip. Color(255, 0, 0), 50); // Rode kleurWipe1 (strip. Kleur (0, 255, 0), 50); // Groene colorWipe1 (strip. Color (0, 0, 255), 50); // Blauwe kleurWipe1 (strip. Kleur (0, 0, 0, 255), 50); // Witte RGBW // Stuur een theater pixel chase in… theaterChase(strip. Color(127, 127, 127), 50); // Witte theaterChase (strip. Color (127, 0, 0), 50); // Rode theaterChase (strip. Color (0, 0, 127), 50); // Blauw

regenboog (5);

regenboogCycle(5); theaterChaseRainbow(5); } teller = 3; }//End if counter==2 //Caso 3: Luces Aleatorias else if(counter == 3){ for(int k=0;k<50;k++){ // Voor een set NeoPixels is de eerste NeoPixel 0, tweede is 1, helemaal tot aan het aantal pixels min één. int a=willekeurig (255); int b=willekeurig (255); int c=willekeurig (255); for(int i=0;i

// pixels. Kleur neemt RGB-waarden aan, van 0, 0, 0 tot 255, 255, 255

pixels.setPixelColor(i, pixels. Color(a, b, c)); // Matig felgroene kleur.

pixels.show(); // Dit stuurt de bijgewerkte pixelkleur naar de hardware.

vertraging (vertragingswaarde); // Vertraging voor een bepaalde tijd (in milliseconden).

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

// pixels. Kleur neemt RGB-waarden aan, van 0, 0, 0 tot 255, 255, 255

pixels.setPixelColor(i, pixels. Color(a, b, c)); // Matig felgroene kleur.

pixels.show(); // Dit stuurt de bijgewerkte pixelkleur naar de hardware.

vertraging (vertragingswaarde); // Vertraging voor een bepaalde tijd (in milliseconden).

} } teller = 4; } else if(counter == 4){ for(int g=0;g<=6;g++){ // Enkele voorbeeldprocedures die laten zien hoe de pixels worden weergegeven: colorWipe(strip. Color(255, 0, 0), 50); // Rode colorWipe (strip. Color (0, 255, 0), 50); // Groene colorWipe (strip. Color (0, 0, 255), 50); // Blauwe colorWipe (strip. Color (0, 0, 0, 255), 50); // Wit witOverRainbow (20, 75, 5); pulseWit (5); // volledig wit (); // vertraging (2000); regenboogFade2White (3, 3, 1);

}

teller = 1; } } //////////////////////////////////////////////// /////////////////////////////////// /////////////// ////////////////////////////////////////////////// //////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit() { Wire.beginTransmission (0x0A); // adres van de versnellingsmeter // reset de versnellingsmeter Wire.write (0x04); // X data Wire.endTransmission(); Wire.requestFrom(0x0A, 1); // verzoek 6 bytes van slave-apparaat #2 while(Wire.available()) // slave kan minder verzenden dan gevraagd {Versie [0] = Wire.read(); // ontvang een byte als karakter } x_data=(int8_t)Version[0]>>2; Wire.beginTransmission (0x0A); // adres van de versnellingsmeter // reset de versnellingsmeter Wire.write (0x06); // Y-gegevens Wire.endTransmission (); Wire.requestFrom(0x0A, 1); // verzoek 6 bytes van slave-apparaat #2 while(Wire.available()) // slave kan minder verzenden dan gevraagd {Versie [1] = Wire.read(); // ontvang een byte als karakter} y_data=(int8_t)Version[1]>>2; Wire.beginTransmission (0x0A); // adres van de versnellingsmeter // reset de versnellingsmeter Wire.write (0x08); // Z-gegevens Wire.endTransmission (); Wire.requestFrom(0x0A, 1); // verzoek 6 bytes van slave-apparaat #2 while(Wire.available()) // slave kan minder verzenden dan gevraagd {Versie [2] = Wire.read(); // ontvang een byte als karakter } z_data=(int8_t)Version[2]>>2; x=(float)x_data/divi; y=(float)y_data/divi; z=(float)z_data/divi; Serieel.print("X="); Serie.print(x); // print het karakter Serial.print(" "); Serieel.print("Y="); Seriële.print(y); // print het karakter Serial.print(" "); Serieel.print("Z="); // print het karakter Serial.println(z); }

int circularize(int pos){

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

int afstand;

int counterClockwiseDistanceBetweenLeds(int prevPos, int nextPos) { distance = nextPos - prevPos; if (afstand < 0) afstand += NUMBER_OF_LEDS_ON_RING; terugkeer (afstand); }

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 int helderheidStep = 255/NUMBER_OF_LEDS_TO_SHINE;

ongeldig 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

// Vul de stippen één voor één met een lege kleur colorWipe (uint32_t c, uint8_t wait) { for (uint16_t i=0; i

ongeldige regenboog (uint8_t wacht) {

uint16_t i, j;

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

// Iets anders, hierdoor is de regenboog gelijkmatig verdeeld

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

for(j=0; j<256*5; j++) {// 5 cycli van alle kleuren op het wiel for(i=0; i<strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); } strip.show(); vertraging (wacht); } }

// Kruiplichten in theaterstijl.

void theaterChase(uint32_t c, uint8_t wacht) { for (int j=0; j<10; j++) {//doe 10 cycli van jagen voor (int q=0; q <3; q++) { for (uint16_t i= 0; ik <strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, c); // zet elke derde pixel aan } strip.show();

vertraging (wacht);

for (uint16_t i=0; i <strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); // zet elke derde pixel uit } } } }

// Kruiplichten in theaterstijl met regenboogeffect

void theaterChaseRainbow(uint8_t wait) { for (int j=0; j <256; j++) { // cycle alle 256 kleuren in het wiel voor (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)); // zet elke derde pixel aan } strip.show();

vertraging (wacht);

for (uint16_t i=0; i <strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); // zet elke derde pixel uit } } } }

// Voer een waarde in van 0 tot 255 om een kleurwaarde te krijgen.

// De kleuren zijn een overgang r - g - b - terug naar r. uint32_t Wheel (byte WheelPos) { WheelPos = 255 - WheelPos; if (WheelPos < 85) { retourstrip. Kleur (255 - WheelPos * 3, 0, WheelPos * 3); } if(WheelPos < 170) { WheelPos -= 85; retourstrip. Kleur (0, WheelPos * 3, 255 - WheelPos * 3); } WielPos -= 170; retourstrook. Kleur (WheelPos * 3, 255 - WheelPos * 3, 0); }

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

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

/Metodos Rueda de colores

// int elegirColor = willekeurig (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

// Vul de stippen een voor een met een kleur

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

void pulseWhite(uint8_t wacht) {

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 wielVal; int roodVal, groenVal, blauwVal;

for(int k = 0; k < rainbowLoops; k ++){ for(int j=0; j<256; j++) { // 5 cycli van alle kleuren op het wiel

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

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

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

greenVal = groen(wheelVal) * float(fadeVal/fadeMax); blueVal = blauw(wheelVal) * float(fadeVal/fadeMax);

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

}

//Eerste lus, fade in!

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

//Laatste lus, uitfaden!

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

strip.show();

vertraging (wacht); } }

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

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

vertraging (500);

}

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

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

int head = witLengte - 1;

int staart = 0;

int-lussen = 3;

int loopNum = 0;

statisch unsigned long lastTime = 0;

terwijl (waar){

for(int j=0; j<256; j++) { for(uint16_t i=0; i= staart && ik hoofd && i >= staart) || (staart > kop && i <= kop)){ strip.setPixelColor(i, strip. Color (0, 0, 0, 255)); } else{ strip.setPixelColor(i, Wheel((((i * 256 / strip.numPixels()) + j) & 255)); } }

if(millis() - lastTime > whiteSpeed) {

hoofd++; staart++; if(head == strip.numPixels()){ loopNum++; } lastTime = millis(); }

if(loopNum == lussen) return;

head%=strip.numPixels(); tail%=strip.numPixels(); strip.show(); vertraging (wacht); } } } void fullWhite() { for(uint16_t i=0; i

// Iets anders, hierdoor is de regenboog gelijkmatig verdeeld

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

for(j=0; j<256 * 5; j++) {// 5 cycli van alle kleuren op het wiel for(i=0; i<strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); } strip.show(); vertraging (wacht); } }

ongeldig regenboog1(uint8_t wacht) {

uint16_t i, j;

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

// Voer een waarde in van 0 tot 255 om een kleurwaarde te krijgen.

// De kleuren zijn een overgang r - g - b - terug naar r. uint32_t Wheel1(byte WheelPos) { WheelPos = 255 - WheelPos; if (WheelPos < 85) { retourstrip. Kleur (255 - WheelPos * 3, 0, WheelPos * 3, 0); } if(WheelPos < 170) { WheelPos -= 85; retourstrip. Kleur (0, WheelPos * 3, 255 - WheelPos * 3, 0); } WielPos -= 170; retourstrip. Kleur (WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t rood(uint32_t c) {

retour (c >> 16); } uint8_t green(uint32_t c) { return (c >> 8); } uint8_t blue(uint32_t c) { return (c); }

Stap 8: 3D-ontwerp

Eerst moet u uw hardwarecomponenten op maat maken om zeker te zijn van de juiste. Als ze hetzelfde zijn als de onze, kunt u dezelfde bestanden gebruiken die we u lenen.

Beide steunen zijn ontworpen met een 3D-printer, die ook worden meegeleverd als:

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

Ten slotte zal het licht zijn zoals op de twee laatste foto's.

Stap 9: De nek monteren

Eerst plaatsen we het zadel op de nek. De gaten die de schroeven nodig hebben om het vast te houden zijn er niet, dus we zullen ze moeten maken, markeren waar ze moeten komen en voorzichtig, met een boor, het gat maken.

Hetzelfde geldt voor de gaten waar de schroeven die de hals zelf vasthouden aan de body van het instrument zitten. Het is niet nodig om ze te doen, omdat er geen schroeven zijn voor deze bevestiging, maar als we het willen doen, zou er geen probleem zijn.

BELANGRIJK: laat 5mm ruimte tussen het begin van de mast en het begin van de stemvork, want in dat gat komt de moer te zitten.

We lijmen de moer met lijm, in de richting die wordt aangegeven door de afbeelding.

Ten slotte zullen we de 4 pinnen in de gaten aan het begin van de mast introduceren, waarbij elke pin met 2 korte schroeven wordt vastgehouden, zoals weergegeven in de afbeelding.

Stap 10: De Birdge monteren

De brug wordt vastgezet door middel van lijmen en met de twee lange schroeven centraal op de carrosserie. Het is raadzaam om met een potlood de juiste positie in het lichaam te markeren. We nemen de afstanden die in de afbeelding zijn gemarkeerd.

We zullen lijm aanbrengen op de verbinding van de twee componenten. We fixeren de twee delen voorzichtig met behulp van een spanschroef totdat de voeg is opgedroogd. We maken de twee gaten voor de schroeven met een boor van 1,5 mm voor hout. Bevestig de brug met de twee lange schroeven in de body. En tot slot plaatsen we de beschermkappen op de koppen van de schroeven.

Stap 11: Lichaams- en nekmontage

Om de twee delen te monteren, hebben we gaten in het hoofd van het lichaam, waar de nek zal passen met twee uitsteeksels die het heeft. We kunnen ze lijmen met lijm of met het hotmeltpistool. Om een grotere fixatie te hebben, kunt u de gaten aan het uiteinde van de stemvork maken om deze aan het lichaam te bevestigen.

Stap 12: Zet de ukelele-snaren

Als laatste moeten we de snaren zo plaatsen dat ons instrument af is.

Voorheen steken we de bevestigingsringen van de pennen in de uitsteeksels hiervan die door de mast gaan. Om de snaren te plaatsen, namen we de 4 snaren die bij de kit werden geleverd. Eerst moet je elke string onderscheiden omdat ze niet allemaal hetzelfde zijn. Je moet het ene uiteinde van elke snaar vastbinden (de twee dikke met een normale knoop en de twee dunne met een dubbele) en de snaren in de sleuven van de brug steken.

Dan gaan we de strings zo plaatsen dat:

• Eerste positie: G-snaar (tweede dikste snaar).

• Tweede positie: C-snaar (dikkere snaar).

• Derde positie: mi-snaar (tweede dunnere snaar).

• Vierde positie: A string (dunnere string).

Rijg de snaren in de gaten van de meegeleverde plug. Probeer elk touw vast te maken door twee of drie slagen op de pin te geven. Span de snaren zonder teveel kracht uit te oefenen en controleer de afstand tussen de snaren en het zadel.

Als je twijfelt over hoe je dat maakt, kun je die tutorial bekijken die je uitlegt hoe je de snaren correct plaatst.

Stap 13: Testen

Ten slotte moeten we kijken of de ukelele goed is gemonteerd, zodat de ideale afstand op de eerste fret 0,1 mm is en op de twaalfde ongeveer 1,2 mm.

Het is nodig dat u de snaren van de ukelele stemt. Ik raad je deze app aan: GuitarTuna

Stap 14: Geniet ervan

Nu hoef je alleen nog maar te genieten van je ukelele.

Als u meer informatie over ons wilt weten, kunt u ons vinden in:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Website: Innovart.cc