KEA64 RAppID Bootloader rbf file for KEA64    MPC57xx RAppID Bootloader rbf file for MPC5744P   RAppID Bootloader rbf file for MPC5746R  RAppID Bootloader rbf file for MPC5777C  RAppID Bootloader rbf file for MPC5777C - BookE (non-VLE)    S32Kxx RAppID Bootloader rbf file for S32K116 RAppID Bootloader rbf file for S32K144W  

S32DS for Vision contains many example projects from which you can learn how S32DS, with the Vision Extension Package for V2xx, can be used with the help of the Vision SDK to develop vision applications. The example projects contain generated and hand-written code, which utilize the Vision SDK to demonstrate a workflow using S32DS. In this document, the procedure for creating a project from one of the provided ISP examples through to execution on the EVB is detailed. Prerequisite Before following the steps in this HOWTO, ensure you have the Vision Extension Package for V2xx (as well as the S32V2xx development package) installed to S32DS. 1) Launch S32DS 2) Select "New S32DS Project from example" 3) Select isp_sonyimx224_csi_dcu project and click Finish.    In this particular project, the ISP graph diagram is included. If you wish to view it, go to the Project Explorer panel and expand 'isp_sonyimx224_csi_dcu_graph'. Then double click on 'ISP data flow : mipi_simple'. The ISP graph diagram will appear in the editor panel. 5) We are ready to build the project, but first, select isp_sonyimx224_csi_dcu: A53 in the Project Explorer panel 6) Build project for A53  7) Start a debug session using method as described in HOWTO: Create S32V234 Cortex-A53 Linux Project in S32DS, beginning at step 10. 😎 Should get results similar to this:

  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 S32G2xx development package. This package is important as the S32 Debugger support component contains the device-specific Python scripts required for performing the flash programming operations.   Open the application project containing the application to be programmed to the flash memory device. 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 S32G274A. 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. Just the memory required by the new image needs to be cleared, so only check the box 'Erase all flash memory' if truly needed. 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 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 's32gxx_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"  

        Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio for ARM v2.0 Update 3          What is new? S32 SDK 0.8.6 EAR (Early Access Release)  for S32K142, S32K144, S32K146, S32K148)- see attached release notes for more details Installation instructions The update is available for online (via Eclipse Updater) or offline installation (direct download link) online installation:  go to menu "Help" -> "Install New Software..." dialog  select predefined update site "S32 Design Studio for ARM v2.0 - http://www.nxp.com/lgfiles/updates/Eclipse/S32DS_ARM_2_0/com.freescale.s32arm.updatesite" select all available items and click "Next" button   offline installation:   go to S32 Design Studio for ARM product page -> Downloads section or use this direct link to download the update archive zip file Start S32DS and go to "Help" -> "Install New Software..." Add a new "Archive" repository and browse to select the downloaded update archive zip file you downloaded in the previous step Select all available items and click "Next" button. This will starts the update installation process.

