Qué es un robot: de programa a máquina que actúa

01 · Punto de partida

Un programa con cuerpo

Hasta ahora tus programas vivían dentro de la computadora: recibían datos, los procesaban y mostraban un resultado. Con los cursos anteriores aprendiste a leer sensores, a mover actuadores, a comunicar dispositivos y a construir sistemas embebidos. Todas esas piezas se juntan ahora en una sola idea: una máquina que percibe, decide y se mueve sola.

La diferencia con el software habitual es profunda. Si una función recibe un valor incorrecto, devuelve un error y el programa continúa. Si un robot recibe una lectura incorrecta, puede chocar, caerse o romper algo. Los errores dejan de ser mensajes en pantalla y pasan a ser hechos físicos.

Este primer tema no entra todavía en motores ni en sensores concretos: construye el mapa mental que vas a usar en los siguientes cuarenta y siete.

02 · Vocabulario

Qué es (y qué no es) un robot

No existe una definición única, pero casi todas coinciden en tres capacidades que el sistema debe tener a la vez:

• Percibir: medir algo del entorno o de sí mismo con sensores (distancia, luz, posición de una articulación, corriente de un motor).
• Decidir: procesar esa información con un controlador (un microcontrolador, una computadora de placa única) según un programa o un modelo.
• Actuar: modificar el mundo con actuadores (motores, servos, pinzas, ruedas) de forma física.

Con ese criterio, un robot aspirador es un robot, y un brazo industrial también. En cambio, una lavadora con programas fijos es una máquina automática que actúa pero casi no percibe, y un asistente virtual percibe y decide pero no tiene cuerpo.

La frontera es difusa y no vale la pena discutirla demasiado. Lo importante es que, cuanto más se acerca un sistema a las tres capacidades a la vez, más desafíos de programación reales aparecen.

03 · El panorama completo

El lazo sentir, decidir y actuar

Todo robot, desde el más simple hasta el más sofisticado, ejecuta el mismo ciclo una y otra vez. Cada vuelta tarda una fracción de segundo y su resultado cambia el entorno, lo que cambia lo que el robot percibirá en la vuelta siguiente.

Pensalo como un bucle while infinito, con la particularidad de que su condición de entrada es el mundo físico:

1. Sentir: leer los sensores y convertir los valores crudos en magnitudes con unidades.
2. Decidir: comparar lo medido con lo deseado y elegir una acción.
3. Actuar: ordenar el movimiento a los actuadores.
4. Esperar: completar el período del ciclo y volver al paso 1.

La variante más importante es la que usa realimentación: lo que se mide sirve para corregir lo que se ordena. Sin realimentación el robot ejecuta órdenes a ciegas (lazo abierto); con ella puede compensar fricción, pendientes, baterías gastadas y errores propios (lazo cerrado). El tema 40 la estudia en profundidad.

04 · Familias

Tipos de robots

Los robots se agrupan por la forma en que se mueven o por el trabajo que hacen. Esa familia determina qué matemática y qué actuadores necesitás:

Una impresora 3D y un brazo industrial usan motores, finales de carrera y cinemática, igual que un robot de laboratorio. Por eso el curso cubre robótica y automatización juntas: las herramientas se comparten.

05 · Quién decide

Grados de autonomía

«Robot» no implica «autónomo». La autonomía es una escala, y conviene ubicar cada proyecto en ella porque define cuánto software hay que escribir y cuánto riesgo se asume.

En este curso construís desde el nivel asistido hasta uno semiautónomo, que es lo que alcanza un robot móvil que sigue una línea y evita obstáculos por su cuenta.

06 · Cambio de mentalidad

Programar en el mundo físico

Si venís del desarrollo de software, varias costumbres dejan de funcionar. La tabla resume qué cambia:

De todos esos cambios, el más importante es el estado: tu programa no sabe dónde está el robot. Solo tiene lecturas y modelos aproximados. Por eso la robótica se apoya tanto en estimación, filtrado y realimentación.

