+ ML
Welcome to the16th Partner Meeting

Arm MCU Tools Team
09 April 2023
Confidential © 2024 Arm

AI-generated image

embedded world 2024

AgendaHistory of CMSIS and future challenges
What is CMSIS today?
Foundation Tools for Developing ML on Edge Devices
Tool Components for VS Code
Open-CMSIS-Pack/CMSIS-Toolbox• Debug for Cortex-A/M including Multicore• LLVM Embedded Toolchain• Arm Tools Artifactory•

Demo of Tool components
Create Reusable Software Stacks•

How we promote software from eco-system partners

More CMSIS Innovations

C++ Matrix and Vector Compute Algorithms• CMSIS-SVD Improvements• CMSIS-Pack Download Authorization• New Standardized APIs for middleware•

Questions and Feedback
2

Confidential © 2024 Arm

CMSIS Partner Meetings – how it began!

3

Confidential © 2024 Arm

Foundation tool components
4

Confidential © 2024 Arm

What is CMSIS today?

Christopher Seidl

Confidential © 2024 Arm

CMSIS - Fifteen Years of Software Evolution
10,000 supported
devices6

1000+ packs from60 vendors

6 million GitHub
projects

Multipletoolchains

2008

2010

2012

2014

2016

2023

CMSIS v1
Access toprocessor core,interrupts, andperipherals

CMSIS v2
Optimized DSP
compute functions
for all Cortex-M
Peripheral debug
description (SVD)

CMSIS v3
Real-time
operatingsystems API

CMSIS v4
Enable middlewarewith Driver and
RTOS interfaces
Device supportand softwaredelivered withCMSIS packs

CMSIS v5
Development on
GitHubCMSIS-NN for
Machine Learning
Optimized computelibraries for Helium

CMSIS v6
Optimized structureand enhancements forsoftware development
CLI build system for
CI, MLOps, and
IDE integration

Confidential © 2024 Arm

Two Decades of Microcontroller Innovation
32-bit Compute

2004
Birth of the Low Cost,
Low Power 32-bit
Microcontroller

7

Confidential © 2024 Arm

2009

2010

Focus on ultralow cost / power/ areaDelivering DSPExtensions

TrustZone Security

2016
Introducing TrustZone
advanced security for
Cortex-M

Helium ML/DSP

2020
Delivering Heliumarchitecture technology
for ML & DSP

2022

2023

Addressing higher
performance ML &DSP applications

Today: Deliveringhigh-efficiency
ML & DSP

Version 6
Consistent software framework for billions of devices
Application codegithub.com/ARM-software/CMSIS_6
Debugger

CMSIS-Toolbox
Command-line
project build

CMSIS-Driver

CMSIS-RTOS2

Middleware I/F

Real-time execution

CMSIS-DSP

Compute library

CMSIS-NN

Machine learning

CMSIS-Compiler
I/O Retargeting

CMSIS-SVD

Peripheral description

CMSIS-Stream
CMSIS-CoreCMSIS-View

Processor core and peripheral access

Event recorder

CMSIS-DAP
Debug access

System partitioning

Arm Cortex processor and peripherals

On-chip
memoryCoreSight
debug logic

MPU, SAUCMSIS-Zone

Optimized
data streamingfor ML and DSPCMSIS-Pack

Software packaging
and delivery

System-on-chip
Software components for the Arm Cortex processor target
8

Confidential © 2024 Arm

Tools for optimizing software development flows

Specifications

More information
CMSIS is not only for Cortex-M
CMSIS v6 Overview

CMSIS-View/Compiler

Cortex-A/M

Cortex-M

Cortex-A/M

CMSIS-Toolbox

CMSIS-Stream/SDS

CMSIS v6 Documentation

9

Confidential © 2024 Arm

All Cortex

All Cortex

Cortex-M Processor Portfolio – Instruction Set Evolution
Cortex-M85
Cortex-M55
Cortex-M52

Cortex-M33
Cortex-M23*
Cortex-M35P
Cortex-M7
Cortex-M4
Cortex-M3**
Cortex-M0+
Cortex-M0
10

