← Volver a proyectos
PROYECTO #07 Avanzado ⏱ 90 min

Pie
Chutador

Controla un pie chutador con la mano a distancia usando dos micro:bits y radio. El sensor magnético detecta la dirección del giro y el acelerómetro lanza el chut. Sin cables entre el mando y el robot.

2× Servo SG90 micro:bit Radio Sensor Magnético Acelerómetro 🔌 2 pines 📚 Radio / Sensores internos
⚽🤖
2
micro:bits
90'
Tiempo
P0+P1
Servos

Materiales

Necesitas dos micro:bits: una hace de mando (en la mano) y otra de actuador (en el pie chutador).

🤖
micro:bit (Mando)
Controlador
Lee brújula y acelerómetro. Envía datos por radio.
×1
🤖
micro:bit (Actuador)
P0 chut · P1 giro
Recibe por radio y mueve los servos.
×1
⚙️
Servo SG90 — Chut
P0 — digital write
Mueve la pierna para chutar cuando se inclina el mando.
×1
🔄
Servo SG90 — Giro
P1 — servo write
Gira el pie según la dirección de la brújula del mando.
×1
🔌
Shield / Breakout
Breakout board para conectar los servos a la micro:bit actuadora.
×1
🧵
Cables Dupont
Para conectar los servos al breakout. Solo en la parte del actuador.
×6

Conexión

Solo la micro:bit actuadora tiene cables físicos. El mando (controlador) usa únicamente los sensores integrados y la radio.

Componente Pin servo micro:bit (Actuador) Cable
Servo Chut — señal S P0 Naranja
Servo Chut — alimentación V 3V Rojo
Servo Chut — masa G GND Negro
Servo Giro — señal S P1 Naranja
Servo Giro — alimentación V 3V Rojo
Servo Giro — masa G GND Negro
1
micro:bit Actuador: inserta en el breakout/shield. Conecta el servo de chut al canal P0 (señal, 3V, GND) y el servo de giro al canal P1.
2
micro:bit Mando: no necesita ningún cable. Sujétala en la mano con una goma o funda. Usará su brújula y acelerómetro internos.
3
Radio: las dos micro:bits se comunican por radio en el mismo grupo (grupo 1). Asegúrate de programar el mismo número de grupo en ambas.
Tip: Calibra la brújula del mando antes de empezar. En MakeCode aparece la pantalla de calibración al arrancar si usas input.compassHeading().

Programación

Dos programas independientes: uno para el mando, otro para el actuador.

Tutorial Pie Chutador con micro:bit
📡 Recuerda: debes cargar el programa del Mando en una micro:bit y el programa del Actuador en la otra. Son dos archivos .hex diferentes.

— PROGRAMA 1: MANDO (micro:bit en la mano) —

MakeCode JavaScript — Mando
// === MANDO — micro:bit 1 (en la mano) ===
radio.setGroup(1)
radio.setTransmitPower(7)

basic.forever(function () {
    // Brújula: heading 0-360 → giro del pie
    let heading = input.compassHeading()
    // Acelerómetro eje Y: inclinar hacia delante → chut
    let acc = input.acceleration(Dimension.Y)

    radio.sendValue("h", heading)
    radio.sendValue("a", acc)
    basic.pause(50)
})

— PROGRAMA 2: ACTUADOR (micro:bit en el pie chutador) —

MakeCode JavaScript — Actuador
// === ACTUADOR — micro:bit 2 (en el robot) ===
radio.setGroup(1)

// Servo giro en P1, servo chut en P0
radio.onReceivedValue(function (name, value) {
    if (name == "h") {
        // Mapear heading 0-360 → servo 0-180
        let angGiro = Math.map(value, 0, 360, 0, 180)
        pins.servoWritePin(AnalogPin.P1, angGiro)
    }
    if (name == "a") {
        // Inclinar hacia delante (acc > 500) → chutar
        if (value > 500) {
            pins.servoWritePin(AnalogPin.P0, 130) // posición chut
            basic.pause(300)
            pins.servoWritePin(AnalogPin.P0, 60)  // posición reposo
        }
    }
})

— PROGRAMA 1: MANDO —

MicroPython — Mando
# === MANDO — micro:bit 1 ===
import radio
from microbit import *

radio.config(group=1, power=7)
radio.on()

while True:
    heading = compass.heading()
    acc = accelerometer.get_y()
    radio.send(str(heading) + "," + str(acc))
    sleep(50)

— PROGRAMA 2: ACTUADOR —

MicroPython — Actuador
# === ACTUADOR — micro:bit 2 ===
import radio
from microbit import *

radio.config(group=1)
radio.on()

while True:
    msg = radio.receive()
    if msg:
        partes = msg.split(",")
        heading = int(partes[0])
        acc = int(partes[1])

        # Giro: mapear 0-360 a 0-180 grados
        ang_giro = heading * 180 // 360
        pin1.write_analog(ang_giro * 1023 // 180)

        # Chut: inclinar hacia delante
        if acc > 500:
            pin0.write_analog(747)  # ~130° chut
            sleep(300)
            pin0.write_analog(341)  # ~60° reposo
📡
radio.setGroup(1) — Las dos micro:bits deben compartir el mismo número de grupo para comunicarse. Cambia el número si hay otras micro:bits cerca.
🧭
input.compassHeading() — Devuelve un valor de 0 a 360 según la orientación magnética del norte. Se mapea a 0-180° para controlar el ángulo del servo de giro.
📐
input.acceleration(Dimension.Y) — El eje Y mide la inclinación hacia delante/atrás. Cuando supera 500 (inclinación fuerte hacia delante), se activa el chut.
⚙️
pins.servoWritePin(P0, 130) — Mueve el servo de chut a 130° (posición de patada) y luego regresa a 60° (reposo). La pausa de 300ms da tiempo al servo.

Problemas frecuentes

📡
El actuador no responde al mando
Verifica que ambas micro:bits usan el mismo grupo de radio (radio.setGroup(1)). Acércalas más: el rango efectivo en interior puede ser menor del esperado.
🧭
El giro no funciona bien o va errático
Calibra la brújula del mando: cuando aparezca el mensaje de calibración, gira la micro:bit en todos los ángulos hasta que el LED forme un círculo completo.
⚙️
El servo chuta solo o de forma continua
El umbral del acelerómetro es demasiado bajo. Aumenta el valor de 500 a 700 u 800 para que solo se active con una inclinación más pronunciada.
🔋
Los servos no se mueven o van débiles
Usa el breakout con alimentación externa (pilas AA) para los servos. El USB de la micro:bit da poca corriente y dos servos pueden sobrecargarla.