¿Qué es MEMS? Acelerómetro, giroscopio y magnetómetro con Arduino

En este tutorial, aprenderemos cómo funcionan el acelerómetro, giroscopio y magnetómetro MEMS y cómo usarlos con la placa Arduino. También haremos algunas aplicaciones prácticas con los sensores usando el IDE de Processing. Puede ver el vídeo a continuación o leer el tutorial escrito a continuación.

¿Qué es MEMS?

Los MEMS son sistemas o dispositivos muy pequeños que constan de microcomponentes con un tamaño de 0,001 mm a 0,1 mm. Estos componentes están hechos de silicio, polímeros, metales y/o cerámica y suelen combinarse con una CPU (microcontrolador) para completar el sistema.

Ahora explicaremos brevemente cómo funciona cada uno de estos sensores MEMS (Sistemas Micro-Electro-Mecánicos).

Acelerómetro MEMS

Mide la aceleración midiendo el cambio en la capacidad. Su microestructura se parece a esto. Cuenta con una masa unida a un resorte que solo puede moverse en una dirección y placas exteriores sólidas. Entonces, cuando se aplica una aceleración en una dirección particular, la masa se mueve y la capacitancia entre las placas y la masa cambia. Este cambio de capacidad se mide, procesa y corresponde a un valor de aceleración específico.

giroscopio MEMS

El giroscopio mide la velocidad angular mediante el efecto Coriolis. Cuando una masa se mueve en una determinada dirección a una determinada velocidad y se aplica una velocidad angular externa, como se muestra con la flecha verde, se crea una fuerza, como se muestra con la flecha roja azul, que hace que la masa se desplace verticalmente. Al igual que en el acelerómetro, este desplazamiento produce un cambio en la capacitancia, que se mide y procesa y corresponde a una determinada velocidad angular.

La>

magnetómetro MEMS

Mide el campo magnético de la Tierra mediante el efecto Hall o efecto magnetorresistivo. De hecho, casi el 90% de los sensores del mercado utilizan el efecto Hall y así es como funciona.

Si>

El>

Sensores Arduino y MEM

Bien, ahora conectemos estos sensores a la placa Arduino y usémoslos. Como ejemplo, usaré la placa de ruptura GY-80, que tiene los siguientes sensores: acelerómetro de 3 ejes ADXL345, giroscopio de 3 ejes L3G4200D, magnetómetro de 3 ejes MC5883L, así como un barómetro y un termómetro que tenemos. En este no usaremos el tutorial.

Puede obtener estos componentes en uno de los siguientes sitios web:

• Acelerador de 3 ejes ADXL345………………………………………………………………………… Amazon / Banggood / AliExpress
• 2 en 1: Giroscopio y acelerómetro de 6 ejes MPU6050…………………… Amazon / Banggood / AliExpress
• 3 en 1: Giroscopio de aceleración de campo magnético de 9 ejes GY-80……… Amazonas
• 3 en 1: Módulo GY-86 10DOF MS5611 HMC5883L MPU6050……… Banggood / AliExpress

Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.

Esta>

• Acelerómetro ADXL345 ficha de datos
• Giroscopio L3G4200D ficha de datos
• Magnetómetro MC5883L ficha de datos

Para obtener más información sobre cómo funciona la comunicación I2C, consulte mi otro tutorial sobre el protocolo de comunicación I2C.

Ver también
Tutorial de acelerómetro y giroscopio Arduino y MPU6050

Código fuente

Ahora veamos los códigos para recuperar los datos de los sensores. Comenzaremos con el acelerómetro y habrá una explicación antes de cada código así como una descripción adicional en los comentarios del código.

Código del acelerómetro Arduino

