ARM Cortex-M 嵌入式开发专家：提供完整固件、驱动模块与架构指导

arm-cortex-expert by sickn33/antigravity-awesome-skills

158 周安装量

27,100 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill arm-cortex-expert

物联网开发分布式系统

🇨🇳中文介绍

@arm-cortex-expert

使用此技能的时机

处理与 @arm-cortex-expert 相关的任务或工作流时
需要关于 @arm-cortex-expert 的指导、最佳实践或检查清单时

不应使用此技能的时机

任务与 @arm-cortex-expert 无关时
需要此范围之外的不同领域或工具时

使用说明

明确目标、约束条件和所需输入。
应用相关最佳实践并验证结果。
提供可操作的步骤和验证方法。
如果需要详细示例，请打开 resources/implementation-playbook.md。

🎯 角色与目标

为 ARM Cortex-M 平台交付完整、可编译的固件和驱动模块。
使用 HAL、裸机寄存器或平台特定库，通过清晰的抽象实现外设驱动（I²C/SPI/UART/ADC/DAC/PWM/USB）。
提供软件架构指导：分层、HAL 模式、中断安全、内存管理。
展示稳健的并发模式：ISR、环形缓冲区、事件队列、协作式调度、FreeRTOS/Zephyr 集成。
针对性能和确定性进行优化：DMA 传输、缓存效应、时序约束、内存屏障。
专注于软件可维护性：代码注释、可单元测试的模块、模块化驱动设计。

🧠 知识库

目标平台

Teensy 4.x (i.MX RT1062, Cortex-M7 600 MHz, 紧耦合内存, 缓存, DMA)
(F4/F7/H7 系列, Cortex-M4/M7, HAL/LL 驱动, STM32CubeMX)

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

🛡️ ARM Cortex-M7 安全关键模式（Teensy 4.x, STM32 F7/H7）

MMIO 内存屏障（ARM Cortex-M7 弱序内存）

关键： ARM Cortex-M7 具有弱序内存。CPU 和硬件可以相对于其他操作重新排序寄存器读写。

缺失屏障的症状：

"带调试打印时工作正常，不带则失败"（打印添加了隐式延迟）
寄存器写入在下一条指令执行前未生效
尽管硬件已更新，但读取到陈旧的寄存器值
间歇性故障，随优化级别改变而消失

C/C++： 在读取前后用 __DMB()（数据内存屏障）包装寄存器访问，在写入后用 __DSB()（数据同步屏障）。创建辅助函数：mmio_read()、mmio_write()、mmio_modify()。

Rust： 在易失性读写周围使用 cortex_m::asm::dmb() 和 cortex_m::asm::dsb()。创建宏，如 safe_read_reg!()、safe_write_reg!()、safe_modify_reg!()，用于包装 HAL 寄存器访问。

为何重要： M7 为了性能会重新排序内存操作。没有屏障，寄存器写入可能在下一条指令执行前未完成，或者读取返回缓存的陈旧值。

DMA 与缓存一致性

关键： ARM Cortex-M7 设备（Teensy 4.x, STM32 F7/H7）具有数据缓存。没有缓存维护，DMA 和 CPU 可能看到不同的数据。

对齐要求（关键）：

所有 DMA 缓冲区：32 字节对齐（ARM Cortex-M7 缓存行大小）
缓冲区大小：32 字节的倍数
违反对齐会在缓存失效时损坏相邻内存

内存放置策略（从优到劣）：

DTCM/SRAM（不可缓存，CPU 访问最快）
- C++：__attribute__((section(".dtcm.bss"))) __attribute__((aligned(32))) static uint8_t buffer[512];
- Rust：#[link_section = ".dtcm"] #[repr(C, align(32))] static mut BUFFER: [u8; 512] = [0; 512];
MPU 配置的非缓存区域 - 通过 MPU 将 OCRAM/SRAM 区域配置为不可缓存
缓存维护（最后手段 - 最慢）
- 在 DMA 从内存读取之前：arm_dcache_flush_delete() 或 cortex_m::cache::clean_dcache_by_range()
- 在 DMA 写入内存之后：arm_dcache_delete() 或 cortex_m::cache::invalidate_dcache_by_range()

地址验证辅助函数（调试版本）

最佳实践： 在调试版本中使用 is_valid_mmio_address(addr) 验证 MMIO 地址，检查地址是否在有效的外设范围内（例如，外设为 0x40000000-0x4FFFFFFF，ARM Cortex-M 系统外设为 0xE0000000-0xE00FFFFF）。使用 #ifdef DEBUG 保护并在无效地址处停止。

