Cactus 2000 : 7 étapes

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

PROJET MIDI-CONTROLEUR EISE4

Français:

Lors de notre quatrième année d'école d'ingénieur, nous avons réalisé un midi-contrôleur. Pour ce faire, nous avions à notre disposition:

• Une carte DE0 Nano Soc
• Des oscilloscopes, des multimètres
• Des composants de différents types (amplificateur, résistance, capacité…)
• Un micro et un haut-parleur
• Un petit écran

Il nous a fallu passer par différentes étapes périlleuses afin de réussir le projet. Nous allons vous présenter dans cet Instructable.

Pour commencer, le dessin du circuit de base était nécessaire afin de récupérer le son du micro et le rendre au haut-parleur. Une fois le circuit dessiner, le PCB était à faire sur le logiciel Altium. Pendant que deux élèves s'occupaient de gérer les PCB de l'entrée et de la sortie, les deux autres s'occupaient de faire fonctionner la carte DE0 Nano Soc afin que la carte puisse récupérer les échantillons du micro et redonner un signal pour le haut-parleur. Enfin, il nous a fallu créer des effets sonores pour modifier le son.

Anglais:

Au cours de notre quatrième année d'école, nous avons réalisé un contrôleur midi. Pour ce faire, nous avions à notre disposition:

• Une carte DE0 Nano Soc
• Oscilloscopes, multimètres
• Composants de différents types (amplificateur, résistance, capacité…)
• Un microphone et un haut-parleur
• Un petit écran

Nous avons dû passer par différentes étapes périlleuses pour faire du projet un succès. Nous allons vous présenter ce Instructable.

Tout d'abord, la conception du circuit de base nécessaire pour récupérer les fils du micro et en faire le haut-parleur. Une fois le circuit tracé, le PCB était à faire sur le logiciel Altium. Pendant que deux étudiants étaient occupés à gérer les PCB d'entrée et de sortie, les deux autres travaillaient à faire fonctionner la carte DE0 Nano Soc afin que la carte puisse capter les échantillons de micro et donner un signal au haut-parleur. Enfin, nous avons dû créer des effets sonores pour changer le son.

Étape 1: Conception Du Circuit En Entrée / Conception du Circuit d'Entrée

Français:

La première étape consiste à mettre en place un circuit qui peut prendre le signal d'envoi sur le micro pour le transmettre à la carte DE0 Nano Soc.

Ci-dessus le schéma de notre entrée.

(1) L'inverseur va permettre de récupérer le 5 Volt et le transformateur en - 5 V. Le - 5 V servira pour l'amplificateur que nous verrons ci-dessous.

(2) Ici, nous avons un amplificateur non inverseur. D'après la formule suivante:

Vs = Ve(1 + Z1/Z2)

On a choisi un gain de 101 en mettant R1 = 100 kOhm et R2 = 1 kOhm.

Cet amplificateur va servir un amplificateur le son du micro.

(3) Les deux résistances vont créer un offset afin que la tension de sortie soit comprise entre 0 et 4 V.

(4) Le micro qui va être amplificateur par l'amplificateur.

(5) CAG (Contrôle Automatique de Gain)

(6) Pour finir, nous avons créé un filtre passe-bas du second ordre avec deux RC. L'ordre 2 était nécessaire pour avoir une atténuation de - 40db / décennie. La fréquence de coupure est de 20 kHz.

Anglais:

La première étape consiste à mettre en place un circuit capable de prendre le signal envoyé sur le microphone pour le transmettre à la carte DE0 Nano Soc. Ci-dessus le schéma de notre entrée.

(1) L'onduleur récupérera le 5 Volt et le transformera en - 5 V. Le - 5 V servira à l'amplificateur que nous verrons ci-dessous.

(2) Ici, nous avons un amplificateur non inverseur. Selon la formule suivante:

Vs = Ve (1 + Z1 / Z2)

Un gain de 101 a été choisi en réglant R1 = 100 kOhm et R2 = 1 kOhm.

Cet amplificateur servira à amplifier le son du microphone.

(3) Les deux résistances vont créer un décalage pour que la tension de sortie soit comprise entre 0 et 4 V.

(4) Le microphone qui sera amplifié par l'amplificateur.

(5) AGC (contrôle automatique de gain)

(6) Enfin, nous avons créé un filtre passe-bas de second ordre avec deux RC. L'ordre 2 était nécessaire pour avoir une atténuation de -40db/décade. La fréquence de coupure choisie est de 20 kHz.

