Você está na página 1de 34

UNIVERSIDAD DE CUENCA

FACULTAD DE INGENIERA

ESCUELA DE ELECTRNICA Y TELECOMUNICACIONES

LABORATORIO DE PROCESAMIENTO DIGITAL DE SEALES

PROYECTO FINAL:
DISTORSIONADOR DIGITAL DE GUITARRA

GABRIEL CASTRO
DAVID GARCIA
LAYLA GUERRERO
PAUL VERDUGO
MARCELO YUNGAICELA

CUARTO AO
1. Objetivos:
Muestrear correctamente una seal analgica proveniente de una fuente de sonido.
Procesar digitalmente y reproducir de manera correcta una seal de audio a travs de un
procesador digital de seal.
Implementar un mecanismo de buffering para la aplicacin de efectos de retardo mediante una
memoria SRAM.
2. Marco Terico
2.1. Procesador digital se seal dsPIC30F4011
Los dsPIC de la familia 30F ofrecen la capacidad de un DSP con las caractersticas de control en tiempo
real de un microcontrolador. Posee acumuladores duales de 40 bits, MACS de 16 x 16 de un solo ciclo.
Est diseado con una arquitectura Harvard modificada, es decir, permite palabras de diferente tamao:
24 bits para programa y 16 bits para datos; y permite un procesamiento ms rpido, el procesador puede
buscar anticipadamente la prxima instruccin mientras ejecuta la instruccin actual que accede a datos
en la RAM [1].
Este dsPIC posee un espacio de memoria para datos de 64Kb. Las instrucciones de multiplicacin de DSP
dividen la memoria en dos bloques, X e Y. Cuando no se usan las instrucciones de DSP, la memoria es
tratada como un solo bloque de memoria X. Se puede tener una frecuencia mxima de trabajo de
aproximadamente 160MHz, dando un muestreo en el conversor AD de 500 Ksps, lo que lo hace muy til
para el procesamiento en tiempo real de seales de audio [2].

Figura 1. Distribucin de pines dsPIC30F4011
2.2. Microcontrolador PIC18F4550
Los PICs de la familia 18 tienen una arquitectura RISC avanzada Harvard: 16 bits con 8 bits de datos, hasta
64Kb de programa y frecuencia mxima de reloj de 40MHz. El PIC18F4550 dispone de buses diferentes
para el acceso a memoria de programa y memoria de datos (arquitectura Harvard). Esto permite acceder
simultneamente a la memoria de programa y a la memoria de datos, es decir, se puede ejecutar una
instruccin mientras se lee la siguiente instruccin. Por tanto la ejecucin completa de una instruccin se
hace en un ciclo de instruccin (4

) [3].
El microcontrolador PIC18F4550 tambin tiene una memoria de programa de 32768 bytes de memoria de
programa (0000H 7FFFH). Las instrucciones ocupan 2 bytes, por lo tanto, la memoria de programa puede
almacenar hasta 16384 instrucciones [4].

Figura 2. Distribucin de pines PIC18F4550
2.3. Memoria SRAM HM6225LP-85
Memoria esttica de acceso aleatorio (SRAM) es un tipo de memoria que es capaz de mantener los datos,
mientras est alimentada, sin necesidad de ser refrescada. Aunque siguen siendo voltiles. Una memoria
SRAM tiene tres estados distintos de operacin: standby, en el cual el circuito est en reposo, reading o
en fase de lectura, durante el cual los datos son ledos desde la memoria, y writing o en fase de escritura,
durante el cual se actualizan los datos almacenados en la memoria [5].
La HM6225LP-85 es una SRAM organizada en 32K palabras de 8 bits. Esta tiene una funcin de apagado
automtico, reduciendo el consumo de potencia por 99.9% cuando no se utiliza [6].

Figura 3. Distribucin de pines HM62256LP-85
2.4. Efectos de Audio Digital
2.4.1. Trmolo
El efecto de trmolo bsicamente consiste en una serie de subidas y bajadas en la amplitud de la seal,
las cuales se coordinan al tempo de la misma. La coordinacin se refiere a que en un comps exista un
nmero entero de subidas y bajadas [7].
Este efecto se logra multiplicando la seal de entrada por una onda peridica, por lo general una
sinusoidal. Esto se puede entender como una modulacin AM. En la figura 1 se puede apreciar un ejemplo
de este efecto, el primer grfico es la seal de entrada, la segunda es la onda moduladora y el tercero es
la multiplicacin.

Figura 4. Equivalencia efecto trmolo con modulacin AM
Se puede utilizar distintas formas de onda segn se desee cambios de amplitud ms o menos bruscos. Por
ejemplo si se utiliza una onda cuadrada los cambios sern muy bruscos. Con una onda triangular o
sinusoidal habr cambios ms suaves, lo que es siempre preferible.
Para la implementacin, la seal se va multiplicando por una onda peridica que va tomando valores
conforme avanza la seal. Esto se puede observar en el diagrama de bloques de la figura 2, donde LFO es
un oscilador de baja frecuencia. Esto produce aumentos y decrementos de volumen en la seal con la
misma frecuencia de la onda utilizada. Se traduce en un temblor de la seal.

Figura 5. Diagrama de bloques del trmolo simple

2.4.2. Distorsin
Este efecto colapsa el margen dinmico y aplana la seal a partir de ciertos niveles de volumen. El lmite
de volumen puede variar hasta el tamao mximo permitido dependiendo del sistema. Cuanto ms se
reduzca se causar un mayor impacto en la seal y habr ms distorsin, mientras lo contrario sucede
cuando se aumenta este lmite [7]. En la figura 3 se puede observar un tono distorsionado levemente y
otro con una distorsin ms dura.

Figura 6. Distintos tipos de distorsin
La distorsin ms sencilla de implementar es reducir el margen dinmico, para esto no se permite que la
seal supere cierto nivel. Cuando se supera el valor mximo, se hace que la seal tome ese valor mximo
y es precisamente este lmite lo que podemos controlar para variar la distorsin. Al reducir el margen
tambin se puede reducir el volumen por lo que generalmente se ampla el volumen una vez realizada la
distorsin, lo que se conoce como normalizador de seal. De esta manera el valor mximo del margen
dinmico pasar a ser el mximo establecido por el normalizador. Para esto se multiplica cada muestra
por el nuevo mximo del margen dinmico dividido para el lmite escogido para la distorsin
[]

= [] ( / )
Este proceso se resume en el diagrama de bloques de la figura 4.

Figura 7. Diagrama de bloques de la distorsin
2.4.3. Delays
Al aplicar un efecto de delay sucede que las muestras que van sonando se repiten al cambio de cierto
tiempo de retraso (delay). Con efectos de delay se puede conseguir reverberacin, provocar una
repeticin con desvanecimiento de la seal y otros efectos ms. El delay simple es la base de la mayora
de efectos temporales.
El odo humano empieza a captar ecos a partir de una separacin entre muestras repetidas a partir de
unos 50ms. Si el tiempo de retraso es inferior a este, el odo los integrar como una reverberacin. En los
delay se tiene la posibilidad de utilizar muestras retrasadas de la entrada o realimentar al sistema
utilizando muestras de salida, en este caso, las salidas sonarn indefinidamente con lo que el sistema
puede volverse inestable. Para controlar esto se debe tener una etapa de atenuacin en la realimentacin
a la que se llama depth [7].

Figura 8. Diagrama de bloques delay simple
La realimentacin ocasionar que cada muestra seguir sonando siempre pero con la atenuacin se
lograr que se repitan pero cada vez con un volumen menor haciendo que se vayan perdiendo para el
odo, lo que ocasionar un efecto de espacialidad dependiendo del tamao del retardo. Si no se atenuara
la realimentacin, las muestras se repetiran pero con el mismo volumen llegando a superponer a la seal
actual lo que creara un caos. Los diagramas de bloques para el delay simple y el retroalimentado se
pueden ver en las figuras 5 y 6 respectivamente.

Figura 9. Diagrama de bloques delay con feedback
2.4.4. Chorus
Produce un efecto similar al de un coro (chorus), consiste en que la seal sea sumada a ella misma, pero
esto no es simplemente aadir una seal encima de otra, ya que al ser la misma, solo se producira un
aumento de volumen. Para entender el efecto se puede tomar como ejemplo cuando dos o ms personas
tocan la guitarra al unsono. En este caso se produce un efecto de chorus debido a que todos tratarn de
tocar las notas en el mismo instante pero por la imprecisin humana no se logra. De este modo existir
un desfase entre las seales que adems ser aleatorio porque a veces uno de los guitarristas toque la
nota antes de tiempo y a veces las toque tarde [7].
El desfase se puede lograr con un delay de tiempo variable y que el intervalo de cambio sea pequeo. Esto
se consigue con un oscilador de baja frecuencia, para producir un leve cambio en el tono, que vaya
cambiando la cantidad de delay. El delay de un chorus vara en un intervalo de entre 20ms y 30ms. Por
tanto se debe distinguir entre una parte fija de 20ms y una parte variable, que sera los 10ms que faltan.
La velocidad con que vare el delay determina el cambio de tono de la seal [7]. En la figura 7 se presenta
un esquema del delay.

Figura 10. Variacin del tamao del delay del chorus
Normalmente el oscilador de baja frecuencia se sita en frecuencias menores a 3Hz. Dependiendo del
tipo de onda variar de una manera diferente la lnea de delay. Cuando el retraso va en aumento la seal
se expande y el tono se torna ms grave. Cuando el retraso decrece, sucede el efecto contrario, el tono
se vuelve ms agudo ya que la seal se comprime. Las ondas ms comunes que se suelen utilizar son la
sinusoidal, triangular o logartmica. En la figura 8 se presenta el diagrama de bloques del chorus.

Figura 11. Diagrama de bloques de chorus
2.5. Transformada rpida de Fourier FFT
La transformada rpida de Fourier, organiza en una matriz las muestras de entrada y realiza transformadas
ms pequeas en las filas y posteriormente en las columnas. Las muestras digitalizadas de la seal
analgica se pueden representar de la siguiente forma:
(0), (1), (2), (3), (4), (5), , ()
Donde N es el nmero mximo de muestras que se desean analizar.
Las muestras son organizadas en una matriz de L filas y M columnas. Las muestras quedan almacenadas
como en la siguiente matriz:
(, ) = [
(0) (4)
(1) (5)
(8) (12)
(9) (13)
(2) (6)
(3) (7)
(10) (14)
(11) (15)
]
Seguidamente se debe realizar la transformacin por filas, haciendo la transformada de M muestras. Esta
operacin se realiza en funcin de la siguiente ecuacin:
(, ) = [(, )

]
1
=0

0 1
0 1 1

= cos (
2

) sin(
2

)
La matriz (, ), es un arreglo de valores complejos correspondientes a las transformadas de M puntos
sobre cada una de las filas. Seguidamente la matriz (, ) se multiplica por los factores de fase

, esta
operacin se define en la siguiente ecuacin:
(, ) =

(, )
0 1
0 1 1

= cos (
2

) sin(
2

)
Por ltimo se realiza la transformada por columnas de L muestras. Esta operacin se resume en la
siguiente ecuacin:
(, ) = [(, )

]
1
=0

0 1
0 1

= cos (
2

) sin(
2

)
La matriz (, ) es la transformada final de las N muestras iniciales. Esta matriz contiene en cada uno de
sus trminos un nmero complejo que representa la magnitud y la fase de las componentes espectrales.
La matriz (, ) se debe leer por filas, como se aprecia en la siguiente matriz [8]:
(, ) =
[

(0) (1)
(4) (5)
(2) (3)
(6) (7)
(8) (9)
(12) (13)
(10) (11)
(14) (15)]


