Comprehensive Learning Path for Embedded AI Engineers

Simply put, an embedded system consists of two parts: software and hardware. It is application-centered and can achieve software and hardware tailoring.

Software includes: specific business applications and operating systems (simple applications may not require an operating system);

Hardware includes: memory, signal processors, communication modules, etc.

In terms of technical implementation, embedded products are divided into two categories: one is simple, without operating system support; the other is complex, with operating system support.

Currently, the latter is the trend. The former can be divided into three layers from a programming implementation perspective: hardware layer, driver layer, application layer; the latter is divided into four layers: hardware layer, driver layer, system layer, application layer.

1. Basic Linux Operations:

Just knowing some basic operations is enough; there’s no need to learn every command in depth. You can search for them when needed.

The knowledge you need to master includes: environment setup; Linux directory structure; file types; basic directory operations, file operations, vim, ifconfig, ping, cd, cp, mv, mkdir, etc. The key command you must know is gcc; some simple shell scripts; writing Makefiles.

2. C Language:

If you can’t write code, it’s recommended not to learn Linux, otherwise, you will face bottlenecks later in your career. Learning C language must include C programming under Linux.

3. Data Structures:

Data structures are very important, but spending too much time on them is unnecessary. I personally suggest mastering a few basic sorting and searching algorithms; there’s no need to study every algorithm. You should be able to grasp common algorithms such as: bubble sort, direct insertion sort, quick sort, binary tree, etc. Operations on linked lists, including creation, addition, deletion, modification, and search.

4. Basic Stage Project:

At the basic stage, I strongly recommend doing a comprehensive project from scratch. Implement a simple “Phonebook Management Software” using linked lists, including addition, deletion, modification, searching, sorting, etc., to integrate all knowledge points.

1. File IO:

Master the POSIX API set: open, read, write, lseek, close, etc. Be proficient in writing a file copy functionality module output. Understand the concept of buffering.

2. Processes and Threads:

Master commonly used functions such as fork, exec family functions, pthread API; process creation and cleanup, the process of turning a .c source file into an executable program; crontab, at commands; inter-process communication: semaphores, message queues, shared memory, pipes, signals; thread creation, synchronization, mutexes; daemon processes; the concept of libraries, what dynamic and static libraries are, and how to create your own dynamic and static libraries.

3. Network Programming:

TCP/IP protocol layering and the function of each layer; you don’t need to study OSI, just know it; usage of socket API, TCP, UDP; setting socket attributes; C/S architecture; multi-process and multi-threaded server models; usage of packet capture tools; common network protocol analysis: ping, tftp, ftp, etc.; knowledge points in the advanced stage are very important. Even if you don’t do Linux C development in the future, having this foundation will give you a different perspective when learning Java or C++.

4. Advanced Project:

At this stage, you can choose a comprehensive project such as “Multi-threaded Chat Room,” implementing public chat, private chat, registration and login, sending files to each other, etc.

This stage of learning requires the use of a development board. It is recommended that beginners solidify the previous content before entering this stage. The choice of development board is crucial; the most important factor is the availability of materials! Do not buy boards without materials!

1. ARM:

ARM architecture, ARM modes, ARM instructions, addressing, exceptions, interrupts, exception vector tables, pseudo-instructions, mutual calls between C language and assembly code, inline assembly; development of bare-metal drivers for common peripherals such as LED, key, ADC, PWM, RTC, watchdog, I2C, SPI, etc. The content of this stage is very important for understanding the working principles of the entire computer software. Many mechanisms of the Linux kernel rely on assembly instructions, especially concepts like ARM working modes, addressing, exceptions, interrupts, and exception vector tables.

2. System Porting:

U-Boot porting, rootfs creation, kernel trimming and porting, USB, network card driver porting, U-Boot, Linux boot processes, and adding U-Boot commands. The content of this stage is frequently used by embedded engineers in actual projects. The porting steps will vary among different manufacturers, but the principles are basically the same. Mastering these operations is very necessary.

3. Linux Drivers:

Character device architecture, inode, cdev, file_operations, relationships between files; platform bus, device tree; synchronization and mutual exclusion mechanisms, spin locks, semaphores, mutexes, atomic operations; interrupts, bottom halves of interrupts; wait queues, implementation of poll; writing drivers for common devices such as keys, LEDs, GPIO, ADC, PWM, I2C, MPU6050; network devices: analysis of network card drivers, usage of netfilter; USB architecture. The learning of drivers mainly focuses on understanding the architecture and the principles of computer implementations, reviewing the kernel daily.

If you can learn to this extent, how to develop further does not need much explanation. You can delve into IoT, algorithms, or research Linux kernel optimization, etc. Each field can stand alone, and the income will not be low.