Применяйтесь различные продолжительности усреднения AGC к QAM модулировали сигналы. Сравните отклонение и график сигналов после того, как AGC будет применен.

Инициализируйте три Системных объекта AGC со средним набором длины окна к 10, 100, и 1 000 выборок.

agc1 = comm.AGC('AveragingLength',10);
agc2 = comm.AGC('AveragingLength',100);
agc3 = comm.AGC('AveragingLength',1000);

Сгенерируйте M-QAM модулируемый и повышенный косинус packetized данные импульсной формы.

M = 16;
d = randi([0 M-1],1000,1);
s = qammod(d,M);
x = 0.1*s;
pulseShaper = comm.RaisedCosineTransmitFilter;
y = awgn(pulseShaper(x),inf);

Примените AGC.

r1 = agc1(y);
r2 = agc2(y);
r3 = agc3(y);

Постройте и сравните сигналы.

figure(1)
subplot(4,1,1)
plot(abs(y))
title('AGC input')
subplot(4,1,2)
plot(abs(r1))
axis([0 8000 0 10])
title('AGC output (AveragingLength = 10 samples)')
text(4000, 5, sprintf('Variance = %f',var(r1(3000:end))))
subplot(4,1,3)
plot(abs(r2))
axis([0 8000 0 10])
title('AGC output (AveragingLength = 100 sample)')
text(4000, 5, sprintf('Variance = %f',var(r2(3000:end))))
subplot(4,1,4)
plot(abs(r3))
axis([0 8000 0 10])
title('AGC output (AveragingLength = 1000 samples)')
text(4000, 5, sprintf('Variance = %f',var(r3(3000:end))))

Когда продолжительность усреднения увеличивает отклонение при выводе уменьшений AGC.

Применяйтесь различный уровень усиления максимума AGC к QPSK модулировал сигналы. С максимальным усилением, слишком маленьким сигнал после того, как, AGC не достигнет желаемой амплитуды. С максимальным усилением, слишком большим, сигнал после AGC промахнется и может насыщать получившийся в потере сигнала в начале полученных пакетов. С максимальным усилением на оптимальном уровне сигнал после того, как AGC достигает желаемой амплитуды без потери сигнала из-за насыщения. Сравните график сигналов после того, как AGC будет применен.

Инициализируйте три Системных объекта AGC с максимальным набором значений усиления к 10 дБ, 20 дБ и 30 дБ.

agc1 = comm.AGC('MaxPowerGain', 10);
agc2 = comm.AGC('MaxPowerGain', 20);
agc3 = comm.AGC('MaxPowerGain', 30);

Сгенерируйте QPSK модулируемый и повышенный косинус packetized данные импульсной формы.

M = 4;
pktLen = 10000;
d = randi([0 M-1],pktLen,1);
s = pskmod(d,M,pi/4);
x = repmat([zeros(pktLen,1); 0.3*s],3,1);
pulseShaper = comm.RaisedCosineTransmitFilter;
y = awgn(pulseShaper(x),50);

Примените AGC и график.

r1 = agc1(y);
r2 = agc2(y);
r3 = agc3(y);

Постройте и сравните сигналы.

figure(1)
subplot(4,1,1)
plot(abs(y))
title('AGC input')
subplot(4,1,2)
plot(abs(r1))
title('AGC output (MaxPowerGain = 10 dB)')
subplot(4,1,3)
plot(abs(r2))
title('AGC output (MaxPowerGain = 20 dB)')
subplot(4,1,4)
plot(abs(r3))
title('AGC output (MaxPowerGain = 30 dB)')

Этот график сравнивает вход сигнала с AGC и выводом от AGC с различными максимальными уровнями усиления. С максимальным набором усиления к 10 дБ AGC вывод не может достигнуть желаемого уровня выходной мощности. С максимальным набором усиления к 20 дБ AGC вывод достигает желаемого уровня без насыщения. С максимальным набором усиления к 30 дБ, AGC перерегулирования вывода, рискуя насыщением сигнала и потерей данных. Между пакетами во входном сигнале существует только шум.

Как показано в графиках, с пакетными передачами могут быть длительные периоды, когда никакие данные не получены. Это приводит к AGC, увеличивающемуся до максимальной установки усиления. Если пакет прибывает, когда усиление AGC слишком высоко, перерегулирования выходной мощности, пока AGC не может ответить на изменение на уровне входной мощности и уменьшать его усиление.

Применяйтесь различные размеры шага AGC к QPSK модулировали сигналы. Сравните сигналы после того, как AGC будет применен.

Инициализируйте три Системных объекта AGC с набором размеров шага к 1e-1, 1e-3, и 1e-4.

agc1 = comm.AGC('AdaptationStepSize',1e-1);
agc2 = comm.AGC('AdaptationStepSize',1e-3);
agc3 = comm.AGC('AdaptationStepSize',1e-4);

Сгенерируйте модулируемые данные QPSK с повышенным формированием импульса косинуса.

d = randi([0 3],500,1);
s = pskmod(d,4,pi/4);
x = 0.1*s;
pulseShaper = comm.RaisedCosineTransmitFilter;
y = pulseShaper(x);

Примените AGC.

r1 = agc1(y);
r2 = agc2(y);
r3 = agc3(y);

Постройте вход сигнала к AGC и выведите после различных размеров шага AGC.

figure
subplot(4,1,1)
plot(abs(y))
title('AGC input')
subplot(4,1,2)
plot(abs(r1))
title('AGC output (AdaptionStepSize = 1e-1)')
subplot(4,1,3)
plot(abs(r2))
title('AGC output (AdaptionStepSize = 1e-3)')
subplot(4,1,4)
plot(abs(r3))
title('AGC output (AdaptionStepSize = 1e-4)')

С набором размера шага к 1e-1, AGC перерегулирование вывода, но сходится очень быстро. С набором размера шага к 1e-3 AGC исчезает перерегулирование вывода, и AGC сходится гладко, но более медленно. С максимальным набором усиления к 1e-4 AGC занимает очень долгое время, чтобы сходиться.

Модулируйте и усильте сигнал QPSK. Установите полученную амплитуду сигнала приблизительно на 1 вольт с помощью AGC. Затем постройте вывод.

Создайте QPSK модулируемый сигнал с помощью Системного объекта QPSK.

data = randi([0 3],1000,1);
qpsk = comm.QPSKModulator;
modData = qpsk(data);

Ослабьте модулируемый сигнал.

txSig = 0.1*modData;

Создайте Систему AGC object™ и передайте переданный сигнал через него с помощью функции step. AGC настраивает полученную степень сигнала приблизительно к 1 Вт.

agc = comm.AGC;
rxSig = agc(txSig);

Постройте сигнальные созвездия передачи и полученных сигналов после того, как AGC достигнет установившийся.

h = scatterplot(txSig(200:end),1,0,'*');
hold on
scatterplot(rxSig(200:end),1,0,'or',h);
legend('Input of AGC', 'Output of AGC')

Измерьте и сравните степень переданных и полученных сигналов после того, как AGC достигнет устойчивого состояния. Степень переданного сигнала в 100 раз меньше, чем степень полученного сигнала.

txPower = var(txSig(200:end));
rxPower = var(rxSig(200:end));
[txPower rxPower]

ans = 1×2

    0.0100    0.9970

Создайте две Системы AGC objects™, чтобы настроить уровень полученного сигнала с помощью двух различных размеров шага с идентичными периодами обновления.

Сгенерируйте сигнал 8-PSK иметь силу, равную 10 Вт.

data = randi([0 7],200,1);
modData = sqrt(10)*pskmod(data,8,pi/8,'gray');

Создайте пару повышенных согласованных фильтров косинуса с их набором свойств Gain так, чтобы у них была выходная мощность единицы.

