Encoder Magnético

Definición, ¿Qué es?

El sensor cuentavueltas o encoder rotativo magnético es un dispositivo que nos proporciona la posición y la velocidad angular de una acción, es decir, cuántos grados hemos girado y a qué velocidad lo hemos hecho a través del envió de pulsos a un Arduino, a partir de la detección de campos magnéticos.

Funcionamiento

El funcionamiento del encoder está basado en el efecto Hall, descubierto por Edwin Hall en 1849, este efecto consiste en que, al circular una corriente eléctrica a través de un semiconductor, en presencia de un campo magnético, los electrones se desvían por la acción de este campo magnético dando lugar una tensión perpendicular a la corriente y al campo magnético. Este campo es el que detecta nuestro sensor, como el campo magnético se produce una vez por cada vuelta, podemos contar el número de veces que el sensor detecta el campo magnético, que será igual al número de vueltas.

Además podemos saber si el giro es horario o antihorario si nuestro encoder es de cuadratura, esto significa que mide el campo magnético por dos sensores, a partir del desfase que tienen entre sí podemos averiguar la dirección de giro.

Uno de los giros (horario o antihorario, para averiguar cuál de ellos es cuestión de probarlo) producirá un flanco igual siempre, es decir, ambos sensores detectarán lo mismo, o los dos detectan campo magnético o los dos no lo detectan.

El otro giro producirá un flanco distinto, es decir, cuando un sensor detecta el campo el otro no y viceversa.

Analógico y digital

Existen sensores magnéticos analógicos y digitales.

Analógico:
Como en otros dispositivos, el encoder analógico envía pulsos proporcionales a la intensidad del campo que detecta, es decir, da valores continuos.

Digital:
El encoder digital puede enviar o no un pulso dependiendo de si detecta o no el campo magnético, en nuestro caso (contar vueltas), lo ideal es un encoder digital.

Esquema eléctrico y Conexión con Arduino

Ejemplo de Código

XXXXXXXX No se insertar el texto con formato de código.

Precio y Adquisición

El sensor Hall por sí solo se puede encontrar fácilmente por 0,5 – 0,7 €.
El motor con el sensor Hall integrado lo podemos encontrar por 8,30 €.

Motor con encoder magnético integrado: https://banggood.app.link/4dUu6QxST4

Enlaces interesantes

Blog Luisllamas encoder rotativo: https://www.luisllamas.es/arduino-encoder-rotativo/
Blog Luisllamas encoder magnético: https://www.luisllamas.es/detectar-campos-magneticos-con-arduino-y-sensor-hall-a3144/

Adquisición de motor con encoder magnético: https://banggood.app.link/4dUu6QxST4

Magnetómetro

¿QUÉ ES UN MAGNETÓMETRO?

Un magnetómetro sirve para cuantificar en fuerza o dirección de la fuerza electromagnética de la Tierra.

Hay distintos tipos de magnetómetro que son:

  1. Los magnetómetros escalares que miden la fuerza magnética de en las que están sometidos.
  2. Los magnetómetros vectoriales que tienen la capacidad de medir  el componente del campo magnético en una dirección particular, en este caso el norte magnético de la Tierra.

CÓMO MONTARLO. 

El montaje de esta brújula magnética  es muy sencillo solo tienes que alimentarlo con su propia toma de tierra y la conexión 5V, también hay conexiones de programación que son la SDA que va al  pin A4 y la conexión SCL que va al pin A5.arduino-brujula-hmc5883-gy273-esquema

arduino-brujula-hmc5883-gy273-conexion

PROGRAMACIÓN.

//GND – GND

//VCC – VCC

//SDA – Pin A4

//SCL – Pin A5

#include «Wire.h»

#include «I2Cdev.h»

#include «HMC5883L.h»

HMC5883L compass;

int16_t mx, my, mz;

void setup()

{

    Serial.begin(9600);

    Wire.begin();

    compass.initialize();

}

void loop()

{

    //Obtener componentes del campo magnético

    compass.getHeading(&mx, &my, &mz);

    Serial.print(«mx:»);

    Serial.print(mx);

    Serial.print(«tmy:»);

    Serial.print(my);

    Serial.print(«tmz:»);

    Serial.println(mz);

    delay(100);

}

//GND – GND

//VCC – VCC

//SDA – Pin A4

//SCL – Pin A5

#include «Wire.h»

#include «I2Cdev.h»

#include «HMC5883L.h»

HMC5883L compass;

int16_t mx, my, mz;

//declinacion en grados en tu posición

const float declinacion = 0.12;

void setup()

{

    Serial.begin(9600);

    Wire.begin();

    compass .initialize();

}

void loop() {

    //Obtener componentes del campo magnético

    compass .getHeading(&mx, &my, &mz);

    //Calcular ángulo el ángulo del eje X respecto al norte

    float angulo = atan2(my, mx);

    angulo = angulo * RAD_TO_DEG;

    angulo = angulo – declinacion;

    if(angulo < 0) angulo = angulo + 360;

    Serial.print(«N:»);

    Serial.println(angulo,0);  

}

Sigue-línea

Definición:

Este conjunto de pares de LED IR / fototransistor es ideal para identificar con precisión los cambios en la reflectancia (como la detección de línea). Funciona de 2.9 V a 5.5 V y ofrece un control de brillo regulable independiente de la tensión de alimentación. En general, cuanto más cerca está el objeto, mayor es el contraste entre las lecturas claras y oscuras, pero los objetos de alta reflectancia son generalmente detectables a alrededor de 40 mm . Esta versión presenta los sensores QTR de estilo tradicional sin lentes.

Especificaciones:

