UD05 · Taller 3 — Sistema experto como controlador de un proceso¶

1
2
3
4
5

import collections, collections.abc
if not hasattr(collections, 'Mapping'):
    collections.Mapping = collections.abc.Mapping
    collections.Iterable = collections.abc.Iterable
    collections.MutableMapping = collections.abc.MutableMapping

Objetivo: implementar un controlador experto que regule la temperatura de una sala, definiendo las especificaciones de respuesta (CE d) y observando cómo influye en el comportamiento del sistema (CE e).

Fase 1 — La planta (modelo simple)¶

1
2
3

def simular_planta(temp, potencia, dt=1.6, inercia=0.05, exterior=15.0):
    """Modelo simple de una sala con inercia térmica."""
    return temp + inercia * (exterior - temp) + potencia * dt

Fase 2 — El controlador experto¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

from experta import P  # constraint de predicado: envuelve el lambda

class ControladorClima(KnowledgeEngine):
    def __init__(self, setpoint=21.0):
        super().__init__()
        self.setpoint = setpoint
        self.potencia = 0.0

    @DefFacts()
    def inicio(self):
        yield Fact(controlar=True)

    @Rule(Fact(controlar=True), salience=10)
    def leer(self):
        # simula la lectura del sensor
        error = self.setpoint - self._temp
        self.declare(Fact(error=round(error, 2)))

    @Rule(Fact(error=P(lambda e: e > 3)))
    def alta(self):
        self.potencia = 1.0

    @Rule(Fact(error=P(lambda e: 0 < e <= 3)))
    def media(self):
        self.potencia = 0.5

    @Rule(Fact(error=P(lambda e: -1 <= e <= 0)))
    def baja(self):
        self.potencia = 0.2

    @Rule(Fact(error=P(lambda e: e < -1)))
    def apagar(self):
        self.potencia = 0.0

    def paso(self, temp):
        self._temp = temp
        self.reset()
        self.run()
        return self.potencia

ctrl = ControladorClima(setpoint=21.0)
temp = 15.0
for i in range(80):
    potencia = ctrl.paso(temp)
    temp = simular_planta(temp, potencia)
    if i % 5 == 0:
        print(f"t={i:3d}: temp={temp:.2f}  potencia={potencia:.2f}")

Con estos parámetros, la temperatura entra en la banda 20,5-21,5 ºC hacia el paso 5 y se estabiliza en torno a 21,4 ºC, dentro de la especificación.

Fase 3 — Mide las especificaciones de respuesta¶

Añade código para medir:

• Error en régimen permanente (temperatura final − setpoint).
• Tiempo de asentamiento (en qué paso entra en la banda 20,5-21,5 ºC, y no vuelve a salir).
• Sobreimpulso (¿supera alguna vez 21,5 ºC?).

Fase 4 — Añade una perturbación¶

En el paso 40, cambia la temperatura exterior a 5 ºC (ventana abierta) y observa cómo responde el controlador. ¿Mantiene la temperatura en la banda?

Fase 5 — Analiza la sensibilidad¶

Cambia el umbral de la regla media (de 3 a 1,5) y compara la respuesta. ¿Qué pasa con el sobreimpulso? ¿Y con el tiempo de asentamiento? Registra los valores en una tabla.

Fase 6 — Compara con un PID (conceptual)¶

Dibuja (o describe) cómo respondería un PID sintonizado frente al controlador experto y explica qué ventaja tiene cada uno. ¿Cuándo usarías cada uno?

Entrega del Taller 3¶

Recopila la simulación y las explicaciones de las seis fases en una memoria en PDF.

Y la respuesta a: ¿qué relación tiene un sistema experto con los sistemas híbridos reglas/datos y la lógica difusa? ¿Cuándo usarías cada uno?

Volver a la UD05 · Taller 1 · Taller 2 · Ejercicios