Taller: salidas con el 74HC595

01 · Punto de partida

Tres montajes, un chip que se repite

El 74HC595 reúne dos bloques que ya conocés: un registro de desplazamiento de 8 bits (tema 14) y un registro de almacenamiento de 8 bits (tema 13) con salidas de tres estados. Los bits se desplazan dentro del primero sin que se note afuera; cuando la palabra está completa, un pulso aparte la copia al segundo, que es el que maneja los pines. Por eso los LED no parpadean mientras llegan los datos.

Como en los talleres anteriores, el tema se aprovecha también sin materiales: el código reproduce el comportamiento del chip y el laboratorio permite probar las secuencias con un 595 virtual.

02 · Preparación

Materiales y herramientas

El multímetro alcanza para el montaje a mano. Para ver los dos relojes y la salida a la vez, un analizador lógico de 4 canales es lo ideal, aunque no imprescindible. Dibujá el esquema con los números de pin antes de cablear: el 595 tiene la salida QA en un lugar poco intuitivo.

Antes de dar tensión

• Un 100 nF entre Vcc (pin 16) y GND (pin 8), pegado al chip.
• SRCLR̅ (pin 10) a +5 V si no se usa; OE̅ (pin 13) a masa en los primeros montajes.
• Ninguna entrada al aire: SER, SRCLK, RCLK, SRCLR̅ y OE̅ tienen siempre un nivel.
• Cada LED con su resistencia; nunca un LED directo a una salida.

03 · El chip

Pines del 74HC595

El encapsulado DIP de 16 patas tiene una muesca en un extremo; el pin 1 queda a la izquierda de la muesca y los números siguen en sentido antihorario. Las salidas están repartidas en los dos lados, con QA «al otro lado» del resto:

Según el fabricante, estos pines también se llaman SH_CP (SRCLK), ST_CP (RCLK), DS (SER), MR̅ (SRCLR̅) y Q7S (QH′). La función de cada uno es la misma.

Cómo se comporta

Los dos relojes son independientes. Conceptualmente, el 595 equivale a un registro de desplazamiento tipo 74HC164 con un registro de salida de tres estados tipo 74HC374 detrás. Si ambos pines se unen, el registro de salida va siempre un pulso por detrás del de desplazamiento: se pierde la gracia de los dos relojes.

04 · Montaje 1

Ocho salidas con reloj manual

Primero un reloj que se pueda manejar con la mano. Reutilizamos el latch de NAND del tema 7 (74HC00) con el conmutador SPDT para generar SRCLK sin rebotes. El pulsador de RCLK no necesita antirrebote: si rebota, cada flanco copia el mismo dato al registro de salida, que ya tenía ese valor, y el resultado no cambia.

Pruebas

Fijate en el paso 7: mientras se desplazan datos, los LED permanecen quietos. Con un solo reloj tendrías que ver cada bit pasar por todos los LED. Esa es la ventaja del registro de salida.

05 · Montaje 2

Dos chips en cadena

La salida serie QH′ (pin 9) entrega el bit que sale del último flip-flop del desplazamiento. Conectándola a SER del segundo chip, los bits que «sobran» pasan al segundo, y las dos mitades se comportan como un único registro de 16 bits. Los dos chips comparten SRCLK y RCLK:

Una palabra completa son 16 bits, es decir 16 pulsos de SRCLK, y un único RCLK al final. Los primeros 8 bits que se mandan terminan en el segundo chip (U3); los últimos 8, en el primero (U2). Con el MSB primero, la palabra de 16 bits queda con el bit 15 en QH de U3 y el bit 0 en QA de U2. Si se envían solo 8 bits, el dato se queda en U2 y U3 conserva lo que tenía.

06 · Montaje 3

Habilitación y arranque limpio

Al encender, el registro de salida del 595 no tiene valor definido: los LED pueden quedar con cualquier patrón hasta que se envíe y copie el primer dato. Con OE̅ se esconde ese arranque: mientras OE̅ = 1, las salidas están en alta impedancia y los LED permanecen apagados.

Secuencia de arranque correcta

1. Encender con OE̅ en alto: los LED están apagados aunque el registro de salida tenga basura.
2. Enviar 8 ceros con SRCLK (o dar un SRCLR̅ = 0 breve) y pulsar RCLK: ahora el registro de salida vale 00000000.
3. Habilitar las salidas bajando OE̅: todos los LED siguen apagados, ahora por un dato válido.
4. Desde acá se envían los datos reales.

SRCLR̅: el borrado que no se ve

