Introdução

Nesta edição irei evoluir um pouco mais as funcionalidades demonstradas no artigo publicado na edição 39 sobre o Accionamento de Servos Usando Arduino apresentando agora um artigo sobre o accionamento e controlo de servos usando o teclado do computador como input das acções pretendidas.

Desta forma será possível controlar a acção dos servos usando a interface das teclas do teclado para a definição das acções.

Para a implementação e controlo dos servos usando o teclado não é necessário efectuar qualquer alteração ao esquema eléctrico apresentado no artigo da edição 39, bastando apenas usar a tecnologia Processing como interface de ligação entre o utilizador e o micro-controlador Arduino.

Programação

A linguagem de programação Processing foi a linguagem de programação utilizada para a criação da interface que permitiu o controlo do micro-controlador.   Esta linguagem usa uma sintaxe muito semelhante à da linguagem de programação C e permite efectuar com alguma facilidade interfaces gráficas.

No entanto também disponibiliza algumas funcionalidades que permitem recolher o resultado do input de um dispositivo de entrada como o teclado ou o rato e usar essa mesma informação para despoletar uma acção.

Neste caso o Arduino estará conectado via porta de série, que na verdade é emulada pelo cabo USB. Usando a biblioteca processing.serial iremos recolher o input do teclado e enviá-lo para o micro-controlador Arduino em tempo real para que seja despoletada a acção pretendida.

O exemplo demonstrado irá ter apenas 5 acções em que as teclas UP, DOWN, RIGHT, LEFT e S que despoletam a acção de andar para a frente, para trás, para a direita, para a esquerda e para parar, respectivamente.

Arduino: Código-Fonte Utilizado

Apesar de as acções serem dadas a partir do teclado e recolhidas pela pequena aplicação programada usando a linguagem de programação Processing é necessário que o micro-controlador esteja programado de modo a saber reagir às acções despoletadas pelo utilizador.

Para isso usamos o seguinte código-fonte, que não é mais do que os movimentos pré-definidos em quem a recepção do código ASCII pertencente a determinada tecla recolhida pela função n = Serial.read(); se traduz numa acção real dos servos.

//Definição de Variáveis
int n;
int motorPin1 = 5;
int motorPin2 = 6;
int motorPin3 = 10;
int motorPin4 = 11;

