Lógica digital

El panorama: bits, señales y dos tipos de circuitos

Un [[bit|abreviatura de binary digit (dígito binario): la información más pequeña posible, un 0 o un 1]] es la respuesta a una pregunta de sí o no, como un interruptor de luz. En un circuito real, el 1 suele ser una tensión alta y el 0 una tensión baja. Un cable lleva un bit, y un grupo de cables lleva un grupo de bits.

¿Por qué solo dos valores? Porque es muy fácil distinguir "alto" de "bajo" incluso cuando la señal tiene un poco de ruido. Distinguir diez niveles de tensión sería mucho más difícil y produciría errores.

Los circuitos digitales tienen dos familias. Un [[circuito combinacional|circuito cuya salida depende solo de las entradas que tiene ahora]] es como el botón de una calculadora: pulsa 2 + 3 y da 5, no importa lo que hiciste antes. Un [[circuito secuencial|circuito cuya salida depende de las entradas y también de lo que pasó antes, que guarda como un estado]] es como el marcador de un juego: depende del pasado, porque recuerda.

El resto del resumen sigue una escalera. Primero los números y códigos que representan los bits, luego las compuertas y el álgebra que las describe, después los bloques combinacionales (sumadores, selectores), luego la memoria (flip-flops, registros, contadores) y, por último, el puente hacia el mundo analógico.

Sistemas de numeración y conversión de bases

Contamos de diez en diez porque tenemos diez dedos. El número 347 significa 3 centenas, 4 decenas y 7 unidades: cada lugar vale diez veces el lugar a su derecha. Esto se llama [[sistema posicional|una manera de escribir números en la que el valor de un dígito depende del lugar donde está]], y el número 10 es su base.

El computador tiene dos estados, así que usa la base 2, el binario. Los lugares valen 1, 2, 4, 8, 16 y así sucesivamente, duplicándose en cada paso hacia la izquierda. La cuenta de los lugares siempre empieza en 0, por la derecha.

Para leer un número binario, suma los pesos de los lugares que tienen 1. Así, 10011 es 16 + 2 + 1 = 19. El bit de más a la izquierda tiene el mayor peso y se llama MSB (bit más significativo). El de más a la derecha tiene el menor y es el LSB (bit menos significativo). Un grupo de 4 bits es un nibble y un grupo de 8 bits es un byte.

Con n bits hay 2^n patrones distintos. Empezando en 0, el mayor número sin signo es 2^n − 1, en el que todos los bits valen 1. En un byte, eso da 255. Para guardar N valores distintos necesitas el menor n con 2^n ≥ N.

Convertir de decimal a binario

Divide entre 2 una y otra vez, anota cada resto y lee los restos del último al primero.

25 / 2 = 12 resto 1   <- LSB
12 / 2 =  6 resto 0
 6 / 2 =  3 resto 0
 3 / 2 =  1 resto 1
 1 / 2 =  0 resto 1   <- MSB

leyendo de abajo hacia arriba: 11001  (16 + 8 + 1 = 25)

Octal y hexadecimal

Las cadenas largas de bits son difíciles de leer. Por eso las agrupamos. El octal (base 8) usa los dígitos 0 a 7, y un dígito equivale exactamente a 3 bits. El hexadecimal (base 16) usa 0 a 9 y luego A a F, que valen 10 a 15. Un dígito hexadecimal equivale exactamente a 4 bits, así que un byte son siempre dos dígitos hexadecimales.

binario  1101 0110
          |    |
hexa      D    6      -> D6

D6 = 13 x 16 + 6 = 214

binario 1010011 -> agrupa de 3 en 3 desde la derecha: 001 010 011 -> octal 123

Las direcciones de memoria se escriben en hexadecimal. Si las posiciones van de la dirección 0000 a la 0FFF, hay 0FFF + 1 = 1000 en hexadecimal, que es 16^3 = 4.096 posiciones. Un rango que empieza en cero y termina en X tiene X + 1 posiciones.

Fracciones

Después de la coma binaria los pesos se reducen a la mitad: 1/2, 1/4, 1/8, 1/16. Así, 110,01 es 4 + 2 + 0,25 = 6,25. Una fracción decimal solo puede escribirse exactamente en binario si su denominador, en forma irreducible, es una potencia de 2. Por eso 0,375 (3/8) es exacto, pero 0,1 (1/10) se repite sin fin en binario y termina redondeado.

