Como implementar e integrar um controlador PID no Python com Aveva Process Simulation?

[Michael Philippe]

Olá meus caros boa tarde, venho até vocês hj, estou tendo dúvidas de como implementar um controlador PID no python, estou desenvolvendo uma dissertação de mestrado cujo um dos objetivos e implementar um controlador PID no python e integrar em uma planta de hidrogênio verde ,porem estou com duvidas sobre a implementação do mesmo, a dúvida e sobre como integrar o controlador PID no python com o aveva process simulation, que e um software de simulação de processos, se alguem poder me ajudar ficaria muito grato.

 

import numpy as np
import matplotlib.pyplot as plt

class PIDController:
    def __init__(self, Kp, Ki, Kd, setpoint):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.setpoint = setpoint
        self.integral = 0
        self.previous_error = 0

    def compute_control_signal(self, measurement, dt):
        error = self.setpoint - measurement
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt
        self.previous_error = error
        control_signal = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
        return control_signal

def simulate_plant(A, B, C, D, u, x):
    x_next = np.dot(A, x) + np.dot(B, u)
    y = np.dot(C, x) + np.dot(D, u)
    return x_next, y

# Modelo da planta
A = np.array([[1.0]])
B = np.array([[0.5]])
C = np.array([[1.0]])
D = np.array([[0.0]])

# Inicialização do controlador PID
Kp = 1.2
Ki = 1.0
Kd = 0.01
setpoint = 1.0
pid_controller = PIDController(Kp, Ki, Kd, setpoint)

# Simulação
num_steps = 100
dt = 1  # passo de tempo
y_values = []
u_values = []
x = np.zeros(A.shape[0])

for _ in range(num_steps):
    y = np.dot(C, x)
    u = pid_controller.compute_control_signal(y, dt)
    x, y = simulate_plant(A, B, C, D, u, x)
    y_values.append(y)
    u_values.append(u)

# Plotando os resultados
plt.figure(figsize=(12, 6))
plt.subplot(2, 1, 1)
plt.plot(y_values, label='Saída (y)')
plt.plot([setpoint] * num_steps, 'r--', label='Alvo')
plt.legend()
plt.title('Saída da Planta')

plt.subplot(2, 1, 2)
plt.plot(u_values, label='Sinal de Controle (u)')
plt.legend()
plt.title('Sinal de Controle')
plt.xlabel('Tempo (passos)')

plt.tight_layout()
plt.show()
 

[Tiago Neves]

Fala, @Michael Philippe!

Quando brinquei com automação industrial (CLP) usava sempre a conexão OPC para se comunicar com  o servidor OPC do AVEVA ou qualquer software de simulação de processos.

Eu acho que tá faltando isso aí para você começar.

[Michael Philippe]

Fala Tiagao, entao mano, eu estou utilizando o aveva process simulation 2024, ja tenho conhecimento da comunicação OPC e matricon, mas eu ja fiz a comunicação do aveva com o python, e  agora meu orientador me pediu para eu implementar um controlador PID simples, e depois chamar o APS ,  a dúvida e justamente essa, e chamar o APS depois de ja ter o controlador PID pronto , mas vou dar uma olhada nessa comunicação OPC sim vlw.

[Tiago Neves]

import numpy as np
import matplotlib.pyplot as plt
import OpenOPC
import time

class PIDController:
    def __init__(self, Kp, Ki, Kd, setpoint):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.setpoint = setpoint
        self.integral = 0
        self.previous_error = 0

    def compute_control_signal(self, measurement, dt):
        error = self.setpoint - measurement
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt
        self.previous_error = error
        control_signal = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
        return control_signal

# Inicialização do controlador PID
Kp = 1.2
Ki = 1.0
Kd = 0.01
setpoint = 1.0
pid_controller = PIDController(Kp, Ki, Kd, setpoint)

# Conectando ao servidor OPC
opc = OpenOPC.client()
opc.connect('Nome_do_Servidor_OPC')

# Simulação
num_steps = 100
dt = 1  # passo de tempo
y_values = []
u_values = []

for _ in range(num_steps):
    # Ler a variável de processo do AVEVA
    y = opc.read('Caminho/Para/Variavel/Y')[0]
    
    # Calcular o sinal de controle usando o PID
    u = pid_controller.compute_control_signal(y, dt)
    
    # Enviar o sinal de controle para o AVEVA
    opc.write(('Caminho/Para/Variavel/U', u))
    
    # Armazenar valores para plotagem
    y_values.append(y)
    u_values.append(u)
    
    # Aguardar o próximo passo
    time.sleep(dt)

# Desconectar do servidor OPC
opc.close()

# Plotando os resultados
plt.figure(figsize=(12, 6))
plt.subplot(2, 1, 1)
plt.plot(y_values, label='Saída (y)')
plt.plot([setpoint] * num_steps, 'r--', label='Alvo')
plt.legend()
plt.title('Saída da Planta')

plt.subplot(2, 1, 2)
plt.plot(u_values, label='Sinal de Controle (u)')
plt.legend()
plt.title('Sinal de Controle')
plt.xlabel('Tempo (passos)')

plt.tight_layout()
plt.show()

Ficaria assim com a comunicação com o OPS.

https://pypi.org/project/OpenOPC-DA/

[Michael Philippe]

no caso vou utilizar so  o python mesmo sem o OPC