Control de temperatura con PID

Presentado por:

 Daniela Poma Reátegui U18209918

 Aldo Canches Gonzales 9811165
 Stefano Renzo Herrera Buiza U19219977

Docente:
 Acuña Condori, Kevin

Control Moderno
 IMPLEMENTACION DEL PROYECTO:

MATERIALES:
- LM35
- MÓDULO REGULADOR DE VOLTAJE
- ARDUINO UNO
- FOCO INCANDESCENTE
- JUMPERS MACHO-HEMBRA
- CABLE Nº16
- SOCKET
 7. LM35 2. MÓDULO REGULADOR DE VOLTAJE
6.

3. ARDUINO UNO 4. FOCO INCANDESCENTE

5.

1. JUMPERS MACHO-HEMBRA 6. CABLE Nº16

2. 4.
 7. SOCKET
8.
Reconocimiento de puertos de placa reguladora de voltaje
 Sistema de Control de foco

Set Point Controlador Actuador

Computadora Arduino Dimmer Sistema

LM35

Sistema de primer orden con retardo

 La respuesta de un sistema de primer orden, depende del tipo de entrada que
recibirá el sistema.
−t
Y ( s) K K −θs K τ
s
G ( s )= = = e = e
U ( s) τs+1 τs+1 τs +1

∆ u=u2−u 1

−t
y ( t ) =K ∆ u ¿) = K ∆ u(1−e τ
s
)
Linealización:
 Con los datos obtenidos al variar la potencia (de 0 a 9), medimos la temperatura
correspondiente a cada porcentaje.

Programación de Arduino:
Código completo:
//Sistema PID de control de temperatura de un foco
//Definiendo modo operación
int Modo_op = 1; // Modo de operación 1: Modo manual (lazo abierto)
// Modo de operación 2: Modo automático (lazo cerrado)

// Parámetros para análisis retroalimentación

float potencia_1 = 0; // valor flotante inicial del cambio escalon unitario (mín = 0)
float potencia_2 = 100; // Valor flotante final del cambio escalón unitario (valor máx =
100)

float setpoint = 30; // en grados Celsius

// Constantes de PID
float Kc = 8; float Tao_I = 80;

int Tiempo0 = 0; // Retardo en milisegundos para ejecutar cambio escalón cuando

se encuentra
//a lazo abierto o cambio en el septpoint a lazo cerrado

////////////////////////////////////////////////////////////////////////////////////////////////////////

int A = 0; // Pin A0 de entrada analógica para sensor LM35 (Variable de salida)

float Potencia = 0; // Potencia inicial enviada al dimmer en rango de 0 a 100 (Variable
de entrada)

// Declaración de variables
int pin_disparo = 3;
int pin_cruce_cero = 8;
int Tiempo_seg=0;

int last_CH1_state = 0;
int detectado_cruce = 0;
int valor=0;

char recibido;
int potencia_recibida=0;
int pot_rec=0;

unsigned long Tiempo_previo = 0;

unsigned long Tiempo_actual = 0;
int Read_Delay = 1000; // Periodo de muestreo en ms
int temperatura = 0; // Grados Celsius
float sp = 0;

// Variables para PID

float PID_error = 0;
float previous_error = 0;
float PID_valor = 0;
float Error_INT = 0;

void setup() {
Serial.begin(9600);
//Definicion de pines
pinMode (pin_disparo,OUTPUT);
pinMode (pin_cruce_cero,INPUT);
PCICR |= (1 << PCIE0);
PCMSK0 |= (1 << PCINT0);
}

