Como implementar um controlador semelhante ao PID auto-ajustável

Estou tentando escrever um programa de microcontrolador para controlar a temperatura em um sistema com as seguintes características:

• a saída só pode ser ligada ou desligada, com frequências de ciclo fixas (~ 2-10 por hora)
• A planta demora a responder (mudanças mensuráveis ​​de temperatura demoram mais de 10 minutos).
• A planta perde a temperatura com base nas condições ambientais.
• o ponto de ajuste pode variar em grandes etapas com base na demanda do usuário.

Estou escrevendo um controlador que visa minimizar o erro, além de seguir a taxa de ciclo fornecida como entrada.

Isso pode ser feito facilmente com um controlador PI e sua saída é convertida no ciclo de trabalho. O problema é que o programa precisa ajustar automaticamente e escolher constantes Kp, Ki corretas e adaptar-se a condições ambientais variadas e mudanças na capacidade de aquecimento. Portanto, o ajuste antecipado do controlador PI não é muito útil.

Usar um PI ou PID real não é um requisito. Estou aberto a usar o Fuzzy-Logic, se ajudar, também possui um algoritmo de aprendizado de máquina no chip que modela a resposta do sistema e a perda de calor (aprox. Linear), o que sugere informações sobre a resposta da etapa medida . Só não sei o que fazer com essa informação.

Algumas postagens sugerem que eu poderia usar os dados de modelagem para ajustar o PI on-line, bem como o manual de visualização em laboratório que sugere que eu poderia usar o Fuzzy-Logic para ajustar o PI.

Minha pergunta é: qual é a melhor abordagem para esse tipo de cenário (por exemplo, PID, difuso-pid, convolução etc.) e como eu iria implementá-lo de fato no software / prática.

Eu não sou um EE, então qualquer entrada seria muito apreciada.

Eu não chegaria a ponto de chamar o PID desatualizado. Mas certamente há espaço para melhorias. Uma maneira pela qual ajustei automaticamente os loops de controle PID é usar o método Nelder-Mead, que é uma forma de algoritmo simplex de escalada . Ele tem o benefício de poder convergir e reconvergir em um parâmetro de destino que se move ao longo do tempo.

A partir deste artigo :

Por exemplo, no nosso caso de ajuste PID parâmetros {K _P , K _I , K _D } um simplex é tetraedro. Nelder – Mead gera uma nova posição de teste do simplex extrapolando o comportamento da função objetivo medida em cada ponto de teste organizado como o simplex. O algoritmo escolhe substituir um desses pontos de teste pelo novo ponto de teste e, assim, a técnica avança.

Minha aplicação particular era para controle motor. Tivemos dois loops, um loop de controle de corrente PID e um loop de controle de velocidade PI. Definimos nossos vértices para P, I e D, respectivamente, e executamos estatísticas na saída do loop. Em seguida, executamos a reflexão, a expansão, a contração e a redução repetidas vezes até que os alvos de controle de corrente ou velocidade gerados estivessem dentro de alguns desvios padrão.

Com o nosso produto, o vice-presidente estava muito preocupado com a forma como o motor "soava". E, como se viu, "soou" melhor quando o alvo atual saltou um pouco mais do que era matematicamente ideal. Assim, nosso ajuste foi feito "ao vivo", pois permitimos que o algoritmo procurasse enquanto o motor estava funcionando, para que a percepção do usuário sobre o som do motor também fosse levada em consideração. Depois de encontrarmos os parâmetros que gostamos, eles foram codificados e não foram alterados.

Provavelmente, isso não seria ideal para você desde que você declara: "colocar o sistema em oscilação mesmo que uma parte do autoajuste não seja aceitável para os usuários". Nosso sistema certamente oscilaria e faria outras coisas horríveis enquanto fazia o autoajuste.

