Generación de señales y PWM

01 · Punto de partida

Del reloj a la señal que necesitás

Casi todo el hardware digital del curso necesita una señal de reloj. Y muchas aplicaciones necesitan, además, señales con características especiales: una frecuencia exacta, un ancho de pulso ajustable, una secuencia de períodos distintos. Generarlas es una cadena de tres pasos:

El último paso es el nuevo y es el que da nombre al tema. El resultado es una señal cuadrada de frecuencia fija y ciclo de trabajo variable, que se puede usar directamente (para encender y apagar una carga con un transistor) o filtrar para obtener una tensión continua proporcional.

02 · Osciladores

Osciladores

Un oscilador es un circuito con realimentación que produce una señal periódica sin entrada externa. Hay cuatro familias que ya viste o vas a ver:

Oscilador RC con inversor Schmitt

Es el oscilador más barato: un 74HC14, una resistencia R de la salida a la entrada y un condensador C de la entrada a masa. Si la salida está en 1, el condensador se carga por R hasta el umbral superior V_T+; el inversor conmuta, la salida pasa a 0 y el condensador se descarga hasta V_T−; vuelve a conmutar, y así sin fin. Con los umbrales típicos de un 74HC14 a 5 V (V_T+ ≈ 2,7 V, V_T− ≈ 1,8 V), el período es unas 0,73 · R · C, o sea f ≈ 1 / (0,73 · R · C). Pero esos umbrales varían mucho entre chips: la frecuencia puede cambiar a la mitad o al doble sin que cambie el circuito. Sirve para señales que no necesitan exactitud.

Cristal

Para una frecuencia que no se mueva, se usa un cristal. Lleva un circuito oscilador de pocos componentes: un inversor sin búfer (74HCU04), una resistencia de realimentación de 1 MΩ, el cristal y dos condensadores de carga de 15 a 33 pF a masa (el valor exacto lo indica el fabricante del cristal). Hay también osciladores completos en una lata de cuatro patas (alimentación, masa y salida), listos para usar, más caros pero sin sorpresas. La precisión del cristal se mide en partes por millón: 20 ppm son 1,73 segundos de error por día.

03 · Divisores

Divisores de frecuencia

Los contadores de los temas 17 a 19 son divisores: cada etapa binaria divide la frecuencia por dos; cada década, por diez. Con ellos se obtiene cualquier frecuencia submúltiplo de la base con la misma precisión que la base.

De 32 768 Hz, quince divisiones por dos dan exactamente 1 Hz (tema 17). Para dividir por un número que no es potencia de dos ni de diez, se usa un contador módulo N (tema 19).

• Ciclo de trabajo del 50 %: la salida de un divisor binario tiene 50 % de ciclo de trabajo. La de un módulo N no. Para dividir por N par y mantener el 50 %, se divide por N/2 con el contador y se pasa la salida por un flip-flop T. Para N impar, solo se logra con los dos flancos del reloj.
• Retardo acumulado: en un divisor ripple, la última salida cambia varias decenas de ns después del reloj de entrada; eso afecta a su fase, no a su frecuencia. Si interesa la fase, se usa un contador síncrono.

04 · PWM

PWM: ancho de pulso variable

Una señal PWM (pulse-width modulation) es una onda cuadrada de frecuencia fija cuyo ciclo de trabajo D (la fracción del período en alto) se varía. Lo que ve una carga lenta (un LED visto a simple vista, un motor con inercia, un filtro RC) es el promedio:

La gran ventaja es la eficiencia. Para atenuar una carga con un nivel intermedio de tensión (un regulador lineal, un transistor en zona activa), el transistor disipa la diferencia en calor. Con PWM, el transistor está siempre en un extremo: apagado (sin corriente) o saturado (casi sin caída). Casi no disipa nada, y por eso se usa para controlar motores, calefactores y LED de potencia.

La frecuencia del PWM se elige según la carga:

05 · PWM digital

PWM digital: contador y comparador

La forma digital de generar un PWM no necesita componentes analógicos. Hacen falta tres bloques:

1. Un contador libre de n bits (tema 18), que recorre 0, 1, 2, … 2ⁿ − 1 y vuelve a 0 sin parar.
2. Un registro de umbral de n bits (tema 13), que guarda el valor deseado, de 0 a 2ⁿ.
3. Un comparador de n bits (como el 74HC85 o el 74HC688), cuya salida es 1 mientras cuenta < umbral.

