Top 12 Embedded Design Skills for New Developers

The electronics industry will soon be in desperate need of new designers, which includes PCB layout specialists and embedded engineers. For a new engineer, embedded is the perfect intersection between building hardware and software. In embedded systems design, a developer needs to know a little bit about the hardware they are working with, and they need to be able to write code for an application. But what other skills are important to ensure success in the workplace?

In this article, we’ll cover some of the most important skills embedded engineers need to know in the modern electronics design world. Embedded designers will have to work closely with PCB layout engineers and electrical engineers, so their skill set relies heavily on gaining information from both groups. As we’ll see, the required skill set goes far beyond learning programming languages and developer resources from semiconductor vendors.

Top 12 Embedded Design Skills

The embedded design skills in this list include many skills that are demanded in both the software world and the hardware world. Many hardware developers can lead a double life as software developers because some of these skills cross over into both areas. If you’re a new developer, and even if you don’t plan on working in electronics professionally, make sure you learn these embedded design skills.

1. C/C++ programming

This is the flagship language used to write applications for most chipsets. In addition, there are many IDEs that provide full support for C/C++, including vendor IDEs that can compile C/C++ code into a HEX or BIN file. Many open-source projects and vendor development libraries are written in C/C++, so it’s important to also know how to integrate these resources into your program.

2. Python Programming

Recently, Python has emerged as one of the major languages used by software developers for building desktop apps, web apps, and even mobile apps with some add-on packages. Now some microcontroller IDEs will support MicroPython, a programming package that uses the Python language applied to firmware development for microcontrollers. As Python continues to see more adoption among traditional software companies, an understanding of this language will make you that much more valuable to employers or as a freelance developer.

3. Algorithm Optimization Skills

Once a core algorithm has been developed and validated, it’s important to understand how to optimize it. Algorithm optimization refers to eliminating redundant or unnecessary computational steps in the algorithm. The idea is to reduce the total computational effort to implement an algorithm on an embedded system. Some algorithms may be simple enough that an extra step will not greatly increase workload. However, advanced embedded systems can implement complex algorithms that need to be completed with minimal time and compute; make sure you know how to spot repetitive steps in an algorithm so as to not waste compute resources.

4. Reading Schematics and Pinouts

This is a basic skill for anyone that works in electronics, including embedded developers. An embedded systems designer may need to participate in a front-end design review by carefully reviewing schematics to ensure the required connections are made between components. This may also be needed as part of system testing and debug once a prototype design has been built and programmed.

5. Digital Signals and Timing Diagrams

This might sound like a broad requirement, but understanding how digital signals transition between levels, and how to read timing diagrams, are extremely important for communicating with a board designer. If you understand signal behavior, you can communicate those requirements to the PCB layout engineer, who can then determine whether high-speed design requirements and controlled impedances are needed.

A motherboard like this may be deployed in an embedded system, and the developer needs to know the important digital interface requirements to communicate to a PCB layout engineer.

6. Common Digital Interfaces

Embedded systems based on microcontrollers or embedded CPUs will commonly use a set of standard digital interfaces to source and receive signals. This is another important part of understanding the basics of digital signaling standards and interfaces in an embedded system and in digital components generally.

Over time, the electronics industry has largely converged to a set of serial interfaces that are most commonly used in embedded processors and ASICs. The four most common single-ended serial interface are:

• Serial peripheral interface (SPI)
• Inter-integrated circuit (I2C)
• Universal asynchronous receiver-transmitter (UART)
• Configurable GPIOs

The embedded developer needs to know how to implement the required interfaces in the product’s application, as well as in any peripherals that will appear in the device. Depending on the component, these interfaces might operate with very fast edge rates, such as in an FPGA. Some microcontrollers will use less advanced logic and will naturally operate at slower edge rates. The PCB layout engineer and the embedded developer should both know the interface requirements, both for PCB layout purposes and for timing purposes.

More advanced embedded systems will use high-speed interfaces, depending on the range of possible components and peripherals needed to support the main chipset. These interfaces include:

