Construya su propio generador de funciones con arduino y módulo generador de funciones dds ad9833

Si eres un entusiasta de la electrónica como yo que quiere retocar con diferentes circuitos electrónicos, tener un generador de funciones decente a veces se vuelve obligatorio. Pero tener uno es un problema porque un equipo tan básico puede costar una fortuna. Construir su propio equipo de prueba no solo es más económico, sino que también es una excelente manera de mejorar sus conocimientos.

Entonces, en este artículo, vamos a construir un generador de señales simple con Arduino y el módulo generador de funciones DDS AD9833 que puede producir ondas sinusoidales, cuadradas y triangulares con una frecuencia máxima de 12 MHz en la salida. Y finalmente, vamos a probar la frecuencia de salida con la ayuda de nuestro osciloscopio.

Anteriormente hemos construido un generador de onda sinusoidal simple, un generador de onda cuadrada y un generador de onda triangular con la ayuda de circuitos analógicos básicos. Puede comprobarlos si está buscando algunos circuitos generadores de forma de onda básicos. Además, si desea construir un generador de funciones Arduino más económico sin usar el módulo AD9833, puede consultar el Proyecto de generador de forma de onda Arduino DIY.

¿Qué es un generador de funciones DDS?

Como su nombre lo indica, un generador de funciones es un dispositivo que puede generar una forma de onda específica con una frecuencia específica al configurarlo. Por ejemplo, considere que tiene un filtro LC para el que desea probar su respuesta de frecuencia de salida, puede hacerlo fácilmente con la ayuda de un generador de funciones. Todo lo que necesita hacer es configurar la frecuencia de salida y la forma de onda deseadas, luego puede subirla o bajarla para probar la respuesta. Este fue solo un ejemplo, puede hacer más cosas con él a medida que avanza la lista.

DDS son las siglas de Direct Digital Synthesis. Es un tipo de generador de forma de onda que utiliza convertidores de digital a analógico (DAC) para generar una señal desde cero. Este método se utiliza específicamente para generar una onda sinusoidal. Pero el IC que estamos usando puede producir señales de ondas cuadradas o triangulares. Las operaciones que ocurrieron dentro de un chip DDS son digitales, por lo que puede cambiar la frecuencia muy rápido o puede cambiar de una señal a otra muy rápidamente. Este dispositivo tiene una resolución de frecuencia fina con un amplio espectro de frecuencias.

Comprender el funcionamiento del IC del generador de funciones AD9833

En el corazón de nuestro proyecto se encuentra el IC generador de forma de onda programable AD9833 que está diseñado y desarrollado por dispositivos analógicos. Es un generador de formas de onda programable de baja potencia capaz de producir ondas sinusoidales, triangulares y cuadradas con una frecuencia máxima de 12 MHz. Es un circuito integrado muy exclusivo que es capaz de alterar la frecuencia y la fase de salida con solo un programa de software. Tiene una interfaz SPI de 3 cables, por lo que comunicarse con este IC se vuelve muy simple y fácil. El diagrama de bloques funcional de este IC se muestra a continuación.

El funcionamiento de este CI es muy sencillo. Si echamos un vistazo al diagrama de bloques funcional anterior, observaremos que tenemos un Acumulador de Fase cuyo trabajo es almacenar todos los valores digitales posibles de una onda sinusoidal, comenzando de 0 a 2π. A continuación, tenemos la ROM SIN cuyo trabajo es convertir la información de fase que luego se puede mapear directamente en amplitud. El SIN ROM usa la información de fase digital como una dirección a una tabla de búsqueda y convierte la información de fase en amplitud. Y por último, tenemos un conversor de digital a analógico de 10 bits cuyo trabajo es recibir los datos digitales del SIN ROM y convertirlos en los voltajes analógicos correspondientes, que es lo que obtenemos de la salida. En la salida, también tenemos un interruptor que podemos encender o apagar con solo un pequeño código de software. Hablaremos de eso más adelante en el artículo.Los detalles que ve arriba son una versión muy simplificada de lo que está sucediendo dentro del IC, y la mayoría de los detalles que ve arriba se toman de la hoja de datos AD9833, también puede consultarla para obtener más información.

Componentes necesarios para construir el generador de funciones basado en AD9833

