Bloque 4.1: Uso de Sensores y Actuadores

1. Sensores: Captando Información del Entorno

Un sensor es un dispositivo que detecta y responde a algún tipo de entrada del entorno físico, como luz, temperatura, movimiento, presión, humedad, etc. Convierte esta información física en una señal eléctrica que puede ser interpretada por un microcontrolador.

1.1. Tipos Comunes de Sensores

Sensor de Temperatura

Mide la temperatura ambiente. Ejemplos comunes incluyen el DHT11, DHT22 y el LM35.

Sensor de Luz (LDR)

Varía su resistencia según la cantidad de luz que recibe. Útil para detectar condiciones de iluminación.

Sensor Ultrasónico (HC-SR04)

Mide distancias utilizando ondas sonoras ultrasónicas. Muy usado en robots para evitar obstáculos.

Acelerómetro/Giroscopio (MPU6050)

Mide la aceleración, orientación y movimiento rotacional. Fundamental en drones y dispositivos de realidad aumentada.

1.2. Características Importantes de un Sensor

• Rango: El intervalo de valores que puede medir (por ejemplo, -40°C a 80°C para temperatura).
• Precisión: Qué tan cerca está la lectura del sensor del valor real.
• Sensibilidad: Cuánto cambia la salida del sensor por unidad de cambio en la entrada.
• Tiempo de respuesta: Qué tan rápido el sensor puede detectar un cambio en la magnitud medida.

1.3. Ejemplo Práctico: Leyendo un Sensor DHT22

El DHT22 es un sensor digital que mide temperatura y humedad. A continuación se muestra cómo conectarlo y leer sus valores usando una librería específica.

Materiales Necesarios

• 1 Arduino UNO (o compatible)
• 1 Sensor DHT22
• 1 Resistencia de 10kΩ
• Protoboard y cables de conexión

Esquema de Conexión

Conexiones:

• VCC del DHT22 al pin 5V del Arduino.
• GND del DHT22 al pin GND del Arduino.
• DATA del DHT22 al pin digital 2 del Arduino. Colocar la resistencia de 10kΩ entre VCC y DATA.

Código del Sketch

Para usar el DHT22, necesitamos la librería DHT.h de Adafruit. Esta librería se puede instalar desde el Gestor de Librerías del Arduino IDE (Herramientas > Administrar Bibliotecas... > Buscar "DHT sensor library").

 Copiar#include <DHT.h>
#include <DHT_U.h>

// Definimos el pin de datos del sensor y su tipo
#define DHTPIN 2     // Pin digital conectado al sensor
#define DHTTYPE DHT22   // Tipo de sensor DHT22

// Creamos una instancia del sensor
DHT_Unified dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  Serial.println(F("DHT22 test!"));

  // Inicializamos el sensor
  dht.begin();
  
  // Imprimimos detalles del sensor (opcional)
  sensor_t sensor;
  dht.getSensor(&sensor);
  Serial.println(F("------------------------------------"));
  Serial.print  (F("Sensor:       ")); Serial.println(sensor.name);
  Serial.print  (F("Driver Ver:   ")); Serial.println(sensor.version);
  Serial.print  (F("Unique ID:    ")); Serial.println(sensor.sensor_id);
  Serial.print  (F("Max Value:    ")); Serial.print(sensor.max_value); Serial.println(F("°C"));
  Serial.print  (F("Min Value:    ")); Serial.print(sensor.min_value); Serial.println(F("°C"));
  Serial.print  (F("Resolution:   ")); Serial.print(sensor.resolution); Serial.println(F("°C"));
  Serial.println(F("------------------------------------"));
}

void loop() {
  // Retardo entre lecturas
  delay(2000);

  // Lectura de temperatura y humedad
  sensors_event_t event;
  
  // Lectura de humedad
  dht.getEvent(&event);
  if (isnan(event.relative_humidity)) {
    Serial.println(F("Error leyendo humedad!"));
  }
  else {
    Serial.print(F("Humedad: "));
    Serial.print(event.relative_humidity);
    Serial.println(F("%"));
  }
  
  // Lectura de temperatura
  dht.getEvent(&event);
  if (isnan(event.temperature)) {
    Serial.println(F("Error leyendo temperatura!"));
  }
  else {
    Serial.print(F("Temperatura: "));
    Serial.print(event.temperature);
    Serial.println(F("°C"));
  }
  
  Serial.println(F("------------------------------------"));
}