Códigos: BCD, Gray, ASCII y complemento a 2

Un patrón de bits no significa nada hasta que acordamos un código: una regla que dice qué representa cada patrón. Los mismos 8 bits pueden ser un número, una letra o un color. Estos son los códigos que todo estudiante debe conocer.

BCD: un dígito decimal a la vez

El [[BCD|decimal codificado en binario: cada dígito decimal se escribe por separado con 4 bits]] (pesos 8-4-2-1) es útil en relojes y calculadoras, porque cada dígito va directo a una pantalla. El número decimal 83 es 1000 0011 en BCD, un dígito a la vez. En binario puro sería 101 0011.

El BCD desperdicia espacio: los patrones 1010 a 1111 nunca aparecen. Cuando un sumador binario común de 4 bits suma dos dígitos BCD y el resultado pasa de 9 (o genera acarreo), suma 6 para saltarte los seis patrones sin usar. En 7 + 6: el sumador da 1101, al sumar 0110 resulta 1 0011, que se lee como los dígitos 1 y 3, es decir, 13.

Código Gray: solo cambia un bit

En binario, pasar de 0111 a 1000 cambia cuatro bits a la vez. Si un sensor lee durante el cambio, puede captar un valor equivocado en el medio. En el código Gray cada paso cambia exactamente un bit, así que una lectura nunca se equivoca en más de un paso.

Para convertir binario a Gray, conserva el primer bit y haz XOR de cada par de bits vecinos. Otra forma: Gray = n XOR (n desplazado un lugar a la derecha). Para 1100: 1100 XOR 0110 = 1010. El código Gray se usa en codificadores de posición y en las etiquetas del mapa de Karnaugh.

ASCII y paridad

El ASCII da un número a letras, dígitos, signos de puntuación y caracteres de control. El ASCII estándar tiene 7 bits, así que 2^7 = 128 caracteres. El 8.º bit del byte quedó libre. A menudo se usa como bit de paridad: un bit extra elegido para que el total de unos sea par (paridad par) o impar (paridad impar).

La letra E es 100 0101, que tiene tres unos. Con paridad par el bit de paridad es 1, y el byte enviado es 1100 0101. Si un bit se invierte en el camino, el receptor cuenta una cantidad impar de unos y se da cuenta del problema. Pero la paridad no dice cuál bit cambió, y dos bits invertidos se cancelan.

Complemento a 2: números negativos

En el complemento a 2 el bit de más a la izquierda tiene peso negativo. En 8 bits los pesos son −128, 64, 32, 16, 8, 4, 2, 1. Así, 1011 0100 = −128 + 32 + 16 + 4 = −76. El bit de la izquierda es 1 en los números negativos, y existe un único cero.

• Para negar un número: invierte todos los bits y suma 1. Para 5 = 0000 0101: al invertir da 1111 1010, al sumar 1 da 1111 1011, que es −5.
• Comprobación rápida: el negativo de una magnitud m en n bits es 2^n − m. En 8 bits, 256 − 5 = 251 = 1111 1011.
• Rango con n bits: de −2^(n−1) a 2^(n−1) − 1. En 8 bits, de −128 a 127.
• Para ampliar un número (de 4 a 8 bits) sin cambiar su valor, copia el bit de signo en todos los bits nuevos de la izquierda: 1010 (−6) pasa a 1111 1010.

Compuertas lógicas y tablas de verdad

Una compuerta lógica es un tomador de decisiones con una regla muy corta. Piensa en una puerta vigilada por dos niños: la puerta AND solo se abre si los dos tienen la llave, la puerta OR se abre si al menos uno la tiene.

Una [[tabla de verdad|una lista de todas las combinaciones posibles de las entradas, con la salida de cada una]] describe una compuerta por completo. Con n entradas hay 2^n filas, normalmente listadas en orden de cuenta binaria. Dos entradas dan 4 filas, tres dan 8, cuatro dan 16.

