Piano basé sur Arduino avec enregistrement et relecture

Arduino a été une aubaine pour les personnes qui ne sont pas issues de l'électronique pour construire facilement des choses. Cela a été un excellent outil de prototypage ou pour essayer quelque chose de cool, dans ce projet, nous allons construire un petit piano amusant en utilisant l'Arduino. Ce piano est assez simple avec seulement 8 boutons poussoirs et un buzzer. Il utilise la fonction tone () d'Arduino pour créer différents types de notes de piano sur le haut-parleur. Pour pimenter un peu, nous avons ajouté la fonction d'enregistrement dans le projet, cela nous permet de jouer un morceau, de l'enregistrer et de le rejouer à plusieurs reprises si nécessaire. Cela semble intéressant! Alors allons construire…

Matériaux nécessaires:

• Arduino Uno
• Écran LCD 16 * 2
• Avertisseur sonore
• Tondeuse 10k
• Commutateur SPDT
• Bouton poussoir (8 Nos)
• Résistances (10k, 560R, 1,5k, 2,6k, 3,9, 5,6k, 6,8k, 8,2k, 10k)
• Planche à pain
• Fils de connexion

Schéma:

Le projet complet de piano Arduino peut être construit sur une maquette avec des fils de connexion. Le schéma de circuit réalisé à l'aide de fritzing qui montre la vue de la maquette du projet est illustré ci-dessous

Suivez simplement le schéma de circuit et connectez les fils en conséquence, les boutons poussoirs et le buzzer utilisés avec un module PCB, mais dans le matériel réel, nous n'avons utilisé que le commutateur et le buzzer, cela ne devrait pas vous dérouter beaucoup car ils ont le même type de broche. Vous pouvez également vous référer à l'image ci-dessous du matériel pour effectuer vos connexions.

La valeur des résistances de gauche est dans l'ordre suivant, 10k, 560R, 1,5k, 2,6k, 3,9, 5,6k, 6,8k, 8,2k et 10k. Si vous n'avez pas le même interrupteur DPST, vous pouvez utiliser un interrupteur à bascule normal comme celui illustré dans le schéma de circuit ci-dessus. Examinons maintenant les schémas du projet pour comprendre pourquoi nous avons établi les connexions suivantes.

Schémas et explication:

Le schéma du schéma de circuit présenté ci-dessus est donné ci-dessous, il a également été réalisé à l'aide de Fritzing.

Une connexion principale que nous devons comprendre est la façon dont nous avons connecté les 8 boutons poussoirs à l'Arduino via la broche analogique A0. Fondamentalement, nous avons besoin de 8 broches d'entrée qui peuvent être connectées aux 8 boutons-poussoirs d'entrée, mais pour des projets comme celui-ci, nous ne pouvons pas utiliser 8 broches du microcontrôleur uniquement pour les boutons-poussoirs, car nous pourrions en avoir besoin pour une utilisation ultérieure. Dans notre cas, nous avons l'écran LCD à interfacer.

Nous utilisons donc la broche analogique de l'Arduino et formons un diviseur de potentiel avec des valeurs de résistance variables pour compléter le circuit. De cette façon, lorsque chaque bouton est enfoncé, une tension analogique différente sera fournie à la broche analogique. Un exemple de circuit avec seulement deux résistances et deux boutons poussoirs est illustré ci-dessous.

Dans ce cas, la broche ADC recevra + 5V lorsque les boutons-poussoirs ne sont pas enfoncés, si le premier bouton est enfoncé, le diviseur de potentiel est complété par la résistance 560R et si le deuxième bouton est enfoncé, le diviseur de potentiel est mis en concurrence à l'aide du 1.5 résistance k. De cette façon, la tension reçue par la broche ADC variera en fonction des formules du diviseur de potentiel. Si vous voulez en savoir plus sur le fonctionnement du diviseur de potentiel et comment calculer la valeur de la tension reçue par la broche ADC, vous pouvez utiliser cette page de calcul du diviseur de potentiel.

En dehors de cela, toutes les connexions sont simples, l' écran LCD est connecté aux broches 8, 9, 10, 11 et 12. Le buzzer est connecté à la broche 7 et le commutateur SPDT est connecté à la broche 6 d'Arduino. Le projet complet est alimenté via le port USB de l'ordinateur portable. Vous pouvez également connecter l'Arduino à une alimentation 9V ou 12V via la prise CC et le projet fonctionnera toujours de la même manière.

