home / skills / a5c-ai / babysitter / arm-cortex-m

This skill provides deep ARM Cortex-M expertise for core configuration, peripheral programming, and low-level optimization to enhance embedded projects.

npx playbooks add skill a5c-ai/babysitter --skill arm-cortex-m

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
2.9 KB
---
name: arm-cortex-m
description: Deep expertise in ARM Cortex-M architecture and peripherals
category: Microcontroller Architecture
allowed-tools:
  - Bash
  - Read
  - Write
  - Edit
  - Glob
  - Grep
---

# ARM Cortex-M Skill

## Overview

This skill provides deep expertise in ARM Cortex-M architecture, including core configuration, peripheral programming, and low-level optimization for the most widely used embedded processor family.

## Capabilities

### CMSIS Integration
- CMSIS-Core configuration and usage
- CMSIS-Driver integration
- CMSIS-DSP library utilization
- CMSIS-RTOS abstraction
- Device header file management

### NVIC Configuration
- Interrupt priority configuration
- Priority grouping setup
- Vector table relocation
- Interrupt enable/disable patterns
- Nested interrupt handling

### Memory Protection Unit (MPU)
- MPU region setup and configuration
- Memory attribute configuration
- Protection scheme design
- Stack overflow protection
- Peripheral isolation

### System Timers
- SysTick timer configuration
- DWT cycle counter usage
- Timer-based profiling
- Timestamp generation
- Delay implementations

### Fault Handling
- HardFault analysis and debugging
- BusFault configuration
- UsageFault detection
- MemManage fault handling
- Fault register interpretation

### Low-Level Optimization
- ARM assembly for critical sections
- Bit-banding operations
- Atomic operations (LDREX/STREX)
- Barrier instructions (DSB, DMB, ISB)
- Compiler intrinsics

### Power Management
- WFI/WFE instruction usage
- Sleep mode entry/exit
- Wake-up source configuration
- Low-power mode selection
- Power domain management

## Target Processes

- `bsp-development.js` - BSP with Cortex-M support
- `isr-design.js` - Interrupt architecture design
- `memory-architecture-planning.js` - Memory layout with MPU
- `real-time-architecture-design.js` - Real-time Cortex-M design
- `bootloader-implementation.js` - Cortex-M bootloader

## Dependencies

- ARM CMSIS headers
- Cortex-M technical reference manual
- Device-specific headers

## Usage Context

This skill is invoked when tasks require:
- Cortex-M core configuration
- Interrupt system design
- MPU setup and protection
- Fault debugging and analysis
- Low-level performance optimization

## Architecture Support

| Core | Features |
|------|----------|
| Cortex-M0/M0+ | Minimal, low-power |
| Cortex-M3 | Full Thumb-2, MPU optional |
| Cortex-M4 | DSP, optional FPU |
| Cortex-M7 | Cache, dual-issue |
| Cortex-M23 | TrustZone-M, security |
| Cortex-M33 | TrustZone-M, DSP |
| Cortex-M55 | MVE (Helium), ML |

## Example Configurations

### NVIC Priority
```c
NVIC_SetPriorityGrouping(3);  // 4 bits preemption, 0 bits sub
NVIC_SetPriority(USART1_IRQn, NVIC_EncodePriority(3, 2, 0));
NVIC_EnableIRQ(USART1_IRQn);
```

### MPU Region
```c
MPU->RNR = 0;  // Region 0
MPU->RBAR = 0x20000000;  // Base address
MPU->RASR = MPU_RASR_ENABLE_Msk |
            (0x0F << MPU_RASR_SIZE_Pos) |  // 64KB
            MPU_RASR_C_Msk | MPU_RASR_S_Msk;
```

Overview

This skill delivers deep, practical expertise in ARM Cortex-M architecture, peripherals, and low-level optimization for embedded systems. It targets core configuration, interrupt and MPU design, fault analysis, system timers, and power management across Cortex-M families. The guidance is focused on actionable patterns and code-level considerations for reliable, real-time firmware.

How this skill works

The skill inspects target core features and maps them to configuration patterns: CMSIS integration, NVIC priority schemes, MPU region layouts, and timer/fault handling strategies. It recommends concrete register-level and CMSIS idioms, assembly snippets, and performance primitives (LDREX/STREX, barriers, bit-banding) to achieve deterministic, low-latency behavior. It also helps choose power modes, wake-up sources, and isolation strategies for safe, low-power operation.

When to use it

  • Designing or reviewing BSPs and startup code for Cortex-M devices.
  • Architecting interrupt systems and priority/grouping strategies for real-time tasks.
  • Creating MPU layouts to isolate peripherals and protect stacks.
  • Debugging HardFaults, BusFaults, UsageFaults, or tuning fault handlers.
  • Optimizing critical paths with assembly, barriers, or atomic primitives.

Best practices

  • Use CMSIS device headers and driver abstractions to keep code portable and reviewable.
  • Define NVIC priority grouping early; document preemption vs subpriority rules.
  • Lock down MPU regions from coarse-to-fine: flash, RAM, stacks, peripherals, then user regions.
  • Prefer compiler intrinsics for atomics and barriers; use assembly only for micro-optimizations.
  • Instrument SysTick and DWT cycle counters for profiling before guessing hotspots.

Example use cases

  • Implementing a BSP that initializes vector table, clock, and MPU for a new board.
  • Designing an ISR topology for mixed latency workloads (sensor sampling vs comms).
  • HardFault triage: extract stacked regs, decode LR/PC, and correlate to source lines.
  • Implementing a bootloader that relocates vector table and configures memory protections.
  • Tuning low-power entry/exit to minimize wake latency while preserving peripheral state.

FAQ

Which Cortex-M cores support an MPU or TrustZone?

MPU support varies: many M3/M4/M7/M33/M55 devices include MPUs; M23/M33/M55 can include TrustZone-M. Check the device-specific reference manual and CMSIS headers for availability.

When should I use LDREX/STREX vs disabling interrupts?

Use LDREX/STREX for short atomic updates on shared data in SMP-like contexts or when interrupt latency must be preserved; disable interrupts only for very short, deterministic critical sections when atomic primitives are unavailable or too costly.