Taller: entradas con el 74HC165

01 · Punto de partida

El espejo del 595

El 74HC595 era serie-paralelo: bits en fila que se convertían en ocho salidas. El 74HC165 hace el camino inverso: ocho entradas simultáneas que se convierten en una fila de bits. Es el PISO del tema 14 en un chip de 16 patas. La clave es la misma de siempre en este curso: todo el trabajo de «mirar» ocurre en un instante, y la transmisión lenta, bit a bit, se hace sobre una copia ya congelada.

Como en los talleres anteriores, el tema se aprovecha sin materiales: el código reproduce el chip y el laboratorio lo simula con la lectura paso a paso.

02 · Preparación

Materiales y herramientas

El multímetro alcanza para el montaje a mano. Con un analizador lógico de 3 canales (PL̅, CP y Q7) vas a ver la lectura entera de un vistazo. Dibujá el esquema con los números de pin: en el 165 las entradas D0..D7 están repartidas en los dos lados del chip, no en orden.

Antes de dar tensión

• Un 100 nF entre Vcc (pin 16) y GND (pin 8), pegado al chip.
• CE̅ (pin 15) a masa y DS (pin 10) a masa en los primeros montajes.
• Ninguna entrada D al aire: las ocho tienen su resistencia a masa (o a +5 V), esté o no el interruptor conectado.
• PL̅ (pin 1) en +5 V por una resistencia: en reposo no debe estar cargando.

03 · El chip

Pines del 74HC165

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 entradas D4..D7 están en los pines 3 a 6 y D0..D3 en los pines 11 a 14:

Algunos fabricantes llaman SH/LD̅ al pin 1 y CLK INH al pin 15. La función es la misma.

Cómo se comporta

Dos diferencias con el 595 conviene tener presentes. Primero, la carga paralela es asíncrona: mientras PL̅ esté en bajo, el registro sigue a las entradas y el reloj se ignora; la «foto» queda tomada cuando PL̅ vuelve a subir. Segundo, no hay registro de salida: Q7 es el último flip-flop del propio desplazamiento, así que cambia con cada flanco de CP.

04 · Montaje 1

Leer ocho interruptores

Reutilizamos el reloj manual de NAND de los talleres anteriores para CP. El pulsador de PL̅ no necesita antirrebote: cada rebote vuelve a cargar los mismos interruptores y el resultado no cambia.

Pruebas

Tené presente el orden: el primer bit que sale es D7. El microcontrolador debe leer Q7 antes de dar el flanco de CP, porque el flanco desplaza y haría perder ese bit.

05 · Montaje 2

Dos chips en cadena

La salida Q7 de un chip se conecta a la entrada DS del siguiente: cuando el primero termina de entregar sus bits, los del vecino quedan detrás. Ambos chips comparten CP y PL̅, de modo que se cargan y desplazan a la vez. El microcontrolador lee el Q7 del último chip de la cadena.

La lectura completa son 16 pulsos de CP después de un PL̅. Los primeros 8 bits que salen son los de U3 (D7..D0), y los 8 siguientes, los de U2. Si se leen solo 8 bits, el microcontrolador ve únicamente el chip que está al final de la cadena y nunca el otro. Es la imagen especular de lo que ocurría con el 595, donde los primeros 8 bits enviados terminaban en el último chip.

06 · Montaje 3

Pulsadores y lectura estable

Los interruptores del montaje 1 son «estables»: nadie los mueve mientras se lee. Los pulsadores no lo son. Ocurren dos cosas distintas: la lógica cambia de signo y el contacto rebota.

Lógica negativa

Es más cómodo conectar un pulsador entre la entrada y masa, con una resistencia de 10 kΩ a +5 V (pull-up). En reposo la entrada lee 1; al pulsar, lee 0. Los bits «activos» valen 0. En el programa se invierte la lectura (XOR con 0xFF) para trabajar con 1 = pulsado.

Rebotes: leer hasta que se repita

Un pulsador rebota unos milisegundos (tema 7). Si el programa lee justo en ese momento, puede obtener un valor intermedio. Hay dos defensas, que se pueden combinar: el filtro RC de arriba y una lectura por software que exige varias lecturas iguales seguidas antes de aceptar el valor (en el código, 3). Como un byte entero se lee en microsegundos, tres lecturas consecutivas cubren apenas unas decenas de µs: para que el filtro por software sirva, las lecturas deben espaciarse unos milisegundos.

Pruebas

• Reposo: sin pulsar nada, la lectura cruda debe ser 11111111 (todo en alto).
• Un pulsador: con D3 apretado, la lectura cruda es 11110111; invertida, 00001000.
• Dos pulsadores a la vez: ambos bits aparecen en la misma lectura, porque todas las entradas se capturan en el mismo instante.
• Pulsar sin soltar: la lectura no cambia entre dos lecturas consecutivas; el programa no debe contar una pulsación por cada lectura, sino un evento por cambio.

07 · Cuando no funciona

Fallas y método

Armar por etapas

1. Alimentación primero: Vcc, GND y el 100 nF en cada chip.
2. Atar todas las entradas, también las de interruptores que no se conecten.
3. Probar la carga sola: con PL̅ pulsado, Q7 debe copiar D7 al instante.
4. Probar el desplazamiento: un pulso de CP por vez y anotar cada bit.
5. Un chip antes que dos: terminar el montaje 1 antes de encadenar.
6. Cambiar una sola cosa a la vez cuando algo falla, y comparar el byte observado con el esperado.

08 · El taller en código

Cargar, desplazar y detectar cambios

Los bloques reproducen el 74HC165 con su carga y su desplazamiento, encadenan dos chips, muestran cómo se obtiene una lectura estable con pulsadores de lógica negativa y detectan pulsaciones y liberaciones comparando lecturas con XOR.

Paso 1: carga paralela y lectura serie

class HC165:
    """74HC165: registro paralelo-serie. sr[0] = Q0 ... sr[7] = Q7 (la salida serie)."""

    def __init__(self):
        self.sr = [0] * 8
        self.ds = 0                          # entrada serie (pin 10)

    def carga(self, entradas):               # PL̅ = 0: carga asíncrona de D0..D7
        self.sr = [(entradas >> i) & 1 for i in range(8)]

    def clk(self):                           # flanco ascendente de CP con CE̅ = 0
        salida = self.sr[7]
        self.sr = [self.ds] + self.sr[:-1]
        return salida

    @property
    def q7(self):
        return self.sr[7]


def leer(chip, entradas):
    chip.carga(entradas)                     # 1) pulso en PL̅: congela las 8 entradas
    valor = 0
    for _ in range(8):
        valor = (valor << 1) | chip.q7       # 2) se lee Q7 y después se da el reloj
        chip.clk()
    return valor


c = HC165()
interruptores = 0b10110010
print(f"entradas D7..D0 = {interruptores:08b}")
c.carga(interruptores)
print("bit leído en cada paso (Q7 antes del reloj):")
bits = []
for i in range(8):
    bits.append(c.q7)
    print(f"  pulso {i}: Q7 = {c.q7}  (corresponde a D{7 - i})")
    c.clk()
print("byte reconstruido:", "".join(map(str, bits)), "=", f"0x{int(''.join(map(str, bits)), 2):02X}")
print("lectura con leer():", f"{leer(HC165(), interruptores):08b}")

Con los interruptores en 10110010, el primer bit leído es D7 y el último D0: el byte se reconstruye como 0xB2 sin ninguna reordenación. El orden «leer Q7 y después dar el reloj» es el que no pierde el bit D7. Probá invertir esas dos líneas dentro de leer() y verificá que el resultado pasa a ser 0x64.

Paso 2: dos chips en cadena

class HC165:
    def __init__(self):
        self.sr = [0] * 8
        self.ds = 0

    def carga(self, entradas):
        self.sr = [(entradas >> i) & 1 for i in range(8)]

    def clk(self):
        self.sr = [self.ds] + self.sr[:-1]


def clk_cadena(chips):
    """Q7 de cada chip alimenta DS del siguiente; el micro lee el Q7 del último."""
    salientes = [c.sr[7] for c in chips]
    for i, c in enumerate(chips):
        c.ds = salientes[i - 1] if i > 0 else 0
        c.clk()


