Synthétiseur de harpe laser sur carte Zybo : 10 étapes (avec photos)

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

Dans ce didacticiel, nous allons créer une harpe laser entièrement fonctionnelle à l'aide de capteurs IR avec une interface série qui permettra à l'utilisateur de modifier l'accord et la tonalité de l'instrument. Cette harpe sera le remake du 21ème siècle de l'instrument séculaire. Le système a été créé à l'aide d'une carte de développement Xilinx Zybo et des suites Vivado Design. Ce dont vous aurez besoin pour réaliser le projet:

• 12 capteurs et émetteurs IR (plus ou moins peut être utilisé selon le nombre de chaînes)
• Carte de développement Zybo Zynq-7000
• RTOS gratuit
• Suite Vivado Design
• Fil (pour connecter les capteurs à la carte)
• 3 morceaux de tuyau en PVC ((2) 18 pouces et (1) 8 pouces)
• 2 coudes PVC

Étape 1: Obtenez la démo audio Zybo DMA de Digilent

Le côté FPGA de ce projet est largement basé sur le projet de démonstration trouvé ici. Il utilise un accès direct à la mémoire pour envoyer des données directement depuis la mémoire que le processeur peut écrire sur AXI Stream vers un bloc audio I2S. Les étapes suivantes vous aideront à lancer le projet de démonstration audio DMA:

1. Une nouvelle version du fichier de carte pour la carte Zybo peut être nécessaire. Suivez ces instructions pour obtenir de nouveaux fichiers de carte pour Vivado.
2. Suivez les étapes 1 et 2 des instructions sur cette page pour ouvrir le projet de démonstration dans Vivado. Utilisez la méthode Vivado, pas le transfert matériel SDK.
3. Vous pouvez recevoir un message indiquant que certains de vos blocs IP doivent être mis à jour. Si c'est le cas, sélectionnez "Afficher l'état IP", puis dans l'onglet État IP, sélectionnez toutes les adresses IP obsolètes et cliquez sur "Mettre à niveau la sélection". Lorsqu'il se termine et qu'une fenêtre apparaît vous demandant si vous souhaitez générer un produit de sortie, continuez et cliquez sur "Générer". Si vous recevez un message d'avertissement critique, ignorez-le.
4. Passez de la conception à l'onglet sources dans Vivado pour voir les fichiers sources. Cliquez avec le bouton droit sur la conception de bloc "design_1" et sélectionnez "Créer un wrapper HDL". Lorsque vous y êtes invité, sélectionnez "copier le wrapper généré pour autoriser les modifications par l'utilisateur". Un fichier wrapper pour le projet sera généré.
5. Maintenant que ces étapes critiques qui ont été omises dans l'autre didacticiel sont terminées, vous pouvez revenir au didacticiel précédemment lié et continuer de l'étape 4 à la fin et vous assurer que le projet de démonstration s'exécute correctement. Si vous n'avez pas de moyen d'entrer l'audio pour l'enregistrer, enregistrez simplement avec votre casque et écoutez un son flou de 5 à 10 secondes lorsque vous appuyez sur le bouton de lecture. Tant que quelque chose sort de la prise casque lorsque vous appuyez sur le bouton de lecture, cela fonctionne probablement correctement.

Étape 2: Apportez quelques modifications dans Vivado

Alors maintenant, vous avez la démo audio DMA de Digilent qui fonctionne, mais ce n'est pas du tout l'objectif final ici. Nous devons donc revenir à Vivado et apporter quelques modifications afin que nos capteurs puissent être branchés sur les en-têtes PMOD et que nous puissions utiliser leur valeur du côté logiciel.