• NOT invierte su única entrada: el 0 pasa a 1 y el 1 pasa a 0. Se escribe A'.
• AND (se escribe A·B) vale 1 solo cuando todas las entradas son 1. Es un producto.
• OR (se escribe A + B) vale 1 cuando al menos una entrada es 1. Es una suma.
• XOR vale 1 cuando las entradas son diferentes. Es la suma de dos bits sin el acarreo: A'·B + A·B'.
• NAND, NOR, XNOR son AND, OR y XOR seguidas de un NOT. Así, la NAND vale 0 solo en la única fila en que todas las entradas son 1, y una NAND de n entradas vale 1 en las otras 2^n − 1 filas.

Para reconocer una compuerta por su tabla, busca la fila distinta de las demás. AND y NOR tienen un único 1. NAND y OR tienen un único 0.

Leer un circuito y un diagrama de tiempo

Para hallar la tabla de un circuito, ponle nombre a cada cable y escribe lo que lleva, paso a paso. En este circuito, X = A·B, W = C' y Y = X + W.

A ----+
      AND ---- X ----+
B ----+              OR ---- Y
                     |
C ---- NOT ---- W ---+

Un diagrama de tiempo muestra las señales a lo largo del tiempo, una columna por instante. Sin retardos, aplicas la tabla de verdad a cada columna. En la NAND la salida es 0 exactamente en los instantes en que todas las entradas son 1.

Compuertas universales

Cualquier función booleana puede hacerse con AND, OR y NOT. Un conjunto de compuertas que puede hacer esas tres es universal. La NAND sola es universal, y la NOR sola también. Si unes las dos entradas de una NAND, A·A = A, así que calcula A' y funciona como NOT. La NAND seguida de ese NOT hace la AND. Y la OR sale de la ley de De Morgan, que veremos en la próxima sección.

NOT A    = NAND(A, A)
A AND B  = NOT( NAND(A, B) )
A OR B   = NAND( NOT A, NOT B )

XOR con 4 NAND:    M = NAND(A, B)
                   XOR = NAND( NAND(A, M), NAND(B, M) )

Álgebra booleana y leyes de De Morgan

El álgebra booleana es la aritmética del 0 y el 1. Permite escribir un circuito como una fórmula y luego acortar la fórmula, lo que significa un circuito más barato. Cada compuerta se vuelve un símbolo: el apóstrofo es NOT, el punto es AND y el más es OR.

El orden de prioridad es el mismo de las matemáticas de la escuela: primero NOT, luego AND (como la multiplicación), luego OR (como la suma). Así, A + B·C significa A + (B·C).

Fíjate en que la segunda ley distributiva, A + B·C = (A + B)·(A + C), no existe en la aritmética común. En el álgebra booleana funcionan los dos sentidos.

Leyes de De Morgan

Para negar una expresión, niega cada variable y cambia AND por OR. En símbolos, (A·B)' = A' + B' y (A + B)' = A'·B'. Imagina la regla "no puedes tener pastel y helado": quiere decir "sin pastel, o sin helado".

