Persistence of Vision

Já ouviu falar de “Persistence Of Vision” (POV) ou, em português bem claro, “Persistência Da Visão”? Não? Esse é o nome do fenômeno responsável por nos causar a ilusão de movimento quando uma imagem, vista pelo olho humano, persiste na retina durante uma minúscula fração de segundo logo após sua captura. Basicamente, se forem projetadas dezesseis ou mais imagens continuamente no espaço de tempo de um segundo, o olho humano não vai ser capaz de capturar a mudança entre elas, gerando um movimento do que aparenta ser uma mesma imagem. Essa nada mais é que a técnica utilizada pelos filmes e animações.
Foi baseado nesse fenômeno que surgiram os POV displays. A ideia é ser capaz de exibir uma mensagem, seja texto, desenho ou apenas símbolos, utilizando uma fileira de LEDs, um motor, alguns componentes básicos e o Arduino.

Para a criação desse POV com Arduino, nós utilizamos:
1 – Arduino Uno
1 – Motor de leitor de CD-ROM;
6 – LEDs;
6 – Resistores;
1 – CD-ROM velho;
1 – Bateria alcalina de 9V;
1 – Adaptador para energia;
1 – Protoboard;
9 – Fios;
1 – Base para fixação;
1 – Fonte de energia;
X – Parafusos;

A BASE
A forma que encontramos de criar nossa base foi utilizando um CD-ROM velho, que tem o formato ideal para a realização da rotação e espaço necessário para acomodação dos componentes (protoboard com os leds, bateria e o Arduino). Distribuídos lado a lado de forma que não prejudicasse o movimento, a bateria com adaptador para energia foi fixada ao lado do Arduino para facilitar a alimentação dele, já que o próprio objetivo do projeto impedia que ele fosse alimentado via USB por razões físicas óbvias. Na placa, foram configurados como saída os pinos digitais 2, 3, 4, 5, 6 e 7. Um para cada LED respectivamente, que se encontram dispostos na protoboard, interligados pelos resistores que foram soldados abaixo para não escaparem durante o movimento.

O MOTOR
O CD foi colado ao motor do leitor de CD-ROM e este fixado numa base de três pés. Já que não arranjamos nada mais pesado para estabilizar o movimento, ainda precisamos segurar a base com pelo menos duas mãos. O motor é acionado através de dois fios conectados a um carregador bivolt que é ligado à energia elétrica. Foi feita a opção pelo acionamento em separado do Arduino, pelo fato de o motor estar abaixo da base e isso ocasionar uma possível falha ou defeito durante a rotação.

A LÓGICA
Enquanto fazíamos as pesquisas a respeito do POV utilizando o Arduino, levantamos alguns dilemas. Dentre eles, um dos principais foi: como medir com mais eficácia a frequência (velocidade de rotação) do motor sem utilizar nada mais além do que temos, sem deixar de considerar a variação causada pelo peso do aparato fixo ao CD? A alternativa foi procurar algo que já existisse e que pudéssemos adaptar. No fim, como o peso e a variação da base alteraram a estabilidade / velocidade do conjunto como um todo, foi importante ter levantado esse questionamento desde o começo. A ideia por trás de todo esse aparato é criar símbolos (no nosso caso, letras) que possam ser escritos utilizando-se da piscada dos LEDs que, de acordo com a frequência de rotação do disco, sejam capazes de formar conjuntos (no nosso caso, palavras) que se repitam de forma estática criando a ilusão de um display que transmita algum tipo de mensagem.

