Simplicity Is Key: Designing Intuitive Devices Using Complex Hardware and Software
Stitching together the pieces—and solving interdependency issues the old-fashioned way— has no place in a billions-of-connected devices world—what’s the solution?
Few, if any, would dispute that the electronics industry is trending toward more complex embedded systems. In its recent report, Embedded Real-Time Operating Systems for the IoT, ABI Research stated: “The connectivity angle of the IoT means that software engineering plays an important role alongside mechanical solutions. Many of the challenges with deploying and scaling the IoT will be addressed using embedded systems and real-time operating systems (RTOS), which are ideal for supporting connectivity functions, especially wireless.”
Indeed, within the industry, we noticed the same thing a while back: The industry is trending toward more complex embedded systems, while developers are given shrinking schedules to deliver these products. Not only do embedded devices need to perform their desired operations, they must do so by taking into account safety, security, connectivity, upgradability, energy efficiency, and footprint constraints as well as a growing number of other considerations. In many cases, the complexity of the function being performed by the embedded device is dwarfed by the infrastructure software around it.
Take for example a WiFi-connected, over-the-air upgradable, cloud-connected thermostat that also contains a full graphics display. This device most likely contains an RTOS, a TCP/IP stack, a WiFi supplicant, SSL, encryption software, a file system, a graphical user interface, a touch screen interface, and a few other processor-hungry functions. The thermostat functionality is comparatively trivial when you think about it. Indeed, what used to be the job of a simple, low-cost 8-bit microcontroller (MCU) now requires a high-end 32-bit processor along with a long list of complex software modules and communications protocols.
Why is this happening? As consumers, we’ve been conditioned to demand more from our devices. It’s too hot? No problem, I’ll simply ask “Alexa” (Amazon’s Echo) to lower the temperature. Alexa samples my voice, sends the compressed samples to a server on the cloud that converts my voice to text, sends the command back to the thermostat, which makes the change, reports back to Alexa and, about two seconds later, Alexa says “OK.” Forgot to turn off the downstairs light as we are lying in bed? Alexa … “lights off” … “OK.” Amazingly simple to use, incredibly complex behind the scenes. Give it a couple of years and some of these repetitive commands will be processed locally instead of depending on having an Internet connection.
When you’re in the embedded software industry, you’re constantly struggling between two often opposite goals: On the one hand, change very little of the software because it’s proven and reliable. On the other hand, introduce new products to pursue new and challenging opportunities. The keys, I believe, are to: develop highly reusable and scalable software modules; be able to easily add modules whether from the same supplier, third parties or even customer-specific to the offering; and have a way to combine these modules to satisfy all the interdependencies these create.
There are additional complexities that embedded developers have to deal with, such as CPUs and MCUs from different manufacturers, different drivers for IP blocks, different toolchains, different evaluation boards from all the different suppliers/third parties and more. The permutations are practically endless, which makes embedded software design very complex.
At Micrium, we concluded a few years ago that manual configuration is becoming almost impossible—but it doesn’t need to be. Accordingly, we embarked on and recently released a JAVA-based tool to simplify embedded software design. The tool characterizes:
- Software modules (RTOS, stacks, file systems, GUIs, SSL, etc.)
- CPUs/MCUs (Cortex-ARM, RX, PPC, Nios, MicroBlaze, MSP430, etc.)
- Drivers (Ethernet, Wi-Fi, USB, SDIO, QSPI, I2C, etc.)
- Toolchains (IAR, Keil, GCC, etc.)
- Evaluation boards
- Example code
- Other embedded elements
The tool, called Platform Builder (Figure 1), significantly reduces the complexity of creating new products through a simple-to-use and intuitive user interface. A developer basically does these tasks:
- Selects the evaluation board you want to use
- Selects the toolchain
- This tells the tool which CPU/MCU you have on the board and, of course, knows the manufacturer of that CPU.
- The tool also knows what resources are available on the board, so, for example, will allow a user to add a TCP/IP stack if the board either has an Ethernet controller or a WiFi chip/module (but won’t allow it if it doesn’t).
- Selects the software modules needed for the project (RTOS, TCP/IP, file system, etc.)
- Optionally adds example code that shows how to properly use some of the selected modules
- Clicks on the “Export” button and all the source files needed for the project will be gathered from a cloud-based repository and copied onto the local machine. The project can then be imported into the IDE (Platform Builder currently supports IAR tools, but others will follow shortly).
- Startup code is created for the developer in the proper sequence based on the selected modules.
As the industry ramps up to the billions of connected devices that many research firms are predicting, developing embedded software simply cannot continue the old-fashioned way, i.e., putting all the pieces together and resolving interdependencies manually. This means developers need to use proven, reliable embedded software components, and leverage tools like the new Platform Builder. Why? Simplicity! This approach automates the creation of new products using components you know will work, that you don’t have to think about, and that you know you can trust. An automated approach will yield higher productivity gains and allow developers to explore “what if?” scenarios that would otherwise not be practical due to the growing complexity of embedded systems.
Jean Labrosse is the chief visionary for the Micrium product line, ensuring that it adheres to the strict policies and standards that have helped cement its reputation as a leader among embedded software components. Labrosse, who founded Micrium in 1999, is a regular speaker at numerous industry conferences. He is the author of three definitive books on embedded design. He holds BSEE and MSEE degrees from the University of Sherbrooke, Quebec.