Integrando processing e Arduino com a biblioteca Firmata 2

Nesse tutorial vamos programar o Arduino com um exemplo da biblioteca Firmata para controlar um circuito com LEDs via a IDE do Processing. O protocolo de comunicação Firmata permite criar uma integração entre processing e arduino abrindo um leque de novas possibilidades para nós makers, quer entender melhor toda essa história? Então, vamos lá! 

O que é Firmata?

“Firmata é um protocolo genérico que permite criar um canal de comunicação para microcontroladores a partir de um software no computador do usuário”.

Fonte: Firmata wiki http://firmata.org/wiki/Main_Page

No Arduino, a Firmata é uma biblioteca que implementa o protocolo de comunicação denominado Firmata. Na prática, a Firmata torna possível controlar totalmente o seu arduíno por um software no seu computador.

O software que estará no seu computador (tablet, smartphone, laptop, etc…) e que será usado para controlar o Arduino pode ser desenvolvido em diversas plataformas. Existem client libraries desenvolvidas para javascript, java, python, processing, php, .NET e, pelo menos, mais uma dezena de outras tecnologias.

Materiais Necessários:

Vamos construir um circuito simples para testar essa técnica que estamos aprendendo. Ligamos 5 LEDs as portas digitais 13, 12, 11, 10 e 9 do Arduino, lembre-se de conectar resistores de pelo menos 220 ohms aos LEDs, como mostra a figura 1.

Faça a montagem na protoboard conforme a figura 2.

fritzing arduino com 5 LEDS

Gravando o Arduino

O Sketch que vamos gravar é um dos exemplos da biblioteca Firmata que é nativa da IDE do Arduino. Com a IDE aberta, siga o caminho: Arquivos > Exemplos > Firmata > StandardFirmata.

Com o Sketch aberto, se certifique que a placa e a porta estão corretamente selecionadas, para isso clique em: Ferramentas > Placa e depois em Ferramentas > Porta. Memorize ou anote o índice da Porta que você está usando, siga o exemplo da figura 3. Por fim, clique no botão Upload para gravar o Sketch no seu Arduino.

processing e arduino

O processing

Aqui eu farei uma rápida apresentação do Processing, certamente aprenderemos mais sobre essa tecnologia em postagens futuras.

Processing é um software que como o Arduíno IDE permite a criação de Sketchs (projetos) e possui uma linguagem de programação com a escrita muito familiar ao Arduino C, porém, com a peculiaridade de ser mais voltada para projetos com artes visuais. É totalmente grátis e open source, e você pode fazer o download na página do Processing.

Para instalar é muito fácil. Basta realizar o download segundo o respectivo sistema operacional da sua máquina e depois descompactar o arquivo onde desejar. Duplo clique sobre o executável e já está funcionando. Simples assim!

Agora vamos instalar a biblioteca Firmata no processing. Com o Processing aberto, no menu superior, clique em Sketch, em seguida, em importar biblioteca… ou import library. E por último clique em adicionar biblioteca… ou add library. Essa ação abrirá uma janela chamada Contribution Manager, clique em Filter e digite Firmata, aparecerá a biblioteca Arduino(Firmata), clique sobre ela e depois no botão Install.

Agora é possível ter acesso aos exemplos da biblioteca Firmata no processing. Vamos abrir um dos exemplos. Clique em Arquivos ou File e em seguida, Examples. Essa última ação abrirá uma nova janela com vários exemplos muito bem organizados em pastas. Clique sobre o “+” na pasta Contributed Libraries e depois em Arduino (Firmata), escolha o arquivo arduino_output e abrirá uma nova janela com o Sketch selecionado.

Como descrito no comentário do Sketch, esse programa demonstra como controlar os pinos digitais de um Arduino que esteja programado com o Sketch Standard Firmata. Agora vamos entender os pontos principais desse Sketch.

Nas linhas 30 e 32, respectivamente, o Processing importa a biblioteca arduino e cria o objeto arduino. Na linha 45, como boa prática, é impresso no console do processing uma lista das portas seriais ativas, e aqui você deve rememorar o índice da porta serial a qual o seu Arduino está conectado. Na linha 50, o objeto é inicializado e aqui precisamos nos atentar aos argumentos, em especial ao segundo e ao terceiro. Em arduino.list()[Coloque o índice da sua porta serial] e logo em seguida certifique-se que a baud rate é igual a programada no Sketch do Arduino.

Entre as linhas 57 e 59 declaramos os pinos do Arduino como entradas ou saídas, note a semelhança como fazemos a declaração na IDE do Arduíno, dentro do setup e usando o comando pinMode. As diferenças se apresentam quando declaramos funções específicas do Arduino e devendo escrever arduino à frente, como em: arduino.pinMode; arduino.digitalWrite; Arduino.HIGH; Arduino.LOW; Arduino.OUTPUT.

Processing e arduino

