Matlab Model Serdes Systems

% WRONG — TxModel is not a cell array
sys.TxModel = {serdes.FFE('TapWeights', [-0.1 0.8 -0.1])};

% CORRECT — use Transmitter/Receiver wrapper objects
sys = SerdesSystem(...
    'TxModel', Transmitter('Blocks', {serdes.FFE('TapWeights', [-0.1 0.8 -0.1])}), ...
    'RxModel', Receiver('Blocks', {serdes.CTLE, serdes.DFECDR}));

% WRONG — Loss is a property of serdes.ChannelLoss, not ChannelData
sys.ChannelData.Loss = 15;
sys.ChannelData.TargetFrequency = 14e9;

% CORRECT — ChannelData uses ChannelLossdB and ChannelLossFreq
sys.ChannelData.ChannelLossdB = 15;
sys.ChannelData.ChannelLossFreq = 14e9;
sys.ChannelData.ChannelDifferentialImpedance = 100;

% WRONG — ChannelLossFreq defaults to 5 GHz, far below Nyquist for most links.
% At 28 GBaud, Nyquist=14 GHz. Specifying 15 dB at 5 GHz means loss at 14 GHz
% is ~40+ dB — the eye appears closed even with strong equalization.
sys.ChannelData.ChannelLossdB = 15;
% ChannelLossFreq is still 5 GHz (default) — channel is MUCH lossier than intended

% CORRECT — always set ChannelLossFreq to Nyquist (BaudRate / 2)
sys.ChannelData.ChannelLossdB = 15;
sys.ChannelData.ChannelLossFreq = 1 / (2 * sys.SymbolTime);  % Nyquist frequency

% WRONG — default Specification is "DC Gain and Peaking Gain", ACGain is ignored
ctle = serdes.CTLE('DCGain', 0, 'ACGain', 12);  % Warning: ACGain not relevant

% CORRECT — set Specification first
ctle = serdes.CTLE('Specification', "DC Gain and AC Gain", ...
                    'DCGain', 0, 'ACGain', 12);

% WRONG — FFE and AGC only support Mode 0 and 1
txFFE = serdes.FFE;
txFFE.Mode = 2;  % ERROR: not a valid value

% CORRECT — only CTLE, DFECDR, and DFE support Mode=2 (Adaptive)
txFFE = serdes.FFE;
txFFE.Mode = 1;            % Fixed, exported as AMI parameter
rxDFECDR = serdes.DFECDR;
rxDFECDR.Mode = 2;         % Adaptive — requires Dual model
% Note: CDR.Mode is deprecated and will be removed in a future release

% WRONG — DFECDR.Mode=2 (adaptive) but Init-Only model cannot run GetWave
% DFE taps stay at initial values, CDR never converges

% CORRECT — when any block uses Mode=2, configure a Dual model:
% R2026a+: set via serdes.AMIExport
AMIExport = serdes.AMIExport("myModel");
AMIExport.ModelTypeRx = "Dual model";  % Init_Returns_Impulse=true AND GetWave_Exists=true
export(AMIExport);
% R2025b and earlier: open IbisAmiManager GUI, set Init_Returns_Impulse=true AND GetWave_Exists=true

% WRONG — row vector causes error
impulse = zeros(1, 128);
impulse(1) = 1;
pulse = impulse2pulse(impulse, 16, 6.25e-12);  % ERROR

% CORRECT — use column vectors
impulse = zeros(128, 1);
impulse(1) = 1;
pulse = impulse2pulse(impulse, 16, 6.25e-12);  % OK

% WRONG — treating Rj as peak-to-peak
jn = JitterAndNoise;
jn.Tx_Rj = 10e-12;  % If this is peak-to-peak, value is ~5x too high

% CORRECT — Rj is standard deviation per IBIS 7.0
jn = JitterAndNoise;
jn.Tx_Rj = 1e-12;   % 1 ps RMS (standard deviation)
jn.Tx_Dj = 5e-12;   % Dj IS peak-to-peak