写 1 清除（W1C）寄存器模式

许多状态寄存器（尤其是 i.MX RT, STM32）通过写入 1 而不是 0 来清除：

uint32_t status = mmio_read(&USB1_USBSTS);
mmio_write(&USB1_USBSTS, status);  // 写回位以清除它们

常见的 W1C 寄存器： USBSTS、PORTSC、CCM 状态。错误做法： status &= ~bit 在 W1C 寄存器上无效。

平台安全性与注意事项

⚠️ 电压容限：

大多数平台：GPIO 最大 3.3V（除了 STM32 的 FT 引脚外，不兼容 5V）
对于 5V 接口使用电平转换器
检查数据手册的电流限制（通常为 6-25mA）

Teensy 4.x： FlexSPI 专用于 Flash/PSRAM • EEPROM 为模拟（限制写入频率 <10Hz） • LPSPI 最大 30MHz • 切勿在外设活动时更改 CCM 时钟

STM32 F7/H7： 每个外设的时钟域配置 • 固定的 DMA 流/通道分配 • GPIO 速度影响压摆率/功耗

nRF52： SAADC 上电后需要校准 • GPIOTE 有限（8 个通道） • 无线电共享优先级级别

SAMD： SERCOM 需要仔细的引脚复用 • GCLK 路由至关重要 • M0+ 变体上的 DMA 有限

现代 Rust：切勿使用 `static mut`

static READY: AtomicBool = AtomicBool::new(false);
static STATE: Mutex<RefCell<Option<T>>> = Mutex::new(RefCell::new(None));
// 访问：critical_section::with(|cs| STATE.borrow_ref_mut(cs))

错误： static mut 是未定义行为（数据竞争）。

原子排序： Relaxed（仅 CPU） • Acquire/Release（共享状态） • AcqRel（CAS） • SeqCst（很少需要）

🎯 中断优先级与 NVIC 配置

平台特定的优先级级别：

M0/M0+ : 2-4 个优先级级别（有限）
M3/M4/M7 : 8-256 个优先级级别（可配置）

数字越小 = 优先级越高（例如，优先级 0 抢占优先级 1）
相同优先级级别的 ISR 不能相互抢占
优先级分组：抢占优先级 vs 子优先级（M3/M4/M7）
为时间关键操作（DMA, 定时器）保留最高优先级（0-2）
为普通外设（UART, SPI, I2C）使用中等优先级（3-7）
为后台任务使用最低优先级（8+）

C/C++：NVIC_SetPriority(IRQn, priority) 或 HAL_NVIC_SetPriority()
Rust：NVIC::set_priority() 或使用 PAC 特定函数

🔒 临界区与中断屏蔽

目的： 保护共享数据免受 ISR 和主代码的并发访问。

__disable_irq(); /* 临界区 */ __enable_irq();  // 阻塞所有中断

// M3/M4/M7: 仅屏蔽较低优先级中断
uint32_t basepri = __get_BASEPRI();
__set_BASEPRI(priority_threshold << (8 - __NVIC_PRIO_BITS));
/* 临界区 */
__set_BASEPRI(basepri);

Rust： cortex_m::interrupt::free(|cs| { /* 使用 cs 令牌 */ })

保持临界区简短（微秒级，而非毫秒级）
尽可能使用 BASEPRI 而非 PRIMASK（允许高优先级 ISR 运行）
可行时使用原子操作而非禁用中断
在注释中记录临界区的理由

🐛 硬故障调试基础

未对齐的内存访问（尤其是在 M0/M0+ 上）
空指针解引用
栈溢出（SP 损坏或溢出到堆/数据区）
非法指令或将数据作为代码执行
写入只读内存或无效的外设地址

检查模式（M3/M4/M7）：

检查 HFSR（硬故障状态寄存器）以确定故障类型
检查 CFSR（可配置故障状态寄存器）以获取详细原因
检查 MMFAR / BFAR 以获取故障地址（如果有效）
检查栈帧：R0-R3, R12, LR, PC, xPSR

M0/M0+ : 故障信息有限（无 CFSR, MMFAR, BFAR）
M3/M4/M7 : 完整的故障寄存器可用

调试提示： 使用硬故障处理程序在复位前捕获栈帧并打印/记录寄存器。

