Ukulélé électronique intelligent bricolage avec Arduino: 14 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Nous allons expliquer étape par étape comment vous pouvez concevoir votre propre ukulélé et ajouter des effets qui le rendront unique, comme dessiner quelque chose que nous voulons sur la surface du ukulélé ou ajouter des effets de lumière.

Pour cela, il faut acheter un kit ukulélé.

Nous allons vous expliquer comment assembler l'instrument, et résoudre les différents problèmes qui peuvent apparaître.

Étape 1: Matériaux

Matériaux de structure:

Kit de montage d'ukulélé DIY (cela pourrait être un autre kit différent) formé par:

1- Corps.

2-cou.

3-Selle

Support à 4 cordes

5-Pont

Écrou à 6 cordes.

7-Bague de fixation pour tête de machine (x4).

8-Machines têtes (x4).

9-Vis de fixation pour têtes de machine (x8).

10-Vis de fixation pour pont machine (x2).

11-Cache-couvercles pour vis de montage du pont (x2).

12 cordes (x4).

Matériel électronique:

• NANO Arduino.
• Roue de Leds WS2812.
• Accéléromètre BMA220 (en option).
• Connecteur de batterie.
• Batterie de 9V.
• Changer.

Autres

• Vernis à bois.
• Velcro.
• Étain à souder.
• Plastique de protection pour le vernissage.
• Silicone thermofusible.

Outils:

• Gravure laser.
• Papier de verre
• Tournevis étoile.
• Pinceau.
• Pistolet thermofusible.
• Fer à souder à l'étain.

Étape 2: Personnalisez le ukulélé

Pour personnaliser notre ukulélé nous pourrions faire une gravure d'un dessin avec un cutter laser sur le corps. Dans le cas de ne pas avoir cet outil, nous pourrions le peindre.

L'image que nous avons choisie est la première qui apparaît.

Tout d'abord, nous devons concevoir le gabarit de dessin pour faire la gravure.

Pour ce faire, nous utiliserons un logiciel appelé 'Inkscape' que nous pourrions obtenir à partir de ce lien:

Pour l'utiliser, nous devons ajuster l'image que nous voulons utiliser comme nous le montrons dans la deuxième image. Vous pourriez regarder que nous avons fait pivoter l'image initiale pour pouvoir ajuster le cycle de la main avec le cercle de l'instrument. Comme nous l'avons déjà dit, vous pouvez mettre n'importe quelle image.

Étape 3: Vectoriser une image à l'aide d'Inkscape

Nous verrons comment créer un fichier vectoriel à partir d'une pixmap (jpg, png, quel que soit le format raster qu'Inkscape peut ouvrir).

Inkscape Inkscape est un éditeur de graphiques vectoriels open source, et comme son titre l'indique, c'est l'outil que j'utiliserai pour vectoriser les logos. Etapes de vectorisation Les étapes sont communes à toute vectorisation que nous souhaitons réaliser.

1. Ouvrir l'image dans Inkscape
2. Ouvrez l'outil Trace Bitmap Path->Trace Bitmap
3. Jouez avec les options Trace Bitmap
4. Exécuter le traçage
5. Nettoyer les résultats (si nécessaire)

Notez la partie « jouer autour ». Je ne suis pas un expert en traçage, donc je traite cet outil comme une boîte noire avec des boutons et des lumières, tournant et changeant jusqu'à ce que j'obtienne le meilleur résultat

Étape 4: Gravure de logo

Pour cela, il est important d'avoir une silhouette de la surface sur laquelle la gravure du dessin sera réalisée.

Pour réaliser la gravure, nous allons utiliser le logiciel 'T2Laser'. Nous pourrions obtenir ce logiciel à partir de:

Une fois que nous avons ouvert le logiciel, nous devons charger l'image que nous avons créée à la dernière étape. Ensuite, appuyez sur le bouton "contrôle laser", et apparaît les commandes cnc. Les deux photos montrent le processus et le résultat de la gravure avec notre découpeuse laser.

Étape 5: ponçage et vernissage

Pour laisser notre ukulélé brillant et avec une couche sans rugosité nous pouvons poncer en douceur les deux parties qui composent notre instrument avec soin, car nous pouvons endommager le dessin qui a été fait (si vous avez choisi de peindre le ukulélé, il faudrait poncez-le d'abord). Ensuite on va vernir nos deux parties pour qu'elles obtiennent une couleur plus foncée et que le bois présente plus de résistance. On peut utiliser un vernis à bois normal, il n'a pas besoin d'être spécial.

Une fois qu'on a le vernis, on le mélange avec un peu de solvant pour qu'il se dissolve un peu. Ensuite, on applique le mélange au pinceau sur le manche et le corps de l'instrument et on le laisse sécher.

Si on constate que le produit a besoin d'une seconde couche, on peut poncer un peu les deux parties et réappliquer une couche de vernis dilué.

** PRÉCAUTIONS: Le vernis est un produit chimique, il est donc nécessaire d'effectuer ce procédé dans un endroit aéré, de porter un masque pour éviter d'inhaler les odeurs et des lunettes de protection.

Les matériaux dont nous avons besoin pour pouvoir travailler correctement sont ceux qui apparaissent sur les photos. On travaillera principalement avec un pinceau, un pot de vernis (dans notre cas de couleur rouge), un peu de solvant et une protection visuelle. Et surtout travailler dans des espaces bien aérés.

Étape 6: Matériel

Notre plaque avec l'Arduino, l'accéléromètre et la roue à leds vont être introduits dans un petit support pour éviter que tous les composants bougent dans l'instrument.

Nous avons également ajouté un support de batterie et un interrupteur pour le rendre plus confortable et nous n'usons pas la batterie lorsque nous n'utilisons pas l'instrument. On va fixer ce support avec un morceau de velcro (ça marcherait aussi avec du silicone et un pistolet thermofusible) sur la face intérieure du corps du ukulélé. Par contre, la roue LED est plus petite que le trou, donc elle tomberait. Un support a été conçu pour qu'il tienne bien et puisse remplir sa fonction.

Étape 7: Logiciel

Pour donner une décoration particulière à notre ukulélé, nous avons pu ajouter des effets lumineux grâce à une roue de leds. Nous allons utiliser le WS2812, mais vous pouvez en utiliser un autre en suivant les instructions de la fiche technique. Nous utiliserons également un accéléromètre (BMA220) qui nous permettra de faire un effet de la gravité.

En fait, nous aurons 4 jeux de lumière, inclus dans la bibliothèque informatique appelée 'Adafruit' d'Arduino. Pour cela, nous devons faire une connexion correcte entre les trois composants: Arduino NANO, WS2812 et BMA220, comme apparaît dans la première image.

Les fils rouges sont pour l'alimentation, les noirs GND et le reste sont des connexions nécessaires au bon fonctionnement. Le code que nous avons utilisé pour le kit d'éclairage est joint dans un fichier appelé "play_of_light_v0.ino". Assurez-vous d'avoir inclus les bibliothèques nécessaires au bon fonctionnement du programme. La batterie que nous ajoutons à l'extérieur du circuit doit avoir une tension minimale de 9V et nous devons nous assurer qu'elle est capable de fournir le courant minimum nécessaire pour alimenter l'ensemble du circuit.

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

octet Version[3];

int8_t x_data; int8_t y_data; int8_t z_data; plage d'octets=0x00; flottant divi=16; flotter x, y, z; flottant pi = 3,14159265359; flotteur nx, ny, angle; int led, précédenteLed; QueueList ledQueue; Adafruit_NeoPixel neoring = Adafruit_NeoPixel(NUMBER_OF_LEDS_ON_RING, NEOPIXEL_RING_DATA_PIN, NEO_GRB + NEO_KHZ800);

//Variables Luces arcoiris

#include #ifdef _AVR_ #include #endif #define PIN 9 // Paramètre 1 = nombre de pixels dans la bande // Paramètre 2 = numéro de broche Arduino (la plupart sont valides) // Paramètre 3 = drapeaux de type de pixel, additionnez si nécessaire: // NEO_KHZ800 800 KHz Bitstream (la plupart des produits NeoPixel avec LED WS2812) // NEO_KHZ400 400 KHz (pixels FLORA classiques 'v1' (pas v2), pilotes WS2811) // Les pixels NEO_GRB sont câblés pour le bitstream GRB (la plupart des produits NeoPixel) / / Les pixels NEO_RGB sont câblés pour le flux binaire RGB (pixels FLORA v1, pas v2) // Les pixels NEO_RGBW sont câblés pour le flux binaire RGBW (produits NeoPixel RGBW) Bande Adafruit_NeoPixel = Adafruit_NeoPixel (16, PIN, NEO_GRB + NEO_KHZ800); // IMPORTANT: pour réduire le risque d'épuisement de NeoPixel, ajoutez un condensateur de 1 000 uF entre les fils d'alimentation // des pixels, ajoutez une résistance de 300 à 500 ohms sur l'entrée de données du premier pixel // et réduisez la distance entre Arduino et le premier pixel. Évitez de connecter // sur un circuit sous tension… si vous le devez, connectez d'abord GND.

//Variables Rueda de colores

// NeoPixel Ring simple sketch (c) 2013 Shae Erisson // publié sous licence GPLv3 pour correspondre au reste de la bibliothèque AdaFruit NeoPixel

#comprendre

#ifdef _AVR_ #include #endif

// Quelle broche de l'Arduino est connectée aux NeoPixels ?

// Sur un bibelot ou un Gemma, nous vous suggérons de le changer en 1 #define PIN 9

// Combien de NeoPixels sont attachés à l'Arduino ?

#define NUMPIXELS 16

// Lorsque nous configurons la bibliothèque NeoPixel, nous lui indiquons combien de pixels et quelle broche utiliser pour envoyer des signaux.

// Notez que pour les bandes NeoPixel plus anciennes, vous devrez peut-être modifier le troisième paramètre -- voir l'exemple // strandtest pour plus d'informations sur les valeurs possibles. Pixels Adafruit_NeoPixel = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int delayval = 50; // retard de 50ms

//Variables colores aleatorios

#include #ifdef _AVR_ #include #endif

#définir le code PIN 9

#définir NUM_LEDS 16

#définir LUMINOSITÉ 200

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

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

/RÉGLAGE MÉTOD

void setup() { //Código: Dirección de la gravedad neoring.begin(); neoring.setBrightness(200); Serial.begin(9600); Fil.begin(); Wire.beginTransmission (0x0A); // adresse de l'accéléromètre // paramètres de plage Wire.write(0x22); //enregistrer l'adresse Wire.write(range); //peut être défini sur "0x00""0x01""0x02""0x03", reportez-vous à Datashhet sur wiki // filtre passe-bas Wire.write(0x20); //enregistrer l'adresse Wire.write(0x05); //peut être défini sur "0x05""0x04"……"0x01""0x00", reportez-vous à Datashhet sur le wiki Wire.endTransmission();

//Codigo; Luces Arcoiris

// Ceci est pour Trinket 5V 16MHz, vous pouvez supprimer ces trois lignes si vous n'utilisez pas de Trinket #if défini (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Fin du code spécial de bibelot strip.begin(); strip.show(); // Initialise tous les pixels sur 'off'

//Código Rueda de colores

// Ceci est pour Trinket 5V 16MHz, vous pouvez supprimer ces trois lignes si vous n'utilisez pas de Trinket #if défini (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Code spécial de fin de bijou

pixels.begin(); // Ceci initialise la bibliothèque NeoPixel.

//Interruption Codigo

compteur = 1;

//Codigo Colores Varios

// Ceci est pour Trinket 5V 16MHz, vous pouvez supprimer ces trois lignes si vous n'utilisez pas de Trinket #if défini (_AVR_ATtiny85_) if (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // Fin du code spécial bibelot strip.setBrightness(BRIGHTNESS); strip.begin(); strip.show(); // Initialiser tous les pixels sur 'off' }

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

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

/Boucle infinie

void loop() { //Caso 1: Juego de luces de la gravedad; if(counter == 1){ for(int i=0;i 0.0){ if(nx 0.0) angle+=180; sinon angle += 360; }//end else if(angle == 360.0) angle = 0.0; led = circularize(angle / (360 / NUMBER_OF_LEDS_ON_RING)); // rend le mouvement de la led fluide if(previousLed == led){ // rien à faire } else if (counterClockwiseDistanceBetweenLeds(previousLed, led) <= 8) led = circularize(previousLed + 1); else led = circularize(previousLed - 1); ledQueue.push(led); makeLightShow(); précédenteLed = led; retard (25); } compteur = 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++){ // Quelques exemples de procédures montrant comment afficher aux pixels: colorWipe1(strip. Color(255, 0, 0), 50); // Rouge colorWipe1(strip. Color(0, 255, 0), 50); // Vert colorWipe1(strip. Color(0, 0, 255), 50); // Bleu colorWipe1(strip. Color(0, 0, 0, 255), 50); // White RGBW // Envoie une poursuite de pixels de théâtre dans… TheaterChase(strip. Color(127, 127, 127), 50); // Théâtre Chase blanc(strip. Color(127, 0, 0), 50); // Théâtre Chase rouge(strip. Color(0, 0, 127), 50); // Bleu

arc-en-ciel (5);

arc-en-ciel(5); théâtreChaseRainbow(5); } compteur = 3; }//End if counter==2 //Caso 3: Luces Aleatorias else if(counter == 3){ for(int k=0;k<50;k++){ // Pour un ensemble de NeoPixels le premier NeoPixel est 0, la seconde vaut 1, jusqu'au nombre de pixels moins un. int a=aléatoire(255); entier b=aléatoire(255); int c=aléatoire(255); for(int i=0;i

// pixels. Color prend les valeurs RVB, de 0, 0, 0 à 255, 255, 255

pixels.setPixelColor(i, pixels. Color(a, b, c)); // Couleur verte modérément brillante.

pixels.show(); // Ceci envoie la couleur de pixel mise à jour au matériel.

délai (valeur de délai); // Retard pour une période de temps (en millisecondes).

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

// pixels. Color prend les valeurs RVB, de 0, 0, 0 à 255, 255, 255

pixels.setPixelColor(i, pixels. Color(a, b, c)); // Couleur verte modérément brillante.

pixels.show(); // Ceci envoie la couleur de pixel mise à jour au matériel.

délai (valeur de délai); // Retard pour une période de temps (en millisecondes).

} } compteur = 4; } else if(counter == 4){ for(int g=0;g<=6;g++){ // Quelques exemples de procédures montrant comment afficher les pixels: colorWipe(strip. Color(255, 0, 0), 50); // Red colorWipe(strip. Color(0, 255, 0), 50); // Vert colorWipe(strip. Color(0, 0, 255), 50); // Blue colorWipe(strip. Color(0, 0, 0, 255), 50); // Blanc blancOverRainbow(20, 75, 5); pulseWhite(5); // fullWhite(); // retard (2000); arc-en-cielFade2White(3, 3, 1);

}

compteur = 1; } } ////////////////////////////////////////////// //////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////// //////////////////

