How to be an Embedded Software Engineer: A simple guide to get started

how to be an embedded software engineer

Compared to other software roles, working with embedded software requires fundamental understanding of hardware systems. The ability to write software while considering available hardware resources is one of the core skills of embedded software engineers. 

Embedded software engineers often write code that runs closer to the hardware layer of a device. Therefore, having some familiarity with hardware systems is crucial. Any limiting constraints of the hardware must be paid attention to and embedded software engineers work on overcoming these constraints.

Learning to shift your mindset to always consider the underlying hardware layer is just one side to becoming an embedded software engineer. We’ll cover an overview of the fundamentals anyone interested in writing embedded software should know. Starting with the important role embedded software engineers play in the advancement of current and future technology.

Related: For a more general overview of embedded systems see our beginner friendly introduction to embedded systems.

Embedded devices are all around us and we interact with several of them in our daily lives. From your alarm clock to your washing machine to your car. Embedded software drives the functions of many devices we’ve come to rely on.

The presence of embedded devices means engineers who are able to write software for them will always be in demand. As long as electronics with embedded microcontrollers exist, embedded software engineers will always be needed.

Related: See our post on 11 interesting examples of embedded systems in daily life.

Future demand for embedded software engineers is also likely to grow especially with more devices becoming “smart” enabled. We are increasingly seeing embedded software driving more devices and technologies each year. 

An example of a device that is now commonly smart enabled are LED light bulbs. Before smart bulbs were a thing, light bulbs were essentially “dumb” devices with only one function – light on, light off. 

Now we have smart bulbs with programmable colour changing features that can connect to your smart home system. The transition from being “dumb” devices to being “smart” means they now have integrated microcontrollers that require software to drive these functionalities. Light bulbs are just one example of a device that’s become smart enabled by embedded software.

Looking outside consumer electronics, the automotive industry is another area seeing immense increase in the use of embedded software. Cars are increasingly packed with more electronics compared to vehicles from just a decade ago. This includes built-in GPS, auto-braking, entertainment system, self-driving features and so on. Cars now commonly contain dozens of microcontrollers driving different functions, essentially making them a moving collection of embedded devices.

Now we know why embedded software engineers will continue to be a very in demand role, let’s go through the basics of what you need to get started.

Fundamental skills of embedded software engineers

1. Get comfortable working with hardware

embedded software engineer hardware

Engineers who end up writing embedded software tend to have a background in Electrical/Electronic Engineering. This is because understanding the hardware of electronics is the main factor that separates embedded software engineers from application software engineers. 

So to get started with embedded software or if you want to make a switch from writing application software, the first step is to get more comfortable working with hardware. 

You can start by building simple electronics to get an understanding of the various types of electronic components and how to put basic circuits together. 

As well as building physical circuits you also need to be familiar with the basics of reading schematics. Schematics are drawings that visually represent how electronic components on a circuit board are physically connected.

Example of a Schematic drawing. A Schematic is a simplified representation of a circuit board. (Source)

You also want to start getting a bit familiar with looking at PCB (printed circuit board) layouts of circuits. While schematics show a simplified representation of the components and connections on a circuit, PCB diagrams show a closer representation of how these components and connections will look like in it’s real-life physical form.

Example of a PCB layout. Compared to a schematic drawing, this represents the real physical layout of the circuit. (Source)
3D drawing of the PCB showing how it will look like when manufactured and with components populated. (Source)

Ideally, embedded engineers should have some level of experience creating schematics and PCB layout even if it’s just a very simple circuit for practice. There are free EDA (Electronic Design Automation) software such as KiCad that you can use to start building simulated circuits and learning about schematics and PCB designs. Also checkout this list for more options for more free EDA software you can use.

If your focus is on learning embedded software and not hardware design, then it’s not essential to go in depth into the knowledge of how to create schematics and PCB layout of hardware. What you need to get started is being able to read schematics diagrams of electronic devices. This should be enough at the start to get you started with writing embedded software.

2. Learn languages suitable for embedded programming

embedded software engineer programming languages

When writing embedded software, the developer must pay attention to the available resources of the device’s CPU. As a result, languages that run at a low-level are ideal for writing code for embedded devices.

“Low-level” refers to programming languages that are designed to be more efficient at translating instructions to the hardware layer of a device. They are suitable for writing embedded software as they use up little resources compared to “higher-level” languages and can be optimised more effectively to run on hardware with low processing capabilities. 

