Word Count: 8000

Many beginners, and even veterans with several years of experience, complain about the fierce competition in the electronics industry. Feeling dejected only kills their passion; without passion, working in electronics is a waste of life. Is the competition really that fierce? Compared to other fields, isn’t the competition in business and management just as fierce? In this society, every field and industry faces competition.

Therefore, if you want to avoid competition, you might as well not live! Of course, if your family is wealthy, that’s another story! So, regardless of the industry, there’s no need to ask whether the competition is intense. The answer is: Yes, competition is fierce, but we must face it. The less competition we face, the more skilled we should be. Those in electronics must keep up with the times, but as people age, their brains may become dull, leading to a natural cycle of aging in electronic talent (especially in software development).

This means that technical talent around the age of 40 typically has three paths.

First, they start their own business or move into management, completely leaving behind technical work, hiring younger novices to explore new ideas while they rely on their experience to guide them.

Second, they switch careers, which is hard to judge as good or bad.

Third, they continue in technical roles, but this can be exhausting. They push themselves to learn daily, but it often feels thankless, and they hesitate to change jobs because their programming mindset becomes fixed, passion wanes, and learning ability declines. Adapting to a new work environment becomes challenging, and unless they are veteran experts or already in a technical leadership role, they can easily be replaced by newcomers. In other words, after over a decade in technology, this group will gradually fade from the industry, leading to a generational shift.

Thus, true technical talent will always be in short supply, provided you genuinely possess the ability. As long as you have the skills, you will always be in demand, never fearing competition. The focus should not be on the intensity of competition but rather on your own capabilities.

How to Learn Microcontrollers Well?

I began self-studying microcontrollers in my sophomore year (our school’s microcontroller course is offered in junior year, covering assembly language). At that time, I had no idea what a microcontroller was; I followed the schematic diagrams in books to solder on a breadboard, not understanding buttons, seven-segment displays, serial ports, potentiometers, temperature sensors, etc. I just soldered blindly and sought help online when confused. I had no programming knowledge, but I copied code, compiled it, and uploaded it, and it worked, even though I didn’t understand it. However, this gave me a significant boost in confidence. Remember, those in electronics always find fulfillment first; even if they don’t understand, creating something still feels rewarding. Gradually, by my junior year, I started learning microcontrollers and C language. The old saying goes, pay attention in class. At this point, an important point is that theoretical knowledge must be applied in practice. I often visited the lab and worked on microcontroller programming and debugging development boards. This period is crucial; despite attending the same classes, some people are not suited for electronics because they don’t engage hands-on and forget too quickly.

Learning microcontrollers is a combination of software and hardware. Simply knowing a bit of assembly or C language doesn’t mean you understand microcontrollers; that only indicates you know programming. Most microcontroller systems are bare-metal systems without operating systems, meaning there are no software interfaces available. This means you need to build a simple front-end and back-end system. If you only know how to write application software, using microcontrollers can be challenging because they lack software interfaces. Thus, when learning microcontrollers, you must first understand hardware, which includes basic components like resistors, capacitors, inductors, transistors, diodes, comparators, etc. I believe that university courses on analog and digital electronics are crucial; mastering analog electronics lays the foundation for digital electronics, making it particularly important. Then, digital electronics should be absorbed for its concepts. Many integrated circuits introduced in digital electronics, such as logic gates, counters, flip-flops, and comparators, are rarely seen in industry today, but their design concepts are worth learning.

Understanding the internals of microcontrollers clarifies that microcontrollers or other main controls (such as ARM and DSP) are highly integrated versions of these components. Therefore, before or while learning microcontroller programming, take some time to study analog and digital electronics to a level you understand, then you can start learning microcontroller programming, whether in C language or assembly, depending on your preference. C language is easy to port, maintain, and program quickly, but its compiled code often takes up more space, typically used in embedded software requiring high portability or larger microcontroller projects where development speed is prioritized over cost. Conversely, assembly is used in industries with thin profit margins, low costs, and less challenging development, such as small appliances. However, modern MCUs are also inexpensive, with some costing just a few dollars for dozens of kB of FLASH ROM. Given today’s high labor costs, C language is likely to be more market-friendly. While learning this theoretical knowledge, hands-on experimentation is essential. Don’t fear making mistakes; the worst is being too lazy to try.

