INSTITUTO TECNOLGICO

DE MORELIA
SECRETARIA DE EDUCACIN
PBLICA

M.C. EN ING. ELECTRNICA

ASIGNATURA:

PROCESAMIENTO DE SEALES

REPORTE DE PRCTICA No. 3:

TRANSFORMADA RAPIDA DE FOURIER

EN UN MICROCONTROLADOR
PRESENTAN:

Rosendo Antonio Seplveda Valdes

Carlos ngel Prez Barrios
DOCENTE:

Dra. ADRIANA DEL CARMEN TLLEZ ANGUIANO

Morelia, Michoacn

31 marzo 2014.

INTRODUCCIN

Para la implementacin de esta prctica 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 rpida 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 ledo por el puerto del ADC, se tena el numero deseado.
Como se sabe la FFT (abreviatura usual para el idioma ingles) es un algoritmo que nos
ayudara a calcular esta transformada rpida, la cual tiene variedad de aplicaciones, que
van desde un tratamiento de seales digitales y un filtrado digital hasta para resolucin de
ecuaciones en derivadas parciales o los algoritmos de multiplicacin rpida de grandes
enteros. Este mtodo es eficaz y de importancia para el anlisis matemtico. Sus
aplicaciones son mltiples adems de que puede facilitar el uso de algoritmos. Para el
caso de la transformada rpida de Fourier se implementar en el programa del
microcontrolador el proceso para el clculo de ocho puntos que se describi
anteriormente en clase.

OBEJETIVO DE LA PRCTICA
Implementar la Transformada Rpida de Fourier en un microcontrolador usando el mtodo
de 8 puntos.

MARCO TERICO
Transformada Rpida de Fourier
El trmino genrico transformada rpida de Fourier abarca distintos algoritmos
con distintas caractersticas, ventajas y desventajas. Por ejemplo, una FFT diseada y
optimizada usando un lenguaje de alto nivel probablemente no funcionar correctamente
en un DSP. Sin embargo, todas las FFTs usan la misma aproximacin para reducir el
algoritmo en un nmero reducido de DFTs sucesivas, cortas y simples. Hay que tener
en cuenta que:

- La FFT es un algoritmo (no una aproximacin) 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 nmeros de
operaciones menores que utiliza la FFT para ser resuelta.
Algoritmo FFF en Base 2 y Diezmado en el tiempo
Consideremos el clculo 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:

Obsrvese, que se realiz el diezmado de la secuencia x[n], una vez. La DFT de N puntos
puede expresarse ahora en trminos de las DFTs de las secuencias diezmadas como
sigue:

Pero

Donde

. Sustituyendo esta igualdad en la expresin anterior se tiene:

( )

( ) son las DFTs de N/2 puntos de las secuencias correspondientes a

la primera expresin.
( )

Puesto que
(

( ) son peridicas, de periodo N/2, tenemos;

( )

Por otro lado, se cumple que

( )
por lo que se puede escribir la siguiente

expresin sustituyendo en la anterior.

Se observa que el clculo directo

igual que

( ) requiere de (

multiplicaciones complejas

( ) Adems, se requieren N/2 multiplicaciones ms para calcular

De aqu el clculo de

( ) Requiere

( )

multiplicaciones complejas. El primer paso

realizado de una reduccin en el nmero de multiplicaciones

, lo que equivale

aproximadamente a dividir por dos el nmero 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 expresin 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 clculo de

clculo de

( ) y

( ) requieres de

( )

( ) puede realizarse con

multiplicaciones y por lo tanto el

multiplicaciones complejas. Se

requieren N/2 multiplicaciones complejas ms para calcular

( )

[ ]

( ) a partir de

Consecuentemente, el nmero total de multiplicaciones necesarias

( )

y
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 nmero total de multiplicaciones complejas se reduce a

, mientras que el nmero de sumas complejas es

. En la tabla inferior se

muestra la comparacin entre el nmero de multiplicaciones complejas usando la FFT y el

clculo directo de la DFT.

Tabla de comparacin 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 clculo 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 multiplicacin y dos sumas complejas. Para N puntos,
tenemos N/2 mariposas por cada etapa del proceso y log2 N etapas de mariposas.

IMPLEMENTACIN DEL TECLADO ADC

Para la implementacin 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 fcil de realizarlo ahorrando tambin 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 electrodomsticos funcionan como los
estreos de casa que tienen muchas teclas, hacen que cada tecla genere un voltaje
distinto.

Tericamente si tenemos un ADC de 8 bits podramos tener hasta 256 teclas, pero en
la prctica 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
sern: 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? Sera cero, pero resulta
que en el ADC el pin quedar flotado porque no est conectado a ningn 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 travs 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 pequea su efecto modificara 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 ms teclas y ms resistencias probablemente si requiera ver los voltajes que

se generaran 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 sera 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 ms grande y deber calcular los
voltajes generados cuando se presione la tecla, pero en el caso de pocas teclas no
influira 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
B0
B1
B2
B3

Voltaje generado
1.25
2.5
3.75
5

Valor en cuentas
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 ms grande o ms
pequea por la tolerancia.

Tecla presionada
B0
B1
B2
B3

Voltaje generado
1.25
2.5
3.75
5

Valor en cuentas
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 botn presionado, de esta manera podemos tener el teclado usando el
ADC del micro, sin gastar ms que un pin del mismo. Con ello simplemente tendramos
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 caractersticas
Ancho de bus de datos:

8 bit

Frecuencia de reloj mxima:

20 MHz

Tamao de memoria del programa:

16 KB

Tamao de RAM de datos:

1 KB

Conversin analgico-digital en chip:

Yes

Voltaje de alimentacin operativo:

2.7 V to 5.5 V

Temperatura de trabajo mxima:

+ 85 C

Paquete / Cubierta:

PDIP-28

Estilo de montaje:

Through Hole

Tamao de bits A/D:

10 bit

Canales A/D disponibles:

Tamao de ROM de datos:

512 B

Tipo de interfaz:

2-Wire, SPI, Serial, USART

Temperatura de trabajo mnima:

- 40 C

Nmero de entradas / salidas programables:

23

Nmero de temporizadores:

Serie de procesadores:

megaAVR

Tipo de memoria de programa:

Flash

Serie:

ATMEGA 168

Diagrama de pines del Atmega168

PANTALLA LCD.
Una pantalla de cristal lquido o LCD (sigla del ingls liquid crystal display) es una
pantalla delgada y plana formada por un nmero de pxeles en color o monocromos
colocados delante de una fuente de luz o reflectora. A menudo se utiliza en dispositivos
electrnicos de pilas, ya que utiliza cantidades muy pequeas de energa elctrica.

Pantalla LCD de 2x16.

La mayora 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 alimentacin (+5V)
Pin 3 Voltaje de contraste. Se conecta a un potencimetro.
Pin 4 Seleccin 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 enva o recibe informacin.
Pin 15 El nodo del LED de iluminacin de fondo (+5v).
Pin 16 El ctodo del LED de iluminacin 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 simulacin y su posterior diseo.

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 cdigo empleado para programar el microcontrolador es el que se muestra a

continuacin:
#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 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
}
}
}
}

Descripcin general del cdigo

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 despus 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 posicin correspondiente, en el caso de ser positivo el

valor se queda igual.
En pantalla se muestra el valor con tres decimales y el cdigo se implement para
muestras>=0

El circuito simulado se implement como se observa en la siguiente imagen:

CONCLUSIONES

Esta prctica resulto algo laboriosa ya que se tuvo que analizar detalladamente como es
que se realiza la transformada rpida de Fourier y cules son las operaciones en las
cuales solo es el conjugado de otra operacin. La transformada Rpida 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 ms difcil que se presento fue tratar de hacer funcionar el teclado donde el usuario
introduca los valores imaginados, al elegir un teclado por medio de ADC se facilit un
poco su implementacin pero se tuvo en ocasiones errores en cuanto al valor que tomaba
el ADC. Se utiliz un ADC con una resolucin de 8 bits obteniendo valores de 0 a 256 los
cuales se peticionaron para que por medio de condiciones obtuviramos 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 Seplveda Valdes

CONCLUSIONES
En el desarrollo de esta prctica se pudo ver cmo es posible realizar el clculo de la
transformada rpida de Fourier implementando en un microcontrolador. De a cuerdo a la
teora esta transformada tiene mucho menos clculos que otras implementadas, por ello
con un algoritmo matemtico utilizando sumas y multiplicaciones simples, podemos llegar
al resultado deseado.
Tambin para la implementacin de esta transformada se implemento el diseo de un
teclado, para que el usuario pudiese ingresar los ocho datos del vector para el clculo de
la misma. Para la implementacin 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 ledo por el puerto ADC, y guardado en una variable obviamente representado
por un numero particular. Con esto se simplifico mucho el diseo para el teclado. Con
otros modelos para hubiese sido un poco ms laborioso y un diseo ms extenso. A pesar
de esto, se tuvieron algunos inconvenientes para la lectura del puerto, ya que en algunas
ocasiones el pulso no era bien ledo por el puerto o reconoca otro valor que no
perteneca, sin embargo esto se pudo superar con modificar el tiempo de lectura del ADC
y cuidando de no mantener presionado el botn por un tiempo prolongado.

Carlos ngel Prez Barrios.