Proyecto: brazalete sonar con ESP32-C3 Super Mini, un sensor de proximidad en el brazo

Este es el primero de una serie de proyectos paso a paso, pensados para armar con las piezas de la mesa del simulador y después llevar a la mesa de verdad. La propuesta de este es salir del laboratorio e ir al cuerpo: un brazalete sujeto al antebrazo, con un sensor ultrasónico que mira hacia adelante y un zumbador que pita cada vez más rápido cuando algo se acerca. Es el mismo principio del sensor de estacionamiento de un auto, llevado al brazo.

La placa elegida es la ESP32-C3 Super Mini: con cerca de 22,5 × 18 mm, cabe en un brazalete de velcro sin pesar. El proyecto usa solo tres piezas — la placa, el sensor HC-SR04 y un zumbador pasivo — y dos resistencias. Todas están en la paleta del simulador, y el circuito listo se abre directo desde los ejemplos de este artículo.

Una observación importante antes de empezar: es un proyecto de aprendizaje. La idea de un brazalete que avisa de obstáculos recuerda a los auxilios de movilidad para personas con discapacidad visual, y es un excelente punto de partida para discutir tecnología asistiva en el aula. Pero un equipo de verdad para eso pasa por pruebas con los usuarios, por normas y por muchas situaciones que un sensor ultrasónico simple no cubre — vidrio, tela, esquinas finas, escalones. Usa el proyecto para aprender y para conversar con quienes usan este tipo de auxilio, no como sustituto de un bastón.

Lo que vas a necesitar

• una ESP32-C3 Super Mini (la ficha de la placa muestra los pines);
• un sensor ultrasónico HC-SR04 (ficha);
• un zumbador pasivo (ficha) — el pasivo, porque es el que toca la frecuencia que el programa elija;
• dos resistencias, de 1 kΩ y 2 kΩ, para el divisor de tensión del ECHO;
• una protoboard pequeña, cables, y para llevar en el brazo: un brazalete de velcro, un trozo de goma EVA o cartón firme y una fuente USB portátil (una power bank pequeña).

Paso 1: entender las conexiones

El HC-SR04 tiene cuatro pines y se alimenta con 5 V, como explica la lección HC-SR04. En la Super Mini, el pin 5V trae la tensión que llega por el USB-C, y de ahí se alimenta el sensor. Un cuidado que la ficha de la placa repite: nunca alimentes la Super Mini por el pin 5V con el cable USB conectado al mismo tiempo; no hay protección entre las dos fuentes.

El TRIG recibe de la placa un pulso corto que manda al sensor disparar el sonido; va en el GPIO3. El ECHO devuelve un pulso cuya duración es el tiempo de ida y vuelta del sonido. Como el sensor está a 5 V, ese pulso sale con 5 V, por encima de los 3,6 V que acepta un pin de la ESP32-C3. Por eso pasa por un divisor de tensión — 1 kΩ en serie y 2 kΩ a tierra —, que entrega cerca de 2/3 de los 5 V, unos 3,3 V, al GPIO4. Es exactamente el circuito de la lección el ECHO tiene 5 V.

El zumbador pasivo va en el GPIO5 y en el GND. Los pines elegidos evitan tres trampas de la Super Mini: el GPIO8, que tiene el LED azul de la placa; el GPIO9, que es el botón BOOT y decide el modo de grabación si está en 0 al encender; y el GPIO20 y el GPIO21, que son la serie del REPL. El GPIO2 también es un pin de configuración del chip (strapping), y es mejor dejarlo libre.

Paso 2: medir la distancia

Antes de hacer ruido, el programa necesita medir. Abre el ejemplo en el simulador: el circuito ya viene con el sensor apuntando a un objeto a 50 cm. El cálculo es el de la lección: el pulso del ECHO dura 58 µs por centímetro de distancia (ida y vuelta del sonido), y time_pulse_us mide esa duración con un límite de 30 ms, que da unos 5 m.

from machine import Pin, time_pulse_us
import time

trig = Pin(3, Pin.OUT, value=0)
echo = Pin(4, Pin.IN)