Un pulso bajo en SRCLR̅ pone a cero el registro de desplazamiento, pero no el de salida: los LED siguen como estaban hasta el próximo RCLK. Es un error clásico esperar que SRCLR̅ apague los LED. Para eso hay que dar SRCLR̅ = 0 y luego un RCLK, o directamente deshabilitar con OE̅.

Pruebas

• Apagar y encender diez veces con el pull-up de OE̅: los LED deben empezar siempre apagados. Después reemplazar el pull-up por masa y repetir: el patrón inicial varía.
• OE̅ sin tocar los datos: cargar 10110001, subir OE̅ (se apagan) y bajarlo (reaparece el mismo patrón).
• SRCLR̅: con 10110001 en los LED, bajar SRCLR̅ un momento: los LED no cambian; pulsar RCLK y se apagan todos.

07 · Cuando no funciona

Corriente, fallas y método

¿Cuánta corriente puede dar?

Los LED se encienden desde las salidas, y las salidas de un 595 tienen un límite. El orden de magnitud para el 74HC595 es de alrededor de 6 mA garantizados por pin con el nivel lógico correcto, un máximo absoluto de unos 35 mA por pin y de unos 70 mA para el total que circula por Vcc o GND (confirmalo en la hoja de datos). Con LED rojos (≈ 2 V) alimentados a 5 V:

Para cargas más grandes (relés, tiras, displays potentes) las salidas del 595 no alcanzan: se agrega un transistor o un driver por salida (tema de «Componentes electrónicos»).

De síntoma a causa

Armar por etapas

1. Alimentación primero: Vcc, GND y el 100 nF en cada chip.
2. Un bloque por vez: probar el reloj manual antes de conectarlo al 595.
3. Un chip antes que dos: terminar y probar el montaje 1 antes de encadenar.
4. Probar cada línea por separado: primero SRCLK sin RCLK, después RCLK.
5. Cambiar una sola cosa a la vez cuando algo falla.
6. Anotar el patrón observado y compararlo con el esperado: el error está entre el último paso correcto y el primero que falla.

08 · El taller en código

Simular, ordenar y encadenar

Los bloques reproducen el 74HC595 con sus dos registros, muestran la diferencia entre enviar MSB y LSB primero, encadenan dos chips y calculan los tiempos y las corrientes de una animación de LED.

Paso 1: el 595 con sus dos registros

class HC595:
    """74HC595: registro de desplazamiento + registro de salida + OE̅. Los textos se leen QH ... QA."""

    def __init__(self):
        self.sr = [0] * 8          # índice 0 = QA ... 7 = QH
        self.st = [0] * 8          # registro de almacenamiento (lo que ven los pines)
        self.oe_n = 0

    def srclk(self, ser):          # flanco ascendente de SRCLK (pin 11)
        self.sr = [ser] + self.sr[:-1]

    def rclk(self):                # flanco ascendente de RCLK (pin 12)
        self.st = self.sr[:]

    def srclr(self):               # SRCLR̅ = 0 (pin 10): borra solo el desplazamiento
        self.sr = [0] * 8

    def desplazamiento(self):
        return "".join(str(b) for b in reversed(self.sr))

    def pines(self):
        return "ZZZZZZZZ" if self.oe_n else "".join(str(b) for b in reversed(self.st))


def enviar(chip, byte, latch=True):
    for i in range(7, -1, -1):             # MSB primero
        chip.srclk((byte >> i) & 1)
    if latch:
        chip.rclk()


c = HC595()
enviar(c, 0b10110001, latch=False)
print("tras 8 SRCLK, sin RCLK:  desplazamiento", c.desplazamiento(), "pines", c.pines())
c.rclk()
print("tras un pulso de RCLK:   desplazamiento", c.desplazamiento(), "pines", c.pines())
enviar(c, 0b01001110, latch=False)
print("nuevo byte sin latch:    desplazamiento", c.desplazamiento(), "pines", c.pines(), "(los LED no cambiaron)")
c.oe_n = 1
print("con OE̅ = 1:              desplazamiento", c.desplazamiento(), "pines", c.pines(), "(el dato sigue guardado)")
c.oe_n = 0
c.srclr()
print("tras SRCLR̅ y OE̅ = 0:    desplazamiento", c.desplazamiento(), "pines", c.pines(), "(SRCLR̅ no toca el registro de salida)")

