Skip to content

Power Saving on Raspberry Pi OS: Measure, Change, Restore

Start with a power measurement, not a list of settings to disable. For an always-on Raspberry Pi, investigate unnecessary work and peripherals first; for a device that is often shut down, investigate standby consumption and how it will wake again. A lower CPU clock is not automatically lower energy per completed job.

This guide separates those cases for Raspberry Pi OS Bookworm/Trixie, with model-specific notes for Pi 4 and Pi 5. The outcome is one measured, reversible change—not a promised wattage reduction.

Choose the Raspberry Pi power-saving problem

  • Always-on server: keep SSH, networking, storage and required services working. Compare idle watts and energy for a representative task.
  • Desktop or kiosk: compare display-on and display-off states. Measure the monitor separately if it has its own supply.
  • Occasional-use device: measure shutdown/standby power and plan a supported wake method. A stopped OS cannot run a cron job.
  • Battery-powered installation: include startup, processing, communications and standby in the energy budget. The board, peripherals and power-conversion losses all matter.

Before changing anything, identify the boot disk and remote-access path. Have local recovery access before testing display, radio, firmware or shutdown behavior. Do not experiment on the DNS/VPN/storage service you currently depend on without a downtime plan.

1. Measure a baseline

Use an external meter appropriate to the supply and expected load. A USB-C meter must support the required power negotiation and current without creating voltage drop. For the electricity bill, an AC-side meter includes adapter losses; a USB-side meter measures a different boundary. Do not compare the two as though they were interchangeable.

Software temperature, CPU usage and clock readings help explain activity; they are not whole-system wattmeters. Pi 5 PMIC telemetry also omits loads that bypass the PMIC, as the official power documentation explains.

Record the model, OS/kernel, supply, cable, meter, peripherals, fan, network state and measurement boundary. Then:

  1. Let startup tasks finish and measure the normal idle setup over a fixed interval, such as five minutes.
  2. Run the same representative application task and record its duration and energy.
  3. Change one thing, let the system settle, and repeat.
  4. Restore the baseline and repeat once more to check whether temperature or background work explains the difference.

Use this worksheet for baseline → change → restored baseline:

Variant:
Hardware, supply and meter:
OS/kernel:
What changed:
Idle interval and average W:
Workload and completion time:
Task energy, Wh:
Temperature and throttling:
SSH / storage / application checks:
How the original state was restored:

For approximately constant power, Wh = W × seconds / 3600. For changing loads, use the meter's integrated energy or integrate samples. At 4 W for 60 seconds a task uses about 0.067 Wh; at 3 W for 120 seconds it uses 0.100 Wh. These are arithmetic examples, not Pi measurements.

Use the electricity cost calculator for measured idle/load scenarios. Include standby separately if the device is not powered on all day.

2. Inspect activity before changing settings

Run these read-only commands on the Pi host, not only inside a container:

1
2
3
4
5
6
tr -d '\000' < /proc/device-tree/model
printf '\n'
cat /etc/os-release
uname -r
# The first line of top is a summary; %CPU varies with sampling and CPU count.
top -b -d 2 -n 2

Look at the second top sample, after the sampling interval. An update, browser tab, video decoder, animation or busy-looping application can keep a nominally idle Pi active. Identify the process before stopping anything; do not kill a process merely because it appears near the top.

Read the available CPU policies:

policy_found=0
for policy in /sys/devices/system/cpu/cpufreq/policy*; do
    [ -d "$policy" ] || continue
    policy_found=1
    printf '\nPolicy: %s\n' "$policy"
    for field in scaling_driver scaling_governor scaling_available_governors \
                 scaling_min_freq scaling_max_freq scaling_cur_freq; do
        [ -r "$policy/$field" ] || continue
        printf '%s: ' "$field"
        cat "$policy/$field"
    done
done
if [ "$policy_found" -eq 0 ]; then
    printf 'No CPUFreq policy is exposed here.\n'
fi

Linux CPUFreq values here are in kHz: 600000 means 600 MHz. The listed governors depend on the kernel/driver. A missing directory does not mean the CPU runs at zero frequency.

If vcgencmd is available, check temperature and power/thermal fault flags:

vcgencmd measure_temp
vcgencmd get_throttled

Resolve undervoltage and thermal problems before comparing results. Historical throttling flags do not prove that the current workload is throttling.

3. Try one reversible change while running

Reduce unnecessary application work

For an application you own, try a slower polling/refresh rate, pause an unused preview, or close an idle animation. Record the original setting, change only that application, and restore it after the comparison.

Check that the application still meets its latency and data-loss requirements. Batching work may reduce wakeups but can delay events. Do not disable monitoring, backups, time synchronization or security updates simply to produce a lower idle number.

Turn off a display without changing boot configuration

On a Wayland desktop, use the desktop's screen-blanking controls or a temporary output change. In a terminal inside the logged-in graphical session, first list outputs:

wlr-randr

Only continue if the utility successfully lists outputs and you have another way to restore the display. Substitute the reported connector for HDMI-A-1; do not assume its name. The following switches that output off:

wlr-randr --output HDMI-A-1 --off

Restore it from the same session or your prepared recovery connection:

wlr-randr --output HDMI-A-1 --on

An SSH shell may not have access to the desktop's Wayland socket. A connection error is not a reason to use sudo or copy arbitrary display environment variables. Follow the official screen-blanking and Wayland instructions for your desktop; this recipe does not apply to a text-only installation.