3. Simulacin en Matlab
Para probar los algoritmos de efectos primero se implementaron en Matlab, obtenindose los resultados
deseados y de esta manera entender mejor el cambio que genera cada efecto a la seal y poder
implementarlos correctamente en el dsPIC en tiempo real, ya que en Matlab se aplic el efecto a una
seal completa y no muestra a muestra cmo se debera de hacer en tiempo real. En el ANEXO 1 se
encuentran los cdigos de Matlab para los distintos efectos.

Figura 12. Grfica en el tiempo de la seal original
3.1. Simulacin Trmolo
Para simular el trmolo se realiz una multiplicacin en el tiempo de la seal original con una onda
triangular obtenindose el resultado mostrado en la figura 13, en la cual se observa que la seal oscila de
acuerdo a la onda triangular y tiene la apariencia de una modulacin AM.

Figura 13. Grfica en el tiempo del efecto trmolo
3.2. Simulacin Distorsin
Para dar este efecto, se multiplic la seal de entrada por una ganancia bastante alta y se cortaron los
picos superiores al mximo de la seal original y se obtuvo una seal en la que es evidente el efecto, tal y
como se muestra en la figura 14.

Figura 14. Grfica en el tiempo de la distorsin
3.3. Simulacin Delay
Para simular el delay se sumaron muestras pasadas de la seal a las muestras actuales y se obtuvo el
efecto de repeticin. En la figura 15 se puede observar el resultado de este efecto y la repeticin de la
muestra inicial aunque no es muy evidente pero al reproducir el audio se pudo constatar que el efecto
funciona.

3.4. Simulacin Chorus
En la simulacin del chorus se aplic una onda senoidal de frecuencia de 0.25Hz para el delay variable y
al igual que el delay no es evidente en la grfica en el tiempo pero se verific el efecto reproduciendo el
audio de salida.

Figura 15. Grfica en el tiempo de chorus
4. Diseo del Sistema de Distorsin
4.1. Plataforma Hardware
Para este sistema de distorsin se hizo uso de dos circuitos: uno que se encargar del procesamiento del
audio y otro que controla un GLCD en el cual se mostrar el efecto que se est utilizando y cul es el nivel
de distorsin, adems, tambin se mostrar la respuesta en frecuencia de la seal mediante el algoritmo
de FFT.
En la figura 12 se muestra el PCB del primer circuito, el cual se encargar de todo el procesamiento de la
seal. Este circuito consta de un dsPIC30F4011, con el que se obtendr las muestras de la seal de entrada
proveniente de la guitarra, se las procesar para darle la distorsin deseada y enviar la seal resultante
para su reproduccin. Tambin se dispone de una memoria SRAM HM6225LP-85 paralela, en la cual se
guardarn las muestras para poder realizar los efectos de retraso (delay y chorus). Se hace uso tambin
de dos conversores serial paralelo para la comunicacin con la memoria y de esta manera ahorrar
puertos en el dsPIC, ya que la memoria paralela necesita de demasiados puertos para su uso. Para el
control de estos se hace uso adems de una compuerta AND 7408, ya que con esto se consigue la
habilitacin y des habilitacin de la seal de reloj que controla el chip select.

Figura 16. PCB del circuito de efectos
Para la conversin Digital Analgica se utiliza un DAC serial MCP4921, que se comunica mediante SPI con
el dsPIC y luego de convertir las muestras las enviar a la otra placa donde se encuentra un filtro pasa bajo
analgico con frecuencia de corte en 10KHz, de manera que la curva se suavice y pueda ser enviada de
manera correcta al amplificador.
En la figura 13 se muestra el PCB del segundo circuito, el cual se encarga de recibir la seal de la guitarra,
pasarla por un preamplificador y enviarla a la placa del distorsionador; tambin recibe la seal ya
procesada, la pasa por un filtro paso bajo y la enva al amplificador. Adems controla un GLCD donde se
mostrar el efecto que se utiliza y la respuesta en frecuencia de la seal mediante un algoritmo de FFT.

Figura 17. PCB del circuito de interfaz
Este circuito consta de un PIC18F4540 que se encarga de realizar el algoritmo de FFT con la seal de
entrada de la guitarra y controlar el GLCD para mostrar el efecto que se est utilizando o la FFT
dependiendo de lo que se desee. Tambin cuenta con un amplificador operacional que se utiliza para el
preamplificador con el que se aumenta el volumen de la seal y se le da un offset para que la seal se
vuelva unipolar y se pueda procesar. El amplificador tambin se utiliza como filtro pasa bajo con
frecuencia de corte de 10KHz para suavizar la seal que llega del DAC.
En este circuito tambin se conectan 5 pulsante, de los cuales dos se encargan de cambiar entre el efecto
siguiente y el anterior, dos ms se encargan de cambiar el nivel del efecto que se est utilizando y el ltimo
que se utiliza para indicarle al PIC que cambi lo mostrado en el GLCD. Tambin lleva un LED para indicar
el encendido del sistema. El GLCD utilizado en este circuito es el del celular NOKIA 3310, el cual es un
GLCD de 48 x 84 pixeles y que cuenta con libreras para su fcil control.

