¿Alguna vez te has preguntado cómo hacer una brújula personalizada con Arduino y Processing IDE? ¡En este artículo te enseñaremos el paso a paso para que puedas crear tu propia brújula electrónica! Con la ayuda de estos dos programas, podrás tener una brújula funcional y divertida de utilizar. ¡Sigue leyendo para descubrir todos los detalles!
En este proyecto Arduino veremos cómo podemos hacer esta atractiva brújula usando un Arduino, un magnetómetro MEMS y el IDE de procesamiento. Aquí hay un vídeo de demostración de la brújula:
descripción general
Todo lo que necesitamos para este proyecto es un magnetómetro MEMS para medir el campo magnético de la Tierra, una placa Arduino y algunos cables de puente. Como ejemplo, usaré el HMC5883L, un magnetómetro de 3 ejes integrado en la placa de conexión GY-80.
Cómo funciona la brújula
parte arduino
Primero necesitamos obtener los datos del sensor usando la placa Arduino mediante el protocolo I2C. Luego, según los valores del eje X y del eje Y del sensor, calculamos el rumbo y enviamos su valor al IDE de procesamiento a través del puerto serie. El siguiente código realiza esta tarea:
/* Arduino Compass
*
* by Dejan Nedelkovski,
* www.HowToMechatronics.com
*
*/
#include <Wire.h> //I2C Arduino Library
#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 //I2C 7bit address of HMC5883
void setup(){
//Initialize Serial and I2C communications
Serial.begin(115200);
Wire.begin();
delay(100);
Wire.beginTransmission(Magnetometer);
Wire.write(0x02); // Select mode register
Wire.write(0x00); // Continuous measurement mode
Wire.endTransmission();
}
void loop(){
//---- X-Axis
Wire.beginTransmission(Magnetometer); // transmit to device
Wire.write(Magnetometer_mX1);
Wire.endTransmission();
Wire.requestFrom(Magnetometer,1);
if(Wire.available()<=1)
{
mX0 = Wire.read();
}
Wire.beginTransmission(Magnetometer); // transmit to device
Wire.write(Magnetometer_mX0);
Wire.endTransmission();
Wire.requestFrom(Magnetometer,1);
if(Wire.available()<=1)
{
mX1 = Wire.read();
}
//---- Y-Axis
Wire.beginTransmission(Magnetometer); // transmit to device
Wire.write(Magnetometer_mY1);
Wire.endTransmission();
Wire.requestFrom(Magnetometer,1);
if(Wire.available()<=1)
{
mY0 = Wire.read();
}
Wire.beginTransmission(Magnetometer); // transmit to device
Wire.write(Magnetometer_mY0);
Wire.endTransmission();
Wire.requestFrom(Magnetometer,1);
if(Wire.available()<=1)
{
mY1 = Wire.read();
}
//---- Z-Axis
Wire.beginTransmission(Magnetometer); // transmit to device
Wire.write(Magnetometer_mZ1);
Wire.endTransmission();
Wire.requestFrom(Magnetometer,1);
if(Wire.available()<=1)
{
mZ0 = Wire.read();
}
Wire.beginTransmission(Magnetometer); // transmit to device
Wire.write(Magnetometer_mZ0);
Wire.endTransmission();
Wire.requestFrom(Magnetometer,1);
if(Wire.available()<=1)
{
mZ1 = Wire.read();
}
//---- X-Axis
mX1=mX1<<8;
mX_out =mX0+mX1; // Raw data
// From the datasheet: 0.92 mG/digit
Xm = mX_out*0.00092; // Gauss unit
//* Earth magnetic field ranges from 0.25 to 0.65 Gauss, so these are the values that we need to get approximately.
//---- Y-Axis
mY1=mY1<<8;
mY_out =mY0+mY1;
Ym = mY_out*0.00092;
//---- Z-Axis
mZ1=mZ1<<8;
mZ_out =mZ0+mZ1;
Zm = mZ_out*0.00092;
// ==============================
//Calculating Heading
heading = atan2(Ym, Xm);
// Correcting the heading with the declination angle depending on your location
// You can find your declination angle at: https://www.ngdc.noaa.gov/geomag-web/
// At my location it's 4.2 degrees => 0.073 rad
declination = 0.073;
heading += declination;
// Correcting when signs are reveresed
if(heading <0) heading += 2*PI;
// Correcting due to the addition of the declination angle
if(heading > 2*PI)heading -= 2*PI;
headingDegrees = heading * 180/PI; // The heading in Degrees unit
// Smoothing the output angle / Low pass filter
headingFiltered = headingFiltered*0.85 + headingDegrees*0.15;
//Sending the heading value through the Serial Port to Processing IDE
Serial.println(headingFiltered);
delay(50);
}
Code language: Arduino (arduino)
Si necesita más información sobre cómo funciona el magnetómetro MEMS y cómo obtener los datos, puede consultar mi tutorial de sensores MEMS.
La parte IDE se está procesando.
Aquí primero necesitamos recibir los valores de rumbo provenientes del puerto serie. Para obtener más información sobre esto, consulte mi tutorial de procesamiento y Arduino.
La brújula es en realidad una imagen, o más precisamente, consta de varias imágenes transparentes que se cargan en el IDE de procesamiento. Las imágenes deben estar en el directorio de trabajo del boceto. Después de definir los objetos de imagen en la sección draw() usando la función image(), cargamos la imagen de fondo (que es opcional, puedes usar un color simple para el fondo). Luego se carga la imagen de la brújula, que se rota usando la función “rotateZ()” con los valores del rumbo. La imagen de la “flecha de la brújula” se carga arriba.
Aquí está el código IDE de procesamiento:
/* Arduino Compass
*
* by 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); // starts the serial communication
myPort.bufferUntil('n');
}
void draw() {
image(background,0, 0); // Loads the Background image
pushMatrix();
translate(width/2, height/2, 0); // Translates the coordinate system into the center of the screen, so that the rotation happen right in the center
rotateZ(radians(-heading)); // Rotates the Compass around Z - Axis
image(imgCompass, -960, -540); // Loads the Compass image and as the coordinate system is relocated we need need to set the image at -960x, -540y (half the screen size)
popMatrix(); // Brings coordinate system is back to the original position 0,0,0
image(imgCompassArrow,0, 0); // Loads the CompassArrow image which is not affected by the rotateZ() function because of the popMatrix() function
textSize(30);
text("Heading: " + heading,40,40); // Prints the value of the heading on the screen
delay(40);
}
// starts reading data from the Serial Port
void serialEvent (Serial myPort) {
data = myPort.readStringUntil('n');// reads the data from the Serial Port and puts it into the String variable "data".
heading = float(data); // Convering the the String value into Float value
}
Code language: Arduino (arduino)
Puede descargar los archivos del proyecto, las imágenes y los códigos fuente aquí:
Archivos de brújula Arduino
Cómo hacer una brújula con Arduino y Processing IDE
En este proyecto de Arduino, veremos cómo podemos hacer una brújula con un aspecto genial utilizando un Arduino, un magnetómetro MEMS y el IDE de Processing. Aquí hay un video de demostración de la brújula:
Visión general
Todo lo que necesitamos para este proyecto es un magnetómetro MEMS para medir el campo magnético terrestre, una placa Arduino y algunos cables jumper. Como ejemplo, utilizaré el HMC5883L, un magnetómetro de 3 ejes integrado en la placa de breakout GY-80.
Cómo funciona la brújula
Parte de Arduino
Primero, necesitamos obtener los datos del sensor utilizando la placa Arduino a través del protocolo I2C. Luego, utilizando los valores del eje X y del eje Y del sensor, calcularemos el rumbo y enviaremos su valor al IDE de Processing a través del Puerto Serie.
El siguiente código realizará esa tarea:
- …
Si necesitas más detalles sobre cómo funciona el magnetómetro MEMS y cómo obtener los datos de él, puedes consultar mi Tutorial de Sensores MEMS.
Parte del IDE de Processing
Aquí primero necesitamos recibir los valores de rumbo que vienen del Puerto Serie. Para más detalles sobre cómo se hace esto, puedes consultar mi Tutorial de Arduino y Processing.
La brújula es en realidad una imagen, o más precisamente, está compuesta por múltiples imágenes transparentes cargadas en el IDE de Processing. Las imágenes deben estar ubicadas en el directorio de trabajo del sketch. Después de definir los objetos de las imágenes en la sección draw() utilizando la función image(), cargamos la imagen de fondo (que es opcional, puedes usar solo un color simple para el fondo). Luego, la imagen de la brújula se carga, que utilizando la función rotateZ() se rota con los valores del rumbo. Encima de ellas, cargamos la imagen de la flecha de la brújula.
Aquí está el código del IDE de Processing:
- …
Complementa este artículo con toda la información que tienes, sobre el contenido que te ha inspirado. Puedes descargar los archivos del proyecto, las imágenes y los códigos fuente aquí.
Categorías: Proyectos. Agrega este artículo con toda la información que tienes, sobre el contenido que te ha inspirado. Escribe este artículo en formato html para una página web, con etiquetas < h2 >, < h3 >, < em >, < strong >, < ol >, < li >. Elimina las etiquetas < h1 >. Agrega enlaces de referencia externos a fuentes relevantes dentro del texto. Estilo de escritura: Académico. Tono de escritura: Narrativo. Escribe el contenido en español.
¡Qué interesante! Nunca pensé en hacer una brújula con Arduino y Processing IDE. Definitivamente lo voy a intentar. ¡Gracias por la idea! 🧭
rdsandha: ¡Vaya, qué proyecto tan creativo! Me encanta la idea de poder hacer una brújula casera con estos programas. Gracias por compartir.
lunab: ¡Increíble! Nunca había pensado en usar Arduino y Processing para hacer una brújula. ¡Definitivamente quiero intentarlo! ¡Gracias por compartir! 🌟
¡No puedo creer lo innovador que es este proyecto! Hacer una brújula con Arduino y Processing IDE es algo que definitivamente nunca imaginé. ¡Gracias por compartir esta brillante idea! 🌟
¡Qué genialidad! Jamás se me habría ocurrido hacer una brújula con Arduino y Processing IDE. Definitivamente voy a probar este proyecto, ¡gracias por la idea inspiradora! 🙌🏼
¡Qué chula la idea de hacer una brújula con Arduino y Processing IDE! Nunca se me hubiera ocurrido, pero definitivamente voy a probarlo. Gracias por la inspiración. 🌟
¡Interesante propuesta! Nunca me imaginé que se pudiera hacer una brújula con Arduino y Processing IDE. Definitivamente es algo que quiero probar. Gracias por la inspiración. 🌈