Étape 2: Conception Du Circuit En Sortie / Design of the Output Circuit

Français:

Dans un second temps, nous avons pensé à la création du circuit en sortie.

Ci-dessus le schéma de notre sortie.

(1) Le DAC (Digital to Analog Converter) qui va permettre de récupérer le signal numérique envoyer par la carte DE0 Nano Soc et le convertir en signal analogique (nécessaire pour le haut parleur)

(2) La capacité va servir à virer la composante continue de notre signal.

(3) Montage qui va permettre d'amplifier la puissance de notre signal. Nous avons pris le schéma:

www.ti.com/lit/ds/symlink/lm386.pdf

page 10

Ce schéma permet d'avoir un gain de 200 qui est nécessaire car notre signal est vraiment faible.

Anglais:

Ci-dessus le schéma de notre sortie.

(1) Le DAC (Digital to Analog Converter) qui va permettre de récupérer le signal numérique envoyé par la carte DE0 Nano Soc et de le convertir en un signal analogique (nécessaire pour le haut-parleur).

(2) La capacité sera utilisée pour transférer la composante continue de notre signal.

(3) Montage qui amplifiera la puissance de notre signal. Nous avons pris le schéma:

www.ti.com/lit/ds/symlink/lm386.pdf

page 10

Ce schéma permet d'avoir un gain de 200 ce qui est nécessaire car notre signal est vraiment faible.

Étape 3: Conception Des PCB / Conception du PCB

Français:

Une fois que nos circuits ont été instanciés il nous a fallu les mettre sur des PCB.

Pour ce faire, nous avons utilisé le logiciel Altium. Il faut que tout soit correctement connecté puis cliquer sur:

Conception de menu -> Mettre à jour le document PCB.

Ensuite, cliquez sur « Valider les modifications ». Pour chaque changement validé, un crochet vert apparaît dans la colonne: « Check ».

Après cela, vous aurez un nouvel onglet qui va s'ouvrir et il faudra placer les composants dans cette fenêtre.

Puis, il faut aller dans le menu "Fichier" -> "Fabrication Output" -> "Gerber Files"

Une fenêtre s'ouvre, dans celle-ci vous trouverez;

• Le menu "Layers" qui vous permettra de choisir sur quel layer va s'appuyer sur votre PCB.
• Le menu "Drill Drawing" dans lequel il faut que tout soit décocher.
• Le menu "Apertures" dans lequel il faut cocher "Embedded Apertures".

Toutes ses étapes sont-elles complétées ?

Revenons maintenant à la fenêtre avec les composants sur celle-ci vous cliquez sur

Fichier -> Sortie de fabrication -> Fichiers de perçage CN

C'est enfin fini, il ne reste plus qu'à donner à l'imprimante 3D les fichiers.

Vous trouverez ci-joint les photos de nos deux PCB.

Anglais:

Une fois nos circuits instanciés, nous avons dû les mettre sur PCB.

Pour ce faire, nous utilisons le logiciel Altium. Tout doit être correctement connecté puis cliquez sur:

Conception de menu -> Mettre à jour le document PCB.

Cliquez ensuite sur "Valider les modifications". Pour chaque modification validée, une coche verte apparaît dans la colonne "Vérifier".

Après cela, vous aurez un nouvel onglet qui s'ouvrira et vous devrez placer les composants dans cette fenêtre.

Ensuite, vous devez aller dans le menu "Fichier" -> "Sortie de sortie" -> "Fichiers Gerber"

Une fenêtre s'ouvre, dans celle-ci vous trouverez;

Le menu "Layers" qui vous permettra de choisir quelles couches supporteront votre PCB. Le menu "Drill Drawing" où tout doit être décoché. Le menu "Ouvertures" dans lequel vous devez cocher "Ouvertures intégrées".

Toutes ses démarches sont-elles terminées ?

Revenons maintenant à la fenêtre avec les composants sur celui-ci sur lequel vous cliquez

Fichier -> Sortie de fabrication -> Fichiers de perçage CN

C'est enfin terminé, il ne vous reste plus qu'à donner les fichiers à l'imprimante 3D.

Vous trouverez ci-joint les photos de nos deux PCB.

Étape 4: Périphériques Pour La Carte DE0 Nano Soc / Peripherals for the DE0 Nano Soc Card

Français:

