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

Purpose This document holds information about how the Design Studio and S32Debugger probe can be used to debug Zephyr OS (Operating System) applications running on NXP’ S32 family processors.    Scope    This document is addressed to the software developer or tester (referred below as user) looking to debug or verify its software using the S32Debugger probe.    The document assumes the user has basic knowledge about Zephyr OS and he can rebuild the image with debug configuration.    The information about the building of the Zephyr application using NXP’s Zephyr distribution is not in the scope of this document. This is part of the user manual delivered with the Zephyr NXP release.    Hardware support    This support is available for Cortex-A53 and Cortex-R52 cores only.    It has been confirmed on S32R41, S32R45 and S32Z/E SoCs (System on Chip).    Software support    This feature is available starting with Design Studio 3.5.3.    It is confirmed with Zephyr OS versions 2.7.2 (S32R41), 3.2.0 (S32Z/E), 3.3.0 (S32R41).    Background    Zephyr is a lightweight RTOS (Real Time Operating System) that supplies support for multiple architectures (aarch64, arm, riscv, x86).    The thread awareness support stands for the capability of the debugger to supply low-level information about OS threads (referred below as standard support) or system-level OS information (referred below as extended support).      Standard support    Design Studio can supply low-level information about Zephyr threads:    Name    State    CPU registers - including FPU (Floating Point Unit)    Call stack    Priority    User options    Core number    Prerequisites    S32Debugger automatically detects the Zephyr OS image using the specific debug symbols.    The Zephyr application image should include the following configuration options:    CONFIG_DEBUG_THREAD_INFO    Mandatory    If this choice is not set, the debugger is not able to parse the kernel internal data.    In debug view, the user will see one thread only and no extra information about this.                                         Debug window    The Zephyr threads are listed in the Debug window when the CPU is stopped.      This is an example about how to follow thread entry can be read:      The Thread with index #15 and thread ID 868402064 (TCB (Thread Control Block) address in decimal format) is running on the CPU core 0 and it is in the Stopped state.    It has running priority 15, the user options 0x01 and its name is “idle 00”.    This is suspended in a breakpoint set in function arch_cpu_idle();    Thread states    The thread states names reported by debugger are accordingly with the output of the kernel function k_thread_state_str() excluding Stopped, that is the active Zephyr thread suspended by debugger.    Thread’s state values:    Stopped    Dummy    Pending    Prestart    Dead    Suspended    Aborting    Queued      CPU registers    The CPU registers of the thread selected in the Debug window can be read from the Registers window. This window is updated automatically when other thread is selected.    Known limitations    The warning message “ccs: Invalid parameter” is printed twice into the Design Studio IDE console (for S32Z/E only).    These can be ignored because the functionality is not affected.      Breakpoint per thread is not supported    Write thread registers is not supported (excluding the thread in state Stopped)    Performance may be affected by high number of Zephyr threads    FPU registers read support requires patch of Zephyr OS to save the offset in the table for ARM64 build. This is the snippet code that must be added in the initialization of _kernel_thread_info_offsets  into file thread_info.c😞    #elif defined(CONFIG_FPU) && defined(CONFIG_FPU_SHARING) && defined(CONFIG_ARM64)     [THREAD_INFO_OFFSET_T_PREEMPT_FLOAT] = offsetof(struct _thread_arch,                          saved_fp_context),        [THREAD_INFO_OFFSET_T_COOP_FLOAT] = THREAD_INFO_UNIMPLEMENTED,        Extended support    Design Studio can supply system-level information about Zephyr OS resources like:    Timer    Semaphore    Mutex    Stack    Message queue    Mailboxes    Pipes    Queues    Threads    This implementation is not CPU architecture specific like standard support.    Prerequisites    The Zephyr application image should include the following configuration options:      CONFIG_DEBUG_THREAD_INFO    Mandatory    If this choice is not set, the debugger is not able to parse kernel internal data and to supply information about resource owners or waiting lists.    CONFIG_TRACING    CONFIG_TRACING_OBJECT_TRACKING    CONFIG_TRACING_NONE    Mandatory    Enable the kernel object tracking. If this is not set, the debugger can show system information about Threads only. Note: This configuration is working on Zephyr version 3.0.0 or higher.    CONFIG_INIT_STACKS    Optional    Enable the fill of stack with a marker that can be used by debugger to report the peak stack usage.    This information might be useful for stack size tunning.    CONFIG_THREAD_STACK_INFO    Recommended    The debugger supplies information about the stack (address, size or usage).        GDB (GNU Debugger)    This support is available through extended GDB commands.    Command name    Description    thread-aware-list-supported-os    List the supported OS types and the detected OS    thread-aware-list-supported-objs    List the supported kernel objects by the detected or specified OS. This is based on types used by the current image only.    thread-aware-read-objs    Read the specified or all objects supported by current image.        These commands can be configured to supply the output in JSON (JavaScript Object Notation) or table format.    Use the help command to get more information about these thread awareness commands.      Figure 2 GDB - Get Thread, Mutex & Semaphore info    Common attributes    Most of the object's attributes are type specific with 2 exceptions:    Attribute name    Description    Format               S32Debugger Zephyr Thread Awareness                                                                       User Manual v1.3                                                                        address    Object data address                     integer                                 name    ELF Symbol name                          string                                    Thread attributes    Attribute name    Description    Format    user_options    User options    integer    state    Thread state – see Thread states    string    prio    Thread priority    integer    stack_addr        integer    stack_delta        integer    stack_size        integer    stack_usage_max    Largest stack usage    float    stack_usage    Current stack usage    float    MemSlab attributes    Attribute name    Description    Format    num_blocks        integer    block_size        integer    buffer        integer    free_list        integer    num_used        integer    locked    Locked by this thread (name)    string    waiting    Threads (name) waiting for this object    string list    Queue attributes    Attribute name    Description    Format    locked    Locked by this thread (name)    string      waiting    Threads (name) waiting for this object    string list    Pipe attributes    Attribute name    Description    Format    buffer        integer    size        integer    bytes_used        integer    read_index        integer    write_index        integer    flags        integer    locked    Locked by this thread (name)    string    waiting_tx    Threads (name) waiting for this object on write    string list    waiting_rx    Threads (name) waiting for this object on read    string list    MBox attributes    Attribute name    Description    Format    locked    Locked by this thread (name)    string    waiting_tx    Threads (name) waiting for this object on write    string list    waiting_rx    Threads (name) waiting for this object on read    string list    Attribute name    Description    Format    timeout        integer      period        integer    MsgQ Attribute name    Description    Format    attributes    Attribute name    Description    Format    msg_size        integer    max_msgs        integer    buffer_start        integer    buffer_end        integer    read_ptr        integer    write_ptr        integer    used_msgs        integer    flags        integer    locked    Locked by this thread (name)    string    waiting    Threads (name) waiting for this object    string list    Stack attributes    Attribute name    Description    Format    base        integer    next        integer    top        integer    flags        integer    locked    Locked by this thread (name)    string    waiting    Threads (name) waiting for this object on write    string list    Timer attributes    status        integer    waiting    Threads (name) waiting for this object on write    string list    Mutex attributes      owner    Own by this thread (name)    string    lock_count        integer    owner_orig_prio        integer    waiting    Threads (name) waiting for this object on write    string list    Semaphore attributes    Attribute name    Description    Format    limit        integer    count        integer    waiting    Threads (name) waiting for this object on write    string list        DS (Design Studio)    The DS version 3.5.3 or higher offers the possibility to display the Thread information only into a dedicated view.    The extended support is still available in DS by running the extended GDB commands directly from the Debugger Console window.            Figure 3 DS - Execute thread awareness GDB commands    Thread view    This window can be accessed from the menu RTOS/Zephyr RTOS/Threads.                  Figure 4 DS IDE - Thread view    Some information can be missing from the view depending on the build configuration used. For example, in the above figure, the Peak stack usage is not available because the CONFIG_INIT_STACKS is not set.    Note the Thread’s field names into DS IDE Thread view can be different than GDB Thread attributes.    Stack    The thread view holds more information about the stack.    The Stack usage stands for the current stack usage, and it is based on SP (Stack Pointer) register while the Peak stack usage stands for the maximum usage of the stack.    Known limitations    Performance may be affected by number of OS resources    Limited configurations tested       

In order to improve user experience with S32 Design Studio, in this article you can find some tips and tricks.   Use-Case #1: S32 Design Studio takes to much time to perform some of UI update operations Workaround: Manually update the Eclipse configuration parameters in the s32ds.ini file Use-Case #2: S32 Design Studio takes a lot of time to open waiting for updates checking to finish Solution: Update your environment to use at least Update12 or newer or disable the checking at startup Use-Case #3: Control of package dependencies between RTD and S32DS during install/update flow Solution: Transition to Package Manager as the main/single delivery solution for SW and Tools installation. The concept of “Bundles & Use Cases” guarantee interoperability and come with customer support.    

