### EWARM/MDK-ARM Project Setup

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Examples/CRYP/CRYP_SAES_WrapKey/README.md

Steps to rebuild and load an STM32 example project using IAR Embedded Workbench (EWARM) or Keil MDK-ARM. This involves rebuilding specific sub-projects and loading the application into internal Flash and external memory.

```text
1. Open your preferred toolchain (EWARM or MDK-ARM).
2. Rebuild all files from the sub-project 'Appli'.
3. Load your images into memories. The 'Boot_XIP.hex' file will be loaded into internal Flash first, followed by the 'Appli' part into external memory.
```

--------------------------------

### STM32CubeIDE Debug Configuration

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/CORDIC/CORDIC_Exp_DMA/README.md

Configuration steps for STM32CubeIDE to debug the example project, including adding external loaders and setting up the debug profile for projects with or without a boot project.

```APIDOC
STM32CubeIDE Debug Setup:

1. Compile the example/application.
2. Open Run -> Debug configuration.
3. Double-click [STM32 C/C++ Application] to create a default debug configuration.
4. In the [Debugger] tab, section "External loaders":
   - Click [Add].
   - Select the appropriate loader (e.g., MX25UW25645G_NUCLEO-H7S3L8.stldr or MX66UW1G45G_STM32H7S78-DK.stldr).
   - Ensure "Enabled" is checked and "Initialize" is unchecked.
5. In the "Misc" section, uncheck "Verify flash download".
6. In the [Startup] tab, section "Load Image and Symbols":
   - If project contains a boot project:
     - Click [Add] -> Project, select boot project.
     - Set Build configuration to "Use active".
     - Check "Perform build" and "Download". Uncheck "Load symbols".
   - If project does not contain a boot project:
     - Click [File System], select Boot_XIP.hex (may require typing '*' to see .hex files).
     - Check "Download". Uncheck "Load symbols". Click Ok.
   - Move the boot project to the second position in the list.

Note: Ensure the "active configuration" is set to "debug" for full debug capabilities.
```

--------------------------------

### EWARM/MDK-ARM Build and Load

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/CORDIC/CORDIC_Exp_DMA/README.md

Instructions for building and loading the example project using EWARM (IAR Embedded Workbench) and MDK-ARM (Keil MDK).

```APIDOC
EWARM/MDK-ARM Build and Load:

1. Open your preferred toolchain (EWARM or MDK-ARM).
2. Rebuild all files from the sub-project 'Appli'.
3. Load your images into memories:
   - The Boot_XIP.hex file is loaded into internal Flash.
   - The 'Appli' part is loaded into the External memory on the NUCLEO-H7S3L8 board.
4. Run the example.
```

--------------------------------

### STM32H7RS LPUART Wake Up Example Setup

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples_LL/LPUART/LPUART_WakeUpFromStop_Init/readme.html

Instructions for setting up the hardware and software environment for the LPUART Wake Up From Stop example. This includes connecting the STM32 MCU board's LPUART1 TX/RX pins to a PC's COM port and configuring the serial communication software.

```APIDOC
HardwareSoftwareEnvironment:
  Device: STM32H7S3L8Hx
  Board: NUCLEO-H7S3L8
  Setup:
    1. Connect STM32 MCU board LPUART1 TX pin (GPIO PA9) to PC COM port RX signal.
    2. Connect STM32 MCU board LPUART1 RX pin (GPIO PA10) to PC COM port TX signal.
    3. Connect STM32 MCU board GND to PC COM port GND signal.
  PC Software Configuration:
    - Use a serial communication tool (e.g., HyperTerminal, TeraTerm).
    - Configure settings: 115200 bauds, 8 data bits, 1 stop bit, no parity, no HW flow control.
```

--------------------------------

### STiROT Boot Path Application Menu Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Applications/ROT/STiROT_Appli/readme.html

An example of the main menu displayed by the STiROT boot path application upon startup. It shows options for starting different functions.

```APIDOC
=================== Main Menu =============================
   Start < Function A > -------------------------------------------------- 1
   Start < Function B > -------------------------------------------------- 2
   Selection :
```

--------------------------------

### Hardware and Software Environment

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples_LL/USART/USART_Com_Tx_IT_VCP_Init/readme.html

Specifies the target hardware (STM32H7S3L8Hx devices, NUCLEO-H7S3L8 board) and software environment required for the example. It also details the necessary PC setup for HyperTerminal communication.

```text
* This example runs on STM32H7S3L8Hx devices.
    
* This example has been tested with NUCLEO-H7S3L8 board and can be easily tailored to any other supported device and development board.    
* NUCLEO-H7S3L8 Set-up    
* Please ensure that USART communication between the target MCU and ST-LINK MCU is properly enabled on HW board in order to support Virtual Com Port (Default HW SB configuration allows use of VCP)
* Launch serial communication SW on PC (as HyperTerminal or TeraTerm) with proper configuration (115200 bauds, 8 bits data, 1 stop bit, no parity, no HW flow control).
* Launch the program. Press on User push button on board to initiate data transfer.
```