1. Ouvrez le schéma fonctionnel dans Vivado
2. Créez un bloc GPIO en cliquant avec le bouton droit dans un espace vide du diagramme et en sélectionnant "Ajouter IP" dans le menu. Recherchez et sélectionnez "AXI GPIO".
3. Double-cliquez sur le nouveau bloc IP et dans la fenêtre de personnalisation IP, accédez à l'onglet de configuration IP. Sélectionnez toutes les entrées et réglez la largeur sur douze, car nous aurons 12 "cordes" sur notre harpe et avons donc besoin de 12 capteurs. Si vous souhaitez utiliser moins ou plus de capteurs, ajustez ce nombre de manière appropriée. Activez également l'interruption.
4. Cliquez avec le bouton droit sur le nouveau bloc IP GPIO et sélectionnez "exécuter l'automatisation de la connexion". Cochez la case AXI et appuyez sur OK. Cela devrait connecter l'interface AXI automatiquement, mais laisser les sorties du bloc non connectées.
5. Afin de faire de la place pour l'interruption supplémentaire, double-cliquez sur le bloc IP xlconcat_0 et modifiez le nombre de ports de 4 à 5. Ensuite, vous pouvez connecter la broche ip2intc_irpt du nouveau bloc GPIO au nouveau port inutilisé sur le bloc xlconcat.
6. Faites un clic droit sur la sortie "GPIO" du nouveau bloc IP GPIO et sélectionnez "make external". Trouvez où va la ligne et cliquez sur le petit pentagone latéral et sur la gauche, une fenêtre devrait s'ouvrir où vous pouvez changer le nom. Changez le nom en "CAPTEURS". Il est important d'utiliser le même nom si vous voulez que le fichier de contraintes que nous fournissons fonctionne, sinon vous devrez changer le nom dans le fichier de contraintes.
7. De retour dans l'onglet sources, recherchez le fichier de contraintes et remplacez-le par celui que nous fournissons. Vous pouvez choisir de remplacer le fichier ou simplement de copier le contenu de notre fichier de contraintes et de le coller sur le contenu de l'ancien. L'une des choses importantes que fait notre fichier de contraintes est d'activer les résistances pullup sur les en-têtes PMOD. Ceci est nécessaire pour les capteurs particuliers que nous avons utilisés, mais tous les capteurs ne sont pas identiques. Si vos capteurs nécessitent des résistances pulldown, vous pouvez changer chaque instance de "set_property PULLUP true" avec "set_property PULLDOWN true". Si elles nécessitent une valeur de résistance différente de celle de la carte, vous pouvez supprimer ces lignes et utiliser des résistances externes. Les noms des broches sont dans les commentaires du fichier de contraintes, et ils correspondent aux étiquettes du premier diagramme du schéma Zybo page qui se trouve ici. Si vous souhaitez utiliser différentes broches pmod, faites simplement correspondre les noms du fichier de contraintes aux étiquettes du schéma. Nous utilisons les en-têtes PMOD JE et JD, et utilisons six broches de données sur chacune, en omettant les broches 1 et 7. Ces informations sont importantes lors du raccordement de vos capteurs. Comme le montre le schéma, les broches 6 et 12 du PMODS sont VCC et les broches 5 et 11 sont à la masse.
8. Régénérez le wrapper HDL comme auparavant, puis copiez et écrasez l'ancien. Lorsque cela est fait, générez le flux binaire et exportez le matériel comme avant, puis relancez le SDK. Si on vous demande si vous souhaitez remplacer l'ancien fichier matériel, la réponse est oui. Il est probablement préférable de fermer le SDK lorsque vous exportez du matériel afin qu'il soit correctement remplacé.
9. Lancez le SDK.

Étape 3: Lancez FreeRTOS

L'étape suivante consiste à faire fonctionner FreeRTOS sur la carte Zybo.

1. Si vous n'en avez pas déjà une copie, téléchargez FreeRTOS ici et extrayez les fichiers.
2. Importez la démo FreeRTOS Zynq située dans FreeRTOSv9.0.0\FreeRTOS\Demo\CORTEX_A9_Zynq_ZC702\RTOSDemo. Le processus d'importation est à peu près le même que pour l'autre projet de démonstration, mais comme la démo FreeRTOS Zynq repose sur d'autres fichiers du dossier FreeRTOS, vous ne devez pas copier les fichiers dans votre espace de travail. Au lieu de cela, vous devez placer l'intégralité du dossier FreeRTOS dans votre dossier de projet.
3. Créez un nouveau package de support de carte en allant dans "fichier" -> "nouveau" -> "pack de support de carte". Assurez-vous que autonome est sélectionné et cliquez sur Terminer. Après un moment, une fenêtre apparaîtra, cochez la case à côté de lwip141 (cela empêche l'une des démos FreeRTOS d'échouer à compiler) et appuyez sur OK. Une fois cela terminé, faites un clic droit sur le projet RTOSdemo et allez dans "Propriétés", allez dans l'onglet "Références de projet", et cochez la case à côté du nouveau bsp que vous avez créé. Espérons qu'il sera reconnu, mais parfois le SDK Xilinx peut être étrange à propos de ce genre de chose. Si vous obtenez toujours une erreur après cette étape indiquant que xparameters.h est manquant ou quelque chose comme ça, essayez de répéter cette étape et peut-être de quitter et de relancer le SDK.