No entanto, você pode executar duas cópias do controlador PID. Um que era "ao vivo" e realmente controlava o processo. E um segundo que estava sendo constantemente ajustado automaticamente enquanto alimentava as mesmas entradas que o controlador "ativo". Quando a saída do controlador auto-sintonizado se tornar "melhor" ou mais estável, você poderá trocar os coeficientes pelo controlador "ativo". O controlador executaria correções no processo até que o desempenho desejado fosse alcançado. Isso impediria oscilações que podem ser percebidas pelo usuário durante o autoajuste. Porém, se as entradas mudarem drasticamente e o controlador PID não for mais ideal, o autoajuste poderá trocar novos coeficientes assim que estiverem disponíveis.

Um controlador PID é útil em situações em que o comportamento do sistema que está sendo controlado pode ser razoavelmente aproximado como sendo uma soma do estímulo de controle, a integral do estímulo de controle e a integral dessa primeira integral. Alguns sistemas de controle de temperatura podem satisfazer esse critério, se houver um objeto que é aquecido uniformemente pelo estímulo, e se esse objeto transferir calor uniformemente para outro objeto a uma taxa proporcional à diferença de temperatura entre eles. Por exemplo, o primeiro objeto pode ser um elemento de aquecimento e o segundo objeto pode ser o ar que circula em uma sala, se houver circulação de ar suficiente para que o ar seja considerado como tendo uma única temperatura uniforme. Para modelos térmicos mais complicados do que isso (por exemplo, aqueles que podem envolver gradientes térmicos em um meio sólido),

Eu sugeriria que uma boa abordagem seria fazer com que o controlador, quando o aquecedor estiver ligado, estime continuamente o quão quente o dispositivo sendo regulado ficaria se a saída fosse desligada imediatamente e a temperatura na qual ele acabaria esfriando se o aquecedor foi ligado assim que permitido depois disso. Estime também quais seriam esses valores se o aquecedor fosse deixado por mais um segundo, dois segundos, três segundos etc. Desligue o aquecedor quando esses valores estiverem tão bons quanto possível. Depois que o aquecedor estiver desligado, comece a executar cálculos semelhantes, mas trocando os papéis de ligado / desligado, quente / frio etc., para decidir quando ligar novamente. Dependendo do comportamento térmico do sistema, pode ser necessário usar uma estratégia de previsão de 'mínimo / máximo' para dar um passo ou dois à frente.

Ser capaz de alterar o estado do controle (ativado ou desativado) de 2 a 10 vezes por hora não se presta ao controle do ciclo de serviço. A saída de um loop PI será um sinal de controle que varia em magnitude em função do erro, e sua planta pode (realisticamente) aceitar apenas uma entrada binária (desativada ou ativada), já que a 'frequência' do controle o ciclo de trabalho que pode ser aceito é uma fração de um hertz.

Você pode simplificar as coisas e usar o controle histérico:

• o sistema liga quando a temperatura ultrapassa um limite inferior
• o sistema desliga quando a temperatura ultrapassa um limite superior
• existe distância suficiente entre os limites superior e inferior para evitar quedas na saída de controle

Uma maneira típica (embora admitidamente simplista de fazer isso) é chamada de programação de ganho. É uma abordagem clássica ao controle não linear quando você tem uma variável observável (ou variável) com a qual seu sistema muda (parâmetro de planejamento). No seu sistema, essa variável provavelmente seria temperatura. A idéia é que você crie uma lista de ganhos do controlador com valores diferentes do parâmetro de programação (temperatura) e, à medida que o parâmetro de programação muda, você utiliza esses ganhos no seu controlador (seja PI, PID, feedback de estado ou qualquer outro). Se isso parece realmente simples, é porque é. No entanto, ele funciona e é usado em alguns sistemas muito complicados.

Se você quiser ser extravagante, poderá implementar um algoritmo de aprendizado de máquina para gerar sua matriz de ganho. Isso resultaria no controlador em evolução e aprendizado que você parece estar descrevendo. No entanto, pode ser um exagero se o sistema puder ser totalmente caracterizado.

Edit: Desculpe, eu interpretei um pouco mal. Você está tentando controlar a temperatura para que as "condições ambientais" de que você falou sejam o seu parâmetro de programação.

Você pode usar o controlador Recursive Least Squares, cf. Astrom e Wittenmark , Adaptive Control, mas não sei se o microcontrolador terá força suficiente para fazer isso.