With the rise of the Internet of Things, smart devices, AI, and automation, embedded systems play a crucial role in our daily lives.
Developing these systems requires a diverse set of skills to ensure their efficiency, reliability, and performance.
It is the goal of Swedish Embedded Online Training to help you develop these skills so that you can be in good position to build embedded systems yourself.
In this issue of Embedded Insights Newsletter we are going to look at top 16 most essential skills today that can help you build embedded systems faster than ever.
Why these skills are important
Embedded systems are everywhere - from our smartphones and home appliances to complex industrial machinery and medical devices. Every electronic device with any kind of programmable functionality in it can be considered to be an embedded system.
Building such systems requires an array of specific skills. The two main skill areas you need are of course software development and hardware design.
However there are other important skills around these areas which are so important that if you have not mastered them you will struggle. One example is control theory - without it you will be forever stuck trying to manually tune PID controllers while with it you will simply solve things mathematically.
Mastering the necessary skills enables you to create innovative solutions, solve real-world problems, and stay ahead in the rapidly evolving tech industry.
Many skills outlined in this post are also highly transferable meaning that they are useful in other software domains as well.
The demand for skilled engineers continues to grow and by acquiring these skills you will be able to explore new opportunities and ensure your growth towards mastery in the embedded domain.
So let’s get right into it!
In this post I’m going to cover the 16 most essential skill areas of embedded engineering.
I wanted to reduce this list further but embedded systems is just such a diverse and multidisciplinary area of computer science that all of these skills are equally as important nearly every embedded project benefits from having a team that together can cover all of these areas.
The 16 key skill areas that we are going to cover in this article are:
- Embedded Systems Design: To build efficient and reliable systems, it’s crucial to understand the principles of embedded systems design, including hardware-software co-design and system architecture.
- Programming Languages: Proficiency in languages like C, C++, and Assembly is vital for writing efficient code and optimizing system performance.
- Microcontroller Programming: Microcontrollers are the brains of many embedded systems, and mastering their programming is essential for building robust and functional devices.
- Real-Time Operating Systems (RTOS): An RTOS can be a game-changer for time-sensitive applications, ensuring timely task execution and optimal resource management.
- Electronics and Circuit Design: A strong foundation in electronics is necessary for designing and implementing the hardware components of embedded systems.
- PCB Design and PCB Layout: Mastering PCB design techniques enables you to create compact and efficient hardware layouts, which are critical for embedded systems.
- FPGA Development: FPGAs provide flexibility and high-performance computing capabilities, making them a popular choice for many embedded systems applications.
- Signal Processing: Digital and analog signal processing techniques are crucial for interpreting, analyzing, and responding to data inputs in embedded systems.
- Communication Protocols: Understanding communication protocols like UART, SPI, I2C, and CAN is essential for seamless data transmission between system components.
- Control Systems: Designing and implementing control algorithms is a critical skill for managing system behavior and achieving desired outcomes.
- Sensors and Actuators: Knowledge of various sensors and actuators, along with their interfacing, allows you to create responsive and interactive embedded systems.
- Debugging and Testing: Effective debugging and testing skills are crucial for identifying and resolving issues, ensuring system reliability and performance.
- Software Development Methodologies: Adopting proven methodologies like Agile and Scrum can streamline the development process and improve team collaboration.
- Project Management: Solid project management techniques enable you to plan, execute, and monitor embedded systems projects effectively.
- Cybersecurity: Security is paramount in today’s connected world, and understanding how to protect embedded systems from vulnerabilities is essential.
- Machine Learning and AI: Integrating machine learning and AI algorithms in embedded systems can enable advanced data analysis and intelligent decision-making.
Skill 1: Embedded Systems Design
To build efficient and reliable systems, it’s crucial to understand the core principles of embedded systems design, including hardware-software co-design (physical and simulated) as well as system architecture.
This involves the following key areas:
- Requirement gathering: this involves communicating with stakeholders and clarifying the system’s functional and performance requirements to make good design decisions. This process needs to create good raw materials for automated verification steps. The end result is requirements outlined into Robot Framework scripts that can be finalized during main development phase.
- Hardware selection: this involves picking the most suitable boards, main CPU architecture, memory, and peripherals based on the specific needs of the embedded system and communication/connectivity requirements. The end product is a block diagram of the hardware to be built.
- Software development: architectural design of the embedded firmware, including drivers, and application layers, to ensure seamless interaction with the hardware components. The end result is a firmware that implements the requirements.
- System optimization: initial prototype usually uses more powerful components and the software may not yet be fully optimized either. This area deals with optimizing out the unnecessary parts and making the system cost efficient to duplicate many times.
- Scalability and modularity: designing for modularity is a skill in and of itself. It involves being able to extrapolate into the future and anticipate how the parts will be evolved and used 10, 20, 30 years from now. The output of this skill is a system that is very easy to maintain and evolve in the face of changing requirements.
Here are some resources that you may find useful for system design:
- 96Boards: this is an open source board specification which aims to standardize multiple classes of boards such as SoM modules, IoT boards and industrial automation PCs. The biggest benefit of starting with a standard and designing your system into it is that you instantly have a level of interoperability with other devices that also follow an overall system design standard.
- Arduino: Arduino is probably the most popular open-source electronics platform featuring microcontroller boards and software, allowing users to create interactive electronic projects. The biggest benefit of studying arduino as a platform is that it has one base system and then countless other components that can be easily integrated with it. The drawback of Arduino is that in an effort towards simplicity it often teaches you bad coding practices that simply are not good enough for production environment - but from system design perspective it is very well thought out.
- Raspberry Pi: is an affordable single-board computers used for various applications, including educational, hobbyist, and industrial purposes. It is probably the simplest linux capable board that can be used to learn Linux embedded application development. You can use either Raspbian linux images on it or build your own images using Buildroot or OpenWRT. The biggest benefit with Raspberry Pi is that it lets you jump right into learning embedded linux without having to worry about hardware because the hardware is very simple and very well supported.
- RepRap: Calls itself the first self-replicating 3D printer, with the aim of making 3D printing technology more accessible and affordable. This ecosystem has sparked many similar projects that reuse the firmware such as Duet2. If you are interested in building your own 3D printers or learning about CNC machine construction then RepRap is an excellent system to study.
- OpenROV: This is an underwater robot project designed to make remotely operated vehicles (ROVs) more accessible for exploration, research, and recreational use. With hardware and software fully available, this project serves as an excellent resource for ideas around embedded systems applied to underwater vehicle construction. This project also features a communication standard Bristlemouth aimed at seamless integration of marine embedded systems.
- FarmBot: If 3D printers are not sufficient to satisfy your curiosity, then here is an open-source, automated precision farming machine aimed at helping users grow food in their backyard, rooftop, or small farm. This project shows integration of embedded system with mobile app and all the source code is available on github: FarmBot Github.
- OpenMV: The OpenMV Cam is a small, low power, microcontroller board which allows you to easily implement applications using machine vision in the real-world. You program the OpenMV Cam in high level Python scripts (courtesy of the MicroPython Operating System) instead of using a language like C. If you are interested in Optical Flow implementations you can also checkout PX4 Flow camera that uses similar hardware.
- OpenCores: This is a community-driven repository of open-source digital designs for hardware components, such as CPUs, peripheral controllers, and System-on-Chip (SoC) designs. If you want to learn about CPU design then this is an excellent resource to learn how actual processors are designed. Source code in Verilog/VHDL is also provided for each core.
- Open Compute Project: A set of open standards for hyperscale data center operators and industry players, joined by telecom, co-location providers and enterprise IT users, working with vendors to develop and commercialize open innovations that, when embedded in product are deployed from the cloud to the edge.
- SatNOGS: A global network of open-source satellite ground stations aimed at improving access to satellite data for amateur and professional users. Documentation.
- Mycroft: An open-source, privacy focused, voice assistant and smart speaker platform that emphasizes privacy and user control. This project is an excellent open example of embedded systems designed for home use such as Google Home and Alexa.
- Marlin Firmware: Taking advantage of the large number of 3D printer embedded boards, this is an open-source firmware for 3D printers, which provides a wide range of customization options and compatibility with various printer models.
- OpenBCI: This is a great example of embedded systems used to implement interface between machines and the human brain. This project focused on creating open-source brain-computer interfaces for research, education, and personal use.
- Libre Solar: A collection of open-source hardware and software projects focused on creating building blocks for renewable energy, including solar charge controllers, battery management systems, and energy monitoring solutions.
- Precious Plastic: An initiative that provides open-source blueprints and instructions for building machines to recycle plastic and create new products.
Open source and open hardware projects are an excellent source of ideas and inspiration that you can learn from to build embedded systems faster than ever before.
Skill 2: Programming Languages
Programming language skills are almost taken for granted today. And yes, new programming languages are fairly easy to learn once you have mastered a few because many concepts are completely transferable from one language to another.
However, for effective embedded systems development you do need to develop proficient skills in the most essential programming languages suitable for such work which includes: C, C++, Assembly, C#, Python and Rust.
Why Python? Because Python is essential in build automation and testing. You will quickly find yourself writing automation in Python.
Why C#? Because Renode uses it as the main extension language so when it comes to extensive device simulation you will find yourself writing test harnesses in C#.
Why Rust? Because it is basically "C done right". It is a language that forces you to write good C code by simply refusing to compile code that doesn’t follow good conventions and so by learning Rust you can then transfer these skills to your C programming or simply use Rust directly since it is possible to compile Rust code and link it with C for embedded firmware use.
Beyond that you can of course also learn other languages, but the above are the most essential.
Other areas that also belong to programming languages are:
- Code optimization: writing efficient and optimized code to minimize resource usage, maximize performance, ensure system stability and simplify testing and maintenance.
- Hardware interaction: knowing how to use programming languages to directly interact with and control hardware components effectively.
- Platform-specific libraries: Leverage platform-specific libraries and frameworks to simplify development and improve code maintainability.
- Debugging techniques: Master debugging techniques in different programming languages to identify and resolve issues in embedded systems code.
The biggest limiting factor beyond just learning a programming language is learning how to APIs and libraries connected to that programming language and the platform on which your software is built.
Here are some online resources related to programming that you may find useful:
- GNU C Manual: a C programming language manual that describes most aspects of the C programming language.
- Beej’s Guide to C Programming: this is a comprehensive guide that dives even deeper into the C programming language.
- The Embedded Rust Book: this is a gentle introduction to embedded Rust and using the Rust programming language specifically in embedded environments.
Skill 3: Microcontroller Programming
Once you have thorough knowledge of programming languages involved in embedded workflow, it is time to understand how to use these languages effectively to program the chips that you will actually be working with.
While it is for the most part a rather low level task to be programming the microcontroller directly, you still need to understand how the chips operate in order to write software that can make effective use of on chip peripherals.
This area thus is a separate skill that is learned primarily by studying microcontroller data sheets and writing software that directly interacts with the on chip peripherals.
This area of knowledge can be further broken down into the following parts:
- Familiarity with architectures: knowledge about peculiarities of microcontroller architectures, such as ARM Cortex, AVR, and RISC-V, to effectively program and optimize system performance. This includes flashing, accessing architecture specific features and debugging over JTAG.
- Peripheral programming: configuring and controlling microcontroller peripherals, such as GPIOs, timers, ADCs, and communication interfaces, for interacting with outside world. This also involves knowing how to use peripherals to generate and capture complex wave forms so that you can read sensors and control actuators.
- Interrupt handling: knowing how to implement efficient interrupt handling to respond to time-sensitive events and ensure real-time performance in your firmware. This is an important skills that is often not covered by most programming courses.
- Low-level programming: understanding of and ability to do low level programming tasks such as context switching, DMA, precise hardware control, linker scripts and resource usage optimization.
- Power management: ability to implement power management strategies, such as sleep modes, clock gating and voltage regulator gating to minimize power consumption and extend battery life of the embedded system.
Here are some application notes and resources that you may find helpful:
"Digital Signal Processing Using the ARM Cortex M4" by Donald S. Reay: This book presents a hands-on approach to teaching Digital Signal Processing (DSP) with real-time examples using the ARM® Cortex®-M4 32-bit microprocessor.
"The Definitive Guide to ARM Cortex-M3 and Cortex-M4 Processors" by Joseph Yiu: This comprehensive book provides detailed information on the architecture, instruction set, and programming techniques for ARM Cortex-M3 and Cortex-M4 processors, with examples and exercises to help readers develop their skills.
"System-on-Chip design with ARM Cortex-M processors" by Joseph Yiu: this reference book is a good read for you even if you don’t intend to do soc design in silicon because when it comes to simulating these chips and verifying your product top to bottom you will need to have at least a basic hint about how these system on chip systems work.
Texas Instruments Resources
Skill 4: Real-Time Operating Systems (RTOS)
Real-Time Operating Systems (RTOS) have been steadily replacing single main loop programming in embedded systems due to the growing complexity of applications and the need for efficient resource management.
As embedded systems become more complex, a single loop programming approach can become cumbersome and inefficient.
RTOS provides a far better architecture by offering multitasking capabilities, which enable the concurrent execution of multiple sequences of operations (multiple loops) in a controlled and organized manner.
This allows developers to break down complex applications into smaller, more manageable units which can then be developed independently and do not require changes when timing requirements change.
RTOS platforms can prioritize these sequences (tasks) based on their importance and timing requirements, ensuring that critical tasks are always executed on time, while lower-priority tasks are executed without causing interference.
An additional advantage of using an RTOS is the ability to manage system resources more effectively. This is primarily due to the fact that RTOS allows multiple sequences of operations to wait for hardware without blocking other code.
This allows the firmware to easily use hardware peripherals in parallel without requiring sophisticated state machines making it possible to take full advantage of the built in parallelism that is inherent in the hardware itself.
RTOS can manage memory, power modes, and handle peripheral devices, making it easier to optimize system performance, simplify the design of the system and reduce power consumption all at the same time.
Single loop programming typically lacks such built-in capabilities, which can lead to sub-optimal performance and unnecessary complexity.
We can further divide the topic of realtime operating systems into the following areas which you need to master in order to master the topic as a whole:
- Task scheduling: understanding how RTOS task scheduling, including preemptive and cooperative multitasking, ensures timely task execution and meets strict timing constraints. In particular how tasks can be prioritized together with interrupts to give an overall highly predictable and deterministic priority order. I describe this in more detail in my Concurrency Introduction section of the Embedded C Programming Design Patterns Training.
- Inter-task communication: mastering inter-task communication techniques, such as message queues, semaphores, and mutexes and conditional variables to effectively synchronize and coordinate tasks in a real-time environment. This is also covered in the Design Patterns training.
- Resource management: using RTOS to manage system resources like memory, CPU, and peripherals to maximize performance and prevent resource contention. It is only with the help of a realtime scheduler that you can seamlessly share resources between multiple independent sequences of operations (threads). Other approaches typically result in more complex and fragile code.
- RTOS platforms: getting experience with popular RTOS platforms, such as FreeRTOS and Zephyr RTOS, and understand their unique features, advantages, and trade-offs. FreeRTOS is a very lightweight and robust scheduler, while Zephyr RTOS is excellently designed well oiled machine - the linux of microcontroller world.
- Configuration and CI: understanding how to configure and customize an RTOS to suit specific embedded system requirements and constraints. In the case of Zephyr this involves tasks such as setting up a board using device tree, configuring drivers for specific board peripherals, enabling power management features, enabling needed communication protocols and so on.
- Real-time debugging and tracing: understanding debugging and tracing features that RTOS provides, including profiling, and monitoring techniques, to ensure system stability and performance. Additionally using tools like Renode to trace and debug embedded applications entirely in software without having to rely only on physical hardware features. This is a tremendously powerful approach that is rapidly gaining traction with more and more boards being readily supported by Renode.
Here are is a collection of resources that will help you with RTOS development:
- Swedish Embedded Platform SDK: this is a CI infrastructure designed to be used with Zephyr RTOS to build embedded firmware applications on top of Zephyr RTOS while adhering to the principles of DevOps.
"Real-time Systems: Design Principles for Distributed Embedded Applications" by Hermann Kopetz- This book provides an overview of real-time systems design principles and covers topics such as scheduling algorithms, resource management, and communication protocols.
- FreeRTOS: A small and popular open-source RTOS for small embedded systems and IoT devices. It offers preemptive and cooperative scheduling, message queues, and software timers.
- Zephyr RTOS: A state of the art RTOS designed for resource-constrained devices and the Internet of Things (IoT). It features a small footprint, support for different architectures, support for huge number of development boards, and a rich set of libraries.
- Renode Simulator: A versatile simulator that can be used together with Zephyr RTOS for design and simulation of hardware. This allows you to do extensive testing of your firmware on the CI pipeline before doing any manual tests.
- NuttX: A small RTOS that provides a POSIX-like interface and supports a wide range of microcontrollers and processors. It is used by among other things PX4 autopilot.
- ChibiOS: An RTOS with a small footprint and low overhead, designed for embedded systems and real-time applications.
- RIOT: An RTOS designed for IoT devices and low-power wireless communication. It features a modular architecture, support for multiple platforms and devices, and a rich set of networking protocols.
- Fuchsia - An RTOS developed by Google for google home devices with a microkernel architecture and support for multiple devices and platforms. It offers a modular design, secure inter-process communication, and real-time scheduling.
Skill 5: Electronics And Circuit Design
Circuit design is central to embedded product development.
Even though all the advances in chip manufacturing have led to the emergence of cheap System-on-Chip (SoC) components that need nothing more than a few supporting components, the importance of understanding circuit design has not gone away.
With the advent of highly integrated SoC systems the focus of circuit design has instead shifted towards creating robust and efficient interfaces between the SoC and external components, sensors, or actuators, which are essential for the embedded system to interact with the real world.
Designing these interfaces requires a deep understanding of both the capabilities of the SoC itself (such as timing and GPIO capabilities) and the specific features of the target application. This involves selecting appropriate interface circuits that can reliably convert and transmit signals between the SoC and the external environment.
We can subdivide the area of circuit design into the following smaller areas:
- Analog and digital electronics: understanding the principles of both analog and digital electronics, including circuit components, signal processing, and power management.
- Circuit analysis: ability to use simulation tools like LT-Spice to analyze and troubleshoot circuits to ensure proper functionality, reliability, and efficiency in embedded systems.
- Component selection: studying datasheets and application notes with manufacturer recommendations for choosing appropriate electronic components, such as resistors, capacitors, inductors, and transistors, based on system requirements and SoC manufacturer constraints.
- Power supply design: designing stable and efficient power supplies to provide the required voltage and current levels for the embedded system’s operation. This is an often overlooked area but a single small mistake in power supply design can easily ruin the whole system.
- Signal integrity: understanding what is necessary for signal integrity in high-speed and mixed-signal designs by considering factors such as impedance matching, crosstalk, and noise reduction. Given that many signal lines are multipurpose, this requires good understanding not just of the SoC itself, but also of the specific embedded application that is going to be running on the board and how that application will be using the signal lines.
- Prototyping and testing: being able to quickly solder a prototype with small surface mounted components in order to test things. Ability to debug manufactured boards and replace components including BGA chips using a hot air station and a microscope.
Here are some resources on these topics that you may find interesting (most of these books are readily available in digital versions from several sources):
"Microelectronic Circuits" by Adel S. Sedra and Kenneth C. Smith. This book provides a comprehensive introduction to both analog and digital electronics, covering topics such as semiconductor devices, amplifiers, filters, and digital circuits.
"Electronic Devices and Circuit Theory" by Robert L. Boylestad and Louis Nashelsky. This book covers the fundamentals of electronic devices and circuits, with an emphasis on analog electronics, including topics like diodes, transistors, and operational amplifiers.
"Digital Design" by M. Morris Mano and Michael D. Ciletti. focuses on digital electronics and provides a thorough introduction to the design of digital circuits, including combinatorial and sequential logic, as well as design using hardware description languages (HDL).
"Analog Integrated Circuit Design" by Tony Chan Carusone, David A. Johns, and Kenneth W. Martin. This book covers the design and analysis of analog integrated circuits, with an emphasis on CMOS technology. It includes topics such as operational amplifiers, comparators, and data converters.
"Engineering Circuit Analysis" by William H. Hayt, Jack E. Kemmerly, and Steven M. Durbin. This book provides a comprehensive introduction to circuit analysis, covering topics such as circuit theorems, resistive and reactive circuits, as well as transient and steady-state analysis.
"Basic Engineering Circuit Analysis" by J. David Irwin and R. Mark Nelms. This book covers the fundamentals of circuit analysis, including topics like Ohm’s Law, Kirchhoff’s Laws, circuit theorems, and AC and DC circuit analysis techniques.
"The Art of Electronics" by Paul Horowitz and Winfield Hill. This is an amazingly comprehensive book that provides a comprehensive introduction to electronics, including in-depth discussions on various components, their properties, and how to select them for specific applications.
"Electronics for Embedded Systems" by Ahmet Bindal. This book focuses on electronics for embedded systems and covers various components, their properties, and how to select them based on system requirements. This book also includes sections on sensor and actuator interfaces including DC-motors, servos etc.
"High-Speed Digital Design: A Handbook of Black Magic" by Howard W. Johnson and Martin Graham. This book provides a comprehensive overview of high-speed digital design principles, with an emphasis on signal integrity issues, such as impedance matching, crosstalk, and noise reduction.
"Signal and Power Integrity - Simplified" by Eric Bogatin. This book covers both signal and power integrity in electronic systems, with a focus on high-speed and mixed-signal designs, addressing topics such as impedance control, crosstalk, and noise reduction.
- Macbook component level logic board repairs. This is one of the best channels on soldering and troubleshooting of electronic boards. Focusing on MacBook board repair, it covers many common solutions that are directly transferable onto any other circuit board.
Skill 6: PCB Layout
There are many similarities between laying out a PCB and compiling C source code into a binary image, despite the graphical nature of the PCB layout process.
Both processes involve converting a designed system into a manufacturable (or deployable in the case of software) unit which can then be printed into many copies.
Just like with C source code, designing the physical PCB with emphasis on testing is just as important for PCB design as it is for writing source code. Features like test points, accessible component pads, and accessible debugging interfaces make troubleshooting the PCB a lot easier.
After your circuit is designed, simulated and reviewed, it is time to do the PCB layout. This is where you load your circuit design into layout CAD software and start placing the electrical components and copper tracks.
We can further split the PCB layout task into following knowledge areas:
- Design tools: proficiency in working with modern CAD PCB design tools such as Altium Designer, Eagle, KiCad, or OrCAD, to efficiently create and edit schematic diagrams and board layouts.
- Component placement: having skills in optimizing component placement on a PCB, considering factors such as signal flow, thermal management, and mechanical constraints to minimize interference and improve system performance.
- Routing: being knowledgeable in routing techniques for high-speed and mixed-signal designs, ensuring signal integrity by managing trace lengths, impedance matching, and avoiding crosstalk or electromagnetic interference.
- Multi-layer PCBs: ability to design multi-layer PCBs to accommodate more complex circuits, being able to effectively utilize ground and power planes for better noise reduction, thermal management, and EMI shielding.
- Designing for manufacturability (DFM): having knowledge of DFM principles to create PCB designs that are cost-effective, reliable, and easily manufacturable, considering aspects such as component tolerances, soldering requirements, and fabrication constraints.
- Design for testing (DFT): Implement DFT techniques to facilitate easier testing and debugging of PCBs, incorporating features like test points, accessible component pads, and well-defined signal paths to improve test coverage and fault detection.
And here are some resources that you may find useful:
- Altium Designer: A powerful and widely used PCB design software that offers a comprehensive suite of tools, including schematic capture, layout design, and signal integrity analysis.
- Autodesk EAGLE: A user-friendly and accessible PCB design software, EAGLE offers schematic capture, board layout, and auto-routing capabilities.
- Cadence OrCAD: A suite of tools for PCB design and simulation, including schematic capture, layout design, and signal integrity analysis.
- KiCAD. KiCad has become an excellent PCB design tool for designing boards with up to about 100 components. Beyond that KiCad is a bit cumbersome to work with.
"Right the First Time: A Practical Handbook on High-Speed PCB and System Design" by Lee W. Ritchey. This handbook covers various aspects of high-speed PCB and system design, including signal integrity, power distribution, and design strategies for high-speed PCBs.
"Printed Circuit Board Design Techniques for EMC Compliance: A Handbook for Designers" by Mark I. Montrose. This book focuses on the design techniques for achieving electromagnetic compatibility (EMC) in printed circuit boards, including topics such as grounding, shielding, and trace routing.
"RF Circuit Design" by Christopher Bowick. A highly Although primarily focused on RF circuit design, this book provides valuable insights into PCB layout techniques for high-frequency applications, including transmission lines, impedance matching, and parasitic effects.
- Olimex: Olimex is a company that designs and manufactures open-source embedded boards. Nearly all of their board designs are also available on github. Just go to the website, find the board you like and then view designs linked to from the product description.
- OpenEVSE: OpenEVSE is an open-source electric vehicle charging station project. They provide well-documented hardware designs, including schematics and PCB layouts.
- Jay Carlson Linux Boards. While this is not an open hardware project itself, this resource provides valuable insights and guidance for those interested in building embedded linux boards using a variety of different CPUs.
Skill 7: FPGA Development
FPGAs allow developers to extend existing designs that use microcontrollers and SoCs with additional high speed hardware over which the developer has full control.
These hardware extensions can be developed in a hardware description language such as Verilog and VHDL and then loaded into an FPGA over SPI bus, giving the developer incredible additional freedom of creating customized peripherals.
Customized peripherals can then be used for highly time critical tasks such as realtime data capture and processing, signal generation and control.
This area embedded development can further be split into the following topics:
- FPGA architecture: understanding programmable logic blocks, interconnects, and configurable I/O blocks, to effectively harness their capabilities in embedded designs.
- Hardware Description Languages (HDLs): being able to describe, simulate and synthesize digital circuit logic using VHDL or Verilog so that they can be implemented on FPGAs.
- FPGA design tools: being proficient with popular FPGA design tools and software suites, such as Xilinx Vivado, Intel Quartus, Lattice Diamond and the newer open source alternatives, to efficiently develop, simulate, and synthesize FPGA-based designs.
- Optimization techniques: optimization techniques for FPGA designs, such as resource utilization, pipelining, and parallelism, to maximize performance, minimize power consumption, and reduce development time.
- IP cores and soft processors: FPGAs can be used for more than just simple peripherals. Full CPU cores can be compiled and used on an FPGA. Examples include MicroBlaze, Nios II, and RISC-V. Integrating an IP core allows developer to implement complex functionality and completely custom processing elements into a design.
- FPGA development boards: there are numerous available FPGA development boards, such as Xilinx Zynq, Intel Cyclone, or Lattice ECP5, which can be used to prototype and test your designs in real-world applications and gain hands-on experience with different FPGA families.
Here are some additional resources that you may find useful:
- Awesome Radar Perception: A curated list of radar datasets, detection, tracking and fusion.
- Home Made FMCW 6GHz Radar: this project uses an FPGA for radar signal capture. The signal is first extracted through a mixer and then the lower frequency signal is captured by the FPGA and forwarded over USB to the computer. All hardware and fpga designs are available on github.
- Open-Source FPGA Stereo Vision Core: A real-time stereo vision processing system implemented on an FPGA, designed to provide depth information for robotics and automation applications.
- Software Defined Radio for FPGAs: ZipCPU has always been a nice resource for highly compact HDL designs that are a great source for learning.
- LimeSDR: LimeSDR provides a hardware platform for developing and prototyping high-performance and logic-intensive digital and RF designs using Altera’s Cyclone IV FPGA and Lime Microsystems transceiver.
"FPGA Prototyping by VHDL Examples" by Pong P. Chu: This book provides a practical introduction to FPGA development using VHDL, with a focus on hands-on examples and projects.
Skill 8: Signal Processing
Signal processing is a critical aspect of embedded systems, as it involves the mathematical tools for manipulating and generating signals, which are the primary means of communication and data exchange between the physical world and the embedded systems.
These signals often start as analog when they enter the PCB from the real world (ie radio waves or analog sensor signals) and are then filtered, amplified and conditioned using analog components and is then converted into digital domain where the signals can be processed by a microprocessor.
Depending on whether the signal is sampled (digital) or continuous time (analog) the equations for handling the signal are different.
Digital signal processing (DSP) is concerned with the manipulation of discrete-time signals, which are represented as a series of numerical values. In embedded systems, digital signals are often generated by analog-to-digital converters (ADCs) that sample the continuous-time signals and convert them into lists of values that a software program can work with.
Digital signal processing techniques include digital filtering, frequency-domain analysis, and time-domain analysis.
In both digital and analog signal processing, the primary goal is to extract meaningful information from the input signals and respond accordingly by for example generating an actuator output signal.
Signal processing requires a separate section because it is such an involved discipline that requires extensive understanding of the mathematics of dynamic systems. It is highly important because all control tasks, signal capture and filtering depend on understanding signal processing.
This can be further divided into the following distinct areas of study:
- Time-Domain Analysis: these are techniques for analyzing signals in the time domain (linear domain), focusing on signal properties such as amplitude, duration, and time-based features.
- Frequency-Domain Analysis: methods for transforming and analyzing signals in the frequency domain, emphasizing the frequency content and spectral characteristics of signals that are periodic in nature.
- Digital Filtering: design and implementation of digital filters, such as low-pass, high-pass, band-pass, and notch filters, to manipulate and process signals according to specific requirements. In digital domain we work with z-transform and the corresponding "difference" equations which we then implement in C.
- Analog Filtering: Design and implementation of analog filters, including passive and active filters, to process continuous-time signals and achieve desired signal characteristics. In this domain we work with continuous time s-transform (Laplace transform) equations and we typically implement such systems using analog components on the PCB.
- Adaptive Signal Processing: Advanced techniques for dynamically adjusting filter coefficients and processing parameters to improve system performance in changing environments or conditions. This section encompasses predictive filters such as the Kalman filter and other model based filtering techniques.
Here are some resources that you may find useful:
"Signals and Systems" by Alan V. Oppenheim, Alan S. Willsky, and S. Hamid Nawab Description: This widely-used textbook covers fundamental concepts in signal processing, including time-domain analysis, signal properties, and basic operations on signals.
"Design with Operational Amplifiers and Analog Integrated Circuits" by Sergio Franco: This textbook covers the design and analysis of analog filters using operational amplifiers and other analog integrated circuits.
"Adaptive Filter Theory" by Simon Haykin Description: This widely-used textbook covers the theory and applications of adaptive filters, including the development of adaptive algorithms and their convergence properties.
- Kalman And Baesian Filters In Python by Roger R Labbe Jr: this excellent book explains kalman filter implementations using Python and comes with a source code repository as well (Python workbooks).
- Swedish Embedded Control Systems Toolbox for Embedded Systems: this project provides a Zephyr RTOS compatible math functions for building digital filters and control algorithms.
- The Scientist and Engineer’s Guide to Digital Signal Processing By Steven W. Smith, Ph.D. This widely-used guidebook covers various aspects of digital signal processing, including digital filtering, with practical examples and applications.
Skill 9: Communication Protocols
Communication protocols play a vital role in embedded systems, as they define standardized rules and formats for data exchange between system components. These protocols allow for seamless integration, enabling devices to work together efficiently and reliably.
By gaining a deep understanding of communication protocols, you gain ability to choose the most suitable protocol for a particular application, ensuring optimal performance and disturbance resilience.
Understanding of communication protocols enables you to identify and resolve potential communication issues during the development and be able to debug communication problems more easily.
We can divide the area of communication protocols into the following main areas of study:
- Serial Communication Protocols: such as UART, SPI, and I2C, which enable efficient data transmission between embedded system components on the same board. Including efficient framing and data integrity checks.
- Network Communication Protocols: such as TCP/IP, UDP, EtherCAT and other network-based communication protocols that allow embedded systems to communicate over standard ethernet networks.
- Industrial Communication Protocols: such as CAN, Modbus, and Profibus, which are designed for reliable and real-time communication in industrial environments and automation systems.
- Wireless Communication Protocols: such as NB-IOT, Zigbee, Bluetooth, Wi-Fi, Sigfox and LoRaWAN, which enable data transmission over longer distances using radio links.
- IoT Communication Protocols: such MQTT, CoAP and Mavlink, which are optimized for efficient and reliable communication between embedded devices and cloud services and often build on top of the other protocols above.
- Communication Security: security protocols and best practices to protect data transmission and ensure the integrity and confidentiality of information being transmitted.
Here are some tools that will make your life easier:
- Wireshark: A widely used network protocol analyzer that supports a multitude of protocols, including Ethernet, TCP/IP, and many others. Wireshark allows for real-time inspection, decoding, and analysis of network traffic. Not only does it do network traffic, but with appropriate linux drivers and extensions you can also decode USB traffic and any custom protocol.
- Saleae Logic Analyzers: Software and hardware for capturing and analyzing digital signals. These logic analyzers support serial protocols such as UART, SPI, and I2C, enabling you to inspect and decode communication between embedded system components.
- Analog Devices: UART Serial Communication: very basic overview of UART.
- Analog Devices: Introduction to SPI interface: very basic overview of SPI.
- Analog Devices: I2C Communication Primer: very basic overview of I2C.
- Microchip: CAN Protocol Primer: An introduction to the CAN protocol that discusses the basics and key features.
Skill 10: Control Systems Design
Control theory is extremely important because it provides the foundation for designing and implementing control algorithms that govern the behavior of a wide range of physical systems.
This area of study provides the mathematical foundation for designing systems that can precisely adopt their behavior and generate appropriate signals for motors and other actuators based on data from sensors. Many embedded systems are in fact either communication or control systems.
Linear and nonlinear control techniques form the cornerstone of control theory. By learning both approaches, you can tackle a wide variety of system dynamics, from simple linear systems to complex nonlinear ones.
The knowledge of robust and adaptive control methods allows you to create systems that can maintain performance in the face of uncertainties, parameter variations, or unanticipated disturbances.
The study of control theory consists of the following main areas of study:
- Linear Control Theory: developing and analyzing linear control techniques, including classical and modern methods for both continuous and discrete-time systems, to achieve stability and desired performance.
- Nonlinear Control Theory: advanced control methodologies specifically designed for nonlinear systems, focusing on stability analysis, performance optimization, and the development of practical control strategies for real-world applications.
- Robust Adaptive Control: Research on designing control systems that can maintain stability and performance despite uncertainties, disturbances, or changing dynamics, ensuring robustness and adaptability in real-world applications.
- Optimal Control: Exploration of control methodologies that optimize specific performance criteria, such as minimizing energy consumption or maximizing system efficiency, subject to constraints.
- Model Predictive Control (MPC): developing MPC algorithms, which use a model of the system to predict future behavior, optimize control actions over a finite horizon, and adjust in real-time based on new measurements.
- Networked Control Systems (NCS): control systems that involve multiple interconnected components, such as multi-agent systems, flocking, distributed control, and cooperative control, with a focus on communication, synchronization, and decision-making.
And here are some resources on this subject that you may find interesting:
"Feedback Systems: An Introduction for Scientists and Engineers" by Karl J. Astrom and Richard M. Murray: This highly regarded book introduces control theory principles, focusing on modeling, analysis, and feedback control.
"Modern Control Engineering" by Katsuhiko Ogata: Excellent book that covers control engineering topics, including state-space analysis, linear system theory, and control system design using modern techniques.
"Control Systems Design" by Graham C. Goodwin, Stefan F. Graebe, and Mario E. Salgado: This resource offers a comprehensive introduction to control systems design, covering topics such as system identification, controller synthesis, and practical implementation. This book covers SISO and MIMO systems.
- Control Systems Toolbox: a C library for implementing control algorithms and mathematical functions on resource constrained embedded systems.
Skill 11: Sensors Actuators
Sensors and actuators are the primary way of the embedded system to interact with the real world. In fact, the most simplified way to illustrate what an embedded system is would be to draw a black box with sensors coming in on one end and actuator signals coming out of the other.
In order to do measurement and control tasks we must therefore work with sensors and actuators. In this section we will go over the vast number of different sensors and actuators that you may run into in your embedded systems career.
- Buttons: this is the simplest of all possible sensors and usually simply connects to a GPIO line.
- Joysticks: simplest form of joystick uses two variable potentiometers. This kind of actuator can also be connected directly to an ADC input.
- Thermocouples: Measure temperature by generating a voltage from the junction of two dissimilar metals.
- Resistance Temperature Detectors (RTDs): Measure temperature by correlating the change in electrical resistance of a metal wire.
- Thermistors: Measure temperature through the change in electrical resistance of a semiconductor material (name is similar to 'transistor')
- Infrared thermometers: Measure temperature by detecting infrared radiation emitted by an object.
- Piezoresistive pressure sensors: Measure pressure by detecting the change in electrical resistance of a strain-sensitive material.
- Capacitive pressure sensors: Measure pressure by detecting changes in capacitance due to the deformation of a diaphragm.
- Optical pressure sensors: Measure pressure by detecting changes in light intensity or wavelength due to pressure-induced deformation.
- Resonant pressure sensors: Measure pressure by detecting changes in the resonant frequency of a structure due to pressure-induced stress.
- Mass flow sensors: Measure mass flow rate by detecting changes in heat transfer or Coriolis force.
- Volumetric flow sensors: Measure volumetric flow rate using mechanical or fluid-dynamic principles, such as turbine, paddlewheel, or positive displacement methods.
- Ultrasonic flow sensors: Measure flow rate by detecting the time difference or frequency shift of ultrasonic waves propagating through a fluid.
- Electromagnetic flow sensors: Measure flow rate by detecting the voltage induced by the motion of conductive fluid through a magnetic field.
- Optical flow sensors: Measure flow rate of a camera image by analyzing how pixels move on the image.
Level And Distance Sensors
- Capacitive level sensors: Measure fluid level by detecting changes in capacitance between a probe and the fluid.
- Ultrasonic level sensors: Measure fluid level by emitting and receiving ultrasonic waves, calculating the distance based on time of flight.
- Optical level sensors: Measure fluid level by detecting changes in light transmission or reflection due to the presence of a fluid.
- Optical time of flight sensors: Measure distance by sending out a laser beam and measuring the time of flight until the light returns and hits the detector.
- Float level sensors: Measure fluid level using a float that moves with the fluid surface and actuates a mechanical or electrical output.
Position And Displacement Sensors
- Linear variable differential transformers (LVDTs): Measure linear displacement by detecting changes in the magnetic coupling between primary and secondary coils.
- Potentiometers: Measure position or displacement by correlating the change in electrical resistance of a sliding contact on a resistive track.
- Encoders: Measure position or displacement by converting mechanical motion into digital signals using optical, magnetic, or capacitive techniques.
- Inclinometers: Measure tilt or inclination by detecting changes in the gravitational force acting on a sensing element, such as a pendulum.
Force and Torque Sensors
- Strain gauges: Measure force or torque by detecting changes in electrical resistance due to strain applied to a sensing element.
- Load cells: Measure force or weight by converting mechanical deformation into an electrical signal using strain gauges.
- Piezoelectric force sensors: Measure force or pressure by generating a voltage proportional to the applied stress on a piezoelectric material.
- Torque transducers: Measure torque by detecting the deformation or twist in a shaft or sensing element using strain gauges, optical, or magnetic techniques.
Acceleration and Angular Velocity Sensors
- Accelerometers: Measure acceleration or vibration by detecting changes in force or displacement of a sensing element, such as a mass-spring system or piezoelectric material.
- Gyroscopes: Measure angular velocity or orientation by detecting the Coriolis force acting on a vibrating structure or the conservation of angular momentum in a spinning mass.
- Seismometers: Measure ground motion or vibration by detecting relative motion between a suspended mass and a fixed frame.
- Capacitive humidity sensors: Measure humidity by detecting changes in capacitance between a moisture-sensitive dielectric material and an electrode.
- Resistive humidity sensors: Measure humidity by detecting changes in the electrical resistance of a moisture-sensitive material.
- Thermal conductivity humidity sensors: Measure humidity by detecting changes in the thermal conductivity of a gas mixture.
- Optical humidity sensors: Measure humidity by detecting changes in the optical properties of a moisture-sensitive material, such as refractive index or light absorption.
Gas and Chemical Sensors
- Electrochemical gas sensors: Measure gas concentration by detecting the current generated from a chemical reaction between the target gas and a sensing electrode.
- Infrared gas sensors: Measure gas concentration by detecting the absorption of infrared radiation by the target gas.
- Photoionization detectors: Measure volatile organic compound (VOC) concentrations by detecting ionized gas molecules generated through UV light exposure.
- Metal oxide semiconductor (MOS) gas sensors: Measure gas concentration by detecting changes in the electrical resistance of a metal oxide semiconductor material due to interaction with the target gas.
Light and Radiation Sensors
- Photodiodes: Measure light intensity by generating a current proportional to the absorbed photons in a semiconductor material.
- Phototransistors: Measure light intensity by modulating the current flowing through a bipolar junction transistor (BJT) based on the absorbed photons.
- Photoresistors: Measure light intensity by detecting changes in the electrical resistance of a light-sensitive material.
- Geiger-Muller counters: Measure ionizing radiation by detecting the ionization of gas molecules inside a detector tube.
- Inductive proximity sensors: Measure proximity by detecting changes in the inductance of a coil due to the presence of a conductive or magnetic object.
- Capacitive proximity sensors: Measure proximity by detecting changes in capacitance between a sensor electrode and the target object.
- Ultrasonic proximity sensors: Measure proximity by emitting and receiving ultrasonic waves, calculating the distance based on time of flight.
- Infrared proximity sensors: Measure proximity by emitting and detecting infrared light reflected off the target object.
- Image sensors: Measure and capture optical images by converting light intensity into an electrical signal using an array of light-sensitive elements, such as CCD or CMOS sensors.
- Color sensors: Measure color by detecting the intensity of light at specific wavelengths using color filters or spectral sensors.
- Lidar sensors: Measure distance and generate 3D maps by emitting and detecting laser pulses, calculating the distance based on time of flight.
- Optical fiber sensors: Measure various parameters, such as temperature, strain, or pressure, by detecting changes in the optical properties of a fiber, such as light intensity, phase, or wavelength.
- Microphones: Measure sound pressure by converting acoustic waves into electrical signals using a diaphragm or other sensing element.
- Hydrophones: Measure underwater sound pressure by detecting pressure changes using a water-tight sensing element, such as a piezoelectric material or an optical fiber.
- Ultrasonic sensors: Measure distance, proximity, or fluid level by emitting and detecting ultrasonic waves, calculating the distance based on time of flight.
- Acoustic emission sensors: Measure stress, strain, or crack formation in materials by detecting the release of acoustic energy due to material deformation or fracture.
- Hall effect sensors: Measure magnetic fields by detecting the Hall voltage induced in a current-carrying conductor by the presence of a magnetic field.
- Magnetoresistive sensors: Measure magnetic fields by detecting changes in the electrical resistance of a magnetic material.
- Fluxgate magnetometers: Measure magnetic fields by detecting changes in magnetic saturation of a ferromagnetic core.
- Magnetostrictive sensors: Measure magnetic fields, force, or position by detecting changes in the dimensions of a magnetostrictive material due to the presence of a magnetic field.
- Voltage sensors: Measure voltage by detecting changes in the electric potential between two points, typically using a voltage divider or an isolation technique such as a transformer.
- Current sensors: Measure current by detecting changes in the magnetic field surrounding a conductor, using methods such as Hall effect sensors, current transformers, or shunt resistors.
- Resistance sensors: Measure resistance by detecting the voltage drop across an unknown resistor, typically using a Wheatstone bridge or a constant current source.
- Capacitance sensors: Measure capacitance by detecting changes in the charge storage capacity of a capacitor, typically using a capacitance-to-voltage converter or a resonant circuit.
When we deal with actuators in embedded development, most of the actuators we deal with are electrical actuators. These actuators are typically controlled using a variation of PWM signal and power electronics connected to the microcontroller. Here is a more extensive list of various actuators and methods of controlling them.
- LED: the most basic actuator. Typically controlled through a current limiting resistor directly from a GPIO pin. However high power leds do need additional LED driver circuitry which is a whole different topic.
- DC Motors: a DC motor is integrated with a microcontroller using a motor driver circuit that connects to an H-bridge which consists of high power transistors. This circuit is then controlled using a PWM signal from the microcontroller often generated using internal timers. An encoder or hall sensor is often used for rotor position feedback.
- AC Motors: AC motors are used in applications where torque and power is important. These motors are also controlled using H-bridge but the control signal needs to be a variable frequency signal adjusted to the rotor angle (or magnetic field of the rotor) to generate optimal torque.
- Stepper Motors: these motors precise open loop control by allowing you to move the motor in a series of steps. You simply have to generate a signal that corresponds to the steps and the motor will move the same number of steps. Stepper motors are useful for precise motion of elements such as a printer head or a CNC machine assembly.
- Servo Motors: these motors include an assembly and electronics that allow it to be precisely positioned depending on the incoming PWM signal duty cycle. The control is greatly simplified by only having to generate the appropriate PWM signal in order to position the servo.
- Linear Motors: this is also an assembly that often consists of a DC motor and a mechanical actuator that together form an assembly that moves a pin back and forth without allowing it to move by itself. This assembly usually involves a gear assembly and a linear resistor as a feedback mechanism and operates similar to a hydraulic actuator.
- Solenoids: this is a magnetic actuator often used in locks where current through a coil moves a pin attached to the coil. The actuator can be easily controlled simply by using a single MOSFET and controlling it using PWM signal or DC voltage (as in the case of a relay).
- Piezoelectric Actuators: these are precision ceramic actuators which convert electrical energy directly into linear motion with high speed, force and virtually unlimited resolution.
- Shape Memory Alloy Actuators: these are a specific class of material with the ability to recover their original shape by a reversible Martensitic phase transformation through a temperature change.
- Voice Coil Actuators: these are basically "speakers" and are controlled using a filtered PWM signal or using a DAC and an operational amplifier circuit.
- Magnetic Levitation Actuators: these are like AC motors but unwrapped to produce linear motion instead of circular motion. This can then be used to move a cart or a train across a linearly arranged array of magnets.
- Hydraulic Actuators: these use hydraulic fluid to create similar motion to linear motors. Integration with a microcontroller requires a hydraulic pump and valves, and pressure and position feedback for precise control.
- Pneumatic Actuators: same as hydraulic actuators only using air instead of hydraulic fluid.
Skill 12: Testing And Debugging
Testing plays an absolutely essential role in embedded systems development, ensuring that the final product is reliable, efficient, and performs as intended.
A thorough testing process helps developers identify and fix issues early, to validate system requirements, and to improve the overall quality of the embedded system.
Testing automates a lot of the work that developers would otherwise have to do manually. A major driving force behind testing is to avoid doing manual work more than once.
We can divide testing and validation into the following key areas:
- Debugging Techniques: knowledge of various debugging techniques, including breakpoints, watch points, and step-by-step execution, usage of debug server and JTAG adapter.
- Unit Testing: writing unit tests to ensure that individual code modules of the embedded firmware have fully correct and validated logic.
- Integration Testing: writing integration tests to verify that different components of the embedded system work together seamlessly and without conflicts.
- System Testing: writing system tests to validate the overall functionality, performance, and reliability of the complete embedded system under real-world conditions. Today this is most often done in Renode.
- Validation and Verification: doing manual testing on real hardware and attempting to find additional bugs that can then be included into automated tests. This process involves building actual physical test rigs and thoroughly validating the whole hardware and software design in real circumstances. The output data from this stage should be fed into the system tests so that as many of the issues as possible are automatically verified so that they do not happen again.
- Test Automation: this area concerns the infrastructure that makes testing easy. It involves being able to leverage test automation tools and frameworks to increase testing efficiency, reduce human errors, and accelerate the debugging and testing processes in embedded systems development - mostly by using python and shell scripts to implement all of the infrastructure as code.
Here are some resources that you may find useful:
- CI DevOps Infrastructure for Embedded Development: this is a course I put together where I handle the infrastructure elements that make the above tasks easy. It uses Zephyr RTOS to greatly simplify the tasks involved and then we build a complete CI infrastructure on top of that which is suitable for a custom project.
"Test Driven Development for Embedded C" by James W. Grenning: This book explores test-driven development (TDD) specifically for embedded C programming, explaining how to apply TDD principles to improve the quality and reliability of embedded systems code. It is very much in line with the course I made and further drives the key points across (until they truly stick!).
"Embedded Software: The Works" by Colin Walls: This comprehensive book covers many aspects of embedded software development, including design, coding, debugging, and testing. It provides useful tips and best practices for creating reliable and efficient embedded systems.
Skill 13: Software Development Methodologies
The continuously increasing complexity of embedded systems demands a highly adaptable and efficient development process to keep up with the ever-changing technologies and customer needs. Scrum, as an Agile methodology, offers significant advantages over older approaches like the Waterfall model, which can make it a more suitable choice for managing embedded systems projects.
Scrum comes with its inherent flexibility and adaptability. In contrast to the rigid structure of older approaches to building projects, Scrum accommodates changes in project requirements, technology, or scope with relative ease. This agility allows development teams to react quickly to new information, ensuring that the end product remains aligned with customer needs and the latest industry standards.
However, implementing scrum as a process requires heavy use of automation - you simply have to build systems around your code and build your code specifically to accommodate for rapid and reliable testing in order to even be able to implement scrum. All such efforts are absolutely worth it but what this means is simply that we can not just talk about scrum without also putting a significant focus on the CI infrastructure around your embedded firmware project.
The study of scrum and agile methodologies can further be split into the following areas:
- Agile and Scrum Fundamentals: understanding fundamentals of Agile and Scrum methodologies, their principles, and how they differ from traditional project management approaches.
- Roles and Responsibilities: Understand the roles within an Agile and Scrum team, such as Product Owner, Scrum Master, and Development Team, and their specific responsibilities in managing embedded systems projects.
- Planning and Estimation: Acquire skills in planning and estimating work effort for embedded systems projects, including backlog creation, prioritization, and the use of techniques like story points and planning poker.
- Iterative Development and Sprints: Learn how to organize work into time-boxed iterations, or sprints, focusing on delivering incremental improvements as a series of validated merge requests implementing new features.
- Continuous Integration and Quality Assurance: Understand the importance of testing code continuously, test automation, and maintaining quality through introduction of rules and constraints that can be validated automatically (such as static analysis). All of this must be integrated into the build process.
Here are some resources that you may find valuable:
- Embedded DevOps Training by Martin Schröder: this is a short training I have put together specifically outlining the philosophy of scrum. It explains the methodology of continuous delivery and specific areas that teams need to pay special attention to in order to make the process very efficient (for example applying 'trunk based development').
- Embedded Firmware DevOps Infrastructure by Martin Schröder: this training takes the scrum theoretical concepts from the previous training above and applies them specifically to Zephyr RTOS project development. We implement a CI pipeline and all of the specific infrastructure that makes highly efficient scrum based development possible (including infrastructure for system testing in Renode).
"Agile Estimating and Planning" by Mike Cohn: this book provides practical guidance on Agile estimation techniques and planning, helping project managers and development teams create accurate estimates and effective plans for software projects.
"User Stories Applied: For Agile Software Development" by Mike Cohn: this book focuses specifically on user stories in Agile development, providing comprehensive guidance on writing, managing, and estimating user stories to ensure a customer-centric approach to software development.
"The Art of Agile Development" by James Shore and Shane Warden: this book offers a comprehensive guide to Agile development with special focus on XP (extreme programming), covering principles, practices, and techniques for creating high-quality, adaptable software solutions without making sacrifices in quality and maintainability. The approach is generally very effective however this too requires the team to utilize CI to the maximum in order to avoid inefficiencies connected to manual work.
"Agile Coaching" by Rachel Davies and Liz Sedley: this book is written specifically for Agile coaches, Scrum Masters, and team leaders, providing practical advice, tips, and techniques for coaching and mentoring Agile teams to success.
- "The Personal Software Process (PSP)" by Watts S. Humphrey. This paper focuses on personal actions that each developer can engage in to properly manage their own development. The idea is that the output of the whole team is directly proportional to how well each developer is able to organize and complete their own tasks. This paper provides a methodology for tracking and organizing ones own development work.
Skill 14: Project Management
While project management and software development methodologies do in fact overlap, they do still have slightly different focus.
Project management encompasses a broader set of techniques, principles, and practices used to plan, execute, and control embedded product projects. This involves managing various aspects of a project, such as scope, time, cost, resources, risks, quality, and communication. Project management ensures that projects are completed on time, within budget, and according to the defined requirements.
Software development methodologies, on the other hand, are specific approaches and frameworks used to manage and organize specifically software development projects.
These methodologies, such as Agile and Scrum, provide a structured process for developing software and focus on improving collaboration, adaptability, and efficiency within the software development team.
This involves techniques like iterative development, continuous integration, and regular review, which are particularly useful for software projects where the team has access to specific tools like GitLab and a CI server.
Project management, therefore, is a broader concept that applies to all aspects of managing a project, while software development methodologies are specialized approaches tailored specifically for software development projects, and consequently also embedded systems.
Adopting a suitable software development methodology is a part of an overall project management strategy but does not replace the need for effective project management.
We can divide project management into the following important areas of study:
- Requirements Management: The process of gathering, defining, documenting, and managing project requirements, often in collaboration with sales and marketing and the end customer, ensuring that the software developed meets the needs and expectations of stakeholders.
- Estimation and Planning: being able to accurately estimate project effort, cost, and duration, as well as creating realistic schedules and plans to guide the development process.
- Risk Management: Identifying, assessing, and mitigating potential risks and uncertainties that could negatively impact the software project’s success, such as technical challenges, resource constraints, or changing requirements.
- Quality Assurance and Testing: Ensuring that the software and hardware meets predefined quality standards and functional requirements through systematic testing, code reviews, and adherence to best practices.
- Infrastructure and CI: managing infrastructure and IT systems that developers need in order to successfully work together on a project. This involves managing GitLab instances, JIRA, Slack, VPN access and other services that comprise the infrastructure on top of which developers work.
- Team Leadership and Communication: Effective leadership and communication in order to motivate, coordinate, and manage the software development team, fostering collaboration and ensuring that project objectives are met in a timely and efficient manner.
Project management is essentially an exercise in leadership while software development methodologies are a technical methodology for managing large amounts of code. The area of project management is primarily concerned with people.
Here are some useful resources that you can find on the area of project management and beyond:
"Project Management Body of Knowledge (PMBOK) Guide": This is comprehensive guide that outlines the best practices, standards, and processes for effective project management.
"The Art of Doing Twice the Work in Half the Time" by Jeff Sutherland: In this book, the co-creator of Scrum introduces the methodology and demonstrates how it can be applied to various types of projects, including entrepreneurial ventures, for faster and more efficient results.
"Ruthless Management of People and Profits" by Dan Kennedy: this is an excellent book that offers insights into effective management strategies to boost productivity, reduce waste, and increase profits in business so that all your projects can be successful. All team members must be required to read and agree with this material.
"The Effective Executive: The Definitive Guide to Getting the Right Things Done" by Peter F. Drucker: This classic book provides valuable insights on time management, decision-making, and effective delegation for business leaders.
"The Phoenix Project": by Gene Kim, Kevin Behr, and George Spafford: This novel follows an IT manager tasked with rescuing a failing project and provides insights into effective project management and good DevOps approach.
Skill 15: Cybersecurity
In an embedded software team, the responsibility of security typically falls on all team members, including system architects, software engineers, hardware engineers, and testers. Just like with unit/integration/system testing, security is more a habit rather than a chore.
It is surprising to see that even the most experienced C programming teams so
often overlook even the most basic security measures such as always using
snprintf instead of
sprintf where the latter one depends on data not being
garbled up in order to not crash the system (or worse become a security risk).
We can subdivide security into a number of distinct areas:
- Cryptography: understanding cryptographic techniques, such as encryption, decryption, and secure key management, to protect data confidentiality and integrity in embedded systems.
- Secure Boot and Firmware Updates: knowing how to implement secure boot processes and firmware updates to ensure the authenticity and integrity of the software running on the embedded device. This often involves developing secure over the air updates (FOTA).
- Authentication and Access Control: implementing robust authentication mechanisms and access control policies to prevent unauthorized access to embedded systems and their resources - including message broker security (such as MQTT broker).
- Network Security: security protocols and best practices for wired and wireless communications to safeguard embedded systems from network-based attacks.
Here are some resources about secure software development for embedded systems:
"Secure Coding in C and C++" by Robert C. Seacord: This book focuses on secure coding practices for C and C++, discussing common vulnerabilities and providing practical techniques to avoid security issues in embedded systems development.
"Security Engineering: A Guide to Building Dependable Distributed Systems" by Ross J. Anderson: This book covers a wide range of security topics, including cryptography, authentication, access control, and network security. It provides valuable insight into building secure systems in general.
- "LavaRand Cloudflare Random Number Generator": LavaRand ensures that Cloudflare’s network remains secure by providing an additional layer of protection in cryptographic randomness generation.
Skill 16: Machine Learning
Modern machine learning has come a long way from its roots in classical nonlinear model identification methods. With the creation of powerful computational resources (like GPUs and TPUs), advanced algorithms, and the availability of massive amounts of data, machine learning has evolved significantly over the recent years, enabling the development of highly accurate and sophisticated models for various applications which would take millions of years for human civilization to comprehend without machine learning.
In the early days of machine learning, researchers primarily focused on simpler techniques like decision trees, support vector machines, and artificial neural networks to model nonlinear relationships. These techniques, while somewhat effective, had limitations in terms of scalability, expressiveness, and the ability to handle complex data.
With the increasing availability of data and computational power, the field witnessed the rise of deep learning, which has revolutionized the way we approach nonlinear model identification and machine learning in general.
Deep learning focuses on the development of deep neural networks, which consist of multiple layers of interconnected neurons. These networks are capable of learning highly complex and hierarchical representations of data, allowing them to outperform traditional techniques in many applications, such as image recognition, natural language processing, and reinforcement learning.
The success of deep learning is attributed to its ability to automatically learn features from raw data, eliminating the need for manual feature engineering, which was often a time-consuming and challenging task in traditional machine learning techniques.
Combined with the massive amount of information that has been digitalized over the last 30 years, today we not only have the ability to train neural networks effectively but we also have all the data needed for effective training. This alignment of circumstances has been a major contributing factor to the explosion of deep learning.
We can divide machine learning into the following areas of knowledge:
- Adaptive Control: machine learning can be used to automatically adjust controller parameters for a conventional optimal controller based on real-time performance, improving system stability and responsiveness.
- Fault Detection and Diagnosis: Machine learning models can be trained to identify complex patterns leading up to faults or anomalies in a system by analyzing sensor data. The same concept can be applied to predict when maintenance needs to be done on a piece of infrastructure.
- Model Predictive Control (MPC): Machine learning models can be used to learn system dynamics and predict future behavior of the system, enabling the implementation of MPC strategies for optimized control and decision-making. In fact, the Kalman filter is a very basic and simple application of machine learning to filtering from a time when machine learning wasn’t as hot as it is today.
- System Optimization: Machine learning techniques can be applied to optimize system parameters and control strategies for improved efficiency, performance, and reduced energy consumption.
- Human-Machine Interaction: Machine learning models can be used to interpret and adapt to human input in control systems, improving the usability and safety of such systems as well as augmenting some of the functionality normally done by the human. Modern self-driving cars are an excellent example.
- Organizing Knowledge: one of the most recent advances in deep learning is modelling relationships between vast amounts of facts. Just like in the old days, Kalman filters were able to predict how a signal would evolve over time, modern deep networks are able to predict missing details from a rough sketch of the facts.
It is fascinating to see how the predictive models of today have evolved from rather basic mathematical principles and how we are able to extend these new models to predict uncertainties in the highly complex world.
Using the steadily growing volume of data that we can collect from widespread sensor technology (this is where IoT plays key role!), I believe that in the next quarter of a century humanity is going to be able to predict almost every event in the world with a steadily extending horizon.
Just like a Kalman filter can predict the next value of a signal in the presence of Gaussian noise, the neural networks are steadily improving towards being able to predict many other types of variables where the noise doesn’t need to be Gaussian to make a good prediction.
This means that if humans are able to pair together with AI, then this has an almost unlimited potential for humanity at large.
Here are some resources that you may find interesting on the topic of machine learning:
"Pattern Recognition and Machine Learning" by Christopher M. Bishop: This book covers machine learning techniques, including supervised and unsupervised learning, neural networks, and probabilistic graphical models. It provides a solid foundation for understanding pattern recognition and machine learning concepts.
"TinyML: Machine Learning with TensorFlow Lite on Arduino and Ultra-Low-Power Microcontrollers" by Pete Warden and Daniel Situnayake: This book offers an introduction to machine learning and TensorFlow Lite for embedded systems. TF-Lite is also supported on Zephyr RTOS making it a very useful framework for using tensorflow models on low power microcontrollers.
- "Deep Learning" by Ian Goodfellow, Yoshua Bengio, and Aaron Courville: This comprehensive book covers deep learning techniques, including feedforward neural networks, convolutional neural networks (CNNs), and recurrent neural networks (RNNs). It offers both theoretical and practical insights into the rapidly evolving field of deep learning.
This concludes the outline of the 16 most essential skills for building embedded systems faster than ever in the modern world where machine learning and continuous delivery play an increasingly important role.
By mastering these skills, you’ll be well-equipped to face the challenges of embedded systems development. This will not only help you create innovative and reliable products, but it will also open up a world of exciting career opportunities in this high-demand industry.
Remember, practice makes perfect, so keep learning and honing your skills through hands-on projects and courses.
If you don’t want to do all your learning yourself, you can explore additional books, courses and consulting services at swedishembedded.com to get help in building your embedded systems faster than ever before.
Books Courses And Consulting
Getting my content in book form is for you if you don’t care about video content, don’t want to go through quizzes and do not need personalized training. You can get the books below in digital form by simply downloading them on your Kindle app.
The main drawback of books compared to for example getting a student subscription here on this website is that books can easily get out of date and updating the file on Amazon doesn’t always work very well. So if you want to always have access to the latest content then getting a swedishembedded.com student subscription can be a far better approach.
- Modern Embedded Firmware Infrastructure: How to setup modern DevOps and continuous delivery infrastructure using Zephyr RTOS, CMock, Unity, RobotFramework and Renode by Martin Schröder: This book describes a process for setting up a comprehensive CI infrastructure for use with Zephyr RTOS with focus on continuous delivery. It also covers a number of testing methodologies using CMock/Unit and Renode with Robot Framework.
- Embedded C Programming Design Patterns: Essential design patterns for clean, maintainable and robust firmware development" by Martin Schröder: This book focuses on design patterns for embedded C programming and covers very useful techniques such as Virtual API pattern for device driver implementation as well as concurrency patterns such as semaphores, mutexes and conditional variables.
Courses are the right choice for you if you prefer listening to content and looking at slides as opposed to reading a book. It has been proven by research into learning that we learn only 10% of what we read while at the same time we retain 50% of what we read, hear and see at the same time.
- Ultimate Embedded Firmware DevOps Infrastructure: this course focuses on implementing key devops principles such as test driven development, trunk based development and continuous delivery specifically on top of the infrastructure already provided by Zephyr RTOS. It is designed to be following in parallel with looking at the actual code provided as part of Swedish Embedded Platform SDK which makes unit testing and simulation simple on Zephyr RTOS.
- Embedded C Programming Design Patterns: This course is based on the book above with the same name. It is a thought provoking course covering design patterns for C programming that make your embedded firmware robust and clean.
The research into learning further tells us that we retain 70% of things we see, hear and discuss compared to just 50% when we learn without discussing. To increase retention to 70% there is an additional option to get a Professional subscription at swedishembedded.com and join the weekly discussion calls live on Wednesdays.
If this is the option you want then you can subscribe by clicking on https://swedishembedded.com/#/portal/signup and choosing "Professional" option when you sign up.
Share this article
If you enjoyed this article, don’t forget to share it with your friends. You can reuse the following template on social media to link to this article:
The 16 Essential Skills Of Embedded Engineering This issue of the Embedded Insights newsletter (you can subscribe here: https://swedishembedded.com/#/portal/signup/free) outlines the 16 most essential skill areas of embedded engineering that can help you build embedded systems faster than ever. Here is a quick summary of the skills: - Embedded Systems Design: so you can build efficient and reliable systems through hardware-software co-design and good system architecture. - Programming Languages (C, C++, Assembly): so you can write efficient and maintainable code and optimize system performance. - Microcontroller Programming: so you can understand how to use the programmable hardware to its fullest. - Real-Time Operating Systems (RTOS): so you can ensure timely task execution and avoid inventing your own scheduling algorithms. - Electronics and Circuit Design: so you can design your own schematics and electronic circuits. - PCB Design and Layout: so you can build your own boards that work. - FPGA Development: so you can extend your existing digital hardware with fast custom peripherals. - Signal Processing: so you can filter and process signals efficiently using mathematics. - Communication Protocols (UART, SPI, I2C, CAN): so you can pick the right protocol for the job. - Control Systems: so you can build precision control into your application. - Sensors and Actuators: so you know what sensors and actuators you have available to you for interaction with real world. - Debugging and Testing: so you can avoid having to find the same bugs twice. - Software Development Methodologies (Agile, Scrum): so you can manage millions of lines of text effectively. - Project Management: so you can manage the whole product lifecycle. - Cybersecurity: so that your embedded devices are secure and robust. - Machine Learning and AI: so you can combine together human element and machine into a single whole. Whether you're a seasoned professional or just starting out, this article is a goldmine of information to help you build robust, efficient, and secure embedded systems. Don't miss out on this opportunity to boost your career and stay ahead of the curve. ==> Read the full article here: https://swedishembedded.com/insights-build-embedded-systems/ If you find the article valuable then like, share, and comment to help spread the word. #EmbeddedEngineering #Skills #EmbeddedSystems #RTOS #FPGA #Cybersecurity #MachineLearning #AI
Thank you for reading this article and I’ll see you in the next issue of the Embedded Insights Newsletter.