El control automático de ganancia

El AGC va entre el filtro antialias y el ecualizador: canal → AGC → ecualizador → slicer, con el error volviendo al ecualizador. Su trabajo es uno solo, llevar la potencia de la señal recibida a un valor fijo ${\phi }_0$. Hace falta porque el LMS no ve el paso $\beta$ solo: ve el producto $\beta {\phi }_0$. Sin AGC, el mismo $\beta$ es un paso distinto para cada nivel que llega.

01 · La definición

La filmina lo define por lo que hace: amplifica las señales débiles y atenúa las fuertes, para que lo que sigue trabaje siempre en el mismo rango de amplitudes. La potencia que llega depende de la potencia transmitida, de la distancia, de la orientación de la antena y de los obstáculos, y cambia con el tiempo. La ganancia del AGC sigue el nivel medio, lento comparado con la tasa de símbolos: los cambios de largo plazo son suyos; los de uno o pocos símbolos son del ecualizador o de la corrección de errores.

En simulación el nivel no cambia durante la corrida, y el AGC se reduce a corregir la varianza de la señal recibida $R$:

$$z=R·\frac{\text{target}}{\mathrm{std}(R)}⟹{\phi }_0=E|z{|}^2={\text{target}}^2$$

El target es un RMS. La filmina dice que se elige mirando la máxima excursión de la señal (la relación potencia pico a promedio) y que usualmente vale 0,3: tiene que dejar lugar a los picos debajo del fondo de escala del ADC, sin tirar resolución. Ese es el otro trabajo del AGC, el del conversor, y lo que cuesta poner mal el fondo de escala está en la nota del cuantizador. El AGC no mejora la SNR: multiplica señal y ruido por el mismo número.

02 · Por qué el LMS lo necesita

El LMS de la cátedra actualiza los taps con el error y la entrada:

$${\mathbf{c}}_{k+1}={\mathbf{c}}_k+\beta E_k{\mathbf{r}}_k^{*},Y_k={\mathbf{c}}_k^T{\mathbf{r}}_k,E_k=A_k-Y_k$$

con ${\mathbf{r}}_k$ los últimos $N$ valores de la entrada y $A_k$ el símbolo de referencia (el conocido, en entrenamiento, o la decisión del slicer). La pregunta es qué cambia si la entrada llega multiplicada por una ganancia $g>0$.

Paso 1: escalar la entrada es escalar el paso. Sea ${\mathbf{c}}_k$ la trayectoria del LMS con entrada ${\mathbf{r}}_k$ y paso $\beta g^2$, y ${\mathbf{c}}_k^{\prime }$ la del LMS con entrada $g{\mathbf{r}}_k$ y paso $\beta$. Si en algún $k$ vale ${\mathbf{c}}_k^{\prime }={\mathbf{c}}_k/g$, la salida es la misma, $Y_k^{\prime }={({\mathbf{c}}_k/g)}^{T}g{\mathbf{r}}_k=Y_k$, así que el error también, y la actualización queda

$${\mathbf{c}}_{k+1}^{\prime }=\frac{{\mathbf{c}}_k}{g}+\beta E_{k}g{\mathbf{r}}_k^{*}=\frac{{\mathbf{c}}_k+\beta g^2{E}_k{\mathbf{r}}_k^{*}}{g}=\frac{{\mathbf{c}}_{k+1}}{g}$$

Por inducción vale para todo $k$, siempre que arranque bien: con los taps en cero arranca, porque $0/g=0$. Es una identidad, no una aproximación: el LMS con la señal $g$ veces más grande hace exactamente lo mismo que el LMS con la señal original y el paso $g^2$ veces más grande. Mismas salidas, mismos errores, taps divididos por $g$.

Paso 2: leerlo con los resultados del LMS. Con entrada blanca de potencia ${\phi }_0$ y $N$ taps, el algoritmo LMS da el factor de convergencia, el paso óptimo, la cota de estabilidad y la constante de tiempo:

$$\gamma =1-2\beta {\phi }_0+{\beta }^{2}N{\phi }_0^2,{\beta }_{\mathrm{opt}}=\frac{1}{N{\phi }_0}$$ $$0<\beta <2{\beta }_{\mathrm{opt}},\tau \approx \frac{1}{2\beta {\phi }_0}$$

