INGENIERÍA MECATRÓNICA
ROBOTICA INDUSTRIAL
NRC: 7759
INFORME
CONTROL PID DE MOTOR DC
PROFESOR:
Ing. DAVID LOZA
INTEGRANTES
FABRICIO VEINTIMILLA
17 DE AGOSTO 2022
SANGOLQUÍ
Introducción
El motor de corriente continua (DC) es un dispositivo que convierte la fuerza eléctrica en
fuerza mecánica. Tiene muchas aplicaciones, en robótica y automatización industrial. El
motor de DC es muy utilizado porque es fácil de controlar, simple y tiene un buen
rendimiento.[1]
El problema de un motor DC es cómo controlar y estabilizar la velocidad angular en valor
especifico. Es necesario aplicar un método para controlar la entrada de voltaje. Se puede
utilizar el método de control PID para lograr esta tarea.[2] Existen varios modelos teóricos
que ayudan a realizar una simulación y encontrar valores para las constantes de control
proporcional, integral y derivativo, sin embargo, esto se limita solo a la simulación, y no
a la implementación del hardware. Al aplicarlo a un sistema real es evidente que se deben
hacer ajustes a las constantes del PID para lograr el mejor rendimiento posible. Dentro de
este trabajo se utilizará un microcontrolador de bajo costo, el Arduino Uno. El objetivo
de este trabajo es observar la implementación del controlador PID y sintonizar las
constantes del controlador PID en la implementación del hardware.
La estructura de este trabajo es la siguiente. El primero es el sistema propuesto. El
segundo es la metodología, el tercero es el resultado y discusión, y el último es la
conclusión.
Sistema propuesto
El sistema que se plantea controlar consta de un motor DC reductor (reducción 1/46), el
cual tienen implementado un encoder de efecto hall en su parte posterior de 6 pulsos por
revolución. Para controlar la entrada de voltaje hacia el motor se utiliza el modulo de
puente H L298N, el cual modula la entrada de voltaje mediante modulación por ancho de
pulso (PWM). Además, consta de una tarjeta Arduino UNO que será el microcontrolador
encargado de enviar una señal digital de 8 bits al puente H para el control de velocidad.
Para el setpoint se utiliza un potenciómetro, la visualización de los datos será a través de
una pantalla LCD de 16x2. El sistema consta de una fuente de voltaje variable y se
alimenta con 9 V
Metodología
Para realizar el control de un sistema lo primero es obtener un modelo matemático que
represente el comportamiento de la planta en base a una entrada. Para realizar la
identificación de un sistema se necesitan los datos de entrada, salida y periodo de
muestreo durante un periodo de tiempo. Para el caso del motor DC se utilizó la tarjeta
Arduino UNO para adquisición de datos. La entrada fue el valor digital de 8 bits que
entrega el microcontrolador al puente H para el PWM. La salida medida fue la velocidad
del motor en rpm. La velocidad en rpm no es una variable que se mide directamente sino
a través de los pulsos por revolución que lee el encoder y la reducción del motor. Para el
cálculo de la velocidad en rpm se utilizó la siguiente formula[3]:
𝑉𝑅𝑃𝑀 = 𝑚 ∗ (𝑓𝑟𝑒𝑐. 𝑒𝑛𝑐𝑜𝑑𝑒𝑟, 𝑝𝑢𝑙𝑠𝑜𝑠/𝑠) ∗ (
Donde
1 𝑟𝑒𝑣
60 𝑠
)∗(
)
𝐼𝑀𝑃 ∗ 𝑟𝑒𝑙𝑎𝑐𝑖ó𝑛 𝑑𝑒 𝑟𝑒𝑑𝑢𝑐𝑐𝑖ó𝑛
1 𝑚𝑖𝑛
𝑚: factor de compensación del tiempo de muestreo
𝑓𝑟𝑒𝑐. 𝑒𝑛𝑐𝑜𝑑𝑒𝑟: los pulsos leídos por la tarjeta en 1 segundo
𝐼𝑀𝑃: Numero de pulsos por cada revolución del encoder.
𝑟𝑒𝑙𝑎𝑐𝑖ó𝑛 𝑑𝑒 𝑟𝑒𝑑𝑢𝑐𝑐𝑖ó𝑛: Reducción de velocidad del motor.
Para tiempo de muestreo se utilizó el mínimo con el cual se pudo obtener lecturas
satisfactorias sobre la velocidad del motor. Este tiempo fue de 50 ms por lo que m (factor
de tiempo de muestreo) toma un valor de 20.
Se realizaron dos mediciones en el cual empieza la entrada con un valor máximo, es decir
con 9 V durante 1 s y luego se apaga el escalón.
Figura 1 Identificación de la planta (motor DC)
El valor máximo alcanzado fue de 69 rpm también se puede observar que el sistema tiene
una reacción inmediata a la entrada de voltaje. Mediante el uso de la función arx de matlab
la cual un modelo polinomial con parámetros y covarianzas estimadas usando el método
de mínimos cuadrados y luego esto transformado a una función de transferencia en tiempo
discreto. La estimación de la función de transferencia de la planta utilizando arx de matlab
tiene una coincidencia del 95.98% como se muestra en la figura
Figura 2 Identificación de la planta (Motor DC)
La función obtenida en la siguiente:
0.1095 𝑧 −1 − 0.0525 𝑧 −2
𝐺 (𝑧 ) =
1 − 1.244 𝑧 −1 + 0.3454 ∗ 𝑧 −2
Este modelo tiene el siguiente comportamiento ante una entrada de escalón unitario con
realimentación:
Figura 3 Respuesta de la planta identificada (motor DC) a una entrada escalón
Se puede observar que el tiempo de establecimiento es de 0.621 segundos, pero, no llega
al nivel de referencia y tiene un error de 0.64 por lo cual es necesario implementar un
control para obtener un mejor rendimiento del sistema.
Para encontrar los valores de las constantes del controlador PID se utilizó el método por
ubicación de polos con un PID cuya acción derivativa e integral están en configuración
Backward Euler de la siguiente manera:
Donde
𝑆0 𝑧 2 + 𝑆1 𝑧 + 𝑆2
𝐶 (𝑧 ) =
𝑧2 − 𝑧
𝑆0 = 𝐾𝑝 + 𝐾𝑖𝑇 +
𝑆1 = −𝐾𝑝 −
𝐾𝑑
𝑇
𝑆2 =
𝐾𝑑
𝑇
2𝐾𝑑
𝑇
Con 𝑇 = 0.05. Los parámetros para la ubicación de polos son
𝜁=1
𝜔=9
Donde la ecuación para ubicación de polos es
Donde
Δ𝑑 (𝑧) = (𝑧 2 + 𝑝1 𝑧 + 𝑝2 )(𝑧 + 𝑧0 )(𝑧 + 𝛼𝑑 )
𝑝1 = −2𝑒 𝜁𝜔𝑛 𝑇 𝐶𝑜𝑠(𝜔𝑑 𝑇)
𝑝2 = 𝑒 −2𝜁𝜔𝑛 𝑇
La forma general de la planta identificada es:
𝑏1 𝑧 + 𝑏2
+ 𝑎1 𝑧 + 𝑎2
Resolviendo:
Δ𝑃𝐶 (𝑧) =
Tenemos que:
Δ𝑃𝐶 (𝑧) ∗ 𝐶 (𝑧) = Δ𝑑 (𝑧)
𝑧2
𝑆0 = 5.03
𝑆1 = −4.795
𝑆2 = 0.9625
𝛼𝑑 = −0.6539
Pues bien, ahora se puede obtener los valores para la parte proporcional, integral y
derivativa. Por ende, los valores son los siguientes:
𝐾𝑝 = 4.07 ≈ 4
𝐾𝑖 = 23.9 ≈ 24
𝐾𝑑 = 0.0481 ≈ 0.05
Implementación del controlador PID en Arduino
La ecuación de un controlador PID es la siguiente[4]
𝑡
𝐶 (𝑠) = 𝐾𝑝 𝑒(𝑡) + 𝐾𝑖 ∫ 𝑒(𝜏)𝑑𝜏 + 𝐾𝑑
0
𝑑𝑒(𝑡)
𝑡
Obviamente esta ecuación no puede ser implementada en un controlador, por lo que se
utiliza su versión en ecuación a diferencias, en este trabajo se utilizó la siguiente ecuación
con corrimiento de dos muestras:
𝑢(𝑛) = 𝑢(𝑛 − 1) + 𝐾𝑝 [𝑒(𝑛) − 𝑒(𝑛 − 1)] + 𝐾𝑖 𝑒(𝑛)𝑇 −
𝐾𝑑
[𝑒(𝑛) − 2𝑒(𝑛 − 1) + 𝑒(𝑛 − 2)]
𝑇
Es importante filtrar de manera correcta la señal de entrega en encoder, para ello se utilizó
un filtro de media móvil exponencial
𝑦(0)
𝑡=0
𝑆 (𝑡 ) = {
𝛼𝑦(𝑡) + (1 − 𝛼)𝑆(𝑡 − 1) 𝑡 > 0
Con esto de puede obtener valores más centrados de las lecturas obtenidas del encoder.
Finalmente se realiza una saturación a la salida del controlador para que no haya
inconvenientes con el PWM de la tarjeta Arduino.
A continuación, el código implementado en Arduino:
// L298N
int pwm_salida = 6; //Pin PWM donde se envia las senial del controlador (u)
int IN1 = 2;
int IN2 = 4;
// Encoder
int pinA = 3;// Pin que lee los pusos generados
volatile int contador = 0; //Contador de pulsos
unsigned long previousMillis = 0;
long interval = 50;// Intervalo de lecturas
// Controlador PID (Variable utilizadas en la ecuacion a diferencias del PID)
float y = 0.0;
float u;
float un1 = 0;
float e1 = 0;
float e2 = 0;
float error;
float sp;
// Valores PID obtenidos por ubicacion de polos
float kp = 4;
float ki = 24;
float kd = 0.05;
float T = 0.05;
// Filtro digital
float alpha = 0.2; //Coeficiente de atenuacion de la senial
float y_print = y;// Salida filtrada de la senial del encoder
void setup() {
pinMode(pinA, INPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(pwm_salida, OUTPUT);
digitalWrite(IN1,HIGH);
digitalWrite(IN2,LOW);
Serial.begin(9600);
attachInterrupt(1,interrupcion,RISING);
}
void loop() {
unsigned long currentMillis = millis();// Lee los milisegundos transcurridos
desde el inicio
if((currentMillis - previousMillis) >= interval){// Si ha transcurrido el
timepo declarado en intervalo entra al if
previousMillis = currentMillis;// Asigna el valor del tiempo actual a
previousMillis para realizar otro intervalo
y = 2.0 * 10.0 * contador*(60.0/554.0);// Se obtiene el valor de la
velocidad de salida del motor
y_print = alpha*y + (1-alpha)*y_print;// Se filtra la senial obtenida
contador = 0;// Se reinicia el contador de pulsos.
}
//---------- SET POINT--------sp = analogRead(A0)*(69.0/1023.0);
error = sp-y;
// --------- Ecuacion a diferencias PID
--------------
u = un1+(kp*(error-e1))+(ki*T*error)-((kd/T)*((error-(2*e1))+e2));
e2 = e1;
e1 = error;
un1 = u;
// ------------Saturar salida PID ----------------if (u >= 255.0){
u = 255;
}
if(u <= 0.0){
u= 0;
}
analogWrite(pwm_salida,u);
Serial.print("sp: ");
Serial.print(sp);
Serial.print(", y: ");
Serial.println(y_print);
//Serial.print(", u: ");
//Serial.println(u);
//Serial.println(",");
delay(60);
}
void interrupcion(){
contador++;
}
Resultado y discusión
El desempeño del controlador se probó primero en matlab con una entrada tipo escalón
unitario obteniendo el siguiente resultado:
Figura 4 Respuesta de la planta (motor DC) con el controlador PID ante una entrada escalón
unitario
Tabla 1 Parámetros de respuesta de la planta (motor DC) con el controlador PID
Sobrepico
Tiempo de establecimiento
Valor en estado estable
0.13%
0.54 segundos
1
Lo que se puede observar en los resultados de la simulación es que el sistema es estable
y presenta un error de cero, se tarda aproximadamente 0.5 segundos en alcanzar el valor
de referencia con un 0.13% de sobrepico.
Al implementar el controlador en la tarjeta Arduino UNO se obtiene los siguientes
resultados:
Figura 5 Respuesta de la planta con las constante teóricas del PID
Esta respuesta muestra un sobrepico alrededor del 12 % por lo que se debe hacer un ajuste
manual para obtener una mejor respuesta del sistema. Después de realizar una calibración
manual cambiando los valores de las constantes PID se obtiene la siguiente respuesta:
Figura 6 Respuesta real de la planta (motor DC), salida con filtro digital
Estos valores se logran con los siguientes valores de constantes:
𝐾𝑝 = 4.0
𝐾𝑖 = 20.0
𝐾𝑑 = 0.01
En la figura 6, en el eje de las abscisas están el número de muestra, como se ve al final
del código de Arduino existe un delay de 60 milisegundos por lo que cada 125 muestras
corresponden a 7.5 segundos como se ve en la imagen. Tomando esto en cuenta el tiempo
de establecimiento es de alrededor 1.5 segundo, pero, esto se debe a que el filtro digital
que se utilizó para la señal del encoder añade una demora al iniciar el conteo de la
velocidad.
Figura 7 Respuesta real de la planta (motor DC) ante variaciones del setpoint, salida con filtro
digital.
En la figura 7 se puede ver que al ir variando el valor del setpoint (línea roja) el
controlador reacciona de manera rápida y sigue exitosamente el valor de referencia.
Cuando existen grandes variaciones del setpoint se puede ver que se demora más tiempo
en estabilizarse la salida del motor. Esto nuevamente se debe a que el filtro de la señal del
encoder se tarda en estabilizar la lectura en un valor.
Figura 8 Respuesta real de la planta (motor DC), salida sin filtro digital
En la imagen se muestra la salida de la velocidad del motor sin aplicar el filtro de media
movil exponencial. Aquí, se observa que el tiempo que realmente se demora en alcanzar
el setpoint es aproximadamente 0.5 segundos, tal como se obtuvo en la simulación del
sistema. Se ven sobrepicos debido al ruido de la señal que tiene el encoder.
Figura 9 Respuesta real de la planta (motor DC) ante variaciones del setpoint, salida sin filtro
digital.
En la imagen se observa la velocidad real del cambio de velocidad que tiene el sistema
cuando se modifica la señal de referencia. Esta es bastante rápida y sigue muy de cerca
los valores de referencia a la medida que van cambiando.
Conclusiones
•
•
•
El controlador PID implementado tiene un tiempo de establecimiento de 0.5
segundos, con un sobrepico imperceptible y un error igual a cero. Por lo que la
implementación del controlador permite cambiar la velocidad del motor de
manera rápida y fiable.
Es necesario filtrar la señal del encoder para lograr centrar las lecturas de
velocidad del motor. Caso contrario se obtiene valores con ruido que no permiten
visualizar bien el desempeño del controlador.
La identificación del sistema es lo bastante buena ya que los valores simulados y
los obtenidos experimentalmente son congruentes entre ellos, Ambos tienen un
tiempo de establecimiento similar, no presentan sobrepicos y el error es cero para
ambos casos.
Bibliografía
[1] S. K. Suman y V. K. Giri, “Speed control of DC motor using optimization
techniques based PID Controller”, en 2016 IEEE International Conference on
Engineering and Technology (ICETECH), Coimbatore, India, mar. 2016, pp. 581–
587. doi: 10.1109/ICETECH.2016.7569318.
[2] E. Yime, J. L. Villa, y J. Paez, “Design of a brushed DC motors PID controller for
development of low-cost robotic applications”, en 2014 III International Congress
of Engineering Mechatronics and Automation (CIIMA), Cartagena, Colombia, oct.
2014, pp. 1–4. doi: 10.1109/CIIMA.2014.6983471.
[3] Y. B. Koca, Y. Aslan, y B. Gokce, “Speed Control Based PID Configuration of a
DC Motor for An Unmanned Agricultural Vehicle”, en 2021 8th International
Conference on Electrical and Electronics Engineering (ICEEE), Antalya, Turkey,
abr. 2021, pp. 117–120. doi: 10.1109/ICEEE52452.2021.9415908.
[4] A. Ma’arif, Iswanto, N. M. Raharja, P. Aditya Rosyady, A. R. Cahya Baswara, y A.
Anggari Nuryono, “Control of DC Motor Using Proportional Integral Derivative
(PID): Arduino Hardware Implementation”, en 2020 2nd International Conference
on Industrial Electrical and Electronics (ICIEE), Lombok, Indonesia, oct. 2020, pp.
74–78. doi: 10.1109/ICIEE49813.2020.9277258.