Con varios niveles, trabaja de afuera hacia adentro y deja que la doble negación se cancele. Por ejemplo, (A + B'·C)' = A'·(B'·C)' = A'·(B + C').

Simplificaciones útiles

• X·Y + X·Y' = X: dos términos que difieren en una variable se unen, y esa variable desaparece.
• A + A'·B = A + B: si A es 1 el resultado ya es 1, si A es 0 solo queda B. Solo sale el literal A', no el término entero.
• Consenso: A·B + A'·C + B·C = A·B + A'·C. El último término es redundante.
• Como X + X = X, el mismo término puede usarse en más de una agrupación.

Formas canónicas: minterms y maxterms

Un [[minterm|un producto que contiene todas las variables de la función, normales o negadas, y vale 1 en exactamente una fila de la tabla de verdad]] lleva el índice de su fila. Lee la fila en binario con la primera variable como bit más significativo. La variable aparece normal si su bit es 1 y negada si es 0. Con tres variables, la fila 5 (101) es el minterm A·B'·C.

La suma de productos canónica suma los minterms de las filas en que la función vale 1, escrita Σm(...). Un maxterm es una suma que vale 0 en exactamente una fila. El producto de sumas canónico, ΠM(...), multiplica los maxterms de las filas en que la función vale 0, y en el maxterm los bits se usan al revés: un 0 da la variable normal y un 1 da la variable negada.

Cada fila es un minterm o un maxterm, nunca los dos. Entonces el número de minterms más el de maxterms es siempre 2^n. Una función con pocos 0 tiene un producto de sumas corto.

Mapas de Karnaugh

Simplificar con álgebra exige buen ojo y suerte. El mapa de Karnaugh lo convierte en un dibujo. Es una tabla de verdad redibujada como una cuadrícula, de modo que dos celdas vecinas difieren en exactamente una variable. Y ya sabemos que X·Y + X·Y' = X, así que dos unos vecinos pueden unirse en un término más corto.

Para que las celdas vecinas difieran en una variable, las etiquetas de filas y columnas siguen el código Gray: 00, 01, 11, 10, y no el orden binario. El mapa además da la vuelta: la primera y la última columna son vecinas, y la primera y la última fila también. Un grupo puede cruzar el borde, y las cuatro esquinas son vecinas.

        BC
       00  01  11  10
A=0 |   1   0   0   1
A=1 |   1   1   0   1

La receta es corta. Cubre todos los unos con los grupos más grandes posibles, usando la menor cantidad de grupos. Una celda puede pertenecer a varios grupos.

• Un grupo es un rectángulo de 1, 2, 4, 8 o 16 celdas: siempre una potencia de 2. Una región de 6 celdas necesita dos grupos, que pueden traslaparse.
• Cada vez que el grupo se duplica, una variable desaparece. Un grupo de 2^k celdas en un mapa de n variables da un término con n − k literales. En un mapa de 4 variables: 2 celdas dan 3 literales, 4 celdas dan 2, 8 celdas dan 1.
• Para escribir el término, conserva solo las variables que no cambian dentro del grupo. Si la variable vale 1 en el grupo, escríbela normal; si vale 0, escríbela negada.
• Suma los términos de todos los grupos: esa es la suma de productos mínima.

En el mapa de arriba, las cuatro celdas de las columnas 00 y 10 (las columnas que dan la vuelta) forman un grupo con C = 0: el término es C'. El par A=1, B=0 (celdas 100 y 101) da A·B'. Entonces F = C' + A·B'.

      CD
     00  01  11  10
AB=00 | 1   0   0   1
AB=01 | 0   1   1   0
AB=11 | 0   1   1   0
AB=10 | 1   0   0   1

esquinas (00,00)(00,10)(10,00)(10,10)  -> B'·D'
bloque central                         -> B·D
F = B'·D' + B·D   (XNOR de B y D)

Producto de sumas, don't-cares e implicantes primos

• Producto de sumas: agrupa los 0. Cada grupo da un término de suma en que la variable es normal cuando vale 0 y negada cuando vale 1. Es lo mismo que simplificar F' y aplicar De Morgan.
• Don't-care (X): una combinación de entrada que nunca ocurre o cuya salida no importa, por ejemplo los códigos 1010 a 1111 en un circuito BCD. Puedes contar una X como 1 para agrandar un grupo, o ignorarla. Solo los unos de verdad deben quedar cubiertos. Ejemplo: unos en los minterms 1, 3, 7 y una X en el 5 dan C, mientras que sin la X harían falta dos pares.
• Implicante primo: un grupo que no se puede agrandar. Es esencial cuando cubre un 1 que ningún otro implicante primo cubre. Toma primero todos los esenciales y luego agrega la menor cantidad de otros para cubrir lo que queda. Es exactamente lo que hace el método de Quine-McCluskey por procedimiento.
• Patrón de tablero de ajedrez: cuando los unos nunca se tocan (como el XOR de tres variables, paridad impar), nada se une y la suma de productos no se puede reducir.

Circuitos aritméticos: sumadores y restadores

Sumar en binario es como sumar en papel en decimal, pero el acarreo ("me llevo uno") aparece en cuanto una columna llega a 2. Las reglas: 0+0 = 0, 0+1 = 1, 1+1 = 10 (escribe 0, llevo 1) y 1+1+1 = 11 (escribe 1, llevo 1).

  acarreos: 1 1 1
            0 1 1 0   (6)
          + 0 1 1 1   (7)
          ---------
            1 1 0 1   (13)

El semisumador

Sumar dos bits da un bit de suma y un acarreo. La suma vale 1 para 01 y 10, así que es XOR. El acarreo vale 1 solo para 11, así que es AND. Este circuito es el semisumador (half adder): S = A XOR B y C = A·B. Es "semi" porque no tiene entrada para el acarreo que viene de la derecha.

El sumador completo

Una columna en medio de un número tiene tres bits que sumar: A, B y el acarreo de entrada Cin. El sumador completo (full adder) recibe los tres. Su suma es la paridad de los tres bits, S = A XOR B XOR Cin. Su acarreo de salida vale 1 cuando al menos dos entradas valen 1 (mayoría): Cout = A·B + A·Cin + B·Cin. Puede construirse con dos semisumadores y una OR.

El sumador ripple-carry

Para sumar números de n bits, encadena n sumadores completos: el acarreo de salida de la etapa i entra en el acarreo de entrada de la etapa i + 1. Este es el sumador ripple-carry. Es el diseño más simple, pero un acarreo puede tener que recorrer todas las etapas, como un balde pasado por una fila de personas. En el peor caso (1111...1 + 1) el retardo es proporcional a n. Con 3 ns por etapa, 16 etapas tardan 16 × 3 = 48 ns. Diseños más rápidos, como el sumador carry-lookahead, predicen los acarreos para reducir ese tiempo.

Restar con el mismo sumador

En complemento a 2, A − B = A + B' + 1. En el circuito, una compuerta XOR en cada bit de B se controla con un cable SUB (XOR con 1 invierte, XOR con 0 deja pasar). El mismo cable SUB va al primer acarreo de entrada, que aporta el +1. Con SUB = 0 el circuito suma, con SUB = 1 resta.

6 - 2 con 4 bits:  A = 0110
                   B' = 1101   (2 = 0010 invertido)
                   Cin = 1
                   -----------
                   suma = 0100  acarreo de salida = 1
6 - 2 = 4 y el acarreo de salida es 1: sin préstamo

Acarreo de salida y desbordamiento son cosas distintas

• Resta sin signo: el acarreo de salida funciona como el inverso del préstamo (borrow). Acarreo 1 significa que no hizo falta pedir prestado (A ≥ B). Acarreo 0 significa que hubo préstamo (A < B). Así compara un procesador dos números sin signo: resta y mira la bandera de acarreo.
• Desbordamiento con signo (overflow): el resultado no cabe en n bits. Ocurre cuando dos operandos de igual signo dan un resultado de signo opuesto. Es lo mismo que decir que el acarreo que entra al bit de signo es distinto del acarreo que sale de él. Ejemplo en 4 bits: 0111 + 0001 = 1000, es decir, 7 + 1 = −8.
• El acarreo de salida, por sí solo, únicamente indica desbordamiento en números sin signo.

Multiplexores, demultiplexores, codificadores y decodificadores

Estos son los "agentes de tránsito" de un circuito. Eligen qué señal va hacia dónde. Todos son combinacionales.

Multiplexor (mux): muchas entradas, una salida

Un multiplexor tiene varias entradas de datos, una salida y algunas entradas de selección. Las entradas de selección forman un número binario que dice qué entrada de datos está conectada a la salida. Es como un control remoto de TV que elige un canal entre muchos.

Para elegir entre 2^n entradas de datos hacen falta n líneas de selección: 1 para un mux 2:1, 2 para 4:1, 3 para 8:1, 4 para 16:1. Un procesador usa muxes para elegir qué registro alimenta la ALU.

I0 --+
I1 --|  4:1
I2 --|  MUX ---- Y
I3 --+   |  |
        S1 S0

S1 S0 = 1 0  ->  Y = I2

Los muxes grandes se construyen como un árbol de muxes pequeños. Un mux 16:1 con piezas 4:1: cuatro muxes en el primer nivel reciben los datos y los dos bits bajos de la selección, y un mux en el segundo nivel elige entre sus salidas con los dos bits altos de la selección. Son 4 + 1 = 5 componentes.

Un mux también puede calcular una función. Un mux con n líneas de selección implementa cualquier función de n + 1 variables. Conecta n de las variables a las selecciones. Para cada valor de selección, la salida solo puede ser 0, 1, la variable restante o su complemento, y eso es lo que se conecta a la entrada de datos. Ejemplo: F = A XOR B con un mux 2:1 cuya selección es A: I0 = B (cuando A = 0, F = B) e I1 = B' (cuando A = 1, F = B').