--------------------------------

### EWARM/MDK-ARM Project Setup

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Examples/SD/SD_ReadWrite_DMALinkedList/README.md

Instructions for setting up projects in IAR Embedded Workbench for ARM (EWARM) and Keil MDK-ARM. This involves rebuilding sub-projects and loading specific HEX files into memory.

```APIDOC
EWARM and MDK-ARM Setup:

1.  **Open Toolchain**: Launch your preferred IDE (EWARM or MDK-ARM).
2.  **Rebuild Sub-projects**: Rebuild all files from the sub-project named 'Appli'.
3.  **Load Images**: Load the generated images into the target memories. The process typically involves loading 'Boot_XIP.hex' into internal Flash first, followed by the 'Appli' part into external memory on the NUCLEO-H7S3L8 board.
4.  **Run Example**: Execute the application on the target hardware.
```

--------------------------------

### STM32CubeIDE Debug Configuration

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/PKA/PKA_ECDSA_Sign/README.md

Detailed steps to configure the debug profile in STM32CubeIDE for the STM32H7S3L8 example project. This includes adding external loaders, setting up memory initialization, and configuring image loading for projects with or without a bootloader.

```APIDOC
STM32CubeIDE Debug Configuration:

1. Compile the example/application. Ensure the 'debug' active configuration is selected for full debug capabilities.

2. Navigate to [Run] -> [Debug configuration].

3. Double-click [STM32 C/C++ Application] to create or select a default debug configuration.

4. Configure the Debugger Tab:
   - In the [Debugger] tab, locate the "External loaders" section.
   - Click [Add] to select the appropriate loader for your board/memory (e.g., MX25UW25645G_NUCLEO-H7S3L8.stldr or MX66UW1G45G_STM32H7S78-DK.stldr).
   - Ensure the "Enabled" option is checked and "Initialize" is unchecked.
   - In the "Misc" section, uncheck the "Verify flash download" option.

5. Configure the Startup Tab:
   - In the [Startup] tab, under the "Load Image and Symbols" section, click [Add].
   - If your project includes a boot project:
     - Click "Project", select the boot project.
     - Set Build configuration to "Use active".
     - Check "Perform build" and "Download".
     - Uncheck "Load symbols".
   - If your project does not include a boot project:
     - Click [File System] and select the Boot HEX file (e.g., Boot_XIP.hex, found in the [Binary] folder of Template_XIP projects). You may need to type " * " to enable file selection.
     - Check "Download".
     - Uncheck "Load symbols".
     - Click Ok.
   - In the [Startup] tab, ensure the boot project (if applicable) is positioned second in the list.

6. Your debug configuration is now ready.
```

--------------------------------

### JavaScript Initialization and Search Box Setup

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/Zone/html/zTInstall.html

Contains common JavaScript code patterns for document ready events, search box initialization, and navigation tree setup, typical in web-based documentation generated by tools like Doxygen.

```javascript
$(document).ready(initResizable);
$(window).load(resizeHeight);
$(document).ready(function() { searchBox.OnSelectItem(0); });

var searchBox = new SearchBox("searchBox", "search",false,'Search');

$(document).ready(function(){initNavTree('zTInstall.html','');});
```

--------------------------------

### Usage Instructions

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples_LL/USART/USART_Com_Tx_IT_VCP_Init/readme.html

Provides step-by-step instructions on how to build, load, and run the example code on the target hardware using a preferred toolchain.

```text
In order to make the program work, you must do the following :

* Open your preferred toolchain
* Rebuild all files and load your image into target memory
* Run the example
```

--------------------------------

### CubeIDE Debug Configuration - Load Image and Symbols

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/TIM/TIM_OCToggle/README.md

Steps for configuring the CubeIDE debugger to load application images and symbols, including handling boot projects and external HEX files.

```APIDOC
CubeIDE Debug Configuration - Load Image and Symbols:

1. In the [Startup] tab, section "Load Image and Symbols":
   - Click [Add].
   - If your project contains a boot project:
     - Click "Project" and select the boot project.
     - Select "Use active" for Build configuration.
     - Check "Perform build".
     - Check "Download".
     - Uncheck "Load symbols".
   - If your project does not contain a boot project:
     - Click [File System] and select the Boot HEX file (e.g., Boot_XIP.hex).
       - Note: You may need to force selection of .hex files by typing " * " + Enter in the file name dialog.
     - Check "Download".
     - Uncheck "Load symbols".
     - Click Ok.
2. Back in the [Startup] tab, ensure the boot project (if applicable) is in the second position.

Parameters:
  - Project: Selects a project for building and downloading.
  - Build configuration: Specifies the build configuration to use (e.g., "Use active").
  - Perform build: Boolean, triggers a build before downloading.
  - Download: Boolean, enables downloading the image to the target.
  - Load symbols: Boolean, enables loading debug symbols (typically unchecked for this setup).
  - File System: Selects a binary file (e.g., .hex) to download.
  - Boot HEX file: The specific HEX file for the bootloader (e.g., Boot_XIP.hex).

Related Settings:
  - Ensure the boot project is positioned correctly in the load order if multiple images are used.
```