Los componentes necesarios para construir el generador de funciones basado en AD9833 se enumeran a continuación, diseñamos este circuito con componentes muy genéricos, lo que hace que el proceso de replicación sea muy fácil.

• Arduino Nano - 1
• Generador de funciones AD9833 DDS - 1
• Pantalla OLED de 128 x 64 - 1
• Codificador rotatorio genérico - 1
• Conector de barril DC - 1
• Regulador de voltaje LM7809 - 1
• Condensador 470uF - 1
• Condensador 220uF - 1
• Condensador 104pF - 1
• Resistencia 10K - 6
• Interruptores táctiles - 4
• Terminal de tornillo 5,04 mm - 1
• Encabezado femenino - 1
• Fuente de alimentación de 12V - 1

Generador de funciones basado en AD9833 - Diagrama esquemático

El diagrama de circuito completo para el generador de funciones basado en Arduino y AD9833 se muestra a continuación.

Vamos a usar el AD9833 con Arduino para generar nuestra frecuencia deseada. Y en este apartado explicaremos todos los detalles con la ayuda del esquema; déjame darte una breve descripción de lo que está sucediendo con el circuito. Comencemos con el módulo AD9833. El módulo AD9833 es el módulo generador de funciones y está conectado con Arduino de acuerdo con el esquema. Para alimentar el circuito, estamos usando un IC regulador de voltaje LM7809, con un condensador de desacoplamiento decente, esto es necesario porque el ruido de suministro puede interferir con la señal de salida, lo que da como resultado una salida no deseada. Como siempre, Arduino está funcionando como el cerebro de este proyecto. Para mostrar la frecuencia establecida y otra información valiosa, hemos conectado un módulo de pantalla OLED de 128 X 64. Para cambiar el rango de frecuencia, usamos tres interruptores. El primero establece la frecuencia en Hz, el segundo establece la frecuencia de salida en KHz, y el tercero establece la frecuencia en MHz, también tenemos otro botón que se puede usar para habilitar o deshabilitar la salida. Finalmente, tenemos el codificador rotatorio,y tenemos que conectarle una resistencia pull-up; de lo contrario, esos interruptores no funcionarán porque estamos verificando el evento de pulsación de botón en el método de agrupación. El codificador rotatorio se usa para cambiar la frecuencia y el interruptor táctil dentro del codificador rotatorio se usa para seleccionar la forma de onda establecida.

Generador de funciones basado en AD9833 - Código Arduino

El código completo utilizado en este proyecto se puede encontrar al final de esta página. Después de agregar los archivos de encabezado y los archivos de origen necesarios, debería poder compilar directamente el archivo Arduino. Puede descargar la biblioteca de Arduino ad9833 y otras bibliotecas desde el enlace que se proporciona a continuación o, de lo contrario, puede usar el método del administrador de placa para instalar la biblioteca.

• Descargar la biblioteca AD9833 de Bill Williams
• Descargar la biblioteca OLED SSD1306 de Adafruit
• Descargar la biblioteca Adafruit GFX

La explicación del código en el ino. archivo es el siguiente. Primero, comenzamos por incluir todas las bibliotecas requeridas. La biblioteca para el módulo AD9833 DDS es seguida primero por la biblioteca para OLED y la biblioteca matemática es necesaria para algunos de nuestros cálculos.

#include // Biblioteca para el módulo AD9833 #include // Biblioteca de cables para OLED #include // Biblioteca de soporte para OLED #include // Biblioteca OLED #include // Biblioteca de matemáticas

A continuación, definimos todos los pines de entrada y salida necesarios para los botones, conmutador, codificador rotatorio y OLED.

#define SCREEN_WIDATA_PINH 128 // Ancho de la pantalla OLED en píxeles #define SCREEN_HEIGHT 64 // Altura de la pantalla OLED, en píxeles #define SET_FREQUENCY_HZ A2 // Pulsador para configurar la frecuencia en Hz #define SET_FREQUENCY_KHZ A3 // Pulsador para configurar la frecuencia A6 // Botón para establecer la frecuencia en Mhz #define ENABLE_DISABLE_OUTPUT_PIN A7 // Botón para habilitar / deshabilitar la salida #define FNC_PIN 4 // Fsync Requerido por el módulo AD9833 #define CLK_PIN 8 // Pin de reloj del codificador #define DATA_PIN 7 / / Pin de datos del codificador #define BTN_PIN 9 // Botón pulsador interno en el codificador