Demultiplexor (demux): una entrada, muchas salidas

Lo opuesto al mux. Una entrada de datos se envía a la salida elegida por las líneas de selección, y todas las demás salidas quedan en 0. Es un decodificador en que el dato hace el papel del enable.

Decodificador: un código se vuelve una línea

Un decodificador binario con n entradas tiene 2^n salidas y exactamente una está activa: aquella cuyo número es igual al código de entrada. Cada salida es un minterm de las entradas. Sirve para seleccionar una posición de memoria, un dispositivo o la operación de una instrucción.

Los decodificadores con entrada de enable pueden expandirse. Para un decodificador 3 a 8 a partir de dos 2 a 4, los dos bits bajos van a los dos bloques, y el bit alto A2 va directo al enable de un bloque y, a través de un inversor, al enable del otro. Los chips de memoria se seleccionan con los bits altos de la dirección de la misma forma.

Codificador: una línea se vuelve un código

El codificador hace lo contrario del decodificador: 2^n entradas, de las cuales una está activa, se convierten en el número de n bits de esa entrada. Un teclado usa uno para convertir la tecla pulsada en un código. Un codificador simple son solo compuertas OR: cada bit de salida es el OR de las entradas cuyo índice tiene ese bit en 1.

El problema empieza cuando dos entradas están activas. Supón que I1 e I2 están activas: las compuertas OR mezclan los códigos 01 y 10 y la salida es 11, que apunta a una tercera entrada. El codificador de prioridad lo resuelve: responde con el código de la entrada activa de mayor prioridad e ignora las otras. Con I3 I2 I1 I0 = 1010 y prioridad para el mayor índice, la salida es 11. Decide qué interrupción se atiende primero.

Latches y flip-flops

Hasta ahora todo circuito olvidaba todo en el momento en que cambiaban las entradas. Para recordar un bit necesitamos realimentación: una salida conectada de vuelta a una entrada. Dos compuertas que se escuchan entre sí pueden sostener un valor, como dos niños que se repiten la misma palabra el uno al otro.

El latch RS

Un [[latch|una celda básica de memoria que guarda un bit y reacciona a las entradas mientras está habilitada]] hecho de dos compuertas con acoplamiento cruzado tiene dos salidas, Q y Q', que siempre deben ser opuestas. Tiene una entrada Set (hace Q = 1) y una entrada Reset (hace Q = 0).

En el latch NOR una entrada en 1 fuerza su compuerta a 0. Pedir set y reset juntos deja las dos salidas en 0, lo que rompe la regla de que Q' es lo opuesto de Q. Y si las dos entradas vuelven a 0 al mismo tiempo, el estado final depende de cuál compuerta es más rápida, así que es impredecible. En el latch NAND el nivel que manda es 0, por eso sus entradas son activas en bajo: es el mismo comportamiento con los niveles al revés.

¿Nivel o flanco?

Un latch D tiene una entrada de dato D y una entrada de habilitación, normalmente conectada al reloj (clock). Mientras la habilitación vale 1 el latch es transparente: Q sigue a D. Cuando la habilitación pasa a 0, Q guarda el último valor. Es sensible al nivel.

Un flip-flop es sensible al flanco: mira D solo en el instante en que el reloj sube (o baja) y mantiene Q hasta el siguiente flanco. Un flip-flop D puede hacerse con dos latches D en serie con habilitaciones opuestas (maestro-esclavo). La forma de onda muestra la diferencia:

t:           0 1 2 3 4 5 6 7
reloj:       0 1 1 0 0 1 1 0
D:           1 1 0 0 1 0 1 1
latch D:     0 1 0 0 0 0 1 1   <- sigue a D mientras reloj = 1
flip-flop:   0 1 1 1 1 0 0 0   <- mira D solo en las subidas del reloj

Mira el instante 6: el reloj vale 1 y D pasa a 1, así que el latch lo sigue, pero el flip-flop no se mueve porque no hay un nuevo flanco de subida.

Los tipos de flip-flop