def medir_cm():
    trig.value(1)
    time.sleep_us(10)          # el pulso de disparo: 10 µs
    trig.value(0)
    t = time_pulse_us(echo, 1, 30000)
    if t < 0:                  # -1 o -2: nada volvió a tiempo
        return None
    return t / 58

for i in range(5):
    d = medir_cm()
    print('distancia:', 'fuera de alcance' if d is None else '%.0f cm' % d)
    time.sleep_ms(200)

En el simulador, haz clic en el sensor y cambia la distancia del objeto; corre de nuevo y mira cómo cambia el número. Fíjate en el None: cuando nada devuelve el eco a tiempo (un pasillo largo, una superficie que absorbe el sonido), la función no inventa un número.

Paso 3: transformar la distancia en ritmo

Ahora la parte que hace útil al proyecto: decidir cuánto tiempo esperar entre un pitido y otro a partir de la distancia. Las franjas de la imagen del comienzo son elecciones de este proyecto, no números de una norma: funcionan bien caminando despacio por un pasillo, pero cada uno puede ajustarlas.

Las lecturas de ultrasonido a veces salen mal — un eco que rebotó en una esquina y volvió atrasado, una medida que no volvió. Un truco simple y eficiente es la mediana de tres: medir tres veces y quedarse con la del medio. Un valor absurdo, solo, nunca es el del medio. El ejemplo corre sin circuito, con lecturas de ejemplo que incluyen dos errores.

def mediana3(a, b, c):
    return sorted([a, b, c])[1]

def intervalo_ms(d):
    # franjas del proyecto: ajústalas a gusto
    if d is None or d > 150:
        return None      # silencio
    if d > 100:
        return 800
    if d >= 50:
        return 400
    if d >= 20:
        return 150
    return 0             # sonido continuo

leituras = [182, 140, 141, 139, 410, 96, 95, 61, 58, 2, 57, 33, 31, 15, 14, 16]
for i in range(0, len(leituras) - 2, 3):
    a, b, c = leituras[i:i + 3]
    d = mediana3(a, b, c)
    r = intervalo_ms(d)
    som = 'silencio' if r is None else ('continuo' if r == 0 else 'pitido cada %d ms' % r)
    print('%3d %3d %3d -> mediana %3d cm -> %s' % (a, b, c, d, som))

Fíjate en las lecturas de 410 cm y de 2 cm: las dos las descarta la mediana, y el sonido no da un salto falso.

Paso 4: pitar sin bloquear

La tentación es escribir un bucle con time.sleep(intervalo) entre los pitidos. El problema, explicado en la ruta Tiempo sin trabarse, es que durante el sleep el programa no mide nada: si la persona se acerca a una pared durante una espera de 800 ms, el aviso llega atrasado. La solución es la de la lección varias tareas: el bucle gira todo el tiempo, y cada tarea comprueba con ticks_ms() y ticks_diff() si ya es su turno.

Son dos tareas: medir cada 100 ms y pitar cuando pasó el intervalo de la franja actual. El pitido es un PWM de 2 kHz durante 40 ms, como en la lección zumbador. El ejemplo corre por 3 segundos y cuenta los pitidos.

from machine import Pin, PWM, time_pulse_us
from time import ticks_ms, ticks_diff, sleep_us, sleep_ms

trig = Pin(3, Pin.OUT, value=0)
echo = Pin(4, Pin.IN)
buzzer = PWM(Pin(5), freq=2000, duty_u16=0)

FREQ_BIPE = 2000     # Hz
DURACAO_BIPE = 40    # ms

def medir_cm():
    trig.value(1); sleep_us(10); trig.value(0)
    t = time_pulse_us(echo, 1, 30000)
    return None if t < 0 else t / 58

def intervalo_ms(d):
    if d is None or d > 150: return None
    if d > 100: return 800
    if d >= 50: return 400
    if d >= 20: return 150
    return 0

inicio = ticks_ms()
ultima_medida = ultimo_bipe = inicio - 1000
intervalo = None
tocando = False
bipes = 0