% WRONG — these functions do not exist in SerDes Toolbox
ibisData = readIBIS("model.ibs");
exportAMI(sys, "output.ami");
generateAMI(sys);

% CORRECT — IBIS-AMI generation requires a Simulink model
% Option A (R2026a+): serdes.AMIExport — fully programmatic
%   1. exportToSimulink(sys)
%   2. ae = serdes.AMIExport("modelName"); ae.DLLFiles = true; export(ae);
% Option B: IbisAmiManager GUI
%   1. exportToSimulink(sys)
%   2. Open IbisAmiManager from the Configuration block
%   3. Configure and Generate from within the app
% Option C: slbuild (R2025b and earlier, requires Simulink Coder + Embedded Coder)
%   1. exportToSimulink(sys)
%   2. Configure AMI settings (IbisAmiManager or programmatic)
%   3. slbuild('modelName/Tx') and slbuild('modelName/Rx')
% For loading compiled DLLs/SOs, use serdes.AMI

% WRONG — WaveType defaults to "Sample", impulse processing gives wrong result
ffe = serdes.FFE('TapWeights', [-0.1 0.8 -0.1]);
ffe.SymbolTime = 100e-12;
ffe.SampleInterval = 6.25e-12;
y = ffe(impulseResponse);  % Processes as time-domain samples

% CORRECT — set WaveType to "Impulse" for impulse processing
ffe = serdes.FFE('TapWeights', [-0.1 0.8 -0.1]);
ffe.SymbolTime = 100e-12;
ffe.SampleInterval = 6.25e-12;
ffe.WaveType = "Impulse";
y = ffe(impulseResponse);  % Correct impulse-domain processing

% WRONG — Transmitter rejects string property names
tx = Transmitter("Blocks", {serdes.FFE});  % ERROR: ismember fails on string

% CORRECT — use char vectors (single quotes) for Transmitter
tx = Transmitter('Blocks', {serdes.FFE});  % OK
% Note: Receiver("Blocks", ...) accepts strings fine; only Transmitter fails
% serdes.* block constructors and SerdesSystem also accept strings fine

% WRONG — treating results.pulse as a column vector
results = analysis(sys);
metrics = optPulseMetric(results.pulse, 16, sys.dt, 1e-6);  % ERROR: not a vector

% CORRECT — column 1 = unequalized, column 2 = equalized
eqPulse = results.pulse(:, 2);    % equalized pulse (column vector)
metrics = optPulseMetric(eqPulse, 16, sys.dt, 1e-6);  % OK
% Same for results.impulse and results.wave

% WRONG — expecting optPulseMetric to reflect JitterAndNoise settings
sys.JitterAndNoise.Tx_Rj = 2e-12;
results = analysis(sys);
metrics = optPulseMetric(results.pulse(:, 2), 16, sys.dt, 1e-6);
% metrics.maxEyeHeight is IDENTICAL with or without jitter — it's LTI only

% CORRECT — use sys.Metrics for jitter-aware statistical eye metrics
analysis(sys);
eyeHeight = sys.Metrics.summary.EH;  % eye height at BERtarget, includes jitter

% WRONG assumption — plotStatEye does NOT create a tiledlayout.
% It renders into the current axes, so both title() and sgtitle() work.

% OK — title() works directly on the axes
plotStatEye(sys);
title("My Custom Title");

% OK — subplot and tiledlayout both work
figure; subplot(1,2,1); plotStatEye(sysA); title("Config A");
        subplot(1,2,2); plotStatEye(sysB); title("Config B");

% OK — tiledlayout works too
figure; tiledlayout(1,2);
nexttile; plotStatEye(sysA); title("Config A");
nexttile; plotStatEye(sysB); title("Config B");

% WRONG — jitter properties are SimpleJitter objects, not doubles
jn = JitterAndNoise;
jn.Tx_Rj = 1e-12;
rjVal = jn.Tx_Rj * 1e12;  % ERROR: "Invalid data type"