Explicación del Código

• #include <DHT.h> y #include <DHT_U.h>: Incluimos las librerías necesarias para trabajar con el sensor DHT22.
• #define DHTPIN 2 y #define DHTTYPE DHT22: Definimos constantes para el pin de datos y el tipo de sensor.
• DHT_Unified dht(DHTPIN, DHTTYPE);: Creamos un objeto dht de la clase DHT_Unified, que representa nuestro sensor.
• dht.begin();: Inicializamos el sensor en la función setup().
• dht.getEvent(&event);: Esta función lee los datos del sensor. El resultado se almacena en una estructura sensors_event_t llamada event.
• event.relative_humidity y event.temperature: Accedemos a los valores específicos de humedad y temperatura dentro de la estructura event.
• isnan(): Esta función verifica si el valor leído es "Not a Number" (NaN), lo que indica un error en la lectura.

Este ejemplo muestra cómo una librería puede simplificar significativamente el trabajo con sensores complejos, manejando los detalles de comunicación digital del sensor.

2. Actuadores: Haciendo que las Cosas Sucedan

Un actuador es un componente que convierte una señal de control (generalmente eléctrica) en una acción física, como movimiento, calor, sonido o luz. Son los "músculos" del sistema mecatrónico.

2.1. Tipos Comunes de Actuadores

LEDs

Emisores de luz que indican estados o proporcionan iluminación. Son los actuadores más simples y comunes en proyectos de aprendizaje.

Motores

Convertidores de energía eléctrica en movimiento mecánico. Existen varios tipos como motores DC, servomotores y motores paso a paso.

Relés

Interruptores electromecánicos que permiten controlar circuitos de alta potencia con señales de baja potencia de un microcontrolador.

Zumbadores (Buzzer)

Dispositivos que emiten sonidos. Pueden ser activos (emiten un tono fijo) o pasivos (requieren una señal para generar tonos).

2.2. Controlando un Servomotor

Un servomotor es un actuador que puede posicionarse en un ángulo específico (generalmente entre 0° y 180°). Son ideales para controlar brazos robóticos, timones de barcos o cualquier aplicación que requiera movimiento controlado.

Materiales Necesarios

• 1 Arduino UNO (o compatible)
• 1 Servomotor (SG90 es muy común)
• Protoboard y cables de conexión

Esquema de Conexión

Conexiones:

• Cable Rojo del servomotor al pin 5V del Arduino.
• Cable Marrón/Negro del servomotor al pin GND del Arduino.
• Cable Naranja/Amarillo del servomotor al pin digital 9 del Arduino.

Código del Sketch

Arduino IDE incluye una librería estándar para controlar servomotores llamada Servo.h. No es necesario instalarla, ya viene incluida.

 Copiar/*
  Control de Servomotor
  
  Mueve un servomotor de 0 a 180 grados y viceversa.
  
  Modificación del ejemplo original de la librería Servo.
 */

#include <Servo.h>

// Creamos un objeto servo para controlar nuestro servomotor
Servo miServo;

// Variable para almacenar la posición del servomotor
int pos = 0;

void setup() {
  // Adjunta el servomotor al pin 9
  miServo.attach(9);
}

void loop() {
  // Va desde 0 grados hasta 180 grados
  // en pasos de 1 grado
  for (pos = 0; pos <= 180; pos += 1) {
    // Le dice al servomotor que vaya a la posición en la variable 'pos'
    miServo.write(pos);
    // espera 15ms para que el servomotor llegue a la posición
    delay(15);
  }

  // Va desde 180 grados hasta 0 grados
  for (pos = 180; pos >= 0; pos -= 1) {
    miServo.write(pos);
    delay(15);
  }
}

