Matlab Model Serdes Systems

AMIExport = serdes.AMIExport              % from currently selected model
AMIExport = serdes.AMIExport("modelName") % from a specific model

% 1. Design and export to Simulink
sys = SerdesSystem(...
    'TxModel', Transmitter('Blocks', {serdes.FFE('TapWeights', [-0.1 0.8 -0.1])}), ...
    'RxModel', Receiver('Blocks', {serdes.CTLE, serdes.DFECDR}), ...
    'SymbolTime', 100e-12, ...
    'SamplesPerSymbol', 16);
exportToSimulink(sys);

% 2. Configure and export programmatically
AMIExport = serdes.AMIExport("untitled");
AMIExport.ModelsToExport = "Both Tx and Rx";
AMIExport.ModelTypeTx = "Init only";
AMIExport.ModelTypeRx = "Dual model";
AMIExport.DLLFiles = true;
AMIExport.LinuxCrossCompile = true;
AMIExport.TargetDir = fullfile(pwd, "export");
AMIExport.Obfuscate = false;

% 3. Review and export
getExportSettings(AMIExport);
export(AMIExport);

% Redriver: linear amplifier (CTLE + VGA, no CDR)
% Rx side: CTLE for frequency-dependent EQ, VGA for flat gain
sysRD = SerdesSystem(...
    'TxModel', Transmitter('Blocks', {serdes.FFE('TapWeights', [-0.1 0.8 -0.1])}), ...
    'RxModel', Receiver('Blocks', ...
        {serdes.CTLE('Specification', "DC Gain and AC Gain", 'DCGain', 0, 'ACGain', 10), ...
         serdes.VGA('Gain', 1.5)}), ...
    'SymbolTime', 100e-12, 'SamplesPerSymbol', 16, 'Modulation', 2);
exportToSimulink(sysRD);

ae = serdes.AMIExport("untitled");
ae.ModelConfiguration = "Redriver";
ae.TargetDir = fullfile(pwd, "export_redriver");
export(ae);  % builds AMI/IBIS/DLL for Tx; Rx code requires slbuild

% Retimer: regenerating repeater (full CDR + DFE)
% Rx side: CTLE + DFECDR with adaptation for clock/data recovery
sysRT = SerdesSystem(...
    'TxModel', Transmitter('Blocks', ...
        {serdes.FFE('TapWeights', [-0.1 0.7 -0.2])}), ...
    'RxModel', Receiver('Blocks', ...
        {serdes.CTLE('Specification', "DC Gain and AC Gain", ...
            'DCGain', 0, 'ACGain', 12, 'PeakingFrequency', 14e9), ...
         serdes.DFECDR('Mode', 2, 'TapWeights', zeros(1, 5), ...
            'SymbolTime', 1/28e9, 'Modulation', 4)}), ...
    'SymbolTime', 1/28e9, 'SamplesPerSymbol', 16, 'Modulation', 4);
exportToSimulink(sysRT);

ae = serdes.AMIExport("untitled");
ae.ModelConfiguration = "Retimer";
ae.ModelTypeTx = "Dual model";
ae.ModelTypeRx = "Dual model";
ae.TargetDir = fullfile(pwd, "export_retimer");
export(ae);

models = {"pcie5_link", "cei56g_link", "usb4_link"};
configs = {"Dual model", "Dual model", "Init only"};

for i = 1:numel(models)
    load_system(models{i});
    ae = serdes.AMIExport(models{i});
    ae.ModelsToExport = "Both Tx and Rx";
    ae.ModelTypeRx = configs{i};
    ae.DLLFiles = true;
    ae.LinuxCrossCompile = true;
    ae.TargetDir = fullfile(pwd, "export", models{i});
    export(ae);
    close_system(models{i}, 0);
end

% Design the SerDes system
sys = SerdesSystem(...
    'TxModel', Transmitter('Blocks', {serdes.FFE('TapWeights', [-0.1 0.8 -0.1])}), ...
    'RxModel', Receiver('Blocks', {serdes.CTLE, serdes.DFECDR}), ...
    'SymbolTime', 100e-12, ...
    'SamplesPerSymbol', 16, ...
    'Modulation', 2);

% Export to Simulink — creates a model with Tx, Rx, and Configuration blocks
exportToSimulink(sys);
mdl = 'untitled';  % default model name