Então O.K. Tudo pronto e configurado? Aperte o play para iniciar o programa no Processing. Aparecerão vários quadradinhos, cada um deles representa uma porta digital do Arduino. Eles são contados da direita para a esquerda, sendo assim, clique nos 5 últimos quadradinhos do lado esquerdo e veja que é possível atuar os LEDs conectados ao Arduino em tempo real!

Na prática, temos uma forma de compilar e programar o Arduino somente uma vez e depois controlá-lo à vontade pelo nosso computador.

Vamos fazer algumas pequenas modificações no Sketch do Processing para aquecermos os motores para os próximos projetos.

A função void draw no Processing funciona como a função void loop no Arduíno, tudo que está nela se repete em ciclos, vamos escrever um programa que ao apertarmos o quadrado de uma das extremidades desencadeia um efeito em dominó ligando ou desligando os LEDs.

Vamos interpretar o que há dentro do void draw. Essencialmente, essa parte do código controla o que é exibido na interface ou janela que é aberta quando apertamos o play.

void draw() {
background(off);
stroke(on);

for (int i = 0; i <= 13; i++) {   //Esse laço itera criando os quadradinhos e os preenchendo ou não, como são 14 portas digitais temos 14 iterações.
if (values[i] == Arduino.HIGH)   //O vetor values possui 14 posições
fill(on);  //Essa função preenche ou não o quadradinho, conforme o valor em determinada posição do vetor.
else
fill(off);
rect(420 - i * 30, 30, 20, 20);  //Essa função é responsável por desenhar os quadradinhos na tela
}
}

//A função void mousePressed é uma interrupção que é acionada toda vez que pressionamos o mouse dentro da janela do programa.

void mousePressed() {
int pin = (450 - mouseX) / 30;   // Essa declaração identifica qual quadradinho estamos clicando

// Os condicionais mudam o estado do pino clicado
if (values[pin] == Arduino.LOW) {  //Se o quadradinho clicado tem valor LOW
arduino.digitalWrite(pin, Arduino.HIGH);   //Ele troca o estado da porta do Arduino
values[pin] = Arduino.HIGH;  //E altera o valor no vetor do Processing
} else {
arduino.digitalWrite(pin, Arduino.LOW);
values[pin] = Arduino.LOW;
}
}

Código entendido, vamos alterar!

//A função void draw recebe mínimas modificações

void draw() {
background(off);
stroke(on);

for (int i = 9; i <= 13; i++) {   //Vamos iniciar nossa variável i em 9, assim desenhamos os quadradinhos respectivos aos pinos 9~13
if (values[i] == Arduino.HIGH)
fill(on);
else
fill(off);
rect(420 - i * 30, 30, 20, 20);
}
}

//A função mousePressed recebe mais alterações

void mousePressed() {
int pin = (450 - mouseX) / 30;
//Essa função é a que terá mais mudanças
if (pin == 13 && values[13] == Arduino.LOW) {   //Se o quadrado clicado corresponder ao pino 13 e ele estiver desligado
for (int i = 13; i>=9; i--){   //Ligamos os outros pinos que estiverem também desligados em sequência, à partir da esquerda
arduino.digitalWrite(i, Arduino.HIGH);
delay(1000);   //Perceba o problema de usarmos o delay!
values[i] = Arduino.HIGH;
}
} else if(pin == 9 && values[9] == Arduino.LOW){   //Se o quadrado clicado corresponder ao pino 9 e ele estiver desligado
for (int i = 9; i<=13; i++){   //Ligamos os outros pinos que estiverem também desligados em sequência, à partir da direita
arduino.digitalWrite(i, Arduino.HIGH);
delay(1000);
values[i] = Arduino.HIGH;
}
}

else {   //Podemos desligar os pinos um a um
arduino.digitalWrite(pin, Arduino.LOW);
values[pin] = Arduino.LOW;
}
}

Perceba que, ao executar o código, os LEDs acendem em sequência e só depois de todos estarem ligados o Processing atualiza os quadradinhos na tela. Podemos analisar o problema pelo seguinte ângulo, a função delay torna perceptível que o programa fica preso ao loop que atualiza os valores das portas do Arduino. A resolução desse problema fica como desafio, vamos discutir a solução nos comentários.

Se você quer saber mais sobre o Firmata ou sobre o Processing não fique ansioso! Acompanhe as próximas postagens onde vamos aprender Como criar uma interface no Processing do zero, onde falarei mais sobre a programação no processing, e Comunicação Serial entre Arduino e Processing, onde aprenderemos mais uma forma de integrar o Arduino ao Processing, programando um jogo no processing e criando um joystick simples com arduino.

Curtiu a integração do processing e Arduino? Ajude-nos a melhorar o blog, participe com a sua sugestão, dúvida ou comentário aqui embaixo. E se quiser postar seu projeto, acesse nosso fórum.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

2 Comentários

  1. Parabéns pelo trabalho. Já tinha lido sobre firmata no arduino, mas, não sabia que tinha para o processing.
    Fiz a instalação da biblioteca no meu computador. Falta testar.

    José Luiz Britto dos Santos
    1. Que bom que gostou José!

      Abraços!
      Diogo – Equipe FilipeFlop