POWMAN P-State and Low-Power Modes on Raspberry Pi Pico 2 (RP2350) with Rust

2026-08-21T00:00:00+00:00

I was working on a hobby Embedded Rust project where the MCU needs to wake up every few hours, do some work, and then go back to sleep. The project will run on a battery, so I want to reduce power consumption as much as possible. </blockquote>

Some STM32 microcontrollers have nice low-power modes, but I have already bought quite a lot of hardware recently and didn’t want to buy another board just for this (at least for now 😉). I already had a Pico 2 (RP2350), so I wanted to utilize that instead.

The Pico 2 has some interesting low-power features that the older RP2040 does not have. The RP2350 has POWMAN, which can significantly reduce power consumption. I wanted to make use of that instead, so I started exploring and researching how it works and how I can use it with Embedded Rust.

</a> Pico (RP2040) vs Pico 2 (RP2350) - Low Power Modes</h2>

In order to achieve low power consumption, a microcontroller usually has features to put components that are not being used into a low-power state. Even the processors can be put to sleep when they have nothing to do.

The original Pico (RP2040) has two sleep modes, known as SLEEP</code> and DORMANT</code>. In SLEEP mode, the processors go to sleep while the hardware needed for wake-up remains active and can generate an interrupt to wake the processors. In DORMANT mode, even the clocks and oscillators are stopped, allowing the RP2040 to reach a much lower-power state while retaining its system state so that execution can continue after waking.

The Pico 2 (RP2350) adds a third mode called P-state, which can switch off power domains instead of just stopping the processor or clocks.

</div>
    
        INFO</strong>
        A power domain</strong> is basically a section of a chip that can be independently powered on or off.</p>
The RP2350’s core logic is divided into five power domains:</p>

AON (Always On)</strong> contains the small amount of logic that is always powered on</li>
SWCORE (Switched Core)</strong> contains the processors, peripherals, and other core logic</li>
XIP</strong> contains the XIP cache and Boot RAM used when running a program from flash</li>
SRAM0</strong> contains part of the on-chip SRAM</li>
SRAM1</strong> contains the rest of the on-chip SRAM and the scratch SRAMs</li>
</ul>
You can find more details in the Power Management section</a>.</p>

    </div>
</div>
The RP2350 has a dedicated hardware block called POWMAN</strong> (Power Manager) that controls these power domains. When you switch off a power domain, its state is lost. So if you want to keep some data, you need to keep it in a powered domain.</p>

  
  RP2350's Power Domain - From the Datasheet</figcaption>
</figure>
The Pico SDK has a nice table</a> that shows the power consumption of the RP2040 and RP2350 in different modes.  It shows how much lower the power consumption can be with P-state compared to SLEEP and DORMANT modes. This is just a simplified version of that table.</p>
Mode</th> Pico (RP2040)</th> Pico 2 (RP2350)</th></tr></thead>

SLEEP</td> 7.3 mA</td> 5.9 mA</td></tr>
DORMANT</td> 0.95 mA</td> 3.3 mA</td></tr>
P-state, SRAM0 on</td> -</td> 0.25 mA</td></tr>
P-state, XIP SRAM on</td> -</td> 0.22 mA</td></tr>
P-state, all SRAM off</td> -</td> 0.18 mA</strong></td></tr>
</tbody></table>
For my hobby project, I don’t need to retain any RAM data or continue from where I left off. A fresh run every time the Pico wakes up is enough for me. So I can turn off as much of the chip as possible while it is sleeping, as I don’t need to keep its previous state.</p>
</span></a>
Power State</h2>
The datasheet uses the notation Pc.m</code> to describe a power state. Here, c</code> indicates the state of the switched core (SWCORE</code>) domain, while m</code> is a 3-bit binary representation of the memory power domains in the order XIP, SRAM0, SRAM1</strong>.</p>
I don’t want to go into all the details here. You can refer to the datasheet if you want to understand the power states in depth. I will just give a brief explanation of how the notation works.</p>
Let’s see a few example states:</p>
Power State</th> SWCORE</th> XIP</th> SRAM0</th> SRAM1</th></tr></thead>

P0.0</code></td> 0</td> 0</td> 0</td> 0</td></tr>
P1.0</code></td> 1</td> 0</td> 0</td> 0</td></tr>
P0.2</code></td> 0</td> 0</td> 1</td> 0</td></tr>
</tbody></table>

    </div>
    
        INFO</strong>
        In this table, 0</code> means ON</code> and 1</code> means OFF</code>.</p>

    </div>
</div>
In normal operation, the RP2350 is in P0.0</code>, which means all these power domains are ON.</p>
If we only want to turn off the SWCORE</strong> domain, it is represented as P1.0</code>. If we want to turn off only SRAM0</strong>, the memory part becomes 010</code> in binary. 010</code> is 2</code> in decimal, so the power state is represented as P0.2</code>.</p>
I want to turn off SWCORE, XIP, SRAM0, and SRAM1</strong>. So, the memory part becomes 111</code> in binary, which is 7</code> in decimal, so we get P1.7</code>.</p>
</span></a>
How Do We Wake Up?</h2>
Once we power down the components, including the CPU, we need a way to wake them up. The one domain that always runs is AON (Always On)</strong>, as the name suggests. We will use the AON Timer</strong> to trigger an alarm after a specified amount of time. We can use this alarm to wake the Pico from its low-power state.</p>
</span></a>
Coding</h2>
Enough with the theory, let’s get into the coding part. I will use the template</a> I created for the “impl Rust for RP2350</a>” book and work on top of it. I won’t cover the basic boilerplate code here.</p>
The overall flow:</p>

Use the Embassy AON Timer to set the wake-up alarm.</li>
Use the RP2350 PAC to configure POWMAN.</li>
Request the P-state we want.</li>
Let the AON Timer wake the Pico after the configured time.</li>
</ul>
</span></a>
Good Old Blinky</h2>
I needed a simple indication that the program is working. So, I will blink the onboard LED whenever the MCU boots.</p>
let mut</span> led</span> =</span> Output</span>::</span>new</span>(</span>p</span>.</span>PIN_25</span>,</span> Level</span>::</span>High</span>);</span></span>
Timer</span>::</span>after_secs</span>(</span>1</span>)</span>.</span>await</span>;</span></span>
led</span>.</span>set_low</span>();</span></span></code></pre>
The LED turns on when the program starts and stays on for one second before turning off. Since the Pico boots again after waking from P-state, the LED will turn on again when the chip wakes.</p>
</span></a>
Setting Up the AON Timer</h2>
First, we need to bind the interrupt used by the AON Timer:</p>
bind_interrupts!</span>(</span>struct</span> Irqs</span> {</span></span>
    POWMAN_IRQ_TIMER</span> =></span> embassy_rp</span>::</span>aon_timer</span>::</span>InterruptHandler</span>;</span></span>
});</span></span></code></pre>
Next, we configure the AON Timer to use the low-power oscillator at 32 kHz:</p>
let</span> config</span> =</span> aon_timer</span>::</span>Config</span> {</span></span>
    clock_source</span>:</span> ClockSource</span>::</span>Lposc</span>,</span></span>
    clock_freq_khz</span>:</span> 32</span>,</span></span>
    alarm_wake_mode</span>:</span> AlarmWakeMode</span>::</span>DormantOnly</span>,</span></span>
};</span></span>
</span>
let mut</span> aon</span> =</span> AonTimer</span>::</span>new</span>(</span>p</span>.</span>POWMAN</span>,</span> Irqs</span>,</span> config</span>);</span></span></code></pre>
And then start the timer:</p>
aon</span>.</span>start</span>();</span></span></code></pre>
Finally, we set an alarm for 10 seconds:</p>
aon</span>.</span>set_alarm_after</span>(</span>Duration</span>::</span>from_secs</span>(</span>10</span>))</span>.</span>unwrap</span>();</span></span></code></pre>
The timer will continue running while the rest of the chip is in the low-power state. When the alarm is triggered, it will wake the Pico.</p>
</span></a>
Entering a Power State</h2>
Now, let’s create a function called enter_pstate()</code> that accepts the P-state as a u8. The P-state only uses 4 bits and ignores the rest. The function will be a diverging function because it never returns, so we mark its return type as !</code>.</p>
I was looking for examples in Rust or C for achieving the P-state. I didn’t come across one for Rust. The Pico SDK has an example for low_power_pstate_timer.c</a>, so I followed the function used by the example and tried to follow what the Pico SDK does as much as possible.</p>
The Pico SDK does some preparation before entering the P-state. One of them is disabling interrupts. I believe this is to prevent another interrupt from waking the processor while POWMAN is waiting to complete the transition.</p>
cortex_m</span>::</span>interrupt</span>::</span>disable</span>();</span></span></code></pre>
Currently, the HAL does not provide a high-level API for P-state. So, we will use the PAC. To apply the P-state, we need to modify the POWMAN registers.</p>
Let’s first get access to POWMAN:</p>
let</span> powman</span> =</span> pac</span>::</span>POWMAN</span>;</span></span></code></pre>
POWMAN registers are password protected and require a constant password (0x5AFE</code>) to be written to the top 16 bits to enable the write operation. This helps prevent accidental writes to these registers.</p>
const</span> POWMAN_PASSWORD</span>:</span> u32</span> =</span> 0x5AFE</span> <<</span> 16</span>;</span></span></code></pre>
Next, we tell POWMAN to ignore power requests from the debugger. We don’t want a connected debugger to prevent the chip from entering the requested power state.</p>
pac</span>::</span>POWMAN</span>.</span>dbg_pwrcfg</span>()</span>.</span>modify</span>(</span>|</span>w</span>|</span> {</span></span>
    w</span>.</span>set_ignore</span>(</span>true</span>);</span></span>
    w</span>.</span>0</span> |=</span> POWMAN_PASSWORD</span>;</span></span>
});</span></span></code></pre>
If you have never used register manipulation through a PAC before, this might look strange. Basically, we are modifying the DBG_PWRCFG</code> register, which we access through the dbg_pwrcfg()</code> function. The modify()</code> function accepts a closure that can change the register value. Inside the closure, we modify the bits we are interested in. The register is written only after the closure completes.</p>
Inside the closure, we call the set_ignore()</code> function with true</code>, which sets the IGNORE</code> bit. Then, as we mentioned earlier, we need to include the POWMAN password in the top 16 bits to authorize the write.</p>
Let’s unlock the voltage regulator so it can switch to the low-power state.</p>
powman</span>.</span>vreg_ctrl</span>()</span>.</span>modify</span>(</span>|</span>w</span>|</span> {</span></span>
    w</span>.</span>set_unlock</span>(</span>true</span>);</span></span>
    w</span>.</span>0</span> |=</span> POWMAN_PASSWORD</span>;</span></span>
});</span></span></code></pre>
We also need to configure how SRAM0 and SRAM1 should be powered when the chip wakes up. Since both SRAM domains are OFF in P1.7</code> and we want both of them ON after waking, we need to clear the corresponding bits in SEQ_CFG</code>.</p>
powman</span>.</span>seq_cfg</span>()</span>.</span>modify</span>(</span>|</span>w</span>|</span> {</span></span>
    w</span>.</span>set_hw_pwrup_sram0</span>(</span>false</span>);</span></span>
    w</span>.</span>set_hw_pwrup_sram1</span>(</span>false</span>);</span></span>
    w</span>.</span>0</span> |=</span> POWMAN_PASSWORD</span>;</span></span>
});</span></span></code></pre>
We clear the REQ_IGNORED flag so we start with a clean status before making our power-state request.</p>
powman</span>.</span>state</span>()</span>.</span>modify</span>(</span>|</span>w</span>|</span> {</span></span>
    w</span>.</span>set_req_ignored</span>(</span>false</span>);</span></span>
    w</span>.</span>0</span> |=</span> POWMAN_PASSWORD</span>;</span></span>
});</span></span></code></pre>
Now, we request the P-state we want by setting the REQ</code> field of the STATE</code> register.</p>
powman</span>.</span>state</span>()</span>.</span>modify</span>(</span>|</span>w</span>|</span> {</span></span>
    w</span>.</span>set_req</span>(</span>pstate</span>);</span></span>
    w</span>.</span>0</span> |=</span> POWMAN_PASSWORD</span>;</span></span>
});</span></span></code></pre>
After requesting the P-state, we will check whether POWMAN accepted the request:</p>
let</span> state</span> =</span> powman</span>.</span>state</span>()</span>.</span>read</span>();</span></span>
</span>
if</span> state</span>.</span>req_ignored</span>() {</span></span>
    error!</span>("</span>POWMAN request ignored</span>");</span></span>
</span>
    loop</span> {</span></span>
        cortex_m</span>::</span>asm</span>::</span>wfi</span>();</span></span>
    }</span></span>
}</span></span>
</span>
if</span> state</span>.</span>bad_sw_req</span>() {</span></span>
    error!</span>("</span>POWMAN request rejected</span>");</span></span>
</span>
    loop</span> {</span></span>
        cortex_m</span>::</span>asm</span>::</span>wfi</span>();</span></span>
    }</span></span>
}</span></span></code></pre>
Let’s wait until POWMAN enters the WAITING</code> state before continuing:</p>
while !</span>powman</span>.</span>state</span>()</span>.</span>read</span>()</span>.</span>waiting</span>() {</span></span>
    core</span>::</span>hint</span>::</span>spin_loop</span>();</span></span>
}</span></span></code></pre>
Finally, we stop the processor and wait for the wake-up event:</p>
loop</span> {</span></span>
    cortex_m</span>::</span>asm</span>::</span>wfi</span>();</span></span>
}</span></span></code></pre>
When we call this function, we will pass the value 0b1_111</code>. This represents the P1.7</code> power state:</p>
const</span> P1_7</span>:</span> u8</span> =</span> 0b1_111</span>;</span></span>
enter_pstate</span>(</span>P1_7</span>);</span> </span></span></code></pre>
Here, the first bit of the P-state value represents SWCORE</code>, while the remaining three bits represent XIP</code>, SRAM0</code>, and SRAM1</code>.</p>
</span></a>
Final Thoughts</h2>
Hurrah! We have written a complicated blinky program :P</p>
I have tested it by blinking the LED, and it is working. But, I am not sure whether it will introduce any side effects or how it will behave when I integrate it into a real project. If I run into any issues, I will update this.</p>
You can find the complete source code for this experiment on GitHub</a>.</p>
</span></a>
Reference</h2>

[RP2350 Powman States</a>]</li>
Pico C Examples</a></li>
</ul>

impl Blog for Rust - pico-2

POWMAN P-State and Low-Power Modes on Raspberry Pi Pico 2 (RP2350) with Rust

</span></a> Reference</h2> [RP2350 Powman States</a>]</li> Pico C Examples</a></li> </ul>

[RP2350 Powman States</a>]</li>
Pico C Examples</a></li> </ul>