Modern Embedded Development: C# on STM32H7 with .NET 10

[snikeguo]

For too long, the choice for high-performance embedded development has been limited to C and C++. While effective, these languages often come with memory safety pitfalls and slower development cycles. What if you could use modern C# on STM32H7 without the overhead of traditional interpreters?

The ICS-CSHARP-SDK​ makes this a reality. It leverages the raw power of .NET 10​​ technology to transform your C# code directly into optimized ARM machine code.

Beyond Traditional Frameworks

This is not nanoFramework.

https://github.com/snikeguo/ICS-CSHARP-SDK

[josesimoes]

Nice! Besides C# APIs, can we use GPIO, SPI, network, etc?

[snikeguo]

yes.

[TerryFogg]

This looked interesting, so I downloaded and managed to build a test program.

Seemed to take about 1.8MBytes of flash and 180Kb of RAM ( More research needed, just a preliminary finding)

I then asked Microsoft Copilot to give me a summary of the code and what is happening.

It uses Nuttx, and I see on the Nuttx site that they support the ESP32, so maybe it could cover these SOC's as well.

Microsoft Copilot summary of the code ICS_CSHARP

Summary: ICS C# SDK Architecture - C# to ARM Code Compilation

This is an ICS (Integrated Control System) C# embedded SDK that enables developers to write C# applications for embedded ARM boards running NuttX RTOS. It uses Microsoft NativeAOT to compile C# code directly to native ARM machine code (no runtime needed).

BUILD PIPELINE: C# → IL → Native Code → Linking

Phase 1: C# to Intermediate Language (IL)
• User writes C# code (e.g., Program.cs)
• .NET SDK compiles C# → IL bytecode
• Target framework: net10.0 with AOT compilation enabled

Phase 2: IL to Native ARM Code
The Ics.NativeAot.Nuttx.targets MSBuild file orchestrates this:

ILC Compiler (IL to Code compiler)
• Located in: dotnet_toolchain/compiler/ilc.exe
• Compiles IL → native ARM assembly
• Outputs object file: NativeObject (.o file)
• JIT compilers for cross-platform compilation:
• clrjit_universal_arm_x64.dll (compile for ARM, run on x64)
• clrjit_unix_x64_x64.dll
• clrjit_win_x64_x64.dll

Phase 3: Object Linking and Compilation
• Skip Standard .NET Linking: The target sets _SkipNativeLink = true
• Custom CMake-based Linking: Instead, a generated CMakeLists.txt is used
• ARM GCC Toolchain:
• Located in: xpack-arm-none-eabi-gcc-13.3.1-1.1/bin
• Tools used:
• arm-none-eabi-gcc - C/C++ compiler
• arm-none-eabi-objcopy - Binary conversion
• arm-none-eabi-nm - Symbol table viewer

---

CMAKE AUTO-GENERATION & NATIVEAOT USER BUILD

Workflow:

User C# Project
    ↓
MSBuild runs "IcsLinkWithSdkTemplate" target
    ↓
Copies SDK template → user project directory:

  - CMakeLists.txt (from CMakeLists.txt.ics_nativeaot_user.cmake)
  - IcsUserAotImageHeader.c (NativeAOT image header)
    ↓
    Copies NativeObject (.o file) from ILC compilation
    ↓
    Runs CMake configuration & build
    ↓
    Links everything with arm-none-eabi-gcc
    ↓
    Post-processing (CRC, binary conversion)

Generated CMakeLists.txt Contents (CMakeLists.txt.ics_nativeaot_user.cmake):

Toolchain Setup:
• Auto-detects ARM GCC location: xpack-arm-none-eabi-gcc-*/bin
• Sets CMAKE_SYSTEM_NAME = Generic
• Sets CMAKE_SYSTEM_PROCESSOR = arm
• Cross-compile mode: CMAKE_TRY_COMPILE_TARGET_TYPE = STATIC_LIBRARY

Architecture Flags:

-march=armv7e-m           # ARM Cortex-M7 instruction set
-mfloat-abi=hard          # Hardware floating point ABI
-mfpu=fpv5-d16            # FPU with 16 double registers
-mthumb                   # Thumb instruction set

C Compiler Flags:

-O1                            # Optimization level 1
-ffunction-sections            # Separate functions for GC
-fdata-sections                # Separate data sections
-fvisibility=hidden            # Hide symbols by default
-fno-asynchronous-unwind-tables # Custom unwind handling

Preprocessor Definitions:
• NativeAOT Features: FEATURE_NATIVEAOT, FEATURE_DYNAMIC_CODE, FEATURE_HIJACK
• Platform: TARGET_NUTTX, TARGET_UNIX, TARGET_ARM_VFP_V5_D16, HOST_ARMV7M
• Hardware: STM32H723xx, USE_HAL_DRIVER
• Security: _LIBUNWIND_ARM_EHABI (ARM Exception Handling ABI)
• Libraries: FEATURE_PERFTRACING, TINY_ICU, WITH_GZFILEOP, ZLIB_COMPAT

Include Directories:

$(SDK)/libs/include/apps
$(SDK)/libs/include/nuttx
$(SDK)/libs/include/nuttx/cxx
$(SDK)/libs/include/nuttx_build

Linker Settings:
• Wrap Functions (-Wl,--wrap): Custom unwinding functions
• _Unwind_RaiseException, _Unwind_Resume, _Unwind_ForcedUnwind
• ARM-specific: __aeabi_unwind_cpp_pr0/1/2
• Linker Scripts:
• ics_user.ld - NativeAOT user image memory layout
• nuttx_symbols.ld - NuttX kernel symbol exports
• Flags:
• -nostartfiles -nostdlib - No standard startup
• -Wl,--gc-sections - Remove unused sections
• -Wl,--print-memory-usage - Memory statistics