After Learning Programming, How to Transition to Microcontrollers?

Beginners who have learned programming languages or those who want to transition from pure software to microcontrollers typically share a common trait: they often don’t know how to start.

So I would ask, do you understand hardware? The requirement isn’t high; a basic understanding is sufficient. Hardware knowledge improves with practice; the more you work with it, the more proficient you become.

If you know nothing, then refer back to the earlier section and start learning hardware basics.

If you have a basic understanding, your entry point is to find a suitable beginner-friendly microcontroller among the myriad options available. Beginners should base any decision on the criterion of “ease of access.” Once you get started, you won’t fear not being able to keep up later. Aim for general-purpose MCUs with abundant resources and software platforms that are easy to use, such as the 8051 core. Although simple, it is the ancestor, making it easy to learn. Once you understand this ancestor, other more complex systems are merely derivatives and won’t be too difficult. Delving into overly complicated things at the start can not only hinder your learning but can also damage your fragile confidence.

Once you’ve chosen a microcontroller, set up a development platform. First is the software development platform; different microcontroller cores or models require different platforms, such as KEIL51 for 8051 cores, IAR for AVR, and many more from various manufacturers. Next is the hardware development platform, which is the development board. Different microcontrollers have slightly different pinouts and peripherals, so development boards are tailored accordingly. Many boards available online aim to be versatile, supporting numerous MCU models at low prices. If you’re afraid of mistakes or soldering errors, you can buy one; importantly, modern development boards are inexpensive and well-designed, often costing just a few dozen dollars. In the past, they often cost hundreds, which was quite a financial burden. However, I recommend soldering your own, especially if you feel confident about hardware; it’s an excellent opportunity to practice soldering and deepen your understanding of circuits. In truth, various development boards are quite similar; as long as you follow these principles in soldering:

First, create a minimal working environment with power circuits, reset circuits, and oscillation circuits (many MCUs now integrate internal oscillators that are accurate and fast). Then include other commonly used peripheral circuits: button inputs (for multiple buttons, you can use a matrix and learn matrix scanning), serial ports (UART), AD/DA converters, buzzers, seven-segment displays, motor drivers, temperature sensors, etc. There is a wealth of information on these peripherals available online; beginners have been learning these for decades.

These peripheral circuits have extensive documentation online; just find a few and compare them. Grab a breadboard, and you can start soldering. If it doesn’t work, check if the microcontroller’s working voltage is normal, whether the oscillator is functioning, and if the reset circuit is correct. If it still doesn’t work, solder another one, haha. With both software and hardware platforms, you can begin experimenting, starting with imitation, then making modifications, and eventually creating something entirely new from scratch, writing code for your first unique project. By the way, programming microcontrollers differs from pure software programming; aside from shared programming concepts and most syntax, other aspects such as register configuration and certain syntax have specific requirements, so it takes time to learn. Once you’ve mastered the 8051, if time allows, you can explore other microcontrollers like AVR, PIC, MSP430, etc., or more powerful 8051 variants as a form of advanced practice.

Are ARM, DSP, and Other Main Controls Difficult?

ARM, DSP, etc., are essentially a type of microcontroller, just with more powerful cores. I have worked with both for a while, but if you merely treat them as ordinary microcontrollers, it shows a lack of understanding.

First, let’s talk about ARM chips. Their cores are ARM cores, which operate at much higher frequencies, often several hundred MHz. They have large CPU caches and multi-level pipelining, significantly improving CPU utilization. These ICs have enough resources to run an embedded operating system smoothly, such as WINCE, LINUX, UCOS, etc. You can port an OS onto them and then write application software using the OS’s interfaces to control their powerful peripherals. Of course, another type of engineer is involved here: the embedded driver engineer, who writes drivers for hardware interfaces, making them available for upper-level users. This role is somewhat similar to working with microcontrollers. Many people want to transition from software to ARM; my advice is, unless you are exceptionally capable, start with microcontrollers before moving to ARM.

