Já tinha apresentado anteriormente uma experiência de controlar o meu robot através do teclado, mas era necessário usar o SerialMonitor para fazer a leitura das teclas desejadas.

No entanto existe a possibilidade de recorrer a tecnologia “Processing” para criar uma solução mais directa para o controlo do robot, e foi o que eu explorei agora.

Recorrendo à tecnologia “Processing” criei o seguinte código no qual uso as teclas “UP”, “DOWN”, “RIGHT”, “LEFT” e “S” para andar para a frente, para trás, para a direita, para a esquerda e para parar, respectivamente.

O código criado é o seguinte:

import processing.serial.*;

Serial myPort;

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

  noStroke();
  background(0);

  // Change "COM35" by your board's COM port
  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);
  }
}

No futuro ainda irei fazer algumas melhorias no código pelo que depois colocarei mais informação acerca deste assunto.

Share

Mais uma vez fiz uns pequenos progressos na área da robótica, mas propriamente no controlo do meu RobóticTank através do teclado do computador.

Para fazer isto recorri ao seguinte código:

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()
{

if (Serial.available() > 0)
{
n = Serial.read();

Serial.print(“Voce Digitou: “);
Serial.println(n, BYTE);

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)
{
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, LOW);
digitalWrite(motorPin3, LOW);
digitalWrite(motorPin4, LOW);
}
}

Utilizando este código no Arduino e recorrendo ao SerialMonitor é possível controlar os movimentos do RobóticTank, ainda que com algumas limitações e sendo necessário ter o cabo sempre conectado ao Arduino.

Desta forma consegui alguns progressos e brevemente irei explorar as técnicas de “processing” que são mais indicadas para estas acções.

Aqui fica um pequeno vídeo com a demonstração dos resultados obtidos:

Nos próximos dias vou tentar evoluir um pouco mais esta solução e se possível recorrer à biblioteca “processing”!

Share

Durante o dia de hoje aventurei-me a explorar o controlo do Arduino através do teclado do computador. Como todos aqueles que seguem as minhas aventuras com o Arduino desde o inicio sabem, o grande objectivo é controlar um Robot através de um teclado ou joystick comunicando através de uma tecnologia sem fios.

Como neste momento ainda não me é possível fazer tudo isto comecei a explorar a comunicação entre o teclado e o Arduino com a ligação COM.

Pelo que li muito brevemente pela Internet existe uma biblioteca chamada “processing” que é destinada a esta operação, mas eu ainda não a implementei estando a usar um método mais rudimentar.

Para executar esta experiência usei apenas o Arduino conectado ao computador via porta COM e usando o seguinte código:

int n=0;

void setup()
{
Serial.begin(9600);
}

void loop()
{
if (Serial.available() > 0)
{
n = Serial.read();

Serial.print(“Valor digitado: “);
Serial.println(n, BYTE);
Serial.print(“Valor Lido: “);
Serial.println(n);
}
}

Após ter feito o upload do código para o Arduino, recorri ao Serial Monitor para efectuar a leitura dos dados, que surgiam da seguinte forma:

Nos próximos dias vou tentar evoluir um pouco mais esta solução e se possível recorrer à biblioteca “processing”, mas algo que eu gostaria mesmo de usar e não encontrei nada esclarecedor na Internet é sobre o uso das teclas não digitáveis do teclado, tais como as setas!

Share

Após ter conseguido colocar o sensor de temperatura LM335A a funcionar correctamente surgiu a ideia de guardar todas as leituras num ficheiro de texto para que pudessem ser acedidas posteriormente.

Após algumas pesquisas verifiquei que o Arduino não tem capacidade de efectuar a leitura e a gravação dos dados num ficheiro alojado no computador tal só é possível se utilizar-mos um cartão de memória SD e gravarmos os dados directamente.

Mas existem algumas aplicações que nos permitem guardar as leituras, no computador, mas funcionam como aplicações externas. Uma delas é o Termite 2.8 que eu escolhi usar.

Aqui fica uma imagem do Termite 2.8 a efectuar a leitura da Porta COM e a guardar os dados num fichiro “.txt”:

Após os dados terem sido guardados são apresentados da seguinte forma:

Além deste tipo de solução tentei ainda implementar via código uma forma de guardar a data e a hora do momento em que a temperatura foi medida, mas não obtive nenhum resultado positivo.

O Termite 2.8 poderá ser obtido Aqui:

Neste momento ando à procura de soluções para conseguir verificar a data e a hora de cada leitura através do Arduino, caso algum dos visitantes tenha alguma dica que me possa ajudar seria óptimo.

Share

Com o sensor de temperatura a funcionar correctamente hoje decidi explorar um pouco mais a programação do Arduino relativamente ao Sensor LM335A.

O objectivo de hoje era criar um alerta quando uma determinada temperatura fosse ultrapassada, fazendo ainda acender um LED verde quando a temperatura estivesse num intervalo “seguro” e quando esse intervalo fosse ultrapassado acenderia o LED Vermelho. Confesso que esta solução não foi difícil de conseguir.

O esquema electrónico que utilizei foi:

O código utilizado foi:

float temp;
int tempPin = 0;
int ledPin1 = 13;
int ledPin2 = 12;

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

void loop()
{
temp = analogRead(tempPin);
temp = (((temp/1023)*5)*100)-273.15;

Serial.print(“A Temperatura é de: “);
Serial.println(temp);
delay(5000);

if (temp <= 18.5)
{
digitalWrite(ledPin1, HIGH);
delay(1000);
digitalWrite(ledPin1, LOW);
delay(1000);
}

if (temp >= 18.5)
{
digitalWrite(ledPin2, HIGH);
delay(1000);
digitalWrite(ledPin2, LOW);
delay(1000);
}

}

Aqui fica um vídeo do resultado da experiência:

Agora que tenho a certeza que a implementação do sensor de temperatura esteja correcta, irei num próximo passo tentar apresentar a temperatura num Graphic LCD 84×48 – Nokia 5110.

Share