CMSIS

What is CMSIS?
CMSIS Peripheral Access Layer
CMSIS Middleware Access Layer
CMSIS – Structure and functional flow
CMSIS – Files for Peripheral Access Layer
CMSIS – Files for Peripheral Access Layer
CMSIS – Example Code
CMSIS – Example code
CMSIS – Example code
Device-specific Header for stm32.h
ITM Debug Access
 Introduction to CMSIS
Cortex Microcontroller Software Interface Standard
(CMSIS)

© 2019 Arm Limited

What is CMSIS?
• CMSIS gives a consistent programming interface for all cortex-M
processes from ARM
Cortex Microcontroller Software Interface Standard
(CMSIS)
• CMSIS: Cortex Microcontroller Software Interface Standard
• A vendor-independent hardware abstraction layer for the Cortex-M processor series
• Provides a standardized software interface, such as library functions, which help control the processor more easily, e.g.
configuring the Nested Vectored Interrupt Controller (NVIC)
• Improves software portability across different Cortex-M processors and Cortex-M based microcontrollers

low level programming higher-level CMSIS programming

Configure Cortex-M by directly accessing Configure Cortex-M processors

registers in its internal memory space by using CMSIS libraries
e.g. *(unsigned int*) NVIC_INT_ENABLE = 0x01; e.g. NVIC_EnableIRQ(Timer_IRQn);

API Arm CMSIS-Core

Cortex-M0

Cortex-M
Arm Cortex-M
Cortex-M3
Processor
Cortex-M4
What is Standardized by CMSIS?
• Functions to access, e.g., NVIC, System Control Block (SCB) and System Tick timer
• Enables an interrupt or exception: NVIC_EnableIRQ (IRQn_Type IRQn)
• Sets pending status of interrupt: void NVIC_SetPendingIRQ (IRQn_Type IRQn)

• Access to special registers e.g.

• Read PRIMASK register: uint32_t __get_PRIMASK (void)

• Set CONTROL register: void __set_CONTROL (uint32_t value)

• Functions to access special instructions e.g.

• REV: uint32_t __REV(uint32_t int value)
• NOP: void __NOP(void)

• Names of system initialization functions e.g.

• System initialization: void SystemInit (void)
Benefits of CMSIS
• Easier to port application code from one Cortex-M based microcontroller to another Cortex-M based
microcontroller
• Easier to reuse the same code between different Cortex-M based microcontrollers
• Better compatibility when integrating third-party software components, since all third-
party components such as applications, embedded OS, middleware etc., can share the
same standard CMSIS interface
• Better code density and smaller memory footprint, since the codes in CMSIS have been
optimized and tested
• CMSIS gives a consistent programming interface for all cortex-M processes from ARM
• The CMSIS standard was first introduced in 2008 and is today widely adopted by Silicon
vendors and software development tools.
• CMSIS simplifies software reuse and reduces learning curve for developers. This
accelerated the time to market for new cortex _M based devices and allows focusing
innovation towards device performance and peripherals.
 CMSIS Components
The CMSIS consists of the following components:
• CMSIS-CORE – Gives access to the cortex-m processor and the core peripherals. It defines standard
ways to access device peripherals and interrupts. The debug interface provides functions for test
messages and auto threat information.
• CMSIS-DSP – Full-featured DSP library with over 60 algorithms available for all cortex-M processes.
The cortex M4 implementation is optimized for the hardware floating point units. Fixed point
functions are therefore twice as fast and floating point functions even 10 times faster.
• CMSIS-RTOS API – New API standard which is portable to many RTOS kernels. Programmers can now
rely on standard RTOS features and can therefore use these capabilities in source code templates,
middle ware libraries and other software components. CMSIS RTOS is already supported by the
RTOS kernel.
• CMSIS-SVD – It is the XML standard that describes the peripherals of a device. SVD files gives
peripheral awareness in debuggers and allow generating device header files for CMSIS Core. SVD
files created by silicon vendors can be downloaded from CMSISarm.com
• In this module, we will focus on using CMSIS-CORE
CMSIS-DAP
• CMSIS-DAP is an interface firmware
for the debug unit that connects the
debug port to USB
Arm
Development
Studio
• Debuggers can connect via USB to Debugger

the debug unit and to the device

running the application software

• The debug unit is connected to the

target device via JTAG or SW

• The Arm-Cortex processors then

provide the CoreSight Debug and
Trace Unit
CMSIS Functions: Access NVIC
CMSIS Function Description
void NVIC_EnableIRQ (IRQn_Type IRQn) Enables an interrupt or exception.
void NVIC_DisableIRQ (IRQn_Type IRQn) Disables an interrupt or exception.

void NVIC_SetPendingIRQ (IRQn_Type IRQn) Sets the pending status of interrupt or exception to 1.

void NVIC_ClearPendingIRQ (IRQn_Type IRQn) Clears the pending status of interrupt or exception to 0.

Reads the pending status of interrupt or exception. This

uint32_t NVIC_GetPendingIRQ (IRQn_Type IRQn)
function returns non-zero value if the pending status is set to 1.

Sets the priority of an interrupt or exception with configurable

void NVIC_SetPriority (IRQn_Type IRQn, uint32_t priority)
priority level to 1.
Reads the priority of an interrupt or exception with
uint32_t NVIC_GetPriority (IRQn_Type IRQn) configurable priority level. This function return the current
priority level.
CMSIS Functions: Access Special Registers
Special Register Access CMSIS Function

Read uint32_t __get_PRIMASK (void)

PRIMASK
Write void __set_PRIMASK (uint32_t value)

Read uint32_t __get_CONTROL (void)

CONTROL
Write void __set_CONTROL (uint32_t value)

Read uint32_t __get_MSP (void)

MSP
Write void __set_MSP (uint32_t TopOfMainStack)

Read uint32_t __get_PSP (void)

PSP
Write void __set_PSP (uint32_t TopOfProcStack)
CMSIS Functions: Execute Special Instructions
Instruction CMSIS Intrinsic Function
CPSIE i void __enable_irq(void)
CPSID i void __disable_irq(void)
ISB void __ISB(void)
DSB void __DSB(void)
DMB void __DMB(void)
NOP void __NOP(void)
REV uint32_t __REV(uint32_t int value)
REV16 uint32_t __REV16(uint32_t int value)
REVSH uint32_t __REVSH(uint32_t int value)
SEV void __SEV(void)
WFE void __WFE(void)
WFI void __WFI(void)
CMSIS Functions: Access System
CMSIS Function Description

void NVIC_SystemReset(void) Initiate a system reset request

uint32_t SysTick_Config(uint32_t ticks) Initialize and start the SysTick counter and its interrupt

void SystemInit (void) Initialize the system

void SystemCoreClockUpdate(void) Update the SystemCoreClock variable