Confidential © 2024 Arm

Armv8.1-M
Helium vector instruction set

Armv8-M
TrustZone Security
Co-processor interface

Armv7-M
DSP/SIMD instructions
Floating-Point Unit (FPU)

Armv6-M>150 new scalar and vector instruction
Low overhead loops
Predication
Arithmetic support for 8-bit fixed and 16-bit float
Gather load, scatter store
Complex math

Ease of development
Energy-efficient compute
Increased throughput
Smarter devices* Cortex-M23 does not include co-processor interface, DSP/SIMD and FPU** Cortex-M3 does not include DSP/SIMD and FPU

TOP/s

Broadest Range of ML-optimized Processing Solutions
ML Edge workloads run on:• Classic Cortex-M• Cortex-M with Helium• Cortex-M with Ethos-U• Cortex-A with Ethos-U85

Sensorfusion11

Confidential © 2024 Arm

Keyworddetection

Anomaly detectionv

Objectdetection

Gesturedetection

Biometric
awareness

Data throughput

Speech recognition Object classification

TOP/s

Real-time
recognition

Generative AI

Ethos-U: Unlocking the Full Potential of Neural Networks
Accelerating implementation of higher performance AI enabled systems

X X X X X X X

X X X X X X X
X X X X X X X

X X X X X X X
X X X X X X X
X X X X X X X
X X X X X X X
X X X X X X X
X X X X X X X
X X X X X X X
X X X X X X X

32-256 MACs

256-512 MACs

128-2048 MACs

Ethos-U55

Ethos-U65

Ethos-U85

Matrix
Weights

MatrixMAC

Weights
MatrixEthos-U55 / Ethos-U65
12

Confidential © 2024 Arm

MAC
Transformer support

Ethos-U85

Ethos-U software flow on Cortex-M systems
HOST (OFFLINE)
Vela Compiler
TF Quantization

Ethos-U
Driver

TFL flat file

TFLu Runtime

TF
Framework

TA R G E T / D E V I C E

NN Optimizer

CMSIS-NN
Optimized
Kernels

Ethos-U
NPU

Cortex-M
CPU

Ref. Kernels

•
•

•
•

Train network in TensorFlow
Model conditioning techniques: Collaborative clustering,pruning and QAT to improve model performance on Ethos-U
while preserving its accuracy.
Quantize it to Int8 TFL flatbuffer file (.tflite file)
NN Optimizer identifies graphs to run on Ethos-U••

13

Optimizes, schedules and allocates these graphs
Lossless compression, reducing size of tflite file

Confidential © 2024 Arm

Linked platform runtime•••

Runtime executable file on device
Accelerates kernels on Ethos-U• Driver handles the communication
The remaining layers are executed on Cortex-M• CMSIS-NN optimized kernels if available• Fallback on the TFLµ reference kernels

The AI Software Ecosystem is Converging on Arm
Accelerating software development and navigating emerging frameworks

Developers, Data Scientists,
Academia
Software Ecosystem

AI Frameworks
Devices

14

Confidential © 2024 Arm

Foundation Tools & Software forDeveloping ML on Edge Devices+ Ecosystem Partnerships
Reinhard Keil

Confidential © 2024 Arm

AI on Edge Devices – Grow Opportunity

Talk about ML

16

Confidential © 2024 Arm

Energy Efficient AI Technology

Applied to New Emerging Markets

www.52audio.com/archives/194825.html••

Medical diagnoses
Natural voice-controlled devices••

Vision based automation
Sustainable agriculture

•

etc.

ML on Edge Devices = compute + libraries + tools
Arm support for DSP/ML
Helium and Ethos-U Benefits: more computations

vector processing (MVE) and micro NPU+ new DSP/ML kernels+ stream-based PoC
Foundation Tools & Software: simplify development- CMSIS-DSP/NN libraries, Python wrapper, Proof ofconcepts- stream-based processing techniques- Open software and tools platform

17

Confidential © 2024 Arm

EEMBC AudioMark = DSP + NN Workload(baseline Cortex-M4)

MLOps: deploy and maintain Machine Learning (ML) models
Combines machine learning data analytics with continuous development (DevOps)
Data
Analysis

ML models are tested and developed inisolated systems.

Data
Labeling* DataCollection

Data
Preparation

Test Data

Adding ML is an evolutionary process.

Validation Data

Training Data

Model
Deployment* System
Validation

18

MLOps is an iterative process to transition
the ML model to production systems.

Model
Training* ModelEvaluation* Supported by Arm Virtual Hardware and SDS Framework
Confidential © 2024 Arm

Evaluation and validation require themodel to run on target hardware.

Machine Learning (ML) Requires Real-World Data
Data collection requires frequently inputs of the final target system
Data
Analysis

Data
Labeling* DataCollection

Data
Preparation

Test DataA
B

Validation Data

Training Data

Model
Deployment* System
Validation

19

Decision:

Model
Training* ModelEvaluation* Supported by Arm Virtual Hardware and SDS Framework
Confidential © 2024 Arm

Source:https://codewords.recurse.com/issues/five/why-do-neural-networks-think-a-panda-is-a-vultureMaterial for ML Developers
ML Developers Guide for Cortex-M Processors and Ethos-U• Embedded Developers that use microcontrollers and/or Ethos-U• MLOps system architects that integrate the various development tools• Data scientists that develop new ML models and need performance

information

Foundation Tool Components for MLOps Systems• Setup of a Docker container for MLOps systems• Create trained ML models with different compilers for target processors• Compare performance (inference time) using Arm Virtual Hardware

Synchronous Data Stream (SDS) Framework• Flexible data stream management for sensor and audio data interfaces• Provides methods to record real-world data for analysis and development• Playback real-world data for algorithm validation using Arm Virtual Hardware
20

Confidential © 2024 Arm

SDS: recording & playback of real-world data for testing
Combined with AVH it enables repeatable test automation in CI systems and MLOps cloud services

MEMS Sensor
Interface

Audio
InterfaceSDS RecorderInterface

GyroscopeSensorMicrophone
Input

SDS Recorderconnects via
different channels

xy21

Same algorithm is verified on
precise processor simulation model

Confidential © 2024 Armz

SDS Data Files*.gyroscope.sds

SDS Data Files*.microphone.sds

Software on
Arm Virtual Hardware

Software on
Physical Board
MCU
DeviceAlgorithm under Development

VSI Sensor
Interface

VSI Audio
Interface

AVH
VSI

Arm Virtual Hardware (AVH)

Microcontroller Hardware

Virtual Streaming
Interface #1

Virtual Streaming
Interface #2

SDS Data FilesSDS Data Files

Algorithm under Development*.gyroscope.sds*.microphone.sds

Core Compute Capabilities for a Modern Development Flow
Access to DSP/ML capabilities without specialized tools simplifies development
Example: Cortex-M Processor with Helium running a predictive maintenance workload

In

Signal conditioning
Filtering, sensor fusion,
Kalman filter

CMSIS-DSP and CMSIS-NN
Optimized compute libraries

22

Confidential © 2024 Arm

Feature extraction
Spectral data

CMSIS-Stream
Optimized data streaming
between compute nodes

ML classification
Classical ML
Deep learning (NN)Out

MLOps workflow exemplified with TDK Qeexo AutoML
CAPTURE
D ATA

ML MODEL
TRAINING

DEPLOYT O TA R G E T

Add SDS framework totarget application

Convert SDS data files
and label data

Data cleaning andpreprocessing

Integrate ML model
library in target project

Define sensors channels
and capturing frequency

Upload data files to
MLOps system, forexample Qeexo AutoML

Feature extraction

Validate ML model using
Arm Virtual Hardware

Create metadata files to
describe sensor data

23

D ATA I M P O R T
TO MLOPS

ML model selection
Parameter optimization

Capture SDS data files

Model Validation

Verify SDS data files using
a viewer

Model conversion anddownload

