Embedded systems are computer systems running on microcontrollers or microprocessors with built-in software designed to perform specific tasks or functions.

Embedded systems can be customized and optimized to provide the functionality to specific hardware and applications with the stability of a complete operating system. However, they are typically resource-constrained, with limited processing power, memory, and storage. Therefore, they are designed with specific components and software tailored to requirements.

An embedded system is designed to operate in a compact form factor. It is commonly utilized in various applications, including consumer electronics, industrial automation systems, medical equipment, automotive systems, and more.

These systems are specifically designed for real-time processing applications that require a combination of low power consumption, high reliability, and efficient computing performance. As such, embedded systems are optimized for various use cases and can be found in many different settings where specialized computing solutions are required.

Embedded Linux is an open-source operating system designed to run on embedded systems. It’s a lightweight version of the Linux operating system that offers a stable, reliable, and secure operating system supported by a large community of developers.

Embedded Linux, often referred to as a “kernel” or “embedded Linux kernel,” allows for customization by including only the essential components needed to optimize the embedded system for specific hardware or applications, resulting in a more compact operating system.

These components are typically hardware drivers, memory management systems, scheduling algorithms, and file systems that provide the basic services to function and support the applications running on the embedded system.

Finally, the embedded Linux kernel is a smaller and more efficient operating system, with less code to maintain, lower power consumption, faster boot times, and reduced system overhead.

Embedded development is the process of designing, developing, and testing custom software and hardware solutions for embedded systems.

Embedded system development is a specialized branch of software engineering that encompasses electrical engineering, computer science, and software development. This field demands a broad range of technical skills to address the distinct challenges of hardware and software components.

A thorough comprehension of hardware components, electronic concepts, and communication protocols is essential in this field. IoT developers need to be well-versed in microcontrollers such as ARM Cortex-M, MSP430, AVR, and PIC, as well as microprocessors like ARM Cortex-A and Intel x86.

Embedded development entails creating software and hardware architectures under stringent low-power limitations, necessitating expertise in low-power design principles and techniques to guarantee system efficiency and minimal resource consumption.

Embedded system development requires proficiency in programming languages such as C and C++ and familiarity with Rust and Assembly. This expertise facilitates the creation of low-level code for diverse tasks, encompassing firmware development, memory management, bit manipulation, and register-level programming.

Embedded development frequently involves real-time systems where tasks must be executed within strict deadlines. As a result, it is crucial to possess knowledge of real-time operating systems (RTOS), particularly FreeRTOS, and understand task scheduling and concurrency management.

In addition to the core competencies, embedded developers should possess a strong understanding of communication protocols such as SPI, I2C, UART, CAN, and Ethernet. Furthermore, they should be well-versed in power management techniques, hardware description languages, and PCB design/layout tools like KiCad, Eagle, and Altium. A solid grasp of electronic concepts, debugging tools (including JTAG, SWD, in-circuit emulators, and oscilloscopes), testing methodologies, and version control systems (VCS) is crucial for success in this field.

As previously discussed, developers need to comprehend hardware components and electronic concepts. Therefore, to design embedded systems, IoT developers analyze target microcontroller (MCU) datasheets, considering various aspects such as:

• Device Specifications: Understand processing capabilities, power consumption, memory size, and supported voltage levels.
• Peripheral Features: Description of peripherals and features to use and configure to exploit the full capabilities (I2C, SPI, UARTs, GPIOs, ADCs, timers, and PWM modules).
• Pin Assignment: Pin diagrams and descriptions of its functions, input/output, power, and other functions are critical for configuring pins correctly and avoiding incorrect connections.
• Electrical Characteristics: Outline the MCU electrical characteristics (current consumption, operating voltage, and maximum ratings for current and voltage) for designing the power supply and ensuring interfaces between components.
• Clock Configuration: Understanding information on clock options enables developers to configure a clock system for optimal power consumption and performance.
• Register Description: Information about MCU registers, functions, and how to program is essential for creating low-level code to control peripherals and features.
• Interrupt Handling: Understand the interrupt system, interrupt sources, vector tables, and handling procedures to design a responsive system (from external events and internal conditions).
• Communication Protocols: Information about supported communication protocols and implementation details are required to create microcontrollers, sensors, and actuator interfaces.
• Debugging Interfaces: Information about debugging and programming interfaces (JTAG or SWD) is essential for setting up dev tools and debugging during the embedded development process.

