Mobile
Este breve tutorial explica como detectar a posição por meio do movimento. O módulo MPU6050 é um sensor de movimento, capaz de medir a aceleração e rotação em todos os três eixos de movimento (x, y, z) com precisão bastante boa.
Também possui um conversor ADC de 16 bits, que converte os dados em um valor digital e os envia para o Arduino via I2C.
Para obter mais informações sobre os produtos ou suas descrições técnicas, entre em nosso site Solectro Shop.
Conexão
O módulo é alimentado diretamente por Arduino , portanto, não precisamos de uma fonte de alimentação externa. Você precisará soldar os pinos ou conectores para usá-los em uma placa de ensaio ou com cabos DuPont. Neste exemplo, conectaremos o módulo à placa Arduino UNO via I2C.
O módulo é alimentado diretamente por Arduino , portanto, não precisamos de uma fonte de alimentação externa. Os pinos são conectados de acordo com a tabela:
Pino do sensor
Arduino por Arduino UNO
VCC
5V
GND
SCL
PARA 5
SDA
A4
INT
D0
Os outros dois pinos do módulo do sensor são conectados à sonda de medição usando os cabos fornecidos, conforme mostrado no diagrama a seguir:
Operação
Com o primeiro exemplo para este módulo, podemos obter os valores brutos ou RAW coletados pelo sensor e exibi-los no monitor serial.
Abra um novo esboço e cole o seguinte código:
// Incluímos a biblioteca para I2C
#include <Wire.h>
// Definimos o endereço I2C do MPU
// Dependendo do estado de AD0, o endereço pode ser 0x68 ou 0x69
# define MPU 0x68
// Nós definimos as taxas de conversão
#define A_R 16384.0
#define G_R 131.0
// Definimos a conversão de radianos para 180 graus / PI
#define RAD_A_DEG = 57.295779
// O MPU fornece os valores em inteiros de 16 bits
// Declaramos memórias para valores RAW
int16_t AcX;
int16_t AcY;
int16_t AcZ;
int16_t GyX;
int16_t GyY;
int16_t GyZ;
// Declaramos string de caracteres para os ângulos
float Acc [2];
float Gy [2];
ângulo de flutuação [2];
configuração vazia ()
{
// Inicializamos o I2C e a porta serial
Wire.begin ();
Wire.beginTransmission (MPU);
Wire.write (0x6B);
Wire.write (0);
Wire.endTransmission (true);
Serial.begin (9600);
}
void loop ()
// Lemos os valores do acelerômetro
Wire.write (0x3B); // Solicitamos o registro 0x3B - corresponde ao AcX
Wire.endTransmission (false);
Wire.requestFrom (MPU, 6, verdadeiro); // De 0x3B, 6 registros são solicitados
AcX = Wire.read () << 8 | Wire.read (); // Cada valor ocupa 2 registros
AcY = Wire.read () << 8 | Wire.read ();
AcZ = Wire.read () << 8 | Wire.read ();
// Lemos os valores do giroscópio
Wire.write (0x43);
Wire.requestFrom (MPU, 4, verdadeiro); // Ao contrário do acelerômetro, apenas 4 registros são solicitados
GyX = Wire.read () << 8 | Wire.read ();
GyY = Wire.read () << 8 | Wire.read ();
/ Mostramos os valores pelo monitor serial
Serial.print ("Acelerômetro bruto X:"); Serial.println (AcX);
Serial.print ("Acelerômetro bruto Y:"); Serial.println (AcY);
Serial.print ("Acelerômetro bruto Z:"); Serial.println (AcZ);
Serial.print ("Gross giroscópio Y:"); Serial.println (GyX);
Serial.print ("Gross giroscópio X:"); Serial.println (GyY);
Serial.print ("Gross giroscópio Y:"); Serial.println (GyZ);
// Esperamos 1 segundo para poder visualizar no monitor serial
atraso (1000);
Assim que o projeto for carregado, abrimos o Monitor Serial na guia Ferramentas e podemos ver os valores brutos capturados:
Como um segundo exemplo, mostramos como, com este módulo, captar o ângulo de inclinação atual. Copie o seguinte código em um esboço vazio:
// Definimos a conversão de radianos para graus 180 / PI
// Declaramos memórias para os valores brutos
// Calculamos os ângulos Y, X respectivamente.
Acc [1] = atan (-1 * (AcX / A_R) / sqrt (pow ((AcY / A_R), 2) + pow ((AcZ / A_R), 2))) * RAD_TO_DEG;
Acc [0] = atan ((AcY / A_R) / sqrt (pow ((AcX / A_R), 2) + pow ((AcZ / A_R), 2))) * RAD_TO_DEG;
// Calculamos o ângulo do giroscópio
Gy [0] = GyX / G_R;
Gy [1] = GyY / G_R;
// Aplicamos um filtro complementar
Ângulo [0] = 0,98 * (Ângulo [0] + Gy [0] * 0,010) + 0,02 * Acc [0];
Ângulo [1] = 0,98 * (Ângulo [1] + Gy [1] * 0,010) + 0,02 * Acc [1];
// Mostramos os valores através do monitor serial
Serial.print ("Ângulo X:"); Serial.println (Ângulo [0]);
Serial.print ("Ângulo Y:"); Serial.println (ângulo [1]);
Depois que o projeto é carregado, abrimos o Monitor Serial na guia Ferramentas e podemos ver os valores brutos dos ângulos X e Y capturados:
Finalmente, também podemos instalar a biblioteca "MPU6050.h" como de costume a partir do "Library Manager" e usar o seguinte código em um novo esboço:
#include "I2Cdev.h"
#include "MPU6050.h"
#include "Wire.h"
// Dependendo do estado do AD0, o endereço pode ser 0x68 ou 0x69, a fim de controlar o escravo que irá ler através do barramento I2C
Sensor MPU6050;
// Valores RAW ou brutos lidos no acelerômetro e giroscópio nos eixos x, y, z
int ax, ay, az;
int gx, gy, gz;
void setup () {
Serial.begin (57600); // Função para iniciar a porta serial com 57600 baud
Wire.begin (); // Comece para o barramento I2C
sensor.initialize (); // A partir do sensor MPU6050
if (sensor.testConnection ()) Serial.println ("Sensor iniciado com sucesso");
else Serial.println ("Erro ao iniciar o sensor");
void loop () {
// Leia acelerações e velocidades angulares
sensor.getAcceleration (& ax, & ay, & az);
sensor.getRotation (& gx, & gy, & gz);
// Mostra as leituras que está registrando separadas por uma guia
Serial.print ("a [xyz] g [xyz]: \ 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);
atraso (100);
Cujo esquema de conexão é o seguinte: