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¶
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¶
Calibração no eixo X
Calibração no eixo Y
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¶
Emissor
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¶
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).