07 · Cálculo

Tiempo, retardo y distancia de seguridad

Una consecuencia directa del mundo físico: entre que algo ocurre y que el robot reacciona pasa tiempo, y en ese tiempo el robot sigue avanzando. Dos retardos se suman:

• El período del lazo T: si el programa lee el sensor cada T segundos, el obstáculo puede aparecer justo después de una lectura y esperar casi T hasta ser visto.
• La distancia de frenado: un robot con velocidad v y deceleración a necesita v² / (2a) para detenerse una vez dada la orden.

Si además el sensor tiene un error de medición e, la distancia mínima a la que el robot debería empezar a frenar es:

Estos números explican por qué un robot que «anda bien» a baja velocidad choca al subirle la velocidad o al sumarle más trabajo al lazo (leer más sensores, imprimir por serie): el período creció sin que nadie lo notara. Subir la velocidad, además, hace crecer el frenado con el cuadrado.

08 · Código

Un lazo completo en código

Este programa para Arduino implementa el lazo con un sensor ultrasónico HC-SR04 y un motor manejado por un driver. Observá que el ciclo se organiza con millis() en lugar de delay(): así el controlador queda libre para atender otras tareas y el período es fijo.

const int PIN_TRIG = 7;
const int PIN_ECO = 8;
const int PIN_MOTOR = 5;                 // PWM hacia el driver del motor

const float UMBRAL_CM = 15.0;            // frenar si la pared está más cerca
const unsigned long PERIODO_MS = 100;    // período del lazo: 10 lecturas por segundo
unsigned long ultimoCiclo = 0;

float sentirDistanciaCm() {
    digitalWrite(PIN_TRIG, LOW);  delayMicroseconds(2);
    digitalWrite(PIN_TRIG, HIGH); delayMicroseconds(10);
    digitalWrite(PIN_TRIG, LOW);
    unsigned long us = pulseIn(PIN_ECO, HIGH, 30000);   // tope de 30 ms
    if (us == 0) return -1.0;                           // sin eco: lectura inválida
    return us * 0.0343 / 2.0;                           // ida y vuelta del sonido
}

void actuar(int velocidad) {
    analogWrite(PIN_MOTOR, velocidad);                  // 0 = detenido, 255 = máxima
}

void setup() {
    pinMode(PIN_TRIG, OUTPUT);
    pinMode(PIN_ECO, INPUT);
    pinMode(PIN_MOTOR, OUTPUT);
}

void loop() {
    if (millis() - ultimoCiclo < PERIODO_MS) return;    // esperar el próximo ciclo
    ultimoCiclo += PERIODO_MS;

    float distancia = sentirDistanciaCm();               // sentir
    int orden;                                           // decidir
    if (distancia < 0 || distancia <= UMBRAL_CM) orden = 0;   // sin dato o muy cerca: parar
    else orden = 150;
    actuar(orden);                                       // actuar
}

Dos decisiones de diseño merecen atención. Primero, una lectura inválida frena el robot: ante la duda, el estado seguro es detenerse. Segundo, ultimoCiclo += PERIODO_MS (y no = millis()) evita que el período se acumule con la deriva del tiempo de cada vuelta. Los dos hábitos vuelven en todos los temas.

09 · Analogía con programación

Simular el robot antes de construirlo

Un robot real tiene riesgo y es lento de probar. Por eso los equipos profesionales escriben primero una simulación del mundo. Este programa en Python recrea el mismo robot del laboratorio de este tema: avanza hacia una pared con una velocidad ordenada de 40 cm/s (el motor entrega un 90 %: 36 cm/s) y frena con una deceleración de 200 cm/s². Compará dos programas: uno de lazo abierto, que frena tras avanzar el tiempo equivalente a 80 cm, y otro de lazo cerrado, que usa un sensor y frena a 15 cm de la pared.

VEL_ORDENADA = 40.0               # cm/s que se le ordena al motor
VEL_REAL = VEL_ORDENADA * 0.9     # el motor entrega solo el 90 %
DECEL = 200.0                     # cm/s² al frenar


def simular(lazo_cerrado, pared, umbral=15.0, periodo_ms=100):
    """Devuelve (choco, distancia_a_la_pared, lecturas). El paso es de 1 ms."""
    x, v, frenando, lecturas = 0.0, VEL_REAL, False, 0
    for ms in range(20000):
        if not frenando and ms % periodo_ms == 0:      # ciclo del programa
            lecturas += 1
            if lazo_cerrado:
                frenando = (pared - x) <= umbral         # mide la distancia real
            else:
                frenando = ms * VEL_ORDENADA / 1000 >= 80   # estima por tiempo
        if frenando:
            v = max(0.0, v - DECEL * 0.001)
        x += v * 0.001
        if x >= pared:
            return True, 0.0, lecturas
        if frenando and v == 0:
            break
    return False, pared - x, lecturas


for nombre, cerrado in (("abierto", False), ("cerrado", True)):
    for pared in (70, 100, 130):
        choco, gap, lecturas = simular(cerrado, pared)
        texto = "CHOQUE" if choco else f"se detuvo a {gap:.1f} cm de la pared"
        print(f"{nombre} · pared a {pared:3d} cm -> {texto} ({lecturas} lecturas)")

Resultado: el lazo abierto choca si la pared está a 70 cm y se detiene a 24,8 y 54,8 cm de ella cuando está a 100 y 130 cm: siempre hace lo mismo, sin importar el mundo. El lazo cerrado queda a 9,2, 10,4 y 11,6 cm, es decir, se adapta a cada pared. Cambiá umbral a 5 y periodo_ms a 500 y predecí qué casos chocan antes de ejecutar.

Observá que el modelo es una versión simplificada: no hay ruido, la deceleración es constante y el motor responde al instante. Aun así enseña lo esencial: sin sensor, el programa solo funciona en el mundo que imaginó el programador.

10 · Exploración interactiva

Un robot frente a una pared

Este laboratorio ejecuta la simulación del tema. Elegí si el robot trabaja en lazo abierto (cuenta tiempo y frena a ciegas tras 80 cm) o en lazo cerrado (frena al medir una distancia menor que el umbral). Ajustá la velocidad, el período de lectura y el ruido del sensor, y ejecutá una corrida: vas a ver dónde se detuvo el robot, cuántas lecturas hizo y si chocó. Uno de los indicadores muestra la distancia segura que calcula la fórmula de la sección 07 para esa configuración: el umbral debería ser mayor que ella.

Reiniciar borra el historial y devuelve el robot al inicio. En lazo abierto, el umbral y el ruido no se usan: el robot no tiene sensor.

Recorrido guiado

Los resultados siguientes valen con la velocidad en 40 cm/s y sin ruido.

1. Con lazo abierto y la pared a 100 cm, ejecutá una corrida: el robot se detiene a unos 21 cm de la pared. Funciona, pero solo por casualidad.
2. Sin cambiar el modo, bajá la pared a 70 cm: el robot choca a 36 cm/s. El programa nunca se enteró. Subila a 120 cm: se detiene a 41 cm de la pared, mucho antes de lo necesario.
3. Pasá a lazo cerrado (umbral 15 cm, período 100 ms) y repetí con paredes de 70, 100 y 130 cm. Se detiene a unos 9, 10 y 12 cm: el sensor hace que se adapte al mundo.
4. Bajá el umbral a 5 cm con la pared en 100 cm: choca a 13 cm/s. El valor es menor que la distancia segura que muestra el laboratorio (6,8 cm), así que el frenado empieza tarde.
5. Con el umbral en 5 cm, cambiá el período a 10 ms: se detiene a unos 1,7 cm. Un lazo más rápido permite acercarse más sin chocar, pero a cambio carga más al procesador.
6. Poné el umbral en 15 cm, el período en 500 ms y la pared en 100 cm: se detiene a 6,8 cm. Ahora cambiá la pared a 90 cm: choca a 36 cm/s. La orden de frenar depende de si una lectura cae justo antes o justo después del umbral: con un período largo el robot queda a merced de la suerte.
7. Subí la velocidad a 60 cm/s con período de 100 ms y pared en 100 cm: se detiene a unos 6 cm. La velocidad crece, el margen cae.
8. Activá el ruido de ±3 cm y repetí varias corridas con la misma configuración: la distancia final cambia de una corrida a otra. Un ruido pequeño obliga a ampliar el margen.

