Creeu el vostre propi generador de funcions amb el mòdul generador de funcions dds arduino i ad9833

Si sou un entusiasta de l’electrònica com jo que voleu modificar els circuits electrònics diferents, de vegades és obligatori tenir un generador de funcions decent. Però posseir-ne un és un problema perquè aquest equipament bàsic pot costar una fortuna. Construir el vostre propi equip de prova no només és més barat, sinó que també és una bona manera de millorar els vostres coneixements.

Així doncs, en aquest article anem a construir un simple generador de senyals amb Arduino i AD9833 DDS Function Generator Module que pugui produir ones sinusoïdals, quadrades i triangulars amb una freqüència màxima de 12 MHz a la sortida. I, finalment, provarem la freqüència de sortida amb l’ajut del nostre oscil·loscopi.

Anteriorment hem creat un generador d’ones sinusoidals simples, un generador d’ones quadrades i un generador d’ones triangulars amb l’ajut de circuits analògics bàsics. Podeu comprovar-los si cerqueu circuits bàsics de generador de formes d'ona. A més, si voleu crear un generador de funcions Arduino més barat sense fer servir el mòdul AD9833, podeu consultar el Projecte DIY Arduino Waveform Generator Project.

Què és un generador de funcions DDS?

Com el seu nom indica, un generador de funcions és un dispositiu que pot configurar una forma d'ona específica amb una freqüència específica. Per exemple, si teniu un filtre LC per al qual voleu provar la resposta de freqüència de sortida, podeu fer-ho fàcilment amb l'ajut d'un generador de funcions. Tot el que heu de fer és establir la freqüència de sortida i la forma d’ona desitjades, i després podeu baixar-la o pujar-la per provar la resposta. Aquest va ser només un exemple: podeu fer-hi més coses a mesura que vagi avançant la llista.

DDS significa Direct Digital Synthesis. És un tipus de generador de formes d' ona que utilitza convertidors digitals a analògics (DAC) per construir un senyal des de zero. Aquest mètode s’utilitza específicament per generar una ona sinusoïdal. Però el CI que estem utilitzant pot produir senyals d'ona quadrades o triangulars. Les operacions que han passat dins d’un xip DDS són digitals, de manera que pot canviar la freqüència molt ràpidament o pot canviar d’un senyal a un altre molt ràpidament. Aquest dispositiu té una resolució de freqüència fina amb un ampli espectre de freqüències.

Conegui el funcionament de l'IC del generador de funcions AD9833

Al centre del nostre projecte hi ha el generador de formes d'ona programable AD9833, dissenyat i desenvolupat per dispositius analògics. És un generador de forma d'ona programable de baixa potència capaç de produir ona sinusoïdal, triangular i quadrada amb una freqüència màxima de 12 MHz. És un CI molt únic que és capaç d’alterar la freqüència i la fase de sortida amb només un programa. Té una interfície SPI de 3 fils, per la qual cosa comunicar-se amb aquest CI es fa molt senzill i fàcil. A continuació es mostra el diagrama de blocs funcionals d’aquest IC.

El funcionament d’aquest CI és molt senzill. Si fem una ullada al diagrama de blocs funcional anterior, observarem que tenim un acumulador de fase que té com a funció emmagatzemar tots els possibles valors digitals d’una ona sinusoïdal, començant de 0 a 2π. A continuació, tenim la ROM SIN el treball de la qual és convertir la informació de fase que posteriorment es pot mapar directament en amplitud. El ROM SIN utilitza la informació de fase digital com a adreça a una taula de cerca i converteix la informació de fase en amplitud. I, finalment, tenim un convertidor digital a analògic de 10 bits que té com a missió rebre les dades digitals del ROM SIN i convertir-les en les tensions analògiques corresponents, això és el que obtenim de la sortida. A la sortida, també tenim un commutador que podem activar o desactivar amb només un petit codi de programari. En parlarem més endavant a l'article.Els detalls que veieu més amunt són una versió molt reduïda del que està passant a l’interior de l’IC i la majoria dels detalls que veieu més amunt provenen del full de dades AD9833. També podeu consultar-lo per obtenir més informació.

