Differences Between Embedded Development and Microcontroller Development

Word Count: 6000 Practical Index: ⭐⭐⭐⭐⭐

This question is asked very frequently, and I personally agree with the following answer:

“Microcontrollers are now classified under embedded systems, but embedded systems have clear definitions. A system with a computer architecture is called an embedded system. A microcontroller is simply the CPU part of an embedded system. However, embedded systems are layered and independent, each having independent capabilities, which is something microcontrollers cannot possess. But with the development of the times, some boards called microcontrollers actually have the concept of system architecture, so the distinction is not very clear now. However, those who write code know that embedded generally refers to the lower levels of Linux/Unix systems (system/driver development), while application program development is relatively independent. Microcontroller development usually involves only one engineer, which is the most fundamental aspect of development. Once microcontroller development is separated, the cost of time becomes very high.”

Reading is beneficial, congratulations on making a little progress.

The following answer is sourced from the internet and is of high credibility, for your reference.💗

There is actually no standard definition to distinguish between microcontrollers and embedded systems. For developers who have experience with both, they each have their own definitions. Next, I will talk about my understanding and insights regarding these two concepts.

First, let’s clarify the concept. What is a microcontroller? A microcontroller is an integrated circuit chip that uses ultra-large-scale integration technology to integrate a central processing unit (CPU) with data processing capabilities, random access memory (RAM), read-only memory (ROM), various I/O ports, an interrupt system, timers/counters, etc. (which may also include display driver circuits, pulse width modulation circuits, analog multiplexers, A/D converters, etc.) into a small and complete microcomputer system on a silicon chip, widely used in industrial control. Since the 1980s, microcontrollers have evolved from 4-bit and 8-bit microcontrollers to the current 300M high-speed microcontrollers.

For example, the classic 51 series microcontroller, as shown in the figure below, looks like a rectangular chip the size of a thumb, with 40 pins, containing a logic operation unit. In fact, it is just a CPU.

Differences Between Embedded Development and Microcontroller Development

When I first encountered microcontrollers, I had a question: why are microcontrollers black and not of other colors? Later, I learned that it was due to material limitations.

For microcontrollers, a chip is everything. Other components, such as the minimum system for microcontrollers, are added to ensure the normal operation of the microcontroller, such as crystal oscillators, 5V power supplies, inductors, resistors, etc. Of course, the minimum system can only guarantee the normal operation of the microcontroller and cannot realize any applications based on the microcontroller.

To enable the microcontroller to realize applications, other peripherals must be added, such as buttons, LED lights, LED screens, buzzers, and various sensors. This is what many companies in the market are doing with microcontroller development boards.

In summary, a microcontroller is a single module that performs functions such as computation, logic control, and communication. It is indeed ‘single’ in nature. A DSP chip can also be considered a microcontroller. Although they are very powerful, their functions remain singular, primarily for data processing and logic.

So, what is embedded? Generally, embedded refers to embedded systems. An embedded system is a system that integrates application programs, operating systems, and computer hardware. It is application-centered, based on computer technology, and can be tailored in hardware and software, targeting applications that have special requirements for functionality, reliability, cost, size, power consumption, and operating environment. The IEEE (Institute of Electrical and Electronics Engineers) defines an embedded system as “a device used to control, monitor, or assist in the operation of machines and equipment.”

An embedded system is a specialized computer system that is part of a device or equipment. Usually, an embedded system is a control program stored in ROM on an embedded processor control board. In fact, all devices with digital interfaces, such as watches, microwaves, video recorders, and cars, use embedded systems. Some embedded systems also include operating systems, but most embedded systems implement the entire control logic with a single program. This is because embedded systems are generally used for industrial control, meaning that the control of peripherals is hardcoded and does not require human intervention, which also ensures the stability and reliability of the system.

We often hear job requirements for embedded software engineers or embedded hardware engineers, which means that embedded systems include both software and hardware. If you think about it carefully, since it already runs a system, it must have both software and BSP hardware. In other words, an embedded system is a combination of hardware and software, and the commonly accepted definition of an embedded system in China is: application-centered, based on computer technology, tailored hardware and software, suitable for specialized computer systems with strict requirements on functionality, reliability, cost, size, power consumption, etc.

Next, I will detail the hardware and software of embedded systems.

Hardware Layer:

The hardware layer includes embedded microprocessors, memory (SDRAM, ROM, Flash, etc.), general device interfaces, and I/O interfaces (A/D, D/A, I/O, etc.). By adding power circuits, clock circuits, and memory circuits to an embedded processor, an embedded core control module is formed. Both the operating system and application programs can be solidified in ROM.

The core is the microprocessor. Embedded processors differ from general computer CPUs. Most embedded microprocessors work in specifically designed systems. For example, companies like TI or Atmel have many processors with different positioning. Atmel’s SAM series is designed specifically for the Internet of Things, while AVR is widely used in the industrial sector due to its outstanding performance.

