Cortex-M0+ Processor

* CoreMark: 1.0 : 21.46 /ARM C Compiler 5.03 [Build 24] -O3 --loop_optimization_level=2   -Otime  -DMICROLIB --library_type=microlib  --cpu=cortex-m0 / FPGA platform, Code in SRAM - Data in SRAM, memory and CPU clocked @10MHz

** The lower result is with inlining turned off (as per dhrystone recommendations), the higher result is with inlining turned on (as reported for other processor architectures). Dhrystone v2.1.

*** Base usable configuration includes 1 IRQ + NMI, excludes debug

ARM Cortex-M technologies

Each Cortex-M series processor delivers specific benefits, all underpinned by fundamental technologies that make Cortex-M processors ideal for a broad range of embedded applications.

CMSIS

The ARM Cortex Microcontroller Software Interface Standard (CMSIS) is a vendor-independent hardware abstraction layer for the Cortex-M processor series. The CMSIS enables consistent and simple software interfaces to the processor for interface peripherals, real-time operating systems, and middleware, simplifying software re-use. CMSIS reduces the learning curve for new microcontroller developers, shortening the time to market for new products.

In-depth: Nested Vectored Interrupt Controller (NVIC)

The NVIC is an integral part of Cortex-M processors and provides the processors' outstanding interrupt handling abilities. The Cortex-M processor uses a vector table that contains the address of the function to be executed for a particular interrupt handler. On accepting an interrupt, the processor fetches the address from the vector table.

To reduce gate count and enhance system flexibility, the Cortex-M processor uses a stack based exception model. When an exception takes place, the Cortex-M processor pushes critical general-purpose onto the stack. Once the stacking and instruction fetch are completed, the interrupt service routine or fault handler is executed, followed by the automatic restoration of the registers to enable the interrupted program to resume normal execution. This approach removes the need to write assembler wrappers that are required to perform stack manipulation for traditional C-based interrupt service routines, making application development significantly easier. The NVIC supports nesting (stacking) of interrupts, allowing earlier servicing of an interrupt by exerting higher priority.

Complete response to interrupts in hardware

The interrupt response of Cortex-M series processor is the number of cycles from interrupt signal to execution of interrupt service routine. It includes:

• Detecting the interrupt
• Optimal handling of back-to-back or late arriving interrupts (see below)
• Fetching the vector address
• Stacking corruptible registers
• Branching to the interrupt handler

These are tasks that are performed in hardware and included in the interrupt response cycle time quoted for Cortex-M processors. In many other architectures these tasks must be performed in a software in the interrupt handler, introducing latency and complexity.

Tail chaining in the NVIC

In the case of back-to-back interrupts, traditional systems would repeat the complete state save and restore cycle twice, resulting in higher latency. The Cortex-M processors simplify moving between active and pending interrupts by implementing tail-chaining technology in the NVIC hardware. In fewer cycles than a software implementation, the processor state is saved automatically on interrupt entry and restored on interrupt exit. This significantly enhances performance in low MHz systems.

Response of the NVIC to late arrival of higher priority interrupts

In case of the late arrival of a higher priority interrupt during the execution of the stack Push for a previous interrupt, the NVIC immediately fetches a new vector address to service the pending interrupt, as shown above. The Cortex-M NVIC provides deterministic response to these possibilities with support for late arrival and pre-emption.

Stack pop pre-emption by the NVIC

Similarly, the NVIC abandons a stack Pop if an exception arrives and services the new interrupt immediately as shown above. By pre-empting and switching to the second interrupt without completing the state restore and save, the NVIC achieves lower latency in a deterministic manner.

ARM Cortex-M code size advantage explained

ARM Cortex-M processors offer superior code density to 8-bit and 16-bit architectures. This has significant advantages in terms of reduced memory requirements and maximizing the usage of precious on-chip Flash memory. In this section we examine the reasons for this advantage.

Instruction width

It is a common misconception that 8-bit microcontrollers use 8-bit instructions and ARM Cortex-M processor-based microcontrollers use 32-bit instructions. In reality for example, the PIC18 and PIC16 instruction sizes are 16-bit and 14-bit respectively. For the 8051 architecture, although some instructions are 1 byte long, many others are 2 or 3 bytes long. The same also applies to 16-bit architectures, where some instructions can take 6 bytes or more of memory.

The ARM Cortex-M3 and Cortex-M0 processors utilize the ARM Thumb^®-2 technology which provides excellent code density. With Thumb-2 technology, the Cortex-M processors support a fundamental base of 16-bit Thumb instructions, extended to include more powerful 32-bit instructions. In many cases a C compiler will use the 16-bit version of the instruction unless the operation can be carried out more efficiently using a 32-bit version.

Instruction efficiency

This picture is not complete without also considering that ARM Cortex-M processor instructions are more powerful. There are many circumstances where a single Thumb instruction equates to several 8/16-bit microcontroller instructions; this means that Cortex-M devices have smaller code and achieve the same task at lower bus speed.

Comparing 16-bit multiply operations across processor architectures

N.B. The Cortex-M multiply in fact performs a 32-bit multiply, here we assume r0 and r1 contain 16-bit data.

Compact data footprint

It is important to note that Cortex-M processors have support for 8-bit and 16-bit data tranfers, making efficient use of data memory. This means programmers can continue to use the same data-types as they have in 8/16-bit targeted software.

Energy efficiency advantage

The demand for ever lower-cost products with increasing connectivity (e.g. USB, Bluetooth, IEEE 802.15) and sophisticated analog sensors (e.g. accelerometers, touch screens) has resulted in the need to more tightly integrate analog devices with digital functionality to pre-process and communicate data. Most 8-bit devices do not offer the performance to sustain these tasks without significant increases in MHz and therefore power, and so embedded developers are required to look for alternative devices with more advanced processor technology. The 16-bit devices have previously been used to address energy efficiency concerns in microcontroller applications. However, the relative performance inefficiencies of 16-bit devices mean they will generally require a longer active duty cycle or higher clock frequency to accomplish the same task as a 32-bit device.

Ease of software development

Software development for ARM Cortex processor-based microcontrollers can be much easier than for 8-bit microcontroller products. Not only is the Cortex processor fully C programmable, it also comes with various enhanced debug features to help locating problems in software. There are also plenty of examples and tutorials on the internet, including many from ARM processor-based MCU vendor's websites, alongside any additional resources included in MCU development kits.

Resources

In this section, you will find useful documentation, white papers and tutorials on ARM Cortex-M processors and related technologies.

For further information including information on development tools, software, boards, and a device database, CMSIS and mBed visit the ARM Embedded Microsite

Books

Definitive Guide to the ARM Cortex-M0 A comprehensive guide to programming and implementing the groundbreaking ARM Cortex-M0 processor

Definitive Guide to the ARM Cortex-M3 A comprehensive guide to programming and implementing the groundbreaking ARM Cortex-M3 processor

 

Documentation for Cortex-M device users

• Cortex-M0+ Introduction (200KB PDF)
• Cortex-M1 FPGA Development Kit Tutorial
• Migrating from ARM7 to Cortex-M3 (256 KB )

Software development tools for Cortex-M device users

• Keil
• mbed
• Third party tools and RTOS support

Find Cortex-M based microcontrollers

• Keil microcontroller device database
• ARM MCU Community - www.onarm.com
• Find an ARM Partner

Universities

• ARM University Program

Related User Guides and App Notes

• Cortex-M0/3/4 Devices Generic User Guides
  • Developer Guides and Articles
    • Software Development
      • Cortex-M0 Devices Generic User Guide
      • Cortex-M3 Devices Generic User Guide
      • Cortex-M4 Devices Generic User Guide
• Instruction Timing Information
  • Cortex-M0 Technical Reference Manual (TRM)
  • Cortex-M3 Technical Reference Manual (TRM)
  • Cortex-M4 Technical Reference Manual (TRM)
• Architecture (requires registration)
  • ARMv7-M Architecture Reference Manual
  • ARMv6-M Architecture Reference Manual
• ARM Application Notes
  • AN237 - Migrating from 8051 to Cortex Microcontrollers
  • AN234 - Migrating from PIC Microcontrollers to Cortex-M3
  • AN179 - Cortex™-M3 Embedded Software Development
• Keil Application Notes
  • 193: Migrating to MDK-ARM from RVDS
  • 197: Serial-Wire Debug and Realtime Trace on STM32 Devices
  • 202: MDK-ARM Compiler Optimizations
  • 208: Keil uVision and Actel SmartFusion
  • 209: Using Cortex-M3 and Cortex-M4 Fault Exceptions
  • 220: Memory Configuration on Freescale Kinetis devices
  • 221: Using CMSIS-DSP Algorithms with RTX

DesignStart for Processor IP

• Cortex-M3 DesignStart Processor
• Cortex-M0 DesignStart Processor