Calculating..Register to attend

Embedded Firmware Platform SDK

Find out more about being able to support 400+ boards and simulate 160+ devices out of the box using Swedish Embedded Platform SDK

The Swedish Embedded Platform SDK is a complete firmware development framework for developing, simulating and testing embedded firmware.

It consists of two parts:

Docker image includes all the compilation tools you need in order to start developing embedded software and for running your build process. You can see exactly what packages are included here and here.

The second link is to a docker configuration file that adds tools for writing code as well. You can of course use any editor you want (including VSCode or Eclipse). There is no rule forcing you to use Emacs.

The docker image together with the SDK (which in turn links to Zephyr, Renode and other tools) provides you with a powerful workflow where you can:

  • Build your application on a powerful RTOS platform: support for Zephyr RTOS is integrated into this SDK - so you get existing cross compilation support for over 400 different boards.
  • Simulate and debug your application without physical hardware: we provide full simulation capability with ability to model networks of devices and running automated test scenarios as part of your CI workflow (provided by this SDK).

We combine the above with embedded firmware consulting where we help your team get up to speed quickly with simulating your hardware and provide support in the form of platform development and training so you don’t have to do it all on your own.

Is this SDK right for you?

This SDK is for you if:

  • You are building a hardware product: and you need to quickly build firmware for your product. You can not afford to have to implement all functionality and infrastructure on your own.
  • You want to migrate to a proven system: Zephyr RTOS is the only RTOS that implements the high standards required by Linux Foundation, making it a good choice for all new development. SDK helps you not only migrate to Zephyr RTOS but also more easily implement testing infrastructure for your new firmware.
  • You want to implement automated firmware verification: you have probably tried doing it before and discovered that it was hard. This SDK provides simulation and unit testing tools that make this task many times easier.

Problem Of Embedded Firmware Testing

Modern web developers have a fantastic tool ecosystem available to them (such as selenium) that make UI testing easy. Embedded firmware development has been much slower at developing similar tools.

Firmware testing usually is either non-existent, or very limited to only testing high level application concepts and hoping for the best with the rest of the software.

There are numerous reasons for testing being problematic in the context of embedded systems and here are just some of the reasons for that:

  • Embedded software runs directly on hardware: thus we can not really test it fully without some form of simulation of our code that can simulate hardware.
  • Embedded software almost always requires C: even if you are running a virtual machine, you still need to code it in C and it needs to be tested and traditional development patterns used in C do not make it easy to verify.
  • Modern embedded devices exist as networks: devices often interact with other devices and to test them we need to simulate this interaction as well.

Traditionally physical hardware was needed in order to do end to end verification - but this is no longer the case!

Lack of verification means your code probably doesn’t work

Programmers often believe that if they are good enough then they can write code that is infallible. Unfortunately, in practice this is almost never the case.

The very volume of programming decisions that are taken each day while writing code quickly result in a bigger picture that is very difficult to fully comprehend.

In addition, a fast pace of development means that functionality that may have worked when it was written can easily become unintentionally broken unless it’s behavior is always being monitored automatically.

Try looking at your existing code and answer the following:

  • What features can you guarantee are working at any given time? - Can you list them with mathematical precision? Can you easily describe how they are being verified?
  • Can you currently be fully sure that your firmware works after each and every change is made? - when you merge a change each day, can you be fully sure that it did not break anything else? Is your software always in a deliverable state?
  • Can you verify multi-device interactions automatically? - Is it possible to do this today using your current development workflow for each and every commit each and every day?

This highlights only some potential problems.

The biggest of these problems is that tracing and debugging multiple embedded applications simultaneously as they interact with each other can quickly become a very complicated task.

Unless you have software tools that help you do it!

Integrated simulation, visualization and testing

Swedish Embedded Platform SDK makes development, simulation and testing of embedded firmware a single straight process.

Combining multiple verified technologies into a workable workflow and automating it fully is a very easy way to ensure that your embedded firmware development flows smoothly.

The SDK provides answers to problems observed during years of experience in developing embedded software.

