embedded-systems

Develop embedded firmware for STM32 and ESP32 microcontrollers with RTOS and bare-metal drivers.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/kamelmh/opencode-config --skill embedded-systems-kamelmh
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: embedded-systems
Source: https://github.com/kamelmh/opencode-config/tree/main/skills/embedded-systems
Command: npx skills add https://github.com/kamelmh/opencode-config --skill embedded-systems-kamelmh

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you design, implement, and optimize firmware for microcontrollers and RTOS-based systems when you need reliable timing, efficient memory use, and careful power management.

Core Features & Use Cases

  • Firmware Implementation: Build bare-metal and RTOS applications for platforms such as STM32 and ESP32.
  • Peripheral and Driver Work: Configure GPIO, timers, ADC, UART, SPI, I2C, CAN, DMA, and interrupts with robust error handling.
  • Optimization and Debugging: Improve flash, RAM, latency, jitter, and battery life while validating behavior with stack checks, watchdogs, and timing analysis.
  • Use Case: Create a low-power sensor controller that reads data on schedule, communicates over UART or I2C, and survives noisy real-time conditions without missed deadlines.

Quick Start

Use the embedded-systems skill to design and implement a low-power microcontroller firmware solution with interrupt-driven peripherals, RTOS tasks, and a concise resource usage summary.

Frequently Asked Questions about embedded-systems

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

FAQPage Schema
How do I write safe and short interrupt service routines for STM32 or ESP32 firmware?

Safe interrupt service routines require minimal logic, deferred processing, and synchronization. This Skill helps design short ISRs, configure DMA transfers, and apply timeout-based error handling to maintain reliable timing on STM32 and ESP32 microcontrollers.

What is the best way to implement low-power microcontroller firmware with an RTOS?

Low-power microcontroller firmware requires careful power optimization, scheduled sensor reads, and efficient resource usage. This Skill implements low-power design strategies for RTOS-based devices, ensuring battery life is maximized without missing real-time deadlines.

How do I configure bare-metal drivers for communication buses like SPI, I2C, and CAN?

Configuring bare-metal communication buses involves hardware initialization, peripheral setup, and robust error handling. This Skill develops reliable drivers for SPI, I2C, CAN, and UART, applying timeout-based error handling and synchronization for noisy real-time conditions.

How do I debug timing jitter and optimize RAM usage in FreeRTOS applications?

Debugging timing jitter and optimizing RAM requires stack checks, watchdogs, and timing analysis. This Skill optimizes flash, RAM, latency, and jitter in FreeRTOS applications while validating behavior through resource usage accounting and timing analysis.

Does this approach support DMA transfers and bare-metal drivers without an RTOS?

Yes, this approach supports DMA transfers and bare-metal drivers without an RTOS. It applies to STM32 and ESP32 platforms, handling hardware initialization and peripheral configuration for GPIO, timers, and ADC with robust error handling even in bare-metal environments.