N20 Micro Gearmotor with Encoder

Qué es

El N20 es el pequeño motor de reductor metálico que aparece siempre que un robot necesita par real en muy poco espacio. El motor desnudo tiene aproximadamente el tamaño de una pila AA; el reductor de la parte delantera cambia su velocidad tan alta por un par utilizable, y en la versión con encoder, un disco magnético en el eje trasero informa de cuánto ha girado.

Esa última parte es lo que le gana un sitio en un robot equilibrador. Sin realimentación de ruedas, un robot equilibrador puede mantenerse erguido pero no tiene ni idea de dónde está: aguantará la vertical con una belleza glasificada mientras recorre la habitación. El encoder cierra ese hueco.

Por qué aquí importa el reductor metálico

Un motor de reductor plástico como el motorreductor TT es perfectamente bueno para un seguidor de línea, que sobre todo avanza recto. Un robot equilibrador es otra carga: invierte la dirección continuamente, cientos de veces por segundo, en incrementos pequeños.

Todo reductor tiene holgura: una zona muerta pequeña donde los engranajes se han desenganchado y la salida no se mueve hasta que los dientes se encuentran otra vez al otro lado. En un reductor de plástico esa zona muerta es grande, y en un robot equilibrador cae exactamente donde más importa la corrección: en el momento de la inversión, cuando el robot necesita que las ruedas respondan ahora. El resultado es un robot que oscila alrededor de la vertical y nunca llega a asentarse, por muy bien que se ajusten las ganancias.

Los engranajes metálicos no eliminan la holgura, pero la reducen lo bastante como para que el lazo pueda hacer su trabajo. Cuánta queda es un número que puedes medir en unos diez minutos; aquí está cómo.

Leer el encoder

El encoder produce dos ondas cuadradas desfasadas 90°: la cuadratura estándar. La relación de fase te dice la dirección; contar flancos te dice la distancia.

Los colores de los cables varían entre proveedores, así que consulta la ficha del producto en lugar de suponerlo. El que despista a la gente es alimentar el encoder desde el riel de motores: el encoder quiere una alimentación lógica limpia, y darle la tensión del motor o lo destruye o llena tus cuentas de ruido cada vez que el motor conmute.

Pon el canal A en un pin que pueda lanzar una interrupción. Sondear un encoder desde loop() en un robot equilibrador perderá cuentas, y las cuentas perdidas significan que el lazo exterior pierde poco a poco la noción de dónde está el robot.

Cómo elegir una relación

La relación de engranajes fija el intercambio entre par y velocidad, y un robot equilibrador necesita de las dos:

• Relación demasiado alta (1:250 en adelante) da par de sobra, pero las ruedas no aceleran lo bastante rápido para recuperar un cuerpo que se está cayendo.
• Relación demasiado baja (1:30 o menos) gira rápido, pero no mueve la masa del robot con autoridad.

Alrededor de 1:100 a 12 V, unos 200 RPM, es un punto de partida fiable para un robot pequeño. Si el tuyo se recupera de pequeñas perturbaciones pero pierde de las grandes, probablemente necesitas más velocidad, no más ganancia.

Cómo manejarlo

Empareja el N20 con un TB6612FNG en lugar de un L298N. El motivo es la caída de tensión: el L298N pierde unos 2 V en su etapa de salida, así que buena parte de tu batería nunca llega al motor, y las órdenes de corrección pequeñas quedan por debajo de la tensión a la que el motor se mueve siquiera. En un robot equilibrador esa zona muerta cae justo donde viven las correcciones finas.

Aliméntalo desde un paquete de baterías que pueda suministrar la corriente de bloqueo de los dos motores a la vez sin que su tensión se desplome: un riel que se desploma reinicia el microcontrolador a mitad de una corrección, y el robot se cae por motivos que no tienen nada que ver con tu lazo de control.

Calcular las cuentas por vuelta de rueda

Este es el número del que depende todo cálculo de distancia, y es el que la gente se equivoca más a menudo, normalmente por un factor de cuatro.

counts per wheel revolution = PPR x 4 x gear ratio

El encoder magnético da 7 pulsos por vuelta de motor en cada canal. Cuadratura significa dos canales desfasados 90°, lo que produce cuatro flancos contables por ciclo de pulso. Y el reductor significa que el motor gira muchas veces por cada vuelta de rueda.

Después la distancia sale directamente:

mm per count = (pi x wheel_diameter_mm) / counts_per_revolution

Hay dos trampas en esa primera fórmula. El ×4 solo es correcto si cuentas de verdad cuatro flancos, los dos flancos en los dos canales. Mucho código de ejemplo cuenta solo flancos de subida en el canal A, que es ×1, y usar una constante ×4 con un recuento ×1 deja todas las distancias fuera por exactamente cuatro. Y la relación impresa en el motor suele ser aproximada: un N20 «1:100» es con frecuencia 1:99,5 o 1:100,37. Para odometría a cualquier distancia, calibra empíricamente: empuja el robot exactamente 2 m y divide.