--------------------------------

### STM32 RTOS Kernel Initialization Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/RTOS2/html/group__CMSIS__RTOS__KernelCtrl.html

Demonstrates the basic setup for an STM32 application using CMSIS-RTOS. It includes system initialization, kernel initialization, thread creation, and starting the RTOS scheduler.

```C
#include "RTE_Components.h"

#include CMSIS_device_header

#include "cmsis_os2.h"

/*----------------------------------------------------------------------------
 * Application main thread
 *--------------------------------------------------------------------------*/
void app_main (void *argument) {
  // ...
  for (;;)
}

int main (void) {
  // System Initialization
  SystemCoreClockUpdate();

  // ...

  osKernelInitialize(); // Initialize CMSIS-RTOS
  osThreadNew(app_main, NULL, NULL); // Create application main thread
  osKernelStart(); // Start thread execution

  for (;;)
}
```

--------------------------------

### Directory Structure

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples_LL/USART/USART_Com_Tx_IT_VCP_Init/readme.html

Lists the key files and their locations within the example project directory, including interrupt handlers, main program files, and system configuration.

```text
* USART/USART_Com_Tx_IT_VCP_Init/Boot/Inc/stm32h7rsxx_it.h Interrupt handlers header file
* USART/USART_Com_Tx_IT_VCP_Init/Boot/Inc/main.h Header for main.c module
* USART/USART_Com_Tx_IT_VCP_Init/Boot/Inc/stm32_assert.h Template file to include assert_failed function
* USART/USART_Com_Tx_IT_VCP_Init/Boot/Src/stm32h7rsxx_it.c Interrupt handlers
* USART/USART_Com_Tx_IT_VCP_Init/Boot/Src/main.c Main program
* USART/USART_Com_Tx_IT_VCP_Init/Boot/Src/system_stm32h7rsxx.c STM32H7RSxx system source file
```

--------------------------------

### Sample Application Menu Output

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Applications/ROT/STiROT_Appli/README.md

An example of the application's main menu as displayed on a UART console. This output indicates successful startup and presents options for user interaction.

```text
=================== Main Menu =============================
   Start < Function A > -------------------------------------------------- 1
   Start < Function B > -------------------------------------------------- 2
   Selection : 
```

--------------------------------

### Main Menu Console Output Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Applications/ROT/OEMiROT_Appli/README.md

This snippet displays the typical main menu output shown on the UART console after the OEMiROT_Appli application starts. It guides the user on how to interact with the bootloader for firmware updates.

```text
=================== Main Menu =============================
    Start BootLoader -------------------------------------- 1
    Selection : 

```

--------------------------------

### SysTick_Config Example (Cortex-M)

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/Core/html/group__SysTick__gr.html

Demonstrates how to initialize and start the SysTick timer for periodic interrupts, typically used for millisecond timing or OS tick. Includes a SysTick interrupt handler and main function setup.

```c
#include "LPC17xx.h"

volatile uint32_t msTicks = 0; /* Variable to store millisecond ticks */ 

void SysTick_Handler(void) { /* SysTick interrupt Handler. */
    msTicks++; /* See startup file startup_LPC17xx.s for SysTick vector */
}

int main (void) {
    uint32_t returnCode;
    returnCode = SysTick_Config(SystemCoreClock / 1000); /* Configure SysTick to generate an interrupt every millisecond */
    if (returnCode != 0) { /* Check return code for errors */
        // Error Handling
    }
    while(1);
}
```

--------------------------------

### CubeIDE Debug Configuration - Startup Image Loading

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Examples/LTDC/LTDC_ColorKeying/README.md

Details on how to configure the startup sequence in STM32CubeIDE for projects involving a bootloader, specifying how the boot project and application image should be loaded and executed.

```text
In CubeIDE, go to the [Startup] tab.
In the "Load Image and Symbols" section:
1. Click [Add].
2. If a boot project exists:
   - Click "Project", select the boot project.
   - Select "Use active" for Build configuration.
   - Check "Perform build" and "Download". Uncheck "Load symbols".
3. If no boot project:
   - Click [File System], select Boot_XIP.hex (found in [Binary] folder).
   - Check "Download". Uncheck "Load symbols".
4. Ensure the boot project (if used) is positioned second in the startup sequence.
```

--------------------------------

### Arm Keil MDK Project Setup Steps

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/Zone/html/zTEM2351.html

Provides a step-by-step guide for importing, building, and debugging the CMSIS-Zone example project for the Nuvoton NuMicro M2351 using the Arm Keil MDK IDE.

```text
1. Navigate to Examples/M2351/MDK
2. Open the multi-project workspace TrustZone.uvmpw
3. Optional: Update the generated files by executing the copy_gen.bat scripts in Secure\mdk and NonSecure\mdk folders.
4. Run the batch build in MDK. Both projects, Secure and NonSecure need to be compiled in order.
5. Set `Secure` as active project.
6. Connect the NuMaker-PFM-M2351 board using a Micro-USB cable at ICEJ.
7. Open **Options for Target - Debug** and make sure that the NULink Debugger is selected.
8. Launch a debug session and watch LEDG and LEDY blinking.
```

