Acelerômetro para Ensino de Física

Construção de dois protótipos baseados em Arduino que permitem armazenar ou transmitir dados de um acelerômetro e/ou giroscópio para análise dos dados em sala de aula. Os dispositivos também pode ser utilizados para medidas em campo. O primeiro é denominado de SD Card, pois armazena os dados em um cartão de memória. O segundo transmite dados por comunicação wireless. O desenvolvimento ficou a cargo de Alef Benedetti e Alexandre Weber orientados por Thomas Braun.

Avisos legais e licenciamento

Licença de software: GPL v2;
Licença de diagramas, imagens e explicações: Creative Commons Attribution 4.0 International Public License;
Licença de hardware: CERN Open Hardware License v1.1.

Aplicações

Um acelerômetro acoplado a uma placa Arduino forma uma verdadeira estação de ensino de física portátil. Com ele, é possível obter, em tempo real, dados da aceleração de um corpo, além de ter a disposição outros dados provenientes dela, como velocidade e deslocamento, e a possibilidade de facilmente plotar gráficos com os dados obtidos, fazendo uso de um software apropriado.
Com essa ferramenta em mãos, os estudantes em um laboratório de física podem investir seu tempo não na obtenção de medidas ou confecção de gráficos, mas sim em refletir sobre o significado do que estão medindo, e assimilar os conceitos físicos envolvidos no experimento; por exemplo, o tempo e o número de repetições necessárias em uma experiência simples de cinemática, como um objeto movendo-se em MRUV, é reduzido drasticamente. Verifica-se também, de maneira quase trivial, eventos contraintuitivos, como o fato de a aceleração de um corpo preso a um elástico e solto de certa altura, ser maior do que g.
Além da rapidez e praticidade concedida às aulas de física clássica experimental, a própria montagem do sistema, acoplando os componentes ao Arduino e programando-o, pode integrar uma sequência de aulas visando a familiarização e introdução dos alunos à eletrônica e computação elementares.

Protótipo I: Acelerômetro com SD Card

Este dispositivo é baseado em um SD Card e visa armazenar os dados da IMU (Unidade de Medida Inercial), colhidos em campo, para posterior análise em qualquer software que permite graficar dados salvos em um arquivo de texto.
Constituído por um Arduino UNO, um RTC (Real Time Clock), um SD Card e um MPU6050, é um dispositivo simples e fácil de ser implementado.

Diagrama de ligação do Fritizing

Esquemático do Fritizing para o Dispositivo I

Calibração

Neste caso, a calibração do dispositivo é feita com base em medidas da aceleração gravitacional antes do início de sua medida aplicação desejada. Esta calibração é necessária pois a construção dos dispositivos MEMS (dispositivos Micro-eletro-mecânicos) utiliza fenômenos físicos, que embora não tenham uma dependência direta com a temperatura, acabam tendo uma variação com esta devido às partes mecânicas do dispositivo. No caso da construção de acelerômetros, por exemplo, a capacitância é normalmente o que utilizamos para realizar a medida.
A calibração anterior à medida visa diminuir os erros causados pela flutuação nos dados captados pela IMU. Estes erros também podem ser diminuídos através da utilização do Filtro de Kalman, dando seguimento ao projeto.
A obtenção das constantes de calibração pode ser feita realizando uma medida de cada eixo do dispositivo em separado, antes da medida a qual deseja graficar. Deve-se alinhar o dispositivo em um dos três eixos coordenados, ligar o dispositivo por um determinado tempo e desligá-lo. Após repetir este procedimento nos três eixos, teremos medidas que representam a aceleração da gravidade em cada eixo. Através do valor médio da soma de todos os dados gravados para cada um dos eixos, e sabendo que a aceleração da gravidade tem valor de aproximadamente 9,8m/s², podemos realizar uma regra de três e assim obter o valor da constante de normalização. Antes de plotar os dados medidos na aplicação desejada, devemos dividir todos eles pelas respectivas constantes (como a análise neste dispositivo é feita à posteriori, a divisão dos dados pela constante não precisa ser implementada no sketch do Arduino).

Imagens do Protótipo Montado e da Calibração

Exemplo de dispositivo I montado no laboratório

Procedimento de calibração do eixo X
Calibração no eixo X

