This instruction details the steps to create an image vector table, then subsequently generate a blob image which can be written to external flash on the S32G274A EVB. For this, the 'hello_world_s32g274a' example project from the S32G274 SDK installed to S32 Design Studio IDE. This instruction shows the process for QSPI, however, SD, MMC, and eMMC are also supported. The Image Vector Table (IVT) image is a set of pointers to other images which are required by the BootROM. It typically contains the following images, though not all are required to create a valid IVT image: DCD Self-Test DCD HSE Application Bootloader The IVT Tool enables configuration and generation of the IVT image as specified in the BootROM reference manual. Prerequisites Before using the IVT Tool, it will be useful to have already generated the binary image from your application project, it will be an input to the IVT. For application bootloader image, follow the steps in HOWTO: Generate S-Record/Intel HEX/Binary file, selecting 'Raw binary' option. For DCD image, follow the steps in HOWTO: Use DCD Tool To Create A Device Configuration Data Image . Procedure With desired project open in project explorer (C/C++ perspective), switch to IVT perspective. Click on 'Open IVT'. In the Boot Configuration section, check that the correct Boot Target is selected. For the demonstration here, M7_0 is the correct selection. Check the 'Interface selection' section. If your intended boot device is SD, MMC or eMMC, then change the setting from QuadSPI Serial Flash. If your intended boot device is QuadSPI AND you do not have a QuadSPI parameter file to specify, then uncheck the box for 'Configure QuadSPI parameters'. QuadSPI parameters change some flash registers' settings away from the default setting and are generally required for larger memory sizes (for ex. applications over 1 MB in size, for some supported devices).  From the Image Table section, depending on your configuration, turn off all unused images. For the demonstration here, the following will be changed to Reserved: Self-Test DCD, Self-Test DCD (backup), DCD (backup), Application bootloader (backup). The following images will remain enabled: DCD, Application bootloader. In DCD section of the Image Table, click 'Browse File' and select the DCD binary file. Some of the fields may become red shaded after the file is loaded. This is OK as it is showing the memory layout is no longer aligned. This will be resolved in a later step. In Application bootloader section of the Image Table, click 'Browse File' icon and select the image as noted in the Prerequisites section. When the application boot image is loaded, the tool processes the file to check if it contains the header for the application bootloader image. If the header is not found, it means that the file is only the raw code (the bin generated by S32 Design Studio) and it will be necessary to provide the values for RAM start & entry addresses (code length is automatically calculated), as noted with the expanded view and red shading. To set the RAM start pointer and entry pointer addresses, from to the C/C++ perspective: Open the linker file and locate the RAM start address and enter it in both the RAM start pointer AND RAM entry pointer fields in the IVT Tool. Use copy and paste to add the values to the Application Boot Image settings. The length must be adjusted since it is not 8 byte aligned. Since 14020 / 8  = 1752.5, we will round up to 1753. Then, 1753 * 8 = 14024, so we will enter 14024. Since the application binary file which was loaded is just a raw binary file, it is necessary to generate the full application bootloader image. The Export Image function takes the values entered for the RAM start & entry pointers and Code length, then generates the Application bootloader header. This header is added to the raw binary file producing a new image, the full application bootloader image file. Within the Application bootloader section, click 'Export Image' and enter a meaningful name for the image file. In addition to being a necessary source component of the IVT image, this file can more easily be shared or re-used to as an input to other IVT images. After the file has been generated, you will notice that the address settings section has collapsed to represent that this information is now included in the application bootloader image which will be used to generate the Blob image file. Click 'Export Blob Image' to generate the blob image file. This is what will be flashed to the target. Now that the Blob Image is generated, the 'Flash Image' button could be used to program the image to the target over serial connection, use the S32 Flash Tool, or over the JTAG connection using the Flash Programmer within the S32 Debugger (QSPI only).

