Encoders incrementales y absolutos

01 · Punto de partida

De la posición al número

En los temas anteriores un sensor entregaba una magnitud que había que interpretar. Un encoder entrega algo más cercano al software: un número que representa un ángulo, o una secuencia de pulsos que se cuentan. Es el sensor de posición y de velocidad de los motores, de las perillas de volumen, de los mouse con rueda, de las impresoras 3D y de los robots. Y en el taller del tema 26 y en el control del tema 31 es la fuente de la realimentación.

Dos ideas organizan el tema. La primera: incremental contra absoluto. Un encoder incremental es un contador que depende del programa: si se corta la luz o se pierde un pulso, la cuenta deja de coincidir con la realidad. Uno absoluto es una tabla que dice en qué ángulo está el eje, siempre. La segunda: la información está en el tiempo. Los pulsos de un incremental llegan a frecuencias que pueden saturar un microcontrolador, y por eso se usan interrupciones (tema 20 del curso de Microcontroladores) o contadores por hardware (tema 24 de ese curso).

02 · Clasificación

Tipos de encoders

Se clasifican por qué entregan y por cómo detectan el giro:

Y por el tipo de salida: incremental (dos canales A y B en cuadratura, a veces un tercer canal Z de índice) o absoluto (un código de posición en paralelo, en SPI/I2C/SSI o como un PWM o una tensión analógica). Un absoluto monovuelta sabe el ángulo dentro de una vuelta; uno multivuelta además cuenta las vueltas, con engranajes o con una pequeña memoria alimentada por batería.

03 · Dos señales desfasadas

Señales en cuadratura

Un encoder incremental tiene dos canales, A y B, con el mismo patrón de pulsos pero desfasados un cuarto de ciclo (90° eléctricos). Cada ciclo recorre cuatro estados; el orden indica el sentido:

Con un solo canal se cuentan pulsos pero no se sabe el sentido. Con dos, el programa mira cuál cambió y cuál era el estado previo: es una pequeña máquina de estados (tema 41). Si se mueve un paso a un estado vecino, la cuenta sube o baja una unidad; si no cambia nada, queda igual; si salta dos estados a la vez (por ejemplo de 01 a 10) se perdió un flanco y no hay forma de saber en qué sentido: es un error.

Muchos encoders agregan un canal Z (índice) que da un pulso por vuelta, en una posición fija del eje. Sirve de referencia para volver a «cero» después de encender: se gira hasta ver el índice y se pone la cuenta en cero (homing). Es la forma barata de darle a un incremental una referencia absoluta.

04 · Contar bien

Decodificación y resolución

Cada ciclo de A tiene cuatro cambios (A sube, B sube, A baja, B baja). Según cuántos se cuenten, hay tres modos:

• x1: un conteo por ciclo (por ejemplo, solo los flancos de subida de A). Resolución más gruesa.
• x2: ambos flancos de A. El doble.
• x4: todos los flancos de A y de B. El máximo, con cuatro cuentas por ciclo. Necesita monitorear los dos canales.

Dos siglas aparecen en las hojas de datos y se confunden: PPR (pulsos, o ciclos, por vuelta de un canal) y CPR (cuentas por vuelta tras decodificar, igual a 4 × PPR en modo x4). Una perilla de 20 PPR tiene 80 cuentas por vuelta y resuelve 360/80 = 4,5° por cuenta; un encoder óptico de 600 PPR da 2400 cuentas por vuelta, es decir 0,15° por cuenta.

El método más sencillo, y el más seguro, es una tabla de transiciones: con el estado previo (2 bits) y el actual (2 bits) se arma un índice de 4 bits que devuelve +1, −1 o 0. No hay lógica condicional ni dependencia del orden en que se atiendan los canales.

const uint8_t PIN_A = 2, PIN_B = 3;                 // ambos con interrupción (tema 20 de Microcontroladores)
const int8_t TABLA[16] = {  0, +1, -1,  0,
                           -1,  0,  0, +1,
                           +1,  0,  0, -1,
                            0, -1, +1,  0 };           // índice = (anterior << 2) | actual