Confidential © 2024 Arm

Final system test in target
hardwareTool Components
for Microsoft Visual
Studio CodeJoe Alderson

Confidential © 2024 Arm

Flexible extensions for embedded and IoT
A composable set ofMicrosoft Visual Studio Codeextensions
Use together as part of MDK
v6 or separately
Plug and play device support
for debug probes anddevelopment boards
Access to the CMSIS Packecosystem
Integration of Open-CMSISPack
25

Confidential © 2024 Arm

Extend your tools with extensions and APIs

Integrate Arm’s extensions into yourtools products and workflows, creating
the best overall experience for yourdevelopers
Use the VS Code dependency systemor access the extension API directly
26

Confidential © 2024 Arm

Access device information andsoftware examples from the OpenCMSIS Pack ecosystem through APIs toenhance your websites or tools
products
Contact Arm about API accessValidate middleware dependencies
Choose from professional
middleware in thousands of
CMSIS-Packs
Resolve dependencies acrossyour stack automaticallyDownload and installrequired CMSIS-Packs with asingle click27

Confidential © 2024 Arm

Pin tools versions

Keep your engineering team in sync acrosstools, source code and project settings
Create reproducible builds that pin yourcompiler, debugger, CMSIS toolbox and third
party build tools like ninja
Share your configuration with your teamthrough source control

28

Confidential © 2024 Arm

Rapid prototyping with code templates
Copy code template files directly
into your application to build up
your solution quickly
Software components are shippedwith example templates
Once a component has been
added, you can select the
template easily from the solution
outline view

29

Confidential © 2024 Arm

New solutions
Create your next solution from a basic
template, or start from one ofthousands of examples
Pre-set device and core information for
10,000+ MCUs and hundreds ofdevelopment boards
Pick from Arm Compiler 6, GCC or LLVM
to get started
Handle complex edits and flags directlyin the Open CMSIS Pack yml files

30

Confidential © 2024 Arm

Arm Keil Studio Pack – Essential VS Code Extensions
Project & Build

Description

Used Services

Arm CMSIS csolution (*)

Create and Manage CMSIS based projects

CMSIS-Toolbox (CMake, Ninja), Compiler (AC6, GCC, LLVM)
Arm License Manager – for activation of Arm Compiler

Arm Environment
Manager

Arm Tools installation and activation

MSFT vcpkg
Arm License Manager – for activation of Arm Compiler

clangd (LLVM)

Intellisense

YAML (RedHat)

YAML Language Support

Debug

Description

Used Services

Arm Debugger

Debug for Cortex-M/A processors

Arm CLI Debugger, MSDAP

Arm Device Manager

Manages device connections andconfiguration for Arm Cortex-M

ULINK series, CMSIS-DAP, ST-Link, Arm Fixed Virtual Platforms

Eclipse CDT Cloud
Memory Inspector
Peripheral Inspector
Web Socket
31

Confidential © 2024 Arm

Memory Window
SVD supported access to peripherals

MSDAP

Tools Roadmap
Visual Studio
Code - CMSISMDK v6••AC6.22 support
Keil Studio Desktop

Enhanced local CMSISPack support• 3rd party code generator• µVision v5.40
•

•
•

CMSIS

•

AC6.23 support
Reference Apps with Layerdiscovery•

Improved Cmake Backend
Pre/Post build

Core register view
Memory inspector• Run on remote AVH• Debug connection config•

2024-CQ1
Confidential © 2024 Arm

CMSIS-Toolbox 2.4.0

•

•

•

•

Arm Debugger 6.1.1••

CMSIS 6.1.0
Maintenance release
Cortex-M52• C++ Vector Operations

Feature enhancement
Off-chip memory support
via scripting• Strategy for Cortex-A/M
debug configuration•

2024-CQ2
Done

Committed

Cortex-A/M Support

Middleware 8.1.0

Free-to-use
For all compilers: AC6,
GCC, IAR, LLVM

CMSIS-Toolbox 2.3.0
•

32

•

Middleware 8.0.0