En las cuatro $\beta$ aparece multiplicado por ${\phi }_0$. Conviene medir el paso en unidades del óptimo, $f=\beta /{\beta }_{\mathrm{opt}}=N\beta {\phi }_0$, y entonces $\gamma =1-f(2-f)/N$. Si el paso se eligió como $f_0$ para la señal nominal y la señal llega con ganancia $g$, su potencia es $g^2{\phi }_0$ y el LMS trabaja con

$$f=g^2{f}_0$$

Con $f_0=\mathrm{0,5}$, que es un paso razonable, la señal diverge en cuanto $g^2>4$: 6,02 dB más fuerte alcanzan. Esa cuenta es de entrada blanca: con un canal que dispersa los autovalores el margen es menor, y en la nota del LMS el MSE ya se dispara al 1,3 del paso óptimo. Hacia abajo no diverge nunca, pero se arrastra: 10 dB más débil es un paso diez veces más chico y, con paso chico, $\tau \approx 1/(2\beta {\phi }_0)$ se multiplica por diez. Un rango de 40 dB en la potencia recibida es un rango de ${10}^4$ en el paso efectivo: no hay un $\beta$ que ande en todo el rango.

Paso 3: el AGC cancela la ganancia. Si la señal llega como $gR$, el AGC de la sección 01 la lleva a

$$z=gR·\frac{\text{target}}{\mathrm{std}(gR)}=gR·\frac{\text{target}}{g\mathrm{std}(R)}=R·\frac{\text{target}}{\mathrm{std}(R)}$$

La $g$ desaparece antes de llegar al ecualizador. El ecualizador ve siempre ${\phi }_0={\text{target}}^2$, y el $\beta$ que se eligió para esa potencia es el que efectivamente usa. Es lo que dice el comentario de la sección AGC del script de clase: «mantiene la potencia de entrada del FSE constante para evitar que se mueva el paso óptimo».

03 · Cómo cambia con el nivel

Medido en MATLAB con un ecualizador entrenado: símbolos $\pm 1$, canal $1+\mathrm{0,3}{z}^{-1}$, ruido de desvío 0,05, $N=11$ taps, target 0,3 (así que ${\phi }_0=\mathrm{0,09}$) y $\beta$ fijo en $\mathrm{0,5}{\beta }_{\mathrm{opt}}=\mathrm{0,505}$ para la señal nominal. La curva de aprendizaje es el promedio de 200 corridas. Las dos primeras columnas son las cuentas del paso 2, con la fórmula de entrada blanca; las dos últimas, lo medido sin AGC:

«Hasta −20 dB» es la primera iteración en que la curva, suavizada con una media móvil de 21, baja de −20 dB; el MSE mínimo de este ecualizador (Wiener) es −25,6 dB. Con AGC las siete filas dan lo mismo: 84 iteraciones y −24,18 dB. Tres cosas se leen de la tabla:

• Débil no es peor, es otro paso. A −10 dB tarda nueve veces más, pero termina más abajo que la nominal, porque un paso chico deja menos exceso de MSE. Es el compromiso velocidad contra piso del LMS, recorrido por el nivel de la señal en vez de por el diseñador.
• Cerca del borde, lento y ruidoso. A +5 dB el paso es 1,58 veces el óptimo: todavía converge, pero el piso queda en −15,30 dB. Pasado ${\beta }_{\mathrm{opt}}$ no se gana nada.
• El borde medido está antes del de la fórmula. La cuenta de entrada blanca pone la divergencia en +6,02 dB; acá +6 dB ya diverge. La entrada del ecualizador no es blanca —pasó por el canal—, y sus autovalores van de 0,47 a 1,53 veces ${\phi }_0$. El borde de verdad depende del canal; lo que no depende es que se mueve con $g^2$.