Étape 4: ajouter le code de la harpe laser

Maintenant que FreeRTOS est importé, vous pouvez importer les fichiers du projet de harpe laser dans la démo FreeRTOS

1. Créez un nouveau dossier sous le dossier src dans la démo FreeRTOS et copiez et collez tous les fichiers c fournis à l'exception de main.c dans ce dossier.
2. Remplacez le RTOSDemo main.c par le main.c fourni.
3. Si tout est fait correctement, vous devriez pouvoir exécuter le code de la harpe laser à ce stade. À des fins de test, l'entrée de bouton qui a été utilisée dans le projet de démonstration DMA est maintenant utilisée pour jouer des sons sans capteurs connectés (n'importe lequel des quatre boutons principaux fonctionnera). Il jouera une chaîne à chaque fois que vous appuyez dessus et fera défiler toutes les chaînes du système sur plusieurs pressions. Branchez des écouteurs ou des haut-parleurs à la prise casque de la carte Zybo et assurez-vous que vous pouvez entendre les sons des cordes lorsque vous appuyez sur un bouton.

Étape 5: À propos du Code

Beaucoup d'entre vous qui lisez ce didacticiel sont probablement ici pour apprendre à configurer l'audio ou à utiliser le DMA pour faire quelque chose de différent, ou pour créer un instrument de musique différent. Pour cette raison, les prochaines sections sont consacrées à la description de la façon dont le code fourni fonctionne en conjonction avec le matériel décrit précédemment pour obtenir une sortie audio fonctionnelle à l'aide du DMA. Si vous comprenez pourquoi les morceaux de code sont là, vous devriez pouvoir les ajuster pour tout ce que vous voulez créer.

Interruptions

Je vais d'abord mentionner comment les interruptions sont créées dans ce projet. Nous l'avons fait en créant d'abord une structure de table de vecteur d'interruption qui garde une trace de l'ID, du gestionnaire d'interruption et d'une référence au périphérique pour chaque interruption. Les ID d'interruption proviennent de xparameters.h. Le gestionnaire d'interruption est une fonction que nous avons écrite pour le DMA et le GPIO, et l'interruption I2C provient du pilote Xlic I2C. La référence de périphérique pointe vers des instances de chaque périphérique que nous initialisons ailleurs. Vers la fin de la fonction _init_audio, une boucle parcourt chaque élément de la table des vecteurs d'interruption et appelle deux fonctions, XScuGic_Connect() et XScuGic_Enable() pour se connecter et activer les interruptions. Ils font référence à xInterruptController, qui est un contrôleur d'interruption créé dans FreeRTOS main.c par défaut. Donc, fondamentalement, nous attachons chacune de nos interruptions à ce contrôleur d'interruption qui a déjà été créé pour nous par FreeRTOS.

DMA