Comprendre le

L'Arduino a une fonction pratique de tonalité () qui peut être utilisée pour générer des signaux de fréquence variables qui peuvent être utilisés pour produire différents sons à l'aide d'un buzzer. Voyons donc comment fonctionne la fonction et comment elle peut être utilisée avec Arduino.

Avant cela, nous devons savoir comment fonctionne un buzzer Piezo. Nous avons peut-être appris l'existence des cristaux Piezo dans notre école, ce n'est rien d'autre qu'un cristal qui convertit les vibrations mécaniques en électricité ou vice versa. On applique ici un courant variable (fréquence) pour lequel le cristal vibre produisant ainsi un son. Par conséquent, pour que le buzzer piézoélectrique fasse du bruit, nous devons faire vibrer le cristal électrique piézoélectrique, la hauteur et le ton du bruit dépendent de la vitesse à laquelle le cristal vibre. Par conséquent, la tonalité et la hauteur peuvent être contrôlées en faisant varier la fréquence du courant.

Ok, alors comment obtenir une fréquence variable d'Arduino? C'est là qu'intervient la fonction tone (). La fonction tone () peut générer une fréquence particulière sur une broche spécifique. La durée du temps peut également être mentionnée si nécessaire. La syntaxe de tone () est

Syntaxe tone (pin, frequency) tone (pin, fréquence, durée) Paramètres pin: la broche sur laquelle générer la fréquence de tonalité: la fréquence de la tonalité en hertz - unsigned int duration: la durée de la tonalité en millisecondes (optionnel1) - non signé long

Les valeurs de pin peuvent être n'importe laquelle de vos broches numériques. J'ai utilisé la broche numéro 8 ici. La fréquence qui peut être générée dépend de la taille de la minuterie de votre carte Arduino. Pour UNO et la plupart des autres cartes courantes, la fréquence minimale pouvant être produite est de 31 Hz et la fréquence maximale pouvant être produite est de 65 535 Hz. Cependant, nous, les humains, ne pouvons entendre que des fréquences comprises entre 2000 Hz et 5000 Hz.

Jouer des sons de piano sur Arduino:

D'accord, avant même de commencer sur ce sujet, permettez-moi de préciser que je suis un novice avec des notes de musique ou du piano, alors pardonnez-moi si quelque chose mentionné sous cette rubrique est du charabia.

Nous savons maintenant que nous pouvons utiliser la fonction de tons dans Arduino pour produire des sons, mais comment pouvons-nous jouer les tons d'une note particulière en utilisant la même chose. Heureusement pour nous, il existe une bibliothèque appelée «pitches.h» écrite par Brett Hagman. Cette bibliothèque contient toutes les informations sur quelle fréquence équivaut à quelle note sur un piano. J'ai été surpris de voir à quel point cette bibliothèque pouvait réellement fonctionner et jouer presque toutes les notes d'un piano, j'ai utilisé la même chose pour jouer les notes de piano de Pirates des Caraïbes, de Crazy Frog, de Mario et même de titanic et elles sonnaient génialement. Oops! Nous sommes un peu hors sujet ici, donc si cela vous intéresse, jetez des mélodies à l'aide du projet Arduino. Vous trouverez également plus d'explications sur la bibliothèque pitches.h dans ce projet.

Notre projet n'a que 8 boutons poussoirs, donc chaque bouton ne peut jouer qu'une seule note de musique particulière et donc totalement nous ne pouvons jouer que 8 notes. J'ai sélectionné les notes les plus utilisées sur un piano, mais pouvez-vous en sélectionner 8 ou même étendre le projet avec plus de boutons poussoirs et ajouter plus de notes.

Les notes sélectionnées dans ce projet sont les notes C4, D4, E4, F4, G4, A4, B4 et C5 qui peuvent être jouées à l'aide des boutons 1 à 8 respectivement.

Programmation de l'Arduino:

Assez de théorie, passons à la partie amusante de la programmation de l'Arduino. Le programme Arduino complet est donné à la fin de cette page, vous pouvez sauter si vous êtes impatient ou lire plus loin pour comprendre comment le code fonctionne.

