INSTITUTO TECNOLÓGICO

DE MORELIA

SECRETARIA DE EDUCACIÓN
PÚBLICA

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, 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:

PORTB=0x00;
#include <stdlib.h> DDRB=0x00;
#include <mega168.h>
#include <delay.h> // Port C initialization
#include <math.h> // Func6=In Func5=In Func4=In Func3=In Func2=In
intval,tecla,cont; Func1=In Func0=In
signed char x0, x1, x2, x3, x4, x5, x6, x7; // State6=T State5=T State4=T State3=T State2=T
signed char aa,bb,cc,dd,ee,ff,gg,hh,A,B,C,D,E,F,G,H; State1=T State0=T
float result[8][2]; PORTC=0x00;
DDRC=0x00;
float valor;
signed int dato,centenas,decenas,unidades,M,P,Q; // Port D initialization
unsigned char i,j; // Func7=In Func6=In Func5=In Func4=In Func3=In
Func2=In Func1=In Func0=In
// Alphanumeric LCD functions // State7=T State6=T State5=T State4=T State3=T
#include <alcd.h> State2=T State1=T State0=T
PORTD=0x00;
#define ADC_VREF_TYPE 0x60 DDRD=0x00;

// Read the 8 most significant bits // Timer/Counter 0 initialization

