Hello everyone, I am your hardcore partner. I used to struggle with the question: what exactly is the deal with those “chips” in embedded systems that are invisible and intangible? What routines and tools are needed to develop them? Today, I will take you through the mainstream MCU and CPU architectures, development methods, and essential tools in one go.
What is an MCU?MCU (Microcontroller Unit) is a “small computer” that integrates the CPU, memory, clock, and peripheral interfaces all on a single chip. It is compact, low-power, and cost-effective, making it best at connecting “black technology” from the real world, such as sensors, displays, and motors. Common brands include:
- • ST’s STM32 series (based on ARM Cortex-M)
- • NXP’s LPC, Kinetis (also part of the Cortex-M family)
- • Microchip’s AVR, PIC, SAM (ranging from 8-bit to 32-bit)
- • TI’s MSP430, Tiva C (Ultra-low-power and Cortex-M)
- • The rising star RISC-V chips (such as SiFive, GD32V, ESP32)
Overview of Common CPU ArchitecturesWhen it comes to architectures, it’s not just MCUs; there are also larger CPUs:
- • ARM (Cortex-M/A/R): The leader in the embedded market, with a complete ecosystem, supporting bare-metal, RTOS, and Linux.
- • RISC-V: An open-source instruction set with customizable hardware, attracting manufacturers both domestically and internationally.
- • MIPS: With a long history, it still finds use in networking devices and set-top boxes today.
- • x86 (Intel/AMD): Desktop-level CPUs, more commonly seen in industrial computers and edge servers in embedded applications.
- • FPGA + soft cores (MicroBlaze, Nios II): Logic can be reconfigured, offering high flexibility, but with a higher barrier to entry.
When choosing an architecture, first consider the project requirements: budget, power consumption, performance, software ecosystem… all are essential.
Comparison of Mainstream Development MethodsYou will find that for the same MCU, there are three main approaches:
- • Bare-metal: Directly manipulating registers, with concise code and fast response. However, you need to write interrupts, SysTick, and drivers yourself, making it the most challenging.
- • RTOS (FreeRTOS, μC/OS): Fully equipped with multitasking, timers, and message queues, significantly improving development efficiency while maintaining reasonable real-time performance.
- • Embedded Linux: Running on Cortex-A, x86, or higher platforms, with a rich file system and readily available network protocols, suitable for handling large data flows, graphical interfaces, and AI inference.
Is there a perfect answer? No. It depends on the project: if cost-sensitive and only reading/writing sensors, go bare-metal; for complex control logic, use RTOS; if cloud-based with large memory needs, opt for Linux.
Essential Development Tools ChecklistHere are the four most common tools on my desk:
- 1. IDE/Compiler: Keil MDK, IAR EWARM, STM32CubeIDE, GCC + VS Code, Arduino, PlatformIO… each has its followers.
- 2. Debugger: ST-Link, J-Link, DAPLink… allowing you to step through, set breakpoints, and control the flow.
- 3. Simulation and Recording: Logic analyzers, oscilloscopes, used to capture the “secrets” in SPI, I²C, UART.
- 4. Peripheral Boards: The most common Nucleo, Discovery, Arduino-compatible boards, great for beginners to avoid soldering all over the board.
There are also various programming tools (programming software), protocol stacks (TCP/IP, Bluetooth), IDE plugins… as you gradually get started, you’ll find that the more you use them, the more proficient you become.
Moving Towards Practical Application: Choosing the Right Solution to WinThe above insights are based on my experiences, having encountered pitfalls and using these tools to turn prototypes into mass production. In summary:
1) First ask yourself, “What am I doing?”
2) Then choose the MCU/CPU architecture.
3) Select the development method; don’t jump straight into Linux or bare-metal, as it can be slow to get started.
4) Get the IDE and debugger set up first, then add instruments.
By mastering these four steps, embedded development will no longer be a mystery. From now on, with just a flick of your fingers, the next generation of smart hardware can be born. Next time you really can’t write firmware, remember to revisit this article for a boost of motivation!
If you have better tools, architectures, or methods, feel free to share in the comments section, and let’s elevate our projects together!