Installation & Activation HOWTO: Download, Install, Activate and Use the S32 Design Studio 3.6 HOWTO: Activate S32 Design Studio   HOWTO: S32 Design Studio - Offline Install of Extensions and Updates  S32DS Extensions & Updates: Explanation and How To Use  HOWTO: Install Lauterbach TRACE32 debugger plug-in into S32 Design Studio HOWTO: Install GHS Compiler Plugin    Getting Started What's new in S32 Design Studio 3.6 S32DS Quick Start Guide  S32 Design Studio 3.5 Tips and Tricks HOWTO: S32 Design Studio - Create a New S32DS Project from Example  HOWTO: S32 Design Studio - Create a New Application Project  HOWTO: Create a Blinking LED example project using S32K1xx RTD with AUTOSAR HOWTO: Create a Blinking LED example project using S32K1xx RTD without AUTOSAR HOWTO: Create a Blinking LED application project for S32G using S32 RTD No AUTOSAR HOWTO: Create a Blinking LED application project for S32G using S32 RTD with AUTOSAR HOWTO: Create a Blinking LED application project for S32M2xx using S32 RTD with AUTOSAR  HOWTO: Create a Blinking LED application project for S32M2xx using S32 RTD No AUTOSAR  HOWTO: Create a Blinking LED application project for S32R45 using S32 RTD No AUTOSAR HOWTO: Create a Blinking LED application project for S32R45 using S32 RTD with AUTOSAR HOWTO: Create a Blinking LED application project for S32R41 using S32 RTD No AUTOSAR  HOWTO: Create a Blinking LED application project for S32R41 using S32 RTD AUTOSAR HOWTO: Create a simple blinking LED project using S32 Config Tool (S32V2xx)  HOWTO: Create a Blinking LED application project for S32Z27x using S32 RTD No AUTOSAR  HOWTO: Create APEX2 Project From Example in S32DS for S32 Platform  HOWTO: Create An ISP Project From Example in S32DS for S32 Platform HOWTO: Create New Project from Example ‘RSDK_S32DS_template’    Build tools & Standard libraries  HOWTO: Add a static library file into S32 Design Studio GCC project HOWTO: Link a binary file(s) into the application project using GNU build tools   HOWTO: Display Percentage Of Memory Usage At End Of Build    Debug  & Flash Programming HOWTO: Setup S32V234 EVB for debugging with S32DS for Vision and Linux BSP  Using GDB Server Monitor Commands from Eclipse GDB Console HOWTO Build a Project and Setup Debugging with GDB PEMicro Debugging Interface  HOWTO: Setup static IP address for S32 debug probe  HOWTO: Start S32 Debugger from S32 Design Studio on S32G274A EVB HOWTO: Start S32 Debugger from S32 Design Studio on S32R45 EVB  HOWTO: Start S32 Debugger from S32 Design Studio on S32R41 EVB HOWTO: Command Line GDB Debugging with S32 Debug Probe for S32G2xx HOWTO: Command Line GDB Debugging with S32 Debug Probe for S32R45  HOWTO: Command Line GDB Debugging with S32 Debug Probe for S32R41 HOWTO: JTAG Flash Programming with S32 Debugger and S32 Debug Probe for S32G274A EVB HOWTO: JTAG Flash Programming with S32 Debugger and S32 Debug Probe for S32R45 EVB  HOWTO: JTAG Flash Programming with S32 Debugger and S32 Debug Probe for S32R41 EVB  HOWTO: Secure Debugging from S32DS IDE with S32 Debugger and S32Debug Probe  HOWTO: Start Trace with S32 Debugger and S32 Debug Probe on S32G2xx HOWTO: Start Trace with S32 Debugger and S32 Debug Probe on S32R45  HOWTO: Start Trace with S32 Debugger and S32 Debug Probe on S32V2xx  Sharing Debug Configuration with Eclipse Debugging the Startup Code with Eclipse and GDB  HOWTO: Add a new debugger configuration to an existing project  HOWTO: Command Line JTAG flash programming with S32 Debug Probe on S32G274A EVB HOWTO: Command Line JTAG flash programming with S32 Debug Probe on S32R45 EVB  HOWTO: Command Line JTAG flash programming with S32 Debug Probe on S32R41 EVB HOWTO: Use FlashSDK to add support for QuadSPI flash memory devices for S32 Flash Tool  HOWTO: Program Serial RCON using S32 Debug Probe  Secure Debug Support on S32K3 | PEmicro  HOWTO: Debugging LAX on S32R45 Using S32 Debugger HOWTO: Debugging SPT on S32R45 Using S32 Debugger HOWTO: Debugging BBE32 DSP on S32R45 Using S32 Debugger HOWTO: Debugging SPT on S32R41 Using S32 Debugger S32Debugger Zephyr Thread Awareness User Manual    S32 Configuration Tools HOWTO: Use DCD Tool To Create A Device Configuration Data Image  HOWTO: Use IVT Tool To Create A Blob Image HOWTO: Use IVT Tool To Create A Blob Image S32G274A HOWTO: Use IVT Tool To Create A Blob Image S32R45    Real-Time Drivers (RTD), S32 SDK & Other SDKs HOWTO: Download RTD 5.0.0 and Install in S32 Design Studio 3.6 HOWTO: Working with AMMCLib SDKs  HOWTO: Add custom SDK into existing project  HOWTO: Migrate S32K1xx SDK project from SDK v4.0.1 to v4.0.2  HOWTO Use FreeRTOS OS Awareness with S32Debugger and PEMicro  Implementing FreeRTOS Performance Counters on ARM Cortex-M | MCU on Eclipse  HOWTO: Move FreeRTOS Heap into DTCM memory - S32K3xx + RTD   General Usage HOWTO: S32 Design Studio Command Line Interface  HOWTO: Generate S-Record/Intel HEX/Binary file  HOWTO: Migrate Application Projects from S32DS for Vision 2018.R1 to S32DS 3.x  HOWTO: Add user example into S32DS   Troubleshooting Troubleshooting: Incompatible JVM Error When Launching S32 Flash Tool v2.1 Troubleshooting: PEmicro Debug Connection: Target Communication Speed  Troubleshooting: Indexer errors on header file  Troubleshooting: PEMicro Debugging: PIT and STM modules cannot count when Debug Mode is entered  Troubleshooting: PEMicro Debugging: Problems resuming from breakpoint in vTaskDelay  Troubleshooting: Quick Fix Option in Problems View  Troubleshooting: S32 Design Studio exits unexpectedly or Installer rolls back immediately following activation code entry  Troubleshooting: Activation fails with error message FNP ERROR 0  Troubleshooting: Can't See AMMCLib for S32K3 in S32DS Extensions and Updates Troubleshooting: Java Error When Config Tools Used From Command Line    

      Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio for Power Architecture v2.1 Update 10          What is new? Service Pack for S32R264 This is a cumulative update - it includes all the content of previous updates (Update 1,Update 2, Update 7, Update 8 ) Installation instructions The update is available for online installation (via S32DS Extensions and Updates) or offline installation (direct download link)  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 for Power 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", then click 'Go to Preferences' link And add a new site "Add..." repository and browse to select the downloaded update archive zip file you downloaded in the previous step Select the 'S32 Design Studio for Power Architecture Device Package' and 'Update with S32 SDK 3.0.2 for Power Architecture' packages and click "Install/Update" button.   This will start the update installation process.

