Low Power ARM7 Design

The biggest influence in reducing an MCU�s power consumption is to limit how fast it is running. The relationship between frequency and power is linear - double the frequency and you double the current consumption. As a result, many of today's power-constrained applications rely on low-frequency MCUs, but these slower MCUs can, in turn, limit the features in the application. To address this problem some chip manufacturers have developed innovative ways to control the clock going to the MCU�s core. For example, the core clock can operate at 1MHz for some instructions and then, one instruction later; it can slow to 32 kHz.

The most common implementation of power management for an MCU is to switch between the maximum speed needed for the application and a very low power mode, either by slowing the clock or building in some kind of stop mode, when possible. This simple method is usually dictated by the MCU�s architecture (Figure 1).

In the past, most MCUs had an oscillator circuit that divided the clock down by a factor of 2 to get a clean square wave. As process technology evolved, PLLs became feasible and you could select other multipliers for the clock using an "option" byte. Later, on-board RC oscillators combined with a PLL to reduce system cost. The most significant feature developed to manage low power was the option for a second clock source, either internal or an external 32 kHz oscillator. This option allowed designers to put the MCU into sleep mode, where most of the MCU stopped, but the 32-kHz oscillator kept a timer running that could wake up the MCU on a periodic or interrupt-driven basis. As process technology continued to evolve, selecting between a main clock and a low-power 32-kHz clock became possible. This is now a standard feature on nearly all MCUs.

Even with these improvements, the only way for most MCUs to optimize power consumption was to minimize the maximum clock frequency used in the application, and/or switch back and forth between the main clock and the low frequency clock (see graph below).

> - - - - - - - - - - - - - - - - - Time - - - - - - - - - - - - - - - - ->
(Figure 1)

The ARM7 core has become a popular core for MCUs, The reason this core has become so popular is because of its performance, and mostly the availability of suppliers and tools supporting it. With the ARM7 core running at clock speeds of 50MHz or more, the core alone accounts for tens of milliamps of current consumption. On the other hand, because of its speed the time to perform tasks by the core is much shorter, making an on/off architecture attractive; You can minimize power consumption by running as fast as possible and finishing the task as quickly as possible and then shutting down (Figure 1).

We talked earlier that current consumption vs. clock speed is linear. But there are other considerations in an MCU that can affect power consumption other than the core and memory. By implementing additional clock/system controls, you can reduce the overall power consumption of the MCU even more.

In recent years engineers have made significant improvements of the architecture of MCUs resulting in lower power consumption. The most recent improvement uses dynamic control of clock and frequency. Some MCUs let you play with the clock frequency, to select multiple clock sources and to provide fast startup of the internal clock (using an FLL instead of a PLL). These, plus the common capabilities of most MCUs to turn on and off the peripherals, allows for a more optimized execution of a power saving scheme. This kind of control maximizes the power-saving capabilities of the ARM7 core. You can put the core in the maximum-performance clock mode and then scale it back when it is doing something less time critical. Since the ARM7 core is very efficient, performance may still be adequate even though you are running at a lower clock frequency.

Let us look at the aforementioned power management schemes in more detail and also look at some additional power-saving features available in some ARM7 MCUs.

As mentioned above, having multiple clock sources helps in managing the current consumption of the MCU. Using multiple clock sources in addition to multiple clock frequencies has the following benefits:

• Oscillator circuits can be optimized for low power
• Ultra low power consumption in stand-by mode is possible

To minimize current consumption when the part goes into standby mode, you can use the external 32 kHz crystal/resonator to wake up the MCU using a Real-Time Counter (RTC) with wake-up feature. If the 32 kHz oscillator circuit is dedicated to support only low frequencies it can then be optimized for very low power.

If you want to optimize your code execution vs. power consumption, having the capability of dynamic and flexible clock switching on the fly is very important. For example, in Figure 2 we can see how mixing clock sources, a PLL, a divider and clock enable/disable gives a very flexible architecture for power management. You can now select the optimal frequency and source for each clock to better match your application needs. For example, you can decide if adding an external 32 kHz crystal/resonator is acceptable or not from a cost point of view, or whether using an internal 300kHz oscillator might give you good enough low power consumption to meet your design requirements. Also, you can adjust the clock driving the ARM7 core and peripherals by using the AHB prescaler and/or APB prescaler, respectively.

�

(Figure 2)

�

�

(Figure 3)

Another feature to further optimize power consumption is to have two or more peripheral buses so that you can optimize the clock on each bus based on what kind of tasks the peripherals on each bus are performing. For example, in Figure 3 (see left), we can see that all the communication peripherals are on one bus, while timers and peripherals that can operate at a slower clock speed are on the other.

This arrangement allows you to stop the clock on the timer side if you want to sit and wait for a serial communication to wake-up the MCU. Additionally, by independently starting and stopping the clock on each bus, you can disable multiple peripherals using a single instruction.

�

�

You can also manage your current consumption in low power modes by using another advanced feature. By having a dedicated on-chip low-power regulator, current consumption is minimized during standby mode while you keep the Real-time clock (RTC) and the 32 kHz oscillator running, with everything else shut off (Figure 4). This dedicated regulator is designed to only support a minimal amount of circuitry, and therefore only has a low power output with corresponding low power consumption.

�

(Figure 4)

�

�

As mentioned previously, enabling and disabling peripherals as needed also helps lower power consumption. For example, if ADC conversion speed is not critical, you could disable the ADC whenever it is not in use. Disabling all the peripherals that are not being used in the application or during certain times is key to minimizing power consumption.

By combining the high performance of the ARM7 core with all of the elements mentioned in this article - multiple clock sources, clock control, multiple regulators, multiple buses and flexible peripheral control - you can achieve a much better overall power-consumption profile, like the one shown in the figure below.

�

> - - - - - - - - - - - - - - - - - Time - - - - - - - - - - - - - - - - ->
(Figure 5)

�

For battery-powered applications, having these advanced features available allows a designer to optimize his/her design to maximize battery life. In Figure 6 we can see how to do this in an actual ARM7 MCU implementation by using the lowest possible power mode whenever possible within the performance requirements of the application.

�

(Figure 6)

Figure 6 does not show all of the additional intermediate power-saving modes for RUN or WAIT that would result from manipulation of the clock or when peripherals are powered on/off. Having a broad set of power-saving features creates a lot of flexibility to manage current consumption in your application.

The many benefits of the ARM7 core include its high performance and relatively low power consumption. Still, performance always comes at a price�which usually includes greater current consumption. You may not have to pay this price if your application does not have to do everything fast or at the same time. Being able to optimize your design for low power and having a flexible architecture in the MCU is going to help you to achieve high performance and lower power consumption.

In battery-powered applications, battery life is a key factor of the design, but other factors include how fast a task is performed and how quickly the MCU wakes up, etc. We all know that the features in today�s end user products are only going to demand increases in system performance as users get accustomed to getting what they want. An ARM7 MCU can address both performance and power savings better when it has the capabilities mentioned in this article as part of its architecture. Otherwise, you may have to limit the product features that you build into your product. For example, if speed is needed, the system may need 65mA of current consumption in RUN mode, and therefore limit battery life. On the other hand, if battery life is the most critical factor you can still have the part run at maximum speed, but only when the application requires it. You can extend the battery life further if you adjust the speed of the various clocks in the MCU and turn off peripherals during appropriate time points in the application.

Having the flexibility to play with multiple factors that affect current consumption will allow you to work out compromises that maximize the features required for your product.