A partir de entonces, definimos todas las variables necesarias que se requieren en este código. Primero, definimos un contador de variables enteras que almacenará el valor del codificador rotatorio. Las siguientes dos variables clockPin y clockPinState almacenan la estatua del pin que se requiere para comprender la dirección del codificador. Tenemos una variable de tiempo que contiene los valores actuales del contador del temporizador, esta variable se usa para eliminar el rebote del botón. A continuación, tenemos un módulo de frecuencia variable larga sin firmar que contiene la frecuencia calculada que se va a aplicar. A continuación, tenemos el retardo antirrebote. Este retraso se puede ajustar según sea necesario. A continuación, tenemos tres variables booleanas set_frequency_hz,set_frequency_Khz y set_frequency_Mhz estas tres variables se utilizan para determinar la configuración actual del módulo. Hablaremos de ello con más detalle más adelante en el artículo. A continuación, tenemos la variable que almacena el estado de la forma de onda de salida, la forma de onda de salida predeterminada es una onda sinusoidal. Y finalmente, tenemos la variable encoder_btn_count que contiene el recuento del botón del codificador que se usa para establecer la forma de onda de salida.

int contador = 1; // Este valor del contador aumentará o disminuirá si cuando se gira el codificador rotatorio int clockPin; // Marcador de posición para el estado del pin utilizado por el codificador rotatorio int clockPinState; // Marcador de posición para el estado del pin utilizado por el codificador rotatorio unsigned long time = 0; // Se utiliza para eliminar el rebote largo sin firmar moduleFrequency; // utilizado para establecer la frecuencia de salida larga antirrebote = 220; // Retraso de rebote bool btn_state; // se utiliza para habilitar la salida de desactivación del módulo AD98333 bool set_frequency_hz = 1; // Frecuencia de defecto del módulo AD9833 bool set_frequency_khz; bool set_frequency_mhz; String waveSelect = "SIN"; // Forma de onda de inicio del módulo int encoder_btn_count = 0; // utilizado para verificar el botón del codificador, presione Siguiente, tenemos nuestros dos objetos, uno es para la pantalla OLED y otro es para el módulo AD9833.Pantalla Adafruit_SSD1306 (SCREEN_WIDATA_PINH, SCREEN_HEIGHT y Wire, -1); AD9833 gen (FNC_PIN);

A continuación, tenemos nuestra función setup (), en esa función de configuración, comenzamos habilitando el Serial para la depuración. Inicializamos el módulo AD9833 con la ayuda del método begin (). A continuación, configuramos todos los pines asignados del codificador rotatorio como Entrada. Y almacenamos el valor del pin de reloj en la variable clockPinState, este es un paso necesario para el codificador rotatorio.

A continuación, configuramos todos los pines de los botones como entrada y habilitamos la pantalla OLED con la ayuda del método display.begin () , y también verificamos cualquier error con una declaración if . Una vez hecho esto, limpiamos la pantalla e imprimimos una pantalla de inicio, agregamos un retraso de 2 segundos que también es el retraso para la pantalla de inicio, y finalmente, llamamos a la función update_display () que borra la pantalla y actualiza la mostrar una vez más. Los detalles del método update_display () se discutirán más adelante en este artículo.