A Linux Board Support Package (BSP) comprises software components, drivers, and configurations that enable the Embedded Linux operating system to run on a specific platform, ensuring seamless interaction and control of hardware components.

The Linux BSP includes a bootloader to initialize the hardware, set up memory, and load the kernel. It also features a configured Linux Kernel tailored to the specific platform. The embedded Linux kernel manages system resources, handles devices, and ensures effective communication between hardware and kernel by including drivers designed for specific hardware components.

A root filesystem within the Linux BSP contains utilities, libraries, and applications required to operate Linux on the target hardware platform. This filesystem can be based on the Debian Linux distribution or Yocto Project Linux, a build system that provides a framework and tools.

The BSP offers documentation on building the bootloader, kernel, and filesystem and deploying and using the target Linux distribution on the target platform. Configuration files and scripts included in the BSP set up the software and hardware environment, encompassing kernel configuration files and scripts for building and deploying the BSP. Although not a real-time operating system, it can be configured for real-time capabilities.

Utilizing a Linux BSP when designing embedded systems ensures seamless integration with the Linux operating system and the target hardware platform, providing necessary hardware-specific configurations, drivers, and software components.

When employing a Linux BSP, a custom Linux-based operating system tailored to your specific embedded system and hardware platform is typically used, which can be created with tools like the Yocto Project.

Consult an IoT expert about available options for your specific IoT use case. Linux BSP is generally suitable for complex, feature-rich operating systems that support numerous libraries, applications, protocols, and compatibility with various software stacks, frameworks, and hardware platforms with sufficient resources (memory, processing power, storage, etc.).

FreeRTOS is an open-source real-time operating system specifically designed for resource-limited systems, offering modularity and high portability across multiple platforms. Widely adopted across various industries, FreeRTOS boasts extensive documentation and strong community support.

FreeRTOS boasts a rich feature set that includes task management, memory management, inter-task communication, timers, and synchronization primitives. Additionally, it provides flexible scheduling options, such as preemptive, cooperative, and hybrid scheduling, to ensure optimal performance and responsiveness.

FreeRTOS serves as a lightweight real-time operating system ideal for projects with minimal memory and storage requirements, rapid and deterministic task scheduling and execution, cost-sensitive applications, and a simpler environment that demands a smaller learning curve compared to using a Linux BSP.

With FreeRTOS, you create a board-specific FreeRTOS port or configuration tailored to the hardware platform, configure the kernel and peripheral drivers, and develop application code using FreeRTOS APIs, eliminating the need for a Linux BSP.

The port or configuration includes a kernel for basic real-time OS functionality, hardware configuration files, startup code, and drivers for target hardware interaction. A Hardware Abstraction Layer (HAL) offers a consistent API for peripheral access across multiple platforms, while middleware components supply networking, file system, and communication functions.

Embedded development demands proficiency in debugging tools and testing methodologies specifically designed for embedded systems, which are crucial for building reliable and robust systems.

Embedded development practically has its testing discipline, presenting unique challenges for testing and debugging. Developers often use limited debugging tools and depend on hardware-based debugging methods, such as JTAG and oscilloscopes.

The lack of screens on most embedded devices increases the complexity of debugging and testing. This limitation necessitates remote debugging techniques (e.g., through USB), retrieval of logs and data analysis using alternative methods, and user interface (UI) testing that relies on external tools, ultimately slowing down the debugging process.

Embedded systems development is a highly specialized field that requires a diverse skill set and comprehensive knowledge of hardware components, electronic concepts, communication protocols, and programming languages. As IoT technology advances, the demand for skilled IoT developers capable of providing embedded software development services is rising. At Krasamo, we have teams of developers with IoT skills and experience in various areas, including microcontrollers, microprocessors, real-time operating systems, Linux BSP, FreeRTOS, debugging, and testing methodologies tailored for embedded systems.