--------------------------------

### Provisioning and Scripting

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Applications/ROT/STiROT_Appli/README.md

Scripts used for project setup and execution. This includes environment setup scripts (env.bat/env.sh), the main provisioning script (provisioning.bat/provisioning.sh), and scripts for debug authentication and regression testing (regression.bat & dbg_auth.bat).

```bash
# ROT_Provisioning/env.bat or ROT_Provisioning/env.sh
# Sets up environment variables, including stirot_boot_path_project.
```

```bash
# ROT_Provisioning/STiROT/provisioning.bat or provisioning.sh
# Executes the provisioning process, updating linker files.
```

```bash
# ROT_Provisioning/DA/regression.bat & ROT_Provisioning/DA/dbg_auth.bat
# Scripts for regression testing and debug authentication.
```

--------------------------------

### CMSIS-DSP FFT Bin Example Setup

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/DSP/html/arm_fft_bin_example_f32_8c-example.html

Demonstrates the setup and configuration for an FFT bin calculation example using the CMSIS-DSP library. It includes necessary includes, defines, and variable declarations for processing.

```c
#include "arm_math.h"
#include "arm_const_structs.h"
#if defined(SEMIHOSTING)
#include <stdio.h>
#endif

#define TEST_LENGTH_SAMPLES 2048

extern float32_t testInput_f32_10khz[TEST_LENGTH_SAMPLES];
static float32_t testOutput[TEST_LENGTH_SAMPLES/2];

uint32_t fftSize = 1024;
uint32_t ifftFlag = 0;
uint32_t doBitReverse = 1;
arm_cfft_instance_f32 varInstCfftF32;

/* Reference index at which max energy of bin ocuurs */

```

--------------------------------

### STiROT Provisioning Scripts (Windows)

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Templates/Template_ROT/STiROT_Appli/README.md

Scripts used for the STiROT provisioning process on Windows. This includes setting up the environment and executing the provisioning steps, which automatically update linker files.

```batch
@echo off

REM Set application project via variable
set stirot_boot_path_project=application_example

REM Start provisioning process
call ROT_Provisioning\STiROT\provisioning.bat
```

--------------------------------

### CMSIS-Zone Installation Instructions

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/Zone/html/zTInstall.html

Provides instructions on how to install the CMSIS-Zone utility by referencing the CMSIS-Pack Eclipse Plug-ins release page. It includes links to the relevant GitHub repository for installation steps.

```text
The CMSIS-Zone utility is part of the [**CMSIS-Pack Eclipse Plug-ins**](https://github.com/ARM-software/cmsis-pack-eclipse/releases/latest).

Follow the instructions on the release page to install the tool.
```

--------------------------------

### CubeIDE Debug Configuration - Startup Image Loading

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/I2C/I2C_TwoBoards_AdvComIT/README.md

Configuration for loading application images and symbols in CubeIDE's startup settings, including handling boot projects and HEX files.

```IDE Configuration
Startup Tab -> Load Image and Symbols -> Add

If project contains boot project:
  Project: Select boot project
  Build configuration: Use active
  Perform build: checked
  Download: checked
  Load symbols: unchecked

If project does not contain boot project:
  File System: Select Boot_XIP.hex
  Download: checked
  Load symbols: unchecked

Move boot project to second position in Startup tab.
```

--------------------------------

### Install Mbed TLS and PSA Headers

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Middlewares/Third_Party/mbed-crypto/include/CMakeLists.txt

Configures CMake to install Mbed TLS and PSA header files. It conditionally installs headers based on the INSTALL_MBEDTLS_HEADERS option and sets specific file permissions for the installed headers.

```cmake
option(INSTALL_MBEDTLS_HEADERS "Install Mbed TLS headers." ON)

if(INSTALL_MBEDTLS_HEADERS)

    file(GLOB headers "mbedtls/*.h")
    file(GLOB psa_headers "psa/*.h")

    install(FILES ${headers}
        DESTINATION include/mbedtls
        PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)

    install(FILES ${psa_headers}
        DESTINATION include/psa
        PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)

endif(INSTALL_MBEDTLS_HEADERS)
```

--------------------------------

### STiROT Provisioning Scripts

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Templates/Template_ROT/STiROT_Appli/README.md

Scripts used for the STiROT provisioning process. This includes setting up the environment and executing the provisioning steps, which automatically update linker files.

```bash
# Set application project via variable
stirot_boot_path_project="application_example"

# Start provisioning process
./ROT_Provisioning/STiROT/provisioning.sh
```

--------------------------------

### STM32CubeH7 Message Queue Get Events

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/RTOS2/html/group__rtx__evr__message__queue.html

Documents events generated during CMSIS-RTOS message queue get operations. This includes events for starting a get operation, waiting for a message, and timeout expiration during a get operation, along with their parameters.

