Social Icons

O que é Processing?



O Processing é uma ferramenta open source que resulta numa simplificação de Java. Possibilita aos designers e artistas a utilização nas suas criações de algoritmos e formas computacionais, com um elevado índice de processamento

  • Sobre:
=> Gratuito e open source.
=> Programas interativos em 2d e 3d ou com saida em pdf.
=> Integração com OpenGL para acelaração 3D.
=> Roda em GNU/Linux, Mac OS X e Windows
=> Compilados para browser Web ou aplicativo desktop.
=> Mais de 100 bibliotecas de extensão para audio, vídeo, captura de imagens, etc.
=> Inúmeros recursos disponíveis (em inglês)

Fazemos o download da pequena aplicação no link abaixo. Só escolher o sistema operativo:

http://processing.org/download/

É composto por uma pasta compactada. Descompactar em localização à sua scolha.

No interior encontra o ficheiro "processing", com ícone. Clicar para executar.

 




  • Referências
Para mais informações acesse:

» Processing.Org
» Processing Wiki
» Processing Discussion Forum
» OpenProcessing
» CreativeApplications.Net
» O'Reilly Answers
» Vimeo
» del.icio.us
» Flickr
» YouTube     

Processing - Primeiros passos para interação com Arduino

Processing + Arduino | Interação Simples

Olá, gostaria de pedir desculpas pelo tempo sem atualização. Tanto o Processing como o Arduino já possuem bibliotecas prontas para uma comunicação eficaz entre eles, e neste post veremos como começar a utilizar tais recursos.

Para começar faça o download da biblioteca Arduino para o processing, já que ela não é nativa do programa.
processing-arduino-0017.zip
Extraia o arquivo zip dentro da pasta "libraries" no Processing, para que você possa utilizá-la.

A seguir, no Arduino, abra o exemplo "Standard Firmata" e faça o upload na sua placa, este exemplo contem o Firmware necessário para interagir diretamente PC-Arduino, este programa é uma ligação entre todos os recursos do arduino e a sua comunicação serial, assim você poderá acessar "diretamente" os valores nas suas entradas digitais e até mesmo escrever valores nas saidas do Arduino interagindo apenas com o seu PC, em outras palavras, você transforma o arduino em um "periférico" do seu pc e pode controlar ele diretamente.

Voltando.


Se você já fez o upload do Firmata para a sua placa, ela não precisa de mais nada para funcionar! Agora vamos a um exemplo básico.

Leitura digital utilizando o Firmata e o Processing

Neste exemplo vamos ver como acessar as portas do Arduino para utilizá-las como saídas para nosso programa Processing. Ligue alguns Leds nos pinos digitais do Arduino, nunca use os pinos 0 e 1 pois eles são ligações diretas com a comunicação serial, que neste caso será obrigatoriamente usada pela placa para conexão com o PC, independente do meio usado (usb, Bluetooth, XBee, rádio, etc). Continuando...

Exemplo de ligações.
Como já disse, você poderá ligar em qualquer pino exceto os pinos 0 e 1.

A seguir abra o Processing e abra o exemplo arduino_output que acompanha os arquivos da biblioteca, deverá ser como este:



import processing.serial.*; // Biblioteca serial nativa do processing

import cc.arduino.*; // Biblioteca de interação com o arduino

Arduino arduino; // Cria um novo objeto arduino para interação com a placa

color off = color(4, 79, 111); //Declara as cores usadas no exemplo
color on = color(84, 145, 158);

int[] values = { Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW,
 Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW,
 Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW, Arduino.LOW };
//Cria um array para armazenar os valores a serem passados para a placa
//Arduino.LOW representa os valor LOW na placa arduino sendo acessada pela biblioteca
//Arduino

