Construye tu Robot con Raspberry Pi: Guía para Principiantes y Proyectos Avanzados

La Raspberry Pi es el cerebro ideal para robótica: Linux completo, GPIO, cámaras, USB, WiFi/BT, comunidad masiva, Python/C++/ROS, y coste accesible. Esta guía te lleva desde un robot evitador de obstáculos básico (Pi 3/4 + L293D + sensor IR) hasta 9 proyectos inspiradores (cuadrúpedos, humanoides, Roomba, lucha, Spot Micro).

Proyecto Base: Robot Evitador Obstáculos (Principiante)

Lista de Materiales (BOM)

Componente	Cantidad	Notas
Raspberry Pi	1	Pi 3B/3B+/4B (4B 2GB+ recomendado)
Motores DC con reductor (geared)	2	6–12 V, 100–300 RPM, eje doble para encoder opcional
Driver motor L293D / L298N / TB6612FNG	1	L293D: 0.6 A/canal, 4.5–36 V. TB6612: 1.2 A, más eficiente, 2.7–5.5 V lógica
Rueda loca (caster)	1	Delantera o trasera, giratoria 360°
Chasis robot + 2 ruedas	1	Kit chasis 2WD (acrílico, aluminio, impreso 3D)
Sensor IR obstáculo (FC-51 / HW-201)	2–3	Salida digital (LOW=obstáculo), rango 2–30 cm, potenciómetro ajuste
Sensor ultrasónico HC-SR04 (opcional)	1	Medición distancia precisa, evasión proactiva
Batería LiPo 2S/3S (7.4/11.1 V) + BEC 5V 3A	1	O power bank 5V 3A (Pi 4) / 5V 5A (Pi 5). LiPo + step-down más ligero.
MicroSD 32 GB Class 10/A2	1	Raspberry Pi OS Lite 64-bit
Protoboard / PCB perf + jumpers M-M, M-H, H-H	1 set
Cinta doble cara, bridas, tornillos M3	1 set	Fijación componentes
Pulsador + LED (opcional)	1	Encendido/apagado seguro, estado

Conexiones Esquemáticas

Sensor IR (FC-51) a GPIO

FC-51 VCC → Pi Pin 2 (5V) o Pin 1 (3.3V)  // Ver spec sensor: muchos funcionan 3.3-5V
FC-51 GND → Pi Pin 6 (GND)
FC-51 OUT → Pi GPIO 17 (Pin 11)  // Sensor izquierdo
FC-51 OUT → Pi GPIO 27 (Pin 13)  // Sensor derecho (2º sensor)

Driver L293D a Motores y Pi

L293D Pin 1 (EN1,2)  → Pi GPIO 22 (Pin 15)  // PWM velocidad motor A
L293D Pin 2 (IN1)    → Pi GPIO 23 (Pin 16)  // Dir motor A
L293D Pin 7 (IN2)    → Pi GPIO 24 (Pin 18)  // Dir motor A
L293D Pin 9 (EN3,4)  → Pi GPIO 25 (Pin 22)  // PWM velocidad motor B
L293D Pin 10 (IN3)   → Pi GPIO 5  (Pin 29)  // Dir motor B
L293D Pin 15 (IN4)   → Pi GPIO 6  (Pin 31)  // Dir motor B
L293D Pin 4,5,12,13 (GND) → Pi GND (Pin 6,9,14,20,25,30,34,39) + Batería GND
L293D Pin 8 (VCC2)   → Batería + (7.4–11.1 V)  // Potencia motores
L293D Pin 16 (VCC1)  → Pi Pin 2 (5V)           // Lógica driver (5V tolerant inputs)
Motores: Out1/Out2 → Motor A, Out3/Out4 → Motor B

Código Python: Control Básico + Evitación Obstáculos

#!/usr/bin/env python3
# robot_avoid.py - Robot evitador obstáculos Raspberry Pi + L293D + 2x FC-51
import RPi.GPIO as GPIO
import time

# Pines (BCM numbering)
MOTOR_A_EN, MOTOR_A_IN1, MOTOR_A_IN2 = 22, 23, 24
MOTOR_B_EN, MOTOR_B_IN1, MOTOR_B_IN2 = 25, 5, 6
IR_LEFT, IR_RIGHT = 17, 27
BTN_START = 4  # Pulsador inicio/parada (pull-up interno)

SPEED = 60  # % PWM (0-100)
TURN_SPEED = 50

GPIO.setmode(GPIO.BCM)
GPIO.setup([MOTOR_A_EN, MOTOR_A_IN1, MOTOR_A_IN2, MOTOR_B_EN, MOTOR_B_IN1, MOTOR_B_IN2], GPIO.OUT)
GPIO.setup([IR_LEFT, IR_RIGHT], GPIO.IN)
GPIO.setup(BTN_START, GPIO.IN, pull_up_down=GPIO.PUD_UP)