DSP, known as Digital Signal Processor, is designed for data processing. Its data processing capabilities far exceed those of ARM. Generally, its interfaces are not as rich as ARM’s, as they are tailored for fast storage and rapid access, preparing for efficient data processing. Typically, it operates at hundreds of MHz and certainly includes DMA. It’s often used for image processing, video processing, and network data processing. Because it’s designed for data processing, those proficient in DSP must master various data processing algorithms, like Fourier transforms. If you treat a DSP as just another MCU, you’re wasting it; using a $100 component like a $10 one is not optimal. To utilize it effectively, you need to master algorithms.

What is Embedded Software?

Embedded software includes embedded operating systems and embedded application software. Most embedded software resides on ARM-based chips. Companies like Samsung and Philips produce ICs with ARM cores. Software developers can easily transition to embedded software, but creating embedded driver software can be challenging since it involves hardware interfaces. This year, embedded development has become popular in digital products like MID and handheld computers. When I joined Lingyang, fresh graduates were already well-versed in Linux, which was quite a pressure, haha. This shows that those looking to escape competition should reconsider.

Embedded systems are often labeled as having high barriers to entry, and their lower starting salaries compared to software development have been humorously referred to as “starving.” Many are passionately entering the embedded field, yet many who cannot cope transition into product management or technical sales. Do embedded engineers really have a future?

Indeed, due to the relatively low code volume in embedded systems compared to pure software, starting salaries may be lower, but the salaries of industry veterans are quite considerable. Moreover, looking long-term, embedded systems are penetrating various fields such as consumer electronics, security, automotive electronics, medical electronics, telecommunications, etc., and there’s an annual talent gap of about 400,000. This year, machine learning (ML) is a hot topic, and Arm has also launched the Arm NN neural network machine learning software, which can easily build and run ML applications on energy-efficient Arm platforms. The future of the embedded industry will continue to innovate, and the embedded market holds promise.

According to a professional with 15 years of experience on Zhihu, there’s no need to be overly pessimistic about embedded systems, nor should one be blindly optimistic. The definition of a promising future varies across different periods and individuals. He stated that factors influencing future development include platform, connections, goals, and opportunities. Gaining more project experience provides a foothold, having a broad network can yield help at critical moments, and having a goal allows focused development in a specific direction. He also mentioned not to get caught up in technical “dead ends.” If you can climb into management positions, do so; missing opportunities and age can lead to regret.

Additionally, some netizens pointed out that not only those in the highest-paying industries can live well; professionals in second, third, and fourth place can also enjoy quality lives, and those in the top ranks may not necessarily thrive. Every industry is influenced by opportunities and environments; even the best industries have people who struggle, while even the worst have those who quietly make significant profits. Moreover, times change, and circumstances evolve; for instance, the once-popular civil service is now gradually being looked down upon. Therefore, pursuing a strong interest is likely to lead to success.