void setup() {
  size(470, 200);//Tamanho da tela
  
  println(Arduino.list());//Esse é um comando usado apenas para saber
  // qual a porta utilizada pela placa.
  
  arduino = new Arduino(this, Arduino.list()[0], 57600); //Construtor
  //do objeto arduino, onde Arduino.list()[0] é a porta usada e 57600 é a Baud
  //da porta serial
  
  //Este For é uma parte do código que devemos prestar atenção
  //pois nele estamos utilizando código do arduino.
  //tente substituir este bloco por:
  /*
  arduino.pinMode(2,Arduino.OUTPUT);
  arduino.pinMode(3,Arduino.OUTPUT);
  arduino.pinMode(4,Arduino.OUTPUT);
  etc
  */
  for (int i = 0; i <= 13; i++)
    arduino.pinMode(i, Arduino.OUTPUT);
}
//Percebeu a semelhança? com o código do arduino?
//Pois é...


//Este bloco desenha a interface, não vem ao caso agora
void draw() {
  background(off);
  stroke(on);
  
  for (int i = 0; i <= 13; i++) {
    if (values[i] == Arduino.HIGH)
      fill(on);
    else
      fill(off);
      
    rect(420 - i * 30, 30, 20, 20);
  }
}

//Esta função é um presset do Processing, pode ser chamada de Evento
// Ela é chamada SEMPRE que um botão do mouse é pressionado.
void mousePressed()
{
  int pin = (450 - mouseX) / 30;//Utiliza a posição X do mouse para
  //saber que botão foi clicado
  //Perceba que aqui ele não utiliza a posição Y 
  //mas vamos deixar assim pra simplificar.
  
  //Este bloco if simplesmente comuta os valores
  if (values[pin] == Arduino.LOW) {
    // A parte legal esta aqui!!
    // pra quem já conhece o arduino e POO não tem o que explicar
    // se não vamos lá:
    // aqui você manda a sua placa, representada aqui pelo objeto "arduino"
    // e manda ele escrever numa saída digital
    // perceba que a variável pin é uma variável do programa, e não da placa
    arduino.digitalWrite(pin, Arduino.HIGH);
    values[pin] = Arduino.HIGH;
  } else {
    arduino.digitalWrite(pin, Arduino.LOW);//idem
    values[pin] = Arduino.LOW;
  }
} 

Processing - Textos e Imagens

Vamos Tratar Aqui sobre Processing e Aplicações Visuais Simples.
Normalmente linguagens como o Delphi por exemplo, a IDE já faz praticamente todo o trabalho de codificação dos objetos apresentados na tela, o que não acontece no processing. Então para começar crie um novo projeto e salve no local desejado. Perceba que você não salva um arquivo apenas, o Processing cria uma pasta com o nome que você digitou, é dentro desta pasta que criaremos uma pasta com o nome "data" ela servirá para guardar os arquivos que você utilizará no programa.

Criando uma Fonte .vlw

No menu do Processing, vá em Tools>Create Font. Você deverá ver uma janela como esta:

Ai você deverá escolher exatamente como sua fonte deve parecer(exceto a cor) pois alterar o tamanho da fonte através do código resultará em perda de qualidade da imagem, você terá que criar um arquivo para cada tamanho que for usar, use nomes fáceis para facilitar o código.



Caso queira usar caracteres especiais clique no botão "Caracters" e selecione os tipos desejados, ou apenas selecione "All Caracters".

Para carregar uma fonte você deverá primeiro criar um objeto PFont, e carregá-lo com a fonte que você criou utilizando o Processing.

Vamos ao Código:
void setup() {
  background(255);//Cor de fundo 255,255,255
  size(200,100);  //tamanho da janela 200x100
  PFont font1; //Para começar crie um objeto PFont
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,255);   //Seta a cor a ser usada
  text("Hello Strings!",10,50);  //Escreve o texto
E o resultado é:
Caso tenha tido alguma dúvida durante o processo, sinta-se a vontade para perguntar.

Utilizando imagens
Nosso aplicativo com texto é extremamente simples ele nem ao menos precisou entrar no loop, a tela foi desenhada apenas uma vez e conseguimos o que queriamos. Para exemplificar o uso de imagens usarei algo pouco mais complexo.

Para começar, eu criei estas duas imagens que serão utilizadas no exemplo podem baixar e usá-las ou use qualquer outro ( .gif, .jpg, .tga, .png).
OBS.: As imagens devem está dentro da pasta "data" dentro do seu projeto.
Assim como o texto, as imagens também precisam ser previamente declaradas e carregadas e a forma de se fazer é praticamente a mesma. Mas para imagens, utilizaremos o objeto PImage e o metodo loadImage().
Organizando melhor o código ele ficou assim:

PFont font1; //Para começar crie um objeto PFont
PImage back; //Objeto PImage para nossa imagem de fundo

void setup() {
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  back = loadImage("back.png"); //carrega a imagem
  size(240,320);  //tamanho da janela 240x320
  image(back,0,0); //Desenha a imagem na posição 0x0
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,0);   //Seta a cor a ser usada
  text("Hello Images!",60,20);  //Escreve o texto
}
Perceba que não usei background pois a imagem utilizada supostamente é o nosso background aqui. Agora para deixar as coisas mais interessantes vamos adicionar a outra imagem, e vamos fazer ela acompanhar a posição do mouse. Nosso código deveria ficar assim:

PFont font1; //Para começar crie um objeto PFont
PImage back; //Objeto PImage para nossa imagem de fundo
PImage pointer;

void setup() {
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  back = loadImage("back.png"); //carrega a imagem
  pointer = loadImage("pointer.png");
  size(240,320);  //tamanho da janela 240x320
  smooth();
  image(back,0,0); //Desenha a imagem na posição 0x0
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,0);   //Seta a cor a ser usada
  text("Hello Images!",60,20);  //Escreve o texto
}

void draw(){
imageMode(CENTER);
image(pointer,mouseX,mouseY);
}

Compile e rode este código, confira cada letra, use nomes fáceis para os arquivos, é comum erros por tentar carregar um arquivo com nome errado, ou que está fora do lugar.
 Interessante!! Mas não é exatamente o que eu queria...
Para quem entendeu o que está acontecendo ótimo você pode pular alguns parágrafos, se não preste bastante atenção nesta parte que é importante.

Como ja foi dito anteriormente, o Processing gera sua aplicação através de desenhos na tela, ele foi feito para as mais diversas aplicações possiveis, desde programas mais comuns como oque utilizamos normalmente, a verdadeiras obras de arte em que sua janela é o quadro. Por este motivo, coisas básicas como limpar a tela a cada ciclo é algo que devemos fazer manualmente.

COMO?!?!?!?!?!?!

Bem simples, vamos ver o código mais de perto.

PFont font1; //Para começar crie um objeto PFont
PImage back; //Objeto PImage para nossa imagem de fundo
PImage pointer;

void setup() {
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  back = loadImage("back.png"); //carrega a imagem
  pointer = loadImage("pointer.png");
  size(240,320);  //tamanho da janela 240x320
  smooth();
  image(back,0,0); //Desenha a imagem na posição 0x0
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,0);   //Seta a cor a ser usada
  text("Hello Images!",60,20);  //Escreve o texto
}

void draw(){
imageMode(CENTER);
image(pointer,mouseX,mouseY);
}
Os trechos destacados acima são as 3 funções que desenham nossa janela, primeiro é desenhado o fundo, depois o texto e por ultimo a espiral na posição do mouse, mas como vocês viram, ele desenha infinitas espirais a cada nova posição do mouse (afinal é pra isso que servem os loops não?), mas eu quero apenas UMA espiral movendo-se na tela, e não um rastro de infinitas...

Para isso basta transferir o código que desenha o fundo e o texto para o loop e fazer alguns ajustes como:
  1. Limpar a tela para que a imagem atual nao se misture com a anterior.
  2. Caso utilize mais de um modo de desenho, por exemplo imageMode(), não deixe de colocar, pois onde não houver explicitamente o modo, será usado o ultimo modo, que pode não ser interessante já que estamos dentro de um loop.