Explicación del Código

• #include <Servo.h>: Incluimos la librería estándar de Arduino para controlar servomotores.
• Servo miServo;: Creamos un objeto de la clase Servo llamado miServo.
• miServo.attach(9);: En la función setup(), adjuntamos (conectamos) el objeto miServo al pin digital 9 del Arduino.
• miServo.write(pos);: Esta función envía una señal al servomotor para que se mueva a la posición especificada por la variable pos (en grados).
• for loops: Usamos dos bucles for para mover el servomotor desde 0° hasta 180° y luego de regreso a 0°, creando un movimiento de vaivén.
• delay(15);: Un pequeño retardo permite que el servomotor tenga tiempo para alcanzar cada posición antes de recibir el siguiente comando.

Este ejemplo demuestra cómo una librería puede abstraer la complejidad de generar señales PWM específicas requeridas por los servomotores, permitiéndonos controlarlos con comandos simples como miServo.write(grados).

3. Proyecto Integrador: Sistema de Alarma de Proximidad con Feedback Visual

Vamos a combinar lo aprendido sobre sensores y actuadores en un proyecto práctico. Este sistema usará un sensor ultrasónico para detectar objetos cercanos y proporcionará feedback mediante un LED (cambia de color/intensidad) y un zumbador (cambia de tono).

3.1. Materiales Necesarios

• 1 Arduino UNO (o compatible)
• 1 Sensor Ultrasónico HC-SR04
• 1 LED RGB (o 3 LEDs individuales: rojo, verde, azul)
• 1 Zumbador (preferiblemente pasivo)
• 3 Resistencias de 220Ω (una para cada color del LED)
• Protoboard y cables de conexión

3.2. Esquema de Conexión

Conexiones del Sensor Ultrasónido (HC-SR04):

• VCC al pin 5V del Arduino.
• GND al pin GND del Arduino.
• Trig al pin digital 7 del Arduino.
• Echo al pin digital 6 del Arduino.

Conexiones del LED RGB:

• Pata Roja (Ánodo) al pin digital ~9 (PWM) del Arduino a través de una resistencia de 220Ω.
• Pata Verde (Ánodo) al pin digital ~10 (PWM) del Arduino a través de una resistencia de 220Ω.
• Pata Azul (Ánodo) al pin digital ~11 (PWM) del Arduino a través de una resistencia de 220Ω.
• Cátodo Común al pin GND del Arduino.

Conexión del Zumbador:

• Positivo al pin digital 8 del Arduino.
• Negativo al pin GND del Arduino.

3.3. Lógica del Proyecto

El sistema medirá continuamente la distancia con el sensor ultrasónico y reaccionará de la siguiente manera:

• Distancia > 50 cm: LED Verde encendido, sin sonido.
• 20 cm < Distancia <=50 cm: LED Amarillo (mezcla de rojo y verde), zumbador emite un tono bajo.
• Distancia <= 20 cm: LED Rojo encendido, zumbador emite un tono alto y rápido.

3.4. Código del Sketch

 Copiar/*
  Sistema de Alarma de Proximidad
  
  Usa un sensor ultrasónico para detectar objetos y proporciona feedback visual y sonoro.
 */

// --- Definición de Pines ---
const int trigPin = 7;
const int echoPin = 6;
const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;
const int buzzerPin = 8;

// --- Variables del Sensor Ultrasónico ---
long duration;
int distance;

void setup() {
  // Inicializamos la comunicación serial para depuración
  Serial.begin(9600);
  
  // Configuramos los pines del sensor ultrasónico
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  
  // Configuramos los pines del LED RGB
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  
  // Configuramos el pin del zumbador
  pinMode(buzzerPin, OUTPUT);
  
  // Apagamos todos los LEDs al inicio
  analogWrite(redPin, 0);
  analogWrite(greenPin, 0);
  analogWrite(bluePin, 0);
  digitalWrite(buzzerPin, LOW);
}

void loop() {
  // --- Lectura del Sensor Ultrasónico ---
  // Limpiamos el pin Trig
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  
  // Enviamos un pulso de 10us al pin Trig
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Leemos el ancho del pulso en el pin Echo
  duration = pulseIn(echoPin, HIGH);
  
  // Calculamos la distancia (en cm) basada en la velocidad del sonido (343 m/s)
  // La distancia es la mitad del tiempo (ida y vuelta) por la velocidad.
  // Formula simplificada para cm: distancia = duración * 0.0343 / 2
  distance = duration * 0.0343 / 2;
  
  // --- Mostramos la distancia en el Monitor Serial para depuración ---
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println(" cm");
  
  // --- Lógica de Control ---
  if (distance > 50) {
    // Seguro: Verde
    setColor(0, 255, 0);  // Rojo=0, Verde=255, Azul=0
    noTone(buzzerPin);    // Sin sonido
  }
  else if (distance > 20) {
    // Precaución: Amarillo
    setColor(255, 100, 0); // Rojo=255, Verde=100, Azul=0
    tone(buzzerPin, 500);  // Tono medio
  }
  else if (distance > 2) { // Evitamos ruido del sensor a distancias muy cortas
    // Peligro: Rojo
    setColor(255, 0, 0);   // Rojo=255, Verde=0, Azul=0
    // Tono alto y rápido (usamos delay para cambiar la frecuencia)
    tone(buzzerPin, 1000);
    delay(100);
    noTone(buzzerPin);
    delay(100);
  }
  else {
    // Fuera de rango o error del sensor
    setColor(0, 0, 255);   // Azul para indicar error
    tone(buzzerPin, 300);  // Tono bajo
  }
  
  // Pequeña pausa antes de la próxima lectura
  delay(100);
}

// --- Función auxiliar para establecer el color del LED RGB ---
void setColor(int red, int green, int blue) {
  analogWrite(redPin, red);
  analogWrite(greenPin, green);
  analogWrite(bluePin, blue);
}

3.5. Explicación del Código

• Variables y Pines: Se definen constantes para todos los pines utilizados, mejorando la legibilidad y facilitando cambios futuros.
• Configuración de Pines: En setup(), se configuran los modos de los pines (INPUT/OUTPUT) y se apagan todos los LEDs al inicio.
• Lectura del Ultrasónico: La secuencia de pulsos en los pines trigPin y echoPin sigue el protocolo estándar del HC-SR04. La función pulseIn() mide el tiempo que tarda el eco en regresar.
• Cálculo de Distancia: Se aplica la fórmula distancia = duración * 0.0343 / 2 para convertir el tiempo de vuelo en centímetros.
• Lógica Condicional: Se usan sentencias if-else if para definir las tres zonas de comportamiento basadas en la distancia medida.
• Control de LED RGB: La función setColor() es una función auxiliar que simplifica el control de los tres pines PWM del LED RGB.
• Control del Zumbador:
  • noTone(pin): Detiene cualquier tono que se esté generando en ese pin.
  • tone(pin, frecuencia): Genera una onda cuadrada de la frecuencia especificada (en Hz) en el pin. Cuanto mayor es la frecuencia, más agudo es el sonido.
  • Para el modo "peligro", se alterna manualmente entre tono y silencio con delay() para crear un sonido intermitente.

Este proyecto integra múltiples conceptos: lectura de un sensor digital, cálculos matemáticos, control de salidas PWM para LEDs, generación de tonos con un zumbador y toma de decisiones basadas en condiciones. Es un excelente ejemplo de cómo los sensores y actuadores trabajan juntos en un sistema mecatrónico.

4. Galería de Videos Recomendados

5. Referencias y Lecturas Recomendadas

• Referencia del Lenguaje Arduino - Documentación oficial de funciones como analogWrite, tone, pulseIn, etc.
• Schwartz, M. (2017). Arduino Cookbook. O'Reilly Media. (Capítulos sobre sensores y actuadores)
• Banzi, M. (2008). Getting Started with Arduino. O'Reilly Media. (Capítulo sobre entradas y salidas)