void setup()
{
  Serial.begin(9600);
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop()
{
  //Verificar se a Porta de Série está disponível
  if (Serial.available() > 0)
  {
    n = Serial.read();
  }
  //Definição das Acções andar para a frente, para trás, para a direita, para a esquerda e para parar
  if (n == 119)
  {
    //Avançar
    digitalWrite(motorPin1, LOW);
    digitalWrite(motorPin2, HIGH);
    digitalWrite(motorPin3, HIGH);
    digitalWrite(motorPin4, LOW);
  }
  if ( n == 115)
  {
    //Recuar
    digitalWrite(motorPin1, HIGH);
    digitalWrite(motorPin2, LOW);
    digitalWrite(motorPin3, LOW);
    digitalWrite(motorPin4, HIGH);
  }
  if ( n == 100)
  {
    //Direita
    digitalWrite(motorPin1, LOW);
    digitalWrite(motorPin2, HIGH);
    digitalWrite(motorPin3, LOW);
    digitalWrite(motorPin4, HIGH);
  }
  if ( n == 97)
  {
    //Esquerda
    digitalWrite(motorPin1, HIGH);
    digitalWrite(motorPin2, LOW);
    digitalWrite(motorPin3, HIGH);
    digitalWrite(motorPin4, LOW);
  }
  if (n == 113)
  {
    //Parar
    digitalWrite(motorPin1, LOW);
    digitalWrite(motorPin2, LOW);
    digitalWrite(motorPin3, LOW);
    digitalWrite(motorPin4, LOW);
  }
}

Este será o código que estará armazenado pelo micro-controlador Arduino, e é em muito semelhante ao código apresentado no artigo publicado na edição 39, tempo apenas definidas as acções que serão realizadas pelos servos mediante o input recebido.

Processing: Interface Utilizador / Arduino

No exemplo em questão é o utilizador que irá despoletar as acções dos servos mediante o toque em determinadas teclas do teclado do computador, sendo neste caso as teclas UP, DOWN, RIGHT, LEFT e S despoletam a acção de andar para a frente, para trás, para a direita, para a esquerda e para parar, respectivamente.

Para que tal aconteça temos de criar uma “interface” entre o utilizador e o micro-controlador Arduino que irá então despoletar as acções sobre os servos. Para isso iremos utilizar uma pequena aplicação recorrendo à linguagem de programação Processing que irá servir de ponte entre a recolha das acções dadas pelo utilizador e a sua transmissão para o micro-controlador Arduino para que este as possa interpretar e processar.

//Definição da biblioteca utilizada
import processing.serial.*;

Serial myPort;

void setup()
{
  size(200,200); 

  noStroke();
  background(0);

  // Alteração "COM35para a Porta COM pretendida
  myPort = new Serial(this, "COM3", 9600);
}

void draw()
{
  //Seta avançar
  triangle(100 , 25, 75, 75, 125, 75);
  //Seta Esquerda
  triangle(75 , 125, 75, 75, 25, 100);
  //Seta Recuar
  triangle(75 , 125, 100, 175, 125, 125);
  //Seta Direita
  triangle(175 , 100, 125, 75, 125, 125);
}

void keyPressed()
{
  if (key == CODED)
  {
    if (keyCode == UP)
    {
      myPort.write(119);
      fill(153);
      //Seta avançar
      triangle(100 , 25, 75, 75, 125, 75);
      fill(255);
      //Seta Esquerda
      triangle(75 , 125, 75, 75, 25, 100);
      //Seta Recuar
      triangle(75 , 125, 100, 175, 125, 125);
      //Seta Direita
      triangle(175 , 100, 125, 75, 125, 125);
    }
    else if (keyCode == DOWN)
    {
      myPort.write(115);
      fill(153);
      //Seta Recuar
      triangle(75 , 125, 100, 175, 125, 125);
      fill(255);
      //Seta avançar
      triangle(100 , 25, 75, 75, 125, 75);
      //Seta Esquerda
      triangle(75 , 125, 75, 75, 25, 100);
      //Seta Recuar
      triangle(75 , 125, 100, 175, 125, 125);
      //Seta Direita
      triangle(175 , 100, 125, 75, 125, 125);
    }
    else if (keyCode == LEFT)
    {
      myPort.write(100);
      fill(153);
      //Seta Esquerda
      triangle(75 , 125, 75, 75, 25, 100);
      fill(255);
      //Seta Recuar
      triangle(75 , 125, 100, 175, 125, 125);
      //Seta avançar
      triangle(100 , 25, 75, 75, 125, 75);
      //Seta Esquerda
      triangle(75 , 125, 75, 75, 25, 100);
      //Seta Direita
      triangle(175 , 100, 125, 75, 125, 125);
    }
    else if (keyCode == RIGHT)
    {
      myPort.write(97);
      fill(153);
      //Seta Direita
      triangle(175 , 100, 125, 75, 125, 125);
      fill(255);
      //Seta Esquerda
      triangle(75 , 125, 75, 75, 25, 100);
      //Seta Recuar
      triangle(75 , 125, 100, 175, 125, 125);
      //Seta avançar
      triangle(100 , 25, 75, 75, 125, 75);
    }
  }
  else if (key == 's' || key == 'S')
  {
    myPort.write(113);
  }
}

A recolha e transmissão do input dado pelo utilizador através do teclado é feita usando a a biblioteca processing.serial.

No fundo o que esta pequena aplicação faz é verificar se alguma das teclas previamente referidas foi pressionada, caso a resposta seja positiva esta vai enviar a respectiva informação (código ASCII definido para a tecla em causa) através do comando myPort.write("código ASCII"); de modo a que este seja recebido pelo micro-controlador Arduino e de seguida seja interpretado e processado resultando numa acção por parte dos servos.

Conclusão

O artigo desta edição mostra apenas uma das inúmeras formas do utilizador controlar directamente e em tempo real as acções dos servos usando como “processador/interpretador” dos dados o micro-controlador Arduino.

Como se diz na gíria popular a criatividade de cada um é o limite, sendo que é possível aplicar este exemplo aos mais variados projectos recorrendo à agilidade e facilidade de programação do micro-controlador Arduino.