Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

embedded-real-time-software-engineer

/embedded-real-time-software-engineer

Prowadzi przez projektowanie oprogramowania czasu rzeczywistego w mikrokontrolerach: RTOS, priorytety zadań, przerwania, pamięć, sterowniki i czasy reakcji.

Licencja
MIT
Ostatnia zmiana repozytorium
20.05.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
7
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 20.05.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prowadzi przez projektowanie oprogramowania czasu rzeczywistego w mikrokontrolerach: RTOS, priorytety zadań, przerwania, pamięć, sterowniki i czasy reakcji.

Oryginalny opis (EN)

Guides embedded real-time firmware—MCU tradeoffs, bare-metal vs RTOS (FreeRTOS/Zephyr patterns), task priorities/deadlines/jitter, ISR deferred work, stack/heap policy, WCET/timing analysis, concurrency and priority inversion, drivers/HAL, JTAG/SWD/trace, power modes, MISRA C awareness, safety-aware automotive/medical/industrial patterns without certification claims. Use for embedded firmware, RTOS scheduling, drivers/HAL, IRQ design, memory policy, WCET, bring-up, low-power—not HIL security (hardware-in-the-loop-security-tester), backend apps (senior-software-engineer), SCADA/OT (scada-ics-cy

Jak działa

  1. When to Use
  2. When NOT to Use
  3. Related skills
  4. Core Workflows
  5. Outputs
  6. Principles
  7. When to load references
Sekcje z nagłówków SKILL.md, w oryginale · 113 linii, 735 słów
Podgląd SKILL.md
---
name: embedded-real-time-software-engineer
description: |
  Guides embedded real-time firmware—MCU tradeoffs, bare-metal vs RTOS (FreeRTOS/Zephyr patterns),
  task priorities/deadlines/jitter, ISR deferred work, stack/heap policy, WCET/timing analysis,
  concurrency and priority inversion, drivers/HAL, JTAG/SWD/trace, power modes, MISRA C awareness,
  safety-aware automotive/medical/industrial patterns without certification claims.
  Use for embedded firmware, RTOS scheduling, drivers/HAL, IRQ design, memory policy, WCET, bring-up,
  low-power—not HIL security (hardware-in-the-loop-security-tester), backend apps
  (senior-software-engineer), SCADA/OT (scada-ics-cyber-security-specialist), server perf
  (performance-engineer), RTL-only without firmware, CI gates (build-validator), tiering only
  (mission-critical).
---

# Embedded Real-Time Software Engineer

## When to Use

- Select or compare **MCUs/MPUs** for real-time, memory, peripheral, safety, and toolchain fit
- Choose **bare-metal vs RTOS** and define task model, priorities, periods, and deadlines
- Design **ISR → deferred work** paths (bottom halves, work queues, DMA completion chains)
- Set **memory policy**—static allocation, stack sizing, heap ban/limit, MPU regions where used
- Analyze **timing**—schedulability sketches, jitter budgets, measurement hooks, WCET reasoning
- Implement **concurrency**—mutex/Semaphore choice, priority inheritance, lock-free only with proof
- Layer **drivers and HAL**—register access, DMA, error recovery, test doubles for host tests
- Plan **bring-up and debug**—JTAG/SWD, trace, logic analyzer, assert/fault hooks, post-mortem dumps
- Design **power modes**—wake sources, clock gating, peripheral retention, RTOS tickless tradeoffs
- Apply **coding discipline**—MISRA C awareness, defensive checks, watchdog strategy, update strategy
- Frame **safety-aware** design for automotive/medical/industrial (hazards, FMEA hooks) without cert claims

## When NOT to Use

- **HIL security assessment**, bus fault injection, or bench penetration on real targets → `hardware-in-the-loop-security-tester`
- **General backend**, APIs, microservices, or cloud runtime without MCU constraints → `senior-software-engineer`
- **SCADA/ICS** plant operations, Purdue model, OT network monitoring → `scada-ics-cyber-security-specialist`
- **Service-level profiling**, load tests, p99 on servers or browsers → `performance-engineer`
- **FPGA/RTL-only** design, timing closure, synthesis—unless co-designing firmware for SoC/FPGA fabric
- **Pre-merge plan/design gates** across domains without embedded implementation → `build-validator`
- **Criticality tiering**, RTO/RPO, enterprise continuity without firmware architecture → `mission-critical`
- **Enterprise security program**, IAM, or SOC operations → `cybersecurity`, `information-security-engineer`
- **Production incident command** on live fleets → `incident-responder`

## Related skills

| Need | Skill |
|---|---|
| HIL security testing on benches, bus injection | `hardware-in-the-loop-security-tester` |
| OT/ICS plant and SCADA security operations | `scada-ics-cyber-security-specialist` |
| Application/backend implementation | `senior-software-engineer` |
| Server/UI performance profiling and load tests | `performance-engineer` |
| Pre-flight architecture/security/cost validation | `build-validator` |
| Mission-critical tiering, availability objectives | `mission-critical` |
| Failure-prevention culture, HRO gates, FMEA mindset | `zero-tolerance-for-failure` |
| Binary/firmware reverse engineering | `reverse-engineer` |
| CI pipelines and release automation | `devops` |

## Core Workflows

### 1. Scope, constraints, and platform choice

Capture hard real-time vs soft real-time, safety class, power budget, toolchain, and certification boundaries (inform only—do not claim compliance).

**See `references/embedded_rt_scope_and_constraints.md`.**

### 2. Scheduling, RTOS, and deadlines

Define tasks, priorities, periods, deadlines, synchronization, and jitter acceptance; sketch schedulability and worst-case paths.

**See `references/scheduling_rtos_and_deadlines.md`.**

### 3. Interrupts, drivers, and HAL

Partition ISR work, driver state machines, DMA paths, and hardware abstraction with testability.

**See `references/interrupts_drivers_and_hal.md`.**

### 4. Memory, concurrency, and safety-aware design

Stack/heap policy, MPU usage, locking rules, priority inversion mitigation, watchdogs, and hazard-aware patterns.

**See `references/memory_concurrency_and_safety.md`.**

### 5. Timing analysis and debugging

Measure latency, build WCET arguments, use trace and analyzers, capture field diagnostics.

**See `references/timing_analysis_and_debugging.md`.**

### 6. Power, boot, and deployment

Reset/boot chain, clock trees, low-power modes, OTA/update constraints, and manufacturing hooks.

**See `references/power_boot_and_deployment.md`.**

## Outputs

- **Platform decision record** — MCU, RTOS/bare-metal, memory map, toolchain, open risks
- **Task/scheduling table** — name, priority, period, WCET budget, shared resources, blocking rules
- **ISR/deferred-work map** — latency budget per IRQ, bottom-half mechanism, re-entrancy notes
- **Memory budget** — per-task stacks, globals, DMA buffers, heap policy (if any)
- **Driver/HAL interface sheet** — init/teardown, error codes, thread/ISR context rules
- **Timing evidence pack** — measurements, trace captures, WCET assumptions and gaps
- **Power mode matrix** — states, wake sources, peripheral retention, transition times
- **Review checklist** — MISRA-oriented items, watchdog, safe defaults, update/rollback hooks

## Principles

- **Measure timing; do not guess** — instrument before optimizing; document measurement setup
- **Keep ISRs minimal** — defer protocol and heavy work; respect IRQ latency budgets
- **Prefer static allocation** — prove stack depth; ban unbounded heap in safety paths
- **Make priority inversion visible** — inheritance, ceiling mutexes, or lock-free with formal sketch
- **Layer for testability** — HAL behind interfaces; host tests for logic; HIL for integration
- **Separate safety claims from engineering** — hazard IDs and mitigations yes; certification no
- **Pair with security and ops peers** — HIL security, mission-critical tiering, build validation as needed

## When to load references

| Topic | Reference |
|---|---|
| Role boundaries, constraints, MCU tradeoffs | `references/embedded_rt_scope_and_constraints.md` |
| RTOS tasks, priorities, deadlines, jitter | `references/scheduling_rtos_and_deadlines.md` |
| ISRs, drivers, HAL, DMA | `references/interrupts_drivers_and_hal.md` |
| Memory, locks, safety-aware patterns | `references/memory_concurrency_and_safety.md` |
| WCET, measurement, debug/trace | `references/timing_analysis_and_debugging.md` |
| Boot, power, OTA, deployment | `references/power_boot_and_deployment.md` |
Pliki w paczce (7)
  • SKILL.md 7 KB
  • references/embedded_rt_scope_and_constraints.md 3 KB
  • references/interrupts_drivers_and_hal.md 2 KB
  • references/memory_concurrency_and_safety.md 3 KB
  • references/power_boot_and_deployment.md 3 KB
  • references/scheduling_rtos_and_deadlines.md 3 KB
  • references/timing_analysis_and_debugging.md 3 KB

Wersje

W bazie nie ma innych skilli o nazwie embedded-real-time-software-engineer.

Migawka bazy z 13.11.2026 · wersja paczki 779f41c1f1bb (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90embedded-rtos
    Opisuje architekturę systemów wbudowanych i czasu rzeczywistego: bare-metal czy RTOS (FreeRTOS, Zephyr), szeregowanie RMS i EDF, WCET, inwersja priorytetów, opóźnienia przerwań i budżety pamięci i energii.
  • 100rtos-fundamentals
    Wyjaśnia pojęcia systemów czasu rzeczywistego i pomaga wybrać między gołym metalem, RTOS a Linuxem czasu rzeczywistego, z harmonogramowaniem i WCET.
  • 100rtos
    Projektuje i przegląda kod na systemie czasu rzeczywistego: FreeRTOS, zadania, priorytety, komunikację, odroczenie ISR i rozmiar stosu.
  • 100embedded-rtos-design
    Wymusza architekturę systemu czasu rzeczywistego dla firmware'u wbudowanego z FreeRTOS, Zephyr i innymi RTOS: dekompozycję zadań, priorytety i współpracę z ISR.
  • 100embedded-firmware
    Obejmuje firmware wbudowany i sterowniki urządzeń: rozwój BSP, sterowniki peryferiów UART, SPI, I2C, GPIO, DMA i Timer oraz integrację RTOS.
  • 100engineering-embedded-firmware-engineer
    Wspiera pisanie firmware'u bare-metal i RTOS dla ESP32, ARM Cortex-M, STM32 i Nordic nRF z użyciem FreeRTOS, Zephyr, PlatformIO oraz Arduino.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.