// of the AD conversion result // Clock source: System Clock
unsigned char read_adc(unsigned char adc_input) // Clock value: Timer 0 Stopped
{ // Mode: Normal top=0xFF
ADMUX=adc_input | (ADC_VREF_TYPE & 0xff); // OC0A output: Disconnected
// Delay needed for the stabilization of the ADC input // OC0B output: Disconnected
voltage TCCR0A=0x00;
delay_us(10); TCCR0B=0x00;
// Start the AD conversion TCNT0=0x00;
ADCSRA|=0x40; OCR0A=0x00;
// Wait for the AD conversion to complete OCR0B=0x00;
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10; // Timer/Counter 1 initialization
return ADCH; // Clock source: System Clock
} // Clock value: Timer1 Stopped
// Mode: Normal top=0xFFFF
// Declare your global variables here // OC1A output: Discon.
// OC1B output: Discon.
void main(void) // Noise Canceler: Off
{ // Input Capture on Falling Edge
// Declare your local variables here // Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Crystal Oscillator division factor: 1 // Compare A Match Interrupt: Off
#pragma optsize- // Compare B Match Interrupt: Off
CLKPR=0x80; TCCR1A=0x00;
CLKPR=0x00; TCCR1B=0x00;
#ifdef _OPTIMIZE_SIZE_ TCNT1H=0x00;
#pragma optsize+ TCNT1L=0x00;
#endif ICR1H=0x00;
ICR1L=0x00;
// Input/Output Ports initialization OCR1AH=0x00;
// Port B initialization OCR1AL=0x00;
// Func7=In Func6=In Func5=In Func4=In Func3=In OCR1BH=0x00;
Func2=In Func1=In Func0=In OCR1BL=0x00;
// State7=T State6=T State5=T State4=T State3=T
State2=T State1=T State0=T // Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer2 Stopped // TWI initialization
// Mode: Normal top=0xFF // TWI disabled
// OC2A output: Disconnected TWCR=0x00;
// OC2B output: Disconnected
ASSR=0x00; // Alphanumeric LCD initialization
TCCR2A=0x00; // Connections are specified in the
TCCR2B=0x00; //
TCNT2=0x00; Project|Configure|CCompiler|Libraries|Alphanumeric
OCR2A=0x00; LCD menu:
OCR2B=0x00; // RS - PORTB Bit 0
// RD - PORTB Bit 1
// External Interrupt(s) initialization // EN - PORTB Bit 2
// INT0: Off // D4 - PORTB Bit 4
// INT1: Off // D5 - PORTB Bit 5
// Interrupt on any change on pins PCINT0-7: Off // D6 - PORTB Bit 6
// Interrupt on any change on pins PCINT8-14: Off // D7 - PORTB Bit 7
// Interrupt on any change on pins PCINT16-23: Off // Characters/line: 16
EICRA=0x00; lcd_init(16);
EIMSK=0x00;
PCICR=0x00; while (1)
{
// Timer/Counter 0 Interrupt(s) initialization val=read_adc(0);
TIMSK0=0x00; delay_ms(200);

// Timer/Counter 1 Interrupt(s) initialization lcd_gotoxy(2,0);

TIMSK1=0x00; lcd_puts("ENTRAR DATOS");

// Timer/Counter 2 Interrupt(s) initialization

TIMSK2=0x00; if(val>=23)
{
// USART initialization if ((val>=23) && (val<44))
// USART disabled tecla=0; //Tecla=0 en ASCII
UCSR0B=0x00; if ((val>=45) && (val<67))
tecla=1; //Tecla=1 en ASCII
// Analog Comparator initialization if ((val>=68) && (val<89))
// Analog Comparator: Off tecla=2; //Tecla=2 en ASCII
// Analog Comparator Input Capture by Timer/Counter if ((val>=90) && (val<112))
1: Off tecla=3; //Tecla=3 en ASCII
ACSR=0x80; if ((val>=113) && (val<135))
ADCSRB=0x00; tecla=4; //Tecla=4 en ASCII
DIDR1=0x00; if ((val>=136) && (val<157))
tecla=5; //Tecla=5 en ASCII
// ADC initialization if ((val>=158) && (val<180))
// ADC Clock frequency: 250,000 kHz tecla=6; //Tecla=6 en ASCII
// ADC Voltage Reference: AVCC pin if ((val>=181) && (val<204))
// ADC Auto Trigger Source: ADC Stopped tecla=7; //Tecla=7 en ASCII
// Only the 8 most significant bits of if ((val>=205) && (val<229))
// the AD conversion result are used tecla=8; //Tecla=8 en ASCII
// Digital input buffers on ADC0: On, ADC1: On, ADC2: if ((val>=229) && (val<253))
On, ADC3: On tecla=9; //Tecla=9 en ASCII
// ADC4: On, ADC5: On if (val>253)
DIDR0=0x00; tecla=-1; //Tecla=- en ASCII
ADMUX=ADC_VREF_TYPE & 0xff; cont=cont+1;
ADCSRA=0x85; }

// SPI initialization if(cont==1)

// SPI disabled {
SPCR=0x00; x0=tecla;
lcd_gotoxy(0,1);
lcd_puts(" X0= "); if(cont==8)
lcd_putchar(x0+48); {
delay_ms(100); x7=tecla;
} lcd_gotoxy(0,1);
lcd_puts(" X7= ");
if(cont==2) lcd_putchar(x7+48);
{ delay_ms(100);
x1=tecla; lcd_clear();
lcd_gotoxy(0,1); }
lcd_puts(" X1= ");
lcd_putchar(x1+48); while(cont==8)
delay_ms(100); {
} //************CODIGO PARA TRANSFORMAR
LAS MUESTRAS**********************
if(cont==3) //********Primer
{ nivel***************************
x2=tecla; aa=x0+x4;
lcd_gotoxy(0,1); bb=x0-x4;
lcd_puts(" X2= "); cc=x2+x6;
lcd_putchar(x2+48); dd=x2-x6;
delay_ms(100); ee=x1+x5;
} ff=x1-x5;
gg=x3+x7;
if(cont==4) hh=x3-x7;
{ //******segundo
x3=tecla; nivel***************************
lcd_gotoxy(0,1); A=aa+cc;
lcd_puts(" X3= "); B=bb-dd;
lcd_putchar(x3+48); C=aa-cc;
delay_ms(100); D=bb+dd;
} E=ee+gg;
F=ff-hh;
if(cont==5) G=ee-gg;
{ H=ff+hh;
x4=tecla;
lcd_gotoxy(0,1); //***************tercer nivel y (ARREGLO PARA
lcd_puts(" X4= "); MUESTRAS
lcd_putchar(x4+48); TRANSFORMADAS)**********************
delay_ms(100);
} result[0][0]=(E+A);

if(cont==6) result[1][0]=((F*0.7071)+(bb));
{
x5=tecla; result[1][1]=(-1)*(((0.7071*hh)+(0.7071*ff))+(dd));
lcd_gotoxy(0,1);
lcd_puts(" X5= "); result[2][0]=C;
lcd_putchar(x5+48); result[2][1]=((-1)*(G));
delay_ms(100);
} result[3][0]=((-0.7071*ff)-(-0.7071*hh))+(bb);
result[3][1]=((1)*(dd))+(H*-0.7071);
if(cont==7)
{ result[4][0]=((-1)*(E))+(A);
x6=tecla;
lcd_gotoxy(0,1);
lcd_puts(" X6= "); result[5][0]=((-0.7071*ff)-(-0.7071*hh))+(bb);
lcd_putchar(x6+48); result[5][1]=(-1)*((dd)+(H*-0.7071));
delay_ms(100);
} result[6][0]=C;
result[6][1]=G;
if(dato<0)//se descompone muestra para desplegarla,
result[7][0]=((F*0.7071)+(bb)); en caso de ser negativa
{
result[7][1]=((0.7071*hh)+(0.7071*ff))+(dd); dato=(dato*(-1));
centenas=(dato/10000); //se descompone la muestra
//********************DESPLIEGUE DE para desplegarla en caso de ser positiva
MUESTRAS EN LCD*********************** decenas=((dato-(centenas*10000))/1000);
// unidades=((dato-(centenas*10000)-
for(i=0;i<=7;i++)//se escoge extrae la muestra (decenas*1000))/100);
correspondiente del arreglo M=((dato-(centenas*10000)-(decenas*1000)-
{ (unidades*100))/10);
result[i]; P=(dato-(centenas*10000)-(decenas*1000)-
lcd_gotoxy(2,0); (unidades*100)-(M*10));
lcd_puts("X"); lcd_puts("-");
lcd_putchar(i+0x30); lcd_putchar(centenas+0x30);
lcd_puts(" "); lcd_putchar(decenas+0x30);
for(j=0;j<=1;j++)//de cada muestra se despliega su lcd_puts(".");
parte real y despues la parte imaginaria lcd_putchar(unidades+0x30);
{ lcd_putchar(M+0x30);
valor=result[i][j];// lcd_putchar(P+0x30);
dato=(valor*1000);
lcd_gotoxy(11,0);//indicadores en la lcd
if(dato>0) lcd_puts("real");
{ lcd_gotoxy(11,1);
centenas=(dato/10000); //se descompone la muestra lcd_puts("imagin");
para desplegarla en caso de ser positiva }
decenas=((dato-(centenas*10000))/1000); lcd_gotoxy(3,1); //se cambia de renglon en la lcd para
unidades=((dato-(centenas*10000)- desplegar la parte imaginaria
(decenas*1000))/100); }valor=read_adc(0);
M=((dato-(centenas*10000)-(decenas*1000)- delay_ms(500);
(unidades*100))/10); if(valor>=254)
P=(dato-(centenas*10000)-(decenas*1000)- {
(unidades*100)-(M*10)); cont=0;
lcd_putchar(centenas+0x30); lcd_clear();
lcd_putchar(decenas+0x30); }
lcd_puts("."); }
lcd_putchar(unidades+0x30); delay_ms(500);//retardo para apreciar los despliegues
lcd_putchar(M+0x30); correspondientes en la lcd
lcd_putchar(P+0x30); lcd_clear();//borrado de pantalla para desplegar un
nuevo par de datos en la lcd
lcd_gotoxy(11,0);//indicadores en la lcd }
lcd_puts("real"); }
lcd_gotoxy(11,1); }
lcd_puts("imagin"); }
}

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.