Embedded microprocessors come in various architectures. Even within the same architecture, they may have different clock frequencies and data bus widths, or integrate different peripherals and interfaces. According to incomplete statistics, there are over 1000 embedded microprocessors worldwide, with more than 30 series of architectures. The mainstream architectures include ARM, MIPS, PowerPC, x86, and SH, etc. However, unlike the global PC market, no single embedded microprocessor dominates the market. Just for 32-bit products, there are over 100 types of embedded microprocessors. The choice of embedded microprocessor depends on the specific application.

For example, ARM has various processor architectures, the most classic being the Cortex series, which belongs to the ARMv7 architecture. This was the latest instruction set architecture from ARM until 2010. The ARMv7 architecture defines three clearly defined series: the “A” series for cutting-edge operating systems and user applications based on virtual memory; the “R” series for real-time systems; and the “M” series for microcontrollers. The figure below shows the different positions of the Cortex series.

In the embedded field, ARM architecture processors occupy a significant market share, and ARM has become a renowned technology company, yet it does not produce any processors but only provides IP, demonstrating that top companies set standards. Other commonly used architectures include SPARC, PowerPC, etc.

Embedded systems interact with the outside world through certain types of general device interfaces, such as A/D, D/A, I/O, etc. Peripherals achieve the input/output functions of the microprocessor by connecting with other devices or sensors outside the chip. Each peripheral usually has a single function, which can be external to the chip or built into the chip. There are many types of peripherals, ranging from simple serial communication devices to very complex 802.11 wireless devices.

Common general device interfaces in embedded systems include A/D (analog-to-digital conversion interface), D/A (digital-to-analog conversion interface), and I/O interfaces such as RS-232 (serial communication interface), Ethernet, USB (universal serial bus interface), audio interfaces, VGA video output interfaces, I2C (field bus), SPI (serial peripheral interface), and IrDA (infrared interface), etc. This is actually similar to microcontrollers.

Software Layer:

This refers to the operating system, including the kernel and file system, as well as the higher-level application programs. Embedded operating systems are generally Linux or other Unix-like systems, along with real-time operating systems (RTOS) such as VxWorks, RTEMS, ucOS, etc.

Linux also includes different distributions, such as Ubuntu, Redhat, Debian, CentOS, etc. They all use the Linux kernel, but differ in the software and tools on top of it. Of course, there is no need to worry too much about standard issues; the software selected for these Linux distributions is generally quite universal, such as the web server Apache, email servers like Postfix, Sendmail, file servers like Samba, etc. Moreover, there are standards like the Linux Standard Base to regulate developers.

Unix-like systems mainly include FreeBSD and Solaris, etc.

In the embedded field, real-time operating systems are still the most commonly used. The core of real-time operating systems is real-time performance, which fundamentally refers to the predictability of task processing time, meaning tasks need to be completed within specified time limits. The IEEE defines real-time systems as “those where correctness depends not only on the logical result of the computation but also on the time taken to produce the result.” Real-time operating systems can be classified into hard real-time and soft real-time. Hard real-time systems must complete operations within specified time limits, which is guaranteed in the design of the operating system; soft real-time systems aim to complete operations as quickly as possible based on task priorities. The operating systems we commonly use can be transformed into real-time operating systems after certain modifications.

The differences between real-time operating systems and time-sharing operating systems like Linux are as follows:

(1) Multiplexing. Real-time information processing systems, like time-sharing systems, have multiplexing capabilities. The system serves multiple terminal users on a time-sharing basis; in contrast, real-time control systems primarily focus on frequently collecting multiple field information and controlling multiple objects or execution mechanisms.

(2) Independence. Real-time information processing systems, like time-sharing systems, have independence. Each terminal user’s service request to the time-sharing system is an independent operation that does not interfere with one another; in a real-time control system, the collection of information and control of objects are also independent of each other.

(3) Timeliness. The requirements for timeliness in real-time information systems are similar to those in time-sharing systems, both determined by acceptable waiting times; however, in real-time control systems, timeliness is determined by the required start and end times of the controlled objects, generally at the second, hundredth of a second, or even millisecond level, with some requiring less than 100 microseconds.

(4) Interactivity. Real-time information processing systems have interactivity, but here the interaction between humans and the system is limited to accessing certain specific dedicated service programs within the system. It does not provide services like data processing and resource sharing to terminal users like time-sharing systems do.

(5) Reliability. Time-sharing systems require system reliability, whereas real-time systems require high reliability. Any error can lead to significant economic losses or unpredictable catastrophic consequences. Therefore, multi-level fault tolerance measures are taken in real-time systems to ensure system safety and data integrity.

Due to their higher reliability and timeliness, embedded real-time operating systems are more widely used in industrial control, aerospace, military, and other fields. For example, the Mars rover launched by NASA in recent years uses the RTEMS real-time operating system.

Middleware:

The so-called middleware is the interface layer between the software layer and the hardware layer, which strictly speaking also belongs to the software layer. Developers generally refer to this layer as BSP, which is primarily responsible for providing hardware drivers, hardware configuration operations, and providing standard APIs to software developers. Developers working on middleware are usually called embedded driver engineers.

