The S32 Design Studio for S32 Platform supports the S32R41 device with the S32 Debugger. This document provides the details on how to setup and begin a debugging session on the S32R41 EVB (X-S32R45-EVB). Preparation Setup the software tools Install S32 Design Studio IDE Use the Extensions and Updates menu within S32 Design Studio for S32 Platform to add the S32R41 Development Package. Setup the hardware Confirm the setup of the S32R41 evaluation board.        Connect the power supply cable Setup the S32 Debug Probe        Connect the S32 Debug Probe to the evaluation board via JTAG cable. Refer to the S32 Debug Probe User Manual for installation instructions.        Connect the S32 Debug Probe to the host PC via USB, or Ethernet (via LAN or directly connected and configured for static IP address) and power supply connected to USB port. Launch S32 Design Studio for S32 Platform Create new or open existing project and check that it successfully builds. If creating a new project, be sure the S32 Debugger is selected in the New Project Wizard. Procedure Open the Debug Configurations menu, then follow the steps depending on whether an S32 Debugger configuration exists for your project. If the project was created using the New Project Wizard in S32 Design Studio for S32 Platform, and the S32 Debugger was selected as the debugger, then it likely has existing debug configuration(s). S32 Debugger Configuration(s) Exist If existing S32 Debugger configuration, proceed with probe configuration. Otherwise, skip to the next section. Below is shown the debug configuration which appears for the provided RTD example project Port_ToggleLed_S32R41_M7'. The suffixes 'debug', 'ram', and 's32debugger' refer to how the project was built and the debugger the configuration is for. Select the debug configuration which corresponds to the project, build type debug, and primary core (if a multicore project) Select the Debugger tab Select the Interface (Ethernet/USB) by which the S32 Debug Probe is connected. If connected via USB and this option is selected for interface, then the COM port will be detected automatically (in the rare event where 2 or more S32 Debug Probes are connected via USB to the host PC, then it may be necessary to select which COM port is correct for the probe which is connected to the EVB) If connected via Ethernet, enter the IP address of the probe. See the S32 Debug Probe User Manual for ways to determine the IP address. Proceed to section ‘Start Debugger’ S32 Debugger Configuration(s) Do Not Exist There might be no existing debug configuration if the project is being ported from another IDE or was created to use another debugger. Select the S32 Debugger heading and click New Launch configuration (or double click on the S32 Debugger heading, or right click on the S32 Debugger heading and select New from the context menu) A new debug configuration appears with the name set to the name of the active project in the Project Explorer window(this can be set by opening a file from the project or selecting an already opened file from the project in the editor), and the build type which was used to build it. If this is not matching your intended project then it can either be modified to match or deleted and recreated after the active project has been changed to the desired project. Adjust the name of the project as desired. From the Main tab, check that the Project field is set to the correct project name, as listed in the Project Explorer, and that the C/C++ Application is set to the ELF file which was built. The name of the project can be customized, but '_' must be used instead of spaces. If the Project field is not set or incorrect, click Browse... and then select the correct project name from the list. If more than one project is open in the workspace, then each will be listed. This shows how, regardless of which project is active in the C/C++ perspective, any available workspace project could be associated. This can be useful when reusing a debug configuration from one project in another. If the C/C++ Application is not set or incorrect, click Search Project... and then select the correct binary file (will only work if Project field is correct and project was successfully built). Switch to the Debugger tab. Click 'Select device and core' and then select the correct core from the list. In the case of our example, the M7_0 core is correct. If this is not the primary core, then uncheck the box next to 'Initial core'. This is done only for multicore projects for the non-boot cores. This causes the scripts to skip the initialization of the core as the boot core will launch the other cores so additional initialization will not be required. Select the Interface (Ethernet/USB) by which the S32 Debug Probe is connected. If connected via USB and this option is selected for interface, then the COM port will be detected automatically (in the rare event where 2 or more S32 Debug Probes are connected to the host PC, then it may be necessary to select which COM port is correct for the probe which is connected to the EVB) If connected via Ethernet, enter the IP address of the probe. See the S32 Debug Probe User Manual for ways to determine the IP address. Click Apply, then proceed to next section ‘Start Debugger’. Start Debugger Click Debug. This will launch the S32 Debugger. When the debugger has been successfully started, the Debug perspective is opened and the application is executed until a breakpoint is reached on the first line in main().