volatile int32_t posicion = 0;
volatile uint8_t anterior = 0;

void isrEncoder() {
    uint8_t actual = (digitalRead(PIN_A) << 1) | digitalRead(PIN_B);
    posicion += TABLA[(anterior << 2) | actual];
    anterior = actual;
}

int32_t leerPosicion() {                              // lectura atómica de 32 bits (tema 21 de Microcontroladores)
    noInterrupts();
    int32_t p = posicion;
    interrupts();
    return p;
}

void setup() {
    pinMode(PIN_A, INPUT_PULLUP); pinMode(PIN_B, INPUT_PULLUP);
    attachInterrupt(digitalPinToInterrupt(PIN_A), isrEncoder, CHANGE);
    attachInterrupt(digitalPinToInterrupt(PIN_B), isrEncoder, CHANGE);
}

La tabla también absorbe el rebote de los encoders mecánicos: si un contacto rebota entre dos estados vecinos, cada ida suma +1 y cada vuelta resta 1, y el total queda correcto. Solo falla si el programa pierde algún flanco por llegar tarde a la interrupción. Por eso en un encoder mecánico se agrega un filtro RC de hardware o un antirrebote por software (tema 6) y, en uno óptico rápido, se usa un contador de hardware.

Frecuencia máxima y carga de procesador

Un encoder de 600 PPR (2400 cuentas por vuelta) que gira a 6000 RPM produce 6000/60 × 2400 = 240 000 cuentas por segundo. Si cada interrupción cuesta unos 4 µs, solo el encoder consume ~96 % del procesador de un AVR. Dos soluciones: x1 o x2 si la resolución sobra, o un periférico de hardware (el modo encoder de un timer de STM32, el PCNT del ESP32, el contador de un Raspberry Pi Pico) que cuenta sin intervención del programa y el CPU solo lee el registro cada tanto.

05 · La derivada de la posición

Medir la velocidad

La velocidad es la variación de la posición en el tiempo, y hay dos formas de obtenerla:

• Método de conteo (M): se cuentan los pulsos en una ventana fija T. RPM = (cuentas / CPR) / T × 60. Un conteo de diferencia equivale a 60 / (CPR × T) RPM. Con 2400 CPR y T = 10 ms, un conteo vale 2,5 RPM; con T = 100 ms, 0,25 RPM. Es simple y preciso a alta velocidad; a baja velocidad hay pocas cuentas por ventana y la lectura salta de escalón en escalón.
• Método de período (T): se mide con un timer el tiempo entre dos cuentas consecutivas. RPM = 60 / (CPR × período). Es muy preciso a baja velocidad (el período es largo y el timer lo mide con muchos «ticks»), pero a alta velocidad el período es de pocos microsegundos y el error de cuantización crece.

Una combinación habitual: usar el período cuando hay pocas cuentas en la ventana y el conteo cuando hay muchas. En un control con realimentación (tema 31 y tema 43), una ventana fija de 10 a 50 ms (que coincida con el lazo de control) y un pequeño filtro de promedio (tema 5) suelen alcanzar. Aumentar la ventana mejora la resolución pero agrega retardo: es el mismo compromiso entre ruido y velocidad del filtrado.

const uint16_t CPR = 2400;                           // 600 PPR en modo x4
const uint16_t T_VENTANA = 20;                       // ms, igual al período del lazo de control

int32_t posicionPrevia = 0;
uint32_t tPrevio = 0;
float rpm = 0;

void loop() {
    uint32_t ahora = millis();
    if (ahora - tPrevio >= T_VENTANA) {
        int32_t p = leerPosicion();
        int32_t delta = p - posicionPrevia;           // con signo: el sentido sale solo
        rpm = (delta / (float)CPR) / ((ahora - tPrevio) / 1000.0) * 60.0;
        posicionPrevia = p;
        tPrevio = ahora;
    }
}

06 · La posición completa

Encoders absolutos y código Gray

