Controle de luminosidade utilizando controlador PID (proporcional Integral Derivativo).
Controlador proporcional integral derivativo, controlador PID ou simplesmente PID, é uma técnica de controle de processos que une as ações derivativa, integral e proporcional, fazendo assim com que o sinal de erro seja minimizado pela ação proporcional, zerado pela ação integral e obtido com uma velocidade antecipativa pela ação derivativa.
É baseado na resposta da modelagem matemática de uma malha de processo a ser controlada.
Na prática os PID são encontrados no interior de controladores eletrônicos chamados "single-loop", muitas vezes com microprocessadores, e também através de software em Controladores programáveis e outros equipamentos de controle.
Neste projeto, vamos simular um controle de luminosidade com Arduino, rodando a biblioteca PID que pode ser encontrada no site:
Para isso necessitamos baixar além da biblioteca PID para o Arduino, também o PID Front-End para processing, que é uma interface gráfica para podermos configurar os parâmetros: P, I, D, Set Point, modos de trabalho, etc...; fazendo a interface com o Arduino.
Você pode baixar o Front-End no link acima.
Como vamos trabalhar com Arduino e Processing, necessitamos ter a IDE 1.0.1 do arduino e o Processing 2.0b8 instalados no computador.
Para o Processing, precisamos da biblioteca ContorlP5 para processing instalada. Baixe a biblioteca no site:
Para mairoes detalhes sobre controle PID de processos, aconselho a visitarem o site do criador da Biblioteca PID_V1.
E o site do Control Guru para maiores detalhes sobre automação e controle.
Detalhes sobre sistemas de controle em:
http://www.facstaff.bucknell.edu/mastascu/econtrolhtml/CourseIndex.html
Vamos agora aos aspectos construtivos do nosso projeto:
Faremos dois testes; um com o ambiente simulado por um tubo escuro, que não admite interferência externa, e o outro aonde poderemos interferir externamente e verificar a resposta do sistema.
Teste - 1
O ambiente será simulado por um tubo negro, com um LED Branco brilhante em uma das pontas (para iluminar o "ambiente") e um LDR na outra ponta (para podermos gerenciar a quantidade de luminosidade no "ambiente").
A ligação com o arduino é muito simples:
Pino D3 (como output) ligado ao LED que tem um resistor de R220 para controlar a corrente.
Pino A0 ligado ao LDR que tem um resistor de pull-down de 10K.
Abaixo o circuito desenhado com o fritzing e fotos reais do sistema.
 |
| Entre o LED e o LDR existe um tubo preto vedado, simulando ambiente totalmente escuro |
 |
| Detalhe do tubo preto (foi utilizado um carretel de linha, vedado por dois passadores de fios de borracha |
 |
| Detalhe do lado LED |
 |
| Detalhe do lado LDR |
Teste - 2
Agora o ambiente pode sofrer ações externas,chamados de distúrbios do nosso sistema, tais como: sombras e ou luz excessiva no ambiente.
Os distúrbios serão automaticamente controlados pelo Arduino PID.
Outro detalhe é que o valor do Setpoint, é controlado por um potenciômetro, não sendo mais necessário usar o Setpoint do PID_FrontEnd.
Abaixo o circuito desenho em fritizing e as fotos reais do sistema.
 |
| Controle do SetPoint feito pelo potenciômetro |
Controle via Software:
1 - Descarregar e descompactar as bibliotecas;
PID_V1 no diretório de bibliotecas da IDE do Arduino
Front-End PID, em uma pasta no seu micro
ControlP5, no diretório de bibliotecas do Processing
Enviar este scketch para o arduino.
3 - Iniciar o Processing e abrir o arquivo "PID_FrontEnd_v03" da pasta PID_FrontEnd.
Executar a aplicação.
Abaixo algumas figuras:
 |
| Pastas pertencentes ao PID_FrontEnd. |
 |
| O arquivo PID-FrontEnd_v03, deve ser aberto no Processing e executado |
 |
| O arquivo PID_FrontEnd_ArduinoSampleCode, deve ser aberto na IDE do Arduino e enviado |
 |
| IDE Arduino e Processing, é só enviar e executar. |
Ao executar a aplicação no Processing, a janela PID_FrontEnd irá abrir.
 |
| SetPoint = 950, Kp=0,01, Ki=0,28 e Kd=0 |
Nesta janela, podemos notar:
TOGGLE_AM - muda o modo para automático PID ou manual;
SETPOINT - valor desejado de luminosidade no ambiente;
INPUT - valor real de luminosidade do ambiente (medido pelo LDR e retornado como feedback medido no pino A0);
OUTPUT - valor de controle retornado pelo Arduino como controlador PID (controle de luminosidade do LED no pino D3);
KP - constante de controle proporcional;
KI - constante de controle Integral;
KD - Constante de controle Derivativo;
TOOGLE_DR - muda a direção (se a saída cresce conforme cresce a entrada ou o inverso);
SEND_TO_ARDUINO - enviar os dados para o arduino;
PID Input/Setpoint - Janela gráfica das curvas setpoint (valor desejado de luminosidade) e entrada (medida de luminosidade do LDR)
PID Output - Janela gráfica da curva de saída de controle do LED
 |
| Linha verde = Set Point SP; Linha Vermelha = Variável Controlada PV; Linha Azul = Variável Manipulada MV |
Nesta figura, podemos notar o setpoint configurado para 950 (linha verde), a variável de entrada (linha vermelha) sofrendo o controle PID e a variável de saída (linha azul) para controle da luminosidade.
Podemos entender também as informações descritas acimas através de um diagrama de blocos (figura abaixo).
Onde podemos notar o que o Error = SP - PV e o erro é aplicado ao controlador PID que gera a MV para o controle do processo.
Cada controlador P, I, e D pode ser utilizado independentemente, ou de forma conjunta, tal como:
Controlador P (muito utilizado)
Controlador PI (muito utilizado)
Controlador PD (raramente utilizado)
Controlador PID (o mais usado)
 |
| Exemplo de Controlador PI com realimentação direta |
Aqui nesta figura, observamos uma variação no valor do setpoint (de 950 para 700 e para 950) e a atuação do controle PID em cima da variável de entrada.
Vejam que houve um pouco de oscilação no controle (característica de cada sistema controlado, de primeira ou segunda ordem).
Para o segundo teste, vamos enviar para o Arduino, o sketch abaixo:
(este será usado em lugar do arquivo "PID_FrontEnd_ArduinoSampleCode")
Lembrando que o controle do Setpoint é feito pelo potenciômetro.
Como fonte de distúrbio, podemos usar uma lanterna para incidir mais luz ou um anteparo para fazer sombra no LDR.
Ao temos um distúrbio no processo (por exemplo sombra), o controlador irá aumentar/diminuir a luminosidade do LED para tentar manter a saída sob controle e no nível estabelecido pelo SetPoint (no caso de fazer uma "sombra no LDR, o controlador irá aumentar a intensidade de luz do LED), poderemos ver estas variações no PID_FrontEnd de forma gráfica.
Abaixo algumas figuras relacionadas.
 |
| Kp=0, Ki=10, Kd=0 -- aplicação de disturbio e variações no SP |
 |
| Kp=0, Ki=10, Kd=0 -- aplicação de disturbio (com bloqueio e sem bloqueio) |
 |
| A seta indica a mudança de parametros Kp=0,01; Ki=0,28; Kd=0 (notar que a atuação ficou mais lenta e com menos overshoot) |
Ao testar os parametros, foi verificado um comportamento semelhante para os dois testes.
Vídeos explicativos:
Dúvidas e sugestões para: arduinobymyself@gmail.com
http://youtu.be/Y267-qba12M
No Próximo Projeto, irei apresentar mais um exemplo de controle PID
Aguardem!
No Próximo Projeto, irei apresentar mais um exemplo de controle PID
Aguardem!
Estudos Futuros e mais aprofudados:
http://en.wikipedia.org/wiki/Controller_(control_theory)
http://en.wikipedia.org/wiki/Control_theory
http://en.wikipedia.org/wiki/PID_controller
http://en.wikipedia.org/wiki/Process_control
http://ctms.engin.umich.edu/CTMS/index.php?example=Introduction§ion=SystemModeling
http://en.wikipedia.org/wiki/Controller_(control_theory)
http://en.wikipedia.org/wiki/Control_theory
http://en.wikipedia.org/wiki/PID_controller
http://en.wikipedia.org/wiki/Process_control
http://ctms.engin.umich.edu/CTMS/index.php?example=Introduction§ion=SystemModeling