Trace functionality is supported in the S32 Debugger for A53 cores on the S32R, RAM-target builds. With Trace, you can record some execution data on an application project and then review it to determine the actions and data surrounding an event of interest.   This document outlines the method to begin using Trace on the S32R45 device. We start by creating a project on which to execute the trace, however, you may start at step 2, if you are starting with an existing project. Please note, you will need to have debug configurations for the S32 Debugger setup for each core which you intend to capture trace. If you do not already have such configurations, you may copy them from another project and adapt them to the new project as shown in HOWTO: Add a new debugger configuration to an existing project.   Create a new application project, selecting the 'S32R45 Cortex-A53' processor and 'S32 Debugger' options.  There should now be 4 new application projects in your workspace. One for each A53 core. The first core of the S32R45, A53_0_0, is also a possible boot core, so this project will have build configurations for RAM and FLASH. The other A53 cores (0_1, 1_0, 1_1) will not. Build all projects for Debug_RAM and check that they build clean before proceeding. Open 'Debug Configurations...' and select the 'Debug_RAM' configuration for the first core (A53_0_0_Debug_RAM_S32Debug). Select the 'Debugger' tab. Enter the Debug Probe Connection settings as appropriate for your hardware setup. Click Apply. Now select the Launch Group configuration for 'Debug_RAM'. It is important to use the launch group to start the debug for each core, not just because it makes it easier, but also because it is necessary to allow for some delay after the first A53 core is started before bringing the other A53 cores from reset to debug state. Press Debug Once the code is loaded to the target and the debugger has started each core and executed to the first line within main(), then it is ready to perform any of the standard debug functions including Trace. Trace does not start automatically, it must be turned on before it will start logging data. To do this, it is necessary to add the view 'Trace Commander'. It can be found by either Window -> Show View -> Other, then search for 'Trace Commander' or enter 'Trace Commander' in the Quick Access field of the toolbar and select Trace Commander from the list. The Trace Commander view will show in the panel with the Console, Problems, etc. Double-click on the tab to enlarge it. Click on the configure button to change settings. Click on the Advanced Trace Generators configuration button For each core to be logged, set the associated ELF file. Select the core, click Add, then '...', and select the elf file for that core. Select Data Streams. Now it is possible to change how the data is captured. Since the buffers have finite memory, they can be set to collect data until full, or to overwrite. If set to One buffer, the data will be collected until the buffer is full, then data collection stops. It is useful to gather data when starting logging from a breakpoint to gather data during execution of a specific section of code. If set to Overwrite, the data collection continues and starts overwriting itself once the buffer is full. This is useful when trying to gather data prior to a breakpoint triggered by a condition.  To turn on the Trace logging, click on the 'Close this trace stream' button. The Trace is now enabled. To collect trace data, the cores must be executing. First double-click the Trace Commander tab to return to the normal Debug Perspective view. Then, one by one, select the main() thread on each core and press Resume to start them all. If collecting from a breakpoint, start the code first with Trace disabled, wait for the breakpoint to be reached, then enable the Trace. Allow the cores to run for a period of time to gather the data, then press Suspend on each one until they are all suspended. Look to the Trace Commander tab to see that the data icon is no longer shaded and click on it to upload the trace data. A new tab, Analysis Results, has appeared. Double-click this tab to see it better. Click on the arrow next to ETF 0 to show the data collected in the trace buffer. Notice there are 5 separate views on the captured data: Trace (raw data), Timeline, Code Coverage, Performance, and Call Tree. Trace - this is the fully decoded trace data log Timeline - displays the functions that are executed in the application and the number of cycles each function takes, separate tabs for each core Code Coverage - displays the summarized data of a function in a tabular form, separate tabs for each core Performance - displays the function performance data in the upper summary table and the call pair data for the selected function and it's calling function Call Tree - shows the call tree for identification of the depth of stack utilization See the S32DS Software Analysis Documentation for more details on settings, ways to store the logged data, etc.

On some versions of Windows 10, there is an issue which could impact your ability to open documents from the Getting Started page in S32 Design Studio. While we have resolved this issue in some of the newer releases, not all editions of S32 Design Studio have been updated since this issue was discovered. Also, you may required to use an older release. The problem occurs when a document linked within the Getting Started window of S32 Design Studio. The S32 Design Studio is configured to use the Windows default web browser to open the files. For some Windows 10 installations, Microsoft Edge is the default browser and it is unable to correctly open the requested file. The typical error message is as shown below: To resolve the issue, it is necessary to change the default browser within your Windows preferences. Here are some steps to do that: 1) Click on 'Settings' from the Windows Start Menu 2) Type 'browser' in the search bar, then select 'Choose a default web browser' 3) Click on the currently selected Web browser to bring up the selection menu and select 'Internet Explorer' or 'Google Chrome' 4) Relaunch S32 Design Studio and try again to open the document from the link in Getting Started page.

      Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio 3.2  Update 191219          What is new? S32 SDK for S32V234 RTM 1.0.1 package (Windows only) Installation instructions The update is available for online (via Eclipse Updater) or offline installation (direct download link)  online installation:  go to menu "Help" -> "S32DS Extensions and Updates" dialog  select from available items and click "Install/Update" button   offline installation:   go to S32 Design Studio product page -> Downloads section or use direct link to download the update archive zip file Start S32 Design Studio and go to "Help" -> "S32DS Extensions and Updates" Add a new "Add.." S32DS Software Site and browse to select the downloaded update archive .zip file you downloaded in the previous step         Select from available items and click "Install/Update" button. This will start the update installation process.