Al comenzar cada período el contador vale 0 y la salida es 1 (si el umbral no es 0); cuando la cuenta alcanza el umbral, la salida baja y se mantiene en 0 hasta que el contador da la vuelta. El ciclo de trabajo es umbral / 2ⁿ, y los n bits del umbral son el valor que se carga desde un microcontrolador, unos interruptores o un sensor.

Resolución frente a frecuencia

Con un reloj fijo hay un compromiso inevitable: más bits dan más niveles de ciclo de trabajo, pero el contador tarda más en dar la vuelta, así que la frecuencia del PWM baja. Al revés, para tener una frecuencia dada con n bits, el reloj debe ser f_PWM · 2ⁿ.

Detalles que se pagan caros

• El extremo del comparador: con «cuenta < umbral», el umbral 0 da 0 % y el umbral 2ⁿ da 100 %. Con «cuenta ≤ umbral», el 0 % es imposible (siempre queda un pulso de una cuenta) y el 100 % se alcanza con el máximo. Hay que saber cuál se implementó.
• Cambiar el umbral en medio de un período: si el nuevo valor se escribe mientras el contador ya pasó (o todavía no pasó) el valor viejo, el comparador puede entregar dos pulsos en el mismo período, o ninguno, o uno de ancho equivocado. La salida de ese período no corresponde ni al valor viejo ni al nuevo.
• La solución es un doble búfer: el valor nuevo se escribe en un registro de espera y se transfiere al registro de umbral solo cuando el contador vuelve a 0 (una vez por período), igual que en el registro de salida del 74HC595 (tema 15). El comparador siempre ve un valor estable durante todo el período.

Los microcontroladores traen este circuito integrado como un periférico (timer con modo PWM): los registros de «período» y «comparación» son exactamente el contador y el umbral, y el doble búfer viene incluido.

06 · Filtro

De PWM a tensión: el filtro RC

Si en vez de una carga lenta se pone un filtro pasa-bajos (una resistencia y un condensador), la salida es una tensión continua casi igual a D · Vcc: un conversor digital-analógico de bajo costo. El filtro no elimina la señal por completo: queda un rizado a la frecuencia del PWM, que será menor cuanto más lento sea el filtro.

El compromiso es evidente: menos rizado exige un filtro más lento. Con un solo polo RC, para que el rizado quede por debajo del paso del PWM de 8 bits (19,5 mV) hay que asentar en cientos de milisegundos. Quien necesita una buena conversión usa un filtro de más polos, una frecuencia de PWM mayor o directamente un conversor D/A dedicado. Además, la salida del filtro tiene impedancia (R): conectarla a una carga baja la tensión, y conviene un seguidor de tensión (un amplificador operacional) para entregarla.

07 · Aplicaciones

Aplicaciones: LED, motor y servo

Brillo de un LED

La salida PWM maneja un LED (con su resistencia) directamente, o un transistor si es de potencia. A 1 kHz el ojo ve un brillo proporcional a D. Pero la percepción de brillo es aproximadamente logarítmica: pasar de 5 % a 10 % se ve como un salto grande, y de 90 % a 95 %, casi nada. Para que una rampa «parezca» lineal, el valor de umbral no va derecho al comparador sino a través de una tabla de corrección (gamma), que no es más que una ROM de consulta (tema 28).

Velocidad de un motor de continua

Un transistor de potencia (un MOSFET) conmuta la alimentación del motor con el PWM. La inercia mecánica y la inductancia del motor promedian la corriente, así que la velocidad es aproximadamente proporcional a D. Detalles imprescindibles: un diodo en antiparalelo con el motor (flyback) para absorber la tensión que genera la inductancia al apagar, y una frecuencia por encima de lo audible (por ejemplo 20 kHz) para que el motor no silbe.

Servo

Un servo de aeromodelismo espera pulsos cada 20 ms (50 Hz), con un ancho de 1 ms (un extremo), 1,5 ms (el centro) o 2 ms (el otro extremo). No es un PWM de «brillo»: el ancho del pulso codifica una posición. Con un reloj de 1 MHz, el contador cuenta 20 000 para el período y el umbral va de 1000 a 2000: una resolución de 1000 pasos en el recorrido. El contador se hace módulo 20 000 (tema 19), no 2ⁿ.

