Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Construa uma Bússola Digital em Tempo Real com Arduino e Processing

Neste Projeto Arduino, veremos como podemos fazer esta bússola legal usando um Arduino, um Magnetômetro MEMS e a IDE Processing. Aqui está um vídeo de demonstração da bússola:

Visão Geral

Tudo o que precisamos para este projeto é um Magnetômetro MEMS, para medir o campo magnético da Terra, uma Placa Arduino e alguns fios jumpers. Como exemplo, usarei o HMC5883L, um Magnetômetro de 3 Eixos integrado na placa breakout GY-80.

Como a Bússola Funciona

Parte Arduino

Primeiro, precisamos obter os dados do sensor usando a Placa Arduino via protocolo I2C. Em seguida, usando os valores dos eixos X e Y do sensor, calcularemos o rumo e enviaremos seu valor para a IDE Processing via Porta Serial. O seguinte código fará esse trabalho:

/* Bússola Arduino
 * por Dejan Nedelkovski,
 * www.HowToMechatronics.com
 */
#include <Wire.h> // Biblioteca I2C Arduino
#define Magnetometer_mX0 0x03
#define Magnetometer_mX1 0x04
#define Magnetometer_mZ0 0x05
#define Magnetometer_mZ1 0x06
#define Magnetometer_mY0 0x07
#define Magnetometer_mY1 0x08
int mX0, mX1, mX_out;
int mY0, mY1, mY_out;
int mZ0, mZ1, mZ_out;
float heading, headingDegrees, headingFiltered, declination;
float Xm,Ym,Zm;
#define Magnetometer 0x1E // Endereço I2C 7-bit do HMC5883

void setup(){
  // Inicializar comunicações Serial e I2C
  Serial.begin(115200);
  Wire.begin();
  delay(100);
  Wire.beginTransmission(Magnetometer);
  Wire.write(0x02); // Selecionar registrador de modo
  Wire.write(0x00); // Modo de medição contínua
  Wire.endTransmission();
}

void loop(){
  //---- Eixo X
  Wire.beginTransmission(Magnetometer); // transmitir para dispositivo
  Wire.write(Magnetometer_mX1);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer,1);
  if(Wire.available()<=1) {
    mX0 = Wire.read();
  }
  Wire.beginTransmission(Magnetometer); // transmitir para dispositivo
  Wire.write(Magnetometer_mX0);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer,1);
  if(Wire.available()<=1) {
    mX1 = Wire.read();
  }
  //---- Eixo Y
  Wire.beginTransmission(Magnetometer); // transmitir para dispositivo
  Wire.write(Magnetometer_mY1);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer,1);
  if(Wire.available()<=1) {
    mY0 = Wire.read();
  }
  Wire.beginTransmission(Magnetometer); // transmitir para dispositivo
  Wire.write(Magnetometer_mY0);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer,1);
  if(Wire.available()<=1) {
    mY1 = Wire.read();
  }
  //---- Eixo Z
  Wire.beginTransmission(Magnetometer); // transmitir para dispositivo
  Wire.write(Magnetometer_mZ1);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer,1);
  if(Wire.available()<=1) {
    mZ0 = Wire.read();
  }
  Wire.beginTransmission(Magnetometer); // transmitir para dispositivo
  Wire.write(Magnetometer_mZ0);
  Wire.endTransmission();
  Wire.requestFrom(Magnetometer,1);
  if(Wire.available()<=1) {
    mZ1 = Wire.read();
  }
  //---- Eixo X
  mX1=mX1<<8;
  mX_out =mX0+mX1; // Dados brutos
  // Do datasheet: 0.92 mG/dígito
  Xm = mX_out*0.00092; // Unidade Gauss
  //* Campo magnético da Terra varia de 0.25 a 0.65 Gauss, então esses são os valores que precisamos obter aproximadamente.
  //---- Eixo Y
  mY1=mY1<<8;
  mY_out =mY0+mY1;
  Ym = mY_out*0.00092;
  //---- Eixo Z
  mZ1=mZ1<<8;
  mZ_out =mZ0+mZ1;
  Zm = mZ_out*0.00092;
  // ==============================
  // Calculando Rumo
  heading = atan2(Ym, Xm);
  // Corrigindo o rumo com o ângulo de declinação dependendo da sua localização
  // Você pode encontrar seu ângulo de declinação em: https://www.ngdc.noaa.gov/geomag-web/
  // Na minha localização são 4.2 graus => 0.073 rad
  declination = 0.073;
  heading += declination;
  // Corrigindo quando sinais são invertidos
  if(heading <0) heading += 2*PI;
  // Corrigindo devido à adição do ângulo de declinação
  if(heading > 2*PI) heading -= 2*PI;
  headingDegrees = heading * 180/PI; // O rumo em graus
  // Suavizando o ângulo de saída / Filtro passa-baixa
  headingFiltered = headingFiltered*0.85 + headingDegrees*0.15;
  // Enviando o valor do rumo pela Porta Serial para IDE Processing
  Serial.println(headingFiltered);
  delay(50);
}

Se você precisar de mais detalhes sobre como o Magnetômetro MEMS funciona e como obter dados dele, pode conferir meu Tutorial de Sensores MEMS.

Parte IDE Processing

Aqui, primeiro precisamos receber os valores de rumo vindos da Porta Serial. Para mais detalhes sobre como isso é feito, você pode conferir meu Tutorial Arduino e Processing.

A bússola é na verdade uma imagem, ou mais precisamente, é composta por múltiplas imagens transparentes carregadas na IDE Processing. As imagens devem estar localizadas no diretório de trabalho do sketch. Após definir os objetos de imagem na seção draw(), usando a função image(), carregamos a imagem de fundo (que é opcional, você pode usar apenas uma cor simples para o fundo). Em seguida, a imagem da Bússola é carregada, que usando a função rotateZ() é rotacionada com os valores do rumo. No topo delas, a imagem da Seta da Bússola é carregada.

Aqui está o Código da IDE Processing:

/* Bússola Arduino
 * por Dejan Nedelkovski,
 * www.HowToMechatronics.com
 */
import processing.serial.*;
import java.awt.event.KeyEvent;
import java.io.IOException;
Serial myPort;
PImage imgCompass;
PImage imgCompassArrow;
PImage background;
String data="";
float heading;

void setup() {
  size (1920, 1080, P3D);
  smooth();
  imgCompass = loadImage("Compass.png");
  imgCompassArrow = loadImage("CompassArrow.png");
  background = loadImage("Background.png");
  myPort = new Serial(this, "COM4", 115200); // inicia a comunicação serial
  myPort.bufferUntil('\n');
}

void draw() {
  image(background,0, 0); // Carrega a imagem de fundo
  pushMatrix();
  translate(width/2, height/2, 0); // Translada o sistema de coordenadas para o centro da tela, para que a rotação aconteça bem no centro
  rotateZ(radians(-heading)); // Rotaciona a Bússola em torno do Eixo Z
  image(imgCompass, -960, -540); // Carrega a imagem da Bússola e, como o sistema de coordenadas foi relocado, precisamos definir a imagem em -960x, -540y (metade do tamanho da tela)
  popMatrix(); // Traz o sistema de coordenadas de volta à posição original 0,0,0
  image(imgCompassArrow,0, 0); // Carrega a imagem da Seta da Bússola que não é afetada pela função rotateZ() por causa da função popMatrix()
  textSize(30);
  text("Heading: " + heading,40,40); // Imprime o valor do rumo na tela
  delay(40);
}

// Inicia leitura de dados da Porta Serial
void serialEvent (Serial myPort) {
  data = myPort.readStringUntil('\n');// lê os dados da Porta Serial e coloca na variável String "data"
  heading = float(data); // Convertendo o valor String em Float
} 

Aqui você pode baixar os arquivos do projeto, as imagens e os códigos fonte:

Processo de manufatura

  1. Crie um Sistema Ambilight Impressionante para Monitor com Arduino
  2. Construa um Dispositivo de Levitação Ultrassônica com Arduino – Guia Passo a Passo
  3. Controle Remoto Universal Android com Arduino, 1Sheeld e IR
  4. Construa um Voltímetro Inteligente com Arduino e Smartphone – Projeto DIY Fácil
  5. Medição Precisa de Frequência e Ciclo de Trabalho com Arduino UNO
  6. Crie um Botão de Teclado "Socável" Personalizado com Arduino: Guia Passo a Passo
  7. Medição de Distância em Tempo Real com Sonar Arduino e Visualização no Processing
  8. Contador Inteligente de Vagas: Rastreamento de Veículos em Tempo Real com Arduino, Processing e PHP
  9. Controle Suave de Brilho de LED com Bolt IoT e Arduino UNO
  10. Braço Robótico Inteligente Controlado por Arduino: Tutorial DIY Fácil