txfilter = comm.RaisedCosineTransmitFilter('Gain',sqrt(8));
rxfilter = comm.RaisedCosineReceiveFilter('Gain',sqrt(1/8));

Пропустите модулируемый сигнал через повышенный объект фильтра передачи косинуса.

txSig = txfilter(modData);

Создайте два объекта AGC настроить полученный уровень сигнала. Выберите размер шага 0,01 и 0.1, соответственно. Установите период обновления на 10.

agc1 = comm.AGC('AdaptationStepSize',0.01);
agc2 = comm.AGC('AdaptationStepSize',0.1);

Передайте модулируемый сигнал через два объекта AGC.

agcOut1 = agc1(txSig);
agcOut2 = agc2(txSig);

Фильтр выходные сигналы AGC при помощи повышенного косинуса получает объект фильтра.

rxSig1 = rxfilter(agcOut1);
rxSig2 = rxfilter(agcOut2);

Постройте степень отфильтрованных ответов AGC, в то время как составление 10 задержек символа через передачу - получает пару фильтра.

plot([abs(rxSig1(11:110)).^2 abs(rxSig2(11:110)).^2])
grid on
xlabel('Symbols')
ylabel('Power (W)')
legend('Step Size 0.01','Step Size 0.1')

Сигнал с большим размером шага сходится быстрее к целевому уровню мощности AGC 1 Вт.

Постройте степень установившихся отфильтрованных сигналов AGC включением только последних 100 символов.

plot((101:200),[abs(rxSig1(101:200)).^2 abs(rxSig2(101:200)).^2])
grid on
xlabel('Symbols')
ylabel('Power (W)')
legend('Step Size 0.01','Step Size 0.1')

Больший размер шага AGC приводит к менее точному исправлению усиления.

Уменьшаемая точность предлагает компромисс со свойством AdaptationStepSize. Большие значения приводят к более быстрой сходимости за счет менее точного управления усилением.

Передайте ослабленные пакетные данные о QPSK двум AGCs наличие различных максимальных усилений. Затем отобразите результаты.

Создайте два, пакеты данных QSPK с 200 символами. Передайте пакеты по кадру с 1200 символами.

modData1 = pskmod(randi([0 3],200,1),4,pi/4);
modData2 = pskmod(randi([0 3],200,1),4,pi/4);
txSig = [modData1; zeros(400,1); modData2; zeros(400,1)];

Ослабьте переданный пакетный сигнал на 20 дБ и постройте его степень.

rxSig = 0.1*txSig;
rxSigPwr = abs(rxSig).^2;
plot(rxSigPwr)
grid
xlabel('Symbols')
ylabel('Power (W)')

Создайте два AGCs, где agc1 имеет усиление максимальной мощности 30 дБ, и agc2 имеет усиление максимальной мощности 24 дБ.

agc1 = comm.AGC('MaxPowerGain',30, ...
    'AdaptationStepSize',0.02);

agc2 = comm.AGC('MaxPowerGain',24, ...
    'AdaptationStepSize',0.02);

Передайте ослабленный сигнал через AGCs и вычислите выходную мощность.

rxAGC1 = agc1(rxSig);
rxAGC2 = agc2(rxSig);

pwrAGC1 = abs(rxAGC1).^2;
pwrAGC2 = abs(rxAGC2).^2;

Постройте выходную мощность.

plot([pwrAGC1 pwrAGC2])
legend('AGC1','AGC2')
grid
xlabel('Symbols')
ylabel('Power (W)')

Первоначально, для второго пакета, степень выходного сигнала agc1 слишком высока, потому что AGC применил свое максимальное усиление в период, когда никакие данные не были переданы. Соответствующая степень выходного сигнала agc2 не промахивается по целевому уровню мощности 1 Вт той же суммой. Это сходится к правильной степени более быстро из-за ее меньшего максимального усиления.