Procedimento de calibração do eixo Y
Calibração no eixo Y

Procedimento de calibração do eixo Z
Calibração no eixo Z

Código Arduino

Realiza medidas do IMU e salva os dados em um cartão de memória, separando medidas pela data e hora em que a medida terminou, através do controle feito por uma chave. Um contador indica o número de dados coletados, e tempo decorrido desde o início daquela medida também será impresso no cartão de memória. As unidades atribuídas às medidas do acelerômetro e do giroscópio são arbitrárias e dependem da calibração feita; o tempo é medido em milissegundos.
As bibliotecas utilizadas possuem referências no próprio sketch. O link para download encontra-se na inicialização da mesma (desde que esta não seja uma biblioteca presente no Arduino IDE).

//SD Card + RTC para aquisição de dados de um acelerômetro utilizado no ensino de física.
//Por Alef Benedetti; Alxandre Weber
//Licença: GPL v2

// Baseado no exemplo MPU6050_raw da biblioteca MPU6050 cujo repositório e termos de licença constam abaixo
//https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

// I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050 class
// 10/7/2011 by Jeff Rowberg <jeff@rowberg.net>
// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
//
// Changelog:
//     2011-10-07 - initial release
/* ============================================
I2Cdev device library code is placed under the MIT license
Copyright (c) 2011 Jeff Rowberg
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
===============================================*/

//Definindo as variáveis utilizadas ao longo do programa
unsigned long tempo_inicial=0;
int auxiliar = 999;
int chave = 5;
int i=0;

//Biblioteca básica Arduino IDE
#include <SPI.h>

// Biblioteca Wire utilizada pela biblioteca I2Cdev, que realiza a comunicação
//do MPU com o arduino. Está presente no Arduino IDE
#include "Wire.h" 

//Incluindo bibliotecas cujo repositório já foi citado
#include "I2Cdev.h" 
#include "MPU6050.h" 

// O endereço padrão para a comunicação I2C do MPUI é 0x68
// Parâmetros específicos são enviados, onde AD0 low = 0x68
// ou AD0 high = 0x69

//Definições do MPU e das variáveis utilizadas por ele
MPU6050 accelgyro;
int16_t ax, ay, az;
int16_t gx, gy, gz;

//Bibliotecas Cartão de memória básica no Arduino IDE
//Utilizando exemplo ReadWrite de domínio público
#include "SD.h" 

//Inicinando o arquivo
File myFile;

//Dando um nome ao arquivo
char arquivo_saida[30] = "Dados.txt";

//Bibliotecas relógio (https://github.com/adafruit/RTClib )
//Em domínio Público
#include "RTClib.h" 

//Iniciando o relógio
RTC_Millis rtc;

void setup()
{

    //A comunicação serial só é utilizada para fins de teste da conexão do MPU
    //Através desta comunicação podemos testar se o MPU e o SD card estão conectados ao arduino
    Serial.begin(115200);
    Wire.begin();
    Serial.println("Iniciando dispositivos I2C...");
    accelgyro.initialize();
    Serial.println("Testando a concexão dos dispositivos...");
    Serial.println(accelgyro.testConnection() ? "MPU6050 conexão bem sucedida" : "MPU6050 conexão falha");

    Serial.print("Iniciando SD card...");
    pinMode(10, OUTPUT);
    if (!SD.begin(4)) {
    Serial.println("SD Card conexão falha");
    return; }
    Serial.println("SD Card conecão bem sucedida");

     //Definindo o modo de operação do pino 10 atrelado ao SD Card 
     //e do pino 5, atrelado a chave do dispositivo
     pinMode(10, OUTPUT);
     pinMode(chave, INPUT);

    //Fazendo a leitura da hora inicial do sistema
    rtc.begin(DateTime(__DATE__, __TIME__));

      //Imprimindo o que estará presente em cada coluna do arquivo
      //de texto no cartão de memória
      myFile.print("Contagens");
      myFile.print("\t");
      myFile.print("Acel x"); 
      myFile.print("\t");
      myFile.print("Acel y"); 
      myFile.print("\t");
      myFile.print("Acel z"); 
      myFile.print("\t");
      myFile.print("Gyro x"); 
      myFile.print("\t"); 
      myFile.print("Gyro y"); 
      myFile.print("\t"); 
      myFile.print("Gyro z"); 
      myFile.print("\t");  
      myFile.println("Tempo");

      //Fechando o arquivo de saída
      myFile.close();
}

