Documentación

Tres capas: base, Escudo y módulos

Open Lambda Core es un robot seguidor de línea para la categoría Robotrace. La placa base es chasis y circuito en una sola pieza. Sobre ella va el Escudo Core, que ocupa el zócalo 2×15 del Arduino Nano y lo reemplaza por un ESP32-S3. En el Escudo van los módulos: el ESP32-S3, el multiplexor, los reguladores, la IMU y el sensor de distancia.

Ficha técnica

Microcontrolador

ESP32-S3, en un módulo LOLIN S3 Mini

Conexión

USB y WiFi de 2,4 GHz

Sensores de línea

6 reflectivos, a 9,5 mm uno del otro

Sensores de marca

2, uno por lado

IMU

MPU6050, giroscopio y acelerómetro

Distancia

VL53L0X (ToF), mirando al frente

Motores

2 × N20 HP de 6 V, con encoder en cuadratura

Driver de motores

TB6612FNG

Ruedas

Ø 32 mm · 100,53 mm por vuelta

Batería

LiPo 2S · 7,4 V · 300 mAh · JST XH

Reguladores

4 en el Escudo: 2 de 5 V y 2 de 3,3 V

Señales

LED RGB, buzzer y botón

Placa base

88 × 100 mm

Escudo Core

61 × 96 mm

El arreglo de línea trae ocho sensores, de los que el robot usa seis. Un multiplexor 74HC4051 lleva esos seis y los dos de marca a una sola entrada analógica del ESP32-S3.

El Escudo trae montado un radar RD-03E de 24 GHz. El firmware actual no lo usa.

Sin el Escudo, la placa base funciona con un Arduino Nano en el mismo zócalo y con su propio firmware: sigue la línea, pero sin encoders, IMU, sensor de distancia ni WiFi. La plataforma y la biblioteca de esta documentación son para el Escudo.

Pines del Escudo

La asignación de los GPIO del ESP32-S3 en el Escudo Core.

Canales del multiplexor

El firmware no sabe de antemano qué extremo de la fila queda a la izquierda ni cuál sensor de marca es el izquierdo. Eso se fija una vez en la puesta a punto, sin recompilar.

Zócalo de la placa base

El Escudo se enchufa en el zócalo 2×15 del Arduino Nano y recibe por ahí las señales de la base.

Driver de motores

El TB6612FNG recibe tres señales por motor: una de potencia (PWM) y dos de sentido.

Energía y conectores

El robot se alimenta con una batería LiPo de dos celdas (2S): 7,4 V nominales y hasta 8,4 V recién cargada. Se carga con un cargador para 2S.

Los motores son de 6 V y reciben el voltaje de la batería. Por eso el firmware limita la potencia que les entrega: el tope viene en 75 %.

El Escudo tiene cuatro reguladores: dos de 5 V, que bajan el voltaje de la batería, y dos de 3,3 V, que se alimentan de esos 5 V.

Puesta en marcha

La plataforma es una sola página que se abre en el navegador. Conecta el robot por USB, le instala el firmware base, lo deja en tu red WiFi y muestra sus sensores en vivo.

Qué necesitas

• Un computador con Chrome o Edge, que son los navegadores que pide la plataforma: la conexión por USB usa Web Serial.
• Un cable USB de datos. Los que son solo de carga no sirven.
• Una red WiFi de 2,4 GHz, con el computador en la misma red que el robot.
• Conexión a internet para instalar o actualizar el firmware base y para usar la IA del chat.

Descargar la plataforma

Los tres pasos

1. Conectar

   Enchufa el robot por USB y pulsa Conectar. Si el robot es nuevo, la página le instala el firmware base, versión 3.2.1. Después elige tu red, escribe la clave y pulsa Guardar red. Cuando la página pase sola al paso Revisar, el robot ya está en el WiFi y puedes desenchufar el cable.

2. Revisar

   Mueve el robot con la mano y mira que los datos cambien: las seis barras de línea, las dos marcas, el rumbo y la distancia. Aquí también se calibran los sensores y se prueban los motores a mano.

3. Conocer

   Las piezas del robot, una por una, cada una con su ficha: cómo se conecta, qué hace, cómo se usa y qué suele fallar. Al lado hay un chat para preguntar y pedir programas; la IA del chat se configura en Ajustes.

Puesta a punto

Los pasos 1 a 5 se hacen una vez por robot y quedan guardados dentro del robot al pulsar Guardar en el robot, al final de la hoja. La calibración del paso 6 no se guarda: se repite cada vez que se enciende el robot o se cambia de pista. Los pasos 2 y 6 mueven las ruedas de verdad; en los demás lo mueves tú. Sujétalo o déjalo en el suelo según lo que pida cada uno.

1. Qué extremo de la fila es la izquierda

   Tapas con el dedo el sensor del extremo izquierdo y miras cuál barra se mueve.

2. Para dónde gira cada motor

   Con el robot levantado, cada botón mueve una sola rueda.

3. Para dónde cuentan los encoders

   Empujas el robot hacia adelante; las dos cuentas tienen que subir.

4. Cuál sensor de marca es el izquierdo

   Pasas algo blanco por el costado izquierdo del robot.

5. Cuántas cuentas da una vuelta de rueda

   Empujas el robot derecho una distancia medida con huincha y la escribes; la página calcula el número.