void loop() {

if (Serial.available()) {

recibido= Serial.read();

if (recibido =='m')
{Modo_op=1;}
else if (recibido=='M')
{Modo_op=2;}
else if (recibido=='a')
{sp=20;}
else if (recibido=='s')
{sp=25;}
 else if (recibido=='d')
{sp=30;}
else if (recibido=='f')
{sp=35;}
else if (recibido >= '0' && recibido <= '9')
{potencia_recibida=recibido - 48;
pot_rec=1;}
}

Tiempo_actual = millis(); // Tiempo Actual

//Generar la onda PWM de control detectado el cruce por cero

if (detectado_cruce)
{
if (valor ==0)
{
digitalWrite(3,HIGH);
}
else if (valor==100)
{
digitalWrite(3,LOW);
}
else
{
digitalWrite(3,LOW);
delayMicroseconds(valor);
digitalWrite(3,HIGH);
}

detectado_cruce=0;
Tiempo_seg+=1;
 }

//Chequeamos que hayan pasado 120 ciclo de la onda senoidal es decir 1 seg
if(Tiempo_seg==120){
Tiempo_seg=0;
temperatura = 5.0*100.0*analogRead(A)/1024.0; //Lectura del sensor LM35
//se divide entre 2 a la 10 bits para hallar
temperatura
//((5-0)100(dato analógico)))/2^10

if(Modo_op == 1){
// Modo manual (lazo abierto)
if(pot_rec=1) {
potencia_1 = potencia_recibida*10;
pot_rec=0;
}
Potencia = potencia_1;
}
else if(Modo_op == 2){
// Modo automatico (lazo cerrado)
PID_error = sp - temperatura; //Cálculo del error
Error_INT = Error_INT + PID_error*(1000/Read_Delay); //Cálculo de la integral
del error
PID_valor = Kc*(PID_error + (1/Tao_I)*Error_INT); //Cálculo de la salida del
controlador PI

// Limite de salida del controlador

if(PID_valor < 0)
{ PID_valor = 0; }
else if(PID_valor > 100)
{ PID_valor = 100; }
 Potencia = PID_valor; //Asignación a la entrada de la planta.
}

// Generar el tiempo de duracion del ciclo alto del pwm

valor= 100-Potencia * 7600 / 100;
//Enviar los parametros por puerto serial
Serial.print(Potencia);
Serial.print(" ");
Serial.print(temperatura);
Serial.print(" ");
Serial.println(sp);
}
}
//Definiendo interrupción
ISR(PCINT0_vect){
if(PINB & B00000001){ //verificamos si el pin 8 está en alto '1'
usando un AND
if(last_CH1_state == 0){ //si el último estado es 0, entonces
tenemos un cambio de estado
detectado_cruce=1; //se pasa al cambio de estado
}
else if(last_CH1_state == 1){ //si el pin 8 es bajo '0' y el último estado
es alto '1', entonces el estado cambia
detectado_cruce=1; //se detecta cambio
last_CH1_state = 0; //Se almacena el estado actual en el último
estado para que se dé el siguiente ciclo
}
}
}

Cuadro de datos del sensor LM35:

Valores Desviación Error al
Potencia Tiempo y (t )
estándar cuadrado
sensados
Se tomaron en total 210 valores para el sensado de temperatura. Todos los datos
calculados se muestran en las capturas del documento de Excel.

Función de transferencia
Para la función de transferencia de nuestro sistema de control de la temperatura de
un foco, se da una respuesta de primer orden:

K 1.32
=
τs+1 67.18 s +1

La curva azul representa a los valores tomados por el sensor (datos reales) y la curva
anaranjada representa a los valores calculados de la Función de transferencia.
No hay una gran exactitud; sin embargo, se aproxima bastante el modelo a los valores
sensados.
Sin embargo, para modelar en espacio de estados, se agregó un polo más para que
el sistema sea de segundo orden.
Modelamiento de espacio de estados
Debido a que es un sistema de primer orden, se agregó un polo para el modelamiento
en espacio de estados. Se multiplicó el primer polo x4 y con ello, se halló el segundo
polo:
K 1.32
G(s)= τs+1 => G*(s)= ( 67.18 s+1 )∗( s +0.06 )

La Función de transferencia para el sistema es la del bloque mostrado. Se modeló de

esa forma para que los cálculos sean más prácticos.
Seguidamente, se usó esta FT para calcular el modelamiento en espacio de estados.
Se emplearon los cálculos aprendidos en clases para hallar las matrices.

Cálculos:

22∗U ( s ) =Y ( s )∗( 1119.67 s +83.85 s +1 ) 1119.67 ÿ + 83.85 ẏ + y =22∗u ( t )

2

x 1= y , x 2= ẏ , x 3= ÿ , x˙1= ẏ=x 2, x˙2= ÿ=x 3

