root/PlatformSupport/sysgen2opb/sysgen2opb.m

% Copyright (c) 2006-2008 Rice University
% All Rights Reserved
% This code is covered by the Rice-WARP license
% See http://warp.rice.edu/license/ for details
%
% 'sysgen2opb' is a MATLAB script which converts a model built in Xilinx
% System Generator into an OPB-compliant peripheral for use with the 
% embedded PowerPCs. The script replaces all the model's From/To Registerse
% with memory mapped registers. It also creates the necessary address 
% decode logic and a C header file with the resulting register map. 
% 
% In addition, there is an option that can be turned on/off:
% Shared Memory Extension Script - This script adds in an option to allow
% the usage of Shared Memory. This script requires the usage of Dual Port
% RAM's.
%
% This script is only supported for Xilinx System Generator 8.1 and 8.2
%
% To run the script, type the following on the Matlab command line:
% sysgen2opb('yourModelName', 'yourSMChoice')
%
%Â  Â Replace 'yourModelName' with your Simulink model's name 
%Â  Â without the .mdl extension. 
%
%Â  Â Replace 'yourSMChoice' with one of the following:
%Â  Â  Â  Â 1. 'smon' which will turn on the Shared Memory Extension Script
%Â  Â  Â  Â 2. 'smoff' which will turn off the Shared Memory Extension Script 
%
% If you want to run the original script that utilizes From/To Registers
% with no shared memory extension, run: sysgen2opb('yourModelName')

function sysgen2opb(sys, varargin)
warning off;

% Run the model to see if there are any errors in the model
try
        sim(sys, 0)
catch
        display(['Error: Simulating the model resulted in error. Please check your model and initialization script.']);
        return;
end 

% Base Address is always zero due to relocatable memory
base = 0;

appendString = '';

% Look at the length of varargin to determine whether to run default
% scripts
if length(varargin) == 0
        %Defult to no shared memory
        smChoice = 'smoff';
elseif length(varargin) == 1
        smChoice = char(varargin(1));
else
        display('Unrecognized parameters on command line.');
        return;
end

% Find the sample time period from the System Generator block
sysgenblock = find_system(sys, 'block_type', 'sysgen');
if length(sysgenblock) == 0
        display(['Error: Please include a System Generator block.']);
        return;
elseif length(sysgenblock) > 1
        display(['Error: Please only include one System Generator block in model.']);
        return;
else
        sysgenperiod = get_param(sysgenblock, 'simulink_period');
        sysgenperiod = mat2str(cell2mat(sysgenperiod));
end

% Load the model. Inform the user if it fails to load (ie: the model does
% not exist)
try
        load_system(sys);
catch
        display(['Error: System ' sys ' does not exist']);
        return;
end

% Check smChoice
if ~(strcmp(smChoice, 'smon') | strcmp(smChoice, 'smoff'))
        display(['Error smChoice input ''' smChoice ''' does not exist. Please use ''smon'' or ''smoff'' as your inputs.']);
        return;
end


% Find the current sysgen version
try
        version = xlVersion;
catch
        display('Error: Sysgen is not found!');
        return;
end

if length(version) >= 1
        % The latest version is the first one in the cell
        version = version{1};
        % Get the first digit of the string array
        version = str2num(version(1:3)); 
else
        display('Error: Sysgen is not found!');
        return;
end

if ((version == 8.1) | (version == 8.2) | (version == 9.1))
        % Find the From/To Registers
        gatewaysInCheck = find_system(sys, 'LookUnderMasks', 'all', 'FollowLinks', 'on',   'block_type', 'fromreg');
        gatewaysOutCheck = find_system(sys, 'LookUnderMasks', 'all', 'FollowLinks', 'on',    'block_type', 'toreg');
else
        display(['Error: Version ' version ' is not supported.']);
        return;
end

% Check how many Gateways we have
numberGateways = length(gatewaysInCheck) + length(gatewaysOutCheck);
if numberGateways > 450
    display('Error: The script only allows a max of 450 From/To Registers');
        return;
elseif numberGateways == 0
    display('Error: The script needs From/To Regs within the model');
        return;
end

% Check to see if we have a converted model by checking if we have the
% Memory Mapped IO
% If we do, inform the user and exit the script
MemoryMappedIO = find_system(sys, 'LookUnderMasks', 'all', 'FollowLinks', 'on',  'BlockType', 'SubSystem', 'Name', 'Memory Mapped I_O');
if length(MemoryMappedIO) > 0
        display('You already have converted this design to a peripheral.');
        display('Please get rid of the Memory Mapped I_O block and make sure')
        display('your gateways are all still in place before trying again.');
        return;
end

% Try saving an unconverted backup
try
        save_system(sys,[sys '_unconverted_backup']);
catch
        % There's a system with that name that's opened right now
        % Close that system without saving
        close_system([sys '_unconverted_backup'], 0);

        % Save the backup system
        save_system(sys,[sys '_unconverted_backup']);
end
close_system([sys '_unconverted_backup']);

% Load the system
load_system(sys);
save_system(sys, sys, 'BreakLinks');

% Try loading a local copy from the skeleton model
% If it is not there, load it from the toolbox
spm = 'skeleton_periph_model';
try
        load_system(spm);
catch
        load_system([matlabroot '\toolbox\WARP\' spm]);
end

%Find Sybsystems and correct all the names
subsystems = find_system(sys,'LookUnderMasks', 'all', 'FollowLinks', 'on', 'BlockType', 'SubSystem');
%First we need to look for duplicate names
for c=1:length(subsystems)
        subsysName = subsystems{c};
        shortName = get_param(subsysName, 'Name');
        parent = get_param(subsysName, 'Parent');
        compName = [shortName '                 '];
        % Make sure that we do not edit the name of the System Generator
        if ~strcmp(compName(1:17), ' System Generator')
            idx=0;  %appended to the end of a duplicate name
            for d=c+1:length(subsystems)
                subsysName2 = subsystems{d};
                shortName2 = get_param(subsysName2,'Name');
                parent2 = get_param(subsysName2, 'Parent');
                if strcmp(parent, parent2) & strcmp(cleanName(shortName), cleanName(shortName2))
                    set_param(subsysName2,'Name', [shortName2 '_' int2str(idx)]);
                    idx=idx+1;            
                    subsystems = find_system(sys,'LookUnderMasks','all','BlockType','SubSystem')';
                end
            end
        end
end

% Update the Subsystem list
subsystems = find_system(sys, 'LookUnderMasks', 'all', 'FollowLinks', 'on',  'BlockType', 'SubSystem');
%Now for Subsystems with spaces, we want to clean up the name
for c=length(subsystems):-1:1
        subsysName = subsystems{c};
        shortName = get_param(subsysName, 'Name');
        compName = [shortName '                 '];
        % Make sure that we do not edit the name of the System Generator
        if ~strcmp(compName(1:17), ' System Generator')
            set_param(subsysName, 'Name', cleanName(shortName));
        end
end

if strcmp(smChoice, 'smon')
        % Define the variables that will be 
        % later used for shared memory extension
        dpramWOAddr={};
        dpramWOAddrIndex = 0;
        dpramWODataI={};
        dpramWODataIIndex = 0;
        dpramWOWE={};
        dpramWOWEIndex = 0;
        dpramROAddr={};
        dpramROAddrIndex = 0;
        dpramRODataO={};
        dpramRODataOIndex = 0;
        
        % dpramROIndex will be used to determine the number of dpram Read-only's
        % This will be used to determine whether we need a delay of one within
        % the mem_if_out
        dpramROIndex = 0;
        
        % maxdpram will be used to determine how many shared memory blocks we
        % can have
        binBaseAddress = dec2bin(base);
        try
            maxdpram = 15 - bin2dec(binBaseAddress(13:16));
        catch
            maxdpram = 15;
        end
        
        % dpram will hold the list of all dual port RAM's
        dpram = find_system(sys,'LookUnderMasks', 'all', 'FollowLinks', 'on',  'block_type', 'dpram');

        % dpramWORO will hold the list of all WO, RO dual port RAM's
        dpramWORO={};
        dpramWOROidx = 0;
        for c=1:length(dpram)
            dpramName = dpram{c};
            compName = [get_param(dpramName, 'Name') '     '];

            % Delete all broken lines
            brokenlines = find_system(sys,'LookUnderMasks', 'all', 'FollowLinks', 'on',  'FindAll', 'on', 'type', 'line', 'SrcBlockHandle', -1);
            delete_line(brokenlines);
            brokenlines = find_system(sys,'LookUnderMasks', 'all', 'FollowLinks', 'on',  'FindAll', 'on', 'type', 'line', 'DstBlockHandle', -1);
            delete_line(brokenlines);
            
            if strcmp(compName(1:5), 'SMWO_') | strcmp(compName(1:5), 'SMRO_')
                dpramWOROidx = dpramWOROidx + 1;
                if dpramWOROidx > maxdpram
                    display(['Error: We are allowed a total of ' num2str(maxdpram) ' dual port RAMS that are read-only/write-only.']);
                    return;
                end
                
                dpramWORO{dpramWOROidx} = [get_param(dpramName, 'Name') '_sm' num2str(dpramWOROidx - 1)] ;
                
                DpramPortHandles = get_param(dpramName, 'PortHandles');

                ports = [DpramPortHandles.Inport(4), DpramPortHandles.Inport(5), DpramPortHandles.Inport(6), DpramPortHandles.Outport(2)];

                SrcBlockHandleAddr = get_param(get_param(ports(1), 'Line'), 'SrcBlockHandle');
                SrcBlockHandleDataI = get_param(get_param(ports(2), 'Line'), 'SrcBlockHandle');
                SrcBlockHandleWE = get_param(get_param(ports(3), 'Line'), 'SrcBlockHandle');
                

                AddrName = get_param(SrcBlockHandleAddr, 'Name');
                CompAddrName = [AddrName '         '];
                AddrFullName = [get_param(SrcBlockHandleAddr, 'Parent') '/' AddrName];
                if ~strcmp(get_param(SrcBlockHandleAddr, 'block_type'), 'gatewayin')
                    display(['A GatewayIn is needed in order to connect to the addrb inport of the dpram ' dpramName '.']);
                    return;
                end
                if  ~strcmp(get_param(SrcBlockHandleAddr, 'arith_type'), 'Unsigned') | (str2num(get_param(SrcBlockHandleAddr, 'n_bits')) > 14) |  (str2num(get_param(SrcBlockHandleAddr, 'bin_pt')) > 0)
                    display(['The GatewayIn ' AddrFullName ' needs to be UFix, with number of bits <= 14, and binary point at 0.']);
                    return;
                end
                orientationAddr = get_param(SrcBlockHandleAddr, 'Orientation');
                placeAddr = get_param(SrcBlockHandleAddr, 'position');
                parentAddr = get_param(SrcBlockHandleAddr, 'Parent');
                fromAddr = [parentAddr '/' cleanName(AddrName) '_sm' int2str(dpramWOROidx)];
                fromAddrSlice = [parentAddr '/' cleanName(AddrName) '_slice_sm' int2str(dpramWOROidx)];
                fromAddrSliceBits = get_param(SrcBlockHandleAddr, 'n_bits');
                
                DataIName = get_param(SrcBlockHandleDataI, 'Name');
                CompDataIName = [DataIName '          '];
                DataIFullName = [get_param(SrcBlockHandleDataI, 'Parent') '/' DataIName];
                orientationDataI = get_param(SrcBlockHandleDataI, 'Orientation');
                placeDataI = get_param(SrcBlockHandleDataI, 'position');
                parentDataI = get_param(SrcBlockHandleDataI, 'Parent');
                fromDataI = [parentAddr '/' cleanName(DataIName) '_sm' int2str(dpramWOROidx)];
                
                WEName = get_param(SrcBlockHandleWE, 'Name');
                CompWEName = [WEName '       '];
                WEFullName = [get_param(SrcBlockHandleWE, 'Parent') '/' WEName];
                orientationWE = get_param(SrcBlockHandleWE, 'Orientation');
                placeWE = get_param(SrcBlockHandleWE, 'position');
                parentWE = get_param(SrcBlockHandleWE, 'Parent');
                fromWE = [parentWE '/' cleanName(WEName) '_sm' int2str(dpramWOROidx)];
                
            end

            if strcmp(compName(1:5), 'SMWO_')
                if ~strcmp(CompAddrName(1:9), 'SMWOAddr_')
                    display(['The Gateway In ' AddrName ' needs to have the prefix of SMWOAddr_']);
                    return;
                end
                
                %%%%% SMWOAddr %%%%%%
                % Delete the GatewayIn
                delete_block(SrcBlockHandleAddr);

                
                deleteSource(sys, cleanName(AddrName));
                
                % Find the broken lines that starts from the output port of the
                % deleted GatewayIn
                brokenlines = find_system(sys,'LookUnderMasks', 'all', 'FollowLinks', 'on',  'FindAll', 'on', 'type', 'line', 'SrcBlockHandle', -1);

                % Find out the handle of the port and the block
                % These two handles will be used to extract more information
                DstPortHandle = get_param(brokenlines, 'DstPortHandle');
                DstBlockHandle = get_param(brokenlines, 'DstBlockHandle');

                % From DstPortHandle, we can find out what is
                % the destination port number
                if length(DstPortHandle) > 1
                    DstPortNumber = cell2mat(get_param(DstPortHandle{length(DstPortHandle)}, 'PortNumber'));
                else
                    DstPortNumber = get_param(DstPortHandle, 'PortNumber');
                end

                % From DstBlockHandle, we can find out what is the name of the
                % destination block
                if length(DstBlockHandle) > 1
                    DstName = get_param(DstBlockHandle{length(DstBlockHandle)}, 'Name');
                    try
                        DstBlockType = get_param(DstBlockHandle{length(DstBlockHandle)}, 'block_type');
                    catch
                        DstBlockType = get_param(DstBlockHandle{length(DstBlockHandle)}, 'BlockType');
                    end
                else
                    DstName = get_param(DstBlockHandle, 'Name');
                    try
                        DstBlockType = get_param(DstBlockHandle, 'block_type');
                    catch
                        DstBlockType = get_param(DstBlockHandle, 'BlockType');
                    end
                end

                % Delete the borken lines
                delete_line(brokenlines);

                dpramWOAddrIndex = dpramWOAddrIndex + 1;
                dpramWOAddr{dpramWOAddrIndex} = fromAddr;
                %placeAddr(1,1) = placeAddr(1,1) - 60;
                placeAddr(1,3) = placeAddr(1,1) + 75;
                placeAddrSlice = placeAddr;
                placeAddrSlice(1,1) = placeAddrSlice(1,3) + 30;
                placeAddrSlice(1,3) = placeAddrSlice(1,1) + 50;
                add_block('built-in/From', fromAddr, 'GotoTag', ['SMWOAddr_' int2str(dpramWOAddrIndex - 1)], 'position', placeAddr);
                if ((version == 8.1) | (version == 8.2) | (version == 9.1))
                    add_block([spm '/Slice8'], fromAddrSlice, 'position', placeAddrSlice, 'nbits', fromAddrSliceBits);
                end
                                        
                FromName = get_param(fromAddr, 'Name');
                FromSliceName = get_param(fromAddrSlice, 'Name');
                set_param(fromAddr,'Orientation', orientationAddr);

                add_line(parentAddr, [FromName '/1' ], [FromSliceName '/1']);
                if size(DstName, 1) == 1
                    
                    add_line(parentAddr, [FromSliceName '/1'], [DstName '/' int2str(DstPortNumber)]);
                    %add_line(parentAddr, [FromName '/1' ], [DstName '/' int2str(DstPortNumber)]);
                else
                    for i=1:size(DstName, 1)
                        if ~strcmp(DstName{i}, get_param(dpramName, 'Name'))
                            add_line(parentAddr, [FromName '/1'], [DstName{i} '/' mat2str(DstPortNumber(i))]);
                        else
                            add_line(parentAddr, [FromSliceName '/1'], [DstName{i} '/' mat2str(DstPortNumber(i))]);
                        end
                    end
                end
                
                %%%%% SMWODataI %%%%%%
                if ~strcmp(get_param(SrcBlockHandleDataI, 'block_type'), 'gatewayin')
                    display(['A Gateway In is needed in order to connect to the datb inport of the dpram ' dpramName '.']);
                    return;
                end
                if ~strcmp(get_param(SrcBlockHandleDataI, 'n_bits'), '32')
                    display(['The Xilinx block ' DataIFullName ' needs to set the number of bits to 32.']);
                    return;
                end
                if ~strcmp(CompDataIName(1:10), 'SMWODataI_')
                    display(['The Xilinx block ' DataIName ' needs to have a prefix of SMWODataI_']);
                    return;
                end
                SMWODataIArithType = get_param(SrcBlockHandleDataI, 'arith_type');
                SMWODataIArithType = [SMWODataIArithType '      '];
                SMWODataIArithType = SMWODataIArithType(1:8);
                if strcmp(SMWODataIArithType, 'Unsigned')
                   fromDataIForce = [parentAddr '/' cleanName(DataIName) '_force_sm' int2str(dpramWOROidx)];
                end
                
                % Delete the GatewayIn
                delete_block(SrcBlockHandleDataI);

                deleteSource(sys, cleanName(DataIName));
                
                % Find the broken lines that starts from the output port of the
                % deleted GatewayIn
                brokenlines = find_system(sys,'LookUnderMasks', 'all', 'FollowLinks', 'on',  'FindAll', 'on', 'type', 'line', 'SrcBlockHandle', -1);

                % Find out the handle of the port and the block
                % These two handles will be used to extract more information
                DstPortHandle = get_param(brokenlines, 'DstPortHandle');
                DstBlockHandle = get_param(brokenlines, 'DstBlockHandle');

                % From DstPortHandle, we can find out what is
                % the destination port number
                if length(DstPortHandle) > 1
                    DstPortNumber = cell2mat(get_param(DstPortHandle{length(DstPortHandle)}, 'PortNumber'));
                else
                    DstPortNumber = get_param(DstPortHandle, 'PortNumber');
                end

                % From DstBlockHandle, we can find otu what is the name of the
                % destination block
                if length(DstBlockHandle) > 1
                    DstName = get_param(DstBlockHandle{length(DstBlockHandle)}, 'Name');
                    try
                        DstBlockType = get_param(DstBlockHandle{length(DstBlockHandle)}, 'block_type');
                    catch
                        DstBlockType = get_param(DstBlockHandle{length(DstBlockHandle)}, 'BlockType');
                    end
                else
                    DstName = get_param(DstBlockHandle, 'Name');
                    try
                        DstBlockType = get_param(DstBlockHandle, 'block_type');
                    catch
                        DstBlockType = get_param(DstBlockHandle, 'BlockType');
                    end
                end

                % Delete the borken lines
                delete_line(brokenlines);
                
                dpramWODataIIndex = dpramWODataIIndex + 1;
                dpramWODataI{dpramWODataIIndex} = fromDataI;
                
                if strcmp(SMWODataIArithType, 'Unsigned')
                    %placeDataI(1,1) = placeDataI(1,1) + 75;
                    placeDataIForce = placeDataI;
                    placeDataIForce(1,1) = placeDataIForce(1,3) + 30;
                    placeDataIForce(1,3) = placeDataIForce(1,1) + 50;
                    add_block('built-in/From', fromDataI, 'GotoTag', ['SMWODataI_' int2str(dpramWODataIIndex - 1)], 'position', placeDataI);
                    add_block([spm '/Force8'], fromDataIForce, 'position', placeDataIForce); 
                   
                    FromName = get_param(fromDataI, 'Name');
                    FromForceName = get_param(fromDataIForce, 'Name');
                    set_param(fromDataI, 'Orientation', orientationDataI);
                    
                    add_line(parentAddr, [FromName '/1' ], [FromForceName '/1']);
                    if size(DstName, 1) == 1

                        add_line(parentAddr, [FromForceName '/1'], [DstName '/' int2str(DstPortNumber)]);
                        %add_line(parentAddr, [FromName '/1' ], [DstName '/' int2str(DstPortNumber)]);
                    else
                        for i=1:size(DstName, 1)
                            if ~strcmp(DstName{i}, get_param(dpramName, 'Name'))
                                add_line(parentAddr, [FromName '/1'], [DstName{i} '/' mat2str(DstPortNumber(i))]);
                            else
                                add_line(parentAddr, [FromForceName '/1'], [DstName{i} '/' mat2str(DstPortNumber(i))]);
                            end
                        end
                    end
                else            
                    placeDataI(1,1) = placeDataI(1,1) - 60;
                    add_block('built-in/From', fromDataI, 'GotoTag', ['SMWODataI_' int2str(dpramWODataIIndex - 1)], 'position', placeDataI);

                    FromName = get_param(fromDataI, 'Name');
                    set_param(fromDataI,'Orientation', orientationDataI);

                    if size(DstName, 1) == 1
                        add_line(parentDataI, [FromName '/1' ], [DstName '/' int2str(DstPortNumber)]);
                    else
                        for i=1:size(DstName, 1)
                            add_line(parentDataI, [FromName '/1'], [DstName{i} '/' mat2str(DstPortNumber(i))]);
                        end
                    end
                end
                
                %%%%% SMWOWE %%%%%
                if ~strcmp(get_param(SrcBlockHandleWE, 'block_type'), 'gatewayin') 
                    display(['A Gateway In is needed in order to connect to the web inport of the dpram ' dpramName '.']); 
                    return; 
                    end 
                if ~strcmp(CompWEName(1:7), 'SMWOWE_')
                    display(['The Gateway In ', WEName ' needs to have the prefix SMWOWE_']);
                    return;
                end
                if ~strcmp(get_param(SrcBlockHandleWE, 'arith_type'), 'Boolean')
                    display(['The GatewayIn ' WEFullName ' needs to have an Output type of Boolean.']);
                    return;
                end
                
                % Delete the GatewayIn
                delete_block(SrcBlockHandleWE);

                deleteSource(sys, cleanName(WEName));
                
                % Find the broken lines that starts from the output port of the
                % deleted GatewayIn
                brokenlines = find_system(sys,'LookUnderMasks', 'all', 'FollowLinks', 'on',  'FindAll', 'on', 'type', 'line', 'SrcBlockHandle', -1);

                % Find out the handle of the port and the block
                % These two handles will be used to extract more information
                DstPortHandle = get_param(brokenlines, 'DstPortHandle');
                DstBlockHandle = get_param(brokenlines, 'DstBlockHandle');

                % From DstPortHandle, we can find out what is
                % the destination port number
                if length(DstPortHandle) > 1
                    DstPortNumber = cell2mat(get_param(DstPortHandle{length(DstPortHandle)}, 'PortNumber'));
                else
                    DstPortNumber = get_param(DstPortHandle, 'PortNumber');
                end

                % From DstBlockHandle, we can find out what is the name of the
                % destination block
                if length(DstBlockHandle) > 1
                    DstName = get_param(DstBlockHandle{length(DstBlockHandle)}, 'Name');
                    try
                        DstBlockType = get_param(DstBlockHandle{length(DstBlockHandle)}, 'block_type');
                    catch
                        DstBlockType = get_param(DstBlockHandle{length(DstBlockHandle)}, 'BlockType');
                    end
                else
                    DstName = get_param(DstBlockHandle, 'Name');
                    try
                        DstBlockType = get_param(DstBlockHandle, 'block_type');
                    catch
                        DstBlockType = get_param(DstBlockHandle, 'BlockType');
                    end
                end

                % Delete the borken lines
                delete_line(brokenlines);

                dpramWOWEIndex = dpramWOWEIndex + 1;
                dpramWOWE{dpramWOWEIndex} = fromWE;
                placeWE(1,1) = placeWE(1,1) - 60;
                add_block('built-in/From', fromWE, 'GotoTag', ['SMWOWE_' int2str(dpramWOWEIndex - 1)], 'position', placeWE);
                
                FromName = get_param(fromWE, 'Name');
                set_param(fromWE,'Orientation', orientationWE);

                if size(DstName, 1) == 1
                    add_line(parentWE, [FromName '/1' ], [DstName '/' int2str(DstPortNumber)]);
                else
                    for i=1:size(DstName, 1)
                        add_line(parentWE, [FromName '/1'], [DstName{i} '/' mat2str(DstPortNumber(i))]);
                    end
                end
                

            elseif strcmp(compName(1:5), 'SMRO_')        
                dpramROIndex = dpramROIndex + 1;
                
                DstBlockHandleDataO = get_param(get_param(ports(4), 'Line'), 'DstBlockHandle');
                
                
                %%%%%% SMROAddr %%%%%
                if ~strcmp(CompAddrName(1:9), 'SMROAddr_')
                    display(['The Gateway In ' AddrName ' needs to have the prefix of SMROAddr_']);
                    return;
                end
                
                % Delete the GatewayIn
                delete_block(SrcBlockHandleAddr);

                deleteSource(sys, cleanName(AddrName));
                
                % Find the broken lines that starts from the output port of the
                % deleted GatewayIn
                brokenlines = find_system(sys,'LookUnderMasks', 'all', 'FollowLinks', 'on',  'FindAll', 'on', 'type', 'line', 'SrcBlockHandle', -1);

                % Find out the handle of the port and the block
                % These two handles will be used to extract more information
                DstPortHandle = get_param(brokenlines, 'DstPortHandle');
                DstBlockHandle = get_param(brokenlines, 'DstBlockHandle');

                % From DstPortHandle, we can find out what is
                % the destination port number
                if length(DstPortHandle) > 1
                    DstPortNumber = cell2mat(get_param(DstPortHandle{length(DstPortHandle)}, 'PortNumber'));
                else
                    DstPortNumber = get_param(DstPortHandle, 'PortNumber');
                end

                % From DstBlockHandle, we can find out what is the name of the
                % destination block
                if length(DstBlockHandle) > 1
                    DstName = get_param(DstBlockHandle{length(DstBlockHandle)}, 'Name');
                    try
                        DstBlockType = get_param(DstBlockHandle{length(DstBlockHandle)}, 'block_type');
                    catch
                        DstBlockType = get_param(DstBlockHandle{length(DstBlockHandle)}, 'BlockType');
                    end
                else
                    DstName = get_param(DstBlockHandle, 'Name');
                    try
                        DstBlockType = get_param(DstBlockHandle, 'block_type');
                    catch
                        DstBlockType = get_param(DstBlockHandle, 'BlockType');
                    end
                end

                % Delete the borken lines
                delete_line(brokenlines);

                dpramROAddrIndex = dpramROAddrIndex + 1;
                dpramROAddr{dpramROAddrIndex} = fromAddr;
                %placeAddr(1,1) = placeAddr(1,1) - 60;
                placeAddr(1,3) = placeAddr(1,1) + 75;
                placeAddrSlice = placeAddr;
                placeAddrSlice(1,1) = placeAddrSlice(1,3) + 30;
                placeAddrSlice(1,3) = placeAddrSlice(1,1) + 50;
                add_block('built-in/From', fromAddr, 'GotoTag', ['SMROAddr_' int2str(dpramROAddrIndex - 1)], 'position', placeAddr);
                
                if(( version == 8.1) | (version == 8.2) | (version == 9.1))
                    add_block([spm '/Slice8'], fromAddrSlice, 'position', placeAddrSlice, 'nbits', fromAddrSliceBits);
                end
                
                FromName = get_param(fromAddr, 'Name');
                FromSliceName = get_param(fromAddrSlice, 'Name');
                set_param(fromAddr,'Orientation', orientationAddr);

                add_line(parentAddr, [FromName '/1' ], [FromSliceName '/1']);
                if size(DstName, 1) == 1
                    
                    add_line(parentAddr, [FromSliceName '/1'], [DstName '/' int2str(DstPortNumber)]);
                    %add_line(parentAddr, [FromName '/1' ], [DstName '/' int2str(DstPortNumber)]);
                else
                    for i=1:size(DstName, 1)
                        if ~strcmp(DstName{i}, get_param(dpramName, 'Name'))
                            add_line(parentAddr, [FromName '/1'], [DstName{i} '/' mat2str(DstPortNumber(i))]);
                        else
                            add_line(parentAddr, [FromSliceName '/1'], [DstName{i} '/' mat2str(DstPortNumber(i))]);
                        end
                    end
                end

                if ~strcmp(get_param(SrcBlockHandleDataI, 'block_type'), 'constant')
                    display(['A Xilinx constant is needed in order to connect to the dinb inport of the dpram ' dpramName '.']);
                    return;
                end
                if ~strcmp(CompDataIName(1:10), 'SMRODataI_')
                    display(['The Xilinx block ' DataIName ' needs to have a prefix of SMRODataI_']);
                    return;
                end
                if (str2num(get_param(SrcBlockHandleDataI, 'const')) ~= 0) | ~strcmp(get_param(SrcBlockHandleDataI, 'n_bits'), '32')
                    display(['The Xilinx constant ' DataIFullName ' needs to have a constant value of zero. Number of bits needs to be 32.']);
                    return;
                end

                if ~strcmp(get_param(SrcBlockHandleWE, 'block_type'), 'constant')
                    display(['A Xilinx constant is needed in order to connect to the web inport of the dpram ' dpramName '.']);
                    return;
                end
                if ~strcmp(CompWEName(1:7), 'SMROWE_')
                    display(['The Gateway In ', WEName ' needs to have the prefix SMROWE_']);
                    return;
                end
                if (str2num(get_param(SrcBlockHandleWE, 'const')) ~=0) | (~strcmp(get_param(SrcBlockHandleWE, 'arith_type'), 'Boolean'))
                    display(['The Xilinx constant ' WEFullName ' needs to be a Boolean constant with a value of zero.']);
                    return;
                end

                %%%%% SMRODataO %%%%%
                DataOName = get_param(DstBlockHandleDataO, 'Name');
                DataONameIdx = 1;
                if length(DstBlockHandleDataO) == 1
                    CompDataOName = [DataOName '          '];
                    DataOFullName = [get_param(DstBlockHandleDataO, 'Parent') '/' DataOName];
                else
                    for i=1:length(DstBlockHandleDataO)
                        CompDataOName{i} = [DataOName{i} '          '];
                        DataOFullName{i} = [get_param(DstBlockHandleDataO(i), 'Parent') '/' DataOName{i}];                           
                    end
                end
                
                IsGatewayOut = false;
                
                for d=1:length(DstBlockHandleDataO)
                    if strcmp(get_param(DstBlockHandleDataO(d), 'block_type'), 'gatewayout')
                        IsGatewayOut = true;

  Â