Sin AGC, bajar el nivel estira la curva hacia la derecha, que es lo que hace un paso más chico. Subirlo la acelera hasta +3 dB, a costa de levantarle el piso; a +5 dB el piso ya queda arriba de −20 dB, y a +6 dB la dispara para arriba. Con AGC el deslizador no hace nada: cualquiera sea el nivel, la curva es la nominal. Y el efecto va con $g^2$, no con $g$: con este canal el margen hacia arriba es de 5 dB y hacia abajo no hay borde, sólo una espera que crece diez veces cada 10 dB.

04 · La escala del slicer

El slicer también supone una escala. Los umbrales de una $M$-PAM con niveles $\pm 1,\pm 3,\dots$ están en $0,\pm 2,\pm 4,\dots$, y si la señal llega a la salida del ecualizador multiplicada por $s$, el punto $M-1$ cae del lado equivocado de $M-2$ apenas $s$ baja de $(M-2)/(M-1)$, y el punto $M-3$ cruza el umbral $M-2$ apenas $s$ pasa $(M-2)/(M-3)$. Sin ruido, la ventana de escalas que decide todo bien es:

Con ruido la ventana se achica todavía más. En QPSK el slicer mira sólo el signo y la escala no le importa; en 64-QAM, 1,6 dB de más ya hace decidir mal todos los puntos que tienen un ±5 en alguno de sus ejes.

Pero esa escala no la pone el AGC: la pone la ganancia del ecualizador. En el script de clase el AGC deja la señal en 0,1 de RMS y la 64-QAM de qammod tiene RMS $\sqrt{42}\approx \mathrm{6,48}$; la diferencia la aporta el ecualizador, que por eso arranca con el tap central en 16 y no en 1. En modo entrenado da igual de dónde arranque, porque el error se calcula contra el símbolo conocido y el LMS aprende la ganancia que falte. En modo dirigido por decisiones no da igual, porque el error se calcula contra lo que decidió el slicer. Lo que el AGC garantiza es que el tap inicial signifique siempre lo mismo: con la entrada en 0,1 de RMS, un tap de 16 da siempre la misma escala de arranque, llegue la señal como llegue. Medida en el script, esa escala es 0,245 veces la de la 64-QAM, afuera de la ventana. Con 64-QAM el script no converge en modo DD (SER 0,938 con la semilla 1), y no es por esto: arrancando en la escala justa da 0,901. Por qué, es tema del modo dirigido por decisiones.

05 · En los scripts de clase

El AGC de basic_transceiver_DD_equalizer.m es la versión de simulación, un escalado del bloque entero, no un lazo: metric = std(y), agc_gain = target/metric, y_norm = y .* agc_gain. Lo mismo hace basic_transceiver_CMA_equalizer.m. Con los números del script DD:

• target = 0.1, así que ${\phi }_0=\mathrm{0,01}$. Con 63 taps, ${\beta }_{\mathrm{opt}}=1/(63·\mathrm{0,01})=\mathrm{1,59}$, y step = 2e-3 es $\mathrm{0,00126}{\beta }_{\mathrm{opt}}$: un paso chiquito, con $\tau \approx 1/(2·\mathrm{0,002}·\mathrm{0,01})=25000$ símbolos. El script cuenta errores desde T0 = L/2, 125 000 símbolos: cinco constantes de tiempo.
• Sin la sección AGC, la entrada del FSE es y tal cual, con std(y) = 2,824 (semilla 1): 29,0 dB por encima del target. El mismo step pasa a valer $\mathrm{1,005}{\beta }_{\mathrm{opt}}$, justo el más rápido y a 3 dB del borde.
• La filmina dice «usualmente target = 0,3» y el código de la misma filmina usa 0,1; el script CMA usa 0,3. Pasar de 0,1 a 0,3 multiplica ${\phi }_0$ por 9: el mismo step es nueve veces más rápido. Cambiar el target sin cambiar el paso cambia el ecualizador.

Con 64-QAM el script DD no converge ni con AGC, así que para ver el efecto del nivel sobre el transceptor de clase hay que bajar a M = 4. Así, con AGC, converge y decide todo bien. Sacando el AGC y metiendo la señal a varios niveles respecto del target, con el tap inicial en 16 como en el script:

