Hoje decidi melhorar e aprimorar um pouco a aplicação que efectuava o tratamento dos dados recolhidos  guardados no ficheiro txt, de modo a tornar a aplicação um pouco mais complexa e com mais funcionalidades:

O código criado é o seguinte:

#include <stdio .h>
#include <stdlib .h>
 
#define N 100
 
float temperatura[N];
int num_linhas = 0, i;
 
void lerficheiro()
{
    FILE *entrada;
 
    entrada=fopen("log.txt","r");
 
    if(entrada==NULL)
    {
        printf("Erro na abertura do ficheiro de entrada\n");
        system("pause");
    }
    else
    {
        while(fscanf(entrada, "Temperatura =    %f\n", &amp; temperatura[i]) != EOF)
        {
            printf("Temperatura =   %f \n", temperatura[i]);
            num_linhas = num_linhas + 1;
 
            i++;
        }
 
        printf("\n\n");
        //printf("Numero de Linhas = %d\n", num_linhas);
    }
}
 
int main()
{
    int escolha;
 
    printf("\t\t\t\t***MENU***");
    printf("\n\n");
    printf("1 - Ler Ficheiro de Dados:\n");
    printf("2 - Calcular a Média das Temperaturas:\n");
    printf("3 - Verificar Temperatura Maxima:\n");
    printf("4 - Verificar Temperatura Minima:\n");
    printf("5 - SAIR\n");
    printf("\n");
    printf("Opcao:");
    scanf("%d", &amp;escolha);
 
    switch(escolha)
    {
        case 1:
        {
            printf("\n\n1- Escolheu Ler o Ficheiro de Dados:\n\n");
 
            lerficheiro();
 
            break;
 
        }
 
        case 2:
        {
            printf("\n\n2 - Escolheu Calcular a Media das Temperaturas:\n\n");
 
            lerficheiro();
 
            float soma_temp = 0, temp_media = 0;
            int j;
 
            for(j = 0; j < num_linhas; j++)
            {
                soma_temp = soma_temp + temperatura[j];
                temp_media = soma_temp / num_linhas;
            }
 
            printf("Media = %f", temp_media);
 
            break;
        }
 
        case 3:
        {
            float temp_max = 0;
            int j;
 
            lerficheiro();
 
            printf("\n\n3 - Verificar Temperatura Maxima:\n\n");
 
            for(j = 0; j < num_linhas; j++)
            {
                if (temperatura[j] > temp_max)
                {
                    temp_max = temperatura[j];
                }
            }
 
            printf("Temperatura Maxima = %f", temp_max);
 
            break;
        }
 
        case 4:
        {
            float temp_min;
            int j;
 
            lerficheiro();
 
            printf("\n\n3 - Verificar Temperatura Minima:\n\n");
 
            for(j = 0; j < num_linhas; j++)
            {
                temp_min = temperatura[0];
 
                if (temperatura[j] < temp_min)
                {
                    temp_min = temperatura[j];
                }
            }
 
            printf("Temperatura Minima = %f", temp_min);
 
            break;
        }
 
        case 5:
        {
            printf("Escolheu SAIR:");
            exit(0);
        }
 
    }while(escolha != 5);
}

Calculo da Média das Temperaturas:

Verificação da Temperatura Máxima:

Verificação da Temperatura Mínima :

O código que criei ainda está um pouco desorganizado pois ainda não me encaixo muito bem com a passagem de parâmetros para as funções. Tenho a plena consciência que a minha aplicação ainda pode ser muito melhorada, mas caso alguém tenha dicas ou ideias dos melhoramentos que fosso efectuar estarei disposto a ouvir e implementar.

Já à muito tempo que não mexia no meu Arduino e restantes sensores, mas agora que a faculdade terminou e que estou práticamente de “férias” voltei a ter algum tempo livre e vontade para fazer mais algumas evoluções e experiências.

O objectivo desta experiência era fazer a leitura das temperaturas do LM335A e guarda-las num ficheiro txt de modo a posteriormente com uma simples aplicação escrita em C (escolhi esta linguagem por ser a linguagem com que tenho mais à vontade neste momento e por ser relativamente fácil de manipular ficheiros txt) que faria a leitura dos dados guardados no ficheiro txt e calcularia algumas das estatísticas sobre esses mesmo dados guardados.

No entanto nem tudo tem sido assim tão fácil, pois guardar os dados num ficheiro txt automaticamente e e fazer com que eles sejam actualizados após determinado tempo não se revelou ser tarefa fácil, pelo que ainda ando à procura de uma solução para isso.

De momento estou a usar a aplicação Termite 2.8, tal como usei aqui: Projecto Robótica – Temperature Sensor LM335A – Leitura e Gravação de Dados   mas esta pequena aplicação não grava os dados automaticamente ao fim de determinado tempo, o que faz com que eu não tenha sempre os dados actualizados disponíveis no ficheiro para que a aplicação possa tratar esses dados.

Apesar destas dificuldades efectuei uma gravação de alguns dados recolhidos manualmente afim de começar a elaborar a aplicação em C, e o resultado que alcancei até agora, ainda que muito rudimentar é o seguinte:

O código fonte da aplicação é o seguinte:

#include
#include 
 
#define N 100
 
FILE *entrada;
float temperatura[N];
int num_linhas = 0, i;
 
lerficheiro()
{
    system("CLS");
 
    entrada=fopen("log.txt","r");
 
    if(entrada==NULL)
    {
        printf("Erro na abertura do ficheiro de entrada\n");
        system("pause");
    }
    else
    {
        while(fscanf(entrada, "Temperatura =    %f\n", & temperatura[i]) != EOF)
        {
            printf("Temperatura =   %f \n", temperatura[i]);
            num_linhas = num_linhas + 1;
 
            i++;
        }
 
        printf("\n\n");
        printf("Numero de Linhas = %d\n", num_linhas);
    }
}
 
int main()
{
    float soma_temp, temp_media;
    int j;
 
    lerficheiro();
 
    for(j = 0; j < num_linhas; j++)
    {
 
        soma_temp = soma_temp + temperatura[j];
        temp_media = soma_temp / num_linhas;
    }
 
    printf("\n\n");
    printf("A Temperatura Media e = %f", temp_media);
}

O código da aplicação ainda está muito pobre e provavelmente muito ineficiente, mas no futuro irei implementar mais funcionalidades assim como um MENU, de modo a tornar a aplicação mais completa e robusta.

Se alguém conhecer uma forma de automatizar a gravação e a leitura dos dados do Arduino + LM335A para o ficheiro txt agradecia que me indicasse essa forma de modo a eu poder evoluir o meu projecto.

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.

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:

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!