When a new application project is created using the New Project Wizard, it is possible to select the debugger to be used. This results in the associated debugger configurations being created within the new project. But what if support for multiple debuggers is required or it is desired to switch to a different debugger? There are easy ways to resolve this. One is as simple as creating a new debug configuration. Another method is by creating new application project, selecting the new debugger to be supported. Then either repurposing the associated debug configuration or duplicating then modifying the debug configuration to support instead the previously existing project. This minimizes the effort by benefiting from the automation of the New Project Wizard.   Detailed below are the steps to add a new debug configuration.  Create A New S32 Debugger Configuration Load the existing project. For this demonstration, the SDK project ‘hello_world_s32v234’ will be used. Select the project so it appears highlighted in blue. Notice that the other project, ‘New_App_Project’, is bold text. This is because the main.c file open in the editor window to the right is the currently selected source file and is from this project. This has no effect on the process detailed in this document. Check that the existing project has been build and the executable is present. If the executable is not present, then an error will be displayed within the Debug Configurations menu and the executable file will need to be selected in a later additional step after it has been created. Open the Debug Configurations menu. Run -> Debug Configurations   Now select the Debugger Group for which you wish to create the new configuration. In this case, we will select ‘S32 Debugger’. Next, click ‘New Launch Configuration’ Now a new Debug Configuration has been created for your project and for the S32 Debugger. Most of the fields are already completed for you. Select the Debugger tab to see the source of the error message. The error message indicates ‘Specify Device and Core’. So click on ‘Select device and core’. Now expand the lists until the Device and Core are visible. Select the correct core for your project. In the demonstration example, the correct Device and Core are ‘S32V234’ and ‘M4’, respectively. Click OK, when done. If you have a debug probe connected, it may have been detected. If not, the Debug Probe Connection section will need to be completed. Now select the ‘Common’ tab to setup the storage location for this new Debug Configuration. Select ‘Shared file’ and then ‘Browse…’ Expand the lists until ‘Project_Settings/Debugger’ is open. Select ‘Debugger’, then click OK. Now the basic debug configuration settings are complete. It is now ready to be used and the Debug button could be clicked to start debug. Otherwise, you may have more customizations to make, such as for Attach Mode. Repurpose S32 Debugger Configuration From A New Project Create new project New -> S32DS Application Project New Project Wizard, processor and toolchain page Enter a project name Select the device and core to match the existing project If necessary, select the toolchain to match the existing project Click Next New Project Wizard, cores and parameters page Select the number of cores to match the existing project Select the debugger, S32 Debugger If necessary, select other parameters to match the existing project Click Finish   Open existing project which does not already have the S32 Debugger debug configurations (for this demonstration, we will use the hello_world_s32v234 example project from the S32 SDK) Copy debug configurations and modify settings to adapt to existing project Run -> Debug Configurations... Debug Configurations window Within the S32 Debugger grouping, select the debug configuration for the new project which corresponds to the build configuration and core of the existing project Change the name of the debug configuration. Change the portion of the name containing the project name to match the name of the existing project. Main tab Project field Click Browse... Select existing project C/C++ Application Click Search Project... Select the Elf file Common tab Save as field Click Browse... Select {existing_project_name}\Project_Settings\Debugger Debugger tab, Debug Probe Connection Setup connection parameters Click Apply Repeat as needed for all core/build config options The existing project now has the S32 Debugger configurations and is ready for debug with the S32 Debug Probe.

This document shows the step-by-step process to create a simple blinking LED application for the S32G family using the S32 RTD AUTOSAR drivers. This example used for the S32G-VNP-RDB2 EVB, connected via ethernet connection through S32 Debugger. Preparation Setup the software tools Install S32 Design Studio for S32 Platform Install the S32G development package and the S32 RTD AUTOSAR 4.4. Both of these are required for the S32 Configuration Tools. Launch S32 Design Studio for S32 Platform Procedure New S32DS Project OR Provide a name for the project, for example 'Blinking_LED_RTD_With_AUTOSAR'. The name must be entered with no space characters. Expand Family S32G2, Select S3G274A_Rev2 Cortex-M7 Click Next Click '…' button next to SDKs   Check box next to PlatformSDK_S32XX_2022_07_S32G274A_Rev2_M7_0. Click OK And also, uncheck the other cores Cortex_M7_1 ,  Cortex_M7_2.   Click Finish. Wait for project generation wizard to complete, then expand the project within the Project Explorer view to show the contents. To control the LED on the board, some configuration needs to be performed within the Pins Tool. There are several ways to do this. One simple way by double-click on the MEX file. Select the overview tab and disable Pins tool. Make sure to overview tab windows shows settings shown as below.  Here, we are disabling pin tools and using MCAL driver from peripheral tools for using AUTOSAR drivers. Now from Overview menu, select peripheral tools and double click to open it. In the driver sections, “Siul2_Port_1 driver” is the non-AUTOSAR version driver and so it must be replaced. Right click on ‘Siul2_Port_1’ and remove it. Keep the osif_1 driver as it is. Click on the ‘+’ next to the MCAL box. Locate and then select the ‘MCU’ component from the list and click OK. Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Dio’ component from the list and click OK. Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Port’ component from the list and click OK. Now components tab should show like below : Now we required to configure the different MCAL drivers that we added. Starting with Dio configuration, open the Dio configuration. Now, open the ‘DioGeneral’ tab, and select checkmark as per shown below: Now, open the ”DioConfig” tab. In that, select  “+” sign adjacent to Dio Channel. Then edit Name to Digital_Output_LED and “Dio Channel Id”  to ‘6’ instead of ‘0’. From the schematic for S32G-VNP-RDB2 EVB, we can select signal line based on your choice for the LED color for the multicolor RGB LED. Now, checking for blue user LED from the schematic, channel 6 is connected to blue LED signal, so we use channel 6 signal line to the chip on the blue LED. Similarly, so you can select signal line based on LED color you select. Now Select Port tab for Port configuration. And open the Port Configuration tab, and from that open “PortConfigSet” tab. Change the PortPin Mscr to 6 , PortPin Direction to PORT_PIN_INOUT. After change it should be as below. At the bottom you will find the “UnTouchedPortPin ’’ . Click on “+’’ and add PortPins. Now add 4 port pins as per below configuration. Pins 0, 1, 4, and 5 should be setup. Now configure MCU component. Select Mcu component in MCAL, and then open the Mcu configuration. In Mcu configuration select “McuModesettingConf” from the dropdown menu as shown below. Select ‘McuPartition0Config’ and deselect checkbox for CM7_0 Under MCU Control, CM7_1 Under MCU Control, CM7_2 Under MCU Control as marked below. And it should show as below Now select the Mcupartition1Config and uncheck checkmarks from the selection boxes as shown below Now the device configurations are complete and the RTD configuration code can be generated. Click ‘Update Code’ from the menu bar. To control the output pin which was just configured, some application code will need to be written. Return to the ‘C/C++’ perspective. If not already open, in the project window click the ‘>’ next to the ‘src’ folder to show the contents, then double click ‘main.c’ file to open it. This is where the application code will be added. Before anything else is done, Initialize the clock tree and apply PLL as system clock, Apply a mode configuration, Initialize all pins using the Port driver by adding – editing code before write code here comment in main function.          Mcu_Init(&Mcu_Config_BOARD_InitPeripherals);     /* Initialize the clock tree and apply PLL as system clock */     Mcu_InitClock(McuClockSettingConfig_0);     /* Apply a mode configuration */     Mcu_SetMode(McuModeSettingConf_0);     /* Initialize all pins using the Port driver */     Port_Init(NULL_PTR); Now replace the logic of for loop as shown below code section, which will enable the LED blinking for 10 times: First define the variable volatile uint8 level; globally above the main function. You also need to declare and initialize the loop variable uint8 i = 0U. Then replace the code as below: while (i++ < 10) {       Dio_WriteChannel(DioConf_DioChannel_Digital_Output_LED, STD_HIGH);       level = Dio_ReadChannel(DioConf_DioChannel_Digital_Output_LED);       TestDelay(2000000);       Dio_WriteChannel(DioConf_DioChannel_Digital_Output_LED, STD_LOW);       level = Dio_ReadChannel(DioConf_DioChannel_Digital_Output_LED);       TestDelay(2000000); } Before the 'main' function, add a delay function as follows: void TestDelay(uint32 delay); void TestDelay(uint32 delay) {     static volatile uint32 DelayTimer = 0;     while(DelayTimer<delay)     {         DelayTimer++;     }     DelayTimer=0; } Update the includes lines at the top of the main.c file to include the headers for the drivers used in the application: Add #include "Mcu.h" #include "Port.h" #include "Dio.h" Build 'Blinking_LED_RTD_AUTOSAR'. Select the project name in 'C/C++ Projects' view and then press 'Build'. After the build completes, check that there are no errors. Open Debug Configurations and select 'Blinking_LED_RTD_with_AUTOSAR_Debug_RAM'. Make sure to select the configuration which matches the build type performed, otherwise it may report an error if the build output doesn’t exist. And make selection as shown in screenshot below. You need to select the ethernet connection for S32 debugger and provide its IP address Click Debug To see the LED blink, click ‘Resume' This code as it is will blink the LED 10 times, you can make changes in for loop condition to blink it infinitely.