def leer(chips, entradas, bits):
    for i, c in enumerate(chips):
        c.carga((entradas[i]))
    valor = 0
    for _ in range(bits):
        valor = (valor << 1) | chips[-1].sr[7]
        clk_cadena(chips)
    return valor


A, B = HC165(), HC165()                    # A: su Q7 va al DS de B; el micro lee Q7 de B
cadena = [A, B]
entradas = [0xA5, 0x3C]                    # A tiene 0xA5 en sus interruptores, B tiene 0x3C
print(f"16 pulsos: leído = 0x{leer(cadena, entradas, 16):04X}   (B = 0x3C primero, luego A = 0xA5)")
A, B = HC165(), HC165()
cadena = [A, B]
print(f" 8 pulsos: leído = 0x{leer(cadena, entradas, 8):02X}   (solo llegó el chip B; A no se vio)")

Con 16 pulsos el microcontrolador recibe 0x3CA5: primero los bits del chip final (B, 0x3C) y después los del chip anterior (A, 0xA5). Con solo 8 pulsos aparece únicamente 0x3C y el chip A permanece invisible. La palabra de 16 bits se arma en el programa en el orden en que llegan los bytes.

Paso 3: rebotes, lectura estable y lógica negativa

import random

rnd = random.Random(7)


def lectura_estable(muestra, repeticiones=3):
    ultimo, cuenta, lecturas = None, 0, 0
    while cuenta < repeticiones:
        lecturas += 1
        v = muestra()
        cuenta = cuenta + 1 if v == ultimo else 1
        ultimo = v
    return ultimo, lecturas


# Un contacto que acaba de cerrarse y todavía rebota
ruido = lambda: 0b00000001 | (rnd.randint(0, 1) << 3)
print("lecturas sueltas de un contacto que rebota:", *(f"{ruido():08b}" for _ in range(5)))
print("lectura estable (3 iguales seguidas):      ", end=" ")
v, n = lectura_estable(ruido, 3)
print(f"{v:08b} tras {n} lecturas")

# Pulsadores con pull-up: leen 1 en reposo y 0 al pulsar (lógica negativa)
crudo = 0b11110111                    # el pulsador 3 está apretado
print(f"\ncrudo (pull-up):  {crudo:08b}  -> activos en bajo")
print(f"invertido en SW:  {crudo ^ 0xFF:08b}  -> 1 = pulsado")

El bit 0 es estable (siempre 1) y el bit 3 oscila, como un contacto que todavía rebota. Las lecturas sueltas alternan entre 00000001 y 00001001; la lectura estable espera tres iguales seguidas y entrega 00000001 tras 5 lecturas. Con pull-up, el pulsador 3 apretado se lee 11110111 y, tras el XOR con 0xFF, 00001000: un 1 donde hay pulsación. Cambiá la semilla y la cantidad de repeticiones para ver cuánto cuesta (en lecturas) una mayor confianza.

Paso 4: detectar eventos con XOR

anterior = 0b00000000
lecturas = [0b00000000, 0b00000100, 0b00000100, 0b00001100, 0b00001000, 0b00001000]
print("lectura    cambios    pulsaciones   liberaciones")
for v in lecturas:
    cambios = anterior ^ v
    pulsa = cambios & v                # pasó de 0 a 1
    suelta = cambios & anterior        # pasó de 1 a 0
    print(f"{v:08b}   {cambios:08b}   {pulsa:08b}      {suelta:08b}")
    anterior = v

f_clk = 1_000_000
for chips in (1, 2, 4):
    bits = 8 * chips
    t = bits / f_clk
    print(f"{chips} chip(s): {bits:2d} bits, {t*1e6:4.0f} us por lectura, hasta {1/t:,.0f} lecturas/s")

Con XOR entre la lectura nueva y la anterior se obtiene un 1 en cada bit que cambió. Al combinarlo con & se separan las pulsaciones (el bit 2 aparece en la segunda lectura y el 3 en la cuarta) de las liberaciones (el bit 2 se suelta en la quinta). Mientras el botón sigue apretado, la lectura repetida no produce eventos nuevos. En cuanto a velocidad, un chip se lee en 8 µs a 1 MHz (125 000 lecturas por segundo) y cuatro en 32 µs: sobra para cualquier teclado humano.