From this, it can be seen that embedded design cannot be separated from both hardware and software; one must understand the characteristics of the underlying hardware and how to drive it, as well as have knowledge of the operating system to write corresponding functional applications.

Therefore, to determine whether an operating system supports a certain chip or development board, one can check if the corresponding board support package is included in its source code.

The above is my understanding of embedded systems. Next, I will discuss what kind of hardware embedded systems should run on.

When it comes to embedded hardware or development boards, many people’s first impression is the Raspberry Pi, which is a microcomputer the size of a credit card. Despite its small appearance, it is powerful inside, capable of video and audio functions, and can be said to be “small but complete.” After the launch of the Raspberry Pi, many manufacturers have rushed to introduce similar products, such as the Banana Pi. Here, I will illustrate using the TI BeagleBone Black board, as shown in the figure below:

It can be seen that the size is similar to that of the Raspberry Pi, with peripherals including USB host and USB mini as well as a network card interface. The back also has an SD card slot and an HDMI interface. Next, let’s look at its performance parameters:

The table below compares the performance parameters of the BBB board and the Raspberry Pi:

The BeagleBone Black’s processor is a TI processor with a clock speed of 1GHz, based on the ARM Cortex-A8 architecture, with 512MB of DDR3 RAM and 2GB of storage. The supported operating systems include Ubuntu, Arch Linux, Android, etc. Peripherals include a USB host and a 100M network card.

The BBB’s processor uses the most popular ARMv7 instruction set in current embedded systems. Using a processor with a widely used instruction set allows for more software support. For example, some operating systems no longer support running on the ARMv6 instruction set, such as Ubuntu, which stopped supporting the ARMv6 instruction set in April 2012.

ARMv7 has another advantage over ARMv6 in that processors using ARMv7 have significantly stronger actual performance. There are many advantages of ARMv7 over ARMv6, such as significant improvements in achieving superscalar architecture, including SIMD operation instructions, and improved branch prediction algorithms, which greatly enhance certain performance metrics.

Final Summary:

The above are the performance parameters of a basic embedded core board. Compared to the performance parameters of microcontrollers mentioned above, microcontrollers generally have lower processing capabilities, with clock speeds mostly in the tens of MHz range, while embedded systems can easily exceed hundreds or thousands of MHz processing speeds. Additionally, microcontrollers lack the capability to process graphical interfaces, meaning the absence of GPUs makes it nearly impossible for microcontrollers to drive graphical interfaces; the storage space of microcontrollers is not at the same level as that of embedded processors, as microcontrollers typically have only a few kB of on-chip memory, and due to peripheral limitations, it is unlikely to significantly increase external storage. In contrast, embedded processors typically have hundreds of MB of RAM. This huge difference results in microcontrollers being unable to run operating systems, and even TCP/IP and USB protocol stacks cannot run on them. Some high-end microcontrollers, such as ST’s STM32 series, may run lightweight OS and embedded network protocol stacks like lwIP. The rich and powerful performance of embedded processors allows them to accomplish many applications that microcontrollers cannot, such as network communication functions and video transmission processing functions. When external storage increases, embedded processors can easily run various Linux systems and graphical GUI interfaces.

In terms of development methods, there are also significant differences between microcontroller and embedded development, specifically in the compilation process. Microcontroller development primarily occurs in Windows and other graphical interfaces, with many mature IDE tools available, such as Keil, IAR, and TI’s CCS. These toolsets integrate compilation, assembly, linking, and simulation, and since development occurs in Windows, they have user-friendly interfaces, allowing developers to write C code, click compile and link buttons, and debug or simulate errors, making it quite easy to get started. In contrast, embedded development generally occurs in Linux, where C code must be compiled on the host and then burned into the development board via system images or U-Boot. Since the processor architecture of the host is x86 while the written code is meant to run on ARM or SPARC architecture processors, there is an installation of a cross-compilation chain. Furthermore, Linux lacks the IDEs found in Windows, meaning that compilation and linking of source code must be completed by the developer, typically using GNU Make scripts to write Makefiles and configure files. The Makefile specifies how to compile C or H files, including compilation rules and dependency files. All of these must be completed by the developer, and the entire process is done in the Linux terminal, which adds to the difficulty of embedded development.

🙋♂️Today’s Interaction

Which do you think is harder, embedded development or microcontroller development? Feel free to share in the comments below Differences Between Embedded Development and Microcontroller Development

Disclaimer: The material for this article is sourced from the internet, and the copyright belongs to the original author. If there are any copyright issues, please contact me for removal.

《Technical Sharing | Development of an Automatic Tracking Car Based on STM32》

《Is Embedded Qt Worth Learning? Which Qt Development Method is Easy to Start?》

《Will There Be More or Fewer Embedded Jobs in the Future?》

View

Related posts

Leave a Comment Cancel reply