Hardware Choice is Key: How to Pick the Right Platform for Your Project
When it comes to choosing the right board or System on Module (SoM) for your software project, the sheer number of options available can feel overwhelming. Whether you're building a simple embedded application or a complex, resource-intensive system, the underlying hardware you select plays a crucial role in the performance and functionality of your final product—often in ways that aren't immediately visible.
In this blog post, we’ll walk you through the key concepts behind why there are so many choices and how these decisions can subtly influence your software’s behavior. We'll take a bottom-up approach: starting with the core components of any board and gradually building up from there until your application is up and running.
It’s a deep dive, so buckle up and stay with us as we explore the hidden intricacies that can make or break your project.
The Core of Your Board: The System on Chip (SoC)
Embedded boards differ from traditional PCs in several key ways. For instance, in a PC, the Central Processing Unit (CPU) sits on the motherboard, which also provides the RAM, storage, and peripheral connections. These components are typically modular, connected either directly on the motherboard or via plug-in cards.
In contrast, an embedded system typically uses a System on Chip (SoC) — a single silicon chip that not only integrates the CPU but also a wide range of other components. These can vary widely depending on the specific SoC.
For example, an SoC might include a Graphics Processing Unit (GPU), machine learning capabilities, video encoders/decoders (e.g., H.264, H.265, VP8, VP9), and a variety of peripheral interfaces such as USB, UART/serial ports, CAN, PCI Express, Ethernet, Wi-Fi, Bluetooth, audio, video, and even camera connections. It may also have integrated memory controllers, Trusted Platform Modules (TPM), watchdog timers, PWM controllers, JTAG, and temperature sensors — the list can go on and on!
While the variety is vast, each SoC is unique, and what’s available will depend on the specific version you choose. Some SoCs offer multiple configurations for these peripherals, which means you can choose the right mix of features for your needs.
However, there’s more to consider: SoCs still require external integrated circuits (ICs), such as additional RAM or non-volatile memory (e.g., eMMC or NAND). This external circuitry is crucial and will become important later in the discussion.
Pin Multiplexing: The Art of Choosing Peripherals
Another key aspect of SoCs is the number of pins they offer. Some SoCs have only a few pins, while others provide a large number. This presents an interesting challenge: how can you access all the features of the SoC? The answer is pin multiplexing.
Pin multiplexing allows a single physical pin to be used for multiple functions. For example, a pin may serve as a UART (serial port) or an I²C connection, depending on the configuration. It’s up to the hardware integrator to decide which functions will be assigned to which pins. And here’s the catch: you can’t expose every peripheral at once. For example, if an SoC has 4 UARTs and 2 I²C peripherals, and the integrator opts to use the 4 UARTs, you might lose access to the I²C interfaces. This is a crucial consideration when designing embedded systems.
Navigating the SoC Landscape: NXP Example
So, how many SoC variants are out there? Let’s take a look at just one vendor — NXP — to illustrate the range of options available. At the time of writing, NXP offers four main families of ARM processors, each tailored for different applications: applications, automotive, edge computing, and vision.
For this example, let’s focus on the i.MX application processors. Within this family, there are six distinct product lines, including the i.MX 6, 7, 8, and 9 series. While these are generally aimed at similar applications, there are still differences between them. Let’s dive deeper into the i.MX 8 series, which offers eight distinct variations!
These variations support a broad range of use cases. For example, if you need an industrial application with minimal user interface, the i.MX 8M Mini may be the ideal choice. However, if machine learning and a powerful GPU are required, you might opt for the i.MX 8M Plus. If we zoom in even further, we see that the i.MX 8M Plus itself has 12 different variants, offering options in terms of packaging and internal capabilities.
The bottom line is that the number of SoC options is vast, and the flexibility offered by vendors like NXP allows for highly tailored solutions. So, before diving into your next embedded project, remember that choosing the right SoC isn't just about the CPU performance — you’ll need to consider the available peripherals, the number of pins, and how you’ll configure them.
Still feeling confident after reading the challenges above and think you can tackle your own, completely custom design? Great! Here are some of the key components you'll need to carefully select:
SoC Vendor, Type and Family
You'll need to pick a system on chip (SoC) that not only fits your needs but also has the necessary peripherals and capabilities—and ideally, can handle them all at once.
SoC Packaging
The packaging of your chosen SoC should align with your production process. It's a practical consideration that can influence both design and manufacturing.
But that's just the beginning. You also need to consider:
The Right RAM Modules
Choosing RAM that suits your performance requirements and works seamlessly with your SoC is crucial.
The Right Non-Volatile Memory
While eMMC is the standard these days, there are still plenty of options to explore, depending on your project needs.
The Right Oscillator
This is critical for ensuring your system runs at the right speed and stability.
Note that this short list of things to consider barely scratches the surface!
And of course, all of this has to be paired with a solid Printed Circuit Board (PCB) Design. While wiring up a low-speed UART might be straightforward, handling complex components like RAM or video displays? That’s a whole different ball game.
But wait, there's more! Your device will likely need a few more key elements, such as:
Ethernet PHY for network connectivity
CAN Transceiver if you're planning on using Controller Area Network (CAN) communication
UART to Serial Converter to facilitate serial communication, if required.
Did we mention that the SoC comes with this stuff? Yes, SoCs generally come with basic circuitry to handle core tasks. But here’s the catch: they typically operate on specific voltage levels—1.8V, 3.3V, or 5V—while your peripherals may need different signals. This means you’ll likely need additional circuitry to adapt those signals to match the peripherals you want to connect. It’s all part of the integration puzzle.
More Considerations: Bootloader, Linux Kernel, OS
Before we jump into your application, there are a few more pieces to consider. The first is the bootloader. The bootloader has a crucial job: it needs to initialize the basic peripherals (like RAM and the CPU) to allow the kernel to load later on. It also has to be aware of every peripheral in your system—Ethernet, UART, GPIOs, SD cards, etc. This is typically managed through a device tree file.
Once the bootloader gets things started, it’s time to hand things off to the Linux kernel. Like the bootloader, the kernel also relies on a device tree to describe the full set of peripherals it will control. But we’re not done yet—next comes the device drivers. These are responsible for making sure the kernel can communicate with and control all the hardware components.
At this point, we're still missing the rest of the operating system (OS). From system to your final application, even a minimal software stack involves hundreds of different software projects, all fine-tuned to achieve your specific goals. This collection of software is what we call a Linux distribution or distro.
Custom Design vs. System on Module (SoM)
So, do we start from scratch? In theory, yes, you could start from scratch. But in practice, most of us don’t. SoC vendors often provide development kits, which include a basic setup for bootloader, kernel and OS (a distro). These kits serve as a starting point, and while they’re useful for building out your project, SoC vendors typically use them to showcase their hardware's capabilities, not necessarily to offer a stable, up-to-date distro for long-term use.
This is where Systems on Modules (SoMs) come into play. SoMs are essentially pre-assembled, ready-to-go systems that provide a basic, working setup, including an updated software stack and hardware you can use to expand your design. SoMs typically include the essentials: a SoC, RAM, non-volatile memory, and core peripherals (like WiFi or Bluetooth), all mounted on a PCB. The module connects to a carrier board that supplies power and any extra connections needed for your specific project.
The big question: why would you use an SoM instead of designing your entire custom PCB from the ground up? Here are some key benefits:
Pre-Integrated, Maintained Software
SoM vendors handle the heavy lifting of basic functionality and keep the software stack up-to-date, including patches for any hardware-related issues (e.g., if a WiFi module is discontinued). This significantly reduces your development time and risk.
Development Kits and Schematics
Most SoM vendors offer development kits with carrier boards that showcase their module’s capabilities. They also provide schematics to help you design your own system based on their modules.
Offload the Integration Effort
SoMs take on much of the integration work—both hardware and software—so you don’t have to worry about getting everything working together from scratch. The better the SoM vendor’s design, the more likely they are to attract customers.
Scaling Up Production
SoMs are fantastic for projects that don’t require massive production volumes. If you're producing fewer than 5,000 units per year, SoMs are a great choice. However, if your production runs are going to be much larger, you might want to invest in custom hardware and software development to optimize costs and control.
SoM Pin Families and Interoperability
SoMs typically come in what’s called "pin families." This means that modules within the same family have a standard connector with a fixed number of pins. The idea is to ensure that different SoMs in the same family are compatible with each other, as long as you don’t need to change how the pins are mapped (known as pin multiplexing). Keep in mind, not every SoC exposes the same set of peripherals on every pin, so you may run into issues when switching SoCs within the same family.
Hardware and Software Differences
Hardware isn’t the only thing that differs between SoMs. Software, too, can vary. Let’s look at SecureBoot, for example. While SoC vendors typically include hardware and software that enables SecureBoot functionality, it’s often up to the integrator (whether it’s you or the SoM vendor) to implement it properly.
There are no universal "gold standards" so each SoC or SoM might require a slightly different approach. This is another area where SoM vendors add value by offering pre-integrated, almost ready-to-use solutions. When issues arise, the SoM vendor can fix them once, and everyone benefits. Plus, with a larger customer base, they’re more likely to identify and resolve issues faster.
As you can see, designing a custom system involves a lot of moving parts. It’s an exciting challenge, but one that demands attention to detail and careful consideration at every step.
The Final Step: Handing Off to Application Developers
So far, we’ve covered the heavy lifting required to build an embedded platform. If everything has been done correctly, application developers can take the reins and begin crafting the features that will truly differentiate your product, all while largely avoiding the complexities of the underlying infrastructure. This is the moment when your project’s "secret sauce" begins to take shape—shifting from a solid foundation to the real innovation that will set it apart.
Key Takeaways
Not all embedded boards are created equal, even if they use the same SoC. There are countless factors at play between the selection of the SoC and the final application, making it essential (but not easy) to choose the right path for your project from the outset.
Ultimately, the goal is to create a solution that allows application developers to work with minimal concern for the underlying hardware details — to the point where they feel like “all boards are the same.” Or, at the very least, very similar. A well-designed system will abstract away the complexity, enabling developers to focus on what matters most: building great applications.
If you’d like assistance choosing the best platform for your next project, get in touch. Our experienced team is ready to meet your ever-evolving software architecture and technology needs and help you turn your ideas into high-performance embedded, connected and mobile products. Explore our platform services.