The author argues that successful programming relies 70% on understanding, 20% on practice, and only 10% on memorization, emphasizing that developers should focus on grasping core concepts, building muscle memory through repeated coding, and using documentation as needed rather than trying to memorize every API.
During Purdue's graduation season, computer science senior Eric Park built a detachable LED‑lit cap driven by Rust code on a Digispark ATtiny85, detailing the hardware choices, power constraints, and why he preferred Rust over Arduino for the project.
This tutorial shows how to use a MAX17048 fuel‑gauge module with an ESP8266 (or ESP32) to read voltage, state‑of‑charge and charge‑rate of a 18650 Li‑ion cell, wire the hardware correctly, calibrate the sensor, and publish the data in real time through MQTT for remote monitoring.
The article outlines a step‑by‑step learning roadmap for embedded software engineers, emphasizing the need to define goals, master C and hardware basics, understand RTOS and Linux, build hands‑on projects, develop debugging skills, and commit to continuous learning.
The article argues that low salaries in entry‑level embedded jobs are misleading, highlights high‑paying roles at companies like Huawei and BYD, explains how demand is shifting to new sectors such as EVs and IoT, and stresses that deep technical expertise, not superficial coding, determines long‑term value.
The ccv library, created in 2010 and still actively maintained, offers a highly portable C‑based computer‑vision toolkit with minimal dependencies, a built‑in cache for preprocessing, a full libnnc neural‑network runtime, and easy builds via Bazel, Make, or Swift Package Manager.
This guide walks through the essential steps of STM32 development—from reading schematics and configuring CubeMX to structuring code, debugging with tools like J‑Link RTT, and optimizing performance, providing practical tips to avoid common pitfalls and build reliable embedded systems.
This article explains how to adopt Linux kernel's struct‑array initialization and device‑tree matching techniques to implement a flexible C‑based UART driver that supports multiple compression configurations, complete with code examples and compilation guidance.
This article provides a comprehensive overview of U‑Boot, covering its definition, boot stages, environment variables, command system, device‑tree usage, network and storage support, security features, debugging techniques, performance tuning, platform migration steps, and a comparison with other bootloaders, all illustrated with concrete code examples and tables.
This tutorial walks through STM32's eight GPIO operating modes—four inputs and four outputs—detailing their electrical behavior, typical use cases, configuration steps, and providing complete HAL code examples to help embedded developers choose the right mode for reliable designs.
This guide explains why FreeRTOS has become essential, what interviewers truly test, practical learning paths for beginners to advanced users, common pitfalls, and how to apply the RTOS effectively to solve real embedded problems.
The article walks through a seemingly simple C file‑creation snippet that fails on Windows because Microsoft's tmpfile() uses C:\, then reveals a hidden bug where a stray backslash in a comment and a missing space in an expression silently turn code into comments, illustrating how tiny syntax errors can break cross‑platform programs.
This article explains what function pointers are in C, shows their declaration syntax, provides simple and advanced usage examples—including callbacks, state machines, and command dispatch—offers best‑practice tips, and demonstrates how they empower flexible embedded development.
This tutorial explains what function pointers are, how to declare and use them in C, and demonstrates practical embedded‑system patterns such as callbacks, state machines, command dispatch, and advanced techniques like pointer arrays and struct members, while highlighting common pitfalls.
This article explains the fundamental concepts and step‑by‑step workflow of ADC conversion in embedded systems, covering sampling, hold, quantization, encoding, and output stages, and provides detailed STM32 HAL code examples along with tips for improving accuracy.
This tutorial explains how to use the YS‑IRTM NEC infrared codec module with an STM32F103C8T6 MCU to decode remote‑control signals, map them to UART commands, and drive a three‑color LED, covering hardware wiring, protocol details, UART configuration, and full source code.
This article explains the concept of flexible arrays in C, compares them with pointer‑based arrays, shows allocation and deallocation code, and discusses memory continuity, performance, fragmentation risk, and suitable usage scenarios for embedded systems.
This article explains how AIoT‑era embedded devices evolve from simple C/assembly code to reusable, portable frameworks by applying design patterns such as the Observer pattern and a custom responsibility‑chain model for low‑power management, complete with code examples, memory‑pool handling, and test cases.
This guide explains how to use a custom dynamic loader library on STM32 (Cortex‑M7) microcontrollers, covering project structure, installation steps, and runtime usage to load relocatable AXF files into RAM similarly to DLLs or shared objects.
This article presents a collection of practical embedded‑system optimization techniques, covering time‑efficiency improvements such as avoiding floating‑point arithmetic and inlining functions, space‑efficiency strategies like choosing appropriate data types, using unions and flexible arrays, as well as loop unrolling, bit‑field usage, and data‑type selection to maximize performance on resource‑constrained devices.
This article introduces the lightweight lwbtn library for embedded C, explains its core features, shows how to integrate it on STM32 with a complete demo, and provides an in‑depth analysis of its architecture, state‑machine processing, click detection algorithm, configuration options, and practical usage tips.
This guide explains the DWT tracing component in Cortex‑M processors, details the CYCCNT register’s precision and limits, and provides step‑by‑step instructions with register definitions and multiple code examples for enabling, resetting, starting, stopping, and reading the cycle counter.
This article curates a collection of popular open‑source microcontroller projects, covering practical software modules such as MultiButton, QueueForMcu, and StateMachine, complete hardware projects like TinyGameEngine and HomeAutomation, IoT platforms, creative gadgets, and debugging tools, each with repository links, feature highlights, usage examples, and code snippets.
This article presents eight high‑frequency embedded‑system interview questions, explains the underlying concepts such as boot process, interrupt handling, stack overflow detection, struct alignment, bit‑banding, dynamic memory risks, volatile usage, and provides concise C code examples and best‑practice answers to help candidates succeed in technical interviews.
This article explains the concept of strong and weak functions in C, shows how to declare them with GCC and other compilers, outlines the linker selection rules, and demonstrates practical uses such as library overrides, interrupt handlers, callbacks, test stubs, plugin systems, and related pitfalls.
This tutorial walks through STM32F103ZET6 ADC fundamentals, explains key parameters, demonstrates how to use the VOFA+ PC tool for data visualization, and provides step‑by‑step implementations of several filtering algorithms—including first‑order complementary, median, arithmetic average, moving average, limit‑average, and Kalman filters—complete with code examples and performance analysis.
This article explains how to apply layered architecture and time‑slice (time‑slot) design in microcontroller programming, using a keypad‑scanning example to illustrate hardware, driver, and application layers, and shows how RTC‑based interrupts can manage multiple concurrent timers efficiently.
This article explains how to design decoupled embedded software by using a layered architecture, event‑driven mechanisms, pipeline‑filter data flows, and dependency injection, providing concrete C code examples and practical guidelines for each technique to improve maintainability and scalability.
This article presents twelve practical guidelines—ranging from layered design and adapter patterns to careful handling of standard functions and platform quirks—that help embedded developers write C/C++ code that can be reliably moved across different hardware and operating systems.
This article examines SQLite’s tiny footprint and embedded nature, compares it with MySQL, outlines its advantages such as cross‑platform support and easy backup, discusses its drawbacks like poor high‑concurrency handling and lack of remote access, and advises when SQLite is a suitable choice.
This article explains how microcontroller units (MCUs) handle floating‑point operations, covering IEEE‑754 representation, hardware versus software FPU approaches, performance and precision challenges, and a range of optimization techniques—from hardware selection and fixed‑point tricks to compiler flags and system‑level power management.
This guide shares practical embedded‑development hacks—from diplomatically blaming hardware issues and using the Linux devmem tool to read registers, to modular sensor driver design, safe pointer practices, and dynamic log‑level control—helping engineers reduce overtime and improve code maintainability.
A postage‑stamp‑sized Linux computer called Quantum Mini measures just 40 mm × 35 mm, packs an Allwinner H3 quad‑core CPU, Mali‑400 GPU, 512 MB RAM, a mini IPS screen, Wi‑Fi, Bluetooth, sensors and runs Ubuntu 16.04 from a micro‑SD, making it a fully functional tiny development platform for IoT, edge AI and robotics.
This article walks through C static keyword meanings, struct size calculations, macro definitions, hexadecimal conversion functions, a full‑featured Linux I2C driver example, and a list of common interview questions for embedded and kernel development, providing clear explanations and code snippets.
This guide explains the purpose of the PREEMPT‑RT real‑time patch, describes the hardware and toolchain used, details the kernel features and modifications introduced by the patch, and provides step‑by‑step instructions for downloading, applying, configuring, compiling, flashing, and verifying the real‑time kernel with cyclictest and stress‑ng benchmarks.
This article demonstrates how to use the H2 database with Java 1.8, covering embedded (file and memory) modes, server modes (Web, TCP, PG), mixed mode configurations, required dependencies, and provides complete JUnit test code examples for creating, accessing, and managing tables.
This article walks through migrating the USB stack of the STM32‑based candleLight_fw project to HPMicro's cherryUSB, detailing key source files, descriptor conversions, endpoint registration, vendor‑request handling, and showing how four CAN channels are enabled with code snippets and screenshots.
This article walks through the theory of Linux file systems, compares flash‑specific filesystems, outlines the essential rootfs directories, details required tools like a cross‑compiler and TFTP/NFS servers, and provides a complete step‑by‑step procedure—including BusyBox compilation, rootfs population, init scripts, and ramdisk creation—to produce a bootable root filesystem for an embedded board.
This guide explains the purpose of the PREEMPT‑RT (real‑time) patch, details the hardware and toolchain used, describes the patch's key features and modifications, provides step‑by‑step instructions for downloading, applying, configuring, compiling, and flashing the kernel, and shows how to verify latency improvements with cyclictest and stress‑ng across idle and CPU‑stress scenarios.
A light‑hearted yet practical guide walks through classic embedded moments—from lighting the first LED, quirky debugging tricks, tracking elusive memory leaks, hardware‑software blame games, to the ultimate goal of breathing life into products—offering both humor and useful tips for developers.
This guide explains the role of the /etc/init.d directory in embedded Linux, walks through common startup scripts such as rcS, rcK, and service-specific files, and provides detailed code examples and command‑line options to help developers understand, customize, and troubleshoot system initialization and shutdown processes.
This article introduces log.c, a compact C99 logging library suitable for any platform—including embedded systems—covers its key features, demonstrates usage with code examples, and explains how to configure log levels, file output, callbacks, multithreading, and colored output.
This guide introduces the log.c library, a compact C99‑based logger suitable for embedded platforms, covering its features, usage examples, level control, file output, callbacks, thread safety, and colorized output with code snippets and configuration details.
This guide explains the concepts of Linux file systems, compares root and regular file systems, lists common embedded flash file systems, outlines required root‑FS directories, and provides a step‑by‑step procedure—including cross‑compilation, BusyBox configuration, mounting, and ramdisk creation—to build and test a minimal root filesystem for an embedded device.
This article explains how MicroPython, a lightweight Python 3 implementation, enables programming on microcontrollers with limited resources, outlines hardware requirements, showcases example I2C code, and discusses its growing ecosystem alongside traditional C development.
This article details the process of adapting the V8 JavaScript engine for HarmonyOS, covering engine selection, cross‑compilation using CMake and Ninja, toolchain configuration, building builtins and snapshots, and integrating the resulting library into native HarmonyOS applications.
This article presents a curated collection of high‑impact C utility code examples—including a circular buffer, assertion macro, bit‑reversal function, fixed‑point arithmetic, endianness conversion, bit masks, timer handling, binary search, and a simple bitset—explaining their purpose and showing ready‑to‑use implementations for embedded systems.
Xiaomi Vela, an open‑source IoT operating system built on the NuttX kernel, offers high‑performance real‑time capabilities, rich components, unified frameworks, and extensive connectivity, and has been deployed on over 47 million devices, with source code now publicly released under Apache 2.0.
This article explains how to implement finite state machines in C using three classic approaches—switch‑case, table‑driven, and function‑pointer—detailing their structures, code examples, trade‑offs, and safety considerations for embedded and general‑purpose software development.
Zephyr RTOS 3.7.0 LTS was released on July 26, 2024, introducing over 650 contributors, new hardware models, expanded POSIX and Bluetooth support, numerous API changes, extensive driver updates, enhanced networking features, and a series of security patches covering multiple CVEs.
This article explains three core ways to implement finite state machines in C—switch‑case, table‑driven, and function‑pointer approaches—detailing their structures, code examples, advantages, pitfalls, and how they relate to extended and hierarchical state machines.
The article explains that __disable_irq() and __enable_irq() are compiler‑provided intrinsics that expand to CPSID i and CPSIE i instructions, return the prior PRIMASK state, globally mask CPU interrupt handling without stopping hardware events, and contrasts them with CMSIS __NVIC_DisableIRQ/EnableIRQ which control individual interrupt lines.
This guide explains why embedded development seems difficult and provides a systematic approach to reproducing, locating, analyzing, and resolving typical embedded problems—including simulation conditions, log printing, online debugging, version rollback, binary search commenting, register snapshots, stack overflow, and hardware quirks—plus regression testing and experience summary.
This article explains C language memory partitioning—including stack, heap, global/static, constant, and code sections—illustrates their characteristics and growth directions, then applies the concepts to STM32F103 by showing memory map details and providing a complete Keil‑based C program that prints the addresses of variables in each region.
This article explains the C language memory segmentation—including stack, heap, global/static, constant, and code areas—illustrates their behavior on STM32F103 with Keil V5, and provides detailed example code that prints the addresses of variables in each region to demonstrate allocation and lifetime.
A customer reported that on an STM32F103VDT6, disconnecting the external 8 MHz crystal did not trigger the external watchdog reset because the MCU’s PLL continued to generate a low‑frequency clock, but enabling the Clock Security System (CSS) and handling the NMI correctly resolves the issue.
This guide explains how to manipulate hardware registers, use function pointers, and perform bit‑level operations in C to control NAND Flash on S3C2410/S3C2440 platforms, providing concrete macro definitions, struct layouts, and initialization code for portable embedded development.
This article presents nine powerful C utility code examples—including a circular buffer, custom assertions, bit reversal, fixed‑point arithmetic, endianness conversion, bit masks, timer handling, binary search, and a simple bitset—explaining their purpose and demonstrating how they can improve performance and maintainability in embedded system development.
This tutorial shows how to wire a three‑color LED to an STM32F103C8T6, configure a HC‑08 Bluetooth module for UART communication, and write C code that toggles each LED based on received keywords (green, yellow, red) using the STM32 HAL library.
This article explains the Linux kernel boot sequence on ARM platforms, covering how the compressed kernel is decompressed, the role of the stext entry point, the preparation steps performed by __switch_data, and the detailed initialization performed by start_kernel and its key sub‑functions.
The article investigates a freeze occurring when dragging icons on an OpenHarmony 3.2.2 device after adapting the Spreadtrum T606 platform, analyzes related system‑ability (SA) logs, explains the SA and SAFWK frameworks, traces the PasteboardService failure to a missing serial‑number configuration, and proposes a practical fix.
This note introduces several open‑source C unit‑testing frameworks, compares their features, and provides a step‑by‑step guide for porting and using the Unity framework on an STM32 platform, including configuration, test case writing, and result interpretation.
This guide explains how GNU ld linker scripts work, covering their purpose, basic concepts like sections, symbols, VMA/LMA, the syntax of SECTIONS, INPUT, OUTPUT, and other commands, with practical examples and code snippets for embedded and desktop ELF binaries.
The article explains embedded ROM updating terminology, compares factory‑level burner programming with board‑level online flashing, details the boot sequence and U‑Boot implementation, outlines security signatures, common USB‑related issues, and the evolution of flash storage, concluding that online flashing offers low‑cost, scalable, high‑speed production for smartphones.
This article presents a comprehensive collection of CVTE embedded engineering interview questions and answers, covering project introductions, C/C++ operators, the static keyword, pointers vs. references, copy constructors, Linux sed usage, file system types, I²C limits, interrupt handling, recursion, IPC, GPIO modes, and compilation stages, providing clear explanations and code examples for each topic.
This article chronicles the 26‑year lifespan of Windows CE, detailing its origins, evolution, competition with Palm, role in embedded devices, the features of its final 8.0 release, and the reasons behind its complete retirement in 2023.
This article examines memory usage on a Junzheng T31ZC embedded Linux board, breaks down physical and kernel allocations, and presents practical techniques—such as trimming kernel symbols, stripping ELF files, optimizing rootfs, and manually dropping caches—to reclaim valuable RAM without adding hardware.
This guide explains a practical method for storing software version, compilation date, and time directly in a designated Flash address using Keil MDK, covering the necessary __attribute__ syntax, code examples, and tips to reduce firmware size.
This article explains the ARM hardware interrupt flow, the Linux kernel's handling of IRQ and FIQ, the construction of exception vector tables, the role of asmlinkage, interrupt registration, shared interrupt models, and the specific implementation for the S3C2410 platform.
This article explains the concept of asymmetric AMP dual‑system architecture, outlines its real‑time, stability, and cost advantages for industrial automation, and provides a step‑by‑step UART‑echo development example on the RK3568J SOM, including flashing commands and U‑Boot configuration.
This guide explains C structs—from basic definitions and declaration styles to memory alignment, byte sizing, bit‑field handling, nested structures, and using structs as function parameters—providing clear code examples and practical tips for efficient embedded and systems programming.
This article explains essential bootloader security mechanisms—including image integrity checks, digital signature verification, hardware/software memory protection, and the use of read‑only storage—while highlighting practical implementation tips for STM32 and the trade‑offs between security and system complexity.
This article shares practical insights from a Linux driver engineer on device trees, cross‑compilation toolchains, filesystem considerations, kernel configuration, and debugging techniques that every newcomer should understand to avoid common pitfalls and integrate drivers successfully.
This article compares Java and embedded development from salary, career development, and entry‑level difficulty perspectives, concluding that Java offers higher short‑term pay while embedded provides more stable, long‑term prospects for those willing to invest in extensive learning.
This guide shows how to create a multi‑threaded C program on embedded Linux, set thread names with pthread_setname_np, and use the top command with the -H option to display each thread’s status, illustrating the difference when thread names are omitted.
This article provides a comprehensive overview of WebAssembly, explaining its import/export model, tooling such as wit‑bindgen and waPC, practical examples for web browsers, command‑line runtimes, embedded systems, and plugin architectures, and demonstrates how to integrate WASM with languages like C, Rust, Go, Java, and Python.
Google unveiled KataOS, a Rust‑based secure operating system built on the formally verified seL4 microkernel, designed for embedded devices running machine‑learning workloads, with open‑source components on GitHub, a Sparrow hardware reference platform, and plans to release additional third‑party app support.
This guide introduces Linux Device Tree concepts, explains why it was added to the kernel, details its syntax and standard properties, describes common nodes, and provides practical examples of OF functions for accessing nodes and properties in kernel code.
The article uses a cultural analogy about Emperor Yongzheng to introduce the concept of mapping, then explains how Linux's mmap can map a physical GPIO register into user space, provides a complete code example for toggling an LED, and discusses mmap's broader uses and performance trade‑offs.
Notkia is a custom-built Linux smartphone that fits inside a repurposed Nokia 168x case, featuring a Ingenic X1000E processor, 64 MB RAM, 4 GB storage, multiple wireless interfaces, an IPS LCD, Yamaha audio chip, and plans for open‑source software and accessories after crowdfunding.
This article explains the real‑time requirements of industrial control, the limitations of traditional OS kernels, and how Linux RT‑Preempt, Xenomai dual‑kernel, and especially hardware‑assisted RTOS (HW‑RTOS) can dramatically reduce latency, interrupt disable periods, and API execution jitter to achieve hard‑real‑time behavior.
This article examines how the memory size of C enum types varies with declared value ranges and compiler options such as -fshort-enums, showing default and shortened sizes across different compilers and illustrating the impact of adding larger constant values.
This article systematically explains the Linux driver ecosystem by covering the bus‑device‑driver model, the role of device trees in decoupling hardware description from driver code, and step‑by‑step guidance for creating a custom development board with full DTS and kernel integration.
This tutorial walks you through preparing hardware, installing required tools, cloning the pico‑sdk, tinyusb and Fuzix sources, compiling the OS for the Raspberry Pi Pico, flashing it, and exploring the resulting system via a serial console.
RT-Thread is an open‑source, highly scalable IoT real‑time operating system written in C, offering ultra‑low resource footprints, modular components, extensive software package ecosystem, and cross‑platform support from tiny nano kernels to full‑featured ARM and MIPS systems.
This guide explains why embedding compile‑time information in embedded binaries is essential for version verification, demonstrates how to use __DATE__ and __TIME__ macros, and provides three practical methods—including touch commands and pre‑build actions—to ensure the timestamp updates on every build.
This tutorial walks you through creating a match‑box‑sized NFC‑enabled smart card that consolidates employee badges, access cards and cafeteria cards, detailing hardware selection, PCB design, firmware, e‑ink screen handling, and open‑source resources for a compact, multifunctional device.
This article introduces an open‑source, solder‑built keyboard that runs CircuitPython on a microcontroller, explains the hardware assembly, firmware flashing, library installation, and Python‑based key‑mapping to create a customizable USB/Bluetooth keyboard for productivity and gaming.
The article describes a complete LoRa‑based environmental monitoring and control system for data centers, built on TencentOS Tiny and featuring a LoRa gateway, sensor‑rich node, LCD display, relay and LED modules, cloud integration via Tencent Cloud IoT Explorer, and a WeChat mini‑program for remote management.
This article describes a tiny Linux‑based business card that boots in seconds, includes classic games and a MicroPython interpreter, runs on an 8 MB Allwinner F1C100s chip, and can be built for under three dollars using inexpensive components and DIY PCB fabrication.
TencentOS tiny is an open‑source, lightweight IoT RTOS supporting over 50 platforms and protocols like MQTT, CoAP, and LoRaWAN, offering a minimal kernel, low‑power frameworks, OTA, and security features, demonstrated through smart‑cabinet and smart‑agriculture solutions, a STM32L4 development board workflow, AT‑adapted networking, and seamless Tencent Cloud integration for rapid, low‑cost product deployment.
This article surveys the most prominent Linux‑derived operating systems for the Internet of Things, detailing their origins, real‑time capabilities, hardware requirements, and the ecosystems that support them, while highlighting the fragmentation and future prospects of Linux in IoT.
A recent Eclipse Foundation survey of 713 developers reveals the most popular programming languages and operating systems across constrained IoT devices, gateways, and cloud platforms, highlighting C/C++ dominance, Java's rise, and Linux's prevalence in the IoT ecosystem.
This article provides a comprehensive overview of SQLite, covering its file‑based embedded architecture, type affinity, core components, supported data types, essential API functions, transaction management, and techniques for storing and retrieving binary data in embedded applications.
This article walks through how the Samsung S3C2410 clocks are defined, linked to parent clocks, and finally registered in the Linux kernel via a chain of initialization functions, illustrating each step with source‑code excerpts and diagrams.
The Huawei LiteOS Workshop in Beijing gathered over 130 online registrants and 100 on‑site developers for a day of hands‑on sessions covering mainstream chip porting, STM32 migration, rapid integration with LianShengDe chips, Keil MDK debugging, and a fun balancing‑car demo, followed by lively Q&A and community bonding.
Minoca OS, a fully from‑scratch, open‑source operating system released under GPL‑v3, targets low‑power, memory‑constrained devices with a modular driver model, package manager, and POSIX compatibility, and the project invites community contributions to expand its ecosystem and improve usability.
This article explains STM32's 43 interrupt channels and how the AIRC register's 4-bit priority fields are divided into pre‑emptive and sub‑priority groups, illustrating each NVIC_PriorityGroup setting with concrete code examples and step‑by‑step configuration instructions.
This article explains what an IoT operating system is, why it matters, its key characteristics, lists major platforms and standard bodies, and analyzes the strategic moves of leading tech companies while highlighting Huawei's own IoT solutions.
NeDB is a pure‑JavaScript, MongoDB‑compatible lightweight database that can be embedded in Node services or desktop applications without requiring a separate installation, offering in‑memory or persistent storage, rich query features, decent write/read performance, and easy npm installation.
