The article compares SOC and MCU for embedded systems, using analogies, performance and power benchmarks, development ecosystem contrasts, and cost considerations to show how each fits different application requirements and why choosing the right one matters.
The article explains why embedded motor control has a high learning curve, outlines the essential hardware, motor, control theory, and math foundations, highlights the gap between theory and practice, and offers a step‑by‑step roadmap—from brushed DC basics to advanced brushless solutions—while emphasizing hands‑on experimentation and community support.
The article chronicles French programmer Fabrice Bellard’s extraordinary career, highlighting his groundbreaking C projects—from the LZEXE compressor and the Harissa JVM to FFmpeg, QEMU, TinyCC, QuickJS, and a record‑breaking Pi calculation—showcasing how a single developer reshaped multiple domains of software engineering.
The article explains that embedded software engineers don't need to be hardware experts, but must understand datasheets, basic digital circuits, common interfaces, interrupts, DMA, clock trees, and hardware pitfalls at different experience levels to effectively troubleshoot and integrate hardware in real projects.
The article compares the long‑term career prospects of graduate studies in embedded control versus machine vision, arguing that embedded systems offer stable demand, lower turnover and higher longevity despite the current hype around AI‑driven vision roles.
The article explains how embedding a computer into devices gives them dedicated intelligence, outlines the hardware‑software makeup, development challenges, widespread applications from household gadgets to industrial control, and highlights emerging AI trends and career opportunities in embedded engineering.
The article examines why many engineers doubt the future of embedded and microcontroller work—citing salary gaps, industry layoffs, steep learning curves, and limited growth—while arguing that the field still thrives in sectors like EVs, IoT, and medical devices and offering practical guidance on choosing the right niche, building deep technical skills, and evaluating the true cost of a career switch.
The article analyzes how the embedded systems field has shifted from a lucrative, in‑demand career five years ago to a highly competitive, low‑pay, technically demanding niche, urging prospective learners to weigh steep learning curves, costly hardware, and limited salary ceilings before committing.
Jcorp Nomad is a DIY, thumb‑sized offline media server built on an ESP32‑S3 that creates a local Wi‑Fi hotspot to stream movies, TV shows, music, e‑books and images without internet, offering ultra‑low power consumption, multi‑device support, extensive format compatibility, and a fully open‑source software stack.
The article argues that beginners should skip exhaustive register manuals, use STM32's HAL library and CubeMX to quickly build functional projects, then deepen their understanding of registers only when performance or special needs arise, emphasizing practical experience over premature low‑level study.
This article compiles a comprehensive set of technical interview questions and concise answers covering Linux kernel‑user communication, interrupt handling, memory allocation strategies, macros, endianness, cache hierarchy, process context, DMA, virtual memory translation, debugging tools, and driver initialization, aimed at candidates preparing for embedded Linux driver roles.
This article explains the open‑drain nature of I2C, why pull‑up resistors are essential for providing a high level, ensuring signal integrity and enabling wired‑AND logic, and offers practical formulas, recommended resistor ranges for different speeds, STM32 configuration examples, and debugging tips.
The article explains why the perceived "cold winter" in embedded development is actually a sectoral shift, contrasting the fast‑paced, low‑margin consumer electronics market with the high‑reliability, high‑demand fields of automotive, industrial control, and emerging AIoT opportunities.
The article explains the essential role of a base‑emitter (BE) resistor in transistor circuits—providing a stable bias, protecting against ESD, speeding up turn‑off, reducing noise sensitivity—and offers practical guidelines for selecting its value and integrating it into common embedded designs.
The article details how to convert analog voltage signals from transmission oil pressure, fuel level, and torque converter temperature sensors into digital values using specific formulas, then designs comprehensive test cases covering voltage boundaries, followed by an extensive set of automotive lighting control scenarios—including IGN, anti‑air, alarm, and turn‑signal logic—organized into multiple test groups.
This tutorial explains the SW-18010P vibration sensor’s features, pinout, and operating principle, then provides detailed hardware wiring, LED initialization, sensor initialization, interrupt handling, and a complete STM32F103C8T6 firmware example that lights a three‑color LED based on vibration detection.
Ferrocene, an open‑source Rust compiler toolchain, has achieved IEC 61508 SIL 2 certification for its core library, highlighting Rust’s growing role in memory‑safe, safety‑critical embedded devices and outlining the implications of SIL levels, certification bodies, and real‑world industrial use cases.
This article introduces MuditaOS, an open‑source embedded operating system for the minimalist Mudita Pure phone, detailing its FreeRTOS‑based service architecture, type‑safe message passing, lifecycle management, and the technical stack that enables a low‑power, E‑Ink‑optimized mobile experience.
This article presents a comprehensive collection of low‑level C optimization techniques for embedded systems, covering algorithm selection, data type choices, arithmetic shortcuts, loop transformations, structure layout, function inlining, register usage, and many practical code examples to dramatically improve execution speed and reduce code size.
RT-Thread, a Chinese open‑source real‑time operating system, offers a highly scalable kernel, rich component ecosystem, and modular design; this article examines its core libraries, module classifications, typical IoT and industrial applications, and provides detailed C code examples for thread management, synchronization, device drivers, file systems, and networking.
This guide explains why refactoring embedded software is uniquely challenging, outlines preparation steps, presents basic to advanced refactoring techniques, shows hardware‑specific and real‑time optimizations, describes verification methods, and provides a concrete sensor‑data case study with measurable results.
Qualcomm announced it will acquire Arduino to extend its reach to long‑tail developers using Qualcomm chips, leveraging Arduino's 33 million‑user community, introducing the dual‑brain UNO Q board and the App Lab IDE to accelerate AI‑enabled embedded solutions across industries.
This guide explains how to achieve clean decoupling in embedded software by employing a systematic layered architecture, leveraging event‑driven and pipeline‑filter patterns for data flow, and applying dependency injection, complete with practical C code examples and best‑practice recommendations for resource‑constrained devices.
This article explains how event‑driven programming and state‑machine concepts can be applied to microcontroller firmware, compares a simple flag‑based approach with a message‑queue solution, and presents a reusable GF1.0 framework that combines ISR, message buffering, and a main state machine for robust embedded systems.
This article compares traditional if‑else/switch‑case branching with the Strategy design pattern in embedded development, illustrating their differences through analogies and code examples, and explains when to adopt Strategy for better extensibility, lower coupling, and maintainability while noting scenarios where simple branching remains preferable.
This intensive two‑day course covers ARM32/64 processor instruction sets, mode switching, exception vectors, system call mechanisms, memory management, atomic operations, cache synchronization, and top‑down performance analysis with perf, while also introducing M‑series MCU architectures and providing hands‑on labs for embedded Linux developers.
This article explains what a MAC address is, its structure and role in networking, and why many embedded devices must assign their own MAC addresses due to cost, industry practices, and the need for on‑demand configuration rather than universal uniqueness.
This article compares functional and imperative programming for embedded systems, examining testability, maintainability, and performance, and provides C code examples that illustrate the trade‑offs of each paradigm; it also discusses resource constraints, recursion overhead, and how to combine both approaches in practice.
This article explains how Rust’s high performance, strict memory safety, and modern concurrency model are reshaping industrial automation—from embedded controllers and IoT devices to robotics—by eliminating common C/C++ bugs, improving reliability, and enabling scalable, secure systems.
From powering cutting‑edge 3A games and operating system kernels to accelerating scientific simulations, high‑frequency trading, and embedded IoT devices, C++ remains the go‑to language for high‑performance, low‑level control across diverse domains, thanks to its speed, portability, and fine‑grained memory management.
This article compares functional and imperative (non‑functional) programming approaches for embedded applications, examining testability, maintainability, performance, and resource usage, and provides concrete C code examples illustrating each paradigm’s trade‑offs, helping developers choose the right style for their constraints.
This article explains the role of the interrupt system in ARM‑based Linux platforms, covering hardware modes, vector tables, exception handling, GIC architecture, and kernel integration, and provides detailed code examples and optimization techniques for developers working on embedded and high‑performance systems.
Shared bicycles rely on a sophisticated blend of smart locks, embedded chips, GPS modules, Bluetooth, and IoT connectivity—powered by kinetic energy—to enable QR‑code unlocking, real‑time location tracking, and seamless payment integration, all coordinated through cloud‑based communication networks.
A bootloader is the first program executed when a device powers on, checking hardware, initializing memory, locating the operating system, and handing control over, while also providing a recovery path and enabling developers to perform low‑level modifications.
This guide presents practical, cross‑industry techniques for advancing embedded software engineers, covering deep memory‑management practices, cache and compiler tuning, real‑time analysis, RTOS kernel customization, security hardening, layered architecture design, and power‑saving strategies such as DVFS and tickless idle.
The article recounts how Japan’s 1989 TRON Intelligent House showcased early ubiquitous computing, describes the TRON architecture’s various profiles, and explains how geopolitical pressure from the United States halted Japan’s ambition to create an independent IT ecosystem, shifting focus to embedded‑system ITRON.
Lua, a lightweight scripting language born in Brazil in 1993, overcame early obscurity to become a globally adopted tool for game development, embedded systems, and diverse applications, illustrating how a small team can solve a universal need and achieve worldwide success.
CherryUSB is a compact, highly portable USB host/device protocol stack for embedded systems that offers simplified code, class‑based APIs, extensive class support, low memory footprint, and easy porting across many USB IP cores, backed by detailed documentation and example repositories.
This article provides a comprehensive interview guide for embedded systems positions, covering Linux thread scheduling, single‑core CPU execution, STM32 chip specifications, SPI communication, DMA concepts, synchronization primitives, priority inversion solutions, debugging techniques, and software design considerations.
This article introduces fourteen mainstream RTOS—including μClinux, μC/OS-II, eCos, FreeRTOS, mbed OS, RTX, VxWorks, QNX, NuttX, djyos, AliOS Things, Huawei LiteOS, RT-Thread, and SylixOS—detailing their characteristics, hardware requirements, strengths, and typical application scenarios for embedded development.
When an RTOS has no runnable tasks and all tasks are delayed or waiting for events, the CPU does not stay idle but executes the system's idle task or thread, which may simply loop forever unless the developer adds custom work.
This article provides an extensive overview of embedded software fundamentals, covering heap vs. stack differences, wild pointers, DMA roles, inter‑process communication methods, memory allocation strategies, malloc vs. new, volatile usage, pointer concepts, Linux kernel locks, FreeRTOS mechanisms, stack overflow prevention, compilation stages, quick‑sort algorithm, header inclusion, CAN identifiers, struct memory optimization, STM32 interrupt handling, user‑to‑kernel transitions, and condition‑variable thundering‑herd effects.
Google has rebuilt the protected virtual‑machine firmware of its Android virtualization framework in Rust, highlighting the language’s safety benefits, productivity gains, and the broader push from both industry and the U.S. government to eliminate memory‑safety bugs in critical software.
This article explains the structure and interpretation of Vector's DBC file format, covering nodes, messages, signals, byte order, scaling, and annotation syntax with concrete examples and code snippets.
Embedded Linux systems often auto‑start applications after boot to save resources, and this guide explains three methods—using a /linuxrc script, adding scripts under /etc/init.d, and editing /etc/rc.d/rc.local—plus a detailed overview of Linux runlevels and the complete boot sequence.
The article shares a firsthand account of an embedded engineer’s workflow, detailing the development, testing/production, and maintenance phases of a product lifecycle, and offers practical insights and personal reflections on the challenges and learning opportunities at each stage.
This article details the successful adaptation of a financial terminal tablet to OpenHarmony on an RK3588 platform, covering the RK3588 display architecture, eDP + DP‑to‑HDMI dual‑screen configuration, DTS settings, Linux DRM driver porting, testing with hello_composer, and the challenges and solutions for DP hot‑plug support.
This article examines how DevOps principles can be applied to embedded software development, analyzing its core concepts, specific challenges such as hardware dependency and resource constraints, and proposing organizational and CI/CD design solutions, illustrated with case studies and workflow diagrams, concluding with measurable efficiency gains.
This article compares the infinite‑loop constructs for(;;) and while(1) in C, examining compiler optimizations, performance measurements on microcontrollers, coding style guidelines, and industry standards to determine if one form offers any real advantage over the other.
Lua is a lightweight, high-performance scripting language supporting multiple paradigms, widely used in game development, embedded systems, and web servers; this guide explains its core characteristics, typical applications, and provides step-by-step instructions for downloading, compiling, and configuring Lua on a Linux system.
This article explains LCD screen fundamentals, covering pixel organization, color encoding methods, framebuffer memory requirements, and the various hardware interfaces such as 8080, TFT‑RGB, and MIPI standards used by both microcontrollers and application processors.
An extensive guide covering MCU fundamentals, from its definition and rapid historical evolution, through classification, core functions, leading manufacturers, practical learning strategies, typical program architecture, and detailed C code examples, offering engineers essential knowledge for effective microcontroller development and application.
This guide details a lightweight AT command parsing module supporting both bare‑metal and OS versions, explains its architecture, core data structures, key APIs, and provides step‑by‑step usage examples—including GPIO testing, signal‑quality queries, and TCP data transmission—for modems, Wi‑Fi and Bluetooth communication.
This article explains the roles of the static and volatile keywords, compares sizeof and strlen, shows how to reliably compare floating‑point numbers, discusses the impact of floating‑point operations on STM32 interrupt performance, and outlines the I2C protocol and address configuration for embedded systems.
In embedded systems, when an interrupt service routine takes too long, rapid successive interrupts can be lost, prompting questions about hardware flag buffering, software alternatives, and practical techniques to emulate a small interrupt cache without sacrificing real‑time responsiveness.
This article introduces an AT‑command communication parsing module that supports both bare‑metal (at_chat) and OS‑based versions, explains its software architecture, core data structures, key interfaces, and provides step‑by‑step usage examples with complete C code snippets for Wi‑Fi, Bluetooth, and modem integration.
The article compares spin_lock, rwlock, seqlock and RCU for protecting a shared kernel resource in a multi‑core embedded system, explains how RCU enables lock‑free reads, discusses the challenges of safe deletion, and outlines the RCU read‑copy‑update workflow.
This article explains the motivation, dictionary design, bigram table, encoding rules, and real‑world compression results of the Smaz2 library, a space‑optimized C/Python compressor for short LoRa messages on microcontrollers with less than 2 KB RAM.
The 2024 National Advanced Computer Teaching Training held in Dongguan brought together over 200 university teachers from 119 schools to explore cutting‑edge topics such as cloud data warehouses, AI platforms, digital logic, and OpenHarmony, showcasing industry‑academic collaboration and practical hands‑on sessions.
This article explains the concept of weak symbols and weak references in C, demonstrates their behavior with practical examples, and shows how they can be leveraged to create maintainable, cross‑platform embedded drivers while addressing compiler differences and linker nuances.
This article presents seven practical, long‑term strategies—such as ROM filling, CRC checks, RAM validation, stack monitoring, MPU usage, robust watchdog design, and avoiding volatile memory allocation—to help embedded engineers build more reliable firmware and catch abnormal behavior early.
This comprehensive guide presents 65 common embedded‑system interview questions covering topics such as memory layout, stack vs. heap, static and volatile keywords, pointers and references, malloc usage, C vs. C++ differences, compilation stages, process and thread concepts, IPC mechanisms, and networking fundamentals, providing concise explanations and code examples for each.
Microsoft has donated the Azure RTOS (formerly ThreadX) to the Eclipse Foundation as open‑source software, expanding access for Raspberry Pi and countless embedded devices while promising broader community collaboration and continued certification support.
This article compares motor‑control engineering and Linux driver development, outlining the core tasks, required knowledge, and typical technologies for each field, and helps readers decide which specialization aligns better with their skills and interests.
At the 2023 CCF ESTC conference, OPPO showcased its 64 KB dynamic large‑page technology that can increase memory‑access bandwidth up to sixteenfold and improve app startup and frame rates, while also co‑hosting a Linux‑kernel forum on scheduler, lock contention, memory defragmentation and hot‑cold page optimization, underscoring the company’s push for industry‑academic collaboration and future OS research.
This article explains the definitions, features, and core concepts of real‑time operating systems (RTOS) and time‑sharing operating systems (TSOS), compares their characteristics and typical use cases, and concludes that standard Linux is a time‑sharing OS that can be patched for real‑time operation.
This article explains the definitions, characteristics, and core concepts of real‑time operating systems (RTOS) and time‑sharing operating systems (TSOS), compares their typical use cases, and clarifies why standard Linux is a time‑sharing system that can be patched to become real‑time.
This article provides a comprehensive overview of serial communication, comparing it with parallel communication, detailing communication modes, and explaining the characteristics, physical interfaces, protocols, baud rates, and data structures of RS232, RS422, and RS485, including practical wiring examples.
The article examines how the automotive sector adopts continuous delivery, describing the multi‑stage deployment pipeline, safety‑critical testing, distributed embedded architectures, and real‑world observations from Tesla’s over‑the‑air updates, while highlighting the technical and organizational challenges involved.
This article explains the principles of event‑driven programming and state‑machine design for microcontrollers, compares them with interrupt handling, introduces a message‑based architecture with concrete data structures and APIs, and shows how to build a reusable framework that solves ordering and loss problems in embedded applications.
The article explains how to safeguard embedded firmware by using each MCU's unique device identifier to generate per‑device licenses, outlines simple and advanced encryption methods, compares secure and regular MCUs, and introduces a production‑grade programming tool that enforces these protections.
In bare‑metal embedded systems without an RTOS, the fate of a program after the C main() function returns varies by compiler, and understanding the startup code and post‑main behavior explains why LEDs may flicker or why an infinite loop is often required.
Linux’s Contiguous Memory Allocator (CMA) reserves and manages large physical memory blocks for devices by integrating with the Buddy system, using structures like struct cma, bitmap allocation, and APIs such as cma_init_reserved_mem and cma_alloc, while handling page migration, LRU and per‑CPU PCP caches to ensure efficient allocation and release.
This article compares the dominant X86 and ARM CPU architectures, explaining their performance versus power trade‑offs, CISC versus RISC designs, typical application domains, and the recent surge of ARM‑based servers driven by cloud, HPC and edge computing demands.
This guide covers core Linux commands, supported file types, inter‑process communication methods, ARM exception categories, interrupt handling steps, GPIO concepts, I2C and SPI pin functions, as well as driver inspection commands, character device creation, synchronization primitives, and key kernel subsystems.
This article explains the principles, transfer modes, parameters, features, and register configuration of Direct Memory Access (DMA) in STM32 microcontrollers, illustrating how DMA offloads data movement from the CPU, improves performance, and integrates with peripherals, memory, and interrupt handling.
Google has unveiled KataOS, a security‑focused operating system for embedded machine‑learning devices built entirely in Rust on the formally verified seL4 microkernel, with open‑source components on GitHub, a Sparrow reference hardware platform using OpenTitan, and plans to open more of its ecosystem.
Google unveiled KataOS, a Rust‑written, seL4‑based secure operating system for embedded AI workloads, open‑sourced on GitHub and complemented by the Sparrow reference platform that combines the OS with OpenTitan hardware for end‑to‑end security.
Google’s experimental KataOS, built with Rust atop the formally verified seL4 microkernel and paired with the Sparrow reference implementation, aims to provide a provably secure operating system for embedded machine‑learning workloads, highlighting collaborations, architectural choices, and its place among historic microkernels.
This article explains the origins, standards, physical layer designs, differential signaling, bit timing, synchronization methods, and frame structures of the CAN bus, illustrating why it remains the most reliable and widely used fieldbus in automotive and industrial applications.
This article examines how the automotive industry adopts continuous delivery, detailing the unique distributed, embedded, and safety‑critical constraints, the three‑stage deployment pipeline, test selection and load‑balancing strategies, and a case study of Tesla’s firmware rollout patterns.
The article examines how the automotive industry adopts continuous delivery and DevOps techniques—detailing deployment pipelines, distributed embedded ECUs, safety‑critical testing, tooling, and real‑world observations from Tesla’s firmware release cycles—to illustrate the unique challenges and emerging solutions for rapid, reliable software updates in vehicles.
This comprehensive guide explores the fundamentals of embedded real‑time operating systems, covering instruction set architecture, hardware‑software ecosystems, multi‑task scheduling algorithms, inter‑process communication primitives, software timers, and concrete RISC‑V and Cortex‑M porting implementations with Rust and assembly examples.
The article explains UEFI’s seven‑phase boot process, its open‑source EDK2 implementation, and how its modular drivers, event‑driven multitasking, and extensible services differ from traditional embedded bootloaders such as u‑boot or LK, making UEFI better suited for complex devices like smartphones.
FreeRTOS supports both static and dynamic memory allocation, allowing tasks, timers, semaphores and mutexes to use either a pre‑allocated region or the system heap, provides pvPortMalloc/vPortFree APIs, and offers five heap schemes (heap_1‑5) ranging from simple non‑freeing allocation to multi‑region coalescing management for flexible embedded applications.
SPI is a high‑speed, full‑duplex serial bus using four pins (CS, SCK, MOSI, MISO) with configurable clock polarity and phase, whose timing diagram shows data transfer on clock edges, and Linux provides a driver framework built around spi_driver, spi_transfer, and spi_message structures for reliable sensor communication.
This article explains how FreeRTOS treats tasks as the smallest scheduling unit, details the three phases of task scheduling, describes task states and transitions, and reviews the built‑in communication mechanisms such as semaphores, queues, notifications, and event groups.
Xiaomi unveiled its bionic quadruped robot, CyberDog (nicknamed “铁蛋”), featuring a Jetson Xavier NX AI brain, 32 N·m torque servomotors, advanced vision and auditory sensors, and a suite of motion capabilities, while offering a limited edition at just 9,999 yuan and promising open‑source hardware and software for developers.
This article explains the limitations of NTP for clock alignment, introduces the Precision Time Protocol (PTP) and its IEEE 1588 versions, describes the master‑slave hierarchy, hardware timestamping, and why PTP delivers far higher synchronization accuracy for networked devices.
The article explains Device Tree fundamentals—defining DTS, DTSI, DTB and DTBO formats, their origin as a cleaner alternative to kernel‑embedded platform code, how overlays decouple vendor changes via matching project and PCB IDs, the rules for modifying nodes, and debugging techniques using dtc and mkdtimgdump tools.
Over decades, embedded technology has expanded into the Internet of Things, reshaping the tech stack, demanding new developer skill sets, introducing advanced IoT operating systems, and driving a shift from hardware‑centric sales to cloud‑based services and innovative business models.
This article examines how the rise of the Internet of Things has transformed the technology stack, developer responsibilities, operating systems, and business models, highlighting the expanding skill set required and the shift from hardware‑centric revenue to cloud‑based services and platforms.
This article provides a comprehensive guide to UART fundamentals, communication protocols, baud‑rate calculations, RS232/RS485 differences, flow‑control mechanisms, and the Linux TTY serial framework, including driver registration, data flow, key kernel structures, and practical C code examples for embedded development.
This article provides a comprehensive guide to UART technology, covering its hardware protocol, baud‑rate calculations, RS232/RS485 differences, flow‑control methods, the Linux TTY serial framework with key data structures, driver registration lifecycle, RS485 debugging modes, and a complete C example for configuring and using a serial port on Linux.
The article explains that aircraft software relies on standard computer components but requires highly reliable, robust, real‑time operating systems such as VxWorks for Boeing 787 and AH‑64, Integrity‑178B for many fighter jets and Airbus A380, and recent C++ implementations with CompCert for the F‑35, highlighting the unique demands of aerospace computing.
This article provides a comprehensive overview of ARM's processor architecture, its ecosystem and business strategy, recent product releases such as Cortex‑A78, Cortex‑X1 and Mali‑G68, as well as the company's role in AIoT, automotive and cloud computing markets.
CHRE (Context Hub Runtime Environment) is an event‑driven, single‑threaded framework that hosts nanoapps on a sensor hub, organizing its source tree into API, Core, PAL, Platform, Apps, and Util directories, and managing events through a singleton EventLoopManager that initializes, queues, and dispatches system and nanoapp events.
TencentOS Tiny is an open‑source, ultra‑lightweight real‑time OS for IoT devices that abstracts hardware, provides secure identity, modular networking, OTA updates, low‑power management, and dynamic ELF loading, supporting dozens of MCUs and enabling rapid integration with Tencent Cloud or private clouds across diverse verticals.
This article explains how to overcome the limitations of PC‑based simulators for in‑vehicle navigation development by using a Thrift‑based proxy (Sandwich) to forward car‑side signals to a PC, enable bidirectional debugging, and project map rendering back to the vehicle display.
This article explains what sensors are, their crucial role as the perception layer in the Internet of Things, outlines common sensor types such as ultrasonic, infrared, temperature‑humidity, light, motion, pressure and gas sensors, and discusses emerging trends like higher precision, miniaturization, low power consumption, and improved reliability.