This tutorial walks a user through the steps to create a new application for the S32V234 MCU using S32DS (with S32V2xx development package and Vision extension package for S32V2xx) and the built in APEX2 Visual Graph tool. The completed application will take a PNG image, upscale and downscale it using APEX engines and return the processed images. Prerequisites: Some knowledge of the S32V234 System on a Chip (SoC) Have an understanding of the APEX architecture and APEX Core Framework (ACF) Refer to UG-10267-03-14-ACF_User_Guide.pdf to learn about ACF Path: s32ds_install_dir\S32DS\software\VSDK_S32V2_RTM_x_x_x\s32v234_sdk\docs\apex\acf Be familiar with the NXP Vision SDK software Looking for Interactive Tutorial? You can view this tutorial as a video, go to Getting started with S32 Design Studio IDE including Vision Extension Package for S32V processors | NXP and select '4 | Create a new APEX2 application'

The S32 Debugger included within the S32 Design Studio for S32 Platform IDE provides the capability to access the flash programming capabilities of the S32 Debug Probe via the S32 Debugger.   Note: currently only QSPI flashing is supported. Preparation Install S32 Design Studio IDE Install the Development Package for the device you are debugging. In this case, the S32R41 development package. This package is important as the S32 Debugger support component contains the device-specific Python scripts required for initialization of the cores. Open the application project from which the flash image will be generated. Follow the steps in HOWTO: Generate S-Record/Intel HEX/Binary file, selecting the 'Raw Binary' option. Build the project, generating the binary executable. This will be our application binary input to the IVT Tool. The IVT Tool must be used to generate the BLOB image which can be programmed to flash memory device and loaded to the RAM by the BootROM. Follow the steps in HOWTO: Use IVT Tool To Create A BLOB Image S32R41. The resulting BLOB image file is what can be flashed to the device. Procedure Open Debug Configuration menu Select 'S32 Debugger Flash Programmer', then right-click and select New. Enter an name for the new configuration and click Add... to add the file to be flashed. Click Browse... to select the project from the workspace where the application binary is located Select the project and click OK By default, the ELF file is found. Click Search in project to select the binary file. Select the .bin file and click OK Now we must enter the base address. Typically, this could be 0, but you may have other requirements. Click OK. Now we are ready to configure the debugger connection settings. Click on the Debugger tab. Starting from the top and working our way down, click on Select device. Select the device and click OK The correct Initialization script will automatically be set. Set the Debug Probe Connection settings to match your setup. When done, click Apply To start the flashing, click Debug Flashing progress will be displayed. When complete, the Debug perspective will show at terminated thread. Happy flashing with GDB! Note, to debug this application since it will be subsequently started by the BootROM: use 's32r41_attach.py' in the Initialization script field on the debugger tab of the Debug Configurations menu Make the following adjustments on the Startup tab within the Debug Configurations menu: Uncheck "Load image" Check “Set program counter at:” and enter the value “Reset_Handler”

When you use the New Project Wizard within S32 Design Studio to create a project, starting a debugging session is easy since the wizard creates the debug configuration for you. In this document, the case for NXP devices supported by the GDB PEMicro Debugging Interface is detailed.    Prerequisites The project to be debugged should be loaded to the workspace and open                 Procedure Build the project. Select the build configuration. (optional) If you already know which build configuration is desired, you can preselect it. If not, one is already selected for you by default. It will be noted with a check mark. Typical options contain choices between RAM and FLASH memory builds and for each a choice between Debug and Release. For debugging purposes the Debug option should be selected.                 Click on Build. Clicking this button will start the build using the preset build type.     Or, select the build type from the pick list. This will start the build for the build type selected, regardless of which one is marked with a check mark.       Check there are no compiler errors.                     Configure the debug configuration to start a debug session. Click ‘Run’ pulldown menu. Select 'Debug Configurations…'     Select the debug configuration associated with your current build configuration.     Select whether to rebuild code each time debug session start is requested.   Click on Debugger tab.     Verify proper interface and port.     Click Debug      

The attached file is an example project based on KEA128 for LED flashing by toggle GPIO signals. It was developed   on S32 Design Studio for ARM 1.0.

So you've just installed the S32DS and are using it for the first time and would like to see how it works. Here is a quick and simple project to get you started. Prerequisite Before following the steps in this HOWTO, ensure you have the S32V2xx development package installed to S32DS. 1. Launch S32DS for Vision 2. Select 'S32DS Application Project' 3. Enter a name for the project 4. Select the 'A53 Linux' processor option 5. Click Next 6. Click the '...' next to the SDKs field 7. Check the box next to 'VSDK_MODULE_WIN' for Windows OS or 'VSDK_MODULE_LINUX' for Linux OS and click OK. 8. Click Finish 9. Build the project for Debug 10. Project is now built, ELF file is ready to be loaded to EVB for execution. However, if we have not prepared the EVB, we must first complete HOWTO: Setup S32V234 EVB2 for debugging with S32DS and Linux BSP. 11. Once the EVB is properly prepared, we must complete HOWTO: Setup A Remote Linux Connection in S32DS (S32V234)  12. With the project debug configuration and remote linux connection selected, select the debug dropdown menu and click Debug Configurations 13. Make sure the Debug_Remote_Linux debug configuration is selected and the connection setup in step 10 is selected (points to the IP address of your EVB). Click Debug 14. The first time you connect to a new IP address (i.e. the first time you debug after booting the board), you will receive a warning message, Click Yes and proceed. 15. The executable file is copied to Linux file system and gdbserver starts. 16. The Debug perspective is opened. You can now step through the code*     *Only debugging of the A53 code is supported by Linux GDB. For multicore debugging, including ISP and APEX2, additional debugger and probe(S32 Debugger with S32 Debug Probe, Lauterbach, etc) will be required.

1) Prepare the evaluation board hardware You can use the S32 Debug Probe to download code to target Connect S32 Debug Probe to S32V234 EVB using JTAG connector Connect S32 Debug Probe to PC via USB cable OR ethernet (if connected via ethernet, then USB power cable must also be connected) Connect the S32V234 EVB to PC via ethernet (typically via LAN) Connect power cable to evaluation board and switch on the power     2) Build the project using the TEST_A53 build option. 3) Start debug on A53 core. Project is now built, ELF file is read to be loaded to EVB for execution. 4) Before a debug session can be started, we must complete HOWTO: Setup A Remote Linux Connection in S32DS for Vision. 5) Select the debug drop-down menu and click Debug Configurations     6) Make sure the Debug_Remote_Linux debug configuration is selected and the connection setup in step 4 is selected (points to the IP address of your EVB). Click Debug     7) The first time you connect to a new IP address (i.e. the first time you debug after booting the board), you will receive a warning message, Click Yes and proceed.     The executable file is copied to Linux file system and gdbserver starts. You may get an error message on the first try, this is normal. Just try it again and it will work. 😎 Once the Linux GDB has started on A53 core and the initial breakpoint is reached in main(), we need to set a breakpoint at the function apu_hal_Enable().    This breakpoint has already been created for you, you just need to enable it! Locate the breakpoint in the Breakpoints view. Due to some known issues with Eclipse CDT, it is necessary to enable->disable->enable the breakpoint so it will work properly. The issue only affects this breakpoint, due to the way it is provided, and will not affect breakpoints which you set. 9) Press Resume twice, so that the breakpoint which was set at apu_hal_enable() is reached for the 2nd time. 10) Open Debug Configurations. You will see a debug configuration within the 'S32 Debugger' group (FAST9COLOR as shown below). This is the debug configuration we will use, however, it will require some setup.     11) You should notice the error message at the top of the window, just below the title and a red 'X' on the Debugger tab. Click on the Debugger tab to select it. We must setup the Debug Probe Connection before we can proceed. There are two options: Ethernet USB   If connecting the Probe via Ethernet, please refer to the Quick Start Guide or S32 Debug Probe User Guide provided with the S32 Debug Probe for instructions on how to connect it and determine the Hostname or IP address.     If connecting the Probe via USB, then the COM port will appear in the Port selection setting. If you have more than one S32 Debug Probe connected, you will need to determine which COM port is the correct one, otherwise, only the COM port for your S32 Debug Probe will appear.       12) Click Apply then Debug. It may take a few moments for the APEX core debug to launch.   13) It may take a moment or two before the APEX2 debug thread launch is complete, see the Thread listed within the <kernel_name>[S32 Debugger] in the Debug window. Also note, a new breakpoint is listed in the Breakpoints view. This breakpoint is set for you at the start of the APEX2 graph function. 14) The debugger context is still on the A53 thread. Press RESUME and then select the APEX2 thread to see that it has stopped on the graph function break point. Now you can step through the graph. 15) To step through a kernel, locate the call to the kernel function in the graph function and set a break point on the line. 16) Press RESUME to advance the program counter to the new break point 17) Press STEP INTO to advance the program counter into the kernel. It may take several steps as the optimizations performed by the compiler produce some synchronization inconsistencies. 18) You may need to help the IDE to locate the source files. Now you can see the kernel wrapper function... and the kernel! 19) Step through, monitor variables and registers and set breakpoints.

Before you can start debugging an S32DS project for S32V234 Cortex-A53 APEX2/ISP Linux target on the S32V234-EVB2, we must first setup the hardware connections and start the Linux BSP OS. 1) Connect (1) S32V234 USB Micro B port to (2) USB A port on your PC. This allow you to connect to the Linux BSP OS via a terminal program to issue commands and to obtain the IP address. 2) Insert microSDHC card (with U-boot, Linux kernel, devicetree, and root file system loaded*) into (3) the S32V234 EVB2 microSD card slot   3) Connect (1) Ethernet port on S32V234 daughter card to (2) LAN**. This will allow S32DS to communicate with the Linux BSP OS for flashing and GDB debugging.   4) Connect the power supply to (3) S234V234 EVB 5) Turn on the (4) power switch, this will start the Linux BSP OS *Instructions for preparing the SD card are provided in the VisionSDK document: ..\S32DS.x.x\S32DS\software\VSDK_S32V2_RTM_x_x_x\s32v234_sdk\docs\vsdk\S32V234-EVB_SetupGuide.pdf or refer to HOWTO: Prepare A SD Card For Linux Boot Of S32V234-EVB2 Using BSP For VisionSDK  **Ensure PC is connected to LAN as well (either hardwired or wireless)

UART0 communication is supported in the latest version of MPC5746R Bootloader .rbf file (attached below) + Supported UART0/LINFlexD_0: PD13-PD14 pins(Speed: 115200b/s)   Tested on the dev boards:   Development Board MPC5746R-252DC MPC57xx-MOTHERBOARD Processor PPC5746RTMMT5 - 1N83M  

The S32 Debugger included within the S32 Design Studio for S32 Platform IDE provides the capability to access the flash programming capabilities of the S32 Debug Probe via GTA command line and the GDB. This instruction details the steps to perform flash programming of the S32R41 EVB via the JTAG interface with the S32 Debug Probe.   Note: currently only QSPI flashing is supported.   Preparation Setup the software tools Install S32 Design Studio IDE Install the Development Package for the device you are debugging. In this case, the S32R41 development package. This is important as the S32 Debugger support within it contains the device-specific Python scripts required for initialization of the cores. Setup the hardware Confirm the setup of the S32R41 evaluation board. Connect the power supply cable Setup the S32 Debug Probe Connect the S32 Debug Probe to the evaluation board via JTAG cable. Refer to the S32 Debug Probe User Manual for installation instructions. Connect the S32 Debug Probe to the host PC via USB, or Ethernet (via LAN or directly connected and configured for static IP address) and power supply connected to USB port. Launch S32 Design Studio for S32 Platform Create new or open existing project and check that it successfully builds. If creating a new project, be sure the S32 Debugger is selected in the New Project Wizard.   Procedure Launch GTA server. From command prompt or Windows File Explorer run the command:{S32DS Install Path}\S32DS\tools\S32Debugger\Debugger\Server\gta\gta.exe Should see a window appear like this: Ensure Environment Variable for Python is set. From command prompt, run the command: set PYTHONPATH={S32DS Install Path}\S32DS\build_tools\msys32\mingw32\lib\python2.7;{S32DS Install Path}\S32DS\build_tools\msys32\mingw32\lib\python2.7\site-packages Start GDB. In a command window, run the command: Windows OS: {S32DS Install Path}\S32DS\tools\gdb-arm\arm32-eabi\bin\arm-none-eabi-gdb-py.exe (for arm32) OR {S32DS Install Path}\S32DS\tools\gdb-arm\arm64-eabi\bin\aarch64-none-elf-gdb-py.exe (for arm64) Linux OS: arm-none-eabi-gdb-py A (gdb) prompt should now be displayed in the command window: Configure the EVB's Boot Mode switches for Serial Boot. Issue the following commands, replacing the PROBE_IP address and FLASH_NAME, as appropriate: source {S32DS Install Path}/S32DS/tools/S32Debugger/Debugger/scripts/gdb_extensions/flash/s32flash.py py _FLASH_TYPE = "qspi" py _PROBE_IP="10.81.64.66" py _JTAG_SPEED=20000 py _GDB_SERVER_PORT=45000 py _GDB_TIMEOUT=7200 py _REMOTE_TIMEOUT=30 py _RESET_DELAY=1 py _RESET_TYPE="default" py _INIT_SCRIPT="{S32DS Install Path}/S32DS/tools/S32Debugger/Debugger/scripts/s32r41/s32r41_generic_bareboard.py" py _FLASH_NAME="W25Q64J" py _IS_LOGGING_ENABLED=False py flash() Note: Replace the {S32DS Install Path} in the commands above with the actual path to your installation of S32 Design Studio. Now flash commands may be used. fl_blankcheck -- blank check fl_close -- close command fl_current -- current device command fl_dump -- dump command fl_erase -- erase section of memory command, will erase whole sectors starting from 'offset' through 'size' contiguously, so to erase only one sector, ensure that the 'offset' address is within the desired sector and 'size' does not extend into the following sector fl_erase_all -- erase all memory command fl_info -- info command, shows list of registered devices fl_protect -- protect section of memory command fl_unprotect -- unprotect section of memory command fl_write -- write memory command, hex or binary are supported, options to erase first and verify after write fl_write_elf -- write elf file to memory command, options to erase first, verify after, and rearrange flash base Type 'help fl_<command>' to print the help info on the specified command Type 'help support' to print a list of the fl_ commands For example, you may wish to write a binary file: fl_write -e 0x0 C:\\Users\\<userid_folder>\\workspaceS32DS\\hello_world\\Debug_RAM\\hello_world_blob.bin Happy flashing with S32DS Flash Programmer!

In this document, we show the steps to use the New Project Wizard to create a new application project for APEX2, ISP, or both.   1. Launch S32DS for Vision 2. Select File -> New -> S32DS Application Project 3. Enter a name for the project 4. Select the 'A53 APEX2/ISP Linux' processor option 5. Click Next 6. Select the APEX2/ISP options you need.       a. APEX2 programming - will add support to your project for an APEX2 application, you need this for any new APEX2 project       b. ISP programming - will add support to your project for an ISP application, you need this for any new ISP project       c. ISP visual modeling - will create a separate project for your ISP data flow diagram, you will not need this if you plan to use an existing graph diagram. This can also be created later. 7. Select the SDK(s) as appropriate for your setup. For example, 'VSDK_MODULE_WIN' for Windows OS or 'VSDK_MODULE_LINUX' for Linux OS, the one which corresponds to your OS is selected for you by default. 7. Click Finish 8. You now have a project or set of projects for development on the S32V234.

Eclipse caches some settings within the workspace directory. After installing a new version of S32DS, some settings in old workspaces may not match the requirement of the new version. The result is often errors reported on new as well as previously existing projects located in an existing workspace which you selected when launching S32DS. The best way to resolve this is to create a new workspace and then import your projects. This will ensure the workspace is created using all the correct settings for the version you have installed.

1) Prepare the evaluation board hardware You can use the S32 Debug Probe to download code to target Connect S32 Debug Probe to S32V234 EVB2 using JTAG connector Connect S32 Debug Probe to PC via USB cable OR ethernet (if connected via ethernet, then USB power cable must also be connected) Connect the S32V234 EVB2 to PC via ethernet (typically via LAN) Connect power cable to evaluation board and switch on the power     2) Build the project using the A53 build option. 3) The project is now built, and the ELF file is ready to be loaded to the EVB for execution. Before a debug session can be started, we must complete HOWTO: Setup A Remote Linux Connection in S32DS (S32V234). Start A53 Debug 4) Select the debug drop-down menu and click Debug Configurations     5) Make sure the '{project_name}_Remote_Linux' debug configuration is selected and the Connection (see step 3) is selected (points to the IP address of your EVB). Click Debug     6) The first time you connect to a new IP address (i.e. the first time you debug after creating a new workspace), you will receive a warning message, Click Yes and proceed.     The executable file is copied to Linux file system and gdbserver starts.   You may get an error message on the first try, this is normal. Just try it again and it will work. 7) Once the Linux GDB has started on A53 core and the initial break point is reached in main(), it is almost ready for to start debug on ISP. Click Resume as the A53 must be running before we can attach the ISP debug thread. 😎 Return to the Debug Configurations menu and locate the ISP debug configuration. You will see a debug configuration within the 'S32 Debugger' group (in our example, isp_sonyimx224_csi_dcu_mipi_simple_IPUS0 as shown below). This is the debug configuration we will use, however, it will require some setup.     9) You should notice the error message at the top of the window, just below the title and a red 'X' on the Debugger tab. Click on the Debugger tab to select it. We must setup the Debug Probe Connection before we can proceed. There are two options: Ethernet USB   If connecting the Probe via Ethernet, please refer to the Quick Start Guide or S32 Debug Probe User Guide provided with the S32 Debug Probe for instructions on how to connect it and determine the Hostname or IP address.     If connecting the Probe via USB, then the COM port will appear in the Port selection setting. If you have more than one S32 Debug Probe connected, you will need to determine which COM port is the correct one, otherwise, only the COM port for your S32 Debug Probe will appear.   10) This is already done for our example, but for your application, it may be necessary to setup the symbols for the ISP engine. Go to the Startup tab and:    a) Check the box for 'Load symbols'    b) Select the option for 'Use file', click Workspace... and locate the object file (.opius) for the ISP engine you wish to debug.   11) Click Apply then Debug. It may take a few moments for the ISP core debug to launch.   12) Wait for the ISP debug launch to complete. You may notice the A53 thread has terminated. This is normal and expected since the camera input cannot be suspended. When the launch completes, the context of the Debug window will switch to the ISP debug thread. 13) Enable Instruction Stepping mode and then step one time to load the object file which was setup in step 6. 14) The ISP debugging is now running and you can step through the ISP engine, look at registers, set a break point, etc. Note: only one hardware break point is supported for ISP.

This document shows the step-by-step process to create a simple blinking LED application for the S32M2xx family using the S32 RTD AUTOSAR drivers. This example used for the S32M244 EVB, connected to a PC through P&E Debugger.  Preparation  Setup the software tools  Install S32 Design Studio for S32 Platform   Install the S32M2xx development package and the S32M24 RTD AUTOSAR 1.9.0 Both of these are required for the S32 Configuration Tools.  Launch S32 Design Studio for S32 Platform  Procedure  New S32DS Project    OR     Provide a name for the project, for example 'Blinking_LED_RTD_With_AUTOSAR'. The name must be entered with no space characters.     Expand Family S32M2xx, Select S32M244  Click Next   Click '…' button next to SDKs      Check box next to PlatformSDK_S32K1_S32M24_2_0_0_S32M244_M4F (or whichever latest SDK for the S32M2xxx is installed). Click OK       Click Finish. Wait for project generation wizard to complete, then expand the project within the Project Explorer view to show the contents.    To control the LED on the board, some configuration needs to be performed within the Pins Tool. There are several ways to do this. One simple way by double-click on the MEX file.     Select the overview tab and disable Pins tool. Make sure to overview tab windows shows settings shown as below.  Here, we are disabling pin tools and using MCAL driver from peripheral tools for using AUTOSAR drivers.     Now from Overview menu, select peripheral tools and double click to open it.     In the driver sections, “Port_Ip_1 driver” is the non-AUTOSAR version driver and so it must be replaced. Right click on ‘Port_Ip_1’ and remove it. Keep the BaseNXP driver as it is.     Click on the ‘+’ next to the MCAL box.   Locate and then select the ‘MCU’ component from the list and click OK.        Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Dio’ component from the list and click OK.     Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Port’ component from the list and click OK.        Now components tab should show like below :    Ignore the error for Port component for now.     Now we required to configure the different MCAL drivers that we added. Starting with Dio configuration, open the Dio configuration.     Now, open the ”DioConfig” tab. From that change Dio Port Id to 4 instead of 0    In that, select  “+” sign adjacent to Dio Channel.     Then edit Name to “DioChannel_0”and “Dio Channel Id”  to ‘6’ instead of ‘0’.       From the schematic for S32M244 EVB, we can select signal line for user LED from the schematic, channel 6 is connected to user LED signal, so we use channel 6 signal line to the chip on the user LED.            Now Select Port tab for Port configuration.   And select and open Port Configuration tab, and from that open “PortConfigSet” tab.  Edit PortPin Pcr to “134” instead of “0”.           Also, change Portpin Direction to “PORT_PIN_OUT” And PortPin Level Value to “PORT_PIN_LEVEL_LOW”.  After change it should be as below.        At the bottom you will find the “UnTouchedPortPin ’’ . Click on “+’’ and add PortPins.         Now add 6 port pins as per below configuration. Pins 0, 1,2,3, 4,5, and 6 should be setup.    Now the device configurations are complete and the RTD configuration code can be generated. Click ‘Update Code’ from the menu bar.     To control the output pin which was just configured, some application code will need to be written. Return to the ‘C/C++’ perspective.        If not already open, in the project window click the ‘>’ next to the ‘src’ folder to show the contents, then double click ‘main.c’ file to open it. This is where the application code will be added.       Before anything else is done, Initialize the clock tree and apply PLL as system clock, Apply a mode configuration, Initialize all pins using the Port driver by adding – editing code before write code here comment in main function.          /* Initialize the Mcu driver */          Mcu_Init(&Mcu_Config_BOARD_InitPeripherals);          /* Initialize the clock tree and apply PLL as system clock */          Mcu_InitClock(McuClockSettingConfig_0);          while ( MCU_PLL_LOCKED != Mcu_GetPllStatus() )          {                 /* Busy wait until the System PLL is locked */          }          Mcu_DistributePllClock();          Mcu_SetMode(McuModeSettingConf_0);       /* Initialize all pins using the Port driver */   Port_Init(NULL_PTR);       Now replace the logic of for loop as shown below code section, which will enable the LED blinking for 10 times:    You also need to declare and initialize the loop variable uint8 count = 0U       Then replace the code as below:                                     /* Logic for blinking LED 10 times */        while (count++ < 10)       {           /* Get input level of channels */           Dio_WriteChannel(DioConf_DioChannel_DioChannel_0, STD_HIGH);           TestDelay(2000000);           Dio_WriteChannel(DioConf_DioChannel_DioChannel_0, STD_LOW);           TestDelay(2000000);        }         Before the 'main' function, add a delay function as follows:  void TestDelay(uint32 delay); void TestDelay(uint32 delay)   {       static volatile uint32 DelayTimer = 0;      while(DelayTimer<delay)       {           DelayTimer++;      }       DelayTimer=0;  }    Update the includes lines at the top of the main.c file to include the headers for the drivers used in the application:    Add   #include "Mcu.h"   #include "Port.h"   #include "Dio.h"     Now, select and open max file again. Then, select and open peripheral tools.      Now, from the toolbar selection menu at the top, select and double click on the symbol as shown as below:     Now, from the global settings, for ComponentGenerationMethod from that select  “FunctionalGroups” from the drop down menu as shown below:          Now. click ‘Update Code’ from the menu bar.    Build 'Blinking_LED_RTD_AUTOSAR'. Select the project name in 'C/C++ Projects' view and then press 'Build'.    After the build completes, check that there are no errors.    Open Debug Configurations and select 'Blinking_LED_RTD_with_AUTOSAR_Debug_RAM'. Make sure to select the configuration which matches the build type performed, otherwise it may report an error if the build output doesn’t exist.    Now, you need configuration for P&E MULTILINK Debug Probe.   Connect PE Micro debugger to EVB using USB, and to make sure that debugger is connected via USB interface, then the COM port will be detected automatically (in the rare event where 2 or more debug Probes are connected via USB to the host PC, then it may be necessary to select which COM port is correct for the probe which is connected to the EVB).  Now, Select PEMicro Multilink debugger, select “Run”, and select debug configuration tab, then select GDB PE Micro Interface Debugging, and from the option available under it, select option with Debug_FLASH_PNE.   Now, in the debug configuration window, select the tab PEmicro Debugger, and in the PEMicro Interface settings, select the interface USB Multilink.   Clink apply and debug     Click Debug    To see the LED blink, click ‘Resume'     This code as it is will blink the LED 10 times, you can make changes in for loop condition to blink it infinitely.      

