O QUE É ARDUINO?

Arduino, por vezes traduzida ao português como Arduíno,^[2] é uma plataforma dehardware livre, projetada com um microcontrolador Atmel AVR de placa única, com suporte de entrada/saída embutido e uma linguagem de programação padrão,^[3] na qual tem origem em Wiring, e é essencialmente C/C++.^[4] O objetivo do projeto é criar ferramentas que são acessíveis, com baixo custo, flexíveis e fáceis de se usar por artistas e amadores. Principalmente para aqueles que não teriam alcance aos controladores mais sofisticados e de ferramentas mais complicadas.^[5]

Pode ser usado para o desenvolvimento de independentes objetos interativos, ou ainda para ser conectado a um computador hospedeiro. Uma típica placa Arduino é composta por um controlador, algumas linhas de E/S digital e analógica, além de umainterface serial ou USB, para interligar-se ao hospedeiro, que é usado para programá-la e interagi-la em tempo real. Ela em si não possui qualquer recurso de rede, porém é comum combinar um ou mais Arduinos deste modo, usando extensões apropriadas chamadas de shield. A interface do hospedeiro é simples, podendo ser escrita em várias linguagens. A mais popular é a Processing, mas outras que podem comunicar-se com a conexão serial são: Max/MSP,^[6] Pure Data,^[7] SuperCollider,^[8] ActionScript^[9] eJava.^[10]

Este vídeo mostra um exemplo com o Arduíno pois é uma linguagem inicial onde deve haver resistor e led.

Código para Espectro Sonoro

Código da programação para experimento do espectrofotômetro com arduino

Segue, agora, a programação comentada utilizada para a coleta de dados do espectrofotômetro com arduino.


/*
 Stepper Motor Control - Espectrofotometro com motor de passo

 Este programa permite a leitua do número de voltas executado pelo motor de passo para um intervalo de step=1
 Com velocidade de ida e volta variáveis
 A indicaçao de que o sistema está efetuando a leitura é realizada atraves do acendimento de um LED no pino 3
 O led conectado no pino 2 indica que o sistema está retornando para o ponto de inicio de medida
 */