This document shows the step-by-step process to create a simple blinking LED application for the S32G family using the S32 RTD non-AUTOSAR drivers. For this example used for the S32G-VNP-RDB2 EVB, connected via ethernet connection through S32 Debugger. Preparation Setup the software tools Install S32 Design Studio for S32 Platform Install the S32G development package and the S32 RTD AUTOSAR 4.4. Both of these are required for the S32 Configuration Tools. Launch S32 Design Studio for S32 Platform Procedure New S32DS Project OR Provide a name for the project, for example 'Blinking_LED_RTD_No_AUTOSAR'. The name must be entered with no space characters. Expand Family S32G2, Select S32G274A_Rev2 Cortex-M7 Click Next Now, uncheck the selection mark for other two cores.    Click '…' button next to SDKs   Check box next to PlatformSDK_S32XX_2022_07_S32G274A_Rev2_M7_0. (or whichever latest SDK for the S32G is installed). Click OK Click Finish. Wait for project generation wizard to complete, then expand the project within the Project Explorer view to show the contents. To control the LED on the board, some configuration needs to be performed within the Pins Tool. There are several ways to do this. One simple way by double-click on the MEX file. By default, the Pins tool is then presented. For the Blinking LED example, one pin must be configured as output. The S32G-VNP-RDB2 EVB has an RGB LED for which each color is connect to a separate pin on the S32G-VNP-RDB2 EVB. For the blue LED the desired pin is PA_06. From the Peripheral Signals tab left to the Pins tool perspective layout, locate Open the Siul2_0 from the peripheral signals tab. And from the drop down menu select “gpio,6 PA_06” option as per shown in the following image. We are using PA_06 for the GPIO usage, so we are routing the SIUL2_0 GPIO signal to this pin. (This pin is also available for other modules like -FR, FTM, SPI_1) . The Direction required! menu will appear. Select Output then OK. In Routing Details view, notice a new line has been added and highlighted in yellow. Add ‘LED’ to the Label and Identifier columns for the PORTD 0 pin. Code Preview Go to Peripherals tool and add Siul2_Dio to enable LED blinking, it adjacent to the Blue LED on S32G-VNP-RDB2 EVB. Click on the Peripherals Tool icon from the Eclipse Perspective navigation bar. From the Components view, click on ‘Add a new configuration component…’ button from the Drivers category. This will bring up a list of all configuration components. Locate and then select the ‘Siul2_Dio’ component from the list and click OK. Do not worry about the warning message. It is only indicating that the driver is not already part of the current project. The associated driver package will be added automatically. Note: It may be necessary to change the selection at the top from ‘Present in the tool-chain project’ to ‘All’. The DIO driver provides services for reading and writing to/from DIO Channels. Also, select the Siul2_Port_1 tab and select the check mark against ‘Siul2 IP Port Development Error Detect’ option as below. The Gpio_Dio driver requires no further configuration. Click Save to store all changes to the .MEX file. Now the device configurations are complete and the RTD configuration code can be generated. Click ‘Update Code’ from the menu bar. To control the output pin which was just configured, some application code will need to be written. Return to the ‘C/C++’ perspective. If not already open, in the project window click the ‘>’ next to the ‘src’ folder to show the contents, then double click ‘main.c’ file to open it. This is where the application code will be added. Before the pin can be controlled, it needs to be initialized using the configuration information that was generated from the S32 Configuration tools. Initialize all pins using the Port driver by adding the following line: Insert the following line into main, after the comment 'Write your code here': /* Initialize all pins using the Port driver */ Siul2_Port_Ip_Init(NUM_OF_CONFIGURED_PINS0, g_pin_mux_InitConfigArr0); Now, add logic for the LED turn and off. To turn the pin on and off with some delays in-between to cause the LED to blink. Make the delays long enough to be perceptible. Add line to initialize variable uint8 i = 0; Change the code within the provided for loop, and add the following lines: //logic for blinking LED 10 times for (i=0; i<10; i++) {       Siul2_Dio_Ip_WritePin(LED_PORT, LED_PIN, 1U);       level = Siul2_Dio_Ip_ReadPin(LED_PORT, LED_PIN);       TestDelay(2000000);       Siul2_Dio_Ip_WritePin(LED_PORT, LED_PIN, 0U);       level = Siul2_Dio_Ip_ReadPin(LED_PORT, LED_PIN);       TestDelay(2000000); } return (0U); And add this line above the main() function to initialize the variable volatile uint8 level; Before the 'main' function, add a delay function as follows: void TestDelay(uint32 delay); void TestDelay(uint32 delay) {    static volatile uint32 DelayTimer = 0;    while (DelayTimer<delay)    {        DelayTimer++;    }    DelayTimer=0; } Update the includes lines at the top of the main.c file to include the headers for the drivers used in the application: Remove #include "Mcal.h" Add #include "Siul2_Port_Ip.h" #include "Siul2_Dio_Ip.h" Build 'Blinking_LED_RTD_No_AUTOSAR'. Select the project name in 'C/C++ Projects' view and then press 'Build'. After the build completes, check that there are no errors. Open Debug Configurations and select 'Blinking_LED_RTD_No_AUTOSAR_Debug_RAM'. Make sure to select the configuration which matches the build type performed, otherwise it may report an error if the build output doesn’t exist. Now, you need to Select the Interface (Ethernet or USB) by which the S32 Debug Probe is connected. If connected via USB and this option is selected for interface, then the COM port will be detected automatically (in the rare event where 2 or more S32 Debug Probes are connected via USB to the host PC, then it may be necessary to select which COM port is correct for the probe which is connected to the EVB) If connected via Ethernet, enter the IP address of the probe. See the S32 Debug Probe User Manual for ways to determine the IP address. Click Debug To see the LED blink, click ‘Resume'. This code as it will blink the LED times, you can make changes in for loop condition to blink it infinitely.

This document shows the step-by-step process to create a simple blinking LED application for the S32R45 device using the S32 RTD non-AUTOSAR drivers. For this example used for the S32R45 EVB, connected via ethernet connection through S32 Debugger. Preparation Setup the software tools Install S32 Design Studio for S32 Platform Install the S32R45 development package and the S32R45 RTD AUTOSAR 4.4. Both of these are required for the S32 Configuration Tools. Launch S32 Design Studio for S32 Platform Procedure New S32DS Project OR Provide a name for the project, for example 'Blinking_LED_RTD_No_AUTOSAR'. The name must be entered with no space characters. Expand Family S32R45, Select S32R45 Cortex-M7 Click Next And Click '…' button next to SDKs   Check box next to PlatformSDK_S32RXX_4_0_0_S32R45_M7_0. (or whichever latest SDK for the S32R45 is installed). Click OK Now, uncheck the selection mark for other core, i.e. for Cortex-M7-1 , Cortex-M7-2   Click Finish. Wait for project generation wizard to complete, then expand the project within the Project Explorer view to show the contents. To control the LED on the board, some configuration needs to be performed within the Pins Tool. There are several ways to do this. One simple way by double-click on the MEX file. By default, the Pins tool is then presented. For the Blinking LED example, one pin must be configured as output. The S32R45 EVB has an user LED connected pin is PD_05. From the Peripheral Signals tab left to the Pins tool perspective layout, locate Open the Siul2_0 from the peripheral signals tab. And from the drop down menu select “gpio,53 PD_05” option as per shown in the following image. We are using PD_05 for the GPIO usage, so we are routing SIUL2_0 GPIO signal to this pin. Select gpio53 -> PD_05 as shown below : The Direction required! menu will appear. Select Output then OK. In Routing Details view, notice a new line has been added and highlighted in yellow. Add ‘LED’ to the Label and Identifier columns for the PORTD 5 pin. Code Preview Go to Peripherals tool and add Siul2_Dio to enable LED blinking, it adjacent to the user LED on S32R45 EVB. Click on the Peripherals Tool icon from the Eclipse Perspective navigation bar. From the Components view, click on ‘Add a new configuration component…’ button from the Drivers category. This will bring up a list of all configuration components. Locate and then select the ‘Siul2_Dio’ component from the list and click OK. Do not worry about the warning message. It is only indicating that the driver is not already part of the current project. The associated driver package will be added automatically. Note: It may be necessary to change the selection at the top from ‘Present in the tool-chain project’ to ‘All’. The DIO driver provides services for reading and writing to/from DIO Channels. The Gpio_Dio driver requires no further configuration. Click Save to store all changes to the .MEX file. Now the device configurations are complete and the RTD configuration code can be generated. Click ‘Update Code’ from the menu bar. To control the output pin which was just configured, some application code will need to be written. Return to the ‘C/C++’ perspective. If not already open, in the project window click the ‘>’ next to the ‘src’ folder to show the contents, then double click ‘main.c’ file to open it. This is where the application code will be added. Before the pin can be controlled, it needs to be initialized using the configuration information that was generated from the S32 Configuration tools. Initialize all pins using the Port driver by adding the following line: Insert the following line into main, after the comment 'Write your code here': /* Initialize all pins using the Port driver */ Siul2_Port_Ip_Init(NUM_OF_CONFIGURED_PINS0, g_pin_mux_InitConfigArr0); Now, add logic for the LED turn and off. To turn the pin on and off with some delays in-between to cause the LED to blink. Make the delays long enough to be perceptible. Add line to initialize variable uint8 i = 0; Change the code within the provided for loop, and add the following lines: //logic for blinking LED 10 times while (i++ < 10) {        Siul2_Dio_Ip_WritePin(LED_PORT, LED_PIN, 1U);        TestDelay(4000000);        Siul2_Dio_Ip_WritePin(LED_PORT, LED_PIN, 0U);        TestDelay(4000000); } Before the 'main' function, add a delay function as follows: void TestDelay(uint32 delay); void TestDelay(uint32 delay) {    static volatile uint32 DelayTimer = 0;    while (DelayTimer<delay)    {        DelayTimer++;    }    DelayTimer=0; } Update the includes lines at the top of the main.c file to include the headers for the drivers used in the application: Remove #include "Mcal.h" Add #include "Siul2_Port_Ip.h" #include "Siul2_Dio_Ip.h" Build 'Blinking_LED_RTD_No_AUTOSAR'. Select the project name in 'C/C++ Projects' view and then press 'Build'. After the build completes, check that there are no errors. Open Debug Configurations and select 'Blinking_LED_RTD_No_AUTOSAR_Debug_RAM'. Make sure to select the configuration which matches the build type performed, otherwise it may report an error if the build output doesn’t exist. Now, you need to Select the Interface (Ethernet or USB) by which the S32 Debug Probe is connected. If connected via USB and this option is selected for interface, then the COM port will be detected automatically (in the rare event where 2 or more S32 Debug Probes are connected via USB to the host PC, then it may be necessary to select which COM port is correct for the probe which is connected to the EVB) If connected via Ethernet, enter the IP address of the probe. See the S32 Debug Probe User Manual for ways to determine the IP address. Click Debug To see the LED blink, click ‘Resume'. This code as it will blink the LED 10 times, you can make changes in for loop condition to blink it infinitely.

