In today’s article, we will explore several low-power design techniques that are often overlooked but can make a significant difference…
Designing embedded systems to extend battery life has become an important consideration for many teams. Optimizing battery life helps to reduce field maintenance costs and ensures that customers can enjoy a good product experience without the need for constant battery replacements or recharging.
Development teams often use some standard techniques to help extend battery life. For example, setting the processor to low-power mode, turning off unused peripherals, etc. However, I find that development teams often overlook some other standard techniques.
In today’s article, we will explore several low-power design techniques that are often overlooked but can make a significant difference.
Tip #1 – Ditch GCC, Use Commercial Compilers
As software developers and teams, we often take pride in using free and open-source tools. But in most cases, you get what you pay for. While GCC is a great tool, it is not suitable for all situations. One such situation is low-power, battery-operated devices.
I recently conducted some performance tests comparing the code execution between GCC and IAR’s EWARM compiler. Compiling the same code on the same processor with the same settings, the performance of the test code improved by 20-30%. While results may vary due to different operations, these numbers are astounding.
What does this mean? It means that using a commercial compiler can significantly speed up the execution of the same code, allowing you to return to sleep mode faster. The longer the time spent in sleep mode, the less current is consumed, resulting in longer battery life!
Using a commercial compiler is an easy win and can yield results; you can leverage it not only for better code performance but also for saving battery life.
Note: Results may vary depending on the extent to which you optimize your code. However, since there are tools available to help you optimize your code, why waste time?
Tip #2 – Use Tickless Mode to Extend Sleep Time
One issue with using low-power modes is that if you are using an RTOS (Real-Time Operating System), the kernel’s tick will periodically wake the system. It is not uncommon to have the tick set to one millisecond. What happens if you want the device to sleep for a minute before waking? During that minute, you will have woken up 6000 times more than you would like, wasting precious battery life.
A direct solution in many RTOS is to use tickless mode. The principle of this mode is that when the system enters sleep mode, it adjusts the low-power timer so that the RTOS tick does not occur every millisecond. Instead, it may not occur for minutes, hours, or even a day!
It is easy to imagine that this allows the system to remain in sleep mode, preventing unnecessary CPU cycles from waking up and running. Less current is used, equating to longer battery life.
Note: The method of enabling tickless mode and the work that may be required by developers varies among different RTOS.
Tip #3 – Utilize Internal Caches
For many years, microcontrollers lacked caches. They are resource-constrained devices and relatively simple compared to their more feature-rich counterparts. But that is no longer the case today. If you look at microcontrollers from ST, NXP, and many others, you will find that high-performance components come with internal caches. If you are working on low-power designs, you can leverage caches to reduce power consumption.
Caches have various mechanisms to help you reduce current consumption. Most of these relate to the primary function of caches: faster access to frequently used data or instructions, thereby reducing the time spent accessing slower main memory by the CPU.
For example, you can optimize memory access patterns using caches. In applications with predictable memory access patterns, caches can significantly optimize energy usage. By effectively prefetching and caching the required data and instructions, microcontrollers can minimize high-energy accesses to main memory.
Compared to other onboard memory, caches provide lower latency and higher access speed. Therefore, the time spent accessing memory is reduced, leading to fewer idle cycles for the CPU. Faster access also means that the CPU can complete tasks more quickly, reducing overall CPU activity time. All of these contribute to lowering the overall power consumption of the processor, thereby extending battery life.
Conclusion
When developers and teams study low-power design, they often resort to sleep modes, clock gating, and other techniques to reduce power consumption. While these are all great techniques, they sometimes overlook some simple tricks that are readily available. In this article, we covered several ways you can use to help extend your device’s battery life or reduce its power consumption.
Ultimately, low-power design requires consideration of many factors. You can certainly optimize energy indefinitely, but during the optimization process, a ‘knee point’ often occurs, leading to diminishing returns in battery life. Always keep track of how your tricks are extending battery life; when you hit a bottleneck, it’s time to stop optimizing!
end
Recommended Reading
👉7 Ways to Improve Power Design Efficiency
👉The Nature of EMC Noise
👉Why LDO Linear Regulators Are Used in Parallel with Diodes
