Shenzhen ChengRong Technology Co.,Ltd. , https://www.laptopstandsupplier.com
Embedded system knowledge system explanation
Learning embedded systems with a microcontroller (MCU) as the core can open up a world of opportunities. These systems are widely applied in two main areas: the intelligentization of electronic systems (such as industrial control, modern agriculture, home appliances, automotive electronics, measurement systems, data acquisition, etc.) and the extension of computer applications (like MP3 players, mobile phones, communications, networks, computer peripherals, etc.). To design an MCU-centered embedded system application product, you'll need knowledge spanning hardware, software, and industry-specific expertise. On the hardware side, this includes the MCU's minimum system, input/output peripheral circuits, and human-machine interface design. Software-wise, you’ll focus on firmware development and might also involve PC software. Industry knowledge comes from collaboration, communication, and summarizing experiences.
In short, mastering an embedded system with an MCU at its heart requires a solid foundation in both software and hardware, along with practical training. Here are the essential aspects:
1. **Hardware Minimum System**: Power supply, crystal oscillator, reset circuit, and debug interface.
2. **General Purpose I/O**: Digital input/output, handling binary value detection and control.
3. **Analog/Digital Conversion**: Acquiring and processing sensor signals like infrared, temperature, light, ultrasonic, and direction.
4. **Digital/Analog Conversion**: Using analog numbers for analog device control.
5. **Communication**: Serial Communication Interface (SCI), Serial Peripheral Interface (SPI), Inter-Integrated Circuit (I2C), Controller Area Network (CAN), Universal Serial Bus (USB), embedded Ethernet, ZigBee technology, etc.
6. **Display**: LED, LCD, etc.
7. **Control**: Control various devices using techniques like Pulse Width Modulation (PWM).
8. **Data Processing**: Processing or recognizing graphics, images, voice, video, etc.
9. **Specific Applications**: Various targeted applications.
All of this falls under these categories, and the hardware design, software design, and testing must adhere to the methods, principles, and fundamental rules of embedded software engineering. Thus, embedded software engineering is a crucial part of the embedded system knowledge system, though it’s integrated into the development process of specific projects.
The knowledge system covers hardware basics, software foundations, and relevant domain knowledge. Programming languages, operating systems, and development environments are tools to achieve these goals. Beginners sometimes confuse tool usage with the ultimate learning objective. For instance, some learners focus on transplanting embedded operating systems for extended periods without actually developing embedded system products. Eventually, they struggle to handle even simple embedded system tasks, losing sight of their learning goals and potentially abandoning the field entirely. This represents a common misunderstanding in embedded system learning, which we’ll explore further.
### Common Misunderstandings in Embedded Systems Learning
Learning approaches for embedded systems may vary depending on personal learning experiences, environments, objectives, and prior knowledge. However, it’s important to distinguish between essential foundational knowledge, what should be learned first versus later, and which skills require practical experience. Additionally, some knowledge applies universally across chips, while other knowledge is specific to particular chips or development environments.
Due to the vast array of microprocessors and microcontrollers, and possibly misleading marketing tactics from some companies or organizations for their own benefit, understanding embedded microcontrollers in China can be confusing. This has led some beginners to fall into learning traps, wasting precious time. Let’s examine a few potential pitfalls.
#### 2.1 Confusion About Operating Systems
If the goal isn’t to develop application products, then there’s no clear learning objective, making the approach irrelevant. Many people struggle to begin learning embedded systems because they lack clarity on their goals. They might pick up random books, attend trainings, or search online without knowing where to start. Those with prior computer experience often begin by learning an embedded operating system, akin to touching only one side of an elephant. How can one grasp the entire embedded product development process?
For many beginners, starting with an “XXX embedded operating system + XXX processor†learning model is inappropriate. Instead, it’s suggested to first lay the groundwork in embedded system hardware and software before choosing a real-time operating system (RTOS) for practical learning based on real-world needs. Remember, RTOS is a tool for certain types of embedded products, not the end goal. Many embedded products don’t require an RTOS. Starting with RTOS doesn’t align with the learning progression from simple to complex.
Given the variety of RTOS options, the choice typically depends on the work environment. The primary focus during the foundational stage should be understanding RTOS principles and software development methods, not designing an RTOS. Those aiming to develop practical embedded products shouldn’t invest excessive energy in RTOS design or porting. Just as many people use Windows without designing it, learning RTOS without practical use can be a waste of time.
#### 2.2 Hardware vs. Software Confusion
The embedded system knowledge system with an MCU at its core must be practiced through specific MCUs. However, choosing any MCU means that chip-specific knowledge constitutes only about 20% of the knowledge system, with the remaining 80% being general software, hardware, and domain knowledge. This 80% must be acquired through practical experience, so it’s recommended to start with a series of MCUs.
Whether to focus on software or hardware first depends on the entry point and balancing the two. To become a true embedded system designer, it’s essential to lay the hardware and software foundation early on. John Catsoulis, an American scholar with over 20 years of embedded system design experience, emphasizes in his book *Designing Embedded Hardware* that embedded systems are a blend of hardware and software. Without understanding hardware, writing embedded software is impossible, and without software knowledge, designing hardware is equally challenging.
#### 2.3 One-Sided Understanding of Embedded Systems
Embedded systems encompass a wide range of products and diverse application fields. Broadly speaking, they include intelligentizing electronic systems and extending computer applications. Beginners may misunderstand embedded systems from either of these perspectives. Some learners focusing on intelligent electronic systems might neglect programming structures, standards, software engineering requirements, and operating systems. Others approaching embedded systems from a computer application perspective might mistakenly apply general computing concepts to embedded practice, ignoring the differences between the two.
At the beginner level, it’s critical to understand the unique characteristics of embedded systems and tailor learning plans to your current knowledge base. The goal should be to build a solid hardware and software foundation for embedded systems, establishing a basic knowledge framework through practice. While specific application systems can serve as practical carriers, they shouldn’t limit learning to just one system—some abstraction and generalization are needed. For instance, beginners shouldn’t dismiss learning real-time operating systems (RTOS) when developing control systems, but they shouldn’t assume every embedded system requires one either. Understanding RTOS principles through examples is beneficial, but beginners shouldn’t assume RTOS is always necessary, even for simple systems. Analyzing real-world problems and solving them according to project needs is a long-term learning journey, not something achievable through short-term training.
#### 2.4 Chip Selection Puzzle
Most beginners need to select an MCU for entry-level learning. Facing the multitude of MCU options from various manufacturers, many are unsure of how to proceed.
First, consider the bit count: 8-bit, 16-bit, and 32-bit MCUs each have distinct application domains. For tasks like remote controls, a 32-bit MCU would be unnecessarily costly. Beginners should choose a chip based on their knowledge base. It’s recommended for most beginners to start with an 8-bit MCU to quickly grasp assembly and low-level hardware knowledge, then progress to 16-bit or 32-bit chips.
A common misunderstanding about chip selection is believing there’s a single “mainstream chip.†Embedded systems don’t experience chip monopolies. Another misconception is thinking higher-frequency chips are more advanced for entry-level learning, which can pose challenges for beginners.
Real-world embedded system design focuses on stability, reliability, maintainability, upgrades, power consumption, and cost—not just chip bit count or operating frequency. When selecting an entry-level chip, beginners should prioritize one that serves as a foundation for the embedded system knowledge system: shorter learning curve, lower hardware costs, more knowledge elements, and lower difficulty.
### Basic Stage Learning Suggestions
Based on the above discussions, here are some basic-stage learning recommendations for those eager to learn embedded systems:
1. **Hardware and Software Integration**: Embedded system software and hardware are inseparable. Anyone, even non-technical students, can learn embedded systems with the right approach and dedication. Look into Zhu Youpeng’s videos for inspiration.
2. **Chip and Evaluation Board Selection**: Start with a simpler chip like an 8-bit MCU. Choose a good evaluation board (below 1,000 yuan), a reliable book (preferably with standard examples), and a supportive teacher. Practical hardware spending should be minimal, as embedded systems are highly practical. A good book prevents detours, and a skilled teacher accelerates learning.
3. **Overcome Fear of Hardware**: Embedded hardware is simpler than general electronics. Understanding concepts like the MCU minimum system, I/O ports, serial communication, keyboards, LEDs, LCDs, SPI, I2C, PWM, A/D (including sensors), and D/A is key. Writing drivers for individual hardware modules is essential. Early on, this hands-on process is unavoidable.
4. **Avoid Learning RTOS from the Start**: Learning RTOS prematurely can lead to detours and fear of embedded systems. Once your software and hardware foundation is strong, understanding RTOS becomes easier. Many embedded applications don’t require an RTOS. Learn one based on project needs when necessary.
5. **Avoid One-Sided Thinking**: Don’t view embedded systems purely from an electronics or computer software perspective. Gradually understand the MCU’s minimum system, hardware principles, and low-level driver programming. Through standardized examples, grasp software engineering concepts like modularity and reusability.
6. **Focus on Experiments and Practice**: Repetition-based experiments help verify others’ work and learn fundamentals. Personalized practice with specific “products†as goals is crucial. Building a stable small system with certain functions for over a year signifies progress.
7. **Entry-Level Chip Selection**: Avoid overly complex chips. Focus on one chip initially, gain practical experience, and choose a chip suited for actual product development later. Differentiate between microprocessors (MPUs) and microcontrollers (MCUs).
8. **Embedded OS Choice**: Wait until you’ve built some practical skills before selecting a simple, understandable RTOS. Don’t start with multiple OSes; learn their basics when real-world needs arise.
9. **Assembly vs. C Language**: Modern MCUs support C compilation, so focus on understanding chip initialization, interrupts, and memory usage rather than mastering assembly. For testing purposes, learn a PC programming language.
10. **Clarify Goals and Methods**: Determine if learning aims to build a foundation or prepare for immediate work. Balance theory and practice, general knowledge with chip-specific knowledge, and hardware with software. Grasp hardware components and software engineering principles.
This is just a beginner’s learning guide. Becoming a proficient embedded system designer requires continuous project experience and ongoing learning.