Después de 8 pulsos de SRCLK el desplazamiento vale 10110001, pero los pines siguen en 00000000 hasta el pulso de RCLK. Un segundo byte puede llenar el desplazamiento sin que los pines se muevan. OE̅ = 1 los pasa a Z sin borrar nada, y SRCLR̅ deja el desplazamiento en cero con los pines intactos. Cambiá los bytes y predecí cada línea antes de ejecutar.

Paso 2: MSB primero o LSB primero

def qh_a_qa(bits):
    sr = [0] * 8                               # sr[0] = QA ... sr[7] = QH
    for b in bits:
        sr = [b] + sr[:-1]
    return "".join(str(b) for b in reversed(sr))          # se muestra QH QG ... QA


byte = 0b10000000
msb = [(byte >> i) & 1 for i in range(7, -1, -1)]
lsb = [(byte >> i) & 1 for i in range(8)]
print("byte 0b10000000 (solo el bit 7 encendido); columnas QH QG QF QE QD QC QB QA")
print("  MSB primero ->", qh_a_qa(msb), "(bit 7 en QH: correcto)")
print("  LSB primero ->", qh_a_qa(lsb), "(bit 7 en QA: el byte llegó espejado)")
print()
q = qh_a_qa(msb)
print("cableado QA..QH a los LED D0..D7 (normal):  LED D7..D0 =", q)
print("cableado QA..QH a los LED D7..D0 (espejo):  LED D7..D0 =", q[::-1])

Con el MSB primero, el bit 7 termina en QH, que es lo esperado. Con el LSB primero, el mismo byte queda espejado y se enciende QA. Un cableado «al revés» de los LED produce el mismo efecto: dos errores distintos con el mismo síntoma, y por eso conviene enviar 10000000 para identificar cuál de los dos ocurre.

Paso 3: dos chips en cadena

class HC595:
    def __init__(self):
        self.sr = [0] * 8               # sr[0] = QA ... sr[7] = QH
        self.st = [0] * 8

    def srclk(self, ser):
        self.sr = [ser] + self.sr[:-1]

    def rclk(self):
        self.st = self.sr[:]

    def valor(self):
        return sum(b << i for i, b in enumerate(self.st))


def pulso(chips, ser):
    """Un SRCLK en una cadena: el bit de entrada entra al primero y QH' de cada chip alimenta al siguiente."""
    salientes = [c.sr[7] for c in chips]
    chips[0].srclk(ser)
    for i in range(1, len(chips)):
        chips[i].srclk(salientes[i - 1])


def enviar(chips, palabra, bits):
    for i in range(bits - 1, -1, -1):
        pulso(chips, (palabra >> i) & 1)
    for c in chips:
        c.rclk()                                # RCLK común a todos


U1, U2 = HC595(), HC595()               # U1 recibe del microcontrolador; su QH' va a U2
enviar([U1, U2], 0xA55A, 16)
print(f"16 bits 0xA55A:  U1 = 0x{U1.valor():02X}   U2 = 0x{U2.valor():02X}")

U1, U2 = HC595(), HC595()
enviar([U1, U2], 0xA5, 8)
print(f"solo 8 bits 0xA5: U1 = 0x{U1.valor():02X}   U2 = 0x{U2.valor():02X}   (el segundo chip no recibió nada)")

La palabra 0xA55A de 16 bits se reparte: U1 (el que recibe del microcontrolador) queda con la mitad baja, 0x5A, y U2 con la alta, 0xA5. Si el programa envía solo 8 bits, el byte queda en U1 y U2 permanece en 0. Es el error típico de olvidar que una cadena de dos chips necesita 16 pulsos.

Paso 4: tiempos y corriente de una animación

def cuadros_auto_fantastico(n=8):
    ida = [1 << i for i in range(n)]
    vuelta = ida[-2:0:-1]
    return ida + vuelta


frames = cuadros_auto_fantastico()
print("secuencia de salidas (cada una es un byte enviado):")
for f in frames:
    print(f"  {f:08b}")

f_clk = 1_000_000                              # reloj de desplazamiento
bits = 8
t_envio = bits / f_clk
print()
print(f"enviar un byte a {f_clk/1e6:g} MHz: {t_envio*1e6:g} us")
print(f"cuadros por segundo posibles: {1/t_envio:,.0f}")

vcc, vf = 5.0, 2.0
for r in (330, 1000):
    i = (vcc - vf) / r
    print(f"R = {r:4d} ohm: {i*1000:4.1f} mA por LED, {8*i*1000:5.1f} mA con 8 LED encendidos")

La secuencia de «auto fantástico» tiene 14 cuadros (ida y vuelta), cada uno un byte con un solo bit encendido. A 1 MHz, enviar un byte lleva 8 µs: el cuello de botella nunca es el 595 sino el tiempo que se elija entre cuadros. En corriente, con 330 Ω cada LED toma unos 9 mA (73 mA con los ocho a la vez, demasiado); con 1 kΩ son 3 mA y 24 mA en total. En esta animación hay un solo LED encendido a la vez, pero en el peor caso (todos encendidos) es lo que se debe mirar.

Los tres hechos que el código deja a la vista son los que más errores causan: dos relojes distintos, orden de bits y cantidad de pulsos. En hardware ningún error produce un mensaje; solo un patrón de LED equivocado.

09 · Exploración interactiva

El banco de pruebas

El simulador reproduce uno o dos 74HC595. Con «Pulso SRCLK» desplazás un bit (el valor de SER); con «Pulso RCLK» copiás el desplazamiento a la salida; «Enviar palabra» ejecuta de una vez todos los pulsos de SRCLK, MSB primero, y opcionalmente el RCLK final. Podés activar la cadena de dos chips, habilitar o no las salidas con OE̅ y armar el error clásico de unir RCLK con SRCLK. Las dos filas de la figura son los dos registros internos; los círculos son los LED.

Recorrido guiado

1. Dejá la palabra 10110001 y presioná «Enviar palabra» con «Dar RCLK al terminar»: el desplazamiento y la salida valen 10110001, y se encienden QA, QE, QF y QH.
2. Desmarcá «Dar RCLK al terminar», cambiá la palabra a 01001110 y enviála: el desplazamiento cambia, pero los pines siguen con el dato anterior. Presioná «Pulso RCLK»: ahora sí cambian, todos a la vez.
3. Marcá OE̅ = 1: los pines pasan a «Z» y los LED se apagan. Desmarcalo: el dato reaparece. OE̅ no altera lo guardado.
4. Presioná «SRCLR̅ = 0»: el desplazamiento queda en cero y la salida no cambia. Con «Pulso RCLK» recién se apagan.
5. Enviá 10000000 y mirá cuál LED se enciende: el de QH. Es la prueba rápida para el orden de bits.
6. Con SER = 1 y pulsos manuales de SRCLK, observá cómo el 1 avanza una posición por pulso y a los 8 pulsos aparece por QH′.
7. Marcá «Dos chips en cadena»: ahora son 16 bits. Enviá 1010101111110000: la primera mitad termina en el segundo chip y la segunda en el primero. QH′ del primero alimenta al segundo.
8. Marcá «Error: RCLK unido a SRCLK» y repetí con pulsos manuales: la salida siempre va un paso por detrás del desplazamiento y pasa por los estados intermedios. Es lo que se ve cuando se cablean mal los pines 11 y 12.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de armar

1. Pulsos y destino

Con un solo 595, SER = 1 y ceros en las demás posiciones, ¿en qué salida está el 1 después de 1, 3 y 8 pulsos de SRCLK (sin más datos)? ¿Y cuántos pulsos hacen falta para que aparezca en QH′?

2. Qué bits mandar

Querés encender QA, QC y QH (y nada más). ¿Qué byte enviás, MSB primero, y qué orden de bits aparece en la línea SER?

3. Cadena de tres

Con tres 595 en cadena, ¿cuántos pulsos de SRCLK y de RCLK lleva actualizar todas las salidas? ¿Cuánto tarda a 2 MHz?

4. Cuál chip recibe qué

En una cadena de dos 595 (U1 recibe del microcontrolador, U2 desde QH′ de U1), se envían los 16 bits 0x1234 con el MSB primero. ¿Qué valor queda en cada chip?

5. Corriente

Con LED verdes (Vf ≈ 2,2 V) y 680 Ω, ¿cuánta corriente toma cada LED y el total con los ocho encendidos?

6. Diagnóstico

Enviás 10000000 y se enciende el LED de QA en lugar del de QH. Los otros patrones también aparecen espejados. ¿Cuáles son las dos causas posibles y cómo se distinguen?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 16?

Antes de avanzar, explicá de memoria para qué sirve cada uno de los dos relojes del 595, en qué LED termina el primer bit enviado y cómo se garantiza que las salidas arranquen apagadas. Si podés justificar las tres respuestas, ya podés pasar de sacar datos a leerlos.

En el próximo tema armaremos el taller del 74HC165, el espejo del 595 para las entradas: un registro paralelo-serie que captura 8 interruptores a la vez y los entrega bit a bit.