Les cœurs IP sont optimisés pour les périphériques Intel FPGA et peuvent être implémentés pour réduire la conception et le temps de test.

Grâce au logiciel Qsys nous avons pu créer des périphériques embarqués dans notre carte.

Voici une liste des périphériques que nous avons ajouter:

• Communication SPI pour le DAC
• ADC pour récupérer les valeurs analogiques de notre signal et les convertir en données numériques
• HPS (processeur) pour gérer tout les codes
• GPIO pour les boutons qui vont servir à certains effets
• Mémoire (sur puce mémoire)

Anglais:

Les cœurs IP sont optimisés pour les périphériques Intel FPGA et peuvent être facilement mis en œuvre pour réduire le temps de conception et de test.

Grâce au logiciel Qsys nous avons pu créer des périphériques embarqués dans notre carte. Voici une liste des appareils que nous avons ajoutés:

• Communication SPI pour le DAC
• ADC pour récupérer les valeurs analogiques de notre signal et les convertir en données numériques
• HPS (processeur) pour gérer tous les codes
• GPIO pour les boutons qui serviront à faire face à certains effets
• Mémoire (sur la mémoire de la puce)

Étape 5: L'écran LT24

Français:

Il nous a fallu comprendre et gérer l'écran LT24 celui-ci sera guidé par un processeur simulé NIOS.

Pour l'initialisation, nous avons lu beaucoup de documentations sur celui-ci.

Au final, notre écran sert à afficher la FFT, à sélectionner l'effet voulu.

Anglais:

Il fallait comprendre et gérer l'écran LT24 il sera guidé par un processeur NIOS simulé. Pour l'initier, nous lisons beaucoup de documentation à son sujet.

Au final, notre écran sert à afficher la FFT, à l'effet désiré.

Étape 6: Codes Utiles En C++ / Codes Utiles en C++

Je vais vous montrer les codes en C++ qui nous ont utiles afin de réaliser des effets sonores.

Voici d'abord toutes nos déclarations (oui un peu exhaustif…):

Je vais vous montrer les codes en C++ qui nous ont été utiles pour créer des effets sonores.

Tout d'abord, toutes nos déclarations (oui un peu exhaustive…):

#comprendre

#include #include #include #include #include #include #include #include #include "WavUtils.cpp" #include "Biquad.cpp" #include #include #include #include "hps_0.h" #include "hps.h" #include "alt_gpio.h" #include "hwlib.h" #include "socal.h" #include #include "kiss_fft.h" #define nbpoint 1000 #define HW_REGS_BASE (ALT_STM_OFST) #define HW_REGS_SPAN (0x04000000) #define HW_REGK HW_REGS_SPAN - 1) #define PI 3.1415926535 #define NFFT 80 #define FE 41000 #define F2 10000 #define F1 5925 #define PH 5000 #define PB 15000 #define MOD 2000 using namespace std; const long SAMPLE_RATE = 1250000; // Création de la configuration et des buffers in et out pour s(t) et S(f) const kiss_fft_cfg config = kiss_fft_alloc(NFFT, 0, NULL, NULL); const kiss_fft_cfg config_inv = kiss_fft_alloc(NFFT, 1, NULL, NULL); kiss_fft_cpx* dans = (kiss_fft_cpx*)malloc(NFFT*sizeof(kiss_fft_cpx)); kiss_fft_cpx* out = (kiss_fft_cpx*)malloc(NFFT*sizeof(kiss_fft_cpx)); kiss_fft_cpx* inv = (kiss_fft_cpx*)malloc(NFFT*sizeof(kiss_fft_cpx));queueoutBuf; entier global = 0; entier i = 0; données courtes, data2;

Ci-dessous une de nos fonctions permettant la modulation:

Ci-dessous une de nos fonctions permettant la modulation:

void modulation (int freq)

{ if(i<NFFT) { data=data*cos(2*PI*freq*i/FE); in.r=données; je++; } else i="0"; }

Voici notre fonction principale:

Ces notre fonction principale:

int main(int argc, char **argv)