void loop()
{

  //Definindo com a função millis, o tempo em que determinada medida iniciou.
  //Assim ao ligar e desligar a chave, sempre teremos um tempo inicial que será o zero
  //da abscissa.
  tempo_inicial=millis();

  //Contador que permitirá saber quantos dados foram salvos. É útil na determinação das 
  //constantes, uma vez que bastará somar todos os valores medidos e dividir pelo valor de "i".
  i=0;

    //Abrindo o arquivo para escrita.
    myFile = SD.open(arquivo_saida, FILE_WRITE);

    //Testando se a chave está alta ou baixa.
    while(digitalRead(chave)==HIGH)
    {
      //Caso a chave esteja ligada, obtendo os valores de aceleração
      accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);

      //Imprimindo estes valores, junto do contador "i" no cartão de memória
      myFile.print(i);
      myFile.print("\t");
      myFile.print(ax); 
      myFile.print("\t");
      myFile.print(ay); 
      myFile.print("\t");
      myFile.print(az); 
      myFile.print("\t");
      myFile.print(gx); 
      myFile.print("\t"); 
      myFile.print(gy); 
      myFile.print("\t"); 
      myFile.print(gz); 
      myFile.print("\t"); 

      //Imprimindo o valor da função millis no tempo atual, descontada do valor
     //de tempo inicial. 
      myFile.println(millis()-tempo_inicial);

      //Somando um ao contador
      i++; 

      //Alterando o valor da variável auxiliar. Sempre que ao menos um dado for salvo,
      //queremos que ao desligar a chave, o valor de data e hora seja escrito no arquivo.
      auxiliar = 999;
    }
    //Fechando o arquivo de saída
    myFile.close();

  //Testando se a data e a hora precisam ser escritas no cartão de memória
  if(auxiliar==999)
  {
    //Iniciando a escrita no cartão de memória
    myFile = SD.open(arquivo_saida, FILE_WRITE);

    //Imprimindo os valores de data e hora
    DateTime now = rtc.now();
    myFile.print(now.year(), DEC);
    myFile.print('/');
    myFile.print(now.month(), DEC);
    myFile.print('/');
    myFile.print(now.day(), DEC);
    myFile.print(' ');
    myFile.print(now.hour(), DEC);
    myFile.print(':');
    myFile.print(now.minute(), DEC);
    myFile.print(':');
    myFile.print(now.second(), DEC);
    myFile.println();

    //Fechando o arquivo de saída
    myFile.close();

    //Alterando o valor da variável auxiliar, para que se no próximo loop
    //a chave permanecer desligara, este não imprima novamente o valor de data
    //e hora no cartão de memória
    auxiliar=0;
  }

}

Protótipo II: Acelerômetro com comunicação Wireless

É um dispositivo com maior valor agregado, pois demanda dois Arduinos UNO, dois módulos wireless NRF20L01+ e um MPU6050. Baseia-se em comunicação wireless e visa analisar em tempo real os dados colhidos, ampliando a gama de possíveis usos, a depender da criatividade do professor interessado.

Diagrama de ligação do Fritizing

Esquemático do Fritizing para o  emissor Dispositivo II

Emissor

Esquemático do Fritizing para o receptor Dispositivo II

Receptor

Calibração

Conforme citado no item calibração, do Dispositivo I, as IMU’s precisam ser calibradas. Neste caso, devido à comunicação wireless, a calibração necessita de alterações no sketch do Arduino emissor dos dados. Caso a aplicação não necessite de muita precisão, as constantes podem ser determinadas apenas uma vez, caso contrário, devido à variação com a temperatura já citada, é necessária uma calibração a cada uso. Para realizar a calibração, deve-se carregar o código de calibração no arduino emissor de dados. Este deve estar alinhado em um dos eixos, conforme exemplo nas imagens do Dispositivo I. Assim o código fará quinhentas medidas, calculará a média e retornará ao usuário este valor na serial do computador. Vale ressaltar que o código retornará valores para os três eixos e cabe ao usuário detectar qual deles está sob a ação da aceleração gravitacional. Com estes valores é possível realizar uma regra de três e determinar os valores das constantes "acel_x", "acel_y" e "acel_z", presente no início do sketch do emissor propriamente dito. Deve se realizar uma medida para cada eixo antes de carregar o sketch emissor, sendo necessário reiniciar o arduino após cada troca de eixo.

