Generador de funciones Series de Fourier
haciendo uso de las plataformas Arduino,
PIC 18f4550 y Raspberry PI 3
Est. Catacora Riveros Raul Alberto CI. 1003067
Est. Gutierrez Chura Robert Amilcar CI. 6043307
Est. Justiniano Palomeque Lidio Hensy CI. 8460284
Ing. German
Microprocesadores II
Mayo, 09 de 2018
1. Objetivos
1.1 Objetivo general
El objetivo de este laboratorio es poder
comparar las frecuencias de salida de tres
plataformas de desarrollo diferentes.
1.2 Objetivos específicos
 Realizar una tabla de comparación
entre Arduino, Pic y Rapberry pi3.
 Comparar los resultados en graficos y
frecuencias de las tres plataformas.
 Determinar los coeficientes de
Fourier de las funcion a generar
2. Marco teórico
2.1 Series de Fourier
Una serie de Fourier es una serie infinita que
converge puntualmente a una función
periódica y continua a trozos (o por partes).
Las series de Fourier constituyen la
herramienta matemática básica del análisis
de Fourier empleado para analizar funciones
periódicas a través de la descomposición de
dicha función en una suma infinita de
Jesús Pereira Muñoz
funciones sinusoidales mucho más simples
(como combinación de senos y cosenos con
frecuencias enteras). El nombre se debe al
matemático francés Jean-Baptiste Joseph
Fourier, que desarrolló la teoría cuando
estudiaba la ecuación del calor. Fue el
primero que estudió tales series
sistemáticamente, y publicó sus resultados
iniciales en 1807 y 1811. Esta área de
investigación se llama algunas veces análisis
armónico.
Es una aplicación usada en muchas ramas de
la ingeniería, además de ser una herramienta
sumamente útil en la teoría matemática
abstracta. Áreas de aplicación incluyen
análisis vibratorio, acústica, óptica,
procesamiento de imágenes y señales, y
compresión de datos. En ingeniería, para el
caso de los sistemas de telecomunicaciones, y
a través del uso de los componentes
espectrales de frecuencia de una señal dada,
se puede optimizar el diseño de un sistema
para la señal portadora del mismo. Refiérase
al uso de un analizador de espectros.
Para poder calcular los coeficientes a0, an y
bn usamos las siguientes fórmulas para las
funciones.
Dependiendo del valor de n podemos obtener
varios armónicos los cuales se asemejen a la
señal que queramos sacar siempre y cuando
esta señal sea periódica.
Gráfico 1.señal cuadrada con 1armonico,
armónicos, tres armónicos y a cuatro armónicos
2.2 Escalera r2r
En Una red R-2R o también llamada escalera
de resistencias es un circuito electrónico
formado por resistencias alternando dos
valores posibles, donde un valor debe ser el
doble del otro. Varias configuraciones son
posibles.
Una red R-2R permite una forma simple y
económica de implementar un convertidor
digital-analógico (DAC), enlazando grupos de
resistencias de precisión alternando los dos
valores posibles en una escalera.scalera r2r
Gráfico 2. escalera r2r
2.3 Plataformas de programación
Las trepaltaformas de programación en las
cuales trabajeremos serán::
 Arduino
 Pic
 Raspberry pi 3
