Giroscópio e acelerômetro

Introdução

Sabemos que no mundo atual estamos rodeados de muita tecnologia, com câmeras, internet, dispositivos inteligentes e muito mais ao nosso redor. Para termos ideia, em um simples smartphone podemos ter mais de 10 sensores, muitos deles com um funcionamento “atrás das cortinas”, funcionando de uma forma quase imperceptível, porém muitas vezes essencial para determinadas funcionalidades. Dois desses sensores, além de estarem presentes nos smartphones, são parte essencial de aviões, drones, entre outros… Esses sensores são chamados de giroscópio e acelerômetro.

Giroscópio

Um giroscópio mecânico consiste essencialmente em uma massa giratória que gira em torno de seu eixo. Em particular, quando a massa está girando em seu eixo, ela tende a permanecer paralela a si mesma e a se opor a qualquer tentativa de mudar sua orientação. Esse mecanismo foi inventado em 1852 pelo físico Léon Foucault durante seus estudos sobre a rotação da Terra. Se um giroscópio for instalado em suportes cardan que permitem que a massa navegue livremente nas três direções do espaço, seu eixo giratório permanecerá orientado na mesma direção, mesmo que o suporte mude de direção. “Traduzindo” essa definição, o giroscópio consegue detectar com precisão para onde o corpo está se movendo, tendo um funcionamento parecido com a bússola, mas em vez de depender dos campos magnéticos terrestres, utiliza a medida do momento angular.

Giroscópio analógico. Fonte: unloveablesteve/CC BY-NC-SA 2.0.

Porem, como tudo no mundo modero diminui de tamanho e sofre alterações (risos) o giroscópio tradicional também teria que sofrer disso. Hoje existem modelos milimétricos chamados de MEMS que utilizam tecnologia mecânica milimétrica. Muito mais pratica e precisa, é normalmente utilizada em celulares e tablets.

Acelerômetro

O acelerômetro é um dispositivo utilizado para medir as forças aplicadas sobre um corpo, baseando-se na teoria da relatividade geral. Podendo ser construido de várias formas como o giroscópio, em suma, pode ser entendido como uma estrutura que varia de posição de acordo com a força aplicada no eixo. Certos acelerômetros podem ser de 3 eixos para medidas tridimensionais e também podem ser do tipo MEMS que são componentes micro-mecânicos. É esse componente que em seu celular detecta se o próprio está na vertical ou na horizontal.

Exemplo de utilização

Como dito anteriormente, existem vários tipos de giroscópios e acelerômetros, de todos os tamanhos, preços e tecnologias. Neste artigo vamos demonstrar como utilizar o MPU6050, um circuito integrado muito completo com um acelerômetro e um giroscópio de 3 eixos cada.

Módulo MPU6050. Fonte: Nevit Dilmen (talk) / CC BY-SA 3.0.

PRINCIPAIS Características

Baixo consumo de corrente;
Conversor ADC de 16 bits integrado;
Comunicação I²C;
Calibração vinda de fábrica;
Acelerômetro de eixo triplo de saída digital com uma faixa de escala total programável de ±2g, ±4g, ±8g e ±16g;
Giroscópio com eixos X, Y e Z de saída digital com uma faixa de escala total programável pelo usuário de ±250, ±500, ±1000 e ±2000°/s;
Para mais características veja este link: MPU-6050.

Este chip pode ser utilizado em brinquedos, controles, drones, celulares e muito mais.

Para demonstrarmos o funcionamento do módulo, utilizaremos o próprio com o Arduino Uno para leitura e análise de sinais lidos pelo sensor.

Exemplo

O sensor pode ser utilizado para várias aplicações, entre elas:

Fazer um algoritmo para detecção de gestos utilizando o acelerômetro em uma luva;
Com a aplicação acima é possível ligar uma lâmpada, um ventilador ou qualquer outra coisa apenas com gestos;
Detectar a rotação de um objeto;
Detectar se o objeto está em queda, podendo, por exemplo, ser utilizado como um sensor de queda de idosos;
Medir a distância deslocada ou a velocidade com base na aceleração.

Aqui, iremos demonstrar um exemplo de um “alarme angular” que pode ser utilizado em próteses ortopédicas: quando o sensor detecta uma certa abertura, um alarme é disparado.

Esquema

O módulo pode ter uma tensão de entrada (VCC) entre 3v e 5v.

Código

// Programa de teste do aceletômetro / giroscópio MPU6050
//
// Referências:
//
// [1] MPU-6000/MPU-6050 Register Map and Descriptions
//     Disponível em https://invensense.tdk.com/wp-content/uploads/2015/02/MPU-6000-Register-Map1.pdf
//
// [2] https://www.filipeflop.com/blog/tutorial-acelerometro-mpu6050-arduino/
//
//
// Criado por: Erick León, 2022
//
// Adaptado por: Lucas Jácome

int buzzer = 7;
#include<Wire.h>                           // Biblioteca para comunicação I2C
const int endereco_MPU = 0x68;             // Variável que irá armazenar o endereço I2C do módulo MPU6050
int eixo_X, eixo_Y, eixo_Z, Tmp, GyX, GyY, GyZ;     // Criando variaveis de inclinação e acelaração.