Un encoder absoluto tiene un disco con varias pistas concéntricas, una por bit, y un sensor por pista. Cada posición angular produce un código distinto. Con n pistas hay 2ⁿ posiciones y la resolución es 360° / 2ⁿ: 10 bits dan 0,352° y 12 bits, 0,088°.

Si las pistas siguieran el binario natural habría un problema: entre el código 7 (0111) y el 8 (1000) cambian cuatro bits al mismo tiempo, y como los sensores nunca conmutan exactamente a la vez, durante un instante se puede leer cualquier combinación, por ejemplo 1111 (15) o 0000 (0). En un encoder de 12 bits, el cambio de 2047 a 2048 cambia los 12 bits y la lectura podría saltar a 0 o a 4095: un error de media vuelta (casi 180°) por un instante. Es un error imposible de filtrar con un promedio simple.

La solución es el código Gray, en el que entre dos posiciones consecutivas cambia un solo bit. Así, aunque la lectura se produzca en medio de una transición, el resultado es el valor anterior o el siguiente: el error máximo es una cuenta. La conversión es muy corta:

Entre 7 y 8, el Gray pasa de 0100 a 1100: cambia solo el primer bit. Los encoders absolutos paralelos entregan Gray; los que usan buses digitales (SSI, SPI, I2C) lo convierten internamente y entregan binario. Los encoders absolutos magnéticos de un solo chip, como el AS5600 (12 bits, I2C o PWM, con un imán diametral sobre el eje) o el AS5048, cuestan pocos dólares y reemplazan un potenciómetro rotativo sin desgaste. Se leen como cualquier dispositivo I2C (tema 33 de Microcontroladores) y entregan ángulo = valor × 360 / 4096.

En las aplicaciones con más de una vuelta, un absoluto monovuelta no alcanza: al pasar de 359° a 0° no sabe si dio una vuelta. Se agrega un contador de vueltas en el programa (detectando el salto entre 4095 y 0), un segundo sensor con engranaje reductor, o un encoder multivuelta con batería. Y al apagar el equipo, un incremental pierde la posición y un absoluto no.

07 · Elegir

Comparación y elección

Regla práctica: incremental para velocidad y posición relativa en motores (con un tope o un índice Z para el cero); absoluto cuando el equipo debe saber dónde está al arrancar o la posición no puede perderse (brazos robóticos, timones, válvulas); mecánico para perillas de usuario; magnético cuando hay polvo, aceite o vibración.

08 · Analogía con programación

El decodificador, el conteo de velocidad y el código Gray

Probemos las tres ideas. Primero, un decodificador en cuadratura con tabla: dos vueltas hacia un lado, una vuelta de regreso, y qué hace con un rebote y con un estado perdido. Segundo, la resolución de velocidad por conteo en una ventana. Tercero, la conversión Gray y la cantidad de bits que cambian en una transición.

# Decodificación en cuadratura x4 con tabla de transiciones
TABLA = [0, +1, -1, 0,
         -1, 0, 0, +1,
         +1, 0, 0, -1,
         0, -1, +1, 0]          # índice = (anterior << 2) | actual, con actual = (A << 1) | B


class Decodificador:
    def __init__(self):
        self.anterior = 0
        self.posicion = 0
        self.errores = 0

    def muestra(self, a, b):
        actual = (a << 1) | b
        paso = TABLA[(self.anterior << 2) | actual]
        if actual != self.anterior and paso == 0:
            self.errores += 1          # salto de dos estados: se perdió un flanco
        self.posicion += paso
        self.anterior = actual


CW = [(0, 1), (1, 1), (1, 0), (0, 0)]  # un ciclo (cuatro estados) con A adelantada
PPR = 20

d = Decodificador()
for _ in range(2 * PPR):
    for a, b in CW:
        d.muestra(a, b)
print(f"2 vueltas en sentido horario: posición = {d.posicion} cuentas")
for _ in range(PPR):
    for a, b in reversed(CW):
        d.muestra(a, b)