• Hacia abajo, el MSE de las últimas 20 000 decisiones pasa de −18,39 dB en 0 dB a −4,18 dB en −10 dB y a +1,81 dB en −20 dB: en 250 000 símbolos no llegó a converger. La SER sigue en cero, pero sólo porque el slicer de QPSK mira el signo.
• Hacia arriba, aguanta hasta +24 dB y en +26 dB, con el paso en $\mathrm{0,50}{\beta }_{\mathrm{opt}}$, se pierde: SER de 0,755, que es decidir al azar. Si además se divide el tap inicial por $g$, que es el paso 1 al pie de la letra, aguanta hasta +28 dB ($\mathrm{0,80}{\beta }_{\mathrm{opt}}$) y se pierde en +30 dB. Cuentan las dos cosas: el paso y la escala de arranque.

Las dos pérdidas llegan bastante antes que el $2{\beta }_{\mathrm{opt}}$ de la fórmula. La fórmula es para entrada blanca, y la del FSE está lejos de serlo: sobremuestreada y filtrada, su autovalor mayor es 2,65 veces ${\phi }_0$. Y en modo DD el error sale de decisiones que pueden estar mal.

En un receptor de verdad el AGC es un lazo: mide el nivel después del ADC y corrige una ganancia variable antes, siguiendo el nivel medio. La filmina pide que sea lento respecto de la tasa de símbolos, y la razón es la misma que en el paso 1: una ganancia que se mueve rápido es un paso que se mueve rápido, y además aplastaría la información de amplitud de una QAM. El std del bloque entero, en cambio, mira toda la señal —también la que todavía no llegó—, y sirve porque en la simulación el nivel no cambia.

06 · El análisis en MATLAB

El barrido de la sección 03. Lo que figura como comentario es la salida real de correrlo en R2026a. Tarda 2,6 segundos.

%% 1. El sistema: 2-PAM, un canal con ISI y un ecualizador LMS entrenado
rng(7)
h      = [1 0.3];            % canal
sigma  = 0.05;               % desvío del ruido
N      = 11;                 % taps del ecualizador
K      = 2000;               % iteraciones
R      = 200;                % realizaciones que se promedian
target = 0.3;                % el objetivo del AGC, en RMS
phi0   = target^2;           % la potencia que el AGC deja a la entrada
beta   = 0.5 / (N*phi0);     % 0,5 beta_opt para la señal nominal, y FIJO
P      = sum(h.^2) + sigma^2;

A = sign(randn(K+N, R));                          % símbolos, uno por columna
X = filter(h, 1, A) + sigma*randn(K+N, R);
X = X * target / sqrt(P);                         % nivel nominal: RMS = target

%% 2. El barrido: el mismo beta con la señal a varios niveles
niveles = [-20 -10 0 3 5 6 10];
fprintf(' nivel  beta/beta_opt  gamma   tau    | sin AGC: k(-20 dB)  MSE(K) | con AGC: k(-20 dB)  MSE(K)\n')
for nivel = niveles
    g = 10^(nivel/20);
    f = 0.5 * g^2;                                % el paso que ve el LMS, en beta_opt
    gam = 1 - f*(2 - f)/N;                        % entrada blanca
    [m0, k0] = curva(g*X, A, beta, N, false);
    [m1, k1] = curva(g*X, A, beta, N, true);
    if gam < 1, tau = sprintf('%6.1f', -1/log(gam)); else, tau = '   inf'; end
    fprintf('%+4d dB   %8.3f    %6.4f  %s  |   %6s    %8s   |   %6s    %8s\n', nivel, f, gam, tau, ...
        txt(k0), dB(m0), txt(k1), dB(m1))
end
%  nivel  beta/beta_opt  gamma   tau    | sin AGC: k(-20 dB)  MSE(K) | con AGC: k(-20 dB)  MSE(K)
%  -20 dB      0.005    0.9991  1102.3  |    nunca    -6.39 dB   |       84    -24.18 dB
%  -10 dB      0.050    0.9911   112.3  |      750    -25.49 dB   |       84    -24.18 dB
%   +0 dB      0.500    0.9318    14.2  |       84    -24.19 dB   |       84    -24.18 dB
%   +3 dB      0.998    0.9091    10.5  |       62    -22.07 dB   |       84    -24.18 dB
%   +5 dB      1.581    0.9398    16.1  |    nunca    -15.30 dB   |       84    -24.18 dB
%   +6 dB      1.991    0.9983   583.4  |    nunca     diverge   |       84    -24.18 dB
%  +10 dB      5.000    2.3636     inf  |    nunca     diverge   |       84    -24.18 dB