while ticks_diff(ticks_ms(), inicio) < 3000:
    agora = ticks_ms()
    if ticks_diff(agora, ultima_medida) >= 100:          # tarea 1: medir
        ultima_medida = agora
        intervalo = intervalo_ms(medir_cm())
    if intervalo == 0:                                    # tarea 2: sonido continuo
        buzzer.duty_u16(32768); tocando = True
    elif tocando and ticks_diff(agora, ultimo_bipe) >= DURACAO_BIPE:
        buzzer.duty_u16(0); tocando = False               # fin del pitido
    elif intervalo and not tocando and ticks_diff(agora, ultimo_bipe) >= intervalo:
        buzzer.freq(FREQ_BIPE); buzzer.duty_u16(32768)    # empieza un pitido
        tocando = True; ultimo_bipe = agora; bipes += 1
    sleep_ms(5)

buzzer.duty_u16(0)
print('intervalo de la franja:', intervalo, 'ms')
print('pitidos en 3 s:', bipes)

Con el objeto a 50 cm, la franja es la de 400 ms, y salen 8 pitidos en 3 segundos. Cambia la distancia en el sensor a 30 cm y corre de nuevo: el ritmo sube a un pitido cada 150 ms. El sleep_ms(5) al final del bucle no bloquea nada: solo evita que el bucle gire más rápido de lo necesario.

Una cuenta para hacer con el curso: el sensor dispara un pulso cada 100 ms. Cada medida tarda como máximo 30 ms (el límite de time_pulse_us), así que sobra tiempo para el zumbador. Si quieres medir más veces por segundo, ten en cuenta que un eco atrasado de una medida puede confundir a la siguiente; dejar al menos algunas decenas de milisegundos entre los disparos es una recomendación común en proyectos con este sensor.

Paso 5: armar en la protoboard y probar en la mesa

Con el programa funcionando en el simulador, arma el circuito de verdad siguiendo la imagen de las conexiones:

1. encaja la Super Mini al lado de la protoboard (o sobre ella, si tu protoboard deja una fila libre a cada lado) y conecta el GND a la barra de alimentación azul y el 5V a la roja;
2. encaja el HC-SR04 con los pines hacia abajo, conecta el VCC a los 5 V y el GND a la barra;
3. conecta el TRIG al GPIO3;
4. arma el divisor: ECHO → resistencia de 1 kΩ → un punto libre; de ese punto, un cable al GPIO4 y una resistencia de 2 kΩ al GND;
5. conecta el zumbador: la pata marcada con + al GPIO5 y la otra al GND;
6. graba el programa como main.py (con el botón de exportar o por Web Serial) y prueba acercando la mano al sensor.

Si no pasa nada, revisa primero el divisor: con el ECHO conectado directo, el pin puede incluso funcionar por un tiempo, pero recibe una tensión por encima del límite. Si el zumbador chilla en lugar de pitar, revisa que sea de verdad el pasivo; el activo tiene un oscilador interno y solo necesita nivel alto, sin PWM.

Paso 6: llevarlo al brazo

La versión de brazo es una cuestión de mecánica y energía:

• base firme: pega la protoboard pequeña (o una placa perforada, si ya sueldas) en un rectángulo de EVA o cartón firme, y sujeta ese rectángulo al brazalete de velcro con pegamento caliente o costura;
• sensor hacia adelante: el HC-SR04 tiene un cono de detección estrecho. Tiene que apuntar hacia donde camina la persona, con el brazo en una posición natural. Prueben con el curso qué ángulo funciona mejor — con el brazo suelto al lado del cuerpo, el sensor tiende a ver el piso;
• cables sujetos: un cable que se suelta en medio de la prueba se vuelve un "obstáculo fantasma" o silencio. Sujeta todo con cinta;
• energía: una power bank pequeña en el bolsillo, con un cable USB-C hasta la placa, es la manera más simple y segura. Entrega los 5 V que necesita el sensor. Una batería de litio directa tiene cerca de 3,7 V, por debajo de los 5 V del HC-SR04; usar una pide un conversor que eleve la tensión, o un sensor de una versión que funcione a 3,3 V — revisa la ficha del tuyo. El artículo baterías en la ESP32 explica cómo calcular cuánto dura la batería.