// esta função só roda uma vez, no início
void setup()
{
    Serial.begin(115200);                  // Inicia comunicação serial com velocidade de 115200bps
    pinMode(buzzer,OUTPUT);
    
    Wire.begin();                          // Iniciando comunicação I2C
    Wire.beginTransmission(endereco_MPU);  // Iniciando transmissão para o endereço do MPU6050
    //Inicializa o MPU-6050 com clock interno 8MHz
    Wire.write(0x6B);                      // Gerenciamento de energia do módulo.
    Wire.write(0);                         // Ver [1], pág. 40
    Wire.endTransmission(true);
}

// esta função se repete indefinidamente
void loop()
{
    Wire.beginTransmission(endereco_MPU);
    Wire.write(0x3B);                        // Começando com o registrador 0x3B (ACCEL_YOUT_H). Ver [1], pág. 29
    Wire.endTransmission(false);
    
    //Solicita 14 bytes de dados do módulo MPU6050
    Wire.requestFrom(endereco_MPU, 14, true);
    
    // Armazena o valor dos 7 sensores nas variáveis correspondentes
    // Cada medida possui 16-bits, ou seja, é formada por dois bytes:
    eixo_Y = Wire.read() << 8 | Wire.read(); // 0x3B (ACCEL_YOUT_H) & 0x3C (ACCEL_YOUT_L)
    eixo_X = Wire.read() << 8 | Wire.read(); // 0x3D (ACCEL_XOUT_H) & 0x3E (ACCEL_XOUT_L)
    eixo_Z = Wire.read() << 8 | Wire.read(); // 0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
    Tmp = Wire.read() << 8 | Wire.read();    // 0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L)
    GyX = Wire.read() << 8 | Wire.read();    // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L)
    GyY = Wire.read() << 8 | Wire.read();    // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
    GyZ = Wire.read() << 8 | Wire.read();    // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L)
    
    Serial.print("Temp= "); Serial.print((Tmp/340)+36.53);       // Envia valor da temperatura para a serial. Ver [1] pág. 30
  
    Serial.print("\tInclin_X= "); Serial.print(eixo_X/180);      // Envia inclinação no eixo X para a serial
    Serial.print("\tInclin_Y= "); Serial.print(eixo_Y/180);      // Envia inclinação no eixo Y para a serial
    Serial.print("\tInclin_Z= "); Serial.print(eixo_Z/180);      // Envia inclinação no eixo Z para a serial
    
    Serial.print("\tVel.Inclinacao_X= "); Serial.print(GyX/180); // Envia velocidade de rotação no eixo X para a serial
    Serial.print("\tVel.Inclinacao_Y= "); Serial.print(GyY/180); // Envia velocidade de rotação no eixo Y para a serial
    Serial.print("\tVel.Inclinacao_Z= "); Serial.print(GyZ/180); // Envia velocidade de rotação no eixo Z para a serial
    
    Serial.println("");
    //Aguarda 100 ms e reinicia o processo
    delay(100);
    if (Gyz > 40)
    {
      digitalWrite(buzzer,HIGH|);
      delay(1000);
      digitalWrite(buzzer,LOW);
      delay(1000);
    }
}

Entendendo o código

Na linha 15 definimos o pino onde está ligado o alarme (buzzer). Em seguida, incluímos a biblioteca Wire, responsável pela comunicação I2C, e definimos o endereço do módulo MPU6050 (0x68). Na linha 18, criamos as variáveis que irão armazenar os ângulos e suas variações nos 3 eixos, e o valor da temperatura, que também é disponibilizada pelo módulo.

Nas linhas 23 a 31 temos nossa função setup(), que roda apenas uma única vez quando a placa Arduino é ligada. Ela configura a comunicação serial para transmissão dos dados para o computador com uma velocidade de 115200bps, define o pino do alarme como de saída, e inicializa o módulo MPU6050.

Nas linhas 37 a 73 temos nossa função loop(), que fica repetindo indefinidamente até que a placa seja desligada. Aqui enviamos ao módulo um comando informando quais dados serão lidos (linhas 37 a 39), e em seguida lemos os 7 dados (3 posições angulares, 1 temperatura e 3 velocidades angulares), nas linhas 42 a 52. Como cada dado é composto por 16 bits, ou 2 bytes, temos que ler 2 bytes por vez, e fazer uma conta para transformar os 2 bytes recebidos em um único valor. Isso é feito nas linhas 46 a 52.

De posse dos dados, agora enviamos os dados pela porta serial o computador, nas linhas 54 a 62. Aqui também convertemos os valores lidos para as unidades que estamos acostumados, como temperatura em graus Celsius e ângulos em graus.

Na linha 66 aguardamos 100 milissegundos, de modo que o processo se repita aproximadamente 10 vezes por segundo.

Por último, verificamos se a velocidade angular no eixo z ultrapassou um certo limite predeterminado (no caso, 40), e em caso positivo tocamos o alarme por 1 segundo. Vocês podem alterar a variável lida e o valor limite conforme a aplicação, verificando se algum eixo ultrapassou determinado ângulo, por exemplo.

Texto por: Lucas Jácome Cabral

Revisão: Erick León