6. Calibrar los sensores

   Tres segundos, con la línea blanca y el negro pasando bajo los sensores.

Si algo sale al revés se corrige con un botón; no hay que reinstalar nada. Mientras no se haga el paso 5, los milímetros y la velocidad que informa el robot son aproximados.

El LED de estado

Desde que un programa llama a led(), el LED pasa a ser del programa.

Si algo falla

• El computador no ve el robot. El cable puede ser solo de carga: prueba con uno de datos.
• No se pudo instalar el firmware. Mantén BOOT, toca RST, suelta BOOT y pulsa Conectar de nuevo.
• Conectar reconoce el robot pero no muestra las redes. El robot trae un firmware más nuevo que el 3.2.1 de la página, y la página no lo toca.
• El robot no entra a la red. Revisa la clave y que la red sea de 2,4 GHz.
• No se llega al robot por WiFi. Revisa que el computador esté en la misma red.

Programar

El robot se programa como un sketch de Arduino en C++: se incluye OpenLambda.h y se escriben setup() y loop().

#include <OpenLambda.h>

void setup() {
  Robot.begin();
  Chat.println("Robot listo. Ponme sobre la linea y pulsa Correr.");
  Robot.waitForStart();
  calibrate(3000);               // gira sobre sí mismo: que la línea le pase por debajo
  beep(900, 100);
}

void loop() {
  int v[6];
  line(v);
  long suma = 0, peso = 0;
  for (int i = 0; i < 6; i++) { suma += v[i]; peso += (long)i * v[i]; }

  if (suma > 200) {
    float pos = (float)peso * 1000 / suma;   // 0 = izquierda, 5000 = derecha
    float error = pos - 2500;
    motors(40 + error * 0.08, 40 - error * 0.08);
  }
  delay(2);
}

Este programa no mueve nada hasta que pulsas Correr en la plataforma o el botón del robot. Entonces calibra tres segundos girando sobre sí mismo, pita y sigue la línea.

Inicio

Sensores

Motores, señales y ajustes

Chat

Todas las funciones sueltas existen también como métodos de Robot: Robot.motors(40, 40) hace lo mismo que motors(40, 40). Robot.println(texto) también escribe en el chat, pero solo acepta texto. No existe battery(): el robot no mide su batería.

Enviar el programa al robot

En la plataforma, pulsa Editor de código: se abre la hoja Mi programa. Escribe el programa o pídeselo a la IA y, con el robot conectado por WiFi, pulsa Compilar y enviar. La página lo manda al servicio de compilación configurado en Ajustes, recibe el firmware compilado y lo carga en el robot por WiFi. La primera compilación es la más lenta y puede tardar un minuto; las siguientes, unos segundos.

Reglamento Robotrace

Robotrace es una competencia en la que un robot autónomo recorre un circuito de línea blanca y compite en velocidad e inteligencia. El reglamento de referencia es «Rules for Robotrace», de la New Technology Foundation de Japón, en su versión del 1 de junio de 2024. Esto es un resumen: el número entre paréntesis es la regla.

El robot

• Es autónomo: salvo la operación de partida, no se lo controla desde afuera, ni por cable ni de forma inalámbrica (1-1).
• No se le agrega, quita ni cambia hardware o software durante la competencia; solo reparaciones menores (1-2).
• Su proyección sobre el piso cabe en un círculo de 25 cm de diámetro y no pasa de 20 cm de alto (1-3).
• No puede agregar fuerza adhesiva excesiva a las ruedas ni a otras partes para aumentar el contacto con el piso (1-4).

La pista

• Superficie negra y línea blanca de 1,9 cm de ancho; el recorrido mide hasta 60 m (2-1).
• Solo rectas y arcos. El radio mínimo es de 10 cm y entre dos cambios de curvatura hay 10 cm o más (2-2, 2-3).
• La línea puede cruzarse a sí misma, a 90° ± 5°, con 10 cm de recta antes y después del cruce (2-2, 2-4).
• Partida y meta van en una recta, con la meta 1 m detrás de la partida; sus marcas van a la derecha de la línea (2-5).
• Cada cambio de curvatura lleva una marca a la izquierda de la línea, en el sentido de carrera (2-8).
• El borde de la pista queda al menos a 20 cm del centro de la línea (2-10).

La corrida

• Cada competidor tiene 3 minutos y un máximo de 5 corridas; su tiempo oficial es la vuelta más rápida (3-2, 3-5).
• La proyección del robot tiene que cubrir la línea durante toda la corrida. Si la suelta por completo, o se detiene más de 2 segundos, el intento es fallido (3-1, 3-7).
• Al terminar, el robot se detiene solo dentro del área de partida y meta, y se queda quieto al menos 2 segundos. Si no queda entero dentro del área, el tiempo no se registra (3-4, 3-6).
• Con el trazado ya a la vista no se le entrega información de la pista al robot (3-8), ni se le cargan programas durante la competencia (atención 1).

En el robot

Open Lambda Core lee esas marcas con sus dos sensores laterales: mark_right() ve la partida y la meta, y mark_left(), los cambios de curvatura.

Japón y Chile

El All Chile Robot Contest publica su propio reglamento para la categoría, que cambia algunas medidas.

Archivos