MDKMiddleware

Visual Studio
Code - Debug

MDK v6.x

MDK v6.1

MaintenanceCollecting Requirements

CMSIS 6.2.0•

Cortex-A/M••

Tentative

Collecting
Requirements

Arm Debugger 6.x

Initial multicore support
RTOS aware processes andthreads stack view2024-CQ3

Maintenance

Enhanced disassemblyview• Define future tracearchitecture•2024-CQ4
Requested

Security
Secure debug
authentication• Segger JLink•

2025-CQ1

Trace and events
Trace visualisation
Component viewer• Event recorder••

FutureLLVM Embedded Toolchain (LLVM ET) for Arm - Status
LLVM-embedded-toolchain-for-Arm in Github
Components

Performance

GCC is a bit better on synthetic benchmarks on smaller cores• LLVM is much better on application benchmarks (like CMSIS DSP)
on bigger cores, especially ones with MVE• clang•• LLVM binutils

Code size• picolibc C standard library

•

• lld

Experimental newlib is available – feedback is needed
Considering LLVM libc in future (currently incomplete)• LLVM libc++ C++ standard library

Release follows the upstream LLVM schedule• Current 17.0.1• April 2024: 18.0.0• October 2024: 19.0.0

How to get involved• Github project – report issues, create PRs• Working Group sync up – every 4 weeks

33

LLVM ET vs. GCC

Confidential © 2024 Arm

Density of code generation is similar• picolibc is comparable to newlib-nano

LLVM ET vs. Arm Compiler 6• Most of optimization work is upstream’ed

With optimize settings reaches ~95% on MVE

Jump threading (-mllvm -enable-dfa-jump-thread)• Inlining threshold (-mllvm -inline-threshold=500)• Loop unrolling threshold (-mllvm -unroll-threshold=450)•

Going forward provide an optimization tuning guideor predefined config files

Automated delivery of Arm tools
Tool deployment to MDK (VS Code), CI SaaS, and MLOps
Git
RepositoryMDK(VS Code)

MLOps System(i.e. Qeexo)

SaaS CI System(i.e. GitHub)

vcpkg
configurationvcpkg enabled

Direct access/vcpkg enabled

Direct accessTools installedon demandUser Code

ML Modelartifacts.tools.arm.com provides access to
all tools for installation in different
environments.
Microsoft vcpkg simplifies the tool
installation across various host systems.
• The vcpkg_configuration.json file specifies therequired tools.
• Adding vcpkg_configuration.json to the project
ensures consistent setup.

MLOps and CI systems may access tools
directly.
tools
artifactory

34

Confidential © 2024 Arm

Consistent, project-specific tools setup

Example for Docker setup:
github.com/ARM-software/AVH-MLOps

It’s demo time

Joachim Krech
Confidential © 2024 Arm

Create Reusable
Software Stacks

Reinhard Keil

Confidential © 2024 Arm

What is a software component?
Provided Interfaces

Interfaces to user application orother software components

Software component
API headers

User code
templates

Configuration
files

Source code/
libraries

Required Interfaces

Documentation

Debug viewdescription

Interfaces to device peripherals orother software components• A software component encapsulates a set of related functions.
• Components should be substitutable by other components at design time.
• Components can have dependencies on other components.
37

Confidential © 2024 Arm

Connecting software components- component: <1>- component: <1>

API headers

API header

Configuration
files

Source code/
libraries

Configuration
files

Source code/
libraries

Documentation

API headers(Definition)

Documentationof API

Source code/
libraries

Source code/
libraries

Source code/
libraries- component: <2.A>- component: <2.B>- component: <2.C>

Central
API definition- component: <2>
API header

Configuration
files
38

Confidential © 2024 Arm

Source code/
libraries

Relationships of packs and software components• Packs can require other packs to be available:
Pack A
Version n

Pack B
Version m• Components can have dependencies on other components; either from the same orfrom other packs:
Pack A, Version n

Component A

39

Confidential © 2024 Arm

Pack B, Version m

Component B

Component C

Component A

Component B

Component C

Example: MDK Middleware
Network• IPv4/IPv6 TCP/IP connectivity via

Ethernet or serial connectionUSB• USB Host and USB Device support• High-performance, small footprint• No need for Windows/Linux drivers

File System• ROM, RAM, Flash, SD/MMC/SDHC• FAT32 support• Simultaneous device accessmbedTLS
40

Confidential © 2024 Arm

Pack Datasheet
Overview Text (Readme)

41

Confidential © 2024 Arm

List of all components

Other packs required

Distribution of Reference Application Examples
Example: Sensor SDK Pack (NXP_Sensor_SDK) that contains:•••

Agnostic middleware for a sensor that is configurable (part of the Reference Application)
Board/Device agnostic examples uses this middleware (part of the Reference Application)
One or more Shield layers that provides configuration settings for the agnostic middleware

Board Layers are provided by a Board Support BSP Pack that is board specific•Connections describe the compatibility of the different layers

Sensor SDK Pack PDSC:

Sensor SDK Pack
Reference Application(<sensor>.csolution.yml / <sensor>.cproject.yml)
Driver APIs

Shield-specific API

Layer Type: Board

Layer Type: Shield(<board-name>.clayer.yml)

BSP Pack
42

Confidential © 2024 Arm(<shield-name>.clayer.yml)<example> describes Reference Application<clayer> describes <shield-name>.clayer.yml
BSP Pack PDSC:<clayer> describes <board-name>.clayer.yml

Reference Application Examples: MDK Middleware
Connections exemplified on MDK Middleware
Example cproject.yml
project:

connections:- connect: FTP Server
provides:- CMSIS-RTOS2
consumes:- CMSIS_ETH: 0- CMSIS_MCI: 0- CMSIS_VIO- STDOUT

43

Confidential © 2024 Arm

Board clayer.yml

layer:
type: Board
connections:- connect: IMXRT1050-EVKB Board
consumes:- CMSIS-RTOS2
provides:- CMSIS_ETH: 0- CMSIS_MCI: 0- CMSIS_VIO- ARDUINO_UNO_UART: 3- ARDUINO_UNO_D2:- ARDUINO_UNO_D19- STDIN- STDOUT- STDERR- Heap: 65536

Command-Line workflow:
solution:
cdefault:
target-types:# Step 1: Specify your board, for example with:#- type: IMXRT1050-EVKB Board#
board: NXP::IMXRT1050-EVKB# Step 2: Run `cbuild setup` and use cbuild-idx.yml to identify variables#
variables:#- Board-Layer: ./layer/board/imxrt1050-iot.clayer.yml

IDE workflow:
1.User selects a reference example and specifies a board• IDE runs `cbuild setup` command, this generates `cbuild-idx.yml` withvariable settings• This command installs a potential missing BSP and DFP pack
• IDE shows one or more potential configurations

2. User selects a configuration• IDE copies variable settings from `cbuild-idx.yml` to `csolution.yml`
which adds the layers• Note: layers may be copied to workspace

Software Stack Validation – from Virtual to Physical Hardware
Validation on Arm Virtual Hardware (AVH) in CI systems; Deployment to physical devices

Unit & Integration Testing on AVH or Physical Hardware Boards

User Application
Code

IoT/ML Software
Platform

IoT/ML Software
PlatformMore Software

Virtual Drivers

HW Drivers

HW Drivers

More Drivers

Confidential © 2024 Arm

Device SDK withconfiguration
Real I/O via test
equipment

TargetLayer

IoT/ML Software
Platform

Simulated I/O via
Python scripts
and stimuli files

44

User Application
Code

Board
Layer

VirtualLayer

User Application
Code

Deployment and System Testing on Production Hardware

Device SDK with configuration
Real I/O via
user peripherals

Validate software stacks using different Compilers & AVH

45

Confidential © 2024 Arm

Virtual Workshop: Create Scalable Software Packs
11. June 2024, 15:00 – 17:00 GMT
Topics:Overall structure of a scalable software packTools for creating software packs
Taxonomy of software components
API interfaces
Reference application examples
Testing and validation
Register via: cmsis@arm.com

