Encuentra tu pasión a solo 4,17 US$/mes | Aprende Robótica, IA e IOT.

Tutorial Sensor Ultrasónico Arduino para Robótica

Tutorial sensor ultrasónico Arduino para robótica

Hace unos días, mientras programaba un robot móvil, recordé mi primer proyecto con sensores. No sabía cómo detectar obstáculos, y siempre terminaba chocando. Fue entonces cuando descubrí el sensor ultrasónico, un módulo económico y fácil de usar. En este tutorial, te enseñaré paso a paso cómo conectar y programar este sensor para que tu robot también pueda medir distancias y evitar colisiones de manera inteligente.

Tabla de contenidos

Lista de materiales

Lista de materiales para conectar y programar el sensor ultrasónico HC-SR04 con Arduino en proyectos de robótica.

Cantidad Material Función
1 Arduino Uno Controlador principal del proyecto
1 Sensor ultrasónico HC-SR04 Mide la distancia hasta un objeto u obstáculo
1 Protoboard Facilita las conexiones sin soldadura
4 Jumpers macho-macho Realizar conexiones entre el Arduino y el sensor
1 Cable USB Conecta Arduino a la computadora para programación

Diagrama de Conexiones

Conecta correctamente tu sensor ultrasónico HC-SR04 al Arduino siguiendo esta guía paso a paso y evita errores que afecten la medición de distancias.
Abrir práctica en Tinkercad

Paso 1: Preparar materiales y espacio de trabajo

Reúne el Arduino, el sensor ultrasónico, los jumpers y la protoboard. Asegúrate de trabajar en una superficie limpia y ordenada para evitar confusiones en las conexiones.

Paso 2: Identificar los pines del sensor HC-SR04

Ubica los cuatro pines del sensor: VCC, TRIG, ECHO y GND. Generalmente están marcados en la parte inferior del módulo, revisa antes de conectar.

Paso 3: Conectar VCC del sensor a 5V de Arduino

Usa un jumper para conectar el pin VCC del sensor al pin de 5V en el Arduino, proporcionando la alimentación necesaria para su funcionamiento.

Paso 4: Conectar GND del sensor a GND de Arduino

Conecta el pin GND del sensor al pin GND del Arduino para completar el circuito de alimentación y asegurar un funcionamiento estable.

Paso 5: Conectar TRIG del sensor al pin digital 9 de Arduino

Conecta el pin TRIG del sensor al pin digital 9 del Arduino. Este pin se encargará de enviar el pulso ultrasónico para medir distancias.

Paso 6: Conectar ECHO del sensor al pin digital 8 de Arduino

Conecta el pin ECHO del sensor al pin digital 8 del Arduino. Este pin recibirá la señal de retorno que permite calcular la distancia.

Código Arduino

Aquí te presento el código completo para usar el sensor ultrasónico Arduino y medir distancias en tus proyectos de robótica.

				
					// -------------------------------
// SENSOR ULTRASÓNICO HC-SR04
// USO EN ROBÓTICA
// -------------------------------

// En robótica, este sensor se usa para detectar obstáculos y medir distancias.
// Por ejemplo, en un robot móvil evita chocar contra objetos,
// o en un brazo robótico mide si hay algo frente a la pinza.

// 1. Definimos los pines de conexión del sensor.
#define trigPin 9   // Pin digital 9 conectado al pin TRIG del sensor
#define echoPin 8   // Pin digital 8 conectado al pin ECHO del sensor

// 2. Variable para almacenar la duración del pulso y la distancia calculada
long duration;      // Duración del pulso en microsegundos
int distance;       // Distancia calculada en centímetros

void setup() {
  // 3. Iniciamos la comunicación serial para ver resultados en la computadora
  Serial.begin(9600);

  // 4. Configuramos los pines
  pinMode(trigPin, OUTPUT); // TRIG se configura como salida, envía el pulso
  pinMode(echoPin, INPUT);  // ECHO se configura como entrada, recibe el eco
}

