Comment construire un ukulélé lumineux ! : 21 étapes

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

Je joue du ukulélé. Un peu médiocre (si c'est un mot) alors j'ai pensé: "si vous voulez vraiment impressionner les dames, vous avez besoin d'un moyen de les distraire du désastre qui se joue sur scène." C'est ainsi que le "Light-up Ukulele" est né.

Ce projet prend un kit Concert Ukulele et ajoute une LED contrôlée par Arduino à chaque position de corde et de frette. Il ajoute également un écran OLED sophistiqué et une interface utilisateur basée sur un encodeur rotatif pour sélectionner le mode et l'intensité de la chaîne LED.

Les fonctionnalités matérielles uke terminées:

1. Arduino MICRO pour interfacer avec la chaîne LED, l'affichage et le périphérique d'entrée.
2. 48 LED polychromes programmables individuellement
3. Un écran OLED
4. Un encodeur rotatif pour la saisie de l'utilisateur
5. Interface USB pour alimentation externe et programmation Arduino

Le logiciel uke a:

1. Modes de contrôle de la lumière de base qui font fonctionner les LED à leur rythme
2. Un mode chapiteau de théâtre astucieux (très pratique pour les représentations !)
3. Contrôle d'intensité LED
4. Une bibliothèque complète d'accords de tous les accords d'ukulélé de première position (valeur et caractère de l'accord)
5. Possibilité d'afficher du texte courant (verticalement) à l'aide d'un jeu de caractères unique de 4 x 6 pixels

Cette instructable décrit le prototype terminé. La saga complète du développement est disponible ICI, y compris quelques erreurs éducatives (douloureuses) et une leçon précieuse sur les raisons pour lesquelles vous DEVEZ terminer votre première conception jusqu'à la fin (peu importe à quel point les choses deviennent laides). Vous ne savez jamais toutes les choses que vous ne savez vraiment pas jusqu'à ce que vous arriviez à la fin (et vous ne savez toujours pas !), mais vous êtes beaucoup mieux loti et beaucoup plus intelligent pour le prochain design.

J'ai construit le prototype autour d'un kit Grizzly Concert Ukulele. Commencer avec un kit soulage les soucis concernant le corps de l'uke (enfin, la plupart du temps), et élimine la plupart du vrai travail de luthier. Ces kits sont assez complets et pas si chers que ça dans le grand schéma des choses (et moins douloureux puisque vous ferez des erreurs).

Étape 1: faire un plan

Le manche (ou la touche) inclus dans certains kits ont déjà les frettes attachées. C'est bon/mauvais. C'est bien comme gain de temps, mais pour ce qui est de tracer un gabarit de perçage et de le maintenir en place pendant le fraisage, c'est un peu pénible. Après avoir détruit celui fourni dans le kit, j'ai opté (enfin, je n'avais pas d'autre choix que d'acheter un autre kit) d'acheter un nouveau manche.

Lors de la conception du manche, il faut calculer l'augmentation d'épaisseur nécessaire pour encastrer le PCB et les LED (et ne pas oublier les composants passifs), mais pas tant que les LED sont trop éloignées de la surface du manche.

La carte de circuit imprimé à LED (PCB) est conçue comme une simple carte à 2 couches. Cela aide beaucoup à l'assemblage à la main de la chaîne LED et fournit une certaine résistance mécanique (c'est de la fibre de verre et de l'époxy) au manche du ukulélé. J'ai commencé la mise en page dans Eagle, mais j'ai fini par utiliser Altium Designer en raison des limitations de la taille de la carte. Le schéma Altium et les fichiers PCB sont ici.

Le manche du kit n'avait que 0,125 pouce d'épaisseur. Ainsi, en supposant un PCB de 0,062 pouce d'épaisseur et en autorisant 0,062 pouce supplémentaire pour les LED, cela signifie que nous aurions à découper beaucoup (comme dans tous) du manche. Pour compenser, nous pouvons soit couper partiellement les poches pour les LED dans le manche avec une poche correspondante dans le manche pour le PCB, soit remplacer l'ensemble du manche (l'option avec laquelle j'ai opté) par une version plus épaisse de Luther Mercantile International (LMII), qui sont de 0,25 pouces pour commencer.

MAIS, rappelez-vous que vous devrez toujours usiner le manche pour compenser l'augmentation d'épaisseur de la touche. L'autre avantage que vous obtenez est esthétique, puisque le PCB est maintenant complètement intégré à l'intérieur du manche, ce qui rend les bords beaucoup plus faciles à finir (et beaucoup plus beaux !) et simplifie le fraisage du manche.

Trucs d'ingénierie (ignorez si vous voulez):

Soit dit en passant, cela ne compromet pas vraiment la rigidité du cou. Le matériau PCB est beaucoup plus rigide que le bois de la touche d'origine (module d'acajou: 10,6 GPa contre module FR4: 24 GPa), et puisque nous construisons un ukulélé, il n'y a pas une énorme quantité de tension de corde qui pourrait autrement déformer (torsion ou déformer) le cou.

Une considération très intéressante (que je devrais probablement encore calculer) est ce qui se passe au-dessus de la température. De manière générique pour le bois, parallèle au fil, le coefficient de dilatation thermique est d'environ 3 x 10^-6/K, et pour FR4 il est de 14×10^−6/K. Donc, il y a une différence assez importante. Le problème est que la tension est créée dans le manche lorsque la température varie, ce qui à son tour désaccorde les cordes. C'est quelque chose qui pourrait être compensé en appliquant une couche similaire sur le côté opposé de l'axe neutre ou en rapprochant le FR4 le plus possible de l'axe neutre. Mais cela restera pour 2.0… Quelque chose à modéliser et à évaluer.

L'électronique est logée dans le corps de l'uke. Des trous sont découpés dans la paroi latérale (pas la table d'harmonie !) La conception et l'emplacement de la plaque d'accès / du support pourraient probablement être améliorés pour que la connexion USB soit plus pratique, mais en l'état, ce n'est pas si mal, car cela ne vous gêne pas lorsque vous jouez.

Le schéma des étapes est le suivant:

1. Rassembler des matériaux
2. Obtenez les outils dont vous avez besoin
3. Fraiser le manche pour s'adapter à la touche plus épaisse
4. Fraisez le manche pour faire des trous aux emplacements requis et pour créer des poches pour la planche et les LED
5. Obtenir et construire le PCB contenant les LED
6. Fraisez les trous d'accès dans le corps du ukulélé pour l'écran OLED, l'encodeur rotatif et le panneau d'accès
7. Fabriquer des plaques de recouvrement
8. Attachez les fils au PCB; connecter et tester l'électronique
9. Attachez le cou au corps du ukulélé
10. Percez une cale d'accès pour faire passer les fils PCB dans le corps
11. Alignez et collez le PCB et le manche sur le manche
12. Niveler les bords de la touche au manche (retirer l'excès de matière)
13. Installer les fils de frette
14. Appliquer le masquage et appliquer la finition sur le ukulélé
15. Aligner et attacher le pont
16. Installez l'électronique et testez.
17. Installez les accordeurs et cordez l'instrument
18. Programmer le contrôleur Uke
19. Surprenez le monde avec votre génialité Ukulélé !

Étape 2: Rassemblez les matériaux

Notre liste de matériaux ressemble à ceci:

1. Kit ukulélé - J'ai utilisé un kit Grizzly Concert Ukulele (Grizzly Uke Kit sur Amazon), mais cela semble être abandonné. Zimo fabrique un modèle similaire (Zimo Uke Kit @ Amazon) qui semble faire le travail
2. Touche ukulélé, pré-fendue (touches LMII Uke). Ils emboîteront le manche sur votre échelle, ce qui vous évitera des ennuis
3. Epoxy - pour coller la touche au manche. J'ai choisi l'époxy car il est compatible avec le matériau PCB. Recherchez quelque chose avec au moins 60 minutes de vie professionnelle. N'utilisez PAS de types de 5 minutes, vous avez besoin de temps pour faire des ajustements
4. Fils de frette - également disponibles chez LMII
5. PCB personnalisé - Les fichiers Altium sont ici. J'ai opté pour du matériel de type FR4 normal. Les panneaux Flex (polyimide) seraient une alternative intéressante (bien que plus chère), car ils peuvent être beaucoup plus minces
6. 48x LED Neopixel (SK6812). Disponible chez Adafruit et Digikey
7. 48x 0.1uF 0402 caps - plus grand est acceptable, mais vous devez surveiller le placement
8. Fil de raccordement - au moins 4 à 6 couleurs pour éviter toute confusion, j'ai utilisé principalement du fil de calibre 28. Regardez la chute de courant continu sur les connexions d'alimentation LED (à la fois VCC et GROUND… ce courant doit retourner à la source !)
9. Encodeur rotatif - PEC16-4220F-S0024
10. Bouton en bois fantaisie - pour l'encodeur rotatif (j'ai eu le mien de LMII)
11. Écran OLED - des écrans OLED des systèmes 4D
12. Batterie USB externe - moins chère tout le temps, en plus vous pouvez emporter des pièces de rechange !
13. Arduino MICRO
14. Feuille de laiton - pour faire la plaque pour tenir l'arduino et la lunette pour l'affichage
15. Consommables divers incluant: papier de verre, finition uréthane, bâtonnets de popsicle, élastiques, soudure, flux, brosses, ruban adhésif double face (j'aime le ruban UHC de 3M) et petites vis à bois en laiton (pour la plaque)
16. Améliorations optionnelles du ukulélé - meilleurs accordeurs, meilleures cordes, meilleurs écrou et selle, incrustation si vous voulez montrer vos prouesses de luthier)

Étape 3: Obtenez les outils dont vous avez besoin

Tôt ou tard, vous devrez obtenir ou accéder à ceux-ci:

Notre liste d'outils comprend:

1. Fraiseuse - CNC de préférence, mais vous pourriez même vous en tirer avec un routeur et beaucoup de chance. J'ai utilisé un combo fraiseuse/routeur CNC
2. Fraises de toupie - carbure préféré. Mèches de toupie choisies par rapport aux fraises en bout car nous usinons du bois, pas du métal
3. Pinces - beaucoup d'entre elles. Surtout nécessaire pour maintenir les pièces pendant le collage
4. Fer à souder - petite pointe pour le soudage en surface
5. Microscope ou loupe - vous pouvez essayer de souder avec seulement vos yeux, mais je ne le recommanderais pas, 10x minimum
6. Pince à épiler (pour mettre les pièces en place)
7. Outils de frettage (voir les outils appropriés sur LMII ici, mais j'ai utilisé ce que j'avais à la maison et j'ai fait faire; marteaux, limes et couteaux)
8. Outils à main assortis tels que des ciseaux à bois, des tournevis, un coup doux ou un marteau en cuir brut (pour le frettage), etc.
9. Abrasifs - divers grains de papier de verre

Nos outils logiciels incluent (certains sont facultatifs selon votre budget/ingéniosité):

1. Logiciel Arduino
2. Le code source du ukulélé (https://github.com/conrad26/Ukulele)
3. Package de mise en page PCB - J'ai utilisé Altium car la version gratuite d'Eagle ne prenait pas en charge la taille de carte que je voulais. Altium est un package de mise en page complet et pas vraiment dans une gamme de prix pour les amateurs. J'ai inclus les fichiers Gerber sur mon site pour le prototype, mais ceux-ci ont certainement besoin d'une mise à jour
4. Logiciel de modélisation 3D - J'ai utilisé SolidWorks, mais une alternative gratuite est FreeCAD (https://www.freecadweb.org/)
5. Logiciel de FAO - comme FeatureCAM d'Autodesk pour créer le fichier de fraisage CN.

La combinaison de l'exportation de fichiers pas à pas 3D depuis Altium avec un modèle 3D du manche élimine une grande partie de la difficulté à s'assurer que tout s'aligne, mais ce n'est pas une exigence. Une mise en page soignée permettra d'obtenir le même résultat.

Maintenant que nous savons ce que nous voulons faire et ce dont nous avons besoin pour le faire, construisons un ukulélé.

Étape 4: Fraisez le manche pour s'adapter à la touche plus épaisse

Avant le fraisage, notez que la planéité de la surface de montage de la touche d'origine DOIT être maintenue, sinon vous allez avoir une touche tordue, ce qui entraîne toutes sortes de problèmes avec le nivellement des frettes.

N'y allez pas, prenez votre temps et serrez soigneusement et fermement le col et vérifiez l'alignement avec la fraise sur tout le col avant de couper. Le temps passé ici vous évitera bien des soucis plus tard.

L'une des raisons pour lesquelles j'ai opté pour une touche plus épaisse plutôt qu'une incrustation dans le manche était l'augmentation de la surface de montage (collage). Une autre raison est qu'elle simplifie le fraisage du col. Vous coupez simplement toute la surface à la hauteur requise.

Étape 5: Obtenir et construire le PCB contenant les LED

J'ai soudé à la main tout l'assemblage. Les emballages LED sont particulièrement faciles à fondre, alors prenez soin de ne pas les endommager. Je suggère de porter une sangle statique, car la chaîne dépend du fonctionnement de chaque LED.

La conception du manche est basée sur les LED WS2812B. J'ai décidé de ne faire que la première octave du manche (48 LED !!). Chaque LED peut être considérée comme un bit dans un registre à décalage. Le registre à décalage est cadencé à 800 kHz. J'ai utilisé la bibliothèque Adafruit (voir la section programmation) pour que les choses soient opérationnelles rapidement.

J'ai commencé la conception dans Eagle, mais la taille de la carte est limitée à environ 4 x 5 pouces, j'ai donc dû (ou plus correctement, j'ai choisi) passer à Altium. J'utilise Altium au travail, donc en réalité, cela m'a rendu les choses plus rapides. Le projet Altium, les fichiers schématiques et pcb (et les pièces de bibliothèque) sont sur mon site. La planche est de forme trapézoïdale et mesure environ 10 pouces de long. Je pense que j'aurais dû essayer de compresser un peu plus le contour (tour suivant!) L'assemblage n'était pas mauvais, mais si vous pouvez vous le permettre, je recommande vraiment un fer à souder décent (JBC Soldering Irons) et un bon microscope. Ouais, je suis gâté et non, je n'ai pas ce genre de trucs dans mon labo à la maison. Je suis bon marché.

J'ai fait fabriquer les planches à Sunstone. 129 $ pour deux planches. Tour d'une semaine garanti. Ne lésinez pas sur l'expédition cependant. Je n'ai pas remarqué que j'utilisais UPS Ground et j'ai fini par attendre une semaine supplémentaire pour que mes planches arrivent. Le temps d'assemblage total était d'environ 2 heures (98 pièces).

Étape 6: fraiser le manche

Nous devons fraiser le manche pour faire des trous aux emplacements requis et pour créer des poches pour la planche et les LED.

J'ai créé un modèle 3D du manche terminé dans Solidworks et créé la routine de fraisage CNC à l'aide de FeatureCAM.

La partie inférieure de la touche (la plus proche de la rosace) devra être affinée pour tenir compte du changement de hauteur entre le manche et le corps. Cela vaut vraiment la peine de tester plusieurs fois l'ajustement pour être sûr que c'est un ajustement raisonnablement ajusté.

Rétrospectivement, j'aurais dû couper les parties inutilisées du manche pour qu'il s'adapte mieux au moulin (mon moulin bon marché n'avait qu'une course sur l'axe X de 12 ). L'ordre des opérations doit être défini pour les premiers ajustements d'épaisseur du moulin avant fraisage des poches, ce qui devrait conduire à moins de cassures entre les poches.

Effectuez les réglages manuels nécessaires pour ajouter de l'espace pour le câblage. Une chose importante à noter est que dans certaines des poches, j'ai percé la fente où ira le fil de frette. Étant donné qu'il s'agit d'un conducteur, assurez-vous qu'il ne court-circuite rien d'important. Cela diminue également la résistance du matériau qui maintient la frette en place. La conception doit être modifiée pour ne jamais croiser une fente de frette.

Étape 7: Fraisez les trous d'accès dans le corps du ukulélé

J'ai fraisé manuellement les trous d'accès dans le corps. La partie la plus difficile est de trouver la région "la plus plate" de ce qui est une surface très incurvée. Marquez le contour au crayon et fraisez progressivement le matériau jusqu'à ce que vous obteniez un ajustement parfait pour l'écran OLED. J'ai obtenu une lunette en laiton usinée et je l'ai fixée à l'aide de ruban adhésif 3M VHB.

Comme aucun des deux ne nécessite une grande précision, les trous de l'encodeur rotatif et du panneau d'accès sont beaucoup plus faciles à créer.

Étape 8: Fabriquez des plaques de recouvrement

Vous devez également fabriquer les plaques de recouvrement du cadre de l'écran et du panneau d'accès. Le panneau d'accès a besoin d'un trou (rectangulaire) pour le connecteur USB (micro). Utilisez simplement le connecteur existant sur l'Arduino, car il n'y a pas beaucoup d'options de montage sur panneau pour micro USB. (bien que si je concevais à partir de zéro, alors je donnerais un coup d'œil à l'un d'entre eux)

Pour maintenir la carte en place, façonnez des supports en L en laiton et soudez-les à l'arrière de la plaque d'accès. Cela vous laisse une certaine latitude dans le positionnement. Pour obtenir le bon positionnement, créez d'abord une carte de montage perfboard (avec des trous de montage) pour l'Arduino MICRO et fixez-y les supports en L à l'aide de vis à métaux 2-56. Vous pouvez ensuite modifier l'emplacement pour aligner le port USB et marquer avec précision les emplacements des supports sur la plaque. Retirez les supports du panneau perforé et soudez-les en place. Enfin, montez l'ensemble de panneaux perforés.

J'ai utilisé quatre petites vis à bois en laiton pour maintenir le panneau d'accès en laiton en place.

À ce stade, je recommande un test d'ajustement avant le début de l'assemblage final. Cette étape est facultative mais recommandée. Il est beaucoup plus facile de faire des ajustements avant de coller.

Étape 9: attachez les fils au circuit imprimé; Connectez et testez l'électronique

Ne fixez pas encore l'électronique de façon permanente. Fixez les fils au PCB, en vous assurant de laisser suffisamment de mou pour acheminer le trou d'accès. Ceux-ci doivent éventuellement être attachés de manière permanente à la carte Arduino MICRO (les photos montrent un Arduino UNO, que j'ai utilisé pour le développement de code)

Étape 10: attachez le cou au corps du ukulélé

Attachez le cou au corps du ukulélé en suivant les instructions fournies avec le kit ukulélé. Surveillez particulièrement l'alignement de la surface de la touche sur le corps de l'uke.

Étape 11: percez un trou d'accès pour faire passer les fils PCB dans le corps

Une fois la colle sèche, percez un trou d'environ 10 mm (1/4 ) à un angle pour permettre aux fils du PCB de passer dans le corps du ukulélé. Assurez-vous de ne pas endommager la table d'harmonie.

Vous devrez peut-être également créer une petite poche pour tenir compte de l'épaisseur des fils sous la planche (ou éventuellement mettre les connexions sur le dessus et inclure un relief dans le manche.)

Un autre test d'ajustement ne ferait pas de mal à ce stade.

Étape 12: alignez et collez le PCB et le manche sur le manche

Je suggère de réfléchir au serrage (et de l'essayer !) avant de coller. Vous voudrez peut-être façonner un bloc en forme de dessous du cou pour vous donner une surface de serrage plate. Le manche est plus grand que le manche à ce stade, vous devez donc en tenir compte.

Faites très attention à ne pas mettre d'époxy sur les surfaces que vous souhaitez finir plus tard. Mieux encore, appliquez un masquage sur toutes les surfaces non collées avant de coller pour vous assurer qu'il ne va que là où vous le souhaitez.

Utilisez de l'époxy avec une durée de vie d'au moins 60 minutes… vous en aurez besoin de tout.

Collez d'abord le PCB en place, en vous assurant que l'excès de colle n'extrude pas dans la surface de collage de la touche. Cela fournit une méthode pour aligner le manche sur le manche. Le PCB a une finition de masque de soudure lisse, je l'ai donc rugueux avec un peu de papier de verre pour donner à l'époxy une finition de surface légèrement améliorée.

Alignez et collez la touche sur le manche. Attention à ne pas laisser de poches qui pourraient par la suite devenir résonnantes (buzz !). Veillez également à ne pas mettre de colle sur les surfaces LED.

Une fois que la colle est sèche, vous pouvez câbler et tester l'électronique une fois de plus. Une mauvaise LED vous fera détester la vie. J'avais une mauvaise LED (la première!)

Étape 13: Niveler les bords de la touche au manche et ajouter des fils de frette

Une fois la colle sèche, vous pouvez commencer à finir les bords. J'ai soigneusement coupé l'excès de matériau de la touche (à l'aide d'un moulin) et j'ai fini le dernier millimètre par ponçage à la main.

L'ajout des fils de frette peut se faire simplement avec un marteau (avec une face en plastique pour éviter les rayures). Ne frappez pas trop fort. Si vous avez fait correspondre le fil de frette aux fentes, ils devraient entrer sans trop de difficulté.

La chose que vous devez surveiller est de casser la fine surface de la poche LED. Sur le prototype, j'ai laissé les poches LED (près de la 12e frette, où l'espace devient restreint) s'étendre dans la fente de la frette. C'est une mauvaise idée, car cela crée un point faible qui peut (et a fait) se fissurer une fois le fil de frette inséré.

Étape 14: Appliquez le masquage et appliquez la finition sur le ukulélé

Masquez le manche (il n'a pas de finition) et la zone de collage du chevalet et commencez à appliquer la finition.

Lorsque vous masquez la zone du pont, lisez les instructions avec votre kit, puis vérifiez la longueur de l'échelle juste pour être sûr. Le kit que j'ai utilisé pour le prototype utilisait la mauvaise longueur d'échelle et fournissait donc les mauvaises dimensions pour localiser le pont (mais il y avait une note pour consulter le site Web pour les dernières instructions !). Mon instinct m'a dit que c'était mal, mais j'ai aveuglément accepté l'autorité.

Il est toujours préférable de comprendre POURQUOI vous faites quelque chose, plutôt que de suivre aveuglément les instructions.

Pour la finition, il existe plein de tutos de luthiers qui savent ce qu'ils font sur le web, je vous conseille donc de les consulter avant de vous lancer dans la finition.

Bien sûr, je ne l'ai pas fait, alors j'ai fini par utiliser le mauvais scellant, ce qui a donné une surface très granuleuse. Ne fais pas ça.

Fais tes devoirs.

Étape 15: alignez et fixez le pont

Cette étape est assez simple, mais encore une fois, planifiez votre méthode de serrage et essayez-la à l'avance avant de coller. J'ai utilisé une colle à bois standard pour fixer le pont.

Étape 16: Installer l'électronique et tester

Il est maintenant temps de rendre votre câblage joli. De plus, vous ne voulez pas qu'il s'effondre à l'intérieur du corps et fasse des bruits de bourdonnement ou pire encore qu'il se brise sur scène.

Le code Arduino peut être mis à jour via le port USB, il n'est donc vraiment pas nécessaire de le démonter à moins que vous ne vouliez bricoler.

Étape 17: Installez les accordeurs et enchaînez l'instrument

Vous aurez également probablement besoin de niveler les frettes et de jouer un peu avec la configuration, mais pourquoi s'inquiéter maintenant, alors que vous êtes si proche de la fin ?

J'ai amélioré les tuners et utilisé de belles cordes Aquila, ce qui n'a pas du tout amélioré le son. Alors gardez cela à l'esprit pendant que vous déboursez de l'argent dans un projet de ukulélé…

Étape 18: Programmation du Uke

Le code Arduino final est sur Github. Il y a quelques lignes dans le code pour prendre en charge les améliorations futures (comme une fonction de métronome et des "curseurs" pour l'affichage (un élément d'interface utilisateur qui ressemble à un curseur)

Ce code utilise une bibliothèque d'encodeur rotatif (bibliothèque Arduino d'encodeur rotatif) pour gérer les entrées utilisateur provenant de l'encodeur rotatif.

Il utilise également la bibliothèque Adafruit Neopixel et un exemple de code situé ici. Les modes théâtre et arc-en-ciel sont dérivés d'exemples fournis avec la bibliothèque. (voir strandtest.ino).

Le pilote d'affichage est fourni par les systèmes 4D et se trouve sur Github ici.

Il y a deux fonctions uniques implémentées pour le projet Ukulele. Le premier implémente la bibliothèque d'accords et le second affiche un message texte défilant à l'aide d'un jeu de caractères personnalisé.

Le schéma ci-joint montre les emplacements des LED du manche et comment ils sont connectés. La LED 0 est située dans le coin supérieur droit.

Étape 19: Comment afficher un accord

La fonction displayChord affiche les positions des doigts (première position uniquement pour l'instant) pour chaque accord. Les accords sélectionnés par l'utilisateur (note fondamentale et qualité) sont stockés sous la forme d'une paire d'indices. Ceux-ci sont à leur tour utilisés pour rechercher les doigtés pour chaque accord.

J'ai utilisé la notation "GCEA" pour stocker les accords (par exemple, "A" est "2100"). Les accords sont pré-calculés pour chaque note fondamentale et stockés dans une variable correspondant à la qualité de l'accord. (ainsi, A major, est stocké dans le premier emplacement du tableau "majorChords", correspondant à "2100").

char* majorChords = {"2100\n", "3211\n", "4322\n", "0003\n", "1114\n", "2220\n", "3331\n", " 4442\n", "2010\n", "3121\n", "0232\n", "5343\n"};

Notez que puisqu'il s'agit d'une chaîne de texte, chaque chiffre pourrait également représenter une valeur hexadécimale pour tenir compte des positions de frette supérieures à 9. C'est-à-dire que A et B représenteraient les LED 10 et 11. Pour les accords de première position, ce n'était pas un problème).

La chaîne LED est câblée dans le sens de la longueur en rangées de 12 (une octave) le long de chaque chaîne (en commençant par la chaîne A), la série suivante de 12 commence à la première case de la chaîne suivante (voir le diagramme à l'étape 18). Ceci est important pour que l'algorithme détermine quelles lumières allumer pour un accord donné. Cela signifie que les pixels 0 à 11 sont les LED de la chaîne A, 12 à 23 sont les LED de la chaîne E, et ainsi de suite. Lors de l'analyse d'un A = "2100" (stocké sous forme de chaîne, il y a aussi un terminateur nul "\n" dans le code), nous l'interprétons comme: aucun pixel sur la chaîne A n'est allumé, ni sur la chaîne E, pixel 0 (fret 1) sur la chaîne C est allumé et le pixel 1 (fret 2) sur la chaîne G. Notez qu'un "0" est éteint, pas la première LED. Sur la base du câblage, nous souhaitons allumer les LED 24 et 37. Le code pour afficher un accord est indiqué ci-dessous.

for (int i = 0; i < 4; i++) { if (int(chord - '0')) { //algorithme pour analyser la chaîne d'accord int ledNumber = int(chord - '0') + (3 - i) * 12 - 1; //voir la discussion ci-dessus, le (3-i) est d'inverser l'index strip.setPixelColor(ledNumber, 0, 125, 125); //setPixelColor(ledNumber, valeur rouge, valeur verte, valeur bleue) } }

L'instruction if vérifie si la led est éteinte. Si ce n'est pas le cas, il prend la valeur ascii du caractère, chord, et soustrait la valeur ascii de '0' pour que le ledNumber s'allume.

strip est une instance de la classe Adafruit_NeoPixel. La fonction setPixelColor définit la couleur du pixel calculé (fixée à (0, 125, 125) dans ce cas.

Étape 20: Comment afficher un message défilant

Nous avons donc une matrice de LED 12 x 4… pourquoi ne pas lui faire afficher autre chose que des motifs lumineux assez aléatoires !

Le premier problème est que la hauteur d'affichage (4) est plutôt limitée en raison du nombre de cordes sur un Uke. Le défilement horizontal serait pour la plupart illisible, mais dans une orientation verticale, nous pouvons prendre en charge 4 x 5 caractères s'exécutant verticalement.

L'organisation des caractères en cinq rangées "verticales" signifie que deux caractères peuvent être affichés simultanément, ce qui permet un espace d'une ligne entre chaque caractère.

La difficulté était qu'il n'y avait pas de jeu de caractères standard 4 x 5. J'ai fait le mien en utilisant la feuille de calcul ci-jointe. J'ai affecté chaque ligne à une seule valeur hexadécimale (4 bits représentant quel pixel est activé ou désactivé). La combinaison des cinq valeurs hexadécimales constitue un caractère (par exemple, "0" est 0x69996).

Les valeurs de chaque caractère sont stockées dans un tableau dans l'ordre ASCII. Le jeu de caractères fait quelques compromis avec certaines lettres, mais la majorité est assez claire. (les gribouillages au bas de la feuille de calcul sont des idées avec lesquelles je jouais puisque nous avons la couleur en option, nous pouvons ajouter de la "profondeur" au personnage et éventuellement obtenir une résolution supplémentaire.

La chaîne à afficher est contenue dans la variable de chaîne, message.

Un tampon est créé pour représenter l'affichage des caractères. Je suppose que j'aurais simplement pu créer un grand tampon avec l'intégralité de la séquence de messages traduits, d'autant plus que la plupart des messages feront moins de 20 caractères environ. Cependant, j'ai plutôt choisi de créer un tampon fixe à trois caractères (18 octets). Seuls deux des caractères sont activement affichés, et le troisième est un aperçu, où le caractère suivant est chargé. La chaîne de LED (considérez-la comme un grand registre à décalage) est chargée avec les 48 bits de la chaîne. J'ai gaspillé un peu d'espace mémoire pour rendre cela plus facile à conceptualiser. Chaque quartet obtient son propre emplacement mémoire, ce qui double l'exigence de mémoire, mais ce n'est pas beaucoup compte tenu de la taille de la mémoire tampon.

Le tampon est chargé avec le caractère suivant lorsque l'index de sortie (pointeur) atteint une limite de caractère (outputPointer à 5, 11 ou 17).

Pour charger le tampon, nous saisissons le premier caractère de "message" en tant que valeur ASCII et soustrayons 48 pour obtenir l'index dans le tableau asciiFont. La valeur à cet index est stockée dans codedChar.

La première partie du message décalée correspond aux LED 47, 35, 23 et 11 (le bas de l'affichage). Ainsi, pour le nombre zéro 0x0F999F, le F (celui de gauche) est décalé en premier, 9 secondes et ainsi de suite.

Le caractère suivant est chargé en masquant chaque quartet et en le déplaçant vers la droite. Pour l'exemple ci-dessus, l'algorithme donne (0x0F999F & 0xF00000) >> 20, puis (0x0F999F & 0x0F0000) >> 16, etc.

indice entier; if (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) { char displayChar = message.charAt(messagePointer); // récupère le premier caractère du message long codedChar = asciiFont[displayChar - 48]; if (displayChar == 32) codedChar = 0x000000; messageBuffer[bytePointer+5]=byte((codedChar & 0xF00000) >> 20); // masquer tout sauf le dernier quartet et le décaler de 20 (et ainsi de suite) messageBuffer[bytePointer+4]=byte((codedChar & 0x0F0000) >> 16); // cela devrait mettre un quartet par emplacement mémoire messageBuffer[bytePointer+3]=byte((codedChar & 0x00F000) >> 12); //tous les six représentent sur le caractère messageBuffer[bytePointer+2]=byte((codedChar & 0x000F00) >> 8); messageBuffer[bytePointer+1]=byte((codedChar & 0x0000F0) >> 4); messageBuffer[bytePointer] =byte((codedChar & 0x00000F)); if(bytePointer ==0) { //gère la boucle autour du bytePointer bytePointer = 12; } else { bytePointer -= 6; //on remplit de bas en haut; REMARQUE: il faut inverser cela pour voir si cela facilite les choses } if (messagePointer == message.length()-1) { // gérer la boucle sur le message messagePointer = 0; } else { messagePointer +=1; //passe au caractère suivant } }

Une fois le tampon chargé, il s'agit de suivre où se trouve le pointeur de sortie et de charger la chaîne de LED avec les 48 bits corrects (les 4 actuels et les 44 précédents). Comme mentionné précédemment, strip est une instance de la classe NeoPixel et setPixelColor définit la couleur (RVB) de chaque pixel. La fonction show() décale les valeurs d'affichage vers la chaîne LED.

// boucle pour sortir continuellement le tampon

// voulez écrire la bande entière à chaque passage dans la boucle, seul l'emplacement de départ change pour (int row=12;row > 0;row--) { index = outputPointer + (12-row); if (index > 17) index = outputPointer+(12-row)-18; //boucle si supérieur à 17 for (int column=4; column > 0; column--) { strip.setPixelColor(uint16_t(12*(column-1)+(row-1)), uint8_t(RedLED*(bitRead (messageBuffer[index], column-1))), uint8_t(GreenLED*(bitRead(messageBuffer[index], column-1))), uint8_t(BlueLED*(bitRead(messageBuffer[index], column-1)))); //à chaque emplacement allume la LED si le bit est un } } //outputPointer pointe sur l'octet le plus bas actuel dans la chaîne d'affichage if (outputPointer == 0) outputPointer=17; sinon outputPointer -= 1; strip.show(); }

Étape 21: Étonnez le monde avec votre ukulélé génial

Le prototype final d'ukulélé a pris environ 6 mois de démarrages et d'arrêts.

Beaucoup de nouvelles technologies à apprendre et peut-être un peu de travail du bois et de théorie musicale pour démarrer !

Que faire pour la prochaine version ?

1. Débarrassez-vous de l'affichage et de l'encodeur rotatif. Remplacez-les par un module Bluetooth attaché à l'arduino. Contrôlez-le à distance à l'aide d'un téléphone ou d'une tablette. Tout va mieux avec Bluetooth.
2. Mettez à jour à distance les modèles d'accords en temps réel. Quelque chose de mieux à gauche pour l'application.
3. Couvercles LED. La version actuelle ne fait rien pour empêcher la crasse de pénétrer dans les trous de LED. Un ami a fabriqué un tas de petites lentilles, mais je n'ai jamais pu comprendre comment les faire rester en place correctement.
4. Matériaux de touche alternatifs, peut-être quelque chose de clair tant que les frettes tiennent.
5. Plus de lumières ! Éliminez la contrainte sur le texte en ajoutant plus de "lignes". C'est vraiment une limitation causée par la taille du manche et des corps de LED.

Encore une fois, voir le compagnon Instructable qui décrit le jeu de caractères que j'ai dû créer pour permettre le défilement du texte.

Merci beaucoup d'être arrivé jusqu'ici ! Mahalo !