- Qu'est-ce qu'un générateur de fonctions DDS?
- Comprendre le fonctionnement du circuit intégré du générateur de fonctions AD9833
- Composants requis pour construire le générateur de fonctions basé sur AD9833
- Générateur de fonctions basé sur AD9833 - Diagramme schématique
- Générateur de fonctions basé sur AD9833 - Code Arduino
- Test du générateur de fonctions basé sur AD9833
- Autres améliorations
Si vous êtes un passionné d'électronique comme moi qui souhaite modifier différents circuits électroniques, avoir un générateur de fonctions décent devient parfois obligatoire. Mais en posséder un est un problème car un tel équipement de base peut coûter une fortune. Construire votre propre équipement de test est non seulement moins cher, mais aussi un excellent moyen d'améliorer vos connaissances.
Donc, dans cet article, nous allons construire un générateur de signaux simple avec Arduino et le module générateur de fonctions AD9833 DDS qui peut produire des ondes sinusoïdales, carrées et triangulaires avec une fréquence maximale de 12 MHz en sortie. Et enfin, nous allons tester la fréquence de sortie à l'aide de notre oscilloscope.
Nous avons déjà construit un générateur d'onde sinusoïdale simple, un générateur d'onde carrée et un générateur d'onde triangulaire à l'aide de circuits analogiques de base. Vous pouvez les vérifier si vous recherchez des circuits de générateur de forme d'onde de base. De plus, si vous souhaitez créer un générateur de fonctions Arduino moins cher sans utiliser le module AD9833, vous pouvez consulter le projet DIY Arduino Waveform Generator.
Qu'est-ce qu'un générateur de fonctions DDS?
Comme son nom l'indique, un générateur de fonctions est un appareil qui peut produire une forme d'onde spécifique avec une fréquence spécifique lors du réglage. Par exemple, considérez que vous avez un filtre LC pour lequel vous souhaitez tester votre réponse en fréquence de sortie, vous pouvez facilement le faire à l'aide d'un générateur de fonctions. Tout ce que vous avez à faire est de définir la fréquence et la forme d'onde de sortie souhaitées, puis vous pouvez la réduire ou la monter afin de tester la réponse. Ce n'était qu'un exemple, vous pouvez en faire plus au fur et à mesure que la liste s'allonge.
DDS signifie Direct Digital Synthesis. C'est un type de générateur de forme d' onde qui utilise des convertisseurs numérique-analogique (DAC) pour créer un signal à partir de la base. Cette méthode est spécifiquement utilisée pour générer une onde sinusoïdale. Mais le CI que nous utilisons peut produire des signaux d'onde carrée ou triangulaire. Les opérations qui se sont produites à l'intérieur d'une puce DDS sont numériques, ce qui permet de changer la fréquence très rapidement ou de passer d'un signal à un autre très rapidement. Cet appareil a une résolution de fréquence fine avec un large spectre de fréquences.
Comprendre le fonctionnement du circuit intégré du générateur de fonctions AD9833
Au cœur de notre projet se trouve le circuit intégré de générateur de signaux programmables AD9833 qui est conçu et développé par des appareils analogiques. Il s'agit d'un générateur de formes d'onde programmable de faible puissance capable de produire des ondes sinusoïdales, triangulaires et carrées avec une fréquence maximale de 12 MHz. C'est un circuit intégré unique qui est capable de modifier la fréquence et la phase de sortie avec juste un logiciel. Il dispose d'une interface SPI à 3 fils, c'est pourquoi la communication avec ce circuit intégré devient très simple et facile. Le schéma fonctionnel de ce circuit intégré est illustré ci-dessous.
Le fonctionnement de ce CI est très simple. Si nous jetons un œil au schéma fonctionnel ci-dessus, nous observerons que nous avons un accumulateur de phase dont le travail est de stocker toutes les valeurs numériques possibles d'une onde sinusoïdale, à partir de 0 à 2π. Ensuite, nous avons la ROM SIN dont le travail est de convertir les informations de phase qui peuvent ensuite être directement mappées en amplitude. La ROM SIN utilise les informations de phase numériques comme adresse d'une table de consultation et convertit les informations de phase en amplitude. Et enfin, nous avons un convertisseur numérique-analogique 10 bits dont le travail est de recevoir les données numériques du SIN ROM et de les convertir en tensions analogiques correspondantes, c'est ce que nous obtenons de la sortie. En sortie, nous avons également un interrupteur que nous pouvons activer ou désactiver avec juste un petit code logiciel. Nous en reparlerons plus tard dans l'article.Les détails que vous voyez ci-dessus sont une version très épurée de ce qui se passe à l'intérieur du CI, et la plupart des détails que vous voyez ci-dessus sont tirés de la fiche technique AD9833, vous pouvez également les consulter pour plus d'informations.
Composants requis pour construire le générateur de fonctions basé sur AD9833
Les composants requis pour construire le générateur de fonctions basé sur AD9833 sont listés ci-dessous, nous avons conçu ce circuit avec des composants très génériques, ce qui rend le processus de réplication très facile.
- Arduino Nano - 1
- AD9833 Générateur de fonctions DDS - 1
- Écran OLED 128 X 64 - 1
- Encodeur rotatif générique - 1
- DC Barrel Jack - 1
- Régulateur de tension LM7809 - 1
- Condensateur 470uF - 1
- Condensateur 220uF - 1
- Condensateur 104pF - 1
- Résistance 10K - 6
- Interrupteurs tactiles - 4
- Borne à vis 5,04 mm - 1
- En-tête femelle - 1
- Source d'alimentation 12 V - 1
Générateur de fonctions basé sur AD9833 - Diagramme schématique
Le schéma de circuit complet du générateur de fonctions AD9833 et Arduino est illustré ci-dessous.
Nous allons utiliser l' AD9833 avec Arduino pour générer la fréquence souhaitée. Et dans cette section, nous expliquerons tous les détails à l'aide du schéma; laissez-moi vous donner un bref aperçu de ce qui se passe avec le circuit. Commençons par le module AD9833. Le module AD9833 est le module générateur de fonctions et il est connecté à l'Arduino selon le schéma. Pour alimenter le circuit, nous utilisons un circuit intégré de régulateur de tension LM7809, avec un condensateur de découplage décent, cela est nécessaire car le bruit d'alimentation peut interférer avec le signal de sortie, ce qui entraîne une sortie indésirable. Comme toujours, l'Arduino fonctionne comme le cerveau de ce projet. Pour afficher la fréquence définie et d'autres informations précieuses, nous avons connecté un module d'affichage OLED 128 X 64. Pour changer la gamme de fréquences, nous utilisons trois commutateurs. Le premier définit la fréquence sur Hz, le second définit la fréquence de sortie sur KHz et le troisième définit la fréquence sur MHz, nous avons également un autre bouton qui peut être utilisé pour activer ou désactiver la sortie. Enfin, nous avons l'encodeur rotatif,et nous devons y attacher une résistance de rappel, sinon ces commutateurs ne fonctionneront pas car nous vérifions l'événement de pression de bouton sur la méthode de mise en commun. L'encodeur rotatif est utilisé pour changer la fréquence et le commutateur tactile à l'intérieur de l'encodeur rotatif est utilisé pour sélectionner la forme d'onde réglée.
Générateur de fonctions basé sur AD9833 - Code Arduino
Le code complet utilisé dans ce projet se trouve au bas de cette page. Après avoir ajouté les fichiers d'en-tête et les fichiers source requis, vous devriez être en mesure de compiler directement le fichier Arduino. Vous pouvez télécharger la bibliothèque Arduino ad9833 et d'autres bibliothèques à partir du lien ci-dessous ou vous pouvez utiliser la méthode du gestionnaire de cartes pour installer la bibliothèque.
- Télécharger la bibliothèque AD9833 par Bill Williams
- Télécharger la bibliothèque OLED SSD1306 par Adafruit
- Télécharger la bibliothèque Adafruit GFX
L'explication du code dans l' ino. fichier est comme suit. Tout d'abord, nous commençons par inclure toutes les bibliothèques requises. La bibliothèque pour le module AD9833 DDS est d'abord suivie de la bibliothèque pour OLED et la bibliothèque mathématique est requise pour certains de nos calculs.
#include // Bibliothèque pour le module AD9833 #include
Ensuite, nous définissons toutes les broches d'entrée et de sortie nécessaires pour les boutons, le commutateur, l'encodeur rotatif et les OLED.
#define SCREEN_WIDATA_PINH 128 // Largeur d'affichage OLED en pixels #define SCREEN_HEIGHT 64 // Hauteur d'affichage OLED, en pixels #define SET_FREQUENCY_HZ A2 // Bouton-poussoir pour régler la fréquence en Hz #define SET_FREQUENCY_KHZ A3 // Bouton-poussoir pour régler la fréquence en Khz_FREQUENCY_KHZ A3 // Bouton-poussoir pour régler la fréquence en Khz_FREQUENCY_KHZ A6 // Bouton-poussoir pour régler la fréquence en Mhz #define ENABLE_DISABLE_OUTPUT_PIN A7 // Bouton-poussoir pour activer / désactiver la sortie #define FNC_PIN 4 // Fsync Requis par le module AD9833 #define CLK_PIN 8 // Broche d'horloge du codeur #define DATA_PIN 7 / / Data Pin du codeur #define BTN_PIN 9 // Bouton poussoir interne sur le codeur
Par la suite, nous définissons toutes les variables nécessaires qui sont requises dans ce code. Tout d'abord, nous définissons un compteur de variables entières qui stockera la valeur du codeur rotatif. Les deux variables suivantes clockPin et clockPinState stockent la statue de broche nécessaire pour comprendre la direction du codeur. Nous avons une variable de temps qui contient les valeurs actuelles du compteur de minuterie, cette variable est utilisée pour la suppression des boutons. Ensuite, nous avons un moduleFrequency variable long non signé qui contient la fréquence calculée qui va être appliquée. Ensuite, nous avons le délai anti - rebond. Ce délai peut être ajusté selon les besoins. Ensuite, nous avons trois variables booléennes set_frequency_hz,set_frequency_Khz et set_frequency_Mhz, ces trois variables sont utilisées pour déterminer le réglage actuel du module. Nous en reparlerons plus en détail plus loin dans l'article. Ensuite, nous avons la variable qui stocke l'état de la forme d'onde de sortie, la forme d'onde de sortie par défaut est une onde sinusoïdale. Et enfin, nous avons la variable encoder_btn_count qui contient le nombre de boutons d'encodeur qui est utilisé pour définir la forme d'onde de sortie.
compteur int = 1; // Cette valeur de compteur augmentera ou diminuera si lorsque le codeur rotatif est tourné int clockPin; // Espace réservé pour l'état des broches utilisé par le codeur rotatif int clockPinState; // Espace réservé pour l'état des broches utilisé par le codeur rotatif unsigned long time = 0; // Utilisé pour le débouncing long moduleFrequency non signé; // utilisé pour définir la fréquence de sortie long debounce = 220; // Retard anti-rebond bool btn_state; // utilisé pour activer la sortie de désactivation du module AD98333 bool set_frequency_hz = 1; // Fréquence par défaut du module AD9833 bool set_frequency_khz; booléen set_frequency_mhz; String waveSelect = "SIN"; // Forme d'onde de démarrage du module int encoder_btn_count = 0; // utilisé pour vérifier la pression du bouton de l'encodeur Ensuite, nous avons nos deux objets, l'un est pour l'affichage OLED et un autre pour le module AD9833.Affichage Adafruit_SSD1306 (SCREEN_WIDATA_PINH, SCREEN_HEIGHT, & Wire, -1); AD9833 gen (FNC_PIN);
Ensuite, nous avons notre fonction setup (), dans cette fonction de configuration, nous commençons par activer le Serial pour le débogage. Nous initialisons le module AD9833 à l'aide de la méthode begin (). Ensuite, nous définissons toutes les broches de l'encodeur rotatif affectées comme entrée. Et nous stockons la valeur de la broche d'horloge dans la variable clockPinState, c'est une étape nécessaire pour l'encodeur rotatif.
Ensuite, nous définissons toutes les broches de bouton comme entrée et activons l'affichage OLED à l'aide de la méthode display.begin () , et nous vérifions également les erreurs avec une instruction if . Lorsque cela est fait, nous effaçons l'affichage et imprimons un écran de démarrage de démarrage, nous ajoutons un délai de 2 secondes qui est également le délai de l'écran de démarrage, et enfin, nous appelons la fonction update_display () qui efface l'écran et met à jour le afficher à nouveau. Les détails de la méthode update_display () seront abordés plus loin dans l'article.
void setup () {Serial.begin (9600); // Activer Serial @ 9600 baud gen.Begin (); // Cela DOIT être la première commande après avoir déclaré l'objet AD9833 pinMode (CLK_PIN, INPUT); // Définition des broches comme entrée pinMode (DATA_PIN, INPUT); pinMode (BTN_PIN, INPUT_PULLUP); clockPinState = digitalRead (CLK_PIN); pinMode (SET_FREQUENCY_HZ, INPUT); // Définition des broches comme entrée pinMode (SET_FREQUENCY_KHZ, INPUT); pinMode (SET_FREQUENCY_MHZ, INPUT); pinMode (ENABLE_DISABLE_OUTPUT_PIN, INPUT); if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Adresse 0x3D pour 128x64 Serial.println (F ("L'allocation SSD1306 a échoué")); pour (;;); } display.clearDisplay (); // Effacer l'écran display.setTextSize (2); // Définit la taille du texte display.setTextColor (WHITE); // définir la couleur LCD display.setCursor (30, 0); // Définir la position du curseur display.println ("AD9833"); // Imprime l'affichage de ce texte.setCursor (17, 20); // Définir la position du curseur display.println ("Function"); // Affiche ce texte display.setCursor (13, 40); // Définir la position du curseur display.println ("Generator"); // Imprimer ce texte display.display (); // Mettre à jour le délai d'affichage (2000); // Délai de 2 SEC update_display (); // Appel de la fonction update_display}
Ensuite, nous avons notre fonction loop (), toutes les fonctionnalités principales sont écrites dans la section loop.
Tout d'abord, nous lisons la broche Clock du Rotary encoder et la stockons dans la variable clockPin que nous avons déclarée précédemment. Ensuite, dans l' instruction if , nous vérifions si la valeur précédente de la broche et la valeur actuelle de la broche sont similaires ou non et nous vérifions également la valeur actuelle de la broche. Si tout est vrai, nous vérifions la broche de données, si c'est vrai, cela signifie que l'encodeur tourne dans le sens antihoraire et nous décrémentons la valeur du compteur à l'aide de la commande contre- commande. Sinon, nous incrémentons la valeur du compteur avec la commande counter ++. Enfin, nous mettons une autre instruction if pour définir la valeur minimale sur 1. Ensuite, nous mettons à jour le clockPinState avec le clockPin actuelvaleur pour une utilisation future.
boucle vide () {clockPin = digitalRead (CLK_PIN); if (clockPin! = clockPinState && clockPin == 1) {if (digitalRead (DATA_PIN)! = clockPin) {compteur -; } else {counter ++; // L'encodeur tourne CW donc incrémenter} if (counter <1) counter = 1; Serial.println (compteur); update_display (); }
Ensuite, nous avons notre code pour détecter une pression sur un bouton. Dans cette section, nous avons détecté le bouton à l'intérieur de l'encodeur à l'aide de quelques instructions if imbriquées, if (digitalRead (BTN_PIN) == LOW && millis () - time> denounce), dans cette instruction, nous vérifions d'abord si le bouton la broche est basse ou non, si elle est basse, c'est qu'elle est enfoncée Ensuite, nous vérifions à nouveau la valeur de la minuterie avec le délai anti-rebond, si les deux déclarations sont vraies, nous le déclarons alors une action de pression de bouton réussie si c'est le cas, nous incrémentons la valeur encoder_btn_count. Ensuite, nous déclarons une autre instruction if pour définir la valeur maximale du compteur sur 2, nous en avons besoin car nous l'utilisons pour définir la forme d'onde de sortie.Les trois instructions if consécutives font cela, si la valeur est zéro, la forme d'onde sinusoïdale est sélectionnée, si c'est une, c'est une onde carrée, et si la valeur est 2, c'est une onde triangulaire. Dans ces trois instructions if, nous mettons à jour l'affichage avec la fonction update_display () . Et enfin, nous mettons à jour la variable de temps avec la valeur actuelle du compteur de minuterie.
// Si nous détectons un signal LOW, le bouton est enfoncé si (digitalRead (BTN_PIN) == LOW && millis () - time> debounce) {encoder_btn_count ++; // Incrémente les valeurs if (encoder_btn_count> 2) // si la valeur est supérieure à 2 réinitialise-la à 0 {encoder_btn_count = 0; } if (encoder_btn_count == 0) {// si la valeur est 0 onde sinusoïdale est sélectionnée waveSelect = "SIN"; // met à jour la variable chaîne avec la valeur sin update_display (); // mettre à jour l'affichage} if (encoder_btn_count == 1) {// si la valeur est 1 onde carrée est sélectionné waveSelect = "SQR"; // met à jour la variable de chaîne avec la valeur SQR update_display (); // mettre à jour l'affichage} if (encoder_btn_count == 2) {// si la valeur est 1 Onde triangulaire est sélectionnée waveSelect = "TRI"; // met à jour la variable chaîne avec la valeur TRI update_display ();// met à jour l'affichage} time = millis (); // mettre à jour la variable de temps}
Ensuite, nous définissons tout le code nécessaire pour configurer tous les boutons avec un délai anti-rebond. Comme les boutons sont connectés aux broches analogiques de l'Arduino, nous utilisons la commande de lecture analogique pour identifier une pression sur un bouton si la valeur de lecture analogique atteint moins de 30, puis nous détectons une pression de bouton réussie et nous attendons 200 ms Vérifiez s'il s'agit d'une pression réelle sur un bouton ou d'un bruit uniquement. Si cette affirmation est vraie, nous affectons aux variables booléennes des valeurs qui sont utilisées pour définir les valeurs Hz, Khz et Mhz du générateur de fonctions. Ensuite, nous mettons à jour l'affichage et mettons à jour la variable de temps. Nous faisons cela pour les quatre boutons connectés à l'Arduino.
if (analogRead (SET_FREQUENCY_HZ) <30 && millis () - time> debounce) {set_frequency_hz = 1; // mise à jour des valeurs booléennes set_frequency_khz = 0; set_frequency_mhz = 0; update_display (); // mettre à jour le temps d'affichage = millis (); // mettre à jour la variable de temps} if (analogRead (SET_FREQUENCY_KHZ) <30 && millis () - time> debounce) {set_frequency_hz = 0; // mise à jour des valeurs booléennes set_frequency_khz = 1; set_frequency_mhz = 0; moduleFrequency = compteur * 1000; update_display (); // mettre à jour le temps d'affichage = millis (); // mettre à jour la variable de temps} if (analogRead (SET_FREQUENCY_MHZ) <30 && millis () - time> debounce) {// vérifier la broche analogique avec un délai d'anti-rebond set_frequency_hz = 0; // mise à jour des valeurs booléennes set_frequency_khz = 0; set_frequency_mhz = 1; moduleFrequency = compteur * 1000000; update_display ();// mettre à jour le temps d'affichage = millis (); // mettre à jour la variable de temps} if (analogRead (ENABLE_DISABLE_OUTPUT_PIN) <30 && millis () - time> debounce) {// vérifier la broche analogique avec un délai d'anti-rebond btn_state =! btn_state; // Inverser l'état du bouton gen.EnableOutput (btn_state); // Activer / Désactiver la sortie du générateur de fonctions en fonction de l'état du bouton update_display (); // mettre à jour le temps d'affichage = millis (); // mettre à jour la variable de temps}}// mettre à jour la variable de temps}}// mettre à jour la variable de temps}}
Enfin, nous avons notre fonction update_display (). Dans cette fonction, nous avons fait beaucoup plus que simplement mettre à jour cet écran car une certaine partie de l'écran ne peut pas être mise à jour dans un OLED. Pour le mettre à jour, vous devez le repeindre avec de nouvelles valeurs. Cela rend le processus de codage beaucoup plus difficile.
Dans cette fonction, nous commençons par effacer l'affichage. Ensuite, nous définissons notre taille de texte requise. Ensuite, nous positionnons notre curseur et le générateur de fonctions imprimé avec display.println ("Function Function"); commander. Nous définissons à nouveau la taille du texte sur 2 et le curseur sur (0,20) à l'aide de la fonction display.setCursor (0, 20).
C'est ici que nous imprimons les informations pour quelle vague il s'agit.
display.clearDisplay (); // Efface d'abord l'affichage display.setTextSize (1); // définir la taille du texte display.setCursor (10, 0); // Définit la position du curseur display.println ("Function Generator"); // imprimer le texte display.setTextSize (2); // définir la taille du texte display.setCursor (0, 20); // définir la position du curseur
Ensuite, nous vérifions les variables booléennes pour les détails de fréquence et mettons à jour la valeur dans la variable moduleFrequency. Nous faisons cela pour les valeurs Hz, kHz et MHz. Ensuite, nous vérifions la variable waveSelect et identifions quelle vague est sélectionnée. Maintenant, nous avons les valeurs pour définir le type d'onde et la fréquence.
if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {// vérifier si le bouton de réglage de la fréquence en Hz est enfoncé moduleFrequency = counter; // mettre à jour la variable moduleFrequency avec la valeur actuelle du compteur} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {// vérifier si le bouton de réglage de la fréquence en KHz est enfoncé moduleFrequency = counter * 1000; // mettre à jour la variable moduleFrequency avec la valeur actuelle du compteur mais nous multiplions 1000 pour la définir sur KHZ} if (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {// vérifier si le bouton de réglage de la fréquence en MHz est enfoncé moduleFrequency = compteur * 1000000; if (moduleFrequency> 12000000) {moduleFrequency = 12000000;// ne laissez pas la fréquence râper que le compteur 12Mhz = 12; }} if (waveSelect == "SIN") {// L'onde sinusoïdale est sélectionnée display.println ("SIN"); gen.ApplySignal (SINE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "SQR") {// Sqr wave est sélectionné display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave est sélectionné display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // mettre à jour le module AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Sqr wave est sélectionné display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave est sélectionné display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // mettre à jour le module AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Sqr wave est sélectionné display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave est sélectionné display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // mettre à jour le module AD9833. Serial.println (moduleFrequency); }
Nous remettons le curseur et mettons à jour les valeurs du compteur. Encore une fois, nous vérifions le booléen pour mettre à jour la plage de fréquences sur l'écran, nous devons le faire car le principe de fonctionnement de l'OLED est très étrange.
display.setCursor (45, 20); display.println (compteur); // imprime les informations du compteur sur l'écran. if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Hz"); // imprime Hz sur l'affichage display.display (); // quand tout est mis à jour l'affichage} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Khz"); display.display (); // quand tout est mis à jour l'affichage} if (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {display.setCursor (90, 20); display.println ("Mhz"); display.display (); // quand tout est mis à jour l'affichage}
Ensuite, nous vérifions la variable de pression du bouton pour activer / désactiver la sortie sur l'OLED. Encore une fois, cela doit être fait à cause du module OLED.
if (btn_state) {display.setTextSize (1); display.setCursor (65, 45); display.print ("Output ON"); // impression de la sortie sur l'écran display.display (); display.setTextSize (2); } else {display.setTextSize (1); display.setCursor (65, 45); display.print ("Output OFF"); // impression de la sortie sur l'affichage display.display (); display.setTextSize (2); }
Cela marque la fin de notre processus de codage. Si vous êtes confus à ce stade, vous pouvez vérifier les commentaires dans le code pour une meilleure compréhension.
Test du générateur de fonctions basé sur AD9833
Pour tester le circuit, la configuration ci-dessus est utilisée. Comme vous pouvez le voir, nous avons connecté un adaptateur d'alimentation 12 V CC à la prise cylindrique CC et nous avons connecté l'oscilloscope Hantek à la sortie du circuit. Nous avons également connecté l'oscilloscope à l'ordinateur portable pour visualiser et mesurer la fréquence de sortie.
Une fois que cela a été fait, nous réglons la fréquence de sortie à 5Khz à l'aide de l'encodeur rotatif et nous testons l'onde sinusoïdale de sortie et bien sûr, c'est une onde sinusoïdale de 5Khz en sortie.
Ensuite, nous avons changé la forme d'onde de sortie en une onde triangulaire mais la fréquence est restée la même, la forme d'onde de sortie est indiquée ci-dessous.
Ensuite, nous avons changé la sortie en une onde carrée et observé la sortie, et c'était une onde carrée parfaite.
Nous avons également modifié les gammes de fréquences et testé la sortie, et cela fonctionnait bien.
Autres améliorations
Ce circuit n'est qu'une preuve de concept et nécessite des améliorations supplémentaires. Tout d'abord, nous avons besoin d'un PCB de bonne qualité et d'un connecteur BNC de bonne qualité pour la sortie, sinon nous ne pouvons pas obtenir une fréquence plus élevée. L'amplitude du module est très faible, donc pour améliorer cela, nous avons besoin de circuits ampli-op pour amplifier la tension de sortie. Un potentiomètre peut être connecté afin de faire varier l'amplitude de sortie. Un interrupteur pour compenser le signal peut être connecté; c'est également une fonctionnalité indispensable. Et de plus, le code a besoin de beaucoup d'améliorations car il est un peu bogué. Enfin, les écrans OLED doivent être modifiés, sinon il est impossible d'écrire un code facilement compréhensible.
Cela marque la fin de ce tutoriel, j'espère que vous avez aimé l'article et appris quelque chose de nouveau. Si vous avez des questions concernant l'article, vous pouvez les laisser dans la section commentaires ci-dessous ou vous pouvez utiliser notre forum électronique.