Running real protocols on constrained hardware: memory budgets, toolchains, and the discipline of fitting a network stack on a microcontroller.
23 posts
Those glass-bead pictures are not a printing trick: each bead is a tiny ball lens that samples a sliver of the image behind it and magnifies it. I ported a real GPU ray tracer of the effect to the browser so you can turn the knobs yourself.
I reimplemented a real mesh VPN's wire protocol in C on an ESP32, then compiled the encoder on my laptop to see the actual bytes. The first thing that bit me was a header field that lies about the packet — and that lie is load-bearing.
I cloned the FreeRTOS kernel, compiled its POSIX port with gcc, and ran five real experiments on Linux — preemptive scheduling, vTaskDelay vs busy-waiting, queues, mutex priority inversion, stack high-water marks — then mapped every concept to ESP-IDF on the ESP32.
A sensor node BOM audited honestly: what the board, regulator, sensor and radio choices really cost your ESP32 battery life, with a Python model computing the real average current, battery life and monthly data budget.
A working bench list, not a shopping list: the compiler with size, objdump and readelf to see what your code costs, gdb plus OpenOCD over SWD, a serial console built from picocom and socat, a logic analyzer driven by sigrok, and flashing with esptool — with real output from every tool I could run.
A cross toolchain whose target triple differs from the host lets you build ARM binaries on an x86 box. I compile for armhf and aarch64, verify with file and readelf, hit the real Exec format error, and run it under qemu-user.
A hands-on tour of Modbus — the tiny protocol that runs factories. Real request/response bytes over TCP and a pty-simulated RS485 link, with CRC16 verification and exception handling.
Hand-roll a lock-free SPSC ring buffer in C with atomic indices and acquire/release ordering. Real benchmarks, ThreadSanitizer race detection, and mutex comparison.
Fixed-point math on microcontrollers: why Q16.16 beats float when a chip has no FPU. Real C code, real overflow failures, a lookup-table sine, and honest timing numbers.
Byte order explained with real programs: dumping a 32-bit integer on x86, htonl and network byte order, the raw-struct-over-a-socket bug, Modbus registers, and how to detect and byte-swap endianness.
A superloop is fine for many devices, but one slow task starves the others. Real measurements of jitter and drift, plus the fixes that don't need an RTOS: fixed-timestep schedulers, state machines, and watchdogs.
Set up a CAN bus on Linux with SocketCAN and a virtual vcan0 interface: real frames, real arbitration rules, candump, cansend, cansniffer, CAN-FD, and the path to real hardware.
MQTT 5 adds shared subscriptions, request-response MQTT patterns, user properties, message expiry and real reason codes. Here is what each one actually changes, with real mosquitto 2.1.2 output.
A guided firmware analysis walkthrough for devices you own: where to get a vendor or OTA image, how binwalk recognises squashfs, cramfs, jffs2 and uImage, how to extract firmware with binwalk -e and unsquashfs, and how to hunt hardcoded credentials, private keys and API tokens with strings and grep.
A hands-on method to reverse engineer a serial protocol from a logic analyzer capture: wire up UART and SPI I2C, find the baud rate, read the hex bytes, test hypotheses with checksums, and write a small Python decoder.
A field guide to debugging ESP32 TCP: how lwIP socket buffers, Wi-Fi retries and Nagle/delayed-ACK interactions produce stalls, resets and half-open connections, which stats and Wireshark views actually reveal a TCP retransmission, and an ESP-IDF snippet plus a checklist.
Vendor clouds are a liability. Here is how self-hosted firmware update works on the ESP32: two app partitions plus an OTA data partition, the esp_ota_* APIs, signed images, and rollback when a new build fails to boot.
A practical guide to ESP32 power management on the ESP32-C3: why the Wi-Fi radio dominates the budget, what active, modem sleep, light sleep and deep sleep each cost in connectivity, how DTIM and listen interval trade latency for battery life, and how to measure real current cheaply.
MQTT fits a microcontroller's budget better than most IoT messaging stacks — a two-byte minimum header, publish/subscribe decoupling, and QoS you can dial down. Here is what an MQTT ESP32 system actually costs once TLS, certificates and reconnects enter the picture.
A hands-on method for reverse engineering BLE devices: enumerate BLE GATT services and characteristics with bluetoothctl, nRF Connect, and Python's bleak, capture the link with an HCI snoop log, read it in Wireshark, and reconstruct the app's protocol.
A practical ESP32 vs ESP8266 buying guide for 2026: CPU, RAM, flash, Wi-Fi, BLE, GPIO, security, power, toolchains and price tiers, plus a decision table and concrete picks by use case — including when an ESP32-C3 is the right default.
A practical ESP-IDF tutorial for the ESP32-C3: choosing between Arduino, PlatformIO and ESP-IDF, installing the toolchain, the project layout, a minimal app_main, GPIO blink, UART logging and a working Wi-Fi station — with copyable commands.
ESPTier reimplements the EasyTier v2.6.4 wire protocol in plain C on an ESP32-C3 — TCP framing, SipHash-1-3 identity, AES-128-GCM, route sync and forwarding — so a constrained MCU becomes a real, pingable member of an overlay network.