Resultado:
PFont font1; //Para começar crie um objeto PFont
PImage back; //Objeto PImage para nossa imagem de fundo
PImage pointer;

void setup() {
  font1 = loadFont("fonte.vlw"); //Carrega o arquivo de fonte
  back = loadImage("back.png"); //carrega a imagem
  pointer = loadImage("pointer.png");
  size(240,320);  //tamanho da janela 240x320
  smooth();
}

void draw() {
  background(255);//Pinta toda a tela de branco  
  imageMode(CORNER);
  image(back,0,0); //Desenha a imagem na posição 0x0
  textFont(font1); //Seta a fonte a ser usada
  fill(0,0,0);   //Seta a cor a ser usada
  text("Hello Images!",60,20);  //Escreve o texto
  imageMode(CENTER);
  image(pointer,mouseX,mouseY);
}

Controlando Relés Pelo Arduino(AtualizadO)

Existem 2 formas faceis de se controlar relés utilizando uma placa arduino, uma delas utilizando os relés mais comuns que sao encontrados por ai, os de 12v, mas para isso é preciso amplificar a saida do arduino que é de 5V, para isso, transistores. A outra possibilidade seria comprando relés de 5V, mas ainda assim nao podemos controlalos diretamente com a saida da placa, pois a corrente nescessaria para fazer a chave do relé mudar é maior doque a disponível pelo arduino. Entao Vamos la:

Pinos:
Arduino_OUT = A saida da sua placa.
Arduino_GND= Ligue ao terra do arduino.
RELAY_V+  = Deve ser ligado a uma fonte que suporte a voltagem do seu relé (12v por exemplo).
RELAY_GND= Ligado ao terra da fonte do seu relé.

Como funciona:
           
O a saida do arduino não tem corrente suficiente para ativar um relé, ligando desta forma, o transistor ativará o relé utilizando a corrente de RELAY_V+, e isso acontecerá quando a saída do arduino for 1. O diodo em paralelo com o controle do relé serve para proteger o transistor contra descargas de alta corrente que podem surgir devido às transisções de estado do relé. O resistor serve apenas para impedir um curto na placa do arduino, qualquer valor entre 330Ohm e 2k2 deve funcionar.

Transistores Testados ( Contribuição da Prigol*)

- BC548 (FUNCIONA)
- BC337 (FUNCIONA)
- TIP102 (FUNCIONA)
- 2N2222 (Ñ FUNCIONA)
Os acima testados com resistor de 1k.
------------------------------------------------------------------------------------------
 

Considerações importantes:

  1. MUITO CUIDADO AO LIGAR OS PINOS!!!! Procure sempre o datasheet do relé utilizado para conferir a pinagem, ligar o seu arduino numa fonte 220V vai danificar mais que a placa.
  2. Se preferir comprar um relé de 5V você poderá ligar o RELAY_V+ ao pino 5V do arduino e deixar o pino RELAY_GND vazio, pois ja tem o ARDUINO_GND.
  3. Você poderá utilizar o 5V do arduino estando ligado a USB apenas para testes onde o consumo de corrente é baixo, NUNCA LIGUE MAIS DE 500mA NUMA PORTA USB evite até mesmo chegar perto deste valor.
Pra quem gosta de pcb ai esta o layout q eu fiz, podem usar a vontade, esse colorido é pra quem vai fazer na mão e o de baixo pra quem vai imprimir
(NÃO ESQUEÇA DE INVERTER A IMAGEM ANTES DE IMPRIMIR).





Layout Atualizado!!! O antigo continua valendo mas este está mais organizado e mais facil de fazer.


Não esqueça de inverter a imagem se for desenhar na mão, pois ela está como sendo vista do lado dos componentes e não do lado do cobre, quem for imprimir pra usar transfer pode imprimir do  jeito que está, resolução de 300dpi.


Video Enviado por com o Circuito em Questão!
Muito Obrigado pelo apoio!