%% 3. Con AGC el nivel desaparece
[mA, ~] = curva(0.01*X, A, beta, N, true);
[mB, ~] = curva(3.16*X, A, beta, N, true);
fprintf('max |curva(-40 dB) - curva(+10 dB)| con AGC = %.1e\n', max(abs(mA - mB)))
% max |curva(-40 dB) - curva(+10 dB)| con AGC = 2.2e-16

function [mse, kc] = curva(X, A, beta, N, agc)
    [K, R] = size(A);  K = K - N;
    target = 0.3;
    mse = zeros(K, 1);
    for r = 1:R
        x = X(:, r);
        if agc, x = x * target / std(x); end      % el AGC de los scripts de clase
        c = zeros(N, 1);
        for k = N:K+N-1
            rk = x(k:-1:k-N+1);
            E  = A(k, r) - c.'*rk;                % modo entrenado, retardo 0
            c  = c + beta*E*rk;
            mse(k-N+1) = mse(k-N+1) + E^2/R;
        end
    end
    kc = find(10*log10(movmean(mse, 21)) < -20, 1);
end
function s = dB(m)
    v = mean(m(end-199:end));
    if ~isfinite(v) || v > 1, s = 'diverge'; else, s = sprintf('%.2f dB', 10*log10(v)); end
end
function s = txt(k)
    if isempty(k), s = 'nunca'; else, s = sprintf('%d', k); end
end

Tres detalles que muerden si no se los conoce:

• El bloque 3 no verifica nada: muestra. Que con AGC la curva a −40 dB y la de +10 dB coincidan hasta el redondeo es la cuenta del paso 3 hecha por la computadora, no una segunda prueba de ella. Lo que sí es una medición es la columna «sin AGC».
• std resta la media. Para una constelación simétrica da lo mismo que el RMS. Si la señal trae continua (un offset del ADC), $E|z{|}^2$ queda más grande que ${\text{target}}^2$. El RMS de verdad es sqrt(mean(abs(y).^2)).
• Los scripts de clase son complejos. C.'*buffer transpone sin conjugar, como pide la salida ${\mathbf{c}}_k^T{\mathbf{r}}_k$, y la actualización lleva conj(buffer). Con ' en vez de .' la salida sale conjugada y el error no tiene sentido; el script lo avisa en un comentario. Acá todo es real y no hace falta.

Para tener a mano

1. El AGC lleva la potencia de la entrada del ecualizador a ${\phi }_0={\text{target}}^2$. En simulación, $z=R·\text{target}/\mathrm{std}(R)$; la filmina dice target 0,3, el script DD usa 0,1.
2. Entrada $g$ veces más grande con paso $\beta$ es exactamente la entrada original con paso $g^2\beta$, con los taps divididos por $g$.
3. Por eso $\beta /{\beta }_{\mathrm{opt}}$ se mueve con la potencia recibida. Con $\mathrm{0,5}{\beta }_{\mathrm{opt}}$, 6,02 dB más fuerte diverge (entrada blanca; con canal, antes); 10 dB más débil tarda diez veces más.
4. El AGC cancela la $g$ antes del ecualizador: un único $\beta$ sirve para cualquier nivel. No mejora la SNR.
5. La escala del slicer la fija la ganancia del ecualizador, no el AGC. Sin ruido, 16-QAM tolera de −3,52 a +6,02 dB de error de escala y 64-QAM de −1,34 a +1,58 dB; QPSK, cualquiera.
6. En el script DD: ${\beta }_{\mathrm{opt}}=\mathrm{1,59}$, step = $\mathrm{0,00126}{\beta }_{\mathrm{opt}}$, $\tau \approx 25000$ símbolos. Cambiar el target de 0,1 a 0,3 hace el paso nueve veces más rápido.