Components necessaris per construir el generador de funcions basat en AD9833

A continuació s’enumeren els components necessaris per construir el generador de funcions basat en AD9833; hem dissenyat aquest circuit amb components molt genèrics, cosa que facilita molt el procés de replicació.

Arduino Nano - 1
AD9833 Generador de funcions DDS: 1
Pantalla OLED de 128 X 64: 1
Codificador rotatiu genèric: 1
DC Barrel Jack - 1
Regulador de tensió LM7809 - 1
Condensador 470uF: 1
Condensador 220uF: 1
Condensador 104pF: 1
Resistència 10K: 6
Interruptors tàctils: 4
Terminal de cargol 5,04 mm - 1
Cap de dona: 1
Font d'alimentació de 12V: 1

Generador de funcions basades en AD9833: diagrama esquemàtic

A continuació es mostra el diagrama complet del circuit per al generador de funcions basat en Arduino i AD9833.

Utilitzarem l’ AD9833 amb Arduino per generar la freqüència desitjada. I en aquesta secció, explicarem tots els detalls amb l’ajut de l’esquema; deixeu-me fer-vos una breu visió general del que passa amb el circuit. Comencem pel mòdul AD9833. El mòdul AD9833 és el mòdul generador de funcions i està connectat amb l'Arduino segons l'esquema. Per alimentar el circuit, estem utilitzant un regulador de voltatge LM7809 IC, amb un condensador de desacoblament decent, això és necessari perquè el soroll de subministrament pot interferir amb el senyal de sortida resultant en una sortida no desitjada. Com sempre, l’Arduino treballa com a cervell per a aquest projecte. Per mostrar la freqüència configurada i altra informació valuosa, hem connectat un mòdul de pantalla OLED de 128 X 64. Per canviar el rang de freqüència, estem utilitzant tres commutadors. El primer estableix la freqüència a Hz, el segon estableix la freqüència de sortida a KHz i el tercer estableix la freqüència a MHz, també tenim un altre botó que es pot utilitzar per habilitar o desactivar la sortida. Finalment, tenim el codificador rotatiu,i hem d’adjuntar-hi alguna resistència pull-up, en cas contrari, aquests commutadors no funcionaran perquè estem comprovant l’esdeveniment de premuda de botó del mètode d’agrupació. El codificador rotatiu s’utilitza per canviar la freqüència i l’interruptor tàctil dins del codificador rotatiu s’utilitza per seleccionar la forma d’ona configurada.

Generador de funcions basades en AD9833: codi Arduino

El codi complet utilitzat en aquest projecte es troba a la part inferior d’aquesta pàgina. Després d'afegir els fitxers de capçalera i fitxers font necessaris, hauríeu de poder compilar directament el fitxer Arduino. Podeu descarregar la biblioteca ad9833 Arduino i altres biblioteques des de l'enllaç que es mostra a continuació o bé podeu utilitzar el mètode del gestor de taules per instal·lar la biblioteca.

Descarregueu la biblioteca AD9833 de Bill Williams
Descarregueu la biblioteca OLED SSD1306 d'Adafruit
Descarregueu la biblioteca Adafruit GFX

L'explicació del codi a la ino. fitxer és el següent. En primer lloc, comencem per incloure totes les biblioteques necessàries. La biblioteca del mòdul AD9833 DDS és seguida primer de la biblioteca per a OLED i la biblioteca de matemàtiques és necessària per a alguns dels nostres càlculs.

#include // LIbrary per al mòdul AD9833 #include // Biblioteca de cables per a OLED #include // Biblioteca de suport per a OLED #include // Biblioteca OLED #include // Biblioteca de matemàtiques

A continuació, definim tots els pins d'entrada i sortida necessaris per als botons, el commutador, el codificador rotatiu i els OLED.