```APIDOC
EvrRtxMessageQueueGet:
  void EvrRtxMessageQueueGet(osMessageQueueId_t mq_id, void *msg_ptr, uint8_t *msg_prio, uint32_t timeout)
  - Records the event when the osMessageQueueGet function is called.
  - Parameters:
    - mq_id: Message queue ID obtained by osMessageQueueNew.
    - msg_ptr: Pointer to the buffer for the message to be retrieved from the queue.
    - msg_prio: Pointer to store the message priority.
    - timeout: Timeout value or 0 for no time-out.
  - Value in Event Recorder:
    - mq_id: Message queue ID.
    - msg_ptr: Memory address of the buffer for the message.
    - msg_prio: Memory address of the buffer for message priority.
    - timeout: Timeout value.

EvrRtxMessageQueueGetPending:
  void EvrRtxMessageQueueGetPending(osMessageQueueId_t mq_id, void *msg_ptr, uint32_t timeout)
  - Records the event when the osMessageQueueGet function starts waiting for a message to be retrieved from the queue.
  - Parameters:
    - mq_id: Message queue ID obtained by osMessageQueueNew.
    - msg_ptr: Pointer to the buffer for the message to be retrieved from the queue.
    - timeout: Timeout value or 0 for no time-out.
  - Value in Event Recorder:
    - mq_id: Message queue ID.
    - msg_ptr: Memory address of the buffer for the message.
    - timeout: Timeout value.

EvrRtxMessageQueueGetTimeout:
  void EvrRtxMessageQueueGetTimeout(osMessageQueueId_t mq_id)
  - Records the event when the osMessageQueuePutTimeout function fails to insert a message into the queue until the timeout expires.
  - Parameters:
    - mq_id: Message queue ID obtained by osMessageQueueNew.
  - Value in Event Recorder:
    - mq_id: Message queue ID.
```

--------------------------------

### CubeIDE Debug Configuration - Startup Settings

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/PSSI/PSSI_Master_Single_ComDMA/README.md

Configuration within STM32CubeIDE's debug profile to manage image loading, including boot projects and HEX files.

```configuration
In the [Startup] tab, section "Load Image and Symbols":
  Click [Add].
  If your project contains a boot project:
    Click "Project", select the boot project.
    Select "Use active" for Build configuration.
    Check "Perform build" and "Download". Uncheck "Load symbols".
  If your project does not contain a boot project:
    Click [File System], select the Boot HEX file (e.g., Boot_XIP.hex from [Binary] folder).
    Check "Download". Uncheck "Load symbols".
    Click Ok.
  Move the boot project (if added) to the second position in the list.
```

--------------------------------

### ADC Single Conversion Trigger SW IT Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32CubeProjectsList.html

Illustrates performing a single ADC conversion at each software start using the programming model with interrupts. This example focuses on interrupt-driven data acquisition.

--------------------------------

### STM32CubeIDE Debug Configuration - Startup Load Image

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/TIM/TIM_PWMOutput/README.md

Describes how to configure the startup sequence in STM32CubeIDE to load the application image, including bootloader projects and HEX files. This ensures the correct firmware is loaded for execution.

```APIDOC
Startup Tab -> Load Image and Symbols section:

If project contains a boot project:
  - Click [Add] -> Project -> Select boot project
  - Build configuration: Use active
  - Perform build: Checked
  - Download: Checked
  - Load symbols: Unchecked

If project does NOT contain a boot project:
  - Click [Add] -> File System -> Select Boot HEX file (e.g., Boot_XIP.hex)
  - Download: Checked
  - Load symbols: Unchecked

Note: May need to force .hex file selection by typing "*" + Enter in file dialog.
```

--------------------------------

### Set Thread Priority Example (C)

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__ThreadMgmt.html

Example demonstrating how to get the current thread's ID and then set its priority to osPriorityBelowNormal.

```C
#include "cmsis_os.h"

void Thread_1 (void const *arg) {
  // Thread function
  osThreadId id;
  osPriority pr;
  osStatus status;

  id = osThreadGetId(); // Obtain ID of current running thread

  if (id != NULL) {
    status = osThreadSetPriority(id, osPriorityBelowNormal);
    if (status == osOK) {
      // Thread priority changed to BelowNormal
    } else {
      // Failed to set the priority
    }
  } else {
    // Failed to get the id
  }
}
```

--------------------------------

### STM32Cube HAL Initialization and Cache Enable

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Templates/Template_XIP/README.md

Demonstrates the initial setup of the STM32Cube HAL, including system initialization and enabling L1 instruction and data caches for performance enhancement. This is a common pattern for STM32 projects.

```c
/* Reset of all peripherals, Initializes the Flash interface and the Systick.
*/
HAL_Init();

/* Enable the Layer 1 Instruction and Data Caches */
SCB_EnableICache();
SCB_EnableDCache();
```

--------------------------------

### Get Thread ID Example (C)

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__ThreadMgmt.html

Example demonstrating how to obtain the ID of the currently running thread using osThreadGetId and then retrieve its priority.

```C
#include "cmsis_os.h"

void Thread_1 (void const *arg) {
  // Thread function
  osThreadId id;
  osPriority priority;

  id = osThreadGetId(); // Obtain ID of current running thread

  if (id != NULL) {
    priority = osThreadGetPriority(id);
  } else {
    // Failed to get the id
  }
}
```

--------------------------------

### STM32Cube HAL Initialization Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Examples/DMA2D/DMA2D_MemToMemWithBlending/readme.html

A basic C code snippet demonstrating the initial HAL setup, including system initialization and cache enablement, as described in the project context.

```c
/* USER CODE BEGIN Init */
HAL_Init();

/* Configure the system clock */
SystemClock_Config();

/* Enable the Layer 1 Core Instruction and Data Caches */
SCB_EnableICache();
SCB_EnableDCache();
/* USER CODE END Init */

/* USER CODE BEGIN SysInit */
// Ensure SysTick time base is set to 1ms
// HAL_SYSTICK_Config(SystemCoreClock / 1000);
/* USER CODE END SysInit */

/* USER CODE BEGIN 2 */
// DMA2D and LTDC initialization would follow here
/* USER CODE END 2 */
```

--------------------------------

### CMSIS-RTOS Timer Deletion Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/RTOS2/html/group__CMSIS__RTOS__TimerMgmt.html

Example demonstrating how to create, start, and delete a periodic CMSIS-RTOS timer using osTimerNew, osTimerStart, and osTimerDelete.

```C
#include "cmsis_os2.h"

void Timer_Callback (void *arg); // prototype for timer callback function
uint32_t exec; // argument for the timer call back function

void TimerDelete_example (void) {
  osTimerId_t id; // timer id
  osStatus_t status; // function return status

  // Create periodic timer
  exec = 1U;
  id = osTimerNew(Timer_Callback, osTimerPeriodic, &exec, NULL);
  osTimerStart(id, 1000U); // start timer

  status = osTimerDelete(id); // stop and delete timer

  if (status != osOK) {
    // Timer could not be deleted
  }
}
```

--------------------------------

### EWARM/MDK-ARM Setup

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/PSSI/PSSI_Master_Single_ComDMA/README.md

Instructions for setting up the project in IAR Embedded Workbench (EWARM) and Keil MDK-ARM. This involves rebuilding sub-projects and loading specific HEX files into memory.

```text
Open your preferred toolchain (EWARM or MDK-ARM).
Rebuild all files from sub-project Appli.
Load your images into memories: This sub-project will first load Boot_XIP.hex in internal Flash, then load the Appli part in External memory.
```

--------------------------------

### CRS Synchronization Polling Example Usage Instructions

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples_LL/CRS/CRS_Synchronization_Polling/readme.html

Provides instructions on how to use the CRS Synchronization Polling example, including toolchain setup and execution.

```text
In order to make the program work, you must do the following :
* Open your preferred toolchain
* Rebuild all files and load your image into target memory
* Run the example
```

--------------------------------

### Full Timer Stop Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__TimerMgmt.html

A comprehensive C code example demonstrating the lifecycle of a CMSIS-RTOS timer, including creation, starting, stopping, and restarting.

```c
#include "[cmsis\_os.h](cmsis__os_8h.html)"

void Timer_Callback (void const *arg); // prototype for timer callback function
[osTimerDef](group__CMSIS__RTOS__TimerMgmt.html#ga1c720627e08d1cc1afcad44e799ed492) (Timer, Timer_Callback); // define timer

void TimerStop_example (void) {

[osTimerId](cmsis__os_8h.html#ab8530dd4273f1f5382187732e14fcaa7) id; // timer id
[osStatus](group__CMSIS__RTOS__Status.html#gae2e091fefc4c767117727bd5aba4d99e) status; // function return status

// Create periodic timer
exec = 1;
id = [osTimerCreate](group__CMSIS__RTOS__TimerMgmt.html#gaedd312bfdca04e0b8162b666e09a1ae6) ([osTimer](group__CMSIS__RTOS__TimerMgmt.html#ga1b8d670eaf964b2910fa06885e650678)(Timer2), [osTimerPeriodic](group__CMSIS__RTOS__TimerMgmt.html#gadac860eb9e1b4b0619271e6595ed83d9ab9c91f9699162edb09bb7c90c11c8788), NULL);
[osTimerStart](group__CMSIS__RTOS__TimerMgmt.html#ga27a797a401b068e2644d1125f22a07ca) (id, 1000); // start timer

status = [osTimerStop](group__CMSIS__RTOS__TimerMgmt.html#ga58f36b121a812936435cacc6e1e0e091) (id); // stop timer

if (status != [osOK](group__CMSIS__RTOS__Status.html#gae2e091fefc4c767117727bd5aba4d99ea9e1c9e2550bb4de8969a935acffc968f)) {

// Timer could not be stopped

}

[osTimerStart](group__CMSIS__RTOS__TimerMgmt.html#ga27a797a401b068e2644d1125f22a07ca) (id, 1000); // start timer again

}
```

--------------------------------

### CubeIDE Debug Configuration - Startup Image Loading

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/I3C/I3C_Target_HotJoin_IT/README.md

