INSTITUTO TECNOLÓGICO DE MORELIA SECRETARIA DE EDUCACIÓN
M.C. EN ING. ELECTRÓNICA ASIGNATURA:
PROCESAMIENTO DE SEÑALES REPORTE DE PRÁCTICA No. 3:
“TRANSFORMADA RAPIDA DE FOURIER EN UN MICROCONTROLADOR ” PRESENTAN:
Rosendo Antonio Sepúlveda Valdes Carlos Ángel Pérez Barrios DOCENTE:
Dra. ADRIANA DEL CARMEN TÉLLEZ ANGUIANO Morelia, Michoacán
31 marzo 2014.
INTRODUCCIÓN
Para la implementación de esta práctica se hace uso únicamente de un microcontrolador ATEMGA168, ATEMGA168, un LCD de 2X16, una serie de push buttons, para ingresar los valores que se desee en la transformada rápida de Fourier, para ello implementamos, como se puede apreciar mas adelante, un teclado del tipo ADC, con arreglos de resistencias, que de acuerdo al voltaje leído por el puerto del ADC, se tenía el numero deseado. Como se sabe la FFT (abreviatura usual para el idioma ingles) es un algoritmo que nos ayudara a calcular esta transformada rápida, la cual tiene variedad de aplicaciones, que van desde un tratamiento de señales digitales y un filtrado digital hasta para resolución de ecuaciones en derivadas parciales o los algoritmos de multiplicación rápida de grandes enteros. Este método es eficaz y de importancia para el análisis matemático. Sus aplicaciones son múltiples además de que puede facilitar el uso de algoritmos. Para el caso de la transformada rápida de Fourier se implementará en el programa del microcontrolador el proceso para el cálculo de ocho puntos que se describió anteriormente en clase.
OBEJETIVO DE LA PRÁCTICA Implementar la Transformada Rápida de Fourier en un microcontrolador usando el método de 8 puntos.
MARCO TEÓRICO Transformada Rápida de Fourier El término genérico “transformada rápida de Fourier”
abarca distintos algoritmos
con distintas características, ventajas y desventajas. Por ejemplo, una FFT diseñada y optimizada usando un lenguaje de alto nivel probablemente no funcionará correctamente en un DSP. Sin embargo, todas las FFT’s usan la misma aproximación para reducir el algoritmo en un número reducido de DFT’s sucesivas, cortas y simples. Hay que tener
en cuenta que: - La FFT es un algoritmo (no una aproximación) a iguales intervalos de espaciamiento. - Las limitaciones de la FFT surgen de las que tiene la DFT. - No es ni mejor ni peor. Sin embargo se logra una eficiencia debido a los números de operaciones menores que utiliza la FFT para ser resuelta. Algoritmo FFF en Base 2 y Diezmado en el tiempo Consideremos el cálculo de la DFT de N = 2v a partir de dividir la secuencia de datos de N puntos, en dos secuencias de N/2, correspondientes a las muestras pares e impares de x[n], respectivamente, esto es:
Obsérvese, que se realizó el diezmado de la secuencia x[n], una vez. La DFT de N puntos puede expresarse ahora en términos de las DFT´s de las secuencias diezmadas como sigue:
Pero . Sustituyendo esta igualdad en la expresión anterior se tiene:
Donde () () son las DFTs de N/2 puntos de las secuencias correspondientes a la primera expresión.
() () son periódicas, de periodo N/2, tenemos; () () () () Por otro lado, se cumple que por lo que se puede escribir la siguiente Puesto que
expresión sustituyendo en la anterior.
Se observa que el cálculo directo () requiere de () multiplicaciones complejas igual que () Además, se requieren N/2 multiplicaciones más para calcular ()
multiplicaciones complejas. El primer paso realizado de una reducción en el número de multiplicaciones a , lo que equivale De aquí el cálculo de () Requiere
aproximadamente a dividir por dos el número de multiplicaciones cuando N es grande.
Habiendo realizado el diezmado en tiempo una vez, podemos repetir el proceso para cada una de las secuencias en la expresión inicial, por lo tanto, se obtendrá dos secuencias de N/4 puntos:
Calculando las DFTs de N/4 puntos se obtienen DFTs de N/2 puntos () y () a partir de las siguientes relaciones:
Donde () son las DFTs de N/4 puntos de las secuencias []
multiplicaciones y por lo tanto el cálculo de () y () puede realizarse con multiplicaciones complejas. Se requieren N/2 multiplicaciones complejas más para calcular () a partir de () y () Consecuentemente, el número total de multiplicaciones necesarias se Se observa que el cálculo de () requieres de
reduce otra vez a aproximaciones por un factor de dos. El diezmado de la secuencia de datos se repite
veces, ya que se tienen
datos. Por lo tanto el número total de multiplicaciones complejas se reduce a
, mientras que el número de sumas complejas es
. En la tabla inferior se
muestra la comparación entre el número de multiplicaciones complejas usando la FFT y el cálculo directo de la DFT.
Tabla de comparación entre la cantidad de multiplicaciones complejas a realizar por parte de la DFT y el algoritmo FFT de base de base 2.
Algoritmo para la FFT de diezmado en tiempo para 8 puntos, utilizado en esta practica.
Como puede observarse, el cálculo que se realiza en cada etapa, el cual consiste en aplicar las operaciones de una transformada DFT de dos puntos o “mariposa”. En gener al
cada mariposa implica una multiplicación y dos sumas complejas. Para N puntos, tenemos N/2 mariposas por cada etapa del proceso y log 2 N etapas de mariposas.
IMPLEMENTACIÓN DEL TECLADO ADC
Para la implementación de un teclado existe muchas formas de realizarlo, usando por ejemplo un pin del microcontrolador por cada tecla, lo cual hace que ocupemos para esto almenos de 10 pines del micro, esto si hacemos el conteo de 0-9 para las teclas, de la misma forma se puede implementar un teclado matricial, de 4x4, por el cual necesitamos 4 pines de entrada y 4 pines de salida para hacer el barrido de las teclas. Sin embargo se tiene una forma mucho mas fácil de realizarlo ahorrando también pines del micro. Esto es haciendo que cada tecla genere un voltaje distinto para diferenciarla de otra tecla. Inclusive es la forma en que muchos aparatos electrodomésticos funcionan como los estéreos de casa que tienen muchas teclas, hacen que cada tecla genere un voltaje distinto.
Teóricamente si tenemos un ADC de 8 bits podríamos tener hasta 256 teclas, pero en la práctica no es posible porque las resistencias tienen tolerancias y hay que separar cada tecla en un voltaje para diferenciar entre c ada tecla. Para tener una idea supongamos que 4 resistencias son de 1Kohm, pero lo importante es que si las 4 resistencias son iguales el voltaje que habrá en los extremos de la resistencia serán: 1.25, 2.5, 3.75 y 5 volts. Entonces si se presiona el B0 Vg=1.25V, si se presiona B1 Vg=2.5, B2 Vg=3.75 y B4=5 volts. Ese Vg es el que aplicamos al pin del ADC del microcontrolador.
Figura 1. Teclado ADC.
Pero si no se presiona ninguna tecla ¿qué voltaje habrá en Vg? Sería cero, pero resulta que en el ADC el pin quedará flotado porque no está conectado a ningún potencial, así que el ADC medirá ruido, así que tenemos que modificar el circuito para fijar el ADC a un potencial de cero cuando no se presione ninguna tecla, figura 2. Se aprecia que el Vadc=0 cuando no se presione ninguna tecla porque está fijado a cero a través de la resistencia de pull down.
Figura 1. Teclado ADC disminuyendo efecto de carga
Vemos que al ser grande esa resistencia de 100Kohms su efecto sobre las resistencias del divisor disminuye, si fuera muy pequeña su efecto modificaría las resistencias del divisor y por lo tanto sus voltajes. Así que despreciaremos el efecto de carga de esa resistencia y consideraremos que los voltajes generados son 1.25, 2.5, 3.75 y 5 volts. Si
se colocan más teclas y más resistencias probablemente si requiera ver los voltajes que se generarían considerando el efecto de la resistencia de pull down. Cuando se presiona la tecla B1 se coloca en paralelo las dos resistencias de 1Kohm con la de 100 Kohm, así que el voltaje en la segunda resistencia no es de 2.5 Volts sino de 2.47 Volts, vemos que el efecto en el voltaje no es muy grande, así que lo seguiremos considerando de 2.5 volts. Vamos a suponer que tiene una red de 100 teclas y 100 resistores de 1Kohm y se presiona la última tecla, la resistencia equivalente sería 100Kohm en paralelo con 100 resistores de 1 Kohm=50 Kohms, en lugar de 100 kohms, así que cuando hay muchas teclas y resistores el efecto de carga se va haciendo más grande y deberá calcular los voltajes generados cuando se presione la tecla, pero en el caso de pocas teclas no influiría el efecto de esa resistencia.
Ahora bien, supongamos que usamos el ADC en 8 bits y el Vref = 5 volts así que el valor en cuentas es el que se muestra:
Tecla presionada
Voltaje generado
Valor en cuentas
B0 B1 B2 B3
1.25 2.5 3.75 5
64 127 191 255
TABLA 1 Valores generados para el teclado
Pero sabemos que las resistencias no son exactas así que colocamos un rango de holgura, vea que entre tecla y tecla hay aproximadamente 64 cuentas de diferencia. Entonces podemos hacer que el rango para detectar la tecla sean 32 cuentas hacia arriba y 32 hacia abajo del valor calculado por si la resistencia real es más grande o más pequeña por la tolerancia.
Tecla presionada
Voltaje generado
Valor en cuentas
B0 B1 B2 B3
1.25 2.5 3.75 5
32 a 96 97 a 159 160 a 223 Mayor a 223
Considere que el valor en cuentas, son los valores que el microcontrolador leerá para hacer el conteo del botón presionado, de esta manera podemos tener el teclado usando el ADC del micro, sin gastar más que un pin del mismo. Con ello simplemente tendríamos que agregar mas resistencias y botones a la entrada del micro, para tener un teclado mas amplio sin necesidad de usar mas puertos como entrada.
MICROCONTROLADOR ATMEGA 168 Principales características Ancho de bus de datos:
8 bit
Frecuencia de reloj máxima:
20 MHz
Tamaño de memoria del programa:
16 KB
Tamaño de RAM de datos:
1 KB
Conversión analógico-digital en chip:
Yes
Voltaje de alimentación operativo:
2.7 V to 5.5 V
Temperatura de trabajo máxima:
+ 85 C
Paquete / Cubierta:
PDIP-28
Estilo de montaje:
Through Hole
Tamaño de bits A/D:
10 bit
Canales A/D disponibles:
6
Tamaño de ROM de datos:
512 B
Tipo de interfaz:
2-Wire, SPI, Serial, USART
Temperatura de trabajo mínima:
- 40 C
Número de entradas / salidas programables:
23
Número de temporizadores:
3
Serie de procesadores:
megaAVR
Tipo de memoria de programa:
Flash
Serie:
ATMEGA 168
Diagrama de pines del Atmega168
PANTALLA LCD. Una pantalla de cristal líquido o L CD (sigla del inglés liquid crystal display ) es una pantalla delgada y plana formada por un número de píxeles en color o monocromos colocados delante de una fuente de luz o reflectora. A menudo se utiliza en dispositivos electrónicos de pilas, ya que utiliza cantidades muy pequeñas de energía eléctrica .
Pantalla LCD de 2x16.
La mayoría de las pantallas LCD vienen unidas a una placa de circuito y poseen pines de entrada/salida de datos.
Estas pantallas constan de 16 pines. De izquierda a derecha, sus usos son los siguientes: Pin 1 – VSS o GND Pin 2 – VDD o alimentación (+5V) Pin 3 – Voltaje de contraste. Se conecta a un potenciómetro. Pin 4 – Selección de registro. Aquí se selecciona el dispositivo para su uso. Pin 5 – Lectura/Escritura. Dependiendo del estado (HIGH o LOW), se podrá escribir o leer datos
en el LCD
Pin 6 – Enable. Es el pin que habilita o deshabilita el LCD. Pin 7 hasta Pin 14 – Son los pines de datos por donde se envía o recibe información. Pin 15 – El ánodo del LED de iluminación de fondo (+5v). Pin 16 – El cátodo del LED de iluminación de fondo (GND).
Diagrama de conexiones para el LCD.
PROCEDIMIENTO Y DESARROLLO DE LA PRACTICA
En la imagen inferior podemos ver como se implemento el circuito en el ISIS de proteus para su simulación y su posterior diseño.
Las teclas van de 0-9 empezando pos las tres primeras de derecha a izquierda y asi sucesivamente hasta llegar a la superior en la parte alta. En la imagen se puede ver como ha sido presionada la tecla 4 que se ve representada en la pantalla.
El código empleado para programar el microcontrolador es el que se muestra a continuación: #include
#include #include #include intval,tecla,cont; signed char x0, x1, x2, x3, x4, x5, x6, x7; signed char aa,bb,cc,dd,ee,ff,gg,hh,A,B,C,D,E,F,G,H; float result[8][2]; float valor; signed int dato,centenas,decenas,unidades,M,P,Q; unsigned char i,j; // Alphanumeric LCD functions #include #define ADC_VREF_TYPE 0x60 // Read the 8 most significant bits // of the AD conversion result unsigned char read_adc(unsigned char adc_input) { ADMUX=adc_input | (ADC_VREF_TYPE & 0xff); // Delay needed for the stabilization of the ADC input voltage delay_us(10); // Start the AD conversion ADCSRA|=0x40; // Wait for the AD conversion to complete while ((ADCSRA & 0x10)==0); ADCSRA|=0x10; return ADCH; } // Declare your global variables here void main(void) { // Declare your local variables here // Crystal Oscillator division factor: 1 #pragma optsizeCLKPR=0x80; CLKPR=0x00; #ifdef _OPTIMIZE_SIZE_ #pragma optsize+ #endif // Input/Output Ports initialization // Port B initialization // Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTB=0x00; DDRB=0x00; // Port C initialization // Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State6=T State5=T State4=T State3=T State2=T State1=T State0=T PORTC=0x00; DDRC=0x00; // Port D initialization // Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In // State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T PORTD=0x00; DDRD=0x00; // Timer/Counter 0 initialization // Clock source: System Clock // Clock value: Timer 0 Stopped // Mode: Normal top=0xFF // OC0A output: Disconnected // OC0B output: Disconnected TCCR0A=0x00; TCCR0B=0x00; TCNT0=0x00; OCR0A=0x00; OCR0B=0x00; // Timer/Counter 1 initialization // Clock source: System Clock // Clock value: Timer1 Stopped // Mode: Normal top=0xFFFF // OC1A output: Discon. // OC1B output: Discon. // Noise Canceler: Off // Input Capture on Falling Edge // Timer1 Overflow Interrupt: Off // Input Capture Interrupt: Off // Compare A Match Interrupt: Off // Compare B Match Interrupt: Off TCCR1A=0x00; TCCR1B=0x00; TCNT1H=0x00; TCNT1L=0x00; ICR1H=0x00; ICR1L=0x00; OCR1AH=0x00; OCR1AL=0x00; OCR1BH=0x00; OCR1BL=0x00; // Timer/Counter 2 initialization
// Clock source: System Clock // Clock value: Timer2 Stopped // Mode: Normal top=0xFF // OC2A output: Disconnected // OC2B output: Disconnected ASSR=0x00; TCCR2A=0x00; TCCR2B=0x00; TCNT2=0x00; OCR2A=0x00; OCR2B=0x00; // External Interrupt(s) initialization // INT0: Off // INT1: Off // Interrupt on any change on pins PCINT0-7: Off // Interrupt on any change on pins PCINT8-14: Off // Interrupt on any change on pins PCINT16-23: Off EICRA=0x00; EIMSK=0x00; PCICR=0x00;
// TWI initialization // TWI disabled TWCR=0x00; // Alphanumeric LCD initialization // Connections are specified in the // Project|Configure|CCompiler|Libraries|Alphanumeric LCD menu: // RS - PORTB Bit 0 // RD - PORTB Bit 1 // EN - PORTB Bit 2 // D4 - PORTB Bit 4 // D5 - PORTB Bit 5 // D6 - PORTB Bit 6 // D7 - PORTB Bit 7 // Characters/line: 16 lcd_init(16);
// Timer/Counter 0 Interrupt(s) initialization TIMSK0=0x00;
while (1) { val=read_adc(0); delay_ms(200);
// Timer/Counter 1 Interrupt(s) initialization TIMSK1=0x00;
lcd_gotoxy(2,0); lcd_puts("ENTRAR DATOS");
// Timer/Counter 2 Interrupt(s) initialization TIMSK2=0x00;
// ADC initialization // ADC Clock frequency: 250,000 kHz // ADC Voltage Reference: AVCC pin // ADC Auto Trigger Source: ADC Stopped // Only the 8 most significant bits of // the AD conversion result are used // Digital input buffers on ADC0: On, ADC1: On, ADC2: On, ADC3: On // ADC4: On, ADC5: On DIDR0=0x00; ADMUX=ADC_VREF_TYPE & 0xff; ADCSRA=0x85;
if(val>=23) { if ((val>=23) && (val<44)) tecla=0; //Tecla=0 en ASCII if ((val>=45) && (val<67)) tecla=1; //Tecla=1 en ASCII if ((val>=68) && (val<89)) tecla=2; //Tecla=2 en ASCII if ((val>=90) && (val<112)) tecla=3; //Tecla=3 en ASCII if ((val>=113) && (val<135)) tecla=4; //Tecla=4 en ASCII if ((val>=136) && (val<157)) tecla=5; //Tecla=5 en ASCII if ((val>=158) && (val<180)) tecla=6; //Tecla=6 en ASCII if ((val>=181) && (val<204)) tecla=7; //Tecla=7 en ASCII if ((val>=205) && (val<229)) tecla=8; //Tecla=8 en ASCII if ((val>=229) && (val<253)) tecla=9; //Tecla=9 en ASCII if (val>253) tecla=-1; //Tecla=- en ASCII cont=cont+1; }
// SPI initialization // SPI disabled SPCR=0x00;
if(cont==1) { x0=tecla;
// USART initialization // USART disabled UCSR0B=0x00; // Analog Comparator initialization // Analog Comparator: Off // Analog Comparator Input Capture by Timer/Counter 1: Off ACSR=0x80; ADCSRB=0x00; DIDR1=0x00;
lcd_gotoxy(0,1); lcd_puts(" X0= "); lcd_putchar(x0+48); delay_ms(100); } if(cont==2) { x1=tecla; lcd_gotoxy(0,1); lcd_puts(" X1= "); lcd_putchar(x1+48); delay_ms(100); } if(cont==3) { x2=tecla; lcd_gotoxy(0,1); lcd_puts(" X2= "); lcd_putchar(x2+48); delay_ms(100); } if(cont==4) { x3=tecla; lcd_gotoxy(0,1); lcd_puts(" X3= "); lcd_putchar(x3+48); delay_ms(100); } if(cont==5) { x4=tecla; lcd_gotoxy(0,1); lcd_puts(" X4= "); lcd_putchar(x4+48); delay_ms(100); } if(cont==6) { x5=tecla; lcd_gotoxy(0,1); lcd_puts(" X5= "); lcd_putchar(x5+48); delay_ms(100); } if(cont==7) { x6=tecla; lcd_gotoxy(0,1); lcd_puts(" X6= "); lcd_putchar(x6+48); delay_ms(100); }
if(cont==8) { x7=tecla; lcd_gotoxy(0,1); lcd_puts(" X7= "); lcd_putchar(x7+48); delay_ms(100); lcd_clear(); } while(cont==8) { //************CODIGO PARA TRANSFORMAR LAS MUESTRAS********************** //********Primer nivel*************************** aa=x0+x4; bb=x0-x4; cc=x2+x6; dd=x2-x6; ee=x1+x5; ff=x1-x5; gg=x3+x7; hh=x3-x7; //******segundo nivel*************************** A=aa+cc; B=bb-dd; C=aa-cc; D=bb+dd; E=ee+gg; F=ff-hh; G=ee-gg; H=ff+hh; //***************tercer nivel y (ARREGLO PARA MUESTRAS TRANSFORMADAS)********************** result[0][0]=(E+A); result[1][0]=((F*0.7071)+(bb)); result[1][1]=(-1)*(((0.7071*hh)+(0.7071*ff))+(dd)); result[2][0]=C; result[2][1]=((-1)*(G)); result[3][0]=((-0.7071*ff)-(-0.7071*hh))+(bb); result[3][1]=((1)*(dd))+(H*-0.7071); result[4][0]=((-1)*(E))+(A);
result[5][0]=((-0.7071*ff)-(-0.7071*hh))+(bb); result[5][1]=(-1)*((dd)+(H*-0.7071)); result[6][0]=C;
result[6][1]=G; result[7][0]=((F*0.7071)+(bb)); result[7][1]=((0.7071*hh)+(0.7071*ff))+(dd); //********************DESPLIEGUE DE MUESTRAS EN LCD*********************** // for(i=0;i<=7;i++)//se escoge extrae la muestra correspondiente del arreglo { result[i]; lcd_gotoxy(2,0); lcd_puts("X"); lcd_putchar(i+0x30); lcd_puts(" "); for(j=0;j<=1;j++)//de cada muestra se despliega su parte real y despues la parte imaginaria { valor=result[i][j];// dato=(valor*1000); if(dato>0) { centenas=(dato/10000); //se descompone la muestra para desplegarla en caso de ser positiva decenas=((dato-(centenas*10000))/1000); unidades=((dato-(centenas*10000)(decenas*1000))/100); M=((dato-(centenas*10000)-(decenas*1000)(unidades*100))/10); P=(dato-(centenas*10000)-(decenas*1000)(unidades*100)-(M*10)); lcd_putchar(centenas+0x30); lcd_putchar(decenas+0x30); lcd_puts("."); lcd_putchar(unidades+0x30); lcd_putchar(M+0x30); lcd_putchar(P+0x30); lcd_gotoxy(11,0);//indicadores en la lcd lcd_puts("real"); lcd_gotoxy(11,1); lcd_puts("imagin"); }
if(dato<0)//se descompone muestra para desplegarla, en caso de ser negativa { dato=(dato*(-1)); centenas=(dato/10000); //se descompone la muestra para desplegarla en caso de ser positiva decenas=((dato-(centenas*10000))/1000); unidades=((dato-(centenas*10000)(decenas*1000))/100); M=((dato-(centenas*10000)-(decenas*1000)(unidades*100))/10); P=(dato-(centenas*10000)-(decenas*1000)(unidades*100)-(M*10)); lcd_puts("-"); lcd_putchar(centenas+0x30); lcd_putchar(decenas+0x30); lcd_puts("."); lcd_putchar(unidades+0x30); lcd_putchar(M+0x30); lcd_putchar(P+0x30); lcd_gotoxy(11,0);//indicadores en la lcd lcd_puts("real"); lcd_gotoxy(11,1); lcd_puts("imagin"); } lcd_gotoxy(3,1); //se cambia de renglon en la lcd para desplegar la parte imaginaria }valor=read_adc(0); delay_ms(500); if(valor>=254) { cont=0; lcd_clear(); } } delay_ms(500);//retardo para apreciar los despliegues correspondientes en la lcd lcd_clear();//borrado de pantalla para desplegar un nuevo par de datos en la lcd } } } }
Descripción general del código Las muestras son capturadas por medio del ADC y guardadas en variables las cuales son utilizadas para hacer las cuentas necesarias y los resultados se fueron guardando en un vector de 8 x 2, para después desplegar los resultados en pantalla uno por uno, para cuando el valor del punto de la transformada es menor a 0 se multiplica el valor por -1 y al
final solo se pinta el signo “ -“ en la posición correspondiente, en el caso de ser positivo el
valor se queda igual. En pantalla se muestra el valor con tres decimales y el código se implementó para muestras>=0
El circuito simulado se implementó como se observa en la siguiente imagen:
CONCLUSIONES
Esta práctica resulto algo laboriosa ya que se tuvo que analizar detalladamente como es que se realiza la transformada rápida de Fourier y cuáles son las operaciones en las cuales solo es el conjugado de otra operación. La transformada Rápida de Fourierpara este caso se implementó a 8 puntos. Por falta de tiempo solo se pudo hacer que el programa aceptará valores mayores a cero y que mostrara en pantalla tres decimales. Lo más difícil que se presento fue tratar de hacer funcionar el teclado donde el usuario introducía los valores imaginados, al elegir un teclado por medio de ADC se facilitó un poco su implementación pero se tuvo en ocasiones errores en cuanto al valor que tomaba el ADC. Se utilizó un ADC con una resolución de 8 bits obteniendo valores de 0 a 256 los cuales se peticionaron para que por medio de condiciones obtuviéramos el valor introducido. En la pantalla LCD se muestran los valores uno a uno esperando durante cada valor para que pueda ser visualizado.
Rosendo Antonio Sepúlveda Valdes
CONCLUSIONES En el desarrollo de esta práctica se pudo ver cómo es posible realizar el cálculo de la transformada rápida de Fourier implementando en un microcontrolador. De a cuerdo a la teoría esta transformada tiene mucho menos cálculos que otras implementadas, por ello con un algoritmo matemático utilizando sumas y multiplicaciones simples, podemos llegar al resultado deseado. También para la implementación de esta transformada se implemento el diseño de un teclado, para que el usuario pudiese ingresar los ocho datos del vector para el cálculo de la misma. Para la implementación de este teclado se uso un modo conocido como teclado ADC, donde el valor de cada push botton está relacionado a un valor de voltaje y este a su vez es leído por el puerto ADC, y guardado en una variable obviamente representado por un numero particular. Con esto se simplifico mucho el diseño para el teclado. Con otros modelos para hubiese sido un poco más laborioso y un diseño más extenso. A pesar de esto, se tuvieron algunos inconvenientes para la lectura del puerto, ya que en algunas ocasiones el pulso no era bien leído por el puerto o reconocía otro valor que no pertenecía, sin embargo esto se pudo superar con modificar el tiempo de lectura del ADC y cuidando de no mantener presionado el botón por un tiempo prolongado.
Carlos Ángel Pérez Barrios.