Despejando ÿ para hallar x˙2

22∗u(t ) 83.85∗x 2 x1
x˙2= − −
1119.67 1119.67 1119.67

Definiendo coeficientes:
Luego de calcular e igualar, se modeló en espacio de estados de tal forma que
cumplan con el diagrama de bloques de la teoría de modelamiento:
Matlab y Simulink
Primero se quiso ver la respuesta usando la FT de segundo orden de nuestra planta:
Se usaron Script y Simulink para verificar las respuestas ante un escalón.
Luego, se agregó la Temperatura inicial (T0 = 21°C) y así vemos su respuesta ante un
escalón, mediante la herramienta Scope:
Para ver la respuesta en modelamiento de espacio de estados, primero se definieron
las matrices anteriormente calculadas:

Se usó tanto un Bloque de espacio de estados ya dado por Simulink y a la vez se

armó el diagrama de simulación. Ambos tienen que ser iguales.
Se puede ver que sí cumple, ya que se superponen entre ambas respuestas.

El sistema es sobreamortiguado, y esto se puede verificar con la FT hallada

anteriormente y el Modelamiento en espacio de estados.
Es lógico que nuestro sistema tenga este tipo de respuesta, ya que los dos polos son
negativos.
4
Su tiempo de establecimiento es aproximadamente de Tss= =269 s. Se tomó el polo
σ1
dominante, el cuál es -1/67.18.

Ley de control
Para que nuestro sistema tenga una salida a un punto de referencia fijo, en presencia
de disturbios, se procedió a aplica la Ley de Control.
En este caso, hicimos los cálculos sin referencia. Por tanto, el u=−kx . Con ello, se
reemplaza y se resuelve:

r=0

|( ) (
0
ẋ= Ax+ B (−kx ) sIX ( s )= AX ( s ) + B (−k ) X ( s )( sI− A+ Bk ) X ( s )=0 det ( sI − A +Bk ) = s 1 0 − −1 −
0 1
1119.67 11

|( ) ( )( )|
0 1 0 0
s 0
¿ − −1 −83.85 + 22 22
0 s k1 k2
1119.67 1119.67 1119.67 1119.67
 |( |
s −1
¿ 1
+
22
1119.67 1119.67
k1 ) (s + 1119.67
83.85
+
1119.67 )
22
k2

¿ s2 + ( 1119.67
83.85
+
22
1119.67
k 2 ) s+ (
1119.67 1119.67 )
1
+
22
k1

Siguiendo la teoría, se procede a hallar la ecuación deseada para nuestro sistema y

se iguala a la ecuación calculada de realimentación.

Luego de hallar los K, se modela en Simulink para verificar que cumplan como
reguladores.

Ley de control en Simulink:

En el Script se define C=eye(2) para que pueda coincidir con el número de matrices y
el D se tomó como [0;0].

En Simulink, se agregaron k1 y k2, y además se definió el valor de C que ya se había

calculado anteriormente. El cual, en realidad es un matriz C = [1 0].
Además, se le agregó la Temperatura inicial de nuestro sistema (T0 = 21) y así
verificar que se estabilice.

Como se puede observar en el Scope, nuestro sistema primero sufre una gran
oscilación, pero sí llega a un ess = 0 luego de unos segundos. Ante un disturbio, sí
llega a estabilizarse. Por tanto, los cálculos realizados sí están correctos y los valores
de k1 y k2 sí sirven como reguladores.

Conclusiones:
- El sistema es sobre amortiguado debido a que los 2 polos son negativos
- Asimismo, el sistema, se estabiliza con un tiempo de establecimiento en 269
segundos. Es posible evidenciar que la respuesta temporal de este sistema es
sobre amortiguada. 

Recomendaciones:
- Para lograr enfriar el foco y tomar las muestras más rapido se recomienda
colocar un ventilador cerca del foco para acelerar el enfriamiento.
- Asimismo, se recomienda tomar la medida de los valores de temperatura,
contando el valor de temperatura de medio ambiente.
Link de exposición y presentación del sistema funcionando

Exposiciones:
https://youtu.be/znUeCmGcwLs
Presentación de Sistema en funcionamiento:
https://youtu.be/46xuS3YCaMg