Dimensiones: 45.0 × 20.0 × 2.5 mm (vea el diagrama de dimensiones (1MB pdf) para más detalles)
Voltaje de funcionamiento: 2.9 V a 5.5 V
Tipo de sensor: QTR
Recuento de sensores: 6
Paso del sensor: 8 mm
Corriente LED de brillo completo: 30 mA (independiente de la tensión de alimentación)
Corriente máxima de la placa: 93 mA
Formato de salida: voltajes analógicos (0 V a VCC)
Distancia de detección óptima: 5 mm
Distancia de detección máxima recomendada: 40 mm.
Peso: 2,3 g

#include <OpenLamborghino.h>

#define BOTON  12
#define BUZZER  10

OpenLamborghino OpenLamborghino(BOTON, BUZZER);


void setup() {
  Serial.begin(9600);
  OpenLamborghino.WaitBoton();
  OpenLamborghino.calibracion();
  OpenLamborghino.WaitBoton();
  delay(1000);
}

void loop() {

  int pos =  OpenLamborghino.LineaBlanca();
  Serial.println(pos);

}

SENSOR DE ULTRASONIDOS

DEFINICIÓN:
Un sensor de ultrasonidos es un detector de proximidad que trabaja libre de roces mecánicos y que detectan objetos a distancias desde centímetros hasta algunos metros, este funciona enviando una onda de sonido y mide el tiempo que tarda en llegarle esa misma onda de sonido, y que haciendo algunas cuentas lo transforma a centímetros.metros, este funciona enviando una onda de sonido y mide el tiempo que tarda en llegarle esa misma onda de sonido, y que haciendo algunas cuentas lo transforma a centímetros.

 – ESTUDIO COMERCIAL:

Actualmente este sensor ronda con un precio en el mercado de 1€. El más barato que he visto ha sido en Aliexpress, donde su precio es de 0,58€.El más barato que he visto ha sido en Aliexpress, donde su precio es de 0,58€. https://es.aliexpress.com/item/690139020.html

FUNCIONAMIENTO:

El sensor se basa simplemente en medir el tiempo entre el envío y la recepción de un pulso sonoro. Sabemos que la velocidad del sonido es 343 m/s en condiciones de temperatura 20 ºC, 50% de humedad, presión atmosférica a nivel del mar. Transformando unidades resulta

343 \frac{m}{s} \cdot{} 100 \frac{cm}{m} \cdot{} \frac{1}{1000000} \frac{s}{\mu s} = \frac{1}{29.2} \frac{cm}{\mu s}

343m/s·100cm/m

Es decir, el sonido tarda 29,2 microsegundos en recorrer un centímetro. Por tanto, podemos obtener la distancia a partir del tiempo entre la emisión y recepción del pulso mediante la siguiente ecuación.

Distancia(cm)= \frac {Tiempo(\mu s)}{29.2 \cdot 2}

El motivo de dividir por dos el tiempo (además de la velocidad del sonido en las unidades apropiadas, que hemos calculado antes) es porque hemos medido el tiempo que tarda el pulso en ir y volver, por lo que la distancia recorrida por el pulso es el doble de la que queremos medir.

sensor-ultrasonico-explicacion
ESQUEMA SOBRE EL FUNCIONAMIENTO DEL SENSOR ULTRASONIDOS

SISTEMA ELÉCTRICO:

  • Directamente a los pines
  • EchoPin = 2;
  • TriggerPin = 4;

  • Montaje en protoboard

arduino-ultrasonidos-montaje

NUESTRO CÓDIGO:

//___________________   AQUI EMPIEZA EL PROGRAMA DEL ROBOT   ______________________
{
  //  avanza(100);                //avanza 100cm
  //  para(3);                    //para 3segundos
  //  retrocede(100);             //retrocede 100cm
  //  para(3);
  //  izquierda(90);              //Gira izda 90º
  //  para(3);
  //  derecha(90);
  para(3);
  siguelinea (600);            //sigue linea 500cm
  if (estado == 1) {
    estado = 0;
    obstaculo();             // hace esto si paró por obstáculo
  }
  if (estado == 2) {
    estado = 0;
    lineaNegra();             // hace esto si paró por linea negra
  }
  para(5);
}

//___________________   AQUI TERMINA EL PROGRAMA DEL ROBOT   ______________________

void avanza(int D)
{
  digitalWrite(pinIN1, HIGH);
  digitalWrite(pinIN2, LOW);
  analogWrite(pinENA, speedAI);
  digitalWrite(pinIN3, HIGH);
  digitalWrite(pinIN4, LOW);
  analogWrite(pinENB, speedAD);
  veMidiendo(millis() + (D * mscmA));    // mide hasta T

}
void veMidiendo (int T) {
  while (T > millis()) {
    pong = ping();
    if (pong < distSeg) {
      estado = 1;
      break;             // si distancia menor a la de seguridad termina
    }
  }
  //   Serial.println(pong);

int ping()
{
  long duration, distanceCm;
  digitalWrite(TriggerPin, LOW);  //para generar un pulso limpio ponemos a LOW 4us
  delayMicroseconds(4);
  digitalWrite(TriggerPin, HIGH);  //generamos Trigger (disparo) de 10us
  delayMicroseconds(10);
  digitalWrite(TriggerPin, LOW);
  duration = pulseIn(EchoPin, HIGH);  //medimos el tiempo entre pulsos, en microsegundos
  //  distanceCm = duration * 10 / 292 / 2;  //convertimos a distancia, en cm
  return duration;
}

      estado = 1;
      break;             // si distancia menor a la de seguridad termina
    }
    //    Serial.println(pong); // Serial.print('\t'); // para depuración

    uint16_t position = qtr.readLineBlack(sensorValues);     // 0=Izda a 5000=Dcha
   void obstaculo() {
  mueveServo();
}