Es la misma técnica que se usa en el software de teclados y paneles: no importa cuántas lecturas se hagan, solo los cambios generan acciones.

09 · Exploración interactiva

El banco de pruebas

El simulador reproduce uno o dos 74HC165. Escribís el valor de las entradas (el campo de texto equivale a los interruptores), cargás el registro con «PL̅ = 0» y leés bit a bit con «Pulso CP», o hacés una lectura completa de una vez. El panel muestra la fila de entradas, el registro interno con Q7 resaltado y los bits que ya recibió el microcontrolador. Podés cambiar las entradas después de cargar para ver que el registro conserva la foto, leer sin cargar para ver qué sale en ese caso, e inhibir el reloj con CE̅.

Recorrido guiado

1. Con las entradas en 10110010, presioná «PL̅ = 0 (cargar)»: el registro vale lo mismo que las entradas y Q7 = 1 sin haber dado ningún reloj.
2. Presioná «Leer Q7 y pulso CP» ocho veces: los bits recibidos van formando 10110010. Fijate en que el primero fue D7 y el último D0.
3. Después del octavo pulso el registro está vacío (se llenó con los ceros de DS). Dos pulsos más empiezan una lectura nueva con datos que ya no son los de las entradas.
4. Cargá de nuevo y cambiá el texto de las entradas a 00000001 sin volver a cargar: «¿Lectura al día?» pasa a «No». El registro conserva la foto.
5. Presioná «Lectura completa»: hace el PL̅ y los ocho CP seguidos, y ahora la lectura coincide con las entradas actuales.
6. Probá «Leer sin cargar (error)»: sale lo que quedaba en el registro, no las entradas. En el hardware real es el error de olvidarse del pulso de PL̅.
7. Marcá CE̅ = 1 y pulsá CP: nada se mueve. Desmarcalo y el desplazamiento continúa. Marcá DS = 1 y mirá cómo entran unos por Q0 en lugar de ceros.
8. Marcá «Dos chips en cadena»: las entradas son ahora 16 bits (el byte alto es el del chip del final). La lectura completa necesita 16 pulsos y entrega primero el byte alto.

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de armar

1. Qué sale en cada pulso

Los interruptores están en D7..D0 = 01101001 y DS = 0. Después de PL̅, ¿cuál es el valor de Q7 antes de cada uno de los ocho pulsos de CP, y qué queda en el registro tras el octavo?

2. Cadena de dos

U2 (DS a masa) tiene 0x5A en sus interruptores y U3 (DS ← Q7 de U2, se lee Q7 de U3) tiene 0xC3. ¿Qué palabra de 16 bits recibe el microcontrolador con 16 pulsos? ¿Y con solo 8?

3. Tiempo de lectura

Una botonera de 32 pulsadores se lee con cuatro 165 en cadena y un reloj de 4 MHz. ¿Cuánto dura una lectura y cuántas se pueden hacer por segundo?

4. Lógica negativa

Con pull-ups, la lectura cruda es 11011110. ¿Qué pulsadores están apretados?

5. Eventos con XOR

La lectura anterior fue 00110000 y la nueva es 01010000. ¿Qué cambió, qué se pulsó y qué se soltó?

6. Diagnóstico

La lectura da siempre 11111111 cuando el interruptor de D7 está cerrado y siempre 00000000 cuando está abierto, sin importar cómo estén los demás, y los bits no cambian al dar el reloj. ¿Qué pasa?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 17?

Antes de avanzar, explicá de memoria qué hace PL̅ y qué hace CP, por qué se lee Q7 antes de dar el reloj y cómo se detecta una pulsación nueva a partir de dos lecturas. Si podés justificar las tres respuestas, ya podés pasar de mover bits a contar con ellos.

En el próximo tema veremos los contadores asíncronos: cómo encadenar flip-flops T para que cada uno divida la frecuencia por dos y el conjunto cuente pulsos en binario.