{ volatile non signé long *h2p_lw_spi_addr=NULL; volatile non signé long *h2p_lw_led_addr=NULL; volatile non signé long *h2p_lw_adc_addr=NULL; volatile non signé long *h2p_lw_blue_addr=NULL; volatile non signé long *h2p_lw_red_addr=NULL; volatile non signé long *h2p_lw_black_addr=NULL; void *base_virtuelle; int fd; printf("1\n"); // mappe l'espace d'adressage des registres spi dans l'espace utilisateur afin que nous puissions interagir avec eux. // nous allons en fait mapper dans l'ensemble de l'étendue CSR du HPS car nous voulons accéder à divers registres dans cette étendue if((fd = open("/dev/mem", (O_RDWR | O_SYNC))) == -1) { printf("ERREUR: impossible d'ouvrir \"/dev/mem\"…\n"); retour(1); } printf("2\n"); virtual_base = mmap(NULL, HW_REGS_SPAN, (PROT_READ | PROT_WRITE), MAP_SHARED, fd, HW_REGS_BASE); printf("3\n"); if(virtual_base == MAP_FAILED) { printf("ERREUR: mmap() a échoué…\n"); fermer(fd); retour(1); } printf("4\n"); printf("5\n"); h2p_lw_spi_addr = virtual_base + ((non signé long) (ALT_LWFPGASLVS_OFST + SPI_0_BASE) & (non signé long) (HW_REGS_MASK)); h2p_lw_led_addr = virtual_base + ((non signé long) (ALT_LWFPGASLVS_OFST + PIO_LED_BASE) & (non signé long) (HW_REGS_MASK)); h2p_lw_adc_addr = virtual_base + ((non signé long) (ALT_LWFPGASLVS_OFST + ADC_0_BASE) & (non signé long) (HW_REGS_MASK)); h2p_lw_blue_addr= virtual_base + ((non signé long) (ALT_LWFPGASLVS_OFST + PIO_BLUE_BASE) & (non signé long) (HW_REGS_MASK)); h2p_lw_black_addr= virtual_base + ((non signé long) (ALT_LWFPGASLVS_OFST + PIO_BLACK_BASE) & (non signé long) (HW_REGS_MASK)); h2p_lw_red_addr= virtual_base + ((non signé long) (ALT_LWFPGASLVS_OFST + PIO_RED_BASE) & (non signé long) (HW_REGS_MASK)); //int i=0; données int; entier i= 0, j; // Création de la configuration et des buffers in et out pour s(t) et S(f) const kiss_fft_cfg config = kiss_fft_alloc(NFFT, 0, NULL, NULL); kiss_fft_cpx* dans = (kiss_fft_cpx*)malloc(NFFT*sizeof(kiss_fft_cpx)); kiss_fft_cpx* out = (kiss_fft_cpx*)malloc(NFFT*sizeof(kiss_fft_cpx)); while(1){ data = *(h2p_lw_adc_addr+2); if(*h2p_lw_blue_addr == 1) data = echo(data, 20); if(*h2p_lw_black_addr == 1) alt_write_word(h2p_lw_led_addr, 0x0F); if(*h2p_lw_red_addr == 0) alt_write_word(h2p_lw_led_addr, 0xF0); alt_write_word(h2p_lw_spi_addr+1, données | 0b111000000000000); } libre(config); libre (dans); libre (hors); renvoie 0; }

Étape 7: La Finale / la Finale

Français:

Eh voilà (enfin) le rendu final de notre Cactus 2000.

Nous avons mis les PCB entrée et sortie qui sont reliés à la carte DE0 Nano Soc.

Ensuite, ses composants sont placés à l'intérieur d'une boite jaune.

Sur la boîte on trouve un potentiomètre à glissière, qui permet de gérer le volume du son, des potentiomètres et des boutons qui permettrons de lancer certains effets, ainsi qu'un écran qui permettra d'afficher la FFT.

Le haut-parleur est déterminé par rapport aux boutons. Le micro est confiné à l'autre coté de la boîte par rapport au haut-parleur.

C'est tout pour aujourd'hui.

En espérant que cet Instructable vous soit utile.

Anglais:

Nous voici (enfin) le rendu final de notre Cactus 2000.

Nous mettons les PCB d'entrée et de sortie qui sont connectés à la carte DE0 Nano Soc.

Ensuite, ses composants sont placés à l'intérieur d'une boîte jaune.

Sur la box se trouve un potentiomètre à glissière, qui permet de gérer le volume du son, des potentiomètres et boutons qui lanceront certains effets, et un écran qui affichera la FFT.

Le haut-parleur est positionné perpendiculairement aux boutons. Le microphone est positionné de l'autre côté du boîtier par rapport au haut-parleur.

C'est tout pour aujourd'hui.

En espérant que ce Instructable vous soit utile.