print(f"1 vuelta en sentido contrario: posición = {d.posicion} cuentas = {d.posicion / (4 * PPR) * 360:.1f}°")
print(f"resolución: {360 / (4 * PPR):.2f}° por cuenta")

r = Decodificador()
for a, b in [(0, 1), (0, 0), (0, 1), (1, 1)]:   # rebote en un flanco
    r.muestra(a, b)
print(f"con rebote: posición = {r.posicion} (los pasos de ida y vuelta se cancelan)")
s = Decodificador()
for a, b in [(0, 1), (1, 0)]:                      # se pierde un estado
    s.muestra(a, b)
print(f"con salto: posición = {s.posicion}, errores detectados = {s.errores}")

# Velocidad por conteo en una ventana
cpr = 600 * 4
print()
print("RPM  ventana  cuentas  RPM medida  resolución")
for rpm in (3, 30, 1200):
    for ventana in (0.01, 0.1):
        n = int(rpm / 60 * cpr * ventana)
        print(f"{rpm:4d}  {ventana * 1000:5.0f} ms  {n:6d}  {n / cpr / ventana * 60:9.2f}  {60 / (cpr * ventana):8.2f} RPM")
print(f"Frecuencia de cuentas a 6000 RPM: {6000 / 60 * cpr / 1000:.0f} kHz")


# Código Gray
def gray(n):
    return n ^ (n >> 1)


def binario(g):
    n = 0
    while g:
        n ^= g
        g >>= 1
    return n


print()
print("n  binario  Gray")
for n in range(6, 10):
    print(f"{n}  {n:04b}    {gray(n):04b}")
bits_binario = bin(0b0111 ^ 0b1000).count("1")
bits_gray = bin(gray(7) ^ gray(8)).count("1")
print(f"Entre 7 y 8 cambian {bits_binario} bits en binario y {bits_gray} en Gray")
print(f"Gray 1100 -> {binario(0b1100)}; resolución de 12 bits: {360 / 2 ** 12:.3f}°")

Resultado: dos vueltas de una perilla de 20 PPR suman 160 cuentas; una vuelta de regreso las deja en 80 (360,0°), con una resolución de 4,50° por cuenta. El rebote (ida y vuelta entre dos estados) termina en +2, la cuenta correcta; el salto de dos estados (01 → 10) suma una sola cuenta y se detecta como 1 error. En velocidad, con 2400 CPR una ventana de 10 ms resuelve 2,5 RPM por cuenta: a 3 RPM se obtiene una cuenta (2,50 RPM, un error del 17 %), a 30 RPM 12 cuentas y a 1200 RPM 480. Con una ventana de 100 ms el escalón baja a 0,25 RPM (a 3 RPM, 12 cuentas = 3,00 RPM). A 6000 RPM llegan 240 kHz de cuentas. Entre 7 y 8 cambian 4 bits en binario y 1 en Gray; Gray 1100 es 8; con 12 bits la resolución es 0,088°.

09 · Exploración interactiva

Cuadratura, velocidad y encoder absoluto

El primer instrumento gira el eje y muestra los estados de A y B, la cuenta en cada modo (x1, x2, x4) y el sentido. El segundo mide la velocidad por conteo y por período, y calcula la carga que generan las interrupciones. El tercero muestra el código binario y Gray de un encoder absoluto y el peor error posible si se lee justo durante una transición. Los parámetros (4 µs por interrupción, un timer de 1 µs) son ilustrativos.

Recorrido guiado