Installation & Activation HOWTO: Activate S32 Design Studio  HOWTO: Install Lauterbach TRACE32 debugger plug-in into S32 Design Studio  Create a New Project  HOWTO: Create APEX2 Project From Example in S32DS for Vision  HOWTO: Create An ISP Project From Example in S32DS for Vision  HOWTO: Create A53 Linux Project in S32DS for Vision  HOWTO: Create An ISP Project From Existing VSDK Graph in S32DS for Vision  HOWTO: Create A New Makefile Project With Existing Code From NXP Vision SDK Example Project   HOWTO: Build a Project and Setup a Debug Configuration for debugging in S32 Design Studio  HOWTO: Create A53 APEX2 and/or ISP Linux Project in S32DS for Vision DDR Configuration & Validation and Stress Test Tools HOWTO: Use DDR Configuration and Validation Tool  HOWTO: Use DDR Stress Test Tool  Hardware Setup HOWTO: Setup S32V234 EVB for debugging with S32DS for Vision and Linux BSP HOWTO: Prepare and boot S32V234 EVB from eMMC  HOWTO: Setup static IP address for S32 debug probe  Debugging HOWTO: Setup S32V234 EVB for debugging with S32DS for Vision and Linux BSP  HOWTO: S32V234-EVB debugging with Linux and gdbserver on target machine  HOWTO: Start Debug on an ISP Application Project with S32 Debugger and S32 Debug Probe  HOWTO: Start Debug on an APEX2 Application Project with S32 Debugger and S32 Debug Probe  Debugging the Startup Code with Eclipse and GDB | MCU on Eclipse   VSDK HOWTO: Change Vision SDK root in S32DS for Vision  HOWTO: Create A New Makefile Project With Existing Code From NXP Vision SDK Example Project  HOWTO: Prepare A SD Card For Linux Boot Of S32V234-EVB Using BSP From VSDK  Linux HOWTO: S32V234 EVB Linux - Static IP address configuration  HOWTO: S32V234 EVB Linux - DHCP IP address setup  HOWTO: Prepare A SD Card For Linux Boot Of S32V234-EVB Using BSP From VSDK  HOWTO: Access Linux BSP file system on S32V234-EVB from S32DS for Vision HOWTO: Setup A Remote Linux Connection in S32DS for Vision  General Usage HOWTO: S32 Design Studio Command Line Interface  HOWTO: Add user example into S32DS  HOWTO: Generate S-Record/Intel HEX/Binary file  HOWTO: Update S32 Design Studio  Troubleshooting Help! I just relaunched S32DS for Vision and my visual graph is collapsed!  Help! I just updated to new version of S32DS and now my projects have errors and I can't build!  Troubleshooting: PEmicro Debug Connection: Target Communication Speed  Troubleshooting: Indexer errors on header file  S32 Design Studio Offline activation issue hot fix  https://community.nxp.com/docs/DOC-345238 