Sonido y tonos

Un oscilador y un divisor generan notas musicales: la frecuencia de una nota se obtiene dividiendo una base con un contador módulo N. Con PWM de ciclo de trabajo variable se pueden construir formas de onda de audio sencillas (tema 28: la tabla de seno, recorrida por un contador, alimenta el umbral).

08 · Las señales en código

Osciladores, divisores, PWM y filtro

Los bloques calculan la frecuencia de un oscilador de Schmitt para distintos umbrales, encadenan divisores, implementan el PWM con contador y comparador (incluyendo la actualización a destiempo) y simulan el filtro RC para ver rizado y tiempo de asentamiento.

Paso 1: el oscilador con inversor Schmitt

from math import log

VCC, VT_ALTO, VT_BAJO = 5.0, 2.7, 1.8             # umbrales típicos de un 74HC14 a 5 V (varían entre chips)


def oscilador_schmitt(R, C, vt_alto=VT_ALTO, vt_bajo=VT_BAJO):
    """Inversor Schmitt con R de la salida a la entrada y C de la entrada a masa."""
    t_sube = R * C * log((VCC - vt_bajo) / (VCC - vt_alto))        # la entrada sube de VT- a VT+ (salida alta)
    t_baja = R * C * log(vt_alto / vt_bajo)                        # la entrada baja de VT+ a VT- (salida baja)
    T = t_sube + t_baja
    return 1 / T, t_sube / T


R, C = 10e3, 10e-9
f, d = oscilador_schmitt(R, C)
print(f"R = 10 kΩ, C = 10 nF: f = {f / 1e3:.2f} kHz, ciclo de trabajo {d * 100:.1f} %  (regla práctica: f ≈ 1/(0,73·R·C) = {1 / (0.73 * R * C) / 1e3:.2f} kHz)")

print("\nla frecuencia depende de los umbrales, que varían de un chip a otro:")
for texto, vh, vl in (("umbrales típicos", 2.7, 1.8), ("histéresis estrecha", 2.4, 2.0), ("histéresis ancha", 3.0, 1.5)):
    f, d = oscilador_schmitt(R, C, vh, vl)
    print(f"  {texto:20s}: VT+ = {vh} V, VT- = {vl} V -> f = {f / 1e3:5.2f} kHz, ciclo de trabajo {d * 100:5.1f} %")

print()
print("cristales usuales:")
for f_cristal, uso in ((32768, "reloj de tiempo real (2^15)"), (1_000_000, "contador decimal"), (4_000_000, "microcontrolador sencillo"), (16_000_000, "microcontrolador")):
    print(f"  {f_cristal / 1e6:9.6f} MHz  ({uso})")
print()
print("error de tiempo acumulado por la tolerancia del cristal (no depende de la frecuencia):")
for ppm in (10, 20, 50, 100):
    print(f"  ±{ppm:3d} ppm: ±{ppm * 1e-6 * 86400:6.2f} s por día, ±{ppm * 1e-6 * 86400 * 30 / 60:5.1f} min por mes")

Con R = 10 kΩ y C = 10 nF y los umbrales típicos, el oscilador de Schmitt da unos 13,6 kHz con 44,9 % de ciclo de trabajo, coincidente con la regla práctica (13,7 kHz). Pero con una histéresis estrecha (2,4 y 2,0 V) llega a 30,7 kHz, y con una ancha (3,0 y 1,5 V), a 8,0 kHz: la misma R y la misma C, un factor casi 4 de diferencia entre chips. Un cristal de 20 ppm, en cambio, se desvía menos de 2 segundos por día, tenga la frecuencia que tenga.

Paso 2: cadenas de divisores

f = 1_000_000.0
print(f"de {f / 1e6:g} MHz a 1 Hz con seis décadas (÷10 cada una):")
for k in range(1, 7):
    f /= 10
    print(f"  tras {k} década(s): {f:>12,.3f} Hz   período {1 / f:>10,.6f} s")

print()
f = 32768.0
print("de 32 768 Hz a 1 Hz con 15 divisiones por dos:")
for k in (1, 5, 10, 14, 15):
    print(f"  ÷2^{k:2d} = ÷{2 ** k:>6d}: {f / 2 ** k:>10.3f} Hz")

