Controle PID com Arduino Deixe um comentário

No mundo atual, com o avanço das tecnologias e sistemas existentes para a maioria dos processos, necessitamos cada vez mais de novas técnicas e atalhos para garantirmos o correto funcionamento de nossos equipamentos para alcançarmos o resultado com o máximo de precisão do produto planejado inicialmente. Precisão é a palavra chave para qualquer processo, alcançar o objetivo desejado atingindo o máximo de detalhes planejados anteriormente é o que todo processo deve almejar, mas, de que forma podemos garantir o alcance de precisão elevadas? Hoje responderemos essa pergunta utilizando uma das técnicas de controle mais efetivas, o controle PID.

Primeiramente, é interessante termos um detalhe mais cauteloso para a teoria de controle em si. O algoritmo de controle PID é um algoritmo que controla de forma precisa uma variável, definida anteriormente, de forma estável e em torno de seu setpoint, mesmo que ocorram perturbações e distúrbios externos que afetem a dinâmica do sistema. Tá, mas você deve estar se perguntando, o que é um setpoint? O que seriam os distúrbios? o que é a estabilidade? Pode ficar tranquilo, suas perguntas já serão respondidas!

O conceito fundamental de qualquer ação de controle é a estabilidade, um sistema estável é um sistema que responde a parâmetros de forma a tomar respostas controláveis e atenuadas, dentro de faixas aceitáveis, enquanto, um sistema instável trata de um sistema que não obedece mais às ações de controle, sua resposta passa a tomar valores que fogem daquilo palpável pelo controlador e muitas vezes a única medida para tornar o sistema estável novamente é o reset de toda a operação, algo inviável para certos processos.

Para facilitar o entendimento do controle PID existe a representação em malha do que nosso processo faz:

Malha de Controle PID
Malha de Controle PID
  • Setpoint: Valor previamente definido para a variável
  • Variável Manipulada: Variável que recebe ação direta do controlador, a fim de influenciar a variável controlada
    Variável Controlada: Variável sob a qual deseja-se controlar
  • PID: Controlador do sistema, mantém a variável controlada próxima do setpoint
  • Atuador: Responsável por executar o processo em si
  • Sensor: Responsável por captar os dados do processo
  • Erro: Diferença entre setpoint e valor medido pelo sensor
  • Distúrbio: Sinal externo ao sistema que tende a alterar sua dinâmica

A aplicação desta técnica de controle é extremamente ampla e praticamente todo processo pode fazer seu uso, desde que se deseje controlar variáveis contínuas (podendo ser apenas uma por vez), portanto, podemos perceber facilmente o vasto poder que obtemos ao usar um PID.

Ok, agora que explicitamos a malha de controle e explicamos o que são todas as variáveis envolvidas na malha, podemos partir para como o PID realmente funciona. Bem, o controle PID é uma sigla para Controle Proporcional Integrativo e Derivativo, sendo essas as ações tomadas pelo controlador, mas, o que exatamente seria cada uma dessas ações? A ação Proporcional talvez seja a mais simples de todas, ela é a primeira ação tomada pelo PID, que tenta ao máximo corrigir o erro (sim, aquele mesmo da malha), tomando uma ação proporcional ao erro (daí o nome de ação proporcional) para manter o setpoint desejado. O ganho utilizado para este tipo de ação é o ganho proporcional Kp.

A ação Integrativa age após a desatenuação do erro pela ação proporcional e vem tentando corrigir ainda mais o erro, porém, de forma fina, executando um somatório de todo erro ao longo do tempo (utilizando das integrais), se esta responsabilidade fosse passada ao proporcional, o sistema poderia alcançar a instabilidade. O ganho utilizado para este tipo de ação é o ganho integrativo Ki.

Por último, entra a ação Derivativa, que interfere caso haja variação de erro (ambas ações interiores agem quando o erro está estacionário), medindo a variação do erro ao longo tempo (por meio de derivadas) e evitando variações bruscas na variável manipulada para alcançar o setpoint, pois, caso ocorressem essas variações, o sistema facilmente torna-se instável. O ganho utilizado para este tipo de ação é o ganho derivativo Kd.

No mundo do controle, existem vários métodos de aplicarmos nossas técnicas, seja por meio de controladores físicos, fabricados por diversas empresas, ou então, empregando o controle digital por meio de microcontroladores e microprocessadores, utilizando os algoritmos das técnicas desejadas. No caso deste artigo, ensinaremos a utilizar a biblioteca de controle PID do próprio Arduino, facilitando no caso de não termos de replicar ou criarmos os nossos algoritmos, basta aprendermos a utilizar a biblioteca.

A biblioteca decidida para uso é a PID, desenvolvida por Brett Beauregard, disponível para instalação no próprio gerenciador de bibliotecas da plataforma Arduino. Primeiramente, é importante saber que as variáveis Input, Output e Setpoint devem necessariamente ser do tipo Double, enquanto os parâmetros de ganho Kp, Ki e Kd podem assumir valores do tipo Float ou então do tipo Int, como desejado. Vamos nos aprofundar um pouco na página do GitHub do código fonte desta biblioteca (disponível no link: GitHub – br3ttb/Arduino-PID-Library) para entendermos melhor o funcionamento da mesma e os outros cuidados que devemos tomar.