This document shows the step-by-step process to create a simple blinking LED application for the S32R45 family using the S32 RTD AUTOSAR drivers. This example used for the S32R45 EVB, connected via ethernet connection through S32 Debugger. Preparation Setup the software tools Install S32 Design Studio for S32 Platform Install the S32R45 development package and the S32R45 RTD AUTOSAR 4.4. Both of these are required for the S32 Configuration Tools. Launch S32 Design Studio for S32 Platform Procedure New S32DS Project OR Provide a name for the project, for example 'Blinking_LED_RTD_With_AUTOSAR'. The name must be entered with no space characters. Expand Family S32R45, Select S32R45 Cortex-M7 Click Next Click '…' button next to SDKs   Check box next to PlatformSDK_S32RXX_4_0_0_S32R45_M7_0. (or whichever latest SDK for the S32R45 is installed). Click OK And also, uncheck the other cores Cortex_M7_1 ,  Cortex_M7_2.   Click Finish. Wait for project generation wizard to complete, then expand the project within the Project Explorer view to show the contents. To control the LED on the board, some configuration needs to be performed within the Pins Tool. There are several ways to do this. One simple way by double-click on the MEX file. Select the overview tab and disable Pins tool. Make sure to overview tab windows shows settings shown as below.  Here, we are disabling pin tools and using MCAL driver from peripheral tools for using AUTOSAR drivers. Now from Overview menu, select peripheral tools and double click to open it. In the driver sections, “Siul2_Port_1 driver” is the non-AUTOSAR version driver and so it must be replaced. Right click on ‘Siul2_Port_1’ and remove it. Keep osif_1 driver as it is. Click on the ‘+’ next to the MCAL box. Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Dio’ component from the list and click OK. Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Mcu’ component from the list and click OK. Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Port’ component from the list and click OK. Now components tab should show like below : Now we required to configure the different MCAL drivers that we added. Starting with Dio configuration, open the Dio configuration. Now, open the ‘DioConfig’ tab, and Edit Dio Port id to 3 as shown below: Now, in “Dio Configuration” window only, Select  “+” sign adjacent to DioChannel. Then Edit Name to “Digital_Output_LED” and Dio Channel Id to ‘5’ instead of ‘0’. From the schematic for S32GR45 EVB, checking for user LED from the schematic, channel 5 is connected to user LED signal, so we use channel 5 signal line to the chip for the user LED. So, we select the singal line for Dio channel Id 5 for the user LED connected on the S32R45 EVB. Now Select Port tab for Port configuration. And open the Port Configuration tab, and from that open “PortConfigSet” tab. Change the PortPin Mscr to ‘53’ and slew rate to ‘SRE_208MHZ_1_8V_166MHZ_3_3V’ and, PortPin Direction to PORT_PIN_INOUT as shown below: Now, at the bottom you will find the “UnTouchedPortPin ’’ . Click on “+’’ and add PortPins. Now add port pins 0, 1, 2, 3 as per below configuration Now configure MCU component. Select Mcu component in MCAL, and then open the Mcu configuration. In Mcu configuration click on MCUModuleConfiguration and then select “McuModesettingConf” from the dropdown menu as shown below. From McuModeSettingConf, select McuPartitionConfiguration tab. Then open the “McuPartition0Config” tab. And under the McuCore0Configuration or “McuCoreClockEnable” select checkbox and for “McuCoreResetEnable” uncheck the checkbox. Similarly, And under the McuCore1Configuration for “McuCoreClockEnable” select checkbox  and for “McuCoreResetEnable” uncheck the checkbox. Similarly, And under the McuCore2Configuration for “McuCoreClockEnable” select checkbox and for “McuCoreResetEnable” uncheck  the checkbox. After modification it should be as shown below: Now open the “McuPartition1Config” tab. for " Partition1 Clock Enable" select checkmark to true and for " Partition1 Clock Reset Enable" uncheck the checkmark for " CA53 CORE 0 cluster0 Core Clock Enable" select checkmark to true and for " Cortex-A53 Core 0 cluster 0 Clock Reset Enable" uncheck  the checkmark In the McuCore1Configuration, and for " Cortex-A53 Core 1 cluster 0 Clock Reset Enable" uncheck the checkmark In the McuCore2Configuration, for " Cortex-A53 CORE 0 cluster 1 Core Clock Enable" select checkmark to true and for " Cortex-A53 CORE 0 cluster 1 Clock Reset Enable" uncheck the checkmark In the McuCore3Configuration, for " Cortex-A53 CORE 0 cluster 1 Clock Reset Enable" uncheck the checkmark After modification it should be as shown below: Now open the “McuPartition2Config” tab. for " Partition2 Clock Enable" select checkmark to true and for " Partition2 Clock Reset Enable" uncheck the checkmark Now open the “McuPartition3Config” tab. for " Partition3 Clock Enable" select checkmark to true and for " Partition3 Clock Reset Enable" uncheck the checkmark Now the device configurations are complete and the RTD configuration code can be generated. Click ‘Update Code’ from the menu bar. To control the output pin which was just configured, some application code will need to be written. Return to the ‘C/C++’ perspective. If not already open, in the project window click the ‘>’ next to the ‘src’ folder to show the contents, then double click ‘main.c’ file to open it. This is where the application code will be added. Before anything else is done, Initialize the clock tree and apply PLL as system clock, Apply a mode configuration, Initialize all pins using the Port driver by adding – editing code before write code here comment in main function.        /* Initialize the Mcu driver */        Mcu_Init(&Mcu_Config_BOARD_InitPeripherals);        /* Initialize the clock tree and apply PLL as system clock */        Mcu_InitClock(McuClockSettingConfig_0);        /* Apply a mode configuration */        Mcu_SetMode(McuModeSettingConf_0);        /* Initialize all pins using the Port driver */        Port_Init(NULL_PTR); Now replace the logic of for loop as shown below code section in the main function, which will enable the LED blinking for 10 times: You also need to declare and initialize the loop variable uint8 i = 0U; . Then replace the code as below after write your code comment: /*Logic for blinking LED 10 times*/ while (i++ < 10) {           /* Get input level of channels */           Dio_WriteChannel(DioConf_DioChannel_Digital_Output_LED, STD_HIGH);           TestDelay(3000000);           Dio_WriteChannel(DioConf_DioChannel_Digital_Output_LED, STD_LOW);           TestDelay(3000000); } Before the 'main' function, add a delay function as follows: void TestDelay(uint32 delay); void TestDelay(uint32 delay) {      static volatile uint32 DelayTimer = 0;      while(DelayTimer<delay)      {             DelayTimer++;      }      DelayTimer=0; } Update the includes lines at the top of the main.c file to include the headers for the drivers used in the application: Add #include "Mcu.h" #include "Port.h" #include "Dio.h" Build 'Blinking_LED_RTD_AUTOSAR'. Select the project name in 'C/C++ Projects' view and then press 'Build'. After the build completes, check that there are no errors. Open Debug Configurations and select 'Blinking_LED_RTD_with_AUTOSAR_Debug_RAM'. Make sure to select the configuration which matches the build type performed, otherwise it may report an error if the build output doesn’t exist. And make selection as shown in screenshot below. You need to select the ethernet connection for S32 debugger and provide its IP address Click Debug To see the LED blink, click ‘Resume' This code as it will blink the LED 10 times, you can make changes in for loop condition to blink it infinitely.