Confirm both output recovery and the application's behavior, then compare measured energy. Screen blanking is not system suspend, and switching the Pi's output off does not necessarily remove the monitor's standby consumption. Do not use legacy tvservice recipes for the current KMS/Wayland desktop.

Test a CPU policy only when the workload justifies it

The Linux CPUFreq documentation distinguishes a governor's frequency requests from actual hardware behavior. Generic powersave requests the lowest allowed frequency; it does not guarantee the least whole-board energy. A slower job may keep RAM, storage and networking active for longer.

Use the reversible governor experiment: record the original governor, choose only a listed alternative, run the same workload, then restore the original in that shell. Keep the default if the measured benefit is absent or service latency becomes unacceptable. Do not add an rc.local override or a fixed 600 MHz cap as a first step.

Remove peripherals only after checking dependencies

An unnecessary USB device or HAT is worth measuring, but first identify whether it supplies storage, networking, input or power. For a comparison, shut down cleanly and remove only the reviewed accessory; reconnect it to restore the baseline. Follow the board/accessory power instructions and never hot-unplug a mounted disk.

Do not unbind a whole USB controller as a general power-saving command: that can disconnect the boot disk, SSH network adapter, keyboard or other required devices. Do not disable Wi-Fi while it is your only access path.

4. Separate shutdown power from running power

Shutdown settings do not reduce consumption while your server is running. On EEPROM-equipped models, inspect the current configuration without editing it:

# Read-only; if unavailable or permission is denied, stop and check your OS tools.
rpi-eeprom-config

Do not assume that an omitted setting means zero, or that every model has this command. Review the model's documented defaults as well as explicit values.

  • Pi 5: POWER_OFF_ON_HALT=1 selects a lower-power standby state after shutdown; the power button can start it again.
  • Pi 4B: shutdown power controls and wake behavior differ from Pi 5. Review POWER_OFF_ON_HALT together with WAKE_ON_GPIO; do not copy a Pi 5 profile.
  • Zero/older boards: do not apply EEPROM configuration instructions intended for Pi 4/5.
  • Compute Modules and keyboard models: defaults and carrier-board dependencies can differ. Check the exact model, not just its generation.

These are model-specific firmware controls, not a universal “low power mode”; see the official bootloader configuration reference. A shutdown state is not a guarantee that all external 5 V accessories are unpowered.

Optional shutdown-behavior change

Only do this with local access, a recorded original configuration, a verified restart method and permission to interrupt services. On current Raspberry Pi OS, the official configuration guide describes the Advanced Options → Shutdown Behaviour menu in sudo raspi-config. If the option is absent, do not blindly install new firmware or replace the whole EEPROM configuration to obtain it.

Record the original menu selection and relevant EEPROM values, select the model-appropriate behavior, and follow the requested reboot procedure. Then, during planned downtime, shut down, measure at the same meter boundary and verify that your intended wake method works. SSH cannot wake a fully stopped OS.

To revert, start the Pi using the supported local method, restore the recorded selection/settings, apply the required reboot, and retest. If you cannot guarantee that recovery, leave the firmware unchanged. No fixed wattage saving is promised for your board, firmware, peripherals or meter.

5. Plan wake-up before scheduling shutdown

A cron entry scheduled for morning cannot restart a Pi whose OS is stopped. Installing pm-utils does not give every Raspberry Pi laptop-style suspend/resume.

Pi 5 has a hardware RTC wake-alarm route described in the official RTC documentation; it depends on the supported hardware/firmware setup. This is not a tested wake recipe for Pi 4. External power controllers are another design option, but must allow clean filesystem shutdown and a verified startup sequence. Do not cut the power to a running Pi with an ordinary timer.

For an intermittent device, compare the energy of booting and reconnecting each cycle with leaving it idle. Include standby and peripheral consumption rather than measuring only the brief CPU task.

Settings not to copy from older guides

  • gpu_mem=16 as a universal power fix: memory allocation is not a wattage measurement. Pi 5 ignores these legacy GPU-memory settings; Pi 4's 3D memory is managed differently. See the official GPU-memory notes.
  • Fixed voltage/clock recipes: do not apply over_voltage=-2 or a copied arm_freq value across boards. Instability or failed work is not an energy saving.
  • Disabling fans, radios or USB indiscriminately: preserve cooling, connectivity and storage. Re-measure after each reviewed change.
  • powertop --auto-tune as a first step: do not apply a collection of tuning changes before understanding device dependencies. Software activity estimates are not a replacement for an external energy measurement.

What was checked

On 30 October 2026, the read-only inspection was checked on a Raspberry Pi 4 Model B Rev 1.5, Debian GNU/Linux 13 (Trixie), kernel 6.18.50+rpt-rpi-v8. Its cpufreq-dt policy reported ondemand, limits of 600000–1800000 kHz, and the governors conservative ondemand userspace powersave performance schedutil.

Those are observations of one installation, not universal defaults. No governor, display, radio, firmware or power-state change was made for this revision. No external-meter power saving, Pi 5 standby or RTC wake cycle was measured.

Next steps

Use the power and cost calculator with your own readings. For a controlled comparison, follow the benchmark methodology; if the Pi is unexpectedly busy, start with performance diagnosis rather than forcing a slower clock.

Donate