Product and Technology culture at Hoomanely

Firmware

Queue vs. Direct Task Notify Performance Trade-offs in FreeRTOS ITC

Modern embedded systems demand efficient inter-task communication (ITC) mechanisms that balance performance with reliability. When building high-performance sensor systems, every microsecond counts—especially in real-time applications where hardware interrupts must trigger rapid processing pipelines. This exploration examines two fundamental FreeRTOS ITC approaches: traditional queues versus direct task notifications, revealing critical

Hardware

Designing Multi-Rail Systems That Don’t Brownout Each Other

Most modern boards are not powered by a single supply. They are ecosystems of rails: high-current domains for motors or radios, quiet domains for sensors, always-on islands for state retention, and transient-heavy rails that only exist during specific modes. On paper, these rails look independent. In reality, they are tightly

Firmware

Ghost in the Shell: Validating Firmware Logic with Mock Sensor Pipelines

Introduction: The Paradox of Hardware-Dependent Firmware In the intricate world of embedded systems development, engineers face a persistent and often debilitating paradox: firmware is explicitly designed to control and react to physical hardware, yet the dependency on that very hardware often becomes the primary bottleneck in software velocity. This creates

Sliding Window vs Event Triggering: What Reduced Our False Alerts

The Problem We Kept Chasing When we first rolled out alerts in production, the system technically worked - models were firing, dashboards were lighting up, notifications were flowing. And yet, something felt off. We were seeing too many alerts. Not because the world suddenly became chaotic, but because our inference

Hardware

Building a Board That Can Boot With Missing Sensors

Most boards are designed under a quiet assumption: everything that should be present will be present. All sensors are populated. All cables are connected. All rails come up cleanly. Firmware discovers what it expects, and the system progresses forward. That assumption holds in the lab. It collapses the moment a

Firmware

I2C Bus Recovery: Implementing Robust "Bus Clear" Sequences

Introduction In the world of smart device ecosystems, where continuous sensor monitoring is paramount, communication reliability becomes the cornerstone of system integrity. When developing multi-sensor platforms that demand 24/7 operation, engineers frequently encounter a subtle yet critical challenge: I2C bus lockups caused by peripherals holding the SDA (Serial Data)

DMA-First Pipelines: Let Models Wait, Not Sensors

Introduction Most edge AI pipelines are accidentally model-first. We optimize inference time, shave milliseconds off convolution layers, and debate INT8 versus INT4—while silently dropping sensor frames upstream. By the time the model runs, the data it sees is already compromised. On constrained hardware like STM32-class processors, this mistake is

Software

Stable BLE Sensor Streams: MTU, Connection Interval, and End-to-End Buffer Control

Stable BLE streaming can feel like magic when it works: sensors stay responsive, data arrives smoothly, and the app feels “live” without burning the battery or stuttering the UI. The good news is that this isn’t luck—it’s engineering. When you treat BLE as an end-to-end streaming pipeline

From Noisy Clips to Trustworthy Labels: How We Fixed Audio Classification at the Source

Most public audio datasets look clean on paper. Five seconds. Ten seconds. One label per clip. That assumption is exactly where our problems started. The Hidden Problem With Scraped Audio Datasets We started with the usual approach: scrape audio clips from public sources, bucket them by class (bark, howl, cough,

Firmware

Designing a Reliable Stop-and-Wait Transport Protocol on CAN FD for Deterministic Embedded Systems

In high-performance embedded systems, data integrity and deterministic timing are paramount. Controller Area Network (CAN) has long been the standard for reliable automotive and industrial communication. With the transition to CAN FD (Flexible Data-rate), we gained higher bandwidth and larger payloads. However, standard CAN FD, while robust for short control

Queue vs. Direct Task Notify Performance Trade-offs in FreeRTOS ITC

Designing Multi-Rail Systems That Don’t Brownout Each Other

Ghost in the Shell: Validating Firmware Logic with Mock Sensor Pipelines

Sliding Window vs Event Triggering: What Reduced Our False Alerts

Building a Board That Can Boot With Missing Sensors

I2C Bus Recovery: Implementing Robust "Bus Clear" Sequences

DMA-First Pipelines: Let Models Wait, Not Sensors

Stable BLE Sensor Streams: MTU, Connection Interval, and End-to-End Buffer Control

From Noisy Clips to Trustworthy Labels: How We Fixed Audio Classification at the Source

Designing a Reliable Stop-and-Wait Transport Protocol on CAN FD for Deterministic Embedded Systems

Tech@Hoomanely

Latest

Queue vs. Direct Task Notify Performance Trade-offs in FreeRTOS ITC

Designing Multi-Rail Systems That Don’t Brownout Each Other

Ghost in the Shell: Validating Firmware Logic with Mock Sensor Pipelines

Sliding Window vs Event Triggering: What Reduced Our False Alerts

Building a Board That Can Boot With Missing Sensors

I2C Bus Recovery: Implementing Robust "Bus Clear" Sequences

DMA-First Pipelines: Let Models Wait, Not Sensors

Stable BLE Sensor Streams: MTU, Connection Interval, and End-to-End Buffer Control

From Noisy Clips to Trustworthy Labels: How We Fixed Audio Classification at the Source

Designing a Reliable Stop-and-Wait Transport Protocol on CAN FD for Deterministic Embedded Systems