Leitura do Acelerômetro da BlackBoard Edge

This tutorial is not available in English

Introdução

A BlackBoard Edge possui um acelerômetro de 3 eixos embarcado em seu circuito e neste tutorial você verá como lê-lo, mas também como aproveitar essas leituras em projetos.

Este tutorial é uma continuação do tutorial Primeiros Passos com a BlackBoard Edge, portanto sugerimos que siga todos os seus passos antes de seguir este tutorial.

Lista de Materiais

Cabo USB Micro B 80cm

R$ 9,40 no PIX

Observação: a BlackBoard Edge é vendida "sozinha", portanto é necessário adquirir um cabo Micro USB separadamente se não possuir um.

Conceitos Teóricos

Antes de vermos como ler os três eixos do acelerômetro da Edge, vamos entender um pouco melhor como os acelerômetros funcionam.

Acelerômetro

Um acelerômetro também pode ser chamado como transdutor, que é um dispositivo capaz de converter grandezas de uma natureza para outra. No caso, o acelerômetro é capaz de converter uma aceleração em energia elétrica. Existem diversas formas de se realizar essa conversão, porém o método mais comum usado nos acelerômetros mais populares no movimento maker é utilizando pelo menos uma massa consideravelmente pequena e um, ou alguns, sensores piezo elétricos. Ao mover a placa em que o acelerômetro está soldado, a massa interna do componente se move e os sensores piezo elétricos variam suas tensões de saída de acordo com a posição da massa sobre eles, como no GIF abaixo.

variacao-piezo — Variação de Tensão do Piezo Elétrico de Acordo com a Aceleração
Fonte: Sparkfun

A tensão de saída de cada sensor é então lida por um microcontrolador pré-programado no encapsulamento do acelerômetro, que trata a tensão lida e então transmite esses dados ("crus" e/ou tratados) para o microcontrolador principal (no caso da Edge, o ESP32) por um protocolo de comunicação (no caso do MMA8452 da Edge, o protocolo é o I2C).

O acelerômetro embarcado no circuito da Edge é capaz de medir a aceleração de 3 eixos em ambos os sentidos, como na imagem abaixo. Em ambos os sentidos as leituras variam entre 0 e 1 g, quando a única força sobre o sensor é a gravidade. A diferença é que o componente possui um sentido "de preferência" e, quando ele está direcionado para sentido oposto, os valores são negativos, ou seja, variam entre 0 e -1 g. Os valores extremos (1 e -1) indicam que o componente está completamente perpendicular em relação ao solo em um dos sentidos de orientação.

É comum usar o acelerômetro para medir apenas a gravidade (1 g), mas ele também pode ser usado para medir acelerações maiores. O MMA8452 da BlackBoard Edge, por exemplo, pode ser configurado para medir até 8 g.

eixo-acelerometro — Eixos de um Acelerômetro Triaxial
Fonte: Dr. Kstas Alexis

Na legenda da Edge estão demarcados os sentidos de leituras positivas dos três eixos do acelerômetro da placa, o que ajuda muito na previsão de comportamento dos eixos ao criar projetos.

Instalação da Biblioteca

A biblioteca de leitura do acelerômetro da Edge pode ser baixada diretamente pelo "Gerenciador de Bibliotecas" da IDE. Para acessá-lo, clique sobre o ícone de livros na seção lateral da Arduino IDE 2.0. Caso esteja utilizando uma versão anterior, siga o caminho da imagem abaixo, ou pressione "Ctrl+Shift+l".

caminho-biblioteca — Caminho para o "Gerenciador de Bibliotecas"

Com o gerenciador aberto, independentemente da versão da IDE, digite "robocore mma8452" no campo de pesquisa, como na imagem a seguir.

biblioteca-encontrada — Biblioteca Encontrada

Pressione o botão instalar e aguarde um pouco. Após alguns instantes a biblioteca estará instalada, como na próxima imagem.

Código

Com a biblioteca instalada, carregue o código a seguir para a sua Edge.

/*******************************************************************************
* Edge - Leitura do Acelerometro (V1.0)
* 
* Codigo de primeiro contato com o acelerometro da BlackBoard Edge.
* 
* Copyright 2023 RoboCore.
* Escrito por Giovanni de Castro (22/02/2023).
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

// Inclusao da biblioteca
#include "RoboCore_MMA8452Q.h"

// Criacao do objeto de leitura do acelerometro
MMA8452Q acelerometro;

void setup(){
  
  // Inicializacao do monitor serial
  Serial.begin(115200);

  // Inicializacao do acelerometro
  acelerometro.init();

}

void loop(){
  
  // Realiza a leitura do acelerometro
  acelerometro.read();

  // Exibe as leituras "cruas" no monitor serial
  Serial.print("Leituras Cruas: X = ");
  Serial.print(acelerometro.raw_x);
  Serial.print("| Y = ");
  Serial.print(acelerometro.raw_y);
  Serial.print("| Z = ");
  Serial.println(acelerometro.raw_z);

  // Exibe as leituras convertidas no monitor serial
  Serial.print("Leituras Convertidas: X = ");
  Serial.print(acelerometro.x);
  Serial.print("g | Y = ");
  Serial.print(acelerometro.x);
  Serial.print("g | Z = ");
  Serial.print(acelerometro.z);
  Serial.println("g");
  
  // Exibe o direcionamento da placa no monitor serial
  if(acelerometro.z > 0.8){
    Serial.println("CIMA");
  } else if(acelerometro.z < -0.8){
    Serial.println("BAIXO");
  } else if(acelerometro.x > 0.8){
    Serial.println("ESQUERDA");
  } else if(acelerometro.x < -0.8){
    Serial.println("DIREITA");
  } else if(acelerometro.y > 0.8){
    Serial.println("TRAS");
  } else if(acelerometro.y < -0.8){
    Serial.println("FRENTE");
  }

  // Aguarda 500 ms para repeticao
  Serial.println("");
  delay(500); 
  
}

Entendendo o Código

No início do código incluímos a biblioteca recém instalada ao código, e em seguida criamos o objeto acelerometro para a leitura de aceleração dos eixos do componente.

Nas configurações do código (função void setup()), apenas inicializamos o monitor serial na velocidade de 115200 bps e a comunicação I2C com o acelerômetro (função acelerometro.init()).

Já na repetição do código, realizamos a leitura dos eixos do acelerômetro pela função acelerometro.read(), e então exibimos no monitor serial as leituras "cruas" salvas nas variáveis acelerometro.raw_x, acelerometro.raw_y e acelerometro.raw_z. Em seguida, exibimos as leituras convertidas e salvas nas variáveis acelerometro.x, acelerometro.y e acelerometro.z. Depois verificamos se a leitura tratada de algum eixo está próximo de um dos extremos, e então exibimos no monitor serial em qual direção o ESP32 da placa está apontado. Por fim, apenas aguardamos 500 milissegundos antes de uma nova leitura do acelerômetro.

O Que Deve Acontecer

Após carregar o código para a placa, abra o monitor serial na velocidade de 115200 bps e monitore as leituras. Você verá que os valores "crus" e convertidos serão exibidos no monitor serial, juntamente com o sentido em que o ESP32 da placa está apontado, como na imagem abaixo.

Mova a placa em sentidos diferentes para ver o comportamento do acelerômetro e como o sentido apontado irá mudar de acordo com a direção em que a placa estiver direcionada.

Conclusão

Neste tutorial vimos como instalar a biblioteca de leitura do acelerômetro da Edge, como ele funciona, como realizar as leituras dos eixos e como usá-los em projetos.