Essential Learning Path for Embedded AI Engineers

In simple terms, an embedded system consists of both software and hardware, centered around specific applications, allowing for tailored software and hardware.

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 main categories: one type is simple, without operating system support; the other type is complex, with an operating system.

Currently, the latter is the trend. The former can be divided into three layers from a programming 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:

You only need to know some basic operations; there’s no need to delve deep into every command; you can search for it when needed.

Knowledge 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 is to be able to use the gcc command; some simple shell scripts; writing Makefiles.

2. C Language:

If you can’t write code, it’s advisable not to learn Linux; otherwise, you will hit a bottleneck in your career later. Learning C language must be paired with C programming on Linux.

3. Data Structures:

Data structures are very important, but spending too much time on them is unnecessary. Personally, I suggest mastering a few basic sorting and searching algorithms; there’s no need to study every algorithm. You should be able to master common algorithms such as: bubble sort, direct insertion sort, quick sort, binary trees, etc. Linked list operations, create, add, delete, modify, query.

4. Basic Stage Project:

During the basic stage, I strongly recommend doing a comprehensive project from scratch. Implement a simple “Phonebook Management Software” using linked lists, including add, delete, modify, query, sorting operations, integrating all knowledge points.

1. File IO:

Master the set of POSIX APIs: open, read, write, lseek, close, etc. Be able to write a file copy functionality module. Understand the concept of buffering.

2. Processes and Threads:

Master commonly used functions such as fork, exec family functions, pthread APIs; process creation and recycling, 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 and mutual exclusion, mutex locks; daemon processes; concepts of libraries, what are dynamic and static libraries, how to create dynamic and static libraries.

3. Network Programming:

Understand the layers of the TCP/IP protocol and the functions of each layer; no need to study OSI, just be aware; usage of socket APIs, TCP, UDP; setting socket attributes; C/S architecture; multi-process, 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 later, having this foundation will give you a different perspective when you learn Java or C++.

4. Advanced Project:

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

This stage of learning requires a development board; it is recommended that beginners solidify the previous content before entering this stage. The choice of development board is crucial; boards without documentation should not be purchased!

1. ARM:

ARM architecture, ARM modes, ARM instructions, addressing, exceptions, interrupts, exception vector tables, pseudo-instructions, inter-calling between C language and assembly code, inline assembly; bare-metal driver development for common peripherals such as LED, key, ADC, PWM, RTC, watchdog, I2C, SPI, etc. The content at 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 the concepts of ARM operating 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 startup process, adding U-Boot commands yourself. The content at this stage will often be used by embedded engineers in actual projects. The porting steps of different manufacturers may vary, but the principles are generally the same, and it is essential to master these operations skillfully.

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: network card driver analysis, usage of netfilter; USB architecture. The study of drivers mainly involves understanding architectures and gaining insights into the implementation principles of computers; read the kernel every day.

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