Dans notre programme Arduino, nous devons lire la tension analogique à partir de la broche A0, puis prédire quel bouton a été enfoncé et jouer la tonalité respective pour ce bouton. Tout en faisant cela, nous devons également enregistrer le bouton sur lequel l'utilisateur a appuyé et combien de temps il / elle a appuyé, afin que nous puissions recréer le ton qui a été joué par l'utilisateur plus tard.

Avant de passer à la partie logique, nous devons déclarer les 8 notes que nous jouerons. La fréquence respective des notes est ensuite extraite de la bibliothèque pitches.h , puis un tableau est formé comme indiqué ci-dessous. Ici, la fréquence de lecture de la note C4 est de 262 et ainsi de suite.

notes int = {262, 294, 330, 349, 392, 440, 494, 523}; // Réglez la fréquence pour C4, D4, E4, F4, G4, A4, B4,

Ensuite, nous devons mentionner à quelles broches l'écran LCD est connecté. Si vous suivez exactement les mêmes schémas donnés ci-dessus, vous n'avez rien à changer ici.

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; // Broches auxquelles l'écran LCD est connecté LiquidCrystal lcd (rs, en, d4, d5, d6, d7);

Ensuite, dans notre fonction de configuration , nous initialisons simplement le module LCD et le moniteur série pour le débogage. Nous affichons également un message d'introduction juste pour nous assurer que tout fonctionne comme prévu. Ensuite , à l'intérieur de la fonction de boucle principale , nous avons deux boucles while.

Une boucle while sera exécutée tant que le commutateur SPDT est placé en enregistrement plus. En mode enregistrement, l'utilisateur peut payer les tonalités requises et en même temps la tonalité qui est jouée sera également sauvegardée. Donc, la boucle while ressemble à ceci ci-dessous

while (digitalRead (6) == 0) // Si le commutateur à bascule est réglé en mode d'enregistrement {lcd.setCursor (0, 0); lcd.print ("Enregistrement.."); lcd.setCursor (0, 1); Detect_button (); Play_tone (); }

Comme vous l'avez peut-être remarqué, nous avons deux fonctions dans la boucle while. La première fonction Detect_button () est utilisée pour trouver le bouton sur lequel l'utilisateur a appuyé et la deuxième fonction Play_tone () est utilisée pour jouer la tonalité respective. En dehors de cette fonction, la fonction Detect_button () enregistre également quel bouton est enfoncé et la fonction Play_tone () enregistre la durée pendant laquelle le bouton a été enfoncé.

À l'intérieur de la fonction Detect_button () , nous lisons la tension analogique de la broche A0 et la comparons avec certaines valeurs prédéfinies pour savoir sur quel bouton a été enfoncé. La valeur peut être déterminée soit en utilisant le calculateur de diviseur de tension ci-dessus, soit en utilisant le moniteur série pour vérifier la valeur analogique lue pour chaque bouton.