print()
print("dividir por N con ciclo de trabajo del 50 %:")
for N in (4, 6, 10, 12):
    print(f"  ÷{N:2d}: contador módulo {N // 2} y un flip-flop T al final -> duty {50}.0 % (salida de f/{N})")
print("  ÷ 5 (impar): un contador módulo 5 da duty 20 % (1 de 5 pulsos); para 50 % exacto hace falta usar los dos flancos del reloj")

print()
print("un divisor ripple de n etapas y un divisor síncrono llegan al mismo cociente, pero:")
n, tpd = 20, 12e-9
print(f"  ripple de {n} etapas: la última salida cambia {n * tpd * 1e9:.0f} ns después del flanco de entrada (retardo acumulado)")
print("  la frecuencia de la última salida es la misma; el retardo no afecta a la frecuencia sino a la fase")

Seis décadas llevan 1 MHz a 1 Hz exacto (con períodos de 10 µs, 100 µs, 1 ms, 10 ms, 100 ms y 1 s). Quince divisiones por dos llevan 32 768 Hz a 1 Hz. Para dividir por N par con 50 % de ciclo, un contador módulo N/2 más un flip-flop T. Un divisor ripple de 20 etapas tarda unos 240 ns en que su última salida responda al flanco de entrada, un retardo de fase que no cambia la frecuencia.

Paso 3: PWM con contador y comparador

def pwm(n_bits, umbral, periodos=2, estricto=True):
    """Contador libre de n bits y comparador: salida = (cuenta < umbral)  [o <= si estricto es False]."""
    N = 2 ** n_bits
    salida = []
    for k in range(periodos * N):
        c = k % N
        salida.append(int(c < umbral) if estricto else int(c <= umbral))
    return salida, N


VCC = 5.0
print("PWM de 8 bits (256 niveles): ciclo de trabajo y tensión media")
for umbral in (0, 1, 64, 128, 192, 255, 256):
    sal, N = pwm(8, umbral, 1)
    duty = sum(sal) / N
    print(f"  umbral {umbral:3d}: duty = {duty * 100:6.2f} %   Vmedia = {duty * VCC:5.3f} V")

print()
sal, N = pwm(8, 0, 1, estricto=False)
print(f"con 'cuenta <= umbral' y umbral 0: duty = {sum(sal) / N * 100:.2f} %  (nunca llega a 0 %: queda un pulso de 1 ciclo)")
sal, N = pwm(8, 255, 1, estricto=False)
print(f"con 'cuenta <= umbral' y umbral 255: duty = {sum(sal) / N * 100:.2f} %  (100 % solo con el máximo)")

print()
print("frecuencia del PWM y resolución según el reloj y los bits (reloj de 1 MHz):")
print("  bits  niveles  f_PWM        paso de tensión (5 V)")
for n in (4, 6, 8, 10, 12):
    print(f"  {n:4d}  {2 ** n:7d}  {1e6 / 2 ** n:9.1f} Hz   {VCC / 2 ** n * 1000:7.2f} mV")

print()
# cambiar el umbral en medio del período (sin sincronizar) produce un ancho incorrecto
N = 16
A, B = 4, 12
cuentas, thr, sal = [], A, []
for k in range(3 * N):
    c = k % N
    if k == 1 * N + 8:                           # a mitad del segundo período se escribe el nuevo valor
        thr = B
    cuentas.append(c)
    sal.append(int(c < thr))
print("umbral 4 -> 12 escrito a mitad del período 2 (reloj de 16 cuentas por período), sin sincronizar:")
for p in range(3):
    tramo = sal[p * N:(p + 1) * N]
    print(f"  período {p}: {''.join(map(str, tramo))}   ({sum(tramo)} de {N} en alto)")
print("el período 1 tiene DOS pulsos (4 + 4 de 16): ancho 8/16 = 50 %, ni el 25 % anterior ni el 75 % nuevo")
sal2 = []
thr = A
pend = None
for k in range(3 * N):
    c = k % N
    if k == 1 * N + 8:
        pend = B                                 # el valor nuevo queda en un registro de espera
    if c == 0 and pend is not None:
        thr, pend = pend, None                   # se carga al terminar el período
    sal2.append(int(c < thr))
print("con registro de espera (se carga cuando el contador vuelve a 0):")
for p in range(3):
    tramo = sal2[p * N:(p + 1) * N]
    print(f"  período {p}: {''.join(map(str, tramo))}   ({sum(tramo)} de {N} en alto)")

Un contador de 8 bits y un comparador dan 0 %, 0,39 %, 25 %, 50 %, 75 % y 99,61 % para los umbrales 0, 1, 64, 128, 192 y 255 (y 100 % con 256). Con «≤» el 0 % ya no existe: queda un pulso de 1 cuenta. A 1 MHz, 8 bits dan 3906 Hz con pasos de 19,5 mV, y 12 bits bajan a 244 Hz con pasos de 1,22 mV. Al cambiar el umbral de 4 a 12 en medio del período, la salida tiene dos pulsos de 4 y un ancho total de 8/16 = 50 %: ni el 25 % anterior ni el 75 % nuevo. Con el registro de espera, el período 1 conserva el 25 % y el cambio ocurre limpio al comienzo del período 2.

Paso 4: filtro RC y servo

from math import pi


def filtro_rc(salida_pwm, f_clk, R, C, v_alto=5.0):
    v, dt, trazas = 0.0, 1 / f_clk, []
    for s in salida_pwm:
        v += (s * v_alto - v) * dt / (R * C)
        trazas.append(v)
    return trazas


f_clk = 1_000_000
n = 8
N = 2 ** n
f_pwm = f_clk / N
duty = 0.25
umbral = int(duty * N)
print(f"PWM de {n} bits a reloj {f_clk / 1e6:g} MHz: f_PWM = {f_pwm:.0f} Hz, duty {duty * 100:.0f} %, Vcc = 5 V\n")
print("filtro RC pasa-bajos:  fc = 1/(2·π·R·C);  rizado pico a pico ≈ Vcc·D·(1−D)/(f·R·C);  asentamiento ≈ 5·R·C")
print("  R        C       RC        fc        rizado calculado   rizado simulado   asentamiento")
for R, C in ((1e3, 100e-9), (10e3, 100e-9), (10e3, 1e-6), (47e3, 1e-6)):
    # simulamos hasta que se estabiliza
    pasos = int(8 * R * C * f_clk + 4 * N)
    salida = [int((k % N) < umbral) for k in range(pasos)]
    v = filtro_rc(salida, f_clk, R, C)
    ultimo = v[-2 * N:]
    riz_sim = max(ultimo) - min(ultimo)
    riz = 5.0 * duty * (1 - duty) / (f_pwm * R * C)
    fc = 1 / (2 * pi * R * C)
    print(f"  {R / 1e3:5.0f}k  {C * 1e9:6.0f}n  {R * C * 1e3:7.2f}ms  {fc:7.1f} Hz  {riz * 1000:12.1f} mV   {riz_sim * 1000:12.1f} mV   {5 * R * C * 1e3:8.1f} ms")
print()
print("promedio esperado: duty x Vcc =", duty * 5.0, "V. Menor rizado exige RC mayor y una respuesta más lenta (compromiso).")

# servo: 50 Hz, pulso de 1 a 2 ms
f_clk = 1_000_000
periodo_cuentas = 20_000                          # 20 ms
print(f"\nservo con reloj de 1 MHz: período = {periodo_cuentas} cuentas = 20 ms (50 Hz)")
for ms, ang in ((1.0, 0), (1.5, 90), (2.0, 180)):
    cuentas = int(ms * 1e-3 * f_clk)
    print(f"  pulso de {ms} ms -> {cuentas} cuentas -> ~{ang}°")
print("resolución del pulso: 1 µs por cuenta -> 1000 pasos entre 1 y 2 ms; un contador de 16 bits alcanza (módulo 20 000)")

Con duty del 25 % y f_PWM de 3906 Hz, el rizado a la salida de un filtro RC cae de unos 2,2 V (con 1 kΩ y 100 nF, un filtro casi inútil) a 240 mV (10 kΩ y 100 nF), 24 mV (10 kΩ y 1 µF) y 5,1 mV (47 kΩ y 1 µF), al precio de asentar en 235 ms. La fórmula coincide con la simulación cuando el filtro es lento respecto del PWM. Para el servo, un reloj de 1 MHz da 1000 cuentas para 1 ms, 1500 para el centro y 2000 para 2 ms, con 1000 pasos de resolución.

Los cuatro bloques recorren la cadena completa: una frecuencia base, una división exacta, un ancho ajustable y, si hace falta, una tensión continua.

09 · Exploración interactiva

El laboratorio: generador de PWM

El simulador implementa el PWM digital: un contador libre de n bits (la rampa verde), un umbral (la línea naranja punteada) y un comparador cuya salida es la señal inferior. Elegís los bits (4 a 10), el reloj y el umbral A; con la casilla «Cambiar de A a B» el umbral cambia a B en mitad del segundo período, y con «Registro de espera» ese cambio se aplica solo al comenzar el período siguiente. El panel muestra la frecuencia, el ciclo de trabajo de cada período, la resolución y los datos de un filtro RC a la salida.

Recorrido guiado

1. Con 5 bits, reloj de 1 MHz y A = 8: el PWM sale a 31,25 kHz con 25 % de ciclo de trabajo (8 de 32), tensión media 1,25 V y pasos de 156 mV. Subí A a 16: 50 % y 2,5 V.
2. Subí los bits a 8: aparecen 256 niveles, la frecuencia baja a 3,9 kHz y el paso de tensión a 19,5 mV. Más resolución, menos frecuencia: el compromiso del contador.
3. Subí el reloj a 16 MHz con 8 bits: la frecuencia vuelve a 62,5 kHz. Para tener a la vez alta frecuencia y alta resolución hace falta un reloj rápido.
4. Volvé a 5 bits y marcá «Cambiar de A a B» (A = 8, B = 24) sin registro de espera: el período 2 sale con 50 % y dos pulsos, ni 25 % ni 75 %. Es el defecto de actualizar a destiempo.
5. Marcá «Registro de espera»: el período 2 conserva el 25 % y el 3 ya sale con el 75 %. El cambio ocurre limpio al comienzo del período siguiente.
6. Con A = 0, probá «≤» en vez de «<»: el ciclo de trabajo no baja de 1/2ⁿ. Con «<» sí llega a 0 %.
7. Con 8 bits, A = 64 y el filtro en 10 kΩ y 1 µF: rizado de unos 24 mV, asentamiento de 50 ms. Bajá C a 100 nF y el rizado sube diez veces mientras el asentamiento baja a 5 ms.
8. Subí el reloj a 10 MHz con 8 bits: la frecuencia sube y el mismo filtro rinde mucho mejor (rizado inversamente proporcional a f_PWM).

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Predecí antes de simular

1. Frecuencia del PWM

Un contador de 10 bits cuenta con un reloj de 16 MHz. ¿Qué frecuencia tiene el PWM y cuántos niveles?

2. Reloj necesario

Se quiere un PWM de 8 bits a 20 kHz (por encima de lo audible). ¿Qué reloj hace falta?

3. Umbral para un porcentaje

En un PWM de 8 bits, ¿qué umbral da un 30 % de ciclo de trabajo y qué tensión media con Vcc = 5 V?

4. Rizado

Un PWM a 3906 Hz con D = 50 % alimenta un filtro de 10 kΩ y 1 µF. ¿Cuánto es el rizado pico a pico (Vcc = 5 V) y cuánto tarda en asentar?

5. Un servo

Con un reloj de 1 MHz se maneja un servo con período de 20 ms. ¿Qué umbral corresponde a un pulso de 1,25 ms y cuántos bits tiene como mínimo el contador?

6. Diagnóstico

Un LED regulado con PWM parpadea brevemente (un «tic») cada vez que el programa cambia su brillo, aunque el PWM funciona bien con el brillo fijo. ¿Qué pasa y cómo se corrige?

12 · Síntesis

Ideas para recordar

¿Listo para el tema 34?

Antes de avanzar, calculá de memoria la frecuencia de un PWM de 8 bits con un reloj de 4 MHz, explicá por qué un registro de espera evita los destellos al cambiar el brillo y decidí qué oscilador usarías para un reloj de tiempo real. Si podés justificar las tres respuestas, ya tenés todas las piezas para el primer proyecto integrador.

En el próximo tema armaremos el proyecto del semáforo con máquina de estados: un reloj, un temporizador, una solicitud peatonal sincronizada y la máquina que coordina todo.