• Flip-flop D: en el flanco activo Q toma el valor de D, el resto del tiempo mantiene. Es la celda básica de los registros.
• Flip-flop JK: J = K = 0 mantiene, J = 1 K = 0 hace set, J = 0 K = 1 hace reset y J = K = 1 hace toggle (Q se invierte). A diferencia del RS, no tiene combinación prohibida. El toggle divide la frecuencia del reloj entre 2, que es la base de los contadores.
• Para seguir un JK en el tiempo, aplica el modo al Q anterior en cada flanco activo. Entre flancos Q se queda quieto.

Temporización: setup, hold y el reloj más rápido

Un flip-flop lee D correctamente solo si D está estable en una pequeña ventana alrededor del flanco del reloj: el tiempo de setup (antes del flanco) y el tiempo de hold (después de él). Violar esta ventana puede dejar la salida en un estado inestable intermedio llamado metaestabilidad.

Entre dos flip-flops con el mismo reloj, el dato debe salir del primero (retardo de propagación), cruzar la lógica y llegar al segundo con tiempo de sobra (tiempo de setup). Entonces el período del reloj debe ser al menos la suma de los tres, y la frecuencia máxima es 1 dividido entre ese período (la frecuencia es cuántos pulsos de reloj caben en un segundo; 1 MHz es un millón por segundo). Para 6 ns + 10 ns + 4 ns = 20 ns la frecuencia máxima es 1 / 20 ns = 50 MHz.

Registros y contadores

Un flip-flop guarda un bit. Varios uno al lado del otro guardan una palabra, como una fila de buzones en que cada uno guarda una carta.

Registros

Un registro de n bits son n flip-flops D que comparten el mismo reloj, así que los n bits se capturan juntos. Para que conserve la palabra aunque el reloj siga marcando, un multiplexor delante de cada flip-flop realimenta el bit hacia sí mismo cuando la señal load vale 0. Los registros guardan operandos, resultados y direcciones dentro de un procesador.

Registros de desplazamiento

En un registro de desplazamiento (shift register) la salida de cada flip-flop va a la entrada de su vecino. En cada pulso de reloj todos los bits avanzan un lugar, entra un bit nuevo por un extremo y sale uno por el otro. Cargar n bits por la única entrada serie lleva n pulsos. En la transferencia paralela hay un cable por bit y un pulso carga la palabra completa.

desplaza a la derecha, entrada serie = 0
inicio  Q3 Q2 Q1 Q0 = 1 1 0 0   (12)
pulso 1               0 1 1 0   (6)
pulso 2               0 0 1 1   (3)

Contadores

Un contador es un registro que recorre una secuencia de estados, uno por pulso de reloj. Un contador binario ascendente de n bits tiene hasta 2^n estados y luego vuelve a empezar; ese número de estados es su módulo. Un contador de 4 bits tiene módulo 16: va 0, 1, ... 15 y vuelve al 0. El contador de programa de un procesador es un registro así, que suma 1 en cada instrucción.

El bit menos significativo se invierte en cada pulso, el siguiente cada 2 pulsos, luego cada 4. Así, el bit k tiene la frecuencia del reloj dividida entre 2^(k+1), y un contador de n bits divide la frecuencia entre 2^n en el último bit.

Asíncrono y síncrono

En un contador asíncrono (ripple) la salida de cada flip-flop es el reloj del siguiente. No cambian juntos, y mientras el cambio se propaga el contador muestra valores erróneos intermedios. El tiempo de asentamiento es el número de etapas por el retardo de un flip-flop. Con 3 flip-flops de 5 ns los pulsos deben estar separados al menos 15 ns, así que 1 / 15 ns ≈ 66,7 MHz como máximo. En un contador síncrono todos los flip-flops comparten el reloj y los retardos no se suman.

Otros módulos y el contador Johnson

Para contar menos de 2^n estados, detecta el primer estado no deseado y úsalo para poner a cero (clear) el contador. Para contar de 0 a 5 (módulo 6), detecta 0110 y pon a cero. Con clear asíncrono, el estado 0110 aparece solo un instante, como un pulso corto (glitch), y el módulo es el valor detectado. Ese glitch es una desventaja; los diseños síncronos prefieren detectar el último estado válido y poner a cero en el siguiente flanco.