Sets up the startup sequence for loading the application image and symbols in CubeIDE. This includes specifying boot projects or HEX files and configuring download and symbol loading options.

```APIDOC
Startup Tab Configuration:
  Section: "Load Image and Symbols"
    Action: Click [Add]
    Conditional Loading:
      If project contains a boot project:
        - "Project": Select the boot project
        - "Build configuration": Select "Use active"
        - "Perform build": checked
        - "Download": checked
        - "Load symbols": unchecked
      If project does NOT contain a boot project:
        - "File System": Select Boot HEX file (e.g., Boot_XIP.hex)
        - "Download": checked
        - "Load symbols": unchecked
    Post-Configuration:
      - Move the boot project entry to the second position in the list.
```

--------------------------------

### STM32CubeIDE Debug Configuration

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Examples/CRYP/CRYP_SAES_WrapKey/README.md

Detailed instructions for configuring the debug profile in STM32CubeIDE, including adding external loaders for memory devices and setting up the image loading process for projects with or without a boot project.

```text
1. Compile the example/application. The elf file is required for debug profile configuration.
2. Ensure the 'active configuration' is set to 'debug'.
3. Navigate to [Run]->[Debug configuration] and double-click [STM32 C/C++ Application] to create a default debug configuration.
4. In the [Debugger] tab, section 'External loaders':
   - Click [Add] and select the appropriate loader (e.g., MX25UW25645G_NUCLEO-H7S3L8.stldr or MX66UW1G45G_STM32H7S78-DK.stldr).
   - Ensure 'Enabled' is checked and 'Initialize' is unchecked.
5. In the 'Misc' section, uncheck 'Verify flash download'.
6. In the [Startup] tab, section 'Load Image and Symbols':
   - If your project has a boot project:
     - Click [Add], select 'Project', choose the boot project, set Build configuration to 'Use active', check 'Perform build' and 'Download', uncheck 'Load symbols'.
     - Move the boot project to the second position in the list.
   - If your project does not have a boot project:
     - Click [Add], select [File System], and choose the 'Boot_XIP.hex' file (found in the [Binary] folder of Template_XIP projects).
     - Check 'Download', uncheck 'Load symbols', and click Ok.
   - You may need to force the selection of a .hex file by typing '*' and pressing Enter in the file name dialog.
```

--------------------------------

### Message Queue Usage Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__Message.html

Example demonstrating the setup and usage of a CMSIS-RTOS message queue. It shows how to declare, create, and populate a message queue with data.

```C
// Declare a message queue with a size of 5 and uint32_t data type
osMessageQDef(message_q, 5, uint32_t);

// Declare an ID for the message queue
osMessageQId message_q_id;

// Create the message queue in a thread
message_q_id = osMessageCreate(&osMessageQ(message_q), NULL);

// Fill the message queue with data
uint32_t data = 512;
// Note: The example text incorrectly uses osMailPut, it should be osMessagePut for message queues.
osMessagePut(message_q_id, data, osWaitForever);

```

--------------------------------

### STM32H7S3L8 Board Setup and LEDs

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/I3C/I3C_Controller_ENTDAA_IT/readme.html

Details the hardware setup for the I3C communication example on the NUCLEO-H7S3L8 board, including pin assignments and LED indicators for status monitoring.

```APIDOC
Hardware Setup:

- Board: NUCLEO-H7S3L8 (embeds a STM32H7S3L8Hx device)
- SCL Pin: PB8 (Arduino SCL/D15 CN7 pin 2, Morpho CN12 pin3)
- SDA Pin: PB9 (Arduino SDA/D14 CN7 pin 4, Morpho CN12 pin5)

- Connection:
  - Connect GND between each board.
  - Use short wires or twist an independent ground wire around SCL and SDA lines for better communication at 12.5MHz.

- LED Indicators:
  - LD1 is ON when the Dynamic Address Assignment process is complete.
```

--------------------------------

### EWARM/MDK-ARM Setup

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Examples/GPIO/GPIO_IOToggle/README.md

Instructions for setting up the project in IAR Embedded Workbench (EWARM) and Keil MDK-ARM. This involves rebuilding sub-projects and loading specific HEX files into memory.

```text
Open your preferred toolchain (EWARM or MDK-ARM).
Rebuild all files from sub-project Appli.
Load your images into memories: This sub-project will first load Boot_XIP.hex in internal Flash, then load the Appli part in External memory.
```

--------------------------------

### Get Event Flags Name Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/RTOS2/html/group__CMSIS__RTOS__EventFlags.html

Example demonstrating how to retrieve the name of an event flags object using osEventFlagsGetName. It includes necessary header inclusion and error checking.

```c
#include "cmsis_os2.h" // CMSIS RTOS header file

osEventFlagsId_t evt_id; // event flasg id

void EvtFlagsGetName_example (void) {
  char *name;
  name = osEventFlagsGetName(evt_id);
  if (name == NULL) {
    // Failed to get the event flags object name
  }
}
```

--------------------------------

### CubeIDE Debug Configuration - Startup Settings

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/Examples/GPIO/GPIO_IOToggle/README.md

