Note:
The following learning path is based on my personal experience and that of my peers during the autumn recruitment for embedded positions (exclusive tips).
It mainly targets embedded software, Linux, and driver positions, and mastering it can help you compete with chip manufacturers, host manufacturers, and large companies!
Compared to other comprehensive embedded learning paths, this article focuses on the key points, core, and concise content for embedded interviews. (No fluff, all practical content)
Core Knowledge Points in Embedded Systems
—-Fundamentals——
Programming Language: C MCU Experience: STM32 Operating Systems: FreeRTOS/ucOS Linux Driver Experience: Bare-metal peripherals/Linux drivers
—-Additional Skills (Not Required)—— 1. Education: It is recommended for undergraduates to consider graduate studies. 2. C++ 3. Data Structures 4. ARM Architecture 5. Computer Networks
Everyone needs to have a clear goal, which is to learn for campus recruitment. Generally speaking, the complete video tutorials we see, such as STM32, C language, Linux drivers, etc., do not need to be fully learned before going for an interview!
What you need to do is to master the basic knowledge points, then reflect them in your resume projects, allowing the interviewer to assess your abilities within twenty to thirty minutes through detailed questions.
Below, I will specifically outline each part.
Long article warning, it is recommended to save!
To practice this skill, you must be patient!
1. C Language
The most commonly used language in embedded positions is C, which is lower-level than assembly and higher-level than application layer C++. C is the core.
The assessment of C during interviews includes the following:
Pointers: single-level/double-level pointers, pointer arrays, array pointers, pointer functions, function pointers Arrays: one-dimensional/two-dimensional arrays, sorting, etc. Strings Keywords: #define, assert, const, static, volatile, extern, sizeof, typedef, etc. Functions: strlen, strcmp, strstr, memcpy, sprintf, etc. Memory: heap, stack, memory allocation malloc/free, endianness Variables: variable types/byte size, local/global/static variables, formal/actual parameters Structures: structs, unions, enums
The above content is not complete, but it covers the basic knowledge points. If these are your first time encountering the knowledge points, I recommend checking out Bilibili or CSDN and then trying it out yourself. When practicing C language, I personally recommend using the VSCode environment, as it is very convenient with plugins. The interviewers will not ask all of the above content, so it is best to prepare more. Below are some videos I previously watched, which you can refer to based on the above content:
You can also watch videos from other sources, but during the learning phase, it is essential to write code yourself to deepen your understanding.
2. STM32
Most embedded learning paths include microcontroller content, and STM32 is written here because it is more mainstream, and there is more learning material available. There are many types of microcontrollers, such as Arduino, ESP32, and various domestic MCUs. If you know others, you can write them on your resume instead of STM32. Most of these are based on ARM architecture MCUs. In fact, the interviewer may not have used STM32 themselves, but they will ask some common hardware questions about this type of microcontroller.
If you are an undergraduate with no foundation, to lower the difficulty, you can start learning from the 51 series, or you can follow the videos directly to learn the 32 series. For STM32, you do not need to finish learning the F1 series before going to the F4 series. In fact, the smallest C8T6 development board can teach you a lot. Here are the questioning points for this microcontroller part:
The process from the microcontroller startup to entering the main function Microcontroller interrupt mechanism, interrupt vector table, interrupt functions (more detailed questions include how to protect the interrupt context, how the PC pointer moves) Timer, output PWM IO port input/output modes Serial communication, I2C, SPI protocols; STM32 generally supports hardware I2C and hardware SPI, so you need to master the timing of these communication protocols Watchdog
If you have limited projects to write on your resume, especially lacking Linux projects, you can supplement with some STM32 microcontroller projects. The above content is just the basics of STM32. If you have time later to learn Linux drivers, then learning these points for STM32 is sufficient, as the Linux driver tutorials will involve more underlying knowledge of MCUs, resulting in some overlap in content.
Of course, many experts can find good jobs even without learning Linux, as some companies’ chips or products do not run operating systems. However, this will focus on assessing your mastery of microcontrollers, such as mastering LCD drivers, high-speed USB protocols, and DDR drivers, which will impress interviewers when listed on your resume.
When learning STM32, do not pursue memorizing every part of the content completely; just know the basic process and be able to copy it.
Video recommendations:
Many people recommend the videos from Jiangxi University of Science and Technology, and the accompanying example code from Zhen Dian Yuan Zi is very comprehensive. If you want to learn, develop directly based on library functions, and do not use the register version.
There is actually another part of knowledge that many people ask about whether embedded systems require analog and digital electronics. There is no need to spend extra time learning this, as common microcontroller circuits and other peripheral circuits can be found online. Interviews generally do not focus on these questions, but I have encountered questions about whether one can use an oscilloscope and troubleshoot hardware circuits. I recommend that everyone take the time to make a minimal STM32 system board, and you can directly get a PCB from Jialichuang!
3. FreeRTOS/ucOS Linux
Here, FreeRTOS/ucOS is listed alongside Linux because they are both operating systems. In some MCU platforms with limited hardware resources, such as Cortex-M architecture STM32-F1 series microcontrollers, which do not support MMU and cannot run Linux systems, they can run lightweight FreeRTOS/ucOS real-time operating systems.
Some chips that need to handle complex tasks usually rely on operating systems for multi-threading/multi-processing task scheduling to improve the system’s real-time response capability. During campus recruitment, some companies will specifically note that the position requires the use of FreeRTOS or ucOS. These two real-time operating systems are somewhat similar, and you only need to learn one of them. If you plan to learn Linux later, then you can skip these two. The concept of “multitasking” is used in FreeRTOS/ucOS, where tasks can synchronize with each other using semaphores. Generally, it is not required to fully master these systems; a basic understanding is enough. The benefit of learning FreeRTOS/ucOS is that if you do not know Linux, you can add FreeRTOS/ucOS to your microcontroller projects to increase project complexity.
For Linux, multi-threading and multi-processing actually belong to application development content, but it is still essential to know the basic concepts. The key points include:
Concepts and differences between processes and threads Synchronization methods for processes and threads Concept of locks: mutex, spinlock, etc. fork, clone Creating daemon processes User space, kernel space
This part of the content is likely to be questioned when applying for embedded Linux driver development engineer positions. I have not watched much about Linux applications, but I recommend Zhen Dian Yuan Zi’s videos. You can also check out other sources like Wei Dongshan.
It is recommended to directly look at the following two PDFs, which will help you understand the basic concepts. If needed, you can contact me privately.
1.——————
2.—————–
4. Bare-metal peripherals/Linux drivers
This part is crucial because during campus recruitment, many embedded positions require knowledge of Linux or are specifically for Linux driver development engineers. You can check Bilibili; in recent years, videos from Zhen Dian Yuan Zi or Wei Dongshan on Linux driver development have had high viewership. Earlier videos were generally based on the NXP i.MX6ULL chip, while newer ones are based on STM32MP157, and some niche boards like Rockchip also run Linux systems, along with Allwinner Technology boards. From my own experience, learning Linux driver content can open up more job opportunities!
For driver development positions, there are those who do bare-metal development and those who do Linux driver development. The existing video tutorials typically start from bare-metal low-level registers, and Linux drivers can be understood as writing low-level code under the Linux environment and framework. I personally have not completed all of this content, but I successfully handled an interview after working on a project. Here are some key interview points for Linux drivers:
U-Boot, kernel, root filesystem porting Cross-compilation Basic shell commands Basic usage of Ubuntu Character device framework I/O subsystem I2C bus, platform bus, etc. Device tree, how drivers and devices match Block device framework
Regarding learning Linux drivers, I recommend that everyone draw block diagrams and structural diagrams for better organization. You must know how to write the typical character device framework and how devices and drivers match. I still have not completed this part of the content. For U-Boot and kernel porting, you can follow tutorials to practice multiple times, as there are many details involved. During campus recruitment, if you can master the first eight points, it is okay not to study block device drivers; there are many questions the interviewer can ask you.
For driver content, I recommend Wei Dongshan or Zhen Dian Yuan Zi’s videos.
5. Advanced
For the first four parts, you can study according to the key points I listed, mastering the core knowledge before learning peripheral knowledge points.
When looking for a job, in addition to embedded knowledge points, there are other influencing factors, such as education and programming ability assessment.
First is education. For undergraduate students, I strongly recommend considering graduate studies. In recent years, Java and other internet positions have become less easy to find, leading to increased competition in embedded systems. It is advisable to aim for better schools for graduate studies to enhance your education. I have encountered real situations where many companies offer different salaries based on whether candidates are from 985, 211, or non-985/211 schools.
Next is the assessment of programming ability. Embedded engineers are also programmers. Major companies typically require coding tests, and failing to achieve a sufficient score can lead to elimination. A typical example is Huawei, which has a coding test with three questions worth 600 points in two hours, where a score above 100 is required to qualify for an interview. If you go in without preparation, it is challenging to score above 100. The preparation referred to here means regularly practicing coding problems, such as on LeetCode, and being able to handle basic input/output, as well as common sorting, binary trees, linked lists, and data structures, along with depth-first/breadth-first search algorithms.
Generally, small and medium-sized companies may not have written tests for embedded positions, but major companies usually do, such as Xiaomi, Oppo, Huawei, Meituan, Nio, DJI, Vivo, Hikvision, Dahua, ByteDance, etc. My suggestion for learning data structures is to grasp the basic concepts first, and then maintain a routine of solving one or two problems daily. Embedded systems do not require complete mastery of data structures, but scoring high on coding tests is advantageous when interviewing at major companies.
Finally, if you want to aim for major companies during campus recruitment, I recommend learning some basics of C++, as using C for algorithm problems can sometimes be cumbersome, making unnecessary repetitive efforts. C++ provides very convenient container classes.
The above content generally covers the knowledge range for embedded interviews. Of course, during interviews, the interviewer’s questions are more based on your resume projects. Therefore, you should learn the foundational knowledge while also working on projects that can be included in your resume or seek internship opportunities.
There may be some shortcomings in the above content. If you have any questions, feel free to discuss them in the WeChat group. Students who have not joined the group can add my WeChat below to get added.
The road is long and difficult, but we will reach it if we keep going. Keep it up, my friend!