Quick Fix is a feature of the Java editor in Eclipse which enables a user to resolve problems found in the Java code of their project. This feature is available to be used within S32 Design Studio for some problems. Such problems will be identified with the 'light bulb' icon in the description field, as shown below: For example, such problems sometimes occur when importing a project created in a previous version of S32 Design Studio, are provided from another user, or some files in a project have become corrupted. To resolve issues identified with the 'light bulb' icon, right-click on the problem and from the pop-up menu, select 'Quick Fix'.  The Quick Fix menu will appear, providing the available solutions for the problem. In most cases, there will be just one solution. Click finish to implement the fix. In some cases, more information will be required from the user to complete the fix. Complete the form to provide the additional information, then click OK. Now the problem should be resolved.

        Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio for Power Architecture v2.1         The Automotive Microcontrollers and Processors’ Embedded Tools Team at NXP Semiconductors, is pleased to announce the release of the S32 Design Studio for Power Architecture version v2.1. It is the successor of S32 Design Studio for Power 2017.R1. - the versioning scheme has changed. Release content (What is new?) Eclipse Neon 4.6 Framework GNU Build Tools for e200 processors bld=1607 rev=gceb1328 (support VLE and BookE ISA, based on gcc 4.9.4 [1.February 2019], binutils 2.28 and gdb 7.8.2) - see the complete GCC release notes Libraries included: newlib, newlib-nano and Freescale EWL2 P&E Multilink/Cyclone/OpenSDA (with P&E GDB Server) - updated (v1.7.2.201709281658) New Project wizards to create application and library projects and projects from project examples for supported devices Peripherals Register and Special Purpose Registers View Fully integrated S32 SDK RTM v.3.0.0 (Windows only). For the details on the feature set of SDK please refer to SDK Release notes attached and Reference Manuals (Please note that SDK has Early Access Release status, which means that there could be some limitations and/or issues. Also note, the SDK is available for Windows host only). SDK management included: o FreeMASTER Serial Communication driver (v2.0 August 31th 2016) o Automotive Math and Motor Control Libraries(v1.1.15) o Support for importing MCAL configuration to a custom SDK o An SDK can be attached to a library project using the project wizard Windriver Diab, and GreenHills compiler support by new project wizard (The Green Hills Software (GHS) compiler support depends on the availability of the Eclipse plug-in integrating GHS compiler compatible with the Eclipse Neon. Full support for the Green Hills Software compiler Eclipse Neon-compatible plug-in within S32DS for PA 2.1 was not validated in time for this release.) Lauterbach, iSystem, and PLS debuggers support by new project wizard (The plugins to support Diab, iSystem, Lauterbach, and GreenHills are not included and have to be installed from the corresponding update site or installation.) Kernel Aware debugging for FreeRTOS, eCOS, OSEK Devices supported: S32R274 S32R372 MPC5775B, MPC5775E MPC5775K, MPC5774K MPC5746R, MPC5745R, MPC5743R MPC5777M MPC5777C MPC5748G, MPC5747G, MPC5746G MPC5744B, MPC5745B, MPC5746B, MPC5744C, MPC5745C, MPC5746C MPC5744P, MPC5743P, MPC5742P, MPC5741P MPC5601P, MPC5602P, MPC5603P, MPC5604P MPC5644B, MPC5644C, MPC5645B, MPC5645C, MPC5646B, MPC5646C MPC5601D, MPC5602B, MPC5602C, MPC5602D, MPC5603B, MPC5603C, MPC5604B, MPC5604C, MPC5605B, MPC5606B, MPC5607B MPC5606S MPC5604E MPC5644A, MPC5642A MPC5643L MPC5676R MPC5632M, MPC5633M, MPC5634M MPC5674F MPC5673K, MPC5674K, MPC5675K Collateral Getting Started page The S32DS Extensions and Updates tool Migration guide to help migrate projects from an earlier version to S32 Design Studio for Power Architecture 2. Bug Fixes For detailed list of the GNU Tools bug fixes, refer to the release notes located in S32DS/ build_tools/powerpc-eabivle-4_9/ Fixed the semihosting issues with the EWL and NewLib libraries Fixed the FLASH programming algorithm for MPC5744P Added missing linker script sections for MPC5748G Fixed reading values from the peripheral bridge A registers for MPC5634M Fixed access to the RAM memory for MPC5634M Removed unavailable addresses from the MPC574xB linker files Added the -fstrict-volatile-bitfield compiler option to the project settings Fixed secure connection to MPC5744P Disabled RTTI for EWL library due to incompatibility with the GNU tools Fixed importing/exporting projectinfo.xml with library settings Complete S32 Design Studio for Power Architecture v2.1 release notes are available here Installation Notes To download the installer please visit the S32DS for Power Architecture product page: downloads section. The installer requires the the NEW Activation ID to be entered during the installation. You should receive an email that includes your Activation ID after starting the installer downloading process: Technical Support S32 Design Studio issues are tracked through the S32DS Public NXP Community space: https://community.nxp.com/community/s32/s32ds    

