Accionamento de LED e Arduino através de Interface Gráfica em Processing

Introdução

Em continuação dos artigos usando o micro-controlador Arduino que tenho vindo a escrever nas edições anteriores, apresento nesta edição um artigo que aborda uma das primeiras experiências que o utilizador pode ter com a plataforma Arduino, que é o simples accionamento de um ou mais LEDs.

O accionamento e controlo dos LEDs é muito simples pelo que neste artigo irei aprofundar um pouco mais e criar uma interface gráfica usando Processing que irá permitir controlar o LED usando um botão clicável pelo rato.

Esquema Eléctrico

Ligar um LED ao Arduino é um dos projectos mais fáceis e indicados para quem está a começar, sendo que é necessário seguir um esquema eléctrico muito simples para colocar o LED em funcionamento.

O esquema eléctrico que elaborei para este projecto foi o seguinte:

LED e Arduino: esquema eléctrico
Figura 1: esquema eléctrico LED

Como podem ver apenas é necessário conectar o polo positivo do LED que geralmente é a perna mais longa ao pino 13 do Arduino enquanto que a perna mais curta do LED deve ser conectado ao GND do Arduino.

Muito simples de implementar mesmo para quem está a dar os primeiros passos.

Conexão entre o Arduino e a Aplicação em Processing

Não basta programar uma pequena aplicação gráfica para que possamos controlar as acções do Arduino, é necessário criar uma ponte entre o Arduino e a aplicação desenvolvida em Processing. Basicamente a aplicação em Processing irá produzir um output que será recebido e interpretado pelo Arduino.

Para sabermos exactamente o output produzido é necessário definir valores de output específicos no Arduino para que possamos controla-los na aplicação em Processing.

O exemplo seguinte mostra como foi definida uma variável estado que irá ser a responsável por controlar o estado do LED, ou seja, ligado ou desligado: 

void loop()
{
  //Verificar se a porta Serial está disponível
  if (Serial.available() > 0)
  {
    // O estado será igual ao valor lido do Output da App em Processing
    estado = Serial.read();
    Serial.print("Estado: ");
    Serial.println(estado);
    //Se o valor recolhido for = 111 o LED está ON
    if (estado == 111)
    {
      digitalWrite(ledPin, HIGH);
    }
    //Se o valor recolhido for = 102 o LED está OFF
    if (estado == 102)
    {
      digitalWrite(ledPin, LOW);
    }
  }
}

Tendo definido a variável estado que vai receber um de dois valores retornados através da aplicação com interface gráfica em Processing, podemos prosseguir e construir todo o código para o Arduino, que é muito simples como podem ver:

//Definir o Pino de Output do Arduino é o Pino 13
int ledPin = 13;
int estado;

void setup()
{
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  if (Serial.available() > 0)
  {
    estado = Serial.read();
    Serial.print("Estado: ");
    Serial.println(estado);
    if (estado == 111)
    {
      digitalWrite(ledPin, HIGH);
    }
    if (estado == 102)
    {
      digitalWrite(ledPin, LOW);
    }
  }
}

Com o código acima indicado temos toda a parte lógica que o Arduino necessita para desempenhar a função pretendida.

mouseClicked()

A função mouseClicked() já faz parte das funções integradas em Processing e de um modo geral é uma função que é chamada após um botão do rato ter sido pressionado e libertado.

Desta forma as acções que irão suceder após o botão ter sido clicado são programadas dentro desta função mouseClicked().

A sintaxe desta função é muito simples como podem ver no exemplo seguinte:

void mouseClicked()
{
  //A expressão da condição do If é responsável
  //por delimitar a área clickável do botão
  if (mouseX > 150 && mouseX < 250
      && mouseY > 250 && mouseY < 350)
  {
    porta.write(111);
  }
  if (mouseX > 250 && mouseX < 350
      && mouseY > 350 && mouseY < 450)
  {
    porta.write(102);
  }
}

Desenho para Interface Gráfica em Processing

O desenho da interface de switch On e Off do LED conectado ao Arduino não necessitava de ser muito complexo e visualmente poluído pelo que tentei implementar de uma forma simples.

LED e Arduino: interface gráfica
Figura 1: interface gráfica

A implementação da interface gráfica acima apresentada resultou do seguinte código Processing:

//Importar a biblioteca Serial de modo a
//obter-mos acesso aos dados
//que circulam na porta Serial
import processing.serial.*;

//Definição de variáveis
PImage Led;
Serial porta;
int button1 = 0;
int estado = 0;

void setup()
{
  //Definir o tamanho da janela
  size(400,400);
  Led = loadImage("Led.jpg");
  background(255);
  porta = new Serial(this, "COM3", 9600);
}

void draw() {
  image(Led, 175, 25);
  rect(150, 250, 100, 100);
  redraw();
}

void mouseClicked()
{
  if (porta.available() &rt; 0)
  {
    estado = porta.read();
    println(estado);
  }
  //Valor 111 significa On
  if (mouseX > 150 && mouseX < 250
      && mouseY > 250 && mouseY < 350
      && button1 == 0 && estado == 0)
  {
    porta.write(111);
    button1 = 1;
    background(255);
    fill(0,0,0);
    textAlign(RIGHT);
    text("Estado: ", 75, 225);
    text("Led On", 115,225);
    rect(150, 250, 100, 100);
    fill(0, 128, 0);
  }
  //Valor 102 Significa Off
  else if(mouseX > 150 && mouseX < 250
      && mouseY > 250 && mouseY < 350
      && button1 == 1)
  {
    porta.write(102);
    button1 = 0;
    background(255);
    fill(0,0,0);
    textAlign(RIGHT);
    text("Estado: ", 75, 225);
    text("Led Off", 115,225);
    rect(150, 250, 100, 100);
    fill (255,0,0);
  }
}

Apesar de ter algumas limitações, tais como a não possibilidade de sobrepor duas imagens na tela, a linguagem Processing é bastante ágil e permite de uma forma simples e com uma sintaxe muito semelhante à linguagem de programação C (com a qual também programamos o Arduino) dar os primeiros passos na criação de interfaces gráficas e interagir com o Arduino

Conclusão

Como ficou demonstrado acima é relativamente fácil criar uma interface gráfica capaz de interagir com o Arduino e controlar através dela um LED. Com base num dos projectos mais simples que podem ser implementados com Arduino e implementando uma interface gráfica aumentamos significativamente a usabilidade e aparência do nosso projecto, pelo menos ao nível de interface.

Publicado na edição 38 (PDF) da Revista PROGRAMAR.