Objetivo.
Demostrar cómo controlar sistemas conmutados. La temperatura de la bombilla aumenta
al encenderla y la temperatura de la bombilla disminuye al apagarla (hasta los límites
ambientales). La bombilla es un sistema binario con sólo dos estados, encendido o
apagado. La bombilla está conectada a la fuente de CA o no; su intensidad no se puede
modular. En este experimento, observamos el comportamiento de "vibración" resultante
de la bombilla e investigamos metodologías alternativas para reducir la frecuencia de esta
vibración, o suavizarla, mediante el uso de bandas muertas, filtros de paso bajo y
modulación de ancho de pulso. Esta actividad también proporciona exposición al control
proporcional (P).
Marco teórico
Control P y PI:
Un método de control más sofisticado modularía la bombilla en proporción al error de
temperatura (y más tarde, también en proporción a la integral del error). En otras
palabras, si la bombilla estuviera demasiado fría (error grande), se encendería
intensamente, pero si la bombilla estuviera sólo un poco fría (error pequeño), solo se
encendería débilmente. Este enfoque, donde el esfuerzo de control es proporcional al
error, se llama Control Proporcional o Control P. Matemáticamente, esto se expresa
como. Este enfoque de control no logrará un mejor rendimiento en comparación con las
estrategias ON/OFF empleadas hasta ahora, pero la dinámica de este sistema es lo
suficientemente lenta y comprensible como para que este ejercicio nos ayude a manejar
mejor el control de P y PI tal como se aplica en otras situaciones.
Control P:
En nuestro sistema, controlamos la temperatura de la bombilla conectándola y
desconectándola alternativamente de la fuente de alimentación de CA. Como tal, no
podemos modular la intensidad de la bombilla, ya sea que esté conectada a la fuente de
energía o no. Sin embargo, podemos aproximarnos a una estrategia de control P continúa
utilizando lo que se denomina modulación de ancho de pulso (PWM). En la modulación
por ancho de pulso, la señal de entrada es un tren de pulsos (una onda cuadrada) con un
período constante (frecuencia) que cambia entre 1 y 0 (completamente encendido y
apagado, como lo hemos hecho aquí). La "intensidad" del control se ve entonces afectada
cambiando el porcentaje de tiempo que la entrada está "activada". Este porcentaje se
llama ciclo de trabajo. A continuación, se muestra una representación de una señal PWM.
Considerando un sistema de primer orden, como el que tenemos aquí, puedes imaginar
cómo se vería la temperatura de la bombilla si el período de la señal PWM fuera muy
largo. Tendría una respuesta escalonada de primer orden que aumenta hasta algún valor
de estado estable (cuando está encendido), seguida de una temperatura que desciende a
ambiente (cuando está apagado). En la práctica, sin embargo, el período de la señal PWM
se hace pequeño (frecuencia grande) en comparación con la dinámica del sistema que se
controla, de modo que no hay mucho tiempo para que la salida suba o baje. Por lo tanto,
modular el ciclo de trabajo de una entrada PWM puede lograr una salida que cambia
aproximadamente sin problemas. El modelo que se muestra a continuación implementa
una estrategia de control P para nuestro sistema de bombillas. La señal PWM se
implementa mediante el bloque de escritura analógica que se muestra. Este bloque
representa el ciclo de trabajo como un número de 8 bits (). Por lo tanto, la entrada al
bloque de escritura analógica debe estar entre 0 y 255, donde 0 corresponde a un ciclo de
trabajo y 255 se asigna a un ciclo de trabajo. Se incluye el bloque de saturación para
capturar estos límites. La señal PWM sale por el Pin Digital 9 que hemos estado utilizando.
Los pines digitales que pueden generar una salida PWM se indican con el símbolo ~ en la
placa Arduino.
Control PI:
Agregar un término a nuestro controlador que sea proporcional a la integral del error nos
da lo que se denomina Controlador Integral Proporcional o Controlador PI para abreviar.
Matemáticamente, este controlador tiene la forma C(s) = Kp + Ki/s. Un controlador de este
tipo hace que el sistema de control de retroalimentación sea de tipo 1, por lo tanto,
debería reducir el error de estado estacionario a una referencia constante (un paso en
esencia) a cero. Al examinar la nueva función de transferencia de circuito cerrado que se
muestra a continuación, podemos investigar esto.
Desarrollo
En este experimento, se utiliza una bombilla incandescente de 25 W como planta para
controlar su temperatura. Se emplea un sensor de temperatura TMP36 para medir la
temperatura en grados Celsius. El sensor está conectado a una placa Arduino y se utiliza
un conductor térmico epoxi para unirlo a la superficie de la bombilla. La bombilla se
enciende y apaga mediante un relé de estado sólido, que se controla con una señal de 5 V
desde la placa Arduino. El relé se inserta en el cable neutro de la bombilla para evitar
conexiones cuando está apagado. La elección del TMP36 se debe a su bajo costo, precisión
y facilidad de uso, siendo comúnmente incluido en kits de inicio de Arduino. El
experimento tiene como objetivo controlar la temperatura de la bombilla utilizando estos
componentes y configuraciones de hardware.
Conexión de los elementos:
En este experimento, se utiliza una bombilla incandescente de 25 W como planta para
controlar su temperatura. Se emplea un sensor de temperatura LM35 para medir la
temperatura en grados Celsius. El sensor está conectado a una placa Arduino y se utiliza
un conductor térmico epoxi para unirlo a la superficie de la bombilla. La bombilla se
enciende y apaga mediante un relé de estado sólido, que se controla con una señal de 5 V
desde la placa Arduino. El relé se inserta en el cable neutro de la bombilla para evitar
conexiones cuando está apagado.
Sensor de temperatura (LM35):
El sensor LM35 tiene tres pines: alimentación (VCC), señal (análogo) y tierra (GND). El pin
de alimentación (VCC) se conecta a una fuente de alimentación de 2,7 V a 5,5 V desde la
placa Arduino. El pin de señal se conecta a una de las entradas analógicas (por ejemplo,
A0) de la placa Arduino.
El pin de tierra (GND) se conecta a la tierra (GND) de la placa Arduino.
Bombilla Incandescente:
La bombilla incandescente se enciende y apaga usando un relé de estado sólido. Uno de
los cables de la bombilla se corta y se conecta al relé en el lado del neutro. Esto significa
que la corriente pasa a través del relé cuando está encendido, completando el circuito de
la bombilla. El otro extremo de la bombilla se conecta de nuevo al circuito para cerrar el
circuito cuando el relé está activado. El relé está controlado por una salida digital (por
ejemplo, pin 6) de la placa Arduino. La señal de control del relé proviene de una salida
digital de 5 V de la placa Arduino.
La salida analógica del sensor de temperatura se utiliza para medir la temperatura actual y
controlar el sistema. La placa Arduino lee esta señal y determina la acción de control
necesaria (encender o apagar la bombilla). Basándose en la lectura del sensor, la placa
Arduino ajusta la señal de control enviada al relé de estado sólido, lo que a su vez
enciende o apaga la bombilla según sea necesario para mantener la temperatura
controlada.
La conexión del sistema se ejemplifica en el siguiente diagrama:
Ilustración 1. Conexión del sistema.
Por lo que, al hacer la conexión de los elementos, se verá de la siguiente forma:
.
Control P:
Los datos obtenidos por segundo se muestran en la siguiente gráfica:
Temperatur Vs Ciclo de trabajo
180
160
140
120
100
80
60
40
20
0
1 55 109 163 217 271 325 379 433 487 541 595 649 703 757 811 865 919 973 1027 1081
Temperatura Duty
Erros vs Ciclo de trabajo
180
160
140
120
100
80
60
40
20
0
1 64 127 190 253 316 379 442 505 568 631 694 757 820 883 946 10091072
-20
Duty Error:
Como podemos ver el error es proporcional al ciclo de trabajo, por otro lado a medida que
la temperatura se acerca a la referencia el error decrece., pero se mantiene lo mas
cercano posible a la referencia.
Para el código de Arduino:
int pinAnalog = A0;
int valor;
int ref = 75;
int retardo = 0;
int pinTemp = 6;
int a = 0;
int b = 100;
int c = 0;
int d = 255;
void setup() {
Serial.begin(9600);
pinMode(A0, INPUT);
pinMode(pinTemp, OUTPUT);
}
void loop() {
valor = analogRead(pinAnalog);
float temp = (5.0 * valor * 100.0)/1024.0; // Convierte el voltaje a
temperatura en grados Celsius
int error = ((ref - temp) / ref) * 100;
float dutyCycle = map(error, a, b, c, d);
dutyCycle = constrain(dutyCycle, c, d); // Asegura que el dutyCycle esté
en el rango de 0 a 255
if (error <= 0) {
digitalWrite(pinTemp, 1);
} else {
analogWrite(pinTemp, int(dutyCycle));
}
retardo = retardo + 1;
Serial.print(retardo);
Serial.print(", Temperatura °C, ");
Serial.print(temp);
Serial.print(", Duty:, ");
Serial.print(dutyCycle);
Serial.print(", Erro r:, ");
Serial.println(error);
delay(1000); // Espera 1 segundo (ajusta según sea necesario)
}
Su funcionamiento es el siguiente:
Claro, este código está diseñado para controlar la temperatura de una bombilla
incandescente usando un sensor de temperatura LM35 y un relé de estado sólido, junto
con un Arduino Mega:
1. **Definición de Pines y Variables:**
- `pinAnalog` se configura como la entrada analógica A0, conectada al sensor de
temperatura LM35.
- `pinTemp` se configura como el pin de salida digital 6, que controla el relé de estado
sólido para encender y apagar la bombilla.
- `ref` representa la temperatura de referencia que se desea mantener (75 grados
Celsius).
- `a`, `b`, `c`, y `d` son valores utilizados para mapear el error en un rango adecuado para
el PWM.
2. **Configuración Inicial:**
- `Serial.begin(9600);` inicia la comunicación serial para la depuración.
- `pinMode(A0, INPUT);` configura el pin A0 como entrada para leer los valores del
sensor de temperatura.
- `pinMode(pinTemp, OUTPUT);` configura el pin 6 como salida para controlar el relé de
estado sólido.
3. **Bucle Principal (`bucle`):**
- Se lee el valor del sensor de temperatura y se convierte en grados Celsius.
- Se calcula el error como la diferencia entre la temperatura de referencia (`ref`) y la
temperatura medida (`temp`).
- El error se convierte en un valor de ciclo de trabajo (duty Cycle) utilizando la función
`map` para mapear el error a un rango de 0 a 255.
- Si el error es menor o igual a 0, lo que significa que la temperatura medida es mayor o
igual a la temperatura de referencia, se enciende la bombilla al máximo (ciclo de trabajo
255). Si no, se ajusta el ciclo de trabajo según el error.
- Se imprime el número de iteración (`retardo`), la temperatura medida, el ciclo de
trabajo y el error en la comunicación serial.
- Hay un retardo de 1 segundo antes de la siguiente iteración.
Este código implementa un controlador de temperatura proporcional (P). Si la medida de
temperatura está por debajo de la referencia, la bombilla se encenderá a una intensidad
proporcional al error. El valor del error determina el ciclo de trabajo del PWM que
controla la bombilla, lo que permite regular la temperatura hacia el valor de referencia.
Recuerde que el éxito del control dependerá de la precisión y estabilidad del sensor LM35,
así como de la respuesta de la bombilla a los cambios en el ciclo de trabajo.
Control PI:
Los datos obtenidos por segundo se muestran en la siguiente gráfica:
Temperatura vs Ciclo de trabajo
250
200
150
100
50
0
1 14 27 40 53 66 79 92 105118131144157170183196209222235248261274287300313326339
Temperatura Duty
Ciclo de trabajo vs Error
250
200
150
100
50
0
1 14 27 40 53 66 79 92 105118131144157170183196209222235248261274287300313326339
Duty Error
Como podemos ver este control se mantiene mas cerca de la referencia, sin embargo, nel
ciclo de trabajo se mantiene mucho mas alto.
int pinAnalog = A0;
int valor;
int ref = 75;
int retardo = 0;
int pinTemp = 6;
int a = 0;
int b = 100;
int c = 0;
int d = 255;
float kp = 1.0;
float ki = 0.001;
float integrador[2];
void setup() {
Serial.begin(9600);
pinMode(A0, INPUT);
pinMode(pinTemp, OUTPUT);
integrador[0] = 0;
integrador[1] = 0;
}
void loop() {
valor = analogRead(pinAnalog);
float temp = (5.0 * valor * 100.0)/1024.0; // Convierte el voltaje a
temperatura en grados Celsius
int error = ((ref - temp) / ref) * 100;
integrador[1] = (kp*error) + (ki*integrador[0]);
float dutyCycle = map(integrador[1], a, b, c, d);
dutyCycle = constrain(dutyCycle, c, d); // Asegura que el dutyCycle esté
en el rango de 0 a 255
analogWrite(pinTemp, int(255-dutyCycle));
retardo = retardo + 1;
Serial.print(retardo);
Serial.print(", Temperatura °C, ");
Serial.print(temp);
Serial.print(", Duty:, ");
Serial.print(255-dutyCycle);
Serial.print(", Error0:, ");
Serial.print(kp*error);
Serial.print(", Error1:, ");
Serial.println(integrador[0]);
integrador[0] = integrador [1];
delay(1000); // Espera 1 segundo (ajusta según sea necesario)
}
1. **Definición de Pines y Variables:**
- `kp` y `ki` son los coeficientes del controlador proporcional-integral.
- `integrador` es un arreglo de dos elementos utilizados para implementar el término
integral del control PI.
2. **Configuración Inicial:**
3. **Bucle Principal (`bucle`):**
- Se lee el valor del sensor de temperatura y se convierte en grados Celsius.
- Se calcula el error como la diferencia entre la temperatura de referencia (`ref`) y la
temperatura medida (`temp`).
- Se calcula el término proporcional (`kp * error`) y el término integral (`ki *
integrador[0]`) del control PI.
- Estos términos se suman para obtener el valor del control PI (`integrador[1]`).
- El valor del control PI se utiliza para ajustar el ciclo de trabajo del PWM del relé de
estado sólido, de modo que se enciende o apaga la bombilla para mantener la
temperatura controlada.
- Se imprime el número de iteración (`retardo`), la temperatura medida, el ciclo de
trabajo (calculado como `255 - dutyCycle` para invertir el PWM), y los valores del término
proporcional y del término integral en la comunicación serial.
- El valor del término integral se almacena en `integrador[0]` para usarlo en la siguiente
iteración.
Este código implementa un controlador de temperatura PI que ajusta el ciclo de trabajo
del relé de estado sólido para mantener la temperatura medida lo más cerca posible de la
temperatura de referencia. Los términos proporcionales e integrales del control PI se
utilizan para ajustar la respuesta del sistema a las variaciones de temperatura.
Conclusión:
Entre ambos controles, el control PI fue el que mantuvo un ciclo de trabajo más estable,
es decir, que este no variaba tanto, además el foco se mantuvo encendido por periodos
más largos, sin embargo, esto hacía que se mantuviera más tiempo apagado y que tardara
más en poder alcanzar la temperatura deseada, por otro lado el control P tardaba menos
es alcanzarla.
