Postagem em destaque

Controle PID de Potência em Corrente Alternada - Arduino e TRIAC - Parte I

Este post é o primeiro de uma série de seis que escrevi tratando de controle de potência e PID (controle proporcional, integral e derivativo...

sábado, 8 de dezembro de 2012

Tutorial: interrupções de tempo (timer interruptions) no Arduino

Introdução

Hoje, no Parque, apareceu o ex-aluno Mackson, com o seu projeto de TCC, o qual foi desenvolvido com várias passagens pelo Automação no Parque. Já foi até objeto de post anterior, aqui. Agora, nos "finalmentes" ele trouxe a maquininha para a gente apreciar.



O trabalho dele consiste desenvolver um sistema para operação automática de um biodigestor. Ele montou uma caixa com o diagrama do equipamento no campo e colocou o circuito dentro da caixa, com LEDs, chaves e potenciômetros para ilustrar o funcionamento da bagaça.
Basicamente o digestor fornece gás metano, que é conduzido através de uma válvula (LED amarelo, aceso qdo a válvula está aberta, bombeado por um compressor (LED verde) e queimado num queimador por uma chama (LED azul). A luz verde indica que o sistema está operando em modo Normal.
Aí alguém deu o palpite: mas a chama não é azul, ela muda de cor. E se a gente colocasse um LED RGB e fizesse um efeito chama com ele mudando de cor? Imediatamente a galera se mobilizou para botar a coisa rodando.
A dificuldade residia em que, ao mesmo tempo em que a rotina da chama deveria ficar "rodando", o sistema teria que monitorar os outros indicadores (temperatura, pressão etc), ou seja, durante o tempo em que a chama estiver ligada, seria interessante que a rotina da chama rodasse "em paralelo" com o resto do sistema, de maneira a criar o efeito desejado.
É aí que entra o recurso de time interruption.

Teoria

Para quem programa há vinte anos ou mais: interrupção do Arduino é igual a interrupção do DOS. Pode pular a teoria.
Para os "menos experientes", interrupção é um mecanismo que permite a um processador parar uma rotina, executar uma outra tarefa e depois voltar à execução da tarefa principal. "Mas então é como uma sub-rotina, um sub-programa?", perguntaria alguém.
Sim, é. A diferença é que o desvio do processo de execução para essa sub-rotina se dá não por decisão do programa que chamou a sub-rotina, mas sim por um outro evento qualquer, por exemplo, um intervalo fixo de tempo entre as chamadas. Assim, a cada "n" microssegundos, o Arduino para o que estiver fazendo, roda a rotina e depois retoma o que estava fazendo antes.

Exempo

Vamos a um exemplo. Primeiro o resultado, um LED RGB com o tal "efeito chama" funcionando.



O LED RGB é uma espécie de 3 em 1. São três LED, um (R)vermelho, outro (G)verde e um (B)azul, tudo no mesmo encapsulamento, com 4 conectores: um para cada cor e um comum. Normalmente o comum é o terra, mas eu já vi muitos onde o comum é o +. Nesse caso, vc tem que ligar ele no 5V ou 3.3V e escrever 1 na porta correspondente para apagar e 0 para acender. Uma dica do Alex, frequentador do Automação no Parque e dono do projeto MariaMole: para "misturar" melhor as cores do LED RGB, lixe o bicho com BomBril, de maneira a que fique um pouco opaco.

O jeito óbvio de fazer uma aplicação dessa seria:

int rPin = 11;
int gPin = 10;

void setup()
{
  pinMode(rPin,OUTPUT);
  pinMode(gPin,OUTPUT);
}

void loop()
{
  for (int i=0; i<100; i++)
  {
    analogWrite(gPin,i);
    analogWrite(rPin,200);
    delay(5);
  }
  for (int i=100; i>0; i--)
  {
    analogWrite(gPin,i);
    analogWrite(rPin,200);
    delay(5);
  }
}


No código acima, os pinos 10 e 11 estão ligados aos terminais verde e vermelho do LED, respectivamente.

No loop(), temos dois laços: um varia a intensidade do verde entre 0 e 100 crescendo, o outro varia a velocidade do LED decrescendo. O vermelho é mantido num valor constante. Moleza.

Só que... imagine que o seu programa tem que fazer algum outro serviço além de ficar comandando o LED. Aí complica, porque se vc colocar, por exemplo, um comando delay(1000), o LED vai "congelar" ou apagar, dependendo de como seu código for escrito. Seria interessante que o código pudesse rodar e o efeito LED continuasse acontecendo, até que vc resolvesse desligá-lo. É a aí que entra a interrupção. Veja o código abaixo, agora usando interrupção de tempo, abaixo:

#include <TimerOne.h>
int rPin = 11;
int gPin = 10;

volatile byte _i = 0;
volatile byte _j = 1;

void chama()
{
    analogWrite(gPin,_i);
    analogWrite(rPin,200);
    _i+=_j;
    if (_i == 100)
      _j=-1;
    else
      if (_i == 0)
        _j=1;
}
void setup()
{
  Timer1.initialize(5000);
  Timer1.attachInterrupt(chama); 
  Serial.begin(9600);
  Serial.begin(9600);
  pinMode(rPin,OUTPUT);
  pinMode(gPin,OUTPUT);
}

void loop()
{
}


Agora temos:
O # include da biblioteca TimeOne.h.
Temos uma rotina chama(), que faz o efeito de chama. Ela é um pouquinho mais complicada:
Temos duas variáveis _j, _j, do tipo inteiro, que são usadas pela rotina mas não ficam definidas dentro dela. Isso porque o seu conteúdo deverá ser preservado a cada chamada da rotina, quer dizer, depois que a rotina terminar esses valores tem que permanecer para ser usados a cada chamada. A palavra "volatile", colocada antes da declaração dessas variáveis basicamente diz ao compilador para cuidar para que essas variáveis tenham seus conteúdos preservados da chamada de uma rotina para outra.
Dentro da rotina agora temos o seguinte: o valor da cor vermelha é sempre 200 (valor arbitrário que vc tem que descobrir para o seu LED qual o melhor para obter o efeito que deseja), e o da cor verde é o valor de _i.
A cada chamada da rotina, _j é somado a _i. Em seguida o valor de _i é testado, de maneira que, quando _i for 100, _j = -1, ou seja, _i passará a ser decrementado. Quando _i for 0, _j = 1, o que fará com que no próximo loop _i assuma o valor 1 e assim por diante.
Em seguida vem o setup(). Lá, a instrução   Timer1.initialize(5000); define que a cada 5000 microssegundos a rotina de timer será executada. Em seguida, a instrução Timer1.attachInterrupt(chama); define a rotina a ser chamada a cada interrupção A nossa chama() anteriormente descrita.

Observem que não existe nenhuma rotina na instrução loop(), ou seja, ela está livre para que vc escreva seu código sem se preocupar com a rotina chama(), que estará sendo executada e dando o efeito desejado normalmente.

Não é legal esse troço de interrupção? Agora vejam o efeito funcionando no TCC do Mackson.


E aí se foi mais um sábado de Automação no Parque, o último com a minha participação esse ano. Se o mundo estiver por aí daqui a alguns dias, estaremos de volta em 2013.

quinta-feira, 22 de novembro de 2012

Projeto ToolBox de automação de um almoxarifado de ferramentas

Um grupo de alunos de engenharia me contratou para ajudá-los com um TCC desafiador: eles bolaram um almoxarifado de peças totalmente automatizado, com controle das ferramentas retiradas por usuário, fazendo um log das operações de retirada e devolução.
O armário, automatizado com um Arduino Mega, funciona conectado a um PC, onde está ligado também um leitor de RFID. O cabra chega com o seu crachá e se identifica. Aí ele aperta o botão da gaveta que contém a ferramenta e o Arduino aciona o motor de passo da gaveta correspondente, que se abre.
Quando o sujeito retira a ferramenta, uma microchave avisa o Arduino qual foi retirada. O Arduino "conta" pro PC que registra no log qual ferramenta o cara retirou. Em seguida o sujeito aperta de novo algum botão de gaveta e o Arduino fecha.
Processo semelhante rola na devolução.
Meu papel foi ajudar com a parte de software. Fizemos o sw do PC em C#. Abaixo imagens do dito. Observem o capricho dos caras na construção da caixa. No fim eles vão trocar a protoboard por um circuito dedicado.

O projeto tem um monte de detalhes: LEDs para indicar o acionamento dos motores das gavetas, um display LCD para o Mega dizer o que está rolando, uma sirene que toca se o sujeito esquecer de fechar a gaveta... automação na veia!

Detalhe da gaveta com os entalhes das ferramentas, com a chave de retirada visível.


Protoboard com os drives de controle de motor e o display.



Parte de trás do armário, com dois dos motores visíveis (são três) e a fonte (de PC, claro).


Tela do software C# mostrando o log de quem pegou qual ferramenta. 




Guerra de Robôs Anhanguera Jacareí 2012 - mais algumas imagens

Aqui o vídeo do vencedor do Segue Faixa (cortesia do amigo Euclides):


Camaro Amarelo


Mesa de som






Guerra de Robôs, Anhanguera Jacareí - 21/11/2012

Ontem tivemos a segunda e última etapa da Guerra de Robôs 2012 da Anhanguera Jacareí. As categorias foram: Melhor Construção, Pista com Obstáculos e Sumô. 
Parabéns à equipe organizadora e a todos os participantes, que deram realmente um show de comprometimento e competência. E que as lições do evento nos ajudem a melhorar ainda mais até 2013.

Abaixo, imagens do evento:


No laboratório, retoques finais.


A galera vai chegando...



Maquininhas alinhadas, com o Godzilla de volta.



Robôs se enfrentam...




Tem hora que a coisa fica mais para balé do que luta.






Premiação, categoria Melhor Construção


Por fim ,vídeo da final da categoria Sumô Sem Fio. 

2013 tem mais!!!






terça-feira, 20 de novembro de 2012

"Gerra de Robôs - Anhanguera Jacareí, 20/11/2012

Imagens da Gerra Robótica de hoje à noite na Anhanguera


As duas pistas: 


As maquininhas...




A turma, ainda trabalhando no robô, e a competição rolando...



Acho que a competição deu ibope, o que vcs acham?




... and the winner was...




No fim do evento... Godzilla X Robocop!!!!



Automação no Parque - 17/11/12

No sabadão tivermos outra sessão do nosso Automação no Parque. Nas últimas duas semanas estive viajando, então não me foi possível estar presente. Este sábado foi muito movimentado devido à aproximação (é hoje!) da data da Competição de Robótica da Anhanguera Jacareí.

Cheguei às 7:00 em ponto e já tinha gente me esperando. O plano era sair às 13:00, acabei saindo depois das 14:00, ainda fiz "hora extra" ontem à noite lá na escola.

O interessante foi que estão aparecendo robôs dos mais diversos tipos, alguns inclusive bem esquisitos. Amanhã postarei alguma coisa sobre a competição de hoje à noite.

Abaixo, fotos do nosso evento de sabadão:


Hexapod comprado no ... WallMart!





Luta com um joystick PS2: dessa vez, 10x0 para ele...



Uma das maneiras fáceis de se começar na robótica é hackeando carrinhos com motores.


Essa foi muito legal: tem dois meninos que tem aparecido no parque todo sábado. Um deles é do projeto Decolar, aqui da Prefeitura de SJC, que assiste crianças bem dotadas intelectualmente das escolas públicas. A gente foi ensinando, dando uns eletrônicos para eles e dessa vez eles trouxeram um projeto que fizeram sozinhos: a Baladinha!

Numa caixa de sapatos, montaram um rádio com dois auto-falantes, revestiram um pedaçõ da caixa com espelhos, instalaram uma espécie de jogo de luzes com LEDs e colocaram uns bonequinhos que são o povo que tá dançando na baladinha. Ficou muito legal! O mais legal é a ideia, será de onde eles tiraram isso???



Abaixo, filme da baladinha rolando:











O Euclides tem-se especializado em cuidar da ala mirim do nosso Automação no Parque. Até por ter filhos pequenos, o cabra leva o maior jeitão para a coisa. Não satisfeito em ensinar a criançada, conseguiu doações para os meninos. Os multímetros deles são bem melhores que o meu... :)




E essa foi a nossa diversão do sábado...