#include //chama a BIBLIOTECA "Stepper.h" (biblioteca do motor de passo)
int valorpino2=LOW; // declara a VARIÁVEL "valorpino2" (LED Vermelho) tipo inteiro e igual a BAIXO (0 Volts), este led indica o retorno do sensor
int valorpino3;     // declara a VARIÁVEL "valorpino3" (LED Verde) igual a inteiro, este led indica que a medida está sendo realizada
const int stepsPerRevolution = 48;  // indica o numero de passos/revolução, para o tipo de motor utilizado (específico p/ cada modelo de motor de passo)
// iniciar a BIBLIOTECA "stepper" pelos pinos pinos 8 a 11
Stepper myStepper(stepsPerRevolution, 8,9,10,11); // Função "passo" myStepper(número de passos, 2 ou 4 pinos que devem ser ligados ao motor;o 5º fio do motor é ligado a +5V da placa, que conecta-se ao pino correspondente do arduino)
int cont=0;            //declara a VARIÁVEL "cont" inteira e igual a 0
int stepCount = 0;     //declara a VARIÁVEL "stepCount" inteira e igual a 0
int intervaloIda=10;   //define a VARIÁVEL "intervaloIda" igual a 10, pode ser alterado pelo usuario, representa o intervalo de passos do motor para cada captura de dados
int velocidadeIda=200; //define a VARIÁVEL "velocidadeIda" igual a 100. Esta variável é a velocidade da varredura do sensor na Ida, pode ser alterada pelo usuario
int valorLDR;          //declara a VARIÁVEL "valorLDR" inteira. Esta variável recebe o valor lido no sensor LDR
int D = 85;           //declara a constante D igual ao comprimento do carro do scanner, em mm
int d = 1398;           //declara a constante d, a distancia entre os sulcos da rede de difração (CD), igual a 1660 linhas/nm (isso para o compdeonda ser em nm).
float senq;            //declara a VARIAVEL senq, o seno do angulo formado entre cursoremX e a hipotenusa, flutuante.
float n;               //declara a VARIÁVEL "N" flutuante. Esta variável será especificada na próxima seção.
float compdeonda;      // declara a VARIÁVEL referente ao comprimento de onda, podendo flutuar (variando as casas decimais, para maior precisão)
float cursoremX;       //declara a VARIÁVEL "cursoremX" flutuante. Esta variável será a responsável pela distância em X percorrida, e será o limite percorrido pelo motor.
float Dmenor;          //declara a VARIÁVEL "Dmenor" flutuante. Esta variável é o diametro da engrenagem menor
float I;// variavel proporcional a intensidade de luz
unsigned long time;    //declara a VARIÁVEL "time" ocupando 1 bit de memória. Esta variável...
void setup()           //declara o início da FUNÇÃO "setup" (configuração das portas e dos pinos)
{
  pinMode(2,INPUT);    //define o pino digital 2 como ENTRADA do motor para o arduino.
  pinMode(3,OUTPUT);   //define o pino digital 3 como SAÍDA do arduino para o motor.
  pinMode(A5,INPUT);   //define o pino analógico A5 como ENTRADA de dados (aquisição dos dados coletados pelo LDR).
  Serial.begin(9600);  //define a taxa de transmissão de dados entre o Arduíno e o computador (comunicação serial -USB- em 9600 bits por segundo).
}
void loop()            //define o inicio da FUNÇÃO loop. Verifica o valor das variáveis continuamente.
{
    //char leitura = Serial.read();
    time=millis(); //variável "time" é igual ao tempo que o Arduíno está operando em milisegundos.
    valorLDR=analogRead(A5); // define variável "valorLDR" igual à leitura do sinal vindo do LDR, na porta analógica A5
    I=1000.0/valorLDR;
    valorpino2=digitalRead(2); // define a variável "valorpino2" igual a leitura da porta digital 2. Isso acende LED vermelho no pino 2
    valorpino3=!valorpino2; // define a variável "valor pino2" igual a "valorpino2". Isso acende led verde no pino 3.
    //O ! indica que o LED conectado no pino 3, apresenta comportamento inverso ao LED do pino 2: ou seja, enq. o do pino 2 acende, o do pino 3 está apagado, e vice-versa.
    digitalWrite(3,valorpino3); //define o valor do pino3 (ALTO ou BAIXO) para o pino digital 3
    if (valorpino2==LOW) //se variável "valorpino2" igual a BAIXO
    /*
    Se valor da variável "valorpino2" estiver em BAIXO (5 OU 3.3 Volts).
    Pino 2 em BAIXO, faz com que o motor gire no sentido positivo de X, com velocidade definida e corre fazendo as leituras do LDR,
    até o limite em X definido.
    */
    //Então, " se a variável 'valorpino2' igual a BAIXO"
    {
      stepCount++; //soma-se 1 à variável stepCount, equivalente a "stepCount=StepCount+1"
      cont = stepCount; // declara a variável "cont" igual ao valor contido na variável "stepCount"
      n = cont*intervaloIda/48.000; //declara a variável "N" igual a "cont x intervalodeIda / 48 , com 3 casas decimais"
      //ou seja, N é o produto do numero de volta do motor, durante o intervalo de ida, em razão das voltas do motor
      Dmenor = 13.5;
      cursoremX = Dmenor * (n/10) * 3.14159; //declara a variável cursoremX, ou o quanto o motor faz o carro se deslocar em X, levando-se em consid. o diâmetro da engrenagem menor ("engrenagem-motora")e o número de voltas
          if (cursoremX > 30); //se a variável cursoremX for maior que 32.7 (limite que o cursor pode percorrer, o pino 2 sobe para HIGH
              {
               valorpino2==HIGH;
              }
      senq=(cursoremX)/sqrt((cursoremX*cursoremX)+(D*D));
      compdeonda = d * senq;
        {
        //Serial.print(cont);     // Imprime em caracteres ASCII a variável "cont" serial
       // Serial.print("   ");    // Imprime em caracteres ASCII "   "
        //Serial.print(n,5);      // Imprime em caracter es ASCII a variável "n" na porta 5
       // Serial.print("   ");    // Imprime em caracteres ASCII "   "
       Serial.print(I,3); // Imprime em caracteres ASCII a variável "proporcional a intensidade de luz"
       Serial.print("   ");    // Imprime em caracteres ASCII "   "
       //Serial.print(cursoremX);     // Imprime em caracteres ASCII a variável "cursoremX"
       //Serial.print("   ");    // Imprime em caracteres ASCII "   "
       Serial.print(compdeonda); //Imprime em caracteres ASCII a variável "compdeonda"
       Serial.print("   ");     // Imprime em caracteres ASCII "   "
        }
        {
        Serial.println();      // Imprime em caracteres ASCII uma nova linha
        }
  myStepper.setSpeed(velocidadeIda); //define a velocidade do motor em RPMs
  myStepper.step(intervaloIda);}     //aciona o motor
    if (valorpino2==HIGH )
        {
         cont=0;  //variável cont igual a 0
         stepCount=0; //variável stepCount=0
         myStepper.setSpeed(200); //define velocidade do motor em 200RPMs
         myStepper.step(-200); //aciona o motor em (-100) passos, na direção -X (a volta fica mais devagar)
       }      
}

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:
}