• Various types of Ethernet routing (MII, RMII, SGMII, etc., usually up to 1 Gbit)
• USB (most commonly USB 2.0, but newer systems are using USB 3.0)
• DDR2 or higher
• PCIe (usually Gen2 or higher)
• SerDes (may not be standardized)

For more complex components like FPGAs, you will need to know some additional interface requirements so that these can be communicated to other engineers. The most important interfaces in high-speed systems will be mostly differential, so additional high-speed design requirements for differential pairs (length tuning and spacing, etc.) are needed to ensure the board functions correctly. An embedded designer needs to know what differential interfaces are and how to spot them in a datasheet, schematic, and block diagram.

7. Basic Linux Installation and Commands

Some embedded systems that you will interact with, even if the embedded application is part of a standard reference design, will be based on a Linux distribution. The firmware for most networking equipment and single-board computers (comprising a huge range of systems) will most likely be built on a Linux distribution. At the basic level, you’ll want to know some of the basic Linux commands that are needed in the terminal. At the advanced level, you may need to build and install a Linux distribution on a new system.

8. Basic Terminal and SSH Applications

Because so many systems may run on Linux (either a full or reduced version) or on a real-time operating system (RTOS), you may need to open a terminal with an SSH tunnel in order to communicate with the device using a computer. Some

• TeraTerm - Allows TCP/IP connections to an embedded system, or serial connections through a COM port
• PuTTY - Provides the same functionality as TeraTerm, but with more connection options
• Git Bash - Used as a Linux-based command prompt on your local machine
• WinSCP - Can be used for file transfer to a remote system with the same connection options as TeraTerm and Putty, but it includes a GUI

These are not the only terminal applications, they just happen to be the most common; there are many other free terminal applications available online. Among these four applications, only WinSCP is fully-GUI based, it has no terminal and is only used for file management.

9. Flashing and Debugging Tools

Different processors and memories support different sets of development tools, some of which may be provided by a component vendor. Other flashing and programming tools are developed independently and can be used to load a firmware image into memory. Make sure you know how to use some of these common developer tools so that you can flash and debug your system. These adapters can plug into a computer over USB and will include a desktop program that allows the device to be flashed and configured.

Some debug tasks are performed by putting the system into debug mode through a serial connection over a COM port (UART connection). When the device is placed into debug mode, it will send operational and error information over the serial connection, and this can be viewed in a terminal window on a computer. This may require a small COM port adapter, like the USB-to-UART adaptor stick shown below. These converters can be purchased online for about $10 or less.

USB-to-UART interface converter.

10. Version Control Systems

When working on an embedded project in a professional setting, each revision to the project needs to be stored and changes tracked in a centralized system. This is where version control systems are used to keep track of data and, if needed, clone or restore an earlier version of the project’s source files. The most common of these systems is Git, which was originally developed by Linus Torvalds (the creator of Linux).

11. Basic Web Development

This one is probably unexpected, but many embedded systems need to interact with a cloud service or a web server. Understanding how to send and receive API calls, common data formats like JSON, how to build and implement an API, and even some database functionality like SQL are very useful for embedded developers. Even if you don’t know how to do all of this, being able to communicate these requirements with a web developer is hugely valuable.

12. Soft Skills

Last but not least, there is one set of skills that is in extreme demand among developers, and yet these are not something easily taught in classes. These are so-called soft skills, which are largely non-technical.

Embedded design requires clear and concise communication, the ability to work on a team, managing tasks and deliverables, and strategies for learning new information quickly. Embedded developers will do much more than just write code, they need to work alongside engineers and PCB designers to collaboratively build a new system. The communication aspect is most important as it is common for PCB designers and electrical engineers to be less-knowledgeable about the code development challenges in an embedded system.

The above list is not comprehensive, and more advanced systems will require additional skills for success. However, this list should help new developers better understand what they need to know in order to get started building embedded systems.

When you’re starting to work with electrical engineers on embedded design projects, make sure you know how to read and modify schematics using OrCAD, the industry’s best PCB design and analysis software from Cadence. OrCAD users can access a complete set of schematic capture features, mixed-signal simulations in PSpice, and powerful CAD features, and much more.

Subscribe to our newsletter for the latest updates. If you’re looking to learn more about how Cadence has the solution for you, talk to our team of experts.