void loop() {
  // 5. Para medir distancia, primero limpiamos el pin TRIG por 2 microsegundos
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  // 6. Enviamos un pulso de 10 microsegundos para activar el sensor
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // 7. Medimos el tiempo que tarda en regresar el eco
  duration = pulseIn(echoPin, HIGH);

  // 8. Calculamos la distancia:
  // La velocidad del sonido es 0.034 cm/us
  // Dividimos entre 2 porque el pulso va y regresa
  distance = duration * 0.034 / 2;

  // 9. Mostramos la distancia en el monitor serial
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println(" cm");

  // 10. Pausa de medio segundo antes de la siguiente medición
  delay(500);

  // -----------------------------------------
  // RELACIÓN CON ROBÓTICA
  // Este código puede usarse en un robot móvil autónomo
  // para evitar chocar con paredes u objetos. 
  // También en brazos robóticos para calcular la distancia a un objeto 
  // antes de cerrar la pinza.
  // -----------------------------------------
}

				
			

Explicación del código

A continuación te explicaré las líneas más importantes de este código para que comprendas su funcionamiento.

Paso 1: Definición de pines

				
					#define trigPin 9
#define echoPin 8

				
			

Aquí se definen los pines digitales que se usan para conectar el sensor. trigPin (9) enviará el pulso ultrasónico y echoPin (8) recibirá el eco reflejado. Es importante porque si cambias los pines físicos en tu Arduino debes modificar estos valores aquí para que el programa funcione correctamente.

Paso 2: Configurar pines

				
					pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);


				
			

Se configuran los pines declarados. trigPin se configura como salida porque enviará el pulso ultrasónico y echoPin como entrada porque recibirá el eco. Esta configuración es esencial para que el sensor cumpla su función de enviar y recibir señales al medir distancias.

Paso 3: Enviar el pulso ultrasónico

				
					digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);



				
			

Este bloque primero limpia el TRIG poniéndolo en LOW, espera 2 microsegundos, luego envía un pulso de 10 microsegundos con HIGH y lo apaga. Esto activa el sensor ultrasónico para emitir la señal y detectar objetos al frente. Es la base de la medición.

Paso 4: Medir la duración del eco

				
					duration = pulseIn(echoPin, HIGH);



				
			

Aquí se mide el tiempo (en microsegundos) que tarda el eco en regresar al sensor después de chocar contra un objeto. Este dato se usa luego para calcular la distancia, siendo la base de todo el funcionamiento del sensor ultrasónico.

Paso 5: Calcular la distancia

				
					distance = duration * 0.034 / 2;



				
			

Calcula la distancia con la fórmula basada en la velocidad del sonido (0.034 cm/us) y dividiéndolo entre 2, ya que el pulso va y regresa. Es fundamental entender esta fórmula para ajustar el sensor a distintas aplicaciones en robótica educativa.

Pruebas Experimentales

Realiza estas pruebas para verificar el funcionamiento del sensor ultrasónico con Arduino de forma correcta y segura.

Paso 1: Preparar el circuito

Verifica que todas las conexiones entre el Arduino y el sensor ultrasónico estén correctas según el diagrama y no haya cables sueltos.

Paso 2: Abrir Arduino IDE

Abre el Arduino IDE en tu computadora y asegúrate de haber seleccionado el puerto y placa correctos antes de cargar el programa.

Paso 3: Cargar el código al Arduino

Haz clic en el botón «Subir» en Arduino IDE y espera a que termine la compilación y carga. Revisa que aparezca el mensaje de carga exitosa.

Paso 4: Abrir el Monitor Serial

Ve al menú Herramientas > Monitor Serial o haz clic en su icono para abrirlo y observar las mediciones de distancia que realiza el sensor.

Paso 5: Colocar objetos frente al sensor

Acerca y aleja objetos frente al sensor ultrasónico HC-SR04 y observa cómo los valores de distancia cambian en tiempo real en el monitor serial.

Paso 6: Verificar el rango de medición

Prueba con objetos a diferentes distancias para verificar que el sensor detecte de forma adecuada dentro de su rango de trabajo (2cm a 400cm).

Paso 7: Revisar posibles errores

Si no aparecen mediciones, revisa las conexiones de VCC, GND, TRIG y ECHO, así como los pines definidos en el código para corregir errores.

Ingrese a su cuenta