1. Con 20 PPR y el ángulo en 0°, el eje está en el estado 00. Subí el ángulo de a 1° o con las flechas del teclado: A y B recorren 00 → 01 → 11 → 10 y la cuenta x4 sube cada 4,5°.
2. Bajá el ángulo: el sentido pasa a «antihorario» y la cuenta decrece. Con un solo canal no se podría distinguir.
3. Pasá a 600 PPR: la resolución x4 es de 0,15°. La cuenta es 30 veces más fina para el mismo giro.
4. En el instrumento 2, 120 RPM con 600 PPR y 10 ms: son 4800 cuentas/s y 48 por ventana; el escalón de 2,5 RPM es el 2 % de la lectura.
5. Bajá la velocidad a 3 RPM: el conteo en 10 ms da 1 cuenta (2,5 RPM, un 17 % de error) mientras el método de período sigue exacto. Pasá a 100 ms y el conteo mejora, pero la lectura llega más tarde.
6. Subí a 6000 RPM con 600 PPR: 240 000 cuentas/s y la carga de interrupciones llega a casi el 96 %. Con 1024 PPR supera el 100 %: el procesador no alcanza y se pierden pasos. Hace falta un contador de hardware o un modo x1.
7. En el instrumento 3, con 12 bits y 90°, el código es 1024. Poné 179,9° para ver el código 2047, cuyo siguiente (2048) cambia los 12 bits: en binario la peor lectura puede estar a 180° de distancia, en Gray a una cuenta.

10 · Método de trabajo

Cómo integrar un encoder

1. Definí qué necesitás: posición relativa, velocidad, posición absoluta o una perilla de usuario.
2. Calculá CPR y la frecuencia máxima de cuentas con la velocidad más alta del eje (incluida la reducción), y compará con lo que tolera tu procesador.
3. Elegí cómo contar: interrupciones para frecuencias moderadas; contador por hardware o x1/x2 para las altas.
4. Conectá con pull-up (los de colector abierto lo necesitan) y filtrá el rebote en los mecánicos.
5. Leé la posición de forma atómica si es mayor que el ancho del procesador (tema 21 de Microcontroladores).
6. Elegí el método de velocidad según el rango de RPM y la ventana del lazo de control.
7. Definí el cero: con el índice Z, con un tope mecánico o con un absoluto.
8. Verificá con una referencia: girá una vuelta exacta y comprobá que la cuenta sea CPR; invertí A y B si el sentido está al revés.

Si la cuenta se desvía con el tiempo, buscá pasos perdidos (frecuencia demasiado alta, interrupciones deshabilitadas mucho tiempo, ruido en los cables sin blindaje); si va al revés, intercambiá A y B; si la velocidad está «escalonada» a baja velocidad, alargá la ventana o pasá al método de período.

11 · Comprensión

Confusiones frecuentes

12 · Práctica guiada

Predecí antes de comprobar

1. Resolución de una perilla

Una perilla de 20 PPR se decodifica en modo x4. ¿Cuántas cuentas hay por vuelta y qué ángulo representa cada una?

2. Velocidad por conteo

Un encoder de 600 PPR (x4) gira a 1200 RPM y se cuenta en ventanas de 10 ms. ¿Cuántas cuentas hay por ventana y cuánto vale un escalón de RPM?

3. Baja velocidad

El mismo encoder gira a 3 RPM. ¿Cuántas cuentas hay en 10 ms y en 100 ms? ¿Qué período hay entre cuentas?

4. Código Gray

Convertí el número 5 a Gray de 4 bits y el Gray 1100 a binario.

5. Encoder magnético

Un AS5600 de 12 bits lee 1024 en un eje. ¿Qué ángulo es y qué resolución tiene el sensor?

6. Elegir el encoder

Elegí tipo para: (a) la perilla de volumen de un equipo; (b) la velocidad de un motor de corriente continua; (c) el ángulo de un timón que no puede perder la referencia al apagar; (d) un brazo que debe poder arrancar en cualquier posición.

13 · Síntesis

Ideas para recordar

¿Listo para el tema 26?

Antes de avanzar, calculá las cuentas por segundo de un encoder de 1024 PPR en modo x4 a 3000 RPM, explicá qué ocurre con una ventana de 10 ms cuando el eje gira muy lento y decí por qué un absoluto de 12 bits en binario puro podría dar una lectura de 0 cuando el eje pasa por 2047. Si podés justificar las tres respuestas, ya sabés trabajar con encoders.

En el próximo tema construimos el taller de velocidad y posición con un encoder: decodificación por interrupciones, RPM y conteo de vueltas en un montaje completo.