#define SCREEN_WIDATA_PINH 128 // Amplada de la pantalla OLED en píxels #define SCREEN_HEIGHT 64 // Alçada de la pantalla OLED, en píxels #define SET_FREQUENCY_HZ A2 // Pulsador per establir la freqüència en Hz #define SET_FREQUENCY_KHZ A3 // Pulsador per definir la freqüència en Khz # A6 // Pulsador per definir la freqüència a Mhz #define ENABLE_DISABLE_OUTPUT_PIN A7 // Pulsador per activar / desactivar la sortida #define FNC_PIN 4 // Fsync requerit pel mòdul AD9833 #define CLK_PIN 8 // Pin de rellotge del codificador 7 / definir DATA_P / Pin de dades del codificador #define BTN_PIN 9 // Polsador intern del codificador

A continuació, definim totes les variables necessàries que es requereixen en aquest codi. En primer lloc, definim un comptador de variables senceres que emmagatzemarà el valor del codificador rotatiu. Les dues variables següents clockPin i clockPinState emmagatzemen l'estàtua del pin que es requereix per entendre la direcció del codificador. Tenim una variable de temps que conté els valors actuals del comptador del temporitzador, aquesta variable s’utilitza per a la descàrrega de botons. A continuació, tenim una variable de llarg sense signe moduleFrequency que manté la freqüència calculada que es va a aplicar. A continuació, tenim el retard de la rebuda. Aquest retard es pot ajustar segons sigui necessari. A continuació, tenim tres variables booleanes set_frequency_hz,set_frequency_Khz i set_frequency_Mhz aquestes tres variables s’utilitzen per determinar la configuració actual del mòdul. En parlarem amb més detall més endavant a l'article. A continuació, tenim la variable que emmagatzema l'estat de la forma d'ona de sortida, la forma d'ona de sortida per defecte és una ona sinusoïdal. I, finalment, tenim la variable encoder_btn_count que conté el recompte de botons del codificador que s’utilitza per configurar la forma d’ona de sortida.

int comptador = 1; // Aquest valor del comptador augmentarà o disminuirà quan es giri el codificador rotatiu en clockPin; // Marcador de posició per a l'estat del pin utilitzat pel codificador rotatiu int clockPinState; // Marcador de posició per a l'estat de pin usat pel codificador rotatiu sense signar molt de temps = 0; // S'utilitza per denunciar la freqüència del mòdul llarg sense signar; // s’utilitza per establir la freqüència de sortida debounce = 220; // Retard de rebounce bool btn_state; // s'utilitza per habilitar la desactivació de la sortida del mòdul AD98333 bool set_frequency_hz = 1; // Freqüència de defecte del mòdul AD9833 bool set_frequency_khz; bool set_frequency_mhz; String waveSelect = "SIN"; // Forma d'ona d'inici del mòdul int encoder_btn_count = 0; // usat per comprovar el botó del codificador, premeu Següent, tenim els nostres dos objectes: un és per a la pantalla OLED i un altre per al mòdul AD9833.Pantalla Adafruit_SSD1306 (SCREEN_WIDATA_PINH, SCREEN_HEIGHT i Wire, -1); AD9833 gen (FNC_PIN);

A continuació, tenim la nostra funció setup (), en aquesta funció de configuració, comencem activant el serial per a la depuració. Inicialitzem el mòdul AD9833 amb l'ajut del mètode begin (). A continuació, establim tots els pins codificadors rotatius assignats com a entrada. I emmagatzemem el valor del pin del rellotge a la variable clockPinState, aquest és un pas necessari per al codificador rotatiu.

A continuació, establim tots els pins dels botons com a entrada i activem la pantalla OLED amb l'ajuda del mètode display.begin () i també comprovem si hi ha errors amb una sentència if . Quan es faci això, esborrem la pantalla i imprimim una pantalla inicial d'inici, afegim un retard de 2 segons que també és el retard de la pantalla inicial i, finalment, anomenem la funció update_display () que neteja la pantalla i actualitza la mostrar una vegada més. Els detalls del mètode update_display () es tractaran més endavant a l'article.