Un contador Johnson (de anillo retorcido) es un registro de desplazamiento en que el complemento del último flip-flop vuelve al primero. Primero se llena de unos y luego se vacía, así que n flip-flops dan 2n estados, y solo cambia un bit entre estados vecinos.

3 flip-flops Q2 Q1 Q0, desplazando a la derecha, Q0' entra en Q2:
0 0 0 -> 1 0 0 -> 1 1 0 -> 1 1 1 -> 0 1 1 -> 0 0 1 -> 0 0 0
6 estados = 2 x 3

Conversión analógico-digital

El mundo real es analógico: la temperatura, el sonido y la luz varían de forma suave. Un circuito digital solo entiende bits. Un conversor D/A (DAC) convierte un código en una tensión. Un conversor A/D (ADC) convierte una tensión en un código. Tu celular usa un ADC para cada sonido que oye el micrófono.

Conversor D/A y resolución

Un DAC de N bits puede generar 2^N niveles con escalones iguales. La resolución es el tamaño de un escalón, el cambio de la salida cuando el código sube 1 (el LSB). Si el mayor código, 2^N − 1, da la tensión de fondo de escala, el escalón es esa tensión dividida entre 2^N − 1. La salida para cualquier código es el escalón por el valor del código.

DAC de 4 bits, 0 V para 0000 y 3,0 V para 1111
escalón = 3,0 V / 15 = 0,2 V
código 0101 = 5  ->  5 x 0,2 V = 1,0 V

Tres maneras de construir un ADC

Todos comparan la tensión de entrada con la salida de un DAC interno o con niveles de referencia fijos. Un comparador es un circuito que dice si una tensión está por encima de otra.

• Rampa digital: un contador sube un escalón por ciclo de reloj hasta que el DAC interno alcanza la entrada. Es el más simple, pero el tiempo depende de la entrada, y el peor caso es 2^N − 1 ciclos de reloj. Se duplica con cada bit añadido. Con 10 bits y un reloj de 1 MHz son 1.023 ciclos, unos 1,023 ms.
• Aproximaciones sucesivas (SAR): una búsqueda binaria. Prueba el bit más significativo en 1, consérvalo solo si la salida del DAC no supera la entrada, y pasa al siguiente bit. Siempre toma exactamente N ciclos, sea cual sea la entrada.
• Flash: un divisor de resistencias genera todos los niveles de referencia y un comparador por nivel prueba la entrada al mismo tiempo. Un codificador de prioridad convierte el resultado en un código. Es prácticamente instantáneo, pero el costo se duplica con cada bit: 2^N − 1 comparadores.

SAR, 4 bits, escalón del DAC 0,5 V, entrada 4,7 V
prueba 1000 = 4,0 V  <= 4,7  conserva ->  1000
prueba 1100 = 6,0 V  >  4,7  descarta ->  1000
prueba 1010 = 5,0 V  >  4,7  descarta ->  1000
prueba 1001 = 4,5 V  <= 4,7  conserva ->  1001
resultado 1001 = 4,5 V, error de cuantización 0,2 V

La diferencia que sobra entre la entrada real y el valor del código final es el error de cuantización. Siempre es menor que un escalón.

Juntando todo

Mira cómo se apilan las ideas, de abajo hacia arriba. Cada nivel está hecho del anterior.

bits y códigos (binario, hexa, complemento a 2, BCD, Gray)
   |
compuertas (AND, OR, NOT, NAND, NOR, XOR)
   |
álgebra booleana + mapas de Karnaugh  (achican el circuito)
   |
bloques combinacionales: sumadores, mux, decodificador, codificador
   |
realimentación -> latch -> flip-flop
   |
registros, registros de desplazamiento, contadores
   |
procesador (ALU + registros + muxes + decodificador)
   |
conversores A/D y D/A lo conectan con el mundo real

Un procesador pequeño es exactamente esta escalera: un sumador con compuertas XOR se vuelve una ALU, los flip-flops se vuelven registros y un contador de programa, los muxes eligen qué registro alimenta la ALU, y un decodificador convierte la instrucción en señales de control. Si quieres verlo todo construido a partir de una sola compuerta NAND, los mini-proyectos de este repositorio lo hacen.

Errores que aparecen una y otra vez

Dos videos muestran todo este camino, y después puedes probarlo por tu cuenta en un simulador.