Código da programação para experimento com osciladores amortecidos

Segue abaixo o código da programação criada para coleta dos dados de oscilações amortecidas, e visualização em tempo real destes dados no programa SimPlot, disponível gratuitamente na internet.

LINK1: Link de acesso a pasta pública do programa em .pde (linguagem do arduino):
http://dl.dropbox.com/u/65582938/Oscilador_Amortecido/Oscilador_Amortecido.pde

LINK2: E também o link para download do arduino 1.0:
http://files.arduino.cc/downloads/arduino-1.0-windows.zip

Com isso, é só baixar o arduino, caso você não o possua, e inserir o código do link 1 na IDE do arduino, e depois de montado todo o aparato, rodar o código, lembrando de sempre estar o arduino em acesso com o SimPlot (LINK 3, disponível em: http://code.google.com/p/projectsimplot/downloads/detail?name=SimPlot%20Ver1-1.zip&can=2&q=).

Vamos agora, à Programação:

/*
SimPlot Demo coleta as amostras da entrada digital, as envia através da porta serial para ser plotado no programa. Até 4 canais dos dados podem ser plotados no programa, que é uma versão de demontração.
Para maiores detalhes, acesse:
www.negtronics.com/simplot
*/

int led1 = 9; //led vermelho;
int led2 = 11;//led amarelo;
int led3 = 13;//led verde;
int Buzzer = 6; //microfone piezoelétrico;
int pingPin = 7;// Pino do ultrassom;

float cm; // Esta condição coloca que serão armazenados os dados de distância de aproximação do obj. 
//em rel. ao ultrassom ("float" indica que são dados considerando as casas decimais);
double Velocidade; // Definir a váriavel de velocidade; entrará no cálculo da distância
int temp=18;   // Temperatura ambiente medida manualmente, para fins didáticos, no calculo de //velocidade 
unsigned long time; // Só armazena tempos positivos;
double tempo; // Definir a variável de tempo;

void setup()
{
  Serial.begin(57600);
pinMode(7, INPUT); // Configura o pino 7, ultrassom (US), como entrada;
pinMode(6, OUTPUT); //Configura o pino 6, buzzer, como saida;
pinMode(13, OUTPUT); //Configura o pino 13, led verde, como saida;
pinMode(11, OUTPUT); //Configura o pino 11, led amarelo, como saida;
pinMode(9, OUTPUT); //Configura o pino 9, led vermelho, como saida;
}

int buffer[20]; //espaço de memória temporária, necessário para armazenar o pacote dos dados p/ //transmissão
int data1;

void loop()
{  long duration; // Estendendo a variável de tempo;
  pinMode(pingPin, OUTPUT); //Configurando a saida do pino do US;
  digitalWrite(pingPin, LOW); //Escreve um valor baixo para o pino digital do US (pino no terra);
  delayMicroseconds(2); //Definindo um atraso para uma nova leitura;
  digitalWrite(pingPin, HIGH); //Escreva um valor alto para o pino digital do US (pino no positivo)
  delayMicroseconds(5); // Definindo um atraso para uma nova leitura;
  digitalWrite(pingPin, LOW); //Escreva um valor baixo para o pino digital do US
 pinMode(pingPin, INPUT);   // termino de leitura no ultrassom;
 duration = pulseIn(pingPin, HIGH); //define duração como função de leitura de tempo (pulseIn)

//Observação sobre a função pulseIn() (arduino.cc)
//[quando o valor é alto, a função "pulseIn ()" espera para a leitura do pino chegar na condição HIGHT (alto), para //começar a contagem de tempo, depois aguarda a leitura de pulso do pino ir para baixo e para a contagem //de tempo. Então, a função retorna o comprimento do pulso em microssegundos, desiste e retorna 
//a um valor 0 caso nenhum pulso comece dentro de tempo estabelecido].

//retrornando às equações para medição da distância e tempo:
Velocidade = 334.1000+(0.61000*temp)  ; // equação de velocidade, em cm/s, retirada do site //"http://www.fisica.ufs.br/egsantana/ondas/acustica/sonido/sonido.htm"
cm = (duration*0.0001000*((Velocidade)/2));  // equação para a distância ser calculada em cm.
time = micros(); // a base de tempo tem que estar em micro para o funcionamento adequado do US
tempo = time/1000;  // deve-se obter distancia vs tempo, entao deve converter a função "time" p/ ms

  // condiçoes para acendimento dos leds e buzzer
  if (cm < 10.0000) { //Se a distância da  placa estiver menor do que 10 cm do sensor,
digitalWrite(led1, HIGH); //o led1 (led vermelho) será acesso
  }
else { //caso contrário,
digitalWrite(led1, LOW); //o led vermelho não acende;
}

if (cm < 15.0000){ //se estiver com a distância da placa menor do que 15cm, em relação ao sensor;
digitalWrite(led2, HIGH); //o led2 (led amarelo)será acesso;
}

else{//caso contrário
digitalWrite(led2, LOW); //o led amarelo não acende;
}

if (cm < 20.0000){ //se estiver com uma distância da placa menor que 20cm, em relação ao sensor,
digitalWrite(led3, HIGH); //o led verde ascende
}
else{//caso contrário
digitalWrite(led3, LOW);//o led verde não acende
}

if (cm < 10.0000){ //Se a placa estiver a menos de 10 cm do ultrassom,
digitalWrite(Buzzer, HIGH); //o Buzzer "apita";
}
else{ //caso contrário,
digitalWrite(Buzzer,LOW); //o buzzer não "apita".
}

{
  // impressao da distancia
  Serial.print(cm,3);
  Serial.print("  ");

 // impressão da velocidade
Serial.print(Velocidade,4);
Serial.print();

//impressão do tempo

Serial.print(tempo);
Serial.print("   ");
Serial.println("   ");

delay(100);
}

  //Leitura de canais analógicos.
  data1 = cm;


  //É possível se plotar até 4 canais por dados. Usamos apenas 1 canal, então, comentamos os outros 3 canais.
  // plot(data1,data2,data3,data4);   //Plota 4 canais de dados
//  plot(data1,data2,data3);       //Plota 3 canais de dados
//  plot(data1,data2);             //Plota 2 canais de dados
plot(data1);                   //Plota 1 canal de dados. Usamos esta opção.
delay(10); //Lê e registra entradas analógicas a cada 10ms.
}


void plot(int data1, int data2, int data3, int data4); //Função que toma 4 valores integrais e gera um //pacote a ser mandado ao SimPlot
{
  int pktSize;
 buffer[0] = 0xCDAB; //Cabeçalho do pacote de dados p/ o SimPlot. Indica o início do pacote de //dados;
 buffer[1] = 4*sizeof(int); //Tamanho dos dados em bytes. Não inclui nem cabeçaljo, nem tamanho //dos campos
 buffer[2] = data1;
  pktSize = 2 + 2 + (4*sizeof(int)); //Bytes do cabeçalho + Bytes do tamanho do campo + dados
  Serial.write((uint8_t * )buffer, pktSize); ////IMPORTANTE: Mude para a porta serial que está //conectada ao PC:
}


void plot(int data1, int data2, int data3); ////Função que toma 3 valores integrais e gera um pacote a ser //mandado ao SimPlot
{
   int pktSize;
 buffer[0] = 0xCDAB; //Cabeçalho do pacote de dados p/ o SimPlot. Indica o início do pacote de //dados;
 buffer[1] = 3*sizeof(int); //Tamanho dos dados em bytes. Não inclui nem cabeçaljo, nem tamanho //dos campos
 buffer[2] = data1;
  pktSize = 2 + 2 + (3*sizeof(int));  //Bytes do cabeçalho + Bytes do tamanho do campo + dados
  Serial.write((uint8_t * )buffer, pktSize); //IMPORTANTE: Mude para a porta serial que está //conectada ao PC:
}


void plot(int data1, int data2);  ////Função que toma 2 valores integrais e gera um pacote a ser mandado ao //SimPlot
{
   int pktSize;
 buffer[0] = 0xCDAB; //Cabeçalho do pacote de dados p/ o SimPlot. Indica o início do pacote de //dados;
 buffer[1] = 2*sizeof(int); //Tamanho dos dados em bytes. Não inclui nem cabeçaljo, nem tamanho //dos campos
 buffer[2] = data1;
  pktSize = 2 + 2 + (2*sizeof(int));  //Bytes do cabeçalho + Bytes do tamanho do campo + dados
  Serial.write((uint8_t * )buffer, pktSize); //IMPORTANTE: Mude para a porta serial que está //conectada ao PC:
}

void plot(int data1);  ////Função que toma 1 valores integrais e gera um pacote a ser mandado ao SimPlot

{
   int pktSize;
 buffer[0] = 0xCDAB; //Cabeçalho do pacote de dados p/ o SimPlot. Indica o início do pacote de //dados;
 buffer[1] = 1*sizeof(int); //Tamanho dos dados em bytes. Não inclui nem cabeçaljo, nem tamanho //dos campos
 buffer[2] = data1;
  pktSize = 2 + 2 + (1*sizeof(int));  //Bytes do cabeçalho + Bytes do tamanho do campo + dados
  Serial.write((uint8_t * )buffer, pktSize); //IMPORTANTE: Mude para a porta serial que está //conectada ao PC:
}