11 · Método de trabajo

Cómo plantear un robot

1. Definí la tarea y el entorno. ¿Qué debe lograr el robot y en qué condiciones: interior o exterior, suelo liso o irregular, presencia de personas?
2. Elegí el nivel de autonomía. Teleoperado, asistido, semiautónomo o autónomo: cada uno exige un volumen distinto de software.
3. Listá qué tiene que percibir. Cada decisión necesita un dato: sin sensor no hay realimentación.
4. Listá qué tiene que mover. Tipo de actuador, potencia y velocidad.
5. Dibujá el lazo. Qué se mide, qué se decide, qué se ordena y cada cuánto tiempo.
6. Calculá los márgenes. Con período, velocidad y frenado obtenés la distancia mínima de reacción.
7. Definí el estado seguro. Qué hace el robot si falla un sensor, si baja la batería o si el programa se cuelga.
8. Simulá y probá por etapas. Primero el software con datos simulados, después los sensores, después los motores sin carga y recién al final el robot completo, a baja velocidad y con un botón de parada accesible.

Este método se repite en el proyecto integrador de los temas 45 a 48, donde lo aplicás a un robot completo.

12 · Comprensión

Confusiones frecuentes

13 · Práctica guiada

Predecí antes de comprobar

1. ¿Es un robot?

Decidí con el criterio percibir, decidir y actuar si son robots: (a) un portón automático que se abre al detectar un auto y se detiene si encuentra un obstáculo; (b) un reloj despertador; (c) un drone que mantiene su altura; (d) un programa de ajedrez.

2. Avance entre lecturas

Un robot avanza a 50 cm/s y su lazo corre cada 200 ms. ¿Cuánto se mueve entre dos lecturas consecutivas?

3. Distancia segura

El mismo robot (50 cm/s, período de 200 ms) frena con una deceleración de 250 cm/s² y su sensor tiene un error de ±2 cm. ¿A qué distancia mínima de un obstáculo debe disparar el frenado?

4. Subir la velocidad

Si ese robot duplica su velocidad a 100 cm/s sin cambiar nada más, ¿cuánto vale la distancia segura?

5. Autonomía

Clasificá según su nivel de autonomía: (a) un robot de limpieza de ventanas que una persona dirige con un joystick; (b) un robot de almacén al que se le indica «llevá esta caja a la estantería 4»; (c) un aspirador que decide solo su recorrido.

6. Estado seguro

Un robot lee la distancia con un sensor ultrasónico. Si el cable del sensor se desconecta, pulseIn devuelve 0. ¿Qué debería hacer el programa y por qué?

14 · Síntesis

Ideas para recordar

¿Listo para el tema 2?

Antes de avanzar, dibujá de memoria el lazo sentir, decidir y actuar de un robot que sigue una línea, calculá la distancia segura de un robot que avanza a 30 cm/s con un lazo de 50 ms y deceleración de 150 cm/s², y explicá por qué un robot en lazo abierto puede fallar sin que el programa lo note.

En el próximo tema estudiamos la anatomía de un robot: qué componentes físicos y de software tiene cada bloque del lazo y cómo se conectan entre sí.