Construye un robot seguidor de línea: de sensores a dirección PID

Un seguidor de línea es el clásico primer robot autónomo: lee una línea bajo sus sensores y dirige para mantenerse sobre ella. Por debajo, es un pequeño problema de control —convertir lecturas de sensores en una corrección de dirección— lo que lo hace una forma perfecta de aprender control por realimentación. Síguelo en el simulador de seguidor de línea.

Detecta la línea

Un sensor de reflectancia emite luz infrarroja hacia abajo y mide cuánta rebota. Una línea oscura refleja menos que la superficie clara que la rodea, así que cada sensor informa si está sobre la línea. Una barra de varios sensores en el frontal del robot te dice no solo si estás sobre la línea, sino dónde está la línea respecto al centro.

Cinco sensores son un buen punto de partida. Tres funcionan a baja velocidad; los robots de competición suelen usar ocho para resolución más fina.

Convierte lecturas en un número de error

En lugar de reaccionar a sensores individuales, combínalos en una única posición ponderada. Da a cada sensor un valor de posición (negativo a la izquierda, cero en el centro, positivo a la derecha) y toma la media ponderada por cuánto ve la línea cada uno:

// positions: {-2, -1, 0, 1, 2}; readings: reflectance per sensor
float weightedPosition = sum(position[i] * reading[i]) / sum(reading[i]);

El resultado es tu error: cero significa centrado, negativo significa que la línea está a la izquierda, positivo a la derecha. Un error suave y continuo es justo lo que necesita un controlador.

Dirige con PID

Alimenta ese error a un controlador PID. La corrección acelera una rueda y frena la otra, girando el robot de vuelta hacia la línea:

float correction = kp * error + ki * integral + kd * derivative;
setMotorSpeeds(baseSpeed - correction, baseSpeed + correction);

La ganancia proporcional lleva la mayor parte de la dirección; la ganancia derivativa amortigua la oscilación en curvas; un pequeño término integral elimina cualquier deriva constante. Si eres nuevo eligiendo ganancias, trabaja primero cómo sintonizar un controlador PID.

Arregla los fallos comunes

• Oscilar alrededor de la línea: la ganancia proporcional es demasiado alta o la derivativa demasiado baja. Reduce primero la velocidad, luego resintoniza. En hardware real, un delay() largo en el bucle añade tiempo muerto que anula el término derivativo.
• Perder la línea en giros cerrados: el robot supera su tasa de actualización de sensores. Baja la velocidad, ensancha la barra o reutiliza la última dirección conocida de la línea para que el robot gire de vuelta en lugar de salirse recto.
• Derivar hacia un lado: calibra los sensores. Pásalos sobre la línea y el fondo, registra el mínimo y máximo de cada uno, y normaliza las lecturas en vivo contra ese rango.

Todo el bucle, en un sitio

Los fragmentos de arriba se convierten en un robot funcional solo cuando la temporización, la calibración y el caso de línea perdida se manejan juntos:

const int N = 5;
const int PIN[N] = {A0, A1, A2, A3, A4};
const int POS[N] = {-2000, -1000, 0, 1000, 2000};   // weights, in the error's units

int minv[N], maxv[N];
long lastError = 0;
float integral = 0;
unsigned long lastMicros = 0;

const float KP = 0.10f, KI = 0.0f, KD = 1.6f;
const int   BASE = 140;                              // out of 255

void loop() {
  // 1. Real elapsed time — never assume the loop period.
  const unsigned long now = micros();
  const float dt = (now - lastMicros) * 1e-6f;
  if (dt < 0.002f) return;                           // cap the rate at 500 Hz
  lastMicros = now;

  // 2. Position from the weighted average.
  long weighted = 0, total = 0;
  for (int i = 0; i < N; i++) {
    const int v = normalized(analogRead(PIN[i]), i);
    if (v > 100) { weighted += (long)v * POS[i]; total += v; }
  }

  // 3. Line lost: hold the last error, do NOT zero it.
  const long error = (total == 0) ? lastError : (weighted / total);

  // 4. PID, with derivative on measurement and conditional integration.
  const float derivative = -(float)(error - lastError) / dt;
  const float candidate = integral + error * dt;
  const float raw = KP * error + KI * candidate + KD * derivative;
  const float correction = constrain(raw, -BASE, BASE);
  if (raw == correction) integral = candidate;

  lastError = error;

  // 5. Differential steering.
  setMotors(BASE - correction, BASE + correction);
}

Cinco cosas ahí dentro son las que separan un robot que sigue una línea de uno que casi lo hace.

dt real. Tanto I como D dividen por tiempo transcurrido. Un bucle cuya duración cambia al añadir funciones —y lo hará— calcula ambos contra una mentira si supones un periodo constante.

El umbral v > 100. Sin él, cinco canales cada uno leyendo un pequeño valor de suelo arrastran la media ponderada hacia el centro sin importar dónde esté la línea. El síntoma es un robot que sigue bien una línea marcada y mal una tenue.

Mantener el último error al perder la línea. Cero significa «centrado», así que un robot que pone cero conduce recto a toda velocidad —lejos de la línea, que casi seguro estaba curvando. Mantener el último error lo mantiene girando hacia donde ya giraba.

Derivativa sobre la medida. Diferenciar el error hace que un cambio de consigna produzca un pico enorme. Aquí la consigna siempre es cero así que apenas importa, pero el hábito merece formarse.

Integración condicional. Una vez que la corrección satura, seguir acumulando integral solo guarda un sobreimpulso para devolver después.

Un orden de sintonía que funciona

No sintonices las tres a la vez. Pon KI = 0 y KD = 0, luego:

El paso 6 es el que la gente olvida: las ganancias dependen de la velocidad. Una sintonía perfecta a 140 de ciclo de trabajo oscilará a 220, porque la misma corrección de dirección ahora produce un cambio mayor en el rumbo por unidad de tiempo. Espera resintonizar siempre que cambies la velocidad de forma significativa.

La integral es genuinamente rara vez útil aquí. La consigna de un seguidor de línea es cero y las perturbaciones son transitorias, así que normalmente no hay desplazamiento en estado estacionario que KI deba cerrar. Si ves un desplazamiento persistente, sospecha trim desigual de motores o un sensor sin calibrar antes de recurrir a la ganancia integral.

La tasa del bucle limita todo en silencio

Un robot que decide cada 20 mm no puede seguir una curva con precisión sin importar cómo se fijen las ganancias, y ningún término derivativo recupera información que nunca se muestreó.

Los culpables habituales son fáciles de eliminar: un delay() en cualquier parte del bucle, Serial.print de más de unos pocos valores a 9600 baudios, y leer sensores que no usas. Eliminarlos suele llevar una primera construcción de 50 Hz a varios cientos, y el seguimiento mejora sin tocar una ganancia. Mide la tasa antes de sintonizar, no después.

Solución de problemas

Pruébalo tú mismo

En el simulador de seguidor de línea puedes dibujar una pista, cambiar el número de sensores y la velocidad, y sintonizar las ganancias mientras observas el error y el tiempo de vuelta. Todo lo que aprendas sobre el error ponderado y el lazo de dirección se traslada directo a un robot Arduino.