% Build Tx and Rx AMI models
% Note: slbuild produces .ami/.ibs/.dll only when IbisAmiManager has been
% configured and saved in the model. Without configuration, slbuild
% generates only the .dll/.so (code generation without AMI metadata).
slbuild([mdl '/Tx']);
slbuild([mdl '/Rx']);

% Output directory structure (with IbisAmiManager configured):
%   <modelName>_build/
%   ├── Tx/
%   │   ├── <TxModelName>.ami
%   │   ├── <TxModelName>.ibs
%   │   └── <TxModelName>.dll  (or .so on Linux)
%   └── Rx/
%       ├── <RxModelName>.ami
%       ├── <RxModelName>.ibs
%       └── <RxModelName>.dll  (or .so on Linux)
%
% Output directory structure (without IbisAmiManager configured):
%   <modelName>_build/
%   ├── Tx/
%   │   └── <TxModelName>.dll  (or .so on Linux)  ← no .ami or .ibs
%   └── Rx/
%       └── <RxModelName>.dll  (or .so on Linux)

% Get reference from behavioral analysis
results = analysis(sys);
channelImpulse = results.impulse(:, 1);  % unequalized channel
simReference   = results.impulse(:, 2);  % equalized (behavioral)
N = numel(channelImpulse);
exportDir = fullfile(pwd, "export");

% Tx Init
txAmi = serdes.AMI;
txAmi.LibraryName = "serdes_tx_win64";
txAmi.LibraryPath = exportDir;
txAmi.SymbolTime = sys.SymbolTime;
txAmi.SampleInterval = sys.dt;
txAmi.InitOnly = true;
txAmi.RowSize = N;
txAmi.InputString = "(serdes_tx)";  % root name from .ami file
[~, txOut] = txAmi(zeros(N,1), channelImpulse, -1);

% Rx Init
rxAmi = serdes.AMI;
rxAmi.LibraryName = "serdes_rx_win64";
rxAmi.LibraryPath = exportDir;
rxAmi.SymbolTime = sys.SymbolTime;
rxAmi.SampleInterval = sys.dt;
rxAmi.InitOnly = true;
rxAmi.RowSize = N;
rxAmi.InputString = "(serdes_rx)";
[~, rxOut] = rxAmi(zeros(N,1), txOut, -1);

% Compare against behavioral reference — expect correlation ≈ 1.0
corrCoef = corrcoef(simReference, rxOut);
fprintf("Correlation: %.6f\n", corrCoef(1,2));

% 1. Run Simulink to get ground-truth channel output and Rx output
mdl = "mySerDesModel";
load_system(mdl);
% NOTE: 'rxOut' is logged by default. For 'chOut', manually enable signal
% logging on the Analog Channel output port in the Simulink model.
set_param(mdl, 'SaveOutput', 'on', 'SaveFormat', 'Dataset');
simOut = sim(mdl);
chSimWave = simOut.logsout.get('chOut').Values.Data(:);
rxSimWave = simOut.logsout.get('rxOut').Values.Data(:);

% 2. Set up Rx DLL
results = analysis(sys);
chImpulse = results.impulse(:, 1);
N = numel(chImpulse);
exportDir = fullfile(pwd, "export");
blockSize = 1024;

rxAmi = serdes.AMI;
rxAmi.LibraryName    = "serdes_rx_win64";
rxAmi.LibraryPath    = exportDir;
rxAmi.SymbolTime     = sys.SymbolTime;
rxAmi.SampleInterval = sys.dt;
rxAmi.InitOnly       = false;       % Init + GetWave
rxAmi.SkipFirstBlock = false;       % required when calling from MATLAB
rxAmi.RowSize        = N;           % must match numel(chImpulse)
rxAmi.BlockSize      = blockSize;
rxAmi.InputString    = "(serdes_rx)";

% 3. Run DLL in chunked loop — one call per BlockSize chunk
Nsim = numel(chSimWave);
nPad = ceil(Nsim / blockSize) * blockSize;
wavePad = [chSimWave; zeros(nPad - Nsim, 1)];
waveOut = zeros(nPad, 1);
clockIn = -ones(blockSize, 1);

for k = 1:nPad/blockSize
    idx = (k-1)*blockSize + (1:blockSize);
    [waveOut(idx), ~] = rxAmi(wavePad(idx), chImpulse, clockIn);
end
dllWave = waveOut(1:Nsim);

% 4. Verify sample-for-sample correlation
R = corrcoef(rxSimWave, dllWave);
fprintf("GetWave vs Simulink correlation: %.15f\n", R(1,2));  % expect 1.0
fprintf("Max abs diff: %.2e\n", max(abs(rxSimWave - dllWave)));

% 5. Analyze with eyeDiagramSI
eyeObj = eyeDiagramSI;
eyeObj.SampleInterval = sys.dt;
eyeObj.SymbolTime = sys.SymbolTime;
eyeObj.Modulation = sys.Modulation;
eyeObj(dllWave);
fprintf("AMI GetWave — EH: %.1f mV, EW: %.1f ps, COM: %.2f dB\n", ...
    eyeHeight(eyeObj)*1e3, eyeWidth(eyeObj)*1e12, com(eyeObj));

% Extract blocks and set WaveType = "Sample"
txBlocks = sys.TxModel.Blocks;
rxBlocks = sys.RxModel.Blocks;
for i = 1:numel(txBlocks)
    txBlocks{i}.SymbolTime = sys.SymbolTime;
    txBlocks{i}.SampleInterval = sys.dt;
    txBlocks{i}.WaveType = "Sample";
end
for i = 1:numel(rxBlocks)
    rxBlocks{i}.SymbolTime = sys.SymbolTime;
    rxBlocks{i}.SampleInterval = sys.dt;
    rxBlocks{i}.WaveType = "Sample";
end

% Stream through Tx chain (FFE accepts full vector)
w = prbsWave;
for i = 1:numel(txBlocks)
    w = txBlocks{i}(w);
end

% Stream through Rx chain — DFECDR/DFE require sample-by-sample
for i = 1:numel(rxBlocks)
    block = rxBlocks{i};
    if isa(block, 'serdes.DFECDR') || isa(block, 'serdes.DFE')
        wOut = zeros(size(w));
        for k = 1:numel(w)
            wOut(k) = block(w(k));
        end
        w = wOut;
    else
        w = block(w);
    end
end

% Analyze
eyeObj2 = eyeDiagramSI;
eyeObj2.SampleInterval = sys.dt;
eyeObj2.SymbolTime = sys.SymbolTime;
eyeObj2.Modulation = sys.Modulation;
eyeObj2(w);
fprintf("SysObj chain — EH: %.1f mV, EW: %.1f ps, COM: %.2f dB\n", ...
    eyeHeight(eyeObj2)*1e3, eyeWidth(eyeObj2)*1e12, com(eyeObj2));

% Check current C compiler
mex -setup C