Furthermore, the embedded field has its share of muddied waters. ARM once published an article titled “It’s not embedded that let you down; it’s you who let embedded down” (https://mp.weixin.qq.com/s/Xh1ks1mlQtSM29v7y2MvIg). Reports indicate that a netizen recently interviewed several hardware engineers with an average work experience of over three years, yet they couldn’t even identify a transistor or MOSFET, and they could even mix up the names of the three pins. Surprisingly, these individuals were asking for salaries of over 10K. The barrier is not high; the challenge is to truly excel in this field.

What does a promising future look like? Personal interest + effort level + seizing opportunities = future. If the only goal is to make ends meet, there’s no need to learn embedded systems; the entry barriers for embedded training are high, tuition is expensive, and there’s blatant discrimination against those with lower degrees and liberal arts backgrounds. Even if the training leads to an annual salary starting at 100,000, can those without a foundation or interest truly learn? If the goal is merely survival, there are countless opportunities in the world; why struggle?

According to a certain expert on Baidu Tieba, those entering the embedded field come from diverse backgrounds; some have computer science degrees, others electronics degrees, some are hardware engineers, and some are completely unrelated, with varying foundational knowledge. The paths in technical careers are also diverse; some end up in management, others transition to product management, some become technical sales, and a few become true technical experts. However, the ultimate goal for embedded engineers is to become true technical experts.

Embedded technology can be broadly divided into programming languages, core technologies, operating systems, bus interfaces, and system integration. Those attentive will notice that the CSDN forum has already reflected this division; aside from system integration, which is only slightly represented in the embedded systems section, other areas have clear corresponding sections. However, the learning path is not linear; based on years of observation, the engineer categorizes the technical range of embedded engineers into several levels:

1. Junior: 8051 or other microcontrollers, UCOS, I2C, SPI, UART. Assembly and C skills are average, and system integration ability is weak.

2. Intermediate: Building on junior skills, ARM/MIPS, various RTOS, and knowledge of Linux, SDIO, USB. Good assembly and C skills, with a certain level of system integration ability.

3. Senior: This level transcends merely mastering specific technologies; it involves grasping the fundamental ideas and compositions of currently popular technologies, making any trending technology easily manageable. Mastering the principles of all technologies also leads to strong system integration abilities.

For both junior and intermediate levels, there are clear benchmarks; at these stages, engineers are still entering the field, and evaluation standards often revolve around the technologies mastered. The highest realm of learning technology is mastering its composition and patterns. For instance, all interface technologies can be summarized into a few key points: simplex or duplex, how to initiate transmission, how to respond, how to report errors, how to correct errors, and how to establish advanced applications based on basic transmission. Once these are understood, interface technology becomes straightforward.

Recently, there’s a trend in the industry to program on certain platforms while neglecting in-depth technical research. Whether it’s Android or MTK’s Tune Key, you’re merely dancing to someone else’s tune without any real technical improvement. If a platform exits the market in five years, what will those skills be worth? Mastering technology requires solid foundations; many people, upon entering the field, first think about focusing on Linux and ARM application processors. However, do you understand process scheduling in Linux? This isn’t a trivial question; it’s a matter of understanding surface versus depth. According to technological development, one should start with RTOS like UCOS and gradually learn Linux, realizing that the basic concepts of Linux, such as system scheduling, semaphores, and events, are similar to those in UCOS.

Finally, let’s discuss practical matters. Currently, Linux and Android are in high demand, and many suggest starting with these popular technologies to earn money. While it’s true that quick learning can yield short-term benefits, in the long run, salaries will fluctuate around the mainstream engineer’s salary, and becoming a high-level expert is impossible without several years of solid work. However, those who persist will undoubtedly achieve greatness.

What Work is Involved in Learning Embedded Systems?

According to a 21IC forum post, the work can be divided into four categories:

1. System Design Work

During the system design phase, system analysts determine the basic hardware composition based on requirements, selecting processors, operating systems, and software development tools. System analysts typically participate comprehensively in the embedded system design process and have a good understanding of the industry applications of embedded systems.

2. Hardware Design Work

Hardware designers must create hardware schematics based on the results of the system analysts’ designs. Typically, hardware designers need to be familiar with the hardware composition of embedded systems. They should understand common embedded system processors, memory (Flash, SDRAM), Ethernet MAC chips, audio/video codec chips, power management chips, bus interface circuits (USB, PCI), LCD modules, programmable logic devices (FPGA/CPLD), and wireless communication modules (Bluetooth, WLAN, GPRS), among other hardware components. Numerous evaluation board schematics are available online; studying these schematics helps clarify the connections between processors, memory, network cards, LCD modules, etc. By researching these circuits, one can quickly grasp the overall composition of embedded systems. While there may be some differences between these circuits and those in actual products, especially for handheld devices, these differences do not hinder beginners from learning the basic components of embedded systems.

3.Driver Program and Operating System Porting Work

Modern embedded system development differs significantly from traditional 8-bit microcontroller systems, primarily due to the widespread use of embedded operating systems. After assembling and testing the circuit board, the next step is to port driver programs and operating systems. The first task is to write and port the Bootloader, akin to the BIOS in PC systems. Some embedded operating systems, like UC/OSII, can be developed and debugged without a Bootloader, but for WindowsCE and embedded Linux systems, a Bootloader is essential.

4.Application Development

Application development for embedded systems is not significantly different from developing applications on PCs. For Windows CE systems, Microsoft provides relatively complete development tools. Developers can use C# directly on PCs for application development and simulation debugging or connect the target system to a PC for online debugging. Many systems now support J2ME (the embedded version of JAVA), giving JAVA a significant advantage in embedded system application development. Additionally, as professional embedded system software developers, it’s crucial to understand object-oriented technology and design patterns, though beginners can initially avoid delving too deeply into these areas. Students should continuously explore knowledge during their embedded learning journey, and gradual learning will lead to significant progress.

Discussing PCB Design

Those in electronics, whether working with MCUs, ARM, DSP, or even other hybrid varieties, cannot avoid working with circuit boards. All components must be soldered onto appropriate circuit boards to function. PROTEL99, PADS, or DXP are commonly used software for designing complex boards, especially in the embedded field. Drawing PCB layouts isn’t difficult, but achieving precision is not easy, as it involves circuit schematic design and many wiring principles, such as trace size, spacing, and angles. Generally, MCU control boards are not very sensitive to these factors, but power supply boards, high-frequency boards, or RF communication boards require careful consideration of interference and anti-interference. For high-power applications, trace width is critical; insufficient copper thickness can lead to overheating and potentially cause board burnouts or component explosions. There are many considerations in this specialized hardware field, so continuous learning and practice are essential.

In summary: to excel in electronics, build a solid foundation in analog and digital electronics, learn programming languages, and then start hands-on practice. Analog and digital electronics serve as the foundation, while programming is the building material; you need to be the architect to construct it. Finally, I want to emphasize that technology is an endless abyss, and I am merely a nameless drop in the vast ocean of technology. All opinions and experiences shared here are my own summaries; they cannot be deemed entirely correct, but this is how I’ve navigated my journey.

Prospects and Current Status of Embedded Development

Currently, embedded development is leaning towards intelligence, which we refer to as smart hardware (hardware + software). This is evident from the various cutting-edge embedded products. A trend in embedded product development is a greater inclination towards automated control and human-machine interaction, rather than emphasizing algorithms. It’s essential to distinguish yourself as an embedded engineer rather than an algorithm engineer; terms like “artificial intelligence,” “AlphaGo,” “deep learning,” and “neural networks” don’t require deep understanding; those are the domains of graduate and doctoral students. The author doesn’t imply a lack of capability; rather, “specialization leads to excellence.” This is not the workload of an embedded engineer; instead, your job is merely to interface with the “cloud brain” and call their APIs. With the rise of advanced disciplines like artificial intelligence and big data, many question, “Does embedded still have prospects?” I can confidently state that “embedded has excellent prospects; cutting-edge embedded technologies are about to rise or have already risen.” Indeed, artificial intelligence and big data may impact embedded systems, and currently, fewer students are inclined towards embedded studies compared to previous years. However, a reduced number of scholars does not equate to decreased demand or declining salary levels; in fact, the current trend in embedded technology is towards integration with intelligent disciplines. For example, in the case of Baidu robots, the core of the robot is the brain, which consists of “data and algorithms.” However, for a robot’s brain to enable it to move like a human, speak, and walk freely, embedded technology is essential. This illustrates my point about the application of embedded systems combined with intelligent disciplines; in the long run, embedded systems will only grow in popularity, and the rise of intelligent disciplines will inevitably foster the development of new embedded technologies.

Comprehensive Skills for Embedded Development

A qualified embedded developer should be a jack-of-all-trades, possessing skills across various domains, including hardware, software, and applications (power system protection, automation, control, artificial intelligence, machine learning, etc.), from single-board to complete systems, from technical to management, and even a bit of performance art, which can enhance team dynamics and enrich personal life during project management.

The knowledge and skill system for embedded systems is vast, and true polymaths are rare; most are proficient in one area while having varying degrees of knowledge in others. Based on the hierarchical relationship of embedded development, here’s a comprehensive skill set for embedded developers:

1. Processors

MCU architecture and development. MCUs, commonly known as microcontrollers, reduce the frequency and specifications of central processing units (CPUs) and integrate memory (Memory), timers, USB, A/D converters, UART, PLC, DMA, and even LCD driver circuits into a single chip, forming a chip-level computer for various applications. Common MCUs include Intel’s C51/C8051F series, Motorola’s 68K series, MicroChip’s PIC series, etc.

MPU architecture and development. MPUs refer to microprocessor units, which typically do not include peripheral devices (like memory arrays) and are highly integrated general-purpose processors. Typical examples include Intel’s X86 series, Freescale’s PowerPC series, P1 series, and ARM architecture processors.

DSP architecture and development. DSPs use Harvard architecture, allowing multiple memory accesses within the same clock cycle. Multi-stage instruction execution pipelines enhance system execution efficiency. DSP chips are commonly used for complex computations, with typical examples being TI’s TMS CXX series, ADI’s SHARC series, and Blackfin series.

2. CPLD & FPGA Architecture and Development

CPLDs and FPGAs emerged as semi-custom circuits in the ASIC domain, addressing the limitations of custom circuits while overcoming the finite gate count of programmable devices. They implement various algorithms and combinational logic through programmable logic units.

Program development based on CPLD & FPGA. This includes RTL gate-level logic design, Verilog HDL programming, VHDL programming, XILINX compilation software use, ALTERA compilation software use, low-speed serial and parallel communication controller design, and high-speed serial communication controller design.

3. Circuit Design and Analysis

This encompasses both analog and digital circuit design, including reading device datasheets, schematics, and PCBs.

4. Schematic/PCB Design Tools

Cadence, Altium, PADS, DXP, etc.

5. Circuit Simulation Tool Usage

Multisim, Pspice, ADS, MATLAB, etc.

6. Principles and Selection of Discrete Electronic Components

Protection devices, passive components, inductors, DC/DC converters, oscillators, diodes, transistors, voltage regulators, opto-isolators, MOSFETs, IGBTs, relays, switches, and indicator LEDs, as well as PCB terminal blocks, and AC current transformers.

7. Principles and Selection of Integrated Electronic Components

AD, logic devices, DA, operational amplifiers, counters, flip-flops, latches, decoders, SRAM, SDRAM, DDR, FLASH, EEPROM, interface chips, etc.

8. Failure Analysis and Reliability

Material structure and principles, metallographic slicing, microscopic observation, PCB deformation measurement, HALT testing techniques, reliability calculations, etc.

9. Hardware Testing (Components, Modules, Systems)

Methods for testing components, modules, and systems, problem analysis for components, modules, and systems, understanding national and industry standards, EMC problem analysis and solutions, etc.

10. Operating System Architecture and Development Environment

Understanding operating system principles and basic compilation principles. Operating systems manage CPU resources, peripheral drivers, memory, thread/process management, file systems, network communication, security mechanisms, and interface management. The defining features of embedded real-time operating systems are rapid event response and determinism, widely applied in embedded systems.

Common operating systems include Windows, Unix, and Linux. Currently, widely used embedded operating systems include embedded real-time operating systems like µC/OS-II, embedded Linux, Windows Embedded, VxWorks, FreeRTOS, QNX, as well as Android and iOS used in smartphones and tablets.

11. Low-Level Driver Development

VxWorks driver development, Linux porting, Linux development, single-board DTS configuration, and root filesystem generation (Buildroot), U-BOOT porting and development, C language development, Python language development, Makefile writing, and usage of GNU compilers and toolchains, as well as Linux operating system usage.

This specifically includes Ethernet drivers, SPI drivers, I2C drivers, filesystem drivers, CAN drivers, etc.

12. System Software Design

Object-oriented programming, design patterns, UML, embedded multitasking development, refactoring, multicore development, etc. Familiarity with common development processes, such as agile programming and test-driven development.

13. System Software Development

Familiarity with programming languages, including C, C++, C#, QT, Python, JAVA, etc. Familiarity with web development and development standards.

14. Data Structures and Algorithms

Common data structures and algorithms, graph theory algorithms, digital signal processing algorithms, wavelet algorithms, etc.

15. Networking and Communication

Computer network principles, TCP/IP protocol principles and analysis, IEC61850 protocol (modeling, MMS, SV, GOOSE, etc.), 103 protocol, 104 protocol, DNP protocol, Modbus protocol, IoT Zigbee protocol, Bluetooth, Wireshark for packet analysis, ring network HSR protocol, network security, etc.

16. Databases

Database principles and design, SQLite/Access/MySQL/SQLServer/Oracle/big data Hadoop, etc.

17. Interface and Graphics Libraries

Zinc, UGL, QT, SVG, MiniGUI, etc.

18. Application Knowledge (Using Power System Automation as an Example)

Knowledge of power systems, relay protection knowledge, measurement and control knowledge; smart substation network architecture, network division, fault recording, protection, remote control, etc.

19. Debugging and Testing

Basics of software testing, IEC61850 protocol testing, network testing, time management testing, application functionality testing (such as relay protection functions), ATS testing development and usage, etc.

20. Project Management

Configuration management such as version control using Git, project planning and task allocation, project progress tracking, project coordination, etc.

In 2020, Two Must-Know Skills for Embedded Development Engineers

1. Programming Languages

When we talk about writing code that runs around hardware layers, the most frequently mentioned is C language. 25 years ago, transitioning from assembly language to C language was a slow process with high demand. If you want to enter the embedded programming field, C and C++ should still be your primary focus in 2020.

If you want to try embedded programming, you can start with the following:

• https://www.learn-c.org/

Learn-c.org is a personal project by Ron Reiter. Although it’s not directly related to embedded systems or hardware, it’s an excellent starting point for learning C language.

• Buy a Microcontroller

In my personal experience, hands-on practice is the best learning method. You can buy a microcontroller to interact with hardware and see actual results, which is what you should focus on. You can purchase popular processors like Arduino and start with a small project to truly understand how hardware works.

• Read Books and Documentation

Reading books and documentation is a crucial learning method. You can select books based on your chosen direction (embedded systems, firmware development, driver development, etc.).

Aside from C/C++, there aren’t any programming languages that have truly captured a significant market share in this field, but the following emerging languages are worth noting:

Rust

This year, I must prioritize learning Rust. Rumor has it that Rust is developed from C, and it will widely replace C in various application areas. Rust is rapidly developing in the embedded field. Comparing the number of questions related to C, Rust, and Assembly on StackOverflow, we can see that the number of questions about Rust surpassed those about Assembly in 2019, while C has declined slightly over the past few years.

Rust has several advantages over C, one of the most significant being memory safety. Medium has many articles discussing Rust; reading them will help you understand its advantages. Additionally, Rust can run on many microcontrollers, and this GitHub repository compiles a wealth of information (https://github.com/rust-embedded/awesome-embedded-rust).

If you want to learn Rust, I highly recommend visiting the Rust homepage (https://www.rust-lang.org/). This site provides a wealth of introductory documentation and tutorials. There’s also the book “The Rust Programming Language,” which is an excellent starting point. The Rust site offers specific guidelines for embedded applications (https://www.rust-lang.org/what/embedded), which can help you understand Rust programming on embedded devices.

Golang

Golang? Golang! The potential of Golang exceeds your imagination. Currently, it mainly operates in user space, replacing backend languages like Ruby or serving as user-space applications because it has excellent multi-processor support.

However, I believe Golang will gradually enter low-level programming. It’s currently being used in firmware development for bootloader development. As embedded devices continue to increase in RAM, ROM, and Flash capacity, it may eventually run on embedded devices. For every embedded system programmer, Golang is definitely worth a try, and those interested in firmware development must learn Golang.

2. Hardware

Aside from programming languages, there are also interesting trends in hardware design. The first thing I want to mention is RISC-V.

RISC-V

RISC-V is an open-source hardware instruction set architecture based on the principles of reduced instruction set computing, known as RISC. Unlike ARM, manufacturers can use RISC-V without paying licensing fees.

Most hardware for servers and consumers currently uses x86 architecture. I don’t think RISC-V will quickly gain market share in this segment, but it may find applications in several other markets. Embedded devices like routers and switches, as well as smartphone manufacturers or IoT devices, may switch to RISC-V architecture.

RISC-V circuit boards are already available on the market, although prices remain relatively high, they’re worth watching. For example, the SiFive HiFive Board on my desk.

big.LITTLE

Finally, I want to discuss the big.LITTLE architecture. Initially proposed by ARM, it combines low-power processors (LITTLE) with powerful, high-power (big) processors. Only one side is active at any given time. This architecture should better adapt to today’s dynamic computing demands.

This isn’t a new idea; ARM suggested it back in 2011. However, it seems that other manufacturers are eager to try big.LITTLE. Intel’s Lakefield heterogeneous processor previewed in 2019 also adopted the big.LITTLE architecture.