O CÓDIGO
Essa foi nossa primeira experiência com o Arduino além das atividades práticas propostas em sala de aula. Nosso primeiro grande projeto não-tão-grande-assim. Pelo tempo proposto para a idealização, criação e elaboração do projeto ser curto em relação a outros casos que já vivemos, decidimos por reutilizar uma tipografia já existente e adaptá-la às nossas necessidades. A fonte original é do Professor de Design de Interação Michael Zöllner, da Universidade de Ciências Aplicadas Hof, Alemanha. Ela está disponível no site do autor (http://i.document.m05.de) ou diretamente no link http://goo.gl/q0ue9Q. As alterações básicas realizadas foram a alteração do tamanho de cada símbolo, o espaçamento entre as letras e principalmente a relação de frequência de exibição de acordo com o motor e o material existente.
Utilizamos a plataforma Arduino 1.6.5 para a codificação, disponível para download pelo próprio site do sistema em https://www.arduino.cc/en/Main/Software. Mas não se limita apenas a ele, já que pode ser codificado em qualquer editor de texto. Contudo, para realizar o carregamento do código para a placa, é preciso ter o software ou semelhante instalado no computador.

/*
 * POV - Persistence of Vision
 * Tipografia com Arduino. Fonte original: Michael Zoellnet. http://i.document.m05.de
 * Alterado e adaptado por: Gustavo Magalhães, Marcelo Rocha, Marcus Vinicius Acioly e Robson Ugo Souza
 * Bacharelandos em Sistemas de Informação
 * Universidade Federal Rural de Pernambuco - UFRPE.
 * 
 */
int _[] = {0,0,0,0,0,0, 0,0,0,0,0,0, 0,0,0,0,0,0};
int A[] = {1,1,1,1,1,1, 1,0,1,0,0,0, 1,1,1,1,1,1};
int B[] = {1,1,1,1,1,1, 1,0,1,0,0,1, 1,1,0,1,1,1};
int C[] = {0,1,1,1,1,0, 1,0,0,0,0,1, 1,0,0,0,0,1};
int D[] = {1,1,1,1,1,1, 1,0,0,0,0,1, 0,1,1,1,1,0};
int E[] = {1,1,1,1,1,1, 1,0,1,0,0,1, 1,0,1,0,0,1};
int F[] = {1,1,1,1,1,1, 1,0,1,0,0,0, 1,0,1,0,0,0};
int G[] = {0,1,1,1,1,1, 1,0,0,1,0,1, 1,0,0,1,1,1};
int H[] = {1,1,1,1,1,1, 0,0,0,1,0,0, 1,1,1,1,1,1};
int I[] = {1,0,0,0,0,1, 1,1,1,1,1,1, 1,0,0,0,0,1};
int J[] = {0,0,0,0,1,1, 1,0,0,0,0,1, 1,1,1,1,1,1};
int K[] = {1,1,1,1,1,1, 0,0,1,0,0,0, 0,1,0,1,1,1};
int L[] = {1,1,1,1,1,1, 0,0,0,0,0,1, 0,0,0,0,0,1};
int M[] = {1,1,1,1,1,1, 0,1,1,0,0,0, 1,1,1,1,1,1};
int N[] = {1,1,1,1,1,1, 0,1,0,0,0,0, 0,1,1,1,1,1};
int O[] = {1,1,1,1,1,1, 1,0,0,0,0,1, 1,1,1,1,1,1};
int P[] = {1,1,1,1,1,1, 1,0,0,1,0,0, 1,1,1,0,0,0};
int Q[] = {1,1,1,1,1,1, 1,0,0,0,1,1, 1,1,1,1,1,1};
int R[] = {1,1,1,1,1,1, 1,0,0,1,0,0, 1,1,1,0,1,1};
int S[] = {0,1,0,0,0,1, 1,0,1,0,0,1, 1,0,0,1,1,0};
int T[] = {1,0,0,0,0,0, 1,1,1,1,1,1, 1,0,0,0,0,0};
int U[] = {1,1,1,1,1,1, 0,0,0,0,0,1, 1,1,1,1,1,1};
int V[] = {1,1,1,1,0,0, 0,0,0,0,1,1, 1,1,1,1,0,0};
int W[] = {1,1,1,1,1,1, 0,0,0,1,1,0, 1,1,1,1,1,1};
int X[] = {1,1,0,0,1,1, 0,0,1,1,0,0, 1,1,0,0,1,1};
int Y[] = {1,1,1,0,0,0, 0,0,0,1,1,1, 1,1,1,0,0,0};
int Z[] = {1,0,0,0,1,1, 1,0,1,1,0,1, 1,1,0,0,0,1};
int letterSpace;
int dotTime;
void setup()
{
  // pinos
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
 
  // espaco entre as letras (ms)
  letterSpace = 6;
  // tempo do blink (ms)
  dotTime = 3;
 
}
void printLetter(int letter[])
{
  int y;
 
  // primeira linha y da letra
  for (y=0; y<7; y++)
  {
    digitalWrite(y+2, letter[y]);
  }
  delay(dotTime);
 
  // segunda linha y da letra
  for (y=0; y<7; y++)
  {
    digitalWrite(y+2, letter[y+6]);
  }
  delay(dotTime);
 
  // terceira linha y da letra
  for (y=0; y<7; y++)
  {
    digitalWrite(y+2, letter[y+12]);
  }
  delay(dotTime);
 
  // printing the sspace between the letters
  for (y=0; y<7; y++)
  {
    digitalWrite(y+2, 0);
  }
  delay(letterSpace);
}
void loop()
{
  //escreva aqui uma palavra de ate 9 caracteres. se for menor, preencha o restante com _
  printLetter(E);
  printLetter(H);
  printLetter(_);
  printLetter(D);
  printLetter(E);
  printLetter(Z);
  printLetter(_);
  printLetter(_);
  //printLetter(_);
 }

O RESULTADO
Curtiu o resultado? Nós adoramos! Começamos com esse projeto que, apesar de parecer simples, foi um grande desafio. Esperamos poder continuar no mundo do Arduino e aproveitar cada vez mais as milhares de ideias que podemos ter.
Pode conferir um pouco de como ficou aqui:

https://goo.gl/LE6XBm