pwm_a = GPIO.PWM(MOTOR_A_EN, 1000)  # 1 kHz PWM
pwm_b = GPIO.PWM(MOTOR_B_EN, 1000)
pwm_a.start(0)
pwm_b.start(0)

def set_motor(pwm, in1, in2, speed):  # speed: -100 a 100
    if speed > 0:
        GPIO.output(in1, GPIO.HIGH); GPIO.output(in2, GPIO.LOW)
    elif speed < 0:
        GPIO.output(in1, GPIO.LOW); GPIO.output(in2, GPIO.HIGH)
    else:
        GPIO.output(in1, GPIO.LOW); GPIO.output(in2, GPIO.LOW)
    pwm.ChangeDutyCycle(min(abs(speed), 100))

def forward(s=SPEED): set_motor(pwm_a, MOTOR_A_IN1, MOTOR_A_IN2, s); set_motor(pwm_b, MOTOR_B_IN1, MOTOR_B_IN2, s)
def backward(s=SPEED): set_motor(pwm_a, MOTOR_A_IN1, MOTOR_A_IN2, -s); set_motor(pwm_b, MOTOR_B_IN1, MOTOR_B_IN2, -s)
def turn_left(s=TURN_SPEED): set_motor(pwm_a, MOTOR_A_IN1, MOTOR_A_IN2, -s); set_motor(pwm_b, MOTOR_B_IN1, MOTOR_B_IN2, s)
def turn_right(s=TURN_SPEED): set_motor(pwm_a, MOTOR_A_IN1, MOTOR_A_IN2, s); set_motor(pwm_b, MOTOR_B_IN1, MOTOR_B_IN2, -s)
def stop(): set_motor(pwm_a, MOTOR_A_IN1, MOTOR_A_IN2, 0); set_motor(pwm_b, MOTOR_B_IN1, MOTOR_B_IN2, 0)

running = False
def btn_callback(ch):
    global running
    running = not running
    print("Robot:", "INICIADO" if running else "DETENIDO")
    if not running: stop()

GPIO.add_event_detect(BTN_START, GPIO.FALLING, callback=btn_callback, bouncetime=300)

print("Presiona botón para INICIAR/DETENER. Ctrl+C para salir.")
try:
    while True:
        if running:
            left_obs = not GPIO.input(IR_LEFT)   # LOW = obstáculo
            right_obs = not GPIO.input(IR_RIGHT)
            if left_obs and right_obs:
                backward(40); time.sleep(0.3); turn_right(); time.sleep(0.4)
            elif left_obs:
                turn_right(); time.sleep(0.3)
            elif right_obs:
                turn_left(); time.sleep(0.3)
            else:
                forward()
        else:
            stop()
        time.sleep(0.05)
except KeyboardInterrupt:
    stop()
finally:
    pwm_a.stop(); pwm_b.stop(); GPIO.cleanup()

Pruebas y Puesta en Marcha

1. Prueba sensores: python3 -c "import RPi.GPIO as GPIO; GPIO.setmode(GPIO.BCM); GPIO.setup(17,GPIO.IN); print(GPIO.input(17))" (cambia al tapar sensor).
2. Prueba motores: sudo python3 test_motors.py (código simple PWM + dirs).
3. Ejecuta robot: sudo python3 robot_avoid.py.
4. Ajusta potenciómetros sensores IR para distancia deseada (2–15 cm típico).
5. Añade histéresis software: requiere N lecturas consecutivas antes de reaccionar.

9 Proyectos Robot Raspberry Pi Inspiradores (Nivel Intermedio/Avanzado)

1. CHOP Quadruped Robot (Estilo Boston Dynamics Spot Mini)

• Hardware: Pi 4B (cerebro alto nivel) + Arduino Mega (bajo nivel: 12 servos, IMU, cinemática inversa).
• Software: Python (Pi) + C++ (Arduino), ROS/ROS2 opcional, cinemática inversa analítica, control joystick BT.
• Fabricación: Piezas 3D imprimibles (PLA/PETG/ASA), tornillos M3, varillas carbono.
• Repo: github.com/chiptron/CHOP.

2. Ping Pong Robot (Juega Tenis de Mesa)

• Visión: Cámara global shutter (Arducam OV7251) + OpenCV / TensorFlow Lite detección pelota + predicción trayectoria.
• Actuación: Motores lineales / actuadores voz + servos rápidos. Latencia crítica <20 ms.
• Control: Pi 4/5 + MCU tiempo real (STM32/Teensy 4.0) para lazo cerrado rápido.
• DIY: Piezas impresas 3D + corte láser. Coste ∼$500–1000 vs $2000+ comercial.

3. Robot Humanoide Raspberry Pi