Here are just some of the benefits that Platform SDK offers:

  • Easy to build your firmware for many platforms: adding new platforms and cross compiling your application easily is very important.
  • Easy to add simulation and visualization: by using instruction set simulation and providing an easy and standardized way to add custom behavior into the automated build process means that simulating complex multi-node systems and verifying them automatically has become extremely simple.
  • Easy to adopt to existing system: the SDK is an extended build system that integrates simulation and testing as part of the build process. Existing code and libraries can be added quite easily.

Extensive Hardware Support

After the chip shortages following 2020, it is more important than ever to design embedded software that can be easily ported to new hardware without having to rework a lot of hardware support.

Swedish Embedded Platform SDK leverages the Zephyr RTOS ecosystem to provide you with open source support for more than 400 different boards using multitude of different architectures.

Here are only some of the hardware platforms supported:


Porting your application to a new hardware becomes a matter of implementing a handful lines of code instead of reworking your whole application. The overall build infrastructure then ensures that you must follow precise patterns of implementation which make porting your application very easy.

From Products To A Platform

Traditionally, chip manufacturers were focusing on providing proprietary SDKs which often contained binary components which were not open source. This has often led customers to face difficulties when bad design in the software was not easily changeable.

Swedish Embedded Platform SDK is open source, eliminating this class of issues entirely. Using Swedish Embedded Platform SDK you can develop your own business specific SDK and provide a platform for you to build on.

This doesn’t necessarily mean that everything about the SDK needs to be publicly open source - but as a consulting client you always have full access to all code delivered to you - and you have right to modify the platform to your own needs if you want.

You can even offer up the SDK as part of the platform to your own customers thus providing them with more than just your hardware product - an application platform for innovation.

Simulating Hardware And Software

The SDK is designed in such a way that you can develop embedded software entirely without requiring access to physical hardware. This is not just excellent from a development perspective - it also means that you are not limited at all when testing features as part of your CI process.

Hundreds of devices and boards can be easily simulated using existing peripheral support and new peripherals can easily be added using scripting.

Swedish Embedded Platform SDK is a complete simulation and development environment for building embedded firmware. Even if you already have existing code, the SDK helps you keep that code up to strict coding standards where you will have to make sure that everything has been properly reviewed and tested. With simulation driven testing we can for the first time truly achieve arbitrarily thorough test coverage.

Cross Platform Verification Made Easy

Managing multiple board revisions and multiple target architectures can be a daunting task. As new product versions are added, the complexity usually increases exponentially because now you must test on many more permutations of configuration options than before.

To keep the complexity at bay, one needs automation. This includes CI automation and test automation.

Swedish Embedded Platform SDK makes powerful open source automation tools available to you in your firmware development with emphasis on ability to simulate your production firmware in full. This is accomplished by extending open source Zephyr RTOS kernel and extending the powerful Renode hardware emulator to make sure that these tools can be used together seamlessly as part of your development process.

Adding on top of that a visualization framework that runs in your browser truly makes for a complete embedded firmware development and debugging environment.

Built on widely recognized technology

The Platform SDK builds on years of experience in building embedded software and the problems and challenges of doing it. Many problems have been solved through relatively recent systems such as Zephyr. This is a good thing. But many new challenges have emerged as well.

With the recent ability of the Renode simulation framework to simulate multinode testing scenarios means that all limitations in simulation and testing of embedded systems is now a thing of the past. We can extend and build on these findings to create bigger and more robust networks of connected devices.

Fully open source development platform

This includes:

  • Excellent connectivity options: LoRaWAN, LwM2M, CANOpen, MQTT etc.
  • Excellent hardware support: including 400+ existing boards and a multitude of hardware architectures.
  • Fully open source ecosystem: there isn’t a single component that is closed source - everything is open source.
  • Integrated support for advanced simulation and testing: using Renode and CMock.

Your firmware can not wait

If you are thinking that you can wait until later to get simulation and testing in place. It is indeed a common thought so you are not alone.

The downside is that issues in code tend to compound the more code you have. A simple lack of proper design pattern multiplied by the number of files in your project can quickly become a huge problem.

A workflow without possibility to run user acceptance tests for each commit is a ticking technical debt where problems accumulate without you knowing.

Each time your developer needs to manually perform testing procedures on your physical hardware is time that could have been better spent on software.

So partner up with us and we will help you get started right away!

Schedule an introductory call

So what are you waiting for? Click here to book a call!