configuración vacía () {Serial.begin (9600); // Habilitar Serial @ 9600 baudios gen.Begin (); // Este DEBE ser el primer comando después de declarar el objeto AD9833 pinMode (CLK_PIN, INPUT); // Configuración de pines como entrada pinMode (DATA_PIN, INPUT); pinMode (BTN_PIN, INPUT_PULLUP); clockPinState = digitalRead (CLK_PIN); pinMode (SET_FREQUENCY_HZ, INPUT); // Configuración de pines como entrada pinMode (SET_FREQUENCY_KHZ, INPUT); pinMode (SET_FREQUENCY_MHZ, INPUT); pinMode (ENABLE_DISABLE_OUTPUT_PIN, INPUT); if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Dirección 0x3D para 128x64 Serial.println (F ("Falló la asignación SSD1306")); para (;;); } display.clearDisplay (); // Limpiar la pantalla display.setTextSize (2); // Establecer el tamaño del texto display.setTextColor (WHITE); // establece la pantalla de color LCD.setCursor (30, 0); // Establecer la posición del cursor display.println ("AD9833"); // Imprime la pantalla de este texto.setCursor (17, 20); // Establecer la posición del cursor display.println ("Función"); // Imprime este texto display.setCursor (13, 40); // Establecer la posición del cursor display.println ("Generador"); // Imprime este texto display.display (); // Actualiza el retraso de la pantalla (2000); // Retraso de 2 SEC update_display (); // Llamar a la función update_display}

A continuación, tenemos nuestra función loop (), todas las funcionalidades principales están escritas en la sección de bucle.

Primero, leemos el pin del reloj del codificador rotatorio y lo almacenamos en la variable clockPin que hemos declarado anteriormente. A continuación, en la sentencia if , comprobamos si el valor anterior del pin y el valor actual del pin es similar o no y también comprobamos el valor actual del pin. Si todo es verdad, comprobamos para el pin de datos, si es cierto que mediante el codificador está girando hacia la izquierda y disminuir el valor del contador con la ayuda de counter-- comando. De lo contrario, incrementamos el valor del contador con el comando counter ++. Finalmente, colocamos otra instrucción if para establecer el valor mínimo en 1. A continuación, actualizamos clockPinState con el clockPin actualvalor para uso futuro.

bucle vacío () {clockPin = digitalRead (CLK_PIN); if (clockPin! = clockPinState && clockPin == 1) {if (digitalRead (DATA_PIN)! = clockPin) {contador -; } else {contador ++; // El codificador está girando CW así que incrementa} if (contador <1) contador = 1; Serial.println (contador); update_display (); }

A continuación, tenemos nuestro código para detectar la pulsación de un botón. En esta sección, hemos detectado el botón dentro del codificador con la ayuda de algunas declaraciones if anidadas, if (digitalRead (BTN_PIN) == LOW && millis () - time> denunciar), en esta declaración, primero verificamos si el botón pin está bajo o no, si es bajo, entonces está presionado. Luego nuevamente verificamos el valor del temporizador con el retardo de rebote, si ambas declaraciones son verdaderas, entonces lo declaramos como una acción exitosa al presionar el botón, si es así, incrementamos el valor encoder_btn_count. A continuación, declaramos otra instrucción if para establecer el valor máximo del contador en 2, lo necesitamos porque lo estamos usando para establecer la forma de onda de salida.Las tres declaraciones if consecutivas hacen eso, si el valor es cero, se selecciona la forma de onda sinusoidal, si es uno, es una onda cuadrada y si el valor es 2, es una onda triangular. En las tres declaraciones if, actualizamos la pantalla con la función update_display () . Y finalmente, actualizamos la variable de tiempo con el valor actual del contador del temporizador.

// Si detectamos una señal BAJA, se presiona el botón if (digitalRead (BTN_PIN) == LOW && millis () - time> debounce) {encoder_btn_count ++; // Incrementa los valores if (encoder_btn_count> 2) // si el valor es mayor que 2, ponlo a 0 {encoder_btn_count = 0; } if (encoder_btn_count == 0) {// si el valor es 0, se selecciona onda sinusoidal waveSelect = "SIN"; // actualiza la variable de cadena con el valor sin update_display (); // actualiza la pantalla} if (encoder_btn_count == 1) {// si el valor es 1 onda cuadrada, se selecciona waveSelect = "SQR"; // actualiza la variable de cadena con el valor SQR update_display (); // actualiza la pantalla} if (encoder_btn_count == 2) {// si el valor es 1 Se selecciona una onda triangular waveSelect = "TRI"; // actualiza la variable de cadena con el valor TRI update_display ();// actualiza la pantalla} time = millis (); // actualiza la variable de tiempo}

A continuación, definimos todo el código necesario que se requiere para configurar todos los botones con un retardo antirrebote. Como los botones están conectados a los pines analógicos del Arduino, estamos usando el comando de lectura analógica para identificar una pulsación de botón si el valor de lectura analógica llega por debajo de 30, luego detectamos que es una pulsación correcta del botón y esperamos 200 ms para compruebe si se trata de una pulsación de botón real o sólo un ruido. Si esta afirmación es verdadera, asignamos a las variables booleanas los valores que se utilizan para establecer los valores Hz, Khz y Mhz del generador de funciones. A continuación, actualizamos la pantalla y actualizamos la variable de tiempo. Hacemos eso para los cuatro botones conectados con Arduino.

if (analogRead (SET_FREQUENCY_HZ) <30 && millis () - tiempo> antirrebote) {set_frequency_hz = 1; // actualiza los valores booleanos set_frequency_khz = 0; set_frequency_mhz = 0; update_display (); // actualiza la visualización time = millis (); // actualiza la variable de tiempo} if (analogRead (SET_FREQUENCY_KHZ) <30 && millis () - time> debounce) {set_frequency_hz = 0; // actualiza los valores booleanos set_frequency_khz = 1; set_frequency_mhz = 0; moduleFrequency = contador * 1000; update_display (); // actualiza la pantalla time = millis (); // actualiza la variable de tiempo} if (analogRead (SET_FREQUENCY_MHZ) <30 && millis () - time> debounce) {// verifica el pin analógico con el retardo de supresión de rebotes set_frequency_hz = 0; // actualiza los valores booleanos set_frequency_khz = 0; set_frequency_mhz = 1; moduleFrequency = contador * 1000000; update_display ();// actualiza la visualización time = millis (); // actualiza la variable de tiempo} if (analogRead (ENABLE_DISABLE_OUTPUT_PIN) <30 && millis () - time> debounce) {// verifica el pin analógico con el retardo de supresión de rebotes btn_state =! btn_state; // Invertir el estado del botón gen.EnableOutput (btn_state); // Habilita / Deshabilita la salida del generador de funciones dependiendo del estado del botón update_display (); // actualiza el tiempo de visualización = millis (); // actualiza la variable de tiempo}}// actualiza la variable de tiempo}}// actualiza la variable de tiempo}}

Finalmente, tenemos nuestra función update_display (). En esta función, hicimos mucho más que actualizar esta pantalla porque una cierta parte de la pantalla no se puede actualizar en un OLED. Para actualizarlo, debe volver a pintarlo con nuevos valores. Esto hace que el proceso de codificación sea mucho más difícil.

Dentro de esta función, comenzamos limpiando la pantalla. A continuación, establecemos nuestro tamaño de texto requerido. A partir de entonces, configuramos nuestro cursor e imprimimos el generador de funciones con display.println ("Función de función"); mando. Nuevamente establecemos el tamaño del texto en 2 y el cursor en (0,20) con la ayuda de la función display.setCursor (0, 20).

Aquí es donde imprimimos la información de qué onda es.

display.clearDisplay (); // Primero borra la pantalla display.setTextSize (1); // establecer el tamaño del texto display.setCursor (10, 0); // Establecer la posición del cursor display.println ("Generador de funciones"); // imprime el texto display.setTextSize (2); // establece el tamaño del texto display.setCursor (0, 20); // establece la posición del cursor

A continuación, verificamos las variables booleanas para obtener detalles de frecuencia y actualizamos el valor en la variable moduleFrequency. Hacemos esto para valores de Hz, kHz y MHz. A continuación, comprobamos la variable waveSelect e identificamos qué onda está seleccionada. Ahora, tenemos los valores para establecer el tipo de onda y la frecuencia.

if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {// comprobar si se presiona el botón para configurar la frecuencia en Hz moduleFrequency = contador; // actualiza la variable moduleFrequency con el valor actual del contador} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {// comprueba si se presiona el botón para configurar la frecuencia en KHz moduleFrequency = contador * 1000; // Actualizamos la variable moduleFrequency con el valor del contador actual pero multiplicamos 1000 para configurarlo en KHZ} if (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {// compruebe si se presiona el botón para configurar la frecuencia en MHz moduleFrequency = contador * 1000000; if (moduleFrequency> 12000000) {moduleFrequency = 12000000;// no dejes que la frecuencia sea mayor que el contador de 12Mhz = 12; }} if (waveSelect == "SIN") {// La onda sinusoidal está seleccionada display.println ("SIN"); gen.ApplySignal (SINE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "SQR") {// Se selecciona la onda Sqr display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave está seleccionada display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // actualiza el módulo AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Se selecciona onda Sqr display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave está seleccionada display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // actualiza el módulo AD9833. Serial.println (moduleFrequency); }} if (waveSelect == "SQR") {// Se selecciona onda Sqr display.println ("SQR"); gen.ApplySignal (SQUARE_WAVE, REG0, moduleFrequency); Serial.println (moduleFrequency); } if (waveSelect == "TRI") {// Tri wave está seleccionado display.println ("TRI"); gen.ApplySignal (TRIANGLE_WAVE, REG0, moduleFrequency); // actualiza el módulo AD9833. Serial.println (moduleFrequency); }

Volvemos a poner el cursor y actualizamos los valores del contador. Nuevamente verificamos el booleano para actualizar el rango de frecuencia en la pantalla, tenemos que hacer esto porque el principio de funcionamiento del OLED es muy extraño.

display.setCursor (45, 20); display.println (contador); // imprime la información del contador en la pantalla. if (set_frequency_hz == 1 && set_frequency_khz == 0 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Hz"); // imprime Hz en la pantalla display.display (); // cuando todo configurado actualice la pantalla} if (set_frequency_hz == 0 && set_frequency_khz == 1 && set_frequency_mhz == 0) {display.setCursor (90, 20); display.println ("Khz"); display.display (); // cuando todo configurado actualice la pantalla} if (set_frequency_hz == 0 && set_frequency_khz == 0 && set_frequency_mhz == 1) {display.setCursor (90, 20); display.println ("Mhz"); display.display (); // cuando todo listo, actualice la pantalla}

A continuación, verificamos la variable de pulsación de botón para imprimir la salida encendida / apagada en el OLED. Nuevamente, esto debe hacerse debido al módulo OLED.

if (btn_state) {display.setTextSize (1); display.setCursor (65, 45); display.print ("Salida ON"); // imprime la salida en la pantalla display.display (); display.setTextSize (2); } else {display.setTextSize (1); display.setCursor (65, 45); display.print ("Salida APAGADA"); // imprime la salida en la pantalla display.display (); display.setTextSize (2); }

Esto marca el final de nuestro proceso de codificación. Si está confundido en este punto, puede consultar los comentarios en el código para una mayor comprensión.

Prueba del generador de funciones basado en AD9833

Para probar el circuito, se utiliza la configuración anterior. Como puede ver, hemos conectado un adaptador de corriente de 12V DC al conector de barril de DC y hemos conectado el Osciloscopio Hantek a la salida del circuito. También hemos conectado el osciloscopio al portátil para visualizar y medir la frecuencia de salida.

Una vez hecho esto, configuramos la frecuencia de salida en 5Khz con la ayuda del codificador rotatorio y probamos la onda sinusoidal de salida y, efectivamente, es una onda sinusoidal de 5Khz en la salida.

A continuación, hemos cambiado la forma de onda de salida a una onda triangular pero la frecuencia se mantuvo igual, la forma de onda de salida se muestra a continuación.

Luego cambiamos la salida a una onda cuadrada y observamos la salida, y fue una onda cuadrada perfecta.

También modificamos los rangos de frecuencia y probamos la salida, y funcionó bien.

Más mejoras

Este circuito es solo una prueba de concepto y necesita más mejoras. Primero, necesitamos una PCB de buena calidad y algún conector BNC de buena calidad para la salida, de lo contrario no podemos obtener una frecuencia más alta. La amplitud del módulo es muy baja, por lo que para mejorar eso, necesitamos algunos circuitos de amplificador operacional para amplificar el voltaje de salida. Se puede conectar un potenciómetro para variar la amplitud de salida. Se puede conectar un interruptor para compensar la señal; esta es también una característica imprescindible. Y además, el código necesita muchas mejoras, ya que tiene algunos errores. Finalmente, las pantallas OLED deben cambiarse, de lo contrario, es imposible escribir un código fácilmente comprensible.

Esto marca el final de este tutorial, espero que les haya gustado el artículo y hayan aprendido algo nuevo. Si tiene alguna pregunta sobre el artículo, puede dejarla en la sección de comentarios a continuación o puede utilizar nuestro Foro de electrónica.