S32 Design Studio Knowledge Base

cancel
Showing results for 
Search instead for 
Did you mean: 

S32 Design Studio Knowledge Base

Discussions

**************************************************************************************** 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
View full article
A typical debug session will begin by downloading code to Flash and then debugging from main() onwards. However, to explore an already running system a debug connection (attach) can be made to the target MCU without affecting the code execution (at least until the user chooses to halt the MCU!).   Note: Source level debug of a running target is only possible if the sources of the project to be attached exactly match the binary code running on the target.   Click the (Debug As) button on the toolbar, then click Debug Configurations from the drop-down menu. In the left pane of the Debug Configurations dialog box, expand the debugging interface specified in the project settings and click the required launch configuration. After you click the configuration in the left pane, the configuration settings appear in the right pane grouped in tabs. PEmicro Select the Startup tab, then set the ‘Attach to Running Target’ check box as below: When a debug connection is made, the target will continue running until it is paused.   SEGGER J-Link Select the Debugger tab, then set the ‘Connect to running target’ check box as below: Unfortunately, this feature currently not supported.
View full article
Watchpoints are Breakpoints for Data and are often referred to as Data Breakpoints. Watchpoints are a powerful aid to debugging and work by allowing the monitoring of global variables, peripheral accesses, stack depth etc. The number of watchpoints that can be set varies with the MCU family and implementation. Watchpoints are implemented using watchpoints units which are data comparators within the debug architecture of an MCU/CPU and sit close to the processor core. When configured they will monitor the processor’s address lines and other signals for the specific event of interest. This hardware is able to monitor data accesses performed by the CPU and force it to halt when a particular data event has occurred. The method for setting Watchpoints is rather more hidden within the IDE than some other debugging features. One of the easiest ways to set a Watchpoint is to use the Outline View. From this view you can locate global and static variables then simply select Toggle Watchpoints.     Once set, they will appear within the Breakpoints pane alongside any breakpoints that have been set.     Watchpoints can be configured to halt the CPU on a Read (or Load), Write (or Store), or both. Since watchpoints ‘watch’ accesses to memory, they are suitable for tracking accesses to global or static variables, and any data accesses to memory including those to memory mapped peripherals.   Note : To easily distinguish between Breakpoints and Watchpoints within the Breakpoint view, you can choose to group entries by Breakpoint type. From within the Breakpoints view, click the Eclipse Down Arrow Icon Menu, then you can select to Group By Breakpoint Types as shown below:   As you can see from the above graphic, the option to set a Watchpoint is also available directly from the Breakpoint view.   When set from here, you will be offered an unpopulated dialogue – simply entering an address will cause a watchpoint to be created, monitoring accesses to that location.     Another place to set Watchpoints within the IDE is from the context sensitive menu within a Memory view.   Unfortunately, the conditional watchpoints in S32 Design Studio for S32 Platform 3.3 may not work in some cases.
View full article
      Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio for Power Architecture v2.1   Update 13           What is new? Integrated Radar SDK RTM 1.5.0 (replacing 1.4.0) This is a cumulative update - it includes all the content of previous updates (Update 1,Update 2, Update 7, Update 8, Update 10, Update 12)   Installation instructions The update is available f or 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 a dd 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.
View full article
        Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio v3.3 Vision Extension Package for S32V234 1.2.0           What is new? Integrated VSDK 1.6.0   Installation instructions The update is available f or 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 S32 Platform 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 a dd 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.