Le code d'initialisation DMA commence dans lh_main.c. Tout d'abord, une instance statique d'une structure XAxiDma est déclarée. Ensuite, dans la fonction _init_audio(), il est configuré. D'abord, la fonction de configuration du projet de démonstration est appelée, qui se trouve dans dma.c. C'est assez bien documenté et vient directement de la démo. Ensuite, l'interruption est connectée et activée. Pour ce projet, seule l'interruption maître-esclave est requise, car toutes les données sont envoyées par le DMA au contrôleur I2S. Si vous souhaitez enregistrer de l'audio, vous aurez également besoin de l'interruption esclave-maître. L'interruption maître-esclave est appelée lorsque le DMA a fini d'envoyer les données que vous lui avez demandé d'envoyer. Cette interruption est extrêmement importante pour notre projet car chaque fois que le DMA termine d'envoyer un tampon d'échantillons audio, il doit immédiatement commencer à envoyer le tampon suivant, sinon un délai audible se produirait entre les envois. Dans la fonction dma_mm2s_ISR(), vous pouvez voir comment nous gérons l'interruption. La partie importante est proche de la fin où nous utilisons xSemaphoreGiveFromISR() et portYIELD_FROM_ISR() pour notifier _audio_task() qu'il peut lancer le prochain transfert DMA. La façon dont nous envoyons des données audio constantes consiste à alterner entre deux tampons. Lorsqu'un tampon est transmis au bloc I2C, l'autre tampon voit ses valeurs calculées et stockées. Ensuite, lorsque l'interruption provient du DMA, le tampon actif bascule et le tampon le plus récemment écrit commence à être transféré tandis que le tampon précédemment transféré commence à être écrasé par de nouvelles données. La partie clé de la fonction _audio_task est l'endroit où fnAudioPlay() est appelé. fnAudioPlay() prend en compte l'instance DMA, la longueur du tampon et un pointeur vers le tampon à partir duquel les données seront transférées. Quelques valeurs sont envoyées aux registres I2S pour lui faire savoir que d'autres échantillons sont à venir. Ensuite, XAxiDma_SimpleTransfer() est appelé pour lancer le transfert.

Audio I2S

audio.c et audio.h sont l'endroit où l'initialisation I2S a lieu. Le code d'initialisation I2S est un morceau de code assez courant qui flotte à plusieurs endroits, vous pouvez trouver de légères variations par rapport à d'autres sources, mais celle-ci devrait fonctionner. C'est assez bien documenté et il n'y a pas grand-chose à changer pour le projet de harpe. La démo audio DMA dont il provient a des fonctions pour basculer vers les entrées micro ou ligne afin que vous puissiez les utiliser si vous avez besoin de cette fonctionnalité.

Synthèse sonore

Pour décrire le fonctionnement de la synthèse sonore, je vais énumérer chacun des modèles sonores utilisés dans le développement qui ont conduit à la méthode finale, car cela vous donnera une idée de pourquoi c'est fait de la façon dont c'est fait.