Configuration within STM32CubeIDE's debug profile to manage image loading, including boot projects and HEX files.

```configuration
In the [Startup] tab, section "Load Image and Symbols":
  Click [Add].
  If your project contains a boot project:
    Click "Project", select the boot project.
    Select "Use active" for Build configuration.
    Check "Perform build" and "Download". Uncheck "Load symbols".
  If your project does not contain a boot project:
    Click [File System], select the Boot HEX file (e.g., Boot_XIP.hex from [Binary] folder).
    Check "Download". Uncheck "Load symbols".
    Click Ok.
  Move the boot project (if added) to the second position in the list.
```

--------------------------------

### CubeIDE Debug Configuration - Startup Image Loading

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/I3C/I3C_Controller_HotJoin_IT/README.md

Sets up the startup sequence for loading the application image and symbols in CubeIDE. This includes specifying boot projects or HEX files and configuring download and symbol loading options.

```APIDOC
Startup Tab Configuration:
  Section: "Load Image and Symbols"
    Action: Click [Add]
    Conditional Loading:
      If project contains a boot project:
        - "Project": Select the boot project
        - "Build configuration": Select "Use active"
        - "Perform build": checked
        - "Download": checked
        - "Load symbols": unchecked
      If project does NOT contain a boot project:
        - "File System": Select Boot HEX file (e.g., Boot_XIP.hex)
        - "Download": checked
        - "Load symbols": unchecked
    Post-Configuration:
      - Move the boot project entry to the second position in the list.
```

--------------------------------

### FDCAN Adaptive Bitrate Example Setup

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/FDCAN/FDCAN_Adaptive_Bitrate_Receiver/readme.html

Instructions for building and running the FDCAN Adaptive Bitrate Receiver and Transmitter examples on separate boards. Emphasizes the correct execution order.

```APIDOC
Project: /stmicroelectronics/stm32cubeh7rs

Functionality: FDCAN Adaptive Bitrate Receiver/Transmitter Setup

Description:
This section outlines the prerequisites and execution steps for the FDCAN Adaptive Bitrate Receiver and Transmitter examples.

Steps:
1. Rebuild all files for the 'FDCAN_Adaptive_Bitrate_Receiver' example and load the image into target memory of Board A.
2. Rebuild all files for the 'FDCAN_Adaptive_Bitrate_Transmitter' example and load the image into target memory of Board B.
3. Run the examples on each board, ensuring that 'FDCAN_Adaptive_Bitrate_Transmitter' is executed first.

Dependencies:
- Two STM32H7 boards.
- Compiled firmware for both Receiver and Transmitter examples.
```

--------------------------------

### EWARM/MDK-ARM Setup

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/NUCLEO-H7S3L8/Examples/PSSI/PSSI_Slave_ComDMA/README.md

Instructions for setting up the project in IAR Embedded Workbench (EWARM) and Keil MDK-ARM. This involves rebuilding sub-projects and loading specific HEX files into memory.

```text
Open your preferred toolchain (EWARM or MDK-ARM).
Rebuild all files from sub-project Appli.
Load your images into memories: This sub-project will first load Boot_XIP.hex in internal Flash, then load the Appli part in External memory.
```

--------------------------------

### STM32 CMSIS-RTOS Application Start Example

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/RTOS/html/group__CMSIS__RTOS__Mail.html

Shows how to initialize the application by creating a mail queue using osMailCreate and starting two threads (send_thread and recv_thread) using osThreadCreate.

```C
void StartApplication (void) {
  mail = osMailCreate(osMailQ(mail), NULL); // create mail queue
  tid_thread1 = osThreadCreate(osThread(send_thread), NULL);
  tid_thread2 = osThreadCreate(osThread(recv_thread), NULL);
}
```

--------------------------------

### ARM Dot Product Example (f32)

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Drivers/CMSIS/Documentation/DSP/html/files.html

A specific example demonstrating the usage of the dot product function for float32 data type, likely for illustrative purposes in a tutorial or guide.

```C
#include "arm_math.h"

/* Example usage of arm_dotproduct_example_f32 */
void example_dotproduct_example_f32() {
    float32_t pSrcA[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
    float32_t pSrcB[] = {6.0f, 7.0f, 8.0f, 9.0f, 10.0f};
    float32_t result;
    uint32_t blockSize = sizeof(pSrcA) / sizeof(float32_t);

    /* Compute the dot product */
    arm_dot_prod_f32(pSrcA, pSrcB, blockSize, &result);

    /* 'result' will contain the sum of element-wise products */
}
```

--------------------------------

### Python Dependencies for AppliCfg

Source: https://github.com/stmicroelectronics/stm32cubeh7rs/blob/main/Projects/STM32H7S78-DK/ROT_Provisioning/STiROT_OEMuROT/README.md

Instructions for setting up the Python environment required for the AppliCfg tool, used during the provisioning process. This includes installing Python and necessary modules.

```shell
pip install -r Utilities/PC_Software/ROT_AppliConfig/requirements.txt
```