4.2. Funcionamiento de Software
Software de dsPIC30F4011
De manera general lo que realiza este software es obtener las muestras del ADC, procesarlas de la manera
en que se haya escogido para darle el efecto deseado y posteriormente enviarlas al DAC para su posterior
reproduccin. Para obtener las muestras se hizo uso de la interrupcin del Timer1 para realizar un
muestreo a una frecuencia de 40KHz, suficiente para que el audio pueda ser reconstruido. Los efectos que
se implementaron fueron: distorsin, trmolo, delay y chorus.
Para el efecto de la distorsin le que se hace es restarle 512 al valor del ADC para eliminar la componente
de corriente continua y luego se cortan los picos de la seal que sobrepasen un lmite determinado, para
esto se utiliza un condicional para que cuando la seal sobrepase el valor lmite, esta tome el valor del
lmite y en caso contrario la seal no cambiar. Luego se aplica la teora y se multiplica la seal limitada
por el valor mximo de salida divido para el lmite de la distorsin. Finalmente se vuelve a sumar los 512
para poder enviar el dato al DAC
Para el efecto del trmolo tambin se elimina la componente corriente continua y se multiplica por el
valor que tendra en ese momento una onda triangular de frecuencia baja, la cual se va generando a la
par con la lectura de los datos. Y al igual que en la distorsin al final se vuelve a sumar los 512 y se enva
al DAC.
Para dar el efecto de delay primero se direcciona la memoria a la posicin en la que se guardarn los
datos para el delay, luego se lee de la memoria el dato de la posicin con el retraso respectivo,
seguidamente al valor actual se le suma el dato que se ley de la memoria multiplicada por una constante
menor a uno para darle el efecto de desvanecimiento en el tiempo, este valor se guarda en la posicin
que se acaba de leer y por ltimo se enva el dato al DAC.
Para el efecto de chorus se realizan los mismos pasos que en el delay pero se direcciona la memoria a la
posicin determinada para el chorus y para poder aplicar el retraso tpico del chorus se coloca un retraso
fijo de 20ms y se va cambiando una variable que simula la onda peridica de baja frecuencia para cambiar
el retraso. Tambin a diferencia del delay, la muestra retrasada se suma sin reduccin, si no que la
reduccin se realiza toda la suma para evitar que se amplifique mucho y se distorsione.
A travs de los pulsantes se puede cambiar el efecto que se va a utilizar y los parmetros de los efectos.
Los dos primeros pulsantes sirven para moverse entre efectos, para esto se aumenta o disminuye una
variable de la cual depende el efecto que se utilizar. El valor de esta variable vara entre 0 y 7 teniendo
los efectos en el siguiente orden: bypass, distorsin, trmolo, delay, chorus, distorsin y trmolo,
distorsin y delay; y, chorus y delay. Los otros dos pulsantes sirven para aumentar o disminuir los
parmetros de los efectos, dependiendo del efecto que est activo se cambiar un parmetro u otro.
Durante la distorsin se puede variar el valor del lmite del corte; en el delay, el tiempo de retraso y,
durante el trmolo, la frecuencia de la onda triangular. En el chorus no se puede cambiar ningn
parmetro ya que este efecto es predeterminado y en el bypass tampoco ya que este es el sonido sin
efecto alguno.
Software de PIC18F4550
El software de este PIC est diseado para controlar el GLCD y realizar el algoritmo de la FFT para obtener
la respuesta en frecuencia de la seal. El algoritmo de FFT que se utiliz es el explicado en el marco terico
y se realiza con 84 muestras, esto debido al tamao del GLCD y la capacidad de memoria del PIC. El PIC
almacena primero las 84 muestras en una matriz de 12 x 7 y una vez obtenidas todas las muestras procede
a realizar el algoritmo. Las muestras se obtienen a una frecuencia de 1291Hz (frecuencia utilizada en la
aplicacin del algoritmo de acuerdo a autor de la referencia [8]).
El GLCD en un principio se utiliza para desplegar el efecto que se est utilizando y el nivel de los parmetros
de dicho efecto, esto se logra mediante pulsantes, los cuales son los mismos del dsPIC y tienen igual
funcionamiento. Es decir los controles para cambiar de efecto sirven para cambiar el efecto que se
muestra en el GLCD y los pulsantes para variar parmetros varan el nivel que se muestra. El nivel del
efecto se muestra a manera de porcentaje, encontrndose normalmente en un 50% y pudiendo variar
entre 1 y 100%.
Adems de esto tambin cuenta con un control ms, el cual cambia la pantalla, es decir, intercambia entre
mostrar el efecto y el nivel y, mostrar la respuesta en frecuencia de la seal mediante los valores obtenidos
del algoritmo de la FFT.
5. Conclusiones y Recomendaciones
Se logr muestrear y procesar digitalmente una seal de audio proveniente de una guitarra mediante un
dsPIC y modificar el sonido aplicando efectos digitales tales como distorsin, trmolo, delay y chorus;
obtenindose resultados satisfactorios. Tambin logr realizar una comunicacin eficiente con una
memoria SRAM y con esto tambin la aplicacin de los efectos de retardo.
Los dsPICs son herramientas muy tiles para procesamiento de seales a tiempo real, debido a su gran
velocidad de trabajo, adems de que su capacidad de memoria es mayor a la de los PICS 16 y 18. Aunque
una desventaja es la complicacin en el manejo de interrupciones y en las configuraciones. En particular
una desventaja del dsPIC30F4011 es la distribucin de pines.
La memoria SRAM paralela, aunque es til por su velocidad, tambin tiene sus desventajas, como la
necesidad de varios pines para su funcionamiento. Por sta razn es de mucha ayuda el uso de los
conversores serie paralelo.
6. Referencias
[1] Programming dsPIC Microcontrollers in C, MikroElektornika, Belgrano, Serbia.
[2] dsPIC30F4011/4012 Data Sheet, Microchip, Chandler, AZ.
[3] Han-Way Huang, PIC Microcontroller: An Introduction to Software and Hardware Interfacing, Delmar
Learning, Minnesota, 2005.
[4] PIC18F2455/2550/4455/4550 Data Sheet, Microchip, Chandler, AZ.
[5] SRAM [online], disponible en: http://es.wikipedia.org/wiki/SRAM.
[6] Jameco Part Number 42876HITACHI, Jameco Electronics, Roseville, CA.
[7] C.Q. Cataln, Implementacin de algoritmos de efectos de audio en un procesador DSP de TI, Trabajo
Final de Carrea, Ingeniera Tcnica de Telecomunicacin, Sistema de Telecomunicacin, Universidad
Politcnica de Catalunya, 2008.
[8] J.R. Clavijo Mendoza, Diseo y simulacin de sistemas microcontrolados en lenguaje C, Primera Edicin,
Colombia, 2011.





































ANEXO 1
Cdigos de Matlab para los efectos

Distorsin
[x,Fs]=wavread('Lamenor.wav');
n=length(x);
lim=max(x);
for i=1:n-1
x(i)=x(i)*11;
if (abs(x(i))>lim)
x(i)=lim*x(i)/abs(x(i));
end
end
wavplay(x,Fs);

Trmolo
[x,Fs]=wavread('Lamenor.wav');
f=2;
n=length(x);
t=(1/Fs)*[0:n-1];
y=sawtooth(2*pi*f*t);
y=y';
x=x.*y;
wavplay(x,Fs);

Delay
[x,Fs]=wavread('Lamenor.wav');
nv=2;
n=length(x);
t=10;
a=t*Fs/1000;
for i=1:a
y(i)=x(i);
end
for i=a+1:n
y(i)=x(i)+0.7*y(i-a);
end
for i=n+1:n+a
y(i)=0.7*y(i-a);
end;
wavplay(y,Fs);

Chorus
[x,Fs]=wavread('Lamenor.wav');
n=length(x);
t=(1/Fs)*[0:n+1322];
f=0.25;
a=(30/1000)*Fs;
lfo=-cos(2*pi*f*t);
for i=1:a
y(i)=x(i);
end
for i=a+1:n-1
y(i)=x(i)+0.7*x(i-882-floor(220.5+lfo(1,i)*220.5));
%y(i)=x(i)+0.7*x(i-a);
end
for i=n:n+882
y(i)=0.7*x(i-882-floor(220.5+lfo(1,i)*220.5));
end
wavplay(y,Fs);

































ANEXO 2
Software dsPIC30F4011

sfr sbit Dac_Chip_Select at LATF0_bit;
sfr sbit Dac_Chip_Select_Direction at TRISF0_bit;
sfr sbit Mem_Chip_Select at LATF1_bit;
sfr sbit Mem_Chip_Select_Direction at TRISF1_bit;
sfr sbit Not_Wr_Select at LATF5_bit;
sfr sbit Not_Wr_Select_Direction at TRISF5_bit;
sfr sbit SerialPar_Chip_Select at LATF4_bit;
sfr sbit SerialPar_Chip_Select_Direction at TRISF4_bit;

signed long valor_ADC;
signed long valor_ADC_Buffer;
unsigned long Tamano_Buffer_Delay=3700;
unsigned long Tamano_Buffer_Chorus=400;
unsigned int Retraso_Chorus;
signed int Limite_Distorsion=28;
float triangular=-205;
float triangular_freq=0.1666667;
unsigned long direccion_Delay=0;
unsigned long direccion_Chorus=10000;
signed short modo;
unsigned long i;
unsigned short seq_mezcla[4];
bit aux, aux1, aux2, mezcla;
bit bandera_ADC;

void configuraciones();
void Cambio_Parametro1();
void Cambio_Parametro2();
void DAC_Output();
void Distorsion();
void Tremolo();
void Delay();
void Chorus();
void Inicializacion_Buffer();
void Direccionamiento_Mem_Delay();
void Direccionamiento_Mem_Chorus();
void Escribir_Mem();
void Leer_Mem();

void main() {
configuraciones();
Inicializacion_Buffer();
while(1){
if(bandera_ADC){
if(!RC13_bit){
delay_ms(300);
modo=modo+1;
if(modo>7){
modo=0;
}
}
if(!RC14_bit){
delay_ms(300);
modo=modo-1;
if(modo<0){
modo=7;
}
}
valor_ADC=ADC1_Get_Sample(0);
switch(modo){
case 0:
break;
case 1:
valor_ADC=valor_ADC-512;
Distorsion();
valor_ADC=valor_ADC+512;
break;
case 2:
valor_ADC=valor_ADC-512;
Tremolo();
valor_ADC=valor_ADC+512;
break;
case 3:
Delay();
break;
case 4:
Chorus();
break;
case 5:
valor_ADC=valor_ADC-512;
Distorsion();
Tremolo();
valor_ADC=valor_ADC+512;
break;
case 6:
valor_ADC=valor_ADC-512;
Distorsion();
valor_ADC=valor_ADC+512;
Delay();
break;
case 7:
Chorus();
Delay();
break;
}
DAC_Output();
bandera_ADC=0;
}
if(!RB1_bit){
delay_ms(300);
Cambio_Parametro1();
}
if(!RB2_bit){
delay_ms(300);
Cambio_Parametro2();
}
}
}

void configuraciones(){
T1CON=0b1000000000000000;
TMR1=0X0000;
PR1=500;
ADPCFG=0xFFFE;
TRISB=0x0007;
TRISC=0xFFFF;
TRISD=0x0000;
TRISE=0x0000;
TRISF=0x0004;
T1IF_bit=0;
T1IE_bit=1;
ADC1_Init();
ADCS_0_bit=1;
ADCS_1_bit=1;
ADCS_2_bit=0;
ADCS_3_bit=0;
ADCS_4_bit=0;
ADCS_5_bit=0;
SPI1_Init_Advanced(_SPI_MASTER, _SPI_8_BIT, _SPI_PRESCALE_SEC_1, _SPI_PRESCALE_PRI_1,_SPI_SS_DISABLE,
_SPI_DATA_SAMPLE_MIDDLE, _SPI_CLK_IDLE_HIGH, _SPI_ACTIVE_2_IDLE);
Dac_Chip_Select_Direction=0;
Dac_Chip_Select=1;
Mem_Chip_Select_Direction=0;
Mem_Chip_Select=1;
Not_Wr_Select_Direction=0;
Not_Wr_Select=0;
SerialPar_Chip_Select=0;
SerialPar_Chip_Select_Direction=0;
modo=0;
aux=1;
aux1=1;
aux2=0,
bandera_ADC=0;
}

