Editor’s note: This three-part series looks at building more-effective smart devices. Part 1 discusses low-power design techniques for balancing power and performance. Part 2 addresses meeting the challenges of user transparent security. Part 3 (here) reviews the MCU specifications required to meet the design objectives.
Users expect smart devices to be highly capable, secure, and have extended battery life. To help meet these expectations, developers now have at their disposal MCUs that not only provide sufficient low-power performance and memory to meet immediate feature requirements, but which also enable secure updates for feature enhancements and bug fixes.
With MCUs forming the heart of wearables, IoT devices, and other smart portable products, it’s critical they have the right mix of high-performance and low-power to execute increasingly sophisticated software applications in small form factor products while minimizing battery drain. Along with assurance of security, long operating life and ease of use are critical to the user experience.
This article will show how to meet these requirements using a well-supported, off-the-shelf MCU line from Maxim Integrated.
Defining a good user experience
In many ways, users’ requirements are not fundamentally different from those that developers have worked to meet in the past. Yet, designers face a critical difference in acceptable solutions for emerging smart products. Users increasingly expect products that are compact, lightweight, and fit comfortably on their persons, or sit unobtrusively in their homes or businesses. Users are more likely to accept a smart product that does not demand undue attention or require cumbersome operations to use, recharge, and update, while remaining secure.
Along with ease of interaction, users expect smart products to retain much of the same size and appearance – including “style” – as conventional products that provided similar functionality. Users will be more likely to accept a fitness wearable, for example, that more closely resembles a bracelet or wristwatch than a strange-looking device attached to their wrist.
Of course, products that pass the test for ease of interaction and style can still fail if they are unable to deliver sufficient value to the user. A stylish wrist wearable that offers little useful information is nothing more than an expensive wristband. A certain level of invisible intelligence is required to allow technology and style to dovetail.
To implement this invisible intelligence, developers need to adapt high-level characteristics such as comfortable interaction, familiar appearance, and high-value information to translate into the distinct requirements appropriate for their application.
For the designer, meeting user expectations for easy interaction means providing sufficient performance to rapidly deliver results from more sophisticated application software running on the smart product. These functional requirements, in turn, translate into a need for processors able to execute that software while extracting more useful information from a growing number of sensor modalities.
In acquiring this information, these devices will gain access to privileged information that requires strong security mechanisms that provide protection without undermining application performance.
Beyond those immediate needs, smart devices need to meet new types of attacks with software updates that run invisibly without burdening the user. At the same time, designs need to incorporate effective power saving features able to extend battery life without burdening the user with bulky batteries or frequent recharge cycles.
The diverse requirements needed to ensure ease of use are challenging in their own right, but they are further constrained by the need to meet user expectations for the aesthetics of smart products. A bulky battery, outsized design footprint, or awkward user interface can kill user interest before they even try to interact with the product.
When building intelligence into a design, developers need to find a balance between the extremes of form versus function. In achieving this balance, developers need to further qualify their solution alternatives, focusing on options able to resolve traditional conflicts between high-performance and low power; between broad functionality and footprint; and between flexibility and security.
Another factor is cost. The rapid evolution of the IoT, and wearables and smart products, means the developer must provide the hardware to support future requirements, along with software updates. In planning for future feature enhancements, developers must balance the incremental cost of the device that might be needed to add spare horsepower and storage to their initial designs.
For developers, the best opportunity for finding a solution across these broad requirements lies with the MCU at the heart of embedded smart product designs. While 8- and 16-bit MCUs remain popular, as users raise their expectations, smart products need to provide higher performance and functionality. As a result, 32-bit MCUs have also become popular for smart product system designs. For example, compared to 8- or 16-bit MCUs, 32-bit MCUs can complete fundamental operations such as 32-bit addition in fewer instruction cycles than these earlier MCUs (Listing 1).
anl PSW, #0E7H ;Register Bank 0 mov a, r0 ;load X low byte into acc add a, r4 ;add Y low byte mov r0, a ;save result mov a, rl ;load X next byte into acc addc a, r5 ;add Y next byte with carry mov rl, a ;save result mov a, r2 ;load X next byte into acc addc a, r6 ;add Y next byte mov r2, a ;save result mov a, r3 ;load X high byte into acc addc a, r7 ;add Y high byte with carry mov r3, a mov C, OV ret (A) mov a, r0 add rl mov r0, a ret (B)
Listing 1: To perform a 32-bit addition, an 8-bit MCU needs significantly more instruction cycles (A) compared to a 32-bit MCU's number of cycles (B) for the same operation. (Code source: Maxim Integrated)
The need for high-performance 32-bit MCUs becomes even more important as designers combine multiple sensor data streams in sensor fusion algorithms. Among their other applications, sensor fusion algorithms are used to generate the precise orientation and indoor location information that users increasingly expect from their wearables and mobile products. In this environment, the capabilities of advanced MCUs such as Maxim Integrated's Darwin MCU family become essential for delivering invisible intelligence.
Delivering invisible intelligence
The Darwin MCUs are designed specifically to support requirements for emerging smart products. Combining low-power operation with a comprehensive set of integrated capabilities, the family includes the MAX32620, MAX32625, and MAX32630.
Based on the 32-bit Arm® Cortex®-M4 with floating-point unit (FPU), Darwin MCUs combine comprehensive support for low-power operation with specialized blocks for peripheral management, power supervision, and cryptography (Figure 1). Secure variants such as the MAX32631 extend support for security through an integrated trust protection unit (TPU) able to support confidentiality, integrity, and authenticity in every interaction between the smart product and external hosts.
Figure 1: Darwin MCUs such as the MAX32630 and its secure variant, the MAX32631, combine 32-bit processing performance with a comprehensive set of peripherals, interfaces, and specialized blocks, including the trust protection unit (TPU) supporting key security mechanisms in the MAX32631. (Image source: Maxim Integrated)
Developers can take advantage of the MCUs' multiple analog and digital peripherals and serial interfaces to simplify hardware design for systems using multiple sensors. Maxim Integrated demonstrates this simplified design with its MAXREFDES100 evaluation kit. The kit includes a board and reference design illustrating the use of multiple sensors, including the Maxim MAX30205 human body temperature sensor, MAX30003 ECG analog front end (AFE), MAX30101 pulse oximeter, and others that would be used in a typical fitness wearable.
While flexible interfaces are necessary to capture more complex data, the Darwin instruction set architecture enables these MCUs to rapidly execute the complex algorithms increasingly required to extract useful information from that data. The instruction set blends 16- and 32-bit instructions, reducing the footprint of application software while retaining the 32-bit architecture’s ability to perform more instructions per byte. Along with its integrated FPU, the Darwin CPU architecture includes a high-speed hardware multiply-accumulate (MAC), as well as single instruction multiple data (SIMD) parallel processing capability, providing digital signal processing capabilities.
This combination of floating-point and DSP instructions helps Darwin MCUs faster execute the data-intensive algorithms needed to build intelligence into next-generation products. At the same time, the MCUs integrate on-chip memories large enough to store algorithms and other application code, along with a growing complement of system level software including real-time kernels, communications stacks, and security protocol stacks. Among Darwin MCU family members, developers can find the mix of flash and SRAM most appropriate for their application. The MAX32630/MAX32631 MCUs provide 2 Mbytes of flash and 512 Kbytes of SRAM; the MAX32620 provides 2 Mbytes of flash and 256 Kbytes of SRAM; and the MAX32625 has 512 Kbytes of flash and 160 Kbytes of SRAM. To simplify working with these memories, Darwin MCUs support a consistent memory map that combines its various memory types and memory-mapped registers in a single address space (Figure 2).
Figure 2: Darwin MCUs use a single address space that contains their various memory types as well as memory-mapped registers for their functional blocks. (Image source: Maxim Integrated)
Developers can further extend available flash to support very large code sets or system libraries. Darwin MCUs support execute-in-place (XIP) operations, which allows the CPU to execute code directly from external flash. Maxim Integrated demonstrates this approach in its MAXREFDES100 reference design, which includes the 32 Mbyte Cypress Semiconductor S25FS256SAGNFI001 flash device.
With extensive memory and processing capabilities, Darwin MCUs still meet developers' needs for low power consumption. The MAX32630/MAX32631 MCUs, which support the largest integrated memory among those mentioned here, can retain their 512 Kbytes of SRAM with as little as 3.4 microwatts (µW). In fully active mode, they still consume only 130 µW/MHz. They can also provide a middle ground between the two, consuming 30 µW/MHz in a special mode that uses the integrated peripheral management unit (PMU) to enable peripheral operations while the CPU core remains in a very low-power sleep state.
Darwin MCUs' ability to run peripherals while the processor sleeps allows developers to reduce power by limiting the time the CPU needs to remain in active mode. Rather than using a fully active CPU to periodically poll sensors and transmit results to a host, developers can use Darwin MCU instructions for Wait for Interrupt, Wait for Event, and Sleep on Exit to minimize the active duty cycle and so reduce overall system power (Figure 3).
Figure 3: In a wearable or other sensor system, developers can dramatically reduce system power by maximizing the time the CPU spends in a low-power sleep state, waking only long enough to acquire sensor data and transmit the results to a host. (Image source: Maxim Integrated)
With their 5 µs wakeup time, these MCUs reduce the amount of power routinely wasted by slower MCUs in the transition from sleep to active mode. Coupled with their SRAM retention sleep states, these devices can quickly resume processing without lengthy delays and wasted power from saving and restoring states using external non-volatile memory. As a result, engineers can develop very efficient power aware applications.
To support development of these applications, Maxim provides the MAX326XX firmware software development (SDK), which includes peripheral drivers, board support drivers, and sample applications (Figure 4).
Figure 4: The Maxim Integrated MAX326XX firmware software development (SDK) supports application software developers with sample applications illustrating use of the SDK's peripheral and board drivers built on the Arm Cortex Microcontroller Software Interface Standard (CMSIS) API. (Image source: Maxim Integrated)
The MAX326XX firmware SDK peripheral and board libraries build on the Arm Cortex Microcontroller Software Interface Standard (CMSIS) API. In turn, application software typically interacts with the peripheral and board libraries, but can interact directly with the CMSIS to reach the underlying hardware as needed.
Users expect wearables, IoT devices, and other smart devices to offer sophisticated applications in systems that interact easily, fit comfortably, and deliver significant value. To meet these demands, developers need MCUs that combine extensive functionality, high-performance processing, and low-power operation.
Designed specifically to meet these requirements, the Maxim Integrated Darwin family of MCUs enables developers to more easily build devices with the invisible intelligence needed to meet smart product user expectations.