This document shows the step-by-step process to create a simple blinking LED application for the S32R41 family using the S32 RTD AUTOSAR drivers. This example used for the S32R41 EVB, connected via ethernet connection through S32 Debugger. Preparation Setup the software tools Install S32 Design Studio for S32 Platform Install the S32R41 development package and the S32R41 RTD AUTOSAR 4.4. Both of these are required for the S32 Configuration Tools. Launch S32 Design Studio for S32 Platform Procedure New S32DS Project OR Provide a name for the project, for example 'Blinking_LED_RTD_With_AUTOSAR'. The name must be entered with no space characters. Expand Family S32R41, Select S32R418AB Cortex-M7  Click Next Click '…' button next to SDKs   Check box next to PlatformSDK_SAF85_S32R41_2022_08_S32R418AB _M7_0. Click OK And also, uncheck the other core Cortex_M7_1 Click Finish. Wait for project generation wizard to complete, then expand the project within the Project Explorer view to show the contents. To control the LED on the board, some configuration needs to be performed within the Pins Tool. There are several ways to do this. One simple way by double-click on the MEX file. Select the overview tab and disable Pins tool. Make sure to overview tab windows shows settings shown as below.  Here, we are disabling pin tools and using MCAL driver from peripheral tools for using AUTOSAR drivers. Now from Overview menu, select peripheral tools and double click to open it. In the driver sections, “Siul2_Port_1 driver” is the non-AUTOSAR version driver and so it must be replaced. Right click on ‘Siul2_Port_1’ and remove it. Keep BaseNXP driver as it is. Click on the ‘+’ next to the MCAL box. Locate and then select the ‘Dem’ component from the list and click OK. Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Dio’ component from the list and click OK. Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Mcu’ component from the list and click OK. Click on the ‘+’ next to the MCAL box again, and Locate and then select the ‘Port’ component from the list and click OK. Now components tab should show like below : Now we required to configure the different MCAL drivers that we added. Starting with Dio configuration, open the Dio configuration. No change is required for Dem configuration. Now, open the ‘DioGeneral’ tab, and select checkmark as per shown below: Now, open the ”DioConfig” tab. In that Select  “+” sign adjacent to Dio Channel. Then Edit Name to “Digital_Output_LED_0” and Dio Channel Id to ‘4’ instead of ‘0’. From the schematic for S32R41 EVB, checking for signal line for the user LED, channel 4 is connected to user LED signal, so we use channel 4 for signal line for user LED on the chip. So, we select the signal line for Dio channel Id 4 for the LED connected on the S32R41 EVB. Now Select Port tab for Port configuration. And open the Port Configuration tab, and from that open “PortConfigSet” tab. Change the PortPin Mscr to 36 , PortPin Direction to PORT_PIN_INOUT as shown below: Now, at the bottom you will find the “UnTouchedPortPin ’’ . Click on “+’’ and add PortPins. Now add port pins 0, 1, 2, 3,4 as per below configuration Now configure MCU component. Select Mcu component in MCAL, and then open the Mcu configuration. In Mcu configuration click MCUModuleConfiguration and then select  “McuModesettingConf” from the dropdown menu as shown below. From McuModeSettingConf select McuPartitionConfiguration Now open “McuPartition0Config” tab. And under the McuCore0Configuration for “McuCoreClockEnable” select checkbox and for “McuCoreResetEnable” uncheck  the checkbox. Similarly, And under the McuCore1Configuration for “McuCoreClockEnable” select checkbox and for “McuCoreResetEnable” uncheck  the checkbox. After modification it should be as shown below: Now open the “McuPartition1Config” tab. for "McuPartitionClockEnable" select checkmark to true and for "McuPartitionResetEnable" uncheck  the checkmark   And under McuCore0Configuration for "McuCoreClockEnable"  select checkmark to true and for "McuCoreResetEnable" uncheck  the checkmark After modification it should be as shown below: Now, click on global setting icon as shown below: And, Confirm that ComponentGenerationMethod is set to “FunctionalGroups” Now the device configurations are complete and the RTD configuration code can be generated. Click ‘Update Code’ from the menu bar. To control the output pin which was just configured, some application code will need to be written. Return to the ‘C/C++’ perspective. If not already open, in the project window click the ‘>’ next to the ‘src’ folder to show the contents, then double click ‘main.c’ file to open it. This is where the application code will be added. Before anything else is done, Initialize the clock tree and apply PLL as system clock, Apply a mode configuration, Initialize all pins using the Port driver by adding – editing code before write code here comment in main function.        /* Initialize the Mcu driver */        Mcu_Init(&Mcu_Config_BOARD_InitPeripherals);        /* Initialize the clock tree and apply PLL as system clock */        Mcu_InitClock(McuClockSettingConfig_0);        /* Apply a mode configuration */        Mcu_SetMode(McuModeSettingConf_0);        /* Initialize all pins using the Port driver */        Port_Init(NULL_PTR); Now replace the logic of for loop as shown below code section, which will enable the LED blinking for 10 times: You also need to declare and initialize the loop variable: uint8 i = 0U; Then replace the code as below after write your code comment: /*Logic for blinking LED 10 times*/ while (i++ < 10) {       /* Get input level of channels */       Dio_WriteChannel(DioConf_DioChannel_Digital_Output_LED_0, STD_HIGH);       TestDelay(3000000);       Dio_WriteChannel(DioConf_DioChannel_Digital_Output_LED_0, STD_LOW);       TestDelay(3000000); } Before the 'main' function, add a delay function as follows: void TestDelay(uint32 delay); void TestDelay(uint32 delay) {     static volatile uint32 DelayTimer = 0;     while(DelayTimer<delay)     {         DelayTimer++;     }     DelayTimer=0; } Update the includes lines at the top of the main.c file to include the headers for the drivers used in the application: Add #include "Mcu.h" #include "Port.h" #include "Dio.h" Now, in open peripheral tools again by clicking on icon as shown below. And then click on global setting icon as shown below: And, Confirm that ComponentGenerationMethod is set to “FunctionalGroups” Build 'Blinking_LED_RTD_AUTOSAR'. Select the project name in 'C/C++ Projects' view and then press 'Build'. After the build completes, check that there are no errors. Open Debug Configurations and select 'Blinking_LED_RTD_with_AUTOSAR_Debug_RAM'. Make sure to select the configuration which matches the build type performed, otherwise it may report an error if the build output doesn’t exist. And make selection as shown in screenshot below. You need to select the ethernet connection for S32 debugger and provide its IP address Click Debug To see the LED blink, click ‘Resume' This code as it will blink the LED 10 times, you can make changes in for loop condition to blink it infinitely.

