Générateur de sons Arduino sans bibliothèque ni fonctions série (avec interruptions) : 10 étapes

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

Ce n'est pas quelque chose sur lequel je ferais normalement un instructable, je préfère ma ferronnerie, mais comme je suis un étudiant en génie électrique et que je dois suivre un cours sur les microcontrôleurs (Embedded Systems Design), j'ai pensé que je ferais un instructable sur un de mes projets. Lorsque j'ai initialement créé le projet et d'autres pour cette classe, j'ai constaté qu'il y avait très peu ou pas de tutoriels qui n'utilisaient pas les fonctions de la bibliothèque arduino ou les fonctions série, ce qui est une autre raison pour laquelle je pensais que ce serait une bonne instructable.

Ce code est conçu pour le microcontrôleur Atmega 2560, donc si vous souhaitez l'implémenter sur une autre carte, vous devrez modifier les registres d'adresses dans le code en fonction du manuel d'utilisation de votre contrôleur. L'idée de base derrière le code est que chaque fois que vous entrez une touche du clavier dans le moniteur série, l'arduino mega produira une certaine fréquence en fonction de la touche sur laquelle vous appuyez, avec "q" la réinitialisant. J'ai fait en sorte que "a" produise la fréquence A flat et "A" produise la fréquence A sharp, "b" produise B flat, "c" pour C flat, "C" pour C sharp, et ainsi de suite. Le code complet est téléchargé à la fin, mais chaque étape décompose le code en morceaux afin qu'il soit plus facile à expliquer.

Étape 1: Définition des adresses de registre

Cette étape est simple, si vous utilisez l'atmega 2560, il vous suffit d'utiliser les adresses que j'ai utilisées, bien que si vous utilisez une carte avec une puce différente, vous devrez trouver les adresses de chacun de ces registres sur votre manuel d'utilisation des puces. Les définitions en haut ne sont que des constantes qui seront utilisées plus tard pour nos fonctions. Nous spécifions les adresses comme volatiles non signées car nous ne voulons pas que le compilateur s'en mêle.

Étape 2: tableaux et variables globales

Ici, nous voulons définir le tableau de fréquences qui contiendra toutes les fréquences que chaque touche doit produire. Ces valeurs sont calculées à partir des fréquences de notes réelles, et honnêtement, j'ai oublié comment je les ai obtenues, mais ce sont les bonnes valeurs car je les ai testées sur un oscilloscope pour m'en assurer. Nous définissons également le tableau de notes qui contient toutes les touches à appuyer pour chaque son, ainsi que les variables dont nous aurons besoin pour nos fonctions ultérieures.

Étape 3: La fonction "serial.begin"

Nous appellerons notre fonction personnalisée qui réplique la fonction "serial.begin" U0init(). Il prend le débit en bauds souhaité en entrée et démarre le port série à ce débit en bauds.

Étape 4: La fonction "serial.available"

Nous appellerons la fonction qui imite "serial.available" U0kbhit(). Il ne prend pas d'entrée mais détecte à la place s'il y a une modification apportée au clavier à l'aide du bit d'état RDA et renvoie vrai lorsqu'une modification est détectée.

Étape 5: La fonction "serial.read"

Nous appellerons la fonction qui imite la fonction "serial.read" U0getchar(), qui ne prend aucune entrée et génère tout changement effectué sur le clavier, qui est stocké dans le registre UDR0.

Étape 6: La fonction "serial.write"

Nous appellerons la fonction qui imite "serial.write" U0putchar(), qui prend les données du registre UDR0 pendant qu'un changement est détecté et stocké, et renvoie ce changement au moniteur série.

Étape 7: La fonction de configuration

C'est la fonction de configuration de base qui utilisera notre imitation "serial.begin" pour initialiser le port série, et initialisera nos paramètres de bits pour les registres de minuterie et configurera PB6 pour émettre nos tonalités.

Étape 8: Les fonctions de boucle et d'ISR

La boucle fonctionne ainsi: si un changement est détecté avec notre fonction "serial.available", notre fonction "serial.read" stocke ce changement, et notre fonction "serial.write" place ce changement dans le moniteur série. Tant qu'une variable i est inférieure à la taille du tableau de fréquences, elle définira la sortie comme étant la position de i dans ce tableau, produisant la fréquence à cette position. L'ISR fonctionne comme la réinitialisation, où si la position du tableau de fréquences n'est pas égale à 0 (en d'autres termes si "q" n'est pas enfoncé), il produira la fréquence, mais lorsque "q" est enfoncé, il se réinitialisera. Veuillez noter: ce code utilise des interruptions, mais cela peut être fait avec les interruptions désactivées. Je posterai le code sans interruption si je reçois des demandes, je pense juste que la version avec interruption est plus amusante.

Étape 9: Câblage

Le câblage de ce code est extrêmement simple, il suffit de mettre un fil de sortie de PB6 à une maquette, de connecter un buzzer ou un haut-parleur en série avec celui-ci et de le reconnecter à la terre. Remarque: si vous utilisez un haut-parleur, placez une petite résistance avant le haut-parleur. Si vous voulez juste voir la sortie sans l'entendre, connectez simplement PB6 au fil rouge d'un oscilloscope et le fil noir à la terre.

Étape 10: Tout assembler

J'ai ajouté le code complet à cette étape, car j'en ai expliqué toutes les parties dans les étapes précédentes. Il suffit d'une entrée clavier pour différentes fréquences et envoie cette fréquence à PB6. J'espère que vous avez apprécié la lecture d'une manière différente de coder avec l'IDE !

Aussi, s'il vous plaît voter pour cela dans le concours Microcontrôleur:D