Decodificación de múltiples codificadores rotatorios de cuadratura

La clave es cómo funciona una codificación en cuadratura: dos señales están desfasadas, por lo que puede detectar la dirección en la que la señal sigue a la otra. Combinados, tienen 4 estados por los que pasan, pero lo harán en orden opuesto para la dirección opuesta. Es decir, 00-01-11-10- para la derecha, 00-10-11-01- para la izquierda. Como puede ver, pasarán los estados 01 y 10 que está buscando, y la única forma de saber de qué manera es comprobando el estado anterior o el siguiente.

Dado que puede garantizar que solo gire un codificador en cualquier momento, la escala del decodificador en cuadratura no es realmente un problema. Puede comenzar por encontrar dónde cambió el puerto y luego decodificar solo esa transición.

De lo contrario, tenemos el interesante desafío de encontrar un algoritmo paralelo para la decodificación en cuadratura aplicable a los microprocesadores. Una operación fundamentalmente paralela que tienen la mayoría de ellos son las operaciones bit a bit en registros más amplios. Comencemos por encontrar cada canal en el que se haya producido un cambio, dada la disposición de puertos a1b1a2b2, etc., es decir, cada grupo de 2 bits pertenece a un canal.

Si hacemos ((value&0xaa)>>1)^(value&0x55)) obtenemos un valor de paridad. Luego, esto se puede comparar con el valor de paridad anterior, y listo, tenemos una señal de paso. Luego viene la dirección.

Configuremos un mapa de Karnaugh, usando las entradas a, b, a' y b' (donde ' significa antes):

phase diagram ___/"""\___/"""  a
              _/"""\___/"""\_  b
             a=0     a=1
           b=0 b=1 b=1 b=0   1 means right, 0 means left, x don't care
a'=0 b'=0   x   1   x   0
a'=0 b'=1   0   x   1   x
a'=1 b'=1   x   0   x   1
a'=1 b'=0   1   x   0   x

Tenemos un patrón diagonal, que tiende a ocurrir con funciones xor. También tenemos un margen de valores que no deben contarse (lo que significa que no hay ningún paso o que se ha perdido un paso). Ya encontramos la función de paso para eliminarlos. En esencia, todo lo que necesitamos es encontrar la diagonal con ceros, para que podamos invertir el paso para obtener la dirección. Parece que la discriminación restante se puede hacer con b^a':

  b^a'       a=0     a=1
           b=0 b=1 b=1 b=0
a'=0 b'=0   0   1   1   0
a'=0 b'=1   0   1   1   0
a'=1 b'=1   1   0   0   1
a'=1 b'=0   1   0   0   1

Entonces, dado que necesitamos a'^b' para el paso y a' para la dirección, podemos guardar esos dos bits del paso anterior. Nuestras funciones son step=a'^b'^a^b, dir=step&(b^a').

old_a_axb = ((oldpin&0xaa)>>1) ^ oldpin
# This has a serious bug, in that the ROL step actually used B from
# the next channel over. Let's fix it. 
#b_axb = ROL(pin)^(pin&0x55)
b_axb = ((pin&0xaa)>>1)^(pin&0x55)|((pin&0x55)<<1)
dir_step = old_a_axb ^ b_axb

# Rewrite since the selections get messy
old_al = oldpin&0xaa
old_ar = old_al>>1
old_br = oldpin&0x55
al = pin&0xaa
ar = al>>1
br = pin&0x55
bl = br<<1
axb_r = ar^br
axb_l = axb_r<<1
old_a_axb = oldpin ^ old_ar
b_axb = bl | axb_r = br*3^ar
dir_step = old_a_axb ^ b_axb
next_old_a_axb = axb_l^b_axb

Podría ser posible optimizar la operación a^b para que ocurra solo una vez, pero dado que necesitaba a o b en los otros bits, se lo dejo a otra persona. Además, este método no discrimina entre canales en absoluto; use otra máscara y encuentre bits establecidos para detectar qué canales realmente intervinieron.

Anexo: el algoritmo en realidad se vuelve mucho más limpio si no emparejamos las señales en bits adyacentes, sino que usamos posiciones coincidentes de variables separadas:

# assume, for instance, a[3:0] in pin[7:4] and b[3:0] in pin[3:0]
a=pin>>4
b=pin&0x0f     # Separate signals into individual variables
axb=a^b
step=oldaxb^axb
dir=olda^b
olda=a
oldaxb=axb

Entonces, para un conteo de ancho de registro de decodificadores en cuadratura, se necesitan dos variables almacenadas, tres operaciones xor y un registro temporal adicional (que rara vez importa).

Creo que muchos codificadores rotatorios tienen salidas de dos bits, A y B, con B ligeramente desfasado con A. Girando CW, el flujo de pulsos de A conduce a B (A cambia antes que B), CCW; B lleva a A.

Le sugiero que lleve un registro de dónde están sus codificadores y qué ha pedido que hagan los espejos, y luego haga algo como:

unsigned char enc_pos0, enc_pos1, enc_pos2, enc_pos3;
unsigned char req_pos0, req_pos1, req_pos2, req_pos3;
ISR(PCINT2_vect)
{
  unsigned char pins = PIND;
  unsigned char delta = 0;
  if (pins & 0x80) // One input from encoder
    delta ^= 1;
  if (pins & 0x40) // Other input from encoder
    delta ^= 3;
  // At this point, delta is what the bottom two bits of count "should" be
  delta = (delta - enc_pos0) & 3; // Amount to adjust enc_pos0
  if (delta & 2) // Instead of moving up by 3 or 2, move down by 1 or 2
    enc_pos0  += delta-4;
  else
    enc_pos0 += delta;
  ... do other three encoders likewise.
}

luego, en algún intervalo conveniente (posiblemente un tictac del temporizador, o posiblemente algo más)

... when convenient (note that if spi_send may take any significant amount of
... time, the pin-change interrupts should not be enabled while it's happening!

  unsigned char delta;

  delta = enc_pos0 - req_pos0;
  if ((delta & 0x80) != 0) // Need to decrease it
  {
    spi_send(MIRROR_X_L);
    req_pos0--;
    goto DONE;
  }
  else if (delta > 1) // Need to increase it
  {
    spi_send(MIRROR_X_R);
    req_pos0++;
    goto DONE;
  }
  delta = enc_pos1 - req_pos1;
  if ((delta & 0x80) != 0) // Need to decrease it
  {
    spi_send(MIRROR_Y_L);
    req_pos1--;
    goto DONE;
  }
  else if (delta > 1) // Need to increase it
  {
    spi_send(MIRROR_Y_R);
    req_pos1++;
    goto DONE;
  }
  delta = ...do likewise for other two encoders
  ...
DONE:

Este estilo de programación garantizará que incluso si uno está limitado en la rapidez con la que puede enviar datos SPI, e incluso si los codificadores pueden moverse más rápido que eso, el sistema terminará enviando la cantidad adecuada de comandos para mover todo. Hay un recuento de contragolpe integrado en el código de movimiento del espejo (decir >0en lugar de >1eliminar eso). Las goto DONEdeclaraciones se proporcionan asumiendo que el código solo querrá enviar un comando cada vez que se invoque, incluso si se han movido varios codificadores (si spi_sendinicia el proceso de envío y no espera a que finalice, el código podría evitar perder el tiempo esperando Para elsendoperación a completar; además, el dispositivo al que se envían los comandos puede necesitar algún retraso después de cada comando antes de manejar el siguiente). Algunos programadores son reacios a usar goto, pero en algunos contextos puede ser más limpio que cualquier alternativa práctica.