configuració nul·la () {Serial.begin (9600); // Activa Serial @ 9600 baud gen.Begin (); // HA DE SER la primera ordre després de declarar l'objecte AD9833 pinMode (CLK_PIN, INPUT); // Configuració de pins com pinMode d'entrada (DATA_PIN, INPUT); pinMode (BTN_PIN, INPUT_PULLUP); clockPinState = digitalRead (CLK_PIN); pinMode (SET_FREQUENCY_HZ, INPUT); // Configuració dels pins com a pinMode d’entrada (SET_FREQUENCY_KHZ, INPUT); pinMode (SET_FREQUENCY_MHZ, INPUT); pinMode (ENABLE_DISABLE_OUTPUT_PIN, INPUT); if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Adreça 0x3D per a 128x64 Serial.println (F ("Ha fallat l'assignació SSD1306")); per (;;); } display.clearDisplay (); // Esborreu la pantalla display.setTextSize (2); // Estableix la mida del text display.setTextColor (BLANC); // configurar LCD Color display.setCursor (30, 0); // Estableix la posició del cursor display.println ("AD9833"); // Imprimiu la pantalla d'aquest text.setCursor (17, 20); // Estableix la posició del cursor display.println ("Funció"); // Imprimiu aquest text display.setCursor (13, 40); // Estableix la posició del cursor display.println ("Generador"); // Imprimiu aquest text display.display (); // Actualitzar el retard de visualització (2000); // Retard de 2 SEC update_display (); // Funció de trucada update_display}

A continuació, tenim la nostra funció loop (), totes les funcions principals s’escriuen a la secció de bucle.

En primer lloc, llegim el pin Clock del codificador rotatiu i l’emmagatzemem a la variable clockPin que hem declarat anteriorment. A continuació, a la sentència if , comprovem si el valor anterior del pin i el valor actual del pin són similars o no, i també comprovem el valor actual del pin. Si tot és cert, comprovem si hi ha un pin de dades, si és cert, això significa que el codificador gira en sentit antihorari i disminuïm el valor del comptador amb l'ajut de l' ordre counter--. Altrament, incrementem el valor del comptador amb l’ ordre counter ++. Finalment, posem una altra sentència if per establir el valor mínim a 1. A continuació, actualitzem clockPinState amb el clockPin actualvalor per a ús futur.

bucle buit () {clockPin = digitalRead (CLK_PIN); if (clockPin! = clockPinState && clockPin == 1) {if (digitalRead (DATA_PIN)! = clockPin) {comptador -; } else {comptador ++; // El codificador gira CW de manera que incrementa} si (comptador <1) comptador = 1; Serial.println (comptador); update_display (); }

A continuació, tenim el nostre codi per detectar un botó premut. En aquesta secció, hem detectat el botó dins del codificador amb l'ajut d'algunes sentències imbricades if, si (digitalRead (BTN_PIN) == LOW && millis () - time> denounce), en aquesta afirmació, primer comprovem si el botó el pin és baix o no, si és baix, es prem. De nou, comprovem el valor del temporitzador amb el retard de rebounce, si les dues afirmacions són certes, llavors declarem que és una acció prement el botó si així augmentem el valor encoder_btn_count. A continuació, declarem una altra sentència if per establir el valor màxim del comptador a 2, la necessitem perquè la fem servir per establir la forma d'ona de sortida.Les declaracions consecutives de tres si ho fan, si el valor és zero, se selecciona la forma d'ona sinusoïdal, si és una, és una ona quadrada i, si el valor és 2, és una ona triangular. En aquestes tres sentències if, actualitzem la pantalla amb la funció update_display () . I, finalment, actualitzem la variable de temps amb el valor actual del comptador del temporitzador.

// Si detectem un senyal BAIX, es prem el botó si (digitalRead (BTN_PIN) == LOW && millis () - time> debounce) {encoder_btn_count ++; // Incrementeu els valors si (encoder_btn_count> 2) // si el valor és superior a 2 restabliu-lo a 0 {encoder_btn_count = 0; } if (encoder_btn_count == 0) {// si el valor és 0 ona sinusoïdal es selecciona waveSelect = "SIN"; // actualitza la variable de cadena amb el valor sin update_display (); // actualitzeu la pantalla} if (encoder_btn_count == 1) {// si el valor és 1 ona quadrada es selecciona waveSelect = "SQR"; // actualitzeu la variable de cadena amb el valor SQR update_display (); // actualitzeu la pantalla} if (encoder_btn_count == 2) {// si el valor és 1 S'ha seleccionat ona triangular waveSelect = "TRI"; // actualitzeu la variable de cadena amb el valor TRI update_display ();// actualitzar la pantalla} time = millis (); // actualitza la variable de temps}

A continuació, definim tot el codi necessari que es requereix per configurar tots els botons amb un retard de rebounce. Com que els botons estan connectats als pins analògics de l’Arduino, utilitzem l’ordre de lectura analògica per identificar un botó premut si el valor de lectura analògica arriba a 30, llavors detectem que s’ha fet un bon botó i esperem 200 ms a comproveu si es tracta d'un botó real o només d'un soroll. Si aquesta afirmació és certa, assignem les variables booleanes amb valors que s’utilitzen per establir els valors Hz, Khz i Mhz del generador de funcions. A continuació, actualitzem la pantalla i actualitzem la variable de temps. Ho fem per als quatre botons connectats amb l'Arduino.

if (analogRead (SET_FREQUENCY_HZ) <30 && millis () - time> debounce) {set_frequency_hz = 1; // actualitza els valors booleans set_frequency_khz = 0; set_frequency_mhz = 0; update_display (); // actualitza el temps de visualització = millis (); // actualitza la variable de temps} if (analogRead (SET_FREQUENCY_KHZ) <30 && millis () - time> debounce) {set_frequency_hz = 0; // actualitza els valors booleans set_frequency_khz = 1; set_frequency_mhz = 0; moduleFrequency = comptador * 1000; update_display (); // actualitza el temps de visualització = millis (); // actualitza la variable de temps} if (analogRead (SET_FREQUENCY_MHZ) <30 && millis () - time> debounce) {// verifica el pin analògic amb retard de rebounce set_frequency_hz = 0; // actualitza els valors booleans set_frequency_khz = 0; set_frequency_mhz = 1; moduleFrequency = comptador * 1000000; update_display ();// actualitza el temps de visualització = millis (); // actualitza la variable de temps} if (analogRead (ENABLE_DISABLE_OUTPUT_PIN) <30 && millis () - time> debounce) {// comprova el pin analògic amb retard de rebounce btn_state =! btn_state; // Inverteix l'estat del botó gen.EnableOutput (btn_state); // Activa / Desactiva la sortida del generador de funcions en funció de l'estat del botó update_display (); // actualitza el temps de visualització = millis (); // actualitza la variable de temps}}// actualitza la variable de temps}}// actualitza la variable de temps}}

Finalment, tenim la nostra funció update_display (). En aquesta funció, hem fet molt més que actualitzar aquesta pantalla perquè una part determinada de la pantalla no es pot actualitzar en un OLED. Per actualitzar-lo, heu de tornar a pintar-lo amb valors nous. Això fa que el procés de codificació sigui molt més difícil.

Dins d'aquesta funció, comencem per netejar la pantalla. A continuació, definim la mida de text necessària. Després, establim el cursor i el Generador de funcions imprès amb el display.println ("Funció de Funció"); comandament. Tornem a establir la mida del text a 2 i el cursor a (0,20) amb l'ajut de la funció display.setCursor (0, 20).

Aquí és on imprimim la informació de quina ona es tracta.

display.clearDisplay (); // Primer esborreu la pantalla display.setTextSize (1); // defineix la mida del text display.setCursor (10, 0); // Estableix la posició del cursor display.println ("Generador de funcions"); // imprimeix el text display.setTextSize (2); // defineix la mida del text display.setCursor (0, 20); // Estableix la posició del cursor

A continuació, comprovem les variables booleanes per obtenir detalls de freqüència i actualitzem el valor de la variable moduleFrequency. Ho fem per valors de Hz, kHz i MHz. A continuació, comprovem la variable waveSelect i identifiquem quina ona es selecciona. Ara tenim els valors per establir el tipus d’ona i la freqüència.

if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {// comproveu si es prem el botó per establir la freqüència en Hz moduleFrequency = comptador; // actualitzeu la variable moduleFrequency amb el valor del comptador actual} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {// comproveu si es prem el botó per establir la freqüència en KHz moduleFrequency = comptador * 1000; // actualitzeu la variable moduleFrequency amb el valor del comptador actual però en multipliquem 1000 per establir-la a KHZ} si (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {// comproveu si es prem el botó per establir la freqüència en MHz = comptador * 1000000; if (freqüència del mòdul> 12000000) {moduleFrequency = 12000000;// no deixeu que la freqüència sigui més ralladora que el comptador de 12Mhz = 12; }} if (waveSelect == "SIN") {// L'ona sinusoidal està seleccionada display.println ("SIN"); gen.ApplySignal (SINE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "SQR") {// L'ona Sqr està seleccionada display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave està seleccionat display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // actualitzeu el mòdul AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// L'ona Sqr està seleccionada display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave està seleccionat display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // actualitzeu el mòdul AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// L'ona Sqr està seleccionada display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave està seleccionat display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // actualitzeu el mòdul AD9833. Serial.println (moduleFrequency); }

Tornem a configurar el cursor i actualitzem els valors del comptador. Novament comprovem el booleà per actualitzar el rang de freqüències a la pantalla, ho hem de fer perquè el principi de funcionament de l’OLED és molt estrany.

display.setCursor (45, 20); display.println (comptador); // imprimeix la informació del comptador a la pantalla. if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Hz"); // imprimeix Hz a la pantalla display.display (); // quan tot el conjunt actualitza la pantalla} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Khz"); display.display (); // quan tot el conjunt actualitza la pantalla} if (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {display.setCursor (90, 20); display.println ("Mhz"); display.display (); // quan tot establert actualitzi la pantalla}

A continuació, comprovem el botó Premeu variable per imprimir la sortida activada / desactivada a l'OLED. Una vegada més, cal fer-ho a causa del mòdul OLED.

if (btn_state) {display.setTextSize (1); display.setCursor (65, 45); display.print ("Sortida ACTIVADA"); // imprimeix la sortida a la pantalla display.display (); display.setTextSize (2); } else {display.setTextSize (1); display.setCursor (65, 45); display.print ("Sortida DESACTIVADA"); // imprimeix la sortida a la pantalla display.display (); display.setTextSize (2); }

Això marca el final del nostre procés de codificació. Si esteu confós en aquest punt, podeu comprovar els comentaris del codi per comprendre-ho més.

Prova del generador de funcions basat en AD9833

Per provar el circuit, s’utilitza la configuració anterior. Com podeu veure, hem connectat un adaptador de corrent de 12V CC a la presa de barril de CC i hem connectat l’oscil·loscopi Hantek a la sortida del circuit. També hem connectat l’oscil·loscopi al portàtil per visualitzar i mesurar la freqüència de sortida.

Un cop fet això, establim la freqüència de sortida a 5 KHz amb l'ajut del codificador rotatiu i comprovem l'ona sinusoïdal de sortida i, amb tota seguretat, és una ona sinusoïdal de 5 KHz a la sortida.

A continuació, hem canviat la forma d'ona de sortida per una ona triangular, però la freqüència es manté igual, la forma d'ona de sortida es mostra a continuació.

Després vam canviar la sortida per una ona quadrada i vam observar la sortida, i era una ona quadrada perfecta.

També vam modificar els rangs de freqüència i vam provar la sortida i funcionava bé.

Millores addicionals

Aquest circuit només és una prova de concepte i necessita més millores. En primer lloc, necessitem un PCB de bona qualitat i algun connector BNC de bona qualitat per a la sortida, en cas contrari no podem obtenir una freqüència més alta. L’amplitud del mòdul és molt baixa, de manera que, per millorar-ho, necessitem alguns circuits amplificadors operatius per amplificar la tensió de sortida. Es pot connectar un potenciòmetre per variar l'amplitud de sortida. Es pot connectar un commutador per compensar el senyal; això també és una característica imprescindible. I, a més, el codi necessita moltes millores, ja que és una mica erroni. Finalment, cal canviar les pantalles OLED, en cas contrari, és impossible escriure codi fàcilment comprensible.

Això marca el final d’aquest tutorial, espero que l’article us hagi agradat i hàgiu après alguna cosa nova. Si teniu cap pregunta sobre l'article, podeu deixar-les a la secció de comentaris que hi ha a continuació o utilitzar el nostre fòrum electrònic.