The most common language you’ll come across that’s used for embedded software is C and closely followed by C++. Python is also creeping up in popularity as an option for writing embedded code. 

Keep in mind there are even lower-level languages like Assembly and Machine code that work much closer to the hardware layer. These languages are used by engineers who write software for compilers and code optimisers.

Also note that embedded software is often referred to as firmware and is a term you’ll hear a lot when working with embedded engineers. Firmware is used to describe software that runs close to the hardware layer of the device and provides low-level control. Firmware is another label used to describe embedded software and emphasises the fact that when writing embedded software, you must learn to work with both hardware and software simultaneously.

3. Get familiar with challenges of writing embedded software

When you begin writing embedded software, you’ll quickly realise there are several challenges unique to this field of development. When you come across a problem you can no longer be sure the issue is entirely software related. 

Is it the hardware that’s defective? Or my code? Or the test equipment? Or the wiring???

These are just some of the questions you’ll find yourself asking in the process of developing for embedded devices!

The close involvement with hardware means you’ll now need to consider hardware components in every aspect of your software implementation. It will take some getting used to, but the best way to learn is to come across these challenges yourself and learn through your mistakes.

As well as the extra consideration when debugging issues, there are also design challenges you’ll come across depending on the type of application you’re developing for.  

Here are some examples of the types of embedded applications you can work with and the challenges associated with them.

Devices using low-bit microcontrollers (8/16-bit): Applications requiring low processing capabilities. 

Examples: Alarm clock, keyboard, mouse, key fobs.

Challenges: Low memory space, optimising performance.

Battery and low power: Applications that run on battery and must be designed to last long enough while meeting the applications processing requirements. 

Examples: Smart watches, remote controls, wireless sensors.

Challenges: Battery life, sleep management.

Connected devices / IoT: Applications that provide wireless connectivity between smart devices. 

Example: Alexa/Google home, thermostats, security camera systems.

Challenges: Latency, security.

Industrial level / safety critical systems: Systems designed with safety and reliability as absolute essentials.

Examples: Motor vehicles, traffic light control, aircraft control, medical equipment.

Challenges: Safety, complying with strict standards (e.g.MISRA C standard)

There is of course also cross-over of challenges across different applications. For example, a security camera system is a connected device that can be battery powered. In this case meeting all the challenges for wireless and battery devices applies in it’s design.

Become familiar with the challenges associated with writing embedded software for the applications you want to develop for.

Beginner friendly embedded software learning platforms

embedded software engineer learning platforms

To get started with Embedded design you can learn to write software for a target hardware platform. Devices such as the Arduino, Raspberry PI and Beagleboard are some beginner friendly platforms you can use to get started with learning the basics of building circuits and writing embedded software. These are known as hobbyist platforms to learn electronics and programming. However, they are also more than suitable for students and professionals who want to develop their skills in embedded programming. 

The reason why these devices are great for embedded software design is because they provide a GPIO (General Purpose Input Output) Interface. GPIOs are pins that provide you with access to some of the internal hardware components of a circuit board. Take a look at the GPIO on a Raspberry PI:

Raspberry PI GPIO drawing. (Source)

This GPIO wiring diagram tells us the pins that connect to various hardware components on the circuit board of the Raspberry PI. Through these pins you can connect from/to components and build circuits you can then manipulate by writing code that interacts with these components.

Getting your hands on a hardware platform such as the Raspberry PI and writing some C code to manipulate the GPIO pins is a great way to start learning the fundamentals of writing embedded software. (The Raspberry PI is also a handy mini but powerful computer to have around!)

However, there are other available embedded based hardware platforms which you can explore programming on. Do some research and find some other platforms you can use depending on the type of embedded applications you want to learn to write code for. 

Conclusion

Working with embedded software usually requires a certain set of skills compared to other software engineering roles. We’ve introduced you to the fundamentals skills you need to get started as an embedded software engineer. 

If you’re set on entering the world of embedded, learning to get comfortable with hardware systems and concepts is where you need to start. At the same time, you can also learn to write code using languages such as C. Getting a hardware platform such as the Raspberry PI that will provide access to basic circuitry you can control is an ideal place to start.

Did this help you figure out how to get started with becoming an embedded software engineer? If you’ve already started with writing embedded software what advice do you have for those new to it? Leave a comment below!

Did you find this article useful? Checkout other related articles: