Pontificia universidad javeriana 1

Facultad de ingeniería – Departamento de electrónica

Controles – 14 DE MARZO DEL 2019

LAB 1: Control de velocidad de un motor DC

mediante Arduino.
Juan Sebastián Corredor Angarita.
juan_corredor@javeriana.edu.co
Juan Camilo Toloza Medina.
j.toloza@javeriana.edu.co

Facultad de Ingeniería
Departamento de Electrónica
Pontificia Universidad Javeriana

Resumen
En este primer acercamiento a los laboratorios previos al
proyecto de investigación y diseño se va a investigar y
analizar los elementos (Motor DC) necesarios para
desarrollar posteriormente nuestro proyecto. Así mismo,
lo que buscamos es poder caracterizar el motor DC lo más
posible, y que tengamos suficiente información acerca del
comportamiento de este actuador. Apoyado por
simulaciones en Matlab.
Índice de Términos — Actuadores, Función de
transferencia, Matlab, Simulación, Sistema de control.
I. INTRODUCCIÓN
//-----------------------------------------------------------------------------------
//Control ON/OFF de un motor
//-----------------------------------------------------------------------------------
//Programa que hace uso de un motor y un pulsador, mientras se
//mantenga pulsado, el motor debe estar encendido (ON) de lo
//contrario debe estar apagado (OFF)
//-----------------------------------------------------------------------------------
//Declara puertos de entradas y salidas y variables
//-----------------------------------------------------------------------------------
int pulsador =7; //Declara Pin del pulsador
int motor=3; //Declara Pin del motor
int vpulsador=0;
//-----------------------------------------------------------------------------------
//Funcion principal
//-----------------------------------------------------------------------------------

E void setup() // Se ejecuta cada vez que el Arduino se inicia

sta práctica se divide en dos segmentos,
comenzando con el comportamiento de nuestro {
motor DC mediante el control de un //Defina la variable –pulsador- como una entrada. Haga uso de
microprocesador ARDUINO. La segunda parte de nuestro la //función pinMode();
laboratorio corresponde a la caracterización del motor DC, pinMode(pulsador,INPUT);
mediante la variación de su velocidad variando el ciclo útil de //Defina la variable –motor- como una salida.
un generador de pulsos que estará encargado de actuar como pinMode(motor,OUTPUT);
un Switch, el cual prende y apaga nuestro motor. Después }
procederemos a diseñar y simular dos tipos de controladores //-----------------------------------------------------------------------------------
o dos leyes de control las cuales corresponder a un controlador //Funcion ciclicla
PID y un compensador en atraso de fase. La idea de //-----------------------------------------------------------------------------------
implementar estos dos actuadores es controlar nuestra void loop() // Esta funcion se mantiene ejecutando
respuesta del motor y también poder ver su comportamiento {
vpulsador = digitalRead(pulsador);
ante diferentes entradas como una entrada paso, una rampa y
//Si el pulsador se encuentra oprimido
una parábola.
if (vpulsador == HIGH)
{
II. DESARROLLO // acción A: Encender motor
digitalWrite(motor,HIGH);
A. Control del motor en lazo abierto //de lo contrario
} else
1. Se desea desarrollar un programa que hace uso de un {
motor y un pulsador, mientras el pulsador se mantenga // acción B: Apagar el motor
pulsado, el motor debe estar encendido (ON) de lo digitalWrite(motor,LOW);
contrario debe estar apagado (OFF). }
}
// Fin programa
Pontificia universidad javeriana 2
Facultad de ingeniería – Departamento de electrónica
Controles – 14 DE MARZO DEL 2019

//Variable para escalar el valor ingresado a rango de PWM

int velocidad = map(a,'0','5',0,255);
//Escritura de PWM al motor
analogWrite(motor,velocidad);
//Mensaje para el usuario
Serial.print("El motor está girando a la velocidad ");
Serial.println(a);
}else{ // Si el caracter ingresado NO esta entre 0 y 5
//Mensaje para el usuario
Serial.print("Velocidad invalida ");
Serial.println(a);
}
}
}
//Fin programa

Ilustración 1. Esquemático circuito (ON/OFF).

2. Se desea desarrollar un programa que hace uso de un

motor y la Consola serial de Arduino, este tiene la
posibilidad de configurar al motor 5 velocidades
distintas, desde el teclado del PC puedes enviarle la
velocidad deseada. Las 5 velocidades se configuran con
5 PWM distintos.

//----------------------------------------------------------------------------------
//Control por PWM de un motor
//---------------------------------------------------------------------------------- Ilustración 2. Esquemático circuito controlado por PWM.
//Programa que hace uso de un motor y la Consola serial de
//Arduino, tiene la posiblidad de configurar al motor 5
//velocidades //distintas, desde el teclado del PC puedes B. Control del motor en lazo cerrado
//enviarle la velocidad //deseada. Las 5 velocidades se
//configuran con 5 PWM distintos. 1. Identifique el modelo de primer orden para el motor
//---------------------------------------------------------------------------------- DC, de la forma:
//Declara puertos de entradas y salidas y variables
//----------------------------------------------------------------------------------
int motor=3; //Declara Pin del motor
//----------------------------------------------------------------------------------
//Funcion principal
//----------------------------------------------------------------------------------
void setup() // Se ejecuta cada vez que el Arduino se inicia
{
Serial.begin(9600); //Inicia la comunicacion serial Arduino-PC
}
//----------------------------------------------------------------------------------
//Funcion ciclicla
//---------------------------------------------------------------------------------- Ilustración 3. Caracterización esperada del motor DC.
void loop() // Esta funcion se mantiene ejecutando
{
//Si hay algun valor en la Consola Serial Inicialmente lo que se busca es poder describir nuestro
if (Serial.available()){ sistema de primer orden (Motor DC), para después poder
//Variable donde se guarda el caracter enviado desde teclado aplicar e implementar técnicas de control (PID y
char a = Serial.read(); compensador de atraso). Entonces, lo primero que debemos
// Si el caracter ingresado esta entre 0 y 5 hacer es caracterizar nuestro motor DC, para esto,
alimentaremos nuestro circuito con una entrada constante de
if (a>='0' && a<='5'){ 5V, y después lo que haremos será, encender y apagar la
Pontificia universidad javeriana 3
Facultad de ingeniería – Departamento de electrónica
Controles – 14 DE MARZO DEL 2019

salida de nuestro transistor que funcionará como Switch

ON/OFF.

Esta caracterización se logra mediante la variación del ancho

de pulso, para esto se implementó un sistema de bloques en la
herramienta de ingeniería Simulink, en el cual se trabaja
conjuntamente con el software/hardware Arduino. Con el
generador de pulsos que se muestra a continuación, establezco
mis pulsos modulados, como se muestra a continuación:

Ilustración 6. Conteo de pulsos en mi sistema.

Estos pulsos leidos van a ser posteriormente convertidos en

RPM, sabiendo la cantidad de huecos que se leen en un tiempo
determinado podemos conocer la velocidad a la que está
girando el motor, dando como resultado la curva vista en el
ultimo scope (rojo).

Ilustración 4. Diagrama de bloques completo para nuestro sistema, el

cual realizara una gran cantidad de muestras y mediciones para
graficar el comportamiento de mi Motor DC.

Dentro de mi sistema con encoder embebido, poseo un buffer.

Este buffer lleva el número de recuentos, sin embargo, solo
puede contar cierto número de veces, en general puede contar
desde -32.768 a 32.767, esto corresponde a 15 bits para el
numero y uno para el signo.

Este bloque compara el número actual de conteos con el

número de conteos de la muestra anterior, para determinar si
se ha producido un reinicio en el conteo, y luego me modifica
el numero acumulado de conteos.
Ilustración 5. Subsistema que trata de eliminar el “rollover” de mi
sistema.
Ilustración 7. Respuesta del motor DC para un ancho de pulso del 50%.
En la ilustración 7 observamos la respuesta de nuestro motor
para un ancho de pulso del 50%. El circuito del motor, junto
con el encoder fue alimentando mediante una fuente de
voltaje de 5 V. Así mismo, la amplitud es de 1 V y ciclo útil
variable. Siguiendo el mismo procedimiento se grafican
diferentes anchos de pulso, la respuesta a estos se presenta a
continuación.

En la ilustración 6 observamos una señal cuadrada con ciclo 90% 80% 70% 60% 50%
util variable que es enviada a través de la tarjeta arduino 35% 25% 15% 5% 2%
(bloques azules) esta señal funciona como nuestro control de
RPM que depende del ancho de los pulsos, debido a esta señal
y al montaje que tenemos el motor va a empezar a girar a una
velocidad que debe ser obtenida utilizando el encoder. La
lectura del encoder puede ser visualizada abriendo el primer
scope (scope verde).
Pontificia universidad javeriana 4
Facultad de ingeniería – Departamento de electrónica
Controles – 14 DE MARZO DEL 2019

Se obtuvo la siguiente respuesta: pulso de entrada, en este caso sabemos que mi pulso siempre
cuenta con una amplitud de 1V, entonces:

∆𝑢 = 𝐷𝑢𝑡𝑦 𝑐𝑦𝑐𝑙𝑒 (3)

Tabla 2. Valores de la constante K para cada uno de los

diferentes anchos de pulso.

Ancho de pulso [%] ∆𝒚

Constante 𝑲 =
∆𝒖

90 77.48
80 77.2625
70 80.7
60 86.18
50 84.52
Ilustración 8. Respuesta de mi sistema para diferentes anchos de 35 89.45
pulsos.
25 98.6
15 115.4
A continuación, procedemos a calcular los distintos tiempos 5 203
de subida de mis respuestas, esto se puede ver mediante la 2 267.95
opción de Matlab “cursor de datos”, observo cual es la ∆𝒚
𝑲=
velocidad a la que mi Motor DC se estabiliza y después ∆𝒖 118.05425
calculo el 63.3% de ese valor. Al poner el cursor podré
observar mi tiempo de subida en segundos.

El valor de la constante K para mi Motor DC es de 118.05425.

Tabla 1. Valores de tiempo de subida para cada uno de los Con el valor promedio de mi tiempo de subida y el valor
diferentes anchos de pulso. promedio de mi constante K puedo saber cuál es la función de
transferencia que describe a mi planta, que es:
Ancho de pulso [%] Tiempo de subida 𝝉 [seg]
90 1.528
80 1.366 118.05425 (4)
𝐺(𝑠) =
70 1.4 (1.3274)𝑠 + 1
60 1.361
50 1.32
35 1.281 C. Diseño de control PID.
25 1.181
15 1.221 Para la planta anterior, diseñe un control de velocidad tipo
5 1.173 PID con tiempo de establecimiento de 4 segundos y factor de
2 1.443 amortiguamiento de 0.8. Halle las ganancias del controlador
y valide sus resultados en Simulink-Matlab. Introduzca
Tiempo de subida 1.3274
pequeñas perturbaciones al sistema y analice si el controlador
promedio
implementado permite el rechazo a dichas perturbaciones.
El tiempo de subida promedio para mi motor es de 1.3274
Teniendo en cuenta ya la caracterización de nuestra planta
segundos. Según este dato, procedemos a calcular la constante
podemos empezar a modelar nuestro sistema PID, entonces:
de mi sistema, que se puede observar en la siguiente ecuación:
𝑘𝑖 (5)
𝐾 (1) 𝑃𝐼𝐷 = 𝐶(𝑠) = 𝑘𝑝 + + 𝑘𝑑 𝑠
𝐺(𝑠) = 𝑠
𝜏𝑠 + 1

∆𝑦 (2)
𝐾=
∆𝑢

En donde ∆𝑦 es la velocidad en RPM a la que mi motor tiende

a estabilizarse después de cierto tiempo y ∆𝑢 es el valor de mi
Pontificia universidad javeriana 5
Facultad de ingeniería – Departamento de electrónica
Controles – 14 DE MARZO DEL 2019

Según esto tenemos el siguiente diagrama de bloques: 𝑈(𝑠) (−1.075)𝑠 2 + 4.68𝑠 + 904.5 (12)
=
𝐸(𝑠) 𝑠 2 + 100𝑠

Sabiendo ya la función de transferencia de mi bloque

controlador PID, podemos implementar y simular mi sistema
en Simulink:
Ilustración 9. Diagrama de bloques empleando un controlador a la
planta.

𝑌(𝑠) 𝐶(𝑠) ∗ 𝐺(𝑠) (6)

=
𝑅(𝑠) 1 + 𝐶(𝑠) ∗ 𝐺(𝑠)

𝑘𝑝 𝑠 + 𝑘𝑖 + 𝑘𝑑 𝑠 2 118.05425 (7)
( )∗( )
𝑌(𝑠) 𝑠 (1.3274)𝑠 + 1
=
𝑅(𝑠) 𝑘𝑝 𝑠 + 𝑘𝑖 + 𝑘𝑑 𝑠 2 118.05425
1+( )∗( )
𝑠 (1.3274)𝑠 + 1
Ilustración 10. Diagrama de bloques del sistema controlado por un
controlador PID.

Mediante la aproximación de la acción derivativa tenemos:

Este sistema con los valores de:
𝜏 1 𝐾𝑘𝑝 𝐾𝑘𝑖
𝑑𝑒𝑛 = ( ) 𝑠 3 + ( + 𝜏 + + 𝐾𝑘𝑑 ) 𝑠 2 + ( + 𝐾𝑘𝑝 + 1) 𝑠 + 𝑘𝑖
𝑁 𝑁 𝑁 𝑁 𝑘𝑖 = 4.68

𝑘𝑑 = −0.0544
4 (8)
𝑇𝑠 =
𝜌𝜔𝑛 𝑘𝑝 = 4.365

𝜔𝑛 = 1.25 Obtuvo la siguiente respuesta a su salida:

0.8𝜋 (9)
−
𝑃𝑂 = 100𝑒 √1−(0.82 ) = 1.51%

𝑠 3 + ((88.89)𝑘𝑝 + (8893.32)𝑘𝑑 + 100.75)𝑠 2

+ ((88.9)𝑘𝑖 + (8893.32)𝑘𝑑 + 77.33)𝑠 + 𝑘𝑖

El polinomio que me define el denominador de mi función de

transferencia de mi sistema con controlador PID incluido, se
iguala a:

𝑠 3 + (𝑘𝑑 − 2)𝑠 2 + (𝑘𝑝 + 2)𝑠 + 𝑘𝑖 (10)

Simplificando esto y desarrollando las ecuaciones, tengo lo

Ilustración 11. Respuesta en tiempo de mi sistema de bloques, al cual
siguiente:
implemento un controlador PID.

𝑘𝑖 = 4.68
Se puede ver que se tiene mucha variabilidad al inicio de la
𝑘𝑑 = −0.0544
simulación, esto puede suceder por el valor que tiene 𝑘𝑑 , como
podemos observar esta constante se acerca mucho a cero, por lo que
para un comportamiento mucho menos ruidoso y variable,
𝑘𝑝 = 4.365 establecemos:

𝑘𝑑 = 0
4.68 (−0.0544)𝑁 (11)
𝑃𝐼𝐷 = 𝐶(𝑠) = 4.365 + + 𝑠
𝑠 𝑠 + 100
Pontificia universidad javeriana 6
Facultad de ingeniería – Departamento de electrónica
Controles – 14 DE MARZO DEL 2019

Para este cambio el sistema se comporta de la siguiente

manera:

Ilustración 14. Respuesta en tiempo de mi sistema de bloques, al cual

implemento un controlador PID perturbado por una señal paso de
amplitud igual a 0.3.

Ilustración 12. Respuesta en tiempo de mi sistema de bloques, al cual

implemento un controlador PID modificado para que kd=0.
D. Diseño de compensador

Teniendo en cuenta ya la caracterización de nuestra planta

Se puede observar que a medida que mi Kd se acerca mucho podemos empezar a modelar nuestro sistema por
más a cero, tengo una respuesta menos variable a la salida de compensación LGR, entonces:
mi planta, por esta razón se decidió cambiar el valor de esta
variable. 118.05425 (13)
𝐺(𝑠) =
(1.3274)𝑠 + 1

Teniendo en cuenta los polos y ceros de mi planta,

procedemos a graficar el LGR no compensado. La grafica es
la siguiente:

Ilustración 13. Diagrama de bloques del sistema controlado por un

controlador PID, agrega una perturbación al sistema.

Ya que se cuenta una perturbación dentro de nuestro sistema,

vamos a ver que, al inicio de la gráfica, esta perturbación
mueve nuestra salida del sistema, sin embargo, poco tiempo
después el sistema soluciona esta perturbación y vuelve al
valor deseado.

Ilustración 15. LGR del sistema no compensado.

Los polos deseados de mi planta son:

𝑆1,2 = −(0.8)(1.25) ± √1 − (0.82 )(1.25)𝑗 (14)

𝑆1,2 = −1 ± 0.75𝑗

Usando el metodo de ajuste de ganancia del LGR, dibujo la

ubicación de los polos de mi planta y los polos deseados de
Pontificia universidad javeriana 7
Facultad de ingeniería – Departamento de electrónica
Controles – 14 DE MARZO DEL 2019

mi sistema, y prosigo a hallar los angulos correspondientes,

en este caso solo tengo un polo entonces, tenemos: 𝑘𝑝 𝑑𝑒𝑠𝑒𝑎𝑑𝑜 = 4

0.7533 (15)
tan−1 ( ) = 71.56° 𝑘𝑝 𝑑𝑒𝑠𝑒𝑎𝑑𝑜 = 𝑘𝑐 (𝑎)𝑘𝑝
0.25
2 2
180° − 71.56° = 108.43° 𝑎= = = 10.86
Usando la condición del ángulo, tengo que sumar todos los √𝐾 √118.05425
ángulos que hay entre el eje real y la recta proyectada desde
mi cero a mi polo deseado. De esta manera prosigo a realizarlo Si 𝑘𝑐 = 1 y 𝑎 = 10.86, tenemos que:
con los polos y por ultimo debo hacer la resta de los ángulos
de los ceros y los ángulos de los polos. −1 1 (19)
𝑠= → − = −0.092
𝑎𝑇 𝑎
En mi planta no tengo ceros, solo tengo un polo que me
describe el sistema, por tanto:

−𝑎𝑛𝑔𝑢𝑙𝑜(𝑝1) = −108.43° (16) Ahora por elección, escogemos un cero cercano a ese polo:

1 (20)
−108.43° ≠ −180° − = −0.093
𝑇
Esto me quiere decir, que la ganancia de mi compensador no
es suficiente, por lo tanto, mi compensador debe aportar un 𝑇 = 10.752
ángulo de -71.57°.
𝑝𝑜𝑙𝑜 → −0.00855
Se debe diseñar un compensador en atraso de fase, por lo
tanto, tenemos: 𝑐𝑒𝑟𝑜 → −0.093

1 (17) Conociendo los valores de a y T puedo ya definir la función

𝑠( ) de transferencia de mi compensador en atraso de fase:
𝑒𝑠𝑠 = 𝑒𝑝 = lim ( 𝑠 )
𝑠→0 1 + 𝐶(𝑠) ∗ 𝐺(𝑠)
𝑠 + 0.093 (21)
𝐶(𝑠) = ( )
𝑠 + 0.0085
1
𝑒𝑠𝑠 = 𝑒𝑝 = lim ( )
𝑠→0 1 + 𝐶(𝑠) ∗ 𝐺(𝑠)

1 Para hallar el nuevo LGR compensado debo multiplicarla

𝑠+( ) 118.05425
( 𝑇 )∗( ) función de transferencia de mi condensador con la función de
1 (1.3274)𝑠 +1 transferencia dela planta, en consecuencia:
𝑠+( )
𝑎𝑇
𝐾 𝑠 + 0.093 118.05425 (22)
( )∗( )
𝑠 + 0.0085 (1.3274)𝑠 + 1
( 𝑇 ) = 𝑘𝑝 = 𝐾𝑎
1
𝑎𝑇 (118.05425)𝑠 + 10.979
( )
𝑠 2 + (0.7618)𝑠 + 0.0064
𝑒𝑝 𝑑𝑒𝑠𝑒𝑎𝑑𝑜 = 0.2

Se escoge una señal paso para ver el comportamiento de mi

compensador con mi planta, y por esta razón es que se
1
multiplica por ( ).
𝑠

El siguiente paso, es determinar el polo y cero necesarios para

producir el incremento necesario en la constante de error
estático. Nosotros anteriormente establecimos un error de 0.2.

1 (18)
𝑒𝑝 𝑑𝑒𝑠𝑒𝑎𝑑𝑜 =
1 + 𝑘𝑝 𝑑𝑒𝑠𝑒𝑎𝑑𝑜
Pontificia universidad javeriana 8
Facultad de ingeniería – Departamento de electrónica
Controles – 14 DE MARZO DEL 2019

Después de ya tener todos los datos necesarios procedemos a

usar Simulink con el objetivo de representar la planta y mi
compensador en atraso de fase para realizar una comparación
entre la teoría de controles y la practica con mi Motor DC.

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

E. Implementación del controlador PID

Se desarrolló la implementación del control PID a la

Ilustración 16. LGR del sistema compensado.
representación de la planta real por medio de diagrama de
bloques, para esto se usó el diagrama en Simulink realizado
anteriormente para caracterizar la planta como sensor en el
sistema de lazo cerrado y configuramos los valores del PID
en el diagrama. El diagrama de bloques se muestra a
continuación:

Ajustar la ganancia Kc del compensador a partir de la

condición de magnitud y que los polos se encuentren la
posición deseada. Para esto, se calcula la dinámica en lazo
cerrado SIN COMPENSADOR 𝐺𝑙𝑐(𝑠) y hallamos el polo
dominante del sistema:

𝑌(𝑠) 𝐺(𝑠) (23)

=
𝑅(𝑠) 1 +∗ 𝐺(𝑠)
Ilustración 17. Diagrama de bloques del sistema controlado por un
compensador en atraso de fase.
118.05425
𝐺𝑙𝑐 (𝑠) =
𝑠 + 118.8

De esta manera, sabemos que el polo dominante de mi sistema

se encuentra en 𝑠 = −118.8.

(24)
118.82
𝜔𝑛 2 (√1 − ( )) = 0
𝜔𝑛

𝜔𝑛 = 118.8 Ilustración 18. Respuesta en tiempo de mi sistema de bloques, al cual

implemento un compensador en atraso de fase.
𝜌=1
Como se puede observar en la ilustración 18, se obtuvo una
Por último, lo que queda es ajustar la ganancia Kc del
respuesta esperada y muy buena de simulación. No se obtuvo
compensador a partir de la condición de magnitud y que los
un sobre pico muy elevado, de hecho, la salida del sistema
polos se encuentren la posición deseada.
sigue muy bien el voltaje de entrada.
1 (25)
𝑠+ 𝐾
𝐶(𝑠) ∗ 𝐺(𝑠) = |𝑘𝑐 ∗ ( 𝑇 )∗ | =1
1 𝜏𝑠 +1
𝑠+
𝑎𝑇 −118.8

𝑠 + 0.095 118.05425
|𝑘𝑐 ∗ ( )∗ | =1
𝑠 + 0.0085 (1.3274)𝑠 + 1 −118.8

1 = (0.999) ∗ (1) ∗ 𝑘𝑐

𝑘𝑐 = 1.0009
Pontificia universidad javeriana 9
Facultad de ingeniería – Departamento de electrónica
Controles – 14 DE MARZO DEL 2019

III. CONCLUSIONES

Es importante realizar la caracterización de cualquier planta o

sistema que utilicemos, si no se conocen los parámetros
necesarios para un correcto funcionamiento el sistema no se
va a comportar de la forma que deseamos y por ende no será
posible realizar el diseño de un buen controlador.

El tiempo de muestreo tanto de salida como de entrada es una

variable que con un solo decimal puede dañar una serie
completa de datos (nuestro montaje no funcionaba
correctamente hasta que se le agregó un 0 al tiempo de
muestreo en la entrada).

Implementar por nuestra propia cuenta un control PID o

compensador ayuda a comprender y profundizar en los tipos
de controladores y como estos actúan en un sistema, esta
práctica nos permite ver los resultados de la teoría explicada
en clase.

Simulink es una herramienta bastante útil para observar el

funcionamiento en tiempo real de nuestros montajes y nos
permite realizar el análisis de los datos obtenidos fácilmente.

IV. BIBLIOGRAFÍA Y REFERENCIAS

[1] https://uvirtual.javeriana.edu.co/bbcswebdav/pid-155143-
dt-content-rid-
557530_1/courses/004107_1910_1275/practica%201%20Mo
torDC_arduino.pdf
[2] https://uvirtual.javeriana.edu.co/bbcswebdav/pid-155129-
dt-content-rid-
557523_1/courses/004107_1910_1275/clase%203%20Tipos
%20de%20control_sintonizacion.pdf
[3] https://uvirtual.javeriana.edu.co/bbcswebdav/pid-155131-
dt-content-rid-
557525_1/courses/004107_1910_1275/clase%205%20Com
pensadores_LGR.pdf
[4]http://www.mathworks.com/help/supportpkg/arduino/exa
mples/drive-with-pid-control.html?refres
h=true#zmw57dd0e2171