embedded-systems

Guide resource-constrained embedded development with static allocation and ISR constraints.

150|48|Updated Jan 24, 2026
One-click install
npx skills add https://github.com/irahardianto/awesome-agv --skill embedded-systems-irahardianto
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: embedded-systems
Source: https://github.com/irahardianto/awesome-agv/tree/main/.agents/skills/embedded-systems
Command: npx skills add https://github.com/irahardianto/awesome-agv --skill embedded-systems-irahardianto

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you produce reliable embedded software by guiding resource-constrained and real-time design decisions that prevent latency spikes, memory hazards, and unsafe concurrency.

Core Features & Use Cases

  • Real-time execution guidance: priority scheduling, interrupt-handling rules (short ISRs, deferred work), and priority inversion mitigation.
  • Embedded resource discipline: static allocation preferences, memory budgeting, fixed-size pools to avoid fragmentation, and power-aware operation.
  • HAL and RTOS structure patterns: clean HAL/BSP layering, task/queue/semaphore/mutex usage with timeout safety, plus host testing and HIL strategy.
  • Use Case: Porting firmware from one microcontroller to another while maintaining deterministic timing, testability via mocked HAL, and safety-critical constraints (e.g., watchdogs and MISRA-like compliance).

Quick Start

Apply the embedded-systems Skill when you are writing or reviewing firmware architecture for a microcontroller with real-time constraints and limited memory.

Frequently Asked Questions about embedded-systems

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I prevent memory fragmentation in embedded systems with limited RAM?

To prevent memory fragmentation in embedded systems, use static memory allocation and fixed-size memory pools. This approach ensures deterministic behavior by avoiding dynamic allocation overhead and heap fragmentation during real-time execution.

What is the best way to handle interrupts in an RTOS without causing latency spikes?

The best way to handle interrupts in an RTOS is to keep Interrupt Service Routines (ISRs) extremely short and defer heavy processing to tasks. Use queues or semaphores to pass data from ISRs to tasks, preventing priority inversion and latency spikes.

How do I design a hardware abstraction layer for microcontroller portability?

Design a hardware abstraction layer (HAL) by cleanly separating microcontroller-specific code from application logic. This structured BSP layering allows you to port firmware across microcontrollers while maintaining testability through mocked HAL interfaces.

How does real-time scheduling manage task synchronization in safety-critical systems?

Real-time scheduling manages task synchronization in safety-critical systems by using structured patterns with mutexes, semaphores, and queues. It enforces timeout safety and priority inversion mitigation to ensure deterministic execution and prevent deadlocks.

Can I use host testing for microcontroller firmware without physical hardware?

Yes, you can use host testing for microcontroller firmware by mocking the hardware abstraction layer. This allows you to execute and verify application logic and RTOS task behavior on a development machine before deploying to physical hardware.