/Metodos del Ejemplo de la gravedad

void AccelerometerInit() { Wire.beginTransmission (0x0A); // adresse de l'accéléromètre // réinitialiser l'accéléromètre Wire.write(0x04); // Données X Wire.endTransmission(); Wire.requestFrom (0x0A, 1); // demande 6 octets au périphérique esclave #2 while(Wire.available()) // l'esclave peut envoyer moins que demandé { Version[0] = Wire.read(); // reçoit un octet comme caractère } x_data=(int8_t)Version[0]>>2; Wire.beginTransmission (0x0A); // adresse de l'accéléromètre // réinitialiser l'accéléromètre Wire.write(0x06); // Données Y Wire.endTransmission(); Wire.requestFrom (0x0A, 1); // demande 6 octets au périphérique esclave #2 while(Wire.available()) // l'esclave peut envoyer moins que demandé { Version[1] = Wire.read(); // reçoit un octet comme caractère } y_data=(int8_t)Version[1]>>2; Wire.beginTransmission (0x0A); // adresse de l'accéléromètre // réinitialiser l'accéléromètre Wire.write(0x08); // Données Z Wire.endTransmission(); Wire.requestFrom (0x0A, 1); // demande 6 octets au périphérique esclave #2 while(Wire.available()) // l'esclave peut envoyer moins que demandé { Version[2] = Wire.read(); // reçoit un octet comme caractère } 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); // affiche le caractère Serial.print(" "); Serial.print("Y="); Serial.print(y); // imprime le caractère Serial.print(" "); Serial.print("Z="); // affiche le caractère Serial.println(z); }

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

distance int;

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

int ledPosition, currentQueueSize;

#define NUMBER_OF_LEDS_TO_SHINE 10 pas de luminosité int = 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

// Remplir les points les uns après les autres avec une couleur vide colorWipe(uint32_t c, uint8_t wait) { for(uint16_t i=0; i

void arc-en-ciel (uint8_t wait) {

uint16_t i, j;

pour(j=0; j<256; j++) { pour(i=0; je

// Légèrement différent, cela rend l'arc-en-ciel également réparti

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

for(j=0; j<256*5; j++) { // 5 cycles de toutes les couleurs sur la roue for(i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); } strip.show(); retarder (attendre); } }

//Lumières rampantes de style théâtre.

void TheaterChase(uint32_t c, uint8_t wait) { for (int j=0; j<10; j++) { //faire 10 cycles de poursuite pour (int q=0; q < 3; q++) { for (uint16_t i= 0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, c); //activer chaque troisième pixel } strip.show();

retarder (attendre);

pour (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); //désactiver chaque troisième pixel } } } }

//Lumières rampantes de style théâtre avec effet arc-en-ciel

void theatreChaseRainbow(uint8_t wait) { for (int j=0; j < 256; j++) { // cycle toutes les 256 couleurs dans la roue pour (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)); //activer chaque troisième pixel } strip.show();

retarder (attendre);

pour (uint16_t i=0; i < strip.numPixels(); i=i+3) { strip.setPixelColor(i+q, 0); //désactiver chaque troisième pixel } } } }

// Saisissez une valeur de 0 à 255 pour obtenir une valeur de couleur.

// Les couleurs sont une transition r - g - b - retour à 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); } RouePos -= 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

// Remplir les points les uns après les autres avec une couleur

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

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

pour(uint16_t i=0; je

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 cycles de toutes les couleurs sur la roue

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

}

//Première boucle, fondu enchaîné !

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

//Dernière boucle, fondu enchaîné !

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

strip.show();

retarder (attendre); } }

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

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

retard (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 queue = 0;

boucles int = 3;

int loopNum = 0;

long lastTime statique non signé = 0;

tandis que (vrai){

for(int j=0; j<256; j++) { for(uint16_t i=0; i= tail && i head && i >= tail) || (queue > tête && i <= tête)){ strip.setPixelColor(i, strip. Color(0, 0, 0, 255)); } else{ strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); } }

if(millis() - lastTime > whiteSpeed) {

tête++; queue++; if(head == strip.numPixels()){ loopNum++; } lastTime = millis(); }

if(loopNum == boucles) return;

head%=strip.numPixels(); queue%=strip.numPixels(); strip.show(); retarder (attendre); } } } void fullWhite() { for(uint16_t i=0; i

// Légèrement différent, cela rend l'arc-en-ciel également réparti

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

for(j=0; j<256 * 5; j++) { // 5 cycles de toutes les couleurs sur la roue for(i=0; i< strip.numPixels(); i++) { strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); } strip.show(); retarder (attendre); } }

void rainbow1(uint8_t wait) {

uint16_t i, j;

pour(j=0; j<256; j++) { pour(i=0; je

// Saisissez une valeur de 0 à 255 pour obtenir une valeur de couleur.

// Les couleurs sont une transition r - g - b - retour à 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); } RouePos -= 170; return strip. Color(WheelPos * 3, 255 - WheelPos * 3, 0, 0); }

uint8_t rouge (uint32_t c) {

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

Étape 8: Conception 3D

Tout d'abord, vous devez dimensionner vos composants matériels pour être sûr qu'ils sont corrects. S'ils sont identiques aux nôtres, vous pouvez utiliser les mêmes fichiers que nous vous prêtons.

Les deux supports ont été conçus avec une imprimante 3D, qui sont également inclus en tant que:

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

Enfin, la lumière sera comme les deux dernières photos.

Étape 9: Montage du cou

Nous allons d'abord placer la selle sur le cou. Les trous dont les vis ont besoin pour le maintenir ne sont pas là, nous devrons donc les faire, en marquant où ils doivent aller et soigneusement, avec une tarière, en faisant le trou.

Il en va de même pour les trous où se trouvent les vis qui maintiennent le manche lui-même au corps de l'instrument. Il n'est pas nécessaire de les faire, car il n'y a pas de vis pour cette fixation, mais si nous voulons le faire, il n'y aurait aucun problème.

IMPORTANT: laissez 5 mm d'espace entre le début du mât et le début du diapason, car dans ce trou l'écrou sera placé.

Nous allons coller l'écrou avec de la colle, dans le sens indiqué par la figure.

Enfin, nous allons introduire les 4 broches dans les trous qui se trouvent au début du mât, en maintenant chaque broche avec 2 vis courtes comme indiqué sur l'image.

Étape 10: Montage du Birdge

Le chevalet est fixé par collage et avec les deux vis longues en position centrale sur le corps. Il est conseillé de marquer avec un crayon la position correcte dans le corps. Nous allons prendre les distances qui sont marquées dans l'image.

Nous appliquerons de la colle à l'union des deux composants. On fixe soigneusement les deux parties à l'aide d'une vis de serrage jusqu'à ce que le joint soit sec. Nous allons faire les deux trous pour les vis avec un foret de 1,5 mm pour le bois. Fixez le pont avec les deux vis longues dans le corps. Et enfin, nous mettons les capuchons de protection sur les têtes des vis.

Étape 11: Assemblage du corps et du cou

Pour assembler les deux parties, nous avons des trous dans la tête du corps, où le cou s'adaptera avec deux projections dont il dispose. Nous pouvons les coller avec de la colle ou avec le pistolet thermofusible. Pour avoir une plus grande fixation, vous pouvez faire les trous qui se trouvent au bout du diapason pour le joindre au corps.

Étape 12: Mettez les cordes du ukulélé

Enfin nous devons placer les cordes pour que notre instrument soit fini.

Auparavant on insèrera les bagues de fixation des goupilles dans les saillies de celles-ci qui traversent le mât. Pour placer les cordes, nous avons pris les 4 cordes fournies avec le kit. Il faut d'abord distinguer chaque chaîne car elles ne sont pas toutes identiques. Vous devez attacher une extrémité de chaque corde (les deux épaisses avec un nœud normal et les deux fines avec un double) et insérer les cordes dans les fentes du chevalet.

Ensuite, nous placerons les cordes de telle sorte que:

• Première position: corde de sol (deuxième corde la plus épaisse).

• Deuxième position: chaîne C (chaîne plus épaisse).

• Troisième position: corde de Mi (deuxième corde plus fine).

• Quatrième position: Une chaîne (chaîne plus fine).

Enfilez les ficelles dans les trous du bouchon fourni. Essayez de fixer chaque corde en donnant deux ou trois tours sur la goupille. Tendez les cordes sans trop forcer et vérifiez la distance entre les cordes et le sillet.

Si vous avez des doutes sur la façon de faire cela, vous pouvez consulter ce tutoriel qui vous explique comment mettre correctement les cordes.

Étape 13: Tester

Enfin, il faut voir si le ukulélé a été correctement assemblé de telle sorte que la distance idéale sur la première frette soit de 0,1 mm et sur la douzième elle soit d'environ 1,2 mm.

Il faut que vous accordiez les cordes du ukulélé. Je vous recommande cette application: GuitarTuna

Étape 14: Profitez-en

Maintenant, vous n'avez plus qu'à profiter de votre ukulélé.

Si vous souhaitez en savoir plus sur nous, vous pouvez nous trouver sur:

Twitter: @Innovart_cc

Facebook: @Innovartcc

Instagram: @Innovart_cc

Web: Innovart.cc