This document details the steps to program external EEPROM with the 32 reset configuration bits in support of the 'Boot from serial RCON' method detailed in the S32R Reference Manual. The Python scripts used for this task are designed and tested to work on the S32R45 EVB and the Atmel AT24C01C it contains.   The RCON can be set by the following: Fuses (internal to the device) Parallel (GPIO pins/DIP Switches on S32R45 EVB) Serial (EEPROM connected via I2C) The Serial option can be programmed using a debug probe connected via JTAG. This enables the RCON to be controlled remotely, assuming the debug probe is setup to allow remote connections.  Preparation Install S32 Design Studio IDE  Install the Development Package for the device you are debugging. This is important as the S32 Debugger support within it contains the device-specific Python scripts required for initialization of the cores.  Connect the S32 Debug Probe to the S32R45 EVB and the host PC containing S32 Design Studio installation. Set BMODE pins to Boot from RCON Set BOOT_CFG[8]=1 on the S32R EVB, for serial RCON mode See the EVB documentation and device reference manual for more details on BOOT_CFG settings, etc.   Procedure  Open cmd window to the S32 Debugger folder where the device-specific scripts are located. C:\NXP\S32DS.3.4\S32DS\tools\S32Debugger\Debugger\scripts\s32r45 Set Python path so correct version is used (if not already set in env vars) set PYTHONPATH=C:\NXP\S32DS.3.4\S32DS\build_tools\msys32\mingw32\lib\python2.7;C:\NXP\S32DS.3.4\S32DS\build_tools\msys32\mingw32\lib\python2.7\site-packages Edit the python script to adjust the value to be programmed to RCON, s32r45_i2c_RCON.py. Note: The listed examples show only the minimum values required to configure each of the external memory types. Additional settings may be required for your specific application.       Adjust the RCON_DATA for the configuration you wish to program.  Do not adjust RCON_ADDR. Adjust the S32DBG_IP for the IP address of your S32 Debug Probe.  Adjust the INTERACTIVE_MODE Set True, if desired to be prompted in the command window to enter RCON_DATA Set False, if desired to have script automatically enter RCON_DATA, based on the value set within the file. Enter the command to start GDB, passing in the RCON Python script: Windows OS: C:\NXP\S32DS.3.4\S32DS\tools\gdb-arm\arm32-eabi\bin\arm-none-eabi-gdb-py.exe -x s32r45_i2c_RCON.py Linux OS: arm-none-eabi-gdb-py -x .\s32r45_i2c_RCON.py   You may need to press enter a couple of times. If everything worked properly, then the value you programmed will be displayed to the screen. To exit GDB, enter 'quit'. Before performing boot from serial RCON, remember to set BOOT_CFG[8] = 1. See the EVB documentation and device reference manual for more details.

      Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio for Power Architecture v2.1 Update 7          What is new? Integrated S32 SDK for Power Architecture RTM 3.0.2 (see the S32 SDK release notes) This is a cumulative update - it includes all the content of previous updates (Update 1,Update 2 ) Installation instructions The update is available for online installation (via S32DS Extensions and Updates) or offline installation (direct download link)  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 for Power 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", then click 'Go to Preferences' link And add a new site "Add..." repository and browse to select the downloaded update archive zip file you downloaded in the previous step Select the 'S32 Design Studio for Power Architecture Device Package' and 'Update with S32 SDK 3.0.2 for Power Architecture' packages and click "Install/Update" button.   This will start the update installation process.

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.

        Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio for ARM v1.3, Update 4             S32 Design Studio for ARM v1.3 Update 4 has been just released. This update is applicable for S32 Design Studio for ARM v1.3 hosted on Windows and Linux and does not require any previous update to be installed. Note: Update 3 (which is available as a separate update) includes S32K148 support only. Update 4  contains update 3 so you don't have to install it separately.   What is new? Update 4 contains: Device support for S32K148 and S32K14x_SDK_EAR_0.8.3 which supports S32K148 & S32K144. More information can be found in the release notes for the SDK attached.   Installation instructions The update is available for online (Eclipse Updater) or offline (direct download link) installation.   online installation: go to menu "Help" -> "Install New Software..." dialog select predefined NXP S32 Design Studio update repository http://www.nxp.com/lgfiles/updates/Eclipse/S32DS_ARM_1_3/com.freescale.s32arm.updatesite select all available items and click "Next" button offline installation: go to S32 Design Studio product page -> Downloads section or use the direct download link to download the "S32 Design Studio for ARM v1.3 - Update 4" file.   Start S32DS and go to Help -> Install New Software... Add a new "Archive" repository, browse to select the downloaded Update 4 archive file. Select all available items and click "Next" button.  

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 ISP Visual Graph tool. The completed application will take an image from camera, processes it on ISP and put the processed image in DDR buffers. Once the image is in DDR buffer, host (A53 core running Linux) will direct the display control unit (DCU) to display it on screen. Prerequisites: Some knowledge of the S32V234 System on a Chip (SoC) Have an understanding of the ISP architecture 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 '3 | Create a new ISP Application'