Imagens do Protótipo Montado

Exemplo de dispositivo II montado no laboratório

Código Arduino

Os dados medidos no IMU são enviados via wireless em tempo real à serial do computador. Dois sketches são necessários, um para o Arduino emissor de dados e outro para o Arduino receptor dos dados. Um terceiro software é utilizado na determinação das constantes de calibração. Na serial do computador, serão impressos os três valores de aceleração, referentes aos eixos x, y, z, respectivamente e aos três valores do giroscópio, também referentes aos eixos x, y, z, respectivamente. Uma sétima coluna apresenta o tempo em milissegundos referente ao instante em que cada dado foi medido em relação ao dado “zero”.
As bibliotecas utilizadas possuem referências no próprio sketch. O link para download encontra-se na inicialização da mesma (desde que esta não seja uma biblioteca presente o Arduino IDE).

Código Emissor utilizado para calibração
//Código utilizado para a calibração do Dispositivo II
//Por Alef Benedetti; Alxandre Weber
//Licença: GPL v2

// Baseado no exemplo MPU6050_raw da biblioteca MPU6050 cujo repositório e termos de licença constam abaixo
//https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

// I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050 class
// 10/7/2011 by Jeff Rowberg <jeff@rowberg.net>
// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
//
// Changelog:
//     2011-10-07 - initial release
/* ============================================
I2Cdev device library code is placed under the MIT license
Copyright (c) 2011 Jeff Rowberg
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
===============================================*/

//Biblioteca básica Arduino IDE
#include <SPI.h>

//Incluindo a biblioteca do módulo wireless
#include "RF24.h" 

//Iniciando um vetor que irá armazenar os dados do aceleômetro
double dados[8];

//Configuração do shield NRF24L01
RF24 radio(9,10);
const uint64_t pipe = 0xE8E8F0F0E1LL;

// Biblioteca Wire utilizada pela biblioteca I2Cdev, que realiza a comunicação
//do MPU com o arduino. Está presente no Arduino IDE
#include "Wire.h" 

//Incluindo bibliotecas cujo repositório já foi citado
#include "I2Cdev.h" 
#include "MPU6050.h" 

// O endereço padrão para a comunicação I2C do MPUI é 0x68
// Parâmetros específicos são enviados, onde AD0 low = 0x68
// ou AD0 high = 0x69

//Definições do MPU e das variáveis utilizadas por ele
MPU6050 accelgyro;
int ax, ay, az;
int gx, gy, gz;
int j = 0;

void setup(void)
{ //A comunicação serial só é utilizada para fins de teste da conexão do MPU
  //Através desta comunicação podemos testar se o MPU está conectando ao arduino
  Serial.begin(115200);
    Wire.begin();
    Serial.println("Iniciando dispositivos I2C...");
    accelgyro.initialize();
    Serial.println("Testando a concexão dos dispositivos...");
    Serial.println(accelgyro.testConnection() ? "MPU6050 conexão bem sucedida" : "MPU6050 conexão falha");

      //Iniciando a comunicação wireless
      radio.begin();
      radio.openWritingPipe(pipe);

  //Queremos que o código rode apenas uma vez, antes do arduino ser reiniciado, por este
  //motivo iremos utilizar o void setup

    //Zerando as variáveis onde iremos somar os valores para realizar a calibração
    dados[0] = 0;
    dados[1] = 0;
    dados[2] = 0;
    dados[3] = 0;
    dados[4] = 0;
    dados[5] = 0;

  //Este "for" irá realizar quinhentas medidas, e posteriormente irá imprimir a média dos dados
  //na serial do computador

    for(j=1; j<=1000; j++)
   {
      // Lendo os valores de aceleração e do giroscópio
      accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz); 

      //Somando os valores medidos a soma já existente
      dados[0] += ax;
      dados[1] += ay;
      dados[2] += az;
      dados[3] += gx;
      dados[4] += gy;
      dados[5] += gz;

      //Impressão, na tela, do número de medidas, 
      //o valor de cada uma e, no fim, a média de todas.

      Serial.print(j); Serial.print("\t");
      Serial.print(az); Serial.print("\t"); 
      Serial.println(dados[2]);
   }

     //Dividindo o valor da soma pelo número de medidas para calcular
     //a média
     dados[0] = dados[0]/1000;
     dados[1] = dados[1]/1000;
     dados[2] = dados[2]/1000;
     dados[3] = dados[3]/1000;
     dados[4] = dados[4]/1000;
     dados[5] = dados[5]/1000;
     dados[6] = 0;

     //Enviando os dados do vetor para o receptor;
     //Há dois envios de dados porque no primeiro é estabelecida comunicação
     //E no segundo, o envio do dado propriamente dito.
     radio.write( dados, sizeof(dados) );
     radio.write( dados, sizeof(dados) );

      Serial.println(dados[2]);
}