46

Confidential © 2024 Arm

More CMSIS Innovations- C++ Matrix and Vector Compute Algorithms- CMSIS-SVD Improvements- CMSIS-Pack Download Authorization

Reinhard Keil

Confidential © 2024 Arm

C++ templates for matrix and vector operations (experimental)
Documentation: https://arm-software.github.io/CMSIS-DSP/main/dsppp_main.html
Example:constexpr int NB = 32;
Vector<float32_t,NB> a;
Vector<float32_t,NB> b;
Vector<float32_t,NB> c;
Vector<float32_t,NB> d = a + b * c;

All vector operations (+,*) are done in
one pass with one loop.
There is no more any temporary buffer.

Matrix operations:• operators: +, -, *• dot for vector / matrix products• diagonal to create a diagonal matrix from a vector.
• identity to create an identity matrix• transpose to create the transposed matrix• outer for the outer product of two vectors• VectorView (slice of a matrix)• MatrixView (subset of a matrix)

Please give feedback, i.e. via github.com/ARM-software/CMSIS-DSP/issues
48

Confidential © 2024 Arm

Example: Matrix inverse (Gauss-Jordan with pivot algorithm)
C Implementation (like in CMSIS-DSP)

C++ Implementation using templates

Total = 70 lines - All datatypes and architectures

Total = 130 lines (without comments) - only for f32 Helium

49

Confidential © 2024 Arm

Matrix inverse f32 (cycles) Arm Compiler 6.21
dims

C++

C

C++ Improvement

4x4
8x8
16 x 16

776
4008
19314

1298
5285
24914

40.22%
24.16%
22.48%

Open-CMSIS-Pack Project
Request for feedback on these proposed enhancements
CMSIS-SVD Improvements
SVD files describe the peripherals of one device
Using conditions and includes device variants
could be described• github.com/Open-CMSIS-Pack/svd-spec/issues/5• github.com/Open-CMSIS-Pack/svd-spec/issues/6

This results in CMSIS-SVD 2.0• For backward compatibility a converter to

CMSIS-SVD 1.0 format is required

Aspects of 64-bit architectures should beconsidered in CMSIS-SVD 2.0
What other features are missing?

50

Confidential © 2024 Arm

Pack Download Authentication
Packs can be behind an access protection, butauthentication in CMSIS-Pack tools is missing
Proposal is to work on authentication for packaccess; this could be potentially used forcommercial software.

Additional Standardize APIs?
IoT Socket 2.0 multiple sockets and multicast• Supports Matter

PWM standardization for motor control• Enable shields with motor control hardware

We are committed to CMSIS and requirements for ML …
… and we will make it work for you – but we need your help
Open-CMSIS Technical Meeting every Tuesday, 15:00 GMT

Virtual Workshop: Create Scalable Software Packs• Audience: software vendors• 11. June 15:00 – 17:00 GMT

Feedback via github issues on the various projects• github.com/arm-software/cmsis_6 – project overview• github.com/ARM-software/CMSIS_6/issues – for CMSIS core components• github.com/ARM-software/AVH-MLOps/issues – for ML components• https://github.com/ARM-software/arm-2d – Graphics utilizing Helium

51

Confidential © 2024 Arm

To get an invite
to these
virtual meetings
send email to:
cmsis@arm.com

Questions?

Confidential © 2024 Arm

Thank You
DankeGraciasGrazie谢谢
ありがとう
AsanteMerci감사합니다ध"यवाद
Kiitos‫ﺷﻛًرا‬ধন#বাদ
‫תודה‬
Confidential © 2024 Armధన#$ాదమ(ల*The Arm trademarks featured in this presentation are registeredtrademarks or trademarks of Arm Limited (or its subsidiaries) in
the US and/or elsewhere. All rights reserved. All other marks
featured may be trademarks of their respective owners.
www.arm.com/company/policies/trademarks

Confidential © 2024 Arm