While the S32V234-EVB2 comes shipped with an SD card preloaded with a Linux Board Support Package(BSP), it does not support the Vision Software Development Kit(VSDK). This you will have to load yourself. There are two methods for installing the S32V234 BSP for VSDK to your SD card: 1) Download the image file from your Software Account on nxp.com and write the file to the SD card, or 2) Create the image on the SD card from ubuntu installed on a PC or virtual machine Download the image file and write it to SD card This is the simplest method, but does not allow for much customization. It is an excellent choice for those users who do not have much experience with Linux or just need something quick to get up and running with S32 Design Studio, try out the application examples, etc. Procedure 1) Login to your account on NXP.COM (if you do not already have an account, then just register for one) 2) Go to Vision SDK Software  3) Accept the license agreement 4) Select the version of VSDK you wish to use 5) Check the box next to 'VisionSDK RTM x.x.x pre-built SD Card image based on Yocto rootfs' and click 'Download selected files'. This will download the .gz file to your PC. 6) Unpack the VisionSDK_S32V2_RTM_x_x_x_img_yocto.tar.gz archive file 7) Unpack the VisionSDK_S32V2_RTM_x_x_x_img_yocto.tar archive file 😎 Navigate to the '\build_content\v234_linux_build\s32v234evb' folder, then unpack the sdcard-evb.tar.bz2 file 9) Unpack the sdcard-evb.tar file 10) The resulting file is sdcard-evb.img. You can use an image writing tool (such as Win32 Disk Imager download | SourceForge.net) to write this image file to the SD card. You will need to use the SD card adapter to insert the microSD card into the SD card slot on your PC, if available. If you do not have an SD card slot on your PC, there are many SD card-to-USB adapters available on the market. 11) The SD card is now ready to inserted into the SD card slot on the S32V234-EVB2 SD card slot. Create the image on SD card from ubuntu This is a better choice for more advanced users who wish to customize the BSP. To prepare an SD card for a Linux boot, it is necessary to connect the SD card to a machine with Linux OS. If a Linux OS machine is not available, then a virtual machine installed to a Windows OS machine may be used. If you have access to a Linux OS machine, skip to step 4. Procedure 1) Download and install a virtual machine VMware Workstation Player Virtual Box 2) Download Ubuntu. This tutorial uses the Ubuntu version 14.04.5.  The image will be ubuntu-14.04.5-desktop-amd64.iso. 3) Launch VMware or Virtual Box and create a new virtual machine Use downloaded Ubuntu image when requested for installer disc image file Hit Next and select Linux as the guest operating system and select Ubuntu for the version. Hit Next and name your virtual machine and specify where you want to store it. Increase the disk size to 40 GB Hit Finish and install VMware Tools for Linux, if asked 4) Within C:\NXP\S32DS_Vision_v2.0\S32DS\s32v234_sdk\os extract 'build_content.tar.gz', then extract 'build_content.tar' and navigate to the 'v234_linux_build' folder 5) Start virtual machine May need to manually connect USB-mounted SD card reader Log in to virtual machine 6) In files, go to 'Home' directory and create a folder "VSDK" 7) Within VSDK folder, copy the files image, u-boot.s32, s32v234-evb.dtb, and rootfs.tar from the 'v234_linux_build' folder.  Note: The file s32v234-evb.dtb and u-boot.s32 will have names with XXXXX-suffix for the schematic number printed on the evaluation board (EVB) you are using. Be sure to use the files which correspond to your EVB. 😎 Load the card into the reader. If you are using a virtual machine, it is recommended to use a USB adapter instead of a built-in reader in the PC. 9) Within the virtual machine, launch the terminal program 10) Within the terminal program, enter command 'cat /proc/partitions' to view the names of the partitions and identify the names of the partitions on your SD card. Perhaps it is named 'sdb'. 11) Delete all existing partitions.    a) Enter command 'sudo fdisk /dev/sdb'.    b) Enter command 'd' and then the number of the partition to delete. Repeat as necessary until all partitions have been deleted 12) Create new partitions    a) Enter command 'n' for new    b) Enter 'p' (or just hit <enter>, as this is the default) for primary    c) Enter '1' (or just hit <enter>, as this is the default) for partition number 1.    d) Press <enter> to select the default value for the First sector    e) Enter '+255M' to set the size    f) Enter command 'n' again, for partition number 2, however, press <enter> to select the default value for the 'Last sector' 13) Set the partition type    a) Enter command 't' for type    b) Enter '1' for partition number 1    c) Enter 'c' for partition type FAT32    d) Enter command 't' again, for partition number 2, however, enter '83' for partition type LINUX If you get error 16: Device or resource busy, as shown above, use commands 'umount /dev/sdb1' and 'umount /dev/sdb2' to free the pre-existing partitions. Then try again and should be ok now 14) Write the new configuration, enter 'w' 15) Try to setup the filesystems. Enter 'sudo mkfs.vfat -n boot /dev/sdb1'. If you get the error '/dev/sdb1 contains a mounted filesystem', you will need to unmount the partition first. To save time, unmount both /dev/sdb1 and /dev/sdb2. Enter 'umount /dev/sdb1' and then 'umount /dev/sdb2' Now try 'sudo mkfs.vfat -n boot /dev/sdb1' again 16) It worked, so now enter 'sudo mkfs.ext3 -L rootfs /dev/sdb2'. It will take a minute or two for this to complete. Wait until you get the command prompt again. 17) Now it's time to load the BSP content from the VSDK. But first, change the directory to the one we created earlier for the BSP files. Enter 'cd /home/user/VSDK' or 'cd VSDK'. Enter the following commands: sudo dd if=u-boot.s32 of=/dev/sdb bs=512 seek=8 conv=fsync sudo cp Image /media/user/boot sudo cp s32v234-evb.dtb /media/user/boot 18) Now we need to extract the root filesystem, change the directory to its location 19) Enter command 'sudo tar -xvf /home/user/VSDK/rootfs.tar' 20) Once the files are extracted, enter command 'sync'   Now the SD card is ready to be used in the S32V234-EVB.

