ws_cfg.py

# This script is licensed under BSD License, see file LICENSE.txt.
#
# (c) TASKING Germany GmbH, 2023
 
import isystem.connect as ic
import os
 
class WorkspaceConfigurator():
    def __init__(self, cmgr: ic.ConnectionMgr):
        self.cmgr = cmgr
        self.wsCtrl = ic.CWorkspaceController(cmgr)
        self.configCtrl = ic.CConfigurationController(cmgr)
 
    def create_workspace(self, workspaceFileName: str, workspaceDir:str = None):
        """
        Creates a new workspace.
            @param workspaceFileName: Name for the created workspace.
            @param workspaceDir: Directory where the new workspace gets generated.
        """
        # Create Workspace Controller instance
        if workspaceDir is None:
            workspaceDir = os.getcwd()
        wsPath=os.path.join(workspaceDir, workspaceFileName)
 
        # Create a new workspace 
        self.wsCtrl.newWS(wsPath)
        self.wsCtrl.save()
 
    def save_workspace(self):
        """
        Saves the workspace.
        """
        self.wsCtrl.save()
 
    def close_workspace(self):
        """
        Closes the workspace.
        """
        self.wsCtrl.close()
 
    
    def set_emulator_type(self, Type: str):
        """
        Sets the emulator type used.
            @param Type: Type of emulator used. 
                        Options available are iC5000, iC5500, iC5700, iC6000 and XCP 
        """
        # Create hardware option controller instance
        optHardware = ic.COptionController(self.cmgr, '/iOPEN/Hardware')
 
        # Set the emulator used. 
        optHardware.set('Emulator', Type)
 
    def set_USB_comm(self, device: str = ''):
        """
        Sets the emulator to use USB connection.
            @param device: USB device name composed from emulator type and the
            emulator serial number. Used when there are more than 1 emulator
            connected to your PC, otherwise it can remain empty.
            More information: https://www.isystem.com/downloads/winIDEA/help/winidea-configuration-communication-type.html
        """
        optCommunication = ic.COptionController(self.cmgr, '/iOPEN/Communication')
        inParams = {}   
        inParams['Mode'] = 'USB'
        inParams['USBDeviceName'] = device 
 
        # Set the communication options.
        optCommunication.set_multi(inParams)
 
 
    def set_TCP_comm(self, IP: str, port: str, useGlobalDiscoveryPort: bool=True):
        """
        Sets the emulator to use TCP connection.
            @param port: Selects which TCP port to use.
            @param ipAddress: Device description. This option can be host name, 
            device ip address or 'localhost'.
            More information: https://www.isystem.com/downloads/winIDEA/help/winidea-configuration-communication-type.html
            @param useGlobalDiscoveryPort: Switches on or off global discovery port.
            This parameter is used for emulator discovery on the network.
        """
 
        # Create communication option controller instance
        optCommunication = ic.COptionController(self.cmgr, '/iOPEN/Communication')
 
        # For TCP
        inParams = {}
 
        inParams['Mode'] = 'TCP'
        inParams['TCPPortNumber'] = port 
        inParams['IPAddress'] = IP  
        if useGlobalDiscoveryPort:
            inParams['IPUseGlobalDiscoveryPort'] = 'true' 
        else:
            inParams['IPUseGlobalDiscoveryPort'] = 'false' 
 
        # Set the communication options.
        optCommunication.set_multi(inParams)
 
    def set_SoC(self, name: str):
        """
        Selects which target is connected.
            @param name: Name of the target device. List of devices is available 
            in the device drop down menu: https://www.isystem.com/downloads/winIDEA/help/advanced-soc-configuration.html.
        """
        # Create a option controller instance for SoC using the configuration controller. 
        # MCU is the default SoC[0] name. 
        optSoC = self.configCtrl.ide_SoC('MCU')
        # Select the target device used
        optSoC.set('SFRName', name)
 
    def add_application(self, name: str):
        """
        Adds a new application.
            @param name: Name of the created application.
        """
        # Create new application
        optApps = self.configCtrl.ide_apps()
        optApp = optApps.add()
 
        # Set application name
        optApp.set('Name', name)
 
 
    def add_symbol_file(self, appName: str, path: str, Type: str):
        """
        Adds a symbol file to the application.
            @param appName: Name of the application to which the symbol file is added.
            @param path: Path to the symbol file.
            @param Type: Type of the symbol file. 
            Options available are BIN, ELF, HEX, OMF51,
            25(OFM2 251/MX51), SIT(SLO text), TMSCOFF, UBROF and S37.
        """
        optApps = self.configCtrl.ide_apps()
        appIndex = optApps.index_of("Name", appName)
        optApp = optApps.at(appIndex)
 
        # Create a new SymbolsFile instance for the application
        optSymbolFile = optApp.opt('SymbolFiles.File').add()
 
        # Set the symbol file path
        optSymbolFile.set('Path', path)
 
        # Set the symbol file type to ELF
        optSymbolFile.set('Options.Type', Type)
 
 
    def add_memory_space(self, name: str, coreName: str, appName: str,
                    isEnabled: bool = True, useMsid: bool = False, msidLevel: str = ''):
        """
        Adds a new memory space.
            @param name: Name for the created memory space.
            @param coreName: Name of the core which is associated with
            the created memory space.
            @param appName: Name of the application which
            is associated with the created memory space.
            @param isEnabled: Selects if the memory space is enabled.
            @param useMsid: Selects if MSID is used.
            @param msidLevel: Selects which MSID level is used.
 
        """
        # Create memory space Option controller instance 
        optSoC = self.configCtrl.ide_SoC('MCU')
        optMemSpace = optSoC.opt("MemorySpaces")
 
        # Add a new memory space
        optMyMemSpace = optMemSpace.add()
 
        # Configure the memory space 
        inParams = {}
        if isEnabled:
            inParams['Enabled'] = 'true' # Enable the memory space
        else:
            inParams['Enabled'] = 'false' # Enable the memory space
        inParams['UserName'] = name # Name for this memory space
        inParams['Cores'] = coreName # CPU core associated to this memory space
        inParams['Application'] = appName # Application associated to this core
 
        # Enable MSID
        if useMsid:
            inParams['MSID.Use'] = 'true'
            inParams['MSID.Level'] = msidLevel
        else:
            inParams['MSID.Use'] = 'false'
 
        # Set the memory space parameters
        optMyMemSpace.set_multi(inParams)    
 
    def add_program_file(self, path: str, Type: str, 
                    offset: int = 0):
        """
        Adds a program file.
            @param path: Path of the program file.
            @param programFileType: Type of the program file.
            Options available are BIN, ELF, HEX and S37.
            @param offset: Download offset of the program file.
        """
        optSoC = self.configCtrl.ide_SoC('MCU')
        optProgFile = optSoC.opt("DLFs_Program.File")
        optProgFile = optProgFile.add()
 
        inParams = {}
        inParams['Path'] = path 
        inParams['Options.Type'] = Type 
        inParams['Options.CodeOffset'] = str(offset) 
 
        optProgFile.set_multi(inParams)
 
    def set_demo_mode(self, isDemoModeOn: bool):
        """
        Enables demo mode for winIDEA.
            @param cmgr: ConnectionMgr instance.
            @param isDemoModeOn: Enables or disables demo mode.
        """
 
        ideCtrl = ic.CIDEController(self.cmgr)
        params = ic.StrStrMap()
        if isDemoModeOn:
            params["Demo"] = "TRUE"
            ideCtrl.invoke("/IDE/Demo", params)
        else:
            params["Demo"] = "FALSE"
            ideCtrl.invoke("/IDE/Demo", params)
 
 
    def create_analyzer_trigger(self, profilerCtrl: ic.CProfilerController2, triggerName: str) -> int:
        """
        Creates a new Analyzer trigger and returns index.
            @param profilerCtrl: Profiler controller instance.
            @param triggerName: Trigger name
        """
        # Remove all existing triggers with triggerName
        profilerCtrl.removeTrigger(triggerName)
 
        # Create and use new trigger
        triggerIdx = profilerCtrl.createTrigger(triggerName)
        profilerCtrl.select(triggerIdx) 
        return triggerIdx   
 
    def remove_existing_process_triggers(self, optProcessTrigger: ic.COptionController):
        """
        Removes all existing process triggers.
            @param optProcessTrigger: Process trigger option controller instance.
        """
        while optProcessTrigger.size():
            optProcessTrigger.remove(0) 
 
    def add_new_process_trigger(self, optProcessTrigger: ic.COptionController, appName: str,
                            memorySpaceName: str) -> ic.COptionController:
        """
        Adds a new process trigger.
            @param optProcessTrigger: Process trigger option controller instance.
            @param appName: Name of the application.
            @param MemorySpaceName: Name of the memory space.
        """ 
        optProcessTriggerInstance = optProcessTrigger.add() 
        optProcessTriggerInstance.set('ProcessURL', appName + '/' + memorySpaceName)
        return optProcessTriggerInstance
 
    def add_new_profiler_data_area(self, optProfilerData: ic.COptionController, variableName: str,
                            appName: str, memorySpaceName: str, interpretationType: str, accessType: str):
        """
        Adds a new profiler data area.
            @param optProfilerData: Profiler data option controller instance.
            @param variableName: Name of the variable to profile.
            @param interpretationType: Profiler data interpretation type.
            Available types are State, Function, Regular and Sampling.
            @param accessType: Type of data access.
            Available types are Write, Read and WriteAndRead.
        """
        # Add a new profiler data area
        optProfilerDataArea = optProfilerData.add()
    
        # Configure the new data area
        inParams = {}
        inParams['Name'] = f'{variableName},,,{appName}/{memorySpaceName}'
        inParams['Type'] = interpretationType
        inParams['DataType'] = 'Variable'
        inParams['AccessType'] = accessType
 
        optProfilerDataArea.set_multi(inParams)