void InterruptTMR1() org 0x01A {
T1IF_bit=0;
bandera_ADC=1;
RB5_bit=~RB5_bit;
}

void DAC_Output(){
DAC_Chip_Select=0;
SPI1_WRITE(0x30|(valor_ADC>>6));
SPI1_WRITE(valor_ADC<<2);
DAC_Chip_Select=1;
}

void Inicializacion_Buffer(){
valor_ADC=512;
for(i=0; i<25000; i++){
Escribir_Mem();
SerialPar_Chip_Select=1;
SPI1_WRITE(direccion_Delay>>8);
SPI1_WRITE(direccion_Delay);
SerialPar_Chip_Select=0;
direccion_Delay++;
}
direccion_delay=0;
}

void Cambio_Parametro1(){
switch(modo){
case 1:
Limite_Distorsion=Limite_Distorsion-2;
if(Limite_Distorsion<14){
Limite_Distorsion=14;
}
break;
case 2:
triangular_freq=1.25*triangular_freq;
if(triangular_freq>0.635783004){
triangular_freq=0.635783004;
}
break;
case 3:
Tamano_Buffer_Delay=Tamano_Buffer_Delay-300;
if(Tamano_Buffer_Delay<1300){
Tamano_Buffer_Delay=1300;
}
break;
default:
break;
}
}

void Cambio_Parametro2(){
switch(modo){
case 1:
Limite_Distorsion=Limite_Distorsion+2;
if(Limite_Distorsion>40){
Limite_Distorsion=40;
}
case 2:
triangular_freq=triangular_freq/1.25;
if(triangular_freq<0.054613344){
triangular_freq=0.054613344;
}
break;
case 3:
Tamano_Buffer_Delay=Tamano_Buffer_Delay+300;
if(Tamano_Buffer_Delay>7300){
Tamano_Buffer_Delay=7300;
}
break;
default:
break;
}
}

void Distorsion(){
if(valor_ADC<=-Limite_Distorsion){
valor_ADC=-Limite_Distorsion;
}
if(valor_ADC>=Limite_Distorsion){
valor_ADC=Limite_Distorsion;
}
valor_ADC=valor_ADC*41/Limite_Distorsion;

void Tremolo(){
valor_ADC=valor_ADC*triangular/205;
if(triangular<205 && aux){
triangular=triangular+triangular_freq;
}
else{
aux=0;
triangular=triangular-triangular_freq;
if(triangular<=-205){
aux=1;
triangular=-205;
}
}
}

void Delay(){
Direccionamiento_Mem_Delay();
Leer_Mem();
valor_ADC=0.625*(valor_ADC+(0.55*valor_ADC_Buffer));
Escribir_Mem();
}

void Chorus(){
Direccionamiento_Mem_Chorus();
direccion_Chorus=direccion_Chorus+(2*Tamano_Buffer_Chorus/3)+Retraso_Chorus;
if(direccion_Chorus>22000+Tamano_Buffer_Chorus){
direccion_Chorus=direccion_Chorus-(Tamano_Buffer_Chorus/3);
aux2=1;
}
Leer_Mem();
if(aux2){
direccion_Chorus=direccion_Chorus+(Tamano_Buffer_Chorus/3);
aux2=0;
}
direccion_Chorus=direccion_Chorus-Retraso_Chorus-(2*Tamano_Buffer_Chorus/3);
Escribir_Mem();
valor_ADC=0.40*(valor_ADC+valor_ADC_Buffer);
if((Retraso_Chorus<=(Tamano_Buffer_Chorus/3)) && (aux1==1)){
Retraso_Chorus++;
}
else{
aux1=0;
Retraso_Chorus--;
if(Retraso_Chorus<=0){
Retraso_Chorus=0;
aux1=1;
}
}
}

void Direccionamiento_Mem_Delay(){
SerialPar_Chip_Select=1;
SPI1_WRITE(direccion_Delay>>8);
SPI1_WRITE(direccion_Delay);
if(direccion_Delay>=Tamano_Buffer_Delay){
direccion_Delay=0;
}
SerialPar_Chip_Select=0;
direccion_Delay++;
}

void Direccionamiento_Mem_Chorus(){
SerialPar_Chip_Select=1;
SPI1_WRITE(direccion_Chorus>>8);
SPI1_WRITE(direccion_Chorus);
if(direccion_Chorus==(21000+Tamano_Buffer_Chorus)){
direccion_Chorus=20999;
}
SerialPar_Chip_Select=0;
direccion_Chorus++;
}

void Escribir_Mem(){
PORTD=valor_ADC>>8;
PORTE=valor_ADC>>2;
Mem_Chip_Select=0;
asm nop;
asm nop;
Mem_Chip_Select=1;
}

void Leer_Mem(){
TRISD=0xFFFF;
TRISE=0xFFFF;
Not_Wr_Select=1;
Mem_Chip_Select=0;
asm nop;
asm nop;
valor_ADC_Buffer=PORTD;
valor_ADC_Buffer=(valor_ADC_Buffer<<6)|(PORTE&0x003F);
valor_ADC_Buffer=valor_ADC_Buffer<<2;
TRISD=0x0000;
TRISE=0x0000;
Mem_Chip_Select=1;
Not_Wr_Select=0;
}




























ANEXO 3
Software PIC18F4550

#define M 12
#define L 7
#define N L*M
#define PI 3.141592654

unsigned char const principal_dsp_bmp[504] = {
255, 255, 255, 255, 255, 255, 7, 7, 7, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 199, 135, 15, 31, 63,
127, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 127, 63, 0, 0, 128, 255, 255, 255, 255, 255, 255, 255, 127, 63, 31, 31,
31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 63, 127, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 248, 252, 254, 255,
255, 255, 255, 255, 255, 255, 255, 255, 224, 192, 128, 143, 143, 143, 143, 143, 143, 143, 143, 143, 143, 14, 30, 62,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 243, 227, 195, 199,
199, 199, 199, 199, 199, 199, 199, 199, 199, 192, 224, 240, 255, 255, 255, 255, 255, 255, 255, 255, 3, 3, 3, 227,
227, 227, 227, 227, 227, 227, 227, 227, 227, 3, 7, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 227, 227, 227, 227, 227, 227, 227, 227, 227, 227, 224, 240, 248,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 252, 252, 252, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
};

unsigned char const efecto_bmp[504] = {
3, 3, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 3, 3, 3, 3, 3, 3, 3, 3,
227, 243, 243, 243, 243, 227, 3, 3, 3, 3, 3, 3, 3, 227, 243, 243, 243, 243, 227, 3, 3, 3, 3, 3,
3, 3, 227, 243, 243, 243, 243, 227, 3, 3, 3, 3, 3, 3, 3, 3, 3, 255, 255, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 3, 3, 48, 48, 63, 255, 240, 0, 0, 0, 0, 0, 0, 0,
0, 240, 255, 63, 48, 48, 48, 48, 48, 48, 48, 48, 49, 51, 51, 51, 51, 49, 48, 48, 48, 48, 48, 48,
48, 49, 51, 51, 51, 51, 49, 48, 48, 48, 48, 48, 48, 48, 49, 51, 51, 51, 51, 49, 48, 48, 48, 48,
48, 48, 48, 48, 48, 63, 255, 240, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 240, 255, 63, 48, 48,
0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 240, 240, 96, 96, 96, 96, 240,
240, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 255, 255, 240, 240, 96, 96, 96, 96, 96, 96, 96, 240, 240, 255, 255, 0, 0, 0,
0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0, 0, 0, 0, 0,
0, 255, 255, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192, 192,
192, 192, 192, 192, 192, 192, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 0, 0, 0
};

unsigned char const PRINCIPAL_MICROS_bmp[504] = {
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 7, 7, 207, 159,
63, 127, 63, 159, 207, 7, 7, 255, 255, 255, 255, 7, 7, 255, 255, 255, 255, 7, 7, 231, 231, 231, 231, 199,
255, 255, 255, 255, 7, 7, 103, 103, 103, 103, 7, 7, 255, 255, 255, 255, 7, 7, 231, 231, 231, 231, 231, 7,
7, 255, 255, 255, 255, 7, 7, 103, 103, 103, 103, 103, 71, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 224, 224, 255, 255, 255, 254, 255, 255, 255, 224, 224, 255, 255, 255, 255, 224,
224, 255, 255, 255, 255, 224, 224, 231, 231, 231, 231, 227, 255, 255, 255, 255, 224, 224, 254, 254, 252, 248, 242, 230,
255, 255, 255, 255, 224, 224, 231, 231, 231, 231, 231, 224, 224, 255, 255, 255, 255, 226, 230, 230, 230, 230, 230, 224,
224, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 243, 243, 243, 243, 243, 243,
243, 243, 243, 243, 243, 243, 243, 243, 243, 3, 3, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 1, 1, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 248, 248, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 248, 248, 249, 249, 249, 249,
249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 249, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255
};

unsigned short ff, cc, cont, modo,valor_delay,valor_overd,valor_trem;
char valor_char[8];
bit cambio_display;

void configuraciones();
void mostrar_FFT ();
void graficar_efecto();
void tipo_efecto();
typedef struct
{
float R, I;
}Complejo;
unsigned short i, OK=0;
unsigned short Fi=0, Co=0;
Complejo X[L][M];
Complejo Y[L][M];

Complejo Producto( Complejo A, Complejo B )
{
Complejo Res;
Res.R = A.R*B.R - A.I*B.I;
Res.I = A.R*B.I + A.I*B.R;
return Res;
}

Complejo Adicion( Complejo A, Complejo B )
{
Complejo Res;
Res.R = A.R + B.R;
Res.I = A.I + B.I;
return Res;
}

float Magnitud( Complejo A )
{
return sqrt( A.R*A.R + A.I*A.I );
}

void FFT( void )
{
unsigned short l,q,m,p;
Complejo WW;
for( l=0; l<L; l++ )
{
for( q=0; q<M; q++ )
{
Y[l][q].R = 0.0;
Y[l][q].I = 0.0;
for( m=0; m<M; m++ )
{
WW.R = cos( 2*PI*m*q / M );
WW.I = -sin( 2*PI*m*q / M );
WW = Producto( X[l][m], WW );
Y[l][q] = Adicion( Y[l][q], WW );
}
}
}
for( l=0; l<L; l++ )
{
for( q=0; q<M; q++ )
{
WW.R = cos( 2*PI*l*q / N );
WW.I = -sin( 2*PI*l*q / N );
X[l][q] = Producto( Y[l][q], WW );
}
}
for( p=0; p<L; p++ )
{
for( q=0; q<M; q++ )
{
Y[p][q].R=0.0;
Y[p][q].I=0.0;
for( l=0; l<L; l++ )
{
WW.R = cos( 2*PI*l*p / L );
WW.I = -sin( 2*PI*l*p / L );
WW = Producto( X[l][q], WW );
Y[p][q] = Adicion( Y[p][q], WW );
}
}
}
for( l=0; l<L; l++ )
for( m=0; m<M; m++ )
{
X[l][m].R = Magnitud( Y[l][m] );
X[l][m].I = 0.0;
}
}

void interrupt ( void )
{
if( INTCON.F2 )
{
TMR0L=135;
if( OK )
{
X[Fi][Co].R = ((float)ADC_Read(0)-127.0);
X[Fi][Co].I = 0.0;
Fi++;
if( Fi==L )
{
Fi = 0;
Co++;
if( Co==M )
{
Co=0;
OK=0;
}
}
}
INTCON.F2=0;
}
if(INT0IF_bit){
modo++;
if(modo>7) modo=0;
delay_ms(300);
INT0IF_bit=0;
}
if(INT1IF_bit){
modo--;
if(modo>8) modo=7;
delay_ms(300);
INT1IF_bit=0;
}
if(INT2IF_bit){
if(modo==1){
valor_overd=valor_overd+7;
if(valor_overd>92) valor_overd = 92 ;
}
if(modo==2){
valor_trem=valor_trem+8;
if(valor_trem>98) valor_trem = 98 ;
}
if(modo==3){
valor_delay=valor_delay+5;
if(valor_delay>95) valor_delay = 95 ;
}
delay_ms(300);
INT2IF_bit=0;
}
if(~RB4_bit){
if(modo==1){
valor_overd=valor_overd-7;
if(valor_overd>100) valor_overd = 1 ;
}
if(modo==2){
valor_trem=valor_trem-8;
if(valor_trem<10) valor_trem = 10 ;
}
if(modo==3){
valor_delay=valor_delay-5;
if(valor_delay<5) valor_delay = 5 ;
}
delay_ms(300);
RBIF_bit=0;
}
if(~RB5_bit){
cambio_display=~cambio_display;
RBIF_bit=0;
delay_ms(300);
}
RBIF_bit=0;
}

void mostrar_FFT(){
posicion=0 ;
X[0][0].R = 0.0;
cont = 0;
RC2_bit=0;
for( cc=0; cc<M; cc++)
{
for( ff=0; ff<L; ff++ )
{
nokia_plot(posicion,X[ff][cc].R/30);
posicion++;
nokia_plot(posicion,X[ff][cc].R/30);
posicion++;
if( posicion==N )
{
cc = M;
ff = L;
}
}
}
RC2_bit=1;
}

void graficar_efecto(){
RC2_bit=0;
cc=0;
ff=0;
posicion=0 ;
while(cc<=5){
for(ff=0;ff<84;ff++){
nokia_gotoxy(ff, cc);
nokia_write_data(efecto_bmp[posicion]);
posicion++;
}
cc++;
}
RC2_bit=1;
}

void tipo_efecto(){
switch(modo){
case 0:
graficar_efecto();
rc2_BIT=0;
nokia_gotoxy(22,2);
printf("BYPASS");
nokia_gotoxy(33,4);
printf("--");
nokia_gotoxy(45,4);
printf("-");
RC2_bit=1;
break;
case 1:
graficar_efecto();
rc2_BIT=0;
nokia_gotoxy(17,2);
printf("OVERDRIV");
ShortToStr(valor_overd, valor_char);
nokia_gotoxy(20,4);
printf(valor_char);
nokia_gotoxy(45,4);
printf("%");
RC2_bit=1;
break;
case 2:
graficar_efecto();
rc2_BIT=0;
nokia_gotoxy(21,2);
printf("TREMOLO");
ShortToStr(valor_trem, valor_char);
nokia_gotoxy(20,4);
printf(valor_char);
nokia_gotoxy(45,4);
printf("%");
RC2_bit=1;
break;
case 3:
graficar_efecto();
rc2_BIT=0;
nokia_gotoxy(27,2);
printf("DELAY");
ShortToStr(valor_delay, valor_char);
nokia_gotoxy(20,4);
printf(valor_char);
nokia_gotoxy(45,4);
printf("%");
RC2_bit=1;
break;
case 4:
graficar_efecto();
rc2_BIT=0;
nokia_gotoxy(24,2);
printf("CHORUS");
nokia_gotoxy(33,4);
printf("--");
nokia_gotoxy(45,4);
printf("-");
RC2_bit=1;
break;
case 5:
graficar_efecto();
rc2_BIT=0;
nokia_gotoxy(17,2);
printf("OVERDRIV");
nokia_gotoxy(21,4);
printf("TREMOLO");
RC2_bit=1;
break;
case 6:
graficar_efecto();
rc2_BIT=0;
nokia_gotoxy(17,2);
printf("OVERDRIV");
nokia_gotoxy(27,4);
printf("DELAY");
RC2_bit=1;
break;
case 7:
graficar_efecto();
rc2_BIT=0;
nokia_gotoxy(24,2);
printf("CHORUS");
nokia_gotoxy(27,4);
printf("DELAY");
RC2_bit=1;
break;
}
}

void configuraciones(){
ADCON1=0b00001110;
TRISB=0x37;
NOT_RBPU_bit=1;
TRISD = 0x00;
TRISC = 0x00;
TRISA = 0XFF;
PORTC=0x00;
PORTD = 0x00;
PORTB = 0x00;
INTCON = 0b11100000;
T0CON = 0b11000101;
RBIF_bit=0;
INT0IF_bit=0;
INT1IF_bit=0;
INT2IF_bit=0;
INT0IE_bit=1;
INT1IE_bit=1;
INT2IE_bit=1;
RBIE_bit=1;
posicion=0;
ff=0;
cc=0;
modo=0;
valor_delay=55;
valor_overd=50;
valor_trem=50;
cambio_display=0;
nokia_init();
RC2_bit=0;
while(cc<=5){
for(ff=0;ff<84;ff++){
nokia_gotoxy(ff, cc);
nokia_write_data( principal_micros_bmp[posicion]);
posicion++;
}
cc++;
}
posicion=0;
ff=0;
cc=0;
delay_ms(2000);
while(cc<=5){
for(ff=0;ff<84;ff++){
nokia_gotoxy(ff, cc);
nokia_write_data( principal_dsp_bmp[posicion]);
posicion++;
}
cc++;
}
delay_ms(3000);
RC2_bit=1;
}

void main( void )
{
configuraciones();

while(1)
{
if(cambio_display){
OK = 1;
while( OK );
FFT();
RC2_bit=0;
nokia_clear_screen();
nokia_gotoxy(30,0);
printf("FFT");
nokia_gotoxy(10,5);
printf("frecuencia");
RC2_bit=1;
mostrar_FFT ();
}
else{
tipo_efecto();
}
}
}

Você também pode gostar