This document details how to create a new project and build using the existing code and makefile provided within the NXP Vision SDK example projects. If you are creating a new makefile project with code from any other source, the procedure may be different. Before creating a new makefile project from existing code we need to add some paths to the environment variable PATH and a couple of new environment variables. There are 3 main methods for adding these paths and variables. Which method depends upon your needs. Method 1 The paths and variables can be added to each project individually. This is useful if you only want these changes to affect a small number of projects. Or if your projects require different paths and variables. Method 2 The paths and variables can be added to the entire workspace within S32DS . These will not be visible outside of S32DS and therefore will not affect the entire Windows environment. This is useful if you have a large number of projects with common requirements for paths and variables and do not want them visible any tools outside of S32DS. Method 3 The paths and variables can be added globally to the Windows environment and will affect all installed tools. This method is not recommended. Add the following paths to the PATH variable (assuming the default installation settings for S32DS for Vision were used): C:\NXP\S32DS_Vision_v2018.R1\Cross_Tools\gcc-6.3-arm64-eabi\bin C:\NXP\S32DS_Vision_v2018.R1\Cross_Tools\gcc-6.3-arm64-linux\bin C:\NXP\S32DS_Vision_v2018.R1\Cross_Tools\gcc-6.3-arm32-eabi\bin C:\NXP\S32DS_Vision_v2018.R1\utils\msys32\mingw32\bin It is also necessary to add the following Windows system variables: Variable Name: S32V234_SDK_ROOT Variable Value: C:\NXP\S32DS_Vision_v2018.R1\S32DS\s32v234_sdk Variable Name: APU_TOOLS Variable Value: C:\NXP\S32DS_Vision_v2018.R1\S32DS\APUC Now we are ready to create the new project. 1) Launch S32DS for Vision 2) Click New 3) Select 'Makefile Project with Existing Code' 4) Select Next 5) For 'Existing Code Location', select 'Browse...' and then select the directory  C:\NXP\S32DS_Vision_v2018.R1\S32DS\s32v234_sdk\demos\isp\isp_sonyimx224_rgb_yuv_gs8 6) Click OK 7) For 'Toolchain for Indexer Settings', select the option which matches your desired build configuration. Select:    Linux builds: 'Standard S32DS Linux toolchain for ARM Cortex-A'    Standalone builds: 'Standard S32DS toolchain for ARM Cortex-A' This sets up some toolchain paths, but later we will set more for the specific needs of the VSDK examples. 😎 Click Finish 9) Change to C/C++ perspective, click on 'Switch to C/C++ Development' 10) Right-click on the project from the Project Explorer. Select Properties 11) Go to section 'C/C++ Build' and make sure that Generate Makefiles automatically is unchecked:  12) Go to the 'Behavior' tab and in the field next to 'Build', enter:    ISP examples: 'allsub'    APEX examples: 'APU_COMP=nxp allsub' 13) In the field next to 'Clean', enter 'clean' 14) Go to 'Builder Settings' tab, in 'Build location' section change the path for the 'Build directory'. Click on 'Workspace...' button 15) In the Folder selection menu, select the subfolder 'build-v234ce-gnu-linux-d' and click OK 16) Go to section 'Environment' 17) Select the environment variable 'PATH' and click 'Edit...' 18) Add the paths to the value field, each separated by a comma ';' C:\NXP\S32DS_Vision_v2018.R1\Cross_Tools\gcc-6.3-arm64-eabi\bin C:\NXP\S32DS_Vision_v2018.R1\Cross_Tools\gcc-6.3-arm64-linux\bin C:\NXP\S32DS_Vision_v2018.R1\Cross_Tools\gcc-6.3-arm32-eabi\bin C:\NXP\S32DS_Vision_v2018.R1\utils\msys32\mingw32\bin Click OK 19) Click 'Add...' 20) Enter the variable name 'S32V234_SDK_ROOT' and value 'C:\NXP\S32DS_Vision_v2018.R1\S32DS\s32v234_sdk' Click OK 21) Click 'Add...' again and this time enter variable name 'APU_TOOLS' and value 'C:\NXP\S32DS_Vision_v2018.R1\S32DS\APUC' Click OK 22) Click OK to close the Properties menu. 23) Click on 'Build' 24) Once the build is complete, the binary file (ELF) will be created If you like to create release version - add another build configuration and select release build folder. Right click on project name->Properties:  Switch configuration to Release and select build folder:  Exclude release build when Default (you can rename it to Debug) configuration is selected and vice versa.  Right click on Release build folder (that one which ends with -o). Choose Resource configuration and select exclude from build:  Right click on Debug build folder (that one which ends with -d) -> Resource Configuration -> Exclude from build and select Release:  Select Build target to Release and build it: 