Primero necesitamos integrar la biblioteca Arduino Wire y definir las direcciones de registro del sensor. En la sección de configuración, debemos iniciar la biblioteca de cables e iniciar la comunicación en serie, ya que usaremos el monitor en serie para mostrar los resultados. Aquí también necesitamos activar el sensor o habilitar la medición enviando el byte correspondiente al registro Power_CTL y así lo hacemos. Usando la función Wire.beginTransmission() seleccionamos con qué sensor queremos comunicarnos, en este caso. El acelerómetro de 3 ejes. Luego usamos la función Wire.write() para indicar con qué registro interno vamos a hablar. Luego enviamos el byte correspondiente para liberar la medida. Usando la función Wire.endTransmission() finalizamos la transmisión y transferimos los datos a los registros.

En la sección de bucle necesitamos leer los datos de cada eje. Empezamos con el eje X. Entonces, primero seleccionamos con qué registros queremos hablar, en este caso los dos registros internos del eje X. Luego usamos la función Wire.requestFrom() para solicitar los datos transferidos o los dos bytes de los dos registros. El Cable.disponible() La función devuelve el número de bytes disponibles para recuperación y si este número coincide con nuestros bytes solicitados, en nuestro caso 2 bytes, use el Cable.read() Con esta función leemos los bytes de los dos registros del eje X.

Los datos de salida de los registros son complemento a dos, donde X0 es el byte menos significativo y es la aceleración de la gravedad o la gravedad. Repetiremos este proceso para los otros dos ejes y terminaremos imprimiendo estos valores en el monitor serie.

#include <Wire.h>

//--- Accelerometer Register Addresses
#define Power_Register 0x2D
#define X_Axis_Register_DATAX0 0x32 // Hexadecima address for the DATAX0 internal register.
#define X_Axis_Register_DATAX1 0x33 // Hexadecima address for the DATAX1 internal register.
#define Y_Axis_Register_DATAY0 0x34 
#define Y_Axis_Register_DATAY1 0x35
#define Z_Axis_Register_DATAZ0 0x36
#define Z_Axis_Register_DATAZ1 0x37

int ADXAddress = 0x53;  //Device address in which is also included the 8th bit for selecting the mode, read in this case.

int X0,X1,X_out;
int Y0,Y1,Y_out;
int Z1,Z0,Z_out;
float Xa,Ya,Za;

void setup() {
  Wire.begin(); // Initiate the Wire library    
  Serial.begin(9600);    
  delay(100);
  
  Wire.beginTransmission(ADXAddress);
  Wire.write(Power_Register); // Power_CTL Register
  // Enable measurement
  Wire.write(8); // Bit D3 High for measuring enable (0000 1000)
  Wire.endTransmission();
}

void loop() {
  // X-axis
  Wire.beginTransmission(ADXAddress); // Begin transmission to the Sensor 
  //Ask the particular registers for data
  Wire.write(X_Axis_Register_DATAX0);
  Wire.write(X_Axis_Register_DATAX1);  
  Wire.endTransmission(); // Ends the transmission and transmits the data from the two registers
  Wire.requestFrom(ADXAddress,2); // Request the transmitted two bytes from the two registers
  if(Wire.available()<=2) {  // 
    X0 = Wire.read(); // Reads the data from the register
    X1 = Wire.read();
    /* Converting the raw data of the X-Axis into X-Axis Acceleration
     - The output data is Two's complement 
     - X0 as the least significant byte
     - X1 as the most significant byte */ 
    X1=X1<<8;
    X_out =X0+X1;
    Xa=X_out/256.0; // Xa = output value from -1 to +1, Gravity acceleration acting on the X-Axis
  }
  // Y-Axis
  Wire.beginTransmission(ADXAddress); 
  Wire.write(Y_Axis_Register_DATAY0);
  Wire.write(Y_Axis_Register_DATAY1);  
  Wire.endTransmission(); 
  Wire.requestFrom(ADXAddress,2);
  if(Wire.available()<=2) { 
    Y0 = Wire.read();
    Y1 = Wire.read();
    Y1=Y1<<8;
    Y_out =Y0+Y1;
    Ya=Y_out/256.0;
  }
  // Z-Axis
  Wire.beginTransmission(ADXAddress); 
  Wire.write(Z_Axis_Register_DATAZ0);
  Wire.write(Z_Axis_Register_DATAZ1);  
  Wire.endTransmission(); 
  Wire.requestFrom(ADXAddress,2);
  if(Wire.available()<=2) { 
    Z0 = Wire.read();
    Z1 = Wire.read();
    Z1=Z1<<8;
    Z_out =Z0+Z1;
    Za=Z_out/256.0;
  }
  // Prints the data on the Serial Monitor
  Serial.print("Xa= ");
  Serial.print(Xa);
  Serial.print("   Ya= ");
  Serial.print(Ya);
  Serial.print("   Za= ");
  Serial.println(Za);
}
Code language: Arduino (arduino)

Código de giroscopio Arduino

Para obtener los datos del giroscopio utilizamos un código similar al anterior. Primero necesitamos definir las direcciones de registro y algunas variables para los datos. En la sección de configuración, debemos activar el sensor usando CTRL_REG1 y configurarlo en modo normal y también seleccionar la sensibilidad del sensor. Para este ejemplo elijo el modo de sensibilidad 2000 dps.

En la sección de bucle similar al acelerómetro, leemos los datos de los ejes X, Y y Z. Luego, los datos sin procesar deben convertirse en valores de ángulos. En la hoja de datos del sensor podemos ver que para el modo de sensibilidad de 2000 dps, una unidad de 70 mdps/dígito es equivalente. Esto significa que necesitamos multiplicar los datos de salida sin procesar por 0,07 para obtener la velocidad angular en grados por segundo. Si luego multiplicamos la velocidad angular por el tiempo, obtenemos el valor angular. Entonces necesitamos calcular el intervalo de tiempo de cada sección del bucle y podemos hacerlo usando la función millis() en la parte superior e inferior de la sección del bucle y almacenando su valor en esta variable «dt». Entonces, para cada bucle ejecutado calculamos el ángulo y lo sumamos al valor del ángulo final. Hacemos lo mismo para los otros dos ejes y al final imprimimos los resultados en el monitor serie.

#include <Wire.h>

//--- Gyro Register Addresses
#define Gyro_gX0 0x28  
#define Gyro_gX1 0x29
#define Gyro_gY0 0x2A
#define Gyro_gY1 0x2B
#define Gyro_gZ0 0x2C  
#define Gyro_gZ1 0x2D

int Gyro = 0x69; //Device address in which is also included the 8th bit for selecting the mode, read in this case.

int gX0, gX1, gX_out;
int gY0, gY1, gY_out;
int gZ0, gZ1, gZ_out;
float Xg,Yg,Zg;
float angleX,angleY,angleZ,angleXc,angleYc,angleZc;


unsigned long start, finished, elapsed;
float dt=0.015;

void setup()
{
  Wire.begin();                
  Serial.begin(9600);    
  delay(100);
  
  Wire.beginTransmission(Gyro);
  Wire.write(0x20); // CTRL_REG1 - Power Mode
  Wire.write(15);   // Normal mode: 15d - 00001111b   
  Wire.endTransmission();
  
  Wire.beginTransmission(Gyro);
  Wire.write(0x23); // CTRL_REG4 - Sensitivity, Scale Selection
  Wire.write(48);   // 2000dps: 48d - 00110000b
  Wire.endTransmission();
}

void loop()
{
  start=millis();
  //---- X-Axis
  Wire.beginTransmission(Gyro); // transmit to device
  Wire.write(Gyro_gX0);
  Wire.endTransmission();
  Wire.requestFrom(Gyro,1); 
  if(Wire.available()<=1)   
  {
    gX0 = Wire.read();
  }
  Wire.beginTransmission(Gyro); // transmit to device
  Wire.write(Gyro_gX1);
  Wire.endTransmission();
  Wire.requestFrom(Gyro,1); 
  if(Wire.available()<=1)   
  {
    gX1 = Wire.read();
  }

  //---- Y-Axis
  Wire.beginTransmission(Gyro); // transmit to device
  Wire.write(Gyro_gY0);
  Wire.endTransmission();
  Wire.requestFrom(Gyro,1); 
  if(Wire.available()<=1)   
  {
    gY0 = Wire.read();
  }
  Wire.beginTransmission(Gyro); // transmit to device
  Wire.write(Gyro_gY1);
  Wire.endTransmission();
  Wire.requestFrom(Gyro,1); 
  if(Wire.available()<=1)   
  {
    gY1 = Wire.read();
  }
  
  //---- Z-Axis
  Wire.beginTransmission(Gyro); // transmit to device
  Wire.write(Gyro_gZ0);
  Wire.endTransmission();
  Wire.requestFrom(Gyro,1); 
  if(Wire.available()<=1)   
  {
    gZ0 = Wire.read();
  }
  Wire.beginTransmission(Gyro); // transmit to device
  Wire.write(Gyro_gZ1);
  Wire.endTransmission();
  Wire.requestFrom(Gyro,1); 
  if(Wire.available()<=1)   
  {
    gZ1 = Wire.read();
  }
  
  //---------- X - Axis
  
  // Raw Data
  gX1=gX1<<8;
  gX_out =gX0+gX1;
  
  // From the datasheet: 70 mdps/digit
  Xg=gX_out*0.07; // Angular rate
  // Angular_rate * dt = angle
  angleXc = Xg*dt;
  angleX = angleX + angleXc;

  //---------- Y - Axis
  gY1=gY1<<8;
  gY_out =gY0+gY1;
  Yg=gY_out*0.07;
  angleYc = Yg*dt;
  angleY = angleY + angleYc;
  
  //---------- Z - Axis
  gZ1=gZ1<<8;
  gZ_out =gZ0+gZ1;
  Zg=gZ_out*0.07;
  angleZc = Zg*dt;
  angleZ = angleZ + angleZc;

  
  // Prints the data on the Serial Monitor
  Serial.print("angleX= ");
  Serial.print(angleX);
  Serial.print("   angleY= ");
  Serial.print(angleY);
  Serial.print("   angleZ= ");
  Serial.println(angleZ);
  
  delay(10);
  // Calculating dt
  finished=millis();
  elapsed=finished-start;
  dt=elapsed/1000.0;
  start = elapsed = 0;
  
}Code language: Arduino (arduino)

Código del magnetómetro Arduino

Aquí también usaremos una técnica similar a la anterior. Primero necesitamos definir las direcciones de registro y configurar el sensor en modo de medición continua en la sección de configuración. En la sección de bucle, obtenemos los datos sin procesar para cada eje utilizando el mismo método que los sensores anteriores.

Luego necesitamos convertir los datos sin procesar en valores de campo magnético o unidades gaussianas. En la hoja de datos del sensor podemos ver que el modo de sensibilidad predeterminado es 0,92 mg/dígito. Esto significa que necesitamos multiplicar los datos sin procesar por 0,00092 para obtener el campo magnético de la Tierra en unidades gaussianas. Al final imprimimos los valores en el monitor serie.

#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 Xm,Ym,Zm;


#define Magnetometer 0x1E //I2C 7bit address of HMC5883

void setup(){
  //Initialize Serial and I2C communications
  Serial.begin(9600);
  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;
 
  //Print out values of each axis
  Serial.print("x: ");
  Serial.print(Xm);
  Serial.print("  y: ");
  Serial.print(Ym);
  Serial.print("  z: ");
  Serial.println(Zm);
  
  delay(50);
}Code language: Arduino (arduino)

Aquí hay una aplicación atractiva del sensor, una brújula digital MEMS construida con Processing IDE. Se pueden encontrar más detalles y el código fuente de este ejemplo en el siguiente enlace: