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

This document shows the step-by-step process for creating a simple blinking LED application for the S32Z27x family using the S32 RTD non-AUTOSAR drivers. This example used for the S32Z27x-DC EVB, which is connected via an Ethernet connection through the S32 Debugger.   Preparation  Setup the software tools  Install S32 Design Studio for S32 Platform   Install the S32Z2/E2 development package and the S32ZE RTD AUTOSAR R21-11 Version 0.9.0 P01 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 the Family ‘S32Z27x’, and Select ‘S32Z270 (Boot core_ R52_0_0)’      Click '…' button next to SDKs    Check box next to PlatformSDK_S32ZE_2022_10_S32Z270_R52_0_0_LS (or whichever latest SDK for the S32M27x is installed). Click OK     Click "Finish" and wait for the project generation wizard to complete. Then, expand the project within the "Project Explorer" view to show its 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 is to double-click on the .MEX file.    By default, the Pins Tool will be presented. The S32Z27x DC EVB has user D12 LED connected to the PA_01 pin on the S32Z270 device.    To configure this pin, select the "Peripheral Signals" tab to the left of the Pins Tool perspective layout. Locate and open the SIUL2_0 from the peripheral signals tab, and from the drop-down menu, select the "gpio,1 PA_01" option as shown in the following image.  We are using Siul2_0 for GPIO usage, so we are routing the gpio,1 –> PA_01 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 Siul2_0, gpio-1 pin.    Code Preview    Go to Peripherals tool and add Gpio_Dio to enable LED blinking, it adjacent to the user LED on S32Z270 EVB.    Click on the Peripherals Tool icon in the Eclipse Perspective navigation bar.  In the Components view, click on the ‘Add a new configuration component…' button in the Drivers category. This will bring up a list of all configuration components.    Locate and select the 'Siul2_Dio' component from the list and click OK. Don't worry about the warning message – it's only indicating that the driver isn't 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 toolchain project' to 'All'.  The Siul2_Dio driver provides services for reading and writing to/from DIO Channels.     Now, form the toolbar selection menu at the top, select and double click on the symbol as shown as below:     Then, from the global settings window, for ComponentGenerationMethod from the drop down menu select “FunctionalGroups” from the drop down menu as shown below:     The Siul2_Dio driver requires no further configuration. Click Save to store all changes to the .MEX file.       Now. click ‘Update Code’ from the menu bar.  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 the 'src' folder is not already open in the project window, click the '>' symbol next to it to show its contents. Then, double-click the 'main.c' file to open it. This is where you will add the application code.    To control the pin, it needs to be 'initialized' using the configuration information generated from the S32 Configuration tools. To do this, add the following line to the 'main' function 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 to turn the LED on and off with some delays in between to make it visible blinking. Make sure the delays are long enough to be perceptible.     Add line to initialize variable uint8 i = 0;  Add line to declare variable level: volatile uint8 level;  Change the code within the provided for loop, and add the following lines:     /*logic for blinking LED 10 times*/     for (; i<10; i++)       {           Siul2_Dio_Ip_WritePin(LED_PORT, LED_PIN, 1U);         level = Siul2_Dio_Ip_ReadPin(LED_PORT, LED_PIN);           TestDelay(480000);           Siul2_Dio_Ip_WritePin(LED_PORT, LED_PIN, 0U);         level = Siul2_Dio_Ip_ReadPin(LED_PORT, LED_PIN);           TestDelay(480000);       }     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 apply and 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.     

There are a number of existing ISP Graph diagrams provided within the VSDK. It is possible to import them into S32DS and use them in a new C/C++ project. The steps to do this are detailed within this document. Prerequisite Before following the steps in this HOWTO, ensure you have the Vision Extension Package for V2xx (as well as the S32V2xx development package) installed to S32DS. 1) Launch S32DS 2) Select File -> New -> S32DS Application Project. 3) Enter a project name, such as: ISP_ISP_Generic_demo 4) Select 'A53 APEX/ISP Linux' 5) Click Next 6) Deselect the APEX2 options and 'ISP Visual Modeling' option. 7) Click Finish 😎 Select File -> New -> S32DS Project from Example. 9) Select isp_generic. 10) Select Finish 11) Open isp_generic in the project explorer 12) Double-click ISP data flow ; isp_generic. The ISP data flow graph will appear in the editor 13) Define a new configuration for emitting code from the graph       a) Right-click in the ISP data flow window and select Emit As -> Emit Configurations...       b) Select ISP Emitter       c) Press New Launch Configuration       d) Enter a name       e) To select the graph, press Browse Workspace       f) Expand each item until you can select the .isp file. Click OK       g) Select the location of the emitted output to the application project, select Browse Workspace       h) Select the name of your application project, then press OK       i) Enter 'A53_gen' to the Dynamic sequences sources folder box. This is the folder within the target project that generated code will be stored. Check the box for Emit host code.       j)Now select the location to store the configuration file. Go to the Common tab, select Shared file and click Browse       k) Select the .launches folder inside ISP_ISP_Generic_demo and click OK       l) Click Apply and Emit. Dialog box will appear when code generation is successful              m) Expand the folders within ISP_ISP_Generic_demo, A53_gen, src and inc, to see the newly generated output files 14) Build the project 'ISP_ISP_Generic_demo' for ISP 15) Open file 'ISP_ISP_Generic_demo/A53_inc/isp_user_define.h', by double clicking on it in the Project Explorer. Change '#define DCU_BPP DCU_BPP_YCbCr422' to '#define DCU_BPP DCU_BPP_24' and change '#define __DCU_BPP' to "#undef __DCU_BPP". Before After 16) Using the method detailed in steps 8 - 10, create the example project 'isp_sonyimx224_csi_dcu'. Take from this project the file 'isp_sonyimx224_csi_dcu/A53_src/main.cpp' and use it to replace the file 'ISP_ISP_Generic_demo/A53_src/main.cpp' in the current project. Then make the following modifications:  On line 36, change <#include "mipi_simple_c.h"> to <#include "isp_generic_c.h">. On line 303, change <gpGraph_mipi_simple> to <gpGraph> AND <gGraphMetadata_mipi_simple> to <gGraphMetadata> On line 330, change <FDMA_IX_FastDMA_Out_MIPI_SIMPLE> to <FDMA_IX_ISP_OUTPUT>. Please see C:\NXP\S32DS.3.1\S32DS\software\VSDK_S32V2_RTM_1_3_0\s32v234_sdk\docs\drivers\SDI_Software_User_Guide.pdf for details on what this code is for. 17) In Project Explorer, right-click on "...\A53_gen\src\isp_process.cpp" and select Build path -> Remove from -> A53 18) Select 'ISP_ISP_Generic_demo:A53' in the Project Explorer panel, then Build for A53 19) Run it remotely on the target using the method fromHOWTO: Create S32V234 Cortex-A53 Linux Project in S32DS . Should get results similar to this:

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

One of the many great features of the S32DS is the ability to access the Linux BSP file system on the SD card in the S32V234-EVB. Once connected, you can drag and drop files between your PC and the EVB. Once you have completed HOWTO: Setup S32V234 EVB2 for debugging with S32DS and Linux BSP  and HOWTO: Setup A Remote Linux Connection in S32DS (S32V234), you are ready to setup the Remote Systems view to connect to the Linux files system to view and access the file system. Prerequisite Before starting this procedure, make sure the BSP is loaded onto the SD Card, the SD Card is inserted into the SD Card Slot, the ethernet cable is connected to both the EVB and the network port, and the EVB is powered up. 1) Go to 'Window -> Show View -> Other' 2) Expand 'Remote Systems', then select "Remote Systems' and click OK 3) Click 'Define a connection to remote system' button OR right-click in the Remote Systems window and select 'New Connection...' from the list Right-click menu 4) Select 'SSH Only' 5) Enter the IP address noted from HOWTO: Setup A Remote Linux Connection in S32DS (S32V234) for Host name, enter a descriptive name for the connection (optional) and click Finish. 6) Right-click on the connection name in the Remote Systems window and select 'Connect' OR expand the folders under the connection name until the login window appears: Connection_name -> Sftp Files -> Root (window appears) 7) Enter "root" for User ID and since the BSP comes with ID root without a set password, leave the password field blank. 😎 Click OK 9) The Linux file system is now visible in the Remote Systems window. You can drag and drop files to and from here. Expand the folders to see the contents.

S32DS for Vision contains many example projects from which you can learn how S32DS, with the Vision Extension Package for V2xx, can be used with the help of the Vision SDK to develop vision applications. The example projects contain generated and hand-written code, which utilize the Vision SDK to demonstrate a workflow using S32DS. In this document, the procedure for creating a project from one of the provided APEX2 examples through to execution on the EVB is detailed. Prerequisite Before following the steps in this HOWTO, ensure you have the Vision Extension Package for V2xx (as well as the S32V2xx development package) installed to S32DS. 1) Launch S32DS 2) Select 'New S32DS Project from example' 3) Select apex2_fast9 project 4) Click Finish 5) Select apex2_fast9: A53 in the Project Explorer panel. Build the project using build config 'TEST_A53'. 6) Start a debug session using method as described in HOWTO: Create A53 Linux Project in S32DS for Vision, beginning at step 9. 7) Click Resume  Should see something similar to what is pictured below There are green diamonds at the corners in the image as identified by the fast9 corner detection algorithm

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