There are three methods to run the configuration tool; from S32DS, from Terminal and JTAG, and from command line. S32DS Method 1) Make sure EVB is powered and connected to PC via PEMicro (Universal Multilink) or Lauterbach 2) Launch S32DS for Vision 3) File -> New -> S32V DDR Configuration Project 4) Enter a name for the project, for example 'DDR_Config_test'. Click Next 5) Expand 'S32V' and select 'S32V_234' 6) Click Finish to generate the project with default settings OR if you wish, to view or adjust more project settings, click Next. For this demonstration, we click Next. a. Select which DDR controller to which the settings will be applied. For this demonstration, we leave it at default (1st DDR Controller) b. There is an option to import settings from a file c. Board setting allows you to select from a list of predefined configurations, one for each of the NXP S32V234 evaluation boards i. S32V234_EVB is for LPDDR2 (SCH28899 and SCH28292(old board)) ii. X_TR_DVAL_625 is for DDR3 (SCH28662(old board)) iii. S32V234_NXP_EVB is for SCH29288 (S32V234-EVB2) iv. Custom allows for more options to be selected. See user manual for more detail d. For this demonstration, we select S32V234_EVB e. Click Finish 7) It will take a couple minutes to generate the project. You will get a prompt to pen the S32V DDR Configuration perspective. Click Yes. 😎 Now the project is generated and you can see it listed in the Project Explorer 9) Notice the Components and Component Inspector views of the S32V DDR Configuration perspective. 10) Select the component 'MMDC_0:Init_MMDC from the Components view 11) In the Component Inspector window you can see all of the configuration settings. You can modify the settings here. Changes made to some of the high-level settings may also cause changes to some of the low-level settings. There are some consistency checks that are run automatically after settings are changed which will trigger an error message in the case of an invalid configuration. a. For an example of high-level settings affecting low-level settings, try changing the 'Memory type' from LPDDR2 to DDR3. You can see the Burst Length, Column Address Width, and Row Address Width have changed. b. For an example of a consistency check on an invalid configuration, try changing the CAS Read Latency value (MDCFG0) from 8 to 12 (valid range as displayed with mouse hover tooltip shows 3-11), you will see the error appear. Change back to 8 and error is gone. 12) Open Configuration Registers view. Window -> Show View -> Other -> Processor Expert -> Configuration Registers. This shows how the settings will appear in the memory map. As you change the settings, the values will update here and the affected rows will be highlighted. Try it by changing Column Address Width in MDCTL of the Component Selector window. Likewise, you can try changing the value manually in the Configuration Registers view and see the setting in the Component Selector window update as well. *Hint: enter the name of the view in the search bar to find it quicker 13) Once all changes to the settings are complete, code can be generated. Press the 'Generate Processor Expert Code' button in the Components view. The generated .c and .h file will appear in the 'Generated_Code' folder of the Configuration project. These can be copied into your application project. OR 14) Back in the Component Inspector view, there are tabs for Import and Export settings. The Import settings tab will allow you to import existing settings files, as was also shown in the new project wizard. From the Export settings tab, you can generate a settings file for storage or sharing. The settings files for MMDC_0 and MMDC_1 for each of the supported NXP EVBs are included and can be located in 'C:\NXP\S32DS_Vision_v2.0\eclipse\ProcessorExpert\Optimization\resources\S32V\Boards' and then select the folder for the specific board. The CodeWarrior Register Text format is recommended for these files. 15) Now select the 'Validation' tab (some views, such as Configuration Registers, can be minimized for better view). Here we can execute a validation of the configuration settings we've made. Now is a good time to double check the hardware connections. 16) Select the connection method (either PEMicro or Lauterbach, depending on your setup). We will use System: S32V234; PEMICRO 17) Press 'Connect to Target' 18) Check a box for one of the scenarios. For example, select 'Read Delay Calibration' 19) Select the 'Choose Tests' tab 20) You can select tests from a list. To see the script behind the test, simply double-click on the name. For faster operation, ELF file versions are also provided. 21) Select the tests you wish to execute and press 'Start Validation'. For example select 'Write-Read-Compare-Elf', 'Walking Ones Elf', and 'Walking Zeros Elf'. 22) These tests will try different values and to determine which will work and which will not. After the test is finished, the best values are chosen and written back to the project configuration settings. To see the values change, go to the Properties tab and find 'PHY Read delay-lines Configuration' or restore the 'Configuration Registers' view and see the values changed. 23) For each test, you can see the errors which occurred in the 'Summary' tab, Test results section. There is also Updated configuration registers section which shows the register and the new value which was written to it. For more details on the errors, there is a Log tab which displays the log for each test which was run. Finally there is a Scripts tab which shows the script for each test containing the test settings. Each test box is colored to reflect the result of the test. Clicking on different ones causes the display below to change and show the results for that test. 24) The Write Delay Calibration test scenario is very similar to the Read Delay Calibration test scenario, but instead, the Write delay-lines Configuration will be updated. 25) The Operational DDR Tests run the same tests, but no value in the configuration is changed. You can set it to run for many repetitions to test for stability. Terminal window Method (JTAG) This checks what settings are already uploaded in MMDC module 1) Make sure EVB is powered and connected to PC via PEMicro (Universal Multilink) or Lauterbach (to load test application) AND serial communications via USB cable(for terminal access). 2) In S32DS, create a simple project a. File->New->S32DS Application Project b. Enter name 'test' c. Select S32V234 Cortex-A53 d. Next e. Uncheck boxes for cores 2-4 f. Finish 3) Setup debug configuration a. Run->Debug Configurations… b. Select test_A53_1_PNE c. Change C/C++ Application to C:\NXP\S32DS_Vision_v2.0\utils\ddr_stresstool\ddr-test-uboot-jtag-s32v234.elf d. Select Debugger tab e. Click Advanced Options f. Check box for Enable initialization script g. Browse to find C:\NXP\S32DS_Vision_v2.0\eclipse\plugins\com.pemicro.debug.gdbjtag.pne_3.1.3.201709051622\win32\gdi\P&E\supportFiles_ARM\NXP\S32Vxxx\S32V234M100_DDR.mac h. OK 4) Click Debug. You will see error message indicating the source file could not be found. This is expected. 5) Open terminal (such as PuTTY.exe) and connect a serial line using the USB port you have connected to the EVB, speed set to 115200, 8 data bits, 1 stop bit, and no parity or flow control. 6) Click Resume in S32DS Debugger. 7) In terminal window, you will see the test script has started. 😎 Select the MMDC channel (for example, enter 1 for MMDC1) 9) Select the DDR density (for example, enter 6 for 32MB) 10) Enter 'y' to accept the DDR Calibration 11) Enter 'y' to accept the DDR frequency of 533MHz 12) Wait and watch while the test completes. 13) When the test completes, the results are shown. You will have to manually update your settings from the information displayed. 14) Next you will have the option to run the DDR Stress Test.

The S32 Design Studio for S32 Platform supports the S32R45 device with the S32 Debugger. This document provides the details on how to setup and begin a debugging session on the S32R45 evaluation board.   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 S32R4xx Development Package.   Setup the hardware Confirm the setup of the S32R45 evaluation board.  Configure the JTAG. The S32R45 evaluation board supports both 10- and 20- pin JTAG connections. The default board configuration is set to 20-pin, change the position of the jumper J59 from 2-3(default)  to 1-2, if you are using the 10 Pin JTAG interface. Both are supported by the S32 Debugger and S32 Debug Probe. 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. Use the JTAG connection as was confirmed in the previous step. Connect the S32 Debug Probe to the host PC via USB OR via 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 SDK example project 'hello_world_s32r45'. 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.   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 this case, 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 multi-core 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 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().  

Hello, the new release of S32DS for ARM v1.3 is available now in the download section of S32DS web page: http://www.nxp.com/s32ds   The Activation code is required to install the product. The activation code is different to previous versions (v1.1/1.2). You should get the appropriate Activation Code by a notification email which is send automatically when you proceed to the downloading: What is new?  New device supported: S32K144 v2.0 ARM64: Linaro GCC 4.9-2015.05 Fully integrated S32 SDK for S32K144 EAR release v0.8.2. including PinMuxing and Processor Expert configuration. FreeMASTER Serial Communication driver for S32K144 family  Highly Assembly Optimized version of Automotive Math and Motor Control Libraries for KEA and S32K devices v1.1.6  IAR debugger support by new project wizard Updated SEGGER and P&E debug plugins to the latest and greatest versions Reset functionality added with P&E debugger for single core projects (KEA, S32K devices) and A5 core for MAC57D54H Flash configuration supported for S32V234 Header files for KEA and MAC57D54H updated Advanced FreeRTOS kernel aware debug support Bug fixes Project Explorer updated to correctly show active build configuration resources     Note: The plugins to support GreenHills, IAR, iSystem, Lauterbach are not included and have to be installed from corresponding update site or installation.

Create Project From Example S32DS for ARM: Create and Debug a New Project from Example Code in S32 DS IDE for ARM based MCUs. Learn how to create a new project in S32 Design Studio IDE and load an example code to blink an LED using the S32K144EVB and build and debug the project. Create New Project S32DS for ARM: Create and Debug a New Project in S32 DS IDE for ARM based MCUs Learn how to create a new project in S32 Design Studio IDE using Processor Expert and SDK to blink an LED using the S32K144EVB and build and debug the project.

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.

The Vision SDK root is contributed to the Design Studio as a dynamic path variable “S32DS_VSDK_DIR”. Several Design Studio services use this variable to access the resources inside the Vision SDK. By default, this variable points to “${eclipse_home}../S32DS/s32v234_sdk”, i.e. to the Vision SDK shipment bundled with Design Studio. Technically you can change this variable to point to another instance of Vision SDK using the following steps: 1. Go to the main menu "Window -> Preferences" 2. Filter the preference dialog with "sub" keyword or just navigate to "Run/Debug -> String Substitution node. 3. Edit Variable "S32DS_VSDK_DIR" to assign another value to be substituted as Vision SDK root 4. Press OK when changes are complete.