Páginas

sexta-feira, 25 de novembro de 2011

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.

segunda-feira, 7 de novembro de 2011

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

quinta-feira, 1 de setembro de 2011

Usando o arduino em experimentos didáticos de física

Você pode se perguntar: o que significa este negócio? O que raios é esse tal de arduino?

Arduino é um microcontrolador com inúmeras possibilidades didáticas, de comunicação, design, uma ferramenta multi-propósito bem interessante.
Veja abaixo, vídeos que se referem aos seus usos:

Primeiro, do que se trata (o que é, como instala, software, programação - visite: arduino.cc).

Agora, aplicações, projetos, curiosidades, coisas legais, nos links que se seguem:

http://www.youtube.com/watch?v=HYUYbN2gRuQ - aceleradores (em inglês)
http://www.youtube.com/watch?v=ATnnMFO60y8&feature=related - células solares (em inglês)
http://www.youtube.com/watch?v=Cif8Pq2dazk&feature=related - sensor de luminosidade e sequência de LED's (em espanhol)
http://www.youtube.com/watch?v=VY0kiJNI5oE&feature=related - construa seu arduino em uma placa-mãe. (em inglês)
http://www.youtube.com/watch?v=NGRqWaIECm8&feature=related - divertindo-se com o kit iniciante (arduino, cabos, LED's, Sensor de pressão, resistores, LDR's..., em inglês)

Enfim, são inúmeras as possibilidades, e o que se tem de melhor a fazer é mexer com elas. 

Então, mãos à massa:
vamos ver quais os projetos que estamos criando para este semestre.

Proposta experimental - oscilador amortecido

video
Apresentação referente à proposta de uso do arduino em experimentos com osciladores amortecidos, baseado no trabalho do pessoal da UFRJ (SOUZA, 2011, A placa Arduino: uma opção de baixo custo para experiências de física assistidas pelo PC), disponível em  http://www.scielo.br/pdf/rbef/v33n1/26.pdf

Além de testar a proposta decorrente do artigo, desenvolveremos experimentos com sensor ultrassônico, e compararemos os resultados das medições de período de oscilação e do coeficiente de amortecimento, com os nossos resultados obtidos reproduzindo a proposta original, na qual se utiliza um LDR para obter os dados de variação da luminosidade, convertendo em um sinal variável de tensão.

Alguns questionamentos acerca da proposta de  Souza et al, foram levantados e um deles diz respeito a ausência de linearidade de resposta do sensor LDR com a intensidade de luz. Assim faremos o mesmo experimento usando sistemas diferentes para a observação da evolução da amplitude do movimento com o tempo, para que possamos determinar o coeficiente de amortecimento.


Alem disso é nosso objetivo desenvolver diferentes aparatos para a verificação de oscilações amortecidas, a fim de se ter um sinal captado com maior intensidade, como forma de adequação didática.