View full article
UART communication is supported in the KEA64 Bootloader .rbf file  + Supported UART0: PTA2-PTA3 pins(Speed: 115200b/s) Tested on the dev board:   Development Board TRK-KEA64 Processor PKEAZN64 MLH 2N22J
View full article
KEA64 RAppID Bootloader rbf file for KEA64    MPC57xx RAppID Bootloader rbf file for MPC5744P   https://community.nxp.com/docs/DOC-344948  RAppID Bootloader rbf file for MPC5777C  RAppID Bootloader rbf file for MPC5777C - BookE (non-VLE) 
View full article
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.
View full article
S32 Design Studio (S32DS) supports Wind River Eclipse plug-in which integrates Wind River Diab tool chain for e200 (PowerPC architecture) into Eclipse IDE. S32DS integration by a new project wizard that allows to create a new project with Wind River Diab build tools. The generated executable can be then debugged by any supported debugger plug-in (PEMicro, iSystem, PLS, Lauterbach) S32 Design Studio versions that support Wind River Diab plugin: S32DS Power v1.1+   Installation instructions First of all make sure you have Wind River Diab tools installed on your machine.  You can start with Wind River Diab Compiler 5.9.6 Evaluation  Anyway, after your evaluation period expires you need a valid license from Wind River to be able to use this plug-in in S32DS. The plug-in is available with the Diab compiler and it's located here: "<WindRiver home folder>\compilers\eclipse_cdt"   1.  Run S32 Design Studio and  go to menu "Help" -> "Install New Software" and  click on "Add..." button. Enter the local location to the folder above. 2.   select the "Diab Compiler Support for Eclipse C/C++ IDE " and click "Next"   3.  Read and  Tick " I Accept the terms of the license agreement"  and agree with installation of the unsigned content. 4. When the plug-in is successfully installed you will be asked to restart S32DS.     5. Set the path to the Diab compiler for your workspace (S32DS_DIAB_PATH environment variable) in the Window->Preferences->C/C++->Build->Build Variables (Show System Variables). If you switch the workspace you will need to enter this path again. Now you should be able to create a new project with Wind River Diab toolchain available: The created project includes Diab specific files such as "dld", startup code as well as tools specific setup in the project properties (Project  Properties->C/C++ Build->Settings (Tools Settings Tab)    Enjoy building with Wind River Diab plug-in in S32DS!
View full article
Problem description When installing S32 Design Studio using the offline activation method (Offline activation on S32 ) the installer may pop up an error dialog: " Error: "Invalid offline response, ResponseType"." This typically occurs on the computers that have no previous installation of S32 Design Studio.   Affected versions S32DS for ARM v1.1, v1.2, v1.3 S32DS for Power v1.1 S32DS for Vision v1.0 Newer versions should include the fix already. Solution Option A) Easiest solution is to use online method instead of offline. But in some cases it may not be possible (LAN restrictions, computer is not connected to the Internet or there is some other network obstacle etc.) Option B) Apply the hot fix attached. See the instructions below how to proceed for Windows and Linux (Ubuntu) users   Windows users Download and extract the attached archive file "licfix.zip" to your local machine (same package for Windows and Linux) Run "clean.bat" to reset trusted storage  Run "setts.bat" to run the activation fix and enter your activation ID for the product you need to activate Select offline activation type and save generated "request.xml" file Submit generated "request.xml" to your nxp.com account offline activation section and generate activation response "activation.xml" Save the created activation response, refresh the Activation response dialog and select the saved file The script is then successfully terminated and now you should be able to install S32 Design Studio Linux (Ubuntu) users Download and extract the attached archive file "licfix.zip" to your local machine (same package for Windows and Linux) Add the executable right to configure.sh script chmod 777 configure.sh Run the script as admin with parameter "install" to install appropriate libraries sudo ./configure.sh install Run the script as admin with parameter "reset" to reset trusted storage into its initial state  sudo ./configure.sh reset Run the script as admin with parameter "activate" to proceed to activation process sudo ./configure.sh activate Enter your activation ID for the product you need to activate Select offline activation type and save generated "request.xml" file Submit generated "request.xml" to your nxp.com account offline activation section and generate activation response "activation.xml" After this step the script should be terminated without any error message.   Now you should be able to install S32 Design Studio on your computer. Special thanks to Denis Robert and zhongzheng liu for your help with fix testing and to all of you who reported this nasty issue. Thank you!!! Stan
View full article
Bare-metal project migration from an older version of S32DS into a newer one is typically pretty straightforward. Despite of that the migration into S32DS Power v1.2+ requires more attention due the fact it includes a new version of GCC compiler  + GCC binutils (see the GCC release notes - here).  This version of GCC is now fully EABI VLE compliant  (in contrast to previous versions of S32DS Power  v1.0 and v1.1) and it has  several consequences for the project migration object code/libraries are not backward compatible - if  you have an object code/library built by a previous version of S32DS Power v1.x you have to rebuild it in new S32DS v1.2+ compiler. default compiler setup has changed - bitfield access is not volatile anymore. This may have a impact on a peripheral registers access via standard header file bitfield structures. Such access may require a specific load/store instruction e.g. "stw" but if compiler is allowed to optimize the access (e.g. use "stb" instead of "stw") an exception may occur. Therefore it is recommended to add  -fstrict-volatile-bitfields  flag into your project GCC compiler settings: linker script file (*.ld) requires some additional linker sections - Linker script file in S32DS Power v1.2+ must contain the sections below: •  KEEP for .init and .fini sections • .ctors and .dtors sections • .preinit array .init array and .fini array sections If the linker script file is not updated and the linker warnings are ignored you may experience an exception at the runtime - typically when __init routine is executed. Missing .init section causes that an invalid instructions is fetched and causes the core IVOR exception. There is an easy way how to automatically fix the linker script file issue directly in IDE. If you import and build an older project in S32DS Power v1.2 the linker issues these linker script related warnings: Right click on the warning and select Quick Fix: Select "Add missed section in linker script"  + "Select All" and press "Finish". Repeat these steps until all the linker script warnings disappears. If you don't use IDE project you have to add the sections below into your linker script manually: . text_vle : { INPUT_SECTION_FLAGS ( SHF_PPC_VLE ) * ( . text . startup ) * ( . text ) * ( . text . * ) KEEP ( * ( . init ) ) KEEP ( * ( . fini ) ) . = ALIGN ( 16 ) ; } > m_text /* that will force pick VLE .text sections */ . ctors : { __CTOR_LIST__ = . ; /* gcc uses crtbegin.o to find the start of the constructors, so we make sure it is first. Because this is a wildcard, it doesn't matter if the user does not actually link against crtbegin.o; the linker won't look for a file to match a wildcard. The wildcard also means that it doesn't matter which directory crtbegin.o is in. */ KEEP ( * crtbegin . o ( . ctors ) ) KEEP ( * crtbegin ? . o ( . ctors ) ) /* We don't want to include the .ctor section from from the crtend.o file until after the sorted ctors. The .ctor section from the crtend file contains the end of ctors marker and it must be last */ KEEP ( * ( EXCLUDE_FILE ( * crtend ? . o * crtend . o ) . ctors ) ) KEEP ( * ( SORT ( . ctors . * ) ) ) KEEP ( * ( . ctors ) ) __CTOR_END__ = . ; } > m_text . dtors : { __DTOR_LIST__ = . ; KEEP ( * crtbegin . o ( . dtors ) ) KEEP ( * crtbegin ? . o ( . dtors ) ) KEEP ( * ( EXCLUDE_FILE ( * crtend ? . o * crtend . o ) . dtors ) ) KEEP ( * ( SORT ( . dtors . * ) ) ) KEEP ( * ( . dtors ) ) __DTOR_END__ = . ; } > m_text . preinit_array : { PROVIDE_HIDDEN ( __preinit_array_start = . ) ; KEEP ( * ( . preinit_array * ) ) PROVIDE_HIDDEN ( __preinit_array_end = . ) ; } > m_text . init_array : { PROVIDE_HIDDEN ( __init_array_start = . ) ; KEEP ( * ( SORT ( . init_array . * ) ) ) KEEP ( * ( . init_array * ) ) PROVIDE_HIDDEN ( __init_array_end = . ) ; } > m_text . fini_array : { PROVIDE_HIDDEN ( __fini_array_start = . ) ; KEEP ( * ( SORT ( . fini_array . * ) ) ) KEEP ( * ( . fini_array * ) ) PROVIDE_HIDDEN ( __fini_array_end = . ) ; } > m_text‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ This may help you to avoid time consuming debugging to figure out the root cause of the core exception. 
View full article
This document describes a way how to execute a selected function(s) out of RAM memory for a project running out of  Flash memory. Create a custom linker section in the linker file (.ld) where a routine(s) should be placed into. This step is optional if you don't care where exactly in RAM the function should be placed. In such case default sections could be used instead. MEMORY {       flash_rchw : org = 0x00FA0000,   len = 0x4     cpu0_reset_vec : org = 0x00FA0000+0x10,   len = 0x4     cpu1_reset_vec : org = 0x00FA0000+0x14,   len = 0x4     cpu2_reset_vec : org = 0x00FA0000+0x04,   len = 0x4                  m_my_flash :     org = 0x01000000, len = 4K       // optional - this is dedicated section for the RAM function rom image     m_text :         org = 0x01001000, len = 5628K    // default section for code       m_my_ram :       org = 0x40000000, len = 4K       // optional - specific section where a RAM routine(s) should be copied into     m_data :         org = 0x40001000,  len = 764K    // default section for data/stack/heap }‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ If it's intended to keep routine(s) that should be executed from RAM within a specific custom section: SECTIONS { ... .MyRamCode : {    MY_RAM_START = .;       // this symbol is optional    KEEP (*(.MyRamCode))    // KEEP - avoid dead stripping if an object is not referenced    MY_RAM_END = .;         // this symbol is optional } > m_my_ram AT>m_my_flash // the section above is linked into m_my_ram and Rom image is stored into m_my_flash‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ Otherwise you can use the default memory areas for code/data if you don't care about the location of the routine(s): SECTIONS { ... .MyRamCode  : {     MY_RAM_START = .;     // this symbol are optional     KEEP (*(.MyRamCode))  // KEEP - avoid dead stripping if an object is not referenced     MY_RAM_END = .;       // this symbol are optional }  > m_data  AT>m_text    // the section is linked into default data memory area and its rom image is placed into the default code memory ‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ add the __attribute__ statements to the RAM function prototypes. The function attribute "longcall" is required to be able to call this RAM function from flash. __attribute__ ((section(".MyRamCode")))              // place the function below into .MyRamCode section int test_RAM(int arg1) __attribute__ ((longcall));   // declare the function as "far"‍‍ ‍ ‍ Default S32DS project startup initializes just the default data sections. Therefore it's necessary to perform section copy-down manually if the functions are placed into a custom section. This must be done before a RAM routine gets called e.g. at the beginning of main() or in the startup routine.       You can create some linker symbols (.MyRamCode RAM and ROM addresses and size) and import them to the module where copy-down is implemented. __MY_RAM_ADR = ADDR (.MyRamCode); __MY_RAM_SIZE = SIZEOF (.MyRamCode); __MY_RAM_ROM_ADR = LOADADDR (.MyRamCode);‍‍‍ ‍ ‍ ‍ The final source file may look like this: #include <string.h> extern unsigned long __MY_RAM_ADR; extern unsigned long __MY_RAM_ROM_ADR; extern unsigned long __MY_RAM_SIZE; __attribute__ ((section(".MyRamCode")))              // place the function below into .MyRamCode section int test_RAM(int arg1) __attribute__ ((longcall));   // declare the function as "far" ... void main(void) {    int counter = 0;    memcpy(&__MY_RAM_ADR , &__MY_RAM_ROM_ADR, &__MY_RAM_SIZE);  // copy the function from flash to RAM    counter = test_RAM(counter);                                // call the function ... }‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ Hope it helps! Stan
View full article
This document describes how to link a binary file(s) with an existing project in S32 Design Studio using GCC build tools. Let's demonstrate this on S32K144 project in S32DS for ARM. Nevertheless it should work with any other GCC based development tools. The first step is to add the binary file(s) into your project folder in the workspace. In the example below I created two binary files "my_bin.bin" and "my_bin2.bin" and added them into a custom folder "bin_files". I also entered 10 characters into each file. my_bin.bin: 0x41 0x41  0x41 0x41 0x41 0x41 0x41 0x41 0x41 0x41  (represents 10 characters "A") my_bin2.bin: 0x42 0x42  0x42 0x42 0x42 0x42 0x42  0x42 0x42 0x42  (represents 10 characters "B") The next step is to modify the linker configuration file (.ld) in order to specify input file format and path to the binary files (see the line 14-17) /* Specify the memory areas */ MEMORY { /* Flash */ m_interrupts ( RX ) : ORIGIN = 0x00000000 , LENGTH = 0x00000400 m_flash_config ( RX ) : ORIGIN = 0x00000400 , LENGTH = 0x00000010 m_text ( RX ) : ORIGIN = 0x00000410 , LENGTH = 0x0007FBF0 /* SRAM_L */ m_data ( RW ) : ORIGIN = 0x1FFF8000 , LENGTH = 0x00008000 /* SRAM_U */ m_data_2 ( RW ) : ORIGIN = 0x20000000 , LENGTH = 0x00007000 } TARGET ( binary ) /* specify the file format of binary file */ INPUT ( . . \bin_files\my_bin . bin ) /* first bin file path (relative to the output folder)*/ INPUT ( . . \bin_files\my_bin2 . bin ) /* second bin file path (relative to the output folder)*/ OUTPUT_FORMAT ( default ) /* restore the out file format */ /* Define output sections */ SECTIONS { . . . ‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ Finally, i n the SECTIONS block of .ld file specify where to place the binary files (in the example it is placed at the end of .text section - see the line 37,38). /* Define output sections */ SECTIONS { /* The startup code goes first into internal flash */ . interrupts : { __VECTOR_TABLE = . ; __interrupts_start__ = . ; . = ALIGN ( 4 ) ; KEEP ( * ( . isr_vector ) ) /* Startup code */ __interrupts_end__ = . ; . = ALIGN ( 4 ) ; } > m_interrupts . flash_config : { . = ALIGN ( 4 ) ; KEEP ( * ( . FlashConfig ) ) /* Flash Configuration Field (FCF) */ . = ALIGN ( 4 ) ; } > m_flash_config /* The program code and other data goes into internal flash */ . text : { . = ALIGN ( 4 ) ; * ( . text ) /* .text sections (code) */ * ( . text * ) /* .text* sections (code) */ * ( . 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 ) ; . . \bin_files\my_bin . bin /* First binary file */ . . \bin_files\my_bin2 . bin /* Second binary file */ } > m_text ‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ After successful compilation and link let's check map and s-record file (HOWTO: Generate S-Record/Intel HEX/Binary file ) to confirm the binary files have been linked correctly: .glue_7t 0x0000080c 0x0 linker stubs *(.eh_frame) *(.init) *(.fini) 0x0000080c . = ALIGN (0x4) ..\bin_files\my_bin.bin() .data 0x0000080c 0xa ..\bin_files\my_bin.bin 0x0000080c _binary____bin_files_my_bin_bin_start 0x00000816 _binary____bin_files_my_bin_bin_end ..\bin_files\my_bin2.bin() .data 0x00000816 0xa ..\bin_files\my_bin2.bin 0x00000816 _binary____bin_files_my_bin2_bin_start 0x00000820 _binary____bin_files_my_bin2_bin_end .vfp11_veneer 0x00000820 0x0 .vfp11_veneer 0x00000820 0x0 linker stubs‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ If you need a reference to the binary file block start/end address in your code you can use the linker symbols generated automatically or you can define your own symbols in the linker script. /* declare symbols from linker script file */ extern unsigned int _binary____bin_files_my_bin_bin_start ; extern unsigned int _binary____bin_files_my_bin_bin_end ; int main ( void ) { #define COUNTER_LIMIT 100 unsigned int counter = 0 ; unsigned int * bin_start_ptr ; unsigned int * bin_end_ptr ; bin_start_ptr = & _binary____bin_files_my_bin_bin_start ; bin_end_ptr = & _binary____bin_files_my_bin_bin_end ; for ( ; ; ) { counter ++ ; counter = * ( bin_start_ptr ) ; /*loads 0x4141_4141 into counter*/ if ( counter > COUNTER_LIMIT ) { counter = 0 ; } } return 0 ; } ‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ Note: if it is intended to place the binary file at specific absolute address (e.g. if binary file that represent bootloader) you have to create a separate custom MEMORY and SECTION block in .ld file. /* Specify the memory areas */ MEMORY { /* Flash */ m_bootloader ( RX ) : ORIGIN = 0x001000 , LENGTH = 0x00010000 /* section for bootloadeer*/ m_text ( RX ) : ORIGIN = 0x00011000 , LENGTH = 0x0040000 /*section for application code*/ . . . } TARGET ( binary ) /* specify the file format of binary file */ INPUT ( . . \bin_files\my_booloader . bin ) /* bootloader bin file path (relative to the output folder)*/ OUTPUT_FORMAT ( default ) /* restore the out file format */ /* Define output sections */ SECTIONS { /* place the bootloader binary into 0x0..0x10000 */ . bootloader : { . . \binary_files\my_bootloader . bin /* place the binary file here */ } > m_bootloader . . . ‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ Enjoy linking binaries in S32 Design Studio!
View full article
This document describes two ways how to add a static library file (*.a) into your S32 Design Studio GCC project. These methods differs from each other in sense how a library update is reflected into project build process. Adding a static library WITHOUT dependency to executable (elf) file This approach assumes a library does not change. An update of the library does not trigger project rebuild process. If the library changes the project needs to be manually cleaned (assuming no other source file has changed) and next build links the updated library. The path to the library and the library name shall be entered into Project Properties -> C/C++ Build -> Settings -> Standard S32DS C Linker -> Libraries Please note that GCC adds prefix "lib" and the extension ".a"  to the library name entered into the above dialog by default. GCC linker will search for the library file named: "libtestlib.a" in the folder "c:\my_libs" In the example above. In case a library cannot be found the linker error occurs e.g. one depicted below. The linker library file name option "-ltestlib.a" is expanded into file name "libtestlib.a.a" which does not exist. 10:28:53 **** Incremental Build of configuration Debug for project S32K144_Project_with_library **** make -j8 all Building target: S32K144_Project_with_library.elf Executing target #5 S32K144_Project_with_library.elf Invoking: Standard S32DS C Linker arm-none-eabi-gcc -o "S32K144_Project_with_library.elf" "@S32K144_Project_with_library.args" c:/nxp/s32ds_arm_v2.0/cross_tools/gcc-arm-none-eabi-4_9/bin/../lib/gcc/arm-none-eabi/4.9.3/../../../../arm-none-eabi/bin/ld.exe: cannot find -ltestlib.a collect2.exe: error: ld returned 1 exit status make: *** [makefile:49: S32K144_Project_with_library.elf] Error 1 10:28:54 Build Finished (took 1s.332ms)‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ For a custom library name add colon character ":" at the beginning of the library name to disable the default prefix/extension expansion. GCC linker now searches for file name "testlib.lib" in the example below:   Adding a static library  WITH dependency to executable (elf) file If a static library has changed - "touched"  it is sometimes desired to trigger project rebuild. In this scenario the library shall be added into a different project dialog: P roject Properties -> C/C++ Build -> Settings -> Standard S32DS C Linker -> Miscellaneous -> Other objects The items from "Other objects" list is propagated into USER_OBJS makefile variable which is prerequisite for auto-generated makefile rule that build the target (elf): Enjoy linking static libraries in S32DS!
View full article
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).
View full article
This document describes how to generate an executable file that includes data flash content and how to program it into DFLASH using PEMicro GDB debugger. The default project generated by the project wizard builds an executable with code flash sections only.  Note: It is demonstrated on MPC5744P project but with some small adjustments it's applicable to any other MPC56xx/57xx derivative supported by S32 Design Studio for Power. Let's first explain how to build an executable that contains DFLASH section:  Check the memory map of the target device in the reference manual to figure out where DFLASH is mapped into.  Add DFLASH memory segment/section into the linker file  (MPC57xx_flash.ld).   MEMORY {     flash_rchw : org = 0x00FA0000,   len = 0x4     cpu0_reset_vec : org = 0x00FA0004,   len = 0x4             m_text :        org = 0x1000000, len = 2048K        m_data :        org = 0x40000000,   len = 384K        int_dram  : org = 0x50800000,   len = 64K                m_dflash :  org = 0x800000, len = 96K    /* data flash memory segment */ }  SECTIONS {   …   .dflash : { KEEP (*(.dflash)) } > m_dflash  /* place .dflash section into dflsah memory*/   … }‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ ‍ Select the data you want to place into the DFLASH section in the source code and associate it with the memory section you created in previous step (".dflash"). __attribute__((section(".dflash"))) const unsigned int dflash_int = 0xFEEDCAFE; __attribute__((section(".dflash"))) const char dflash_char[]= "Hello World form DFLASH!";‍‍‍‍‍‍ ‍ ‍ Build the project and check the generated .map file.  The custom".dflash" section should contain the selected data objects. .dflash         0x00800000       0x1d  *(.dflash)  .dflash        0x00800000       0x1d ./src/main.o                 0x00800000                dflash_int                 0x00800004                dflash_char‍‍‍‍‍‍‍‍‍‍ ‍ ‍ ‍ ‍ ‍ Let's now adjust the project debug configuration to be able to program DFLASH.  First  make sure you installed the latest version of PEMicro Eclipse Plugin. See the post below - it's about ARM version of S32DS but the update process for S32DS for Power is exactly the same. You just need is to select e200 component instead of ARM: error while dubbing: "ERROR loading to the device"  If you need to control DFLASH programming separately from code flash you would need a separate debug configuration for DFLASH. You can use "Duplicate" feature on an existing Debug configuration. This creates a new configuration with pre-populated fields so you don't have to enter them all manually. Change the debug configuration name and press "Apply" Switch to the Debugger tab -> Advanced Options and tick "Use Alternative Algorithm" option. Open Browse dialog and go to the folder below where all flash programming algorithms are located (*.pcp) and  select the appropriate DFLASH programming algorithm e.g. for this example: freescale_mpc5744p_1x32x20k_dflash_cut2.pcp          "<S32_Power_v1.x>\eclipse\plugins\com.pemicro.debug.gdbjtag.ppc_1.5.6.201703011834\win32\gdi\P&E"   Note: Folder name "com.pemicro.debug.gdbjtag.ppc_1.5.6.201703011834" may differ depending on the latest version of Pemicro GDB plugin version installed on your machine. It's recommended to enter the latest version folder if there are multiple plugin versions available.   If you want to program DFLASH and code flash at once you can just adjust the existing debug configuration. In this case you should select combined cflash+dflash flash algorithm such as e.g.  freescale_mpc5744p_ cflash_dflash _cut2.pcp  Click on debug button and as soon as the debug session is established check the DFLASH memory space in the Memory View
View full article
      Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio for Power Architecture v2.1   Update 12           What is new? Integrated S32 SDK for Power Architecture RTM 3.0.3 (replacing 3.0.2) Integrated AMMCLIB 1.1.21 This is a cumulative update - it includes all the content of previous updates (Update 1,Update 2, Update 7, Update 8, Update 10)   Installation instructions The update is available f or 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 a dd 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.
View full article
      Product Release Announcement Automotive Microcontrollers and Processors S32 Design Studio 3.3   S32K1xx dev package and S32 SDK for S32K1xx RTM 4.0.0           What is new? S32K1xx Development Package: New Project Wizard support for S32K1xx family, including S32K14xW P&E debugger support for S32K1 family NXP GCC for ARM NXP GCC for Arm version 6.3 build 2017 (same as was used in S32DS for ARM 2.2) S32 SDK for S32K1xx RTM 4.0.0: S32 SDK RTM 4.0.0 package adding support for S32K1xx and S32K1xxW families,  cumulative release containing also the changes present in S32 SDK for S32K1xx RTM 3.0.0, 3.0.1, 3.0.2 and 3.0.3 Supports S32 Design Studio for S32 Platform v3.3 with S32 Configuration tools - Pin Wizard, Clock Configuration,... Supports creating project with NXP GCC for Arm Release version 6.3.1, GreenHills Multi and IAR Compiler Examples for supported devices with P&E Debugger and Segger J-link support Migration support for projects created in S32DS for ARM v2.2 (with Processor Expert) For more details, please review the S32SDK_for_S32K1xx_RTM_4.0.0_ReleaseNotes.pdf attached to this notice. See below. Installation instructions The update is available f or  online   (via Eclipse Updater) or   offline  installation   online  installation:  go to menu  "Help" -> " S32DS Extensions and Updates " dialog   select from available items and click "Install/Update" button   offline   installation:    go to S32 Design Studio v3.3 product download page: S32 Design Studio for S32 Platform -> Downloads, click 'Download' button next to S32DS for S32 Platform v3.3, then select 'S32DS.S32K1.3.3.0_D2006.zip'   to download the update archive zip file Start S32 Design Studio and go to "Help" -> "S32DS Extensions and Updates" Add a new "Add.." S32DS Software Site and browse to select the downloaded update archive .zip file you downloaded in the previous step         Select from available items and click "Install/Update" button. This will start the update installation process.
View full article
        Product Release Announcement Automotive Processing S32 Design Studio for S32 Platform  v3.3         Austin, Texas, USA Sep 22, 2019   The Automotive Processing's Software Development Tools Engineering Team at NXP Semiconductors is pleased to announce the release of the  S32 Design Studio v3.3 Here are some of major features: Eclipse Neon 4.6 Framework GNU tools: GCC version 6.3.1 20170509, build 1620 revision g01b30c3 GCC version 9.2.0 20190812, build 1649 revision gaf57174 NPW support for GCC 9.2 toolchain (available for selected devices only) S32 Configuration Tool framework 1.1 update 1 with the Pin, Clock, Peripheral, DCD, IVT, DDR and QuadSPI Configuration tools  The wizards for creating application, library projects and projects from project examples for the supported processor families The S32DS Extensions and Updates tool S32 Trace Tool S32 Debugger support PEMicro® debugger support Lauterbach Trace32 ® support Green Hills compiler support S32 Flash Tool Peripheral Registers view and EmbSys Registers view SDK management Support for importing MCAL configuration to a custom SDK Support for migration: project with GCC 6.3.1 toolchain to GCC 9.2 toolchain S32DS for ARM  projects for S32K1 device to S32DS 3.3, including SDK* *  available with S32K1 package, not yet released Release is available for download on  NXP web  and from  S32DS 3.3 . Please make sure that you get new activation ID for this version. Support for S32S247TV and S32V23x is available on public update site and release location. S32V23x support: S32SDK S32V234 RTM 1.0.1  S32 Configuration tools - Pins, CLocks, Peripheral (installed with SDK package) S32 Debugger (with S32 Debug Probe) support for ARM cores S32 Trace for A53 cores GCC version 6.3.1 20170509, build 1574 S32 Flash Tool support AMMCLIB 1.1.20 P&E and Lauterbach debuggers support Note : Vision Extension package 1.0.0 is not compatible with S32 Design Studio 3.3, if you need to work with VSDK and Vision tools - it is recommended to stay on S32DS 3.2 untill a new version of Vision Extension package is released   S32S247TV support: Support for S32S247TV new project wizards, GCC 6.3.1 and GHS compilers S32SDK S32S247TV EAR 0.8.1  S32 Configuration tools - Pins, CLocks, Peripheral, DCD, IVT (installed with SDK package) S32 Debugger (with S32 Debug Probe) support  S32 Flash Tool support Lauterbach support P&E and Lauterbach debuggers support S32 Design Studio Versions   S32DS IDE for S32 Platform S32DS IDE for Arm® S32DS IDE for Power Architecture® S32DS IDE for Vision Devices Supported S32V23x S32K1xx MPC56xx S32V234 S32S247TV KEA MPC57xx   S32 Platform Devices MAC57D54H S32R2xx/S32R3xx   Integrated NXP Tools S32 Flash Tool FreeMASTER FreeMASTER DDR stress tool DDR stress tool     Integrated Configuration Tools S32 Configuration Tools Processor Expert Configuration Tool Processor Expert Configuration Tool  DDR configuration tool Pins Wizard Pins Wizard Pins Wizard Clocks configuration Peripheral/Drivers configuration   Peripheral/Drivers configuration   Peripheral/Drivers configuration   DCD/IVT configuration       DDR configuration tool       Integrated NXP Software S32 SDK S32K1 SDK S32 SDK Vision SDK FreeRTOS FreeRTOS FreeRTOS Linux BSP AMMCLib for S32V23x AMMCLib for KEA and S32K AMMCLib for MPC56xx and MPC57xx MCUs   Vision SDK KEA SDK Radar SDK Linux BSP MQX OS/MQX Drivers for MAC57D54H     Compilers: NXP GCC 6.3.1* NXP GCC 9.2 NXP GCC 6.3.1* NXP GCC 4.9* NXP GCC 6.3.1* GreenHills GreenHills GreenHills   IAR IAR Diab     GCC 4.9*     DEBUGGERS Built-in GDB interface : S32 Debugger/ S32 Debug Probe P&E Multilink/Cyclone/OpenSDA P&E Multilink/Cyclone/OpenSDA S32 Debugger/S32 Debug Probe P&E Multilink/Cyclone/OpenSDA Segger J-Link   P&E Multilink/Cyclone/OpenSDA DEBUGGERS supported: Lauterbach Lauterbach Lauterbach Lauterbach   iSystem iSystem   IAR PLS   Host Operating Systems: Microsoft Windows® 7/8/10 64-bit OS (with 32-bit binaries)  – Ubuntu 14.04, 16.04 (64 bit) – Debian 8 (64 bit) – CentOS 7 (64 bit) Microsoft Windows® 7/8/10 32/64-bit OS (with 32-bit binaries)  – Ubuntu 14.04, 16.04 (64 bit) – Debian 8 (64 bit) – CentOS 7 (64 bit) Microsoft Windows® 7/8/10 32/64-bit OS (with 32-bit binaries)  – Ubuntu 14.04, 16.04 (64 bit) – Debian 8 (64 bit) – CentOS 7 (64 bit) Microsoft Windows® 7/8/10 32/64-bit OS (with 32-bit binaries)  – Ubuntu 14.04, 16.04 (64 bit) – Debian 8 (64 bit) – CentOS 7 (64 bit) Vision specific tools : NXP APU Compiler     NXP APU Compiler ISP assembler     ISP assembler ISP and APEX graph tools     ISP and APEX graph tools Radar specific tools :     SPT assembler       SPT Explorer/ SPT graph tool   Complete S32 Design Studio for S32 Platform v3.3 release notes are attached.   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 development packages available are S32S2xxTV and S32V2xx. 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  
View full article
S32DS contains many example projects from which you can learn how S32DS 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. This project was run using S32DS version 3.2 and VSDK version 1.5.0.   1) Launch S32DS 2)  Select 'File -> New -> S32DS Project from Example' 3) Select 'isp_h264dec_single_stream' project    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_h264dec_single_stream_graph'. Then double click on 'ISP data flow : h264dec_single_stream'. The ISP graph diagram will appear in the editor panel. 4) If not in the C/C++ Perspective, switch over by clicking on the icon showed below (Hovering over the correct icon should display 'C/C++'). The current perspective is displayed on the top bar. 5) Select isp_h264dec_single_stream: A53 in the Project Explorer panel 6) Build project for A53  7) Start a debug session using method as described in HOWTO Create A53 Linux Project in S32DS for Vision, beginning at step 9. 😎 Click Resume  The program takes the input H264 encoded image img_1280x960.h264 located in the /home/root/vsdk/data/common folder on the Linux BSP and outputs it on the display The output image should look like below.
View full article