Pre-linked Libraries:

libics_nativeaot_user_export.a     # NativeAOT runtime exports
libBrotli.a                        # Compression
libSystem_*.a                      # .NET runtime system libraries
libics_csharp_pinvoke.a            # P/Invoke support
libopenssl.a                       # Crypto/TLS

Post-Build Steps:

arm-none-eabi-objcopy -O binary → .bin file
post_link_crc.py (Python script):
   - Calculates CRC32 checksum
   - Updates IcsUserAotImageHeader with CRC
   - Patches binary with correct image signature

NUTTX INTEGRATION

How NuttX is Used:

Kernel Interface:
• Headers in libs/include/nuttx/ - NuttX OS API headers
• Memory layout managed by NuttX bootloader

User Application Model:
• C# code runs as a NuttX application (not kernel code)
• Uses NuttX system calls through headers
• Compiled into separate user-space image

Symbol Export:
• nuttx_symbols.ld exports kernel symbols (UART, GPIO, etc.)
• User code can call NuttX kernel functions via linker symbols

Startup:
• -nostartfiles means no C standard startup
• NuttX bootloader loads the user ELF
• Transfers control to C# entry point

---

PUBLICATION & DISTRIBUTION SYSTEM

publish_ics_csharp_sdk.py - Prepares SDK for distribution:

Finds Demo Project:
• Locates demo/*.csproj (unique project in demo folder)

Executes NativeAOT Build:
• Runs: dotnet publish -c Release -r linux-arm --self-contained
• Generates published files

Detects ILC Version:
• Parses project.assets.json
• Extracts microsoft.dotnet.ilcompiler version
• Falls back to latest version in ~/.nuget/packages

Patches Microsoft.NETCore.Native.targets:
• Modifies LinkNative target condition: adds _SkipNativeLink check
• Removes skip condition from linker exec
• Enables custom CMake linking pipeline

Installation:
• Copies modified build files to SDK distribution

---

COMPILATION FLOW DIAGRAM

┌─────────────────────────────────────────────────────────┐
│ User C# Project (.csproj)                               │
└────────────────┬────────────────────────────────────────┘
                 │
                 ▼
    ┌─────────────────────────────┐
    │ dotnet publish              │
    │ --configuration=Release     │
    │ --runtime=linux-arm         │
    │ --self-contained            │
    └────────┬────────────────────┘
             │
             ▼
    ┌─────────────────────────────┐
    │ ILC.exe (IL Compiler)       │
    │ Compiles IL → native code   │
    │ Outputs: NativeObject (.o)  │
    └────────┬────────────────────┘
             │
             ▼
    ┌─────────────────────────────────────────┐
    │ MSBuild Target: IcsLinkWithSdkTemplate   │
    │ - Copies CMakeLists.txt template        │
    │ - Copies .o file to build dir           │
    │ - Runs cmake configure                  │
    └────────┬────────────────────────────────┘
             │
             ▼
    ┌─────────────────────────────────────────┐
    │ CMake Build (with ARM GCC)              │
    │ - Links .o files                        │
    │ - Links pre-built libraries (.a)        │
    │ - Applies custom unwind wrapping        │
    │ - Uses linker scripts (.ld)             │
    │ Outputs: ics_nativeaot_user.elf         │
    └────────┬────────────────────────────────┘
             │
             ▼
    ┌─────────────────────────────────────────┐
    │ Post-Link Processing                    │
    │ - objcopy: ELF → .bin                   │
    │ - post_link_crc.py: Calculate CRC32     │
    │ - Patch image header signature          │
    └────────┬────────────────────────────────┘
             │
             ▼
    ┌─────────────────────────────────────────┐
    │ Final Output:                           │
    │ - ics_nativeaot_user.elf (ELF binary)   │
    │ - ics_nativeaot_user.bin (raw binary)   │
    │ - ics_nativeaot_user.map (memory map)   │
    └─────────────────────────────────────────┘

KEY CONFIGURATION PROPERTIES

User configures in GpioForCSharpDriver.csproj:

<IcsCSharpSdk>D:\path\to\sdk</IcsCSharpSdk>
<DisableUnsupportedError>true</DisableUnsupportedError>
<InvariantGlobalization>true</InvariantGlobalization>
<AllowUnsafeBlocks>True</AllowUnsafeBlocks>
<PublishAot>true</PublishAot>
<RuntimeIdentifier>linux-arm</RuntimeIdentifier>

Optional overrides:

<IcsNativeAotUserCmakeGenerator>Ninja</IcsNativeAotUserCmakeGenerator>
<IcsNativeAotUserCmakeArgs>-DCUSTOM=value</IcsNativeAotUserCmakeArgs>
<IcsNativeAotUserBuildArgs>--verbose</IcsNativeAotUserBuildArgs>
<IcsNativeAotUserForceConfigure>false</IcsNativeAotUserForceConfigure>

Summary

This system is a sophisticated end-to-end compiler toolchain that:

1. Leverages .NET's NativeAOT to eliminate runtime overhead
2. Uses ARM GCC (via xpack distribution) for final compilation
3. Integrates with NuttX through carefully crafted linker scripts and headers
4. Auto-generates CMake build files from templates to handle complex linking
5. Post-processes binaries with CRC verification for safety
6. Abstracts complexity behind MSBuild targets so users just write C#

[TerryFogg]

Looks like the ILC compiler only supports ARM based SOC's, so this is limited to ARM at the moment