2.3.1 Arduino
Alimentación
El Arduino Mega puede ser alimentado vía la
conexión USB o con una fuente de
alimentación externa. El origen de la
alimentación se selecciona automáticamente.
La placa puede trabajar con una alimentación
externa de entre 6 a 20 voltios. Si el voltaje
dos suministrado es inferior a 7V el pin de 5V
puede proporcionar menos de 5 Voltios y la
placa puede volverse inestable, si se usan mas
de 12V los reguladores de voltaje se pueden
sobrecalentar y dañar la placa. El rango
recomendado es de 7 a 12 voltios.
Memoria
El ATmega1280 tiene 128KB de memoria flash
para almacenar código (4KB son usados para
el arranque del sistema(bootloader).El
ATmega1280 tiene 8 KB de memoria SRAM .
El ATmega1280 tiene 4KB de EEPROM , que
puede a la cual se puede acceder para leer o
escribir con la [Reference/EEPROM |librería
EEPROM]].
Programación
El ATmega1280 en el Arduino Mega viene
precargado con un gestor de arranque
(bootloader) que permite cargar nuevo
código sin necesidad de un programador por
hardware externo. Se comunica utilizando el
protocolo STK500 original(archivo de
cabecera C).
También te puedes saltar el gestor de
arranque y programar directamente el
microcontrolador a través del puerto ISCP (In
Circuit Serial Programming);.
Características físicas
La longitud y amplitud máxima de la placa
Duemilanove es de 4 y 2.1 pulgadas
respectivamente, con el conector USB y la
conexión de alimentación sobresaliendo de
estas dimensiones. Tres agujeros para fijación
con tornillos permiten colocar la placa en
superficies y cajas. Ten en cuenta que la
distancia entre los pines digitales 7 y 8 es 160
mil (0,16"), no es múltiple de la separación de
100 mil entre los otros pines.
Frecuencia de trabajo del pic 18f4550
La frecuencia de trabajo vari según el tipo de
cristal que le coloquemos pero la máxima
frecuencia a la que puede trabajar es de
48MHz.
Gráfico 3. Arduino Mega
2.3.2 Pic 18F4550
Con el propósito de sincronizar el
funcionamiento de los puertos de E/S con la
organización interna del microcontrolador de
8 bits, ellos se agrupan, de manera similar a
los registros, en cinco puertos denotados con
A, B, C, D y E. Todos ellos tienen las siguientes
características en común:
Por las razones prácticas, muchos pines de E/S
son multifuncionales. Si un pin re aliza una de
estas funciones, puede ser utilizado como pin
de E/S de propósito general.
Cada puerto tiene su propio registro de
control de flujo, o sea el registro TRIS
correspondiente: TRISA, TRISB, TRISC etc. lo
que determina el comportamiento de bits del
puerto, pero no determina su contenido.
Al poner a cero un bit del registro TRIS (pin=0),
el pin correspondiente del puerto se
configurará como una salida. De manera
similar, al poner a uno un bit del registro TRIS
(bit=1), el pin correspondiente del puerto se
configurará como una entrada. Esta regla es
fácil de recordar: 0 = Entrada 1 = Salida.
Alimentación
El voltaje máximo con el cual puede trabaj el
pic es 5.5v y el voltaje minimo es de 4.2v
Memoria
El tamaño de memoria de programa es de
32KB y el tamaño de la memoria RAM es de
2048b
Programación
El pic tiene dos forma de cargar el programa
mediante bootloader o pickit, lo mas
ecomendable en todos los casos es usar pickit
debido que al momento de usar bootloader
la memoria rom se satura.
Frecuencia de trabajo del arduino MEGA
La frecuencia de trabajo del arduino mega es
de 13.56 MHz
Gráfico 4. pic 18f4550
2.3.3 Raspberry pi 3
GPIO (General Purpose Input/Output) es,
como su propio nombre indica, un sistema de
E/S (Entrada/Salida) de propósito general, es
decir, una serie de conexiones que se pueden
usar como entradas o salidas para usos
múltiples. Estos pines están incluidos en
todos los modelos de Raspberry Pi, para que
puedas realizar proyectos interesantes como
lo harías con Arduino.
Los GPIO representan la interfaz entre la
Raspberry Pi y el mundo exterior. Y con ellos
podrás hacer multitud de proyectos, desde
hacer titilar un LED hasta otros mucho más
sofisticados. Pero para eso debes saber sus
características y como se programan. Lo
primero variará en función de la revisión de
placa que tengas o del modelo.
Alimentación
La alimentación de la raspberry pi 3 es de 5v
mínimo con corriente de 2A.
puedes apreciar pines de 5v, 3v3 (limitados a
50mA) y tierra (GND o Ground), que aportan
alimentación a estos voltajes para tus
circuitos. Te pueden servir como una fuente
de alimentación, aunque también puedes
utilizar otras fuentes (pilas, fuentes de
alimentación externas, etc). Recuerda que
son unbuffered y debes tener cuidado para no
dañar la placa.
Memoria
Cuenta con una ram de 1GB
La memoria de almacenamiento varia según
el tipo de sd que le coloquemos y además la
velocidad de transmisión de datos varia según
la clase de la memoria aquí colocaremos una
tabla de cales de memoria .
Programación
Para manejar las GPIO se usa mucho el
Python, sobre todo comunicarlo con Arduido
que haga de actuador, también se puede
directamente por USB. Raspberry Pi 2 como
servidor.
Frecuencia de trabajo de la raspberry pi 3
1.4 GHz
Gráfico 5raspberry pi 3
 3. Procedimiento Ya que la Raspberry nos entrega como
máximo 16mA en los pines GPIO, surge la
Los materiales que se utilizaran para el
necesidad del uso de un buffer, una escalera
armado del siguiente circuito son los
r2r y un circuito de amplificación
siguientes:
el armado de la escalera R2R con un
 10 Resistencias de 1k ohms
amplificador operacional tl082 a la salida
 12 Resistencias de 2k ohms
asegura una etapa de amplificación sin mucho
 1 amplificador operacional tl082
ruido que podemos manejar analógicamente
 74245 (buffer)
para poder visualizar claramente en el
 1 raspberry PI 3
osciloscopio la conversión que se produce de
 Pic 18f4550
un contador binario, a una señal analogía
 Arduino uno
(DAC).
 Cables de conexión
 Protoboard PROCESO MATEMATICO
 Fuente de alimentacion
Las señales generadas deberán tener sus
Tomando en cuenta los pines del raspberry Pi coeficientes en series de Fourier para poder
3: ser representadas.

Para un mejor desarrollo se divide la función

en 4 sub funciones

SENO

𝐴 1 𝜋
0= ∗∫0 𝑠𝑒𝑛(𝑡)𝑑𝑡
𝑇
Gráfico 6. puertos GPIO de la raspberry pi 3. 𝐴 2
0= =0.64
𝜋
Se lleva a cabo la implementación del
𝐴 1 𝜋
siguiente circuito: 𝑛= ∗∫ 𝑠𝑒𝑛(𝑡)∗cos(2𝑛𝑡)=𝑑𝑡
2𝑇 0

1 1 1
2 ∗ (− 4𝑛2 − 1 − 4𝑛2 − 1)
𝐴𝑛 =
𝜋
𝐴 1
𝑛=−
4𝑛2 𝜋−𝜋
𝜋
1
𝐵𝑛 = ∗ ∫ 𝑠𝑒𝑛(𝑡) ∗ sen(2𝑛𝑡) = 𝑑𝑡
2𝑇 0

0.5 ∗ 𝑠𝑒𝑛(2𝑛𝜋)
𝐵𝑛 = −
𝜋
 𝜋
𝐵𝑛 = 0 1 2
𝐴𝑛 = ∗ ∫ − 𝑡 + 2 ∗ cos(2𝑛𝑡) = 𝑑𝑡
2 2𝑇 0 𝜋
FUNCION (𝑌 = 𝜋 𝑡)
1
∗ (−2𝑛𝜋)
𝐴 1 𝜋2
0= ∗∫0 𝑡𝑑𝑡 𝐴𝑛 = 4 2 2
𝑇 𝜋 𝑛 𝜋
𝐴0=1 𝐴𝑛=0
𝜋 𝜋
1 2 1 2
𝐴𝑛 = ∗ ∫ 𝑡 ∗ cos(2𝑛𝑡) = 𝑑𝑡 𝐵𝑛 = ∗ ∫ − 𝑡 + 2 ∗ sen(2𝑛𝑡) = 𝑑𝑡
2𝑇 0 𝜋 2𝑇 0 𝜋
1
∗ (−2𝑛𝜋)
𝐴𝑛 = 4 2 2
𝑛 𝜋 1 1
∗( )
𝐴 1
𝐵𝑛 = 2 𝑛
𝑛= 𝜋
2𝑛𝜋
𝜋 1
1 2 𝐵𝑛 =
𝐵𝑛 = ∗ ∫ 𝑡 ∗ sen(2𝑛𝑡) = 𝑑𝑡 2𝑛𝜋
2𝑇 0 𝜋

A continuación se prosigue con la

1 1 1/𝜋
2 ∗ (𝑛2 𝜋 − 𝑛2 𝜋) programación
𝐵𝑛 =
𝜋
1
𝐵𝑛 =
4𝑛2 𝜋 2
FUNCION (Y=2)

𝐴 1 𝜋
0= ∗∫0 2𝑑𝑡
𝑇

𝐴0=2
𝜋
1
𝐴𝑛 = ∗ ∫ 2 ∗ cos(2𝑛𝑡) = 𝑑𝑡
2𝑇 0

𝐴𝑛 = 0
𝜋
1
𝐵𝑛 = ∗ ∫ 2 ∗ sen(2𝑛𝑡) = 𝑑𝑡
2𝑇 0 4. Tablas de comparación

𝐵𝑛 = 0
2
FUNCION (𝑌 = − 𝑡 + 2)
𝜋
𝜋
1 2
𝐴0 = ∗ ∫ − 𝑡 + 2𝑑𝑡
𝑇 0 𝜋

𝐴0=1
 Parámetros Arduin Raspberry PI3 Pic
o 18F455
0

Frecuencia 16MHz 1.2GHz 48MHz

de trabajo

Alimentacion 7v-12v 5V 2A 5.5V

4.9V

Volaje de 5v 2.7V 5V
operativo 3.3V

RAM 2Kb 1GB 2kb

ROM 1Kb Slot 256b
dependiendo
del sistema
operativo
recomendable
hasta 64GB
Lenguaje de C++ Con raspbian C++
programacio Python,
n c,c++,javascrip
t
Corriente de 20mA 16mA 2.5mA
salida de
puertos

Precios 120 Bs. 350 Bs. 50 Bs.

Imágenes obtenidas al momento de simular
Bibliografía

https://www.mikroe.com/ebooks/microcont
roladores-pic-programacion-en-c-con-
ejemplos/puertos-de-entradasalida

https://arduinodhtics.weebly.com/tipos-de-
arduino.html

https://electronilab.co/tienda/pic18f4550-ip-
pic-18-40-pines-48-mhz-32kb/

http://www.electronicoscaldas.com/microco
ntroladores-pic/32-microcontrolador-pic-
18f4550-usb.html

https://www.xataka.com/ordenadores/raspb
erry-pi-3-model-b-analisis-mas-potencia-y-
mejor-wifi-para-un-minipc-que-sigue-
asombrando

https://comohacer.eu/gpio-raspberry-pi/

https://es.wikipedia.org/wiki/Raspberry_Pi

https://gist.github.com/m3nd3s/2065690
Anexos.

Anexo 4

Anexo 1

Anexo 8

#define PI 3.14159265
Anexo 3 int ww;

int graf[600];

double seno,inc=0;

double aa=0.5,ff,bn;

int nn,pp;

void main( void )

TRISD = 0;

PORTD = 0;

TRISC = 0;

PORTC = 0;

//Se configura el TIMER 0, su interrupción.

 ADCON1 = 0x0F; import math

CMCON = 0x07; import time

for(ww=0;ww<=512;ww++) GPIO.setmode(GPIO.BOARD)

{ graf=[]

bn=0; i=0

for(nn=1;nn<200;nn+=2) a=0

{ t=0

bn=bn+((-2*sin(10*nn*inc))/(10*nn*PI)) armonicos=1000
;
num=1
}
ff=1
ff=(aa+bn)*200;
pines = [3,5,7,11,13,15,19,21,23,29]
inc=inc+0.0123;
for pin in pines:
//if(seno>1000){seno=500;}
GPIO.setup(pin,GPIO.OUT)
//if(seno<0){seno=0;}
for pin in pines:
graf[ww]=ff*512/200;
GPIO.output(pin, False)
}
def mostrar(data):
ww=0;
ii=1
while(1)//Bucle infinito.
for pin in pines:
{
if (data&ii)==0:
pp=graf[ww];

ww=ww+1; GPIO.output(pin,False)

PORTC=(pp>>8); else:

PORTD = pp&255;
GPIO.output(pin,True)
if(ww>512){ww=0;}
ii=ii<<1
//}
while contador<100:
}
num=1;
}
sumatoria=0
Anexo 9
while num<=armonicos:
import RPi.GPIO as GPIO
 sumatoria=sumatoria + void setup()
(math.sin(num*wo*t))/num
char pin;
num+=1
{
xf=512-(1024/math.pi)*sumatoria
for (pin=2;pin<11;pin++)
sierra.insert(contador,int(xf))
{
t+=0.01
pinMode(pin,OUTPUT);
contador+=1
}
while (True):
for (pin=2;pin<11;pin++)
contador=0
{
while contador<100 :
digitalWrite(pin,LOW);
mostrar(sierra[contador])
}
contador+=1
}

void loop()
Anexo 10
{
int intrmd=0;
cont=0;
int cont=0;
while(cont<100)
int sum=0;
{
int ondas[50];
mostrar(ondas[cont]);
float i=0;
cont+=1;
float xf,sumatoria;
}
int a=0;
}
float t=0;

char ii;
void mostrar(int data)
float pi=3.141592;
{
int armonicos=100;
ii=1;
int num=1;
for (pin=2;pin<11;pin++)
int ff=1;
{
float wo=2*pi*ff;
if((data&ii)==0)

{
 digitalWrite(pin,LOW); {

}
sumatoria=sumatoria+(sin(num*wo*t))/num
else
;
{
num+=2;
digitalWrite(pin,HIGH);
}
}
xf=(1024/pi)*sumatoria;
ii=ii<<1;
t+=0.01;
}
ondas[cont]=int(xf);
}
cont+=1;

}
void senoidal()
}
{
anexo solucionario
while(cont<100)
ejercicio 1
{ 0 1
1
𝐴0 = ∗ ∫ −2𝑑𝑡 + ∫ 𝑑𝑡
intrmd=int(128+127*sin(i)); 𝑇 −1 0

ondas[cont]-intrmd; 𝐴 1
0=−
4
i+=0.0628;

cont+=1; 0
1
𝐴𝑛 = ∗ ∫ −2 cos(𝑤𝑛𝑡) 𝑑𝑡
} 2 −1
1
} + ∫ cos⁡(𝑤𝑛𝑡)𝑑𝑡
0

𝑛𝜋 𝑛𝜋
𝑠𝑒𝑛 ( 2 ) 𝑠𝑒𝑛( )
void cuadrada() 𝐴𝑛 = 2 ∗ + 2
𝑛𝜋 𝑛𝜋
{ 1 0
𝐵= ∗ ∫ −2 sin(𝑤𝑛𝑡) 𝑑𝑡
while(cont<=100) 2 −1
1
{ + ∫ sin⁡(𝑤𝑛𝑡)𝑑𝑡
0
sum=1;

sumatoria=0; 𝑛𝜋 𝑛𝜋
3 cos (− 2 ) cos⁡( )
𝐵𝑛 = −4 − 2
armonicos=1000; 𝑛𝜋 𝑛𝜋 𝑛𝜋
while(num<=armonicos)
 GPIO.setmode(GPIO.BOARD)

muest=0

sumat=0

Ejercicio numero 2 armon=0

−𝜋
1 an=0
𝐴0 = ∗ ∫ 𝑑𝑡
𝑇 −2𝜋
𝜋 bn=0
+ ∫ (𝜋 − 𝑡)𝑑𝑡
0 ft=0
2𝜋
+ ∫ (𝑡 − 𝜋)𝑑𝑡 xf=0
𝜋
aa=-0.3333
1 𝜋
𝐴0 = +
4 4 inc=-1
−𝜋
1 𝑛𝑡 graf=[]
𝐴𝑛 = ∗ ∫ cos ( ) 𝑑𝑡
8𝜋 −2𝜋 2
𝜋
𝑛𝑡 pines = [3,5,7,11,13,15,19,21,23,29]
+ ∫ (𝜋 − 𝑡) cos ( ) 𝑑𝑡
0 2 for pin in pines:
2𝜋
𝑛𝑡
+ ∫ (𝑡 − 𝜋)cos⁡( )𝑑𝑡 GPIO.setup(pin,GPIO.OUT)
𝜋 2
1 𝑛𝜋 1 𝑛𝜋 1 for pin in pines:
𝐴𝑛 = − 𝑠𝑒𝑛 ( ) − 2 cos ( ) +
4 2 𝜋𝑛 2 2𝜋𝑛2 GPIO.output(pin, False)
1
+ cos⁡(𝑛𝜋)
2𝜋𝑛2 def mostrar(data):
−𝜋
1 𝑛𝑡 ii=1
𝐵𝑛 = ∗ ∫ sen ( ) 𝑑𝑡
8𝜋 −2𝜋 2
𝜋
𝑛𝑡 for pin in pines:
+ ∫ (𝜋 − 𝑡) sen ( ) 𝑑𝑡
0 2 if (data&ii)==0:
2𝜋
𝑛𝑡
+ ∫ (𝑡 − 𝜋)sen⁡( )𝑑𝑡 GPIO.output(pin,False)
𝜋 2
else:

1 𝑛𝜋 1−𝜋 1 GPIO.output(pin,True)
𝐵𝑛 = − cos ( ) + cos(𝑛𝜋) +
4𝑛𝜋 2 4𝑛𝜋 4𝑛 ii=ii<<1
1 𝑛𝜋
− 2 𝑠𝑒𝑛( )
𝜋𝑛 2 for muest in range (0,100):

sumat=0
Codigos utilizados for armon in range (1,50):
import RPi.GPIO as GPIO an=(-
import math 0.079577/armon)*math.sin(2.0944*armon)
 bn=(0.2387/armon)*(1-
math.cos(2.0944*armon))

sumat=sumat+an*math.cos(2.0944*armon*i
nc)+bn*math.sin(2.0944*armon*inc)

ft=2+(aa+sumat)

xf=ft*1024/3

inc=inc+0.03

graf.insert(muest,int(xf))

while (True):

muest=0

while muest<100 :

mostrar(graf[muest])

muest+=1