So you have created a project in S32DS with target of S32V234 Cortex-A53 APEX2/ISP Linux . You have built the project and now want to execute it on the S32V234-EVB2, which is running the Linux BSP for the VSDK on a microSD card. There are many ways to do this, however, the simplest is to use the built-in support within S32DS to run and/or debug over an Ethernet connection to the Linux BSP OS running on the EVB. In order for S32DS to connect to the Linux BSP OS, the following steps should be followed: 1) First, we must complete the steps in HOWTO: Setup S32V234 EVB2 for debugging with S32DS and Linux BSP . 2) With the Linux running on the EVB, start a terminal program (for ex. PuTTY) on your PC 3) Set Connection type to Serial 4) Set speed to 115200, Data bits 8, Stop bits 1, Parity None 5) Set Serial line to the COM port associated with the USB port setup in step 1 of this document. (for ex. COM3) 6) Click Open to start the terminal session 7) Press enter key to bring up login prompt 😎 Log into Linux (login name is "root") 9) Get IP address, enter command:    ifconfig       Make note of the IP address 10) Launch S32DS for Vision. From the C/C++ Perspective, select Run->Debug Configurations... 11) From 'C/C++ Remote Application'. Select '<project_name>_Remote_Linux' debug configuration. 12) Select New to create new debug connection. 13) Select SSH 14) Enter the IP address noted earlier 15) Enter user ID as "root". The Linux BSP uses Password based authentication, but by default, no password is set. So the password can be left blank. 16) Select Finish 17) Select Apply, and then if you wish, Debug This connection is stored within the workspace. It can be added to any projects within the workspace. If a new workspace is created, then this connection will not appear in the selection list.

Has this happened to you? You just launched S32DS for Vision and opened a visual graph but the blocks are collapsed onto one another. Probably looks something like this: There is an easy solution. Just click on the 'Arrange All' button and the graph will automatically expand to a manageable state. Here is the result:

UART communication is supported in the KEA64 Bootloader .rbf file  + Supported UART0: PTA2-PTA3 pins(Speed: 115200b/s) Tested on the dev board:   Development Board TRK-KEA64 Processor PKEAZN64 MLH 2N22J