% CORRECT — use .Value to read; direct assignment auto-sets Include=true
rjVal = jn.Tx_Rj.Value * 1e12;  % OK
% Note: jn.Tx_Rj.Value = 1e-12 alone leaves Include=false (jitter ignored)

% WRONG — root name does not match Simulink model name
ami.InputString = "(mySerDesModel_Tx)";  % ERROR: root name mismatch

% CORRECT — exported DLLs use serdes_tx / serdes_rx as default root names
ami.InputString = "(serdes_tx)";   % Tx DLL
ami.InputString = "(serdes_rx)";   % Rx DLL
% Or use generateDefaultInputString to extract from .ami file

% WRONG — post-hoc assignment silently ignored, loss model runs
sys.ChannelData.Impulse = spCh.ImpulseResponse;
sys.ChannelData.dt = spCh.SampleInterval;

% CORRECT — pass Impulse and dt as constructor name-value pairs
channel = ChannelData("Impulse", spCh.ImpulseResponse, "dt", spCh.SampleInterval);
sys = SerdesSystem("ChannelData", channel, ...);

% WRONG — positional syntax does not work
spCh = SParameterChannel("channel.s4p");

% CORRECT — use "FileName" name-value pair
spCh = SParameterChannel("FileName", "channel.s4p");

% WRONG — default PeakingFrequency is 5 GHz, only correct for ~10 Gbps NRZ
ctle = serdes.CTLE('Specification', "DC Gain and AC Gain", ...
    'DCGain', 0, 'ACGain', 10);  % PeakingFrequency = 5 GHz (default)

% CORRECT — set PeakingFrequency to Nyquist = 1/(2*SymbolTime)
% 56 Gbps PAM4 → SymbolTime=35.71 ps → Nyquist=14 GHz
ctle = serdes.CTLE('Specification', "DC Gain and AC Gain", ...
    'DCGain', 0, 'ACGain', 10, ...
    'PeakingFrequency', 1 / (2 * 35.71e-12));  % 14 GHz
% Impact: ~3 dB COM improvement on a 15 dB loss PAM4 channel

% WRONG — these set_param parameter names do not exist
set_param('model/Tx', 'AMIVersion', '7.0');
set_param('model/Tx', 'ExportAMI', 'on');
set_param('model/Rx', 'Description', 'My Rx Model');

% CORRECT — AMI export uses *AMI suffix on block property names
get_param('model/Tx/FFE', 'ModeAMI')          % 'on' or 'off'
get_param('model/Tx/FFE', 'TapWeightsAMI')    % 'on' or 'off'
get_param('model/Rx/CTLE', 'ConfigSelectAMI')  % 'on' or 'off'
set_param('model/Tx/FFE', 'ModeAMI', 'off');   % disable from AMI export
% AMI version, model type, IBIS metadata are set via IbisAmiManager or serdes.AMIExport
% NOT via set_param on the top-level model

% WRONG — block object retains INITIAL values, not adapted values
results = analysis(sys);
dfeTaps = sys.RxModel.Blocks{2}.TapWeights;  % Still zeros!

% CORRECT — adapted parameters are in results.outparams
% outparams is a cell array: one entry per datapath block (Tx first, then Rx)
results = analysis(sys);
for p = 1:numel(results.outparams)
    if isstruct(results.outparams{p}) && isfield(results.outparams{p}, 'DFECDR')
        dfeTaps = results.outparams{p}.DFECDR.TapWeights;  % Solver's adapted values
        phase = results.outparams{p}.DFECDR.Phase;          % Recovered clock phase
    end
end
% With FFE + CTLE + DFECDR: outparams{1}=FFE, outparams{2}=CTLE, outparams{3}=DFECDR