Paso 7: probar con método

Un proyecto que avisa de obstáculos merece una prueba más cuidadosa que "acerqué la mano y pitó". Una sugerencia de guion para hacer en grupo, con una cinta métrica en el piso:

1. Precisión. Coloca una caja de cartón a 30, 60, 100 y 150 cm del sensor, comprobados con la cinta. Para cada distancia, anota cinco lecturas que el programa imprime en el Serial. Calcula el promedio y la diferencia con la distancia real. ¿Qué pasa a 150 cm? ¿Y a 2 m?
2. Materiales. Repite a 60 cm con una pared lisa, una cortina, un cojín y una puerta de vidrio. El ultrasonido depende del eco: las superficies blandas absorben parte del sonido y las superficies inclinadas lo desvían. Anota qué materiales el sensor "no ve" bien — ese es el tipo de límite que tiene que estar escrito en el manual de cualquier equipo.
3. Ángulo. Con la caja a 60 cm, gira el sensor poco a poco hacia el costado y descubre en qué ángulo deja de verla. Eso muestra el tamaño del "cono" del sensor y ayuda a decidir la posición en el brazo.
4. Tiempo de respuesta. Camina despacio hacia una pared y pide a un compañero que observe: ¿el sonido cambia de franja antes de que llegues demasiado cerca? Si no, aumenta las distancias de las franjas.

Organiza los resultados en una tabla y compara entre los grupos. Las diferencias entre sensores del mismo modelo suelen sorprender, y son una buena conversación sobre por qué se mide antes de confiar.

Ideas para ir más lejos

Vibración en lugar de sonido. En un lugar ruidoso, o para no llamar la atención, un pequeño motor de vibración (como el de un celular) es mejor que un zumbador. No está en la paleta del simulador, y un motor no debe conectarse directo a un pin de la placa: necesita un transistor y un diodo. Es un excelente proyecto de continuación para quien ya domina lo básico.

Dos sensores. Uno apuntando hacia adelante y otro un poco hacia abajo, con sonidos distintos, ayuda a percibir escalones y objetos bajos. La Super Mini tiene pines libres para eso — el GPIO6 y el GPIO7, por ejemplo.

Registrar el recorrido. Guardar las distancias en un archivo, como en el artículo guardar datos en la ESP32, permite hacer después un gráfico del camino: dónde estaban las paredes, cuánto tiempo llevó.

Conversar con el celular. Con el servidor web de la propia placa, se pueden ajustar las franjas de distancia desde una página en el celular, sin volver a grabar el programa.

Lo que enseña este proyecto

Detrás de un objeto simple hay muchos conceptos de la plataforma juntos: tensión y divisor para proteger el pin, medida de tiempo con time_pulse_us, filtrado con la mediana, PWM para generar sonido, tareas sin bloquear con ticks_ms y, al final, la conversación sobre para quién se hace la tecnología. Vale la pena cerrar el proyecto con esa pregunta para el curso: ¿qué cambiaría en el proyecto si lo hubieran pensado junto con alguien que lo usaría todos los días?

Para continuar

Las lecciones usadas aquí están en las rutas Sensores (HC-SR04 y divisor de tensión), PWM (zumbador) y Tiempo sin trabarse (ticks y varias tareas). El artículo sensores DHT22, HC-SR04 y PIR profundiza en el sensor, y el mapa de pines ayuda a elegir pines para tus variaciones.

Fuentes

• Distribución de pines y cuidados de la ESP32-C3 Super Mini: espboards.dev y Last Minute Engineers, las mismas fuentes de la ficha de la placa.
• Tensiones y funcionamiento del HC-SR04 y del divisor: las lecciones y la ficha del componente, con las fuentes citadas en ellas.
• Documentación de MicroPython: machine.time_pulse_us y PWM.