In embedded firmware, "optimization" is usually the golden word. We optimize for speed, for power, and most frantically, for memory. We count bytes like misers counting pennies, shaving off struct padding and squashing enums into uint8_t wherever we can. We analyze map files, hunt down stack overflows,
The build failed at 11 PM on a Thursday. Not from our code, from a missing pkg-config path. The CMake configure step for Mosquitto was resolving openssl.pc from /usr/lib/x86_64-linux-gnu instead of from the target sysroot. We'd seen this class of error before. Fix it,
When users tell you "the chat feels slow," the first instinct is to blame the model. Bigger LLM, longer prompt, more retrieved context, those are the obvious suspects. But when we profiled our AI assistant's chat endpoint end to end, the model itself was already running
From Raw Bayer to JPEG on STM32H5 in roughly 200ms When a camera sensor captures an image A camera sensor doesn't directly produce a photograph. It generates a grid of raw intensity values arranged behind a color filter mosaic. On a desktop system, converting that raw data into
Firmware that passes physical hardware testing can still ship with bugs that vanish the moment you go looking for them, only to appear disastrously in the field under chaotic conditions. We call these Heisenberg bugs. The fix we landed on, which we call the Ghost strategy, introduces an injection point
In high-performance embedded systems, data integrity and deterministic timing matter more than almost anything else. Controller Area Network has been the backbone of reliable automotive and industrial communication for decades. CAN FD gave us higher bandwidth and larger payloads, up to 64 bytes, but standard CAN FD, while solid for
In embedded systems there's often a wide gap between a system that "functions" and one that performs. A prototype might capture an image, but if that simple act paralyzes the device for 200 milliseconds, blocking network keep-alives, delaying sensor readings, freezing the interface, is it really
In embedded systems, we often celebrate the idea of doing more with less. Smaller MCUs, tighter power budgets, fewer components efficiency as a virtue. But once you start building real device fleets at the edge, that philosophy quickly meets its limits. At Hoomanely, our devices don’t just sample a
When your camera produces data faster than your bus can consume it, buffer sizing alone won't save you. The real problem is state ownership, and the bars cutting through our images proved it. The problem: when fast producers meet slow consumers In multi-stage embedded pipelines, timing mismatches are
The decision we didn't question When we started building our edge systems, the filesystem was the easiest decision we made. It was familiar, stable, and came with decades of engineering behind it. Logs went into files. State got persisted as small blobs. Recovery was something the OS already