% WRONG — bare Transmitter/Receiver omit analog termination and clock model
sys = SerdesSystem(...
    'TxModel', Transmitter('Blocks', {serdes.FFE(...)}), ...
    'RxModel', Receiver('Blocks', {serdes.CTLE(...), serdes.DFECDR(...)}), ...
    'SymbolTime', 35.71e-12, 'SamplesPerSymbol', 16, 'Modulation', 4);

% CORRECT — include AnalogModel and JitterAndNoise for realistic results
sys = SerdesSystem(...
    'TxModel', Transmitter('Blocks', {serdes.FFE(...)}, ...
        'AnalogModel', AnalogModel('R', 50, 'C', 1e-13), ...
        'RiseTime', 1e-11, 'VoltageSwingIdeal', 1), ...
    'RxModel', Receiver('Blocks', {serdes.CTLE(...), serdes.DFECDR(...)}, ...
        'AnalogModel', AnalogModel('R', 50, 'C', 2e-13)), ...
    'JitterAndNoise', JitterAndNoise('RxClockMode', 'clocked'), ...
    'SymbolTime', 35.71e-12, 'SamplesPerSymbol', 16, ...
    'Modulation', 4, 'Signaling', 'Differential', 'BERtarget', 1e-6);

% WRONG — ConfigSelect has no effect with default Mode=0
ctle = serdes.CTLE('Specification', "GPZ Matrix", ...
    'GPZ', gpzMatrix, 'ConfigSelect', 3);
% Always uses row 0 regardless of ConfigSelect value

% CORRECT — Mode=1 enables ConfigSelect switching
ctle = serdes.CTLE('Specification', "GPZ Matrix", ...
    'GPZ', gpzMatrix, 'ConfigSelect', 3, 'Mode', 1);

% WRONG — Include defaults to false, jitter value stored but excluded from analysis
sj = SimpleJitter;
sj.Value = 3e-12;
sj.Type = "Float";
jn.Tx_DCD = sj;      % Value is 3 ps but Include=false → analysis ignores it

% Also wrong — .Value assignment alone leaves Include=false
sj = jn.Tx_DCD;
sj.Value = 3e-12;    % Include is still false from default
jn.Tx_DCD = sj;      % no effect on analysis results

% CORRECT — use direct scalar assignment (auto-sets Include=true)
jn.Tx_DCD = 3e-12;   % sets Value=3e-12, Include=true, Type="Float"

% Or construct SimpleJitter with Include=true explicitly
sj = SimpleJitter('Value', 3e-12, 'Include', true, 'Type', 'Float');
jn.Tx_DCD = sj;

% UI type also works — Value is in unit intervals, converted internally
sj = SimpleJitter('Value', 0.084, 'Include', true, 'Type', 'UI');
jn.Tx_DCD = sj;      % 0.084 UI → analysis converts using SymbolTime

% WRONG — Rx jitter has NO effect with ideal clock
jn = JitterAndNoise('RxClockMode', 'ideal');
jn.Rx_Rj = 2e-12;   % silently ignored

% CORRECT — Rx jitter only affects analysis with clocked mode
jn = JitterAndNoise('RxClockMode', 'clocked');
jn.Rx_Rj = 2e-12;   % now degrades the eye

% WRONG — impulse from analysis() is in V/s, amplitudes blow up by ~10^11
chImpulse = results.impulse(:, 1);
w = filter(chImpulse, 1, stimWave);  % output range: ±86 billion V

% CORRECT — multiply by dt to convert V/s → unitless FIR coefficients
w = filter(chImpulse * dt, 1, stimWave);  % output range: ±0.19 V

% WRONG — DFECDR defaults to NRZ, PAM4 adaptation fails silently
dfecdr = serdes.DFECDR('TapWeights', zeros(1, 5), 'Mode', 2);
dfecdr.SymbolTime = symbolTime;
dfecdr.SampleInterval = dt;
dfecdr.WaveType = "Sample";
% Adapts as NRZ → eye stays closed for PAM4 input