% List available compilers
compilersC = mex.getCompilerConfigurations('C');
disp({compilersC.Name}')

% One-time setup — downloads and configures Linux GCC toolchain
% Takes ~2.5 hours, requires ~12.5 GB disk space
serdes.utilities.createCrossCompiler

% After setup, select the cross-compiler toolchain in IbisAmiManager
% or set it programmatically before slbuild:
%   Model Configuration Parameters > Code Generation > Toolchain
%   Select: "SerDes Linux Cross-Compiler"

% Check which FFE parameters will be exported to AMI
get_param('untitled/Tx/FFE', 'ModeAMI')         % 'on' or 'off'
get_param('untitled/Tx/FFE', 'TapWeightsAMI')   % 'on' or 'off'

% CTLE AMI parameters
get_param('untitled/Rx/CTLE', 'ModeAMI')
get_param('untitled/Rx/CTLE', 'ConfigSelectAMI')
get_param('untitled/Rx/CTLE', 'SliceSelectAMI')

% DFECDR AMI parameters
get_param('untitled/Rx/DFECDR', 'ModeAMI')
get_param('untitled/Rx/DFECDR', 'TapWeightsAMI')
get_param('untitled/Rx/DFECDR', 'PhaseOffsetAMI')
get_param('untitled/Rx/DFECDR', 'ReferenceOffsetAMI')

% Disable a parameter from AMI export
set_param('untitled/Tx/FFE', 'ModeAMI', 'off');

% Batch-build AMI models for multiple configurations
models = {"pcie5_link", "cei56g_link", "usb4_link"};
subsystems = {"Tx", "Rx"};

for i = 1:numel(models)
    mdl = models{i};
    load_system(mdl);
    for j = 1:numel(subsystems)
        fprintf("Building %s/%s...\n", mdl, subsystems{j});
        slbuild([mdl '/' subsystems{j}]);
    end
    close_system(mdl, 0);
end
fprintf("All builds complete.\n");

'Tx.bat' is not recognized as an internal or external command

% Save and clear the security setting
origVal = getenv('NoDefaultCurrentDirectoryInExePath');
setenv('NoDefaultCurrentDirectoryInExePath', '');

% Run export — both Tx and Rx build successfully
ae = serdes.AMIExport(mdl);
ae.ModelsToExport = "Both Tx and Rx";
ae.DLLFiles = true;
ae.TargetDir = fullfile(pwd, "export");
export(ae);

% Restore
setenv('NoDefaultCurrentDirectoryInExePath', origVal);

exportToSimulink(sys);
% Then: open model → Configuration block → "Open SerDes IBIS-AMI Manager"
% → configure AMI parameters + IBIS component/pin data → Generate

results = analysis(sys);
chImpulse = results.impulse(:, 1);  % unequalized channel
N = numel(chImpulse);
exportDir = fullfile(pwd, "export");

% LibraryName = DLL filename without .dll (export() produces serdes_tx_win64.dll)
% InputString root = .ami file root name (serdes_tx)
txAmi = serdes.AMI;
txAmi.LibraryName = "serdes_tx_win64";  txAmi.LibraryPath = exportDir;
txAmi.SymbolTime = sys.SymbolTime;      txAmi.SampleInterval = sys.dt;
txAmi.InitOnly = true;  txAmi.RowSize = N;  txAmi.InputString = "(serdes_tx)";
[~, txImp] = txAmi(zeros(N, 1), chImpulse, -1);

rxAmi = serdes.AMI;
rxAmi.LibraryName = "serdes_rx_win64";  rxAmi.LibraryPath = exportDir;
rxAmi.SymbolTime = sys.SymbolTime;      rxAmi.SampleInterval = sys.dt;
rxAmi.InitOnly = true;  rxAmi.RowSize = N;  rxAmi.InputString = "(serdes_rx)";
[~, rxImp] = rxAmi(zeros(N, 1), txImp, -1);

R = corrcoef(rxImp, results.impulse(:, 2));
fprintf("Init correlation: %.6f\n", R(1, 2));  % expect ≈ 1.0

% GetWave validation — chunked loop (requires manual signal logging on chOut)
% Log Analog Channel output in Simulink as 'chOut', Rx output as 'rxOut'
blockSize = 1024;
rxAmiGW = serdes.AMI;
rxAmiGW.LibraryName = "serdes_rx_win64";  rxAmiGW.LibraryPath = exportDir;
rxAmiGW.SymbolTime = sys.SymbolTime;      rxAmiGW.SampleInterval = sys.dt;
rxAmiGW.InitOnly = false;       rxAmiGW.SkipFirstBlock = false;
rxAmiGW.RowSize = N;            rxAmiGW.BlockSize = blockSize;
rxAmiGW.InputString = "(serdes_rx)";

Nsim = numel(chSimWave);  % chSimWave from Simulink logsout 'chOut'
nPad = ceil(Nsim / blockSize) * blockSize;
wavePad = [chSimWave; zeros(nPad - Nsim, 1)];
waveOut = zeros(nPad, 1);  clockIn = -ones(blockSize, 1);
for k = 1:nPad/blockSize
    idx = (k-1)*blockSize + (1:blockSize);
    [waveOut(idx), ~] = rxAmiGW(wavePad(idx), chImpulse, clockIn);
end
dllWave = waveOut(1:Nsim);
R = corrcoef(rxSimWave, dllWave);  % rxSimWave from Simulink logsout 'rxOut'
fprintf("GetWave vs Simulink: %.15f\n", R(1, 2));  % expect 1.0

% R2026a+: Full programmatic control via serdes.AMIExport
AMIExport = serdes.AMIExport("mySerDesModel");
AMIExport.ModelsToExport = "Both Tx and Rx";
AMIExport.DLLFiles = true;
AMIExport.TargetDir = fullfile(pwd, "export");
export(AMIExport);  % generates .ami, .ibs, .dll/.so