ADVERTENCIA:

Los contenidos de este Blog manejan Voltajes, Altos Voltajes y Muy Altos Voltajes. Potencialmente Peligrosos e incluso Potencialmente Letales, Sí No estas Capacitado Técnicamente, No conoces la Normativa Técnica de cada Lugar o tienes la Más Mínima Duda, no sigas con el Contenido de este Sitio. TODOS LOS CONTENIDOS DEL BLOG SON A NIVEL INFORMATIVO, Al acceder a los Contenidos "Aceptas ser el Único Responsable de Tus Actos y Sus Consecuencias así de como Utilizas la Información".

miércoles, 11 de enero de 2017

GENERADOR DE ONDAS - ARDUINO NANO Y AD9850


GENERADOR DE ONDA SENOIDAL Y CUADRADA CON ARDUINO Y AD9850.


El diseño está basado en una placa de "Arduino" que puede ser el "Nano" o el "Mega 2560",..., las diferencias que nos interesan entre ellas son la capacidad de Memoria Interna (que se traduce en el nº de instrucciones de programación y por lo tanto en opciones) y el nº de "Pines" de Entrad/Salida disponibles.

Para el Generador se va a utilizar una placa Arduino "Nano" como Generador de Onda Cuadrada PWM hasta 30KHz con buena precisión y para gobernar un Generador de Ondas Senoidal y Cuadrada DDS de Precisión AD9850 hasta 2 MHZ de Onda Cuadrada y hasta 10 MHz de Onda Senoidal; con posibilidad de regulación de 1 decimal hasta la frecuencia de 99.999 Hz .
-PUEDE GENERAR FRECUENCIAS POR DEBAJO DE 1 Hz HASTA 25 SEGUNDOS.

ARDUINO EXTRAIDO DE WIKIPEDIA:
Arduino se enfoca en acercar y facilitar el uso de la electrónica y programación de sistemas embebidos en proyectos multidisciplinarios1 2 . Toda la plataforma, tanto para sus componentes de hardware como de software, son liberados con licencia de código abierto que permite libertad de acceso a ellos3 .
El hardware consiste en una placa de circuito impreso con un microcontrolador, usualmente Atmel AVR, puertos digitales y analógicos de entrada/salida,4 , los cuales pueden conectarse a placas de expansión (shields), que amplían las características de funcionamiento de la placa Arduino. Asimismo, posee un puerto de conexión USB desde donde se puede alimentar la placa y establecer comunicación con el computador.
Por otro lado, el software consiste en un entorno de desarrollo (IDE) basado en el entorno de Processing y lenguaje de programación basado en Wiring, así como en el cargador de arranque (bootloader) que es ejecutado en la placa.4 El microcontrolador de la placa se programa mediante un computador, usando una comunicación serial mediante un convertidor de niveles RS-232 a TTL serial.

La plataforma Arduino se programa mediante el uso de un lenguaje propio basado en el lenguaje de programación de alto nivel Processing que es similar a C++.


ALGUNAS FUNCIONES DE PROGRAMACIÓN:

Sintaxis básica

  • Delimitadores:;, {}
  • Comentarios: //, /* */
  • Cabeceras: #define, #include
  • Operadores aritméticos: +, -, *, /, %
  • Asignación: =
  • Operadores de comparación: ==, !=, <, >, <=, >=
  • Operadores Booleanos: &&, ||, !
  • Operadores de acceso a punteros: *, &
  • Operadores de bits: &, |, ^, ~, <<, >>
  • Operadores compuestos:
    • Incremento y decremento de variables: ++, --
    • Asignación y operación: +=, -=, *=, /=, &=, |=

Estructuras de control

  • Condicionales: if, if...else, switch case
  • Bucles: for, while, do. while
  • Bifurcaciones y saltos: break, continue, return, goto

Variables

En cuanto al tratamiento de las variables también comparte un gran parecido con el lenguaje C.
Constantes
  • HIGH/LOW: representan los niveles alto y bajo de las señales de entrada y salida. Los niveles altos son aquellos de 3 voltios o más.
  • INPUT/OUTPUT: entrada o salida.
  • false (falso): Señal que representa al cero lógico. A diferencia de las señales HIGH/LOW, su nombre se escribe en letra minúscula.
  • true (verdadero): Señal cuya definición es más amplia que la de false. Cualquier número entero diferente de cero es "verdadero", según el álgebra de Boole, como en el caso de -200, -1 o 1. Si es cero, es "falso".