Na hora de declararmos o construtor do PID, precisamos passar os parâmetros de Input, Output, Setpoint, Kp, Ki, Kd, POn e ControllerDirection. POn é a variável que vai ditar se nosso controle proporcional é aplicado ao erro ou a medição (em nosso caso consideramos o controle aplicado ao erro, já que é o que define o controlador PID clássico que desejamos tratar) e ControllerDirection é a variável que diz se a ação de controle é positiva ou negativa em relação ao processo. Para exemplificar a última variável considere um processo de aquecimento através da atuação em um termopar, a ação de controle sobre o processo é positiva, elevando a temperatura do processo, em um sistema de refrigeração a ação controladora é negativa com relação a variável manipulada (temperatura), desejamos diminuí-la conforme as medições de erro.

Com os parâmetros sendo corretamente passados ao construtor, o próprio método já define certos valores por default, acertando algumas variáveis internas e tomando certas liberdades com relação a outros parâmetros internos, a exemplo de por padrão deixar o modo automático como falso, definindo as saídas limites como valores no range de 0 à 255 (padrão da saída analógica do Arduino) e um sample time (tempo de amostragem) de 100ms (o sample time define o período com o qual o controlador opera). Todos estes valores são capazes de serem alterados através de métodos específicos possíveis de serem chamados dentro do próprio código.

Agora que entendemos melhor o funcionamento da biblioteca e os cuidados e detalhes existentes nos métodos e construtores, vamos pensar em um projetinho para aplicação bem básica da biblioteca e da ação de controle PID. Imagine que desejamos ler certo valor de temperatura de uma mini-estufa para controlarmos a temperatura desta através de um termopar simples, considere ainda que a temperatura deve estar sempre em torno de 26°C, com pouca variação, para garantir que uma plantinha que cultivamos ali se mantenha saudável. Já deu pra notar que a precisão do nosso valor de setpoint deve ser estritamente mantida para garantir a vida da nossa planta, né? Portanto, o uso do PID é ideal para esse caso! Considere que o valor de 26°C teria uma leitura de tensão gerada de 2V, que o pino onde a leitura de tensão ocorre no pino 0 e a saída analógica usada para controle do termopar seja o pino 3, além do mais, vamos supor que após testes e cálculos encontramos os valores ideais de ganho como sendo 2 para ganho proporcional, 1 para derivativo e 5 para integrativo. Vamos ao código!

#include <PID_v1.h>
//Definindo as variáveis que vamos utilizar
double Setpoint, Input, Output;
int Kp = 2, Kd = 1, Ki = 5;
//Especificando os parâmetros do construtor
PID myPID(&Input, &Output, &Setpoint,Kp,Ki,Kd, DIRECT);
void setup()
{
//Inicializando as variáveis
Input = analogRead(0);
Setpoint = 2;
//Ligando o PID e deixando-o em modo Automático
myPID.SetMode(AUTOMATIC);
}
void loop()
{
Input = analogRead(0);
myPID.Compute();
analogWrite(3,Output);
}

Vamos analisar com cautela nosso código para entendermos passo a passo nossas ações! Primeiramente declaramos as variáveis que vamos passar como parâmetros seguindo os cuidados explicitados anteriormente, e então, criamos o construtor com todas as variáveis de interesse ao sistema. Mas ainda devemos lembrar que o controlador está desligado e em modo manual, portanto, em nosso setup utilizamos o método SetMode para iniciarmos o modo automático e enfim “ligamos” de fato o PID, só assim as variáveis internas são ajustadas e os parâmetros de ganho começam a agir. Outro detalhe interessante é perceber que o Input é definido como a leitura analógica do pino 0 (onde conectamos a saída do leitor de temperatura) e o pino 3 (entrada do termistor) é quem recebe a Output do controlador, obedecendo aos ajustes adequados pelo sistema. Perceba também o uso do método Compute, necessário para atualizar o controlador das medidas a cada loop que ocorre.

Com isso já conseguimos fazer um sistema de controle básico de temperatura, ideal para o início do aprendizado de sistemas de controle digital utilizando microcontroladores! Gostou da ideia? Que tal fazer seu próprio projeto agora? Faça uso dos conhecimentos adquiridos e bota a mão na massa! Siga o Cheetah E-Racing nas redes sociais e fique ligado para nossos novos posts! Até a próxima!


Esse conteúdo é resultado da parceria da FilipeFlop com a Cheetah E-Racing. Curtiu o conteúdo? Então deixe seu comentário abaixo! E não esqueça de acompanhar a Cheetah E-Racing nas redes sociais.

 

Faça seu comentário

Acesse sua conta e participe