void loop(void)
{

 }

Código Emissor utilizado nas medidas
//Receptor wireless NRF24l01 para aquisição de dados de um acelerômetro utilizado no ensino de física.
//Por Alef Benedetti; Alxandre Weber
//Licença: GPL v2

// Baseado no exemplo MPU6050_raw da biblioteca MPU6050 cujo repositório e termos de licença constam abaixo
//https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

// I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050 class
// 10/7/2011 by Jeff Rowberg <jeff@rowberg.net>
// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
//
// Changelog:
//     2011-10-07 - initial release
/* ============================================
I2Cdev device library code is placed under the MIT license
Copyright (c) 2011 Jeff Rowberg
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
===============================================*/

//Definindo os valores das constantes de normalização. Conforme documentação
//estas constantes devem ser produzidas e adicionadas antes de uma medida de
//aceleração. Caso precisão não seje necessária, este procedimento pode ser 
//feito apenas uma vez. O valor padrão é "1" para que caso a calibração não
//seja realizada, o valor medido será o valor exato que é envidado pela IMU.
double acel_x=1;
double acel_y=1;
double acel_z=1;
double gyro_x=1;
double gyro_y=1;
double gyro_z=1;

//Biblioteca básica Arduino IDE
#include <SPI.h>

//Incluindo a biblioteca do módulo wireless
#include "RF24.h" 

//Iniciando um vetor que irá armazenar os dados do aceleômetro
double dados[8];

//Configuração do shield NRF24L01
RF24 radio(9,10);
const uint64_t pipe = 0xE8E8F0F0E1LL;

// Biblioteca Wire utilizada pela biblioteca I2Cdev, que realiza a comunicação
//do MPU com o arduino. Está presente no Arduino IDE
#include "Wire.h" 

//Incluindo bibliotecas cujo repositório já foi citado
#include "I2Cdev.h" 
#include "MPU6050.h" 

// O endereço padrão para a comunicação I2C do MPUI é 0x68
// Parâmetros específicos são enviados, onde AD0 low = 0x68
// ou AD0 high = 0x69

//Definições do MPU e das variáveis utilizadas por ele
MPU6050 accelgyro;
int ax, ay, az;
int gx, gy, gz;

void setup(void)
{ //A comunicação serial só é utilizada para fins de teste da conexão do MPU
  //Através desta comunicação podemos testar se o MPU está conectando ao arduino
  Serial.begin(115200);
    Wire.begin();
    Serial.println("Iniciando dispositivos I2C...");
    accelgyro.initialize();
    Serial.println("Testando a concexão dos dispositivos...");
    Serial.println(accelgyro.testConnection() ? "MPU6050 conexão bem sucedida" : "MPU6050 conexão falha");

      //Iniciando a comunicação wireless
      radio.begin();
      radio.openWritingPipe(pipe);

}

void loop(void)
{
    // Lendo os valores de aceleração e do giroscópio
    accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);

       //Caso necessário, pode se retirar as barras das linhas abaixo e 
       //utilizar comunicação serial para ver o resultado dos dados medidos

  //  Serial.print("a/g:\t");
  //  Serial.print(ax); Serial.print("\t");
  //  Serial.print(ay); Serial.print("\t");
  //  Serial.print(az); Serial.print("\t");
  //  Serial.print(gx); Serial.print("\t");
  //  Serial.print(gy); Serial.print("\t");
  //  Serial.println(gz);*/

  //Atribuindo ao vetor os valores medidos do IMU
  //Posições que contém zeros podem receber outras variáveis no futuro
  //A função millis() imprime o número de milisegundos desde a inicialização
  //do arduino. É necessária para podermos plotar o gráfico aceleração vs. tempo
  dados[0] = ax/acel_x;
  dados[1] = ay/acel_y;
  dados[2] = az/acel_z;
  dados[3] = gx/gyro_x;
  dados[4] = gy/gyro_y;
  dados[5] = gz/gyro_z;
  dados[6] = millis();

  //Enviando os dados do vetor para o receptor
  radio.write( dados, sizeof(dados) ); 

}