Tipos de datos
  • void, boolean, char, unsigned char, byte, int, unsigned int, word, long, unsigned long, float, double, string, array.
Conversión entre tipos
Estas funciones reciben como argumento una variable de cualquier tipo y devuelven una variable convertida en el tipo deseado.
  • char(), byte(), int(), word(), long(), float()

ESTRUCTURA BÁSICA DE UN PROGRAMA:
Las primeras lineas de programación se utilizan para definir Variables, Matrices, Cargar librerías, etc..., después consta de un Procedimiento llamado "void setup ()" que es el procedimiento que primero se ejecuta y en el cual se abren puertos y se definen los parámetros de la LCD de visualización de Datos en pantalla, parámetros de componentes externos como el generador de Frecuencias "AD9850"; el siguiente Procedimiento que se ejecuta es el "void loop ()" en el cual todas las Instrucciones que correspondan se ejecutan Ciclicamente e Indefinidamente; tabién se pueden agregar por el programador otros Procedimientos que serán llamados cuando procedan y se definen como "void ........ ()".

En la Programación es importante el uso de las minúsculas y las Mayúsculas correspondientes en las instrucciones (sino dará fallos en la compilación del programa).
Cada Arduino lleva un nº determinado de "TIMERS" que son osciladores, salidas-entradas Analógicas y Digitales que son Programables.
Cuando se compila un Programa (el compilador chequea y convierte las instrucciones al código del microprocesador del arduino) debe de estar seleccionado el Tipo de Arduino a Utilizar.


ELEMENTOS NECESARIOS:

- UNA PLACA "ARDUINO".
- GENERADOR DE ONDAS "AD9850".
- LCD 16x2 (16 caracteres x 2 líneas) o 24x4 (24 caractgeres x 4 líneas).
- POTENCIOMETROS 10K (el nº según las opciones).
- FUENTE DE ALIMENTACIÓN FIJA DE 5Vcc o 9Vcc.
- UNA CAJA SI SE DESEA DEJARLO BONITO.
- SOFTWARE PARA EL ENTORNO DE PROGRAMACIÓN.
- LIBRERÍAS DE PROGRAMACIÓN.
- UN ORDENADOR PARA CARGAR EL PROGRAMA DE COMPILACIÓN DE INSTRUCCIONES Y DESPUÉS VOLCARLO SOBRE EL ARDUINO.


SOFTWARE:

COMPILADOR ARDUINO "IDE" (PROGRAMADOR + GRABADOR EN ARDUINO):
http://www.arduino.org/downloads

CONJUNTO DE PROGRAMAS Y LIBRERÍAS (incluido compilador "IDE") TODO EN UNO:
https://drive.google.com/open?id=0B4bwT8N01X-9S2JzQ1FFOUZ6bk0
extraer el comprimido en C:\
una vez extraído para abrir el programador "IDE" ejecutar el fichero "arduino.exe".


PLACA ARDUINO "NANO":


DESIGNACIÓN DE PINES:



AD9850 (Generador de Señales):
posibilidades del Generador de Ondas:
- Onda Cuadrada: hasta 2 MHz - Salida de 5 Vp.
- Onda Senoidal: hasta 8 MHz - Salida  de 1 Vpp.

El potenciometro de 10K azul de la placa sirve para variar el Ancho de Pulso (Duty Cicle) de la Onda Cuadrada (ojo que el potenciometro sobre todo al principio de su recorrido y algo menos al final no actúa realmente sobre el ancho de pulso de la onda cuadrada, es decir impide que salga la Onda Cuadrada.


MONTAJE:


ARDUINO "NANO" SOBRE UN SHIELD:

AD9850 SOBRE  UNA PROTOBOARD:

SISTEMA DE 4 POTENCIOMETROS (para diversas opciones):

INTERCONEXIÓN ENTRE COMPONENTES:

LCD 16x2:
el LCD puede ser conectado a los pines de salidas digitales del arduino (se utiliza muchos cables) o por el sistema  del BUS "I2C" que solo utiliza 4 cables (se necesita un modulo "I2C") dos para alimentación y 2 para transmisión de datos.

MODULO "I2C":
el modulo se suelda a la pantalla por la parte de atrás del LCD (aconsejo no soldar directamente al LCD, soldar una tira de pines hembra e introducir el modulo en ellos), el potenciometro azul sirve para regular el brillo de la pantalla LCD.





ESQUEMA DE CONEXIONADO ENTRE COMPONENTES:


P0 - REGULA EL ANCHO DE PULSO DE LA ONDA CUADRADA DE LA SALIDA PWM POR EL PIN 9 DEL ARDUINO NANO.
P1 - REGULACIÓN NUMÉRICA DEL 0 AL 9.
P3 - REGULA LA POSICIÓN DEL CARACTER NUMÉRICO PARA CONSEGUIR LA CIFRA DE LA FRECUENCIA

Con P0 se varía Únicamente el ancho de Pulso (Duty Cycle) de la Onda Cuadrada de la Salida PWM del Pin 9 del Arduino (se visualiza en la parte inferior izquierda del LCD, el ancho de pulso de la Onda Cuadrada del DDS se varia con el potenciometro azul integrado en al placa.

El sistema de Variación o Selección de Frecuencia de las Salidas es muy Sencillo, para ello se utilizan los Potenciometros P1 y P2, con P1 se regula el dígito del 0 al 9 y con P2 se desplaza la posición del cursor sobre la línea inferior derecha de la pantalla (la ultima posición siempre es para el nº decimal de la frecuencia seleccionada con los demás dígitos), 
Conforme se varia la posición del cursor con el nº seleccionado también se varia la cifra total en la parte superior derecha del LCD.
En la parte superior izquierda de la pantalla se visualiza la Frecuencia Definitiva Seleccionada de Salida.
Las Frecuencias con  decimal (primer decimal sólo) se visualiza en la parte superior izquierda del LCD.

Visualización de la frecuencia de 1.234.567 Hz (el cursor esta en las unidades y 0 decimales):

Visualización de la frecuencia de 7.654.321 Hz (el cursor esta en los millones y 0 decimales):



0.1 Hz (1 decimal):

1 Hz:


10 Hz:


100 Hz:


1.000 Hz:


10.000 Hz (10 KHz):



A PARTIR DE LOS 100 KHz NO SE VISUALIZA EN PANTALLA EL DECIMAL.
100.000 Hz (100 KHz):


1.000.000 (1 MHz):




EJEMPLOS DE MEDICIÓN DE LA FRECUENCIA DE SALIDA DEL AD9850:

1.5 Hz.



5.5 Hz:



55 Hz:



555.5 Hz:



5.555.5 Hz:



55.555 Hz:




555.555 Hz:




5.555.555 Hz:













MEDICIONES DE VOLTAJE DE LA ONDA SENOIDAL DEL AD9850:





la señal Senoidal mantiene el nivel hasta los 9 MHz.


MEDICIONES DE LA ONDA CUADRADA DEL AD9850:


la señal de la Onda Cuadrada se mantiene estable hasta los 2 MHz.


MEDICIONES DE ONDA CUADRADA ENTRE LA SALIDA "PWM" Y LA SALIDA "DDS" DEL AD9850:

SALIDA "DDS" en Amarillo.
SALIDA "PWM" (PIN 9 del Arduino) en Azul.


La FRECUENCIA de la salida de Onda Cuadrada de "PWM" del Pin 9 del Arduino Nano se mantiene con buena tolerancia hasta los 30 KHz, después aumenta la tolerancia según si es múltiplo exacto de frecuencias inferiores, con la Salida "DDS" no pasa esto.

el Duty Cicle de la señal "DDS" solo se puede variar en el recorrido útil del potenciometro azul de la placa del AD9850.
el Duty Cicle de la señal "PWM" se puede varia con el potenciometro P0.



CÓDIGO ARDUINO:

CONECTAR EL CABLE MINI-USB ENTRE EL ARDUINO NANO Y UNA SALIDA USB DEL PC.
ABRIR EL PROGRAMA "IDE".
COPIAR Y PEGAR EL "CÓDIGO" EN EL PROGRAMA "IDE".
SELECCIONAR EN EL MENÚ "HERRAMIENTAS" - SUBMENÚ "PLACA: ARDUINO NANO".
SELECCIONAR EN EL MENÚ "PROGRAMA" - "VERIFICAR/COMPILAR" O PULSAR EL ICONO DE LA "FLECHA" (>).
SI EL PROGRAMA DA ERRORES DE CARGA VOLVER A PULSAR EN LA "FLECHA" (>) ; SI SIGUE DANDO ERROR DE CARGA DESCONECTAR EL CABLE USB DEL "PC" Y VOLVER A INTENTAR; CUANDO EL PROGRAMA NO DÉ ERROR, YA ESTÁ SUBIDO AL ARDUINO NANO.


// INICIO DEL CODIGO

// GENERADOR DE FRECUENCIA VARIABLE Y DUTY CICLE CON POTENCIOMETROS DE 10K
// POTENCIOMETROS PARA VARIAR EL PULSO DE TRABAJO DE PWM Y PARA LOS DIGITOS Y POSICIONAMIENTO DE LOS DIGITOS
// RANGO DE FRECUENCIA DESDE 0.1 Hz A 9.999.999 Hz, EL PULSO DE TRABAJO DE LA ONDA CUADRADA SE PUEDE VARIAR DESDE EL 0% AL 99%
// SALIDA DE ONDA CUADRADA DE PWM EN EL PIN D9 (SALIDA MAXIMA APROXIMADA REAL HASTA 100.000 Hz)
// SALIDA DE ONDA SENOIDAL Y CUADRADA POR EL GENERADOR AD9850, VARIACION DEL PULSO DE TRABAJO DE LA ONDA CUADRADA POR POTENCIOMETRO DEL PROPIO MODULO
// LADO SUPERIOR IZQUIERDO DE LA PANTALLA: FRECUENCIA DE SALIDA CON 1 DECIMAL HASTA 99.999 Hz Y SUPERIORES SIN DECIMAL
// LADO SUPERIOR DERECHA DE LA PANTALLA: FRECUENCIA SELECIONADA POR EL DIGITO FLOTANTE SEGUN LAS POSICIONES SELECCIONADAS
// LADO INFERIOR IZQUIERDO DE LA PANTALLA: ANCHO DE PULSO DE LA ONDA CUADRADA (SOLO SALIDA PWM -PIN D9 DEL ARDUINO)
// LADO INFERIOR DERECHO DE LA PANTALLA: DIGITO FLOTANTE (0-9) PARA SELECCION DEL VALOR DE LA FRECUENCIA DE SALIDA
//HASTA 99.999Hz CON 1 DECIMAL EFECTIVO
//DESDE 100.000Hz HASTA 9.999.999Hz SIN DECIMAL
// -----COPYRIGHT LIBRE POR "TESLATRONICA & TESLAMEN"-----


int pulso;
int menu;
int menu_;
int menu1;
int menu_1;
int menu2;
long menu_2;

float f_; 
float f_1 = 0;
float f_f;

long a0;
long a1;
long a2;
long a3;
int a4;
int a5;
int a6;
float a7; //decimales

int pulso2;
int pulso2_2=0;
long contador__=1;

// matriz para potenciometro multivueltas---
int matriz_posicion[] = {0,0,1, 2, 3, 4, 5, 6, 7,0,1, 2, 3, 4, 5, 6, 7,0,1, 2, 3, 4, 5, 6, 7,0,1, 2, 3, 4, 5, 6, 7,0, 1,2, 3, 4, 5, 6, 7, 7};
//------------------------------------------

#include <PWM.h> // GENERADOR DE ONDA CUADRADA PWM

#include <AD9850.h> // GENERADOR DE ONDAS

//----- I2C
#include <Wire.h>   //
#include <LiquidCrystal_I2C.h>
//                     Addr, En, Rw, Rs, d4, d5, d6, d7, backlighpin, polarity
LiquidCrystal_I2C lcd( 0x27, 2,   1,  0,  4,  5,  6,  7,           3, POSITIVE );   //
//----- I2C


void setup() {
  
  InitTimersSafe();  //inicializa timers para PWM
  DDS.begin(7,6,5,4); // del generador a las patillas  D7-D6-D5-D4 del arduino Nano
  //DDS.begin(4,5,6,7); // del generador a las patillas  D4-D5-D6-D7 del arduino Mega
  DDS.calibrate(124999500); //calibración
    
  lcd.begin(16,2);   //pantalla 16x2
  //lcd.begin(20, 4);  //pantalla 20x4
  
//-----I2C
  lcd.backlight();   //Iniciamos el fondo retroiluminado pantalla conexion serie
//-----I2C
  
  //Serial.begin(9600);    // abre el Puerto serie

  
}

void loop() {
  pulso = analogRead (0); //lee el potenciometro P0 para el ancho de pulso variable por PWM
  pulso2 = map (pulso, 0, 1023, 0, 99);  
    if (pulso2!=pulso2_2){ 
      pulso_();
      //Serial.println(pulso2); 
    }
    pulso2_2=pulso2;
      
      Menu__();
      menu1 = analogRead (1); //lee el potenciometro P1 para el digito del 0 al 9
      menu_1 = map(menu1, 0, 1023, 0, 9);
      menu2 = analogRead (2); ///lee el potenciometro P2 de posicionamiento del cursor para los digitos
      menu_2 = map(menu2, 0, 1023, 0, 8); //con potenciometro normal
      //menu_2 = map(menu2, 0, 1023, 1, 41); //con matriz para potenciometro multivuelta
      //menu_2 = matriz_posicion[menu_2]; //con matriz para potenciometro multivuelta

      switch (menu_2)  {  //SELECCION DE LOS DIGITOS DE LA FRECUENCIA  
        case 0:
          a0 = menu_1; //millones
          lcd.setCursor(8, 1);
          lcd.print(a0);
          break;
        case 1:
          a1 = menu_1; //cien mil
          lcd.setCursor(9, 1);
          lcd.print(a1);
          break;
        case 2:
          a2 = menu_1; //diez mil
          lcd.setCursor(10, 1);
          lcd.print(a2);
          break;
        case 3:
          a3 = menu_1; //mil
          lcd.setCursor(11, 1);
          lcd.print(a3);
          break;
        case 4:
          a4 = menu_1; //centenas
          lcd.setCursor(12, 1);
          lcd.print(a4);
          break;
        case 5:
          a5 = menu_1; //decenas
          lcd.setCursor(13, 1);
          lcd.print(a5);
          break;
        case 6:
          a6 = menu_1; //unidades
          lcd.setCursor(14, 1);
          lcd.print(a6);
          break;
        case 7:
          a7 = menu_1; //1 decimal
          lcd.setCursor(15, 1);
          lcd.print(a7);
          break;
      }  

      //suma los valores de cada digito y los multiplica---
      f_ = (a6 * 1) + (a5 * 10) + (a4 * 100) + (a3 * 1000) + (a2 * 10000) + (a1 * 100000) +(a0 * 1000000);
      f_f= f_+(a7/10); 
      //---------------------------------------------------
      
      lcd.setCursor(8, 0);
      lcd.print(a0);
      lcd.print(a1);
      lcd.print(a2);
      lcd.print(a3);
      lcd.print(a4);
      lcd.print(a5);
      lcd.print(a6);
      lcd.print(a7);
      
      lcd.setCursor(0, 0);
      
      if (f_f >=99999) {
        lcd.print (long (f_f));
        //lcd.print("Hz");
      }
      else {
        lcd.print(f_f);
      }

      if (f_f != f_1) {
        SetPinFrequencySafe(9, f_ ); //envia la frecuencia de la onda cuadrada al pin PWM 9 del arduino nano
        pulso_();
        //Serial.println(f_);
        DDS.setfreq(f_f, 0); //envia la frecuencia de la onda senoidal y cuadrada al generador AD9850
        //Serial.println(f_f);  
        lcd.setCursor(0, 0);
        lcd.print("         "); //borra parte de la linea 0
        lcd.setCursor(8, 1);
        lcd.print("        "); //borra parte de la linea 1
      }
      f_1 = f_f;
          
    delay(200);
  
}   // fin void loop

void pulso_() {
  if (f_!=0) {
    pwmWrite(9, pulso2 * 2.55);
     //Serial.println(pulso2);
 }
else {
    pwmWrite(9, 0);
 }
  lcd.setCursor(0, 1);
  lcd.print("Pulso"); //ancho de pulso
  lcd.setCursor(5, 1);
  lcd.print("   ");
  lcd.setCursor(5, 1);
  lcd.print(pulso2);
  lcd.print("%");
} //final void loop


void Menu__ ()  {
 if (millis() >= contador__ + 400) {   //el numero es el tiempo que tarda en imprimir en pantalla
  
  lcd.setCursor(8, 0);
  lcd.print("                "); //borra la linea 0
  lcd.setCursor(8, 1);
  lcd.print("        "); //borra parte de la linea 1
  contador__=millis();
 }
}

// FIN DEL CODIGO





ARDUINO "MEGA 2560":

Si se utiliza el arduino "Mega 2560" hay que cambiar en el código las siguientes instrucciones:
 DDS.begin(7,6,5,4); // del generador a las patillas  D7-D6-D5-D4 del arduino Nano
  //DDS.begin(4,5,6,7); // del generador a las patillas  D4-D5-D6-D7 del arduino Mega
por estas:
 //DDS.begin(7,6,5,4); // del generador a las patillas  D7-D6-D5-D4 del arduino Nano
  DDS.begin(4,5,6,7); // del generador a las patillas  D4-D5-D6-D7 del arduino Mega



SHIELD (PLACA ADAPTADORA DEL AD9850 AL ARDUINO "MEGA 2560":


CONSTRUCCIÓN DE UN SHIELD:

se ha recortado una placa de tiras de cobre a 19 pistas para adaptarlo a las dimensiones del Arduino "Mega 2560" donde irá acoplado encima sobre los propios pines hembra del "Mega" (también se puede hacer sobre una placa externa o protoboard):

A la placa de tiras de cobre se sueldan en los extremos de las pistas las tiras de pines macho necesarias que se introducirán en el arduino "Mega", sobre la placa se sueldan dos tiras adaptadoras de 10 pines hembra donde se introduce el "AD9850", se hacen con una broca fina y con mucho cuidado los cortes marcados en el esquema con el fin de que los pines que no se utilizan del "Mega" y del "AD9850" no se interfieran entre ellos (posibilidad de rotura de ambos), se sueldan los 3 puentes y por último se sueldan los cables de las diversas Salidas en los puntos marcados en el esquema.


placa de pistas de cobre con los cortes correspondientes.


El Modulo AD9850 sólo da Señal de Onda Cuadrada en una parte del tramo del ajuste del potenciometro azul que viene en su placa (1/3 aproximadamente) que es el recorrido con el cual se puede ajustar el Ancho de Pulso de la Señal (Duty Cicle) por lo cual he añadido en el Shield dos potenciometros ajustables de 50K y 5K (ver esquema de abajo) con el fin de ajustar el inicio de la onda cuadrada desde el 5% aproximadamente y acabar en el 95% y así aprovechar todo el recorrido del potenciometro de Ancho de Pulso que se ha puesto externo:


esquema con los potenciometros multivuelta de 5Ky 50K:




7 comentarios:

  1. Hola, implemente el programa en Arduino Mega y funciona perfectamente, es exacta la frecuencia ! Solo lo uso con onda cuadrara, Genial el post!!!!! Gracias

    ResponderEliminar
  2. es un dispositivo de radionica ?? espero tu respuesta; necesito construir una maquina radionica, agradecere tu comunicacion

    ResponderEliminar
    Respuestas
    1. No es una máquina de Radiónica, es un Generador de Onda Cuadrada, aunque algunas Máquinas Radiónicas Modernas incorporan Genradores de Ondas comocomplemento.

      Eliminar
    2. Pon tu E-mail o mándalo por el Formulario de contacto arriba a la derecha

      Eliminar
  3. hola, me dice ERROR COMPILANDO PARA LA TARJETA ARDUINO NANO,
    EXIT STATUS 1

    ResponderEliminar
    Respuestas
    1. Cuando se carga un programa desde el Arduino "IDE" al Modulo Arduino Nano puede dar errores diversos, hay que desconectar cable de l Ordenador y cambiarlo a otro puerto y seguir probando varias veces.
      Otro error típico es no tener seleccionado en los Menus desplegables el tipo de Arduino correcto o el Puerto de Comunicacion al que esta conectado el Arduino.

      Eliminar

Gracias por Tu Comentario, Aporta Siempre lo Mejor de Ti.