embedded-firmware-dev

Embedded Firmware Development

FreeRTOS

• Give each task a clear ownership boundary. Shared resources need a deliberate synchronization strategy.
• Prefer task notifications for one-to-one wakeups, queues for data transfer, event groups for combined state, mutexes for mutual exclusion, semaphores for one-way signaling.
• Use a mutex (not binary semaphore) when mutual exclusion matters and priority inheritance is needed.
• Make every blocking wait explicit: use a timeout unless an infinite wait is deliberate.
• Keep timer callbacks short and non-blocking — use them to schedule work, not do it.
• Avoid holding locks across flash, storage, or long operations.
• Size task stacks from worst-case call chains. Recheck high-water marks after adding buffers or deeper call trees.
• Use ISR-safe APIs for interrupt-to-task handoff. Keep ISR state capture minimal.
• Avoid priority inversion: don't hold shared locks across blocking I/O or long processing.
• If a task can be paused/restarted/signaled from multiple places, define resume, timeout, and recovery paths explicitly.
• For cross-task pointer ownership: make lifetime and invalidation rules obvious.
• Prefer the smallest critical section that protects the state transition. Don't wrap whole operations in locks when narrower ordering suffices.
• For objects handed between threads: define whether the receiver owns, borrows, or copies before crossing the boundary.

Interrupts / ISR

• Keep the interrupt path short, deterministic, and bounded. Capture minimum state, clear the source, defer expensive work.
• Do not block, sleep, allocate heap, or call non-ISR-safe APIs from an ISR.
• Prefer top-half/bottom-half split when the handler needs more than quick state capture and wakeup.
• Make shared-state ownership explicit. Use minimum synchronization for the data being shared.
• If an ISR wakes a task, use the ISR-safe RTOS primitive and preserve yield-from-ISR behavior.
• Define clear read/clear/re-enable ordering to avoid losing edges or creating re-trigger loops.
• Avoid logging and complex branching in the hot interrupt path.
• If code runs from both task and ISR context, separate wrappers so the ISR-safe path stays obvious.