ALP SDK

The ALP SDK is the unification software layer for ALP Lab edge AI modules built on the E1M open-standard form factor. It provides a single C/C++ API — <alp/...> — that works across every E1M SoM variant by wrapping each vendor's SDK on top of ARM CMSIS.

Write once, run on any E1M module.

Design principles

• Vendor-independent — one API across Alif Ensemble, Renesas RZ/V2N, NXP i.MX 93, and any future conformant silicon.
• CMSIS-compatible — sits on top of ARM CMSIS so existing CMSIS code and DSP libraries integrate without friction.
• Heterogeneous-OS — Zephyr, Yocto Linux, and bare-metal are peers, declared per-core in one board.yaml. One SoM can run all three at once.
• Hand-written friendly — the SDK supports hand-written firmware as a first-class consumer, not just alp-studio codegen.
• Declarative configuration — a single board.yaml at your app root replaces scattered Kconfig fragments, CMake -D flags, and local.conf edits.

Supported targets

Per-core OS choice (heterogeneous orchestration since v0.6):

Module family	A-class cores	M-class cores	Heterogeneous?
E1M-AEN E3/E4	—	M55-HP + M55-HE (Zephyr)	No — RTOS-only
E1M-AEN E5..E8	A32 cluster (Yocto)	M55-HP + M55-HE (Zephyr)	Yes
E1M-X V2N	A55 cluster (Yocto)	M33-SM (Zephyr)	Yes
E1M-X V2N-M1	A55 cluster (Yocto)	M33-SM (Zephyr) + DEEPX	Yes
E1M-N93	A55 cluster (Yocto)	M33 (Zephyr)	Yes

Stack

┌──────────────────────────────────────────────────────────────────┐
│                       Application code                           │
└──────────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────────────┐
│   ALP SDK  <alp/*.h>                                             │
│   Peripherals · Audio · Camera · Inference · IoT · BLE · Security│
│   Multi-proc IPC · HW info · 20+ chip drivers                    │
└──────────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────────────┐
│   OS backend  (Zephyr · Yocto · bare-metal)                      │
└──────────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────────────┐
│   Vendor SDK / HAL  (Alif · Renesas · NXP · DEEPX · TI)          │
└──────────────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────────────┐
│   E1M / E1M-X SoM hardware                                       │
└──────────────────────────────────────────────────────────────────┘

SDK components

Public API — <alp/*.h>

Group	Headers
Peripherals	peripheral.h (GPIO/I²C/SPI/UART), pwm.h, adc.h, counter.h, i2s.h, can.h, rtc.h, wdt.h, usb.h
Audio / camera / display	audio.h (PDM in + I²S out), camera.h, gui.h (LVGL), display.h
Connectivity & security	iot.h (Wi-Fi/MQTT), ble.h (BLE 5.4), security.h (MbedTLS PSA Crypto)
Inference dispatcher	inference.h — backend selector (auto / cpu / ethos_u / drpai / deepx_dx)
Cross-core IPC	rpc.h — framed RPC over OpenAMP/RPMsg; mproc.h — raw mailbox + shared memory
Hardware info	hw_info.h — 128-byte EEPROM manifest + BOARD_ID ADC
Signal / DSP	dsp.h — FIR/IIR/FFT chains over CMSIS-DSP
Power / storage	power.h, storage.h, tmu.h, gpu2d.h
Capability tables	soc_caps.h (generated), e1m_pinout.h (portable instance IDs)
Generated headers	system_ipc.h — endpoint IDs + addresses + mailbox channels emitted from board.yaml's ipc: block
Chip drivers	50+ under <alp/chips/...> — opt-in via board.yaml

See the API overview.

Dev tooling

• board.yaml v2 project config — single source of truth for SoM SKU, carrier, per-core runtime, inference backend, libraries, peripherals, IoT toggles, IPC carve-outs, diagnostics, hw_rev. See the reference.
• scripts/alp_orchestrate.py — fans out board.yaml v2 into per-core build slices; emits system-manifest.yaml, alp/system_ipc.h, dts-reservations.dtsi, per-slice Kconfig fragments / Yocto local.conf snippets / CMake -D flags.
• Five west alp-* commands — alp-build (fan-out), alp-image (assemble bundle), alp-flash (boot-order-aware programming), alp-clean (idempotent teardown), alp-renode (dual-OS smoke test).
• scripts/validate_board_yaml.py — customer-side linter (schema v2).
• scripts/program_eeprom.py — packs board.yaml + serial + mfg date into the 128-byte EEPROM manifest for production-test programming.
• VS Code extension — schema-aware editing, GUI configurator, west wrappers, per-OS bootstrap. Ships from its own repo at alplabai/alp-sdk-vscode since 2026-05-12.

Inference back-ends

The <alp/inference.h> dispatcher routes TFLite Micro models to silicon-specific NPU back-ends:

• Arm Ethos-U — Alif Ensemble (AEN family — every E3..E8 SKU carries U55; E4/E6/E8 additionally carry Transformer-capable U85) + NXP i.MX 93 (U65)
• Renesas DRP-AI3 — RZ/V2N (V2N family)
• DEEPX DX-M1 — V2N-M1 (V2M family); ONNX → DXNN compiler, model-family agnostic
• CPU — reference-kernel fallback on any target

Supported on-device model families

Class	Examples	Backends
Classification	MobileNet, EfficientNet-Lite	Ethos-U, DRP-AI3, DEEPX, CPU
Detection	YOLOv5, YOLOv8, SSD-MobileNet	YOLO v5/v8 on DEEPX + DRP-AI3; SSD on Ethos-U + CPU
Segmentation	DeepLabV3, U-Net	Ethos-U, DRP-AI3, DEEPX
Keyword spotting	DS-CNN, Conformer-Tiny	Ethos-U (HE core, ~1 mW continuous)
Pose estimation	MoveNet, BlazePose	DRP-AI3, DEEPX
Anomaly / forecasting	1D-CNN, TinyTransformer (U85 only)	Ethos-U55 (1D-CNN); Ethos-U85 (Transformer)

Offline training (off-device) stays in TensorFlow / PyTorch.

Two consumer paths

The SDK supports both equally — pick whichever fits.

Standalone / hand-written

Write Zephyr, Yocto, or bare-metal app code directly against <alp/...> headers. Pick instance IDs from <alp/e1m_pinout.h> (E1M_I2C0, E1M_PWM3, …). Your app stays portable across every E1M-conformant SoM.

alp-studio codegen

The Studio reads block manifests, runs the pin allocator against the active SoM, and emits C that calls the same <alp/...> API. Pin-allocation correctness comes for free.

The standalone path is not a Studio escape hatch — it's a first-class consumer.

Where next

• Install the SDK
• Quick start — build and flash the GPIO example
• board.yaml reference — schema v2
• Heterogeneous builds — dual-OS project walkthrough
• Firmware quickstart — per-SoM patterns
• Architecture — wrapper layers, codegen split, orchestrator
• API reference