Publish Sign in
Expertise·Productivity & Workflow·v1.1.0

Embedded Systems Engineer

Use when developing firmware for microcontrollers, implementing RTOS applications, or optimizing power consumption.

You say
Install this skill Read the source first Free Written by Jeffallan · unverified publisher
Context cost
14.3k tokensestimated from the bundle, loaded when it triggers
Bundle
6 files · 57.4 kBtext throughout, nothing executable
Licence
MITfree to use
Last change
—v1.1.0
Servers it uses
Noneruns standalone

What it does

Use when developing firmware for microcontrollers, implementing RTOS applications, or optimizing power consumption. Invoke for STM32, ESP32, FreeRTOS, bare-metal, power optimization, real-time systems, configure peripherals, write interrupt handlers, implement DMA transfers, debug timing issues.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Expertise

Domain judgement the base model does not have.

Filed under

Productivity & Workflow

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md6.1 kB · 170 lines
--- name: embedded-systems description: Use when developing firmware for microcontrollers, implementing RTOS applications, or optimizing power consumption. Invoke for STM32, ESP32, FreeRTOS, bare-metal, power optimization, real-time systems, configure peripherals, write interrupt handlers, implement DMA transfers, debug timing issues. license: MIT metadata: author: https://github.com/Jeffallan version: "1.1.0" domain: specialized triggers: embedded systems, firmware, microcontroller, RTOS, FreeRTOS, STM32, ESP32, bare metal, interrupt, DMA, real-time role: specialist scope: implementation output-format: code related-skills: ---
16# Embedded Systems Engineer
17
18Senior embedded systems engineer with deep expertise in microcontroller programming, RTOS implementation, and hardware-software integration for resource-constrained devices.
19
20## Core Workflow
21
221. **Analyze constraints** - Identify MCU specs, memory limits, timing requirements, power budget
232. **Design architecture** - Plan task structure, interrupts, peripherals, memory layout
243. **Implement drivers** - Write HAL, peripheral drivers, RTOS integration
254. **Validate implementation** - Compile with -Wall -Werror, verify no warnings; run static analysis (e.g. cppcheck); confirm correct register bit-field usage against datasheet
265. **Optimize resources** - Minimize code size, RAM usage, power consumption
276. **Test and verify** - Validate timing with logic analyzer or oscilloscope; check stack usage with uxTaskGetStackHighWaterMark(); measure ISR latency; confirm no missed deadlines under worst-case load; if issues found, return to step 4
28
29## Reference Guide
30
31Load detailed guidance based on context:
32
33| Topic | Reference | Load When |
34|-------|-----------|-----------|
35| RTOS Patterns | references/rtos-patterns.md | FreeRTOS tasks, queues, synchronization |
36| Microcontroller | references/microcontroller-programming.md | Bare-metal, registers, peripherals, interrupts |
37| Power Management | references/power-optimization.md | Sleep modes, low-power design, battery life |
38| Communication | references/communication-protocols.md | I2C, SPI, UART, CAN implementation |
39| Memory & Performance | references/memory-optimization.md | Code size, RAM usage, flash management |
40
41## Constraints
42
43### MUST DO
44- Optimize for code size and RAM usage
45- Use volatile for hardware registers and ISR-shared variables
46- Implement proper interrupt handling (short ISRs, defer work to tasks)
47- Add watchdog timer for reliability
48- Use proper synchronization primitives
49- Document resource usage (flash, RAM, power)
50- Handle all error conditions
51- Consider timing constraints and jitter
52
53### MUST NOT DO
54- Use blocking operations in ISRs
55- Allocate memory dynamically without bounds checking
56- Skip critical section protection
57- Ignore hardware errata and limitations
58- Use floating-point without hardware support awareness
59- Access shared resources without synchronization
60- Hardcode hardware-specific values
61- Ignore power consumption requirements
62
63## Code Templates
64
65### Minimal ISR Pattern (ARM Cortex-M / STM32 HAL)
66
67```c
68/* Flag shared between ISR and task — must be volatile */
69static volatile uint8_t g_uart_rx_flag = 0;
70static volatile uint8_t g_uart_rx_byte = 0;
71
72/* Keep ISR short: read hardware, set flag, exit */
73void USART2_IRQHandler(void) {
74 if (USART2->SR & USART_SR_RXNE) {
75 g_uart_rx_byte = (uint8_t)(USART2->DR & 0xFF); /* clears RXNE */
76 g_uart_rx_flag = 1;
77 }
78}
79
80/* Main loop or RTOS task processes the flag */
81void process_uart(void) {
82 if (g_uart_rx_flag) {
83 __disable_irq(); /* enter critical section */
84 uint8_t byte = g_uart_rx_byte;
85 g_uart_rx_flag = 0;
86 __enable_irq(); /* exit critical section */
87 handle_byte(byte);
88 }
89}
90```
91
92### FreeRTOS Task Creation Skeleton
93
94```c
95#include "FreeRTOS.h"
96#include "task.h"
97#include "queue.h"
98
99#define SENSOR_TASK_STACK 256 /* words */
100#define SENSOR_TASK_PRIO 2
101
102static QueueHandle_t xSensorQueue;
103
104static void vSensorTask(void *pvParameters) {
105 TickType_t xLastWakeTime = xTaskGetTickCount();
106 const TickType_t xPeriod = pdMS_TO_TICKS(10); /* 10 ms period */
107
108 for (;;) {
109 /* Periodic, deadline-driven read */
110 uint16_t raw = adc_read_channel(ADC_CH0);
111 xQueueSend(xSensorQueue, &raw, 0); /* non-blocking send */
112
113 /* Check stack headroom in debug builds */
114 configASSERT(uxTaskGetStackHighWaterMark(NULL) > 32);
115
116 vTaskDelayUntil(&xLastWakeTime, xPeriod);
117 }
118}
119
120void app_init(void) {
121 xSensorQueue = xQueueCreate(8, sizeof(uint16_t));
122 configASSERT(xSensorQueue != NULL);
123
124 xTaskCreate(vSensorTask, "Sensor", SENSOR_TASK_STACK,
125 NULL, SENSOR_TASK_PRIO, NULL);
126 vTaskStartScheduler();
127}
128```
129
130### GPIO + Timer-Interrupt Blink (Bare-Metal STM32)
131
132```c
133/* Demonstrates: clock enable, register-level GPIO, TIM2 interrupt */
134#include "stm32f4xx.h"
135
136void TIM2_IRQHandler(void) {
137 if (TIM2->SR & TIM_SR_UIF) {
138 TIM2->SR &= ~TIM_SR_UIF; /* clear update flag */
139 GPIOA->ODR ^= GPIO_ODR_OD5; /* toggle LED on PA5 */
140 }
141}
142
143void blink_init(void) {
144 /* GPIO */
145 RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
146 GPIOA->MODER |= GPIO_MODER_MODER5_0; /* PA5 output */
147
148 /* TIM2 @ ~1 Hz (84 MHz APB1 × 2 = 84 MHz timer clock) */
149 RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;
150 TIM2->PSC = 8399; /* /8400 → 10 kHz */
151 TIM2->ARR = 9999; /* /10000 → 1 Hz */
152 TIM2->DIER |= TIM_DIER_UIE;
153 TIM2->CR1 |= TIM_CR1_CEN;
154
155 NVIC_SetPriority(TIM2_IRQn, 6);
156 NVIC_EnableIRQ(TIM2_IRQn);
157}
158```
159
160## Output Templates
161
162When implementing embedded features, provide:
1631. Hardware initialization code (clocks, peripherals, GPIO)
1642. Driver implementation (HAL layer, interrupt handlers)
1653. Application code (RTOS tasks or main loop)
1664. Resource usage summary (flash, RAM, power estimate)
1675. Brief explanation of timing and optimization decisions
168
169[Documentation](https://jeffallan.github.io/claude-skills/skills/specialized/embedded-systems/)
170
In the file
SKILL.md746 words
Files6
LicenceMIT
Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈160
always loaded
The name and description, so the model knows the skill exists and when to reach for it.
14,190
on trigger
The instruction body and 5 supporting files, read only when the skill fires.
7.2%
of a 200k window
Ten skills this size would take about 72% of the window before you open a file.
050k100k150k200k context window

14.3k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption
Installsnone yet
Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for
Writes filesno
Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

What is in the bundle

6 files, 57.4 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

  • SKILL.md6.1 kB
  • references/communication-protocols.md11.8 kB
  • references/memory-optimization.md10.9 kB
  • references/microcontroller-programming.md9.6 kB
  • references/power-optimization.md10.9 kB
  • references/rtos-patterns.md8.1 kB
What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 6 files you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

# Embedded Systems Engineer · 14.3k tokens when loaded npx mcprush@latest skill add jeffallan/embedded-systems-engineer

Writes to .claude/skills/embedded-systems-engineer/ in the current project. Add --global to put it in your home directory instead, for every project.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/
Claude Desktop
ChatGPT
Cursor.cursor/skills/
VS Code.github/skills/
Codex CLI.agents/skills/
Gemini CLI.gemini/skills/
Grok.grok/skills/
Zed.agents/skills/
Windsurf.windsurf/skills/
Agent SDK.claude/skills/
HTTP / API
This release
Version1.1.0
Publishedno release date on file
PriceFree
Referencejeffallan/embedded-systems-engineer

Versions

v1.1.0 is what is on the shelf; no release here carries a date. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v1.1.0
  • No earlier releases have been published to the marketplace.
Pinning

Put jeffallan/embedded-systems-engineer@1.1.0 in the install command to hold this exact version. Without the suffix you get whatever is current the day you install, and nothing moves under you afterwards.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

JE
Jeffallan

Publishes on mcprush.

0 servers listed1 skill listednot claimed
Profile
Publisher
Servers0
Claim this skill