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.

SECRETARIA DE EDUCACIÓN

PÚBLICA

INSTITUTO TECNOLÓGICO DE MORELIA

INTRODUCCIÓN

Para la implementación de esta práctica se hace uso únicamente de un microcontrolador

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.

Puesto que ( ) ( ) son periódicas, de periodo N/2, tenemos;

( ) ( ) ( ) ( )

Por otro lado, se cumple que

por lo que se puede escribir la siguiente

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 ( )

De aquí el cálculo de ( ) Requiere

multiplicaciones complejas. El primer paso

realizado de una reducción en el número de multiplicaciones a

, lo que equivale

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 [ ]

Se observa que el cálculo de ( ) requieres de (

) 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

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 general

cada mariposa implica una multiplicación y dos sumas complejas. Para N puntos,

tenemos N/2 mariposas por cada etapa del proceso y log2 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 cada 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 1.25 64 B1 2.5 127 B2 3.75 191 B3 5 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 1.25 32 a 96 B1 2.5 97 a 159 B2 3.75 160 a 223 B3 5 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 LCD (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 <stdlib.h> #include <mega168.h> #include <delay.h> #include <math.h> 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 <alcd.h> #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 optsize- CLKPR=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; // Timer/Counter 0 Interrupt(s) initialization TIMSK0=0x00; // Timer/Counter 1 Interrupt(s) initialization TIMSK1=0x00; // Timer/Counter 2 Interrupt(s) initialization TIMSK2=0x00; // 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; // 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; // SPI initialization // SPI disabled SPCR=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); while (1) { val=read_adc(0); delay_ms(200); lcd_gotoxy(2,0); lcd_puts("ENTRAR DATOS"); 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; } if(cont==1) { x0=tecla;

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.