419 lines
19 KiB
Matlab
419 lines
19 KiB
Matlab
|
|
folderpath = 'C:\Users\sioe\Documents\High_Speed_Measurement_2024\mpi_measurement\';
|
|
experiment_name = 'testen';
|
|
currentTime = datetime('now', 'Format', 'yyyyMMdd_HHmmss');
|
|
timeStr = char(currentTime);
|
|
experiment_name = [experiment_name, timeStr];
|
|
|
|
|
|
%%% BITRATE Sweep for MPI Experiment %%%
|
|
awg_vpp = 2.7;
|
|
rop_atten = 0; %VOA 1 -> %nicht angeschlossen
|
|
pd_in_set = 8; %VOA 2 -> PD in
|
|
%VOA 3 -> Signal path
|
|
%VOA 4 -> Interference path
|
|
|
|
random_key = 0;
|
|
|
|
params = struct;
|
|
params.M = [8];
|
|
params.bitrate = [336].*1e9;%[90:60:480].*1e9;%[300:30:480].*1e9;
|
|
params.duobinary = [0];
|
|
params.interference_atten = [45];
|
|
|
|
wh = DataStorage(params);
|
|
|
|
wh.addStorage("ber_ffe");
|
|
wh.addStorage("ber_ffe_mlse");
|
|
wh.addStorage("ber_vnle");
|
|
wh.addStorage("ber_vnle_mlse");
|
|
wh.addStorage("ber_db");
|
|
|
|
wh.addStorage("FFE");
|
|
wh.addStorage("VNLE");
|
|
|
|
wh.addStorage("pd_in");
|
|
wh.addStorage("rop");
|
|
wh.addStorage("s_power");
|
|
wh.addStorage("i_power");
|
|
wh.addStorage("sir");
|
|
|
|
|
|
wh.addStorage("m");
|
|
|
|
wh.addStorage("dcs");
|
|
wh.addStorage("pdfa");
|
|
wh.addStorage("exfo");
|
|
wh.addStorage("voa");
|
|
|
|
precomp_path = "C:\Users\sioe\Documents\High_Speed_Measurement_2024\precomp\";
|
|
precomp_fn = "lab_high_speed";
|
|
precomp_mode = 2; %0=do nothing ; 1= measure; 2=precomp active
|
|
|
|
looptotal = prod(wh.dim);
|
|
|
|
disp(['Start Measurement of ',num2str(looptotal),' loops...'])
|
|
iterationTimes = zeros(looptotal, 1); % Preallocate for speed
|
|
if ~exist('hWaitbar', 'var') || ~isvalid(hWaitbar)
|
|
hWaitbar = waitbar(0, sprintf('Starting %d measurements',looptotal), 'Name', 'Processing Progress');
|
|
else
|
|
waitbar(0, hWaitbar, sprintf('Starting %d measurements',looptotal));
|
|
end
|
|
|
|
loopcnt = 0;
|
|
estimatedTimeRemaining = 0;
|
|
estimatedTotalTime = 0;
|
|
|
|
for M = wh.parameter.M.values
|
|
|
|
|
|
dcs = DC_supply("active",[1,0],"voltage",[2.3, 0]);
|
|
|
|
if M == 4
|
|
|
|
v_bias_for_pam = 2.3;
|
|
dcs.set("voltage",[v_bias_for_pam, 0]);
|
|
pulsef = 1;
|
|
|
|
elseif M == 6
|
|
%pause(7*60); %wait 30 minutes for stable bias
|
|
v_bias_for_pam=2.3;
|
|
dcs.set("voltage",[v_bias_for_pam, 0]);
|
|
pulsef = 0;
|
|
|
|
elseif M == 8
|
|
|
|
v_bias_for_pam=2.6;
|
|
dcs.set("voltage",[v_bias_for_pam, 0]);
|
|
disp('waiting...');
|
|
%pause(5*60); %wait 5 minutes for stable bias
|
|
pulsef = 0;
|
|
|
|
end
|
|
|
|
for bitrate = wh.parameter.bitrate.values
|
|
|
|
fsym = floor( bitrate*1e-9./log2(M) ).*1e9;
|
|
|
|
for db = wh.parameter.duobinary.values
|
|
|
|
if db == 1
|
|
ffe_only = 0;
|
|
postfilter_approach = 0;
|
|
db_channel_approach = 1;
|
|
db_coding_approach = 0;
|
|
db_precode = db_coding_approach || db_channel_approach;
|
|
if M == 4
|
|
pulsef=1;
|
|
precomp_amp_max = -50;
|
|
elseif M == 6
|
|
pulsef=0;
|
|
precomp_amp_max = -50;
|
|
elseif M == 8
|
|
pulsef=0;
|
|
precomp_amp_max = -50;
|
|
end
|
|
elseif db == 0
|
|
ffe_only = 0;
|
|
postfilter_approach = 1;
|
|
db_channel_approach = 0;
|
|
db_coding_approach = 0;
|
|
db_precode = db_coding_approach || db_channel_approach;
|
|
if M == 4
|
|
pulsef=1;
|
|
precomp_amp_max = -38;
|
|
elseif M == 6
|
|
pulsef=0;
|
|
precomp_amp_max = -34;
|
|
elseif M == 8
|
|
pulsef=0;
|
|
precomp_amp_max = -34;
|
|
end
|
|
end
|
|
|
|
%%%%% Construct AWG and Scope Modules %%%%%%
|
|
fdac = 256e9;
|
|
fadc = 256e9;
|
|
|
|
|
|
%%%%% Symbol Generation %%%%%%
|
|
rcalpha = 0.05;
|
|
Pform = Pulseformer("fsym",fsym,"fdac",4*fsym,"pulse","rrc","pulselength",16,"rrcalpha",rcalpha);
|
|
|
|
Pamsource = PAMsource(...
|
|
"fsym",fsym,"M",M,"order",19,"useprbs",1,...
|
|
"fs_out",fdac,...
|
|
"applyclipping",0,"clipfactor",1.5,...
|
|
"applypulseform",pulsef,"pulseformer",Pform,...
|
|
"randkey",random_key,...
|
|
"db_precode",db_precode,"db_encode",db_coding_approach,...
|
|
"mrds_code",0,"mrds_blocklength",512);
|
|
|
|
[Digi_sig,Symbols,Bits] = Pamsource.process();
|
|
|
|
%%%%% Precompensation Routine %%%%%%
|
|
if precomp_mode == 1 % measure channel
|
|
precomp_est = ChannelFreqResp("Nacq",1024,"Navg",64,"Ncp",63,'f_ref',fdac);
|
|
Digi_sig = precomp_est.buildOFDM();
|
|
elseif precomp_mode == 2 % apply precomp
|
|
precomp_est = ChannelFreqResp("Nacq",1024,"Navg",64,"Ncp",63,'f_ref',Digi_sig.fs);
|
|
Digi_sig = precomp_est.precomp(Digi_sig,'maxampdb',precomp_amp_max,'loadPath',precomp_path,'fileName',precomp_fn);
|
|
end
|
|
|
|
%%%%% Resample to DAC rate %%%%%%
|
|
Digi_sig = Digi_sig.resample("fs_out",AWG.fdac);
|
|
|
|
% Digi_sig = Filter('filtdegree',5,"f_cutoff",0.75*fsym,"fs",fadc,"filterType",filtertypes.gaussian,"active",true).process(Digi_sig);
|
|
|
|
% Digi_sig.spectrum("displayname","TX After precomp","fignum",10,"normalizeToNyquist",0,"normalizeTo0dB",0);
|
|
|
|
|
|
holdAndShowValue;
|
|
|
|
scopeAutoScale = 1;
|
|
|
|
for interference_atten = wh.parameter.interference_atten.values
|
|
|
|
SCP = ScopeKeysight("model","UXR1104B",'autoscale',scopeAutoScale,"fadc","GSa_256","channel",[0,1,0,0],"recordLen",10000000,"removeDC",1);
|
|
AWG = AwgKeysight("model","M8199B","fdac",fdac,"scaletodac",[1,1],"skews",[0,0],"voltages",[0,awg_vpp]);
|
|
A2S = Awg2Scope(AWG,SCP,[0,2,0,0],"waitUntilClick",1); %
|
|
|
|
scopeAutoScale = 0; %until is set to 1 in next db change and then bitrate
|
|
|
|
%%%%% Loop Preps
|
|
iterationStartTime = tic;
|
|
loopcnt = loopcnt+1;
|
|
loop_name = ['_PAM_',num2str(M),'_R_',num2str(bitrate),'_DB_',num2str(db),'_I_atten_',num2str(interference_atten)];
|
|
loop_name = strrep(loop_name,'.','_');
|
|
|
|
%%%%% READ Voltages %%%%%%
|
|
dcs.readVals();
|
|
|
|
%%%%% SET Attenuator %%%%%%
|
|
voa = OptAtten("active",[1,2,1,1],"value",[rop_atten,pd_in_set,0,interference_atten],"wavelength",[1310,1310,1310,1310],"speed",[1000,100,1000,1000]);
|
|
voa.set('active',[1,2,1,1],'value',[rop_atten,pd_in_set,0,interference_atten]);
|
|
|
|
%%%% SIGNAL USUALLY HERE, NOW ABOVE ROP_ATTEN %%%
|
|
|
|
%%%%% Plot and Save Routine 1 - same for all rops, thus save only once %%%%%%%%%%%%%%%%%%%%%%%%%
|
|
if interference_atten == 0
|
|
save([folderpath,experiment_name,loop_name,'_bits'],"Bits");
|
|
save([folderpath,experiment_name,loop_name,'_symbols'],"Symbols");
|
|
end
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
%%%%% AWG --> Scope %%%%%%
|
|
[~,Scpe_sig_raw,~,D] = A2S.process("signal2",Digi_sig,"waitUntilClick",0);
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
% Scpe_sig_raw.spectrum("displayname","Scope PSD before filter","fignum",30,"normalizeTo0dB",1);
|
|
|
|
Scpe_sig_raw = Filter('filtdegree',5,"f_cutoff",0.65.*fsym,"fs",fadc,"filterType",filtertypes.gaussian,"active",true).process(Scpe_sig_raw);
|
|
|
|
% Scpe_sig_raw.spectrum("displayname","Scope PSD after filter","fignum",30,"normalizeTo0dB",1);
|
|
|
|
%%%%%% Sample to 2x fsym %%%%%%
|
|
Scpe_sig_resampled = Scpe_sig_raw.resample("fs_in",fadc,"fs_out",2*fsym);
|
|
|
|
voa.readvals();
|
|
rop = voa.power_state(1);
|
|
pd_in = voa.power_state(2);
|
|
i_power = voa.power_state(4);
|
|
s_power = voa.power_state(3);
|
|
sir = s_power-i_power;
|
|
|
|
Scpe_sig_raw.plot("displayname",['SIR: ',sprintf('%.2f',sir),' dB'],"fignum",20,"clear",1);
|
|
|
|
|
|
disp(['PDin: ',sprintf('%.2f',pd_in),' dB | S: ',sprintf('%.2f',s_power),' dB | I: ',sprintf('%.2f',i_power),' dB | -> SIR: ',sprintf('%.2f',sir),' dB']);
|
|
|
|
%%%%%% Sync Rx signal with reference (S is a cell array with all occurences) %%%%%%
|
|
[Scpe_sig_syncd,S,isFlipped] = Scpe_sig_resampled.tsynch("reference",Symbols,"fs_ref",fsym);
|
|
|
|
%%%%% Plot and Save Routines: SAVE RECEIVED SIGNALS %%%%%%%%%%%%%%%%%%%%%%%%%
|
|
save([folderpath,experiment_name,loop_name,'_rx_signal'],"S");
|
|
save([folderpath,experiment_name,loop_name,'_raw_signal'],"Scpe_sig_raw");
|
|
|
|
%%%%% EQUALIZE %%%%%%
|
|
% set to minus one not zero not avoid confusion if BER is acutally zero
|
|
ber_vnle = [-1];
|
|
ber_vnle_mlse = [-1];
|
|
ber_ffe_mlse =[-1];
|
|
ber_ffe = [-1];
|
|
ber_db = [-1];
|
|
ffe = EQ("Ne",[50,0,0],"Nb",[0,0,0],"training_length",4096*2,"training_loops",5,"dd_loops",5,"K",2,"DCmu",0.05,"DDmu",[0.0004 0.0004 0.0004 0.0004 ],"DFEmu",0.005,"FFEmu",0,"plotfinal",0,"ideal_dfe",1);
|
|
vnle = EQ("Ne",[50,7,7],"Nb",[0,0,0],"training_length",4096*2,"training_loops",5,"dd_loops",5,"K",2,"DCmu",0.05,"DDmu",[0.0004 0.0004 0.0004 0.0004 ],"DFEmu",0.005,"FFEmu",0,"plotfinal",0,"ideal_dfe",1);
|
|
|
|
|
|
if postfilter_approach %%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
|
|
if 1
|
|
|
|
eq_values = min(numel(S),8);
|
|
Noi = cell(eq_values,1);
|
|
EQ_vnle= cell(eq_values,1);
|
|
EQ_ffe= cell(eq_values,1);
|
|
|
|
parfor s = 1:eq_values
|
|
|
|
if 0
|
|
%FFE LINEAR
|
|
Scpe_sig_syncd = S{s};
|
|
[EQ_ffe{s}] = ffe.process(Scpe_sig_syncd,Symbols);
|
|
Noi{s} = EQ_ffe{s}-Symbols;
|
|
Rx_bits = PAMmapper(M,0).demap(EQ_ffe{s});
|
|
[~,~,ber_ffe(s),~] = calc_ber(Rx_bits.signal,Bits.signal,"skip_front",100,"skip_end",150,"returnErrorLocation",1);
|
|
end
|
|
|
|
if 0
|
|
%FFE + MLSE
|
|
nc = 2;
|
|
burg_coeff = arburg(Noi{s}.signal,nc);
|
|
EQ_ffe{s} = EQ_ffe{s}.filter(burg_coeff,1);
|
|
|
|
EQ_mlse = MLSE("DIR",burg_coeff,"duobinary_output",0,"M",M,"trellis_states",PAMmapper(M,0).levels).process(EQ_ffe{s});
|
|
Rx_bits = PAMmapper(M,0).demap(EQ_mlse);
|
|
[~,~,ber_ffe_mlse(s),~] = calc_ber(Rx_bits.signal,Bits.signal,"skip_front",100,"skip_end",150,"returnErrorLocation",1);
|
|
end
|
|
|
|
if 1
|
|
%VNLE
|
|
Scpe_sig_syncd = S{s};
|
|
[EQ_vnle{s}] = vnle.process(Scpe_sig_syncd,Symbols);
|
|
Noi{s} = EQ_vnle{s}-Symbols;
|
|
Rx_bits = PAMmapper(M,0).demap(EQ_vnle{s});
|
|
[~,~,ber_vnle(s),~] = calc_ber(Rx_bits.signal,Bits.signal,"skip_front",100,"skip_end",150,"returnErrorLocation",1);
|
|
end
|
|
|
|
%VNLE + MLSE
|
|
if 1
|
|
nc = 2;
|
|
burg_coeff = arburg(Noi{s}.signal,nc);
|
|
EQ_mlse = EQ_vnle{s}.filter(burg_coeff,1);
|
|
|
|
EQ_mlse = MLSE("DIR",burg_coeff,"duobinary_output",0,"M",M,"trellis_states",PAMmapper(M,0).levels).process(EQ_mlse);
|
|
Rx_bits = PAMmapper(M,0).demap(EQ_mlse);
|
|
[~,~,ber_vnle_mlse(s),~] = calc_ber(Rx_bits.signal,Bits.signal,"skip_front",100,"skip_end",150,"returnErrorLocation",1);
|
|
end
|
|
end
|
|
|
|
if 0
|
|
nc=1;
|
|
Noi{1}.spectrum('displayname',['Noise; SIR:',sprintf('%.2f',sir)],'fignum',40,'normalizeTo0dB',1);
|
|
burg_coeff = arburg(Noi{1}.signal,nc);
|
|
[h,w] = freqz(1,burg_coeff,length(Noi{1}),"whole",Noi{1}.fs);
|
|
h = h/max(abs(h));
|
|
hold on
|
|
w_ = (w - Noi{1}.fs/2);
|
|
plot(w_.*1e-9,20*log10(fftshift(h)),'DisplayName',[num2str(nc), ' burg; SIR:',sprintf('%.2f',sir)]);
|
|
drawnow;
|
|
end
|
|
|
|
end
|
|
|
|
% disp(['FFE EQ: BEST BER: ',sprintf('%.1E',min(ber_ffe)),' AVG BER: ',sprintf('%.1E',mean(ber_ffe)),' WORST:',sprintf('%.1E',max(ber_ffe)),'. Out of ',num2str(numel(ber_ffe))]);
|
|
% disp(['FFE + MLSE EQ: BEST BER: ',sprintf('%.1E',min(ber_ffe_mlse)),' AVG BER: ',sprintf('%.1E',mean(ber_ffe_mlse)),' WORST:',sprintf('%.1E',max(ber_ffe_mlse)),'. Out of ',num2str(numel(ber_ffe_mlse))]);
|
|
disp(['VNLE EQ: BEST BER: ',sprintf('%.1E',min(ber_vnle)),' AVG BER: ',sprintf('%.1E',mean(ber_vnle)),' WORST:',sprintf('%.1E',max(ber_vnle)),'. Out of ',num2str(numel(ber_vnle))]);
|
|
% disp(['VNLE+MLSE EQ: BEST BER: ',sprintf('%.1E',min(ber_vnle_mlse)),' AVG BER: ',sprintf('%.1E',mean(ber_vnle_mlse)),' WORST:',sprintf('%.1E',max(ber_vnle_mlse)),'. Out of ',num2str(numel(ber_vnle_mlse))]);
|
|
|
|
elseif db_channel_approach %%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
ffe = EQ("Ne",[50,0,0],"Nb",[0,0,0],"training_length",4096*2,"training_loops",5,"dd_loops",5,"K",2,"DCmu",0.05,"DDmu",[0.0004 0.0004 0.0004 0.0004 ],"DFEmu",0.005,"FFEmu",0,"plotfinal",0,"ideal_dfe",1);
|
|
ffe = EQ("Ne",[50,7,7],"Nb",[0,0,0],"training_length",4096*2,"training_loops",5,"dd_loops",5,"K",2,"DCmu",0.05,"DDmu",[0.0004 0.0004 0.0004 0.0004 ],"DFEmu",0.005,"FFEmu",0,"plotfinal",0,"ideal_dfe",1);
|
|
|
|
if 0
|
|
|
|
eq_values = min(numel(S),8);
|
|
Noi = cell(eq_values,1);
|
|
EQ_sig = cell(eq_values,1);
|
|
|
|
parfor s = 1:eq_values
|
|
|
|
Scpe_sig_syncd = S{s};
|
|
|
|
[EQ_sig{s}, Noi{s}] = ffe.process(Scpe_sig_syncd,Duobinary().encode(Symbols));
|
|
|
|
EQ_sig{s}.signal = EQ_sig{s}.signal-mean(EQ_sig{s}.signal);
|
|
|
|
EQ_sig_mlse = MLSE("DIR",[1,1],"duobinary_output",1,"M",M,"trellis_states",PAMmapper(M,0).levels).process(EQ_sig{s});
|
|
|
|
EQ_sig_mlse = Duobinary().decode(EQ_sig_mlse);
|
|
|
|
Rx_bits = PAMmapper(M,0).demap(EQ_sig_mlse);
|
|
|
|
[~,num_errors,ber_db(s),pos_errors] = calc_ber(Rx_bits.signal,Bits.signal,"skip_front",100,"skip_end",150,"returnErrorLocation",1);
|
|
|
|
end
|
|
|
|
if 0
|
|
Noi{1}.spectrum('displayname',['Noise; SIR:',sprintf('%.2f',sir)],'fignum',40,'normalizeTo0dB',1);
|
|
|
|
Duobinary().encode(Symbols).spectrum('displayname',['DB coded symbols; SIR:',sprintf('%.2f',sir)],'fignum',40,'normalizeTo0dB',1);
|
|
EQ_sig{1}.spectrum('displayname',['EQ; SIR:',sprintf('%.2f',sir)],'fignum',40,'normalizeTo0dB',1);
|
|
EQ_sig{1}.signal = EQ_sig{1}.signal-mean(EQ_sig{1}.signal);
|
|
end
|
|
|
|
disp(['DB EQ: BEST BER: ',sprintf('%.1E',min(ber_db)),' AVG BER: ',sprintf('%.1E',mean(ber_db)),' WORST:',sprintf('%.1E',max(ber_db)),'. Out of',num2str(numel(ber_db))]);
|
|
|
|
else
|
|
|
|
disp('Disabled MLSE for DB in all cases, due to time in measurement loop')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
%%%%% Store measurement into measurement "warehouse" %%%%%%
|
|
wh.addValueToStorage({ber_ffe},'ber_ffe',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage({ber_ffe_mlse},'ber_ffe_mlse',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage({ber_vnle},'ber_vnle',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage({ber_vnle_mlse},'ber_vnle_mlse',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage({ber_db},'ber_db',M,bitrate,db,interference_atten);
|
|
|
|
wh.addValueToStorage(rop,'rop',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage(pd_in,'pd_in',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage(s_power,'s_power',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage(i_power,'i_power',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage(sir,'sir',M,bitrate,db,interference_atten);
|
|
|
|
wh.addValueToStorage(M,'m',M,bitrate,db,interference_atten);
|
|
|
|
wh.addValueToStorage(dcs,'dcs',M,bitrate,db,interference_atten);
|
|
|
|
exfo = Exfo_laser("serialport_number",'COM8','mainframe_channel',1,'safety_mode',0);
|
|
exfo.getLaserInfo;
|
|
|
|
wh.addValueToStorage(exfo,'exfo',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage(voa,'voa',M,bitrate,db,interference_atten);
|
|
|
|
wh.addValueToStorage(ffe,'FFE',M,bitrate,db,interference_atten);
|
|
wh.addValueToStorage(vnle,'VNLE',M,bitrate,db,interference_atten);
|
|
|
|
iterationTimes(loopcnt) = toc(iterationStartTime);
|
|
averageTimePerIteration = mean(iterationTimes(1:loopcnt));
|
|
estimatedTotalTime = averageTimePerIteration * looptotal;
|
|
estimatedTimeRemaining = estimatedTotalTime - sum(iterationTimes(1:loopcnt));
|
|
progressFraction = loopcnt / looptotal;
|
|
waitbar(progressFraction, hWaitbar, ...
|
|
sprintf('Loop: %d of %d \n Runtime: %.1f min | %.1f sec per Loop |Time to go: %.1f min ', ...
|
|
loopcnt, looptotal, sum(iterationTimes(1:loopcnt))/60, averageTimePerIteration, estimatedTimeRemaining/60 ));
|
|
|
|
wh.save([folderpath,experiment_name,'_wh']);
|
|
|
|
showCurrentMeasurement('SIR', sir, 'I Att', interference_atten,'BER V', min(ber_vnle),'BER M',min(ber_vnle_mlse),'BER DB',min(ber_db),'Fsym',fsym.*1e-9, 'ROP', rop, 'PAM',M);
|
|
|
|
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
close(hWaitbar);
|
|
|
|
wh.save([folderpath,experiment_name,'_wh']);
|
|
|
|
disp('Measurement complete')
|