This document shows the step-by-step process to create a simple blinking LED application for the S32R41 device using the S32 RTD non-AUTOSAR drivers. For this example used for the S32R41 EVB, connected via ethernet connection through S32 Debugger. Preparation Setup the software tools Install S32 Design Studio for S32 Platform Install the S32R41 development package and the S32R41 RTD AUTOSAR 4.4. Both of these are required for the S32 Configuration Tools. Launch S32 Design Studio for S32 Platform Procedure New S32DS Project OR Provide a name for the project, for example 'Blinking_LED_RTD_No_AUTOSAR'. The name must be entered with no space characters. Expand Family S32R41, Select S32R418AB Cortex-M7 Click Next Now, uncheck the selection mark for other core, i.e. for Cortex-M7-1   And Click '…' button next to SDKs   Check box next to PlatformSDK_SAF85_S32R41_2022_08_S32R418AB _M7_0. (or whichever latest SDK for the S32R41 is installed). Click OK Click Finish. Wait for project generation wizard to complete, then expand the project within the Project Explorer view to show the contents. To control the LED on the board, some configuration needs to be performed within the Pins Tool. There are several ways to do this. One simple way by double-click on the MEX file. The schematic for S32R41 EVB, checking for signal line for the user LED, channel 4 is connected to user LED signal, so we use channel 4 for signal line for user LED on the chip. So, we select the signal line for Dio channel Id 4 for the LED connected on the S32R41 EVB. From the Peripheral Signals tab left to the Pins tool perspective layout, locate Open the Siul2_0 from the peripheral signals tab. And from the drop down menu select “gpio,36 PC_04” option as per shown in the following image. We are using PC_04 for the GPIO usage, so we are routing SIUL2_0 GPIO signal to this pin. The Direction required! menu will appear. Select Output then OK. In Routing Details view, notice a new line has been added and highlighted in yellow. Add ‘LED’ to the Label and Identifier columns for the PC_04 pin. Code Preview Go to Peripherals tool and add Siul2_Dio to enable LED blinking, it adjacent to the Blue LED on S32R41  EVB. Click on the Peripherals Tool icon from the Eclipse Perspective navigation bar. From the Components view, click on ‘Add a new configuration component…’ button from the Drivers category. This will bring up a list of all configuration components. Locate and then select the ‘Siul2_Dio’ component from the list and click OK. Do not worry about the warning message. It is only indicating that the driver is not already part of the current project. The associated driver package will be added automatically. Note: It may be necessary to change the selection at the top from ‘Present in the tool-chain project’ to ‘All’. The DIO driver provides services for reading and writing to/from DIO Channels. Also, select the Siul2_Port tab and uncheck the checkmark against ‘Siul2 IP Port Development Error Detect’ option as below. The Gpio_Dio driver requires no further configuration. Click Save to store all changes to the .MEX file. Now the device configurations are complete and the RTD configuration code can be generated. Click ‘Update Code’ from the menu bar. To control the output pin which was just configured, some application code will need to be written. Return to the ‘C/C++’ perspective. If not already open, in the project window click the ‘>’ next to the ‘src’ folder to show the contents, then double click ‘main.c’ file to open it. This is where the application code will be added. Before the pin can be controlled, it needs to be initialized using the configuration information that was generated from the S32 Configuration tools. Initialize all pins using the Port driver by adding the following line: Insert the following line into main, after the comment 'Write your code here': /* Initialize all pins using the Port driver */ Siul2_Port_Ip_Init(NUM_OF_CONFIGURED_PINS0, g_pin_mux_InitConfigArr0); Now, add logic for the LED turn and off. To turn the pin on and off with some delays in-between to cause the LED to blink. Make the delays long enough to be perceptible. Add line to initialize variable uint8 i = 0; Change the code within the provided for loop, and add the following lines: /* logic for blinking LED 10 times for (i=0; i<10; i++) {       Siul2_Dio_Ip_WritePin(LED_PORT, LED_PIN, 1U);       level = Siul2_Dio_Ip_ReadPin(LED_PORT, LED_PIN);       TestDelay(2000000);       Siul2_Dio_Ip_WritePin(LED_PORT, LED_PIN, 0U);       level = Siul2_Dio_Ip_ReadPin(LED_PORT, LED_PIN);       TestDelay(2000000); } return (0U); And add this line above the main() function to initialize the variable volatile uint8 level; Before the 'main' function, add a delay function as follows: void TestDelay(uint32 delay); void TestDelay(uint32 delay) {    static volatile uint32 DelayTimer = 0;    while (DelayTimer<delay)    {        DelayTimer++;    }    DelayTimer=0; } Update the includes lines at the top of the main.c file to include the headers for the drivers used in the application: Remove #include "Mcal.h" Add #include "Siul2_Port_Ip.h" #include "Siul2_Dio_Ip.h" Build 'Blinking_LED_RTD_No_AUTOSAR'. Select the project name in 'C/C++ Projects' view and then press 'Build'. After the build completes, check that there are no errors. Open Debug Configurations and select 'Blinking_LED_RTD_No_AUTOSAR_Debug_RAM'. Make sure to select the configuration which matches the build type performed, otherwise it may report an error if the build output doesn’t exist. Now, you need to Select the Interface (Ethernet or USB) by which the S32 Debug Probe is connected. If connected via USB and this option is selected for interface, then the COM port will be detected automatically (in the rare event where 2 or more S32 Debug Probes are connected via USB to the host PC, then it may be necessary to select which COM port is correct for the probe which is connected to the EVB) If connected via Ethernet, enter the IP address of the probe. See the S32 Debug Probe User Manual for ways to determine the IP address. Click Debug To see the LED blink, click ‘Resume'. This code, as it is, will blink the LED 10 times, you can make changes in for loop condition to blink it infinitely.

The NXP device S32R41 has accelerators that can be programmed. The S32 Debugger included within the S32 Design Studio for S32 Platform IDE with the S32 Debug Probe provides the ability to debug these accelerators. The accelerator covered in this document: Signal Processing Toolbox (SPT).   Section map: Preparation             Setup the software tools             Setup the hardware Procedure             Create A New Debug Configuration                                Start A Debug Session                         Multi-Core Preparation Setup the software tools Install S32 Design Studio for S32 Platform Install the S32R41 development package and the Radar extension package for S32R41. Both of these are required for the SPT3.5 accelerator. Setup the hardware Confirm the setup of the S32R41 evaluation board. Connect the power supply cable Setup the S32 Debug Probe. Refer to the S32 Debug Probe User Guide for installation instructions. Connect the S32 Debug Probe to the evaluation board via JTAG cable. Connect the S32 Debug Probe to the host PC via USB cable OR via Ethernet cable (via LAN or directly connected and configured for static IP address) and power supply connected to USB port. Launch S32 Design Studio for S32 Platform Open existing project or create a new project and check that it successfully builds. If creating a new project, be sure the S32 Debugger is selected in the New Project Wizard.   Procedure The procedure for starting a debug session and accessing the associated accelerator-specific registers is detailed here. Debugging SPT is only conducted through the multi-core method. The SPT executable is included within A53 executable, the A53 application loads the SPT executable to the SPT core and both A53 and SPT core are available for debugging. The debug connection is made to the two cores through the Baremetal/Bareboard method. The debugger connects to both the A53 and SPT cores using the probe over JTAG. Before a debug session can be started a debug configuration must exist.   Create A New Debug Configuration If the New Project Wizard was used to create the project using the S32DS Application Project option, then there was an opportunity to select the desired debugger from within the wizard. If the desired debugger option was selected at this time, then the needed configuration already exists and will only require adjustments to the hardware connection settings.   If the New Project Wizard was not used to create the project OR the currently desired debugger was not the one selected at the time of project creation, a new debug configuration must be created. With the existing project selected in Project Explorer, open the Debug Configurations Menu: Run -> Debug Configurations Having the existing project selected in the Project Explorer view will make the creation of a new launch configuration easier as many settings will be imported from the selected project. To select a project, click on it so it becomes highlighted. Next, select the debugger for which the new debug configuration will be created. To create the new configuration, either click on the ‘New launch configuration’ button from the toolbar at the top and to the left, or right-click on the ‘S32 Debugger’ and select ‘New Configuration’ from the menu. Once the configuration is created it will be displayed and any errors with the configuration will be shown. If the project was selected in the Project Explorer, then the Name of the debug configuration will contain the project’s name and the Project and C/C++ Application fields may be populated as well. The C/C++ Application field will only be populated if the build output executable exists. Confirm these values are correct before moving on. If the C/C++ Application field is empty, just click ‘Browse..’ button (The ‘Search Project…’ button is setup to identify standard executable file types, not the SPT’s ‘aspt’ file type) and navigate to the folder containing the build output <project name>.aspt. If you like, the tool already knows the project directory path, so you could shorten the path to start with from the ‘Debug’ folder, as shown here. There is an error showing that the Device core ID is not specified on the Debugger tab. Switch to the Debugger tab and click on the button ‘Select device and core’. From the Select Target Device and Core window, expand the listing until all cores are listed. Notice that all supported cores on the S32R41 are listed. Select the SPT35 core and click OK. Now that the device and core are selected, the attach script is selected automatically. The attach script will allow to start debugging on a core that is already initialized. This is correct for the SPT core as it is always launched in multicore scenario. Refer to the document 'README.txt' located in the same folder as these script files for details on all of the provided scripts. Confirm the setting of the ‘Initial core’ checkbox. This box should be checked within the debug configuration that establishes the first connection to the target device via S32 Debug Probe. When this box is checked, the Debug Probe Connection interface and GDB Server settings become available. The probe connection only needs to be configured once and only one GDB Server needs to be running for each debug session. When debugging the SPT3.5 core, the A53 core will always launch first, so this box should be checked for the A53 debug configuration and should not be checked for the SPT debug configuration. Check that the GDB Client section has the correct path to the SPT GDB executable. It should point to the variable ‘S32DS_R41_GDB_SPT_PATH’. Startup tab check the following settings Load image is NOT checked for multicore debugging. Basically, if it is loaded by A53 core (SPT executable is contained within A53 ELF file), then it does not need to be loaded. Load symbols is NOT checked. The SPT source file is assembly code, so there are no symbols to load. Set breakpoint at main and Resume are NOT checked for multicore debugging. After saving the new configuration with the ‘Apply’ button, SPT debugging can be performed. Start A Debug Session For convenience, the S32DS Application Project wizard was used to create a new project for demonstrating multi-core A53/SPT debugging. The SPT core does not support standalone debugging. For instructions on loading this example project to your workspace, see ‘HOWTO: S32 Design Studio - Create New Application Project’, selecting instead the Processor option Family S32R41 -> S32R41xxx Cortex-A53 SPT3 from the wizard menu. A53 / SPT Multi-Core For multi-core debugging, the A53 core is running an executable which also contains the SPT code. The A53 code will make a call into the SPT to load the SPT code to memory and to start the SPT execution. So the A53 must be started first. The EVB settings are irrelevant as the debugger will take control of the target via the JTAG connection. Before beginning the debug sessions, be sure each project is built clean. Start A53 debug. From the menu at the top, select Run -> Debug Configurations… In the Debug Configurations menu, from the configuration list, look for the ‘S32 Debugger’ group and select the A53 Debug_RAM configuration for the project to be debugged. In the case of our example, the ‘New_S32R41_SPT_Project_A53_Debug_RAM_S32Debug’ configuration. On the Debugger tab, check that the Debug Probe Connection settings match with the current hardware connection configuration for the S32 Debug Probe. Use the ‘Test connection’ button to confirm. Click Debug to start debugging on the A53 core. The debugger will launch and execute until the first executable line in main(). See Debugger tab in Debug Configurations menu to adjust this setting. Once the A53 debug session is running, advance the program counter to a line after the desired SPT kernel is loaded to memory but before the SPT kernel is launched. In the example here, this would be in ‘main.c’, line 57, where ‘StartSptProgram()’ function is called. This can be done by setting a breakpoint on the line and clicking Resume.  After the breakpoint is reached, the SPT debug session can be started. Return to the Debug Configurations menu, select the SPT debug configuration. In the case of this example, ‘New_S32R41_SPT_Project_SPT35_Debug_S32Debug’, and click Debug. Wait for the SPT debug session to launch and stop in the disassembly. Use the Step Over command one time in the A53 debug thread to complete the SPT launch. Select the SPT debug thread to change the context of the Disassembly, Registers and etc.views. Notice the SPT code is not loaded yet. Enable Instruction Stepping Mode and step one time. Notice the SPT code is now loaded. Now you can step through the assembly code, access registers, etc.

Sometimes you need an output file other than the standard ELF, like a FLASH image. This instruction shows how to setup the selected build type to generate an additional output from the supported file types.   Go to Project Properties Right click on the Project name in Project Explorer -> Properties, OR Select the Project name in Project Explorer, select from pulldown menu Project -> Properties Navigate to C/C++ Build -> Settings -> Cross Settings, check the box for ‘Create flash image’. Be sure to take note that the build configuration set in the Configuration field is correct one. The change you make here will only apply to the selected configuration. Scroll the window down until you can see the ‘Apply’ button, then click on it. You can specify output in newly appeared option Standard S32DS Create flash image Build the project. The new output file is generated.

  In some cases FreeRTOS heap can consume huge portion of RAM memory - especially on small devices like S32K312 and for example DTCM memory is unused. FreeRTOS allows user defined heap which can be moved in any section in RAM.  First step - make sure, that in FreeRTOS config is application allocated heap is disabled:   Second step - open linker script file and create new section which points into DTCM memory:     Third step - define ucHeap variable with section attribute:     We are done - FreeRTOS Heap is moved into DTCM memory:    In case, that DTCM memory is used - typically there can be Interrupt Vector Table, stack and so on, you can skip creating new section in linker script file and simply add *(my_head) at the end of existing section mapped into dtcm:    FreeRTOS heap will be placet at the end of used DTCM memory:     

There are 2 errors which produce the FNP error 0 message for which we have identified solutions:   1) That activation request yields no right to a license If you receive the following error message following an attempt to activate S32 Design Studio, this is a known issue and we have a solution.     This issue is due to a recent event. On October 1st, 2019, Flexera made this change. Since NXP uses Flexera for product activations, we were affected.   The solution to the issue is to enable support for TLS 1.2 within your Internet Properties.   2) com.acresso.activation.handler.ServerException If you receive the following error message following an attempt to activate S32 Design Studio, this is a known issue and we have a solution. This issue is known to occur on older releases of S32 Design Studio.     The version of FlexNet Publisher (FNP) used to activate the S32 Design Studio on your PC has an issue on some users machines. While we don't fully understand what change is happening to cause this issue, we have determined that an update to the version of FNP will resolve it. We have incorporated a newer version in the 3.5 release of S32 Design Studio.   Attached is a package of files (Activation.7z) which will allow you to update the version of FNP on your machine.   Enter the following command replacing the paths as noted. It should be possible to execute from CMD window located at any path. Make sure to use the ‘/’ instead of ‘\’ and if you have any paths with spaces, then enclose the full path with “.   For 64-bit OS: C:/NXP/S32DS.3.5/jre/bin/java  -Djava.library.path="{path to where you extracted the activation.zip}/Activation/cll/x64"  -jar "{path to where you extracted the activation.zip}/Activation/license.jar" activateUI   For 32-bit OS: C:/NXP/S32DS.3.5/jre/bin/java -Djava.library.path="{path to where you extracted the activation.zip}/Activation/cll/i86" -jar "{path to where you extracted the activation.zip}/Activation/license.jar" activateUI   If you have no existing S32DS installation from which to use Java, then please use the attached package (CLL_FNP.11.18.0.2.zip) and follow the instructions in the included .txt file. This package only works on Windows OS 64-bit.

     This summary records my process of using J-LINK Plus in S32 Design Studio for S32 Platform, hoping to help people who use the same tool.   1.Download the latest package: https://www.segger.com/downloads/jlink/   2.Install the downloaded package and some note will show like this.   3.Open J-Link GDB Server V7.8 , if you current firmware version is too low, you will be prompted to upgrade to the latest firmware version.       At this point ,if you use the default configuration to debug the application, the following error will appear.   Modified the "Debug configurations" for S32 Design Studio platform V3.4   Change the highlighted part to the path below. C:\Program Files (x86)\SEGGER\JLink\JLinkGDBServerCL.exe C:\NXP\S32DS.3.4\S32DS\tools\gdb-arm\arm32-eabi\bin\arm-none-eabi-gdb.exe   Modified the "Debug configurations" for S32 Design Studio platform V3.5 Change the highlight part to the path below. C:\Program Files (x86)\SEGGER\JLink\JLinkGDBServerCL.exe C:\NXP\S32DS.3.5\S32DS\tools\gdb-arm\arm32-eabi\bin\arm-none-eabi-gdb.exe   For now, you may debug your project with SEGGER J-Link Plus Tools. Hope it works for you!

For S32 Design Studio v3.5 and earlier, there is a known issue when the S32 Configuration Tools are invoked from command line from a location outside of the S32DS installation directory. The following error is reported: java.lang.reflect.InvocationTargetException at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source) at java.base/jdk.internal.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source) at java.base/java.lang.reflect.Constructor.newInstance(Unknown Source) at com.nxp.swtools.common.utils.runtime.SingletonProvider.getSingletonInstance(SingletonProvider.java:46) at com.nxp.swtools.common.ui.utils.swt.internal.SWTFactory.getSingletonInstance(SWTFactory.java:421) at com.nxp.swtools.common.ui.utils.swt.SWTFactoryProxy.getSingletonInstance(SWTFactoryProxy.java:448) at com.nxp.swtools.dcd.controller.DCDController.getInstance(DCDController.java:84) at com.nxp.swtools.dcd.DCDStartup.earlyStartup(DCDStartup.java:23) at com.nxp.swtools.provider.SWToolsPlatform.initializeAllTools(SWToolsPlatform.java:702) at com.nxp.swtools.framework.Application.start(Application.java:475) at com.nxp.swtools.framework.Application.start(Application.java:445) at org.eclipse.equinox.internal.app.EclipseAppHandle.run(EclipseAppHandle.java:203) at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.runApplication(EclipseAppLauncher.java:134) at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.start(EclipseAppLauncher.java:104) at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:401) at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:255) at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(Unknown Source) at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source) at java.base/java.lang.reflect.Method.invoke(Unknown Source) at org.eclipse.equinox.launcher.Main.invokeFramework(Main.java:654) at org.eclipse.equinox.launcher.Main.basicRun(Main.java:591) at org.eclipse.equinox.launcher.Main.run(Main.java:1462) Caused by: java.lang.NoClassDefFoundError: javafx/beans/property/SimpleBooleanProperty at com.nxp.swtools.bootimage.controller.ABootController.<init>(ABootController.java:37) at com.nxp.swtools.dcd.dcf.common.DCDCommonController.<init>(DCDCommonController.java:90) at com.nxp.swtools.dcd.controller.DCDController.<init>(DCDController.java:43) ... 24 more Caused by: java.lang.ClassNotFoundException: javafx.beans.property.SimpleBooleanProperty cannot be found by com.nxp.swtools.bootimage_1.0.0.202207251223 at org.eclipse.osgi.internal.loader.BundleLoader.findClass(BundleLoader.java:519) at org.eclipse.osgi.internal.loader.ModuleClassLoader.loadClass(ModuleClassLoader.java:170) at java.base/java.lang.ClassLoader.loadClass(Unknown Source)   Resolution: To resolve the issue: Invoke the command from within the installation directory, for example, from 'C:\NXP\S32DS.3.5\eclipse' OR Change "{S32DS Installation Folder}\eclipse\s32ds.ini" by setting the javafx path from relative to absolute. So, if default installation is used, then: Change -Defxclipse.java-modules.dir=jre/javafx-sdk-11.0.2/lib To -Defxclipse.java-modules.dir=C:/NXP/S32DS.3.5/eclipse/jre/javafx-sdk-11.0.2/lib   In addition, if it is desired to suppress unimportant warning messages: go to {S32DS installation folder}\eclipse\configuration, open logging.properties file and change com.nxp.swtools.level = SEVERE

S32 Design Studio (S32DS) supports IAR Eclipse plug-in that enables users to build and debug a S32DS project with IAR toolchain for ARM. This document describes how to install this plugin and how to enable IAR in the new project wizard. Current version of S32DS 3.4 supports IAR compilers v9.x. After the IAR eclipse plugin installation is finished you should be able to create, build and debug a new S32DS project (including SDKs) using IAR compiler/debugger interface directly under S32DS Eclipse environment.   Installation instructions First of all make sure you have IAR Embedded Workbench installed with a valid license from IAR. Now let's proceed to eclipse plug-in installation. 1. Install IAR Plugin manager  Go to menu "Help" -> "Install New Software"         Click on "Add..." button to add a new IAR repository located here: http://eclipse-update.iar.com/plugin-manager/1.0                   Tick "I Accept the terms of the license agreement" and click "Finish" to accept unsigned content software Finally you proceed to the installation. When the plugin is installed you will be asked to restart S32DS Again, go to menu "Help" -> "Install New Software" and  click on "Add..." button to add a new IAR repository located here: http://eclipse-update.iar.com/arm/9.10/                   Tick "I Accept the terms of the license agreement" and click "Finish" to accept unsigned content software Finally you proceed to the installation. When the plugin is installed you will be asked to restart S32DS Anytime you create a new workspace you will be asked to enter path to IAR Embedded Workbench IDE. Go to menu "Window" -> "Preferences", click on "IAR Embedded Workbench" menu, select “IAR Toolchain for Arm – (9.x)” in the “Installed IAR Toolchains”, and then input the IAR Embedded Workbench IDE installation path.            2. Configure IAR plugins in IAR Embedded Workbench plugin manager Start the IAR plugin manager (Menu "Help" -> "IAR Embedded Workbench plugin manager")          Select the ARM version (9.10-) and click "Install" button.           Select all the IAR components displayed and proceed to installation by clicking "Next" button.   3. New IAR project in the project wizard You can now create a new project in S32DS and select IAR toolchain for ARM instead of default GCC compiler.          There should appear a new item it the Debugger selection - "IAR plugin Debugger". Please choose this option if you intend to debug using IAR supported probes (e.g. I-jet)          IAR specific panels and settings are now displayed in the project properties for a new S32DS project with the IAR options enabled (see below).          There is a new category "IAR C-SPY Application" in the debug configurations panel that contains all the debug configurations for projects with IAR debug plugin option selected.          The Debugger perspective now offers several IAR specific Views and features.   Enjoy building and debugging with IAR Eclipse plug-in in S32DS!

Installation & Activation HOWTO: Install Wind River compiler Eclipse plug-in into S32 Design Studio  HOWTO: Install Lauterbach TRACE32 debugger plug-in into S32 Design Studio  HOWTO: Install PLS UDE debugger plug-in into S32 Design Studio HOWTO: Activate S32 Design Studio    Getting Started HOWTO: Create a Blinking LED Project (MPC5748G)  HOWTO: Build a Project and Setup a Debug Configuration for debugging in S32 Design Studio   Build tools & standard libraries HOWTO: Run a routine from RAM in S32 Design Studio   HOWTO: Use printf() function and EWL library  HOWTO: Migrate project created in S32DS Power v1.x into v1.2+  HOWTO: Add a static library file into S32DS GCC project  HOWTO: Link a binary file(s) into the application project using GNU build tools  HOWTO: Execute a library function from RAM memory using GNU build tools  NEW!   Debug & Flash Programming HOWTO: download separate elf/srec/hex file to microcontroller using S32 Design Studio  HOWTO: Program data flash (DFLASH) in S32 Design Studio for Power  HOWTO: Program DCF record into UTEST flash in S32 Design Studio for Power  HOWTO: debug multi-core project in S32 Design studio  HOWTO: Update OpenSDA Firmware on EVB  HOWTO: MPC5777C - Low/Mid Flash block erase via PE Micro   HOWTO: Use RappID BL tool with MPC5744p EVB  HOWTO: Debug multiple elf files in S32 Design Studio  HOWTO: Reset MCU in S32 Design Studio debugger (Pemicro/OpenSDA interface)  HOWTO: Program multiple memory types in single debug session  NEW!   SDKs HOWTO: Working with AMMCLib SDKs  HOWTO: Working with FreeMASTER SDKs  HOWTO: Add custom SDK into existing project  HOWTO: Use SDK based example code as standalone (usable for GIT, SVN...) NEW!   General Usage HOWTO: S32 Design Studio Command Line Interface  HOWTO: Add user example into S32DS  HOWTO: Generate S-Record/Intel HEX/Binary file  HOWTO: Update S32 Design Studio  How to export Generated Code to S32 Design Studio IDE (applicable for MBDT for MPC5744P v2.0)   HOWTO: Install update from 3rd party vendor  S32 Design Studio for Power Architecture v2.1 Migration Guide  HOWTO: Set project optimization level    Troubleshooting Troubleshooting: Issue opening documents from Getting Started page  Troubleshooting: PEmicro Debug Connection: Target Communication Speed  Troubleshooting: Indexer errors on header file  S32 Design Studio Offline activation issue hot fix  Troubleshooting: Installer rolls back immediately following activation code entry  Troubleshooting: Activation fails with error message FNP ERROR 0 

The S32K3 RTD 2.0.0 lacks SIUL2 external interrupt function. Siul2_Icu is part of Icu(Input Capture Unit), the main function of the example should have been: use the Icu and Dio drivers to toggle a LED on a push button. But it doesn't. So this document will show the step-by-step process to add 'SIUL2 external interrupt' function in Siul2_Port_Ip_Example_S32K344 using the S32K3xx RTD LLD(Low Level Driver) and the S32 Configuration Tools. This example is for the S32K3X4EVB-Q257, connected to a PC through USB (OpenSDA) connection. Preparation Setup the software tools Install S32 Design Studio for S32 Platform Install the S32K1xx development package and the S32K1 RTD AUTOSAR 4.4. Both of these are required for the S32 Configuration Tools. Launch S32 Design Studio for S32 Platform Procedure 1. Import Siul2_Port_Ip_Example_S32K344 example File->New->S32DS Project from Example It can be seen that in the Icu (Input Capture Unit Driver) folder of S32K3 RTD 2.0.0, there are only interrupt routines implemented by the Emios module for the time being, and external interrupt routines for the EIRQ pin of the Siul2 module does not exist. Here we import the Siul2_Port_Ip_Example_S32K344 routine, and add the Siul2_Icu part on this basis.   2. Add push button and LED in Pins tool Add the pins for user buttons (SW4 PTB26 SIUL2 eirq13) according to the S32K3X4EVB-Q257.   3. Add IntCtrl_Ip component Go to Peripherals tool. Here we can see that the ‘Siul2_Dio’ and ‘Siul2_Port’ components are already added. From the Components view, click on ‘Add a new configuration component…’ button from the Drivers category. This will bring up a list of non-AUTOSAR components. Locate and then select the ‘IntCtrl_Ip’ component from the list and click OK. Option 1: Keep the default setting after add ‘IntCtrl_Ip’ component(Here we didn't change the settings of ‘IntCtrl_Ip’, nor use IntCtrl_Ip_Init and IntCtrl_Ip_ConfigIrqRouting API to enable interrupts and install handlers in IntCtrl_Ip).This routine only uses one interrupt, so we will call IntCtrl_Ip_InstallHandler and IntCtrl_Ip_EnableIrq those two APIs to install and enable the SIUL2 EIRQ13 IRQ separately. Option 2: User can enable many interrupts in the Interrupt Controller configuration(Note user can only add one interrupt controller configuration in the RTD); Meanwhile, it can set interrupt’s priority separately. The two APIs IntCtrl_Ip_Init and IntCtrl_Ip_ConfigIrqRouting can initialize these interrupts as a whole. The name of the Handler in the Generic Interrupt Settings tab needs to be the same as the name in peripheral_Ip_Irq.c of the corresponding peripheral. For example, this routine uses the PTB26 SIUL2 EIRQ13 external interrupt, which can be found in RTD/src/Siul2_Icu_Ip_Irq.c: ISR(SIUL2_EXT_IRQ_8_15_ISR) According to the "Table 35" of S32K3XXRM reference manual, we can see the SIUL2 EIRQ13(PTB26) external interrupt used in this routine belongs to SIUL_1_IRQn and the Handler name SIUL2_EXT_IRQ_8_15_ISR.   4. Add Siul2_Icu component Click on ‘Add a new configuration component…’ button from the Drivers category. Locate and then select the ‘Siul2_Icu’ component from the list and click OK. Step 5 select SIUL2_0_IRQ_CH_13 because this routine selects the onboard SW4 PTB26 SIUL2 EIRQ13 external interrupt (the onboard SW5 PTB19 pin has no EIRQ external interrupt function, so I did not added here). Step 6 set DIRER0[EIREn] to enable this external interrupt pin. Step 8 set the IFCPR[IFCP] filter clock prescaler. Step 10 input 13 for the Hardware channel due to we use SIUL2 EIRQ13. Step 11 set IFER0[IFEn] to enable the glitch filter for the external interrupt pin. Step 12 set IFMCRn[MAXCNT] to assign value to the external interrupt filter counter. Step 14 select the IcuSiu2Channel_0 channel configured in the IcuSiul2 tab above. Step 15 select the ICU_RISING_EDGE according to the SW4 button circuit (press to generate a rising edge). Step 16 Because the SIUL2 EIRQ external interrupt is used in this routine, ICU_MODE_SIGNAL_EDGE_DETECT mode must be selected. Step 17 add the corresponding callback function name. That is, it corresponds to the notification after the SIUL2 EIRQ external interrupt pin captures the rising edge (the interrupt flag does not need to be cleared here, the driver has already been implemented it).   5. Include the headers for the drivers used in the application #include "Siul2_Icu_Ip.h" #include "IntCtrl_Ip.h"   6. Add Siul2_Icu LLD APIs Siul2_Icu_Ip_Init is used to initialize all Siul2_Icu channels generated by the S32 Configuration Tools (this routine only configures the channel SW4 PTB26 SIUL2 EIRQ13). Siul2_Icu_Ip_EnableInterrupt enable Siul2 IRQ interrupt for the specified channels. Siul2_Icu_Ip_EnableNotification enable callback function of Siul2 IRQ interrupt for the specified channels. This routine uses the SW4 button to trigger the PTB26 SIUL2 EIRQ13 external interrupt callback function SW4_eirq13_PTB26_Callback to flip the PTB18 D33 red LED.   7. Add IntCtrl LLD APIs IntCtrl_Ip_InstallHandler installs the SIUL2_EXT_IRQ_8_15_ISR interrupt handler generated by the S32 Configuration Tools. IntCtrl_Ip_EnableIrq enables the corresponding interrupt. Why input SIUL_1_IRQn and SIUL2_EXT_IRQ_8_15_ISR has been explained at the end of "4. Adding the IntCtrl_Ip component" above. References - S32K3xx Pins and Clocks with RTD - Training - AN13435: SDK/MCAL to Real-Time Drivers - Integration Manual for S32K3 ICU Driver （RTD_ICU_IM.pdf） - User Manual for S32K3 ICU Driver （RTD_ICU_UM.pdf） - Integration Manual for S32K3 PLATFORM Driver (RTD_PLATFORM_IM.pdf) - User Manual for S32K3 PLATFORM Driver (RTD_PLATFORM_UM.pdf)

Users can now get the AMMCLib for S32K3 in S32DS 3.4 if they manually add the following URL to the list of “Available S32DS Software Sites”: http://www.nxp.com/lgfiles/updates/Eclipse/AMMCLIB/S32DS_3.5 (the URL will be auto-added with the upcoming S32DS 3.5 release). From within S32 Design Studio for S32 Platform 3.4, launch S32DS Extensions and Updates menu (Help -> S32DS Extensions and Updates), then select 'Add Update Sites'. Please note that the S32K3XXMCLUG.pdf User’s Guide incorrectly indicates that the library is available as a standalone SDK, which is incorrect. AMMCLib for S32K3 is part of the “PlatformSDK” system which means that users must use the RTD for S32K3 in their S32DS project to gain access to AMMCLib:   Then they must activate the „S32 Configuration Tool“ (CT):   Within the CT, they must click on the „Peripherals“, then „Libraries“, and select „AMMCLib“ from the list:   Then they must click on „Update code“, to update the paths in the project: