Skip to main content
skill CX Codex

freertos-patterns — Claude Code skill: what it does, how to install

freertos-patterns picks the right FreeRTOS pattern for ESP32 tasks or RP2040 dual-core work: queues, mutexes, notifications, stack checks.

MIT 120 installs ★ 33 updated 2026-10-15

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add wedsamuel1230/embedded-engineering-skills --skill freertos-patterns -a claude-code
Open on GitHub

What freertos-patterns does

The skill activates for concurrency problems on ESP32 or core coordination between setup1 and loop1 on RP2040: task priorities, queues, mutexes, semaphores, notifications, watchdogs, event groups, timers. Rather than general advice it loads one of five reference files, matched to task creation, queues, synchronization, memory, or advanced topics, depending on the actual problem.

The rules are specific: a FreeRTOS task should never call delay(), only vTaskDelay() or event-driven blocking; stack headroom gets checked with uxTaskGetStackHighWaterMark() instead of guessed. ESP-IDF and Arduino/RP2040 examples don't carry over between each other — each SDK port has its own stack units, core affinity, and critical-section rules, and the skill flags copying one into another as a mistake.

It steps aside for Arduino UNO and other single-core boards, pointing instead to a plain millis() scheduler. For task ownership and timing budgets in a control system it hands off to realtime-control-design, and for a finished sketch to arduino-code-generator.

What it helps with

  • choose between a queue, a mutex, and a task notification
  • check ESP32 task stack headroom with uxTaskGetStackHighWaterMark
  • split ownership of data between RP2040 cores in setup1 and loop1
  • trace a deadlock caused by inconsistent lock ordering
  • tell a real FreeRTOS task apart from a simple millis() loop on UNO

Example prompts for the agent

  • Design synchronization between two FreeRTOS tasks on ESP32 using a queue
  • Help split work across RP2040 cores in setup1 and loop1 without data races
  • Check whether this FreeRTOS task's stack is sized correctly

How to install freertos-patterns

1Skills CLI (Vercel)

npx skills add wedsamuel1230/embedded-engineering-skills --skill freertos-patterns -a claude-code

2Manually: put the files in place

~/.claude/skills/freertos-patterns/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/freertos-patterns/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about freertos-patterns

How to install freertos-patterns in Claude Code?

Run npx skills add wedsamuel1230/embedded-engineering-skills --skill freertos-patterns -a claude-code; the skill lands at ~/.claude/skills/freertos-patterns/SKILL.md.

What does the freertos-patterns skill do?

It matches FreeRTOS concurrency problems on ESP32 and dual-core coordination on RP2040 to the right pattern — task creation, queues, mutexes, notifications, watchdogs — and opens the matching reference file.

Which boards does freertos-patterns skip?

It steps aside for Arduino UNO and other single-core boards, and for any case a plain millis() scheduler already covers without real concurrency.

Source text

SKILL.md · MIT
---
name: freertos-patterns
description: Use when users need ESP32 FreeRTOS or RP2040 multicore patterns for task creation, queues, synchronization, memory checks, task notifications, or cross-core coordination.
metadata: {triggers: "FreeRTOS, multicore, task, queue, mutex, cross-core"}
---

# FreeRTOS Patterns for ESP32 and RP2040

Use this skill for real concurrency problems on ESP32 or RP2040. Keep the main
flow focused and load the detailed reference that matches the user's exact
problem.

## Resources

- `references/patterns-task-creation.md` - task lifecycle, priorities, stack
  sizing, and task startup
- `references/patterns-queues.md` - inter-task communication with queues
- `references/patterns-synchronization.md` - mutexes, semaphores, critical
  sections, and ISR coordination
- `references/patterns-memory.md` - stack sizing, heap checks, and monitoring
- `references/patterns-advanced.md` - watchdogs, notifications, event groups,
  timers, and affinity
- `assets/workflow.mmd` - architecture overview

## When to Use

Use this skill when the request includes:

- multiple concurrent jobs on ESP32
- task priorities or preemption
- queue, semaphore, mutex, or notification design
- RP2040 `setup1` and `loop1` multicore coordination
- watchdog-safe long-running behavior
- debugging race conditions, stack overflows, or deadlocks

Do not use this skill when:

- the target is UNO or another single-core board
- a simple `millis()` scheduler solves the problem
- the request is only about one blocking loop with no concurrency requirement

## Workflow

For a control system's task/resource ownership, action timing or deadline
budget, start with `realtime-control-design`. Return here for the actual RTOS
primitive. Native ESP-IDF uses its own port's stack units, affinity and critical
section rules; do not copy an Arduino/RP2040 example into another framework
without checking the selected SDK.

1. Confirm the target platform first:
   - ESP32 -> FreeRTOS task model
   - RP2040 -> dual-core coordination model
2. Identify the dominant problem:
   - task startup -> open `patterns-task-creation.md`
   - communication -> open `patterns-queues.md`
   - shared data or ISR signaling -> open `patterns-synchronization.md`
   - stack or heap risk -> open `patterns-memory.md`
   - watchdogs, notifications, timers, or affinity -> open
     `patterns-advanced.md`
3. Solve one synchronization boundary at a time. Avoid mixing queue, mutex, and
   notification advice unless the design truly needs all of them.
4. Keep board-specific details explicit. ESP32 FreeRTOS guidance and RP2040
   multicore guidance are not interchangeable.

## Core Rules

- Prefer the smallest concurrency primitive that solves the problem.
- Protect shared state explicitly. "Probably safe" is not safe.
- Use `vTaskDelay()` or event-driven blocking on ESP32, never `delay()` inside
  a task.
- Budget stack size deliberately and verify it with runtime evidence.
- For RP2040, define core ownership clearly before sharing data.

## Verification

- Confirm each task or core has a single clear responsibility.
- Check queue depth, notification flow, or mutex coverage against the concrete
  data path.
- For ESP32, inspect stack headroom with
  `uxTaskGetStackHighWaterMark()` where the task size is uncertain.
- Verify the sketch can keep making progress without deadlock or busy waiting.
- If an ISR is involved, verify the synchronization primitive is ISR-safe for
  that platform.

## Common Failure Modes

- undersized task stack
- `delay()` used inside a FreeRTOS task
- unprotected shared data
- deadlock from inconsistent lock order
- RP2040 core startup assumptions without mutex or ownership discipline

## Integration

- Combine with `arduino-code-generator` when the user needs a full sketch rather
  than design guidance.
- Combine with `circuit-debugger` only after the concurrency design looks sound
  and a hardware timing issue still remains.
- Combine with `mermaid-diagram-generator` when the concurrency design needs a
  task, queue, or event-flow diagram.

## Shared Output Contract

Use [the shared Arduino skill contract](../../docs/arduino-skill-contract.md):
state assumptions, required tools and versions, implementation steps,
tests/evidence by proof stage, known limitations, and recovery/security notes.

© wedsamuel1230 · MIT · wedsamuel1230/embedded-engineering-skills

Similar skills

All skills for Programming languages →

From the same set19

The whole set →
code-review-facilitator The code-review-facilitator skill reviews Arduino, ESP32, and RP2040 projects for memory risks, structural issues, and common mistakes. Use it before publishing code or after finishing a feature. CX Codex +1 154installs readme-generator readme-generator generates README.md files for Arduino, ESP32, and RP2040 projects. Use it when a working project needs clear GitHub documentation. CX Codex +1 147installs sensor-calibration-workbench The sensor-calibration-workbench skill guides sensor calibration from warm-up and reference readings to coefficient storage and drift checks for CO2, load-cell, magnetic, color, and analog sensors. CX Codex +1 137installs i2c-bringup-diagnostician i2c-bringup-diagnostician diagnoses I2C bring-up failures on Arduino and ESP32 boards, covering wiring, scanner mismatches, and driver bugs. CX Codex +1 134installs ota-deployment-guardian ota-deployment-guardian prevents remote bricking on ESP32 boards and Arduino Uno R4 WiFi during OTA updates. Troubleshoots disappearing network ports and sets up rollback workflows. CX Codex +1 115installs mermaid-diagram-generator mermaid-diagram-generator is a Claude Code skill that turns Arduino code and embedded-system behavior into Mermaid diagrams for mapping states, signal sequences, and FreeRTOS task architecture. CX Codex +1 113installs field-power-and-connectivity-triager field-power-and-connectivity-triager is a Claude Code skill that investigates power and connectivity faults when a board works over USB but fails on its intended supply. It checks voltage drops, current peaks, regulators, and wiring. CX Codex +1 113installs arduino-serial-monitor arduino-serial-monitor is a Claude Code skill that reads and analyzes Arduino serial output, including boot logs, sensor data, and communication failures. CX Codex +1 1installs

Project sponsors

Companies that keep this analytics open