void Detect_button () { analogVal = analogRead (A0); // lire le voltag analogique sur la broche A0 pev_button = bouton; // se souvient du bouton précédent pressé par l'utilisateur if (analogVal <550) button = 8; bouton if (analogVal <500) = 7; bouton if (analogVal <450) = 6; bouton if (analogVal <400) = 5; bouton if (analogVal <300) = 4; bouton if (analogVal <250) = 3; bouton if (analogVal <150) = 2; bouton if (analogVal <100) = 1; bouton if (analogVal> 1000) = 0; / **** Rcord les boutons pressés dans un tableau *** / if (bouton! = bouton_pev && bouton_pev! = 0) { bouton_enregistré = bouton_pev; button_index ++; enregistré_button = 0; button_index ++; } / ** Fin du programme d'enregistrement ** / }

Comme dit, dans cette fonction, nous enregistrons également la séquence dans laquelle les boutons sont enfoncés. Les valeurs enregistrées sont stockées dans un tableau nommé Registered_button. Nous vérifions d'abord s'il y a un nouveau bouton enfoncé, s'il est pressé, nous vérifions également si ce n'est pas le bouton 0. Où le bouton 0 n'est rien mais aucun bouton n'est enfoncé. À l'intérieur de la boucle if, nous stockons la valeur à l'emplacement d'index donné par la variable button_index, puis nous augmentons également cette valeur d'index afin de ne pas surécrire au même emplacement.

/ **** Rcord les boutons pressés dans un tableau *** / if (button! = Pev_button && pev_button! = 0) { registered_button = pev_button; button_index ++; enregistré_button = 0; button_index ++; } / ** Fin du programme d'enregistrement ** /

Dans la fonction Play_tone () , nous jouerons la tonalité respective pour le bouton pressé en utilisant plusieurs conditions if . Nous utiliserons également un tableau nommé Registered_time dans lequel nous enregistrerons la durée pendant laquelle le bouton a été enfoncé. L'opération est similaire à l'enregistrement de la séquence de boutons en utilisant la fonction millis () pour déterminer combien de temps chaque bouton a été enfoncé, également pour réduire la taille de la variable, nous divisons la valeur par 10. Pour le bouton 0, ce qui signifie que l'utilisateur n'est pas en appuyant sur quoi que ce soit, nous ne jouons aucun ton pendant la même durée. Le code complet à l'intérieur de la fonction est indiqué ci-dessous.

void Play_tone () { / **** Rcord le délai entre chaque pression de bouton dans un tableau *** / if (button! = pev_button) { lcd.clear (); // Puis nettoyez-le note_time = (millis () - start_time) / 10; enregistré_time = note_time; time_index ++; heure_début = millis (); } / ** Fin du programme d'enregistrement ** / if (bouton == 0) { noTone (7); lcd.print ("0 -> Pause.."); } if (bouton == 1) { ton (7, notes); lcd.print ("1 -> NOTE_C4"); } if (bouton == 2) { ton (7, notes); lcd.print ("2 -> NOTE_D4"); } si (bouton == 3) { ton (7, notes); lcd.print ("3 -> NOTE_E4"); } if (bouton == 4) { ton (7, notes); lcd.print ("4 -> NOTE_F4"); } if (bouton == 5) { ton (7, notes); lcd.print ("5 -> NOTE_G4"); } if (bouton == 6) { ton (7, notes); lcd.print ("6 -> NOTE_A4"); } if (bouton == 7) { ton (7, notes); lcd.print ("7 -> NOTE_B4"); } if (bouton == 8) { ton (7, notes); lcd.print ("8 -> NOTE_C5"); } }

Enfin, après l'enregistrement, l' utilisateur doit basculer le DPST dans l'autre sens pour jouer la tonalité enregistrée. Lorsque cela est fait, le programme sort de la boucle while précédente et entre dans la deuxième boucle while où nous jouons les notes dans la séquence des boutons enfoncés pendant une durée précédemment enregistrée. Le code pour faire de même est indiqué ci-dessous.

while (digitalRead (6) == 1) // Si le commutateur à bascule est réglé en mode de lecture { lcd.clear (); lcd.setCursor (0, 0); lcd.print ("Lecture en cours.."); for (int i = 0; i <sizeof (bouton_enregistré) / 2; i ++) { délai ((heure_enregistrée) * 10); // Attendre avant de payer le prochain morceau if (enregistré_button == 0) noTone (7); // l'utilisateur touche n'importe quel bouton autre ton (7, notes - 1)]); // joue le son correspondant au bouton touché par l'utilisateur } } }

Jouez, enregistrez, rejouez et répétez!:

Faites le matériel selon le schéma de circuit illustré et téléchargez le code sur la carte Arduino et son heure affichée. Placez le SPDT en mode d'enregistrement et commencez à jouer les tonalités de votre choix, en appuyant sur chaque bouton, vous produirez une tonalité différente. Pendant ce mode, l'écran LCD affichera « Recording…» et sur la deuxième ligne, vous verrez le nom de la note actuellement pressée comme indiqué ci-dessous

Une fois que vous avez joué votre son, basculez le commutateur SPDT de l'autre côté et l'écran LCD devrait afficher « Now Playing..» , puis commencez à jouer le son que vous venez de jouer. La même tonalité sera jouée encore et encore tant que l'interrupteur à bascule est maintenu dans la position indiquée dans l'image ci-dessous.

Le fonctionnement complet du projet peut être trouvé dans la vidéo ci-dessous. J'espère que vous avez compris le projet et que vous avez apprécié sa construction. Si vous rencontrez des problèmes lors de la création de ce message, postez-les dans la section des commentaires ou utilisez les forums pour obtenir une aide technique sur votre projet. N'oubliez pas non plus de consulter la vidéo de démonstration ci-dessous.