% CORRECT — set Modulation explicitly for PAM-N
dfecdr = serdes.DFECDR('TapWeights', zeros(1, 5), 'Mode', 2);
dfecdr.SymbolTime = symbolTime;
dfecdr.SampleInterval = dt;
dfecdr.WaveType = "Sample";
dfecdr.Modulation = 4;  % PAM4 — required for correct adaptation

% pulse2wave operates on whatever stimulus is provided
% Output modulation depends on the input pattern (NRZ or PAM-N)
prbsSeq = prbs(10, 1023 * samplesPerSymbol);
wave = pulse2wave(eqPulse, prbsSeq, samplesPerSymbol);

% For PAM-N eye analysis, use eyeDiagramSI with correct Modulation setting
eyeObj = eyeDiagramSI;
eyeObj.Modulation = modulation;
eyeObj.SampleInterval = dt;
eyeObj.SymbolTime = symbolTime;
eyeObj(wave);

% WRONG — Mode=0 does NOT apply DFE correction in Sample mode
dfecdr = serdes.DFECDR('TapWeights', [-0.05 0.11 0.07 0.04 0.02], 'Mode', 0);
dfecdr.WaveType = "Sample";
y = zeros(size(w)); for k = 1:numel(w), y(k) = dfecdr(w(k)); end
% y ≈ w — DFE taps are ignored, signal passes through unchanged

% CORRECT — use Mode=1 (fixed) or Mode=2 (adaptive) for DFE to function
dfecdr = serdes.DFECDR('TapWeights', [-0.05 0.11 0.07 0.04 0.02], 'Mode', 1);
dfecdr.WaveType = "Sample";
y = zeros(size(w)); for k = 1:numel(w), y(k) = dfecdr(w(k)); end
% y has DFE correction applied — eye opens

% WRONG — TapWeights property always shows INITIAL values
dfecdr = serdes.DFECDR('TapWeights', zeros(1, 5), 'Mode', 2);
dfecdr.WaveType = "Sample";
for k = 1:numel(w), y(k) = dfecdr(w(k)); end
fprintf("Taps: %s\n", mat2str(dfecdr.TapWeights));  % always [0 0 0 0 0]

% CORRECT — capture adapted taps from the SECOND output
dfecdr = serdes.DFECDR('TapWeights', zeros(1, 5), 'Mode', 2);
dfecdr.WaveType = "Sample";
for k = 1:numel(w), [y(k), adaptedTaps, phase] = dfecdr(w(k)); end
fprintf("Taps: %s\n", mat2str(adaptedTaps));  % shows actual adapted values

% WRONG — default gain needs 80K+ symbols to converge
dfecdr = serdes.DFECDR('TapWeights', zeros(1, 5), 'Mode', 2);
% EqualizationGain = 9.6e-05 (default)
% After 20K symbols: taps reach only ~25% of target

% CORRECT — increase gain for faster convergence in MATLAB chains
dfecdr = serdes.DFECDR('TapWeights', zeros(1, 5), 'Mode', 2);
dfecdr.EqualizationGain = 9.6e-04;  % 10x default
% After 20K symbols: taps reach ~100% of target
%
% Or: pre-load adapted taps from analysis() for instant convergence
adaptedTaps = results.outparams{end}.DFECDR.TapWeights;
dfecdr = serdes.DFECDR('TapWeights', adaptedTaps, 'Mode', 1);

% WRONG — stimulus longer than impulse causes MATLAB process crash (segfault)
chImpulse = results.impulse(:, 1);   % e.g. 16253 samples
prbsWave = repelem(levels, sps);     % e.g. 16368 samples (longer!)
txAmi.RowSize = numel(prbsWave);
[out, ~] = txAmi(prbsWave, chImpulse, -1);  % CRASHES MATLAB — no error, process terminates

% CORRECT — zero-pad impulse to match stimulus length
chImpulse = results.impulse(:, 1);
if numel(prbsWave) > numel(chImpulse)
    chImpulse = [chImpulse; zeros(numel(prbsWave) - numel(chImpulse), 1)];
end
txAmi.RowSize = numel(prbsWave);
[out, ~] = txAmi(prbsWave, chImpulse, -1);  % OK

% WRONG — serdes.AMI is for standalone validation, not Simulink integration
ami = serdes.AMI;
ami.LibraryName = "vendor_tx";
ami.LibraryPath = "C:/vendor/dlls";
% This works for quick Init/GetWave checks but does NOT integrate into
% a Simulink time-domain simulation

% CORRECT — for Simulink integration, use the AMI block in the testbench
% 1. Create testbench: exportToSimulink(sys)
% 2. Open Configuration block -> IbisAmiManager
% 3. Import vendor .ami/.ibs/.dll files for Tx and/or Rx
% 4. Run: out = sim(mdl)
%
% Use serdes.AMI only for standalone validation outside Simulink
% (e.g., comparing Init impulse response against behavioral reference)

% WRONG — SamplesPerSymbol is read-only (hidden, protected) on DFECDR
dfecdr = serdes.DFECDR("Mode", 2, "TapWeights", zeros(1, 5), ...
    "SymbolTime", symbolTime, "SamplesPerSymbol", 16, "Modulation", 4);
% Error: Unable to set the 'SamplesPerSymbol' property ... because it is read-only

% CORRECT — omit SamplesPerSymbol; SerdesSystem sets it automatically
dfecdr = serdes.DFECDR("Mode", 2, "TapWeights", zeros(1, 5), ...
    "SymbolTime", symbolTime, "Modulation", 4);

% For standalone use, set SampleInterval instead
dfecdr.SampleInterval = symbolTime / 16;

% WRONG — Stimulus has no SamplesPerSymbol property, and only 1 output
stim = serdes.Stimulus("SamplesPerSymbol", 16, "SymbolTime", symbolTime, ...
    "Modulation", 2, "PRBS", 13);
[wave, t, symbols] = stim();  % ERROR: not accessible / too many outputs

% CORRECT — use SampleInterval, set Specification/Order, call in a loop
stim = serdes.Stimulus("SampleInterval", dt, "SymbolTime", symbolTime, ...
    "Modulation", 2);
stim.Specification = "PRBS";
stim.Order = 13;

numSamples = (2^13 - 1) * round(symbolTime / dt);
wave = zeros(numSamples, 1);
for k = 1:numSamples
    wave(k) = stim();
end

% WRONG — stat-analysis adapted taps assume different signal normalization
adaptedTaps = results.outparams{2}.DFECDR.TapWeights;
dfecdr = serdes.DFECDR("TapWeights", adaptedTaps, "Mode", 1, "Modulation", 4);
% Eye stays closed — taps from stat path don't transfer to PAM4 time-domain

% CORRECT — use adaptive DFE with high gain for PAM4 waveform processing
dfecdr = serdes.DFECDR("TapWeights", zeros(1, 10), "Mode", 2, ...
    "EqualizationGain", 5e-3, "Modulation", 4);
% Measure converged portion only (skip first ~2000 symbols)
eyeObj(eqWave(convergedStart:end));

% WRONG — JitterAndNoise is not a Transmitter or Receiver property
sys = SerdesSystem(...
    'TxModel', Transmitter('Blocks', {ffe}, 'JitterAndNoise', jn), ...  % ERROR
    ...);

% ALSO WRONG — cannot set post-hoc on Transmitter
sys.TxModel.JitterAndNoise = jn;  % ERROR: Unrecognized property

% CORRECT — JitterAndNoise is a SerdesSystem property
jn = JitterAndNoise;
jn.Tx_Rj = 2e-12;

sys = SerdesSystem(...
    'TxModel', Transmitter('Blocks', {ffe}), ...
    'RxModel', Receiver('Blocks', {ctle, dfecdr}), ...
    'JitterAndNoise', jn, ...        % on SerdesSystem, not Tx/Rx
    'SymbolTime', symbolTime, ...
    'SamplesPerSymbol', 16);