• Kit Bioloid / Robotis / Poppy / impresión 3D (InMoov).
• Pi Zero 2 W / Pi 4 + servo bus (Dynamixel XL320/430, MX28) + IMU (MPU6050/BNO055).
• Funciones: Caminata, evasión ultrasónica, reconocimiento voz/rostro, control app/Blynk.
• Alimentación: LiPo 2S/3S + BEC 5V/6V alta corriente (servos pican 2–5 A picos).

4. Pi Roomba (Aspiradora Robot DIY)

• Interfaz: Roomba SCI (Serial Command Interface) via UART (RX/TX Pi → Mini-DIN 7 pines Roomba). Nivel 0–5V / 0–3.3V según modelo.
• Software: Python pycreate2, roomba_ci, o Node.js node-roomba. Joystick USB/Bluetooth.
• Sensores: Cliff, bump, wheel drop, dirt detect, battery, encoders vía SCI.
• Extensión: Cámara Pi + OpenCV → navegación visual, SLAM ligero.

5. Butter Robot (Rick & Morty) — Cámara + Audio Streaming

• Pi Zero 2 W + Camera Module 3 + USB Audio (mic + speaker) + 2× DC motor + L9110 + 9g servo (cabeza) + Blynk app.
• Streaming vídeo MJPEG / WebRTC + audio bidireccional. Batería 18650×2 + TP4056 + step-up 5V.
• Chasis impreso 3D (Butter bot design).

6. Petoi Nybble / Bittle (Gato / Perro Robótico Open-Source)

• Nybble: Madera cortada láser + Arduino Pro Mini (control servos) + Pi opcional (IA).
• Bittle: Plástico inyectado + ESP32 (control) + Pi opcional. 9 servos P1S.
• Memoria muscular: Guarda gaits aprendidos. Programable Python/C++/Scratch.
• Comunidad activa, docs extensas, STEM education.

7. Spot Micro (Mini Spot de Boston Dynamics)

• Pi 3B/4B + Ubuntu 20.04/22.04 + ROS 2 (Foxy/Humble).
• 12 servos (3 por pata) + PCA9685 / controlador servo serie.
• Gaits: trot, walk, crawl. Control ángulo 3 ejes por pata (inverse kinematics).
• Opcional: LiDAR (RPLIDAR A1/A2) → mapeo SLAM, navegación autónoma.
• Repo: github.com/mike4192/SpotMicro.

8. Mini Robot Lucha (Antweight / Beetleweight)

• Pi Zero 2 W (cerebro) + 2× ESC brushless (drone) + 2× motor brushless 1102–1404 (arma + drive) o 4× brushed (drive).
• Control: Mando RC (PPM/SBUS) → Pi GPIO / UART → ESCs. O Bluetooth + app custom.
• Chasis: Impresión 3D (TPU/PETG-CF) o carbono. Peso ≤ 150 g (Antweight) / ≤ 1.5 kg (Beetle).
• Reglas: Builders Database, eventos locales.

9. Devastator Tank Robot (Plataforma Móvil con Cañón/Cámara)

• Kit: DFRobot Devastator / châssis oruga metálico + 2 motores DC + driver (L298N/TB6612).
• Pi Zero W + Camera Module → streaming vídeo WebRTC / MJPEG.
• Control: Web interface (Flask/FastAPI + WebSocket) o app Blynk/RemoteXY.
• Extensión: Brazo robótico 3 DOF + gripper, sensor ultrasónico torreta.

Consejos para Escalar tus Proyectos

• ROS 2 (Robot Operating System): Estándar robótica profesional. Nodos: driver motores, sensores, SLAM (slam_toolbox), navegación (Nav2), percepción (OpenCV, YOLO, DepthAI). Pi 4/5 + Ubuntu 22.04 + ROS 2 Humble.
• Simulación: Gazebo / Webots / Isaac Sim → valida código antes de hardware.
• Visión: Pi Camera Module 3 (12 MP, AF, HDR) + OpenCV / TensorFlow Lite / YOLOv8n / DepthAI (OAK-D Lite).
• IMU + Odometría: BNO055 / ICM-20948 + encoders motores → EKF (robot_localization) → pose 2D/3D.
• Alimentación robusta: LiPo 3S/4S + BEC 5V 5–10 A (Pololu D24V50F5) + protección baja tensión (LiPo alarm).
• Comunicación baja latencia: UDP / WebRTC / ROS 2 DDS (Fast DDS / Cyclone DDS) sobre WiFi 5/6 o Ethernet.

Conclusión

Raspberry Pi democratiza la robótica: desde un evitador de obstáculos de $50 hasta un cuadrúpedo tipo Spot de $500. Python + GPIO + cámara + comunidad = curva aprendizaje suave. Para proyectos serios: Pi 4/5 + ROS 2 + MCU tiempo real (STM32/Teensy/ESP32) para lazos de control rápidos. Imprime 3D, itera, comparte.

¿Atascado en tu robot? Contáctanos para ayuda con cinemática, ROS 2, visión, drivers motores, PCB custom o selección de componentes.