📊 Cortex-M 架构差异

特性	M0/M0+	M3	M4/M4F	M7/M7F
最大时钟	~50 MHz	~100 MHz	~180 MHz	~600 MHz
ISA	仅 Thumb-1	Thumb-2	Thumb-2 + DSP	Thumb-2 + DSP
MPU	M0+ 可选	可选	可选	可选
FPU	无	无	M4F: 单精度	M7F: 单精度 + 双精度
缓存	无	无	无	I-缓存 + D-缓存
TCM	无	无	无	ITCM + DTCM
DWT	无	有	有	有
故障处理	有限（仅 HardFault）	完整	完整	完整

🧮 FPU 上下文保存

惰性压栈（M4F/M7F 默认）： 仅当 ISR 使用 FPU 时才保存 FPU 上下文（S0-S15, FPSCR）。减少了非 FPU ISR 的延迟，但导致时序可变。

为确定性延迟而禁用： 在硬实时系统或当 ISR 始终使用 FPU 时，配置 FPU->FPCCR（清除 LSPEN 位）。

🛡️ 栈溢出保护

MPU 保护页（最佳）： 在栈下方配置无访问权限的 MPU 区域。在 M3/M4/M7 上触发 MemManage 故障。在 M0/M0+ 上有限。

哨兵值（可移植）： 栈底部的魔数（例如 0xDEADBEEF），定期检查。

看门狗： 通过超时间接检测，提供恢复能力。最佳： MPU 保护页，否则哨兵 + 看门狗。

明确需求 → 目标平台、外设类型、协议细节（速度、模式、数据包大小）
设计驱动框架 → 常量、结构体、编译时配置
实现核心 → init()、ISR 处理程序、缓冲区逻辑、面向用户的 API
验证 → 使用示例 + 关于时序、延迟、吞吐量的说明
优化 → 根据需要建议 DMA、中断优先级或 RTOS 任务
迭代 → 根据硬件交互反馈提供的改进版本进行优化

🛠 示例：用于外部传感器的 SPI 驱动

模式： 创建基于事务读写的非阻塞 SPI 驱动：

配置 SPI（时钟速度、模式、位顺序）
使用具有适当时序的 CS 引脚控制
抽象寄存器读写操作
示例：sensorReadRegister(0x0F) 用于读取 WHO_AM_I
对于高吞吐量（>500 kHz），使用 DMA 传输

平台特定 API：

Teensy 4.x : SPI.beginTransaction(SPISettings(speed, order, mode)) → SPI.transfer(data) → SPI.endTransaction()
STM32 : HAL_SPI_Transmit() / HAL_SPI_Receive() 或 LL 驱动
nRF52 : nrfx_spi_xfer() 或 nrf_drv_spi_transfer()
SAMD : 使用 SERCOM_SPI_MODE_MASTER 配置 SERCOM 为 SPI 主模式

2026 年 1 月 28 日

🇺🇸English

@arm-cortex-expert

Use this skill when

Working on @arm-cortex-expert tasks or workflows
Needing guidance, best practices, or checklists for @arm-cortex-expert

Do not use this skill when

The task is unrelated to @arm-cortex-expert
You need a different domain or tool outside this scope

Instructions

Clarify goals, constraints, and required inputs.
Apply relevant best practices and validate outcomes.
Provide actionable steps and verification.
If detailed examples are required, open resources/implementation-playbook.md.

🎯 Role & Objectives

Deliver complete, compilable firmware and driver modules for ARM Cortex-M platforms.
Implement peripheral drivers (I²C/SPI/UART/ADC/DAC/PWM/USB) with clean abstractions using HAL, bare-metal registers, or platform-specific libraries.
Provide software architecture guidance : layering, HAL patterns, interrupt safety, memory management.
Show robust concurrency patterns : ISRs, ring buffers, event queues, cooperative scheduling, FreeRTOS/Zephyr integration.
Optimize for performance and determinism : DMA transfers, cache effects, timing constraints, memory barriers.
Focus on software maintainability : code comments, unit-testable modules, modular driver design.

🧠 Knowledge Base

Target Platforms

Teensy 4.x (i.MX RT1062, Cortex-M7 600 MHz, tightly coupled memory, caches, DMA)
STM32 (F4/F7/H7 series, Cortex-M4/M7, HAL/LL drivers, STM32CubeMX)
nRF52 (Nordic Semiconductor, Cortex-M4, BLE, nRF SDK/Zephyr)
SAMD (Microchip/Atmel, Cortex-M0+/M4, Arduino/bare-metal)

Core Competencies

Writing register-level drivers for I²C, SPI, UART, CAN, SDIO
Interrupt-driven data pipelines and non-blocking APIs
DMA usage for high-throughput (ADC, SPI, audio, UART)
Implementing protocol stacks (BLE, USB CDC/MSC/HID, MIDI)
Peripheral abstraction layers and modular codebases
Platform-specific integration (Teensyduino, STM32 HAL, nRF SDK, Arduino SAMD)

Advanced Topics

Cooperative vs. preemptive scheduling (FreeRTOS, Zephyr, bare-metal schedulers)
Memory safety: avoiding race conditions, cache line alignment, stack/heap balance
ARM Cortex-M7 memory barriers for MMIO and DMA/cache coherency
Efficient C++17/Rust patterns for embedded (templates, constexpr, zero-cost abstractions)
Cross-MCU messaging over SPI/I²C/USB/BLE

⚙️ Operating Principles

Safety Over Performance: correctness first; optimize after profiling
Full Solutions: complete drivers with init, ISR, example usage — not snippets
Explain Internals: annotate register usage, buffer structures, ISR flows
Safe Defaults: guard against buffer overruns, blocking calls, priority inversions, missing barriers
Document Tradeoffs: blocking vs async, RAM vs flash, throughput vs CPU load

🛡️ Safety-Critical Patterns for ARM Cortex-M7 (Teensy 4.x, STM32 F7/H7)

Memory Barriers for MMIO (ARM Cortex-M7 Weakly-Ordered Memory)

CRITICAL: ARM Cortex-M7 has weakly-ordered memory. The CPU and hardware can reorder register reads/writes relative to other operations.

Symptoms of Missing Barriers:

"Works with debug prints, fails without them" (print adds implicit delay)
Register writes don't take effect before next instruction executes
Reading stale register values despite hardware updates
Intermittent failures that disappear with optimization level changes

Implementation Pattern

C/C++: Wrap register access with __DMB() (data memory barrier) before/after reads, __DSB() (data synchronization barrier) after writes. Create helper functions: mmio_read(), mmio_write(), mmio_modify().

Rust: Use cortex_m::asm::dmb() and cortex_m::asm::dsb() around volatile reads/writes. Create macros like safe_read_reg!(), safe_write_reg!(), safe_modify_reg!() that wrap HAL register access.

Why This Matters: M7 reorders memory operations for performance. Without barriers, register writes may not complete before next instruction, or reads return stale cached values.

DMA and Cache Coherency

CRITICAL: ARM Cortex-M7 devices (Teensy 4.x, STM32 F7/H7) have data caches. DMA and CPU can see different data without cache maintenance.

Alignment Requirements (CRITICAL):

All DMA buffers: 32-byte aligned (ARM Cortex-M7 cache line size)
Buffer size: multiple of 32 bytes
Violating alignment corrupts adjacent memory during cache invalidate

Memory Placement Strategies (Best to Worst):

DTCM/SRAM (Non-cacheable, fastest CPU access)
- C++: __attribute__((section(".dtcm.bss"))) __attribute__((aligned(32))) static uint8_t buffer[512];
- Rust: #[link_section = ".dtcm"] #[repr(C, align(32))] static mut BUFFER: [u8; 512] = [0; 512];
MPU-configured Non-cacheable regions - Configure OCRAM/SRAM regions as non-cacheable via MPU
Cache Maintenance (Last resort - slowest)
- Before DMA reads from memory: arm_dcache_flush_delete() or cortex_m::cache::clean_dcache_by_range()
- After DMA writes to memory: arm_dcache_delete() or cortex_m::cache::invalidate_dcache_by_range()

Address Validation Helper (Debug Builds)

Best practice: Validate MMIO addresses in debug builds using is_valid_mmio_address(addr) checking addr is within valid peripheral ranges (e.g., 0x40000000-0x4FFFFFFF for peripherals, 0xE0000000-0xE00FFFFF for ARM Cortex-M system peripherals). Use #ifdef DEBUG guards and halt on invalid addresses.

Write-1-to-Clear (W1C) Register Pattern

Many status registers (especially i.MX RT, STM32) clear by writing 1, not 0:

uint32_t status = mmio_read(&USB1_USBSTS);
mmio_write(&USB1_USBSTS, status);  // Write bits back to clear them

Common W1C: USBSTS, PORTSC, CCM status. Wrong: status &= ~bit does nothing on W1C registers.

Platform Safety & Gotchas

⚠️ Voltage Tolerances:

Most platforms: GPIO max 3.3V (NOT 5V tolerant except STM32 FT pins)
Use level shifters for 5V interfaces
Check datasheet current limits (typically 6-25mA)

Teensy 4.x: FlexSPI dedicated to Flash/PSRAM only • EEPROM emulated (limit writes <10Hz) • LPSPI max 30MHz • Never change CCM clocks while peripherals active

STM32 F7/H7: Clock domain config per peripheral • Fixed DMA stream/channel assignments • GPIO speed affects slew rate/power

nRF52: SAADC needs calibration after power-on • GPIOTE limited (8 channels) • Radio shares priority levels

SAMD: SERCOM needs careful pin muxing • GCLK routing critical • Limited DMA on M0+ variants

Modern Rust: Never Use `static mut`

CORRECT Patterns:

static READY: AtomicBool = AtomicBool::new(false);
static STATE: Mutex<RefCell<Option<T>>> = Mutex::new(RefCell::new(None));
// Access: critical_section::with(|cs| STATE.borrow_ref_mut(cs))

WRONG: static mut is undefined behavior (data races).

Atomic Ordering: Relaxed (CPU-only) • Acquire/Release (shared state) • AcqRel (CAS) • SeqCst (rarely needed)

🎯 Interrupt Priorities & NVIC Configuration

Platform-Specific Priority Levels:

M0/M0+ : 2-4 priority levels (limited)
M3/M4/M7 : 8-256 priority levels (configurable)

Key Principles:

Lower number = higher priority (e.g., priority 0 preempts priority 1)
ISRs at same priority level cannot preempt each other
Priority grouping: preemption priority vs sub-priority (M3/M4/M7)
Reserve highest priorities (0-2) for time-critical operations (DMA, timers)
Use middle priorities (3-7) for normal peripherals (UART, SPI, I2C)
Use lowest priorities (8+) for background tasks

Configuration:

C/C++: NVIC_SetPriority(IRQn, priority) or HAL_NVIC_SetPriority()
Rust: NVIC::set_priority() or use PAC-specific functions

🔒 Critical Sections & Interrupt Masking

Purpose: Protect shared data from concurrent access by ISRs and main code.

C/C++:

__disable_irq(); /* critical section */ __enable_irq();  // Blocks all

// M3/M4/M7: Mask only lower-priority interrupts
uint32_t basepri = __get_BASEPRI();
__set_BASEPRI(priority_threshold << (8 - __NVIC_PRIO_BITS));
/* critical section */
__set_BASEPRI(basepri);

Rust: cortex_m::interrupt::free(|cs| { /* use cs token */ })

Best Practices:

Keep critical sections SHORT (microseconds, not milliseconds)
Prefer BASEPRI over PRIMASK when possible (allows high-priority ISRs to run)
Use atomic operations when feasible instead of disabling interrupts
Document critical section rationale in comments

🐛 Hardfault Debugging Basics

Common Causes:

Unaligned memory access (especially on M0/M0+)
Null pointer dereference
Stack overflow (SP corrupted or overflows into heap/data)
Illegal instruction or executing data as code
Writing to read-only memory or invalid peripheral addresses

Inspection Pattern (M3/M4/M7):

Check HFSR (HardFault Status Register) for fault type
Check CFSR (Configurable Fault Status Register) for detailed cause
Check MMFAR / BFAR for faulting address (if valid)
Inspect stack frame: R0-R3, R12, LR, PC, xPSR

Platform Limitations:

M0/M0+ : Limited fault information (no CFSR, MMFAR, BFAR)
M3/M4/M7 : Full fault registers available

Debug Tip: Use hardfault handler to capture stack frame and print/log registers before reset.

📊 Cortex-M Architecture Differences

Feature	M0/M0+	M3	M4/M4F	M7/M7F
Max Clock	~50 MHz	~100 MHz	~180 MHz	~600 MHz
ISA	Thumb-1 only	Thumb-2	Thumb-2 + DSP	Thumb-2 + DSP
MPU	M0+ optional	Optional	Optional	Optional
FPU	No	No	M4F: single precision	M7F: single + double
Cache	No	No	No	I-cache + D-cache

🧮 FPU Context Saving

Lazy Stacking (Default on M4F/M7F): FPU context (S0-S15, FPSCR) saved only if ISR uses FPU. Reduces latency for non-FPU ISRs but creates variable timing.

Disable for deterministic latency: Configure FPU->FPCCR (clear LSPEN bit) in hard real-time systems or when ISRs always use FPU.

🛡️ Stack Overflow Protection

MPU Guard Pages (Best): Configure no-access MPU region below stack. Triggers MemManage fault on M3/M4/M7. Limited on M0/M0+.

Canary Values (Portable): Magic value (e.g., 0xDEADBEEF) at stack bottom, check periodically.

Watchdog: Indirect detection via timeout, provides recovery. Best: MPU guard pages, else canary + watchdog.

🔄 Workflow

Clarify Requirements → target platform, peripheral type, protocol details (speed, mode, packet size)
Design Driver Skeleton → constants, structs, compile-time config
Implement Core → init(), ISR handlers, buffer logic, user-facing API
Validate → example usage + notes on timing, latency, throughput
Optimize → suggest DMA, interrupt priorities, or RTOS tasks if needed
Iterate → refine with improved versions as hardware interaction feedback is provided

🛠 Example: SPI Driver for External Sensor

Pattern: Create non-blocking SPI drivers with transaction-based read/write:

Configure SPI (clock speed, mode, bit order)
Use CS pin control with proper timing
Abstract register read/write operations
Example: sensorReadRegister(0x0F) for WHO_AM_I
For high throughput (>500 kHz), use DMA transfers

Platform-specific APIs:

Teensy 4.x : SPI.beginTransaction(SPISettings(speed, order, mode)) → SPI.transfer(data) → SPI.endTransaction()
STM32 : HAL_SPI_Transmit() / HAL_SPI_Receive() or LL drivers
nRF52 : nrfx_spi_xfer() or nrf_drv_spi_transfer()
SAMD : Configure SERCOM in SPI master mode with SERCOM_SPI_MODE_MASTER

Weekly Installs

158

Repository

sickn33/antigra…e-skills

GitHub Stars

27.1K

First Seen

Jan 28, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykPass

Installed on

opencode150

gemini-cli141

codex140

github-copilot134

cursor125

claude-code120

React 组合模式指南：Vercel 组件架构最佳实践，提升代码可维护性

113,700 周安装

ARM Cortex-M 嵌入式开发专家：提供完整固件、驱动模块与架构指导

🇨🇳中文介绍

@arm-cortex-expert

使用此技能的时机

不应使用此技能的时机

使用说明

🎯 角色与目标

🧠 知识库

相关 Skills

⚙️ 操作原则

🛡️ ARM Cortex-M7 安全关键模式（Teensy 4.x, STM32 F7/H7）

MMIO 内存屏障（ARM Cortex-M7 弱序内存）

实现模式

DMA 与缓存一致性

地址验证辅助函数（调试版本）

写 1 清除（W1C）寄存器模式

平台安全性与注意事项

现代 Rust：切勿使用 static mut

🎯 中断优先级与 NVIC 配置

🔒 临界区与中断屏蔽

🐛 硬故障调试基础

📊 Cortex-M 架构差异

🧮 FPU 上下文保存

🛡️ 栈溢出保护

🔄 工作流程

🛠 示例：用于外部传感器的 SPI 驱动

🇺🇸English

@arm-cortex-expert

Use this skill when

Do not use this skill when

Instructions

🎯 Role & Objectives

🧠 Knowledge Base

⚙️ Operating Principles

🛡️ Safety-Critical Patterns for ARM Cortex-M7 (Teensy 4.x, STM32 F7/H7)

Memory Barriers for MMIO (ARM Cortex-M7 Weakly-Ordered Memory)

Implementation Pattern

DMA and Cache Coherency

Address Validation Helper (Debug Builds)

Write-1-to-Clear (W1C) Register Pattern

Platform Safety & Gotchas

Modern Rust: Never Use static mut

🎯 Interrupt Priorities & NVIC Configuration

🔒 Critical Sections & Interrupt Masking

🐛 Hardfault Debugging Basics

📊 Cortex-M Architecture Differences

🧮 FPU Context Saving

🛡️ Stack Overflow Protection

🔄 Workflow

🛠 Example: SPI Driver for External Sensor

最新 Skills

现代 Rust：切勿使用 `static mut`

Modern Rust: Never Use `static mut`