Código Receptor
//Receptor wireless NRF24l01 para aquisição de dados de um acelerômetro utilizado no ensino de física.
//Por Alef Benedetti; Alxandre Weber
//Licença: GPL v2

//Biblioteca básica Arduino IDE
#include <SPI.h>

//Biblioteca do shield NRF24L01
//https://github.com/maniacbug/RF24
#include "RF24.h" 

//Iniciando um vetor que receberá os dados do acelerômetro
double dados[8];

//Definições do shield NRF24L01
RF24 radio(9,10);
const uint64_t pipe = 0xE8E8F0F0E1LL;

void setup(void)
{
  //Iniciando a comunicação serial para vizualizar os dados no computador
  Serial.begin(115200);
  //Iniciando o NRF
  radio.begin();
  radio.openReadingPipe(1,pipe);
  radio.startListening();
}

void loop(void)
{
  //Testando se a comunicação wireless está ativa
  if ( radio.available() )
  {
    //Iniciando uma variável que irá testa se todos os dados do
    //vetor foram recebidos
    bool done = false;
    while (!done)
    {
      //Realizando a transmissão dos dados
      done = radio.read( dados, sizeof(dados) );

      //Imprimindo os dados na serial, seguidos de um "TAB" 
      Serial.print(dados[0]); Serial.print("\t");
      Serial.print(dados[1]); Serial.print("\t");
      Serial.print(dados[2]); Serial.print("\t");
      Serial.print(dados[3]); Serial.print("\t");
      Serial.print(dados[4]); Serial.print("\t");
      Serial.print(dados[5]); Serial.print("\t");
      //O "ln" no último print indica que este irá para uma 
      //nova linha
      Serial.print(dados[6]); Serial.println("\t");

    }
  }
  //Definindo um tempo de pausa de 5 milissegundos
  delay(5);
}

SD_RTC.ino - Código .ino Protótipo I (6,9 KB) Alef Benedetti, 29/09/2014 12:55

Emissor_final.ino - Código .ino Emissor Protótipo II (4,7 KB) Alef Benedetti, 29/09/2014 12:55

Receptor_final.ino - Código .ino Receptor Protótipo II (1,6 KB) Alef Benedetti, 29/09/2014 12:55

Exemplo_montagem_dispositivo_I.jpg - Exemplo de dispositivo I montado no laboratório (88,9 KB) Alef Benedetti, 29/09/2014 16:50

Exemplo_montagem_dispositivo_II.jpg - Exemplo de dispositivo II montado no laboratório (90,8 KB) Alef Benedetti, 29/09/2014 16:50

Calibração_eixo_X.jpg - Procedimento de calibração do eixo X (91,3 KB) Alef Benedetti, 29/09/2014 16:50

Calibração_eixo_Y.jpg - Procedimento de calibração do eixo Y (94,8 KB) Alef Benedetti, 29/09/2014 16:50

Calibração_eixo_Z.jpg - Procedimento de calibração do eixo Z (84,7 KB) Alef Benedetti, 29/09/2014 16:50

Esquemático_dispositivo_I.png - Esquemático do Fritizing para o Dispositivo I (48 KB) Alef Benedetti, 29/09/2014 17:26

Esquemático_emissor_dispositivo_II.png - Esquemático do Fritizing para o emissor Dispositivo II (40,6 KB) Alef Benedetti, 29/09/2014 17:26

Esquemático_receptor_dispositivo_II.png - Esquemático do Fritizing para o receptor Dispositivo II (32,5 KB) Alef Benedetti, 29/09/2014 17:26

Emissor_calibracao_final.ino (4,7 KB) Alexandre Weber, 30/09/2014 16:37