Application based on FreeRTOS S32DS example performs prinf/scanf functionality in FreeRTOS. Application runs in two modes - standard run-time mode with two tasks maintained by scheduler and command mode implementing basic memory monitor. Application was tested with putty terminal (http://www.putty.org/). Putty serial terminal settings: 115200 8N1, no HW control. USAGE: In run-time mode is green LED blinking and on terminal are shown task counter values. To enter into COMMAND MODE - press button (next to LED diode). LED light switches to red and you can enter commands. Available commands: =================== F show free heap memory A set memory address V print value on address M set address to main() P previous mem page N next mem page ? help X Exit from command mode Putty configuration: Terminal output:

S32 Design Studio (S32DS) for ARM supports IAR Plugin, and the user can use IAR specific features in S32DS with IAR toolchain for ARM. This document describes the way to convert S32DS project to IAR EW based project using project exporting wizard in S32DS. This guidance is based on the NXP S32K144 microcontroller, and compatible with S32K14x / S32K11x family.   The version of each IDE which is used for this document is as follows: S32 Design Studio for Arm 2018.R1 IAR Embedded Workbench for ARM 8.32.1.18631     1. Install IAR Plugin using IAR Embedded Workbench plugin manager on S32DS Help - Install New Software   Put "IAR Embedded Workbench for Eclipse " as the repository for new installation of software.     Help - IAR Embedded Workbench Plugin Manager     Install IAR Plugin which is matched with your IAR version.         2. Create S32DS Project File - New - S32DS Application Project   The tool chain should be chosen as IAR Toolchain. Be noted that the IAR 7.x toolchain is different from the IAR 8.x.   The project is created as follows.     3. Export S32DS Application Project File - Export   Choose S32 Design Studio - Project Info Export Wizard   Now "ProjectInfo.xml" was created. "ProjectInfo.xml" should be used for creating a project in the IAR EW.   4. Create IAR EW Project The way to create IAR project as described below. The snapshots are based on IAR EW 8.32.1. Details may vary.   5. Connect the Project Use the menu - Project - Add Project Connection, and choose "Freescale Processor Expert".   Select the "ProjectInfo.xml" file which was created at step #3.    Now, the project which had been created in IAR was connected to the S32DS project.   The created IAR project should be modified if the user wants to use the project with S32DS SDK to build and debug under IAR EW environment as follows.   1. Modify the Linker configuration and remove ProjectInfo.xml Remove "ProjectInfo.xml"   Linker configuration from the project Options   Even though the user modified the linker configuration, a definition in IAR EW  for "device_registers.h" from SDK will cause build error when trying building the project.   This error will be eliminated by inserting Chip specific definition into IAR project. If you take a look into the "device_register.h", you can find the definition as follows.   2. Define symbols  Right mouse click on the Project name - Options   Write the symbols referred from "device_register.h". The symbols may vary (e.g., CPU_S32K146, CPU_S32K142, ...).   3. Build and Debugger configuration Options - Debugger   I used PE micro's OpenSDA on S32K144EVB for this document. After choosing debugger and clicking Download and Debug (Ctrl+D), you can see the P&E Configuration Manager as follows. Just choose appropriate configuration, and select the correct part number of S32K by clicking Select New Device.   Finally, you can download and debug the converted IAR EW project with S32DS SDK.

        Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio 2018.R1         Austin, Texas, USA December 28, 2018   The Automotive Microcontrollers and Processors’ Embedded Tools Team at NXP Semiconductors, is pleased to announce the release of the S32 Design Studio 2018.R1 for S32 Automotive Platform|NXP.  Major features  • NXP GCC toolchains for ARM32 and aarch64 bareboard and Linux targets  (GCC version 6.3.1 20170509, build 1574 revision g924fb68) • S32 Debug Probe support provided with S32 Debugger (support for S32V23x, RAM + FLASH) and S32 Trace tool for S32V23x • S32 Trace tool is integrated to provide software analysis features (profiling, code coverage, and other) • PEMicro® hardware debugger support provided with P&E Debugger • Lauterbach Trace32® support • S32 Flash Tool is delivered to support Flash/SD/MMC memory programming for S32V234 • S32 SDK for S32V23x 0.8.1 EAR is integrated • S32DS Extensions and Updates tool for automatic lookup and on-demand installation of software packages adding support for the NXP Arm® based processor families • S32 Configuration Tool framework (EAR6) with the Pin, Clock, Peripheral configuration tools Complete S32 Design Studio 2018.R1 release notes are available here.   Installation To download the installer please visit the S32 Design Studio product page download section or click the direct here.     The installer requires the Activation ID to be entered. You should receive a notification email including the Activation ID after the download of the installation package starts. The installer installs just the base tools/package. In order to start development it is necessary to install at least one Development package. Currently the only application package available is Vision S32V2xx  (Other packages are coming soon). The application packages are managed by S32DS Extensions and Updates. Technical Support S32 Design Studio issues are tracked through the S32DS Public NXP Community space. https://community.nxp.com/community/s32/s32ds  

There are situations that require debugging multiple executable files within one debug session. Typical example is debugging the bootloader + application together where each one is a separate executable elf file or S32DS eclipse project. S32DS project loads the debug information of the generated executable file by default. Anyway GDB supports command to add additional elf files debug information into same debug session. If the executable source files are present on the same machine then the source level debugging of all the elf files is possible. Let's assume there are two elf files (bootloader and application) and both are built with debug information enabled - build configuration is named "Debug". Generation of the debug information for GCC compiler could be set in the Project Properties -> C/C++ Build -> Settings -> Standard  S32DS C Compiler -> Debug Level  Each debug configuration in S32 Design Studio supports loading or ignoring debug information. "Load symbols" loads just the debug information whereas "Load executable" basically loads program/code/data sections into MCU memory without debug information. Both options are enabled by default. Before starting the debugger it's necessary to load both executable files into your MCU memory. This could be easily achieved in S32DS (GDB) debug configuration where you specify to add the additional object files. In this specific case we need just 1 additional file - bootloader elf. The bootloader project in this example is actually another project in the same workspace (workspace relative path to elf file entered). After starting debugger the Debugger Console view now shows the details about programming of two elf files instead of one including load address of each section. When loading is finished the debug information for bootloader is not yet available ("No source available..." message displayed in the source level debug view) In order to display source and symbols for the bootloader elf please enter "add-symbol-file"  GDB command into Debugger Console View: add-symbol-file "C:/Users/NXA21306/workspaceS32DS.ARM.2018.R1/s32K144_Bootloader/Debug/s32K144_Bootloader.elf" 0x0000000‍‍‍‍‍ The GDB client command could be executed automatically when launching a debug session: The first argument is path to the elf file and the second argument (0x00000000) is the load address of the elf file (see the first bootloader load address ). Finally the debug session needs to be refreshed in order to display changes from just added symbol file. The refresh can be forced by performing a single step or issuing the target reset from the debugger.

The ability to reset target MCU via debugger (also known as "in-target reset") is one of the essential feature when it comes to e.g. debugging of a code that is getting into an Exception/Fault Handler or situations like "...why my code works fine in the debugger, but fails without debug..." S32 Design Studio offers this feature for all Pemicro debug interfaces (Multilink Universal/FX, OpenSDA) and it is available in all S32 Design studio flavors (S32DS ARM, S32DS Power, S32DS Vision) Reset button icon is active only in the active debug session (debug perspective) and in the root debug context only.  By default the reset icon is inactive during project debugging: To activate the reset icon change the Debug view context to the root one. After reset is completed the execution stops at the application reset vector and the information about reset that has just occurred is displayed in GDB server console. It is also possible to execute initialization script (.mac) which is triggered by the reset action. The reset script can be selected in the  Debug Configuration (Debugger Tab -> Advanced Options -> Enable Initialization Script) For more information about initialization scripting capabilities please contact www.pemicro.com

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    

Building Projects There is already a significant amount of information already available on this topic. Please explore the external references listed below for detailed information. External References Building Projects with Eclipse Build Several CDT C++ projects from command line With the following command line, it is possible to build the project KEA128: eclipsec -nosplash -application org.eclipse.cdt.managedbuilder.core.headlessbuild -data C:\Users\username\workspaceS32DS.ARM2.0 -build KEA128/Release   The project was located in workspace - C:\Users\username\workspaceS32DS.ARM2.0 Project Name is: KEA128 Build Configuration is: Release Emitting Source Code S32 Design Studio for Vision Emitting the source code from the command line: There are 2 sections in the Reference Manual, one for each of the ISP and APEX2 Visual Graph Tools. Processor Expert Software - S32 Design Studio There is a section in the Processor Expert User Guide titled 'Command Line Interface'

        Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio for ARM 2018.R1         February 6, 2017 NXP Semiconductors is pleased to announce the release of the S32 Design Studio for ARM 2018.R1 for Automotive and Ultra-Reliable MCUs. The S32 Design Studio is based on the Eclipse open development platform and integrates the Eclipse IDE, GNU Compiler Collection (GCC), GNU Debugger (GDB), and other open-source software to offer designers a straightforward development tool with no code-size limitations. Red highlighted items below are new/updated features in comparison to previous releases/updates. Release content (What is new?) Eclipse Neon 4.6 Framework GNU Tools for ARM® Embedded Processors (Launchpad) build (4.9.3 20150529) ARM64: Linaro GCC 4.9-2015.05 GNU Tools for ARM® Embedded Processors build (6.3.1 20170824) - supported by New Project Wizard for S32K1xx device. See the complete GNU ARM 6.3.1 release notes attached below. GCC Source code package is available here. Libraries included: newlib, newlib-nano and ewl2 (ewl and ewlnano). GDB 7.12.1 with Python P&E Multilink/Cyclone/OpenSDA (with P&E GDB Server) - updated (v3.3.5.201801101746) SEGGER J-Link (with SEGGER GDB Server) - updated (V6.22e_B180108) New Project wizard to create application and library projects for supported devices Fully integrated S32 SDK for S32K14x EAR release v.0.8.6. For the details on the feature set of SDK please refer to SDK Release notes and Reference Manuals. S32 SDK Release notes attached.Please note that S32K SDK has Early Access Release status, that means that there could be some limitations and issues. The S32K SDK is available for Windows host only. There is limitation on the supported GreenHills compiler version – the SDK released with GreenHills v2014.4, but due to GreenHills plugin limitation support for GreenHills compiler v2017.1 integrated, so new project wizard would not provide possibility to create SDK project with GreenHills compiler. SDK management included Sample Drivers for KEA family (Evaluation grade) FreeMASTER Serial Communication driver for KEA and S32K families Automotive Math and Motor Control Libraries for KEA,S32K and S32V234 devices supporting the ARM Cortex-M4 core v1.1.11 (the particular version availability for a device could be limited by supported compiler versions) Import projects from CodeWarrior for MCU v.10.6 and Kinetis Design Studio for respective supported processors IAR v7.x and v8.11.2 compiler support by new project wizard GreenHills v2017.1.4 compiler support by new project wizard iSystem, Lauterbach and IAR debuggers support by new project wizard. Kernel Aware debugging for FreeRTOS, OSEK. MQX 4.2 for MAC57D54H with possibility to create project from example Devices supported SKEAZN8, SKEAZN16, SKEAZN32, SKEAZN64, SKEAZ128, SKEAZ64 S32K144 v2.0, S32K142, S32K146, S32K148 S32V234 MAC57D54 Getting started page to allow the centralized access to documentation and additional materials Bug Fixes Updated header and register description files to fix issues and synchronize with latest Ref Manual versions [S32DS-4629] Clean rule doesn't work after particular user actions in "C/C++ Build -> Behavior" [S32DS-301] After some debugging work (using BP, Stepping, Resume...) Disassembly view content disappears. [S32DS-1093] Debugging session hangs when "c" step over is done on a loop statement that has its entire block in a single line. [S32DS-273] Can not suspend after set condition of breakpoint = 0 and resume [S32DS-61] Breakpoint properties disappeared after right-click into breakpoint [S32DS-6072] Unable to export S32K144 SDK project into ProjectInfo.xml The complete S32 Design Studio for ARM 2018.R1 release notes are attached below. Installation Notes Please visit the S32DS for ARM product page - download section to download the installer. The installer requires the NEW Activation ID to be entered during the installation. You should receive an email that includes your Activation ID after starting the download. Technical Support S32 Design Studio issues are tracked through the S32DS Public NXP Community space: https://community.nxp.com/community/s32/s32ds    

S32 Design Studio (S32DS) supports Lauterbach’s “loos coupling” version of Eclipse plug-in to debug S32DS projects via a Lauterbach probe + TRACE32 standalone application. This configuration uses Eclipse IDE for development and standalone TRACE32 for debugging.    This plug-in supports the features below: Start TRACE32 from an Eclipse launch configuration Support for multiple projects (multi-core) Synchronization of breakpoints between Eclipse and TRACE32 Open source file' functionality from TRACE32 to Eclipse and vice versa See the Lauterbach document for additional information about the plug-in.   Installation instructions First of all make sure you have TRACE32 installed. Now let's proceed to eclipse plug-in installation.   First of all make sure you have TRACE32 installed. Now let's proceed to eclipse plug-in installation.   go to menu "Help" -> "Install New Software"    Click on the arrow to bring up the list.  Select ‘LauterbachGmbHUpdateSite - http://www.lauterbach.com/eclipse‘                 Check the box next to the Lauterbach TRACE32 Eclipse Loose Coupling and click "Next"   Check "I Accept the terms of the license agreement" and Select all Lauterbach certificates to trust. Finally you proceed to the installation. When the plugin is installed you will be asked to restart S32DS   Now you should be able to use the New Project Wizard create an application project with Lauterbach Debugger support:     Or manage (create, delete, adjust) Lauterbach eclipse debug configurations:   Enjoy debugging with TRACE32 Eclipse plug-in in S32DS!  

This document describes a way, how to place custom constant data into specific flash memory area. Create a custom linker section in the linker file (.ld), where custom data should be placed into. Use the KEEP keyword in case you would like to avoid dead stripping if and object is not referenced. add the __attribute__ section statements to the custom data definition. Map file should looks like this way Hope it helps. Martin

The document describes the steps that need to be done in order to place and execute a library function from a custom memory section - typically RAM using GNU Build tools. The instructions are applicable to any GNU tool-chain. It is demonstrated on a New S32DS Project created in S32 Design Studio for ARM. Lets assume that we'd like to execute memcpy() function from the standard library (NewLib). 1) The first step is to exclude specific library object file(s) from the input section (using EXCLUDE_FILE) so they will not be linked into the standard .text* flash section.  The input section associated with EXCLUDE_FILE shall not interfere with the same input section used later in section list (e.g. with *(.text*) input section deleted from the list below). EXCLUDE_FILE in behaves the same was as *.(text*) rule - it only exclude selected file(s) but places all the remaining (non-excluded) input data. /* The program code and other data goes into internal flash */ .text : { . = ALIGN(4); *(.text) /* .text sections (code) */ /* Exclude file(s) from NewLib libc.a from .text.* section */ *(EXCLUDE_FILE (*libc.a:lib_a-memcpy-stub.o) .text*) *(.rodata) /* .rodata sections (constants, strings, etc.) */ *(.rodata*) /* .rodata* sections (constants, strings, etc.) */ *(.glue_7) /* glue arm to thumb code */ *(.glue_7t) /* glue thumb to arm code */ *(.eh_frame) KEEP (*(.init)) KEEP (*(.fini)) . = ALIGN(4); } > m_text‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ 2) Now let's place the memcpy object into a code_ram section which is already defined in the project .ld file. This section is dedicated to a code that shall be executed from RAM (startup routine initializes this section). For more details see HOWTO: Run a routine from RAM in S32 Design Studio  . The following line places the code (.text* section) from the object file (lib_a-memcpy-stub.o) from the standard NewLib (libc.a)  *libc.a:lib_a-memcpy-stub.o (.text*)‍ into .code section: .code : AT(__CODE_ROM) { . = ALIGN(4); __CODE_RAM = .; __code_start__ = .; /* Create a global symbol at code start. */ __code_ram_start__ = .; *(.code_ram) /* Custom section for storing code in RAM */ *libc.a:lib_a-memcpy-stub.o (.text*) /* add memcpy from the NewLib library here*/ . = ALIGN(4); __code_end__ = .; /* Define a global symbol at code end. */ __code_ram_end__ = .; } > m_data‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ After building the project you can check the map file to confirm memcpy is indeed placed into .code section in RAM memory: .code 0x1fff881c 0x18 load address 0x00000d90 0x1fff881c . = ALIGN (0x4) 0x1fff881c __CODE_RAM = . 0x1fff881c __code_start__ = . 0x1fff881c __code_ram_start__ = . *(.code_ram) *libc.a:lib_a-memcpy-stub.o(.text*) .text.memcpy 0x1fff881c 0x16 C:/NXP/S32DS_ARM_v2018.R1/Cross_Tools/gcc-6.3-arm32-eabi/arm-none-eabi/newlib/lib/thumb/v7e-m\libc.a(lib_a-memcpy-stub.o) 0x1fff881c memcpy 0x1fff8834 . = ALIGN (0x4) *fill* 0x1fff8832 0x2 0x1fff8834 __code_end__ = . 0x1fff8834 __code_ram_end__ = . 0x00000da8 __CODE_END = (__CODE_ROM + (__code_end__ - __code_start__)) 0x00000da8 __CUSTOM_ROM = __CODE_END‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ Note If you are placing a function into RAM always consider to add sub-functions called by that function (typically located in a different object file).

On reset, all module registers have default values. These settings are typically not ideal for achieving optimal system performance. Also, some peripherals must be configured before they can be used. DCD is the configuration information contained in the DCD image that BootROM uses to configure peripherals on the device. BootROM determines the location of the DCD table from the associated pointer in the IVT.   The main functionality of the DCD Tool is to generate the Device Configuration Data (DCD) image using the format and constraints as specified in the Boot ROM reference manual.   In the steps below, an example process for creating the DCD binary for initializing SRAM is shown. To initialize the SRAM, a logic '1' must be written to the INITREQ bit within the PRAMCR register of the SRAMC and SRAMC_1 peripherals.   Procedure With a project open in project explorer (C/C++ perspective), switch to DCD perspective. Click on the arrow next to the 'Open S32 Configuration' button and select 'Open DCD'. Check that correct project is selected  In DCD Commands panel, select Command Type 'Write', then click 'Set' Click 'Add Register', then set the following settings. Can start typing the names to filter the list for faster setting selection.   For Peripheral setting, select 'SRAMC'. You can search for it by typing the name. Register setting, select 'PRAMCR'. The list is short, so it is not necessary to type the name. In Bitfields, select 'INITREQ' Now click on the highlighted bit to set it. Again using 'New Command' box, repeat settings of steps 3 & 4, however, this time select Peripheral 'SRAMC_1'. If everything was done correctly, in the DCD Binary panel to the right, should appear as shown. If so, click 'Export'. The generated DCD file will be displayed. By default, C format is selected. Select Binary format and click OK. Select a location to save the file (such as the project folder in the workspace directory) and give it a meaningful name. Click Save. You are done! DCD image file is created in binary format and ready to be imported to IVT Tool.  

**************************************************************************************** IDE: S32 Design Studio for ARM Version 2.2 Workspace: C:\Projects\S32DS_ARM_22 Project name: S32K142_08_CommandLine Project location: C:\Projects\S32DS_ARM_22\S32K142_08_CommandLine **************************************************************************************** 1. After you finish the edit on your codes, please close S32DS 2. Input the command(as below) at your command_line.bat  3. Run command prompt with Administrator right. 4. Run command_line.bat at command prompt   You will get the *.elf under the folder of C:\Projects\S32DS_ARM_22\S32K142_08_CommandLine\Debug_FLASH   Cheers! Oliver

This short video discuss the main features introduced with the S32 Design Studio 3.6.0 A comparison between S32DS 3.5 and 3.6 in regards to the product architecture & release changes is shown, followed by a quick overview of the main features introduced that impact everyone using the new version of the toolset

      ​S32 Design Studio Version 3.6.0   1. IDE New Features The S32Design Studio 3.6 is delivered with all public NPI's in a single 2.5GB installer to improve first time user experience. Additional packages for alpha customers are available based on Flexera entitlement and can be installed on top of S32Design Studio 3.6.0 using Extension and Updates mechanism as depicted below. New S32Design Studio Installer is faster and lighter (compared to S32Design Studio 3.5) Official support for Window 11 OS and Ubuntu 20.04. Windows 10 OS is tested for compatibility. New Eclipse 2023.12, CDT11.4 and Java 17  Development, Add-Ons and Extension Packages delivered with older S32Design Studio 3.5.x are compatible with version 3.6.0 RTD and Runtime Software releases made on top of S32Design Studio 3.5.x are backward compatible with S32Design Studio 3.6.0 using smart compatibility mechanism New GDB 15.1 for ARM cores New Python 3.10 for ARM cores Improved Extension and Updates mechanism to warn the user when S32Design Studio processes are in use and the installation can not be completed Improved Watch Registers view to expand all registers and export bitfields Improved Dashboard view to include more options for quick access Improvements on UI, update of C/C++ and Debug perspective Improve CLI support to facilitate New Project Creation from command line. For more details please see HOWTO_S32_Design_Studio_Command_Line_Interface.pdf Enable CCS remote for all NPIs 2. S32Debugger New Features New S32Debug Probe OS version 1.1.0 update for resolving WiFi disconnect issue when the probe is connected via USB. Follow the HOWTO_Update_the_S32Debug_Probe_OS.pdf to update the probe firmware to the new version: Expose current exception level in Debug View for ArmV8 cores: New GDB version GDB 15.1 integrated for Arm cores with Python3 interpreter S32K3xx/S32M2xx/S32K14x: S32K14x flash programmer support Enhanced flash programmer to support also programming the Data Flash   3. S32Configuration Tools 1.8.0 New Features Alignment to S32Design Studio: Java 17, Windows 11, Eclipse 2023.12 3.1 DDR features: Intermediate progress report of memory test execution Import log options Access to LPDDR5 DRAM beyond 32bit address space Quickboot, retention support and multicore test execution for LPDDR5    3.2 Scenario Tools features: UI/UX updates for all Boot tools (IVT, DCD, QSPI), allowing quicker access to main tools functions via the built-in toolbar   3.2 GTM Tool features: External Clock for CMU Extended configuration modes and new predefined use-cases for TIM Dynamic channel management for TOM, ATOM, TIM and TBU modules Export HTML report   4. Major features for S32Trace 3.6.0 Added support for all S32G3 Family parts and application cores Added support for Cortex-M7 cores for all S32G2 Family parts   5. Major features for MCU - S32K1, S32K3, S32K37/39 and S32M2 Families: S32Debugger support of S32K14x for FLASH and RAM configuration   S32Debugger support of S32K3xx for FLASH and RAM configuration with multicore support   Now, S32K37/39 Family is part of S32K3 Family distribution S32Debugger support of S32M2xx for FLASH and RAM configuration   Update of 3rd Party Debuggers support: Segger J-Link 8.10c PEmicro v5.9.2 TASKING v9.21.273   6. This release is available: S32Design Studio 3.6.0 can be found on nxp.com and on Flexera   7. The installation instructions: 1. Navigate to S32Design Studio page on nxp.com and click Download 2. Login(if not) and Accept License Agreement. 3. Navigate to License Key tab and copy Activation Code 4. Launch S32Design Studio installer and when asked for Activation code, please provide the one from above step.   ​   ​ `

Use the New Project Wizard in S32 Design Studio to create a bare board project. The process is very straightforward, but there are some choices to be made. Which processor, toolchain, SDKs, and debugger you want supported, are the most important. However, you also have options to select on how many cores should be enabled, which C library to use,  I/O Support, FPU Support, C/C++ language. All of these are explained within the user manual, but the default settings should work for most users. In this document, we walk you through the process from start to finish.   1. Launch S32 Design Studio 2. Select File->New->S32DS Application Project or use quick button S32DS Application Project from Dashboard view 3. Enter a project name. 4. Expand the folder family and select the desired core. For example 'S32Z270 (Boot core:M33)' 5. Click Next 6. Notice there are options for I/O Support, FPU Support, Language, SDKs, and Debugger. Notice different options are supported for Debugger, depending upon the selected Processor. Also, some families have multicore projects. If you want to use single core, leave only the first Boot core checked. 7. Click Finish. The new project is generated. It contains a sample bareboard application. It is possible to build and debug this project without any changes. Add your content to this base project.  

  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"