Méthode 1: Une période de valeurs sinusoïdales est calculée pour chaque corde à la fréquence correspondante pour la note musicale de cette corde et stockée dans un tableau. Par exemple, la longueur du tableau sera la période de l'onde sinusoïdale en échantillons, ce qui équivaut au nombre d'échantillons / cycle. Si le taux d'échantillonnage est de 48 kHz et la fréquence de note est de 100 Hz, alors il y a 48 000 échantillons/seconde et 100 cycles/seconde conduisant à 4800 échantillons par cycle, et la longueur du tableau sera de 4800 échantillons et contiendra les valeurs d'un complet période d'onde sinusoïdale. Lorsque la chaîne est jouée, le tampon d'échantillon audio est rempli en prenant une valeur du tableau d'onde sinusoïdale et en la plaçant dans le tampon audio en tant qu'échantillon, puis en incrémentant l'index dans le tableau d'onde sinusoïdale de sorte que, en utilisant notre exemple précédent au cours du cours sur 4800 échantillons, un cycle d'onde sinusoïdale est placé dans la mémoire tampon audio. Une opération modulo est utilisée sur l'index du tableau afin qu'il soit toujours compris entre 0 et la longueur, et lorsque l'index du tableau dépasse un certain seuil (comme peut-être 2 secondes d'échantillons), la chaîne est désactivée. Pour lire plusieurs chaînes en même temps, gardez une trace de l'index de tableau de chaque chaîne séparément et ajoutez la valeur de l'onde sinusoïdale de chaque chaîne pour obtenir chaque échantillon.

Méthode 2: Pour créer un son plus musical, nous commençons par le modèle précédent et ajoutons des harmoniques à chaque fréquence fondamentale. Les fréquences harmoniques sont des fréquences qui sont des multiples entiers de la fréquence fondamentale. Contrairement à la somme de deux fréquences non liées, ce qui entraîne la lecture simultanée de deux sons distincts, lorsque les harmoniques sont additionnées, elles continuent à sonner comme un seul son, mais avec une tonalité différente. Pour ce faire, chaque fois que nous ajoutons la valeur de l'onde sinusoïdale à l'emplacement (indice de tableau % longueur de tableau) à l'échantillon audio, nous ajoutons également (2 * indice de tableau % longueur de tableau) et (3 * indice de tableau % longueur de tableau), et ainsi de suite pour le nombre d'harmoniques souhaité. Ces indices multipliés traverseront l'onde sinusoïdale à des fréquences qui sont des multiples entiers de la fréquence d'origine. Pour permettre un meilleur contrôle de la tonalité, les valeurs de chaque harmonique sont multipliées par une variable qui représente la quantité de cette harmonique dans le son global. Par exemple, l'onde sinusoïdale fondamentale peut avoir ses valeurs toutes multipliées par 6 pour en faire un facteur plus important dans le son global, tandis que la 5e harmonique peut avoir un multiplicateur de 1, ce qui signifie que ses valeurs contribuent beaucoup moins au son global.

Méthode 3: Bon, maintenant nous avons un très beau ton sur les notes, mais il y a quand même un problème assez crucial: elles jouent à un volume fixe pour une durée fixe. Pour sonner comme un véritable instrument, le volume d'une corde jouée doit diminuer progressivement avec le temps. Pour ce faire, un tableau est rempli avec les valeurs d'une fonction à décroissance exponentielle. Désormais, lorsque les échantillons audio sont créés, le son provenant de chaque chaîne est calculé comme dans la méthode précédente, mais avant d'être ajouté à l'échantillon audio, il est multiplié par la valeur à l'indice de tableau de cette chaîne dans le tableau de la fonction de décroissance exponentielle. Cela permet au son de se dissiper en douceur au fil du temps. Lorsque l'index du tableau atteint la fin du tableau de décroissance, la chaîne est arrêtée.

Méthode 4: Cette dernière étape est ce qui donne vraiment aux sons de corde leur son de corde réaliste. Avant, ils sonnaient agréablement mais clairement synthétisés. Pour essayer de mieux émuler une corde de harpe du monde réel, un taux de décroissance différent est attribué à chaque harmonique. Dans les vraies cordes, lorsque la corde est frappée pour la première fois, il y a un contenu élevé d'harmoniques à haute fréquence qui crée le genre de son de pincement que nous attendons d'une corde. Ces harmoniques à haute fréquence sont très brièvement la partie principale du son, le son de la corde frappée, mais elles décroissent très rapidement au fur et à mesure que les harmoniques plus lentes prennent le relais. Un tableau de décroissance est créé pour chaque numéro d'harmonique utilisé dans la synthèse sonore, chacun avec son propre taux de décroissance. Maintenant, chaque harmonique peut être indépendamment multipliée par la valeur de son tableau de décroissance correspondant à l'indice de tableau de la corde et ajoutée au son.

Globalement la synthèse sonore est intuitive mais lourde de calcul. Le stockage de l'intégralité du son de la chaîne en mémoire prendrait trop de mémoire, mais le calcul de l'onde sinusoïdale et de la fonction exponentielle entre chaque image prendrait beaucoup trop de temps pour suivre le rythme de lecture audio. Un certain nombre d'astuces sont utilisées dans le code pour accélérer le calcul. Tous les calculs, à l'exception de la création initiale des tables de décroissance sinusoïdale et exponentielle, sont effectués au format entier, ce qui nécessite de répartir l'espace numérique disponible dans la sortie audio 24 bits. Par exemple, la table de sinus est d'amplitude 150 de sorte qu'elle est lisse mais pas si grande que de nombreuses cordes jouées ensemble peuvent s'additionner pour dépasser 24 bits. De même, les valeurs du tableau exponentiel sont multipliées par 80 avant d'être arrondies à des nombres entiers et stockées. Les poids harmoniques peuvent prendre des valeurs discrètes entre 0 et 10. De plus, tous les échantillons sont en fait doublés et les ondes sinusoïdales sont indexées par 2, réduisant ainsi de moitié le taux d'échantillonnage. Cela limite la fréquence maximale pouvant être jouée, mais était nécessaire pour que le nombre actuel de cordes et d'harmoniques soit calculé assez rapidement.

Créer ce modèle sonore et le faire fonctionner a demandé des efforts considérables du côté du processeur, et il aurait été incroyablement difficile de le faire fonctionner du côté fpga à partir de zéro dans le laps de temps de ce projet (imaginez devoir recréer le flux binaire chaque fois qu'un morceau de verilog a été modifié pour tester le son). Cependant, le faire sur le fpga pourrait probablement être une meilleure façon de le faire, éliminant éventuellement le problème de ne pas pouvoir calculer les échantillons assez rapidement et permettant d'exécuter plus de chaînes, d'harmoniques et même d'effets audio ou d'autres tâches sur le côté processeur.

Étape 6: Câblage des capteurs

Pour créer les cordes, nous avons utilisé des capteurs de faisceau infrarouge qui détecteront quand la corde est jouée. Nous avons commandé nos capteurs à partir du lien suivant. Les capteurs ont un fil d'alimentation, de terre et de données tandis que les émetteurs n'ont qu'un fil d'alimentation et de terre. Nous avons utilisé les broches de 3,3 V et de masse des en-têtes PMOD pour alimenter à la fois les émetteurs et les capteurs. Pour alimenter tous les capteurs et émetteurs, il est nécessaire de connecter tous les capteurs et émetteurs en parallèle. Les fils de données des capteurs devront chacun aller à leur propre broche pmod.

Étape 7: Construire le squelette

Afin de créer la forme de la harpe, les trois pièces sont utilisées comme squelette pour placer les capteurs et les émetteurs. Sur l'un des deux morceaux de tuyau en PVC de 18 pouces, alignez les capteurs et les émetteurs dans un ordre alterné à 1,5 pouces l'un de l'autre, puis collez-les au tuyau. Sur l'autre tuyau en PVC de 18 pouces, alignez les capteurs et les émetteurs dans un ordre alterné, mais assurez-vous de décaler l'ordre (c'est-à-dire que si le premier tuyau avait un capteur en premier, le second devrait avoir un émetteur en premier et vice versa). Il sera nécessaire de souder des fils plus longs sur les fils de données, d'alimentation et de terre pour s'assurer qu'ils pourront atteindre la carte.

Étape 8: Construire l'extérieur en bois

Cette étape est facultative mais fortement recommandée. L'extérieur en bois donne non seulement une belle apparence à la harpe, mais protège également les capteurs et les fils des dommages. Le cadre en bois peut être créé par un anneau rectangulaire en bois. L'intérieur du rectangle doit avoir une ouverture d'au moins 1-1/2 pouces pour s'adapter au squelette du tuyau et du capteur. Une fois le cadre construit, percez deux trous qui permettront aux fils du capteur et des émetteurs de sortir afin de les connecter à la carte.

*Remarque: Il est recommandé d'ajouter des points d'accès pour pouvoir retirer et insérer le squelette du tuyau au cas où des réparations ou de légers ajustements devraient être effectués.

Étape 9: Assembler toutes les pièces

Une fois toutes les étapes précédentes terminées, il est temps de construire la harpe. Placez d'abord le squelette du tuyau à l'intérieur de l'extérieur en bois. Branchez ensuite les fils des capteurs et des émetteurs au bon endroit sur la carte. Ouvrez ensuite le SDK et cliquez sur le bouton de débogage pour programmer la carte. Une fois la carte programmée, branchez un casque ou un haut-parleur. Selon quel capteur se retrouve dans quel port pmod, les cordes de votre harpe seront probablement en panne pour commencer. Parce qu'il peut être difficile de dire quel fil va à quel capteur lorsque tant de fils sont impliqués, nous avons inclus un moyen de mapper les numéros de chaîne pour interrompre les positions des bits dans le logiciel. Recherchez "static int sensor_map[NUM_STRINGS]" et ajustez les valeurs dans le tableau jusqu'à ce que les chaînes soient lues du plus bas au plus élevé dans l'ordre.

Le menu peut être utilisé en ouvrant un terminal série (par exemple RealTerm) et en définissant le débit en bauds sur 115200 et l'affichage sur ANSI. Le menu peut être parcouru en utilisant les touches w et s pour monter et descendre et les touches a et d pour modifier les valeurs.

Étape 10: DÉBARQUEZ-VOUS

Une fois la harpe pleinement fonctionnelle. Maîtrisez la harpe et écoutez le doux son de votre propre musique !