Contar los flancos sin perder ninguno

A 200 RPM a través de un reductor 1:100, el eje del motor gira a 20000 RPM, lo que da 20000/60 × 7 × 4 ≈ 9300 flancos por segundo y motor. Dos motores son casi 19000 interrupciones por segundo, y eso es a plena velocidad y sin carga.

El manejador de interrupción tiene que ser realmente pequeño:

volatile long countL = 0;

// Full x4 decoding, table-driven. Both channels, both edges.
const int8_t QUAD_TABLE[16] = {0,-1,1,0, 1,0,0,-1, -1,0,0,1, 0,1,-1,0};
volatile uint8_t prevL = 0;

void isrLeft() {
  uint8_t now = (digitalRead(ENC_L_A) << 1) | digitalRead(ENC_L_B);
  countL += QUAD_TABLE[(prevL << 2) | now];
  prevL = now;
}

void setup() {
  pinMode(ENC_L_A, INPUT_PULLUP);
  pinMode(ENC_L_B, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(ENC_L_A), isrLeft, CHANGE);
  attachInterrupt(digitalPinToInterrupt(ENC_L_B), isrLeft, CHANGE);
}

long readCount() {           // long is not atomic on an 8-bit AVR
  noInterrupts();
  long v = countL;
  interrupts();
  return v;
}

Tres detalles que importan:

volatile, y una lectura atómica. Un long son cuatro bytes en un AVR, y se lee de un byte en otro. Una interrupción que cae en mitad de la lectura te da un valor medio viejo y medio nuevo, lo que produce un salto puntual enorme en tu odometría, al azar, más o menos una vez cada pocos miles de lecturas.

La tabla de consulta decodifica la transición en lugar de adivinar la dirección a partir de un solo canal. También rechaza de forma natural las transiciones inválidas (ambos bits cambian a la vez, lo que significa que te saltaste una) contribuyendo cero.

Presión de pines. La decodificación ×4 completa en dos motores necesita cuatro pines capaces de interrupción, y un Arduino Uno tiene exactamente dos. Las opciones son: usar decodificación ×2 (un canal por motor, CHANGE), que reduce la resolución a la mitad y aun así da dirección; cambiar a una placa con más pines de interrupción, como un Mega o un ESP32; o usar interrupciones de cambio de pin, que admite cualquier pin del AVR pero que exigen atender un puerto entero a la vez.

Velocidad a partir de las cuentas

La posición es una cuenta. La velocidad necesita una diferencia en el tiempo, y cómo la tomes decide si tu lazo de control es utilizable.

long lastCount = 0;
unsigned long lastMicros = 0;

float speedMmPerSec() {
  long   c  = readCount();
  unsigned long t = micros();

  float dt = (t - lastMicros) * 1e-6f;
  if (dt < 0.005f) return lastSpeed;        // too short: quantisation dominates

  float mm = (c - lastCount) * MM_PER_COUNT;
  lastCount = c; lastMicros = t;

  lastSpeed = mm / dt;
  return lastSpeed;
}

La guarda de dt es la línea importante. Si muestras demasiado rápido estás dividiendo una diferencia de una o dos cuentas por un intervalo diminuto, así que el error de cuantización domina y la «velocidad» es sobre todo ruido, que un término derivativo de un lazo PID se encargará después de amplificar con entusiasmo.

Hay dos formas honestas de medir la velocidad con un encoder, y sirven para extremos distintos del rango. Contar flancos en una ventana fija (el código de arriba) es bueno a alta velocidad y malo a baja, donde llegan pocos flancos por ventana. Cronometrar el intervalo entre flancos es lo contrario: excelente a baja velocidad, ruidoso a alta. Un robot que necesita los dos extremos suele cambiar entre ellos en un umbral.

Resolución de problemas

¿N20 o motorreductor TT?

El factor decisivo rara vez es el par y casi siempre es la holgura y la realimentación. Un seguidor de línea avanza sobre todo hacia delante y corrige con un sensor que mira al suelo: nunca nota el juego del reductor, y un motor TT es la respuesta correcta y barata. Un robot equilibrador invierte la dirección cientos de veces por segundo en incrementos diminutos, así que la zona muerta en cada inversión es exactamente donde su corrección necesita actuar, y los engranajes de plástico hacen el lazo inestable por mucho que se ajuste.

La misma lógica se aplica a un resolutor de laberinto: navega contando distancia, así que el movimiento perdido en cada giro se acumula directamente en error de posición.

Dónde se usa

• Robot autoequilibrado: los motores de tracción, con los encoders alimentando el lazo exterior de posición