Managing Power in Small Systems

Low-Power in Small Systems Made Simple

The key to managing power in small systems is to address power consumption in every part of the design process—not just the processor and memory system, but also electrical design, operating system, peripheral selection and application layer functionality.


  • Page 1 of 1
    Bookmark and Share

Article Media

Developing a power management plan is a critical step in embedded systems design. Consumers and manufacturers alike value long battery life, and engineers must focus on the same end goal to meet market expectations—high performance with low-power requirements. To design a truly low-power embedded system, a power management strategy is essential during every step of the design process, not as an afterthought.  

Power saving techniques, while good for battery life, also improve system reliability. A low-power system does not need a fan, which allows for a sealed enclosure and a more rugged product. Power management also eliminates the need for heat sinks, which increase cost and occupy valuable real estate. The end result is a lighter, more reliable product that is also better for the environment with increased battery life and lower touch temperatures.

There are many different approaches to power control, and each comes with distinct considerations and tradeoffs. When minimal power consumption is the top priority, the system will require low-power hardware and peripherals, and the operating system and applications must also be customized to take advantage of low-power usage states (Figure 1).

Figure 1
A low-power, high-performance board showing a small current draw.

Enabling the Operating System

Central processing units (CPUs) all support various power states between full on and full off.  Experienced embedded systems designers know how to customize the operating system to take advantage of the CPU’s unique power saving characteristics. 

When the end user selects a power state on a finished device, the operating system does the dirty work to make the power switch happen smoothly. Customizing the operating system to work with the hardware and save power without adversely affecting operation is one of the most important and complicated steps of embedded systems design.

Designers start with an out-of-the-box operating system, such as Windows CE or Linux, and implement additional capabilities to enable functionality specific to the board design. Optimizing the operating system (OS) is a large part of the system design process, and arguably the most time-consuming. 

Some board vendors deliver a board support package that requires the customer to create the operating system themselves. Since optimizing the operating system is one of the most labor- and time-intensive activities of embedded system design, it is the board vendor’s responsibility to offer customers a simple solution by providing hardware with the OS installed and ready to run.

Once the OS has been optimized, machines test the system over thousands of transitions between full on and full off, and every power state in between, to make sure there are no failures. Laptop computers offer an excellent example of what happens when the operating system does not communicate properly with the hardware. A common operating system bug reveals itself when you “wake up” a laptop and it can no longer access a peripheral. The hardware certainly has the capability to enter and exit low-power mode, but the operating system failed to communicate correctly to the peripheral during power-up.

OEMs and end users demand higher reliability and error-free operation from embedded systems—so extensive testing and validation ensures the system will function properly when the user puts it into a low-power state, and when they power it back up. 

In addition to maximizing the hardware’s low-power states, the OS determines when there is an application running and tells the peripherals to wake up and start performing, or to remain in one of many sleep modes. Just about every part of the system has interfaces and on/off switches, and the operating system must be customized to determine when power needs to be increased or decreased to each component. When the operating system detects that an application is using resources, it will increase the power supply and move the hardware and peripherals into an appropriate power mode.  

Peripherals and Applications Designed for Low Power

After choosing and optimizing the hardware and operating system, you can select peripherals that will reduce power consumption. Good designers consider every last detail to save power.  Some peripherals have communication protocols to allow you to put them into a low-power mode, or you can design the system with that function. Either way, select peripherals that support low-power modes and power off.  

Your operating system will dictate some of these peripheral choices since they are not all compatible with all operating systems. If the power saving functionality is not fully accessible, control command sequences can be extensive and complex.

Ethernet is one example of a peripheral with sophisticated power management—it never goes to sleep, but if you choose the right components there are many ways to reduce power with a command control protocol. For instance, Ethernet can be programmed to remain in low-power state until an incoming message is detected, allowing it to wake and pass the data to the OS. For example, devices like the Intel 82574 Ethernet Controller can be configured to wake the board from a low-power sleep state.

Another example of how peripheral choices can save power is the display. If a device is going to be used outside in daylight, a display with some reflective properties will reduce the need for backlight, which can be a significant power savings. Identifying use cases to support powering off the display during non-critical periods is also very useful, making it important to select an LCD with the ability to support this level of control. 

After choosing peripherals that offer low-power states, the designer must spend a fair amount of time and complexity in the development cycle to make use of those states. Some embedded computer providers choose low-power peripherals, but don’t take advantage of the low-power capabilities in their development process. In the end, they are not able to reach the lowest power levels for the computer system as a whole, even though the individual specifications for each component promise power efficiency. 

At the detailed design level, you have to consider undesired circuit paths and insert the hooks necessary to use the available power-down features. These hooks will likely require additional I/O and partitioning power supplies to make sure the circuits that are powered down are really off.

Most hardware power saving features must be controlled by driver software to make the features available to the application environment. This arrangement also allows for complete validation at the platform level prior to application integration, which is an important consideration that speeds integration and reduces field trouble reports.

The application layer is another important factor in the power management equation, since the application is aware of which peripherals are connected and how to best handle them. Some integrated circuits can enter low-power mode based on their operating conditions on their own, but in most cases you will have to access the application layer to command the power reduction modes.

A running application instructs the operating system to turn different functions on or off. For instance, a computer may turn off the display when the user is in motion, or power down the cellular modem when the 801.11 interface has connectivity.

Since the application layer is typically handled by Eurotech’s customers after we provide the embedded system, we work closely with OEM developers to optimize the power management of their specific application.

The most successful low-power embedded systems have an extremely low sleep current. The board is in a state where the CPU is stopped, but the board is powered just enough to wake back up and continue where it left off within a second.  

The minimum achievable current is calculated in order to verify the design is optimized. Verification of the board design includes measuring the sleep current, tracking down any discrepancies, and verifying wakeup during operational modes without loss of function.  

For example, as shown in Table 1, power consumption was measured on a fully populated Eurotech 64 MiB rev 3 BitsyXb system with no peripheral connections and the following additional conditions:

  • System in Run mode at 104 MHz.  Running Linux, the system is predominantly in Idle mode (<5% CPU utilization).  
  • System in Run mode at 520 MHz, running Linux.  Full (95 to 100%) processor utilization achieved by running multiple instances of a graphics-intensive application.


During application development, the user may need to track down exactly where power is being dissipated, to enable the system tradeoffs that will allow the low-power design requirements to be met. Developers can check which features are available on a development system to assist with creation of applications that take advantage of low-power operating modes. Processor, RAM and other power consumption information are valuable to understand what is happening during low-power modes.  

Columbia, MD.
(800) 541-2003.